From ac43c4e5ce5fdbb3b3ae9c4e71587a10355241e3 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 8 Feb 2016 20:13:57 +0300 Subject: [PATCH 0001/1139] Add mmts --- Makefile | 33 + README.md | 117 ++ bgwpool.c | 134 +++ bgwpool.h | 35 + bytebuf.c | 36 + bytebuf.h | 17 + decoder_raw.c | 552 +++++++++ logical.conf | 2 + multimaster--1.0.sql | 15 + multimaster.c | 1035 +++++++++++++++++ multimaster.control | 4 + multimaster.h | 24 + pglogical_apply.c | 818 +++++++++++++ pglogical_config.c | 499 ++++++++ pglogical_config.h | 55 + pglogical_hooks.c | 232 ++++ pglogical_hooks.h | 22 + pglogical_output.c | 535 +++++++++ pglogical_output.h | 105 ++ pglogical_output/README | 7 + pglogical_output/hooks.h | 72 ++ pglogical_proto.c | 384 ++++++ pglogical_proto.h | 57 + pglogical_receiver.c | 598 ++++++++++ tests/daemons.go | 259 +++++ tests/deploy_layouts/cluster.yml | 131 +++ tests/deploy_layouts/cluster_pg_shard.yml | 32 + .../roles/postgres/tasks/main.yml | 117 ++ .../roles/postgres/vars/main.yml | 27 + .../roles/postgrespro/tasks/dtm.yml | 43 + .../roles/postgrespro/tasks/main.yml | 58 + .../roles/postgrespro/tasks/pg_shard.yml | 50 + .../roles/postgrespro/tasks/postgres.yml | 77 ++ .../roles/postgrespro/vars/main.yml | 38 + tests/deploy_layouts/single.yml | 20 + tests/dtmbench | Bin 0 -> 451917 bytes tests/dtmbench.cpp | 316 +++++ tests/farms/localhost | 8 + tests/farms/sai | 19 + tests/init.sql | 2 + tests/makefile | 10 + tests/mm.pgb | 7 + tests/perf.results | 102 ++ tests/perf.yml | 60 + tests/perf/perf.go | 292 +++++ tests/perf/readers.go | 92 ++ tests/perf/transfers-fdw.go | 153 +++ tests/perf/transfers-pgshard.go | 124 ++ tests/perf/transfers.go | 166 +++ tests/pg_hba.conf | 93 ++ tests/postgresql.conf.mm | 628 ++++++++++ tests/reinit-mm.sh | 37 + tests/run-pgbench.sh | 1 + tests/run.sh | 5 + tests/run_perf.sh | 9 + 55 files changed, 8364 insertions(+) create mode 100644 Makefile create mode 100644 README.md create mode 100644 bgwpool.c create mode 100644 bgwpool.h create mode 100644 bytebuf.c create mode 100644 bytebuf.h create mode 100644 decoder_raw.c create mode 100644 logical.conf create mode 100644 multimaster--1.0.sql create mode 100644 multimaster.c create mode 100644 multimaster.control create mode 100644 multimaster.h create mode 100644 pglogical_apply.c create mode 100644 pglogical_config.c create mode 100644 pglogical_config.h create mode 100644 pglogical_hooks.c create mode 100644 pglogical_hooks.h create mode 100644 pglogical_output.c create mode 100644 pglogical_output.h create mode 100644 pglogical_output/README create mode 100644 pglogical_output/hooks.h create mode 100644 pglogical_proto.c create mode 100644 pglogical_proto.h create mode 100644 pglogical_receiver.c create mode 100644 tests/daemons.go create mode 100644 tests/deploy_layouts/cluster.yml create mode 100644 tests/deploy_layouts/cluster_pg_shard.yml create mode 100644 tests/deploy_layouts/roles/postgres/tasks/main.yml create mode 100644 tests/deploy_layouts/roles/postgres/vars/main.yml create mode 100644 tests/deploy_layouts/roles/postgrespro/tasks/dtm.yml create mode 100644 tests/deploy_layouts/roles/postgrespro/tasks/main.yml create mode 100644 tests/deploy_layouts/roles/postgrespro/tasks/pg_shard.yml create mode 100644 tests/deploy_layouts/roles/postgrespro/tasks/postgres.yml create mode 100644 tests/deploy_layouts/roles/postgrespro/vars/main.yml create mode 100644 tests/deploy_layouts/single.yml create mode 100755 tests/dtmbench create mode 100644 tests/dtmbench.cpp create mode 100644 tests/farms/localhost create mode 100644 tests/farms/sai create mode 100644 tests/init.sql create mode 100644 tests/makefile create mode 100644 tests/mm.pgb create mode 100644 tests/perf.results create mode 100644 tests/perf.yml create mode 100644 tests/perf/perf.go create mode 100644 tests/perf/readers.go create mode 100644 tests/perf/transfers-fdw.go create mode 100644 tests/perf/transfers-pgshard.go create mode 100644 tests/perf/transfers.go create mode 100644 tests/pg_hba.conf create mode 100644 tests/postgresql.conf.mm create mode 100755 tests/reinit-mm.sh create mode 100755 tests/run-pgbench.sh create mode 100755 tests/run.sh create mode 100644 tests/run_perf.sh diff --git a/Makefile b/Makefile new file mode 100644 index 0000000000..ea66e1225f --- /dev/null +++ b/Makefile @@ -0,0 +1,33 @@ +MODULE_big = multimaster +OBJS = multimaster.o ../arbiter/lib/libarbiter.a ../arbiter/sockhub/libsockhub.a bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o +#OBJS = multimaster.o pglogical_receiver.o decoder_raw.o libdtm.o bytebuf.o bgwpool.o sockhub/sockhub.o + +override CPPFLAGS += -I../arbiter/api -I../arbiter/sockhub + +EXTENSION = multimaster +DATA = multimaster--1.0.sql + +.PHONY: all + +all: multimaster.o multimaster.so + +../arbiter/sockhub/libsockhub.a: + make -C ../arbiter/sockhub + +../arbiter/lib/libarbiter.a: + make -C ../arbiter + +PG_CPPFLAGS = -I$(libpq_srcdir) -DUSE_PGLOGICAL_OUTPUT +SHLIB_LINK = $(libpq) + +ifdef USE_PGXS +PG_CONFIG = pg_config +PGXS := $(shell $(PG_CONFIG) --pgxs) +include $(PGXS) +else +subdir = contrib/multimaster +top_builddir = ../.. +include $(top_builddir)/src/Makefile.global +include $(top_srcdir)/contrib/contrib-global.mk +endif + diff --git a/README.md b/README.md new file mode 100644 index 0000000000..01225bfd72 --- /dev/null +++ b/README.md @@ -0,0 +1,117 @@ +# pg_dtm + +### Design + +This repo implements distributed transaction manager using Snapshot Sharing mechanism. General concepts and alternative approaches described in postgres wiki https://wiki.postgresql.org/wiki/DTM. + +Backend-DTM protocol description can be found in [dtmd/README](dtmd/README). + +### Installation + +* Patch postgres using xtm.patch. After that build and install postgres in usual way. +```bash +cd ~/code/postgres +patch -p1 < ~/code/pg_dtm/xtm.patch +``` +* Install pg_dtm extension. +```bash +export PATH=/path/to/pgsql/bin/:$PATH +cd ~/code/pg_dtm +make && make install +``` +* Run dtmd. +```bash +cd ~/code/pg_dtm/dtmd +make +mkdir /tmp/clog +./bin/dtmd & +``` +* To run something meaningful you need at leat two postgres instances. Also pg_dtm requires presense in ```shared_preload_libraries```. +```bash +initdb -D ./install/data1 +initdb -D ./install/data2 +echo "port = 5433" >> ./install/data2/postgresql.conf +echo "shared_preload_libraries = 'pg_dtm'" >> ./install/data1/postgresql.conf +echo "shared_preload_libraries = 'pg_dtm'" >> ./install/data2/postgresql.conf +pg_ctl -D ./install/data1 -l ./install/data1/log start +pg_ctl -D ./install/data2 -l ./install/data2/log start +``` + +#### Automatic provisioning + +For a cluster-wide deploy we use ansible, more details in tests/deploy_layouts. (Ansible instructions will be later) + +### Usage + +Now cluster is running and you can use global tx between two nodes. Let's connect to postgres instances at different ports: + +```sql +create extension pg_dtm; -- node1 +create table accounts(user_id int, amount int); -- node1 +insert into accounts (select 2*generate_series(1,100)-1, 0); -- node1, odd user_id's + create extension pg_dtm; -- node2 + create table accounts(user_id int, amount int); -- node2 + insert into accounts (select 2*generate_series(1,100), 0); -- node2, even user_id's +select dtm_begin_transaction(); -- node1, returns global xid, e.g. 42 + select dtm_join_transaction(42); -- node2, join global tx +begin; -- node1 + begin; -- node2 +update accounts set amount=amount-100 where user_id=1; -- node1, transfer money from user#1 + update accounts set amount=amount+100 where user_id=2; -- node2, to user#2 +commit; -- node1, blocks until second commit happend + commit; -- node2 +``` + +### Consistency testing + +To ensure consistency we use simple bank test: perform a lot of simultaneous transfers between accounts on different servers, while constantly checking total amount of money on all accounts. This test can be found in tests/perf. + +```bash +> go run ./tests/perf/* + -C value + Connection string (repeat for multiple connections) + -a int + The number of bank accounts (default 100000) + -b string + Backend to use. Possible optinos: transfers, fdw, pgshard, readers. (default "transfers") + -g Use DTM to keep global consistency + -i Init database + -l Use 'repeatable read' isolation level instead of 'read committed' + -n int + The number updates each writer (reader in case of Reades backend) performs (default 10000) + -p Use parallel execs + -r int + The number of readers (default 1) + -s int + StartID. Script will update rows starting from this value + -v Show progress and other stuff for mortals + -w int + The number of writers (default 8) +``` + +So previous installation can be initialized with: +``` +go run ./tests/perf/*.go \ +-C "dbname=postgres port=5432" \ +-C "dbname=postgres port=5433" \ +-g -i +``` +and tested with: +``` +go run ./tests/perf/*.go \ +-C "dbname=postgres port=5432" \ +-C "dbname=postgres port=5433" \ +-g +``` + +### Using with postres_fdw. + +We also provide a patch, that enables support of global transactions with postres_fdw. After patching and installing postres_fdw it is possible to run same test via fdw usig key ```-b fdw```. + +### Using with pg_shard + +Citus Data have branch in their pg_shard repo, that interacts with transaction manager. https://github.com/citusdata/pg_shard/tree/transaction_manager_integration +To use this feature one should have following line in postgresql.conf (or set it via GUC) +``` +pg_shard.use_dtm_transactions = 1 +``` diff --git a/bgwpool.c b/bgwpool.c new file mode 100644 index 0000000000..933f7fcfb2 --- /dev/null +++ b/bgwpool.c @@ -0,0 +1,134 @@ +#include "postgres.h" +#include "fmgr.h" +#include "miscadmin.h" +#include "postmaster/postmaster.h" +#include "postmaster/bgworker.h" +#include "storage/s_lock.h" +#include "storage/spin.h" +#include "storage/pg_sema.h" +#include "storage/shmem.h" + +#include "bgwpool.h" + +typedef struct +{ + BgwPoolConstructor constructor; + int id; +} BgwPoolExecutorCtx; + +size_t n_snapshots; +size_t n_active; + +static void BgwPoolMainLoop(Datum arg) +{ + BgwPoolExecutorCtx* ctx = (BgwPoolExecutorCtx*)arg; + int id = ctx->id; + BgwPool* pool = ctx->constructor(); + int size; + void* work; + + BackgroundWorkerUnblockSignals(); + BackgroundWorkerInitializeConnection(pool->dbname, NULL); + + elog(WARNING, "Start background worker %d", id); + + while(true) { + PGSemaphoreLock(&pool->available); + SpinLockAcquire(&pool->lock); + size = *(int*)&pool->queue[pool->head]; + Assert(size < pool->size); + work = palloc(size); + pool->active -= 1; + if (pool->head + size + 4 > pool->size) { + memcpy(work, pool->queue, size); + pool->head = INTALIGN(size); + } else { + memcpy(work, &pool->queue[pool->head+4], size); + pool->head += 4 + INTALIGN(size); + } + if (pool->size == pool->head) { + pool->head = 0; + } + if (pool->producerBlocked) { + pool->producerBlocked = false; + PGSemaphoreUnlock(&pool->overflow); + } + SpinLockRelease(&pool->lock); + pool->executor(id, work, size); + pfree(work); + } +} + +void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, size_t queueSize) +{ + pool->queue = (char*)ShmemAlloc(queueSize); + pool->executor = executor; + PGSemaphoreCreate(&pool->available); + PGSemaphoreCreate(&pool->overflow); + PGSemaphoreReset(&pool->available); + PGSemaphoreReset(&pool->overflow); + SpinLockInit(&pool->lock); + pool->producerBlocked = false; + pool->head = 0; + pool->tail = 0; + pool->size = queueSize; + pool->active = 0; + strcpy(pool->dbname, dbname); +} + +void BgwPoolStart(int nWorkers, BgwPoolConstructor constructor) +{ + int i; + BackgroundWorker worker; + + MemSet(&worker, 0, sizeof(BackgroundWorker)); + worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; + worker.bgw_start_time = BgWorkerStart_ConsistentState; + worker.bgw_main = BgwPoolMainLoop; + worker.bgw_restart_time = 10; /* Wait 10 seconds for restart before crash */ + + for (i = 0; i < nWorkers; i++) { + BgwPoolExecutorCtx* ctx = (BgwPoolExecutorCtx*)malloc(sizeof(BgwPoolExecutorCtx)); + snprintf(worker.bgw_name, BGW_MAXLEN, "bgw_pool_worker_%d", i+1); + ctx->id = i; + ctx->constructor = constructor; + worker.bgw_main_arg = (Datum)ctx; + RegisterBackgroundWorker(&worker); + } +} + +void BgwPoolExecute(BgwPool* pool, void* work, size_t size) +{ + Assert(size+4 <= pool->size); + + SpinLockAcquire(&pool->lock); + while (true) { + if ((pool->head <= pool->tail && pool->size - pool->tail < size + 4 && pool->head < size) + || (pool->head > pool->tail && pool->head - pool->tail < size + 4)) + { + pool->producerBlocked = true; + SpinLockRelease(&pool->lock); + PGSemaphoreLock(&pool->overflow); + SpinLockAcquire(&pool->lock); + } else { + pool->active += 1; + n_snapshots += 1; + n_active += pool->active; + *(int*)&pool->queue[pool->tail] = size; + if (pool->size - pool->tail >= size + 4) { + memcpy(&pool->queue[pool->tail+4], work, size); + pool->tail += 4 + INTALIGN(size); + } else { + memcpy(pool->queue, work, size); + pool->tail = INTALIGN(size); + } + if (pool->tail == pool->size) { + pool->tail = 0; + } + PGSemaphoreUnlock(&pool->available); + break; + } + } + SpinLockRelease(&pool->lock); +} + diff --git a/bgwpool.h b/bgwpool.h new file mode 100644 index 0000000000..36303fd155 --- /dev/null +++ b/bgwpool.h @@ -0,0 +1,35 @@ +#ifndef __BGWPOOL_H__ +#define __BGWPOOL_H__ + +#include "storage/s_lock.h" +#include "storage/spin.h" +#include "storage/pg_sema.h" + +typedef void(*BgwPoolExecutor)(int id, void* work, size_t size); + +#define MAX_DBNAME_LEN 30 + +typedef struct +{ + BgwPoolExecutor executor; + volatile slock_t lock; + PGSemaphoreData available; + PGSemaphoreData overflow; + size_t head; + size_t tail; + size_t size; + size_t active; + bool producerBlocked; + char dbname[MAX_DBNAME_LEN]; + char* queue; +} BgwPool; + +typedef BgwPool*(*BgwPoolConstructor)(void); + +extern void BgwPoolStart(int nWorkers, BgwPoolConstructor constructor); + +extern void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, size_t queueSize); + +extern void BgwPoolExecute(BgwPool* pool, void* work, size_t size); + +#endif diff --git a/bytebuf.c b/bytebuf.c new file mode 100644 index 0000000000..a7f6708947 --- /dev/null +++ b/bytebuf.c @@ -0,0 +1,36 @@ +#include "postgres.h" +#include "bytebuf.h" + +#define INIT_BUF_SIZE 1024 + +void ByteBufferAlloc(ByteBuffer* buf) +{ + buf->size = INIT_BUF_SIZE; + buf->data = palloc(buf->size); + buf->used = 0; +} + +void ByteBufferAppend(ByteBuffer* buf, void* data, int len) +{ + if (buf->used + len > buf->size) { + buf->size = buf->used + len > buf->size*2 ? buf->used + len : buf->size*2; + buf->data = (char*)repalloc(buf->data, buf->size); + } + memcpy(&buf->data[buf->used], data, len); + buf->used += len; +} + +void ByteBufferAppendInt32(ByteBuffer* buf, int data) +{ + ByteBufferAppend(buf, &data, sizeof data); +} + +void ByteBufferFree(ByteBuffer* buf) +{ + pfree(buf->data); +} + +void ByteBufferReset(ByteBuffer* buf) +{ + buf->used = 0; +} diff --git a/bytebuf.h b/bytebuf.h new file mode 100644 index 0000000000..5f4097adde --- /dev/null +++ b/bytebuf.h @@ -0,0 +1,17 @@ +#ifndef __BYTEBUF_H__ +#define __BYTEBUF_H__ + +typedef struct +{ + char* data; + int size; + int used; +} ByteBuffer; + +extern void ByteBufferAlloc(ByteBuffer* buf); +extern void ByteBufferAppend(ByteBuffer* buf, void* data, int len); +extern void ByteBufferAppendInt32(ByteBuffer* buf, int data); +extern void ByteBufferFree(ByteBuffer* buf); +extern void ByteBufferReset(ByteBuffer* buf); + +#endif diff --git a/decoder_raw.c b/decoder_raw.c new file mode 100644 index 0000000000..4d1d5b81b7 --- /dev/null +++ b/decoder_raw.c @@ -0,0 +1,552 @@ +/*------------------------------------------------------------------------- + * + * decoder_raw.c + * Logical decoding output plugin generating SQL queries based + * on things decoded. + * + * Copyright (c) 1996-2015, PostgreSQL Global Development Group + * + * IDENTIFICATION + * decoder_raw/decoder_raw.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/genam.h" +#include "access/sysattr.h" +#include "catalog/pg_class.h" +#include "catalog/pg_type.h" +#include "nodes/parsenodes.h" +#include "replication/output_plugin.h" +#include "replication/logical.h" +#include "utils/builtins.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/rel.h" +#include "utils/relcache.h" +#include "utils/syscache.h" +#include "utils/typcache.h" +#include "multimaster.h" + +/* These must be available to pg_dlsym() */ +extern void _PG_output_plugin_init(OutputPluginCallbacks *cb); + +/* + * Structure storing the plugin specifications and options. + */ +typedef struct +{ + MemoryContext context; + bool isLocal; +} DecoderRawData; + +static void decoder_raw_startup(LogicalDecodingContext *ctx, + OutputPluginOptions *opt, + bool is_init); +static void decoder_raw_shutdown(LogicalDecodingContext *ctx); +static void decoder_raw_begin_txn(LogicalDecodingContext *ctx, + ReorderBufferTXN *txn); +static void decoder_raw_commit_txn(LogicalDecodingContext *ctx, + ReorderBufferTXN *txn, + XLogRecPtr commit_lsn); +static void decoder_raw_change(LogicalDecodingContext *ctx, + ReorderBufferTXN *txn, Relation rel, + ReorderBufferChange *change); + +/* specify output plugin callbacks */ +void +_PG_output_plugin_init(OutputPluginCallbacks *cb) +{ + AssertVariableIsOfType(&_PG_output_plugin_init, LogicalOutputPluginInit); + + cb->startup_cb = decoder_raw_startup; + cb->begin_cb = decoder_raw_begin_txn; + cb->change_cb = decoder_raw_change; + cb->commit_cb = decoder_raw_commit_txn; + cb->shutdown_cb = decoder_raw_shutdown; +} + + +/* initialize this plugin */ +static void +decoder_raw_startup(LogicalDecodingContext *ctx, OutputPluginOptions *opt, + bool is_init) +{ + DecoderRawData *data; + + data = (DecoderRawData*)palloc(sizeof(DecoderRawData)); + data->context = AllocSetContextCreate(ctx->context, + "Raw decoder context", + ALLOCSET_DEFAULT_MINSIZE, + ALLOCSET_DEFAULT_INITSIZE, + ALLOCSET_DEFAULT_MAXSIZE); + data->isLocal = false; + ctx->output_plugin_private = data; + + opt->output_type = OUTPUT_PLUGIN_TEXTUAL_OUTPUT; +} + +/* cleanup this plugin's resources */ +static void +decoder_raw_shutdown(LogicalDecodingContext *ctx) +{ + DecoderRawData *data = ctx->output_plugin_private; + + /* cleanup our own resources via memory context reset */ + MemoryContextDelete(data->context); +} + +/* BEGIN callback */ +static TransactionId lastXid; + +static void +decoder_raw_begin_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn) +{ + DecoderRawData *data = ctx->output_plugin_private; + Assert(lastXid != txn->xid); + lastXid = txn->xid; + if (MMIsLocalTransaction(txn->xid)) { + XTM_INFO("Skip local transaction %u\n", txn->xid); + data->isLocal = true; + } else { + OutputPluginPrepareWrite(ctx, true); + XTM_INFO("Send transaction %u to replica\n", txn->xid); + appendStringInfo(ctx->out, "BEGIN %u;", txn->xid); + OutputPluginWrite(ctx, true); + data->isLocal = false; + } +} + +/* COMMIT callback */ +static void +decoder_raw_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, + XLogRecPtr commit_lsn) +{ + DecoderRawData *data = ctx->output_plugin_private; + if (!data->isLocal) { + XTM_INFO("Send commit of transaction %u to replica\n", txn->xid); + OutputPluginPrepareWrite(ctx, true); + appendStringInfoString(ctx->out, "COMMIT;"); + OutputPluginWrite(ctx, true); + } else { + XTM_INFO("Skip commit of transaction %u\n", txn->xid); + } +} + +/* + * Print literal `outputstr' already represented as string of type `typid' + * into stringbuf `s'. + * + * Some builtin types aren't quoted, the rest is quoted. Escaping is done as + * if standard_conforming_strings were enabled. + */ +static void +print_literal(StringInfo s, Oid typid, char *outputstr) +{ + const char *valptr; + + switch (typid) + { + case BOOLOID: + if (outputstr[0] == 't') + appendStringInfoString(s, "true"); + else + appendStringInfoString(s, "false"); + break; + + case INT2OID: + case INT4OID: + case INT8OID: + case OIDOID: + case FLOAT4OID: + case FLOAT8OID: + case NUMERICOID: + /* NB: We don't care about Inf, NaN et al. */ + appendStringInfoString(s, outputstr); + break; + + case BITOID: + case VARBITOID: + appendStringInfo(s, "B'%s'", outputstr); + break; + + default: + appendStringInfoChar(s, '\''); + for (valptr = outputstr; *valptr; valptr++) + { + char ch = *valptr; + + if (SQL_STR_DOUBLE(ch, false)) + appendStringInfoChar(s, ch); + appendStringInfoChar(s, ch); + } + appendStringInfoChar(s, '\''); + break; + } +} + +/* + * Print a relation name into the StringInfo provided by caller. + */ +static void +print_relname(StringInfo s, Relation rel) +{ + Form_pg_class class_form = RelationGetForm(rel); + + appendStringInfoString(s, + quote_qualified_identifier( + get_namespace_name( + get_rel_namespace(RelationGetRelid(rel))), + NameStr(class_form->relname))); +} + +/* + * Print a value into the StringInfo provided by caller. + */ +static void +print_value(StringInfo s, Datum origval, Oid typid, bool isnull) +{ + Oid typoutput; + bool typisvarlena; + + /* Query output function */ + getTypeOutputInfo(typid, + &typoutput, &typisvarlena); + + /* Print value */ + if (isnull) + appendStringInfoString(s, "null"); + else if (typisvarlena && VARATT_IS_EXTERNAL_ONDISK(origval)) + appendStringInfoString(s, "unchanged-toast-datum"); + else if (!typisvarlena) + print_literal(s, typid, + OidOutputFunctionCall(typoutput, origval)); + else + { + /* Definitely detoasted Datum */ + Datum val; + val = PointerGetDatum(PG_DETOAST_DATUM(origval)); + print_literal(s, typid, OidOutputFunctionCall(typoutput, val)); + } +} + +/* + * Print a WHERE clause item + */ +static void +print_where_clause_item(StringInfo s, + Relation relation, + HeapTuple tuple, + int natt, + bool *first_column) +{ + Form_pg_attribute attr; + Datum origval; + bool isnull; + TupleDesc tupdesc = RelationGetDescr(relation); + + attr = tupdesc->attrs[natt - 1]; + + /* Skip dropped columns and system columns */ + if (attr->attisdropped || attr->attnum < 0) + return; + + /* Skip comma for first colums */ + if (!*first_column) + appendStringInfoString(s, " AND "); + else + *first_column = false; + + /* Print attribute name */ + appendStringInfo(s, "%s = ", quote_identifier(NameStr(attr->attname))); + + /* Get Datum from tuple */ + origval = heap_getattr(tuple, natt, tupdesc, &isnull); + + /* Get output function */ + print_value(s, origval, attr->atttypid, isnull); +} + +/* + * Generate a WHERE clause for UPDATE or DELETE. + */ +static void +print_where_clause(StringInfo s, + Relation relation, + HeapTuple oldtuple, + HeapTuple newtuple) +{ + TupleDesc tupdesc = RelationGetDescr(relation); + int natt; + bool first_column = true; + + Assert(relation->rd_rel->relreplident == REPLICA_IDENTITY_DEFAULT || + relation->rd_rel->relreplident == REPLICA_IDENTITY_FULL || + relation->rd_rel->relreplident == REPLICA_IDENTITY_INDEX); + + /* Build the WHERE clause */ + appendStringInfoString(s, " WHERE "); + + RelationGetIndexList(relation); + /* Generate WHERE clause using new values of REPLICA IDENTITY */ + if (OidIsValid(relation->rd_replidindex)) + { + Relation indexRel; + int key; + + /* Use all the values associated with the index */ + indexRel = index_open(relation->rd_replidindex, AccessShareLock); + for (key = 0; key < indexRel->rd_index->indnatts; key++) + { + int relattr = indexRel->rd_index->indkey.values[key]; + + /* + * For a relation having REPLICA IDENTITY set at DEFAULT + * or INDEX, if one of the columns used for tuple selectivity + * is changed, the old tuple data is not NULL and need to + * be used for tuple selectivity. If no such columns are + * updated, old tuple data is NULL. + */ + print_where_clause_item(s, relation, + oldtuple ? oldtuple : newtuple, + relattr, &first_column); + } + index_close(indexRel, NoLock); + return; + } + + /* We need absolutely some values for tuple selectivity now */ + Assert(oldtuple != NULL && + relation->rd_rel->relreplident == REPLICA_IDENTITY_FULL); + + /* + * Fallback to default case, use of old values and print WHERE clause + * using all the columns. This is actually the code path for FULL. + */ + for (natt = 0; natt < tupdesc->natts; natt++) + print_where_clause_item(s, relation, oldtuple, + natt + 1, &first_column); +} + +/* + * Decode an INSERT entry + */ +static void +decoder_raw_insert(StringInfo s, + Relation relation, + HeapTuple tuple) +{ + TupleDesc tupdesc = RelationGetDescr(relation); + int natt; + bool first_column = true; + StringInfo values = makeStringInfo(); + + /* Initialize string info for values */ + initStringInfo(values); + + /* Query header */ + appendStringInfo(s, "INSERT INTO "); + print_relname(s, relation); + appendStringInfo(s, " ("); + + /* Build column names and values */ + for (natt = 0; natt < tupdesc->natts; natt++) + { + Form_pg_attribute attr; + Datum origval; + bool isnull; + + attr = tupdesc->attrs[natt]; + + /* Skip dropped columns and system columns */ + if (attr->attisdropped || attr->attnum < 0) + continue; + + /* Skip comma for first colums */ + if (!first_column) + { + appendStringInfoString(s, ", "); + appendStringInfoString(values, ", "); + } + else + first_column = false; + + /* Print attribute name */ + appendStringInfo(s, "%s", quote_identifier(NameStr(attr->attname))); + + /* Get Datum from tuple */ + origval = heap_getattr(tuple, natt + 1, tupdesc, &isnull); + + /* Get output function */ + print_value(values, origval, attr->atttypid, isnull); + } + + /* Append values */ + appendStringInfo(s, ") VALUES (%s);", values->data); + + /* Clean up */ + resetStringInfo(values); +} + +/* + * Decode a DELETE entry + */ +static void +decoder_raw_delete(StringInfo s, + Relation relation, + HeapTuple tuple) +{ + appendStringInfo(s, "DELETE FROM "); + print_relname(s, relation); + + /* + * Here the same tuple is used as old and new values, selectivity will + * be properly reduced by relation uses DEFAULT or INDEX as REPLICA + * IDENTITY. + */ + print_where_clause(s, relation, tuple, tuple); + appendStringInfoString(s, ";"); +} + + +/* + * Decode an UPDATE entry + */ +static void +decoder_raw_update(StringInfo s, + Relation relation, + HeapTuple oldtuple, + HeapTuple newtuple) +{ + TupleDesc tupdesc = RelationGetDescr(relation); + int natt; + bool first_column = true; + + /* If there are no new values, simply leave as there is nothing to do */ + if (newtuple == NULL) + return; + + appendStringInfo(s, "UPDATE "); + print_relname(s, relation); + + /* Build the SET clause with the new values */ + appendStringInfo(s, " SET "); + for (natt = 0; natt < tupdesc->natts; natt++) + { + Form_pg_attribute attr; + Datum origval; + bool isnull; + + attr = tupdesc->attrs[natt]; + + /* Skip dropped columns and system columns */ + if (attr->attisdropped || attr->attnum < 0) + continue; + + /* Skip comma for first colums */ + if (!first_column) + { + appendStringInfoString(s, ", "); + } + else + first_column = false; + + /* Print attribute name */ + appendStringInfo(s, "%s = ", quote_identifier(NameStr(attr->attname))); + + /* Get Datum from tuple */ + origval = heap_getattr(newtuple, natt + 1, tupdesc, &isnull); + + /* Get output function */ + print_value(s, origval, attr->atttypid, isnull); + } + + /* Print WHERE clause */ + print_where_clause(s, relation, oldtuple, newtuple); + + appendStringInfoString(s, ";"); +} + +/* + * Callback for individual changed tuples + */ +static void +decoder_raw_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, + Relation relation, ReorderBufferChange *change) +{ + DecoderRawData *data; + MemoryContext old; + char replident = relation->rd_rel->relreplident; + bool is_rel_non_selective; + + data = ctx->output_plugin_private; + if (data->isLocal) { + XTM_INFO("Skip action %d in transaction %u\n", change->action, txn->xid); + return; + } + XTM_INFO("Send action %d in transaction %u to replica\n", change->action, txn->xid); + + /* Avoid leaking memory by using and resetting our own context */ + old = MemoryContextSwitchTo(data->context); + + /* + * Determine if relation is selective enough for WHERE clause generation + * in UPDATE and DELETE cases. A non-selective relation uses REPLICA + * IDENTITY set as NOTHING, or DEFAULT without an available replica + * identity index. + */ + RelationGetIndexList(relation); + is_rel_non_selective = (replident == REPLICA_IDENTITY_NOTHING || + (replident == REPLICA_IDENTITY_DEFAULT && + !OidIsValid(relation->rd_replidindex))); + + /* Decode entry depending on its type */ + switch (change->action) + { + case REORDER_BUFFER_CHANGE_INSERT: + if (change->data.tp.newtuple != NULL) + { + OutputPluginPrepareWrite(ctx, true); + decoder_raw_insert(ctx->out, + relation, + &change->data.tp.newtuple->tuple); + OutputPluginWrite(ctx, true); + } + break; + case REORDER_BUFFER_CHANGE_UPDATE: + if (!is_rel_non_selective) + { + HeapTuple oldtuple = change->data.tp.oldtuple != NULL ? + &change->data.tp.oldtuple->tuple : NULL; + HeapTuple newtuple = change->data.tp.newtuple != NULL ? + &change->data.tp.newtuple->tuple : NULL; + + OutputPluginPrepareWrite(ctx, true); + decoder_raw_update(ctx->out, + relation, + oldtuple, + newtuple); + OutputPluginWrite(ctx, true); + } + break; + case REORDER_BUFFER_CHANGE_DELETE: + if (!is_rel_non_selective) + { + OutputPluginPrepareWrite(ctx, true); + decoder_raw_delete(ctx->out, + relation, + &change->data.tp.oldtuple->tuple); + OutputPluginWrite(ctx, true); + } + break; + default: + /* Should not come here */ + Assert(0); + break; + } + + MemoryContextSwitchTo(old); + MemoryContextReset(data->context); +} diff --git a/logical.conf b/logical.conf new file mode 100644 index 0000000000..407bbf3d9c --- /dev/null +++ b/logical.conf @@ -0,0 +1,2 @@ +wal_level = logical +max_replication_slots = 1 diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql new file mode 100644 index 0000000000..d15688916e --- /dev/null +++ b/multimaster--1.0.sql @@ -0,0 +1,15 @@ +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION multimaster" to load this file. \quit + +CREATE FUNCTION mm_start_replication() RETURNS void +AS 'MODULE_PATHNAME','mm_start_replication' +LANGUAGE C; + +CREATE FUNCTION mm_stop_replication() RETURNS void +AS 'MODULE_PATHNAME','mm_stop_replication' +LANGUAGE C; + +CREATE FUNCTION mm_drop_node(node integer, drop_slot bool default false) RETURNS void +AS 'MODULE_PATHNAME','mm_drop_node' +LANGUAGE C; + diff --git a/multimaster.c b/multimaster.c new file mode 100644 index 0000000000..d316624c5a --- /dev/null +++ b/multimaster.c @@ -0,0 +1,1035 @@ +/* + * multimaster.c + * + * Multimaster based on logical replication + * + */ + +#include +#include +#include + +#include "postgres.h" +#include "fmgr.h" +#include "miscadmin.h" +#include "libpq-fe.h" +#include "postmaster/postmaster.h" +#include "postmaster/bgworker.h" +#include "storage/s_lock.h" +#include "storage/spin.h" +#include "storage/lmgr.h" +#include "storage/shmem.h" +#include "storage/ipc.h" +#include "access/xlogdefs.h" +#include "access/xact.h" +#include "access/xtm.h" +#include "access/transam.h" +#include "access/subtrans.h" +#include "access/commit_ts.h" +#include "access/xlog.h" +#include "storage/proc.h" +#include "storage/procarray.h" +#include "executor/executor.h" +#include "access/twophase.h" +#include "utils/guc.h" +#include "utils/hsearch.h" +#include "utils/tqual.h" +#include "utils/array.h" +#include "utils/builtins.h" +#include "utils/memutils.h" +#include "commands/dbcommands.h" +#include "miscadmin.h" +#include "postmaster/autovacuum.h" +#include "storage/pmsignal.h" +#include "storage/proc.h" +#include "utils/syscache.h" +#include "replication/walsender.h" +#include "replication/slot.h" +#include "port/atomics.h" +#include "tcop/utility.h" + +#include "arbiter.h" +#include "sockhub.h" +#include "multimaster.h" +#include "bgwpool.h" + +typedef struct +{ + LWLockId hashLock; + LWLockId xidLock; + TransactionId minXid; /* XID of oldest transaction visible by any active transaction (local or global) */ + TransactionId nextXid; /* next XID for local transaction */ + size_t nReservedXids; /* number of XIDs reserved for local transactions */ + int64 disabledNodeMask; + int nNodes; + pg_atomic_uint32 nReceivers; + bool initialized; + BgwPool pool; +} DtmState; + +typedef struct +{ + TransactionId xid; + int count; +} LocalTransaction; + +typedef struct { + TransactionId xid; + GlobalTransactionId gtid; + bool is_global; + csn_t csn; + csn_t snapshot; +} DtmCurrentTrans; + + +#define DTM_SHMEM_SIZE (64*1024*1024) +#define DTM_HASH_SIZE 1003 + +#define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) +#define MAKE_GTID(xid) (((GlobalTransactionId)MyProcId << 32) | xid) + +void _PG_init(void); +void _PG_fini(void); + +PG_MODULE_MAGIC; + +PG_FUNCTION_INFO_V1(mm_start_replication); +PG_FUNCTION_INFO_V1(mm_stop_replication); +PG_FUNCTION_INFO_V1(mm_drop_node); + +static Snapshot DtmGetSnapshot(Snapshot snapshot); +static void DtmMergeWithGlobalSnapshot(Snapshot snapshot); +static XidStatus DtmGetTransactionStatus(TransactionId xid, XLogRecPtr *lsn); +static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); +static void DtmUpdateRecentXmin(Snapshot snapshot); +static void DtmInitialize(void); +static void DtmSubXactCallback(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg); +static void DtmXactCallback(XactEvent event, void *arg); +static TransactionId DtmGetNextXid(void); +static TransactionId DtmGetNewTransactionId(bool isSubXact); +static TransactionId DtmGetOldestXmin(Relation rel, bool ignoreVacuum); +static TransactionId DtmGetGlobalTransactionId(void); + +static bool DtmDetectGlobalDeadLock(PGPROC* proc); +static void DtmSerializeLock(PROCLOCK* lock, void* arg); +static char const* DtmGetName(void); + +static bool TransactionIdIsInSnapshot(TransactionId xid, Snapshot snapshot); +static bool TransactionIdIsInDoubt(TransactionId xid); + +static void DtmShmemStartup(void); +static void DtmBackgroundWorker(Datum arg); + +static void MMMarkTransAsLocal(TransactionId xid); +static BgwPool* MMPoolConstructor(void); +static bool MMRunUtilityStmt(PGconn* conn, char const* sql); +static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError); + +static HTAB* xid_in_doubt; +static HTAB* local_trans; +static DtmState* dtm; + +static TransactionId DtmNextXid; +static SnapshotData DtmSnapshot = { HeapTupleSatisfiesMVCC }; +static bool DtmHasGlobalSnapshot; +static int DtmLocalXidReserve; +static CommandId DtmCurcid; +static Snapshot DtmLastSnapshot; +static TransactionManager DtmTM = { + DtmGetTransactionStatus, + DtmSetTransactionStatus, + DtmGetSnapshot, + DtmGetNewTransactionId, + DtmGetOldestXmin, + PgTransactionIdIsInProgress, + DtmGetGlobalTransactionId, + PgXidInMVCCSnapshot, + DtmDetectGlobalDeadLock, + DtmGetName +}; + +bool MMDoReplication; +char* MMDatabaseName; + +static char* MMConnStrs; +static int MMNodeId; +static int MMNodes; +static int MMQueueSize; +static int MMWorkers; + +static char *Arbiters; +static char *ArbitersCopy; +static int DtmBufferSize; +static bool DtmVoted; + +static ExecutorFinish_hook_type PreviousExecutorFinishHook; +static ProcessUtility_hook_type PreviousProcessUtilityHook; +static shmem_startup_hook_type PreviousShmemStartupHook; + + +static void MMExecutorFinish(QueryDesc *queryDesc); +static void MMProcessUtility(Node *parsetree, const char *queryString, + ProcessUtilityContext context, ParamListInfo params, + DestReceiver *dest, char *completionTag); +static bool MMIsDistributedTrans; + + +static char const* DtmGetName(void) +{ + return "mmts"; +} + +Snapshot DtmGetSnapshot(Snapshot snapshot) +{ + snapshot = PgGetSnapshotData(snapshot); + RecentGlobalDataXmin = RecentGlobalXmin = DtmAdjustOldestXid(RecentGlobalDataXmin); + return snapshot; +} + + +TransactionId DtmGetOldestXmin(Relation rel, bool ignoreVacuum) +{ + TransactionId xmin = PgGetOldestXmin(rel, ignoreVacuum); + xmin = DtmAdjustOldestXid(xmin); + return xmin; +} + +bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) +{ +#if TRACE_SLEEP_TIME + static timestamp_t firstReportTime; + static timestamp_t prevReportTime; + static timestamp_t totalSleepTime; + static timestamp_t maxSleepTime; +#endif + timestamp_t delay = MIN_WAIT_TIMEOUT; + Assert(xid != InvalidTransactionId); + + SpinLockAcquire(&local->lock); + +#if TRACE_SLEEP_TIME + if (firstReportTime == 0) { + firstReportTime = dtm_get_current_time(); + } +#endif + while (true) + { + DtmTransStatus* ts = (DtmTransStatus*)hash_search(xid2status, &xid, HASH_FIND, NULL); + if (ts != NULL) + { + if (ts->cid > dtm_tx.snapshot) { + DTM_TRACE((stderr, "%d: tuple with xid=%d(csn=%lld) is invisibile in snapshot %lld\n", + getpid(), xid, ts->cid, dtm_tx.snapshot)); + SpinLockRelease(&local->lock); + return true; + } + if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) + { + DTM_TRACE((stderr, "%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtm_tx.snapshot)); + SpinLockRelease(&local->lock); +#if TRACE_SLEEP_TIME + { + timestamp_t delta, now = dtm_get_current_time(); +#endif + dtm_sleep(delay); +#if TRACE_SLEEP_TIME + delta = dtm_get_current_time() - now; + totalSleepTime += delta; + if (delta > maxSleepTime) { + maxSleepTime = delta; + } + if (now > prevReportTime + USEC*10) { + prevReportTime = now; + if (firstReportTime == 0) { + firstReportTime = now; + } else { + fprintf(stderr, "Snapshot sleep %lu of %lu usec (%f%%), maximum=%lu\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime), maxSleepTime); + } + } + } +#endif + if (delay*2 <= MAX_WAIT_TIMEOUT) { + delay *= 2; + } + SpinLockAcquire(&local->lock); + } + else + { + bool invisible = ts->status == TRANSACTION_STATUS_ABORTED; + DTM_TRACE((stderr, "%d: tuple with xid=%d(csn= %lld) is %s in snapshot %lld\n", + getpid(), xid, ts->cid, invisible ? "rollbacked" : "committed", dtm_tx.snapshot)); + SpinLockRelease(&local->lock); + return invisible; + } + } + else + { + DTM_TRACE((stderr, "%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtm_tx.snapshot)); + break; + } + } + SpinLockRelease(&local->lock); + return PgXidInMVCCSnapshot(xid, snapshot); +} + +static uint32 dtm_xid_hash_fn(const void *key, Size keysize) +{ + return (uint32)*(TransactionId*)key; +} + +static int dtm_xid_match_fn(const void *key1, const void *key2, Size keysize) +{ + return *(TransactionId*)key1 - *(TransactionId*)key2; +} + +static void DtmTransactionListAppend(DtmTransStatus* ts) +{ + ts->next = NULL; + *local->trans_list_tail = ts; + local->trans_list_tail = &ts->next; +} + +static void DtmTransactionListInsertAfter(DtmTransStatus* after, DtmTransStatus* ts) +{ + ts->next = after->next; + after->next = ts; + if (local->trans_list_tail == &after->next) { + local->trans_list_tail = &ts->next; + } +} + +static TransactionId DtmAdjustOldestXid(TransactionId xid) +{ + if (TransactionIdIsValid(xid)) { + DtmTransStatus *ts, *prev = NULL; + timestamp_t cutoff_time = dtm_get_current_time() - DtmVacuumDelay*USEC; + SpinLockAcquire(&local->lock); + ts = (DtmTransStatus*)hash_search(xid2status, &xid, HASH_FIND, NULL); + if (ts != NULL) { + cutoff_time = ts->cid - DtmVacuumDelay*USEC; + } + for (ts = local->trans_list_head; ts != NULL && ts->cid < cutoff_time; prev = ts, ts = ts->next) { + if (prev != NULL) { + hash_search(xid2status, &prev->xid, HASH_REMOVE, NULL); + } + } + if (prev != NULL) { + local->trans_list_head = prev; + xid = prev->xid; + } else { + xid = FirstNormalTransactionId; + } + SpinLockRelease(&local->lock); + } + return xid; +} + +static void DtmInitialize() +{ + bool found; + static HASHCTL info; + + LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); + dtm = ShmemInitStruct("dtm", sizeof(DtmState), &found); + if (!found) + { + dtm->hashLock = LWLockAssign(); + dtm->xidLock = LWLockAssign(); + dtm->nReservedXids = 0; + dtm->minXid = InvalidTransactionId; + dtm->nNodes = MMNodes; + dtm->disabledNodeMask = 0; + pg_atomic_write_u32(&dtm->nReceivers, 0); + dtm->initialized = false; + BgwPoolInit(&dtm->pool, MMExecutor, MMDatabaseName, MMQueueSize); + RegisterXactCallback(DtmXactCallback, NULL); + RegisterSubXactCallback(DtmSubXactCallback, NULL); + } + LWLockRelease(AddinShmemInitLock); + + info.keysize = sizeof(TransactionId); + info.entrysize = sizeof(TransactionId); + info.hash = dtm_xid_hash_fn; + info.match = dtm_xid_match_fn; + xid_in_doubt = ShmemInitHash( + "xid_in_doubt", + DTM_HASH_SIZE, DTM_HASH_SIZE, + &info, + HASH_ELEM | HASH_FUNCTION | HASH_COMPARE + ); + + info.keysize = sizeof(TransactionId); + info.entrysize = sizeof(LocalTransaction); + info.hash = dtm_xid_hash_fn; + info.match = dtm_xid_match_fn; + local_trans = ShmemInitHash( + "local_trans", + DTM_HASH_SIZE, DTM_HASH_SIZE, + &info, + HASH_ELEM | HASH_FUNCTION | HASH_COMPARE + ); + + MMDoReplication = true; + TM = &DtmTM; +} + +static void +DtmSubXactCallback(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg) +{ + elog(ERROR, "Subtransactions are not currently supported"); +} + +static void +DtmXactCallback(XactEvent event, void *arg) +{ + //XTM_INFO("%d: DtmXactCallbackevent=%d nextxid=%d\n", getpid(), event, DtmNextXid); + switch (event) + { + case XACT_EVENT_START: + //XTM_INFO("%d: normal=%d, initialized=%d, replication=%d, bgw=%d, vacuum=%d\n", + // getpid(), IsNormalProcessingMode(), dtm->initialized, MMDoReplication, IsBackgroundWorker, IsAutoVacuumWorkerProcess()); + if (IsNormalProcessingMode() && dtm->initialized && MMDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess()) { + MMBeginTransaction(); + } + break; + case XACT_EVENT_PRE_COMMIT: + DtmPrepareTransaction(xid); + break; + case XACT_EVENT_COMMIT: + case XACT_EVENT_ABORT: + if (TransactionIdIsValid(DtmNextXid)) + { + if (!DtmVoted) { + ArbiterSetTransStatus(DtmNextXid, TRANSACTION_STATUS_ABORTED, false); + } + if (event == XACT_EVENT_COMMIT) + { + /* + * Now transaction status is already written in CLOG, + * so we can remove information about it from hash table + */ + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + hash_search(xid_in_doubt, &DtmNextXid, HASH_REMOVE, NULL); + LWLockRelease(dtm->hashLock); + } +#if 0 /* should be handled now using DtmVoted flag */ + else + { + /* + * Transaction at the node can be aborted because of transaction failure at some other node + * before it starts doing anything and assigned Xid, in this case Postgres is not calling SetTransactionStatus, + * so we have to send report to DTMD here + */ + if (!TransactionIdIsValid(GetCurrentTransactionIdIfAny())) { + XTM_INFO("%d: abort transation on DTMD\n", getpid()); + ArbiterSetTransStatus(DtmNextXid, TRANSACTION_STATUS_ABORTED, false); + } + } +#endif + DtmNextXid = InvalidTransactionId; + DtmLastSnapshot = NULL; + } + MMIsDistributedTrans = false; + break; + default: + break; + } +} + + +static void DtmPrepareTransaction(TransactionId xid) +{ + Assert(xid == dtm_tx.xid); + + if (!dtm_tx.gtid) { /* GTID is assigned for replicated transaction */ + DtmTransStatus* ts; + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + ts = hash_search(xid2status, &xid, HASH_ENTER, NULL); + ts->gtid = MAKE_GTID(xid); + ts->snapshot = dtm_tx.snapshot; + ts->status = TRANSACTION_STATUS_UNKNOWN; + LWLockRelease(dtm->hashLock); + } +} + +static void DtmCommitTransaction(TransactionId xid) +{ + DtmTransStatus* ts; + GlobalTransactionId gtid = dtm_tx.gtid; + csn_t csn; + bool found; + int i; + + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + status = hash_search(xid2status, &xid, HASH_ENTER, &found); + if (found) { /* master transaction */ + Assert(!gtid); + gtid = ts->gtid; + } else { + Assert(gtid); + /* GTID is assigned for replicated transaction */ + ts->status = TRANSACTION_STATUS_IN_PROGRESS; + } + ts->csn = dtm_get_cid(); + ts->nSubxids = id->nSubxids; + DtmTransactionListAppend(ts); + DtmAddSubtransactions(ts, id->subxids, id->nSubxids); + LWLockRelease(dtm->hashLock); + + csn = ArbiterGetCSN(gtid, ts->csn); /* get max CSN */ + + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + ts->csn = csn; + for (i = 0; i < ts->nSubxids; i++) { + ts = ts->next; + ts->cid = csn; + } + dtm_sync(csn); + LWLockRelease(dtm->hashLock); + + + + + + +static XidStatus DtmGetTransactionStatus(TransactionId xid, XLogRecPtr *lsn) +{ + /* Because of global snapshots we can ask for status of transaction which is not yet started locally: so we have + * to compare xid with ShmemVariableCache->nextXid before accessing CLOG + */ + XidStatus status = xid >= ShmemVariableCache->nextXid + ? TRANSACTION_STATUS_IN_PROGRESS + : PgTransactionIdGetStatus(xid, lsn); + XTM_TRACE("XTM: DtmGetTransactionStatus\n"); + return status; +} + +static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) +{ + XTM_INFO("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); + if (!RecoveryInProgress()) + { + if (TransactionIdIsValid(DtmNextXid)) + { + DtmVoted = true; + if (status == TRANSACTION_STATUS_ABORTED || !MMIsDistributedTrans) + { + PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); + ArbiterSetTransStatus(xid, TRANSACTION_STATUS_ABORTED, false); + XTM_INFO("Abort transaction %d\n", xid); + return; + } + else + { + XidStatus verdict; + XTM_INFO("Begin commit transaction %d\n", xid); + + /* Mark transaction as in-doubt in xid_in_doubt hash table */ + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + hash_search(xid_in_doubt, &DtmNextXid, HASH_ENTER, NULL); + LWLockRelease(dtm->hashLock); + verdict = ArbiterSetTransStatus(xid, status, true); + if (verdict != status) { + XTM_INFO("Commit of transaction %d is rejected by arbiter: staus=%d\n", xid, verdict); + DtmNextXid = InvalidTransactionId; + DtmLastSnapshot = NULL; + MMIsDistributedTrans = false; + MarkAsAborted(); + END_CRIT_SECTION(); + elog(ERROR, "Commit of transaction %d is rejected by DTM", xid); + } else { + XTM_INFO("Commit transaction %d\n", xid); + } + } + } + else + { + XTM_INFO("Set transaction %u status in local CLOG\n" , xid); + } + } + else if (status != TRANSACTION_STATUS_ABORTED) + { + XidStatus gs; + gs = ArbiterGetTransStatus(xid, false); + if (gs != TRANSACTION_STATUS_UNKNOWN) { + Assert(gs != TRANSACTION_STATUS_IN_PROGRESS); + status = gs; + } + } + PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); +} + +/* + * *************************************************************************** + */ + +void +_PG_init(void) +{ + /* + * In order to create our shared memory area, we have to be loaded via + * shared_preload_libraries. If not, fall out without hooking into any of + * the main system. (We don't throw error here because it seems useful to + * allow the cs_* functions to be created even when the + * module isn't active. The functions must protect themselves against + * being called then, however.) + */ + if (!process_shared_preload_libraries_in_progress) + return; + + DefineCustomIntVariable( + "multimaster.workers", + "Number of multimaster executor workers per node", + NULL, + &MMWorkers, + 8, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomIntVariable( + "multimaster.queue_size", + "Multimaster queue size", + NULL, + &MMQueueSize, + 1024*1024, + 1024, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomIntVariable( + "multimaster.local_xid_reserve", + "Number of XIDs reserved by node for local transactions", + NULL, + &DtmLocalXidReserve, + 100, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomIntVariable( + "multimaster.buffer_size", + "Size of sockhub buffer for connection to DTM daemon, if 0, then direct connection will be used", + NULL, + &DtmBufferSize, + 0, + 0, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomStringVariable( + "multimaster.arbiters", + "The comma separated host:port pairs where arbiters reside", + NULL, + &Arbiters, + "127.0.0.1:5431", + PGC_BACKEND, // context + 0, // flags, + NULL, // GucStringCheckHook check_hook, + NULL, // GucStringAssignHook assign_hook, + NULL // GucShowHook show_hook + ); + + DefineCustomStringVariable( + "multimaster.conn_strings", + "Multimaster node connection strings separated by commas, i.e. 'replication=database dbname=postgres host=localhost port=5001,replication=database dbname=postgres host=localhost port=5002'", + NULL, + &MMConnStrs, + "", + PGC_BACKEND, // context + 0, // flags, + NULL, // GucStringCheckHook check_hook, + NULL, // GucStringAssignHook assign_hook, + NULL // GucShowHook show_hook + ); + + DefineCustomIntVariable( + "multimaster.node_id", + "Multimaster node ID", + NULL, + &MMNodeId, + 1, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + /* + * Request additional shared resources. (These are no-ops if we're not in + * the postmaster process.) We'll allocate or attach to the shared + * resources in dtm_shmem_startup(). + */ + RequestAddinShmemSpace(DTM_SHMEM_SIZE + MMQueueSize); + RequestAddinLWLocks(2); + + MMNodes = MMStartReceivers(MMConnStrs, MMNodeId); + if (MMNodes < 2) { + elog(ERROR, "Multimaster should have at least two nodes"); + } + BgwPoolStart(MMWorkers, MMPoolConstructor); + + ArbitersCopy = strdup(Arbiters); + if (DtmBufferSize != 0) + { + ArbiterConfig(Arbiters, Unix_socket_directories); + RegisterBackgroundWorker(&DtmWorker); + } + else + ArbiterConfig(Arbiters, NULL); + + /* + * Install hooks. + */ + PreviousShmemStartupHook = shmem_startup_hook; + shmem_startup_hook = DtmShmemStartup; + + PreviousExecutorFinishHook = ExecutorFinish_hook; + ExecutorFinish_hook = MMExecutorFinish; + + PreviousProcessUtilityHook = ProcessUtility_hook; + ProcessUtility_hook = MMProcessUtility; +} + +/* + * Module unload callback + */ +void +_PG_fini(void) +{ + shmem_startup_hook = PreviousShmemStartupHook; + ExecutorFinish_hook = PreviousExecutorFinishHook; + ProcessUtility_hook = PreviousProcessUtilityHook; +} + + +static void DtmShmemStartup(void) +{ + if (PreviousShmemStartupHook) { + PreviousShmemStartupHook(); + } + DtmInitialize(); +} + +void DtmLocalBegin(DtmCurrentTrans* x) +{ + if (!TransactionIdIsValid(x->xid)) { + SpinLockAcquire(&local->lock); + x->xid = GetCurrentTransactionIdIfAny(); + x->csn = INVALID_CSN; + x->is_global = false; + x->snapshot = dtm_get_csn(); + SpinLockRelease(&local->lock); + DTM_TRACE((stderr, "DtmLocalBegin: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot)); + } +} + +/* + * *************************************************************************** + */ + +GlobalTransactionId MMBeginTransaction(void) +{ + MMIsDistributedTrans = false; + return dtm_tx.snapshot; +} + +csn_t MMExtend + +void MMJoinTransaction(GlonalTransactionId gtid, csn_t snapshot) +{ + SpinLockAcquire(&local->lock); + dtm_sync(snapshot); + SpinLockRelease(&local->lock); + + dtm_tx.gtid = gtid; + dtm_tx.xid = GetCurrentTransactionId(); + dtm_tx.snapshot = snapshot; + MMIsDistributedTrans = true; + MMMarkTransAsLocal(dtm_tx.xid); +} + +void MMReceiverStarted() +{ + if (pg_atomic_fetch_add_u32(&dtm->nReceivers, 1) == dtm->nNodes-2) { + dtm->initialized = true; + } +} + +void MMMarkTransAsLocal(TransactionId xid) +{ + LocalTransaction* lt; + + Assert(TransactionIdIsValid(xid)); + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + lt = hash_search(local_trans, &xid, HASH_ENTER, NULL); + lt->count = dtm->nNodes-1; + LWLockRelease(dtm->hashLock); +} + +bool MMIsLocalTransaction(TransactionId xid) +{ + LocalTransaction* lt; + bool result = false; + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + lt = hash_search(local_trans, &xid, HASH_FIND, NULL); + if (lt != NULL) { + result = true; + Assert(lt->count > 0); + if (--lt->count == 0) { + hash_search(local_trans, &xid, HASH_REMOVE, NULL); + } + } + LWLockRelease(dtm->hashLock); + return result; +} + +bool MMDetectGlobalDeadLock(PGPROC* proc) +{ + elog(WARNING, "Global deadlock?"); + return true; +} + + +Datum +mm_start_replication(PG_FUNCTION_ARGS) +{ + MMDoReplication = true; + PG_RETURN_VOID(); +} + +Datum +mm_stop_replication(PG_FUNCTION_ARGS) +{ + MMDoReplication = false; + MMIsDistributedTrans = false; + PG_RETURN_VOID(); +} + +Datum +mm_drop_node(PG_FUNCTION_ARGS) +{ + int nodeId = PG_GETARG_INT32(0); + bool dropSlot = PG_GETARG_BOOL(1); + if (!BIT_SET(dtm->disabledNodeMask, nodeId-1)) + { + if (nodeId <= 0 || nodeId > dtm->nNodes) + { + elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, dtm->nNodes); + } + dtm->disabledNodeMask |= ((int64)1 << (nodeId-1)); + dtm->nNodes -= 1; + if (!IsTransactionBlock()) + { + MMBroadcastUtilityStmt(psprintf("select mm_drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); + } + if (dropSlot) + { + ReplicationSlotDrop(psprintf("mm_slot_%d", nodeId)); + } + } + PG_RETURN_VOID(); +} + +/* + * Execute statement with specified parameters and check its result + */ +static bool MMRunUtilityStmt(PGconn* conn, char const* sql) +{ + PGresult *result = PQexec(conn, sql); + int status = PQresultStatus(result); + bool ret = status == PGRES_COMMAND_OK || status == PGRES_TUPLES_OK; + if (!ret) { + elog(WARNING, "Command '%s' failed with status %d", sql, status); + } + PQclear(result); + return ret; +} + +static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError) +{ + char* conn_str = pstrdup(MMConnStrs); + char* conn_str_end = conn_str + strlen(conn_str); + int i = 0; + int64 disabledNodeMask = dtm->disabledNodeMask; + int failedNode = -1; + char const* errorMsg = NULL; + PGconn **conns = palloc0(sizeof(PGconn*)*MMNodes); + + while (conn_str < conn_str_end) + { + char* p = strchr(conn_str, ','); + if (p == NULL) { + p = conn_str_end; + } + *p = '\0'; + if (!BIT_SET(disabledNodeMask, i)) + { + conns[i] = PQconnectdb(conn_str); + if (PQstatus(conns[i]) != CONNECTION_OK) + { + if (ignoreError) + { + PQfinish(conns[i]); + conns[i] = NULL; + } else { + failedNode = i; + do { + PQfinish(conns[i]); + } while (--i >= 0); + elog(ERROR, "Failed to establish connection '%s' to node %d", conn_str, failedNode); + } + } + } + conn_str = p + 1; + i += 1; + } + Assert(i == MMNodes); + + for (i = 0; i < MMNodes; i++) + { + if (conns[i]) + { + if (!MMRunUtilityStmt(conns[i], "BEGIN TRANSACTION") && !ignoreError) + { + errorMsg = "Failed to start transaction at node %d"; + failedNode = i; + break; + } + if (!MMRunUtilityStmt(conns[i], sql) && !ignoreError) + { + errorMsg = "Failed to run command at node %d"; + failedNode = i; + break; + } + } + } + if (failedNode >= 0 && !ignoreError) + { + for (i = 0; i < MMNodes; i++) + { + if (conns[i]) + { + MMRunUtilityStmt(conns[i], "ROLLBACK TRANSACTION"); + } + } + } else { + for (i = 0; i < MMNodes; i++) + { + if (conns[i] && !MMRunUtilityStmt(conns[i], "COMMIT TRANSACTION") && !ignoreError) + { + errorMsg = "Commit failed at node %d"; + failedNode = i; + } + } + } + for (i = 0; i < MMNodes; i++) + { + if (conns[i]) + { + PQfinish(conns[i]); + } + } + if (!ignoreError && failedNode >= 0) + { + elog(ERROR, errorMsg, failedNode+1); + } +} + +static void MMProcessUtility(Node *parsetree, const char *queryString, + ProcessUtilityContext context, ParamListInfo params, + DestReceiver *dest, char *completionTag) +{ + bool skipCommand; + switch (nodeTag(parsetree)) + { + case T_TransactionStmt: + case T_PlannedStmt: + case T_ClosePortalStmt: + case T_FetchStmt: + case T_DoStmt: + case T_CopyStmt: + case T_PrepareStmt: + case T_ExecuteStmt: + case T_NotifyStmt: + case T_ListenStmt: + case T_UnlistenStmt: + case T_LoadStmt: + case T_VariableSetStmt: + case T_VariableShowStmt: + skipCommand = true; + break; + default: + skipCommand = false; + break; + } + if (skipCommand || IsTransactionBlock()) { + if (PreviousProcessUtilityHook != NULL) + { + PreviousProcessUtilityHook(parsetree, queryString, context, + params, dest, completionTag); + } + else + { + standard_ProcessUtility(parsetree, queryString, context, + params, dest, completionTag); + } + if (!skipCommand) { + MMIsDistributedTrans = false; + } + } else { + MMBroadcastUtilityStmt(queryString, false); + } +} +static void +MMExecutorFinish(QueryDesc *queryDesc) +{ + if (MMDoReplication) { + CmdType operation = queryDesc->operation; + EState *estate = queryDesc->estate; + if (estate->es_processed != 0) { + MMIsDistributedTrans |= operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE; + } + } + if (PreviousExecutorFinishHook != NULL) + { + PreviousExecutorFinishHook(queryDesc); + } + else + { + standard_ExecutorFinish(queryDesc); + } +} + +void MMExecute(void* work, int size) +{ + BgwPoolExecute(&dtm->pool, work, size); +} + +static BgwPool* MMPoolConstructor(void) +{ + return &dtm->pool; +} diff --git a/multimaster.control b/multimaster.control new file mode 100644 index 0000000000..6938570163 --- /dev/null +++ b/multimaster.control @@ -0,0 +1,4 @@ +comment = 'Multimaster' +default_version = '1.0' +module_pathname = '$libdir/multimaster' +relocatable = true \ No newline at end of file diff --git a/multimaster.h b/multimaster.h new file mode 100644 index 0000000000..433347fcac --- /dev/null +++ b/multimaster.h @@ -0,0 +1,24 @@ +#ifndef __MULTIMASTER_H__ +#define __MULTIMASTER_H__ + +#include "bytebuf.h" + +#define XTM_TRACE(fmt, ...) +/* #define XTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ +#define XTM_INFO(fmt, ...) + +typedef int64 GlobalTransactionId; +typedef int64 csn_t; + +extern int MMStartReceivers(char* nodes, int node_id); +extern GlobalTransactionId MMBeginTransaction(void); +extern GlobalTransactionId MMTransactionSnapshot(TransactionId xid); +extern void MMJoinTransaction(GlobalTransactionId gtid, csn_t snapshot); +extern bool MMIsLocalTransaction(TransactionId xid); +extern void MMReceiverStarted(void); +extern void MMExecute(void* work, int size); +extern void MMExecutor(int id, void* work, size_t size); + +extern char* MMDatabaseName; + +#endif diff --git a/pglogical_apply.c b/pglogical_apply.c new file mode 100644 index 0000000000..aaafd155e7 --- /dev/null +++ b/pglogical_apply.c @@ -0,0 +1,818 @@ +#include "postgres.h" + +#include "funcapi.h" +#include "libpq-fe.h" +#include "miscadmin.h" +#include "pgstat.h" + +#include "access/htup_details.h" +#include "access/relscan.h" +#include "access/xact.h" + +#include "catalog/catversion.h" +#include "catalog/dependency.h" +#include "catalog/index.h" +#include "catalog/namespace.h" +#include "catalog/pg_type.h" + +#include "executor/spi.h" + +#include "libpq/pqformat.h" + +#include "mb/pg_wchar.h" + +#include "parser/parse_type.h" + +#include "replication/logical.h" + +#include "storage/ipc.h" +#include "storage/lmgr.h" +#include "storage/lwlock.h" +#include "storage/bufmgr.h" +#include "storage/proc.h" + +#include "tcop/pquery.h" +#include "tcop/tcopprot.h" +#include "tcop/utility.h" + +#include "utils/array.h" +#include "utils/tqual.h" +#include "utils/builtins.h" +#include "utils/datetime.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/snapmgr.h" +#include "utils/syscache.h" +#include "parser/parse_relation.h" + +#include "multimaster.h" + +typedef struct TupleData +{ + Datum values[MaxTupleAttributeNumber]; + bool isnull[MaxTupleAttributeNumber]; + bool changed[MaxTupleAttributeNumber]; +} TupleData; + +static Relation read_rel(StringInfo s, LOCKMODE mode); +static void read_tuple_parts(StringInfo s, Relation rel, TupleData *tup); +static EState* create_rel_estate(Relation rel); +static bool find_pkey_tuple(ScanKey skey, Relation rel, Relation idxrel, + TupleTableSlot *slot, bool lock, LockTupleMode mode); +static void build_index_scan_keys(EState *estate, ScanKey *scan_keys, TupleData *tup); +static bool build_index_scan_key(ScanKey skey, Relation rel, Relation idxrel, TupleData *tup); +static void UserTableUpdateOpenIndexes(EState *estate, TupleTableSlot *slot); +static void UserTableUpdateIndexes(EState *estate, TupleTableSlot *slot); + +static void process_remote_begin(StringInfo s); +static void process_remote_commit(StringInfo s); +static void process_remote_insert(StringInfo s, Relation rel); +static void process_remote_update(StringInfo s, Relation rel); +static void process_remote_delete(StringInfo s, Relation rel); + +/* + * Search the index 'idxrel' for a tuple identified by 'skey' in 'rel'. + * + * If a matching tuple is found setup 'tid' to point to it and return true, + * false is returned otherwise. + */ +bool +find_pkey_tuple(ScanKey skey, Relation rel, Relation idxrel, + TupleTableSlot *slot, bool lock, LockTupleMode mode) +{ + HeapTuple scantuple; + bool found; + IndexScanDesc scan; + SnapshotData snap; + TransactionId xwait; + + InitDirtySnapshot(snap); + scan = index_beginscan(rel, idxrel, + &snap, + RelationGetNumberOfAttributes(idxrel), + 0); + +retry: + found = false; + + index_rescan(scan, skey, RelationGetNumberOfAttributes(idxrel), NULL, 0); + + if ((scantuple = index_getnext(scan, ForwardScanDirection)) != NULL) + { + found = true; + /* FIXME: Improve TupleSlot to not require copying the whole tuple */ + ExecStoreTuple(scantuple, slot, InvalidBuffer, false); + ExecMaterializeSlot(slot); + + xwait = TransactionIdIsValid(snap.xmin) ? + snap.xmin : snap.xmax; + + if (TransactionIdIsValid(xwait)) + { + XactLockTableWait(xwait, NULL, NULL, XLTW_None); + goto retry; + } + } + + if (lock && found) + { + Buffer buf; + HeapUpdateFailureData hufd; + HTSU_Result res; + HeapTupleData locktup; + + ItemPointerCopy(&slot->tts_tuple->t_self, &locktup.t_self); + + PushActiveSnapshot(GetLatestSnapshot()); + + res = heap_lock_tuple(rel, &locktup, GetCurrentCommandId(false), mode, + false /* wait */, + false /* don't follow updates */, + &buf, &hufd); + /* the tuple slot already has the buffer pinned */ + ReleaseBuffer(buf); + + PopActiveSnapshot(); + + switch (res) + { + case HeapTupleMayBeUpdated: + break; + case HeapTupleUpdated: + /* XXX: Improve handling here */ + ereport(LOG, + (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), + errmsg("concurrent update, retrying"))); + goto retry; + default: + elog(ERROR, "unexpected HTSU_Result after locking: %u", res); + break; + } + } + + index_endscan(scan); + + return found; +} + +static void +build_index_scan_keys(EState *estate, ScanKey *scan_keys, TupleData *tup) +{ + ResultRelInfo *relinfo; + int i; + + relinfo = estate->es_result_relation_info; + + /* build scankeys for each index */ + for (i = 0; i < relinfo->ri_NumIndices; i++) + { + IndexInfo *ii = relinfo->ri_IndexRelationInfo[i]; + + /* + * Only unique indexes are of interest here, and we can't deal with + * expression indexes so far. FIXME: predicates should be handled + * better. + */ + if (!ii->ii_Unique || ii->ii_Expressions != NIL) + { + scan_keys[i] = NULL; + continue; + } + + scan_keys[i] = palloc(ii->ii_NumIndexAttrs * sizeof(ScanKeyData)); + + /* + * Only return index if we could build a key without NULLs. + */ + if (build_index_scan_key(scan_keys[i], + relinfo->ri_RelationDesc, + relinfo->ri_IndexRelationDescs[i], + tup)) + { + pfree(scan_keys[i]); + scan_keys[i] = NULL; + continue; + } + } +} + +/* + * Setup a ScanKey for a search in the relation 'rel' for a tuple 'key' that + * is setup to match 'rel' (*NOT* idxrel!). + * + * Returns whether any column contains NULLs. + */ +static bool +build_index_scan_key(ScanKey skey, Relation rel, Relation idxrel, TupleData *tup) +{ + int attoff; + Datum indclassDatum; + Datum indkeyDatum; + bool isnull; + oidvector *opclass; + int2vector *indkey; + bool hasnulls = false; + + indclassDatum = SysCacheGetAttr(INDEXRELID, idxrel->rd_indextuple, + Anum_pg_index_indclass, &isnull); + Assert(!isnull); + opclass = (oidvector *) DatumGetPointer(indclassDatum); + + indkeyDatum = SysCacheGetAttr(INDEXRELID, idxrel->rd_indextuple, + Anum_pg_index_indkey, &isnull); + Assert(!isnull); + indkey = (int2vector *) DatumGetPointer(indkeyDatum); + + + for (attoff = 0; attoff < RelationGetNumberOfAttributes(idxrel); attoff++) + { + Oid operator; + Oid opfamily; + RegProcedure regop; + int pkattno = attoff + 1; + int mainattno = indkey->values[attoff]; + Oid atttype = attnumTypeId(rel, mainattno); + Oid optype = get_opclass_input_type(opclass->values[attoff]); + + opfamily = get_opclass_family(opclass->values[attoff]); + + operator = get_opfamily_member(opfamily, optype, + optype, + BTEqualStrategyNumber); + + if (!OidIsValid(operator)) + elog(ERROR, + "could not lookup equality operator for type %u, optype %u in opfamily %u", + atttype, optype, opfamily); + + regop = get_opcode(operator); + + /* FIXME: convert type? */ + ScanKeyInit(&skey[attoff], + pkattno, + BTEqualStrategyNumber, + regop, + tup->values[mainattno - 1]); + + if (tup->isnull[mainattno - 1]) + { + hasnulls = true; + skey[attoff].sk_flags |= SK_ISNULL; + } + } + return hasnulls; +} + +static void +UserTableUpdateIndexes(EState *estate, TupleTableSlot *slot) +{ + /* HOT update does not require index inserts */ + if (HeapTupleIsHeapOnly(slot->tts_tuple)) + return; + + ExecOpenIndices(estate->es_result_relation_info, false); + UserTableUpdateOpenIndexes(estate, slot); + ExecCloseIndices(estate->es_result_relation_info); +} + +static void +UserTableUpdateOpenIndexes(EState *estate, TupleTableSlot *slot) +{ + List *recheckIndexes = NIL; + + /* HOT update does not require index inserts */ + if (HeapTupleIsHeapOnly(slot->tts_tuple)) + return; + + if (estate->es_result_relation_info->ri_NumIndices > 0) + { + recheckIndexes = ExecInsertIndexTuples(slot, + &slot->tts_tuple->t_self, + estate, false, NULL, NIL); + + if (recheckIndexes != NIL) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("bdr doesn't support index rechecks"))); + } + + /* FIXME: recheck the indexes */ + list_free(recheckIndexes); +} + +static EState * +create_rel_estate(Relation rel) +{ + EState *estate; + ResultRelInfo *resultRelInfo; + + estate = CreateExecutorState(); + + resultRelInfo = makeNode(ResultRelInfo); + resultRelInfo->ri_RangeTableIndex = 1; /* dummy */ + resultRelInfo->ri_RelationDesc = rel; + resultRelInfo->ri_TrigInstrument = NULL; + + estate->es_result_relations = resultRelInfo; + estate->es_num_result_relations = 1; + estate->es_result_relation_info = resultRelInfo; + + return estate; +} + +static void +process_remote_begin(StringInfo s) +{ + GlobalTransactionId gtid = pg_getmsgint64(s); + csn_t snapshot = pq_getmsgint64(s); + MMJoinTransaction(gtid, snapshot); + SetCurrentStatementStartTimestamp(); + StartTransactionCommand(); +} + +static void +read_tuple_parts(StringInfo s, Relation rel, TupleData *tup) +{ + TupleDesc desc = RelationGetDescr(rel); + int i; + int rnatts; + char action; + + action = pq_getmsgbyte(s); + + if (action != 'T') + elog(ERROR, "expected TUPLE, got %c", action); + + memset(tup->isnull, 1, sizeof(tup->isnull)); + memset(tup->changed, 1, sizeof(tup->changed)); + + rnatts = pq_getmsgint(s, 2); + + if (desc->natts != rnatts) + elog(ERROR, "tuple natts mismatch, %u vs %u", desc->natts, rnatts); + + /* FIXME: unaligned data accesses */ + + for (i = 0; i < desc->natts; i++) + { + Form_pg_attribute att = desc->attrs[i]; + char kind = pq_getmsgbyte(s); + const char *data; + int len; + + switch (kind) + { + case 'n': /* null */ + /* already marked as null */ + tup->values[i] = 0xdeadbeef; + break; + case 'u': /* unchanged column */ + tup->isnull[i] = true; + tup->changed[i] = false; + tup->values[i] = 0xdeadbeef; /* make bad usage more obvious */ + break; + + case 'b': /* binary format */ + tup->isnull[i] = false; + len = pq_getmsgint(s, 4); /* read length */ + + data = pq_getmsgbytes(s, len); + + /* and data */ + if (att->attbyval) + tup->values[i] = fetch_att(data, true, len); + else + tup->values[i] = PointerGetDatum(data); + break; + case 's': /* send/recv format */ + { + Oid typreceive; + Oid typioparam; + StringInfoData buf; + + tup->isnull[i] = false; + len = pq_getmsgint(s, 4); /* read length */ + + getTypeBinaryInputInfo(att->atttypid, + &typreceive, &typioparam); + + /* create StringInfo pointing into the bigger buffer */ + initStringInfo(&buf); + /* and data */ + buf.data = (char *) pq_getmsgbytes(s, len); + buf.len = len; + tup->values[i] = OidReceiveFunctionCall( + typreceive, &buf, typioparam, att->atttypmod); + + if (buf.len != buf.cursor) + ereport(ERROR, + (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION), + errmsg("incorrect binary data format"))); + break; + } + case 't': /* text format */ + { + Oid typinput; + Oid typioparam; + + tup->isnull[i] = false; + len = pq_getmsgint(s, 4); /* read length */ + + getTypeInputInfo(att->atttypid, &typinput, &typioparam); + /* and data */ + data = (char *) pq_getmsgbytes(s, len); + tup->values[i] = OidInputFunctionCall( + typinput, (char *) data, typioparam, att->atttypmod); + } + break; + default: + elog(ERROR, "unknown column type '%c'", kind); + } + + if (att->attisdropped && !tup->isnull[i]) + elog(ERROR, "data for dropped column"); + } +} + +static Relation +read_rel(StringInfo s, LOCKMODE mode) +{ + int relnamelen; + int nspnamelen; + RangeVar* rv; + Oid relid; + + rv = makeNode(RangeVar); + + nspnamelen = pq_getmsgbyte(s); + rv->schemaname = (char *) pq_getmsgbytes(s, nspnamelen); + + relnamelen = pq_getmsgbyte(s); + rv->relname = (char *) pq_getmsgbytes(s, relnamelen); + + relid = RangeVarGetRelidExtended(rv, mode, false, false, NULL, NULL); + + return heap_open(relid, NoLock); +} + +static void +process_remote_commit(StringInfo s) +{ + CommitTransactionCommand(); +} + +static void +process_remote_insert(StringInfo s, Relation rel) +{ + EState *estate; + TupleData new_tuple; + TupleTableSlot *newslot; + TupleTableSlot *oldslot; + ResultRelInfo *relinfo; + ScanKey *index_keys; + int i; + + estate = create_rel_estate(rel); + newslot = ExecInitExtraTupleSlot(estate); + oldslot = ExecInitExtraTupleSlot(estate); + ExecSetSlotDescriptor(newslot, RelationGetDescr(rel)); + ExecSetSlotDescriptor(oldslot, RelationGetDescr(rel)); + + read_tuple_parts(s, rel, &new_tuple); + { + HeapTuple tup; + tup = heap_form_tuple(RelationGetDescr(rel), + new_tuple.values, new_tuple.isnull); + ExecStoreTuple(tup, newslot, InvalidBuffer, true); + } + + if (rel->rd_rel->relkind != RELKIND_RELATION) + elog(ERROR, "unexpected relkind '%c' rel \"%s\"", + rel->rd_rel->relkind, RelationGetRelationName(rel)); + + /* debug output */ +#ifdef VERBOSE_INSERT + log_tuple("INSERT:%s", RelationGetDescr(rel), newslot->tts_tuple); +#endif + + /* + * Search for conflicting tuples. + */ + ExecOpenIndices(estate->es_result_relation_info, false); + relinfo = estate->es_result_relation_info; + index_keys = palloc0(relinfo->ri_NumIndices * sizeof(ScanKeyData*)); + + build_index_scan_keys(estate, index_keys, &new_tuple); + + /* do a SnapshotDirty search for conflicting tuples */ + for (i = 0; i < relinfo->ri_NumIndices; i++) + { + IndexInfo *ii = relinfo->ri_IndexRelationInfo[i]; + bool found = false; + + /* + * Only unique indexes are of interest here, and we can't deal with + * expression indexes so far. FIXME: predicates should be handled + * better. + * + * NB: Needs to match expression in build_index_scan_key + */ + if (!ii->ii_Unique || ii->ii_Expressions != NIL) + continue; + + if (index_keys[i] == NULL) + continue; + + Assert(ii->ii_Expressions == NIL); + + /* if conflict: wait */ + found = find_pkey_tuple(index_keys[i], + rel, relinfo->ri_IndexRelationDescs[i], + oldslot, true, LockTupleExclusive); + + /* alert if there's more than one conflicting unique key */ + if (found) + { + /* TODO: Report tuple identity in log */ + ereport(ERROR, + (errcode(ERRCODE_UNIQUE_VIOLATION), + errmsg("Unique constraints violated by remotely INSERTed tuple"), + errdetail("Cannot apply transaction because remotely INSERTed tuple conflicts with a local tuple on UNIQUE constraint and/or PRIMARY KEY"))); + } + CHECK_FOR_INTERRUPTS(); + } + + simple_heap_insert(rel, newslot->tts_tuple); + UserTableUpdateOpenIndexes(estate, newslot); + + ExecCloseIndices(estate->es_result_relation_info); + + heap_close(rel, NoLock); + ExecResetTupleTable(estate->es_tupleTable, true); + FreeExecutorState(estate); + + CommandCounterIncrement(); +} + +static void +process_remote_update(StringInfo s, Relation rel) +{ + char action; + EState *estate; + TupleTableSlot *newslot; + TupleTableSlot *oldslot; + bool pkey_sent; + bool found_tuple; + TupleData old_tuple; + TupleData new_tuple; + Oid idxoid; + Relation idxrel; + ScanKeyData skey[INDEX_MAX_KEYS]; + HeapTuple remote_tuple = NULL; + + action = pq_getmsgbyte(s); + + /* old key present, identifying key changed */ + if (action != 'K' && action != 'N') + elog(ERROR, "expected action 'N' or 'K', got %c", + action); + + estate = create_rel_estate(rel); + oldslot = ExecInitExtraTupleSlot(estate); + ExecSetSlotDescriptor(oldslot, RelationGetDescr(rel)); + newslot = ExecInitExtraTupleSlot(estate); + ExecSetSlotDescriptor(newslot, RelationGetDescr(rel)); + + if (action == 'K') + { + pkey_sent = true; + read_tuple_parts(s, rel, &old_tuple); + action = pq_getmsgbyte(s); + } + else + pkey_sent = false; + + /* check for new tuple */ + if (action != 'N') + elog(ERROR, "expected action 'N', got %c", + action); + + if (rel->rd_rel->relkind != RELKIND_RELATION) + elog(ERROR, "unexpected relkind '%c' rel \"%s\"", + rel->rd_rel->relkind, RelationGetRelationName(rel)); + + /* read new tuple */ + read_tuple_parts(s, rel, &new_tuple); + + /* lookup index to build scankey */ + if (rel->rd_indexvalid == 0) + RelationGetIndexList(rel); + idxoid = rel->rd_replidindex; + if (!OidIsValid(idxoid)) + { + elog(ERROR, "could not find primary key for table with oid %u", + RelationGetRelid(rel)); + return; + } + + /* open index, so we can build scan key for row */ + idxrel = index_open(idxoid, RowExclusiveLock); + + Assert(idxrel->rd_index->indisunique); + + /* Use columns from the new tuple if the key didn't change. */ + build_index_scan_key(skey, rel, idxrel, + pkey_sent ? &old_tuple : &new_tuple); + + PushActiveSnapshot(GetTransactionSnapshot()); + + /* look for tuple identified by the (old) primary key */ + found_tuple = find_pkey_tuple(skey, rel, idxrel, oldslot, true, + pkey_sent ? LockTupleExclusive : LockTupleNoKeyExclusive); + + if (found_tuple) + { + remote_tuple = heap_modify_tuple(oldslot->tts_tuple, + RelationGetDescr(rel), + new_tuple.values, + new_tuple.isnull, + new_tuple.changed); + + ExecStoreTuple(remote_tuple, newslot, InvalidBuffer, true); + +#ifdef VERBOSE_UPDATE + { + StringInfoData o; + initStringInfo(&o); + tuple_to_stringinfo(&o, RelationGetDescr(rel), oldslot->tts_tuple); + appendStringInfo(&o, " to"); + tuple_to_stringinfo(&o, RelationGetDescr(rel), remote_tuple); + elog(DEBUG1, "UPDATE:%s", o.data); + resetStringInfo(&o); + } +#endif + + simple_heap_update(rel, &oldslot->tts_tuple->t_self, newslot->tts_tuple); + UserTableUpdateIndexes(estate, newslot); + } + else + { + ereport(ERROR, + (errcode(ERRCODE_NO_DATA_FOUND), + errmsg("Record with specified key can not be located at this node"), + errdetail("Most likely we have DELETE-UPDATE conflict"))); + + } + + PopActiveSnapshot(); + + /* release locks upon commit */ + index_close(idxrel, NoLock); + heap_close(rel, NoLock); + + ExecResetTupleTable(estate->es_tupleTable, true); + FreeExecutorState(estate); + + CommandCounterIncrement(); +} + +static void +process_remote_delete(StringInfo s, Relation rel) +{ + EState *estate; + TupleData oldtup; + TupleTableSlot *oldslot; + Oid idxoid; + Relation idxrel; + ScanKeyData skey[INDEX_MAX_KEYS]; + bool found_old; + + estate = create_rel_estate(rel); + oldslot = ExecInitExtraTupleSlot(estate); + ExecSetSlotDescriptor(oldslot, RelationGetDescr(rel)); + + read_tuple_parts(s, rel, &oldtup); + + /* lookup index to build scankey */ + if (rel->rd_indexvalid == 0) + RelationGetIndexList(rel); + idxoid = rel->rd_replidindex; + if (!OidIsValid(idxoid)) + { + elog(ERROR, "could not find primary key for table with oid %u", + RelationGetRelid(rel)); + return; + } + + /* Now open the primary key index */ + idxrel = index_open(idxoid, RowExclusiveLock); + + if (rel->rd_rel->relkind != RELKIND_RELATION) + elog(ERROR, "unexpected relkind '%c' rel \"%s\"", + rel->rd_rel->relkind, RelationGetRelationName(rel)); + +#ifdef VERBOSE_DELETE + { + HeapTuple tup; + tup = heap_form_tuple(RelationGetDescr(rel), + oldtup.values, oldtup.isnull); + ExecStoreTuple(tup, oldslot, InvalidBuffer, true); + } + log_tuple("DELETE old-key:%s", RelationGetDescr(rel), oldslot->tts_tuple); +#endif + + PushActiveSnapshot(GetTransactionSnapshot()); + + build_index_scan_key(skey, rel, idxrel, &oldtup); + + /* try to find tuple via a (candidate|primary) key */ + found_old = find_pkey_tuple(skey, rel, idxrel, oldslot, true, LockTupleExclusive); + + if (found_old) + { + simple_heap_delete(rel, &oldslot->tts_tuple->t_self); + } + else + { + ereport(ERROR, + (errcode(ERRCODE_NO_DATA_FOUND), + errmsg("Record with specified key can not be located at this node"), + errdetail("Most likely we have DELETE-DELETE conflict"))); + } + + PopActiveSnapshot(); + + index_close(idxrel, NoLock); + heap_close(rel, NoLock); + + ExecResetTupleTable(estate->es_tupleTable, true); + FreeExecutorState(estate); + + CommandCounterIncrement(); +} + +static MemoryContext ApplyContext; + +void MMExecutor(int id, void* work, size_t size) +{ + StringInfoData s; + Relation rel = NULL; + initStringInfo(&s); + s.data = work; + s.len = size; + s.maxlen = -1; + + if (ApplyContext == NULL) { + ApplyContext = AllocSetContextCreate(TopMemoryContext, + "MessageContext", + ALLOCSET_DEFAULT_MINSIZE, + ALLOCSET_DEFAULT_INITSIZE, + ALLOCSET_DEFAULT_MAXSIZE); + } + MemoryContextSwitchTo(ApplyContext); + + PG_TRY(); + { + while (true) { + char action = pq_getmsgbyte(&s); + + switch (action) { + /* BEGIN */ + case 'B': + process_remote_begin(&s); + continue; + /* COMMIT */ + case 'C': + process_remote_commit(&s); + break; + /* INSERT */ + case 'I': + process_remote_insert(&s, rel); + continue; + /* UPDATE */ + case 'U': + process_remote_update(&s, rel); + continue; + /* DELETE */ + case 'D': + process_remote_delete(&s, rel); + continue; + case 'R': + rel = read_rel(&s, RowExclusiveLock); + continue; + default: + elog(ERROR, "unknown action of type %c", action); + } + break; + } + } + PG_CATCH(); + { + FlushErrorState(); + AbortCurrentTransaction(); + } + PG_END_TRY(); + + MemoryContextResetAndDeleteChildren(ApplyContext); +} + diff --git a/pglogical_config.c b/pglogical_config.c new file mode 100644 index 0000000000..cc22700a09 --- /dev/null +++ b/pglogical_config.c @@ -0,0 +1,499 @@ +/*------------------------------------------------------------------------- + * + * pglogical_config.c + * Logical Replication output plugin + * + * Copyright (c) 2012-2015, PostgreSQL Global Development Group + * + * IDENTIFICATION + * pglogical_config.c + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + +#include "pglogical_config.h" +#include "pglogical_output.h" + +#include "catalog/catversion.h" +#include "catalog/namespace.h" + +#include "mb/pg_wchar.h" + +#include "nodes/makefuncs.h" + +#include "utils/builtins.h" +#include "utils/int8.h" +#include "utils/inval.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/rel.h" +#include "utils/relcache.h" +#include "utils/syscache.h" +#include "utils/typcache.h" + +typedef enum PGLogicalOutputParamType +{ + OUTPUT_PARAM_TYPE_BOOL, + OUTPUT_PARAM_TYPE_UINT32, + OUTPUT_PARAM_TYPE_STRING, + OUTPUT_PARAM_TYPE_QUALIFIED_NAME +} PGLogicalOutputParamType; + +/* param parsing */ +static Datum get_param_value(DefElem *elem, bool null_ok, + PGLogicalOutputParamType type); + +static Datum get_param(List *options, const char *name, bool missing_ok, + bool null_ok, PGLogicalOutputParamType type, + bool *found); +static bool parse_param_bool(DefElem *elem); +static uint32 parse_param_uint32(DefElem *elem); + +static void +process_parameters_v1(List *options, PGLogicalOutputData *data); + +enum { + PARAM_UNRECOGNISED, + PARAM_MAX_PROTOCOL_VERSION, + PARAM_MIN_PROTOCOL_VERSION, + PARAM_PROTOCOL_FORMAT, + PARAM_EXPECTED_ENCODING, + PARAM_BINARY_BIGENDIAN, + PARAM_BINARY_SIZEOF_DATUM, + PARAM_BINARY_SIZEOF_INT, + PARAM_BINARY_SIZEOF_LONG, + PARAM_BINARY_FLOAT4BYVAL, + PARAM_BINARY_FLOAT8BYVAL, + PARAM_BINARY_INTEGER_DATETIMES, + PARAM_BINARY_WANT_INTERNAL_BASETYPES, + PARAM_BINARY_WANT_BINARY_BASETYPES, + PARAM_BINARY_BASETYPES_MAJOR_VERSION, + PARAM_PG_VERSION, + PARAM_FORWARD_CHANGESETS, + PARAM_HOOKS_SETUP_FUNCTION, + PARAM_NO_TXINFO +} OutputPluginParamKey; + +typedef struct { + const char * const paramname; + int paramkey; +} OutputPluginParam; + +/* Oh, if only C had switch on strings */ +static OutputPluginParam param_lookup[] = { + {"max_proto_version", PARAM_MAX_PROTOCOL_VERSION}, + {"min_proto_version", PARAM_MIN_PROTOCOL_VERSION}, + {"proto_format", PARAM_PROTOCOL_FORMAT}, + {"expected_encoding", PARAM_EXPECTED_ENCODING}, + {"binary.bigendian", PARAM_BINARY_BIGENDIAN}, + {"binary.sizeof_datum", PARAM_BINARY_SIZEOF_DATUM}, + {"binary.sizeof_int", PARAM_BINARY_SIZEOF_INT}, + {"binary.sizeof_long", PARAM_BINARY_SIZEOF_LONG}, + {"binary.float4_byval", PARAM_BINARY_FLOAT4BYVAL}, + {"binary.float8_byval", PARAM_BINARY_FLOAT8BYVAL}, + {"binary.integer_datetimes", PARAM_BINARY_INTEGER_DATETIMES}, + {"binary.want_internal_basetypes", PARAM_BINARY_WANT_INTERNAL_BASETYPES}, + {"binary.want_binary_basetypes", PARAM_BINARY_WANT_BINARY_BASETYPES}, + {"binary.basetypes_major_version", PARAM_BINARY_BASETYPES_MAJOR_VERSION}, + {"pg_version", PARAM_PG_VERSION}, + {"forward_changesets", PARAM_FORWARD_CHANGESETS}, + {"hooks.setup_function", PARAM_HOOKS_SETUP_FUNCTION}, + {"no_txinfo", PARAM_NO_TXINFO}, + {NULL, PARAM_UNRECOGNISED} +}; + +/* + * Look up a param name to find the enum value for the + * param, or PARAM_UNRECOGNISED if not found. + */ +static int +get_param_key(const char * const param_name) +{ + OutputPluginParam *param = ¶m_lookup[0]; + + do { + if (strcmp(param->paramname, param_name) == 0) + return param->paramkey; + param++; + } while (param->paramname != NULL); + + return PARAM_UNRECOGNISED; +} + + +void +process_parameters_v1(List *options, PGLogicalOutputData *data) +{ + Datum val; + bool found; + ListCell *lc; + + /* + * max_proto_version and min_proto_version are specified + * as required, and must be parsed before anything else. + * + * TODO: We should still parse them as optional and + * delay the ERROR until after the startup reply. + */ + val = get_param(options, "max_proto_version", false, false, + OUTPUT_PARAM_TYPE_UINT32, &found); + data->client_max_proto_version = DatumGetUInt32(val); + + val = get_param(options, "min_proto_version", false, false, + OUTPUT_PARAM_TYPE_UINT32, &found); + data->client_min_proto_version = DatumGetUInt32(val); + + /* Examine all the other params in the v1 message. */ + foreach(lc, options) + { + DefElem *elem = lfirst(lc); + + Assert(elem->arg == NULL || IsA(elem->arg, String)); + + /* Check each param, whether or not we recognise it */ + switch(get_param_key(elem->defname)) + { + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_UINT32); + + case PARAM_BINARY_BIGENDIAN: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_binary_bigendian_set = true; + data->client_binary_bigendian = DatumGetBool(val); + break; + + case PARAM_BINARY_SIZEOF_DATUM: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_UINT32); + data->client_binary_sizeofdatum = DatumGetUInt32(val); + break; + + case PARAM_BINARY_SIZEOF_INT: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_UINT32); + data->client_binary_sizeofint = DatumGetUInt32(val); + break; + + case PARAM_BINARY_SIZEOF_LONG: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_UINT32); + data->client_binary_sizeoflong = DatumGetUInt32(val); + break; + + case PARAM_BINARY_FLOAT4BYVAL: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_binary_float4byval_set = true; + data->client_binary_float4byval = DatumGetBool(val); + break; + + case PARAM_BINARY_FLOAT8BYVAL: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_binary_float4byval_set = true; + data->client_binary_float4byval = DatumGetBool(val); + break; + + case PARAM_BINARY_INTEGER_DATETIMES: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_binary_intdatetimes_set = true; + data->client_binary_intdatetimes = DatumGetBool(val); + break; + + case PARAM_PROTOCOL_FORMAT: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_STRING); + data->client_protocol_format = DatumGetCString(val); + break; + + case PARAM_EXPECTED_ENCODING: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_STRING); + data->client_expected_encoding = DatumGetCString(val); + break; + + case PARAM_PG_VERSION: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_UINT32); + data->client_pg_version = DatumGetUInt32(val); + break; + + case PARAM_FORWARD_CHANGESETS: + /* + * Check to see if the client asked for changeset forwarding + * + * Note that we cannot support this on 9.4. We'll tell the client + * in the startup reply message. + */ + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_forward_changesets_set = true; + data->client_forward_changesets = DatumGetBool(val); + break; + + case PARAM_BINARY_WANT_INTERNAL_BASETYPES: + /* check if we want to use internal data representation */ + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_want_internal_basetypes_set = true; + data->client_want_internal_basetypes = DatumGetBool(val); + break; + + case PARAM_BINARY_WANT_BINARY_BASETYPES: + /* check if we want to use binary data representation */ + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_want_binary_basetypes_set = true; + data->client_want_binary_basetypes = DatumGetBool(val); + break; + + case PARAM_BINARY_BASETYPES_MAJOR_VERSION: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_UINT32); + data->client_binary_basetypes_major_version = DatumGetUInt32(val); + break; + + case PARAM_HOOKS_SETUP_FUNCTION: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_QUALIFIED_NAME); + data->hooks_setup_funcname = (List*) PointerGetDatum(val); + break; + + case PARAM_NO_TXINFO: + val = get_param_value(elem, false, OUTPUT_PARAM_TYPE_BOOL); + data->client_no_txinfo = DatumGetBool(val); + break; + + case PARAM_UNRECOGNISED: + ereport(DEBUG1, + (errmsg("Unrecognised pglogical parameter %s ignored", elem->defname))); + break; + } + } +} + +/* + * Read parameters sent by client at startup and store recognised + * ones in the parameters PGLogicalOutputData. + * + * The PGLogicalOutputData must have all client-surprised parameter fields + * zeroed, such as by memset or palloc0, since values not supplied + * by the client are not set. + */ +int +process_parameters(List *options, PGLogicalOutputData *data) +{ + Datum val; + bool found; + int params_format; + + val = get_param(options, "startup_params_format", false, false, + OUTPUT_PARAM_TYPE_UINT32, &found); + + params_format = DatumGetUInt32(val); + + if (params_format == 1) + { + process_parameters_v1(options, data); + } + + return params_format; +} + +static Datum +get_param_value(DefElem *elem, bool null_ok, PGLogicalOutputParamType type) +{ + /* Check for NULL value */ + if (elem->arg == NULL || strVal(elem->arg) == NULL) + { + if (null_ok) + return (Datum) 0; + else + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("parameter \"%s\" cannot be NULL", elem->defname))); + } + + switch (type) + { + case OUTPUT_PARAM_TYPE_UINT32: + return UInt32GetDatum(parse_param_uint32(elem)); + case OUTPUT_PARAM_TYPE_BOOL: + return BoolGetDatum(parse_param_bool(elem)); + case OUTPUT_PARAM_TYPE_STRING: + return PointerGetDatum(pstrdup(strVal(elem->arg))); + case OUTPUT_PARAM_TYPE_QUALIFIED_NAME: + return PointerGetDatum(textToQualifiedNameList(cstring_to_text(pstrdup(strVal(elem->arg))))); + default: + elog(ERROR, "unknown parameter type %d", type); + } +} + +/* + * Param parsing + * + * This is not exactly fast but since it's only called on replication start + * we'll leave it for now. + */ +static Datum +get_param(List *options, const char *name, bool missing_ok, bool null_ok, + PGLogicalOutputParamType type, bool *found) +{ + ListCell *option; + + *found = false; + + foreach(option, options) + { + DefElem *elem = lfirst(option); + + Assert(elem->arg == NULL || IsA(elem->arg, String)); + + /* Search until matching parameter found */ + if (pg_strcasecmp(name, elem->defname)) + continue; + + *found = true; + + return get_param_value(elem, null_ok, type); + } + + if (!missing_ok) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("missing required parameter \"%s\"", name))); + + return (Datum) 0; +} + +static bool +parse_param_bool(DefElem *elem) +{ + bool res; + + if (!parse_bool(strVal(elem->arg), &res)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("could not parse boolean value \"%s\" for parameter \"%s\"", + strVal(elem->arg), elem->defname))); + + return res; +} + +static uint32 +parse_param_uint32(DefElem *elem) +{ + int64 res; + + if (!scanint8(strVal(elem->arg), true, &res)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("could not parse integer value \"%s\" for parameter \"%s\"", + strVal(elem->arg), elem->defname))); + + if (res > PG_UINT32_MAX || res < 0) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("value \"%s\" out of range for parameter \"%s\"", + strVal(elem->arg), elem->defname))); + + return (uint32) res; +} + +static List* +add_startup_msg_s(List *l, char *key, char *val) +{ + return lappend(l, makeDefElem(key, (Node*)makeString(val))); +} + +static List* +add_startup_msg_i(List *l, char *key, int val) +{ + return lappend(l, makeDefElem(key, (Node*)makeString(psprintf("%d", val)))); +} + +static List* +add_startup_msg_b(List *l, char *key, bool val) +{ + return lappend(l, makeDefElem(key, (Node*)makeString(val ? "t" : "f"))); +} + +/* + * This builds the protocol startup message, which is always the first + * message on the wire after the client sends START_REPLICATION. + * + * It confirms to the client that we could apply requested options, and + * tells the client our capabilities. + * + * Any additional parameters provided by the startup hook are also output + * now. + * + * The output param 'msg' is a null-terminated char* palloc'd in the current + * memory context and the length 'len' of that string that is valid. The caller + * should pfree the result after use. + * + * This is a bit less efficient than direct pq_sendblah calls, but + * separates config handling from the protocol implementation, and + * it's not like startup msg performance matters much. + */ +List * +prepare_startup_message(PGLogicalOutputData *data) +{ + ListCell *lc; + List *l = NIL; + + l = add_startup_msg_s(l, "max_proto_version", "1"); + l = add_startup_msg_s(l, "min_proto_version", "1"); + + /* We don't support understand column types yet */ + l = add_startup_msg_b(l, "coltypes", false); + + /* Info about our Pg host */ + l = add_startup_msg_i(l, "pg_version_num", PG_VERSION_NUM); + l = add_startup_msg_s(l, "pg_version", PG_VERSION); + l = add_startup_msg_i(l, "pg_catversion", CATALOG_VERSION_NO); + + l = add_startup_msg_s(l, "database_encoding", (char*)GetDatabaseEncodingName()); + + l = add_startup_msg_s(l, "encoding", (char*)pg_encoding_to_char(data->field_datum_encoding)); + + l = add_startup_msg_b(l, "forward_changesets", + data->forward_changesets); + l = add_startup_msg_b(l, "forward_changeset_origins", + data->forward_changeset_origins); + + /* binary options enabled */ + l = add_startup_msg_b(l, "binary.internal_basetypes", + data->allow_internal_basetypes); + l = add_startup_msg_b(l, "binary.binary_basetypes", + data->allow_binary_basetypes); + + /* Binary format characteristics of server */ + l = add_startup_msg_i(l, "binary.basetypes_major_version", PG_VERSION_NUM/100); + l = add_startup_msg_i(l, "binary.sizeof_int", sizeof(int)); + l = add_startup_msg_i(l, "binary.sizeof_long", sizeof(long)); + l = add_startup_msg_i(l, "binary.sizeof_datum", sizeof(Datum)); + l = add_startup_msg_i(l, "binary.maxalign", MAXIMUM_ALIGNOF); + l = add_startup_msg_b(l, "binary.bigendian", server_bigendian()); + l = add_startup_msg_b(l, "binary.float4_byval", server_float4_byval()); + l = add_startup_msg_b(l, "binary.float8_byval", server_float8_byval()); + l = add_startup_msg_b(l, "binary.integer_datetimes", server_integer_datetimes()); + /* We don't know how to send in anything except our host's format */ + l = add_startup_msg_i(l, "binary.binary_pg_version", + PG_VERSION_NUM/100); + + l = add_startup_msg_b(l, "no_txinfo", data->client_no_txinfo); + + + /* + * Confirm that we've enabled any requested hook functions. + */ + l = add_startup_msg_b(l, "hooks.startup_hook_enabled", + data->hooks.startup_hook != NULL); + l = add_startup_msg_b(l, "hooks.shutdown_hook_enabled", + data->hooks.shutdown_hook != NULL); + l = add_startup_msg_b(l, "hooks.row_filter_enabled", + data->hooks.row_filter_hook != NULL); + l = add_startup_msg_b(l, "hooks.transaction_filter_enabled", + data->hooks.txn_filter_hook != NULL); + + /* + * Output any extra params supplied by a startup hook by appending + * them verbatim to the params list. + */ + foreach(lc, data->extra_startup_params) + { + DefElem *param = (DefElem*)lfirst(lc); + Assert(IsA(param->arg, String) && strVal(param->arg) != NULL); + l = lappend(l, param); + } + + return l; +} diff --git a/pglogical_config.h b/pglogical_config.h new file mode 100644 index 0000000000..3af3ce8a35 --- /dev/null +++ b/pglogical_config.h @@ -0,0 +1,55 @@ +#ifndef PG_LOGICAL_CONFIG_H +#define PG_LOGICAL_CONFIG_H + +#ifndef PG_VERSION_NUM +#error must be included first +#endif + +inline static bool +server_float4_byval(void) +{ +#ifdef USE_FLOAT4_BYVAL + return true; +#else + return false; +#endif +} + +inline static bool +server_float8_byval(void) +{ +#ifdef USE_FLOAT8_BYVAL + return true; +#else + return false; +#endif +} + +inline static bool +server_integer_datetimes(void) +{ +#ifdef USE_INTEGER_DATETIMES + return true; +#else + return false; +#endif +} + +inline static bool +server_bigendian(void) +{ +#ifdef WORDS_BIGENDIAN + return true; +#else + return false; +#endif +} + +typedef struct List List; +typedef struct PGLogicalOutputData PGLogicalOutputData; + +extern int process_parameters(List *options, PGLogicalOutputData *data); + +extern List * prepare_startup_message(PGLogicalOutputData *data); + +#endif diff --git a/pglogical_hooks.c b/pglogical_hooks.c new file mode 100644 index 0000000000..73e812063f --- /dev/null +++ b/pglogical_hooks.c @@ -0,0 +1,232 @@ +#include "postgres.h" + +#include "access/xact.h" + +#include "catalog/pg_proc.h" +#include "catalog/pg_type.h" + +#include "replication/origin.h" + +#include "parser/parse_func.h" + +#include "utils/acl.h" +#include "utils/lsyscache.h" + +#include "miscadmin.h" + +#include "pglogical_hooks.h" +#include "pglogical_output.h" + +/* + * Returns Oid of the hooks function specified in funcname. + * + * Error is thrown if function doesn't exist or doen't return correct datatype + * or is volatile. + */ +static Oid +get_hooks_function_oid(List *funcname) +{ + Oid funcid; + Oid funcargtypes[1]; + + funcargtypes[0] = INTERNALOID; + + /* find the the function */ + funcid = LookupFuncName(funcname, 1, funcargtypes, false); + + /* Validate that the function returns void */ + if (get_func_rettype(funcid) != VOIDOID) + { + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("function %s must return void", + NameListToString(funcname)))); + } + + if (func_volatile(funcid) == PROVOLATILE_VOLATILE) + { + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("function %s must not be VOLATILE", + NameListToString(funcname)))); + } + + if (pg_proc_aclcheck(funcid, GetUserId(), ACL_EXECUTE) != ACLCHECK_OK) + { + const char * username; +#if PG_VERSION_NUM >= 90500 + username = GetUserNameFromId(GetUserId(), false); +#else + username = GetUserNameFromId(GetUserId()); +#endif + ereport(ERROR, + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + errmsg("current user %s does not have permission to call function %s", + username, NameListToString(funcname)))); + } + + return funcid; +} + +/* + * If a hook setup function was specified in the startup parameters, look it up + * in the catalogs, check permissions, call it, and store the resulting hook + * info struct. + */ +void +load_hooks(PGLogicalOutputData *data) +{ + Oid hooks_func; + MemoryContext old_ctxt; + bool txn_started = false; + + if (!IsTransactionState()) + { + txn_started = true; + StartTransactionCommand(); + } + + if (data->hooks_setup_funcname != NIL) + { + hooks_func = get_hooks_function_oid(data->hooks_setup_funcname); + + old_ctxt = MemoryContextSwitchTo(data->hooks_mctxt); + (void) OidFunctionCall1(hooks_func, PointerGetDatum(&data->hooks)); + MemoryContextSwitchTo(old_ctxt); + + elog(DEBUG3, "pglogical_output: Loaded hooks from function %u. Hooks are: \n" + "\tstartup_hook: %p\n" + "\tshutdown_hook: %p\n" + "\trow_filter_hook: %p\n" + "\ttxn_filter_hook: %p\n" + "\thooks_private_data: %p\n", + hooks_func, + data->hooks.startup_hook, + data->hooks.shutdown_hook, + data->hooks.row_filter_hook, + data->hooks.txn_filter_hook, + data->hooks.hooks_private_data); + } + + if (txn_started) + CommitTransactionCommand(); +} + +void +call_startup_hook(PGLogicalOutputData *data, List *plugin_params) +{ + struct PGLogicalStartupHookArgs args; + MemoryContext old_ctxt; + + if (data->hooks.startup_hook != NULL) + { + bool tx_started = false; + + args.private_data = data->hooks.hooks_private_data; + args.in_params = plugin_params; + args.out_params = NIL; + + elog(DEBUG3, "calling pglogical startup hook"); + + if (!IsTransactionState()) + { + tx_started = true; + StartTransactionCommand(); + } + + old_ctxt = MemoryContextSwitchTo(data->hooks_mctxt); + (void) (*data->hooks.startup_hook)(&args); + MemoryContextSwitchTo(old_ctxt); + + if (tx_started) + CommitTransactionCommand(); + + data->extra_startup_params = args.out_params; + /* The startup hook might change the private data seg */ + data->hooks.hooks_private_data = args.private_data; + + elog(DEBUG3, "called pglogical startup hook"); + } +} + +void +call_shutdown_hook(PGLogicalOutputData *data) +{ + struct PGLogicalShutdownHookArgs args; + MemoryContext old_ctxt; + + if (data->hooks.shutdown_hook != NULL) + { + args.private_data = data->hooks.hooks_private_data; + + elog(DEBUG3, "calling pglogical shutdown hook"); + + old_ctxt = MemoryContextSwitchTo(data->hooks_mctxt); + (void) (*data->hooks.shutdown_hook)(&args); + MemoryContextSwitchTo(old_ctxt); + + data->hooks.hooks_private_data = args.private_data; + + elog(DEBUG3, "called pglogical shutdown hook"); + } +} + +/* + * Decide if the individual change should be filtered out by + * calling a client-provided hook. + */ +bool +call_row_filter_hook(PGLogicalOutputData *data, ReorderBufferTXN *txn, + Relation rel, ReorderBufferChange *change) +{ + struct PGLogicalRowFilterArgs hook_args; + MemoryContext old_ctxt; + bool ret = true; + + if (data->hooks.row_filter_hook != NULL) + { + hook_args.change_type = change->action; + hook_args.private_data = data->hooks.hooks_private_data; + hook_args.changed_rel = rel; + + elog(DEBUG3, "calling pglogical row filter hook"); + + old_ctxt = MemoryContextSwitchTo(data->hooks_mctxt); + ret = (*data->hooks.row_filter_hook)(&hook_args); + MemoryContextSwitchTo(old_ctxt); + + /* Filter hooks shouldn't change the private data ptr */ + Assert(data->hooks.hooks_private_data == hook_args.private_data); + + elog(DEBUG3, "called pglogical row filter hook, returned %d", (int)ret); + } + + return ret; +} + +bool +call_txn_filter_hook(PGLogicalOutputData *data, RepOriginId txn_origin) +{ + struct PGLogicalTxnFilterArgs hook_args; + bool ret = true; + MemoryContext old_ctxt; + + if (data->hooks.txn_filter_hook != NULL) + { + hook_args.private_data = data->hooks.hooks_private_data; + hook_args.origin_id = txn_origin; + + elog(DEBUG3, "calling pglogical txn filter hook"); + + old_ctxt = MemoryContextSwitchTo(data->hooks_mctxt); + ret = (*data->hooks.txn_filter_hook)(&hook_args); + MemoryContextSwitchTo(old_ctxt); + + /* Filter hooks shouldn't change the private data ptr */ + Assert(data->hooks.hooks_private_data == hook_args.private_data); + + elog(DEBUG3, "called pglogical txn filter hook, returned %d", (int)ret); + } + + return ret; +} diff --git a/pglogical_hooks.h b/pglogical_hooks.h new file mode 100644 index 0000000000..df661f335c --- /dev/null +++ b/pglogical_hooks.h @@ -0,0 +1,22 @@ +#ifndef PGLOGICAL_HOOKS_H +#define PGLOGICAL_HOOKS_H + +#include "replication/reorderbuffer.h" + +/* public interface for hooks */ +#include "pglogical_output/hooks.h" + +extern void load_hooks(PGLogicalOutputData *data); + +extern void call_startup_hook(PGLogicalOutputData *data, List *plugin_params); + +extern void call_shutdown_hook(PGLogicalOutputData *data); + +extern bool call_row_filter_hook(PGLogicalOutputData *data, + ReorderBufferTXN *txn, Relation rel, ReorderBufferChange *change); + +extern bool call_txn_filter_hook(PGLogicalOutputData *data, + RepOriginId txn_origin); + + +#endif diff --git a/pglogical_output.c b/pglogical_output.c new file mode 100644 index 0000000000..29de03c628 --- /dev/null +++ b/pglogical_output.c @@ -0,0 +1,535 @@ +/*------------------------------------------------------------------------- + * + * pglogical_output.c + * Logical Replication output plugin + * + * Copyright (c) 2012-2015, PostgreSQL Global Development Group + * + * IDENTIFICATION + * pglogical_output.c + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + +#include "pglogical_config.h" +#include "pglogical_output.h" +#include "pglogical_proto.h" +#include "pglogical_hooks.h" + +#include "access/hash.h" +#include "access/sysattr.h" +#include "access/xact.h" + +#include "catalog/pg_class.h" +#include "catalog/pg_proc.h" +#include "catalog/pg_type.h" + +#include "mb/pg_wchar.h" + +#include "nodes/parsenodes.h" + +#include "parser/parse_func.h" + +#include "replication/output_plugin.h" +#include "replication/logical.h" +#include "replication/origin.h" + +#include "utils/builtins.h" +#include "utils/catcache.h" +#include "utils/guc.h" +#include "utils/int8.h" +#include "utils/inval.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/rel.h" +#include "utils/relcache.h" +#include "utils/syscache.h" +#include "utils/typcache.h" + +extern void _PG_output_plugin_init(OutputPluginCallbacks *cb); + +/* These must be available to pg_dlsym() */ +static void pg_decode_startup(LogicalDecodingContext * ctx, + OutputPluginOptions *opt, bool is_init); +static void pg_decode_shutdown(LogicalDecodingContext * ctx); +static void pg_decode_begin_txn(LogicalDecodingContext *ctx, + ReorderBufferTXN *txn); +static void pg_decode_commit_txn(LogicalDecodingContext *ctx, + ReorderBufferTXN *txn, XLogRecPtr commit_lsn); +static void pg_decode_change(LogicalDecodingContext *ctx, + ReorderBufferTXN *txn, Relation rel, + ReorderBufferChange *change); + +static bool pg_decode_origin_filter(LogicalDecodingContext *ctx, + RepOriginId origin_id); + +static void send_startup_message(LogicalDecodingContext *ctx, + PGLogicalOutputData *data, bool last_message); + +static bool startup_message_sent = false; + +/* specify output plugin callbacks */ +void +_PG_output_plugin_init(OutputPluginCallbacks *cb) +{ + AssertVariableIsOfType(&_PG_output_plugin_init, LogicalOutputPluginInit); + + cb->startup_cb = pg_decode_startup; + cb->begin_cb = pg_decode_begin_txn; + cb->change_cb = pg_decode_change; + cb->commit_cb = pg_decode_commit_txn; + cb->filter_by_origin_cb = pg_decode_origin_filter; + cb->shutdown_cb = pg_decode_shutdown; +} + +static bool +check_binary_compatibility(PGLogicalOutputData *data) +{ + if (data->client_binary_basetypes_major_version != PG_VERSION_NUM / 100) + return false; + + if (data->client_binary_bigendian_set + && data->client_binary_bigendian != server_bigendian()) + { + elog(DEBUG1, "Binary mode rejected: Server and client endian mis-match"); + return false; + } + + if (data->client_binary_sizeofdatum != 0 + && data->client_binary_sizeofdatum != sizeof(Datum)) + { + elog(DEBUG1, "Binary mode rejected: Server and client endian sizeof(Datum) mismatch"); + return false; + } + + if (data->client_binary_sizeofint != 0 + && data->client_binary_sizeofint != sizeof(int)) + { + elog(DEBUG1, "Binary mode rejected: Server and client endian sizeof(int) mismatch"); + return false; + } + + if (data->client_binary_sizeoflong != 0 + && data->client_binary_sizeoflong != sizeof(long)) + { + elog(DEBUG1, "Binary mode rejected: Server and client endian sizeof(long) mismatch"); + return false; + } + + if (data->client_binary_float4byval_set + && data->client_binary_float4byval != server_float4_byval()) + { + elog(DEBUG1, "Binary mode rejected: Server and client endian float4byval mismatch"); + return false; + } + + if (data->client_binary_float8byval_set + && data->client_binary_float8byval != server_float8_byval()) + { + elog(DEBUG1, "Binary mode rejected: Server and client endian float8byval mismatch"); + return false; + } + + if (data->client_binary_intdatetimes_set + && data->client_binary_intdatetimes != server_integer_datetimes()) + { + elog(DEBUG1, "Binary mode rejected: Server and client endian integer datetimes mismatch"); + return false; + } + + return true; +} + +/* initialize this plugin */ +static void +pg_decode_startup(LogicalDecodingContext * ctx, OutputPluginOptions *opt, + bool is_init) +{ + PGLogicalOutputData *data = palloc0(sizeof(PGLogicalOutputData)); + + data->context = AllocSetContextCreate(TopMemoryContext, + "pglogical conversion context", + ALLOCSET_DEFAULT_MINSIZE, + ALLOCSET_DEFAULT_INITSIZE, + ALLOCSET_DEFAULT_MAXSIZE); + data->allow_internal_basetypes = false; + data->allow_binary_basetypes = false; + + + ctx->output_plugin_private = data; + + /* + * This is replication start and not slot initialization. + * + * Parse and validate options passed by the client. + */ + if (!is_init) + { + int params_format; + + /* + * Ideally we'd send the startup message immediately. That way + * it'd arrive before any error we emit if we see incompatible + * options sent by the client here. That way the client could + * possibly adjust its options and reconnect. It'd also make + * sure the client gets the startup message in a timely way if + * the server is idle, since otherwise it could be a while + * before the next callback. + * + * The decoding plugin API doesn't let us write to the stream + * from here, though, so we have to delay the startup message + * until the first change processed on the stream, in a begin + * callback. + * + * If we ERROR there, the startup message is buffered but not + * sent since the callback didn't finish. So we'd have to send + * the startup message, finish the callback and check in the + * next callback if we need to ERROR. + * + * That's a bit much hoop jumping, so for now ERRORs are + * immediate. A way to emit a message from the startup callback + * is really needed to change that. + */ + startup_message_sent = false; + + /* Now parse the rest of the params and ERROR if we see any we don't recognise */ + params_format = process_parameters(ctx->output_plugin_options, data); + + if (params_format != 1) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("client sent startup parameters in format %d but we only support format 1", + params_format))); + + if (data->client_min_proto_version > PG_LOGICAL_PROTO_VERSION_NUM) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("client sent min_proto_version=%d but we only support protocol %d or lower", + data->client_min_proto_version, PG_LOGICAL_PROTO_VERSION_NUM))); + + if (data->client_max_proto_version < PG_LOGICAL_PROTO_MIN_VERSION_NUM) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("client sent max_proto_version=%d but we only support protocol %d or higher", + data->client_max_proto_version, PG_LOGICAL_PROTO_MIN_VERSION_NUM))); + + /* + * Set correct protocol format. + * + * This is the output plugin protocol format, this is different + * from the individual fields binary vs textual format. + */ + if (data->client_protocol_format != NULL + && strcmp(data->client_protocol_format, "json") == 0) + { + data->api = pglogical_init_api(PGLogicalProtoJson); + opt->output_type = OUTPUT_PLUGIN_TEXTUAL_OUTPUT; + } + else if ((data->client_protocol_format != NULL + && strcmp(data->client_protocol_format, "native") == 0) + || data->client_protocol_format == NULL) + { + data->api = pglogical_init_api(PGLogicalProtoNative); + opt->output_type = OUTPUT_PLUGIN_BINARY_OUTPUT; + + if (data->client_no_txinfo) + { + elog(WARNING, "no_txinfo option ignored for protocols other than json"); + data->client_no_txinfo = false; + } + } + else + { + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("client requested protocol %s but only \"json\" or \"native\" are supported", + data->client_protocol_format))); + } + + /* check for encoding match if specific encoding demanded by client */ + if (data->client_expected_encoding != NULL + && strlen(data->client_expected_encoding) != 0) + { + int wanted_encoding = pg_char_to_encoding(data->client_expected_encoding); + + if (wanted_encoding == -1) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("unrecognised encoding name %s passed to expected_encoding", + data->client_expected_encoding))); + + if (opt->output_type == OUTPUT_PLUGIN_TEXTUAL_OUTPUT) + { + /* + * datum encoding must match assigned client_encoding in text + * proto, since everything is subject to client_encoding + * conversion. + */ + if (wanted_encoding != pg_get_client_encoding()) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("expected_encoding must be unset or match client_encoding in text protocols"))); + } + else + { + /* + * currently in the binary protocol we can only emit encoded + * datums in the server encoding. There's no support for encoding + * conversion. + */ + if (wanted_encoding != GetDatabaseEncoding()) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("encoding conversion for binary datum not supported yet"), + errdetail("expected_encoding %s must be unset or match server_encoding %s", + data->client_expected_encoding, GetDatabaseEncodingName()))); + } + + data->field_datum_encoding = wanted_encoding; + } + + /* + * It's obviously not possible to send binary representatio of data + * unless we use the binary output. + */ + if (opt->output_type == OUTPUT_PLUGIN_BINARY_OUTPUT && + data->client_want_internal_basetypes) + { + data->allow_internal_basetypes = + check_binary_compatibility(data); + } + + if (opt->output_type == OUTPUT_PLUGIN_BINARY_OUTPUT && + data->client_want_binary_basetypes && + data->client_binary_basetypes_major_version == PG_VERSION_NUM / 100) + { + data->allow_binary_basetypes = true; + } + + /* + * Will we forward changesets? We have to if we're on 9.4; + * otherwise honour the client's request. + */ + if (PG_VERSION_NUM/100 == 904) + { + /* + * 9.4 unconditionally forwards changesets due to lack of + * replication origins, and it can't ever send origin info + * for the same reason. + */ + data->forward_changesets = true; + data->forward_changeset_origins = false; + + if (data->client_forward_changesets_set + && !data->client_forward_changesets) + { + ereport(DEBUG1, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("Cannot disable changeset forwarding on PostgreSQL 9.4"))); + } + } + else if (data->client_forward_changesets_set + && data->client_forward_changesets) + { + /* Client explicitly asked for forwarding; forward csets and origins */ + data->forward_changesets = true; + data->forward_changeset_origins = true; + } + else + { + /* Default to not forwarding or honour client's request not to fwd */ + data->forward_changesets = false; + data->forward_changeset_origins = false; + } + + if (data->hooks_setup_funcname != NIL) + { + + data->hooks_mctxt = AllocSetContextCreate(ctx->context, + "pglogical_output hooks context", + ALLOCSET_SMALL_MINSIZE, + ALLOCSET_SMALL_INITSIZE, + ALLOCSET_SMALL_MAXSIZE); + + load_hooks(data); + call_startup_hook(data, ctx->output_plugin_options); + } + } +} + +/* + * BEGIN callback + */ +void +pg_decode_begin_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn) +{ + PGLogicalOutputData* data = (PGLogicalOutputData*)ctx->output_plugin_private; + bool send_replication_origin = data->forward_changeset_origins; + + if (!startup_message_sent) + send_startup_message(ctx, data, false /* can't be last message */); + + /* If the record didn't originate locally, send origin info */ + send_replication_origin &= txn->origin_id != InvalidRepOriginId; + + OutputPluginPrepareWrite(ctx, !send_replication_origin); + data->api->write_begin(ctx->out, data, txn); + + if (send_replication_origin) + { + char *origin; + + /* Message boundary */ + OutputPluginWrite(ctx, false); + OutputPluginPrepareWrite(ctx, true); + + /* + * XXX: which behaviour we want here? + * + * Alternatives: + * - don't send origin message if origin name not found + * (that's what we do now) + * - throw error - that will break replication, not good + * - send some special "unknown" origin + */ + if (data->api->write_origin && + replorigin_by_oid(txn->origin_id, true, &origin)) + data->api->write_origin(ctx->out, origin, txn->origin_lsn); + } + + OutputPluginWrite(ctx, true); +} + +/* + * COMMIT callback + */ +void +pg_decode_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, + XLogRecPtr commit_lsn) +{ + PGLogicalOutputData* data = (PGLogicalOutputData*)ctx->output_plugin_private; + + OutputPluginPrepareWrite(ctx, true); + data->api->write_commit(ctx->out, data, txn, commit_lsn); + OutputPluginWrite(ctx, true); +} + +void +pg_decode_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, + Relation relation, ReorderBufferChange *change) +{ + PGLogicalOutputData *data = ctx->output_plugin_private; + MemoryContext old; + + /* First check the table filter */ + if (!call_row_filter_hook(data, txn, relation, change)) + return; + + /* Avoid leaking memory by using and resetting our own context */ + old = MemoryContextSwitchTo(data->context); + + /* TODO: add caching (send only if changed) */ + if (data->api->write_rel) + { + OutputPluginPrepareWrite(ctx, false); + data->api->write_rel(ctx->out, data, relation); + OutputPluginWrite(ctx, false); + } + + /* Send the data */ + switch (change->action) + { + case REORDER_BUFFER_CHANGE_INSERT: + OutputPluginPrepareWrite(ctx, true); + data->api->write_insert(ctx->out, data, relation, + &change->data.tp.newtuple->tuple); + OutputPluginWrite(ctx, true); + break; + case REORDER_BUFFER_CHANGE_UPDATE: + { + HeapTuple oldtuple = change->data.tp.oldtuple ? + &change->data.tp.oldtuple->tuple : NULL; + + OutputPluginPrepareWrite(ctx, true); + data->api->write_update(ctx->out, data, relation, oldtuple, + &change->data.tp.newtuple->tuple); + OutputPluginWrite(ctx, true); + break; + } + case REORDER_BUFFER_CHANGE_DELETE: + if (change->data.tp.oldtuple) + { + OutputPluginPrepareWrite(ctx, true); + data->api->write_delete(ctx->out, data, relation, + &change->data.tp.oldtuple->tuple); + OutputPluginWrite(ctx, true); + } + else + elog(DEBUG1, "didn't send DELETE change because of missing oldtuple"); + break; + default: + Assert(false); + } + + /* Cleanup */ + MemoryContextSwitchTo(old); + MemoryContextReset(data->context); +} + +/* + * Decide if the whole transaction with specific origin should be filtered out. + */ +static bool +pg_decode_origin_filter(LogicalDecodingContext *ctx, + RepOriginId origin_id) +{ + PGLogicalOutputData *data = ctx->output_plugin_private; + + if (!call_txn_filter_hook(data, origin_id)) + return true; + + if (!data->forward_changesets && origin_id != InvalidRepOriginId) + return true; + + return false; +} + +static void +send_startup_message(LogicalDecodingContext *ctx, + PGLogicalOutputData *data, bool last_message) +{ + List *msg; + + Assert(!startup_message_sent); + + msg = prepare_startup_message(data); + + /* + * We could free the extra_startup_params DefElem list here, but it's + * pretty harmless to just ignore it, since it's in the decoding memory + * context anyway, and we don't know if it's safe to free the defnames or + * not. + */ + + OutputPluginPrepareWrite(ctx, last_message); + data->api->write_startup_message(ctx->out, msg); + OutputPluginWrite(ctx, last_message); + + pfree(msg); + + startup_message_sent = true; +} + +static void pg_decode_shutdown(LogicalDecodingContext * ctx) +{ + PGLogicalOutputData* data = (PGLogicalOutputData*)ctx->output_plugin_private; + + call_shutdown_hook(data); + + if (data->hooks_mctxt != NULL) + { + MemoryContextDelete(data->hooks_mctxt); + data->hooks_mctxt = NULL; + } +} diff --git a/pglogical_output.h b/pglogical_output.h new file mode 100644 index 0000000000..a874c40843 --- /dev/null +++ b/pglogical_output.h @@ -0,0 +1,105 @@ +/*------------------------------------------------------------------------- + * + * pglogical_output.h + * pglogical output plugin + * + * Copyright (c) 2015, PostgreSQL Global Development Group + * + * IDENTIFICATION + * pglogical_output.h + * + *------------------------------------------------------------------------- + */ +#ifndef PG_LOGICAL_OUTPUT_H +#define PG_LOGICAL_OUTPUT_H + +#include "nodes/parsenodes.h" + +#include "replication/logical.h" +#include "replication/output_plugin.h" + +#include "storage/lock.h" + +#include "pglogical_output/hooks.h" + +#include "pglogical_proto.h" + +#define PG_LOGICAL_PROTO_VERSION_NUM 1 +#define PG_LOGICAL_PROTO_MIN_VERSION_NUM 1 + +/* + * The name of a hook function. This is used instead of the usual List* + * because can serve as a hash key. + * + * Must be zeroed on allocation if used as a hash key since padding is + * *not* ignored on compare. + */ +typedef struct HookFuncName +{ + /* funcname is more likely to be unique, so goes first */ + char function[NAMEDATALEN]; + char schema[NAMEDATALEN]; +} HookFuncName; + +typedef struct PGLogicalOutputData +{ + MemoryContext context; + + PGLogicalProtoAPI *api; + + /* protocol */ + bool allow_internal_basetypes; + bool allow_binary_basetypes; + bool forward_changesets; + bool forward_changeset_origins; + int field_datum_encoding; + + /* + * client info + * + * Lots of this should move to a separate shorter-lived struct used only + * during parameter reading, since it contains what the client asked for. + * Once we've processed this during startup we don't refer to it again. + */ + uint32 client_pg_version; + uint32 client_max_proto_version; + uint32 client_min_proto_version; + const char *client_expected_encoding; + const char *client_protocol_format; + uint32 client_binary_basetypes_major_version; + bool client_want_internal_basetypes_set; + bool client_want_internal_basetypes; + bool client_want_binary_basetypes_set; + bool client_want_binary_basetypes; + bool client_binary_bigendian_set; + bool client_binary_bigendian; + uint32 client_binary_sizeofdatum; + uint32 client_binary_sizeofint; + uint32 client_binary_sizeoflong; + bool client_binary_float4byval_set; + bool client_binary_float4byval; + bool client_binary_float8byval_set; + bool client_binary_float8byval; + bool client_binary_intdatetimes_set; + bool client_binary_intdatetimes; + bool client_forward_changesets_set; + bool client_forward_changesets; + bool client_no_txinfo; + + /* hooks */ + List *hooks_setup_funcname; + struct PGLogicalHooks hooks; + MemoryContext hooks_mctxt; + + /* DefElem list populated by startup hook */ + List *extra_startup_params; +} PGLogicalOutputData; + +typedef struct PGLogicalTupleData +{ + Datum values[MaxTupleAttributeNumber]; + bool nulls[MaxTupleAttributeNumber]; + bool changed[MaxTupleAttributeNumber]; +} PGLogicalTupleData; + +#endif /* PG_LOGICAL_OUTPUT_H */ diff --git a/pglogical_output/README b/pglogical_output/README new file mode 100644 index 0000000000..5480e5c179 --- /dev/null +++ b/pglogical_output/README @@ -0,0 +1,7 @@ +/* + * This directory contains the public header files for the pglogical_output + * extension. It is installed into the PostgreSQL source tree when the extension + * is installed. + * + * These headers are not part of the PostgreSQL project its self. + */ diff --git a/pglogical_output/hooks.h b/pglogical_output/hooks.h new file mode 100644 index 0000000000..b20fa72410 --- /dev/null +++ b/pglogical_output/hooks.h @@ -0,0 +1,72 @@ +#ifndef PGLOGICAL_OUTPUT_HOOKS_H +#define PGLOGICAL_OUTPUT_HOOKS_H + +#include "access/xlogdefs.h" +#include "nodes/pg_list.h" +#include "utils/rel.h" +#include "utils/palloc.h" +#include "replication/reorderbuffer.h" + +struct PGLogicalOutputData; +typedef struct PGLogicalOutputData PGLogicalOutputData; + +/* + * This header is to be included by extensions that implement pglogical output + * plugin callback hooks for transaction origin and row filtering, etc. It is + * installed as "pglogical_output/hooks.h" + * + * See the README.md and the example in examples/hooks/ for details on hooks. + */ + + +struct PGLogicalStartupHookArgs +{ + void *private_data; + List *in_params; + List *out_params; +}; + +typedef void (*pglogical_startup_hook_fn)(struct PGLogicalStartupHookArgs *args); + + +struct PGLogicalTxnFilterArgs +{ + void *private_data; + RepOriginId origin_id; +}; + +typedef bool (*pglogical_txn_filter_hook_fn)(struct PGLogicalTxnFilterArgs *args); + + +struct PGLogicalRowFilterArgs +{ + void *private_data; + Relation changed_rel; + enum ReorderBufferChangeType change_type; +}; + +typedef bool (*pglogical_row_filter_hook_fn)(struct PGLogicalRowFilterArgs *args); + + +struct PGLogicalShutdownHookArgs +{ + void *private_data; +}; + +typedef void (*pglogical_shutdown_hook_fn)(struct PGLogicalShutdownHookArgs *args); + +/* + * This struct is passed to the pglogical_get_hooks_fn as the first argument, + * typed 'internal', and is unwrapped with `DatumGetPointer`. + */ +struct PGLogicalHooks +{ + pglogical_startup_hook_fn startup_hook; + pglogical_shutdown_hook_fn shutdown_hook; + pglogical_txn_filter_hook_fn txn_filter_hook; + pglogical_row_filter_hook_fn row_filter_hook; + void *hooks_private_data; +}; + + +#endif /* PGLOGICAL_OUTPUT_HOOKS_H */ diff --git a/pglogical_proto.c b/pglogical_proto.c new file mode 100644 index 0000000000..75fca5e6d7 --- /dev/null +++ b/pglogical_proto.c @@ -0,0 +1,384 @@ +#include "postgres.h" + +#include "miscadmin.h" + +#include "pglogical_output.h" + +#include "access/sysattr.h" +#include "access/tuptoaster.h" +#include "access/xact.h" + +#include "catalog/catversion.h" +#include "catalog/index.h" + +#include "catalog/namespace.h" +#include "catalog/pg_class.h" +#include "catalog/pg_database.h" +#include "catalog/pg_namespace.h" +#include "catalog/pg_type.h" + +#include "commands/dbcommands.h" + +#include "executor/spi.h" + +#include "libpq/pqformat.h" + +#include "mb/pg_wchar.h" + +#include "utils/builtins.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/rel.h" +#include "utils/syscache.h" +#include "utils/timestamp.h" +#include "utils/typcache.h" + +#include "multimaster.h" + +typedef struct PGLogicalProtoMM +{ + PGLogicalProtoAPI api; + bool isLocal; +} PGLogicalProtoMM; + +static void pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel); + +static void pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, + ReorderBufferTXN *txn); +static void pglogical_write_commit(StringInfo out,PGLogicalOutputData *data, + ReorderBufferTXN *txn, XLogRecPtr commit_lsn); + +static void pglogical_write_insert(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple newtuple); +static void pglogical_write_update(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple oldtuple, + HeapTuple newtuple); +static void pglogical_write_delete(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple oldtuple); + +static void pglogical_write_tuple(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple tuple); +static char decide_datum_transfer(Form_pg_attribute att, + Form_pg_type typclass, + bool allow_internal_basetypes, + bool allow_binary_basetypes); + +/* + * Write relation description to the output stream. + */ +static void +pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel) +{ + PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; + if (!mm->isLocal) { + const char *nspname; + uint8 nspnamelen; + const char *relname; + uint8 relnamelen; + + pq_sendbyte(out, 'R'); /* sending RELATION */ + + nspname = get_namespace_name(rel->rd_rel->relnamespace); + if (nspname == NULL) + elog(ERROR, "cache lookup failed for namespace %u", + rel->rd_rel->relnamespace); + nspnamelen = strlen(nspname) + 1; + + relname = NameStr(rel->rd_rel->relname); + relnamelen = strlen(relname) + 1; + + pq_sendbyte(out, nspnamelen); /* schema name length */ + pq_sendbytes(out, nspname, nspnamelen); + + pq_sendbyte(out, relnamelen); /* table name length */ + pq_sendbytes(out, relname, relnamelen); + } +} + +/* + * Write BEGIN to the output stream. + */ +static void +pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, + ReorderBufferTXN *txn) +{ + PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; + if (MMIsLocalTransaction(txn->xid)) { + mm->isLocal = true; + } else { + mm->isLocal = false; + pq_sendbyte(out, 'B'); /* BEGIN */ + pq_sendint64(out, MMTransactionSnapshot(txn->xid)); + } +} + +/* + * Write COMMIT to the output stream. + */ +static void +pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, + ReorderBufferTXN *txn, XLogRecPtr commit_lsn) +{ + PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; + if (!mm->isLocal) { + pq_sendbyte(out, 'C'); /* sending COMMIT */ + pq_sendint64(out, MyProcPid, txn->xid); + } +} + +/* + * Write INSERT to the output stream. + */ +static void +pglogical_write_insert(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple newtuple) +{ + PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; + if (!mm->isLocal) { + pq_sendbyte(out, 'I'); /* action INSERT */ + pglogical_write_tuple(out, data, rel, newtuple); + } +} + +/* + * Write UPDATE to the output stream. + */ +static void +pglogical_write_update(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple oldtuple, HeapTuple newtuple) +{ + PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; + if (!mm->isLocal) { + pq_sendbyte(out, 'U'); /* action UPDATE */ + /* FIXME support whole tuple (O tuple type) */ + if (oldtuple != NULL) + { + pq_sendbyte(out, 'K'); /* old key follows */ + pglogical_write_tuple(out, data, rel, oldtuple); + } + + pq_sendbyte(out, 'N'); /* new tuple follows */ + pglogical_write_tuple(out, data, rel, newtuple); + } +} +/* + * Write DELETE to the output stream. + */ +static void +pglogical_write_delete(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple oldtuple) +{ + PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; + if (!mm->isLocal) { + pq_sendbyte(out, 'D'); /* action DELETE */ + pglogical_write_tuple(out, data, rel, oldtuple); + } +} + +/* + * Most of the brains for startup message creation lives in + * pglogical_config.c, so this presently just sends the set of key/value pairs. + */ +static void +write_startup_message(StringInfo out, List *msg) +{ +} + +/* + * Write a tuple to the outputstream, in the most efficient format possible. + */ +static void +pglogical_write_tuple(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple tuple) +{ + TupleDesc desc; + Datum values[MaxTupleAttributeNumber]; + bool isnull[MaxTupleAttributeNumber]; + int i; + uint16 nliveatts = 0; + + desc = RelationGetDescr(rel); + + pq_sendbyte(out, 'T'); /* sending TUPLE */ + + for (i = 0; i < desc->natts; i++) + { + if (desc->attrs[i]->attisdropped) + continue; + nliveatts++; + } + pq_sendint(out, nliveatts, 2); + + /* try to allocate enough memory from the get go */ + enlargeStringInfo(out, tuple->t_len + + nliveatts * (1 + 4)); + + /* + * XXX: should this prove to be a relevant bottleneck, it might be + * interesting to inline heap_deform_tuple() here, we don't actually need + * the information in the form we get from it. + */ + heap_deform_tuple(tuple, desc, values, isnull); + + for (i = 0; i < desc->natts; i++) + { + HeapTuple typtup; + Form_pg_type typclass; + Form_pg_attribute att = desc->attrs[i]; + char transfer_type; + + /* skip dropped columns */ + if (att->attisdropped) + continue; + + if (isnull[i]) + { + pq_sendbyte(out, 'n'); /* null column */ + continue; + } + else if (att->attlen == -1 && VARATT_IS_EXTERNAL_ONDISK(values[i])) + { + pq_sendbyte(out, 'u'); /* unchanged toast column */ + continue; + } + + typtup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(att->atttypid)); + if (!HeapTupleIsValid(typtup)) + elog(ERROR, "cache lookup failed for type %u", att->atttypid); + typclass = (Form_pg_type) GETSTRUCT(typtup); + + transfer_type = decide_datum_transfer(att, typclass, + data->allow_internal_basetypes, + data->allow_binary_basetypes); + pq_sendbyte(out, transfer_type); + switch (transfer_type) + { + case 'b': /* internal-format binary data follows */ + + /* pass by value */ + if (att->attbyval) + { + pq_sendint(out, att->attlen, 4); /* length */ + + enlargeStringInfo(out, att->attlen); + store_att_byval(out->data + out->len, values[i], + att->attlen); + out->len += att->attlen; + out->data[out->len] = '\0'; + } + /* fixed length non-varlena pass-by-reference type */ + else if (att->attlen > 0) + { + pq_sendint(out, att->attlen, 4); /* length */ + + appendBinaryStringInfo(out, DatumGetPointer(values[i]), + att->attlen); + } + /* varlena type */ + else if (att->attlen == -1) + { + char *data = DatumGetPointer(values[i]); + + /* send indirect datums inline */ + if (VARATT_IS_EXTERNAL_INDIRECT(values[i])) + { + struct varatt_indirect redirect; + VARATT_EXTERNAL_GET_POINTER(redirect, data); + data = (char *) redirect.pointer; + } + + Assert(!VARATT_IS_EXTERNAL(data)); + + pq_sendint(out, VARSIZE_ANY(data), 4); /* length */ + + appendBinaryStringInfo(out, data, VARSIZE_ANY(data)); + } + else + elog(ERROR, "unsupported tuple type"); + + break; + + case 's': /* binary send/recv data follows */ + { + bytea *outputbytes; + int len; + + outputbytes = OidSendFunctionCall(typclass->typsend, + values[i]); + + len = VARSIZE(outputbytes) - VARHDRSZ; + pq_sendint(out, len, 4); /* length */ + pq_sendbytes(out, VARDATA(outputbytes), len); /* data */ + pfree(outputbytes); + } + break; + + default: + { + char *outputstr; + int len; + + outputstr = OidOutputFunctionCall(typclass->typoutput, + values[i]); + len = strlen(outputstr) + 1; + pq_sendint(out, len, 4); /* length */ + appendBinaryStringInfo(out, outputstr, len); /* data */ + pfree(outputstr); + } + } + + ReleaseSysCache(typtup); + } +} + +/* + * Make the executive decision about which protocol to use. + */ +static char +decide_datum_transfer(Form_pg_attribute att, Form_pg_type typclass, + bool allow_internal_basetypes, + bool allow_binary_basetypes) +{ + /* + * Use the binary protocol, if allowed, for builtin & plain datatypes. + */ + if (allow_internal_basetypes && + typclass->typtype == 'b' && + att->atttypid < FirstNormalObjectId && + typclass->typelem == InvalidOid) + { + return 'b'; + } + /* + * Use send/recv, if allowed, if the type is plain or builtin. + * + * XXX: we can't use send/recv for array or composite types for now due to + * the embedded oids. + */ + else if (allow_binary_basetypes && + OidIsValid(typclass->typreceive) && + (att->atttypid < FirstNormalObjectId || typclass->typtype != 'c') && + (att->atttypid < FirstNormalObjectId || typclass->typelem == InvalidOid)) + { + return 's'; + } + + return 't'; +} + + +PGLogicalProtoAPI * +pglogical_init_api(PGLogicalProtoType typ) +{ + PGLogicalProtoMM* pmm = palloc0(sizeof(PGLogicalProtoMM)); + PGLogicalProtoAPI* res = &pmm->api; + pmm->isLocal = false; + res->write_rel = pglogical_write_rel; + res->write_begin = pglogical_write_begin; + res->write_commit = pglogical_write_commit; + res->write_insert = pglogical_write_insert; + res->write_update = pglogical_write_update; + res->write_delete = pglogical_write_delete; + res->write_startup_message = write_startup_message; + return res; +} diff --git a/pglogical_proto.h b/pglogical_proto.h new file mode 100644 index 0000000000..b8c419d27e --- /dev/null +++ b/pglogical_proto.h @@ -0,0 +1,57 @@ +/*------------------------------------------------------------------------- + * + * pglogical_proto.h + * pglogical protocol + * + * Copyright (c) 2015, PostgreSQL Global Development Group + * + * IDENTIFICATION + * pglogical_proto.h + * + *------------------------------------------------------------------------- + */ +#ifndef PG_LOGICAL_PROTO_H +#define PG_LOGICAL_PROTO_H + +typedef void (*pglogical_write_rel_fn)(StringInfo out, PGLogicalOutputData *data, Relation rel); + +typedef void (*pglogical_write_begin_fn)(StringInfo out, PGLogicalOutputData *data, + ReorderBufferTXN *txn); +typedef void (*pglogical_write_commit_fn)(StringInfo out, PGLogicalOutputData *data, + ReorderBufferTXN *txn, XLogRecPtr commit_lsn); + +typedef void (*pglogical_write_origin_fn)(StringInfo out, const char *origin, + XLogRecPtr origin_lsn); + +typedef void (*pglogical_write_insert_fn)(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple newtuple); +typedef void (*pglogical_write_update_fn)(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple oldtuple, + HeapTuple newtuple); +typedef void (*pglogical_write_delete_fn)(StringInfo out, PGLogicalOutputData *data, + Relation rel, HeapTuple oldtuple); + +typedef void (*write_startup_message_fn)(StringInfo out, List *msg); + +typedef struct PGLogicalProtoAPI +{ + pglogical_write_rel_fn write_rel; + pglogical_write_begin_fn write_begin; + pglogical_write_commit_fn write_commit; + pglogical_write_origin_fn write_origin; + pglogical_write_insert_fn write_insert; + pglogical_write_update_fn write_update; + pglogical_write_delete_fn write_delete; + write_startup_message_fn write_startup_message; +} PGLogicalProtoAPI; + + +typedef enum PGLogicalProtoType +{ + PGLogicalProtoNative, + PGLogicalProtoJson +} PGLogicalProtoType; + +extern PGLogicalProtoAPI *pglogical_init_api(PGLogicalProtoType typ); + +#endif /* PG_LOGICAL_PROTO_H */ diff --git a/pglogical_receiver.c b/pglogical_receiver.c new file mode 100644 index 0000000000..a2b777d7f0 --- /dev/null +++ b/pglogical_receiver.c @@ -0,0 +1,598 @@ +/*------------------------------------------------------------------------- + * + * receiver_raw.c + * Receive and apply logical changes generated by decoder_raw. This + * creates some basics for a multi-master cluster using vanilla + * PostgreSQL without modifying its code. + * + * Copyright (c) 1996-2015, PostgreSQL Global Development Group + * + * IDENTIFICATION + * receiver_raw/receiver_raw.c + * + *------------------------------------------------------------------------- + */ + +/* Some general headers for custom bgworker facility */ +#include +#include "postgres.h" +#include "fmgr.h" +#include "libpq-fe.h" +#include "pqexpbuffer.h" +#include "access/xact.h" +#include "access/transam.h" +#include "lib/stringinfo.h" +#include "pgstat.h" +#include "postmaster/bgworker.h" +#include "storage/ipc.h" +#include "storage/latch.h" +#include "storage/proc.h" +#include "utils/guc.h" +#include "utils/snapmgr.h" +#include "executor/spi.h" + +#include "multimaster.h" + +/* Allow load of this module in shared libs */ + +typedef struct ReceiverArgs { + char* receiver_conn_string; + char receiver_slot[16]; +} ReceiverArgs; + +#define ERRCODE_DUPLICATE_OBJECT_STR "42710" + +/* Signal handling */ +static volatile sig_atomic_t got_sigterm = false; +static volatile sig_atomic_t got_sighup = false; + +/* GUC variables */ +static int receiver_idle_time = 0; +static bool receiver_sync_mode = false; + +/* Worker name */ +static char *worker_name = "multimaster"; +char worker_proc[16]; + +/* Lastly written positions */ +static XLogRecPtr output_written_lsn = InvalidXLogRecPtr; +static XLogRecPtr output_fsync_lsn = InvalidXLogRecPtr; +static XLogRecPtr output_applied_lsn = InvalidXLogRecPtr; + +/* Stream functions */ +static void fe_sendint64(int64 i, char *buf); +static int64 fe_recvint64(char *buf); + +static void +receiver_raw_sigterm(SIGNAL_ARGS) +{ + int save_errno = errno; + got_sigterm = true; + if (MyProc) + SetLatch(&MyProc->procLatch); + errno = save_errno; +} + +static void +receiver_raw_sighup(SIGNAL_ARGS) +{ + int save_errno = errno; + got_sighup = true; + if (MyProc) + SetLatch(&MyProc->procLatch); + errno = save_errno; +} + +/* + * Send a Standby Status Update message to server. + */ +static bool +sendFeedback(PGconn *conn, int64 now) +{ + char replybuf[1 + 8 + 8 + 8 + 8 + 1]; + int len = 0; + + replybuf[len] = 'r'; + len += 1; + fe_sendint64(output_written_lsn, &replybuf[len]); /* write */ + len += 8; + fe_sendint64(output_fsync_lsn, &replybuf[len]); /* flush */ + len += 8; + fe_sendint64(output_applied_lsn, &replybuf[len]); /* apply */ + len += 8; + fe_sendint64(now, &replybuf[len]); /* sendTime */ + len += 8; + + /* No reply requested from server */ + replybuf[len] = 0; + len += 1; + + if (PQputCopyData(conn, replybuf, len) <= 0 || PQflush(conn)) + { + ereport(LOG, (errmsg("%s: could not send feedback packet: %s", + worker_proc, PQerrorMessage(conn)))); + return false; + } + + return true; +} + +/* + * Converts an int64 to network byte order. + */ +static void +fe_sendint64(int64 i, char *buf) +{ + uint32 n32; + + /* High order half first, since we're doing MSB-first */ + n32 = (uint32) (i >> 32); + n32 = htonl(n32); + memcpy(&buf[0], &n32, 4); + + /* Now the low order half */ + n32 = (uint32) i; + n32 = htonl(n32); + memcpy(&buf[4], &n32, 4); +} + +/* + * Converts an int64 from network byte order to native format. + */ +static int64 +fe_recvint64(char *buf) +{ + int64 result; + uint32 h32; + uint32 l32; + + memcpy(&h32, buf, 4); + memcpy(&l32, buf + 4, 4); + h32 = ntohl(h32); + l32 = ntohl(l32); + + result = h32; + result <<= 32; + result |= l32; + + return result; +} + +static int64 +feGetCurrentTimestamp(void) +{ + int64 result; + struct timeval tp; + + gettimeofday(&tp, NULL); + + result = (int64) tp.tv_sec - + ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY); + + result = (result * USECS_PER_SEC) + tp.tv_usec; + + return result; +} + +static void +feTimestampDifference(int64 start_time, int64 stop_time, + long *secs, int *microsecs) +{ + int64 diff = stop_time - start_time; + + if (diff <= 0) + { + *secs = 0; + *microsecs = 0; + } + else + { + *secs = (long) (diff / USECS_PER_SEC); + *microsecs = (int) (diff % USECS_PER_SEC); + } +} + +static void +pglogical_receiver_main(Datum main_arg) +{ + ReceiverArgs* args = (ReceiverArgs*)main_arg; + /* Variables for replication connection */ + PQExpBuffer query; + PGconn *conn; + PGresult *res; + bool insideTrans = false; + ByteBuffer buf; + + /* Register functions for SIGTERM/SIGHUP management */ + pqsignal(SIGHUP, receiver_raw_sighup); + pqsignal(SIGTERM, receiver_raw_sigterm); + + sprintf(worker_proc, "mm_recv_%d", getpid()); + + /* We're now ready to receive signals */ + BackgroundWorkerUnblockSignals(); + + /* Connect to a database */ + BackgroundWorkerInitializeConnection(MMDatabaseName, NULL); + + /* Establish connection to remote server */ + conn = PQconnectdb(args->receiver_conn_string); + if (PQstatus(conn) != CONNECTION_OK) + { + PQfinish(conn); + ereport(ERROR, (errmsg("%s: Could not establish connection to remote server", + worker_proc))); + proc_exit(1); + } + + query = createPQExpBuffer(); + + appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"", args->receiver_slot, worker_name); + res = PQexec(conn, query->data); + if (PQresultStatus(res) != PGRES_TUPLES_OK) + { + const char *sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE); + if (!sqlstate || strcmp(sqlstate, ERRCODE_DUPLICATE_OBJECT_STR) != 0) + { + PQclear(res); + ereport(ERROR, (errmsg("%s: Could not create logical slot", + worker_proc))); + proc_exit(1); + } + } + PQclear(res); + resetPQExpBuffer(query); + + /* Start logical replication at specified position */ + appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL 0/0 (\"startup_params_format\" '1', \"max_proto_version\" '1', \"min_proto_version\" '1')", + args->receiver_slot); + res = PQexec(conn, query->data); + if (PQresultStatus(res) != PGRES_COPY_BOTH) + { + PQclear(res); + ereport(LOG, (errmsg("%s: Could not start logical replication", + worker_proc))); + proc_exit(1); + } + PQclear(res); + resetPQExpBuffer(query); + + MMReceiverStarted(); + ByteBufferAlloc(&buf); + + while (!got_sigterm) + { + int rc, hdr_len; + /* Buffer for COPY data */ + char *copybuf = NULL; + /* Wait necessary amount of time */ + rc = WaitLatch(&MyProc->procLatch, + WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + receiver_idle_time * 1L); + ResetLatch(&MyProc->procLatch); + /* Process signals */ + if (got_sighup) + { + /* Process config file */ + ProcessConfigFile(PGC_SIGHUP); + got_sighup = false; + ereport(LOG, (errmsg("%s: processed SIGHUP", worker_proc))); + } + + if (got_sigterm) + { + /* Simply exit */ + ereport(LOG, (errmsg("%s: processed SIGTERM", worker_proc))); + proc_exit(0); + } + + /* Emergency bailout if postmaster has died */ + if (rc & WL_POSTMASTER_DEATH) + proc_exit(1); + + /* Some cleanup */ + if (copybuf != NULL) + { + PQfreemem(copybuf); + copybuf = NULL; + } + + /* + * Receive data. + */ + while (true) + { + XLogRecPtr walEnd; + char* stmt; + + rc = PQgetCopyData(conn, ©buf, 1); + if (rc <= 0) { + break; + } + + /* + * Check message received from server: + * - 'k', keepalive message + * - 'w', check for streaming header + */ + if (copybuf[0] == 'k') + { + int pos; + bool replyRequested; + + /* + * Parse the keepalive message, enclosed in the CopyData message. + * We just check if the server requested a reply, and ignore the + * rest. + */ + pos = 1; /* skip msgtype 'k' */ + + /* + * In this message is the latest WAL position that server has + * considered as sent to this receiver. + */ + walEnd = fe_recvint64(©buf[pos]); + pos += 8; /* read walEnd */ + pos += 8; /* skip sendTime */ + if (rc < pos + 1) + { + ereport(LOG, (errmsg("%s: streaming header too small: %d", + worker_proc, rc))); + proc_exit(1); + } + replyRequested = copybuf[pos]; + + /* Update written position */ + output_written_lsn = Max(walEnd, output_written_lsn); + output_fsync_lsn = output_written_lsn; + output_applied_lsn = output_written_lsn; + + /* + * If the server requested an immediate reply, send one. + * If sync mode is sent reply in all cases to ensure that + * server knows how far replay has been done. + */ + if (replyRequested || receiver_sync_mode) + { + int64 now = feGetCurrentTimestamp(); + + /* Leave is feedback is not sent properly */ + if (!sendFeedback(conn, now)) + proc_exit(1); + } + continue; + } + else if (copybuf[0] != 'w') + { + ereport(LOG, (errmsg("%s: Incorrect streaming header", + worker_proc))); + proc_exit(1); + } + + /* Now fetch the data */ + hdr_len = 1; /* msgtype 'w' */ + fe_recvint64(©buf[hdr_len]); + hdr_len += 8; /* dataStart */ + walEnd = fe_recvint64(©buf[hdr_len]); + hdr_len += 8; /* WALEnd */ + hdr_len += 8; /* sendTime */ + + /*ereport(LOG, (errmsg("%s: receive message %c length %d", worker_proc, copybuf[hdr_len], rc - hdr_len)));*/ + + Assert(rc >= hdr_len); + + if (rc > hdr_len) + { + stmt = copybuf + hdr_len; + +#ifdef USE_PGLOGICAL_OUTPUT + ByteBufferAppend(&buf, stmt, rc - hdr_len); + if (stmt[0] == 'C') /* commit */ + { + MMExecute(buf.data, buf.used); + ByteBufferReset(&buf); + } +#else + if (strncmp(stmt, "BEGIN ", 6) == 0) { + TransactionId xid; + int rc = sscanf(stmt + 6, "%u", &xid); + Assert(rc == 1); + ByteBufferAppendInt32(&buf, xid); + Assert(!insideTrans); + insideTrans = true; + } else if (strncmp(stmt, "COMMIT;", 7) == 0) { + Assert(insideTrans); + Assert(buf.used > 4); + buf.data[buf.used-1] = '\0'; /* replace last ';' with '\0' to make string zero terminated */ + MMExecute(buf.data, buf.used); + ByteBufferReset(&buf); + insideTrans = false; + } else { + Assert(insideTrans); + ByteBufferAppend(&buf, stmt, rc - hdr_len/*strlen(stmt)*/); + } +#endif + } + /* Update written position */ + output_written_lsn = Max(walEnd, output_written_lsn); + output_fsync_lsn = output_written_lsn; + output_applied_lsn = output_written_lsn; + } + + /* No data, move to next loop */ + if (rc == 0) + { + /* + * In async mode, and no data available. We block on reading but + * not more than the specified timeout, so that we can send a + * response back to the client. + */ + int r; + fd_set input_mask; + int64 message_target = 0; + int64 fsync_target = 0; + struct timeval timeout; + struct timeval *timeoutptr = NULL; + int64 targettime; + long secs; + int usecs; + int64 now; + + FD_ZERO(&input_mask); + FD_SET(PQsocket(conn), &input_mask); + + /* Now compute when to wakeup. */ + targettime = message_target; + + if (fsync_target > 0 && fsync_target < targettime) + targettime = fsync_target; + now = feGetCurrentTimestamp(); + feTimestampDifference(now, + targettime, + &secs, + &usecs); + if (secs <= 0) + timeout.tv_sec = 1; /* Always sleep at least 1 sec */ + else + timeout.tv_sec = secs; + timeout.tv_usec = usecs; + timeoutptr = &timeout; + + r = select(PQsocket(conn) + 1, &input_mask, NULL, NULL, timeoutptr); + if (r == 0 || (r < 0 && errno == EINTR)) + { + /* + * Got a timeout or signal. Continue the loop and either + * deliver a status packet to the server or just go back into + * blocking. + */ + continue; + } + else if (r < 0) + { + ereport(LOG, (errmsg("%s: Incorrect status received... Leaving.", + worker_proc))); + proc_exit(1); + } + + /* Else there is actually data on the socket */ + if (PQconsumeInput(conn) == 0) + { + ereport(LOG, (errmsg("%s: Data remaining on the socket... Leaving.", + worker_proc))); + proc_exit(1); + } + continue; + } + + /* End of copy stream */ + if (rc == -1) + { + ereport(LOG, (errmsg("%s: COPY Stream has abruptly ended...", + worker_proc))); + break; + } + + /* Failure when reading copy stream, leave */ + if (rc == -2) + { + ereport(LOG, (errmsg("%s: Failure while receiving changes...", + worker_proc))); + proc_exit(1); + } + } + + ByteBufferFree(&buf); + /* No problems, so clean exit */ + proc_exit(0); +} + + +int MMStartReceivers(char* conns, int node_id) +{ + int i = 0; + BackgroundWorker worker; + char* conn_str = conns; + char* conn_str_end = conn_str + strlen(conn_str); + MemSet(&worker, 0, sizeof(BackgroundWorker)); + worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; + worker.bgw_start_time = BgWorkerStart_ConsistentState; + worker.bgw_main = pglogical_receiver_main; + worker.bgw_restart_time = 10; /* Wait 10 seconds for restart before crash */ + + while (conn_str < conn_str_end) { + char* p = strchr(conn_str, ','); + if (p == NULL) { + p = conn_str_end; + } + if (++i != node_id) { + ReceiverArgs* ctx = (ReceiverArgs*)malloc(sizeof(ReceiverArgs)); + if (MMDatabaseName == NULL) { + char* dbname = strstr(conn_str, "dbname="); + char* eon; + int len; + Assert(dbname != NULL); + dbname += 7; + eon = strchr(dbname, ' '); + len = eon - dbname; + MMDatabaseName = (char*)malloc(len + 1); + memcpy(MMDatabaseName, dbname, len); + MMDatabaseName[len] = '\0'; + } + ctx->receiver_conn_string = psprintf("replication=database %.*s", (int)(p - conn_str), conn_str); + sprintf(ctx->receiver_slot, "mm_slot_%d", node_id); + + /* Worker parameter and registration */ + snprintf(worker.bgw_name, BGW_MAXLEN, "mm_worker_%d_%d", node_id, i); + + worker.bgw_main_arg = (Datum)ctx; + RegisterBackgroundWorker(&worker); + } + conn_str = p + 1; + } + + return i; +} + +#ifndef USE_PGLOGICAL_OUTPUT +void MMExecutor(int id, void* work, size_t size) +{ + TransactionId xid = *(TransactionId*)work; + char* stmts = (char*)work + 4; + bool finished = false; + + MMJoinTransaction(xid); + + SetCurrentStatementStartTimestamp(); + StartTransactionCommand(); + SPI_connect(); + PushActiveSnapshot(GetTransactionSnapshot()); + + PG_TRY(); + { + int rc = SPI_execute(stmts, false, 0); + SPI_finish(); + PopActiveSnapshot(); + finished = true; + if (rc != SPI_OK_INSERT && rc != SPI_OK_UPDATE && rc != SPI_OK_DELETE) { + ereport(LOG, (errmsg("Executor %d: failed to apply transaction %u", + id, xid))); + AbortCurrentTransaction(); + } else { + CommitTransactionCommand(); + } + } + PG_CATCH(); + { + FlushErrorState(); + if (!finished) { + SPI_finish(); + if (ActiveSnapshotSet()) { + PopActiveSnapshot(); + } + } + AbortCurrentTransaction(); + } + PG_END_TRY(); +} +#endif diff --git a/tests/daemons.go b/tests/daemons.go new file mode 100644 index 0000000000..6fe977bd9f --- /dev/null +++ b/tests/daemons.go @@ -0,0 +1,259 @@ +package main + +import ( + "log" + "fmt" + "os/exec" + "io" + "bufio" + "sync" + "flag" + "os" + "strconv" + "strings" + "time" +) + +func read_to_channel(r io.Reader, c chan string, wg *sync.WaitGroup) { + defer wg.Done() + scanner := bufio.NewScanner(r) + for scanner.Scan() { + c <- scanner.Text() + } + if err := scanner.Err(); err != nil { + log.Fatal(err) + } +} + +func mux_readers_into_channel(a io.Reader, b io.Reader, c chan string) { + var wg sync.WaitGroup + wg.Add(2) + go read_to_channel(a, c, &wg) + go read_to_channel(b, c, &wg) + wg.Wait() + close(c) +} + +func cmd_to_channel(argv []string, name string, out chan string) { + var cmd exec.Cmd + cmd.Path = argv[0] + cmd.Args = argv + log.Printf("starting '%s'\n", name) + + stdout, err := cmd.StdoutPipe() + if err != nil { + log.Println(err) + } + + stderr, err := cmd.StderrPipe() + if err != nil { + log.Println(err) + } + + if err := cmd.Start(); err != nil { + log.Fatal(err) + } + + mux_readers_into_channel(stdout, stderr, out) + cmd.Wait() + log.Printf("'%s' finished\n", name) +} + +const ( + DtmHost = "127.0.0.1" + DtmPort = 5431 + PgPort = 5432 +) + +func arbiter(bin string, datadir string, servers []string, id int, wg *sync.WaitGroup) { + argv := []string{ + bin, + "-d", datadir, + "-i", strconv.Itoa(id), + } + for _, server := range servers { + argv = append(argv, "-r", server) + } + log.Println(argv) + + name := "arbiter " + datadir + c := make(chan string) + + go cmd_to_channel(argv, name, c) + + for s := range c { + log.Printf("[%s] %s\n", name, s) + } + + wg.Done() +} + +func appendfile(filename string, lines ...string) { + f, err := os.OpenFile(filename, os.O_APPEND | os.O_WRONLY, 0600) + if err != nil { + log.Fatal(err) + } + + defer f.Close() + + for _, l := range lines { + if _, err = f.WriteString(l + "\n"); err != nil { + log.Fatal(err) + } + } +} + +func initdb(bin string, datadir string) { + if err := os.RemoveAll(datadir); err != nil { + log.Fatal(err) + } + + argv := []string{bin, datadir} + name := "initdb " + datadir + c := make(chan string) + + go cmd_to_channel(argv, name, c) + + for s := range c { + log.Printf("[%s] %s\n", name, s) + } + + appendfile( + datadir + "/pg_hba.conf", + "local replication all trust", + "host replication all 127.0.0.1/32 trust", + "host replication all ::1/128 trust", + ) +} + +func initarbiter(arbiterdir string) { + if err := os.RemoveAll(arbiterdir); err != nil { + log.Fatal(err) + } + if err := os.MkdirAll(arbiterdir, os.ModeDir | 0777); err != nil { + log.Fatal(err) + } +} + +func postgres(bin string, datadir string, postgresi []string, arbiters []string, port int, nodeid int, wg *sync.WaitGroup) { + argv := []string{ + bin, + "-D", datadir, + "-p", strconv.Itoa(port), + "-c", "multimaster.buffer_size=65536", + "-c", "multimaster.conn_strings=" + strings.Join(postgresi, ","), + "-c", "multimaster.node_id=" + strconv.Itoa(nodeid + 1), + "-c", "multimaster.arbiters=" + strings.Join(arbiters, ","), + "-c", "multimaster.workers=8", + "-c", "multimaster.queue_size=1073741824", + "-c", "wal_level=logical", + "-c", "wal_sender_timeout=0", + "-c", "max_wal_senders=10", + "-c", "max_worker_processes=100", + "-c", "max_replication_slots=10", + "-c", "autovacuum=off", + "-c", "fsync=off", + "-c", "synchronous_commit=on", + "-c", "max_connections=200", + "-c", "shared_preload_libraries=multimaster", + } + name := "postgres " + datadir + c := make(chan string) + + go cmd_to_channel(argv, name, c) + + for s := range c { + log.Printf("[%s] %s\n", name, s) + } + + wg.Done() +} + +func check_bin(bin *map[string]string) { + for k, v := range *bin { + path, err := exec.LookPath(v) + if err != nil { + log.Fatalf("'%s' executable not found", k) + } else { + log.Printf("'%s' executable is '%s'", k, path) + } + } +} + +func get_prefix(srcroot string) string { + makefile, err := os.Open(srcroot + "/src/Makefile.global") + if err != nil { + return "." + } + + scanner := bufio.NewScanner(makefile) + for scanner.Scan() { + s := scanner.Text() + if strings.HasPrefix(s, "prefix := ") { + return strings.TrimPrefix(s, "prefix := ") + } + } + return "." +} + +var doInitDb bool = false +func init() { + flag.BoolVar(&doInitDb, "i", false, "perform initdb") + flag.Parse() +} + +func main() { + srcroot := "../../.." + prefix := get_prefix(srcroot) + + bin := map[string]string{ + "arbiter": srcroot + "/contrib/arbiter/bin/arbiter", + "initdb": prefix + "/bin/initdb", + "postgres": prefix + "/bin/postgres", + } + + datadirs := []string{"/tmp/data0", "/tmp/data1", "/tmp/data2"} + //arbiterdirs := []string{"/tmp/arbiter0", "/tmp/arbiter1", "/tmp/arbiter2"} + arbiterdirs := []string{"/tmp/arbiter0"} + + check_bin(&bin); + + if doInitDb { + for _, datadir := range datadirs { + initdb(bin["initdb"], datadir) + } + for _, arbiterdir := range arbiterdirs { + initarbiter(arbiterdir) + } + } + + var wg sync.WaitGroup + + var arbiters []string + for i := range arbiterdirs { + arbiters = append(arbiters, DtmHost + ":" + strconv.Itoa(DtmPort - i)) + } + for i, dir := range arbiterdirs { + wg.Add(1) + go arbiter(bin["arbiter"], dir, arbiters, i, &wg) + } + + time.Sleep(3 * time.Second) + + var postgresi []string + for i := range datadirs { + postgresi = append( + postgresi, + fmt.Sprintf("dbname=postgres host=127.0.0.1 port=%d sslmode=disable", PgPort + i), + ) + } + for i, dir := range datadirs { + wg.Add(1) + go postgres(bin["postgres"], dir, postgresi, arbiters, PgPort + i, i, &wg) + } + + wg.Wait() + + log.Println("done.") +} + diff --git a/tests/deploy_layouts/cluster.yml b/tests/deploy_layouts/cluster.yml new file mode 100644 index 0000000000..1088615b51 --- /dev/null +++ b/tests/deploy_layouts/cluster.yml @@ -0,0 +1,131 @@ +--- + +- hosts: nodes[0] + + roles: + - role: postgres + pg_port: 15432 + pg_repo: https://github.com/postgrespro/postgres_cluster.git + pg_version_tag: master + pg_destroy_and_init: true + + tasks: + - name: build sockhub + shell: "make clean && make -j 4" + args: + chdir: "~/pg_cluster/src/contrib/arbiter/sockhub" + + - name: build dtm + shell: "make clean && make -j 4" + args: + chdir: "~/pg_cluster/src/contrib/arbiter" + # when: dtm_sources.changed + + - name: kill arbiter + shell: kill -9 `cat ~/pg_cluster/dtm_data/arbiter.pid` || true + + - name: ensure datadir for dtm exists + shell: "rm -rf ~/pg_cluster/dtm_data && mkdir ~/pg_cluster/dtm_data" + + - name: start dtm + shell: > + nohup ~/pg_cluster/src/contrib/arbiter/bin/arbiter + -d ~/pg_cluster/dtm_data -r 0.0.0.0:5431 -i 0 -l ~/pg_cluster/dtm_data/log & + + - name: wait until dtm is available + wait_for: port=5431 delay=1 + + +- hosts: nodes[1]:nodes[2]:nodes[3] + # accelerate: true + + roles: + - role: postgres + pg_port: 15432 + pg_repo: https://github.com/postgrespro/postgres_cluster.git + pg_version_tag: master + pg_destroy_and_init: true + pg_datadir: "/mnt/pgtmpfs/data_{{pg_port}}" + pg_config_role: + - line: "multimaster.buffer_size = 65536" + + tasks: + - name: generate connstrings + set_fact: + connstr: "host={{item}} user={{ansible_ssh_user}} port=15432 dbname=postgres sslmode=disable" + with_items: + groups['nodes'] | reverse | batch(nnodes | d(3) | int) | first + register: connstrs + + - name: make a list + set_fact: + connections: "{{ connstrs.results | map(attribute='ansible_facts.connstr') | join(', ') }}" + + - name: build sockhub + shell: "make clean && make -j 4" + args: + chdir: "{{pg_src}}/contrib/arbiter/sockhub" + + - name: build multimaster + shell: "make clean && make -j {{makejobs}} install" + args: + chdir: "{{pg_src}}/contrib/multimaster" + + - name: enable dtm extension on datanodes + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + line: "{{item}}" + state: present + with_items: + - "wal_level = logical" + - "max_wal_senders = 10" + - "wal_sender_timeout = 0" + - "max_replication_slots = 10" + - "max_worker_processes = 100" + - "shared_preload_libraries = 'multimaster'" + - "multimaster.arbiters = '{{groups['nodes'][0]}}:5431'" + - "multimaster.conn_strings = '{{connections}}'" + - "multimaster.node_id = {{ node_id }}" + - "multimaster.queue_size = 1073741824" + - "multimaster.workers = 32" + + - name: restart postgrespro + command: "{{pg_dst}}/bin/pg_ctl restart -w -D {{pg_datadir}} -l {{pg_datadir}}/pg.log" + environment: + LD_LIBRARY_PATH: "{{pg_dst}}/lib/" + + +- hosts: clients + + tasks: + - name: copy transfers source + copy: src=../{{item}} dest=~/{{item}} mode=0755 + with_items: + - "dtmbench.cpp" + + - name: clone pqxx + git: repo=https://github.com/Ambrosys/pqxx.git + dest=~/pg_cluster/pqxx + accept_hostkey=yes + update=no + force=yes + register: pqxx + + # - name: ensure dirs + # shell: "mkdir -p /home/{{ansible_ssh_user}}/pg_cluster/install/lib/" + + - name: build pqxx + shell: "./configure --prefix=/home/{{ansible_ssh_user}}/pg_cluster/install/ --enable-shared && make -j 6 && make install" + args: + chdir: "~/pg_cluster/pqxx" + environment: + PATH: "/home/{{ansible_ssh_user}}/pg_cluster/install/bin/:{{ansible_env.PATH}}" + when: pqxx.changed + + - name: compile dtmbench + shell: "g++ -g -Wall -O2 -o dtmbench dtmbench.cpp -lpqxx -lpq -pthread -L/home/{{ansible_ssh_user}}/pg_cluster/install/lib/ -I/home/{{ansible_ssh_user}}/pg_cluster/install/include/" + + - name: install dtmbench + shell: "mv dtmbench ~/pg_cluster/install/bin/dtmbench" + + diff --git a/tests/deploy_layouts/cluster_pg_shard.yml b/tests/deploy_layouts/cluster_pg_shard.yml new file mode 100644 index 0000000000..8f406d5b1e --- /dev/null +++ b/tests/deploy_layouts/cluster_pg_shard.yml @@ -0,0 +1,32 @@ +--- + +- hosts: nodes[0] + roles: + - role: postgrespro + deploy_dtm: true + +- hosts: nodes, !master + roles: + - role: postgrespro + pg_src: ./postgrespro_pgshard + pg_version: xtm_pgshard + pg_port: 25432 + deploy_postgres: true + pg_dtm_enable: true + pg_dtm_host: "{{ groups['nodes'][0] }}" + +- hosts: master + roles: + - role: postgrespro + pg_src: ./postgrespro_pgshard + pg_version: xtm_pgshard + pg_port: 25432 + deploy_postgres: true + pg_dtm_enable: true + pg_dtm_host: "{{ groups['nodes'][0] }}" + deploy_pg_shard: true + +# - hosts: clients +# roles: +# - role: postgrespro + diff --git a/tests/deploy_layouts/roles/postgres/tasks/main.yml b/tests/deploy_layouts/roles/postgres/tasks/main.yml new file mode 100644 index 0000000000..219461d7ef --- /dev/null +++ b/tests/deploy_layouts/roles/postgres/tasks/main.yml @@ -0,0 +1,117 @@ +--- + +- name: ensure dependencies (Debian) + apt: pkg={{item}} state=installed + with_items: + - git + - automake + - libtool + - build-essential + - bison + - flex + - libreadline-dev + when: ansible_os_family == "Debian" + sudo: yes + +- name: ensure dependencies (RedHat) + yum: name="@Development tools" state=present + when: (pg_copydist is undefined) and ansible_os_family == "RedHat" + sudo: yes + +- name: ensure dependencies (RedHat) + yum: name={{item}} state=installed + with_items: + - git + - automake + - libtool + - bison + - flex + - readline-devel + when: (pg_copydist is undefined) and ansible_os_family == "RedHat" + sudo: yes + +- name: increase semaphores + shell: sysctl kernel.sem='1000 128000 128 512' + sudo: yes + +- name: increase open files + shell: "echo '{{ansible_ssh_user}} soft nofile 65535' > /etc/security/limits.d/cluster.conf" + args: + creates: "/etc/security/limits.d/cluster.conf" + sudo: yes + +############################################################################# + +- name: stop postgres if it was running + shell: "pkill -9 postgres || true" + +- name: clone postgres sources + git: repo={{pg_repo}} + dest={{pg_src}} + version={{pg_version_tag}} + depth=1 + accept_hostkey=True + key_file={{pg_repo_key}} + register: pg_sources + when: pg_copydist is undefined + +- name: force rebuild on changed sources + command: "rm -f {{pg_dst}}/bin/postgres" + when: (pg_copydist is undefined) and pg_sources.changed + +- name: build and install + shell: ./configure --prefix={{pg_dst}} --enable-debug --without-zlib && make clean && make -j {{makejobs}} && make install + args: + chdir: "{{pg_src}}" + # creates: "{{pg_dst}}/bin/postgres" + # when: pg_copydist is undefined + +############################################################################# + +# - stat: path={{pg_datadir}}/postmaster.pid +# register: pg_pidfile + +# - name: stop postgres if it was running +# shell: "kill -9 `head -n 1 {{pg_datadir}}/postmaster.pid` || true" +# when: pg_pidfile.stat.exists + +- name: remove datadirs on datanodes + command: "rm -rf {{pg_datadir}}" + when: pg_destroy_and_init + +- name: create datadirs on datanodes + command: "{{pg_dst}}/bin/initdb {{pg_datadir}}" + environment: + LD_LIBRARY_PATH: "{{pg_dst}}/lib/" + args: + creates: "{{pg_datadir}}" + +- name: configure postgres on datanodes + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + line: "{{item.line}}" + state: present + with_items: "{{pg_config}}" + +- name: configure postgres on datanodes -- 2 + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + line: "{{item.line}}" + state: present + with_items: "{{pg_config_role}}" + +- name: enable blind trust on datanodes + lineinfile: + dest: "{{pg_datadir}}/pg_hba.conf" + line: "{{item}}" + state: present + with_items: + - "host all all 0.0.0.0/0 trust" + - "host replication all 0.0.0.0/0 trust" + - "local replication all trust" + +- name: start postgrespro + shell: "{{pg_dst}}/bin/pg_ctl start -w -D {{pg_datadir}} -l {{pg_datadir}}/pg.log" + environment: + LD_LIBRARY_PATH: "{{pg_dst}}/lib/" + diff --git a/tests/deploy_layouts/roles/postgres/vars/main.yml b/tests/deploy_layouts/roles/postgres/vars/main.yml new file mode 100644 index 0000000000..e23758f507 --- /dev/null +++ b/tests/deploy_layouts/roles/postgres/vars/main.yml @@ -0,0 +1,27 @@ +# vim: ts=2 sts=2 sw=2 expandtab +--- +makejobs: 4 + +pg_repo: git://git.postgresql.org/git/postgresql.git +pg_repo_key: None +pg_version_tag: master + +pg_destroy_and_init: false + +pg_port: 5432 +pg_config: + - line: "shared_buffers = 3GB" + - line: "wal_keep_segments = 128" + - line: "fsync = off" + - line: "autovacuum = off" + - line: "listen_addresses = '*'" + - line: "max_connections = 2048" + - line: "max_prepared_transactions = 4000" + - line: "port = {{pg_port}}" +pg_config_role: + - line: "#pg_config_role" + +pg_prefix: "{{ansible_env.HOME}}/pg_cluster" +pg_src: "{{pg_prefix}}/src" +pg_dst: "{{pg_prefix}}/install" +pg_datadir: "{{pg_prefix}}/data_{{pg_port}}" diff --git a/tests/deploy_layouts/roles/postgrespro/tasks/dtm.yml b/tests/deploy_layouts/roles/postgrespro/tasks/dtm.yml new file mode 100644 index 0000000000..20651ecaa5 --- /dev/null +++ b/tests/deploy_layouts/roles/postgrespro/tasks/dtm.yml @@ -0,0 +1,43 @@ +--- + +# - name: ensure we have checked out libuv-1.7.5 +# git: repo=https://github.com/libuv/libuv.git +# dest={{libuv.src}} +# version={{libuv.version}} +# update=no + +# - name: build libuv +# shell: ./autogen.sh && ./configure --disable-shared --prefix={{libuv.dst}} && make && make install +# args: +# chdir: "{{libuv.src}}" +# creates: "{{libuv.dst}}/lib/libuv.a" + +- name: configure postgrespro to build dtmd + shell: ./configure --prefix={{pg_dst}} --without-zlib + args: + chdir: "{{pg_src}}" + creates: "{{pg_dst}}/src/Makefile.global" + +- name: compile dtmd + shell: "make clean && make" + args: + chdir: "{{pg_src}}/contrib/pg_dtm/dtmd" + creates: "{{pg_src}}/contrib/pg_dtm/dtmd/bin/dtmd" + +- name: install dtmd + command: cp "{{pg_src}}/contrib/pg_dtm/dtmd/bin/dtmd" "{{dtmd.dst}}" + args: + creates: "{{dtmd.dst}}" + +- name: ensure datadir for dtm exists + file: dest={{dtmd.datadir}} state=directory + +# FIXME: use dtmd'd pid file +- name: kill dtmd + shell: killall -q dtmd || true + +- name: start dtm + shell: nohup {{dtmd.dst}} -d {{dtmd.datadir}} -a 0.0.0.0 -p {{dtmd.port}} > {{dtmd.log}} & + +- name: wait until dtm is available + wait_for: port=5431 delay=1 diff --git a/tests/deploy_layouts/roles/postgrespro/tasks/main.yml b/tests/deploy_layouts/roles/postgrespro/tasks/main.yml new file mode 100644 index 0000000000..59a5559a25 --- /dev/null +++ b/tests/deploy_layouts/roles/postgrespro/tasks/main.yml @@ -0,0 +1,58 @@ +--- + +- name: ensure dependencies (Debian) + apt: pkg={{item}} state=installed + with_items: + - git + - automake + - libtool + - build-essential + - bison + - flex + - libreadline-dev + when: ansible_os_family == "Debian" + sudo: yes + +- name: ensure dependencies (RedHat) + yum: name="@Development tools" state=present + when: ansible_os_family == "RedHat" + sudo: yes + +- name: ensure dependencies (RedHat) + yum: name={{item}} state=installed + with_items: + - git + - automake + - libtool + - bison + - flex + - readline-devel + when: ansible_os_family == "RedHat" + sudo: yes + +- name: setup the private key for postgrespro git access + copy: dest=.ssh/ppg-deploy src=ppg-deploy.key mode=0600 + +- name: ensure we have checked out postgrespro (xtm) + git: repo=git@gitlab.postgrespro.ru:pgpro-dev/postgrespro.git + dest={{pg_src}} + version={{pg_version}} + force=yes + update=yes + key_file=.ssh/ppg-deploy + accept_hostkey=yes + depth=1 + register: pg_sources + +- name: remove binaries if sources have changed + file: dest={{item}} state=absent + with_items: + - "{{pg_dst}}" + - "{{dtmd.dst}}" + when: pg_sources.changed + +- include: postgres.yml + when: deploy_postgres + +- include: dtm.yml + when: deploy_dtm diff --git a/tests/deploy_layouts/roles/postgrespro/tasks/pg_shard.yml b/tests/deploy_layouts/roles/postgrespro/tasks/pg_shard.yml new file mode 100644 index 0000000000..a62b0b2f9c --- /dev/null +++ b/tests/deploy_layouts/roles/postgrespro/tasks/pg_shard.yml @@ -0,0 +1,50 @@ +- name: checkout pg_shard + # git: repo=https://github.com/citusdata/pg_shard.git + git: repo=git@gitlab.postgrespro.ru:s.kelvich/pg_shard.git + dest=./pg_shard + version=transaction_manager_integration + force=yes + update=yes + key_file=.ssh/ppg-deploy + accept_hostkey=yes + depth=1 + register: pg_shard_source + +- name: build pg_shard extension + shell: "PATH={{pg_dst}}/bin:$PATH make clean && PATH={{pg_dst}}/bin:$PATH make && PATH={{pg_dst}}/bin:$PATH make install" + args: + chdir: "~/pg_shard" + creates: "{{pg_dst}}/lib/pg_shard.so" + +- name: enable pg_shard extension in postgresql.conf with dtm + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + regexp: "{{item.regexp}}" + line: "{{item.line}}" + state: present + with_items: + - line: "shared_preload_libraries = 'pg_dtm, pg_shard'" + regexp: "^shared_preload_libraries " + - line: "pg_shard.all_modifications_commutative = 1" + regexp: "^pg_shard.all_modifications_commutative " + - line: "pg_shard.use_dtm_transactions = 1" + regexp: "^pg_shard.use_dtm_transactions " + when: pg_dtm_enable + +- name: enable pg_shard extension in postgresql.conf without dtm + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + regexp: "{{item.regexp}}" + line: "{{item.line}}" + state: present + with_items: + - line: "shared_preload_libraries = 'pg_shard'" + regexp: "^shared_preload_libraries " + - line: "pg_shard.all_modifications_commutative = 1" + regexp: "^pg_shard.all_modifications_commutative " + when: not pg_dtm_enable + +- name: create pg_worker_list.conf + shell: echo "{{item}} 25432" >> {{pg_datadir}}/pg_worker_list.conf + with_items: groups['nodes'] + diff --git a/tests/deploy_layouts/roles/postgrespro/tasks/postgres.yml b/tests/deploy_layouts/roles/postgrespro/tasks/postgres.yml new file mode 100644 index 0000000000..b6b6b8866f --- /dev/null +++ b/tests/deploy_layouts/roles/postgrespro/tasks/postgres.yml @@ -0,0 +1,77 @@ +- name: build postgrespro + shell: ./configure --prefix={{pg_dst}} --without-zlib && make clean && make -j {{makejobs}} && make install + args: + chdir: "{{pg_src}}" + creates: "{{pg_dst}}/bin/postgres" + +- name: remove dtm.so + shell: rm -f {{pg_dst}}/lib/pg_dtm.so + +- name: build dtm extension + shell: make clean && make && make install + args: + chdir: "{{pg_src}}/contrib/pg_dtm" + creates: "{{pg_dst}}/lib/pg_dtm.so" + +# - name: build ts-dtm extension +# shell: make clean && make && make install +# args: +# chdir: "{{pg_src}}/contrib/pg_tsdtm" +# creates: "{{pg_dst}}/lib/pg_dtm.so" + +- stat: path={{pg_datadir}}/postmaster.pid + register: pg_pidfile + +- name: stop postgres if it was running + command: "{{pg_dst}}/bin/pg_ctl stop -w -D {{pg_datadir}}" + when: pg_pidfile.stat.exists + +- name: remove datadirs on datanodes + command: "rm -rf {{pg_datadir}}" + +- name: create datadirs on datanodes + command: "{{pg_dst}}/bin/initdb {{pg_datadir}}" + args: + creates: "{{pg_datadir}}" + +- name: configure postgres on datanodes + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + line: "{{item.line}}" + state: present + with_items: "{{pg_config}}" + +- name: configure2 postgres on datanodes + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + line: "{{item.line}}" + state: present + with_items: "{{pg_config_role}}" + +- name: enable dtm extension on datanodes + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + regexp: "{{item.regexp}}" + line: "{{item.line}}" + state: present + with_items: + - line: "dtm.host = '{{pg_dtm_host}}'" + regexp: "^dtm.host " + - line: "shared_preload_libraries = 'pg_dtm'" + regexp: "^shared_preload_libraries " + when: pg_dtm_enable + +- name: enable blind trust on datanodes + lineinfile: + dest: "{{pg_datadir}}/pg_hba.conf" + line: "host all all 0.0.0.0/0 trust" + +- include: pg_shard.yml + when: deploy_pg_shard + +- name: start postgrespro + command: "{{pg_dst}}/bin/pg_ctl start -w -D {{pg_datadir}} -l {{pg_datadir}}/pg.log" + +- name: create pg_dtm extension + command: "{{pg_dst}}/bin/psql -p {{pg_port}} postgres -c 'create extension pg_dtm;'" + diff --git a/tests/deploy_layouts/roles/postgrespro/vars/main.yml b/tests/deploy_layouts/roles/postgrespro/vars/main.yml new file mode 100644 index 0000000000..aa8ebe180b --- /dev/null +++ b/tests/deploy_layouts/roles/postgrespro/vars/main.yml @@ -0,0 +1,38 @@ +# vim: ts=2 sts=2 sw=2 expandtab +--- +makejobs: 4 + +deploy_postgres: false +deploy_dtm: false +deploy_pg_shard: false + +pg_version: xtm +pg_port: 5432 +pg_dtm_enable: false +pg_dtm_host: "127.0.0.1" +pg_config: + - line: "shared_buffers = 3GB" + - line: "wal_keep_segments = 128" + - line: "fsync = off" + - line: "autovacuum = off" + - line: "listen_addresses = '*'" + - line: "max_connections = 2048" + - line: "max_prepared_transactions = 400" + - line: "port = {{pg_port}}" +pg_config_role: + - line: "#pg_config_role" +pg_src: ./postgrespro +pg_dst: /tmp/postgrespro-build +pg_datadir: ./postgrespro-data + +libuv: + version: v1.7.5 + src: ./libuv + dst: /tmp/libuv-build + +dtmd: + port: 5431 + dst: ./dtmd + datadir: ./dtmd-data + log: ./dtmd.log + diff --git a/tests/deploy_layouts/single.yml b/tests/deploy_layouts/single.yml new file mode 100644 index 0000000000..53302cbbe1 --- /dev/null +++ b/tests/deploy_layouts/single.yml @@ -0,0 +1,20 @@ +--- +- hosts: nodes[-1] + roles: + + - role: postgrespro + deploy_dtm: true + + - role: postgrespro + deploy_postgres: true + pg_port: 15432 + pg_dtm_enable: true + pg_datadir: ./postgrespro-data + + - role: postgrespro + deploy_postgres: true + pg_port: 15433 + pg_dtm_enable: true + pg_datadir: ./postgrespro-data2 + + diff --git a/tests/dtmbench b/tests/dtmbench new file mode 100755 index 0000000000000000000000000000000000000000..3ad806cd7b75ce539658d9555058f72e348c61e5 GIT binary patch literal 451917 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 ~xMtdrtSz+z|$D#eJD&5X#F9ozJ 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

2FO@o-&`geQ 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 +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +using namespace std; +using namespace pqxx; + +template +class my_unique_ptr +{ + T* ptr; + + public: + my_unique_ptr(T* p = NULL) : ptr(p) {} + ~my_unique_ptr() { delete ptr; } + T& operator*() { return *ptr; } + T* operator->() { return ptr; } + void operator=(T* p) { ptr = p; } + void operator=(my_unique_ptr& other) { + ptr = other.ptr; + other.ptr = NULL; + } +}; + +typedef void* (*thread_proc_t)(void*); +typedef uint32_t xid_t; + +struct thread +{ + pthread_t t; + size_t transactions; + size_t updates; + size_t selects; + size_t aborts; + int id; + + void start(int tid, thread_proc_t proc) { + id = tid; + updates = 0; + selects = 0; + aborts = 0; + transactions = 0; + pthread_create(&t, NULL, proc, this); + } + + void wait() { + pthread_join(t, NULL); + } +}; + +struct config +{ + int nReaders; + int nWriters; + int nIterations; + int nAccounts; + int updatePercent; + vector connections; + + config() { + nReaders = 1; + nWriters = 10; + nIterations = 1000; + nAccounts = 100000; + updatePercent = 100; + } +}; + +config cfg; +bool running; + +#define USEC 1000000 + +static time_t getCurrentTime() +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return (time_t)tv.tv_sec*USEC + tv.tv_usec; +} + + +void exec(transaction_base& txn, char const* sql, ...) +{ + va_list args; + va_start(args, sql); + char buf[1024]; + vsprintf(buf, sql, args); + va_end(args); + txn.exec(buf); +} + +template +T execQuery( transaction_base& txn, char const* sql, ...) +{ + va_list args; + va_start(args, sql); + char buf[1024]; + vsprintf(buf, sql, args); + va_end(args); + result r = txn.exec(buf); + return r[0][0].as(T()); +} + +void* reader(void* arg) +{ + thread& t = *(thread*)arg; + vector< my_unique_ptr > conns(cfg.connections.size()); + for (size_t i = 0; i < conns.size(); i++) { + conns[i] = new connection(cfg.connections[i]); + } + int64_t prevSum = 0; + + while (running) { + work txn(*conns[random() % conns.size()]); + result r = txn.exec("select sum(v) from t"); + int64_t sum = r[0][0].as(int64_t()); + if (sum != prevSum) { + printf("Total=%ld\n", sum); + prevSum = sum; + } + t.transactions += 1; + t.selects += 1; + txn.commit(); + } + return NULL; +} + +void* writer(void* arg) +{ + thread& t = *(thread*)arg; + vector< my_unique_ptr > conns(cfg.connections.size()); + for (size_t i = 0; i < conns.size(); i++) { + conns[i] = new connection(cfg.connections[i]); + } + for (int i = 0; i < cfg.nIterations; i++) + { + //work + transaction txn(*conns[random() % conns.size()]); + // transaction txn(*conns[random() % conns.size()]); + int srcAcc = random() % cfg.nAccounts; + int dstAcc = random() % cfg.nAccounts; + try { + if (random() % 100 < cfg.updatePercent) { + exec(txn, "update t set v = v - 1 where u=%d", srcAcc); + exec(txn, "update t set v = v + 1 where u=%d", dstAcc); + t.updates += 2; + } else { + int64_t sum = execQuery(txn, "select v from t where u=%d", srcAcc) + + execQuery(txn, "select v from t where u=%d", dstAcc); + if (sum > cfg.nIterations*cfg.nWriters || sum < -cfg.nIterations*cfg.nWriters) { + printf("Wrong sum=%ld\n", sum); + } + t.selects += 2; + } + txn.commit(); + t.transactions += 1; + } catch (pqxx_exception const& x) { + txn.abort(); + t.aborts += 1; + i -= 1; + continue; + } + } + return NULL; +} + +void initializeDatabase() +{ + connection conn(cfg.connections[0]); + + printf("creating extension\n"); + { + nontransaction txn(conn); + exec(txn, "drop extension if exists multimaster"); + exec(txn, "create extension multimaster"); + txn.commit(); + } + printf("extension created\n"); + + printf("creating table t\n"); + { + nontransaction txn(conn); + exec(txn, "drop table if exists t"); + exec(txn, "create table t(u int primary key, v int)"); + txn.commit(); + } + printf("table t created\n"); + + printf("inserting stuff into t\n"); + { + work txn(conn); + exec(txn, "insert into t (select generate_series(0,%d), %d)", cfg.nAccounts-1, 0); + txn.commit(); + } + printf("stuff inserted\n"); +} + +int main (int argc, char* argv[]) +{ + bool initialize = false; + + if (argc == 1){ + printf("Use -h to show usage options\n"); + return 1; + } + + for (int i = 1; i < argc; i++) { + if (argv[i][0] == '-') { + switch (argv[i][1]) { + case 'r': + cfg.nReaders = atoi(argv[++i]); + continue; + case 'w': + cfg.nWriters = atoi(argv[++i]); + continue; + case 'a': + cfg.nAccounts = atoi(argv[++i]); + continue; + case 'n': + cfg.nIterations = atoi(argv[++i]); + continue; + case 'p': + cfg.updatePercent = atoi(argv[++i]); + continue; + case 'c': + cfg.connections.push_back(string(argv[++i])); + continue; + case 'i': + initialize = true; + continue; + } + } + printf("Options:\n" + "\t-r N\tnumber of readers (1)\n" + "\t-w N\tnumber of writers (10)\n" + "\t-a N\tnumber of accounts (100000)\n" + "\t-n N\tnumber of iterations (1000)\n" + "\t-p N\tupdate percent (100)\n" + "\t-c STR\tdatabase connection string\n" + "\t-i\tinitialize database\n"); + return 1; + } + + if (initialize) { + initializeDatabase(); + printf("%d accounts inserted\n", cfg.nAccounts); + return 0; + } + + time_t start = getCurrentTime(); + running = true; + + vector readers(cfg.nReaders); + vector writers(cfg.nWriters); + size_t nAborts = 0; + size_t nUpdates = 0; + size_t nSelects = 0; + size_t nTransactions = 0; + + for (int i = 0; i < cfg.nReaders; i++) { + readers[i].start(i, reader); + } + for (int i = 0; i < cfg.nWriters; i++) { + writers[i].start(i, writer); + } + + for (int i = 0; i < cfg.nWriters; i++) { + writers[i].wait(); + nUpdates += writers[i].updates; + nSelects += writers[i].selects; + nAborts += writers[i].aborts; + nTransactions += writers[i].transactions; + } + + running = false; + + for (int i = 0; i < cfg.nReaders; i++) { + readers[i].wait(); + nSelects += readers[i].selects; + nTransactions += writers[i].transactions; + } + + time_t elapsed = getCurrentTime() - start; + + printf( + "{\"tps\":%f, \"transactions\":%ld," + " \"selects\":%ld, \"updates\":%ld, \"aborts\":%ld, \"abort_percent\": %d," + " \"readers\":%d, \"writers\":%d, \"update_percent\":%d, \"accounts\":%d, \"iterations\":%d, \"hosts\":%ld}\n", + (double)(nTransactions*USEC)/elapsed, + nTransactions, + nSelects, + nUpdates, + nAborts, + (int)(nAborts*100/nTransactions), + cfg.nReaders, + cfg.nWriters, + cfg.updatePercent, + cfg.nAccounts, + cfg.nIterations, + cfg.connections.size() + ); + + return 0; +} diff --git a/tests/farms/localhost b/tests/farms/localhost new file mode 100644 index 0000000000..8ae34b77bc --- /dev/null +++ b/tests/farms/localhost @@ -0,0 +1,8 @@ +[clients] +localhost + +[nodes] +localhost + +[master] +localhost diff --git a/tests/farms/sai b/tests/farms/sai new file mode 100644 index 0000000000..53f996c11c --- /dev/null +++ b/tests/farms/sai @@ -0,0 +1,19 @@ +[clients] +158.250.29.5 ansible_ssh_user=cluster offset=1 +#158.250.29.7 ansible_ssh_user=cluster ansible_ssh_port=2299 offset=100001 + +[nodes] +158.250.29.4 ansible_ssh_user=cluster node_id=5 +#158.250.29.6 ansible_ssh_user=cluster node_id=4 +#158.250.29.8 ansible_ssh_user=cluster node_id=3 +#158.250.29.9 ansible_ssh_user=cluster node_id=2 + +158.250.29.8 ansible_ssh_user=cluster node_id=3 +158.250.29.9 ansible_ssh_user=cluster node_id=2 +158.250.29.10 ansible_ssh_user=cluster node_id=1 + +[master] +158.250.29.10 ansible_ssh_user=cluster + +[local] +localhost diff --git a/tests/init.sql b/tests/init.sql new file mode 100644 index 0000000000..2d4937b7e7 --- /dev/null +++ b/tests/init.sql @@ -0,0 +1,2 @@ +create extension multimaster; +create table t(u int primary key, v int); diff --git a/tests/makefile b/tests/makefile new file mode 100644 index 0000000000..8a45d37e85 --- /dev/null +++ b/tests/makefile @@ -0,0 +1,10 @@ +CXX=g++ +CXXFLAGS=-g -Wall -O2 -pthread + +all: dtmbench + +dtmbench: dtmbench.cpp + $(CXX) $(CXXFLAGS) -o dtmbench dtmbench.cpp -lpqxx -lpq + +clean: + rm -f dtmbench diff --git a/tests/mm.pgb b/tests/mm.pgb new file mode 100644 index 0000000000..70c3894cab --- /dev/null +++ b/tests/mm.pgb @@ -0,0 +1,7 @@ +\setrandom id1 1 100000 +\setrandom id2 1 100000 +begin; +--select v from t where u=:id; +update t set v = v - 1 where u=:id1; +update t set v = v + 1 where u=:id2; +commit; diff --git a/tests/perf.results b/tests/perf.results new file mode 100644 index 0000000000..95939ddae3 --- /dev/null +++ b/tests/perf.results @@ -0,0 +1,102 @@ +Bench started at Пн. дек. 28 16:45:57 MSK 2015 +astro5:{tps:82710.398466, transactions:505000, selects:1000094, updates:0, aborts:0, abort_percent: 0, readers:1, writers:100, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. дек. 28 16:46:03 MSK 2015 +Bench started at Пн. дек. 28 16:48:11 MSK 2015 +astro5:{tps:95486.419038, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:48:32 MSK 2015 +Bench started at Пн. дек. 28 16:50:40 MSK 2015 +astro5:{tps:58000.391271, transactions:3000000, selects:6000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:300, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:51:32 MSK 2015 +Bench started at Пн. дек. 28 16:52:36 MSK 2015 +astro5:{tps:75481.448607, transactions:2500000, selects:5000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:53:10 MSK 2015 +Bench started at Пн. дек. 28 16:53:30 MSK 2015 +astro5:{tps:96849.761356, transactions:1500000, selects:3000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:150, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:53:46 MSK 2015 +Bench started at Пн. дек. 28 16:54:35 MSK 2015 +astro5:{tps:99112.256474, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:54:56 MSK 2015 +Bench started at Пн. дек. 28 16:55:40 MSK 2015 +astro5:{tps:77118.328667, transactions:2500000, selects:5000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:56:13 MSK 2015 +Bench started at Пн. дек. 28 16:56:38 MSK 2015 +astro5:{tps:97729.043079, transactions:1800000, selects:3600000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:180, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:56:57 MSK 2015 +Bench started at Пн. дек. 28 16:57:21 MSK 2015 +astro5:{tps:88135.849072, transactions:2200000, selects:4400000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:220, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:57:46 MSK 2015 +Bench started at Пн. дек. 28 16:58:06 MSK 2015 +astro5:{tps:96213.836406, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 16:58:27 MSK 2015 +Bench started at Пн. дек. 28 17:00:08 MSK 2015 +astro5:{tps:94062.466696, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:00:30 MSK 2015 +Bench started at Пн. дек. 28 17:01:23 MSK 2015 +astro5:{tps:96258.868672, transactions:1900000, selects:3800000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:190, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:01:43 MSK 2015 +Bench started at Пн. дек. 28 17:06:24 MSK 2015 +astro5:{tps:98201.344180, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:06:45 MSK 2015 +Bench started at Пн. дек. 28 17:10:02 MSK 2015 +astro5:{tps:99260.179144, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:10:23 MSK 2015 +Bench started at Пн. дек. 28 17:10:45 MSK 2015 +astro5:{tps:59596.922177, transactions:3000000, selects:6000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:300, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:11:36 MSK 2015 +Bench started at Пн. дек. 28 17:12:04 MSK 2015 +astro5:{tps:97180.149516, transactions:1500000, selects:3000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:150, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:12:19 MSK 2015 +Bench started at Пн. дек. 28 17:14:24 MSK 2015 + +Bench finished at Пн. дек. 28 17:14:24 MSK 2015 +Bench started at Пн. дек. 28 17:14:50 MSK 2015 +astro5:{tps:75264.442560, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:15:17 MSK 2015 +Bench started at Пн. дек. 28 17:15:43 MSK 2015 +astro5:{tps:73916.036114, transactions:1500000, selects:3000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:150, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:16:04 MSK 2015 +Bench started at Пн. дек. 28 17:16:32 MSK 2015 +astro5:{tps:75341.921227, transactions:2500000, selects:5000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:17:06 MSK 2015 +Bench started at Пн. дек. 28 17:17:45 MSK 2015 +astro5:{tps:75056.119461, transactions:2500000, selects:5000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:18:18 MSK 2015 +Bench started at Пн. дек. 28 17:18:43 MSK 2015 +astro5:{tps:75890.386233, transactions:2500000, selects:5000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:19:16 MSK 2015 +Bench started at Пн. дек. 28 17:21:07 MSK 2015 + +Bench finished at Пн. дек. 28 17:21:08 MSK 2015 +Bench started at Пн. дек. 28 17:21:29 MSK 2015 +astro5:{tps:100635.796837, transactions:2000000, selects:4000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пн. дек. 28 17:21:49 MSK 2015 +Bench started at Пн. дек. 28 17:25:19 MSK 2015 +astro5:{tps:105187.951278, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Пн. дек. 28 17:28:30 MSK 2015 +Bench started at Пн. дек. 28 17:28:58 MSK 2015 + +Bench finished at Пн. дек. 28 17:37:24 MSK 2015 +Bench started at Ср. дек. 30 10:20:00 MSK 2015 +astro5:{tps:58953.867049, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 10:25:40 MSK 2015 +Bench started at Ср. дек. 30 10:35:41 MSK 2015 +astro5:{tps:57329.959855, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 10:41:30 MSK 2015 +Bench started at Ср. дек. 30 11:00:00 MSK 2015 +astro5:{tps:112584.121096, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 11:02:57 MSK 2015 +Bench started at Ср. дек. 30 12:52:42 MSK 2015 +astro5:{tps:112702.584939, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 12:55:40 MSK 2015 +Bench started at Ср. дек. 30 13:04:02 MSK 2015 +astro5:{tps:112698.844997, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 13:07:00 MSK 2015 +Bench started at Ср. дек. 30 13:20:16 MSK 2015 +astro5:{tps:109226.955236, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 13:23:20 MSK 2015 +Bench started at Ср. дек. 30 15:32:48 MSK 2015 +astro5:{tps:112740.183590, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 15:35:45 MSK 2015 +Bench started at Ср. дек. 30 19:57:27 MSK 2015 +astro5:{tps:111696.732113, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. дек. 30 20:00:27 MSK 2015 diff --git a/tests/perf.yml b/tests/perf.yml new file mode 100644 index 0000000000..c911285165 --- /dev/null +++ b/tests/perf.yml @@ -0,0 +1,60 @@ +--- + +- hosts: nodes[-1] + gather_facts: no + tasks: + + - name: create mm ext + shell: > + ~/pg_cluster/install/bin/psql -p 15432 postgres -c "drop extension if exists multimaster"; + ~/pg_cluster/install/bin/psql -p 15432 postgres -c "drop table if exists t"; + ~/pg_cluster/install/bin/psql -p 15432 postgres -c 'create extension multimaster;'; + ~/pg_cluster/install/bin/psql -p 15432 postgres -c 'create table t(u int primary key, v int);'; + +- hosts: clients + gather_facts: no + tasks: + + - name: generate connstrings + set_fact: + connstr: "-c 'host={{item}} user={{ansible_ssh_user}} port=15432 dbname=postgres' " + with_items: + groups['nodes'] | reverse | batch(nnodes | d(1) | int) | first + register: connstrs + + - name: make a list + set_fact: + connections: "{{ connstrs.results | map(attribute='ansible_facts.connstr') | join }}" + +- hosts: clients[0] + gather_facts: no + tasks: + - name: init database + shell: "~/pg_cluster/install/bin/dtmbench {{connections}} -a 500000 -i" + register: init_result + environment: + LD_LIBRARY_PATH: "/home/{{ansible_ssh_user}}/pg_cluster/install/lib" + + - debug: var=init_result + +- hosts: clients + gather_facts: no + tasks: + + - local_action: shell echo "Bench started at `date`" >> perf.results + + - name: run transfers + shell: > + ~/pg_cluster/install/bin/dtmbench {{connections}} + -w {{ nconns }} -r 0 -n 5000 -a 500000 -p {{ up }} | + tee -a perf.results | + sed "s/^/`hostname`:/" + register: transfers_result + environment: + LD_LIBRARY_PATH: "/home/{{ansible_ssh_user}}/pg_cluster/install/lib" + + - debug: var=transfers_result + + - local_action: 'shell echo "{{transfers_result.stdout }}" >> perf.results' + + - local_action: shell echo "Bench finished at `date`" >> perf.results diff --git a/tests/perf/perf.go b/tests/perf/perf.go new file mode 100644 index 0000000000..fce190e528 --- /dev/null +++ b/tests/perf/perf.go @@ -0,0 +1,292 @@ +package main + +import ( + "fmt" + "flag" + "os" + "sync" + "time" + "github.com/jackc/pgx" +) + +type ConnStrings []string + +var backend interface{ + prepare(connstrs []string) + writer(id int, cCommits chan int, cAborts chan int, wg *sync.WaitGroup) + reader(wg *sync.WaitGroup, cFetches chan int, inconsistency *bool) +} + +var cfg struct { + ConnStrs ConnStrings + Backend string + Verbose bool + UseDtm bool + Init bool + Parallel bool + Isolation string + AccountsNum int + ReadersNum int + IterNum int + + Writers struct { + Num int + StartId int + } +} + +// The first method of flag.Value interface +func (c *ConnStrings) String() string { + if len(*c) > 0 { + return (*c)[0] + } else { + return "" + } +} + +// The second method of flag.Value interface +func (c *ConnStrings) Set(value string) error { + *c = append(*c, value) + return nil +} + +func append_with_comma(s *string, x string) { + if len(*s) > 0 { + *s = *s + ", " + x + } else { + *s = x + } +} + +func dump_cfg() { + fmt.Printf("Connections: %d\n", len(cfg.ConnStrs)) + for _, cs := range cfg.ConnStrs { + fmt.Printf(" %s\n", cs) + } + fmt.Printf("Isolation: %s\n", cfg.Isolation) + fmt.Printf( + "Accounts: %d × $%d\n", + cfg.AccountsNum, 0, + ) + fmt.Printf("Readers: %d\n", cfg.ReadersNum) + + fmt.Printf( + "Writers: %d × %d updates\n", + cfg.Writers.Num, cfg.IterNum, + ) +} + +func init() { + flag.StringVar(&cfg.Backend, "b", "transfers", + "Backend to use. Possible optinos: transfers, fdw, pgshard, readers.") + flag.Var(&cfg.ConnStrs, "C", + "Connection string (repeat for multiple connections)") + flag.BoolVar(&cfg.Init, "i", false, + "Init database") + flag.BoolVar(&cfg.UseDtm, "g", false, + "Use DTM to keep global consistency") + flag.IntVar(&cfg.AccountsNum, "a", 100000, + "The number of bank accounts") + flag.IntVar(&cfg.Writers.StartId, "s", 0, + "StartID. Script will update rows starting from this value") + flag.IntVar(&cfg.IterNum, "n", 10000, + "The number updates each writer (reader in case of Reades backend) performs") + flag.IntVar(&cfg.ReadersNum, "r", 1, + "The number of readers") + flag.IntVar(&cfg.Writers.Num, "w", 8, + "The number of writers") + flag.BoolVar(&cfg.Verbose, "v", false, + "Show progress and other stuff for mortals") + flag.BoolVar(&cfg.Parallel, "p", false, + "Use parallel execs") + repread := flag.Bool("l", false, + "Use 'repeatable read' isolation level instead of 'read committed'") + flag.Parse() + + if len(cfg.ConnStrs) == 0 { + flag.PrintDefaults() + os.Exit(1) + } + + if cfg.AccountsNum < 2 { + fmt.Println( + "There should be at least 2 accounts (to avoid deadlocks)", + ) + os.Exit(1) + } + + if *repread { + cfg.Isolation = "repeatable read" + } else { + cfg.Isolation = "read committed" + } + + dump_cfg() +} + +func main() { + if len(cfg.ConnStrs) < 2 { + fmt.Println("ERROR: This test needs at leas two connections") + os.Exit(1) + } + + switch cfg.Backend { + case "transfers": + backend = new(Transfers) + case "fdw": + backend = new(TransfersFDW) + case "readers": + backend = new(Readers) + case "pgshard": + backend = new(TransfersPgShard) + default: + fmt.Println("No backend named: '%s'\n", cfg.Backend) + return + } + + start := time.Now() + + if (cfg.Init){ + backend.prepare(cfg.ConnStrs) + fmt.Printf("database prepared in %0.2f seconds\n", time.Since(start).Seconds()) + return + } + + var writerWg sync.WaitGroup + var readerWg sync.WaitGroup + + cCommits := make(chan int) + cFetches:= make(chan int) + cAborts := make(chan int) + + go progress(cfg.Writers.Num * cfg.IterNum, cCommits, cAborts) + + start = time.Now() + writerWg.Add(cfg.Writers.Num) + for i := 0; i < cfg.Writers.Num; i++ { + go backend.writer(i, cCommits, cAborts, &writerWg) + } + running = true + + inconsistency := false + readerWg.Add(cfg.ReadersNum) + for i := 0; i < cfg.ReadersNum; i++ { + go backend.reader(&readerWg, cFetches, &inconsistency) + } + + writerWg.Wait() + running = false + readerWg.Wait() + + fmt.Printf("writers finished in %0.2f seconds\n", + time.Since(start).Seconds()) + fmt.Printf("TPS = %0.2f\n", + float64(cfg.Writers.Num*cfg.IterNum)/time.Since(start).Seconds()) + + if inconsistency { + fmt.Printf("INCONSISTENCY DETECTED\n") + } + fmt.Printf("done.\n") +} + +var running = false + +func asyncCommit(conn *pgx.Conn, wg *sync.WaitGroup) { + exec(conn, "commit") + wg.Done() +} + +func commit(conns ...*pgx.Conn) { + var wg sync.WaitGroup + wg.Add(len(conns)) + for _, conn := range conns { + go asyncCommit(conn, &wg) + } + wg.Wait() +} + +func parallel_exec(conns []*pgx.Conn, requests []string) bool { + var wg sync.WaitGroup + state := true + wg.Add(len(conns)) + for i := range conns { + if cfg.Parallel { + go func(j int) { + _, err := conns[j].Exec(requests[j]) + if err != nil { + state = false + } + wg.Done() + }(i) + } else { + _, err := conns[i].Exec(requests[i]) + if err != nil { + state = false + } + wg.Done() + } + } + wg.Wait() + return state +} + +func progress(total int, cCommits chan int, cAborts chan int) { + commits := 0 + aborts := 0 + start := time.Now() + for newcommits := range cCommits { + newaborts := <-cAborts + commits += newcommits + aborts += newaborts + if time.Since(start).Seconds() > 1 { + if cfg.Verbose { + fmt.Printf( + "progress %0.2f%%: %d commits, %d aborts\n", + float32(commits) * 100.0 / float32(total), commits, aborts, + ) + } + start = time.Now() + } + } +} + +func exec(conn *pgx.Conn, stmt string, arguments ...interface{}) { + var err error + // fmt.Println(stmt) + _, err = conn.Exec(stmt, arguments... ) + checkErr(err) +} + +func execUpdate(conn *pgx.Conn, stmt string, arguments ...interface{}) bool { + var err error + // fmt.Println(stmt) + _, err = conn.Exec(stmt, arguments... ) + //if err != nil { + // fmt.Println(err) + //} + return err == nil +} + +func execQuery(conn *pgx.Conn, stmt string, arguments ...interface{}) int32 { + var err error + var result int32 + err = conn.QueryRow(stmt, arguments...).Scan(&result) + checkErr(err) + return result +} + +func execQuery64(conn *pgx.Conn, stmt string, arguments ...interface{}) int64 { + var err error + var result int64 + err = conn.QueryRow(stmt, arguments...).Scan(&result) + checkErr(err) + return result +} + +func checkErr(err error) { + if err != nil { + panic(err) + } +} + +// vim: expandtab ts=4 sts=4 sw=4 diff --git a/tests/perf/readers.go b/tests/perf/readers.go new file mode 100644 index 0000000000..144154b65d --- /dev/null +++ b/tests/perf/readers.go @@ -0,0 +1,92 @@ +package main + +import ( + "sync" + "math/rand" + "github.com/jackc/pgx" +) + +type Readers struct {} + +func (t Readers) prepare(connstrs []string) { + var wg sync.WaitGroup + wg.Add(len(connstrs)) + for _, connstr := range connstrs { + go t.prepare_one(connstr, &wg) + } + wg.Wait() +} + +func (t Readers) prepare_one(connstr string, wg *sync.WaitGroup) { + dbconf, err := pgx.ParseDSN(connstr) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + + if cfg.UseDtm { + exec(conn, "drop extension if exists pg_dtm") + exec(conn, "create extension pg_dtm") + } + exec(conn, "drop table if exists t cascade") + exec(conn, "create table t(u int primary key, v int)") + exec(conn, "insert into t (select generate_series(0,$1-1), $2)", cfg.AccountsNum, 0) + wg.Done() +} + +func (t Readers) writer(id int, cCommits chan int, cAborts chan int, wg *sync.WaitGroup) { + var updates = 0 + var conns []*pgx.Conn + + for _, connstr := range cfg.ConnStrs { + dbconf, err := pgx.ParseDSN(connstr) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + conns = append(conns, conn) + } + for updates < cfg.IterNum { + acc := rand.Intn(cfg.AccountsNum) + + if cfg.UseDtm { + xid := execQuery(conns[0], "select dtm_begin_transaction()") + for i := 1; i < len(conns); i++ { + exec(conns[i], "select dtm_join_transaction($1)", xid) + } + } + for _, conn := range conns { + exec(conn, "begin transaction isolation level " + cfg.Isolation) + exec(conn, "update t set v = v + 1 where u=$1", acc) + } + commit(conns...) + updates++ + } + // cCommits <- updates + wg.Done() +} + +func (t Readers) reader(wg *sync.WaitGroup, cFetches chan int, inconsistency *bool) { + var fetches = 0 + var conns []*pgx.Conn + var sum int32 = 0 + + for _, connstr := range cfg.ConnStrs { + dbconf, err := pgx.ParseDSN(connstr) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + conns = append(conns, conn) + } + for running { + acc := rand.Intn(cfg.AccountsNum) + con := rand.Intn(len(conns)) + sum += execQuery(conns[con], "select v from t where u=$1", acc) + fetches++ + } + // cFetches <- fetches + wg.Done() +} + +// vim: expandtab ts=4 sts=4 sw=4 diff --git a/tests/perf/transfers-fdw.go b/tests/perf/transfers-fdw.go new file mode 100644 index 0000000000..e5c052ecb3 --- /dev/null +++ b/tests/perf/transfers-fdw.go @@ -0,0 +1,153 @@ +package main + +import ( + "fmt" + "sync" + "time" + "os" + "github.com/jackc/pgx" +) + +type TransfersFDW struct {} + +func (t TransfersFDW) prepare(connstrs []string) { + var wg sync.WaitGroup + wg.Add(len(connstrs)) + + for i, connstr := range connstrs { + go t.prepare_slave(i, connstr, &wg) + } + wg.Wait() + t.prepare_master() +} + +func (t TransfersFDW) prepare_slave(id int, connstr string, wg *sync.WaitGroup) { + dbconf, err := pgx.ParseDSN(connstr) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + + if len(dbconf.User) == 0 { + fmt.Println("ERROR: FDW test need explicit usernames in connection strings") + os.Exit(2) + } + + if cfg.UseDtm { + exec(conn, "drop extension if exists pg_dtm") + exec(conn, "create extension pg_dtm") + } + exec(conn, "drop extension if exists postgres_fdw cascade") + exec(conn, "drop table if exists t cascade") + exec(conn, "create table t(u int primary key, v int)") + exec(conn, "insert into t (select $3*generate_series(0,$1-1) + $4, $2)", + cfg.AccountsNum, 0, len(cfg.ConnStrs), id) + wg.Done() +} + +func (t TransfersFDW) prepare_master() { + dbconf, err := pgx.ParseDSN(cfg.ConnStrs[0]) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + + exec(conn, "CREATE EXTENSION postgres_fdw") + + for i, connstr := range cfg.ConnStrs[1:] { + conf, _ := pgx.ParseDSN(connstr) + server_sql := fmt.Sprintf( + "CREATE SERVER dtm%d FOREIGN DATA WRAPPER postgres_fdw options(dbname '%s', host '%s', port '%d')", + i, conf.Database, conf.Host, conf.Port) + foreign_sql := fmt.Sprintf( + "CREATE FOREIGN TABLE t_fdw%d() inherits (t) server dtm%d options(table_name 't')", + i, i) + mapping_sql := fmt.Sprintf( + "CREATE USER MAPPING for %s SERVER dtm%d options (user '%s')", + conf.User, i, conf.User) + + exec(conn, server_sql) + exec(conn, foreign_sql) + exec(conn, mapping_sql) + } + + if dbconf.User != "" { + + } + +} + +func (t TransfersFDW) writer(id int, cCommits chan int, cAborts chan int, wg *sync.WaitGroup) { + var err error + var nAborts = 0 + var nCommits = 0 + var myCommits = 0 + + dbconf, err := pgx.ParseDSN(cfg.ConnStrs[0]) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + + start := time.Now() + for myCommits < cfg.IterNum { + amount := 1 + from_acc := cfg.Writers.StartId + 2*id + 1 + to_acc := cfg.Writers.StartId + 2*id + 2 + + if cfg.UseDtm { + exec(conn, "select dtm_begin_transaction()") + } + exec(conn, "begin transaction isolation level " + cfg.Isolation) + + ok1 := execUpdate(conn, "update t set v = v - $1 where u=$2", amount, from_acc) + ok2 := execUpdate(conn, "update t set v = v + $1 where u=$2", amount, to_acc) + if !ok1 || !ok2 { + exec(conn, "rollback") + nAborts += 1 + } else { + exec(conn, "commit") + nCommits += 1 + myCommits += 1 + } + + if time.Since(start).Seconds() > 1 { + cCommits <- nCommits + cAborts <- nAborts + nCommits = 0 + nAborts = 0 + start = time.Now() + } + } + cCommits <- nCommits + cAborts <- nAborts + wg.Done() +} + +func (t TransfersFDW) reader(wg *sync.WaitGroup, cFetches chan int, inconsistency *bool) { + var sum int64 + var prevSum int64 = 0 + + dbconf, err := pgx.ParseDSN(cfg.ConnStrs[0]) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + + for running { + exec(conn, "select dtm_begin_transaction()") + exec(conn, "begin transaction isolation level " + cfg.Isolation) + sum = execQuery64(conn, "select sum(v) from t") + if (sum != prevSum) { + fmt.Printf("Total=%d\n", sum) + fmt.Printf("inconsistency!\n") + *inconsistency = true + prevSum = sum + } + exec(conn, "commit") + } + conn.Close() + wg.Done() +} + +// vim: expandtab ts=4 sts=4 sw=4 diff --git a/tests/perf/transfers-pgshard.go b/tests/perf/transfers-pgshard.go new file mode 100644 index 0000000000..334e49ac6a --- /dev/null +++ b/tests/perf/transfers-pgshard.go @@ -0,0 +1,124 @@ +package main + +import ( + "fmt" + "sync" + _ "github.com/lib/pq" + "database/sql" + "strconv" + "math/rand" +) + +type TransfersPgShard struct {} + +func (t TransfersPgShard) prepare(connstrs []string) { + var wg sync.WaitGroup + wg.Add(len(connstrs)-1) + for i, connstr := range connstrs[1:] { + go t.prepare_slave(i, connstr, &wg) + } + wg.Wait() + t.prepare_master() +} + +func (t TransfersPgShard) prepare_slave(id int, connstr string, wg *sync.WaitGroup) { + conn, err := sql.Open("postgres", connstr) + checkErr(err) + defer conn.Close() + + if cfg.UseDtm { + _exec(conn, "drop extension if exists pg_dtm --") + _exec(conn, "create extension pg_dtm") + } + + drop_sql := fmt.Sprintf("drop table if exists t_1000%d", id) + _exec(conn, drop_sql) + + conn.Close() + wg.Done() +} + +func (t TransfersPgShard) prepare_master() { + conn, err := sql.Open("postgres", cfg.ConnStrs[0]) + checkErr(err) + + _exec(conn, "drop extension if exists pg_shard CASCADE") + _exec(conn, "create extension pg_shard") + _exec(conn, "drop table if exists t") + _exec(conn, "create table t(u int primary key, v int)") + _exec(conn, "select master_create_distributed_table(table_name := 't', partition_column := 'u')") + + master_sql := fmt.Sprintf( + "select master_create_worker_shards(table_name := 't', shard_count := %d, replication_factor := 1)", + len(cfg.ConnStrs)-1) + _exec(conn, master_sql) + + fmt.Println("Database feed started") + for i:=0; i<=cfg.AccountsNum; i++ { + _exec(conn, "insert into t values(" + strconv.Itoa(i) + ", 0)") + } + fmt.Println("Database feed finished") + + conn.Close() +} + +func (t TransfersPgShard) writer(id int, cCommits chan int, cAborts chan int, wg *sync.WaitGroup) { + conn, err := sql.Open("postgres", cfg.ConnStrs[0]) + checkErr(err) + + i:=0 + for i=0; i < cfg.IterNum; i++ { + amount := 1 + account1 := rand.Intn(cfg.AccountsNum-1)+1 + account2 := rand.Intn(cfg.AccountsNum-1)+1 + + _exec(conn, "begin") + _exec(conn, fmt.Sprintf("update t set v = v - %d where u=%d", amount, account1)) + _exec(conn, fmt.Sprintf("update t set v = v + %d where u=%d", amount, account2)) + _exec(conn, "commit") + + if i%1000==0 { + fmt.Printf("%d tx processed.\n", i) + } + } + + cCommits <- i + cAborts <- 0 + + conn.Close() + wg.Done() +} + +func (t TransfersPgShard) reader(wg *sync.WaitGroup, cFetches chan int, inconsistency *bool) { + var sum int64 + var prevSum int64 = 0 + + conn, err := sql.Open("postgres", cfg.ConnStrs[0]) + checkErr(err) + + for running { + sum = _execQuery(conn, "select sum(v) from t") + if sum != prevSum { + fmt.Println("Total = ", sum) + *inconsistency = true + prevSum = sum + } + } + + conn.Close() + wg.Done() +} + +func _exec(conn *sql.DB, stmt string) { + var err error + _, err = conn.Exec(stmt) + checkErr(err) +} + +func _execQuery(conn *sql.DB, stmt string) int64 { + var err error + var result int64 + err = conn.QueryRow(stmt).Scan(&result) + checkErr(err) + return result +} diff --git a/tests/perf/transfers.go b/tests/perf/transfers.go new file mode 100644 index 0000000000..16177c0b84 --- /dev/null +++ b/tests/perf/transfers.go @@ -0,0 +1,166 @@ +package main + +import ( + "fmt" + "sync" + "math/rand" + "strconv" + "time" + "github.com/jackc/pgx" +) + +type Transfers struct {} + +func (t Transfers) prepare(connstrs []string) { + var wg sync.WaitGroup + wg.Add(len(connstrs)) + for _, connstr := range connstrs { + go t.prepare_one(connstr, &wg) + } + wg.Wait() +} + +func (t Transfers) prepare_one(connstr string, wg *sync.WaitGroup) { + dbconf, err := pgx.ParseDSN(connstr) + checkErr(err) + + conn, err := pgx.Connect(dbconf) + checkErr(err) + + defer conn.Close() + + if cfg.UseDtm { + exec(conn, "drop extension if exists pg_dtm") + exec(conn, "create extension pg_dtm") + } + exec(conn, "drop table if exists t") + exec(conn, "create table t(u int primary key, v int)") + exec(conn, "insert into t (select generate_series(0,$1-1), $2)", + cfg.AccountsNum, 0) + + exec(conn, "commit") + wg.Done() +} + +func (t Transfers) writer(id int, cCommits chan int, cAborts chan int, wg *sync.WaitGroup) { + var nAborts = 0 + var nCommits = 0 + var myCommits = 0 + + var conns []*pgx.Conn + + if len(cfg.ConnStrs) == 1 { + cfg.ConnStrs.Set(cfg.ConnStrs[0]) + } + + for _, connstr := range cfg.ConnStrs { + dbconf, err := pgx.ParseDSN(connstr) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + conns = append(conns, conn) + } + + start := time.Now() + for myCommits < cfg.IterNum { + amount := 1 + + from_acc := cfg.Writers.StartId + 2*id + 1 + to_acc := cfg.Writers.StartId + 2*id + 2 + + src := conns[rand.Intn(len(conns))] + dst := conns[rand.Intn(len(conns))] + if src == dst { + continue + } + + if cfg.UseDtm { + xid := execQuery(src, "select dtm_begin_transaction()") + exec(dst, "select dtm_join_transaction($1)", xid) + } + + parallel_exec( + []*pgx.Conn{src,dst}, + []string{"begin transaction isolation level " + cfg.Isolation, + "begin transaction isolation level " + cfg.Isolation}) + + ok := true + + + sql1 := "update t set v = v - " + + strconv.Itoa(amount) + " where u=" + strconv.Itoa(from_acc) + sql2 := "update t set v = v + " + + strconv.Itoa(amount) + " where u=" + strconv.Itoa(to_acc) + + ok = parallel_exec([]*pgx.Conn{src,dst}, []string{sql1,sql2}) + + + if ok { + commit(src, dst) + nCommits += 1 + myCommits += 1 + } else { + exec(src, "rollback") + exec(dst, "rollback") + nAborts += 1 + } + + if time.Since(start).Seconds() > 1 { + cCommits <- nCommits + cAborts <- nAborts + nCommits = 0 + nAborts = 0 + start = time.Now() + } + } + cCommits <- nCommits + cAborts <- nAborts + wg.Done() +} + +func (t Transfers) reader(wg *sync.WaitGroup, cFetches chan int, inconsistency *bool) { + var prevSum int64 = 0 + + var conns []*pgx.Conn + + for _, connstr := range cfg.ConnStrs { + dbconf, err := pgx.ParseDSN(connstr) + checkErr(err) + conn, err := pgx.Connect(dbconf) + checkErr(err) + defer conn.Close() + conns = append(conns, conn) + } + + for running { + var sum int64 = 0 + var xid int32 + for i, conn := range conns { + if cfg.UseDtm { + if i == 0 { + xid = execQuery(conn, "select dtm_begin_transaction()") + } else { + exec(conn, "select dtm_join_transaction($1)", xid) + } + } + + exec(conn, "begin transaction isolation level " + cfg.Isolation) + sum += execQuery64(conn, "select sum(v) from t") + } + commit(conns...) + + if (sum != prevSum) { + fmt.Printf("Total=%d xid=%d\n", sum, xid) + if (prevSum != 0) { + fmt.Printf("inconsistency!\n") + *inconsistency = true + } + prevSum = sum + } + } + + wg.Done() +} + +// vim: expandtab ts=4 sts=4 sw=4 diff --git a/tests/pg_hba.conf b/tests/pg_hba.conf new file mode 100644 index 0000000000..bb032013b6 --- /dev/null +++ b/tests/pg_hba.conf @@ -0,0 +1,93 @@ +# PostgreSQL Client Authentication Configuration File +# =================================================== +# +# Refer to the "Client Authentication" section in the PostgreSQL +# documentation for a complete description of this file. A short +# synopsis follows. +# +# This file controls: which hosts are allowed to connect, how clients +# are authenticated, which PostgreSQL user names they can use, which +# databases they can access. Records take one of these forms: +# +# local DATABASE USER METHOD [OPTIONS] +# host DATABASE USER ADDRESS METHOD [OPTIONS] +# hostssl DATABASE USER ADDRESS METHOD [OPTIONS] +# hostnossl DATABASE USER ADDRESS METHOD [OPTIONS] +# +# (The uppercase items must be replaced by actual values.) +# +# The first field is the connection type: "local" is a Unix-domain +# socket, "host" is either a plain or SSL-encrypted TCP/IP socket, +# "hostssl" is an SSL-encrypted TCP/IP socket, and "hostnossl" is a +# plain TCP/IP socket. +# +# DATABASE can be "all", "sameuser", "samerole", "replication", a +# database name, or a comma-separated list thereof. The "all" +# keyword does not match "replication". Access to replication +# must be enabled in a separate record (see example below). +# +# USER can be "all", a user name, a group name prefixed with "+", or a +# comma-separated list thereof. In both the DATABASE and USER fields +# you can also write a file name prefixed with "@" to include names +# from a separate file. +# +# ADDRESS specifies the set of hosts the record matches. It can be a +# host name, or it is made up of an IP address and a CIDR mask that is +# an integer (between 0 and 32 (IPv4) or 128 (IPv6) inclusive) that +# specifies the number of significant bits in the mask. A host name +# that starts with a dot (.) matches a suffix of the actual host name. +# Alternatively, you can write an IP address and netmask in separate +# columns to specify the set of hosts. Instead of a CIDR-address, you +# can write "samehost" to match any of the server's own IP addresses, +# or "samenet" to match any address in any subnet that the server is +# directly connected to. +# +# METHOD can be "trust", "reject", "md5", "password", "gss", "sspi", +# "ident", "peer", "pam", "ldap", "radius" or "cert". Note that +# "password" sends passwords in clear text; "md5" is preferred since +# it sends encrypted passwords. +# +# OPTIONS are a set of options for the authentication in the format +# NAME=VALUE. The available options depend on the different +# authentication methods -- refer to the "Client Authentication" +# section in the documentation for a list of which options are +# available for which authentication methods. +# +# Database and user names containing spaces, commas, quotes and other +# special characters must be quoted. Quoting one of the keywords +# "all", "sameuser", "samerole" or "replication" makes the name lose +# its special character, and just match a database or username with +# that name. +# +# This file is read on server startup and when the postmaster receives +# a SIGHUP signal. If you edit the file on a running system, you have +# to SIGHUP the postmaster for the changes to take effect. You can +# use "pg_ctl reload" to do that. + +# Put your actual configuration here +# ---------------------------------- +# +# If you want to allow non-local connections, you need to add more +# "host" records. In that case you will also need to make PostgreSQL +# listen on a non-local interface via the listen_addresses +# configuration parameter, or via the -i or -h command line switches. + +# CAUTION: Configuring the system for local "trust" authentication +# allows any local user to connect as any PostgreSQL user, including +# the database superuser. If you do not trust all your local users, +# use another authentication method. + + +# TYPE DATABASE USER ADDRESS METHOD + +# "local" is for Unix domain socket connections only +local all all trust +# IPv4 local connections: +host all all 127.0.0.1/32 trust +# IPv6 local connections: +host all all ::1/128 trust +# Allow replication connections from localhost, by a user with the +# replication privilege. +local replication knizhnik trust +host replication knizhnik 127.0.0.1/32 trust +#host replication knizhnik ::1/128 trust diff --git a/tests/postgresql.conf.mm b/tests/postgresql.conf.mm new file mode 100644 index 0000000000..8151f4c34d --- /dev/null +++ b/tests/postgresql.conf.mm @@ -0,0 +1,628 @@ +# ----------------------------- +# PostgreSQL configuration file +# ----------------------------- +# +# This file consists of lines of the form: +# +# name = value +# +# (The "=" is optional.) Whitespace may be used. Comments are introduced with +# "#" anywhere on a line. The complete list of parameter names and allowed +# values can be found in the PostgreSQL documentation. +# +# The commented-out settings shown in this file represent the default values. +# Re-commenting a setting is NOT sufficient to revert it to the default value; +# you need to reload the server. +# +# This file is read on server startup and when the server receives a SIGHUP +# signal. If you edit the file on a running system, you have to SIGHUP the +# server for the changes to take effect, or use "pg_ctl reload". Some +# parameters, which are marked below, require a server shutdown and restart to +# take effect. +# +# Any parameter can also be given as a command-line option to the server, e.g., +# "postgres -c log_connections=on". Some parameters can be changed at run time +# with the "SET" SQL command. +# +# Memory units: kB = kilobytes Time units: ms = milliseconds +# MB = megabytes s = seconds +# GB = gigabytes min = minutes +# TB = terabytes h = hours +# d = days + + +#------------------------------------------------------------------------------ +# FILE LOCATIONS +#------------------------------------------------------------------------------ + +# The default values of these variables are driven from the -D command-line +# option or PGDATA environment variable, represented here as ConfigDir. + +#data_directory = 'ConfigDir' # use data in another directory + # (change requires restart) +#hba_file = 'ConfigDir/pg_hba.conf' # host-based authentication file + # (change requires restart) +#ident_file = 'ConfigDir/pg_ident.conf' # ident configuration file + # (change requires restart) + +# If external_pid_file is not explicitly set, no extra PID file is written. +#external_pid_file = '' # write an extra PID file + # (change requires restart) + + +#------------------------------------------------------------------------------ +# CONNECTIONS AND AUTHENTICATION +#------------------------------------------------------------------------------ + +# - Connection Settings - + +#listen_addresses = 'localhost' # what IP address(es) to listen on; + # comma-separated list of addresses; + # defaults to 'localhost'; use '*' for all + # (change requires restart) +port = 5432 # (change requires restart) +max_connections = 200 # (change requires restart) +# Note: Increasing max_connections costs ~400 bytes of shared memory per +# connection slot, plus lock space (see max_locks_per_transaction). +#superuser_reserved_connections = 3 # (change requires restart) +#unix_socket_directories = '/tmp' # comma-separated list of directories + # (change requires restart) +#unix_socket_group = '' # (change requires restart) +#unix_socket_permissions = 0777 # begin with 0 to use octal notation + # (change requires restart) +#bonjour = off # advertise server via Bonjour + # (change requires restart) +#bonjour_name = '' # defaults to the computer name + # (change requires restart) + +# - Security and Authentication - + +#authentication_timeout = 1min # 1s-600s +#ssl = off # (change requires restart) +#ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL' # allowed SSL ciphers + # (change requires restart) +#ssl_prefer_server_ciphers = on # (change requires restart) +#ssl_ecdh_curve = 'prime256v1' # (change requires restart) +#ssl_cert_file = 'server.crt' # (change requires restart) +#ssl_key_file = 'server.key' # (change requires restart) +#ssl_ca_file = '' # (change requires restart) +#ssl_crl_file = '' # (change requires restart) +#password_encryption = on +#db_user_namespace = off +#row_security = on + +# GSSAPI using Kerberos +#krb_server_keyfile = '' +#krb_caseins_users = off + +# - TCP Keepalives - +# see "man 7 tcp" for details + +#tcp_keepalives_idle = 0 # TCP_KEEPIDLE, in seconds; + # 0 selects the system default +#tcp_keepalives_interval = 0 # TCP_KEEPINTVL, in seconds; + # 0 selects the system default +#tcp_keepalives_count = 0 # TCP_KEEPCNT; + # 0 selects the system default + + +#------------------------------------------------------------------------------ +# RESOURCE USAGE (except WAL) +#------------------------------------------------------------------------------ + +# - Memory - + +shared_buffers = 1GB # min 128kB + # (change requires restart) +#huge_pages = try # on, off, or try + # (change requires restart) +#temp_buffers = 8MB # min 800kB +max_prepared_transactions = 200 # zero disables the feature + # (change requires restart) +# Note: Increasing max_prepared_transactions costs ~600 bytes of shared memory +# per transaction slot, plus lock space (see max_locks_per_transaction). +# It is not advisable to set max_prepared_transactions nonzero unless you +# actively intend to use prepared transactions. +#work_mem = 4MB # min 64kB +#maintenance_work_mem = 64MB # min 1MB +#autovacuum_work_mem = -1 # min 1MB, or -1 to use maintenance_work_mem +#max_stack_depth = 2MB # min 100kB +dynamic_shared_memory_type = posix # the default is the first option + # supported by the operating system: + # posix + # sysv + # windows + # mmap + # use none to disable dynamic shared memory + +# - Disk - + +#temp_file_limit = -1 # limits per-session temp file space + # in kB, or -1 for no limit + +# - Kernel Resource Usage - + +#max_files_per_process = 1000 # min 25 + # (change requires restart) +shared_preload_libraries = 'multimaster' # (change requires restart) + +# - Cost-Based Vacuum Delay - + +#vacuum_cost_delay = 0 # 0-100 milliseconds +#vacuum_cost_page_hit = 1 # 0-10000 credits +#vacuum_cost_page_miss = 10 # 0-10000 credits +#vacuum_cost_page_dirty = 20 # 0-10000 credits +#vacuum_cost_limit = 200 # 1-10000 credits + +# - Background Writer - + +#bgwriter_delay = 200ms # 10-10000ms between rounds +#bgwriter_lru_maxpages = 100 # 0-1000 max buffers written/round +#bgwriter_lru_multiplier = 2.0 # 0-10.0 multipler on buffers scanned/round + +# - Asynchronous Behavior - + +#effective_io_concurrency = 1 # 1-1000; 0 disables prefetching +max_worker_processes = 100 + + +#------------------------------------------------------------------------------ +# WRITE AHEAD LOG +#------------------------------------------------------------------------------ + +# - Settings - + +wal_level = logical # minimal, archive, hot_standby, or logical + # (change requires restart) +fsync = off # turns forced synchronization on or off +#synchronous_commit = on # synchronization level; + # off, local, remote_write, or on +#wal_sync_method = fsync # the default is the first option + # supported by the operating system: + # open_datasync + # fdatasync (default on Linux) + # fsync + # fsync_writethrough + # open_sync +#full_page_writes = on # recover from partial page writes +#wal_compression = off # enable compression of full-page writes +#wal_log_hints = off # also do full page writes of non-critical updates + # (change requires restart) +#wal_buffers = -1 # min 32kB, -1 sets based on shared_buffers + # (change requires restart) +#wal_writer_delay = 200ms # 1-10000 milliseconds + +#commit_delay = 0 # range 0-100000, in microseconds +#commit_siblings = 5 # range 1-1000 + +# - Checkpoints - + +checkpoint_timeout = 50min # range 30s-1h +max_wal_size = 100GB +min_wal_size = 1GB +#checkpoint_completion_target = 0.5 # checkpoint target duration, 0.0 - 1.0 +#checkpoint_warning = 30s # 0 disables + +# - Archiving - + +#archive_mode = off # enables archiving; off, on, or always + # (change requires restart) +#archive_command = '' # command to use to archive a logfile segment + # placeholders: %p = path of file to archive + # %f = file name only + # e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f' +#archive_timeout = 0 # force a logfile segment switch after this + # number of seconds; 0 disables + + +#------------------------------------------------------------------------------ +# REPLICATION +#------------------------------------------------------------------------------ + +# - Sending Server(s) - + +# Set these on the master and on any standby that will send replication data. + +max_wal_senders = 10 # max number of walsender processes + # (change requires restart) +#wal_keep_segments = 0 # in logfile segments, 16MB each; 0 disables +wal_sender_timeout = 0 # in milliseconds; 0 disables + +max_replication_slots = 10 # max number of replication slots + # (change requires restart) +#track_commit_timestamp = off # collect timestamp of transaction commit + # (change requires restart) + +# - Master Server - + +# These settings are ignored on a standby server. + +#synchronous_standby_names = '' # standby servers that provide sync rep + # comma-separated list of application_name + # from standby(s); '*' = all +#vacuum_defer_cleanup_age = 0 # number of xacts by which cleanup is delayed + +# - Standby Servers - + +# These settings are ignored on a master server. + +#hot_standby = off # "on" allows queries during recovery + # (change requires restart) +#max_standby_archive_delay = 30s # max delay before canceling queries + # when reading WAL from archive; + # -1 allows indefinite delay +#max_standby_streaming_delay = 30s # max delay before canceling queries + # when reading streaming WAL; + # -1 allows indefinite delay +#wal_receiver_status_interval = 10s # send replies at least this often + # 0 disables +#hot_standby_feedback = off # send info from standby to prevent + # query conflicts +#wal_receiver_timeout = 60s # time that receiver waits for + # communication from master + # in milliseconds; 0 disables +#wal_retrieve_retry_interval = 5s # time to wait before retrying to + # retrieve WAL after a failed attempt + + +#------------------------------------------------------------------------------ +# QUERY TUNING +#------------------------------------------------------------------------------ + +# - Planner Method Configuration - + +#enable_bitmapscan = on +#enable_hashagg = on +#enable_hashjoin = on +#enable_indexscan = on +#enable_indexonlyscan = on +#enable_material = on +#enable_mergejoin = on +#enable_nestloop = on +#enable_seqscan = on +#enable_sort = on +#enable_tidscan = on + +# - Planner Cost Constants - + +#seq_page_cost = 1.0 # measured on an arbitrary scale +#random_page_cost = 4.0 # same scale as above +#cpu_tuple_cost = 0.01 # same scale as above +#cpu_index_tuple_cost = 0.005 # same scale as above +#cpu_operator_cost = 0.0025 # same scale as above +#effective_cache_size = 4GB + +# - Genetic Query Optimizer - + +#geqo = on +#geqo_threshold = 12 +#geqo_effort = 5 # range 1-10 +#geqo_pool_size = 0 # selects default based on effort +#geqo_generations = 0 # selects default based on effort +#geqo_selection_bias = 2.0 # range 1.5-2.0 +#geqo_seed = 0.0 # range 0.0-1.0 + +# - Other Planner Options - + +#default_statistics_target = 100 # range 1-10000 +#constraint_exclusion = partition # on, off, or partition +#cursor_tuple_fraction = 0.1 # range 0.0-1.0 +#from_collapse_limit = 8 +#join_collapse_limit = 8 # 1 disables collapsing of explicit + # JOIN clauses + + +#------------------------------------------------------------------------------ +# ERROR REPORTING AND LOGGING +#------------------------------------------------------------------------------ + +# - Where to Log - + +#log_destination = 'stderr' # Valid values are combinations of + # stderr, csvlog, syslog, and eventlog, + # depending on platform. csvlog + # requires logging_collector to be on. + +# This is used when logging to stderr: +#logging_collector = off # Enable capturing of stderr and csvlog + # into log files. Required to be on for + # csvlogs. + # (change requires restart) + +# These are only used if logging_collector is on: +#log_directory = 'pg_log' # directory where log files are written, + # can be absolute or relative to PGDATA +#log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log' # log file name pattern, + # can include strftime() escapes +#log_file_mode = 0600 # creation mode for log files, + # begin with 0 to use octal notation +#log_truncate_on_rotation = off # If on, an existing log file with the + # same name as the new log file will be + # truncated rather than appended to. + # But such truncation only occurs on + # time-driven rotation, not on restarts + # or size-driven rotation. Default is + # off, meaning append to existing files + # in all cases. +#log_rotation_age = 1d # Automatic rotation of logfiles will + # happen after that time. 0 disables. +#log_rotation_size = 10MB # Automatic rotation of logfiles will + # happen after that much log output. + # 0 disables. + +# These are relevant when logging to syslog: +#syslog_facility = 'LOCAL0' +#syslog_ident = 'postgres' + +# This is only relevant when logging to eventlog (win32): +#event_source = 'PostgreSQL' + +# - When to Log - + +#client_min_messages = notice # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # log + # notice + # warning + # error + +#log_min_messages = warning # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # info + # notice + # warning + # error + # log + # fatal + # panic + +#log_min_error_statement = error # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # info + # notice + # warning + # error + # log + # fatal + # panic (effectively off) + +#log_min_duration_statement = -1 # -1 is disabled, 0 logs all statements + # and their durations, > 0 logs only + # statements running at least this number + # of milliseconds + + +# - What to Log - + +#debug_print_parse = off +#debug_print_rewritten = off +#debug_print_plan = off +#debug_pretty_print = on +#log_checkpoints = off +#log_connections = off +#log_disconnections = off +#log_duration = off +#log_error_verbosity = default # terse, default, or verbose messages +#log_hostname = off +#log_line_prefix = '' # special values: + # %a = application name + # %u = user name + # %d = database name + # %r = remote host and port + # %h = remote host + # %p = process ID + # %t = timestamp without milliseconds + # %m = timestamp with milliseconds + # %i = command tag + # %e = SQL state + # %c = session ID + # %l = session line number + # %s = session start timestamp + # %v = virtual transaction ID + # %x = transaction ID (0 if none) + # %q = stop here in non-session + # processes + # %% = '%' + # e.g. '<%u%%%d> ' +#log_lock_waits = off # log lock waits >= deadlock_timeout +#log_statement = 'none' # none, ddl, mod, all +#log_replication_commands = off +#log_temp_files = -1 # log temporary files equal or larger + # than the specified size in kilobytes; + # -1 disables, 0 logs all temp files +log_timezone = 'W-SU' +#cluster_name = '' # added to process titles if nonempty + # (change requires restart) + + +#------------------------------------------------------------------------------ +# RUNTIME STATISTICS +#------------------------------------------------------------------------------ + +# - Query/Index Statistics Collector - + +#track_activities = on +#track_counts = on +#track_io_timing = off +#track_functions = none # none, pl, all +#track_activity_query_size = 1024 # (change requires restart) +#update_process_title = on +#stats_temp_directory = 'pg_stat_tmp' + + +# - Statistics Monitoring - + +#log_parser_stats = off +#log_planner_stats = off +#log_executor_stats = off +#log_statement_stats = off + + +#------------------------------------------------------------------------------ +# AUTOVACUUM PARAMETERS +#------------------------------------------------------------------------------ + +autovacuum = on # Enable autovacuum subprocess? 'on' + # requires track_counts to also be on. +#log_autovacuum_min_duration = -1 # -1 disables, 0 logs all actions and + # their durations, > 0 logs only + # actions running at least this number + # of milliseconds. +#autovacuum_max_workers = 3 # max number of autovacuum subprocesses + # (change requires restart) +#autovacuum_naptime = 1min # time between autovacuum runs +#autovacuum_vacuum_threshold = 50 # min number of row updates before + # vacuum +#autovacuum_analyze_threshold = 50 # min number of row updates before + # analyze +#autovacuum_vacuum_scale_factor = 0.2 # fraction of table size before vacuum +#autovacuum_analyze_scale_factor = 0.1 # fraction of table size before analyze +#autovacuum_freeze_max_age = 200000000 # maximum XID age before forced vacuum + # (change requires restart) +#autovacuum_multixact_freeze_max_age = 400000000 # maximum multixact age + # before forced vacuum + # (change requires restart) +#autovacuum_vacuum_cost_delay = 20ms # default vacuum cost delay for + # autovacuum, in milliseconds; + # -1 means use vacuum_cost_delay +#autovacuum_vacuum_cost_limit = -1 # default vacuum cost limit for + # autovacuum, -1 means use + # vacuum_cost_limit + + +#------------------------------------------------------------------------------ +# CLIENT CONNECTION DEFAULTS +#------------------------------------------------------------------------------ + +# - Statement Behavior - + +#search_path = '"$user", public' # schema names +#default_tablespace = '' # a tablespace name, '' uses the default +#temp_tablespaces = '' # a list of tablespace names, '' uses + # only default tablespace +#check_function_bodies = on +#default_transaction_isolation = 'read committed' +#default_transaction_read_only = off +#default_transaction_deferrable = off +#session_replication_role = 'origin' +#statement_timeout = 0 # in milliseconds, 0 is disabled +#lock_timeout = 0 # in milliseconds, 0 is disabled +#vacuum_freeze_min_age = 50000000 +#vacuum_freeze_table_age = 150000000 +#vacuum_multixact_freeze_min_age = 5000000 +#vacuum_multixact_freeze_table_age = 150000000 +#bytea_output = 'hex' # hex, escape +#xmlbinary = 'base64' +#xmloption = 'content' +#gin_pending_list_limit = 4MB + +# - Locale and Formatting - + +datestyle = 'iso, dmy' +#intervalstyle = 'postgres' +timezone = 'W-SU' +#timezone_abbreviations = 'Default' # Select the set of available time zone + # abbreviations. Currently, there are + # Default + # Australia (historical usage) + # India + # You can create your own file in + # share/timezonesets/. +#extra_float_digits = 0 # min -15, max 3 +#client_encoding = sql_ascii # actually, defaults to database + # encoding + +# These settings are initialized by initdb, but they can be changed. +lc_messages = 'en_US.UTF-8' # locale for system error message + # strings +lc_monetary = 'en_US.UTF-8' # locale for monetary formatting +lc_numeric = 'en_US.UTF-8' # locale for number formatting +lc_time = 'en_US.UTF-8' # locale for time formatting + +# default configuration for text search +default_text_search_config = 'pg_catalog.english' + +# - Other Defaults - + +#dynamic_library_path = '$libdir' +#local_preload_libraries = '' +#session_preload_libraries = '' + + +#------------------------------------------------------------------------------ +# LOCK MANAGEMENT +#------------------------------------------------------------------------------ + +#deadlock_timeout = 1s +#max_locks_per_transaction = 64 # min 10 + # (change requires restart) +# Note: Each lock table slot uses ~270 bytes of shared memory, and there are +# max_locks_per_transaction * (max_connections + max_prepared_transactions) +# lock table slots. +#max_pred_locks_per_transaction = 64 # min 10 + # (change requires restart) + + +#------------------------------------------------------------------------------ +# VERSION/PLATFORM COMPATIBILITY +#------------------------------------------------------------------------------ + +# - Previous PostgreSQL Versions - + +#array_nulls = on +#backslash_quote = safe_encoding # on, off, or safe_encoding +#default_with_oids = off +#escape_string_warning = on +#lo_compat_privileges = off +#operator_precedence_warning = off +#quote_all_identifiers = off +#sql_inheritance = on +#standard_conforming_strings = on +#synchronize_seqscans = on + +# - Other Platforms and Clients - + +#transform_null_equals = off + + +#------------------------------------------------------------------------------ +# ERROR HANDLING +#------------------------------------------------------------------------------ + +#exit_on_error = off # terminate session on any error? +#restart_after_crash = on # reinitialize after backend crash? + + +#------------------------------------------------------------------------------ +# CONFIG FILE INCLUDES +#------------------------------------------------------------------------------ + +# These options allow settings to be loaded from files other than the +# default postgresql.conf. + +#include_dir = 'conf.d' # include files ending in '.conf' from + # directory 'conf.d' +#include_if_exists = 'exists.conf' # include file only if it exists +#include = 'special.conf' # include file + + +#------------------------------------------------------------------------------ +# CUSTOMIZED OPTIONS +#------------------------------------------------------------------------------ + +# Add settings for extensions here + +multimaster.workers=8 +multimaster.queue_size=1073741824 diff --git a/tests/reinit-mm.sh b/tests/reinit-mm.sh new file mode 100755 index 0000000000..7be2ea645a --- /dev/null +++ b/tests/reinit-mm.sh @@ -0,0 +1,37 @@ +n_nodes=3 +export PATH=~/postgres_cluster/dist/bin/:$PATH +ulimit -c unlimited +pkill -9 postgres +pkill -9 arbiter +rm -fr node? *.log dtm +mkdir dtm +conn_str="" +sep="" +for ((i=1;i<=n_nodes;i++)) +do + port=$((5431+i)) + conn_str="$conn_str${sep}dbname=postgres host=127.0.0.1 port=$port sslmode=disable" + sep="," + initdb node$i +done + +echo Start DTM +~/postgres_cluster/contrib/arbiter/bin/arbiter -r 0.0.0.0:5431 -i 0 -d dtm 2> dtm.log & +sleep 2 + +echo Start nodes +for ((i=1;i<=n_nodes;i++)) +do + port=$((5431+i)) + sed "s/5432/$port/g" < postgresql.conf.mm > node$i/postgresql.conf + echo "multimaster.conn_strings = '$conn_str'" >> node$i/postgresql.conf + echo "multimaster.node_id = $i" >> node$i/postgresql.conf + cp pg_hba.conf node$i + pg_ctl -D node$i -l node$i.log start +done + +sleep 5 +echo Initialize database schema +psql postgres -f init.sql + +echo Done diff --git a/tests/run-pgbench.sh b/tests/run-pgbench.sh new file mode 100755 index 0000000000..4502148d70 --- /dev/null +++ b/tests/run-pgbench.sh @@ -0,0 +1 @@ +pgbench -M prepared -f mm.pgb -T 15 -P 1 -c 50 -j 16 -r postgres diff --git a/tests/run.sh b/tests/run.sh new file mode 100755 index 0000000000..6a01cd36d9 --- /dev/null +++ b/tests/run.sh @@ -0,0 +1,5 @@ +./dtmbench \ +-c "dbname=postgres host=localhost port=5432 sslmode=disable" \ +-c "dbname=postgres host=localhost port=5433 sslmode=disable" \ +-c "dbname=postgres host=localhost port=5434 sslmode=disable" \ +-n 1000 -a 1000 -w 10 -r 1 $* diff --git a/tests/run_perf.sh b/tests/run_perf.sh new file mode 100644 index 0000000000..ba8bd4f1ce --- /dev/null +++ b/tests/run_perf.sh @@ -0,0 +1,9 @@ +go run ./perf/*.go \ +-C "dbname=postgres user=stas port=5432 sslmode=disable" \ +-C "dbname=postgres user=stas port=5433 sslmode=disable" \ +-g -w 8 -r 1 -n 1000 -a 1000 -i + +go run ./perf/*.go \ +-C "dbname=postgres user=stas port=5432 sslmode=disable" \ +-C "dbname=postgres user=stas port=5433 sslmode=disable" \ +-g -w 8 -r 1 -n 1000 -a 1000 From 5c63dab83836f9287e3809d5193117ea3bdd9adb Mon Sep 17 00:00:00 2001 From: Fujii Masao Date: Thu, 13 Apr 2017 12:09:14 +0900 Subject: [PATCH 0002/1139] Move pg_stat_progress_vacuum to the table of Dynamic Statistics Views in doc. Previously the description about pg_stat_progress_vacuum was in the table of "Collected Statistics Views" in the doc. But since it repors dynamic information, i.e., the current progress of VACUUM, its description should be in the table of "Dynamic Statistics Views". Back-patch to 9.6 where pg_stat_progress_vacuum was added. Author: Amit Langote Discussion: http://postgr.es/m/7ab51b59-8d4d-6193-c60a-b75f222efb12@lab.ntt.co.jp --- doc/src/sgml/monitoring.sgml | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index 077642878e..dc82465105 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -316,6 +316,14 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser + + pg_stat_progress_vacuumpg_stat_progress_vacuum + One row for each backend (including autovacuum worker processes) running + VACUUM, showing current progress. + See . + + + @@ -507,12 +515,6 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser yet included in pg_stat_user_functions). - - pg_stat_progress_vacuumpg_stat_progress_vacuum - One row for each backend (including autovacuum worker processes) running - VACUUM, showing current progress. - See . - From a70b18b89459c137d7c2554133981b0752450e4e Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 13 Apr 2017 17:18:35 -0400 Subject: [PATCH 0003/1139] Fix regexport.c to behave sanely with lookaround constraints. regexport.c thought it could just ignore LACON arcs, but the correct behavior is to treat them as satisfiable while consuming zero input (rather reminiscently of commit 9f1e642d5). Otherwise, the emitted simplified-NFA representation may contain no paths leading from initial to final state, which unsurprisingly confuses pg_trgm, as seen in bug #14623 from Jeff Janes. Since regexport's output representation has no concept of an arc that consumes zero input, recurse internally to find the next normal arc(s) after any LACON transitions. We'd be forced into changing that representation if a LACON could be the last arc reaching the final state, but fortunately the regex library never builds NFAs with such a configuration, so there always is a next normal arc. Back-patch to 9.3 where this logic was introduced. Discussion: https://postgr.es/m/20170413180503.25948.94871@wrigleys.postgresql.org --- contrib/pg_trgm/expected/pg_trgm.out | 12 ++++ contrib/pg_trgm/sql/pg_trgm.sql | 3 + src/backend/regex/regexport.c | 92 ++++++++++++++++++++-------- 3 files changed, 82 insertions(+), 25 deletions(-) diff --git a/contrib/pg_trgm/expected/pg_trgm.out b/contrib/pg_trgm/expected/pg_trgm.out index 6329d9a017..e6b5793fdd 100644 --- a/contrib/pg_trgm/expected/pg_trgm.out +++ b/contrib/pg_trgm/expected/pg_trgm.out @@ -3676,6 +3676,12 @@ select * from test2 where t ~ ' z foo'; z foo bar (1 row) +select * from test2 where t ~ 'qua(?!foo)'; + t +------- + quark +(1 row) + drop index test2_idx_gin; create index test2_idx_gist on test2 using gist (t gist_trgm_ops); set enable_seqscan=off; @@ -3856,6 +3862,12 @@ select * from test2 where t ~ ' z foo'; z foo bar (1 row) +select * from test2 where t ~ 'qua(?!foo)'; + t +------- + quark +(1 row) + -- Check similarity threshold (bug #14202) CREATE TEMP TABLE restaurants (city text); INSERT INTO restaurants SELECT 'Warsaw' FROM generate_series(1, 10000); diff --git a/contrib/pg_trgm/sql/pg_trgm.sql b/contrib/pg_trgm/sql/pg_trgm.sql index 6cddda2115..eccd921d82 100644 --- a/contrib/pg_trgm/sql/pg_trgm.sql +++ b/contrib/pg_trgm/sql/pg_trgm.sql @@ -81,7 +81,9 @@ select * from test2 where t ~ 'z foo bar'; select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo'; +select * from test2 where t ~ 'qua(?!foo)'; drop index test2_idx_gin; + create index test2_idx_gist on test2 using gist (t gist_trgm_ops); set enable_seqscan=off; explain (costs off) @@ -116,6 +118,7 @@ select * from test2 where t ~ 'z foo bar'; select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo'; +select * from test2 where t ~ 'qua(?!foo)'; -- Check similarity threshold (bug #14202) diff --git a/src/backend/regex/regexport.c b/src/backend/regex/regexport.c index 93da82286f..43fbe98f77 100644 --- a/src/backend/regex/regexport.c +++ b/src/backend/regex/regexport.c @@ -6,8 +6,8 @@ * In this implementation, the NFA defines a necessary but not sufficient * condition for a string to match the regex: that is, there can be strings * that match the NFA but don't match the full regex, but not vice versa. - * Thus, for example, it is okay for the functions below to ignore lookaround - * constraints, which merely constrain the string some more. + * Thus, for example, it is okay for the functions below to treat lookaround + * constraints as no-ops, since they merely constrain the string some more. * * Notice that these functions return info into caller-provided arrays * rather than doing their own malloc's. This simplifies the APIs by @@ -28,6 +28,8 @@ #include "regex/regexport.h" +#include "miscadmin.h" + static void scancolormap(struct colormap * cm, int co, union tree * t, int level, chr partial, pg_wchar **chars, int *chars_len); @@ -76,29 +78,78 @@ pg_reg_getfinalstate(const regex_t *regex) } /* - * Get number of outgoing NFA arcs of state number "st". + * pg_reg_getnumoutarcs() and pg_reg_getoutarcs() mask the existence of LACON + * arcs from the caller, treating any LACON as being automatically satisfied. + * Since the output representation does not support arcs that consume no + * character when traversed, we have to recursively traverse LACON arcs here, + * and report whatever normal arcs are reachable by traversing LACON arcs. + * Note that this wouldn't work if it were possible to reach the final state + * via LACON traversal, but the regex library never builds NFAs that have + * LACON arcs leading directly to the final state. (This is because the + * regex executor is designed to consume one character beyond the nominal + * match end --- possibly an EOS indicator --- so there is always a set of + * ordinary arcs leading to the final state.) * - * Note: LACON arcs are ignored, both here and in pg_reg_getoutarcs(). + * traverse_lacons is a recursive subroutine used by both exported functions + * to count and then emit the reachable regular arcs. *arcs_count is + * incremented by the number of reachable arcs, and as many as will fit in + * arcs_len (possibly 0) are emitted into arcs[]. + */ +static void +traverse_lacons(struct cnfa * cnfa, int st, + int *arcs_count, + regex_arc_t *arcs, int arcs_len) +{ + struct carc *ca; + + /* + * Since this function recurses, it could theoretically be driven to stack + * overflow. In practice, this is mostly useful to backstop against a + * failure of the regex compiler to remove a loop of LACON arcs. + */ + check_stack_depth(); + + for (ca = cnfa->states[st]; ca->co != COLORLESS; ca++) + { + if (ca->co < cnfa->ncolors) + { + /* Ordinary arc, so count and possibly emit it */ + int ndx = (*arcs_count)++; + + if (ndx < arcs_len) + { + arcs[ndx].co = ca->co; + arcs[ndx].to = ca->to; + } + } + else + { + /* LACON arc --- assume it's satisfied and recurse... */ + /* ... but first, assert it doesn't lead directly to post state */ + Assert(ca->to != cnfa->post); + + traverse_lacons(cnfa, ca->to, arcs_count, arcs, arcs_len); + } + } +} + +/* + * Get number of outgoing NFA arcs of state number "st". */ int pg_reg_getnumoutarcs(const regex_t *regex, int st) { struct cnfa *cnfa; - struct carc *ca; - int count; + int arcs_count; assert(regex != NULL && regex->re_magic == REMAGIC); cnfa = &((struct guts *) regex->re_guts)->search; if (st < 0 || st >= cnfa->nstates) return 0; - count = 0; - for (ca = cnfa->states[st]; ca->co != COLORLESS; ca++) - { - if (ca->co < cnfa->ncolors) - count++; - } - return count; + arcs_count = 0; + traverse_lacons(cnfa, st, &arcs_count, NULL, 0); + return arcs_count; } /* @@ -111,24 +162,15 @@ pg_reg_getoutarcs(const regex_t *regex, int st, regex_arc_t *arcs, int arcs_len) { struct cnfa *cnfa; - struct carc *ca; + int arcs_count; assert(regex != NULL && regex->re_magic == REMAGIC); cnfa = &((struct guts *) regex->re_guts)->search; if (st < 0 || st >= cnfa->nstates || arcs_len <= 0) return; - for (ca = cnfa->states[st]; ca->co != COLORLESS; ca++) - { - if (ca->co < cnfa->ncolors) - { - arcs->co = ca->co; - arcs->to = ca->to; - arcs++; - if (--arcs_len == 0) - break; - } - } + arcs_count = 0; + traverse_lacons(cnfa, st, &arcs_count, arcs, arcs_len); } /* From d51279433cdf30d62e92bb5f5f1790e9014a0342 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 14 Apr 2017 14:52:03 -0400 Subject: [PATCH 0004/1139] Further fix pg_trgm's extraction of trigrams from regular expressions. Commit 9e43e8714 turns out to have been insufficient: not only is it necessary to track tentative parent links while considering a set of arc removals, but it's necessary to track tentative flag additions as well. This is because we always merge arc target states into arc source states; therefore, when considering a merge of the final state with some other, it is the other state that will acquire a new TSTATE_FIN bit. If there's another arc for the same color trigram that would cause merging of that state with the initial state, we failed to recognize the problem. The test cases for the prior commit evidently only exercised situations where a tentative merge with the initial state occurs before one with the final state. If it goes the other way around, we'll happily merge the initial and final states, either producing a broken final graph that would never match anything, or triggering the Assert added by the prior commit. It's tempting to consider switching the merge direction when the merge involves the final state, but I lack the time to analyze that idea in detail. Instead just keep track of the flag changes that would result from proposed merges, in the same way that the prior commit tracked proposed parent links. Along the way, add some more debugging support, because I'm not entirely confident that this is the last bug here. And tweak matters so that the transformed.dot file uses small integers rather than pointer values to identify states; that makes it more readable if you're just eyeballing it rather than fooling with Graphviz. And rename a couple of identically named struct fields to reduce confusion. Per report from Corey Csuhta. Add a test case based on his example. (Note: this case does not trigger the bug under 9.3, apparently because its different measurement of costs causes it to stop merging states before it hits the failure. I spent some time trying to find a variant that would fail in 9.3, without success; but I'm sure such cases exist.) Like the previous patch, back-patch to 9.3 where this code was added. Report: https://postgr.es/m/E2B01A4B-4530-406B-8D17-2F67CF9A16BA@csuhta.com --- contrib/pg_trgm/expected/pg_trgm.out | 19 +++- contrib/pg_trgm/sql/pg_trgm.sql | 3 + contrib/pg_trgm/trgm_regexp.c | 156 ++++++++++++++++++++------- 3 files changed, 136 insertions(+), 42 deletions(-) diff --git a/contrib/pg_trgm/expected/pg_trgm.out b/contrib/pg_trgm/expected/pg_trgm.out index e6b5793fdd..4e37a7ee10 100644 --- a/contrib/pg_trgm/expected/pg_trgm.out +++ b/contrib/pg_trgm/expected/pg_trgm.out @@ -3489,6 +3489,7 @@ create table test2(t text COLLATE "C"); insert into test2 values ('abcdef'); insert into test2 values ('quark'); insert into test2 values (' z foo bar'); +insert into test2 values ('/123/-45/'); create index test2_idx_gin on test2 using gin (t gin_trgm_ops); set enable_seqscan=off; explain (costs off) @@ -3590,7 +3591,8 @@ select * from test2 where t ~ '(abc)*$'; abcdef quark z foo bar -(3 rows) + /123/-45/ +(4 rows) select * from test2 where t ~* 'DEF'; t @@ -3682,6 +3684,12 @@ select * from test2 where t ~ 'qua(?!foo)'; quark (1 row) +select * from test2 where t ~ '/\d+/-\d'; + t +----------- + /123/-45/ +(1 row) + drop index test2_idx_gin; create index test2_idx_gist on test2 using gist (t gist_trgm_ops); set enable_seqscan=off; @@ -3776,7 +3784,8 @@ select * from test2 where t ~ '(abc)*$'; abcdef quark z foo bar -(3 rows) + /123/-45/ +(4 rows) select * from test2 where t ~* 'DEF'; t @@ -3868,6 +3877,12 @@ select * from test2 where t ~ 'qua(?!foo)'; quark (1 row) +select * from test2 where t ~ '/\d+/-\d'; + t +----------- + /123/-45/ +(1 row) + -- Check similarity threshold (bug #14202) CREATE TEMP TABLE restaurants (city text); INSERT INTO restaurants SELECT 'Warsaw' FROM generate_series(1, 10000); diff --git a/contrib/pg_trgm/sql/pg_trgm.sql b/contrib/pg_trgm/sql/pg_trgm.sql index eccd921d82..389114a63e 100644 --- a/contrib/pg_trgm/sql/pg_trgm.sql +++ b/contrib/pg_trgm/sql/pg_trgm.sql @@ -47,6 +47,7 @@ create table test2(t text COLLATE "C"); insert into test2 values ('abcdef'); insert into test2 values ('quark'); insert into test2 values (' z foo bar'); +insert into test2 values ('/123/-45/'); create index test2_idx_gin on test2 using gin (t gin_trgm_ops); set enable_seqscan=off; explain (costs off) @@ -82,6 +83,7 @@ select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo'; select * from test2 where t ~ 'qua(?!foo)'; +select * from test2 where t ~ '/\d+/-\d'; drop index test2_idx_gin; create index test2_idx_gist on test2 using gist (t gist_trgm_ops); @@ -119,6 +121,7 @@ select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo bar'; select * from test2 where t ~ ' z foo'; select * from test2 where t ~ 'qua(?!foo)'; +select * from test2 where t ~ '/\d+/-\d'; -- Check similarity threshold (bug #14202) diff --git a/contrib/pg_trgm/trgm_regexp.c b/contrib/pg_trgm/trgm_regexp.c index a2e4a61630..1ef91b3519 100644 --- a/contrib/pg_trgm/trgm_regexp.c +++ b/contrib/pg_trgm/trgm_regexp.c @@ -200,9 +200,10 @@ /* - * Uncomment to print intermediate stages, for exploring and debugging the - * algorithm implementation. This produces three graph files in /tmp, - * in Graphviz .dot format. + * Uncomment (or use -DTRGM_REGEXP_DEBUG) to print debug info, + * for exploring and debugging the algorithm implementation. + * This produces three graph files in /tmp, in Graphviz .dot format. + * Some progress information is also printed to postmaster stderr. */ /* #define TRGM_REGEXP_DEBUG */ @@ -226,7 +227,7 @@ * Penalty multipliers for trigram counts depending on whitespace contents. * Numbers based on analysis of real-life texts. */ -const float4 penalties[8] = { +static const float4 penalties[8] = { 1.0f, /* "aaa" */ 3.5f, /* "aa " */ 0.0f, /* "a a" (impossible) */ @@ -319,9 +320,12 @@ typedef struct * enterKeys - enter keys reachable from this state without reading any * predictable trigram (List of TrgmStateKey) * flags - flag bits + * snumber - number of this state (initially assigned as -1, -2, etc, + * for debugging purposes only; then at the packaging stage, + * surviving states are renumbered with positive numbers) * parent - parent state, if this state has been merged into another + * tentFlags - flags this state would acquire via planned merges * tentParent - planned parent state, if considering a merge - * number - number of this state (used at the packaging stage) */ #define TSTATE_INIT 0x01 /* flag indicating this state is initial */ #define TSTATE_FIN 0x02 /* flag indicating this state is final */ @@ -332,9 +336,10 @@ typedef struct TrgmState List *arcs; List *enterKeys; int flags; + int snumber; struct TrgmState *parent; + int tentFlags; struct TrgmState *tentParent; - int number; } TrgmState; /* @@ -361,7 +366,7 @@ typedef struct * Information about color trigram (used in stage 3) * * ctrgm - trigram itself - * number - number of this trigram (used in the packaging stage) + * cnumber - number of this trigram (used in the packaging stage) * count - number of simple trigrams created from this color trigram * expanded - indicates this color trigram is expanded into simple trigrams * arcs - list of all arcs labeled with this color trigram. @@ -369,7 +374,7 @@ typedef struct typedef struct { ColorTrgm ctrgm; - int number; + int cnumber; int count; float4 penalty; bool expanded; @@ -403,6 +408,7 @@ typedef struct /* Expanded graph (stage 2) */ HTAB *states; TrgmState *initState; + int nstates; /* Workspace for stage 2 */ List *queue; @@ -918,6 +924,7 @@ transformGraph(TrgmNFA *trgmNFA) 1024, &hashCtl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + trgmNFA->nstates = 0; /* Create initial state: ambiguous prefix, NFA's initial state */ MemSet(&initkey, 0, sizeof(initkey)); @@ -1387,9 +1394,11 @@ getState(TrgmNFA *trgmNFA, TrgmStateKey *key) state->arcs = NIL; state->enterKeys = NIL; state->flags = 0; + /* states are initially given negative numbers */ + state->snumber = -(++trgmNFA->nstates); state->parent = NULL; + state->tentFlags = 0; state->tentParent = NULL; - state->number = -1; trgmNFA->queue = lappend(trgmNFA->queue, state); } @@ -1454,10 +1463,10 @@ selectColorTrigrams(TrgmNFA *trgmNFA) ColorTrgmInfo *colorTrgms; int64 totalTrgmCount; float4 totalTrgmPenalty; - int number; + int cnumber; /* Collect color trigrams from all arcs */ - colorTrgms = (ColorTrgmInfo *) palloc(sizeof(ColorTrgmInfo) * arcsCount); + colorTrgms = (ColorTrgmInfo *) palloc0(sizeof(ColorTrgmInfo) * arcsCount); trgmNFA->colorTrgms = colorTrgms; i = 0; @@ -1470,12 +1479,15 @@ selectColorTrigrams(TrgmNFA *trgmNFA) { TrgmArc *arc = (TrgmArc *) lfirst(cell); TrgmArcInfo *arcInfo = (TrgmArcInfo *) palloc(sizeof(TrgmArcInfo)); + ColorTrgmInfo *trgmInfo = &colorTrgms[i]; arcInfo->source = state; arcInfo->target = arc->target; - colorTrgms[i].arcs = list_make1(arcInfo); - colorTrgms[i].expanded = true; - colorTrgms[i].ctrgm = arc->ctrgm; + trgmInfo->ctrgm = arc->ctrgm; + trgmInfo->cnumber = -1; + /* count and penalty will be set below */ + trgmInfo->expanded = true; + trgmInfo->arcs = list_make1(arcInfo); i++; } } @@ -1573,6 +1585,15 @@ selectColorTrigrams(TrgmNFA *trgmNFA) if (totalTrgmPenalty <= WISH_TRGM_PENALTY) break; +#ifdef TRGM_REGEXP_DEBUG + fprintf(stderr, "considering ctrgm %d %d %d, penalty %f, %d arcs\n", + trgmInfo->ctrgm.colors[0], + trgmInfo->ctrgm.colors[1], + trgmInfo->ctrgm.colors[2], + trgmInfo->penalty, + list_length(trgmInfo->arcs)); +#endif + /* * Does any arc of this color trigram connect initial and final * states? If so we can't remove it. @@ -1585,26 +1606,44 @@ selectColorTrigrams(TrgmNFA *trgmNFA) int source_flags, target_flags; +#ifdef TRGM_REGEXP_DEBUG + fprintf(stderr, "examining arc to s%d (%x) from s%d (%x)\n", + -target->snumber, target->flags, + -source->snumber, source->flags); +#endif + /* examine parent states, if any merging has already happened */ while (source->parent) source = source->parent; while (target->parent) target = target->parent; +#ifdef TRGM_REGEXP_DEBUG + fprintf(stderr, " ... after completed merges: to s%d (%x) from s%d (%x)\n", + -target->snumber, target->flags, + -source->snumber, source->flags); +#endif + /* we must also consider merges we are planning right now */ - source_flags = source->flags; + source_flags = source->flags | source->tentFlags; while (source->tentParent) { source = source->tentParent; - source_flags |= source->flags; + source_flags |= source->flags | source->tentFlags; } - target_flags = target->flags; + target_flags = target->flags | target->tentFlags; while (target->tentParent) { target = target->tentParent; - target_flags |= target->flags; + target_flags |= target->flags | target->tentFlags; } +#ifdef TRGM_REGEXP_DEBUG + fprintf(stderr, " ... after tentative merges: to s%d (%x) from s%d (%x)\n", + -target->snumber, target_flags, + -source->snumber, source_flags); +#endif + /* would fully-merged state have both INIT and FIN set? */ if (((source_flags | target_flags) & (TSTATE_INIT | TSTATE_FIN)) == (TSTATE_INIT | TSTATE_FIN)) @@ -1615,29 +1654,62 @@ selectColorTrigrams(TrgmNFA *trgmNFA) /* ok so far, so remember planned merge */ if (source != target) + { +#ifdef TRGM_REGEXP_DEBUG + fprintf(stderr, " ... tentatively merging s%d into s%d\n", + -target->snumber, -source->snumber); +#endif target->tentParent = source; + source->tentFlags |= target_flags; + } } - /* We must clear all the tentParent fields before continuing */ + /* + * We must reset all the tentFlags/tentParent fields before + * continuing. tentFlags could only have become set in states that + * are the source or parent or tentative parent of one of the current + * arcs; likewise tentParent could only have become set in states that + * are the target or parent or tentative parent of one of the current + * arcs. There might be some overlap between those sets, but if we + * clear tentFlags in target states as well as source states, we + * should be okay even if we visit a state as target before visiting + * it as a source. + */ foreach(cell, trgmInfo->arcs) { TrgmArcInfo *arcInfo = (TrgmArcInfo *) lfirst(cell); - TrgmState *target = arcInfo->target; + TrgmState *source = arcInfo->source, + *target = arcInfo->target; TrgmState *ttarget; + /* no need to touch previously-merged states */ + while (source->parent) + source = source->parent; while (target->parent) target = target->parent; + while (source) + { + source->tentFlags = 0; + source = source->tentParent; + } + while ((ttarget = target->tentParent) != NULL) { target->tentParent = NULL; + target->tentFlags = 0; /* in case it was also a source */ target = ttarget; } } /* Now, move on if we can't drop this trigram */ if (!canRemove) + { +#ifdef TRGM_REGEXP_DEBUG + fprintf(stderr, " ... not ok to merge\n"); +#endif continue; + } /* OK, merge states linked by each arc labeled by the trigram */ foreach(cell, trgmInfo->arcs) @@ -1652,6 +1724,10 @@ selectColorTrigrams(TrgmNFA *trgmNFA) target = target->parent; if (source != target) { +#ifdef TRGM_REGEXP_DEBUG + fprintf(stderr, "merging s%d into s%d\n", + -target->snumber, -source->snumber); +#endif mergeStates(source, target); /* Assert we didn't merge initial and final states */ Assert((source->flags & (TSTATE_INIT | TSTATE_FIN)) != @@ -1675,15 +1751,15 @@ selectColorTrigrams(TrgmNFA *trgmNFA) * Sort color trigrams by colors (will be useful for bsearch in packGraph) * and enumerate the color trigrams that are expanded. */ - number = 0; + cnumber = 0; qsort(colorTrgms, trgmNFA->colorTrgmsCount, sizeof(ColorTrgmInfo), colorTrgmInfoCmp); for (i = 0; i < trgmNFA->colorTrgmsCount; i++) { if (colorTrgms[i].expanded) { - colorTrgms[i].number = number; - number++; + colorTrgms[i].cnumber = cnumber; + cnumber++; } } @@ -1854,7 +1930,7 @@ colorTrgmInfoPenaltyCmp(const void *p1, const void *p2) static TrgmPackedGraph * packGraph(TrgmNFA *trgmNFA, MemoryContext rcontext) { - int number = 2, + int snumber = 2, arcIndex, arcsCount; HASH_SEQ_STATUS scan_status; @@ -1874,16 +1950,16 @@ packGraph(TrgmNFA *trgmNFA, MemoryContext rcontext) while (state->parent) state = state->parent; - if (state->number < 0) + if (state->snumber < 0) { if (state->flags & TSTATE_INIT) - state->number = 0; + state->snumber = 0; else if (state->flags & TSTATE_FIN) - state->number = 1; + state->snumber = 1; else { - state->number = number; - number++; + state->snumber = snumber; + snumber++; } } } @@ -1909,7 +1985,7 @@ packGraph(TrgmNFA *trgmNFA, MemoryContext rcontext) while (target->parent) target = target->parent; - if (source->number != target->number) + if (source->snumber != target->snumber) { ColorTrgmInfo *ctrgm; @@ -1921,9 +1997,9 @@ packGraph(TrgmNFA *trgmNFA, MemoryContext rcontext) Assert(ctrgm != NULL); Assert(ctrgm->expanded); - arcs[arcIndex].sourceState = source->number; - arcs[arcIndex].targetState = target->number; - arcs[arcIndex].colorTrgm = ctrgm->number; + arcs[arcIndex].sourceState = source->snumber; + arcs[arcIndex].targetState = target->snumber; + arcs[arcIndex].colorTrgm = ctrgm->cnumber; arcIndex++; } } @@ -1969,13 +2045,13 @@ packGraph(TrgmNFA *trgmNFA, MemoryContext rcontext) } /* Pack states and arcs information */ - result->statesCount = number; + result->statesCount = snumber; result->states = (TrgmPackedState *) - MemoryContextAlloc(rcontext, number * sizeof(TrgmPackedState)); + MemoryContextAlloc(rcontext, snumber * sizeof(TrgmPackedState)); packedArcs = (TrgmPackedArc *) MemoryContextAlloc(rcontext, arcsCount * sizeof(TrgmPackedArc)); j = 0; - for (i = 0; i < number; i++) + for (i = 0; i < snumber; i++) { int cnt = 0; @@ -2141,7 +2217,7 @@ printTrgmNFA(TrgmNFA *trgmNFA) { ListCell *cell; - appendStringInfo(&buf, "s%p", (void *) state); + appendStringInfo(&buf, "s%d", -state->snumber); if (state->flags & TSTATE_FIN) appendStringInfoString(&buf, " [shape = doublecircle]"); if (state->flags & TSTATE_INIT) @@ -2153,8 +2229,8 @@ printTrgmNFA(TrgmNFA *trgmNFA) { TrgmArc *arc = (TrgmArc *) lfirst(cell); - appendStringInfo(&buf, " s%p -> s%p [label = \"", - (void *) state, (void *) arc->target); + appendStringInfo(&buf, " s%d -> s%d [label = \"", + -state->snumber, -arc->target->snumber); printTrgmColor(&buf, arc->ctrgm.colors[0]); appendStringInfoChar(&buf, ' '); printTrgmColor(&buf, arc->ctrgm.colors[1]); @@ -2167,7 +2243,7 @@ printTrgmNFA(TrgmNFA *trgmNFA) if (initstate) { appendStringInfoString(&buf, " node [shape = point ]; initial;\n"); - appendStringInfo(&buf, " initial -> s%p;\n", (void *) initstate); + appendStringInfo(&buf, " initial -> s%d;\n", -initstate->snumber); } appendStringInfoString(&buf, "}\n"); From 9c225acf0b97a7a3a5ca1a12ee0e89c98cf16442 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 15 Apr 2017 16:23:27 -0400 Subject: [PATCH 0005/1139] Avoid passing function pointers across process boundaries. This back-patches commit 32470825d36d99a81347ee36c181d609c952c061 into 9.6, primarily to make buildfarm member culicidae happy. Unlike the HEAD patch, avoid changing the existing API of CreateParallelContext; instead we just switch to using CreateParallelContextForExternalFunction, even for core functions. Petr Jelinek, with a bunch of basically-cosmetic adjustments by me Discussion: https://postgr.es/m/548f9c1d-eafa-e3fa-9da8-f0cc2f654e60@2ndquadrant.com --- src/backend/access/transam/README.parallel | 2 +- src/backend/access/transam/parallel.c | 145 +++++++++++++++------ src/backend/executor/execParallel.c | 7 +- src/backend/postmaster/bgworker.c | 103 ++++++++------- src/include/executor/execParallel.h | 2 + 5 files changed, 167 insertions(+), 92 deletions(-) diff --git a/src/backend/access/transam/README.parallel b/src/backend/access/transam/README.parallel index db9ac3d504..61d54dc550 100644 --- a/src/backend/access/transam/README.parallel +++ b/src/backend/access/transam/README.parallel @@ -198,7 +198,7 @@ pattern looks like this: EnterParallelMode(); /* prohibit unsafe state changes */ - pcxt = CreateParallelContext(entrypoint, nworkers); + pcxt = CreateParallelContextForExternalFunction("library_name", "function_name", nworkers); /* Allow space for application-specific data here. */ shm_toc_estimate_chunk(&pcxt->estimator, size); diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c index d2bed72705..867ccf855d 100644 --- a/src/backend/access/transam/parallel.c +++ b/src/backend/access/transam/parallel.c @@ -19,6 +19,7 @@ #include "access/xlog.h" #include "catalog/namespace.h" #include "commands/async.h" +#include "executor/execParallel.h" #include "libpq/libpq.h" #include "libpq/pqformat.h" #include "libpq/pqmq.h" @@ -60,7 +61,7 @@ #define PARALLEL_KEY_TRANSACTION_SNAPSHOT UINT64CONST(0xFFFFFFFFFFFF0006) #define PARALLEL_KEY_ACTIVE_SNAPSHOT UINT64CONST(0xFFFFFFFFFFFF0007) #define PARALLEL_KEY_TRANSACTION_STATE UINT64CONST(0xFFFFFFFFFFFF0008) -#define PARALLEL_KEY_EXTENSION_TRAMPOLINE UINT64CONST(0xFFFFFFFFFFFF0009) +#define PARALLEL_KEY_ENTRYPOINT UINT64CONST(0xFFFFFFFFFFFF0009) /* Fixed-size parallel state. */ typedef struct FixedParallelState @@ -76,7 +77,7 @@ typedef struct FixedParallelState pid_t parallel_master_pid; BackendId parallel_master_backend_id; - /* Entrypoint for parallel workers. */ + /* Entrypoint for parallel workers (deprecated)! */ parallel_worker_main_type entrypoint; /* Mutex protects remaining fields. */ @@ -106,16 +107,36 @@ static FixedParallelState *MyFixedParallelState; /* List of active parallel contexts. */ static dlist_head pcxt_list = DLIST_STATIC_INIT(pcxt_list); +/* + * List of internal parallel worker entry points. We need this for + * reasons explained in LookupParallelWorkerFunction(), below. + */ +static const struct +{ + const char *fn_name; + parallel_worker_main_type fn_addr; +} InternalParallelWorkers[] = + +{ + { + "ParallelQueryMain", ParallelQueryMain + } +}; + /* Private functions. */ static void HandleParallelMessage(ParallelContext *pcxt, int i, StringInfo msg); -static void ParallelExtensionTrampoline(dsm_segment *seg, shm_toc *toc); static void WaitForParallelWorkersToExit(ParallelContext *pcxt); +static parallel_worker_main_type LookupParallelWorkerFunction(char *libraryname, char *funcname); /* * Establish a new parallel context. This should be done after entering * parallel mode, and (unless there is an error) the context should be * destroyed before exiting the current subtransaction. + * + * NB: specifying the entrypoint as a function address is unportable. + * This will go away in Postgres 10, in favor of the API provided by + * CreateParallelContextForExternalFunction; in the meantime use that. */ ParallelContext * CreateParallelContext(parallel_worker_main_type entrypoint, int nworkers) @@ -163,9 +184,9 @@ CreateParallelContext(parallel_worker_main_type entrypoint, int nworkers) } /* - * Establish a new parallel context that calls a function provided by an - * extension. This works around the fact that the library might get mapped - * at a different address in each backend. + * Establish a new parallel context that calls a function specified by name. + * Unlike CreateParallelContext, this is robust against possible differences + * in address space layout between different processes. */ ParallelContext * CreateParallelContextForExternalFunction(char *library_name, @@ -179,7 +200,7 @@ CreateParallelContextForExternalFunction(char *library_name, oldcontext = MemoryContextSwitchTo(TopTransactionContext); /* Create the context. */ - pcxt = CreateParallelContext(ParallelExtensionTrampoline, nworkers); + pcxt = CreateParallelContext(NULL, nworkers); pcxt->library_name = pstrdup(library_name); pcxt->function_name = pstrdup(function_name); @@ -248,10 +269,9 @@ InitializeParallelDSM(ParallelContext *pcxt) pcxt->nworkers)); shm_toc_estimate_keys(&pcxt->estimator, 1); - /* Estimate how much we'll need for extension entrypoint info. */ + /* Estimate how much we'll need for entrypoint info. */ if (pcxt->library_name != NULL) { - Assert(pcxt->entrypoint == ParallelExtensionTrampoline); Assert(pcxt->function_name != NULL); shm_toc_estimate_chunk(&pcxt->estimator, strlen(pcxt->library_name) + strlen(pcxt->function_name) + 2); @@ -367,7 +387,7 @@ InitializeParallelDSM(ParallelContext *pcxt) } shm_toc_insert(pcxt->toc, PARALLEL_KEY_ERROR_QUEUE, error_queue_space); - /* Serialize extension entrypoint information. */ + /* Serialize entrypoint information. */ if (pcxt->library_name != NULL) { Size lnamelen = strlen(pcxt->library_name); @@ -377,7 +397,7 @@ InitializeParallelDSM(ParallelContext *pcxt) + strlen(pcxt->function_name) + 2); strcpy(extensionstate, pcxt->library_name); strcpy(extensionstate + lnamelen + 1, pcxt->function_name); - shm_toc_insert(pcxt->toc, PARALLEL_KEY_EXTENSION_TRAMPOLINE, + shm_toc_insert(pcxt->toc, PARALLEL_KEY_ENTRYPOINT, extensionstate); } } @@ -669,6 +689,10 @@ DestroyParallelContext(ParallelContext *pcxt) } /* Free memory. */ + if (pcxt->library_name) + pfree(pcxt->library_name); + if (pcxt->function_name) + pfree(pcxt->function_name); pfree(pcxt); } @@ -939,6 +963,8 @@ ParallelWorkerMain(Datum main_arg) shm_mq *mq; shm_mq_handle *mqh; char *libraryspace; + char *entrypointstate; + parallel_worker_main_type entrypt; char *gucspace; char *combocidspace; char *tsnapspace; @@ -1038,6 +1064,25 @@ ParallelWorkerMain(Datum main_arg) Assert(libraryspace != NULL); RestoreLibraryState(libraryspace); + /* + * Identify the entry point to be called. In theory this could result in + * loading an additional library, though most likely the entry point is in + * the core backend or in a library we just loaded. + */ + entrypointstate = shm_toc_lookup(toc, PARALLEL_KEY_ENTRYPOINT); + if (entrypointstate != NULL) + { + char *library_name; + char *function_name; + + library_name = entrypointstate; + function_name = entrypointstate + strlen(library_name) + 1; + + entrypt = LookupParallelWorkerFunction(library_name, function_name); + } + else + entrypt = fps->entrypoint; + /* Restore database connection. */ BackgroundWorkerInitializeConnectionByOid(fps->database_id, fps->authenticated_user_id); @@ -1101,10 +1146,11 @@ ParallelWorkerMain(Datum main_arg) /* * Time to do the real work: invoke the caller-supplied code. * - * If you get a crash at this line, see the comments for - * ParallelExtensionTrampoline. + * If you get a crash at this line, try using + * CreateParallelContextForExternalFunction instead of + * CreateParallelContext. */ - fps->entrypoint(seg, toc); + entrypt(seg, toc); /* Must exit parallel mode to pop active snapshot. */ ExitParallelMode(); @@ -1119,33 +1165,6 @@ ParallelWorkerMain(Datum main_arg) pq_putmessage('X', NULL, 0); } -/* - * It's unsafe for the entrypoint invoked by ParallelWorkerMain to be a - * function living in a dynamically loaded module, because the module might - * not be loaded in every process, or might be loaded but not at the same - * address. To work around that problem, CreateParallelContextForExtension() - * arranges to call this function rather than calling the extension-provided - * function directly; and this function then looks up the real entrypoint and - * calls it. - */ -static void -ParallelExtensionTrampoline(dsm_segment *seg, shm_toc *toc) -{ - char *extensionstate; - char *library_name; - char *function_name; - parallel_worker_main_type entrypt; - - extensionstate = shm_toc_lookup(toc, PARALLEL_KEY_EXTENSION_TRAMPOLINE); - Assert(extensionstate != NULL); - library_name = extensionstate; - function_name = extensionstate + strlen(library_name) + 1; - - entrypt = (parallel_worker_main_type) - load_external_function(library_name, function_name, true, NULL); - entrypt(seg, toc); -} - /* * Update shared memory with the ending location of the last WAL record we * wrote, if it's greater than the value already stored there. @@ -1161,3 +1180,47 @@ ParallelWorkerReportLastRecEnd(XLogRecPtr last_xlog_end) fps->last_xlog_end = last_xlog_end; SpinLockRelease(&fps->mutex); } + +/* + * Look up (and possibly load) a parallel worker entry point function. + * + * For functions contained in the core code, we use library name "postgres" + * and consult the InternalParallelWorkers array. External functions are + * looked up, and loaded if necessary, using load_external_function(). + * + * The point of this is to pass function names as strings across process + * boundaries. We can't pass actual function addresses because of the + * possibility that the function has been loaded at a different address + * in a different process. This is obviously a hazard for functions in + * loadable libraries, but it can happen even for functions in the core code + * on platforms using EXEC_BACKEND (e.g., Windows). + * + * At some point it might be worthwhile to get rid of InternalParallelWorkers[] + * in favor of applying load_external_function() for core functions too; + * but that raises portability issues that are not worth addressing now. + */ +static parallel_worker_main_type +LookupParallelWorkerFunction(char *libraryname, char *funcname) +{ + /* + * If the function is to be loaded from postgres itself, search the + * InternalParallelWorkers array. + */ + if (strcmp(libraryname, "postgres") == 0) + { + int i; + + for (i = 0; i < lengthof(InternalParallelWorkers); i++) + { + if (strcmp(InternalParallelWorkers[i].fn_name, funcname) == 0) + return InternalParallelWorkers[i].fn_addr; + } + + /* We can only reach this by programming error. */ + elog(ERROR, "internal function \"%s\" not found", funcname); + } + + /* Otherwise load from external library. */ + return (parallel_worker_main_type) + load_external_function(libraryname, funcname, true, NULL); +} diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c index 96e2ac06b8..4741aec46d 100644 --- a/src/backend/executor/execParallel.c +++ b/src/backend/executor/execParallel.c @@ -105,8 +105,7 @@ static shm_mq_handle **ExecParallelSetupTupleQueues(ParallelContext *pcxt, static bool ExecParallelRetrieveInstrumentation(PlanState *planstate, SharedExecutorInstrumentation *instrumentation); -/* Helper functions that run in the parallel worker. */ -static void ParallelQueryMain(dsm_segment *seg, shm_toc *toc); +/* Helper function that runs in the parallel worker. */ static DestReceiver *ExecParallelGetReceiver(dsm_segment *seg, shm_toc *toc); /* @@ -355,7 +354,7 @@ ExecInitParallelPlan(PlanState *planstate, EState *estate, int nworkers) pstmt_data = ExecSerializePlan(planstate->plan, estate); /* Create a parallel context. */ - pcxt = CreateParallelContext(ParallelQueryMain, nworkers); + pcxt = CreateParallelContextForExternalFunction("postgres", "ParallelQueryMain", nworkers); pei->pcxt = pcxt; /* @@ -720,7 +719,7 @@ ExecParallelInitializeWorker(PlanState *planstate, shm_toc *toc) * to do this are also stored in the dsm_segment and can be accessed through * the shm_toc. */ -static void +void ParallelQueryMain(dsm_segment *seg, shm_toc *toc) { BufferUsage *buffer_usage; diff --git a/src/backend/postmaster/bgworker.c b/src/backend/postmaster/bgworker.c index 5ea5abff8d..ff266009fc 100644 --- a/src/backend/postmaster/bgworker.c +++ b/src/backend/postmaster/bgworker.c @@ -95,23 +95,24 @@ struct BackgroundWorkerHandle static BackgroundWorkerArray *BackgroundWorkerData; /* - * List of internal background workers. These are used for mapping the - * function name to actual function when building with EXEC_BACKEND and also - * to allow these to be loaded outside of shared_preload_libraries. + * List of internal background worker entry points. We need this for + * reasons explained in LookupBackgroundWorkerFunction(), below. */ -typedef struct InternalBGWorkerMain +static const struct { - char *bgw_function_name; - bgworker_main_type bgw_main; -} InternalBGWorkerMain; - -static const InternalBGWorkerMain InternalBGWorkers[] = { - {"ParallelWorkerMain", ParallelWorkerMain}, - /* Dummy entry marking end of the array. */ - {NULL, NULL} + const char *fn_name; + bgworker_main_type fn_addr; +} InternalBGWorkers[] = + +{ + { + "ParallelWorkerMain", ParallelWorkerMain + } }; -static bgworker_main_type GetInternalBgWorkerMain(BackgroundWorker *worker); +/* Private functions. */ +static bgworker_main_type LookupBackgroundWorkerFunction(char *libraryname, char *funcname); + /* * Calculate shared memory needed. @@ -715,27 +716,18 @@ StartBackgroundWorker(void) #endif } - /* For internal workers set the entry point to known function address. */ - entrypt = GetInternalBgWorkerMain(worker); - /* - * Otherwise, if bgw_main is set, we use that value as the initial - * entrypoint. This does not work well EXEC_BACKEND outside Windows but - * we keep the logic for backwards compatibility. In other cases use - * the entry point specified by library name (which will be loaded, if - * necessary) and a function name (which will be looked up in the named - * library). + * If bgw_main is set, we use that value as the entry point function. + * Passing function addresses across processes is unreliable on many + * platforms, but we'll leave the option in place in 9.x for backwards + * compatibility. Otherwise, look up the entry point function, loading + * its library if necessary. */ - if (entrypt == NULL) - { - if (worker->bgw_main != NULL) - entrypt = worker->bgw_main; - else - entrypt = (bgworker_main_type) - load_external_function(worker->bgw_library_name, - worker->bgw_function_name, - true, NULL); - } + if (worker->bgw_main != NULL) + entrypt = worker->bgw_main; + else + entrypt = LookupBackgroundWorkerFunction(worker->bgw_library_name, + worker->bgw_function_name); /* * Note that in normal processes, we would call InitPostgres here. For a @@ -1077,26 +1069,45 @@ TerminateBackgroundWorker(BackgroundWorkerHandle *handle) } /* - * Search the known internal worker array and return its main function - * pointer if found. + * Look up (and possibly load) a bgworker entry point function. * - * Returns NULL if not known internal worker. + * For functions contained in the core code, we use library name "postgres" + * and consult the InternalBGWorkers array. External functions are + * looked up, and loaded if necessary, using load_external_function(). + * + * The point of this is to pass function names as strings across process + * boundaries. We can't pass actual function addresses because of the + * possibility that the function has been loaded at a different address + * in a different process. This is obviously a hazard for functions in + * loadable libraries, but it can happen even for functions in the core code + * on platforms using EXEC_BACKEND (e.g., Windows). + * + * At some point it might be worthwhile to get rid of InternalBGWorkers[] + * in favor of applying load_external_function() for core functions too; + * but that raises portability issues that are not worth addressing now. */ static bgworker_main_type -GetInternalBgWorkerMain(BackgroundWorker *worker) +LookupBackgroundWorkerFunction(char *libraryname, char *funcname) { - int i; + /* + * If the function is to be loaded from postgres itself, search the + * InternalBGWorkers array. + */ + if (strcmp(libraryname, "postgres") == 0) + { + int i; - /* Internal workers always have to use postgres as library name. */ - if (strncmp(worker->bgw_library_name, "postgres", BGW_MAXLEN) != 0) - return NULL; + for (i = 0; i < lengthof(InternalBGWorkers); i++) + { + if (strcmp(InternalBGWorkers[i].fn_name, funcname) == 0) + return InternalBGWorkers[i].fn_addr; + } - for (i = 0; InternalBGWorkers[i].bgw_function_name; i++) - { - if (strncmp(InternalBGWorkers[i].bgw_function_name, - worker->bgw_function_name, BGW_MAXLEN) == 0) - return InternalBGWorkers[i].bgw_main; + /* We can only reach this by programming error. */ + elog(ERROR, "internal function \"%s\" not found", funcname); } - return NULL; + /* Otherwise load from external library. */ + return (bgworker_main_type) + load_external_function(libraryname, funcname, true, NULL); } diff --git a/src/include/executor/execParallel.h b/src/include/executor/execParallel.h index f4c6d37a11..42424d1b5c 100644 --- a/src/include/executor/execParallel.h +++ b/src/include/executor/execParallel.h @@ -36,4 +36,6 @@ extern void ExecParallelFinish(ParallelExecutorInfo *pei); extern void ExecParallelCleanup(ParallelExecutorInfo *pei); extern void ExecParallelReinitialize(ParallelExecutorInfo *pei); +extern void ParallelQueryMain(dsm_segment *seg, shm_toc *toc); + #endif /* EXECPARALLEL_H */ From a30f146db4e75379c5b5e733027a0013e542d3ed Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 15 Apr 2017 17:27:38 -0400 Subject: [PATCH 0006/1139] Provide a way to control SysV shmem attach address in EXEC_BACKEND builds. In standard non-Windows builds, there's no particular reason to care what address the kernel chooses to map the shared memory segment at. However, when building with EXEC_BACKEND, there's a risk that the chosen address won't be available in all child processes. Linux with ASLR enabled (which it is by default) seems particularly at risk because it puts shmem segments into the same area where it maps shared libraries. We can work around that by specifying a mapping address that's outside the range where shared libraries could get mapped. On x86_64 Linux, 0x7e0000000000 seems to work well. This is only meant for testing/debugging purposes, so it doesn't seem necessary to go as far as providing a GUC (or any user-visible documentation, though we might change that later). Instead, it's just controlled by setting an environment variable PG_SHMEM_ADDR to the desired attach address. Back-patch to all supported branches, since the point here is to remove intermittent buildfarm failures on EXEC_BACKEND animals. Owners of affected animals will need to add a suitable setting of PG_SHMEM_ADDR to their build_env configuration. Discussion: https://postgr.es/m/7036.1492231361@sss.pgh.pa.us --- src/backend/port/sysv_shmem.c | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c index 1ad898d350..850eafddc3 100644 --- a/src/backend/port/sysv_shmem.c +++ b/src/backend/port/sysv_shmem.c @@ -102,8 +102,28 @@ static void * InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size) { IpcMemoryId shmid; + void *requestedAddress = NULL; void *memAddress; + /* + * Normally we just pass requestedAddress = NULL to shmat(), allowing the + * system to choose where the segment gets mapped. But in an EXEC_BACKEND + * build, it's possible for whatever is chosen in the postmaster to not + * work for backends, due to variations in address space layout. As a + * rather klugy workaround, allow the user to specify the address to use + * via setting the environment variable PG_SHMEM_ADDR. (If this were of + * interest for anything except debugging, we'd probably create a cleaner + * and better-documented way to set it, such as a GUC.) + */ +#ifdef EXEC_BACKEND + { + char *pg_shmem_addr = getenv("PG_SHMEM_ADDR"); + + if (pg_shmem_addr) + requestedAddress = (void *) strtoul(pg_shmem_addr, NULL, 0); + } +#endif + shmid = shmget(memKey, size, IPC_CREAT | IPC_EXCL | IPCProtection); if (shmid < 0) @@ -203,10 +223,11 @@ InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size) on_shmem_exit(IpcMemoryDelete, Int32GetDatum(shmid)); /* OK, should be able to attach to the segment */ - memAddress = shmat(shmid, NULL, PG_SHMAT_FLAGS); + memAddress = shmat(shmid, requestedAddress, PG_SHMAT_FLAGS); if (memAddress == (void *) -1) - elog(FATAL, "shmat(id=%d) failed: %m", shmid); + elog(FATAL, "shmat(id=%d, addr=%p, flags=0x%x) failed: %m", + shmid, requestedAddress, PG_SHMAT_FLAGS); /* Register on-exit routine to detach new segment before deleting */ on_shmem_exit(IpcMemoryDetach, PointerGetDatum(memAddress)); From 1ec36a9eb4c29dc49838319d1e666f66961d757c Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Sun, 16 Apr 2017 20:49:40 -0400 Subject: [PATCH 0007/1139] Fix compiler warning Introduced by 41306a511c01dd299115cf447858a00e34aebbf6, happens with gcc 4.7.2. --- src/backend/catalog/objectaddress.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/backend/catalog/objectaddress.c b/src/backend/catalog/objectaddress.c index 8ccc171d03..68ba35248c 100644 --- a/src/backend/catalog/objectaddress.c +++ b/src/backend/catalog/objectaddress.c @@ -1578,8 +1578,8 @@ get_object_address_opf_member(ObjectType objtype, ObjectAddress address; ListCell *cell; List *copy; - TypeName *typenames[2]; - Oid typeoids[2]; + TypeName *typenames[2] = { NULL, NULL }; + Oid typeoids[2] = { InvalidOid, InvalidOid }; int membernum; int i; From 6c73b390b4797c6b81ee4f5d17feda34cfde6ccd Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 17 Apr 2017 15:29:00 -0400 Subject: [PATCH 0008/1139] Always build a custom plan node's targetlist from the path's pathtarget. We were applying the use_physical_tlist optimization to all relation scan plans, even those implemented by custom scan providers. However, that's a bad idea for a couple of reasons. The custom provider might be unable to provide columns that it hadn't expected to be asked for (for example, the custom scan might depend on an index-only scan). Even more to the point, there's no good reason to suppose that this "optimization" is a win for a custom scan; whatever the custom provider is doing is likely not based on simply returning physical heap tuples. (As a counterexample, if the custom scan is an interface to a column store, demanding all columns would be a huge loss.) If it is a win, the custom provider could make that decision for itself and insert a suitable pathtarget into the path, anyway. Per discussion with Dmitry Ivanov. Back-patch to 9.5 where custom scan support was introduced. The argument that the custom provider can adjust the behavior by changing the pathtarget only applies to 9.6+, but on balance it seems more likely that use_physical_tlist will hurt custom scans than help them. Discussion: https://postgr.es/m/e29ddd30-8ef9-4da5-a50b-2bb7b8c7198d@postgrespro.ru --- src/backend/optimizer/plan/createplan.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index 71678d08dc..6f1166b703 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -761,6 +761,15 @@ use_physical_tlist(PlannerInfo *root, Path *path, int flags) if (rel->reloptkind != RELOPT_BASEREL) return false; + /* + * Also, don't do it to a CustomPath; the premise that we're extracting + * columns from a simple physical tuple is unlikely to hold for those. + * (When it does make sense, the custom path creator can set up the path's + * pathtarget that way.) + */ + if (IsA(path, CustomPath)) + return false; + /* * Can't do it if any system columns or whole-row Vars are requested. * (This could possibly be fixed but would take some fragile assumptions From f07f6b62c9a7853d7bac2de6316b1b0f96a688c4 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 21 Apr 2017 15:55:56 -0400 Subject: [PATCH 0009/1139] Avoid depending on non-POSIX behavior of fcntl(2). The POSIX standard does not say that the success return value for fcntl(F_SETFD) and fcntl(F_SETFL) is zero; it says only that it's not -1. We had several calls that were making the stronger assumption. Adjust them to test specifically for -1 for strict spec compliance. The standard further leaves open the possibility that the O_NONBLOCK flag bit is not the only active one in F_SETFL's argument. Formally, therefore, one ought to get the current flags with F_GETFL and store them back with only the O_NONBLOCK bit changed when trying to change the nonblock state. In port/noblock.c, we were doing the full pushup in pg_set_block but not in pg_set_noblock, which is just weird. Make both of them do it properly, since they have little business making any assumptions about the socket they're handed. The other places where we're issuing F_SETFL are working with FDs we just got from pipe(2), so it's reasonable to assume the FDs' properties are all default, so I didn't bother adding F_GETFL steps there. Also, while pg_set_block deserves some points for trying to do things right, somebody had decided that it'd be even better to cast fcntl's third argument to "long". Which is completely loony, because POSIX clearly says the third argument for an F_SETFL call is "int". Given the lack of field complaints, these missteps apparently are not of significance on any common platforms. But they're still wrong, so back-patch to all supported branches. Discussion: https://postgr.es/m/30882.1492800880@sss.pgh.pa.us --- src/backend/postmaster/postmaster.c | 4 ++-- src/backend/storage/ipc/latch.c | 4 ++-- src/bin/pg_test_fsync/pg_test_fsync.c | 1 + src/port/noblock.c | 24 ++++++++++++++++++++---- 4 files changed, 25 insertions(+), 8 deletions(-) diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 533252a258..218915f3be 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -6214,7 +6214,7 @@ InitPostmasterDeathWatchHandle(void) * write fd. That is taken care of in ClosePostmasterPorts(). */ Assert(MyProcPid == PostmasterPid); - if (pipe(postmaster_alive_fds)) + if (pipe(postmaster_alive_fds) < 0) ereport(FATAL, (errcode_for_file_access(), errmsg_internal("could not create pipe to monitor postmaster death: %m"))); @@ -6223,7 +6223,7 @@ InitPostmasterDeathWatchHandle(void) * Set O_NONBLOCK to allow testing for the fd's presence with a read() * call. */ - if (fcntl(postmaster_alive_fds[POSTMASTER_FD_WATCH], F_SETFL, O_NONBLOCK)) + if (fcntl(postmaster_alive_fds[POSTMASTER_FD_WATCH], F_SETFL, O_NONBLOCK) == -1) ereport(FATAL, (errcode_for_socket_access(), errmsg_internal("could not set postmaster death monitoring pipe to nonblocking mode: %m"))); diff --git a/src/backend/storage/ipc/latch.c b/src/backend/storage/ipc/latch.c index 3e0c4689db..cac72ae428 100644 --- a/src/backend/storage/ipc/latch.c +++ b/src/backend/storage/ipc/latch.c @@ -169,9 +169,9 @@ InitializeLatchSupport(void) */ if (pipe(pipefd) < 0) elog(FATAL, "pipe() failed: %m"); - if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) < 0) + if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) == -1) elog(FATAL, "fcntl() failed on read-end of self-pipe: %m"); - if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) < 0) + if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) == -1) elog(FATAL, "fcntl() failed on write-end of self-pipe: %m"); selfpipe_readfd = pipefd[0]; diff --git a/src/bin/pg_test_fsync/pg_test_fsync.c b/src/bin/pg_test_fsync/pg_test_fsync.c index c8427623d2..b4f3551b94 100644 --- a/src/bin/pg_test_fsync/pg_test_fsync.c +++ b/src/bin/pg_test_fsync/pg_test_fsync.c @@ -7,6 +7,7 @@ #include #include +#include #include #include #include diff --git a/src/port/noblock.c b/src/port/noblock.c index 52e1d71d9d..959d3ada86 100644 --- a/src/port/noblock.c +++ b/src/port/noblock.c @@ -1,7 +1,7 @@ /*------------------------------------------------------------------------- * * noblock.c - * set a file descriptor as non-blocking + * set a file descriptor as blocking or non-blocking * * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California @@ -17,11 +17,22 @@ #include +/* + * Put socket into nonblock mode. + * Returns true on success, false on failure. + */ bool pg_set_noblock(pgsocket sock) { #if !defined(WIN32) - return (fcntl(sock, F_SETFL, O_NONBLOCK) != -1); + int flags; + + flags = fcntl(sock, F_GETFL); + if (flags < 0) + return false; + if (fcntl(sock, F_SETFL, (flags | O_NONBLOCK)) == -1) + return false; + return true; #else unsigned long ioctlsocket_ret = 1; @@ -30,7 +41,10 @@ pg_set_noblock(pgsocket sock) #endif } - +/* + * Put socket into blocking mode. + * Returns true on success, false on failure. + */ bool pg_set_block(pgsocket sock) { @@ -38,7 +52,9 @@ pg_set_block(pgsocket sock) int flags; flags = fcntl(sock, F_GETFL); - if (flags < 0 || fcntl(sock, F_SETFL, (long) (flags & ~O_NONBLOCK))) + if (flags < 0) + return false; + if (fcntl(sock, F_SETFL, (flags & ~O_NONBLOCK)) == -1) return false; return true; #else From 95a23165fd9d0a3e8d3d5b8637237d2b7d93783c Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Fri, 21 Apr 2017 19:42:01 -0400 Subject: [PATCH 0010/1139] doc: Update link The reference "That is the topic of the next section." has been incorrect since the materialized views documentation got inserted between the section "rules-views" and "rules-update". Author: Zertrin --- doc/src/sgml/rules.sgml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/src/sgml/rules.sgml b/doc/src/sgml/rules.sgml index ca1b767d69..bcbc170335 100644 --- a/doc/src/sgml/rules.sgml +++ b/doc/src/sgml/rules.sgml @@ -862,7 +862,7 @@ SELECT t1.a, t2.b, t1.ctid FROM t1, t2 WHERE t1.a = t2.a; UPDATE, and DELETE commands on a view. These rules will rewrite the command, typically into a command that updates one or more tables, rather than views. That is the topic - of the next section. + of . From 551cc9af57814a93f809bc907a21595c0771b1a6 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 22 Apr 2017 16:58:15 -0400 Subject: [PATCH 0011/1139] Make PostgresNode::append_conf append a newline automatically. Although the documentation for append_conf said clearly that it didn't add a newline, many test authors seem to have forgotten that ... or maybe they just consulted the example at the top of the POD documentation, which clearly shows adding a config entry without bothering to add a trailing newline. The worst part of that is that it works, as long as you don't do it more than once, since the backend isn't picky about whether config files end with newlines. So there's not a strong forcing function reminding test authors not to do it like that. Upshot is that this is a terribly fragile way to go about things, and there's at least one existing test case that is demonstrably broken and not testing what it thinks it is. Let's just make append_conf append a newline, instead; that is clearly way safer than the old definition. I also cleaned up a few call sites that were unnecessarily ugly. (I left things alone in places where it's plausible that additional config lines would need to be added someday.) Back-patch the change in append_conf itself to 9.6 where it was added, as having a definitional inconsistency between branches would obviously be pretty hazardous for back-patching TAP tests. The other changes are just cosmetic and don't need to be back-patched. Discussion: https://postgr.es/m/19751.1492892376@sss.pgh.pa.us --- src/test/perl/PostgresNode.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm index bd627b29de..b55f8bf57e 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgresNode.pm @@ -441,7 +441,7 @@ A shortcut method to append to files like pg_hba.conf and postgresql.conf. Does no validation or sanity checking. Does not reload the configuration after writing. -A newline is NOT automatically appended to the string. +A newline is automatically appended to the string. =cut @@ -451,7 +451,7 @@ sub append_conf my $conffile = $self->data_dir . '/' . $filename; - TestLib::append_to_file($conffile, $str); + TestLib::append_to_file($conffile, $str . "\n"); } =pod From 9d5f0718d75772265b476e41f8a7e97dd8856710 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 22 Apr 2017 18:18:25 -0400 Subject: [PATCH 0012/1139] Make PostgresNode.pm check server status more carefully. PostgresNode blithely ignored the exit status of pg_ctl, and in general made no effort to be sure that the server was running when it should be. This caused it to miss server crashes, which is a serious shortcoming in a test scaffold. Make it complain if pg_ctl fails, and modify the start and stop logic to complain if the server doesn't start, or doesn't stop, when expected. Also, have it turn off the "restart_after_crash" configuration parameter in created clusters, as bitter experience has shown that leaving that on can mask crashes too. We might at some point need variant functions that allow for, eg, server start failure to be expected. But no existing test case appears to want that, and it surely shouldn't be the default behavior. Note that this *will* break the buildfarm, as it will expose known bugs that the previous testing failed to. I'm committing it despite that, to verify that we get the expected failures in the buildfarm not just in manual testing. Back-patch into 9.6 where PostgresNode was introduced. (The 9.6 branch is not expected to show any failures.) Discussion: https://postgr.es/m/21432.1492886428@sss.pgh.pa.us --- src/test/perl/PostgresNode.pm | 42 ++++++++++++++++++++++------------- 1 file changed, 26 insertions(+), 16 deletions(-) diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm index b55f8bf57e..20bc90b007 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgresNode.pm @@ -402,6 +402,7 @@ sub init open my $conf, ">>$pgdata/postgresql.conf"; print $conf "\n# Added by PostgresNode.pm\n"; print $conf "fsync = off\n"; + print $conf "restart_after_crash = off\n"; print $conf "log_statement = all\n"; print $conf "port = $port\n"; @@ -636,18 +637,19 @@ sub start my $port = $self->port; my $pgdata = $self->data_dir; my $name = $self->name; + BAIL_OUT("node \"$name\" is already running") if defined $self->{_pid}; print("### Starting node \"$name\"\n"); my $ret = TestLib::system_log('pg_ctl', '-w', '-D', $self->data_dir, '-l', $self->logfile, 'start'); if ($ret != 0) { - print "# pg_ctl failed; logfile:\n"; + print "# pg_ctl start failed; logfile:\n"; print TestLib::slurp_file($self->logfile); - BAIL_OUT("pg_ctl failed"); + BAIL_OUT("pg_ctl start failed"); } - $self->_update_pid; + $self->_update_pid(1); } =pod @@ -656,6 +658,10 @@ sub start Stop the node using pg_ctl -m $mode and wait for it to stop. +Note: if the node is already known stopped, this does nothing. +However, if we think it's running and it's not, it's important for +this to fail. Otherwise, tests might fail to detect server crashes. + =cut sub stop @@ -667,9 +673,8 @@ sub stop $mode = 'fast' unless defined $mode; return unless defined $self->{_pid}; print "### Stopping node \"$name\" using mode $mode\n"; - TestLib::system_log('pg_ctl', '-D', $pgdata, '-m', $mode, 'stop'); - $self->{_pid} = undef; - $self->_update_pid; + TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-m', $mode, 'stop'); + $self->_update_pid(0); } =pod @@ -687,7 +692,7 @@ sub reload my $pgdata = $self->data_dir; my $name = $self->name; print "### Reloading node \"$name\"\n"; - TestLib::system_log('pg_ctl', '-D', $pgdata, 'reload'); + TestLib::system_or_bail('pg_ctl', '-D', $pgdata, 'reload'); } =pod @@ -706,9 +711,9 @@ sub restart my $logfile = $self->logfile; my $name = $self->name; print "### Restarting node \"$name\"\n"; - TestLib::system_log('pg_ctl', '-D', $pgdata, '-w', '-l', $logfile, - 'restart'); - $self->_update_pid; + TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-w', '-l', $logfile, + 'restart'); + $self->_update_pid(1); } =pod @@ -727,7 +732,8 @@ sub promote my $logfile = $self->logfile; my $name = $self->name; print "### Promoting node \"$name\"\n"; - TestLib::system_log('pg_ctl', '-D', $pgdata, '-l', $logfile, 'promote'); + TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-l', $logfile, + 'promote'); } # Internal routine to enable streaming replication on a standby node. @@ -805,22 +811,26 @@ archive_command = '$copy_command' # Internal method sub _update_pid { - my $self = shift; + my ($self, $is_running) = @_; my $name = $self->name; # If we can open the PID file, read its first line and that's the PID we - # want. If the file cannot be opened, presumably the server is not - # running; don't be noisy in that case. - if (open my $pidfile, $self->data_dir . "/postmaster.pid") + # want. + if (open my $pidfile, '<', $self->data_dir . "/postmaster.pid") { chomp($self->{_pid} = <$pidfile>); print "# Postmaster PID for node \"$name\" is $self->{_pid}\n"; close $pidfile; + + # If we found a pidfile when there shouldn't be one, complain. + BAIL_OUT("postmaster.pid unexpectedly present") unless $is_running; return; } $self->{_pid} = undef; - print "# No postmaster PID\n"; + print "# No postmaster PID for node \"$name\"\n"; + # Complain if we expected to find a pidfile. + BAIL_OUT("postmaster.pid unexpectedly not present") if $is_running; } =pod From 11927e575dd2afc8361e785c34db2141156702d6 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Sun, 23 Apr 2017 09:39:43 -0400 Subject: [PATCH 0013/1139] Fix TAP infrastructure to support Mingw better archive_command and restore_command need to refer to Windows paths, not Msys virtual file system paths, as postgres is completely unaware of the latter, so prefix them with the Windows path to the virtual file system root. Clean psql output of carriage returns. --- src/test/perl/PostgresNode.pm | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm index 20bc90b007..65c4a88045 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgresNode.pm @@ -101,6 +101,15 @@ our @EXPORT = qw( our ($test_localhost, $test_pghost, $last_port_assigned, @all_nodes); +# Windows path to virtual file system root + +our $vfs_path = ''; +if ($Config{osname} eq 'msys') +{ + $vfs_path = `cd / && pwd -W`; + chomp $vfs_path; +} + INIT { @@ -755,7 +764,7 @@ standby_mode=on sub enable_restoring { my ($self, $root_node) = @_; - my $path = $root_node->archive_dir; + my $path = $vfs_path . $root_node->archive_dir; my $name = $self->name; print "### Enabling WAL restore for node \"$name\"\n"; @@ -783,7 +792,7 @@ standby_mode = on sub enable_archiving { my ($self) = @_; - my $path = $self->archive_dir; + my $path = $vfs_path. $self->archive_dir; my $name = $self->name; print "### Enabling WAL archiving for node \"$name\"\n"; @@ -971,6 +980,7 @@ sub safe_psql print "\n#### End standard error\n"; } + $stdout =~ s/\r//g if $TestLib::windows_os; return $stdout; } From f5885488dacb62277c6452919e8961d27685675f Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 23 Apr 2017 13:10:57 -0400 Subject: [PATCH 0014/1139] Fix order of arguments to SubTransSetParent(). ProcessTwoPhaseBuffer (formerly StandbyRecoverPreparedTransactions) mixed up the parent and child XIDs when calling SubTransSetParent to record the transactions' relationship in pg_subtrans. Remarkably, analysis by Simon Riggs suggests that this doesn't lead to visible problems (at least, not in non-Assert builds). That might explain why we'd not noticed it before. Nonetheless, it's surely wrong. This code was born broken, so back-patch to all supported branches. Discussion: https://postgr.es/m/20110.1492905318@sss.pgh.pa.us --- src/backend/access/transam/twophase.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c index ea7bfa0578..88fa270fe3 100644 --- a/src/backend/access/transam/twophase.c +++ b/src/backend/access/transam/twophase.c @@ -1887,7 +1887,7 @@ StandbyRecoverPreparedTransactions(bool overwriteOK) TransactionId subxid = subxids[i]; Assert(TransactionIdFollows(subxid, xid)); - SubTransSetParent(xid, subxid, overwriteOK); + SubTransSetParent(subxid, xid, overwriteOK); } pfree(buf); From 39369b41451e432396aa3a913cc4c68bf0f4ee3c Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Sun, 23 Apr 2017 15:48:31 -0700 Subject: [PATCH 0015/1139] Zero padding in replication origin's checkpointed on disk-state. This seems to be largely cosmetic, avoiding valgrind bleats and the like. The uninitialized padding influences the CRC of the on-disk entry, but because it's also used when verifying the CRC, that doesn't cause spurious failures. Backpatch nonetheless. It's a bit unfortunate that contrib/test_decoding/sql/replorigin.sql doesn't exercise the checkpoint path, but checkpoints are fairly expensive on weaker machines, and we'd have to stop/start for that to be meaningful. Author: Andres Freund Discussion: https://postgr.es/m/20170422183123.w2jgiuxtts7qrqaq@alap3.anarazel.de Backpatch: 9.5, where replication origins were introduced --- src/backend/replication/logical/origin.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/backend/replication/logical/origin.c b/src/backend/replication/logical/origin.c index 78d9e9f17b..0d0aa407ba 100644 --- a/src/backend/replication/logical/origin.c +++ b/src/backend/replication/logical/origin.c @@ -566,6 +566,9 @@ CheckPointReplicationOrigin(void) if (curstate->roident == InvalidRepOriginId) continue; + /* zero, to avoid uninitialized padding bytes */ + memset(&disk_state, 0, sizeof(disk_state)); + LWLockAcquire(&curstate->lock, LW_SHARED); disk_state.roident = curstate->roident; From 63f64d2824b290a75a82ac60c5b62a971b7c7a4e Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 24 Apr 2017 12:16:58 -0400 Subject: [PATCH 0016/1139] Fix postmaster's handling of fork failure for a bgworker process. This corner case didn't behave nicely at all: the postmaster would (partially) update its state as though the process had started successfully, and be quite confused thereafter. Fix it to act like the worker had crashed, instead. In passing, refactor so that do_start_bgworker contains all the state-change logic for bgworker launch, rather than just some of it. Back-patch as far as 9.4. 9.3 contains similar logic, but it's just enough different that I don't feel comfortable applying the patch without more study; and the use of bgworkers in 9.3 was so small that it doesn't seem worth the extra work. transam/parallel.c is still entirely unprepared for the possibility of bgworker startup failure, but that seems like material for a separate patch. Discussion: https://postgr.es/m/4905.1492813727@sss.pgh.pa.us --- src/backend/postmaster/postmaster.c | 108 ++++++++++++++++++++-------- 1 file changed, 77 insertions(+), 31 deletions(-) diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 218915f3be..ad5bcfe339 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -412,6 +412,7 @@ static void TerminateChildren(int signal); #define SignalChildren(sig) SignalSomeChildren(sig, BACKEND_TYPE_ALL) static int CountChildren(int target); +static bool assign_backendlist_entry(RegisteredBgWorker *rw); static void maybe_start_bgworker(void); static bool CreateOptsFile(int argc, char *argv[], char *fullprogname); static pid_t StartChildProcess(AuxProcType type); @@ -5491,13 +5492,33 @@ bgworker_forkexec(int shmem_slot) * Start a new bgworker. * Starting time conditions must have been checked already. * + * Returns true on success, false on failure. + * In either case, update the RegisteredBgWorker's state appropriately. + * * This code is heavily based on autovacuum.c, q.v. */ -static void +static bool do_start_bgworker(RegisteredBgWorker *rw) { pid_t worker_pid; + Assert(rw->rw_pid == 0); + + /* + * Allocate and assign the Backend element. Note we must do this before + * forking, so that we can handle out of memory properly. + * + * Treat failure as though the worker had crashed. That way, the + * postmaster will wait a bit before attempting to start it again; if it + * tried again right away, most likely it'd find itself repeating the + * out-of-memory or fork failure condition. + */ + if (!assign_backendlist_entry(rw)) + { + rw->rw_crashed_at = GetCurrentTimestamp(); + return false; + } + ereport(DEBUG1, (errmsg("starting background worker process \"%s\"", rw->rw_worker.bgw_name))); @@ -5509,9 +5530,17 @@ do_start_bgworker(RegisteredBgWorker *rw) #endif { case -1: + /* in postmaster, fork failed ... */ ereport(LOG, (errmsg("could not fork worker process: %m"))); - return; + /* undo what assign_backendlist_entry did */ + ReleasePostmasterChildSlot(rw->rw_child_slot); + rw->rw_child_slot = 0; + free(rw->rw_backend); + rw->rw_backend = NULL; + /* mark entry as crashed, so we'll try again later */ + rw->rw_crashed_at = GetCurrentTimestamp(); + break; #ifndef EXEC_BACKEND case 0: @@ -5535,14 +5564,24 @@ do_start_bgworker(RegisteredBgWorker *rw) PostmasterContext = NULL; StartBackgroundWorker(); + + exit(1); /* should not get here */ break; #endif default: + /* in postmaster, fork successful ... */ rw->rw_pid = worker_pid; rw->rw_backend->pid = rw->rw_pid; ReportBackgroundWorkerPID(rw); - break; + /* add new worker to lists of backends */ + dlist_push_head(&BackendList, &rw->rw_backend->elem); +#ifdef EXEC_BACKEND + ShmemBackendArrayAdd(rw->rw_backend); +#endif + return true; } + + return false; } /* @@ -5589,6 +5628,8 @@ bgworker_should_start_now(BgWorkerStartTime start_time) * Allocate the Backend struct for a connected background worker, but don't * add it to the list of backends just yet. * + * On failure, return false without changing any worker state. + * * Some info from the Backend is copied into the passed rw. */ static bool @@ -5601,14 +5642,6 @@ assign_backendlist_entry(RegisteredBgWorker *rw) ereport(LOG, (errcode(ERRCODE_OUT_OF_MEMORY), errmsg("out of memory"))); - - /* - * The worker didn't really crash, but setting this nonzero makes - * postmaster wait a bit before attempting to start it again; if it - * tried again right away, most likely it'd find itself under the same - * memory pressure. - */ - rw->rw_crashed_at = GetCurrentTimestamp(); return false; } @@ -5638,6 +5671,11 @@ assign_backendlist_entry(RegisteredBgWorker *rw) * As a side effect, the bgworker control variables are set or reset whenever * there are more workers to start after this one, and whenever the overall * system state requires it. + * + * The reason we start at most one worker per call is to avoid consuming the + * postmaster's attention for too long when many such requests are pending. + * As long as StartWorkerNeeded is true, ServerLoop will not block and will + * call this function again after dealing with any other issues. */ static void maybe_start_bgworker(void) @@ -5645,13 +5683,19 @@ maybe_start_bgworker(void) slist_mutable_iter iter; TimestampTz now = 0; + /* + * During crash recovery, we have no need to be called until the state + * transition out of recovery. + */ if (FatalError) { StartWorkerNeeded = false; HaveCrashedWorker = false; - return; /* not yet */ + return; } + /* Don't need to be called again unless we find a reason for it below */ + StartWorkerNeeded = false; HaveCrashedWorker = false; slist_foreach_modify(iter, &BackgroundWorkerList) @@ -5660,11 +5704,11 @@ maybe_start_bgworker(void) rw = slist_container(RegisteredBgWorker, rw_lnode, iter.cur); - /* already running? */ + /* ignore if already running */ if (rw->rw_pid != 0) continue; - /* marked for death? */ + /* if marked for death, clean up and remove from list */ if (rw->rw_terminate) { ForgetBackgroundWorker(&iter); @@ -5686,12 +5730,14 @@ maybe_start_bgworker(void) continue; } + /* read system time only when needed */ if (now == 0) now = GetCurrentTimestamp(); if (!TimestampDifferenceExceeds(rw->rw_crashed_at, now, rw->rw_worker.bgw_restart_time * 1000)) { + /* Set flag to remember that we have workers to start later */ HaveCrashedWorker = true; continue; } @@ -5699,35 +5745,35 @@ maybe_start_bgworker(void) if (bgworker_should_start_now(rw->rw_worker.bgw_start_time)) { - /* reset crash time before calling assign_backendlist_entry */ + /* reset crash time before trying to start worker */ rw->rw_crashed_at = 0; /* - * Allocate and assign the Backend element. Note we must do this - * before forking, so that we can handle out of memory properly. + * Try to start the worker. + * + * On failure, give up processing workers for now, but set + * StartWorkerNeeded so we'll come back here on the next iteration + * of ServerLoop to try again. (We don't want to wait, because + * there might be additional ready-to-run workers.) We could set + * HaveCrashedWorker as well, since this worker is now marked + * crashed, but there's no need because the next run of this + * function will do that. */ - if (!assign_backendlist_entry(rw)) + if (!do_start_bgworker(rw)) + { + StartWorkerNeeded = true; return; - - do_start_bgworker(rw); /* sets rw->rw_pid */ - - dlist_push_head(&BackendList, &rw->rw_backend->elem); -#ifdef EXEC_BACKEND - ShmemBackendArrayAdd(rw->rw_backend); -#endif + } /* - * Have ServerLoop call us again. Note that there might not - * actually *be* another runnable worker, but we don't care all - * that much; we will find out the next time we run. + * Quit, but have ServerLoop call us again to look for additional + * ready-to-run workers. There might not be any, but we'll find + * out the next time we run. */ StartWorkerNeeded = true; return; } } - - /* no runnable worker found */ - StartWorkerNeeded = false; } /* From dfa4baf91cee77520335f2d7d6eff7f968dfe29c Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 24 Apr 2017 13:00:23 -0400 Subject: [PATCH 0017/1139] Run the postmaster's signal handlers without SA_RESTART. The postmaster keeps signals blocked everywhere except while waiting for something to happen in ServerLoop(). The code expects that the select(2) will be cancelled with EINTR if an interrupt occurs; without that, followup actions that should be performed by ServerLoop() itself will be delayed. However, some platforms interpret the SA_RESTART signal flag as meaning that they should restart rather than cancel the select(2). Worse yet, some of them restart it with the original timeout delay, meaning that a steady stream of signal interrupts can prevent ServerLoop() from iterating at all if there are no incoming connection requests. Observable symptoms of this, on an affected platform such as HPUX 10, include extremely slow parallel query startup (possibly as much as 30 seconds) and failure to update timestamps on the postmaster's sockets and lockfiles when no new connections arrive for a long time. We can fix this by running the postmaster's signal handlers without SA_RESTART. That would be quite a scary change if the range of code where signals are accepted weren't so tiny, but as it is, it seems safe enough. (Note that postmaster children do, and must, reset all the handlers before unblocking signals; so this change should not affect any child process.) There is talk of rewriting the postmaster to use a WaitEventSet and not do signal response work in signal handlers, at which point it might be appropriate to revert this patch. But that's not happening before v11 at the earliest. Back-patch to 9.6. The problem exists much further back, but the worst symptom arises only in connection with parallel query, so it does not seem worth taking any portability risks in older branches. Discussion: https://postgr.es/m/9205.1492833041@sss.pgh.pa.us --- src/backend/postmaster/postmaster.c | 29 +++++++++++++++++++-------- src/include/port.h | 5 +++++ src/port/pqsignal.c | 31 ++++++++++++++++++++++++++++- 3 files changed, 56 insertions(+), 9 deletions(-) diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index ad5bcfe339..5a60995889 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -603,6 +603,15 @@ PostmasterMain(int argc, char *argv[]) /* * Set up signal handlers for the postmaster process. * + * In the postmaster, we want to install non-ignored handlers *without* + * SA_RESTART. This is because they'll be blocked at all times except + * when ServerLoop is waiting for something to happen, and during that + * window, we want signals to exit the select(2) wait so that ServerLoop + * can respond if anything interesting happened. On some platforms, + * signals marked SA_RESTART would not cause the select() wait to end. + * Child processes will generally want SA_RESTART, but we expect them to + * set up their own handlers before unblocking signals. + * * CAUTION: when changing this list, check for side-effects on the signal * handling setup of child processes. See tcop/postgres.c, * bootstrap/bootstrap.c, postmaster/bgwriter.c, postmaster/walwriter.c, @@ -613,16 +622,20 @@ PostmasterMain(int argc, char *argv[]) pqinitmask(); PG_SETMASK(&BlockSig); - pqsignal(SIGHUP, SIGHUP_handler); /* reread config file and have - * children do same */ - pqsignal(SIGINT, pmdie); /* send SIGTERM and shut down */ - pqsignal(SIGQUIT, pmdie); /* send SIGQUIT and die */ - pqsignal(SIGTERM, pmdie); /* wait for children and shut down */ + pqsignal_no_restart(SIGHUP, SIGHUP_handler); /* reread config file + * and have children do + * same */ + pqsignal_no_restart(SIGINT, pmdie); /* send SIGTERM and shut down */ + pqsignal_no_restart(SIGQUIT, pmdie); /* send SIGQUIT and die */ + pqsignal_no_restart(SIGTERM, pmdie); /* wait for children and shut + * down */ pqsignal(SIGALRM, SIG_IGN); /* ignored */ pqsignal(SIGPIPE, SIG_IGN); /* ignored */ - pqsignal(SIGUSR1, sigusr1_handler); /* message from child process */ - pqsignal(SIGUSR2, dummy_handler); /* unused, reserve for children */ - pqsignal(SIGCHLD, reaper); /* handle child termination */ + pqsignal_no_restart(SIGUSR1, sigusr1_handler); /* message from child + * process */ + pqsignal_no_restart(SIGUSR2, dummy_handler); /* unused, reserve for + * children */ + pqsignal_no_restart(SIGCHLD, reaper); /* handle child termination */ pqsignal(SIGTTIN, SIG_IGN); /* ignored */ pqsignal(SIGTTOU, SIG_IGN); /* ignored */ /* ignore SIGXFSZ, so that ulimit violations work like disk full */ diff --git a/src/include/port.h b/src/include/port.h index 455f72338c..a61e59c8f8 100644 --- a/src/include/port.h +++ b/src/include/port.h @@ -462,6 +462,11 @@ extern int pg_mkdir_p(char *path, int omode); /* port/pqsignal.c */ typedef void (*pqsigfunc) (int signo); extern pqsigfunc pqsignal(int signo, pqsigfunc func); +#ifndef WIN32 +extern pqsigfunc pqsignal_no_restart(int signo, pqsigfunc func); +#else +#define pqsignal_no_restart(signo, func) pqsignal(signo, func) +#endif /* port/quotes.c */ extern char *escape_single_quotes_ascii(const char *src); diff --git a/src/port/pqsignal.c b/src/port/pqsignal.c index e5a73f2274..07797f909a 100644 --- a/src/port/pqsignal.c +++ b/src/port/pqsignal.c @@ -32,7 +32,7 @@ #if !defined(WIN32) || defined(FRONTEND) /* - * Set up a signal handler for signal "signo" + * Set up a signal handler, with SA_RESTART, for signal "signo" * * Returns the previous handler. */ @@ -58,4 +58,33 @@ pqsignal(int signo, pqsigfunc func) #endif } +/* + * Set up a signal handler, without SA_RESTART, for signal "signo" + * + * Returns the previous handler. + * + * On Windows, this would be identical to pqsignal(), so don't bother. + */ +#ifndef WIN32 + +pqsigfunc +pqsignal_no_restart(int signo, pqsigfunc func) +{ + struct sigaction act, + oact; + + act.sa_handler = func; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; +#ifdef SA_NOCLDSTOP + if (signo == SIGCHLD) + act.sa_flags |= SA_NOCLDSTOP; +#endif + if (sigaction(signo, &act, &oact) < 0) + return SIG_ERR; + return oact.sa_handler; +} + +#endif /* !WIN32 */ + #endif /* !defined(WIN32) || defined(FRONTEND) */ From b9515b62879722e3497236f6e0d6783c3fc059a2 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 24 Apr 2017 14:03:14 -0400 Subject: [PATCH 0018/1139] Use pselect(2) not select(2), if available, to wait in postmaster's loop. Traditionally we've unblocked signals, called select(2), and then blocked signals again. The code expects that the select() will be cancelled with EINTR if an interrupt occurs; but there's a race condition, which is that an already-pending signal will be delivered as soon as we unblock, and then when we reach select() there will be nothing preventing it from waiting. This can result in a long delay before we perform any action that ServerLoop was supposed to have taken in response to the signal. As with the somewhat-similar symptoms fixed by commit 893902085, the main practical problem is slow launching of parallel workers. The window for trouble is usually pretty short, corresponding to one iteration of ServerLoop; but it's not negligible. To fix, use pselect(2) in place of select(2) where available, as that's designed to solve exactly this problem. Where not available, we continue to use the old way, and are no worse off than before. pselect(2) has been required by POSIX since about 2001, so most modern platforms should have it. A bigger portability issue is that some implementations are said to be non-atomic, ie pselect() isn't really any different from unblock/select/reblock. Still, we're no worse off than before on such a platform. There is talk of rewriting the postmaster to use a WaitEventSet and not do signal response work in signal handlers, at which point this could be reverted, since we'd be using a self-pipe to solve the race condition. But that's not happening before v11 at the earliest. Back-patch to 9.6. The problem exists much further back, but the worst symptom arises only in connection with parallel query, so it does not seem worth taking any portability risks in older branches. Discussion: https://postgr.es/m/9205.1492833041@sss.pgh.pa.us --- configure | 2 +- configure.in | 2 +- src/backend/postmaster/postmaster.c | 63 +++++++++++++++++++++-------- src/include/pg_config.h.in | 3 ++ src/include/pg_config.h.win32 | 3 ++ 5 files changed, 54 insertions(+), 19 deletions(-) diff --git a/configure b/configure index bb285e4e1b..21631258f6 100755 --- a/configure +++ b/configure @@ -12504,7 +12504,7 @@ fi LIBS_including_readline="$LIBS" LIBS=`echo "$LIBS" | sed -e 's/-ledit//g' -e 's/-lreadline//g'` -for ac_func in cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l +for ac_func in cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pselect pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" diff --git a/configure.in b/configure.in index 09a887d4f0..319ad43ab9 100644 --- a/configure.in +++ b/configure.in @@ -1456,7 +1456,7 @@ PGAC_FUNC_WCSTOMBS_L LIBS_including_readline="$LIBS" LIBS=`echo "$LIBS" | sed -e 's/-ledit//g' -e 's/-lreadline//g'` -AC_CHECK_FUNCS([cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l]) +AC_CHECK_FUNCS([cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pselect pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l]) AC_REPLACE_FUNCS(fseeko) case $host_os in diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 5a60995889..cd793886f8 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -606,9 +606,9 @@ PostmasterMain(int argc, char *argv[]) * In the postmaster, we want to install non-ignored handlers *without* * SA_RESTART. This is because they'll be blocked at all times except * when ServerLoop is waiting for something to happen, and during that - * window, we want signals to exit the select(2) wait so that ServerLoop + * window, we want signals to exit the pselect(2) wait so that ServerLoop * can respond if anything interesting happened. On some platforms, - * signals marked SA_RESTART would not cause the select() wait to end. + * signals marked SA_RESTART would not cause the pselect() wait to end. * Child processes will generally want SA_RESTART, but we expect them to * set up their own handlers before unblocking signals. * @@ -1642,6 +1642,8 @@ ServerLoop(void) for (;;) { fd_set rmask; + fd_set *rmask_p; + struct timeval timeout; int selres; time_t now; @@ -1651,37 +1653,64 @@ ServerLoop(void) * We block all signals except while sleeping. That makes it safe for * signal handlers, which again block all signals while executing, to * do nontrivial work. - * - * If we are in PM_WAIT_DEAD_END state, then we don't want to accept - * any new connections, so we don't call select(), and just sleep. */ - memcpy((char *) &rmask, (char *) &readmask, sizeof(fd_set)); - if (pmState == PM_WAIT_DEAD_END) { - PG_SETMASK(&UnBlockSig); - - pg_usleep(100000L); /* 100 msec seems reasonable */ - selres = 0; - - PG_SETMASK(&BlockSig); + /* + * If we are in PM_WAIT_DEAD_END state, then we don't want to + * accept any new connections, so pass a null rmask. + */ + rmask_p = NULL; + timeout.tv_sec = 0; + timeout.tv_usec = 100000; /* 100 msec seems reasonable */ } else { - /* must set timeout each time; some OSes change it! */ - struct timeval timeout; + /* Normal case: check sockets, and compute a suitable timeout */ + memcpy(&rmask, &readmask, sizeof(fd_set)); + rmask_p = &rmask; /* Needs to run with blocked signals! */ DetermineSleepTime(&timeout); + } + /* + * We prefer to wait with pselect(2) if available, as using that, + * together with *not* using SA_RESTART for signals, guarantees that + * we will get kicked off the wait if a signal occurs. + * + * If we lack pselect(2), fake it with select(2). This has a race + * condition: a signal that was already pending will be delivered + * before we reach the select(), and therefore the select() will wait, + * even though we might wish to do something in response. Therefore, + * beware of putting any time-critical signal response logic into + * ServerLoop rather than into the signal handler itself. It will run + * eventually, but maybe not till after a timeout delay. + * + * Some implementations of pselect() are reportedly not atomic, making + * the first alternative here functionally equivalent to the second. + * Not much we can do about that though. + */ + { +#ifdef HAVE_PSELECT + /* pselect uses a randomly different timeout API, sigh */ + struct timespec ptimeout; + + ptimeout.tv_sec = timeout.tv_sec; + ptimeout.tv_nsec = timeout.tv_usec * 1000; + + selres = pselect(nSockets, rmask_p, NULL, NULL, + &ptimeout, &UnBlockSig); +#else PG_SETMASK(&UnBlockSig); - selres = select(nSockets, &rmask, NULL, NULL, &timeout); + selres = select(nSockets, rmask_p, NULL, NULL, &timeout); PG_SETMASK(&BlockSig); +#endif } - /* Now check the select() result */ + /* Now check the select()/pselect() result */ if (selres < 0) { if (errno != EINTR && errno != EWOULDBLOCK) diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in index 7dbfa90bf4..5eabcce5da 100644 --- a/src/include/pg_config.h.in +++ b/src/include/pg_config.h.in @@ -397,6 +397,9 @@ /* Define to 1 if the assembler supports PPC's LWARX mutex hint bit. */ #undef HAVE_PPC_LWARX_MUTEX_HINT +/* Define to 1 if you have the `pselect' function. */ +#undef HAVE_PSELECT + /* Define to 1 if you have the `pstat' function. */ #undef HAVE_PSTAT diff --git a/src/include/pg_config.h.win32 b/src/include/pg_config.h.win32 index 2163187082..9288e05e07 100644 --- a/src/include/pg_config.h.win32 +++ b/src/include/pg_config.h.win32 @@ -264,6 +264,9 @@ /* Define to 1 if you have the header file. */ /* #undef HAVE_POLL_H */ +/* Define to 1 if you have the `pselect' function. */ +/* #undef HAVE_PSELECT */ + /* Define to 1 if you have the `pstat' function. */ /* #undef HAVE_PSTAT */ From e615605239f6df491cd171ed6890b8c70566ef75 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 24 Apr 2017 18:29:55 -0400 Subject: [PATCH 0019/1139] Revert "Use pselect(2) not select(2), if available, to wait in postmaster's loop." This reverts commit b9515b62879722e3497236f6e0d6783c3fc059a2. Buildfarm results suggest that some platforms have versions of pselect(2) that are not merely non-atomic, but flat out non-functional. Revert the use-pselect patch to confirm this diagnosis (and exclude the no-SA_RESTART patch as the source of trouble). If it's so, we should probably look into blacklisting specific platforms that have broken pselect. Discussion: https://postgr.es/m/9696.1493072081@sss.pgh.pa.us --- configure | 2 +- configure.in | 2 +- src/backend/postmaster/postmaster.c | 63 ++++++++--------------------- src/include/pg_config.h.in | 3 -- src/include/pg_config.h.win32 | 3 -- 5 files changed, 19 insertions(+), 54 deletions(-) diff --git a/configure b/configure index 21631258f6..bb285e4e1b 100755 --- a/configure +++ b/configure @@ -12504,7 +12504,7 @@ fi LIBS_including_readline="$LIBS" LIBS=`echo "$LIBS" | sed -e 's/-ledit//g' -e 's/-lreadline//g'` -for ac_func in cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pselect pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l +for ac_func in cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" diff --git a/configure.in b/configure.in index 319ad43ab9..09a887d4f0 100644 --- a/configure.in +++ b/configure.in @@ -1456,7 +1456,7 @@ PGAC_FUNC_WCSTOMBS_L LIBS_including_readline="$LIBS" LIBS=`echo "$LIBS" | sed -e 's/-ledit//g' -e 's/-lreadline//g'` -AC_CHECK_FUNCS([cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pselect pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l]) +AC_CHECK_FUNCS([cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l]) AC_REPLACE_FUNCS(fseeko) case $host_os in diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index cd793886f8..5a60995889 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -606,9 +606,9 @@ PostmasterMain(int argc, char *argv[]) * In the postmaster, we want to install non-ignored handlers *without* * SA_RESTART. This is because they'll be blocked at all times except * when ServerLoop is waiting for something to happen, and during that - * window, we want signals to exit the pselect(2) wait so that ServerLoop + * window, we want signals to exit the select(2) wait so that ServerLoop * can respond if anything interesting happened. On some platforms, - * signals marked SA_RESTART would not cause the pselect() wait to end. + * signals marked SA_RESTART would not cause the select() wait to end. * Child processes will generally want SA_RESTART, but we expect them to * set up their own handlers before unblocking signals. * @@ -1642,8 +1642,6 @@ ServerLoop(void) for (;;) { fd_set rmask; - fd_set *rmask_p; - struct timeval timeout; int selres; time_t now; @@ -1653,64 +1651,37 @@ ServerLoop(void) * We block all signals except while sleeping. That makes it safe for * signal handlers, which again block all signals while executing, to * do nontrivial work. + * + * If we are in PM_WAIT_DEAD_END state, then we don't want to accept + * any new connections, so we don't call select(), and just sleep. */ + memcpy((char *) &rmask, (char *) &readmask, sizeof(fd_set)); + if (pmState == PM_WAIT_DEAD_END) { - /* - * If we are in PM_WAIT_DEAD_END state, then we don't want to - * accept any new connections, so pass a null rmask. - */ - rmask_p = NULL; - timeout.tv_sec = 0; - timeout.tv_usec = 100000; /* 100 msec seems reasonable */ + PG_SETMASK(&UnBlockSig); + + pg_usleep(100000L); /* 100 msec seems reasonable */ + selres = 0; + + PG_SETMASK(&BlockSig); } else { - /* Normal case: check sockets, and compute a suitable timeout */ - memcpy(&rmask, &readmask, sizeof(fd_set)); - rmask_p = &rmask; + /* must set timeout each time; some OSes change it! */ + struct timeval timeout; /* Needs to run with blocked signals! */ DetermineSleepTime(&timeout); - } - /* - * We prefer to wait with pselect(2) if available, as using that, - * together with *not* using SA_RESTART for signals, guarantees that - * we will get kicked off the wait if a signal occurs. - * - * If we lack pselect(2), fake it with select(2). This has a race - * condition: a signal that was already pending will be delivered - * before we reach the select(), and therefore the select() will wait, - * even though we might wish to do something in response. Therefore, - * beware of putting any time-critical signal response logic into - * ServerLoop rather than into the signal handler itself. It will run - * eventually, but maybe not till after a timeout delay. - * - * Some implementations of pselect() are reportedly not atomic, making - * the first alternative here functionally equivalent to the second. - * Not much we can do about that though. - */ - { -#ifdef HAVE_PSELECT - /* pselect uses a randomly different timeout API, sigh */ - struct timespec ptimeout; - - ptimeout.tv_sec = timeout.tv_sec; - ptimeout.tv_nsec = timeout.tv_usec * 1000; - - selres = pselect(nSockets, rmask_p, NULL, NULL, - &ptimeout, &UnBlockSig); -#else PG_SETMASK(&UnBlockSig); - selres = select(nSockets, rmask_p, NULL, NULL, &timeout); + selres = select(nSockets, &rmask, NULL, NULL, &timeout); PG_SETMASK(&BlockSig); -#endif } - /* Now check the select()/pselect() result */ + /* Now check the select() result */ if (selres < 0) { if (errno != EINTR && errno != EWOULDBLOCK) diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in index 5eabcce5da..7dbfa90bf4 100644 --- a/src/include/pg_config.h.in +++ b/src/include/pg_config.h.in @@ -397,9 +397,6 @@ /* Define to 1 if the assembler supports PPC's LWARX mutex hint bit. */ #undef HAVE_PPC_LWARX_MUTEX_HINT -/* Define to 1 if you have the `pselect' function. */ -#undef HAVE_PSELECT - /* Define to 1 if you have the `pstat' function. */ #undef HAVE_PSTAT diff --git a/src/include/pg_config.h.win32 b/src/include/pg_config.h.win32 index 9288e05e07..2163187082 100644 --- a/src/include/pg_config.h.win32 +++ b/src/include/pg_config.h.win32 @@ -264,9 +264,6 @@ /* Define to 1 if you have the header file. */ /* #undef HAVE_POLL_H */ -/* Define to 1 if you have the `pselect' function. */ -/* #undef HAVE_PSELECT */ - /* Define to 1 if you have the `pstat' function. */ /* #undef HAVE_PSTAT */ From 86e640a6941b956d05c0380b754a92050f06bf43 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Tue, 25 Apr 2017 10:01:59 -0400 Subject: [PATCH 0020/1139] postgres_fdw: Fix join push down with extensions Objects in an extension are shippable to a foreign server if the extension is part of the foreign server definition's shippable extensions list. But this was not properly considered in some cases when checking whether a join condition can be pushed to a foreign server and the join condition uses an object from a shippable extension. So the join would never be pushed down in those cases. So, the list of extensions needs to be made available in fpinfo of the relation being considered to be pushed down before any expressions are assessed for being shippable. Fix foreign_join_ok() to do that for a join relation. David Rowley and Ashutosh Bapat, per report from David Rowley reduced version of patch 332bec1e6096679b04ec9717beb44a858495260f for backpatch to 9.6, first release with join push down --- .../postgres_fdw/expected/postgres_fdw.out | 29 +++++++++++++++++++ contrib/postgres_fdw/postgres_fdw.c | 12 ++++++-- contrib/postgres_fdw/sql/postgres_fdw.sql | 8 +++++ 3 files changed, 46 insertions(+), 3 deletions(-) diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out index 9a1c68f61d..eb6124cccd 100644 --- a/contrib/postgres_fdw/expected/postgres_fdw.out +++ b/contrib/postgres_fdw/expected/postgres_fdw.out @@ -1501,6 +1501,35 @@ SELECT t1.c1, t2.c1 FROM ft4 t1 FULL JOIN ft5 t2 ON (t1.c1 = t2.c1) WHERE (t1.c1 | 21 (10 rows) +-- full outer join + WHERE clause with shippable extensions set +EXPLAIN (VERBOSE, COSTS OFF) +SELECT t1.c1, t2.c2, t1.c3 FROM ft1 t1 FULL JOIN ft2 t2 ON (t1.c1 = t2.c1) WHERE postgres_fdw_abs(t1.c1) > 0 OFFSET 10 LIMIT 10; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit + Output: t1.c1, t2.c2, t1.c3 + -> Foreign Scan + Output: t1.c1, t2.c2, t1.c3 + Relations: (public.ft1 t1) FULL JOIN (public.ft2 t2) + Remote SQL: SELECT r1."C 1", r1.c3, r2.c2 FROM ("S 1"."T 1" r1 FULL JOIN "S 1"."T 1" r2 ON (((r1."C 1" = r2."C 1")))) WHERE ((public.postgres_fdw_abs(r1."C 1") > 0)) +(6 rows) + +ALTER SERVER loopback OPTIONS (DROP extensions); +-- full outer join + WHERE clause with shippable extensions not set +EXPLAIN (VERBOSE, COSTS OFF) +SELECT t1.c1, t2.c2, t1.c3 FROM ft1 t1 FULL JOIN ft2 t2 ON (t1.c1 = t2.c1) WHERE postgres_fdw_abs(t1.c1) > 0 OFFSET 10 LIMIT 10; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------- + Limit + Output: t1.c1, t2.c2, t1.c3 + -> Foreign Scan + Output: t1.c1, t2.c2, t1.c3 + Filter: (postgres_fdw_abs(t1.c1) > 0) + Relations: (public.ft1 t1) FULL JOIN (public.ft2 t2) + Remote SQL: SELECT r1."C 1", r1.c3, r2.c2 FROM ("S 1"."T 1" r1 FULL JOIN "S 1"."T 1" r2 ON (((r1."C 1" = r2."C 1")))) +(7 rows) + +ALTER SERVER loopback OPTIONS (ADD extensions 'postgres_fdw'); -- join two tables with FOR UPDATE clause -- tests whole-row reference for row marks EXPLAIN (VERBOSE, COSTS OFF) diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c index 856798ee72..88fac15a5c 100644 --- a/contrib/postgres_fdw/postgres_fdw.c +++ b/contrib/postgres_fdw/postgres_fdw.c @@ -3990,6 +3990,15 @@ foreign_join_ok(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, joinclauses = NIL; } + /* Get foreign server */ + fpinfo->server = fpinfo_o->server; + + /* + * Copy shippable_extensions before checking whether the foreign join is + * OK, so that we know which quals can be evaluated on the foreign server. + */ + fpinfo->shippable_extensions = fpinfo_o->shippable_extensions; + /* Join quals must be safe to push down. */ foreach(lc, joinclauses) { @@ -4133,9 +4142,6 @@ foreign_join_ok(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, else fpinfo->user = NULL; - /* Get foreign server */ - fpinfo->server = fpinfo_o->server; - /* * Since both the joining relations come from the same server, the server * level options should have same value for both the relations. Pick from diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql index b09244a0cb..176b3a32a8 100644 --- a/contrib/postgres_fdw/sql/postgres_fdw.sql +++ b/contrib/postgres_fdw/sql/postgres_fdw.sql @@ -422,6 +422,14 @@ SELECT t1.c1, t2.c2, t3.c3 FROM ft2 t1 LEFT JOIN ft2 t2 ON (t1.c1 = t2.c1) RIGHT EXPLAIN (VERBOSE, COSTS OFF) SELECT t1.c1, t2.c1 FROM ft4 t1 FULL JOIN ft5 t2 ON (t1.c1 = t2.c1) WHERE (t1.c1 = t2.c1 OR t1.c1 IS NULL) ORDER BY t1.c1, t2.c1 OFFSET 10 LIMIT 10; SELECT t1.c1, t2.c1 FROM ft4 t1 FULL JOIN ft5 t2 ON (t1.c1 = t2.c1) WHERE (t1.c1 = t2.c1 OR t1.c1 IS NULL) ORDER BY t1.c1, t2.c1 OFFSET 10 LIMIT 10; +-- full outer join + WHERE clause with shippable extensions set +EXPLAIN (VERBOSE, COSTS OFF) +SELECT t1.c1, t2.c2, t1.c3 FROM ft1 t1 FULL JOIN ft2 t2 ON (t1.c1 = t2.c1) WHERE postgres_fdw_abs(t1.c1) > 0 OFFSET 10 LIMIT 10; +ALTER SERVER loopback OPTIONS (DROP extensions); +-- full outer join + WHERE clause with shippable extensions not set +EXPLAIN (VERBOSE, COSTS OFF) +SELECT t1.c1, t2.c2, t1.c3 FROM ft1 t1 FULL JOIN ft2 t2 ON (t1.c1 = t2.c1) WHERE postgres_fdw_abs(t1.c1) > 0 OFFSET 10 LIMIT 10; +ALTER SERVER loopback OPTIONS (ADD extensions 'postgres_fdw'); -- join two tables with FOR UPDATE clause -- tests whole-row reference for row marks EXPLAIN (VERBOSE, COSTS OFF) From e880df25ec35fab727678531d392403ce4226dd9 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 26 Apr 2017 16:17:29 -0400 Subject: [PATCH 0021/1139] Allow multiple bgworkers to be launched per postmaster iteration. Previously, maybe_start_bgworker() would launch at most one bgworker process per call, on the grounds that the postmaster might otherwise neglect its other duties for too long. However, that seems overly conservative, especially since bad effects only become obvious when many hundreds of bgworkers need to be launched at once. On the other side of the coin is that the existing logic could result in substantial delay of bgworker launches, because ServerLoop isn't guaranteed to iterate immediately after a signal arrives. (My attempt to fix that by using pselect(2) encountered too many portability question marks, and in any case could not help on platforms without pselect().) One could also question the wisdom of using an O(N^2) processing method if the system is intended to support so many bgworkers. As a compromise, allow that function to launch up to 100 bgworkers per call (and in consequence, rename it to maybe_start_bgworkers). This will allow any normal parallel-query request for workers to be satisfied immediately during sigusr1_handler, avoiding the question of whether ServerLoop will be able to launch more promptly. There is talk of rewriting the postmaster to use a WaitEventSet to avoid the signal-response-delay problem, but I'd argue that this change should be kept even after that happens (if it ever does). Backpatch to 9.6 where parallel query was added. The issue exists before that, but previous uses of bgworkers typically aren't as sensitive to how quickly they get launched. Discussion: https://postgr.es/m/4707.1493221358@sss.pgh.pa.us --- src/backend/postmaster/postmaster.c | 39 ++++++++++++++++------------- 1 file changed, 22 insertions(+), 17 deletions(-) diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 5a60995889..6f923bdbdb 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -413,7 +413,7 @@ static void TerminateChildren(int signal); static int CountChildren(int target); static bool assign_backendlist_entry(RegisteredBgWorker *rw); -static void maybe_start_bgworker(void); +static void maybe_start_bgworkers(void); static bool CreateOptsFile(int argc, char *argv[], char *fullprogname); static pid_t StartChildProcess(AuxProcType type); static void StartAutovacuumWorker(void); @@ -1318,7 +1318,7 @@ PostmasterMain(int argc, char *argv[]) pmState = PM_STARTUP; /* Some workers may be scheduled to start now */ - maybe_start_bgworker(); + maybe_start_bgworkers(); status = ServerLoop(); @@ -1785,7 +1785,7 @@ ServerLoop(void) /* Get other worker processes running, if needed */ if (StartWorkerNeeded || HaveCrashedWorker) - maybe_start_bgworker(); + maybe_start_bgworkers(); #ifdef HAVE_PTHREAD_IS_THREADED_NP @@ -2823,7 +2823,7 @@ reaper(SIGNAL_ARGS) PgStatPID = pgstat_start(); /* workers may be scheduled to start now */ - maybe_start_bgworker(); + maybe_start_bgworkers(); /* at this point we are really open for business */ ereport(LOG, @@ -4970,7 +4970,7 @@ sigusr1_handler(SIGNAL_ARGS) } if (StartWorkerNeeded || HaveCrashedWorker) - maybe_start_bgworker(); + maybe_start_bgworkers(); if (CheckPostmasterSignal(PMSIGNAL_WAKEN_ARCHIVER) && PgArchPID != 0) @@ -5679,22 +5679,23 @@ assign_backendlist_entry(RegisteredBgWorker *rw) } /* - * If the time is right, start one background worker. + * If the time is right, start background worker(s). * - * As a side effect, the bgworker control variables are set or reset whenever - * there are more workers to start after this one, and whenever the overall - * system state requires it. + * As a side effect, the bgworker control variables are set or reset + * depending on whether more workers may need to be started. * - * The reason we start at most one worker per call is to avoid consuming the + * We limit the number of workers started per call, to avoid consuming the * postmaster's attention for too long when many such requests are pending. * As long as StartWorkerNeeded is true, ServerLoop will not block and will * call this function again after dealing with any other issues. */ static void -maybe_start_bgworker(void) +maybe_start_bgworkers(void) { - slist_mutable_iter iter; +#define MAX_BGWORKERS_TO_LAUNCH 100 + int num_launched = 0; TimestampTz now = 0; + slist_mutable_iter iter; /* * During crash recovery, we have no need to be called until the state @@ -5779,12 +5780,16 @@ maybe_start_bgworker(void) } /* - * Quit, but have ServerLoop call us again to look for additional - * ready-to-run workers. There might not be any, but we'll find - * out the next time we run. + * If we've launched as many workers as allowed, quit, but have + * ServerLoop call us again to look for additional ready-to-run + * workers. There might not be any, but we'll find out the next + * time we run. */ - StartWorkerNeeded = true; - return; + if (++num_launched >= MAX_BGWORKERS_TO_LAUNCH) + { + StartWorkerNeeded = true; + return; + } } } } From 866452cd8b52b0231e159eab4201d86d9164ab69 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 27 Apr 2017 15:07:36 -0400 Subject: [PATCH 0022/1139] Make latch.c more paranoid about child-process cases. Although the postmaster doesn't currently create a self-pipe or any latches, there's discussion of it doing so in future. It's also conceivable that a shared_preload_libraries extension would try to create such a thing in the postmaster process today. In that case the self-pipe FDs would be inherited by forked child processes. latch.c was entirely unprepared for such a case and could suffer an assertion failure, or worse try to use the inherited pipe if somebody called WaitLatch without having called InitializeLatchSupport in that process. Make it keep track of whether InitializeLatchSupport has been called in the *current* process, and do the right thing if state has been inherited from a parent. Apply FD_CLOEXEC to file descriptors created in latch.c (the self-pipe, as well as epoll event sets). This ensures that child processes spawned in backends, the archiver, etc cannot accidentally or intentionally mess with these FDs. It also ensures that we end up with the right state for the self-pipe in EXEC_BACKEND processes, which otherwise wouldn't know to close the postmaster's self-pipe FDs. Back-patch to 9.6, mainly to keep latch.c looking similar in all branches it exists in. Discussion: https://postgr.es/m/8322.1493240739@sss.pgh.pa.us --- src/backend/storage/ipc/latch.c | 74 ++++++++++++++++++++++++++++----- 1 file changed, 64 insertions(+), 10 deletions(-) diff --git a/src/backend/storage/ipc/latch.c b/src/backend/storage/ipc/latch.c index cac72ae428..86e18a4aa6 100644 --- a/src/backend/storage/ipc/latch.c +++ b/src/backend/storage/ipc/latch.c @@ -130,6 +130,9 @@ static volatile sig_atomic_t waiting = false; static int selfpipe_readfd = -1; static int selfpipe_writefd = -1; +/* Process owning the self-pipe --- needed for checking purposes */ +static int selfpipe_owner_pid = 0; + /* Private function prototypes */ static void sendSelfPipeByte(void); static void drainSelfPipe(void); @@ -158,7 +161,41 @@ InitializeLatchSupport(void) #ifndef WIN32 int pipefd[2]; - Assert(selfpipe_readfd == -1); + if (IsUnderPostmaster) + { + /* + * We might have inherited connections to a self-pipe created by the + * postmaster. It's critical that child processes create their own + * self-pipes, of course, and we really want them to close the + * inherited FDs for safety's sake. + */ + if (selfpipe_owner_pid != 0) + { + /* Assert we go through here but once in a child process */ + Assert(selfpipe_owner_pid != MyProcPid); + /* Release postmaster's pipe FDs; ignore any error */ + (void) close(selfpipe_readfd); + (void) close(selfpipe_writefd); + /* Clean up, just for safety's sake; we'll set these below */ + selfpipe_readfd = selfpipe_writefd = -1; + selfpipe_owner_pid = 0; + } + else + { + /* + * Postmaster didn't create a self-pipe ... or else we're in an + * EXEC_BACKEND build, in which case it doesn't matter since the + * postmaster's pipe FDs were closed by the action of FD_CLOEXEC. + */ + Assert(selfpipe_readfd == -1); + } + } + else + { + /* In postmaster or standalone backend, assert we do this but once */ + Assert(selfpipe_readfd == -1); + Assert(selfpipe_owner_pid == 0); + } /* * Set up the self-pipe that allows a signal handler to wake up the @@ -166,23 +203,30 @@ InitializeLatchSupport(void) * SetLatch won't block if the event has already been set many times * filling the kernel buffer. Make the read-end non-blocking too, so that * we can easily clear the pipe by reading until EAGAIN or EWOULDBLOCK. + * Also, make both FDs close-on-exec, since we surely do not want any + * child processes messing with them. */ if (pipe(pipefd) < 0) elog(FATAL, "pipe() failed: %m"); if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) == -1) - elog(FATAL, "fcntl() failed on read-end of self-pipe: %m"); + elog(FATAL, "fcntl(F_SETFL) failed on read-end of self-pipe: %m"); if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) == -1) - elog(FATAL, "fcntl() failed on write-end of self-pipe: %m"); + elog(FATAL, "fcntl(F_SETFL) failed on write-end of self-pipe: %m"); + if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) == -1) + elog(FATAL, "fcntl(F_SETFD) failed on read-end of self-pipe: %m"); + if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) == -1) + elog(FATAL, "fcntl(F_SETFD) failed on write-end of self-pipe: %m"); selfpipe_readfd = pipefd[0]; selfpipe_writefd = pipefd[1]; + selfpipe_owner_pid = MyProcPid; #else /* currently, nothing to do here for Windows */ #endif } /* - * Initialize a backend-local latch. + * Initialize a process-local latch. */ void InitLatch(volatile Latch *latch) @@ -193,7 +237,7 @@ InitLatch(volatile Latch *latch) #ifndef WIN32 /* Assert InitializeLatchSupport has been called in this process */ - Assert(selfpipe_readfd >= 0); + Assert(selfpipe_readfd >= 0 && selfpipe_owner_pid == MyProcPid); #else latch->event = CreateEvent(NULL, TRUE, FALSE, NULL); if (latch->event == NULL) @@ -211,6 +255,10 @@ InitLatch(volatile Latch *latch) * containing the latch with ShmemInitStruct. (The Unix implementation * doesn't actually require that, but the Windows one does.) Because of * this restriction, we have no concurrency issues to worry about here. + * + * Note that other handles created in this module are never marked as + * inheritable. Thus we do not need to worry about cleaning up child + * process references to postmaster-private latches or WaitEventSets. */ void InitSharedLatch(volatile Latch *latch) @@ -256,7 +304,7 @@ OwnLatch(volatile Latch *latch) #ifndef WIN32 /* Assert InitializeLatchSupport has been called in this process */ - Assert(selfpipe_readfd >= 0); + Assert(selfpipe_readfd >= 0 && selfpipe_owner_pid == MyProcPid); #endif if (latch->owner_pid != 0) @@ -289,7 +337,7 @@ DisownLatch(volatile Latch *latch) * is incurred when WL_TIMEOUT is given, so avoid using a timeout if possible. * * The latch must be owned by the current process, ie. it must be a - * backend-local latch initialized with InitLatch, or a shared latch + * process-local latch initialized with InitLatch, or a shared latch * associated with the current process by calling OwnLatch. * * Returns bit mask indicating which condition(s) caused the wake-up. Note @@ -526,9 +574,9 @@ CreateWaitEventSet(MemoryContext context, int nevents) set->nevents_space = nevents; #if defined(WAIT_USE_EPOLL) - set->epoll_fd = epoll_create(nevents); + set->epoll_fd = epoll_create1(EPOLL_CLOEXEC); if (set->epoll_fd < 0) - elog(ERROR, "epoll_create failed: %m"); + elog(ERROR, "epoll_create1 failed: %m"); #elif defined(WAIT_USE_WIN32) /* @@ -549,6 +597,12 @@ CreateWaitEventSet(MemoryContext context, int nevents) /* * Free a previously created WaitEventSet. + * + * Note: preferably, this shouldn't have to free any resources that could be + * inherited across an exec(). If it did, we'd likely leak those resources in + * many scenarios. For the epoll case, we ensure that by setting FD_CLOEXEC + * when the FD is created. For the Windows case, we assume that the handles + * involved are non-inheritable. */ void FreeWaitEventSet(WaitEventSet *set) @@ -595,7 +649,7 @@ FreeWaitEventSet(WaitEventSet *set) * used to modify previously added wait events using ModifyWaitEvent(). * * In the WL_LATCH_SET case the latch must be owned by the current process, - * i.e. it must be a backend-local latch initialized with InitLatch, or a + * i.e. it must be a process-local latch initialized with InitLatch, or a * shared latch associated with the current process by calling OwnLatch. * * In the WL_SOCKET_READABLE/WRITEABLE case, EOF and error conditions are From 28afff347a5db51a02b269fa13677d6924a88e78 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Sun, 23 Apr 2017 20:41:29 -0700 Subject: [PATCH 0023/1139] Preserve required !catalog tuples while computing initial decoding snapshot. The logical decoding machinery already preserved all the required catalog tuples, which is sufficient in the course of normal logical decoding, but did not guarantee that non-catalog tuples were preserved during computation of the initial snapshot when creating a slot over the replication protocol. This could cause a corrupted initial snapshot being exported. The time window for issues is usually not terribly large, but on a busy server it's perfectly possible to it hit it. Ongoing decoding is not affected by this bug. To avoid increased overhead for the SQL API, only retain additional tuples when a logical slot is being created over the replication protocol. To do so this commit changes the signature of CreateInitDecodingContext(), but it seems unlikely that it's being used in an extension, so that's probably ok. In a drive-by fix, fix handling of ReplicationSlotsComputeRequiredXmin's already_locked argument, which should only apply to ProcArrayLock, not ReplicationSlotControlLock. Reported-By: Erik Rijkers Analyzed-By: Petr Jelinek Author: Petr Jelinek, heavily editorialized by Andres Freund Reviewed-By: Andres Freund Discussion: https://postgr.es/m/9a897b86-46e1-9915-ee4c-da02e4ff6a95@2ndquadrant.com Backport: 9.4, where logical decoding was introduced. --- src/backend/replication/logical/logical.c | 25 ++++++++++++++------- src/backend/replication/logical/snapbuild.c | 12 ++++++++++ src/backend/replication/slot.c | 25 +++++++++++++++++---- src/backend/replication/slotfuncs.c | 4 ++-- src/backend/replication/walsender.c | 1 + src/backend/storage/ipc/procarray.c | 14 +++++++++--- src/include/replication/logical.h | 1 + src/include/storage/procarray.h | 2 +- 8 files changed, 66 insertions(+), 18 deletions(-) diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c index 1512be5322..40432fe640 100644 --- a/src/backend/replication/logical/logical.c +++ b/src/backend/replication/logical/logical.c @@ -210,6 +210,7 @@ StartupDecodingContext(List *output_plugin_options, LogicalDecodingContext * CreateInitDecodingContext(char *plugin, List *output_plugin_options, + bool need_full_snapshot, XLogPageReadCB read_page, LogicalOutputPluginWriterPrepareWrite prepare_write, LogicalOutputPluginWriterWrite do_write) @@ -267,23 +268,31 @@ CreateInitDecodingContext(char *plugin, * the slot machinery about the new limit. Once that's done the * ProcArrayLock can be released as the slot machinery now is * protecting against vacuum. + * + * Note that, temporarily, the data, not just the catalog, xmin has to be + * reserved if a data snapshot is to be exported. Otherwise the initial + * data snapshot created here is not guaranteed to be valid. After that + * the data xmin doesn't need to be managed anymore and the global xmin + * should be recomputed. As we are fine with losing the pegged data xmin + * after crash - no chance a snapshot would get exported anymore - we can + * get away with just setting the slot's + * effective_xmin. ReplicationSlotRelease will reset it again. + * * ---- */ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); - slot->effective_catalog_xmin = GetOldestSafeDecodingTransactionId(); - slot->data.catalog_xmin = slot->effective_catalog_xmin; + xmin_horizon = GetOldestSafeDecodingTransactionId(need_full_snapshot); + + slot->effective_catalog_xmin = xmin_horizon; + slot->data.catalog_xmin = xmin_horizon; + if (need_full_snapshot) + slot->effective_xmin = xmin_horizon; ReplicationSlotsComputeRequiredXmin(true); LWLockRelease(ProcArrayLock); - /* - * tell the snapshot builder to only assemble snapshot once reaching the - * running_xact's record with the respective xmin. - */ - xmin_horizon = slot->data.catalog_xmin; - ReplicationSlotMarkDirty(); ReplicationSlotSave(); diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c index 6ae09ce400..727ef77853 100644 --- a/src/backend/replication/logical/snapbuild.c +++ b/src/backend/replication/logical/snapbuild.c @@ -551,6 +551,18 @@ SnapBuildExportSnapshot(SnapBuild *builder) * mechanism. Due to that we can do this without locks, we're only * changing our own value. */ +#ifdef USE_ASSERT_CHECKING + { + TransactionId safeXid; + + LWLockAcquire(ProcArrayLock, LW_SHARED); + safeXid = GetOldestSafeDecodingTransactionId(true); + LWLockRelease(ProcArrayLock); + + Assert(TransactionIdPrecedesOrEquals(safeXid, snap->xmin)); + } +#endif + MyPgXact->xmin = snap->xmin; /* allocate in transaction context */ diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index 0b2575ee9d..d64cfc6dc9 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -397,6 +397,22 @@ ReplicationSlotRelease(void) SpinLockRelease(&slot->mutex); } + + /* + * If slot needed to temporarily restrain both data and catalog xmin to + * create the catalog snapshot, remove that temporary constraint. + * Snapshots can only be exported while the initial snapshot is still + * acquired. + */ + if (!TransactionIdIsValid(slot->data.xmin) && + TransactionIdIsValid(slot->effective_xmin)) + { + SpinLockAcquire(&slot->mutex); + slot->effective_xmin = InvalidTransactionId; + SpinLockRelease(&slot->mutex); + ReplicationSlotsComputeRequiredXmin(false); + } + MyReplicationSlot = NULL; /* might not have been set when we've been a plain slot */ @@ -574,6 +590,9 @@ ReplicationSlotPersist(void) /* * Compute the oldest xmin across all slots and store it in the ProcArray. + * + * If already_locked is true, ProcArrayLock has already been acquired + * exclusively. */ void ReplicationSlotsComputeRequiredXmin(bool already_locked) @@ -584,8 +603,7 @@ ReplicationSlotsComputeRequiredXmin(bool already_locked) Assert(ReplicationSlotCtl != NULL); - if (!already_locked) - LWLockAcquire(ReplicationSlotControlLock, LW_SHARED); + LWLockAcquire(ReplicationSlotControlLock, LW_SHARED); for (i = 0; i < max_replication_slots; i++) { @@ -614,8 +632,7 @@ ReplicationSlotsComputeRequiredXmin(bool already_locked) agg_catalog_xmin = effective_catalog_xmin; } - if (!already_locked) - LWLockRelease(ReplicationSlotControlLock); + LWLockRelease(ReplicationSlotControlLock); ProcArraySetReplicationSlotXmin(agg_xmin, agg_catalog_xmin, already_locked); } diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c index f9087619d2..de8cd2a67e 100644 --- a/src/backend/replication/slotfuncs.c +++ b/src/backend/replication/slotfuncs.c @@ -125,8 +125,8 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS) /* * Create logical decoding context, to build the initial snapshot. */ - ctx = CreateInitDecodingContext( - NameStr(*plugin), NIL, + ctx = CreateInitDecodingContext(NameStr(*plugin), NIL, + false, /* do not build snapshot */ logical_read_local_xlog_page, NULL, NULL); /* build initial snapshot, might take a while */ diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index b2c059e6b0..834bf947a3 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -813,6 +813,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd) LogicalDecodingContext *ctx; ctx = CreateInitDecodingContext(cmd->plugin, NIL, + true, /* build snapshot */ logical_read_xlog_page, WalSndPrepareWrite, WalSndWriteData); diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index 651c561dfd..a3a0207872 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -2153,7 +2153,7 @@ GetOldestActiveTransactionId(void) * that the caller will immediately use the xid to peg the xmin horizon. */ TransactionId -GetOldestSafeDecodingTransactionId(void) +GetOldestSafeDecodingTransactionId(bool catalogOnly) { ProcArrayStruct *arrayP = procArray; TransactionId oldestSafeXid; @@ -2176,9 +2176,17 @@ GetOldestSafeDecodingTransactionId(void) /* * If there's already a slot pegging the xmin horizon, we can start with * that value, it's guaranteed to be safe since it's computed by this - * routine initially and has been enforced since. + * routine initially and has been enforced since. We can always use the + * slot's general xmin horizon, but the catalog horizon is only usable + * when we only catalog data is going to be looked at. */ - if (TransactionIdIsValid(procArray->replication_slot_catalog_xmin) && + if (TransactionIdIsValid(procArray->replication_slot_xmin) && + TransactionIdPrecedes(procArray->replication_slot_xmin, + oldestSafeXid)) + oldestSafeXid = procArray->replication_slot_xmin; + + if (catalogOnly && + TransactionIdIsValid(procArray->replication_slot_catalog_xmin) && TransactionIdPrecedes(procArray->replication_slot_catalog_xmin, oldestSafeXid)) oldestSafeXid = procArray->replication_slot_catalog_xmin; diff --git a/src/include/replication/logical.h b/src/include/replication/logical.h index 947000e63f..ad3ff5eacb 100644 --- a/src/include/replication/logical.h +++ b/src/include/replication/logical.h @@ -79,6 +79,7 @@ extern void CheckLogicalDecodingRequirements(void); extern LogicalDecodingContext *CreateInitDecodingContext(char *plugin, List *output_plugin_options, + bool need_full_snapshot, XLogPageReadCB read_page, LogicalOutputPluginWriterPrepareWrite prepare_write, LogicalOutputPluginWriterWrite do_write); diff --git a/src/include/storage/procarray.h b/src/include/storage/procarray.h index ecc3c4a4f6..f6af33340b 100644 --- a/src/include/storage/procarray.h +++ b/src/include/storage/procarray.h @@ -55,7 +55,7 @@ extern bool TransactionIdIsInProgress(TransactionId xid); extern bool TransactionIdIsActive(TransactionId xid); extern TransactionId GetOldestXmin(Relation rel, bool ignoreVacuum); extern TransactionId GetOldestActiveTransactionId(void); -extern TransactionId GetOldestSafeDecodingTransactionId(void); +extern TransactionId GetOldestSafeDecodingTransactionId(bool catalogOnly); extern VirtualTransactionId *GetVirtualXIDsDelayingChkpt(int *nvxids); extern bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids); From 53b157846024f28f8d48a6e0163c89a577f886a8 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 27 Apr 2017 17:13:29 -0400 Subject: [PATCH 0024/1139] Cope with glibc too old to have epoll_create1(). Commit fa31b6f4e supposed that we didn't have to worry about that anymore, but it seems that RHEL5 is like that, and that's still a supported platform. Put back the prior coding under an #ifdef, adding an explicit fcntl() to retain the desired CLOEXEC property. Discussion: https://postgr.es/m/12307.1493325329@sss.pgh.pa.us --- src/backend/storage/ipc/latch.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/backend/storage/ipc/latch.c b/src/backend/storage/ipc/latch.c index 86e18a4aa6..437ee6edc5 100644 --- a/src/backend/storage/ipc/latch.c +++ b/src/backend/storage/ipc/latch.c @@ -574,9 +574,18 @@ CreateWaitEventSet(MemoryContext context, int nevents) set->nevents_space = nevents; #if defined(WAIT_USE_EPOLL) +#ifdef EPOLL_CLOEXEC set->epoll_fd = epoll_create1(EPOLL_CLOEXEC); if (set->epoll_fd < 0) elog(ERROR, "epoll_create1 failed: %m"); +#else + /* cope with ancient glibc lacking epoll_create1 (e.g., RHEL5) */ + set->epoll_fd = epoll_create(nevents); + if (set->epoll_fd < 0) + elog(ERROR, "epoll_create failed: %m"); + if (fcntl(set->epoll_fd, F_SETFD, FD_CLOEXEC) == -1) + elog(ERROR, "fcntl(F_SETFD) failed on epoll descriptor: %m"); +#endif /* EPOLL_CLOEXEC */ #elif defined(WAIT_USE_WIN32) /* From 29e8c881dd077fd94d3f35a341c266f72e9285f2 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Thu, 27 Apr 2017 15:28:24 -0700 Subject: [PATCH 0025/1139] Don't use on-disk snapshots for exported logical decoding snapshot. Logical decoding stores historical snapshots on disk, so that logical decoding can restart without having to reconstruct a snapshot from scratch (for which the resources are not guaranteed to be present anymore). These serialized snapshots were also used when creating a new slot via the walsender interface, which can export a "full" snapshot (i.e. one that can read all tables, not just catalog ones). The problem is that the serialized snapshots are only useful for catalogs and not for normal user tables. Thus the use of such a serialized snapshot could result in an inconsistent snapshot being exported, which could lead to queries returning wrong data. This would only happen if logical slots are created while another logical slot already exists. Author: Petr Jelinek Reviewed-By: Andres Freund Discussion: https://postgr.es/m/f37e975c-908f-858e-707f-058d3b1eb214@2ndquadrant.com Backport: 9.4, where logical decoding was introduced. --- src/backend/replication/logical/logical.c | 9 ++++++--- src/backend/replication/logical/snapbuild.c | 19 ++++++++++++++----- src/include/replication/snapbuild.h | 3 ++- 3 files changed, 22 insertions(+), 9 deletions(-) diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c index 40432fe640..3ea80253d3 100644 --- a/src/backend/replication/logical/logical.c +++ b/src/backend/replication/logical/logical.c @@ -114,6 +114,7 @@ static LogicalDecodingContext * StartupDecodingContext(List *output_plugin_options, XLogRecPtr start_lsn, TransactionId xmin_horizon, + bool need_full_snapshot, XLogPageReadCB read_page, LogicalOutputPluginWriterPrepareWrite prepare_write, LogicalOutputPluginWriterWrite do_write) @@ -171,7 +172,8 @@ StartupDecodingContext(List *output_plugin_options, ctx->reorder = ReorderBufferAllocate(); ctx->snapshot_builder = - AllocateSnapshotBuilder(ctx->reorder, xmin_horizon, start_lsn); + AllocateSnapshotBuilder(ctx->reorder, xmin_horizon, start_lsn, + need_full_snapshot); ctx->reorder->private_data = ctx; @@ -297,7 +299,8 @@ CreateInitDecodingContext(char *plugin, ReplicationSlotSave(); ctx = StartupDecodingContext(NIL, InvalidXLogRecPtr, xmin_horizon, - read_page, prepare_write, do_write); + need_full_snapshot, read_page, prepare_write, + do_write); /* call output plugin initialization callback */ old_context = MemoryContextSwitchTo(ctx->context); @@ -386,7 +389,7 @@ CreateDecodingContext(XLogRecPtr start_lsn, } ctx = StartupDecodingContext(output_plugin_options, - start_lsn, InvalidTransactionId, + start_lsn, InvalidTransactionId, false, read_page, prepare_write, do_write); /* call output plugin initialization callback */ diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c index 727ef77853..9f0796a0ec 100644 --- a/src/backend/replication/logical/snapbuild.c +++ b/src/backend/replication/logical/snapbuild.c @@ -164,6 +164,9 @@ struct SnapBuild */ TransactionId initial_xmin_horizon; + /* Indicates if we are building full snapshot or just catalog one .*/ + bool building_full_snapshot; + /* * Snapshot that's valid to see the catalog state seen at this moment. */ @@ -280,7 +283,8 @@ static bool SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn); SnapBuild * AllocateSnapshotBuilder(ReorderBuffer *reorder, TransactionId xmin_horizon, - XLogRecPtr start_lsn) + XLogRecPtr start_lsn, + bool need_full_snapshot) { MemoryContext context; MemoryContext oldcontext; @@ -307,6 +311,7 @@ AllocateSnapshotBuilder(ReorderBuffer *reorder, builder->initial_xmin_horizon = xmin_horizon; builder->start_decoding_at = start_lsn; + builder->building_full_snapshot = need_full_snapshot; MemoryContextSwitchTo(oldcontext); @@ -1227,7 +1232,7 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn * * a) There were no running transactions when the xl_running_xacts record * was inserted, jump to CONSISTENT immediately. We might find such a - * state we were waiting for b) and c). + * state we were waiting for b) or c). * * b) Wait for all toplevel transactions that were running to end. We * simply track the number of in-progress toplevel transactions and @@ -1242,7 +1247,10 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn * at all. * * c) This (in a previous run) or another decoding slot serialized a - * snapshot to disk that we can use. + * snapshot to disk that we can use. Can't use this method for the + * initial snapshot when slot is being created and needs full snapshot + * for export or direct use, as that snapshot will only contain catalog + * modifying transactions. * --- */ @@ -1297,8 +1305,9 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn return false; } - /* c) valid on disk state */ - else if (SnapBuildRestore(builder, lsn)) + /* c) valid on disk state and not building full snapshot */ + else if (!builder->building_full_snapshot && + SnapBuildRestore(builder, lsn)) { /* there won't be any state to cleanup */ return false; diff --git a/src/include/replication/snapbuild.h b/src/include/replication/snapbuild.h index df229a895c..1df4f37634 100644 --- a/src/include/replication/snapbuild.h +++ b/src/include/replication/snapbuild.h @@ -54,7 +54,8 @@ struct xl_running_xacts; extern void CheckPointSnapBuild(void); extern SnapBuild *AllocateSnapshotBuilder(struct ReorderBuffer *cache, - TransactionId xmin_horizon, XLogRecPtr start_lsn); + TransactionId xmin_horizon, XLogRecPtr start_lsn, + bool need_full_snapshot); extern void FreeSnapshotBuilder(SnapBuild *cache); extern void SnapBuildSnapDecRefcount(Snapshot snap); From 8a9c83bfaf889702401f532fbe2adaf604ca1bd6 Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Fri, 28 Apr 2017 14:48:38 -0400 Subject: [PATCH 0026/1139] Fix VALIDATE CONSTRAINT to consider NO INHERIT attribute. Currently, trying to validate a NO INHERIT constraint on the parent will search for the constraint in child tables (where it is not supposed to exist), wrongly causing a "constraint does not exist" error. Amit Langote, per a report from Hans Buschmann. Discussion: http://postgr.es/m/20170421184012.24362.19@wrigleys.postgresql.org --- src/backend/commands/tablecmds.c | 5 +++-- src/test/regress/expected/alter_table.out | 20 ++++++++++++++++++++ src/test/regress/sql/alter_table.sql | 15 +++++++++++++++ 3 files changed, 38 insertions(+), 2 deletions(-) diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 608b0b19c4..5fe367d46b 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -6903,9 +6903,10 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse, /* * If we're recursing, the parent has already done this, so skip - * it. + * it. Also, if the constraint is a NO INHERIT constraint, we + * shouldn't try to look for it in the children. */ - if (!recursing) + if (!recursing && !con->connoinherit) children = find_all_inheritors(RelationGetRelid(rel), lockmode, NULL); diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out index f931236410..513d9e20f6 100644 --- a/src/test/regress/expected/alter_table.out +++ b/src/test/regress/expected/alter_table.out @@ -367,6 +367,26 @@ NOTICE: merging constraint "identity" with inherited definition ALTER TABLE tmp3 VALIDATE CONSTRAINT identity; NOTICE: boo: 16 NOTICE: boo: 20 +-- A NO INHERIT constraint should not be looked for in children during VALIDATE CONSTRAINT +create table parent_noinh_convalid (a int); +create table child_noinh_convalid () inherits (parent_noinh_convalid); +insert into parent_noinh_convalid values (1); +insert into child_noinh_convalid values (1); +alter table parent_noinh_convalid add constraint check_a_is_2 check (a = 2) no inherit not valid; +-- fail, because of the row in parent +alter table parent_noinh_convalid validate constraint check_a_is_2; +ERROR: check constraint "check_a_is_2" is violated by some row +delete from only parent_noinh_convalid; +-- ok (parent itself contains no violating rows) +alter table parent_noinh_convalid validate constraint check_a_is_2; +select convalidated from pg_constraint where conrelid = 'parent_noinh_convalid'::regclass and conname = 'check_a_is_2'; + convalidated +-------------- + t +(1 row) + +-- cleanup +drop table parent_noinh_convalid, child_noinh_convalid; -- Try (and fail) to create constraint from tmp5(a) to tmp4(a) - unique constraint on -- tmp4 is a,b ALTER TABLE tmp5 add constraint tmpconstr foreign key(a) references tmp4(a) match full; diff --git a/src/test/regress/sql/alter_table.sql b/src/test/regress/sql/alter_table.sql index 4a32f99ec7..9b3615b4dd 100644 --- a/src/test/regress/sql/alter_table.sql +++ b/src/test/regress/sql/alter_table.sql @@ -307,6 +307,21 @@ ALTER TABLE tmp7 ADD CONSTRAINT identity CHECK (b = boo(b)); ALTER TABLE tmp3 ADD CONSTRAINT IDENTITY check (b = boo(b)) NOT VALID; ALTER TABLE tmp3 VALIDATE CONSTRAINT identity; +-- A NO INHERIT constraint should not be looked for in children during VALIDATE CONSTRAINT +create table parent_noinh_convalid (a int); +create table child_noinh_convalid () inherits (parent_noinh_convalid); +insert into parent_noinh_convalid values (1); +insert into child_noinh_convalid values (1); +alter table parent_noinh_convalid add constraint check_a_is_2 check (a = 2) no inherit not valid; +-- fail, because of the row in parent +alter table parent_noinh_convalid validate constraint check_a_is_2; +delete from only parent_noinh_convalid; +-- ok (parent itself contains no violating rows) +alter table parent_noinh_convalid validate constraint check_a_is_2; +select convalidated from pg_constraint where conrelid = 'parent_noinh_convalid'::regclass and conname = 'check_a_is_2'; +-- cleanup +drop table parent_noinh_convalid, child_noinh_convalid; + -- Try (and fail) to create constraint from tmp5(a) to tmp4(a) - unique constraint on -- tmp4 is a,b From 0a65b18d2d17891766627da73633e808e66ecdd1 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Fri, 28 Apr 2017 15:30:54 -0400 Subject: [PATCH 0027/1139] doc: Fix typo in 9.6 release notes Author: Huong Dangminh --- doc/src/sgml/release-9.6.sgml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml index ac404ff3b1..0ef2b0c64e 100644 --- a/doc/src/sgml/release-9.6.sgml +++ b/doc/src/sgml/release-9.6.sgml @@ -5004,7 +5004,7 @@ This commit is also listed under libpq and PL/pgSQL --> Allow the number of client connections ( From 6872d96a3bb893c987a3df623754c13deac8254f Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 30 Apr 2017 15:13:51 -0400 Subject: [PATCH 0028/1139] Sync our copy of the timezone library with IANA release tzcode2017b. zic no longer mishandles some transitions in January 2038 when it attempts to work around Qt bug 53071. This fixes a bug affecting Pacific/Tongatapu that was introduced in zic 2016e. localtime.c now contains a workaround, useful when loading a file generated by a buggy zic. There are assorted cosmetic changes as well, notably relocation of a bunch of #defines. --- src/timezone/README | 2 +- src/timezone/localtime.c | 73 +++++++++++++++++++++++++++++--------- src/timezone/pgtz.c | 9 ++--- src/timezone/private.h | 76 ++++++++++++++++++++++++++++++---------- src/timezone/strftime.c | 11 ++++-- src/timezone/tzfile.h | 52 --------------------------- src/timezone/zic.c | 15 ++++++-- 7 files changed, 139 insertions(+), 99 deletions(-) diff --git a/src/timezone/README b/src/timezone/README index a82d77c7ba..2544230c4c 100644 --- a/src/timezone/README +++ b/src/timezone/README @@ -50,7 +50,7 @@ match properly on the old version. Time Zone code ============== -The code in this directory is currently synced with tzcode release 2016j. +The code in this directory is currently synced with tzcode release 2017b. There are many cosmetic (and not so cosmetic) differences from the original tzcode library, but diffs in the upstream version should usually be propagated to our version. Here are some notes about that. diff --git a/src/timezone/localtime.c b/src/timezone/localtime.c index ae9c2d23e6..6e0fa10066 100644 --- a/src/timezone/localtime.c +++ b/src/timezone/localtime.c @@ -17,8 +17,9 @@ #include #include "datatype/timestamp.h" -#include "private.h" #include "pgtz.h" + +#include "private.h" #include "tzfile.h" @@ -414,10 +415,10 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, { /* * Attempt to reuse existing abbreviations. Without this, - * America/Anchorage would stop working after 2037 when - * TZ_MAX_CHARS is 50, as sp->charcnt equals 42 (for LMT CAT CAWT - * CAPT AHST AHDT YST AKDT AKST) and ts->charcnt equals 10 (for - * AKST AKDT). Reusing means sp->charcnt can stay 42 in this + * America/Anchorage would be right on the edge after 2037 when + * TZ_MAX_CHARS is 50, as sp->charcnt equals 40 (for LMT AST AWT + * APT AHST AHDT YST AKDT AKST) and ts->charcnt equals 10 (for + * AKST AKDT). Reusing means sp->charcnt can stay 40 in this * example. */ int gotabbr = 0; @@ -451,6 +452,17 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, if (gotabbr == 2) { sp->charcnt = charcnt; + + /* + * Ignore any trailing, no-op transitions generated by zic as + * they don't help here and can run afoul of bugs in zic 2016j + * or earlier. + */ + while (1 < sp->timecnt + && (sp->types[sp->timecnt - 1] + == sp->types[sp->timecnt - 2])) + sp->timecnt--; + for (i = 0; i < ts->timecnt; i++) if (sp->ats[sp->timecnt - 1] < ts->ats[i]) break; @@ -974,6 +986,8 @@ tzparse(const char *name, struct state * sp, bool lastditch) int yearlim; int timecnt; pg_time_t janfirst; + int32 janoffset = 0; + int yearbeg; ++name; if ((name = getrule(name, &start)) == NULL) @@ -994,8 +1008,23 @@ tzparse(const char *name, struct state * sp, bool lastditch) sp->defaulttype = 0; timecnt = 0; janfirst = 0; - yearlim = EPOCH_YEAR + YEARSPERREPEAT; - for (year = EPOCH_YEAR; year < yearlim; year++) + yearbeg = EPOCH_YEAR; + + do + { + int32 yearsecs + = year_lengths[isleap(yearbeg - 1)] * SECSPERDAY; + + yearbeg--; + if (increment_overflow_time(&janfirst, -yearsecs)) + { + janoffset = -yearsecs; + break; + } + } while (EPOCH_YEAR - YEARSPERREPEAT / 2 < yearbeg); + + yearlim = yearbeg + YEARSPERREPEAT + 1; + for (year = yearbeg; year < yearlim; year++) { int32 starttime = transtime(year, &start, stdoffset), @@ -1020,24 +1049,34 @@ tzparse(const char *name, struct state * sp, bool lastditch) { if (TZ_MAX_TIMES - 2 < timecnt) break; - yearlim = year + YEARSPERREPEAT + 1; sp->ats[timecnt] = janfirst; - if (increment_overflow_time - (&sp->ats[timecnt], starttime)) - break; - sp->types[timecnt++] = reversed; + if (!increment_overflow_time + (&sp->ats[timecnt], + janoffset + starttime)) + sp->types[timecnt++] = reversed; + else if (janoffset) + sp->defaulttype = reversed; sp->ats[timecnt] = janfirst; - if (increment_overflow_time - (&sp->ats[timecnt], endtime)) - break; - sp->types[timecnt++] = !reversed; + if (!increment_overflow_time + (&sp->ats[timecnt], + janoffset + endtime)) + { + sp->types[timecnt++] = !reversed; + yearlim = year + YEARSPERREPEAT + 1; + } + else if (janoffset) + sp->defaulttype = !reversed; } - if (increment_overflow_time(&janfirst, yearsecs)) + if (increment_overflow_time + (&janfirst, janoffset + yearsecs)) break; + janoffset = 0; } sp->timecnt = timecnt; if (!timecnt) sp->typecnt = 1; /* Perpetual DST. */ + else if (YEARSPERREPEAT < year - yearbeg) + sp->goback = sp->goahead = true; } else { diff --git a/src/timezone/pgtz.c b/src/timezone/pgtz.c index 4fa3d0da89..982fc1fe71 100644 --- a/src/timezone/pgtz.c +++ b/src/timezone/pgtz.c @@ -17,6 +17,7 @@ #include #include +#include "datatype/timestamp.h" #include "miscadmin.h" #include "pgtz.h" #include "storage/fd.h" @@ -308,14 +309,14 @@ pg_tzset_offset(long gmtoffset) char tzname[128]; snprintf(offsetstr, sizeof(offsetstr), - "%02ld", absoffset / SECSPERHOUR); - absoffset %= SECSPERHOUR; + "%02ld", absoffset / SECS_PER_HOUR); + absoffset %= SECS_PER_HOUR; if (absoffset != 0) { snprintf(offsetstr + strlen(offsetstr), sizeof(offsetstr) - strlen(offsetstr), - ":%02ld", absoffset / SECSPERMIN); - absoffset %= SECSPERMIN; + ":%02ld", absoffset / SECS_PER_MINUTE); + absoffset %= SECS_PER_MINUTE; if (absoffset != 0) snprintf(offsetstr + strlen(offsetstr), sizeof(offsetstr) - strlen(offsetstr), diff --git a/src/timezone/private.h b/src/timezone/private.h index b8533d51e8..f031b17b7e 100644 --- a/src/timezone/private.h +++ b/src/timezone/private.h @@ -67,14 +67,8 @@ extern int unlink(const char *filename); * Finally, some convenience items. */ -#ifndef TYPE_BIT #define TYPE_BIT(type) (sizeof (type) * CHAR_BIT) -#endif /* !defined TYPE_BIT */ - -#ifndef TYPE_SIGNED #define TYPE_SIGNED(type) (((type) -1) < 0) -#endif /* !defined TYPE_SIGNED */ - #define TWOS_COMPLEMENT(t) ((t) ~ (t) 0 < 0) /* @@ -88,7 +82,6 @@ extern int unlink(const char *filename); #define MINVAL(t, b) \ ((t) (TYPE_SIGNED(t) ? - TWOS_COMPLEMENT(t) - MAXVAL(t, b) : 0)) -#ifndef INT_STRLEN_MAXIMUM /* * 302 / 1000 is log10(2.0) rounded up. * Subtract one for the sign bit if the type is signed; @@ -98,7 +91,6 @@ extern int unlink(const char *filename); #define INT_STRLEN_MAXIMUM(type) \ ((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + \ 1 + TYPE_SIGNED(type)) -#endif /* !defined INT_STRLEN_MAXIMUM */ /* * INITIALIZE(x) @@ -108,24 +100,70 @@ extern int unlink(const char *filename); #undef _ #define _(msgid) (msgid) -#ifndef YEARSPERREPEAT +/* Handy macros that are independent of tzfile implementation. */ + #define YEARSPERREPEAT 400 /* years before a Gregorian repeat */ -#endif /* !defined YEARSPERREPEAT */ + +#define SECSPERMIN 60 +#define MINSPERHOUR 60 +#define HOURSPERDAY 24 +#define DAYSPERWEEK 7 +#define DAYSPERNYEAR 365 +#define DAYSPERLYEAR 366 +#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR) +#define SECSPERDAY ((int32) SECSPERHOUR * HOURSPERDAY) +#define MONSPERYEAR 12 + +#define TM_SUNDAY 0 +#define TM_MONDAY 1 +#define TM_TUESDAY 2 +#define TM_WEDNESDAY 3 +#define TM_THURSDAY 4 +#define TM_FRIDAY 5 +#define TM_SATURDAY 6 + +#define TM_JANUARY 0 +#define TM_FEBRUARY 1 +#define TM_MARCH 2 +#define TM_APRIL 3 +#define TM_MAY 4 +#define TM_JUNE 5 +#define TM_JULY 6 +#define TM_AUGUST 7 +#define TM_SEPTEMBER 8 +#define TM_OCTOBER 9 +#define TM_NOVEMBER 10 +#define TM_DECEMBER 11 + +#define TM_YEAR_BASE 1900 + +#define EPOCH_YEAR 1970 +#define EPOCH_WDAY TM_THURSDAY + +#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0)) /* - * The Gregorian year averages 365.2425 days, which is 31556952 seconds. + * Since everything in isleap is modulo 400 (or a factor of 400), we know that + * isleap(y) == isleap(y % 400) + * and so + * isleap(a + b) == isleap((a + b) % 400) + * or + * isleap(a + b) == isleap(a % 400 + b % 400) + * This is true even if % means modulo rather than Fortran remainder + * (which is allowed by C89 but not C99). + * We use this to avoid addition overflow problems. */ -#ifndef AVGSECSPERYEAR -#define AVGSECSPERYEAR 31556952L -#endif /* !defined AVGSECSPERYEAR */ +#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400) -#ifndef SECSPERREPEAT -#define SECSPERREPEAT ((int64) YEARSPERREPEAT * (int64) AVGSECSPERYEAR) -#endif /* !defined SECSPERREPEAT */ -#ifndef SECSPERREPEAT_BITS +/* + * The Gregorian year averages 365.2425 days, which is 31556952 seconds. + */ + +#define AVGSECSPERYEAR 31556952L +#define SECSPERREPEAT \ + ((int64) YEARSPERREPEAT * (int64) AVGSECSPERYEAR) #define SECSPERREPEAT_BITS 34 /* ceil(log2(SECSPERREPEAT)) */ -#endif /* !defined SECSPERREPEAT_BITS */ #endif /* !defined PRIVATE_H */ diff --git a/src/timezone/strftime.c b/src/timezone/strftime.c index 4a0a01db65..ab8f60e9c8 100644 --- a/src/timezone/strftime.c +++ b/src/timezone/strftime.c @@ -1,4 +1,4 @@ -/* Convert a broken-down time stamp to a string. */ +/* Convert a broken-down timestamp to a string. */ /* * Copyright 1989 The Regents of the University of California. @@ -44,7 +44,6 @@ #include #include "private.h" -#include "tzfile.h" struct lc_time_T @@ -452,11 +451,17 @@ _fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, { long diff; char const *sign; + bool negative; if (t->tm_isdst < 0) continue; diff = t->tm_gmtoff; - if (diff < 0) + negative = diff < 0; + if (diff == 0) + { + negative = t->tm_zone[0] == '-'; + } + if (negative) { sign = "-"; diff = -diff; diff --git a/src/timezone/tzfile.h b/src/timezone/tzfile.h index 32d237b827..56a5b43472 100644 --- a/src/timezone/tzfile.h +++ b/src/timezone/tzfile.h @@ -100,56 +100,4 @@ struct tzhead #define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */ -#define SECSPERMIN 60 -#define MINSPERHOUR 60 -#define HOURSPERDAY 24 -#define DAYSPERWEEK 7 -#define DAYSPERNYEAR 365 -#define DAYSPERLYEAR 366 -#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR) -#define SECSPERDAY ((int32) SECSPERHOUR * HOURSPERDAY) -#define MONSPERYEAR 12 - -#define TM_SUNDAY 0 -#define TM_MONDAY 1 -#define TM_TUESDAY 2 -#define TM_WEDNESDAY 3 -#define TM_THURSDAY 4 -#define TM_FRIDAY 5 -#define TM_SATURDAY 6 - -#define TM_JANUARY 0 -#define TM_FEBRUARY 1 -#define TM_MARCH 2 -#define TM_APRIL 3 -#define TM_MAY 4 -#define TM_JUNE 5 -#define TM_JULY 6 -#define TM_AUGUST 7 -#define TM_SEPTEMBER 8 -#define TM_OCTOBER 9 -#define TM_NOVEMBER 10 -#define TM_DECEMBER 11 - -#define TM_YEAR_BASE 1900 - -#define EPOCH_YEAR 1970 -#define EPOCH_WDAY TM_THURSDAY - -#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0)) - -/* - * Since everything in isleap is modulo 400 (or a factor of 400), we know that - * isleap(y) == isleap(y % 400) - * and so - * isleap(a + b) == isleap((a + b) % 400) - * or - * isleap(a + b) == isleap(a % 400 + b % 400) - * This is true even if % means modulo rather than Fortran remainder - * (which is allowed by C89 but not C99). - * We use this to avoid addition overflow problems. - */ - -#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400) - #endif /* !defined TZFILE_H */ diff --git a/src/timezone/zic.c b/src/timezone/zic.c index a83cea12dd..f6beedcab2 100644 --- a/src/timezone/zic.c +++ b/src/timezone/zic.c @@ -2672,6 +2672,9 @@ outzone(const struct zone * zpfirst, ptrdiff_t zonecount) bool do_extend; char version; ptrdiff_t lastatmax = -1; + zic_t one = 1; + zic_t y2038_boundary = one << 31; + zic_t max_year0; max_abbr_len = 2 + max_format_len + max_abbrvar_len; max_envvar_len = 2 * max_abbr_len + 5 * 9; @@ -2781,12 +2784,13 @@ outzone(const struct zone * zpfirst, ptrdiff_t zonecount) } /* - * For the benefit of older systems, generate data from 1900 through 2037. + * For the benefit of older systems, generate data from 1900 through 2038. */ if (min_year > 1900) min_year = 1900; - if (max_year < 2037) - max_year = 2037; + max_year0 = max_year; + if (max_year < 2038) + max_year = 2038; for (i = 0; i < zonecount; ++i) { /* @@ -2836,7 +2840,12 @@ outzone(const struct zone * zpfirst, ptrdiff_t zonecount) year <= rp->r_hiyear && yearistype(year, rp->r_yrtype); if (rp->r_todo) + { rp->r_temp = rpytime(rp, year); + rp->r_todo + = (rp->r_temp < y2038_boundary + || year <= max_year0); + } } for (;;) { From 66510630d8621a638b487fa5ae685bdc60240440 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Mon, 1 May 2017 10:12:02 -0400 Subject: [PATCH 0029/1139] Allow vcregress.pl to run an arbitrary TAP test set Currently only provision for running the bin checks in a single step is provided for. Now these tests can be run individually, as well as tests in other locations (e.g. src.test/recover). Also provide for suppressing unnecessary temp installs by setting the NO_TEMP_INSTALL environment variable just as the Makefiles do. Backpatch to 9.4. --- src/tools/msvc/vcregress.pl | 48 +++++++++++++++++++++++-------------- 1 file changed, 30 insertions(+), 18 deletions(-) diff --git a/src/tools/msvc/vcregress.pl b/src/tools/msvc/vcregress.pl index b4f946474f..5a08a585a5 100644 --- a/src/tools/msvc/vcregress.pl +++ b/src/tools/msvc/vcregress.pl @@ -34,7 +34,7 @@ my $what = shift || ""; if ($what =~ -/^(check|installcheck|plcheck|contribcheck|modulescheck|ecpgcheck|isolationcheck|upgradecheck|bincheck|recoverycheck)$/i +/^(check|installcheck|plcheck|contribcheck|modulescheck|ecpgcheck|isolationcheck|upgradecheck|bincheck|recoverycheck|taptest)$/i ) { $what = uc $what; @@ -54,13 +54,6 @@ $ENV{PATH} = "$topdir/$Config/libpq;$ENV{PATH}"; -my $schedule = shift; -unless ($schedule) -{ - $schedule = "serial"; - $schedule = "parallel" if ($what eq 'CHECK' || $what =~ /PARALLEL/); -} - if ($ENV{PERL5LIB}) { $ENV{PERL5LIB} = "$topdir/src/tools/msvc;$ENV{PERL5LIB}"; @@ -90,13 +83,14 @@ ISOLATIONCHECK => \&isolationcheck, BINCHECK => \&bincheck, RECOVERYCHECK => \&recoverycheck, - UPGRADECHECK => \&upgradecheck,); + UPGRADECHECK => \&upgradecheck, + TAPTEST => \&taptest,); my $proc = $command{$what}; exit 3 unless $proc; -&$proc(); +&$proc(@_); exit 0; @@ -104,6 +98,7 @@ sub installcheck { + my $schedule = shift || 'serial'; my @args = ( "../../../$Config/pg_regress/pg_regress", "--dlpath=.", @@ -119,6 +114,7 @@ sub installcheck sub check { + my $schedule = shift || 'parallel'; InstallTemp(); chdir "${topdir}/src/test/regress"; my @args = ( @@ -144,8 +140,8 @@ sub ecpgcheck exit $status if $status; InstallTemp(); chdir "$topdir/src/interfaces/ecpg/test"; - $schedule = "ecpg"; - my @args = ( + my $schedule = "ecpg"; + my @args = ( "../../../../$Config/pg_regress_ecpg/pg_regress_ecpg", "--bindir=", "--dbname=ecpg1_regression,ecpg2_regression", @@ -218,6 +214,17 @@ sub bincheck exit $mstat if $mstat; } +sub taptest +{ + my $dir = shift; + + die "no tests found!" unless -d "$topdir/$dir/t"; + + InstallTemp(); + my $status = tap_check("$topdir/$dir"); + exit $status if $status; +} + sub plcheck { chdir "../../pl"; @@ -515,7 +522,6 @@ sub fetchRegressOpts $m =~ s{\\\r?\n}{}g; if ($m =~ /^\s*REGRESS_OPTS\s*\+?=(.*)/m) { - # Substitute known Makefile variables, then ignore options that retain # an unhandled variable reference. Ignore anything that isn't an # option starting with "--". @@ -588,15 +594,18 @@ sub GetTests sub InstallTemp { - print "Setting up temp install\n\n"; - Install("$tmp_installdir", "all", $config); + unless ($ENV{NO_TEMP_INSTALL}) + { + print "Setting up temp install\n\n"; + Install("$tmp_installdir", "all", $config); + } $ENV{PATH} = "$tmp_installdir/bin;$ENV{PATH}"; } sub usage { print STDERR - "Usage: vcregress.pl [ ]\n\n", + "Usage: vcregress.pl [ ]\n\n", "Options for :\n", " bincheck run tests of utilities in src/bin/\n", " check deploy instance and run regression tests on it\n", @@ -607,9 +616,12 @@ sub usage " modulescheck run tests of modules in src/test/modules/\n", " plcheck run tests of PL languages\n", " recoverycheck run recovery test suite\n", + " taptest run an arbitrary TAP test set\n", " upgradecheck run tests of pg_upgrade\n", - "\nOptions for :\n", + "\nOptions for : (used by check and installcheck)\n", " serial serial mode\n", - " parallel parallel mode\n"; + " parallel parallel mode\n", + "\nOption for : for taptest\n", + " TEST_DIR (required) directory where tests reside\n"; exit(1); } From 1fdc3f6e8afe580c30515c70a04d074d527ae780 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 1 May 2017 11:52:59 -0400 Subject: [PATCH 0030/1139] Update time zone data files to tzdata release 2017b. DST law changes in Chile, Haiti, and Mongolia. Historical corrections for Ecuador, Kazakhstan, Liberia, and Spain. The IANA crew continue their campaign to replace invented time zone abbrevations with numeric GMT offsets. This update changes numerous zones in South America, the Pacific and Indian oceans, and some Asian and Middle Eastern zones. I kept these abbreviations in the tznames/ data files, however, so that we will still accept them for input. (We may want to start trimming those files someday, but I think we should wait for the upstream dust to settle before deciding what to do.) In passing, add MESZ (Mitteleuropaeische Sommerzeit) to the tznames lists; since we accept MEZ (Mitteleuropaeische Zeit) it seems rather strange not to take the other one. And fix some incorrect, or at least obsolete, comments that certain abbreviations are not traceable to the IANA data. --- src/timezone/data/africa | 126 ++++--- src/timezone/data/antarctica | 3 +- src/timezone/data/asia | 312 ++++++++-------- src/timezone/data/australasia | 159 ++++---- src/timezone/data/backward | 1 + src/timezone/data/backzone | 138 ++++--- src/timezone/data/europe | 204 ++++++---- src/timezone/data/northamerica | 95 +++-- src/timezone/data/southamerica | 554 ++++++++++++++-------------- src/timezone/known_abbrevs.txt | 113 +----- src/timezone/tznames/America.txt | 106 ++---- src/timezone/tznames/Antarctica.txt | 11 +- src/timezone/tznames/Asia.txt | 86 ++--- src/timezone/tznames/Atlantic.txt | 15 +- src/timezone/tznames/Australia.txt | 9 +- src/timezone/tznames/Default | 288 +++++---------- src/timezone/tznames/Europe.txt | 11 +- src/timezone/tznames/Indian.txt | 24 +- src/timezone/tznames/Pacific.txt | 103 ++---- src/timezone/tznames/README | 12 +- 20 files changed, 1063 insertions(+), 1307 deletions(-) diff --git a/src/timezone/data/africa b/src/timezone/data/africa index f30c910f42..dcc20b9b1c 100644 --- a/src/timezone/data/africa +++ b/src/timezone/data/africa @@ -6,15 +6,15 @@ # tz@iana.org for general use in the future). For more, please see # the file CONTRIBUTING in the tz distribution. -# From Paul Eggert (2014-10-31): +# From Paul Eggert (2017-02-20): # # Unless otherwise specified, the source for data through 1990 is: # Thomas G. Shanks and Rique Pottenger, The International Atlas (6th edition), # San Diego: ACS Publications, Inc. (2003). # Unfortunately this book contains many errors and cites no sources. # -# Gwillim Law writes that a good source -# for recent time zone data is the International Air Transport +# Many years ago Gwillim Law wrote that a good source +# for time zone data was the International Air Transport # Association's Standard Schedules Information Manual (IATA SSIM), # published semiannually. Law sent in several helpful summaries # of the IATA's data after 1990. Except where otherwise noted, @@ -31,39 +31,33 @@ # A reliable and entertaining source about time zones is # Derek Howse, Greenwich time and longitude, Philip Wilson Publishers (1997). # +# European-style abbreviations are commonly used along the Mediterranean. +# For sub-Saharan Africa abbreviations were less standardized. # Previous editions of this database used WAT, CAT, SAT, and EAT -# for +0:00 through +3:00, respectively, -# but Mark R V Murray reports that -# 'SAST' is the official abbreviation for +2:00 in the country of South Africa, -# 'CAT' is commonly used for +2:00 in countries north of South Africa, and -# 'WAT' is probably the best name for +1:00, as the common phrase for +# for UT +00 through +03, respectively, +# but in 1997 Mark R V Murray reported that +# 'SAST' is the official abbreviation for +02 in the country of South Africa, +# 'CAT' is commonly used for +02 in countries north of South Africa, and +# 'WAT' is probably the best name for +01, as the common phrase for # the area that includes Nigeria is "West Africa". -# He has heard of "Western Sahara Time" for +0:00 but can find no reference. -# -# To make things confusing, 'WAT' seems to have been used for -1:00 long ago; -# I'd guess that this was because people needed _some_ name for -1:00, -# and at the time, far west Africa was the only major land area in -1:00. -# This usage is now obsolete, as the last use of -1:00 on the African -# mainland seems to have been 1976 in Western Sahara. -# -# To summarize, the following abbreviations seem to have some currency: -# -1:00 WAT West Africa Time (no longer used) -# 0:00 GMT Greenwich Mean Time -# 2:00 CAT Central Africa Time -# 2:00 SAST South Africa Standard Time -# and Murray suggests the following abbreviation: -# 1:00 WAT West Africa Time -# I realize that this leads to 'WAT' being used for both -1:00 and 1:00 -# for times before 1976, but this is the best I can think of -# until we get more information. +# +# To summarize, the following abbreviations seemed to have some currency: +# +00 GMT Greenwich Mean Time +# +02 CAT Central Africa Time +# +02 SAST South Africa Standard Time +# and Murray suggested the following abbreviation: +# +01 WAT West Africa Time +# Murray's suggestion seems to have caught on in news reports and the like. +# I vaguely recall 'WAT' also being used for -01 in the past but +# cannot now come up with solid citations. # # I invented the following abbreviations; corrections are welcome! -# 2:00 WAST West Africa Summer Time -# 2:30 BEAT British East Africa Time (no longer used) -# 2:45 BEAUT British East Africa Unified Time (no longer used) -# 3:00 CAST Central Africa Summer Time (no longer used) -# 3:00 SAST South Africa Summer Time (no longer used) -# 3:00 EAT East Africa Time +# +02 WAST West Africa Summer Time +# +03 CAST Central Africa Summer Time (no longer used) +# +03 SAST South Africa Summer Time (no longer used) +# +03 EAT East Africa Time +# 'EAT' also seems to have caught on; the others are rare but are paired +# with better-attested non-DST abbreviations. # Algeria # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S @@ -121,17 +115,17 @@ Zone Africa/Algiers 0:12:12 - LMT 1891 Mar 15 0:01 # Cape Verde / Cabo Verde # -# Shanks gives 1907 for the transition to CVT. +# Shanks gives 1907 for the transition to +02. # Perhaps the 1911-05-26 Portuguese decree -# http://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf +# https://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf # merely made it official? # # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Atlantic/Cape_Verde -1:34:04 - LMT 1907 # Praia - -2:00 - CVT 1942 Sep - -2:00 1:00 CVST 1945 Oct 15 - -2:00 - CVT 1975 Nov 25 2:00 - -1:00 - CVT + -2:00 - -02 1942 Sep + -2:00 1:00 -01 1945 Oct 15 + -2:00 - -02 1975 Nov 25 2:00 + -1:00 - -01 # Central African Republic # See Africa/Lagos. @@ -388,7 +382,7 @@ Rule Ghana 1920 1942 - Sep 1 0:00 0:20 GHST Rule Ghana 1920 1942 - Dec 31 0:00 0 GMT # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Africa/Accra -0:00:52 - LMT 1918 - 0:00 Ghana %s + 0:00 Ghana GMT/+0020 # Guinea # See Africa/Abidjan. @@ -397,20 +391,20 @@ Zone Africa/Accra -0:00:52 - LMT 1918 # # Shanks gives 1911-05-26 for the transition to WAT, # evidently confusing the date of the Portuguese decree -# http://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf +# https://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf # with the date that it took effect, namely 1912-01-01. # # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Africa/Bissau -1:02:20 - LMT 1912 Jan 1 - -1:00 - WAT 1975 + -1:00 - -01 1975 0:00 - GMT # Kenya # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Africa/Nairobi 2:27:16 - LMT 1928 Jul 3:00 - EAT 1930 - 2:30 - BEAT 1940 - 2:45 - BEAUT 1960 + 2:30 - +0230 1940 + 2:45 - +0245 1960 3:00 - EAT Link Africa/Nairobi Africa/Addis_Ababa # Ethiopia Link Africa/Nairobi Africa/Asmara # Eritrea @@ -426,18 +420,25 @@ Link Africa/Nairobi Indian/Mayotte # See Africa/Johannesburg. # Liberia -# From Paul Eggert (2006-03-22): -# In 1972 Liberia was the last country to switch -# from a UTC offset that was not a multiple of 15 or 20 minutes. -# Howse reports that it was in honor of their president's birthday. -# Shank & Pottenger report the date as May 1, whereas Howse reports Jan; -# go with Shanks & Pottenger. -# For Liberia before 1972, Shanks & Pottenger report -0:44, whereas Howse and -# Whitman each report -0:44:30; go with the more precise figure. +# +# From Paul Eggert (2017-03-02): +# +# The Nautical Almanac for the Year 1970, p 264, is the source for -0:44:30. +# +# In 1972 Liberia was the last country to switch from a UTC offset +# that was not a multiple of 15 or 20 minutes. The 1972 change was on +# 1972-01-07, according to an entry dated 1972-01-04 on p 330 of: +# Presidential Papers: First year of the administration of +# President William R. Tolbert, Jr., July 23, 1971-July 31, 1972. +# Monrovia: Executive Mansion. +# +# Use the abbreviation "MMT" before 1972, as the more-accurate numeric +# abbreviation "-004430" would be one byte over the POSIX limit. +# # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Africa/Monrovia -0:43:08 - LMT 1882 -0:43:08 - MMT 1919 Mar # Monrovia Mean Time - -0:44:30 - LRT 1972 May # Liberia Time + -0:44:30 - MMT 1972 Jan 7 # approximately MMT 0:00 - GMT ############################################################################### @@ -596,7 +597,7 @@ Rule Mauritius 2008 only - Oct lastSun 2:00 1:00 S Rule Mauritius 2009 only - Mar lastSun 2:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Indian/Mauritius 3:50:00 - LMT 1907 # Port Louis - 4:00 Mauritius MU%sT # Mauritius Time + 4:00 Mauritius +04/+05 # Agalega Is, Rodriguez # no information; probably like Indian/Mauritius @@ -915,14 +916,14 @@ Zone Africa/Casablanca -0:30:20 - LMT 1913 Oct 26 # since most of it was then controlled by Morocco. Zone Africa/El_Aaiun -0:52:48 - LMT 1934 Jan # El Aaiún - -1:00 - WAT 1976 Apr 14 + -1:00 - -01 1976 Apr 14 0:00 Morocco WE%sT # Mozambique # # Shanks gives 1903-03-01 for the transition to CAT. # Perhaps the 1911-05-26 Portuguese decree -# http://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf +# https://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf # merely made it official? # # Zone NAME GMTOFF RULES FORMAT [UNTIL] @@ -949,16 +950,19 @@ Link Africa/Maputo Africa/Lusaka # Zambia # the country are close to 40 minutes earlier in sunrise than the rest # of the country. # -# From Paul Eggert (2007-03-31): -# Apparently the Caprivi Strip informally observes Botswana time, but -# we have no details. In the meantime people there can use Africa/Gaborone. +# From Paul Eggert (2017-02-22): +# Although the Zambezi Region (formerly known as Caprivi) informally +# observes Botswana time, we have no details about historical practice. +# In the meantime people there can use Africa/Gaborone. +# See: Immanuel S. The Namibian. 2017-02-23. +# http://www.namibian.com.na/51480/read/Time-change-divides-lawmakers # RULE NAME FROM TO TYPE IN ON AT SAVE LETTER/S Rule Namibia 1994 max - Sep Sun>=1 2:00 1:00 S Rule Namibia 1995 max - Apr Sun>=1 2:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Africa/Windhoek 1:08:24 - LMT 1892 Feb 8 - 1:30 - SWAT 1903 Mar # SW Africa Time + 1:30 - +0130 1903 Mar 2:00 - SAST 1942 Sep 20 2:00 2:00 1:00 SAST 1943 Mar 21 2:00 2:00 - SAST 1990 Mar 21 # independence @@ -985,7 +989,7 @@ Link Africa/Lagos Africa/Porto-Novo # Benin # Réunion # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Indian/Reunion 3:41:52 - LMT 1911 Jun # Saint-Denis - 4:00 - RET # Réunion Time + 4:00 - +04 # # Crozet Islands also observes Réunion time; see the 'antarctica' file. # @@ -1020,7 +1024,7 @@ Zone Indian/Reunion 3:41:52 - LMT 1911 Jun # Saint-Denis # Seychelles # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Indian/Mahe 3:41:48 - LMT 1906 Jun # Victoria - 4:00 - SCT # Seychelles Time + 4:00 - +04 # From Paul Eggert (2001-05-30): # Aldabra, Farquhar, and Desroches, originally dependencies of the # Seychelles, were transferred to the British Indian Ocean Territory diff --git a/src/timezone/data/antarctica b/src/timezone/data/antarctica index 6da1aef87f..3332d66842 100644 --- a/src/timezone/data/antarctica +++ b/src/timezone/data/antarctica @@ -110,7 +110,8 @@ Zone Antarctica/Mawson 0 - -00 1954 Feb 13 # O'Higgins, Antarctic Peninsula, -6319-05704, since 1948-02 # Prat, -6230-05941 # Villa Las Estrellas (a town), around the Frei base, since 1984-04-09 -# These locations have always used Santiago time; use TZ='America/Santiago'. +# These locations employ Region of Magallanes time; use +# TZ='America/Punta_Arenas'. # China - year-round bases # Great Wall, King George Island, -6213-05858, since 1985-02-20 diff --git a/src/timezone/data/asia b/src/timezone/data/asia index c6f63b5205..35774c6d7e 100644 --- a/src/timezone/data/asia +++ b/src/timezone/data/asia @@ -6,15 +6,15 @@ # tz@iana.org for general use in the future). For more, please see # the file CONTRIBUTING in the tz distribution. -# From Paul Eggert (2015-08-08): +# From Paul Eggert (2017-01-13): # # Unless otherwise specified, the source for data through 1990 is: # Thomas G. Shanks and Rique Pottenger, The International Atlas (6th edition), # San Diego: ACS Publications, Inc. (2003). # Unfortunately this book contains many errors and cites no sources. # -# Gwillim Law writes that a good source -# for recent time zone data is the International Air Transport +# Many years ago Gwillim Law wrote that a good source +# for time zone data was the International Air Transport # Association's Standard Schedules Information Manual (IATA SSIM), # published semiannually. Law sent in several helpful summaries # of the IATA's data after 1990. Except where otherwise noted, @@ -35,29 +35,24 @@ # A reliable and entertaining source about time zones is # Derek Howse, Greenwich time and longitude, Philip Wilson Publishers (1997). # -# I invented the abbreviations marked '*' in the following table; -# the rest are from earlier versions of this file, or from other sources. -# Corrections are welcome! +# The following alphabetic abbreviations appear in these tables: # std dst # LMT Local Mean Time # 2:00 EET EEST Eastern European Time # 2:00 IST IDT Israel -# 3:00 AST ADT Arabia* -# 3:30 IRST IRDT Iran* -# 4:00 GST Gulf* # 5:30 IST India -# 7:00 ICT Indochina, most times and locations* # 7:00 WIB west Indonesia (Waktu Indonesia Barat) # 8:00 WITA central Indonesia (Waktu Indonesia Tengah) # 8:00 CST China -# 8:00 IDT Indochina, 1943-45, 1947-55, 1960-75 (some locations)* -# 8:00 JWST Western Standard Time (Japan, 1896/1937)* -# 8:30 KST KDT Korea when at +0830* -# 9:00 JCST Central Standard Time (Japan, 1896/1937) +# 8:30 KST KDT Korea when at +0830 # 9:00 WIT east Indonesia (Waktu Indonesia Timur) # 9:00 JST JDT Japan # 9:00 KST KDT Korea when at +09 # 9:30 ACST Australian Central Standard Time +# Otherwise, these tables typically use numeric abbreviations like +03 +# and +0330 for integer hour and minute UTC offsets. Although earlier +# editions invented alphabetic time zone abbreviations for every +# offset, this did not reflect common practice. # # See the 'europe' file for Russia and Turkey in Asia. @@ -65,7 +60,7 @@ # Incorporates data for Singapore from Robert Elz' asia 1.1, as well as # additional information from Tom Yap, Sun Microsystems Intercontinental # Technical Support (including a page from the Official Airline Guide - -# Worldwide Edition). The names for time zones are guesses. +# Worldwide Edition). ############################################################################### @@ -86,8 +81,8 @@ Rule RussiaAsia 1996 2011 - Oct lastSun 2:00s 0 - # Afghanistan # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Kabul 4:36:48 - LMT 1890 - 4:00 - AFT 1945 - 4:30 - AFT + 4:00 - +04 1945 + 4:30 - +0430 # Armenia # From Paul Eggert (2006-03-22): @@ -230,18 +225,17 @@ Rule Dhaka 2009 only - Dec 31 24:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Dhaka 6:01:40 - LMT 1890 5:53:20 - HMT 1941 Oct # Howrah Mean Time? - 6:30 - BURT 1942 May 15 # Burma Time - 5:30 - IST 1942 Sep - 6:30 - BURT 1951 Sep 30 - 6:00 - DACT 1971 Mar 26 # Dacca Time - 6:00 - BDT 2009 - 6:00 Dhaka BD%sT + 6:30 - +0630 1942 May 15 + 5:30 - +0530 1942 Sep + 6:30 - +0630 1951 Sep 30 + 6:00 - +06 2009 + 6:00 Dhaka +06/+07 # Bhutan # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Thimphu 5:58:36 - LMT 1947 Aug 15 # or Thimbu - 5:30 - IST 1987 Oct - 6:00 - BTT # Bhutan Time + 5:30 - +0530 1987 Oct + 6:00 - +06 # British Indian Ocean Territory # Whitman and the 1995 CIA time zone map say 5:00, but the @@ -251,14 +245,14 @@ Zone Asia/Thimphu 5:58:36 - LMT 1947 Aug 15 # or Thimbu # then contained the Chagos Archipelago). # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Indian/Chagos 4:49:40 - LMT 1907 - 5:00 - IOT 1996 # BIOT Time - 6:00 - IOT + 5:00 - +05 1996 + 6:00 - +06 # Brunei # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Brunei 7:39:40 - LMT 1926 Mar # Bandar Seri Begawan - 7:30 - BNT 1933 - 8:00 - BNT + 7:30 - +0730 1933 + 8:00 - +08 # Burma / Myanmar @@ -267,9 +261,9 @@ Zone Asia/Brunei 7:39:40 - LMT 1926 Mar # Bandar Seri Begawan # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Yangon 6:24:40 - LMT 1880 # or Rangoon 6:24:40 - RMT 1920 # Rangoon Mean Time? - 6:30 - BURT 1942 May # Burma Time - 9:00 - JST 1945 May 3 - 6:30 - MMT # Myanmar Time + 6:30 - +0630 1942 May + 9:00 - +09 1945 May 3 + 6:30 - +0630 # Cambodia # See Asia/Bangkok. @@ -332,7 +326,7 @@ Rule PRC 1987 1991 - Apr Sun>=10 0:00 1:00 D # (could be true), for the moment I am assuming that those two # counties are mistakes in the astro.com data. -# From Paul Eggert (2014-06-30): +# From Paul Eggert (2017-01-05): # Alois Treindl kindly sent me translations of the following two sources: # # (1) @@ -390,28 +384,26 @@ Rule PRC 1987 1991 - Apr Sun>=10 0:00 1:00 D # mainly observed in coastal areas), the five zones were: # # Changbai Time ("Long-white Time", Long-white = Heilongjiang area) UT +08:30 -# Asia/Harbin (currently a link to Asia/Shanghai) +# Now part of Asia/Shanghai; its pre-1970 times are not recorded here. # Heilongjiang (except Mohe county), Jilin # # Zhongyuan Time ("Central plain Time") UT +08 -# Asia/Shanghai +# Now part of Asia/Shanghai. # most of China -# This currently represents most other zones as well, -# as apparently these regions have been the same since 1970. # Milne gives 8:05:43.2 for Xujiahui Observatory time; round to nearest. # Guo says Shanghai switched to UT +08 "from the end of the 19th century". # -# Long-shu Time (probably due to Long and Shu being two names of the area) UT +07 -# Asia/Chongqing (currently a link to Asia/Shanghai) +# Long-shu Time (probably as Long and Shu were two names of the area) UT +07 +# Now part of Asia/Shanghai; its pre-1970 times are not recorded here. # Guangxi, Guizhou, Hainan, Ningxia, Sichuan, Shaanxi, and Yunnan; -# most of Gansu; west Inner Mongolia; west Qinghai; and the Guangdong +# most of Gansu; west Inner Mongolia; east Qinghai; and the Guangdong # counties Deqing, Enping, Kaiping, Luoding, Taishan, Xinxing, # Yangchun, Yangjiang, Yu'nan, and Yunfu. # # Xin-zang Time ("Xinjiang-Tibet Time") UT +06 -# Asia/Urumqi -# This currently represents Kunlun Time as well, -# as apparently the two regions have been the same since 1970. +# This region is now part of either Asia/Urumqi or Asia/Shanghai with +# current boundaries uncertain; times before 1970 for areas that +# disagree with Ãœrümqi or Shanghai are not recorded here. # The Gansu counties Aksay, Anxi, Dunhuang, Subei; west Qinghai; # the Guangdong counties Xuwen, Haikang, Suixi, Lianjiang, # Zhanjiang, Wuchuan, Huazhou, Gaozhou, Maoming, Dianbai, and Xinyi; @@ -422,7 +414,7 @@ Rule PRC 1987 1991 - Apr Sun>=10 0:00 1:00 D # Fukang, Kuitun, Kumukuli, Miquan, Qitai, and Turfan. # # Kunlun Time UT +05:30 -# Asia/Kashgar (currently a link to Asia/Urumqi) +# This region is now in the same status as Xin-zang Time (see above). # West Tibet, including Pulan, Aheqi, Shufu, Shule; # West Xinjiang, including Aksu, Atushi, Yining, Hetian, Cele, Luopu, Nileke, # Zhaosu, Tekesi, Gongliu, Chabuchaer, Huocheng, Bole, Pishan, Suiding, @@ -523,7 +515,7 @@ Zone Asia/Shanghai 8:05:43 - LMT 1901 # Xinjiang time, used by many in western China; represented by Ãœrümqi / Ãœrümchi # / Wulumuqi. (Please use Asia/Shanghai if you prefer Beijing time.) Zone Asia/Urumqi 5:50:20 - LMT 1928 - 6:00 - XJT + 6:00 - +06 # Hong Kong (Xianggang) @@ -742,30 +734,29 @@ Rule Taiwan 1979 only - Oct 1 0:00 0 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] # Taipei or Taibei or T'ai-pei Zone Asia/Taipei 8:06:00 - LMT 1896 Jan 1 - 8:00 - JWST 1937 Oct 1 + 8:00 - CST 1937 Oct 1 9:00 - JST 1945 Sep 21 1:00 8:00 Taiwan C%sT # Macau (Macao, Aomen) # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S -Rule Macau 1961 1962 - Mar Sun>=16 3:30 1:00 S -Rule Macau 1961 1964 - Nov Sun>=1 3:30 0 - -Rule Macau 1963 only - Mar Sun>=16 0:00 1:00 S -Rule Macau 1964 only - Mar Sun>=16 3:30 1:00 S -Rule Macau 1965 only - Mar Sun>=16 0:00 1:00 S -Rule Macau 1965 only - Oct 31 0:00 0 - -Rule Macau 1966 1971 - Apr Sun>=16 3:30 1:00 S -Rule Macau 1966 1971 - Oct Sun>=16 3:30 0 - -Rule Macau 1972 1974 - Apr Sun>=15 0:00 1:00 S -Rule Macau 1972 1973 - Oct Sun>=15 0:00 0 - -Rule Macau 1974 1977 - Oct Sun>=15 3:30 0 - -Rule Macau 1975 1977 - Apr Sun>=15 3:30 1:00 S -Rule Macau 1978 1980 - Apr Sun>=15 0:00 1:00 S -Rule Macau 1978 1980 - Oct Sun>=15 0:00 0 - +Rule Macau 1961 1962 - Mar Sun>=16 3:30 1:00 D +Rule Macau 1961 1964 - Nov Sun>=1 3:30 0 S +Rule Macau 1963 only - Mar Sun>=16 0:00 1:00 D +Rule Macau 1964 only - Mar Sun>=16 3:30 1:00 D +Rule Macau 1965 only - Mar Sun>=16 0:00 1:00 D +Rule Macau 1965 only - Oct 31 0:00 0 S +Rule Macau 1966 1971 - Apr Sun>=16 3:30 1:00 D +Rule Macau 1966 1971 - Oct Sun>=16 3:30 0 S +Rule Macau 1972 1974 - Apr Sun>=15 0:00 1:00 D +Rule Macau 1972 1973 - Oct Sun>=15 0:00 0 S +Rule Macau 1974 1977 - Oct Sun>=15 3:30 0 S +Rule Macau 1975 1977 - Apr Sun>=15 3:30 1:00 D +Rule Macau 1978 1980 - Apr Sun>=15 0:00 1:00 D +Rule Macau 1978 1980 - Oct Sun>=15 0:00 0 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Macau 7:34:20 - LMT 1912 Jan 1 - 8:00 Macau MO%sT 1999 Dec 20 # return to China - 8:00 PRC C%sT + 8:00 Macau C%sT ############################################################################### @@ -881,11 +872,10 @@ Zone Asia/Tbilisi 2:59:11 - LMT 1880 # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Dili 8:22:20 - LMT 1912 Jan 1 - 8:00 - TLT 1942 Feb 21 23:00 # E Timor Time - 9:00 - JST 1945 Sep 23 - 9:00 - TLT 1976 May 3 - 8:00 - WITA 2000 Sep 17 0:00 - 9:00 - TLT + 8:00 - +08 1942 Feb 21 23:00 + 9:00 - +09 1976 May 3 + 8:00 - +08 2000 Sep 17 0:00 + 9:00 - +09 # India @@ -900,9 +890,9 @@ Zone Asia/Dili 8:22:20 - LMT 1912 Jan 1 # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Kolkata 5:53:28 - LMT 1880 # Kolkata 5:53:20 - HMT 1941 Oct # Howrah Mean Time? - 6:30 - BURT 1942 May 15 # Burma Time + 6:30 - +0630 1942 May 15 5:30 - IST 1942 Sep - 5:30 1:00 IST 1945 Oct 15 + 5:30 1:00 +0630 1945 Oct 15 5:30 - IST # The following are like Asia/Kolkata: # Andaman Is @@ -953,33 +943,33 @@ Zone Asia/Jakarta 7:07:12 - LMT 1867 Aug 10 # Shanks & Pottenger say the next transition was at 1924 Jan 1 0:13, # but this must be a typo. 7:07:12 - BMT 1923 Dec 31 23:47:12 # Batavia - 7:20 - JAVT 1932 Nov # Java Time - 7:30 - WIB 1942 Mar 23 - 9:00 - JST 1945 Sep 23 - 7:30 - WIB 1948 May - 8:00 - WIB 1950 May - 7:30 - WIB 1964 + 7:20 - +0720 1932 Nov + 7:30 - +0730 1942 Mar 23 + 9:00 - +09 1945 Sep 23 + 7:30 - +0730 1948 May + 8:00 - +08 1950 May + 7:30 - +0730 1964 7:00 - WIB # west and central Borneo Zone Asia/Pontianak 7:17:20 - LMT 1908 May 7:17:20 - PMT 1932 Nov # Pontianak MT - 7:30 - WIB 1942 Jan 29 - 9:00 - JST 1945 Sep 23 - 7:30 - WIB 1948 May - 8:00 - WIB 1950 May - 7:30 - WIB 1964 + 7:30 - +0730 1942 Jan 29 + 9:00 - +09 1945 Sep 23 + 7:30 - +0730 1948 May + 8:00 - +08 1950 May + 7:30 - +0730 1964 8:00 - WITA 1988 Jan 1 7:00 - WIB # Sulawesi, Lesser Sundas, east and south Borneo Zone Asia/Makassar 7:57:36 - LMT 1920 7:57:36 - MMT 1932 Nov # Macassar MT - 8:00 - WITA 1942 Feb 9 - 9:00 - JST 1945 Sep 23 + 8:00 - +08 1942 Feb 9 + 9:00 - +09 1945 Sep 23 8:00 - WITA # Maluku Islands, West Papua, Papua Zone Asia/Jayapura 9:22:48 - LMT 1932 Nov - 9:00 - WIT 1944 Sep 1 - 9:30 - ACST 1964 + 9:00 - +09 1944 Sep 1 + 9:30 - +0930 1964 9:00 - WIT # Iran @@ -1011,8 +1001,6 @@ Zone Asia/Jayapura 9:22:48 - LMT 1932 Nov # for at least the last 5 years. Before that, for a few years, the # date used was the first Thursday night of Farvardin and the last # Thursday night of Shahrivar, but I can't give exact dates.... -# I have also changed the abbreviations to what is considered correct -# here in Iran, IRST for regular time and IRDT for daylight saving time. # # From Roozbeh Pournader (2005-04-05): # The text of the Iranian law, in effect since 1925, clearly mentions @@ -1119,9 +1107,9 @@ Rule Iran 2036 max - Sep 21 0:00 0 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Tehran 3:25:44 - LMT 1916 3:25:44 - TMT 1946 # Tehran Mean Time - 3:30 - IRST 1977 Nov - 4:00 Iran IR%sT 1979 - 3:30 Iran IR%sT + 3:30 - +0330 1977 Nov + 4:00 Iran +04/+05 1979 + 3:30 Iran +0330/+0430 # Iraq @@ -1164,8 +1152,8 @@ Rule Iraq 1991 2007 - Oct 1 3:00s 0 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Baghdad 2:57:40 - LMT 1890 2:57:36 - BMT 1918 # Baghdad Mean Time? - 3:00 - AST 1982 May - 3:00 Iraq A%sT + 3:00 - +03 1982 May + 3:00 Iraq +03/+04 ############################################################################### @@ -1464,8 +1452,6 @@ Rule Japan 1950 1951 - May Sun>=1 2:00 1:00 D # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Tokyo 9:18:59 - LMT 1887 Dec 31 15:00u - 9:00 - JST 1896 Jan 1 - 9:00 - JCST 1937 Oct 1 9:00 Japan J%sT # Since 1938, all Japanese possessions have been like Asia/Tokyo. @@ -1741,7 +1727,23 @@ Zone Asia/Amman 2:23:44 - LMT 1931 # Kazakh 1992-01-13 act appears to provide the same rules and 1992-03-27 # act was to be enacted on the last Sunday of March 1992. -# From Paul Eggert (2016-11-07): +# From Stepan Golosunov (2016-11-08): +# Turgai reorganization should affect only southern part of Qostanay +# oblast. Which should probably be separated into Asia/Arkalyk zone. +# (There were also 1970, 1988 and 1990 Turgai oblast reorganizations +# according to wikipedia.) +# +# [For Qostanay] http://www.ng.kz/gazeta/195/hranit/ +# suggests that clocks were to be moved 40 minutes backwards on +# 1920-01-01 to the fourth time belt. But I do not understand +# how that could happen.... +# +# [For Atyrau and Oral] 1919 decree +# (http://www.worldtimezone.com/dst_news/dst_news_russia-1919-02-08.html +# and in Byalokoz) lists Ural river (plus 10 versts on its left bank) in +# the third time belt (before 1930 this means +03). + +# From Paul Eggert (2016-12-06): # The tables below reflect Golosunov's remarks, with exceptions as noted. # Zone NAME GMTOFF RULES FORMAT [UNTIL] @@ -1771,7 +1773,7 @@ Zone Asia/Qyzylorda 4:21:52 - LMT 1924 May 2 6:00 - +06 # The following zone is like Asia/Qyzylorda except for being one # hour earlier from 1991-09-29 to 1992-03-29. The 1991/2 rules for -# Qostenay are unclear partly because of the 1997 Turgai +# Qostanay are unclear partly because of the 1997 Turgai # reorganization, so this zone is commented out for now. #Zone Asia/Qostanay 4:14:20 - LMT 1924 May 2 # 4:00 - +04 1930 Jun 21 @@ -1808,7 +1810,7 @@ Zone Asia/Aqtau 3:21:04 - LMT 1924 May 2 # AtyraÅ« (KZ-ATY) is like MangghystaÅ« except it switched from # +04/+05 to +05/+06 in spring 1999, not fall 1994. Zone Asia/Atyrau 3:27:44 - LMT 1924 May 2 - 4:00 - +04 1930 Jun 21 + 3:00 - +03 1930 Jun 21 5:00 - +05 1981 Oct 1 6:00 - +06 1982 Apr 1 5:00 RussiaAsia +05/+06 1991 Mar 31 2:00s @@ -1820,7 +1822,7 @@ Zone Asia/Atyrau 3:27:44 - LMT 1924 May 2 # From Paul Eggert (2016-03-18): # The 1989 transition is from USSR act No. 227 (1989-03-14). Zone Asia/Oral 3:25:24 - LMT 1924 May 2 # or Ural'sk - 4:00 - +04 1930 Jun 21 + 3:00 - +03 1930 Jun 21 5:00 - +05 1981 Apr 1 5:00 1:00 +06 1981 Oct 1 6:00 - +06 1982 Apr 1 @@ -1926,14 +1928,12 @@ Rule ROK 1987 1988 - Oct Sun>=8 3:00 0 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Seoul 8:27:52 - LMT 1908 Apr 1 8:30 - KST 1912 Jan 1 - 9:00 - JCST 1937 Oct 1 9:00 - JST 1945 Sep 8 9:00 - KST 1954 Mar 21 8:30 ROK K%sT 1961 Aug 10 9:00 ROK K%sT Zone Asia/Pyongyang 8:23:00 - LMT 1908 Apr 1 8:30 - KST 1912 Jan 1 - 9:00 - JCST 1937 Oct 1 9:00 - JST 1945 Aug 24 9:00 - KST 2015 Aug 15 00:00 8:30 - KST @@ -1988,30 +1988,29 @@ Rule NBorneo 1935 1941 - Dec 14 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Kuala_Lumpur 6:46:46 - LMT 1901 Jan 1 6:55:25 - SMT 1905 Jun 1 # Singapore M.T. - 7:00 - MALT 1933 Jan 1 # Malaya Time - 7:00 0:20 MALST 1936 Jan 1 - 7:20 - MALT 1941 Sep 1 - 7:30 - MALT 1942 Feb 16 - 9:00 - JST 1945 Sep 12 - 7:30 - MALT 1982 Jan 1 - 8:00 - MYT # Malaysia Time + 7:00 - +07 1933 Jan 1 + 7:00 0:20 +0720 1936 Jan 1 + 7:20 - +0720 1941 Sep 1 + 7:30 - +0730 1942 Feb 16 + 9:00 - +09 1945 Sep 12 + 7:30 - +0730 1982 Jan 1 + 8:00 - +08 # Sabah & Sarawak # From Paul Eggert (2014-08-12): # The data entries here are mostly from Shanks & Pottenger, but the 1942, 1945 # and 1982 transition dates are from Mok Ly Yng. # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Kuching 7:21:20 - LMT 1926 Mar - 7:30 - BORT 1933 # Borneo Time - 8:00 NBorneo BOR%sT 1942 Feb 16 - 9:00 - JST 1945 Sep 12 - 8:00 - BORT 1982 Jan 1 - 8:00 - MYT + 7:30 - +0730 1933 + 8:00 NBorneo +08/+0820 1942 Feb 16 + 9:00 - +09 1945 Sep 12 + 8:00 - +08 # Maldives # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Indian/Maldives 4:54:00 - LMT 1880 # Male 4:54:00 - MMT 1960 # Male Mean Time - 5:00 - MVT # Maldives Time + 5:00 - +05 # Mongolia @@ -2138,37 +2137,41 @@ Rule Mongol 1983 only - Oct 1 0:00 0 - # correction of 02:00 (in the previous edition) not being done correctly # in the latest edition; so ignore it for now. +# From Ganbold Tsagaankhuu (2017-02-09): +# Mongolian Government meeting has concluded today to cancel daylight +# saving time adoption in Mongolia. Source: http://zasag.mn/news/view/16192 + Rule Mongol 1985 1998 - Mar lastSun 0:00 1:00 S Rule Mongol 1984 1998 - Sep lastSun 0:00 0 - # IATA SSIM (1999-09) says Mongolia no longer observes DST. Rule Mongol 2001 only - Apr lastSat 2:00 1:00 S Rule Mongol 2001 2006 - Sep lastSat 2:00 0 - Rule Mongol 2002 2006 - Mar lastSat 2:00 1:00 S -Rule Mongol 2015 max - Mar lastSat 2:00 1:00 S -Rule Mongol 2015 max - Sep lastSat 0:00 0 - +Rule Mongol 2015 2016 - Mar lastSat 2:00 1:00 S +Rule Mongol 2015 2016 - Sep lastSat 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] # Hovd, a.k.a. Chovd, Dund-Us, Dzhargalant, Khovd, Jirgalanta Zone Asia/Hovd 6:06:36 - LMT 1905 Aug - 6:00 - HOVT 1978 # Hovd Time - 7:00 Mongol HOV%sT + 6:00 - +06 1978 + 7:00 Mongol +07/+08 # Ulaanbaatar, a.k.a. Ulan Bataar, Ulan Bator, Urga Zone Asia/Ulaanbaatar 7:07:32 - LMT 1905 Aug - 7:00 - ULAT 1978 # Ulaanbaatar Time - 8:00 Mongol ULA%sT + 7:00 - +07 1978 + 8:00 Mongol +08/+09 # Choibalsan, a.k.a. Bajan Tümen, Bajan Tumen, Chojbalsan, # Choybalsan, Sanbejse, Tchoibalsan Zone Asia/Choibalsan 7:38:00 - LMT 1905 Aug - 7:00 - ULAT 1978 - 8:00 - ULAT 1983 Apr - 9:00 Mongol CHO%sT 2008 Mar 31 # Choibalsan Time - 8:00 Mongol CHO%sT + 7:00 - +07 1978 + 8:00 - +08 1983 Apr + 9:00 Mongol +09/+10 2008 Mar 31 + 8:00 Mongol +08/+09 # Nepal # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Kathmandu 5:41:16 - LMT 1920 - 5:30 - IST 1986 - 5:45 - NPT # Nepal Time + 5:30 - +0530 1986 + 5:45 - +0545 # Oman # See Asia/Dubai. @@ -2317,10 +2320,10 @@ Rule Pakistan 2009 only - Apr 15 0:00 1:00 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Karachi 4:28:12 - LMT 1907 - 5:30 - IST 1942 Sep - 5:30 1:00 IST 1945 Oct 15 - 5:30 - IST 1951 Sep 30 - 5:00 - KART 1971 Mar 26 # Karachi Time + 5:30 - +0530 1942 Sep + 5:30 1:00 +0630 1945 Oct 15 + 5:30 - +0530 1951 Sep 30 + 5:00 - +05 1971 Mar 26 5:00 Pakistan PK%sT # Pakistan Time # Palestine @@ -2685,15 +2688,15 @@ Rule Phil 1978 only - Sep 21 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Manila -15:56:00 - LMT 1844 Dec 31 8:04:00 - LMT 1899 May 11 - 8:00 Phil PH%sT 1942 May - 9:00 - JST 1944 Nov - 8:00 Phil PH%sT + 8:00 Phil +08/+09 1942 May + 9:00 - +09 1944 Nov + 8:00 Phil +08/+09 # Qatar # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Qatar 3:26:08 - LMT 1920 # Al Dawhah / Doha - 4:00 - GST 1972 Jun - 3:00 - AST + 4:00 - +04 1972 Jun + 3:00 - +03 Link Asia/Qatar Asia/Bahrain # Saudi Arabia @@ -2720,7 +2723,7 @@ Link Asia/Qatar Asia/Bahrain # # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Riyadh 3:06:52 - LMT 1947 Mar 14 - 3:00 - AST + 3:00 - +03 Link Asia/Riyadh Asia/Aden # Yemen Link Asia/Riyadh Asia/Kuwait @@ -2730,14 +2733,13 @@ Link Asia/Riyadh Asia/Kuwait # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Singapore 6:55:25 - LMT 1901 Jan 1 6:55:25 - SMT 1905 Jun 1 # Singapore M.T. - 7:00 - MALT 1933 Jan 1 # Malaya Time - 7:00 0:20 MALST 1936 Jan 1 - 7:20 - MALT 1941 Sep 1 - 7:30 - MALT 1942 Feb 16 - 9:00 - JST 1945 Sep 12 - 7:30 - MALT 1965 Aug 9 # independence - 7:30 - SGT 1982 Jan 1 # Singapore Time - 8:00 - SGT + 7:00 - +07 1933 Jan 1 + 7:00 0:20 +0720 1936 Jan 1 + 7:20 - +0720 1941 Sep 1 + 7:30 - +0730 1942 Feb 16 + 9:00 - +09 1945 Sep 12 + 7:30 - +0730 1982 Jan 1 + 8:00 - +08 # Spratly Is # no information @@ -2796,8 +2798,8 @@ Zone Asia/Singapore 6:55:25 - LMT 1901 Jan 1 Zone Asia/Colombo 5:19:24 - LMT 1880 5:19:32 - MMT 1906 # Moratuwa Mean Time 5:30 - +0530 1942 Jan 5 - 5:30 0:30 +0530/+06 1942 Sep - 5:30 1:00 +0530/+0630 1945 Oct 16 2:00 + 5:30 0:30 +06 1942 Sep + 5:30 1:00 +0630 1945 Oct 16 2:00 5:30 - +0530 1996 May 25 0:00 6:30 - +0630 1996 Oct 26 0:30 6:00 - +06 2006 Apr 15 0:30 @@ -2979,7 +2981,7 @@ Zone Asia/Dushanbe 4:35:12 - LMT 1924 May 2 # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Bangkok 6:42:04 - LMT 1880 6:42:04 - BMT 1920 Apr # Bangkok Mean Time - 7:00 - ICT + 7:00 - +07 Link Asia/Bangkok Asia/Phnom_Penh # Cambodia Link Asia/Bangkok Asia/Vientiane # Laos @@ -2995,7 +2997,7 @@ Zone Asia/Ashgabat 3:53:32 - LMT 1924 May 2 # or Ashkhabad # United Arab Emirates # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Dubai 3:41:12 - LMT 1920 - 4:00 - GST + 4:00 - +04 Link Asia/Dubai Asia/Muscat # Oman # Uzbekistan @@ -3068,15 +3070,15 @@ Zone Asia/Tashkent 4:37:11 - LMT 1924 May 2 # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Ho_Chi_Minh 7:06:40 - LMT 1906 Jul 1 - 7:06:30 - PLMT 1911 May 1 - 7:00 - ICT 1942 Dec 31 23:00 - 8:00 - IDT 1945 Mar 14 23:00 - 9:00 - JST 1945 Sep 2 - 7:00 - ICT 1947 Apr 1 - 8:00 - IDT 1955 Jul 1 - 7:00 - ICT 1959 Dec 31 23:00 - 8:00 - IDT 1975 Jun 13 - 7:00 - ICT + 7:06:30 - PLMT 1911 May 1 # Phù Liá»…n MT + 7:00 - +07 1942 Dec 31 23:00 + 8:00 - +08 1945 Mar 14 23:00 + 9:00 - +09 1945 Sep 2 + 7:00 - +07 1947 Apr 1 + 8:00 - +08 1955 Jul 1 + 7:00 - +07 1959 Dec 31 23:00 + 8:00 - +08 1975 Jun 13 + 7:00 - +07 # Yemen # See Asia/Riyadh. diff --git a/src/timezone/data/australasia b/src/timezone/data/australasia index 0bca53e2ee..d389ae134a 100644 --- a/src/timezone/data/australasia +++ b/src/timezone/data/australasia @@ -44,8 +44,8 @@ Zone Australia/Perth 7:43:24 - LMT 1895 Dec 8:00 Aus AW%sT 1943 Jul 8:00 AW AW%sT Zone Australia/Eucla 8:35:28 - LMT 1895 Dec - 8:45 Aus ACW%sT 1943 Jul - 8:45 AW ACW%sT + 8:45 Aus +0845/+0945 1943 Jul + 8:45 AW +0845/+0945 # Queensland # @@ -212,7 +212,8 @@ Rule LH 2008 max - Apr Sun>=1 2:00 0 S Rule LH 2008 max - Oct Sun>=1 2:00 0:30 D Zone Australia/Lord_Howe 10:36:20 - LMT 1895 Feb 10:00 - AEST 1981 Mar - 10:30 LH LH%sT + 10:30 LH +1030/+1130 1985 Jul + 10:30 LH +1030/+11 # Australian miscellany # @@ -250,19 +251,19 @@ Zone Antarctica/Macquarie 0 - -00 1899 Nov 0 - -00 1948 Mar 25 10:00 Aus AE%sT 1967 10:00 AT AE%sT 2010 Apr 4 3:00 - 11:00 - MIST # Macquarie I Standard Time + 11:00 - +11 # Christmas # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Indian/Christmas 7:02:52 - LMT 1895 Feb - 7:00 - CXT # Christmas Island Time + 7:00 - +07 # Cocos (Keeling) Is # These islands were ruled by the Ross family from about 1830 to 1978. # We don't know when standard time was introduced; for now, we guess 1900. # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Indian/Cocos 6:27:40 - LMT 1900 - 6:30 - CCT # Cocos Islands Time + 6:30 - +0630 # Fiji @@ -375,16 +376,16 @@ Rule Fiji 2014 max - Nov Sun>=1 2:00 1:00 S Rule Fiji 2015 max - Jan Sun>=15 3:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Fiji 11:55:44 - LMT 1915 Oct 26 # Suva - 12:00 Fiji FJ%sT # Fiji Time + 12:00 Fiji +12/+13 # French Polynesia # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Gambier -8:59:48 - LMT 1912 Oct # Rikitea - -9:00 - GAMT # Gambier Time + -9:00 - -09 Zone Pacific/Marquesas -9:18:00 - LMT 1912 Oct - -9:30 - MART # Marquesas Time + -9:30 - -0930 Zone Pacific/Tahiti -9:58:16 - LMT 1912 Oct # Papeete - -10:00 - TAHT # Tahiti Time + -10:00 - -10 # Clipperton (near North America) is administered from French Polynesia; # it is uninhabited. @@ -399,15 +400,15 @@ Link Pacific/Guam Pacific/Saipan # N Mariana Is # Kiribati # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Tarawa 11:32:04 - LMT 1901 # Bairiki - 12:00 - GILT # Gilbert Is Time + 12:00 - +12 Zone Pacific/Enderbury -11:24:20 - LMT 1901 - -12:00 - PHOT 1979 Oct # Phoenix Is Time - -11:00 - PHOT 1995 - 13:00 - PHOT + -12:00 - -12 1979 Oct + -11:00 - -11 1995 + 13:00 - +13 Zone Pacific/Kiritimati -10:29:20 - LMT 1901 - -10:40 - LINT 1979 Oct # Line Is Time - -10:00 - LINT 1995 - 14:00 - LINT + -10:40 - -1040 1979 Oct + -10:00 - -10 1995 + 14:00 - +14 # N Mariana Is # See Pacific/Guam. @@ -415,31 +416,31 @@ Zone Pacific/Kiritimati -10:29:20 - LMT 1901 # Marshall Is # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Majuro 11:24:48 - LMT 1901 - 11:00 - MHT 1969 Oct # Marshall Islands Time - 12:00 - MHT + 11:00 - +11 1969 Oct + 12:00 - +12 Zone Pacific/Kwajalein 11:09:20 - LMT 1901 - 11:00 - MHT 1969 Oct - -12:00 - KWAT 1993 Aug 20 # Kwajalein Time - 12:00 - MHT + 11:00 - +11 1969 Oct + -12:00 - -12 1993 Aug 20 + 12:00 - +12 # Micronesia # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Chuuk 10:07:08 - LMT 1901 - 10:00 - CHUT # Chuuk Time + 10:00 - +10 Zone Pacific/Pohnpei 10:32:52 - LMT 1901 # Kolonia - 11:00 - PONT # Pohnpei Time + 11:00 - +11 Zone Pacific/Kosrae 10:51:56 - LMT 1901 - 11:00 - KOST 1969 Oct # Kosrae Time - 12:00 - KOST 1999 - 11:00 - KOST + 11:00 - +11 1969 Oct + 12:00 - +12 1999 + 11:00 - +11 # Nauru # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Nauru 11:07:40 - LMT 1921 Jan 15 # Uaobe - 11:30 - NRT 1942 Mar 15 # Nauru Time - 9:00 - JST 1944 Aug 15 - 11:30 - NRT 1979 May - 12:00 - NRT + 11:30 - +1130 1942 Mar 15 + 9:00 - +09 1944 Aug 15 + 11:30 - +1130 1979 May + 12:00 - +12 # New Caledonia # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S @@ -450,7 +451,7 @@ Rule NC 1996 only - Dec 1 2:00s 1:00 S Rule NC 1997 only - Mar 2 2:00s 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Noumea 11:05:48 - LMT 1912 Jan 13 # Nouméa - 11:00 NC NC%sT + 11:00 NC +11/+12 ############################################################################### @@ -491,8 +492,8 @@ Zone Pacific/Auckland 11:39:04 - LMT 1868 Nov 2 11:30 NZ NZ%sT 1946 Jan 1 12:00 NZ NZ%sT Zone Pacific/Chatham 12:13:48 - LMT 1868 Nov 2 - 12:15 - CHAST 1946 Jan 1 - 12:45 Chatham CHA%sT + 12:15 - +1215 1946 Jan 1 + 12:45 Chatham +1245/+1345 Link Pacific/Auckland Antarctica/McMurdo @@ -514,8 +515,8 @@ Rule Cook 1979 1991 - Mar Sun>=1 0:00 0 - Rule Cook 1979 1990 - Oct lastSun 0:00 0:30 HS # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Rarotonga -10:39:04 - LMT 1901 # Avarua - -10:30 - CKT 1978 Nov 12 # Cook Is Time - -10:00 Cook CK%sT + -10:30 - -1030 1978 Nov 12 + -10:00 Cook -10/-0930 ############################################################################### @@ -523,29 +524,29 @@ Zone Pacific/Rarotonga -10:39:04 - LMT 1901 # Avarua # Niue # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Niue -11:19:40 - LMT 1901 # Alofi - -11:20 - NUT 1951 # Niue Time - -11:30 - NUT 1978 Oct 1 - -11:00 - NUT + -11:20 - -1120 1951 + -11:30 - -1130 1978 Oct 1 + -11:00 - -11 # Norfolk # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Norfolk 11:11:52 - LMT 1901 # Kingston - 11:12 - NMT 1951 # Norfolk Mean Time - 11:30 - NFT 1974 Oct 27 02:00 # Norfolk T. - 11:30 1:00 NFST 1975 Mar 2 02:00 - 11:30 - NFT 2015 Oct 4 02:00 - 11:00 - NFT + 11:12 - +1112 1951 + 11:30 - +1130 1974 Oct 27 02:00 + 11:30 1:00 +1230 1975 Mar 2 02:00 + 11:30 - +1130 2015 Oct 4 02:00 + 11:00 - +11 # Palau (Belau) # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Palau 8:57:56 - LMT 1901 # Koror - 9:00 - PWT # Palau Time + 9:00 - +09 # Papua New Guinea # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Port_Moresby 9:48:40 - LMT 1880 9:48:32 - PMMT 1895 # Port Moresby Mean Time - 10:00 - PGT # Papua New Guinea Time + 10:00 - +10 # # From Paul Eggert (2014-10-13): # Base the Bougainville entry on the Arawa-Kieta region, which appears to have @@ -560,28 +561,26 @@ Zone Pacific/Port_Moresby 9:48:40 - LMT 1880 # and seem to have controlled it until their 1945-08-21 surrender. # # The Autonomous Region of Bougainville switched from UT +10 to +11 -# on 2014-12-28 at 02:00. They call +11 "Bougainville Standard Time"; -# abbreviate this as BST. See: +# on 2014-12-28 at 02:00. They call +11 "Bougainville Standard Time". +# See: # http://www.bougainville24.com/bougainville-issues/bougainville-gets-own-timezone/ # Zone Pacific/Bougainville 10:22:16 - LMT 1880 9:48:32 - PMMT 1895 - 10:00 - PGT 1942 Jul - 9:00 - JST 1945 Aug 21 - 10:00 - PGT 2014 Dec 28 2:00 - 11:00 - BST + 10:00 - +10 1942 Jul + 9:00 - +09 1945 Aug 21 + 10:00 - +10 2014 Dec 28 2:00 + 11:00 - +11 # Pitcairn # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Pitcairn -8:40:20 - LMT 1901 # Adamstown - -8:30 - PNT 1998 Apr 27 0:00 - -8:00 - PST # Pitcairn Standard Time + -8:30 - -0830 1998 Apr 27 0:00 + -8:00 - -08 # American Samoa Zone Pacific/Pago_Pago 12:37:12 - LMT 1879 Jul 5 -11:22:48 - LMT 1911 - -11:00 - NST 1967 Apr # N=Nome - -11:00 - BST 1983 Nov 30 # B=Bering -11:00 - SST # S=Samoa Link Pacific/Pago_Pago Pacific/Midway # in US minor outlying islands @@ -662,17 +661,17 @@ Rule WS 2012 max - Sep lastSun 3:00 1 D # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Apia 12:33:04 - LMT 1879 Jul 5 -11:26:56 - LMT 1911 - -11:30 - WSST 1950 - -11:00 WS S%sT 2011 Dec 29 24:00 # S=Samoa - 13:00 WS WS%sT + -11:30 - -1130 1950 + -11:00 WS -11/-10 2011 Dec 29 24:00 + 13:00 WS +13/+14 # Solomon Is # excludes Bougainville, for which see Papua New Guinea # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Guadalcanal 10:39:48 - LMT 1912 Oct # Honiara - 11:00 - SBT # Solomon Is Time + 11:00 - +11 -# Tokelau Is +# Tokelau # # From Gwillim Law (2011-12-29) # A correspondent informed me that Tokelau, like Samoa, will be skipping @@ -693,8 +692,8 @@ Zone Pacific/Guadalcanal 10:39:48 - LMT 1912 Oct # Honiara # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Fakaofo -11:24:56 - LMT 1901 - -11:00 - TKT 2011 Dec 30 # Tokelau Time - 13:00 - TKT + -11:00 - -11 2011 Dec 30 + 13:00 - +13 # Tonga # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S @@ -713,7 +712,7 @@ Zone Pacific/Tongatapu 12:19:20 - LMT 1901 # Tuvalu # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Funafuti 11:56:52 - LMT 1901 - 12:00 - TVT # Tuvalu Time + 12:00 - +12 # US minor outlying islands @@ -737,10 +736,11 @@ Zone Pacific/Funafuti 11:56:52 - LMT 1901 # Johnston # -# From Paul Eggert (2014-03-11): +# From Paul Eggert (2017-02-10): # Sometimes Johnston kept Hawaii time, and sometimes it was an hour behind. # Details are uncertain. We have no data for Johnston after 1970, so -# treat it like Hawaii for now. +# treat it like Hawaii for now. Since Johnston is now uninhabited, +# its link to Pacific/Honolulu is in the 'backward' file. # # In his memoirs of June 6th to October 4, 1945 # (2005), Herbert C. Bach writes, @@ -760,8 +760,6 @@ Zone Pacific/Funafuti 11:56:52 - LMT 1901 # See the table on page 4 where he lists GMT and local times for the tests; a # footnote for the JI tests reads that local time is "JI time = Hawaii Time # Minus One Hour". -# -# See 'northamerica' for Pacific/Johnston. # Kingman # uninhabited @@ -775,7 +773,7 @@ Zone Pacific/Funafuti 11:56:52 - LMT 1901 # Wake # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Wake 11:06:28 - LMT 1901 - 12:00 - WAKT # Wake Time + 12:00 - +12 # Vanuatu @@ -788,12 +786,12 @@ Rule Vanuatu 1992 1993 - Jan Sun>=23 0:00 0 - Rule Vanuatu 1992 only - Oct Sun>=23 0:00 1:00 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Efate 11:13:16 - LMT 1912 Jan 13 # Vila - 11:00 Vanuatu VU%sT # Vanuatu Time + 11:00 Vanuatu +11/+12 # Wallis and Futuna # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Pacific/Wallis 12:15:20 - LMT 1901 - 12:00 - WFT # Wallis & Futuna Time + 12:00 - +12 ############################################################################### @@ -804,15 +802,15 @@ Zone Pacific/Wallis 12:15:20 - LMT 1901 # tz@iana.org for general use in the future). For more, please see # the file CONTRIBUTING in the tz distribution. -# From Paul Eggert (2014-10-31): +# From Paul Eggert (2017-02-10): # # Unless otherwise specified, the source for data through 1990 is: # Thomas G. Shanks and Rique Pottenger, The International Atlas (6th edition), # San Diego: ACS Publications, Inc. (2003). # Unfortunately this book contains many errors and cites no sources. # -# Gwillim Law writes that a good source -# for recent time zone data is the International Air Transport +# Many years ago Gwillim Law wrote that a good source +# for time zone data was the International Air Transport # Association's Standard Schedules Information Manual (IATA SSIM), # published semiannually. Law sent in several helpful summaries # of the IATA's data after 1990. Except where otherwise noted, @@ -829,28 +827,19 @@ Zone Pacific/Wallis 12:15:20 - LMT 1901 # A reliable and entertaining source about time zones is # Derek Howse, Greenwich time and longitude, Philip Wilson Publishers (1997). # -# I invented the abbreviations marked '*' in the following table; -# the rest are from earlier versions of this file, or from other sources. +# The following abbreviations are from other sources. # Corrections are welcome! # std dst # LMT Local Mean Time # 8:00 AWST AWDT Western Australia -# 8:45 ACWST ACWDT Central Western Australia* -# 9:00 JST Japan # 9:30 ACST ACDT Central Australia # 10:00 AEST AEDT Eastern Australia +# 10:00 GST Guam through 2000 # 10:00 ChST Chamorro -# 10:30 LHST LHDT Lord Howe* -# 11:00 BST Bougainville* # 11:30 NZMT NZST New Zealand through 1945 # 12:00 NZST NZDT New Zealand 1946-present -# 12:15 CHAST Chatham through 1945* -# 12:45 CHAST CHADT Chatham 1946-present* -# 13:00 WSST WSDT (western) Samoa 2011-present* -# -11:30 WSST Western Samoa through 1950* # -11:00 SST Samoa # -10:00 HST Hawaii -# - 8:00 PST Pitcairn* # # See the 'northamerica' file for Hawaii. # See the 'southamerica' file for Easter I and the Galápagos Is. diff --git a/src/timezone/data/backward b/src/timezone/data/backward index aa23dd844e..09f2a31b68 100644 --- a/src/timezone/data/backward +++ b/src/timezone/data/backward @@ -96,6 +96,7 @@ Link Pacific/Auckland NZ Link Pacific/Chatham NZ-CHAT Link America/Denver Navajo Link Asia/Shanghai PRC +Link Pacific/Honolulu Pacific/Johnston Link Pacific/Pohnpei Pacific/Ponape Link Pacific/Pago_Pago Pacific/Samoa Link Pacific/Chuuk Pacific/Truk diff --git a/src/timezone/data/backzone b/src/timezone/data/backzone index 4a5085f422..9ce78316c2 100644 --- a/src/timezone/data/backzone +++ b/src/timezone/data/backzone @@ -65,7 +65,7 @@ Link Africa/Asmara Africa/Asmera # Mali (southern) Zone Africa/Bamako -0:32:00 - LMT 1912 0:00 - GMT 1934 Feb 26 - -1:00 - WAT 1960 Jun 20 + -1:00 - -01 1960 Jun 20 0:00 - GMT # Central African Republic @@ -75,7 +75,7 @@ Zone Africa/Bangui 1:14:20 - LMT 1912 # Gambia Zone Africa/Banjul -1:06:36 - LMT 1912 -1:06:36 - BMT 1935 # Banjul Mean Time - -1:00 - WAT 1964 + -1:00 - -01 1964 0:00 - GMT # Malawi @@ -93,18 +93,18 @@ Zone Africa/Bujumbura 1:57:28 - LMT 1890 # Guinea Zone Africa/Conakry -0:54:52 - LMT 1912 0:00 - GMT 1934 Feb 26 - -1:00 - WAT 1960 + -1:00 - -01 1960 0:00 - GMT # Senegal Zone Africa/Dakar -1:09:44 - LMT 1912 - -1:00 - WAT 1941 Jun + -1:00 - -01 1941 Jun 0:00 - GMT # Tanzania Zone Africa/Dar_es_Salaam 2:37:08 - LMT 1931 3:00 - EAT 1948 - 2:45 - BEAUT 1961 + 2:45 - +0245 1961 3:00 - EAT # Djibouti @@ -122,14 +122,14 @@ Zone Africa/Douala 0:38:48 - LMT 1912 # The International Hydrographic Bulletin, 1932-33, p 63 says that # Sierra Leone would advance its clocks by 20 minutes on 1933-10-01. # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S -Rule SL 1935 1942 - Jun 1 0:00 0:40 SLST -Rule SL 1935 1942 - Oct 1 0:00 0 WAT -Rule SL 1957 1962 - Jun 1 0:00 1:00 SLST +Rule SL 1935 1942 - Jun 1 0:00 0:40 -0020 +Rule SL 1935 1942 - Oct 1 0:00 0 -01 +Rule SL 1957 1962 - Jun 1 0:00 1:00 +01 Rule SL 1957 1962 - Sep 1 0:00 0 GMT Zone Africa/Freetown -0:53:00 - LMT 1882 -0:53:00 - FMT 1913 Jun # Freetown Mean Time -1:00 SL %s 1957 - 0:00 SL %s + 0:00 SL GMT/+01 # Botswana # From Paul Eggert (2013-02-21): @@ -153,8 +153,8 @@ Zone Africa/Juba 2:06:24 - LMT 1931 # Uganda Zone Africa/Kampala 2:09:40 - LMT 1928 Jul 3:00 - EAT 1930 - 2:30 - BEAT 1948 - 2:45 - BEAUT 1957 + 2:30 - +0230 1948 + 2:45 - +0245 1957 3:00 - EAT # Rwanda @@ -177,11 +177,11 @@ Zone Africa/Lome 0:04:52 - LMT 1893 # # Shanks gives 1911-05-26 for the transition to WAT, # evidently confusing the date of the Portuguese decree -# http://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf +# https://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf # with the date that it took effect, namely 1912-01-01. # Zone Africa/Luanda 0:52:56 - LMT 1892 - 0:52:04 - AOT 1912 Jan 1 # Angola Time + 0:52:04 - +005204 1912 Jan 1 1:00 - WAT # Democratic Republic of the Congo (east) @@ -216,19 +216,19 @@ Zone Africa/Mbabane 2:04:24 - LMT 1903 Mar # Somalia Zone Africa/Mogadishu 3:01:28 - LMT 1893 Nov 3:00 - EAT 1931 - 2:30 - BEAT 1957 + 2:30 - +0230 1957 3:00 - EAT # Niger Zone Africa/Niamey 0:08:28 - LMT 1912 - -1:00 - WAT 1934 Feb 26 + -1:00 - -01 1934 Feb 26 0:00 - GMT 1960 1:00 - WAT # Mauritania Zone Africa/Nouakchott -1:03:48 - LMT 1912 0:00 - GMT 1934 Feb 26 - -1:00 - WAT 1960 Nov 28 + -1:00 - -01 1960 Nov 28 0:00 - GMT # Burkina Faso @@ -264,19 +264,19 @@ Zone America/Antigua -4:07:12 - LMT 1912 Mar 2 # The name "Comodoro Rivadavia" exceeds the 14-byte POSIX limit. Zone America/Argentina/ComodRivadavia -4:30:00 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Mar 3 - -4:00 - WART 1991 Oct 20 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 Jun 1 - -4:00 - WART 2004 Jun 20 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Mar 3 + -4:00 - -04 1991 Oct 20 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 Jun 1 + -4:00 - -04 2004 Jun 20 + -3:00 - -03 # Aruba Zone America/Aruba -4:40:24 - LMT 1912 Feb 12 # Oranjestad - -4:30 - ANT 1965 # Netherlands Antilles Time + -4:30 - -0430 1965 -4:00 - AST # Cayman Is @@ -365,12 +365,12 @@ Zone America/Montserrat -4:08:52 - LMT 1911 Jul 1 0:01 # Cork Hill # Formosa (FM), La Pampa (LP), Chubut (CH) Zone America/Rosario -4:02:40 - LMT 1894 Nov -4:16:44 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Jul - -3:00 - ART 1999 Oct 3 0:00 - -4:00 Arg AR%sT 2000 Mar 3 0:00 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Jul + -3:00 - -03 1999 Oct 3 0:00 + -4:00 Arg -04/-03 2000 Mar 3 0:00 + -3:00 - -03 # St Kitts-Nevis Zone America/St_Kitts -4:10:52 - LMT 1912 Mar 2 # Basseterre @@ -403,12 +403,12 @@ Link Antarctica/McMurdo Antarctica/South_Pole # Milne says 2:59:54 was the meridian of the saluting battery at Aden, # and that Yemen was at 1:55:56, the meridian of the Hagia Sophia. Zone Asia/Aden 2:59:54 - LMT 1950 - 3:00 - AST + 3:00 - +03 # Bahrain Zone Asia/Bahrain 3:22:20 - LMT 1920 # Manamah - 4:00 - GST 1972 Jun - 3:00 - AST + 4:00 - +04 1972 Jun + 3:00 - +03 # India # @@ -431,7 +431,7 @@ Zone Asia/Bahrain 3:22:20 - LMT 1920 # Manamah # counties Deqing, Enping, Kaiping, Luoding, Taishan, Xinxing, # Yangchun, Yangjiang, Yu'nan, and Yunfu. Zone Asia/Chongqing 7:06:20 - LMT 1928 # or Chungking - 7:00 - LONT 1980 May # Long-shu Time + 7:00 - +07 1980 May 8:00 PRC C%sT Link Asia/Chongqing Asia/Chungking @@ -442,43 +442,43 @@ Link Asia/Chongqing Asia/Chungking # October 1954, with exact date and time unspecified. Zone Asia/Hanoi 7:03:24 - LMT 1906 Jul 1 7:06:30 - PLMT 1911 May 1 - 7:00 - ICT 1942 Dec 31 23:00 - 8:00 - IDT 1945 Mar 14 23:00 - 9:00 - JST 1945 Sep 2 - 7:00 - ICT 1947 Apr 1 - 8:00 - IDT 1954 Oct - 7:00 - ICT + 7:00 - +07 1942 Dec 31 23:00 + 8:00 - +08 1945 Mar 14 23:00 + 9:00 - +09 1945 Sep 2 + 7:00 - +07 1947 Apr 1 + 8:00 - +08 1954 Oct + 7:00 - +07 # China # Changbai Time ("Long-white Time", Long-white = Heilongjiang area) # Heilongjiang (except Mohe county), Jilin Zone Asia/Harbin 8:26:44 - LMT 1928 # or Haerbin - 8:30 - CHAT 1932 Mar # Changbai Time + 8:30 - +0830 1932 Mar 8:00 - CST 1940 - 9:00 - CHAT 1966 May - 8:30 - CHAT 1980 May + 9:00 - +09 1966 May + 8:30 - +0830 1980 May 8:00 PRC C%sT # far west China Zone Asia/Kashgar 5:03:56 - LMT 1928 # or Kashi or Kaxgar - 5:30 - KAST 1940 # Kashgar Time - 5:00 - KAST 1980 May + 5:30 - +0530 1940 + 5:00 - +05 1980 May 8:00 PRC C%sT # Kuwait Zone Asia/Kuwait 3:11:56 - LMT 1950 - 3:00 - AST + 3:00 - +03 # Oman # Milne says 3:54:24 was the meridian of the Muscat Tidal Observatory. Zone Asia/Muscat 3:54:24 - LMT 1920 - 4:00 - GST + 4:00 - +04 # India # From Paul Eggert (2014-08-11), after a heads-up from Stephen Colebourne: # According to a Portuguese decree (1911-05-26) -# http://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf +# https://dre.pt/pdf1sdip/1911/05/12500/23132313.pdf # Portuguese India switched to UT +05 on 1912-01-01. #Zone Asia/Panaji [not enough info to complete] @@ -491,12 +491,12 @@ Zone Asia/Muscat 3:54:24 - LMT 1920 # transitions there. Zone Asia/Phnom_Penh 6:59:40 - LMT 1906 Jul 1 7:06:30 - PLMT 1911 May 1 - 7:00 - ICT 1942 Dec 31 23:00 - 8:00 - IDT 1945 Mar 14 23:00 - 9:00 - JST 1945 Sep 2 - 7:00 - ICT 1947 Apr 1 - 8:00 - IDT 1953 Nov 9 - 7:00 - ICT + 7:00 - +07 1942 Dec 31 23:00 + 8:00 - +08 1945 Mar 14 23:00 + 9:00 - +09 1945 Sep 2 + 7:00 - +07 1947 Apr 1 + 8:00 - +08 1953 Nov 9 + 7:00 - +07 # Israel Zone Asia/Tel_Aviv 2:19:04 - LMT 1880 @@ -511,16 +511,16 @@ Zone Asia/Tel_Aviv 2:19:04 - LMT 1880 # this is probably wrong but it's better than guessing no transition. Zone Asia/Vientiane 6:50:24 - LMT 1906 Jul 1 7:06:30 - PLMT 1911 May 1 - 7:00 - ICT 1942 Dec 31 23:00 - 8:00 - IDT 1945 Mar 14 23:00 - 9:00 - JST 1945 Sep 2 - 7:00 - ICT 1947 Apr 1 - 8:00 - IDT 1955 Apr 15 - 7:00 - ICT + 7:00 - +07 1942 Dec 31 23:00 + 8:00 - +08 1945 Mar 14 23:00 + 9:00 - +09 1945 Sep 2 + 7:00 - +07 1947 Apr 1 + 8:00 - +08 1955 Apr 15 + 7:00 - +07 # Jan Mayen # From Whitman: -Zone Atlantic/Jan_Mayen -1:00 - EGT +Zone Atlantic/Jan_Mayen -1:00 - -01 # St Helena Zone Atlantic/St_Helena -0:22:48 - LMT 1890 # Jamestown @@ -663,15 +663,13 @@ Zone Pacific/Johnston -10:00 - HST # " 3:00P Ar. MIDWAY ISLAND . . . . . . . . . M.L.T. Lv. 6:00A " # Zone Pacific/Midway -11:49:28 - LMT 1901 - -11:00 - NST 1956 Jun 3 - -11:00 1:00 NDT 1956 Sep 2 - -11:00 - NST 1967 Apr # N=Nome - -11:00 - BST 1983 Nov 30 # B=Bering - -11:00 - SST # S=Samoa + -11:00 - -11 1956 Jun 3 + -11:00 1:00 -10 1956 Sep 2 + -11:00 - -11 # N Mariana Is Zone Pacific/Saipan -14:17:00 - LMT 1844 Dec 31 9:43:00 - LMT 1901 - 9:00 - MPT 1969 Oct # N Mariana Is Time - 10:00 - MPT 2000 Dec 23 + 9:00 - +09 1969 Oct + 10:00 - +10 2000 Dec 23 10:00 - ChST # Chamorro Standard Time diff --git a/src/timezone/data/europe b/src/timezone/data/europe index bf3bf06446..558b9f168f 100644 --- a/src/timezone/data/europe +++ b/src/timezone/data/europe @@ -6,15 +6,15 @@ # tz@iana.org for general use in the future). For more, please see # the file CONTRIBUTING in the tz distribution. -# From Paul Eggert (2014-10-31): +# From Paul Eggert (2017-02-10): # # Unless otherwise specified, the source for data through 1990 is: # Thomas G. Shanks and Rique Pottenger, The International Atlas (6th edition), # San Diego: ACS Publications, Inc. (2003). # Unfortunately this book contains many errors and cites no sources. # -# Gwillim Law writes that a good source -# for recent time zone data is the International Air Transport +# Many years ago Gwillim Law wrote that a good source +# for time zone data was the International Air Transport # Association's Standard Schedules Information Manual (IATA SSIM), # published semiannually. Law sent in several helpful summaries # of the IATA's data after 1990. Except where otherwise noted, @@ -56,26 +56,23 @@ # History of Summer Time # # (1998-09-21, in Portuguese) - # # I invented the abbreviations marked '*' in the following table; -# the rest are from earlier versions of this file, or from other sources. -# Corrections are welcome! -# std dst 2dst -# LMT Local Mean Time -# -4:00 AST ADT Atlantic -# -3:00 WGT WGST Western Greenland* -# -1:00 EGT EGST Eastern Greenland* -# 0:00 GMT BST BDST Greenwich, British Summer -# 0:00 GMT IST Greenwich, Irish Summer -# 0:00 WET WEST WEMT Western Europe -# 0:19:32.13 AMT NST Amsterdam, Netherlands Summer (1835-1937)* -# 0:20 NET NEST Netherlands (1937-1940)* -# 1:00 BST British Standard (1968-1971) -# 1:00 CET CEST CEMT Central Europe -# 1:00:14 SET Swedish (1879-1899)* -# 2:00 EET EEST Eastern Europe -# 3:00 MSK MSD Moscow +# the rest are variants of the "xMT" pattern for a city's mean time, +# or are from other sources. Corrections are welcome! +# std dst 2dst +# LMT Local Mean Time +# -4:00 AST ADT Atlantic +# 0:00 GMT BST BDST Greenwich, British Summer +# 0:00 GMT IST Greenwich, Irish Summer +# 0:00 WET WEST WEMT Western Europe +# 0:19:32.13 AMT* NST* Amsterdam, Netherlands Summer (1835-1937) +# 1:00 BST British Standard (1968-1971) +# 1:00 CET CEST CEMT Central Europe +# 1:00:14 SET Swedish (1879-1899) +# 1:36:34 RMT* LST* Riga, Latvian Summer (1880-1926)* +# 2:00 EET EEST Eastern Europe +# 3:00 MSK MSD MDST* Moscow # From Peter Ilieve (1994-12-04), # The original six [EU members]: Belgium, France, (West) Germany, Italy, @@ -475,7 +472,7 @@ Link Europe/London Europe/Isle_of_Man # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Europe/Dublin -0:25:00 - LMT 1880 Aug 2 - -0:25:21 - DMT 1916 May 21 2:00 + -0:25:21 - DMT 1916 May 21 2:00 # Dublin MT -0:25:21 1:00 IST 1916 Oct 1 2:00s 0:00 GB-Eire %s 1921 Dec 6 # independence 0:00 GB-Eire GMT/IST 1940 Feb 25 2:00 @@ -1064,16 +1061,16 @@ Rule Thule 2007 max - Nov Sun>=1 2:00 0 S # # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Danmarkshavn -1:14:40 - LMT 1916 Jul 28 - -3:00 - WGT 1980 Apr 6 2:00 - -3:00 EU WG%sT 1996 + -3:00 - -03 1980 Apr 6 2:00 + -3:00 EU -03/-02 1996 0:00 - GMT Zone America/Scoresbysund -1:27:52 - LMT 1916 Jul 28 # Ittoqqortoormiit - -2:00 - CGT 1980 Apr 6 2:00 - -2:00 C-Eur CG%sT 1981 Mar 29 - -1:00 EU EG%sT + -2:00 - -02 1980 Apr 6 2:00 + -2:00 C-Eur -02/-01 1981 Mar 29 + -1:00 EU -01/+00 Zone America/Godthab -3:26:56 - LMT 1916 Jul 28 # Nuuk - -3:00 - WGT 1980 Apr 6 2:00 - -3:00 EU WG%sT + -3:00 - -03 1980 Apr 6 2:00 + -3:00 EU -03/-02 Zone America/Thule -4:35:08 - LMT 1916 Jul 28 # Pituffik air base -4:00 Thule A%sT @@ -1488,7 +1485,7 @@ Rule Iceland 1950 1966 - Oct Sun>=22 1:00s 0 - Rule Iceland 1967 only - Oct 29 1:00s 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Atlantic/Reykjavik -1:28 - LMT 1908 - -1:00 Iceland IS%sT 1968 Apr 7 1:00s + -1:00 Iceland -01/+00 1968 Apr 7 1:00s 0:00 - GMT # Italy @@ -1952,7 +1949,7 @@ Rule Neth 1945 only - Sep 16 2:00s 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Europe/Amsterdam 0:19:32 - LMT 1835 0:19:32 Neth %s 1937 Jul 1 - 0:20 Neth NE%sT 1940 May 16 0:00 # Dutch Time + 0:20 Neth +0020/+0120 1940 May 16 0:00 1:00 C-Eur CE%sT 1945 Apr 2 2:00 1:00 Neth CE%sT 1977 1:00 EU CE%sT @@ -2169,16 +2166,34 @@ Zone Europe/Lisbon -0:36:45 - LMT 1884 0:00 W-Eur WE%sT 1992 Sep 27 1:00s 1:00 EU CE%sT 1996 Mar 31 1:00u 0:00 EU WE%sT +# This Zone can be simplified once we assume zic %z. Zone Atlantic/Azores -1:42:40 - LMT 1884 # Ponta Delgada -1:54:32 - HMT 1912 Jan 1 # Horta Mean Time - -2:00 Port AZO%sT 1966 Apr 3 2:00 # Azores Time - -1:00 Port AZO%sT 1983 Sep 25 1:00s - -1:00 W-Eur AZO%sT 1992 Sep 27 1:00s + -2:00 Port -02/-01 1942 Apr 25 22:00s + -2:00 Port +00 1942 Aug 15 22:00s + -2:00 Port -02/-01 1943 Apr 17 22:00s + -2:00 Port +00 1943 Aug 28 22:00s + -2:00 Port -02/-01 1944 Apr 22 22:00s + -2:00 Port +00 1944 Aug 26 22:00s + -2:00 Port -02/-01 1945 Apr 21 22:00s + -2:00 Port +00 1945 Aug 25 22:00s + -2:00 Port -02/-01 1966 Apr 3 2:00 + -1:00 Port -01/+00 1983 Sep 25 1:00s + -1:00 W-Eur -01/+00 1992 Sep 27 1:00s 0:00 EU WE%sT 1993 Mar 28 1:00u - -1:00 EU AZO%sT + -1:00 EU -01/+00 +# This Zone can be simplified once we assume zic %z. Zone Atlantic/Madeira -1:07:36 - LMT 1884 # Funchal -1:07:36 - FMT 1912 Jan 1 # Funchal Mean Time - -1:00 Port MAD%sT 1966 Apr 3 2:00 # Madeira Time + -1:00 Port -01/+00 1942 Apr 25 22:00s + -1:00 Port +01 1942 Aug 15 22:00s + -1:00 Port -01/+00 1943 Apr 17 22:00s + -1:00 Port +01 1943 Aug 28 22:00s + -1:00 Port -01/+00 1944 Apr 22 22:00s + -1:00 Port +01 1944 Aug 26 22:00s + -1:00 Port -01/+00 1945 Apr 21 22:00s + -1:00 Port +01 1945 Aug 25 22:00s + -1:00 Port -01/+00 1966 Apr 3 2:00 0:00 Port WE%sT 1983 Sep 25 1:00s 0:00 EU WE%sT @@ -2536,10 +2551,8 @@ Zone Europe/Moscow 2:30:17 - LMT 1880 3:00 - MSK -# From Tim Parenti (2014-07-03): -# Europe/Simferopol covers... -# ** **** Crimea, Republic of -# ** **** Sevastopol +# From Paul Eggert (2016-12-06): +# Europe/Simferopol covers Crimea. Zone Europe/Simferopol 2:16:24 - LMT 1880 2:16 - SMT 1924 May 2 # Simferopol Mean T @@ -3232,46 +3245,77 @@ Link Europe/Prague Europe/Bratislava # See Europe/Belgrade. # Spain +# +# From Paul Eggert (2016-12-14): +# +# The source for Europe/Madrid before 2013 is: +# Planesas P. La hora oficial en España y sus cambios. +# Anuario del Observatorio Astronómico de Madrid (2013, in Spanish). +# http://astronomia.ign.es/rknowsys-theme/images/webAstro/paginas/documentos/Anuario/lahoraoficialenespana.pdf +# As this source says that historical time in the Canaries is obscure, +# and it does not discuss Ceuta, stick with Shanks for now for that data. +# +# In the 1918 and 1919 fallback transitions in Spain, the clock for +# the hour-longer day officially kept going after midnight, so that +# the repeated instances of that day's 00:00 hour were 24 hours apart, +# with a fallback transition from the second occurrence of 00:59... to +# the next day's 00:00. Our data format cannot represent this +# directly, and instead repeats the first hour of the next day, with a +# fallback transition from the next day's 00:59... to 00:00. + +# From Michael Deckers (2016-12-15): +# The Royal Decree of 1900-06-26 quoted by Planesas, online at +# https://www.boe.es/datos/pdfs/BOE//1900/209/A00383-00384.pdf +# says in its article 5 (my translation): +# These dispositions will enter into force beginning with the +# instant at which, according to the time indicated in article 1, +# the 1st day of January of 1901 will begin. + # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S -# For 1917-1919 Whitman gives Apr Sat>=1 - Oct Sat>=1; -# go with Shanks & Pottenger. -Rule Spain 1917 only - May 5 23:00s 1:00 S -Rule Spain 1917 1919 - Oct 6 23:00s 0 - -Rule Spain 1918 only - Apr 15 23:00s 1:00 S -Rule Spain 1919 only - Apr 5 23:00s 1:00 S -# Whitman gives 1921 Feb 28 - Oct 14; go with Shanks & Pottenger. -Rule Spain 1924 only - Apr 16 23:00s 1:00 S -# Whitman gives 1924 Oct 14; go with Shanks & Pottenger. -Rule Spain 1924 only - Oct 4 23:00s 0 - -Rule Spain 1926 only - Apr 17 23:00s 1:00 S -# Whitman says no DST in 1929; go with Shanks & Pottenger. -Rule Spain 1926 1929 - Oct Sat>=1 23:00s 0 - -Rule Spain 1927 only - Apr 9 23:00s 1:00 S -Rule Spain 1928 only - Apr 14 23:00s 1:00 S -Rule Spain 1929 only - Apr 20 23:00s 1:00 S -# Whitman gives 1937 Jun 16, 1938 Apr 16, 1940 Apr 13; -# go with Shanks & Pottenger. -Rule Spain 1937 only - May 22 23:00s 1:00 S -Rule Spain 1937 1939 - Oct Sat>=1 23:00s 0 - -Rule Spain 1938 only - Mar 22 23:00s 1:00 S -Rule Spain 1939 only - Apr 15 23:00s 1:00 S -Rule Spain 1940 only - Mar 16 23:00s 1:00 S -# Whitman says no DST 1942-1945; go with Shanks & Pottenger. -Rule Spain 1942 only - May 2 22:00s 2:00 M # Midsummer -Rule Spain 1942 only - Sep 1 22:00s 1:00 S -Rule Spain 1943 1946 - Apr Sat>=13 22:00s 2:00 M -Rule Spain 1943 only - Oct 3 22:00s 1:00 S -Rule Spain 1944 only - Oct 10 22:00s 1:00 S -Rule Spain 1945 only - Sep 30 1:00 1:00 S -Rule Spain 1946 only - Sep 30 0:00 0 - +Rule Spain 1918 only - Apr 15 23:00 1:00 S +Rule Spain 1918 1919 - Oct 6 24:00s 0 - +Rule Spain 1919 only - Apr 6 23:00 1:00 S +Rule Spain 1924 only - Apr 16 23:00 1:00 S +Rule Spain 1924 only - Oct 4 24:00s 0 - +Rule Spain 1926 only - Apr 17 23:00 1:00 S +Rule Spain 1926 1929 - Oct Sat>=1 24:00s 0 - +Rule Spain 1927 only - Apr 9 23:00 1:00 S +Rule Spain 1928 only - Apr 15 0:00 1:00 S +Rule Spain 1929 only - Apr 20 23:00 1:00 S +# Republican Spain during the civil war; it controlled Madrid until 1939-03-28. +Rule Spain 1937 only - Jun 16 23:00 1:00 S +Rule Spain 1937 only - Oct 2 24:00s 0 - +Rule Spain 1938 only - Apr 2 23:00 1:00 S +Rule Spain 1938 only - Apr 30 23:00 2:00 M +Rule Spain 1938 only - Oct 2 24:00 1:00 S +# The following rules are for unified Spain again. +# +# Planesas does not say what happened in Madrid between its fall on +# 1939-03-28 and the Nationalist spring-forward transition on +# 1939-04-15. For lack of better info, assume Madrid's clocks did not +# change during that period. +# +# The first rule is commented out, as it is redundant for Republican Spain. +#Rule Spain 1939 only - Apr 15 23:00 1:00 S +Rule Spain 1939 only - Oct 7 24:00s 0 - +Rule Spain 1942 only - May 2 23:00 1:00 S +Rule Spain 1942 only - Sep 1 1:00 0 - +Rule Spain 1943 1946 - Apr Sat>=13 23:00 1:00 S +Rule Spain 1943 1944 - Oct Sun>=1 1:00 0 - +Rule Spain 1945 1946 - Sep lastSun 1:00 0 - Rule Spain 1949 only - Apr 30 23:00 1:00 S -Rule Spain 1949 only - Sep 30 1:00 0 - -Rule Spain 1974 1975 - Apr Sat>=13 23:00 1:00 S +Rule Spain 1949 only - Oct 2 1:00 0 - +Rule Spain 1974 1975 - Apr Sat>=12 23:00 1:00 S Rule Spain 1974 1975 - Oct Sun>=1 1:00 0 - Rule Spain 1976 only - Mar 27 23:00 1:00 S Rule Spain 1976 1977 - Sep lastSun 1:00 0 - -Rule Spain 1977 1978 - Apr 2 23:00 1:00 S -Rule Spain 1978 only - Oct 1 1:00 0 - +Rule Spain 1977 only - Apr 2 23:00 1:00 S +Rule Spain 1978 only - Apr 2 2:00s 1:00 S +Rule Spain 1978 only - Oct 1 2:00s 0 - +# Nationalist Spain during the civil war +#Rule NatSpain 1937 only - May 22 23:00 1:00 S +#Rule NatSpain 1937 1938 - Oct Sat>=1 24:00s 0 - +#Rule NatSpain 1938 only - Mar 26 23:00 1:00 S # The following rules are copied from Morocco from 1967 through 1978. Rule SpainAfrica 1967 only - Jun 3 12:00 1:00 S Rule SpainAfrica 1967 only - Oct 1 0:00 0 - @@ -3283,11 +3327,11 @@ Rule SpainAfrica 1977 only - Sep 28 0:00 0 - Rule SpainAfrica 1978 only - Jun 1 0:00 1:00 S Rule SpainAfrica 1978 only - Aug 4 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] -Zone Europe/Madrid -0:14:44 - LMT 1901 Jan 1 0:00s - 0:00 Spain WE%sT 1946 Sep 30 +Zone Europe/Madrid -0:14:44 - LMT 1900 Dec 31 23:45:16 + 0:00 Spain WE%sT 1940 Mar 16 23:00 1:00 Spain CE%sT 1979 1:00 EU CE%sT -Zone Africa/Ceuta -0:21:16 - LMT 1901 +Zone Africa/Ceuta -0:21:16 - LMT 1900 Dec 31 23:38:44 0:00 - WET 1918 May 6 23:00 0:00 1:00 WEST 1918 Oct 7 23:00 0:00 - WET 1924 @@ -3296,7 +3340,7 @@ Zone Africa/Ceuta -0:21:16 - LMT 1901 1:00 - CET 1986 1:00 EU CE%sT Zone Atlantic/Canary -1:01:36 - LMT 1922 Mar # Las Palmas de Gran C. - -1:00 - CANT 1946 Sep 30 1:00 # Canaries T + -1:00 - -01 1946 Sep 30 1:00 0:00 - WET 1980 Apr 6 0:00s 0:00 1:00 WEST 1980 Sep 28 1:00u 0:00 EU WE%sT @@ -3709,7 +3753,7 @@ Zone Europe/Uzhgorod 1:29:12 - LMT 1890 Oct # spelling, except omit the apostrophe as it is not allowed in # portable Posix file names. Zone Europe/Zaporozhye 2:20:40 - LMT 1880 - 2:20 - CUT 1924 May 2 # Central Ukraine T + 2:20 - +0220 1924 May 2 2:00 - EET 1930 Jun 21 3:00 - MSK 1941 Aug 25 1:00 C-Eur CE%sT 1943 Oct 25 diff --git a/src/timezone/data/northamerica b/src/timezone/data/northamerica index e1ed9e4a87..6ede9dcd96 100644 --- a/src/timezone/data/northamerica +++ b/src/timezone/data/northamerica @@ -178,22 +178,6 @@ Zone CST6CDT -6:00 US C%sT Zone MST7MDT -7:00 US M%sT Zone PST8PDT -8:00 US P%sT -# From Bob Devine (1988-01-28): -# ...Alaska (and Hawaii) had the timezone names changed in 1967. -# old new -# Pacific Standard Time(PST) -same- -# Yukon Standard Time(YST) -same- -# Central Alaska S.T. (CAT) Alaska-Hawaii St[an]dard Time (AHST) -# Nome Standard Time (NT) Bering Standard Time (BST) -# -# ...Alaska's timezone lines were redrawn in 1983 to give only 2 tz. -# The YST zone now covers nearly all of the state, AHST just part -# of the Aleutian islands. No DST. - -# From Paul Eggert (1995-12-19): -# The tables below use 'NST', not 'NT', for Nome Standard Time. -# I invented 'CAWT' for Central Alaska War Time. - # From U. S. Naval Observatory (1989-01-19): # USA EASTERN 5 H BEHIND UTC NEW YORK, WASHINGTON # USA EASTERN 4 H BEHIND UTC APR 3 - OCT 30 @@ -250,6 +234,21 @@ Zone PST8PDT -8:00 US P%sT # Samoa standard time # The law doesn't give abbreviations. # +# From Paul Eggert (2016-12-19): +# Here are URLs for the 1918 and 1966 legislation: +# http://uscode.house.gov/statviewer.htm?volume=40&page=451 +# http://uscode.house.gov/statviewer.htm?volume=80&page=108 +# Although the 1918 names were officially "United States Standard +# Eastern Time" and similarly for "Central", "Mountain", "Pacific", +# and "Alaska", in practice "Standard" was placed just before "Time", +# as codified in 1966. In practice, Alaska time was abbreviated "AST" +# before 1968. Summarizing the 1967 name changes: +# 1918 names 1967 names +# -08 Standard Pacific Time (PST) Pacific standard time (PST) +# -09 (unofficial) Yukon (YST) Yukon standard time (YST) +# -10 Standard Alaska Time (AST) Alaska-Hawaii standard time (AHST) +# -11 (unofficial) Nome (NST) Bering standard time (BST) +# # From Paul Eggert (2000-01-08), following a heads-up from Rives McDow: # Public law 106-564 (2000-12-23) introduced ... "Chamorro Standard Time" # for time in Guam and the Northern Marianas. See the file "australasia". @@ -305,6 +304,15 @@ Zone PST8PDT -8:00 US P%sT # Roberts, city administrator in Phenix City. as saying "We are in the Central # time zone, but we do go by the Eastern time zone because so many people work # in Columbus." +# +# From Paul Eggert (2017-02-22): +# Four cities are involved. The two not mentioned above are Smiths Station +# and Valley. Barbara Brooks, Valley's assistant treasurer, heard it started +# because West Point Pepperell textile mills were in Alabama while the +# corporate office was in Georgia, and residents voted to keep Eastern +# time even after the mills closed. See: Kazek K. Did you know which +# Alabama towns are in a different time zone? al.com 2017-02-06. +# http://www.al.com/living/index.ssf/2017/02/do_you_know_which_alabama_town.html # From Paul Eggert (2014-09-06): # Monthly Notices of the Royal Astronomical Society 44, 4 (1884-02-08), 208 @@ -482,7 +490,7 @@ Zone America/Los_Angeles -7:52:58 - LMT 1883 Nov 18 12:07:02 -8:00 US P%sT # Alaska -# AK%sT is the modern abbreviation for -9:00 per USNO. +# AK%sT is the modern abbreviation for -09 per USNO. # # From Paul Eggert (2001-05-30): # Howse writes that Alaska switched from the Julian to the Gregorian calendar, @@ -588,10 +596,8 @@ Zone America/Yakutat 14:41:05 - LMT 1867 Oct 18 -9:00 US AK%sT Zone America/Anchorage 14:00:24 - LMT 1867 Oct 18 -9:59:36 - LMT 1900 Aug 20 12:00 - -10:00 - CAT 1942 - -10:00 US CAT/CAWT 1945 Aug 14 23:00u - -10:00 US CAT/CAPT 1946 # Peace - -10:00 - CAT 1967 Apr + -10:00 - AST 1942 + -10:00 US A%sT 1967 Apr -10:00 - AHST 1969 -10:00 US AH%sT 1983 Oct 30 2:00 -9:00 US Y%sT 1983 Nov 30 @@ -680,7 +686,6 @@ Zone Pacific/Honolulu -10:31:26 - LMT 1896 Jan 13 12:00 -10:30 1:00 HDT 1945 Sep 30 2:00 -10:30 - HST 1947 Jun 8 2:00 -10:00 - HST -Link Pacific/Honolulu Pacific/Johnston # Now we turn to US areas that have diverged from the consensus since 1970. @@ -1068,15 +1073,15 @@ Zone America/Menominee -5:50:27 - LMT 1885 Sep 18 12:00 ################################################################################ -# From Paul Eggert (2014-10-31): +# From Paul Eggert (2017-02-10): # # Unless otherwise specified, the source for data through 1990 is: # Thomas G. Shanks and Rique Pottenger, The International Atlas (6th edition), # San Diego: ACS Publications, Inc. (2003). # Unfortunately this book contains many errors and cites no sources. # -# Gwillim Law writes that a good source -# for recent time zone data is the International Air Transport +# Many years ago Gwillim Law wrote that a good source +# for time zone data was the International Air Transport # Association's Standard Schedules Information Manual (IATA SSIM), # published semiannually. Law sent in several helpful summaries # of the IATA's data after 1990. Except where otherwise noted, @@ -2734,15 +2739,15 @@ Zone America/Barbados -3:58:29 - LMT 1924 # Bridgetown # Belize # Whitman entirely disagrees with Shanks; go with Shanks & Pottenger. # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S -Rule Belize 1918 1942 - Oct Sun>=2 0:00 0:30 HD -Rule Belize 1919 1943 - Feb Sun>=9 0:00 0 S -Rule Belize 1973 only - Dec 5 0:00 1:00 D -Rule Belize 1974 only - Feb 9 0:00 0 S -Rule Belize 1982 only - Dec 18 0:00 1:00 D -Rule Belize 1983 only - Feb 12 0:00 0 S +Rule Belize 1918 1942 - Oct Sun>=2 0:00 0:30 -0530 +Rule Belize 1919 1943 - Feb Sun>=9 0:00 0 CST +Rule Belize 1973 only - Dec 5 0:00 1:00 CDT +Rule Belize 1974 only - Feb 9 0:00 0 CST +Rule Belize 1982 only - Dec 18 0:00 1:00 CDT +Rule Belize 1983 only - Feb 12 0:00 0 CST # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Belize -5:52:48 - LMT 1912 Apr - -6:00 Belize C%sT + -6:00 Belize %s # Bermuda @@ -3014,16 +3019,16 @@ Zone America/Havana -5:29:28 - LMT 1890 # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S -Rule DR 1966 only - Oct 30 0:00 1:00 D -Rule DR 1967 only - Feb 28 0:00 0 S -Rule DR 1969 1973 - Oct lastSun 0:00 0:30 HD -Rule DR 1970 only - Feb 21 0:00 0 S -Rule DR 1971 only - Jan 20 0:00 0 S -Rule DR 1972 1974 - Jan 21 0:00 0 S +Rule DR 1966 only - Oct 30 0:00 1:00 EDT +Rule DR 1967 only - Feb 28 0:00 0 EST +Rule DR 1969 1973 - Oct lastSun 0:00 0:30 -0430 +Rule DR 1970 only - Feb 21 0:00 0 EST +Rule DR 1971 only - Jan 20 0:00 0 EST +Rule DR 1972 1974 - Jan 21 0:00 0 EST # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Santo_Domingo -4:39:36 - LMT 1890 -4:40 - SDMT 1933 Apr 1 12:00 # S. Dom. MT - -5:00 DR E%sT 1974 Oct 27 + -5:00 DR %s 1974 Oct 27 -4:00 - AST 2000 Oct 29 2:00 -5:00 US E%sT 2000 Dec 3 1:00 -4:00 - AST @@ -3134,6 +3139,12 @@ Zone America/Guatemala -6:02:04 - LMT 1918 Oct 5 # http://www.vantbefinfo.com/changement-dheure-pas-pour-haiti/ # http://news.anmwe.com/haiti-lheure-nationale-ne-sera-ni-avancee-ni-reculee-cette-annee/ +# From Steffen Thorsen (2017-03-12): +# We have received 4 mails from different people telling that Haiti +# has started DST again today, and this source seems to confirm that, +# I have not been able to find a more authoritative source: +# https://www.haitilibre.com/en/news-20319-haiti-notices-time-change-in-haiti.html + # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S Rule Haiti 1983 only - May 8 0:00 1:00 D Rule Haiti 1984 1987 - Apr lastSun 0:00 1:00 D @@ -3146,6 +3157,8 @@ Rule Haiti 2005 2006 - Apr Sun>=1 0:00 1:00 D Rule Haiti 2005 2006 - Oct lastSun 0:00 0 S Rule Haiti 2012 2015 - Mar Sun>=8 2:00 1:00 D Rule Haiti 2012 2015 - Nov Sun>=1 2:00 0 S +Rule Haiti 2017 max - Mar Sun>=8 2:00 1:00 D +Rule Haiti 2017 max - Nov Sun>=1 2:00 0 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Port-au-Prince -4:49:20 - LMT 1890 -4:49 - PPMT 1917 Jan 24 12:00 # P-a-P MT @@ -3313,8 +3326,8 @@ Zone America/Puerto_Rico -4:24:25 - LMT 1899 Mar 28 12:00 # San Juan # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Miquelon -3:44:40 - LMT 1911 May 15 # St Pierre -4:00 - AST 1980 May - -3:00 - PMST 1987 # Pierre & Miquelon Time - -3:00 Canada PM%sT + -3:00 - -03 1987 + -3:00 Canada -03/-02 # St Vincent and the Grenadines # See America/Port_of_Spain. diff --git a/src/timezone/data/southamerica b/src/timezone/data/southamerica index 532145172f..6038c3b65c 100644 --- a/src/timezone/data/southamerica +++ b/src/timezone/data/southamerica @@ -6,15 +6,15 @@ # tz@iana.org for general use in the future). For more, please see # the file CONTRIBUTING in the tz distribution. -# From Paul Eggert (2014-10-31): +# From Paul Eggert (2016-12-05): # # Unless otherwise specified, the source for data through 1990 is: # Thomas G. Shanks and Rique Pottenger, The International Atlas (6th edition), # San Diego: ACS Publications, Inc. (2003). # Unfortunately this book contains many errors and cites no sources. # -# Gwillim Law writes that a good source -# for recent time zone data is the International Air Transport +# Many years ago Gwillim Law wrote that a good source +# for time zone data was the International Air Transport # Association's Standard Schedules Information Manual (IATA SSIM), # published semiannually. Law sent in several helpful summaries # of the IATA's data after 1990. Except where otherwise noted, @@ -24,32 +24,10 @@ # Milne J. Civil time. Geogr J. 1899 Feb;13(2):173-94. # http://www.jstor.org/stable/1774359 # -# Earlier editions of these tables used the North American style (e.g. ARST and -# ARDT for Argentine Standard and Daylight Time), but the following quote -# suggests that it's better to use European style (e.g. ART and ARST). -# I suggest the use of _Summer time_ instead of the more cumbersome -# _daylight-saving time_. _Summer time_ seems to be in general use -# in Europe and South America. -# -- E O Cutler, _New York Times_ (1937-02-14), quoted in -# H L Mencken, _The American Language: Supplement I_ (1960), p 466 -# -# Earlier editions of these tables also used the North American style -# for time zones in Brazil, but this was incorrect, as Brazilians say -# "summer time". Reinaldo Goulart, a São Paulo businessman active in -# the railroad sector, writes (1999-07-06): -# The subject of time zones is currently a matter of discussion/debate in -# Brazil. Let's say that "the Brasília time" is considered the -# "official time" because Brasília is the capital city. -# The other three time zones are called "Brasília time "minus one" or -# "plus one" or "plus two". As far as I know there is no such -# name/designation as "Eastern Time" or "Central Time". -# So I invented the following (English-language) abbreviations for now. -# Corrections are welcome! -# std dst -# -2:00 FNT FNST Fernando de Noronha -# -3:00 BRT BRST Brasília -# -4:00 AMT AMST Amazon -# -5:00 ACT ACST Acre +# These tables use numeric abbreviations like -03 and -0330 for +# integer hour and minute UTC offsets. Although earlier editions used +# alphabetic time zone abbreviations, these abbreviations were +# invented and did not reflect common practice. ############################################################################### @@ -384,12 +362,6 @@ Rule Arg 2008 only - Oct Sun>=15 0:00 1:00 S # # So I guess a new set of rules, besides "Arg", must be made and the last # America/Argentina/San_Luis entries should change to use these... -# -# I'm enclosing a patch that does what I say... regretfully, the San Luis -# timezone must be called "WART/WARST" even when most of the time (like, -# right now) WARST == ART... that is, since last Sunday, all the country -# is using UTC-3, but in my patch, San Luis calls it "WARST" and the rest -# of the country calls it "ART". # ... # From Alexander Krivenyshev (2010-04-09): @@ -428,11 +400,11 @@ Rule Arg 2008 only - Oct Sun>=15 0:00 1:00 S # Buenos Aires (BA), Capital Federal (CF), Zone America/Argentina/Buenos_Aires -3:53:48 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May # Córdoba Mean Time - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 Arg AR%sT + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 Arg -03/-02 # # Córdoba (CB), Santa Fe (SF), Entre Ríos (ER), Corrientes (CN), Misiones (MN), # Chaco (CC), Formosa (FM), Santiago del Estero (SE) @@ -446,113 +418,113 @@ Zone America/Argentina/Buenos_Aires -3:53:48 - LMT 1894 Oct 31 # Zone America/Argentina/Cordoba -4:16:48 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Mar 3 - -4:00 - WART 1991 Oct 20 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 Arg AR%sT + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Mar 3 + -4:00 - -04 1991 Oct 20 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 Arg -03/-02 # # Salta (SA), La Pampa (LP), Neuquén (NQ), Rio Negro (RN) Zone America/Argentina/Salta -4:21:40 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Mar 3 - -4:00 - WART 1991 Oct 20 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Mar 3 + -4:00 - -04 1991 Oct 20 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # # Tucumán (TM) Zone America/Argentina/Tucuman -4:20:52 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Mar 3 - -4:00 - WART 1991 Oct 20 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 Jun 1 - -4:00 - WART 2004 Jun 13 - -3:00 Arg AR%sT + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Mar 3 + -4:00 - -04 1991 Oct 20 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 Jun 1 + -4:00 - -04 2004 Jun 13 + -3:00 Arg -03/-02 # # La Rioja (LR) Zone America/Argentina/La_Rioja -4:27:24 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Mar 1 - -4:00 - WART 1991 May 7 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 Jun 1 - -4:00 - WART 2004 Jun 20 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Mar 1 + -4:00 - -04 1991 May 7 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 Jun 1 + -4:00 - -04 2004 Jun 20 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # # San Juan (SJ) Zone America/Argentina/San_Juan -4:34:04 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Mar 1 - -4:00 - WART 1991 May 7 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 May 31 - -4:00 - WART 2004 Jul 25 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Mar 1 + -4:00 - -04 1991 May 7 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 May 31 + -4:00 - -04 2004 Jul 25 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # # Jujuy (JY) Zone America/Argentina/Jujuy -4:21:12 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1990 Mar 4 - -4:00 - WART 1990 Oct 28 - -4:00 1:00 WARST 1991 Mar 17 - -4:00 - WART 1991 Oct 6 - -3:00 1:00 ARST 1992 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1990 Mar 4 + -4:00 - -04 1990 Oct 28 + -4:00 1:00 -03 1991 Mar 17 + -4:00 - -04 1991 Oct 6 + -3:00 1:00 -02 1992 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # # Catamarca (CT), Chubut (CH) Zone America/Argentina/Catamarca -4:23:08 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1991 Mar 3 - -4:00 - WART 1991 Oct 20 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 Jun 1 - -4:00 - WART 2004 Jun 20 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1991 Mar 3 + -4:00 - -04 1991 Oct 20 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 Jun 1 + -4:00 - -04 2004 Jun 20 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # # Mendoza (MZ) Zone America/Argentina/Mendoza -4:35:16 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1990 Mar 4 - -4:00 - WART 1990 Oct 15 - -4:00 1:00 WARST 1991 Mar 1 - -4:00 - WART 1991 Oct 15 - -4:00 1:00 WARST 1992 Mar 1 - -4:00 - WART 1992 Oct 18 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 May 23 - -4:00 - WART 2004 Sep 26 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1990 Mar 4 + -4:00 - -04 1990 Oct 15 + -4:00 1:00 -03 1991 Mar 1 + -4:00 - -04 1991 Oct 15 + -4:00 1:00 -03 1992 Mar 1 + -4:00 - -04 1992 Oct 18 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 May 23 + -4:00 - -04 2004 Sep 26 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # # San Luis (SL) @@ -561,44 +533,44 @@ Rule SanLuis 2007 2008 - Oct Sun>=8 0:00 1:00 S Zone America/Argentina/San_Luis -4:25:24 - LMT 1894 Oct 31 -4:16:48 - CMT 1920 May - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1990 - -3:00 1:00 ARST 1990 Mar 14 - -4:00 - WART 1990 Oct 15 - -4:00 1:00 WARST 1991 Mar 1 - -4:00 - WART 1991 Jun 1 - -3:00 - ART 1999 Oct 3 - -4:00 1:00 WARST 2000 Mar 3 - -3:00 - ART 2004 May 31 - -4:00 - WART 2004 Jul 25 - -3:00 Arg AR%sT 2008 Jan 21 - -4:00 SanLuis WAR%sT 2009 Oct 11 - -3:00 - ART + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1990 + -3:00 1:00 -02 1990 Mar 14 + -4:00 - -04 1990 Oct 15 + -4:00 1:00 -03 1991 Mar 1 + -4:00 - -04 1991 Jun 1 + -3:00 - -03 1999 Oct 3 + -4:00 1:00 -03 2000 Mar 3 + -3:00 - -03 2004 May 31 + -4:00 - -04 2004 Jul 25 + -3:00 Arg -03/-02 2008 Jan 21 + -4:00 SanLuis -04/-03 2009 Oct 11 + -3:00 - -03 # # Santa Cruz (SC) Zone America/Argentina/Rio_Gallegos -4:36:52 - LMT 1894 Oct 31 - -4:16:48 - CMT 1920 May # Córdoba Mean Time - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 Jun 1 - -4:00 - WART 2004 Jun 20 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:16:48 - CMT 1920 May + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 Jun 1 + -4:00 - -04 2004 Jun 20 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # # Tierra del Fuego, Antártida e Islas del Atlántico Sur (TF) Zone America/Argentina/Ushuaia -4:33:12 - LMT 1894 Oct 31 - -4:16:48 - CMT 1920 May # Córdoba Mean Time - -4:00 - ART 1930 Dec - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1999 Oct 3 - -4:00 Arg AR%sT 2000 Mar 3 - -3:00 - ART 2004 May 30 - -4:00 - WART 2004 Jun 20 - -3:00 Arg AR%sT 2008 Oct 18 - -3:00 - ART + -4:16:48 - CMT 1920 May + -4:00 - -04 1930 Dec + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1999 Oct 3 + -4:00 Arg -04/-03 2000 Mar 3 + -3:00 - -03 2004 May 30 + -4:00 - -04 2004 Jun 20 + -3:00 Arg -03/-02 2008 Oct 18 + -3:00 - -03 # Aruba Link America/Curacao America/Aruba @@ -608,7 +580,7 @@ Link America/Curacao America/Aruba Zone America/La_Paz -4:32:36 - LMT 1890 -4:32:36 - CMT 1931 Oct 15 # Calamarca MT -4:32:36 1:00 BOST 1932 Mar 21 # Bolivia ST - -4:00 - BOT # Bolivia Time + -4:00 - -04 # Brazil @@ -960,12 +932,12 @@ Rule Brazil 2038 max - Feb Sun>=15 0:00 0 - # # Fernando de Noronha (administratively part of PE) Zone America/Noronha -2:09:40 - LMT 1914 - -2:00 Brazil FN%sT 1990 Sep 17 - -2:00 - FNT 1999 Sep 30 - -2:00 Brazil FN%sT 2000 Oct 15 - -2:00 - FNT 2001 Sep 13 - -2:00 Brazil FN%sT 2002 Oct 1 - -2:00 - FNT + -2:00 Brazil -02/-01 1990 Sep 17 + -2:00 - -02 1999 Sep 30 + -2:00 Brazil -02/-01 2000 Oct 15 + -2:00 - -02 2001 Sep 13 + -2:00 Brazil -02/-01 2002 Oct 1 + -2:00 - -02 # Other Atlantic islands have no permanent settlement. # These include Trindade and Martim Vaz (administratively part of ES), # Rocas Atoll (RN), and the St Peter and St Paul Archipelago (PE). @@ -978,119 +950,119 @@ Zone America/Noronha -2:09:40 - LMT 1914 # In the north a very small part from the river Javary (now Jari I guess, # the border with Amapá) to the Amazon, then to the Xingu. Zone America/Belem -3:13:56 - LMT 1914 - -3:00 Brazil BR%sT 1988 Sep 12 - -3:00 - BRT + -3:00 Brazil -03/-02 1988 Sep 12 + -3:00 - -03 # # west Pará (PA) # West Pará includes Altamira, Óbidos, Prainha, Oriximiná, and Santarém. Zone America/Santarem -3:38:48 - LMT 1914 - -4:00 Brazil AM%sT 1988 Sep 12 - -4:00 - AMT 2008 Jun 24 0:00 - -3:00 - BRT + -4:00 Brazil -04/-03 1988 Sep 12 + -4:00 - -04 2008 Jun 24 0:00 + -3:00 - -03 # # Maranhão (MA), Piauí (PI), Ceará (CE), Rio Grande do Norte (RN), # Paraíba (PB) Zone America/Fortaleza -2:34:00 - LMT 1914 - -3:00 Brazil BR%sT 1990 Sep 17 - -3:00 - BRT 1999 Sep 30 - -3:00 Brazil BR%sT 2000 Oct 22 - -3:00 - BRT 2001 Sep 13 - -3:00 Brazil BR%sT 2002 Oct 1 - -3:00 - BRT + -3:00 Brazil -03/-02 1990 Sep 17 + -3:00 - -03 1999 Sep 30 + -3:00 Brazil -03/-02 2000 Oct 22 + -3:00 - -03 2001 Sep 13 + -3:00 Brazil -03/-02 2002 Oct 1 + -3:00 - -03 # # Pernambuco (PE) (except Atlantic islands) Zone America/Recife -2:19:36 - LMT 1914 - -3:00 Brazil BR%sT 1990 Sep 17 - -3:00 - BRT 1999 Sep 30 - -3:00 Brazil BR%sT 2000 Oct 15 - -3:00 - BRT 2001 Sep 13 - -3:00 Brazil BR%sT 2002 Oct 1 - -3:00 - BRT + -3:00 Brazil -03/-02 1990 Sep 17 + -3:00 - -03 1999 Sep 30 + -3:00 Brazil -03/-02 2000 Oct 15 + -3:00 - -03 2001 Sep 13 + -3:00 Brazil -03/-02 2002 Oct 1 + -3:00 - -03 # # Tocantins (TO) Zone America/Araguaina -3:12:48 - LMT 1914 - -3:00 Brazil BR%sT 1990 Sep 17 - -3:00 - BRT 1995 Sep 14 - -3:00 Brazil BR%sT 2003 Sep 24 - -3:00 - BRT 2012 Oct 21 - -3:00 Brazil BR%sT 2013 Sep - -3:00 - BRT + -3:00 Brazil -03/-02 1990 Sep 17 + -3:00 - -03 1995 Sep 14 + -3:00 Brazil -03/-02 2003 Sep 24 + -3:00 - -03 2012 Oct 21 + -3:00 Brazil -03/-02 2013 Sep + -3:00 - -03 # # Alagoas (AL), Sergipe (SE) Zone America/Maceio -2:22:52 - LMT 1914 - -3:00 Brazil BR%sT 1990 Sep 17 - -3:00 - BRT 1995 Oct 13 - -3:00 Brazil BR%sT 1996 Sep 4 - -3:00 - BRT 1999 Sep 30 - -3:00 Brazil BR%sT 2000 Oct 22 - -3:00 - BRT 2001 Sep 13 - -3:00 Brazil BR%sT 2002 Oct 1 - -3:00 - BRT + -3:00 Brazil -03/-02 1990 Sep 17 + -3:00 - -03 1995 Oct 13 + -3:00 Brazil -03/-02 1996 Sep 4 + -3:00 - -03 1999 Sep 30 + -3:00 Brazil -03/-02 2000 Oct 22 + -3:00 - -03 2001 Sep 13 + -3:00 Brazil -03/-02 2002 Oct 1 + -3:00 - -03 # # Bahia (BA) # There are too many Salvadors elsewhere, so use America/Bahia instead # of America/Salvador. Zone America/Bahia -2:34:04 - LMT 1914 - -3:00 Brazil BR%sT 2003 Sep 24 - -3:00 - BRT 2011 Oct 16 - -3:00 Brazil BR%sT 2012 Oct 21 - -3:00 - BRT + -3:00 Brazil -03/-02 2003 Sep 24 + -3:00 - -03 2011 Oct 16 + -3:00 Brazil -03/-02 2012 Oct 21 + -3:00 - -03 # # Goiás (GO), Distrito Federal (DF), Minas Gerais (MG), # Espírito Santo (ES), Rio de Janeiro (RJ), São Paulo (SP), Paraná (PR), # Santa Catarina (SC), Rio Grande do Sul (RS) Zone America/Sao_Paulo -3:06:28 - LMT 1914 - -3:00 Brazil BR%sT 1963 Oct 23 0:00 - -3:00 1:00 BRST 1964 - -3:00 Brazil BR%sT + -3:00 Brazil -03/-02 1963 Oct 23 0:00 + -3:00 1:00 -02 1964 + -3:00 Brazil -03/-02 # # Mato Grosso do Sul (MS) Zone America/Campo_Grande -3:38:28 - LMT 1914 - -4:00 Brazil AM%sT + -4:00 Brazil -04/-03 # # Mato Grosso (MT) Zone America/Cuiaba -3:44:20 - LMT 1914 - -4:00 Brazil AM%sT 2003 Sep 24 - -4:00 - AMT 2004 Oct 1 - -4:00 Brazil AM%sT + -4:00 Brazil -04/-03 2003 Sep 24 + -4:00 - -04 2004 Oct 1 + -4:00 Brazil -04/-03 # # Rondônia (RO) Zone America/Porto_Velho -4:15:36 - LMT 1914 - -4:00 Brazil AM%sT 1988 Sep 12 - -4:00 - AMT + -4:00 Brazil -04/-03 1988 Sep 12 + -4:00 - -04 # # Roraima (RR) Zone America/Boa_Vista -4:02:40 - LMT 1914 - -4:00 Brazil AM%sT 1988 Sep 12 - -4:00 - AMT 1999 Sep 30 - -4:00 Brazil AM%sT 2000 Oct 15 - -4:00 - AMT + -4:00 Brazil -04/-03 1988 Sep 12 + -4:00 - -04 1999 Sep 30 + -4:00 Brazil -04/-03 2000 Oct 15 + -4:00 - -04 # # east Amazonas (AM): Boca do Acre, Jutaí, Manaus, Floriano Peixoto # The great circle line from Tabatinga to Porto Acre divides # east from west Amazonas. Zone America/Manaus -4:00:04 - LMT 1914 - -4:00 Brazil AM%sT 1988 Sep 12 - -4:00 - AMT 1993 Sep 28 - -4:00 Brazil AM%sT 1994 Sep 22 - -4:00 - AMT + -4:00 Brazil -04/-03 1988 Sep 12 + -4:00 - -04 1993 Sep 28 + -4:00 Brazil -04/-03 1994 Sep 22 + -4:00 - -04 # # west Amazonas (AM): Atalaia do Norte, Boca do Maoco, Benjamin Constant, # Eirunepé, Envira, Ipixuna Zone America/Eirunepe -4:39:28 - LMT 1914 - -5:00 Brazil AC%sT 1988 Sep 12 - -5:00 - ACT 1993 Sep 28 - -5:00 Brazil AC%sT 1994 Sep 22 - -5:00 - ACT 2008 Jun 24 0:00 - -4:00 - AMT 2013 Nov 10 - -5:00 - ACT + -5:00 Brazil -05/-04 1988 Sep 12 + -5:00 - -05 1993 Sep 28 + -5:00 Brazil -05/-04 1994 Sep 22 + -5:00 - -05 2008 Jun 24 0:00 + -4:00 - -04 2013 Nov 10 + -5:00 - -05 # # Acre (AC) Zone America/Rio_Branco -4:31:12 - LMT 1914 - -5:00 Brazil AC%sT 1988 Sep 12 - -5:00 - ACT 2008 Jun 24 0:00 - -4:00 - AMT 2013 Nov 10 - -5:00 - ACT + -5:00 Brazil -05/-04 1988 Sep 12 + -5:00 - -05 2008 Jun 24 0:00 + -4:00 - -04 2013 Nov 10 + -5:00 - -05 # Chile @@ -1235,6 +1207,18 @@ Zone America/Rio_Branco -4:31:12 - LMT 1914 # to mean 24:00 mainland time, not 24:00 local time, so that Easter # Island is always two hours behind the mainland. +# From Juan Correa (2016-12-04): +# Magallanes region ... will keep DST (UTC -3) all year round.... +# http://www.soychile.cl/Santiago/Sociedad/2016/12/04/433428/Bachelet-firmo-el-decreto-para-establecer-un-horario-unico-para-la-Region-de-Magallanes.aspx +# +# From Deborah Goldsmith (2017-01-19): +# http://www.diariooficial.interior.gob.cl/publicaciones/2017/01/17/41660/01/1169626.pdf +# From Paul Eggert (2017-01-19): +# The above says the Magallanes change expires 2019-05-11 at 24:00, +# so in theory, they will revert to -04/-03 after that, which means +# they will switch from -03 to -04 one hour after Santiago does that day. +# For now, assume that they will not revert. + # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S Rule Chile 1927 1931 - Sep 1 0:00 1:00 S Rule Chile 1928 1932 - Apr 1 0:00 0 - @@ -1275,22 +1259,35 @@ Rule Chile 2016 max - Aug Sun>=9 4:00u 1:00 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Santiago -4:42:46 - LMT 1890 -4:42:46 - SMT 1910 Jan 10 # Santiago Mean Time - -5:00 - CLT 1916 Jul 1 # Chile Time + -5:00 - -05 1916 Jul 1 -4:42:46 - SMT 1918 Sep 10 - -4:00 - CLT 1919 Jul 1 + -4:00 - -04 1919 Jul 1 -4:42:46 - SMT 1927 Sep 1 - -5:00 Chile CL%sT 1932 Sep 1 - -4:00 - CLT 1942 Jun 1 - -5:00 - CLT 1942 Aug 1 - -4:00 - CLT 1946 Jul 15 - -4:00 1:00 CLST 1946 Sep 1 # central Chile - -4:00 - CLT 1947 Apr 1 - -5:00 - CLT 1947 May 21 23:00 - -4:00 Chile CL%sT + -5:00 Chile -05/-04 1932 Sep 1 + -4:00 - -04 1942 Jun 1 + -5:00 - -05 1942 Aug 1 + -4:00 - -04 1946 Jul 15 + -4:00 1:00 -03 1946 Sep 1 # central Chile + -4:00 - -04 1947 Apr 1 + -5:00 - -05 1947 May 21 23:00 + -4:00 Chile -04/-03 +Zone America/Punta_Arenas -4:43:40 - LMT 1890 + -4:42:46 - SMT 1910 Jan 10 + -5:00 - -05 1916 Jul 1 + -4:42:46 - SMT 1918 Sep 10 + -4:00 - -04 1919 Jul 1 + -4:42:46 - SMT 1927 Sep 1 + -5:00 Chile -05/-04 1932 Sep 1 + -4:00 - -04 1942 Jun 1 + -5:00 - -05 1942 Aug 1 + -4:00 - -04 1947 Apr 1 + -5:00 - -05 1947 May 21 23:00 + -4:00 Chile -04/-03 2016 Dec 4 + -3:00 - -03 Zone Pacific/Easter -7:17:28 - LMT 1890 -7:17:28 - EMT 1932 Sep # Easter Mean Time - -7:00 Chile EAS%sT 1982 Mar 14 3:00u # Easter Time - -6:00 Chile EAS%sT + -7:00 Chile -07/-06 1982 Mar 14 3:00u # Easter Time + -6:00 Chile -06/-05 # # Salas y Gómez Island is uninhabited. # Other Chilean locations, including Juan Fernández Is, Desventuradas Is, @@ -1310,9 +1307,10 @@ Zone Pacific/Easter -7:17:28 - LMT 1890 # # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Antarctica/Palmer 0 - -00 1965 - -4:00 Arg AR%sT 1969 Oct 5 - -3:00 Arg AR%sT 1982 May - -4:00 Chile CL%sT + -4:00 Arg -04/-03 1969 Oct 5 + -3:00 Arg -03/-02 1982 May + -4:00 Chile -04/-03 2016 Dec 4 + -3:00 - -03 # Colombia @@ -1325,7 +1323,7 @@ Rule CO 1993 only - Apr 4 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Bogota -4:56:16 - LMT 1884 Mar 13 -4:56:16 - BMT 1914 Nov 23 # Bogotá Mean Time - -5:00 CO CO%sT # Colombia Time + -5:00 CO -05/-04 # Malpelo, Providencia, San Andres # no information; probably like America/Bogota @@ -1349,7 +1347,7 @@ Zone America/Bogota -4:56:16 - LMT 1884 Mar 13 # # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Curacao -4:35:47 - LMT 1912 Feb 12 # Willemstad - -4:30 - ANT 1965 # Netherlands Antilles Time + -4:30 - -0430 1965 -4:00 - AST # From Arthur David Olson (2011-06-15): @@ -1364,19 +1362,32 @@ Link America/Curacao America/Kralendijk # Caribbean Netherlands # # Milne says the Central and South American Telegraph Company used -5:24:15. # -# From Paul Eggert (2007-03-04): -# Apparently Ecuador had a failed experiment with DST in 1992. -# (2007-02-27) and -# (2006-11-06) both -# talk about "hora Sixto". Leave this alone for now, as we have no data. +# From Alois Treindl (2016-12-15): +# http://www.elcomercio.com/actualidad/hora-sixto-1993.html +# ... Whether the law applied also to Galápagos, I do not know. +# From Paul Eggert (2016-12-15): +# http://www.elcomercio.com/afull/modificacion-husohorario-ecuador-presidentes-decreto.html +# This says President Sixto Durán Ballén signed decree No. 285, which +# established DST from 1992-11-28 to 1993-02-05; it does not give transition +# times. The people called it "hora de Sixto" ("Sixto hour"). The change did +# not go over well; a popular song "Qué hora es" by Jaime Guevara had lyrics +# that included "Amanecía en mitad de la noche, los guaguas iban a clase sin +# sol" ("It was dawning in the middle of the night, the buses went to class +# without sun"). Although Ballén's campaign slogan was "Ni un paso atrás" +# (Not one step back), the clocks went back in 1993 and the experiment was not +# repeated. For now, assume transitions were at 00:00 local time country-wide. +# +# Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S +Rule Ecuador 1992 only - Nov 28 0:00 1:00 S +Rule Ecuador 1993 only - Feb 5 0:00 0 - # # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Guayaquil -5:19:20 - LMT 1890 -5:14:00 - QMT 1931 # Quito Mean Time - -5:00 - ECT # Ecuador Time + -5:00 Ecuador -05/-04 Zone Pacific/Galapagos -5:58:24 - LMT 1931 # Puerto Baquerizo Moreno - -5:00 - ECT 1986 - -6:00 - GALT # Galápagos Time + -5:00 - -05 1986 + -6:00 Ecuador -06/-05 # Falklands @@ -1476,25 +1487,24 @@ Rule Falk 2001 2010 - Sep Sun>=1 2:00 1:00 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Atlantic/Stanley -3:51:24 - LMT 1890 -3:51:24 - SMT 1912 Mar 12 # Stanley Mean Time - -4:00 Falk FK%sT 1983 May # Falkland Is Time - -3:00 Falk FK%sT 1985 Sep 15 - -4:00 Falk FK%sT 2010 Sep 5 2:00 - -3:00 - FKST + -4:00 Falk -04/-03 1983 May + -3:00 Falk -03/-02 1985 Sep 15 + -4:00 Falk -04/-03 2010 Sep 5 2:00 + -3:00 - -03 # French Guiana # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Cayenne -3:29:20 - LMT 1911 Jul - -4:00 - GFT 1967 Oct # French Guiana Time - -3:00 - GFT + -4:00 - -04 1967 Oct + -3:00 - -03 # Guyana # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Guyana -3:52:40 - LMT 1915 Mar # Georgetown - -3:45 - GBGT 1966 May 26 # Br Guiana Time - -3:45 - GYT 1975 Jul 31 # Guyana Time - -3:00 - GYT 1991 + -3:45 - -0345 1975 Jul 31 + -3:00 - -03 1991 # IATA SSIM (1996-06) says -4:00. Assume a 1991 switch. - -4:00 - GYT + -4:00 - -04 # Paraguay # @@ -1586,9 +1596,9 @@ Rule Para 2013 max - Mar Sun>=22 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Asuncion -3:50:40 - LMT 1890 -3:50:40 - AMT 1931 Oct 10 # Asunción Mean Time - -4:00 - PYT 1972 Oct # Paraguay Time - -3:00 - PYT 1974 Apr - -4:00 Para PY%sT + -4:00 - -04 1972 Oct + -3:00 - -03 1974 Apr + -4:00 Para -04/-03 # Peru # @@ -1615,12 +1625,12 @@ Rule Peru 1994 only - Apr 1 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Lima -5:08:12 - LMT 1890 -5:08:36 - LMT 1908 Jul 28 # Lima Mean Time? - -5:00 Peru PE%sT # Peru Time + -5:00 Peru -05/-04 # South Georgia # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Atlantic/South_Georgia -2:26:08 - LMT 1890 # Grytviken - -2:00 - GST # South Georgia Time + -2:00 - -02 # South Sandwich Is # uninhabited; scientific personnel have wintered @@ -1630,9 +1640,8 @@ Zone Atlantic/South_Georgia -2:26:08 - LMT 1890 # Grytviken Zone America/Paramaribo -3:40:40 - LMT 1911 -3:40:52 - PMT 1935 # Paramaribo Mean Time -3:40:36 - PMT 1945 Oct # The capital moved? - -3:30 - NEGT 1975 Nov 20 # Dutch Guiana Time - -3:30 - SRT 1984 Oct # Suriname Time - -3:00 - SRT + -3:30 - -0330 1984 Oct + -3:00 - -03 # Trinidad and Tobago # Zone NAME GMTOFF RULES FORMAT [UNTIL] @@ -1735,11 +1744,16 @@ Rule Uruguay 2006 only - Mar 12 2:00 0 - # [dated 2015-06-29; repeals Decree 311/006 dated 2006-09-04] Rule Uruguay 2006 2014 - Oct Sun>=1 2:00 1:00 S Rule Uruguay 2007 2015 - Mar Sun>=8 2:00 0 - -# Zone NAME GMTOFF RULES FORMAT [UNTIL] + +# This Zone can be simplified once we assume zic %z. Zone America/Montevideo -3:44:44 - LMT 1898 Jun 28 -3:44:44 - MMT 1920 May 1 # Montevideo MT - -3:30 Uruguay UY%sT 1942 Dec 14 # Uruguay Time - -3:00 Uruguay UY%sT + -3:30 Uruguay -0330/-03 1942 Dec 14 + -3:00 Uruguay -03/-02 1968 + -3:00 Uruguay -03/-0230 1971 + -3:00 Uruguay -03/-02 1974 + -3:00 Uruguay -03/-0230 1974 Dec 22 + -3:00 Uruguay -03/-02 # Venezuela # @@ -1773,7 +1787,7 @@ Zone America/Montevideo -3:44:44 - LMT 1898 Jun 28 # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Caracas -4:27:44 - LMT 1890 -4:27:40 - CMT 1912 Feb 12 # Caracas Mean Time? - -4:30 - VET 1965 Jan 1 0:00 # Venezuela T. - -4:00 - VET 2007 Dec 9 3:00 - -4:30 - VET 2016 May 1 2:30 - -4:00 - VET + -4:30 - -0430 1965 Jan 1 0:00 + -4:00 - -04 2007 Dec 9 3:00 + -4:30 - -0430 2016 May 1 2:30 + -4:00 - -04 diff --git a/src/timezone/known_abbrevs.txt b/src/timezone/known_abbrevs.txt index 0935dc26e2..eb48069d87 100644 --- a/src/timezone/known_abbrevs.txt +++ b/src/timezone/known_abbrevs.txt @@ -1,186 +1,105 @@ +00 0 ++00 0 D +01 3600 +02 7200 +02 7200 D +03 10800 ++0330 12600 +04 14400 ++0430 16200 ++0430 16200 D +05 18000 +0530 19800 ++0545 20700 +06 21600 ++0630 23400 +07 25200 +08 28800 ++0845 31500 +09 32400 +10 36000 ++1030 37800 +11 39600 ++11 39600 D +12 43200 ++1245 45900 +13 46800 ++13 46800 D ++1345 49500 D +14 50400 +14 50400 D -00 0 -01 -3600 -02 -7200 +-02 -7200 D -03 -10800 +-03 -10800 D -04 -14400 -05 -18000 +-05 -18000 D -06 -21600 -07 -25200 -08 -28800 -09 -32400 +-0930 -34200 -10 -36000 -11 -39600 -12 -43200 ACDT 37800 D ACST 34200 -ACT -18000 -ACWST 31500 ADT -10800 D AEDT 39600 D AEST 36000 -AFT 16200 AKDT -28800 D AKST -32400 -AMST -10800 D -AMT -14400 -ART -10800 AST -14400 -AST 10800 AWST 28800 -AZOST 0 D -AZOT -3600 -BDT 21600 -BNT 28800 -BOT -14400 -BRST -7200 D -BRT -10800 BST 3600 D -BST 39600 -BTT 21600 CAT 7200 -CCT 23400 CDT -14400 D CDT -18000 D CEST 7200 D CET 3600 -CHADT 49500 D -CHAST 45900 -CHOST 32400 D -CHOT 28800 -CHUT 36000 -CKT -36000 -CLST -10800 D -CLT -14400 -COT -18000 CST -18000 CST -21600 CST 28800 -CVT -3600 -CXT 25200 ChST 36000 -EASST -18000 D -EAST -21600 EAT 10800 -ECT -18000 EDT -14400 D EEST 10800 D EET 7200 -EGST 0 D -EGT -3600 EST -18000 -FJST 46800 D -FJT 43200 -FKST -10800 -FNT -7200 -GALT -21600 -GAMT -32400 -GFT -10800 -GILT 43200 GMT 0 -GST -7200 -GST 14400 -GYT -14400 HDT -32400 D HKT 28800 -HOVST 28800 D -HOVT 25200 HST -36000 -ICT 25200 IDT 10800 D -IOT 21600 -IRDT 16200 D -IRST 12600 IST 19800 IST 3600 D IST 7200 JST 32400 -KOST 39600 KST 30600 KST 32400 -LHDT 39600 D -LHST 37800 -LINT 50400 -MART -34200 MDT -21600 D MEST 7200 D MET 3600 -MHT 43200 -MIST 39600 -MMT 23400 MSK 10800 MST -25200 -MUT 14400 -MVT 18000 -MYT 28800 -NCT 39600 NDT -9000 D -NFT 39600 -NPT 20700 -NRT 43200 NST -12600 -NUT -39600 NZDT 46800 D NZST 43200 PDT -25200 D -PET -18000 -PGT 36000 -PHOT 46800 -PHT 28800 PKT 18000 -PMDT -7200 D -PMST -10800 -PONT 39600 PST -28800 -PWT 32400 -PYST -10800 D -PYT -14400 -RET 14400 SAST 7200 -SBT 39600 -SCT 14400 -SGT 28800 -SRT -10800 SST -39600 -TAHT -36000 -TKT 46800 -TLT 32400 -TVT 43200 UCT 0 -ULAST 32400 D -ULAT 28800 UTC 0 -UYT -10800 -VET -14400 -VUT 39600 -WAKT 43200 WAST 7200 D WAT 3600 WEST 3600 D WET 0 -WFT 43200 -WGST -7200 D -WGT -10800 WIB 25200 WIT 32400 WITA 28800 -WSDT 50400 D -WSST 46800 -XJT 21600 diff --git a/src/timezone/tznames/America.txt b/src/timezone/tznames/America.txt index f00834e987..1c5eb1f8c5 100644 --- a/src/timezone/tznames/America.txt +++ b/src/timezone/tznames/America.txt @@ -9,9 +9,7 @@ # Acre time is sometimes called Acre Standard Time (AST) which leads to a # conflict with AST (see below at AST) -ACT -18000 # Acre Time - # (America/Eirunepe) - # (America/Rio_Branco) +ACT -18000 # Acre Time (obsolete) # CONFLICT! ACST is not unique # Other timezones: # - ACST: Australian Central Standard Time @@ -35,30 +33,13 @@ AKST -32400 # Alaska Standard Time # CONFLICT! AMST is not unique # Other timezones: # - AMST: Armenia Summer Time (Asia) -AMST -10800 D # Amazon Summer Time - # (America/Campo_Grande) - # (America/Cuiaba) +AMST -10800 D # Amazon Summer Time (obsolete) # CONFLICT! AMT is not unique # Other timezones: # - AMT: Armenia Time (Asia) -AMT -14400 # Amazon Time - # (America/Boa_Vista) - # (America/Campo_Grande) - # (America/Cuiaba) - # (America/Manaus) - # (America/Porto_Velho) -ART America/Argentina/Buenos_Aires # Argentina Time - # (America/Argentina/Buenos_Aires) - # (America/Argentina/Cordoba) - # (America/Argentina/Tucuman) - # (America/Argentina/La_Rioja) - # (America/Argentina/San_Juan) - # (America/Argentina/Jujuy) - # (America/Argentina/Catamarca) - # (America/Argentina/Mendoza) - # (America/Argentina/Rio_Gallegos) - # (America/Argentina/Ushuaia) -ARST America/Argentina/Buenos_Aires # Argentina Summer Time +AMT -14400 # Amazon Time (obsolete) +ART America/Argentina/Buenos_Aires # Argentina Time (obsolete) +ARST America/Argentina/Buenos_Aires # Argentina Summer Time (obsolete) # CONFLICT! AST is not unique # Other timezones: # - AST: Arabic Standard Time (Asia) @@ -90,19 +71,10 @@ AST -14400 # Atlantic Standard Time # (America/Thule) # (America/Tortola) # (Atlantic/Bermuda) -BOT -14400 # Bolivia Time - # (America/La_Paz) +BOT -14400 # Bolivia Time (obsolete) BRA -10800 # Brazil Time (not in IANA database) -BRST -7200 D # Brasil Summer Time - # (America/Sao_Paulo) -BRT -10800 # Brasil Time - # (America/Araguaina) - # (America/Bahia) - # (America/Belem) - # (America/Fortaleza) - # (America/Maceio) - # (America/Recife) - # (America/Sao_Paulo) +BRST -7200 D # Brasil Summer Time (obsolete) +BRT -10800 # Brasil Time (obsolete) # CONFLICT! CDT is not unique # Other timezones: # - CDT: Central Daylight Time (America) @@ -125,13 +97,9 @@ CDT -18000 D # Central Daylight Time # (America/Rainy_River) # (America/Rankin_Inlet) # (America/Winnipeg) -CLST -10800 D # Chile Summer Time - # (America/Santiago) - # (Antarctica/Palmer) -CLT America/Santiago # Chile Time - # (America/Santiago) - # (Antarctica/Palmer) -COT -18000 # Columbia Time (not in IANA database) +CLST -10800 D # Chile Summer Time (obsolete) +CLT America/Santiago # Chile Time (obsolete) +COT -18000 # Columbia Time (obsolete) # CONFLICT! CST is not unique # Other timezones: # - CST: Central Standard Time (Australia) @@ -156,9 +124,7 @@ CST -21600 # Central Standard Time (America) # (America/Regina) # (America/Swift_Current) # (America/Winnipeg) -ECT -18000 # Ecuador Time - # Eastern Caribbean Time - # (America/Guayaquil) +ECT -18000 # Ecuador Time (obsolete) EDT -14400 D # Eastern Daylight Saving Time # (America/Detroit) # (America/Grand_Turk) @@ -176,10 +142,8 @@ EDT -14400 D # Eastern Daylight Saving Time # (America/Pangnirtung) # (America/Thunder_Bay) # (America/Toronto) -EGST 0 D # East Greenland Summer Time - # (America/Scoresbysund) -EGT -3600 # East Greenland Time (Svalbard & Jan Mayen) - # (America/Scoresbysund) +EGST 0 D # East Greenland Summer Time (obsolete) +EGT -3600 # East Greenland Time (Svalbard & Jan Mayen) (obsolete) # CONFLICT! EST is not unique # Other timezones: # - EST: Eastern Standard Time (Australia) @@ -205,12 +169,9 @@ EST -18000 # Eastern Standard Time (America) # (America/Pangnirtung) # (America/Thunder_Bay) # (America/Toronto) -FNT -7200 # Fernando de Noronha Time - # (America/Noronha) -FNST -3600 D # Fernando de Noronha Summer Time (not in IANA database) - # (America/Noronha) -GFT -10800 # French Guiana Time - # (America/Cayenne) +FNT -7200 # Fernando de Noronha Time (obsolete) +FNST -3600 D # Fernando de Noronha Summer Time (obsolete) +GFT -10800 # French Guiana Time (obsolete) GMT 0 # Greenwich Mean Time # (Africa/Abidjan) # (Africa/Bamako) @@ -229,8 +190,7 @@ GMT 0 # Greenwich Mean Time # (Etc/GMT) # (Europe/Dublin) # (Europe/London) -GYT America/Guyana # Guyana Time - # (America/Guyana) +GYT America/Guyana # Guyana Time (obsolete) HADT -32400 D # Hawaii-Aleutian Daylight Time (obsolete abbreviation) # (America/Adak) HAST -36000 # Hawaii-Aleutian Standard Time (obsolete abbreviation) @@ -274,11 +234,9 @@ PDT -25200 D # Pacific Daylight Time # (America/Tijuana) # (America/Vancouver) # (America/Whitehorse) -PET -18000 # Peru Time (not in IANA database) -PMDT -7200 D # Pierre & Miquelon Daylight Time - # (America/Miquelon) -PMST -10800 # Pierre & Miquelon Standard Time - # (America/Miquelon) +PET -18000 # Peru Time (obsolete) +PMDT -7200 D # Pierre & Miquelon Daylight Time (obsolete) +PMST -10800 # Pierre & Miquelon Standard Time (obsolete) PST -28800 # Pacific Standard Time # (America/Dawson) # (America/Los_Angeles) @@ -286,19 +244,11 @@ PST -28800 # Pacific Standard Time # (America/Vancouver) # (America/Whitehorse) # (Pacific/Pitcairn) -PYST -10800 D # Paraguay Summer Time - # (America/Asuncion) -PYT America/Asuncion # Paraguay Time - # (America/Asuncion) -SRT America/Paramaribo # Suriname Time - # (America/Paramaribo) +PYST -10800 D # Paraguay Summer Time (obsolete) +PYT America/Asuncion # Paraguay Time (obsolete) +SRT America/Paramaribo # Suriname Time (obsolete) UYST -7200 D # Uruguay Summer Time (obsolete) - # (America/Montevideo) -UYT -10800 # Uruguay Time - # (America/Montevideo) -VET America/Caracas # Venezuela Time - # (America/Caracas) -WGST -7200 D # Western Greenland Summer Time - # (America/Godthab) -WGT -10800 # West Greenland Time - # (America/Godthab) +UYT -10800 # Uruguay Time (obsolete) +VET America/Caracas # Venezuela Time (obsolete) +WGST -7200 D # Western Greenland Summer Time (obsolete) +WGT -10800 # West Greenland Time (obsolete) diff --git a/src/timezone/tznames/Antarctica.txt b/src/timezone/tznames/Antarctica.txt index 1a0729dcbb..709f6c023b 100644 --- a/src/timezone/tznames/Antarctica.txt +++ b/src/timezone/tznames/Antarctica.txt @@ -10,17 +10,12 @@ AWST 28800 # Australian Western Standard Time # (Antarctica/Casey) # (Australia/Perth) -CLST -10800 D # Chile Summer Time - # (America/Santiago) - # (Antarctica/Palmer) -CLT America/Santiago # Chile Time - # (America/Santiago) - # (Antarctica/Palmer) +CLST -10800 D # Chile Summer Time (obsolete) +CLT America/Santiago # Chile Time (obsolete) DAVT Antarctica/Davis # Davis Time (Antarctica) (obsolete) DDUT 36000 # Dumont-d`Urville Time (Antarctica) (obsolete) MAWT Antarctica/Mawson # Mawson Time (Antarctica) (obsolete) -MIST 39600 # Macquarie Island Time - # (Antarctica/Macquarie) +MIST 39600 # Macquarie Island Time (obsolete) NZDT 46800 D # New Zealand Daylight Time # (Antarctica/McMurdo) # (Pacific/Auckland) diff --git a/src/timezone/tznames/Asia.txt b/src/timezone/tznames/Asia.txt index c834b6f1e4..4e365b0028 100644 --- a/src/timezone/tznames/Asia.txt +++ b/src/timezone/tznames/Asia.txt @@ -7,15 +7,13 @@ # src/timezone/tznames/Asia.txt # -AFT 16200 # Afghanistan Time - # (Asia/Kabul) +AFT 16200 # Afghanistan Time (obsolete) ALMST 25200 D # Alma-Ata Summer Time (obsolete) ALMT 21600 # Alma-Ata Time (obsolete) # CONFLICT! AMST is not unique # Other timezones: # - AMST: Amazon Summer Time (America) -AMST Asia/Yerevan # Armenia Summer Time - # (Asia/Yerevan) +AMST Asia/Yerevan # Armenia Summer Time (obsolete) # CONFLICT! AMT is not unique # Other timezones: # - AMT: Amazon Time (America) @@ -32,27 +30,16 @@ AQTT Asia/Aqtau # Aqtau Time (obsolete) # - AST: Antigua Standard Time (America) same offset as Atlantic Standard Time # - AST: Antilles Standard Time (America) same offset as Atlantic Standard Time # - AST: Al Manamah Standard Time (Asia) same offset as Arabia Standard Time -AST 10800 # Arabia Standard Time - # (Asia/Aden) - # (Asia/Baghdad) - # (Asia/Bahrain) - # (Asia/Kuwait) - # (Asia/Qatar) - # (Asia/Riyadh) +AST 10800 # Arabia Standard Time (obsolete) AZST Asia/Baku # Azerbaijan Summer Time (obsolete) AZT Asia/Baku # Azerbaijan Time (obsolete) -BDT 21600 # Bangladesh Time - # (Asia/Dhaka) -BNT 28800 # Brunei Darussalam Time - # (Asia/Brunei) +BDT 21600 # Bangladesh Time (obsolete) +BNT 28800 # Brunei Darussalam Time (obsolete) BORT 28800 # Borneo Time (Indonesia) (not in IANA database) -BTT 21600 # Bhutan Time - # (Asia/Thimphu) +BTT 21600 # Bhutan Time (obsolete) CCT 28800 # China Coastal Time (not in IANA database) -CHOST Asia/Choibalsan # Choibalsan Summer Time - # (Asia/Choibalsan) -CHOT Asia/Choibalsan # Choibalsan Time - # (Asia/Choibalsan) +CHOST Asia/Choibalsan # Choibalsan Summer Time (obsolete) +CHOT Asia/Choibalsan # Choibalsan Time (obsolete) CIT 28800 # Central Indonesia Time (obsolete, WITA is now preferred) # CONFLICT! CST is not unique # Other timezones: @@ -116,27 +103,18 @@ GET Asia/Tbilisi # Georgia Time (obsolete) # CONFLICT! GST is not unique # Other timezones: # - GST: South Georgia Time (Atlantic) -GST 14400 # Gulf Standard Time - # (Asia/Dubai) - # (Asia/Muscat) -HKT 28800 # Hong Kong Time (not in IANA database) -HOVST 28800 D # Hovd Summer Time - # (Asia/Hovd) -HOVT Asia/Hovd # Hovd Time - # (Asia/Hovd) -ICT 25200 # Indochina Time - # (Asia/Bangkok) - # (Asia/Phnom_Penh) - # (Asia/Saigon) - # (Asia/Vientiane) +GST 14400 # Gulf Standard Time (obsolete) +HKT 28800 # Hong Kong Time + # (Asia/Hong_Kong) +HOVST 28800 D # Hovd Summer Time (obsolete) +HOVT Asia/Hovd # Hovd Time (obsolete) +ICT 25200 # Indochina Time (obsolete) IDT 10800 D # Israel Daylight Time # (Asia/Jerusalem) -IRDT Asia/Tehran # Iran Daylight Time - # (Asia/Tehran) +IRDT Asia/Tehran # Iran Daylight Time (obsolete) IRKST Asia/Irkutsk # Irkutsk Summer Time (obsolete) IRKT Asia/Irkutsk # Irkutsk Time (obsolete) -IRST Asia/Tehran # Iran Standard Time - # (Asia/Tehran) +IRST Asia/Tehran # Iran Standard Time (obsolete) IRT 12600 # Iran Time (not in IANA database) # CONFLICT! IST is not unique # Other timezones: @@ -165,22 +143,17 @@ KST 32400 # Korean Standard Time LKT Asia/Colombo # Lanka Time (obsolete) MAGST Asia/Magadan # Magadan Summer Time (obsolete) MAGT Asia/Magadan # Magadan Time (obsolete) -MMT 23400 # Myanmar Time - # (Asia/Yangon) -MYT 28800 # Malaysia Time - # (Asia/Kuala_Lumpur) - # (Asia/Kuching) +MMT 23400 # Myanmar Time (obsolete) +MYT 28800 # Malaysia Time (obsolete) NOVST Asia/Novosibirsk # Novosibirsk Summer Time (obsolete) NOVT Asia/Novosibirsk # Novosibirsk Time (obsolete) -NPT 20700 # Nepal Time - # (Asia/Katmandu) +NPT 20700 # Nepal Time (obsolete) OMSST Asia/Omsk # Omsk Summer Time (obsolete) OMST Asia/Omsk # Omsk Time (obsolete) ORAT Asia/Oral # Oral Time (obsolete) PETST Asia/Kamchatka # Petropavlovsk-Kamchatski Summer Time (obsolete) PETT Asia/Kamchatka # Petropavlovsk-Kamchatski Time (obsolete) -PHT 28800 # Philippine Time - # (Asia/Manila) +PHT 28800 # Philippine Time (obsolete) PKT 18000 # Pakistan Time # (Asia/Karachi) PKST 21600 D # Pakistan Summer Time @@ -188,20 +161,14 @@ PKST 21600 D # Pakistan Summer Time QYZT 21600 # Kizilorda Time (obsolete) SAKST Asia/Sakhalin # Sakhalin Summer Time (obsolete) SAKT Asia/Sakhalin # Sakhalin Time (obsolete) -SGT Asia/Singapore # Singapore Time - # (Asia/Singapore) +SGT Asia/Singapore # Singapore Time (obsolete) SRET 39600 # Srednekolymsk Time (obsolete) TJT 18000 # Tajikistan Time (obsolete) -TLT 32400 # East Timor Time - # (Asia/Dili) +TLT 32400 # East Timor Time (obsolete) TMT Asia/Ashgabat # Turkmenistan Time (obsolete) -ULAST 32400 D # Ulan Bator Summer Time - # (Asia/Ulaanbaatar) -ULAT Asia/Ulaanbaatar # Ulan Bator Time - # (Asia/Ulaanbaatar) -UZST 21600 D # Uzbekistan Summer Time - # (Asia/Samarkand) - # (Asia/Tashkent) +ULAST 32400 D # Ulan Bator Summer Time (obsolete) +ULAT Asia/Ulaanbaatar # Ulan Bator Time (obsolete) +UZST 21600 D # Uzbekistan Summer Time (obsolete) UZT 18000 # Uzbekistan Time (obsolete) VLAST Asia/Vladivostok # Vladivostok Summer Time (obsolete) VLAT Asia/Vladivostok # Vladivostok Time (obsolete) @@ -212,8 +179,7 @@ WIT 32400 # Waktu Indonesia Timur (caution: this used to mean 25200) # (Asia/Jayapura) WITA 28800 # Waktu Indonesia Tengah # (Asia/Makassar) -XJT 21600 # Xinjiang Time - # (Asia/Urumqi) +XJT 21600 # Xinjiang Time (obsolete) YAKST Asia/Yakutsk # Yakutsk Summer Time (obsolete) YAKT Asia/Yakutsk # Yakutsk Time (obsolete) YEKST 21600 D # Yekaterinburg Summer Time (obsolete) diff --git a/src/timezone/tznames/Atlantic.txt b/src/timezone/tznames/Atlantic.txt index 1d34d1ed4b..4e036cdda5 100644 --- a/src/timezone/tznames/Atlantic.txt +++ b/src/timezone/tznames/Atlantic.txt @@ -44,14 +44,10 @@ AST -14400 # Atlantic Standard Time # (America/Thule) # (America/Tortola) # (Atlantic/Bermuda) -AZOST 0 D # Azores Summer Time - # (Atlantic/Azores) -AZOT -3600 # Azores Time - # (Atlantic/Azores) -CVT Atlantic/Cape_Verde # Cape Verde Time - # (Atlantic/Cape_Verde) -FKST Atlantic/Stanley # Falkland Islands Summer/Standard Time - # (Atlantic/Stanley) +AZOST 0 D # Azores Summer Time (obsolete) +AZOT -3600 # Azores Time (obsolete) +CVT Atlantic/Cape_Verde # Cape Verde Time (obsolete) +FKST Atlantic/Stanley # Falkland Islands Summer/Standard Time (obsolete) FKT Atlantic/Stanley # Falkland Islands Time (obsolete) GMT 0 # Greenwich Mean Time # (Africa/Abidjan) @@ -74,8 +70,7 @@ GMT 0 # Greenwich Mean Time # CONFLICT! GST is not unique # Other timezones: # - GST: Gulf Standard Time (Asia) -GST -7200 # South Georgia Time (Atlantic) - # (Atlantic/South_Georgia) +GST -7200 # South Georgia Time (Atlantic) (obsolete) WEST 3600 D # Western Europe Summer Time # (Atlantic/Canary) # (Atlantic/Faeroe) diff --git a/src/timezone/tznames/Australia.txt b/src/timezone/tznames/Australia.txt index 9751c3deb1..01629de72a 100644 --- a/src/timezone/tznames/Australia.txt +++ b/src/timezone/tznames/Australia.txt @@ -16,8 +16,7 @@ ACST 34200 # Australian Central Standard Time # (Australia/Adelaide) # (Australia/Broken_Hill) # (Australia/Darwin) -ACWST 31500 # Australian Central Western Standard Time - # (Australia/Eucla) +ACWST 31500 # Australian Central Western Standard Time (obsolete) AESST 39600 D # Australia Eastern Summer Standard Time (not in IANA database) AEDT 39600 D # Australian Eastern Daylight Time # (Australia/Brisbane) @@ -53,10 +52,8 @@ EAST 36000 # East Australian Standard Time (not in IANA database) # Other timezones: # - EST: Eastern Standard Time (America) EST 36000 # Eastern Standard Time (not in IANA database) -LHDT Australia/Lord_Howe # Lord Howe Daylight Time - # (Australia/Lord_Howe) -LHST 37800 # Lord Howe Standard Time - # (Australia/Lord_Howe) +LHDT Australia/Lord_Howe # Lord Howe Daylight Time (obsolete) +LHST 37800 # Lord Howe Standard Time (obsolete) LIGT 36000 # Melbourne, Australia (not in IANA database) NZT 43200 # New Zealand Time (not in IANA database) SADT 37800 D # South Australian Daylight-Saving Time (not in IANA database) diff --git a/src/timezone/tznames/Default b/src/timezone/tznames/Default index 591f2c4c25..80eb1b1290 100644 --- a/src/timezone/tznames/Default +++ b/src/timezone/tznames/Default @@ -41,9 +41,7 @@ WAT 3600 # West Africa Time # Acre time is sometimes called Acre Standard Time (AST) which leads to a # conflict with AST (see below at AST) -ACT -18000 # Acre Time - # (America/Eirunepe) - # (America/Rio_Branco) +ACT -18000 # Acre Time (obsolete) AKDT -28800 D # Alaska Daylight Time # (America/Anchorage) # (America/Juneau) @@ -54,32 +52,13 @@ AKST -32400 # Alaska Standard Time # (America/Juneau) # (America/Nome) # (America/Yakutat) -ART America/Argentina/Buenos_Aires # Argentina Time - # (America/Argentina/Buenos_Aires) - # (America/Argentina/Cordoba) - # (America/Argentina/Tucuman) - # (America/Argentina/La_Rioja) - # (America/Argentina/San_Juan) - # (America/Argentina/Jujuy) - # (America/Argentina/Catamarca) - # (America/Argentina/Mendoza) - # (America/Argentina/Rio_Gallegos) - # (America/Argentina/Ushuaia) -ARST America/Argentina/Buenos_Aires # Argentina Summer Time -BOT -14400 # Bolivia Time - # (America/La_Paz) +ART America/Argentina/Buenos_Aires # Argentina Time (obsolete) +ARST America/Argentina/Buenos_Aires # Argentina Summer Time (obsolete) +BOT -14400 # Bolivia Time (obsolete) BRA -10800 # Brazil Time (not in IANA database) -BRST -7200 D # Brasil Summer Time - # (America/Sao_Paulo) -BRT -10800 # Brasil Time - # (America/Araguaina) - # (America/Bahia) - # (America/Belem) - # (America/Fortaleza) - # (America/Maceio) - # (America/Recife) - # (America/Sao_Paulo) -COT -18000 # Columbia Time (not in IANA database) +BRST -7200 D # Brasil Summer Time (obsolete) +BRT -10800 # Brasil Time (obsolete) +COT -18000 # Columbia Time (obsolete) # CONFLICT! CDT is not unique # Other timezones: # - CDT: Mexico Central Daylight Time (America) @@ -95,12 +74,8 @@ CDT -18000 D # Central Daylight Time # (America/Rainy_River) # (America/Rankin_Inlet) # (America/Winnipeg) -CLST -10800 D # Chile Summer Time - # (America/Santiago) - # (Antarctica/Palmer) -CLT America/Santiago # Chile Time - # (America/Santiago) - # (Antarctica/Palmer) +CLST -10800 D # Chile Summer Time (obsolete) +CLT America/Santiago # Chile Time (obsolete) # CONFLICT! CST is not unique # Other timezones: # - CST: Central Standard Time (Australia) @@ -135,10 +110,8 @@ EDT -14400 D # Eastern Daylight Saving Time # (America/Pangnirtung) # (America/Thunder_Bay) # (America/Toronto) -EGST 0 D # East Greenland Summer Time - # (America/Scoresbysund) -EGT -3600 # East Greenland Time (Svalbard & Jan Mayen) - # (America/Scoresbysund) +EGST 0 D # East Greenland Summer Time (obsolete) +EGT -3600 # East Greenland Time (Svalbard & Jan Mayen) (obsolete) # CONFLICT! EST is not unique # Other timezones: # - EST: Eastern Standard Time (Australia) @@ -164,14 +137,10 @@ EST -18000 # Eastern Standard Time (America) # (America/Pangnirtung) # (America/Thunder_Bay) # (America/Toronto) -FNT -7200 # Fernando de Noronha Time - # (America/Noronha) -FNST -3600 D # Fernando de Noronha Summer Time (not in IANA database) - # (America/Noronha) -GFT -10800 # French Guiana Time - # (America/Cayenne) -GYT America/Guyana # Guyana Time - # (America/Guyana) +FNT -7200 # Fernando de Noronha Time (obsolete) +FNST -3600 D # Fernando de Noronha Summer Time (obsolete) +GFT -10800 # French Guiana Time (obsolete) +GYT America/Guyana # Guyana Time (obsolete) MDT -21600 D # Mexico Mountain Daylight Time # Mountain Daylight Time # (America/Boise) @@ -197,19 +166,21 @@ MST -25200 # Mexico Mountain Standard Time # (America/Yellowknife) NDT -9000 D # Newfoundland Daylight Time # (America/St_Johns) +# CONFLICT! NFT is not unique +# Other timezones: +# - NFT: Norfolk Time (Pacific) +NFT -12600 # Newfoundland Time (not in IANA database) NST -12600 # Newfoundland Standard Time # (America/St_Johns) -PET -18000 # Peru Time (not in IANA database) +PET -18000 # Peru Time (obsolete) PDT -25200 D # Pacific Daylight Time # (America/Dawson) # (America/Los_Angeles) # (America/Tijuana) # (America/Vancouver) # (America/Whitehorse) -PMDT -7200 D # Pierre & Miquelon Daylight Time - # (America/Miquelon) -PMST -10800 # Pierre & Miquelon Standard Time - # (America/Miquelon) +PMDT -7200 D # Pierre & Miquelon Daylight Time (obsolete) +PMST -10800 # Pierre & Miquelon Standard Time (obsolete) PST -28800 # Pacific Standard Time # (America/Dawson) # (America/Los_Angeles) @@ -217,20 +188,13 @@ PST -28800 # Pacific Standard Time # (America/Vancouver) # (America/Whitehorse) # (Pacific/Pitcairn) -PYST -10800 D # Paraguay Summer Time - # (America/Asuncion) -PYT America/Asuncion # Paraguay Time - # (America/Asuncion) +PYST -10800 D # Paraguay Summer Time (obsolete) +PYT America/Asuncion # Paraguay Time (obsolete) UYST -7200 D # Uruguay Summer Time (obsolete) - # (America/Montevideo) -UYT -10800 # Uruguay Time - # (America/Montevideo) -VET America/Caracas # Venezuela Time - # (America/Caracas) -WGST -7200 D # Western Greenland Summer Time - # (America/Godthab) -WGT -10800 # West Greenland Time - # (America/Godthab) +UYT -10800 # Uruguay Time (obsolete) +VET America/Caracas # Venezuela Time (obsolete) +WGST -7200 D # Western Greenland Summer Time (obsolete) +WGT -10800 # West Greenland Time (obsolete) #################### ANTARCTICA #################### @@ -240,44 +204,31 @@ MAWT Antarctica/Mawson # Mawson Time (Antarctica) (obsolete) #################### ASIA #################### -AFT 16200 # Afghanistan Time - # (Asia/Kabul) +AFT 16200 # Afghanistan Time (obsolete) ALMT 21600 # Alma-Ata Time (obsolete) ALMST 25200 D # Alma-Ata Summer Time (obsolete) # CONFLICT! AMST is not unique # Other timezones: # - AMST: Amazon Summer Time (America) -AMST Asia/Yerevan # Armenia Summer Time - # (Asia/Yerevan) +AMST Asia/Yerevan # Armenia Summer Time (obsolete) # CONFLICT! AMT is not unique # Other timezones: # - AMT: Armenia Time (Asia) -AMT -14400 # Amazon Time - # (America/Boa_Vista) - # (America/Campo_Grande) - # (America/Cuiaba) - # (America/Manaus) - # (America/Porto_Velho) +AMT -14400 # Amazon Time (obsolete) ANAST Asia/Anadyr # Anadyr Summer Time (obsolete) ANAT Asia/Anadyr # Anadyr Time (obsolete) AZST Asia/Baku # Azerbaijan Summer Time (obsolete) AZT Asia/Baku # Azerbaijan Time (obsolete) -BDT 21600 # Bangladesh Time - # (Asia/Dhaka) -BNT 28800 # Brunei Darussalam Time - # (Asia/Brunei) +BDT 21600 # Bangladesh Time (obsolete) +BNT 28800 # Brunei Darussalam Time (obsolete) BORT 28800 # Borneo Time (Indonesia) (not in IANA database) -BTT 21600 # Bhutan Time - # (Asia/Thimphu) +BTT 21600 # Bhutan Time (obsolete) CCT 28800 # China Coastal Time (not in IANA database) GEST Asia/Tbilisi # Georgia Summer Time (obsolete) GET Asia/Tbilisi # Georgia Time (obsolete) -HKT 28800 # Hong Kong Time (not in IANA database) -ICT 25200 # Indochina Time - # (Asia/Bangkok) - # (Asia/Phnom_Penh) - # (Asia/Saigon) - # (Asia/Vientiane) +HKT 28800 # Hong Kong Time + # (Asia/Hong_Kong) +ICT 25200 # Indochina Time (obsolete) IDT 10800 D # Israel Daylight Time # (Asia/Jerusalem) IRKST Asia/Irkutsk # Irkutsk Summer Time (obsolete) @@ -302,41 +253,30 @@ KST 32400 # Korean Standard Time LKT Asia/Colombo # Lanka Time (obsolete) MAGST Asia/Magadan # Magadan Summer Time (obsolete) MAGT Asia/Magadan # Magadan Time (obsolete) -MMT 23400 # Myanmar Time - # (Asia/Yangon) -MYT 28800 # Malaysia Time - # (Asia/Kuala_Lumpur) - # (Asia/Kuching) +MMT 23400 # Myanmar Time (obsolete) +MYT 28800 # Malaysia Time (obsolete) NOVST Asia/Novosibirsk # Novosibirsk Summer Time (obsolete) NOVT Asia/Novosibirsk # Novosibirsk Time (obsolete) -NPT 20700 # Nepal Time - # (Asia/Katmandu) +NPT 20700 # Nepal Time (obsolete) OMSST Asia/Omsk # Omsk Summer Time (obsolete) OMST Asia/Omsk # Omsk Time (obsolete) PETST Asia/Kamchatka # Petropavlovsk-Kamchatski Summer Time (obsolete) PETT Asia/Kamchatka # Petropavlovsk-Kamchatski Time (obsolete) -PHT 28800 # Philippine Time - # (Asia/Manila) +PHT 28800 # Philippine Time (obsolete) PKT 18000 # Pakistan Time # (Asia/Karachi) PKST 21600 D # Pakistan Summer Time # (Asia/Karachi) -SGT Asia/Singapore # Singapore Time - # (Asia/Singapore) +SGT Asia/Singapore # Singapore Time (obsolete) TJT 18000 # Tajikistan Time (obsolete) TMT Asia/Ashgabat # Turkmenistan Time (obsolete) -ULAST 32400 D # Ulan Bator Summer Time - # (Asia/Ulaanbaatar) -ULAT Asia/Ulaanbaatar # Ulan Bator Time - # (Asia/Ulaanbaatar) -UZST 21600 D # Uzbekistan Summer Time - # (Asia/Samarkand) - # (Asia/Tashkent) +ULAST 32400 D # Ulan Bator Summer Time (obsolete) +ULAT Asia/Ulaanbaatar # Ulan Bator Time (obsolete) +UZST 21600 D # Uzbekistan Summer Time (obsolete) UZT 18000 # Uzbekistan Time (obsolete) VLAST Asia/Vladivostok # Vladivostok Summer Time (obsolete) VLAT Asia/Vladivostok # Vladivostok Time (obsolete) -XJT 21600 # Xinjiang Time - # (Asia/Urumqi) +XJT 21600 # Xinjiang Time (obsolete) YAKST Asia/Yakutsk # Yakutsk Summer Time (obsolete) YAKT Asia/Yakutsk # Yakutsk Time (obsolete) YEKST 21600 D # Yekaterinburg Summer Time (obsolete) @@ -381,12 +321,9 @@ AST -14400 # Atlantic Standard Time # (America/Thule) # (America/Tortola) # (Atlantic/Bermuda) -AZOST 0 D # Azores Summer Time - # (Atlantic/Azores) -AZOT -3600 # Azores Time - # (Atlantic/Azores) -FKST Atlantic/Stanley # Falkland Islands Summer/Standard Time - # (Atlantic/Stanley) +AZOST 0 D # Azores Summer Time (obsolete) +AZOT -3600 # Azores Time (obsolete) +FKST Atlantic/Stanley # Falkland Islands Summer/Standard Time (obsolete) FKT Atlantic/Stanley # Falkland Islands Time (obsolete) #################### AUSTRALIA #################### @@ -400,8 +337,7 @@ ACST 34200 # Australian Central Standard Time # (Australia/Adelaide) # (Australia/Broken_Hill) # (Australia/Darwin) -ACWST 31500 # Australian Central Western Standard Time - # (Australia/Eucla) +ACWST 31500 # Australian Central Western Standard Time (obsolete) AESST 39600 D # Australian Eastern Summer Standard Time (not in IANA database) AEDT 39600 D # Australian Eastern Daylight Time # (Australia/Brisbane) @@ -422,10 +358,8 @@ AWST 28800 # Australian Western Standard Time # (Australia/Perth) CADT 37800 D # Central Australia Daylight-Saving Time (not in IANA database) CAST 34200 # Central Australia Standard Time (not in IANA database) -LHDT Australia/Lord_Howe # Lord Howe Daylight Time - # (Australia/Lord_Howe) -LHST 37800 # Lord Howe Standard Time - # (Australia/Lord_Howe) +LHDT Australia/Lord_Howe # Lord Howe Daylight Time (obsolete) +LHST 37800 # Lord Howe Standard Time (obsolete) LIGT 36000 # Melbourne, Australia (not in IANA database) NZT 43200 # New Zealand Time (not in IANA database) SADT 37800 D # South Australian Daylight-Saving Time (not in IANA database) @@ -614,10 +548,15 @@ EETDST 10800 D # East-Egypt Summertime FET 10800 # Further-eastern European Time (obsolete) # (Europe/Kaliningrad) # (Europe/Minsk) -MEST 7200 D # Middle Europe Summer Time (not in IANA database) -MET 3600 # Middle Europe Time (not in IANA database) +MEST 7200 D # Middle Europe Summer Time + # (MET) +MESZ 7200 D # Mitteleuropaeische Sommerzeit (German) + # (attested in IANA comments though not their code) +MET 3600 # Middle Europe Time + # (MET) METDST 7200 D # Middle Europe Summer Time (not in IANA database) -MEZ 3600 # Mitteleuropaeische Zeit (German) (not in IANA database) +MEZ 3600 # Mitteleuropaeische Zeit (German) + # (attested in IANA comments though not their code) MSD 14400 D # Moscow Daylight Time (obsolete) MSK Europe/Moscow # Moscow Time # (Europe/Moscow) @@ -638,92 +577,53 @@ WETDST 3600 D # Western Europe Summer Time #################### INDIAN #################### -CXT 25200 # Christmas Island Time (Indian Ocean) - # (Indian/Christmas) -IOT Indian/Chagos # British Indian Ocean Territory (Chagos) - # (Indian/Chagos) -MUT 14400 # Mauritius Island Time - # (Indian/Mauritius) -MUST 18000 D # Mauritius Island Summer Time - # (Indian/Mauritius) -MVT 18000 # Maldives Island Time - # (Indian/Maldives) -RET 14400 # Reunion Time - # (Indian/Reunion) -SCT 14400 # Seychelles Time - # (Indian/Mahe) +CXT 25200 # Christmas Island Time (Indian Ocean) (obsolete) +IOT Indian/Chagos # British Indian Ocean Territory (Chagos) (obsolete) +MUT 14400 # Mauritius Island Time (obsolete) +MUST 18000 D # Mauritius Island Summer Time (obsolete) +MVT 18000 # Maldives Island Time (obsolete) +RET 14400 # Reunion Time (obsolete) +SCT 14400 # Seychelles Time (obsolete) TFT 18000 # Kerguelen Time (obsolete) #################### PACIFIC #################### -CHADT 49500 D # Chatham Daylight Time (New Zealand) - # (Pacific/Chatham) -CHAST 45900 # Chatham Standard Time (New Zealand) - # (Pacific/Chatham) -CHUT 36000 # Chuuk Time - # (Pacific/Chuuk) -CKT Pacific/Rarotonga # Cook Islands Time - # (Pacific/Rarotonga) -EASST Pacific/Easter # Easter Island Summer Time - # (Pacific/Easter) -EAST Pacific/Easter # Easter Island Time (Chile) - # (Pacific/Easter) -FJST 46800 D # Fiji Summer Time - # (Pacific/Fiji) -FJT 43200 # Fiji Time - # (Pacific/Fiji) -GALT -21600 # Galapagos Time - # (Pacific/Galapagos) -GAMT -32400 # Gambier Time - # (Pacific/Gambier) -GILT 43200 # Gilbert Islands Time - # (Pacific/Tarawa) +CHADT 49500 D # Chatham Daylight Time (New Zealand) (obsolete) +CHAST 45900 # Chatham Standard Time (New Zealand) (obsolete) +CHUT 36000 # Chuuk Time (obsolete) +CKT Pacific/Rarotonga # Cook Islands Time (obsolete) +EASST Pacific/Easter # Easter Island Summer Time (obsolete) +EAST Pacific/Easter # Easter Island Time (Chile) (obsolete) +FJST 46800 D # Fiji Summer Time (obsolete) +FJT 43200 # Fiji Time (obsolete) +GALT -21600 # Galapagos Time (obsolete) +GAMT -32400 # Gambier Time (obsolete) +GILT 43200 # Gilbert Islands Time (obsolete) HST -36000 # Hawaiian Standard Time # (Pacific/Honolulu) # (Pacific/Johnston) -KOST Pacific/Kosrae # Kosrae Time - # (Pacific/Kosrae) -LINT Pacific/Kiritimati # Line Islands Time (Kiribati) - # (Pacific/Kiritimati) -MART -34200 # Marquesas Time - # (Pacific/Marquesas) -MHT 43200 # Kwajalein Time - # (Pacific/Kwajalein) - # (Pacific/Majuro) +KOST Pacific/Kosrae # Kosrae Time (obsolete) +LINT Pacific/Kiritimati # Line Islands Time (Kiribati) (obsolete) +MART -34200 # Marquesas Time (obsolete) +MHT 43200 # Kwajalein Time (obsolete) MPT 36000 # North Mariana Islands Time (not in IANA database) -# CONFLICT! NFT is not unique -# Other timezones: -# - NFT: Norfolk Time (Pacific) -NFT -12600 # Newfoundland Time (not in IANA database) -NUT Pacific/Niue # Niue Time - # (Pacific/Niue) +NUT Pacific/Niue # Niue Time (obsolete) NZDT 46800 D # New Zealand Daylight Time # (Antarctica/McMurdo) # (Pacific/Auckland) NZST 43200 # New Zealand Standard Time # (Antarctica/McMurdo) # (Pacific/Auckland) -PGT 36000 # Papua New Guinea Time - # (Pacific/Port_Moresby) -PHOT Pacific/Enderbury # Phoenix Islands Time (Kiribati) - # (Pacific/Enderbury) -PONT 39600 # Ponape Time (Micronesia) - # (Pacific/Ponape) -PWT 32400 # Palau Time - # (Pacific/Palau) -TAHT -36000 # Tahiti Time (IANA database says "TAHT", other sources "THAT") - # (Pacific/Tahiti) -TKT Pacific/Fakaofo # Tokelau Time - # (Pacific/Fakaofo) +PGT 36000 # Papua New Guinea Time (obsolete) +PHOT Pacific/Enderbury # Phoenix Islands Time (Kiribati) (obsolete) +PONT 39600 # Ponape Time (Micronesia) (obsolete) +PWT 32400 # Palau Time (obsolete) +TAHT -36000 # Tahiti Time (obsolete) +TKT Pacific/Fakaofo # Tokelau Time (obsolete) TOT 46800 # Tonga Time (obsolete) -TRUT 36000 # Truk Time (IANA database used to say "TRUT", other sources say "TRUK") - # (Pacific/Truk) -TVT 43200 # Tuvalu Time - # (Pacific/Funafuti) -VUT 39600 # Vanuata Time - # (Pacific/Efate) -WAKT 43200 # Wake Time - # (Pacific/Wake) -WFT 43200 # Wallis and Futuna Time - # (Pacific/Wallis) +TRUT 36000 # Truk Time (obsolete) +TVT 43200 # Tuvalu Time (obsolete) +VUT 39600 # Vanuata Time (obsolete) +WAKT 43200 # Wake Time (obsolete) +WFT 43200 # Wallis and Futuna Time (obsolete) YAPT 36000 # Yap Time (Micronesia) (not in IANA database) diff --git a/src/timezone/tznames/Europe.txt b/src/timezone/tznames/Europe.txt index 85d18d9d2d..0cb49f156b 100644 --- a/src/timezone/tznames/Europe.txt +++ b/src/timezone/tznames/Europe.txt @@ -182,10 +182,15 @@ GMT 0 # Greenwich Mean Time # - IST: Israel Standard Time (Asia) IST 3600 D # Irish Summer Time # (Europe/Dublin) -MEST 7200 D # Middle Europe Summer Time (not in IANA database) -MET 3600 # Middle Europe Time (not in IANA database) +MEST 7200 D # Middle Europe Summer Time + # (MET) +MESZ 7200 D # Mitteleuropäische Sommerzeit (German) + # (attested in IANA comments though not their code) +MET 3600 # Middle Europe Time + # (MET) METDST 7200 D # Middle Europe Summer Time (not in IANA database) -MEZ 3600 # Mitteleuropäische Zeit (German) (not in IANA database) +MEZ 3600 # Mitteleuropäische Zeit (German) + # (attested in IANA comments though not their code) MSD 14400 D # Moscow Daylight Time (obsolete) MSK Europe/Moscow # Moscow Time # (Europe/Moscow) diff --git a/src/timezone/tznames/Indian.txt b/src/timezone/tznames/Indian.txt index 12842d366f..8e6fe6094c 100644 --- a/src/timezone/tznames/Indian.txt +++ b/src/timezone/tznames/Indian.txt @@ -7,10 +7,8 @@ # src/timezone/tznames/Indian.txt # -CCT 23400 # Cocos Islands Time (Indian Ocean) - # (Indian/Cocos) -CXT 25200 # Christmas Island Time (Indian Ocean) - # (Indian/Christmas) +CCT 23400 # Cocos Islands Time (Indian Ocean) (obsolete) +CXT 25200 # Christmas Island Time (Indian Ocean) (obsolete) EAT 10800 # East Africa Time # (Africa/Addis_Ababa) # (Africa/Asmera) @@ -23,16 +21,10 @@ EAT 10800 # East Africa Time # (Indian/Antananarivo) # (Indian/Comoro) # (Indian/Mayotte) -IOT Indian/Chagos # British Indian Ocean Territory (Chagos) - # (Indian/Chagos) -MUT 14400 # Mauritius Island Time - # (Indian/Mauritius) -MUST 18000 D # Mauritius Island Summer Time - # (Indian/Mauritius) -MVT 18000 # Maldives Island Time - # (Indian/Maldives) -RET 14400 # Reunion Time - # (Indian/Reunion) -SCT 14400 # Seychelles Time - # (Indian/Mahe) +IOT Indian/Chagos # British Indian Ocean Territory (Chagos) (obsolete) +MUT 14400 # Mauritius Island Time (obsolete) +MUST 18000 D # Mauritius Island Summer Time (obsolete) +MVT 18000 # Maldives Island Time (obsolete) +RET 14400 # Reunion Time (obsolete) +SCT 14400 # Seychelles Time (obsolete) TFT 18000 # Kerguelen Time (obsolete) diff --git a/src/timezone/tznames/Pacific.txt b/src/timezone/tznames/Pacific.txt index 205655ed87..c86248bbc7 100644 --- a/src/timezone/tznames/Pacific.txt +++ b/src/timezone/tznames/Pacific.txt @@ -10,72 +10,48 @@ # CONFLICT! BST is not unique # Other timezones: # - BST: British Summer Time -BST 39600 # Bougainville Standard Time (Papua New Guinea) - # (Pacific/Bougainville) -CHADT 49500 D # Chatham Daylight Time (New Zealand) - # (Pacific/Chatham) -CHAST 45900 # Chatham Standard Time (New Zealand) - # (Pacific/Chatham) +BST 39600 # Bougainville Standard Time (Papua New Guinea) (obsolete) +CHADT 49500 D # Chatham Daylight Time (New Zealand) (obsolete) +CHAST 45900 # Chatham Standard Time (New Zealand) (obsolete) ChST 36000 # Chamorro Standard Time (lower case "h" is as in IANA database) # (Pacific/Guam) # (Pacific/Saipan) -CHUT 36000 # Chuuk Time - # (Pacific/Chuuk) -CKT Pacific/Rarotonga # Cook Islands Time - # (Pacific/Rarotonga) -EASST Pacific/Easter # Easter Island Summer Time - # (Pacific/Easter) +CHUT 36000 # Chuuk Time (obsolete) +CKT Pacific/Rarotonga # Cook Islands Time (obsolete) +EASST Pacific/Easter # Easter Island Summer Time (obsolete) # CONFLICT! EAST is not unique # Other timezones: # - EAST: East Australian Standard Time (Australia) -EAST Pacific/Easter # Easter Island Time (Chile) - # (Pacific/Easter) -FJST 46800 D # Fiji Summer Time (caution: this used to mean -46800) - # (Pacific/Fiji) -FJT 43200 # Fiji Time (caution: this used to mean -43200) - # (Pacific/Fiji) -GALT -21600 # Galapagos Time - # (Pacific/Galapagos) -GAMT -32400 # Gambier Time - # (Pacific/Gambier) -GILT 43200 # Gilbert Islands Time - # (Pacific/Tarawa) +EAST Pacific/Easter # Easter Island Time (Chile) (obsolete) +FJST 46800 D # Fiji Summer Time (caution: this used to mean -46800) (obsolete) +FJT 43200 # Fiji Time (caution: this used to mean -43200) (obsolete) +GALT -21600 # Galapagos Time (obsolete) +GAMT -32400 # Gambier Time (obsolete) +GILT 43200 # Gilbert Islands Time (obsolete) HST -36000 # Hawaiian Standard Time # (Pacific/Honolulu) # (Pacific/Johnston) -KOST Pacific/Kosrae # Kosrae Time - # (Pacific/Kosrae) -LINT Pacific/Kiritimati # Line Islands Time (Kiribati) - # (Pacific/Kiritimati) -MART -34200 # Marquesas Time - # (Pacific/Marquesas) -MHT 43200 # Kwajalein Time - # (Pacific/Kwajalein) - # (Pacific/Majuro) +KOST Pacific/Kosrae # Kosrae Time (obsolete) +LINT Pacific/Kiritimati # Line Islands Time (Kiribati) (obsolete) +MART -34200 # Marquesas Time (obsolete) +MHT 43200 # Kwajalein Time (obsolete) MPT 36000 # North Mariana Islands Time (not in IANA database) -NCT 39600 # New Caledonia Time - # (Pacific/Noumea) +NCT 39600 # New Caledonia Time (obsolete) # CONFLICT! NFT is not unique # Other timezones: # - NFT: Newfoundland Time (America) -NFT Pacific/Norfolk # Norfolk Time - # (Pacific/Norfolk) -NRT Pacific/Nauru # Nauru Time - # (Pacific/Nauru) -NUT Pacific/Niue # Niue Time - # (Pacific/Niue) +NFT Pacific/Norfolk # Norfolk Time (obsolete) +NRT Pacific/Nauru # Nauru Time (obsolete) +NUT Pacific/Niue # Niue Time (obsolete) NZDT 46800 D # New Zealand Daylight Time # (Antarctica/McMurdo) # (Pacific/Auckland) NZST 43200 # New Zealand Standard Time # (Antarctica/McMurdo) # (Pacific/Auckland) -PGT 36000 # Papua New Guinea Time - # (Pacific/Port_Moresby) -PHOT Pacific/Enderbury # Phoenix Islands Time (Kiribati) - # (Pacific/Enderbury) -PONT 39600 # Ponape Time (Micronesia) - # (Pacific/Ponape) +PGT 36000 # Papua New Guinea Time (obsolete) +PHOT Pacific/Enderbury # Phoenix Islands Time (Kiribati) (obsolete) +PONT 39600 # Ponape Time (Micronesia) (obsolete) PST -28800 # Pacific Standard Time # (America/Dawson) # (America/Los_Angeles) @@ -83,32 +59,21 @@ PST -28800 # Pacific Standard Time # (America/Vancouver) # (America/Whitehorse) # (Pacific/Pitcairn) -PWT 32400 # Palau Time - # (Pacific/Palau) -SBT 39600 # Solomon Islands Time - # (Pacific/Guadalcanal) +PWT 32400 # Palau Time (obsolete) +SBT 39600 # Solomon Islands Time (obsolete) SST -39600 # South Sumatran Time # (Pacific/Midway) # (Pacific/Pago_Pago) -TAHT -36000 # Tahiti Time (IANA database says "TAHT", other sources "THAT") - # (Pacific/Tahiti) -TKT Pacific/Fakaofo # Tokelau Time - # (Pacific/Fakaofo) +TAHT -36000 # Tahiti Time (obsolete) +TKT Pacific/Fakaofo # Tokelau Time (obsolete) TOT 46800 # Tonga Time (obsolete) -TRUT 36000 # Truk Time (IANA database used to say "TRUT", other sources say "TRUK") - # (Pacific/Truk) -TVT 43200 # Tuvalu Time - # (Pacific/Funafuti) -VUT 39600 # Vanuata Time - # (Pacific/Efate) -WAKT 43200 # Wake Time - # (Pacific/Wake) -WFT 43200 # Wallis and Futuna Time - # (Pacific/Wallis) -WSDT 50400 D # West Samoa Daylight Time - # (Pacific/Apia) -WSST 46800 # West Samoa Standard Time - # (Pacific/Apia) +TRUT 36000 # Truk Time (obsolete) +TVT 43200 # Tuvalu Time (obsolete) +VUT 39600 # Vanuata Time (obsolete) +WAKT 43200 # Wake Time (obsolete) +WFT 43200 # Wallis and Futuna Time (obsolete) +WSDT 50400 D # West Samoa Daylight Time (obsolete) +WSST 46800 # West Samoa Standard Time (obsolete) # CONFLICT! WST is not unique # Other timezones: # - WST: Western Standard Time (Australia) diff --git a/src/timezone/tznames/README b/src/timezone/tznames/README index c80caa3786..0058770d19 100644 --- a/src/timezone/tznames/README +++ b/src/timezone/tznames/README @@ -29,6 +29,12 @@ see the `Australia' and `India' files. The files named Africa.txt, etc, are not intended to be used directly as time zone abbreviation files. They contain reference definitions of time zone abbreviations that can be copied into a custom abbreviation file as needed. -Note that these files (*.txt) are already a subset of the IANA timezone -database files: we tried to list only those time zone abbreviations that -(according to the IANA timezone database) appear to be still in use. +These files contain most of the time zone abbreviations that were shown +in the IANA timezone database circa 2010. + +However, it turns out that many of these abbreviations had simply been +invented by the IANA timezone group, and do not have currency in real-world +use. The IANA group have changed their policy about that, and now prefer to +use numeric UTC offsets whenever there's not an abbreviation with known +real-world popularity. A lot of these abbreviations therefore no longer +appear in the IANA data, and so are marked "obsolete" in these data files. From f06caa09d9c539a2336434e6b521b6541c3da624 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Tue, 2 May 2017 08:20:11 -0400 Subject: [PATCH 0031/1139] Fix perl thinko in commit fed6df486dca Report and fix from Vaishnavi Prabakaran Backpatch to 9.4 like original. --- src/tools/msvc/vcregress.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/msvc/vcregress.pl b/src/tools/msvc/vcregress.pl index 5a08a585a5..d757e176a7 100644 --- a/src/tools/msvc/vcregress.pl +++ b/src/tools/msvc/vcregress.pl @@ -90,7 +90,7 @@ exit 3 unless $proc; -&$proc(@_); +&$proc(@ARGV); exit 0; From 4596c34f6ffe43f6807fa38c1263a3a0fe58c8d9 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 2 May 2017 19:32:26 +0300 Subject: [PATCH 0032/1139] Optimized version of postgres_fdw: use 2pc only when needed --- contrib/postgres_fdw/connection.c | 47 +- contrib/postgres_fdw/postgres_fdw.c | 31 +- contrib/postgres_fdw/tests/dtmbench.cpp | 37 +- src/backend/nodes/nodeFuncs.c | 448 +++++++++++++ src/backend/nodes/outfuncs.c | 47 ++ src/backend/tcop/postgres.c | 857 ++++++++++++++++++++++++ src/backend/utils/misc/guc.c | 26 + src/include/nodes/nodeFuncs.h | 3 + src/include/utils/guc.h | 3 + 9 files changed, 1462 insertions(+), 37 deletions(-) diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c index 2b28b8c40b..3b525cbefb 100644 --- a/contrib/postgres_fdw/connection.c +++ b/contrib/postgres_fdw/connection.c @@ -67,6 +67,8 @@ static bool xact_got_connection = false; typedef long long csn_t; static csn_t currentGlobalTransactionId = 0; static int currentLocalTransactionId = 0; +static PGconn* currentConnection = NULL; + /* prototypes of private functions */ static PGconn *connect_pg_server(ForeignServer *server, UserMapping *user); @@ -406,6 +408,8 @@ static void begin_remote_xact(ConnCacheEntry *entry) { int curlevel = GetCurrentTransactionNestLevel(); + PGresult *res; + /* Start main transaction if we haven't yet */ if (entry->xact_depth <= 0) @@ -419,8 +423,6 @@ begin_remote_xact(ConnCacheEntry *entry) if (TransactionIdIsValid(gxid)) { char stmt[64]; - PGresult *res; - snprintf(stmt, sizeof(stmt), "select public.dtm_join_transaction(%d)", gxid); res = PQexec(entry->conn, stmt); PQclear(res); @@ -434,26 +436,30 @@ begin_remote_xact(ConnCacheEntry *entry) entry->xact_depth = 1; if (UseTsDtmTransactions) { - if (!currentGlobalTransactionId) + if (currentConnection == NULL) { - PGresult *res = PQexec(entry->conn, psprintf("SELECT public.dtm_extend('%d.%d')", - MyProcPid, ++currentLocalTransactionId)); - char *resp; - - if (PQresultStatus(res) != PGRES_TUPLES_OK) - { - pgfdw_report_error(ERROR, res, entry->conn, true, sql); - } - resp = PQgetvalue(res, 0, 0); - if (resp == NULL || (*resp) == '\0' || sscanf(resp, "%lld", ¤tGlobalTransactionId) != 1) - { - pgfdw_report_error(ERROR, res, entry->conn, true, sql); - } - PQclear(res); - } - else + currentConnection = entry->conn; + } + else if (entry->conn != currentConnection) { - PGresult *res = PQexec(entry->conn, psprintf("SELECT public.dtm_access(%llu, '%d.%d')", currentGlobalTransactionId, MyProcPid, currentLocalTransactionId)); + if (!currentGlobalTransactionId) + { + char *resp; + res = PQexec(currentConnection, psprintf("SELECT public.dtm_extend('%d.%d')", + MyProcPid, ++currentLocalTransactionId)); + + if (PQresultStatus(res) != PGRES_TUPLES_OK) + { + pgfdw_report_error(ERROR, res, currentConnection, true, sql); + } + resp = PQgetvalue(res, 0, 0); + if (resp == NULL || (*resp) == '\0' || sscanf(resp, "%lld", ¤tGlobalTransactionId) != 1) + { + pgfdw_report_error(ERROR, res, currentConnection, true, sql); + } + PQclear(res); + } + res = PQexec(entry->conn, psprintf("SELECT public.dtm_access(%llu, '%d.%d')", currentGlobalTransactionId, MyProcPid, currentLocalTransactionId)); if (PQresultStatus(res) != PGRES_TUPLES_OK) { @@ -954,6 +960,7 @@ pgfdw_xact_callback(XactEvent event, void *arg) cursor_number = 0; currentGlobalTransactionId = 0; + currentConnection = NULL; } } diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c index c51d775b57..7cfe925db8 100644 --- a/contrib/postgres_fdw/postgres_fdw.c +++ b/contrib/postgres_fdw/postgres_fdw.c @@ -3179,22 +3179,29 @@ execute_dml_stmt(ForeignScanState *node) /* * Construct array of query parameter values in text format. */ - if (numParams > 0) + if (numParams > 0) + { process_query_params(econtext, dmstate->param_flinfo, dmstate->param_exprs, values); - - /* - * Notice that we pass NULL for paramTypes, thus forcing the remote server - * to infer types for all parameters. Since we explicitly cast every - * parameter (see deparse.c), the "inference" is trivial and will produce - * the desired result. This allows us to avoid assuming that the remote - * server has the same OIDs we do for the parameters' types. - */ - if (!PQsendQueryParams(dmstate->conn, dmstate->query, numParams, - NULL, values, NULL, NULL, 0)) - pgfdw_report_error(ERROR, NULL, dmstate->conn, false, dmstate->query); + + /* + * Notice that we pass NULL for paramTypes, thus forcing the remote server + * to infer types for all parameters. Since we explicitly cast every + * parameter (see deparse.c), the "inference" is trivial and will produce + * the desired result. This allows us to avoid assuming that the remote + * server has the same OIDs we do for the parameters' types. + */ + if (!PQsendQueryParams(dmstate->conn, dmstate->query, numParams, + NULL, values, NULL, NULL, 0)) + pgfdw_report_error(ERROR, NULL, dmstate->conn, false, dmstate->query); + } + else + { + if (!PQsendQuery(dmstate->conn, dmstate->query)) + pgfdw_report_error(ERROR, NULL, dmstate->conn, false, dmstate->query); + } /* * Get the result, and check for success. diff --git a/contrib/postgres_fdw/tests/dtmbench.cpp b/contrib/postgres_fdw/tests/dtmbench.cpp index 4f1db6bbce..05421db584 100644 --- a/contrib/postgres_fdw/tests/dtmbench.cpp +++ b/contrib/postgres_fdw/tests/dtmbench.cpp @@ -53,6 +53,8 @@ struct config int nShards; string connection; bool prepared; + bool local; + bool pathman_sharding; config() { nShards = 1; @@ -62,6 +64,8 @@ struct config nAccounts = 10000; updatePercent = 100; prepared = false; + local = false; + pathman_sharding = false; } }; @@ -125,14 +129,17 @@ void* writer(void* arg) { thread& t = *(thread*)arg; connection conn(cfg.connection); + if (cfg.prepared) { conn.prepare("transfer", "update t set v = v + $1 where u=$2"); } + for (int i = 0; i < cfg.nIterations; i++) { work txn(conn); int srcAcc = random() % cfg.nAccounts; - int dstAcc = random() % cfg.nAccounts; + int dstAcc = (cfg.local ? srcAcc + 1 : random()) % cfg.nAccounts; + try { if (random() % 100 < cfg.updatePercent) { int rc = cfg.prepared @@ -180,8 +187,17 @@ void initializeDatabase() for (int i = 0; i < cfg.nShards; i++) { work txn(conn); - exec(txn, "alter table t_fdw%i add check (u between %d and %d)", i+1, accountsPerShard*i, accountsPerShard*(i+1)-1); + + if (!cfg.pathman_sharding) { + exec(txn, "alter table t_fdw%i add check (u between %d and %d)", i+1, accountsPerShard*i, accountsPerShard*(i+1)-1); + } else { + //exec(txn, "SELECT add_range_partition('t', %d::int, %d, 't_fdw%i')", + exec(txn, "SELECT add_foreign_range_partition('t', %d::int, %d, 't_fdw%i', 'shard%i')", + accountsPerShard*i, accountsPerShard*(i+1), i+1, i % 3 + 1); + } + exec(txn, "insert into t_fdw%i (select generate_series(%d,%d), %d)", i+1, accountsPerShard*i, accountsPerShard*(i+1)-1, 0); + txn.commit(); } } @@ -221,9 +237,15 @@ int main (int argc, char* argv[]) initialize = true; cfg.nShards = atoi(argv[++i]); continue; + case 'l': + cfg.local = true; + continue; case 'P': cfg.prepared = true; continue; + case 'S': + cfg.pathman_sharding = true; + continue; } } printf("Options:\n" @@ -234,7 +256,9 @@ int main (int argc, char* argv[]) "\t-p N\tupdate percent (100)\n" "\t-c STR\tdatabase connection string\n" "\t-i N\tinitialize N shards\n" - "\t-P\tuse prepared statements\n"); + "\t-l\ttlocal tranfers\n" + "\t-P\tuse prepared statements\n" + "\t-S\tuse pathman_sharding\n"); return 1; } @@ -282,7 +306,8 @@ int main (int argc, char* argv[]) printf( "{\"tps\":%f, \"transactions\":%ld," " \"selects\":%ld, \"updates\":%ld, \"aborts\":%ld, \"abort_percent\": %d," - " \"readers\":%d, \"writers\":%d, \"update_percent\":%d, \"accounts\":%d, \"iterations\":%d ,\"shards\":%d, \"prepared\":%d}\n", + " \"readers\":%d, \"writers\":%d, \"update_percent\":%d, \"accounts\":%d," + " \"iterations\":%d ,\"shards\":%d, \"prepared\":%d, \"pathman_sharding\":%d, \"local\":%d}\n", (double)(nTransactions*USEC)/elapsed, nTransactions, nSelects, @@ -295,7 +320,9 @@ int main (int argc, char* argv[]) cfg.nAccounts, cfg.nIterations, cfg.nShards, - cfg.prepared); + cfg.prepared, + cfg.pathman_sharding, + cfg.local); return 0; } diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c index cd39167351..4fbc8b7f0c 100644 --- a/src/backend/nodes/nodeFuncs.c +++ b/src/backend/nodes/nodeFuncs.c @@ -3609,6 +3609,454 @@ raw_expression_tree_walker(Node *node, return false; } +/* + * raw_expression_tree_mutator --- transform raw parse tree. + * + * This function is implementing slightly different approach for tree update than expression_tree_mutator(). + * Callback is given pointer to pointer to the current node and can update this field instead of returning reference to new node. + * It makes it possible to remember changes and easily revert them without extra traversal of the tree. + * + * This function do not need QTW_DONT_COPY_QUERY flag: it never implicitly copy tree nodes, doing in-place update. + * + * Like raw_expression_tree_walker, there is no special rule about query + * boundaries: we descend to everything that's possibly interesting. + * + * Currently, the node type coverage here extends only to DML statements + * (SELECT/INSERT/UPDATE/DELETE) and nodes that can appear in them, because + * this is used mainly during analysis of CTEs, and only DML statements can + * appear in CTEs. If some other node is visited, iteration is immediately stopped and true is returned. + */ +bool +raw_expression_tree_mutator(Node *node, + bool (*mutator) (), + void *context) +{ + ListCell *temp; + + /* + * The walker has already visited the current node, and so we need only + * recurse into any sub-nodes it has. + */ + if (node == NULL) + return false; + + /* Guard against stack overflow due to overly complex expressions */ + check_stack_depth(); + + switch (nodeTag(node)) + { + case T_SetToDefault: + case T_CurrentOfExpr: + case T_Integer: + case T_Float: + case T_String: + case T_BitString: + case T_Null: + case T_ParamRef: + case T_A_Const: + case T_A_Star: + /* primitive node types with no subnodes */ + break; + case T_Alias: + /* we assume the colnames list isn't interesting */ + break; + case T_RangeVar: + return mutator(&((RangeVar *) node)->alias, context); + case T_GroupingFunc: + return mutator(&((GroupingFunc *) node)->args, context); + case T_SubLink: + { + SubLink *sublink = (SubLink *) node; + + if (mutator(&sublink->testexpr, context)) + return true; + /* we assume the operName is not interesting */ + if (mutator(&sublink->subselect, context)) + return true; + } + break; + case T_CaseExpr: + { + CaseExpr *caseexpr = (CaseExpr *) node; + + if (mutator(&caseexpr->arg, context)) + return true; + /* we assume mutator(& doesn't care about CaseWhens, either */ + foreach(temp, caseexpr->args) + { + CaseWhen *when = (CaseWhen *) lfirst(temp); + + Assert(IsA(when, CaseWhen)); + if (mutator(&when->expr, context)) + return true; + if (mutator(&when->result, context)) + return true; + } + if (mutator(&caseexpr->defresult, context)) + return true; + } + break; + case T_RowExpr: + /* Assume colnames isn't interesting */ + return mutator(&((RowExpr *) node)->args, context); + case T_CoalesceExpr: + return mutator(&((CoalesceExpr *) node)->args, context); + case T_MinMaxExpr: + return mutator(&((MinMaxExpr *) node)->args, context); + case T_XmlExpr: + { + XmlExpr *xexpr = (XmlExpr *) node; + + if (mutator(&xexpr->named_args, context)) + return true; + /* we assume mutator(& doesn't care about arg_names */ + if (mutator(&xexpr->args, context)) + return true; + } + break; + case T_NullTest: + return mutator(&((NullTest *) node)->arg, context); + case T_BooleanTest: + return mutator(&((BooleanTest *) node)->arg, context); + case T_JoinExpr: + { + JoinExpr *join = (JoinExpr *) node; + + if (mutator(&join->larg, context)) + return true; + if (mutator(&join->rarg, context)) + return true; + if (mutator(&join->quals, context)) + return true; + if (mutator(&join->alias, context)) + return true; + /* using list is deemed uninteresting */ + } + break; + case T_IntoClause: + { + IntoClause *into = (IntoClause *) node; + + if (mutator(&into->rel, context)) + return true; + /* colNames, options are deemed uninteresting */ + /* viewQuery should be null in raw parsetree, but check it */ + if (mutator(&into->viewQuery, context)) + return true; + } + break; + case T_List: + foreach(temp, (List *) node) + { + if (mutator(&lfirst(temp), context)) + return true; + } + break; + case T_InsertStmt: + { + InsertStmt *stmt = (InsertStmt *) node; + + if (mutator(&stmt->relation, context)) + return true; + if (mutator(&stmt->cols, context)) + return true; + if (mutator(&stmt->selectStmt, context)) + return true; + if (mutator(&stmt->onConflictClause, context)) + return true; + if (mutator(&stmt->returningList, context)) + return true; + if (mutator(&stmt->withClause, context)) + return true; + } + break; + case T_DeleteStmt: + { + DeleteStmt *stmt = (DeleteStmt *) node; + + if (mutator(&stmt->relation, context)) + return true; + if (mutator(&stmt->usingClause, context)) + return true; + if (mutator(&stmt->whereClause, context)) + return true; + if (mutator(&stmt->returningList, context)) + return true; + if (mutator(&stmt->withClause, context)) + return true; + } + break; + case T_UpdateStmt: + { + UpdateStmt *stmt = (UpdateStmt *) node; + + if (mutator(&stmt->relation, context)) + return true; + if (mutator(&stmt->targetList, context)) + return true; + if (mutator(&stmt->whereClause, context)) + return true; + if (mutator(&stmt->fromClause, context)) + return true; + if (mutator(&stmt->returningList, context)) + return true; + if (mutator(&stmt->withClause, context)) + return true; + } + break; + case T_SelectStmt: + { + SelectStmt *stmt = (SelectStmt *) node; + + if (mutator(&stmt->distinctClause, context)) + return true; + if (mutator(&stmt->intoClause, context)) + return true; + if (mutator(&stmt->targetList, context)) + return true; + if (mutator(&stmt->fromClause, context)) + return true; + if (mutator(&stmt->whereClause, context)) + return true; + if (mutator(&stmt->groupClause, context)) + return true; + if (mutator(&stmt->havingClause, context)) + return true; + if (mutator(&stmt->windowClause, context)) + return true; + if (mutator(&stmt->valuesLists, context)) + return true; + if (mutator(&stmt->sortClause, context)) + return true; + if (mutator(&stmt->limitOffset, context)) + return true; + if (mutator(&stmt->limitCount, context)) + return true; + if (mutator(&stmt->lockingClause, context)) + return true; + if (mutator(&stmt->withClause, context)) + return true; + if (mutator(&stmt->larg, context)) + return true; + if (mutator(&stmt->rarg, context)) + return true; + } + break; + case T_A_Expr: + { + A_Expr *expr = (A_Expr *) node; + + if (mutator(&expr->lexpr, context)) + return true; + if (mutator(&expr->rexpr, context)) + return true; + /* operator name is deemed uninteresting */ + } + break; + case T_BoolExpr: + { + BoolExpr *expr = (BoolExpr *) node; + + if (mutator(&expr->args, context)) + return true; + } + break; + case T_ColumnRef: + /* we assume the fields contain nothing interesting */ + break; + case T_FuncCall: + { + FuncCall *fcall = (FuncCall *) node; + + if (mutator(&fcall->args, context)) + return true; + if (mutator(&fcall->agg_order, context)) + return true; + if (mutator(&fcall->agg_filter, context)) + return true; + if (mutator(&fcall->over, context)) + return true; + /* function name is deemed uninteresting */ + } + break; + case T_NamedArgExpr: + return mutator(&((NamedArgExpr *) node)->arg, context); + case T_A_Indices: + { + A_Indices *indices = (A_Indices *) node; + + if (mutator(&indices->lidx, context)) + return true; + if (mutator(&indices->uidx, context)) + return true; + } + break; + case T_A_Indirection: + { + A_Indirection *indir = (A_Indirection *) node; + + if (mutator(&indir->arg, context)) + return true; + if (mutator(&indir->indirection, context)) + return true; + } + break; + case T_A_ArrayExpr: + return mutator(&((A_ArrayExpr *) node)->elements, context); + case T_ResTarget: + { + ResTarget *rt = (ResTarget *) node; + + if (mutator(&rt->indirection, context)) + return true; + if (mutator(&rt->val, context)) + return true; + } + break; + case T_MultiAssignRef: + return mutator(&((MultiAssignRef *) node)->source, context); + case T_TypeCast: + { + TypeCast *tc = (TypeCast *) node; + + if (mutator(&tc->arg, context)) + return true; + if (mutator(&tc->typeName, context)) + return true; + } + break; + case T_CollateClause: + return mutator(&((CollateClause *) node)->arg, context); + case T_SortBy: + return mutator(&((SortBy *) node)->node, context); + case T_WindowDef: + { + WindowDef *wd = (WindowDef *) node; + + if (mutator(&wd->partitionClause, context)) + return true; + if (mutator(&wd->orderClause, context)) + return true; + if (mutator(&wd->startOffset, context)) + return true; + if (mutator(&wd->endOffset, context)) + return true; + } + break; + case T_RangeSubselect: + { + RangeSubselect *rs = (RangeSubselect *) node; + + if (mutator(&rs->subquery, context)) + return true; + if (mutator(&rs->alias, context)) + return true; + } + break; + case T_RangeFunction: + { + RangeFunction *rf = (RangeFunction *) node; + + if (mutator(&rf->functions, context)) + return true; + if (mutator(&rf->alias, context)) + return true; + if (mutator(&rf->coldeflist, context)) + return true; + } + break; + case T_RangeTableSample: + { + RangeTableSample *rts = (RangeTableSample *) node; + + if (mutator(&rts->relation, context)) + return true; + /* method name is deemed uninteresting */ + if (mutator(&rts->args, context)) + return true; + if (mutator(&rts->repeatable, context)) + return true; + } + break; + case T_TypeName: + { + TypeName *tn = (TypeName *) node; + + if (mutator(&tn->typmods, context)) + return true; + if (mutator(&tn->arrayBounds, context)) + return true; + /* type name itself is deemed uninteresting */ + } + break; + case T_ColumnDef: + { + ColumnDef *coldef = (ColumnDef *) node; + + if (mutator(&coldef->typeName, context)) + return true; + if (mutator(&coldef->raw_default, context)) + return true; + if (mutator(&coldef->collClause, context)) + return true; + /* for now, constraints are ignored */ + } + break; + case T_IndexElem: + { + IndexElem *indelem = (IndexElem *) node; + + if (mutator(&indelem->expr, context)) + return true; + /* collation and opclass names are deemed uninteresting */ + } + break; + case T_GroupingSet: + return mutator(&((GroupingSet *) node)->content, context); + case T_LockingClause: + return mutator(&((LockingClause *) node)->lockedRels, context); + case T_XmlSerialize: + { + XmlSerialize *xs = (XmlSerialize *) node; + + if (mutator(&xs->expr, context)) + return true; + if (mutator(&xs->typeName, context)) + return true; + } + break; + case T_WithClause: + return mutator(&((WithClause *) node)->ctes, context); + case T_InferClause: + { + InferClause *stmt = (InferClause *) node; + + if (mutator(&stmt->indexElems, context)) + return true; + if (mutator(&stmt->whereClause, context)) + return true; + } + break; + case T_OnConflictClause: + { + OnConflictClause *stmt = (OnConflictClause *) node; + + if (mutator(&stmt->infer, context)) + return true; + if (mutator(&stmt->targetList, context)) + return true; + if (mutator(&stmt->whereClause, context)) + return true; + } + break; + case T_CommonTableExpr: + return mutator(&((CommonTableExpr *) node)->ctequery, context); + default: + return true; + } + return false; +} + /* * planstate_tree_walker --- walk plan state trees * diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index f8d43dbf99..05bce204f3 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -2505,6 +2505,44 @@ _outSelectStmt(StringInfo str, const SelectStmt *node) WRITE_NODE_FIELD(rarg); } +static void +_outInsertStmt(StringInfo str, const InsertStmt *node) +{ + WRITE_NODE_TYPE("INSERT"); + + WRITE_NODE_FIELD(relation); + WRITE_NODE_FIELD(cols); + WRITE_NODE_FIELD(selectStmt); + WRITE_NODE_FIELD(onConflictClause); + WRITE_NODE_FIELD(returningList); + WRITE_NODE_FIELD(withClause); +} + +static void +_outDeleteStmt(StringInfo str, const DeleteStmt *node) +{ + WRITE_NODE_TYPE("DELETE"); + + WRITE_NODE_FIELD(relation); + WRITE_NODE_FIELD(usingClause); + WRITE_NODE_FIELD(whereClause); + WRITE_NODE_FIELD(returningList); + WRITE_NODE_FIELD(withClause); +} + +static void +_outUpdateStmt(StringInfo str, const UpdateStmt *node) +{ + WRITE_NODE_TYPE("UPDATE"); + + WRITE_NODE_FIELD(relation); + WRITE_NODE_FIELD(targetList); + WRITE_NODE_FIELD(whereClause); + WRITE_NODE_FIELD(fromClause); + WRITE_NODE_FIELD(returningList); + WRITE_NODE_FIELD(withClause); +} + static void _outFuncCall(StringInfo str, const FuncCall *node) { @@ -3733,6 +3771,15 @@ outNode(StringInfo str, const void *obj) case T_SelectStmt: _outSelectStmt(str, obj); break; + case T_UpdateStmt: + _outUpdateStmt(str, obj); + break; + case T_DeleteStmt: + _outDeleteStmt(str, obj); + break; + case T_InsertStmt: + _outInsertStmt(str, obj); + break; case T_ColumnDef: _outColumnDef(str, obj); break; diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index f6be98bdd4..94cbbf8a64 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -42,11 +42,13 @@ #include "catalog/pg_type.h" #include "commands/async.h" #include "commands/prepare.h" +#include "commands/defrem.h" #include "libpq/libpq.h" #include "libpq/pqformat.h" #include "libpq/pqsignal.h" #include "miscadmin.h" #include "nodes/print.h" +#include "nodes/nodeFuncs.h" #include "optimizer/planner.h" #include "pgstat.h" #include "pg_trace.h" @@ -69,6 +71,7 @@ #include "tcop/utility.h" #include "utils/lsyscache.h" #include "utils/memutils.h" +#include "utils/builtins.h" #include "utils/ps_status.h" #include "utils/snapmgr.h" #include "utils/timeout.h" @@ -188,6 +191,7 @@ static bool IsTransactionStmtList(List *parseTrees); static void drop_unnamed_stmt(void); static void SigHupHandler(SIGNAL_ARGS); static void log_disconnections(int code, Datum arg); +static bool exec_cached_query(const char* query, Node* parse_tree); /* ---------------------------------------------------------------- @@ -950,6 +954,14 @@ exec_simple_query(const char *query_string) */ isTopLevel = (list_length(parsetree_list) == 1); + /* + * Try to find cached plan + */ + if (isTopLevel && autoprepare_threshold != 0 && exec_cached_query(query_string, linitial(parsetree_list))) + { + return; + } + /* * Run through the raw parsetree(s) and process each one. */ @@ -4500,3 +4512,848 @@ log_disconnections(int code, Datum arg) port->user_name, port->database_name, port->remote_host, port->remote_port[0] ? " port=" : "", port->remote_port))); } + +/* + * Autoprepare implementation. + * It combines exec_parse_message + exec_bind_message + exec_execute_message + */ + +/* + * Plan cache entry + */ +typedef struct { + Node* parse_tree; /* tree is used as hash key */ + dlist_node lru; /* double linked list to implement LRU */ + int64 exec_count; /* counter of execution of this query */ + CachedPlanSource* plan; + uint32 hash; /* hash calculated for this parsed tree */ + int n_params; /* number of parameters extracted for this query */ + int16 format; /* portal output format */ + bool disable_autoprepare; /* disable preparing of this query */ +} plan_cache_entry; + +static uint32 plan_cache_hash_fn(const void *key, Size keysize) +{ + return ((plan_cache_entry*)key)->hash; +} + +static int plan_cache_match_fn(const void *key1, const void *key2, Size keysize) +{ + return !equal(((plan_cache_entry*)key1)->parse_tree, ((plan_cache_entry*)key2)->parse_tree); +} + +static void* plan_cache_keycopy_fn(void *dest, const void *src, Size keysize) +{ + plan_cache_entry* dst_entry = (plan_cache_entry*)dest; + plan_cache_entry* src_entry = (plan_cache_entry*)src; + dst_entry->parse_tree = copyObject(src_entry->parse_tree); + dst_entry->hash = src_entry->hash; + return dest; +} + +#define PLAN_CACHE_SIZE 113 + +/* + * Plan cache access statistic + */ +size_t n_plan_cache_hits; +size_t n_plan_cache_misses; +size_t n_cached_queries; + +/* + * Mapping between parameters and replaced literals + */ +typedef struct ConstParam { + A_Const* literal; /* Original literal */ + ParamRef* param; /* Constructed parameter reference */ + Node** ref; /* Pointer to pointer to literal node (used to revert parse tree update) */ + struct ConstParam* next; /* L1-list of query parameters */ +} ConstParam; + +/* + * Context for raw_expression_tree_mutator + */ +typedef struct { + int n_params; /* Number of extracted parameters */ + uint32 hash; /* We calculate hash for parse tree during plan traversal */ + ConstParam** param_list_tail; /* pointer to last element "next" field address, used to contruct L1 list of parameters */ +} GeneralizerCtx; + +/* + * Check if expression is constant (used to eliminate substitution of literals with parameters in such expressions + */ +static bool is_constant_expression(Node* node) +{ + return node != NULL + && (IsA(node, A_Const) + || (IsA(node, A_Expr) + && is_constant_expression(((A_Expr*)node)->lexpr) + && is_constant_expression(((A_Expr*)node)->rexpr))); +} + +/* + * Callback for raw_expression_tree_mutator performing susbtitution of literals with paramaters + */ +static bool +query_plan_generalizer(Node** ref, void *context) +{ + Node* node = *ref; + GeneralizerCtx* ctx = (GeneralizerCtx*)context; + if (node == NULL) + { + return false; + } + /* + * Calculate hash for parse tree. We consider only node tags here, precise comparion of trees is done using equal() function. + * Here we calculate hash for original (unpatched) tree, without ParamRef nodes. + * It is non priniciple, because hash calculation doesn't take in account types and values of Const nodes. So the same generalized queries + * will have the same hash value. There are about 1000 dirrent nodes tags, this is why we rotate hash on 10 bits. + */ + ctx->hash = (ctx->hash << 10) ^ (ctx->hash >> 22) ^ nodeTag(node); + + switch (nodeTag(node)) + { + case T_A_Expr: + { + /* + * Do not perform substitution of literals in constant expression (which is likely to be the the same for all queries and optimized by compiler) + */ + if (!is_constant_expression(node)) + { + A_Expr *expr = (A_Expr *) node; + if (query_plan_generalizer((Node**)&expr->lexpr, context)) + return true; + if (query_plan_generalizer((Node**)&expr->rexpr, context)) + return true; + } + break; + } + case T_A_Const: + { + /* + * Do sunstitution of literals with parameters here + */ + A_Const* literal = (A_Const*)node; + ConstParam* cp = palloc(sizeof(ConstParam)); + ParamRef* param = makeNode(ParamRef); + param->number = ++ctx->n_params; + param->location = literal->location; + cp->ref = ref; + cp->param = param; + cp->literal = literal; + *ctx->param_list_tail = cp; + ctx->param_list_tail = &cp->next; + *ref = (Node*)param; + break; + } + case T_SelectStmt: + { + /* + * Substitute literals onlu in WHERE, VALUES and WITH clause, + * skipping target and from lists, which is unlikely contains some parameterized values + */ + SelectStmt *stmt = (SelectStmt *) node; + if (query_plan_generalizer((Node**)&stmt->targetList, context)) + return true; + if (query_plan_generalizer((Node**)&stmt->whereClause, context)) + return true; + if (query_plan_generalizer((Node**)&stmt->valuesLists, context)) + return true; + if (query_plan_generalizer((Node**)&stmt->withClause, context)) + return true; + if (query_plan_generalizer((Node**)&stmt->larg, context)) + return true; + if (query_plan_generalizer((Node**)&stmt->rarg, context)) + return true; + break; + } + case T_TypeName: + case T_SortGroupClause: + case T_SortBy: + case T_A_ArrayExpr: + /* + * Literals in this clauses should not be replaced with parameters + */ + break; + default: + /* + * Default traversal. raw_expression_tree_mutator returns true for all not recognized nodes, for example right now + * all transaction control statements are not covered by raw_expression_tree_mutator and so will not pe autoprepared. + * My experiments show that effect of non-preparing start/commit transaction statements is positive. + */ + return raw_expression_tree_mutator(node, query_plan_generalizer, context); + } + return false; +} + +/* + * Restore original parse tree, replacing all ParamRef back with Const nodes. + * Such undo operation seems to be more efficient than copying the whole parse tree by raw_expression_tree_mutator + */ +static void undo_query_plan_changes(Node* parse_tree, ConstParam* cp) +{ + while (cp != NULL) { + *cp->ref = (Node*)cp->literal; + cp = cp->next; + } + n_plan_cache_misses += 1; +} + +/* + * Callback for raw_expression_tree_walker droping parse tree + */ +static bool drop_tree_node(Node* node, void* context) +{ + if (node) { + raw_expression_tree_walker(node, drop_tree_node, NULL); + pfree(node); + } + return false; +} + +/* + * Location of converted literal in query. + * Used for precise error reporting (line number) + */ +static int param_location; + +/* + * Error callback adding information about error location + */ +static void +prepare_error_callback(void *arg) +{ + CachedPlanSource *psrc = (CachedPlanSource*)arg; + /* And pass it to the ereport mechanism */ + if (geterrcode() != ERRCODE_QUERY_CANCELED) { + int pos = pg_mbstrlen_with_len(psrc->query_string, param_location) + 1; + (void)errposition(pos); + } +} + +/* + * Try to generalize query, find cached plan for it and execute + */ + static bool exec_cached_query(const char *query_string, Node* parse_tree) +{ + CommandDest dest = whereToSendOutput; + DestReceiver *receiver; + int n_params; + plan_cache_entry *entry; + bool found; + MemoryContext old_context; + CachedPlanSource *psrc; + ParamListInfo params; + int paramno; + CachedPlan *cplan; + Portal portal; + bool was_logged = false; + bool is_xact_command; + bool execute_is_fetch; + char completion_tag[COMPLETION_TAG_BUFSIZE]; + bool save_log_statement_stats = log_statement_stats; + ParamListInfo portal_params; + const char *source_text; + char msec_str[32]; + bool snapshot_set = false; + GeneralizerCtx ctx; + ConstParam* const_param; + ConstParam* const_param_list; + plan_cache_entry pattern; + + static HTAB* plan_cache; /* hash table for plan cache */ + static dlist_head lru; /* LRU L2-list for cached queries */ + static MemoryContext plan_cache_context; /* memory context used for plan cache */ + + /* + * Substitute literals with parameters and calculate hash for parse tree + */ + ctx.param_list_tail = &const_param_list; + ctx.n_params = 0; + ctx.hash = 0; + if (query_plan_generalizer((Node**)&parse_tree, &ctx)) { + *ctx.param_list_tail = NULL; + undo_query_plan_changes(parse_tree, const_param_list); + return false; + } + *ctx.param_list_tail = NULL; + n_params = ctx.n_params; + + /* + * Construct plan cache context if not constructed yet. + */ + if (plan_cache_context == NULL) { + plan_cache_context = AllocSetContextCreate(TopMemoryContext, + "plan cache context", + ALLOCSET_DEFAULT_SIZES); + } + /* Manipulations with hash table are performed in plan_cache_context memory context */ + old_context = MemoryContextSwitchTo(plan_cache_context); + + /* + * Initialize hash table if not initialized yet + */ + if (plan_cache == NULL) + { + static HASHCTL info; + info.keysize = sizeof(plan_cache_entry); + info.entrysize = sizeof(plan_cache_entry); + info.hash = plan_cache_hash_fn; + info.match = plan_cache_match_fn; + info.keycopy = plan_cache_keycopy_fn; + plan_cache = hash_create("plan_cache", autoprepare_limit != 0 ? autoprepare_limit : PLAN_CACHE_SIZE, + &info, HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_KEYCOPY); + dlist_init(&lru); + } + + /* + * Lookup generalized query + */ + pattern.parse_tree = parse_tree; + pattern.hash = ctx.hash; + entry = (plan_cache_entry*)hash_search(plan_cache, &pattern, HASH_ENTER, &found); + if (!found) + { + /* Check number of cached queries */ + if (++n_cached_queries > autoprepare_limit && autoprepare_limit != 0) + { + /* Drop least recently access query */ + plan_cache_entry* victim = dlist_container(plan_cache_entry, lru, lru.head.prev); + Node* dropped_tree = victim->parse_tree; + dlist_delete(&victim->lru); + DropCachedPlan(victim->plan); + hash_search(plan_cache, victim, HASH_REMOVE, NULL); + raw_expression_tree_walker(dropped_tree, drop_tree_node, NULL); + n_cached_queries -= 1; + } + entry->exec_count = 0; + entry->plan = NULL; + entry->disable_autoprepare = false; + } + else + { + dlist_delete(&entry->lru); /* accessed entry will be moved to the head of LRU list */ + if (entry->plan != NULL && !entry->plan->is_valid) { + /* Drop invalidated plan: it will be reconstructed later */ + DropCachedPlan(entry->plan); + entry->plan = NULL; + } + } + dlist_insert_after(&lru.head, &entry->lru); /* prepend entry to the head of LRU list */ + MemoryContextSwitchTo(old_context); /* Done with plan_cache_context memory context */ + + /* + * Prepare query only when it is executed more than autoprepare_threshold times + */ + if (entry->disable_autoprepare || entry->exec_count++ < autoprepare_threshold) + { + undo_query_plan_changes(parse_tree, const_param_list); + return false; + } + if (entry->plan == NULL) + { + /* + * Prepare new plan + */ + const char *command_tag; + Query *query; + List *querytree_list; + Oid *param_types = NULL; + int num_params = 0; + + /* + * Switch to appropriate context for constructing parsetrees. + */ + old_context = MemoryContextSwitchTo(MessageContext); + + /* + * Get the command name for possible use in status display. + */ + command_tag = CreateCommandTag(parse_tree); + + /* + * If we are in an aborted transaction, reject all commands except + * COMMIT/ROLLBACK. It is important that this test occur before we + * try to do parse analysis, rewrite, or planning, since all those + * phases try to do database accesses, which may fail in abort state. + * (It might be safe to allow some additional utility commands in this + * state, but not many...) + */ + if (IsAbortedTransactionBlockState() && + !IsTransactionExitStmt(parse_tree)) + ereport(ERROR, + (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), + errmsg("current transaction is aborted, " + "commands ignored until end of transaction block"), + errdetail_abort())); + + /* + * Create the CachedPlanSource before we do parse analysis, since it + * needs to see the unmodified raw parse tree. + */ + psrc = CreateCachedPlan(parse_tree, query_string, command_tag); + + /* + * Set up a snapshot if parse analysis will need one. + */ + if (analyze_requires_snapshot(parse_tree)) + { + PushActiveSnapshot(GetTransactionSnapshot()); + snapshot_set = true; + } + + /* + * Analyze and rewrite the query. Note that the originally specified + * parameter set is not required to be complete, so we have to use + * parse_analyze_varparams(). + */ + if (log_parser_stats) { + ResetUsage(); + } + + PG_TRY(); + { + query = parse_analyze_varparams(parse_tree, + query_string, + ¶m_types, + &num_params); + } + PG_CATCH(); + { + /* + * In case of analyze errors revert back to original query processing + * and disable autoprepare for this query to avoid such problems in future. + */ + FlushErrorState(); + if (snapshot_set) { + PopActiveSnapshot(); + } + entry->disable_autoprepare = true; + undo_query_plan_changes(parse_tree, const_param_list); + MemoryContextSwitchTo(old_context); + return false; + } + PG_END_TRY(); + + Assert(num_params == n_params); + + /* + * Check all parameter types got determined. + */ + for (paramno = 0, const_param = const_param_list; + paramno < n_params; + paramno++, const_param = const_param->next) + { + Oid ptype = param_types[paramno]; + + /* + * Check if type of parameter can be infered from query and is compatible with actual literal type. + * We explicitly exclude some cases when parameter type is wrongly assumed to be TEXT. + * Hopefully there will be few such misdetections in real queries. + */ + if (ptype == InvalidOid || ptype == UNKNOWNOID + || (ptype == TEXTOID && (const_param->literal->val.type == T_BitString || const_param->literal->val.type == T_Integer))) + { + /* Type of parameter can not be determined: disable autoprepare for this query. */ + if (snapshot_set) { + PopActiveSnapshot(); + } + entry->disable_autoprepare = true; + undo_query_plan_changes(parse_tree, const_param_list); + MemoryContextSwitchTo(old_context); + return false; + } + } + + if (log_parser_stats) { + ShowUsage("PARSE ANALYSIS STATISTICS"); + } + + querytree_list = pg_rewrite_query(query); + + /* Done with the snapshot used for parsing */ + if (snapshot_set) { + PopActiveSnapshot(); + snapshot_set = false; + } + + CompleteCachedPlan(psrc, + querytree_list, + NULL, + param_types, + n_params, + NULL, + NULL, + CURSOR_OPT_PARALLEL_OK, /* allow parallel mode */ + true); /* fixed result */ + + /* If we got a cancel signal during analysis, quit */ + CHECK_FOR_INTERRUPTS(); + + entry->format = 0; /* TEXT is default */ + if (IsA(parse_tree, FetchStmt)) + { + FetchStmt *stmt = (FetchStmt *)parse_tree; + + if (!stmt->ismove) + { + Portal fportal = GetPortalByName(stmt->portalname); + + if (PortalIsValid(fportal) && + (fportal->cursorOptions & CURSOR_OPT_BINARY)) + entry->format = 1; /* BINARY */ + } + } + + /* + * Register cached plan for invalidation mechanism + */ + SaveCachedPlan(psrc); + entry->plan = psrc; + entry->n_params = n_params; + + MemoryContextSwitchTo(old_context); /* Done with message context */ + + /* + * We do NOT close the open transaction command here; that only happens + * when the client sends Sync. Instead, do CommandCounterIncrement just + * in case something happened during parse/plan. + */ + CommandCounterIncrement(); + } + else + { + /* Plan found */ + psrc = entry->plan; + Assert(n_params == entry->n_params); + } + + /* + * If we are in aborted transaction state, the only portals we can + * actually run are those containing COMMIT or ROLLBACK commands. We + * disallow binding anything else to avoid problems with infrastructure + * that expects to run inside a valid transaction. We also disallow + * binding any parameters, since we can't risk calling user-defined I/O + * functions. + */ + if (IsAbortedTransactionBlockState() && + (!IsTransactionExitStmt(psrc->raw_parse_tree) || + n_params != 0)) + ereport(ERROR, + (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), + errmsg("current transaction is aborted, " + "commands ignored until end of transaction block"), + errdetail_abort())); + + /* + * Create unnamed portal to run the query or queries in. If there + * already is one, silently drop it. + */ + portal = CreatePortal("", true, true); + /* Don't display the portal in pg_cursors */ + portal->visible = false; + + /* + * Prepare to copy stuff into the portal's memory context. We do all this + * copying first, because it could possibly fail (out-of-memory) and we + * don't want a failure to occur between GetCachedPlan and + * PortalDefineQuery; that would result in leaking our plancache refcount. + */ + old_context = MemoryContextSwitchTo(PortalGetHeapMemory(portal)); + + /* Copy the plan's query string into the portal */ + query_string = pstrdup(psrc->query_string); + + /* + * Set a snapshot if we have parameters to fetch (since the input + * functions might need it) or the query isn't a utility command (and + * hence could require redoing parse analysis and planning). We keep the + * snapshot active till we're done, so that plancache.c doesn't have to + * take new ones. + */ + if (n_params > 0 || + (psrc->raw_parse_tree && + analyze_requires_snapshot(psrc->raw_parse_tree))) + { + PushActiveSnapshot(GetTransactionSnapshot()); + snapshot_set = true; + } + + /* + * Fetch parameters, if any, and store in the portal's memory context. + */ + if (n_params > 0) + { + ErrorContextCallback errcallback; + Oid typinput; + Oid typioparam; + char buf[64]; + + /* + * Register error callback to precisely report error in case of conversion error while storig parameter value. + */ + errcallback.callback = prepare_error_callback; + errcallback.arg = (void *) psrc; + errcallback.previous = error_context_stack; + error_context_stack = &errcallback; + + params = (ParamListInfo) palloc(offsetof(ParamListInfoData, params) + + n_params * sizeof(ParamExternData)); + params->paramFetch = NULL; + params->paramFetchArg = NULL; + params->parserSetup = NULL; + params->parserSetupArg = NULL; + params->numParams = n_params; + params->paramMask = NULL; + + for (paramno = 0, const_param = const_param_list; + paramno < n_params; + paramno++, const_param = const_param->next) + { + Oid ptype = psrc->param_types[paramno]; + + + param_location = const_param->literal->location; + + params->params[paramno].isnull = false; + + /* Convert literal value to parameter value */ + switch (const_param->literal->val.type) + { + /* + * Convert from integer literal + */ + case T_Integer: + switch (ptype) { + case INT8OID: + params->params[paramno].value = Int64GetDatum((int64)const_param->literal->val.val.ival); + break; + case INT4OID: + params->params[paramno].value = Int32GetDatum((int32)const_param->literal->val.val.ival); + break; + case INT2OID: + if (const_param->literal->val.val.ival < SHRT_MIN + || const_param->literal->val.val.ival > SHRT_MAX) + { + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallint out of range"))); + } + params->params[paramno].value = Int16GetDatum((int16)const_param->literal->val.val.ival); + break; + case FLOAT4OID: + params->params[paramno].value = Float4GetDatum((float)const_param->literal->val.val.ival); + break; + case FLOAT8OID: + params->params[paramno].value = Float8GetDatum((double)const_param->literal->val.val.ival); + break; + case INT4RANGEOID: + sprintf(buf, "[%ld,%ld]", const_param->literal->val.val.ival, const_param->literal->val.val.ival); + getTypeInputInfo(ptype, &typinput, &typioparam); + params->params[paramno].value = OidInputFunctionCall(typinput, buf, typioparam, -1); + break; + default: + pg_lltoa(const_param->literal->val.val.ival, buf); + getTypeInputInfo(ptype, &typinput, &typioparam); + params->params[paramno].value = OidInputFunctionCall(typinput, buf, typioparam, -1); + } + break; + case T_Null: + params->params[paramno].isnull = true; + break; + default: + /* + * Convert from string literal + */ + getTypeInputInfo(ptype, &typinput, &typioparam); + params->params[paramno].value = OidInputFunctionCall(typinput, const_param->literal->val.val.str, typioparam, -1); + } + /* + * We mark the params as CONST. This ensures that any custom plan + * makes full use of the parameter values. + */ + params->params[paramno].pflags = PARAM_FLAG_CONST; + params->params[paramno].ptype = ptype; + } + error_context_stack = errcallback.previous; + } else { + params = NULL; + } + + /* Done storing stuff in portal's context */ + MemoryContextSwitchTo(old_context); + + /* + * Obtain a plan from the CachedPlanSource. Any cruft from (re)planning + * will be generated in MessageContext. The plan refcount will be + * assigned to the Portal, so it will be released at portal destruction. + */ + cplan = GetCachedPlan(psrc, params, false); + + /* + * Now we can define the portal. + * + * DO NOT put any code that could possibly throw an error between the + * above GetCachedPlan call and here. + */ + PortalDefineQuery(portal, + NULL, + query_string, + psrc->commandTag, + cplan->stmt_list, + cplan); + + /* Done with the snapshot used for parameter I/O and parsing/planning */ + if (snapshot_set) { + PopActiveSnapshot(); + } + + /* + * And we're ready to start portal execution. + */ + PortalStart(portal, params, 0, InvalidSnapshot); + + /* + * Apply the result format requests to the portal. + */ + PortalSetResultFormat(portal, 1, &entry->format); + + /* Does the portal contain a transaction command? */ + is_xact_command = IsTransactionStmtList(portal->stmts); + + /* + * We must copy the sourceText into MessageContext in + * case the portal is destroyed during finish_xact_command. Can avoid the + * copy if it's not an xact command, though. + */ + if (is_xact_command) + { + source_text = pstrdup(portal->sourceText); + /* + * An xact command shouldn't have any parameters, which is a good + * thing because they wouldn't be around after finish_xact_command. + */ + portal_params = NULL; + } + else + { + source_text = portal->sourceText; + portal_params = portal->portalParams; + } + + /* + * Report query to various monitoring facilities. + */ + debug_query_string = source_text; + + pgstat_report_activity(STATE_RUNNING, source_text); + + set_ps_display(portal->commandTag, false); + + if (save_log_statement_stats) { + ResetUsage(); + } + + BeginCommand(portal->commandTag, dest); + + PortalSetResultFormat(portal, 1, &entry->format); + + + /* + * Create dest receiver in MessageContext (we don't want it in transaction + * context, because that may get deleted if portal contains VACUUM). + */ + receiver = CreateDestReceiver(dest); + if (dest == DestRemote) { + SetRemoteDestReceiverParams(receiver, portal); + } + + /* + * If we re-issue an Execute protocol request against an existing portal, + * then we are only fetching more rows rather than completely re-executing + * the query from the start. atStart is never reset for a v3 portal, so we + * are safe to use this check. + */ + execute_is_fetch = !portal->atStart; + + /* Log immediately if dictated by log_statement */ + if (check_log_statement(portal->stmts)) + { + ereport(LOG, + (errmsg("%s %s%s%s: %s", + execute_is_fetch ? + _("execute fetch from") : + _("execute"), + "", + "", + "", + source_text), + errhidestmt(true), + errdetail_params(portal_params))); + was_logged = true; + } + + /* Check for cancel signal before we start execution */ + CHECK_FOR_INTERRUPTS(); + + /* + * Run the portal to completion, and then drop it (and the receiver). + */ + (void) PortalRun(portal, + FETCH_ALL, + true, + receiver, + receiver, + completion_tag); + + (*receiver->rDestroy) (receiver); + + PortalDrop(portal, false); + + /* + * Tell client that we're done with this query. Note we emit exactly + * one EndCommand report for each raw parsetree, thus one for each SQL + * command the client sent, regardless of rewriting. (But a command + * aborted by error will not send an EndCommand report at all.) + */ + EndCommand(completion_tag, dest); + + /* + * Close down transaction statement, if one is open. + */ + finish_xact_command(); + + /* + * Emit duration logging if appropriate. + */ + switch (check_log_duration(msec_str, was_logged)) + { + case 1: + ereport(LOG, + (errmsg("duration: %s ms", msec_str), + errhidestmt(true))); + break; + case 2: + ereport(LOG, + (errmsg("duration: %s ms %s %s%s%s: %s", + msec_str, + execute_is_fetch ? + _("execute fetch from") : + _("execute"), + "", + "", + "", + source_text), + errhidestmt(true), + errdetail_params(portal_params))); + break; + } + + if (save_log_statement_stats) { + ShowUsage("EXECUTE MESSAGE STATISTICS"); + } + debug_query_string = NULL; + n_plan_cache_hits += 1; + + return true; +} diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index 4f1891f844..859476fdc8 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -450,6 +450,10 @@ int tcp_keepalives_idle; int tcp_keepalives_interval; int tcp_keepalives_count; + +int autoprepare_threshold; +int autoprepare_limit; + /* * SSL renegotiation was been removed in PostgreSQL 9.5, but we tolerate it * being set to zero (meaning never renegotiate) for backward compatibility. @@ -1949,6 +1953,28 @@ static struct config_int ConfigureNamesInt[] = check_max_stack_depth, assign_max_stack_depth, NULL }, + /* + * Threshold for implicit preparing of frequently executed queries + */ + { + {"autoprepare_threshold", PGC_USERSET, QUERY_TUNING_OTHER, + gettext_noop("Threshold for autopreparing query."), + gettext_noop("0 value disables autoprepare."), + }, + &autoprepare_threshold, + 0, 0, INT_MAX, + NULL, NULL, NULL + }, + { + {"autoprepare_limit", PGC_USERSET, QUERY_TUNING_OTHER, + gettext_noop("Maximal number of autoprepared queries."), + gettext_noop("0 means unlimited number of autoprepared queries."), + }, + &autoprepare_limit, + 0, 0, INT_MAX, + NULL, NULL, NULL + }, + { {"temp_file_limit", PGC_SUSET, RESOURCES_DISK, gettext_noop("Limits the total size of all temporary files used by each process."), diff --git a/src/include/nodes/nodeFuncs.h b/src/include/nodes/nodeFuncs.h index 97af142929..29a5216356 100644 --- a/src/include/nodes/nodeFuncs.h +++ b/src/include/nodes/nodeFuncs.h @@ -73,8 +73,11 @@ extern Node *query_or_expression_tree_mutator(Node *node, Node *(*mutator) (), extern bool raw_expression_tree_walker(Node *node, bool (*walker) (), void *context); +extern bool raw_expression_tree_mutator(Node *node, bool (*mutator) (), + void *context); struct PlanState; extern bool planstate_tree_walker(struct PlanState *planstate, bool (*walker) (), void *context); + #endif /* NODEFUNCS_H */ diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h index 0bf9f21067..f035ce737b 100644 --- a/src/include/utils/guc.h +++ b/src/include/utils/guc.h @@ -252,6 +252,9 @@ extern int client_min_messages; extern int log_min_duration_statement; extern int log_temp_files; +extern int autoprepare_threshold; +extern int autoprepare_limit; + extern int temp_file_limit; extern int num_temp_buffers; From d56b8b41b32b3f5c576d6fc2b2c9af3ae4b55511 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 2 May 2017 18:05:54 -0400 Subject: [PATCH 0033/1139] Ensure commands in extension scripts see the results of preceding DDL. Due to a missing CommandCounterIncrement() call, parsing of a non-utility command in an extension script would not see the effects of the immediately preceding DDL command, unless that command's execution ends with CommandCounterIncrement() internally ... which some do but many don't. Report by Philippe Beaudoin, diagnosis by Julien Rouhaud. Rather remarkably, this bug has evaded detection since extensions were invented, so back-patch to all supported branches. Discussion: https://postgr.es/m/2cf7941e-4e41-7714-3de8-37b1a8f74dff@free.fr --- src/backend/commands/extension.c | 3 +++ src/test/modules/test_extensions/test_ext3--1.0.sql | 6 ++++++ 2 files changed, 9 insertions(+) diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c index 33b0de0a76..4b923c205e 100644 --- a/src/backend/commands/extension.c +++ b/src/backend/commands/extension.c @@ -706,6 +706,9 @@ execute_sql_string(const char *sql, const char *filename) List *stmt_list; ListCell *lc2; + /* Be sure parser can see any DDL done so far */ + CommandCounterIncrement(); + stmt_list = pg_analyze_and_rewrite(parsetree, sql, NULL, diff --git a/src/test/modules/test_extensions/test_ext3--1.0.sql b/src/test/modules/test_extensions/test_ext3--1.0.sql index 7dec684dcb..4fcb63d2bc 100644 --- a/src/test/modules/test_extensions/test_ext3--1.0.sql +++ b/src/test/modules/test_extensions/test_ext3--1.0.sql @@ -1,3 +1,9 @@ /* src/test/modules/test_extensions/test_ext3--1.0.sql */ -- complain if script is sourced in psql, rather than via CREATE EXTENSION \echo Use "CREATE EXTENSION test_ext3" to load this file. \quit + +CREATE TABLE test_ext3_table (col_old INT); + +ALTER TABLE test_ext3_table RENAME col_old TO col_new; + +UPDATE test_ext3_table SET col_new = 0; From c521d5a8d7bb014171e328976643367c170dc8f3 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 2 May 2017 21:50:35 -0400 Subject: [PATCH 0034/1139] Improve performance of timezone loading, especially pg_timezone_names view. tzparse() would attempt to load the "posixrules" timezone database file on each call. That might seem like it would only be an issue when selecting a POSIX-style zone name rather than a zone defined in the timezone database, but it turns out that each zone definition file contains a POSIX-style zone string and tzload() will call tzparse() to parse that. Thus, when scanning the whole timezone file tree as we do in the pg_timezone_names view, "posixrules" was read repetitively for each zone definition file. Fix that by caching the file on first use within any given process. (We cache other zone definitions for the life of the process, so there seems little reason not to cache this one as well.) This probably won't help much in processes that never run pg_timezone_names, but even one additional SET of the timezone GUC would come out ahead. An even worse problem for pg_timezone_names is that pg_open_tzfile() has an inefficient way of identifying the canonical case of a zone name: it basically re-descends the directory tree to the zone file. That's not awful for an individual "SET timezone" operation, but it's pretty horrid when we're inspecting every zone in the database. And it's pointless too because we already know the canonical spelling, having just read it from the filesystem. Fix by teaching pg_open_tzfile() to avoid the directory search if it's not asked for the canonical name, and backfilling the proper result in pg_tzenumerate_next(). In combination these changes seem to make the pg_timezone_names view about 3x faster to read, for me. Since a scan of pg_timezone_names has up to now been one of the slowest queries in the regression tests, this should help some little bit for buildfarm cycle times. Back-patch to all supported branches, not so much because it's likely that users will care much about the view's performance as because tracking changes in the upstream IANA timezone code is really painful if we don't keep all the branches in sync. Discussion: https://postgr.es/m/27962.1493671706@sss.pgh.pa.us --- src/timezone/README | 3 +++ src/timezone/localtime.c | 23 +++++++++++++++++++++- src/timezone/pgtz.c | 42 +++++++++++++++++++++++++++++++++------- 3 files changed, 60 insertions(+), 8 deletions(-) diff --git a/src/timezone/README b/src/timezone/README index 2544230c4c..912e0c1b39 100644 --- a/src/timezone/README +++ b/src/timezone/README @@ -79,6 +79,9 @@ other exposed names. slightly modified the API of the former, in part because it now relies on our own pg_open_tzfile() rather than opening files for itself. +* tzparse() is adjusted to cache the result of loading the TZDEFRULES +zone, so that that's not repeated more than once per process. + * There's a fair amount of code we don't need and have removed, including all the nonstandard optional APIs. We have also added a few functions of our own at the bottom of localtime.c. diff --git a/src/timezone/localtime.c b/src/timezone/localtime.c index 6e0fa10066..04105b2c96 100644 --- a/src/timezone/localtime.c +++ b/src/timezone/localtime.c @@ -54,6 +54,13 @@ static const char gmt[] = "GMT"; static const pg_time_t time_t_min = MINVAL(pg_time_t, TYPE_BIT(pg_time_t)); static const pg_time_t time_t_max = MAXVAL(pg_time_t, TYPE_BIT(pg_time_t)); +/* + * We cache the result of trying to load the TZDEFRULES zone here. + * tzdefrules_loaded is 0 if not tried yet, +1 if good, -1 if failed. + */ +static struct state tzdefrules_s; +static int tzdefrules_loaded = 0; + /* * The DST rules to use if TZ has no rules and we can't load TZDEFRULES. * We default to US rules as of 1999-08-17. @@ -942,7 +949,21 @@ tzparse(const char *name, struct state * sp, bool lastditch) charcnt = stdlen + 1; if (sizeof sp->chars < charcnt) return false; - load_ok = tzload(TZDEFRULES, NULL, sp, false) == 0; + + /* + * This bit also differs from the IANA code, which doesn't make any + * attempt to avoid repetitive loadings of the TZDEFRULES zone. + */ + if (tzdefrules_loaded == 0) + { + if (tzload(TZDEFRULES, NULL, &tzdefrules_s, false) == 0) + tzdefrules_loaded = 1; + else + tzdefrules_loaded = -1; + } + load_ok = (tzdefrules_loaded > 0); + if (load_ok) + memcpy(sp, &tzdefrules_s, sizeof(struct state)); } if (!load_ok) sp->leapcnt = 0; /* so, we're off a little */ diff --git a/src/timezone/pgtz.c b/src/timezone/pgtz.c index 982fc1fe71..9356f2592d 100644 --- a/src/timezone/pgtz.c +++ b/src/timezone/pgtz.c @@ -80,12 +80,37 @@ pg_open_tzfile(const char *name, char *canonname) int fullnamelen; int orignamelen; + /* Initialize fullname with base name of tzdata directory */ + strlcpy(fullname, pg_TZDIR(), sizeof(fullname)); + orignamelen = fullnamelen = strlen(fullname); + + if (fullnamelen + 1 + strlen(name) >= MAXPGPATH) + return -1; /* not gonna fit */ + + /* + * If the caller doesn't need the canonical spelling, first just try to + * open the name as-is. This can be expected to succeed if the given name + * is already case-correct, or if the filesystem is case-insensitive; and + * we don't need to distinguish those situations if we aren't tasked with + * reporting the canonical spelling. + */ + if (canonname == NULL) + { + int result; + + fullname[fullnamelen] = '/'; + /* test above ensured this will fit: */ + strcpy(fullname + fullnamelen + 1, name); + result = open(fullname, O_RDONLY | PG_BINARY, 0); + if (result >= 0) + return result; + /* If that didn't work, fall through to do it the hard way */ + } + /* * Loop to split the given name into directory levels; for each level, * search using scan_directory_ci(). */ - strlcpy(fullname, pg_TZDIR(), sizeof(fullname)); - orignamelen = fullnamelen = strlen(fullname); fname = name; for (;;) { @@ -97,8 +122,6 @@ pg_open_tzfile(const char *name, char *canonname) fnamelen = slashptr - fname; else fnamelen = strlen(fname); - if (fullnamelen + 1 + fnamelen >= MAXPGPATH) - return -1; /* not gonna fit */ if (!scan_directory_ci(fullname, fname, fnamelen, fullname + fullnamelen + 1, MAXPGPATH - fullnamelen - 1)) @@ -458,10 +481,11 @@ pg_tzenumerate_next(pg_tzenum *dir) /* * Load this timezone using tzload() not pg_tzset(), so we don't fill - * the cache + * the cache. Also, don't ask for the canonical spelling: we already + * know it, and pg_open_tzfile's way of finding it out is pretty + * inefficient. */ - if (tzload(fullname + dir->baselen, dir->tz.TZname, &dir->tz.state, - true) != 0) + if (tzload(fullname + dir->baselen, NULL, &dir->tz.state, true) != 0) { /* Zone could not be loaded, ignore it */ continue; @@ -473,6 +497,10 @@ pg_tzenumerate_next(pg_tzenum *dir) continue; } + /* OK, return the canonical zone name spelling. */ + strlcpy(dir->tz.TZname, fullname + dir->baselen, + sizeof(dir->tz.TZname)); + /* Timezone loaded OK. */ return &dir->tz; } From 56064d55128024a5ae55427025392bcfd1932609 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 3 May 2017 19:37:01 -0400 Subject: [PATCH 0035/1139] Remove useless and rather expensive stanza in matview regression test. This removes a test case added by commit b69ec7cc9, which was intended to exercise a corner case involving the rule used at that time that materialized views were unpopulated iff they had physical size zero. We got rid of that rule very shortly later, in commit 1d6c72a55, but kept the test case. However, because the case now asks what VACUUM will do to a zero-sized physical file, it would be pretty surprising if the answer were ever anything but "nothing" ... and if things were indeed that broken, surely we'd find it out from other tests. Since the test involves a table that's fairly large by regression-test standards (100K rows), it's quite slow to run. Dropping it should save some buildfarm cycles, so let's do that. Discussion: https://postgr.es/m/32386.1493831320@sss.pgh.pa.us --- src/test/regress/expected/matview.out | 20 -------------------- src/test/regress/sql/matview.sql | 12 ------------ 2 files changed, 32 deletions(-) diff --git a/src/test/regress/expected/matview.out b/src/test/regress/expected/matview.out index 1e34b9b6d7..ef5b21aa3a 100644 --- a/src/test/regress/expected/matview.out +++ b/src/test/regress/expected/matview.out @@ -382,26 +382,6 @@ NOTICE: drop cascades to 3 other objects DETAIL: drop cascades to view mvtest_vt2 drop cascades to materialized view mv_test2 drop cascades to materialized view mv_test3 --- test that vacuum does not make empty matview look unpopulated -CREATE TABLE mvtest_huge (i int); -INSERT INTO mvtest_huge VALUES (generate_series(1,100000)); -CREATE MATERIALIZED VIEW mvtest_hugeview AS SELECT * FROM mvtest_huge WHERE i % 2 = 0; -CREATE INDEX mvtest_hugeviewidx ON mvtest_hugeview (i); -DELETE FROM mvtest_huge; -REFRESH MATERIALIZED VIEW mvtest_hugeview; -SELECT * FROM mvtest_hugeview WHERE i < 10; - i ---- -(0 rows) - -VACUUM ANALYZE mvtest_hugeview; -SELECT * FROM mvtest_hugeview WHERE i < 10; - i ---- -(0 rows) - -DROP TABLE mvtest_huge CASCADE; -NOTICE: drop cascades to materialized view mvtest_hugeview -- test that duplicate values on unique index prevent refresh CREATE TABLE mvtest_foo(a, b) AS VALUES(1, 10); CREATE MATERIALIZED VIEW mvtest_mv AS SELECT * FROM mvtest_foo; diff --git a/src/test/regress/sql/matview.sql b/src/test/regress/sql/matview.sql index e342918a3d..94829b9eaa 100644 --- a/src/test/regress/sql/matview.sql +++ b/src/test/regress/sql/matview.sql @@ -122,18 +122,6 @@ SELECT relispopulated FROM pg_class WHERE oid = 'mv_test3'::regclass; DROP VIEW mvtest_vt1 CASCADE; --- test that vacuum does not make empty matview look unpopulated -CREATE TABLE mvtest_huge (i int); -INSERT INTO mvtest_huge VALUES (generate_series(1,100000)); -CREATE MATERIALIZED VIEW mvtest_hugeview AS SELECT * FROM mvtest_huge WHERE i % 2 = 0; -CREATE INDEX mvtest_hugeviewidx ON mvtest_hugeview (i); -DELETE FROM mvtest_huge; -REFRESH MATERIALIZED VIEW mvtest_hugeview; -SELECT * FROM mvtest_hugeview WHERE i < 10; -VACUUM ANALYZE mvtest_hugeview; -SELECT * FROM mvtest_hugeview WHERE i < 10; -DROP TABLE mvtest_huge CASCADE; - -- test that duplicate values on unique index prevent refresh CREATE TABLE mvtest_foo(a, b) AS VALUES(1, 10); CREATE MATERIALIZED VIEW mvtest_mv AS SELECT * FROM mvtest_foo; From 855f0e9247a160bfad00c117ba7d97148cd2a0ec Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 4 May 2017 13:59:13 -0400 Subject: [PATCH 0036/1139] Fix pfree-of-already-freed-tuple when rescanning a GiST index-only scan. GiST's getNextNearest() function attempts to pfree the previously-returned tuple if any (that is, scan->xs_hitup in HEAD, or scan->xs_itup in older branches). However, if we are rescanning a plan node after ending a previous scan early, those tuple pointers could be pointing to garbage, because they would be pointing into the scan's pageDataCxt or queueCxt which has been reset. In a debug build this reliably results in a crash, although I think it might sometimes accidentally fail to fail in production builds. To fix, clear the pointer field anyplace we reset a context it might be pointing into. This may be overkill --- I think probably only the queueCxt case is involved in this bug, so that resetting in gistrescan() would be sufficient --- but dangling pointers are generally bad news, so let's avoid them. Another plausible answer might be to just not bother with the pfree in getNextNearest(). The reconstructed tuples would go away anyway in the context resets, and I'm far from convinced that freeing them a bit earlier really saves anything meaningful. I'll stick with the original logic in this patch, but if we find more problems in the same area we should consider that approach. Per bug #14641 from Denis Smirnov. Back-patch to 9.5 where this logic was introduced. Discussion: https://postgr.es/m/20170504072034.24366.57688@wrigleys.postgresql.org --- src/backend/access/gist/gistget.c | 3 +++ src/backend/access/gist/gistscan.c | 3 +++ src/test/regress/expected/gist.out | 34 ++++++++++++++++++++++++++++++ src/test/regress/sql/gist.sql | 16 ++++++++++++++ 4 files changed, 56 insertions(+) diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c index 5ba7d0a793..c1b05d66d2 100644 --- a/src/backend/access/gist/gistget.c +++ b/src/backend/access/gist/gistget.c @@ -375,6 +375,7 @@ gistScanPage(IndexScanDesc scan, GISTSearchItem *pageItem, double *myDistances, } so->nPageData = so->curPageData = 0; + scan->xs_itup = NULL; /* might point into pageDataCxt */ if (so->pageDataCxt) MemoryContextReset(so->pageDataCxt); @@ -641,6 +642,7 @@ gistgettuple(IndexScanDesc scan, ScanDirection dir) so->firstCall = false; so->curPageData = so->nPageData = 0; + scan->xs_itup = NULL; if (so->pageDataCxt) MemoryContextReset(so->pageDataCxt); @@ -765,6 +767,7 @@ gistgetbitmap(IndexScanDesc scan, TIDBitmap *tbm) /* Begin the scan by processing the root page */ so->curPageData = so->nPageData = 0; + scan->xs_itup = NULL; if (so->pageDataCxt) MemoryContextReset(so->pageDataCxt); diff --git a/src/backend/access/gist/gistscan.c b/src/backend/access/gist/gistscan.c index 2526a3965c..12c74b982c 100644 --- a/src/backend/access/gist/gistscan.c +++ b/src/backend/access/gist/gistscan.c @@ -312,6 +312,9 @@ gistrescan(IndexScanDesc scan, ScanKey key, int nkeys, if (!first_time) pfree(fn_extras); } + + /* any previous xs_itup will have been pfree'd in context resets above */ + scan->xs_itup = NULL; } void diff --git a/src/test/regress/expected/gist.out b/src/test/regress/expected/gist.out index c7181b0397..91f9998140 100644 --- a/src/test/regress/expected/gist.out +++ b/src/test/regress/expected/gist.out @@ -114,6 +114,40 @@ order by point(0.101, 0.101) <-> p; (0.5,0.5) (11 rows) +-- Check case with multiple rescans (bug #14641) +explain (costs off) +select p from + (values (box(point(0,0), point(0.5,0.5))), + (box(point(0.5,0.5), point(0.75,0.75))), + (box(point(0.8,0.8), point(1.0,1.0)))) as v(bb) +cross join lateral + (select p from gist_tbl where p <@ bb order by p <-> bb[0] limit 2) ss; + QUERY PLAN +-------------------------------------------------------------------- + Nested Loop + -> Values Scan on "*VALUES*" + -> Limit + -> Index Only Scan using gist_tbl_point_index on gist_tbl + Index Cond: (p <@ "*VALUES*".column1) + Order By: (p <-> ("*VALUES*".column1)[0]) +(6 rows) + +select p from + (values (box(point(0,0), point(0.5,0.5))), + (box(point(0.5,0.5), point(0.75,0.75))), + (box(point(0.8,0.8), point(1.0,1.0)))) as v(bb) +cross join lateral + (select p from gist_tbl where p <@ bb order by p <-> bb[0] limit 2) ss; + p +------------- + (0.5,0.5) + (0.45,0.45) + (0.75,0.75) + (0.7,0.7) + (1,1) + (0.95,0.95) +(6 rows) + drop index gist_tbl_point_index; -- Test index-only scan with box opclass create index gist_tbl_box_index on gist_tbl using gist (b); diff --git a/src/test/regress/sql/gist.sql b/src/test/regress/sql/gist.sql index 9d4ff1e97e..49126fd466 100644 --- a/src/test/regress/sql/gist.sql +++ b/src/test/regress/sql/gist.sql @@ -69,6 +69,22 @@ order by point(0.101, 0.101) <-> p; select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)) order by point(0.101, 0.101) <-> p; +-- Check case with multiple rescans (bug #14641) +explain (costs off) +select p from + (values (box(point(0,0), point(0.5,0.5))), + (box(point(0.5,0.5), point(0.75,0.75))), + (box(point(0.8,0.8), point(1.0,1.0)))) as v(bb) +cross join lateral + (select p from gist_tbl where p <@ bb order by p <-> bb[0] limit 2) ss; + +select p from + (values (box(point(0,0), point(0.5,0.5))), + (box(point(0.5,0.5), point(0.75,0.75))), + (box(point(0.8,0.8), point(1.0,1.0)))) as v(bb) +cross join lateral + (select p from gist_tbl where p <@ bb order by p <-> bb[0] limit 2) ss; + drop index gist_tbl_point_index; -- Test index-only scan with box opclass From 071d13395cc2ea0b87aa5f135c87808d6dd60cd5 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Wed, 3 May 2017 21:25:01 -0400 Subject: [PATCH 0037/1139] Fix cursor_to_xml in tableforest false mode It only produced elements but no wrapping element. By contrast, cursor_to_xmlschema produced a schema that is now correct but did not previously match the XML data produced by cursor_to_xml. In passing, also fix a minor misunderstanding about moving cursors in the tests related to this. Reported-by: filip@jirsak.org Based-on-patch-by: Thomas Munro --- src/backend/utils/adt/xml.c | 13 ++++++ src/test/regress/expected/xmlmap.out | 64 ++++++++++++++++++++------ src/test/regress/expected/xmlmap_1.out | 6 ++- src/test/regress/sql/xmlmap.sql | 3 +- 4 files changed, 71 insertions(+), 15 deletions(-) diff --git a/src/backend/utils/adt/xml.c b/src/backend/utils/adt/xml.c index b144920ec6..f5348b3465 100644 --- a/src/backend/utils/adt/xml.c +++ b/src/backend/utils/adt/xml.c @@ -147,6 +147,10 @@ static int xml_xpathobjtoxmlarray(xmlXPathObjectPtr xpathobj, PgXmlErrorContext *xmlerrcxt); #endif /* USE_LIBXML */ +static void xmldata_root_element_start(StringInfo result, const char *eltname, + const char *xmlschema, const char *targetns, + bool top_level); +static void xmldata_root_element_end(StringInfo result, const char *eltname); static StringInfo query_to_xml_internal(const char *query, char *tablename, const char *xmlschema, bool nulls, bool tableforest, const char *targetns, bool top_level); @@ -2381,6 +2385,12 @@ cursor_to_xml(PG_FUNCTION_ARGS) initStringInfo(&result); + if (!tableforest) + { + xmldata_root_element_start(&result, "table", NULL, targetns, true); + appendStringInfoChar(&result, '\n'); + } + SPI_connect(); portal = SPI_cursor_find(name); if (portal == NULL) @@ -2395,6 +2405,9 @@ cursor_to_xml(PG_FUNCTION_ARGS) SPI_finish(); + if (!tableforest) + xmldata_root_element_end(&result, "table"); + PG_RETURN_XML_P(stringinfo_to_xmltype(&result)); } diff --git a/src/test/regress/expected/xmlmap.out b/src/test/regress/expected/xmlmap.out index b50396face..c08f8a0d9c 100644 --- a/src/test/regress/expected/xmlmap.out +++ b/src/test/regress/expected/xmlmap.out @@ -696,20 +696,58 @@ SELECT cursor_to_xml('xc'::refcursor, 5, false, true, ''); (1 row) -MOVE FIRST IN xc; +SELECT cursor_to_xmlschema('xc'::refcursor, false, true, ''); + cursor_to_xmlschema +---------------------------------------------------------------------------------------------- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +(1 row) + +MOVE BACKWARD ALL IN xc; SELECT cursor_to_xml('xc'::refcursor, 5, true, false, ''); - cursor_to_xml ---------------- - + - 1 + - one + - + - + - + - 2 + - two + - + - + + cursor_to_xml +--------------------------------------------------------------- +
+ + + + + + -1 + + + + + + + + + + 1 + + one + + + + + + + + 2 + + two + + + + + +
+ (1 row) diff --git a/src/test/regress/expected/xmlmap_1.out b/src/test/regress/expected/xmlmap_1.out index d67ef6d3e2..f6dbf81666 100644 --- a/src/test/regress/expected/xmlmap_1.out +++ b/src/test/regress/expected/xmlmap_1.out @@ -78,7 +78,11 @@ SELECT cursor_to_xml('xc'::refcursor, 5, false, true, ''); ERROR: unsupported XML feature DETAIL: This functionality requires the server to be built with libxml support. HINT: You need to rebuild PostgreSQL using --with-libxml. -MOVE FIRST IN xc; +SELECT cursor_to_xmlschema('xc'::refcursor, false, true, ''); +ERROR: unsupported XML feature +DETAIL: This functionality requires the server to be built with libxml support. +HINT: You need to rebuild PostgreSQL using --with-libxml. +MOVE BACKWARD ALL IN xc; SELECT cursor_to_xml('xc'::refcursor, 5, true, false, ''); ERROR: unsupported XML feature DETAIL: This functionality requires the server to be built with libxml support. diff --git a/src/test/regress/sql/xmlmap.sql b/src/test/regress/sql/xmlmap.sql index 8f8d680813..fde1b9eb59 100644 --- a/src/test/regress/sql/xmlmap.sql +++ b/src/test/regress/sql/xmlmap.sql @@ -30,7 +30,8 @@ SELECT query_to_xml_and_xmlschema('SELECT * FROM testxmlschema.test1', true, tru DECLARE xc CURSOR WITH HOLD FOR SELECT * FROM testxmlschema.test1 ORDER BY 1, 2; SELECT cursor_to_xml('xc'::refcursor, 5, false, true, ''); -MOVE FIRST IN xc; +SELECT cursor_to_xmlschema('xc'::refcursor, false, true, ''); +MOVE BACKWARD ALL IN xc; SELECT cursor_to_xml('xc'::refcursor, 5, true, false, ''); SELECT cursor_to_xmlschema('xc'::refcursor, true, false, ''); From bd05ad8b052012155fd5de0c21029d5869ad5eb4 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Fri, 5 May 2017 11:24:02 +0300 Subject: [PATCH 0038/1139] Give nicer error message when connecting to a v10 server requiring SCRAM. This is just to give the user a hint that they need to upgrade, if they try to connect to a v10 server that uses SCRAM authentication, with an older client. Commit to all stable branches, but not master. Discussion: https://www.postgresql.org/message-id/bbf45d92-3896-eeb7-7399-2111d517261b@pivotal.io --- src/include/libpq/pqcomm.h | 2 ++ src/interfaces/libpq/fe-auth.c | 13 +++++++++++++ 2 files changed, 15 insertions(+) diff --git a/src/include/libpq/pqcomm.h b/src/include/libpq/pqcomm.h index c6bbfc2377..1d063d1248 100644 --- a/src/include/libpq/pqcomm.h +++ b/src/include/libpq/pqcomm.h @@ -172,6 +172,8 @@ extern bool Db_user_namespace; #define AUTH_REQ_GSS 7 /* GSSAPI without wrap() */ #define AUTH_REQ_GSS_CONT 8 /* Continue GSS exchanges */ #define AUTH_REQ_SSPI 9 /* SSPI negotiate without wrap() */ +#define AUTH_REQ_SASL 10 /* SASL authentication. Not supported before + * libpq version 10. */ typedef uint32 AuthRequest; diff --git a/src/interfaces/libpq/fe-auth.c b/src/interfaces/libpq/fe-auth.c index 9bf6e52d63..493ef82d4a 100644 --- a/src/interfaces/libpq/fe-auth.c +++ b/src/interfaces/libpq/fe-auth.c @@ -703,6 +703,19 @@ pg_fe_sendauth(AuthRequest areq, PGconn *conn) return STATUS_ERROR; break; + /* + * SASL authentication was introduced in version 10. Older + * versions recognize the request only to give a nicer error + * message. We call it "SCRAM authentication" in the error, rather + * than SASL, because SCRAM is more familiar to users, and it's + * the only SASL authentication mechanism that has been + * implemented as of this writing, anyway. + */ + case AUTH_REQ_SASL: + printfPQExpBuffer(&conn->errorMessage, + libpq_gettext("SCRAM authentication requires libpq version 10 or above\n")); + return STATUS_ERROR; + default: printfPQExpBuffer(&conn->errorMessage, libpq_gettext("authentication method %u not supported\n"), areq); From 19a40337854ee83bd0fb1b65d0787e2c74065722 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Fri, 5 May 2017 12:05:34 -0300 Subject: [PATCH 0039/1139] Allow MSVC to build with Tcl 8.6. Commit eaba54c20c5 added support for Tcl 8.6 for configure-supported platforms after verifying that pltcl works without further changes, but the MSVC tooling wasn't updated accordingly. Update MSVC to match, restructuring the code to avoid duplicating the logic for every Tcl version supported. Backpatch to all live branches, like eaba54c20c5. In 9.4 and previous, change the patch to use backslashes rather than forward, as in the rest of the file. Reported by Paresh More, who also tested the patch I provided. Discussion: https://postgr.es/m/CAAgiCNGVw3ssBtSi3ZNstrz5k00ax=UV+_ZEHUeW_LMSGL2sew@mail.gmail.com --- src/tools/msvc/Mkvcbuild.pm | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/src/tools/msvc/Mkvcbuild.pm b/src/tools/msvc/Mkvcbuild.pm index fe905d3c9d..57af0a0a95 100644 --- a/src/tools/msvc/Mkvcbuild.pm +++ b/src/tools/msvc/Mkvcbuild.pm @@ -194,20 +194,24 @@ sub mkvcbuild if ($solution->{options}->{tcl}) { + my $found = 0; my $pltcl = $solution->AddProject('pltcl', 'dll', 'PLs', 'src/pl/tcl'); $pltcl->AddIncludeDir($solution->{options}->{tcl} . '/include'); $pltcl->AddReference($postgres); - if (-e $solution->{options}->{tcl} . '/lib/tcl85.lib') - { - $pltcl->AddLibrary( - $solution->{options}->{tcl} . '/lib/tcl85.lib'); - } - else + + for my $tclver (qw(86t 85 84)) { - $pltcl->AddLibrary( - $solution->{options}->{tcl} . '/lib/tcl84.lib'); + my $tcllib = $solution->{options}->{tcl} . "/lib/tcl$tclver.lib"; + if (-e $tcllib) + { + $pltcl->AddLibrary($tcllib); + $found = 1; + last; + } } + die "Unable to find $solution->{options}->{tcl}/lib/tcl.lib" + unless $found; } $libpq = $solution->AddProject('libpq', 'dll', 'interfaces', From a24a1a2ec44d71cf43bdafc2c17db370cd1908ea Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 6 May 2017 14:19:47 -0400 Subject: [PATCH 0040/1139] Document current_role. This system function has been there a very long time, but somehow escaped being listed in func.sgml. Fabien Coelho and Tom Lane Discussion: https://postgr.es/m/alpine.DEB.2.20.1705061027580.3896@lancre --- doc/src/sgml/func.sgml | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index e4102cdd17..ca4aa51df6 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -15306,6 +15306,12 @@ SELECT * FROM pg_ls_dir('.') WITH ORDINALITY AS t(ls,n); by the client (might contain more than one statement) + + current_role + name + equivalent to current_user + + current_schema[()] name @@ -15429,8 +15435,11 @@ SELECT * FROM pg_ls_dir('.') WITH ORDINALITY AS t(ls,n); - current_catalog, current_schema, - current_user, session_user, + current_catalog, + current_role, + current_schema, + current_user, + session_user, and user have special syntactic status in SQL: they must be called without trailing parentheses. (In PostgreSQL, parentheses can optionally be used with @@ -15450,6 +15459,10 @@ SELECT * FROM pg_ls_dir('.') WITH ORDINALITY AS t(ls,n); current_query + + current_role + + current_schema @@ -15501,6 +15514,11 @@ SELECT * FROM pg_ls_dir('.') WITH ORDINALITY AS t(ls,n); functions with the attribute SECURITY DEFINER. In Unix parlance, the session user is the real user and the current user is the effective user. + current_role and user are + synonyms for current_user. (The SQL standard draws + a distinction between current_role + and current_user, but PostgreSQL + does not, since it unifies users and roles into a single kind of entity.) From 92b15224b4eac8eeae0616491ccf0c852fa2dff9 Mon Sep 17 00:00:00 2001 From: Stephen Frost Date: Sat, 6 May 2017 21:46:41 -0400 Subject: [PATCH 0041/1139] RLS: Fix ALL vs. SELECT+UPDATE policy usage When we add the SELECT-privilege based policies to the RLS with check options (such as for an UPDATE statement, or when we have INSERT ... RETURNING), we need to be sure and use the 'USING' case if the policy is actually an 'ALL' policy (which could have both a USING clause and an independent WITH CHECK clause). This could result in policies acting differently when built using ALL (when the ALL had both USING and WITH CHECK clauses) and when building the policies independently as SELECT and UPDATE policies. Fix this by adding an explicit boolean to add_with_check_options() to indicate when the USING policy should be used, even if the policy has both USING and WITH CHECK policies on it. Reported by: Rod Taylor Back-patch to 9.5 where RLS was introduced. --- src/backend/rewrite/rowsecurity.c | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/src/backend/rewrite/rowsecurity.c b/src/backend/rewrite/rowsecurity.c index e02911656a..6b34c596f3 100644 --- a/src/backend/rewrite/rowsecurity.c +++ b/src/backend/rewrite/rowsecurity.c @@ -78,7 +78,8 @@ static void add_with_check_options(Relation rel, List *permissive_policies, List *restrictive_policies, List **withCheckOptions, - bool *hasSubLinks); + bool *hasSubLinks, + bool force_using); static bool check_role_for_policy(ArrayType *policy_roles, Oid user_id); @@ -271,7 +272,8 @@ get_row_security_policies(Query *root, RangeTblEntry *rte, int rt_index, permissive_policies, restrictive_policies, withCheckOptions, - hasSubLinks); + hasSubLinks, + false); /* * Get and add ALL/SELECT policies, if SELECT rights are required for @@ -294,7 +296,8 @@ get_row_security_policies(Query *root, RangeTblEntry *rte, int rt_index, select_permissive_policies, select_restrictive_policies, withCheckOptions, - hasSubLinks); + hasSubLinks, + true); } /* @@ -323,7 +326,8 @@ get_row_security_policies(Query *root, RangeTblEntry *rte, int rt_index, conflict_permissive_policies, conflict_restrictive_policies, withCheckOptions, - hasSubLinks); + hasSubLinks, + true); /* * Get and add ALL/SELECT policies, as WCO_RLS_CONFLICT_CHECK WCOs @@ -345,7 +349,8 @@ get_row_security_policies(Query *root, RangeTblEntry *rte, int rt_index, conflict_select_permissive_policies, conflict_select_restrictive_policies, withCheckOptions, - hasSubLinks); + hasSubLinks, + true); } /* Enforce the WITH CHECK clauses of the UPDATE policies */ @@ -354,7 +359,8 @@ get_row_security_policies(Query *root, RangeTblEntry *rte, int rt_index, conflict_permissive_policies, conflict_restrictive_policies, withCheckOptions, - hasSubLinks); + hasSubLinks, + false); } } @@ -645,13 +651,14 @@ add_with_check_options(Relation rel, List *permissive_policies, List *restrictive_policies, List **withCheckOptions, - bool *hasSubLinks) + bool *hasSubLinks, + bool force_using) { ListCell *item; List *permissive_quals = NIL; #define QUAL_FOR_WCO(policy) \ - ( kind != WCO_RLS_CONFLICT_CHECK && \ + ( !force_using && \ (policy)->with_check_qual != NULL ? \ (policy)->with_check_qual : (policy)->qual ) From ef42c1103708cbbb77fff674f339d452a13aac14 Mon Sep 17 00:00:00 2001 From: Stephen Frost Date: Sat, 6 May 2017 22:58:22 -0400 Subject: [PATCH 0042/1139] pg_dump: Don't leak memory in buildDefaultACLCommands() buildDefaultACLCommands() didn't destroy the string buffer created in certain cases, leading to a memory leak. Fix by destroying the buffer before returning from the function. Spotted by Coverity. Author: Michael Paquier Back-patch to 9.6 where buildDefaultACLCommands() was added. --- src/bin/pg_dump/dumputils.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/bin/pg_dump/dumputils.c b/src/bin/pg_dump/dumputils.c index a062a6b330..11870a33fa 100644 --- a/src/bin/pg_dump/dumputils.c +++ b/src/bin/pg_dump/dumputils.c @@ -394,13 +394,19 @@ buildDefaultACLCommands(const char *type, const char *nspname, appendPQExpBuffer(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(true);\n"); if (!buildACLCommands("", NULL, type, initacls, initracls, owner, prefix->data, remoteVersion, sql)) + { + destroyPQExpBuffer(prefix); return false; + } appendPQExpBuffer(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n"); } if (!buildACLCommands("", NULL, type, acls, racls, owner, prefix->data, remoteVersion, sql)) + { + destroyPQExpBuffer(prefix); return false; + } destroyPQExpBuffer(prefix); From 5042e9492b17f6f4029bb1aca7c1c0b8247c8c95 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 7 May 2017 11:34:31 -0400 Subject: [PATCH 0043/1139] Restore fullname[] contents before falling through in pg_open_tzfile(). Fix oversight in commit af2c5aa88: if the shortcut open() doesn't work, we need to reset fullname[] to be just the name of the toplevel tzdata directory before we fall through into the pre-existing code. This failed to be exposed in my (tgl's) testing because the fall-through path is actually never taken under normal circumstances. David Rowley, per report from Amit Kapila Discussion: https://postgr.es/m/CAA4eK1LC7CaNhRAQ__C3ht1JVrPzaAXXhEJRnR5L6bfYHiLmWw@mail.gmail.com --- src/timezone/pgtz.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/timezone/pgtz.c b/src/timezone/pgtz.c index 9356f2592d..b2a4a2d356 100644 --- a/src/timezone/pgtz.c +++ b/src/timezone/pgtz.c @@ -105,6 +105,7 @@ pg_open_tzfile(const char *name, char *canonname) if (result >= 0) return result; /* If that didn't work, fall through to do it the hard way */ + fullname[fullnamelen] = '\0'; } /* From f754728170b7bd4624902bf0129a1c88f910ac3c Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 7 May 2017 11:57:41 -0400 Subject: [PATCH 0044/1139] Install the "posixrules" timezone link in MSVC builds. Somehow, we'd missed ever doing this. The consequences aren't too severe: basically, the timezone library would fall back on its hardwired notion of the DST transition dates to use for a POSIX-style zone name, rather than obeying US/Eastern which is the intended behavior. The net effect would only be to obey current US DST law further back than it ought to apply; so it's not real surprising that nobody noticed. David Rowley, per report from Amit Kapila Discussion: https://postgr.es/m/CAA4eK1LC7CaNhRAQ__C3ht1JVrPzaAXXhEJRnR5L6bfYHiLmWw@mail.gmail.com --- src/tools/msvc/Install.pm | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/tools/msvc/Install.pm b/src/tools/msvc/Install.pm index e04efe6559..afb1b770e7 100644 --- a/src/tools/msvc/Install.pm +++ b/src/tools/msvc/Install.pm @@ -380,13 +380,20 @@ sub GenerateTimezoneFiles my $conf = shift; my $mf = read_file("src/timezone/Makefile"); $mf =~ s{\\\r?\n}{}g; + $mf =~ /^TZDATA\s*:?=\s*(.*)$/m || die "Could not find TZDATA line in timezone makefile\n"; my @tzfiles = split /\s+/, $1; + $mf =~ /^POSIXRULES\s*:?=\s*(.*)$/m + || die "Could not find POSIXRULES line in timezone makefile\n"; + my $posixrules = $1; + $posixrules =~ s/\s+//g; + print "Generating timezone files..."; - my @args = ("$conf/zic/zic", '-d', "$target/share/timezone"); + my @args = ("$conf/zic/zic", '-d', "$target/share/timezone", + '-p', "$posixrules"); foreach (@tzfiles) { my $tzfile = $_; From fab2d0d7f45a5cdf0d63cf27c161f966e89ddc9e Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 7 May 2017 12:33:12 -0400 Subject: [PATCH 0045/1139] Guard against null t->tm_zone in strftime.c. The upstream IANA code does not guard against null TM_ZONE pointers in this function, but in our code there is such a check in the other pre-existing use of t->tm_zone. We do have some places that set pg_tm.tm_zone to NULL. I'm not entirely sure it's possible to reach strftime with such a value, but I'm not sure it isn't either, so be safe. Per Coverity complaint. --- src/timezone/strftime.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/timezone/strftime.c b/src/timezone/strftime.c index ab8f60e9c8..2f32cf8bdb 100644 --- a/src/timezone/strftime.c +++ b/src/timezone/strftime.c @@ -459,7 +459,8 @@ _fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, negative = diff < 0; if (diff == 0) { - negative = t->tm_zone[0] == '-'; + if (t->tm_zone != NULL) + negative = t->tm_zone[0] == '-'; } if (negative) { From 3178f467c81823954f76603a03ad3edb7f54f588 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 7 May 2017 16:56:02 -0400 Subject: [PATCH 0046/1139] Release notes for 9.6.3, 9.5.7, 9.4.12, 9.3.17, 9.2.21. --- doc/src/sgml/release-9.2.sgml | 325 ++++++++++++ doc/src/sgml/release-9.3.sgml | 346 +++++++++++++ doc/src/sgml/release-9.4.sgml | 437 +++++++++++++++- doc/src/sgml/release-9.5.sgml | 496 ++++++++++++++++++ doc/src/sgml/release-9.6.sgml | 949 +++++++++++++++++++++++++++++++++- 5 files changed, 2551 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/release-9.2.sgml b/doc/src/sgml/release-9.2.sgml index 0c7fe30bda..ea86c8a42d 100644 --- a/doc/src/sgml/release-9.2.sgml +++ b/doc/src/sgml/release-9.2.sgml @@ -1,6 +1,331 @@ + + Release 9.2.21 + + + Release Date + 2017-05-11 + + + + This release contains a variety of fixes from 9.2.20. + For information about new features in the 9.2 major release, see + . + + + + The PostgreSQL community will stop releasing updates + for the 9.2.X release series in September 2017. + Users are encouraged to update to a newer release branch soon. + + + + Migration to Version 9.2.21 + + + A dump/restore is not required for those running 9.2.X. + + + + However, if you are upgrading from a version earlier than 9.2.20, + see . + + + + + + Changes + + + + + + Fix possible corruption of init forks of unlogged indexes + (Robert Haas, Michael Paquier) + + + + This could result in an unlogged index being set to an invalid state + after a crash and restart. Such a problem would persist until the + index was dropped and rebuilt. + + + + + + Fix incorrect reconstruction of pg_subtrans entries + when a standby server replays a prepared but uncommitted two-phase + transaction (Tom Lane) + + + + In most cases this turned out to have no visible ill effects, but in + corner cases it could result in circular references + in pg_subtrans, potentially causing infinite loops + in queries that examine rows modified by the two-phase transaction. + + + + + + Ensure parsing of queries in extension scripts sees the results of + immediately-preceding DDL (Julien Rouhaud, Tom Lane) + + + + Due to lack of a cache flush step between commands in an extension + script file, non-utility queries might not see the effects of an + immediately preceding catalog change, such as ALTER TABLE + ... RENAME. + + + + + + Skip tablespace privilege checks when ALTER TABLE ... ALTER + COLUMN TYPE rebuilds an existing index (Noah Misch) + + + + The command failed if the calling user did not currently have + CREATE privilege for the tablespace containing the index. + That behavior seems unhelpful, so skip the check, allowing the + index to be rebuilt where it is. + + + + + + Fix ALTER TABLE ... VALIDATE CONSTRAINT to not recurse + to child tables when the constraint is marked NO INHERIT + (Amit Langote) + + + + This fix prevents unwanted constraint does not exist failures + when no matching constraint is present in the child tables. + + + + + + Fix VACUUM to account properly for pages that could not + be scanned due to conflicting page pins (Andrew Gierth) + + + + This tended to lead to underestimation of the number of tuples in + the table. In the worst case of a small heavily-contended + table, VACUUM could incorrectly report that the table + contained no tuples, leading to very bad planning choices. + + + + + + Ensure that bulk-tuple-transfer loops within a hash join are + interruptible by query cancel requests (Tom Lane, Thomas Munro) + + + + + + Fix cursor_to_xml() to produce valid output + with tableforest = false + (Thomas Munro, Peter Eisentraut) + + + + Previously it failed to produce a wrapping <table> + element. + + + + + + Improve performance of pg_timezone_names view + (Tom Lane, David Rowley) + + + + + + Fix sloppy handling of corner-case errors from lseek() + and close() (Tom Lane) + + + + Neither of these system calls are likely to fail in typical situations, + but if they did, fd.c could get quite confused. + + + + + + Fix incorrect check for whether postmaster is running as a Windows + service (Michael Paquier) + + + + This could result in attempting to write to the event log when that + isn't accessible, so that no logging happens at all. + + + + + + Fix ecpg to support COMMIT PREPARED + and ROLLBACK PREPARED (Masahiko Sawada) + + + + + + Fix a double-free error when processing dollar-quoted string literals + in ecpg (Michael Meskes) + + + + + + In pg_dump, fix incorrect schema and owner marking for + comments and security labels of some types of database objects + (Giuseppe Broccolo, Tom Lane) + + + + In simple cases this caused no ill effects; but for example, a + schema-selective restore might omit comments it should include, because + they were not marked as belonging to the schema of their associated + object. + + + + + + Avoid emitting an invalid list file in pg_restore -l + when SQL object names contain newlines (Tom Lane) + + + + Replace newlines by spaces, which is sufficient to make the output + valid for pg_restore -L's purposes. + + + + + + Fix pg_upgrade to transfer comments and security labels + attached to large objects (blobs) (Stephen Frost) + + + + Previously, blobs were correctly transferred to the new database, but + any comments or security labels attached to them were lost. + + + + + + Improve error handling + in contrib/adminpack's pg_file_write() + function (Noah Misch) + + + + Notably, it failed to detect errors reported + by fclose(). + + + + + + In contrib/dblink, avoid leaking the previous unnamed + connection when establishing a new unnamed connection (Joe Conway) + + + + + + Support OpenSSL 1.1.0 (Heikki Linnakangas, Andreas Karlsson, Tom Lane) + + + + This is a back-patch of work previously done in newer branches; + it's needed since many platforms are adopting newer OpenSSL versions. + + + + + + Support Tcl 8.6 in MSVC builds (Álvaro Herrera) + + + + + + Sync our copy of the timezone library with IANA release tzcode2017b + (Tom Lane) + + + + This fixes a bug affecting some DST transitions in January 2038. + + + + + + Update time zone data files to tzdata release 2017b + for DST law changes in Chile, Haiti, and Mongolia, plus historical + corrections for Ecuador, Kazakhstan, Liberia, and Spain. + Switch to numeric abbreviations for numerous time zones in South + America, the Pacific and Indian oceans, and some Asian and Middle + Eastern countries. + + + + The IANA time zone database previously provided textual abbreviations + for all time zones, sometimes making up abbreviations that have little + or no currency among the local population. They are in process of + reversing that policy in favor of using numeric UTC offsets in zones + where there is no evidence of real-world use of an English + abbreviation. At least for the time being, PostgreSQL + will continue to accept such removed abbreviations for timestamp input. + But they will not be shown in the pg_timezone_names + view nor used for output. + + + + + + Use correct daylight-savings rules for POSIX-style time zone names + in MSVC builds (David Rowley) + + + + The Microsoft MSVC build scripts neglected to install + the posixrules file in the timezone directory tree. + This resulted in the timezone code falling back to its built-in + rule about what DST behavior to assume for a POSIX-style time zone + name. For historical reasons that still corresponds to the DST rules + the USA was using before 2007 (i.e., change on first Sunday in April + and last Sunday in October). With this fix, a POSIX-style zone name + will use the current and historical DST transition dates of + the US/Eastern zone. If you don't want that, remove + the posixrules file, or replace it with a copy of some + other zone file (see ). Note that + due to caching, you may need to restart the server to get such changes + to take effect. + + + + + + + + Release 9.2.20 diff --git a/doc/src/sgml/release-9.3.sgml b/doc/src/sgml/release-9.3.sgml index 6e1f010187..0bf5648be7 100644 --- a/doc/src/sgml/release-9.3.sgml +++ b/doc/src/sgml/release-9.3.sgml @@ -1,6 +1,352 @@ + + Release 9.3.17 + + + Release Date + 2017-05-11 + + + + This release contains a variety of fixes from 9.3.16. + For information about new features in the 9.3 major release, see + . + + + + Migration to Version 9.3.17 + + + A dump/restore is not required for those running 9.3.X. + + + + However, if you are upgrading from a version earlier than 9.3.16, + see . + + + + + + Changes + + + + + + Fix possible corruption of init forks of unlogged indexes + (Robert Haas, Michael Paquier) + + + + This could result in an unlogged index being set to an invalid state + after a crash and restart. Such a problem would persist until the + index was dropped and rebuilt. + + + + + + Fix incorrect reconstruction of pg_subtrans entries + when a standby server replays a prepared but uncommitted two-phase + transaction (Tom Lane) + + + + In most cases this turned out to have no visible ill effects, but in + corner cases it could result in circular references + in pg_subtrans, potentially causing infinite loops + in queries that examine rows modified by the two-phase transaction. + + + + + + Ensure parsing of queries in extension scripts sees the results of + immediately-preceding DDL (Julien Rouhaud, Tom Lane) + + + + Due to lack of a cache flush step between commands in an extension + script file, non-utility queries might not see the effects of an + immediately preceding catalog change, such as ALTER TABLE + ... RENAME. + + + + + + Skip tablespace privilege checks when ALTER TABLE ... ALTER + COLUMN TYPE rebuilds an existing index (Noah Misch) + + + + The command failed if the calling user did not currently have + CREATE privilege for the tablespace containing the index. + That behavior seems unhelpful, so skip the check, allowing the + index to be rebuilt where it is. + + + + + + Fix ALTER TABLE ... VALIDATE CONSTRAINT to not recurse + to child tables when the constraint is marked NO INHERIT + (Amit Langote) + + + + This fix prevents unwanted constraint does not exist failures + when no matching constraint is present in the child tables. + + + + + + Fix VACUUM to account properly for pages that could not + be scanned due to conflicting page pins (Andrew Gierth) + + + + This tended to lead to underestimation of the number of tuples in + the table. In the worst case of a small heavily-contended + table, VACUUM could incorrectly report that the table + contained no tuples, leading to very bad planning choices. + + + + + + Ensure that bulk-tuple-transfer loops within a hash join are + interruptible by query cancel requests (Tom Lane, Thomas Munro) + + + + + + Fix cursor_to_xml() to produce valid output + with tableforest = false + (Thomas Munro, Peter Eisentraut) + + + + Previously it failed to produce a wrapping <table> + element. + + + + + + Improve performance of pg_timezone_names view + (Tom Lane, David Rowley) + + + + + + Fix sloppy handling of corner-case errors from lseek() + and close() (Tom Lane) + + + + Neither of these system calls are likely to fail in typical situations, + but if they did, fd.c could get quite confused. + + + + + + Fix incorrect check for whether postmaster is running as a Windows + service (Michael Paquier) + + + + This could result in attempting to write to the event log when that + isn't accessible, so that no logging happens at all. + + + + + + Fix ecpg to support COMMIT PREPARED + and ROLLBACK PREPARED (Masahiko Sawada) + + + + + + Fix a double-free error when processing dollar-quoted string literals + in ecpg (Michael Meskes) + + + + + + In pg_dump, fix incorrect schema and owner marking for + comments and security labels of some types of database objects + (Giuseppe Broccolo, Tom Lane) + + + + In simple cases this caused no ill effects; but for example, a + schema-selective restore might omit comments it should include, because + they were not marked as belonging to the schema of their associated + object. + + + + + + Avoid emitting an invalid list file in pg_restore -l + when SQL object names contain newlines (Tom Lane) + + + + Replace newlines by spaces, which is sufficient to make the output + valid for pg_restore -L's purposes. + + + + + + Fix pg_upgrade to transfer comments and security labels + attached to large objects (blobs) (Stephen Frost) + + + + Previously, blobs were correctly transferred to the new database, but + any comments or security labels attached to them were lost. + + + + + + Improve error handling + in contrib/adminpack's pg_file_write() + function (Noah Misch) + + + + Notably, it failed to detect errors reported + by fclose(). + + + + + + In contrib/dblink, avoid leaking the previous unnamed + connection when establishing a new unnamed connection (Joe Conway) + + + + + + Fix contrib/pg_trgm's extraction of trigrams from regular + expressions (Tom Lane) + + + + In some cases it would produce a broken data structure that could never + match anything, leading to GIN or GiST indexscans that use a trigram + index not finding any matches to the regular expression. + + + + + + In contrib/postgres_fdw, + transmit query cancellation requests to the remote server + (Michael Paquier, Etsuro Fujita) + + + + Previously, a local query cancellation request did not cause an + already-sent remote query to terminate early. This is a back-patch + of work originally done for 9.6. + + + + + + Support OpenSSL 1.1.0 (Heikki Linnakangas, Andreas Karlsson, Tom Lane) + + + + This is a back-patch of work previously done in newer branches; + it's needed since many platforms are adopting newer OpenSSL versions. + + + + + + Support Tcl 8.6 in MSVC builds (Álvaro Herrera) + + + + + + Sync our copy of the timezone library with IANA release tzcode2017b + (Tom Lane) + + + + This fixes a bug affecting some DST transitions in January 2038. + + + + + + Update time zone data files to tzdata release 2017b + for DST law changes in Chile, Haiti, and Mongolia, plus historical + corrections for Ecuador, Kazakhstan, Liberia, and Spain. + Switch to numeric abbreviations for numerous time zones in South + America, the Pacific and Indian oceans, and some Asian and Middle + Eastern countries. + + + + The IANA time zone database previously provided textual abbreviations + for all time zones, sometimes making up abbreviations that have little + or no currency among the local population. They are in process of + reversing that policy in favor of using numeric UTC offsets in zones + where there is no evidence of real-world use of an English + abbreviation. At least for the time being, PostgreSQL + will continue to accept such removed abbreviations for timestamp input. + But they will not be shown in the pg_timezone_names + view nor used for output. + + + + + + Use correct daylight-savings rules for POSIX-style time zone names + in MSVC builds (David Rowley) + + + + The Microsoft MSVC build scripts neglected to install + the posixrules file in the timezone directory tree. + This resulted in the timezone code falling back to its built-in + rule about what DST behavior to assume for a POSIX-style time zone + name. For historical reasons that still corresponds to the DST rules + the USA was using before 2007 (i.e., change on first Sunday in April + and last Sunday in October). With this fix, a POSIX-style zone name + will use the current and historical DST transition dates of + the US/Eastern zone. If you don't want that, remove + the posixrules file, or replace it with a copy of some + other zone file (see ). Note that + due to caching, you may need to restart the server to get such changes + to take effect. + + + + + + + + Release 9.3.16 diff --git a/doc/src/sgml/release-9.4.sgml b/doc/src/sgml/release-9.4.sgml index d02d2aaff5..5bc6f68fd1 100644 --- a/doc/src/sgml/release-9.4.sgml +++ b/doc/src/sgml/release-9.4.sgml @@ -1,6 +1,441 @@ + + Release 9.4.12 + + + Release Date + 2017-05-11 + + + + This release contains a variety of fixes from 9.4.11. + For information about new features in the 9.4 major release, see + . + + + + Migration to Version 9.4.12 + + + A dump/restore is not required for those running 9.4.X. + + + + However, if you are using third-party replication tools that depend + on logical decoding, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.4.11, + see . + + + + + Changes + + + + + + Fix possibly-invalid initial snapshot during logical decoding + (Petr Jelinek, Andres Freund) + + + + The initial snapshot created for a logical decoding replication slot + was potentially incorrect. This could cause third-party tools that + use logical decoding to copy incomplete/inconsistent initial data. + This was more likely to happen if the source server was busy at the + time of slot creation, or if another logical slot already existed. + + + + If you are using a replication tool that depends on logical decoding, + and it should have copied a nonempty data set at the start of + replication, it is advisable to recreate the replica after + installing this update, or to verify its contents against the source + server. + + + + + + Fix possible corruption of init forks of unlogged indexes + (Robert Haas, Michael Paquier) + + + + This could result in an unlogged index being set to an invalid state + after a crash and restart. Such a problem would persist until the + index was dropped and rebuilt. + + + + + + Fix incorrect reconstruction of pg_subtrans entries + when a standby server replays a prepared but uncommitted two-phase + transaction (Tom Lane) + + + + In most cases this turned out to have no visible ill effects, but in + corner cases it could result in circular references + in pg_subtrans, potentially causing infinite loops + in queries that examine rows modified by the two-phase transaction. + + + + + + Avoid possible crash in walsender due to failure + to initialize a string buffer (Stas Kelvich, Fujii Masao) + + + + + + Fix postmaster's handling of fork() failure for a + background worker process (Tom Lane) + + + + Previously, the postmaster updated portions of its state as though + the process had been launched successfully, resulting in subsequent + confusion. + + + + + + Ensure parsing of queries in extension scripts sees the results of + immediately-preceding DDL (Julien Rouhaud, Tom Lane) + + + + Due to lack of a cache flush step between commands in an extension + script file, non-utility queries might not see the effects of an + immediately preceding catalog change, such as ALTER TABLE + ... RENAME. + + + + + + Skip tablespace privilege checks when ALTER TABLE ... ALTER + COLUMN TYPE rebuilds an existing index (Noah Misch) + + + + The command failed if the calling user did not currently have + CREATE privilege for the tablespace containing the index. + That behavior seems unhelpful, so skip the check, allowing the + index to be rebuilt where it is. + + + + + + Fix ALTER TABLE ... VALIDATE CONSTRAINT to not recurse + to child tables when the constraint is marked NO INHERIT + (Amit Langote) + + + + This fix prevents unwanted constraint does not exist failures + when no matching constraint is present in the child tables. + + + + + + Fix VACUUM to account properly for pages that could not + be scanned due to conflicting page pins (Andrew Gierth) + + + + This tended to lead to underestimation of the number of tuples in + the table. In the worst case of a small heavily-contended + table, VACUUM could incorrectly report that the table + contained no tuples, leading to very bad planning choices. + + + + + + Ensure that bulk-tuple-transfer loops within a hash join are + interruptible by query cancel requests (Tom Lane, Thomas Munro) + + + + + + Fix integer-overflow problems in interval comparison (Kyotaro + Horiguchi, Tom Lane) + + + + The comparison operators for type interval could yield wrong + answers for intervals larger than about 296000 years. Indexes on + columns containing such large values should be reindexed, since they + may be corrupt. + + + + + + Fix cursor_to_xml() to produce valid output + with tableforest = false + (Thomas Munro, Peter Eisentraut) + + + + Previously it failed to produce a wrapping <table> + element. + + + + + + Fix roundoff problems in float8_timestamptz() + and make_interval() (Tom Lane) + + + + These functions truncated, rather than rounded, when converting a + floating-point value to integer microseconds; that could cause + unexpectedly off-by-one results. + + + + + + Improve performance of pg_timezone_names view + (Tom Lane, David Rowley) + + + + + + Reduce memory management overhead for contexts containing many large + blocks (Tom Lane) + + + + + + Fix sloppy handling of corner-case errors from lseek() + and close() (Tom Lane) + + + + Neither of these system calls are likely to fail in typical situations, + but if they did, fd.c could get quite confused. + + + + + + Fix incorrect check for whether postmaster is running as a Windows + service (Michael Paquier) + + + + This could result in attempting to write to the event log when that + isn't accessible, so that no logging happens at all. + + + + + + Fix ecpg to support COMMIT PREPARED + and ROLLBACK PREPARED (Masahiko Sawada) + + + + + + Fix a double-free error when processing dollar-quoted string literals + in ecpg (Michael Meskes) + + + + + + In pg_dump, fix incorrect schema and owner marking for + comments and security labels of some types of database objects + (Giuseppe Broccolo, Tom Lane) + + + + In simple cases this caused no ill effects; but for example, a + schema-selective restore might omit comments it should include, because + they were not marked as belonging to the schema of their associated + object. + + + + + + Avoid emitting an invalid list file in pg_restore -l + when SQL object names contain newlines (Tom Lane) + + + + Replace newlines by spaces, which is sufficient to make the output + valid for pg_restore -L's purposes. + + + + + + Fix pg_upgrade to transfer comments and security labels + attached to large objects (blobs) (Stephen Frost) + + + + Previously, blobs were correctly transferred to the new database, but + any comments or security labels attached to them were lost. + + + + + + Improve error handling + in contrib/adminpack's pg_file_write() + function (Noah Misch) + + + + Notably, it failed to detect errors reported + by fclose(). + + + + + + In contrib/dblink, avoid leaking the previous unnamed + connection when establishing a new unnamed connection (Joe Conway) + + + + + + Fix contrib/pg_trgm's extraction of trigrams from regular + expressions (Tom Lane) + + + + In some cases it would produce a broken data structure that could never + match anything, leading to GIN or GiST indexscans that use a trigram + index not finding any matches to the regular expression. + + + + + + In contrib/postgres_fdw, + transmit query cancellation requests to the remote server + (Michael Paquier, Etsuro Fujita) + + + + Previously, a local query cancellation request did not cause an + already-sent remote query to terminate early. This is a back-patch + of work originally done for 9.6. + + + + + + + Support OpenSSL 1.1.0 (Heikki Linnakangas, Andreas Karlsson, Tom Lane) + + + + This is a back-patch of work previously done in newer branches; + it's needed since many platforms are adopting newer OpenSSL versions. + + + + + + Support Tcl 8.6 in MSVC builds (Álvaro Herrera) + + + + + + Sync our copy of the timezone library with IANA release tzcode2017b + (Tom Lane) + + + + This fixes a bug affecting some DST transitions in January 2038. + + + + + + Update time zone data files to tzdata release 2017b + for DST law changes in Chile, Haiti, and Mongolia, plus historical + corrections for Ecuador, Kazakhstan, Liberia, and Spain. + Switch to numeric abbreviations for numerous time zones in South + America, the Pacific and Indian oceans, and some Asian and Middle + Eastern countries. + + + + The IANA time zone database previously provided textual abbreviations + for all time zones, sometimes making up abbreviations that have little + or no currency among the local population. They are in process of + reversing that policy in favor of using numeric UTC offsets in zones + where there is no evidence of real-world use of an English + abbreviation. At least for the time being, PostgreSQL + will continue to accept such removed abbreviations for timestamp input. + But they will not be shown in the pg_timezone_names + view nor used for output. + + + + + + Use correct daylight-savings rules for POSIX-style time zone names + in MSVC builds (David Rowley) + + + + The Microsoft MSVC build scripts neglected to install + the posixrules file in the timezone directory tree. + This resulted in the timezone code falling back to its built-in + rule about what DST behavior to assume for a POSIX-style time zone + name. For historical reasons that still corresponds to the DST rules + the USA was using before 2007 (i.e., change on first Sunday in April + and last Sunday in October). With this fix, a POSIX-style zone name + will use the current and historical DST transition dates of + the US/Eastern zone. If you don't want that, remove + the posixrules file, or replace it with a copy of some + other zone file (see ). Note that + due to caching, you may need to restart the server to get such changes + to take effect. + + + + + + + + Release 9.4.11 @@ -8828,7 +9263,7 @@ Branch: REL9_4_STABLE [c2b06ab17] 2015-01-30 22:45:58 -0500 - Add ability to retrieve the current PL/PgSQL call stack + Add ability to retrieve the current PL/pgSQL call stack using GET DIAGNOSTICS (Pavel Stehule, Stephen Frost) diff --git a/doc/src/sgml/release-9.5.sgml b/doc/src/sgml/release-9.5.sgml index aab3ddc3c1..b00b1e64ea 100644 --- a/doc/src/sgml/release-9.5.sgml +++ b/doc/src/sgml/release-9.5.sgml @@ -1,6 +1,502 @@ + + Release 9.5.7 + + + Release Date + 2017-05-11 + + + + This release contains a variety of fixes from 9.5.6. + For information about new features in the 9.5 major release, see + . + + + + Migration to Version 9.5.7 + + + A dump/restore is not required for those running 9.5.X. + + + + However, if you are using third-party replication tools that depend + on logical decoding, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.5.6, + see . + + + + + Changes + + + + + + Fix possibly-invalid initial snapshot during logical decoding + (Petr Jelinek, Andres Freund) + + + + The initial snapshot created for a logical decoding replication slot + was potentially incorrect. This could cause third-party tools that + use logical decoding to copy incomplete/inconsistent initial data. + This was more likely to happen if the source server was busy at the + time of slot creation, or if another logical slot already existed. + + + + If you are using a replication tool that depends on logical decoding, + and it should have copied a nonempty data set at the start of + replication, it is advisable to recreate the replica after + installing this update, or to verify its contents against the source + server. + + + + + + Fix possible corruption of init forks of unlogged indexes + (Robert Haas, Michael Paquier) + + + + This could result in an unlogged index being set to an invalid state + after a crash and restart. Such a problem would persist until the + index was dropped and rebuilt. + + + + + + Fix incorrect reconstruction of pg_subtrans entries + when a standby server replays a prepared but uncommitted two-phase + transaction (Tom Lane) + + + + In most cases this turned out to have no visible ill effects, but in + corner cases it could result in circular references + in pg_subtrans, potentially causing infinite loops + in queries that examine rows modified by the two-phase transaction. + + + + + + Avoid possible crash in walsender due to failure + to initialize a string buffer (Stas Kelvich, Fujii Masao) + + + + + + Fix possible crash when rescanning a nearest-neighbor index-only scan + on a GiST index (Tom Lane) + + + + + + Fix postmaster's handling of fork() failure for a + background worker process (Tom Lane) + + + + Previously, the postmaster updated portions of its state as though + the process had been launched successfully, resulting in subsequent + confusion. + + + + + + + Fix crash or wrong answers when a GROUPING SETS column's + data type is hashable but not sortable (Pavan Deolasee) + + + + + + Avoid applying physical targetlist optimization to custom + scans (Dmitry Ivanov, Tom Lane) + + + + This optimization supposed that retrieving all columns of a tuple + is inexpensive, which is true for ordinary Postgres tuples; but it + might not be the case for a custom scan provider. + + + + + + Use the correct sub-expression when applying a FOR ALL + row-level-security policy (Stephen Frost) + + + + In some cases the WITH CHECK restriction would be applied + when the USING restriction is more appropriate. + + + + + + Ensure parsing of queries in extension scripts sees the results of + immediately-preceding DDL (Julien Rouhaud, Tom Lane) + + + + Due to lack of a cache flush step between commands in an extension + script file, non-utility queries might not see the effects of an + immediately preceding catalog change, such as ALTER TABLE + ... RENAME. + + + + + + Skip tablespace privilege checks when ALTER TABLE ... ALTER + COLUMN TYPE rebuilds an existing index (Noah Misch) + + + + The command failed if the calling user did not currently have + CREATE privilege for the tablespace containing the index. + That behavior seems unhelpful, so skip the check, allowing the + index to be rebuilt where it is. + + + + + + Fix ALTER TABLE ... VALIDATE CONSTRAINT to not recurse + to child tables when the constraint is marked NO INHERIT + (Amit Langote) + + + + This fix prevents unwanted constraint does not exist failures + when no matching constraint is present in the child tables. + + + + + + Avoid dangling pointer in COPY ... TO when row-level + security is active for the source table (Tom Lane) + + + + Usually this had no ill effects, but sometimes it would cause + unexpected errors or crashes. + + + + + + Avoid accessing an already-closed relcache entry in CLUSTER + and VACUUM FULL (Tom Lane) + + + + With some bad luck, this could lead to indexes on the target + relation getting rebuilt with the wrong persistence setting. + + + + + + Fix VACUUM to account properly for pages that could not + be scanned due to conflicting page pins (Andrew Gierth) + + + + This tended to lead to underestimation of the number of tuples in + the table. In the worst case of a small heavily-contended + table, VACUUM could incorrectly report that the table + contained no tuples, leading to very bad planning choices. + + + + + + Ensure that bulk-tuple-transfer loops within a hash join are + interruptible by query cancel requests (Tom Lane, Thomas Munro) + + + + + + Fix integer-overflow problems in interval comparison (Kyotaro + Horiguchi, Tom Lane) + + + + The comparison operators for type interval could yield wrong + answers for intervals larger than about 296000 years. Indexes on + columns containing such large values should be reindexed, since they + may be corrupt. + + + + + + Fix cursor_to_xml() to produce valid output + with tableforest = false + (Thomas Munro, Peter Eisentraut) + + + + Previously it failed to produce a wrapping <table> + element. + + + + + + Fix roundoff problems in float8_timestamptz() + and make_interval() (Tom Lane) + + + + These functions truncated, rather than rounded, when converting a + floating-point value to integer microseconds; that could cause + unexpectedly off-by-one results. + + + + + + Fix pg_get_object_address() to handle members of operator + families correctly (Álvaro Herrera) + + + + + + Improve performance of pg_timezone_names view + (Tom Lane, David Rowley) + + + + + + Reduce memory management overhead for contexts containing many large + blocks (Tom Lane) + + + + + + Fix sloppy handling of corner-case errors from lseek() + and close() (Tom Lane) + + + + Neither of these system calls are likely to fail in typical situations, + but if they did, fd.c could get quite confused. + + + + + + Fix incorrect check for whether postmaster is running as a Windows + service (Michael Paquier) + + + + This could result in attempting to write to the event log when that + isn't accessible, so that no logging happens at all. + + + + + + Fix ecpg to support COMMIT PREPARED + and ROLLBACK PREPARED (Masahiko Sawada) + + + + + + Fix a double-free error when processing dollar-quoted string literals + in ecpg (Michael Meskes) + + + + + + In pg_dump, fix incorrect schema and owner marking for + comments and security labels of some types of database objects + (Giuseppe Broccolo, Tom Lane) + + + + In simple cases this caused no ill effects; but for example, a + schema-selective restore might omit comments it should include, because + they were not marked as belonging to the schema of their associated + object. + + + + + + Avoid emitting an invalid list file in pg_restore -l + when SQL object names contain newlines (Tom Lane) + + + + Replace newlines by spaces, which is sufficient to make the output + valid for pg_restore -L's purposes. + + + + + + Fix pg_upgrade to transfer comments and security labels + attached to large objects (blobs) (Stephen Frost) + + + + Previously, blobs were correctly transferred to the new database, but + any comments or security labels attached to them were lost. + + + + + + Improve error handling + in contrib/adminpack's pg_file_write() + function (Noah Misch) + + + + Notably, it failed to detect errors reported + by fclose(). + + + + + + In contrib/dblink, avoid leaking the previous unnamed + connection when establishing a new unnamed connection (Joe Conway) + + + + + + Fix contrib/pg_trgm's extraction of trigrams from regular + expressions (Tom Lane) + + + + In some cases it would produce a broken data structure that could never + match anything, leading to GIN or GiST indexscans that use a trigram + index not finding any matches to the regular expression. + + + + + + + In contrib/postgres_fdw, + transmit query cancellation requests to the remote server + (Michael Paquier, Etsuro Fujita) + + + + Previously, a local query cancellation request did not cause an + already-sent remote query to terminate early. This is a back-patch + of work originally done for 9.6. + + + + + + Support Tcl 8.6 in MSVC builds (Álvaro Herrera) + + + + + + Sync our copy of the timezone library with IANA release tzcode2017b + (Tom Lane) + + + + This fixes a bug affecting some DST transitions in January 2038. + + + + + + Update time zone data files to tzdata release 2017b + for DST law changes in Chile, Haiti, and Mongolia, plus historical + corrections for Ecuador, Kazakhstan, Liberia, and Spain. + Switch to numeric abbreviations for numerous time zones in South + America, the Pacific and Indian oceans, and some Asian and Middle + Eastern countries. + + + + The IANA time zone database previously provided textual abbreviations + for all time zones, sometimes making up abbreviations that have little + or no currency among the local population. They are in process of + reversing that policy in favor of using numeric UTC offsets in zones + where there is no evidence of real-world use of an English + abbreviation. At least for the time being, PostgreSQL + will continue to accept such removed abbreviations for timestamp input. + But they will not be shown in the pg_timezone_names + view nor used for output. + + + + + + Use correct daylight-savings rules for POSIX-style time zone names + in MSVC builds (David Rowley) + + + + The Microsoft MSVC build scripts neglected to install + the posixrules file in the timezone directory tree. + This resulted in the timezone code falling back to its built-in + rule about what DST behavior to assume for a POSIX-style time zone + name. For historical reasons that still corresponds to the DST rules + the USA was using before 2007 (i.e., change on first Sunday in April + and last Sunday in October). With this fix, a POSIX-style zone name + will use the current and historical DST transition dates of + the US/Eastern zone. If you don't want that, remove + the posixrules file, or replace it with a copy of some + other zone file (see ). Note that + due to caching, you may need to restart the server to get such changes + to take effect. + + + + + + + + Release 9.5.6 diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml index 0ef2b0c64e..1ec705c71b 100644 --- a/doc/src/sgml/release-9.6.sgml +++ b/doc/src/sgml/release-9.6.sgml @@ -1,6 +1,953 @@ + + Release 9.6.3 + + + Release Date + 2017-05-11 + + + + This release contains a variety of fixes from 9.6.2. + For information about new features in the 9.6 major release, see + . + + + + Migration to Version 9.6.3 + + + A dump/restore is not required for those running 9.6.X. + + + + However, if you are using third-party replication tools that depend + on logical decoding, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.6.2, + see . + + + + + Changes + + + + + + + Fix possibly-invalid initial snapshot during logical decoding + (Petr Jelinek, Andres Freund) + + + + The initial snapshot created for a logical decoding replication slot + was potentially incorrect. This could cause third-party tools that + use logical decoding to copy incomplete/inconsistent initial data. + This was more likely to happen if the source server was busy at the + time of slot creation, or if another logical slot already existed. + + + + If you are using a replication tool that depends on logical decoding, + and it should have copied a nonempty data set at the start of + replication, it is advisable to recreate the replica after + installing this update, or to verify its contents against the source + server. + + + + + + + Fix possible corruption of init forks of unlogged indexes + (Robert Haas, Michael Paquier) + + + + This could result in an unlogged index being set to an invalid state + after a crash and restart. Such a problem would persist until the + index was dropped and rebuilt. + + + + + + + Fix incorrect reconstruction of pg_subtrans entries + when a standby server replays a prepared but uncommitted two-phase + transaction (Tom Lane) + + + + In most cases this turned out to have no visible ill effects, but in + corner cases it could result in circular references + in pg_subtrans, potentially causing infinite loops + in queries that examine rows modified by the two-phase transaction. + + + + + + + Avoid possible crash in walsender due to failure + to initialize a string buffer (Stas Kelvich, Fujii Masao) + + + + + + + Fix possible crash when rescanning a nearest-neighbor index-only scan + on a GiST index (Tom Lane) + + + + + + + Prevent delays in postmaster's launching of multiple parallel worker + processes (Tom Lane) + + + + There could be a significant delay (up to tens of seconds) before + satisfying a query's request for more than one worker process, or when + multiple queries requested workers simultaneously. On most platforms + this required unlucky timing, but on some it was the typical case. + + + + + + + Fix postmaster's handling of fork() failure for a + background worker process (Tom Lane) + + + + Previously, the postmaster updated portions of its state as though + the process had been launched successfully, resulting in subsequent + confusion. + + + + + + + Fix possible no relation entry for relid 0 error when + planning nested set operations (Tom Lane) + + + + + + + Fix assorted minor issues in planning of parallel queries (Robert Haas) + + + + + + + Avoid applying physical targetlist optimization to custom + scans (Dmitry Ivanov, Tom Lane) + + + + This optimization supposed that retrieving all columns of a tuple + is inexpensive, which is true for ordinary Postgres tuples; but it + might not be the case for a custom scan provider. + + + + + + + Use the correct sub-expression when applying a FOR ALL + row-level-security policy (Stephen Frost) + + + + In some cases the WITH CHECK restriction would be applied + when the USING restriction is more appropriate. + + + + + + + Ensure parsing of queries in extension scripts sees the results of + immediately-preceding DDL (Julien Rouhaud, Tom Lane) + + + + Due to lack of a cache flush step between commands in an extension + script file, non-utility queries might not see the effects of an + immediately preceding catalog change, such as ALTER TABLE + ... RENAME. + + + + + + + Skip tablespace privilege checks when ALTER TABLE ... ALTER + COLUMN TYPE rebuilds an existing index (Noah Misch) + + + + The command failed if the calling user did not currently have + CREATE privilege for the tablespace containing the index. + That behavior seems unhelpful, so skip the check, allowing the + index to be rebuilt where it is. + + + + + + + Fix ALTER TABLE ... VALIDATE CONSTRAINT to not recurse + to child tables when the constraint is marked NO INHERIT + (Amit Langote) + + + + This fix prevents unwanted constraint does not exist failures + when no matching constraint is present in the child tables. + + + + + + + Avoid dangling pointer in COPY ... TO when row-level + security is active for the source table (Tom Lane) + + + + Usually this had no ill effects, but sometimes it would cause + unexpected errors or crashes. + + + + + + + Avoid accessing an already-closed relcache entry in CLUSTER + and VACUUM FULL (Tom Lane) + + + + With some bad luck, this could lead to indexes on the target + relation getting rebuilt with the wrong persistence setting. + + + + + + + Fix VACUUM to account properly for pages that could not + be scanned due to conflicting page pins (Andrew Gierth) + + + + This tended to lead to underestimation of the number of tuples in + the table. In the worst case of a small heavily-contended + table, VACUUM could incorrectly report that the table + contained no tuples, leading to very bad planning choices. + + + + + + + Ensure that bulk-tuple-transfer loops within a hash join are + interruptible by query cancel requests (Tom Lane, Thomas Munro) + + + + + + + Fix incorrect support for certain box operators in SP-GiST + (Nikita Glukhov) + + + + SP-GiST index scans using the operators &< + &> &<| and |&> + would yield incorrect answers. + + + + + + + Fix integer-overflow problems in interval comparison (Kyotaro + Horiguchi, Tom Lane) + + + + The comparison operators for type interval could yield wrong + answers for intervals larger than about 296000 years. Indexes on + columns containing such large values should be reindexed, since they + may be corrupt. + + + + + + + Fix cursor_to_xml() to produce valid output + with tableforest = false + (Thomas Munro, Peter Eisentraut) + + + + Previously it failed to produce a wrapping <table> + element. + + + + + + + Fix roundoff problems in float8_timestamptz() + and make_interval() (Tom Lane) + + + + These functions truncated, rather than rounded, when converting a + floating-point value to integer microseconds; that could cause + unexpectedly off-by-one results. + + + + + + + Fix pg_get_object_address() to handle members of operator + families correctly (Álvaro Herrera) + + + + + + + Fix cancelling of pg_stop_backup() when attempting to stop + a non-exclusive backup (Michael Paquier, David Steele) + + + + If pg_stop_backup() was cancelled while waiting for a + non-exclusive backup to end, related state was left inconsistent; + a new exclusive backup could not be started, and there were other minor + problems. + + + + + + + Improve performance of pg_timezone_names view + (Tom Lane, David Rowley) + + + + + + + Reduce memory management overhead for contexts containing many large + blocks (Tom Lane) + + + + + + + Fix sloppy handling of corner-case errors from lseek() + and close() (Tom Lane) + + + + Neither of these system calls are likely to fail in typical situations, + but if they did, fd.c could get quite confused. + + + + + + + Fix incorrect check for whether postmaster is running as a Windows + service (Michael Paquier) + + + + This could result in attempting to write to the event log when that + isn't accessible, so that no logging happens at all. + + + + + + + Fix ecpg to support COMMIT PREPARED + and ROLLBACK PREPARED (Masahiko Sawada) + + + + + + + Fix a double-free error when processing dollar-quoted string literals + in ecpg (Michael Meskes) + + + + + + + Fix pgbench to handle the combination + of + + + + + + Fix pgbench to honor the long-form option + spelling + + + + + + Fix pg_dump/pg_restore to correctly + handle privileges for the public schema when + using + + + Other schemas start out with no privileges granted, + but public does not; this requires special-case treatment + when it is dropped and restored due to the + + + + + + In pg_dump, fix incorrect schema and owner marking for + comments and security labels of some types of database objects + (Giuseppe Broccolo, Tom Lane) + + + + In simple cases this caused no ill effects; but for example, a + schema-selective restore might omit comments it should include, because + they were not marked as belonging to the schema of their associated + object. + + + + + + + Fix typo in pg_dump's query for initial privileges + of a procedural language (Peter Eisentraut) + + + + This resulted in pg_dump always believing that the + language had no initial privileges. Since that's true for most + procedural languages, ill effects from this bug are probably rare. + + + + + + + Avoid emitting an invalid list file in pg_restore -l + when SQL object names contain newlines (Tom Lane) + + + + Replace newlines by spaces, which is sufficient to make the output + valid for pg_restore -L's purposes. + + + + + + + Fix pg_upgrade to transfer comments and security labels + attached to large objects (blobs) (Stephen Frost) + + + + Previously, blobs were correctly transferred to the new database, but + any comments or security labels attached to them were lost. + + + + + + + Improve error handling + in contrib/adminpack's pg_file_write() + function (Noah Misch) + + + + Notably, it failed to detect errors reported + by fclose(). + + + + + + + In contrib/dblink, avoid leaking the previous unnamed + connection when establishing a new unnamed connection (Joe Conway) + + + + + + + Fix contrib/pg_trgm's extraction of trigrams from regular + expressions (Tom Lane) + + + + In some cases it would produce a broken data structure that could never + match anything, leading to GIN or GiST indexscans that use a trigram + index not finding any matches to the regular expression. + + + + + + + In contrib/postgres_fdw, allow join conditions that + contain shippable extension-provided functions to be pushed to the + remote server (David Rowley, Ashutosh Bapat) + + + + + + + Support Tcl 8.6 in MSVC builds (Álvaro Herrera) + + + + + + + Sync our copy of the timezone library with IANA release tzcode2017b + (Tom Lane) + + + + This fixes a bug affecting some DST transitions in January 2038. + + + + + + + Update time zone data files to tzdata release 2017b + for DST law changes in Chile, Haiti, and Mongolia, plus historical + corrections for Ecuador, Kazakhstan, Liberia, and Spain. + Switch to numeric abbreviations for numerous time zones in South + America, the Pacific and Indian oceans, and some Asian and Middle + Eastern countries. + + + + The IANA time zone database previously provided textual abbreviations + for all time zones, sometimes making up abbreviations that have little + or no currency among the local population. They are in process of + reversing that policy in favor of using numeric UTC offsets in zones + where there is no evidence of real-world use of an English + abbreviation. At least for the time being, PostgreSQL + will continue to accept such removed abbreviations for timestamp input. + But they will not be shown in the pg_timezone_names + view nor used for output. + + + + + + + Use correct daylight-savings rules for POSIX-style time zone names + in MSVC builds (David Rowley) + + + + The Microsoft MSVC build scripts neglected to install + the posixrules file in the timezone directory tree. + This resulted in the timezone code falling back to its built-in + rule about what DST behavior to assume for a POSIX-style time zone + name. For historical reasons that still corresponds to the DST rules + the USA was using before 2007 (i.e., change on first Sunday in April + and last Sunday in October). With this fix, a POSIX-style zone name + will use the current and historical DST transition dates of + the US/Eastern zone. If you don't want that, remove + the posixrules file, or replace it with a copy of some + other zone file (see ). Note that + due to caching, you may need to restart the server to get such changes + to take effect. + + + + + + + + Release 9.6.2 @@ -5765,7 +6712,7 @@ This commit is also listed under libpq and PL/pgSQL --> Transmit query cancellation requests to the remote server - (Michael Paquier) + (Michael Paquier, Etsuro Fujita) From c33c42362256382ed398df9dcda559cd547c68a7 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Fri, 5 May 2017 12:18:48 -0400 Subject: [PATCH 0047/1139] Add security checks to selectivity estimation functions Some selectivity estimation functions run user-supplied operators over data obtained from pg_statistic without security checks, which allows those operators to leak pg_statistic data without having privileges on the underlying tables. Fix by checking that one of the following is satisfied: (1) the user has table or column privileges on the table underlying the pg_statistic data, or (2) the function implementing the user-supplied operator is leak-proof. If neither is satisfied, planning will proceed as if there are no statistics available. At least one of these is satisfied in most cases in practice. The only situations that are negatively impacted are user-defined or not-leak-proof operators on a security-barrier view. Reported-by: Robert Haas Author: Peter Eisentraut Author: Tom Lane Security: CVE-2017-7484 --- doc/src/sgml/planstats.sgml | 60 ++++++++ src/backend/utils/adt/array_selfuncs.c | 6 +- src/backend/utils/adt/rangetypes_selfuncs.c | 22 +++ src/backend/utils/adt/selfuncs.c | 160 ++++++++++++++++---- src/include/utils/selfuncs.h | 2 + src/test/regress/expected/privileges.out | 97 ++++++++++++ src/test/regress/sql/privileges.sql | 61 ++++++++ 7 files changed, 376 insertions(+), 32 deletions(-) diff --git a/doc/src/sgml/planstats.sgml b/doc/src/sgml/planstats.sgml index 1a482d37f4..c667899e28 100644 --- a/doc/src/sgml/planstats.sgml +++ b/doc/src/sgml/planstats.sgml @@ -448,4 +448,64 @@ rows = (outer_cardinality * inner_cardinality) * selectivity + + Planner Statistics and Security + + + Access to the table pg_statistic is restricted to + superusers, so that ordinary users cannot learn about the contents of the + tables of other users from it. Some selectivity estimation functions will + use a user-provided operator (either the operator appearing in the query or + a related operator) to analyze the stored statistics. For example, in order + to determine whether a stored most common value is applicable, the + selectivity estimator will have to run the appropriate = + operator to compare the constant in the query to the stored value. + Thus the data in pg_statistic is potentially + passed to user-defined operators. An appropriately crafted operator can + intentionally leak the passed operands (for example, by logging them + or writing them to a different table), or accidentally leak them by showing + their values in error messages, in either case possibly exposing data from + pg_statistic to a user who should not be able to + see it. + + + + In order to prevent this, the following applies to all built-in selectivity + estimation functions. When planning a query, in order to be able to use + stored statistics, the current user must either + have SELECT privilege on the table or the involved + columns, or the operator used must be LEAKPROOF (more + accurately, the function that the operator is based on). If not, then the + selectivity estimator will behave as if no statistics are available, and + the planner will proceed with default or fall-back assumptions. + + + + If a user does not have the required privilege on the table or columns, + then in many cases the query will ultimately receive a permission-denied + error, in which case this mechanism is invisible in practice. But if the + user is reading from a security-barrier view, then the planner might wish + to check the statistics of an underlying table that is otherwise + inaccessible to the user. In that case, the operator should be leak-proof + or the statistics will not be used. There is no direct feedback about + that, except that the plan might be suboptimal. If one suspects that this + is the case, one could try running the query as a more privileged user, + to see if a different plan results. + + + + This restriction applies only to cases where the planner would need to + execute a user-defined operator on one or more values + from pg_statistic. Thus the planner is permitted + to use generic statistical information, such as the fraction of null values + or the number of distinct values in a column, regardless of access + privileges. + + + + Selectivity estimation functions contained in third-party extensions that + potentially operate on statistics with user-defined operators should follow + the same security rules. Consult the PostgreSQL source code for guidance. + + diff --git a/src/backend/utils/adt/array_selfuncs.c b/src/backend/utils/adt/array_selfuncs.c index dd44d57e20..a306477397 100644 --- a/src/backend/utils/adt/array_selfuncs.c +++ b/src/backend/utils/adt/array_selfuncs.c @@ -132,7 +132,8 @@ scalararraysel_containment(PlannerInfo *root, useOr = !useOr; /* Get array element stats for var, if available */ - if (HeapTupleIsValid(vardata.statsTuple)) + if (HeapTupleIsValid(vardata.statsTuple) && + statistic_proc_security_check(&vardata, cmpfunc->fn_oid)) { Form_pg_statistic stats; Datum *values; @@ -363,7 +364,8 @@ calc_arraycontsel(VariableStatData *vardata, Datum constval, */ array = DatumGetArrayTypeP(constval); - if (HeapTupleIsValid(vardata->statsTuple)) + if (HeapTupleIsValid(vardata->statsTuple) && + statistic_proc_security_check(vardata, cmpfunc->fn_oid)) { Form_pg_statistic stats; Datum *values; diff --git a/src/backend/utils/adt/rangetypes_selfuncs.c b/src/backend/utils/adt/rangetypes_selfuncs.c index 1aab4fe277..90c78fc3c2 100644 --- a/src/backend/utils/adt/rangetypes_selfuncs.c +++ b/src/backend/utils/adt/rangetypes_selfuncs.c @@ -255,6 +255,7 @@ calc_rangesel(TypeCacheEntry *typcache, VariableStatData *vardata, if (nnumbers != 1) elog(ERROR, "invalid empty fraction statistic"); /* shouldn't happen */ empty_frac = numbers[0]; + free_attstatsslot(vardata->atttype, NULL, 0, numbers, nnumbers); } else { @@ -383,6 +384,15 @@ calc_hist_selectivity(TypeCacheEntry *typcache, VariableStatData *vardata, bool empty; double hist_selec; + /* Can't use the histogram with insecure range support functions */ + if (!statistic_proc_security_check(vardata, + typcache->rng_cmp_proc_finfo.fn_oid)) + return -1; + if (OidIsValid(typcache->rng_subdiff_finfo.fn_oid) && + !statistic_proc_security_check(vardata, + typcache->rng_subdiff_finfo.fn_oid)) + return -1; + /* Try to get histogram of ranges */ if (!(HeapTupleIsValid(vardata->statsTuple) && get_attstatsslot(vardata->statsTuple, @@ -420,11 +430,19 @@ calc_hist_selectivity(TypeCacheEntry *typcache, VariableStatData *vardata, NULL, &length_hist_values, &length_nhist, NULL, NULL))) + { + free_attstatsslot(vardata->atttype, hist_values, nhist, NULL, 0); return -1.0; + } /* check that it's a histogram, not just a dummy entry */ if (length_nhist < 2) + { + free_attstatsslot(vardata->atttype, + length_hist_values, length_nhist, NULL, 0); + free_attstatsslot(vardata->atttype, hist_values, nhist, NULL, 0); return -1.0; + } } /* Extract the bounds of the constant value. */ @@ -560,6 +578,10 @@ calc_hist_selectivity(TypeCacheEntry *typcache, VariableStatData *vardata, break; } + free_attstatsslot(vardata->atttype, + length_hist_values, length_nhist, NULL, 0); + free_attstatsslot(vardata->atttype, hist_values, nhist, NULL, 0); + return hist_selec; } diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index 56943f2a87..6a4f7b19eb 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -112,6 +112,7 @@ #include "catalog/pg_type.h" #include "executor/executor.h" #include "mb/pg_wchar.h" +#include "miscadmin.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "optimizer/clauses.h" @@ -125,6 +126,7 @@ #include "parser/parse_clause.h" #include "parser/parse_coerce.h" #include "parser/parsetree.h" +#include "utils/acl.h" #include "utils/builtins.h" #include "utils/bytea.h" #include "utils/date.h" @@ -266,6 +268,7 @@ var_eq_const(VariableStatData *vardata, Oid operator, { double selec; bool isdefault; + Oid opfuncoid; /* * If the constant is NULL, assume operator is strict and return zero, ie, @@ -284,7 +287,9 @@ var_eq_const(VariableStatData *vardata, Oid operator, if (vardata->isunique && vardata->rel && vardata->rel->tuples >= 1.0) return 1.0 / vardata->rel->tuples; - if (HeapTupleIsValid(vardata->statsTuple)) + if (HeapTupleIsValid(vardata->statsTuple) && + statistic_proc_security_check(vardata, + (opfuncoid = get_opcode(operator)))) { Form_pg_statistic stats; Datum *values; @@ -312,7 +317,7 @@ var_eq_const(VariableStatData *vardata, Oid operator, { FmgrInfo eqproc; - fmgr_info(get_opcode(operator), &eqproc); + fmgr_info(opfuncoid, &eqproc); for (i = 0; i < nvalues; i++) { @@ -618,6 +623,7 @@ mcv_selectivity(VariableStatData *vardata, FmgrInfo *opproc, sumcommon = 0.0; if (HeapTupleIsValid(vardata->statsTuple) && + statistic_proc_security_check(vardata, opproc->fn_oid) && get_attstatsslot(vardata->statsTuple, vardata->atttype, vardata->atttypmod, STATISTIC_KIND_MCV, InvalidOid, @@ -694,6 +700,7 @@ histogram_selectivity(VariableStatData *vardata, FmgrInfo *opproc, Assert(min_hist_size > 2 * n_skip); if (HeapTupleIsValid(vardata->statsTuple) && + statistic_proc_security_check(vardata, opproc->fn_oid) && get_attstatsslot(vardata->statsTuple, vardata->atttype, vardata->atttypmod, STATISTIC_KIND_HISTOGRAM, InvalidOid, @@ -771,6 +778,7 @@ ineq_histogram_selectivity(PlannerInfo *root, * the reverse way if isgt is TRUE. */ if (HeapTupleIsValid(vardata->statsTuple) && + statistic_proc_security_check(vardata, opproc->fn_oid) && get_attstatsslot(vardata->statsTuple, vardata->atttype, vardata->atttypmod, STATISTIC_KIND_HISTOGRAM, InvalidOid, @@ -2255,6 +2263,7 @@ eqjoinsel_inner(Oid operator, double nd2; bool isdefault1; bool isdefault2; + Oid opfuncoid; Form_pg_statistic stats1 = NULL; Form_pg_statistic stats2 = NULL; bool have_mcvs1 = false; @@ -2271,30 +2280,36 @@ eqjoinsel_inner(Oid operator, nd1 = get_variable_numdistinct(vardata1, &isdefault1); nd2 = get_variable_numdistinct(vardata2, &isdefault2); + opfuncoid = get_opcode(operator); + if (HeapTupleIsValid(vardata1->statsTuple)) { + /* note we allow use of nullfrac regardless of security check */ stats1 = (Form_pg_statistic) GETSTRUCT(vardata1->statsTuple); - have_mcvs1 = get_attstatsslot(vardata1->statsTuple, - vardata1->atttype, - vardata1->atttypmod, - STATISTIC_KIND_MCV, - InvalidOid, - NULL, - &values1, &nvalues1, - &numbers1, &nnumbers1); + if (statistic_proc_security_check(vardata1, opfuncoid)) + have_mcvs1 = get_attstatsslot(vardata1->statsTuple, + vardata1->atttype, + vardata1->atttypmod, + STATISTIC_KIND_MCV, + InvalidOid, + NULL, + &values1, &nvalues1, + &numbers1, &nnumbers1); } if (HeapTupleIsValid(vardata2->statsTuple)) { + /* note we allow use of nullfrac regardless of security check */ stats2 = (Form_pg_statistic) GETSTRUCT(vardata2->statsTuple); - have_mcvs2 = get_attstatsslot(vardata2->statsTuple, - vardata2->atttype, - vardata2->atttypmod, - STATISTIC_KIND_MCV, - InvalidOid, - NULL, - &values2, &nvalues2, - &numbers2, &nnumbers2); + if (statistic_proc_security_check(vardata2, opfuncoid)) + have_mcvs2 = get_attstatsslot(vardata2->statsTuple, + vardata2->atttype, + vardata2->atttypmod, + STATISTIC_KIND_MCV, + InvalidOid, + NULL, + &values2, &nvalues2, + &numbers2, &nnumbers2); } if (have_mcvs1 && have_mcvs2) @@ -2328,7 +2343,7 @@ eqjoinsel_inner(Oid operator, int i, nmatches; - fmgr_info(get_opcode(operator), &eqproc); + fmgr_info(opfuncoid, &eqproc); hasmatch1 = (bool *) palloc0(nvalues1 * sizeof(bool)); hasmatch2 = (bool *) palloc0(nvalues2 * sizeof(bool)); @@ -2471,6 +2486,7 @@ eqjoinsel_inner(Oid operator, * * (Also used for anti join, which we are supposed to estimate the same way.) * Caller has ensured that vardata1 is the LHS variable. + * Unlike eqjoinsel_inner, we have to cope with operator being InvalidOid. */ static double eqjoinsel_semi(Oid operator, @@ -2482,6 +2498,7 @@ eqjoinsel_semi(Oid operator, double nd2; bool isdefault1; bool isdefault2; + Oid opfuncoid; Form_pg_statistic stats1 = NULL; bool have_mcvs1 = false; Datum *values1 = NULL; @@ -2497,6 +2514,8 @@ eqjoinsel_semi(Oid operator, nd1 = get_variable_numdistinct(vardata1, &isdefault1); nd2 = get_variable_numdistinct(vardata2, &isdefault2); + opfuncoid = OidIsValid(operator) ? get_opcode(operator) : InvalidOid; + /* * We clamp nd2 to be not more than what we estimate the inner relation's * size to be. This is intuitively somewhat reasonable since obviously @@ -2518,18 +2537,21 @@ eqjoinsel_semi(Oid operator, if (HeapTupleIsValid(vardata1->statsTuple)) { + /* note we allow use of nullfrac regardless of security check */ stats1 = (Form_pg_statistic) GETSTRUCT(vardata1->statsTuple); - have_mcvs1 = get_attstatsslot(vardata1->statsTuple, - vardata1->atttype, - vardata1->atttypmod, - STATISTIC_KIND_MCV, - InvalidOid, - NULL, - &values1, &nvalues1, - &numbers1, &nnumbers1); + if (statistic_proc_security_check(vardata1, opfuncoid)) + have_mcvs1 = get_attstatsslot(vardata1->statsTuple, + vardata1->atttype, + vardata1->atttypmod, + STATISTIC_KIND_MCV, + InvalidOid, + NULL, + &values1, &nvalues1, + &numbers1, &nnumbers1); } - if (HeapTupleIsValid(vardata2->statsTuple)) + if (HeapTupleIsValid(vardata2->statsTuple) && + statistic_proc_security_check(vardata2, opfuncoid)) { have_mcvs2 = get_attstatsslot(vardata2->statsTuple, vardata2->atttype, @@ -2571,7 +2593,7 @@ eqjoinsel_semi(Oid operator, */ clamped_nvalues2 = Min(nvalues2, nd2); - fmgr_info(get_opcode(operator), &eqproc); + fmgr_info(opfuncoid, &eqproc); hasmatch1 = (bool *) palloc0(nvalues1 * sizeof(bool)); hasmatch2 = (bool *) palloc0(clamped_nvalues2 * sizeof(bool)); @@ -4387,6 +4409,9 @@ get_join_variables(PlannerInfo *root, List *args, SpecialJoinInfo *sjinfo, * this query. (Caution: this should be trusted for statistical * purposes only, since we do not check indimmediate nor verify that * the exact same definition of equality applies.) + * acl_ok: TRUE if current user has permission to read the column(s) + * underlying the pg_statistic entry. This is consulted by + * statistic_proc_security_check(). * * Caller is responsible for doing ReleaseVariableStats() before exiting. */ @@ -4555,6 +4580,30 @@ examine_variable(PlannerInfo *root, Node *node, int varRelid, Int16GetDatum(pos + 1), BoolGetDatum(false)); vardata->freefunc = ReleaseSysCache; + + if (HeapTupleIsValid(vardata->statsTuple)) + { + /* Get index's table for permission check */ + RangeTblEntry *rte; + + rte = planner_rt_fetch(index->rel->relid, root); + Assert(rte->rtekind == RTE_RELATION); + + /* + * For simplicity, we insist on the whole + * table being selectable, rather than trying + * to identify which column(s) the index + * depends on. + */ + vardata->acl_ok = + (pg_class_aclcheck(rte->relid, GetUserId(), + ACL_SELECT) == ACLCHECK_OK); + } + else + { + /* suppress leakproofness checks later */ + vardata->acl_ok = true; + } } if (vardata->statsTuple) break; @@ -4607,6 +4656,21 @@ examine_simple_variable(PlannerInfo *root, Var *var, Int16GetDatum(var->varattno), BoolGetDatum(rte->inh)); vardata->freefunc = ReleaseSysCache; + + if (HeapTupleIsValid(vardata->statsTuple)) + { + /* check if user has permission to read this column */ + vardata->acl_ok = + (pg_class_aclcheck(rte->relid, GetUserId(), + ACL_SELECT) == ACLCHECK_OK) || + (pg_attribute_aclcheck(rte->relid, var->varattno, GetUserId(), + ACL_SELECT) == ACLCHECK_OK); + } + else + { + /* suppress any possible leakproofness checks later */ + vardata->acl_ok = true; + } } else if (rte->rtekind == RTE_SUBQUERY && !rte->inh) { @@ -4723,6 +4787,30 @@ examine_simple_variable(PlannerInfo *root, Var *var, } } +/* + * Check whether it is permitted to call func_oid passing some of the + * pg_statistic data in vardata. We allow this either if the user has SELECT + * privileges on the table or column underlying the pg_statistic data or if + * the function is marked leak-proof. + */ +bool +statistic_proc_security_check(VariableStatData *vardata, Oid func_oid) +{ + if (vardata->acl_ok) + return true; + + if (!OidIsValid(func_oid)) + return false; + + if (get_func_leakproof(func_oid)) + return true; + + ereport(DEBUG2, + (errmsg_internal("not using statistics because function \"%s\" is not leak-proof", + get_func_name(func_oid)))); + return false; +} + /* * get_variable_numdistinct * Estimate the number of distinct values of a variable. @@ -4865,6 +4953,7 @@ get_variable_range(PlannerInfo *root, VariableStatData *vardata, Oid sortop, bool have_data = false; int16 typLen; bool typByVal; + Oid opfuncoid; Datum *values; int nvalues; int i; @@ -4887,6 +4976,17 @@ get_variable_range(PlannerInfo *root, VariableStatData *vardata, Oid sortop, return false; } + /* + * If we can't apply the sortop to the stats data, just fail. In + * principle, if there's a histogram and no MCVs, we could return the + * histogram endpoints without ever applying the sortop ... but it's + * probably not worth trying, because whatever the caller wants to do with + * the endpoints would likely fail the security check too. + */ + if (!statistic_proc_security_check(vardata, + (opfuncoid = get_opcode(sortop)))) + return false; + get_typlenbyval(vardata->atttype, &typLen, &typByVal); /* @@ -4939,7 +5039,7 @@ get_variable_range(PlannerInfo *root, VariableStatData *vardata, Oid sortop, bool tmax_is_mcv = false; FmgrInfo opproc; - fmgr_info(get_opcode(sortop), &opproc); + fmgr_info(opfuncoid, &opproc); for (i = 0; i < nvalues; i++) { diff --git a/src/include/utils/selfuncs.h b/src/include/utils/selfuncs.h index 8e0d317468..61233aed7a 100644 --- a/src/include/utils/selfuncs.h +++ b/src/include/utils/selfuncs.h @@ -75,6 +75,7 @@ typedef struct VariableStatData Oid atttype; /* type to pass to get_attstatsslot */ int32 atttypmod; /* typmod to pass to get_attstatsslot */ bool isunique; /* matches unique index or DISTINCT clause */ + bool acl_ok; /* result of ACL check on table or column */ } VariableStatData; #define ReleaseVariableStats(vardata) \ @@ -153,6 +154,7 @@ extern PGDLLIMPORT get_index_stats_hook_type get_index_stats_hook; extern void examine_variable(PlannerInfo *root, Node *node, int varRelid, VariableStatData *vardata); +extern bool statistic_proc_security_check(VariableStatData *vardata, Oid func_oid); extern bool get_restriction_variable(PlannerInfo *root, List *args, int varRelid, VariableStatData *vardata, Node **other, diff --git a/src/test/regress/expected/privileges.out b/src/test/regress/expected/privileges.out index 8ac46ecef2..52ba77f822 100644 --- a/src/test/regress/expected/privileges.out +++ b/src/test/regress/expected/privileges.out @@ -184,6 +184,103 @@ SELECT * FROM atest1; -- ok 1 | two (2 rows) +-- test leaky-function protections in selfuncs +-- regress_user1 will own a table and provide a view for it. +SET SESSION AUTHORIZATION regress_user1; +CREATE TABLE atest12 as + SELECT x AS a, 10001 - x AS b FROM generate_series(1,10000) x; +CREATE INDEX ON atest12 (a); +CREATE INDEX ON atest12 (abs(a)); +VACUUM ANALYZE atest12; +CREATE FUNCTION leak(integer,integer) RETURNS boolean + AS $$begin return $1 < $2; end$$ + LANGUAGE plpgsql immutable; +CREATE OPERATOR <<< (procedure = leak, leftarg = integer, rightarg = integer, + restrict = scalarltsel); +-- view with leaky operator +CREATE VIEW atest12v AS + SELECT * FROM atest12 WHERE b <<< 5; +GRANT SELECT ON atest12v TO PUBLIC; +-- This plan should use nestloop, knowing that few rows will be selected. +EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b; + QUERY PLAN +------------------------------------------------- + Nested Loop + -> Seq Scan on atest12 atest12_1 + Filter: (b <<< 5) + -> Index Scan using atest12_a_idx on atest12 + Index Cond: (a = atest12_1.b) + Filter: (b <<< 5) +(6 rows) + +-- And this one. +EXPLAIN (COSTS OFF) SELECT * FROM atest12 x, atest12 y + WHERE x.a = y.b and abs(y.a) <<< 5; + QUERY PLAN +--------------------------------------------------- + Nested Loop + -> Seq Scan on atest12 y + Filter: (abs(a) <<< 5) + -> Index Scan using atest12_a_idx on atest12 x + Index Cond: (a = y.b) +(5 rows) + +-- Check if regress_user2 can break security. +SET SESSION AUTHORIZATION regress_user2; +CREATE FUNCTION leak2(integer,integer) RETURNS boolean + AS $$begin raise notice 'leak % %', $1, $2; return $1 > $2; end$$ + LANGUAGE plpgsql immutable; +CREATE OPERATOR >>> (procedure = leak2, leftarg = integer, rightarg = integer, + restrict = scalargtsel); +-- This should not show any "leak" notices before failing. +EXPLAIN (COSTS OFF) SELECT * FROM atest12 WHERE a >>> 0; +ERROR: permission denied for relation atest12 +-- This plan should use hashjoin, as it will expect many rows to be selected. +EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b; + QUERY PLAN +------------------------------------------- + Hash Join + Hash Cond: (atest12.a = atest12_1.b) + -> Seq Scan on atest12 + Filter: (b <<< 5) + -> Hash + -> Seq Scan on atest12 atest12_1 + Filter: (b <<< 5) +(7 rows) + +-- Now regress_user1 grants sufficient access to regress_user2. +SET SESSION AUTHORIZATION regress_user1; +GRANT SELECT (a, b) ON atest12 TO PUBLIC; +SET SESSION AUTHORIZATION regress_user2; +-- Now regress_user2 will also get a good row estimate. +EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b; + QUERY PLAN +------------------------------------------------- + Nested Loop + -> Seq Scan on atest12 atest12_1 + Filter: (b <<< 5) + -> Index Scan using atest12_a_idx on atest12 + Index Cond: (a = atest12_1.b) + Filter: (b <<< 5) +(6 rows) + +-- But not for this, due to lack of table-wide permissions needed +-- to make use of the expression index's statistics. +EXPLAIN (COSTS OFF) SELECT * FROM atest12 x, atest12 y + WHERE x.a = y.b and abs(y.a) <<< 5; + QUERY PLAN +-------------------------------------- + Hash Join + Hash Cond: (x.a = y.b) + -> Seq Scan on atest12 x + -> Hash + -> Seq Scan on atest12 y + Filter: (abs(a) <<< 5) +(6 rows) + +-- clean up (regress_user1's objects are all dropped later) +DROP FUNCTION leak2(integer, integer) CASCADE; +NOTICE: drop cascades to operator >>>(integer,integer) -- groups SET SESSION AUTHORIZATION regress_user3; CREATE TABLE atest3 (one int, two int, three int); diff --git a/src/test/regress/sql/privileges.sql b/src/test/regress/sql/privileges.sql index 3d74abf043..5622f7e4a8 100644 --- a/src/test/regress/sql/privileges.sql +++ b/src/test/regress/sql/privileges.sql @@ -127,6 +127,67 @@ bar true SELECT * FROM atest1; -- ok +-- test leaky-function protections in selfuncs + +-- regress_user1 will own a table and provide a view for it. +SET SESSION AUTHORIZATION regress_user1; + +CREATE TABLE atest12 as + SELECT x AS a, 10001 - x AS b FROM generate_series(1,10000) x; +CREATE INDEX ON atest12 (a); +CREATE INDEX ON atest12 (abs(a)); +VACUUM ANALYZE atest12; + +CREATE FUNCTION leak(integer,integer) RETURNS boolean + AS $$begin return $1 < $2; end$$ + LANGUAGE plpgsql immutable; +CREATE OPERATOR <<< (procedure = leak, leftarg = integer, rightarg = integer, + restrict = scalarltsel); + +-- view with leaky operator +CREATE VIEW atest12v AS + SELECT * FROM atest12 WHERE b <<< 5; +GRANT SELECT ON atest12v TO PUBLIC; + +-- This plan should use nestloop, knowing that few rows will be selected. +EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b; + +-- And this one. +EXPLAIN (COSTS OFF) SELECT * FROM atest12 x, atest12 y + WHERE x.a = y.b and abs(y.a) <<< 5; + +-- Check if regress_user2 can break security. +SET SESSION AUTHORIZATION regress_user2; + +CREATE FUNCTION leak2(integer,integer) RETURNS boolean + AS $$begin raise notice 'leak % %', $1, $2; return $1 > $2; end$$ + LANGUAGE plpgsql immutable; +CREATE OPERATOR >>> (procedure = leak2, leftarg = integer, rightarg = integer, + restrict = scalargtsel); + +-- This should not show any "leak" notices before failing. +EXPLAIN (COSTS OFF) SELECT * FROM atest12 WHERE a >>> 0; + +-- This plan should use hashjoin, as it will expect many rows to be selected. +EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b; + +-- Now regress_user1 grants sufficient access to regress_user2. +SET SESSION AUTHORIZATION regress_user1; +GRANT SELECT (a, b) ON atest12 TO PUBLIC; +SET SESSION AUTHORIZATION regress_user2; + +-- Now regress_user2 will also get a good row estimate. +EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b; + +-- But not for this, due to lack of table-wide permissions needed +-- to make use of the expression index's statistics. +EXPLAIN (COSTS OFF) SELECT * FROM atest12 x, atest12 y + WHERE x.a = y.b and abs(y.a) <<< 5; + +-- clean up (regress_user1's objects are all dropped later) +DROP FUNCTION leak2(integer, integer) CASCADE; + + -- groups SET SESSION AUTHORIZATION regress_user3; From 0294ac2a5df1ef6e8685fc0b653db5aa21860db4 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Mon, 8 May 2017 10:10:54 -0400 Subject: [PATCH 0048/1139] Translation updates Source-Git-URL: git://git.postgresql.org/git/pgtranslation/messages.git Source-Git-Hash: dd6f9ed0d9d7b33d328761dcdd3a70f44aaff6ff --- src/backend/po/fr.po | 4175 ++++++++-------- src/backend/po/it.po | 6861 +++++++++++++------------- src/backend/po/ko.po | 4418 +++++++++-------- src/backend/po/ru.po | 82 +- src/bin/initdb/po/it.po | 265 +- src/bin/pg_basebackup/po/de.po | 418 +- src/bin/pg_basebackup/po/ja.po | 486 +- src/bin/pg_config/po/it.po | 14 +- src/bin/pg_config/po/ja.po | 121 +- src/bin/pg_controldata/po/it.po | 51 +- src/bin/pg_controldata/po/ja.po | 282 +- src/bin/pg_controldata/po/ru.po | 4 +- src/bin/pg_ctl/po/ja.po | 390 +- src/bin/pg_dump/po/fr.po | 1386 +++--- src/bin/pg_dump/po/it.po | 904 ++-- src/bin/pg_dump/po/ja.po | 1567 +++--- src/bin/pg_dump/po/ru.po | 22 +- src/bin/pg_resetxlog/po/ja.po | 31 +- src/bin/pg_resetxlog/po/ru.po | 4 +- src/bin/pg_rewind/po/it.po | 198 +- src/bin/pg_rewind/po/ja.po | 136 +- src/bin/psql/po/it.po | 2502 +++++----- src/bin/psql/po/ja.po | 3769 ++++++++------ src/bin/scripts/po/ja.po | 146 +- src/interfaces/ecpg/preproc/po/it.po | 180 +- src/interfaces/ecpg/preproc/po/ja.po | 209 +- src/interfaces/libpq/po/de.po | 219 +- src/interfaces/libpq/po/it.po | 209 +- src/interfaces/libpq/po/ja.po | 542 +- src/pl/plperl/po/ja.po | 111 +- src/pl/plpgsql/src/po/ja.po | 421 +- src/pl/plpython/po/fr.po | 136 +- src/pl/plpython/po/it.po | 95 +- src/pl/plpython/po/ja.po | 259 +- src/pl/plpython/po/ru.po | 4 +- 35 files changed, 15810 insertions(+), 14807 deletions(-) diff --git a/src/backend/po/fr.po b/src/backend/po/fr.po index 629554d0fc..c70937040c 100644 --- a/src/backend/po/fr.po +++ b/src/backend/po/fr.po @@ -8,8 +8,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-11-26 18:38+0000\n" -"PO-Revision-Date: 2016-11-26 22:31+0100\n" +"POT-Creation-Date: 2017-02-06 16:08+0000\n" +"PO-Revision-Date: 2017-02-06 19:01+0100\n" "Last-Translator: Guillaume Lelarge \n" "Language-Team: French \n" "Language: fr\n" @@ -17,13 +17,13 @@ msgstr "" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n > 1);\n" -"X-Generator: Poedit 1.8.8\n" +"X-Generator: Poedit 1.8.11\n" #: ../common/config_info.c:131 ../common/config_info.c:139 ../common/config_info.c:147 ../common/config_info.c:155 ../common/config_info.c:163 ../common/config_info.c:171 ../common/config_info.c:179 ../common/config_info.c:187 ../common/config_info.c:195 msgid "not recorded" msgstr "non enregistré" -#: ../common/controldata_utils.c:52 commands/copy.c:2833 commands/extension.c:3120 utils/adt/genfile.c:134 +#: ../common/controldata_utils.c:52 commands/copy.c:2833 commands/extension.c:3141 utils/adt/genfile.c:134 #, c-format msgid "could not open file \"%s\" for reading: %m" msgstr "n'a pas pu ouvrir le fichier « %s » pour une lecture : %m" @@ -33,7 +33,7 @@ msgstr "n'a pas pu ouvrir le fichier « %s » pour une lecture : %m" msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s : n'a pas pu ouvrir le fichier « %s » en lecture : %s\n" -#: ../common/controldata_utils.c:66 access/transam/timeline.c:346 access/transam/xlog.c:3194 access/transam/xlog.c:10375 access/transam/xlog.c:10388 access/transam/xlog.c:10751 access/transam/xlog.c:10794 access/transam/xlog.c:10833 access/transam/xlog.c:10876 access/transam/xlogfuncs.c:665 access/transam/xlogfuncs.c:684 commands/extension.c:3130 replication/logical/origin.c:665 replication/logical/origin.c:695 +#: ../common/controldata_utils.c:66 access/transam/timeline.c:346 access/transam/xlog.c:3220 access/transam/xlog.c:10423 access/transam/xlog.c:10436 access/transam/xlog.c:10828 access/transam/xlog.c:10871 access/transam/xlog.c:10910 access/transam/xlog.c:10953 access/transam/xlogfuncs.c:665 access/transam/xlogfuncs.c:684 commands/extension.c:3151 replication/logical/origin.c:665 replication/logical/origin.c:695 #: replication/logical/reorderbuffer.c:3099 replication/walsender.c:499 storage/file/copydir.c:176 utils/adt/genfile.c:151 #, c-format msgid "could not read file \"%s\": %m" @@ -141,8 +141,8 @@ msgstr "n'a pas pu lire le répertoire « %s » : %s\n" msgid "could not close directory \"%s\": %s\n" msgstr "n'a pas pu fermer le répertoire « %s » : %s\n" -#: ../common/psprintf.c:179 ../port/path.c:630 ../port/path.c:668 ../port/path.c:685 access/transam/twophase.c:1261 access/transam/xlog.c:6082 lib/stringinfo.c:258 libpq/auth.c:850 libpq/auth.c:1213 libpq/auth.c:1281 libpq/auth.c:1797 postmaster/bgworker.c:289 postmaster/bgworker.c:796 postmaster/postmaster.c:2335 postmaster/postmaster.c:2366 postmaster/postmaster.c:3899 postmaster/postmaster.c:4589 postmaster/postmaster.c:4664 -#: postmaster/postmaster.c:5339 postmaster/postmaster.c:5603 replication/libpqwalreceiver/libpqwalreceiver.c:143 replication/logical/logical.c:168 storage/buffer/localbuf.c:436 storage/file/fd.c:729 storage/file/fd.c:1126 storage/file/fd.c:1244 storage/file/fd.c:1916 storage/ipc/procarray.c:1060 storage/ipc/procarray.c:1546 storage/ipc/procarray.c:1553 storage/ipc/procarray.c:1967 storage/ipc/procarray.c:2570 utils/adt/formatting.c:1522 +#: ../common/psprintf.c:179 ../port/path.c:630 ../port/path.c:668 ../port/path.c:685 access/transam/twophase.c:1262 access/transam/xlog.c:6108 lib/stringinfo.c:258 libpq/auth.c:850 libpq/auth.c:1213 libpq/auth.c:1281 libpq/auth.c:1797 postmaster/bgworker.c:289 postmaster/bgworker.c:796 postmaster/postmaster.c:2335 postmaster/postmaster.c:2366 postmaster/postmaster.c:3899 postmaster/postmaster.c:4589 postmaster/postmaster.c:4664 +#: postmaster/postmaster.c:5339 postmaster/postmaster.c:5603 replication/libpqwalreceiver/libpqwalreceiver.c:143 replication/logical/logical.c:168 storage/buffer/localbuf.c:436 storage/file/fd.c:729 storage/file/fd.c:1126 storage/file/fd.c:1244 storage/file/fd.c:1916 storage/ipc/procarray.c:1061 storage/ipc/procarray.c:1547 storage/ipc/procarray.c:1554 storage/ipc/procarray.c:1968 storage/ipc/procarray.c:2571 utils/adt/formatting.c:1522 #: utils/adt/formatting.c:1642 utils/adt/formatting.c:1763 utils/adt/pg_locale.c:463 utils/adt/pg_locale.c:647 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 utils/adt/varlena.c:4461 utils/fmgr/dfmgr.c:216 utils/hash/dynahash.c:429 utils/hash/dynahash.c:535 utils/hash/dynahash.c:1047 utils/mb/mbutils.c:376 utils/mb/mbutils.c:709 utils/misc/guc.c:3888 utils/misc/guc.c:3904 utils/misc/guc.c:3917 utils/misc/guc.c:6863 utils/misc/tzparser.c:468 #: utils/mmgr/aset.c:509 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 utils/mmgr/mcxt.c:839 utils/mmgr/mcxt.c:876 utils/mmgr/mcxt.c:910 utils/mmgr/mcxt.c:939 utils/mmgr/mcxt.c:973 utils/mmgr/mcxt.c:1055 utils/mmgr/mcxt.c:1089 utils/mmgr/mcxt.c:1138 #, c-format @@ -506,17 +506,17 @@ msgstr "" "Le nombre de colonnes renvoyées (%d) ne correspond pas au nombre de colonnes\n" "attendues (%d)." -#: access/common/tupconvert.c:241 +#: access/common/tupconvert.c:314 #, c-format msgid "Attribute \"%s\" of type %s does not match corresponding attribute of type %s." msgstr "L'attribut « %s » du type %s ne correspond pas à l'attribut correspondant de type %s." -#: access/common/tupconvert.c:253 +#: access/common/tupconvert.c:326 #, c-format msgid "Attribute \"%s\" of type %s does not exist in type %s." msgstr "L'attribut « %s » du type %s n'existe pas dans le type %s." -#: access/common/tupdesc.c:635 parser/parse_relation.c:1517 +#: access/common/tupdesc.c:635 parser/parse_relation.c:1518 #, c-format msgid "column \"%s\" cannot be declared SETOF" msgstr "la colonne « %s » ne peut pas être déclarée SETOF" @@ -536,7 +536,7 @@ msgstr "Réduisez le maintenance_work_mem" msgid "index row size %zu exceeds maximum %zu for index \"%s\"" msgstr "la taille de la ligne index, %zu, dépasse le maximum, %zu, pour l'index « %s »" -#: access/gin/ginfast.c:989 access/transam/xlog.c:9832 access/transam/xlog.c:10303 access/transam/xlogfuncs.c:293 access/transam/xlogfuncs.c:320 access/transam/xlogfuncs.c:359 access/transam/xlogfuncs.c:380 access/transam/xlogfuncs.c:401 access/transam/xlogfuncs.c:471 access/transam/xlogfuncs.c:527 +#: access/gin/ginfast.c:989 access/transam/xlog.c:9858 access/transam/xlog.c:10362 access/transam/xlogfuncs.c:293 access/transam/xlogfuncs.c:320 access/transam/xlogfuncs.c:359 access/transam/xlogfuncs.c:380 access/transam/xlogfuncs.c:401 access/transam/xlogfuncs.c:471 access/transam/xlogfuncs.c:527 #, c-format msgid "recovery is in progress" msgstr "restauration en cours" @@ -725,12 +725,12 @@ msgstr "la famille d'opérateur gist « %s » contient l'opérateur %s avec une msgid "gist operator class \"%s\" is missing support function %d" msgstr "la famille d'opérateur gist « %s » nécessite la fonction de support %d" -#: access/hash/hashinsert.c:68 +#: access/hash/hashinsert.c:70 #, c-format msgid "index row size %zu exceeds hash maximum %zu" msgstr "la taille de la ligne index, %zu, dépasse le hachage maximum, %zu" -#: access/hash/hashinsert.c:70 access/spgist/spgdoinsert.c:1911 access/spgist/spgutils.c:703 +#: access/hash/hashinsert.c:72 access/spgist/spgdoinsert.c:1911 access/spgist/spgutils.c:703 #, c-format msgid "Values larger than a buffer page cannot be indexed." msgstr "Les valeurs plus larges qu'une page de tampon ne peuvent pas être indexées." @@ -819,12 +819,12 @@ msgstr "il manque des opérateurs pour la classe d'opérateur hash « %s »" msgid "hash operator family \"%s\" is missing cross-type operator(s)" msgstr "il manque des opérateurs inter-type pour la famille d'opérateur hash « %s »" -#: access/heap/heapam.c:1295 access/heap/heapam.c:1323 access/heap/heapam.c:1355 catalog/aclchk.c:1748 +#: access/heap/heapam.c:1295 access/heap/heapam.c:1323 access/heap/heapam.c:1355 catalog/aclchk.c:1756 #, c-format msgid "\"%s\" is an index" msgstr "« %s » est un index" -#: access/heap/heapam.c:1300 access/heap/heapam.c:1328 access/heap/heapam.c:1360 catalog/aclchk.c:1755 commands/tablecmds.c:9023 commands/tablecmds.c:12092 +#: access/heap/heapam.c:1300 access/heap/heapam.c:1328 access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9081 commands/tablecmds.c:12189 #, c-format msgid "\"%s\" is a composite type" msgstr "« %s » est un type composite" @@ -854,7 +854,7 @@ msgstr "ne peut pas mettre à jour les lignes lors d'une opération parallèle" msgid "attempted to update invisible tuple" msgstr "a tenté de mettre à jour la ligne invisible" -#: access/heap/heapam.c:4963 access/heap/heapam.c:5001 access/heap/heapam.c:5253 executor/execMain.c:2312 +#: access/heap/heapam.c:4963 access/heap/heapam.c:5001 access/heap/heapam.c:5253 executor/execMain.c:2314 #, c-format msgid "could not obtain lock on row in relation \"%s\"" msgstr "n'a pas pu obtenir un verrou sur la relation « %s »" @@ -869,12 +869,12 @@ msgstr "la ligne est trop grande : taille %zu, taille maximale %zu" msgid "could not write to file \"%s\", wrote %d of %d: %m" msgstr "n'a pas pu écrire le fichier « %s », a écrit %d de %d : %m" -#: access/heap/rewriteheap.c:963 access/heap/rewriteheap.c:1175 access/heap/rewriteheap.c:1272 access/transam/timeline.c:407 access/transam/timeline.c:483 access/transam/xlog.c:3061 access/transam/xlog.c:3223 replication/logical/snapbuild.c:1605 replication/slot.c:1088 replication/slot.c:1173 storage/file/fd.c:624 storage/file/fd.c:3052 storage/smgr/md.c:1041 storage/smgr/md.c:1274 storage/smgr/md.c:1447 utils/misc/guc.c:6885 +#: access/heap/rewriteheap.c:963 access/heap/rewriteheap.c:1175 access/heap/rewriteheap.c:1272 access/transam/timeline.c:407 access/transam/timeline.c:483 access/transam/xlog.c:3087 access/transam/xlog.c:3249 replication/logical/snapbuild.c:1605 replication/slot.c:1088 replication/slot.c:1173 storage/file/fd.c:624 storage/file/fd.c:3052 storage/smgr/md.c:1041 storage/smgr/md.c:1274 storage/smgr/md.c:1447 utils/misc/guc.c:6885 #, c-format msgid "could not fsync file \"%s\": %m" msgstr "n'a pas pu synchroniser sur disque (fsync) le fichier « %s » : %m" -#: access/heap/rewriteheap.c:1018 access/heap/rewriteheap.c:1138 access/transam/timeline.c:315 access/transam/timeline.c:461 access/transam/xlog.c:3017 access/transam/xlog.c:3166 access/transam/xlog.c:10161 access/transam/xlog.c:10199 access/transam/xlog.c:10526 postmaster/postmaster.c:4364 replication/logical/origin.c:542 replication/slot.c:1045 storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1275 +#: access/heap/rewriteheap.c:1018 access/heap/rewriteheap.c:1138 access/transam/timeline.c:315 access/transam/timeline.c:461 access/transam/xlog.c:3043 access/transam/xlog.c:3192 access/transam/xlog.c:10192 access/transam/xlog.c:10230 access/transam/xlog.c:10603 postmaster/postmaster.c:4364 replication/logical/origin.c:542 replication/slot.c:1045 storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1275 #, c-format msgid "could not create file \"%s\": %m" msgstr "n'a pas pu créer le fichier « %s » : %m" @@ -889,18 +889,18 @@ msgstr "n'a pas pu tronquer le fichier « %s » en %u : %m" msgid "could not seek to end of file \"%s\": %m" msgstr "n'a pas pu trouver la fin du fichier « %s » : %m" -#: access/heap/rewriteheap.c:1165 access/transam/timeline.c:367 access/transam/timeline.c:401 access/transam/timeline.c:477 access/transam/xlog.c:3052 access/transam/xlog.c:3216 postmaster/postmaster.c:4374 postmaster/postmaster.c:4384 replication/logical/origin.c:551 replication/logical/origin.c:587 replication/logical/origin.c:603 replication/logical/snapbuild.c:1589 replication/slot.c:1074 storage/file/copydir.c:187 +#: access/heap/rewriteheap.c:1165 access/transam/timeline.c:367 access/transam/timeline.c:401 access/transam/timeline.c:477 access/transam/xlog.c:3078 access/transam/xlog.c:3242 postmaster/postmaster.c:4374 postmaster/postmaster.c:4384 replication/logical/origin.c:551 replication/logical/origin.c:587 replication/logical/origin.c:603 replication/logical/snapbuild.c:1589 replication/slot.c:1074 storage/file/copydir.c:187 #: utils/init/miscinit.c:1228 utils/init/miscinit.c:1237 utils/init/miscinit.c:1244 utils/misc/guc.c:6846 utils/misc/guc.c:6877 utils/misc/guc.c:8727 utils/misc/guc.c:8741 utils/time/snapmgr.c:1280 utils/time/snapmgr.c:1287 #, c-format msgid "could not write to file \"%s\": %m" msgstr "n'a pas pu écrire dans le fichier « %s » : %m" -#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10393 access/transam/xlogarchive.c:114 access/transam/xlogarchive.c:468 replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2632 replication/logical/reorderbuffer.c:2689 replication/logical/snapbuild.c:1533 replication/logical/snapbuild.c:1908 replication/slot.c:1147 storage/ipc/dsm.c:326 storage/smgr/md.c:427 storage/smgr/md.c:476 storage/smgr/md.c:1394 +#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10441 access/transam/xlogarchive.c:114 access/transam/xlogarchive.c:468 replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2632 replication/logical/reorderbuffer.c:2689 replication/logical/snapbuild.c:1533 replication/logical/snapbuild.c:1908 replication/slot.c:1147 storage/ipc/dsm.c:326 storage/smgr/md.c:427 storage/smgr/md.c:476 storage/smgr/md.c:1394 #, c-format msgid "could not remove file \"%s\": %m" msgstr "n'a pas pu supprimer le fichier « %s » : %m" -#: access/heap/rewriteheap.c:1262 access/transam/timeline.c:111 access/transam/timeline.c:236 access/transam/timeline.c:334 access/transam/xlog.c:2993 access/transam/xlog.c:3110 access/transam/xlog.c:3151 access/transam/xlog.c:3424 access/transam/xlog.c:3502 access/transam/xlogutils.c:701 replication/basebackup.c:403 replication/basebackup.c:1150 replication/logical/origin.c:658 replication/logical/reorderbuffer.c:2156 +#: access/heap/rewriteheap.c:1262 access/transam/timeline.c:111 access/transam/timeline.c:236 access/transam/timeline.c:334 access/transam/xlog.c:3019 access/transam/xlog.c:3136 access/transam/xlog.c:3177 access/transam/xlog.c:3450 access/transam/xlog.c:3528 access/transam/xlogutils.c:701 replication/basebackup.c:403 replication/basebackup.c:1150 replication/logical/origin.c:658 replication/logical/reorderbuffer.c:2156 #: replication/logical/reorderbuffer.c:2402 replication/logical/reorderbuffer.c:3081 replication/logical/snapbuild.c:1582 replication/logical/snapbuild.c:1666 replication/slot.c:1162 replication/walsender.c:474 replication/walsender.c:2102 storage/file/copydir.c:155 storage/file/fd.c:607 storage/file/fd.c:2964 storage/file/fd.c:3031 storage/smgr/md.c:609 utils/error/elog.c:1879 utils/init/miscinit.c:1163 utils/init/miscinit.c:1284 #: utils/init/miscinit.c:1362 utils/misc/guc.c:7105 utils/misc/guc.c:7138 #, c-format @@ -917,7 +917,7 @@ msgstr "la méthode d'accès « %s » n'est pas de type %s" msgid "index access method \"%s\" does not have a handler" msgstr "la méthode d'accès « %s » n'a pas de handler" -#: access/index/indexam.c:155 catalog/objectaddress.c:1196 commands/indexcmds.c:1799 commands/tablecmds.c:241 commands/tablecmds.c:12083 +#: access/index/indexam.c:155 catalog/objectaddress.c:1196 commands/indexcmds.c:1799 commands/tablecmds.c:242 commands/tablecmds.c:12180 #, c-format msgid "\"%s\" is not an index" msgstr "« %s » n'est pas un index" @@ -953,7 +953,7 @@ msgstr "" "Utilisez un index sur le hachage MD5 de la valeur ou passez à l'indexation\n" "de la recherche plein texte." -#: access/nbtree/nbtpage.c:168 access/nbtree/nbtpage.c:371 access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1717 +#: access/nbtree/nbtpage.c:168 access/nbtree/nbtpage.c:371 access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1702 #, c-format msgid "index \"%s\" is not a btree" msgstr "l'index « %s » n'est pas un btree" @@ -1354,7 +1354,7 @@ msgstr "" "Les identifiants timeline doivent être plus petits que les enfants des\n" "identifiants timeline." -#: access/transam/timeline.c:412 access/transam/timeline.c:488 access/transam/xlog.c:3067 access/transam/xlog.c:3228 access/transam/xlogfuncs.c:690 commands/copy.c:1708 storage/file/copydir.c:201 +#: access/transam/timeline.c:412 access/transam/timeline.c:488 access/transam/xlog.c:3093 access/transam/xlog.c:3254 access/transam/xlogfuncs.c:690 commands/copy.c:1708 storage/file/copydir.c:201 #, c-format msgid "could not close file \"%s\": %m" msgstr "n'a pas pu fermer le fichier « %s » : %m" @@ -1394,139 +1394,139 @@ msgstr "nombre maximum de transactions préparées obtenu" msgid "Increase max_prepared_transactions (currently %d)." msgstr "Augmentez max_prepared_transactions (actuellement %d)." -#: access/transam/twophase.c:539 +#: access/transam/twophase.c:540 #, c-format msgid "prepared transaction with identifier \"%s\" is busy" msgstr "la transaction préparée d'identifiant « %s » est occupée" -#: access/transam/twophase.c:545 +#: access/transam/twophase.c:546 #, c-format msgid "permission denied to finish prepared transaction" msgstr "droit refusé pour terminer la transaction préparée" -#: access/transam/twophase.c:546 +#: access/transam/twophase.c:547 #, c-format msgid "Must be superuser or the user that prepared the transaction." msgstr "Doit être super-utilisateur ou l'utilisateur qui a préparé la transaction." -#: access/transam/twophase.c:557 +#: access/transam/twophase.c:558 #, c-format msgid "prepared transaction belongs to another database" msgstr "la transaction préparée appartient à une autre base de données" -#: access/transam/twophase.c:558 +#: access/transam/twophase.c:559 #, c-format msgid "Connect to the database where the transaction was prepared to finish it." msgstr "" "Connectez-vous à la base de données où la transaction a été préparée pour\n" "la terminer." -#: access/transam/twophase.c:573 +#: access/transam/twophase.c:574 #, c-format msgid "prepared transaction with identifier \"%s\" does not exist" msgstr "la transaction préparée d'identifiant « %s » n'existe pas" -#: access/transam/twophase.c:1042 +#: access/transam/twophase.c:1043 #, c-format msgid "two-phase state file maximum length exceeded" msgstr "" "longueur maximale dépassée pour le fichier de statut de la validation en\n" "deux phase" -#: access/transam/twophase.c:1160 +#: access/transam/twophase.c:1161 #, c-format msgid "could not open two-phase state file \"%s\": %m" msgstr "" "n'a pas pu ouvrir le fichier d'état de la validation en deux phases nommé\n" "« %s » : %m" -#: access/transam/twophase.c:1177 +#: access/transam/twophase.c:1178 #, c-format msgid "could not stat two-phase state file \"%s\": %m" msgstr "" "n'a pas pu récupérer des informations sur le fichier d'état de la validation\n" "en deux phases nommé « %s » : %m" -#: access/transam/twophase.c:1209 +#: access/transam/twophase.c:1210 #, c-format msgid "could not read two-phase state file \"%s\": %m" msgstr "" "n'a pas pu lire le fichier d'état de la validation en deux phases nommé\n" "« %s » : %m" -#: access/transam/twophase.c:1262 access/transam/xlog.c:6083 +#: access/transam/twophase.c:1263 access/transam/xlog.c:6109 #, c-format msgid "Failed while allocating an XLog reading processor." msgstr "Échec lors de l'allocation d'un processeur de lecture XLog" -#: access/transam/twophase.c:1268 +#: access/transam/twophase.c:1269 #, c-format msgid "could not read two-phase state from xlog at %X/%X" msgstr "n'a pas pu lire le fichier d'état de la validation en deux phases depuis les journaux de transaction à %X/%X" -#: access/transam/twophase.c:1276 +#: access/transam/twophase.c:1277 #, c-format msgid "expected two-phase state data is not present in xlog at %X/%X" msgstr "" "le fichier d'état de la validation en deux phases attendu n'est pas présent\n" "dans les journaux de transaction à %X/%X" -#: access/transam/twophase.c:1511 +#: access/transam/twophase.c:1512 #, c-format msgid "could not remove two-phase state file \"%s\": %m" msgstr "" "n'a pas pu supprimer le fichier d'état de la validation en deux phases\n" "« %s » : %m" -#: access/transam/twophase.c:1541 +#: access/transam/twophase.c:1542 #, c-format msgid "could not recreate two-phase state file \"%s\": %m" msgstr "" "n'a pas pu re-créer le fichier d'état de la validation en deux phases nommé\n" "« %s » : %m" -#: access/transam/twophase.c:1550 access/transam/twophase.c:1557 +#: access/transam/twophase.c:1551 access/transam/twophase.c:1558 #, c-format msgid "could not write two-phase state file: %m" msgstr "n'a pas pu écrire dans le fichier d'état de la validation en deux phases : %m" -#: access/transam/twophase.c:1569 +#: access/transam/twophase.c:1570 #, c-format msgid "could not fsync two-phase state file: %m" msgstr "" "n'a pas pu synchroniser sur disque (fsync) le fichier d'état de la\n" "validation en deux phases : %m" -#: access/transam/twophase.c:1575 +#: access/transam/twophase.c:1576 #, c-format msgid "could not close two-phase state file: %m" msgstr "n'a pas pu fermer le fichier d'état de la validation en deux phases : %m" -#: access/transam/twophase.c:1648 +#: access/transam/twophase.c:1649 #, c-format msgid "%u two-phase state file was written for long-running prepared transactions" msgid_plural "%u two-phase state files were written for long-running prepared transactions" msgstr[0] "le fichier d'état de la validation en deux phases %u a été écrit pour des transaction préparée de longue duré" msgstr[1] "les fichiers d'état de la validation en deux phases %u a été écrit pour des transaction préparée de longue duré" -#: access/transam/twophase.c:1712 +#: access/transam/twophase.c:1713 #, c-format msgid "removing future two-phase state file \"%s\"" msgstr "suppression du futur fichier d'état de la validation en deux phases nommé « %s »" -#: access/transam/twophase.c:1728 access/transam/twophase.c:1739 access/transam/twophase.c:1859 access/transam/twophase.c:1870 access/transam/twophase.c:1947 +#: access/transam/twophase.c:1729 access/transam/twophase.c:1740 access/transam/twophase.c:1860 access/transam/twophase.c:1871 access/transam/twophase.c:1948 #, c-format msgid "removing corrupt two-phase state file \"%s\"" msgstr "" "suppression du fichier d'état corrompu de la validation en deux phases nommé\n" "« %s »" -#: access/transam/twophase.c:1848 access/transam/twophase.c:1936 +#: access/transam/twophase.c:1849 access/transam/twophase.c:1937 #, c-format msgid "removing stale two-phase state file \"%s\"" msgstr "suppression du vieux fichier d'état de la validation en deux phases nommé « %s »" -#: access/transam/twophase.c:1954 +#: access/transam/twophase.c:1955 #, c-format msgid "recovering prepared transaction %u" msgstr "récupération de la transaction préparée %u" @@ -1681,147 +1681,147 @@ msgstr "ne peut pas valider de sous-transactions pendant une opération parallè msgid "cannot have more than 2^32-1 subtransactions in a transaction" msgstr "ne peut pas avoir plus de 2^32-1 sous-transactions dans une transaction" -#: access/transam/xlog.c:2273 +#: access/transam/xlog.c:2299 #, c-format msgid "could not seek in log file %s to offset %u: %m" msgstr "n'a pas pu se déplacer dans le fichier de transactions « %s » au décalage %u : %m" -#: access/transam/xlog.c:2293 +#: access/transam/xlog.c:2319 #, c-format msgid "could not write to log file %s at offset %u, length %zu: %m" msgstr "n'a pas pu écrire le fichier de transactions %s au décalage %u, longueur %zu : %m" -#: access/transam/xlog.c:2556 +#: access/transam/xlog.c:2582 #, c-format msgid "updated min recovery point to %X/%X on timeline %u" msgstr "mise à jour du point minimum de restauration sur %X/%X pour la timeline %u" -#: access/transam/xlog.c:3198 +#: access/transam/xlog.c:3224 #, c-format msgid "not enough data in file \"%s\"" msgstr "données insuffisantes dans le fichier « %s »" -#: access/transam/xlog.c:3339 +#: access/transam/xlog.c:3365 #, c-format msgid "could not open transaction log file \"%s\": %m" msgstr "n'a pas pu ouvrir le journal des transactions « %s » : %m" -#: access/transam/xlog.c:3528 access/transam/xlog.c:5313 +#: access/transam/xlog.c:3554 access/transam/xlog.c:5339 #, c-format msgid "could not close log file %s: %m" msgstr "n'a pas pu fermer le fichier de transactions « %s » : %m" -#: access/transam/xlog.c:3585 access/transam/xlogutils.c:696 replication/walsender.c:2097 +#: access/transam/xlog.c:3611 access/transam/xlogutils.c:696 replication/walsender.c:2097 #, c-format msgid "requested WAL segment %s has already been removed" msgstr "le segment demandé du journal de transaction, %s, a déjà été supprimé" -#: access/transam/xlog.c:3645 access/transam/xlog.c:3720 access/transam/xlog.c:3918 +#: access/transam/xlog.c:3671 access/transam/xlog.c:3746 access/transam/xlog.c:3944 #, c-format msgid "could not open transaction log directory \"%s\": %m" msgstr "n'a pas pu ouvrir le répertoire des journaux de transactions « %s » : %m" -#: access/transam/xlog.c:3801 +#: access/transam/xlog.c:3827 #, c-format msgid "recycled transaction log file \"%s\"" msgstr "recyclage du journal de transactions « %s »" -#: access/transam/xlog.c:3813 +#: access/transam/xlog.c:3839 #, c-format msgid "removing transaction log file \"%s\"" msgstr "suppression du journal de transactions « %s »" -#: access/transam/xlog.c:3833 +#: access/transam/xlog.c:3859 #, c-format msgid "could not rename old transaction log file \"%s\": %m" msgstr "n'a pas pu renommer l'ancien journal de transactions « %s » : %m" -#: access/transam/xlog.c:3845 +#: access/transam/xlog.c:3871 #, c-format msgid "could not remove old transaction log file \"%s\": %m" msgstr "n'a pas pu supprimer l'ancien journal de transaction « %s » : %m" -#: access/transam/xlog.c:3878 access/transam/xlog.c:3888 +#: access/transam/xlog.c:3904 access/transam/xlog.c:3914 #, c-format msgid "required WAL directory \"%s\" does not exist" msgstr "le répertoire « %s » requis pour les journaux de transactions n'existe pas" -#: access/transam/xlog.c:3894 +#: access/transam/xlog.c:3920 #, c-format msgid "creating missing WAL directory \"%s\"" msgstr "création du répertoire manquant « %s » pour les journaux de transactions" -#: access/transam/xlog.c:3897 +#: access/transam/xlog.c:3923 #, c-format msgid "could not create missing directory \"%s\": %m" msgstr "n'a pas pu créer le répertoire « %s » manquant : %m" -#: access/transam/xlog.c:3928 +#: access/transam/xlog.c:3954 #, c-format msgid "removing transaction log backup history file \"%s\"" msgstr "suppression du fichier historique des journaux de transaction « %s »" -#: access/transam/xlog.c:4009 +#: access/transam/xlog.c:4035 #, c-format msgid "unexpected timeline ID %u in log segment %s, offset %u" msgstr "identifiant timeline %u inattendu dans le journal de transactions %s, décalage %u" -#: access/transam/xlog.c:4131 +#: access/transam/xlog.c:4157 #, c-format msgid "new timeline %u is not a child of database system timeline %u" msgstr "" "le nouveau timeline %u n'est pas un fils du timeline %u du système de bases\n" "de données" -#: access/transam/xlog.c:4145 +#: access/transam/xlog.c:4171 #, c-format msgid "new timeline %u forked off current database system timeline %u before current recovery point %X/%X" msgstr "" "la nouvelle timeline %u a été créée à partir de la timeline de la base de données système %u\n" "avant le point de restauration courant %X/%X" -#: access/transam/xlog.c:4164 +#: access/transam/xlog.c:4190 #, c-format msgid "new target timeline is %u" msgstr "la nouvelle timeline cible est %u" -#: access/transam/xlog.c:4244 +#: access/transam/xlog.c:4270 #, c-format msgid "could not create control file \"%s\": %m" msgstr "n'a pas pu créer le fichier de contrôle « %s » : %m" -#: access/transam/xlog.c:4255 access/transam/xlog.c:4491 +#: access/transam/xlog.c:4281 access/transam/xlog.c:4517 #, c-format msgid "could not write to control file: %m" msgstr "n'a pas pu écrire le fichier de contrôle : %m" -#: access/transam/xlog.c:4261 access/transam/xlog.c:4497 +#: access/transam/xlog.c:4287 access/transam/xlog.c:4523 #, c-format msgid "could not fsync control file: %m" msgstr "n'a pas pu synchroniser sur disque (fsync) le fichier de contrôle : %m" -#: access/transam/xlog.c:4266 access/transam/xlog.c:4502 +#: access/transam/xlog.c:4292 access/transam/xlog.c:4528 #, c-format msgid "could not close control file: %m" msgstr "n'a pas pu fermer le fichier de contrôle : %m" -#: access/transam/xlog.c:4284 access/transam/xlog.c:4480 +#: access/transam/xlog.c:4310 access/transam/xlog.c:4506 #, c-format msgid "could not open control file \"%s\": %m" msgstr "n'a pas pu ouvrir le fichier de contrôle « %s » : %m" -#: access/transam/xlog.c:4290 +#: access/transam/xlog.c:4316 #, c-format msgid "could not read from control file: %m" msgstr "n'a pas pu lire le fichier de contrôle : %m" -#: access/transam/xlog.c:4303 access/transam/xlog.c:4312 access/transam/xlog.c:4336 access/transam/xlog.c:4343 access/transam/xlog.c:4350 access/transam/xlog.c:4355 access/transam/xlog.c:4362 access/transam/xlog.c:4369 access/transam/xlog.c:4376 access/transam/xlog.c:4383 access/transam/xlog.c:4390 access/transam/xlog.c:4397 access/transam/xlog.c:4404 access/transam/xlog.c:4413 access/transam/xlog.c:4420 access/transam/xlog.c:4429 -#: access/transam/xlog.c:4436 access/transam/xlog.c:4445 access/transam/xlog.c:4452 utils/init/miscinit.c:1380 +#: access/transam/xlog.c:4329 access/transam/xlog.c:4338 access/transam/xlog.c:4362 access/transam/xlog.c:4369 access/transam/xlog.c:4376 access/transam/xlog.c:4381 access/transam/xlog.c:4388 access/transam/xlog.c:4395 access/transam/xlog.c:4402 access/transam/xlog.c:4409 access/transam/xlog.c:4416 access/transam/xlog.c:4423 access/transam/xlog.c:4430 access/transam/xlog.c:4439 access/transam/xlog.c:4446 access/transam/xlog.c:4455 +#: access/transam/xlog.c:4462 access/transam/xlog.c:4471 access/transam/xlog.c:4478 utils/init/miscinit.c:1380 #, c-format msgid "database files are incompatible with server" msgstr "les fichiers de la base de données sont incompatibles avec le serveur" -#: access/transam/xlog.c:4304 +#: access/transam/xlog.c:4330 #, c-format msgid "The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x), but the server was compiled with PG_CONTROL_VERSION %d (0x%08x)." msgstr "" @@ -1829,300 +1829,300 @@ msgstr "" "%d (0x%08x) alors que le serveur a été compilé avec un PG_CONTROL_VERSION à\n" "%d (0x%08x)." -#: access/transam/xlog.c:4308 +#: access/transam/xlog.c:4334 #, c-format msgid "This could be a problem of mismatched byte ordering. It looks like you need to initdb." msgstr "" "Ceci peut être un problème d'incohérence dans l'ordre des octets.\n" "Il se peut que vous ayez besoin d'initdb." -#: access/transam/xlog.c:4313 +#: access/transam/xlog.c:4339 #, c-format msgid "The database cluster was initialized with PG_CONTROL_VERSION %d, but the server was compiled with PG_CONTROL_VERSION %d." msgstr "" "Le cluster de base de données a été initialisé avec un PG_CONTROL_VERSION à\n" "%d alors que le serveur a été compilé avec un PG_CONTROL_VERSION à %d." -#: access/transam/xlog.c:4316 access/transam/xlog.c:4340 access/transam/xlog.c:4347 access/transam/xlog.c:4352 +#: access/transam/xlog.c:4342 access/transam/xlog.c:4366 access/transam/xlog.c:4373 access/transam/xlog.c:4378 #, c-format msgid "It looks like you need to initdb." msgstr "Il semble que vous avez besoin d'initdb." -#: access/transam/xlog.c:4327 +#: access/transam/xlog.c:4353 #, c-format msgid "incorrect checksum in control file" msgstr "somme de contrôle incorrecte dans le fichier de contrôle" -#: access/transam/xlog.c:4337 +#: access/transam/xlog.c:4363 #, c-format msgid "The database cluster was initialized with CATALOG_VERSION_NO %d, but the server was compiled with CATALOG_VERSION_NO %d." msgstr "" "Le cluster de base de données a été initialisé avec un CATALOG_VERSION_NO à\n" "%d alors que le serveur a été compilé avec un CATALOG_VERSION_NO à %d." -#: access/transam/xlog.c:4344 +#: access/transam/xlog.c:4370 #, c-format msgid "The database cluster was initialized with MAXALIGN %d, but the server was compiled with MAXALIGN %d." msgstr "" "Le cluster de bases de données a été initialisé avec un MAXALIGN à %d alors\n" "que le serveur a été compilé avec un MAXALIGN à %d." -#: access/transam/xlog.c:4351 +#: access/transam/xlog.c:4377 #, c-format msgid "The database cluster appears to use a different floating-point number format than the server executable." msgstr "" "Le cluster de bases de données semble utiliser un format différent pour les\n" "nombres à virgule flottante de celui de l'exécutable serveur." -#: access/transam/xlog.c:4356 +#: access/transam/xlog.c:4382 #, c-format msgid "The database cluster was initialized with BLCKSZ %d, but the server was compiled with BLCKSZ %d." msgstr "" "Le cluster de base de données a été initialisé avec un BLCKSZ à %d alors que\n" "le serveur a été compilé avec un BLCKSZ à %d." -#: access/transam/xlog.c:4359 access/transam/xlog.c:4366 access/transam/xlog.c:4373 access/transam/xlog.c:4380 access/transam/xlog.c:4387 access/transam/xlog.c:4394 access/transam/xlog.c:4401 access/transam/xlog.c:4408 access/transam/xlog.c:4416 access/transam/xlog.c:4423 access/transam/xlog.c:4432 access/transam/xlog.c:4439 access/transam/xlog.c:4448 access/transam/xlog.c:4455 +#: access/transam/xlog.c:4385 access/transam/xlog.c:4392 access/transam/xlog.c:4399 access/transam/xlog.c:4406 access/transam/xlog.c:4413 access/transam/xlog.c:4420 access/transam/xlog.c:4427 access/transam/xlog.c:4434 access/transam/xlog.c:4442 access/transam/xlog.c:4449 access/transam/xlog.c:4458 access/transam/xlog.c:4465 access/transam/xlog.c:4474 access/transam/xlog.c:4481 #, c-format msgid "It looks like you need to recompile or initdb." msgstr "Il semble que vous avez besoin de recompiler ou de relancer initdb." -#: access/transam/xlog.c:4363 +#: access/transam/xlog.c:4389 #, c-format msgid "The database cluster was initialized with RELSEG_SIZE %d, but the server was compiled with RELSEG_SIZE %d." msgstr "" "Le cluster de bases de données a été initialisé avec un RELSEG_SIZE à %d\n" "alors que le serveur a été compilé avec un RELSEG_SIZE à %d." -#: access/transam/xlog.c:4370 +#: access/transam/xlog.c:4396 #, c-format msgid "The database cluster was initialized with XLOG_BLCKSZ %d, but the server was compiled with XLOG_BLCKSZ %d." msgstr "" "Le cluster de base de données a été initialisé avec un XLOG_BLCKSZ à %d\n" "alors que le serveur a été compilé avec un XLOG_BLCKSZ à %d." -#: access/transam/xlog.c:4377 +#: access/transam/xlog.c:4403 #, c-format msgid "The database cluster was initialized with XLOG_SEG_SIZE %d, but the server was compiled with XLOG_SEG_SIZE %d." msgstr "" "Le cluster de bases de données a été initialisé avec un XLOG_SEG_SIZE à %d\n" "alors que le serveur a été compilé avec un XLOG_SEG_SIZE à %d." -#: access/transam/xlog.c:4384 +#: access/transam/xlog.c:4410 #, c-format msgid "The database cluster was initialized with NAMEDATALEN %d, but the server was compiled with NAMEDATALEN %d." msgstr "" "Le cluster de bases de données a été initialisé avec un NAMEDATALEN à %d\n" "alors que le serveur a été compilé avec un NAMEDATALEN à %d." -#: access/transam/xlog.c:4391 +#: access/transam/xlog.c:4417 #, c-format msgid "The database cluster was initialized with INDEX_MAX_KEYS %d, but the server was compiled with INDEX_MAX_KEYS %d." msgstr "" "Le groupe de bases de données a été initialisé avec un INDEX_MAX_KEYS à %d\n" "alors que le serveur a été compilé avec un INDEX_MAX_KEYS à %d." -#: access/transam/xlog.c:4398 +#: access/transam/xlog.c:4424 #, c-format msgid "The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d, but the server was compiled with TOAST_MAX_CHUNK_SIZE %d." msgstr "" "Le cluster de bases de données a été initialisé avec un TOAST_MAX_CHUNK_SIZE\n" "à %d alors que le serveur a été compilé avec un TOAST_MAX_CHUNK_SIZE à %d." -#: access/transam/xlog.c:4405 +#: access/transam/xlog.c:4431 #, c-format msgid "The database cluster was initialized with LOBLKSIZE %d, but the server was compiled with LOBLKSIZE %d." msgstr "" "Le cluster de base de données a été initialisé avec un LOBLKSIZE à %d alors que\n" "le serveur a été compilé avec un LOBLKSIZE à %d." -#: access/transam/xlog.c:4414 +#: access/transam/xlog.c:4440 #, c-format msgid "The database cluster was initialized without HAVE_INT64_TIMESTAMP but the server was compiled with HAVE_INT64_TIMESTAMP." msgstr "Le cluster de bases de données a été initialisé sans HAVE_INT64_TIMESTAMPalors que le serveur a été compilé avec." -#: access/transam/xlog.c:4421 +#: access/transam/xlog.c:4447 #, c-format msgid "The database cluster was initialized with HAVE_INT64_TIMESTAMP but the server was compiled without HAVE_INT64_TIMESTAMP." msgstr "" "Le cluster de bases de données a été initialisé avec HAVE_INT64_TIMESTAMP\n" "alors que le serveur a été compilé sans." -#: access/transam/xlog.c:4430 +#: access/transam/xlog.c:4456 #, c-format msgid "The database cluster was initialized without USE_FLOAT4_BYVAL but the server was compiled with USE_FLOAT4_BYVAL." msgstr "" "Le cluster de base de données a été initialisé sans USE_FLOAT4_BYVAL\n" "alors que le serveur a été compilé avec USE_FLOAT4_BYVAL." -#: access/transam/xlog.c:4437 +#: access/transam/xlog.c:4463 #, c-format msgid "The database cluster was initialized with USE_FLOAT4_BYVAL but the server was compiled without USE_FLOAT4_BYVAL." msgstr "" "Le cluster de base de données a été initialisé avec USE_FLOAT4_BYVAL\n" "alors que le serveur a été compilé sans USE_FLOAT4_BYVAL." -#: access/transam/xlog.c:4446 +#: access/transam/xlog.c:4472 #, c-format msgid "The database cluster was initialized without USE_FLOAT8_BYVAL but the server was compiled with USE_FLOAT8_BYVAL." msgstr "" "Le cluster de base de données a été initialisé sans USE_FLOAT8_BYVAL\n" "alors que le serveur a été compilé avec USE_FLOAT8_BYVAL." -#: access/transam/xlog.c:4453 +#: access/transam/xlog.c:4479 #, c-format msgid "The database cluster was initialized with USE_FLOAT8_BYVAL but the server was compiled without USE_FLOAT8_BYVAL." msgstr "" "Le cluster de base de données a été initialisé avec USE_FLOAT8_BYVAL\n" "alors que le serveur a été compilé sans USE_FLOAT8_BYVAL." -#: access/transam/xlog.c:4874 +#: access/transam/xlog.c:4900 #, c-format msgid "could not write bootstrap transaction log file: %m" msgstr "n'a pas pu écrire le « bootstrap » du journal des transactions : %m" -#: access/transam/xlog.c:4880 +#: access/transam/xlog.c:4906 #, c-format msgid "could not fsync bootstrap transaction log file: %m" msgstr "" "n'a pas pu synchroniser sur disque (fsync) le « bootstrap » du journal des\n" "transactions : %m" -#: access/transam/xlog.c:4885 +#: access/transam/xlog.c:4911 #, c-format msgid "could not close bootstrap transaction log file: %m" msgstr "n'a pas pu fermer le « bootstrap » du journal des transactions : %m" -#: access/transam/xlog.c:4960 +#: access/transam/xlog.c:4986 #, c-format msgid "could not open recovery command file \"%s\": %m" msgstr "n'a pas pu ouvrir le fichier de restauration « %s » : %m" -#: access/transam/xlog.c:5006 access/transam/xlog.c:5091 +#: access/transam/xlog.c:5032 access/transam/xlog.c:5117 #, c-format msgid "invalid value for recovery parameter \"%s\": \"%s\"" msgstr "valeur invalide pour le paramètre de restauration « %s » : « %s »" -#: access/transam/xlog.c:5009 +#: access/transam/xlog.c:5035 #, c-format msgid "Valid values are \"pause\", \"promote\", and \"shutdown\"." msgstr "Les valeurs valides sont « pause », « promote » et « shutdown »." -#: access/transam/xlog.c:5029 +#: access/transam/xlog.c:5055 #, c-format msgid "recovery_target_timeline is not a valid number: \"%s\"" msgstr "recovery_target_timeline n'est pas un nombre valide : « %s »" -#: access/transam/xlog.c:5046 +#: access/transam/xlog.c:5072 #, c-format msgid "recovery_target_xid is not a valid number: \"%s\"" msgstr "recovery_target_xid n'est pas un nombre valide : « %s »" -#: access/transam/xlog.c:5077 +#: access/transam/xlog.c:5103 #, c-format msgid "recovery_target_name is too long (maximum %d characters)" msgstr "recovery_target_name est trop long (%d caractères maximum)" -#: access/transam/xlog.c:5094 +#: access/transam/xlog.c:5120 #, c-format msgid "The only allowed value is \"immediate\"." msgstr "La seule valeur autorisée est « immediate »." -#: access/transam/xlog.c:5107 access/transam/xlog.c:5118 commands/extension.c:533 commands/extension.c:541 utils/misc/guc.c:5640 +#: access/transam/xlog.c:5133 access/transam/xlog.c:5144 commands/extension.c:534 commands/extension.c:542 utils/misc/guc.c:5640 #, c-format msgid "parameter \"%s\" requires a Boolean value" msgstr "le paramètre « %s » requiert une valeur booléenne" -#: access/transam/xlog.c:5153 +#: access/transam/xlog.c:5179 #, c-format msgid "parameter \"%s\" requires a temporal value" msgstr "le paramètre « %s » requiert une valeur temporelle" -#: access/transam/xlog.c:5155 catalog/dependency.c:990 catalog/dependency.c:991 catalog/dependency.c:997 catalog/dependency.c:998 catalog/dependency.c:1009 catalog/dependency.c:1010 catalog/objectaddress.c:1100 commands/tablecmds.c:795 commands/tablecmds.c:9484 commands/user.c:1045 commands/view.c:470 libpq/auth.c:307 replication/syncrep.c:919 storage/lmgr/deadlock.c:1139 storage/lmgr/proc.c:1276 utils/adt/acl.c:5281 utils/misc/guc.c:5662 +#: access/transam/xlog.c:5181 catalog/dependency.c:990 catalog/dependency.c:991 catalog/dependency.c:997 catalog/dependency.c:998 catalog/dependency.c:1009 catalog/dependency.c:1010 catalog/objectaddress.c:1100 commands/tablecmds.c:796 commands/tablecmds.c:9542 commands/user.c:1045 commands/view.c:499 libpq/auth.c:307 replication/syncrep.c:919 storage/lmgr/deadlock.c:1139 storage/lmgr/proc.c:1278 utils/adt/acl.c:5281 utils/misc/guc.c:5662 #: utils/misc/guc.c:5755 utils/misc/guc.c:9708 utils/misc/guc.c:9742 utils/misc/guc.c:9776 utils/misc/guc.c:9810 utils/misc/guc.c:9845 #, c-format msgid "%s" msgstr "%s" -#: access/transam/xlog.c:5162 +#: access/transam/xlog.c:5188 #, c-format msgid "unrecognized recovery parameter \"%s\"" msgstr "paramètre de restauration « %s » non reconnu" -#: access/transam/xlog.c:5173 +#: access/transam/xlog.c:5199 #, c-format msgid "recovery command file \"%s\" specified neither primary_conninfo nor restore_command" msgstr "le fichier de restauration « %s » n'a spécifié ni primary_conninfo ni restore_command" -#: access/transam/xlog.c:5175 +#: access/transam/xlog.c:5201 #, c-format msgid "The database server will regularly poll the pg_xlog subdirectory to check for files placed there." msgstr "" "Le serveur de la base de données va régulièrement interroger le sous-répertoire\n" "pg_xlog pour vérifier les fichiers placés ici." -#: access/transam/xlog.c:5182 +#: access/transam/xlog.c:5208 #, c-format msgid "recovery command file \"%s\" must specify restore_command when standby mode is not enabled" msgstr "" "le fichier de restauration « %s » doit spécifier restore_command quand le mode\n" "de restauration n'est pas activé" -#: access/transam/xlog.c:5203 +#: access/transam/xlog.c:5229 #, c-format msgid "standby mode is not supported by single-user servers" msgstr "le mode de restauration n'est pas supporté pour les serveurs mono-utilisateur" -#: access/transam/xlog.c:5222 +#: access/transam/xlog.c:5248 #, c-format msgid "recovery target timeline %u does not exist" msgstr "le timeline cible, %u, de la restauration n'existe pas" -#: access/transam/xlog.c:5343 +#: access/transam/xlog.c:5369 #, c-format msgid "archive recovery complete" msgstr "restauration terminée de l'archive" -#: access/transam/xlog.c:5402 access/transam/xlog.c:5630 +#: access/transam/xlog.c:5428 access/transam/xlog.c:5656 #, c-format msgid "recovery stopping after reaching consistency" msgstr "arrêt de la restauration après avoir atteint le point de cohérence" -#: access/transam/xlog.c:5490 +#: access/transam/xlog.c:5516 #, c-format msgid "recovery stopping before commit of transaction %u, time %s" msgstr "arrêt de la restauration avant validation de la transaction %u, %s" -#: access/transam/xlog.c:5497 +#: access/transam/xlog.c:5523 #, c-format msgid "recovery stopping before abort of transaction %u, time %s" msgstr "arrêt de la restauration avant annulation de la transaction %u, %s" -#: access/transam/xlog.c:5542 +#: access/transam/xlog.c:5568 #, c-format msgid "recovery stopping at restore point \"%s\", time %s" msgstr "restauration en arrêt au point de restauration « %s », heure %s" -#: access/transam/xlog.c:5610 +#: access/transam/xlog.c:5636 #, c-format msgid "recovery stopping after commit of transaction %u, time %s" msgstr "arrêt de la restauration après validation de la transaction %u, %s" -#: access/transam/xlog.c:5618 +#: access/transam/xlog.c:5644 #, c-format msgid "recovery stopping after abort of transaction %u, time %s" msgstr "arrêt de la restauration après annulation de la transaction %u, %s" -#: access/transam/xlog.c:5657 +#: access/transam/xlog.c:5683 #, c-format msgid "recovery has paused" msgstr "restauration en pause" -#: access/transam/xlog.c:5658 +#: access/transam/xlog.c:5684 #, c-format msgid "Execute pg_xlog_replay_resume() to continue." msgstr "Exécuter pg_xlog_replay_resume() pour continuer." -#: access/transam/xlog.c:5865 +#: access/transam/xlog.c:5891 #, c-format msgid "hot standby is not possible because %s = %d is a lower setting than on the master server (its value was %d)" msgstr "" @@ -2130,266 +2130,266 @@ msgstr "" "paramètrage plus bas que celui du serveur maître des journaux de transactions\n" "(la valeur était %d)" -#: access/transam/xlog.c:5891 +#: access/transam/xlog.c:5917 #, c-format msgid "WAL was generated with wal_level=minimal, data may be missing" msgstr "" "le journal de transactions a été généré avec le paramètre wal_level configuré\n" "à « minimal », des données pourraient manquer" -#: access/transam/xlog.c:5892 +#: access/transam/xlog.c:5918 #, c-format msgid "This happens if you temporarily set wal_level=minimal without taking a new base backup." msgstr "" "Ceci peut arriver si vous configurez temporairement wal_level à minimal sans avoir\n" "pris une nouvelle sauvegarde de base." -#: access/transam/xlog.c:5903 +#: access/transam/xlog.c:5929 #, c-format msgid "hot standby is not possible because wal_level was not set to \"replica\" or higher on the master server" msgstr "" "les connexions en lecture seules ne sont pas possibles parce que le paramètre wal_level\n" "n'a pas été positionné à « replica » ou plus sur le serveur maître" -#: access/transam/xlog.c:5904 +#: access/transam/xlog.c:5930 #, c-format msgid "Either set wal_level to \"replica\" on the master, or turn off hot_standby here." msgstr "" "Vous devez soit positionner le paramètre wal_level à « replica » sur le maître,\n" "soit désactiver le hot_standby ici." -#: access/transam/xlog.c:5961 +#: access/transam/xlog.c:5987 #, c-format msgid "control file contains invalid data" msgstr "le fichier de contrôle contient des données invalides" -#: access/transam/xlog.c:5967 +#: access/transam/xlog.c:5993 #, c-format msgid "database system was shut down at %s" msgstr "le système de bases de données a été arrêté à %s" -#: access/transam/xlog.c:5972 +#: access/transam/xlog.c:5998 #, c-format msgid "database system was shut down in recovery at %s" msgstr "le système de bases de données a été arrêté pendant la restauration à %s" -#: access/transam/xlog.c:5976 +#: access/transam/xlog.c:6002 #, c-format msgid "database system shutdown was interrupted; last known up at %s" msgstr "le système de bases de données a été interrompu ; dernier lancement connu à %s" -#: access/transam/xlog.c:5980 +#: access/transam/xlog.c:6006 #, c-format msgid "database system was interrupted while in recovery at %s" msgstr "le système de bases de données a été interrompu lors d'une restauration à %s" -#: access/transam/xlog.c:5982 +#: access/transam/xlog.c:6008 #, c-format msgid "This probably means that some data is corrupted and you will have to use the last backup for recovery." msgstr "" "Ceci signifie probablement que des données ont été corrompues et que vous\n" "devrez utiliser la dernière sauvegarde pour la restauration." -#: access/transam/xlog.c:5986 +#: access/transam/xlog.c:6012 #, c-format msgid "database system was interrupted while in recovery at log time %s" msgstr "" "le système de bases de données a été interrompu lors d'une récupération à %s\n" "(moment de la journalisation)" -#: access/transam/xlog.c:5988 +#: access/transam/xlog.c:6014 #, c-format msgid "If this has occurred more than once some data might be corrupted and you might need to choose an earlier recovery target." msgstr "" "Si c'est arrivé plus d'une fois, des données ont pu être corrompues et vous\n" "pourriez avoir besoin de choisir une cible de récupération antérieure." -#: access/transam/xlog.c:5992 +#: access/transam/xlog.c:6018 #, c-format msgid "database system was interrupted; last known up at %s" msgstr "le système de bases de données a été interrompu ; dernier lancement connu à %s" -#: access/transam/xlog.c:6048 +#: access/transam/xlog.c:6074 #, c-format msgid "entering standby mode" msgstr "entre en mode standby" -#: access/transam/xlog.c:6051 +#: access/transam/xlog.c:6077 #, c-format msgid "starting point-in-time recovery to XID %u" msgstr "début de la restauration de l'archive au XID %u" -#: access/transam/xlog.c:6055 +#: access/transam/xlog.c:6081 #, c-format msgid "starting point-in-time recovery to %s" msgstr "début de la restauration de l'archive à %s" -#: access/transam/xlog.c:6059 +#: access/transam/xlog.c:6085 #, c-format msgid "starting point-in-time recovery to \"%s\"" msgstr "début de la restauration PITR à « %s »" -#: access/transam/xlog.c:6063 +#: access/transam/xlog.c:6089 #, c-format msgid "starting point-in-time recovery to earliest consistent point" msgstr "début de la restauration de l'archive jusqu'au point de cohérence le plus proche" -#: access/transam/xlog.c:6066 +#: access/transam/xlog.c:6092 #, c-format msgid "starting archive recovery" msgstr "début de la restauration de l'archive" -#: access/transam/xlog.c:6110 access/transam/xlog.c:6238 +#: access/transam/xlog.c:6136 access/transam/xlog.c:6264 #, c-format msgid "checkpoint record is at %X/%X" msgstr "l'enregistrement du point de vérification est à %X/%X" -#: access/transam/xlog.c:6124 +#: access/transam/xlog.c:6150 #, c-format msgid "could not find redo location referenced by checkpoint record" msgstr "n'a pas pu localiser l'enregistrement redo référencé par le point de vérification" -#: access/transam/xlog.c:6125 access/transam/xlog.c:6132 +#: access/transam/xlog.c:6151 access/transam/xlog.c:6158 #, c-format msgid "If you are not restoring from a backup, try removing the file \"%s/backup_label\"." msgstr "" "Si vous n'avez pas pu restaurer une sauvegarde, essayez de supprimer le\n" "fichier « %s/backup_label »." -#: access/transam/xlog.c:6131 +#: access/transam/xlog.c:6157 #, c-format msgid "could not locate required checkpoint record" msgstr "n'a pas pu localiser l'enregistrement d'un point de vérification requis" -#: access/transam/xlog.c:6157 commands/tablespace.c:641 +#: access/transam/xlog.c:6183 commands/tablespace.c:641 #, c-format msgid "could not create symbolic link \"%s\": %m" msgstr "n'a pas pu créer le lien symbolique « %s » : %m" -#: access/transam/xlog.c:6189 access/transam/xlog.c:6195 +#: access/transam/xlog.c:6215 access/transam/xlog.c:6221 #, c-format msgid "ignoring file \"%s\" because no file \"%s\" exists" msgstr "ignore le fichier « %s » car le fichier « %s » n'existe pas" -#: access/transam/xlog.c:6191 access/transam/xlog.c:10955 +#: access/transam/xlog.c:6217 access/transam/xlog.c:11032 #, c-format msgid "File \"%s\" was renamed to \"%s\"." msgstr "Le fichier « %s » a été renommé en « %s »." -#: access/transam/xlog.c:6197 +#: access/transam/xlog.c:6223 #, c-format msgid "Could not rename file \"%s\" to \"%s\": %m." msgstr "N'a pas pu renommer le fichier « %s » en « %s » : %m" -#: access/transam/xlog.c:6248 access/transam/xlog.c:6263 +#: access/transam/xlog.c:6274 access/transam/xlog.c:6289 #, c-format msgid "could not locate a valid checkpoint record" msgstr "n'a pas pu localiser un enregistrement d'un point de vérification valide" -#: access/transam/xlog.c:6257 +#: access/transam/xlog.c:6283 #, c-format msgid "using previous checkpoint record at %X/%X" msgstr "utilisation du précédent enregistrement d'un point de vérification à %X/%X" -#: access/transam/xlog.c:6301 +#: access/transam/xlog.c:6327 #, c-format msgid "requested timeline %u is not a child of this server's history" msgstr "la timeline requise %u n'est pas un fils de l'historique de ce serveur" -#: access/transam/xlog.c:6303 +#: access/transam/xlog.c:6329 #, c-format msgid "Latest checkpoint is at %X/%X on timeline %u, but in the history of the requested timeline, the server forked off from that timeline at %X/%X." msgstr "Le dernier checkpoint est à %X/%X sur la timeline %u, mais dans l'historique de la timeline demandée, le serveur est sorti de cette timeline à %X/%X." -#: access/transam/xlog.c:6319 +#: access/transam/xlog.c:6345 #, c-format msgid "requested timeline %u does not contain minimum recovery point %X/%X on timeline %u" msgstr "la timeline requise, %u, ne contient pas le point de restauration minimum (%X/%X) sur la timeline %u" -#: access/transam/xlog.c:6350 +#: access/transam/xlog.c:6376 #, c-format msgid "invalid next transaction ID" msgstr "prochain ID de transaction invalide" -#: access/transam/xlog.c:6433 +#: access/transam/xlog.c:6459 #, c-format msgid "invalid redo in checkpoint record" msgstr "ré-exécution invalide dans l'enregistrement du point de vérification" -#: access/transam/xlog.c:6444 +#: access/transam/xlog.c:6470 #, c-format msgid "invalid redo record in shutdown checkpoint" msgstr "enregistrement de ré-exécution invalide dans le point de vérification d'arrêt" -#: access/transam/xlog.c:6472 +#: access/transam/xlog.c:6498 #, c-format msgid "database system was not properly shut down; automatic recovery in progress" msgstr "" "le système de bases de données n'a pas été arrêté proprement ; restauration\n" "automatique en cours" -#: access/transam/xlog.c:6476 +#: access/transam/xlog.c:6502 #, c-format msgid "crash recovery starts in timeline %u and has target timeline %u" msgstr "la restauration après crash commence avec la timeline %u et a la timeline %u en cible" -#: access/transam/xlog.c:6520 +#: access/transam/xlog.c:6546 #, c-format msgid "backup_label contains data inconsistent with control file" msgstr "backup_label contient des données incohérentes avec le fichier de contrôle" -#: access/transam/xlog.c:6521 +#: access/transam/xlog.c:6547 #, c-format msgid "This means that the backup is corrupted and you will have to use another backup for recovery." msgstr "" "Ceci signifie que la sauvegarde a été corrompue et que vous devrez utiliser\n" "la dernière sauvegarde pour la restauration." -#: access/transam/xlog.c:6595 +#: access/transam/xlog.c:6621 #, c-format msgid "initializing for hot standby" msgstr "initialisation pour « Hot Standby »" -#: access/transam/xlog.c:6727 +#: access/transam/xlog.c:6753 #, c-format msgid "redo starts at %X/%X" msgstr "la ré-exécution commence à %X/%X" -#: access/transam/xlog.c:6952 +#: access/transam/xlog.c:6978 #, c-format msgid "requested recovery stop point is before consistent recovery point" msgstr "" "le point d'arrêt de la restauration demandée se trouve avant le point\n" "cohérent de restauration" -#: access/transam/xlog.c:6990 +#: access/transam/xlog.c:7016 #, c-format msgid "redo done at %X/%X" msgstr "ré-exécution faite à %X/%X" -#: access/transam/xlog.c:6995 access/transam/xlog.c:8943 +#: access/transam/xlog.c:7021 access/transam/xlog.c:8969 #, c-format msgid "last completed transaction was at log time %s" msgstr "la dernière transaction a eu lieu à %s (moment de la journalisation)" -#: access/transam/xlog.c:7004 +#: access/transam/xlog.c:7030 #, c-format msgid "redo is not required" msgstr "la ré-exécution n'est pas nécessaire" -#: access/transam/xlog.c:7079 access/transam/xlog.c:7083 +#: access/transam/xlog.c:7105 access/transam/xlog.c:7109 #, c-format msgid "WAL ends before end of online backup" msgstr "le journal de transactions se termine avant la fin de la sauvegarde de base" -#: access/transam/xlog.c:7080 +#: access/transam/xlog.c:7106 #, c-format msgid "All WAL generated while online backup was taken must be available at recovery." msgstr "" "Tous les journaux de transactions générés pendant la sauvegarde en ligne\n" "doivent être disponibles pour la restauration." -#: access/transam/xlog.c:7084 +#: access/transam/xlog.c:7110 #, c-format msgid "Online backup started with pg_start_backup() must be ended with pg_stop_backup(), and all WAL up to that point must be available at recovery." msgstr "" @@ -2397,219 +2397,219 @@ msgstr "" "pg_stop_backup() et tous les journaux de transactions générés entre les deux\n" "doivent être disponibles pour la restauration." -#: access/transam/xlog.c:7087 +#: access/transam/xlog.c:7113 #, c-format msgid "WAL ends before consistent recovery point" msgstr "Le journal de transaction se termine avant un point de restauration cohérent" -#: access/transam/xlog.c:7114 +#: access/transam/xlog.c:7140 #, c-format msgid "selected new timeline ID: %u" msgstr "identifiant d'un timeline nouvellement sélectionné : %u" -#: access/transam/xlog.c:7525 +#: access/transam/xlog.c:7551 #, c-format msgid "consistent recovery state reached at %X/%X" msgstr "état de restauration cohérent atteint à %X/%X" -#: access/transam/xlog.c:7716 +#: access/transam/xlog.c:7742 #, c-format msgid "invalid primary checkpoint link in control file" msgstr "lien du point de vérification primaire invalide dans le fichier de contrôle" -#: access/transam/xlog.c:7720 +#: access/transam/xlog.c:7746 #, c-format msgid "invalid secondary checkpoint link in control file" msgstr "lien du point de vérification secondaire invalide dans le fichier de contrôle" -#: access/transam/xlog.c:7724 +#: access/transam/xlog.c:7750 #, c-format msgid "invalid checkpoint link in backup_label file" msgstr "lien du point de vérification invalide dans le fichier backup_label" -#: access/transam/xlog.c:7741 +#: access/transam/xlog.c:7767 #, c-format msgid "invalid primary checkpoint record" msgstr "enregistrement du point de vérification primaire invalide" -#: access/transam/xlog.c:7745 +#: access/transam/xlog.c:7771 #, c-format msgid "invalid secondary checkpoint record" msgstr "enregistrement du point de vérification secondaire invalide" -#: access/transam/xlog.c:7749 +#: access/transam/xlog.c:7775 #, c-format msgid "invalid checkpoint record" msgstr "enregistrement du point de vérification invalide" -#: access/transam/xlog.c:7760 +#: access/transam/xlog.c:7786 #, c-format msgid "invalid resource manager ID in primary checkpoint record" msgstr "identifiant du gestionnaire de ressource invalide dans l'enregistrement primaire du point de vérification" -#: access/transam/xlog.c:7764 +#: access/transam/xlog.c:7790 #, c-format msgid "invalid resource manager ID in secondary checkpoint record" msgstr "identifiant du gestionnaire de ressource invalide dans l'enregistrement secondaire du point de vérification" -#: access/transam/xlog.c:7768 +#: access/transam/xlog.c:7794 #, c-format msgid "invalid resource manager ID in checkpoint record" msgstr "identifiant du gestionnaire de ressource invalide dans l'enregistrement du point de vérification" -#: access/transam/xlog.c:7780 +#: access/transam/xlog.c:7806 #, c-format msgid "invalid xl_info in primary checkpoint record" msgstr "xl_info invalide dans l'enregistrement du point de vérification primaire" -#: access/transam/xlog.c:7784 +#: access/transam/xlog.c:7810 #, c-format msgid "invalid xl_info in secondary checkpoint record" msgstr "xl_info invalide dans l'enregistrement du point de vérification secondaire" -#: access/transam/xlog.c:7788 +#: access/transam/xlog.c:7814 #, c-format msgid "invalid xl_info in checkpoint record" msgstr "xl_info invalide dans l'enregistrement du point de vérification" -#: access/transam/xlog.c:7799 +#: access/transam/xlog.c:7825 #, c-format msgid "invalid length of primary checkpoint record" msgstr "longueur invalide de l'enregistrement primaire du point de vérification" -#: access/transam/xlog.c:7803 +#: access/transam/xlog.c:7829 #, c-format msgid "invalid length of secondary checkpoint record" msgstr "longueur invalide de l'enregistrement secondaire du point de vérification" -#: access/transam/xlog.c:7807 +#: access/transam/xlog.c:7833 #, c-format msgid "invalid length of checkpoint record" msgstr "longueur invalide de l'enregistrement du point de vérification" -#: access/transam/xlog.c:7975 +#: access/transam/xlog.c:8001 #, c-format msgid "shutting down" msgstr "arrêt en cours" -#: access/transam/xlog.c:8488 +#: access/transam/xlog.c:8514 #, c-format msgid "concurrent transaction log activity while database system is shutting down" msgstr "" "activité en cours du journal de transactions alors que le système de bases\n" "de données est en cours d'arrêt" -#: access/transam/xlog.c:8742 +#: access/transam/xlog.c:8768 #, c-format msgid "skipping restartpoint, recovery has already ended" msgstr "restartpoint ignoré, la récupération est déjà terminée" -#: access/transam/xlog.c:8765 +#: access/transam/xlog.c:8791 #, c-format msgid "skipping restartpoint, already performed at %X/%X" msgstr "ignore le point de redémarrage, déjà réalisé à %X/%X" -#: access/transam/xlog.c:8941 +#: access/transam/xlog.c:8967 #, c-format msgid "recovery restart point at %X/%X" msgstr "la ré-exécution en restauration commence à %X/%X" -#: access/transam/xlog.c:9074 +#: access/transam/xlog.c:9100 #, c-format msgid "restore point \"%s\" created at %X/%X" msgstr "point de restauration « %s » créé à %X/%X" -#: access/transam/xlog.c:9204 +#: access/transam/xlog.c:9230 #, c-format msgid "unexpected previous timeline ID %u (current timeline ID %u) in checkpoint record" msgstr "identifiant de timeline précédent %u inattendu (identifiant de la timeline courante %u) dans l'enregistrement du point de vérification" -#: access/transam/xlog.c:9213 +#: access/transam/xlog.c:9239 #, c-format msgid "unexpected timeline ID %u (after %u) in checkpoint record" msgstr "" "identifiant timeline %u inattendu (après %u) dans l'enregistrement du point\n" "de vérification" -#: access/transam/xlog.c:9229 +#: access/transam/xlog.c:9255 #, c-format msgid "unexpected timeline ID %u in checkpoint record, before reaching minimum recovery point %X/%X on timeline %u" msgstr "identifiant timeline %u inattendu dans l'enregistrement du checkpoint, avant d'atteindre le point de restauration minimum %X/%X sur la timeline %u" -#: access/transam/xlog.c:9300 +#: access/transam/xlog.c:9326 #, c-format msgid "online backup was canceled, recovery cannot continue" msgstr "la sauvegarde en ligne a été annulée, la restauration ne peut pas continuer" -#: access/transam/xlog.c:9356 access/transam/xlog.c:9403 access/transam/xlog.c:9426 +#: access/transam/xlog.c:9382 access/transam/xlog.c:9429 access/transam/xlog.c:9452 #, c-format msgid "unexpected timeline ID %u (should be %u) in checkpoint record" msgstr "" "identifiant timeline %u inattendu (devrait être %u) dans l'enregistrement du\n" "point de vérification" -#: access/transam/xlog.c:9701 +#: access/transam/xlog.c:9727 #, c-format msgid "could not fsync log segment %s: %m" msgstr "n'a pas pu synchroniser sur disque (fsync) le segment du journal des transactions %s : %m" -#: access/transam/xlog.c:9725 +#: access/transam/xlog.c:9751 #, c-format msgid "could not fsync log file %s: %m" msgstr "n'a pas pu synchroniser sur disque (fsync) le fichier de transactions « %s » : %m" -#: access/transam/xlog.c:9733 +#: access/transam/xlog.c:9759 #, c-format msgid "could not fsync write-through log file %s: %m" msgstr "n'a pas pu synchroniser sur disque (fsync) le journal des transactions %s : %m" -#: access/transam/xlog.c:9742 +#: access/transam/xlog.c:9768 #, c-format msgid "could not fdatasync log file %s: %m" msgstr "n'a pas pu synchroniser sur disque (fdatasync) le journal de transactions %s : %m" -#: access/transam/xlog.c:9833 access/transam/xlog.c:10304 access/transam/xlogfuncs.c:294 access/transam/xlogfuncs.c:321 access/transam/xlogfuncs.c:360 access/transam/xlogfuncs.c:381 access/transam/xlogfuncs.c:402 +#: access/transam/xlog.c:9859 access/transam/xlog.c:10363 access/transam/xlogfuncs.c:294 access/transam/xlogfuncs.c:321 access/transam/xlogfuncs.c:360 access/transam/xlogfuncs.c:381 access/transam/xlogfuncs.c:402 #, c-format msgid "WAL control functions cannot be executed during recovery." msgstr "" "les fonctions de contrôle des journaux de transactions ne peuvent pas\n" "être exécutées lors de la restauration." -#: access/transam/xlog.c:9842 access/transam/xlog.c:10313 +#: access/transam/xlog.c:9868 access/transam/xlog.c:10372 #, c-format msgid "WAL level not sufficient for making an online backup" msgstr "" "Le niveau de journalisation (configuré par wal_level) n'est pas suffisant pour\n" "faire une sauvegarde en ligne." -#: access/transam/xlog.c:9843 access/transam/xlog.c:10314 access/transam/xlogfuncs.c:327 +#: access/transam/xlog.c:9869 access/transam/xlog.c:10373 access/transam/xlogfuncs.c:327 #, c-format msgid "wal_level must be set to \"replica\" or \"logical\" at server start." msgstr "" "wal_level doit être configuré à « replica » ou « logical »\n" "au démarrage du serveur." -#: access/transam/xlog.c:9848 +#: access/transam/xlog.c:9874 #, c-format msgid "backup label too long (max %d bytes)" msgstr "label de sauvegarde trop long (%d octets maximum)" -#: access/transam/xlog.c:9880 access/transam/xlog.c:10152 access/transam/xlog.c:10190 +#: access/transam/xlog.c:9911 access/transam/xlog.c:10183 access/transam/xlog.c:10221 #, c-format msgid "a backup is already in progress" msgstr "une sauvegarde est déjà en cours" -#: access/transam/xlog.c:9881 +#: access/transam/xlog.c:9912 #, c-format msgid "Run pg_stop_backup() and try again." msgstr "Exécutez pg_stop_backup() et tentez de nouveau." -#: access/transam/xlog.c:9976 +#: access/transam/xlog.c:10007 #, c-format msgid "WAL generated with full_page_writes=off was replayed since last restartpoint" msgstr "Les journaux générés avec full_page_writes=off ont été rejoués depuis le dernier restartpoint." -#: access/transam/xlog.c:9978 access/transam/xlog.c:10477 +#: access/transam/xlog.c:10009 access/transam/xlog.c:10554 #, c-format msgid "This means that the backup being taken on the standby is corrupt and should not be used. Enable full_page_writes and run CHECKPOINT on the master, and then try an online backup again." msgstr "" @@ -2617,86 +2617,86 @@ msgstr "" "corrompue et ne doit pas être utilisée. Activez full_page_writes et lancez\n" "CHECKPOINT sur le maître, puis recommencez la sauvegarde." -#: access/transam/xlog.c:10045 replication/basebackup.c:1026 utils/adt/misc.c:498 +#: access/transam/xlog.c:10076 replication/basebackup.c:1026 utils/adt/misc.c:498 #, c-format msgid "could not read symbolic link \"%s\": %m" msgstr "n'a pas pu lire le lien symbolique « %s » : %m" -#: access/transam/xlog.c:10052 replication/basebackup.c:1031 utils/adt/misc.c:503 +#: access/transam/xlog.c:10083 replication/basebackup.c:1031 utils/adt/misc.c:503 #, c-format msgid "symbolic link \"%s\" target is too long" msgstr "la cible du lien symbolique « %s » est trop long" -#: access/transam/xlog.c:10105 commands/tablespace.c:391 commands/tablespace.c:553 replication/basebackup.c:1047 utils/adt/misc.c:511 +#: access/transam/xlog.c:10136 commands/tablespace.c:391 commands/tablespace.c:553 replication/basebackup.c:1047 utils/adt/misc.c:511 #, c-format msgid "tablespaces are not supported on this platform" msgstr "les tablespaces ne sont pas supportés sur cette plateforme" -#: access/transam/xlog.c:10146 access/transam/xlog.c:10184 access/transam/xlog.c:10363 access/transam/xlogarchive.c:106 access/transam/xlogarchive.c:265 commands/copy.c:1815 commands/copy.c:2839 commands/extension.c:3109 commands/tablespace.c:782 commands/tablespace.c:873 guc-file.l:1001 replication/basebackup.c:409 replication/basebackup.c:477 replication/logical/snapbuild.c:1491 storage/file/copydir.c:72 storage/file/copydir.c:115 +#: access/transam/xlog.c:10177 access/transam/xlog.c:10215 access/transam/xlog.c:10411 access/transam/xlogarchive.c:106 access/transam/xlogarchive.c:265 commands/copy.c:1815 commands/copy.c:2839 commands/extension.c:3130 commands/tablespace.c:782 commands/tablespace.c:873 guc-file.l:1001 replication/basebackup.c:409 replication/basebackup.c:477 replication/logical/snapbuild.c:1491 storage/file/copydir.c:72 storage/file/copydir.c:115 #: storage/file/fd.c:2826 storage/file/fd.c:2918 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 utils/adt/dbsize.c:300 utils/adt/genfile.c:114 utils/adt/genfile.c:333 #, c-format msgid "could not stat file \"%s\": %m" msgstr "n'a pas pu tester le fichier « %s » : %m" -#: access/transam/xlog.c:10153 access/transam/xlog.c:10191 +#: access/transam/xlog.c:10184 access/transam/xlog.c:10222 #, c-format msgid "If you're sure there is no backup in progress, remove file \"%s\" and try again." msgstr "" "Si vous êtes certain qu'aucune sauvegarde n'est en cours, supprimez le\n" "fichier « %s » et recommencez de nouveau." -#: access/transam/xlog.c:10170 access/transam/xlog.c:10208 access/transam/xlog.c:10538 +#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 access/transam/xlog.c:10615 #, c-format msgid "could not write file \"%s\": %m" msgstr "impossible d'écrire le fichier « %s » : %m" -#: access/transam/xlog.c:10327 +#: access/transam/xlog.c:10388 #, c-format msgid "exclusive backup not in progress" msgstr "une sauvegarde exclusive n'est pas en cours" -#: access/transam/xlog.c:10367 +#: access/transam/xlog.c:10415 #, c-format msgid "a backup is not in progress" msgstr "une sauvegarde n'est pas en cours" -#: access/transam/xlog.c:10412 access/transam/xlog.c:10425 access/transam/xlog.c:10765 access/transam/xlog.c:10771 access/transam/xlog.c:10855 access/transam/xlogfuncs.c:695 +#: access/transam/xlog.c:10489 access/transam/xlog.c:10502 access/transam/xlog.c:10842 access/transam/xlog.c:10848 access/transam/xlog.c:10932 access/transam/xlogfuncs.c:695 #, c-format msgid "invalid data in file \"%s\"" msgstr "données invalides dans le fichier « %s »" -#: access/transam/xlog.c:10429 replication/basebackup.c:938 +#: access/transam/xlog.c:10506 replication/basebackup.c:938 #, c-format msgid "the standby was promoted during online backup" msgstr "le standby a été promu lors de la sauvegarde en ligne" -#: access/transam/xlog.c:10430 replication/basebackup.c:939 +#: access/transam/xlog.c:10507 replication/basebackup.c:939 #, c-format msgid "This means that the backup being taken is corrupt and should not be used. Try taking another online backup." msgstr "" "Cela signifie que la sauvegarde en cours de réalisation est corrompue et ne\n" "doit pas être utilisée. Recommencez la sauvegarde." -#: access/transam/xlog.c:10475 +#: access/transam/xlog.c:10552 #, c-format msgid "WAL generated with full_page_writes=off was replayed during online backup" msgstr "" "le journal de transactions généré avec full_page_writes=off a été rejoué lors\n" "de la sauvegarde en ligne" -#: access/transam/xlog.c:10587 +#: access/transam/xlog.c:10664 #, c-format msgid "pg_stop_backup cleanup done, waiting for required WAL segments to be archived" msgstr "nettoyage de pg_stop_backup terminé, en attente des journaux de transactions requis à archiver" -#: access/transam/xlog.c:10597 +#: access/transam/xlog.c:10674 #, c-format msgid "pg_stop_backup still waiting for all required WAL segments to be archived (%d seconds elapsed)" msgstr "" "pg_stop_backup toujours en attente de la fin de l'archivage des segments de\n" "journaux de transactions requis (%d secondes passées)" -#: access/transam/xlog.c:10599 +#: access/transam/xlog.c:10676 #, c-format msgid "Check that your archive_command is executing properly. pg_stop_backup can be canceled safely, but the database backup will not be usable without all the WAL segments." msgstr "" @@ -2704,12 +2704,12 @@ msgstr "" "peut être annulé avec sûreté mais la sauvegarde de la base ne sera pas\n" "utilisable sans tous les segments WAL." -#: access/transam/xlog.c:10606 +#: access/transam/xlog.c:10683 #, c-format msgid "pg_stop_backup complete, all required WAL segments have been archived" msgstr "pg_stop_backup terminé, tous les journaux de transactions requis ont été archivés" -#: access/transam/xlog.c:10610 +#: access/transam/xlog.c:10687 #, c-format msgid "WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup" msgstr "" @@ -2718,57 +2718,57 @@ msgstr "" "transactions sont copiés par d'autre moyens pour terminer la sauvegarde." #. translator: %s is an XLog record description -#: access/transam/xlog.c:10895 +#: access/transam/xlog.c:10972 #, c-format msgid "xlog redo at %X/%X for %s" msgstr "xlog redo à %X/%X pour %s" -#: access/transam/xlog.c:10944 +#: access/transam/xlog.c:11021 #, c-format msgid "online backup mode was not canceled" msgstr "le mode de sauvegarde en ligne n'a pas été annulé" -#: access/transam/xlog.c:10945 +#: access/transam/xlog.c:11022 #, c-format msgid "File \"%s\" could not be renamed to \"%s\": %m." msgstr "Le fichier « %s » n'a pas pu être renommé en « %s » : %m" -#: access/transam/xlog.c:10954 access/transam/xlog.c:10966 access/transam/xlog.c:10976 +#: access/transam/xlog.c:11031 access/transam/xlog.c:11043 access/transam/xlog.c:11053 #, c-format msgid "online backup mode canceled" msgstr "mode de sauvegarde en ligne annulé" -#: access/transam/xlog.c:10967 +#: access/transam/xlog.c:11044 #, c-format msgid "Files \"%s\" and \"%s\" were renamed to \"%s\" and \"%s\", respectively." msgstr "Les fichiers « %s » et « %s » sont renommés respectivement « %s » et « %s »." -#: access/transam/xlog.c:10977 +#: access/transam/xlog.c:11054 #, c-format msgid "File \"%s\" was renamed to \"%s\", but file \"%s\" could not be renamed to \"%s\": %m." msgstr "Le fichier « %s » a été renommé en « %s », mais le fichier « %s » n'a pas pu être renommé en « %s » : %m" -#: access/transam/xlog.c:11099 access/transam/xlogutils.c:718 replication/walreceiver.c:994 replication/walsender.c:2114 +#: access/transam/xlog.c:11176 access/transam/xlogutils.c:718 replication/walreceiver.c:994 replication/walsender.c:2114 #, c-format msgid "could not seek in log segment %s to offset %u: %m" msgstr "n'a pas pu se déplacer dans le journal de transactions %s au décalage %u : %m" -#: access/transam/xlog.c:11111 +#: access/transam/xlog.c:11188 #, c-format msgid "could not read from log segment %s, offset %u: %m" msgstr "n'a pas pu lire le journal de transactions %s, décalage %u : %m" -#: access/transam/xlog.c:11585 +#: access/transam/xlog.c:11662 #, c-format msgid "received promote request" msgstr "a reçu une demande de promotion" -#: access/transam/xlog.c:11598 +#: access/transam/xlog.c:11675 #, c-format msgid "trigger file found: %s" msgstr "fichier trigger trouvé : %s" -#: access/transam/xlog.c:11607 +#: access/transam/xlog.c:11684 #, c-format msgid "could not stat trigger file \"%s\": %m" msgstr "n'a pas pu tester le fichier trigger « %s » : %m" @@ -2836,7 +2836,7 @@ msgstr "une sauvegarde non exclusive est en cours" msgid "Did you mean to use pg_stop_backup('f')?" msgstr "Souhaitiez-vous utiliser pg_stop_backup('f') ?" -#: access/transam/xlogfuncs.c:200 commands/event_trigger.c:1445 commands/event_trigger.c:1996 commands/extension.c:1728 commands/extension.c:1837 commands/extension.c:2030 commands/prepare.c:702 executor/execQual.c:1757 executor/execQual.c:1782 executor/execQual.c:2157 executor/execQual.c:5423 executor/functions.c:1022 foreign/foreign.c:492 replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1391 replication/slotfuncs.c:189 +#: access/transam/xlogfuncs.c:200 commands/event_trigger.c:1445 commands/event_trigger.c:1996 commands/extension.c:1729 commands/extension.c:1838 commands/extension.c:2031 commands/prepare.c:702 executor/execQual.c:1757 executor/execQual.c:1782 executor/execQual.c:2157 executor/execQual.c:5438 executor/functions.c:1031 foreign/foreign.c:492 replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1391 replication/slotfuncs.c:189 #: replication/walsender.c:2763 utils/adt/jsonfuncs.c:1483 utils/adt/jsonfuncs.c:1613 utils/adt/jsonfuncs.c:1801 utils/adt/jsonfuncs.c:1928 utils/adt/jsonfuncs.c:2694 utils/adt/pgstatfuncs.c:554 utils/adt/pgstatfuncs.c:655 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8436 utils/mmgr/portalmem.c:1074 #, c-format msgid "set-valued function called in context that cannot accept a set" @@ -2844,7 +2844,7 @@ msgstr "" "la fonction avec set-value a été appelé dans un contexte qui n'accepte pas\n" "un ensemble" -#: access/transam/xlogfuncs.c:204 commands/event_trigger.c:1449 commands/event_trigger.c:2000 commands/extension.c:1732 commands/extension.c:1841 commands/extension.c:2034 commands/prepare.c:706 foreign/foreign.c:497 replication/logical/logicalfuncs.c:179 replication/logical/origin.c:1395 replication/slotfuncs.c:193 replication/walsender.c:2767 utils/adt/pgstatfuncs.c:558 utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8440 +#: access/transam/xlogfuncs.c:204 commands/event_trigger.c:1449 commands/event_trigger.c:2000 commands/extension.c:1733 commands/extension.c:1842 commands/extension.c:2035 commands/prepare.c:706 foreign/foreign.c:497 replication/logical/logicalfuncs.c:179 replication/logical/origin.c:1395 replication/slotfuncs.c:193 replication/walsender.c:2767 utils/adt/pgstatfuncs.c:558 utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8440 #: utils/misc/pg_config.c:44 utils/mmgr/portalmem.c:1078 #, c-format msgid "materialize mode required, but it is not allowed in this context" @@ -3056,123 +3056,123 @@ msgstr "Essayez « %s --help » pour plus d'informations.\n" msgid "%s: invalid command-line arguments\n" msgstr "%s : arguments invalides en ligne de commande\n" -#: catalog/aclchk.c:193 +#: catalog/aclchk.c:201 #, c-format msgid "grant options can only be granted to roles" msgstr "les options grant peuvent seulement être données aux rôles" -#: catalog/aclchk.c:316 +#: catalog/aclchk.c:324 #, c-format msgid "no privileges were granted for column \"%s\" of relation \"%s\"" msgstr "aucun droit n'a pu être accordé pour la colonne « %s » de la relation « %s »" -#: catalog/aclchk.c:321 +#: catalog/aclchk.c:329 #, c-format msgid "no privileges were granted for \"%s\"" msgstr "aucun droit n'a été accordé pour « %s »" -#: catalog/aclchk.c:329 +#: catalog/aclchk.c:337 #, c-format msgid "not all privileges were granted for column \"%s\" of relation \"%s\"" msgstr "certains droits n'ont pu être accordé pour la colonne « %s » de la relation « %s »" -#: catalog/aclchk.c:334 +#: catalog/aclchk.c:342 #, c-format msgid "not all privileges were granted for \"%s\"" msgstr "tous les droits n'ont pas été accordés pour « %s »" -#: catalog/aclchk.c:345 +#: catalog/aclchk.c:353 #, c-format msgid "no privileges could be revoked for column \"%s\" of relation \"%s\"" msgstr "aucun droit n'a pu être révoqué pour la colonne « %s » de la relation « %s »" -#: catalog/aclchk.c:350 +#: catalog/aclchk.c:358 #, c-format msgid "no privileges could be revoked for \"%s\"" msgstr "aucun droit n'a pu être révoqué pour « %s »" -#: catalog/aclchk.c:358 +#: catalog/aclchk.c:366 #, c-format msgid "not all privileges could be revoked for column \"%s\" of relation \"%s\"" msgstr "certains droits n'ont pu être révoqué pour la colonne « %s » de la relation « %s »" -#: catalog/aclchk.c:363 +#: catalog/aclchk.c:371 #, c-format msgid "not all privileges could be revoked for \"%s\"" msgstr "certains droits n'ont pu être révoqué pour « %s »" -#: catalog/aclchk.c:445 catalog/aclchk.c:935 +#: catalog/aclchk.c:453 catalog/aclchk.c:943 #, c-format msgid "invalid privilege type %s for relation" msgstr "droit %s invalide pour la relation" -#: catalog/aclchk.c:449 catalog/aclchk.c:939 +#: catalog/aclchk.c:457 catalog/aclchk.c:947 #, c-format msgid "invalid privilege type %s for sequence" msgstr "droit %s invalide pour la séquence" -#: catalog/aclchk.c:453 +#: catalog/aclchk.c:461 #, c-format msgid "invalid privilege type %s for database" msgstr "droit %s invalide pour la base de données" -#: catalog/aclchk.c:457 +#: catalog/aclchk.c:465 #, c-format msgid "invalid privilege type %s for domain" msgstr "type de droit %s invalide pour le domaine" -#: catalog/aclchk.c:461 catalog/aclchk.c:943 +#: catalog/aclchk.c:469 catalog/aclchk.c:951 #, c-format msgid "invalid privilege type %s for function" msgstr "droit %s invalide pour la fonction" -#: catalog/aclchk.c:465 +#: catalog/aclchk.c:473 #, c-format msgid "invalid privilege type %s for language" msgstr "droit %s invalide pour le langage" -#: catalog/aclchk.c:469 +#: catalog/aclchk.c:477 #, c-format msgid "invalid privilege type %s for large object" msgstr "type de droit invalide, %s, pour le Large Object" -#: catalog/aclchk.c:473 +#: catalog/aclchk.c:481 #, c-format msgid "invalid privilege type %s for schema" msgstr "droit %s invalide pour le schéma" -#: catalog/aclchk.c:477 +#: catalog/aclchk.c:485 #, c-format msgid "invalid privilege type %s for tablespace" msgstr "droit %s invalide pour le tablespace" -#: catalog/aclchk.c:481 catalog/aclchk.c:947 +#: catalog/aclchk.c:489 catalog/aclchk.c:955 #, c-format msgid "invalid privilege type %s for type" msgstr "type de droit %s invalide pour le type" -#: catalog/aclchk.c:485 +#: catalog/aclchk.c:493 #, c-format msgid "invalid privilege type %s for foreign-data wrapper" msgstr "type de droit %s invalide pour le wrapper de données distantes" -#: catalog/aclchk.c:489 +#: catalog/aclchk.c:497 #, c-format msgid "invalid privilege type %s for foreign server" msgstr "type de droit %s invalide pour le serveur distant" -#: catalog/aclchk.c:528 +#: catalog/aclchk.c:536 #, c-format msgid "column privileges are only valid for relations" msgstr "les droits sur la colonne sont seulement valides pour les relations" -#: catalog/aclchk.c:687 catalog/aclchk.c:3915 catalog/aclchk.c:4697 catalog/objectaddress.c:873 catalog/pg_largeobject.c:113 storage/large_object/inv_api.c:291 +#: catalog/aclchk.c:695 catalog/aclchk.c:3923 catalog/aclchk.c:4705 catalog/objectaddress.c:873 catalog/pg_largeobject.c:113 storage/large_object/inv_api.c:291 #, c-format msgid "large object %u does not exist" msgstr "le « Large Object » %u n'existe pas" -#: catalog/aclchk.c:874 catalog/aclchk.c:882 commands/collationcmds.c:92 commands/copy.c:1047 commands/copy.c:1065 commands/copy.c:1073 commands/copy.c:1081 commands/copy.c:1089 commands/copy.c:1097 commands/copy.c:1105 commands/copy.c:1113 commands/copy.c:1121 commands/copy.c:1137 commands/copy.c:1151 commands/copy.c:1170 commands/copy.c:1185 commands/dbcommands.c:155 commands/dbcommands.c:163 commands/dbcommands.c:171 -#: commands/dbcommands.c:179 commands/dbcommands.c:187 commands/dbcommands.c:195 commands/dbcommands.c:203 commands/dbcommands.c:211 commands/dbcommands.c:219 commands/dbcommands.c:1397 commands/dbcommands.c:1405 commands/dbcommands.c:1413 commands/dbcommands.c:1421 commands/extension.c:1218 commands/extension.c:1226 commands/extension.c:1234 commands/extension.c:1242 commands/extension.c:2760 commands/foreigncmds.c:539 +#: catalog/aclchk.c:882 catalog/aclchk.c:890 commands/collationcmds.c:92 commands/copy.c:1047 commands/copy.c:1065 commands/copy.c:1073 commands/copy.c:1081 commands/copy.c:1089 commands/copy.c:1097 commands/copy.c:1105 commands/copy.c:1113 commands/copy.c:1121 commands/copy.c:1137 commands/copy.c:1151 commands/copy.c:1170 commands/copy.c:1185 commands/dbcommands.c:155 commands/dbcommands.c:163 commands/dbcommands.c:171 +#: commands/dbcommands.c:179 commands/dbcommands.c:187 commands/dbcommands.c:195 commands/dbcommands.c:203 commands/dbcommands.c:211 commands/dbcommands.c:219 commands/dbcommands.c:1397 commands/dbcommands.c:1405 commands/dbcommands.c:1413 commands/dbcommands.c:1421 commands/extension.c:1219 commands/extension.c:1227 commands/extension.c:1235 commands/extension.c:1243 commands/extension.c:2761 commands/foreigncmds.c:539 #: commands/foreigncmds.c:548 commands/functioncmds.c:533 commands/functioncmds.c:649 commands/functioncmds.c:657 commands/functioncmds.c:665 commands/functioncmds.c:673 commands/functioncmds.c:2085 commands/functioncmds.c:2093 commands/sequence.c:1189 commands/sequence.c:1197 commands/sequence.c:1205 commands/sequence.c:1213 commands/sequence.c:1221 commands/sequence.c:1229 commands/sequence.c:1237 commands/sequence.c:1245 #: commands/typecmds.c:295 commands/typecmds.c:1382 commands/typecmds.c:1391 commands/typecmds.c:1399 commands/typecmds.c:1407 commands/typecmds.c:1415 commands/user.c:139 commands/user.c:156 commands/user.c:164 commands/user.c:172 commands/user.c:180 commands/user.c:188 commands/user.c:196 commands/user.c:204 commands/user.c:212 commands/user.c:220 commands/user.c:228 commands/user.c:236 commands/user.c:244 commands/user.c:537 #: commands/user.c:549 commands/user.c:557 commands/user.c:565 commands/user.c:573 commands/user.c:581 commands/user.c:589 commands/user.c:597 commands/user.c:606 commands/user.c:614 commands/user.c:622 @@ -3180,373 +3180,373 @@ msgstr "le « Large Object » %u n'existe pas" msgid "conflicting or redundant options" msgstr "options en conflit ou redondantes" -#: catalog/aclchk.c:980 +#: catalog/aclchk.c:988 #, c-format msgid "default privileges cannot be set for columns" msgstr "les droits par défaut ne peuvent pas être configurés pour les colonnes" -#: catalog/aclchk.c:1494 catalog/objectaddress.c:1390 commands/analyze.c:376 commands/copy.c:4458 commands/sequence.c:1491 commands/tablecmds.c:5197 commands/tablecmds.c:5303 commands/tablecmds.c:5363 commands/tablecmds.c:5476 commands/tablecmds.c:5533 commands/tablecmds.c:5627 commands/tablecmds.c:5723 commands/tablecmds.c:7914 commands/tablecmds.c:8119 commands/tablecmds.c:8539 commands/trigger.c:642 parser/analyze.c:2231 -#: parser/parse_relation.c:2542 parser/parse_relation.c:2604 parser/parse_target.c:951 parser/parse_type.c:127 utils/adt/acl.c:2840 utils/adt/ruleutils.c:1984 +#: catalog/aclchk.c:1502 catalog/objectaddress.c:1390 commands/analyze.c:376 commands/copy.c:4458 commands/sequence.c:1491 commands/tablecmds.c:5198 commands/tablecmds.c:5304 commands/tablecmds.c:5364 commands/tablecmds.c:5477 commands/tablecmds.c:5534 commands/tablecmds.c:5628 commands/tablecmds.c:5724 commands/tablecmds.c:7915 commands/tablecmds.c:8177 commands/tablecmds.c:8597 commands/trigger.c:642 parser/analyze.c:2228 +#: parser/parse_relation.c:2628 parser/parse_relation.c:2690 parser/parse_target.c:951 parser/parse_type.c:127 utils/adt/acl.c:2840 utils/adt/ruleutils.c:1984 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist" msgstr "la colonne « %s » de la relation « %s » n'existe pas" -#: catalog/aclchk.c:1763 catalog/objectaddress.c:1203 commands/sequence.c:1078 commands/tablecmds.c:223 commands/tablecmds.c:12057 utils/adt/acl.c:2076 utils/adt/acl.c:2106 utils/adt/acl.c:2138 utils/adt/acl.c:2170 utils/adt/acl.c:2198 utils/adt/acl.c:2228 +#: catalog/aclchk.c:1771 catalog/objectaddress.c:1203 commands/sequence.c:1078 commands/tablecmds.c:224 commands/tablecmds.c:12154 utils/adt/acl.c:2076 utils/adt/acl.c:2106 utils/adt/acl.c:2138 utils/adt/acl.c:2170 utils/adt/acl.c:2198 utils/adt/acl.c:2228 #, c-format msgid "\"%s\" is not a sequence" msgstr "« %s » n'est pas une séquence" -#: catalog/aclchk.c:1801 +#: catalog/aclchk.c:1809 #, c-format msgid "sequence \"%s\" only supports USAGE, SELECT, and UPDATE privileges" msgstr "la séquence « %s » accepte seulement les droits USAGE, SELECT et UPDATE" -#: catalog/aclchk.c:1818 +#: catalog/aclchk.c:1826 #, c-format msgid "invalid privilege type USAGE for table" msgstr "droit USAGE invalide pour la table" -#: catalog/aclchk.c:1986 +#: catalog/aclchk.c:1994 #, c-format msgid "invalid privilege type %s for column" msgstr "type de droit %s invalide pour la colonne" -#: catalog/aclchk.c:1999 +#: catalog/aclchk.c:2007 #, c-format msgid "sequence \"%s\" only supports SELECT column privileges" msgstr "la séquence « %s » accepte seulement le droit SELECT pour les colonnes" -#: catalog/aclchk.c:2593 +#: catalog/aclchk.c:2601 #, c-format msgid "language \"%s\" is not trusted" msgstr "le langage « %s » n'est pas de confiance" -#: catalog/aclchk.c:2595 +#: catalog/aclchk.c:2603 #, c-format msgid "GRANT and REVOKE are not allowed on untrusted languages, because only superusers can use untrusted languages." msgstr "GRANT et REVOKE ne sont pas autorisés sur des langages qui ne sont pas de confiance car seuls les super-utilisateurs peuvent utiliser ces langages" -#: catalog/aclchk.c:3121 +#: catalog/aclchk.c:3129 #, c-format msgid "cannot set privileges of array types" msgstr "ne peut pas configurer les droits des types tableau" -#: catalog/aclchk.c:3122 +#: catalog/aclchk.c:3130 #, c-format msgid "Set the privileges of the element type instead." msgstr "Configurez les droits du type élément à la place." -#: catalog/aclchk.c:3129 catalog/objectaddress.c:1523 commands/typecmds.c:3146 +#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3146 #, c-format msgid "\"%s\" is not a domain" msgstr "« %s » n'est pas un domaine" -#: catalog/aclchk.c:3252 +#: catalog/aclchk.c:3260 #, c-format msgid "unrecognized privilege type \"%s\"" msgstr "droit « %s » non reconnu" -#: catalog/aclchk.c:3301 +#: catalog/aclchk.c:3309 #, c-format msgid "permission denied for column %s" msgstr "droit refusé pour la colonne %s" -#: catalog/aclchk.c:3303 +#: catalog/aclchk.c:3311 #, c-format msgid "permission denied for relation %s" msgstr "droit refusé pour la relation %s" -#: catalog/aclchk.c:3305 commands/sequence.c:561 commands/sequence.c:786 commands/sequence.c:828 commands/sequence.c:865 commands/sequence.c:1543 +#: catalog/aclchk.c:3313 commands/sequence.c:561 commands/sequence.c:786 commands/sequence.c:828 commands/sequence.c:865 commands/sequence.c:1543 #, c-format msgid "permission denied for sequence %s" msgstr "droit refusé pour la séquence %s" -#: catalog/aclchk.c:3307 +#: catalog/aclchk.c:3315 #, c-format msgid "permission denied for database %s" msgstr "droit refusé pour la base de données %s" -#: catalog/aclchk.c:3309 +#: catalog/aclchk.c:3317 #, c-format msgid "permission denied for function %s" msgstr "droit refusé pour la fonction %s" -#: catalog/aclchk.c:3311 +#: catalog/aclchk.c:3319 #, c-format msgid "permission denied for operator %s" msgstr "droit refusé pour l'opérateur %s" -#: catalog/aclchk.c:3313 +#: catalog/aclchk.c:3321 #, c-format msgid "permission denied for type %s" msgstr "droit refusé pour le type %s" -#: catalog/aclchk.c:3315 +#: catalog/aclchk.c:3323 #, c-format msgid "permission denied for language %s" msgstr "droit refusé pour le langage %s" -#: catalog/aclchk.c:3317 +#: catalog/aclchk.c:3325 #, c-format msgid "permission denied for large object %s" msgstr "droit refusé pour le Large Object %s" -#: catalog/aclchk.c:3319 +#: catalog/aclchk.c:3327 #, c-format msgid "permission denied for schema %s" msgstr "droit refusé pour le schéma %s" -#: catalog/aclchk.c:3321 +#: catalog/aclchk.c:3329 #, c-format msgid "permission denied for operator class %s" msgstr "droit refusé pour la classe d'opérateur %s" -#: catalog/aclchk.c:3323 +#: catalog/aclchk.c:3331 #, c-format msgid "permission denied for operator family %s" msgstr "droit refusé pour la famille d'opérateur %s" -#: catalog/aclchk.c:3325 +#: catalog/aclchk.c:3333 #, c-format msgid "permission denied for collation %s" msgstr "droit refusé pour le collationnement %s" -#: catalog/aclchk.c:3327 +#: catalog/aclchk.c:3335 #, c-format msgid "permission denied for conversion %s" msgstr "droit refusé pour la conversion %s" -#: catalog/aclchk.c:3329 +#: catalog/aclchk.c:3337 #, c-format msgid "permission denied for tablespace %s" msgstr "droit refusé pour le tablespace %s" -#: catalog/aclchk.c:3331 +#: catalog/aclchk.c:3339 #, c-format msgid "permission denied for text search dictionary %s" msgstr "droit refusé pour le dictionnaire de recherche plein texte %s" -#: catalog/aclchk.c:3333 +#: catalog/aclchk.c:3341 #, c-format msgid "permission denied for text search configuration %s" msgstr "droit refusé pour la configuration de recherche plein texte %s" -#: catalog/aclchk.c:3335 +#: catalog/aclchk.c:3343 #, c-format msgid "permission denied for foreign-data wrapper %s" msgstr "droit refusé pour le wrapper de données distantes %s" -#: catalog/aclchk.c:3337 +#: catalog/aclchk.c:3345 #, c-format msgid "permission denied for foreign server %s" msgstr "droit refusé pour le serveur distant %s" -#: catalog/aclchk.c:3339 +#: catalog/aclchk.c:3347 #, c-format msgid "permission denied for event trigger %s" msgstr "droit refusé pour le trigger sur événement %s" -#: catalog/aclchk.c:3341 +#: catalog/aclchk.c:3349 #, c-format msgid "permission denied for extension %s" msgstr "droit refusé pour l'extension %s" -#: catalog/aclchk.c:3347 catalog/aclchk.c:3349 +#: catalog/aclchk.c:3355 catalog/aclchk.c:3357 #, c-format msgid "must be owner of relation %s" msgstr "doit être le propriétaire de la relation %s" -#: catalog/aclchk.c:3351 +#: catalog/aclchk.c:3359 #, c-format msgid "must be owner of sequence %s" msgstr "doit être le propriétaire de la séquence %s" -#: catalog/aclchk.c:3353 +#: catalog/aclchk.c:3361 #, c-format msgid "must be owner of database %s" msgstr "doit être le propriétaire de la base de données %s" -#: catalog/aclchk.c:3355 +#: catalog/aclchk.c:3363 #, c-format msgid "must be owner of function %s" msgstr "doit être le propriétaire de la fonction %s" -#: catalog/aclchk.c:3357 +#: catalog/aclchk.c:3365 #, c-format msgid "must be owner of operator %s" msgstr "doit être le prorpriétaire de l'opérateur %s" -#: catalog/aclchk.c:3359 +#: catalog/aclchk.c:3367 #, c-format msgid "must be owner of type %s" msgstr "doit être le propriétaire du type %s" -#: catalog/aclchk.c:3361 +#: catalog/aclchk.c:3369 #, c-format msgid "must be owner of language %s" msgstr "doit être le propriétaire du langage %s" -#: catalog/aclchk.c:3363 +#: catalog/aclchk.c:3371 #, c-format msgid "must be owner of large object %s" msgstr "doit être le propriétaire du Large Object %s" -#: catalog/aclchk.c:3365 +#: catalog/aclchk.c:3373 #, c-format msgid "must be owner of schema %s" msgstr "doit être le propriétaire du schéma %s" -#: catalog/aclchk.c:3367 +#: catalog/aclchk.c:3375 #, c-format msgid "must be owner of operator class %s" msgstr "doit être le propriétaire de la classe d'opérateur %s" -#: catalog/aclchk.c:3369 +#: catalog/aclchk.c:3377 #, c-format msgid "must be owner of operator family %s" msgstr "doit être le prorpriétaire de la famille d'opérateur %s" -#: catalog/aclchk.c:3371 +#: catalog/aclchk.c:3379 #, c-format msgid "must be owner of collation %s" msgstr "doit être le propriétaire du collationnement %s" -#: catalog/aclchk.c:3373 +#: catalog/aclchk.c:3381 #, c-format msgid "must be owner of conversion %s" msgstr "doit être le propriétaire de la conversion %s" -#: catalog/aclchk.c:3375 +#: catalog/aclchk.c:3383 #, c-format msgid "must be owner of tablespace %s" msgstr "doit être le propriétaire du tablespace %s" -#: catalog/aclchk.c:3377 +#: catalog/aclchk.c:3385 #, c-format msgid "must be owner of text search dictionary %s" msgstr "doit être le propriétaire du dictionnaire de recherche plein texte %s" -#: catalog/aclchk.c:3379 +#: catalog/aclchk.c:3387 #, c-format msgid "must be owner of text search configuration %s" msgstr "doit être le propriétaire de la configuration de recherche plein texte %s" -#: catalog/aclchk.c:3381 +#: catalog/aclchk.c:3389 #, c-format msgid "must be owner of foreign-data wrapper %s" msgstr "doit être le propriétaire du wrapper de données distantes %s" -#: catalog/aclchk.c:3383 +#: catalog/aclchk.c:3391 #, c-format msgid "must be owner of foreign server %s" msgstr "doit être le propriétaire de serveur distant %s" -#: catalog/aclchk.c:3385 +#: catalog/aclchk.c:3393 #, c-format msgid "must be owner of event trigger %s" msgstr "doit être le propriétaire du trigger sur événement %s" -#: catalog/aclchk.c:3387 +#: catalog/aclchk.c:3395 #, c-format msgid "must be owner of extension %s" msgstr "doit être le propriétaire de l'extension %s" -#: catalog/aclchk.c:3429 +#: catalog/aclchk.c:3437 #, c-format msgid "permission denied for column \"%s\" of relation \"%s\"" msgstr "droit refusé pour la colonne « %s » de la relation « %s »" -#: catalog/aclchk.c:3548 catalog/aclchk.c:3556 +#: catalog/aclchk.c:3556 catalog/aclchk.c:3564 #, c-format msgid "attribute %d of relation with OID %u does not exist" msgstr "l'attribut %d de la relation d'OID %u n'existe pas" -#: catalog/aclchk.c:3629 catalog/aclchk.c:4548 +#: catalog/aclchk.c:3637 catalog/aclchk.c:4556 #, c-format msgid "relation with OID %u does not exist" msgstr "la relation d'OID %u n'existe pas" -#: catalog/aclchk.c:3728 catalog/aclchk.c:4966 +#: catalog/aclchk.c:3736 catalog/aclchk.c:4974 #, c-format msgid "database with OID %u does not exist" msgstr "la base de données d'OID %u n'existe pas" -#: catalog/aclchk.c:3782 catalog/aclchk.c:4626 tcop/fastpath.c:223 +#: catalog/aclchk.c:3790 catalog/aclchk.c:4634 tcop/fastpath.c:223 #, c-format msgid "function with OID %u does not exist" msgstr "la fonction d'OID %u n'existe pas" -#: catalog/aclchk.c:3836 catalog/aclchk.c:4652 +#: catalog/aclchk.c:3844 catalog/aclchk.c:4660 #, c-format msgid "language with OID %u does not exist" msgstr "le langage d'OID %u n'existe pas" -#: catalog/aclchk.c:4000 catalog/aclchk.c:4724 +#: catalog/aclchk.c:4008 catalog/aclchk.c:4732 #, c-format msgid "schema with OID %u does not exist" msgstr "le schéma d'OID %u n'existe pas" -#: catalog/aclchk.c:4054 catalog/aclchk.c:4751 +#: catalog/aclchk.c:4062 catalog/aclchk.c:4759 #, c-format msgid "tablespace with OID %u does not exist" msgstr "le tablespace d'OID %u n'existe pas" -#: catalog/aclchk.c:4113 catalog/aclchk.c:4885 commands/foreigncmds.c:325 +#: catalog/aclchk.c:4121 catalog/aclchk.c:4893 commands/foreigncmds.c:325 #, c-format msgid "foreign-data wrapper with OID %u does not exist" msgstr "le wrapper de données distantes d'OID %u n'existe pas" -#: catalog/aclchk.c:4175 catalog/aclchk.c:4912 commands/foreigncmds.c:461 +#: catalog/aclchk.c:4183 catalog/aclchk.c:4920 commands/foreigncmds.c:461 #, c-format msgid "foreign server with OID %u does not exist" msgstr "le serveur distant d'OID %u n'existe pas" -#: catalog/aclchk.c:4235 catalog/aclchk.c:4574 +#: catalog/aclchk.c:4243 catalog/aclchk.c:4582 #, c-format msgid "type with OID %u does not exist" msgstr "le type d'OID %u n'existe pas" -#: catalog/aclchk.c:4600 +#: catalog/aclchk.c:4608 #, c-format msgid "operator with OID %u does not exist" msgstr "l'opérateur d'OID %u n'existe pas" -#: catalog/aclchk.c:4777 +#: catalog/aclchk.c:4785 #, c-format msgid "operator class with OID %u does not exist" msgstr "la classe d'opérateur d'OID %u n'existe pas" -#: catalog/aclchk.c:4804 +#: catalog/aclchk.c:4812 #, c-format msgid "operator family with OID %u does not exist" msgstr "la famille d'opérateur d'OID %u n'existe pas" -#: catalog/aclchk.c:4831 +#: catalog/aclchk.c:4839 #, c-format msgid "text search dictionary with OID %u does not exist" msgstr "le dictionnaire de recherche plein texte d'OID %u n'existe pas" -#: catalog/aclchk.c:4858 +#: catalog/aclchk.c:4866 #, c-format msgid "text search configuration with OID %u does not exist" msgstr "la configuration de recherche plein texte d'OID %u n'existe pas" -#: catalog/aclchk.c:4939 commands/event_trigger.c:587 +#: catalog/aclchk.c:4947 commands/event_trigger.c:587 #, c-format msgid "event trigger with OID %u does not exist" msgstr "le trigger sur événement d'OID %u n'existe pas" -#: catalog/aclchk.c:4992 +#: catalog/aclchk.c:5000 #, c-format msgid "collation with OID %u does not exist" msgstr "le collationnement d'OID %u n'existe pas" -#: catalog/aclchk.c:5018 +#: catalog/aclchk.c:5026 #, c-format msgid "conversion with OID %u does not exist" msgstr "la conversion d'OID %u n'existe pas" -#: catalog/aclchk.c:5059 +#: catalog/aclchk.c:5067 #, c-format msgid "extension with OID %u does not exist" msgstr "l'extension d'OID %u n'existe pas" @@ -3634,12 +3634,12 @@ msgstr "droit refusé pour créer « %s.%s »" msgid "System catalog modifications are currently disallowed." msgstr "Les modifications du catalogue système sont actuellement interdites." -#: catalog/heap.c:415 commands/tablecmds.c:1438 commands/tablecmds.c:1895 commands/tablecmds.c:4819 +#: catalog/heap.c:415 commands/tablecmds.c:1439 commands/tablecmds.c:1896 commands/tablecmds.c:4820 #, c-format msgid "tables can have at most %d columns" msgstr "les tables peuvent avoir au plus %d colonnes" -#: catalog/heap.c:432 commands/tablecmds.c:5080 +#: catalog/heap.c:432 commands/tablecmds.c:5081 #, c-format msgid "column name \"%s\" conflicts with a system column name" msgstr "le nom de la colonne « %s » entre en conflit avec le nom d'une colonne système" @@ -3674,12 +3674,12 @@ msgstr "le type composite %s ne peut pas être membre de lui-même" msgid "no collation was derived for column \"%s\" with collatable type %s" msgstr "aucun collationnement n'a été dérivé pour la colonne « %s » de type collationnable %s" -#: catalog/heap.c:586 commands/createas.c:204 commands/createas.c:501 commands/indexcmds.c:1132 commands/view.c:105 regex/regc_pg_locale.c:262 utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 utils/adt/like.c:213 utils/adt/selfuncs.c:5334 utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 +#: catalog/heap.c:586 commands/createas.c:204 commands/createas.c:501 commands/indexcmds.c:1132 commands/view.c:103 regex/regc_pg_locale.c:262 utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 utils/adt/like.c:213 utils/adt/selfuncs.c:5334 utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 #, c-format msgid "Use the COLLATE clause to set the collation explicitly." msgstr "Utilisez la clause COLLARE pour configurer explicitement le collationnement." -#: catalog/heap.c:1067 catalog/index.c:792 commands/tablecmds.c:2622 +#: catalog/heap.c:1067 catalog/index.c:792 commands/tablecmds.c:2623 #, c-format msgid "relation \"%s\" already exists" msgstr "la relation « %s » existe déjà" @@ -3701,89 +3701,89 @@ msgstr "" msgid "pg_class heap OID value not set when in binary upgrade mode" msgstr "OID du heap de pg_class non configuré en mode de mise à jour binaire" -#: catalog/heap.c:2290 +#: catalog/heap.c:2291 #, c-format msgid "check constraint \"%s\" already exists" msgstr "la contrainte de vérification « %s » existe déjà" -#: catalog/heap.c:2455 catalog/pg_constraint.c:654 commands/tablecmds.c:6068 +#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6069 #, c-format msgid "constraint \"%s\" for relation \"%s\" already exists" msgstr "la contrainte « %s » de la relation « %s » existe déjà" -#: catalog/heap.c:2462 +#: catalog/heap.c:2463 #, c-format msgid "constraint \"%s\" conflicts with non-inherited constraint on relation \"%s\"" msgstr "la contrainte « %s » entre en conflit avec la constrainte non héritée sur la relation « %s »" -#: catalog/heap.c:2473 +#: catalog/heap.c:2474 #, c-format msgid "constraint \"%s\" conflicts with inherited constraint on relation \"%s\"" msgstr "la contrainte « %s » entre en conflit avec une contrainte héritée sur la relation « %s »" -#: catalog/heap.c:2483 +#: catalog/heap.c:2484 #, c-format msgid "constraint \"%s\" conflicts with NOT VALID constraint on relation \"%s\"" msgstr "la contrainte « %s » entre en conflit avec une contrainte NOT VALID sur la relation « %s »" -#: catalog/heap.c:2488 +#: catalog/heap.c:2489 #, c-format msgid "merging constraint \"%s\" with inherited definition" msgstr "assemblage de la contrainte « %s » avec une définition héritée" -#: catalog/heap.c:2594 +#: catalog/heap.c:2595 #, c-format msgid "cannot use column references in default expression" msgstr "ne peut pas utiliser les références de colonnes dans l'expression par défaut" -#: catalog/heap.c:2605 +#: catalog/heap.c:2606 #, c-format msgid "default expression must not return a set" msgstr "l'expression par défaut ne doit pas renvoyer un ensemble" -#: catalog/heap.c:2624 rewrite/rewriteHandler.c:1084 +#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1084 #, c-format msgid "column \"%s\" is of type %s but default expression is of type %s" msgstr "la colonne « %s » est de type %s alors que l'expression par défaut est de type %s" -#: catalog/heap.c:2629 commands/prepare.c:374 parser/parse_node.c:428 parser/parse_target.c:539 parser/parse_target.c:789 parser/parse_target.c:799 rewrite/rewriteHandler.c:1089 +#: catalog/heap.c:2630 commands/prepare.c:374 parser/parse_node.c:428 parser/parse_target.c:539 parser/parse_target.c:789 parser/parse_target.c:799 rewrite/rewriteHandler.c:1089 #, c-format msgid "You will need to rewrite or cast the expression." msgstr "Vous devez réécrire l'expression ou lui appliquer une transformation de type." -#: catalog/heap.c:2676 +#: catalog/heap.c:2677 #, c-format msgid "only table \"%s\" can be referenced in check constraint" msgstr "seule la table « %s » peut être référencée dans la contrainte de vérification" -#: catalog/heap.c:2916 +#: catalog/heap.c:2917 #, c-format msgid "unsupported ON COMMIT and foreign key combination" msgstr "combinaison ON COMMIT et clé étrangère non supportée" -#: catalog/heap.c:2917 +#: catalog/heap.c:2918 #, c-format msgid "Table \"%s\" references \"%s\", but they do not have the same ON COMMIT setting." msgstr "" "La table « %s » référence « %s » mais elles n'ont pas la même valeur pour le\n" "paramètre ON COMMIT." -#: catalog/heap.c:2922 +#: catalog/heap.c:2923 #, c-format msgid "cannot truncate a table referenced in a foreign key constraint" msgstr "ne peut pas tronquer une table référencée dans une contrainte de clé étrangère" -#: catalog/heap.c:2923 +#: catalog/heap.c:2924 #, c-format msgid "Table \"%s\" references \"%s\"." msgstr "La table « %s » référence « %s »." -#: catalog/heap.c:2925 +#: catalog/heap.c:2926 #, c-format msgid "Truncate table \"%s\" at the same time, or use TRUNCATE ... CASCADE." msgstr "Tronquez la table « %s » en même temps, ou utilisez TRUNCATE ... CASCADE." -#: catalog/index.c:210 parser/parse_utilcmd.c:1488 parser/parse_utilcmd.c:1574 +#: catalog/index.c:210 parser/parse_utilcmd.c:1473 parser/parse_utilcmd.c:1559 #, c-format msgid "multiple primary keys for table \"%s\" are not allowed" msgstr "les clés primaires multiples ne sont pas autorisées pour la table « %s »" @@ -3810,7 +3810,7 @@ msgstr "" msgid "shared indexes cannot be created after initdb" msgstr "les index partagés ne peuvent pas être créés après initdb" -#: catalog/index.c:784 commands/createas.c:249 commands/sequence.c:141 parser/parse_utilcmd.c:192 +#: catalog/index.c:784 commands/createas.c:249 commands/sequence.c:141 parser/parse_utilcmd.c:191 #, c-format msgid "relation \"%s\" already exists, skipping" msgstr "la relation « %s » existe déjà, poursuite du traitement" @@ -3865,17 +3865,17 @@ msgstr "n'a pas pu obtenir un verrou sur la relation « %s.%s »" msgid "could not obtain lock on relation \"%s\"" msgstr "n'a pas pu obtenir un verrou sur la relation « %s »" -#: catalog/namespace.c:414 parser/parse_relation.c:1137 +#: catalog/namespace.c:414 parser/parse_relation.c:1138 #, c-format msgid "relation \"%s.%s\" does not exist" msgstr "la relation « %s.%s » n'existe pas" -#: catalog/namespace.c:419 parser/parse_relation.c:1150 parser/parse_relation.c:1158 utils/adt/regproc.c:1034 +#: catalog/namespace.c:419 parser/parse_relation.c:1151 parser/parse_relation.c:1159 utils/adt/regproc.c:1034 #, c-format msgid "relation \"%s\" does not exist" msgstr "la relation « %s » n'existe pas" -#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1382 commands/extension.c:1388 +#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1383 commands/extension.c:1389 #, c-format msgid "no schema has been selected to create in" msgstr "aucun schéma n'a été sélectionné pour cette création" @@ -3935,7 +3935,7 @@ msgstr "ne peut pas déplacer les objets dans ou à partir des schémas temporai msgid "cannot move objects into or out of TOAST schema" msgstr "ne peut pas déplacer les objets dans ou à partir des schémas TOAST" -#: catalog/namespace.c:2862 commands/schemacmds.c:238 commands/schemacmds.c:317 commands/tablecmds.c:740 +#: catalog/namespace.c:2862 commands/schemacmds.c:238 commands/schemacmds.c:317 commands/tablecmds.c:741 #, c-format msgid "schema \"%s\" does not exist" msgstr "le schéma « %s » n'existe pas" @@ -3983,7 +3983,7 @@ msgstr "le nom de la méthode d'accès ne peut pas être qualifiée" msgid "database name cannot be qualified" msgstr "le nom de la base de donnée ne peut être qualifié" -#: catalog/objectaddress.c:1071 commands/extension.c:2506 +#: catalog/objectaddress.c:1071 commands/extension.c:2507 #, c-format msgid "extension name cannot be qualified" msgstr "le nom de l'extension ne peut pas être qualifié" @@ -4016,22 +4016,22 @@ msgstr "le nom du serveur ne peut pas être qualifié" msgid "event trigger name cannot be qualified" msgstr "le nom du trigger sur événement ne peut pas être qualifié" -#: catalog/objectaddress.c:1210 commands/lockcmds.c:94 commands/policy.c:94 commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:217 commands/tablecmds.c:1299 commands/tablecmds.c:4346 commands/tablecmds.c:8016 +#: catalog/objectaddress.c:1210 commands/lockcmds.c:94 commands/policy.c:94 commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:218 commands/tablecmds.c:1300 commands/tablecmds.c:4347 commands/tablecmds.c:8017 #, c-format msgid "\"%s\" is not a table" msgstr "« %s » n'est pas une table" -#: catalog/objectaddress.c:1217 commands/tablecmds.c:229 commands/tablecmds.c:4376 commands/tablecmds.c:12062 commands/view.c:143 +#: catalog/objectaddress.c:1217 commands/tablecmds.c:230 commands/tablecmds.c:4377 commands/tablecmds.c:12159 commands/view.c:141 #, c-format msgid "\"%s\" is not a view" msgstr "« %s » n'est pas une vue" -#: catalog/objectaddress.c:1224 commands/matview.c:174 commands/tablecmds.c:235 commands/tablecmds.c:12067 +#: catalog/objectaddress.c:1224 commands/matview.c:174 commands/tablecmds.c:236 commands/tablecmds.c:12164 #, c-format msgid "\"%s\" is not a materialized view" msgstr "« %s » n'est pas une vue matérialisée" -#: catalog/objectaddress.c:1231 commands/tablecmds.c:253 commands/tablecmds.c:4379 commands/tablecmds.c:12072 +#: catalog/objectaddress.c:1231 commands/tablecmds.c:254 commands/tablecmds.c:4380 commands/tablecmds.c:12169 #, c-format msgid "\"%s\" is not a foreign table" msgstr "« %s » n'est pas une table distante" @@ -4046,7 +4046,7 @@ msgstr "le nom de la colonne doit être qualifié" msgid "default value for column \"%s\" of relation \"%s\" does not exist" msgstr "la valeur par défaut de la colonne « %s » de la relation « %s » n'existe pas" -#: catalog/objectaddress.c:1512 commands/functioncmds.c:128 commands/tablecmds.c:245 commands/typecmds.c:3214 parser/parse_type.c:226 parser/parse_type.c:255 parser/parse_type.c:795 utils/adt/acl.c:4374 utils/adt/regproc.c:1225 +#: catalog/objectaddress.c:1512 commands/functioncmds.c:128 commands/tablecmds.c:246 commands/typecmds.c:3214 parser/parse_type.c:226 parser/parse_type.c:255 parser/parse_type.c:795 utils/adt/acl.c:4374 utils/adt/regproc.c:1225 #, c-format msgid "type \"%s\" does not exist" msgstr "le type « %s » n'existe pas" @@ -4575,7 +4575,7 @@ msgstr "la conversion « %s » existe déjà" msgid "default conversion for %s to %s already exists" msgstr "la conversion par défaut de %s vers %s existe déjà" -#: catalog/pg_depend.c:165 commands/extension.c:3028 +#: catalog/pg_depend.c:165 commands/extension.c:3029 #, c-format msgid "%s is already a member of extension \"%s\"" msgstr "%s est déjà un membre de l'extension « %s »" @@ -4783,7 +4783,7 @@ msgstr "les fonctions SQL ne peuvent pas renvoyer un type %s" msgid "SQL functions cannot have arguments of type %s" msgstr "les fonctions SQL ne peuvent avoir d'arguments du type %s" -#: catalog/pg_proc.c:973 executor/functions.c:1422 +#: catalog/pg_proc.c:973 executor/functions.c:1431 #, c-format msgid "SQL function \"%s\"" msgstr "Fonction SQL « %s »" @@ -4892,7 +4892,7 @@ msgstr "les types de taille fixe doivent avoir un stockage de base" msgid "could not form array type name for type \"%s\"" msgstr "n'a pas pu former le nom du type array pour le type de données %s" -#: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4358 commands/tablecmds.c:11950 +#: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4359 commands/tablecmds.c:12047 #, c-format msgid "\"%s\" is not a table or materialized view" msgstr "« %s » n'est pas une table ou une vue matérialisée" @@ -5147,7 +5147,7 @@ msgstr "ignore l'analyse de l'arbre d'héritage « %s.%s » --- cet arbre d'hér msgid "skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no analyzable child tables" msgstr "ignore l'analyse de l'arbre d'héritage « %s.%s » --- cet arbre d'héritage ne contient pas de tables enfants analysables" -#: commands/analyze.c:1420 executor/execQual.c:2927 +#: commands/analyze.c:1420 commands/tablecmds.c:8079 executor/execQual.c:2927 msgid "could not convert row type" msgstr "n'a pas pu convertir le type de ligne" @@ -5205,7 +5205,7 @@ msgstr "ne peut pas exécuter CLUSTER sur les tables temporaires des autres sess msgid "there is no previously clustered index for table \"%s\"" msgstr "Il n'existe pas d'index CLUSTER pour la table « %s »" -#: commands/cluster.c:173 commands/tablecmds.c:9325 commands/tablecmds.c:11052 +#: commands/cluster.c:173 commands/tablecmds.c:9383 commands/tablecmds.c:11143 #, c-format msgid "index \"%s\" for table \"%s\" does not exist" msgstr "l'index « %s » pour la table « %s » n'existe pas" @@ -5220,7 +5220,7 @@ msgstr "ne peut pas exécuter CLUSTER sur un catalogue partagé" msgid "cannot vacuum temporary tables of other sessions" msgstr "ne peut pas exécuter VACUUM sur les tables temporaires des autres sessions" -#: commands/cluster.c:431 commands/tablecmds.c:11062 +#: commands/cluster.c:431 commands/tablecmds.c:11153 #, c-format msgid "\"%s\" is not an index for table \"%s\"" msgstr "« %s » n'est pas un index de la table « %s »" @@ -5303,7 +5303,7 @@ msgstr "le collationnement « %s » existe déjà dans le schéma « %s »" msgid "database \"%s\" does not exist" msgstr "la base de données « %s » n'existe pas" -#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:768 +#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:753 #, c-format msgid "\"%s\" is not a table, view, materialized view, composite type, or foreign table" msgstr "« %s » n'est ni une table, ni une vue, ni une vue matérialisée, ni un type composite, ni une table distante" @@ -5839,12 +5839,12 @@ msgstr "taille du champ invalide" msgid "incorrect binary data format" msgstr "format de données binaires incorrect" -#: commands/copy.c:4463 commands/indexcmds.c:1053 commands/tablecmds.c:1463 commands/tablecmds.c:2290 parser/parse_relation.c:3084 parser/parse_relation.c:3104 utils/adt/tsvector_op.c:2307 +#: commands/copy.c:4463 commands/indexcmds.c:1053 commands/tablecmds.c:1464 commands/tablecmds.c:2291 parser/parse_relation.c:3177 parser/parse_relation.c:3197 utils/adt/tsvector_op.c:2559 #, c-format msgid "column \"%s\" does not exist" msgstr "la colonne « %s » n'existe pas" -#: commands/copy.c:4470 commands/tablecmds.c:1489 commands/trigger.c:651 parser/parse_target.c:967 parser/parse_target.c:978 +#: commands/copy.c:4470 commands/tablecmds.c:1490 commands/trigger.c:651 parser/parse_target.c:967 parser/parse_target.c:978 #, c-format msgid "column \"%s\" specified more than once" msgstr "la colonne « %s » est spécifiée plus d'une fois" @@ -6140,17 +6140,17 @@ msgstr "« %s » est une fonction d'agrégat" msgid "Use DROP AGGREGATE to drop aggregate functions." msgstr "Utiliser DROP AGGREGATE pour supprimer les fonctions d'agrégat." -#: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2377 commands/tablecmds.c:2528 commands/tablecmds.c:2570 commands/tablecmds.c:11427 tcop/utility.c:1119 +#: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2378 commands/tablecmds.c:2529 commands/tablecmds.c:2571 commands/tablecmds.c:11524 tcop/utility.c:1119 #, c-format msgid "relation \"%s\" does not exist, skipping" msgstr "la relation « %s » n'existe pas, poursuite du traitement" -#: commands/dropcmds.c:195 commands/dropcmds.c:296 commands/tablecmds.c:745 +#: commands/dropcmds.c:195 commands/dropcmds.c:296 commands/tablecmds.c:746 #, c-format msgid "schema \"%s\" does not exist, skipping" msgstr "le schéma « %s » n'existe pas, poursuite du traitement" -#: commands/dropcmds.c:237 commands/dropcmds.c:276 commands/tablecmds.c:246 +#: commands/dropcmds.c:237 commands/dropcmds.c:276 commands/tablecmds.c:247 #, c-format msgid "type \"%s\" does not exist, skipping" msgstr "le type « %s » n'existe pas, poursuite du traitement" @@ -6357,239 +6357,239 @@ msgstr "l'option BUFFERS d'EXPLAIN nécessite ANALYZE" msgid "EXPLAIN option TIMING requires ANALYZE" msgstr "l'option TIMING d'EXPLAIN nécessite ANALYZE" -#: commands/extension.c:154 commands/extension.c:2718 +#: commands/extension.c:155 commands/extension.c:2719 #, c-format msgid "extension \"%s\" does not exist" msgstr "l'extension « %s » n'existe pas" -#: commands/extension.c:253 commands/extension.c:262 commands/extension.c:274 commands/extension.c:284 +#: commands/extension.c:254 commands/extension.c:263 commands/extension.c:275 commands/extension.c:285 #, c-format msgid "invalid extension name: \"%s\"" msgstr "nom d'extension invalide : « %s »" -#: commands/extension.c:254 +#: commands/extension.c:255 #, c-format msgid "Extension names must not be empty." msgstr "Les noms d'extension ne doivent pas être vides." -#: commands/extension.c:263 +#: commands/extension.c:264 #, c-format msgid "Extension names must not contain \"--\"." msgstr "Les noms d'extension ne doivent pas contenir « -- »." -#: commands/extension.c:275 +#: commands/extension.c:276 #, c-format msgid "Extension names must not begin or end with \"-\"." msgstr "Les noms des extensions ne doivent pas commencer ou finir avec un tiret (« - »)." -#: commands/extension.c:285 +#: commands/extension.c:286 #, c-format msgid "Extension names must not contain directory separator characters." msgstr "Les noms des extensions ne doivent pas contenir des caractères séparateurs de répertoire." -#: commands/extension.c:300 commands/extension.c:309 commands/extension.c:318 commands/extension.c:328 +#: commands/extension.c:301 commands/extension.c:310 commands/extension.c:319 commands/extension.c:329 #, c-format msgid "invalid extension version name: \"%s\"" msgstr "nom de version de l'extension invalide : « %s »" -#: commands/extension.c:301 +#: commands/extension.c:302 #, c-format msgid "Version names must not be empty." msgstr "Les noms de version ne doivent pas être vides." -#: commands/extension.c:310 +#: commands/extension.c:311 #, c-format msgid "Version names must not contain \"--\"." msgstr "Les noms de version ne doivent pas contenir « -- »." -#: commands/extension.c:319 +#: commands/extension.c:320 #, c-format msgid "Version names must not begin or end with \"-\"." msgstr "Les noms de version ne doivent ni commencer ni se terminer avec un tiret." -#: commands/extension.c:329 +#: commands/extension.c:330 #, c-format msgid "Version names must not contain directory separator characters." msgstr "" "Les noms de version ne doivent pas contenir de caractères séparateurs de\n" "répertoire." -#: commands/extension.c:479 +#: commands/extension.c:480 #, c-format msgid "could not open extension control file \"%s\": %m" msgstr "n'a pas pu ouvrir le fichier de contrôle d'extension « %s » : %m" -#: commands/extension.c:501 commands/extension.c:511 +#: commands/extension.c:502 commands/extension.c:512 #, c-format msgid "parameter \"%s\" cannot be set in a secondary extension control file" msgstr "" "le paramètre « %s » ne peut pas être configuré dans un fichier de contrôle\n" "secondaire de l'extension" -#: commands/extension.c:550 +#: commands/extension.c:551 #, c-format msgid "\"%s\" is not a valid encoding name" msgstr "« %s » n'est pas un nom d'encodage valide" -#: commands/extension.c:564 +#: commands/extension.c:565 #, c-format msgid "parameter \"%s\" must be a list of extension names" msgstr "l'argument « %s » doit être une liste de noms d'extension" -#: commands/extension.c:571 +#: commands/extension.c:572 #, c-format msgid "unrecognized parameter \"%s\" in file \"%s\"" msgstr "paramètre « %s » non reconnu dans le fichier « %s »" -#: commands/extension.c:580 +#: commands/extension.c:581 #, c-format msgid "parameter \"schema\" cannot be specified when \"relocatable\" is true" msgstr "le paramètre « schema » ne peut pas être indiqué quand « relocatable » est vrai" -#: commands/extension.c:721 +#: commands/extension.c:722 #, c-format msgid "transaction control statements are not allowed within an extension script" msgstr "" "les instructions de contrôle des transactions ne sont pas autorisées dans un\n" "script d'extension" -#: commands/extension.c:789 +#: commands/extension.c:790 #, c-format msgid "permission denied to create extension \"%s\"" msgstr "droit refusé pour créer l'extension « %s »" -#: commands/extension.c:791 +#: commands/extension.c:792 #, c-format msgid "Must be superuser to create this extension." msgstr "Doit être super-utilisateur pour créer cette extension." -#: commands/extension.c:795 +#: commands/extension.c:796 #, c-format msgid "permission denied to update extension \"%s\"" msgstr "droit refusé pour mettre à jour l'extension « %s »" -#: commands/extension.c:797 +#: commands/extension.c:798 #, c-format msgid "Must be superuser to update this extension." msgstr "Doit être super-utilisateur pour mettre à jour cette extension." -#: commands/extension.c:1079 +#: commands/extension.c:1080 #, c-format msgid "extension \"%s\" has no update path from version \"%s\" to version \"%s\"" msgstr "l'extension « %s » n'a pas de chemin de mise à jour pour aller de la version « %s » à la version « %s »" -#: commands/extension.c:1261 commands/extension.c:2778 +#: commands/extension.c:1262 commands/extension.c:2779 #, c-format msgid "version to install must be specified" msgstr "la version à installer doit être précisée" -#: commands/extension.c:1278 +#: commands/extension.c:1279 #, c-format msgid "FROM version must be different from installation target version \"%s\"" msgstr "la version FROM doit être différente de la version cible d'installation « %s »" -#: commands/extension.c:1343 +#: commands/extension.c:1344 #, c-format msgid "extension \"%s\" must be installed in schema \"%s\"" msgstr "l'extension « %s » doit être installée dans le schéma « %s »" -#: commands/extension.c:1435 +#: commands/extension.c:1436 #, c-format msgid "cyclic dependency detected between extensions \"%s\" and \"%s\"" msgstr "dépendance cyclique détectée entre les extensions « %s » et « %s »" -#: commands/extension.c:1440 +#: commands/extension.c:1441 #, c-format msgid "installing required extension \"%s\"" msgstr "installation de l'extension requise « %s »" -#: commands/extension.c:1468 commands/extension.c:2923 +#: commands/extension.c:1469 commands/extension.c:2924 #, c-format msgid "required extension \"%s\" is not installed" msgstr "l'extension « %s » requise n'est pas installée" -#: commands/extension.c:1470 +#: commands/extension.c:1471 #, c-format msgid "Use CREATE EXTENSION ... CASCADE to install required extensions too." msgstr "Utilisez CREATE EXTENSION ... CASCADE pour installer également les extensions requises." -#: commands/extension.c:1534 +#: commands/extension.c:1535 #, c-format msgid "extension \"%s\" already exists, skipping" msgstr "l'extension « %s » existe déjà, poursuite du traitement" -#: commands/extension.c:1541 +#: commands/extension.c:1542 #, c-format msgid "extension \"%s\" already exists" msgstr "l'extension « %s » existe déjà" -#: commands/extension.c:1552 +#: commands/extension.c:1553 #, c-format msgid "nested CREATE EXTENSION is not supported" msgstr "CREATE EXTENSION imbriqué n'est pas supporté" -#: commands/extension.c:1680 +#: commands/extension.c:1681 #, c-format msgid "cannot drop extension \"%s\" because it is being modified" msgstr "ne peut pas supprimer l'extension « %s » car il est en cours de modification" -#: commands/extension.c:2151 +#: commands/extension.c:2152 #, c-format msgid "pg_extension_config_dump() can only be called from an SQL script executed by CREATE EXTENSION" msgstr "" "pg_extension_config_dump() peut seulement être appelé à partir d'un script SQL\n" "exécuté par CREATE EXTENSION" -#: commands/extension.c:2163 +#: commands/extension.c:2164 #, c-format msgid "OID %u does not refer to a table" msgstr "l'OID %u ne fait pas référence à une table" -#: commands/extension.c:2168 +#: commands/extension.c:2169 #, c-format msgid "table \"%s\" is not a member of the extension being created" msgstr "la table « %s » n'est pas un membre de l'extension en cours de création" -#: commands/extension.c:2533 +#: commands/extension.c:2534 #, c-format msgid "cannot move extension \"%s\" into schema \"%s\" because the extension contains the schema" msgstr "" "ne peut pas déplacer l'extension « %s » dans le schéma « %s » car l'extension\n" "contient le schéma" -#: commands/extension.c:2573 commands/extension.c:2636 +#: commands/extension.c:2574 commands/extension.c:2637 #, c-format msgid "extension \"%s\" does not support SET SCHEMA" msgstr "l'extension « %s » ne supporte pas SET SCHEMA" -#: commands/extension.c:2638 +#: commands/extension.c:2639 #, c-format msgid "%s is not in the extension's schema \"%s\"" msgstr "%s n'est pas dans le schéma « %s » de l'extension" -#: commands/extension.c:2698 +#: commands/extension.c:2699 #, c-format msgid "nested ALTER EXTENSION is not supported" msgstr "un ALTER EXTENSION imbriqué n'est pas supporté" -#: commands/extension.c:2789 +#: commands/extension.c:2790 #, c-format msgid "version \"%s\" of extension \"%s\" is already installed" msgstr "la version « %s » de l'extension « %s » est déjà installée" -#: commands/extension.c:3040 +#: commands/extension.c:3041 #, c-format msgid "cannot add schema \"%s\" to extension \"%s\" because the schema contains the extension" msgstr "" "ne peut pas ajouter le schéma « %s » à l'extension « %s » car le schéma\n" "contient l'extension" -#: commands/extension.c:3058 +#: commands/extension.c:3069 #, c-format msgid "%s is not a member of extension \"%s\"" msgstr "%s n'est pas un membre de l'extension « %s »" -#: commands/extension.c:3114 +#: commands/extension.c:3135 #, c-format msgid "file \"%s\" is too large" msgstr "le fichier « %s » est trop gros" @@ -7053,7 +7053,7 @@ msgstr "ne peut pas créer un index sur la table distante « %s »" msgid "cannot create indexes on temporary tables of other sessions" msgstr "ne peut pas créer les index sur les tables temporaires des autres sessions" -#: commands/indexcmds.c:454 commands/tablecmds.c:545 commands/tablecmds.c:9636 +#: commands/indexcmds.c:454 commands/tablecmds.c:546 commands/tablecmds.c:9694 #, c-format msgid "only shared relations can be placed in pg_global tablespace" msgstr "seules les relations partagées peuvent être placées dans le tablespace pg_global" @@ -7098,7 +7098,7 @@ msgstr "%s %s créera un index implicite « %s » pour la table « %s »" msgid "functions in index predicate must be marked IMMUTABLE" msgstr "les fonctions dans un prédicat d'index doivent être marquées comme IMMUTABLE" -#: commands/indexcmds.c:1048 parser/parse_utilcmd.c:1896 +#: commands/indexcmds.c:1048 parser/parse_utilcmd.c:1881 #, c-format msgid "column \"%s\" named in key does not exist" msgstr "la colonne « %s » nommée dans la clé n'existe pas" @@ -7115,7 +7115,7 @@ msgstr "" msgid "could not determine which collation to use for index expression" msgstr "n'a pas pu déterminer le collationnement à utiliser pour l'expression d'index" -#: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2608 parser/parse_type.c:550 parser/parse_utilcmd.c:2822 utils/adt/misc.c:666 +#: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2608 parser/parse_type.c:550 parser/parse_utilcmd.c:2807 utils/adt/misc.c:666 #, c-format msgid "collations are not supported by type %s" msgstr "les collationnements ne sont pas supportés par le type %s" @@ -7442,7 +7442,7 @@ msgstr "" msgid "operator attribute \"%s\" cannot be changed" msgstr "l'attribut « %s » de l'opérateur ne peut pas être changé" -#: commands/policy.c:87 commands/policy.c:388 commands/policy.c:477 commands/tablecmds.c:970 commands/tablecmds.c:1312 commands/tablecmds.c:2184 commands/tablecmds.c:4328 commands/tablecmds.c:6279 commands/tablecmds.c:11983 commands/tablecmds.c:12018 commands/trigger.c:241 commands/trigger.c:1125 commands/trigger.c:1233 rewrite/rewriteDefine.c:273 rewrite/rewriteDefine.c:917 +#: commands/policy.c:87 commands/policy.c:388 commands/policy.c:477 commands/tablecmds.c:971 commands/tablecmds.c:1313 commands/tablecmds.c:2185 commands/tablecmds.c:4329 commands/tablecmds.c:6280 commands/tablecmds.c:12080 commands/tablecmds.c:12115 commands/trigger.c:241 commands/trigger.c:1125 commands/trigger.c:1233 rewrite/rewriteDefine.c:273 rewrite/rewriteDefine.c:917 #, c-format msgid "permission denied: \"%s\" is a system catalog" msgstr "droit refusé : « %s » est un catalogue système" @@ -7700,275 +7700,275 @@ msgstr "la séquence doit avoir le même propriétaire que la table avec laquell msgid "sequence must be in same schema as table it is linked to" msgstr "la séquence doit être dans le même schéma que la table avec laquelle elle est liée" -#: commands/tablecmds.c:215 +#: commands/tablecmds.c:216 #, c-format msgid "table \"%s\" does not exist" msgstr "la table « %s » n'existe pas" -#: commands/tablecmds.c:216 +#: commands/tablecmds.c:217 #, c-format msgid "table \"%s\" does not exist, skipping" msgstr "la table « %s » n'existe pas, poursuite du traitement" -#: commands/tablecmds.c:218 +#: commands/tablecmds.c:219 msgid "Use DROP TABLE to remove a table." msgstr "Utilisez DROP TABLE pour supprimer une table." -#: commands/tablecmds.c:221 +#: commands/tablecmds.c:222 #, c-format msgid "sequence \"%s\" does not exist" msgstr "la séquence « %s » n'existe pas" -#: commands/tablecmds.c:222 +#: commands/tablecmds.c:223 #, c-format msgid "sequence \"%s\" does not exist, skipping" msgstr "la séquence « %s » n'existe pas, poursuite du traitement" -#: commands/tablecmds.c:224 +#: commands/tablecmds.c:225 msgid "Use DROP SEQUENCE to remove a sequence." msgstr "Utilisez DROP SEQUENCE pour supprimer une séquence." -#: commands/tablecmds.c:227 +#: commands/tablecmds.c:228 #, c-format msgid "view \"%s\" does not exist" msgstr "la vue « %s » n'existe pas" -#: commands/tablecmds.c:228 +#: commands/tablecmds.c:229 #, c-format msgid "view \"%s\" does not exist, skipping" msgstr "la vue « %s » n'existe pas, poursuite du traitement" -#: commands/tablecmds.c:230 +#: commands/tablecmds.c:231 msgid "Use DROP VIEW to remove a view." msgstr "Utilisez DROP VIEW pour supprimer une vue." -#: commands/tablecmds.c:233 +#: commands/tablecmds.c:234 #, c-format msgid "materialized view \"%s\" does not exist" msgstr "la vue matérialisée « %s » n'existe pas" -#: commands/tablecmds.c:234 +#: commands/tablecmds.c:235 #, c-format msgid "materialized view \"%s\" does not exist, skipping" msgstr "la vue matérialisée « %s » n'existe pas, poursuite du traitement" -#: commands/tablecmds.c:236 +#: commands/tablecmds.c:237 msgid "Use DROP MATERIALIZED VIEW to remove a materialized view." msgstr "Utilisez DROP MATERIALIZED VIEW pour supprimer une vue matérialisée." -#: commands/tablecmds.c:239 parser/parse_utilcmd.c:1645 +#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1630 #, c-format msgid "index \"%s\" does not exist" msgstr "l'index « %s » n'existe pas" -#: commands/tablecmds.c:240 +#: commands/tablecmds.c:241 #, c-format msgid "index \"%s\" does not exist, skipping" msgstr "l'index « %s » n'existe pas, poursuite du traitement" -#: commands/tablecmds.c:242 +#: commands/tablecmds.c:243 msgid "Use DROP INDEX to remove an index." msgstr "Utilisez DROP INDEX pour supprimer un index." -#: commands/tablecmds.c:247 +#: commands/tablecmds.c:248 #, c-format msgid "\"%s\" is not a type" msgstr "« %s » n'est pas un type" -#: commands/tablecmds.c:248 +#: commands/tablecmds.c:249 msgid "Use DROP TYPE to remove a type." msgstr "Utilisez DROP TYPE pour supprimer un type." -#: commands/tablecmds.c:251 commands/tablecmds.c:8525 commands/tablecmds.c:11244 +#: commands/tablecmds.c:252 commands/tablecmds.c:8583 commands/tablecmds.c:11335 #, c-format msgid "foreign table \"%s\" does not exist" msgstr "la table distante « %s » n'existe pas" -#: commands/tablecmds.c:252 +#: commands/tablecmds.c:253 #, c-format msgid "foreign table \"%s\" does not exist, skipping" msgstr "la table distante « %s » n'existe pas, poursuite du traitement" -#: commands/tablecmds.c:254 +#: commands/tablecmds.c:255 msgid "Use DROP FOREIGN TABLE to remove a foreign table." msgstr "Utilisez DROP FOREIGN TABLE pour supprimer une table distante." -#: commands/tablecmds.c:493 +#: commands/tablecmds.c:494 #, c-format msgid "ON COMMIT can only be used on temporary tables" msgstr "ON COMMIT peut seulement être utilisé sur des tables temporaires" -#: commands/tablecmds.c:513 +#: commands/tablecmds.c:514 #, c-format msgid "cannot create temporary table within security-restricted operation" msgstr "" "ne peut pas créer une table temporaire à l'intérieur d'une fonction\n" "restreinte pour sécurité" -#: commands/tablecmds.c:821 +#: commands/tablecmds.c:822 #, c-format msgid "DROP INDEX CONCURRENTLY does not support dropping multiple objects" msgstr "DROP INDEX CONCURRENTLY ne permet pas de supprimer plusieurs objets" -#: commands/tablecmds.c:825 +#: commands/tablecmds.c:826 #, c-format msgid "DROP INDEX CONCURRENTLY does not support CASCADE" msgstr "DROP INDEX CONCURRENTLY ne permet pas la CASCADE" -#: commands/tablecmds.c:1084 +#: commands/tablecmds.c:1085 #, c-format msgid "truncate cascades to table \"%s\"" msgstr "TRUNCATE cascade sur la table « %s »" -#: commands/tablecmds.c:1322 +#: commands/tablecmds.c:1323 #, c-format msgid "cannot truncate temporary tables of other sessions" msgstr "ne peut pas tronquer les tables temporaires des autres sessions" -#: commands/tablecmds.c:1528 parser/parse_utilcmd.c:1859 +#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1844 #, c-format msgid "inherited relation \"%s\" is not a table or foreign table" msgstr "la relation héritée « %s » n'est ni une table ni une table distante" -#: commands/tablecmds.c:1535 commands/tablecmds.c:10092 +#: commands/tablecmds.c:1536 commands/tablecmds.c:10150 #, c-format msgid "cannot inherit from temporary relation \"%s\"" msgstr "ine peut pas hériter à partir d'une relation temporaire « %s »" -#: commands/tablecmds.c:1543 commands/tablecmds.c:10100 +#: commands/tablecmds.c:1544 commands/tablecmds.c:10158 #, c-format msgid "cannot inherit from temporary relation of another session" msgstr "ne peut pas hériter de la table temporaire d'une autre session" -#: commands/tablecmds.c:1559 commands/tablecmds.c:10134 +#: commands/tablecmds.c:1560 commands/tablecmds.c:10192 #, c-format msgid "relation \"%s\" would be inherited from more than once" msgstr "la relation « %s » serait héritée plus d'une fois" -#: commands/tablecmds.c:1607 +#: commands/tablecmds.c:1608 #, c-format msgid "merging multiple inherited definitions of column \"%s\"" msgstr "assemblage de plusieurs définitions d'héritage pour la colonne « %s »" -#: commands/tablecmds.c:1615 +#: commands/tablecmds.c:1616 #, c-format msgid "inherited column \"%s\" has a type conflict" msgstr "la colonne héritée « %s » a un conflit de type" -#: commands/tablecmds.c:1617 commands/tablecmds.c:1640 commands/tablecmds.c:1838 commands/tablecmds.c:1862 parser/parse_coerce.c:1630 parser/parse_coerce.c:1650 parser/parse_coerce.c:1670 parser/parse_coerce.c:1715 parser/parse_coerce.c:1752 parser/parse_param.c:218 +#: commands/tablecmds.c:1618 commands/tablecmds.c:1641 commands/tablecmds.c:1839 commands/tablecmds.c:1863 parser/parse_coerce.c:1630 parser/parse_coerce.c:1650 parser/parse_coerce.c:1670 parser/parse_coerce.c:1715 parser/parse_coerce.c:1752 parser/parse_param.c:218 #, c-format msgid "%s versus %s" msgstr "%s versus %s" -#: commands/tablecmds.c:1626 +#: commands/tablecmds.c:1627 #, c-format msgid "inherited column \"%s\" has a collation conflict" msgstr "la colonne héritée « %s » a un conflit sur le collationnement" -#: commands/tablecmds.c:1628 commands/tablecmds.c:1850 commands/tablecmds.c:4766 +#: commands/tablecmds.c:1629 commands/tablecmds.c:1851 commands/tablecmds.c:4767 #, c-format msgid "\"%s\" versus \"%s\"" msgstr "« %s » versus « %s »" -#: commands/tablecmds.c:1638 +#: commands/tablecmds.c:1639 #, c-format msgid "inherited column \"%s\" has a storage parameter conflict" msgstr "la colonne héritée « %s » a un conflit de paramètre de stockage" -#: commands/tablecmds.c:1751 parser/parse_utilcmd.c:938 parser/parse_utilcmd.c:1289 parser/parse_utilcmd.c:1365 +#: commands/tablecmds.c:1752 commands/tablecmds.c:8088 parser/parse_utilcmd.c:923 parser/parse_utilcmd.c:1274 parser/parse_utilcmd.c:1350 #, c-format msgid "cannot convert whole-row table reference" msgstr "ne peut pas convertir une référence de ligne complète de table" -#: commands/tablecmds.c:1752 parser/parse_utilcmd.c:939 +#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:924 #, c-format msgid "Constraint \"%s\" contains a whole-row reference to table \"%s\"." msgstr "La constrainte « %s » contient une référence de ligne complète vers la table « %s »." -#: commands/tablecmds.c:1824 +#: commands/tablecmds.c:1825 #, c-format msgid "merging column \"%s\" with inherited definition" msgstr "assemblage de la colonne « %s » avec une définition héritée" -#: commands/tablecmds.c:1828 +#: commands/tablecmds.c:1829 #, c-format msgid "moving and merging column \"%s\" with inherited definition" msgstr "déplacement et assemblage de la colonne « %s » avec une définition héritée" -#: commands/tablecmds.c:1829 +#: commands/tablecmds.c:1830 #, c-format msgid "User-specified column moved to the position of the inherited column." msgstr "Colonne utilisateur déplacée à la position de la colonne héritée." -#: commands/tablecmds.c:1836 +#: commands/tablecmds.c:1837 #, c-format msgid "column \"%s\" has a type conflict" msgstr "la colonne « %s » a un conflit de type" -#: commands/tablecmds.c:1848 +#: commands/tablecmds.c:1849 #, c-format msgid "column \"%s\" has a collation conflict" msgstr "la colonne « %s » a un conflit sur le collationnement" -#: commands/tablecmds.c:1860 +#: commands/tablecmds.c:1861 #, c-format msgid "column \"%s\" has a storage parameter conflict" msgstr "la colonne « %s » a un conflit de paramètre de stockage" -#: commands/tablecmds.c:1912 +#: commands/tablecmds.c:1913 #, c-format msgid "column \"%s\" inherits conflicting default values" msgstr "la colonne « %s » hérite de valeurs par défaut conflictuelles" -#: commands/tablecmds.c:1914 +#: commands/tablecmds.c:1915 #, c-format msgid "To resolve the conflict, specify a default explicitly." msgstr "Pour résoudre le conflit, spécifiez explicitement une valeur par défaut." -#: commands/tablecmds.c:1961 +#: commands/tablecmds.c:1962 #, c-format msgid "check constraint name \"%s\" appears multiple times but with different expressions" msgstr "" "le nom de la contrainte de vérification, « %s », apparaît plusieurs fois\n" "mais avec des expressions différentes" -#: commands/tablecmds.c:2155 +#: commands/tablecmds.c:2156 #, c-format msgid "cannot rename column of typed table" msgstr "ne peut pas renommer une colonne d'une table typée" -#: commands/tablecmds.c:2172 +#: commands/tablecmds.c:2173 #, c-format msgid "\"%s\" is not a table, view, materialized view, composite type, index, or foreign table" msgstr "« %s » n'est ni une table, ni une vue, ni une vue matérialisée, ni un type composite, ni un index, ni une table distante" -#: commands/tablecmds.c:2266 +#: commands/tablecmds.c:2267 #, c-format msgid "inherited column \"%s\" must be renamed in child tables too" msgstr "la colonne héritée « %s » doit aussi être renommée pour les tables filles" -#: commands/tablecmds.c:2298 +#: commands/tablecmds.c:2299 #, c-format msgid "cannot rename system column \"%s\"" msgstr "ne peut pas renommer la colonne système « %s »" -#: commands/tablecmds.c:2313 +#: commands/tablecmds.c:2314 #, c-format msgid "cannot rename inherited column \"%s\"" msgstr "ne peut pas renommer la colonne héritée « %s »" -#: commands/tablecmds.c:2468 +#: commands/tablecmds.c:2469 #, c-format msgid "inherited constraint \"%s\" must be renamed in child tables too" msgstr "la contrainte héritée « %s » doit aussi être renommée pour les tables enfants" -#: commands/tablecmds.c:2475 +#: commands/tablecmds.c:2476 #, c-format msgid "cannot rename inherited constraint \"%s\"" msgstr "ne peut pas renommer la colonne héritée « %s »" #. translator: first %s is a SQL command, eg ALTER TABLE -#: commands/tablecmds.c:2701 +#: commands/tablecmds.c:2702 #, c-format msgid "cannot %s \"%s\" because it is being used by active queries in this session" msgstr "" @@ -7976,647 +7976,652 @@ msgstr "" "des requêtes actives dans cette session" #. translator: first %s is a SQL command, eg ALTER TABLE -#: commands/tablecmds.c:2710 +#: commands/tablecmds.c:2711 #, c-format msgid "cannot %s \"%s\" because it has pending trigger events" msgstr "ne peut pas exécuter %s « %s » car il reste des événements sur les triggers" -#: commands/tablecmds.c:3784 +#: commands/tablecmds.c:3785 #, c-format msgid "cannot rewrite system relation \"%s\"" msgstr "ne peut pas ré-écrire la relation système « %s »" -#: commands/tablecmds.c:3790 +#: commands/tablecmds.c:3791 #, c-format msgid "cannot rewrite table \"%s\" used as a catalog table" msgstr "ne peut pas réécrire la table « %s » utilisée comme une table catalogue" -#: commands/tablecmds.c:3800 +#: commands/tablecmds.c:3801 #, c-format msgid "cannot rewrite temporary tables of other sessions" msgstr "ne peut pas ré-écrire les tables temporaires des autres sessions" -#: commands/tablecmds.c:4068 +#: commands/tablecmds.c:4069 #, c-format msgid "rewriting table \"%s\"" msgstr "ré-écriture de la table « %s »" -#: commands/tablecmds.c:4072 +#: commands/tablecmds.c:4073 #, c-format msgid "verifying table \"%s\"" msgstr "vérification de la table « %s »" -#: commands/tablecmds.c:4186 +#: commands/tablecmds.c:4187 #, c-format msgid "column \"%s\" contains null values" msgstr "la colonne « %s » contient des valeurs NULL" -#: commands/tablecmds.c:4201 commands/tablecmds.c:7384 +#: commands/tablecmds.c:4202 commands/tablecmds.c:7385 #, c-format msgid "check constraint \"%s\" is violated by some row" msgstr "la contrainte de vérification « %s » est rompue par une ligne" -#: commands/tablecmds.c:4349 commands/trigger.c:235 rewrite/rewriteDefine.c:267 rewrite/rewriteDefine.c:912 +#: commands/tablecmds.c:4350 commands/trigger.c:235 rewrite/rewriteDefine.c:267 rewrite/rewriteDefine.c:912 #, c-format msgid "\"%s\" is not a table or view" msgstr "« %s » n'est pas une table ou une vue" -#: commands/tablecmds.c:4352 commands/trigger.c:1119 commands/trigger.c:1224 +#: commands/tablecmds.c:4353 commands/trigger.c:1119 commands/trigger.c:1224 #, c-format msgid "\"%s\" is not a table, view, or foreign table" msgstr "« %s » n'est pas une table, une vue ou une table distante" -#: commands/tablecmds.c:4355 +#: commands/tablecmds.c:4356 #, c-format msgid "\"%s\" is not a table, view, materialized view, or index" msgstr "« %s » n'est pas une table, une vue, une vue matérialisée, une séquence ou une table distante" -#: commands/tablecmds.c:4361 +#: commands/tablecmds.c:4362 #, c-format msgid "\"%s\" is not a table, materialized view, or index" msgstr "« %s » n'est pas une table, une vue matérialisée ou un index" -#: commands/tablecmds.c:4364 +#: commands/tablecmds.c:4365 #, c-format msgid "\"%s\" is not a table, materialized view, or foreign table" msgstr "« %s » n'est pas une table, une vue matérialisée ou une table distante" -#: commands/tablecmds.c:4367 +#: commands/tablecmds.c:4368 #, c-format msgid "\"%s\" is not a table or foreign table" msgstr "« %s » n'est pas une table ou une table distante" -#: commands/tablecmds.c:4370 +#: commands/tablecmds.c:4371 #, c-format msgid "\"%s\" is not a table, composite type, or foreign table" msgstr "« %s » n'est ni une table, ni un type composite, ni une table distante" -#: commands/tablecmds.c:4373 commands/tablecmds.c:5425 +#: commands/tablecmds.c:4374 commands/tablecmds.c:5426 #, c-format msgid "\"%s\" is not a table, materialized view, index, or foreign table" msgstr "« %s » n'est pas une table, une vue matérialisée, un index ou une table distante" -#: commands/tablecmds.c:4383 +#: commands/tablecmds.c:4384 #, c-format msgid "\"%s\" is of the wrong type" msgstr "« %s » est du mauvais type" -#: commands/tablecmds.c:4535 commands/tablecmds.c:4542 +#: commands/tablecmds.c:4536 commands/tablecmds.c:4543 #, c-format msgid "cannot alter type \"%s\" because column \"%s.%s\" uses it" msgstr "ne peux pas modifier le type « %s » car la colonne « %s.%s » l'utilise" -#: commands/tablecmds.c:4549 +#: commands/tablecmds.c:4550 #, c-format msgid "cannot alter foreign table \"%s\" because column \"%s.%s\" uses its row type" msgstr "" "ne peut pas modifier la table distante « %s » car la colonne « %s.%s » utilise\n" "son type de ligne" -#: commands/tablecmds.c:4556 +#: commands/tablecmds.c:4557 #, c-format msgid "cannot alter table \"%s\" because column \"%s.%s\" uses its row type" msgstr "" "ne peut pas modifier la table « %s » car la colonne « %s.%s » utilise\n" "son type de ligne" -#: commands/tablecmds.c:4618 +#: commands/tablecmds.c:4619 #, c-format msgid "cannot alter type \"%s\" because it is the type of a typed table" msgstr "ne peut pas modifier le type « %s » car il s'agit du type d'une table de type" -#: commands/tablecmds.c:4620 +#: commands/tablecmds.c:4621 #, c-format msgid "Use ALTER ... CASCADE to alter the typed tables too." msgstr "Utilisez ALTER ... CASCADE pour modifier aussi les tables de type." -#: commands/tablecmds.c:4664 +#: commands/tablecmds.c:4665 #, c-format msgid "type %s is not a composite type" msgstr "le type %s n'est pas un type composite" -#: commands/tablecmds.c:4690 +#: commands/tablecmds.c:4691 #, c-format msgid "cannot add column to typed table" msgstr "ne peut pas ajouter une colonne à une table typée" -#: commands/tablecmds.c:4758 commands/tablecmds.c:10293 +#: commands/tablecmds.c:4759 commands/tablecmds.c:10351 #, c-format msgid "child table \"%s\" has different type for column \"%s\"" msgstr "la table fille « %s » a un type différent pour la colonne « %s »" -#: commands/tablecmds.c:4764 commands/tablecmds.c:10300 +#: commands/tablecmds.c:4765 commands/tablecmds.c:10358 #, c-format msgid "child table \"%s\" has different collation for column \"%s\"" msgstr "la table fille « %s » a un collationnement différent pour la colonne « %s »" -#: commands/tablecmds.c:4774 +#: commands/tablecmds.c:4775 #, c-format msgid "child table \"%s\" has a conflicting \"%s\" column" msgstr "la table fille « %s » a une colonne conflictuelle, « %s »" -#: commands/tablecmds.c:4786 +#: commands/tablecmds.c:4787 #, c-format msgid "merging definition of column \"%s\" for child \"%s\"" msgstr "assemblage de la définition de la colonne « %s » pour le fils « %s »" -#: commands/tablecmds.c:5013 +#: commands/tablecmds.c:5014 #, c-format msgid "column must be added to child tables too" msgstr "la colonne doit aussi être ajoutée aux tables filles" -#: commands/tablecmds.c:5088 +#: commands/tablecmds.c:5089 #, c-format msgid "column \"%s\" of relation \"%s\" already exists, skipping" msgstr "la colonne « %s » de la relation « %s » existe déjà, poursuite du traitement" -#: commands/tablecmds.c:5095 +#: commands/tablecmds.c:5096 #, c-format msgid "column \"%s\" of relation \"%s\" already exists" msgstr "la colonne « %s » de la relation « %s » existe déjà" -#: commands/tablecmds.c:5206 commands/tablecmds.c:5312 commands/tablecmds.c:5370 commands/tablecmds.c:5484 commands/tablecmds.c:5541 commands/tablecmds.c:5635 commands/tablecmds.c:7923 commands/tablecmds.c:8548 +#: commands/tablecmds.c:5207 commands/tablecmds.c:5313 commands/tablecmds.c:5371 commands/tablecmds.c:5485 commands/tablecmds.c:5542 commands/tablecmds.c:5636 commands/tablecmds.c:7924 commands/tablecmds.c:8606 #, c-format msgid "cannot alter system column \"%s\"" msgstr "n'a pas pu modifier la colonne système « %s »" -#: commands/tablecmds.c:5242 +#: commands/tablecmds.c:5243 #, c-format msgid "column \"%s\" is in a primary key" msgstr "la colonne « %s » est dans une clé primaire" -#: commands/tablecmds.c:5457 +#: commands/tablecmds.c:5458 #, c-format msgid "statistics target %d is too low" msgstr "la cible statistique %d est trop basse" -#: commands/tablecmds.c:5465 +#: commands/tablecmds.c:5466 #, c-format msgid "lowering statistics target to %d" msgstr "abaissement de la cible statistique à %d" -#: commands/tablecmds.c:5615 +#: commands/tablecmds.c:5616 #, c-format msgid "invalid storage type \"%s\"" msgstr "type « %s » de stockage invalide" -#: commands/tablecmds.c:5647 +#: commands/tablecmds.c:5648 #, c-format msgid "column data type %s can only have storage PLAIN" msgstr "le type de données %s de la colonne peut seulement avoir un stockage PLAIN" -#: commands/tablecmds.c:5685 +#: commands/tablecmds.c:5686 #, c-format msgid "cannot drop column from typed table" msgstr "ne peut pas supprimer une colonne à une table typée" -#: commands/tablecmds.c:5729 +#: commands/tablecmds.c:5730 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist, skipping" msgstr "la colonne « %s » de la relation « %s » n'existe pas, ignore" -#: commands/tablecmds.c:5742 +#: commands/tablecmds.c:5743 #, c-format msgid "cannot drop system column \"%s\"" msgstr "ne peut pas supprimer la colonne système « %s »" -#: commands/tablecmds.c:5749 +#: commands/tablecmds.c:5750 #, c-format msgid "cannot drop inherited column \"%s\"" msgstr "ne peut pas supprimer la colonne héritée « %s »" -#: commands/tablecmds.c:5989 +#: commands/tablecmds.c:5990 #, c-format msgid "ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index \"%s\" to \"%s\"" msgstr "ALTER TABLE / ADD CONSTRAINT USING INDEX renommera l'index « %s » en « %s »" -#: commands/tablecmds.c:6202 +#: commands/tablecmds.c:6203 #, c-format msgid "constraint must be added to child tables too" msgstr "la contrainte doit aussi être ajoutée aux tables filles" -#: commands/tablecmds.c:6273 +#: commands/tablecmds.c:6274 #, c-format msgid "referenced relation \"%s\" is not a table" msgstr "la relation référencée « %s » n'est pas une table" -#: commands/tablecmds.c:6296 +#: commands/tablecmds.c:6297 #, c-format msgid "constraints on permanent tables may reference only permanent tables" msgstr "les contraintes sur les tables permanentes peuvent seulement référencer des tables permanentes" -#: commands/tablecmds.c:6303 +#: commands/tablecmds.c:6304 #, c-format msgid "constraints on unlogged tables may reference only permanent or unlogged tables" msgstr "les contraintes sur les tables non tracées peuvent seulement référencer des tables permanentes ou non tracées" -#: commands/tablecmds.c:6309 +#: commands/tablecmds.c:6310 #, c-format msgid "constraints on temporary tables may reference only temporary tables" msgstr "" "les constraintes sur des tables temporaires ne peuvent référencer que des\n" "tables temporaires" -#: commands/tablecmds.c:6313 +#: commands/tablecmds.c:6314 #, c-format msgid "constraints on temporary tables must involve temporary tables of this session" msgstr "" "les contraintes sur des tables temporaires doivent référencer les tables\n" "temporaires de cette session" -#: commands/tablecmds.c:6374 +#: commands/tablecmds.c:6375 #, c-format msgid "number of referencing and referenced columns for foreign key disagree" msgstr "nombre de colonnes de référence et référencées pour la clé étrangère en désaccord" -#: commands/tablecmds.c:6481 +#: commands/tablecmds.c:6482 #, c-format msgid "foreign key constraint \"%s\" cannot be implemented" msgstr "la contrainte de clé étrangère « %s » ne peut pas être implémentée" -#: commands/tablecmds.c:6484 +#: commands/tablecmds.c:6485 #, c-format msgid "Key columns \"%s\" and \"%s\" are of incompatible types: %s and %s." msgstr "Les colonnes clés « %s » et « %s » sont de types incompatibles : %s et %s." -#: commands/tablecmds.c:6691 commands/tablecmds.c:6859 commands/tablecmds.c:7762 commands/tablecmds.c:7818 +#: commands/tablecmds.c:6692 commands/tablecmds.c:6860 commands/tablecmds.c:7763 commands/tablecmds.c:7819 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist" msgstr "la contrainte « %s » de la relation « %s » n'existe pas" -#: commands/tablecmds.c:6697 +#: commands/tablecmds.c:6698 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key constraint" msgstr "la contrainte « %s » de la relation « %s » n'est pas une clé étrangère" -#: commands/tablecmds.c:6866 +#: commands/tablecmds.c:6867 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key or check constraint" msgstr "la contrainte « %s » de la relation « %s » n'est pas une clé étrangère ou une contrainte de vérification" -#: commands/tablecmds.c:6934 +#: commands/tablecmds.c:6935 #, c-format msgid "constraint must be validated on child tables too" msgstr "la contrainte doit aussi être validées sur les tables enfants" -#: commands/tablecmds.c:7003 +#: commands/tablecmds.c:7004 #, c-format msgid "column \"%s\" referenced in foreign key constraint does not exist" msgstr "la colonne « %s » référencée dans la contrainte de clé étrangère n'existe pas" -#: commands/tablecmds.c:7008 +#: commands/tablecmds.c:7009 #, c-format msgid "cannot have more than %d keys in a foreign key" msgstr "ne peut pas avoir plus de %d clés dans une clé étrangère" -#: commands/tablecmds.c:7073 +#: commands/tablecmds.c:7074 #, c-format msgid "cannot use a deferrable primary key for referenced table \"%s\"" msgstr "ne peut pas utiliser une clé primaire déferrable pour la table « %s » référencée" -#: commands/tablecmds.c:7090 +#: commands/tablecmds.c:7091 #, c-format msgid "there is no primary key for referenced table \"%s\"" msgstr "il n'existe pas de clé étrangère pour la table « %s » référencée" -#: commands/tablecmds.c:7155 +#: commands/tablecmds.c:7156 #, c-format msgid "foreign key referenced-columns list must not contain duplicates" msgstr "la liste de colonnes référencées dans la clé étrangère ne doit pas contenir de duplicats" -#: commands/tablecmds.c:7249 +#: commands/tablecmds.c:7250 #, c-format msgid "cannot use a deferrable unique constraint for referenced table \"%s\"" msgstr "" "ne peut pas utiliser une contrainte unique déferrable pour la table\n" "référencée « %s »" -#: commands/tablecmds.c:7254 +#: commands/tablecmds.c:7255 #, c-format msgid "there is no unique constraint matching given keys for referenced table \"%s\"" msgstr "" "il n'existe aucune contrainte unique correspondant aux clés données pour la\n" "table « %s » référencée" -#: commands/tablecmds.c:7417 +#: commands/tablecmds.c:7418 #, c-format msgid "validating foreign key constraint \"%s\"" msgstr "validation de la contraintes de clé étrangère « %s »" -#: commands/tablecmds.c:7716 +#: commands/tablecmds.c:7717 #, c-format msgid "cannot drop inherited constraint \"%s\" of relation \"%s\"" msgstr "ne peut pas supprimer la contrainte héritée « %s » de la relation « %s »" -#: commands/tablecmds.c:7768 +#: commands/tablecmds.c:7769 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist, skipping" msgstr "la contrainte « %s » de la relation « %s » n'existe pas, ignore" -#: commands/tablecmds.c:7907 +#: commands/tablecmds.c:7908 #, c-format msgid "cannot alter column type of typed table" msgstr "ne peut pas modifier le type d'une colonne appartenant à une table typée" -#: commands/tablecmds.c:7930 +#: commands/tablecmds.c:7931 #, c-format msgid "cannot alter inherited column \"%s\"" msgstr "ne peut pas modifier la colonne héritée « %s »" -#: commands/tablecmds.c:7979 +#: commands/tablecmds.c:7980 #, c-format msgid "result of USING clause for column \"%s\" cannot be cast automatically to type %s" msgstr "le résultat de la clause USING pour la colonne « %s » ne peut pas être converti automatiquement vers le type %s" -#: commands/tablecmds.c:7982 +#: commands/tablecmds.c:7983 #, c-format msgid "You might need to add an explicit cast." msgstr "Vous pouvez avoir besoin d'ajouter une conversion explicite." -#: commands/tablecmds.c:7986 +#: commands/tablecmds.c:7987 #, c-format msgid "column \"%s\" cannot be cast automatically to type %s" msgstr "la colonne « %s » ne peut pas être convertie vers le type %s" #. translator: USING is SQL, don't translate it -#: commands/tablecmds.c:7989 +#: commands/tablecmds.c:7990 #, c-format msgid "You might need to specify \"USING %s::%s\"." msgstr "Vous pouvez avoir besoin de spécifier \"USING %s::%s\"." -#: commands/tablecmds.c:8042 +#: commands/tablecmds.c:8089 +#, c-format +msgid "USING expression contains a whole-row table reference." +msgstr "l'expression USING contient une référence de table de ligne complète" + +#: commands/tablecmds.c:8100 #, c-format msgid "type of inherited column \"%s\" must be changed in child tables too" msgstr "le type de colonne héritée « %s » doit aussi être renommée pour les tables filles" -#: commands/tablecmds.c:8129 +#: commands/tablecmds.c:8187 #, c-format msgid "cannot alter type of column \"%s\" twice" msgstr "ne peut pas modifier la colonne « %s » deux fois" -#: commands/tablecmds.c:8165 +#: commands/tablecmds.c:8223 #, c-format msgid "default for column \"%s\" cannot be cast automatically to type %s" msgstr "" "la valeur par défaut de la colonne « %s » ne peut pas être convertie vers le\n" "type %s automatiquement" -#: commands/tablecmds.c:8291 +#: commands/tablecmds.c:8349 #, c-format msgid "cannot alter type of a column used by a view or rule" msgstr "ne peut pas modifier le type d'une colonne utilisée dans une vue ou une règle" -#: commands/tablecmds.c:8292 commands/tablecmds.c:8311 commands/tablecmds.c:8329 +#: commands/tablecmds.c:8350 commands/tablecmds.c:8369 commands/tablecmds.c:8387 #, c-format msgid "%s depends on column \"%s\"" msgstr "%s dépend de la colonne « %s »" -#: commands/tablecmds.c:8310 +#: commands/tablecmds.c:8368 #, c-format msgid "cannot alter type of a column used in a trigger definition" msgstr "ne peut pas modifier le type d'une colonne utilisée dans la définition d'un trigger" -#: commands/tablecmds.c:8328 +#: commands/tablecmds.c:8386 #, c-format msgid "cannot alter type of a column used in a policy definition" msgstr "ne peut pas modifier le type d'une colonne utilisée dans la définition d'une politique" -#: commands/tablecmds.c:8993 +#: commands/tablecmds.c:9051 #, c-format msgid "cannot change owner of index \"%s\"" msgstr "ne peut pas modifier le propriétaire de l'index « %s »" -#: commands/tablecmds.c:8995 +#: commands/tablecmds.c:9053 #, c-format msgid "Change the ownership of the index's table, instead." msgstr "Modifier à la place le propriétaire de la table concernée par l'index." -#: commands/tablecmds.c:9011 +#: commands/tablecmds.c:9069 #, c-format msgid "cannot change owner of sequence \"%s\"" msgstr "ne peut pas modifier le propriétaire de la séquence « %s »" -#: commands/tablecmds.c:9013 commands/tablecmds.c:11446 +#: commands/tablecmds.c:9071 commands/tablecmds.c:11543 #, c-format msgid "Sequence \"%s\" is linked to table \"%s\"." msgstr "La séquence « %s » est liée à la table « %s »." -#: commands/tablecmds.c:9025 commands/tablecmds.c:12093 +#: commands/tablecmds.c:9083 commands/tablecmds.c:12190 #, c-format msgid "Use ALTER TYPE instead." msgstr "Utilisez ALTER TYPE à la place." -#: commands/tablecmds.c:9034 +#: commands/tablecmds.c:9092 #, c-format msgid "\"%s\" is not a table, view, sequence, or foreign table" msgstr "« %s » n'est pas une table, une vue, une séquence ou une table distante" -#: commands/tablecmds.c:9377 +#: commands/tablecmds.c:9435 #, c-format msgid "cannot have multiple SET TABLESPACE subcommands" msgstr "ne peut pas avoir de nombreuses sous-commandes SET TABLESPACE" -#: commands/tablecmds.c:9450 +#: commands/tablecmds.c:9508 #, c-format msgid "\"%s\" is not a table, view, materialized view, index, or TOAST table" msgstr "« %s » n'est pas une table, une vue, une vue matérialisée, un index ou une table TOAST" -#: commands/tablecmds.c:9483 commands/view.c:469 +#: commands/tablecmds.c:9541 commands/view.c:498 #, c-format msgid "WITH CHECK OPTION is supported only on automatically updatable views" msgstr "WITH CHECK OPTION est uniquement accepté pour les vues dont la mise à jour est automatique" -#: commands/tablecmds.c:9629 +#: commands/tablecmds.c:9687 #, c-format msgid "cannot move system relation \"%s\"" msgstr "ne peut pas déplacer la colonne système « %s »" -#: commands/tablecmds.c:9645 +#: commands/tablecmds.c:9703 #, c-format msgid "cannot move temporary tables of other sessions" msgstr "ne peut pas déplacer les tables temporaires d'autres sessions" -#: commands/tablecmds.c:9782 +#: commands/tablecmds.c:9840 #, c-format msgid "only tables, indexes, and materialized views exist in tablespaces" msgstr "seuls les tables, index et vues matérialisées existent dans les tablespaces" -#: commands/tablecmds.c:9794 +#: commands/tablecmds.c:9852 #, c-format msgid "cannot move relations in to or out of pg_global tablespace" msgstr "ne peut pas déplacer les relations dans ou à partir du tablespace pg_global" -#: commands/tablecmds.c:9885 +#: commands/tablecmds.c:9943 #, c-format msgid "aborting because lock on relation \"%s.%s\" is not available" msgstr "annulation car le verrou sur la relation « %s.%s » n'est pas disponible" -#: commands/tablecmds.c:9901 +#: commands/tablecmds.c:9959 #, c-format msgid "no matching relations in tablespace \"%s\" found" msgstr "aucune relation correspondante trouvée dans le tablespace « %s »" -#: commands/tablecmds.c:9975 storage/buffer/bufmgr.c:915 +#: commands/tablecmds.c:10033 storage/buffer/bufmgr.c:915 #, c-format msgid "invalid page in block %u of relation %s" msgstr "page invalide dans le bloc %u de la relation %s" -#: commands/tablecmds.c:10057 +#: commands/tablecmds.c:10115 #, c-format msgid "cannot change inheritance of typed table" msgstr "ne peut pas modifier l'héritage d'une table typée" -#: commands/tablecmds.c:10107 +#: commands/tablecmds.c:10165 #, c-format msgid "cannot inherit to temporary relation of another session" msgstr "ne peut pas hériter à partir d'une relation temporaire d'une autre session" -#: commands/tablecmds.c:10161 +#: commands/tablecmds.c:10219 #, c-format msgid "circular inheritance not allowed" msgstr "héritage circulaire interdit" -#: commands/tablecmds.c:10162 +#: commands/tablecmds.c:10220 #, c-format msgid "\"%s\" is already a child of \"%s\"." msgstr "« %s » est déjà un enfant de « %s »." -#: commands/tablecmds.c:10170 +#: commands/tablecmds.c:10228 #, c-format msgid "table \"%s\" without OIDs cannot inherit from table \"%s\" with OIDs" msgstr "la table « %s » qui n'a pas d'OID ne peut pas hériter de la table « %s » qui en a" -#: commands/tablecmds.c:10311 +#: commands/tablecmds.c:10369 #, c-format msgid "column \"%s\" in child table must be marked NOT NULL" msgstr "la colonne « %s » de la table enfant doit être marquée comme NOT NULL" -#: commands/tablecmds.c:10327 +#: commands/tablecmds.c:10385 commands/tablecmds.c:10418 #, c-format msgid "child table is missing column \"%s\"" msgstr "la colonne « %s » manque à la table enfant" -#: commands/tablecmds.c:10410 +#: commands/tablecmds.c:10501 #, c-format msgid "child table \"%s\" has different definition for check constraint \"%s\"" msgstr "la table fille « %s » a un type différent pour la contrainte de vérification « %s »" -#: commands/tablecmds.c:10418 +#: commands/tablecmds.c:10509 #, c-format msgid "constraint \"%s\" conflicts with non-inherited constraint on child table \"%s\"" msgstr "la contrainte « %s » entre en conflit avec une contrainte non héritée sur la table fille « %s »" -#: commands/tablecmds.c:10429 +#: commands/tablecmds.c:10520 #, c-format msgid "constraint \"%s\" conflicts with NOT VALID constraint on child table \"%s\"" msgstr "la contrainte « %s » entre en conflit avec une contrainte NOT VALID sur la table fille « %s »" -#: commands/tablecmds.c:10453 +#: commands/tablecmds.c:10544 #, c-format msgid "child table is missing constraint \"%s\"" msgstr "la contrainte « %s » manque à la table enfant" -#: commands/tablecmds.c:10537 +#: commands/tablecmds.c:10628 #, c-format msgid "relation \"%s\" is not a parent of relation \"%s\"" msgstr "la relation « %s » n'est pas un parent de la relation « %s »" -#: commands/tablecmds.c:10771 +#: commands/tablecmds.c:10862 #, c-format msgid "typed tables cannot inherit" msgstr "les tables avec type ne peuvent pas hériter d'autres tables" -#: commands/tablecmds.c:10802 +#: commands/tablecmds.c:10893 #, c-format msgid "table is missing column \"%s\"" msgstr "la colonne « %s » manque à la table" -#: commands/tablecmds.c:10812 +#: commands/tablecmds.c:10903 #, c-format msgid "table has column \"%s\" where type requires \"%s\"" msgstr "la table a une colonne « %s » alors que le type impose « %s »." -#: commands/tablecmds.c:10821 +#: commands/tablecmds.c:10912 #, c-format msgid "table \"%s\" has different type for column \"%s\"" msgstr "la table « %s » a un type différent pour la colonne « %s »" -#: commands/tablecmds.c:10834 +#: commands/tablecmds.c:10925 #, c-format msgid "table has extra column \"%s\"" msgstr "la table a une colonne supplémentaire « %s »" -#: commands/tablecmds.c:10886 +#: commands/tablecmds.c:10977 #, c-format msgid "\"%s\" is not a typed table" msgstr "« %s » n'est pas une table typée" -#: commands/tablecmds.c:11070 +#: commands/tablecmds.c:11161 #, c-format msgid "cannot use non-unique index \"%s\" as replica identity" msgstr "ne peut pas utiliser l'index non unique « %s » comme identité de réplicat" -#: commands/tablecmds.c:11076 +#: commands/tablecmds.c:11167 #, c-format msgid "cannot use non-immediate index \"%s\" as replica identity" msgstr "ne peut pas utiliser l'index « %s » immédiat comme identité de réplicat" -#: commands/tablecmds.c:11082 +#: commands/tablecmds.c:11173 #, c-format msgid "cannot use expression index \"%s\" as replica identity" msgstr "ne peut pas utiliser un index par expression « %s » comme identité de réplicat" -#: commands/tablecmds.c:11088 +#: commands/tablecmds.c:11179 #, c-format msgid "cannot use partial index \"%s\" as replica identity" msgstr "ne peut pas utiliser l'index partiel « %s » comme identité de réplicat" -#: commands/tablecmds.c:11094 +#: commands/tablecmds.c:11185 #, c-format msgid "cannot use invalid index \"%s\" as replica identity" msgstr "ne peut pas utiliser l'index invalide « %s » comme identité de réplicat" -#: commands/tablecmds.c:11115 +#: commands/tablecmds.c:11206 #, c-format msgid "index \"%s\" cannot be used as replica identity because column %d is a system column" msgstr "l'index « %s » ne peut pas être utilisé comme identité de réplicat car la colonne %d est une colonne système" -#: commands/tablecmds.c:11122 +#: commands/tablecmds.c:11213 #, c-format msgid "index \"%s\" cannot be used as replica identity because column \"%s\" is nullable" msgstr "l'index « %s » ne peut pas être utilisé comme identité de réplicat car la colonne « %s » peut être NULL" -#: commands/tablecmds.c:11319 +#: commands/tablecmds.c:11416 #, c-format msgid "cannot change logged status of table \"%s\" because it is temporary" msgstr "ne peut pas modifier le statut de journalisation de la table « %s » parce qu'elle est temporaire" -#: commands/tablecmds.c:11378 +#: commands/tablecmds.c:11475 #, c-format msgid "could not change table \"%s\" to logged because it references unlogged table \"%s\"" msgstr "n'a pas pu passer la table « %s » en journalisé car elle référence la table non journalisée « %s »" -#: commands/tablecmds.c:11388 +#: commands/tablecmds.c:11485 #, c-format msgid "could not change table \"%s\" to unlogged because it references logged table \"%s\"" msgstr "n'a pas pu passer la table « %s » en non journalisé car elle référence la table journalisée « %s »" -#: commands/tablecmds.c:11445 +#: commands/tablecmds.c:11542 #, c-format msgid "cannot move an owned sequence into another schema" msgstr "ne peut pas déplacer une séquence OWNED BY dans un autre schéma" -#: commands/tablecmds.c:11550 +#: commands/tablecmds.c:11647 #, c-format msgid "relation \"%s\" already exists in schema \"%s\"" msgstr "la relation « %s » existe déjà dans le schéma « %s »" -#: commands/tablecmds.c:12077 +#: commands/tablecmds.c:12174 #, c-format msgid "\"%s\" is not a composite type" msgstr "« %s » n'est pas un type composite" -#: commands/tablecmds.c:12107 +#: commands/tablecmds.c:12204 #, c-format msgid "\"%s\" is not a table, view, materialized view, sequence, or foreign table" msgstr "« %s » n'est pas une table, une vue, une vue matérialisée, une séquence ou une table distante" @@ -8714,7 +8719,7 @@ msgstr "n'a pas pu configurer les droits du répertoire « %s » : %m" #: commands/tablespace.c:620 #, c-format msgid "directory \"%s\" already in use as a tablespace" -msgstr "répertoire « %s » déjà en cours d'utilisation" +msgstr "répertoire « %s » déjà utilisé comme tablespace" #: commands/tablespace.c:744 commands/tablespace.c:757 commands/tablespace.c:793 commands/tablespace.c:885 #, c-format @@ -8897,7 +8902,7 @@ msgstr "la ligne à mettre à jour était déjà modifiée par une opération d msgid "Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." msgstr "Considérez l'utilisation d'un trigger AFTER au lieu d'un trigger BEFORE pour propager les changements sur les autres lignes." -#: commands/trigger.c:2741 executor/execMain.c:2377 executor/nodeLockRows.c:216 executor/nodeModifyTable.c:213 executor/nodeModifyTable.c:692 executor/nodeModifyTable.c:985 executor/nodeModifyTable.c:1151 +#: commands/trigger.c:2741 executor/execMain.c:2379 executor/nodeLockRows.c:216 executor/nodeModifyTable.c:213 executor/nodeModifyTable.c:692 executor/nodeModifyTable.c:985 executor/nodeModifyTable.c:1151 #, c-format msgid "could not serialize access due to concurrent update" msgstr "n'a pas pu sérialiser un accès à cause d'une mise à jour en parallèle" @@ -9789,54 +9794,54 @@ msgstr "valeur invalide pour l'option « check_option »" msgid "Valid values are \"local\" and \"cascaded\"." msgstr "Les valeurs valides sont entre « local » et « cascaded »." -#: commands/view.c:103 +#: commands/view.c:101 #, c-format msgid "could not determine which collation to use for view column \"%s\"" msgstr "" "n'a pas pu déterminer le collationnement à utiliser pour la colonne « %s »\n" "de la vue" -#: commands/view.c:117 +#: commands/view.c:115 #, c-format msgid "view must have at least one column" msgstr "la vue doit avoir au moins une colonne" -#: commands/view.c:251 commands/view.c:263 +#: commands/view.c:280 commands/view.c:292 #, c-format msgid "cannot drop columns from view" msgstr "ne peut pas supprimer les colonnes d'une vue" -#: commands/view.c:268 +#: commands/view.c:297 #, c-format msgid "cannot change name of view column \"%s\" to \"%s\"" msgstr "ne peut pas modifier le nom de la colonne « %s » de la vue en « %s »" -#: commands/view.c:276 +#: commands/view.c:305 #, c-format msgid "cannot change data type of view column \"%s\" from %s to %s" msgstr "ne peut pas modifier le type de données de la colonne « %s » de la vue de %s à %s" -#: commands/view.c:415 +#: commands/view.c:444 #, c-format msgid "views must not contain SELECT INTO" msgstr "les vues ne peuvent pas contenir SELECT INTO" -#: commands/view.c:428 +#: commands/view.c:457 #, c-format msgid "views must not contain data-modifying statements in WITH" msgstr "les vues ne peuvent pas contenir d'instructions de modifications de données avec WITH" -#: commands/view.c:499 +#: commands/view.c:528 #, c-format msgid "CREATE VIEW specifies more column names than columns" msgstr "CREATE VIEW spécifie plus de noms de colonnes que de colonnes" -#: commands/view.c:507 +#: commands/view.c:536 #, c-format msgid "views cannot be unlogged because they do not have storage" msgstr "les vues ne peuvent pas être non tracées car elles n'ont pas de stockage" -#: commands/view.c:521 +#: commands/view.c:550 #, c-format msgid "view \"%s\" will be a temporary view" msgstr "la vue « %s » sera une vue temporaire" @@ -10016,7 +10021,7 @@ msgstr "ne peut pas verrouiller les lignes dans la vue « %s »" msgid "cannot lock rows in materialized view \"%s\"" msgstr "ne peut pas verrouiller les lignes dans la vue matérialisée « %s »" -#: executor/execMain.c:1192 executor/execMain.c:2611 executor/nodeLockRows.c:132 +#: executor/execMain.c:1192 executor/execMain.c:2613 executor/nodeLockRows.c:132 #, c-format msgid "cannot lock rows in foreign table \"%s\"" msgstr "ne peut pas verrouiller la table distante « %s »" @@ -10026,47 +10031,47 @@ msgstr "ne peut pas verrouiller la table distante « %s »" msgid "cannot lock rows in relation \"%s\"" msgstr "n'a pas pu verrouiller les lignes dans la relation « %s »" -#: executor/execMain.c:1729 +#: executor/execMain.c:1731 #, c-format msgid "null value in column \"%s\" violates not-null constraint" msgstr "une valeur NULL viole la contrainte NOT NULL de la colonne « %s »" -#: executor/execMain.c:1731 executor/execMain.c:1757 executor/execMain.c:1846 +#: executor/execMain.c:1733 executor/execMain.c:1759 executor/execMain.c:1848 #, c-format msgid "Failing row contains %s." msgstr "La ligne en échec contient %s" -#: executor/execMain.c:1755 +#: executor/execMain.c:1757 #, c-format msgid "new row for relation \"%s\" violates check constraint \"%s\"" msgstr "la nouvelle ligne viole la contrainte de vérification « %s » de la relation « %s »" -#: executor/execMain.c:1844 +#: executor/execMain.c:1846 #, c-format msgid "new row violates check option for view \"%s\"" msgstr "la nouvelle ligne viole la contrainte de vérification pour la vue « %s »" -#: executor/execMain.c:1854 +#: executor/execMain.c:1856 #, c-format msgid "new row violates row-level security policy \"%s\" for table \"%s\"" msgstr "la nouvelle ligne viole la politique de sécurité au niveau ligne « %s » pour la table « %s »" -#: executor/execMain.c:1859 +#: executor/execMain.c:1861 #, c-format msgid "new row violates row-level security policy for table \"%s\"" msgstr "la nouvelle ligne viole la politique de sécurité au niveau ligne pour la table « %s »" -#: executor/execMain.c:1866 +#: executor/execMain.c:1868 #, c-format msgid "new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"" msgstr "la nouvelle ligne viole la politique de sécurité au niveau ligne « %s » (expression USING) pour la table « %s »" -#: executor/execMain.c:1871 +#: executor/execMain.c:1873 #, c-format msgid "new row violates row-level security policy (USING expression) for table \"%s\"" msgstr "la nouvelle ligne viole la politique de sécurité au niveau ligne (expression USING) pour la table « %s »" -#: executor/execQual.c:302 executor/execQual.c:339 executor/execQual.c:3230 utils/adt/array_userfuncs.c:484 utils/adt/arrayfuncs.c:260 utils/adt/arrayfuncs.c:558 utils/adt/arrayfuncs.c:1288 utils/adt/arrayfuncs.c:3361 utils/adt/arrayfuncs.c:5241 utils/adt/arrayfuncs.c:5764 +#: executor/execQual.c:302 executor/execQual.c:339 executor/execQual.c:3236 utils/adt/array_userfuncs.c:484 utils/adt/arrayfuncs.c:260 utils/adt/arrayfuncs.c:558 utils/adt/arrayfuncs.c:1288 utils/adt/arrayfuncs.c:3361 utils/adt/arrayfuncs.c:5241 utils/adt/arrayfuncs.c:5758 #, c-format msgid "number of array dimensions (%d) exceeds the maximum allowed (%d)" msgstr "le nombre de dimensions du tableau (%d) dépasse le maximum autorisé (%d)" @@ -10076,12 +10081,12 @@ msgstr "le nombre de dimensions du tableau (%d) dépasse le maximum autorisé (% msgid "array subscript in assignment must not be null" msgstr "l'indice du tableau dans l'affectation ne doit pas être NULL" -#: executor/execQual.c:657 executor/execQual.c:4170 +#: executor/execQual.c:657 executor/execQual.c:4183 #, c-format msgid "attribute %d has wrong type" msgstr "l'attribut %d a un type invalide" -#: executor/execQual.c:658 executor/execQual.c:4171 +#: executor/execQual.c:658 executor/execQual.c:4184 #, c-format msgid "Table has type %s, but query expects %s." msgstr "La table a le type %s alors que la requête attend %s." @@ -10173,59 +10178,59 @@ msgstr "" "l'opérateur ANY/ALL (pour les types array) ne supporte pas les arguments\n" "d'ensemble" -#: executor/execQual.c:3208 +#: executor/execQual.c:3214 #, c-format msgid "cannot merge incompatible arrays" msgstr "ne peut pas fusionner les tableaux incompatibles" -#: executor/execQual.c:3209 +#: executor/execQual.c:3215 #, c-format msgid "Array with element type %s cannot be included in ARRAY construct with element type %s." msgstr "Le tableau avec le type d'élément %s ne peut pas être inclus dans la construction ARRAY avec le type d'élément %s." -#: executor/execQual.c:3250 executor/execQual.c:3277 +#: executor/execQual.c:3256 executor/execQual.c:3283 #, c-format msgid "multidimensional arrays must have array expressions with matching dimensions" msgstr "" "les tableaux multidimensionnels doivent avoir des expressions de tableaux\n" "avec les dimensions correspondantes" -#: executor/execQual.c:3792 +#: executor/execQual.c:3798 #, c-format msgid "NULLIF does not support set arguments" msgstr "NULLIF ne supporte pas les arguments d'ensemble" -#: executor/execQual.c:4040 utils/adt/domains.c:136 +#: executor/execQual.c:4046 utils/adt/domains.c:137 #, c-format msgid "domain %s does not allow null values" msgstr "le domaine %s n'autorise pas les valeurs NULL" -#: executor/execQual.c:4070 utils/adt/domains.c:173 +#: executor/execQual.c:4083 utils/adt/domains.c:179 #, c-format msgid "value for domain %s violates check constraint \"%s\"" msgstr "la valeur pour le domaine %s viole la contrainte de vérification « %s »" -#: executor/execQual.c:4425 +#: executor/execQual.c:4438 #, c-format msgid "WHERE CURRENT OF is not supported for this table type" msgstr "WHERE CURRENT OF n'est pas supporté pour ce type de table" -#: executor/execQual.c:4614 parser/parse_agg.c:758 +#: executor/execQual.c:4627 parser/parse_agg.c:758 #, c-format msgid "window function calls cannot be nested" msgstr "les appels à la fonction window ne peuvent pas être imbriqués" -#: executor/execQual.c:4826 +#: executor/execQual.c:4839 #, c-format msgid "target type is not an array" msgstr "le type cible n'est pas un tableau" -#: executor/execQual.c:4941 +#: executor/execQual.c:4956 #, c-format msgid "ROW() column has type %s instead of type %s" msgstr "une colonne ROW() a le type %s au lieu du type %s" -#: executor/execQual.c:5076 utils/adt/arrayfuncs.c:3803 utils/adt/arrayfuncs.c:6337 utils/adt/rowtypes.c:927 +#: executor/execQual.c:5091 utils/adt/arrayfuncs.c:3803 utils/adt/arrayfuncs.c:6325 utils/adt/rowtypes.c:927 #, c-format msgid "could not identify a comparison function for type %s" msgstr "n'a pas pu identifier une fonction de comparaison pour le type %s" @@ -10245,90 +10250,95 @@ msgstr "Utilisez la commande REFRESH MATERIALIZED VIEW." msgid "could not determine actual type of argument declared %s" msgstr "n'a pas pu déterminer le type actuel de l'argument déclaré %s" +#: executor/functions.c:511 +#, c-format +msgid "cannot COPY to/from client in a SQL function" +msgstr "ne peut pas utiliser COPY TO/FROM dans une fonction SQL" + #. translator: %s is a SQL statement name -#: executor/functions.c:508 +#: executor/functions.c:517 #, c-format msgid "%s is not allowed in a SQL function" msgstr "%s n'est pas autorisé dans une fonction SQL" #. translator: %s is a SQL statement name -#: executor/functions.c:515 executor/spi.c:1364 executor/spi.c:2154 +#: executor/functions.c:524 executor/spi.c:1364 executor/spi.c:2154 #, c-format msgid "%s is not allowed in a non-volatile function" msgstr "%s n'est pas autorisé dans une fonction non volatile" -#: executor/functions.c:641 +#: executor/functions.c:650 #, c-format msgid "could not determine actual result type for function declared to return type %s" msgstr "" "n'a pas pu déterminer le type du résultat actuel pour la fonction déclarant\n" "renvoyer le type %s" -#: executor/functions.c:1406 +#: executor/functions.c:1415 #, c-format msgid "SQL function \"%s\" statement %d" msgstr "fonction SQL « %s », instruction %d" -#: executor/functions.c:1432 +#: executor/functions.c:1441 #, c-format msgid "SQL function \"%s\" during startup" msgstr "fonction SQL « %s » lors du lancement" -#: executor/functions.c:1591 executor/functions.c:1628 executor/functions.c:1640 executor/functions.c:1753 executor/functions.c:1786 executor/functions.c:1816 +#: executor/functions.c:1600 executor/functions.c:1637 executor/functions.c:1649 executor/functions.c:1762 executor/functions.c:1795 executor/functions.c:1825 #, c-format msgid "return type mismatch in function declared to return %s" msgstr "le type de retour ne correspond pas à la fonction déclarant renvoyer %s" -#: executor/functions.c:1593 +#: executor/functions.c:1602 #, c-format msgid "Function's final statement must be SELECT or INSERT/UPDATE/DELETE RETURNING." msgstr "" "L'instruction finale de la fonction doit être un SELECT ou un\n" "INSERT/UPDATE/DELETE RETURNING." -#: executor/functions.c:1630 +#: executor/functions.c:1639 #, c-format msgid "Final statement must return exactly one column." msgstr "L'instruction finale doit renvoyer exactement une colonne." -#: executor/functions.c:1642 +#: executor/functions.c:1651 #, c-format msgid "Actual return type is %s." msgstr "Le code de retour réel est %s." -#: executor/functions.c:1755 +#: executor/functions.c:1764 #, c-format msgid "Final statement returns too many columns." msgstr "L'instruction finale renvoie beaucoup trop de colonnes." -#: executor/functions.c:1788 +#: executor/functions.c:1797 #, c-format msgid "Final statement returns %s instead of %s at column %d." msgstr "L'instruction finale renvoie %s au lieu de %s pour la colonne %d." -#: executor/functions.c:1818 +#: executor/functions.c:1827 #, c-format msgid "Final statement returns too few columns." msgstr "L'instruction finale renvoie trop peu de colonnes." -#: executor/functions.c:1867 +#: executor/functions.c:1876 #, c-format msgid "return type %s is not supported for SQL functions" msgstr "le type de retour %s n'est pas supporté pour les fonctions SQL" -#: executor/nodeAgg.c:3023 +#: executor/nodeAgg.c:3038 #, c-format msgid "combine function for aggregate %u must be declared as STRICT" msgstr "la fonction d'unification pour l'aggrégat %u doit être déclarée comme STRICT" -#: executor/nodeAgg.c:3068 executor/nodeWindowAgg.c:2318 +#: executor/nodeAgg.c:3083 executor/nodeWindowAgg.c:2318 #, c-format msgid "aggregate %u needs to have compatible input type and transition type" msgstr "" "L'agrégat %u a besoin d'avoir un type en entrée compatible avec le type en\n" "transition" -#: executor/nodeAgg.c:3134 parser/parse_agg.c:612 parser/parse_agg.c:642 +#: executor/nodeAgg.c:3149 parser/parse_agg.c:612 parser/parse_agg.c:642 #, c-format msgid "aggregate function calls cannot be nested" msgstr "les appels à la fonction d'agrégat ne peuvent pas être imbriqués" @@ -10476,7 +10486,7 @@ msgstr "ne peut pas ouvrir la requête %s comme curseur" msgid "DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE is not supported" msgstr "DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE n'est pas supporté" -#: executor/spi.c:1339 parser/analyze.c:2363 +#: executor/spi.c:1339 parser/analyze.c:2360 #, c-format msgid "Scrollable cursors must be READ ONLY." msgstr "Les curseurs déplaçables doivent être en lecture seule (READ ONLY)." @@ -10545,7 +10555,7 @@ msgstr "MATCH PARTIAL non implémenté" msgid "duplicate trigger events specified" msgstr "événements de trigger dupliqués spécifiés" -#: gram.y:4902 parser/parse_utilcmd.c:2743 parser/parse_utilcmd.c:2769 +#: gram.y:4902 parser/parse_utilcmd.c:2728 parser/parse_utilcmd.c:2754 #, c-format msgid "constraint declared INITIALLY DEFERRED must be DEFERRABLE" msgstr "la contrainte déclarée INITIALLY DEFERRED doit être DEFERRABLE" @@ -12457,46 +12467,46 @@ msgid "%s cannot be applied to the nullable side of an outer join" msgstr "%s ne peut être appliqué sur le côté possiblement NULL d'une jointure externe" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: optimizer/plan/planner.c:1494 parser/analyze.c:1552 parser/analyze.c:1750 parser/analyze.c:2531 +#: optimizer/plan/planner.c:1480 parser/analyze.c:1549 parser/analyze.c:1747 parser/analyze.c:2528 #, c-format msgid "%s is not allowed with UNION/INTERSECT/EXCEPT" msgstr "%s n'est pas autorisé avec UNION/INTERSECT/EXCEPT" -#: optimizer/plan/planner.c:3823 +#: optimizer/plan/planner.c:3809 #, c-format msgid "could not implement GROUP BY" msgstr "n'a pas pu implanté GROUP BY" -#: optimizer/plan/planner.c:3824 optimizer/plan/planner.c:4217 optimizer/prep/prepunion.c:929 +#: optimizer/plan/planner.c:3810 optimizer/plan/planner.c:4203 optimizer/prep/prepunion.c:929 #, c-format msgid "Some of the datatypes only support hashing, while others only support sorting." msgstr "" "Certains des types de données supportent seulement le hachage,\n" "alors que les autres supportent seulement le tri." -#: optimizer/plan/planner.c:4216 +#: optimizer/plan/planner.c:4202 #, c-format msgid "could not implement DISTINCT" msgstr "n'a pas pu implanté DISTINCT" -#: optimizer/plan/planner.c:4846 +#: optimizer/plan/planner.c:4832 #, c-format msgid "could not implement window PARTITION BY" msgstr "n'a pas pu implanter PARTITION BY de window" -#: optimizer/plan/planner.c:4847 +#: optimizer/plan/planner.c:4833 #, c-format msgid "Window partitioning columns must be of sortable datatypes." msgstr "" "Les colonnes de partitionnement de window doivent être d'un type de données\n" "triables." -#: optimizer/plan/planner.c:4851 +#: optimizer/plan/planner.c:4837 #, c-format msgid "could not implement window ORDER BY" msgstr "n'a pas pu implanter ORDER BY dans le window" -#: optimizer/plan/planner.c:4852 +#: optimizer/plan/planner.c:4838 #, c-format msgid "Window ordering columns must be of sortable datatypes." msgstr "Les colonnes de tri de la window doivent être d'un type de données triable." @@ -12527,32 +12537,32 @@ msgstr "n'a pas pu implanté %s" msgid "SQL function \"%s\" during inlining" msgstr "fonction SQL « %s » durant « inlining »" -#: optimizer/util/plancat.c:113 +#: optimizer/util/plancat.c:114 #, c-format msgid "cannot access temporary or unlogged relations during recovery" msgstr "ne peut pas accéder à des tables temporaires et non tracées lors de la restauration" -#: optimizer/util/plancat.c:610 +#: optimizer/util/plancat.c:611 #, c-format msgid "whole row unique index inference specifications are not supported" msgstr "les spécifications d'inférence d'index unique pour une ligne entière ne sont pas supportées" -#: optimizer/util/plancat.c:627 +#: optimizer/util/plancat.c:628 #, c-format msgid "constraint in ON CONFLICT clause has no associated index" msgstr "la contrainte de la clause ON CONFLICT n'a pas d'index associé" -#: optimizer/util/plancat.c:678 +#: optimizer/util/plancat.c:679 #, c-format msgid "ON CONFLICT DO UPDATE not supported with exclusion constraints" msgstr "ON CONFLICT DO UPDATE non supporté avec les contraintes d'exclusion" -#: optimizer/util/plancat.c:783 +#: optimizer/util/plancat.c:784 #, c-format msgid "there is no unique or exclusion constraint matching the ON CONFLICT specification" msgstr "il n'existe aucune contrainte unique ou contrainte d'exclusion correspondant à la spécification ON CONFLICT" -#: parser/analyze.c:663 parser/analyze.c:1324 +#: parser/analyze.c:663 parser/analyze.c:1321 #, c-format msgid "VALUES lists must all be the same length" msgstr "les listes VALUES doivent toutes être de la même longueur" @@ -12575,181 +12585,181 @@ msgstr "" "de colonnes que celui attendu par INSERT. Auriez-vous utilisé des parenthèses\n" "supplémentaires ?" -#: parser/analyze.c:1145 parser/analyze.c:1525 +#: parser/analyze.c:1142 parser/analyze.c:1522 #, c-format msgid "SELECT ... INTO is not allowed here" msgstr "SELECT ... INTO n'est pas autorisé ici" -#: parser/analyze.c:1338 +#: parser/analyze.c:1335 #, c-format msgid "DEFAULT can only appear in a VALUES list within INSERT" msgstr "DEFAULT peut seulement apparaître dans la liste VALUES comprise dans un INSERT" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:1457 parser/analyze.c:2701 +#: parser/analyze.c:1454 parser/analyze.c:2698 #, c-format msgid "%s cannot be applied to VALUES" msgstr "%s ne peut pas être appliqué à VALUES" -#: parser/analyze.c:1678 +#: parser/analyze.c:1675 #, c-format msgid "invalid UNION/INTERSECT/EXCEPT ORDER BY clause" msgstr "clause UNION/INTERSECT/EXCEPT ORDER BY invalide" -#: parser/analyze.c:1679 +#: parser/analyze.c:1676 #, c-format msgid "Only result column names can be used, not expressions or functions." msgstr "" "Seuls les noms de colonnes résultats peuvent être utilisés, pas les\n" "expressions et les fonctions." -#: parser/analyze.c:1680 +#: parser/analyze.c:1677 #, c-format msgid "Add the expression/function to every SELECT, or move the UNION into a FROM clause." msgstr "Ajouter l'expression/fonction à chaque SELECT, ou déplacer l'UNION dans une clause FROM." -#: parser/analyze.c:1740 +#: parser/analyze.c:1737 #, c-format msgid "INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT" msgstr "INTO est autorisé uniquement sur le premier SELECT d'un UNION/INTERSECT/EXCEPT" -#: parser/analyze.c:1804 +#: parser/analyze.c:1801 #, c-format msgid "UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level" msgstr "" "L'instruction membre UNION/INTERSECT/EXCEPT ne peut pas faire référence à\n" "d'autres relations que celles de la requête de même niveau" -#: parser/analyze.c:1893 +#: parser/analyze.c:1890 #, c-format msgid "each %s query must have the same number of columns" msgstr "chaque requête %s doit avoir le même nombre de colonnes" -#: parser/analyze.c:2286 +#: parser/analyze.c:2283 #, c-format msgid "RETURNING must have at least one column" msgstr "RETURNING doit avoir au moins une colonne" -#: parser/analyze.c:2323 +#: parser/analyze.c:2320 #, c-format msgid "cannot specify both SCROLL and NO SCROLL" msgstr "ne peut pas spécifier à la fois SCROLL et NO SCROLL" -#: parser/analyze.c:2341 +#: parser/analyze.c:2338 #, c-format msgid "DECLARE CURSOR must not contain data-modifying statements in WITH" msgstr "DECLARE CURSOR ne doit pas contenir des instructions de modification de données dans WITH" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2349 +#: parser/analyze.c:2346 #, c-format msgid "DECLARE CURSOR WITH HOLD ... %s is not supported" msgstr "DECLARE CURSOR WITH HOLD ... %s n'est pas supporté" -#: parser/analyze.c:2352 +#: parser/analyze.c:2349 #, c-format msgid "Holdable cursors must be READ ONLY." msgstr "Les curseurs détenables doivent être en lecture seule (READ ONLY)." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2360 +#: parser/analyze.c:2357 #, c-format msgid "DECLARE SCROLL CURSOR ... %s is not supported" msgstr "DECLARE SCROLL CURSOR ... %s n'est pas supporté" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2371 +#: parser/analyze.c:2368 #, c-format msgid "DECLARE INSENSITIVE CURSOR ... %s is not supported" msgstr "DECLARE INSENSITIVE CURSOR ... %s n'est pas supporté" -#: parser/analyze.c:2374 +#: parser/analyze.c:2371 #, c-format msgid "Insensitive cursors must be READ ONLY." msgstr "Les curseurs insensibles doivent être en lecture seule (READ ONLY)." -#: parser/analyze.c:2440 +#: parser/analyze.c:2437 #, c-format msgid "materialized views must not use data-modifying statements in WITH" msgstr "les vues matérialisées ne peuvent pas contenir d'instructions de modifications de données avec WITH" -#: parser/analyze.c:2450 +#: parser/analyze.c:2447 #, c-format msgid "materialized views must not use temporary tables or views" msgstr "les vues matérialisées ne doivent pas utiliser de tables temporaires ou de vues" -#: parser/analyze.c:2460 +#: parser/analyze.c:2457 #, c-format msgid "materialized views may not be defined using bound parameters" msgstr "les vues matérialisées ne peuvent pas être définies en utilisant des paramètres liés" -#: parser/analyze.c:2472 +#: parser/analyze.c:2469 #, c-format msgid "materialized views cannot be UNLOGGED" msgstr "les vues matérialisées ne peuvent pas être UNLOGGED" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2538 +#: parser/analyze.c:2535 #, c-format msgid "%s is not allowed with DISTINCT clause" msgstr "%s n'est pas autorisé avec la clause DISTINCT" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2545 +#: parser/analyze.c:2542 #, c-format msgid "%s is not allowed with GROUP BY clause" msgstr "%s n'est pas autorisé avec la clause GROUP BY" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2552 +#: parser/analyze.c:2549 #, c-format msgid "%s is not allowed with HAVING clause" msgstr "%s n'est pas autorisé avec la clause HAVING" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2559 +#: parser/analyze.c:2556 #, c-format msgid "%s is not allowed with aggregate functions" msgstr "%s n'est pas autorisé avec les fonctions d'agrégat" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2566 +#: parser/analyze.c:2563 #, c-format msgid "%s is not allowed with window functions" msgstr "%s n'est pas autorisé avec les fonctions de fenêtrage" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2573 +#: parser/analyze.c:2570 #, c-format msgid "%s is not allowed with set-returning functions in the target list" msgstr "%s n'est pas autorisé avec les fonctions renvoyant plusieurs lignes dans la liste cible" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2652 +#: parser/analyze.c:2649 #, c-format msgid "%s must specify unqualified relation names" msgstr "%s doit indiquer les noms de relation non qualifiés" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2683 +#: parser/analyze.c:2680 #, c-format msgid "%s cannot be applied to a join" msgstr "%s ne peut pas être appliqué à une jointure" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2692 +#: parser/analyze.c:2689 #, c-format msgid "%s cannot be applied to a function" msgstr "%s ne peut pas être appliqué à une fonction" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2710 +#: parser/analyze.c:2707 #, c-format msgid "%s cannot be applied to a WITH query" msgstr "%s ne peut pas être appliqué à une requête WITH" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2727 +#: parser/analyze.c:2724 #, c-format msgid "relation \"%s\" in %s clause not found in FROM clause" msgstr "relation « %s » dans une clause %s introuvable dans la clause FROM" @@ -13039,7 +13049,7 @@ msgstr "la méthode d'échantillonage %s ne supporte pas REPEATABLE" #: parser/parse_clause.c:940 #, c-format msgid "TABLESAMPLE clause can only be applied to tables and materialized views" -msgstr "la clause TABLESPACE est uniquement applicable pour les tables et les vues matérialisées" +msgstr "la clause TABLESAMPLE est uniquement applicable pour les tables et les vues matérialisées" #: parser/parse_clause.c:1110 #, c-format @@ -13449,7 +13459,7 @@ msgstr "FOR UPDATE/SHARE dans une requête récursive n'est pas implémenté" msgid "recursive reference to query \"%s\" must not appear more than once" msgstr "la référence récursive à la requête « %s » ne doit pas apparaître plus d'une fois" -#: parser/parse_expr.c:390 parser/parse_relation.c:3083 parser/parse_relation.c:3103 +#: parser/parse_expr.c:390 parser/parse_relation.c:3176 parser/parse_relation.c:3196 #, c-format msgid "column %s.%s does not exist" msgstr "la colonne %s.%s n'existe pas" @@ -13474,7 +13484,7 @@ msgstr "notation d'attribut .%s appliqué au type %s, qui n'est pas un type comp msgid "row expansion via \"*\" is not supported here" msgstr "l'expansion de ligne via « * » n'est pas supporté ici" -#: parser/parse_expr.c:770 parser/parse_relation.c:667 parser/parse_relation.c:767 parser/parse_target.c:1120 +#: parser/parse_expr.c:770 parser/parse_relation.c:668 parser/parse_relation.c:768 parser/parse_target.c:1120 #, c-format msgid "column reference \"%s\" is ambiguous" msgstr "la référence à la colonne « %s » est ambigu" @@ -13808,7 +13818,7 @@ msgstr "l'opérateur n'existe pas : %s" msgid "Use an explicit ordering operator or modify the query." msgstr "Utilisez un opérateur explicite de tri ou modifiez la requête." -#: parser/parse_oper.c:226 utils/adt/array_userfuncs.c:794 utils/adt/array_userfuncs.c:932 utils/adt/arrayfuncs.c:3639 utils/adt/arrayfuncs.c:4077 utils/adt/arrayfuncs.c:6051 utils/adt/rowtypes.c:1167 +#: parser/parse_oper.c:226 utils/adt/array_userfuncs.c:794 utils/adt/array_userfuncs.c:933 utils/adt/arrayfuncs.c:3639 utils/adt/arrayfuncs.c:4077 utils/adt/arrayfuncs.c:6039 utils/adt/rowtypes.c:1167 #, c-format msgid "could not identify an equality operator for type %s" msgstr "n'a pas pu identifier un opérateur d'égalité pour le type %s" @@ -13862,124 +13872,124 @@ msgstr "op ANY/ALL (tableau) requiert que l'opérateur ne renvoie pas un ensembl msgid "inconsistent types deduced for parameter $%d" msgstr "types incohérents déduit pour le paramètre $%d" -#: parser/parse_relation.c:174 +#: parser/parse_relation.c:175 #, c-format msgid "table reference \"%s\" is ambiguous" msgstr "la référence à la table « %s » est ambigu" -#: parser/parse_relation.c:218 +#: parser/parse_relation.c:219 #, c-format msgid "table reference %u is ambiguous" msgstr "la référence à la table %u est ambigu" -#: parser/parse_relation.c:397 +#: parser/parse_relation.c:398 #, c-format msgid "table name \"%s\" specified more than once" msgstr "le nom de la table « %s » est spécifié plus d'une fois" -#: parser/parse_relation.c:424 parser/parse_relation.c:3023 +#: parser/parse_relation.c:425 parser/parse_relation.c:3116 #, c-format msgid "invalid reference to FROM-clause entry for table \"%s\"" msgstr "référence invalide d'une entrée de la clause FROM pour la table « %s »" -#: parser/parse_relation.c:427 parser/parse_relation.c:3028 +#: parser/parse_relation.c:428 parser/parse_relation.c:3121 #, c-format msgid "There is an entry for table \"%s\", but it cannot be referenced from this part of the query." msgstr "" "Il existe une entrée pour la table « %s » mais elle ne peut pas être\n" "référencée de cette partie de la requête." -#: parser/parse_relation.c:429 +#: parser/parse_relation.c:430 #, c-format msgid "The combining JOIN type must be INNER or LEFT for a LATERAL reference." msgstr "Le type JOIN combiné doit être INNER ou LEFT pour une référence LATERAL." -#: parser/parse_relation.c:705 +#: parser/parse_relation.c:706 #, c-format msgid "system column \"%s\" reference in check constraint is invalid" msgstr "la référence de la colonne système « %s » dans la contrainte CHECK est invalide" -#: parser/parse_relation.c:1065 parser/parse_relation.c:1345 parser/parse_relation.c:1847 +#: parser/parse_relation.c:1066 parser/parse_relation.c:1346 parser/parse_relation.c:1848 #, c-format msgid "table \"%s\" has %d columns available but %d columns specified" msgstr "la table « %s » a %d colonnes disponibles mais %d colonnes spécifiées" -#: parser/parse_relation.c:1152 +#: parser/parse_relation.c:1153 #, c-format msgid "There is a WITH item named \"%s\", but it cannot be referenced from this part of the query." msgstr "" "Il existe un élément WITH nommé « %s » mais il ne peut pas être\n" "référencée de cette partie de la requête." -#: parser/parse_relation.c:1154 +#: parser/parse_relation.c:1155 #, c-format msgid "Use WITH RECURSIVE, or re-order the WITH items to remove forward references." msgstr "" "Utilisez WITH RECURSIVE ou ré-ordonnez les éléments WITH pour supprimer\n" "les références en avant." -#: parser/parse_relation.c:1465 +#: parser/parse_relation.c:1466 #, c-format msgid "a column definition list is only allowed for functions returning \"record\"" msgstr "" "une liste de définition de colonnes est uniquement autorisée pour les fonctions\n" "renvoyant un « record »" -#: parser/parse_relation.c:1474 +#: parser/parse_relation.c:1475 #, c-format msgid "a column definition list is required for functions returning \"record\"" msgstr "" "une liste de définition de colonnes est requise pour les fonctions renvoyant\n" "un « record »" -#: parser/parse_relation.c:1553 +#: parser/parse_relation.c:1554 #, c-format msgid "function \"%s\" in FROM has unsupported return type %s" msgstr "la fonction « %s » dans la clause FROM a un type de retour %s non supporté" -#: parser/parse_relation.c:1675 +#: parser/parse_relation.c:1676 #, c-format msgid "VALUES lists \"%s\" have %d columns available but %d columns specified" msgstr "" "les listes « %s » de VALUES ont %d colonnes disponibles mais %d colonnes\n" "spécifiées" -#: parser/parse_relation.c:1730 +#: parser/parse_relation.c:1731 #, c-format msgid "joins can have at most %d columns" msgstr "les jointures peuvent avoir au plus %d colonnes" -#: parser/parse_relation.c:1820 +#: parser/parse_relation.c:1821 #, c-format msgid "WITH query \"%s\" does not have a RETURNING clause" msgstr "La requête WITH « %s » n'a pas de clause RETURNING" -#: parser/parse_relation.c:2652 parser/parse_relation.c:2807 +#: parser/parse_relation.c:2738 parser/parse_relation.c:2900 #, c-format msgid "column %d of relation \"%s\" does not exist" msgstr "la colonne %d de la relation « %s » n'existe pas" -#: parser/parse_relation.c:3026 +#: parser/parse_relation.c:3119 #, c-format msgid "Perhaps you meant to reference the table alias \"%s\"." msgstr "Peut-être que vous souhaitiez référencer l'alias de la table « %s »." -#: parser/parse_relation.c:3034 +#: parser/parse_relation.c:3127 #, c-format msgid "missing FROM-clause entry for table \"%s\"" msgstr "entrée manquante de la clause FROM pour la table « %s »" -#: parser/parse_relation.c:3086 +#: parser/parse_relation.c:3179 #, c-format msgid "Perhaps you meant to reference the column \"%s.%s\"." msgstr "Peut-être que vous souhaitiez référencer la colonne « %s.%s »." -#: parser/parse_relation.c:3088 +#: parser/parse_relation.c:3181 #, c-format msgid "There is a column named \"%s\" in table \"%s\", but it cannot be referenced from this part of the query." msgstr "Il existe une colonne nommée « %s » pour la table « %s » mais elle ne peut pas être référencée dans cette partie de la requête." -#: parser/parse_relation.c:3105 +#: parser/parse_relation.c:3198 #, c-format msgid "Perhaps you meant to reference the column \"%s.%s\" or the column \"%s.%s\"." msgstr "Peut-être que vous souhaitiez référencer la colonne « %s.%s » ou la colonne « %s.%s »." @@ -14070,225 +14080,225 @@ msgstr "les modificateurs de type doivent être des constantes ou des identifian msgid "invalid type name \"%s\"" msgstr "nom de type « %s » invalide" -#: parser/parse_utilcmd.c:399 +#: parser/parse_utilcmd.c:384 #, c-format msgid "array of serial is not implemented" msgstr "le tableau de type serial n'est pas implanté" -#: parser/parse_utilcmd.c:447 +#: parser/parse_utilcmd.c:432 #, c-format msgid "%s will create implicit sequence \"%s\" for serial column \"%s.%s\"" msgstr "%s créera des séquences implicites « %s » pour la colonne serial « %s.%s »" -#: parser/parse_utilcmd.c:541 parser/parse_utilcmd.c:553 +#: parser/parse_utilcmd.c:526 parser/parse_utilcmd.c:538 #, c-format msgid "conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"" msgstr "déclarations NULL/NOT NULL en conflit pour la colonne « %s » de la table « %s »" -#: parser/parse_utilcmd.c:565 +#: parser/parse_utilcmd.c:550 #, c-format msgid "multiple default values specified for column \"%s\" of table \"%s\"" msgstr "" "plusieurs valeurs par défaut sont spécifiées pour la colonne « %s » de la table\n" "« %s »" -#: parser/parse_utilcmd.c:582 parser/parse_utilcmd.c:673 +#: parser/parse_utilcmd.c:567 parser/parse_utilcmd.c:658 #, c-format msgid "primary key constraints are not supported on foreign tables" msgstr "les clés primaires ne sont pas supportées par les tables distantes" -#: parser/parse_utilcmd.c:591 parser/parse_utilcmd.c:683 +#: parser/parse_utilcmd.c:576 parser/parse_utilcmd.c:668 #, c-format msgid "unique constraints are not supported on foreign tables" msgstr "les contraintes uniques ne sont pas supportées par les tables distantes" -#: parser/parse_utilcmd.c:608 parser/parse_utilcmd.c:707 +#: parser/parse_utilcmd.c:593 parser/parse_utilcmd.c:692 #, c-format msgid "foreign key constraints are not supported on foreign tables" msgstr "les clés étrangères ne sont pas supportées par les tables distantes" -#: parser/parse_utilcmd.c:693 +#: parser/parse_utilcmd.c:678 #, c-format msgid "exclusion constraints are not supported on foreign tables" msgstr "les contraintes d'exclusion ne sont pas supportées par les tables distantes" -#: parser/parse_utilcmd.c:757 +#: parser/parse_utilcmd.c:742 #, c-format msgid "LIKE is not supported for creating foreign tables" msgstr "LIKE n'est pas supporté pour la création de tables distantes" -#: parser/parse_utilcmd.c:1290 parser/parse_utilcmd.c:1366 +#: parser/parse_utilcmd.c:1275 parser/parse_utilcmd.c:1351 #, c-format msgid "Index \"%s\" contains a whole-row table reference." msgstr "l'index « %s » contient une référence de table de ligne complète" -#: parser/parse_utilcmd.c:1636 +#: parser/parse_utilcmd.c:1621 #, c-format msgid "cannot use an existing index in CREATE TABLE" msgstr "ne peut pas utiliser un index existant dans CREATE TABLE" -#: parser/parse_utilcmd.c:1656 +#: parser/parse_utilcmd.c:1641 #, c-format msgid "index \"%s\" is already associated with a constraint" msgstr "l'index « %s » est déjà associé à une contrainte" -#: parser/parse_utilcmd.c:1664 +#: parser/parse_utilcmd.c:1649 #, c-format msgid "index \"%s\" does not belong to table \"%s\"" msgstr "l'index « %s » n'appartient pas à la table « %s »" -#: parser/parse_utilcmd.c:1671 +#: parser/parse_utilcmd.c:1656 #, c-format msgid "index \"%s\" is not valid" msgstr "l'index « %s » n'est pas valide" -#: parser/parse_utilcmd.c:1677 +#: parser/parse_utilcmd.c:1662 #, c-format msgid "\"%s\" is not a unique index" msgstr "« %s » n'est pas un index unique" -#: parser/parse_utilcmd.c:1678 parser/parse_utilcmd.c:1685 parser/parse_utilcmd.c:1692 parser/parse_utilcmd.c:1762 +#: parser/parse_utilcmd.c:1663 parser/parse_utilcmd.c:1670 parser/parse_utilcmd.c:1677 parser/parse_utilcmd.c:1747 #, c-format msgid "Cannot create a primary key or unique constraint using such an index." msgstr "Ne peut pas créer une clé primaire ou une contrainte unique avec cet index." -#: parser/parse_utilcmd.c:1684 +#: parser/parse_utilcmd.c:1669 #, c-format msgid "index \"%s\" contains expressions" msgstr "l'index « %s » contient des expressions" -#: parser/parse_utilcmd.c:1691 +#: parser/parse_utilcmd.c:1676 #, c-format msgid "\"%s\" is a partial index" msgstr "« %s » est un index partiel" -#: parser/parse_utilcmd.c:1703 +#: parser/parse_utilcmd.c:1688 #, c-format msgid "\"%s\" is a deferrable index" msgstr "« %s » est un index déferrable" -#: parser/parse_utilcmd.c:1704 +#: parser/parse_utilcmd.c:1689 #, c-format msgid "Cannot create a non-deferrable constraint using a deferrable index." msgstr "Ne peut pas créer une contrainte non-déferrable utilisant un index déferrable." -#: parser/parse_utilcmd.c:1761 +#: parser/parse_utilcmd.c:1746 #, c-format msgid "index \"%s\" does not have default sorting behavior" msgstr "l'index « %s » n'a pas de comportement de tri par défaut" -#: parser/parse_utilcmd.c:1908 +#: parser/parse_utilcmd.c:1893 #, c-format msgid "column \"%s\" appears twice in primary key constraint" msgstr "la colonne « %s » apparaît deux fois dans la contrainte de la clé primaire" -#: parser/parse_utilcmd.c:1914 +#: parser/parse_utilcmd.c:1899 #, c-format msgid "column \"%s\" appears twice in unique constraint" msgstr "la colonne « %s » apparaît deux fois sur une contrainte unique" -#: parser/parse_utilcmd.c:2118 +#: parser/parse_utilcmd.c:2103 #, c-format msgid "index expression cannot return a set" msgstr "l'expression de l'index ne peut pas renvoyer un ensemble" -#: parser/parse_utilcmd.c:2129 +#: parser/parse_utilcmd.c:2114 #, c-format msgid "index expressions and predicates can refer only to the table being indexed" msgstr "les expressions et prédicats d'index peuvent seulement faire référence à la table en cours d'indexage" -#: parser/parse_utilcmd.c:2175 +#: parser/parse_utilcmd.c:2160 #, c-format msgid "rules on materialized views are not supported" msgstr "les règles ne sont pas supportés sur les vues matérialisées" -#: parser/parse_utilcmd.c:2236 +#: parser/parse_utilcmd.c:2221 #, c-format msgid "rule WHERE condition cannot contain references to other relations" msgstr "" "la condition WHERE d'une règle ne devrait pas contenir de références à d'autres\n" "relations" -#: parser/parse_utilcmd.c:2308 +#: parser/parse_utilcmd.c:2293 #, c-format msgid "rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE actions" msgstr "" "les règles avec des conditions WHERE ne peuvent contenir que des actions\n" "SELECT, INSERT, UPDATE ou DELETE " -#: parser/parse_utilcmd.c:2326 parser/parse_utilcmd.c:2425 rewrite/rewriteHandler.c:485 rewrite/rewriteManip.c:1015 +#: parser/parse_utilcmd.c:2311 parser/parse_utilcmd.c:2410 rewrite/rewriteHandler.c:485 rewrite/rewriteManip.c:1015 #, c-format msgid "conditional UNION/INTERSECT/EXCEPT statements are not implemented" msgstr "" "les instructions conditionnelles UNION/INTERSECT/EXCEPT ne sont pas\n" "implémentées" -#: parser/parse_utilcmd.c:2344 +#: parser/parse_utilcmd.c:2329 #, c-format msgid "ON SELECT rule cannot use OLD" msgstr "la règle ON SELECT ne peut pas utiliser OLD" -#: parser/parse_utilcmd.c:2348 +#: parser/parse_utilcmd.c:2333 #, c-format msgid "ON SELECT rule cannot use NEW" msgstr "la règle ON SELECT ne peut pas utiliser NEW" -#: parser/parse_utilcmd.c:2357 +#: parser/parse_utilcmd.c:2342 #, c-format msgid "ON INSERT rule cannot use OLD" msgstr "la règle ON INSERT ne peut pas utiliser OLD" -#: parser/parse_utilcmd.c:2363 +#: parser/parse_utilcmd.c:2348 #, c-format msgid "ON DELETE rule cannot use NEW" msgstr "la règle ON INSERT ne peut pas utiliser NEW" -#: parser/parse_utilcmd.c:2391 +#: parser/parse_utilcmd.c:2376 #, c-format msgid "cannot refer to OLD within WITH query" msgstr "ne peut référencer OLD dans une requête WITH" -#: parser/parse_utilcmd.c:2398 +#: parser/parse_utilcmd.c:2383 #, c-format msgid "cannot refer to NEW within WITH query" msgstr "ne peut référencer NEW dans une requête WITH" -#: parser/parse_utilcmd.c:2601 +#: parser/parse_utilcmd.c:2586 #, c-format msgid "transform expression must not return a set" msgstr "l'expression de transformation ne doit pas renvoyer un ensemble" -#: parser/parse_utilcmd.c:2715 +#: parser/parse_utilcmd.c:2700 #, c-format msgid "misplaced DEFERRABLE clause" msgstr "clause DEFERRABLE mal placée" -#: parser/parse_utilcmd.c:2720 parser/parse_utilcmd.c:2735 +#: parser/parse_utilcmd.c:2705 parser/parse_utilcmd.c:2720 #, c-format msgid "multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed" msgstr "clauses DEFERRABLE/NOT DEFERRABLE multiples non autorisées" -#: parser/parse_utilcmd.c:2730 +#: parser/parse_utilcmd.c:2715 #, c-format msgid "misplaced NOT DEFERRABLE clause" msgstr "clause NOT DEFERRABLE mal placée" -#: parser/parse_utilcmd.c:2751 +#: parser/parse_utilcmd.c:2736 #, c-format msgid "misplaced INITIALLY DEFERRED clause" msgstr "clause INITIALLY DEFERRED mal placée" -#: parser/parse_utilcmd.c:2756 parser/parse_utilcmd.c:2782 +#: parser/parse_utilcmd.c:2741 parser/parse_utilcmd.c:2767 #, c-format msgid "multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed" msgstr "clauses INITIALLY IMMEDIATE/DEFERRED multiples non autorisées" -#: parser/parse_utilcmd.c:2777 +#: parser/parse_utilcmd.c:2762 #, c-format msgid "misplaced INITIALLY IMMEDIATE clause" msgstr "clause INITIALLY IMMEDIATE mal placée" -#: parser/parse_utilcmd.c:2968 +#: parser/parse_utilcmd.c:2953 #, c-format msgid "CREATE specifies a schema (%s) different from the one being created (%s)" msgstr "CREATE spécifie un schéma (%s) différent de celui tout juste créé (%s)" @@ -14512,36 +14522,36 @@ msgstr "n'a pas pu exécuter le processus autovacuum worker : %m" msgid "autovacuum: processing database \"%s\"" msgstr "autovacuum : traitement de la base de données « %s »" -#: postmaster/autovacuum.c:2050 +#: postmaster/autovacuum.c:2052 #, c-format msgid "autovacuum: dropping orphan temp table \"%s\".\"%s\" in database \"%s\"" msgstr "" "autovacuum : suppression de la table temporaire orpheline « %s.%s » dans la\n" "base de données « %s »" -#: postmaster/autovacuum.c:2062 +#: postmaster/autovacuum.c:2064 #, c-format msgid "autovacuum: found orphan temp table \"%s\".\"%s\" in database \"%s\"" msgstr "" "autovacuum : a trouvé la table temporaire orpheline « %s.%s » dans la base de\n" "données « %s »" -#: postmaster/autovacuum.c:2344 +#: postmaster/autovacuum.c:2347 #, c-format msgid "automatic vacuum of table \"%s.%s.%s\"" msgstr "VACUUM automatique de la table « %s.%s.%s »" -#: postmaster/autovacuum.c:2347 +#: postmaster/autovacuum.c:2350 #, c-format msgid "automatic analyze of table \"%s.%s.%s\"" msgstr "ANALYZE automatique de la table « %s.%s.%s »" -#: postmaster/autovacuum.c:2877 +#: postmaster/autovacuum.c:2899 #, c-format msgid "autovacuum not started because of misconfiguration" msgstr "autovacuum non exécuté à cause d'une mauvaise configuration" -#: postmaster/autovacuum.c:2878 +#: postmaster/autovacuum.c:2900 #, c-format msgid "Enable the \"track_counts\" option." msgstr "Activez l'option « track_counts »." @@ -15612,7 +15622,7 @@ msgstr "Attendait 1 ligne avec 2 champs, a obtenu %d lignes avec %d champs." msgid "invalid socket: %s" msgstr "socket invalide : %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:426 storage/ipc/latch.c:1277 +#: replication/libpqwalreceiver/libpqwalreceiver.c:426 storage/ipc/latch.c:1280 #, c-format msgid "select() failed: %m" msgstr "échec de select() : %m" @@ -16003,6 +16013,11 @@ msgstr "le serveur « %s » en standby est maintenant un serveur standby synchro msgid "synchronous_standby_names parser failed" msgstr "l'analyseur du paramètre synchronous_standby_names a échoué" +#: replication/syncrep.c:927 +#, c-format +msgid "number of synchronous standbys (%d) must be greater than zero" +msgstr "le nombre de standbys synchrones (%d) doit être supérieur à zéro" + #: replication/walreceiver.c:173 #, c-format msgid "terminating walreceiver process due to administrator command" @@ -16569,7 +16584,7 @@ msgstr "" msgid "invalid Unicode escape character" msgstr "chaîne d'échappement Unicode invalide" -#: scan.l:605 scan.l:613 scan.l:621 scan.l:622 scan.l:623 scan.l:1337 scan.l:1364 scan.l:1368 scan.l:1406 scan.l:1410 scan.l:1432 +#: scan.l:605 scan.l:613 scan.l:621 scan.l:622 scan.l:623 scan.l:1337 scan.l:1364 scan.l:1368 scan.l:1406 scan.l:1410 scan.l:1432 scan.l:1442 msgid "invalid Unicode surrogate pair" msgstr "paire surrogate Unicode invalide" @@ -16634,34 +16649,34 @@ msgstr "" msgid "invalid Unicode escape value" msgstr "valeur d'échappement Unicode invalide" -#: scan.l:1481 +#: scan.l:1488 #, c-format msgid "nonstandard use of \\' in a string literal" msgstr "utilisation non standard de \\' dans une chaîne littérale" -#: scan.l:1482 +#: scan.l:1489 #, c-format msgid "Use '' to write quotes in strings, or use the escape string syntax (E'...')." msgstr "" "Utilisez '' pour écrire des guillemets dans une chaîne ou utilisez la syntaxe de\n" "chaîne d'échappement (E'...')." -#: scan.l:1491 +#: scan.l:1498 #, c-format msgid "nonstandard use of \\\\ in a string literal" msgstr "utilisation non standard de \\\\ dans une chaîne littérale" -#: scan.l:1492 +#: scan.l:1499 #, c-format msgid "Use the escape string syntax for backslashes, e.g., E'\\\\'." msgstr "Utilisez la syntaxe de chaîne d'échappement pour les antislashs, c'est-à-dire E'\\\\'." -#: scan.l:1506 +#: scan.l:1513 #, c-format msgid "nonstandard use of escape in a string literal" msgstr "utilisation non standard d'un échappement dans une chaîne littérale" -#: scan.l:1507 +#: scan.l:1514 #, c-format msgid "Use the escape string syntax for escapes, e.g., E'\\r\\n'." msgstr "" @@ -16887,17 +16902,17 @@ msgstr "n'a pas pu créer le segment de mémoire partagée « %s » : %m" msgid "could not duplicate handle for \"%s\": %m" msgstr "n'a pas pu dupliquer le lien pour « %s » : %m" -#: storage/ipc/latch.c:775 +#: storage/ipc/latch.c:778 #, c-format msgid "epoll_ctl() failed: %m" msgstr "échec de epoll_ctl() : %m" -#: storage/ipc/latch.c:999 +#: storage/ipc/latch.c:1002 #, c-format msgid "epoll_wait() failed: %m" msgstr "échec de epoll_wait() : %m" -#: storage/ipc/latch.c:1119 +#: storage/ipc/latch.c:1122 #, c-format msgid "poll() failed: %m" msgstr "échec de poll() : %m" @@ -16927,12 +16942,12 @@ msgstr "La taille de l'entrée ShmemIndex est mauvaise pour la structure de donn msgid "requested shared memory size overflows size_t" msgstr "la taille de la mémoire partagée demandée dépasse size_t" -#: storage/ipc/standby.c:528 tcop/postgres.c:2976 +#: storage/ipc/standby.c:530 tcop/postgres.c:2976 #, c-format msgid "canceling statement due to conflict with recovery" msgstr "annulation de la requête à cause d'un conflit avec la restauration" -#: storage/ipc/standby.c:529 tcop/postgres.c:2263 +#: storage/ipc/standby.c:531 tcop/postgres.c:2263 #, c-format msgid "User transaction caused buffer deadlock with recovery." msgstr "La transaction de l'utilisateur causait un verrou mortel lors de la restauration." @@ -17181,46 +17196,46 @@ msgstr "" msgid "The transaction might succeed if retried." msgstr "La transaction pourrait réussir après une nouvelle tentative." -#: storage/lmgr/proc.c:1263 +#: storage/lmgr/proc.c:1265 #, c-format msgid "Process %d waits for %s on %s." msgstr "Le processus %d attend %s sur %s." -#: storage/lmgr/proc.c:1274 +#: storage/lmgr/proc.c:1276 #, c-format msgid "sending cancel to blocking autovacuum PID %d" msgstr "envoi de l'annulation pour bloquer le PID %d de l'autovacuum" -#: storage/lmgr/proc.c:1292 utils/adt/misc.c:270 +#: storage/lmgr/proc.c:1294 utils/adt/misc.c:270 #, c-format msgid "could not send signal to process %d: %m" msgstr "n'a pas pu envoyer le signal au processus %d : %m" -#: storage/lmgr/proc.c:1394 +#: storage/lmgr/proc.c:1396 #, c-format msgid "process %d avoided deadlock for %s on %s by rearranging queue order after %ld.%03d ms" msgstr "" "le processus %d a évité un verrou mortel pour %s sur %s en modifiant l'ordre\n" "de la queue après %ld.%03d ms" -#: storage/lmgr/proc.c:1409 +#: storage/lmgr/proc.c:1411 #, c-format msgid "process %d detected deadlock while waiting for %s on %s after %ld.%03d ms" msgstr "" "le processus %d a détecté un verrou mortel alors qu'il était en attente de\n" "%s sur %s après %ld.%03d ms" -#: storage/lmgr/proc.c:1418 +#: storage/lmgr/proc.c:1420 #, c-format msgid "process %d still waiting for %s on %s after %ld.%03d ms" msgstr "le processus %d est toujours en attente de %s sur %s après %ld.%03d ms" -#: storage/lmgr/proc.c:1425 +#: storage/lmgr/proc.c:1427 #, c-format msgid "process %d acquired %s on %s after %ld.%03d ms" msgstr "le processus %d a acquis %s sur %s après %ld.%03d ms" -#: storage/lmgr/proc.c:1441 +#: storage/lmgr/proc.c:1443 #, c-format msgid "process %d failed to acquire %s on %s after %ld.%03d ms" msgstr "le processus %d a échoué pour l'acquisition de %s sur %s après %ld.%03d ms" @@ -17901,7 +17916,7 @@ msgstr "nombre d'alias de vecteur de drapeau invalide" msgid "affix file contains both old-style and new-style commands" msgstr "le fichier d'affixes contient des commandes ancien et nouveau style" -#: tsearch/to_tsany.c:170 utils/adt/tsvector.c:270 utils/adt/tsvector_op.c:1132 +#: tsearch/to_tsany.c:170 utils/adt/tsvector.c:270 utils/adt/tsvector_op.c:1133 #, c-format msgid "string is too long for tsvector (%d bytes, max %d bytes)" msgstr "la chaîne est trop longue (%d octets, max %d octets)" @@ -18076,7 +18091,7 @@ msgstr "la fonction « %s » n'existe pas" msgid "must be member of role \"%s\"" msgstr "doit être un membre du rôle « %s »" -#: utils/adt/array_expanded.c:274 utils/adt/arrayfuncs.c:931 utils/adt/arrayfuncs.c:1519 utils/adt/arrayfuncs.c:3251 utils/adt/arrayfuncs.c:3389 utils/adt/arrayfuncs.c:5860 utils/adt/arrayfuncs.c:6171 utils/adt/arrayutils.c:93 utils/adt/arrayutils.c:102 utils/adt/arrayutils.c:109 +#: utils/adt/array_expanded.c:274 utils/adt/arrayfuncs.c:931 utils/adt/arrayfuncs.c:1519 utils/adt/arrayfuncs.c:3251 utils/adt/arrayfuncs.c:3389 utils/adt/arrayfuncs.c:5848 utils/adt/arrayfuncs.c:6159 utils/adt/arrayutils.c:93 utils/adt/arrayutils.c:102 utils/adt/arrayutils.c:109 #, c-format msgid "array size exceeds the maximum allowed (%d)" msgstr "la taille du tableau dépasse le maximum permis (%d)" @@ -18135,12 +18150,12 @@ msgstr "" "Les tableaux de dimensions différentes ne sont pas compatibles pour\n" "une concaténation." -#: utils/adt/array_userfuncs.c:480 utils/adt/arrayfuncs.c:1284 utils/adt/arrayfuncs.c:3357 utils/adt/arrayfuncs.c:5760 +#: utils/adt/array_userfuncs.c:480 utils/adt/arrayfuncs.c:1284 utils/adt/arrayfuncs.c:3357 utils/adt/arrayfuncs.c:5754 #, c-format msgid "invalid number of dimensions: %d" msgstr "nombre de dimensions invalides : %d" -#: utils/adt/array_userfuncs.c:737 utils/adt/array_userfuncs.c:888 +#: utils/adt/array_userfuncs.c:737 utils/adt/array_userfuncs.c:889 #, c-format msgid "searching for elements in multidimensional arrays is not supported" msgstr "la recherche d'éléments dans des tableaux multidimensionnels n'est pas supportée" @@ -18255,7 +18270,7 @@ msgstr "aucune fonction de sortie binaire disponible pour le type %s" msgid "slices of fixed-length arrays not implemented" msgstr "les morceaux des tableaux à longueur fixe ne sont pas implémentés" -#: utils/adt/arrayfuncs.c:2230 utils/adt/arrayfuncs.c:2252 utils/adt/arrayfuncs.c:2301 utils/adt/arrayfuncs.c:2537 utils/adt/arrayfuncs.c:2848 utils/adt/arrayfuncs.c:5740 utils/adt/arrayfuncs.c:5772 utils/adt/arrayfuncs.c:5789 utils/adt/json.c:2290 utils/adt/json.c:2365 utils/adt/jsonb.c:1369 utils/adt/jsonb.c:1455 utils/adt/jsonfuncs.c:3529 utils/adt/jsonfuncs.c:3574 utils/adt/jsonfuncs.c:3621 +#: utils/adt/arrayfuncs.c:2230 utils/adt/arrayfuncs.c:2252 utils/adt/arrayfuncs.c:2301 utils/adt/arrayfuncs.c:2537 utils/adt/arrayfuncs.c:2848 utils/adt/arrayfuncs.c:5740 utils/adt/arrayfuncs.c:5766 utils/adt/arrayfuncs.c:5777 utils/adt/json.c:2290 utils/adt/json.c:2365 utils/adt/jsonb.c:1369 utils/adt/jsonb.c:1455 utils/adt/jsonfuncs.c:3529 utils/adt/jsonfuncs.c:3574 utils/adt/jsonfuncs.c:3621 #, c-format msgid "wrong number of array subscripts" msgstr "mauvais nombre d'indices du tableau" @@ -18332,42 +18347,32 @@ msgstr "ne peut pas accumuler des tableaux de dimensions différentes" msgid "dimension array or low bound array cannot be null" msgstr "la dimension ou la limite basse du tableau ne peut pas être NULL" -#: utils/adt/arrayfuncs.c:5741 utils/adt/arrayfuncs.c:5773 +#: utils/adt/arrayfuncs.c:5741 utils/adt/arrayfuncs.c:5767 #, c-format msgid "Dimension array must be one dimensional." msgstr "le tableau doit avoir une seule dimension" -#: utils/adt/arrayfuncs.c:5746 utils/adt/arrayfuncs.c:5778 -#, c-format -msgid "wrong range of array subscripts" -msgstr "mauvais échelle des indices du tableau" - -#: utils/adt/arrayfuncs.c:5747 utils/adt/arrayfuncs.c:5779 -#, c-format -msgid "Lower bound of dimension array must be one." -msgstr "La limite inférieure du tableau doit valoir un." - -#: utils/adt/arrayfuncs.c:5752 utils/adt/arrayfuncs.c:5784 +#: utils/adt/arrayfuncs.c:5746 utils/adt/arrayfuncs.c:5772 #, c-format msgid "dimension values cannot be null" msgstr "les valeurs de dimension ne peuvent pas être NULL" -#: utils/adt/arrayfuncs.c:5790 +#: utils/adt/arrayfuncs.c:5778 #, c-format msgid "Low bound array has different size than dimensions array." msgstr "La limite basse du tableau a une taille différentes des dimensions du tableau." -#: utils/adt/arrayfuncs.c:6036 +#: utils/adt/arrayfuncs.c:6024 #, c-format msgid "removing elements from multidimensional arrays is not supported" msgstr "la suppression d'éléments de tableaux multidimensionnels n'est pas supportée" -#: utils/adt/arrayfuncs.c:6313 +#: utils/adt/arrayfuncs.c:6301 #, c-format msgid "thresholds must be one-dimensional array" msgstr "les limites doivent être un tableau à une dimension" -#: utils/adt/arrayfuncs.c:6318 +#: utils/adt/arrayfuncs.c:6306 #, c-format msgid "thresholds array must not contain NULLs" msgstr "le tableau de limites ne doit pas contenir de valeurs NULL" @@ -18403,7 +18408,7 @@ msgid "invalid input syntax for type money: \"%s\"" msgstr "syntaxe en entrée invalide pour le type money : « %s »" #: utils/adt/cash.c:607 utils/adt/cash.c:657 utils/adt/cash.c:708 utils/adt/cash.c:757 utils/adt/cash.c:809 utils/adt/cash.c:859 utils/adt/float.c:855 utils/adt/float.c:919 utils/adt/float.c:3315 utils/adt/float.c:3378 utils/adt/geo_ops.c:4093 utils/adt/int.c:719 utils/adt/int.c:861 utils/adt/int.c:969 utils/adt/int.c:1058 utils/adt/int.c:1097 utils/adt/int.c:1125 utils/adt/int8.c:597 utils/adt/int8.c:657 utils/adt/int8.c:897 -#: utils/adt/int8.c:1005 utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6818 utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 utils/adt/timestamp.c:3446 +#: utils/adt/int8.c:1005 utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6818 utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 utils/adt/timestamp.c:3499 #, c-format msgid "division by zero" msgstr "division par zéro" @@ -18464,9 +18469,9 @@ msgid "date out of range for timestamp" msgstr "date en dehors des limites pour un timestamp" #: utils/adt/date.c:1022 utils/adt/date.c:1068 utils/adt/date.c:1678 utils/adt/date.c:1714 utils/adt/date.c:1748 utils/adt/date.c:2592 utils/adt/datetime.c:1759 utils/adt/formatting.c:3404 utils/adt/formatting.c:3436 utils/adt/formatting.c:3504 utils/adt/json.c:1534 utils/adt/json.c:1556 utils/adt/jsonb.c:823 utils/adt/jsonb.c:847 utils/adt/nabstime.c:455 utils/adt/nabstime.c:498 utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 -#: utils/adt/timestamp.c:224 utils/adt/timestamp.c:268 utils/adt/timestamp.c:726 utils/adt/timestamp.c:735 utils/adt/timestamp.c:820 utils/adt/timestamp.c:860 utils/adt/timestamp.c:3021 utils/adt/timestamp.c:3042 utils/adt/timestamp.c:3055 utils/adt/timestamp.c:3064 utils/adt/timestamp.c:3072 utils/adt/timestamp.c:3127 utils/adt/timestamp.c:3150 utils/adt/timestamp.c:3163 utils/adt/timestamp.c:3174 utils/adt/timestamp.c:3182 -#: utils/adt/timestamp.c:3756 utils/adt/timestamp.c:3885 utils/adt/timestamp.c:3926 utils/adt/timestamp.c:4014 utils/adt/timestamp.c:4060 utils/adt/timestamp.c:4171 utils/adt/timestamp.c:4578 utils/adt/timestamp.c:4694 utils/adt/timestamp.c:4704 utils/adt/timestamp.c:4800 utils/adt/timestamp.c:4919 utils/adt/timestamp.c:4929 utils/adt/timestamp.c:5250 utils/adt/timestamp.c:5264 utils/adt/timestamp.c:5269 utils/adt/timestamp.c:5283 -#: utils/adt/timestamp.c:5366 utils/adt/timestamp.c:5398 utils/adt/timestamp.c:5405 utils/adt/timestamp.c:5431 utils/adt/timestamp.c:5435 utils/adt/timestamp.c:5504 utils/adt/timestamp.c:5508 utils/adt/timestamp.c:5522 utils/adt/timestamp.c:5560 utils/adt/xml.c:2049 utils/adt/xml.c:2056 utils/adt/xml.c:2076 utils/adt/xml.c:2083 +#: utils/adt/timestamp.c:224 utils/adt/timestamp.c:268 utils/adt/timestamp.c:726 utils/adt/timestamp.c:735 utils/adt/timestamp.c:820 utils/adt/timestamp.c:860 utils/adt/timestamp.c:3074 utils/adt/timestamp.c:3095 utils/adt/timestamp.c:3108 utils/adt/timestamp.c:3117 utils/adt/timestamp.c:3125 utils/adt/timestamp.c:3180 utils/adt/timestamp.c:3203 utils/adt/timestamp.c:3216 utils/adt/timestamp.c:3227 utils/adt/timestamp.c:3235 +#: utils/adt/timestamp.c:3809 utils/adt/timestamp.c:3938 utils/adt/timestamp.c:3979 utils/adt/timestamp.c:4067 utils/adt/timestamp.c:4113 utils/adt/timestamp.c:4224 utils/adt/timestamp.c:4631 utils/adt/timestamp.c:4747 utils/adt/timestamp.c:4757 utils/adt/timestamp.c:4853 utils/adt/timestamp.c:4972 utils/adt/timestamp.c:4982 utils/adt/timestamp.c:5234 utils/adt/timestamp.c:5248 utils/adt/timestamp.c:5253 utils/adt/timestamp.c:5267 +#: utils/adt/timestamp.c:5316 utils/adt/timestamp.c:5348 utils/adt/timestamp.c:5355 utils/adt/timestamp.c:5381 utils/adt/timestamp.c:5385 utils/adt/timestamp.c:5454 utils/adt/timestamp.c:5458 utils/adt/timestamp.c:5472 utils/adt/timestamp.c:5510 utils/adt/xml.c:2049 utils/adt/xml.c:2056 utils/adt/xml.c:2076 utils/adt/xml.c:2083 #, c-format msgid "timestamp out of range" msgstr "timestamp en dehors des limites" @@ -18506,12 +18511,12 @@ msgstr "déplacement du fuseau horaire en dehors des limites" msgid "\"time with time zone\" units \"%s\" not recognized" msgstr "L'unité « %s » n'est pas reconnu pour le type « time with time zone »" -#: utils/adt/date.c:2830 utils/adt/datetime.c:995 utils/adt/datetime.c:1917 utils/adt/datetime.c:4743 utils/adt/timestamp.c:532 utils/adt/timestamp.c:559 utils/adt/timestamp.c:5275 utils/adt/timestamp.c:5514 +#: utils/adt/date.c:2830 utils/adt/datetime.c:995 utils/adt/datetime.c:1917 utils/adt/datetime.c:4743 utils/adt/timestamp.c:532 utils/adt/timestamp.c:559 utils/adt/timestamp.c:5259 utils/adt/timestamp.c:5464 #, c-format msgid "time zone \"%s\" not recognized" msgstr "le fuseau horaire « %s » n'est pas reconnu" -#: utils/adt/date.c:2870 utils/adt/timestamp.c:5351 utils/adt/timestamp.c:5545 +#: utils/adt/date.c:2870 utils/adt/timestamp.c:5301 utils/adt/timestamp.c:5495 #, c-format msgid "interval time zone \"%s\" must not include months or days" msgstr "l'intervalle de fuseau horaire « %s » ne doit pas spécifier de mois ou de jours" @@ -18573,7 +18578,7 @@ msgstr "Unité invalide pour une taille : « %s »." msgid "Valid units are \"bytes\", \"kB\", \"MB\", \"GB\", and \"TB\"." msgstr "Les unités valides pour ce paramètre sont « bytes », « kB », « MB », « GB » et « TB »." -#: utils/adt/domains.c:85 +#: utils/adt/domains.c:86 #, c-format msgid "type %s is not a domain" msgstr "le type %s n'est pas un domaine" @@ -19062,7 +19067,7 @@ msgstr "données int2vector invalide" msgid "oidvector has too many elements" msgstr "oidvector a trop d'éléments" -#: utils/adt/int.c:1362 utils/adt/int8.c:1460 utils/adt/numeric.c:1351 utils/adt/timestamp.c:5611 utils/adt/timestamp.c:5692 +#: utils/adt/int.c:1362 utils/adt/int8.c:1460 utils/adt/numeric.c:1351 utils/adt/timestamp.c:5561 utils/adt/timestamp.c:5642 #, c-format msgid "step size cannot equal zero" msgstr "la taille du pas ne peut pas valoir zéro" @@ -20326,8 +20331,8 @@ msgstr "timestamp en dehors de limites : %d-%02d-%02d %d:%02d:%02g" msgid "timestamp out of range: \"%g\"" msgstr "timestamp en dehors de limites : « %g »" -#: utils/adt/timestamp.c:987 utils/adt/timestamp.c:1558 utils/adt/timestamp.c:2068 utils/adt/timestamp.c:3220 utils/adt/timestamp.c:3225 utils/adt/timestamp.c:3230 utils/adt/timestamp.c:3280 utils/adt/timestamp.c:3287 utils/adt/timestamp.c:3294 utils/adt/timestamp.c:3314 utils/adt/timestamp.c:3321 utils/adt/timestamp.c:3328 utils/adt/timestamp.c:3358 utils/adt/timestamp.c:3366 utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3751 -#: utils/adt/timestamp.c:3880 utils/adt/timestamp.c:4271 +#: utils/adt/timestamp.c:987 utils/adt/timestamp.c:1611 utils/adt/timestamp.c:2121 utils/adt/timestamp.c:3273 utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3283 utils/adt/timestamp.c:3333 utils/adt/timestamp.c:3340 utils/adt/timestamp.c:3347 utils/adt/timestamp.c:3367 utils/adt/timestamp.c:3374 utils/adt/timestamp.c:3381 utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3419 utils/adt/timestamp.c:3464 utils/adt/timestamp.c:3804 +#: utils/adt/timestamp.c:3933 utils/adt/timestamp.c:4324 #, c-format msgid "interval out of range" msgstr "intervalle en dehors des limites" @@ -20347,51 +20352,51 @@ msgstr "la précision de l'intervalle INTERVAL(%d) ne doit pas être négative" msgid "INTERVAL(%d) precision reduced to maximum allowed, %d" msgstr "La précision de l'intervalle INTERVAL(%d) doit être réduit au maximum permis, %d" -#: utils/adt/timestamp.c:1502 +#: utils/adt/timestamp.c:1555 #, c-format msgid "interval(%d) precision must be between %d and %d" msgstr "La précision de interval(%d) doit être comprise entre %d et %d" -#: utils/adt/timestamp.c:2797 +#: utils/adt/timestamp.c:2850 #, c-format msgid "cannot subtract infinite timestamps" msgstr "ne peut pas soustraire les valeurs timestamps infinies" -#: utils/adt/timestamp.c:4006 utils/adt/timestamp.c:4531 utils/adt/timestamp.c:4715 utils/adt/timestamp.c:4740 +#: utils/adt/timestamp.c:4059 utils/adt/timestamp.c:4584 utils/adt/timestamp.c:4768 utils/adt/timestamp.c:4793 #, c-format msgid "timestamp units \"%s\" not supported" msgstr "les unités timestamp « %s » ne sont pas supportées" -#: utils/adt/timestamp.c:4020 utils/adt/timestamp.c:4485 utils/adt/timestamp.c:4750 +#: utils/adt/timestamp.c:4073 utils/adt/timestamp.c:4538 utils/adt/timestamp.c:4803 #, c-format msgid "timestamp units \"%s\" not recognized" msgstr "les unité « %s » ne sont pas reconnues pour le type timestamp" -#: utils/adt/timestamp.c:4160 utils/adt/timestamp.c:4526 utils/adt/timestamp.c:4937 utils/adt/timestamp.c:4963 +#: utils/adt/timestamp.c:4213 utils/adt/timestamp.c:4579 utils/adt/timestamp.c:4990 utils/adt/timestamp.c:5016 #, c-format msgid "timestamp with time zone units \"%s\" not supported" msgstr "" "les unités « %s » ne sont pas supportées pour le type « timestamp with time\n" "zone »" -#: utils/adt/timestamp.c:4177 utils/adt/timestamp.c:4480 utils/adt/timestamp.c:4972 +#: utils/adt/timestamp.c:4230 utils/adt/timestamp.c:4533 utils/adt/timestamp.c:5025 #, c-format msgid "timestamp with time zone units \"%s\" not recognized" msgstr "" "Les unités « %s » ne sont pas reconnues pour le type « timestamp with time\n" "zone »" -#: utils/adt/timestamp.c:4258 +#: utils/adt/timestamp.c:4311 #, c-format msgid "interval units \"%s\" not supported because months usually have fractional weeks" msgstr "unités d'intervalle « %s » non supporté car les mois ont généralement des semaines fractionnaires" -#: utils/adt/timestamp.c:4264 utils/adt/timestamp.c:5078 +#: utils/adt/timestamp.c:4317 utils/adt/timestamp.c:5131 #, c-format msgid "interval units \"%s\" not supported" msgstr "Les unités « %s » ne sont pas supportées pour le type interval" -#: utils/adt/timestamp.c:4280 utils/adt/timestamp.c:5105 +#: utils/adt/timestamp.c:4333 utils/adt/timestamp.c:5158 #, c-format msgid "interval units \"%s\" not recognized" msgstr "Les unités « %s » ne sont pas reconnues pour le type interval" @@ -20451,17 +20456,17 @@ msgstr "l'opérande est trop long dans tsquery : « %s »" msgid "word is too long in tsquery: \"%s\"" msgstr "le mot est trop long dans tsquery : « %s »" -#: utils/adt/tsquery.c:643 +#: utils/adt/tsquery.c:642 #, c-format msgid "text-search query doesn't contain lexemes: \"%s\"" msgstr "la requête de recherche plein texte ne contient pas de lexemes : « %s »" -#: utils/adt/tsquery.c:654 utils/adt/tsquery_util.c:375 +#: utils/adt/tsquery.c:653 utils/adt/tsquery_util.c:375 #, c-format msgid "tsquery is too large" msgstr "le champ tsquery est trop gros" -#: utils/adt/tsquery_cleanup.c:601 +#: utils/adt/tsquery_cleanup.c:407 #, c-format msgid "text-search query contains only stop words or doesn't contain lexemes, ignored" msgstr "" @@ -20508,59 +20513,59 @@ msgstr "le mot est trop long (%ld octets, max %ld octets)" msgid "string is too long for tsvector (%ld bytes, max %ld bytes)" msgstr "la chaîne est trop longue pour tsvector (%ld octets, max %ld octets)" -#: utils/adt/tsvector_op.c:321 utils/adt/tsvector_op.c:608 utils/adt/tsvector_op.c:776 +#: utils/adt/tsvector_op.c:322 utils/adt/tsvector_op.c:609 utils/adt/tsvector_op.c:777 #, c-format msgid "lexeme array may not contain nulls" msgstr "le tableau de lexème ne doit pas contenir de valeurs NULL" -#: utils/adt/tsvector_op.c:851 +#: utils/adt/tsvector_op.c:852 #, c-format msgid "weight array may not contain nulls" msgstr "le tableau de poids ne doit pas contenir de valeurs NULL" -#: utils/adt/tsvector_op.c:875 +#: utils/adt/tsvector_op.c:876 #, c-format msgid "unrecognized weight: \"%c\"" msgstr "poids non reconnu : « %c »" -#: utils/adt/tsvector_op.c:2061 +#: utils/adt/tsvector_op.c:2313 #, c-format msgid "ts_stat query must return one tsvector column" msgstr "la requête ts_stat doit renvoyer une colonne tsvector" -#: utils/adt/tsvector_op.c:2243 +#: utils/adt/tsvector_op.c:2495 #, c-format msgid "tsvector column \"%s\" does not exist" msgstr "la colonne tsvector « %s » n'existe pas" -#: utils/adt/tsvector_op.c:2249 +#: utils/adt/tsvector_op.c:2501 #, c-format msgid "column \"%s\" is not of tsvector type" msgstr "la colonne « %s » n'est pas de type tsvector" -#: utils/adt/tsvector_op.c:2261 +#: utils/adt/tsvector_op.c:2513 #, c-format msgid "configuration column \"%s\" does not exist" msgstr "la colonne de configuration « %s » n'existe pas" -#: utils/adt/tsvector_op.c:2267 +#: utils/adt/tsvector_op.c:2519 #, c-format msgid "column \"%s\" is not of regconfig type" msgstr "la colonne « %s » n'est pas de type regconfig" -#: utils/adt/tsvector_op.c:2274 +#: utils/adt/tsvector_op.c:2526 #, c-format msgid "configuration column \"%s\" must not be null" msgstr "la colonne de configuration « %s » ne doit pas être NULL" -#: utils/adt/tsvector_op.c:2287 +#: utils/adt/tsvector_op.c:2539 #, c-format msgid "text search configuration name \"%s\" must be schema-qualified" msgstr "" "le nom de la configuration de la recherche plein texte « %s » doit être\n" "qualifié par son schéma" -#: utils/adt/tsvector_op.c:2312 +#: utils/adt/tsvector_op.c:2564 #, c-format msgid "column \"%s\" is not of a character type" msgstr "la colonne « %s » n'est pas de type caractère" @@ -20911,7 +20916,7 @@ msgstr "aucune fonction en entrée disponible pour le type %s" msgid "no output function available for type %s" msgstr "aucune fonction en sortie disponible pour le type %s" -#: utils/cache/plancache.c:716 +#: utils/cache/plancache.c:718 #, c-format msgid "cached plan must not change result type" msgstr "le plan en cache ne doit pas modifier le type en résultat" @@ -21016,81 +21021,81 @@ msgstr "n'a pas pu ré-ouvrir le fichier « %s » comme stdout : %m" msgid "[unknown]" msgstr "[inconnu]" -#: utils/error/elog.c:2881 utils/error/elog.c:3184 utils/error/elog.c:3292 +#: utils/error/elog.c:2882 utils/error/elog.c:3185 utils/error/elog.c:3293 msgid "missing error text" msgstr "texte d'erreur manquant" -#: utils/error/elog.c:2884 utils/error/elog.c:2887 utils/error/elog.c:3295 utils/error/elog.c:3298 +#: utils/error/elog.c:2885 utils/error/elog.c:2888 utils/error/elog.c:3296 utils/error/elog.c:3299 #, c-format msgid " at character %d" msgstr " au caractère %d" -#: utils/error/elog.c:2897 utils/error/elog.c:2904 +#: utils/error/elog.c:2898 utils/error/elog.c:2905 msgid "DETAIL: " msgstr "DÉTAIL: " -#: utils/error/elog.c:2911 +#: utils/error/elog.c:2912 msgid "HINT: " msgstr "ASTUCE : " -#: utils/error/elog.c:2918 +#: utils/error/elog.c:2919 msgid "QUERY: " msgstr "REQUÊTE : " -#: utils/error/elog.c:2925 +#: utils/error/elog.c:2926 msgid "CONTEXT: " msgstr "CONTEXTE : " -#: utils/error/elog.c:2935 +#: utils/error/elog.c:2936 #, c-format msgid "LOCATION: %s, %s:%d\n" msgstr "EMPLACEMENT : %s, %s:%d\n" -#: utils/error/elog.c:2942 +#: utils/error/elog.c:2943 #, c-format msgid "LOCATION: %s:%d\n" msgstr "EMPLACEMENT : %s:%d\n" -#: utils/error/elog.c:2956 +#: utils/error/elog.c:2957 msgid "STATEMENT: " msgstr "INSTRUCTION : " #. translator: This string will be truncated at 47 #. characters expanded. -#: utils/error/elog.c:3413 +#: utils/error/elog.c:3414 #, c-format msgid "operating system error %d" msgstr "erreur %d du système d'exploitation" -#: utils/error/elog.c:3611 +#: utils/error/elog.c:3612 msgid "DEBUG" msgstr "DEBUG" -#: utils/error/elog.c:3615 +#: utils/error/elog.c:3616 msgid "LOG" msgstr "LOG" -#: utils/error/elog.c:3618 +#: utils/error/elog.c:3619 msgid "INFO" msgstr "INFO" -#: utils/error/elog.c:3621 +#: utils/error/elog.c:3622 msgid "NOTICE" msgstr "NOTICE" -#: utils/error/elog.c:3624 +#: utils/error/elog.c:3625 msgid "WARNING" msgstr "ATTENTION" -#: utils/error/elog.c:3627 +#: utils/error/elog.c:3628 msgid "ERROR" msgstr "ERREUR" -#: utils/error/elog.c:3630 +#: utils/error/elog.c:3631 msgid "FATAL" msgstr "FATAL" -#: utils/error/elog.c:3633 +#: utils/error/elog.c:3634 msgid "PANIC" msgstr "PANIC" @@ -23727,869 +23732,856 @@ msgstr "" msgid "cannot import a snapshot from a different database" msgstr "ne peut pas importer un snapshot à partir d'une base de données différente" -#~ msgid "huge TLB pages not supported on this platform" -#~ msgstr "Huge Pages TLB non supporté sur cette plateforme." +#~ msgid "could not create two-phase state file \"%s\": %m" +#~ msgstr "" +#~ "n'a pas pu créer le fichier de statut de la validation en deux phases nommé\n" +#~ "« %s » : %m" -#~ msgid "Only superusers can use untrusted languages." +#~ msgid "could not seek in two-phase state file: %m" #~ msgstr "" -#~ "Seuls les super-utilisateurs peuvent utiliser des langages qui ne sont pas\n" -#~ "de confiance." +#~ "n'a pas pu se déplacer dans le fichier de statut de la validation en deux\n" +#~ "phases : %m" -#~ msgid "function returning set of rows cannot return null value" +#~ msgid "two-phase state file for transaction %u is corrupt" #~ msgstr "" -#~ "la fonction renvoyant un ensemble de lignes ne peut pas renvoyer une valeur\n" -#~ "NULL" +#~ "le fichier d'état de la validation en deux phases est corrompu pour la\n" +#~ "transaction %u" -#~ msgid "system columns cannot be used in an ON CONFLICT clause" -#~ msgstr "les colonnes systèmes ne peuvent pas être utilisées dans une clause ON CONFLICT" +#~ msgid "could not fsync two-phase state file \"%s\": %m" +#~ msgstr "" +#~ "n'a pas pu synchroniser sur disque (fsync) le fichier d'état de la\n" +#~ "validation en deux phases nommé « %s » : %m" -#~ msgid "role \"%s\" is reserved" -#~ msgstr "le rôle « %s » est réservé" +#~ msgid "could not close two-phase state file \"%s\": %m" +#~ msgstr "" +#~ "n'a pas pu fermer le fichier d'état de la validation en deux phases nommé\n" +#~ "« %s » : %m" -#~ msgid "time zone abbreviation \"%s\" is not used in time zone \"%s\"" -#~ msgstr "l'abréviation « %s » du fuseau horaire n'est pas utilisée dans le fuseau horaire « %s »" +#~ msgid "could not link file \"%s\" to \"%s\" (initialization of log file): %m" +#~ msgstr "n'a pas pu lier le fichier « %s » à « %s » (initialisation du journal de transactions) : %m" -#~ msgid "invalid length in external \"numeric\" value" -#~ msgstr "longueur invalide dans la valeur externe « numeric »" +#~ msgid "could not rename file \"%s\" to \"%s\" (initialization of log file): %m" +#~ msgstr "n'a pas pu renommer le fichier « %s » en « %s » (initialisation du journal de transactions) : %m" -#~ msgid "too few arguments for format" -#~ msgstr "trop peu d'arguments pour le format" +#~ msgid "ignoring \"%s\" file because no \"%s\" file exists" +#~ msgstr "ignore le fichier « %s » parce que le fichier « %s » n'existe pas" -#~ msgid "mapped win32 error code %lu to %d" -#~ msgstr "correspondance du code d'erreur win32 %lu en %d" +#~ msgid "must be superuser or replication role to run a backup" +#~ msgstr "doit être super-utilisateur ou avoir l'attribut de réplication pour exécuter une sauvegarde" -#~ msgid "unrecognized win32 error code: %lu" -#~ msgstr "code d'erreur win32 non reconnu : %lu" +#~ msgid "must be superuser to switch transaction log files" +#~ msgstr "doit être super-utilisateur pour changer de journal de transactions" -#~ msgid "invalid value for recovery parameter \"recovery_target\"" -#~ msgstr "valeur invalide pour le paramètre de restauration « recovery_target »" +#~ msgid "must be superuser to create a restore point" +#~ msgstr "doit être super-utilisateur pour créer un point de restauration" -#~ msgid "redo record is at %X/%X; shutdown %s" -#~ msgstr "l'enregistrement à ré-exécuter se trouve à %X/%X ; arrêt %s" +#~ msgid "must be superuser to control recovery" +#~ msgstr "doit être super-utilisateur pour contrôler la restauration" -#~ msgid "next transaction ID: %u/%u; next OID: %u" -#~ msgstr "prochain identifiant de transaction : %u/%u ; prochain OID : %u" +#~ msgid "invalid record length at %X/%X" +#~ msgstr "longueur invalide de l'enregistrement à %X/%X" -#~ msgid "next MultiXactId: %u; next MultiXactOffset: %u" -#~ msgstr "prochain MultiXactId : %u ; prochain MultiXactOffset : %u" +#~ msgid "%s is already in schema \"%s\"" +#~ msgstr "%s existe déjà dans le schéma « %s »" -#~ msgid "oldest unfrozen transaction ID: %u, in database %u" -#~ msgstr "" -#~ "identifiant de transaction non gelé le plus ancien : %u, dans la base de\n" -#~ "données %u" +#~ msgid "function \"%s\" must return type \"event_trigger\"" +#~ msgstr "la fonction « %s » doit renvoyer le type « event_trigger »" -#~ msgid "invalid xlog switch record at %X/%X" -#~ msgstr "enregistrement de basculement du journal de transaction invalide à %X/%X" +#~ msgid "function %s must return type \"fdw_handler\"" +#~ msgstr "la fonction %s doit renvoyer le type « fdw_handler »" -#~ msgid "record with zero length at %X/%X" -#~ msgstr "enregistrement de longueur nulle à %X/%X" +#~ msgid "could not reposition held cursor" +#~ msgstr "n'a pas pu repositionner le curseur détenu" -#~ msgid "invalid backup block size in record at %X/%X" -#~ msgstr "taille du bloc de sauvegarde invalide dans l'enregistrement à %X/%X" +#~ msgid "function %s must return type \"language_handler\"" +#~ msgstr "la fonction %s doit renvoyer le type « language_handler »" -#~ msgid "incorrect hole size in record at %X/%X" -#~ msgstr "taille du trou incorrect à l'enregistrement %X/%X" +#~ msgid "function %s must return type \"trigger\"" +#~ msgstr "la fonction %s doit renvoyer le type « trigger »" -#~ msgid "incorrect total length in record at %X/%X" -#~ msgstr "longueur totale incorrecte à l'enregistrement %X/%X" +#~ msgid "changing return type of function %s from \"opaque\" to \"cstring\"" +#~ msgstr "changement du type de retour de la fonction %s d'« opaque » vers « cstring »" -#~ msgid "WAL file is from different database system: WAL file database system identifier is %s, pg_control database system identifier is %s." -#~ msgstr "" -#~ "L'identifiant du journal de transactions du système de base de données est %s,\n" -#~ "l'identifiant pg_control du système de base de données dans pg_control est %s." +#~ msgid "type output function %s must return type \"cstring\"" +#~ msgstr "le type de sortie de la fonction %s doit être « cstring »" -#~ msgid "WAL file is from different database system: Incorrect XLOG_SEG_SIZE in page header." -#~ msgstr "" -#~ "le journal de transactions provient d'un système de bases de données différent :\n" -#~ "XLOG_SEG_SIZE incorrect dans l'en-tête de page." +#~ msgid "type send function %s must return type \"bytea\"" +#~ msgstr "la fonction send du type %s doit renvoyer le type « bytea »" -#~ msgid "WAL file is from different database system: Incorrect XLOG_BLCKSZ in page header." -#~ msgstr "" -#~ "le journal de transactions provient d'un système de bases de données différent :\n" -#~ "XLOG_BLCKSZ incorrect dans l'en-tête de page." +#~ msgid "typmod_in function %s must return type \"integer\"" +#~ msgstr "la fonction typmod_in %s doit renvoyer le type « entier »" -#~ msgid "=> is deprecated as an operator name" -#~ msgstr "=> est un nom d'opérateur obsolète" +#~ msgid "Permissions should be u=rw (0600) or less." +#~ msgstr "Les droits devraient être u=rwx (0600) ou inférieures." -#~ msgid "This name may be disallowed altogether in future versions of PostgreSQL." -#~ msgstr "Ce nom pourrait être interdit dans les prochaines versions de PostgreSQL." +#~ msgid "function %s must return type \"tsm_handler\"" +#~ msgstr "la fonction %s doit renvoyer le type « tsm_handler »" -#~ msgid "inherited relation \"%s\" is not a table" -#~ msgstr "la relation héritée « %s » n'est pas une table" +#~ msgid "must be superuser to reset statistics counters" +#~ msgstr "doit être super-utilisateur pour réinitialiser les compteurs statistiques" -#~ msgid "\"%s\" is not a table, materialized view, composite type, or foreign table" -#~ msgstr "« %s » n'est ni une table, ni une vue matérialisée, ni un type composite, ni une table distante" +#~ msgid "socket not open" +#~ msgstr "socket non ouvert" -#~ msgid "Specify a USING expression to perform the conversion." -#~ msgstr "Donnez une expression USING pour réaliser la conversion." +#~ msgid "multibyte flag character is not allowed" +#~ msgstr "un caractère drapeau multi-octet n'est pas autorisé" -#~ msgid "" -#~ "automatic vacuum of table \"%s.%s.%s\": index scans: %d\n" -#~ "pages: %d removed, %d remain\n" -#~ "tuples: %.0f removed, %.0f remain, %.0f are dead but not yet removable\n" -#~ "buffer usage: %d hits, %d misses, %d dirtied\n" -#~ "avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n" -#~ "system usage: %s" -#~ msgstr "" -#~ "VACUUM automatique de la table « %s.%s.%s » : parcours d'index : %d\n" -#~ "pages : %d supprimées, %d restantes\n" -#~ "lignes : %.0f supprimées, %.0f restantes, %.0f sont mortes mais non supprimables\n" -#~ "utilisation des tampons : %d lus dans le cache, %d lus hors du cache, %d modifiés\n" -#~ "taux moyen de lecture : %.3f Mo/s, taux moyen d'écriture : %.3f Mo/s\n" -#~ "utilisation système : %s" +#~ msgid "could not format \"path\" value" +#~ msgstr "n'a pas pu formater la valeur « path »" -#~ msgid "" -#~ "%.0f dead row versions cannot be removed yet.\n" -#~ "There were %.0f unused item pointers.\n" -#~ "%u pages are entirely empty.\n" -#~ "%s." -#~ msgstr "" -#~ "%.0f versions de lignes mortes ne peuvent pas encore être supprimées.\n" -#~ "Il y avait %.0f pointeurs d'éléments inutilisés.\n" -#~ "%u pages sont entièrement vides.\n" -#~ "%s." +#~ msgid "invalid input syntax for type box: \"%s\"" +#~ msgstr "syntaxe en entrée invalide pour le type box : « %s »" -#~ msgid "interval precision specified twice" -#~ msgstr "précision d'intervalle spécifiée deux fois" +#~ msgid "invalid input syntax for type line: \"%s\"" +#~ msgstr "syntaxe en entrée invalide pour le type line: « %s »" -#~ msgid "received password packet" -#~ msgstr "paquet du mot de passe reçu" +#~ msgid "invalid input syntax for type path: \"%s\"" +#~ msgstr "syntaxe en entrée invalide pour le type path : « %s »" -#~ msgid "SSL failure during renegotiation start" -#~ msgstr "échec SSL au début de la re-négotiation" +#~ msgid "invalid input syntax for type point: \"%s\"" +#~ msgstr "syntaxe en entrée invalide pour le type point : « %s »" -#~ msgid "SSL handshake failure on renegotiation, retrying" -#~ msgstr "échec du handshake SSL lors de la renégotiation, nouvelle tentative" +#~ msgid "invalid input syntax for type lseg: \"%s\"" +#~ msgstr "syntaxe en entrée invalide pour le type lseg : « %s »" -#~ msgid "could not complete SSL handshake on renegotiation, too many failures" -#~ msgstr "n'a pas pu terminer la poignée de main de renégotiation, trop d'échecs" +#~ msgid "invalid input syntax for type polygon: \"%s\"" +#~ msgstr "syntaxe en entrée invalide pour le type polygon : « %s »" -#~ msgid "SSL failed to renegotiate connection before limit expired" -#~ msgstr "SSL a échoué à renégotier la connexion avant l'expiration du délai" +#~ msgid "invalid input syntax for type circle: \"%s\"" +#~ msgstr "syntaxe en entrée invalide pour le type circle : « %s »" -#~ msgid "could not set socket to blocking mode: %m" -#~ msgstr "n'a pas pu activer le mode bloquant pour la socket : %m" +#~ msgid "could not format \"circle\" value" +#~ msgstr "n'a pas pu formater la valeur « circle »" -#~ msgid "%s: setsysinfo failed: %s\n" -#~ msgstr "%s : setsysinfo a échoué : %s\n" +#~ msgid "must be superuser to signal the postmaster" +#~ msgstr "doit être super-utilisateur pour envoyer un signal au postmaster" -#~ msgid " -A 1|0 enable/disable run-time assert checking\n" -#~ msgstr "" -#~ " -A 1|0 active/désactive la vérification des limites (assert) à\n" -#~ " l'exécution\n" +#~ msgid "must be superuser to rotate log files" +#~ msgstr "doit être super-utilisateur pour exécuter la rotation des journaux applicatifs" -#~ msgid "subquery must return a column" -#~ msgstr "la sous-requête doit renvoyer une colonne" +#~ msgid "argument for function \"exp\" too big" +#~ msgstr "l'argument de la fonction « exp » est trop gros" -#~ msgid "Consider increasing the configuration parameter \"checkpoint_segments\"." -#~ msgstr "Considèrez l'augmentation du paramètre « checkpoint_segments »." +#~ msgid "could not convert to time zone \"%s\"" +#~ msgstr "n'a pas pu convertir vers le fuseau horaire « %s »" -#~ msgid "WAL archival (archive_mode=on) requires wal_level \"archive\", \"hot_standby\", or \"logical\"" +#~ msgid "WAL writer sleep time between WAL flushes." #~ msgstr "" -#~ "l'archivage des journaux de transactions (archive_mode=on) nécessite que\n" -#~ "le paramètre wal_level soit initialisé avec « archive », « hot_standby » ou « logical »" +#~ "Temps d'endormissement du processus d'écriture pendant le vidage des\n" +#~ "journaux de transactions en millisecondes." -#~ msgid "invalid value for parameter \"replication\"" -#~ msgstr "valeur invalide pour le paramètre « replication »" +#~ msgid "JSON does not support infinite date values." +#~ msgstr "JSON ne supporte pas les valeurs infinies de date." -#~ msgid "postmaster became multithreaded" -#~ msgstr "le postmaster est devenu multithreadé" +#~ msgid "JSON does not support infinite timestamp values." +#~ msgstr "JSON ne supporte pas les valeurs infinies de timestamp." -#~ msgid "archive member \"%s\" too large for tar format" -#~ msgstr "membre « %s » de l'archive trop volumineux pour le format tar" +#~ msgid "cannot override frame clause of window \"%s\"" +#~ msgstr "ne peut pas surcharger la frame clause du window « %s »" -#~ msgid "could not determine input data types" -#~ msgstr "n'a pas pu déterminer les types de données en entrée" +#~ msgid "window functions cannot use named arguments" +#~ msgstr "les fonctions window ne peuvent pas renvoyer des arguments nommés" -#~ msgid "neither input type is an array" -#~ msgstr "aucun type de données n'est un tableau" +#~ msgid "invalid list syntax for \"listen_addresses\"" +#~ msgstr "syntaxe de liste invalide pour le paramètre « listen_addresses »" -#~ msgid "unexpected \"=\"" -#~ msgstr "« = » inattendu" +#~ msgid "invalid list syntax for \"unix_socket_directories\"" +#~ msgstr "syntaxe de liste invalide pour le paramètre « unix_socket_directories »" -#~ msgid "invalid symbol" -#~ msgstr "symbole invalide" +#~ msgid "Valid values are '[]', '[)', '(]', and '()'." +#~ msgstr "Les valeurs valides sont « [] », « [) », « (] » et « () »." -#~ msgid "must be superuser or have the same role to cancel queries running in other server processes" -#~ msgstr "" -#~ "doit être super-utilisateur ou avoir le même rôle pour annuler des requêtes\n" -#~ "exécutées dans les autres processus serveur" +#~ msgid "poll() failed in statistics collector: %m" +#~ msgstr "échec du poll() dans le récupérateur de statistiques : %m" -#~ msgid "must be superuser or have the same role to terminate other server processes" -#~ msgstr "" -#~ "doit être super-utilisateur ou avoir le même rôle pour fermer les connexions\n" -#~ "exécutées dans les autres processus serveur" +#~ msgid "select() failed in logger process: %m" +#~ msgstr "échec de select() dans le processus des journaux applicatifs : %m" -#~ msgid "cannot accept a value of type pg_node_tree" -#~ msgstr "ne peut pas accepter une valeur de type pg_node_tree" +#~ msgid "%s: could not open file \"%s\": %s\n" +#~ msgstr "%s : n'a pas pu ouvrir le fichier « %s » : %s\n" -#~ msgid "Turns on various assertion checks." -#~ msgstr "Active les différentes vérifications des assertions." +#~ msgid "%s: could not open log file \"%s/%s\": %s\n" +#~ msgstr "%s : n'a pas pu ouvrir le journal applicatif « %s/%s » : %s\n" -#~ msgid "This is a debugging aid." -#~ msgstr "C'est une aide de débogage." +#~ msgid "%s: could not fork background process: %s\n" +#~ msgstr "%s : n'a pas pu créer un processus fils : %s\n" -#~ msgid "This parameter doesn't do anything." -#~ msgstr "Ce paramètre ne fait rien." +#~ msgid "%s: could not dissociate from controlling TTY: %s\n" +#~ msgstr "%s : n'a pas pu se dissocier du TTY contrôlant : %s\n" -#~ msgid "It's just here so that we won't choke on SET AUTOCOMMIT TO ON from 7.3-vintage clients." -#~ msgstr "" -#~ "C'est ici uniquement pour ne pas avoir de problèmes avec le SET AUTOCOMMIT\n" -#~ "TO ON des clients 7.3." +#~ msgid "Runs the server silently." +#~ msgstr "Lance le serveur de manière silencieuse." -#~ msgid "Sets the maximum distance in log segments between automatic WAL checkpoints." +#~ msgid "If this parameter is set, the server will automatically run in the background and any controlling terminals are dissociated." #~ msgstr "" -#~ "Initialise la distance maximale dans les journaux de transaction entre chaque\n" -#~ "point de vérification (checkpoints) des journaux." +#~ "Si ce paramètre est initialisé, le serveur sera exécuté automatiquement en\n" +#~ "tâche de fond et les terminaux de contrôles seront dés-associés." -#~ msgid "Set the amount of traffic to send and receive before renegotiating the encryption keys." +#~ msgid "WAL sender sleep time between WAL replications." #~ msgstr "" -#~ "Configure la quantité de trafic à envoyer et recevoir avant la renégotiation\n" -#~ "des clés d'enchiffrement." +#~ "Temps d'endormissement du processus d'envoi des journaux de transactions entre\n" +#~ "les réplications des journaux de transactions." -#~ msgid "SET AUTOCOMMIT TO OFF is no longer supported" -#~ msgstr "SET AUTOCOMMIT TO OFF n'est plus supporté" +#~ msgid "Sets the list of known custom variable classes." +#~ msgstr "Initialise la liste des classes variables personnalisées connues." -#~ msgid "assertion checking is not supported by this build" -#~ msgstr "la vérification de l'assertion n'a pas été intégrée lors de la compilation" +#~ msgid "foreign key constraint \"%s\" of relation \"%s\" does not exist" +#~ msgstr "la clé étrangère « %s » de la relation « %s » n'existe pas" -#~ msgid "%s \"%s\": return code %d" -#~ msgstr "%s « %s » : code de retour %d" +#~ msgid "removing built-in function \"%s\"" +#~ msgstr "suppression de la fonction interne « %s »" -#~ msgid "could not parse transaction log location \"%s\"" -#~ msgstr "n'a pas pu analyser l'emplacement du journal des transactions « %s »" +#~ msgid "permission denied to drop foreign-data wrapper \"%s\"" +#~ msgstr "droit refusé pour supprimer le wrapper de données distantes « %s »" -#~ msgid "invalid input syntax for transaction log location: \"%s\"" -#~ msgstr "syntaxe invalide en entrée pour l'emplacement du journal de transactions : « %s »" +#~ msgid "Must be superuser to drop a foreign-data wrapper." +#~ msgstr "Doit être super-utilisateur pour supprimer un wrapper de données distantes." -#~ msgid "trigger \"%s\" for table \"%s\" does not exist, skipping" -#~ msgstr "le trigger « %s » pour la table « %s » n'existe pas, poursuite du traitement" +#~ msgid "must be superuser to drop text search parsers" +#~ msgstr "" +#~ "doit être super-utilisateur pour supprimer des analyseurs de recherche plein\n" +#~ "texte" -#~ msgid "Kerberos 5 authentication failed for user \"%s\"" -#~ msgstr "authentification Kerberos 5 échouée pour l'utilisateur « %s »" +#~ msgid "must be superuser to drop text search templates" +#~ msgstr "doit être super-utilisateur pour supprimer des modèles de recherche plein texte" -#~ msgid "Kerberos initialization returned error %d" -#~ msgstr "l'initialisation de Kerberos a retourné l'erreur %d" +#~ msgid "recovery is still in progress, can't accept WAL streaming connections" +#~ msgstr "la restauration est en cours, ne peut pas accepter les connexions de flux WAL" -#~ msgid "Kerberos keytab resolving returned error %d" -#~ msgstr "la résolution keytab de Kerberos a renvoyé l'erreur %d" +#~ msgid "standby connections not allowed because wal_level=minimal" +#~ msgstr "connexions standby non autorisées car wal_level=minimal" -#~ msgid "Kerberos sname_to_principal(\"%s\", \"%s\") returned error %d" -#~ msgstr "sname_to_principal(« %s », « %s ») de Kerberos a renvoyé l'erreur %d" +#~ msgid "could not open directory \"pg_tblspc\": %m" +#~ msgstr "n'a pas pu ouvrir le répertoire « pg_tblspc » : %m" -#~ msgid "Kerberos recvauth returned error %d" -#~ msgstr "recvauth de Kerberos a renvoyé l'erreur %d" +#~ msgid "could not access root certificate file \"%s\": %m" +#~ msgstr "n'a pas pu accéder au fichier du certificat racine « %s » : %m" -#~ msgid "Kerberos unparse_name returned error %d" -#~ msgstr "unparse_name de Kerberos a renvoyé l'erreur %d" +#~ msgid "SSL certificate revocation list file \"%s\" not found, skipping: %s" +#~ msgstr "liste de révocation des certificats SSL « %s » introuvable, continue : %s" -#~ msgid "local user with ID %d does not exist" -#~ msgstr "l'utilisateur local dont l'identifiant est %d n'existe pas" +#~ msgid "Certificates will not be checked against revocation list." +#~ msgstr "Les certificats ne seront pas vérifiés avec la liste de révocation." -#~ msgid "SSL renegotiation failure" -#~ msgstr "échec lors de la re-négotiation SSL" +#~ msgid "missing or erroneous pg_hba.conf file" +#~ msgstr "fichier pg_hba.conf manquant ou erroné" -#~ msgid "krb5 authentication is not supported on local sockets" -#~ msgstr "" -#~ "l'authentification krb5 n'est pas supportée sur les connexions locales par\n" -#~ "socket" +#~ msgid "See server log for details." +#~ msgstr "Voir les journaux applicatifs du serveur pour plus de détails." -#~ msgid "%s: invalid effective UID: %d\n" -#~ msgstr "%s : UID effectif invalide : %d\n" +#~ msgid "Make sure the root.crt file is present and readable." +#~ msgstr "Assurez-vous que le certificat racine (root.crt) est présent et lisible" -#~ msgid "%s: could not determine user name (GetUserName failed)\n" -#~ msgstr "%s : n'a pas pu déterminer le nom de l'utilisateur (GetUserName a échoué)\n" +#~ msgid " --help show this help, then exit\n" +#~ msgstr " --help affiche cette aide, puis quitte\n" -#~ msgid "too many column aliases specified for function %s" -#~ msgstr "trop d'alias de colonnes spécifiées pour la fonction %s" +#~ msgid " --version output version information, then exit\n" +#~ msgstr " --version affiche la version, puis quitte\n" -#~ msgid "Expected 1 tuple with 3 fields, got %d tuples with %d fields." -#~ msgstr "Attendait 1 ligne avec 3 champs, a obtenu %d lignes avec %d champs." +#~ msgid "CREATE TABLE AS cannot specify INTO" +#~ msgstr "CREATE TABLE AS ne peut pas spécifier INTO" -#~ msgid "Security-barrier views are not automatically updatable." -#~ msgstr "Les vues avec barrière de sécurité ne sont pas automatiquement disponibles en écriture." +#~ msgid "column name list not allowed in CREATE TABLE / AS EXECUTE" +#~ msgstr "la liste de noms de colonnes n'est pas autorisée dans CREATE TABLE / AS EXECUTE" -#~ msgid "Views that return the same column more than once are not automatically updatable." -#~ msgstr "Les vues qui renvoient la même colonne plus d'une fois ne sont pas automatiquement disponibles en écriture." +#~ msgid "INSERT ... SELECT cannot specify INTO" +#~ msgstr "INSERT ... SELECT ne peut pas avoir INTO" -#~ msgid "wrong affix file format for flag" -#~ msgstr "mauvais format de fichier affixe pour le drapeau" +#~ msgid "DECLARE CURSOR cannot specify INTO" +#~ msgstr "DECLARE CURSOR ne peut pas spécifier INTO" -#~ msgid "missing assignment operator" -#~ msgstr "opérateur d'affectation manquant" +#~ msgid "subquery in FROM cannot have SELECT INTO" +#~ msgstr "la sous-requête du FROM ne peut pas avoir de SELECT INTO" -#~ msgid "cannot call json_object_keys on an array" -#~ msgstr "ne peut pas appeler json_object_keys sur un tableau" +#~ msgid "subquery cannot have SELECT INTO" +#~ msgstr "la sous-requête ne peut pas avoir de SELECT INTO" -#~ msgid "cannot call json_object_keys on a scalar" -#~ msgstr "ne peut pas appeler json_object_keys sur un scalaire" +#~ msgid "subquery in WITH cannot have SELECT INTO" +#~ msgstr "la sous-requête du WITH ne peut pas avoir de SELECT INTO" -#~ msgid "cannot call function with null path elements" -#~ msgstr "ne peut pas appeler une fonction avec des éléments chemins NULL" - -#~ msgid "cannot call function with empty path elements" -#~ msgstr "ne peut pas appeler une fonction avec des éléments chemins vides" - -#~ msgid "cannot extract array element from a non-array" -#~ msgstr "ne peut pas extraire un élément du tableau à partir d'un objet qui n'est pas un tableau" - -#~ msgid "cannot extract field from a non-object" -#~ msgstr "ne peut pas extraire le chemin à partir d'un non-objet" +#~ msgid "tablespace %u is not empty" +#~ msgstr "le tablespace %u n'est pas vide" -#~ msgid "cannot call json_array_elements on a non-array" -#~ msgstr "ne peut pas appeler json_array_elements sur un objet qui n'est pas un tableau" +#~ msgid "consistent state delayed because recovery snapshot incomplete" +#~ msgstr "état de cohérence pas encore atteint à cause d'un snapshot de restauration incomplet" -#~ msgid "cannot call json_array_elements on a scalar" -#~ msgstr "ne peut pas appeler json_array_elements sur un scalaire" +#~ msgid "SSPI error %x" +#~ msgstr "erreur SSPI : %x" -#~ msgid "first argument of json_populate_record must be a row type" -#~ msgstr "le premier argument de json_populate_record doit être un type ROW" +#~ msgid "%s (%x)" +#~ msgstr "%s (%x)" -#~ msgid "first argument of json_populate_recordset must be a row type" -#~ msgstr "le premier argument de json_populate_recordset doit être un type ROW" +#~ msgid "resetting unlogged relations: cleanup %d init %d" +#~ msgstr "réinitialisation des relations non tracées : nettoyage %d initialisation %d" -#~ msgid "cannot call json_populate_recordset on an object" -#~ msgstr "ne peut pas appeler json_populate_recordset sur un objet" +#~ msgid "ALTER TYPE USING is only supported on plain tables" +#~ msgstr "ALTER TYPE USING est seulement supportés sur les tables standards" -#~ msgid "cannot call json_populate_recordset with nested objects" -#~ msgstr "ne peut pas appeler json_populate_recordset sur des objets imbriqués" +#~ msgid "index \"%s\" is not a b-tree" +#~ msgstr "l'index « %s » n'est pas un btree" -#~ msgid "must call json_populate_recordset on an array of objects" -#~ msgstr "doit appeler json_populate_recordset sur un tableau d'objets" +#~ msgid "unable to read symbolic link %s: %m" +#~ msgstr "incapable de lire le lien symbolique %s : %m" -#~ msgid "cannot call json_populate_recordset with nested arrays" -#~ msgstr "ne peut pas appeler json_populate_recordset avec des tableaux imbriqués" +#~ msgid "unable to open directory pg_tblspc: %m" +#~ msgstr "impossible d'ouvrir le répertoire p_tblspc : %m" -#~ msgid "cannot call json_populate_recordset on a scalar" -#~ msgstr "ne peut pas appeler json_populate_recordset sur un scalaire" +#~ msgid "Write-Ahead Log / Streaming Replication" +#~ msgstr "Write-Ahead Log / Réplication en flux" -#~ msgid "cannot call json_populate_recordset on a nested object" -#~ msgstr "ne peut pas appeler json_populate_recordset sur un objet imbriqué" +#~ msgid "syntax error in recovery command file: %s" +#~ msgstr "erreur de syntaxe dans le fichier de restauration : %s" -#~ msgid "No description available." -#~ msgstr "Aucune description disponible." +#~ msgid "Lines should have the format parameter = 'value'." +#~ msgstr "Les lignes devraient avoir le format paramètre = 'valeur'" -#~ msgid "Sets the name of the Kerberos service." -#~ msgstr "Initialise le nom du service Kerberos." +#~ msgid "index %u/%u/%u needs VACUUM FULL or REINDEX to finish crash recovery" +#~ msgstr "" +#~ "l'index %u/%u/%u a besoin d'un VACUUM FULL ou d'un REINDEX pour terminer la\n" +#~ "récupération suite à un arrêt brutal" -#~ msgid "time zone offset %d is not a multiple of 900 sec (15 min) in time zone file \"%s\", line %d" +#~ msgid "Incomplete insertion detected during crash replay." #~ msgstr "" -#~ "le décalage %d du fuseau horaire n'est pas un multiples de 900 secondes\n" -#~ "(15 minutes) dans le fichier des fuseaux horaires « %s », ligne %d" +#~ "Insertion incomplète détectée lors de la ré-exécution des requêtes suite à\n" +#~ "l'arrêt brutal." -#~ msgid "Perhaps out of disk space?" -#~ msgstr "Peut-être manquez-vous de place disque ?" +#~ msgid "index \"%s\" needs VACUUM or REINDEX to finish crash recovery" +#~ msgstr "" +#~ "l'index « %s » a besoin d'un VACUUM ou d'un REINDEX pour terminer la\n" +#~ "récupération suite à un arrêt brutal" -#~ msgid "could not change directory to \"%s\"" -#~ msgstr "n'a pas pu accéder au répertoire « %s »" +#~ msgid "index \"%s\" needs VACUUM FULL or REINDEX to finish crash recovery" +#~ msgstr "" +#~ "l'index « %s » a besoin d'un VACUUM FULL ou d'un REINDEX pour terminer la\n" +#~ "récupération suite à un arrêt brutal" -#~ msgid "unlogged GiST indexes are not supported" -#~ msgstr "les index GiST non tracés ne sont pas supportés" +#~ msgid "EnumValuesCreate() can only set a single OID" +#~ msgstr "EnumValuesCreate() peut seulement initialiser un seul OID" -#~ msgid "could not open file \"%s\" (log file %u, segment %u): %m" -#~ msgstr "n'a pas pu ouvrir le fichier « %s » (journal de transactions %u, segment %u) : %m" +#~ msgid "clustering \"%s.%s\"" +#~ msgstr "exécution de CLUSTER sur « %s.%s »" -#~ msgid "there is no contrecord flag in log file %u, segment %u, offset %u" +#~ msgid "cannot cluster on index \"%s\" because access method does not handle null values" #~ msgstr "" -#~ "il n'y a pas de drapeaux « contrecord » dans le journal de transactions %u,\n" -#~ "segment %u, décalage %u" +#~ "ne peut pas créer un cluster sur l'index « %s » car la méthode d'accès de\n" +#~ "l'index ne gère pas les valeurs NULL" -#~ msgid "invalid contrecord length %u in log file %u, segment %u, offset %u" +#~ msgid "You might be able to work around this by marking column \"%s\" NOT NULL, or use ALTER TABLE ... SET WITHOUT CLUSTER to remove the cluster specification from the table." #~ msgstr "" -#~ "longueur invalide du « contrecord » %u dans le journal de tranasctions %u,\n" -#~ "segment %u, décalage %u" +#~ "Vous pourriez contourner ceci en marquant la colonne « %s » avec la\n" +#~ "contrainte NOT NULL ou en utilisant ALTER TABLE ... SET WITHOUT CLUSTER pour\n" +#~ "supprimer la spécification CLUSTER de la table." -#~ msgid "Incorrect XLOG_SEG_SIZE in page header." -#~ msgstr "XLOG_SEG_SIZE incorrecte dans l'en-tête de page." +#~ msgid "You might be able to work around this by marking column \"%s\" NOT NULL." +#~ msgstr "Vous pouvez contourner ceci en marquant la colonne « %s » comme NOT NULL." -#~ msgid "Incorrect XLOG_BLCKSZ in page header." -#~ msgstr "XLOG_BLCKSZ incorrect dans l'en-tête de page." +#~ msgid "cannot cluster on expressional index \"%s\" because its index access method does not handle null values" +#~ msgstr "" +#~ "ne peut pas exécuter CLUSTER sur l'index à expression « %s » car sa méthode\n" +#~ "d'accès ne gère pas les valeurs NULL" -#~ msgid "xrecoff \"%X\" is out of valid range, 0..%X" -#~ msgstr "xrecoff « %X » en dehors des limites valides, 0..%X" +#~ msgid "\"%s\" is not a table, view, or composite type" +#~ msgstr "« %s » n'est pas une table, une vue ou un type composite" -#~ msgid "uncataloged table %s" -#~ msgstr "table %s sans catalogue" +#~ msgid "must be superuser to comment on procedural language" +#~ msgstr "" +#~ "doit être super-utilisateur pour ajouter un commentaire sur un langage de\n" +#~ "procédures" -#~ msgid "cannot use subquery in default expression" -#~ msgstr "ne peut pas utiliser une sous-requête dans l'expression par défaut" +#~ msgid "must be superuser to comment on text search parser" +#~ msgstr "" +#~ "doit être super-utilisateur pour ajouter un commentaire sur l'analyseur de\n" +#~ "recherche plein texte" -#~ msgid "cannot use aggregate function in default expression" -#~ msgstr "ne peut pas utiliser une fonction d'agrégat dans une expression par défaut" +#~ msgid "must be superuser to comment on text search template" +#~ msgstr "" +#~ "doit être super-utilisateur pour ajouter un commentaire sur un modèle de\n" +#~ "recherche plein texte" -#~ msgid "cannot use window function in default expression" -#~ msgstr "ne peut pas utiliser une fonction window dans une expression par défaut" +#~ msgid "function \"%s\" is already in schema \"%s\"" +#~ msgstr "la fonction « %s » existe déjà dans le schéma « %s »" -#~ msgid "cannot use window function in check constraint" -#~ msgstr "ne peut pas utiliser une fonction window dans une contrainte de vérification" +#~ msgid "cannot reference temporary table from permanent table constraint" +#~ msgstr "" +#~ "ne peut pas référencer une table temporaire à partir d'une contrainte de\n" +#~ "table permanente" -#~ msgid "A function returning ANYRANGE must have at least one ANYRANGE argument." +#~ msgid "cannot reference permanent table from temporary table constraint" #~ msgstr "" -#~ "Une fonction renvoyant ANYRANGE doit avoir au moins un argument du type\n" -#~ "ANYRANGE." +#~ "ne peut pas référencer une table permanente à partir de la contrainte de\n" +#~ "table temporaire" -#~ msgid "%s already exists in schema \"%s\"" -#~ msgstr "%s existe déjà dans le schéma « %s »" +#~ msgid "composite type must have at least one attribute" +#~ msgstr "le type composite doit avoir au moins un attribut" -#~ msgid "CREATE TABLE AS specifies too many column names" -#~ msgstr "CREATE TABLE AS spécifie trop de noms de colonnes" +#~ msgid "database \"%s\" not found" +#~ msgstr "base de données « %s » non trouvée" -#~ msgid "cannot use subquery in parameter default value" -#~ msgstr "ne peut pas utiliser une sous-requête dans une valeur par défaut d'un paramètre" +#~ msgid "invalid list syntax for parameter \"datestyle\"" +#~ msgstr "syntaxe de liste invalide pour le paramètre « datestyle »" -#~ msgid "cannot use aggregate function in parameter default value" -#~ msgstr "" -#~ "ne peut pas utiliser une fonction d'agrégat dans la valeur par défaut d'un\n" -#~ "paramètre" +#~ msgid "unrecognized \"datestyle\" key word: \"%s\"" +#~ msgstr "mot clé « datestyle » non reconnu : « %s »" -#~ msgid "cannot use window function in parameter default value" -#~ msgstr "ne peut pas utiliser la fonction window dans la valeur par défaut d'un paramètre" +#~ msgid "invalid interval value for time zone: month not allowed" +#~ msgstr "valeur d'intervalle invalide pour le fuseau horaire : les mois ne sont pas autorisés" -#~ msgid "Use ALTER AGGREGATE to rename aggregate functions." -#~ msgstr "Utiliser ALTER AGGREGATE pour renommer les fonctions d'agrégat." +#~ msgid "invalid interval value for time zone: day not allowed" +#~ msgstr "valeur d'intervalle invalide pour le fuseau horaire : jour non autorisé" -#~ msgid "Use ALTER AGGREGATE to change owner of aggregate functions." -#~ msgstr "Utiliser ALTER AGGREGATE pour changer le propriétaire des fonctions d'agrégat." +#~ msgid "argument to pg_get_expr() must come from system catalogs" +#~ msgstr "l'argument de pg_get_expr() doit provenir des catalogues systèmes" -#~ msgid "function \"%s\" already exists in schema \"%s\"" -#~ msgstr "la fonction « %s » existe déjà dans le schéma « %s »" +#~ msgid "could not enable credential reception: %m" +#~ msgstr "n'a pas pu activer la réception de lettres de créance : %m" -#~ msgid "cannot use aggregate in index predicate" -#~ msgstr "ne peut pas utiliser un agrégat dans un prédicat d'index" +#~ msgid "could not get effective UID from peer credentials: %m" +#~ msgstr "n'a pas pu obtenir l'UID réel à partir des pièces d'identité de l'autre : %m" -#~ msgid "cannot use window function in EXECUTE parameter" -#~ msgstr "ne peut pas utiliser une fonction window dans le paramètre EXECUTE" +#~ msgid "Ident authentication is not supported on local connections on this platform" +#~ msgstr "l'authentification Ident n'est pas supportée sur les connexions locales sur cette plateforme" -#~ msgid "constraints on foreign tables are not supported" -#~ msgstr "les contraintes sur les tables distantes ne sont pas supportées" +#~ msgid "could not create log file \"%s\": %m" +#~ msgstr "n'a pas pu créer le journal applicatif « %s » : %m" -#~ msgid "default values on foreign tables are not supported" -#~ msgstr "les valeurs par défaut ne sont pas supportées sur les tables distantes" +#~ msgid "could not open new log file \"%s\": %m" +#~ msgstr "n'a pas pu ouvrir le nouveau journal applicatif « %s » : %m" -#~ msgid "cannot use window function in transform expression" -#~ msgstr "ne peut pas utiliser la fonction window dans l'expression de la transformation" +#~ msgid "Sets immediate fsync at commit." +#~ msgstr "Configure un fsync immédiat lors du commit." -#~ msgid "Use ALTER FOREIGN TABLE instead." -#~ msgstr "Utilisez ALTER FOREIGN TABLE à la place." +#~ msgid "invalid list syntax for parameter \"log_destination\"" +#~ msgstr "syntaxe de liste invalide pour le paramètre « log_destination »" -#~ msgid "cannot use window function in trigger WHEN condition" -#~ msgstr "ne peut pas utiliser la fonction window dans la condition WHEN d'un trigger" +#~ msgid "unrecognized \"log_destination\" key word: \"%s\"" +#~ msgstr "mot clé « log_destination » non reconnu : « %s »" -#~ msgid "must be superuser to rename text search parsers" +#~ msgid "cannot drop \"%s\" because it is being used by active queries in this session" #~ msgstr "" -#~ "doit être super-utilisateur pour renommer les analyseurs de recherche plein\n" -#~ "texte" - -#~ msgid "must be superuser to rename text search templates" -#~ msgstr "doit être super-utilisateur pour renommer les modèles de recherche plein texte" +#~ "ne peut pas supprimer « %s » car cet objet est en cours d'utilisation par\n" +#~ "des requêtes actives dans cette session" -#~ msgid "automatic vacuum of table \"%s.%s.%s\": cannot (re)acquire exclusive lock for truncate scan" -#~ msgstr "vacuum automatique de la table « %s.%s.%s » : ne peut pas acquérir le verrou exclusif pour la tronquer" +#~ msgid "parameter \"recovery_target_inclusive\" requires a Boolean value" +#~ msgstr "le paramètre « recovery_target_inclusive » requiert une valeur booléenne" -#~ msgid "You need an unconditional ON INSERT DO INSTEAD rule or an INSTEAD OF INSERT trigger." -#~ msgstr "Vous avez besoin d'une règle ON INSERT DO INSTEAD sans condition ou d'un trigger INSTEAD OF INSERT." +#~ msgid "parameter \"standby_mode\" requires a Boolean value" +#~ msgstr "le paramètre « standby_mode » requiert une valeur booléenne" -#~ msgid "You need an unconditional ON UPDATE DO INSTEAD rule or an INSTEAD OF UPDATE trigger." -#~ msgstr "Vous avez besoin d'une règle non conditionnelle ON UPDATE DO INSTEAD ou d'un trigger INSTEAD OF UPDATE." +#~ msgid "Sets the message levels that are logged during recovery." +#~ msgstr "Initialise les niveaux de messages qui sont tracés lors de la restauration." -#~ msgid "You need an unconditional ON DELETE DO INSTEAD rule or an INSTEAD OF DELETE trigger." -#~ msgstr "Vous avez besoin d'une règle inconditionnelle ON DELETE DO INSTEAD ou d'un trigger INSTEAD OF DELETE." +#~ msgid "Not safe to send CSV data\n" +#~ msgstr "Envoi non sûr des données CSV\n" -#~ msgid "LDAP search failed for filter \"%s\" on server \"%s\": user is not unique (%ld matches)" +#~ msgid "recovery restart point at %X/%X with latest known log time %s" #~ msgstr "" -#~ "échec de la recherche LDAP pour le filtre « %s » sur le serveur « %s » :\n" -#~ "utilisateur non unique (%ld correspondances)" +#~ "point de relancement de la restauration sur %X/%X avec %s comme dernière\n" +#~ "date connue du journal" -#~ msgid "VALUES must not contain table references" -#~ msgstr "VALUES ne doit pas contenir de références de table" +#~ msgid "restartpoint_command = '%s'" +#~ msgstr "restartpoint_command = '%s'" -#~ msgid "VALUES must not contain OLD or NEW references" -#~ msgstr "VALUES ne doit pas contenir des références à OLD et NEW" +#~ msgid "usermap \"%s\"" +#~ msgstr "correspondance utilisateur « %s »" -#~ msgid "Use SELECT ... UNION ALL ... instead." -#~ msgstr "Utilisez à la place SELECT ... UNION ALL ..." +#~ msgid "WAL archiving is not active" +#~ msgstr "l'archivage des journaux de transactions n'est pas actif" -#~ msgid "cannot use aggregate function in VALUES" -#~ msgstr "ne peut pas utiliser la fonction d'agrégat dans un VALUES" +#~ msgid "archive_mode must be enabled at server start." +#~ msgstr "archive_mode doit être activé au lancement du serveur." -#~ msgid "cannot use window function in VALUES" -#~ msgstr "ne peut pas utiliser la fonction window dans un VALUES" +#~ msgid "archive_command must be defined before online backups can be made safely." +#~ msgstr "" +#~ "archive_command doit être défini avant que les sauvegardes à chaud puissent\n" +#~ "s'effectuer correctement." -#~ msgid "cannot use aggregate function in UPDATE" -#~ msgstr "ne peut pas utiliser une fonction d'agrégat dans un UPDATE" +#~ msgid "During recovery, allows connections and queries. During normal running, causes additional info to be written to WAL to enable hot standby mode on WAL standby nodes." +#~ msgstr "" +#~ "Lors de la restauration, autorise les connexions et les requêtes. Lors d'une\n" +#~ "exécution normale, fait que des informations supplémentaires sont écrites dans\n" +#~ "les journaux de transactions pour activer le mode Hot Standby sur les nÅ“uds\n" +#~ "en attente." -#~ msgid "cannot use window function in UPDATE" -#~ msgstr "ne peut pas utiliser une fonction window dans un UPDATE" +#~ msgid "unlogged operation performed, data may be missing" +#~ msgstr "opération réalisée non tracée, les données pourraient manquer" -#~ msgid "cannot use aggregate function in RETURNING" -#~ msgstr "ne peut pas utiliser une fonction d'agrégat dans RETURNING" +#~ msgid "not enough shared memory for walsender" +#~ msgstr "pas assez de mémoire partagée pour le processus d'envoi des journaux de transactions" -#~ msgid "cannot use window function in RETURNING" -#~ msgstr "ne peut pas utiliser une fonction window dans RETURNING" +#~ msgid "not enough shared memory for walreceiver" +#~ msgstr "" +#~ "pas assez de mémoire partagée pour le processus de réception des journaux de\n" +#~ "transactions" -#~ msgid "RETURNING cannot contain references to other relations" -#~ msgstr "RETURNING ne doit pas contenir de références à d'autres relations" +#~ msgid "connection limit exceeded for non-superusers" +#~ msgstr "limite de connexions dépassée pour les utilisateurs standards" -#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with GROUP BY clause" -#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec la clause GROUP BY" +#~ msgid "not enough shared memory for background writer" +#~ msgstr "pas assez de mémoire partagée pour le processus d'écriture en tâche de fond" -#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with HAVING clause" -#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec la clause HAVING" +#, fuzzy +#~ msgid "couldn't put socket to non-blocking mode: %m" +#~ msgstr "n'a pas pu activer le mode non-bloquant pour la socket : %s\n" -#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with aggregate functions" -#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec les fonctions d'agrégats" +#, fuzzy +#~ msgid "couldn't put socket to blocking mode: %m" +#~ msgstr "n'a pas pu activer le mode bloquant pour la socket : %s\n" -#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with window functions" -#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec les fonctions window" +#~ msgid "WAL file SYSID is %s, pg_control SYSID is %s" +#~ msgstr "le SYSID du journal de transactions WAL est %s, celui de pg_control est %s" -#~ msgid "SELECT FOR UPDATE/SHARE cannot be used with foreign table \"%s\"" -#~ msgstr "SELECT FOR UPDATE/SHARE ne peut pas être utilisé avec une table distante « %s »" +#, fuzzy +#~ msgid "sorry, too many standbys already" +#~ msgstr "désolé, trop de clients sont déjà connectés" -#~ msgid "aggregates not allowed in WHERE clause" -#~ msgstr "agrégats non autorisés dans une clause WHERE" +#, fuzzy +#~ msgid "invalid WAL message received from primary" +#~ msgstr "format du message invalide" -#~ msgid "window functions not allowed in GROUP BY clause" -#~ msgstr "fonctions window non autorisées dans une clause GROUP BY" +#~ msgid "PID %d is among the slowest backends." +#~ msgstr "Le PID %d est parmi les processus serveur les plus lents." -#~ msgid "JOIN/ON clause refers to \"%s\", which is not part of JOIN" -#~ msgstr "la clause JOIN/ON se réfère à « %s », qui ne fait pas partie du JOIN" +#~ msgid "transaction is read-only" +#~ msgstr "la transaction est en lecture seule" -#~ msgid "subquery in FROM cannot refer to other relations of same query level" -#~ msgstr "" -#~ "la sous-requête du FROM ne peut pas faire référence à d'autres relations\n" -#~ "dans le même niveau de la requête" +#~ msgid "binary value is out of range for type bigint" +#~ msgstr "la valeur binaire est en dehors des limites du type bigint" -#~ msgid "function expression in FROM cannot refer to other relations of same query level" +#~ msgid "redo starts at %X/%X, consistency will be reached at %X/%X" +#~ msgstr "la restauration comme à %X/%X, la cohérence sera atteinte à %X/%X" + +#~ msgid "This error can also happen if the byte sequence does not match the encoding expected by the server, which is controlled by \"client_encoding\"." #~ msgstr "" -#~ "l'expression de la fonction du FROM ne peut pas faire référence à d'autres\n" -#~ "relations sur le même niveau de la requête" +#~ "Cette erreur peut aussi survenir si la séquence d'octets ne correspond pas\n" +#~ "au jeu de caractères attendu par le serveur, le jeu étant contrôlé par\n" +#~ "« client_encoding »." -#~ msgid "cannot use window function in function expression in FROM" +#~ msgid "Sets the language used in DO statement if LANGUAGE is not specified." #~ msgstr "" -#~ "ne peut pas utiliser la fonction window dans l'expression de la fonction\n" -#~ "du FROM" +#~ "Configure le langage utilisé dans une instruction DO si la clause LANGUAGE n'est\n" +#~ "pas spécifiée." -#~ msgid "argument of %s must not contain aggregate functions" -#~ msgstr "l'argument de %s ne doit pas contenir de fonctions d'agrégats" +#~ msgid "shared index \"%s\" can only be reindexed in stand-alone mode" +#~ msgstr "un index partagé « %s » peut seulement être réindexé en mode autonome" -#~ msgid "argument of %s must not contain window functions" -#~ msgstr "l'argument de %s ne doit pas contenir des fonctions window" +#~ msgid "\"%s\" is a system catalog" +#~ msgstr "« %s » est un catalogue système" -#~ msgid "arguments of row IN must all be row expressions" -#~ msgstr "les arguments de la ligne IN doivent tous être des expressions de ligne" +#~ msgid "shared table \"%s\" can only be reindexed in stand-alone mode" +#~ msgstr "la table partagée « %s » peut seulement être réindexé en mode autonome" -#~ msgid "cannot use aggregate function in rule WHERE condition" -#~ msgstr "ne peut pas utiliser la fonction d'agrégat dans la condition d'une règle WHERE" +#~ msgid "cannot truncate system relation \"%s\"" +#~ msgstr "ne peut pas tronquer la relation système « %s »" -#~ msgid "cannot use window function in rule WHERE condition" -#~ msgstr "ne peut pas utiliser la fonction window dans la condition d'une règle WHERE" +#~ msgid "number of distinct values %g is too low" +#~ msgstr "le nombre de valeurs distinctes %g est trop basse" -#~ msgid "" -#~ "This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter. You can either reduce the request size or reconfigure the kernel with larger SHMMAX. To reduce the request size (currently %lu bytes), reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.\n" -#~ "If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter, in which case raising the request size or reconfiguring SHMMIN is called for.\n" -#~ "The PostgreSQL documentation contains more information about shared memory configuration." -#~ msgstr "" -#~ "Cette erreur signifie habituellement que la demande de PostgreSQL pour un\n" -#~ "segment de mémoire partagée a dépassé le paramètre SHMMAX de votre noyau.\n" -#~ "Vous pouvez soit réduire la taille de la requête soit reconfigurer le noyau\n" -#~ "avec un SHMMAX plus important. Pour réduire la taille de la requête\n" -#~ "(actuellement %lu octets), réduisez l'utilisation de la mémoire partagée par PostgreSQL,par exemple en réduisant shared_buffers ou max_connections\n" -#~ "Si la taille de la requête est déjà petite, il est possible qu'elle soit\n" -#~ "moindre que le paramètre SHMMIN de votre noyau, auquel cas, augmentez la\n" -#~ "taille de la requête ou reconfigurez SHMMIN.\n" -#~ "La documentation de PostgreSQL contient plus d'informations sur la\n" -#~ "configuration de la mémoire partagée." +#~ msgid "directory \"%s\" is not empty" +#~ msgstr "le répertoire « %s » n'est pas vide" -#~ msgid "terminating all walsender processes to force cascaded standby(s) to update timeline and reconnect" +#~ msgid "relation \"%s\" TID %u/%u: XMIN_COMMITTED not set for transaction %u --- cannot shrink relation" #~ msgstr "" -#~ "arrêt de tous les processus walsender pour forcer les serveurs standby en\n" -#~ "cascade à mettre à jour la timeline et à se reconnecter" - -#~ msgid "shutdown requested, aborting active base backup" -#~ msgstr "arrêt demandé, annulation de la sauvegarde active de base" - -#~ msgid "streaming replication successfully connected to primary" -#~ msgstr "réplication de flux connecté avec succès au serveur principal" - -#~ msgid "invalid standby handshake message type %d" -#~ msgstr "type %d du message de handshake du serveur en attente invalide" +#~ "relation « %s », TID %u/%u : XMIN_COMMITTED non configuré pour la\n" +#~ "transaction %u --- n'a pas pu diminuer la taille de la relation" -#~ msgid "terminating walsender process to force cascaded standby to update timeline and reconnect" +#~ msgid "relation \"%s\" TID %u/%u: dead HOT-updated tuple --- cannot shrink relation" #~ msgstr "" -#~ "arrêt du processus walreceiver pour forcer le serveur standby en cascade à\n" -#~ "mettre à jour la timeline et à se reconnecter" - -#~ msgid "invalid standby query string: %s" -#~ msgstr "chaîne de requête invalide sur le serveur en attente : %s" - -#~ msgid "large object %u was not opened for writing" -#~ msgstr "le « Large Object » %u n'a pas été ouvert en écriture" - -#~ msgid "large object %u was already dropped" -#~ msgstr "le « Large Object » %u a déjà été supprimé" +#~ "relation « %s », TID %u/%u : ligne morte mise à jour par HOT --- n'a pas pu\n" +#~ "diminuer la taille de la relation" -#~ msgid "Not enough memory for reassigning the prepared transaction's locks." -#~ msgstr "Pas assez de mémoire pour réaffecter les verrous des transactions préparées." +#~ msgid "relation \"%s\" TID %u/%u: InsertTransactionInProgress %u --- cannot shrink relation" +#~ msgstr "" +#~ "relation « %s », TID %u/%u : InsertTransactionInProgress %u --- n'a pas pu\n" +#~ "diminuer la taille de la relation" -#~ msgid "\"interval\" time zone \"%s\" not valid" -#~ msgstr "le fuseau horaire « %s » n'est pas valide pour le type « interval »" +#~ msgid "relation \"%s\" TID %u/%u: DeleteTransactionInProgress %u --- cannot shrink relation" +#~ msgstr "" +#~ "relation « %s », TID %u/%u : DeleteTransactionInProgress %u --- n'a pas pu\n" +#~ "diminuer la taille de la relation" -#~ msgid "inconsistent use of year %04d and \"BC\"" -#~ msgstr "utilisation non cohérente de l'année %04d et de « BC »" +#~ msgid "" +#~ "%.0f dead row versions cannot be removed yet.\n" +#~ "Nonremovable row versions range from %lu to %lu bytes long.\n" +#~ "There were %.0f unused item pointers.\n" +#~ "Total free space (including removable row versions) is %.0f bytes.\n" +#~ "%u pages are or will become empty, including %u at the end of the table.\n" +#~ "%u pages containing %.0f free bytes are potential move destinations.\n" +#~ "%s." +#~ msgstr "" +#~ "%.0f versions de lignes mortes ne peuvent pas encore être supprimées.\n" +#~ "Les versions non supprimables de ligne vont de %lu to %lu octets.\n" +#~ "Il existait %.0f pointeurs d'éléments inutilisés.\n" +#~ "L'espace libre total (incluant les versions supprimables de ligne) est de\n" +#~ "%.0f octets.\n" +#~ "%u pages sont ou deviendront vides, ceci incluant %u pages en fin de la\n" +#~ "table.\n" +#~ "%u pages contenant %.0f octets libres sont des destinations de déplacement\n" +#~ "disponibles.\n" +#~ "%s." -#~ msgid "No rows were found in \"%s\"." -#~ msgstr "Aucune ligne trouvée dans « %s »." +#~ msgid "\"%s\": moved %u row versions, truncated %u to %u pages" +#~ msgstr "« %s » : %u versions de ligne déplacées, %u pages tronquées sur %u" -#~ msgid "argument number is out of range" -#~ msgstr "le nombre en argument est en dehors des limites" +#~ msgid "" +#~ "%u index pages have been deleted, %u are currently reusable.\n" +#~ "%s." +#~ msgstr "" +#~ "%u pages d'index ont été supprimées, %u sont actuellement réutilisables.\n" +#~ "%s." -#~ msgid "index \"%s\" is not ready" -#~ msgstr "l'index « %s » n'est pas prêt" +#~ msgid "index \"%s\" contains %.0f row versions, but table contains %.0f row versions" +#~ msgstr "" +#~ "l'index « %s » contient %.0f versions de ligne, mais la table contient %.0f\n" +#~ "versions de ligne" -#~ msgid "could not remove database directory \"%s\"" -#~ msgstr "n'a pas pu supprimer le répertoire de bases de données « %s »" +#~ msgid "Rebuild the index with REINDEX." +#~ msgstr "Reconstruisez l'index avec REINDEX." -#~ msgid "unexpected end of line at line %d of thesaurus file \"%s\"" -#~ msgstr "fin de ligne inattendue à la ligne %d du thésaurus « %s »" +#~ msgid "frame start at CURRENT ROW is not implemented" +#~ msgstr "début du frame à CURRENT ROW n'est pas implémenté" -#~ msgid "unexpected end of line or lexeme at line %d of thesaurus file \"%s\"" -#~ msgstr "fin de ligne ou de lexeme inattendu sur la ligne %d du thesaurus « %s »" +#~ msgid "database system is in consistent recovery mode" +#~ msgstr "le système de bases de données est dans un mode de restauration cohérent" -#~ msgid "unexpected delimiter at line %d of thesaurus file \"%s\"" -#~ msgstr "délimiteur inattendu sur la ligne %d du thesaurus « %s »" +#~ msgid "DISTINCT is supported only for single-argument aggregates" +#~ msgstr "DISTINCT est seulement supporté pour les agrégats à un seul argument" -#~ msgid "Use the @@@ operator instead." -#~ msgstr "Utilisez à la place l'opérateur @@@." +#~ msgid "index row size %lu exceeds btree maximum, %lu" +#~ msgstr "la taille de la ligne index %lu dépasse le maximum de btree, %lu" -#~ msgid "@@ operator does not support lexeme weight restrictions in GIN index searches" -#~ msgstr "" -#~ "l'opérateur @@ ne supporte pas les restrictions de poids de lexeme dans les\n" -#~ "recherches par index GIN" +#~ msgid "Table contains duplicated values." +#~ msgstr "La table contient des valeurs dupliquées." -#~ msgid "query requires full scan, which is not supported by GIN indexes" +#~ msgid "Automatically adds missing table references to FROM clauses." #~ msgstr "" -#~ "la requête nécessite un parcours complet, ce qui n'est pas supporté par les\n" -#~ "index GIN" - -#~ msgid "cannot calculate week number without year information" -#~ msgstr "ne peut pas calculer le numéro de la semaine sans informations sur l'année" +#~ "Ajoute automatiquement les références à la table manquant dans les clauses\n" +#~ "FROM." -#~ msgid "UTF-16 to UTF-8 translation failed: %lu" -#~ msgstr "échec de la conversion d'UTF16 vers UTF8 : %lu" +#~ msgid "Sets the regular expression \"flavor\"." +#~ msgstr "Initialise l'expression rationnelle « flavor »." -#~ msgid "AM/PM hour must be between 1 and 12" -#~ msgstr "l'heure AM/PM doit être compris entre 1 et 12" +#~ msgid "attempted change of parameter \"%s\" ignored" +#~ msgstr "tentative de modification du paramètre « %s » ignoré" -#~ msgid "Sat" -#~ msgstr "Sam" +#~ msgid "This parameter cannot be changed after server start." +#~ msgstr "Ce paramètre ne peut pas être modifié après le lancement du serveur" -#~ msgid "Fri" -#~ msgstr "Ven" +#~ msgid "invalid database name \"%s\"" +#~ msgstr "nom de base de données « %s » invalide" -#~ msgid "Thu" -#~ msgstr "Jeu" +#~ msgid "invalid role name \"%s\"" +#~ msgstr "nom de rôle « %s » invalide" -#~ msgid "Wed" -#~ msgstr "Mer" +#~ msgid "invalid role password \"%s\"" +#~ msgstr "mot de passe « %s » de l'utilisateur invalide" -#~ msgid "Tue" -#~ msgstr "Mar" +#~ msgid "cannot specify CSV in BINARY mode" +#~ msgstr "ne peut pas spécifier CSV en mode binaire (BINARY)" -#~ msgid "Mon" -#~ msgstr "Lun" +#~ msgid "cannot set session authorization within security-definer function" +#~ msgstr "ne peut pas exécuter SESSION AUTHORIZATION sur la fonction SECURITY DEFINER" -#~ msgid "Sun" -#~ msgstr "Dim" +#~ msgid "SELECT FOR UPDATE/SHARE is not supported within a query with multiple result relations" +#~ msgstr "" +#~ "SELECT FOR UPDATE/SHARE n'est pas supporté dans une requête avec plusieurs\n" +#~ "relations" -#~ msgid "Saturday" -#~ msgstr "Samedi" +#~ msgid "could not remove relation %s: %m" +#~ msgstr "n'a pas pu supprimer la relation %s : %m" -#~ msgid "Friday" -#~ msgstr "Vendredi" +#~ msgid "could not remove segment %u of relation %s: %m" +#~ msgstr "n'a pas pu supprimer le segment %u de la relation %s : %m" -#~ msgid "Thursday" -#~ msgstr "Jeudi" +#~ msgid "could not seek to block %u of relation %s: %m" +#~ msgstr "n'a pas pu se positionner sur le bloc %u de la relation %s : %m" -#~ msgid "Wednesday" -#~ msgstr "Mercredi" +#~ msgid "could not extend relation %s: %m" +#~ msgstr "n'a pas pu étendre la relation %s : %m" -#~ msgid "Tuesday" -#~ msgstr "Mardi" +#~ msgid "could not open relation %s: %m" +#~ msgstr "n'a pas pu ouvrir la relation %s : %m" -#~ msgid "Monday" -#~ msgstr "Lundi" +#~ msgid "could not read block %u of relation %s: %m" +#~ msgstr "n'a pas pu lire le bloc %u de la relation %s : %m" -#~ msgid "Sunday" -#~ msgstr "Dimanche" +#~ msgid "could not write block %u of relation %s: %m" +#~ msgstr "n'a pas pu écrire le bloc %u de la relation %s : %m" -#~ msgid "Dec" -#~ msgstr "Déc" +#~ msgid "could not open segment %u of relation %s: %m" +#~ msgstr "n'a pas pu ouvrir le segment %u de la relation %s : %m" -#~ msgid "Nov" -#~ msgstr "Nov" +#~ msgid "could not fsync segment %u of relation %s: %m" +#~ msgstr "" +#~ "n'a pas pu synchroniser sur disque (fsync) le segment %u de la relation\n" +#~ "%s : %m" -#~ msgid "Oct" -#~ msgstr "Oct" +#~ msgid "could not fsync segment %u of relation %s but retrying: %m" +#~ msgstr "" +#~ "n'a pas pu synchroniser sur disque (fsync) le segment %u de la relation\n" +#~ "%s, nouvelle tentative : %m" -#~ msgid "Sep" -#~ msgstr "Sep" +#~ msgid "could not seek to end of segment %u of relation %s: %m" +#~ msgstr "n'a pas pu se déplacer à la fin du segment %u de la relation %s : %m" -#~ msgid "Aug" -#~ msgstr "Aoû" +#~ msgid "unsupported PAM conversation %d/%s" +#~ msgstr "conversation PAM %d/%s non supportée" -#~ msgid "Jul" -#~ msgstr "Juil" +#~ msgid "SELECT FOR UPDATE/SHARE is not allowed in subqueries" +#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé dans les sous-requêtes" -#~ msgid "Jun" -#~ msgstr "Juin" +#~ msgid "adding missing FROM-clause entry for table \"%s\"" +#~ msgstr "ajout d'une entrée manquante dans FROM (table « %s »)" -#~ msgid "S:May" -#~ msgstr "S:Mai" +#~ msgid "OLD used in query that is not in a rule" +#~ msgstr "OLD utilisé dans une requête qui n'est pas une règle" -#~ msgid "Apr" -#~ msgstr "Avr" +#~ msgid "NEW used in query that is not in a rule" +#~ msgstr "NEW utilisé dans une requête qui ne fait pas partie d'une règle" -#~ msgid "Mar" -#~ msgstr "Mar" +#~ msgid "hurrying in-progress restartpoint" +#~ msgstr "accélération du restartpoint en cours" -#~ msgid "Feb" -#~ msgstr "Fév" +#~ msgid "multiple DELETE events specified" +#~ msgstr "multiples événements DELETE spécifiés" -#~ msgid "Jan" -#~ msgstr "Jan" +#~ msgid "multiple UPDATE events specified" +#~ msgstr "multiples événements UPDATE spécifiés" -#~ msgid "December" -#~ msgstr "Décembre" +#~ msgid "multiple TRUNCATE events specified" +#~ msgstr "multiples événements TRUNCATE spécifiés" -#~ msgid "November" -#~ msgstr "Novembre" +#~ msgid "could not create XPath object" +#~ msgstr "n'a pas pu créer l'objet XPath" -#~ msgid "October" -#~ msgstr "Octobre" +#, fuzzy +#~ msgid "wrong number of array_subscripts" +#~ msgstr "mauvais nombre d'indices du tableau" -#~ msgid "September" -#~ msgstr "Septembre" +#~ msgid "fillfactor=%d is out of range (should be between %d and 100)" +#~ msgstr "le facteur de remplissage (%d) est en dehors des limites (il devrait être entre %d et 100)" -#~ msgid "August" -#~ msgstr "Août" +#~ msgid "GIN index does not support search with void query" +#~ msgstr "les index GIN ne supportent pas la recherche avec des requêtes vides" -#~ msgid "July" -#~ msgstr "Juillet" +#~ msgid "invalid LC_COLLATE setting" +#~ msgstr "paramètre LC_COLLATE invalide" -#~ msgid "June" -#~ msgstr "Juin" +#~ msgid "invalid LC_CTYPE setting" +#~ msgstr "paramètre LC_CTYPE invalide" -#~ msgid "May" -#~ msgstr "Mai" +#~ msgid "The database cluster was initialized with LOCALE_NAME_BUFLEN %d, but the server was compiled with LOCALE_NAME_BUFLEN %d." +#~ msgstr "" +#~ "Le cluster de bases de données a été initialisé avec un LOCALE_NAME_BUFLEN\n" +#~ "à %d alors que le serveur a été compilé avec un LOCALE_NAME_BUFLEN à %d." -#~ msgid "April" -#~ msgstr "Avril" +#~ msgid "It looks like you need to initdb or install locale support." +#~ msgstr "" +#~ "Il semble que vous avez besoin d'exécuter initdb ou d'installer le support\n" +#~ "des locales." -#~ msgid "March" -#~ msgstr "Mars" +#~ msgid "log_restartpoints = %s" +#~ msgstr "log_restartpoints = %s" -#~ msgid "February" -#~ msgstr "Février" +#~ msgid "syntax error: cannot back up" +#~ msgstr "erreur de syntaxe : n'a pas pu revenir" -#~ msgid "January" -#~ msgstr "Janvier" +#~ msgid "syntax error; also virtual memory exhausted" +#~ msgstr "erreur de syntaxe ; de plus, mémoire virtuelle saturée" -#~ msgid "\"TZ\"/\"tz\" not supported" -#~ msgstr "« TZ »/« tz » non supporté" +#~ msgid "parser stack overflow" +#~ msgstr "saturation de la pile de l'analyseur" -#~ msgid "invalid AM/PM string" -#~ msgstr "chaîne AM/PM invalide" +#~ msgid "failed to drop all objects depending on %s" +#~ msgstr "échec lors de la suppression de tous les objets dépendant de %s" -#~ msgid "not unique \"S\"" -#~ msgstr "« S » non unique" +#~ msgid "there are objects dependent on %s" +#~ msgstr "des objets dépendent de %s" -#~ msgid "invalid argument for power function" -#~ msgstr "argument invalide pour la fonction puissance (power)" +#~ msgid "multiple constraints named \"%s\" were dropped" +#~ msgstr "les contraintes multiples nommées « %s » ont été supprimées" -#~ msgid "Valid values are DOCUMENT and CONTENT." -#~ msgstr "Les valeurs valides sont DOCUMENT et CONTENT." +#~ msgid "constraint definition for check constraint \"%s\" does not match" +#~ msgstr "" +#~ "la définition de la contrainte « %s » pour la contrainte de vérification ne\n" +#~ "correspond pas" -#~ msgid "Valid values are LOCAL0, LOCAL1, LOCAL2, LOCAL3, LOCAL4, LOCAL5, LOCAL6, LOCAL7." +#~ msgid "relation \"%s.%s\" contains more than \"max_fsm_pages\" pages with useful free space" #~ msgstr "" -#~ "Les valeurs valides sont LOCAL0, LOCAL1, LOCAL2, LOCAL3, LOCAL4, LOCAL5,\n" -#~ "LOCAL6, LOCAL7." +#~ "la relation « %s.%s » contient plus de « max_fsm_pages » pages d'espace\n" +#~ "libre utile" -#~ msgid "This can be set to advanced, extended, or basic." +#~ msgid "Consider using VACUUM FULL on this relation or increasing the configuration parameter \"max_fsm_pages\"." #~ msgstr "" -#~ "Ceci peut être initialisé avec advanced (avancé), extended (étendu) ou\n" -#~ "basic (basique)." +#~ "Pensez à compacter cette relation en utilisant VACUUM FULL ou à augmenter le\n" +#~ "paramètre de configuration « max_fsm_pages »." -#~ msgid "Sets the hostname of the Kerberos server." -#~ msgstr "Initalise le nom d'hôte du serveur Kerberos." +#~ msgid "cannot change number of columns in view" +#~ msgstr "ne peut pas modifier le nombre de colonnes dans la vue" -#~ msgid "Sets realm to match Kerberos and GSSAPI users against." +#~ msgid "unexpected Kerberos user name received from client (received \"%s\", expected \"%s\")" #~ msgstr "" -#~ "Indique le royaume pour l'authentification des utilisateurs via Kerberos et\n" -#~ "GSSAPI." +#~ "nom d'utilisateur Kerberos inattendu reçu à partir du client (reçu « %s »,\n" +#~ "attendu « %s »)" + +#~ msgid "Kerberos 5 not implemented on this server" +#~ msgstr "Kerberos 5 non implémenté sur ce serveur" + +#~ msgid "GSSAPI not implemented on this server" +#~ msgstr "GSSAPI non implémenté sur ce serveur" -#~ msgid "Each session can be either \"origin\", \"replica\", or \"local\"." -#~ msgstr "Chaque session peut valoir soit « origin » soit « replica » soit « local »." +#~ msgid "could not get security token from context" +#~ msgstr "n'a pas pu récupérer le jeton de sécurité à partir du contexte" -#~ msgid "Each SQL transaction has an isolation level, which can be either \"read uncommitted\", \"read committed\", \"repeatable read\", or \"serializable\"." -#~ msgstr "" -#~ "Chaque transaction SQL a un niveau d'isolation qui peut être soit « read\n" -#~ "uncommitted », soit « read committed », soit « repeatable read », soit\n" -#~ "« serializable »." +#~ msgid "unsafe permissions on private key file \"%s\"" +#~ msgstr "droits non sûrs sur le fichier de la clé privée « %s »" -#~ msgid "All SQL statements that cause an error of the specified level or a higher level are logged." +#~ msgid "File must be owned by the database user and must have no permissions for \"group\" or \"other\"." #~ msgstr "" -#~ "Toutes les instructions SQL causant une erreur du niveau spécifié ou d'un\n" -#~ "niveau supérieur sont tracées." +#~ "Le fichier doit appartenir au propriétaire de la base de données et ne doit\n" +#~ "pas avoir de droits pour un groupe ou pour les autres." -#~ msgid "Valid values are DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1, INFO, NOTICE, WARNING, ERROR, LOG, FATAL, and PANIC. Each level includes all the levels that follow it." +#~ msgid "cannot use authentication method \"crypt\" because password is MD5-encrypted" #~ msgstr "" -#~ "Les valeurs valides sont DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1, INFO,\n" -#~ "NOTICE, WARNING, ERROR, LOG, FATAL et PANIC. Chaque niveau incut tous les\n" -#~ "niveaux qui le suit." - -#~ msgid "Valid values are ON, OFF, and SAFE_ENCODING." -#~ msgstr "Les valeurs valides sont ON, OFF et SAFE_ENCODING." +#~ "n'a pas pu utiliser la méthode d'authentification « crypt » car le mot de\n" +#~ "passe est chiffré avec MD5" -#~ msgid "Sets the maximum number of disk pages for which free space is tracked." -#~ msgstr "" -#~ "Initialise le nombre maximum de pages disque pour lesquelles l'espace libre\n" -#~ "est tracé." +#~ msgid "invalid entry in file \"%s\" at line %d, token \"%s\"" +#~ msgstr "entrée invalide dans le fichier « %s » à la ligne %d, jeton « %s »" -#~ msgid "Sets the maximum number of tables and indexes for which free space is tracked." -#~ msgstr "" -#~ "Initialise le nombre maximum de tables et index pour lesquels l'espace libre\n" -#~ "est tracé." +#~ msgid "missing field in file \"%s\" at end of line %d" +#~ msgstr "champ manquant dans le fichier « %s » à la fin de la ligne %d" -#~ msgid "Uses the indented output format for EXPLAIN VERBOSE." -#~ msgstr "Utilise le format de sortie indenté pour EXPLAIN VERBOSE." +#~ msgid "cannot use Ident authentication without usermap field" +#~ msgstr "n'a pas pu utiliser l'authentication Ident sans le champ usermap" -#~ msgid "Prints the execution plan to server log." -#~ msgstr "Affiche le plan d'exécution dans les journaux applicatifs du serveur." +#~ msgid "Ident protocol identifies remote user as \"%s\"" +#~ msgstr "le protocole Ident identifie l'utilisateur distant comme « %s »" -#~ msgid "Prints the parse tree after rewriting to server log." -#~ msgstr "Affiche l'arbre d'analyse après ré-écriture dans les journaux applicatifs du serveur." +#~ msgid "SELECT FOR UPDATE/SHARE is not supported for inheritance queries" +#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas supporté pour les requêtes d'héritage" -#~ msgid "Prints the parse tree to the server log." -#~ msgstr "Affiche l'arbre d'analyse dans les journaux applicatifs du serveur." +#~ msgid "missing FROM-clause entry in subquery for table \"%s\"" +#~ msgstr "entrée manquante de la clause FROM dans la sous-requête de la table « %s »" -#~ msgid "string is too long for tsvector" -#~ msgstr "la chaîne est trop longue pour un tsvector" +#~ msgid "adding missing FROM-clause entry in subquery for table \"%s\"" +#~ msgstr "entrée manquante de la clause FROM dans la sous-requête pour la table « %s »" -#~ msgid "Consider increasing the configuration parameter \"max_fsm_pages\" to a value over %.0f." +#~ msgid "%s: the number of buffers (-B) must be at least twice the number of allowed connections (-N) and at least 16\n" #~ msgstr "" -#~ "Considérez l'augmentation du paramètre de configuration « max_fsm_pages »\n" -#~ "à une valeur supérieure à %.0f." +#~ "%s : le nombre de tampons (-B) doit être au moins deux fois le nombre de\n" +#~ "connexions disponibles (-N) et au moins 16\n" -#~ msgid "number of page slots needed (%.0f) exceeds max_fsm_pages (%d)" -#~ msgstr "le nombre d'emplacements de pages nécessaires (%.0f) dépasse max_fsm_pages (%d)" +#~ msgid "could not set statistics collector timer: %m" +#~ msgstr "n'a pas pu configurer le timer du récupérateur de statistiques : %m" -#~ msgid "You have at least %d relations. Consider increasing the configuration parameter \"max_fsm_relations\"." -#~ msgstr "" -#~ "Vous avez au moins %d relations.Considèrez l'augmentation du paramètre de\n" -#~ "configuration « max_fsm_relations »." +#~ msgid "insufficient shared memory for free space map" +#~ msgstr "mémoire partagée insuffisante pour la structure FSM" -#~ msgid "max_fsm_relations(%d) equals the number of relations checked" -#~ msgstr "max_fsm_relations(%d) équivaut au nombre de relations tracées" +#~ msgid "max_fsm_pages must exceed max_fsm_relations * %d" +#~ msgstr "max_fsm_pages doit excéder max_fsm_relations * %d" + +#~ msgid "free space map contains %d pages in %d relations" +#~ msgstr "la structure FSM contient %d pages dans %d relations" #~ msgid "" #~ "A total of %.0f page slots are in use (including overhead).\n" @@ -24602,853 +24594,872 @@ msgstr "ne peut pas importer un snapshot à partir d'une base de données diffé #~ "Les limites actuelles sont : %d emplacements de pages, %d relations,\n" #~ "utilisant %.0f Ko." -#~ msgid "free space map contains %d pages in %d relations" -#~ msgstr "la structure FSM contient %d pages dans %d relations" - -#~ msgid "max_fsm_pages must exceed max_fsm_relations * %d" -#~ msgstr "max_fsm_pages doit excéder max_fsm_relations * %d" - -#~ msgid "insufficient shared memory for free space map" -#~ msgstr "mémoire partagée insuffisante pour la structure FSM" - -#~ msgid "could not set statistics collector timer: %m" -#~ msgstr "n'a pas pu configurer le timer du récupérateur de statistiques : %m" +#~ msgid "max_fsm_relations(%d) equals the number of relations checked" +#~ msgstr "max_fsm_relations(%d) équivaut au nombre de relations tracées" -#~ msgid "%s: the number of buffers (-B) must be at least twice the number of allowed connections (-N) and at least 16\n" +#~ msgid "You have at least %d relations. Consider increasing the configuration parameter \"max_fsm_relations\"." #~ msgstr "" -#~ "%s : le nombre de tampons (-B) doit être au moins deux fois le nombre de\n" -#~ "connexions disponibles (-N) et au moins 16\n" +#~ "Vous avez au moins %d relations.Considèrez l'augmentation du paramètre de\n" +#~ "configuration « max_fsm_relations »." -#~ msgid "adding missing FROM-clause entry in subquery for table \"%s\"" -#~ msgstr "entrée manquante de la clause FROM dans la sous-requête pour la table « %s »" +#~ msgid "number of page slots needed (%.0f) exceeds max_fsm_pages (%d)" +#~ msgstr "le nombre d'emplacements de pages nécessaires (%.0f) dépasse max_fsm_pages (%d)" -#~ msgid "missing FROM-clause entry in subquery for table \"%s\"" -#~ msgstr "entrée manquante de la clause FROM dans la sous-requête de la table « %s »" +#~ msgid "Consider increasing the configuration parameter \"max_fsm_pages\" to a value over %.0f." +#~ msgstr "" +#~ "Considérez l'augmentation du paramètre de configuration « max_fsm_pages »\n" +#~ "à une valeur supérieure à %.0f." -#~ msgid "SELECT FOR UPDATE/SHARE is not supported for inheritance queries" -#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas supporté pour les requêtes d'héritage" +#~ msgid "string is too long for tsvector" +#~ msgstr "la chaîne est trop longue pour un tsvector" -#~ msgid "Ident protocol identifies remote user as \"%s\"" -#~ msgstr "le protocole Ident identifie l'utilisateur distant comme « %s »" +#~ msgid "Prints the parse tree to the server log." +#~ msgstr "Affiche l'arbre d'analyse dans les journaux applicatifs du serveur." -#~ msgid "cannot use Ident authentication without usermap field" -#~ msgstr "n'a pas pu utiliser l'authentication Ident sans le champ usermap" +#~ msgid "Prints the parse tree after rewriting to server log." +#~ msgstr "Affiche l'arbre d'analyse après ré-écriture dans les journaux applicatifs du serveur." -#~ msgid "missing field in file \"%s\" at end of line %d" -#~ msgstr "champ manquant dans le fichier « %s » à la fin de la ligne %d" +#~ msgid "Prints the execution plan to server log." +#~ msgstr "Affiche le plan d'exécution dans les journaux applicatifs du serveur." -#~ msgid "invalid entry in file \"%s\" at line %d, token \"%s\"" -#~ msgstr "entrée invalide dans le fichier « %s » à la ligne %d, jeton « %s »" +#~ msgid "Uses the indented output format for EXPLAIN VERBOSE." +#~ msgstr "Utilise le format de sortie indenté pour EXPLAIN VERBOSE." -#~ msgid "cannot use authentication method \"crypt\" because password is MD5-encrypted" +#~ msgid "Sets the maximum number of tables and indexes for which free space is tracked." #~ msgstr "" -#~ "n'a pas pu utiliser la méthode d'authentification « crypt » car le mot de\n" -#~ "passe est chiffré avec MD5" +#~ "Initialise le nombre maximum de tables et index pour lesquels l'espace libre\n" +#~ "est tracé." -#~ msgid "File must be owned by the database user and must have no permissions for \"group\" or \"other\"." +#~ msgid "Sets the maximum number of disk pages for which free space is tracked." #~ msgstr "" -#~ "Le fichier doit appartenir au propriétaire de la base de données et ne doit\n" -#~ "pas avoir de droits pour un groupe ou pour les autres." - -#~ msgid "unsafe permissions on private key file \"%s\"" -#~ msgstr "droits non sûrs sur le fichier de la clé privée « %s »" +#~ "Initialise le nombre maximum de pages disque pour lesquelles l'espace libre\n" +#~ "est tracé." -#~ msgid "could not get security token from context" -#~ msgstr "n'a pas pu récupérer le jeton de sécurité à partir du contexte" +#~ msgid "Valid values are ON, OFF, and SAFE_ENCODING." +#~ msgstr "Les valeurs valides sont ON, OFF et SAFE_ENCODING." -#~ msgid "GSSAPI not implemented on this server" -#~ msgstr "GSSAPI non implémenté sur ce serveur" +#~ msgid "Valid values are DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1, INFO, NOTICE, WARNING, ERROR, LOG, FATAL, and PANIC. Each level includes all the levels that follow it." +#~ msgstr "" +#~ "Les valeurs valides sont DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1, INFO,\n" +#~ "NOTICE, WARNING, ERROR, LOG, FATAL et PANIC. Chaque niveau incut tous les\n" +#~ "niveaux qui le suit." -#~ msgid "Kerberos 5 not implemented on this server" -#~ msgstr "Kerberos 5 non implémenté sur ce serveur" +#~ msgid "All SQL statements that cause an error of the specified level or a higher level are logged." +#~ msgstr "" +#~ "Toutes les instructions SQL causant une erreur du niveau spécifié ou d'un\n" +#~ "niveau supérieur sont tracées." -#~ msgid "unexpected Kerberos user name received from client (received \"%s\", expected \"%s\")" +#~ msgid "Each SQL transaction has an isolation level, which can be either \"read uncommitted\", \"read committed\", \"repeatable read\", or \"serializable\"." #~ msgstr "" -#~ "nom d'utilisateur Kerberos inattendu reçu à partir du client (reçu « %s »,\n" -#~ "attendu « %s »)" +#~ "Chaque transaction SQL a un niveau d'isolation qui peut être soit « read\n" +#~ "uncommitted », soit « read committed », soit « repeatable read », soit\n" +#~ "« serializable »." -#~ msgid "cannot change number of columns in view" -#~ msgstr "ne peut pas modifier le nombre de colonnes dans la vue" +#~ msgid "Each session can be either \"origin\", \"replica\", or \"local\"." +#~ msgstr "Chaque session peut valoir soit « origin » soit « replica » soit « local »." -#~ msgid "Consider using VACUUM FULL on this relation or increasing the configuration parameter \"max_fsm_pages\"." +#~ msgid "Sets realm to match Kerberos and GSSAPI users against." #~ msgstr "" -#~ "Pensez à compacter cette relation en utilisant VACUUM FULL ou à augmenter le\n" -#~ "paramètre de configuration « max_fsm_pages »." +#~ "Indique le royaume pour l'authentification des utilisateurs via Kerberos et\n" +#~ "GSSAPI." -#~ msgid "relation \"%s.%s\" contains more than \"max_fsm_pages\" pages with useful free space" +#~ msgid "Sets the hostname of the Kerberos server." +#~ msgstr "Initalise le nom d'hôte du serveur Kerberos." + +#~ msgid "This can be set to advanced, extended, or basic." #~ msgstr "" -#~ "la relation « %s.%s » contient plus de « max_fsm_pages » pages d'espace\n" -#~ "libre utile" +#~ "Ceci peut être initialisé avec advanced (avancé), extended (étendu) ou\n" +#~ "basic (basique)." -#~ msgid "constraint definition for check constraint \"%s\" does not match" +#~ msgid "Valid values are LOCAL0, LOCAL1, LOCAL2, LOCAL3, LOCAL4, LOCAL5, LOCAL6, LOCAL7." #~ msgstr "" -#~ "la définition de la contrainte « %s » pour la contrainte de vérification ne\n" -#~ "correspond pas" +#~ "Les valeurs valides sont LOCAL0, LOCAL1, LOCAL2, LOCAL3, LOCAL4, LOCAL5,\n" +#~ "LOCAL6, LOCAL7." -#~ msgid "multiple constraints named \"%s\" were dropped" -#~ msgstr "les contraintes multiples nommées « %s » ont été supprimées" +#~ msgid "Valid values are DOCUMENT and CONTENT." +#~ msgstr "Les valeurs valides sont DOCUMENT et CONTENT." -#~ msgid "there are objects dependent on %s" -#~ msgstr "des objets dépendent de %s" +#~ msgid "invalid argument for power function" +#~ msgstr "argument invalide pour la fonction puissance (power)" -#~ msgid "failed to drop all objects depending on %s" -#~ msgstr "échec lors de la suppression de tous les objets dépendant de %s" +#~ msgid "not unique \"S\"" +#~ msgstr "« S » non unique" -#~ msgid "parser stack overflow" -#~ msgstr "saturation de la pile de l'analyseur" +#~ msgid "invalid AM/PM string" +#~ msgstr "chaîne AM/PM invalide" -#~ msgid "syntax error; also virtual memory exhausted" -#~ msgstr "erreur de syntaxe ; de plus, mémoire virtuelle saturée" +#~ msgid "\"TZ\"/\"tz\" not supported" +#~ msgstr "« TZ »/« tz » non supporté" -#~ msgid "syntax error: cannot back up" -#~ msgstr "erreur de syntaxe : n'a pas pu revenir" +#~ msgid "January" +#~ msgstr "Janvier" -#~ msgid "log_restartpoints = %s" -#~ msgstr "log_restartpoints = %s" +#~ msgid "February" +#~ msgstr "Février" -#~ msgid "It looks like you need to initdb or install locale support." -#~ msgstr "" -#~ "Il semble que vous avez besoin d'exécuter initdb ou d'installer le support\n" -#~ "des locales." +#~ msgid "March" +#~ msgstr "Mars" -#~ msgid "The database cluster was initialized with LOCALE_NAME_BUFLEN %d, but the server was compiled with LOCALE_NAME_BUFLEN %d." -#~ msgstr "" -#~ "Le cluster de bases de données a été initialisé avec un LOCALE_NAME_BUFLEN\n" -#~ "à %d alors que le serveur a été compilé avec un LOCALE_NAME_BUFLEN à %d." +#~ msgid "April" +#~ msgstr "Avril" + +#~ msgid "May" +#~ msgstr "Mai" + +#~ msgid "June" +#~ msgstr "Juin" + +#~ msgid "July" +#~ msgstr "Juillet" + +#~ msgid "August" +#~ msgstr "Août" + +#~ msgid "September" +#~ msgstr "Septembre" + +#~ msgid "October" +#~ msgstr "Octobre" + +#~ msgid "November" +#~ msgstr "Novembre" -#~ msgid "invalid LC_CTYPE setting" -#~ msgstr "paramètre LC_CTYPE invalide" +#~ msgid "December" +#~ msgstr "Décembre" -#~ msgid "invalid LC_COLLATE setting" -#~ msgstr "paramètre LC_COLLATE invalide" +#~ msgid "Jan" +#~ msgstr "Jan" -#~ msgid "GIN index does not support search with void query" -#~ msgstr "les index GIN ne supportent pas la recherche avec des requêtes vides" +#~ msgid "Feb" +#~ msgstr "Fév" -#~ msgid "fillfactor=%d is out of range (should be between %d and 100)" -#~ msgstr "le facteur de remplissage (%d) est en dehors des limites (il devrait être entre %d et 100)" +#~ msgid "Mar" +#~ msgstr "Mar" -#, fuzzy -#~ msgid "wrong number of array_subscripts" -#~ msgstr "mauvais nombre d'indices du tableau" +#~ msgid "Apr" +#~ msgstr "Avr" -#~ msgid "could not create XPath object" -#~ msgstr "n'a pas pu créer l'objet XPath" +#~ msgid "S:May" +#~ msgstr "S:Mai" -#~ msgid "multiple TRUNCATE events specified" -#~ msgstr "multiples événements TRUNCATE spécifiés" +#~ msgid "Jun" +#~ msgstr "Juin" -#~ msgid "multiple UPDATE events specified" -#~ msgstr "multiples événements UPDATE spécifiés" +#~ msgid "Jul" +#~ msgstr "Juil" -#~ msgid "multiple DELETE events specified" -#~ msgstr "multiples événements DELETE spécifiés" +#~ msgid "Aug" +#~ msgstr "Aoû" -#~ msgid "hurrying in-progress restartpoint" -#~ msgstr "accélération du restartpoint en cours" +#~ msgid "Sep" +#~ msgstr "Sep" -#~ msgid "NEW used in query that is not in a rule" -#~ msgstr "NEW utilisé dans une requête qui ne fait pas partie d'une règle" +#~ msgid "Oct" +#~ msgstr "Oct" -#~ msgid "OLD used in query that is not in a rule" -#~ msgstr "OLD utilisé dans une requête qui n'est pas une règle" +#~ msgid "Nov" +#~ msgstr "Nov" -#~ msgid "adding missing FROM-clause entry for table \"%s\"" -#~ msgstr "ajout d'une entrée manquante dans FROM (table « %s »)" +#~ msgid "Dec" +#~ msgstr "Déc" -#~ msgid "SELECT FOR UPDATE/SHARE is not allowed in subqueries" -#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé dans les sous-requêtes" +#~ msgid "Sunday" +#~ msgstr "Dimanche" -#~ msgid "unsupported PAM conversation %d/%s" -#~ msgstr "conversation PAM %d/%s non supportée" +#~ msgid "Monday" +#~ msgstr "Lundi" -#~ msgid "could not seek to end of segment %u of relation %s: %m" -#~ msgstr "n'a pas pu se déplacer à la fin du segment %u de la relation %s : %m" +#~ msgid "Tuesday" +#~ msgstr "Mardi" -#~ msgid "could not fsync segment %u of relation %s but retrying: %m" -#~ msgstr "" -#~ "n'a pas pu synchroniser sur disque (fsync) le segment %u de la relation\n" -#~ "%s, nouvelle tentative : %m" +#~ msgid "Wednesday" +#~ msgstr "Mercredi" -#~ msgid "could not fsync segment %u of relation %s: %m" -#~ msgstr "" -#~ "n'a pas pu synchroniser sur disque (fsync) le segment %u de la relation\n" -#~ "%s : %m" +#~ msgid "Thursday" +#~ msgstr "Jeudi" -#~ msgid "could not open segment %u of relation %s: %m" -#~ msgstr "n'a pas pu ouvrir le segment %u de la relation %s : %m" +#~ msgid "Friday" +#~ msgstr "Vendredi" -#~ msgid "could not write block %u of relation %s: %m" -#~ msgstr "n'a pas pu écrire le bloc %u de la relation %s : %m" +#~ msgid "Saturday" +#~ msgstr "Samedi" -#~ msgid "could not read block %u of relation %s: %m" -#~ msgstr "n'a pas pu lire le bloc %u de la relation %s : %m" +#~ msgid "Sun" +#~ msgstr "Dim" -#~ msgid "could not open relation %s: %m" -#~ msgstr "n'a pas pu ouvrir la relation %s : %m" +#~ msgid "Mon" +#~ msgstr "Lun" -#~ msgid "could not extend relation %s: %m" -#~ msgstr "n'a pas pu étendre la relation %s : %m" +#~ msgid "Tue" +#~ msgstr "Mar" -#~ msgid "could not seek to block %u of relation %s: %m" -#~ msgstr "n'a pas pu se positionner sur le bloc %u de la relation %s : %m" +#~ msgid "Wed" +#~ msgstr "Mer" -#~ msgid "could not remove segment %u of relation %s: %m" -#~ msgstr "n'a pas pu supprimer le segment %u de la relation %s : %m" +#~ msgid "Thu" +#~ msgstr "Jeu" -#~ msgid "could not remove relation %s: %m" -#~ msgstr "n'a pas pu supprimer la relation %s : %m" +#~ msgid "Fri" +#~ msgstr "Ven" -#~ msgid "SELECT FOR UPDATE/SHARE is not supported within a query with multiple result relations" -#~ msgstr "" -#~ "SELECT FOR UPDATE/SHARE n'est pas supporté dans une requête avec plusieurs\n" -#~ "relations" +#~ msgid "Sat" +#~ msgstr "Sam" -#~ msgid "cannot set session authorization within security-definer function" -#~ msgstr "ne peut pas exécuter SESSION AUTHORIZATION sur la fonction SECURITY DEFINER" +#~ msgid "AM/PM hour must be between 1 and 12" +#~ msgstr "l'heure AM/PM doit être compris entre 1 et 12" -#~ msgid "cannot specify CSV in BINARY mode" -#~ msgstr "ne peut pas spécifier CSV en mode binaire (BINARY)" +#~ msgid "UTF-16 to UTF-8 translation failed: %lu" +#~ msgstr "échec de la conversion d'UTF16 vers UTF8 : %lu" -#~ msgid "invalid role password \"%s\"" -#~ msgstr "mot de passe « %s » de l'utilisateur invalide" +#~ msgid "cannot calculate week number without year information" +#~ msgstr "ne peut pas calculer le numéro de la semaine sans informations sur l'année" -#~ msgid "invalid role name \"%s\"" -#~ msgstr "nom de rôle « %s » invalide" +#~ msgid "query requires full scan, which is not supported by GIN indexes" +#~ msgstr "" +#~ "la requête nécessite un parcours complet, ce qui n'est pas supporté par les\n" +#~ "index GIN" -#~ msgid "invalid database name \"%s\"" -#~ msgstr "nom de base de données « %s » invalide" +#~ msgid "@@ operator does not support lexeme weight restrictions in GIN index searches" +#~ msgstr "" +#~ "l'opérateur @@ ne supporte pas les restrictions de poids de lexeme dans les\n" +#~ "recherches par index GIN" -#~ msgid "This parameter cannot be changed after server start." -#~ msgstr "Ce paramètre ne peut pas être modifié après le lancement du serveur" +#~ msgid "Use the @@@ operator instead." +#~ msgstr "Utilisez à la place l'opérateur @@@." -#~ msgid "attempted change of parameter \"%s\" ignored" -#~ msgstr "tentative de modification du paramètre « %s » ignoré" +#~ msgid "unexpected delimiter at line %d of thesaurus file \"%s\"" +#~ msgstr "délimiteur inattendu sur la ligne %d du thesaurus « %s »" -#~ msgid "Sets the regular expression \"flavor\"." -#~ msgstr "Initialise l'expression rationnelle « flavor »." +#~ msgid "unexpected end of line or lexeme at line %d of thesaurus file \"%s\"" +#~ msgstr "fin de ligne ou de lexeme inattendu sur la ligne %d du thesaurus « %s »" -#~ msgid "Automatically adds missing table references to FROM clauses." -#~ msgstr "" -#~ "Ajoute automatiquement les références à la table manquant dans les clauses\n" -#~ "FROM." +#~ msgid "unexpected end of line at line %d of thesaurus file \"%s\"" +#~ msgstr "fin de ligne inattendue à la ligne %d du thésaurus « %s »" -#~ msgid "Table contains duplicated values." -#~ msgstr "La table contient des valeurs dupliquées." +#~ msgid "could not remove database directory \"%s\"" +#~ msgstr "n'a pas pu supprimer le répertoire de bases de données « %s »" -#~ msgid "index row size %lu exceeds btree maximum, %lu" -#~ msgstr "la taille de la ligne index %lu dépasse le maximum de btree, %lu" +#~ msgid "index \"%s\" is not ready" +#~ msgstr "l'index « %s » n'est pas prêt" -#~ msgid "DISTINCT is supported only for single-argument aggregates" -#~ msgstr "DISTINCT est seulement supporté pour les agrégats à un seul argument" +#~ msgid "argument number is out of range" +#~ msgstr "le nombre en argument est en dehors des limites" -#~ msgid "database system is in consistent recovery mode" -#~ msgstr "le système de bases de données est dans un mode de restauration cohérent" +#~ msgid "No rows were found in \"%s\"." +#~ msgstr "Aucune ligne trouvée dans « %s »." -#~ msgid "frame start at CURRENT ROW is not implemented" -#~ msgstr "début du frame à CURRENT ROW n'est pas implémenté" +#~ msgid "inconsistent use of year %04d and \"BC\"" +#~ msgstr "utilisation non cohérente de l'année %04d et de « BC »" -#~ msgid "Rebuild the index with REINDEX." -#~ msgstr "Reconstruisez l'index avec REINDEX." +#~ msgid "\"interval\" time zone \"%s\" not valid" +#~ msgstr "le fuseau horaire « %s » n'est pas valide pour le type « interval »" -#~ msgid "index \"%s\" contains %.0f row versions, but table contains %.0f row versions" -#~ msgstr "" -#~ "l'index « %s » contient %.0f versions de ligne, mais la table contient %.0f\n" -#~ "versions de ligne" +#~ msgid "Not enough memory for reassigning the prepared transaction's locks." +#~ msgstr "Pas assez de mémoire pour réaffecter les verrous des transactions préparées." -#~ msgid "" -#~ "%u index pages have been deleted, %u are currently reusable.\n" -#~ "%s." -#~ msgstr "" -#~ "%u pages d'index ont été supprimées, %u sont actuellement réutilisables.\n" -#~ "%s." +#~ msgid "large object %u was already dropped" +#~ msgstr "le « Large Object » %u a déjà été supprimé" -#~ msgid "\"%s\": moved %u row versions, truncated %u to %u pages" -#~ msgstr "« %s » : %u versions de ligne déplacées, %u pages tronquées sur %u" +#~ msgid "large object %u was not opened for writing" +#~ msgstr "le « Large Object » %u n'a pas été ouvert en écriture" -#~ msgid "" -#~ "%.0f dead row versions cannot be removed yet.\n" -#~ "Nonremovable row versions range from %lu to %lu bytes long.\n" -#~ "There were %.0f unused item pointers.\n" -#~ "Total free space (including removable row versions) is %.0f bytes.\n" -#~ "%u pages are or will become empty, including %u at the end of the table.\n" -#~ "%u pages containing %.0f free bytes are potential move destinations.\n" -#~ "%s." -#~ msgstr "" -#~ "%.0f versions de lignes mortes ne peuvent pas encore être supprimées.\n" -#~ "Les versions non supprimables de ligne vont de %lu to %lu octets.\n" -#~ "Il existait %.0f pointeurs d'éléments inutilisés.\n" -#~ "L'espace libre total (incluant les versions supprimables de ligne) est de\n" -#~ "%.0f octets.\n" -#~ "%u pages sont ou deviendront vides, ceci incluant %u pages en fin de la\n" -#~ "table.\n" -#~ "%u pages contenant %.0f octets libres sont des destinations de déplacement\n" -#~ "disponibles.\n" -#~ "%s." +#~ msgid "invalid standby query string: %s" +#~ msgstr "chaîne de requête invalide sur le serveur en attente : %s" -#~ msgid "relation \"%s\" TID %u/%u: DeleteTransactionInProgress %u --- cannot shrink relation" +#~ msgid "terminating walsender process to force cascaded standby to update timeline and reconnect" #~ msgstr "" -#~ "relation « %s », TID %u/%u : DeleteTransactionInProgress %u --- n'a pas pu\n" -#~ "diminuer la taille de la relation" +#~ "arrêt du processus walreceiver pour forcer le serveur standby en cascade à\n" +#~ "mettre à jour la timeline et à se reconnecter" -#~ msgid "relation \"%s\" TID %u/%u: InsertTransactionInProgress %u --- cannot shrink relation" -#~ msgstr "" -#~ "relation « %s », TID %u/%u : InsertTransactionInProgress %u --- n'a pas pu\n" -#~ "diminuer la taille de la relation" +#~ msgid "invalid standby handshake message type %d" +#~ msgstr "type %d du message de handshake du serveur en attente invalide" -#~ msgid "relation \"%s\" TID %u/%u: dead HOT-updated tuple --- cannot shrink relation" -#~ msgstr "" -#~ "relation « %s », TID %u/%u : ligne morte mise à jour par HOT --- n'a pas pu\n" -#~ "diminuer la taille de la relation" +#~ msgid "streaming replication successfully connected to primary" +#~ msgstr "réplication de flux connecté avec succès au serveur principal" -#~ msgid "relation \"%s\" TID %u/%u: XMIN_COMMITTED not set for transaction %u --- cannot shrink relation" +#~ msgid "shutdown requested, aborting active base backup" +#~ msgstr "arrêt demandé, annulation de la sauvegarde active de base" + +#~ msgid "terminating all walsender processes to force cascaded standby(s) to update timeline and reconnect" #~ msgstr "" -#~ "relation « %s », TID %u/%u : XMIN_COMMITTED non configuré pour la\n" -#~ "transaction %u --- n'a pas pu diminuer la taille de la relation" +#~ "arrêt de tous les processus walsender pour forcer les serveurs standby en\n" +#~ "cascade à mettre à jour la timeline et à se reconnecter" -#~ msgid "directory \"%s\" is not empty" -#~ msgstr "le répertoire « %s » n'est pas vide" +#~ msgid "" +#~ "This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter. You can either reduce the request size or reconfigure the kernel with larger SHMMAX. To reduce the request size (currently %lu bytes), reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.\n" +#~ "If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter, in which case raising the request size or reconfiguring SHMMIN is called for.\n" +#~ "The PostgreSQL documentation contains more information about shared memory configuration." +#~ msgstr "" +#~ "Cette erreur signifie habituellement que la demande de PostgreSQL pour un\n" +#~ "segment de mémoire partagée a dépassé le paramètre SHMMAX de votre noyau.\n" +#~ "Vous pouvez soit réduire la taille de la requête soit reconfigurer le noyau\n" +#~ "avec un SHMMAX plus important. Pour réduire la taille de la requête\n" +#~ "(actuellement %lu octets), réduisez l'utilisation de la mémoire partagée par PostgreSQL,par exemple en réduisant shared_buffers ou max_connections\n" +#~ "Si la taille de la requête est déjà petite, il est possible qu'elle soit\n" +#~ "moindre que le paramètre SHMMIN de votre noyau, auquel cas, augmentez la\n" +#~ "taille de la requête ou reconfigurez SHMMIN.\n" +#~ "La documentation de PostgreSQL contient plus d'informations sur la\n" +#~ "configuration de la mémoire partagée." -#~ msgid "number of distinct values %g is too low" -#~ msgstr "le nombre de valeurs distinctes %g est trop basse" +#~ msgid "cannot use window function in rule WHERE condition" +#~ msgstr "ne peut pas utiliser la fonction window dans la condition d'une règle WHERE" -#~ msgid "cannot truncate system relation \"%s\"" -#~ msgstr "ne peut pas tronquer la relation système « %s »" +#~ msgid "cannot use aggregate function in rule WHERE condition" +#~ msgstr "ne peut pas utiliser la fonction d'agrégat dans la condition d'une règle WHERE" -#~ msgid "shared table \"%s\" can only be reindexed in stand-alone mode" -#~ msgstr "la table partagée « %s » peut seulement être réindexé en mode autonome" +#~ msgid "arguments of row IN must all be row expressions" +#~ msgstr "les arguments de la ligne IN doivent tous être des expressions de ligne" -#~ msgid "\"%s\" is a system catalog" -#~ msgstr "« %s » est un catalogue système" +#~ msgid "argument of %s must not contain window functions" +#~ msgstr "l'argument de %s ne doit pas contenir des fonctions window" -#~ msgid "shared index \"%s\" can only be reindexed in stand-alone mode" -#~ msgstr "un index partagé « %s » peut seulement être réindexé en mode autonome" +#~ msgid "argument of %s must not contain aggregate functions" +#~ msgstr "l'argument de %s ne doit pas contenir de fonctions d'agrégats" -#~ msgid "Sets the language used in DO statement if LANGUAGE is not specified." +#~ msgid "cannot use window function in function expression in FROM" #~ msgstr "" -#~ "Configure le langage utilisé dans une instruction DO si la clause LANGUAGE n'est\n" -#~ "pas spécifiée." +#~ "ne peut pas utiliser la fonction window dans l'expression de la fonction\n" +#~ "du FROM" -#~ msgid "This error can also happen if the byte sequence does not match the encoding expected by the server, which is controlled by \"client_encoding\"." +#~ msgid "function expression in FROM cannot refer to other relations of same query level" #~ msgstr "" -#~ "Cette erreur peut aussi survenir si la séquence d'octets ne correspond pas\n" -#~ "au jeu de caractères attendu par le serveur, le jeu étant contrôlé par\n" -#~ "« client_encoding »." - -#~ msgid "redo starts at %X/%X, consistency will be reached at %X/%X" -#~ msgstr "la restauration comme à %X/%X, la cohérence sera atteinte à %X/%X" +#~ "l'expression de la fonction du FROM ne peut pas faire référence à d'autres\n" +#~ "relations sur le même niveau de la requête" -#~ msgid "binary value is out of range for type bigint" -#~ msgstr "la valeur binaire est en dehors des limites du type bigint" +#~ msgid "subquery in FROM cannot refer to other relations of same query level" +#~ msgstr "" +#~ "la sous-requête du FROM ne peut pas faire référence à d'autres relations\n" +#~ "dans le même niveau de la requête" -#~ msgid "transaction is read-only" -#~ msgstr "la transaction est en lecture seule" +#~ msgid "JOIN/ON clause refers to \"%s\", which is not part of JOIN" +#~ msgstr "la clause JOIN/ON se réfère à « %s », qui ne fait pas partie du JOIN" -#~ msgid "PID %d is among the slowest backends." -#~ msgstr "Le PID %d est parmi les processus serveur les plus lents." +#~ msgid "window functions not allowed in GROUP BY clause" +#~ msgstr "fonctions window non autorisées dans une clause GROUP BY" -#, fuzzy -#~ msgid "invalid WAL message received from primary" -#~ msgstr "format du message invalide" +#~ msgid "aggregates not allowed in WHERE clause" +#~ msgstr "agrégats non autorisés dans une clause WHERE" -#, fuzzy -#~ msgid "sorry, too many standbys already" -#~ msgstr "désolé, trop de clients sont déjà connectés" +#~ msgid "SELECT FOR UPDATE/SHARE cannot be used with foreign table \"%s\"" +#~ msgstr "SELECT FOR UPDATE/SHARE ne peut pas être utilisé avec une table distante « %s »" -#~ msgid "WAL file SYSID is %s, pg_control SYSID is %s" -#~ msgstr "le SYSID du journal de transactions WAL est %s, celui de pg_control est %s" +#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with window functions" +#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec les fonctions window" -#, fuzzy -#~ msgid "couldn't put socket to blocking mode: %m" -#~ msgstr "n'a pas pu activer le mode bloquant pour la socket : %s\n" +#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with aggregate functions" +#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec les fonctions d'agrégats" -#, fuzzy -#~ msgid "couldn't put socket to non-blocking mode: %m" -#~ msgstr "n'a pas pu activer le mode non-bloquant pour la socket : %s\n" +#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with HAVING clause" +#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec la clause HAVING" -#~ msgid "not enough shared memory for background writer" -#~ msgstr "pas assez de mémoire partagée pour le processus d'écriture en tâche de fond" +#~ msgid "SELECT FOR UPDATE/SHARE is not allowed with GROUP BY clause" +#~ msgstr "SELECT FOR UPDATE/SHARE n'est pas autorisé avec la clause GROUP BY" -#~ msgid "connection limit exceeded for non-superusers" -#~ msgstr "limite de connexions dépassée pour les utilisateurs standards" +#~ msgid "RETURNING cannot contain references to other relations" +#~ msgstr "RETURNING ne doit pas contenir de références à d'autres relations" -#~ msgid "not enough shared memory for walreceiver" -#~ msgstr "" -#~ "pas assez de mémoire partagée pour le processus de réception des journaux de\n" -#~ "transactions" +#~ msgid "cannot use window function in RETURNING" +#~ msgstr "ne peut pas utiliser une fonction window dans RETURNING" -#~ msgid "not enough shared memory for walsender" -#~ msgstr "pas assez de mémoire partagée pour le processus d'envoi des journaux de transactions" +#~ msgid "cannot use aggregate function in RETURNING" +#~ msgstr "ne peut pas utiliser une fonction d'agrégat dans RETURNING" -#~ msgid "unlogged operation performed, data may be missing" -#~ msgstr "opération réalisée non tracée, les données pourraient manquer" +#~ msgid "cannot use window function in UPDATE" +#~ msgstr "ne peut pas utiliser une fonction window dans un UPDATE" -#~ msgid "During recovery, allows connections and queries. During normal running, causes additional info to be written to WAL to enable hot standby mode on WAL standby nodes." -#~ msgstr "" -#~ "Lors de la restauration, autorise les connexions et les requêtes. Lors d'une\n" -#~ "exécution normale, fait que des informations supplémentaires sont écrites dans\n" -#~ "les journaux de transactions pour activer le mode Hot Standby sur les nÅ“uds\n" -#~ "en attente." +#~ msgid "cannot use aggregate function in UPDATE" +#~ msgstr "ne peut pas utiliser une fonction d'agrégat dans un UPDATE" -#~ msgid "archive_command must be defined before online backups can be made safely." -#~ msgstr "" -#~ "archive_command doit être défini avant que les sauvegardes à chaud puissent\n" -#~ "s'effectuer correctement." +#~ msgid "cannot use window function in VALUES" +#~ msgstr "ne peut pas utiliser la fonction window dans un VALUES" -#~ msgid "archive_mode must be enabled at server start." -#~ msgstr "archive_mode doit être activé au lancement du serveur." +#~ msgid "cannot use aggregate function in VALUES" +#~ msgstr "ne peut pas utiliser la fonction d'agrégat dans un VALUES" -#~ msgid "WAL archiving is not active" -#~ msgstr "l'archivage des journaux de transactions n'est pas actif" +#~ msgid "Use SELECT ... UNION ALL ... instead." +#~ msgstr "Utilisez à la place SELECT ... UNION ALL ..." -#~ msgid "usermap \"%s\"" -#~ msgstr "correspondance utilisateur « %s »" +#~ msgid "VALUES must not contain OLD or NEW references" +#~ msgstr "VALUES ne doit pas contenir des références à OLD et NEW" -#~ msgid "restartpoint_command = '%s'" -#~ msgstr "restartpoint_command = '%s'" +#~ msgid "VALUES must not contain table references" +#~ msgstr "VALUES ne doit pas contenir de références de table" -#~ msgid "recovery restart point at %X/%X with latest known log time %s" +#~ msgid "LDAP search failed for filter \"%s\" on server \"%s\": user is not unique (%ld matches)" #~ msgstr "" -#~ "point de relancement de la restauration sur %X/%X avec %s comme dernière\n" -#~ "date connue du journal" +#~ "échec de la recherche LDAP pour le filtre « %s » sur le serveur « %s » :\n" +#~ "utilisateur non unique (%ld correspondances)" -#~ msgid "Not safe to send CSV data\n" -#~ msgstr "Envoi non sûr des données CSV\n" +#~ msgid "You need an unconditional ON DELETE DO INSTEAD rule or an INSTEAD OF DELETE trigger." +#~ msgstr "Vous avez besoin d'une règle inconditionnelle ON DELETE DO INSTEAD ou d'un trigger INSTEAD OF DELETE." -#~ msgid "Sets the message levels that are logged during recovery." -#~ msgstr "Initialise les niveaux de messages qui sont tracés lors de la restauration." +#~ msgid "You need an unconditional ON UPDATE DO INSTEAD rule or an INSTEAD OF UPDATE trigger." +#~ msgstr "Vous avez besoin d'une règle non conditionnelle ON UPDATE DO INSTEAD ou d'un trigger INSTEAD OF UPDATE." -#~ msgid "parameter \"standby_mode\" requires a Boolean value" -#~ msgstr "le paramètre « standby_mode » requiert une valeur booléenne" +#~ msgid "You need an unconditional ON INSERT DO INSTEAD rule or an INSTEAD OF INSERT trigger." +#~ msgstr "Vous avez besoin d'une règle ON INSERT DO INSTEAD sans condition ou d'un trigger INSTEAD OF INSERT." -#~ msgid "parameter \"recovery_target_inclusive\" requires a Boolean value" -#~ msgstr "le paramètre « recovery_target_inclusive » requiert une valeur booléenne" +#~ msgid "automatic vacuum of table \"%s.%s.%s\": cannot (re)acquire exclusive lock for truncate scan" +#~ msgstr "vacuum automatique de la table « %s.%s.%s » : ne peut pas acquérir le verrou exclusif pour la tronquer" -#~ msgid "cannot drop \"%s\" because it is being used by active queries in this session" +#~ msgid "must be superuser to rename text search templates" +#~ msgstr "doit être super-utilisateur pour renommer les modèles de recherche plein texte" + +#~ msgid "must be superuser to rename text search parsers" #~ msgstr "" -#~ "ne peut pas supprimer « %s » car cet objet est en cours d'utilisation par\n" -#~ "des requêtes actives dans cette session" +#~ "doit être super-utilisateur pour renommer les analyseurs de recherche plein\n" +#~ "texte" -#~ msgid "unrecognized \"log_destination\" key word: \"%s\"" -#~ msgstr "mot clé « log_destination » non reconnu : « %s »" +#~ msgid "cannot use window function in trigger WHEN condition" +#~ msgstr "ne peut pas utiliser la fonction window dans la condition WHEN d'un trigger" -#~ msgid "invalid list syntax for parameter \"log_destination\"" -#~ msgstr "syntaxe de liste invalide pour le paramètre « log_destination »" +#~ msgid "Use ALTER FOREIGN TABLE instead." +#~ msgstr "Utilisez ALTER FOREIGN TABLE à la place." -#~ msgid "Sets immediate fsync at commit." -#~ msgstr "Configure un fsync immédiat lors du commit." +#~ msgid "cannot use window function in transform expression" +#~ msgstr "ne peut pas utiliser la fonction window dans l'expression de la transformation" -#~ msgid "could not open new log file \"%s\": %m" -#~ msgstr "n'a pas pu ouvrir le nouveau journal applicatif « %s » : %m" +#~ msgid "default values on foreign tables are not supported" +#~ msgstr "les valeurs par défaut ne sont pas supportées sur les tables distantes" -#~ msgid "could not create log file \"%s\": %m" -#~ msgstr "n'a pas pu créer le journal applicatif « %s » : %m" +#~ msgid "constraints on foreign tables are not supported" +#~ msgstr "les contraintes sur les tables distantes ne sont pas supportées" -#~ msgid "Ident authentication is not supported on local connections on this platform" -#~ msgstr "l'authentification Ident n'est pas supportée sur les connexions locales sur cette plateforme" +#~ msgid "cannot use window function in EXECUTE parameter" +#~ msgstr "ne peut pas utiliser une fonction window dans le paramètre EXECUTE" -#~ msgid "could not get effective UID from peer credentials: %m" -#~ msgstr "n'a pas pu obtenir l'UID réel à partir des pièces d'identité de l'autre : %m" +#~ msgid "cannot use aggregate in index predicate" +#~ msgstr "ne peut pas utiliser un agrégat dans un prédicat d'index" -#~ msgid "could not enable credential reception: %m" -#~ msgstr "n'a pas pu activer la réception de lettres de créance : %m" +#~ msgid "function \"%s\" already exists in schema \"%s\"" +#~ msgstr "la fonction « %s » existe déjà dans le schéma « %s »" -#~ msgid "argument to pg_get_expr() must come from system catalogs" -#~ msgstr "l'argument de pg_get_expr() doit provenir des catalogues systèmes" +#~ msgid "Use ALTER AGGREGATE to change owner of aggregate functions." +#~ msgstr "Utiliser ALTER AGGREGATE pour changer le propriétaire des fonctions d'agrégat." -#~ msgid "invalid interval value for time zone: day not allowed" -#~ msgstr "valeur d'intervalle invalide pour le fuseau horaire : jour non autorisé" +#~ msgid "Use ALTER AGGREGATE to rename aggregate functions." +#~ msgstr "Utiliser ALTER AGGREGATE pour renommer les fonctions d'agrégat." -#~ msgid "invalid interval value for time zone: month not allowed" -#~ msgstr "valeur d'intervalle invalide pour le fuseau horaire : les mois ne sont pas autorisés" +#~ msgid "cannot use window function in parameter default value" +#~ msgstr "ne peut pas utiliser la fonction window dans la valeur par défaut d'un paramètre" -#~ msgid "unrecognized \"datestyle\" key word: \"%s\"" -#~ msgstr "mot clé « datestyle » non reconnu : « %s »" +#~ msgid "cannot use aggregate function in parameter default value" +#~ msgstr "" +#~ "ne peut pas utiliser une fonction d'agrégat dans la valeur par défaut d'un\n" +#~ "paramètre" -#~ msgid "invalid list syntax for parameter \"datestyle\"" -#~ msgstr "syntaxe de liste invalide pour le paramètre « datestyle »" +#~ msgid "cannot use subquery in parameter default value" +#~ msgstr "ne peut pas utiliser une sous-requête dans une valeur par défaut d'un paramètre" -#~ msgid "database \"%s\" not found" -#~ msgstr "base de données « %s » non trouvée" +#~ msgid "CREATE TABLE AS specifies too many column names" +#~ msgstr "CREATE TABLE AS spécifie trop de noms de colonnes" -#~ msgid "composite type must have at least one attribute" -#~ msgstr "le type composite doit avoir au moins un attribut" +#~ msgid "%s already exists in schema \"%s\"" +#~ msgstr "%s existe déjà dans le schéma « %s »" -#~ msgid "cannot reference permanent table from temporary table constraint" +#~ msgid "A function returning ANYRANGE must have at least one ANYRANGE argument." #~ msgstr "" -#~ "ne peut pas référencer une table permanente à partir de la contrainte de\n" -#~ "table temporaire" +#~ "Une fonction renvoyant ANYRANGE doit avoir au moins un argument du type\n" +#~ "ANYRANGE." -#~ msgid "cannot reference temporary table from permanent table constraint" -#~ msgstr "" -#~ "ne peut pas référencer une table temporaire à partir d'une contrainte de\n" -#~ "table permanente" +#~ msgid "cannot use window function in check constraint" +#~ msgstr "ne peut pas utiliser une fonction window dans une contrainte de vérification" -#~ msgid "function \"%s\" is already in schema \"%s\"" -#~ msgstr "la fonction « %s » existe déjà dans le schéma « %s »" +#~ msgid "cannot use window function in default expression" +#~ msgstr "ne peut pas utiliser une fonction window dans une expression par défaut" -#~ msgid "must be superuser to comment on text search template" -#~ msgstr "" -#~ "doit être super-utilisateur pour ajouter un commentaire sur un modèle de\n" -#~ "recherche plein texte" +#~ msgid "cannot use aggregate function in default expression" +#~ msgstr "ne peut pas utiliser une fonction d'agrégat dans une expression par défaut" -#~ msgid "must be superuser to comment on text search parser" -#~ msgstr "" -#~ "doit être super-utilisateur pour ajouter un commentaire sur l'analyseur de\n" -#~ "recherche plein texte" +#~ msgid "cannot use subquery in default expression" +#~ msgstr "ne peut pas utiliser une sous-requête dans l'expression par défaut" -#~ msgid "must be superuser to comment on procedural language" -#~ msgstr "" -#~ "doit être super-utilisateur pour ajouter un commentaire sur un langage de\n" -#~ "procédures" +#~ msgid "uncataloged table %s" +#~ msgstr "table %s sans catalogue" -#~ msgid "\"%s\" is not a table, view, or composite type" -#~ msgstr "« %s » n'est pas une table, une vue ou un type composite" +#~ msgid "xrecoff \"%X\" is out of valid range, 0..%X" +#~ msgstr "xrecoff « %X » en dehors des limites valides, 0..%X" -#~ msgid "cannot cluster on expressional index \"%s\" because its index access method does not handle null values" -#~ msgstr "" -#~ "ne peut pas exécuter CLUSTER sur l'index à expression « %s » car sa méthode\n" -#~ "d'accès ne gère pas les valeurs NULL" +#~ msgid "Incorrect XLOG_BLCKSZ in page header." +#~ msgstr "XLOG_BLCKSZ incorrect dans l'en-tête de page." -#~ msgid "You might be able to work around this by marking column \"%s\" NOT NULL." -#~ msgstr "Vous pouvez contourner ceci en marquant la colonne « %s » comme NOT NULL." +#~ msgid "Incorrect XLOG_SEG_SIZE in page header." +#~ msgstr "XLOG_SEG_SIZE incorrecte dans l'en-tête de page." -#~ msgid "You might be able to work around this by marking column \"%s\" NOT NULL, or use ALTER TABLE ... SET WITHOUT CLUSTER to remove the cluster specification from the table." +#~ msgid "invalid contrecord length %u in log file %u, segment %u, offset %u" #~ msgstr "" -#~ "Vous pourriez contourner ceci en marquant la colonne « %s » avec la\n" -#~ "contrainte NOT NULL ou en utilisant ALTER TABLE ... SET WITHOUT CLUSTER pour\n" -#~ "supprimer la spécification CLUSTER de la table." +#~ "longueur invalide du « contrecord » %u dans le journal de tranasctions %u,\n" +#~ "segment %u, décalage %u" -#~ msgid "cannot cluster on index \"%s\" because access method does not handle null values" +#~ msgid "there is no contrecord flag in log file %u, segment %u, offset %u" #~ msgstr "" -#~ "ne peut pas créer un cluster sur l'index « %s » car la méthode d'accès de\n" -#~ "l'index ne gère pas les valeurs NULL" +#~ "il n'y a pas de drapeaux « contrecord » dans le journal de transactions %u,\n" +#~ "segment %u, décalage %u" -#~ msgid "clustering \"%s.%s\"" -#~ msgstr "exécution de CLUSTER sur « %s.%s »" +#~ msgid "could not open file \"%s\" (log file %u, segment %u): %m" +#~ msgstr "n'a pas pu ouvrir le fichier « %s » (journal de transactions %u, segment %u) : %m" -#~ msgid "EnumValuesCreate() can only set a single OID" -#~ msgstr "EnumValuesCreate() peut seulement initialiser un seul OID" +#~ msgid "unlogged GiST indexes are not supported" +#~ msgstr "les index GiST non tracés ne sont pas supportés" -#~ msgid "index \"%s\" needs VACUUM FULL or REINDEX to finish crash recovery" -#~ msgstr "" -#~ "l'index « %s » a besoin d'un VACUUM FULL ou d'un REINDEX pour terminer la\n" -#~ "récupération suite à un arrêt brutal" +#~ msgid "could not change directory to \"%s\"" +#~ msgstr "n'a pas pu accéder au répertoire « %s »" -#~ msgid "index \"%s\" needs VACUUM or REINDEX to finish crash recovery" -#~ msgstr "" -#~ "l'index « %s » a besoin d'un VACUUM ou d'un REINDEX pour terminer la\n" -#~ "récupération suite à un arrêt brutal" +#~ msgid "Perhaps out of disk space?" +#~ msgstr "Peut-être manquez-vous de place disque ?" -#~ msgid "Incomplete insertion detected during crash replay." +#~ msgid "time zone offset %d is not a multiple of 900 sec (15 min) in time zone file \"%s\", line %d" #~ msgstr "" -#~ "Insertion incomplète détectée lors de la ré-exécution des requêtes suite à\n" -#~ "l'arrêt brutal." +#~ "le décalage %d du fuseau horaire n'est pas un multiples de 900 secondes\n" +#~ "(15 minutes) dans le fichier des fuseaux horaires « %s », ligne %d" -#~ msgid "index %u/%u/%u needs VACUUM FULL or REINDEX to finish crash recovery" -#~ msgstr "" -#~ "l'index %u/%u/%u a besoin d'un VACUUM FULL ou d'un REINDEX pour terminer la\n" -#~ "récupération suite à un arrêt brutal" +#~ msgid "Sets the name of the Kerberos service." +#~ msgstr "Initialise le nom du service Kerberos." -#~ msgid "Lines should have the format parameter = 'value'." -#~ msgstr "Les lignes devraient avoir le format paramètre = 'valeur'" +#~ msgid "No description available." +#~ msgstr "Aucune description disponible." -#~ msgid "syntax error in recovery command file: %s" -#~ msgstr "erreur de syntaxe dans le fichier de restauration : %s" +#~ msgid "cannot call json_populate_recordset on a nested object" +#~ msgstr "ne peut pas appeler json_populate_recordset sur un objet imbriqué" -#~ msgid "Write-Ahead Log / Streaming Replication" -#~ msgstr "Write-Ahead Log / Réplication en flux" +#~ msgid "cannot call json_populate_recordset on a scalar" +#~ msgstr "ne peut pas appeler json_populate_recordset sur un scalaire" -#~ msgid "unable to open directory pg_tblspc: %m" -#~ msgstr "impossible d'ouvrir le répertoire p_tblspc : %m" +#~ msgid "cannot call json_populate_recordset with nested arrays" +#~ msgstr "ne peut pas appeler json_populate_recordset avec des tableaux imbriqués" -#~ msgid "unable to read symbolic link %s: %m" -#~ msgstr "incapable de lire le lien symbolique %s : %m" +#~ msgid "must call json_populate_recordset on an array of objects" +#~ msgstr "doit appeler json_populate_recordset sur un tableau d'objets" -#~ msgid "index \"%s\" is not a b-tree" -#~ msgstr "l'index « %s » n'est pas un btree" +#~ msgid "cannot call json_populate_recordset with nested objects" +#~ msgstr "ne peut pas appeler json_populate_recordset sur des objets imbriqués" -#~ msgid "ALTER TYPE USING is only supported on plain tables" -#~ msgstr "ALTER TYPE USING est seulement supportés sur les tables standards" +#~ msgid "cannot call json_populate_recordset on an object" +#~ msgstr "ne peut pas appeler json_populate_recordset sur un objet" -#~ msgid "resetting unlogged relations: cleanup %d init %d" -#~ msgstr "réinitialisation des relations non tracées : nettoyage %d initialisation %d" +#~ msgid "first argument of json_populate_recordset must be a row type" +#~ msgstr "le premier argument de json_populate_recordset doit être un type ROW" -#~ msgid "%s (%x)" -#~ msgstr "%s (%x)" +#~ msgid "first argument of json_populate_record must be a row type" +#~ msgstr "le premier argument de json_populate_record doit être un type ROW" -#~ msgid "SSPI error %x" -#~ msgstr "erreur SSPI : %x" +#~ msgid "cannot call json_array_elements on a scalar" +#~ msgstr "ne peut pas appeler json_array_elements sur un scalaire" -#~ msgid "consistent state delayed because recovery snapshot incomplete" -#~ msgstr "état de cohérence pas encore atteint à cause d'un snapshot de restauration incomplet" +#~ msgid "cannot call json_array_elements on a non-array" +#~ msgstr "ne peut pas appeler json_array_elements sur un objet qui n'est pas un tableau" -#~ msgid "tablespace %u is not empty" -#~ msgstr "le tablespace %u n'est pas vide" +#~ msgid "cannot extract field from a non-object" +#~ msgstr "ne peut pas extraire le chemin à partir d'un non-objet" -#~ msgid "subquery in WITH cannot have SELECT INTO" -#~ msgstr "la sous-requête du WITH ne peut pas avoir de SELECT INTO" +#~ msgid "cannot extract array element from a non-array" +#~ msgstr "ne peut pas extraire un élément du tableau à partir d'un objet qui n'est pas un tableau" -#~ msgid "subquery cannot have SELECT INTO" -#~ msgstr "la sous-requête ne peut pas avoir de SELECT INTO" +#~ msgid "cannot call function with empty path elements" +#~ msgstr "ne peut pas appeler une fonction avec des éléments chemins vides" -#~ msgid "subquery in FROM cannot have SELECT INTO" -#~ msgstr "la sous-requête du FROM ne peut pas avoir de SELECT INTO" +#~ msgid "cannot call function with null path elements" +#~ msgstr "ne peut pas appeler une fonction avec des éléments chemins NULL" -#~ msgid "DECLARE CURSOR cannot specify INTO" -#~ msgstr "DECLARE CURSOR ne peut pas spécifier INTO" +#~ msgid "cannot call json_object_keys on a scalar" +#~ msgstr "ne peut pas appeler json_object_keys sur un scalaire" -#~ msgid "INSERT ... SELECT cannot specify INTO" -#~ msgstr "INSERT ... SELECT ne peut pas avoir INTO" +#~ msgid "cannot call json_object_keys on an array" +#~ msgstr "ne peut pas appeler json_object_keys sur un tableau" -#~ msgid "column name list not allowed in CREATE TABLE / AS EXECUTE" -#~ msgstr "la liste de noms de colonnes n'est pas autorisée dans CREATE TABLE / AS EXECUTE" +#~ msgid "missing assignment operator" +#~ msgstr "opérateur d'affectation manquant" -#~ msgid "CREATE TABLE AS cannot specify INTO" -#~ msgstr "CREATE TABLE AS ne peut pas spécifier INTO" +#~ msgid "wrong affix file format for flag" +#~ msgstr "mauvais format de fichier affixe pour le drapeau" -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version affiche la version, puis quitte\n" +#~ msgid "Views that return the same column more than once are not automatically updatable." +#~ msgstr "Les vues qui renvoient la même colonne plus d'une fois ne sont pas automatiquement disponibles en écriture." -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help affiche cette aide, puis quitte\n" +#~ msgid "Security-barrier views are not automatically updatable." +#~ msgstr "Les vues avec barrière de sécurité ne sont pas automatiquement disponibles en écriture." -#~ msgid "Make sure the root.crt file is present and readable." -#~ msgstr "Assurez-vous que le certificat racine (root.crt) est présent et lisible" +#~ msgid "Expected 1 tuple with 3 fields, got %d tuples with %d fields." +#~ msgstr "Attendait 1 ligne avec 3 champs, a obtenu %d lignes avec %d champs." -#~ msgid "See server log for details." -#~ msgstr "Voir les journaux applicatifs du serveur pour plus de détails." +#~ msgid "too many column aliases specified for function %s" +#~ msgstr "trop d'alias de colonnes spécifiées pour la fonction %s" -#~ msgid "missing or erroneous pg_hba.conf file" -#~ msgstr "fichier pg_hba.conf manquant ou erroné" +#~ msgid "%s: could not determine user name (GetUserName failed)\n" +#~ msgstr "%s : n'a pas pu déterminer le nom de l'utilisateur (GetUserName a échoué)\n" -#~ msgid "Certificates will not be checked against revocation list." -#~ msgstr "Les certificats ne seront pas vérifiés avec la liste de révocation." +#~ msgid "%s: invalid effective UID: %d\n" +#~ msgstr "%s : UID effectif invalide : %d\n" -#~ msgid "SSL certificate revocation list file \"%s\" not found, skipping: %s" -#~ msgstr "liste de révocation des certificats SSL « %s » introuvable, continue : %s" +#~ msgid "krb5 authentication is not supported on local sockets" +#~ msgstr "" +#~ "l'authentification krb5 n'est pas supportée sur les connexions locales par\n" +#~ "socket" -#~ msgid "could not access root certificate file \"%s\": %m" -#~ msgstr "n'a pas pu accéder au fichier du certificat racine « %s » : %m" +#~ msgid "SSL renegotiation failure" +#~ msgstr "échec lors de la re-négotiation SSL" -#~ msgid "could not open directory \"pg_tblspc\": %m" -#~ msgstr "n'a pas pu ouvrir le répertoire « pg_tblspc » : %m" +#~ msgid "local user with ID %d does not exist" +#~ msgstr "l'utilisateur local dont l'identifiant est %d n'existe pas" -#~ msgid "standby connections not allowed because wal_level=minimal" -#~ msgstr "connexions standby non autorisées car wal_level=minimal" +#~ msgid "Kerberos unparse_name returned error %d" +#~ msgstr "unparse_name de Kerberos a renvoyé l'erreur %d" -#~ msgid "recovery is still in progress, can't accept WAL streaming connections" -#~ msgstr "la restauration est en cours, ne peut pas accepter les connexions de flux WAL" +#~ msgid "Kerberos recvauth returned error %d" +#~ msgstr "recvauth de Kerberos a renvoyé l'erreur %d" -#~ msgid "must be superuser to drop text search templates" -#~ msgstr "doit être super-utilisateur pour supprimer des modèles de recherche plein texte" +#~ msgid "Kerberos sname_to_principal(\"%s\", \"%s\") returned error %d" +#~ msgstr "sname_to_principal(« %s », « %s ») de Kerberos a renvoyé l'erreur %d" -#~ msgid "must be superuser to drop text search parsers" -#~ msgstr "" -#~ "doit être super-utilisateur pour supprimer des analyseurs de recherche plein\n" -#~ "texte" +#~ msgid "Kerberos keytab resolving returned error %d" +#~ msgstr "la résolution keytab de Kerberos a renvoyé l'erreur %d" -#~ msgid "Must be superuser to drop a foreign-data wrapper." -#~ msgstr "Doit être super-utilisateur pour supprimer un wrapper de données distantes." +#~ msgid "Kerberos initialization returned error %d" +#~ msgstr "l'initialisation de Kerberos a retourné l'erreur %d" -#~ msgid "permission denied to drop foreign-data wrapper \"%s\"" -#~ msgstr "droit refusé pour supprimer le wrapper de données distantes « %s »" +#~ msgid "Kerberos 5 authentication failed for user \"%s\"" +#~ msgstr "authentification Kerberos 5 échouée pour l'utilisateur « %s »" -#~ msgid "removing built-in function \"%s\"" -#~ msgstr "suppression de la fonction interne « %s »" +#~ msgid "trigger \"%s\" for table \"%s\" does not exist, skipping" +#~ msgstr "le trigger « %s » pour la table « %s » n'existe pas, poursuite du traitement" -#~ msgid "foreign key constraint \"%s\" of relation \"%s\" does not exist" -#~ msgstr "la clé étrangère « %s » de la relation « %s » n'existe pas" +#~ msgid "invalid input syntax for transaction log location: \"%s\"" +#~ msgstr "syntaxe invalide en entrée pour l'emplacement du journal de transactions : « %s »" -#~ msgid "Sets the list of known custom variable classes." -#~ msgstr "Initialise la liste des classes variables personnalisées connues." +#~ msgid "could not parse transaction log location \"%s\"" +#~ msgstr "n'a pas pu analyser l'emplacement du journal des transactions « %s »" -#~ msgid "WAL sender sleep time between WAL replications." +#~ msgid "%s \"%s\": return code %d" +#~ msgstr "%s « %s » : code de retour %d" + +#~ msgid "assertion checking is not supported by this build" +#~ msgstr "la vérification de l'assertion n'a pas été intégrée lors de la compilation" + +#~ msgid "SET AUTOCOMMIT TO OFF is no longer supported" +#~ msgstr "SET AUTOCOMMIT TO OFF n'est plus supporté" + +#~ msgid "Set the amount of traffic to send and receive before renegotiating the encryption keys." #~ msgstr "" -#~ "Temps d'endormissement du processus d'envoi des journaux de transactions entre\n" -#~ "les réplications des journaux de transactions." +#~ "Configure la quantité de trafic à envoyer et recevoir avant la renégotiation\n" +#~ "des clés d'enchiffrement." -#~ msgid "If this parameter is set, the server will automatically run in the background and any controlling terminals are dissociated." +#~ msgid "Sets the maximum distance in log segments between automatic WAL checkpoints." #~ msgstr "" -#~ "Si ce paramètre est initialisé, le serveur sera exécuté automatiquement en\n" -#~ "tâche de fond et les terminaux de contrôles seront dés-associés." +#~ "Initialise la distance maximale dans les journaux de transaction entre chaque\n" +#~ "point de vérification (checkpoints) des journaux." -#~ msgid "Runs the server silently." -#~ msgstr "Lance le serveur de manière silencieuse." +#~ msgid "It's just here so that we won't choke on SET AUTOCOMMIT TO ON from 7.3-vintage clients." +#~ msgstr "" +#~ "C'est ici uniquement pour ne pas avoir de problèmes avec le SET AUTOCOMMIT\n" +#~ "TO ON des clients 7.3." -#~ msgid "%s: could not dissociate from controlling TTY: %s\n" -#~ msgstr "%s : n'a pas pu se dissocier du TTY contrôlant : %s\n" +#~ msgid "This parameter doesn't do anything." +#~ msgstr "Ce paramètre ne fait rien." -#~ msgid "%s: could not fork background process: %s\n" -#~ msgstr "%s : n'a pas pu créer un processus fils : %s\n" +#~ msgid "This is a debugging aid." +#~ msgstr "C'est une aide de débogage." -#~ msgid "%s: could not open log file \"%s/%s\": %s\n" -#~ msgstr "%s : n'a pas pu ouvrir le journal applicatif « %s/%s » : %s\n" +#~ msgid "Turns on various assertion checks." +#~ msgstr "Active les différentes vérifications des assertions." -#~ msgid "%s: could not open file \"%s\": %s\n" -#~ msgstr "%s : n'a pas pu ouvrir le fichier « %s » : %s\n" +#~ msgid "cannot accept a value of type pg_node_tree" +#~ msgstr "ne peut pas accepter une valeur de type pg_node_tree" -#~ msgid "select() failed in logger process: %m" -#~ msgstr "échec de select() dans le processus des journaux applicatifs : %m" +#~ msgid "must be superuser or have the same role to terminate other server processes" +#~ msgstr "" +#~ "doit être super-utilisateur ou avoir le même rôle pour fermer les connexions\n" +#~ "exécutées dans les autres processus serveur" -#~ msgid "poll() failed in statistics collector: %m" -#~ msgstr "échec du poll() dans le récupérateur de statistiques : %m" +#~ msgid "must be superuser or have the same role to cancel queries running in other server processes" +#~ msgstr "" +#~ "doit être super-utilisateur ou avoir le même rôle pour annuler des requêtes\n" +#~ "exécutées dans les autres processus serveur" -#~ msgid "Valid values are '[]', '[)', '(]', and '()'." -#~ msgstr "Les valeurs valides sont « [] », « [) », « (] » et « () »." +#~ msgid "invalid symbol" +#~ msgstr "symbole invalide" -#~ msgid "invalid list syntax for \"unix_socket_directories\"" -#~ msgstr "syntaxe de liste invalide pour le paramètre « unix_socket_directories »" +#~ msgid "unexpected \"=\"" +#~ msgstr "« = » inattendu" -#~ msgid "invalid list syntax for \"listen_addresses\"" -#~ msgstr "syntaxe de liste invalide pour le paramètre « listen_addresses »" +#~ msgid "neither input type is an array" +#~ msgstr "aucun type de données n'est un tableau" -#~ msgid "window functions cannot use named arguments" -#~ msgstr "les fonctions window ne peuvent pas renvoyer des arguments nommés" +#~ msgid "could not determine input data types" +#~ msgstr "n'a pas pu déterminer les types de données en entrée" -#~ msgid "cannot override frame clause of window \"%s\"" -#~ msgstr "ne peut pas surcharger la frame clause du window « %s »" +#~ msgid "archive member \"%s\" too large for tar format" +#~ msgstr "membre « %s » de l'archive trop volumineux pour le format tar" -#~ msgid "JSON does not support infinite timestamp values." -#~ msgstr "JSON ne supporte pas les valeurs infinies de timestamp." +#~ msgid "postmaster became multithreaded" +#~ msgstr "le postmaster est devenu multithreadé" -#~ msgid "JSON does not support infinite date values." -#~ msgstr "JSON ne supporte pas les valeurs infinies de date." +#~ msgid "invalid value for parameter \"replication\"" +#~ msgstr "valeur invalide pour le paramètre « replication »" -#~ msgid "WAL writer sleep time between WAL flushes." +#~ msgid "WAL archival (archive_mode=on) requires wal_level \"archive\", \"hot_standby\", or \"logical\"" #~ msgstr "" -#~ "Temps d'endormissement du processus d'écriture pendant le vidage des\n" -#~ "journaux de transactions en millisecondes." +#~ "l'archivage des journaux de transactions (archive_mode=on) nécessite que\n" +#~ "le paramètre wal_level soit initialisé avec « archive », « hot_standby » ou « logical »" -#~ msgid "could not convert to time zone \"%s\"" -#~ msgstr "n'a pas pu convertir vers le fuseau horaire « %s »" +#~ msgid "Consider increasing the configuration parameter \"checkpoint_segments\"." +#~ msgstr "Considèrez l'augmentation du paramètre « checkpoint_segments »." -#~ msgid "argument for function \"exp\" too big" -#~ msgstr "l'argument de la fonction « exp » est trop gros" +#~ msgid "subquery must return a column" +#~ msgstr "la sous-requête doit renvoyer une colonne" -#~ msgid "must be superuser to rotate log files" -#~ msgstr "doit être super-utilisateur pour exécuter la rotation des journaux applicatifs" +#~ msgid " -A 1|0 enable/disable run-time assert checking\n" +#~ msgstr "" +#~ " -A 1|0 active/désactive la vérification des limites (assert) à\n" +#~ " l'exécution\n" -#~ msgid "must be superuser to signal the postmaster" -#~ msgstr "doit être super-utilisateur pour envoyer un signal au postmaster" +#~ msgid "%s: setsysinfo failed: %s\n" +#~ msgstr "%s : setsysinfo a échoué : %s\n" -#~ msgid "could not format \"circle\" value" -#~ msgstr "n'a pas pu formater la valeur « circle »" +#~ msgid "could not set socket to blocking mode: %m" +#~ msgstr "n'a pas pu activer le mode bloquant pour la socket : %m" -#~ msgid "invalid input syntax for type circle: \"%s\"" -#~ msgstr "syntaxe en entrée invalide pour le type circle : « %s »" +#~ msgid "SSL failed to renegotiate connection before limit expired" +#~ msgstr "SSL a échoué à renégotier la connexion avant l'expiration du délai" -#~ msgid "invalid input syntax for type polygon: \"%s\"" -#~ msgstr "syntaxe en entrée invalide pour le type polygon : « %s »" +#~ msgid "could not complete SSL handshake on renegotiation, too many failures" +#~ msgstr "n'a pas pu terminer la poignée de main de renégotiation, trop d'échecs" -#~ msgid "invalid input syntax for type lseg: \"%s\"" -#~ msgstr "syntaxe en entrée invalide pour le type lseg : « %s »" +#~ msgid "SSL handshake failure on renegotiation, retrying" +#~ msgstr "échec du handshake SSL lors de la renégotiation, nouvelle tentative" -#~ msgid "invalid input syntax for type point: \"%s\"" -#~ msgstr "syntaxe en entrée invalide pour le type point : « %s »" +#~ msgid "SSL failure during renegotiation start" +#~ msgstr "échec SSL au début de la re-négotiation" -#~ msgid "invalid input syntax for type path: \"%s\"" -#~ msgstr "syntaxe en entrée invalide pour le type path : « %s »" +#~ msgid "received password packet" +#~ msgstr "paquet du mot de passe reçu" -#~ msgid "invalid input syntax for type line: \"%s\"" -#~ msgstr "syntaxe en entrée invalide pour le type line: « %s »" +#~ msgid "interval precision specified twice" +#~ msgstr "précision d'intervalle spécifiée deux fois" -#~ msgid "invalid input syntax for type box: \"%s\"" -#~ msgstr "syntaxe en entrée invalide pour le type box : « %s »" +#~ msgid "" +#~ "%.0f dead row versions cannot be removed yet.\n" +#~ "There were %.0f unused item pointers.\n" +#~ "%u pages are entirely empty.\n" +#~ "%s." +#~ msgstr "" +#~ "%.0f versions de lignes mortes ne peuvent pas encore être supprimées.\n" +#~ "Il y avait %.0f pointeurs d'éléments inutilisés.\n" +#~ "%u pages sont entièrement vides.\n" +#~ "%s." -#~ msgid "could not format \"path\" value" -#~ msgstr "n'a pas pu formater la valeur « path »" +#~ msgid "" +#~ "automatic vacuum of table \"%s.%s.%s\": index scans: %d\n" +#~ "pages: %d removed, %d remain\n" +#~ "tuples: %.0f removed, %.0f remain, %.0f are dead but not yet removable\n" +#~ "buffer usage: %d hits, %d misses, %d dirtied\n" +#~ "avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n" +#~ "system usage: %s" +#~ msgstr "" +#~ "VACUUM automatique de la table « %s.%s.%s » : parcours d'index : %d\n" +#~ "pages : %d supprimées, %d restantes\n" +#~ "lignes : %.0f supprimées, %.0f restantes, %.0f sont mortes mais non supprimables\n" +#~ "utilisation des tampons : %d lus dans le cache, %d lus hors du cache, %d modifiés\n" +#~ "taux moyen de lecture : %.3f Mo/s, taux moyen d'écriture : %.3f Mo/s\n" +#~ "utilisation système : %s" -#~ msgid "multibyte flag character is not allowed" -#~ msgstr "un caractère drapeau multi-octet n'est pas autorisé" +#~ msgid "Specify a USING expression to perform the conversion." +#~ msgstr "Donnez une expression USING pour réaliser la conversion." -#~ msgid "socket not open" -#~ msgstr "socket non ouvert" +#~ msgid "\"%s\" is not a table, materialized view, composite type, or foreign table" +#~ msgstr "« %s » n'est ni une table, ni une vue matérialisée, ni un type composite, ni une table distante" -#~ msgid "must be superuser to reset statistics counters" -#~ msgstr "doit être super-utilisateur pour réinitialiser les compteurs statistiques" +#~ msgid "inherited relation \"%s\" is not a table" +#~ msgstr "la relation héritée « %s » n'est pas une table" -#~ msgid "function %s must return type \"tsm_handler\"" -#~ msgstr "la fonction %s doit renvoyer le type « tsm_handler »" +#~ msgid "This name may be disallowed altogether in future versions of PostgreSQL." +#~ msgstr "Ce nom pourrait être interdit dans les prochaines versions de PostgreSQL." -#~ msgid "Permissions should be u=rw (0600) or less." -#~ msgstr "Les droits devraient être u=rwx (0600) ou inférieures." +#~ msgid "=> is deprecated as an operator name" +#~ msgstr "=> est un nom d'opérateur obsolète" -#~ msgid "typmod_in function %s must return type \"integer\"" -#~ msgstr "la fonction typmod_in %s doit renvoyer le type « entier »" +#~ msgid "WAL file is from different database system: Incorrect XLOG_BLCKSZ in page header." +#~ msgstr "" +#~ "le journal de transactions provient d'un système de bases de données différent :\n" +#~ "XLOG_BLCKSZ incorrect dans l'en-tête de page." -#~ msgid "type send function %s must return type \"bytea\"" -#~ msgstr "la fonction send du type %s doit renvoyer le type « bytea »" +#~ msgid "WAL file is from different database system: Incorrect XLOG_SEG_SIZE in page header." +#~ msgstr "" +#~ "le journal de transactions provient d'un système de bases de données différent :\n" +#~ "XLOG_SEG_SIZE incorrect dans l'en-tête de page." -#~ msgid "type output function %s must return type \"cstring\"" -#~ msgstr "le type de sortie de la fonction %s doit être « cstring »" +#~ msgid "WAL file is from different database system: WAL file database system identifier is %s, pg_control database system identifier is %s." +#~ msgstr "" +#~ "L'identifiant du journal de transactions du système de base de données est %s,\n" +#~ "l'identifiant pg_control du système de base de données dans pg_control est %s." -#~ msgid "changing return type of function %s from \"opaque\" to \"cstring\"" -#~ msgstr "changement du type de retour de la fonction %s d'« opaque » vers « cstring »" +#~ msgid "incorrect total length in record at %X/%X" +#~ msgstr "longueur totale incorrecte à l'enregistrement %X/%X" -#~ msgid "function %s must return type \"trigger\"" -#~ msgstr "la fonction %s doit renvoyer le type « trigger »" +#~ msgid "incorrect hole size in record at %X/%X" +#~ msgstr "taille du trou incorrect à l'enregistrement %X/%X" -#~ msgid "function %s must return type \"language_handler\"" -#~ msgstr "la fonction %s doit renvoyer le type « language_handler »" +#~ msgid "invalid backup block size in record at %X/%X" +#~ msgstr "taille du bloc de sauvegarde invalide dans l'enregistrement à %X/%X" -#~ msgid "could not reposition held cursor" -#~ msgstr "n'a pas pu repositionner le curseur détenu" +#~ msgid "record with zero length at %X/%X" +#~ msgstr "enregistrement de longueur nulle à %X/%X" -#~ msgid "function %s must return type \"fdw_handler\"" -#~ msgstr "la fonction %s doit renvoyer le type « fdw_handler »" +#~ msgid "invalid xlog switch record at %X/%X" +#~ msgstr "enregistrement de basculement du journal de transaction invalide à %X/%X" -#~ msgid "function \"%s\" must return type \"event_trigger\"" -#~ msgstr "la fonction « %s » doit renvoyer le type « event_trigger »" +#~ msgid "oldest unfrozen transaction ID: %u, in database %u" +#~ msgstr "" +#~ "identifiant de transaction non gelé le plus ancien : %u, dans la base de\n" +#~ "données %u" -#~ msgid "%s is already in schema \"%s\"" -#~ msgstr "%s existe déjà dans le schéma « %s »" +#~ msgid "next MultiXactId: %u; next MultiXactOffset: %u" +#~ msgstr "prochain MultiXactId : %u ; prochain MultiXactOffset : %u" -#~ msgid "invalid record length at %X/%X" -#~ msgstr "longueur invalide de l'enregistrement à %X/%X" +#~ msgid "next transaction ID: %u/%u; next OID: %u" +#~ msgstr "prochain identifiant de transaction : %u/%u ; prochain OID : %u" -#~ msgid "must be superuser to control recovery" -#~ msgstr "doit être super-utilisateur pour contrôler la restauration" +#~ msgid "redo record is at %X/%X; shutdown %s" +#~ msgstr "l'enregistrement à ré-exécuter se trouve à %X/%X ; arrêt %s" -#~ msgid "must be superuser to create a restore point" -#~ msgstr "doit être super-utilisateur pour créer un point de restauration" +#~ msgid "invalid value for recovery parameter \"recovery_target\"" +#~ msgstr "valeur invalide pour le paramètre de restauration « recovery_target »" -#~ msgid "must be superuser to switch transaction log files" -#~ msgstr "doit être super-utilisateur pour changer de journal de transactions" +#~ msgid "unrecognized win32 error code: %lu" +#~ msgstr "code d'erreur win32 non reconnu : %lu" -#~ msgid "must be superuser or replication role to run a backup" -#~ msgstr "doit être super-utilisateur ou avoir l'attribut de réplication pour exécuter une sauvegarde" +#~ msgid "mapped win32 error code %lu to %d" +#~ msgstr "correspondance du code d'erreur win32 %lu en %d" -#~ msgid "ignoring \"%s\" file because no \"%s\" file exists" -#~ msgstr "ignore le fichier « %s » parce que le fichier « %s » n'existe pas" +#~ msgid "too few arguments for format" +#~ msgstr "trop peu d'arguments pour le format" -#~ msgid "could not rename file \"%s\" to \"%s\" (initialization of log file): %m" -#~ msgstr "n'a pas pu renommer le fichier « %s » en « %s » (initialisation du journal de transactions) : %m" +#~ msgid "invalid length in external \"numeric\" value" +#~ msgstr "longueur invalide dans la valeur externe « numeric »" -#~ msgid "could not link file \"%s\" to \"%s\" (initialization of log file): %m" -#~ msgstr "n'a pas pu lier le fichier « %s » à « %s » (initialisation du journal de transactions) : %m" +#~ msgid "time zone abbreviation \"%s\" is not used in time zone \"%s\"" +#~ msgstr "l'abréviation « %s » du fuseau horaire n'est pas utilisée dans le fuseau horaire « %s »" -#~ msgid "could not close two-phase state file \"%s\": %m" -#~ msgstr "" -#~ "n'a pas pu fermer le fichier d'état de la validation en deux phases nommé\n" -#~ "« %s » : %m" +#~ msgid "role \"%s\" is reserved" +#~ msgstr "le rôle « %s » est réservé" -#~ msgid "could not fsync two-phase state file \"%s\": %m" -#~ msgstr "" -#~ "n'a pas pu synchroniser sur disque (fsync) le fichier d'état de la\n" -#~ "validation en deux phases nommé « %s » : %m" +#~ msgid "system columns cannot be used in an ON CONFLICT clause" +#~ msgstr "les colonnes systèmes ne peuvent pas être utilisées dans une clause ON CONFLICT" -#~ msgid "two-phase state file for transaction %u is corrupt" +#~ msgid "function returning set of rows cannot return null value" #~ msgstr "" -#~ "le fichier d'état de la validation en deux phases est corrompu pour la\n" -#~ "transaction %u" +#~ "la fonction renvoyant un ensemble de lignes ne peut pas renvoyer une valeur\n" +#~ "NULL" -#~ msgid "could not seek in two-phase state file: %m" +#~ msgid "Only superusers can use untrusted languages." #~ msgstr "" -#~ "n'a pas pu se déplacer dans le fichier de statut de la validation en deux\n" -#~ "phases : %m" +#~ "Seuls les super-utilisateurs peuvent utiliser des langages qui ne sont pas\n" +#~ "de confiance." -#~ msgid "could not create two-phase state file \"%s\": %m" -#~ msgstr "" -#~ "n'a pas pu créer le fichier de statut de la validation en deux phases nommé\n" -#~ "« %s » : %m" +#~ msgid "huge TLB pages not supported on this platform" +#~ msgstr "Huge Pages TLB non supporté sur cette plateforme." + +#~ msgid "Lower bound of dimension array must be one." +#~ msgstr "La limite inférieure du tableau doit valoir un." + +#~ msgid "wrong range of array subscripts" +#~ msgstr "mauvais échelle des indices du tableau" diff --git a/src/backend/po/it.po b/src/backend/po/it.po index 393ed954ae..3c3af1403f 100644 --- a/src/backend/po/it.po +++ b/src/backend/po/it.po @@ -16,8 +16,8 @@ msgid "" msgstr "" "Project-Id-Version: postgres (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:08+0000\n" -"PO-Revision-Date: 2016-04-17 20:26+0100\n" +"POT-Creation-Date: 2017-02-09 21:08+0000\n" +"PO-Revision-Date: 2017-04-23 02:19+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -26,7 +26,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" "X-Poedit-SourceCharset: utf-8\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" #: ../common/config_info.c:131 ../common/config_info.c:139 #: ../common/config_info.c:147 ../common/config_info.c:155 @@ -36,8 +36,8 @@ msgstr "" msgid "not recorded" msgstr "non registrato" -#: ../common/controldata_utils.c:52 commands/copy.c:2798 -#: commands/extension.c:3120 utils/adt/genfile.c:134 +#: ../common/controldata_utils.c:52 commands/copy.c:2833 +#: commands/extension.c:3141 utils/adt/genfile.c:134 #, c-format msgid "could not open file \"%s\" for reading: %m" msgstr "apertura del file \"%s\" in lettura fallita: %m" @@ -48,13 +48,13 @@ msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: apertura del file \"%s\" in lettura fallita: %s\n" #: ../common/controldata_utils.c:66 access/transam/timeline.c:346 -#: access/transam/xlog.c:3193 access/transam/xlog.c:10338 -#: access/transam/xlog.c:10351 access/transam/xlog.c:10714 -#: access/transam/xlog.c:10757 access/transam/xlog.c:10796 -#: access/transam/xlog.c:10839 access/transam/xlogfuncs.c:666 -#: access/transam/xlogfuncs.c:685 commands/extension.c:3130 +#: access/transam/xlog.c:3220 access/transam/xlog.c:10423 +#: access/transam/xlog.c:10436 access/transam/xlog.c:10828 +#: access/transam/xlog.c:10871 access/transam/xlog.c:10910 +#: access/transam/xlog.c:10953 access/transam/xlogfuncs.c:665 +#: access/transam/xlogfuncs.c:684 commands/extension.c:3151 #: replication/logical/origin.c:665 replication/logical/origin.c:695 -#: replication/logical/reorderbuffer.c:3077 replication/walsender.c:499 +#: replication/logical/reorderbuffer.c:3099 replication/walsender.c:499 #: storage/file/copydir.c:176 utils/adt/genfile.c:151 #, c-format msgid "could not read file \"%s\": %m" @@ -163,28 +163,30 @@ msgid "could not close directory \"%s\": %s\n" msgstr "chiusura della directory \"%s\" fallita: %s\n" #: ../common/psprintf.c:179 ../port/path.c:630 ../port/path.c:668 -#: ../port/path.c:685 access/transam/twophase.c:1261 -#: access/transam/xlog.c:6069 lib/stringinfo.c:258 libpq/auth.c:847 -#: libpq/auth.c:1210 libpq/auth.c:1278 libpq/auth.c:1794 -#: postmaster/bgworker.c:289 postmaster/bgworker.c:797 -#: postmaster/postmaster.c:2323 postmaster/postmaster.c:2354 -#: postmaster/postmaster.c:3886 postmaster/postmaster.c:4576 -#: postmaster/postmaster.c:4644 postmaster/postmaster.c:5343 -#: postmaster/postmaster.c:5596 replication/logical/logical.c:170 -#: storage/buffer/localbuf.c:422 storage/file/fd.c:729 storage/file/fd.c:1126 -#: storage/file/fd.c:1244 storage/file/fd.c:1916 storage/ipc/procarray.c:1060 -#: storage/ipc/procarray.c:1546 storage/ipc/procarray.c:1553 -#: storage/ipc/procarray.c:1967 storage/ipc/procarray.c:2570 -#: utils/adt/formatting.c:1523 utils/adt/formatting.c:1643 -#: utils/adt/formatting.c:1764 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 -#: utils/adt/varlena.c:4461 utils/fmgr/dfmgr.c:216 utils/hash/dynahash.c:431 -#: utils/hash/dynahash.c:537 utils/hash/dynahash.c:1049 utils/mb/mbutils.c:376 -#: utils/mb/mbutils.c:709 utils/misc/guc.c:3885 utils/misc/guc.c:3901 -#: utils/misc/guc.c:3914 utils/misc/guc.c:6859 utils/misc/tzparser.c:470 -#: utils/mmgr/aset.c:505 utils/mmgr/mcxt.c:770 utils/mmgr/mcxt.c:805 -#: utils/mmgr/mcxt.c:842 utils/mmgr/mcxt.c:879 utils/mmgr/mcxt.c:913 -#: utils/mmgr/mcxt.c:942 utils/mmgr/mcxt.c:976 utils/mmgr/mcxt.c:1058 -#: utils/mmgr/mcxt.c:1092 utils/mmgr/mcxt.c:1141 +#: ../port/path.c:685 access/transam/twophase.c:1262 access/transam/xlog.c:6108 +#: lib/stringinfo.c:258 libpq/auth.c:850 libpq/auth.c:1213 libpq/auth.c:1281 +#: libpq/auth.c:1797 postmaster/bgworker.c:289 postmaster/bgworker.c:796 +#: postmaster/postmaster.c:2335 postmaster/postmaster.c:2366 +#: postmaster/postmaster.c:3899 postmaster/postmaster.c:4589 +#: postmaster/postmaster.c:4664 postmaster/postmaster.c:5339 +#: postmaster/postmaster.c:5603 +#: replication/libpqwalreceiver/libpqwalreceiver.c:143 +#: replication/logical/logical.c:168 storage/buffer/localbuf.c:436 +#: storage/file/fd.c:729 storage/file/fd.c:1126 storage/file/fd.c:1244 +#: storage/file/fd.c:1916 storage/ipc/procarray.c:1061 +#: storage/ipc/procarray.c:1547 storage/ipc/procarray.c:1554 +#: storage/ipc/procarray.c:1968 storage/ipc/procarray.c:2571 +#: utils/adt/formatting.c:1522 utils/adt/formatting.c:1642 +#: utils/adt/formatting.c:1763 utils/adt/pg_locale.c:463 +#: utils/adt/pg_locale.c:647 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 +#: utils/adt/varlena.c:4461 utils/fmgr/dfmgr.c:216 utils/hash/dynahash.c:429 +#: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1047 utils/mb/mbutils.c:376 +#: utils/mb/mbutils.c:709 utils/misc/guc.c:3888 utils/misc/guc.c:3904 +#: utils/misc/guc.c:3917 utils/misc/guc.c:6863 utils/misc/tzparser.c:468 +#: utils/mmgr/aset.c:509 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 +#: utils/mmgr/mcxt.c:839 utils/mmgr/mcxt.c:876 utils/mmgr/mcxt.c:910 +#: utils/mmgr/mcxt.c:939 utils/mmgr/mcxt.c:973 utils/mmgr/mcxt.c:1055 +#: utils/mmgr/mcxt.c:1089 utils/mmgr/mcxt.c:1138 #, c-format msgid "out of memory" msgstr "memoria esaurita" @@ -249,7 +251,7 @@ msgstr "rimozione del file o directory \"%s\" fallita: %s\n" msgid "could not look up effective user ID %ld: %s" msgstr "ID utente effettivo %ld non trovato: %s" -#: ../common/username.c:47 libpq/auth.c:1741 +#: ../common/username.c:47 libpq/auth.c:1744 msgid "user does not exist" msgstr "l'utente non esiste" @@ -293,18 +295,17 @@ msgstr "processo figlio terminato da segnale %d" msgid "child process exited with unrecognized status %d" msgstr "processo figlio uscito con stato non riconosciuto %d" -#: ../port/chklocale.c:259 +#: ../port/chklocale.c:293 #, c-format msgid "could not determine encoding for codeset \"%s\"" msgstr "determinazione della codifica per il codeset \"%s\" fallita" -#: ../port/chklocale.c:260 ../port/chklocale.c:389 -#: postmaster/postmaster.c:4876 +#: ../port/chklocale.c:294 ../port/chklocale.c:423 postmaster/postmaster.c:4868 #, c-format msgid "Please report this to ." msgstr "Per favore segnala questo problema a ." -#: ../port/chklocale.c:381 ../port/chklocale.c:387 +#: ../port/chklocale.c:415 ../port/chklocale.c:421 #, c-format msgid "could not determine encoding for locale \"%s\": codeset is \"%s\"" msgstr "non è stato possibile determinare una codifica per il locale \"%s\": il codeset è \"%s\"" @@ -362,71 +363,86 @@ msgstr "determinazione della directory corrente fallita: %s\n" msgid "unrecognized error %d" msgstr "errore sconosciuto %d" -#: access/brin/brin.c:817 +#: ../port/win32security.c:68 +#, c-format +msgid "could not open process token: error code %lu\n" +msgstr "apertura del token di processo fallita: codice di errore %lu\n" + +#: ../port/win32security.c:89 +#, c-format +msgid "could not get SID for Administrators group: error code %lu\n" +msgstr "lettura del SID del gruppo Amministratori fallita: codice di errore %lu\n" + +#: ../port/win32security.c:99 +#, c-format +msgid "could not get SID for PowerUsers group: error code %lu\n" +msgstr "lettura del SID del gruppo PowerUsers fallita: codice di errore %lu\n" + +#: access/brin/brin.c:810 #, c-format msgid "\"%s\" is not a BRIN index" msgstr "\"%s\" non è un indice BRIN" -#: access/brin/brin.c:833 +#: access/brin/brin.c:826 #, c-format msgid "could not open parent table of index %s" msgstr "apertura della tabella dell'indice %s non riuscita" -#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:369 -#: access/brin/brin_pageops.c:844 +#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:362 +#: access/brin/brin_pageops.c:828 #, c-format msgid "index row size %lu exceeds maximum %lu for index \"%s\"" msgstr "la dimensione %lu della riga dell'indice supera il massimo %lu per l'indice \"%s\"" -#: access/brin/brin_revmap.c:456 +#: access/brin/brin_revmap.c:459 #, c-format msgid "unexpected page type 0x%04X in BRIN index \"%s\" block %u" msgstr "tipo di pagina inaspettato 0x%04X nell'indice BRIN \"%s\" blocco %u" #: access/brin/brin_validate.c:115 #, c-format -msgid "brin opfamily %s contains function %s with invalid support number %d" -msgstr "la famiglia di operatori brin %s contiene la funzione %s con numero di supporto non valido %d" +msgid "brin operator family \"%s\" contains function %s with invalid support number %d" +msgstr "la famiglia di operatori brin \"%s\" contiene la funzione %s con numero di supporto non valido %d" #: access/brin/brin_validate.c:131 #, c-format -msgid "brin opfamily %s contains function %s with wrong signature for support number %d" -msgstr "la famiglia di operatori brin %s contiene la funzione %s con signature non valida per il numero di supporto %d" +msgid "brin operator family \"%s\" contains function %s with wrong signature for support number %d" +msgstr "la famiglia di operatori brin \"%s\" contiene la funzione %s con signature non valida per il numero di supporto %d" #: access/brin/brin_validate.c:153 #, c-format -msgid "brin opfamily %s contains operator %s with invalid strategy number %d" -msgstr "la famiglia di operatori brin %s contiene la funzione %s con numero di strategia non valido %d" +msgid "brin operator family \"%s\" contains operator %s with invalid strategy number %d" +msgstr "la famiglia di operatori brin \"%s\" contiene la funzione %s con numero di strategia non valido %d" #: access/brin/brin_validate.c:182 #, c-format -msgid "brin opfamily %s contains invalid ORDER BY specification for operator %s" -msgstr "la famiglia di operatori brin %s contiene una specifica ORDER BY non valida per l'operatore %s" +msgid "brin operator family \"%s\" contains invalid ORDER BY specification for operator %s" +msgstr "la famiglia di operatori brin \"%s\" contiene una specifica ORDER BY non valida per l'operatore %s" #: access/brin/brin_validate.c:195 #, c-format -msgid "brin opfamily %s contains operator %s with wrong signature" -msgstr "la famiglia di operatori brin %s contiene l'operatore %s con signature non valida" +msgid "brin operator family \"%s\" contains operator %s with wrong signature" +msgstr "la famiglia di operatori brin \"%s\" contiene l'operatore %s con signature non valida" #: access/brin/brin_validate.c:233 #, c-format -msgid "brin opfamily %s is missing operator(s) for types %s and %s" -msgstr "alla famiglia di operatori brin %s mancano operatori per i tipi %s e %s" +msgid "brin operator family \"%s\" is missing operator(s) for types %s and %s" +msgstr "alla famiglia di operatori brin \"%s\" mancano operatori per i tipi %s e %s" #: access/brin/brin_validate.c:243 #, c-format -msgid "brin opfamily %s is missing support function(s) for types %s and %s" -msgstr "alla famiglia di operatori brin %s mancano funzioni di supporto per i tipi %s e %s" +msgid "brin operator family \"%s\" is missing support function(s) for types %s and %s" +msgstr "alla famiglia di operatori brin \"%s\" mancano funzioni di supporto per i tipi %s e %s" #: access/brin/brin_validate.c:256 #, c-format -msgid "brin opclass %s is missing operator(s)" -msgstr "alla classe di operatori brin %s mancano operatori" +msgid "brin operator class \"%s\" is missing operator(s)" +msgstr "alla classe di operatori brin \"%s\" mancano operatori" #: access/brin/brin_validate.c:267 #, c-format -msgid "brin opclass %s is missing support function %d" -msgstr "alla classe di operatori brin %s manca la funzione di supporto %d" +msgid "brin operator class \"%s\" is missing support function %d" +msgstr "alla classe di operatori brin \"%s\" manca la funzione di supporto %d" #: access/common/heaptuple.c:708 access/common/heaptuple.c:1339 #, c-format @@ -438,68 +454,68 @@ msgstr "il numero di colonne (%d) eccede il limite (%d)" msgid "number of index columns (%d) exceeds limit (%d)" msgstr "il numero delle colonne dell'indice (%d) eccede il limite (%d)" -#: access/common/indextuple.c:176 access/spgist/spgutils.c:646 +#: access/common/indextuple.c:176 access/spgist/spgutils.c:642 #, c-format msgid "index row requires %zu bytes, maximum size is %zu" msgstr "la riga dell'indice richiede %zu byte, la dimensione massima è %zu" -#: access/common/printtup.c:294 tcop/fastpath.c:182 tcop/fastpath.c:544 -#: tcop/postgres.c:1721 +#: access/common/printtup.c:292 tcop/fastpath.c:182 tcop/fastpath.c:544 +#: tcop/postgres.c:1719 #, c-format msgid "unsupported format code: %d" msgstr "codice di formato non supportato: %d" -#: access/common/reloptions.c:488 +#: access/common/reloptions.c:493 #, c-format msgid "user-defined relation parameter types limit exceeded" msgstr "è stato superato il limite per i tipi di parametro per la relazione definita dall'utente" -#: access/common/reloptions.c:770 +#: access/common/reloptions.c:775 #, c-format msgid "RESET must not include values for parameters" msgstr "RESET non deve contenere valori per i parametri" -#: access/common/reloptions.c:803 +#: access/common/reloptions.c:808 #, c-format msgid "unrecognized parameter namespace \"%s\"" msgstr "parametro del namespace \"%s\" sconosciuto" -#: access/common/reloptions.c:1045 parser/parse_clause.c:281 +#: access/common/reloptions.c:1050 parser/parse_clause.c:281 #, c-format msgid "unrecognized parameter \"%s\"" msgstr "parametro \"%s\" non identificato" -#: access/common/reloptions.c:1075 +#: access/common/reloptions.c:1080 #, c-format msgid "parameter \"%s\" specified more than once" msgstr "parametro \"%s\" specificato più di una volta" -#: access/common/reloptions.c:1091 +#: access/common/reloptions.c:1096 #, c-format msgid "invalid value for boolean option \"%s\": %s" msgstr "valore non valido per l'opzione booleana \"%s\": %s" -#: access/common/reloptions.c:1103 +#: access/common/reloptions.c:1108 #, c-format msgid "invalid value for integer option \"%s\": %s" msgstr "valore non valido per l'opzione intera \"%s\": %s" -#: access/common/reloptions.c:1109 access/common/reloptions.c:1129 +#: access/common/reloptions.c:1114 access/common/reloptions.c:1134 #, c-format msgid "value %s out of bounds for option \"%s\"" msgstr "il valore %s non rientra nei limiti previsti per l'opzione \"%s\"" -#: access/common/reloptions.c:1111 +#: access/common/reloptions.c:1116 #, c-format msgid "Valid values are between \"%d\" and \"%d\"." msgstr "I valori validi sono quelli compresi fra \"%d\" e \"%d\"." -#: access/common/reloptions.c:1123 +#: access/common/reloptions.c:1128 #, c-format msgid "invalid value for floating point option \"%s\": %s" msgstr "valore non valido per l'opzione in virgola mobile \"%s\": %s" -#: access/common/reloptions.c:1131 +#: access/common/reloptions.c:1136 #, c-format msgid "Valid values are between \"%f\" and \"%f\"." msgstr "I valori validi sono quelli compresi fra \"%f\" e \"%f\"." @@ -514,17 +530,17 @@ msgstr "Il tipo restituito %s non corrisponde al tipo attesto %s nella colonna % msgid "Number of returned columns (%d) does not match expected column count (%d)." msgstr "il numero di colonne restituito (%d) non coincide col numero di colonne atteso (%d)" -#: access/common/tupconvert.c:241 +#: access/common/tupconvert.c:314 #, c-format msgid "Attribute \"%s\" of type %s does not match corresponding attribute of type %s." msgstr "L'attributo \"%s\" di tipo %s non combacia con l'attributo corrispondente di tipo %s." -#: access/common/tupconvert.c:253 +#: access/common/tupconvert.c:326 #, c-format msgid "Attribute \"%s\" of type %s does not exist in type %s." msgstr "L'attributo \"%s\" di tipo %s non esiste nel tipo %s." -#: access/common/tupdesc.c:635 parser/parse_relation.c:1517 +#: access/common/tupdesc.c:635 parser/parse_relation.c:1518 #, c-format msgid "column \"%s\" cannot be declared SETOF" msgstr "la colonna \"%s\" non può essere dichiarata SETOF" @@ -536,105 +552,105 @@ msgstr "la lista di posting è troppo lunga" #: access/gin/ginbulk.c:45 #, c-format -msgid "Reduce maintenance_work_mem" -msgstr "Riduci maintenance_work_mem" +msgid "Reduce maintenance_work_mem." +msgstr "Riduci maintenance_work_mem." -#: access/gin/ginentrypage.c:109 access/gist/gist.c:1354 -#: access/nbtree/nbtinsert.c:575 access/nbtree/nbtsort.c:488 -#: access/spgist/spgdoinsert.c:1915 +#: access/gin/ginentrypage.c:109 access/gist/gist.c:1337 +#: access/nbtree/nbtinsert.c:576 access/nbtree/nbtsort.c:488 +#: access/spgist/spgdoinsert.c:1907 #, c-format msgid "index row size %zu exceeds maximum %zu for index \"%s\"" msgstr "la dimensione %zu della riga dell'indice supera il massimo %zu per l'indice \"%s\"" -#: access/gin/ginfast.c:979 access/transam/xlog.c:9795 -#: access/transam/xlog.c:10266 access/transam/xlogfuncs.c:294 -#: access/transam/xlogfuncs.c:321 access/transam/xlogfuncs.c:360 -#: access/transam/xlogfuncs.c:381 access/transam/xlogfuncs.c:402 -#: access/transam/xlogfuncs.c:472 access/transam/xlogfuncs.c:528 +#: access/gin/ginfast.c:989 access/transam/xlog.c:9858 +#: access/transam/xlog.c:10362 access/transam/xlogfuncs.c:293 +#: access/transam/xlogfuncs.c:320 access/transam/xlogfuncs.c:359 +#: access/transam/xlogfuncs.c:380 access/transam/xlogfuncs.c:401 +#: access/transam/xlogfuncs.c:471 access/transam/xlogfuncs.c:527 #, c-format msgid "recovery is in progress" msgstr "il ripristino è in corso" -#: access/gin/ginfast.c:980 +#: access/gin/ginfast.c:990 #, c-format msgid "GIN pending list cannot be cleaned up during recovery." msgstr "La lista GIN in attesa non può essere completata durante il recupero." -#: access/gin/ginfast.c:987 +#: access/gin/ginfast.c:997 #, c-format msgid "\"%s\" is not a GIN index" msgstr "\"%s\" non è un indice GIN" -#: access/gin/ginfast.c:998 +#: access/gin/ginfast.c:1008 #, c-format msgid "cannot access temporary indexes of other sessions" msgstr "non è possibile accedere ad indici temporanei di altre sessioni" -#: access/gin/ginscan.c:409 +#: access/gin/ginscan.c:405 #, c-format msgid "old GIN indexes do not support whole-index scans nor searches for nulls" msgstr "i vecchi indici GIN non supportano le scansioni sull'intero indice né le ricerche di null" -#: access/gin/ginscan.c:410 +#: access/gin/ginscan.c:406 #, c-format msgid "To fix this, do REINDEX INDEX \"%s\"." msgstr "Per correggere questo problema esegui REINDEX INDEX \"%s\"." #: access/gin/ginvalidate.c:92 #, c-format -msgid "gin opfamily %s contains support procedure %s with cross-type registration" -msgstr "la famiglia di operatori gin %s contiene la procedura di supporto %s con tipi misti" +msgid "gin operator family \"%s\" contains support procedure %s with cross-type registration" +msgstr "la famiglia di operatori gin \"%s\" contiene la procedura di supporto %s con tipi misti" #: access/gin/ginvalidate.c:148 #, c-format -msgid "gin opfamily %s contains function %s with invalid support number %d" -msgstr "la famiglia di operatori gin %s contiene la funzione %s con numero di supporto non valido %d" +msgid "gin operator family \"%s\" contains function %s with invalid support number %d" +msgstr "la famiglia di operatori gin \"%s\" contiene la funzione %s con numero di supporto non valido %d" #: access/gin/ginvalidate.c:160 #, c-format -msgid "gin opfamily %s contains function %s with wrong signature for support number %d" -msgstr "la famiglia di operatori gin %s contiene la funzione %s con signature non valida per il numero di supporto %d" +msgid "gin operator family \"%s\" contains function %s with wrong signature for support number %d" +msgstr "la famiglia di operatori gin \"%s\" contiene la funzione %s con signature non valida per il numero di supporto %d" #: access/gin/ginvalidate.c:179 #, c-format -msgid "gin opfamily %s contains operator %s with invalid strategy number %d" -msgstr "la famiglia di operatori gin %s contiene l'operatore %s con numero di strategia non valida %d" +msgid "gin operator family \"%s\" contains operator %s with invalid strategy number %d" +msgstr "la famiglia di operatori gin \"%s\" contiene l'operatore %s con numero di strategia non valido %d" #: access/gin/ginvalidate.c:192 #, c-format -msgid "gin opfamily %s contains invalid ORDER BY specification for operator %s" -msgstr "la famiglia di operatori gin %s contiene una specifica ORDER BY non valida per l'operatore %s" +msgid "gin operator family \"%s\" contains invalid ORDER BY specification for operator %s" +msgstr "la famiglia di operatori gin \"%s\" contiene una specifica ORDER BY non valida per l'operatore %s" #: access/gin/ginvalidate.c:205 #, c-format -msgid "gin opfamily %s contains operator %s with wrong signature" -msgstr "la famiglia di operatori gin %s contiene l'operatore %s con signature non valida" +msgid "gin operator family \"%s\" contains operator %s with wrong signature" +msgstr "la famiglia di operatori gin \"%s\" contiene l'operatore %s con signature non valida" #: access/gin/ginvalidate.c:246 #, c-format -msgid "gin opclass %s is missing support function %d" -msgstr "alla classe di operatori gin %s manca la funzione di supporto %d" +msgid "gin operator class \"%s\" is missing support function %d" +msgstr "alla classe di operatori gin \"%s\" manca la funzione di supporto %d" #: access/gin/ginvalidate.c:256 #, c-format -msgid "gin opclass %s is missing support function %d or %d" -msgstr "alla classe di operatori gin %s mancano le funzioni di supporto %d o %d" +msgid "gin operator class \"%s\" is missing support function %d or %d" +msgstr "alla classe di operatori gin \"%s\" mancano le funzioni di supporto %d o %d" -#: access/gist/gist.c:692 access/gist/gistvacuum.c:258 +#: access/gist/gist.c:680 access/gist/gistvacuum.c:258 #, c-format msgid "index \"%s\" contains an inner tuple marked as invalid" msgstr "l'indice \"%s\" contiene una tupla interna marcata come invalida" -#: access/gist/gist.c:694 access/gist/gistvacuum.c:260 +#: access/gist/gist.c:682 access/gist/gistvacuum.c:260 #, c-format msgid "This is caused by an incomplete page split at crash recovery before upgrading to PostgreSQL 9.1." msgstr "Ciò è causato da una separazione di pagina incompleta al ripristino del crash prima dell'aggiornamento a PostgreSQL 9.1." -#: access/gist/gist.c:695 access/gist/gistutil.c:735 -#: access/gist/gistutil.c:746 access/gist/gistvacuum.c:261 -#: access/hash/hashutil.c:172 access/hash/hashutil.c:183 -#: access/hash/hashutil.c:195 access/hash/hashutil.c:216 -#: access/nbtree/nbtpage.c:518 access/nbtree/nbtpage.c:529 +#: access/gist/gist.c:683 access/gist/gistutil.c:738 access/gist/gistutil.c:749 +#: access/gist/gistvacuum.c:261 access/hash/hashutil.c:172 +#: access/hash/hashutil.c:183 access/hash/hashutil.c:195 +#: access/hash/hashutil.c:216 access/nbtree/nbtpage.c:518 +#: access/nbtree/nbtpage.c:529 #, c-format msgid "Please REINDEX it." msgstr "Si richiede l'esecuzione di REINDEX." @@ -664,13 +680,13 @@ msgstr "il metodo picksplit per la colonna %d dell'indice \"%s\" è fallito" msgid "The index is not optimal. To optimize it, contact a developer, or try to use the column as the second one in the CREATE INDEX command." msgstr "L'indice non è ottimale. Per ottimizzarlo si contatti uno sviluppatore o si usi la colonna ponendola in seconda posizione nel comando CREATE INDEX." -#: access/gist/gistutil.c:732 access/hash/hashutil.c:169 +#: access/gist/gistutil.c:735 access/hash/hashutil.c:169 #: access/nbtree/nbtpage.c:515 #, c-format msgid "index \"%s\" contains unexpected zero page at block %u" msgstr "l'indice \"%s\" contiene una pagina inaspettata completamente a zero al blocco %u" -#: access/gist/gistutil.c:743 access/hash/hashutil.c:180 +#: access/gist/gistutil.c:746 access/hash/hashutil.c:180 #: access/hash/hashutil.c:192 access/nbtree/nbtpage.c:526 #, c-format msgid "index \"%s\" contains corrupted page at block %u" @@ -678,56 +694,56 @@ msgstr "l'indice \"%s\" contiene una pagina corrotta al blocco %u" #: access/gist/gistvalidate.c:92 #, c-format -msgid "gist opfamily %s contains support procedure %s with cross-type registration" -msgstr "la famiglia di operatori gist %s contiene la procedura di supporto %s con tipi misti" +msgid "gist operator family \"%s\" contains support procedure %s with cross-type registration" +msgstr "la famiglia di operatori gist \"%s\" contiene la procedura di supporto %s con tipi misti" #: access/gist/gistvalidate.c:145 #, c-format -msgid "gist opfamily %s contains function %s with invalid support number %d" -msgstr "la famiglia di operatori gist %s contiene la funzione %s con numero di supporto non valido %d" +msgid "gist operator family \"%s\" contains function %s with invalid support number %d" +msgstr "la famiglia di operatori gist \"%s\" contiene la funzione %s con numero di supporto non valido %d" #: access/gist/gistvalidate.c:157 #, c-format -msgid "gist opfamily %s contains function %s with wrong signature for support number %d" -msgstr "la famiglia di operatori gist %s contiene la funzione %s con signature non valida per il numero di supporto %d" +msgid "gist operator family \"%s\" contains function %s with wrong signature for support number %d" +msgstr "la famiglia di operatori gist \"%s\" contiene la funzione %s con signature non valida per il numero di supporto %d" #: access/gist/gistvalidate.c:177 #, c-format -msgid "gist opfamily %s contains operator %s with invalid strategy number %d" -msgstr "la famiglia di operatori gist %s contiene l'operatore %s con numero di strategia non valida %d" +msgid "gist operator family \"%s\" contains operator %s with invalid strategy number %d" +msgstr "la famiglia di operatori gist \"%s\" contiene l'operatore %s con numero di strategia non valido %d" #: access/gist/gistvalidate.c:195 #, c-format -msgid "gist opfamily %s contains unsupported ORDER BY specification for operator %s" -msgstr "la famiglia di operatori gist %s contiene una specifica ORDER BY non supportata per l'operatore %s" +msgid "gist operator family \"%s\" contains unsupported ORDER BY specification for operator %s" +msgstr "la famiglia di operatori gist \"%s\" contiene una specifica ORDER BY non supportata per l'operatore %s" #: access/gist/gistvalidate.c:206 #, c-format -msgid "gist opfamily %s contains incorrect ORDER BY opfamily specification for operator %s" -msgstr "la famiglia di operatori gist %s contiene una specifica ORDER BY non corretta per l'operatore %s" +msgid "gist operator family \"%s\" contains incorrect ORDER BY opfamily specification for operator %s" +msgstr "la famiglia di operatori gist \"%s\" contiene una specifica ORDER BY non corretta per l'operatore %s" #: access/gist/gistvalidate.c:225 #, c-format -msgid "gist opfamily %s contains operator %s with wrong signature" -msgstr "la famiglia di operatori gist %s contiene l'operatore %s con signature non valida" +msgid "gist operator family \"%s\" contains operator %s with wrong signature" +msgstr "la famiglia di operatori gist \"%s\" contiene l'operatore %s con signature non valida" #: access/gist/gistvalidate.c:264 #, c-format -msgid "gist opclass %s is missing support function %d" -msgstr "alla classe di operatori gist %s manca la funzione di supporto %d" +msgid "gist operator class \"%s\" is missing support function %d" +msgstr "-alla classe di operatori gist \"%s\" manca la funzione di supporto %d" -#: access/hash/hashinsert.c:69 +#: access/hash/hashinsert.c:70 #, c-format msgid "index row size %zu exceeds hash maximum %zu" msgstr "la dimensione %zu della riga dell'indice supera il massimo dell'hash %zu" -#: access/hash/hashinsert.c:71 access/spgist/spgdoinsert.c:1919 -#: access/spgist/spgutils.c:707 +#: access/hash/hashinsert.c:72 access/spgist/spgdoinsert.c:1911 +#: access/spgist/spgutils.c:703 #, c-format msgid "Values larger than a buffer page cannot be indexed." msgstr "Non si possono indicizzare valori più grandi di una pagina di buffer." -#: access/hash/hashovfl.c:548 +#: access/hash/hashovfl.c:546 #, c-format msgid "out of overflow pages in hash index \"%s\"" msgstr "pagine di overflow esaurite per l'indice hash \"%s\"" @@ -749,230 +765,225 @@ msgstr "l'indice \"%s\" ha una versione errata dell'hash" #: access/hash/hashvalidate.c:98 #, c-format -msgid "hash opfamily %s contains support procedure %s with cross-type registration" -msgstr "la famiglia di operatori hash %s contiene la procedura di supporto %s con tipi misti" +msgid "hash operator family \"%s\" contains support procedure %s with cross-type registration" +msgstr "la famiglia di operatori hash \"%s\" contiene la procedura di supporto %s con tipi misti" #: access/hash/hashvalidate.c:113 #, c-format -msgid "hash opfamily %s contains function %s with wrong signature for support number %d" -msgstr "la famiglia di operatori hash %s contiene la funzione %s con signature non valida per il numero di supporto %d" +msgid "hash operator family \"%s\" contains function %s with wrong signature for support number %d" +msgstr "la famiglia di operatori hash \"%s\" contiene la funzione %s con signature non valida per il numero di supporto %d" #: access/hash/hashvalidate.c:130 #, c-format -msgid "hash opfamily %s contains function %s with invalid support number %d" -msgstr "la famiglia di operatori hash %s contiene la funzione %s con numero di supporto non valido %d" +msgid "hash operator family \"%s\" contains function %s with invalid support number %d" +msgstr "la famiglia di operatori hash \"%s\" contiene la funzione %s con numero di supporto non valido %d" #: access/hash/hashvalidate.c:151 #, c-format -msgid "hash opfamily %s contains operator %s with invalid strategy number %d" -msgstr "la famiglia di operatori hash %s contiene l'operatore %s con numero di strategia non valida %d" +msgid "hash operator family \"%s\" contains operator %s with invalid strategy number %d" +msgstr "la famiglia di operatori hash \"%s\" contiene l'operatore %s con numero di strategia non valido %d" #: access/hash/hashvalidate.c:164 #, c-format -msgid "hash opfamily %s contains invalid ORDER BY specification for operator %s" -msgstr "la famiglia di operatori hash %s contiene una specifica ORDER BY non valida per l'operatore %s" +msgid "hash operator family \"%s\" contains invalid ORDER BY specification for operator %s" +msgstr "la famiglia di operatori hash \"%s\" contiene una specifica ORDER BY non valida per l'operatore %s" #: access/hash/hashvalidate.c:177 #, c-format -msgid "hash opfamily %s contains operator %s with wrong signature" -msgstr "la famiglia di operatori hash %s contiene l'operatore %s con signature non valida" +msgid "hash operator family \"%s\" contains operator %s with wrong signature" +msgstr "la famiglia di operatori hash \"%s\" contiene l'operatore %s con signature non valida" #: access/hash/hashvalidate.c:189 #, c-format -msgid "hash opfamily %s lacks support function for operator %s" -msgstr "alla famiglia di operatori hash %s manca la funzione di supporto per l'operatore %s" +msgid "hash operator family \"%s\" lacks support function for operator %s" +msgstr "alla famiglia di operatori hash \"%s\" manca la funzione di supporto per l'operatore %s" #: access/hash/hashvalidate.c:217 #, c-format -msgid "hash opfamily %s is missing operator(s) for types %s and %s" -msgstr "alla famiglia di operatori hash %s mancano operatori per i tipi %s e %s" +msgid "hash operator family \"%s\" is missing operator(s) for types %s and %s" +msgstr "alla famiglia di operatori hash \"%s\" mancano operatori per i tipi %s e %s" #: access/hash/hashvalidate.c:231 #, c-format -msgid "hash opclass %s is missing operator(s)" -msgstr "alla classe di operatori hash %s mancano operatori" +msgid "hash operator class \"%s\" is missing operator(s)" +msgstr "alla classe di operatori hash \"%s\" mancano operatori" #: access/hash/hashvalidate.c:247 #, c-format -msgid "hash opfamily %s is missing cross-type operator(s)" -msgstr "alla famiglia di operatori hash %s mancano operatori tra tipi diversi" +msgid "hash operator family \"%s\" is missing cross-type operator(s)" +msgstr "alla famiglia di operatori hash \"%s\" mancano operatori tra tipi diversi" -#: access/heap/heapam.c:1137 access/heap/heapam.c:1189 -#, c-format -msgid "cannot access temporary tables during a parallel operation" -msgstr "non è possibile accedere alle tabelle temporanee durante un'operazione parallela" - -#: access/heap/heapam.c:1306 access/heap/heapam.c:1334 -#: access/heap/heapam.c:1366 catalog/aclchk.c:1755 +#: access/heap/heapam.c:1295 access/heap/heapam.c:1323 +#: access/heap/heapam.c:1355 catalog/aclchk.c:1756 #, c-format msgid "\"%s\" is an index" msgstr "\"%s\" è un indice" -#: access/heap/heapam.c:1311 access/heap/heapam.c:1339 -#: access/heap/heapam.c:1371 catalog/aclchk.c:1762 commands/tablecmds.c:8986 -#: commands/tablecmds.c:12044 +#: access/heap/heapam.c:1300 access/heap/heapam.c:1328 +#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9081 +#: commands/tablecmds.c:12189 #, c-format msgid "\"%s\" is a composite type" msgstr "\"%s\" è un tipo composito" -#: access/heap/heapam.c:2580 +#: access/heap/heapam.c:2567 #, c-format msgid "cannot insert tuples during a parallel operation" msgstr "non è possibile inserire tuple durante un'operazione parallela" -#: access/heap/heapam.c:3030 +#: access/heap/heapam.c:3017 #, c-format msgid "cannot delete tuples during a parallel operation" msgstr "non è possibile eliminare tuple durante un'operazione parallela" -#: access/heap/heapam.c:3076 +#: access/heap/heapam.c:3063 #, c-format msgid "attempted to delete invisible tuple" msgstr "tentativo di eliminare tuple invisibili" -#: access/heap/heapam.c:3503 access/heap/heapam.c:6063 +#: access/heap/heapam.c:3489 access/heap/heapam.c:6240 #, c-format msgid "cannot update tuples during a parallel operation" msgstr "non è possibile aggiornare tuple durante un'operazione parallela" -#: access/heap/heapam.c:3625 +#: access/heap/heapam.c:3611 #, c-format msgid "attempted to update invisible tuple" msgstr "tentativo di aggiornare tuple invisibili" -#: access/heap/heapam.c:4884 access/heap/heapam.c:4922 -#: access/heap/heapam.c:5145 executor/execMain.c:2304 +#: access/heap/heapam.c:4963 access/heap/heapam.c:5001 +#: access/heap/heapam.c:5253 executor/execMain.c:2314 #, c-format msgid "could not obtain lock on row in relation \"%s\"" msgstr "lock di riga nella relazione \"%s\" fallito" -#: access/heap/hio.c:325 access/heap/rewriteheap.c:666 +#: access/heap/hio.c:322 access/heap/rewriteheap.c:664 #, c-format msgid "row is too big: size %zu, maximum size %zu" msgstr "la riga è troppo grande: la dimensione %zu supera il massimo %zu" -#: access/heap/rewriteheap.c:925 +#: access/heap/rewriteheap.c:923 #, c-format msgid "could not write to file \"%s\", wrote %d of %d: %m" msgstr "scrittura nel file \"%s\" fallita, scritti %d di %d: %m" -#: access/heap/rewriteheap.c:965 access/heap/rewriteheap.c:1177 -#: access/heap/rewriteheap.c:1274 access/transam/timeline.c:407 -#: access/transam/timeline.c:483 access/transam/xlog.c:3060 -#: access/transam/xlog.c:3222 replication/logical/snapbuild.c:1607 -#: replication/slot.c:1077 replication/slot.c:1162 storage/file/fd.c:624 -#: storage/file/fd.c:3052 storage/smgr/md.c:1031 storage/smgr/md.c:1262 -#: storage/smgr/md.c:1435 utils/misc/guc.c:6881 +#: access/heap/rewriteheap.c:963 access/heap/rewriteheap.c:1175 +#: access/heap/rewriteheap.c:1272 access/transam/timeline.c:407 +#: access/transam/timeline.c:483 access/transam/xlog.c:3087 +#: access/transam/xlog.c:3249 replication/logical/snapbuild.c:1605 +#: replication/slot.c:1088 replication/slot.c:1173 storage/file/fd.c:624 +#: storage/file/fd.c:3052 storage/smgr/md.c:1041 storage/smgr/md.c:1274 +#: storage/smgr/md.c:1447 utils/misc/guc.c:6885 #, c-format msgid "could not fsync file \"%s\": %m" msgstr "fsync del file \"%s\" fallito: %m" -#: access/heap/rewriteheap.c:1020 access/heap/rewriteheap.c:1140 +#: access/heap/rewriteheap.c:1018 access/heap/rewriteheap.c:1138 #: access/transam/timeline.c:315 access/transam/timeline.c:461 -#: access/transam/xlog.c:3016 access/transam/xlog.c:3165 -#: access/transam/xlog.c:10124 access/transam/xlog.c:10162 -#: access/transam/xlog.c:10489 postmaster/postmaster.c:4351 -#: replication/logical/origin.c:542 replication/slot.c:1034 -#: storage/file/copydir.c:162 storage/smgr/md.c:320 utils/time/snapmgr.c:1175 +#: access/transam/xlog.c:3043 access/transam/xlog.c:3192 +#: access/transam/xlog.c:10192 access/transam/xlog.c:10230 +#: access/transam/xlog.c:10603 postmaster/postmaster.c:4364 +#: replication/logical/origin.c:542 replication/slot.c:1045 +#: storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1275 #, c-format msgid "could not create file \"%s\": %m" msgstr "creazione del file \"%s\" fallita: %m" -#: access/heap/rewriteheap.c:1149 +#: access/heap/rewriteheap.c:1147 #, c-format msgid "could not truncate file \"%s\" to %u: %m" msgstr "troncamento del file \"%s\" a %u fallito: %m" -#: access/heap/rewriteheap.c:1156 replication/walsender.c:481 -#: storage/smgr/md.c:1847 +#: access/heap/rewriteheap.c:1154 replication/walsender.c:481 +#: storage/smgr/md.c:1899 #, c-format msgid "could not seek to end of file \"%s\": %m" msgstr "non è stato possibile spostarsi alla fine del file \"%s\": %m" -#: access/heap/rewriteheap.c:1167 access/transam/timeline.c:367 +#: access/heap/rewriteheap.c:1165 access/transam/timeline.c:367 #: access/transam/timeline.c:401 access/transam/timeline.c:477 -#: access/transam/xlog.c:3051 access/transam/xlog.c:3215 -#: postmaster/postmaster.c:4361 postmaster/postmaster.c:4371 +#: access/transam/xlog.c:3078 access/transam/xlog.c:3242 +#: postmaster/postmaster.c:4374 postmaster/postmaster.c:4384 #: replication/logical/origin.c:551 replication/logical/origin.c:587 -#: replication/logical/origin.c:603 replication/logical/snapbuild.c:1591 -#: replication/slot.c:1063 storage/file/copydir.c:187 +#: replication/logical/origin.c:603 replication/logical/snapbuild.c:1589 +#: replication/slot.c:1074 storage/file/copydir.c:187 #: utils/init/miscinit.c:1228 utils/init/miscinit.c:1237 -#: utils/init/miscinit.c:1244 utils/misc/guc.c:6842 utils/misc/guc.c:6873 -#: utils/misc/guc.c:8715 utils/misc/guc.c:8729 utils/time/snapmgr.c:1180 -#: utils/time/snapmgr.c:1187 +#: utils/init/miscinit.c:1244 utils/misc/guc.c:6846 utils/misc/guc.c:6877 +#: utils/misc/guc.c:8727 utils/misc/guc.c:8741 utils/time/snapmgr.c:1280 +#: utils/time/snapmgr.c:1287 #, c-format msgid "could not write to file \"%s\": %m" msgstr "scrittura nel file \"%s\" fallita: %m" -#: access/heap/rewriteheap.c:1250 access/transam/xlog.c:10356 +#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10441 #: access/transam/xlogarchive.c:114 access/transam/xlogarchive.c:468 -#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2611 -#: replication/logical/reorderbuffer.c:2668 -#: replication/logical/snapbuild.c:1535 replication/logical/snapbuild.c:1910 -#: replication/slot.c:1136 storage/ipc/dsm.c:326 storage/smgr/md.c:420 -#: storage/smgr/md.c:469 storage/smgr/md.c:1382 +#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2632 +#: replication/logical/reorderbuffer.c:2689 +#: replication/logical/snapbuild.c:1533 replication/logical/snapbuild.c:1908 +#: replication/slot.c:1147 storage/ipc/dsm.c:326 storage/smgr/md.c:427 +#: storage/smgr/md.c:476 storage/smgr/md.c:1394 #, c-format msgid "could not remove file \"%s\": %m" msgstr "rimozione del file \"%s\" fallita: %m" -#: access/heap/rewriteheap.c:1264 access/transam/timeline.c:111 +#: access/heap/rewriteheap.c:1262 access/transam/timeline.c:111 #: access/transam/timeline.c:236 access/transam/timeline.c:334 -#: access/transam/xlog.c:2992 access/transam/xlog.c:3109 -#: access/transam/xlog.c:3150 access/transam/xlog.c:3423 -#: access/transam/xlog.c:3501 access/transam/xlogutils.c:705 -#: replication/basebackup.c:401 replication/basebackup.c:1162 -#: replication/logical/origin.c:658 replication/logical/reorderbuffer.c:2141 -#: replication/logical/reorderbuffer.c:2381 -#: replication/logical/reorderbuffer.c:3059 -#: replication/logical/snapbuild.c:1584 replication/logical/snapbuild.c:1668 -#: replication/slot.c:1151 replication/walsender.c:474 -#: replication/walsender.c:2104 storage/file/copydir.c:155 +#: access/transam/xlog.c:3019 access/transam/xlog.c:3136 +#: access/transam/xlog.c:3177 access/transam/xlog.c:3450 +#: access/transam/xlog.c:3528 access/transam/xlogutils.c:701 +#: replication/basebackup.c:403 replication/basebackup.c:1150 +#: replication/logical/origin.c:658 replication/logical/reorderbuffer.c:2156 +#: replication/logical/reorderbuffer.c:2402 +#: replication/logical/reorderbuffer.c:3081 +#: replication/logical/snapbuild.c:1582 replication/logical/snapbuild.c:1666 +#: replication/slot.c:1162 replication/walsender.c:474 +#: replication/walsender.c:2102 storage/file/copydir.c:155 #: storage/file/fd.c:607 storage/file/fd.c:2964 storage/file/fd.c:3031 -#: storage/smgr/md.c:602 utils/error/elog.c:1870 utils/init/miscinit.c:1163 -#: utils/init/miscinit.c:1284 utils/init/miscinit.c:1362 utils/misc/guc.c:7101 -#: utils/misc/guc.c:7134 +#: storage/smgr/md.c:609 utils/error/elog.c:1879 utils/init/miscinit.c:1163 +#: utils/init/miscinit.c:1284 utils/init/miscinit.c:1362 utils/misc/guc.c:7105 +#: utils/misc/guc.c:7138 #, c-format msgid "could not open file \"%s\": %m" msgstr "apertura del file \"%s\" fallita: %m" -#: access/index/amapi.c:69 commands/amcmds.c:164 +#: access/index/amapi.c:82 commands/amcmds.c:164 #, c-format msgid "access method \"%s\" is not of type %s" msgstr "il metodo di accesso \"%s\" non è del tipo %s" -#: access/index/amapi.c:78 +#: access/index/amapi.c:98 #, c-format msgid "index access method \"%s\" does not have a handler" msgstr "il metodo di accesso dell'indice \"%s\" non ha un handler" #: access/index/indexam.c:155 catalog/objectaddress.c:1196 -#: commands/indexcmds.c:1799 commands/tablecmds.c:241 -#: commands/tablecmds.c:12035 +#: commands/indexcmds.c:1799 commands/tablecmds.c:242 +#: commands/tablecmds.c:12180 #, c-format msgid "\"%s\" is not an index" msgstr "\"%s\" non è un indice" -#: access/nbtree/nbtinsert.c:427 +#: access/nbtree/nbtinsert.c:428 #, c-format msgid "duplicate key value violates unique constraint \"%s\"" msgstr "un valore chiave duplicato viola il vincolo univoco \"%s\"" -#: access/nbtree/nbtinsert.c:429 +#: access/nbtree/nbtinsert.c:430 #, c-format msgid "Key %s already exists." msgstr "La chiave %s esiste già." -#: access/nbtree/nbtinsert.c:496 +#: access/nbtree/nbtinsert.c:497 #, c-format msgid "failed to re-find tuple within index \"%s\"" msgstr "non ho ritrovato la tupla nell'indice \"%s\"" -#: access/nbtree/nbtinsert.c:498 +#: access/nbtree/nbtinsert.c:499 #, c-format msgid "This may be because of a non-immutable index expression." msgstr "Ciò potrebbe essere causato da un'espressione dell'indice non immutabile." -#: access/nbtree/nbtinsert.c:578 access/nbtree/nbtsort.c:491 +#: access/nbtree/nbtinsert.c:579 access/nbtree/nbtsort.c:491 #, c-format msgid "" "Values larger than 1/3 of a buffer page cannot be indexed.\n" @@ -982,7 +993,7 @@ msgstr "" "Si consiglia un indice funzionale su un hash MD5 del valore o l'uso del full text indexing." #: access/nbtree/nbtpage.c:168 access/nbtree/nbtpage.c:371 -#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1715 +#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1702 #, c-format msgid "index \"%s\" is not a btree" msgstr "l'indice \"%s\" non è un btree" @@ -1005,120 +1016,120 @@ msgstr "Ciò può essere causato da un VACUUM interrotto in una versione 9.3 o p #: access/nbtree/nbtvalidate.c:100 #, c-format -msgid "btree opfamily %s contains function %s with invalid support number %d" -msgstr "la famiglia di operatori btree %s contiene la funzione %s con numero di supporto non valido %d" +msgid "btree operator family \"%s\" contains function %s with invalid support number %d" +msgstr "la famiglia di operatori btree \"%s\" contiene la funzione %s con numero di supporto non valido %d" #: access/nbtree/nbtvalidate.c:112 #, c-format -msgid "btree opfamily %s contains function %s with wrong signature for support number %d" -msgstr "la famiglia di operatori btree %s contiene la funzione %s con signature non valida per il numero di supporto %d" +msgid "btree operator family \"%s\" contains function %s with wrong signature for support number %d" +msgstr "la famiglia di operatori btree \"%s\" contiene la funzione %s con signature non valida per il numero di supporto %d" #: access/nbtree/nbtvalidate.c:132 #, c-format -msgid "btree opfamily %s contains operator %s with invalid strategy number %d" -msgstr "la famiglia di operatori btree %s contiene l'operatore %s con numero di strategia non valida %d" +msgid "btree operator family \"%s\" contains operator %s with invalid strategy number %d" +msgstr "la famiglia di operatori btree \"%s\" contiene l'operatore %s con numero di strategia non valido %d" #: access/nbtree/nbtvalidate.c:145 #, c-format -msgid "btree opfamily %s contains invalid ORDER BY specification for operator %s" -msgstr "la famiglia di operatori btree %s contiene una specifica ORDER BY non valida per l'operatore %s" +msgid "btree operator family \"%s\" contains invalid ORDER BY specification for operator %s" +msgstr "la famiglia di operatori btree \"%s\" contiene una specifica ORDER BY non valida per l'operatore %s" #: access/nbtree/nbtvalidate.c:158 #, c-format -msgid "btree opfamily %s contains operator %s with wrong signature" -msgstr "la famiglia di operatori btree %s contiene l'operatore %s con signature non valida" +msgid "btree operator family \"%s\" contains operator %s with wrong signature" +msgstr "la famiglia di operatori btree \"%s\" contiene l'operatore %s con signature non valida" #: access/nbtree/nbtvalidate.c:200 #, c-format -msgid "btree opfamily %s is missing operator(s) for types %s and %s" -msgstr "alla famiglia di operatori btree %s mancano operatori per i tipi %s e %s" +msgid "btree operator family \"%s\" is missing operator(s) for types %s and %s" +msgstr "alla famiglia di operatori btree \"%s\" mancano operatori per i tipi %s e %s" #: access/nbtree/nbtvalidate.c:210 #, c-format -msgid "btree opfamily %s is missing support function for types %s and %s" -msgstr "alla famiglia di operatori btree %s mancano funzioni di supporto per i tipi %s e %s" +msgid "btree operator family \"%s\" is missing support function for types %s and %s" +msgstr "alla famiglia di operatori btree \"%s\" mancano funzioni di supporto per i tipi %s e %s" #: access/nbtree/nbtvalidate.c:224 #, c-format -msgid "btree opclass %s is missing operator(s)" -msgstr "alla classe di operatori btree %s mancano operatori" +msgid "btree operator class \"%s\" is missing operator(s)" +msgstr "alla classe di operatori btree \"%s\" mancano operatori" #: access/nbtree/nbtvalidate.c:241 #, c-format -msgid "btree opfamily %s is missing cross-type operator(s)" -msgstr "alla famiglia di operatori btree %s mancano operatori tra tipi diversi" +msgid "btree operator family \"%s\" is missing cross-type operator(s)" +msgstr "alla famiglia di operatori btree \"%s\" mancano operatori tra tipi diversi" -#: access/spgist/spgutils.c:704 +#: access/spgist/spgutils.c:700 #, c-format msgid "SP-GiST inner tuple size %zu exceeds maximum %zu" msgstr "La dimensione %zu della tupla interna SP-GiST supera il massimo %zu" #: access/spgist/spgvalidate.c:92 #, c-format -msgid "spgist opfamily %s contains support procedure %s with cross-type registration" -msgstr "la famiglia di operatori spgist %s contiene la procedura di supporto %s con tipi misti" +msgid "spgist operator family \"%s\" contains support procedure %s with cross-type registration" +msgstr "la famiglia di operatori spgist \"%s\" contiene la procedura di supporto %s con tipi misti" #: access/spgist/spgvalidate.c:115 #, c-format -msgid "spgist opfamily %s contains function %s with invalid support number %d" -msgstr "la famiglia di operatori spgist %s contiene la funzione %s con numero di supporto non valido %d" +msgid "spgist operator family \"%s\" contains function %s with invalid support number %d" +msgstr "la famiglia di operatori spgist \"%s\" contiene la funzione %s con numero di supporto non valido %d" #: access/spgist/spgvalidate.c:127 #, c-format -msgid "spgist opfamily %s contains function %s with wrong signature for support number %d" -msgstr "la famiglia di operatori spgist %s contiene la funzione %s con signature non valida per il numero di supporto %d" +msgid "spgist operator family \"%s\" contains function %s with wrong signature for support number %d" +msgstr "la famiglia di operatori spgist \"%s\" contiene la funzione %s con signature non valida per il numero di supporto %d" #: access/spgist/spgvalidate.c:146 #, c-format -msgid "spgist opfamily %s contains operator %s with invalid strategy number %d" -msgstr "la famiglia di operatori spgist %s contiene l'operatore %s con numero di strategia non valida %d" +msgid "spgist operator family \"%s\" contains operator %s with invalid strategy number %d" +msgstr "la famiglia di operatori spgist \"%s\" contiene l'operatore %s con numero di strategia non valido %d" #: access/spgist/spgvalidate.c:159 #, c-format -msgid "spgist opfamily %s contains invalid ORDER BY specification for operator %s" -msgstr "la famiglia di operatori spgist %s contiene una specifica ORDER BY non valida per l'operatore %s" +msgid "spgist operator family \"%s\" contains invalid ORDER BY specification for operator %s" +msgstr "la famiglia di operatori spgist \"%s\" contiene una specifica ORDER BY non valida per l'operatore %s" #: access/spgist/spgvalidate.c:172 #, c-format -msgid "spgist opfamily %s contains operator %s with wrong signature" -msgstr "la famiglia di operatori spgist %s contiene l'operatore %s con signature non valida" +msgid "spgist operator family \"%s\" contains operator %s with wrong signature" +msgstr "la famiglia di operatori spgist \"%s\" contiene l'operatore %s con signature non valida" #: access/spgist/spgvalidate.c:200 #, c-format -msgid "spgist opfamily %s is missing operator(s) for types %s and %s" -msgstr "alla famiglia di operatori spgist %s mancano operatori per i tipi %s e %s" +msgid "spgist operator family \"%s\" is missing operator(s) for types %s and %s" +msgstr "alla famiglia di operatori spgist \"%s\" mancano operatori per i tipi %s e %s" #: access/spgist/spgvalidate.c:220 #, c-format -msgid "spgist opfamily %s is missing support function %d for type %s" -msgstr "alla famiglia di operatori spgist %s manca la funzione di supporto %d per il tipo %s" +msgid "spgist operator family \"%s\" is missing support function %d for type %s" +msgstr "alla famiglia di operatori spgist \"%s\" manca la funzione di supporto %d per il tipo %s" #: access/spgist/spgvalidate.c:233 #, c-format -msgid "spgist opclass %s is missing operator(s)" -msgstr "alla classe di operatori spgist %s mancano operatori" +msgid "spgist operator class \"%s\" is missing operator(s)" +msgstr "alla classe di operatori spgist \"%s\" mancano operatori" #: access/tablesample/bernoulli.c:152 access/tablesample/system.c:156 #, c-format msgid "sample percentage must be between 0 and 100" msgstr "la percentuale dei campioni dev'essere tra 0 e 100" -#: access/transam/commit_ts.c:295 +#: access/transam/commit_ts.c:294 #, c-format msgid "cannot retrieve commit timestamp for transaction %u" msgstr "non è stato possibile ottenere l'ora di commit per la transazione %u" -#: access/transam/commit_ts.c:385 +#: access/transam/commit_ts.c:392 #, c-format msgid "could not get commit timestamp data" msgstr "non è stato possibile ottenere i dati dell'ora di commit" -#: access/transam/commit_ts.c:387 +#: access/transam/commit_ts.c:394 #, c-format msgid "Make sure the configuration parameter \"%s\" is set on the master server." msgstr "Assicurati che il parametro di configurazione \"%s\" sia impostato sul server master." -#: access/transam/commit_ts.c:389 libpq/hba.c:1441 +#: access/transam/commit_ts.c:396 libpq/hba.c:1439 #, c-format msgid "Make sure the configuration parameter \"%s\" is set." msgstr "Assicurati che il parametro di configurazione \"%s\" sia impostato." @@ -1143,14 +1154,14 @@ msgstr "" msgid "database is not accepting commands that generate new MultiXactIds to avoid wraparound data loss in database with OID %u" msgstr "il database non sta accettando comandi che generano nuovi MultiXactIds per evitare perdite di dati per wraparound nel database con OID %u" -#: access/transam/multixact.c:1028 access/transam/multixact.c:2317 +#: access/transam/multixact.c:1028 access/transam/multixact.c:2314 #, c-format msgid "database \"%s\" must be vacuumed before %u more MultiXactId is used" msgid_plural "database \"%s\" must be vacuumed before %u more MultiXactIds are used" msgstr[0] "il database \"%s\" deve ricevere un vacuum prima che altri %u MultiXactIds siano usati" msgstr[1] "il database \"%s\" deve ricevere un vacuum prima che altri %u MultiXactIds siano usati" -#: access/transam/multixact.c:1037 access/transam/multixact.c:2326 +#: access/transam/multixact.c:1037 access/transam/multixact.c:2323 #, c-format msgid "database with OID %u must be vacuumed before %u more MultiXactId is used" msgid_plural "database with OID %u must be vacuumed before %u more MultiXactIds are used" @@ -1186,22 +1197,22 @@ msgstr[1] "il database con OID %u deve ricevere un vacuum prima che altri %d mem msgid "Execute a database-wide VACUUM in that database with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings." msgstr "Esegui un VACUUM su quel database intero con impostazioni di vacuum_multixact_freeze_min_age e vacuum_multixact_freeze_table_age ridotte." -#: access/transam/multixact.c:1278 +#: access/transam/multixact.c:1277 #, c-format msgid "MultiXactId %u does no longer exist -- apparent wraparound" msgstr "il MultiXactId %u non esiste più -- sembra ci sia stato un wraparound" -#: access/transam/multixact.c:1286 +#: access/transam/multixact.c:1285 #, c-format msgid "MultiXactId %u has not been created yet -- apparent wraparound" msgstr "il MultiXactId %u non è stato ancora creato -- sembra ci sia stato un wraparound" -#: access/transam/multixact.c:2267 +#: access/transam/multixact.c:2264 #, c-format msgid "MultiXactId wrap limit is %u, limited by database with OID %u" msgstr "il limite di wrap di MultiXactId è %u, limitato dal database con OID %u" -#: access/transam/multixact.c:2322 access/transam/multixact.c:2331 +#: access/transam/multixact.c:2319 access/transam/multixact.c:2328 #: access/transam/varsup.c:146 access/transam/varsup.c:153 #: access/transam/varsup.c:384 access/transam/varsup.c:391 #, c-format @@ -1212,66 +1223,65 @@ msgstr "" "Per evitare lo spegnimento del database, si deve eseguire un VACUUM su tutto il database.\n" "Potrebbe essere necessario inoltre effettuare il COMMIT o il ROLLBACK di vecchie transazioni preparate." -#: access/transam/multixact.c:2601 +#: access/transam/multixact.c:2598 #, c-format msgid "oldest MultiXactId member is at offset %u" msgstr "il membro MultiXactId più vecchio è all'offset %u" -#: access/transam/multixact.c:2605 +#: access/transam/multixact.c:2602 #, c-format msgid "MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk" msgstr "le protezioni di wraparound dei membri MultiXact sono disabilitate perché il il MultiXact più vecchio che abbia ricevuto un checkpoint %u non esiste sul disco" -#: access/transam/multixact.c:2627 +#: access/transam/multixact.c:2624 #, c-format msgid "MultiXact member wraparound protections are now enabled" msgstr "le protezioni di wraparound dei membri MultiXact ora sono abilitate" -#: access/transam/multixact.c:2629 +#: access/transam/multixact.c:2626 #, c-format msgid "MultiXact member stop limit is now %u based on MultiXact %u" msgstr "il limite di arresto dei membri MultiXact è ora %u basato sul MultiXact %u" -#: access/transam/multixact.c:3009 +#: access/transam/multixact.c:3006 #, c-format msgid "oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation" msgstr "MultiXact più vecchio %u non trovato, il primo è il MultiXact %u, troncamento non eseguito" -#: access/transam/multixact.c:3027 +#: access/transam/multixact.c:3024 #, c-format msgid "cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation" msgstr "impossibile troncare fino al MultiXact %u perché non esiste su disco, troncamento non eseguito" -#: access/transam/multixact.c:3353 +#: access/transam/multixact.c:3350 #, c-format msgid "invalid MultiXactId: %u" msgstr "MultiXactId non valido: %u" -#: access/transam/parallel.c:581 +#: access/transam/parallel.c:589 #, c-format msgid "postmaster exited during a parallel transaction" msgstr "il postmaster è terminato durante una transazione parallela" -#: access/transam/parallel.c:739 +#: access/transam/parallel.c:774 #, c-format msgid "lost connection to parallel worker" msgstr "connessione al worker parallelo perduta" -#: access/transam/parallel.c:914 +#: access/transam/parallel.c:833 access/transam/parallel.c:835 +msgid "parallel worker" +msgstr "worker parallelo" + +#: access/transam/parallel.c:974 #, c-format msgid "could not map dynamic shared memory segment" msgstr "mappatura del segmento di memoria dinamica condivisa non riuscito" -#: access/transam/parallel.c:919 +#: access/transam/parallel.c:979 #, c-format msgid "invalid magic number in dynamic shared memory segment" msgstr "numero magico non valido nel segmento di memoria dinamica condivisa" -#: access/transam/parallel.c:1084 -#, c-format -msgid "parallel worker, PID %d" -msgstr "lavoratore parallelo, PID %d" - #: access/transam/slru.c:665 #, c-format msgid "file \"%s\" doesn't exist, reading as zeroes" @@ -1360,8 +1370,8 @@ msgid "Timeline IDs must be less than child timeline's ID." msgstr "Gli ID della timeline devono avere valori inferiori degli ID della timeline figlia" #: access/transam/timeline.c:412 access/transam/timeline.c:488 -#: access/transam/xlog.c:3066 access/transam/xlog.c:3227 -#: access/transam/xlogfuncs.c:691 commands/copy.c:1671 +#: access/transam/xlog.c:3093 access/transam/xlog.c:3254 +#: access/transam/xlogfuncs.c:690 commands/copy.c:1708 #: storage/file/copydir.c:201 #, c-format msgid "could not close file \"%s\": %m" @@ -1402,67 +1412,67 @@ msgstr "è stato raggiunto il numero massimo di transazioni preparate" msgid "Increase max_prepared_transactions (currently %d)." msgstr "Incrementa il valore di max_prepared_transactions (il valore attuale è %d)" -#: access/transam/twophase.c:539 +#: access/transam/twophase.c:540 #, c-format msgid "prepared transaction with identifier \"%s\" is busy" msgstr "la transazione preparata con identificativo \"%s\" è in uso" -#: access/transam/twophase.c:545 +#: access/transam/twophase.c:546 #, c-format msgid "permission denied to finish prepared transaction" msgstr "non è consentito portare a termine la transazione preparata" -#: access/transam/twophase.c:546 +#: access/transam/twophase.c:547 #, c-format msgid "Must be superuser or the user that prepared the transaction." msgstr "È consentito solo a un superutente o all'utente che ha preparato la transazione." -#: access/transam/twophase.c:557 +#: access/transam/twophase.c:558 #, c-format msgid "prepared transaction belongs to another database" msgstr "la transazione preparata appartiene ad un altro database" -#: access/transam/twophase.c:558 +#: access/transam/twophase.c:559 #, c-format msgid "Connect to the database where the transaction was prepared to finish it." msgstr "Connettersi al database in cui la transazione è stata preparata per portarla a termine." -#: access/transam/twophase.c:573 +#: access/transam/twophase.c:574 #, c-format msgid "prepared transaction with identifier \"%s\" does not exist" msgstr "la transazione preparata con identificativo \"%s\" non esiste" -#: access/transam/twophase.c:1042 +#: access/transam/twophase.c:1043 #, c-format msgid "two-phase state file maximum length exceeded" msgstr "è stata superata la lunghezza massima del file dello stato a due fasi" -#: access/transam/twophase.c:1160 +#: access/transam/twophase.c:1161 #, c-format msgid "could not open two-phase state file \"%s\": %m" msgstr "apertura del file dello stato a due fasi \"%s\" fallita: %m" -#: access/transam/twophase.c:1177 +#: access/transam/twophase.c:1178 #, c-format msgid "could not stat two-phase state file \"%s\": %m" msgstr "non è stato possibile ottenere informazioni sul file dello stato a due fasi \"%s\": %m" -#: access/transam/twophase.c:1209 +#: access/transam/twophase.c:1210 #, c-format msgid "could not read two-phase state file \"%s\": %m" msgstr "lettura del file dello stato a due fasi \"%s\" fallita: %m" -#: access/transam/twophase.c:1262 access/transam/xlog.c:6070 +#: access/transam/twophase.c:1263 access/transam/xlog.c:6109 #, c-format msgid "Failed while allocating an XLog reading processor." msgstr "Errore nell'alllocazione di un processore di lettura XLog." -#: access/transam/twophase.c:1268 +#: access/transam/twophase.c:1269 #, c-format msgid "could not read two-phase state from xlog at %X/%X" msgstr "lettura dello stato a due fasi fallita per l'xlog a %X/%X" -#: access/transam/twophase.c:1276 +#: access/transam/twophase.c:1277 #, c-format msgid "expected two-phase state data is not present in xlog at %X/%X" msgstr "i dati dello stato a due fasi attesi non sono presenti nell'xlog a %X/%X" @@ -1492,29 +1502,31 @@ msgstr "fsync del file dello stato a due fasi: %m" msgid "could not close two-phase state file: %m" msgstr "chiusura del file dello stato a due fasi fallita: %m" -#: access/transam/twophase.c:1651 +#: access/transam/twophase.c:1649 #, c-format -msgid "%u two-phase state files were written for long-running prepared transactions" -msgstr "%u file di stato a due fasi sono stati scritti per transazioni preparate di lunga durata" +msgid "%u two-phase state file was written for long-running prepared transactions" +msgid_plural "%u two-phase state files were written for long-running prepared transactions" +msgstr[0] "scritti %u file di stato a due fasi per transazioni preparate di lunga durata" +msgstr[1] "scritti %u file di stato a due fasi per transazioni preparate di lunga durata" -#: access/transam/twophase.c:1712 +#: access/transam/twophase.c:1713 #, c-format msgid "removing future two-phase state file \"%s\"" msgstr "rimozione del file dello stato a due fasi nel futuro \"%s\"" -#: access/transam/twophase.c:1728 access/transam/twophase.c:1739 -#: access/transam/twophase.c:1858 access/transam/twophase.c:1869 -#: access/transam/twophase.c:1943 +#: access/transam/twophase.c:1729 access/transam/twophase.c:1740 +#: access/transam/twophase.c:1860 access/transam/twophase.c:1871 +#: access/transam/twophase.c:1948 #, c-format msgid "removing corrupt two-phase state file \"%s\"" msgstr "rimozione del file dello stato a due fasi corrotto \"%s\"" -#: access/transam/twophase.c:1847 access/transam/twophase.c:1932 +#: access/transam/twophase.c:1849 access/transam/twophase.c:1937 #, c-format msgid "removing stale two-phase state file \"%s\"" msgstr "rimozione del file dello stato a due fasi obsoleto \"%s\"" -#: access/transam/twophase.c:1950 +#: access/transam/twophase.c:1955 #, c-format msgid "recovering prepared transaction %u" msgstr "recupero della transazione preparata %u" @@ -1558,1136 +1570,1135 @@ msgstr "il limite di sovrascrittura degli ID di transazione è %u, definito dal msgid "cannot have more than 2^32-2 commands in a transaction" msgstr "non è possibile effettuare più di 2^32-2 comandi in una transazione" -#: access/transam/xact.c:1453 +#: access/transam/xact.c:1467 #, c-format msgid "maximum number of committed subtransactions (%d) exceeded" msgstr "il numero massimo di sottotransazioni committed (%d) è stato superato" -#: access/transam/xact.c:2249 +#: access/transam/xact.c:2263 #, c-format msgid "cannot PREPARE a transaction that has operated on temporary tables" msgstr "non è possibile eseguire PREPARE in una transazione che ha operato su tabelle temporanee" -#: access/transam/xact.c:2259 +#: access/transam/xact.c:2273 #, c-format msgid "cannot PREPARE a transaction that has exported snapshots" msgstr "non è possibile eseguire PREPARE in una transazione che ha esportato snapshot" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3141 +#: access/transam/xact.c:3155 #, c-format msgid "%s cannot run inside a transaction block" msgstr "non è possibile eseguire %s all'interno di un blocco di transazione" # translator: %s represents an SQL statement name #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3151 +#: access/transam/xact.c:3165 #, c-format msgid "%s cannot run inside a subtransaction" msgstr "non è possibile eseguire %s all'interno di una sottotransazione" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3161 +#: access/transam/xact.c:3175 #, c-format msgid "%s cannot be executed from a function or multi-command string" msgstr "una funzione o una stringa multi-comando non può eseguire %s" # translator: %s represents an SQL statement name #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3232 +#: access/transam/xact.c:3246 #, c-format msgid "%s can only be used in transaction blocks" msgstr "si può usare %s solo entro blocchi di transazione" -#: access/transam/xact.c:3416 +#: access/transam/xact.c:3430 #, c-format msgid "there is already a transaction in progress" msgstr "c'è già una transazione in corso" -#: access/transam/xact.c:3584 access/transam/xact.c:3687 +#: access/transam/xact.c:3598 access/transam/xact.c:3701 #, c-format msgid "there is no transaction in progress" msgstr "non c'è alcuna transazione in corso" -#: access/transam/xact.c:3595 +#: access/transam/xact.c:3609 #, c-format msgid "cannot commit during a parallel operation" msgstr "non è possibile effettuare un commit durante un'operazione parallela" -#: access/transam/xact.c:3698 +#: access/transam/xact.c:3712 #, c-format msgid "cannot abort during a parallel operation" msgstr "non è possibile interrompere durante un'operazione parallela" -#: access/transam/xact.c:3740 +#: access/transam/xact.c:3754 #, c-format msgid "cannot define savepoints during a parallel operation" msgstr "non è possibile definire un punto di salvataggio durante un'operazione parallela" -#: access/transam/xact.c:3807 +#: access/transam/xact.c:3821 #, c-format msgid "cannot release savepoints during a parallel operation" msgstr "non è possibile rilasciare un punto di salvataggio durante un'operazione parallela" -#: access/transam/xact.c:3818 access/transam/xact.c:3870 -#: access/transam/xact.c:3876 access/transam/xact.c:3932 -#: access/transam/xact.c:3982 access/transam/xact.c:3988 +#: access/transam/xact.c:3832 access/transam/xact.c:3884 +#: access/transam/xact.c:3890 access/transam/xact.c:3946 +#: access/transam/xact.c:3996 access/transam/xact.c:4002 #, c-format msgid "no such savepoint" msgstr "punto di salvataggio inesistente" -#: access/transam/xact.c:3920 +#: access/transam/xact.c:3934 #, c-format msgid "cannot rollback to savepoints during a parallel operation" msgstr "non è possibile effettuare un rollback durante un'operazione parallela" -#: access/transam/xact.c:4048 +#: access/transam/xact.c:4062 #, c-format msgid "cannot start subtransactions during a parallel operation" msgstr "non è possibile iniziare una sub-transazione durante un'operazione parallela" -#: access/transam/xact.c:4115 +#: access/transam/xact.c:4129 #, c-format msgid "cannot commit subtransactions during a parallel operation" msgstr "non è possibile effettuare il commit di una sub-transazione durante un'operazione parallela" -#: access/transam/xact.c:4723 +#: access/transam/xact.c:4737 #, c-format msgid "cannot have more than 2^32-1 subtransactions in a transaction" msgstr "non è possibile avere più di 2^32-1 comandi in una sottotransazione" -#: access/transam/xlog.c:2272 +#: access/transam/xlog.c:2299 #, c-format msgid "could not seek in log file %s to offset %u: %m" msgstr "spostamento nel file di log %s alla posizione %u fallito: %m" -#: access/transam/xlog.c:2292 +#: access/transam/xlog.c:2319 #, c-format msgid "could not write to log file %s at offset %u, length %zu: %m" msgstr "scrittura nel file di log %s in posizione %u, lunghezza %zu fallita: %m" -#: access/transam/xlog.c:2555 +#: access/transam/xlog.c:2582 #, c-format msgid "updated min recovery point to %X/%X on timeline %u" msgstr "punto di recupero minimo aggiornato a %X/%X sulla timeline %u" -#: access/transam/xlog.c:3197 +#: access/transam/xlog.c:3224 #, c-format msgid "not enough data in file \"%s\"" msgstr "il file \"%s\" non contiene abbastanza dati" -#: access/transam/xlog.c:3338 +#: access/transam/xlog.c:3365 #, c-format msgid "could not open transaction log file \"%s\": %m" msgstr "apertura del file di log delle transazioni \"%s\" fallita: %m" -#: access/transam/xlog.c:3527 access/transam/xlog.c:5300 +#: access/transam/xlog.c:3554 access/transam/xlog.c:5339 #, c-format msgid "could not close log file %s: %m" msgstr "chiusura del file di log %s fallita: %m" -#: access/transam/xlog.c:3584 access/transam/xlogutils.c:700 -#: replication/walsender.c:2099 +#: access/transam/xlog.c:3611 access/transam/xlogutils.c:696 +#: replication/walsender.c:2097 #, c-format msgid "requested WAL segment %s has already been removed" msgstr "il segmento WAL richiesto %s è stato già rimosso" # da non tradursi # DV: perché? (trovato tradotto, tra l'altro) -#: access/transam/xlog.c:3644 access/transam/xlog.c:3719 -#: access/transam/xlog.c:3917 +#: access/transam/xlog.c:3671 access/transam/xlog.c:3746 +#: access/transam/xlog.c:3944 #, c-format msgid "could not open transaction log directory \"%s\": %m" msgstr "apertura della directory dei log delle transazioni \"%s\" fallita: %m" -#: access/transam/xlog.c:3800 +#: access/transam/xlog.c:3827 #, c-format msgid "recycled transaction log file \"%s\"" msgstr "il file di log delle transazioni \"%s\" è stato riciclato" -#: access/transam/xlog.c:3812 +#: access/transam/xlog.c:3839 #, c-format msgid "removing transaction log file \"%s\"" msgstr "eliminazione del file di log delle transazioni \"%s\"" -#: access/transam/xlog.c:3832 +#: access/transam/xlog.c:3859 #, c-format msgid "could not rename old transaction log file \"%s\": %m" msgstr "non è stato possibile rinominare il vecchio file di log delle transazioni \"%s\": %m" -#: access/transam/xlog.c:3844 +#: access/transam/xlog.c:3871 #, c-format msgid "could not remove old transaction log file \"%s\": %m" msgstr "chiusura del vecchio file di log delle transazioni \"%s\" fallita: %m" -#: access/transam/xlog.c:3877 access/transam/xlog.c:3887 +#: access/transam/xlog.c:3904 access/transam/xlog.c:3914 #, c-format msgid "required WAL directory \"%s\" does not exist" msgstr "la directory dei file WAL \"%s\" necessaria non esiste" -#: access/transam/xlog.c:3893 +#: access/transam/xlog.c:3920 #, c-format msgid "creating missing WAL directory \"%s\"" msgstr "creazione della directory dei file WAL mancante \"%s\"" -#: access/transam/xlog.c:3896 +#: access/transam/xlog.c:3923 #, c-format msgid "could not create missing directory \"%s\": %m" msgstr "creazione della directory mancante \"%s\" fallita: %m" -#: access/transam/xlog.c:3927 +#: access/transam/xlog.c:3954 #, c-format msgid "removing transaction log backup history file \"%s\"" msgstr "rimozione del file storico di backup del log delle transazioni \"%s\"" -#: access/transam/xlog.c:4008 +#: access/transam/xlog.c:4035 #, c-format msgid "unexpected timeline ID %u in log segment %s, offset %u" msgstr "ID di timeline %u inatteso nel segmento di log %s, offset %u" -#: access/transam/xlog.c:4130 +#: access/transam/xlog.c:4157 #, c-format msgid "new timeline %u is not a child of database system timeline %u" msgstr "la nuova timeline %u non è figlia della timeline %u del database" -#: access/transam/xlog.c:4144 +#: access/transam/xlog.c:4171 #, c-format msgid "new timeline %u forked off current database system timeline %u before current recovery point %X/%X" msgstr "la nuova timeline %u si è staccata dalla timeline attuale %u prima del punto di recupero corrente %X/%X" -#: access/transam/xlog.c:4163 +#: access/transam/xlog.c:4190 #, c-format msgid "new target timeline is %u" msgstr "la nuova timeline di destinazione %u" -#: access/transam/xlog.c:4243 +#: access/transam/xlog.c:4270 #, c-format msgid "could not create control file \"%s\": %m" msgstr "creazione del file di controllo \"%s\" fallita: %m" -#: access/transam/xlog.c:4254 access/transam/xlog.c:4490 +#: access/transam/xlog.c:4281 access/transam/xlog.c:4517 #, c-format msgid "could not write to control file: %m" msgstr "scrittura nel file di controllo fallita: %m" -#: access/transam/xlog.c:4260 access/transam/xlog.c:4496 +#: access/transam/xlog.c:4287 access/transam/xlog.c:4523 #, c-format msgid "could not fsync control file: %m" msgstr "fsync del file di controllo fallito: %m" -#: access/transam/xlog.c:4265 access/transam/xlog.c:4501 +#: access/transam/xlog.c:4292 access/transam/xlog.c:4528 #, c-format msgid "could not close control file: %m" msgstr "chiusura del file di controllo fallita: %m" -#: access/transam/xlog.c:4283 access/transam/xlog.c:4479 +#: access/transam/xlog.c:4310 access/transam/xlog.c:4506 #, c-format msgid "could not open control file \"%s\": %m" msgstr "apertura del file di controllo \"%s\" fallita: %m" -#: access/transam/xlog.c:4289 +#: access/transam/xlog.c:4316 #, c-format msgid "could not read from control file: %m" msgstr "lettura dal file di controllo fallita: %m" -#: access/transam/xlog.c:4302 access/transam/xlog.c:4311 -#: access/transam/xlog.c:4335 access/transam/xlog.c:4342 -#: access/transam/xlog.c:4349 access/transam/xlog.c:4354 -#: access/transam/xlog.c:4361 access/transam/xlog.c:4368 -#: access/transam/xlog.c:4375 access/transam/xlog.c:4382 -#: access/transam/xlog.c:4389 access/transam/xlog.c:4396 -#: access/transam/xlog.c:4403 access/transam/xlog.c:4412 -#: access/transam/xlog.c:4419 access/transam/xlog.c:4428 -#: access/transam/xlog.c:4435 access/transam/xlog.c:4444 -#: access/transam/xlog.c:4451 utils/init/miscinit.c:1380 +#: access/transam/xlog.c:4329 access/transam/xlog.c:4338 +#: access/transam/xlog.c:4362 access/transam/xlog.c:4369 +#: access/transam/xlog.c:4376 access/transam/xlog.c:4381 +#: access/transam/xlog.c:4388 access/transam/xlog.c:4395 +#: access/transam/xlog.c:4402 access/transam/xlog.c:4409 +#: access/transam/xlog.c:4416 access/transam/xlog.c:4423 +#: access/transam/xlog.c:4430 access/transam/xlog.c:4439 +#: access/transam/xlog.c:4446 access/transam/xlog.c:4455 +#: access/transam/xlog.c:4462 access/transam/xlog.c:4471 +#: access/transam/xlog.c:4478 utils/init/miscinit.c:1380 #, c-format msgid "database files are incompatible with server" msgstr "i file del database sono incompatibili col server" -#: access/transam/xlog.c:4303 +#: access/transam/xlog.c:4330 #, c-format msgid "The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x), but the server was compiled with PG_CONTROL_VERSION %d (0x%08x)." msgstr "Il cluster di database è stato inizializzato con PG_CONTROL_VERSION %d (0x%08x), ma il server è stato compilato con PG_CONTROL_VERSION %d (0x%08x)." -#: access/transam/xlog.c:4307 +#: access/transam/xlog.c:4334 #, c-format msgid "This could be a problem of mismatched byte ordering. It looks like you need to initdb." msgstr "Questo potrebbe essere un problema di ordinamento di byte che non combacia. Sembra sia necessario eseguire initdb." -#: access/transam/xlog.c:4312 +#: access/transam/xlog.c:4339 #, c-format msgid "The database cluster was initialized with PG_CONTROL_VERSION %d, but the server was compiled with PG_CONTROL_VERSION %d." msgstr "Il cluster di database è stato inizializzato con PG_CONTROL_VERSION %d, ma il server è stato compilato con PG_CONTROL_VERSION %d." -#: access/transam/xlog.c:4315 access/transam/xlog.c:4339 -#: access/transam/xlog.c:4346 access/transam/xlog.c:4351 +#: access/transam/xlog.c:4342 access/transam/xlog.c:4366 +#: access/transam/xlog.c:4373 access/transam/xlog.c:4378 #, c-format msgid "It looks like you need to initdb." msgstr "Sembra sia necessario eseguire initdb." -#: access/transam/xlog.c:4326 +#: access/transam/xlog.c:4353 #, c-format msgid "incorrect checksum in control file" msgstr "il checksum nel file di controllo non è corretto" -#: access/transam/xlog.c:4336 +#: access/transam/xlog.c:4363 #, c-format msgid "The database cluster was initialized with CATALOG_VERSION_NO %d, but the server was compiled with CATALOG_VERSION_NO %d." msgstr "Il cluster di database è stato inizializzato con CATALOG_VERSION_NO %d, ma il server è stato compilato con CATALOG_VERSION_NO %d." -#: access/transam/xlog.c:4343 +#: access/transam/xlog.c:4370 #, c-format msgid "The database cluster was initialized with MAXALIGN %d, but the server was compiled with MAXALIGN %d." msgstr "Il cluster di database è stato inizializzato con MAXALIGN %d, ma il server è stato compilato con MAXALIGN %d." -#: access/transam/xlog.c:4350 +#: access/transam/xlog.c:4377 #, c-format msgid "The database cluster appears to use a different floating-point number format than the server executable." msgstr "Il cluster di database sta usando un formato per i numeri in virgola mobile diverso da quello usato dall'eseguibile del server." -#: access/transam/xlog.c:4355 +#: access/transam/xlog.c:4382 #, c-format msgid "The database cluster was initialized with BLCKSZ %d, but the server was compiled with BLCKSZ %d." msgstr "Il cluster di database è stato inizializzato con BLCKSZ %d, ma il server è stato compilato con BLCKSZ %d." -#: access/transam/xlog.c:4358 access/transam/xlog.c:4365 -#: access/transam/xlog.c:4372 access/transam/xlog.c:4379 -#: access/transam/xlog.c:4386 access/transam/xlog.c:4393 -#: access/transam/xlog.c:4400 access/transam/xlog.c:4407 -#: access/transam/xlog.c:4415 access/transam/xlog.c:4422 -#: access/transam/xlog.c:4431 access/transam/xlog.c:4438 -#: access/transam/xlog.c:4447 access/transam/xlog.c:4454 +#: access/transam/xlog.c:4385 access/transam/xlog.c:4392 +#: access/transam/xlog.c:4399 access/transam/xlog.c:4406 +#: access/transam/xlog.c:4413 access/transam/xlog.c:4420 +#: access/transam/xlog.c:4427 access/transam/xlog.c:4434 +#: access/transam/xlog.c:4442 access/transam/xlog.c:4449 +#: access/transam/xlog.c:4458 access/transam/xlog.c:4465 +#: access/transam/xlog.c:4474 access/transam/xlog.c:4481 #, c-format msgid "It looks like you need to recompile or initdb." msgstr "Si consiglia di ricompilare il sistema o di eseguire initdb." -#: access/transam/xlog.c:4362 +#: access/transam/xlog.c:4389 #, c-format msgid "The database cluster was initialized with RELSEG_SIZE %d, but the server was compiled with RELSEG_SIZE %d." msgstr "Il cluster di database è stato inizializzato con RELSEG_SIZE %d, ma il server è stato compilato con RELSEG_SIZE %d." -#: access/transam/xlog.c:4369 +#: access/transam/xlog.c:4396 #, c-format msgid "The database cluster was initialized with XLOG_BLCKSZ %d, but the server was compiled with XLOG_BLCKSZ %d." msgstr "Il cluster di database è stato inizializzato con XLOG_BLOCKSZ %d, ma il server è stato compilato con XLOG_BLOCKSZ %d." -#: access/transam/xlog.c:4376 +#: access/transam/xlog.c:4403 #, c-format msgid "The database cluster was initialized with XLOG_SEG_SIZE %d, but the server was compiled with XLOG_SEG_SIZE %d." msgstr "Il cluster di database è stato inizializzato con XLOG_SEG_SIZE %d, ma il server è stato compilato con XLOG_SEG_SIZE %d." -#: access/transam/xlog.c:4383 +#: access/transam/xlog.c:4410 #, c-format msgid "The database cluster was initialized with NAMEDATALEN %d, but the server was compiled with NAMEDATALEN %d." msgstr "Il cluster di database è stato inizializzato con NAMEDATALEN %d, ma il server è stato compilato con NAMEDATALEN %d." -#: access/transam/xlog.c:4390 +#: access/transam/xlog.c:4417 #, c-format msgid "The database cluster was initialized with INDEX_MAX_KEYS %d, but the server was compiled with INDEX_MAX_KEYS %d." msgstr "Il cluster di database è stato inizializzato con INDEX_MAX_KEYS %d, ma il server è stato compilato con INDEX_MAX_KEYS %d." -#: access/transam/xlog.c:4397 +#: access/transam/xlog.c:4424 #, c-format msgid "The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d, but the server was compiled with TOAST_MAX_CHUNK_SIZE %d." msgstr "Il cluster di database è stato inizializzato con TOAST_MAX_CHUNK_SIZE %d, ma il server è stato compilato con TOAST_MAX_CHUNK_SIZE %d." -#: access/transam/xlog.c:4404 +#: access/transam/xlog.c:4431 #, c-format msgid "The database cluster was initialized with LOBLKSIZE %d, but the server was compiled with LOBLKSIZE %d." msgstr "Il cluster di database è stato inizializzato con LOBLKSIZE %d, ma il server è stato compilato con LOBLKSIZE %d." -#: access/transam/xlog.c:4413 +#: access/transam/xlog.c:4440 #, c-format msgid "The database cluster was initialized without HAVE_INT64_TIMESTAMP but the server was compiled with HAVE_INT64_TIMESTAMP." msgstr "Il cluster di database è stato inizializzato senza HAVE_INT64_TIMESTAMP ma il server è stato compilato con HAVE_INT64_TIMESTAMP." -#: access/transam/xlog.c:4420 +#: access/transam/xlog.c:4447 #, c-format msgid "The database cluster was initialized with HAVE_INT64_TIMESTAMP but the server was compiled without HAVE_INT64_TIMESTAMP." msgstr "Il cluster di database è stato inizializzato con HAVE_INT64_TIMESTAMP ma il server è stato compilato senza HAVE_INT64_TIMESTAMP." -#: access/transam/xlog.c:4429 +#: access/transam/xlog.c:4456 #, c-format msgid "The database cluster was initialized without USE_FLOAT4_BYVAL but the server was compiled with USE_FLOAT4_BYVAL." msgstr "Il cluster di database è stato inizializzato senza USE_FLOAT4_BYVAL, ma il server è stato compilato con USE_FLOAT4_BYVAL." -#: access/transam/xlog.c:4436 +#: access/transam/xlog.c:4463 #, c-format msgid "The database cluster was initialized with USE_FLOAT4_BYVAL but the server was compiled without USE_FLOAT4_BYVAL." msgstr "Il cluster di database è stato inizializzato con USE_FLOAT4_BYVAL, ma il server è stato compilato senza USE_FLOAT4_BYVAL." -#: access/transam/xlog.c:4445 +#: access/transam/xlog.c:4472 #, c-format msgid "The database cluster was initialized without USE_FLOAT8_BYVAL but the server was compiled with USE_FLOAT8_BYVAL." msgstr "Il cluster di database è stato inizializzato senza USE_FLOAT8_BYVAL, ma il server è stato compilato con USE_FLOAT8_BYVAL." -#: access/transam/xlog.c:4452 +#: access/transam/xlog.c:4479 #, c-format msgid "The database cluster was initialized with USE_FLOAT8_BYVAL but the server was compiled without USE_FLOAT8_BYVAL." msgstr "Il cluster di database è stato inizializzato con USE_FLOAT8_BYVAL, ma il server è stato compilato senza USE_FLOAT8_BYVAL." -#: access/transam/xlog.c:4875 +#: access/transam/xlog.c:4900 #, c-format msgid "could not write bootstrap transaction log file: %m" msgstr "scrittura nel file di log della transazione di bootstrap fallita: %m" -#: access/transam/xlog.c:4881 +#: access/transam/xlog.c:4906 #, c-format msgid "could not fsync bootstrap transaction log file: %m" msgstr "fsync del file di log della transazione di bootstrap fallito: %m" -#: access/transam/xlog.c:4886 +#: access/transam/xlog.c:4911 #, c-format msgid "could not close bootstrap transaction log file: %m" msgstr "chiusura del file di log della transazione di bootstrap fallita: %m" -#: access/transam/xlog.c:4961 +#: access/transam/xlog.c:4986 #, c-format msgid "could not open recovery command file \"%s\": %m" msgstr "apertura del file di ripristino \"%s\" fallita: %m" -#: access/transam/xlog.c:5007 access/transam/xlog.c:5090 +#: access/transam/xlog.c:5032 access/transam/xlog.c:5117 #, c-format msgid "invalid value for recovery parameter \"%s\": \"%s\"" msgstr "valore non valido per il parametro di ripristino \"%s\": \"%s\"" -#: access/transam/xlog.c:5010 +#: access/transam/xlog.c:5035 #, c-format msgid "Valid values are \"pause\", \"promote\", and \"shutdown\"." msgstr "I valori validi sono \"pause\", \"promote\" e \"shutdown\"." # da non tradurre # DV: perché (già tradotto peraltro) -#: access/transam/xlog.c:5029 +#: access/transam/xlog.c:5055 #, c-format msgid "recovery_target_timeline is not a valid number: \"%s\"" msgstr "recovery_target_timeline non ha un valore numerico valido: \"%s\"" -#: access/transam/xlog.c:5045 +#: access/transam/xlog.c:5072 #, c-format msgid "recovery_target_xid is not a valid number: \"%s\"" msgstr "recovery_target_xid non ha un valore numerico valido: \"%s\"" -#: access/transam/xlog.c:5076 +#: access/transam/xlog.c:5103 #, c-format msgid "recovery_target_name is too long (maximum %d characters)" msgstr "il recovery_target_name è troppo lungo (massimo %d caratteri)" -#: access/transam/xlog.c:5093 +#: access/transam/xlog.c:5120 #, c-format msgid "The only allowed value is \"immediate\"." msgstr "Il solo valore permesso è \"immediate\"." -#: access/transam/xlog.c:5106 access/transam/xlog.c:5117 -#: commands/extension.c:533 commands/extension.c:541 utils/misc/guc.c:5637 +#: access/transam/xlog.c:5133 access/transam/xlog.c:5144 +#: commands/extension.c:534 commands/extension.c:542 utils/misc/guc.c:5640 #, c-format msgid "parameter \"%s\" requires a Boolean value" msgstr "il parametro \"%s\" richiede un valore booleano" -#: access/transam/xlog.c:5152 +#: access/transam/xlog.c:5179 #, c-format msgid "parameter \"%s\" requires a temporal value" msgstr "il parametro \"%s\" richiede un valore temporale" -#: access/transam/xlog.c:5154 catalog/dependency.c:991 -#: catalog/dependency.c:992 catalog/dependency.c:998 catalog/dependency.c:999 -#: catalog/dependency.c:1010 catalog/dependency.c:1011 -#: catalog/objectaddress.c:1100 commands/tablecmds.c:795 -#: commands/tablecmds.c:9447 commands/user.c:1045 commands/view.c:482 -#: libpq/auth.c:304 storage/lmgr/deadlock.c:1139 storage/lmgr/proc.c:1276 -#: utils/adt/acl.c:5281 utils/misc/guc.c:5659 utils/misc/guc.c:5752 -#: utils/misc/guc.c:9686 utils/misc/guc.c:9720 utils/misc/guc.c:9754 -#: utils/misc/guc.c:9788 utils/misc/guc.c:9823 +#: access/transam/xlog.c:5181 catalog/dependency.c:990 catalog/dependency.c:991 +#: catalog/dependency.c:997 catalog/dependency.c:998 catalog/dependency.c:1009 +#: catalog/dependency.c:1010 catalog/objectaddress.c:1100 +#: commands/tablecmds.c:796 commands/tablecmds.c:9542 commands/user.c:1045 +#: commands/view.c:499 libpq/auth.c:307 replication/syncrep.c:919 +#: storage/lmgr/deadlock.c:1139 storage/lmgr/proc.c:1278 utils/adt/acl.c:5281 +#: utils/misc/guc.c:5662 utils/misc/guc.c:5755 utils/misc/guc.c:9708 +#: utils/misc/guc.c:9742 utils/misc/guc.c:9776 utils/misc/guc.c:9810 +#: utils/misc/guc.c:9845 #, c-format msgid "%s" msgstr "%s" -#: access/transam/xlog.c:5160 +#: access/transam/xlog.c:5188 #, c-format msgid "unrecognized recovery parameter \"%s\"" msgstr "parametro di ripristino \"%s\" sconosciuto" -#: access/transam/xlog.c:5171 +#: access/transam/xlog.c:5199 #, c-format msgid "recovery command file \"%s\" specified neither primary_conninfo nor restore_command" msgstr "il file dei comandi di ripristino \"%s\" non specifica né primary_conninfo né restore_command" -#: access/transam/xlog.c:5173 +#: access/transam/xlog.c:5201 #, c-format msgid "The database server will regularly poll the pg_xlog subdirectory to check for files placed there." msgstr "Il server database ispezionerà regolarmente la sottodirectory pg_xlog per controllare se vi vengono aggiunti dei file." -#: access/transam/xlog.c:5179 +#: access/transam/xlog.c:5208 #, c-format msgid "recovery command file \"%s\" must specify restore_command when standby mode is not enabled" msgstr "il file dei comandi di ripristino \"%s\" deve specificare restore_command quando la modalità standby non è abilitata" -#: access/transam/xlog.c:5209 +#: access/transam/xlog.c:5229 +#, c-format +msgid "standby mode is not supported by single-user servers" +msgstr "la modalità di standby non è supportata per i server a utente singolo" + +#: access/transam/xlog.c:5248 #, c-format msgid "recovery target timeline %u does not exist" msgstr "la timeline destinazione di recupero %u non esiste" -#: access/transam/xlog.c:5330 +#: access/transam/xlog.c:5369 #, c-format msgid "archive recovery complete" msgstr "il ripristino dell'archivio è stato completato" -#: access/transam/xlog.c:5389 access/transam/xlog.c:5617 +#: access/transam/xlog.c:5428 access/transam/xlog.c:5656 #, c-format msgid "recovery stopping after reaching consistency" msgstr "il ripristino è stato interrotto dopo aver raggiunto la consistenza" -#: access/transam/xlog.c:5477 +#: access/transam/xlog.c:5516 #, c-format msgid "recovery stopping before commit of transaction %u, time %s" msgstr "il ripristino è stato interrotto prima del commit della transazione %u, orario %s" -#: access/transam/xlog.c:5484 +#: access/transam/xlog.c:5523 #, c-format msgid "recovery stopping before abort of transaction %u, time %s" msgstr "il ripristino è stato interrotto prima dell'abort della transazione %u alle %s" -#: access/transam/xlog.c:5529 +#: access/transam/xlog.c:5568 #, c-format msgid "recovery stopping at restore point \"%s\", time %s" msgstr "il ripristino è stato interrotto al punto di ripristino \"%s\" alle %s" -#: access/transam/xlog.c:5597 +#: access/transam/xlog.c:5636 #, c-format msgid "recovery stopping after commit of transaction %u, time %s" msgstr "il ripristino è stato interrotto dopo il commit della transazione %u alle %s" -#: access/transam/xlog.c:5605 +#: access/transam/xlog.c:5644 #, c-format msgid "recovery stopping after abort of transaction %u, time %s" msgstr "il ripristino è stato interrotto dopo l'abort della transazione %u alle %s" -#: access/transam/xlog.c:5644 +#: access/transam/xlog.c:5683 #, c-format msgid "recovery has paused" msgstr "ripristino in pausa" -#: access/transam/xlog.c:5645 +#: access/transam/xlog.c:5684 #, c-format msgid "Execute pg_xlog_replay_resume() to continue." msgstr "Esegui pg_xlog_replay_resume() per continuare." -#: access/transam/xlog.c:5852 +#: access/transam/xlog.c:5891 #, c-format msgid "hot standby is not possible because %s = %d is a lower setting than on the master server (its value was %d)" msgstr "l'hot standby non è possibile perché %s = %d è un'impostazione inferiore a quella del server master (il cui valore era %d)" -#: access/transam/xlog.c:5878 +#: access/transam/xlog.c:5917 #, c-format msgid "WAL was generated with wal_level=minimal, data may be missing" msgstr "il WAL è stato generato con wal_level=minimal, alcuni dati potrebbero mancare" -#: access/transam/xlog.c:5879 +#: access/transam/xlog.c:5918 #, c-format msgid "This happens if you temporarily set wal_level=minimal without taking a new base backup." msgstr "Questo avviene se imposti temporaneamente wal_level=minimal senza effettuare un nuovo backup di base." -#: access/transam/xlog.c:5890 +#: access/transam/xlog.c:5929 #, c-format msgid "hot standby is not possible because wal_level was not set to \"replica\" or higher on the master server" msgstr "l'hot standby non è possibile perché il wal_level non è impostato a \"replica\" o superiore nel server master" -#: access/transam/xlog.c:5891 +#: access/transam/xlog.c:5930 #, c-format msgid "Either set wal_level to \"replica\" on the master, or turn off hot_standby here." msgstr "Imposta il wal_level a \"replica\" sul master oppure disattiva hot_standby qui." -#: access/transam/xlog.c:5948 +#: access/transam/xlog.c:5987 #, c-format msgid "control file contains invalid data" msgstr "il file di controllo contiene dati non validi" -#: access/transam/xlog.c:5954 +#: access/transam/xlog.c:5993 #, c-format msgid "database system was shut down at %s" msgstr "il database è stato arrestato alle %s" -#: access/transam/xlog.c:5959 +#: access/transam/xlog.c:5998 #, c-format msgid "database system was shut down in recovery at %s" msgstr "il database è stato arrestato durante il ripristino alle %s" -#: access/transam/xlog.c:5963 +#: access/transam/xlog.c:6002 #, c-format msgid "database system shutdown was interrupted; last known up at %s" msgstr "l'arresto del database è stato interrotto; l'ultimo segno di vita risale alle %s" -#: access/transam/xlog.c:5967 +#: access/transam/xlog.c:6006 #, c-format msgid "database system was interrupted while in recovery at %s" msgstr "il database è stato interrotto alle %s mentre era in fase di ripristino" -#: access/transam/xlog.c:5969 +#: access/transam/xlog.c:6008 #, c-format msgid "This probably means that some data is corrupted and you will have to use the last backup for recovery." msgstr "Questo probabilmente significa che alcuni dati sono corrotti e dovrai usare il backup più recente per il ripristino." -#: access/transam/xlog.c:5973 +#: access/transam/xlog.c:6012 #, c-format msgid "database system was interrupted while in recovery at log time %s" msgstr "il database è stato interrotto all'orario di log %s mentre era in fase di ripristino" -#: access/transam/xlog.c:5975 +#: access/transam/xlog.c:6014 #, c-format msgid "If this has occurred more than once some data might be corrupted and you might need to choose an earlier recovery target." msgstr "Se ciò è avvenuto più di una volta, alcuni dati potrebbero essere corrotti e potresti dover scegliere una destinazione di ripristino precedente." -#: access/transam/xlog.c:5979 +#: access/transam/xlog.c:6018 #, c-format msgid "database system was interrupted; last known up at %s" msgstr "il database è stato interrotto; l'ultimo segno di vita risale alle %s" -#: access/transam/xlog.c:6035 +#: access/transam/xlog.c:6074 #, c-format msgid "entering standby mode" msgstr "inizio modalità standby" -#: access/transam/xlog.c:6038 +#: access/transam/xlog.c:6077 #, c-format msgid "starting point-in-time recovery to XID %u" msgstr "avvio del ripristino point-in-time allo XID %u" -#: access/transam/xlog.c:6042 +#: access/transam/xlog.c:6081 #, c-format msgid "starting point-in-time recovery to %s" msgstr "avvio del ripristino point-in-time alle %s" -#: access/transam/xlog.c:6046 +#: access/transam/xlog.c:6085 #, c-format msgid "starting point-in-time recovery to \"%s\"" msgstr "avvio del ripristino point-in-time a \"%s\"" -#: access/transam/xlog.c:6050 +#: access/transam/xlog.c:6089 #, c-format msgid "starting point-in-time recovery to earliest consistent point" msgstr "avvio del ripristino point-in-time al precedente punto consistente" -#: access/transam/xlog.c:6053 +#: access/transam/xlog.c:6092 #, c-format msgid "starting archive recovery" msgstr "avvio del ripristino dell'archivio" -#: access/transam/xlog.c:6097 access/transam/xlog.c:6225 +#: access/transam/xlog.c:6136 access/transam/xlog.c:6264 #, c-format msgid "checkpoint record is at %X/%X" msgstr "il record di checkpoint si trova in %X/%X" -#: access/transam/xlog.c:6111 +#: access/transam/xlog.c:6150 #, c-format msgid "could not find redo location referenced by checkpoint record" msgstr "localizzazione della posizione di redo referenziata dal record di checkpoint fallita" -#: access/transam/xlog.c:6112 access/transam/xlog.c:6119 +#: access/transam/xlog.c:6151 access/transam/xlog.c:6158 #, c-format msgid "If you are not restoring from a backup, try removing the file \"%s/backup_label\"." msgstr "Se non si sta effettuando il ripristino da backup, prova a rimuovere il file \"%s/backup_label\"." -#: access/transam/xlog.c:6118 +#: access/transam/xlog.c:6157 #, c-format msgid "could not locate required checkpoint record" msgstr "localizzazione del record di checkpoint richiesto fallita" -#: access/transam/xlog.c:6144 commands/tablespace.c:645 +#: access/transam/xlog.c:6183 commands/tablespace.c:641 #, c-format msgid "could not create symbolic link \"%s\": %m" msgstr "creazione del link simbolico \"%s\" fallita: %m" -#: access/transam/xlog.c:6176 +#: access/transam/xlog.c:6215 access/transam/xlog.c:6221 #, c-format msgid "ignoring file \"%s\" because no file \"%s\" exists" msgstr "il file \"%s\" verrà ignorato perché il file \"%s\" non esiste" -#: access/transam/xlog.c:6178 access/transam/xlog.c:10918 +#: access/transam/xlog.c:6217 access/transam/xlog.c:11032 #, c-format msgid "File \"%s\" was renamed to \"%s\"." msgstr "Il file \"%s\" è stato rinominato in \"%s\"." -#: access/transam/xlog.c:6182 -#, c-format -msgid "ignoring \"%s\" file because no \"%s\" file exists" -msgstr "\"%s\" verrà ignorato perché il file \"%s\" non esiste" - -#: access/transam/xlog.c:6184 +#: access/transam/xlog.c:6223 #, c-format msgid "Could not rename file \"%s\" to \"%s\": %m." msgstr "Cambio del nome del file da \"%s\" a \"%s\" fallito: %m." -#: access/transam/xlog.c:6235 access/transam/xlog.c:6250 +#: access/transam/xlog.c:6274 access/transam/xlog.c:6289 #, c-format msgid "could not locate a valid checkpoint record" msgstr "localizzazione di un record di checkpoint valido fallita" -#: access/transam/xlog.c:6244 +#: access/transam/xlog.c:6283 #, c-format msgid "using previous checkpoint record at %X/%X" msgstr "si sta usando il precedente record di checkpoint in %X/%X" -#: access/transam/xlog.c:6288 +#: access/transam/xlog.c:6327 #, c-format msgid "requested timeline %u is not a child of this server's history" msgstr "la timeline richiesta %u non è figlia della storia di questo server" -#: access/transam/xlog.c:6290 +#: access/transam/xlog.c:6329 #, c-format msgid "Latest checkpoint is at %X/%X on timeline %u, but in the history of the requested timeline, the server forked off from that timeline at %X/%X." msgstr "L'ultimo checkpoint è a %X/%X sulla timeline %u, ma nella storia della timeline richiesta, il server si è separato da quella timeline a %X/%X." -#: access/transam/xlog.c:6306 +#: access/transam/xlog.c:6345 #, c-format msgid "requested timeline %u does not contain minimum recovery point %X/%X on timeline %u" msgstr "la timeline richiesta %u non contiene il punto di recupero minimo %X/%X sulla timeline %u" -#: access/transam/xlog.c:6337 +#: access/transam/xlog.c:6376 #, c-format msgid "invalid next transaction ID" msgstr "l'ID della prossima transazione non è valido" -#: access/transam/xlog.c:6420 +#: access/transam/xlog.c:6459 #, c-format msgid "invalid redo in checkpoint record" msgstr "il redo nel record di checkpoint non è valido" -#: access/transam/xlog.c:6431 +#: access/transam/xlog.c:6470 #, c-format msgid "invalid redo record in shutdown checkpoint" msgstr "record di redo non valido nel checkpoint di arresto" -#: access/transam/xlog.c:6459 +#: access/transam/xlog.c:6498 #, c-format msgid "database system was not properly shut down; automatic recovery in progress" msgstr "il database non è stato arrestato correttamente; ripristino automatico in corso" -#: access/transam/xlog.c:6463 +#: access/transam/xlog.c:6502 #, c-format msgid "crash recovery starts in timeline %u and has target timeline %u" msgstr "il recupero dal crash comincia nella timeline %u e si conclude nella timeline %u" -#: access/transam/xlog.c:6507 +#: access/transam/xlog.c:6546 #, c-format msgid "backup_label contains data inconsistent with control file" msgstr "backup_label contiene dati non consistenti col file di controllo" -#: access/transam/xlog.c:6508 +#: access/transam/xlog.c:6547 #, c-format msgid "This means that the backup is corrupted and you will have to use another backup for recovery." msgstr "Questo vuol dire che il backup è corrotto e sarà necessario usare un altro backup per il ripristino." -#: access/transam/xlog.c:6582 +#: access/transam/xlog.c:6621 #, c-format msgid "initializing for hot standby" msgstr "inizializzazione per l'hot standby" -#: access/transam/xlog.c:6714 +#: access/transam/xlog.c:6753 #, c-format msgid "redo starts at %X/%X" msgstr "il redo inizia in %X/%X" -#: access/transam/xlog.c:6939 +#: access/transam/xlog.c:6978 #, c-format msgid "requested recovery stop point is before consistent recovery point" msgstr "lo stop point di ripristino è posto prima di un punto di ripristino consistente" -#: access/transam/xlog.c:6977 +#: access/transam/xlog.c:7016 #, c-format msgid "redo done at %X/%X" msgstr "redo concluso in %X/%X" -#: access/transam/xlog.c:6982 access/transam/xlog.c:8906 +#: access/transam/xlog.c:7021 access/transam/xlog.c:8969 #, c-format msgid "last completed transaction was at log time %s" msgstr "l'ultima transazione è stata completata all'orario di log %s" -#: access/transam/xlog.c:6991 +#: access/transam/xlog.c:7030 #, c-format msgid "redo is not required" msgstr "redo non richiesto" -#: access/transam/xlog.c:7066 access/transam/xlog.c:7070 +#: access/transam/xlog.c:7105 access/transam/xlog.c:7109 #, c-format msgid "WAL ends before end of online backup" msgstr "il WAL termina prima della fine del backup online" -#: access/transam/xlog.c:7067 +#: access/transam/xlog.c:7106 #, c-format msgid "All WAL generated while online backup was taken must be available at recovery." msgstr "Tutti i file WAL generati mentre il backup online veniva effettuato devono essere disponibili al momento del ripristino." -#: access/transam/xlog.c:7071 +#: access/transam/xlog.c:7110 #, c-format msgid "Online backup started with pg_start_backup() must be ended with pg_stop_backup(), and all WAL up to that point must be available at recovery." msgstr "Un backup online iniziato con pg_start_backup() deve essere terminato con pg_stop_backup(), e tutti i file WAL fino a quel punto devono essere disponibili per il ripristino." -#: access/transam/xlog.c:7074 +#: access/transam/xlog.c:7113 #, c-format msgid "WAL ends before consistent recovery point" msgstr "il WAL termina prima di un punto di ripristino consistente" -#: access/transam/xlog.c:7101 +#: access/transam/xlog.c:7140 #, c-format msgid "selected new timeline ID: %u" msgstr "l'ID della nuova timeline selezionata è %u" -#: access/transam/xlog.c:7512 +#: access/transam/xlog.c:7551 #, c-format msgid "consistent recovery state reached at %X/%X" msgstr "è stato raggiunto uno stato di ripristino consistente a %X/%X" -#: access/transam/xlog.c:7703 +#: access/transam/xlog.c:7742 #, c-format msgid "invalid primary checkpoint link in control file" msgstr "il link nel file di controllo al checkpoint primario non è valido" -#: access/transam/xlog.c:7707 +#: access/transam/xlog.c:7746 #, c-format msgid "invalid secondary checkpoint link in control file" msgstr "il link nel file di controllo al checkpoint secondario non è valido" -#: access/transam/xlog.c:7711 +#: access/transam/xlog.c:7750 #, c-format msgid "invalid checkpoint link in backup_label file" msgstr "il link al checkpoint nel file backup_label non è valido" -#: access/transam/xlog.c:7728 +#: access/transam/xlog.c:7767 #, c-format msgid "invalid primary checkpoint record" msgstr "il record del checkpoint primario non è valido" -#: access/transam/xlog.c:7732 +#: access/transam/xlog.c:7771 #, c-format msgid "invalid secondary checkpoint record" msgstr "il record del checkpoint secondario non è valido" -#: access/transam/xlog.c:7736 +#: access/transam/xlog.c:7775 #, c-format msgid "invalid checkpoint record" msgstr "il record del checkpoint non è valido" -#: access/transam/xlog.c:7747 +#: access/transam/xlog.c:7786 #, c-format msgid "invalid resource manager ID in primary checkpoint record" msgstr "l'ID del resource manager nel record del checkpoint primario non è valido" -#: access/transam/xlog.c:7751 +#: access/transam/xlog.c:7790 #, c-format msgid "invalid resource manager ID in secondary checkpoint record" msgstr "l'ID del resource manager nel record del checkpoint secondario non è valido" -#: access/transam/xlog.c:7755 +#: access/transam/xlog.c:7794 #, c-format msgid "invalid resource manager ID in checkpoint record" msgstr "l'ID del resource manager nel record del checkpoint non è valido" -#: access/transam/xlog.c:7767 +#: access/transam/xlog.c:7806 #, c-format msgid "invalid xl_info in primary checkpoint record" msgstr "l'xl_info nel record del checkpoint primario non è valido" -#: access/transam/xlog.c:7771 +#: access/transam/xlog.c:7810 #, c-format msgid "invalid xl_info in secondary checkpoint record" msgstr "l'xl_info nel record del checkpoint secondario non è valido" -#: access/transam/xlog.c:7775 +#: access/transam/xlog.c:7814 #, c-format msgid "invalid xl_info in checkpoint record" msgstr "l'xl_info nel record del checkpoint non è valido" -#: access/transam/xlog.c:7786 +#: access/transam/xlog.c:7825 #, c-format msgid "invalid length of primary checkpoint record" msgstr "la lunghezza del record del checkpoint primario non è valida" -#: access/transam/xlog.c:7790 +#: access/transam/xlog.c:7829 #, c-format msgid "invalid length of secondary checkpoint record" msgstr "la lunghezza del record del checkpoint secondario non è valida" -#: access/transam/xlog.c:7794 +#: access/transam/xlog.c:7833 #, c-format msgid "invalid length of checkpoint record" msgstr "la lunghezza del record del checkpoint non è valida" -#: access/transam/xlog.c:7962 +#: access/transam/xlog.c:8001 #, c-format msgid "shutting down" msgstr "arresto in corso" -#: access/transam/xlog.c:8475 +#: access/transam/xlog.c:8514 #, c-format msgid "concurrent transaction log activity while database system is shutting down" msgstr "rilevata attività concorrente sul log delle transazioni durante l'arresto del database" -#: access/transam/xlog.c:8726 +#: access/transam/xlog.c:8768 #, c-format msgid "skipping restartpoint, recovery has already ended" msgstr "si tralascia il restartpoint, il ripristino è ormai terminato" -#: access/transam/xlog.c:8749 +#: access/transam/xlog.c:8791 #, c-format msgid "skipping restartpoint, already performed at %X/%X" msgstr "si tralascia il restartpoint, già eseguito in %X/%X" -#: access/transam/xlog.c:8904 +#: access/transam/xlog.c:8967 #, c-format msgid "recovery restart point at %X/%X" msgstr "punto di avvio del ripristino in %X/%X" -#: access/transam/xlog.c:9037 +#: access/transam/xlog.c:9100 #, c-format msgid "restore point \"%s\" created at %X/%X" msgstr "punto di ripristino \"%s\" creato in %X/%X" -#: access/transam/xlog.c:9167 +#: access/transam/xlog.c:9230 #, c-format msgid "unexpected previous timeline ID %u (current timeline ID %u) in checkpoint record" msgstr "timeline precedente con ID %u non prevista (l'ID della timeline corrente è %u) nel record di checkpoint" -#: access/transam/xlog.c:9176 +#: access/transam/xlog.c:9239 #, c-format msgid "unexpected timeline ID %u (after %u) in checkpoint record" msgstr "timeline ID %u imprevista (dopo %u) nel record di checkpoint" -#: access/transam/xlog.c:9192 +#: access/transam/xlog.c:9255 #, c-format msgid "unexpected timeline ID %u in checkpoint record, before reaching minimum recovery point %X/%X on timeline %u" msgstr "timeline ID %u imprevista nel record di checkpoint, prima di raggiungere il punto di recupero minimo %X/%X sulla timeline %u" -#: access/transam/xlog.c:9263 +#: access/transam/xlog.c:9326 #, c-format msgid "online backup was canceled, recovery cannot continue" msgstr "il backup online è stato annullato, il ripristino non può continuare" -#: access/transam/xlog.c:9319 access/transam/xlog.c:9366 -#: access/transam/xlog.c:9389 +#: access/transam/xlog.c:9382 access/transam/xlog.c:9429 +#: access/transam/xlog.c:9452 #, c-format msgid "unexpected timeline ID %u (should be %u) in checkpoint record" msgstr "l'ID della timeline %u (che dovrebbe essere %u) non era prevista nel record di checkpoint" -#: access/transam/xlog.c:9664 +#: access/transam/xlog.c:9727 #, c-format msgid "could not fsync log segment %s: %m" msgstr "fsync del segmento di log %s fallito: %m" -#: access/transam/xlog.c:9688 +#: access/transam/xlog.c:9751 #, c-format msgid "could not fsync log file %s: %m" msgstr "fsync del file di log %s fallito: %m" -#: access/transam/xlog.c:9696 +#: access/transam/xlog.c:9759 #, c-format msgid "could not fsync write-through log file %s: %m" msgstr "fsync write-through del file di log %s fallito: %m" -#: access/transam/xlog.c:9705 +#: access/transam/xlog.c:9768 #, c-format msgid "could not fdatasync log file %s: %m" msgstr "fdatasync del file di log %s fallito: %m" -#: access/transam/xlog.c:9796 access/transam/xlog.c:10267 -#: access/transam/xlogfuncs.c:295 access/transam/xlogfuncs.c:322 -#: access/transam/xlogfuncs.c:361 access/transam/xlogfuncs.c:382 -#: access/transam/xlogfuncs.c:403 +#: access/transam/xlog.c:9859 access/transam/xlog.c:10363 +#: access/transam/xlogfuncs.c:294 access/transam/xlogfuncs.c:321 +#: access/transam/xlogfuncs.c:360 access/transam/xlogfuncs.c:381 +#: access/transam/xlogfuncs.c:402 #, c-format msgid "WAL control functions cannot be executed during recovery." msgstr "le funzioni di controllo WAL non possono essere eseguite durante il ripristino." -#: access/transam/xlog.c:9805 access/transam/xlog.c:10276 +#: access/transam/xlog.c:9868 access/transam/xlog.c:10372 #, c-format msgid "WAL level not sufficient for making an online backup" msgstr "livello WAL non sufficiente per creare un backup online" -#: access/transam/xlog.c:9806 access/transam/xlog.c:10277 -#: access/transam/xlogfuncs.c:328 +#: access/transam/xlog.c:9869 access/transam/xlog.c:10373 +#: access/transam/xlogfuncs.c:327 #, c-format msgid "wal_level must be set to \"replica\" or \"logical\" at server start." msgstr "Il wal_level deve essere impostato a \"replica\" o \"logical\" all'avvio del server." -#: access/transam/xlog.c:9811 +#: access/transam/xlog.c:9874 #, c-format msgid "backup label too long (max %d bytes)" msgstr "etichetta di backup troppo lunga (massimo %d byte)" -#: access/transam/xlog.c:9843 access/transam/xlog.c:10115 -#: access/transam/xlog.c:10153 +#: access/transam/xlog.c:9911 access/transam/xlog.c:10183 +#: access/transam/xlog.c:10221 #, c-format msgid "a backup is already in progress" msgstr "c'è già un backup in corso" -#: access/transam/xlog.c:9844 +#: access/transam/xlog.c:9912 #, c-format msgid "Run pg_stop_backup() and try again." msgstr "Esegui pg_stop_backup() e prova di nuovo." -#: access/transam/xlog.c:9939 +#: access/transam/xlog.c:10007 #, c-format msgid "WAL generated with full_page_writes=off was replayed since last restartpoint" msgstr "un WAL generato con full_page_writes=off è stato riprodotto dopo l'ultimo restartpoint" -#: access/transam/xlog.c:9941 access/transam/xlog.c:10440 +#: access/transam/xlog.c:10009 access/transam/xlog.c:10554 #, c-format msgid "This means that the backup being taken on the standby is corrupt and should not be used. Enable full_page_writes and run CHECKPOINT on the master, and then try an online backup again." msgstr "Ciò vuol dire che il backup che sta venendo preso sullo standby è corrotto e non dovrebbe essere usato. Abilita full_page_writes ed esegui CHECKPOINT sul master, poi prova ad effettuare nuovamente un backup online.\"" -#: access/transam/xlog.c:10008 replication/basebackup.c:1038 +#: access/transam/xlog.c:10076 replication/basebackup.c:1026 #: utils/adt/misc.c:498 #, c-format msgid "could not read symbolic link \"%s\": %m" msgstr "lettura del link simbolico \"%s\" fallita: %m" -#: access/transam/xlog.c:10015 replication/basebackup.c:1043 +#: access/transam/xlog.c:10083 replication/basebackup.c:1031 #: utils/adt/misc.c:503 #, c-format msgid "symbolic link \"%s\" target is too long" msgstr "la destinazione del link simbolico \"%s\" è troppo lunga" -#: access/transam/xlog.c:10068 commands/tablespace.c:395 -#: commands/tablespace.c:557 replication/basebackup.c:1059 -#: utils/adt/misc.c:511 +#: access/transam/xlog.c:10136 commands/tablespace.c:391 +#: commands/tablespace.c:553 replication/basebackup.c:1047 utils/adt/misc.c:511 #, c-format msgid "tablespaces are not supported on this platform" msgstr "i tablespace non sono supportati su questa piattaforma" -#: access/transam/xlog.c:10109 access/transam/xlog.c:10147 -#: access/transam/xlog.c:10326 access/transam/xlogarchive.c:106 -#: access/transam/xlogarchive.c:265 commands/copy.c:1778 commands/copy.c:2804 -#: commands/extension.c:3109 commands/tablespace.c:786 -#: commands/tablespace.c:877 replication/basebackup.c:407 -#: replication/basebackup.c:475 replication/logical/snapbuild.c:1493 +#: access/transam/xlog.c:10177 access/transam/xlog.c:10215 +#: access/transam/xlog.c:10411 access/transam/xlogarchive.c:106 +#: access/transam/xlogarchive.c:265 commands/copy.c:1815 commands/copy.c:2839 +#: commands/extension.c:3130 commands/tablespace.c:782 +#: commands/tablespace.c:873 replication/basebackup.c:409 +#: replication/basebackup.c:477 replication/logical/snapbuild.c:1491 #: storage/file/copydir.c:72 storage/file/copydir.c:115 storage/file/fd.c:2826 #: storage/file/fd.c:2918 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 #: utils/adt/dbsize.c:300 utils/adt/genfile.c:114 utils/adt/genfile.c:333 -#: guc-file.l:1003 +#: guc-file.l:1001 #, c-format msgid "could not stat file \"%s\": %m" msgstr "non è stato possibile ottenere informazioni sul file \"%s\": %m" -#: access/transam/xlog.c:10116 access/transam/xlog.c:10154 +#: access/transam/xlog.c:10184 access/transam/xlog.c:10222 #, c-format msgid "If you're sure there is no backup in progress, remove file \"%s\" and try again." msgstr "Se si è certi che non ci sono backup in corso, rimuovi il file \"%s\" e prova di nuovo." -#: access/transam/xlog.c:10133 access/transam/xlog.c:10171 -#: access/transam/xlog.c:10501 +#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 +#: access/transam/xlog.c:10615 #, c-format msgid "could not write file \"%s\": %m" msgstr "scrittura nel file \"%s\" fallita: %m" -#: access/transam/xlog.c:10290 +#: access/transam/xlog.c:10388 #, c-format msgid "exclusive backup not in progress" msgstr "non c'è un backup esclusivo in corso" -#: access/transam/xlog.c:10330 +#: access/transam/xlog.c:10415 #, c-format msgid "a backup is not in progress" msgstr "non c'è un backup in esecuzione" -#: access/transam/xlog.c:10375 access/transam/xlog.c:10388 -#: access/transam/xlog.c:10728 access/transam/xlog.c:10734 -#: access/transam/xlog.c:10818 access/transam/xlogfuncs.c:696 +#: access/transam/xlog.c:10489 access/transam/xlog.c:10502 +#: access/transam/xlog.c:10842 access/transam/xlog.c:10848 +#: access/transam/xlog.c:10932 access/transam/xlogfuncs.c:695 #, c-format msgid "invalid data in file \"%s\"" msgstr "i dati nel file \"%s\" non sono validi" -#: access/transam/xlog.c:10392 replication/basebackup.c:936 +#: access/transam/xlog.c:10506 replication/basebackup.c:938 #, c-format msgid "the standby was promoted during online backup" msgstr "lo standby è stato promosso durante il backup online" -#: access/transam/xlog.c:10393 replication/basebackup.c:937 +#: access/transam/xlog.c:10507 replication/basebackup.c:939 #, c-format msgid "This means that the backup being taken is corrupt and should not be used. Try taking another online backup." msgstr "Ciò vuol dire che il backup che stava venendo salvato è corrotto e non dovrebbe essere usato. Prova ad effettuare un altro backup online." -#: access/transam/xlog.c:10438 +#: access/transam/xlog.c:10552 #, c-format msgid "WAL generated with full_page_writes=off was replayed during online backup" msgstr "un WAL generato con full_page_writes=off è stato riprodotto durante il backup online" -#: access/transam/xlog.c:10550 +#: access/transam/xlog.c:10664 #, c-format msgid "pg_stop_backup cleanup done, waiting for required WAL segments to be archived" msgstr "pulizia di pg_stop_backup effettuata, in attesa che i segmenti WAL richiesti vengano archiviati" -#: access/transam/xlog.c:10560 +#: access/transam/xlog.c:10674 #, c-format msgid "pg_stop_backup still waiting for all required WAL segments to be archived (%d seconds elapsed)" msgstr "pg_stop_backup è ancora in attesa che tutti i segmenti WAL richiesti siano stati archiviati (sono passati %d secondi)" -#: access/transam/xlog.c:10562 +#: access/transam/xlog.c:10676 #, c-format msgid "Check that your archive_command is executing properly. pg_stop_backup can be canceled safely, but the database backup will not be usable without all the WAL segments." msgstr "Controlla che il tuo archive_command venga eseguito correttamente. pg_stop_backup può essere interrotto in sicurezza ma il backup del database non sarà utilizzabile senza tutti i segmenti WAL." -#: access/transam/xlog.c:10569 +#: access/transam/xlog.c:10683 #, c-format msgid "pg_stop_backup complete, all required WAL segments have been archived" msgstr "pg_stop_backup completo, tutti i segmenti WAL richiesti sono stati archiviati" -#: access/transam/xlog.c:10573 +#: access/transam/xlog.c:10687 #, c-format msgid "WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup" msgstr "l'archiviazione WAL non è abilitata; devi verificare che tutti i segmenti WAL richiesti vengano copiati in qualche altro modo per completare il backup" #. translator: %s is an XLog record description -#: access/transam/xlog.c:10858 +#: access/transam/xlog.c:10972 #, c-format msgid "xlog redo at %X/%X for %s" msgstr "ripristino xlog a %X/%X per %s" -#: access/transam/xlog.c:10907 +#: access/transam/xlog.c:11021 #, c-format msgid "online backup mode was not canceled" msgstr "la modalità di backup online non è stata annullata" -#: access/transam/xlog.c:10908 +#: access/transam/xlog.c:11022 #, c-format msgid "File \"%s\" could not be renamed to \"%s\": %m." msgstr "Non è stato possibile rinominare il file \"%s\" in \"%s\": %m." -#: access/transam/xlog.c:10917 access/transam/xlog.c:10929 -#: access/transam/xlog.c:10939 +#: access/transam/xlog.c:11031 access/transam/xlog.c:11043 +#: access/transam/xlog.c:11053 #, c-format msgid "online backup mode canceled" msgstr "modalità backup online annullata" -#: access/transam/xlog.c:10930 +#: access/transam/xlog.c:11044 #, c-format msgid "Files \"%s\" and \"%s\" were renamed to \"%s\" and \"%s\", respectively." msgstr "File \"%s\" e \"%s\" rinominati rispettivamente in \"%s\" e \"%s\"." -#: access/transam/xlog.c:10940 +#: access/transam/xlog.c:11054 #, c-format msgid "File \"%s\" was renamed to \"%s\", but file \"%s\" could not be renamed to \"%s\": %m." msgstr "File \"%s\" rinominato in \"%s\", ma non è stato possibile rinominare il file \"%s\" in \"%s\": %m." -#: access/transam/xlog.c:11062 access/transam/xlogutils.c:723 -#: replication/walreceiver.c:973 replication/walsender.c:2116 +#: access/transam/xlog.c:11176 access/transam/xlogutils.c:718 +#: replication/walreceiver.c:994 replication/walsender.c:2114 #, c-format msgid "could not seek in log segment %s to offset %u: %m" msgstr "spostamento nel segmento di log %s alla posizione %u fallito: %m" -#: access/transam/xlog.c:11074 +#: access/transam/xlog.c:11188 #, c-format msgid "could not read from log segment %s, offset %u: %m" msgstr "lettura del segmento di log %s, posizione %u fallita: %m" -#: access/transam/xlog.c:11548 +#: access/transam/xlog.c:11662 #, c-format msgid "received promote request" msgstr "richiesta di promozione ricevuta" -#: access/transam/xlog.c:11561 +#: access/transam/xlog.c:11675 #, c-format msgid "trigger file found: %s" msgstr "trovato il file trigger: %s" -#: access/transam/xlog.c:11570 +#: access/transam/xlog.c:11684 #, c-format msgid "could not stat trigger file \"%s\": %m" msgstr "non è stato possibile ottenere informazioni sul file trigger \"%s\": %m" @@ -2715,9 +2726,9 @@ msgstr "non è stato possibile ripristinare il file \"%s\" dall'archivio: %s" msgid "%s \"%s\": %s" msgstr "%s \"%s\": %s" -#: access/transam/xlogarchive.c:458 replication/logical/snapbuild.c:1621 -#: replication/slot.c:470 replication/slot.c:981 replication/slot.c:1089 -#: storage/file/fd.c:635 storage/file/fd.c:693 utils/time/snapmgr.c:1198 +#: access/transam/xlogarchive.c:458 replication/logical/snapbuild.c:1619 +#: replication/slot.c:480 replication/slot.c:992 replication/slot.c:1100 +#: storage/file/fd.c:635 storage/file/fd.c:693 utils/time/snapmgr.c:1298 #, c-format msgid "could not rename file \"%s\" to \"%s\": %m" msgstr "non è stato possibile rinominare il file \"%s\" in \"%s\": %m" @@ -2742,9 +2753,9 @@ msgstr "interruzione del backup perché il backend è terminato prima della chia msgid "a backup is already in progress in this session" msgstr "c'è già un backup in corso in questa sessione" -#: access/transam/xlogfuncs.c:94 commands/tablespace.c:709 -#: commands/tablespace.c:719 postmaster/postmaster.c:1395 -#: replication/basebackup.c:295 replication/basebackup.c:635 +#: access/transam/xlogfuncs.c:94 commands/tablespace.c:705 +#: commands/tablespace.c:715 postmaster/postmaster.c:1406 +#: replication/basebackup.c:297 replication/basebackup.c:637 #: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2292 #: storage/file/fd.c:2891 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 #: utils/adt/misc.c:411 utils/misc/tzparser.c:339 @@ -2759,33 +2770,33 @@ msgstr "il backup in corso non è esclusivo" #: access/transam/xlogfuncs.c:156 access/transam/xlogfuncs.c:230 #, c-format -msgid "did you mean to use pg_stop_backup('f')?" -msgstr "forse intendevi usare pg_stop_backup('f')?" +msgid "Did you mean to use pg_stop_backup('f')?" +msgstr "Forse intendevi usare pg_stop_backup('f')?" -#: access/transam/xlogfuncs.c:200 commands/event_trigger.c:1449 -#: commands/event_trigger.c:2000 commands/extension.c:1728 -#: commands/extension.c:1837 commands/extension.c:2030 commands/prepare.c:702 +#: access/transam/xlogfuncs.c:200 commands/event_trigger.c:1445 +#: commands/event_trigger.c:1996 commands/extension.c:1729 +#: commands/extension.c:1838 commands/extension.c:2031 commands/prepare.c:702 #: executor/execQual.c:1757 executor/execQual.c:1782 executor/execQual.c:2157 -#: executor/execQual.c:5386 executor/functions.c:1024 foreign/foreign.c:598 +#: executor/execQual.c:5438 executor/functions.c:1031 foreign/foreign.c:492 #: replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1391 -#: replication/slotfuncs.c:189 replication/walsender.c:2761 -#: utils/adt/jsonfuncs.c:1483 utils/adt/jsonfuncs.c:1615 -#: utils/adt/jsonfuncs.c:1805 utils/adt/jsonfuncs.c:1934 -#: utils/adt/jsonfuncs.c:2702 utils/adt/pgstatfuncs.c:552 -#: utils/adt/pgstatfuncs.c:653 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8424 -#: utils/mmgr/portalmem.c:1064 +#: replication/slotfuncs.c:189 replication/walsender.c:2763 +#: utils/adt/jsonfuncs.c:1483 utils/adt/jsonfuncs.c:1613 +#: utils/adt/jsonfuncs.c:1801 utils/adt/jsonfuncs.c:1928 +#: utils/adt/jsonfuncs.c:2694 utils/adt/pgstatfuncs.c:554 +#: utils/adt/pgstatfuncs.c:655 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8436 +#: utils/mmgr/portalmem.c:1074 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "la funzione che restituisce insiemi è chiamata in un contesto che non può accettare un insieme" -#: access/transam/xlogfuncs.c:204 commands/event_trigger.c:1453 -#: commands/event_trigger.c:2004 commands/extension.c:1732 -#: commands/extension.c:1841 commands/extension.c:2034 commands/prepare.c:706 -#: foreign/foreign.c:603 replication/logical/logicalfuncs.c:179 +#: access/transam/xlogfuncs.c:204 commands/event_trigger.c:1449 +#: commands/event_trigger.c:2000 commands/extension.c:1733 +#: commands/extension.c:1842 commands/extension.c:2035 commands/prepare.c:706 +#: foreign/foreign.c:497 replication/logical/logicalfuncs.c:179 #: replication/logical/origin.c:1395 replication/slotfuncs.c:193 -#: replication/walsender.c:2765 utils/adt/pgstatfuncs.c:556 -#: utils/adt/pgstatfuncs.c:657 utils/misc/guc.c:8428 utils/misc/pg_config.c:44 -#: utils/mmgr/portalmem.c:1068 +#: replication/walsender.c:2767 utils/adt/pgstatfuncs.c:558 +#: utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8440 utils/misc/pg_config.c:44 +#: utils/mmgr/portalmem.c:1078 #, c-format msgid "materialize mode required, but it is not allowed in this context" msgstr "necessaria modalità materializzata, ma non ammessa in questo contesto" @@ -2797,193 +2808,193 @@ msgstr "non c'è un backup non esclusivo in corso" #: access/transam/xlogfuncs.c:248 #, c-format -msgid "did you mean to use pg_stop_backup('t')?" -msgstr "forse intendevi usare pg_stop_backup('t')?" +msgid "Did you mean to use pg_stop_backup('t')?" +msgstr "Forse intendevi usare pg_stop_backup('t')?" -#: access/transam/xlogfuncs.c:327 +#: access/transam/xlogfuncs.c:326 #, c-format msgid "WAL level not sufficient for creating a restore point" msgstr "livello WAL non sufficiente per creare un punto di ripristino" -#: access/transam/xlogfuncs.c:335 +#: access/transam/xlogfuncs.c:334 #, c-format msgid "value too long for restore point (maximum %d characters)" msgstr "il valore è troppo lungo per un punto di ripristino (massimo %d caratteri)" -#: access/transam/xlogfuncs.c:473 +#: access/transam/xlogfuncs.c:472 #, c-format msgid "pg_xlogfile_name_offset() cannot be executed during recovery." msgstr "pg_xlogfile_name_offset() non può essere eseguito durante il recupero." -#: access/transam/xlogfuncs.c:529 +#: access/transam/xlogfuncs.c:528 #, c-format msgid "pg_xlogfile_name() cannot be executed during recovery." msgstr "pg_xlogfile_name() non può essere eseguito durante il recupero." -#: access/transam/xlogfuncs.c:549 access/transam/xlogfuncs.c:569 -#: access/transam/xlogfuncs.c:586 +#: access/transam/xlogfuncs.c:548 access/transam/xlogfuncs.c:568 +#: access/transam/xlogfuncs.c:585 #, c-format msgid "recovery is not in progress" msgstr "il recupero non è in corso" -#: access/transam/xlogfuncs.c:550 access/transam/xlogfuncs.c:570 -#: access/transam/xlogfuncs.c:587 +#: access/transam/xlogfuncs.c:549 access/transam/xlogfuncs.c:569 +#: access/transam/xlogfuncs.c:586 #, c-format msgid "Recovery control functions can only be executed during recovery." msgstr "Le funzioni di controllo del recupero possono essere eseguite solo durante un recupero." -#: access/transam/xlogreader.c:285 +#: access/transam/xlogreader.c:276 #, c-format msgid "invalid record offset at %X/%X" msgstr "offset del record non valido a %X/%X" -#: access/transam/xlogreader.c:293 +#: access/transam/xlogreader.c:284 #, c-format msgid "contrecord is requested by %X/%X" msgstr "contrecord richiesto da %X/%X" -#: access/transam/xlogreader.c:334 access/transam/xlogreader.c:633 +#: access/transam/xlogreader.c:325 access/transam/xlogreader.c:624 #, c-format msgid "invalid record length at %X/%X: wanted %u, got %u" msgstr "lunghezza del record a %X/%X non valida: atteso %u, ricevuto %u" -#: access/transam/xlogreader.c:349 +#: access/transam/xlogreader.c:340 #, c-format msgid "record length %u at %X/%X too long" msgstr "lunghezza del record %u a %X/%X eccessiva" -#: access/transam/xlogreader.c:390 +#: access/transam/xlogreader.c:381 #, c-format msgid "there is no contrecord flag at %X/%X" msgstr "non c'è un flag di contrecord a %X/%X" -#: access/transam/xlogreader.c:403 +#: access/transam/xlogreader.c:394 #, c-format msgid "invalid contrecord length %u at %X/%X" msgstr "lunghezza di contrecord %u non valida a %X/%X" -#: access/transam/xlogreader.c:641 +#: access/transam/xlogreader.c:632 #, c-format msgid "invalid resource manager ID %u at %X/%X" msgstr "ID di gestione risorse %u non valido a %X/%X" -#: access/transam/xlogreader.c:655 access/transam/xlogreader.c:672 +#: access/transam/xlogreader.c:646 access/transam/xlogreader.c:663 #, c-format msgid "record with incorrect prev-link %X/%X at %X/%X" msgstr "record con link-precedente %X/%X non corretto a %X/%X" -#: access/transam/xlogreader.c:709 +#: access/transam/xlogreader.c:700 #, c-format msgid "incorrect resource manager data checksum in record at %X/%X" msgstr "checksum dei dati del manager di risorse non corretto nel record a %X/%X" -#: access/transam/xlogreader.c:742 +#: access/transam/xlogreader.c:733 #, c-format msgid "invalid magic number %04X in log segment %s, offset %u" msgstr "numero magico %04X non valido nel segmento di log %s, offset %u" -#: access/transam/xlogreader.c:756 access/transam/xlogreader.c:807 +#: access/transam/xlogreader.c:747 access/transam/xlogreader.c:798 #, c-format msgid "invalid info bits %04X in log segment %s, offset %u" msgstr "bit di info %04X non validi nel segmento di log %s, offset %u" -#: access/transam/xlogreader.c:782 +#: access/transam/xlogreader.c:773 #, c-format msgid "WAL file is from different database system: WAL file database system identifier is %s, pg_control database system identifier is %s" msgstr "il file di WAL è di un database diverso: l'identificativo del file di WAL del database è %s, l'identificativo di pg_control del database è %s" -#: access/transam/xlogreader.c:789 +#: access/transam/xlogreader.c:780 #, c-format msgid "WAL file is from different database system: incorrect XLOG_SEG_SIZE in page header" msgstr "il file di WAL è di un database diverso: XLOG_SEG_SIZE non corretto nell'header di pagina" -#: access/transam/xlogreader.c:795 +#: access/transam/xlogreader.c:786 #, c-format msgid "WAL file is from different database system: incorrect XLOG_BLCKSZ in page header" msgstr "il file di WAL è di un database diverso: XLOG_BLCKSZ non corretto nell'header di pagina" -#: access/transam/xlogreader.c:821 +#: access/transam/xlogreader.c:812 #, c-format msgid "unexpected pageaddr %X/%X in log segment %s, offset %u" msgstr "pageaddr inaspettato %X/%X nel segmento di log %s, offset %u" -#: access/transam/xlogreader.c:846 +#: access/transam/xlogreader.c:837 #, c-format msgid "out-of-sequence timeline ID %u (after %u) in log segment %s, offset %u" msgstr "ID della timeline %u (dopo %u) fuori sequenza nel segmento di log %s, offset %u" -#: access/transam/xlogreader.c:1053 +#: access/transam/xlogreader.c:1081 #, c-format msgid "out-of-order block_id %u at %X/%X" msgstr "block_id fuori sequenza %u a %X/%X" -#: access/transam/xlogreader.c:1075 +#: access/transam/xlogreader.c:1103 #, c-format msgid "BKPBLOCK_HAS_DATA set, but no data included at %X/%X" msgstr "BKPBLOCK_HAS_DATA impostato, ma dati non inclusi a %X/%X" -#: access/transam/xlogreader.c:1082 +#: access/transam/xlogreader.c:1110 #, c-format msgid "BKPBLOCK_HAS_DATA not set, but data length is %u at %X/%X" msgstr "BKPBLOCK_HAS_DATA non impostato, ma la lunghezza dei dati è %u a %X/%X" -#: access/transam/xlogreader.c:1115 +#: access/transam/xlogreader.c:1143 #, c-format msgid "BKPIMAGE_HAS_HOLE set, but hole offset %u length %u block image length %u at %X/%X" msgstr "BKPIMAGE_HAS_HOLE impostato, ma offset buco %u lunghezza %u lunghezza dell'immagine del blocco %u a %X/%X" -#: access/transam/xlogreader.c:1131 +#: access/transam/xlogreader.c:1159 #, c-format msgid "BKPIMAGE_HAS_HOLE not set, but hole offset %u length %u at %X/%X" msgstr "BKPIMAGE_HAS_HOLE non impostato, ma offset buco %u lunghezza %u a %X/%X" -#: access/transam/xlogreader.c:1146 +#: access/transam/xlogreader.c:1174 #, c-format msgid "BKPIMAGE_IS_COMPRESSED set, but block image length %u at %X/%X" msgstr "BKPIMAGE_IS_COMPRESSED impostato, ma la lunghezza dell'immagine del blocco è %u a %X/%X" -#: access/transam/xlogreader.c:1161 +#: access/transam/xlogreader.c:1189 #, c-format msgid "neither BKPIMAGE_HAS_HOLE nor BKPIMAGE_IS_COMPRESSED set, but block image length is %u at %X/%X" msgstr "né BKPIMAGE_HAS_HOLE né BKPIMAGE_IS_COMPRESSED impostati, ma la lunghezza dell'immagine del blocco è %u a %X/%X" -#: access/transam/xlogreader.c:1177 +#: access/transam/xlogreader.c:1205 #, c-format msgid "BKPBLOCK_SAME_REL set but no previous rel at %X/%X" msgstr "BKPBLOCK_SAME_REL impostato ma non c'è un rel precedente a %X/%X" -#: access/transam/xlogreader.c:1189 +#: access/transam/xlogreader.c:1217 #, c-format msgid "invalid block_id %u at %X/%X" msgstr "block_id %u non valido a %X/%X" -#: access/transam/xlogreader.c:1254 +#: access/transam/xlogreader.c:1282 #, c-format msgid "record with invalid length at %X/%X" msgstr "record con lunghezza non valida a %X/%X" -#: access/transam/xlogreader.c:1343 +#: access/transam/xlogreader.c:1371 #, c-format msgid "invalid compressed image at %X/%X, block %d" msgstr "immagine compressa non valida a %X/%X, blocco %d" -#: access/transam/xlogutils.c:744 replication/walsender.c:2133 +#: access/transam/xlogutils.c:739 replication/walsender.c:2131 #, c-format msgid "could not read from log segment %s, offset %u, length %lu: %m" msgstr "lettura del segmento di log %s, posizione %u, lunghezza %lu fallita: %m" -#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:785 tcop/postgres.c:3488 +#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:793 tcop/postgres.c:3501 #, c-format msgid "--%s requires a value" msgstr "--%s richiede un valore" -#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:790 tcop/postgres.c:3493 +#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:798 tcop/postgres.c:3506 #, c-format msgid "-c %s requires a value" msgstr "-c %s richiede un valore" -#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:802 -#: postmaster/postmaster.c:815 +#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:810 +#: postmaster/postmaster.c:823 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Prova \"%s --help\" per maggiori informazioni.\n" @@ -2993,137 +3004,137 @@ msgstr "Prova \"%s --help\" per maggiori informazioni.\n" msgid "%s: invalid command-line arguments\n" msgstr "%s: parametri della riga di comando non validi\n" -#: catalog/aclchk.c:193 +#: catalog/aclchk.c:201 #, c-format msgid "grant options can only be granted to roles" msgstr "le opzioni di concessione possono essere concesse solo ai ruoli" -#: catalog/aclchk.c:316 +#: catalog/aclchk.c:324 #, c-format msgid "no privileges were granted for column \"%s\" of relation \"%s\"" msgstr "nessun privilegio è stato concesso per la colonna \"%s\" della relazione \"%s\"" -#: catalog/aclchk.c:321 +#: catalog/aclchk.c:329 #, c-format msgid "no privileges were granted for \"%s\"" msgstr "nessun privilegio è stato concesso per \"%s\"" -#: catalog/aclchk.c:329 +#: catalog/aclchk.c:337 #, c-format msgid "not all privileges were granted for column \"%s\" of relation \"%s\"" msgstr "non tutti i privilegi sono stati concessi per la colonna \"%s\" della relazione \"%s\"" -#: catalog/aclchk.c:334 +#: catalog/aclchk.c:342 #, c-format msgid "not all privileges were granted for \"%s\"" msgstr "non tutti i privilegi sono stati concessi per \"%s\"" -#: catalog/aclchk.c:345 +#: catalog/aclchk.c:353 #, c-format msgid "no privileges could be revoked for column \"%s\" of relation \"%s\"" msgstr "non è stato possibile revocare alcun privilegio per la colonna \"%s\" della relazione \"%s\"" -#: catalog/aclchk.c:350 +#: catalog/aclchk.c:358 #, c-format msgid "no privileges could be revoked for \"%s\"" msgstr "non è stato possibile revocare alcun privilegio per \"%s\"" -#: catalog/aclchk.c:358 +#: catalog/aclchk.c:366 #, c-format msgid "not all privileges could be revoked for column \"%s\" of relation \"%s\"" msgstr "non è stato possibile revocare tutti i privilegi per la colonna \"%s\" della relazione \"%s\"" -#: catalog/aclchk.c:363 +#: catalog/aclchk.c:371 #, c-format msgid "not all privileges could be revoked for \"%s\"" msgstr "non è stato possibile revocare tutti i privilegi per \"%s\"" -#: catalog/aclchk.c:448 catalog/aclchk.c:940 +#: catalog/aclchk.c:453 catalog/aclchk.c:943 #, c-format msgid "invalid privilege type %s for relation" msgstr "tipo di privilegio %s non valido per la relazione" -#: catalog/aclchk.c:452 catalog/aclchk.c:944 +#: catalog/aclchk.c:457 catalog/aclchk.c:947 #, c-format msgid "invalid privilege type %s for sequence" msgstr "tipo di privilegio %s non valido per la sequenza" -#: catalog/aclchk.c:456 +#: catalog/aclchk.c:461 #, c-format msgid "invalid privilege type %s for database" msgstr "tipo di privilegio %s non valido per il database" -#: catalog/aclchk.c:460 +#: catalog/aclchk.c:465 #, c-format msgid "invalid privilege type %s for domain" msgstr "tipo di privilegio %s non valido per il dominio" -#: catalog/aclchk.c:464 catalog/aclchk.c:948 +#: catalog/aclchk.c:469 catalog/aclchk.c:951 #, c-format msgid "invalid privilege type %s for function" msgstr "tipo di privilegio %s non valido per la funzione" -#: catalog/aclchk.c:468 +#: catalog/aclchk.c:473 #, c-format msgid "invalid privilege type %s for language" msgstr "tipo di privilegio %s non valido per il linguaggio" -#: catalog/aclchk.c:472 +#: catalog/aclchk.c:477 #, c-format msgid "invalid privilege type %s for large object" msgstr "tipo di privilegio %s non valido per il large object" -#: catalog/aclchk.c:476 +#: catalog/aclchk.c:481 #, c-format msgid "invalid privilege type %s for schema" msgstr "tipo di privilegio %s non valido per lo schema" -#: catalog/aclchk.c:480 +#: catalog/aclchk.c:485 #, c-format msgid "invalid privilege type %s for tablespace" msgstr "tipo di privilegio %s non valido per il tablespace" -#: catalog/aclchk.c:484 catalog/aclchk.c:952 +#: catalog/aclchk.c:489 catalog/aclchk.c:955 #, c-format msgid "invalid privilege type %s for type" msgstr "tipo di privilegio %s non valido per il tipo" -#: catalog/aclchk.c:488 +#: catalog/aclchk.c:493 #, c-format msgid "invalid privilege type %s for foreign-data wrapper" msgstr "tipo di privilegio %s non valido per il wrapper di dati esterni" -#: catalog/aclchk.c:492 +#: catalog/aclchk.c:497 #, c-format msgid "invalid privilege type %s for foreign server" msgstr "tipo di privilegio %s non valido per il server esterno" -#: catalog/aclchk.c:531 +#: catalog/aclchk.c:536 #, c-format msgid "column privileges are only valid for relations" msgstr "i privilegi della colonna sono validi solo per le relazioni" -#: catalog/aclchk.c:690 catalog/aclchk.c:3921 catalog/aclchk.c:4698 +#: catalog/aclchk.c:695 catalog/aclchk.c:3923 catalog/aclchk.c:4705 #: catalog/objectaddress.c:873 catalog/pg_largeobject.c:113 #: storage/large_object/inv_api.c:291 #, c-format msgid "large object %u does not exist" msgstr "il large object %u non esiste" -#: catalog/aclchk.c:877 catalog/aclchk.c:885 commands/collationcmds.c:92 -#: commands/copy.c:1008 commands/copy.c:1026 commands/copy.c:1034 -#: commands/copy.c:1042 commands/copy.c:1050 commands/copy.c:1058 -#: commands/copy.c:1066 commands/copy.c:1074 commands/copy.c:1082 -#: commands/copy.c:1098 commands/copy.c:1112 commands/copy.c:1131 -#: commands/copy.c:1146 commands/dbcommands.c:155 commands/dbcommands.c:163 +#: catalog/aclchk.c:882 catalog/aclchk.c:890 commands/collationcmds.c:92 +#: commands/copy.c:1047 commands/copy.c:1065 commands/copy.c:1073 +#: commands/copy.c:1081 commands/copy.c:1089 commands/copy.c:1097 +#: commands/copy.c:1105 commands/copy.c:1113 commands/copy.c:1121 +#: commands/copy.c:1137 commands/copy.c:1151 commands/copy.c:1170 +#: commands/copy.c:1185 commands/dbcommands.c:155 commands/dbcommands.c:163 #: commands/dbcommands.c:171 commands/dbcommands.c:179 #: commands/dbcommands.c:187 commands/dbcommands.c:195 #: commands/dbcommands.c:203 commands/dbcommands.c:211 #: commands/dbcommands.c:219 commands/dbcommands.c:1397 #: commands/dbcommands.c:1405 commands/dbcommands.c:1413 -#: commands/dbcommands.c:1421 commands/extension.c:1218 -#: commands/extension.c:1226 commands/extension.c:1234 -#: commands/extension.c:1242 commands/extension.c:2760 +#: commands/dbcommands.c:1421 commands/extension.c:1219 +#: commands/extension.c:1227 commands/extension.c:1235 +#: commands/extension.c:1243 commands/extension.c:2761 #: commands/foreigncmds.c:539 commands/foreigncmds.c:548 #: commands/functioncmds.c:533 commands/functioncmds.c:649 #: commands/functioncmds.c:657 commands/functioncmds.c:665 @@ -3146,420 +3157,420 @@ msgstr "il large object %u non esiste" msgid "conflicting or redundant options" msgstr "opzioni contraddittorie o ridondanti" -#: catalog/aclchk.c:985 +#: catalog/aclchk.c:988 #, c-format msgid "default privileges cannot be set for columns" msgstr "i privilegi predefiniti non possono essere impostati sulle colonne" -#: catalog/aclchk.c:1501 catalog/objectaddress.c:1390 commands/analyze.c:378 -#: commands/copy.c:4423 commands/sequence.c:1491 commands/tablecmds.c:5199 -#: commands/tablecmds.c:5305 commands/tablecmds.c:5365 -#: commands/tablecmds.c:5478 commands/tablecmds.c:5535 -#: commands/tablecmds.c:5629 commands/tablecmds.c:5725 -#: commands/tablecmds.c:7877 commands/tablecmds.c:8082 -#: commands/tablecmds.c:8502 commands/trigger.c:642 parser/analyze.c:2160 -#: parser/parse_relation.c:2542 parser/parse_relation.c:2604 -#: parser/parse_target.c:940 parser/parse_type.c:127 utils/adt/acl.c:2840 -#: utils/adt/ruleutils.c:1862 +#: catalog/aclchk.c:1502 catalog/objectaddress.c:1390 commands/analyze.c:376 +#: commands/copy.c:4458 commands/sequence.c:1491 commands/tablecmds.c:5198 +#: commands/tablecmds.c:5304 commands/tablecmds.c:5364 +#: commands/tablecmds.c:5477 commands/tablecmds.c:5534 +#: commands/tablecmds.c:5628 commands/tablecmds.c:5724 +#: commands/tablecmds.c:7915 commands/tablecmds.c:8177 +#: commands/tablecmds.c:8597 commands/trigger.c:642 parser/analyze.c:2228 +#: parser/parse_relation.c:2628 parser/parse_relation.c:2690 +#: parser/parse_target.c:951 parser/parse_type.c:127 utils/adt/acl.c:2840 +#: utils/adt/ruleutils.c:1984 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist" msgstr "la colonna \"%s\" della relazione \"%s\" non esiste" -#: catalog/aclchk.c:1770 catalog/objectaddress.c:1203 commands/sequence.c:1078 -#: commands/tablecmds.c:223 commands/tablecmds.c:12009 utils/adt/acl.c:2076 +#: catalog/aclchk.c:1771 catalog/objectaddress.c:1203 commands/sequence.c:1078 +#: commands/tablecmds.c:224 commands/tablecmds.c:12154 utils/adt/acl.c:2076 #: utils/adt/acl.c:2106 utils/adt/acl.c:2138 utils/adt/acl.c:2170 #: utils/adt/acl.c:2198 utils/adt/acl.c:2228 #, c-format msgid "\"%s\" is not a sequence" msgstr "\"%s\" non è una sequenza" -#: catalog/aclchk.c:1808 +#: catalog/aclchk.c:1809 #, c-format msgid "sequence \"%s\" only supports USAGE, SELECT, and UPDATE privileges" msgstr "la sequenza \"%s\" supporta solo i privilegi USAGE, SELECT e UPDATE" -#: catalog/aclchk.c:1825 +#: catalog/aclchk.c:1826 #, c-format msgid "invalid privilege type USAGE for table" msgstr "tipo di privilegio USAGE non valido per la tabella" -#: catalog/aclchk.c:1993 +#: catalog/aclchk.c:1994 #, c-format msgid "invalid privilege type %s for column" msgstr "tipo di privilegio %s non valido per la colonna" -#: catalog/aclchk.c:2006 +#: catalog/aclchk.c:2007 #, c-format msgid "sequence \"%s\" only supports SELECT column privileges" msgstr "la sequenza \"%s\" supporta solo i privilegi di SELECT sulla colonna" -#: catalog/aclchk.c:2600 +#: catalog/aclchk.c:2601 #, c-format msgid "language \"%s\" is not trusted" msgstr "il linguaggio \"%s\" non è fidato" -#: catalog/aclchk.c:2602 +#: catalog/aclchk.c:2603 #, c-format -msgid "Only superusers can use untrusted languages." -msgstr "Solo un superutente può usare linguaggi non fidati." +msgid "GRANT and REVOKE are not allowed on untrusted languages, because only superusers can use untrusted languages." +msgstr "GRANT e REVOKE non sono ammessi sui linguaggi non fidati, perché i linguaggi non fidati possono essere usati solo da superutenti." -#: catalog/aclchk.c:3127 +#: catalog/aclchk.c:3129 #, c-format msgid "cannot set privileges of array types" msgstr "non è possibile impostare privilegi su tipi array" -#: catalog/aclchk.c:3128 +#: catalog/aclchk.c:3130 #, c-format msgid "Set the privileges of the element type instead." msgstr "Puoi impostare i privilegi del tipo dell'elemento." -#: catalog/aclchk.c:3135 catalog/objectaddress.c:1523 commands/typecmds.c:3146 +#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3146 #, c-format msgid "\"%s\" is not a domain" msgstr "\"%s\" non è un dominio" -#: catalog/aclchk.c:3258 +#: catalog/aclchk.c:3260 #, c-format msgid "unrecognized privilege type \"%s\"" msgstr "tipo di privilegio \"%s\" sconosciuto" -#: catalog/aclchk.c:3307 +#: catalog/aclchk.c:3309 #, c-format msgid "permission denied for column %s" msgstr "permesso negato per la colonna %s" -#: catalog/aclchk.c:3309 +#: catalog/aclchk.c:3311 #, c-format msgid "permission denied for relation %s" msgstr "permesso negato per la relazione %s" -#: catalog/aclchk.c:3311 commands/sequence.c:561 commands/sequence.c:786 +#: catalog/aclchk.c:3313 commands/sequence.c:561 commands/sequence.c:786 #: commands/sequence.c:828 commands/sequence.c:865 commands/sequence.c:1543 #, c-format msgid "permission denied for sequence %s" msgstr "permesso negato per la sequenza %s" -#: catalog/aclchk.c:3313 +#: catalog/aclchk.c:3315 #, c-format msgid "permission denied for database %s" msgstr "permesso negato per il database %s" -#: catalog/aclchk.c:3315 +#: catalog/aclchk.c:3317 #, c-format msgid "permission denied for function %s" msgstr "permesso negato per la funzione %s" -#: catalog/aclchk.c:3317 +#: catalog/aclchk.c:3319 #, c-format msgid "permission denied for operator %s" msgstr "permesso negato per l'operatore %s" -#: catalog/aclchk.c:3319 +#: catalog/aclchk.c:3321 #, c-format msgid "permission denied for type %s" msgstr "permesso negato per il tipo %s" -#: catalog/aclchk.c:3321 +#: catalog/aclchk.c:3323 #, c-format msgid "permission denied for language %s" msgstr "permesso negato per il linguaggio %s" -#: catalog/aclchk.c:3323 +#: catalog/aclchk.c:3325 #, c-format msgid "permission denied for large object %s" msgstr "permesso negato per large object %s" -#: catalog/aclchk.c:3325 +#: catalog/aclchk.c:3327 #, c-format msgid "permission denied for schema %s" msgstr "permesso negato per lo schema %s" -#: catalog/aclchk.c:3327 +#: catalog/aclchk.c:3329 #, c-format msgid "permission denied for operator class %s" msgstr "permesso negato per la classe di operatori %s" -#: catalog/aclchk.c:3329 +#: catalog/aclchk.c:3331 #, c-format msgid "permission denied for operator family %s" msgstr "permesso negato per la famiglia di operatori %s" -#: catalog/aclchk.c:3331 +#: catalog/aclchk.c:3333 #, c-format msgid "permission denied for collation %s" msgstr "permesso negato per l'ordinamento %s" -#: catalog/aclchk.c:3333 +#: catalog/aclchk.c:3335 #, c-format msgid "permission denied for conversion %s" msgstr "permesso negato per la conversione %s" -#: catalog/aclchk.c:3335 +#: catalog/aclchk.c:3337 #, c-format msgid "permission denied for tablespace %s" msgstr "permesso negato per il tablespace %s" -#: catalog/aclchk.c:3337 +#: catalog/aclchk.c:3339 #, c-format msgid "permission denied for text search dictionary %s" msgstr "permesso negato per il dizionario di ricerca di testo %s" -#: catalog/aclchk.c:3339 +#: catalog/aclchk.c:3341 #, c-format msgid "permission denied for text search configuration %s" msgstr "permesso negato per la configurazione di ricerca di testo %s" -#: catalog/aclchk.c:3341 +#: catalog/aclchk.c:3343 #, c-format msgid "permission denied for foreign-data wrapper %s" msgstr "permesso negato per il wrapper di dati esterni %s" -#: catalog/aclchk.c:3343 +#: catalog/aclchk.c:3345 #, c-format msgid "permission denied for foreign server %s" msgstr "permesso negato per il server esterno %s" -#: catalog/aclchk.c:3345 +#: catalog/aclchk.c:3347 #, c-format msgid "permission denied for event trigger %s" msgstr "permesso negato per il trigger di evento %s" -#: catalog/aclchk.c:3347 +#: catalog/aclchk.c:3349 #, c-format msgid "permission denied for extension %s" msgstr "permesso negato per l'estensione %s" -#: catalog/aclchk.c:3353 catalog/aclchk.c:3355 +#: catalog/aclchk.c:3355 catalog/aclchk.c:3357 #, c-format msgid "must be owner of relation %s" msgstr "bisogna essere proprietari della relazione %s" -#: catalog/aclchk.c:3357 +#: catalog/aclchk.c:3359 #, c-format msgid "must be owner of sequence %s" msgstr "bisogna essere proprietari della sequenza %s" -#: catalog/aclchk.c:3359 +#: catalog/aclchk.c:3361 #, c-format msgid "must be owner of database %s" msgstr "bisogna essere proprietari del database %s" -#: catalog/aclchk.c:3361 +#: catalog/aclchk.c:3363 #, c-format msgid "must be owner of function %s" msgstr "bisogna essere proprietari della funzione %s" -#: catalog/aclchk.c:3363 +#: catalog/aclchk.c:3365 #, c-format msgid "must be owner of operator %s" msgstr "bisogna essere proprietari dell'operatore %s" -#: catalog/aclchk.c:3365 +#: catalog/aclchk.c:3367 #, c-format msgid "must be owner of type %s" msgstr "bisogna essere proprietari del tipo %s" -#: catalog/aclchk.c:3367 +#: catalog/aclchk.c:3369 #, c-format msgid "must be owner of language %s" msgstr "bisogna essere proprietari del linguaggio %s" -#: catalog/aclchk.c:3369 +#: catalog/aclchk.c:3371 #, c-format msgid "must be owner of large object %s" msgstr "bisogna essere proprietari del large object %s" -#: catalog/aclchk.c:3371 +#: catalog/aclchk.c:3373 #, c-format msgid "must be owner of schema %s" msgstr "bisogna essere proprietari dello schema %s" -#: catalog/aclchk.c:3373 +#: catalog/aclchk.c:3375 #, c-format msgid "must be owner of operator class %s" msgstr "bisogna essere proprietari della classe di operatore %s" -#: catalog/aclchk.c:3375 +#: catalog/aclchk.c:3377 #, c-format msgid "must be owner of operator family %s" msgstr "bisogna essere proprietari della famiglia di operatori %s" -#: catalog/aclchk.c:3377 +#: catalog/aclchk.c:3379 #, c-format msgid "must be owner of collation %s" msgstr "bisogna essere proprietari dell'ordinamento %s" -#: catalog/aclchk.c:3379 +#: catalog/aclchk.c:3381 #, c-format msgid "must be owner of conversion %s" msgstr "bisogna essere proprietari della conversione %s" -#: catalog/aclchk.c:3381 +#: catalog/aclchk.c:3383 #, c-format msgid "must be owner of tablespace %s" msgstr "bisogna essere proprietari del tablespace %s" -#: catalog/aclchk.c:3383 +#: catalog/aclchk.c:3385 #, c-format msgid "must be owner of text search dictionary %s" msgstr "bisogna essere proprietari del dizionario di ricerca di testo %s" -#: catalog/aclchk.c:3385 +#: catalog/aclchk.c:3387 #, c-format msgid "must be owner of text search configuration %s" msgstr "bisogna essere proprietari della configurazione di ricerca di testo %s" -#: catalog/aclchk.c:3387 +#: catalog/aclchk.c:3389 #, c-format msgid "must be owner of foreign-data wrapper %s" msgstr "bisogna essere proprietari del wrapper di dati esterni %s" -#: catalog/aclchk.c:3389 +#: catalog/aclchk.c:3391 #, c-format msgid "must be owner of foreign server %s" msgstr "bisogna essere proprietari del server esterno %s" -#: catalog/aclchk.c:3391 +#: catalog/aclchk.c:3393 #, c-format msgid "must be owner of event trigger %s" msgstr "bisogna essere proprietari del trigger di evento %s" -#: catalog/aclchk.c:3393 +#: catalog/aclchk.c:3395 #, c-format msgid "must be owner of extension %s" msgstr "bisogna essere proprietari dell'estensione %s" -#: catalog/aclchk.c:3435 +#: catalog/aclchk.c:3437 #, c-format msgid "permission denied for column \"%s\" of relation \"%s\"" msgstr "permesso negato per la colonna \"%s\" della relazione \"%s\"" -#: catalog/aclchk.c:3554 catalog/aclchk.c:3562 +#: catalog/aclchk.c:3556 catalog/aclchk.c:3564 #, c-format msgid "attribute %d of relation with OID %u does not exist" msgstr "l'attributo %d della relazione con OID %u non esiste" -#: catalog/aclchk.c:3635 catalog/aclchk.c:4549 +#: catalog/aclchk.c:3637 catalog/aclchk.c:4556 #, c-format msgid "relation with OID %u does not exist" msgstr "la relazione con OID %u non esiste" -#: catalog/aclchk.c:3734 catalog/aclchk.c:4967 +#: catalog/aclchk.c:3736 catalog/aclchk.c:4974 #, c-format msgid "database with OID %u does not exist" msgstr "il database con OID %u non esiste" -#: catalog/aclchk.c:3788 catalog/aclchk.c:4627 tcop/fastpath.c:223 +#: catalog/aclchk.c:3790 catalog/aclchk.c:4634 tcop/fastpath.c:223 #, c-format msgid "function with OID %u does not exist" msgstr "la funzione con OID %u non esiste" -#: catalog/aclchk.c:3842 catalog/aclchk.c:4653 +#: catalog/aclchk.c:3844 catalog/aclchk.c:4660 #, c-format msgid "language with OID %u does not exist" msgstr "il linguaggio con OID %u non esiste" -#: catalog/aclchk.c:4006 catalog/aclchk.c:4725 +#: catalog/aclchk.c:4008 catalog/aclchk.c:4732 #, c-format msgid "schema with OID %u does not exist" msgstr "lo schema con OID %u non esiste" -#: catalog/aclchk.c:4060 catalog/aclchk.c:4752 +#: catalog/aclchk.c:4062 catalog/aclchk.c:4759 #, c-format msgid "tablespace with OID %u does not exist" msgstr "il tablespace con l'OID %u non esiste" -#: catalog/aclchk.c:4118 catalog/aclchk.c:4886 commands/foreigncmds.c:325 +#: catalog/aclchk.c:4121 catalog/aclchk.c:4893 commands/foreigncmds.c:325 #, c-format msgid "foreign-data wrapper with OID %u does not exist" msgstr "il wrapper di dati esterni con OID %u non esiste" -#: catalog/aclchk.c:4179 catalog/aclchk.c:4913 commands/foreigncmds.c:461 +#: catalog/aclchk.c:4183 catalog/aclchk.c:4920 commands/foreigncmds.c:461 #, c-format msgid "foreign server with OID %u does not exist" msgstr "il server esterno con OID %u non esiste" -#: catalog/aclchk.c:4238 catalog/aclchk.c:4252 catalog/aclchk.c:4575 +#: catalog/aclchk.c:4243 catalog/aclchk.c:4582 #, c-format msgid "type with OID %u does not exist" msgstr "il tipo con OID %u non esiste" -#: catalog/aclchk.c:4601 +#: catalog/aclchk.c:4608 #, c-format msgid "operator with OID %u does not exist" msgstr "l'operatore con OID %u non esiste" -#: catalog/aclchk.c:4778 +#: catalog/aclchk.c:4785 #, c-format msgid "operator class with OID %u does not exist" msgstr "la classe di operatori con OID %u non esiste" -#: catalog/aclchk.c:4805 +#: catalog/aclchk.c:4812 #, c-format msgid "operator family with OID %u does not exist" msgstr "la famiglia di operatori con OID %u non esiste" -#: catalog/aclchk.c:4832 +#: catalog/aclchk.c:4839 #, c-format msgid "text search dictionary with OID %u does not exist" msgstr "il dizionario di ricerca di testo con OID %u non esiste" -#: catalog/aclchk.c:4859 +#: catalog/aclchk.c:4866 #, c-format msgid "text search configuration with OID %u does not exist" msgstr "la configurazione di ricerca di testo con OID %u non esiste" -#: catalog/aclchk.c:4940 commands/event_trigger.c:587 +#: catalog/aclchk.c:4947 commands/event_trigger.c:587 #, c-format msgid "event trigger with OID %u does not exist" msgstr "il trigger di evento con OID %u non esiste" -#: catalog/aclchk.c:4993 +#: catalog/aclchk.c:5000 #, c-format msgid "collation with OID %u does not exist" msgstr "l'ordinamento con OID %u non esiste" -#: catalog/aclchk.c:5019 +#: catalog/aclchk.c:5026 #, c-format msgid "conversion with OID %u does not exist" msgstr "la conversione con OID %u non esiste" -#: catalog/aclchk.c:5060 +#: catalog/aclchk.c:5067 #, c-format msgid "extension with OID %u does not exist" msgstr "l'estensione con OID %u non esiste" -#: catalog/dependency.c:646 +#: catalog/dependency.c:645 #, c-format msgid "cannot drop %s because %s requires it" msgstr "non è possibile eliminare %s perché %s lo richiede" -#: catalog/dependency.c:649 +#: catalog/dependency.c:648 #, c-format msgid "You can drop %s instead." msgstr "È invece possibile eliminare %s." -#: catalog/dependency.c:811 catalog/pg_shdepend.c:576 +#: catalog/dependency.c:810 catalog/pg_shdepend.c:576 #, c-format msgid "cannot drop %s because it is required by the database system" msgstr "non è possibile eliminare %s perché richiesto dal sistema database" -#: catalog/dependency.c:927 +#: catalog/dependency.c:926 #, c-format msgid "drop auto-cascades to %s" msgstr "l'eliminazione elimina anche %s in cascata automatica" -#: catalog/dependency.c:939 catalog/dependency.c:948 +#: catalog/dependency.c:938 catalog/dependency.c:947 #, c-format msgid "%s depends on %s" msgstr "%s dipende da %s" -#: catalog/dependency.c:960 catalog/dependency.c:969 +#: catalog/dependency.c:959 catalog/dependency.c:968 #, c-format msgid "drop cascades to %s" msgstr "l'eliminazione elimina anche %s in cascata" -#: catalog/dependency.c:977 catalog/pg_shdepend.c:687 +#: catalog/dependency.c:976 catalog/pg_shdepend.c:687 #, c-format msgid "" "\n" @@ -3574,190 +3585,200 @@ msgstr[1] "" "\n" "e %d altri oggetti (vedere il log del server per la lista)" -#: catalog/dependency.c:989 +#: catalog/dependency.c:988 #, c-format msgid "cannot drop %s because other objects depend on it" msgstr "non è possibile eliminare %s perché altri oggetti dipendono da esso" -#: catalog/dependency.c:993 catalog/dependency.c:1000 +#: catalog/dependency.c:992 catalog/dependency.c:999 #, c-format msgid "Use DROP ... CASCADE to drop the dependent objects too." msgstr "Usa DROP ... CASCADE per eliminare anche gli oggetti dipendenti." -#: catalog/dependency.c:997 +#: catalog/dependency.c:996 #, c-format msgid "cannot drop desired object(s) because other objects depend on them" msgstr "non è possibile eliminare gli oggetti desiderati perché altri oggetti dipendono da essi" #. translator: %d always has a value larger than 1 -#: catalog/dependency.c:1006 +#: catalog/dependency.c:1005 #, c-format msgid "drop cascades to %d other object" msgid_plural "drop cascades to %d other objects" msgstr[0] "l'eliminazione elimina in cascata %d altro oggetto" msgstr[1] "l'eliminazione elimina in cascata %d altri oggetti" -#: catalog/dependency.c:1634 +#: catalog/dependency.c:1633 #, c-format msgid "constant of the type \"regrole\" cannot be used here" msgstr "le costanti di tipo \"regrole\" non possono essere usate qui" -#: catalog/heap.c:277 +#: catalog/heap.c:278 #, c-format msgid "permission denied to create \"%s.%s\"" msgstr "permesso di creare \"%s.%s\" negato" -#: catalog/heap.c:279 +#: catalog/heap.c:280 #, c-format msgid "System catalog modifications are currently disallowed." msgstr "Le modifiche al catalogo di sistema non sono attualmente consentite." -#: catalog/heap.c:414 commands/tablecmds.c:1438 commands/tablecmds.c:1895 -#: commands/tablecmds.c:4821 +#: catalog/heap.c:415 commands/tablecmds.c:1439 commands/tablecmds.c:1896 +#: commands/tablecmds.c:4820 #, c-format msgid "tables can have at most %d columns" msgstr "le tabelle possono avere al massimo %d colonne" -#: catalog/heap.c:431 commands/tablecmds.c:5082 +#: catalog/heap.c:432 commands/tablecmds.c:5081 #, c-format msgid "column name \"%s\" conflicts with a system column name" msgstr "il nome della colonna \"%s\" è in conflitto con il nome di una colonna di sistema" -#: catalog/heap.c:447 +#: catalog/heap.c:448 #, c-format msgid "column name \"%s\" specified more than once" msgstr "nome di colonna \"%s\" specificato più di una volta" -#: catalog/heap.c:497 +#: catalog/heap.c:498 #, c-format msgid "column \"%s\" has type \"unknown\"" msgstr "la colonna \"%s\" è di tipo \"unknown\"" -#: catalog/heap.c:498 +#: catalog/heap.c:499 #, c-format msgid "Proceeding with relation creation anyway." msgstr "Si procede comunque alla creazione della relazione." -#: catalog/heap.c:511 +#: catalog/heap.c:512 #, c-format msgid "column \"%s\" has pseudo-type %s" msgstr "la colonna \"%s\" ha pseudo-tipo %s" -#: catalog/heap.c:541 +#: catalog/heap.c:542 #, c-format msgid "composite type %s cannot be made a member of itself" msgstr "il tipo composito %s non può essere fatto membro di sé stesso" -#: catalog/heap.c:583 commands/createas.c:373 +#: catalog/heap.c:584 commands/createas.c:201 commands/createas.c:498 #, c-format msgid "no collation was derived for column \"%s\" with collatable type %s" msgstr "nessun ordinamento è stato derivato per la colonna \"%s\" con tipo ordinabile %s" -#: catalog/heap.c:585 commands/createas.c:375 commands/indexcmds.c:1132 -#: commands/view.c:116 regex/regc_pg_locale.c:262 utils/adt/formatting.c:1514 -#: utils/adt/formatting.c:1566 utils/adt/formatting.c:1634 -#: utils/adt/formatting.c:1686 utils/adt/formatting.c:1755 -#: utils/adt/formatting.c:1819 utils/adt/like.c:213 utils/adt/selfuncs.c:5330 -#: utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 +#: catalog/heap.c:586 commands/createas.c:204 commands/createas.c:501 +#: commands/indexcmds.c:1132 commands/view.c:103 regex/regc_pg_locale.c:262 +#: utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 +#: utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 +#: utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 utils/adt/like.c:213 +#: utils/adt/selfuncs.c:5334 utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 #, c-format msgid "Use the COLLATE clause to set the collation explicitly." msgstr "Usa la clausola COLLATE per impostare esplicitamente l'ordinamento." -#: catalog/heap.c:1066 catalog/index.c:792 commands/tablecmds.c:2622 +#: catalog/heap.c:1067 catalog/index.c:792 commands/tablecmds.c:2623 #, c-format msgid "relation \"%s\" already exists" msgstr "la relazione \"%s\" esiste già" -#: catalog/heap.c:1082 catalog/pg_type.c:412 catalog/pg_type.c:722 +#: catalog/heap.c:1083 catalog/pg_type.c:412 catalog/pg_type.c:722 #: commands/typecmds.c:237 commands/typecmds.c:784 commands/typecmds.c:1135 #: commands/typecmds.c:1357 commands/typecmds.c:2113 #, c-format msgid "type \"%s\" already exists" msgstr "il tipo \"%s\" esiste già" -#: catalog/heap.c:1083 +#: catalog/heap.c:1084 #, c-format msgid "A relation has an associated type of the same name, so you must use a name that doesn't conflict with any existing type." msgstr "Una relazione ha un tipo associato con lo stesso nome, quindi devi usare nomi che non siano in conflitto con alcun tipo esistente." -#: catalog/heap.c:1111 +#: catalog/heap.c:1112 #, c-format msgid "pg_class heap OID value not set when in binary upgrade mode" msgstr "valore OID heap pg_class non impostato in modalità di aggiornamento binaria" -#: catalog/heap.c:2289 +#: catalog/heap.c:2291 #, c-format msgid "check constraint \"%s\" already exists" msgstr "il vincolo di controllo \"%s\" esiste già" -#: catalog/heap.c:2442 catalog/pg_constraint.c:654 commands/tablecmds.c:6070 +#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6069 #, c-format msgid "constraint \"%s\" for relation \"%s\" already exists" msgstr "il vincolo \"%s\" per la relazione \"%s\" esiste già" -#: catalog/heap.c:2452 +#: catalog/heap.c:2463 #, c-format msgid "constraint \"%s\" conflicts with non-inherited constraint on relation \"%s\"" -msgstr "il vincolo \"%s\" è in conflitto con il vincolo non ereditato sulla relazione \"%s\"" +msgstr "il vincolo \"%s\" è in conflitto con un vincolo non ereditato sulla relazione \"%s\"" -#: catalog/heap.c:2466 +#: catalog/heap.c:2474 +#, c-format +msgid "constraint \"%s\" conflicts with inherited constraint on relation \"%s\"" +msgstr "il vincolo \"%s\" è in conflitto con un vincolo ereditato sulla relazione \"%s\"" + +#: catalog/heap.c:2484 +#, c-format +msgid "constraint \"%s\" conflicts with NOT VALID constraint on relation \"%s\"" +msgstr "il vincolo \"%s\" è in conflitto con un vincolo non valido sulla relazione \"%s\"" + +#: catalog/heap.c:2489 #, c-format msgid "merging constraint \"%s\" with inherited definition" msgstr "unione del vincolo \"%s\" con una definizione ereditata" -#: catalog/heap.c:2559 +#: catalog/heap.c:2595 #, c-format msgid "cannot use column references in default expression" msgstr "non si possono usare riferimenti a colonne nell'espressione predefinita" -#: catalog/heap.c:2570 +#: catalog/heap.c:2606 #, c-format msgid "default expression must not return a set" msgstr "le espressioni predefinite non devono restituire un insieme" -#: catalog/heap.c:2589 rewrite/rewriteHandler.c:1084 +#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1084 #, c-format msgid "column \"%s\" is of type %s but default expression is of type %s" msgstr "la colonna \"%s\" è di tipo %s ma l'espressione predefinita è di tipo %s" -#: catalog/heap.c:2594 commands/prepare.c:374 parser/parse_node.c:428 -#: parser/parse_target.c:528 parser/parse_target.c:778 -#: parser/parse_target.c:788 rewrite/rewriteHandler.c:1089 +#: catalog/heap.c:2630 commands/prepare.c:374 parser/parse_node.c:428 +#: parser/parse_target.c:539 parser/parse_target.c:789 +#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1089 #, c-format msgid "You will need to rewrite or cast the expression." msgstr "Devi riscrivere o convertire il tipo dell'espressione" -#: catalog/heap.c:2641 +#: catalog/heap.c:2677 #, c-format msgid "only table \"%s\" can be referenced in check constraint" msgstr "solo la tabella \"%s\" può essere referenziata nel vincolo di controllo" -#: catalog/heap.c:2881 +#: catalog/heap.c:2917 #, c-format msgid "unsupported ON COMMIT and foreign key combination" msgstr "la combinazione di COMMIT con una chiave esterna non è supportata" -#: catalog/heap.c:2882 +#: catalog/heap.c:2918 #, c-format msgid "Table \"%s\" references \"%s\", but they do not have the same ON COMMIT setting." msgstr "La tabella \"%s\" referenzia \"%s\", ma non hanno la stessa impostazione ON COMMIT." -#: catalog/heap.c:2887 +#: catalog/heap.c:2923 #, c-format msgid "cannot truncate a table referenced in a foreign key constraint" msgstr "non è possibile troncare una tabella referenziata da un vincolo di chiave esterna" -#: catalog/heap.c:2888 +#: catalog/heap.c:2924 #, c-format msgid "Table \"%s\" references \"%s\"." msgstr "La tabella \"%s\" referenzia \"%s\"." -#: catalog/heap.c:2890 +#: catalog/heap.c:2926 #, c-format msgid "Truncate table \"%s\" at the same time, or use TRUNCATE ... CASCADE." msgstr "Troncare la tabella \"%s\" nello stesso tempo o usare TRUNCATE ... CASCADE." -#: catalog/index.c:210 parser/parse_utilcmd.c:1486 parser/parse_utilcmd.c:1572 +#: catalog/index.c:210 parser/parse_utilcmd.c:1473 parser/parse_utilcmd.c:1559 #, c-format msgid "multiple primary keys for table \"%s\" are not allowed" msgstr "non è possibile avere più di una chiave primaria per la tabella \"%s\"" @@ -3782,8 +3803,8 @@ msgstr "la creazione concorrente di indici sulle tabelle del catalogo di sistema msgid "shared indexes cannot be created after initdb" msgstr "indici condivisi non possono essere creati dopo initdb" -#: catalog/index.c:784 commands/createas.c:100 commands/sequence.c:141 -#: parser/parse_utilcmd.c:192 +#: catalog/index.c:784 commands/createas.c:249 commands/sequence.c:141 +#: parser/parse_utilcmd.c:191 #, c-format msgid "relation \"%s\" already exists, skipping" msgstr "la relazione \"%s\" esiste già, saltata" @@ -3803,24 +3824,24 @@ msgstr "DROP INDEX CONCURRENTLY deve essere la prima azione della transazione" msgid "building index \"%s\" on table \"%s\"" msgstr "creazione dell'indice \"%s\" sulla tabella \"%s\"" -#: catalog/index.c:3315 +#: catalog/index.c:3322 #, c-format msgid "cannot reindex temporary tables of other sessions" msgstr "non è possibile reindicizzare le tabelle temporanee di altre sessioni" -#: catalog/index.c:3440 +#: catalog/index.c:3454 #, c-format msgid "index \"%s\" was reindexed" msgstr "l'indice \"%s\" è stato reindicizzato" -#: catalog/index.c:3442 commands/vacuumlazy.c:1323 commands/vacuumlazy.c:1399 -#: commands/vacuumlazy.c:1588 commands/vacuumlazy.c:1789 +#: catalog/index.c:3456 commands/vacuumlazy.c:1338 commands/vacuumlazy.c:1414 +#: commands/vacuumlazy.c:1603 commands/vacuumlazy.c:1813 #, c-format msgid "%s." msgstr "%s." #: catalog/namespace.c:249 catalog/namespace.c:447 catalog/namespace.c:541 -#: commands/trigger.c:4527 +#: commands/trigger.c:4523 #, c-format msgid "cross-database references are not implemented: \"%s.%s.%s\"" msgstr "i riferimenti tra database diversi non sono implementati: \"%s.%s.%s\"" @@ -3840,19 +3861,19 @@ msgstr "lock della relazione \"%s.%s\" fallito" msgid "could not obtain lock on relation \"%s\"" msgstr "lock della relazione \"%s\" fallito" -#: catalog/namespace.c:414 parser/parse_relation.c:1137 +#: catalog/namespace.c:414 parser/parse_relation.c:1138 #, c-format msgid "relation \"%s.%s\" does not exist" msgstr "la relazione \"%s.%s\" non esiste" -#: catalog/namespace.c:419 parser/parse_relation.c:1150 -#: parser/parse_relation.c:1158 utils/adt/regproc.c:1034 +#: catalog/namespace.c:419 parser/parse_relation.c:1151 +#: parser/parse_relation.c:1159 utils/adt/regproc.c:1034 #, c-format msgid "relation \"%s\" does not exist" msgstr "la relazione \"%s\" non esiste" -#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1382 -#: commands/extension.c:1388 +#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1383 +#: commands/extension.c:1389 #, c-format msgid "no schema has been selected to create in" msgstr "nessuna schema selezionato per crearci dentro" @@ -3888,18 +3909,18 @@ msgid "text search template \"%s\" does not exist" msgstr "il modello di ricerca di testo \"%s\" non esiste" #: catalog/namespace.c:2533 commands/tsearchcmds.c:1197 -#: utils/cache/ts_cache.c:613 +#: utils/cache/ts_cache.c:611 #, c-format msgid "text search configuration \"%s\" does not exist" msgstr "la configurazione di ricerca di testo \"%s\" non esiste" -#: catalog/namespace.c:2646 parser/parse_expr.c:789 parser/parse_target.c:1130 +#: catalog/namespace.c:2646 parser/parse_expr.c:792 parser/parse_target.c:1141 #, c-format msgid "cross-database references are not implemented: %s" msgstr "i riferimenti tra database diversi non sono implementati: %s" -#: catalog/namespace.c:2652 parser/parse_expr.c:796 parser/parse_target.c:1137 -#: gram.y:13434 gram.y:14791 +#: catalog/namespace.c:2652 parser/parse_expr.c:799 parser/parse_target.c:1148 +#: gram.y:13450 gram.y:14819 #, c-format msgid "improper qualified name (too many dotted names): %s" msgstr "nome qualificato improprio (troppi nomi puntati): %s" @@ -3914,8 +3935,8 @@ msgstr "non posso spostare oggetti dentro o fuori gli schemi temporanei" msgid "cannot move objects into or out of TOAST schema" msgstr "non posso spostare oggetti dentro o fuori lo schema TOAST" -#: catalog/namespace.c:2862 commands/schemacmds.c:242 -#: commands/schemacmds.c:321 commands/tablecmds.c:740 +#: catalog/namespace.c:2862 commands/schemacmds.c:238 commands/schemacmds.c:317 +#: commands/tablecmds.c:741 #, c-format msgid "schema \"%s\" does not exist" msgstr "lo schema \"%s\" non esiste" @@ -3925,33 +3946,33 @@ msgstr "lo schema \"%s\" non esiste" msgid "improper relation name (too many dotted names): %s" msgstr "nome di relazione improprio (troppi nomi puntati): %s" -#: catalog/namespace.c:3358 +#: catalog/namespace.c:3403 #, c-format msgid "collation \"%s\" for encoding \"%s\" does not exist" msgstr "l'ordinamento \"%s\" per la codifica \"%s\" non esiste" -#: catalog/namespace.c:3413 +#: catalog/namespace.c:3458 #, c-format msgid "conversion \"%s\" does not exist" msgstr "la conversione \"%s\" non esiste" -#: catalog/namespace.c:3621 +#: catalog/namespace.c:3666 #, c-format msgid "permission denied to create temporary tables in database \"%s\"" msgstr "permesso di creare tabelle temporanee nel database \"%s\" negato" -#: catalog/namespace.c:3637 +#: catalog/namespace.c:3682 #, c-format msgid "cannot create temporary tables during recovery" msgstr "non è possibile creare tabelle temporanee durante il recupero" -#: catalog/namespace.c:3643 +#: catalog/namespace.c:3688 #, c-format msgid "cannot create temporary tables in parallel mode" msgstr "non è possibile creare tabelle temporanee in modalità parallela" -#: catalog/namespace.c:3887 commands/tablespace.c:1177 commands/variable.c:63 -#: utils/misc/guc.c:9853 +#: catalog/namespace.c:3932 commands/tablespace.c:1173 commands/variable.c:63 +#: utils/misc/guc.c:9875 #, c-format msgid "List syntax is invalid." msgstr "La sintassi della lista non è valida." @@ -3964,7 +3985,7 @@ msgstr "il nome del metodo di accesso non può essere qualificato" msgid "database name cannot be qualified" msgstr "il nome del database non può essere qualificato" -#: catalog/objectaddress.c:1071 commands/extension.c:2506 +#: catalog/objectaddress.c:1071 commands/extension.c:2507 #, c-format msgid "extension name cannot be qualified" msgstr "il nome dell'estensione non può essere qualificato" @@ -3998,27 +4019,27 @@ msgid "event trigger name cannot be qualified" msgstr "il nome del trigger di evento non può essere qualificato" #: catalog/objectaddress.c:1210 commands/lockcmds.c:94 commands/policy.c:94 -#: commands/policy.c:389 commands/policy.c:478 commands/tablecmds.c:217 -#: commands/tablecmds.c:1299 commands/tablecmds.c:4348 -#: commands/tablecmds.c:7979 +#: commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:218 +#: commands/tablecmds.c:1300 commands/tablecmds.c:4347 +#: commands/tablecmds.c:8017 #, c-format msgid "\"%s\" is not a table" msgstr "\"%s\" non è una tabella" -#: catalog/objectaddress.c:1217 commands/tablecmds.c:229 -#: commands/tablecmds.c:4378 commands/tablecmds.c:12014 commands/view.c:155 +#: catalog/objectaddress.c:1217 commands/tablecmds.c:230 +#: commands/tablecmds.c:4377 commands/tablecmds.c:12159 commands/view.c:141 #, c-format msgid "\"%s\" is not a view" msgstr "\"%s\" non è una vista" -#: catalog/objectaddress.c:1224 commands/matview.c:174 -#: commands/tablecmds.c:235 commands/tablecmds.c:12019 +#: catalog/objectaddress.c:1224 commands/matview.c:174 commands/tablecmds.c:236 +#: commands/tablecmds.c:12164 #, c-format msgid "\"%s\" is not a materialized view" msgstr "\"%s\" non è una vista materializzata" -#: catalog/objectaddress.c:1231 commands/tablecmds.c:253 -#: commands/tablecmds.c:4381 commands/tablecmds.c:12024 +#: catalog/objectaddress.c:1231 commands/tablecmds.c:254 +#: commands/tablecmds.c:4380 commands/tablecmds.c:12169 #, c-format msgid "\"%s\" is not a foreign table" msgstr "\"%s\" non è una tabella esterna" @@ -4034,7 +4055,7 @@ msgid "default value for column \"%s\" of relation \"%s\" does not exist" msgstr "il valore di default per la colonna \"%s\" della relazione \"%s\" non esiste" #: catalog/objectaddress.c:1512 commands/functioncmds.c:128 -#: commands/tablecmds.c:245 commands/typecmds.c:3214 parser/parse_type.c:226 +#: commands/tablecmds.c:246 commands/typecmds.c:3214 parser/parse_type.c:226 #: parser/parse_type.c:255 parser/parse_type.c:795 utils/adt/acl.c:4374 #: utils/adt/regproc.c:1225 #, c-format @@ -4057,8 +4078,7 @@ msgid "user mapping for user \"%s\" on server \"%s\" does not exist" msgstr "la mappatura per l'utente \"%s\" sul server \"%s\" non esiste" #: catalog/objectaddress.c:1722 commands/foreigncmds.c:430 -#: commands/foreigncmds.c:997 commands/foreigncmds.c:1372 -#: foreign/foreign.c:798 +#: commands/foreigncmds.c:997 commands/foreigncmds.c:1359 foreign/foreign.c:692 #, c-format msgid "server \"%s\" does not exist" msgstr "il server \"%s\" non esiste" @@ -4115,7 +4135,7 @@ msgstr "la lunghezza della lista dei nomi deve essere almeno %d" msgid "argument list length must be exactly %d" msgstr "la lunghezza della lista degli argomenti deve essere %d" -#: catalog/objectaddress.c:2165 libpq/be-fsstubs.c:352 +#: catalog/objectaddress.c:2165 libpq/be-fsstubs.c:350 #, c-format msgid "must be owner of large object %u" msgstr "occorre essere proprietari del large object %u" @@ -4135,72 +4155,72 @@ msgstr "occorre essere superutenti" msgid "must have CREATEROLE privilege" msgstr "occorre avere privilegio CREATEROLE" -#: catalog/objectaddress.c:2307 +#: catalog/objectaddress.c:2302 #, c-format msgid "unrecognized object type \"%s\"" msgstr "tipo di oggetto \"%s\" non riconosciuto" -#: catalog/objectaddress.c:2502 +#: catalog/objectaddress.c:2497 #, c-format msgid " column %s" msgstr " colonna %s" -#: catalog/objectaddress.c:2508 +#: catalog/objectaddress.c:2503 #, c-format msgid "function %s" msgstr "funzione %s" -#: catalog/objectaddress.c:2513 +#: catalog/objectaddress.c:2508 #, c-format msgid "type %s" msgstr "tipo %s" -#: catalog/objectaddress.c:2543 +#: catalog/objectaddress.c:2538 #, c-format msgid "cast from %s to %s" msgstr "conversione da %s a %s" -#: catalog/objectaddress.c:2563 +#: catalog/objectaddress.c:2558 #, c-format msgid "collation %s" msgstr "ordinamento %s" -#: catalog/objectaddress.c:2587 +#: catalog/objectaddress.c:2582 #, c-format msgid "constraint %s on %s" msgstr "vincolo %s su %s" -#: catalog/objectaddress.c:2593 +#: catalog/objectaddress.c:2588 #, c-format msgid "constraint %s" msgstr "vincolo %s" -#: catalog/objectaddress.c:2610 +#: catalog/objectaddress.c:2605 #, c-format msgid "conversion %s" msgstr "conversione %s" -#: catalog/objectaddress.c:2647 +#: catalog/objectaddress.c:2642 #, c-format msgid "default for %s" msgstr "predefinito per %s" -#: catalog/objectaddress.c:2656 +#: catalog/objectaddress.c:2651 #, c-format msgid "language %s" msgstr "linguaggio %s" -#: catalog/objectaddress.c:2661 +#: catalog/objectaddress.c:2656 #, c-format msgid "large object %u" msgstr "large object %u" -#: catalog/objectaddress.c:2666 +#: catalog/objectaddress.c:2661 #, c-format msgid "operator %s" msgstr "operatore %s" -#: catalog/objectaddress.c:2698 +#: catalog/objectaddress.c:2693 #, c-format msgid "operator class %s for access method %s" msgstr "classe di operatori %s per il metodo di accesso %s" @@ -4209,7 +4229,7 @@ msgstr "classe di operatori %s per il metodo di accesso %s" #. first two %s's are data type names, the third %s is the #. description of the operator family, and the last %s is the #. textual form of the operator with arguments. -#: catalog/objectaddress.c:2748 +#: catalog/objectaddress.c:2743 #, c-format msgid "operator %d (%s, %s) of %s: %s" msgstr "operatore %d (%s, %s) della %s: %s" @@ -4218,304 +4238,304 @@ msgstr "operatore %d (%s, %s) della %s: %s" #. are data type names, the third %s is the description of the #. operator family, and the last %s is the textual form of the #. function with arguments. -#: catalog/objectaddress.c:2798 +#: catalog/objectaddress.c:2793 #, c-format msgid "function %d (%s, %s) of %s: %s" msgstr "funzione %d (%s, %s) della %s: %s" -#: catalog/objectaddress.c:2838 +#: catalog/objectaddress.c:2833 #, c-format msgid "rule %s on " msgstr "regola %s on " -#: catalog/objectaddress.c:2860 +#: catalog/objectaddress.c:2855 #, c-format msgid "transform for %s language %s" msgstr "trasformazione per %s linguaggio %s" -#: catalog/objectaddress.c:2894 +#: catalog/objectaddress.c:2889 #, c-format msgid "trigger %s on " msgstr "trigger %s su " -#: catalog/objectaddress.c:2911 +#: catalog/objectaddress.c:2906 #, c-format msgid "schema %s" msgstr "schema %s" -#: catalog/objectaddress.c:2924 +#: catalog/objectaddress.c:2919 #, c-format msgid "text search parser %s" msgstr "analizzatore di ricerca di testo %s" -#: catalog/objectaddress.c:2939 +#: catalog/objectaddress.c:2934 #, c-format msgid "text search dictionary %s" msgstr "dizionario di ricerca di testo %s" -#: catalog/objectaddress.c:2954 +#: catalog/objectaddress.c:2949 #, c-format msgid "text search template %s" msgstr "modello di ricerca di testo %s" -#: catalog/objectaddress.c:2969 +#: catalog/objectaddress.c:2964 #, c-format msgid "text search configuration %s" msgstr "configurazione di ricerca di testo %s" -#: catalog/objectaddress.c:2977 +#: catalog/objectaddress.c:2972 #, c-format msgid "role %s" msgstr "regola %s" -#: catalog/objectaddress.c:2990 +#: catalog/objectaddress.c:2985 #, c-format msgid "database %s" msgstr "database %s" -#: catalog/objectaddress.c:3002 +#: catalog/objectaddress.c:2997 #, c-format msgid "tablespace %s" msgstr "tablespace %s" -#: catalog/objectaddress.c:3011 +#: catalog/objectaddress.c:3006 #, c-format msgid "foreign-data wrapper %s" msgstr "wrapper di dati esterni %s" -#: catalog/objectaddress.c:3020 +#: catalog/objectaddress.c:3015 #, c-format msgid "server %s" msgstr "server %s" -#: catalog/objectaddress.c:3048 +#: catalog/objectaddress.c:3043 #, c-format msgid "user mapping for %s on server %s" msgstr "mappatura utenti per %s sul server %s" -#: catalog/objectaddress.c:3083 +#: catalog/objectaddress.c:3078 #, c-format msgid "default privileges on new relations belonging to role %s" msgstr "privilegi predefiniti sulle nuove relazioni appartenenti al ruolo %s" -#: catalog/objectaddress.c:3088 +#: catalog/objectaddress.c:3083 #, c-format msgid "default privileges on new sequences belonging to role %s" msgstr "privilegi predefiniti sulle nuove sequenze appartenenti al ruolo %s" -#: catalog/objectaddress.c:3093 +#: catalog/objectaddress.c:3088 #, c-format msgid "default privileges on new functions belonging to role %s" msgstr "privilegi predefiniti sulle nuove funzioni appartenenti al ruolo %s" -#: catalog/objectaddress.c:3098 +#: catalog/objectaddress.c:3093 #, c-format msgid "default privileges on new types belonging to role %s" msgstr "privilegi predefiniti sui nuovi tipi appartenenti al ruolo %s" -#: catalog/objectaddress.c:3104 +#: catalog/objectaddress.c:3099 #, c-format msgid "default privileges belonging to role %s" msgstr "privilegi predefiniti appartenenti al ruolo %s" -#: catalog/objectaddress.c:3112 +#: catalog/objectaddress.c:3107 #, c-format msgid " in schema %s" msgstr " nello schema %s" -#: catalog/objectaddress.c:3129 +#: catalog/objectaddress.c:3124 #, c-format msgid "extension %s" msgstr "estensione %s" -#: catalog/objectaddress.c:3142 +#: catalog/objectaddress.c:3137 #, c-format msgid "event trigger %s" msgstr "trigger di evento %s" -#: catalog/objectaddress.c:3174 +#: catalog/objectaddress.c:3169 #, c-format msgid "policy %s on " msgstr "regola di sicurezza %s su " -#: catalog/objectaddress.c:3192 +#: catalog/objectaddress.c:3187 #, c-format msgid "access method %s" msgstr "metodo di accesso %s" -#: catalog/objectaddress.c:3252 +#: catalog/objectaddress.c:3247 #, c-format msgid "table %s" msgstr "tabella %s" -#: catalog/objectaddress.c:3256 +#: catalog/objectaddress.c:3251 #, c-format msgid "index %s" msgstr "indice %s" -#: catalog/objectaddress.c:3260 +#: catalog/objectaddress.c:3255 #, c-format msgid "sequence %s" msgstr "sequenza %s" -#: catalog/objectaddress.c:3264 +#: catalog/objectaddress.c:3259 #, c-format msgid "toast table %s" msgstr "tabella toast %s" -#: catalog/objectaddress.c:3268 +#: catalog/objectaddress.c:3263 #, c-format msgid "view %s" msgstr "vista %s" -#: catalog/objectaddress.c:3272 +#: catalog/objectaddress.c:3267 #, c-format msgid "materialized view %s" msgstr "vista materializzata %s" -#: catalog/objectaddress.c:3276 +#: catalog/objectaddress.c:3271 #, c-format msgid "composite type %s" msgstr "tipo composito %s" -#: catalog/objectaddress.c:3280 +#: catalog/objectaddress.c:3275 #, c-format msgid "foreign table %s" msgstr "tabella esterna %s" -#: catalog/objectaddress.c:3285 +#: catalog/objectaddress.c:3280 #, c-format msgid "relation %s" msgstr "relazione %s" -#: catalog/objectaddress.c:3322 +#: catalog/objectaddress.c:3317 #, c-format msgid "operator family %s for access method %s" msgstr "famiglia di operatori %s per il metodo d'accesso %s" -#: catalog/pg_aggregate.c:126 +#: catalog/pg_aggregate.c:125 #, c-format msgid "aggregates cannot have more than %d argument" msgid_plural "aggregates cannot have more than %d arguments" msgstr[0] "gli aggregati non possono avere più di %d argomento" msgstr[1] "gli aggregati non possono avere più di %d argomenti" -#: catalog/pg_aggregate.c:149 catalog/pg_aggregate.c:159 +#: catalog/pg_aggregate.c:148 catalog/pg_aggregate.c:158 #, c-format msgid "cannot determine transition data type" msgstr "non è possibile determinare il tipo di dati della transizione" -#: catalog/pg_aggregate.c:150 catalog/pg_aggregate.c:160 +#: catalog/pg_aggregate.c:149 catalog/pg_aggregate.c:159 #, c-format msgid "An aggregate using a polymorphic transition type must have at least one polymorphic argument." msgstr "Un aggregato che usa un tipo di transizione polimorfico deve avere almeno un argomento polimorfico." -#: catalog/pg_aggregate.c:173 +#: catalog/pg_aggregate.c:172 #, c-format msgid "a variadic ordered-set aggregate must use VARIADIC type ANY" msgstr "un aggregato variadico su insieme ordinato deve usare il tipo VARIADIC ANY" -#: catalog/pg_aggregate.c:199 +#: catalog/pg_aggregate.c:198 #, c-format msgid "a hypothetical-set aggregate must have direct arguments matching its aggregated arguments" msgstr "gli argomenti diretti di un aggregato su insieme ipotetico devono combaciare con gli argomenti aggregati" -#: catalog/pg_aggregate.c:246 catalog/pg_aggregate.c:290 +#: catalog/pg_aggregate.c:245 catalog/pg_aggregate.c:289 #, c-format msgid "return type of transition function %s is not %s" msgstr "il tipo restituito dalla funzione di transizione %s non è %s" -#: catalog/pg_aggregate.c:266 catalog/pg_aggregate.c:309 +#: catalog/pg_aggregate.c:265 catalog/pg_aggregate.c:308 #, c-format msgid "must not omit initial value when transition function is strict and transition type is not compatible with input type" msgstr "non si può omettere initval quando la funzione di transizione è strict e il tipo di transizione non è compatibile col tipo in input" -#: catalog/pg_aggregate.c:335 +#: catalog/pg_aggregate.c:334 #, c-format msgid "return type of inverse transition function %s is not %s" msgstr "il tipo restituito dalla funzione di transizione inversa %s non è %s" -#: catalog/pg_aggregate.c:352 executor/nodeWindowAgg.c:2305 +#: catalog/pg_aggregate.c:351 executor/nodeWindowAgg.c:2334 #, c-format msgid "strictness of aggregate's forward and inverse transition functions must match" msgstr "le ristrettezze della trasformazione diretta ed inversa di un aggregato devono combaciare" -#: catalog/pg_aggregate.c:396 catalog/pg_aggregate.c:547 +#: catalog/pg_aggregate.c:395 catalog/pg_aggregate.c:545 #, c-format msgid "final function with extra arguments must not be declared STRICT" msgstr "la funzione finale con argomenti aggiuntivi non deve essere dichiarata STRICT" -#: catalog/pg_aggregate.c:426 +#: catalog/pg_aggregate.c:425 #, c-format msgid "return type of combine function %s is not %s" msgstr "il tipo restituito dalla funzione di combinazione %s non è %s" -#: catalog/pg_aggregate.c:437 +#: catalog/pg_aggregate.c:436 #, c-format msgid "combine function with \"%s\" transition type must not be declared STRICT" msgstr "una funzione di combinazione con \"%s\" tipi di transizione non può essere dichiarata STRICT" -#: catalog/pg_aggregate.c:457 +#: catalog/pg_aggregate.c:455 #, c-format msgid "return type of serialization function %s is not %s" msgstr "il tipo restituito dalla funzione di serializzazione %s non è %s" -#: catalog/pg_aggregate.c:477 +#: catalog/pg_aggregate.c:475 #, c-format msgid "return type of deserialization function %s is not %s" msgstr "il tipo restituito dalla funzione di deserializzazione %s non è %s" -#: catalog/pg_aggregate.c:493 catalog/pg_proc.c:246 catalog/pg_proc.c:253 +#: catalog/pg_aggregate.c:491 catalog/pg_proc.c:246 catalog/pg_proc.c:253 #, c-format msgid "cannot determine result data type" msgstr "non è possibile determinare il tipo di dati del risultato" -#: catalog/pg_aggregate.c:494 +#: catalog/pg_aggregate.c:492 #, c-format msgid "An aggregate returning a polymorphic type must have at least one polymorphic argument." msgstr "Una funzione di aggregazione che restituisce un tipo polimorfico deve avere almeno un argomento polimorfico." -#: catalog/pg_aggregate.c:506 catalog/pg_proc.c:259 +#: catalog/pg_aggregate.c:504 catalog/pg_proc.c:259 #, c-format msgid "unsafe use of pseudo-type \"internal\"" msgstr "uso dello pseudo-tipo \"internal\" non sicuro" -#: catalog/pg_aggregate.c:507 catalog/pg_proc.c:260 +#: catalog/pg_aggregate.c:505 catalog/pg_proc.c:260 #, c-format msgid "A function returning \"internal\" must have at least one \"internal\" argument." msgstr "Una funzione che restituisce \"internal\" deve avere almeno un argomento \"internal\"." -#: catalog/pg_aggregate.c:560 +#: catalog/pg_aggregate.c:558 #, c-format msgid "moving-aggregate implementation returns type %s, but plain implementation returns type %s" msgstr "l'implementazione dell'aggregazione mobile restituisce il tipo %s ma l'implementazione semplice resituisce il tipo %s" -#: catalog/pg_aggregate.c:571 +#: catalog/pg_aggregate.c:569 #, c-format msgid "sort operator can only be specified for single-argument aggregates" msgstr "l'operatore di ordinamento può essere specificato sono per aggregati con un solo argomento" -#: catalog/pg_aggregate.c:816 commands/typecmds.c:1705 -#: commands/typecmds.c:1756 commands/typecmds.c:1787 commands/typecmds.c:1810 -#: commands/typecmds.c:1831 commands/typecmds.c:1858 commands/typecmds.c:1885 -#: commands/typecmds.c:1962 commands/typecmds.c:2004 parser/parse_func.c:364 -#: parser/parse_func.c:393 parser/parse_func.c:418 parser/parse_func.c:432 -#: parser/parse_func.c:507 parser/parse_func.c:518 parser/parse_func.c:1921 +#: catalog/pg_aggregate.c:812 commands/typecmds.c:1705 commands/typecmds.c:1756 +#: commands/typecmds.c:1787 commands/typecmds.c:1810 commands/typecmds.c:1831 +#: commands/typecmds.c:1858 commands/typecmds.c:1885 commands/typecmds.c:1962 +#: commands/typecmds.c:2004 parser/parse_func.c:364 parser/parse_func.c:393 +#: parser/parse_func.c:418 parser/parse_func.c:432 parser/parse_func.c:507 +#: parser/parse_func.c:518 parser/parse_func.c:1923 #, c-format msgid "function %s does not exist" msgstr "la funzione %s non esiste" -#: catalog/pg_aggregate.c:822 +#: catalog/pg_aggregate.c:818 #, c-format msgid "function %s returns a set" msgstr "la funzione %s restituisce un insieme" -#: catalog/pg_aggregate.c:837 +#: catalog/pg_aggregate.c:833 #, c-format msgid "function %s must accept VARIADIC ANY to be used in this aggregate" msgstr "la funzione %s deve accettare VARIADIC ANY per essere usata in questo aggregato" -#: catalog/pg_aggregate.c:861 +#: catalog/pg_aggregate.c:857 #, c-format msgid "function %s requires run-time type coercion" msgstr "la funzione %s richiede una coercizione di tipo a run-time" @@ -4565,7 +4585,7 @@ msgstr "la conversione \"%s\" esiste già" msgid "default conversion for %s to %s already exists" msgstr "la conversione predefinita da %s a %s esiste già" -#: catalog/pg_depend.c:165 commands/extension.c:3028 +#: catalog/pg_depend.c:165 commands/extension.c:3029 #, c-format msgid "%s is already a member of extension \"%s\"" msgstr "%s fa già parte dell'estensione \"%s\"" @@ -4610,7 +4630,7 @@ msgstr "valore di OID di pg_enum non impostato in modalità di aggiornamento bin msgid "ALTER TYPE ADD BEFORE/AFTER is incompatible with binary upgrade" msgstr "ALTER TYPE ADD BEFORE/AFTER non è compatibile con gli aggiornamenti binari" -#: catalog/pg_namespace.c:61 commands/schemacmds.c:250 +#: catalog/pg_namespace.c:61 commands/schemacmds.c:246 #, c-format msgid "schema \"%s\" already exists" msgstr "lo schema \"%s\" esiste già" @@ -4675,7 +4695,7 @@ msgstr "l'operatore %s esiste già " msgid "operator cannot be its own negator or sort operator" msgstr "l'operatore non può negare o ordinare se stesso" -#: catalog/pg_proc.c:134 parser/parse_func.c:1945 parser/parse_func.c:1985 +#: catalog/pg_proc.c:134 parser/parse_func.c:1947 parser/parse_func.c:1987 #, c-format msgid "functions cannot have more than %d argument" msgid_plural "functions cannot have more than %d arguments" @@ -4768,7 +4788,7 @@ msgstr "Le funzioni SQL non possono restituire il tipo %s" msgid "SQL functions cannot have arguments of type %s" msgstr "le funzioni SQL non possono avere argomenti di tipo %s" -#: catalog/pg_proc.c:973 executor/functions.c:1424 +#: catalog/pg_proc.c:973 executor/functions.c:1431 #, c-format msgid "SQL function \"%s\"" msgstr "funzione SQL \"%s\"" @@ -4872,8 +4892,8 @@ msgstr "i tipi a dimensione fissa devono avere immagazzinamento PLAIN" msgid "could not form array type name for type \"%s\"" msgstr "creazione del nome per il tipo array del tipo \"%s\" fallita" -#: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4360 -#: commands/tablecmds.c:11902 +#: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4359 +#: commands/tablecmds.c:12047 #, c-format msgid "\"%s\" is not a table or materialized view" msgstr "\"%s\" non è una tabella né una vista materializzata" @@ -4883,112 +4903,87 @@ msgstr "\"%s\" non è una tabella né una vista materializzata" msgid "shared tables cannot be toasted after initdb" msgstr "le tabelle condivise non possono essere trasformate in toast dopo initdb" -#: commands/aggregatecmds.c:161 +#: commands/aggregatecmds.c:159 #, c-format msgid "only ordered-set aggregates can be hypothetical" msgstr "solo gli aggregati su insiemi ordinati possono essere ipotetici" -#: commands/aggregatecmds.c:188 +#: commands/aggregatecmds.c:184 #, c-format msgid "aggregate attribute \"%s\" not recognized" msgstr "attributo dell'aggregato \"%s\" non riconosciuto" -#: commands/aggregatecmds.c:198 +#: commands/aggregatecmds.c:194 #, c-format msgid "aggregate stype must be specified" msgstr "l'attributo stype dell'aggregato deve essere specificato" -#: commands/aggregatecmds.c:202 +#: commands/aggregatecmds.c:198 #, c-format msgid "aggregate sfunc must be specified" msgstr "l'attributo sfunc dell'aggregato deve essere specificato" -#: commands/aggregatecmds.c:214 +#: commands/aggregatecmds.c:210 #, c-format msgid "aggregate msfunc must be specified when mstype is specified" msgstr "l'attributo msfunc dell'aggregato deve essere specificato quando mstype lo è" -#: commands/aggregatecmds.c:218 +#: commands/aggregatecmds.c:214 #, c-format msgid "aggregate minvfunc must be specified when mstype is specified" msgstr "l'attributo minvfunc dell'aggregato deve essere specificato quando mstype lo è" -#: commands/aggregatecmds.c:225 +#: commands/aggregatecmds.c:221 #, c-format msgid "aggregate msfunc must not be specified without mstype" msgstr "l'attributo msfunc dell'aggregato non deve essere specificato se mstype non lo è" -#: commands/aggregatecmds.c:229 +#: commands/aggregatecmds.c:225 #, c-format msgid "aggregate minvfunc must not be specified without mstype" msgstr "l'attributo minvfunc dell'aggregato non deve essere specificato se mstype non lo è" -#: commands/aggregatecmds.c:233 +#: commands/aggregatecmds.c:229 #, c-format msgid "aggregate mfinalfunc must not be specified without mstype" msgstr "l'attributo mfinalfunc dell'aggregato non deve essere specificato se mstype non lo è" -#: commands/aggregatecmds.c:237 +#: commands/aggregatecmds.c:233 #, c-format msgid "aggregate msspace must not be specified without mstype" msgstr "l'attributo msspace dell'aggregato non deve essere specificato se mstype non lo è" -#: commands/aggregatecmds.c:241 +#: commands/aggregatecmds.c:237 #, c-format msgid "aggregate minitcond must not be specified without mstype" msgstr "l'attributo minitcond dell'aggregato non deve essere specificato se mstype non lo è" -#: commands/aggregatecmds.c:261 +#: commands/aggregatecmds.c:257 #, c-format msgid "aggregate input type must be specified" msgstr "il tipo di input dell'aggregato deve essere specificato" -#: commands/aggregatecmds.c:291 +#: commands/aggregatecmds.c:287 #, c-format msgid "basetype is redundant with aggregate input type specification" msgstr "il basetype è ridondante se il tipo di input è specificato per un aggregato" -#: commands/aggregatecmds.c:332 commands/aggregatecmds.c:421 +#: commands/aggregatecmds.c:328 commands/aggregatecmds.c:369 #, c-format msgid "aggregate transition data type cannot be %s" msgstr "il tipo di dato della transizione dell'aggregato non può essere %s" -#: commands/aggregatecmds.c:347 -#, c-format -msgid "a serialization type must only be specified when the aggregate transition data type is \"%s\"" -msgstr "un tipo di serializzazione dev'essere specificato solo quando il tipo di dato di transizione dell'aggregato è \"%s\"" - -#: commands/aggregatecmds.c:356 -#, c-format -msgid "aggregate serialization data type cannot be %s" -msgstr "il tipo di dato di serializzazione dell'aggregato non può essere %s" - -#: commands/aggregatecmds.c:369 -#, c-format -msgid "aggregate serialization type cannot be \"%s\"" -msgstr "il tipo di serializzazione dell'aggregato non può essere \"%s\"" - -#: commands/aggregatecmds.c:380 -#, c-format -msgid "aggregate serialization function must be specified when serialization type is specified" -msgstr "occorre specificare una funzione di serializzazione dell'aggregato quando il tipo di serializzazione è specificato" - -#: commands/aggregatecmds.c:385 -#, c-format -msgid "aggregate deserialization function must be specified when serialization type is specified" -msgstr "occorre specificare una funzione di deserializzazione dell'aggregato quando il tipo di serializzazione è specificato" - -#: commands/aggregatecmds.c:396 +#: commands/aggregatecmds.c:340 #, c-format -msgid "must specify serialization type when specifying serialization function" -msgstr "occorre specificare il tipo di serializzazione quando la funzione di serializzazione è specificata" +msgid "serialization functions may be specified only when the aggregate transition data type is %s" +msgstr "le funzioni di serializzazione possono essere specificate solo quando il tipo di dato di transizione dell'aggregato è %s" -#: commands/aggregatecmds.c:402 +#: commands/aggregatecmds.c:350 #, c-format -msgid "must specify serialization type when specifying deserialization function" -msgstr "occorre specificare il tipo di serializzazione quando la funzione di deserializzazione è specificata" +msgid "must specify both or neither of serialization and deserialization functions" +msgstr "occorre specificare o entrambe le funzioni di serializzazione e deserializzazione o nessuna" -#: commands/aggregatecmds.c:467 commands/functioncmds.c:570 +#: commands/aggregatecmds.c:415 commands/functioncmds.c:570 #, c-format msgid "parameter \"parallel\" must be SAFE, RESTRICTED, or UNSAFE" msgstr "il parametro \"parallel\" deve essere SAFE, RESTRICTED o UNSAFE" @@ -5043,7 +5038,7 @@ msgstr "la configurazione di ricerca di testo \"%s\" esiste già nello schema \" msgid "must be superuser to rename %s" msgstr "occorre essere un superutente per rinominare %s" -#: commands/alter.c:656 +#: commands/alter.c:655 #, c-format msgid "must be superuser to set schema of %s" msgstr "occorre essere un superutente per impostare lo schema di %s" @@ -5126,71 +5121,71 @@ msgstr "analisi dell'albero di ereditarietà di \"%s.%s\"" msgid "analyzing \"%s.%s\"" msgstr "analisi di \"%s.%s\"" -#: commands/analyze.c:651 +#: commands/analyze.c:650 #, c-format msgid "automatic analyze of table \"%s.%s.%s\" system usage: %s" msgstr "analisi automatica della tabella \"%s.%s.%s\" uso del sistema: %s" -#: commands/analyze.c:1207 +#: commands/analyze.c:1204 #, c-format msgid "\"%s\": scanned %d of %u pages, containing %.0f live rows and %.0f dead rows; %d rows in sample, %.0f estimated total rows" msgstr "\"%s\": esaminate %d pagine su %u, contenenti %.0f righe vive e %.0f righe morte; %d righe nel campione, %.0f righe totali stimate" -#: commands/analyze.c:1286 +#: commands/analyze.c:1283 #, c-format msgid "skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no child tables" msgstr "analyze dell'albero di ereditarietà \"%s.%s\" saltato --- questo albero non ha tabelle figlie" -#: commands/analyze.c:1375 +#: commands/analyze.c:1372 #, c-format msgid "skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no analyzable child tables" msgstr "analyze dell'albero di ereditarietà \"%s.%s\" saltato --- questo albero non ha tabelle figlie analizzabili" -#: commands/analyze.c:1423 executor/execQual.c:2922 +#: commands/analyze.c:1420 commands/tablecmds.c:8079 executor/execQual.c:2927 msgid "could not convert row type" msgstr "conversione del tipo riga fallita" -#: commands/async.c:558 +#: commands/async.c:555 #, c-format msgid "channel name cannot be empty" msgstr "Il nome del canale non può essere vuoto" -#: commands/async.c:563 +#: commands/async.c:560 #, c-format msgid "channel name too long" msgstr "il nome del canale è troppo lungo" -#: commands/async.c:570 +#: commands/async.c:567 #, c-format msgid "payload string too long" msgstr "la stringa del carico è troppo lunga" -#: commands/async.c:756 +#: commands/async.c:753 #, c-format msgid "cannot PREPARE a transaction that has executed LISTEN, UNLISTEN, or NOTIFY" msgstr "non è possibile eseguire PREPARE in una transazione che ha eseguito LISTEN, UNLISTEN o NOTIFY" -#: commands/async.c:859 +#: commands/async.c:856 #, c-format msgid "too many notifications in the NOTIFY queue" msgstr "troppe notifiche nella coda di NOTIFY" -#: commands/async.c:1489 +#: commands/async.c:1486 #, c-format msgid "NOTIFY queue is %.0f%% full" msgstr "la coda di NOTIFY è piena al %.0f%%" -#: commands/async.c:1491 +#: commands/async.c:1488 #, c-format msgid "The server process with PID %d is among those with the oldest transactions." msgstr "Il processo server con PID %d è tra quelli con le transazioni più vecchie." -#: commands/async.c:1494 +#: commands/async.c:1491 #, c-format msgid "The NOTIFY queue cannot be emptied until that process ends its current transaction." msgstr "La coda di NOTIFY non può essere svuotata finché quel processo non avrà terminato la sua transazione corrente." -#: commands/cluster.c:129 commands/cluster.c:366 +#: commands/cluster.c:129 commands/cluster.c:364 #, c-format msgid "cannot cluster temporary tables of other sessions" msgstr "non è possibile raggruppare tabelle temporanee di altre sessioni" @@ -5200,62 +5195,62 @@ msgstr "non è possibile raggruppare tabelle temporanee di altre sessioni" msgid "there is no previously clustered index for table \"%s\"" msgstr "non esiste un indice già raggruppato per la tabella \"%s\"" -#: commands/cluster.c:173 commands/tablecmds.c:9288 commands/tablecmds.c:11004 +#: commands/cluster.c:173 commands/tablecmds.c:9383 commands/tablecmds.c:11143 #, c-format msgid "index \"%s\" for table \"%s\" does not exist" msgstr "l'indice \"%s\" per la tabella \"%s\" non esiste" -#: commands/cluster.c:355 +#: commands/cluster.c:353 #, c-format msgid "cannot cluster a shared catalog" msgstr "non è possibile raggruppare un catalogo condiviso" -#: commands/cluster.c:370 +#: commands/cluster.c:368 #, c-format msgid "cannot vacuum temporary tables of other sessions" msgstr "non è possibile ripulire tabelle temporanee di altre sessioni" -#: commands/cluster.c:433 commands/tablecmds.c:11014 +#: commands/cluster.c:431 commands/tablecmds.c:11153 #, c-format msgid "\"%s\" is not an index for table \"%s\"" msgstr "\"%s\" non è un indice per la tabella \"%s\"" -#: commands/cluster.c:441 +#: commands/cluster.c:439 #, c-format msgid "cannot cluster on index \"%s\" because access method does not support clustering" msgstr "non è possibile raggruppare sull'indice \"%s\" perché il metodo di accesso non supporta il raggruppamento" -#: commands/cluster.c:453 +#: commands/cluster.c:451 #, c-format msgid "cannot cluster on partial index \"%s\"" msgstr "non è possibile raggruppare sull'indice parziale \"%s\"" -#: commands/cluster.c:467 +#: commands/cluster.c:465 #, c-format msgid "cannot cluster on invalid index \"%s\"" msgstr "non è possibile raggruppare sull'indice non valido \"%s\"" -#: commands/cluster.c:920 +#: commands/cluster.c:918 #, c-format msgid "clustering \"%s.%s\" using index scan on \"%s\"" msgstr "raggruppamento di \"%s.%s\" usando una scansione sull'indice \"%s\"" -#: commands/cluster.c:926 +#: commands/cluster.c:924 #, c-format msgid "clustering \"%s.%s\" using sequential scan and sort" msgstr "raggruppamento di \"%s.%s\" usando una scansione sequenziale e ordinamento" -#: commands/cluster.c:931 commands/vacuumlazy.c:476 +#: commands/cluster.c:929 commands/vacuumlazy.c:479 #, c-format msgid "vacuuming \"%s.%s\"" msgstr "pulizia di \"%s.%s\"" -#: commands/cluster.c:1090 +#: commands/cluster.c:1088 #, c-format msgid "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u pages" msgstr "\"%s\": trovate %.0f versioni di riga removibili, %.0f non removibili in %u pagine" -#: commands/cluster.c:1094 +#: commands/cluster.c:1092 #, c-format msgid "" "%.0f dead row versions cannot be removed yet.\n" @@ -5292,23 +5287,23 @@ msgstr "l'ordinamento \"%s\" già esiste nello schema \"%s\"" #: commands/comment.c:62 commands/dbcommands.c:797 commands/dbcommands.c:962 #: commands/dbcommands.c:1067 commands/dbcommands.c:1257 #: commands/dbcommands.c:1477 commands/dbcommands.c:1594 -#: commands/dbcommands.c:2011 utils/init/postinit.c:842 -#: utils/init/postinit.c:944 utils/init/postinit.c:961 +#: commands/dbcommands.c:2011 utils/init/postinit.c:841 +#: utils/init/postinit.c:943 utils/init/postinit.c:960 #, c-format msgid "database \"%s\" does not exist" msgstr "il database \"%s\" non esiste" -#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:768 +#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:753 #, c-format msgid "\"%s\" is not a table, view, materialized view, composite type, or foreign table" msgstr "\"%s\" non è una tabella, vista, vista materializzata, tipo composito né una tabella esterna" -#: commands/constraint.c:60 utils/adt/ri_triggers.c:2717 +#: commands/constraint.c:60 utils/adt/ri_triggers.c:2715 #, c-format msgid "function \"%s\" was not called by trigger manager" msgstr "la funzione \"%s\" non è stata invocata dal trigger manager" -#: commands/constraint.c:67 utils/adt/ri_triggers.c:2726 +#: commands/constraint.c:67 utils/adt/ri_triggers.c:2724 #, c-format msgid "function \"%s\" must be fired AFTER ROW" msgstr "la funzione \"%s\" deve essere eseguita AFTER ROW" @@ -5390,466 +5385,466 @@ msgstr "Chiunque può eseguire COPY verso stdout e da stdin. Anche il comando \\ msgid "must be superuser to COPY to or from a file" msgstr "bisogna essere un superutente per eseguire un COPY da o verso un file" -#: commands/copy.c:878 +#: commands/copy.c:879 #, c-format msgid "COPY FROM not supported with row-level security" msgstr "COPY FROM non supportato con il livello di sicurezza di righe" -#: commands/copy.c:879 +#: commands/copy.c:880 #, c-format msgid "Use INSERT statements instead." msgstr "Usa istruzioni INSERT invece." -#: commands/copy.c:1019 +#: commands/copy.c:1058 #, c-format msgid "COPY format \"%s\" not recognized" msgstr "Formato di COPY \"%s\" non riconosciuto" -#: commands/copy.c:1090 commands/copy.c:1104 commands/copy.c:1118 -#: commands/copy.c:1138 +#: commands/copy.c:1129 commands/copy.c:1143 commands/copy.c:1157 +#: commands/copy.c:1177 #, c-format msgid "argument to option \"%s\" must be a list of column names" msgstr "l'argomento dell'opzione \"%s\" dev'essere una lista di nomi di colonne" -#: commands/copy.c:1151 +#: commands/copy.c:1190 #, c-format msgid "argument to option \"%s\" must be a valid encoding name" msgstr "l'argomento dell'opzione \"%s\" dev'essere un nome di codifica valido" -#: commands/copy.c:1157 commands/dbcommands.c:232 commands/dbcommands.c:1427 +#: commands/copy.c:1196 commands/dbcommands.c:232 commands/dbcommands.c:1427 #, c-format msgid "option \"%s\" not recognized" msgstr "opzione \"%s\" non riconosciuta" -#: commands/copy.c:1168 +#: commands/copy.c:1207 #, c-format msgid "cannot specify DELIMITER in BINARY mode" msgstr "non è possibile specificare DELIMITER in BINARY mode" -#: commands/copy.c:1173 +#: commands/copy.c:1212 #, c-format msgid "cannot specify NULL in BINARY mode" msgstr "non è possibile specificare NULL in BINARY mode" -#: commands/copy.c:1195 +#: commands/copy.c:1234 #, c-format msgid "COPY delimiter must be a single one-byte character" msgstr "il delimitatore di COPY deve essere un solo carattere di un solo byte" -#: commands/copy.c:1202 +#: commands/copy.c:1241 #, c-format msgid "COPY delimiter cannot be newline or carriage return" msgstr "Il delimitatore di COPY non può essere una \"nuova riga\" o un \"ritorno carrello\"" -#: commands/copy.c:1208 +#: commands/copy.c:1247 #, c-format msgid "COPY null representation cannot use newline or carriage return" msgstr "la rappresentazione dei null in COPY non può usare \"nuova riga\" o \"ritorno carrello\"" -#: commands/copy.c:1225 +#: commands/copy.c:1264 #, c-format msgid "COPY delimiter cannot be \"%s\"" msgstr "il delimitatore di COPY non può essere \"%s\"" -#: commands/copy.c:1231 +#: commands/copy.c:1270 #, c-format msgid "COPY HEADER available only in CSV mode" msgstr "l'HEADER di COPY è disponibile solo in modalità CSV" -#: commands/copy.c:1237 +#: commands/copy.c:1276 #, c-format msgid "COPY quote available only in CSV mode" msgstr "il quoting di COPY è disponibile solo in modalità CSV" -#: commands/copy.c:1242 +#: commands/copy.c:1281 #, c-format msgid "COPY quote must be a single one-byte character" msgstr "il quote di COPY dev'essere un solo carattere di un byte" -#: commands/copy.c:1247 +#: commands/copy.c:1286 #, c-format msgid "COPY delimiter and quote must be different" msgstr "il delimitatore e il quote di COPY devono essere diversi" -#: commands/copy.c:1253 +#: commands/copy.c:1292 #, c-format msgid "COPY escape available only in CSV mode" msgstr "l'escape di COPY è disponibile solo in modalità CSV" -#: commands/copy.c:1258 +#: commands/copy.c:1297 #, c-format msgid "COPY escape must be a single one-byte character" msgstr "l'escape di COPY deve essere un solo carattere di un byte" -#: commands/copy.c:1264 +#: commands/copy.c:1303 #, c-format msgid "COPY force quote available only in CSV mode" msgstr "il \"force quote\" di COPY è disponibile solo in modalità CSV" -#: commands/copy.c:1268 +#: commands/copy.c:1307 #, c-format msgid "COPY force quote only available using COPY TO" msgstr "il \"force quote\" di COPY è disponibile solo in modalità CSV" -#: commands/copy.c:1274 +#: commands/copy.c:1313 #, c-format msgid "COPY force not null available only in CSV mode" msgstr "il \"force not null\" di COPY è disponibile solo in modalità CSV" -#: commands/copy.c:1278 +#: commands/copy.c:1317 #, c-format msgid "COPY force not null only available using COPY FROM" msgstr "il \"force not null\" di COPY è disponibile solo in COPY FROM" -#: commands/copy.c:1284 +#: commands/copy.c:1323 #, c-format msgid "COPY force null available only in CSV mode" msgstr "il \"force null\" di COPY è disponibile solo in modalità CSV" -#: commands/copy.c:1289 +#: commands/copy.c:1328 #, c-format msgid "COPY force null only available using COPY FROM" msgstr "il \"force null\" di COPY è disponibile solo usando COPY FROM" -#: commands/copy.c:1295 +#: commands/copy.c:1334 #, c-format msgid "COPY delimiter must not appear in the NULL specification" msgstr "il delimitatore di COPY non deve apparire nella specificazione di NULL" -#: commands/copy.c:1302 +#: commands/copy.c:1341 #, c-format msgid "CSV quote character must not appear in the NULL specification" msgstr "Il carattere quote del CSV non deve apparire nella specificazione di NULL" -#: commands/copy.c:1365 +#: commands/copy.c:1402 #, c-format msgid "table \"%s\" does not have OIDs" msgstr "la tabella \"%s\" non ha OID" -#: commands/copy.c:1382 +#: commands/copy.c:1419 #, c-format msgid "COPY (query) WITH OIDS is not supported" msgstr "COPY (query) WITH OIDS non è supportata" -#: commands/copy.c:1402 +#: commands/copy.c:1439 #, c-format msgid "DO INSTEAD NOTHING rules are not supported for COPY" msgstr "le regole DO INSTEAD NOTHING non sono supportate per COPY" -#: commands/copy.c:1416 +#: commands/copy.c:1453 #, c-format msgid "conditional DO INSTEAD rules are not supported for COPY" msgstr "le regole DO INSTEAD condizionali non sono supportate per COPY" -#: commands/copy.c:1420 +#: commands/copy.c:1457 #, c-format msgid "DO ALSO rules are not supported for the COPY" msgstr "le regole DO ALSO non sono supportate per COPY" -#: commands/copy.c:1425 +#: commands/copy.c:1462 #, c-format msgid "multi-statement DO INSTEAD rules are not supported for COPY" msgstr "le regole DO INSTEAD con più istruzioni non sono supportate per COPY" -#: commands/copy.c:1435 +#: commands/copy.c:1472 #, c-format msgid "COPY (SELECT INTO) is not supported" msgstr "COPY (SELECT INTO) non è supportata" -#: commands/copy.c:1452 +#: commands/copy.c:1489 #, c-format msgid "COPY query must have a RETURNING clause" msgstr "la query COPY deve avere una clausola RETURNING" -#: commands/copy.c:1480 +#: commands/copy.c:1517 #, c-format msgid "relation referenced by COPY statement has changed" msgstr "la relazione referenziata dall'istruzione COPY è cambiata" -#: commands/copy.c:1538 +#: commands/copy.c:1575 #, c-format msgid "FORCE_QUOTE column \"%s\" not referenced by COPY" msgstr "la colonna FORCE_QUOTE \"%s\" non è referenziata da COPY" -#: commands/copy.c:1560 +#: commands/copy.c:1597 #, c-format msgid "FORCE_NOT_NULL column \"%s\" not referenced by COPY" msgstr "la colonna FORCE_NOT_NULL \"%s\" non è referenziata da COPY" -#: commands/copy.c:1582 +#: commands/copy.c:1619 #, c-format msgid "FORCE_NULL column \"%s\" not referenced by COPY" msgstr "la colonna FORCE_NULL \"%s\" non è referenziata da COPY" -#: commands/copy.c:1647 +#: commands/copy.c:1684 #, c-format msgid "could not close pipe to external command: %m" msgstr "chiusura della pipe per verso il comando esterno fallita: %m" -#: commands/copy.c:1651 +#: commands/copy.c:1688 #, c-format msgid "program \"%s\" failed" msgstr "programma \"%s\" fallito" -#: commands/copy.c:1701 +#: commands/copy.c:1738 #, c-format msgid "cannot copy from view \"%s\"" msgstr "non è possibile copiare dalla vista \"%s\"" -#: commands/copy.c:1703 commands/copy.c:1709 commands/copy.c:1715 +#: commands/copy.c:1740 commands/copy.c:1746 commands/copy.c:1752 #, c-format msgid "Try the COPY (SELECT ...) TO variant." msgstr "Prova la variante COPY (SELECT ...) TO." -#: commands/copy.c:1707 +#: commands/copy.c:1744 #, c-format msgid "cannot copy from materialized view \"%s\"" msgstr "non è possibile copiare dalla vista materializzata \"%s\"" -#: commands/copy.c:1713 +#: commands/copy.c:1750 #, c-format msgid "cannot copy from foreign table \"%s\"" msgstr "non è possibile copiare dalla tabella esterna \"%s\"" -#: commands/copy.c:1719 +#: commands/copy.c:1756 #, c-format msgid "cannot copy from sequence \"%s\"" msgstr "non è possibile copiare dalla sequenza \"%s\"" -#: commands/copy.c:1724 +#: commands/copy.c:1761 #, c-format msgid "cannot copy from non-table relation \"%s\"" msgstr "non è possibile copiare dalla relazione \"%s\" perché non è una tabella" -#: commands/copy.c:1749 commands/copy.c:2787 +#: commands/copy.c:1786 commands/copy.c:2822 #, c-format msgid "could not execute command \"%s\": %m" msgstr "esecuzione del comando \"%s\" fallita: %m" -#: commands/copy.c:1764 +#: commands/copy.c:1801 #, c-format msgid "relative path not allowed for COPY to file" msgstr "i percorsi relativi non sono consentiti per il COPY verso un file" -#: commands/copy.c:1772 +#: commands/copy.c:1809 #, c-format msgid "could not open file \"%s\" for writing: %m" msgstr "apertura del file \"%s\" in scrittura fallita: %m" -#: commands/copy.c:1784 commands/copy.c:2810 +#: commands/copy.c:1821 commands/copy.c:2845 #, c-format msgid "\"%s\" is a directory" msgstr "\"%s\" è una directory" -#: commands/copy.c:2109 +#: commands/copy.c:2144 #, c-format msgid "COPY %s, line %d, column %s" msgstr "COPY %s, riga %d, colonna %s" -#: commands/copy.c:2113 commands/copy.c:2160 +#: commands/copy.c:2148 commands/copy.c:2195 #, c-format msgid "COPY %s, line %d" msgstr "COPY %s, riga %d" -#: commands/copy.c:2124 +#: commands/copy.c:2159 #, c-format msgid "COPY %s, line %d, column %s: \"%s\"" msgstr "COPY %s, riga %d, colonna %s: \"%s\"" -#: commands/copy.c:2132 +#: commands/copy.c:2167 #, c-format msgid "COPY %s, line %d, column %s: null input" msgstr "COPY %s, riga %d, colonna %s: input nullo" -#: commands/copy.c:2154 +#: commands/copy.c:2189 #, c-format msgid "COPY %s, line %d: \"%s\"" msgstr "COPY %s, riga %d: \"%s\"" -#: commands/copy.c:2238 +#: commands/copy.c:2273 #, c-format msgid "cannot copy to view \"%s\"" msgstr "non è possibile copiare verso la vista \"%s\"" -#: commands/copy.c:2243 +#: commands/copy.c:2278 #, c-format msgid "cannot copy to materialized view \"%s\"" msgstr "non è possibile copiare verso la vista materializzata \"%s\"" -#: commands/copy.c:2248 +#: commands/copy.c:2283 #, c-format msgid "cannot copy to foreign table \"%s\"" msgstr "non è possibile copiare verso la tabella esterna \"%s\"" -#: commands/copy.c:2253 +#: commands/copy.c:2288 #, c-format msgid "cannot copy to sequence \"%s\"" msgstr "non è possibile copiare verso sequenza \"%s\"" -#: commands/copy.c:2258 +#: commands/copy.c:2293 #, c-format msgid "cannot copy to non-table relation \"%s\"" msgstr "non è possibile copiare verso la relazione \"%s\" perché non è una tabella" -#: commands/copy.c:2321 +#: commands/copy.c:2356 #, c-format msgid "cannot perform FREEZE because of prior transaction activity" msgstr "non è possibile eseguire FREEZE a causa di precedente attività della transazione" -#: commands/copy.c:2327 +#: commands/copy.c:2362 #, c-format msgid "cannot perform FREEZE because the table was not created or truncated in the current subtransaction" msgstr "non è possibile eseguire FREEZE perché la tabella non è stata creata o troncata nella sottotransazione corrente" -#: commands/copy.c:2830 +#: commands/copy.c:2865 #, c-format msgid "COPY file signature not recognized" msgstr "formato del file COPY non riconosciuto" -#: commands/copy.c:2835 +#: commands/copy.c:2870 #, c-format msgid "invalid COPY file header (missing flags)" msgstr "intestazione del file COPY non valida (flag mancanti)" -#: commands/copy.c:2841 +#: commands/copy.c:2876 #, c-format msgid "unrecognized critical flags in COPY file header" msgstr "alcune flag critici non sono stati riconosciuti nell'intestazione del file COPY" -#: commands/copy.c:2847 +#: commands/copy.c:2882 #, c-format msgid "invalid COPY file header (missing length)" msgstr "intestazione del file COPY non valida (manca la lunghezza)" -#: commands/copy.c:2854 +#: commands/copy.c:2889 #, c-format msgid "invalid COPY file header (wrong length)" msgstr "intestazione del file COPY non valida (lunghezza errata)" -#: commands/copy.c:2987 commands/copy.c:3694 commands/copy.c:3924 +#: commands/copy.c:3022 commands/copy.c:3729 commands/copy.c:3959 #, c-format msgid "extra data after last expected column" msgstr "ci sono dati in eccesso dopo l'ultima colonna attesa" -#: commands/copy.c:2997 +#: commands/copy.c:3032 #, c-format msgid "missing data for OID column" msgstr "dati per la colonna OID mancanti" -#: commands/copy.c:3003 +#: commands/copy.c:3038 #, c-format msgid "null OID in COPY data" msgstr "OID nullo nei dati da COPY" -#: commands/copy.c:3013 commands/copy.c:3136 +#: commands/copy.c:3048 commands/copy.c:3171 #, c-format msgid "invalid OID in COPY data" msgstr "OID non valido nei dati da COPY" -#: commands/copy.c:3028 +#: commands/copy.c:3063 #, c-format msgid "missing data for column \"%s\"" msgstr "dati mancanti per la colonna \"%s\"" -#: commands/copy.c:3111 +#: commands/copy.c:3146 #, c-format msgid "received copy data after EOF marker" msgstr "dati da copiare ricevuti dopo il segnalatore di fine file" -#: commands/copy.c:3118 +#: commands/copy.c:3153 #, c-format msgid "row field count is %d, expected %d" msgstr "il numero di campi è %d, ne erano attesi %d" -#: commands/copy.c:3458 commands/copy.c:3475 +#: commands/copy.c:3493 commands/copy.c:3510 #, c-format msgid "literal carriage return found in data" msgstr "\"ritorno carrello\" trovato nei dati" -#: commands/copy.c:3459 commands/copy.c:3476 +#: commands/copy.c:3494 commands/copy.c:3511 #, c-format msgid "unquoted carriage return found in data" msgstr "\"ritorno carrello\" non quotato trovato nei dati" -#: commands/copy.c:3461 commands/copy.c:3478 +#: commands/copy.c:3496 commands/copy.c:3513 #, c-format msgid "Use \"\\r\" to represent carriage return." msgstr "Usa \"\\r\" per rappresentare i caratteri \"ritorno carrello\"." -#: commands/copy.c:3462 commands/copy.c:3479 +#: commands/copy.c:3497 commands/copy.c:3514 #, c-format msgid "Use quoted CSV field to represent carriage return." msgstr "Usa un campo CSV quotato per rappresentare i caratteri \"ritorno carrello\"." -#: commands/copy.c:3491 +#: commands/copy.c:3526 #, c-format msgid "literal newline found in data" msgstr "\"nuova riga\" letterale trovato nei dati" -#: commands/copy.c:3492 +#: commands/copy.c:3527 #, c-format msgid "unquoted newline found in data" msgstr "\"nuova riga\" non quotato trovato nei dati" -#: commands/copy.c:3494 +#: commands/copy.c:3529 #, c-format msgid "Use \"\\n\" to represent newline." msgstr "Usa \"\\n\" per rappresentare i caratteri \"nuova riga\"." -#: commands/copy.c:3495 +#: commands/copy.c:3530 #, c-format msgid "Use quoted CSV field to represent newline." msgstr "Usa un campo CSV quotato per rappresentare i caratteri \"nuova riga\"." -#: commands/copy.c:3541 commands/copy.c:3577 +#: commands/copy.c:3576 commands/copy.c:3612 #, c-format msgid "end-of-copy marker does not match previous newline style" msgstr "il marcatore di fine copia non combacia con il precedente stile \"nuova riga\"" -#: commands/copy.c:3550 commands/copy.c:3566 +#: commands/copy.c:3585 commands/copy.c:3601 #, c-format msgid "end-of-copy marker corrupt" msgstr "il marcatore di fine copia è corrotto" -#: commands/copy.c:4008 +#: commands/copy.c:4043 #, c-format msgid "unterminated CSV quoted field" msgstr "campo CSV tra virgolette non terminato" -#: commands/copy.c:4085 commands/copy.c:4104 +#: commands/copy.c:4120 commands/copy.c:4139 #, c-format msgid "unexpected EOF in COPY data" msgstr "fine file inattesa dei dati da COPY" -#: commands/copy.c:4094 +#: commands/copy.c:4129 #, c-format msgid "invalid field size" msgstr "dimensione del campo non valida" -#: commands/copy.c:4117 +#: commands/copy.c:4152 #, c-format msgid "incorrect binary data format" msgstr "formato di dati binari non corretto" -#: commands/copy.c:4428 commands/indexcmds.c:1053 commands/tablecmds.c:1463 -#: commands/tablecmds.c:2290 parser/parse_relation.c:3084 -#: parser/parse_relation.c:3104 utils/adt/tsvector_op.c:2222 +#: commands/copy.c:4463 commands/indexcmds.c:1053 commands/tablecmds.c:1464 +#: commands/tablecmds.c:2291 parser/parse_relation.c:3177 +#: parser/parse_relation.c:3197 utils/adt/tsvector_op.c:2559 #, c-format msgid "column \"%s\" does not exist" msgstr "la colonna \"%s\" non esiste" -#: commands/copy.c:4435 commands/tablecmds.c:1489 commands/trigger.c:651 -#: parser/parse_target.c:956 parser/parse_target.c:967 +#: commands/copy.c:4470 commands/tablecmds.c:1490 commands/trigger.c:651 +#: parser/parse_target.c:967 parser/parse_target.c:978 #, c-format msgid "column \"%s\" specified more than once" msgstr "la colonna \"%s\" è stata specificata più di una volta" -#: commands/createas.c:383 +#: commands/createas.c:213 commands/createas.c:509 #, c-format msgid "too many column names were specified" msgstr "troppi nomi di colonne specificati" -#: commands/createas.c:452 +#: commands/createas.c:550 #, c-format msgid "policies not yet implemented for this command" msgstr "regole di sicurezza non ancora implementate per questo comando" @@ -6035,7 +6030,7 @@ msgstr "Occorre spostarle di nuovo nel tablespace di default del database prima #: commands/dbcommands.c:1325 commands/dbcommands.c:1868 #: commands/dbcommands.c:2072 commands/dbcommands.c:2120 -#: commands/tablespace.c:610 +#: commands/tablespace.c:606 #, c-format msgid "some useless files may be left behind in old database directory \"%s\"" msgstr "alcuni file inutili possono essere stati lasciati nella vecchia directory del database \"%s\"" @@ -6112,7 +6107,7 @@ msgid "invalid argument for %s: \"%s\"" msgstr "argomento non valido per %s: \"%s\"" #: commands/dropcmds.c:112 commands/functioncmds.c:1203 -#: utils/adt/ruleutils.c:1957 +#: utils/adt/ruleutils.c:2080 #, c-format msgid "\"%s\" is an aggregate function" msgstr "\"%s\" è una funzione di aggregazione" @@ -6122,124 +6117,129 @@ msgstr "\"%s\" è una funzione di aggregazione" msgid "Use DROP AGGREGATE to drop aggregate functions." msgstr "Usa DROP AGGREGATE per rimuovere le funzioni di aggregazione." -#: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2377 -#: commands/tablecmds.c:2528 commands/tablecmds.c:2570 -#: commands/tablecmds.c:11379 tcop/utility.c:1119 +#: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2378 +#: commands/tablecmds.c:2529 commands/tablecmds.c:2571 +#: commands/tablecmds.c:11524 tcop/utility.c:1119 #, c-format msgid "relation \"%s\" does not exist, skipping" msgstr "la relazione \"%s\" non esiste, saltata" -#: commands/dropcmds.c:195 commands/dropcmds.c:292 commands/tablecmds.c:745 +#: commands/dropcmds.c:195 commands/dropcmds.c:296 commands/tablecmds.c:746 #, c-format msgid "schema \"%s\" does not exist, skipping" msgstr "lo schema \"%s\" non esiste, saltato" -#: commands/dropcmds.c:237 commands/dropcmds.c:272 commands/tablecmds.c:246 +#: commands/dropcmds.c:237 commands/dropcmds.c:276 commands/tablecmds.c:247 #, c-format msgid "type \"%s\" does not exist, skipping" msgstr "il tipo \"%s\" non esiste, saltato" -#: commands/dropcmds.c:280 +#: commands/dropcmds.c:266 +#, c-format +msgid "access method \"%s\" does not exist, skipping" +msgstr "il metodo di accesso \"%s\" non esiste, saltato" + +#: commands/dropcmds.c:284 #, c-format msgid "collation \"%s\" does not exist, skipping" msgstr "l'ordinamento \"%s\" non esiste, saltato" -#: commands/dropcmds.c:287 +#: commands/dropcmds.c:291 #, c-format msgid "conversion \"%s\" does not exist, skipping" msgstr "la conversione \"%s\" non esiste, saltata" -#: commands/dropcmds.c:298 +#: commands/dropcmds.c:302 #, c-format msgid "text search parser \"%s\" does not exist, skipping" msgstr "l'analizzatore di ricerca di testo \"%s\" non esiste, saltato" -#: commands/dropcmds.c:305 +#: commands/dropcmds.c:309 #, c-format msgid "text search dictionary \"%s\" does not exist, skipping" msgstr "il dizionario di ricerca di testo \"%s\" non esiste, saltato" -#: commands/dropcmds.c:312 +#: commands/dropcmds.c:316 #, c-format msgid "text search template \"%s\" does not exist, skipping" msgstr "il modello di ricerca di testo \"%s\" non esiste, saltato" -#: commands/dropcmds.c:319 +#: commands/dropcmds.c:323 #, c-format msgid "text search configuration \"%s\" does not exist, skipping" msgstr "la combinazione di ricerca di testo \"%s\" non esiste, saltato" -#: commands/dropcmds.c:324 +#: commands/dropcmds.c:328 #, c-format msgid "extension \"%s\" does not exist, skipping" msgstr "l'estensione \"%s\" non esiste, saltata" -#: commands/dropcmds.c:331 +#: commands/dropcmds.c:335 #, c-format msgid "function %s(%s) does not exist, skipping" msgstr "la funzione %s(%s) non esiste, saltata" -#: commands/dropcmds.c:340 +#: commands/dropcmds.c:344 #, c-format msgid "aggregate %s(%s) does not exist, skipping" msgstr "la funzione di aggregazione %s(%s) non esiste, saltato" -#: commands/dropcmds.c:349 +#: commands/dropcmds.c:353 #, c-format msgid "operator %s does not exist, skipping" msgstr "l'operatore %s non esiste, saltato" -#: commands/dropcmds.c:354 +#: commands/dropcmds.c:358 #, c-format msgid "language \"%s\" does not exist, skipping" msgstr "il linguaggio \"%s\" non esiste, saltato" -#: commands/dropcmds.c:363 +#: commands/dropcmds.c:367 #, c-format msgid "cast from type %s to type %s does not exist, skipping" msgstr "la conversione dal tipo %s al tipo %s non esiste, saltata" -#: commands/dropcmds.c:372 +#: commands/dropcmds.c:376 #, c-format msgid "transform for type %s language \"%s\" does not exist, skipping" msgstr "la trasformazione per il tipo %s linguaggio \"%s\" non esiste, saltata" -#: commands/dropcmds.c:380 +#: commands/dropcmds.c:384 #, c-format msgid "trigger \"%s\" for relation \"%s\" does not exist, skipping" msgstr "il trigger \"%s\" per la relazione \"%s\" non esiste, saltato" -#: commands/dropcmds.c:389 +#: commands/dropcmds.c:393 #, c-format msgid "policy \"%s\" for relation \"%s\" does not exist, skipping" msgstr "la regola di sicurezza \"%s\" per la relazione \"%s\" non esiste, saltata" -#: commands/dropcmds.c:396 +#: commands/dropcmds.c:400 #, c-format msgid "event trigger \"%s\" does not exist, skipping" msgstr "il trigger di evento \"%s\" non esiste, saltato" -#: commands/dropcmds.c:402 +#: commands/dropcmds.c:406 #, c-format msgid "rule \"%s\" for relation \"%s\" does not exist, skipping" msgstr "la regola \"%s\" per la relazione \"%s\" non esiste, saltata" -#: commands/dropcmds.c:409 +#: commands/dropcmds.c:413 #, c-format msgid "foreign-data wrapper \"%s\" does not exist, skipping" msgstr "il wrapper di dati remoti \"%s\" non esiste, saltato" -#: commands/dropcmds.c:413 +#: commands/dropcmds.c:417 #, c-format msgid "server \"%s\" does not exist, skipping" msgstr "il server \"%s\" non esiste, saltato" -#: commands/dropcmds.c:422 +#: commands/dropcmds.c:426 #, c-format msgid "operator class \"%s\" does not exist for access method \"%s\", skipping" msgstr "la classe di operatori \"%s\" non esiste per il metodo di accesso \"%s\", saltata" -#: commands/dropcmds.c:434 +#: commands/dropcmds.c:438 #, c-format msgid "operator family \"%s\" does not exist for access method \"%s\", skipping" msgstr "la famiglia di operatori \"%s\" non esiste per il metodo di accesso \"%s\", saltata" @@ -6296,264 +6296,264 @@ msgstr "permesso di cambiare il proprietario del trigger di evento \"%s\" negato msgid "The owner of an event trigger must be a superuser." msgstr "Il proprietario di un trigger di evento deve essere un superutente." -#: commands/event_trigger.c:1442 +#: commands/event_trigger.c:1438 #, c-format msgid "%s can only be called in a sql_drop event trigger function" msgstr "%s può essere chiamata solo in una funzione trigger di evento sql_drop" -#: commands/event_trigger.c:1562 commands/event_trigger.c:1583 +#: commands/event_trigger.c:1558 commands/event_trigger.c:1579 #, c-format msgid "%s can only be called in a table_rewrite event trigger function" msgstr "%s può essere chiamata solo in una funzione trigger di evento table_rewrite" -#: commands/event_trigger.c:1993 +#: commands/event_trigger.c:1989 #, c-format msgid "%s can only be called in an event trigger function" msgstr "%s può essere chiamata solo in una funzione trigger di evento" -#: commands/explain.c:184 +#: commands/explain.c:185 #, c-format msgid "unrecognized value for EXPLAIN option \"%s\": \"%s\"" msgstr "valore sconosciuto per l'opzione di EXPLAIN \"%s\": \"%s\"" -#: commands/explain.c:190 +#: commands/explain.c:191 #, c-format msgid "unrecognized EXPLAIN option \"%s\"" msgstr "opzione di EXPLAIN non riconosciuta \"%s\"" -#: commands/explain.c:197 +#: commands/explain.c:198 #, c-format msgid "EXPLAIN option BUFFERS requires ANALYZE" msgstr "l'opzione BUFFERS di EXPLAIN richiede ANALYZE" -#: commands/explain.c:206 +#: commands/explain.c:207 #, c-format msgid "EXPLAIN option TIMING requires ANALYZE" msgstr "l'opzione TIMING di EXPLAIN richiede ANALYZE" -#: commands/extension.c:154 commands/extension.c:2718 +#: commands/extension.c:155 commands/extension.c:2719 #, c-format msgid "extension \"%s\" does not exist" msgstr "l'estensione \"%s\" non esiste" -#: commands/extension.c:253 commands/extension.c:262 commands/extension.c:274 -#: commands/extension.c:284 +#: commands/extension.c:254 commands/extension.c:263 commands/extension.c:275 +#: commands/extension.c:285 #, c-format msgid "invalid extension name: \"%s\"" msgstr "nome di estensione non valido: \"%s\"" -#: commands/extension.c:254 +#: commands/extension.c:255 #, c-format msgid "Extension names must not be empty." msgstr "I nomi delle estensioni non possono essere vuoti." -#: commands/extension.c:263 +#: commands/extension.c:264 #, c-format msgid "Extension names must not contain \"--\"." msgstr "I nomi delle estensioni non possono contenere \"--\"." -#: commands/extension.c:275 +#: commands/extension.c:276 #, c-format msgid "Extension names must not begin or end with \"-\"." msgstr "I nomi delle estensioni non possono iniziare o finire con \"-\"." -#: commands/extension.c:285 +#: commands/extension.c:286 #, c-format msgid "Extension names must not contain directory separator characters." msgstr "I nomi delle estensioni non possono contenere caratteri separatore directory." -#: commands/extension.c:300 commands/extension.c:309 commands/extension.c:318 -#: commands/extension.c:328 +#: commands/extension.c:301 commands/extension.c:310 commands/extension.c:319 +#: commands/extension.c:329 #, c-format msgid "invalid extension version name: \"%s\"" msgstr "nome di versione dell'estensione non valido: \"%s\"" -#: commands/extension.c:301 +#: commands/extension.c:302 #, c-format msgid "Version names must not be empty." msgstr "I nomi di versione non possono essere vuoti." -#: commands/extension.c:310 +#: commands/extension.c:311 #, c-format msgid "Version names must not contain \"--\"." msgstr "I nomi di versione non possono contenere \"--\"." -#: commands/extension.c:319 +#: commands/extension.c:320 #, c-format msgid "Version names must not begin or end with \"-\"." msgstr "I nomi di versione non possono iniziare o finire con \"-\"." -#: commands/extension.c:329 +#: commands/extension.c:330 #, c-format msgid "Version names must not contain directory separator characters." msgstr "I nomi di versione non possono contenere caratteri separatore directory." -#: commands/extension.c:479 +#: commands/extension.c:480 #, c-format msgid "could not open extension control file \"%s\": %m" msgstr "apertura del file di controllo dell'estensione \"%s\" fallita: %m" -#: commands/extension.c:501 commands/extension.c:511 +#: commands/extension.c:502 commands/extension.c:512 #, c-format msgid "parameter \"%s\" cannot be set in a secondary extension control file" msgstr "il parametro \"%s\" non può essere impostato in un file di controllo secondario di estensione" -#: commands/extension.c:550 +#: commands/extension.c:551 #, c-format msgid "\"%s\" is not a valid encoding name" msgstr "\"%s\" non è un nome di codifica valido" -#: commands/extension.c:564 +#: commands/extension.c:565 #, c-format msgid "parameter \"%s\" must be a list of extension names" msgstr "il parametro \"%s\" dev'essere una lista di nomi di estensioni" -#: commands/extension.c:571 +#: commands/extension.c:572 #, c-format msgid "unrecognized parameter \"%s\" in file \"%s\"" msgstr "parametro sconosciuto \"%s\" nel file \"%s\"" -#: commands/extension.c:580 +#: commands/extension.c:581 #, c-format msgid "parameter \"schema\" cannot be specified when \"relocatable\" is true" msgstr "il parametro \"schema\" non può essere specificato quando \"relocatable\" è abilitato" -#: commands/extension.c:721 +#: commands/extension.c:722 #, c-format msgid "transaction control statements are not allowed within an extension script" msgstr "le istruzioni di controllo di transazione non sono valide in uno script di estensione" -#: commands/extension.c:789 +#: commands/extension.c:790 #, c-format msgid "permission denied to create extension \"%s\"" msgstr "permesso di creare l'estensione \"%s\" negato" -#: commands/extension.c:791 +#: commands/extension.c:792 #, c-format msgid "Must be superuser to create this extension." msgstr "Solo un superutente può creare questa estensione." -#: commands/extension.c:795 +#: commands/extension.c:796 #, c-format msgid "permission denied to update extension \"%s\"" msgstr "permesso di modificare l'estensione \"%s\" negato" -#: commands/extension.c:797 +#: commands/extension.c:798 #, c-format msgid "Must be superuser to update this extension." msgstr "Solo un superutente può modificare questa estensione." -#: commands/extension.c:1079 +#: commands/extension.c:1080 #, c-format msgid "extension \"%s\" has no update path from version \"%s\" to version \"%s\"" msgstr "l'estensione \"%s\" non ha un percorso di aggiornamento dalla versione \"%s\" alla versione \"%s\"" -#: commands/extension.c:1261 commands/extension.c:2778 +#: commands/extension.c:1262 commands/extension.c:2779 #, c-format msgid "version to install must be specified" msgstr "il nome di versione da installare deve essere specificato" -#: commands/extension.c:1278 +#: commands/extension.c:1279 #, c-format msgid "FROM version must be different from installation target version \"%s\"" msgstr "la versione FROM dev'essere diversa dalla versione \"%s\" oggetto dell'installazione" -#: commands/extension.c:1343 +#: commands/extension.c:1344 #, c-format msgid "extension \"%s\" must be installed in schema \"%s\"" msgstr "l'estensione \"%s\" dev'essere installata nello schema \"%s\"" -#: commands/extension.c:1435 +#: commands/extension.c:1436 #, c-format msgid "cyclic dependency detected between extensions \"%s\" and \"%s\"" msgstr "individuata una dipendenza ciclica tra le estensioni \"%s\" e \"%s\"" -#: commands/extension.c:1440 +#: commands/extension.c:1441 #, c-format msgid "installing required extension \"%s\"" msgstr "installazione dell'estensione richiesta \"%s\"" -#: commands/extension.c:1468 commands/extension.c:2923 +#: commands/extension.c:1469 commands/extension.c:2924 #, c-format msgid "required extension \"%s\" is not installed" msgstr "l'estensione richiesta \"%s\" non è installata" -#: commands/extension.c:1470 +#: commands/extension.c:1471 #, c-format -msgid "Use CREATE EXTENSION CASCADE to install required extensions too." -msgstr "Usa CREATE EXTENSION CASCADE per installare anche le estensioni richieste." +msgid "Use CREATE EXTENSION ... CASCADE to install required extensions too." +msgstr "Usa CREATE EXTENSION ... CASCADE per installare anche le estensioni richieste." -#: commands/extension.c:1534 +#: commands/extension.c:1535 #, c-format msgid "extension \"%s\" already exists, skipping" msgstr "l'estensione \"%s\" esiste già, saltata" -#: commands/extension.c:1541 +#: commands/extension.c:1542 #, c-format msgid "extension \"%s\" already exists" msgstr "l'estensione \"%s\" esiste già" -#: commands/extension.c:1552 +#: commands/extension.c:1553 #, c-format msgid "nested CREATE EXTENSION is not supported" msgstr "CREATE EXTENSION annidati non sono supportati" -#: commands/extension.c:1680 +#: commands/extension.c:1681 #, c-format msgid "cannot drop extension \"%s\" because it is being modified" msgstr "non è possibile eliminare l'estensione \"%s\" perché sta venendo modificata" -#: commands/extension.c:2151 +#: commands/extension.c:2152 #, c-format msgid "pg_extension_config_dump() can only be called from an SQL script executed by CREATE EXTENSION" msgstr "pg_extension_config_dump() può essere richiamata solo da uno script SQL eseguito da CREATE EXTENSION" -#: commands/extension.c:2163 +#: commands/extension.c:2164 #, c-format msgid "OID %u does not refer to a table" msgstr "l'OID %u non si riferisce ad una tabella" -#: commands/extension.c:2168 +#: commands/extension.c:2169 #, c-format msgid "table \"%s\" is not a member of the extension being created" msgstr "la tabella \"%s\" non è membra dell'estensione in fase di creazione" -#: commands/extension.c:2533 +#: commands/extension.c:2534 #, c-format msgid "cannot move extension \"%s\" into schema \"%s\" because the extension contains the schema" msgstr "non è possibile spostare l'estensione \"%s\" nello schema \"%s\" perché l'estensione contiene lo schema" -#: commands/extension.c:2573 commands/extension.c:2636 +#: commands/extension.c:2574 commands/extension.c:2637 #, c-format msgid "extension \"%s\" does not support SET SCHEMA" msgstr "l'estensione \"%s\" non supporta SET SCHEMA" -#: commands/extension.c:2638 +#: commands/extension.c:2639 #, c-format msgid "%s is not in the extension's schema \"%s\"" msgstr "%s non è nello schema dell'estensione \"%s\"" -#: commands/extension.c:2698 +#: commands/extension.c:2699 #, c-format msgid "nested ALTER EXTENSION is not supported" msgstr "ALTER EXTENSION annidati non sono supportati" -#: commands/extension.c:2789 +#: commands/extension.c:2790 #, c-format msgid "version \"%s\" of extension \"%s\" is already installed" msgstr "la versione \"%s\" dell'estensione \"%s\" è già installata" -#: commands/extension.c:3040 +#: commands/extension.c:3041 #, c-format msgid "cannot add schema \"%s\" to extension \"%s\" because the schema contains the extension" msgstr "non è possibile aggiungere lo schema \"%s\" all'estensione \"%s\" perché lo schema contiene l'estensione" -#: commands/extension.c:3058 +#: commands/extension.c:3069 #, c-format msgid "%s is not a member of extension \"%s\"" msgstr "%s non fa parte dell'estensione \"%s\"" -#: commands/extension.c:3114 +#: commands/extension.c:3135 #, c-format msgid "file \"%s\" is too large" msgstr "il file \"%s\" è troppo grande" @@ -6583,7 +6583,7 @@ msgstr "Solo un superutente può cambiare proprietario di un wrapper di dati est msgid "The owner of a foreign-data wrapper must be a superuser." msgstr "Il proprietario di un wrapper di dati esterni dev'essere un superutente." -#: commands/foreigncmds.c:292 commands/foreigncmds.c:709 foreign/foreign.c:777 +#: commands/foreigncmds.c:292 commands/foreigncmds.c:709 foreign/foreign.c:671 #, c-format msgid "foreign-data wrapper \"%s\" does not exist" msgstr "il wrapper di dati esterni \"%s\" non esiste" @@ -6618,37 +6618,37 @@ msgstr "cambiare il gestore del wrapper di dati esterni può cambiare il comport msgid "changing the foreign-data wrapper validator can cause the options for dependent objects to become invalid" msgstr "cambiare il validatore del wrapper di dati esterni può rendere non valide le opzioni degli oggetti dipendenti" -#: commands/foreigncmds.c:1169 +#: commands/foreigncmds.c:1165 #, c-format msgid "user mapping \"%s\" already exists for server %s" msgstr "la mappatura utenti \"%s\" esiste già per il server %s" -#: commands/foreigncmds.c:1267 commands/foreigncmds.c:1388 +#: commands/foreigncmds.c:1259 commands/foreigncmds.c:1375 #, c-format msgid "user mapping \"%s\" does not exist for the server" msgstr "la mappatura utenti \"%s\" non esiste per il server" -#: commands/foreigncmds.c:1375 +#: commands/foreigncmds.c:1362 #, c-format msgid "server does not exist, skipping" msgstr "il server non esiste, saltato" -#: commands/foreigncmds.c:1393 +#: commands/foreigncmds.c:1380 #, c-format msgid "user mapping \"%s\" does not exist for the server, skipping" msgstr "la mappatura utenti \"%s\" non esiste per il server, saltata" -#: commands/foreigncmds.c:1545 foreign/foreign.c:467 +#: commands/foreigncmds.c:1532 foreign/foreign.c:361 #, c-format msgid "foreign-data wrapper \"%s\" has no handler" msgstr "il wrapper di dati remoti \"%s\" non ha un handler" -#: commands/foreigncmds.c:1551 +#: commands/foreigncmds.c:1538 #, c-format msgid "foreign-data wrapper \"%s\" does not support IMPORT FOREIGN SCHEMA" msgstr "il wrapper di dati remoti \"%s\" non supporta IMPORT FOREIGN SCHEMA" -#: commands/foreigncmds.c:1644 +#: commands/foreigncmds.c:1631 #, c-format msgid "importing foreign table \"%s\"" msgstr "importazione della tabella remota \"%s\"" @@ -7004,7 +7004,7 @@ msgstr "non è possibile creare indici sulla tabella esterna \"%s\"" msgid "cannot create indexes on temporary tables of other sessions" msgstr "non è possibile creare indici su tabelle temporanee di altre sessioni" -#: commands/indexcmds.c:454 commands/tablecmds.c:545 commands/tablecmds.c:9599 +#: commands/indexcmds.c:454 commands/tablecmds.c:546 commands/tablecmds.c:9694 #, c-format msgid "only shared relations can be placed in pg_global tablespace" msgstr "solo le relazioni condivise possono essere poste nel tablespace pg_global" @@ -7049,7 +7049,7 @@ msgstr "%s %s creerà un indice implicito \"%s\" per la tabella \"%s\"" msgid "functions in index predicate must be marked IMMUTABLE" msgstr "le funzioni nel predicato dell'indice devono essere marcate IMMUTABLE" -#: commands/indexcmds.c:1048 parser/parse_utilcmd.c:1894 +#: commands/indexcmds.c:1048 parser/parse_utilcmd.c:1881 #, c-format msgid "column \"%s\" named in key does not exist" msgstr "la colonna \"%s\" nominata nella chiave non esiste" @@ -7064,8 +7064,8 @@ msgstr "le funzioni nell'espressione dell'indice devono essere marcate IMMUTABLE msgid "could not determine which collation to use for index expression" msgstr "non è stato possibile determinare quale ordinamento usare per l'espressione dell'indice" -#: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2559 -#: parser/parse_type.c:550 parser/parse_utilcmd.c:2820 utils/adt/misc.c:666 +#: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2608 +#: parser/parse_type.c:550 parser/parse_utilcmd.c:2807 utils/adt/misc.c:666 #, c-format msgid "collations are not supported by type %s" msgstr "gli ordinamenti non sono supportati dal tipo %s" @@ -7136,7 +7136,7 @@ msgstr "la tabella \"%s\" non ha indici" msgid "can only reindex the currently open database" msgstr "è possibile reindicizzare solo il database corrente" -#: commands/indexcmds.c:1994 +#: commands/indexcmds.c:1992 #, c-format msgid "table \"%s.%s\" was reindexed" msgstr "la tabella \"%s.%s\" è stata reindicizzata" @@ -7151,22 +7151,22 @@ msgstr "non si può usare CONCURRENTLY quando la vista materializzata non è pop msgid "CONCURRENTLY and WITH NO DATA options cannot be used together" msgstr "le opzioni CONCURRENTLY e WITH NO DATA non possono essere usate insieme" -#: commands/matview.c:258 +#: commands/matview.c:257 #, c-format msgid "cannot refresh materialized view \"%s\" concurrently" msgstr "non è possibile aggiornare la vista materializzata \"%s\" concorrentemente" -#: commands/matview.c:261 +#: commands/matview.c:260 #, c-format msgid "Create a unique index with no WHERE clause on one or more columns of the materialized view." msgstr "Crea un indice unico senza clausola WHERE su una o più colonna della vista materializzata." -#: commands/matview.c:656 +#: commands/matview.c:657 #, c-format msgid "new data for materialized view \"%s\" contains duplicate rows without any null columns" msgstr "i nuovi dati per la vista materializzata \"%s\" contengono righe duplicate senza alcuna colonna null" -#: commands/matview.c:658 +#: commands/matview.c:659 #, c-format msgid "Row: %s" msgstr "Riga: %s" @@ -7370,15 +7370,14 @@ msgstr "la funzione di stima del join %s deve restituire il tipo %s" #: commands/operatorcmds.c:451 #, c-format -msgid "operator attribute \"%s\" can not be changed" +msgid "operator attribute \"%s\" cannot be changed" msgstr "l'attributo dell'operatore \"%s\" non può essere cambiato" -#: commands/policy.c:87 commands/policy.c:395 commands/policy.c:484 -#: commands/tablecmds.c:970 commands/tablecmds.c:1312 -#: commands/tablecmds.c:2184 commands/tablecmds.c:4330 -#: commands/tablecmds.c:6281 commands/tablecmds.c:11935 -#: commands/tablecmds.c:11970 commands/trigger.c:241 commands/trigger.c:1125 -#: commands/trigger.c:1233 rewrite/rewriteDefine.c:273 +#: commands/policy.c:87 commands/policy.c:388 commands/policy.c:477 +#: commands/tablecmds.c:971 commands/tablecmds.c:1313 commands/tablecmds.c:2185 +#: commands/tablecmds.c:4329 commands/tablecmds.c:6280 +#: commands/tablecmds.c:12080 commands/tablecmds.c:12115 commands/trigger.c:241 +#: commands/trigger.c:1125 commands/trigger.c:1233 rewrite/rewriteDefine.c:273 #: rewrite/rewriteDefine.c:917 #, c-format msgid "permission denied: \"%s\" is a system catalog" @@ -7394,44 +7393,43 @@ msgstr "i ruoli specificati a parte PUBLIC verranno ignorati" msgid "All roles are members of the PUBLIC role." msgstr "TuttiTutti i ruoli sono membri del ruolo PUBLIC." -#: commands/policy.c:508 +#: commands/policy.c:501 #, c-format msgid "role \"%s\" could not be removed from policy \"%s\" on \"%s\"" msgstr "non è stato possibile rimuovere il ruolo \"%s\" dalla regola di sicurezza \"%s\" su \"%s\"" -#: commands/policy.c:717 +#: commands/policy.c:710 #, c-format msgid "WITH CHECK cannot be applied to SELECT or DELETE" msgstr "WITH CHECK non può essere applicato a SELECT o a DELETE" -#: commands/policy.c:726 commands/policy.c:1026 +#: commands/policy.c:719 commands/policy.c:1019 #, c-format msgid "only WITH CHECK expression allowed for INSERT" msgstr "solo le espressioni WITH CHECK sono consentite per INSERT" -#: commands/policy.c:799 commands/policy.c:1249 +#: commands/policy.c:792 commands/policy.c:1242 #, c-format msgid "policy \"%s\" for table \"%s\" already exists" msgstr "la regola di sicurezza \"%s\" per la tabella \"%s\" esiste già" -#: commands/policy.c:998 commands/policy.c:1277 commands/policy.c:1352 +#: commands/policy.c:991 commands/policy.c:1270 commands/policy.c:1345 #, c-format msgid "policy \"%s\" for table \"%s\" does not exist" msgstr "la regola di sicurezza \"%s\" per la tabella \"%s\" non esiste" -#: commands/policy.c:1016 +#: commands/policy.c:1009 #, c-format msgid "only USING expression allowed for SELECT, DELETE" msgstr "solo le espressioni USING sono permesse per SELECT e DELETE" -#: commands/portalcmds.c:61 commands/portalcmds.c:160 -#: commands/portalcmds.c:212 +#: commands/portalcmds.c:61 commands/portalcmds.c:160 commands/portalcmds.c:212 #, c-format msgid "invalid cursor name: must not be empty" msgstr "nome di cursore non valido: non deve essere vuoto" #: commands/portalcmds.c:168 commands/portalcmds.c:222 -#: executor/execCurrent.c:67 utils/adt/xml.c:2391 utils/adt/xml.c:2558 +#: executor/execCurrent.c:67 utils/adt/xml.c:2389 utils/adt/xml.c:2556 #, c-format msgid "cursor \"%s\" does not exist" msgstr "il cursore \"%s\" non esiste" @@ -7441,7 +7439,7 @@ msgstr "il cursore \"%s\" non esiste" msgid "invalid statement name: must not be empty" msgstr "nome di istruzione non valido: non deve essere vuoto" -#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1345 +#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1343 #, c-format msgid "could not determine data type of parameter $%d" msgstr "non è stato possibile determinare il tipo di dato del parametro $%d" @@ -7511,17 +7509,17 @@ msgstr "solo i superutenti possono creare un linguaggio procedurale personalizza msgid "changing return type of function %s from \"opaque\" to \"language_handler\"" msgstr "cambio del tipo restituito dalla funzione %s da \"opaque\" a \"language_handler\"" -#: commands/schemacmds.c:103 commands/schemacmds.c:266 +#: commands/schemacmds.c:99 commands/schemacmds.c:262 #, c-format msgid "unacceptable schema name \"%s\"" msgstr "nome dello schema \"%s\" non accettabile" -#: commands/schemacmds.c:104 commands/schemacmds.c:267 +#: commands/schemacmds.c:100 commands/schemacmds.c:263 #, c-format msgid "The prefix \"pg_\" is reserved for system schemas." msgstr "Il prefisso \"pg_\" è riservato agli schemi di sistema." -#: commands/schemacmds.c:118 +#: commands/schemacmds.c:114 #, c-format msgid "schema \"%s\" already exists, skipping" msgstr "lo schema \"%s\" esiste già, saltato" @@ -7631,162 +7629,162 @@ msgstr "la sequenza deve avere lo stesso proprietario della tabella a cui è col msgid "sequence must be in same schema as table it is linked to" msgstr "la sequenza deve essere nello stesso schema della tabella a cui è collegata" -#: commands/tablecmds.c:215 +#: commands/tablecmds.c:216 #, c-format msgid "table \"%s\" does not exist" msgstr "la tabella \"%s\" non esiste" -#: commands/tablecmds.c:216 +#: commands/tablecmds.c:217 #, c-format msgid "table \"%s\" does not exist, skipping" msgstr "la tabella \"%s\" non esiste, saltata" -#: commands/tablecmds.c:218 +#: commands/tablecmds.c:219 msgid "Use DROP TABLE to remove a table." msgstr "Usa DROP TABLE per eliminare una tabella." -#: commands/tablecmds.c:221 +#: commands/tablecmds.c:222 #, c-format msgid "sequence \"%s\" does not exist" msgstr "la sequenza \"%s\" non esiste" -#: commands/tablecmds.c:222 +#: commands/tablecmds.c:223 #, c-format msgid "sequence \"%s\" does not exist, skipping" msgstr "la sequenza \"%s\" non esiste, saltata" -#: commands/tablecmds.c:224 +#: commands/tablecmds.c:225 msgid "Use DROP SEQUENCE to remove a sequence." msgstr "Usa DROP SEQUENCE per eliminare una sequenza." -#: commands/tablecmds.c:227 +#: commands/tablecmds.c:228 #, c-format msgid "view \"%s\" does not exist" msgstr "la vista \"%s\" non esiste" -#: commands/tablecmds.c:228 +#: commands/tablecmds.c:229 #, c-format msgid "view \"%s\" does not exist, skipping" msgstr "la vista \"%s\" non esiste, saltata" -#: commands/tablecmds.c:230 +#: commands/tablecmds.c:231 msgid "Use DROP VIEW to remove a view." msgstr "Usa DROP VIEW per eliminare una vista." -#: commands/tablecmds.c:233 +#: commands/tablecmds.c:234 #, c-format msgid "materialized view \"%s\" does not exist" msgstr "la vista materializzata \"%s\" non esiste" -#: commands/tablecmds.c:234 +#: commands/tablecmds.c:235 #, c-format msgid "materialized view \"%s\" does not exist, skipping" msgstr "la vista materializzata \"%s\" non esiste, saltata" -#: commands/tablecmds.c:236 +#: commands/tablecmds.c:237 msgid "Use DROP MATERIALIZED VIEW to remove a materialized view." msgstr "Usa DROP MATERIALIZED VIEW per rimuovere una vista materializzata." -#: commands/tablecmds.c:239 parser/parse_utilcmd.c:1643 +#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1630 #, c-format msgid "index \"%s\" does not exist" msgstr "l'indice \"%s\" non esiste" -#: commands/tablecmds.c:240 +#: commands/tablecmds.c:241 #, c-format msgid "index \"%s\" does not exist, skipping" msgstr "l'indice \"%s\" non esiste, saltato" -#: commands/tablecmds.c:242 +#: commands/tablecmds.c:243 msgid "Use DROP INDEX to remove an index." msgstr "Usa DROP INDEX per eliminare un indice." -#: commands/tablecmds.c:247 +#: commands/tablecmds.c:248 #, c-format msgid "\"%s\" is not a type" msgstr "\"%s\" non è un tipo" -#: commands/tablecmds.c:248 +#: commands/tablecmds.c:249 msgid "Use DROP TYPE to remove a type." msgstr "Usa DROP TYPE per eliminare un tipo." -#: commands/tablecmds.c:251 commands/tablecmds.c:8488 -#: commands/tablecmds.c:11196 +#: commands/tablecmds.c:252 commands/tablecmds.c:8583 +#: commands/tablecmds.c:11335 #, c-format msgid "foreign table \"%s\" does not exist" msgstr "la tabella esterna \"%s\" non esiste" -#: commands/tablecmds.c:252 +#: commands/tablecmds.c:253 #, c-format msgid "foreign table \"%s\" does not exist, skipping" msgstr "la tabella esterna \"%s\" non esiste, saltata" -#: commands/tablecmds.c:254 +#: commands/tablecmds.c:255 msgid "Use DROP FOREIGN TABLE to remove a foreign table." msgstr "Usa DROP FOREIGN TABLE per eliminare una tabella esterna." -#: commands/tablecmds.c:493 +#: commands/tablecmds.c:494 #, c-format msgid "ON COMMIT can only be used on temporary tables" msgstr "ON COMMIT può essere usato solo con le tabelle temporanee" -#: commands/tablecmds.c:513 +#: commands/tablecmds.c:514 #, c-format msgid "cannot create temporary table within security-restricted operation" msgstr "non è possibile creare la tabella temporanea nell'ambito di operazioni a sicurezza ristretta" -#: commands/tablecmds.c:821 +#: commands/tablecmds.c:822 #, c-format msgid "DROP INDEX CONCURRENTLY does not support dropping multiple objects" msgstr "DROP INDEX CONCURRENTLY non supporta l'eliminazione di più di un oggetto" -#: commands/tablecmds.c:825 +#: commands/tablecmds.c:826 #, c-format msgid "DROP INDEX CONCURRENTLY does not support CASCADE" msgstr "DROP INDEX CONCURRENTLY non supporta CASCADE" -#: commands/tablecmds.c:1084 +#: commands/tablecmds.c:1085 #, c-format msgid "truncate cascades to table \"%s\"" msgstr "truncate si propaga in cascata alla tabella \"%s\"" -#: commands/tablecmds.c:1322 +#: commands/tablecmds.c:1323 #, c-format msgid "cannot truncate temporary tables of other sessions" msgstr "non è possibile troncare tabelle temporanee di altre sessioni" -#: commands/tablecmds.c:1528 parser/parse_utilcmd.c:1857 +#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1844 #, c-format msgid "inherited relation \"%s\" is not a table or foreign table" msgstr "la relazione ereditata \"%s\" non è una tabella o tabella esterna" -#: commands/tablecmds.c:1535 commands/tablecmds.c:10055 +#: commands/tablecmds.c:1536 commands/tablecmds.c:10150 #, c-format msgid "cannot inherit from temporary relation \"%s\"" msgstr "non è possibile ereditare dalla relazione temporanea \"%s\"" -#: commands/tablecmds.c:1543 commands/tablecmds.c:10063 +#: commands/tablecmds.c:1544 commands/tablecmds.c:10158 #, c-format msgid "cannot inherit from temporary relation of another session" msgstr "non è possibile ereditare da una relazione temporanea di un'altra sessione" -#: commands/tablecmds.c:1559 commands/tablecmds.c:10097 +#: commands/tablecmds.c:1560 commands/tablecmds.c:10192 #, c-format msgid "relation \"%s\" would be inherited from more than once" msgstr "la relazione \"%s\" sarebbe ereditata più di una volta" -#: commands/tablecmds.c:1607 +#: commands/tablecmds.c:1608 #, c-format msgid "merging multiple inherited definitions of column \"%s\"" msgstr "unione delle definizioni multiple ereditate della colonna \"%s\"" -#: commands/tablecmds.c:1615 +#: commands/tablecmds.c:1616 #, c-format msgid "inherited column \"%s\" has a type conflict" msgstr "la colonna ereditata \"%s\" ha un conflitto di tipo" -#: commands/tablecmds.c:1617 commands/tablecmds.c:1640 -#: commands/tablecmds.c:1838 commands/tablecmds.c:1862 +#: commands/tablecmds.c:1618 commands/tablecmds.c:1641 +#: commands/tablecmds.c:1839 commands/tablecmds.c:1863 #: parser/parse_coerce.c:1630 parser/parse_coerce.c:1650 #: parser/parse_coerce.c:1670 parser/parse_coerce.c:1715 #: parser/parse_coerce.c:1752 parser/parse_param.c:218 @@ -7794,755 +7792,766 @@ msgstr "la colonna ereditata \"%s\" ha un conflitto di tipo" msgid "%s versus %s" msgstr "tra %s e %s" -#: commands/tablecmds.c:1626 +#: commands/tablecmds.c:1627 #, c-format msgid "inherited column \"%s\" has a collation conflict" msgstr "la colonna ereditata \"%s\" ha un conflitto di ordinamento" -#: commands/tablecmds.c:1628 commands/tablecmds.c:1850 -#: commands/tablecmds.c:4768 +#: commands/tablecmds.c:1629 commands/tablecmds.c:1851 +#: commands/tablecmds.c:4767 #, c-format msgid "\"%s\" versus \"%s\"" msgstr "tra \"%s\" e \"%s\"" -#: commands/tablecmds.c:1638 +#: commands/tablecmds.c:1639 #, c-format msgid "inherited column \"%s\" has a storage parameter conflict" msgstr "la colonna ereditata \"%s\" ha un conflitto di parametro di memorizzazione" -#: commands/tablecmds.c:1751 parser/parse_utilcmd.c:938 -#: parser/parse_utilcmd.c:1287 parser/parse_utilcmd.c:1363 +#: commands/tablecmds.c:1752 commands/tablecmds.c:8088 +#: parser/parse_utilcmd.c:923 parser/parse_utilcmd.c:1274 +#: parser/parse_utilcmd.c:1350 #, c-format msgid "cannot convert whole-row table reference" msgstr "non è possibile convertire riferimenti ad una riga intera di tabella" -#: commands/tablecmds.c:1752 parser/parse_utilcmd.c:939 +#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:924 #, c-format msgid "Constraint \"%s\" contains a whole-row reference to table \"%s\"." msgstr "Il vincolo \"%s\" contiene un riferimento alla riga intera alla tabella \"%s\"." -#: commands/tablecmds.c:1824 +#: commands/tablecmds.c:1825 #, c-format msgid "merging column \"%s\" with inherited definition" msgstr "unione della colonna \"%s\" con la definizione ereditata" -#: commands/tablecmds.c:1828 +#: commands/tablecmds.c:1829 #, c-format msgid "moving and merging column \"%s\" with inherited definition" msgstr "spostamento e unione della colonna \"%s\" con la definizione ereditata" -#: commands/tablecmds.c:1829 +#: commands/tablecmds.c:1830 #, c-format msgid "User-specified column moved to the position of the inherited column." msgstr "Colonna specificata dall'utente spostata nella posizione della colonna ereditata." -#: commands/tablecmds.c:1836 +#: commands/tablecmds.c:1837 #, c-format msgid "column \"%s\" has a type conflict" msgstr "la colonna \"%s\" ha un conflitto di tipi" -#: commands/tablecmds.c:1848 +#: commands/tablecmds.c:1849 #, c-format msgid "column \"%s\" has a collation conflict" msgstr "la colonna \"%s\" ha un conflitto di ordinamento" -#: commands/tablecmds.c:1860 +#: commands/tablecmds.c:1861 #, c-format msgid "column \"%s\" has a storage parameter conflict" msgstr "la colonna \"%s\" ha un conflitto di parametri di memorizzazione" -#: commands/tablecmds.c:1912 +#: commands/tablecmds.c:1913 #, c-format msgid "column \"%s\" inherits conflicting default values" msgstr "la colonna \"%s\" eredita valori predefiniti in conflitto tra loro" -#: commands/tablecmds.c:1914 +#: commands/tablecmds.c:1915 #, c-format msgid "To resolve the conflict, specify a default explicitly." msgstr "Per risolvere il conflitto, specificare esplicitamente un valore predefinito." -#: commands/tablecmds.c:1961 +#: commands/tablecmds.c:1962 #, c-format msgid "check constraint name \"%s\" appears multiple times but with different expressions" msgstr "il nome del vincolo di controllo \"%s\" compare più di una volta ma con espressioni diverse" -#: commands/tablecmds.c:2155 +#: commands/tablecmds.c:2156 #, c-format msgid "cannot rename column of typed table" msgstr "non è possibile rinominare la colonna di una tabella con tipo" -#: commands/tablecmds.c:2172 +#: commands/tablecmds.c:2173 #, c-format msgid "\"%s\" is not a table, view, materialized view, composite type, index, or foreign table" msgstr "\"%s\" non è una tabella, vista, vista materializzata, tipo composito, indice né una tabella esterna" -#: commands/tablecmds.c:2266 +#: commands/tablecmds.c:2267 #, c-format msgid "inherited column \"%s\" must be renamed in child tables too" msgstr "la colonna ereditata \"%s\" dev'essere rinominata anche nelle tabelle figlie" -#: commands/tablecmds.c:2298 +#: commands/tablecmds.c:2299 #, c-format msgid "cannot rename system column \"%s\"" msgstr "non è possibile rinominare la colonna di sistema \"%s\"" -#: commands/tablecmds.c:2313 +#: commands/tablecmds.c:2314 #, c-format msgid "cannot rename inherited column \"%s\"" msgstr "non è possibile rinominare la colonna ereditata \"%s\"" -#: commands/tablecmds.c:2468 +#: commands/tablecmds.c:2469 #, c-format msgid "inherited constraint \"%s\" must be renamed in child tables too" msgstr "i vincoli ereditati \"%s\" devono essere rinominati anche nelle tabelle figlie" -#: commands/tablecmds.c:2475 +#: commands/tablecmds.c:2476 #, c-format msgid "cannot rename inherited constraint \"%s\"" msgstr "non è possibile rinominare il vincolo ereditato \"%s\"" #. translator: first %s is a SQL command, eg ALTER TABLE -#: commands/tablecmds.c:2701 +#: commands/tablecmds.c:2702 #, c-format msgid "cannot %s \"%s\" because it is being used by active queries in this session" msgstr "non è possibile effettuare %s \"%s\" perché è in uso da query attive in questa sessione" #. translator: first %s is a SQL command, eg ALTER TABLE -#: commands/tablecmds.c:2710 +#: commands/tablecmds.c:2711 #, c-format msgid "cannot %s \"%s\" because it has pending trigger events" msgstr "non è possibile effettuare %s \"%s\" perché ha eventi trigger in sospeso" -#: commands/tablecmds.c:3786 +#: commands/tablecmds.c:3785 #, c-format msgid "cannot rewrite system relation \"%s\"" msgstr "non è possibile riscrivere la relazione di sistema \"%s\"" -#: commands/tablecmds.c:3792 +#: commands/tablecmds.c:3791 #, c-format msgid "cannot rewrite table \"%s\" used as a catalog table" msgstr "non è possibile riscrivere la tabella \"%s\" usata come tabella di catalogo" -#: commands/tablecmds.c:3802 +#: commands/tablecmds.c:3801 #, c-format msgid "cannot rewrite temporary tables of other sessions" msgstr "non è possibile riscrivere tabelle temporanee di altre sessioni" -#: commands/tablecmds.c:4070 +#: commands/tablecmds.c:4069 #, c-format msgid "rewriting table \"%s\"" msgstr "riscrittura della tabella \"%s\"" -#: commands/tablecmds.c:4074 +#: commands/tablecmds.c:4073 #, c-format msgid "verifying table \"%s\"" msgstr "verifica della tabella \"%s\"" -#: commands/tablecmds.c:4188 +#: commands/tablecmds.c:4187 #, c-format msgid "column \"%s\" contains null values" msgstr "la colonna \"%s\" contiene valori null" -#: commands/tablecmds.c:4203 commands/tablecmds.c:7368 +#: commands/tablecmds.c:4202 commands/tablecmds.c:7385 #, c-format msgid "check constraint \"%s\" is violated by some row" msgstr "il vincolo di controllo \"%s\" è violato da alcune righe" -#: commands/tablecmds.c:4351 commands/trigger.c:235 -#: rewrite/rewriteDefine.c:267 rewrite/rewriteDefine.c:912 +#: commands/tablecmds.c:4350 commands/trigger.c:235 rewrite/rewriteDefine.c:267 +#: rewrite/rewriteDefine.c:912 #, c-format msgid "\"%s\" is not a table or view" msgstr "\"%s\" non è una tabella né una vista" -#: commands/tablecmds.c:4354 commands/trigger.c:1119 commands/trigger.c:1224 +#: commands/tablecmds.c:4353 commands/trigger.c:1119 commands/trigger.c:1224 #, c-format msgid "\"%s\" is not a table, view, or foreign table" msgstr "\"%s\" non è una tabella, una vista né una tabella esterna" -#: commands/tablecmds.c:4357 +#: commands/tablecmds.c:4356 #, c-format msgid "\"%s\" is not a table, view, materialized view, or index" msgstr "\"%s\" non è una tabella, una vista, una vista materializzata né un indice" -#: commands/tablecmds.c:4363 +#: commands/tablecmds.c:4362 #, c-format msgid "\"%s\" is not a table, materialized view, or index" msgstr "\"%s\" non è una tabella, una vista materializzata né un indice" -#: commands/tablecmds.c:4366 +#: commands/tablecmds.c:4365 #, c-format msgid "\"%s\" is not a table, materialized view, or foreign table" msgstr "\"%s\" non è una tabella, una vista materializzata né una tabella esterna" -#: commands/tablecmds.c:4369 +#: commands/tablecmds.c:4368 #, c-format msgid "\"%s\" is not a table or foreign table" msgstr "\"%s\" non è una tabella né una tabella esterna" -#: commands/tablecmds.c:4372 +#: commands/tablecmds.c:4371 #, c-format msgid "\"%s\" is not a table, composite type, or foreign table" msgstr "\"%s\" non è una tabella, un tipo composito né una tabella esterna" -#: commands/tablecmds.c:4375 commands/tablecmds.c:5427 +#: commands/tablecmds.c:4374 commands/tablecmds.c:5426 #, c-format msgid "\"%s\" is not a table, materialized view, index, or foreign table" msgstr "\"%s\" non è una tabella, una vista materializzata, un indice né una tabella esterna" -#: commands/tablecmds.c:4385 +#: commands/tablecmds.c:4384 #, c-format msgid "\"%s\" is of the wrong type" msgstr "\"%s\" è del tipo sbagliato" -#: commands/tablecmds.c:4537 commands/tablecmds.c:4544 +#: commands/tablecmds.c:4536 commands/tablecmds.c:4543 #, c-format msgid "cannot alter type \"%s\" because column \"%s.%s\" uses it" msgstr "non è possibile modificare il tipo \"%s\" perché la colonna \"%s.%s\" lo usa" -#: commands/tablecmds.c:4551 +#: commands/tablecmds.c:4550 #, c-format msgid "cannot alter foreign table \"%s\" because column \"%s.%s\" uses its row type" msgstr "non è possibile modificare la tabella esterna \"%s\" perché la colonna \"%s.%s\" usa il suo tipo di riga" -#: commands/tablecmds.c:4558 +#: commands/tablecmds.c:4557 #, c-format msgid "cannot alter table \"%s\" because column \"%s.%s\" uses its row type" msgstr "non è possibile modificare la tabella \"%s\" perché la colonna \"%s.%s\" usa il suo tipo di riga" -#: commands/tablecmds.c:4620 +#: commands/tablecmds.c:4619 #, c-format msgid "cannot alter type \"%s\" because it is the type of a typed table" msgstr "non è possibile modificare il tipo \"%s\" perché è il tipo di una tabella con tipo" -#: commands/tablecmds.c:4622 +#: commands/tablecmds.c:4621 #, c-format msgid "Use ALTER ... CASCADE to alter the typed tables too." msgstr "Usa DROP ... CASCADE per eliminare anche le tabelle con tipo." -#: commands/tablecmds.c:4666 +#: commands/tablecmds.c:4665 #, c-format msgid "type %s is not a composite type" msgstr "il tipo %s non è un tipo composito" -#: commands/tablecmds.c:4692 +#: commands/tablecmds.c:4691 #, c-format msgid "cannot add column to typed table" msgstr "non è possibile aggiungere una colonna ad una tabella con tipo" -#: commands/tablecmds.c:4760 commands/tablecmds.c:10256 +#: commands/tablecmds.c:4759 commands/tablecmds.c:10351 #, c-format msgid "child table \"%s\" has different type for column \"%s\"" msgstr "la tabella figlia \"%s\" ha tipo diverso per la colonna \"%s\"" -#: commands/tablecmds.c:4766 commands/tablecmds.c:10263 +#: commands/tablecmds.c:4765 commands/tablecmds.c:10358 #, c-format msgid "child table \"%s\" has different collation for column \"%s\"" msgstr "la tabella figlia \"%s\" ha ordinamento diverso per la colonna \"%s\"" -#: commands/tablecmds.c:4776 +#: commands/tablecmds.c:4775 #, c-format msgid "child table \"%s\" has a conflicting \"%s\" column" msgstr "la tabella figlia \"%s\" ha la colonna \"%s\" in conflitto" -#: commands/tablecmds.c:4788 +#: commands/tablecmds.c:4787 #, c-format msgid "merging definition of column \"%s\" for child \"%s\"" msgstr "unione delle definizioni della colonna \"%s\" per la tabella figlia \"%s\"" -#: commands/tablecmds.c:5015 +#: commands/tablecmds.c:5014 #, c-format msgid "column must be added to child tables too" msgstr "la colonna deve essere aggiunta anche alle tabelle figlie" -#: commands/tablecmds.c:5090 +#: commands/tablecmds.c:5089 #, c-format msgid "column \"%s\" of relation \"%s\" already exists, skipping" msgstr "la colonna \"%s\" della relazione \"%s\" esiste già, saltata" -#: commands/tablecmds.c:5097 +#: commands/tablecmds.c:5096 #, c-format msgid "column \"%s\" of relation \"%s\" already exists" msgstr "la colonna \"%s\" della relazione \"%s\" esiste già" -#: commands/tablecmds.c:5208 commands/tablecmds.c:5314 -#: commands/tablecmds.c:5372 commands/tablecmds.c:5486 -#: commands/tablecmds.c:5543 commands/tablecmds.c:5637 -#: commands/tablecmds.c:7886 commands/tablecmds.c:8511 +#: commands/tablecmds.c:5207 commands/tablecmds.c:5313 +#: commands/tablecmds.c:5371 commands/tablecmds.c:5485 +#: commands/tablecmds.c:5542 commands/tablecmds.c:5636 +#: commands/tablecmds.c:7924 commands/tablecmds.c:8606 #, c-format msgid "cannot alter system column \"%s\"" msgstr "non è possibile modificare la colonna di sistema \"%s\"" -#: commands/tablecmds.c:5244 +#: commands/tablecmds.c:5243 #, c-format msgid "column \"%s\" is in a primary key" msgstr "la colonna \"%s\" è in una chiave primaria" -#: commands/tablecmds.c:5459 +#: commands/tablecmds.c:5458 #, c-format msgid "statistics target %d is too low" msgstr "il target delle statistiche %d è troppo basso" -#: commands/tablecmds.c:5467 +#: commands/tablecmds.c:5466 #, c-format msgid "lowering statistics target to %d" msgstr "target delle statistiche abbassato a %d" -#: commands/tablecmds.c:5617 +#: commands/tablecmds.c:5616 #, c-format msgid "invalid storage type \"%s\"" msgstr "tipo di immagazzinamento non valido \"%s\"" -#: commands/tablecmds.c:5649 +#: commands/tablecmds.c:5648 #, c-format msgid "column data type %s can only have storage PLAIN" msgstr "il tipo di dato della colonna %s può avere solo immagazzinamento PLAIN" -#: commands/tablecmds.c:5687 +#: commands/tablecmds.c:5686 #, c-format msgid "cannot drop column from typed table" msgstr "non è possibile eliminare la colonna da una tabella con tipo" -#: commands/tablecmds.c:5731 +#: commands/tablecmds.c:5730 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist, skipping" msgstr "la colonna \"%s\" della relazione \"%s\" non esiste, saltato" -#: commands/tablecmds.c:5744 +#: commands/tablecmds.c:5743 #, c-format msgid "cannot drop system column \"%s\"" msgstr "non è possibile eliminare la colonna di sistema \"%s\"" -#: commands/tablecmds.c:5751 +#: commands/tablecmds.c:5750 #, c-format msgid "cannot drop inherited column \"%s\"" msgstr "non è possibile eliminare la colonna ereditata \"%s\"" -#: commands/tablecmds.c:5991 +#: commands/tablecmds.c:5990 #, c-format msgid "ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index \"%s\" to \"%s\"" msgstr "ALTER TABLE / ADD CONSTRAINT USING INDEX rinominerà l'indice \"%s\" in \"%s\"" -#: commands/tablecmds.c:6204 +#: commands/tablecmds.c:6203 #, c-format msgid "constraint must be added to child tables too" msgstr "il vincolo deve essere aggiunto anche alle tabelle figlie" -#: commands/tablecmds.c:6275 +#: commands/tablecmds.c:6274 #, c-format msgid "referenced relation \"%s\" is not a table" msgstr "la relazione referenziata \"%s\" non è una tabella" -#: commands/tablecmds.c:6298 +#: commands/tablecmds.c:6297 #, c-format msgid "constraints on permanent tables may reference only permanent tables" msgstr "i vincoli su tabelle permanenti possono referenziare solo tabelle permanenti" -#: commands/tablecmds.c:6305 +#: commands/tablecmds.c:6304 #, c-format msgid "constraints on unlogged tables may reference only permanent or unlogged tables" msgstr "i vincoli su tabelle non loggate possono referenziare solo tabelle permanenti o non loggate" -#: commands/tablecmds.c:6311 +#: commands/tablecmds.c:6310 #, c-format msgid "constraints on temporary tables may reference only temporary tables" msgstr "i vincoli su tabelle temporanee possono referenziare solo tabelle temporanee" -#: commands/tablecmds.c:6315 +#: commands/tablecmds.c:6314 #, c-format msgid "constraints on temporary tables must involve temporary tables of this session" msgstr "i vincoli su tabelle temporanee devono riferirsi a tabelle temporanee di questa sessione" -#: commands/tablecmds.c:6376 +#: commands/tablecmds.c:6375 #, c-format msgid "number of referencing and referenced columns for foreign key disagree" msgstr "i numeri di colonne referenzianti e referenziate per la chiave esterna non combaciano" -#: commands/tablecmds.c:6483 +#: commands/tablecmds.c:6482 #, c-format msgid "foreign key constraint \"%s\" cannot be implemented" msgstr "non è possibile implementare il vincolo di chiave esterna \"%s\"" -#: commands/tablecmds.c:6486 +#: commands/tablecmds.c:6485 #, c-format msgid "Key columns \"%s\" and \"%s\" are of incompatible types: %s and %s." msgstr "Le colonne chiave \"%s\" e \"%s\" hanno tipi incompatibili: %s e %s." -#: commands/tablecmds.c:6693 commands/tablecmds.c:6843 -#: commands/tablecmds.c:7725 commands/tablecmds.c:7781 +#: commands/tablecmds.c:6692 commands/tablecmds.c:6860 +#: commands/tablecmds.c:7763 commands/tablecmds.c:7819 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist" msgstr "il vincolo \"%s\" della relazione \"%s\" non esiste" -#: commands/tablecmds.c:6699 +#: commands/tablecmds.c:6698 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key constraint" msgstr "il vincolo \"%s\" della relazione \"%s\" non è una chiave esterna" -#: commands/tablecmds.c:6850 +#: commands/tablecmds.c:6867 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key or check constraint" msgstr "il vincolo \"%s\" della relazione \"%s\" non è una chiave esterna o un vincolo di controllo" -#: commands/tablecmds.c:6918 +#: commands/tablecmds.c:6935 #, c-format msgid "constraint must be validated on child tables too" msgstr "i vincoli devono essere validati anche sulle tabelle figlie" -#: commands/tablecmds.c:6987 +#: commands/tablecmds.c:7004 #, c-format msgid "column \"%s\" referenced in foreign key constraint does not exist" msgstr "la colonna \"%s\" referenziata dal vincolo di chiave esterna non esiste" -#: commands/tablecmds.c:6992 +#: commands/tablecmds.c:7009 #, c-format msgid "cannot have more than %d keys in a foreign key" msgstr "non possono esserci più di %d chiavi in una chiave esterna" -#: commands/tablecmds.c:7057 +#: commands/tablecmds.c:7074 #, c-format msgid "cannot use a deferrable primary key for referenced table \"%s\"" msgstr "non è possibile usare una chiave primaria deferita per la tabella referenziata \"%s\"" -#: commands/tablecmds.c:7074 +#: commands/tablecmds.c:7091 #, c-format msgid "there is no primary key for referenced table \"%s\"" msgstr "la tabella referenziata \"%s\" non ha una chiave primaria" -#: commands/tablecmds.c:7139 +#: commands/tablecmds.c:7156 #, c-format msgid "foreign key referenced-columns list must not contain duplicates" msgstr "la lista di colonne referenziate dalla chiave esterna non deve contenere duplicati" -#: commands/tablecmds.c:7233 +#: commands/tablecmds.c:7250 #, c-format msgid "cannot use a deferrable unique constraint for referenced table \"%s\"" msgstr "non è possibile usare un vincolo univoco deferito per la tabella referenziata \"%s\"" -#: commands/tablecmds.c:7238 +#: commands/tablecmds.c:7255 #, c-format msgid "there is no unique constraint matching given keys for referenced table \"%s\"" msgstr "non c'è alcun vincolo univoco che corrisponda alle chiavi indicate per la tabella referenziata \"%s\"" -#: commands/tablecmds.c:7401 +#: commands/tablecmds.c:7418 #, c-format msgid "validating foreign key constraint \"%s\"" msgstr "validazione del vincolo di chiave esterna \"%s\"" -#: commands/tablecmds.c:7697 +#: commands/tablecmds.c:7717 #, c-format msgid "cannot drop inherited constraint \"%s\" of relation \"%s\"" msgstr "non è possibile eliminare il vincolo ereditato \"%s\" della relazione \"%s\"" -#: commands/tablecmds.c:7731 +#: commands/tablecmds.c:7769 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist, skipping" msgstr "il vincolo \"%s\" della relazione \"%s\" non esiste, saltato" -#: commands/tablecmds.c:7870 +#: commands/tablecmds.c:7908 #, c-format msgid "cannot alter column type of typed table" msgstr "non è possibile modificare il tipo di colonna di una tabella con tipo" -#: commands/tablecmds.c:7893 +#: commands/tablecmds.c:7931 #, c-format msgid "cannot alter inherited column \"%s\"" msgstr "non è possibile modificare la colonna ereditata \"%s\"" -#: commands/tablecmds.c:7942 +#: commands/tablecmds.c:7980 #, c-format msgid "result of USING clause for column \"%s\" cannot be cast automatically to type %s" msgstr "il risultato della clausola USING per la colonna \"%s\" non può essere convertito automaticamente al tipo %s" -#: commands/tablecmds.c:7945 +#: commands/tablecmds.c:7983 #, c-format msgid "You might need to add an explicit cast." msgstr "Potresti dover aggiungere una conversione esplicita." -#: commands/tablecmds.c:7949 +#: commands/tablecmds.c:7987 #, c-format msgid "column \"%s\" cannot be cast automatically to type %s" msgstr "la colonna \"%s\" non può essere convertita automaticamente al tipo %s" #. translator: USING is SQL, don't translate it -#: commands/tablecmds.c:7952 +#: commands/tablecmds.c:7990 #, c-format msgid "You might need to specify \"USING %s::%s\"." msgstr "Potresti dover specificare \"USING %s::%s\"." -#: commands/tablecmds.c:8005 +#: commands/tablecmds.c:8089 +#, c-format +msgid "USING expression contains a whole-row table reference." +msgstr "L'espressione USING contiene un riferimento alla riga completa della tabella." + +#: commands/tablecmds.c:8100 #, c-format msgid "type of inherited column \"%s\" must be changed in child tables too" msgstr "il tipo della colonna ereditata \"%s\" deve essere cambiato anche nelle tabelle figlie" -#: commands/tablecmds.c:8092 +#: commands/tablecmds.c:8187 #, c-format msgid "cannot alter type of column \"%s\" twice" msgstr "non è possibile cambiare il tipo della colonna \"%s\" due volte" -#: commands/tablecmds.c:8128 +#: commands/tablecmds.c:8223 #, c-format msgid "default for column \"%s\" cannot be cast automatically to type %s" msgstr "il valore predefinito della colonna \"%s\" non può essere convertito automaticamente al tipo %s" -#: commands/tablecmds.c:8254 +#: commands/tablecmds.c:8349 #, c-format msgid "cannot alter type of a column used by a view or rule" msgstr "non è possibile cambiare il tipo di una colonna usata in una vista o una regola" -#: commands/tablecmds.c:8255 commands/tablecmds.c:8274 -#: commands/tablecmds.c:8292 +#: commands/tablecmds.c:8350 commands/tablecmds.c:8369 +#: commands/tablecmds.c:8387 #, c-format msgid "%s depends on column \"%s\"" msgstr "%s dipende dalla colonna \"%s\"" -#: commands/tablecmds.c:8273 +#: commands/tablecmds.c:8368 #, c-format msgid "cannot alter type of a column used in a trigger definition" msgstr "non è possibile cambiare il tipo di una colonna usata nella definizione di un trigger" -#: commands/tablecmds.c:8291 +#: commands/tablecmds.c:8386 #, c-format msgid "cannot alter type of a column used in a policy definition" msgstr "non è possibile cambiare il tipo di una colonna usata nella definizione di una regola di sicurezza" -#: commands/tablecmds.c:8956 +#: commands/tablecmds.c:9051 #, c-format msgid "cannot change owner of index \"%s\"" msgstr "non è possibile cambiare il proprietario dell'indice \"%s\"" -#: commands/tablecmds.c:8958 +#: commands/tablecmds.c:9053 #, c-format msgid "Change the ownership of the index's table, instead." msgstr "Cambia il proprietario della tabella dell'indice invece." -#: commands/tablecmds.c:8974 +#: commands/tablecmds.c:9069 #, c-format msgid "cannot change owner of sequence \"%s\"" msgstr "non è possibile cambiare il proprietario della sequenza \"%s\"" -#: commands/tablecmds.c:8976 commands/tablecmds.c:11398 +#: commands/tablecmds.c:9071 commands/tablecmds.c:11543 #, c-format msgid "Sequence \"%s\" is linked to table \"%s\"." msgstr "La sequenza \"%s\" è collegata alla tabella \"%s\"." -#: commands/tablecmds.c:8988 commands/tablecmds.c:12045 +#: commands/tablecmds.c:9083 commands/tablecmds.c:12190 #, c-format msgid "Use ALTER TYPE instead." msgstr "È possibile usare ALTER TYPE invece." -#: commands/tablecmds.c:8997 +#: commands/tablecmds.c:9092 #, c-format msgid "\"%s\" is not a table, view, sequence, or foreign table" msgstr "\"%s\" non è una tabella, una vista, una sequenza né una tabella esterna" -#: commands/tablecmds.c:9340 +#: commands/tablecmds.c:9435 #, c-format msgid "cannot have multiple SET TABLESPACE subcommands" msgstr "non è possibile avere più di un sottocomando SET TABLESPACE" -#: commands/tablecmds.c:9413 +#: commands/tablecmds.c:9508 #, c-format msgid "\"%s\" is not a table, view, materialized view, index, or TOAST table" msgstr "\"%s\" non è una tabella, una vista, una vista materializzata né una tabella TOAST" -#: commands/tablecmds.c:9446 commands/view.c:481 +#: commands/tablecmds.c:9541 commands/view.c:498 #, c-format msgid "WITH CHECK OPTION is supported only on automatically updatable views" msgstr "WITH CHECK OPTION è supportato solo su viste aggiornabili automaticamente" -#: commands/tablecmds.c:9592 +#: commands/tablecmds.c:9687 #, c-format msgid "cannot move system relation \"%s\"" msgstr "non è possibile spostare la relazione \"%s\"" -#: commands/tablecmds.c:9608 +#: commands/tablecmds.c:9703 #, c-format msgid "cannot move temporary tables of other sessions" msgstr "non è possibile spostare tabelle temporanee di altre sessioni" -#: commands/tablecmds.c:9745 +#: commands/tablecmds.c:9840 #, c-format msgid "only tables, indexes, and materialized views exist in tablespaces" msgstr "solo tabelle, indici e viste materializzate esistono nei tablespace" -#: commands/tablecmds.c:9757 +#: commands/tablecmds.c:9852 #, c-format msgid "cannot move relations in to or out of pg_global tablespace" msgstr "non è possibile spostare relazioni dentro o fuori il tablespace pg_global" -#: commands/tablecmds.c:9848 +#: commands/tablecmds.c:9943 #, c-format msgid "aborting because lock on relation \"%s.%s\" is not available" msgstr "interruzione perché non c'è un lock disponibile sulla relazione \"%s.%s\"" -#: commands/tablecmds.c:9864 +#: commands/tablecmds.c:9959 #, c-format msgid "no matching relations in tablespace \"%s\" found" msgstr "nessuna relazione corrispondente trovata nel tablespace \"%s\"" -#: commands/tablecmds.c:9938 storage/buffer/bufmgr.c:915 +#: commands/tablecmds.c:10033 storage/buffer/bufmgr.c:915 #, c-format msgid "invalid page in block %u of relation %s" msgstr "pagina non valida nel blocco %u della relazione %s" -#: commands/tablecmds.c:10020 +#: commands/tablecmds.c:10115 #, c-format msgid "cannot change inheritance of typed table" msgstr "non è possibile cambiare ereditarietà di tabelle con tipo" -#: commands/tablecmds.c:10070 +#: commands/tablecmds.c:10165 #, c-format msgid "cannot inherit to temporary relation of another session" msgstr "non è possibile ereditare tabelle temporanee di un'altra sessione" -#: commands/tablecmds.c:10124 +#: commands/tablecmds.c:10219 #, c-format msgid "circular inheritance not allowed" msgstr "l'ereditarietà circolare non è consentita" -#: commands/tablecmds.c:10125 +#: commands/tablecmds.c:10220 #, c-format msgid "\"%s\" is already a child of \"%s\"." msgstr "\"%s\" è già figlia di \"%s\"." -#: commands/tablecmds.c:10133 +#: commands/tablecmds.c:10228 #, c-format msgid "table \"%s\" without OIDs cannot inherit from table \"%s\" with OIDs" msgstr "la tabella \"%s\" senza OID non può ereditare dalla tabella \"%s\" con OID" -#: commands/tablecmds.c:10274 +#: commands/tablecmds.c:10369 #, c-format msgid "column \"%s\" in child table must be marked NOT NULL" msgstr "la colonna \"%s\" nella tabella figlia dev'essere marcata NOT NULL" -#: commands/tablecmds.c:10290 +#: commands/tablecmds.c:10385 commands/tablecmds.c:10418 #, c-format msgid "child table is missing column \"%s\"" msgstr "la tabella figlia non ha la colonna \"%s\"" -#: commands/tablecmds.c:10373 +#: commands/tablecmds.c:10501 #, c-format msgid "child table \"%s\" has different definition for check constraint \"%s\"" msgstr "la tabella figlia \"%s\" ha una definizione diversa del vincolo di controllo \"%s\"" -#: commands/tablecmds.c:10381 +#: commands/tablecmds.c:10509 #, c-format msgid "constraint \"%s\" conflicts with non-inherited constraint on child table \"%s\"" msgstr "il vincolo \"%s\" è in conflitto con un vincolo non ereditato nella tabella figlia \"%s\"" -#: commands/tablecmds.c:10405 +#: commands/tablecmds.c:10520 +#, c-format +msgid "constraint \"%s\" conflicts with NOT VALID constraint on child table \"%s\"" +msgstr "il vincolo \"%s\" è in conflitto con un vincolo non valido nella tabella figlia \"%s\"" + +#: commands/tablecmds.c:10544 #, c-format msgid "child table is missing constraint \"%s\"" msgstr "la tabella figlia non ha il vincolo \"%s\"" -#: commands/tablecmds.c:10489 +#: commands/tablecmds.c:10628 #, c-format msgid "relation \"%s\" is not a parent of relation \"%s\"" msgstr "la relazione \"%s\" non è genitore della relazione \"%s\"" -#: commands/tablecmds.c:10723 +#: commands/tablecmds.c:10862 #, c-format msgid "typed tables cannot inherit" msgstr "le tabelle con tipo non possono essere ereditate" -#: commands/tablecmds.c:10754 +#: commands/tablecmds.c:10893 #, c-format msgid "table is missing column \"%s\"" msgstr "la tabella non ha la colonna \"%s\"" -#: commands/tablecmds.c:10764 +#: commands/tablecmds.c:10903 #, c-format msgid "table has column \"%s\" where type requires \"%s\"" msgstr "la tabella ha la colonna \"%s\" laddove il tipo richiede \"%s\"" -#: commands/tablecmds.c:10773 +#: commands/tablecmds.c:10912 #, c-format msgid "table \"%s\" has different type for column \"%s\"" msgstr "la tabella \"%s\" ha tipo diverso per la colonna \"%s\"" -#: commands/tablecmds.c:10786 +#: commands/tablecmds.c:10925 #, c-format msgid "table has extra column \"%s\"" msgstr "la tabella ha la colonna \"%s\" in eccesso" -#: commands/tablecmds.c:10838 +#: commands/tablecmds.c:10977 #, c-format msgid "\"%s\" is not a typed table" msgstr "\"%s\" non è una tabella con tipo" -#: commands/tablecmds.c:11022 +#: commands/tablecmds.c:11161 #, c-format msgid "cannot use non-unique index \"%s\" as replica identity" msgstr "non è possibile usare l'indice non univoco \"%s\" come identità di replica" -#: commands/tablecmds.c:11028 +#: commands/tablecmds.c:11167 #, c-format msgid "cannot use non-immediate index \"%s\" as replica identity" msgstr "non è possibile usare l'indice non immediato \"%s\" come identità di replica" -#: commands/tablecmds.c:11034 +#: commands/tablecmds.c:11173 #, c-format msgid "cannot use expression index \"%s\" as replica identity" msgstr "non è possibile usare l'indice su espressione \"%s\" come identità di replica" -#: commands/tablecmds.c:11040 +#: commands/tablecmds.c:11179 #, c-format msgid "cannot use partial index \"%s\" as replica identity" msgstr "non è possibile usare l'indice parziale \"%s\" come identità di replica" -#: commands/tablecmds.c:11046 +#: commands/tablecmds.c:11185 #, c-format msgid "cannot use invalid index \"%s\" as replica identity" msgstr "non è possibile usare l'indice non valido \"%s\" come identità di replica" -#: commands/tablecmds.c:11067 +#: commands/tablecmds.c:11206 #, c-format msgid "index \"%s\" cannot be used as replica identity because column %d is a system column" msgstr "l'indice \"%s\" non può essere usato come identità di replica perché la colonna %d è una colonna di sistema" -#: commands/tablecmds.c:11074 +#: commands/tablecmds.c:11213 #, c-format msgid "index \"%s\" cannot be used as replica identity because column \"%s\" is nullable" msgstr "l'indice \"%s\" non può essere usato come identità di replica perché la colonna \"%s\" può essere NULL" -#: commands/tablecmds.c:11271 +#: commands/tablecmds.c:11416 #, c-format msgid "cannot change logged status of table \"%s\" because it is temporary" msgstr "non è possibile cambiare lo stato di log della tabella \"%s\" perché è temporanea" -#: commands/tablecmds.c:11330 +#: commands/tablecmds.c:11475 #, c-format msgid "could not change table \"%s\" to logged because it references unlogged table \"%s\"" msgstr "non è possibile cambiare lo stato della tabella \"%s\" a loggata perché referenzia la tabella non loggata \"%s\"" -#: commands/tablecmds.c:11340 +#: commands/tablecmds.c:11485 #, c-format msgid "could not change table \"%s\" to unlogged because it references logged table \"%s\"" msgstr "non è possibile cambiare lo stato della tabella \"%s\" a non loggata perché referenzia la tabella loggata \"%s\"" -#: commands/tablecmds.c:11397 +#: commands/tablecmds.c:11542 #, c-format msgid "cannot move an owned sequence into another schema" msgstr "non è possibile spostare una sequenza con proprietario in uno schema diverso" -#: commands/tablecmds.c:11502 +#: commands/tablecmds.c:11647 #, c-format msgid "relation \"%s\" already exists in schema \"%s\"" msgstr "la relazione \"%s\" esiste già nello schema \"%s\"" -#: commands/tablecmds.c:12029 +#: commands/tablecmds.c:12174 #, c-format msgid "\"%s\" is not a composite type" msgstr "\"%s\" non è un tipo composito" -#: commands/tablecmds.c:12059 +#: commands/tablecmds.c:12204 #, c-format msgid "\"%s\" is not a table, view, materialized view, sequence, or foreign table" msgstr "\"%s\" non è una tabella, una vista, una vista materializzata, una sequenza né una tabella esterna" #: commands/tablespace.c:162 commands/tablespace.c:179 #: commands/tablespace.c:190 commands/tablespace.c:198 -#: commands/tablespace.c:629 replication/slot.c:969 storage/file/copydir.c:47 +#: commands/tablespace.c:625 replication/slot.c:980 storage/file/copydir.c:47 #, c-format msgid "could not create directory \"%s\": %m" msgstr "creazione della directory \"%s\" fallita: %m" @@ -8567,105 +8576,105 @@ msgstr "permesso di creare il tablespace \"%s\" negato" msgid "Must be superuser to create a tablespace." msgstr "Solo un superutente può incrementare questo valore." -#: commands/tablespace.c:271 +#: commands/tablespace.c:267 #, c-format msgid "tablespace location cannot contain single quotes" msgstr "la posizione del tablespace non può contenere apici" -#: commands/tablespace.c:281 +#: commands/tablespace.c:277 #, c-format msgid "tablespace location must be an absolute path" msgstr "la posizione del tablespace dev'essere un percorso assoluto" -#: commands/tablespace.c:292 +#: commands/tablespace.c:288 #, c-format msgid "tablespace location \"%s\" is too long" msgstr "la posizione del tablespace \"%s\" è troppo lunga" -#: commands/tablespace.c:299 +#: commands/tablespace.c:295 #, c-format msgid "tablespace location should not be inside the data directory" msgstr "la locazione del tablespace non dev'essere all'interno della directory dei dati" -#: commands/tablespace.c:308 commands/tablespace.c:956 +#: commands/tablespace.c:304 commands/tablespace.c:952 #, c-format msgid "unacceptable tablespace name \"%s\"" msgstr "il nome del tablespace \"%s\" non è accettabile" -#: commands/tablespace.c:310 commands/tablespace.c:957 +#: commands/tablespace.c:306 commands/tablespace.c:953 #, c-format msgid "The prefix \"pg_\" is reserved for system tablespaces." msgstr "Il prefisso \"pg_\" è riservato per i tablespace di sistema." -#: commands/tablespace.c:320 commands/tablespace.c:969 +#: commands/tablespace.c:316 commands/tablespace.c:965 #, c-format msgid "tablespace \"%s\" already exists" msgstr "il tablespace \"%s\" esiste già" -#: commands/tablespace.c:434 commands/tablespace.c:939 -#: commands/tablespace.c:1020 commands/tablespace.c:1089 -#: commands/tablespace.c:1222 commands/tablespace.c:1422 +#: commands/tablespace.c:430 commands/tablespace.c:935 +#: commands/tablespace.c:1016 commands/tablespace.c:1085 +#: commands/tablespace.c:1218 commands/tablespace.c:1418 #, c-format msgid "tablespace \"%s\" does not exist" msgstr "il tablespace \"%s\" non esiste" -#: commands/tablespace.c:440 +#: commands/tablespace.c:436 #, c-format msgid "tablespace \"%s\" does not exist, skipping" msgstr "il tablespace \"%s\" non esiste, saltato" -#: commands/tablespace.c:516 +#: commands/tablespace.c:512 #, c-format msgid "tablespace \"%s\" is not empty" msgstr "il tablespace \"%s\" non è vuoto" -#: commands/tablespace.c:588 +#: commands/tablespace.c:584 #, c-format msgid "directory \"%s\" does not exist" msgstr "la directory \"%s\" non esiste" -#: commands/tablespace.c:589 +#: commands/tablespace.c:585 #, c-format msgid "Create this directory for the tablespace before restarting the server." msgstr "Crea questa directory per il tablespace prima di riavviare il server." -#: commands/tablespace.c:594 +#: commands/tablespace.c:590 #, c-format msgid "could not set permissions on directory \"%s\": %m" msgstr "impostazione dei permessi sulla directory \"%s\" fallita: %m" -#: commands/tablespace.c:624 +#: commands/tablespace.c:620 #, c-format msgid "directory \"%s\" already in use as a tablespace" msgstr "la directory \"%s\" già è in uso come tablespace" -#: commands/tablespace.c:748 commands/tablespace.c:761 -#: commands/tablespace.c:797 commands/tablespace.c:889 +#: commands/tablespace.c:744 commands/tablespace.c:757 +#: commands/tablespace.c:793 commands/tablespace.c:885 #, c-format msgid "could not remove directory \"%s\": %m" msgstr "rimozione della directory \"%s\" fallita: %m" -#: commands/tablespace.c:810 commands/tablespace.c:898 +#: commands/tablespace.c:806 commands/tablespace.c:894 #, c-format msgid "could not remove symbolic link \"%s\": %m" msgstr "rimozione del link simbolico \"%s\" fallita: %m" -#: commands/tablespace.c:820 commands/tablespace.c:907 +#: commands/tablespace.c:816 commands/tablespace.c:903 #, c-format msgid "\"%s\" is not a directory or symbolic link" msgstr "\"%s\" non è una directory o un link simbolico" -#: commands/tablespace.c:1094 +#: commands/tablespace.c:1090 #, c-format msgid "Tablespace \"%s\" does not exist." msgstr "Il tablespace \"%s\" non esiste." -#: commands/tablespace.c:1521 +#: commands/tablespace.c:1517 #, c-format msgid "directories for tablespace %u could not be removed" msgstr "rimozioni delle directory per il tablespace %u fallita" -#: commands/tablespace.c:1523 +#: commands/tablespace.c:1519 #, c-format msgid "You can remove the directories manually if necessary." msgstr "Puoi rimuovere le directory manualmente se necessario." @@ -8808,32 +8817,31 @@ msgstr "la funzione trigger %u ha restituito un valore null" msgid "BEFORE STATEMENT trigger cannot return a value" msgstr "il trigger BEFORE STATEMENT non può restituire un valore" -#: commands/trigger.c:2726 executor/nodeModifyTable.c:664 -#: executor/nodeModifyTable.c:957 +#: commands/trigger.c:2726 executor/nodeModifyTable.c:679 +#: executor/nodeModifyTable.c:972 #, c-format msgid "tuple to be updated was already modified by an operation triggered by the current command" msgstr "la tupla da aggiornare era stata già modificata da un'operazione fatta eseguire da un comando corrente" -#: commands/trigger.c:2727 executor/nodeModifyTable.c:665 -#: executor/nodeModifyTable.c:958 +#: commands/trigger.c:2727 executor/nodeModifyTable.c:680 +#: executor/nodeModifyTable.c:973 #, c-format msgid "Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." msgstr "Considera l'utilizzo di un trigger AFTER invece di un trigger BEFORE per propagare i cambiamenti ad altre righe." -#: commands/trigger.c:2741 executor/execMain.c:2369 -#: executor/nodeLockRows.c:216 executor/nodeModifyTable.c:200 -#: executor/nodeModifyTable.c:677 executor/nodeModifyTable.c:970 -#: executor/nodeModifyTable.c:1136 +#: commands/trigger.c:2741 executor/execMain.c:2379 executor/nodeLockRows.c:216 +#: executor/nodeModifyTable.c:213 executor/nodeModifyTable.c:692 +#: executor/nodeModifyTable.c:985 executor/nodeModifyTable.c:1151 #, c-format msgid "could not serialize access due to concurrent update" msgstr "serializzazione dell'accesso fallita a causa di modifiche concorrenti" -#: commands/trigger.c:4579 +#: commands/trigger.c:4575 #, c-format msgid "constraint \"%s\" is not deferrable" msgstr "il vincolo \"%s\" non è deferibile" -#: commands/trigger.c:4602 +#: commands/trigger.c:4598 #, c-format msgid "constraint \"%s\" does not exist" msgstr "il vincolo \"%s\" non esiste" @@ -9078,7 +9086,7 @@ msgstr "i vincoli di chiave esterna non sono ammessi per i domini" msgid "specifying constraint deferrability not supported for domains" msgstr "specificare la deferibilità dei vincoli non è ammesso per i domini" -#: commands/typecmds.c:1291 utils/cache/typcache.c:1634 +#: commands/typecmds.c:1291 utils/cache/typcache.c:1630 #, c-format msgid "%s is not an enum" msgstr "%s non è una enumerazione" @@ -9243,8 +9251,8 @@ msgstr "solo i superutenti possono cambiare l'attributo bypassrls" msgid "permission denied to create role" msgstr "permesso di creare il ruolo negato" -#: commands/user.c:322 commands/user.c:1176 commands/user.c:1183 gram.y:13599 -#: gram.y:13634 +#: commands/user.c:322 commands/user.c:1176 commands/user.c:1183 +#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 gram.y:13615 gram.y:13650 #, c-format msgid "role name \"%s\" is reserved" msgstr "il nome di ruolo \"%s\" è riservato" @@ -9264,8 +9272,8 @@ msgstr "il ruolo \"%s\" esiste già" msgid "pg_authid OID value not set when in binary upgrade mode" msgstr "valore di OID di pg_authid non impostato in modalità di aggiornamento binaria" -#: commands/user.c:679 commands/user.c:896 commands/user.c:1443 -#: commands/user.c:1589 +#: commands/user.c:679 commands/user.c:896 commands/user.c:1432 +#: commands/user.c:1578 #, c-format msgid "must be superuser to alter superusers" msgstr "solo i superutenti possono modificare superutenti" @@ -9295,8 +9303,8 @@ msgstr "permesso di eliminare il ruolo negato" msgid "cannot use special role specifier in DROP ROLE" msgstr "non è possibile usare lo specificatore di ruolo speciale in DROP ROLE" -#: commands/user.c:990 commands/user.c:1147 commands/variable.c:805 -#: commands/variable.c:880 utils/adt/acl.c:5121 utils/adt/acl.c:5173 +#: commands/user.c:990 commands/user.c:1147 commands/variable.c:825 +#: commands/variable.c:897 utils/adt/acl.c:5121 utils/adt/acl.c:5173 #: utils/adt/acl.c:5206 utils/adt/acl.c:5224 utils/init/miscinit.c:502 #, c-format msgid "role \"%s\" does not exist" @@ -9352,42 +9360,42 @@ msgstr "permesso di rinominare il ruolo negato" msgid "MD5 password cleared because of role rename" msgstr "L'MD5 della password è stato cancellato perché il ruolo è stato rinominato" -#: commands/user.c:1299 +#: commands/user.c:1291 #, c-format msgid "column names cannot be included in GRANT/REVOKE ROLE" msgstr "la colonna dei nomi non può essere inclusa in GRANT/REVOKE ROLE" -#: commands/user.c:1337 +#: commands/user.c:1329 #, c-format msgid "permission denied to drop objects" msgstr "permesso di eliminare gli oggetti negato" -#: commands/user.c:1364 commands/user.c:1376 +#: commands/user.c:1356 commands/user.c:1365 #, c-format msgid "permission denied to reassign objects" msgstr "permesso di riassegnare gli oggetti negato" -#: commands/user.c:1451 commands/user.c:1597 +#: commands/user.c:1440 commands/user.c:1586 #, c-format msgid "must have admin option on role \"%s\"" msgstr "occorre avere l'opzione admin sul ruolo \"%s\"" -#: commands/user.c:1468 +#: commands/user.c:1457 #, c-format msgid "must be superuser to set grantor" msgstr "solo i superutenti possono impostare chi ha concesso il privilegio" -#: commands/user.c:1493 +#: commands/user.c:1482 #, c-format msgid "role \"%s\" is a member of role \"%s\"" msgstr "il ruolo \"%s\" è membro del ruolo \"%s\"" -#: commands/user.c:1508 +#: commands/user.c:1497 #, c-format msgid "role \"%s\" is already a member of role \"%s\"" msgstr "il ruolo \"%s\" è già membro del ruolo \"%s\"" -#: commands/user.c:1619 +#: commands/user.c:1608 #, c-format msgid "role \"%s\" is not a member of role \"%s\"" msgstr "il ruolo \"%s\" non è membro del ruolo \"%s\"" @@ -9397,146 +9405,151 @@ msgstr "il ruolo \"%s\" non è membro del ruolo \"%s\"" msgid "%s cannot be executed from VACUUM or ANALYZE" msgstr "%s non può essere eseguito da VACUUM o ANALYZE" -#: commands/vacuum.c:528 +#: commands/vacuum.c:195 +#, c-format +msgid "VACUUM option DISABLE_PAGE_SKIPPING cannot be used with FULL" +msgstr "l'opzione DISABLE_PAGE_SKIPPING di VACUUM non può essere usata con FULL" + +#: commands/vacuum.c:535 #, c-format msgid "oldest xmin is far in the past" msgstr "il più vecchio xmin è molto lontano nel tempo" -#: commands/vacuum.c:529 +#: commands/vacuum.c:536 #, c-format msgid "Close open transactions soon to avoid wraparound problems." msgstr "Chiudi presto le transazioni per evitare problemi di wraparound." -#: commands/vacuum.c:568 +#: commands/vacuum.c:575 #, c-format msgid "oldest multixact is far in the past" msgstr "il multixact più vecchio è remoto" -#: commands/vacuum.c:569 +#: commands/vacuum.c:576 #, c-format msgid "Close open transactions with multixacts soon to avoid wraparound problems." msgstr "Chiudi presto le transazioni con multixact per evitare problemi di wraparound." -#: commands/vacuum.c:1131 +#: commands/vacuum.c:1146 #, c-format msgid "some databases have not been vacuumed in over 2 billion transactions" msgstr "alcuni database non sono stati ripuliti per più di 2 miliardi di transazioni" -#: commands/vacuum.c:1132 +#: commands/vacuum.c:1147 #, c-format msgid "You might have already suffered transaction-wraparound data loss." msgstr "Potresti aver già subito perdita di dati dovuta al wraparound delle transazioni." -#: commands/vacuum.c:1253 +#: commands/vacuum.c:1268 #, c-format msgid "skipping vacuum of \"%s\" --- lock not available" msgstr "pulizia di \"%s\" saltata --- lock non disponibile" -#: commands/vacuum.c:1279 +#: commands/vacuum.c:1294 #, c-format msgid "skipping \"%s\" --- only superuser can vacuum it" msgstr "\"%s\" saltato --- solo i superutenti possono pulirla" -#: commands/vacuum.c:1283 +#: commands/vacuum.c:1298 #, c-format msgid "skipping \"%s\" --- only superuser or database owner can vacuum it" msgstr "\"%s\" saltato --- solo i superutenti o il proprietario del database possono pulirla" -#: commands/vacuum.c:1287 +#: commands/vacuum.c:1302 #, c-format msgid "skipping \"%s\" --- only table or database owner can vacuum it" msgstr "\"%s\" saltato --- solo il proprietario del database o della tabella possono pulirla" -#: commands/vacuum.c:1305 +#: commands/vacuum.c:1320 #, c-format msgid "skipping \"%s\" --- cannot vacuum non-tables or special system tables" msgstr "\"%s\" saltato --- non è possibile ripulire non-tabelle o tabelle speciali di sistema" -#: commands/vacuumlazy.c:363 +#: commands/vacuumlazy.c:366 #, c-format msgid "automatic vacuum of table \"%s.%s.%s\": index scans: %d\n" msgstr "vacuum automatico della tabella \"%s.%s.%s\": scan di indici: %d\n" -#: commands/vacuumlazy.c:368 +#: commands/vacuumlazy.c:371 #, c-format msgid "pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n" msgstr "pagine: %u rimosse, %u restanti, %u saltate perché bloccate, %u congelate saltate\n" -#: commands/vacuumlazy.c:374 +#: commands/vacuumlazy.c:377 #, c-format msgid "tuples: %.0f removed, %.0f remain, %.0f are dead but not yet removable\n" msgstr "tuple: %.0f rimosse, %.0f restanti, %.0f sono morte ma non ancora removibili\n" -#: commands/vacuumlazy.c:379 +#: commands/vacuumlazy.c:382 #, c-format msgid "buffer usage: %d hits, %d misses, %d dirtied\n" msgstr "uso dei buffer: %d colpiti, %d mancati, %d sporcati\n" -#: commands/vacuumlazy.c:383 +#: commands/vacuumlazy.c:386 #, c-format msgid "avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n" msgstr "velocità di lettura media: %.3f MB/s, velocità di scrittura media: %.3f MB/s\n" -#: commands/vacuumlazy.c:385 +#: commands/vacuumlazy.c:388 #, c-format msgid "system usage: %s" msgstr "utilizzo di sistema: %s" -#: commands/vacuumlazy.c:837 +#: commands/vacuumlazy.c:846 #, c-format msgid "relation \"%s\" page %u is uninitialized --- fixing" msgstr "la relazione \"%s\" pagina %u non è inizializzata --- in correzione" -#: commands/vacuumlazy.c:1301 +#: commands/vacuumlazy.c:1316 #, c-format msgid "\"%s\": removed %.0f row versions in %u pages" msgstr "\"%s\": %.0f versioni di riga rimosse in %u pagine" -#: commands/vacuumlazy.c:1311 +#: commands/vacuumlazy.c:1326 #, c-format msgid "%.0f dead row versions cannot be removed yet.\n" msgstr "%.0f versioni di righe morte non possono essere ancora rimosse.\n" -#: commands/vacuumlazy.c:1313 +#: commands/vacuumlazy.c:1328 #, c-format msgid "There were %.0f unused item pointers.\n" msgstr "C'erano %.0f puntatori ad elementi non usati.\n" -#: commands/vacuumlazy.c:1315 +#: commands/vacuumlazy.c:1330 #, c-format msgid "Skipped %u page due to buffer pins.\n" msgid_plural "Skipped %u pages due to buffer pins.\n" msgstr[0] "%u pagina saltata a causa di blocchi dei buffer.\n" msgstr[1] "%u pagine saltate a causa di blocchi dei buffer.\n" -#: commands/vacuumlazy.c:1319 +#: commands/vacuumlazy.c:1334 #, c-format msgid "%u page is entirely empty.\n" msgid_plural "%u pages are entirely empty.\n" msgstr[0] "%u pagina è completamente vuota.\n" msgstr[1] "%u pagina sono completamente vuote.\n" -#: commands/vacuumlazy.c:1327 +#: commands/vacuumlazy.c:1342 #, c-format msgid "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u pages" msgstr "\"%s\": trovate %.0f versioni di riga removibili, %.0f non removibili in %u pagine su %u" -#: commands/vacuumlazy.c:1396 +#: commands/vacuumlazy.c:1411 #, c-format msgid "\"%s\": removed %d row versions in %d pages" msgstr "\"%s\": %d versioni di riga rimosse in %d pagine" -#: commands/vacuumlazy.c:1585 +#: commands/vacuumlazy.c:1600 #, c-format msgid "scanned index \"%s\" to remove %d row versions" msgstr "effettuata la scansione dell'indice \"%s\" per rimuovere %d versioni di riga" -#: commands/vacuumlazy.c:1631 +#: commands/vacuumlazy.c:1646 #, c-format msgid "index \"%s\" now contains %.0f row versions in %u pages" msgstr "l'indice \"%s\" ora contiene %.0f versioni di riga in %u pagine" -#: commands/vacuumlazy.c:1635 +#: commands/vacuumlazy.c:1650 #, c-format msgid "" "%.0f index row versions were removed.\n" @@ -9547,22 +9560,22 @@ msgstr "" "%u pagine dell'indice sono state cancellate, %u sono attualmente riusabili.\n" "%s." -#: commands/vacuumlazy.c:1721 +#: commands/vacuumlazy.c:1745 #, c-format msgid "\"%s\": stopping truncate due to conflicting lock request" msgstr "\"%s\": truncate interrotto a causa di una richiesta di lock in conflitto" -#: commands/vacuumlazy.c:1786 +#: commands/vacuumlazy.c:1810 #, c-format msgid "\"%s\": truncated %u to %u pages" msgstr "\"%s\": %u pagine ridotte a %u" -#: commands/vacuumlazy.c:1842 +#: commands/vacuumlazy.c:1866 #, c-format msgid "\"%s\": suspending truncate due to conflicting lock request" msgstr "\"%s\": annullamento del troncamento a causa di richieste di lock in conflitto" -#: commands/variable.c:164 utils/misc/guc.c:9877 +#: commands/variable.c:164 utils/misc/guc.c:9899 #, c-format msgid "Unrecognized key word: \"%s\"." msgstr "Parola chiave non riconosciuta: \"%s\"." @@ -9652,7 +9665,12 @@ msgstr "La conversione fra %s e %s non è supportata." msgid "Cannot change \"client_encoding\" now." msgstr "Non è possibile cambiare \"client_encoding\" ora." -#: commands/variable.c:898 +#: commands/variable.c:779 +#, c-format +msgid "cannot change client_encoding in a parallel worker" +msgstr "non è possibile cambiare client_encoding in un worker parallelo" + +#: commands/variable.c:915 #, c-format msgid "permission denied to set role \"%s\"" msgstr "permesso di impostare il ruolo \"%s\" negato" @@ -9667,52 +9685,52 @@ msgstr "valore non valido per l'opzione \"check_option\"" msgid "Valid values are \"local\" and \"cascaded\"." msgstr "Valori validi sono \"local\" e \"cascaded\"." -#: commands/view.c:114 +#: commands/view.c:101 #, c-format msgid "could not determine which collation to use for view column \"%s\"" msgstr "non è stato possibile determinare quale ordinamento usare per la colonna \"%s\"" -#: commands/view.c:129 +#: commands/view.c:115 #, c-format msgid "view must have at least one column" msgstr "la vista deve avere almeno una colonna" -#: commands/view.c:263 commands/view.c:275 +#: commands/view.c:280 commands/view.c:292 #, c-format msgid "cannot drop columns from view" msgstr "non è possibile eliminare colonne da una vista" -#: commands/view.c:280 +#: commands/view.c:297 #, c-format msgid "cannot change name of view column \"%s\" to \"%s\"" msgstr "non è possibile cambiare nome della colonna di vista \"%s\" in \"%s\"" -#: commands/view.c:288 +#: commands/view.c:305 #, c-format msgid "cannot change data type of view column \"%s\" from %s to %s" msgstr "non è possibile cambiare tipo di dato della colonna di vista \"%s\" da %s a %s" -#: commands/view.c:427 +#: commands/view.c:444 #, c-format msgid "views must not contain SELECT INTO" msgstr "le viste non possono contenere SELECT INTO" -#: commands/view.c:440 +#: commands/view.c:457 #, c-format msgid "views must not contain data-modifying statements in WITH" msgstr "una vista non può contenere istruzioni di modifica dei dati in un WITH" -#: commands/view.c:511 +#: commands/view.c:528 #, c-format msgid "CREATE VIEW specifies more column names than columns" msgstr "CREATE VIEW specifica più nomi di colonne che colonne" -#: commands/view.c:519 +#: commands/view.c:536 #, c-format msgid "views cannot be unlogged because they do not have storage" msgstr "le viste non possono essere non loggate perché non sono immagazzinate" -#: commands/view.c:533 +#: commands/view.c:550 #, c-format msgid "view \"%s\" will be a temporary view" msgstr "la vista \"%s\" sarà una vista temporanea" @@ -9757,37 +9775,37 @@ msgstr "il tipo del parametro %d (%s) non combacia con quello usato alla prepara msgid "no value found for parameter %d" msgstr "nessun valore trovato per il parametro %d" -#: executor/execIndexing.c:539 +#: executor/execIndexing.c:544 #, c-format msgid "ON CONFLICT does not support deferrable unique constraints/exclusion constraints as arbiters" msgstr "ON CONFLICT non supporta vincoli/esclusioni unici deferibili come arbitri" -#: executor/execIndexing.c:816 +#: executor/execIndexing.c:821 #, c-format msgid "could not create exclusion constraint \"%s\"" msgstr "creazione del vincolo di esclusione \"%s\" fallita" -#: executor/execIndexing.c:819 +#: executor/execIndexing.c:824 #, c-format msgid "Key %s conflicts with key %s." msgstr "La chiave %s è in conflitto con la chiave %s." -#: executor/execIndexing.c:821 +#: executor/execIndexing.c:826 #, c-format msgid "Key conflicts exist." msgstr "Ci sono conflitti di chiave." -#: executor/execIndexing.c:827 +#: executor/execIndexing.c:832 #, c-format msgid "conflicting key value violates exclusion constraint \"%s\"" msgstr "le chiavi in conflitto violano il vincolo di esclusione \"%s\"" -#: executor/execIndexing.c:830 +#: executor/execIndexing.c:835 #, c-format msgid "Key %s conflicts with existing key %s." msgstr "La chiave %s è in conflitto con la chiave esistente %s." -#: executor/execIndexing.c:832 +#: executor/execIndexing.c:837 #, c-format msgid "Key conflicts with existing key." msgstr "Conflitti di chiave con chiave esistente." @@ -9892,7 +9910,7 @@ msgstr "non è possibile bloccare righe vista \"%s\"" msgid "cannot lock rows in materialized view \"%s\"" msgstr "non è possibile bloccare righe nella vista materializzata \"%s\"" -#: executor/execMain.c:1192 executor/execMain.c:2603 +#: executor/execMain.c:1192 executor/execMain.c:2613 #: executor/nodeLockRows.c:132 #, c-format msgid "cannot lock rows in foreign table \"%s\"" @@ -9903,51 +9921,51 @@ msgstr "non è possibile bloccare righe nella tabella esterna \"%s\"" msgid "cannot lock rows in relation \"%s\"" msgstr "non è possibile bloccare righe nella relazione \"%s\"" -#: executor/execMain.c:1721 +#: executor/execMain.c:1731 #, c-format msgid "null value in column \"%s\" violates not-null constraint" msgstr "valori null nella colonna \"%s\" violano il vincolo non-null" -#: executor/execMain.c:1723 executor/execMain.c:1749 executor/execMain.c:1838 +#: executor/execMain.c:1733 executor/execMain.c:1759 executor/execMain.c:1848 #, c-format msgid "Failing row contains %s." msgstr "La riga in errore contiene %s." -#: executor/execMain.c:1747 +#: executor/execMain.c:1757 #, c-format msgid "new row for relation \"%s\" violates check constraint \"%s\"" msgstr "la nuova riga per la relazione \"%s\" viola il vincolo di controllo \"%s\"" -#: executor/execMain.c:1836 +#: executor/execMain.c:1846 #, c-format msgid "new row violates check option for view \"%s\"" msgstr "la nuova riga viola l'opzione di controllo della vista \"%s\"" -#: executor/execMain.c:1846 +#: executor/execMain.c:1856 #, c-format msgid "new row violates row-level security policy \"%s\" for table \"%s\"" msgstr "la nuova riga viola la regola di sicurezza per riga \"%s\" per la tabella \"%s\"" -#: executor/execMain.c:1851 +#: executor/execMain.c:1861 #, c-format msgid "new row violates row-level security policy for table \"%s\"" msgstr "la nuova riga viola la regola di sicurezza per riga per la tabella \"%s\"" -#: executor/execMain.c:1858 +#: executor/execMain.c:1868 #, c-format msgid "new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"" msgstr "la nuova riga viola la regola di sicurezza per riga \"%s\" (espressione USING) per la tabella \"%s\"" -#: executor/execMain.c:1863 +#: executor/execMain.c:1873 #, c-format msgid "new row violates row-level security policy (USING expression) for table \"%s\"" msgstr "la nuova riga viola la regola di sicurezza per riga (espressione USING) per la tabella \"%s\"" -#: executor/execQual.c:302 executor/execQual.c:339 executor/execQual.c:3213 -#: utils/adt/array_userfuncs.c:472 utils/adt/arrayfuncs.c:260 +#: executor/execQual.c:302 executor/execQual.c:339 executor/execQual.c:3236 +#: utils/adt/array_userfuncs.c:484 utils/adt/arrayfuncs.c:260 #: utils/adt/arrayfuncs.c:558 utils/adt/arrayfuncs.c:1288 -#: utils/adt/arrayfuncs.c:3361 utils/adt/arrayfuncs.c:5245 -#: utils/adt/arrayfuncs.c:5768 +#: utils/adt/arrayfuncs.c:3361 utils/adt/arrayfuncs.c:5241 +#: utils/adt/arrayfuncs.c:5758 #, c-format msgid "number of array dimensions (%d) exceeds the maximum allowed (%d)" msgstr "il numero di dimensioni dell'array (%d) eccede il massimo consentito (%d)" @@ -9957,12 +9975,12 @@ msgstr "il numero di dimensioni dell'array (%d) eccede il massimo consentito (%d msgid "array subscript in assignment must not be null" msgstr "l'indice di un array nell'assegnamento non può essere nullo" -#: executor/execQual.c:657 executor/execQual.c:4138 +#: executor/execQual.c:657 executor/execQual.c:4183 #, c-format msgid "attribute %d has wrong type" msgstr "l'attributo %d è di tipo errato" -#: executor/execQual.c:658 executor/execQual.c:4139 +#: executor/execQual.c:658 executor/execQual.c:4184 #, c-format msgid "Table has type %s, but query expects %s." msgstr "La tabella ha il tipo %s, ma la query prevede %s." @@ -9992,7 +10010,7 @@ msgid "Physical storage mismatch on dropped attribute at ordinal position %d." msgstr "Il tipo di immagazzinamento fisico non corrisponde per l'attributo eliminato in posizione %d." #: executor/execQual.c:1344 parser/parse_func.c:115 parser/parse_func.c:542 -#: parser/parse_func.c:895 +#: parser/parse_func.c:897 #, c-format msgid "cannot pass more than %d argument to a function" msgid_plural "cannot pass more than %d arguments to a function" @@ -10026,98 +10044,93 @@ msgstr[1] "La riga restituita contiene %d attributi, ma la query ne prevede %d." msgid "Returned type %s at ordinal position %d, but query expects %s." msgstr "Tipo %s restituito in posizione %d, ma la query prevede %s." -#: executor/execQual.c:1897 executor/execQual.c:2328 +#: executor/execQual.c:1897 executor/execQual.c:2335 #, c-format msgid "table-function protocol for materialize mode was not followed" msgstr "il protocollo tabella-funzione del modo di materializzazione non è stato seguito" -#: executor/execQual.c:1917 executor/execQual.c:2335 +#: executor/execQual.c:1917 executor/execQual.c:2342 #, c-format msgid "unrecognized table-function returnMode: %d" msgstr "returnMode tabella-funzione sconosciuto: %d" -#: executor/execQual.c:2245 -#, c-format -msgid "function returning set of rows cannot return null value" -msgstr "una funzione che restituisce un insieme di righe non può restituire un valore null" - -#: executor/execQual.c:2302 +#: executor/execQual.c:2287 #, c-format msgid "rows returned by function are not all of the same row type" msgstr "le righe restituite dalla funzione non sono tutte dello stesso tipo" -#: executor/execQual.c:2517 +#: executor/execQual.c:2522 #, c-format msgid "IS DISTINCT FROM does not support set arguments" msgstr "IS DISTINCT FROM non supporta argomenti di tipo insieme" -#: executor/execQual.c:2594 +#: executor/execQual.c:2599 #, c-format msgid "op ANY/ALL (array) does not support set arguments" msgstr "l'operatore ANY/ALL (array) non supporta argomenti di tipo insieme" -#: executor/execQual.c:3191 +#: executor/execQual.c:3214 #, c-format msgid "cannot merge incompatible arrays" msgstr "non è possibile unire array non compatibili" -#: executor/execQual.c:3192 +#: executor/execQual.c:3215 #, c-format msgid "Array with element type %s cannot be included in ARRAY construct with element type %s." msgstr "Un array con tipo di elementi %s non può essere incluso nel costrutto ARRAY con elementi di tipo %s." -#: executor/execQual.c:3233 executor/execQual.c:3260 +#: executor/execQual.c:3256 executor/execQual.c:3283 #, c-format msgid "multidimensional arrays must have array expressions with matching dimensions" msgstr "gli array multidimensionali devono avere espressioni array di dimensioni corrispondenti" -#: executor/execQual.c:3775 +#: executor/execQual.c:3798 #, c-format msgid "NULLIF does not support set arguments" msgstr "NULLIF non supporta argomenti di tipo insieme" -#: executor/execQual.c:4008 utils/adt/domains.c:136 +#: executor/execQual.c:4046 utils/adt/domains.c:137 #, c-format msgid "domain %s does not allow null values" msgstr "il DOMAIN %s non consente valori nulli" -#: executor/execQual.c:4038 utils/adt/domains.c:173 +#: executor/execQual.c:4083 utils/adt/domains.c:179 #, c-format msgid "value for domain %s violates check constraint \"%s\"" msgstr "il valore per il DOMAIN %s viola il vincolo di controllo \"%s\"" -#: executor/execQual.c:4393 +#: executor/execQual.c:4438 #, c-format msgid "WHERE CURRENT OF is not supported for this table type" msgstr "WHERE CURRENT OF non è supportato per questo tipo di tabella" -#: executor/execQual.c:4590 parser/parse_agg.c:743 +#: executor/execQual.c:4627 parser/parse_agg.c:758 #, c-format msgid "window function calls cannot be nested" msgstr "le chiamate a funzioni finestra non possono essere annidate" -#: executor/execQual.c:4802 +#: executor/execQual.c:4839 #, c-format msgid "target type is not an array" msgstr "il tipo di destinazione non è un array" -#: executor/execQual.c:4917 +#: executor/execQual.c:4956 #, c-format msgid "ROW() column has type %s instead of type %s" msgstr "la colonna ROW() è di tipo %s invece di %s" -#: executor/execQual.c:5052 utils/adt/arrayfuncs.c:3803 -#: utils/adt/arrayfuncs.c:6341 utils/adt/rowtypes.c:927 +#: executor/execQual.c:5091 utils/adt/arrayfuncs.c:3803 +#: utils/adt/arrayfuncs.c:6325 utils/adt/rowtypes.c:927 #, c-format msgid "could not identify a comparison function for type %s" msgstr "non è stato possibile trovare un operatore di confronto per il tipo %s" -#: executor/execUtils.c:819 +#: executor/execUtils.c:813 #, c-format msgid "materialized view \"%s\" has not been populated" msgstr "la vista materializzata \"%s\" non è stata popolata" -#: executor/execUtils.c:821 +#: executor/execUtils.c:815 #, c-format msgid "Use the REFRESH MATERIALIZED VIEW command." msgstr "Usa il comando REFRESH MATERIALIZED VIEW." @@ -10127,86 +10140,91 @@ msgstr "Usa il comando REFRESH MATERIALIZED VIEW." msgid "could not determine actual type of argument declared %s" msgstr "non è stato possibile determinare il tipo reale dell'argomento dichiarato %s" +#: executor/functions.c:511 +#, c-format +msgid "cannot COPY to/from client in a SQL function" +msgstr "non è possibile usare COPY da o verso il client in una funzione SQL" + #. translator: %s is a SQL statement name -#: executor/functions.c:508 +#: executor/functions.c:517 #, c-format msgid "%s is not allowed in a SQL function" msgstr "%s non è consentito in una funzione SQL" #. translator: %s is a SQL statement name -#: executor/functions.c:515 executor/spi.c:1368 executor/spi.c:2158 +#: executor/functions.c:524 executor/spi.c:1364 executor/spi.c:2154 #, c-format msgid "%s is not allowed in a non-volatile function" msgstr "%s non è consentito in una funzione non volatile" -#: executor/functions.c:643 +#: executor/functions.c:650 #, c-format msgid "could not determine actual result type for function declared to return type %s" msgstr "non è stato possibile determinare il tipo reale restituito dalla funzione dichiarata con tipo restituito %s" -#: executor/functions.c:1408 +#: executor/functions.c:1415 #, c-format msgid "SQL function \"%s\" statement %d" msgstr "funzione SQL \"%s\" istruzione %d" -#: executor/functions.c:1434 +#: executor/functions.c:1441 #, c-format msgid "SQL function \"%s\" during startup" msgstr "funzione SQL \"%s\" durante l'avvio" -#: executor/functions.c:1593 executor/functions.c:1630 -#: executor/functions.c:1642 executor/functions.c:1755 -#: executor/functions.c:1788 executor/functions.c:1818 +#: executor/functions.c:1600 executor/functions.c:1637 +#: executor/functions.c:1649 executor/functions.c:1762 +#: executor/functions.c:1795 executor/functions.c:1825 #, c-format msgid "return type mismatch in function declared to return %s" msgstr "il tipo restituito non combacia nella funzione dichiarata con tipo restituito %s" -#: executor/functions.c:1595 +#: executor/functions.c:1602 #, c-format msgid "Function's final statement must be SELECT or INSERT/UPDATE/DELETE RETURNING." msgstr "L'istruzione finale della funzione deve essere SELECT oppure INSERT/UPDATE/DELETE RETURNING." -#: executor/functions.c:1632 +#: executor/functions.c:1639 #, c-format msgid "Final statement must return exactly one column." msgstr "L'istruzione finale deve restituire esattamente una colonna." -#: executor/functions.c:1644 +#: executor/functions.c:1651 #, c-format msgid "Actual return type is %s." msgstr "Il tipo restituito realmente è %s." -#: executor/functions.c:1757 +#: executor/functions.c:1764 #, c-format msgid "Final statement returns too many columns." msgstr "L'istruzione finale restituisce troppe colonne." -#: executor/functions.c:1790 +#: executor/functions.c:1797 #, c-format msgid "Final statement returns %s instead of %s at column %d." msgstr "L'istruzione finale restituisce %s invece di %s alla colonna %d." -#: executor/functions.c:1820 +#: executor/functions.c:1827 #, c-format msgid "Final statement returns too few columns." msgstr "L'istruzione finale restituisce troppe poche colonne." -#: executor/functions.c:1869 +#: executor/functions.c:1876 #, c-format msgid "return type %s is not supported for SQL functions" msgstr "il tipo di risultato %s non è supportato per le funzioni SQL" -#: executor/nodeAgg.c:3011 +#: executor/nodeAgg.c:3038 #, c-format -msgid "combine function for aggregate %u must to be declared as strict" -msgstr "la funzione di combinazione per l'aggregato %u deve essere dichiarata strict" +msgid "combine function for aggregate %u must be declared as STRICT" +msgstr "la funzione di combinazione per l'aggregato %u deve essere dichiarata STRICT" -#: executor/nodeAgg.c:3055 executor/nodeWindowAgg.c:2289 +#: executor/nodeAgg.c:3083 executor/nodeWindowAgg.c:2318 #, c-format msgid "aggregate %u needs to have compatible input type and transition type" msgstr "l'aggregato %u deve avere tipi di input e transizione compatibili" -#: executor/nodeAgg.c:3127 parser/parse_agg.c:597 parser/parse_agg.c:627 +#: executor/nodeAgg.c:3149 parser/parse_agg.c:612 parser/parse_agg.c:642 #, c-format msgid "aggregate function calls cannot be nested" msgstr "le chiamate a funzioni di aggregazione non possono essere annidate" @@ -10271,12 +10289,12 @@ msgstr "La query produce un valore per una colonna eliminata in posizione %d." msgid "Query has too few columns." msgstr "La query ha troppe poche colonne." -#: executor/nodeModifyTable.c:1117 +#: executor/nodeModifyTable.c:1132 #, c-format msgid "ON CONFLICT DO UPDATE command cannot affect row a second time" msgstr "il comando ON CONFLICT DO UPDATE non può toccare le righe una seconda volta" -#: executor/nodeModifyTable.c:1118 +#: executor/nodeModifyTable.c:1133 #, c-format msgid "Ensure that no rows proposed for insertion within the same command have duplicate constrained values." msgstr "Assicurati che non ci siano righe proposte per l'inserimento nello stesso comando che abbiano valori vincolati uguali." @@ -10292,7 +10310,7 @@ msgid "TABLESAMPLE REPEATABLE parameter cannot be null" msgstr "il parametro TABLESAMPLE REPEATABLE non può essere null" #: executor/nodeSubplan.c:345 executor/nodeSubplan.c:384 -#: executor/nodeSubplan.c:1040 +#: executor/nodeSubplan.c:1036 #, c-format msgid "more than one row returned by a subquery used as an expression" msgstr "più di una riga restituita da una sottoquery usata come espressione" @@ -10302,58 +10320,58 @@ msgstr "più di una riga restituita da una sottoquery usata come espressione" msgid "moving-aggregate transition function must not return null" msgstr "le funzioni di transizione per aggregati mobili non possono restituire null" -#: executor/nodeWindowAgg.c:1609 +#: executor/nodeWindowAgg.c:1642 #, c-format msgid "frame starting offset must not be null" msgstr "l'offset di inizio della finestra dev'essere non nullo" -#: executor/nodeWindowAgg.c:1622 +#: executor/nodeWindowAgg.c:1655 #, c-format msgid "frame starting offset must not be negative" msgstr "l'offset di inizio della finestra non può essere negativo" -#: executor/nodeWindowAgg.c:1635 +#: executor/nodeWindowAgg.c:1668 #, c-format msgid "frame ending offset must not be null" msgstr "l'offset di fine della finestra dev'essere non nullo" -#: executor/nodeWindowAgg.c:1648 +#: executor/nodeWindowAgg.c:1681 #, c-format msgid "frame ending offset must not be negative" msgstr "l'offset di fine della finestra non può essere negativo" -#: executor/spi.c:214 +#: executor/spi.c:210 #, c-format msgid "transaction left non-empty SPI stack" msgstr "la transazione ha lasciato lo stack SPI non vuoto" -#: executor/spi.c:215 executor/spi.c:279 +#: executor/spi.c:211 executor/spi.c:275 #, c-format msgid "Check for missing \"SPI_finish\" calls." msgstr "Verifica che non ci siano chiamate \"SPI_finish\" mancanti." -#: executor/spi.c:278 +#: executor/spi.c:274 #, c-format msgid "subtransaction left non-empty SPI stack" msgstr "la sottotransazione ha lasciato lo stack SPI non vuoto" -#: executor/spi.c:1229 +#: executor/spi.c:1225 #, c-format msgid "cannot open multi-query plan as cursor" msgstr "non è possibile aprire un piano multi-query come cursore" #. translator: %s is name of a SQL command, eg INSERT -#: executor/spi.c:1234 +#: executor/spi.c:1230 #, c-format msgid "cannot open %s query as cursor" msgstr "non è possibile aprire una query %s come cursore" -#: executor/spi.c:1342 +#: executor/spi.c:1338 #, c-format msgid "DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE is not supported" msgstr "DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE non è supportato" -#: executor/spi.c:1343 parser/analyze.c:2292 +#: executor/spi.c:1339 parser/analyze.c:2360 #, c-format msgid "Scrollable cursors must be READ ONLY." msgstr "Un cursore scorribile dev'essere READ ONLY." @@ -10363,17 +10381,22 @@ msgstr "Un cursore scorribile dev'essere READ ONLY." msgid "SQL statement \"%s\"" msgstr "istruzione SQL \"%s\"" -#: foreign/foreign.c:314 +#: executor/tqueue.c:317 +#, c-format +msgid "could not send tuple to shared-memory queue" +msgstr "invio delle tuple alla coda in memoria condivisa fallito" + +#: foreign/foreign.c:192 #, c-format msgid "user mapping not found for \"%s\"" msgstr "mappatura utenti non trovata per \"%s\"" -#: foreign/foreign.c:750 +#: foreign/foreign.c:644 #, c-format msgid "invalid option \"%s\"" msgstr "opzione \"%s\" non valida" -#: foreign/foreign.c:751 +#: foreign/foreign.c:645 #, c-format msgid "Valid options in this context are: %s" msgstr "Le opzioni valide in questo contesto sono: %s" @@ -10383,710 +10406,710 @@ msgstr "Le opzioni valide in questo contesto sono: %s" msgid "Cannot enlarge string buffer containing %d bytes by %d more bytes." msgstr "Non è possibile aumentare il buffer della stringa contenente %d byte di altri %d byte." -#: libpq/auth.c:251 +#: libpq/auth.c:254 #, c-format msgid "authentication failed for user \"%s\": host rejected" msgstr "autenticazione fallita per l'utente \"%s\": host rifiutato" -#: libpq/auth.c:254 +#: libpq/auth.c:257 #, c-format msgid "\"trust\" authentication failed for user \"%s\"" msgstr "autenticazione \"trust\" fallita per l'utente \"%s\"" -#: libpq/auth.c:257 +#: libpq/auth.c:260 #, c-format msgid "Ident authentication failed for user \"%s\"" msgstr "autenticazione Ident fallita per l'utente \"%s\"" -#: libpq/auth.c:260 +#: libpq/auth.c:263 #, c-format msgid "Peer authentication failed for user \"%s\"" msgstr "autenticazione Peer fallita per l'utente \"%s\"" -#: libpq/auth.c:264 +#: libpq/auth.c:267 #, c-format msgid "password authentication failed for user \"%s\"" msgstr "autenticazione con password fallita per l'utente \"%s\"" -#: libpq/auth.c:269 +#: libpq/auth.c:272 #, c-format msgid "GSSAPI authentication failed for user \"%s\"" msgstr "autenticazione GSSAPI fallita per l'utente \"%s\"" -#: libpq/auth.c:272 +#: libpq/auth.c:275 #, c-format msgid "SSPI authentication failed for user \"%s\"" msgstr "autenticazione SSPI fallita per l'utente \"%s\"" -#: libpq/auth.c:275 +#: libpq/auth.c:278 #, c-format msgid "PAM authentication failed for user \"%s\"" msgstr "autenticazione PAM fallita per l'utente \"%s\"" -#: libpq/auth.c:278 +#: libpq/auth.c:281 #, c-format msgid "BSD authentication failed for user \"%s\"" msgstr "autenticazione BSD fallita per l'utente \"%s\"" -#: libpq/auth.c:281 +#: libpq/auth.c:284 #, c-format msgid "LDAP authentication failed for user \"%s\"" msgstr "autenticazione LDAP fallita per l'utente \"%s\"" -#: libpq/auth.c:284 +#: libpq/auth.c:287 #, c-format msgid "certificate authentication failed for user \"%s\"" msgstr "autenticazione con certificato fallita per l'utente \"%s\"" -#: libpq/auth.c:287 +#: libpq/auth.c:290 #, c-format msgid "RADIUS authentication failed for user \"%s\"" msgstr "autenticazione RADIUS fallita per l'utente \"%s\"" -#: libpq/auth.c:290 +#: libpq/auth.c:293 #, c-format msgid "authentication failed for user \"%s\": invalid authentication method" msgstr "autenticazione fallita per l'utente \"%s\": metodo di autenticazione non valido" -#: libpq/auth.c:294 +#: libpq/auth.c:297 #, c-format msgid "Connection matched pg_hba.conf line %d: \"%s\"" msgstr "La connessione si abbina con la riga %d di pg_hba.log: \"%s\"" -#: libpq/auth.c:349 +#: libpq/auth.c:352 #, c-format msgid "connection requires a valid client certificate" msgstr "la connessione richiede un certificato valido per il client" -#: libpq/auth.c:391 +#: libpq/auth.c:394 #, c-format msgid "pg_hba.conf rejects replication connection for host \"%s\", user \"%s\", %s" msgstr "pg_hba.conf rifiuta connessioni di replica per l'host \"%s\", utente \"%s\", %s" -#: libpq/auth.c:393 libpq/auth.c:409 libpq/auth.c:467 libpq/auth.c:485 +#: libpq/auth.c:396 libpq/auth.c:412 libpq/auth.c:470 libpq/auth.c:488 msgid "SSL off" msgstr "SSL non abilitato" -#: libpq/auth.c:393 libpq/auth.c:409 libpq/auth.c:467 libpq/auth.c:485 +#: libpq/auth.c:396 libpq/auth.c:412 libpq/auth.c:470 libpq/auth.c:488 msgid "SSL on" msgstr "SSL abilitato" -#: libpq/auth.c:397 +#: libpq/auth.c:400 #, c-format msgid "pg_hba.conf rejects replication connection for host \"%s\", user \"%s\"" msgstr "pg_hba.conf rifiuta connessioni di replica per l'host \"%s\", utente \"%s\"" -#: libpq/auth.c:406 +#: libpq/auth.c:409 #, c-format msgid "pg_hba.conf rejects connection for host \"%s\", user \"%s\", database \"%s\", %s" msgstr "pg_hba.conf rifiuta connessioni per l'host \"%s\", utente \"%s\", database \"%s\", %s" -#: libpq/auth.c:413 +#: libpq/auth.c:416 #, c-format msgid "pg_hba.conf rejects connection for host \"%s\", user \"%s\", database \"%s\"" msgstr "pg_hba.conf rifiuta connessioni per l'host \"%s\", user \"%s\", database \"%s\"" -#: libpq/auth.c:442 +#: libpq/auth.c:445 #, c-format msgid "Client IP address resolved to \"%s\", forward lookup matches." msgstr "Indirizzo IP del client risolto in \"%s\", il forward lookup combacia." -#: libpq/auth.c:445 +#: libpq/auth.c:448 #, c-format msgid "Client IP address resolved to \"%s\", forward lookup not checked." msgstr "Indirizzo IP del client risolto in \"%s\", forward lookup non controllato." -#: libpq/auth.c:448 +#: libpq/auth.c:451 #, c-format msgid "Client IP address resolved to \"%s\", forward lookup does not match." msgstr "Indirizzo IP del client risolto in \"%s\", il forward lookup non combacia." -#: libpq/auth.c:451 +#: libpq/auth.c:454 #, c-format msgid "Could not translate client host name \"%s\" to IP address: %s." msgstr "Conversione del nome host \"%s\" in indirizzo IP non riuscita: %s." -#: libpq/auth.c:456 +#: libpq/auth.c:459 #, c-format msgid "Could not resolve client IP address to a host name: %s." msgstr "Risoluzione dell'indirizzo IP del client in nome host non riuscita: %s." -#: libpq/auth.c:465 +#: libpq/auth.c:468 #, c-format msgid "no pg_hba.conf entry for replication connection from host \"%s\", user \"%s\", %s" msgstr "nessuna voce in pg_hba.conf per connessioni di replica da host \"%s\", utente \"%s\", database \"%s\"" -#: libpq/auth.c:472 +#: libpq/auth.c:475 #, c-format msgid "no pg_hba.conf entry for replication connection from host \"%s\", user \"%s\"" msgstr "nessuna voce in pg_hba.conf per connessioni di replica da host \"%s\", user \"%s\"" -#: libpq/auth.c:482 +#: libpq/auth.c:485 #, c-format msgid "no pg_hba.conf entry for host \"%s\", user \"%s\", database \"%s\", %s" msgstr "nessuna voce in pg_hba.conf per l'host \"%s\", utente \"%s\", database \"%s\", %s" -#: libpq/auth.c:490 +#: libpq/auth.c:493 #, c-format msgid "no pg_hba.conf entry for host \"%s\", user \"%s\", database \"%s\"" msgstr "nessuna voce in pg_hba.conf per l'host \"%s\", utente \"%s\", database \"%s\"" -#: libpq/auth.c:533 libpq/hba.c:1180 +#: libpq/auth.c:536 libpq/hba.c:1178 #, c-format msgid "MD5 authentication is not supported when \"db_user_namespace\" is enabled" msgstr "l'autenticazione MD5 non è supportata quando \"db_user_namespace\" è abilitato" -#: libpq/auth.c:667 +#: libpq/auth.c:670 #, c-format msgid "expected password response, got message type %d" msgstr "era attesa una risposta password, ricevuto messaggio di tipo %d" -#: libpq/auth.c:695 +#: libpq/auth.c:698 #, c-format msgid "invalid password packet size" msgstr "dimensione del pacchetto password non valida" -#: libpq/auth.c:825 +#: libpq/auth.c:828 #, c-format msgid "GSSAPI is not supported in protocol version 2" msgstr "GSSAPI non è supportato con la versione 2 del protocollo" -#: libpq/auth.c:885 +#: libpq/auth.c:888 #, c-format msgid "expected GSS response, got message type %d" msgstr "era attesa una risposta GSS, ricevuto messaggio di tipo %d" -#: libpq/auth.c:946 +#: libpq/auth.c:949 msgid "accepting GSS security context failed" msgstr "contesto di sicurezza accettazione GSS fallito" -#: libpq/auth.c:972 +#: libpq/auth.c:975 msgid "retrieving GSS user name failed" msgstr "la richiesta del GSS user name è fallita" -#: libpq/auth.c:1091 +#: libpq/auth.c:1094 #, c-format msgid "SSPI is not supported in protocol version 2" msgstr "SSPI non è supportato con la versione 2 del protocollo" -#: libpq/auth.c:1106 +#: libpq/auth.c:1109 msgid "could not acquire SSPI credentials" msgstr "non è stato possibile ottenere le credenziali SSPI" -#: libpq/auth.c:1124 +#: libpq/auth.c:1127 #, c-format msgid "expected SSPI response, got message type %d" msgstr "era attesa una risposta SSPI, ricevuto messaggio di tipo %d" -#: libpq/auth.c:1196 +#: libpq/auth.c:1199 msgid "could not accept SSPI security context" msgstr "non è stato possibile accettare il contesto di sicurezza SSPI" -#: libpq/auth.c:1258 +#: libpq/auth.c:1261 msgid "could not get token from SSPI security context" msgstr "non è stato possibile ottenere il token dal contesto di sicurezza SSPI" -#: libpq/auth.c:1377 libpq/auth.c:1396 +#: libpq/auth.c:1380 libpq/auth.c:1399 #, c-format msgid "could not translate name" msgstr "non è stato possibile tradurre il nome" -#: libpq/auth.c:1409 +#: libpq/auth.c:1412 #, c-format msgid "realm name too long" msgstr "nome di realm troppo lungo" -#: libpq/auth.c:1424 +#: libpq/auth.c:1427 #, c-format msgid "translated account name too long" msgstr "nome di account tradotto troppo lungo" -#: libpq/auth.c:1610 +#: libpq/auth.c:1613 #, c-format msgid "could not create socket for Ident connection: %m" msgstr "creazione del socket per la connessione Ident fallita: %m" -#: libpq/auth.c:1625 +#: libpq/auth.c:1628 #, c-format msgid "could not bind to local address \"%s\": %m" msgstr "bind sull'indirizzo locale \"%s\" fallito: %m" -#: libpq/auth.c:1637 +#: libpq/auth.c:1640 #, c-format msgid "could not connect to Ident server at address \"%s\", port %s: %m" msgstr "connessione al server Ident all'indirizzo \"%s\", porta %s fallita: %m" -#: libpq/auth.c:1659 +#: libpq/auth.c:1662 #, c-format msgid "could not send query to Ident server at address \"%s\", port %s: %m" msgstr "invio della query al server Ident all'indirizzo \"%s\", porta %s fallito: %m" -#: libpq/auth.c:1676 +#: libpq/auth.c:1679 #, c-format msgid "could not receive response from Ident server at address \"%s\", port %s: %m" msgstr "ricezione della risposta dal server Ident all'indirizzo \"%s\", porta %s fallita: %m" -#: libpq/auth.c:1686 +#: libpq/auth.c:1689 #, c-format msgid "invalidly formatted response from Ident server: \"%s\"" msgstr "risposta dal server Ident formattata in maniera non corretta: \"%s\"" -#: libpq/auth.c:1726 +#: libpq/auth.c:1729 #, c-format msgid "peer authentication is not supported on this platform" msgstr "il metodo di autenticazione peer non è supportato su questa piattaforma" -#: libpq/auth.c:1730 +#: libpq/auth.c:1733 #, c-format msgid "could not get peer credentials: %m" msgstr "non è stato possibile recuperare le credenziali del peer: %m" -#: libpq/auth.c:1739 +#: libpq/auth.c:1742 #, c-format msgid "could not look up local user ID %ld: %s" msgstr "ricerca dell'ID utente locale %ld fallita: %s" -#: libpq/auth.c:1823 libpq/auth.c:2149 libpq/auth.c:2509 +#: libpq/auth.c:1826 libpq/auth.c:2152 libpq/auth.c:2512 #, c-format msgid "empty password returned by client" msgstr "il client ha restituito una password vuota" -#: libpq/auth.c:1833 +#: libpq/auth.c:1836 #, c-format msgid "error from underlying PAM layer: %s" msgstr "errore dal livello PAM sottostante: %s" -#: libpq/auth.c:1914 +#: libpq/auth.c:1917 #, c-format msgid "could not create PAM authenticator: %s" msgstr "creazione dell'autenticatore PAM fallita: %s" -#: libpq/auth.c:1925 +#: libpq/auth.c:1928 #, c-format msgid "pam_set_item(PAM_USER) failed: %s" msgstr "pam_set_item(PAM_USER) fallita: %s" -#: libpq/auth.c:1936 +#: libpq/auth.c:1939 #, c-format msgid "pam_set_item(PAM_RHOST) failed: %s" msgstr "pam_set_item(PAM_RHOST) fallita: %s" -#: libpq/auth.c:1947 +#: libpq/auth.c:1950 #, c-format msgid "pam_set_item(PAM_CONV) failed: %s" msgstr "pam_set_item(PAM_CONV) fallita: %s" -#: libpq/auth.c:1958 +#: libpq/auth.c:1961 #, c-format msgid "pam_authenticate failed: %s" msgstr "pam_authenticate fallita: %s" -#: libpq/auth.c:1969 +#: libpq/auth.c:1972 #, c-format msgid "pam_acct_mgmt failed: %s" msgstr "pam_acct_mgmt fallita: %s" -#: libpq/auth.c:1980 +#: libpq/auth.c:1983 #, c-format msgid "could not release PAM authenticator: %s" msgstr "rilascio dell'autenticatore PAM fallito: %s" -#: libpq/auth.c:2045 +#: libpq/auth.c:2048 #, c-format msgid "could not initialize LDAP: %m" msgstr "inizializzazione LDAP fallita: %m" -#: libpq/auth.c:2048 +#: libpq/auth.c:2051 #, c-format msgid "could not initialize LDAP: error code %d" msgstr "inizializzazione LDAP fallita: codice errore %d" -#: libpq/auth.c:2058 +#: libpq/auth.c:2061 #, c-format msgid "could not set LDAP protocol version: %s" msgstr "impostazione della versione del protocollo LDAP fallita: %s" -#: libpq/auth.c:2087 +#: libpq/auth.c:2090 #, c-format msgid "could not load wldap32.dll" msgstr "caricamento wldap32.dll fallito" -#: libpq/auth.c:2095 +#: libpq/auth.c:2098 #, c-format msgid "could not load function _ldap_start_tls_sA in wldap32.dll" msgstr "caricamento della funzione _ldap_start_tls_sA in wldap32.dll fallito" -#: libpq/auth.c:2096 +#: libpq/auth.c:2099 #, c-format msgid "LDAP over SSL is not supported on this platform." msgstr "LDAP su SSL non è supportato su questa piattaforma." -#: libpq/auth.c:2111 +#: libpq/auth.c:2114 #, c-format msgid "could not start LDAP TLS session: %s" msgstr "avvio della sessione TLS LDAP fallito: %s" -#: libpq/auth.c:2133 +#: libpq/auth.c:2136 #, c-format msgid "LDAP server not specified" msgstr "server LDAP non specificato" -#: libpq/auth.c:2186 +#: libpq/auth.c:2189 #, c-format msgid "invalid character in user name for LDAP authentication" msgstr "carattere non valido nel nome utente per l'autenticazione LDAP" -#: libpq/auth.c:2201 +#: libpq/auth.c:2204 #, c-format msgid "could not perform initial LDAP bind for ldapbinddn \"%s\" on server \"%s\": %s" msgstr "bind iniziale LDAP fallito per ldapbinddn \"%s\" sul server \"%s\": %s" -#: libpq/auth.c:2225 +#: libpq/auth.c:2228 #, c-format msgid "could not search LDAP for filter \"%s\" on server \"%s\": %s" msgstr "ricerca in LDAP del filtro \"%s\" sul server \"%s\" fallita: %s" -#: libpq/auth.c:2236 +#: libpq/auth.c:2239 #, c-format msgid "LDAP user \"%s\" does not exist" msgstr "l'utente LDAP \"%s\" non esiste" -#: libpq/auth.c:2237 +#: libpq/auth.c:2240 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned no entries." msgstr "La ricerca LDAP del filtro \"%s\" sul server \"%s\" non ha restituito risultati." -#: libpq/auth.c:2241 +#: libpq/auth.c:2244 #, c-format msgid "LDAP user \"%s\" is not unique" msgstr "L'utente LDAP \"%s\" non è unico" -#: libpq/auth.c:2242 +#: libpq/auth.c:2245 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned %d entry." msgid_plural "LDAP search for filter \"%s\" on server \"%s\" returned %d entries." msgstr[0] "La ricerca LDAP del filtro \"%s\" sul server \"%s\" ha restituito %d risultato." msgstr[1] "La ricerca LDAP del filtro \"%s\" sul server \"%s\" ha restituito %d risultati." -#: libpq/auth.c:2260 +#: libpq/auth.c:2263 #, c-format msgid "could not get dn for the first entry matching \"%s\" on server \"%s\": %s" msgstr "dn per il primo risultato di \"%s\" non trovato sul server \"%s\": %s" -#: libpq/auth.c:2280 +#: libpq/auth.c:2283 #, c-format msgid "could not unbind after searching for user \"%s\" on server \"%s\": %s" msgstr "unbind fallito dopo aver cercato l'utente \"%s\" sul server \"%s\": %s" -#: libpq/auth.c:2310 +#: libpq/auth.c:2313 #, c-format msgid "LDAP login failed for user \"%s\" on server \"%s\": %s" msgstr "login LDAP fallito per l'utente \"%s\" sul server \"%s\": %s" -#: libpq/auth.c:2338 +#: libpq/auth.c:2341 #, c-format msgid "certificate authentication failed for user \"%s\": client certificate contains no user name" msgstr "autenticazione con certificato fallita per l'utente \"%s\": il certificato del client non contiene alcun nome utente" -#: libpq/auth.c:2465 +#: libpq/auth.c:2468 #, c-format msgid "RADIUS server not specified" msgstr "server RADIUS non specificato" -#: libpq/auth.c:2472 +#: libpq/auth.c:2475 #, c-format msgid "RADIUS secret not specified" msgstr "segreto RADIUS non specificato" -#: libpq/auth.c:2488 libpq/hba.c:1634 +#: libpq/auth.c:2491 libpq/hba.c:1632 #, c-format msgid "could not translate RADIUS server name \"%s\" to address: %s" msgstr "conversione del nome del server RADIUS \"%s\" in indirizzo fallita: %s" -#: libpq/auth.c:2516 +#: libpq/auth.c:2519 #, c-format msgid "RADIUS authentication does not support passwords longer than %d characters" msgstr "l'autenticazione RADIUS non supporta password più lunghe di %d caratteri" -#: libpq/auth.c:2528 +#: libpq/auth.c:2531 #, c-format msgid "could not generate random encryption vector" msgstr "generazione del vettore di criptaggio casuale fallita" -#: libpq/auth.c:2563 +#: libpq/auth.c:2569 #, c-format msgid "could not perform MD5 encryption of password" msgstr "criptaggio MD5 della password fallito" -#: libpq/auth.c:2588 +#: libpq/auth.c:2594 #, c-format msgid "could not create RADIUS socket: %m" msgstr "creazione del socket RADIUS fallita: %m" -#: libpq/auth.c:2609 +#: libpq/auth.c:2615 #, c-format msgid "could not bind local RADIUS socket: %m" msgstr "bind del socket RADIUS fallito: %m" -#: libpq/auth.c:2619 +#: libpq/auth.c:2625 #, c-format msgid "could not send RADIUS packet: %m" msgstr "invio del pacchetto RADIUS fallito: %m" -#: libpq/auth.c:2652 libpq/auth.c:2677 +#: libpq/auth.c:2658 libpq/auth.c:2683 #, c-format msgid "timeout waiting for RADIUS response" msgstr "tempo scaduto in attesa della risposta RADIUS" -#: libpq/auth.c:2670 +#: libpq/auth.c:2676 #, c-format msgid "could not check status on RADIUS socket: %m" msgstr "controllo dello stato sul socket RADIUS fallito: %m" -#: libpq/auth.c:2699 +#: libpq/auth.c:2705 #, c-format msgid "could not read RADIUS response: %m" msgstr "lettura della risposta RADIUS fallita: %m" -#: libpq/auth.c:2711 libpq/auth.c:2715 +#: libpq/auth.c:2717 libpq/auth.c:2721 #, c-format msgid "RADIUS response was sent from incorrect port: %d" msgstr "la risposta RADIUS è stata inviata da una porta sbagliata: %d" -#: libpq/auth.c:2724 +#: libpq/auth.c:2730 #, c-format msgid "RADIUS response too short: %d" msgstr "risposta RADIUS troppo breve: %d" -#: libpq/auth.c:2731 +#: libpq/auth.c:2737 #, c-format msgid "RADIUS response has corrupt length: %d (actual length %d)" msgstr "la risposta RADIUS ha una lunghezza corrotta: %d (lunghezza reale %d)" -#: libpq/auth.c:2739 +#: libpq/auth.c:2745 #, c-format msgid "RADIUS response is to a different request: %d (should be %d)" msgstr "la risposta RADIUS è a una richiesta differente: %d (dovrebbe essere %d)" -#: libpq/auth.c:2764 +#: libpq/auth.c:2770 #, c-format msgid "could not perform MD5 encryption of received packet" msgstr "criptaggio MD5 dei pacchetti ricevuti fallito" -#: libpq/auth.c:2773 +#: libpq/auth.c:2779 #, c-format msgid "RADIUS response has incorrect MD5 signature" msgstr "la firma MD5 della risposta RADIUS non è corretta" -#: libpq/auth.c:2790 +#: libpq/auth.c:2796 #, c-format msgid "RADIUS response has invalid code (%d) for user \"%s\"" msgstr "il codice della risposta RADIUS (%d) per l'utente \"%s\" non è corretto" -#: libpq/be-fsstubs.c:134 libpq/be-fsstubs.c:165 libpq/be-fsstubs.c:199 -#: libpq/be-fsstubs.c:239 libpq/be-fsstubs.c:264 libpq/be-fsstubs.c:312 -#: libpq/be-fsstubs.c:335 libpq/be-fsstubs.c:583 +#: libpq/be-fsstubs.c:132 libpq/be-fsstubs.c:163 libpq/be-fsstubs.c:197 +#: libpq/be-fsstubs.c:237 libpq/be-fsstubs.c:262 libpq/be-fsstubs.c:310 +#: libpq/be-fsstubs.c:333 libpq/be-fsstubs.c:581 #, c-format msgid "invalid large-object descriptor: %d" msgstr "descrittore di large object non valido: %d" -#: libpq/be-fsstubs.c:180 libpq/be-fsstubs.c:218 libpq/be-fsstubs.c:602 -#: libpq/be-fsstubs.c:790 +#: libpq/be-fsstubs.c:178 libpq/be-fsstubs.c:216 libpq/be-fsstubs.c:600 +#: libpq/be-fsstubs.c:788 #, c-format msgid "permission denied for large object %u" msgstr "permesso per il large object %u negato" -#: libpq/be-fsstubs.c:205 libpq/be-fsstubs.c:589 +#: libpq/be-fsstubs.c:203 libpq/be-fsstubs.c:587 #, c-format msgid "large object descriptor %d was not opened for writing" msgstr "il descrittore per il large object %d non era aperto in scrittura" -#: libpq/be-fsstubs.c:247 +#: libpq/be-fsstubs.c:245 #, c-format msgid "lo_lseek result out of range for large-object descriptor %d" msgstr "il risultato di lo_lseek è fuori dall'intervallo consentito per il descrittore di large object %d" -#: libpq/be-fsstubs.c:320 +#: libpq/be-fsstubs.c:318 #, c-format msgid "lo_tell result out of range for large-object descriptor %d" msgstr "il risultato di lo_tell è fuori dall'intervallo consentito per il descrittore di large object %d" -#: libpq/be-fsstubs.c:457 +#: libpq/be-fsstubs.c:455 #, c-format msgid "must be superuser to use server-side lo_import()" msgstr "solo un superutente può usare lo_import() lato server" -#: libpq/be-fsstubs.c:458 +#: libpq/be-fsstubs.c:456 #, c-format msgid "Anyone can use the client-side lo_import() provided by libpq." msgstr "Chiunque può invece usare lo_import() lato client fornito da libpq." -#: libpq/be-fsstubs.c:471 +#: libpq/be-fsstubs.c:469 #, c-format msgid "could not open server file \"%s\": %m" msgstr "apertura del file del server \"%s\" fallita: %m" -#: libpq/be-fsstubs.c:493 +#: libpq/be-fsstubs.c:491 #, c-format msgid "could not read server file \"%s\": %m" msgstr "lettura dal file del server \"%s\" fallita: %m" -#: libpq/be-fsstubs.c:523 +#: libpq/be-fsstubs.c:521 #, c-format msgid "must be superuser to use server-side lo_export()" msgstr "solo un superutente può usare lo_export() lato server" -#: libpq/be-fsstubs.c:524 +#: libpq/be-fsstubs.c:522 #, c-format msgid "Anyone can use the client-side lo_export() provided by libpq." msgstr "Chiunque può invece usare lo_export() lato client fornito da libpq." -#: libpq/be-fsstubs.c:549 +#: libpq/be-fsstubs.c:547 #, c-format msgid "could not create server file \"%s\": %m" msgstr "creazione del file del server \"%s\" fallita: %m" -#: libpq/be-fsstubs.c:561 +#: libpq/be-fsstubs.c:559 #, c-format msgid "could not write server file \"%s\": %m" msgstr "scrittura del file del server \"%s\" fallita: %m" -#: libpq/be-fsstubs.c:815 +#: libpq/be-fsstubs.c:813 #, c-format msgid "large object read request is too large" msgstr "la richiesta di lettura per il large object è troppo grande" -#: libpq/be-fsstubs.c:857 utils/adt/genfile.c:211 utils/adt/genfile.c:252 +#: libpq/be-fsstubs.c:855 utils/adt/genfile.c:211 utils/adt/genfile.c:252 #, c-format msgid "requested length cannot be negative" msgstr "la lunghezza richiesta non può essere negativa" -#: libpq/be-secure-openssl.c:184 +#: libpq/be-secure-openssl.c:189 #, c-format msgid "could not create SSL context: %s" msgstr "creazione del contesto SSL fallita: %s" -#: libpq/be-secure-openssl.c:200 +#: libpq/be-secure-openssl.c:205 #, c-format msgid "could not load server certificate file \"%s\": %s" msgstr "caricamento del file di certificato del server \"%s\" fallito: %s" -#: libpq/be-secure-openssl.c:206 +#: libpq/be-secure-openssl.c:211 #, c-format msgid "could not access private key file \"%s\": %m" msgstr "accesso fallito al file della chiave privata \"%s\": %m" -#: libpq/be-secure-openssl.c:212 +#: libpq/be-secure-openssl.c:217 #, c-format msgid "private key file \"%s\" is not a regular file" msgstr "il file di chiave privata \"%s\" non è un file regolare" -#: libpq/be-secure-openssl.c:224 +#: libpq/be-secure-openssl.c:229 #, c-format msgid "private key file \"%s\" must be owned by the database user or root" msgstr "il file di chiave privata \"%s\" deve essere di proprietà dell'utente del database o di root" -#: libpq/be-secure-openssl.c:244 +#: libpq/be-secure-openssl.c:249 #, c-format msgid "private key file \"%s\" has group or world access" msgstr "il file della chiave privata \"%s\" ha accesso al gruppo o a chiunque" -#: libpq/be-secure-openssl.c:246 +#: libpq/be-secure-openssl.c:251 #, c-format msgid "File must have permissions u=rw (0600) or less if owned by the database user, or permissions u=rw,g=r (0640) or less if owned by root." msgstr "Il file deve avere permesso u=rw (0600) o inferiore se di proprietà dell'utente database, o permesso u=rw,g=r (0640) o inferiore se di proprietà di root." -#: libpq/be-secure-openssl.c:253 +#: libpq/be-secure-openssl.c:258 #, c-format msgid "could not load private key file \"%s\": %s" msgstr "caricamento del file della chiave privata \"%s\" fallito: %s" -#: libpq/be-secure-openssl.c:258 +#: libpq/be-secure-openssl.c:263 #, c-format msgid "check of private key failed: %s" msgstr "controllo della chiave privata fallito: %s" -#: libpq/be-secure-openssl.c:287 +#: libpq/be-secure-openssl.c:292 #, c-format msgid "could not load root certificate file \"%s\": %s" msgstr "caricamento del file del certificato radice \"%s\" fallito: %s" -#: libpq/be-secure-openssl.c:311 +#: libpq/be-secure-openssl.c:316 #, c-format msgid "SSL certificate revocation list file \"%s\" ignored" msgstr "il file di lista di revoche di certificati SSL \"%s\" è stato ignorato" -#: libpq/be-secure-openssl.c:313 +#: libpq/be-secure-openssl.c:318 #, c-format msgid "SSL library does not support certificate revocation lists." msgstr "La libreria SSL non supporta le liste di revoca dei certificati." -#: libpq/be-secure-openssl.c:318 +#: libpq/be-secure-openssl.c:323 #, c-format msgid "could not load SSL certificate revocation list file \"%s\": %s" msgstr "caricamento del file di lista di revoche di certificati SSL \"%s\" fallito: %s" -#: libpq/be-secure-openssl.c:365 +#: libpq/be-secure-openssl.c:370 #, c-format msgid "could not initialize SSL connection: %s" msgstr "inizializzazione della connessione SSL fallita: %s" -#: libpq/be-secure-openssl.c:373 +#: libpq/be-secure-openssl.c:378 #, c-format msgid "could not set SSL socket: %s" msgstr "impostazione del socket SSL fallita: %s" -#: libpq/be-secure-openssl.c:427 +#: libpq/be-secure-openssl.c:432 #, c-format msgid "could not accept SSL connection: %m" msgstr "accettazione della connessione SSL fallita: %m" -#: libpq/be-secure-openssl.c:431 libpq/be-secure-openssl.c:442 +#: libpq/be-secure-openssl.c:436 libpq/be-secure-openssl.c:447 #, c-format msgid "could not accept SSL connection: EOF detected" msgstr "accettazione della connessione SSL fallita: fine file individuata" -#: libpq/be-secure-openssl.c:436 +#: libpq/be-secure-openssl.c:441 #, c-format msgid "could not accept SSL connection: %s" msgstr "accettazione della connessione SSL fallita: %s" -#: libpq/be-secure-openssl.c:447 libpq/be-secure-openssl.c:588 -#: libpq/be-secure-openssl.c:648 +#: libpq/be-secure-openssl.c:452 libpq/be-secure-openssl.c:593 +#: libpq/be-secure-openssl.c:653 #, c-format msgid "unrecognized SSL error code: %d" msgstr "codice di errore SSL sconosciuto: %d" -#: libpq/be-secure-openssl.c:491 +#: libpq/be-secure-openssl.c:496 #, c-format msgid "SSL certificate's common name contains embedded null" msgstr "Il nome comune del certificato SSL contiene un null" -#: libpq/be-secure-openssl.c:502 +#: libpq/be-secure-openssl.c:507 #, c-format msgid "SSL connection from \"%s\"" msgstr "connessione SSL da \"%s\"" -#: libpq/be-secure-openssl.c:579 libpq/be-secure-openssl.c:639 +#: libpq/be-secure-openssl.c:584 libpq/be-secure-openssl.c:644 #, c-format msgid "SSL error: %s" msgstr "errore SSL: %s" -#: libpq/be-secure-openssl.c:988 +#: libpq/be-secure-openssl.c:1055 #, c-format msgid "ECDH: unrecognized curve name: %s" msgstr "ECDH: nome della curva non riconosciuto: %s" -#: libpq/be-secure-openssl.c:993 +#: libpq/be-secure-openssl.c:1060 #, c-format msgid "ECDH: could not create key" msgstr "ECDH: chiave non creata" -#: libpq/be-secure-openssl.c:1017 +#: libpq/be-secure-openssl.c:1084 msgid "no SSL error reported" msgstr "nessun errore SSL riportato" -#: libpq/be-secure-openssl.c:1021 +#: libpq/be-secure-openssl.c:1088 #, c-format msgid "SSL error code %lu" msgstr "codice di errore SSL: %lu" @@ -11131,304 +11154,304 @@ msgstr "token del file di autenticazione troppo lungo, saltato: \"%s\"" msgid "could not open secondary authentication file \"@%s\" as \"%s\": %m" msgstr "apertura del file secondario di autenticazione \"@%s\" come \"%s\" fallita: %m" -#: libpq/hba.c:409 +#: libpq/hba.c:407 #, c-format msgid "authentication file line too long" msgstr "riga del file di autenticazione troppo lunga" -#: libpq/hba.c:410 libpq/hba.c:757 libpq/hba.c:773 libpq/hba.c:803 -#: libpq/hba.c:849 libpq/hba.c:862 libpq/hba.c:884 libpq/hba.c:893 -#: libpq/hba.c:914 libpq/hba.c:926 libpq/hba.c:945 libpq/hba.c:966 -#: libpq/hba.c:977 libpq/hba.c:1032 libpq/hba.c:1050 libpq/hba.c:1062 -#: libpq/hba.c:1079 libpq/hba.c:1089 libpq/hba.c:1103 libpq/hba.c:1119 -#: libpq/hba.c:1134 libpq/hba.c:1145 libpq/hba.c:1181 libpq/hba.c:1219 -#: libpq/hba.c:1230 libpq/hba.c:1250 libpq/hba.c:1261 libpq/hba.c:1278 -#: libpq/hba.c:1327 libpq/hba.c:1364 libpq/hba.c:1374 libpq/hba.c:1430 -#: libpq/hba.c:1442 libpq/hba.c:1455 libpq/hba.c:1547 libpq/hba.c:1636 -#: libpq/hba.c:1654 libpq/hba.c:1675 tsearch/ts_locale.c:182 +#: libpq/hba.c:408 libpq/hba.c:755 libpq/hba.c:771 libpq/hba.c:801 +#: libpq/hba.c:847 libpq/hba.c:860 libpq/hba.c:882 libpq/hba.c:891 +#: libpq/hba.c:912 libpq/hba.c:924 libpq/hba.c:943 libpq/hba.c:964 +#: libpq/hba.c:975 libpq/hba.c:1030 libpq/hba.c:1048 libpq/hba.c:1060 +#: libpq/hba.c:1077 libpq/hba.c:1087 libpq/hba.c:1101 libpq/hba.c:1117 +#: libpq/hba.c:1132 libpq/hba.c:1143 libpq/hba.c:1179 libpq/hba.c:1217 +#: libpq/hba.c:1228 libpq/hba.c:1248 libpq/hba.c:1259 libpq/hba.c:1276 +#: libpq/hba.c:1325 libpq/hba.c:1362 libpq/hba.c:1372 libpq/hba.c:1428 +#: libpq/hba.c:1440 libpq/hba.c:1453 libpq/hba.c:1545 libpq/hba.c:1634 +#: libpq/hba.c:1652 libpq/hba.c:1673 tsearch/ts_locale.c:182 #, c-format msgid "line %d of configuration file \"%s\"" msgstr "riga %d del file di configurazione \"%s\"" #. translator: the second %s is a list of auth methods -#: libpq/hba.c:755 +#: libpq/hba.c:753 #, c-format msgid "authentication option \"%s\" is only valid for authentication methods %s" msgstr "l'opzione di autenticazione \"%s\" è valida solo per i metodi di autenticazione %s" -#: libpq/hba.c:771 +#: libpq/hba.c:769 #, c-format msgid "authentication method \"%s\" requires argument \"%s\" to be set" msgstr "il metodo di autenticazione \"%s\" richiede che l'argomenti \"%s\" sia impostato" -#: libpq/hba.c:792 +#: libpq/hba.c:790 #, c-format msgid "missing entry in file \"%s\" at end of line %d" msgstr "voce mancante nel file \"%s\" alla fine della riga %d" -#: libpq/hba.c:802 +#: libpq/hba.c:800 #, c-format msgid "multiple values in ident field" msgstr "più di un valore nel campo ident" -#: libpq/hba.c:847 +#: libpq/hba.c:845 #, c-format msgid "multiple values specified for connection type" msgstr "più di un valore specificato per il tipo di connessione" -#: libpq/hba.c:848 +#: libpq/hba.c:846 #, c-format msgid "Specify exactly one connection type per line." msgstr "Specifica esattamente un tipo di connessione per riga." -#: libpq/hba.c:861 +#: libpq/hba.c:859 #, c-format msgid "local connections are not supported by this build" msgstr "le connessioni locali non sono supportate in questo binario" -#: libpq/hba.c:882 +#: libpq/hba.c:880 #, c-format msgid "hostssl requires SSL to be turned on" msgstr "hostssl richiede che SSL sia abilitato" -#: libpq/hba.c:883 +#: libpq/hba.c:881 #, c-format msgid "Set ssl = on in postgresql.conf." msgstr "Imposta ssl = on in postgresql.conf." -#: libpq/hba.c:891 +#: libpq/hba.c:889 #, c-format msgid "hostssl is not supported by this build" msgstr "hostssl non è supportato in questo binario" -#: libpq/hba.c:892 +#: libpq/hba.c:890 #, c-format msgid "Compile with --with-openssl to use SSL connections." msgstr "Compila con --with-openssl per usare connessioni SSL." -#: libpq/hba.c:912 +#: libpq/hba.c:910 #, c-format msgid "invalid connection type \"%s\"" msgstr "tipo di connessione \"%s\" non valido" -#: libpq/hba.c:925 +#: libpq/hba.c:923 #, c-format msgid "end-of-line before database specification" msgstr "fine riga prima della specificazione del database" -#: libpq/hba.c:944 +#: libpq/hba.c:942 #, c-format msgid "end-of-line before role specification" msgstr "fine riga prima della specificazione del ruolo" -#: libpq/hba.c:965 +#: libpq/hba.c:963 #, c-format msgid "end-of-line before IP address specification" msgstr "fine riga prima della specificazione dell'indirizzo IP" -#: libpq/hba.c:975 +#: libpq/hba.c:973 #, c-format msgid "multiple values specified for host address" msgstr "più di un valore specificato per l'indirizzo host" -#: libpq/hba.c:976 +#: libpq/hba.c:974 #, c-format msgid "Specify one address range per line." msgstr "Specifica un intervallo di indirizzi per riga." -#: libpq/hba.c:1030 +#: libpq/hba.c:1028 #, c-format msgid "invalid IP address \"%s\": %s" msgstr "indirizzo IP non valido \"%s\": %s" -#: libpq/hba.c:1048 +#: libpq/hba.c:1046 #, c-format msgid "specifying both host name and CIDR mask is invalid: \"%s\"" msgstr "specificare sia un nome host che una maschera CIDR non è consentito: \"%s\"" -#: libpq/hba.c:1060 +#: libpq/hba.c:1058 #, c-format msgid "invalid CIDR mask in address \"%s\"" msgstr "maschera CIDR non valida nell'indirizzo \"%s\"" -#: libpq/hba.c:1077 +#: libpq/hba.c:1075 #, c-format msgid "end-of-line before netmask specification" msgstr "fine riga prima della specificazione della maschera di rete" -#: libpq/hba.c:1078 +#: libpq/hba.c:1076 #, c-format msgid "Specify an address range in CIDR notation, or provide a separate netmask." msgstr "Specifica un intervallo di indirizzi in notazione CIDR, oppure fornisci una maschera di rete separata." -#: libpq/hba.c:1088 +#: libpq/hba.c:1086 #, c-format msgid "multiple values specified for netmask" msgstr "più di un valore specificato per la maschera di rete" -#: libpq/hba.c:1101 +#: libpq/hba.c:1099 #, c-format msgid "invalid IP mask \"%s\": %s" msgstr "maschera IP non valida \"%s\": %s" -#: libpq/hba.c:1118 +#: libpq/hba.c:1116 #, c-format msgid "IP address and mask do not match" msgstr "l'indirizzo IP e la maschera non combaciano" -#: libpq/hba.c:1133 +#: libpq/hba.c:1131 #, c-format msgid "end-of-line before authentication method" msgstr "fine riga prima del metodo di autenticazione" -#: libpq/hba.c:1143 +#: libpq/hba.c:1141 #, c-format msgid "multiple values specified for authentication type" msgstr "più di un valore specificato per il tipo di autenticazione" -#: libpq/hba.c:1144 +#: libpq/hba.c:1142 #, c-format msgid "Specify exactly one authentication type per line." msgstr "Specifica esattamente un tipo di autenticazione per riga." -#: libpq/hba.c:1217 +#: libpq/hba.c:1215 #, c-format msgid "invalid authentication method \"%s\"" msgstr "metodo di autenticazione \"%s\" non valido" -#: libpq/hba.c:1228 +#: libpq/hba.c:1226 #, c-format msgid "invalid authentication method \"%s\": not supported by this build" msgstr "metodo di autenticazione \"%s\" non valido: non supportato in questo binario" -#: libpq/hba.c:1249 +#: libpq/hba.c:1247 #, c-format msgid "gssapi authentication is not supported on local sockets" msgstr "l'autenticazione gssapi non è supportata su socket locali" -#: libpq/hba.c:1260 +#: libpq/hba.c:1258 #, c-format msgid "peer authentication is only supported on local sockets" msgstr "l'autenticazione peer è supportata solo su socket locali" -#: libpq/hba.c:1277 +#: libpq/hba.c:1275 #, c-format msgid "cert authentication is only supported on hostssl connections" msgstr "l'autenticazione cert è supportata solo su connessioni hostssl" -#: libpq/hba.c:1326 +#: libpq/hba.c:1324 #, c-format msgid "authentication option not in name=value format: %s" msgstr "opzione di autenticazione non in formato nome=valore: %s" -#: libpq/hba.c:1363 +#: libpq/hba.c:1361 #, c-format msgid "cannot use ldapbasedn, ldapbinddn, ldapbindpasswd, ldapsearchattribute, or ldapurl together with ldapprefix" msgstr "non si possono usare ldapbasedn, ldapbinddn, ldapbindpasswd, ldapsearchattribute né ldapurl insieme a ldapprefix" -#: libpq/hba.c:1373 +#: libpq/hba.c:1371 #, c-format msgid "authentication method \"ldap\" requires argument \"ldapbasedn\", \"ldapprefix\", or \"ldapsuffix\" to be set" msgstr "il metodo di autenticazione \"ldap\" richiede che gli argomenti \"ldapbasedn\", \"ldapprefix\" o \"ldapsuffix\" siano impostati" -#: libpq/hba.c:1416 +#: libpq/hba.c:1414 msgid "ident, peer, gssapi, sspi, and cert" msgstr "ident, peer, gssapi, sspi e cert" -#: libpq/hba.c:1429 +#: libpq/hba.c:1427 #, c-format msgid "clientcert can only be configured for \"hostssl\" rows" msgstr "il clientcert può essere configurato solo per le righe \"hostssl\"" -#: libpq/hba.c:1440 +#: libpq/hba.c:1438 #, c-format msgid "client certificates can only be checked if a root certificate store is available" msgstr "il certificato del client può essere controllato solo se un root certificate store è disponibile" -#: libpq/hba.c:1454 +#: libpq/hba.c:1452 #, c-format msgid "clientcert can not be set to 0 when using \"cert\" authentication" msgstr "clientcert non può essere impostato a 0 quando si usa l'autenticazione \"cert\"" -#: libpq/hba.c:1490 +#: libpq/hba.c:1488 #, c-format msgid "could not parse LDAP URL \"%s\": %s" msgstr "impossibile interpretare la URL LDAP \"%s\": %s" -#: libpq/hba.c:1498 +#: libpq/hba.c:1496 #, c-format msgid "unsupported LDAP URL scheme: %s" msgstr "schema di URL LDAP non supportato: %s" -#: libpq/hba.c:1514 +#: libpq/hba.c:1512 #, c-format msgid "filters not supported in LDAP URLs" msgstr "i filtri non sono supportati nelle URL LDAP" -#: libpq/hba.c:1522 +#: libpq/hba.c:1520 #, c-format msgid "LDAP URLs not supported on this platform" msgstr "URL LDAP non supportate su questa piattaforma" -#: libpq/hba.c:1546 +#: libpq/hba.c:1544 #, c-format msgid "invalid LDAP port number: \"%s\"" msgstr "numero di porta LDAP non valido: \"%s\"" -#: libpq/hba.c:1586 libpq/hba.c:1593 +#: libpq/hba.c:1584 libpq/hba.c:1591 msgid "gssapi and sspi" msgstr "gssapi e sspi" -#: libpq/hba.c:1602 libpq/hba.c:1611 +#: libpq/hba.c:1600 libpq/hba.c:1609 msgid "sspi" msgstr "sspi" -#: libpq/hba.c:1653 +#: libpq/hba.c:1651 #, c-format msgid "invalid RADIUS port number: \"%s\"" msgstr "numero di porta RADIUS non valido: \"%s\"" -#: libpq/hba.c:1673 +#: libpq/hba.c:1671 #, c-format msgid "unrecognized authentication option name: \"%s\"" msgstr "nome di opzione di autenticazione sconosciuto: \"%s\"" -#: libpq/hba.c:1808 guc-file.l:595 +#: libpq/hba.c:1806 guc-file.l:593 #, c-format msgid "could not open configuration file \"%s\": %m" msgstr "apertura del file di configurazione \"%s\" fallita: %m" -#: libpq/hba.c:1859 +#: libpq/hba.c:1855 #, c-format msgid "configuration file \"%s\" contains no entries" msgstr "il file di configurazione \"%s\" non contiene alcuna voce" -#: libpq/hba.c:1955 +#: libpq/hba.c:1951 #, c-format msgid "invalid regular expression \"%s\": %s" msgstr "espressione regolare non valida \"%s\": %s" -#: libpq/hba.c:2015 +#: libpq/hba.c:2011 #, c-format msgid "regular expression match for \"%s\" failed: %s" msgstr "corrispondenza dell'espressione regolare \"%s\" fallita: %s" -#: libpq/hba.c:2034 +#: libpq/hba.c:2030 #, c-format msgid "regular expression \"%s\" has no subexpressions as requested by backreference in \"%s\"" msgstr "l'espressione regolare \"%s\" non ha la sottoespressione richiesta dal riferimento in \"%s\"" -#: libpq/hba.c:2131 +#: libpq/hba.c:2127 #, c-format msgid "provided user name (%s) and authenticated user name (%s) do not match" msgstr "il nome utente fornito (%s) e il nome utente autenticato (%s) non combaciano" -#: libpq/hba.c:2151 +#: libpq/hba.c:2147 #, c-format msgid "no match in usermap \"%s\" for user \"%s\" authenticated as \"%s\"" msgstr "nessuna corrispondenza nella mappa utenti \"%s\" per l'utente \"%s\" autenticato come \"%s\"" -#: libpq/hba.c:2186 +#: libpq/hba.c:2182 #, c-format msgid "could not open usermap file \"%s\": %m" msgstr "apertura del file usermap \"%s\" fallita: %m" @@ -11543,7 +11566,7 @@ msgstr "c'è alcuna connessione client" msgid "could not receive data from client: %m" msgstr "ricezione dati dal client fallita: %m" -#: libpq/pqcomm.c:1177 tcop/postgres.c:3906 +#: libpq/pqcomm.c:1177 tcop/postgres.c:3917 #, c-format msgid "terminating connection because protocol synchronization was lost" msgstr "la connessione verrà terminata perché la sincronizzazione del protocollo è stata persa" @@ -11568,23 +11591,23 @@ msgstr "messaggio incompleto dal client" msgid "could not send data to client: %m" msgstr "invio dati al client fallito: %m" -#: libpq/pqformat.c:436 +#: libpq/pqformat.c:437 #, c-format msgid "no data left in message" msgstr "nessun dato rimasto nel messaggio" -#: libpq/pqformat.c:556 libpq/pqformat.c:574 libpq/pqformat.c:595 +#: libpq/pqformat.c:557 libpq/pqformat.c:575 libpq/pqformat.c:596 #: utils/adt/arrayfuncs.c:1457 utils/adt/rowtypes.c:563 #, c-format msgid "insufficient data left in message" msgstr "i dati rimasti nel messaggio non sono sufficienti" -#: libpq/pqformat.c:636 +#: libpq/pqformat.c:637 libpq/pqformat.c:666 #, c-format msgid "invalid string in message" msgstr "stringa non valida nel messaggio" -#: libpq/pqformat.c:652 +#: libpq/pqformat.c:682 #, c-format msgid "invalid message format" msgstr "formato del messaggio non valido" @@ -11594,7 +11617,7 @@ msgstr "formato del messaggio non valido" msgid "%s: WSAStartup failed: %d\n" msgstr "%s: WSAStartup fallita: %d\n" -#: main/main.c:327 +#: main/main.c:328 #, c-format msgid "" "%s is the PostgreSQL server.\n" @@ -11603,7 +11626,7 @@ msgstr "" "%s è il server PostgreSQL.\n" "\n" -#: main/main.c:328 +#: main/main.c:329 #, c-format msgid "" "Usage:\n" @@ -11614,114 +11637,114 @@ msgstr "" " %s [OPZIONE]...\n" "\n" -#: main/main.c:329 +#: main/main.c:330 #, c-format msgid "Options:\n" msgstr "Opzioni:\n" -#: main/main.c:330 +#: main/main.c:331 #, c-format msgid " -B NBUFFERS number of shared buffers\n" msgstr " -B NBUFFERS numero di buffer condivisi\n" -#: main/main.c:331 +#: main/main.c:332 #, c-format msgid " -c NAME=VALUE set run-time parameter\n" msgstr " -c NOME=VALORE imposta un parametro di esecuzione\n" -#: main/main.c:332 +#: main/main.c:333 #, c-format msgid " -C NAME print value of run-time parameter, then exit\n" msgstr " -C NAME stampa il valore del parametro di esecuzione ed esci\n" -#: main/main.c:333 +#: main/main.c:334 #, c-format msgid " -d 1-5 debugging level\n" msgstr " -d 1-5 livello di debugging\n" -#: main/main.c:334 +#: main/main.c:335 #, c-format msgid " -D DATADIR database directory\n" msgstr " -D DATADIR directory del database\n" -#: main/main.c:335 +#: main/main.c:336 #, c-format msgid " -e use European date input format (DMY)\n" msgstr " -e usa il formato date europeo (GMA)\n" -#: main/main.c:336 +#: main/main.c:337 #, c-format msgid " -F turn fsync off\n" msgstr " -F disabilita fsync\n" -#: main/main.c:337 +#: main/main.c:338 #, c-format msgid " -h HOSTNAME host name or IP address to listen on\n" msgstr " -h HOSTNAME nome host o indirizzo IP su cui ascoltare\n" -#: main/main.c:338 +#: main/main.c:339 #, c-format msgid " -i enable TCP/IP connections\n" msgstr " -i abilita le connessioni TCP/IP\n" -#: main/main.c:339 +#: main/main.c:340 #, c-format msgid " -k DIRECTORY Unix-domain socket location\n" msgstr " -k DIRECTORY posizione dei socket di dominio Unix\n" -#: main/main.c:341 +#: main/main.c:342 #, c-format msgid " -l enable SSL connections\n" msgstr " -l abilita la connessione SSL\n" -#: main/main.c:343 +#: main/main.c:344 #, c-format msgid " -N MAX-CONNECT maximum number of allowed connections\n" msgstr " -N MAX-CONNECT numero massimo di connessioni consentite\n" -#: main/main.c:344 +#: main/main.c:345 #, c-format msgid " -o OPTIONS pass \"OPTIONS\" to each server process (obsolete)\n" msgstr " -o OPZIONI passa \"OPZIONI\" ad ogni processo server (obsoleto)\n" -#: main/main.c:345 +#: main/main.c:346 #, c-format msgid " -p PORT port number to listen on\n" msgstr " -p PORT numero di porta sul quale ascoltare\n" -#: main/main.c:346 +#: main/main.c:347 #, c-format msgid " -s show statistics after each query\n" msgstr " -s mostra le statistiche dopo ogni query\n" -#: main/main.c:347 +#: main/main.c:348 #, c-format msgid " -S WORK-MEM set amount of memory for sorts (in kB)\n" msgstr "" " -S WORK-MEM imposta la dimensione della memoria per gli ordinamenti\n" " (in kB)\n" -#: main/main.c:348 +#: main/main.c:349 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version mostra informazioni sulla versione ed esci\n" -#: main/main.c:349 +#: main/main.c:350 #, c-format msgid " --NAME=VALUE set run-time parameter\n" msgstr " --NOME=VALORE imposta un parametro di esecuzione\n" -#: main/main.c:350 +#: main/main.c:351 #, c-format msgid " --describe-config describe configuration parameters, then exit\n" msgstr " --describe-config descrivi i parametri di configurazione ed esci\n" -#: main/main.c:351 +#: main/main.c:352 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help mostra questo aiuto ed esci\n" -#: main/main.c:353 +#: main/main.c:354 #, c-format msgid "" "\n" @@ -11730,48 +11753,48 @@ msgstr "" "\n" "Opzioni per gli sviluppatori:\n" -#: main/main.c:354 +#: main/main.c:355 #, c-format msgid " -f s|i|n|m|h forbid use of some plan types\n" msgstr " -f s|i|n|m|h vieta l'uso di alcuni tipi di piani\n" -#: main/main.c:355 +#: main/main.c:356 #, c-format msgid " -n do not reinitialize shared memory after abnormal exit\n" msgstr "" " -n non reinizializzare la memoria condivisa dopo un'uscita\n" " anormale\n" -#: main/main.c:356 +#: main/main.c:357 #, c-format msgid " -O allow system table structure changes\n" msgstr "" " -O consenti cambiamenti alla struttura delle tabelle\n" " di sistema\n" -#: main/main.c:357 +#: main/main.c:358 #, c-format msgid " -P disable system indexes\n" msgstr " -P disabilita gli indici di sistema\n" -#: main/main.c:358 +#: main/main.c:359 #, c-format msgid " -t pa|pl|ex show timings after each query\n" msgstr " -t pa|pl|ex mostra i tempi impiegati dopo ogni query\n" -#: main/main.c:359 +#: main/main.c:360 #, c-format msgid " -T send SIGSTOP to all backend processes if one dies\n" msgstr " -T invia SIGSTOP a tutti i processi backend se uno muore\n" -#: main/main.c:360 +#: main/main.c:361 #, c-format msgid " -W NUM wait NUM seconds to allow attach from a debugger\n" msgstr "" " -W NUM attendi NUM secondi per consentire ad un debugger\n" " di collegarsi\n" -#: main/main.c:362 +#: main/main.c:363 #, c-format msgid "" "\n" @@ -11780,41 +11803,41 @@ msgstr "" "\n" "Opzione per la modalità a singolo utente:\n" -#: main/main.c:363 +#: main/main.c:364 #, c-format msgid " --single selects single-user mode (must be first argument)\n" msgstr "" " --single imposta la modalità utente singolo (deve essere il primo\n" " argomento)\n" -#: main/main.c:364 +#: main/main.c:365 #, c-format msgid " DBNAME database name (defaults to user name)\n" msgstr " DBNAME nome del database (il predefinito è il nome dell'utente)\n" -#: main/main.c:365 +#: main/main.c:366 #, c-format msgid " -d 0-5 override debugging level\n" msgstr " -d 0-5 scavalca il livello di debugging\n" -#: main/main.c:366 +#: main/main.c:367 #, c-format msgid " -E echo statement before execution\n" msgstr " -E stampa le istruzioni prima dell'esecuzione\n" -#: main/main.c:367 +#: main/main.c:368 #, c-format msgid " -j do not use newline as interactive query delimiter\n" msgstr "" " -j non usare \"a capo\" come delimitatore delle query\n" " interattivo\n" -#: main/main.c:368 main/main.c:373 +#: main/main.c:369 main/main.c:374 #, c-format msgid " -r FILENAME send stdout and stderr to given file\n" msgstr " -r NOMEFILE invia stdout e stderr al file in argomento\n" -#: main/main.c:370 +#: main/main.c:371 #, c-format msgid "" "\n" @@ -11823,26 +11846,26 @@ msgstr "" "\n" "Opzioni per la modalità di inizializzazione:\n" -#: main/main.c:371 +#: main/main.c:372 #, c-format msgid " --boot selects bootstrapping mode (must be first argument)\n" msgstr "" " --boot seleziona la modalità di inizializzazione (dev'essere\n" " il primo argomento)\n" -#: main/main.c:372 +#: main/main.c:373 #, c-format msgid " DBNAME database name (mandatory argument in bootstrapping mode)\n" msgstr "" " DBNAME nome del database (obbligatorio in modalità di\n" " inizializzazione)\n" -#: main/main.c:374 +#: main/main.c:375 #, c-format msgid " -x NUM internal use\n" msgstr " -x NUM uso interno\n" -#: main/main.c:376 +#: main/main.c:377 #, c-format msgid "" "\n" @@ -11859,7 +11882,7 @@ msgstr "" "\n" "Puoi segnalare eventuali bug a .\n" -#: main/main.c:390 +#: main/main.c:391 #, c-format msgid "" "\"root\" execution of the PostgreSQL server is not permitted.\n" @@ -11872,12 +11895,12 @@ msgstr "" "prevenire possibili problemi di sicurezza. Consulta la documentazione\n" "per avere maggiori informazioni su come avviare il server correttamente.\n" -#: main/main.c:407 +#: main/main.c:408 #, c-format msgid "%s: real and effective user IDs must match\n" msgstr "%s: utente gli ID reale e quello effettivo devono coincidere\n" -#: main/main.c:414 +#: main/main.c:415 #, c-format msgid "" "Execution of PostgreSQL by a user with administrative permissions is not\n" @@ -11902,24 +11925,24 @@ msgstr "il tipo di nodo estendibile \"%s\" esiste già" msgid "ExtensibleNodeMethods \"%s\" was not registered" msgstr "ExtensibleNodeMethods \"%s\" non è stato registrato" -#: nodes/nodeFuncs.c:123 nodes/nodeFuncs.c:154 parser/parse_coerce.c:1820 +#: nodes/nodeFuncs.c:124 nodes/nodeFuncs.c:155 parser/parse_coerce.c:1820 #: parser/parse_coerce.c:1848 parser/parse_coerce.c:1924 -#: parser/parse_expr.c:1981 parser/parse_func.c:597 parser/parse_oper.c:952 +#: parser/parse_expr.c:2019 parser/parse_func.c:597 parser/parse_oper.c:952 #, c-format msgid "could not find array type for data type %s" msgstr "non è stato possibile trovare il tipo di array per il tipo di dati %s" -#: optimizer/path/allpaths.c:2608 +#: optimizer/path/allpaths.c:2653 #, c-format msgid "WHERE CURRENT OF is not supported on a view with no underlying relation" msgstr "WHERE CURRENT OF non è supportato per una vista senza una relazione sottostante" -#: optimizer/path/allpaths.c:2613 +#: optimizer/path/allpaths.c:2658 #, c-format msgid "WHERE CURRENT OF is not supported on a view with more than one underlying relation" msgstr "WHERE CURRENT OF non è supportato per una vista con più di una relazione sottostante" -#: optimizer/path/allpaths.c:2618 +#: optimizer/path/allpaths.c:2663 #, c-format msgid "WHERE CURRENT OF is not supported on a view with grouping or aggregation" msgstr "WHERE CURRENT OF non è supportato per una vista con raggruppamenti o aggregazioni" @@ -11936,70 +11959,70 @@ msgid "%s cannot be applied to the nullable side of an outer join" msgstr "%s non può essere applicato sul lato che può essere nullo di un join esterno" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: optimizer/plan/planner.c:1473 parser/analyze.c:1481 parser/analyze.c:1679 -#: parser/analyze.c:2460 +#: optimizer/plan/planner.c:1480 parser/analyze.c:1549 parser/analyze.c:1747 +#: parser/analyze.c:2528 #, c-format msgid "%s is not allowed with UNION/INTERSECT/EXCEPT" msgstr "%s non è consentito con UNION/INTERSECT/EXCEPT" -#: optimizer/plan/planner.c:3752 +#: optimizer/plan/planner.c:3809 #, c-format msgid "could not implement GROUP BY" msgstr "non è stato possibile implementare GROUP BY" -#: optimizer/plan/planner.c:3753 optimizer/plan/planner.c:4095 -#: optimizer/prep/prepunion.c:927 +#: optimizer/plan/planner.c:3810 optimizer/plan/planner.c:4203 +#: optimizer/prep/prepunion.c:929 #, c-format msgid "Some of the datatypes only support hashing, while others only support sorting." msgstr "Alcuni dei tipi di dati supportano solo l'hashing, mentre altri supportano solo l'ordinamento." -#: optimizer/plan/planner.c:4094 +#: optimizer/plan/planner.c:4202 #, c-format msgid "could not implement DISTINCT" msgstr "non è stato possibile implementare DISTINCT" -#: optimizer/plan/planner.c:4633 +#: optimizer/plan/planner.c:4832 #, c-format msgid "could not implement window PARTITION BY" msgstr "non è stato possibile implementare PARTITION BY della finestra" -#: optimizer/plan/planner.c:4634 +#: optimizer/plan/planner.c:4833 #, c-format msgid "Window partitioning columns must be of sortable datatypes." msgstr "La colonna di partizionamento della finestra dev'essere un tipo di dato ordinabile." -#: optimizer/plan/planner.c:4638 +#: optimizer/plan/planner.c:4837 #, c-format msgid "could not implement window ORDER BY" msgstr "non è stato possibile implementare ORDER BY della finestra" -#: optimizer/plan/planner.c:4639 +#: optimizer/plan/planner.c:4838 #, c-format msgid "Window ordering columns must be of sortable datatypes." msgstr "La colonna di ordinamento della finestra dev'essere un tipo di dato ordinabile." -#: optimizer/plan/setrefs.c:423 +#: optimizer/plan/setrefs.c:415 #, c-format msgid "too many range table entries" msgstr "troppi intervalli di tabella" -#: optimizer/prep/prepunion.c:480 +#: optimizer/prep/prepunion.c:484 #, c-format msgid "could not implement recursive UNION" msgstr "non è stato possibile implementare la UNION ricorsiva" -#: optimizer/prep/prepunion.c:481 +#: optimizer/prep/prepunion.c:485 #, c-format msgid "All column datatypes must be hashable." msgstr "Tutti i tipi di dati devono supportare l'hash." #. translator: %s is UNION, INTERSECT, or EXCEPT -#: optimizer/prep/prepunion.c:926 +#: optimizer/prep/prepunion.c:928 #, c-format msgid "could not implement %s" msgstr "non è stato possibile implementare %s" -#: optimizer/util/clauses.c:4965 +#: optimizer/util/clauses.c:4634 #, c-format msgid "SQL function \"%s\" during inlining" msgstr "funzione SQL \"%s\" durante l'inlining" @@ -12009,443 +12032,443 @@ msgstr "funzione SQL \"%s\" durante l'inlining" msgid "cannot access temporary or unlogged relations during recovery" msgstr "non è possibile accedere a relazioni temporanee o non loggate durante il ripristino" -#: optimizer/util/plancat.c:591 +#: optimizer/util/plancat.c:611 #, c-format -msgid "system columns cannot be used in an ON CONFLICT clause" -msgstr "le colonne di sistema non possono essere usate in una clausola ON CONFLICT" +msgid "whole row unique index inference specifications are not supported" +msgstr "le specifiche di inferenza di indici unici per l'intera riga non sono supportate" -#: optimizer/util/plancat.c:609 +#: optimizer/util/plancat.c:628 #, c-format msgid "constraint in ON CONFLICT clause has no associated index" msgstr "il vincolo nella clausola ON CONFLICT non ha indici associati" -#: optimizer/util/plancat.c:661 +#: optimizer/util/plancat.c:679 #, c-format msgid "ON CONFLICT DO UPDATE not supported with exclusion constraints" msgstr "ON CONFLICT DO UPDATE non supportato con vincoli di esclusione" -#: optimizer/util/plancat.c:768 +#: optimizer/util/plancat.c:784 #, c-format msgid "there is no unique or exclusion constraint matching the ON CONFLICT specification" msgstr "non c'è alcun vincolo di unicità o esclusione che combaci con la specifica ON CONFLICT" -#: parser/analyze.c:639 parser/analyze.c:1253 +#: parser/analyze.c:663 parser/analyze.c:1321 #, c-format msgid "VALUES lists must all be the same length" msgstr "le liste VALUES devono essere tutte della stessa lunghezza" -#: parser/analyze.c:811 +#: parser/analyze.c:859 #, c-format msgid "INSERT has more expressions than target columns" msgstr "INSERT ha più espressioni che colonne di destinazione" -#: parser/analyze.c:829 +#: parser/analyze.c:877 #, c-format msgid "INSERT has more target columns than expressions" msgstr "INSERT ha più colonne di destinazione che espressioni" -#: parser/analyze.c:833 +#: parser/analyze.c:881 #, c-format msgid "The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?" msgstr "L'origine dell'inserimento è un'espressione riga con lo stesso numero di colonne attese da INSERT. Forse hai usato accidentalmente parentesi in eccesso?" -#: parser/analyze.c:1074 parser/analyze.c:1454 +#: parser/analyze.c:1142 parser/analyze.c:1522 #, c-format msgid "SELECT ... INTO is not allowed here" msgstr "SELECT ... INTO non è permesso qui" -#: parser/analyze.c:1267 +#: parser/analyze.c:1335 #, c-format msgid "DEFAULT can only appear in a VALUES list within INSERT" msgstr "DEFAULT può apparire solo nella lista di VALUES usata in un INSERT" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:1386 parser/analyze.c:2630 +#: parser/analyze.c:1454 parser/analyze.c:2698 #, c-format msgid "%s cannot be applied to VALUES" msgstr "%s non è consentito con VALUES" -#: parser/analyze.c:1607 +#: parser/analyze.c:1675 #, c-format msgid "invalid UNION/INTERSECT/EXCEPT ORDER BY clause" msgstr "clausola UNION/INTERSECT/EXCEPT ORDER BY non valida" -#: parser/analyze.c:1608 +#: parser/analyze.c:1676 #, c-format msgid "Only result column names can be used, not expressions or functions." msgstr "Possono essere usati solo nomi di colonne risultanti, non espressioni o funzioni." -#: parser/analyze.c:1609 +#: parser/analyze.c:1677 #, c-format msgid "Add the expression/function to every SELECT, or move the UNION into a FROM clause." msgstr "Aggiungi l'espressione/funzione ad ogni SELECT, oppure sposta la UNION in una clausola FROM." -#: parser/analyze.c:1669 +#: parser/analyze.c:1737 #, c-format msgid "INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT" msgstr "INTO è permesso solo nella prima SELECT di UNION/INTERSECT/EXCEPT" -#: parser/analyze.c:1733 +#: parser/analyze.c:1801 #, c-format msgid "UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level" msgstr "l'istruzione membro di UNION/INTERSECT/EXCEPT non può riferirsi al altre relazione allo stesso livello della query" -#: parser/analyze.c:1822 +#: parser/analyze.c:1890 #, c-format msgid "each %s query must have the same number of columns" msgstr "ogni query in %s deve avere lo stesso numero di colonne" -#: parser/analyze.c:2215 +#: parser/analyze.c:2283 #, c-format msgid "RETURNING must have at least one column" msgstr "RETURNING deve avere almeno una colonna" -#: parser/analyze.c:2252 +#: parser/analyze.c:2320 #, c-format msgid "cannot specify both SCROLL and NO SCROLL" msgstr "non è possibile specificare sia SCROLL che NO SCROLL" -#: parser/analyze.c:2270 +#: parser/analyze.c:2338 #, c-format msgid "DECLARE CURSOR must not contain data-modifying statements in WITH" msgstr "DECLARE CURSOR non può contenere istruzioni di modifica dei dati nel WITH" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2278 +#: parser/analyze.c:2346 #, c-format msgid "DECLARE CURSOR WITH HOLD ... %s is not supported" msgstr "DECLARE CURSOR WITH HOLD ... %s non è supportato" -#: parser/analyze.c:2281 +#: parser/analyze.c:2349 #, c-format msgid "Holdable cursors must be READ ONLY." msgstr "I cursori trattenibili devono essere READ ONLY." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2289 +#: parser/analyze.c:2357 #, c-format msgid "DECLARE SCROLL CURSOR ... %s is not supported" msgstr "DECLARE SCROLL CURSOR ... %s non è supportato" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2300 +#: parser/analyze.c:2368 #, c-format msgid "DECLARE INSENSITIVE CURSOR ... %s is not supported" msgstr "DECLARE INSENSITIVE CURSOR ... %s non è supportato" -#: parser/analyze.c:2303 +#: parser/analyze.c:2371 #, c-format msgid "Insensitive cursors must be READ ONLY." msgstr "I cursori Insensitive devono essere READ ONLY." -#: parser/analyze.c:2369 +#: parser/analyze.c:2437 #, c-format msgid "materialized views must not use data-modifying statements in WITH" msgstr "le viste materializzate non possono usare istruzioni di modifica dei dati nel WITH" -#: parser/analyze.c:2379 +#: parser/analyze.c:2447 #, c-format msgid "materialized views must not use temporary tables or views" msgstr "le viste materializzate non possono usare tabelle temporanee o viste" -#: parser/analyze.c:2389 +#: parser/analyze.c:2457 #, c-format msgid "materialized views may not be defined using bound parameters" msgstr "le viste materializzate non possono essere definite con parametri impostati" -#: parser/analyze.c:2401 +#: parser/analyze.c:2469 #, c-format msgid "materialized views cannot be UNLOGGED" msgstr "le viste materializzate non possono essere UNLOGGED" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2467 +#: parser/analyze.c:2535 #, c-format msgid "%s is not allowed with DISTINCT clause" msgstr "%s non è consentito con la clausola DISTINCT" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2474 +#: parser/analyze.c:2542 #, c-format msgid "%s is not allowed with GROUP BY clause" msgstr "%s non è consentito con la clausola GROUP BY" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2481 +#: parser/analyze.c:2549 #, c-format msgid "%s is not allowed with HAVING clause" msgstr "%s non è consentito con la clausola HAVING" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2488 +#: parser/analyze.c:2556 #, c-format msgid "%s is not allowed with aggregate functions" msgstr "%s non è consentito con funzioni di aggregazione" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2495 +#: parser/analyze.c:2563 #, c-format msgid "%s is not allowed with window functions" msgstr "%s non è consentito con funzioni finestra" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2502 +#: parser/analyze.c:2570 #, c-format msgid "%s is not allowed with set-returning functions in the target list" msgstr "%s non è consentito con la le funzioni che restituiscono insiemi nella lista di destinazione" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2581 +#: parser/analyze.c:2649 #, c-format msgid "%s must specify unqualified relation names" msgstr "%s deve specificare nomi di tabelle non qualificati" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2612 +#: parser/analyze.c:2680 #, c-format msgid "%s cannot be applied to a join" msgstr "%s non può essere applicato ad un join" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2621 +#: parser/analyze.c:2689 #, c-format msgid "%s cannot be applied to a function" msgstr "%s non può essere applicato ad una funzione" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2639 +#: parser/analyze.c:2707 #, c-format msgid "%s cannot be applied to a WITH query" msgstr "%s non può essere applicato ad una query WITH" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2656 +#: parser/analyze.c:2724 #, c-format msgid "relation \"%s\" in %s clause not found in FROM clause" msgstr "la relazione \"%s\" nella clausola %s non è stata trovata nella clausola FROM" -#: parser/parse_agg.c:208 parser/parse_oper.c:220 +#: parser/parse_agg.c:223 parser/parse_oper.c:220 #, c-format msgid "could not identify an ordering operator for type %s" msgstr "non è stato possibile identificare un operatore di ordinamento per il tipo %s" -#: parser/parse_agg.c:210 +#: parser/parse_agg.c:225 #, c-format msgid "Aggregates with DISTINCT must be able to sort their inputs." msgstr "Gli aggregati con DISTINCT devono essere in grado di ordinare i loro input." -#: parser/parse_agg.c:245 +#: parser/parse_agg.c:260 #, c-format msgid "GROUPING must have fewer than 32 arguments" msgstr "GROUPING deve avere meno di 32 argomenti" -#: parser/parse_agg.c:348 +#: parser/parse_agg.c:363 msgid "aggregate functions are not allowed in JOIN conditions" msgstr "le funzioni di aggregazione non sono ammesse nelle condizioni di JOIN" -#: parser/parse_agg.c:350 +#: parser/parse_agg.c:365 msgid "grouping operations are not allowed in JOIN conditions" msgstr "le operazioni di raggruppamento non sono ammesse nelle condizioni di JOIN" -#: parser/parse_agg.c:362 +#: parser/parse_agg.c:377 msgid "aggregate functions are not allowed in FROM clause of their own query level" msgstr "le funzioni di aggregazione non sono ammesse nella clausola FROM del loro stesso livello della query" -#: parser/parse_agg.c:364 +#: parser/parse_agg.c:379 msgid "grouping operations are not allowed in FROM clause of their own query level" msgstr "le operazioni di raggruppamento non sono ammesse nella clausola FROM del proprio livello di query" -#: parser/parse_agg.c:369 +#: parser/parse_agg.c:384 msgid "aggregate functions are not allowed in functions in FROM" msgstr "le funzioni di aggregazione non sono ammesse nelle funzioni in FROM" -#: parser/parse_agg.c:371 +#: parser/parse_agg.c:386 msgid "grouping operations are not allowed in functions in FROM" msgstr "le operazioni di raggruppamento non sono ammesse nelle funzioni in FROM" -#: parser/parse_agg.c:379 +#: parser/parse_agg.c:394 msgid "aggregate functions are not allowed in policy expressions" msgstr "le funzioni di aggregazione non sono ammesse nell'espressione di una regola di sicurezza" -#: parser/parse_agg.c:381 +#: parser/parse_agg.c:396 msgid "grouping operations are not allowed in policy expressions" msgstr "le funzioni di raggruppamento non sono ammesse nell'espressione di una regola di sicurezza" -#: parser/parse_agg.c:398 +#: parser/parse_agg.c:413 msgid "aggregate functions are not allowed in window RANGE" msgstr "le funzioni di aggregazione non sono ammesse nel RANGE della finestra" -#: parser/parse_agg.c:400 +#: parser/parse_agg.c:415 msgid "grouping operations are not allowed in window RANGE" msgstr "le operazioni di taggruppamento non sono ammesse nel RANGE della finestra" -#: parser/parse_agg.c:405 +#: parser/parse_agg.c:420 msgid "aggregate functions are not allowed in window ROWS" msgstr "le funzioni di aggregazione non sono ammesse nel ROWS della finestra" -#: parser/parse_agg.c:407 +#: parser/parse_agg.c:422 msgid "grouping operations are not allowed in window ROWS" msgstr "le operazioni di raggruppamento non sono ammesse nel ROWS della finestra" -#: parser/parse_agg.c:440 +#: parser/parse_agg.c:455 msgid "aggregate functions are not allowed in check constraints" msgstr "le funzioni di aggregazione non sono ammesse nei vincoli di controllo" -#: parser/parse_agg.c:442 +#: parser/parse_agg.c:457 msgid "grouping operations are not allowed in check constraints" msgstr "le operazioni di raggruppamento non sono ammesse nei vincoli di controllo" -#: parser/parse_agg.c:449 +#: parser/parse_agg.c:464 msgid "aggregate functions are not allowed in DEFAULT expressions" msgstr "le funzioni di aggregazione non sono ammesse nelle espressioni DEFAULT" -#: parser/parse_agg.c:451 +#: parser/parse_agg.c:466 msgid "grouping operations are not allowed in DEFAULT expressions" msgstr "le operazioni di raggruppamento non sono ammesse nelle espressioni DEFAULT" -#: parser/parse_agg.c:456 +#: parser/parse_agg.c:471 msgid "aggregate functions are not allowed in index expressions" msgstr "le funzioni di aggregazione non sono ammesse nelle espressioni degli indici" -#: parser/parse_agg.c:458 +#: parser/parse_agg.c:473 msgid "grouping operations are not allowed in index expressions" msgstr "le operazioni di raggruppamento non sono ammesse nelle espressioni degli indici" -#: parser/parse_agg.c:463 +#: parser/parse_agg.c:478 msgid "aggregate functions are not allowed in index predicates" msgstr "le funzioni di aggregazione non sono ammesse nei predicati degli indici" -#: parser/parse_agg.c:465 +#: parser/parse_agg.c:480 msgid "grouping operations are not allowed in index predicates" msgstr "le operazioni di raggruppamento non sono ammesse nei predicati degli indici" -#: parser/parse_agg.c:470 +#: parser/parse_agg.c:485 msgid "aggregate functions are not allowed in transform expressions" msgstr "le funzioni di aggregazione non sono ammesse nelle espressioni di trasformazione" -#: parser/parse_agg.c:472 +#: parser/parse_agg.c:487 msgid "grouping operations are not allowed in transform expressions" msgstr "le operazioni di raggruppamento non sono ammesse nelle espressioni di trasformazione" -#: parser/parse_agg.c:477 +#: parser/parse_agg.c:492 msgid "aggregate functions are not allowed in EXECUTE parameters" msgstr "le funzioni di aggregazione non sono ammesse nei parametri di EXECUTE" -#: parser/parse_agg.c:479 +#: parser/parse_agg.c:494 msgid "grouping operations are not allowed in EXECUTE parameters" msgstr "le operazioni di raggruppamento non sono ammesse nei parametri di EXECUTE" -#: parser/parse_agg.c:484 +#: parser/parse_agg.c:499 msgid "aggregate functions are not allowed in trigger WHEN conditions" msgstr "le funzioni di aggregazione non sono ammesse nelle condizioni WHEN dei trigger" -#: parser/parse_agg.c:486 +#: parser/parse_agg.c:501 msgid "grouping operations are not allowed in trigger WHEN conditions" msgstr "le operazioni di raggruppamento non sono ammesse nelle condizioni WHEN dei trigger" #. translator: %s is name of a SQL construct, eg GROUP BY -#: parser/parse_agg.c:509 parser/parse_clause.c:1550 +#: parser/parse_agg.c:524 parser/parse_clause.c:1550 #, c-format msgid "aggregate functions are not allowed in %s" msgstr "le funzioni di aggregazione non sono ammesse in %s" #. translator: %s is name of a SQL construct, eg GROUP BY -#: parser/parse_agg.c:512 +#: parser/parse_agg.c:527 #, c-format msgid "grouping operations are not allowed in %s" msgstr "le operazioni di raggruppamento non sono ammesse in %s" -#: parser/parse_agg.c:620 +#: parser/parse_agg.c:635 #, c-format msgid "outer-level aggregate cannot contain a lower-level variable in its direct arguments" msgstr "gli aggregati di livello esterno non possono contenere una variabile di livello inferiore tra gli argomenti diretti" -#: parser/parse_agg.c:691 +#: parser/parse_agg.c:706 #, c-format msgid "aggregate function calls cannot contain window function calls" msgstr "le chiamate a funzioni di aggregazione non possono contenere chiamate a funzioni finestra" -#: parser/parse_agg.c:769 +#: parser/parse_agg.c:784 msgid "window functions are not allowed in JOIN conditions" msgstr "le funzioni finestra non sono ammesse nelle condizioni JOIN" -#: parser/parse_agg.c:776 +#: parser/parse_agg.c:791 msgid "window functions are not allowed in functions in FROM" msgstr "le funzioni finestra non sono ammesse nelle funzioni in FROM" -#: parser/parse_agg.c:782 +#: parser/parse_agg.c:797 msgid "window functions are not allowed in policy expressions" msgstr "le funzioni finestra non sono ammesse nell'espressione di una regola di sicurezza" -#: parser/parse_agg.c:794 +#: parser/parse_agg.c:809 msgid "window functions are not allowed in window definitions" msgstr "le funzioni finestra non sono ammesse nelle definizioni di finestre" -#: parser/parse_agg.c:825 +#: parser/parse_agg.c:840 msgid "window functions are not allowed in check constraints" msgstr "le funzioni finestra non sono ammesse nei vincoli di controllo" -#: parser/parse_agg.c:829 +#: parser/parse_agg.c:844 msgid "window functions are not allowed in DEFAULT expressions" msgstr "le funzioni finestra non sono ammesse nelle espressioni DEFAULT" -#: parser/parse_agg.c:832 +#: parser/parse_agg.c:847 msgid "window functions are not allowed in index expressions" msgstr "le funzioni finestra non sono ammesse nelle espressioni degli indici" -#: parser/parse_agg.c:835 +#: parser/parse_agg.c:850 msgid "window functions are not allowed in index predicates" msgstr "le funzioni finestra non sono ammesse nei predicati degli indici" -#: parser/parse_agg.c:838 +#: parser/parse_agg.c:853 msgid "window functions are not allowed in transform expressions" msgstr "le funzioni finestra non sono ammesse nelle espressioni di trasformazione" -#: parser/parse_agg.c:841 +#: parser/parse_agg.c:856 msgid "window functions are not allowed in EXECUTE parameters" msgstr "le funzioni finestra non sono ammesse nei parametri di EXECUTE" -#: parser/parse_agg.c:844 +#: parser/parse_agg.c:859 msgid "window functions are not allowed in trigger WHEN conditions" msgstr "le funzioni finestra non sono ammesse nelle condizioni WHEN dei trigger" #. translator: %s is name of a SQL construct, eg GROUP BY -#: parser/parse_agg.c:864 parser/parse_clause.c:1559 +#: parser/parse_agg.c:879 parser/parse_clause.c:1559 #, c-format msgid "window functions are not allowed in %s" msgstr "le funzioni finestra non sono ammesse in %s" -#: parser/parse_agg.c:898 parser/parse_clause.c:2396 +#: parser/parse_agg.c:913 parser/parse_clause.c:2396 #, c-format msgid "window \"%s\" does not exist" msgstr "la finestra \"%s\" non esiste" -#: parser/parse_agg.c:983 +#: parser/parse_agg.c:998 #, c-format msgid "too many grouping sets present (maximum 4096)" msgstr "troppi insiemi di raggruppamento presenti (il massimo è 4096)" -#: parser/parse_agg.c:1132 +#: parser/parse_agg.c:1147 #, c-format msgid "aggregate functions are not allowed in a recursive query's recursive term" msgstr "le funzioni di aggregazione non sono ammesse nel termine ricorsivo di una query ricorsiva" -#: parser/parse_agg.c:1325 +#: parser/parse_agg.c:1340 #, c-format msgid "column \"%s.%s\" must appear in the GROUP BY clause or be used in an aggregate function" msgstr "la colonna \"%s.%s\" deve comparire nella clausola GROUP BY o essere usata in una funzione di aggregazione" -#: parser/parse_agg.c:1328 +#: parser/parse_agg.c:1343 #, c-format msgid "Direct arguments of an ordered-set aggregate must use only grouped columns." msgstr "Gli argomenti diretti di un aggregato su insieme ordinato devono usare solo colonne raggruppate." -#: parser/parse_agg.c:1333 +#: parser/parse_agg.c:1348 #, c-format msgid "subquery uses ungrouped column \"%s.%s\" from outer query" msgstr "la sottoquery usa la colonna non raggruppata \"%s.%s\" dalla query esterna" -#: parser/parse_agg.c:1497 +#: parser/parse_agg.c:1512 #, c-format msgid "arguments to GROUPING must be grouping expressions of the associated query level" msgstr "gli argomenti di GROUPING devono essere espressioni di raggruppamento del livello della query associato" @@ -12659,7 +12682,7 @@ msgstr "Gli operatori di ordinamento devono essere i membri \"<\" oppure \">\" d #: parser/parse_coerce.c:971 parser/parse_coerce.c:1001 #: parser/parse_coerce.c:1019 parser/parse_coerce.c:1034 -#: parser/parse_expr.c:2015 parser/parse_expr.c:2528 parser/parse_target.c:874 +#: parser/parse_expr.c:2053 parser/parse_expr.c:2577 parser/parse_target.c:885 #, c-format msgid "cannot cast type %s to %s" msgstr "non è possibile convertire il tipo %s in %s" @@ -12883,173 +12906,173 @@ msgstr "FOR UPDATE/SHARE non è implementato in una query ricorsiva" msgid "recursive reference to query \"%s\" must not appear more than once" msgstr "il riferimento ricorsivo alla query \"%s\" non può apparire più di una volta" -#: parser/parse_expr.c:387 parser/parse_relation.c:3083 -#: parser/parse_relation.c:3103 +#: parser/parse_expr.c:390 parser/parse_relation.c:3176 +#: parser/parse_relation.c:3196 #, c-format msgid "column %s.%s does not exist" msgstr "la colonna %s.%s non esiste" -#: parser/parse_expr.c:399 +#: parser/parse_expr.c:402 #, c-format msgid "column \"%s\" not found in data type %s" msgstr "la colonna \"%s\" non è stata trovata nel tipo di dato %s" -#: parser/parse_expr.c:405 +#: parser/parse_expr.c:408 #, c-format msgid "could not identify column \"%s\" in record data type" msgstr "la colonna \"%s\" non identificata nel tipo di dato record" -#: parser/parse_expr.c:411 +#: parser/parse_expr.c:414 #, c-format msgid "column notation .%s applied to type %s, which is not a composite type" msgstr "la notazione della colonna .%s sembra essere di tipo %s, che non è un tipo composito" -#: parser/parse_expr.c:441 parser/parse_target.c:660 +#: parser/parse_expr.c:444 parser/parse_target.c:671 #, c-format msgid "row expansion via \"*\" is not supported here" msgstr "l'espansione della riga tramite \"*\" non è supportata qui" -#: parser/parse_expr.c:767 parser/parse_relation.c:667 -#: parser/parse_relation.c:767 parser/parse_target.c:1109 +#: parser/parse_expr.c:770 parser/parse_relation.c:668 +#: parser/parse_relation.c:768 parser/parse_target.c:1120 #, c-format msgid "column reference \"%s\" is ambiguous" msgstr "il riferimento alla colonna \"%s\" è ambiguo" -#: parser/parse_expr.c:823 parser/parse_param.c:110 parser/parse_param.c:142 +#: parser/parse_expr.c:826 parser/parse_param.c:110 parser/parse_param.c:142 #: parser/parse_param.c:199 parser/parse_param.c:298 #, c-format msgid "there is no parameter $%d" msgstr "parametro $%d non presente" -#: parser/parse_expr.c:1034 +#: parser/parse_expr.c:1067 #, c-format msgid "NULLIF requires = operator to yield boolean" msgstr "NULLIF richiede che l'operatore = restituisca un valore booleano" -#: parser/parse_expr.c:1468 gram.y:9867 +#: parser/parse_expr.c:1501 gram.y:9887 #, c-format msgid "number of columns does not match number of values" msgstr "il numero di colonne non corrisponde al numero di valori" -#: parser/parse_expr.c:1697 +#: parser/parse_expr.c:1730 msgid "cannot use subquery in check constraint" msgstr "non si può usare una sottoquery nel vincolo di controllo" -#: parser/parse_expr.c:1701 +#: parser/parse_expr.c:1734 msgid "cannot use subquery in DEFAULT expression" msgstr "non si può usare una sottoquery in un'espressione DEFAULT" -#: parser/parse_expr.c:1704 +#: parser/parse_expr.c:1737 msgid "cannot use subquery in index expression" msgstr "non si possono usare sottoquery nell'espressione dell'indice" -#: parser/parse_expr.c:1707 +#: parser/parse_expr.c:1740 msgid "cannot use subquery in index predicate" msgstr "non è possibile usare sottoquery nel predicato dell'indice" -#: parser/parse_expr.c:1710 +#: parser/parse_expr.c:1743 msgid "cannot use subquery in transform expression" msgstr "non è possibile usare sottoquery in un'espressione di trasformazione" -#: parser/parse_expr.c:1713 +#: parser/parse_expr.c:1746 msgid "cannot use subquery in EXECUTE parameter" msgstr "non si possono usare sottoquery nel parametro EXECUTE" -#: parser/parse_expr.c:1716 +#: parser/parse_expr.c:1749 msgid "cannot use subquery in trigger WHEN condition" msgstr "non è possibile usare sottoquery nella condizione WHEN del trigger" -#: parser/parse_expr.c:1770 +#: parser/parse_expr.c:1803 #, c-format msgid "subquery must return only one column" msgstr "la sottoquery deve restituire solo una colonna" -#: parser/parse_expr.c:1854 +#: parser/parse_expr.c:1887 #, c-format msgid "subquery has too many columns" msgstr "la sottoquery ha troppe colonne" -#: parser/parse_expr.c:1859 +#: parser/parse_expr.c:1892 #, c-format msgid "subquery has too few columns" msgstr "la sottoquery ha troppe poche colonne" -#: parser/parse_expr.c:1955 +#: parser/parse_expr.c:1993 #, c-format msgid "cannot determine type of empty array" msgstr "non è possibile determinare il tipo di un array vuoto" -#: parser/parse_expr.c:1956 +#: parser/parse_expr.c:1994 #, c-format msgid "Explicitly cast to the desired type, for example ARRAY[]::integer[]." msgstr "Effettua una conversione esplicita al tipo desiderato, ad esempio ARRAY[]::integer[]." -#: parser/parse_expr.c:1970 +#: parser/parse_expr.c:2008 #, c-format msgid "could not find element type for data type %s" msgstr "tipo dell'elemento non trovato per il tipo di dato %s" -#: parser/parse_expr.c:2193 +#: parser/parse_expr.c:2231 #, c-format msgid "unnamed XML attribute value must be a column reference" msgstr "il valore dell'attributo XML senza nome dev'essere un riferimento ad una colonna" -#: parser/parse_expr.c:2194 +#: parser/parse_expr.c:2232 #, c-format msgid "unnamed XML element value must be a column reference" msgstr "il valore dell'elemento XML senza nome dev'essere un riferimento ad una colonna" -#: parser/parse_expr.c:2209 +#: parser/parse_expr.c:2247 #, c-format msgid "XML attribute name \"%s\" appears more than once" msgstr "l'attributo XML di nome \"%s\" compare più di una volta" -#: parser/parse_expr.c:2316 +#: parser/parse_expr.c:2354 #, c-format msgid "cannot cast XMLSERIALIZE result to %s" msgstr "non è possibile convertire il risultato di XMLSERIALIZE a %s" -#: parser/parse_expr.c:2601 parser/parse_expr.c:2797 +#: parser/parse_expr.c:2650 parser/parse_expr.c:2846 #, c-format msgid "unequal number of entries in row expressions" msgstr "numero di elementi differente nelle espressioni di riga" -#: parser/parse_expr.c:2611 +#: parser/parse_expr.c:2660 #, c-format msgid "cannot compare rows of zero length" msgstr "non possono comparire righe di lunghezza zero" -#: parser/parse_expr.c:2636 +#: parser/parse_expr.c:2685 #, c-format msgid "row comparison operator must yield type boolean, not type %s" msgstr "l'operatore di comparazione tra righe deve restituire il tipo booleano, non il tipo %s" -#: parser/parse_expr.c:2643 +#: parser/parse_expr.c:2692 #, c-format msgid "row comparison operator must not return a set" msgstr "l'operatore di comparazione tra righe non può restituire un insieme" -#: parser/parse_expr.c:2702 parser/parse_expr.c:2743 +#: parser/parse_expr.c:2751 parser/parse_expr.c:2792 #, c-format msgid "could not determine interpretation of row comparison operator %s" msgstr "non è stato possibile determinare un'interpretazione dell'operatore di comparazione tra righe %s" -#: parser/parse_expr.c:2704 +#: parser/parse_expr.c:2753 #, c-format msgid "Row comparison operators must be associated with btree operator families." msgstr "Gli operatori di comparazione tra righe devono essere associati a famiglie di operatori btree." -#: parser/parse_expr.c:2745 +#: parser/parse_expr.c:2794 #, c-format msgid "There are multiple equally-plausible candidates." msgstr "C'è più di un candidato egualmente plausibile." -#: parser/parse_expr.c:2837 +#: parser/parse_expr.c:2886 #, c-format msgid "IS DISTINCT FROM requires = operator to yield boolean" msgstr "IS DISTINCT FROM richiede che l'operatore = restituisca un valore booleano" -#: parser/parse_expr.c:3127 parser/parse_expr.c:3145 +#: parser/parse_expr.c:3199 parser/parse_expr.c:3217 #, c-format msgid "operator precedence change: %s is now lower precedence than %s" msgstr "cambio di precedenza di operatori: %s ora ha precedenza inferiore di %s" @@ -13159,52 +13182,52 @@ msgstr "Nessuna funzione trovata con nome e tipi di argomenti forniti. Potrebbe msgid "VARIADIC argument must be an array" msgstr "l'argomento VARIADIC deve essere un array" -#: parser/parse_func.c:669 parser/parse_func.c:733 +#: parser/parse_func.c:671 parser/parse_func.c:735 #, c-format msgid "%s(*) must be used to call a parameterless aggregate function" msgstr "%s(*) dev'essere usato per richiamare una funzione di aggregazione senza parametri" -#: parser/parse_func.c:676 +#: parser/parse_func.c:678 #, c-format msgid "aggregates cannot return sets" msgstr "le funzioni di aggregazione non possono restituire insiemi" -#: parser/parse_func.c:691 +#: parser/parse_func.c:693 #, c-format msgid "aggregates cannot use named arguments" msgstr "le funzioni di aggregazione non possono usare argomenti con nome" -#: parser/parse_func.c:723 +#: parser/parse_func.c:725 #, c-format msgid "DISTINCT is not implemented for window functions" msgstr "DISTINCT non è implementato per funzioni finestra" -#: parser/parse_func.c:743 +#: parser/parse_func.c:745 #, c-format msgid "aggregate ORDER BY is not implemented for window functions" msgstr "ORDER BY delle funzioni di aggregazione non è implementato per funzioni finestra" -#: parser/parse_func.c:752 +#: parser/parse_func.c:754 #, c-format msgid "FILTER is not implemented for non-aggregate window functions" msgstr "FILTER non è implementato per funzioni finestra non aggregate" -#: parser/parse_func.c:758 +#: parser/parse_func.c:760 #, c-format msgid "window functions cannot return sets" msgstr "le funzioni finestra non possono restituire insiemi" -#: parser/parse_func.c:2008 +#: parser/parse_func.c:2010 #, c-format msgid "aggregate %s(*) does not exist" msgstr "la funzione di aggregazione %s(*) non esiste" -#: parser/parse_func.c:2013 +#: parser/parse_func.c:2015 #, c-format msgid "aggregate %s does not exist" msgstr "la funzione di aggregazione %s non esiste" -#: parser/parse_func.c:2032 +#: parser/parse_func.c:2034 #, c-format msgid "function %s is not an aggregate" msgstr "la funzione %s non è una funzione di aggregazione" @@ -13240,9 +13263,9 @@ msgstr "l'operatore non esiste: %s" msgid "Use an explicit ordering operator or modify the query." msgstr "Usa un operatore di ordinamento esplicito, oppure modifica la query." -#: parser/parse_oper.c:226 utils/adt/array_userfuncs.c:782 -#: utils/adt/array_userfuncs.c:920 utils/adt/arrayfuncs.c:3639 -#: utils/adt/arrayfuncs.c:4077 utils/adt/arrayfuncs.c:6055 +#: parser/parse_oper.c:226 utils/adt/array_userfuncs.c:794 +#: utils/adt/array_userfuncs.c:933 utils/adt/arrayfuncs.c:3639 +#: utils/adt/arrayfuncs.c:4077 utils/adt/arrayfuncs.c:6039 #: utils/adt/rowtypes.c:1167 #, c-format msgid "could not identify an equality operator for type %s" @@ -13293,158 +13316,158 @@ msgstr "op ANY/ALL (array) richiede che l'operatore non restituisca un insieme" msgid "inconsistent types deduced for parameter $%d" msgstr "tipi di dati dedotti per il parametro $%d non consistenti" -#: parser/parse_relation.c:174 +#: parser/parse_relation.c:175 #, c-format msgid "table reference \"%s\" is ambiguous" msgstr "il riferimento alla tabella \"%s\" è ambiguo" -#: parser/parse_relation.c:218 +#: parser/parse_relation.c:219 #, c-format msgid "table reference %u is ambiguous" msgstr "il riferimento alla tabella %u è ambiguo" -#: parser/parse_relation.c:397 +#: parser/parse_relation.c:398 #, c-format msgid "table name \"%s\" specified more than once" msgstr "la tabella di nome \"%s\" è stata specificata più di una volta" -#: parser/parse_relation.c:424 parser/parse_relation.c:3023 +#: parser/parse_relation.c:425 parser/parse_relation.c:3116 #, c-format msgid "invalid reference to FROM-clause entry for table \"%s\"" msgstr "riferimento non valido all'elemento della clausola FROM per la tabella \"%s\"" -#: parser/parse_relation.c:427 parser/parse_relation.c:3028 +#: parser/parse_relation.c:428 parser/parse_relation.c:3121 #, c-format msgid "There is an entry for table \"%s\", but it cannot be referenced from this part of the query." msgstr "C'è un elemento per la tabella \"%s\", ma non può essere referenziato da questa parte della query." -#: parser/parse_relation.c:429 +#: parser/parse_relation.c:430 #, c-format msgid "The combining JOIN type must be INNER or LEFT for a LATERAL reference." msgstr "Il tipo del JOIN deve essere INNER oppure LEFT per un riferimento LATERAL." -#: parser/parse_relation.c:705 +#: parser/parse_relation.c:706 #, c-format msgid "system column \"%s\" reference in check constraint is invalid" msgstr "la colonna di sistema \"%s\" referenziata nel vincolo di controllo non è valida" -#: parser/parse_relation.c:1065 parser/parse_relation.c:1345 -#: parser/parse_relation.c:1847 +#: parser/parse_relation.c:1066 parser/parse_relation.c:1346 +#: parser/parse_relation.c:1848 #, c-format msgid "table \"%s\" has %d columns available but %d columns specified" msgstr "la tabella \"%s\" ha %d colonne disponibili ma %d colonne specificate" -#: parser/parse_relation.c:1152 +#: parser/parse_relation.c:1153 #, c-format msgid "There is a WITH item named \"%s\", but it cannot be referenced from this part of the query." msgstr "C'è un elemento di WITH di nome \"%s\", ma non può essere referenziato da questa parte della query." -#: parser/parse_relation.c:1154 +#: parser/parse_relation.c:1155 #, c-format msgid "Use WITH RECURSIVE, or re-order the WITH items to remove forward references." msgstr "Usa WITH RECURSIVE, oppure riordina gli elementi di WITH per rimuovere i riferimenti in avanti." -#: parser/parse_relation.c:1465 +#: parser/parse_relation.c:1466 #, c-format msgid "a column definition list is only allowed for functions returning \"record\"" msgstr "la lista di definizione di colonne è consentita solo per funzioni che restituiscono \"record\"" -#: parser/parse_relation.c:1474 +#: parser/parse_relation.c:1475 #, c-format msgid "a column definition list is required for functions returning \"record\"" msgstr "la lista di definizione di colonne è necessaria per funzioni che restituiscono \"record\"" -#: parser/parse_relation.c:1553 +#: parser/parse_relation.c:1554 #, c-format msgid "function \"%s\" in FROM has unsupported return type %s" msgstr "la funzione \"%s\" in FROM restituisce il tipo non supportato %s" -#: parser/parse_relation.c:1675 +#: parser/parse_relation.c:1676 #, c-format msgid "VALUES lists \"%s\" have %d columns available but %d columns specified" msgstr "le liste VALUES \"%s\" hanno %d colonne disponibili ma %d colonne specificate" -#: parser/parse_relation.c:1730 +#: parser/parse_relation.c:1731 #, c-format msgid "joins can have at most %d columns" msgstr "i join possono avere al più %d colonne" -#: parser/parse_relation.c:1820 +#: parser/parse_relation.c:1821 #, c-format msgid "WITH query \"%s\" does not have a RETURNING clause" msgstr "la query WITH \"%s\" non ha una clausola RETURNING" -#: parser/parse_relation.c:2652 parser/parse_relation.c:2807 +#: parser/parse_relation.c:2738 parser/parse_relation.c:2900 #, c-format msgid "column %d of relation \"%s\" does not exist" msgstr "la colonna %d della relazione \"%s\" non esiste" -#: parser/parse_relation.c:3026 +#: parser/parse_relation.c:3119 #, c-format msgid "Perhaps you meant to reference the table alias \"%s\"." msgstr "Forse intendevi utilizzare l'alias \"%s\" della tabella." -#: parser/parse_relation.c:3034 +#: parser/parse_relation.c:3127 #, c-format msgid "missing FROM-clause entry for table \"%s\"" msgstr "elemento FROM per la tabella \"%s\" mancante" -#: parser/parse_relation.c:3086 +#: parser/parse_relation.c:3179 #, c-format msgid "Perhaps you meant to reference the column \"%s.%s\"." msgstr "Forse intendevi referenziare la colonna \"%s.%s\"." -#: parser/parse_relation.c:3088 +#: parser/parse_relation.c:3181 #, c-format msgid "There is a column named \"%s\" in table \"%s\", but it cannot be referenced from this part of the query." msgstr "Esiste una colonna di nome \"%s\" nella tabella \"%s\", ma non può essere referenziata da questa parte della query." -#: parser/parse_relation.c:3105 +#: parser/parse_relation.c:3198 #, c-format msgid "Perhaps you meant to reference the column \"%s.%s\" or the column \"%s.%s\"." msgstr "Forse intendevi referenziare la colonna \"%s.%s\" o la colonna \"%s.%s\"." -#: parser/parse_target.c:421 parser/parse_target.c:713 +#: parser/parse_target.c:432 parser/parse_target.c:724 #, c-format msgid "cannot assign to system column \"%s\"" msgstr "non è possibile assegnare alla colonna di sistema \"%s\"" -#: parser/parse_target.c:449 +#: parser/parse_target.c:460 #, c-format msgid "cannot set an array element to DEFAULT" msgstr "non è possibile impostare gli elementi di un array a DEFAULT" -#: parser/parse_target.c:454 +#: parser/parse_target.c:465 #, c-format msgid "cannot set a subfield to DEFAULT" msgstr "non è possibile impostare un sottocampo a DEFAULT" -#: parser/parse_target.c:523 +#: parser/parse_target.c:534 #, c-format msgid "column \"%s\" is of type %s but expression is of type %s" msgstr "la colonna \"%s\" è di tipo %s ma l'espressione è di tipo %s" -#: parser/parse_target.c:697 +#: parser/parse_target.c:708 #, c-format msgid "cannot assign to field \"%s\" of column \"%s\" because its type %s is not a composite type" msgstr "non è possibile assegnare al campo \"%s\" della colonna \"%s\" perché il suo tipo %s non è un tipo composito" -#: parser/parse_target.c:706 +#: parser/parse_target.c:717 #, c-format msgid "cannot assign to field \"%s\" of column \"%s\" because there is no such column in data type %s" msgstr "non è possibile assegnare al campo \"%s\" della colonna \"%s\" perché non questa colonna non compare nel tipo di dato %s" -#: parser/parse_target.c:773 +#: parser/parse_target.c:784 #, c-format msgid "array assignment to \"%s\" requires type %s but expression is of type %s" msgstr "l'assegnamento array a \"%s\" richiede il tipo %s ma l'espressione è di tipo %s" -#: parser/parse_target.c:783 +#: parser/parse_target.c:794 #, c-format msgid "subfield \"%s\" is of type %s but expression is of type %s" msgstr "il sottocampo \"%s\" è di tipo %s ma l'espressione è di tipo %s" -#: parser/parse_target.c:1199 +#: parser/parse_target.c:1210 #, c-format msgid "SELECT * with no tables specified is not valid" msgstr "SELECT * senza tabelle specificate non è consentito" @@ -13484,224 +13507,224 @@ msgstr "i modificatori di tipo devono essere costanti o identificatori semplici" msgid "invalid type name \"%s\"" msgstr "nome di tipo \"%s\" non valido" -#: parser/parse_utilcmd.c:399 +#: parser/parse_utilcmd.c:384 #, c-format msgid "array of serial is not implemented" msgstr "gli array di serial non sono implementati" -#: parser/parse_utilcmd.c:447 +#: parser/parse_utilcmd.c:432 #, c-format msgid "%s will create implicit sequence \"%s\" for serial column \"%s.%s\"" msgstr "%s creerà la sequenza implicita \"%s\" per la colonna serial \"%s.%s\"" -#: parser/parse_utilcmd.c:541 parser/parse_utilcmd.c:553 +#: parser/parse_utilcmd.c:526 parser/parse_utilcmd.c:538 #, c-format msgid "conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"" msgstr "dichiarazioni NULL/NOT NULL in conflitto per la colonna \"%s\" della tabella \"%s\"" -#: parser/parse_utilcmd.c:565 +#: parser/parse_utilcmd.c:550 #, c-format msgid "multiple default values specified for column \"%s\" of table \"%s\"" msgstr "più di un valore predefinito specificato per la colonna \"%s\" della tabella \"%s\"" -#: parser/parse_utilcmd.c:582 parser/parse_utilcmd.c:673 +#: parser/parse_utilcmd.c:567 parser/parse_utilcmd.c:658 #, c-format msgid "primary key constraints are not supported on foreign tables" msgstr "i vincoli di chiave primaria non sono supportati sulle tabelle esterne" -#: parser/parse_utilcmd.c:591 parser/parse_utilcmd.c:683 +#: parser/parse_utilcmd.c:576 parser/parse_utilcmd.c:668 #, c-format msgid "unique constraints are not supported on foreign tables" msgstr "i vincoli di unicità non sono supportati sulle tabelle esterne" -#: parser/parse_utilcmd.c:608 parser/parse_utilcmd.c:707 +#: parser/parse_utilcmd.c:593 parser/parse_utilcmd.c:692 #, c-format msgid "foreign key constraints are not supported on foreign tables" msgstr "i vincoli di chiave esterna non sono supportati sulle tabelle esterne" -#: parser/parse_utilcmd.c:693 +#: parser/parse_utilcmd.c:678 #, c-format msgid "exclusion constraints are not supported on foreign tables" msgstr "i vincoli esclusione non sono supportati sulle tabelle esterne" -#: parser/parse_utilcmd.c:757 +#: parser/parse_utilcmd.c:742 #, c-format msgid "LIKE is not supported for creating foreign tables" msgstr "LIKE non è supportato nella creazione di tabelle esterne" -#: parser/parse_utilcmd.c:1288 parser/parse_utilcmd.c:1364 +#: parser/parse_utilcmd.c:1275 parser/parse_utilcmd.c:1351 #, c-format msgid "Index \"%s\" contains a whole-row table reference." msgstr "L'indice \"%s\" contiene un riferimento all'intera riga della tabella." -#: parser/parse_utilcmd.c:1634 +#: parser/parse_utilcmd.c:1621 #, c-format msgid "cannot use an existing index in CREATE TABLE" msgstr "non è possibile usare un indice preesistente in CREATE TABLE" -#: parser/parse_utilcmd.c:1654 +#: parser/parse_utilcmd.c:1641 #, c-format msgid "index \"%s\" is already associated with a constraint" msgstr "l'indice \"%s\" è già associato ad un vincolo" -#: parser/parse_utilcmd.c:1662 +#: parser/parse_utilcmd.c:1649 #, c-format msgid "index \"%s\" does not belong to table \"%s\"" msgstr "l'indice \"%s\" non appartiene alla tabella \"%s\"" -#: parser/parse_utilcmd.c:1669 +#: parser/parse_utilcmd.c:1656 #, c-format msgid "index \"%s\" is not valid" msgstr "l'indice \"%s\" non è valido" -#: parser/parse_utilcmd.c:1675 +#: parser/parse_utilcmd.c:1662 #, c-format msgid "\"%s\" is not a unique index" msgstr "\"%s\" non è un indice univoco" -#: parser/parse_utilcmd.c:1676 parser/parse_utilcmd.c:1683 -#: parser/parse_utilcmd.c:1690 parser/parse_utilcmd.c:1760 +#: parser/parse_utilcmd.c:1663 parser/parse_utilcmd.c:1670 +#: parser/parse_utilcmd.c:1677 parser/parse_utilcmd.c:1747 #, c-format msgid "Cannot create a primary key or unique constraint using such an index." msgstr "Non è possibile creare una chiave primaria o un vincolo univoco usando tale indice." -#: parser/parse_utilcmd.c:1682 +#: parser/parse_utilcmd.c:1669 #, c-format msgid "index \"%s\" contains expressions" msgstr "l'indice \"%s\" contiene espressioni" -#: parser/parse_utilcmd.c:1689 +#: parser/parse_utilcmd.c:1676 #, c-format msgid "\"%s\" is a partial index" msgstr "\"%s\" è un indice parziale" -#: parser/parse_utilcmd.c:1701 +#: parser/parse_utilcmd.c:1688 #, c-format msgid "\"%s\" is a deferrable index" msgstr "\"%s\" è un indice deferibile" -#: parser/parse_utilcmd.c:1702 +#: parser/parse_utilcmd.c:1689 #, c-format msgid "Cannot create a non-deferrable constraint using a deferrable index." msgstr "Non è possibile creare un vincolo non deferibile usando un indice deferibile." -#: parser/parse_utilcmd.c:1759 +#: parser/parse_utilcmd.c:1746 #, c-format msgid "index \"%s\" does not have default sorting behavior" msgstr "l'indice \"%s\" non ha un ordinamento predefinito" -#: parser/parse_utilcmd.c:1906 +#: parser/parse_utilcmd.c:1893 #, c-format msgid "column \"%s\" appears twice in primary key constraint" msgstr "la colonna \"%s\" appare due volte nel vincolo di chiave primaria" -#: parser/parse_utilcmd.c:1912 +#: parser/parse_utilcmd.c:1899 #, c-format msgid "column \"%s\" appears twice in unique constraint" msgstr "la colonna \"%s\" appare due volte nel vincolo univoco" -#: parser/parse_utilcmd.c:2116 +#: parser/parse_utilcmd.c:2103 #, c-format msgid "index expression cannot return a set" msgstr "l'espressione dell'indice non può restituire un insieme" -#: parser/parse_utilcmd.c:2127 +#: parser/parse_utilcmd.c:2114 #, c-format msgid "index expressions and predicates can refer only to the table being indexed" msgstr "le espressioni e i predicati dell'indice possono riferirsi solo alla tabella indicizzata" -#: parser/parse_utilcmd.c:2173 +#: parser/parse_utilcmd.c:2160 #, c-format msgid "rules on materialized views are not supported" msgstr "le regole sulle viste materializzate non sono supportate" -#: parser/parse_utilcmd.c:2234 +#: parser/parse_utilcmd.c:2221 #, c-format msgid "rule WHERE condition cannot contain references to other relations" msgstr "le condizioni WHERE delle regole non possono avere riferimenti ad altre relazioni" -#: parser/parse_utilcmd.c:2306 +#: parser/parse_utilcmd.c:2293 #, c-format msgid "rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE actions" msgstr "le regole con una condizione WHERE possono avere solo azione SELECT, INSERT, UPDATE o DELETE" -#: parser/parse_utilcmd.c:2324 parser/parse_utilcmd.c:2423 +#: parser/parse_utilcmd.c:2311 parser/parse_utilcmd.c:2410 #: rewrite/rewriteHandler.c:485 rewrite/rewriteManip.c:1015 #, c-format msgid "conditional UNION/INTERSECT/EXCEPT statements are not implemented" msgstr "le istruzioni UNION/INTERSECT/EXCEPT condizionali non sono implementate" -#: parser/parse_utilcmd.c:2342 +#: parser/parse_utilcmd.c:2329 #, c-format msgid "ON SELECT rule cannot use OLD" msgstr "la regola ON SELECT non può usare OLD" -#: parser/parse_utilcmd.c:2346 +#: parser/parse_utilcmd.c:2333 #, c-format msgid "ON SELECT rule cannot use NEW" msgstr "la regola ON SELECT non può usare NEW" -#: parser/parse_utilcmd.c:2355 +#: parser/parse_utilcmd.c:2342 #, c-format msgid "ON INSERT rule cannot use OLD" msgstr "la regola ON INSERT non può usare OLD" -#: parser/parse_utilcmd.c:2361 +#: parser/parse_utilcmd.c:2348 #, c-format msgid "ON DELETE rule cannot use NEW" msgstr "La regola ON DELETE non può usare NEW" -#: parser/parse_utilcmd.c:2389 +#: parser/parse_utilcmd.c:2376 #, c-format msgid "cannot refer to OLD within WITH query" msgstr "non ci si può riferire ad OLD nella query WITH" -#: parser/parse_utilcmd.c:2396 +#: parser/parse_utilcmd.c:2383 #, c-format msgid "cannot refer to NEW within WITH query" msgstr "non ci si può riferire a NEW nella query WITH" -#: parser/parse_utilcmd.c:2599 +#: parser/parse_utilcmd.c:2586 #, c-format msgid "transform expression must not return a set" msgstr "l'espressione di trasformazione non può restituire un insieme" -#: parser/parse_utilcmd.c:2713 +#: parser/parse_utilcmd.c:2700 #, c-format msgid "misplaced DEFERRABLE clause" msgstr "clausola DEFERRABLE mal posizionata" -#: parser/parse_utilcmd.c:2718 parser/parse_utilcmd.c:2733 +#: parser/parse_utilcmd.c:2705 parser/parse_utilcmd.c:2720 #, c-format msgid "multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed" msgstr "clausole DEFERRABLE/NOT DEFERRABLE multiple non consentite" -#: parser/parse_utilcmd.c:2728 +#: parser/parse_utilcmd.c:2715 #, c-format msgid "misplaced NOT DEFERRABLE clause" msgstr "clausola NOT DEFERRABLE mal posizionata" -#: parser/parse_utilcmd.c:2741 parser/parse_utilcmd.c:2767 gram.y:4893 +#: parser/parse_utilcmd.c:2728 parser/parse_utilcmd.c:2754 gram.y:4902 #, c-format msgid "constraint declared INITIALLY DEFERRED must be DEFERRABLE" msgstr "un vincolo dichiarato INITIALLY DEFERRED dev'essere DEFERRABLE" -#: parser/parse_utilcmd.c:2749 +#: parser/parse_utilcmd.c:2736 #, c-format msgid "misplaced INITIALLY DEFERRED clause" msgstr "clausola INITIALLY DEFERRED mal posizionata" -#: parser/parse_utilcmd.c:2754 parser/parse_utilcmd.c:2780 +#: parser/parse_utilcmd.c:2741 parser/parse_utilcmd.c:2767 #, c-format msgid "multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed" msgstr "clausole INITIALLY IMMEDIATE/DEFERRED multiple non sono consentite" -#: parser/parse_utilcmd.c:2775 +#: parser/parse_utilcmd.c:2762 #, c-format msgid "misplaced INITIALLY IMMEDIATE clause" msgstr "clausola INITIALLY IMMEDIATE mal posizionata" -#: parser/parse_utilcmd.c:2966 +#: parser/parse_utilcmd.c:2953 #, c-format msgid "CREATE specifies a schema (%s) different from the one being created (%s)" msgstr "CREATE specifica uno schema (%s) differente da quello che sta venendo creato (%s)" @@ -13735,17 +13758,17 @@ msgstr "" msgid "You possibly need to raise your kernel's SEMVMX value to be at least %d. Look into the PostgreSQL documentation for details." msgstr "Potresti dover aumentare il valore SEMVMX del tuo kernel ad almeno %d. Consulta la documentazione di PostgreSQL per ulteriori dettagli." -#: port/pg_shmem.c:141 port/sysv_shmem.c:141 +#: port/pg_shmem.c:175 port/sysv_shmem.c:175 #, c-format msgid "could not create shared memory segment: %m" msgstr "creazione del segmento di memoria condivisa fallita: %m" -#: port/pg_shmem.c:142 port/sysv_shmem.c:142 +#: port/pg_shmem.c:176 port/sysv_shmem.c:176 #, c-format msgid "Failed system call was shmget(key=%lu, size=%zu, 0%o)." msgstr "La chiamata di sistema fallita era shmget(key=%lu, size=%zu, 0%o)." -#: port/pg_shmem.c:146 port/sysv_shmem.c:146 +#: port/pg_shmem.c:180 port/sysv_shmem.c:180 #, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter, or possibly that it is less than your kernel's SHMMIN parameter.\n" @@ -13754,7 +13777,7 @@ msgstr "" "Questo errore di solito vuol dire che la richiesta di PostgreSQL di un segmento di memoria condivisa eccede il valore del parametro SHMMAX del tuo kernel, o anche che sia inferiore del parametro SHMMIN.\n" "La documentazione di PostgreSQL contiene ulteriori informazioni sulla configurazione della memoria condivisa." -#: port/pg_shmem.c:153 port/sysv_shmem.c:153 +#: port/pg_shmem.c:187 port/sysv_shmem.c:187 #, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMALL parameter. You might need to reconfigure the kernel with larger SHMALL.\n" @@ -13763,7 +13786,7 @@ msgstr "" "Questo errore di solito vuol dire che la richiesta di PostgreSQL di un segmento di memoria condivisa eccede il valore del parametro SHMALL del tuo kernel. Potresti dover riconfigurare il kernel con uno SHMALL più grande.\n" "La documentazione di PostgreSQL contiene ulteriori informazioni sulla configurazione della memoria condivisa." -#: port/pg_shmem.c:159 port/sysv_shmem.c:159 +#: port/pg_shmem.c:193 port/sysv_shmem.c:193 #, c-format msgid "" "This error does *not* mean that you have run out of disk space. It occurs either if all available shared memory IDs have been taken, in which case you need to raise the SHMMNI parameter in your kernel, or because the system's overall limit for shared memory has been reached.\n" @@ -13772,52 +13795,47 @@ msgstr "" "Questo errore *non* significa che è finito lo spazio su disco. Può succedere se tutti gli ID di memoria condivisa sono stati presi, nel cui caso è necessario aumentare il parametro SHMMNI del tuo kernel, oppure perché il limite globale la memoria condivisa di sistema è stato raggiunto.\n" "La documentazione di PostgreSQL contiene ulteriori informazioni sulla configurazione della memoria condivisa." -#: port/pg_shmem.c:340 port/sysv_shmem.c:340 -#, c-format -msgid "huge TLB pages not supported on this platform" -msgstr "pagine TLB huge non supportate su questa piattaforma" - -#: port/pg_shmem.c:390 port/sysv_shmem.c:390 +#: port/pg_shmem.c:483 port/sysv_shmem.c:483 #, c-format msgid "could not map anonymous shared memory: %m" msgstr "mappatura della memoria condivisa anonima fallita: %m" -#: port/pg_shmem.c:392 port/sysv_shmem.c:392 +#: port/pg_shmem.c:485 port/sysv_shmem.c:485 #, c-format msgid "This error usually means that PostgreSQL's request for a shared memory segment exceeded available memory, swap space, or huge pages. To reduce the request size (currently %zu bytes), reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections." msgstr "Questo errore di solito vuol dire che la richiesta di PostgreSQL di un segmento di memoria condivisa supera la memoria disponibile, lo spazio di swap o le pagine huge. Per ridurre la dimensione richiesta (attualmente %zu byte), riduci l'utilizzo di memoria condivisa di PostgreSQL, ad esempio riducendo shared_buffers o max_connections." -#: port/pg_shmem.c:439 port/sysv_shmem.c:439 port/win32_shmem.c:134 +#: port/pg_shmem.c:551 port/sysv_shmem.c:551 port/win32_shmem.c:134 #, c-format msgid "huge pages not supported on this platform" msgstr "pagine huge non supportate su questa piattaforma" -#: port/pg_shmem.c:553 port/sysv_shmem.c:553 +#: port/pg_shmem.c:646 port/sysv_shmem.c:646 #, c-format msgid "could not stat data directory \"%s\": %m" msgstr "non è stato possibile ottenere informazioni sulla directory dati \"%s\": %m" -#: port/win32/crashdump.c:108 +#: port/win32/crashdump.c:122 #, c-format msgid "could not load dbghelp.dll, cannot write crash dump\n" msgstr "caricamento di dbghelp.dll fallito, impossibile salvare il crash dump\n" -#: port/win32/crashdump.c:116 +#: port/win32/crashdump.c:130 #, c-format msgid "could not load required functions in dbghelp.dll, cannot write crash dump\n" msgstr "caricamento della funzione richiesta in dbghelp.dll fallito, impossibile salvare il crash dump\n" -#: port/win32/crashdump.c:147 +#: port/win32/crashdump.c:161 #, c-format msgid "could not open crash dump file \"%s\" for writing: error code %lu\n" msgstr "apertura del file del crash dump \"%s\" in scrittura fallito: codice errore %lu\n" -#: port/win32/crashdump.c:154 +#: port/win32/crashdump.c:168 #, c-format msgid "wrote crash dump to file \"%s\"\n" msgstr "crash dump salvato nel file \"%s\"\n" -#: port/win32/crashdump.c:156 +#: port/win32/crashdump.c:170 #, c-format msgid "could not write crash dump to file \"%s\": error code %lu\n" msgstr "scrittura del crash dump nel file \"%s\" fallito: codice errore %lu\n" @@ -13887,22 +13905,22 @@ msgstr "La chiamata di sistema fallita era DuplicateHandle." msgid "Failed system call was MapViewOfFileEx." msgstr "La chiamata di sistema fallita era MapViewOfFileEx." -#: postmaster/autovacuum.c:377 +#: postmaster/autovacuum.c:380 #, c-format msgid "could not fork autovacuum launcher process: %m" msgstr "fork del processo di esecuzione di autovacuum fallito: %m" -#: postmaster/autovacuum.c:413 +#: postmaster/autovacuum.c:416 #, c-format msgid "autovacuum launcher started" msgstr "esecutore di autovacuum avviato" -#: postmaster/autovacuum.c:775 +#: postmaster/autovacuum.c:779 #, c-format msgid "autovacuum launcher shutting down" msgstr "arresto dell'esecutore di autovacuum" -#: postmaster/autovacuum.c:1443 +#: postmaster/autovacuum.c:1441 #, c-format msgid "could not fork autovacuum worker process: %m" msgstr "fork del processo di lavoro di autovacuum fallito: %m" @@ -13912,37 +13930,37 @@ msgstr "fork del processo di lavoro di autovacuum fallito: %m" msgid "autovacuum: processing database \"%s\"" msgstr "autovacuum: elaborazione del database \"%s\"" -#: postmaster/autovacuum.c:2051 +#: postmaster/autovacuum.c:2052 #, c-format msgid "autovacuum: dropping orphan temp table \"%s\".\"%s\" in database \"%s\"" msgstr "autovacuum: eliminazione della tabella temporanea orfana \"%s\".\"%s\" nel database \"%s\"" -#: postmaster/autovacuum.c:2063 +#: postmaster/autovacuum.c:2064 #, c-format msgid "autovacuum: found orphan temp table \"%s\".\"%s\" in database \"%s\"" msgstr "autovacuum: trovata tabella temporanea orfana \"%s\".\"%s\" nel database \"%s\"" -#: postmaster/autovacuum.c:2346 +#: postmaster/autovacuum.c:2347 #, c-format msgid "automatic vacuum of table \"%s.%s.%s\"" msgstr "pulizia automatica della tabella \"%s.%s.%s\"" -#: postmaster/autovacuum.c:2349 +#: postmaster/autovacuum.c:2350 #, c-format msgid "automatic analyze of table \"%s.%s.%s\"" msgstr "analisi automatica della tabella \"%s.%s.%s\"" -#: postmaster/autovacuum.c:2877 +#: postmaster/autovacuum.c:2899 #, c-format msgid "autovacuum not started because of misconfiguration" msgstr "autovacuum non avviato a causa di configurazione errata" -#: postmaster/autovacuum.c:2878 +#: postmaster/autovacuum.c:2900 #, c-format msgid "Enable the \"track_counts\" option." msgstr "Abilita l'opzione \"track_counts\"." -#: postmaster/bgworker.c:346 postmaster/bgworker.c:746 +#: postmaster/bgworker.c:346 postmaster/bgworker.c:745 #, c-format msgid "registering background worker \"%s\"" msgstr "registrazione del processo di lavoro in background \"%s\"" @@ -13972,61 +13990,61 @@ msgstr "processo di lavoro in background \"%s\": intervallo di riavvio non valid msgid "terminating background worker \"%s\" due to administrator command" msgstr "interruzione del processo di lavoro in background \"%s\" a causa di comando amministrativo" -#: postmaster/bgworker.c:753 +#: postmaster/bgworker.c:752 #, c-format msgid "background worker \"%s\": must be registered in shared_preload_libraries" msgstr "processo di lavoro in background \"%s\": deve essere registrato in shared_preload_libraries" -#: postmaster/bgworker.c:765 +#: postmaster/bgworker.c:764 #, c-format msgid "background worker \"%s\": only dynamic background workers can request notification" msgstr "processo di lavoro in background \"%s\": solo i processi dinamici possono richiedere notifiche" -#: postmaster/bgworker.c:780 +#: postmaster/bgworker.c:779 #, c-format msgid "too many background workers" msgstr "troppi processi di lavoro in background" -#: postmaster/bgworker.c:781 +#: postmaster/bgworker.c:780 #, c-format msgid "Up to %d background worker can be registered with the current settings." msgid_plural "Up to %d background workers can be registered with the current settings." msgstr[0] "Le impostazioni correnti consentono la registrazione di un massimo di %d processi di lavoro in background." msgstr[1] "Le impostazioni correnti consentono la registrazione di un massimo di %d processi di lavoro in background." -#: postmaster/bgworker.c:785 +#: postmaster/bgworker.c:784 #, c-format msgid "Consider increasing the configuration parameter \"max_worker_processes\"." msgstr "Considera di incrementare il parametro di configurazione \"max_worker_processes\"." -#: postmaster/checkpointer.c:465 +#: postmaster/checkpointer.c:463 #, c-format msgid "checkpoints are occurring too frequently (%d second apart)" msgid_plural "checkpoints are occurring too frequently (%d seconds apart)" msgstr[0] "i checkpoint stanno avvenendo troppo frequentemente (a distanza di %d secondo)" msgstr[1] "i checkpoint stanno avvenendo troppo frequentemente (a distanza di %d secondi)" -#: postmaster/checkpointer.c:469 +#: postmaster/checkpointer.c:467 #, c-format msgid "Consider increasing the configuration parameter \"max_wal_size\"." msgstr "Considera di incrementare il parametro di configurazione \"max_wal_size\"." -#: postmaster/checkpointer.c:616 +#: postmaster/checkpointer.c:614 #, c-format msgid "transaction log switch forced (archive_timeout=%d)" msgstr "passaggio al prossimo log delle transazioni forzato (archive_timeout=%d)" -#: postmaster/checkpointer.c:1074 +#: postmaster/checkpointer.c:1072 #, c-format msgid "checkpoint request failed" msgstr "richiesta di checkpoint fallita" -#: postmaster/checkpointer.c:1075 +#: postmaster/checkpointer.c:1073 #, c-format msgid "Consult recent messages in the server log for details." msgstr "Consulta i messaggi recenti nel log del server per i dettagli." -#: postmaster/checkpointer.c:1270 +#: postmaster/checkpointer.c:1268 #, c-format msgid "compacted fsync request queue from %d entries to %d entries" msgstr "coda di richieste di fsync ridotta da %d a %d elementi" @@ -14062,7 +14080,7 @@ msgstr "Il comando di archiviazione fallito era: %s" msgid "archive command was terminated by exception 0x%X" msgstr "comando di archiviazione terminato da eccezione 0x%X" -#: postmaster/pgarch.c:598 postmaster/postmaster.c:3478 +#: postmaster/pgarch.c:598 postmaster/postmaster.c:3491 #, c-format msgid "See C include file \"ntstatus.h\" for a description of the hexadecimal value." msgstr "Consulta il file include C \"ntstatus.h\" per una spiegazione del valore esadecimale." @@ -14092,293 +14110,293 @@ msgstr "file di log delle transazioni archiviato \"%s\"" msgid "could not open archive status directory \"%s\": %m" msgstr "apertura della directory dello stato dell'archivio \"%s\" fallita: %m" -#: postmaster/pgstat.c:356 +#: postmaster/pgstat.c:355 #, c-format msgid "could not resolve \"localhost\": %s" msgstr "risoluzione di \"localhost\" fallita: %s" -#: postmaster/pgstat.c:379 +#: postmaster/pgstat.c:378 #, c-format msgid "trying another address for the statistics collector" msgstr "si sta tentando di usare un diverso indirizzo per il raccoglitore di statistiche" -#: postmaster/pgstat.c:388 +#: postmaster/pgstat.c:387 #, c-format msgid "could not create socket for statistics collector: %m" msgstr "creazione del socket per il raccoglitore di statistiche fallita: %m" -#: postmaster/pgstat.c:400 +#: postmaster/pgstat.c:399 #, c-format msgid "could not bind socket for statistics collector: %m" msgstr "bind del socket per il raccoglitore di statistiche fallito: %m" -#: postmaster/pgstat.c:411 +#: postmaster/pgstat.c:410 #, c-format msgid "could not get address of socket for statistics collector: %m" msgstr "non è stato possibile ottenere l'indirizzo del socket per il raccoglitore di statistiche: %m" -#: postmaster/pgstat.c:427 +#: postmaster/pgstat.c:426 #, c-format msgid "could not connect socket for statistics collector: %m" msgstr "connessione al socket per il raccoglitore statistiche fallita: %m" -#: postmaster/pgstat.c:448 +#: postmaster/pgstat.c:447 #, c-format msgid "could not send test message on socket for statistics collector: %m" msgstr "invio del messaggio di prova al socket per il raccoglitore di statistiche fallito: %m" -#: postmaster/pgstat.c:474 +#: postmaster/pgstat.c:473 #, c-format msgid "select() failed in statistics collector: %m" msgstr "select() fallita nel raccoglitore di statistiche: %m" -#: postmaster/pgstat.c:489 +#: postmaster/pgstat.c:488 #, c-format msgid "test message did not get through on socket for statistics collector" msgstr "il messaggio di prova non ha raggiunto il socket per il raccoglitore di statistiche" -#: postmaster/pgstat.c:504 +#: postmaster/pgstat.c:503 #, c-format msgid "could not receive test message on socket for statistics collector: %m" msgstr "ricezione del messaggio di prova sul socket per il raccoglitore di statistiche fallito: %m" -#: postmaster/pgstat.c:514 +#: postmaster/pgstat.c:513 #, c-format msgid "incorrect test message transmission on socket for statistics collector" msgstr "trasmissione errata del messaggio di prova per il raccoglitore di statistiche" -#: postmaster/pgstat.c:537 +#: postmaster/pgstat.c:536 #, c-format msgid "could not set statistics collector socket to nonblocking mode: %m" msgstr "impostazione del socket per il raccoglitore di statistiche in modalità non bloccante fallita: %m" -#: postmaster/pgstat.c:547 +#: postmaster/pgstat.c:546 #, c-format msgid "disabling statistics collector for lack of working socket" msgstr "raccoglitore di statistiche disabilitato per mancanza di un socket funzionante" -#: postmaster/pgstat.c:694 +#: postmaster/pgstat.c:693 #, c-format msgid "could not fork statistics collector: %m" msgstr "fork del raccoglitore di statistiche fallito: %m" -#: postmaster/pgstat.c:1262 +#: postmaster/pgstat.c:1261 #, c-format msgid "unrecognized reset target: \"%s\"" msgstr "destinazione di reset sconosciuta: \"%s\"" -#: postmaster/pgstat.c:1263 +#: postmaster/pgstat.c:1262 #, c-format msgid "Target must be \"archiver\" or \"bgwriter\"." msgstr "La destinazione deve essere \"archiver\" o \"bgwriter\"." -#: postmaster/pgstat.c:3578 +#: postmaster/pgstat.c:3587 #, c-format msgid "could not read statistics message: %m" msgstr "lettura del messaggio delle statistiche fallito: %m" -#: postmaster/pgstat.c:3909 postmaster/pgstat.c:4086 +#: postmaster/pgstat.c:3918 postmaster/pgstat.c:4075 #, c-format msgid "could not open temporary statistics file \"%s\": %m" msgstr "apertura del file temporaneo delle statistiche \"%s\" fallita: %m" -#: postmaster/pgstat.c:3977 postmaster/pgstat.c:4131 +#: postmaster/pgstat.c:3985 postmaster/pgstat.c:4120 #, c-format msgid "could not write temporary statistics file \"%s\": %m" msgstr "scrittura del file temporaneo delle statistiche \"%s\" fallita: %m" -#: postmaster/pgstat.c:3986 postmaster/pgstat.c:4140 +#: postmaster/pgstat.c:3994 postmaster/pgstat.c:4129 #, c-format msgid "could not close temporary statistics file \"%s\": %m" msgstr "chiusura del file temporaneo delle statistiche \"%s\" fallita: %m" -#: postmaster/pgstat.c:3994 postmaster/pgstat.c:4148 +#: postmaster/pgstat.c:4002 postmaster/pgstat.c:4137 #, c-format msgid "could not rename temporary statistics file \"%s\" to \"%s\": %m" msgstr "non è stato possibile rinominare il file temporaneo delle statistiche \"%s\" in \"%s\": %m" -#: postmaster/pgstat.c:4230 postmaster/pgstat.c:4413 postmaster/pgstat.c:4568 +#: postmaster/pgstat.c:4226 postmaster/pgstat.c:4411 postmaster/pgstat.c:4564 #, c-format msgid "could not open statistics file \"%s\": %m" msgstr "apertura del file delle statistiche \"%s\" fallita: %m" -#: postmaster/pgstat.c:4242 postmaster/pgstat.c:4252 postmaster/pgstat.c:4262 -#: postmaster/pgstat.c:4283 postmaster/pgstat.c:4298 postmaster/pgstat.c:4354 -#: postmaster/pgstat.c:4425 postmaster/pgstat.c:4445 postmaster/pgstat.c:4463 -#: postmaster/pgstat.c:4479 postmaster/pgstat.c:4497 postmaster/pgstat.c:4513 -#: postmaster/pgstat.c:4580 postmaster/pgstat.c:4592 postmaster/pgstat.c:4604 -#: postmaster/pgstat.c:4629 postmaster/pgstat.c:4651 +#: postmaster/pgstat.c:4238 postmaster/pgstat.c:4248 postmaster/pgstat.c:4258 +#: postmaster/pgstat.c:4279 postmaster/pgstat.c:4294 postmaster/pgstat.c:4348 +#: postmaster/pgstat.c:4423 postmaster/pgstat.c:4443 postmaster/pgstat.c:4461 +#: postmaster/pgstat.c:4477 postmaster/pgstat.c:4495 postmaster/pgstat.c:4511 +#: postmaster/pgstat.c:4576 postmaster/pgstat.c:4588 postmaster/pgstat.c:4600 +#: postmaster/pgstat.c:4625 postmaster/pgstat.c:4647 #, c-format msgid "corrupted statistics file \"%s\"" msgstr "file delle statistiche corrotto \"%s\"" -#: postmaster/pgstat.c:4768 +#: postmaster/pgstat.c:4776 #, c-format msgid "using stale statistics instead of current ones because stats collector is not responding" msgstr "verranno utilizzate statistiche vecchie invece di quelle correnti perché il processo di raccolta statistiche non risponde" -#: postmaster/pgstat.c:5086 +#: postmaster/pgstat.c:5103 #, c-format msgid "database hash table corrupted during cleanup --- abort" msgstr "tabella hash del database corrotta durante la pulizia --- interruzione" -#: postmaster/postmaster.c:676 +#: postmaster/postmaster.c:684 #, c-format msgid "%s: invalid argument for option -f: \"%s\"\n" msgstr "%s: argomento non valido per l'opzione -f: \"%s\"\n" -#: postmaster/postmaster.c:762 +#: postmaster/postmaster.c:770 #, c-format msgid "%s: invalid argument for option -t: \"%s\"\n" msgstr "%s: argomento non valido per l'opzione -t: \"%s\"\n" -#: postmaster/postmaster.c:813 +#: postmaster/postmaster.c:821 #, c-format msgid "%s: invalid argument: \"%s\"\n" msgstr "%s: argomento non valido: \"%s\"\n" -#: postmaster/postmaster.c:848 +#: postmaster/postmaster.c:860 #, c-format msgid "%s: superuser_reserved_connections must be less than max_connections\n" msgstr "%s: superuser_reserved_connections dev'essere minore di max_connections\n" -#: postmaster/postmaster.c:853 +#: postmaster/postmaster.c:865 #, c-format msgid "%s: max_wal_senders must be less than max_connections\n" msgstr "%s: max_wal_senders dev'essere minore di max_connections\n" -#: postmaster/postmaster.c:858 +#: postmaster/postmaster.c:870 #, c-format msgid "WAL archival cannot be enabled when wal_level is \"minimal\"" msgstr "l'archiviazione dei WAL non può essere attivata quando wal_level è \"minimal\"" -#: postmaster/postmaster.c:861 +#: postmaster/postmaster.c:873 #, c-format msgid "WAL streaming (max_wal_senders > 0) requires wal_level \"replica\" or \"logical\"" msgstr "lo streaming WAL (max_wal_senders > 0) richiede wal_level \"replica\" oppure \"logical\"" -#: postmaster/postmaster.c:869 +#: postmaster/postmaster.c:881 #, c-format msgid "%s: invalid datetoken tables, please fix\n" msgstr "%s: datetoken tables non valido, per favore correggilo\n" -#: postmaster/postmaster.c:961 postmaster/postmaster.c:1059 +#: postmaster/postmaster.c:973 postmaster/postmaster.c:1071 #: utils/init/miscinit.c:1429 #, c-format msgid "invalid list syntax in parameter \"%s\"" msgstr "sintassi di lista non valida nel parametro \"%s\"" -#: postmaster/postmaster.c:992 +#: postmaster/postmaster.c:1004 #, c-format msgid "could not create listen socket for \"%s\"" msgstr "creazione del socket di ascolto per \"%s\" fallita" -#: postmaster/postmaster.c:998 +#: postmaster/postmaster.c:1010 #, c-format msgid "could not create any TCP/IP sockets" msgstr "non è stato possibile creare alcun socket TCP/IP" -#: postmaster/postmaster.c:1081 +#: postmaster/postmaster.c:1093 #, c-format msgid "could not create Unix-domain socket in directory \"%s\"" msgstr "creazione del socket di dominio Unix fallita nella directory \"%s\"" -#: postmaster/postmaster.c:1087 +#: postmaster/postmaster.c:1099 #, c-format msgid "could not create any Unix-domain sockets" msgstr "creazione del socket di dominio Unix fallita" -#: postmaster/postmaster.c:1099 +#: postmaster/postmaster.c:1111 #, c-format msgid "no socket created for listening" msgstr "nessun socket per l'ascolto è stato creato" -#: postmaster/postmaster.c:1139 +#: postmaster/postmaster.c:1151 #, c-format msgid "could not create I/O completion port for child queue" msgstr "creazione della porta di completamento I/O per la coda dei figli fallita" -#: postmaster/postmaster.c:1168 +#: postmaster/postmaster.c:1180 #, c-format msgid "%s: could not change permissions of external PID file \"%s\": %s\n" msgstr "%s: modifica dei permessi del file PID esterno \"%s\" fallita: %s\n" -#: postmaster/postmaster.c:1172 +#: postmaster/postmaster.c:1184 #, c-format msgid "%s: could not write external PID file \"%s\": %s\n" msgstr "%s: scrittura del file PID esterno \"%s\" fallita: %s\n" -#: postmaster/postmaster.c:1223 +#: postmaster/postmaster.c:1234 #, c-format msgid "ending log output to stderr" msgstr "terminazione dell'output del log su stderr" -#: postmaster/postmaster.c:1224 +#: postmaster/postmaster.c:1235 #, c-format msgid "Future log output will go to log destination \"%s\"." msgstr "L'output dei prossimi log andrà su \"%s\"." -#: postmaster/postmaster.c:1250 utils/init/postinit.c:214 +#: postmaster/postmaster.c:1261 utils/init/postinit.c:213 #, c-format msgid "could not load pg_hba.conf" msgstr "caricamento di pg_hba.conf fallito" -#: postmaster/postmaster.c:1276 +#: postmaster/postmaster.c:1287 #, c-format msgid "postmaster became multithreaded during startup" msgstr "il postmaster è diventato multithread durante l'avvio" -#: postmaster/postmaster.c:1277 +#: postmaster/postmaster.c:1288 #, c-format msgid "Set the LC_ALL environment variable to a valid locale." msgstr "Imposta la variabile d'ambiente LC_ALL non corrisponde ad un locale valido." -#: postmaster/postmaster.c:1374 +#: postmaster/postmaster.c:1385 #, c-format msgid "%s: could not locate matching postgres executable" msgstr "%s: eseguibile postgres corrispondente non trovato" -#: postmaster/postmaster.c:1397 utils/misc/tzparser.c:341 +#: postmaster/postmaster.c:1408 utils/misc/tzparser.c:341 #, c-format msgid "This may indicate an incomplete PostgreSQL installation, or that the file \"%s\" has been moved away from its proper location." msgstr "Questo potrebbe indicare una installazione di PostgreSQL incompleta, o che il file \"%s\" sia stato spostato dalla sua posizione corretta." -#: postmaster/postmaster.c:1425 +#: postmaster/postmaster.c:1436 #, c-format msgid "data directory \"%s\" does not exist" msgstr "la directory dei dati \"%s\" non esiste" -#: postmaster/postmaster.c:1430 +#: postmaster/postmaster.c:1441 #, c-format msgid "could not read permissions of directory \"%s\": %m" msgstr "lettura dei permessi della directory \"%s\" fallita: %m" -#: postmaster/postmaster.c:1438 +#: postmaster/postmaster.c:1449 #, c-format msgid "specified data directory \"%s\" is not a directory" msgstr "la directory dei dati specificata \"%s\" non è una directory" -#: postmaster/postmaster.c:1454 +#: postmaster/postmaster.c:1465 #, c-format msgid "data directory \"%s\" has wrong ownership" msgstr "la directory dei dati \"%s\" ha il proprietario errato" -#: postmaster/postmaster.c:1456 +#: postmaster/postmaster.c:1467 #, c-format msgid "The server must be started by the user that owns the data directory." msgstr "Il server deve essere avviato dall'utente che possiede la directory dei dati." -#: postmaster/postmaster.c:1476 +#: postmaster/postmaster.c:1487 #, c-format msgid "data directory \"%s\" has group or world access" msgstr "la directory dei dati \"%s\" è accessibile dal gruppo o da tutti" -#: postmaster/postmaster.c:1478 +#: postmaster/postmaster.c:1489 #, c-format msgid "Permissions should be u=rwx (0700)." msgstr "I permessi dovrebbero essere u=rwx (0700)." -#: postmaster/postmaster.c:1489 +#: postmaster/postmaster.c:1500 #, c-format msgid "" "%s: could not find the database system\n" @@ -14389,365 +14407,365 @@ msgstr "" "Sarebbe dovuto essere nella directory \"%s\",\n" "ma l'apertura del file \"%s\" è fallita: %s\n" -#: postmaster/postmaster.c:1666 +#: postmaster/postmaster.c:1677 #, c-format msgid "select() failed in postmaster: %m" msgstr "select() fallita in postmaster: %m" -#: postmaster/postmaster.c:1816 +#: postmaster/postmaster.c:1828 #, c-format msgid "performing immediate shutdown because data directory lock file is invalid" msgstr "arresto immediato perché il file di lock della directory dati non è valido" -#: postmaster/postmaster.c:1894 postmaster/postmaster.c:1925 +#: postmaster/postmaster.c:1906 postmaster/postmaster.c:1937 #, c-format msgid "incomplete startup packet" msgstr "pacchetto di avvio incompleto" -#: postmaster/postmaster.c:1906 +#: postmaster/postmaster.c:1918 #, c-format msgid "invalid length of startup packet" msgstr "dimensione del pacchetto di avvio non valida" -#: postmaster/postmaster.c:1964 +#: postmaster/postmaster.c:1976 #, c-format msgid "failed to send SSL negotiation response: %m" msgstr "invio della risposta di negoziazione SSL fallito: %m" -#: postmaster/postmaster.c:1993 +#: postmaster/postmaster.c:2005 #, c-format msgid "unsupported frontend protocol %u.%u: server supports %u.0 to %u.%u" msgstr "protocollo frontend non supportato %u.%u: il server supporta da %u.0 a %u.%u" -#: postmaster/postmaster.c:2056 utils/misc/guc.c:5657 utils/misc/guc.c:5750 -#: utils/misc/guc.c:7047 utils/misc/guc.c:9783 utils/misc/guc.c:9817 +#: postmaster/postmaster.c:2068 utils/misc/guc.c:5660 utils/misc/guc.c:5753 +#: utils/misc/guc.c:7051 utils/misc/guc.c:9805 utils/misc/guc.c:9839 #, c-format msgid "invalid value for parameter \"%s\": \"%s\"" msgstr "valore non valido per il parametro \"%s\": \"%s\"" -#: postmaster/postmaster.c:2059 +#: postmaster/postmaster.c:2071 #, c-format msgid "Valid values are: \"false\", 0, \"true\", 1, \"database\"." msgstr "I valori validi sono: \"false\", 0, \"true\", 1, \"database\"." -#: postmaster/postmaster.c:2079 +#: postmaster/postmaster.c:2091 #, c-format msgid "invalid startup packet layout: expected terminator as last byte" msgstr "formato del pacchetto di avvio non valido: atteso il terminatore all'ultimo byte" -#: postmaster/postmaster.c:2107 +#: postmaster/postmaster.c:2119 #, c-format msgid "no PostgreSQL user name specified in startup packet" msgstr "nessun utente PostgreSQL specificato nel pacchetto di avvio" -#: postmaster/postmaster.c:2166 +#: postmaster/postmaster.c:2178 #, c-format msgid "the database system is starting up" msgstr "il database si sta avviando" -#: postmaster/postmaster.c:2171 +#: postmaster/postmaster.c:2183 #, c-format msgid "the database system is shutting down" msgstr "il database si sta spegnendo" -#: postmaster/postmaster.c:2176 +#: postmaster/postmaster.c:2188 #, c-format msgid "the database system is in recovery mode" msgstr "il database è in modalità di ripristino" -#: postmaster/postmaster.c:2181 storage/ipc/procarray.c:297 +#: postmaster/postmaster.c:2193 storage/ipc/procarray.c:297 #: storage/ipc/sinvaladt.c:298 storage/lmgr/proc.c:340 #, c-format msgid "sorry, too many clients already" msgstr "spiacente, troppi client già connessi" -#: postmaster/postmaster.c:2243 +#: postmaster/postmaster.c:2255 #, c-format msgid "wrong key in cancel request for process %d" msgstr "chiave sbagliata nella richiesta di annullamento per il processo %d" -#: postmaster/postmaster.c:2251 +#: postmaster/postmaster.c:2263 #, c-format msgid "PID %d in cancel request did not match any process" msgstr "il PID %d nella richiesta di annullamento non corrisponde ad alcun processo" -#: postmaster/postmaster.c:2471 +#: postmaster/postmaster.c:2483 #, c-format msgid "received SIGHUP, reloading configuration files" msgstr "SIGHUP ricevuto, sto ricaricando i file di configurazione" -#: postmaster/postmaster.c:2496 +#: postmaster/postmaster.c:2508 #, c-format msgid "pg_hba.conf not reloaded" msgstr "pg_hba.conf non è stato ricaricato" -#: postmaster/postmaster.c:2500 +#: postmaster/postmaster.c:2512 #, c-format msgid "pg_ident.conf not reloaded" msgstr "pg_ident.conf non è stato ricaricato" -#: postmaster/postmaster.c:2541 +#: postmaster/postmaster.c:2553 #, c-format msgid "received smart shutdown request" msgstr "richiesta di arresto smart ricevuta" -#: postmaster/postmaster.c:2596 +#: postmaster/postmaster.c:2608 #, c-format msgid "received fast shutdown request" msgstr "richiesta di arresto fast ricevuta" -#: postmaster/postmaster.c:2625 +#: postmaster/postmaster.c:2638 #, c-format msgid "aborting any active transactions" msgstr "interruzione di tutte le transazioni attive" -#: postmaster/postmaster.c:2659 +#: postmaster/postmaster.c:2672 #, c-format msgid "received immediate shutdown request" msgstr "richiesta di arresto immediate ricevuta" -#: postmaster/postmaster.c:2723 +#: postmaster/postmaster.c:2736 #, c-format msgid "shutdown at recovery target" msgstr "arresto alla destinazione di recupero" -#: postmaster/postmaster.c:2739 postmaster/postmaster.c:2762 +#: postmaster/postmaster.c:2752 postmaster/postmaster.c:2775 msgid "startup process" msgstr "avvio del processo" -#: postmaster/postmaster.c:2742 +#: postmaster/postmaster.c:2755 #, c-format msgid "aborting startup due to startup process failure" msgstr "avvio interrotto a causa del fallimento del processo di avvio" -#: postmaster/postmaster.c:2803 +#: postmaster/postmaster.c:2816 #, c-format msgid "database system is ready to accept connections" msgstr "il database è pronto ad accettare connessioni" -#: postmaster/postmaster.c:2822 +#: postmaster/postmaster.c:2835 msgid "background writer process" msgstr "processo di scrittura in background" -#: postmaster/postmaster.c:2876 +#: postmaster/postmaster.c:2889 msgid "checkpointer process" msgstr "processo di creazione checkpoint" -#: postmaster/postmaster.c:2892 +#: postmaster/postmaster.c:2905 msgid "WAL writer process" msgstr "processo di scrittura WAL" -#: postmaster/postmaster.c:2906 +#: postmaster/postmaster.c:2919 msgid "WAL receiver process" msgstr "processo di ricezione WAL" -#: postmaster/postmaster.c:2921 +#: postmaster/postmaster.c:2934 msgid "autovacuum launcher process" msgstr "processo del lanciatore di autovacuum" -#: postmaster/postmaster.c:2936 +#: postmaster/postmaster.c:2949 msgid "archiver process" msgstr "processo di archiviazione" -#: postmaster/postmaster.c:2952 +#: postmaster/postmaster.c:2965 msgid "statistics collector process" msgstr "processo del raccoglitore di statistiche" -#: postmaster/postmaster.c:2966 +#: postmaster/postmaster.c:2979 msgid "system logger process" msgstr "processo del logger di sistema" -#: postmaster/postmaster.c:3028 +#: postmaster/postmaster.c:3041 msgid "worker process" msgstr "processo di lavoro" -#: postmaster/postmaster.c:3111 postmaster/postmaster.c:3131 -#: postmaster/postmaster.c:3138 postmaster/postmaster.c:3156 +#: postmaster/postmaster.c:3124 postmaster/postmaster.c:3144 +#: postmaster/postmaster.c:3151 postmaster/postmaster.c:3169 msgid "server process" msgstr "processo del server" -#: postmaster/postmaster.c:3210 +#: postmaster/postmaster.c:3223 #, c-format msgid "terminating any other active server processes" msgstr "interruzione di tutti gli altri processi attivi del server" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3466 +#: postmaster/postmaster.c:3479 #, c-format msgid "%s (PID %d) exited with exit code %d" msgstr "%s (PID %d) è uscito con codice di uscita %d" -#: postmaster/postmaster.c:3468 postmaster/postmaster.c:3479 -#: postmaster/postmaster.c:3490 postmaster/postmaster.c:3499 -#: postmaster/postmaster.c:3509 +#: postmaster/postmaster.c:3481 postmaster/postmaster.c:3492 +#: postmaster/postmaster.c:3503 postmaster/postmaster.c:3512 +#: postmaster/postmaster.c:3522 #, c-format msgid "Failed process was running: %s" msgstr "Il processo fallito stava eseguendo: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3476 +#: postmaster/postmaster.c:3489 #, c-format msgid "%s (PID %d) was terminated by exception 0x%X" msgstr "%s (PID %d) è stato terminato dall'eccezione 0x%X" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3486 +#: postmaster/postmaster.c:3499 #, c-format msgid "%s (PID %d) was terminated by signal %d: %s" msgstr "%s (PID %d) è stato terminato dal segnale %d: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3497 +#: postmaster/postmaster.c:3510 #, c-format msgid "%s (PID %d) was terminated by signal %d" msgstr "%s (PID %d) è stato terminato dal segnale %d" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3507 +#: postmaster/postmaster.c:3520 #, c-format msgid "%s (PID %d) exited with unrecognized status %d" msgstr "%s (PID %d) uscito con stato sconosciuto %d" -#: postmaster/postmaster.c:3694 +#: postmaster/postmaster.c:3707 #, c-format msgid "abnormal database system shutdown" msgstr "spegnimento anormale del database" -#: postmaster/postmaster.c:3734 +#: postmaster/postmaster.c:3747 #, c-format msgid "all server processes terminated; reinitializing" msgstr "tutti i processi server sono terminati; re-inizializzazione" -#: postmaster/postmaster.c:3946 +#: postmaster/postmaster.c:3959 #, c-format msgid "could not fork new process for connection: %m" msgstr "fork del nuovo processo per la connessione fallito: %m" -#: postmaster/postmaster.c:3988 +#: postmaster/postmaster.c:4001 msgid "could not fork new process for connection: " msgstr "fork del nuovo processo per la connessione fallito: " -#: postmaster/postmaster.c:4102 +#: postmaster/postmaster.c:4115 #, c-format msgid "connection received: host=%s port=%s" msgstr "connessione ricevuta: host=%s porta=%s" -#: postmaster/postmaster.c:4107 +#: postmaster/postmaster.c:4120 #, c-format msgid "connection received: host=%s" msgstr "connessione ricevuta: host=%s" -#: postmaster/postmaster.c:4390 +#: postmaster/postmaster.c:4403 #, c-format msgid "could not execute server process \"%s\": %m" msgstr "esecuzione del processo del server \"%s\" fallita: %m" -#: postmaster/postmaster.c:4955 +#: postmaster/postmaster.c:4947 #, c-format msgid "database system is ready to accept read only connections" msgstr "il database è pronto ad accettare connessioni in sola lettura" -#: postmaster/postmaster.c:5242 +#: postmaster/postmaster.c:5238 #, c-format msgid "could not fork startup process: %m" msgstr "fork del processo di avvio fallito: %m" -#: postmaster/postmaster.c:5246 +#: postmaster/postmaster.c:5242 #, c-format msgid "could not fork background writer process: %m" msgstr "fork del processo di scrittura in background fallito: %m" -#: postmaster/postmaster.c:5250 +#: postmaster/postmaster.c:5246 #, c-format msgid "could not fork checkpointer process: %m" msgstr "fork del processo di creazione dei checkpoint fallito: %m" -#: postmaster/postmaster.c:5254 +#: postmaster/postmaster.c:5250 #, c-format msgid "could not fork WAL writer process: %m" msgstr "fork del processo di scrittura dei WAL fallito: %m" -#: postmaster/postmaster.c:5258 +#: postmaster/postmaster.c:5254 #, c-format msgid "could not fork WAL receiver process: %m" msgstr "fork del processo di ricezione dei WAL fallito: %m" -#: postmaster/postmaster.c:5262 +#: postmaster/postmaster.c:5258 #, c-format msgid "could not fork process: %m" msgstr "fork del processo fallito: %m" -#: postmaster/postmaster.c:5424 postmaster/postmaster.c:5447 +#: postmaster/postmaster.c:5420 postmaster/postmaster.c:5443 #, c-format msgid "database connection requirement not indicated during registration" msgstr "requisiti di connessione a database non indicati durante la registrazione" -#: postmaster/postmaster.c:5431 postmaster/postmaster.c:5454 +#: postmaster/postmaster.c:5427 postmaster/postmaster.c:5450 #, c-format msgid "invalid processing mode in background worker" msgstr "modalità di processo non valida nel processo di lavoro in background" -#: postmaster/postmaster.c:5506 +#: postmaster/postmaster.c:5502 #, c-format msgid "starting background worker process \"%s\"" msgstr "avvio del processo di lavoro in background \"%s\"" -#: postmaster/postmaster.c:5517 +#: postmaster/postmaster.c:5513 #, c-format msgid "could not fork worker process: %m" msgstr "fork del processo di lavoro in background fallito: %m" -#: postmaster/postmaster.c:5895 +#: postmaster/postmaster.c:5901 #, c-format msgid "could not duplicate socket %d for use in backend: error code %d" msgstr "duplicazione del socket %d da usare nel backend fallita: codice errore %d" -#: postmaster/postmaster.c:5927 +#: postmaster/postmaster.c:5933 #, c-format msgid "could not create inherited socket: error code %d\n" msgstr "creazione del socket ereditato fallita: codice errore %d\n" -#: postmaster/postmaster.c:5956 +#: postmaster/postmaster.c:5962 #, c-format msgid "could not open backend variables file \"%s\": %s\n" msgstr "apertura del file delle variabili del backend \"%s\" fallita: %s\n" -#: postmaster/postmaster.c:5963 +#: postmaster/postmaster.c:5969 #, c-format msgid "could not read from backend variables file \"%s\": %s\n" msgstr "lettura dal file delle variabili del backend \"%s\" fallita: %s\n" -#: postmaster/postmaster.c:5972 +#: postmaster/postmaster.c:5978 #, c-format msgid "could not remove file \"%s\": %s\n" msgstr "rimozione del file \"%s\" fallita: %s\n" -#: postmaster/postmaster.c:5989 +#: postmaster/postmaster.c:5995 #, c-format msgid "could not map view of backend variables: error code %lu\n" msgstr "non è stato possibile mappare la vista delle variabili del backend: codice errore %lu\n" -#: postmaster/postmaster.c:5998 +#: postmaster/postmaster.c:6004 #, c-format msgid "could not unmap view of backend variables: error code %lu\n" msgstr "non è stato possibile rimuovere la mappa della vista delle variabili del backend: codice errore %lu\n" -#: postmaster/postmaster.c:6005 +#: postmaster/postmaster.c:6011 #, c-format msgid "could not close handle to backend parameter variables: error code %lu\n" msgstr "chiusura dell'handle dei parametri variabili del backend fallita: codice errore %lu\n" -#: postmaster/postmaster.c:6166 +#: postmaster/postmaster.c:6172 #, c-format msgid "could not read exit code for process\n" msgstr "lettura del codice di uscita del processo fallita\n" -#: postmaster/postmaster.c:6171 +#: postmaster/postmaster.c:6177 #, c-format msgid "could not post child completion status\n" msgstr "invio dello stato di completamento del figlio fallito\n" @@ -14812,150 +14830,154 @@ msgstr "rotazione automatica disabilitata (usa SIGHUP per abilitarla di nuovo)" msgid "could not determine which collation to use for regular expression" msgstr "non è stato possibile determinare quale ordinamento usare per le espressioni regolari" -#: replication/basebackup.c:230 +#: replication/basebackup.c:232 #, c-format msgid "could not stat control file \"%s\": %m" msgstr "non è stato possibile ottenere informazioni sul file di controllo \"%s\": %m" -#: replication/basebackup.c:339 +#: replication/basebackup.c:341 #, c-format msgid "could not find any WAL files" msgstr "nessun file WAL trovato" -#: replication/basebackup.c:352 replication/basebackup.c:366 -#: replication/basebackup.c:375 +#: replication/basebackup.c:354 replication/basebackup.c:368 +#: replication/basebackup.c:377 #, c-format msgid "could not find WAL file \"%s\"" msgstr "file WAL \"%s\" non trovato" -#: replication/basebackup.c:414 replication/basebackup.c:440 +#: replication/basebackup.c:416 replication/basebackup.c:442 #, c-format msgid "unexpected WAL file size \"%s\"" msgstr "dimensione inaspettata del file WAL \"%s\"" -#: replication/basebackup.c:426 replication/basebackup.c:1172 +#: replication/basebackup.c:428 replication/basebackup.c:1160 #, c-format msgid "base backup could not send data, aborting backup" msgstr "invio dati da parte del backup di base fallito, backup interrotto" -#: replication/basebackup.c:528 replication/basebackup.c:537 -#: replication/basebackup.c:546 replication/basebackup.c:555 -#: replication/basebackup.c:564 replication/basebackup.c:575 -#: replication/basebackup.c:592 +#: replication/basebackup.c:530 replication/basebackup.c:539 +#: replication/basebackup.c:548 replication/basebackup.c:557 +#: replication/basebackup.c:566 replication/basebackup.c:577 +#: replication/basebackup.c:594 #, c-format msgid "duplicate option \"%s\"" msgstr "opzione duplicata \"%s\"" -#: replication/basebackup.c:581 utils/misc/guc.c:5667 +#: replication/basebackup.c:583 utils/misc/guc.c:5670 #, c-format msgid "%d is outside the valid range for parameter \"%s\" (%d .. %d)" msgstr "%d non è compreso nell'intervallo di validità del il parametro \"%s\" (%d .. %d)" -#: replication/basebackup.c:855 replication/basebackup.c:957 +#: replication/basebackup.c:857 replication/basebackup.c:959 #, c-format msgid "could not stat file or directory \"%s\": %m" msgstr "non è stato possibile ottenere informazioni sul file o directory \"%s\": %m" -#: replication/basebackup.c:1124 +#: replication/basebackup.c:1112 #, c-format msgid "skipping special file \"%s\"" msgstr "file speciale \"%s\" saltato" -#: replication/basebackup.c:1235 +#: replication/basebackup.c:1223 #, c-format msgid "file name too long for tar format: \"%s\"" msgstr "nome del file troppo lungo per il formato tar: \"%s\"" -#: replication/basebackup.c:1240 +#: replication/basebackup.c:1228 #, c-format msgid "symbolic link target too long for tar format: file name \"%s\", target \"%s\"" msgstr "destinazione del link simbolico troppo lunga per il formato tar: nome del file \"%s\", destinazione \"%s\"" -#: replication/libpqwalreceiver/libpqwalreceiver.c:116 +#: replication/libpqwalreceiver/libpqwalreceiver.c:119 #, c-format msgid "could not connect to the primary server: %s" msgstr "connessione al server primario fallita: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:140 +#: replication/libpqwalreceiver/libpqwalreceiver.c:142 +#, c-format +msgid "could not parse connection string: %s" +msgstr "interpretazione della stringa di connessione fallita: %s" + +#: replication/libpqwalreceiver/libpqwalreceiver.c:192 #, c-format msgid "could not receive database system identifier and timeline ID from the primary server: %s" msgstr "ricezione fallita dell'identificativo del database e l'ID della timeline dal server primario: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:151 -#: replication/libpqwalreceiver/libpqwalreceiver.c:305 +#: replication/libpqwalreceiver/libpqwalreceiver.c:203 +#: replication/libpqwalreceiver/libpqwalreceiver.c:357 #, c-format msgid "invalid response from primary server" msgstr "risposta non valida dal server primario" -#: replication/libpqwalreceiver/libpqwalreceiver.c:152 +#: replication/libpqwalreceiver/libpqwalreceiver.c:204 #, c-format msgid "Could not identify system: got %d rows and %d fields, expected %d rows and %d or more fields." msgstr "Identificazione del sistema non riuscita: ricevute %d righe and %d campi, attese %d righe e %d o più campi." -#: replication/libpqwalreceiver/libpqwalreceiver.c:168 +#: replication/libpqwalreceiver/libpqwalreceiver.c:220 #, c-format msgid "database system identifier differs between the primary and standby" msgstr "l'identificativo del database è diverso tra il primario e lo standby" -#: replication/libpqwalreceiver/libpqwalreceiver.c:169 +#: replication/libpqwalreceiver/libpqwalreceiver.c:221 #, c-format msgid "The primary's identifier is %s, the standby's identifier is %s." msgstr "L'identificativo del primario è %s, quello dello standby è %s." -#: replication/libpqwalreceiver/libpqwalreceiver.c:211 +#: replication/libpqwalreceiver/libpqwalreceiver.c:263 #, c-format msgid "could not start WAL streaming: %s" msgstr "avvio dello streaming dei WAL fallito: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:229 +#: replication/libpqwalreceiver/libpqwalreceiver.c:281 #, c-format msgid "could not send end-of-streaming message to primary: %s" msgstr "invio del messaggio di fine stream al primario fallito: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:251 +#: replication/libpqwalreceiver/libpqwalreceiver.c:303 #, c-format msgid "unexpected result set after end-of-streaming" msgstr "risultato imprevisto dopo la fine stream" -#: replication/libpqwalreceiver/libpqwalreceiver.c:263 +#: replication/libpqwalreceiver/libpqwalreceiver.c:315 #, c-format msgid "error reading result of streaming command: %s" msgstr "errore nella lettura del risultato del comando di streaming: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:271 +#: replication/libpqwalreceiver/libpqwalreceiver.c:323 #, c-format msgid "unexpected result after CommandComplete: %s" msgstr "risultato imprevisto dopo CommandComplete: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:294 +#: replication/libpqwalreceiver/libpqwalreceiver.c:346 #, c-format msgid "could not receive timeline history file from the primary server: %s" msgstr "errore nella ricezione del file di storia della timeline dal server primario: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:306 +#: replication/libpqwalreceiver/libpqwalreceiver.c:358 #, c-format msgid "Expected 1 tuple with 2 fields, got %d tuples with %d fields." msgstr "Attesa una tupla con 2 campi, ricevute %d tuple con %d campi." -#: replication/libpqwalreceiver/libpqwalreceiver.c:334 +#: replication/libpqwalreceiver/libpqwalreceiver.c:386 #, c-format msgid "invalid socket: %s" msgstr "socket non valido: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:374 -#: storage/ipc/latch.c:1271 +#: replication/libpqwalreceiver/libpqwalreceiver.c:426 storage/ipc/latch.c:1280 #, c-format msgid "select() failed: %m" msgstr "select() fallita: %m" -#: replication/libpqwalreceiver/libpqwalreceiver.c:497 -#: replication/libpqwalreceiver/libpqwalreceiver.c:524 -#: replication/libpqwalreceiver/libpqwalreceiver.c:530 +#: replication/libpqwalreceiver/libpqwalreceiver.c:549 +#: replication/libpqwalreceiver/libpqwalreceiver.c:576 +#: replication/libpqwalreceiver/libpqwalreceiver.c:582 #, c-format msgid "could not receive data from WAL stream: %s" msgstr "ricezione dati dallo stream WAL fallita: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:549 +#: replication/libpqwalreceiver/libpqwalreceiver.c:601 #, c-format msgid "could not send data to WAL stream: %s" msgstr "invio dati allo stream WAL fallito: %s" @@ -14975,37 +14997,37 @@ msgstr "la decodifica logica richiede una connessione al database" msgid "logical decoding cannot be used while in recovery" msgstr "la decodifica logica non può essere usata in modalità di recupero" -#: replication/logical/logical.c:238 replication/logical/logical.c:342 +#: replication/logical/logical.c:236 replication/logical/logical.c:348 #, c-format msgid "cannot use physical replication slot for logical decoding" msgstr "non si possono usare slot di replica fisica per la decodifica logica" -#: replication/logical/logical.c:243 replication/logical/logical.c:347 +#: replication/logical/logical.c:241 replication/logical/logical.c:353 #, c-format msgid "replication slot \"%s\" was not created in this database" msgstr "lo slot di replica \"%s\" non è stato creato in questo database" -#: replication/logical/logical.c:250 +#: replication/logical/logical.c:248 #, c-format msgid "cannot create logical replication slot in transaction that has performed writes" msgstr "non si possono creare slot di replica logica in transazioni che hanno effettuato scritture" -#: replication/logical/logical.c:384 +#: replication/logical/logical.c:390 #, c-format msgid "starting logical decoding for slot \"%s\"" msgstr "avvio della decodifica logica per lo slot \"%s\"" -#: replication/logical/logical.c:386 +#: replication/logical/logical.c:392 #, c-format msgid "streaming transactions committing after %X/%X, reading WAL from %X/%X" msgstr "commit dello streaming delle transazioni dopo %X/%X, lettura del wal a partire da %X/%X" -#: replication/logical/logical.c:521 +#: replication/logical/logical.c:527 #, c-format msgid "slot \"%s\", output plugin \"%s\", in the %s callback, associated LSN %X/%X" msgstr "slot \"%s\", plugin di output \"%s\", nel callback %s, LSN associato %X/%X" -#: replication/logical/logical.c:528 +#: replication/logical/logical.c:534 #, c-format msgid "slot \"%s\", output plugin \"%s\", in the %s callback" msgstr "slot \"%s\", plugin di output \"%s\", nel callback %s" @@ -15041,7 +15063,7 @@ msgstr "l'array non deve contenere NULL" msgid "array must have even number of elements" msgstr "l'array deve avere un numero pari di elementi" -#: replication/logical/logicalfuncs.c:261 +#: replication/logical/logicalfuncs.c:264 #, c-format msgid "logical decoding output plugin \"%s\" produces binary output, but function \"%s\" expects textual data" msgstr "il plugin di output di decodifica logica \"%s\" produce dati binari, ma la funzione \"%s\" si aspetta dati testuali" @@ -15102,7 +15124,7 @@ msgid "could not find free replication state slot for replication origin with OI msgstr "nessuno slot di stato di replica trovato per l'origine di replica con OID %u" #: replication/logical/origin.c:867 replication/logical/origin.c:1047 -#: replication/slot.c:1288 +#: replication/slot.c:1299 #, c-format msgid "Increase max_replication_slots and try again." msgstr "Incrementa max_replication_slots e prova di nuovo." @@ -15123,90 +15145,90 @@ msgstr "l'identificativo di replica %d è già attivo per il PID %d" msgid "no replication origin is configured" msgstr "nessuna origine di replica configurata" -#: replication/logical/reorderbuffer.c:2309 +#: replication/logical/reorderbuffer.c:2330 #, c-format msgid "could not write to data file for XID %u: %m" msgstr "scrittura nel file di dati per lo XID %u non riuscita: %m" -#: replication/logical/reorderbuffer.c:2405 -#: replication/logical/reorderbuffer.c:2425 +#: replication/logical/reorderbuffer.c:2426 +#: replication/logical/reorderbuffer.c:2446 #, c-format msgid "could not read from reorderbuffer spill file: %m" msgstr "lettura dal file spill reorderbuffer non riuscita: %m" -#: replication/logical/reorderbuffer.c:2409 -#: replication/logical/reorderbuffer.c:2429 +#: replication/logical/reorderbuffer.c:2430 +#: replication/logical/reorderbuffer.c:2450 #, c-format msgid "could not read from reorderbuffer spill file: read %d instead of %u bytes" msgstr "lettura dal file spill reorderbuffer non riuscita: letti %d byte invece di %u" -#: replication/logical/reorderbuffer.c:3084 +#: replication/logical/reorderbuffer.c:3106 #, c-format msgid "could not read from file \"%s\": read %d instead of %d bytes" msgstr "lettura dal file \"%s\" non riuscita: letti %d byte invece di %d" -#: replication/logical/snapbuild.c:600 +#: replication/logical/snapbuild.c:598 #, c-format msgid "exported logical decoding snapshot: \"%s\" with %u transaction ID" msgid_plural "exported logical decoding snapshot: \"%s\" with %u transaction IDs" msgstr[0] "snapshot di decidifica logica esportati: \"%s\" con %u ID di transazione" msgstr[1] "snapshot di decidifica logica esportati: \"%s\" con %u ID di transazione" -#: replication/logical/snapbuild.c:919 replication/logical/snapbuild.c:1284 -#: replication/logical/snapbuild.c:1815 +#: replication/logical/snapbuild.c:917 replication/logical/snapbuild.c:1282 +#: replication/logical/snapbuild.c:1813 #, c-format msgid "logical decoding found consistent point at %X/%X" msgstr "la decodifica logica ha trovato un punto consistente a %X/%X" -#: replication/logical/snapbuild.c:921 +#: replication/logical/snapbuild.c:919 #, c-format msgid "Transaction ID %u finished; no more running transactions." msgstr "ID di transazione %u terminato; non ci sono altre transazioni." -#: replication/logical/snapbuild.c:1286 +#: replication/logical/snapbuild.c:1284 #, c-format msgid "There are no running transactions." msgstr "Non ci sono transazioni in corso." -#: replication/logical/snapbuild.c:1348 +#: replication/logical/snapbuild.c:1346 #, c-format msgid "logical decoding found initial starting point at %X/%X" msgstr "la decodifica logica ha trovato un punto di avvio iniziale a %X/%X" -#: replication/logical/snapbuild.c:1350 +#: replication/logical/snapbuild.c:1348 #, c-format msgid "%u transaction needs to finish." msgid_plural "%u transactions need to finish." msgstr[0] "%u transazione deve terminare." msgstr[1] "%u transazioni devono terminare." -#: replication/logical/snapbuild.c:1689 replication/logical/snapbuild.c:1715 -#: replication/logical/snapbuild.c:1729 replication/logical/snapbuild.c:1743 +#: replication/logical/snapbuild.c:1687 replication/logical/snapbuild.c:1713 +#: replication/logical/snapbuild.c:1727 replication/logical/snapbuild.c:1741 #, c-format msgid "could not read file \"%s\", read %d of %d: %m" msgstr "lettura del file \"%s\" non riuscita, letti %d su %d: %m" -#: replication/logical/snapbuild.c:1695 +#: replication/logical/snapbuild.c:1693 #, c-format msgid "snapbuild state file \"%s\" has wrong magic number: %u instead of %u" msgstr "il file di stato snapbuild \"%s\" ha il numero magico sbagliato: %u invece di %u" -#: replication/logical/snapbuild.c:1700 +#: replication/logical/snapbuild.c:1698 #, c-format msgid "snapbuild state file \"%s\" has unsupported version: %u instead of %u" msgstr "il file di stato snapbuild \"%s\" ha una versione non supportata: %u invece di %u" -#: replication/logical/snapbuild.c:1756 +#: replication/logical/snapbuild.c:1754 #, c-format msgid "checksum mismatch for snapbuild state file \"%s\": is %u, should be %u" msgstr "il checksum del file di stato snapbuild \"%s\" non combacia: è %u, sarebbe dovuto essere %u" -#: replication/logical/snapbuild.c:1817 +#: replication/logical/snapbuild.c:1815 #, c-format msgid "Logical decoding will begin using saved snapshot." msgstr "La decodifica logica inizierà usando uno snapshot salvato." -#: replication/logical/snapbuild.c:1890 +#: replication/logical/snapbuild.c:1888 #, c-format msgid "could not parse file name \"%s\"" msgstr "interpretazione del nome di file \"%s\" fallita" @@ -15246,157 +15268,152 @@ msgstr "tutti gli slot di replica sono in uso" msgid "Free one or increase max_replication_slots." msgstr "Liberane uno o incrementa max_replication_slots." -#: replication/slot.c:351 +#: replication/slot.c:361 #, c-format msgid "replication slot \"%s\" does not exist" msgstr "lo slot di replica \"%s\" non esiste" -#: replication/slot.c:355 +#: replication/slot.c:365 #, c-format msgid "replication slot \"%s\" is active for PID %d" msgstr "lo slot di replica \"%s\" è attivo per il PID %d" -#: replication/slot.c:501 replication/slot.c:912 replication/slot.c:1249 +#: replication/slot.c:511 replication/slot.c:923 replication/slot.c:1260 #, c-format msgid "could not remove directory \"%s\"" msgstr "eliminazione della directory \"%s\" fallita" -#: replication/slot.c:761 +#: replication/slot.c:772 #, c-format msgid "replication slots can only be used if max_replication_slots > 0" msgstr "gli slot di replica possono essere usati solo se max_replication_slots > 0" -#: replication/slot.c:766 +#: replication/slot.c:777 #, c-format msgid "replication slots can only be used if wal_level >= replica" msgstr "gli slot di replica possono essere usati solo se wal_level >= replica" -#: replication/slot.c:1181 replication/slot.c:1219 +#: replication/slot.c:1192 replication/slot.c:1230 #, c-format msgid "could not read file \"%s\", read %d of %u: %m" msgstr "lettura del file \"%s\" fallita, letti %d su %u: %m" -#: replication/slot.c:1190 +#: replication/slot.c:1201 #, c-format msgid "replication slot file \"%s\" has wrong magic number: %u instead of %u" msgstr "il file dello slot di replica \"%s\" ha il numero magico sbagliato: %u invece di %u" -#: replication/slot.c:1197 +#: replication/slot.c:1208 #, c-format msgid "replication slot file \"%s\" has unsupported version %u" msgstr "il file dello slot di replica \"%s\" ha la versione non supportata %u" -#: replication/slot.c:1204 +#: replication/slot.c:1215 #, c-format msgid "replication slot file \"%s\" has corrupted length %u" msgstr "il file dello slot di replica \"%s\" ha la lunghezza corrotta %u" -#: replication/slot.c:1234 +#: replication/slot.c:1245 #, c-format msgid "checksum mismatch for replication slot file \"%s\": is %u, should be %u" msgstr "il checksum del file dello slot di replica \"%s\" non combacia: è %u, sarebbe dovuto essere %u" -#: replication/slot.c:1287 +#: replication/slot.c:1298 #, c-format msgid "too many replication slots active before shutdown" msgstr "troppi slot di replica attivi prima dell'arresto" -#: replication/syncrep.c:228 +#: replication/syncrep.c:221 #, c-format msgid "canceling the wait for synchronous replication and terminating connection due to administrator command" msgstr "annullamento dell'attesa di replica sincrona ed interruzione della connessione su comando dell'amministratore" -#: replication/syncrep.c:229 replication/syncrep.c:246 +#: replication/syncrep.c:222 replication/syncrep.c:239 #, c-format msgid "The transaction has already committed locally, but might not have been replicated to the standby." msgstr "La transazione ha già effettuato il commit localmente, ma potrebbe non essere stata replicata agli standby." -#: replication/syncrep.c:245 +#: replication/syncrep.c:238 #, c-format msgid "canceling wait for synchronous replication due to user request" msgstr "annullamento dell'attesa di replica sincrona su richiesta utente" -#: replication/syncrep.c:380 +#: replication/syncrep.c:368 #, c-format msgid "standby \"%s\" now has synchronous standby priority %u" msgstr "lo standby \"%s\" ha ora priorità di standby sincrono %u" -#: replication/syncrep.c:440 +#: replication/syncrep.c:428 #, c-format msgid "standby \"%s\" is now a synchronous standby with priority %u" msgstr "lo standby \"%s\" è ora uno standby sincrono con priorità %u" -#: replication/syncrep.c:969 +#: replication/syncrep.c:921 #, c-format -msgid "synchronous_standby_names parser returned %d" -msgstr "il parser synchronous_standby_names ha restituito %d" +msgid "synchronous_standby_names parser failed" +msgstr "interpretazione di synchronous_standby_names non riuscita" -#: replication/syncrep.c:1014 +#: replication/syncrep.c:927 #, c-format -msgid "The configured number of synchronous standbys (%d) exceeds the number of names of potential synchronous ones (%d)" -msgstr "Il numero di standby sincroni configurati (%d) eccede quello di standby sincroni potenziali (%d)" +msgid "number of synchronous standbys (%d) must be greater than zero" +msgstr "il numero di standby sincroni (%d) deve essere maggiore di zero" -#: replication/syncrep.c:1016 -#, c-format -msgid "Specify more names of potential synchronous standbys in synchronous_standby_names." -msgstr "Specifica più nomi di standby sincroni potenziali in synchronous_standby_names." - -#: replication/walreceiver.c:172 +#: replication/walreceiver.c:173 #, c-format msgid "terminating walreceiver process due to administrator command" msgstr "interruzione del processo walreceiver su comando dell'amministratore" -#: replication/walreceiver.c:324 +#: replication/walreceiver.c:344 #, c-format msgid "highest timeline %u of the primary is behind recovery timeline %u" msgstr "la timeline massima %u del primario è dietro la timeline di recupero %u" -#: replication/walreceiver.c:357 +#: replication/walreceiver.c:377 #, c-format msgid "started streaming WAL from primary at %X/%X on timeline %u" msgstr "streaming WAL avviato dal primario a %X/%X sulla timeline %u" -#: replication/walreceiver.c:362 +#: replication/walreceiver.c:382 #, c-format msgid "restarted WAL streaming at %X/%X on timeline %u" msgstr "streaming WAL riavviato sulla timeline %X/%X sulla timeline %u" -#: replication/walreceiver.c:391 +#: replication/walreceiver.c:411 #, c-format msgid "cannot continue WAL streaming, recovery has already ended" msgstr "non è possibile continuare lo streaming dei WAL, il recupero è già terminato" -#: replication/walreceiver.c:428 +#: replication/walreceiver.c:448 #, c-format msgid "replication terminated by primary server" msgstr "replica terminata dal server primario" -#: replication/walreceiver.c:429 +#: replication/walreceiver.c:449 #, c-format msgid "End of WAL reached on timeline %u at %X/%X." msgstr "Fine del WAL raggiunta sulla timeline %u a %X/%X." -#: replication/walreceiver.c:523 +#: replication/walreceiver.c:543 #, c-format msgid "terminating walreceiver due to timeout" msgstr "walreceiver terminato a causa di timeout" -#: replication/walreceiver.c:563 +#: replication/walreceiver.c:583 #, c-format msgid "primary server contains no more WAL on requested timeline %u" msgstr "il server primario non contiene più alcun WAL sulla timeline richiesta %u" -#: replication/walreceiver.c:578 replication/walreceiver.c:936 +#: replication/walreceiver.c:598 replication/walreceiver.c:957 #, c-format msgid "could not close log segment %s: %m" msgstr "chiusura del segmento di log %s fallita: %m" -#: replication/walreceiver.c:702 +#: replication/walreceiver.c:722 #, c-format msgid "fetching timeline history file for timeline %u from primary server" msgstr "recupero del file di storia della timeline %u dal server primario" -#: replication/walreceiver.c:990 +#: replication/walreceiver.c:1011 #, c-format msgid "could not write to log segment %s at offset %u, length %lu: %m" msgstr "scrittura nel segmento di log %s in posizione %u, lunghezza %lu fallita: %m" @@ -15436,37 +15453,37 @@ msgstr "interruzione del processo walsender dopo la promozione" msgid "received replication command: %s" msgstr "ricevuto comando di replica: %s" -#: replication/walsender.c:1393 replication/walsender.c:1409 +#: replication/walsender.c:1391 replication/walsender.c:1407 #, c-format msgid "unexpected EOF on standby connection" msgstr "fine del file inaspettato sulla connessione di standby" -#: replication/walsender.c:1423 +#: replication/walsender.c:1421 #, c-format msgid "unexpected standby message type \"%c\", after receiving CopyDone" msgstr "tipo di messaggio di standby \"%c\" imprevisto, dopo la ricezione di CopyDone" -#: replication/walsender.c:1461 +#: replication/walsender.c:1459 #, c-format msgid "invalid standby message type \"%c\"" msgstr "tipo di messaggio \"%c\" di standby non valido" -#: replication/walsender.c:1502 +#: replication/walsender.c:1500 #, c-format msgid "unexpected message type \"%c\"" msgstr "tipo di messaggio \"%c\" inatteso" -#: replication/walsender.c:1786 +#: replication/walsender.c:1784 #, c-format msgid "terminating walsender process due to replication timeout" msgstr "interruzione del processo walsender a causa di timeout di replica" -#: replication/walsender.c:1879 +#: replication/walsender.c:1877 #, c-format msgid "standby \"%s\" has now caught up with primary" msgstr "lo standby \"%s\" ha ora raggiunto il primario" -#: replication/walsender.c:1982 +#: replication/walsender.c:1980 #, c-format msgid "number of requested standby connections exceeds max_wal_senders (currently %d)" msgstr "il numero di richieste di connessioni di standby supera max_wal_senders (attualmente %d)" @@ -15903,31 +15920,36 @@ msgstr "Questo fenomeno è stato riportato con kernel difettosi: considera l'agg msgid "invalid page in block %u of relation %s; zeroing out page" msgstr "pagina non valida nel blocco %u della relazione %s; azzeramento della pagina" -#: storage/buffer/bufmgr.c:3951 +#: storage/buffer/bufmgr.c:3952 #, c-format msgid "could not write block %u of %s" msgstr "scrittura del blocco %u di %s fallita" -#: storage/buffer/bufmgr.c:3953 +#: storage/buffer/bufmgr.c:3954 #, c-format msgid "Multiple failures --- write error might be permanent." msgstr "Più di un fallimento --- l'errore in scrittura potrebbe essere permanente." -#: storage/buffer/bufmgr.c:3974 storage/buffer/bufmgr.c:3993 +#: storage/buffer/bufmgr.c:3975 storage/buffer/bufmgr.c:3994 #, c-format msgid "writing block %u of relation %s" msgstr "scrittura del blocco %u della relazione %s" -#: storage/buffer/bufmgr.c:4317 +#: storage/buffer/bufmgr.c:4295 #, c-format msgid "snapshot too old" msgstr "snapshot troppo vecchio" -#: storage/buffer/localbuf.c:198 +#: storage/buffer/localbuf.c:199 #, c-format msgid "no empty local buffer available" msgstr "nessun buffer locale vuoto disponibile" +#: storage/buffer/localbuf.c:427 +#, c-format +msgid "cannot access temporary tables during a parallel operation" +msgstr "non è possibile accedere alle tabelle temporanee durante un'operazione parallela" + #: storage/file/fd.c:436 storage/file/fd.c:508 storage/file/fd.c:544 #, c-format msgid "could not flush dirty data: %m" @@ -16026,37 +16048,37 @@ msgstr "troppi segmenti di memoria dinamica condivisa" #: storage/ipc/dsm_impl.c:261 storage/ipc/dsm_impl.c:361 #: storage/ipc/dsm_impl.c:533 storage/ipc/dsm_impl.c:648 -#: storage/ipc/dsm_impl.c:811 storage/ipc/dsm_impl.c:953 +#: storage/ipc/dsm_impl.c:819 storage/ipc/dsm_impl.c:961 #, c-format msgid "could not unmap shared memory segment \"%s\": %m" msgstr "unmap del segmento di memoria condivisa \"%s\" fallito: %m" #: storage/ipc/dsm_impl.c:271 storage/ipc/dsm_impl.c:543 -#: storage/ipc/dsm_impl.c:658 storage/ipc/dsm_impl.c:821 +#: storage/ipc/dsm_impl.c:658 storage/ipc/dsm_impl.c:829 #, c-format msgid "could not remove shared memory segment \"%s\": %m" msgstr "rimozione del segmento di memoria condivisa \"%s\" fallito: %m" -#: storage/ipc/dsm_impl.c:292 storage/ipc/dsm_impl.c:721 -#: storage/ipc/dsm_impl.c:835 +#: storage/ipc/dsm_impl.c:292 storage/ipc/dsm_impl.c:729 +#: storage/ipc/dsm_impl.c:843 #, c-format msgid "could not open shared memory segment \"%s\": %m" msgstr "apertura del segmento di memoria condivisa \"%s\" fallito: %m" #: storage/ipc/dsm_impl.c:316 storage/ipc/dsm_impl.c:559 -#: storage/ipc/dsm_impl.c:766 storage/ipc/dsm_impl.c:859 +#: storage/ipc/dsm_impl.c:774 storage/ipc/dsm_impl.c:867 #, c-format msgid "could not stat shared memory segment \"%s\": %m" msgstr "lettura informazioni sul segmento di memoria condivisa \"%s\" fallito: %m" -#: storage/ipc/dsm_impl.c:335 storage/ipc/dsm_impl.c:878 -#: storage/ipc/dsm_impl.c:926 +#: storage/ipc/dsm_impl.c:335 storage/ipc/dsm_impl.c:886 +#: storage/ipc/dsm_impl.c:934 #, c-format msgid "could not resize shared memory segment \"%s\" to %zu bytes: %m" msgstr "ridimensionamento del segmento di memoria condivisa \"%s\" a %zu byte fallito: %m" #: storage/ipc/dsm_impl.c:385 storage/ipc/dsm_impl.c:580 -#: storage/ipc/dsm_impl.c:742 storage/ipc/dsm_impl.c:977 +#: storage/ipc/dsm_impl.c:750 storage/ipc/dsm_impl.c:985 #, c-format msgid "could not map shared memory segment \"%s\": %m" msgstr "map del segmento di memoria condivisa \"%s\" fallito: %m" @@ -16066,67 +16088,67 @@ msgstr "map del segmento di memoria condivisa \"%s\" fallito: %m" msgid "could not get shared memory segment: %m" msgstr "impossibile ottenere un segmento di memoria condivisa: %m" -#: storage/ipc/dsm_impl.c:694 +#: storage/ipc/dsm_impl.c:714 #, c-format msgid "could not create shared memory segment \"%s\": %m" msgstr "creazione del segmento di memoria condivisa \"%s\" fallito: %m" -#: storage/ipc/dsm_impl.c:1018 +#: storage/ipc/dsm_impl.c:1026 #, c-format msgid "could not duplicate handle for \"%s\": %m" msgstr "duplicazione dell'handle per \"%s\" fallita: %m" -#: storage/ipc/latch.c:769 +#: storage/ipc/latch.c:778 #, c-format msgid "epoll_ctl() failed: %m" msgstr "epoll_ctl() fallita: %m" -#: storage/ipc/latch.c:993 +#: storage/ipc/latch.c:1002 #, c-format msgid "epoll_wait() failed: %m" msgstr "epoll_wait() fallita: %m" -#: storage/ipc/latch.c:1113 +#: storage/ipc/latch.c:1122 #, c-format msgid "poll() failed: %m" msgstr "poll() fallito: %m" -#: storage/ipc/shm_toc.c:108 storage/ipc/shm_toc.c:189 storage/ipc/shmem.c:210 +#: storage/ipc/shm_toc.c:108 storage/ipc/shm_toc.c:189 storage/ipc/shmem.c:212 #: storage/lmgr/lock.c:883 storage/lmgr/lock.c:917 storage/lmgr/lock.c:2682 #: storage/lmgr/lock.c:4007 storage/lmgr/lock.c:4072 storage/lmgr/lock.c:4364 #: storage/lmgr/predicate.c:2329 storage/lmgr/predicate.c:2344 #: storage/lmgr/predicate.c:3736 storage/lmgr/predicate.c:4879 -#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1045 +#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1043 #, c-format msgid "out of shared memory" msgstr "memoria condivisa esaurita" -#: storage/ipc/shmem.c:366 storage/ipc/shmem.c:417 +#: storage/ipc/shmem.c:370 storage/ipc/shmem.c:421 #, c-format msgid "not enough shared memory for data structure \"%s\" (%zu bytes requested)" msgstr "memoria condivisa per la struttura di dati \"%s\" insufficiente (richiesti %zu byte)" -#: storage/ipc/shmem.c:385 +#: storage/ipc/shmem.c:389 #, c-format msgid "could not create ShmemIndex entry for data structure \"%s\"" msgstr "creazione dell'elemento ShmemIndex fallita per la struttura di dati \"%s\"" -#: storage/ipc/shmem.c:400 +#: storage/ipc/shmem.c:404 #, c-format msgid "ShmemIndex entry size is wrong for data structure \"%s\": expected %zu, actual %zu" msgstr "dimensione elemento ShmemIndex errata per la struttura di dati \"%s\": attesi %zu, effettivi %zu" -#: storage/ipc/shmem.c:445 storage/ipc/shmem.c:464 +#: storage/ipc/shmem.c:452 storage/ipc/shmem.c:471 #, c-format msgid "requested shared memory size overflows size_t" msgstr "la dimensione richiesta di memoria condivisa supera size_t" -#: storage/ipc/standby.c:527 tcop/postgres.c:2963 +#: storage/ipc/standby.c:530 tcop/postgres.c:2976 #, c-format msgid "canceling statement due to conflict with recovery" msgstr "annullamento dell'istruzione a causa di un conflitto con il ripristino" -#: storage/ipc/standby.c:528 tcop/postgres.c:2265 +#: storage/ipc/standby.c:531 tcop/postgres.c:2263 #, c-format msgid "User transaction caused buffer deadlock with recovery." msgstr "La transazione utente ha causato un deadlock del buffer con il ripristino." @@ -16337,13 +16359,13 @@ msgstr "Puoi usare \"SET default_transaction_isolation = 'repeatable read'\" per msgid "a snapshot-importing transaction must not be READ ONLY DEFERRABLE" msgstr "una transazione che importa uno snapshot non può essere READ ONLY DEFERRABLE" -#: storage/lmgr/predicate.c:1706 utils/time/snapmgr.c:535 -#: utils/time/snapmgr.c:541 +#: storage/lmgr/predicate.c:1706 utils/time/snapmgr.c:617 +#: utils/time/snapmgr.c:623 #, c-format msgid "could not import the requested snapshot" msgstr "non è stato possibile importare lo snapshot richiesto" -#: storage/lmgr/predicate.c:1707 utils/time/snapmgr.c:542 +#: storage/lmgr/predicate.c:1707 utils/time/snapmgr.c:624 #, c-format msgid "The source transaction %u is not running anymore." msgstr "La transazione di origine %u non è più in esecuzione." @@ -16372,42 +16394,42 @@ msgstr "serializzazione dell'accesso fallita a causa di dipendenze di lettura/sc msgid "The transaction might succeed if retried." msgstr "La transazione potrebbe riuscire se ritentata." -#: storage/lmgr/proc.c:1263 +#: storage/lmgr/proc.c:1265 #, c-format msgid "Process %d waits for %s on %s." msgstr "Processo %d in attesa di %s su %s." -#: storage/lmgr/proc.c:1274 +#: storage/lmgr/proc.c:1276 #, c-format msgid "sending cancel to blocking autovacuum PID %d" msgstr "invio di annullamento per bloccare l'autovacuum con PID %d" -#: storage/lmgr/proc.c:1292 utils/adt/misc.c:270 +#: storage/lmgr/proc.c:1294 utils/adt/misc.c:270 #, c-format msgid "could not send signal to process %d: %m" msgstr "invio del segnale al processo %d fallito: %m" -#: storage/lmgr/proc.c:1394 +#: storage/lmgr/proc.c:1396 #, c-format msgid "process %d avoided deadlock for %s on %s by rearranging queue order after %ld.%03d ms" msgstr "il processo %d ha evitato un deadlock per %s su %s modificando l'ordine della coda dopo %ld.%03d ms" -#: storage/lmgr/proc.c:1409 +#: storage/lmgr/proc.c:1411 #, c-format msgid "process %d detected deadlock while waiting for %s on %s after %ld.%03d ms" msgstr "il processo %d ha individuato un deadlock mentre era in attesa di %s su %s dopo %ld.%03d ms" -#: storage/lmgr/proc.c:1418 +#: storage/lmgr/proc.c:1420 #, c-format msgid "process %d still waiting for %s on %s after %ld.%03d ms" msgstr "il processo %d è ancora un attesa di %s su %s dopo %ld.%03d ms" -#: storage/lmgr/proc.c:1425 +#: storage/lmgr/proc.c:1427 #, c-format msgid "process %d acquired %s on %s after %ld.%03d ms" msgstr "il processo %d ha acquisito %s su %s dopo %ld.%03d ms" -#: storage/lmgr/proc.c:1441 +#: storage/lmgr/proc.c:1443 #, c-format msgid "process %d failed to acquire %s on %s after %ld.%03d ms" msgstr "il processo %d ha fallito l'acquisizione di %s su %s dopo %ld.%03d ms" @@ -16417,105 +16439,110 @@ msgstr "il processo %d ha fallito l'acquisizione di %s su %s dopo %ld.%03d ms" msgid "page verification failed, calculated checksum %u but expected %u" msgstr "verifica della pagina fallita, somma di controllo calcolata %u ma era attesa %u" -#: storage/page/bufpage.c:200 storage/page/bufpage.c:490 -#: storage/page/bufpage.c:705 storage/page/bufpage.c:836 -#: storage/page/bufpage.c:936 +#: storage/page/bufpage.c:203 storage/page/bufpage.c:522 +#: storage/page/bufpage.c:737 storage/page/bufpage.c:868 +#: storage/page/bufpage.c:968 #, c-format msgid "corrupted page pointers: lower = %u, upper = %u, special = %u" msgstr "puntatore di pagina corrotto: lower = %u, upper = %u, special = %u" -#: storage/page/bufpage.c:534 +#: storage/page/bufpage.c:566 #, c-format msgid "corrupted item pointer: %u" msgstr "puntatore di elemento corrotto: %u" -#: storage/page/bufpage.c:545 storage/page/bufpage.c:887 -#: storage/page/bufpage.c:1042 +#: storage/page/bufpage.c:577 storage/page/bufpage.c:919 +#: storage/page/bufpage.c:1074 #, c-format msgid "corrupted item lengths: total %u, available space %u" msgstr "lunghezza dell'elemento corrotta: totale %u, spazio disponibile %u" -#: storage/page/bufpage.c:724 storage/page/bufpage.c:860 +#: storage/page/bufpage.c:756 storage/page/bufpage.c:892 #, c-format msgid "corrupted item pointer: offset = %u, size = %u" msgstr "puntatore di elemento corrotto: offset = %u, size = %u" -#: storage/page/bufpage.c:965 +#: storage/page/bufpage.c:997 #, c-format msgid "corrupted item pointer: offset = %u, length = %u" msgstr "puntatore di elemento corrotto: offset = %u, lunghezza = %u" -#: storage/smgr/md.c:442 storage/smgr/md.c:962 +#: storage/smgr/md.c:449 storage/smgr/md.c:971 #, c-format msgid "could not truncate file \"%s\": %m" msgstr "troncamento del file \"%s\" fallito: %m" -#: storage/smgr/md.c:509 +#: storage/smgr/md.c:516 #, c-format msgid "cannot extend file \"%s\" beyond %u blocks" msgstr "estendere il file \"%s\" oltre %u blocchi" -#: storage/smgr/md.c:531 storage/smgr/md.c:743 storage/smgr/md.c:818 +#: storage/smgr/md.c:538 storage/smgr/md.c:751 storage/smgr/md.c:827 #, c-format msgid "could not seek to block %u in file \"%s\": %m" msgstr "spostamento al blocco %u nel file \"%s\" fallito: %m" -#: storage/smgr/md.c:539 +#: storage/smgr/md.c:546 #, c-format msgid "could not extend file \"%s\": %m" msgstr "non è stato possibile estendere il file \"%s\": %m" -#: storage/smgr/md.c:541 storage/smgr/md.c:548 storage/smgr/md.c:845 +#: storage/smgr/md.c:548 storage/smgr/md.c:555 storage/smgr/md.c:854 #, c-format msgid "Check free disk space." msgstr "Controlla lo spazio libero sul disco." -#: storage/smgr/md.c:545 +#: storage/smgr/md.c:552 #, c-format msgid "could not extend file \"%s\": wrote only %d of %d bytes at block %u" msgstr "non è stato possibile estendere il file \"%s\": scritti soli %d byte di %d nel blocco %u" -#: storage/smgr/md.c:761 +#: storage/smgr/md.c:769 #, c-format msgid "could not read block %u in file \"%s\": %m" msgstr "lettura del blocco %u nel file \"%s\" fallita: %m" -#: storage/smgr/md.c:777 +#: storage/smgr/md.c:785 #, c-format msgid "could not read block %u in file \"%s\": read only %d of %d bytes" msgstr "lettura del blocco %u nel file \"%s\" fallita: letti soli %d byte di %d" -#: storage/smgr/md.c:836 +#: storage/smgr/md.c:845 #, c-format msgid "could not write block %u in file \"%s\": %m" msgstr "scrittura del blocco %u nel file \"%s\" fallita: %m" -#: storage/smgr/md.c:841 +#: storage/smgr/md.c:850 #, c-format msgid "could not write block %u in file \"%s\": wrote only %d of %d bytes" msgstr "lettura del blocco %u nel file \"%s\" fallita: scritti solo %d byte di %d" -#: storage/smgr/md.c:938 +#: storage/smgr/md.c:947 #, c-format msgid "could not truncate file \"%s\" to %u blocks: it's only %u blocks now" msgstr "troncamento del file \"%s\" a %u blocchi fallito: ora è di soli %u blocchi" -#: storage/smgr/md.c:987 +#: storage/smgr/md.c:997 #, c-format msgid "could not truncate file \"%s\" to %u blocks: %m" msgstr "troncamento del file \"%s\" a %u blocchi fallito: %m" -#: storage/smgr/md.c:1267 +#: storage/smgr/md.c:1279 #, c-format msgid "could not fsync file \"%s\" but retrying: %m" msgstr "fsync del file \"%s\" fallito ma sto ritentando: %m" -#: storage/smgr/md.c:1430 +#: storage/smgr/md.c:1442 #, c-format msgid "could not forward fsync request because request queue is full" msgstr "inoltro della richiesta di fsync fallito perché la coda di richieste è piena" -#: storage/smgr/md.c:1825 +#: storage/smgr/md.c:1863 +#, c-format +msgid "could not open file \"%s\" (target block %u): previous segment is only %u blocks" +msgstr "apertura del file \"%s\" fallita (blocco di destinazione %u): il segmento precedente è di soli %u blocchi" + +#: storage/smgr/md.c:1877 #, c-format msgid "could not open file \"%s\" (target block %u): %m" msgstr "apertura del file \"%s\" fallita (blocco di destinazione %u): %m" @@ -16525,9 +16552,9 @@ msgstr "apertura del file \"%s\" fallita (blocco di destinazione %u): %m" msgid "invalid argument size %d in function call message" msgstr "La dimensione dell'argomento %d non è valida nel messaggi di chiamata di funzione" -#: tcop/fastpath.c:291 tcop/postgres.c:992 tcop/postgres.c:1303 -#: tcop/postgres.c:1561 tcop/postgres.c:1966 tcop/postgres.c:2333 -#: tcop/postgres.c:2408 +#: tcop/fastpath.c:291 tcop/postgres.c:992 tcop/postgres.c:1301 +#: tcop/postgres.c:1559 tcop/postgres.c:1964 tcop/postgres.c:2331 +#: tcop/postgres.c:2406 #, c-format msgid "current transaction is aborted, commands ignored until end of transaction block" msgstr "la transazione corrente è interrotta, i comandi saranno ignorati fino alla fine del blocco della transazione" @@ -16537,8 +16564,8 @@ msgstr "la transazione corrente è interrotta, i comandi saranno ignorati fino a msgid "fastpath function call: \"%s\" (OID %u)" msgstr "chiamata funzione fastpath: \"%s\" (OID %u)" -#: tcop/fastpath.c:401 tcop/postgres.c:1163 tcop/postgres.c:1428 -#: tcop/postgres.c:1807 tcop/postgres.c:2024 +#: tcop/fastpath.c:401 tcop/postgres.c:1163 tcop/postgres.c:1426 +#: tcop/postgres.c:1805 tcop/postgres.c:2022 #, c-format msgid "duration: %s ms" msgstr "durata: %s ms" @@ -16569,7 +16596,7 @@ msgid "unexpected EOF on client connection" msgstr "fine file inaspettata nella connessione al client" #: tcop/postgres.c:438 tcop/postgres.c:450 tcop/postgres.c:461 -#: tcop/postgres.c:473 tcop/postgres.c:4297 +#: tcop/postgres.c:473 tcop/postgres.c:4314 #, c-format msgid "invalid frontend message type %d" msgstr "messaggio frontend di tipo %d non valido" @@ -16589,260 +16616,260 @@ msgstr "durata: %s ms istruzione: %s" msgid "parse %s: %s" msgstr "analisi di %s: %s" -#: tcop/postgres.c:1276 +#: tcop/postgres.c:1274 #, c-format msgid "cannot insert multiple commands into a prepared statement" msgstr "non è possibile inserire comandi multipli in una istruzione preparata" -#: tcop/postgres.c:1433 +#: tcop/postgres.c:1431 #, c-format msgid "duration: %s ms parse %s: %s" msgstr "durata: %s ms analisi di %s: %s" -#: tcop/postgres.c:1478 +#: tcop/postgres.c:1476 #, c-format msgid "bind %s to %s" msgstr "bind di %s a %s" -#: tcop/postgres.c:1497 tcop/postgres.c:2314 +#: tcop/postgres.c:1495 tcop/postgres.c:2312 #, c-format msgid "unnamed prepared statement does not exist" msgstr "l'istruzione preparata senza nome non esiste" -#: tcop/postgres.c:1539 +#: tcop/postgres.c:1537 #, c-format msgid "bind message has %d parameter formats but %d parameters" msgstr "il messaggio di bind ha %d formati di parametri ma %d parametri" -#: tcop/postgres.c:1545 +#: tcop/postgres.c:1543 #, c-format msgid "bind message supplies %d parameters, but prepared statement \"%s\" requires %d" msgstr "il messaggio di bind fornisce %d paramatri, ma l'istruzione preparata \"%s\" ne richiede %d" -#: tcop/postgres.c:1714 +#: tcop/postgres.c:1712 #, c-format msgid "incorrect binary data format in bind parameter %d" msgstr "formato del dato binario errato nel parametro di bind %d" -#: tcop/postgres.c:1812 +#: tcop/postgres.c:1810 #, c-format msgid "duration: %s ms bind %s%s%s: %s" msgstr "durata: %s ms bind %s%s%s: %s" -#: tcop/postgres.c:1860 tcop/postgres.c:2394 +#: tcop/postgres.c:1858 tcop/postgres.c:2392 #, c-format msgid "portal \"%s\" does not exist" msgstr "il portale \"%s\" non esiste" -#: tcop/postgres.c:1945 +#: tcop/postgres.c:1943 #, c-format msgid "%s %s%s%s: %s" msgstr "%s %s%s%s: %s" -#: tcop/postgres.c:1947 tcop/postgres.c:2032 +#: tcop/postgres.c:1945 tcop/postgres.c:2030 msgid "execute fetch from" msgstr "esecuzione di fetch da" -#: tcop/postgres.c:1948 tcop/postgres.c:2033 +#: tcop/postgres.c:1946 tcop/postgres.c:2031 msgid "execute" msgstr "esecuzione di" -#: tcop/postgres.c:2029 +#: tcop/postgres.c:2027 #, c-format msgid "duration: %s ms %s %s%s%s: %s" msgstr "durata: %s ms %s %s%s%s: %s" -#: tcop/postgres.c:2155 +#: tcop/postgres.c:2153 #, c-format msgid "prepare: %s" msgstr "preparazione: %s" -#: tcop/postgres.c:2218 +#: tcop/postgres.c:2216 #, c-format msgid "parameters: %s" msgstr "parametri: %s" -#: tcop/postgres.c:2237 +#: tcop/postgres.c:2235 #, c-format msgid "abort reason: recovery conflict" msgstr "motivo dell'interruzione: conflitto di recupero" -#: tcop/postgres.c:2253 +#: tcop/postgres.c:2251 #, c-format msgid "User was holding shared buffer pin for too long." msgstr "L'utente stava trattenendo un pin di shared buffer troppo a lungo." -#: tcop/postgres.c:2256 +#: tcop/postgres.c:2254 #, c-format msgid "User was holding a relation lock for too long." msgstr "L'utente stava trattenendo un lock di relazione troppo a lungo." -#: tcop/postgres.c:2259 +#: tcop/postgres.c:2257 #, c-format msgid "User was or might have been using tablespace that must be dropped." msgstr "L'utente stava usando o potrebbe aver usato un tablespace che deve essere eliminato." -#: tcop/postgres.c:2262 +#: tcop/postgres.c:2260 #, c-format msgid "User query might have needed to see row versions that must be removed." msgstr "L'utente potrebbe aver avuto bisogno di vedere versioni di righe che devono essere rimosse." -#: tcop/postgres.c:2268 +#: tcop/postgres.c:2266 #, c-format msgid "User was connected to a database that must be dropped." msgstr "L'utente era connesso ad un database che deve essere eliminato." -#: tcop/postgres.c:2597 +#: tcop/postgres.c:2595 #, c-format msgid "terminating connection because of crash of another server process" msgstr "la connessione è stata terminata a causa del crash di un altro processo del server" -#: tcop/postgres.c:2598 +#: tcop/postgres.c:2596 #, c-format msgid "The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory." msgstr "Il postmaster ha obbligato questo processo del server di attuare il roll back della transazione corrente e di uscire, perché un altro processo del server è terminato anormalmente e con possibile corruzione della memoria condivisa." -#: tcop/postgres.c:2602 tcop/postgres.c:2906 +#: tcop/postgres.c:2600 tcop/postgres.c:2904 #, c-format msgid "In a moment you should be able to reconnect to the database and repeat your command." msgstr "In un momento sarai in grado di riconnetterti al database e di ripetere il comando." -#: tcop/postgres.c:2688 +#: tcop/postgres.c:2686 #, c-format msgid "floating-point exception" msgstr "eccezione floating-point" -#: tcop/postgres.c:2689 +#: tcop/postgres.c:2687 #, c-format msgid "An invalid floating-point operation was signaled. This probably means an out-of-range result or an invalid operation, such as division by zero." msgstr "Un'operazione in floating-point non valida è stata segnalata. Questo probabilmente sta a significare che il risultato è un valore fuori limite o l'operazione non è valida, ad esempio una divisione per zero." -#: tcop/postgres.c:2851 +#: tcop/postgres.c:2849 #, c-format msgid "canceling authentication due to timeout" msgstr "annullamento dell'autenticazione a causa di timeout" -#: tcop/postgres.c:2855 +#: tcop/postgres.c:2853 #, c-format msgid "terminating autovacuum process due to administrator command" msgstr "interruzione del processo autovacuum su comando dell'amministratore" -#: tcop/postgres.c:2861 tcop/postgres.c:2871 tcop/postgres.c:2904 +#: tcop/postgres.c:2859 tcop/postgres.c:2869 tcop/postgres.c:2902 #, c-format msgid "terminating connection due to conflict with recovery" msgstr "interruzione della connessione a causa di conflitto con il ripristino" -#: tcop/postgres.c:2877 +#: tcop/postgres.c:2875 #, c-format msgid "terminating connection due to administrator command" msgstr "interruzione della connessione su comando dell'amministratore" -#: tcop/postgres.c:2887 +#: tcop/postgres.c:2885 #, c-format msgid "connection to client lost" msgstr "connessione al client persa" -#: tcop/postgres.c:2940 +#: tcop/postgres.c:2953 #, c-format msgid "canceling statement due to lock timeout" msgstr "annullamento dell'istruzione a causa di timeout di lock" -#: tcop/postgres.c:2947 +#: tcop/postgres.c:2960 #, c-format msgid "canceling statement due to statement timeout" msgstr "annullamento dell'istruzione a causa di timeout" -#: tcop/postgres.c:2954 +#: tcop/postgres.c:2967 #, c-format msgid "canceling autovacuum task" msgstr "annullamento del task di autovacuum" -#: tcop/postgres.c:2977 +#: tcop/postgres.c:2990 #, c-format msgid "canceling statement due to user request" msgstr "annullamento dell'istruzione su richiesta dell'utente" -#: tcop/postgres.c:2987 +#: tcop/postgres.c:3000 #, c-format msgid "terminating connection due to idle-in-transaction timeout" msgstr "la connessione è stata terminata a causa di timeout di inattività durante una transazione" -#: tcop/postgres.c:3101 +#: tcop/postgres.c:3114 #, c-format msgid "stack depth limit exceeded" msgstr "limite di profondità dello stack superato" -#: tcop/postgres.c:3102 +#: tcop/postgres.c:3115 #, c-format msgid "Increase the configuration parameter \"max_stack_depth\" (currently %dkB), after ensuring the platform's stack depth limit is adequate." msgstr "Incrementa il parametro di configurazione \"max_stack_depth\" (attualmente %dkB), dopo esserti assicurato che il limite dello stack della piattaforma sia adeguato." -#: tcop/postgres.c:3165 +#: tcop/postgres.c:3178 #, c-format msgid "\"max_stack_depth\" must not exceed %ldkB." msgstr "\"max_stack_depth\" non deve superare %ldkB" -#: tcop/postgres.c:3167 +#: tcop/postgres.c:3180 #, c-format msgid "Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent." msgstr "Incrementa il limite dello stack della piattaforma usando \"ulimit -s\" on un comando equivalente." -#: tcop/postgres.c:3527 +#: tcop/postgres.c:3540 #, c-format msgid "invalid command-line argument for server process: %s" msgstr "argomento della riga di comando non valido per il processo server: %s" -#: tcop/postgres.c:3528 tcop/postgres.c:3534 +#: tcop/postgres.c:3541 tcop/postgres.c:3547 #, c-format msgid "Try \"%s --help\" for more information." msgstr "Prova \"%s --help\" per maggiori informazioni." -#: tcop/postgres.c:3532 +#: tcop/postgres.c:3545 #, c-format msgid "%s: invalid command-line argument: %s" msgstr "%s: argomento della riga di comando non valido: %s" -#: tcop/postgres.c:3594 +#: tcop/postgres.c:3607 #, c-format msgid "%s: no database nor user name specified" msgstr "%s: nessun database né nome utente specificato" -#: tcop/postgres.c:4205 +#: tcop/postgres.c:4222 #, c-format msgid "invalid CLOSE message subtype %d" msgstr "sottotipo %d del messaggio CLOSE non valido" -#: tcop/postgres.c:4240 +#: tcop/postgres.c:4257 #, c-format msgid "invalid DESCRIBE message subtype %d" msgstr "sottotipo %d del messaggio DESCRIBE non valido" -#: tcop/postgres.c:4318 +#: tcop/postgres.c:4335 #, c-format msgid "fastpath function calls not supported in a replication connection" msgstr "le chiamate di funzione fastpath non sono supportate in una connessione di replica" -#: tcop/postgres.c:4322 +#: tcop/postgres.c:4339 #, c-format msgid "extended query protocol not supported in a replication connection" msgstr "il protocollo di query esteso non è supportato in una connessione di replica" -#: tcop/postgres.c:4492 +#: tcop/postgres.c:4509 #, c-format msgid "disconnection: session time: %d:%02d:%02d.%03d user=%s database=%s host=%s%s%s" msgstr "disconnessione: tempo della sessione: %d:%02d:%02d.%03d utente=%s database=%s host=%s%s%s" -#: tcop/pquery.c:663 +#: tcop/pquery.c:665 #, c-format msgid "bind message has %d result formats but query has %d columns" msgstr "il messaggio di bind ha %d formati di risultato ma la query ha %d colonne" -#: tcop/pquery.c:965 +#: tcop/pquery.c:967 #, c-format msgid "cursor can only scan forward" msgstr "il cursore effettuare solo scansioni in avanti" -#: tcop/pquery.c:966 +#: tcop/pquery.c:968 #, c-format msgid "Declare it with SCROLL option to enable backward scan." msgstr "Dichiaralo con l'opzione SCROLL per abilitare le scansioni all'indietro." @@ -16996,28 +17023,28 @@ msgstr "parametro di Thesaurus sconosciuto: \"%s\"" msgid "missing Dictionary parameter" msgstr "parametro di Dictionary mancante" -#: tsearch/spell.c:382 tsearch/spell.c:399 tsearch/spell.c:408 +#: tsearch/spell.c:380 tsearch/spell.c:397 tsearch/spell.c:406 #: tsearch/spell.c:1034 #, c-format msgid "invalid affix flag \"%s\"" msgstr "flag di affix non valido \"%s\"" -#: tsearch/spell.c:386 tsearch/spell.c:1038 +#: tsearch/spell.c:384 tsearch/spell.c:1038 #, c-format msgid "affix flag \"%s\" is out of range" msgstr "flag di affix \"%s\" fuori dall'intervallo valido" -#: tsearch/spell.c:416 +#: tsearch/spell.c:414 #, c-format msgid "invalid character in affix flag \"%s\"" msgstr "carattere non valido nel flag affix \"%s\"" -#: tsearch/spell.c:436 +#: tsearch/spell.c:434 #, c-format -msgid "invalid affix flag \"%s\" with long flag value" -msgstr "flag affix \"%s\" con valore di flag lungo" +msgid "invalid affix flag \"%s\" with \"long\" flag value" +msgstr "flag di affix \"%s\" con valore di flag \"long\" non valido" -#: tsearch/spell.c:523 +#: tsearch/spell.c:522 #, c-format msgid "could not open dictionary file \"%s\": %m" msgstr "apertura del file dictionary \"%s\" fallita: %m" @@ -17028,38 +17055,37 @@ msgid "invalid regular expression: %s" msgstr "espressione regolare non valida: %s" #: tsearch/spell.c:954 tsearch/spell.c:971 tsearch/spell.c:988 -#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14385 gram.y:14402 +#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14401 gram.y:14418 #, c-format msgid "syntax error" msgstr "errore di sintassi" -#: tsearch/spell.c:1161 tsearch/spell.c:1716 +#: tsearch/spell.c:1161 tsearch/spell.c:1721 #, c-format msgid "invalid affix alias \"%s\"" msgstr "alias di affix \"%s\" non valido" -#: tsearch/spell.c:1210 tsearch/spell.c:1280 tsearch/spell.c:1422 +#: tsearch/spell.c:1211 tsearch/spell.c:1282 tsearch/spell.c:1426 #, c-format msgid "could not open affix file \"%s\": %m" msgstr "apertura del file affix \"%s\" fallita: %m" -#: tsearch/spell.c:1264 +#: tsearch/spell.c:1265 #, c-format -msgid "Ispell dictionary supports only default, long and num flag value" -msgstr "il dizionario Ispell supporta solo valori di flag default, long e num" +msgid "Ispell dictionary supports only \"default\", \"long\", and \"num\" flag values" +msgstr "il dizionario Ispell supporta solo valori di flag \"default\", \"long\" e \"num\"" -#: tsearch/spell.c:1307 +#: tsearch/spell.c:1309 #, c-format msgid "invalid number of flag vector aliases" msgstr "numero di alias nel vettore di flag non valido" -#: tsearch/spell.c:1538 +#: tsearch/spell.c:1542 #, c-format msgid "affix file contains both old-style and new-style commands" msgstr "il file affix contiene comandi sia vecchio stile che nuovo stile" -#: tsearch/to_tsany.c:170 utils/adt/tsvector.c:270 -#: utils/adt/tsvector_op.c:1064 +#: tsearch/to_tsany.c:170 utils/adt/tsvector.c:270 utils/adt/tsvector_op.c:1133 #, c-format msgid "string is too long for tsvector (%d bytes, max %d bytes)" msgstr "la stringa è troppo lunga per tsvector (%d byte, massimo %d byte)" @@ -17237,91 +17263,86 @@ msgstr "la funzione \"%s\" non esiste" msgid "must be member of role \"%s\"" msgstr "occorre far parte del ruolo \"%s\"" -#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 -#, c-format -msgid "role \"%s\" is reserved" -msgstr "il ruolo \"%s\" è riservato" - -#: utils/adt/array_expanded.c:276 utils/adt/arrayfuncs.c:931 +#: utils/adt/array_expanded.c:274 utils/adt/arrayfuncs.c:931 #: utils/adt/arrayfuncs.c:1519 utils/adt/arrayfuncs.c:3251 -#: utils/adt/arrayfuncs.c:3389 utils/adt/arrayfuncs.c:5864 -#: utils/adt/arrayfuncs.c:6175 utils/adt/arrayutils.c:93 +#: utils/adt/arrayfuncs.c:3389 utils/adt/arrayfuncs.c:5848 +#: utils/adt/arrayfuncs.c:6159 utils/adt/arrayutils.c:93 #: utils/adt/arrayutils.c:102 utils/adt/arrayutils.c:109 #, c-format msgid "array size exceeds the maximum allowed (%d)" msgstr "la dimensione dell'array supera il massimo consentito (%d)" -#: utils/adt/array_userfuncs.c:67 utils/adt/array_userfuncs.c:529 -#: utils/adt/array_userfuncs.c:609 utils/adt/json.c:1759 utils/adt/json.c:1854 +#: utils/adt/array_userfuncs.c:79 utils/adt/array_userfuncs.c:541 +#: utils/adt/array_userfuncs.c:621 utils/adt/json.c:1759 utils/adt/json.c:1854 #: utils/adt/json.c:1892 utils/adt/jsonb.c:1126 utils/adt/jsonb.c:1155 #: utils/adt/jsonb.c:1591 utils/adt/jsonb.c:1755 utils/adt/jsonb.c:1765 #, c-format msgid "could not determine input data type" msgstr "non è stato possibile determinare il tipo di dato di input" -#: utils/adt/array_userfuncs.c:72 +#: utils/adt/array_userfuncs.c:84 #, c-format msgid "input data type is not an array" msgstr "il tipo di dati in input non è un array" -#: utils/adt/array_userfuncs.c:120 utils/adt/array_userfuncs.c:174 -#: utils/adt/arrayfuncs.c:1322 utils/adt/float.c:1221 utils/adt/float.c:1280 -#: utils/adt/float.c:3509 utils/adt/float.c:3525 utils/adt/int.c:623 +#: utils/adt/array_userfuncs.c:132 utils/adt/array_userfuncs.c:186 +#: utils/adt/arrayfuncs.c:1322 utils/adt/float.c:1228 utils/adt/float.c:1287 +#: utils/adt/float.c:3556 utils/adt/float.c:3572 utils/adt/int.c:623 #: utils/adt/int.c:652 utils/adt/int.c:673 utils/adt/int.c:704 #: utils/adt/int.c:737 utils/adt/int.c:759 utils/adt/int.c:907 #: utils/adt/int.c:928 utils/adt/int.c:955 utils/adt/int.c:995 #: utils/adt/int.c:1016 utils/adt/int.c:1043 utils/adt/int.c:1076 -#: utils/adt/int.c:1159 utils/adt/int8.c:1298 utils/adt/numeric.c:2907 -#: utils/adt/numeric.c:2916 utils/adt/varbit.c:1173 utils/adt/varbit.c:1565 +#: utils/adt/int.c:1159 utils/adt/int8.c:1298 utils/adt/numeric.c:2903 +#: utils/adt/numeric.c:2912 utils/adt/varbit.c:1173 utils/adt/varbit.c:1575 #: utils/adt/varlena.c:1055 utils/adt/varlena.c:2807 #, c-format msgid "integer out of range" msgstr "intero fuori dall'intervallo" -#: utils/adt/array_userfuncs.c:127 utils/adt/array_userfuncs.c:184 +#: utils/adt/array_userfuncs.c:139 utils/adt/array_userfuncs.c:196 #, c-format msgid "argument must be empty or one-dimensional array" msgstr "l'argomento deve essere vuoto o un array con una sola dimensione" -#: utils/adt/array_userfuncs.c:266 utils/adt/array_userfuncs.c:305 -#: utils/adt/array_userfuncs.c:342 utils/adt/array_userfuncs.c:371 -#: utils/adt/array_userfuncs.c:399 +#: utils/adt/array_userfuncs.c:278 utils/adt/array_userfuncs.c:317 +#: utils/adt/array_userfuncs.c:354 utils/adt/array_userfuncs.c:383 +#: utils/adt/array_userfuncs.c:411 #, c-format msgid "cannot concatenate incompatible arrays" msgstr "non è possibile concatenare array non compatibili" -#: utils/adt/array_userfuncs.c:267 +#: utils/adt/array_userfuncs.c:279 #, c-format msgid "Arrays with element types %s and %s are not compatible for concatenation." msgstr "Array con elementi di tipi %s e %s non sono compatibili per il concatenamento." -#: utils/adt/array_userfuncs.c:306 +#: utils/adt/array_userfuncs.c:318 #, c-format msgid "Arrays of %d and %d dimensions are not compatible for concatenation." msgstr "Array con dimensioni %d e %d non sono compatibili per il concatenamento." -#: utils/adt/array_userfuncs.c:343 +#: utils/adt/array_userfuncs.c:355 #, c-format msgid "Arrays with differing element dimensions are not compatible for concatenation." msgstr "Array con elementi dalle dimensioni diverse non sono compatibili per il concatenamento." -#: utils/adt/array_userfuncs.c:372 utils/adt/array_userfuncs.c:400 +#: utils/adt/array_userfuncs.c:384 utils/adt/array_userfuncs.c:412 #, c-format msgid "Arrays with differing dimensions are not compatible for concatenation." msgstr "Array con dimensioni diverse non sono compatibili per il concatenamento." -#: utils/adt/array_userfuncs.c:468 utils/adt/arrayfuncs.c:1284 -#: utils/adt/arrayfuncs.c:3357 utils/adt/arrayfuncs.c:5764 +#: utils/adt/array_userfuncs.c:480 utils/adt/arrayfuncs.c:1284 +#: utils/adt/arrayfuncs.c:3357 utils/adt/arrayfuncs.c:5754 #, c-format msgid "invalid number of dimensions: %d" msgstr "numero di dimensioni non valido: %d" -#: utils/adt/array_userfuncs.c:725 utils/adt/array_userfuncs.c:876 +#: utils/adt/array_userfuncs.c:737 utils/adt/array_userfuncs.c:889 #, c-format msgid "searching for elements in multidimensional arrays is not supported" msgstr "la ricerca di elementi in array multidimensionali non è supportata" -#: utils/adt/array_userfuncs.c:749 +#: utils/adt/array_userfuncs.c:761 #, c-format msgid "initial position must not be null" msgstr "la posizione iniziale non può essere nulla" @@ -17445,11 +17466,11 @@ msgstr "le sezioni di array a lunghezza fissa non sono implementate" #: utils/adt/arrayfuncs.c:2230 utils/adt/arrayfuncs.c:2252 #: utils/adt/arrayfuncs.c:2301 utils/adt/arrayfuncs.c:2537 -#: utils/adt/arrayfuncs.c:2848 utils/adt/arrayfuncs.c:5744 -#: utils/adt/arrayfuncs.c:5776 utils/adt/arrayfuncs.c:5793 +#: utils/adt/arrayfuncs.c:2848 utils/adt/arrayfuncs.c:5740 +#: utils/adt/arrayfuncs.c:5766 utils/adt/arrayfuncs.c:5777 #: utils/adt/json.c:2290 utils/adt/json.c:2365 utils/adt/jsonb.c:1369 -#: utils/adt/jsonb.c:1455 utils/adt/jsonfuncs.c:3537 -#: utils/adt/jsonfuncs.c:3582 utils/adt/jsonfuncs.c:3629 +#: utils/adt/jsonb.c:1455 utils/adt/jsonfuncs.c:3529 utils/adt/jsonfuncs.c:3574 +#: utils/adt/jsonfuncs.c:3621 #, c-format msgid "wrong number of array subscripts" msgstr "il numero di indici di array è errato" @@ -17501,67 +17522,57 @@ msgstr "non è possibile confrontare array con elementi di tipo diverso" msgid "could not identify a hash function for type %s" msgstr "non è stato possibile trovare una funzione di hash per il tipo %s" -#: utils/adt/arrayfuncs.c:5156 +#: utils/adt/arrayfuncs.c:5154 #, c-format msgid "data type %s is not an array type" msgstr "il tipo di dati %s non è un tipo array" -#: utils/adt/arrayfuncs.c:5213 +#: utils/adt/arrayfuncs.c:5209 #, c-format msgid "cannot accumulate null arrays" msgstr "non è possibile accumulare array nulli" -#: utils/adt/arrayfuncs.c:5241 +#: utils/adt/arrayfuncs.c:5237 #, c-format msgid "cannot accumulate empty arrays" msgstr "non è possibile accumulare array vuoti" -#: utils/adt/arrayfuncs.c:5270 utils/adt/arrayfuncs.c:5276 +#: utils/adt/arrayfuncs.c:5266 utils/adt/arrayfuncs.c:5272 #, c-format msgid "cannot accumulate arrays of different dimensionality" msgstr "non è possibile accumulare array di dimensioni diverse" -#: utils/adt/arrayfuncs.c:5642 utils/adt/arrayfuncs.c:5682 +#: utils/adt/arrayfuncs.c:5638 utils/adt/arrayfuncs.c:5678 #, c-format msgid "dimension array or low bound array cannot be null" msgstr "la dimensione dell'array o il suo limite inferiore non possono essere nulli" -#: utils/adt/arrayfuncs.c:5745 utils/adt/arrayfuncs.c:5777 +#: utils/adt/arrayfuncs.c:5741 utils/adt/arrayfuncs.c:5767 #, c-format msgid "Dimension array must be one dimensional." msgstr "L'array delle dimensioni deve avere una sola dimensione." -#: utils/adt/arrayfuncs.c:5750 utils/adt/arrayfuncs.c:5782 -#, c-format -msgid "wrong range of array subscripts" -msgstr "il range degli indici dell'array non è corretto" - -#: utils/adt/arrayfuncs.c:5751 utils/adt/arrayfuncs.c:5783 -#, c-format -msgid "Lower bound of dimension array must be one." -msgstr "Il valore minimo dell'array delle dimensioni deve essere uno." - -#: utils/adt/arrayfuncs.c:5756 utils/adt/arrayfuncs.c:5788 +#: utils/adt/arrayfuncs.c:5746 utils/adt/arrayfuncs.c:5772 #, c-format msgid "dimension values cannot be null" msgstr "i valori di dimensione non possono essere nulli" -#: utils/adt/arrayfuncs.c:5794 +#: utils/adt/arrayfuncs.c:5778 #, c-format msgid "Low bound array has different size than dimensions array." msgstr "L'array dei valori inferiori ha dimensione differente dal numero di dimensioni dell'array." -#: utils/adt/arrayfuncs.c:6040 +#: utils/adt/arrayfuncs.c:6024 #, c-format msgid "removing elements from multidimensional arrays is not supported" msgstr "la rimozione di elementi da array multidimensionali non è supportata" -#: utils/adt/arrayfuncs.c:6317 +#: utils/adt/arrayfuncs.c:6301 #, c-format msgid "thresholds must be one-dimensional array" msgstr "la soglia dev'essere un array monodimensionale" -#: utils/adt/arrayfuncs.c:6322 +#: utils/adt/arrayfuncs.c:6306 #, c-format msgid "thresholds array must not contain NULLs" msgstr "l'array delle soglie non può contenere NULL" @@ -17598,14 +17609,13 @@ msgstr "sintassi di input non valida per il tipo money: \"%s\"" #: utils/adt/cash.c:607 utils/adt/cash.c:657 utils/adt/cash.c:708 #: utils/adt/cash.c:757 utils/adt/cash.c:809 utils/adt/cash.c:859 -#: utils/adt/float.c:848 utils/adt/float.c:912 utils/adt/float.c:3268 -#: utils/adt/float.c:3331 utils/adt/geo_ops.c:4085 utils/adt/int.c:719 +#: utils/adt/float.c:855 utils/adt/float.c:919 utils/adt/float.c:3315 +#: utils/adt/float.c:3378 utils/adt/geo_ops.c:4093 utils/adt/int.c:719 #: utils/adt/int.c:861 utils/adt/int.c:969 utils/adt/int.c:1058 #: utils/adt/int.c:1097 utils/adt/int.c:1125 utils/adt/int8.c:597 #: utils/adt/int8.c:657 utils/adt/int8.c:897 utils/adt/int8.c:1005 -#: utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6800 -#: utils/adt/numeric.c:7089 utils/adt/numeric.c:8090 -#: utils/adt/timestamp.c:3446 +#: utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6818 +#: utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 utils/adt/timestamp.c:3499 #, c-format msgid "division by zero" msgstr "divisione per zero" @@ -17631,19 +17641,19 @@ msgstr "la precisione di TIME(%d)%s non può essere negativa" msgid "TIME(%d)%s precision reduced to maximum allowed, %d" msgstr "la precisione di TIME(%d)%s è stata ridotta al massimo consentito (%d)" -#: utils/adt/date.c:141 utils/adt/datetime.c:1277 utils/adt/datetime.c:2148 +#: utils/adt/date.c:141 utils/adt/datetime.c:1278 utils/adt/datetime.c:2191 #, c-format msgid "date/time value \"current\" is no longer supported" msgstr "il valore \"current\" per i tipi date/time non è più supportato" -#: utils/adt/date.c:167 utils/adt/date.c:175 utils/adt/formatting.c:3535 -#: utils/adt/formatting.c:3544 +#: utils/adt/date.c:167 utils/adt/date.c:175 utils/adt/formatting.c:3529 +#: utils/adt/formatting.c:3538 #, c-format msgid "date out of range: \"%s\"" msgstr "data fuori dall'intervallo consentito: \"%s\"" #: utils/adt/date.c:222 utils/adt/date.c:456 utils/adt/date.c:480 -#: utils/adt/xml.c:2029 +#: utils/adt/xml.c:2027 #, c-format msgid "date out of range" msgstr "data fuori dall'intervallo consentito" @@ -17671,32 +17681,32 @@ msgstr "data fuori dall'intervallo consentito per timestamp" #: utils/adt/date.c:1022 utils/adt/date.c:1068 utils/adt/date.c:1678 #: utils/adt/date.c:1714 utils/adt/date.c:1748 utils/adt/date.c:2592 -#: utils/adt/formatting.c:3410 utils/adt/formatting.c:3442 -#: utils/adt/formatting.c:3510 utils/adt/json.c:1534 utils/adt/json.c:1556 -#: utils/adt/jsonb.c:823 utils/adt/jsonb.c:847 utils/adt/nabstime.c:455 -#: utils/adt/nabstime.c:498 utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 -#: utils/adt/timestamp.c:224 utils/adt/timestamp.c:268 -#: utils/adt/timestamp.c:726 utils/adt/timestamp.c:735 -#: utils/adt/timestamp.c:820 utils/adt/timestamp.c:860 -#: utils/adt/timestamp.c:3021 utils/adt/timestamp.c:3042 -#: utils/adt/timestamp.c:3055 utils/adt/timestamp.c:3064 -#: utils/adt/timestamp.c:3072 utils/adt/timestamp.c:3127 -#: utils/adt/timestamp.c:3150 utils/adt/timestamp.c:3163 -#: utils/adt/timestamp.c:3174 utils/adt/timestamp.c:3182 -#: utils/adt/timestamp.c:3756 utils/adt/timestamp.c:3885 -#: utils/adt/timestamp.c:3926 utils/adt/timestamp.c:4014 -#: utils/adt/timestamp.c:4060 utils/adt/timestamp.c:4171 -#: utils/adt/timestamp.c:4578 utils/adt/timestamp.c:4694 -#: utils/adt/timestamp.c:4704 utils/adt/timestamp.c:4800 -#: utils/adt/timestamp.c:4919 utils/adt/timestamp.c:4929 -#: utils/adt/timestamp.c:5250 utils/adt/timestamp.c:5264 -#: utils/adt/timestamp.c:5269 utils/adt/timestamp.c:5283 -#: utils/adt/timestamp.c:5366 utils/adt/timestamp.c:5398 -#: utils/adt/timestamp.c:5405 utils/adt/timestamp.c:5431 -#: utils/adt/timestamp.c:5435 utils/adt/timestamp.c:5504 -#: utils/adt/timestamp.c:5508 utils/adt/timestamp.c:5522 -#: utils/adt/timestamp.c:5560 utils/adt/xml.c:2051 utils/adt/xml.c:2058 -#: utils/adt/xml.c:2078 utils/adt/xml.c:2085 +#: utils/adt/datetime.c:1759 utils/adt/formatting.c:3404 +#: utils/adt/formatting.c:3436 utils/adt/formatting.c:3504 +#: utils/adt/json.c:1534 utils/adt/json.c:1556 utils/adt/jsonb.c:823 +#: utils/adt/jsonb.c:847 utils/adt/nabstime.c:455 utils/adt/nabstime.c:498 +#: utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 utils/adt/timestamp.c:224 +#: utils/adt/timestamp.c:268 utils/adt/timestamp.c:726 +#: utils/adt/timestamp.c:735 utils/adt/timestamp.c:817 +#: utils/adt/timestamp.c:857 utils/adt/timestamp.c:3074 +#: utils/adt/timestamp.c:3095 utils/adt/timestamp.c:3108 +#: utils/adt/timestamp.c:3117 utils/adt/timestamp.c:3125 +#: utils/adt/timestamp.c:3180 utils/adt/timestamp.c:3203 +#: utils/adt/timestamp.c:3216 utils/adt/timestamp.c:3227 +#: utils/adt/timestamp.c:3235 utils/adt/timestamp.c:3809 +#: utils/adt/timestamp.c:3938 utils/adt/timestamp.c:3979 +#: utils/adt/timestamp.c:4067 utils/adt/timestamp.c:4113 +#: utils/adt/timestamp.c:4224 utils/adt/timestamp.c:4631 +#: utils/adt/timestamp.c:4747 utils/adt/timestamp.c:4757 +#: utils/adt/timestamp.c:4853 utils/adt/timestamp.c:4972 +#: utils/adt/timestamp.c:4982 utils/adt/timestamp.c:5234 +#: utils/adt/timestamp.c:5248 utils/adt/timestamp.c:5253 +#: utils/adt/timestamp.c:5267 utils/adt/timestamp.c:5316 +#: utils/adt/timestamp.c:5348 utils/adt/timestamp.c:5355 +#: utils/adt/timestamp.c:5381 utils/adt/timestamp.c:5385 +#: utils/adt/timestamp.c:5454 utils/adt/timestamp.c:5458 +#: utils/adt/timestamp.c:5472 utils/adt/timestamp.c:5510 utils/adt/xml.c:2049 +#: utils/adt/xml.c:2056 utils/adt/xml.c:2076 utils/adt/xml.c:2083 #, c-format msgid "timestamp out of range" msgstr "timestamp fuori dall'intervallo consentito" @@ -17737,57 +17747,52 @@ msgstr "la differenza di fuso orario è fuori dall'intervallo consentito" msgid "\"time with time zone\" units \"%s\" not recognized" msgstr "unità \"%s\" di \"time with time zone\" non è riconosciuta" -#: utils/adt/date.c:2830 utils/adt/datetime.c:994 utils/adt/datetime.c:1874 -#: utils/adt/datetime.c:4700 utils/adt/timestamp.c:532 -#: utils/adt/timestamp.c:559 utils/adt/timestamp.c:5275 -#: utils/adt/timestamp.c:5514 +#: utils/adt/date.c:2830 utils/adt/datetime.c:995 utils/adt/datetime.c:1917 +#: utils/adt/datetime.c:4743 utils/adt/timestamp.c:532 +#: utils/adt/timestamp.c:559 utils/adt/timestamp.c:5259 +#: utils/adt/timestamp.c:5464 #, c-format msgid "time zone \"%s\" not recognized" msgstr "fuso orario \"%s\" non riconosciuto" -#: utils/adt/date.c:2870 utils/adt/timestamp.c:5351 utils/adt/timestamp.c:5545 +#: utils/adt/date.c:2870 utils/adt/timestamp.c:5301 utils/adt/timestamp.c:5495 #, c-format msgid "interval time zone \"%s\" must not include months or days" msgstr "l'intervallo di fusi orari \"%s\" non può contenere mesi o giorni" -#: utils/adt/datetime.c:1749 -#, c-format -msgid "time zone abbreviation \"%s\" is not used in time zone \"%s\"" -msgstr "l'abbreviazione di fuso orario \"%s\" non è usata nel fuso orario \"%s\"" - -#: utils/adt/datetime.c:3835 utils/adt/datetime.c:3842 +#: utils/adt/datetime.c:3878 utils/adt/datetime.c:3885 #, c-format msgid "date/time field value out of range: \"%s\"" msgstr "valore del campo date/time fuori dall'intervallo consentito: \"%s\"" -#: utils/adt/datetime.c:3844 +#: utils/adt/datetime.c:3887 #, c-format msgid "Perhaps you need a different \"datestyle\" setting." msgstr "Forse è necessario impostare un \"datestyle\" diverso." -#: utils/adt/datetime.c:3849 +#: utils/adt/datetime.c:3892 #, c-format msgid "interval field value out of range: \"%s\"" msgstr "valore del campo interval fuori dall'intervallo consentito: \"%s\"" -#: utils/adt/datetime.c:3855 +#: utils/adt/datetime.c:3898 #, c-format msgid "time zone displacement out of range: \"%s\"" msgstr "la differenza di fuso orario è fuori dall'intervallo consentito: \"%s\"" #. translator: first %s is inet or cidr -#: utils/adt/datetime.c:3862 utils/adt/float.c:454 utils/adt/float.c:537 -#: utils/adt/float.c:563 utils/adt/geo_ops.c:156 utils/adt/geo_ops.c:166 +#: utils/adt/datetime.c:3905 utils/adt/float.c:461 utils/adt/float.c:544 +#: utils/adt/float.c:570 utils/adt/geo_ops.c:156 utils/adt/geo_ops.c:166 #: utils/adt/geo_ops.c:178 utils/adt/geo_ops.c:210 utils/adt/geo_ops.c:255 #: utils/adt/geo_ops.c:265 utils/adt/geo_ops.c:935 utils/adt/geo_ops.c:1321 -#: utils/adt/geo_ops.c:1356 utils/adt/geo_ops.c:1364 utils/adt/geo_ops.c:3422 -#: utils/adt/geo_ops.c:4555 utils/adt/geo_ops.c:4571 utils/adt/geo_ops.c:4578 +#: utils/adt/geo_ops.c:1356 utils/adt/geo_ops.c:1364 utils/adt/geo_ops.c:3430 +#: utils/adt/geo_ops.c:4563 utils/adt/geo_ops.c:4579 utils/adt/geo_ops.c:4586 #: utils/adt/network.c:58 #, c-format msgid "invalid input syntax for type %s: \"%s\"" msgstr "sintassi di input non valida per il tipo %s: \"%s\"" -#: utils/adt/datetime.c:4702 +#: utils/adt/datetime.c:4745 #, c-format msgid "This time zone name appears in the configuration file for time zone abbreviation \"%s\"." msgstr "Il nome del fuso orario figura nel file di configurazione delle abbreviazioni di fuso orario \"%s\"." @@ -17802,22 +17807,22 @@ msgstr "puntatore al Datum non valido" msgid "could not open tablespace directory \"%s\": %m" msgstr "apertura della directory del tablespace \"%s\" fallita: %m" -#: utils/adt/dbsize.c:757 utils/adt/dbsize.c:776 utils/adt/dbsize.c:828 +#: utils/adt/dbsize.c:757 utils/adt/dbsize.c:825 #, c-format msgid "invalid size: \"%s\"" msgstr "dimensione non valida: \"%s\"" -#: utils/adt/dbsize.c:829 +#: utils/adt/dbsize.c:826 #, c-format msgid "Invalid size unit: \"%s\"." msgstr "Unità di dimensione non valida: \"%s\"." -#: utils/adt/dbsize.c:830 +#: utils/adt/dbsize.c:827 #, c-format msgid "Valid units are \"bytes\", \"kB\", \"MB\", \"GB\", and \"TB\"." msgstr "Le unità valide sono \"bytes\", \"kB\", \"MB\", \"GB\" e \"TB\"." -#: utils/adt/domains.c:85 +#: utils/adt/domains.c:86 #, c-format msgid "type %s is not a domain" msgstr "il tipo %s non è un dominio" @@ -17895,78 +17900,78 @@ msgstr "il valore è fuori dall'intervallo consentito: overflow" msgid "value out of range: underflow" msgstr "il valore è fuori dall'intervallo consentito: underflow" -#: utils/adt/float.c:237 utils/adt/float.c:311 utils/adt/float.c:335 +#: utils/adt/float.c:244 utils/adt/float.c:318 utils/adt/float.c:342 #, c-format msgid "invalid input syntax for type real: \"%s\"" msgstr "la sintassi in input per il tipo real non è valida: \"%s\"" -#: utils/adt/float.c:305 +#: utils/adt/float.c:312 #, c-format msgid "\"%s\" is out of range for type real" msgstr "\"%s\" è fuori dall'intervallo consentito per il tipo real" -#: utils/adt/float.c:530 +#: utils/adt/float.c:537 #, c-format msgid "\"%s\" is out of range for type double precision" msgstr "\"%s\" è fuori dall'intervallo consentito per il tipo double precision" -#: utils/adt/float.c:1239 utils/adt/float.c:1297 utils/adt/int.c:349 +#: utils/adt/float.c:1246 utils/adt/float.c:1304 utils/adt/int.c:349 #: utils/adt/int.c:775 utils/adt/int.c:804 utils/adt/int.c:825 #: utils/adt/int.c:845 utils/adt/int.c:879 utils/adt/int.c:1174 -#: utils/adt/int8.c:1323 utils/adt/numeric.c:3004 utils/adt/numeric.c:3013 +#: utils/adt/int8.c:1323 utils/adt/numeric.c:3000 utils/adt/numeric.c:3009 #, c-format msgid "smallint out of range" msgstr "il valore è fuori dall'intervallo consentito per il tipo smallint" -#: utils/adt/float.c:1423 utils/adt/numeric.c:7522 +#: utils/adt/float.c:1430 utils/adt/numeric.c:7540 #, c-format msgid "cannot take square root of a negative number" msgstr "non è possibile estrarre la radice quadrata di un numero negativo" -#: utils/adt/float.c:1465 utils/adt/numeric.c:2807 +#: utils/adt/float.c:1472 utils/adt/numeric.c:2803 #, c-format msgid "zero raised to a negative power is undefined" msgstr "zero elevato a potenza negativa non è definito" -#: utils/adt/float.c:1469 utils/adt/numeric.c:2813 +#: utils/adt/float.c:1476 utils/adt/numeric.c:2809 #, c-format msgid "a negative number raised to a non-integer power yields a complex result" msgstr "un numero negativo elevato a potenza non intera è un valore di tipo complesso" -#: utils/adt/float.c:1535 utils/adt/float.c:1565 utils/adt/numeric.c:7787 +#: utils/adt/float.c:1542 utils/adt/float.c:1572 utils/adt/numeric.c:7806 #, c-format msgid "cannot take logarithm of zero" msgstr "non è possibile calcolare il logaritmo di zero" -#: utils/adt/float.c:1539 utils/adt/float.c:1569 utils/adt/numeric.c:7791 +#: utils/adt/float.c:1546 utils/adt/float.c:1576 utils/adt/numeric.c:7810 #, c-format msgid "cannot take logarithm of a negative number" msgstr "non è possibile calcolare il logaritmo di un numero negativo" -#: utils/adt/float.c:1599 utils/adt/float.c:1629 utils/adt/float.c:1721 -#: utils/adt/float.c:1747 utils/adt/float.c:1774 utils/adt/float.c:1800 -#: utils/adt/float.c:1922 utils/adt/float.c:1957 utils/adt/float.c:2110 -#: utils/adt/float.c:2163 utils/adt/float.c:2226 utils/adt/float.c:2280 +#: utils/adt/float.c:1606 utils/adt/float.c:1636 utils/adt/float.c:1728 +#: utils/adt/float.c:1754 utils/adt/float.c:1781 utils/adt/float.c:1807 +#: utils/adt/float.c:1954 utils/adt/float.c:1989 utils/adt/float.c:2153 +#: utils/adt/float.c:2207 utils/adt/float.c:2271 utils/adt/float.c:2326 #, c-format msgid "input is out of range" msgstr "il valore di input è fuori dall'intervallo consentito" -#: utils/adt/float.c:3485 utils/adt/numeric.c:1447 +#: utils/adt/float.c:3532 utils/adt/numeric.c:1443 #, c-format msgid "count must be greater than zero" msgstr "il valore count dev'essere maggiore di zero" -#: utils/adt/float.c:3490 utils/adt/numeric.c:1454 +#: utils/adt/float.c:3537 utils/adt/numeric.c:1450 #, c-format msgid "operand, lower bound, and upper bound cannot be NaN" msgstr "l'operando e i valori minimo e massimo non possono essere NaN" -#: utils/adt/float.c:3496 +#: utils/adt/float.c:3543 #, c-format msgid "lower and upper bounds must be finite" msgstr "i valori minimo e massimo devono essere finiti" -#: utils/adt/float.c:3534 utils/adt/numeric.c:1467 +#: utils/adt/float.c:3581 utils/adt/numeric.c:1463 #, c-format msgid "lower bound cannot equal upper bound" msgstr "il valore minimo non può essere uguale a quello massimo" @@ -17981,203 +17986,203 @@ msgstr "la specifica di formato per un intervallo non è valida" msgid "Intervals are not tied to specific calendar dates." msgstr "Gli intervalli non sono legati a specifiche date di calendario." -#: utils/adt/formatting.c:1059 +#: utils/adt/formatting.c:1058 #, c-format msgid "\"EEEE\" must be the last pattern used" msgstr "\"EEEE\" dev'essere l'ultimo pattern usato" -#: utils/adt/formatting.c:1067 +#: utils/adt/formatting.c:1066 #, c-format msgid "\"9\" must be ahead of \"PR\"" msgstr "\"9\" dev'essere più avanti di \"PR\"" -#: utils/adt/formatting.c:1083 +#: utils/adt/formatting.c:1082 #, c-format msgid "\"0\" must be ahead of \"PR\"" msgstr "\"0\" dev'essere più avanti di \"PR\"" -#: utils/adt/formatting.c:1110 +#: utils/adt/formatting.c:1109 #, c-format msgid "multiple decimal points" msgstr "troppi punti decimali" -#: utils/adt/formatting.c:1114 utils/adt/formatting.c:1197 +#: utils/adt/formatting.c:1113 utils/adt/formatting.c:1196 #, c-format msgid "cannot use \"V\" and decimal point together" msgstr "non è possibile usare \"V\" ed un punto decimale insieme" -#: utils/adt/formatting.c:1126 +#: utils/adt/formatting.c:1125 #, c-format msgid "cannot use \"S\" twice" msgstr "non è possibile usare \"S\" due volte" -#: utils/adt/formatting.c:1130 +#: utils/adt/formatting.c:1129 #, c-format msgid "cannot use \"S\" and \"PL\"/\"MI\"/\"SG\"/\"PR\" together" msgstr "non è possibile usare sia \"S\" che \"PL\"/\"MI\"/\"SG\"/\"PR\" insieme" -#: utils/adt/formatting.c:1150 +#: utils/adt/formatting.c:1149 #, c-format msgid "cannot use \"S\" and \"MI\" together" msgstr "non è possibile usare sia \"S\" che \"MI\" insieme" -#: utils/adt/formatting.c:1160 +#: utils/adt/formatting.c:1159 #, c-format msgid "cannot use \"S\" and \"PL\" together" msgstr "non è possibile usare sia \"S\" che \"PL\" insieme" -#: utils/adt/formatting.c:1170 +#: utils/adt/formatting.c:1169 #, c-format msgid "cannot use \"S\" and \"SG\" together" msgstr "non è possibile usare sia \"S\" che \"SG\" insieme" -#: utils/adt/formatting.c:1179 +#: utils/adt/formatting.c:1178 #, c-format msgid "cannot use \"PR\" and \"S\"/\"PL\"/\"MI\"/\"SG\" together" msgstr "non è possibile usare sia \"PR\" che \"S\"/\"PL\"/\"MI\"/\"SG\" insieme" -#: utils/adt/formatting.c:1205 +#: utils/adt/formatting.c:1204 #, c-format msgid "cannot use \"EEEE\" twice" msgstr "non è possibile usare \"EEEE\" due volte" -#: utils/adt/formatting.c:1211 +#: utils/adt/formatting.c:1210 #, c-format msgid "\"EEEE\" is incompatible with other formats" msgstr "\"EEEE\" non è compatibile con altri formati" -#: utils/adt/formatting.c:1212 +#: utils/adt/formatting.c:1211 #, c-format msgid "\"EEEE\" may only be used together with digit and decimal point patterns." msgstr "\"EEEE\" può essere usato soltanto insieme a pattern di cifre e punti decimali." -#: utils/adt/formatting.c:1412 +#: utils/adt/formatting.c:1411 #, c-format msgid "\"%s\" is not a number" msgstr "\"%s\" non è un numero" -#: utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 +#: utils/adt/formatting.c:1512 utils/adt/formatting.c:1564 #, c-format msgid "could not determine which collation to use for lower() function" msgstr "non è stato possibile determinare quale ordinamento usare per la funzione lower()" -#: utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 +#: utils/adt/formatting.c:1632 utils/adt/formatting.c:1684 #, c-format msgid "could not determine which collation to use for upper() function" msgstr "non è stato possibile determinare quale ordinamento usare per la funzione upper()" -#: utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 +#: utils/adt/formatting.c:1753 utils/adt/formatting.c:1817 #, c-format msgid "could not determine which collation to use for initcap() function" msgstr "non è stato possibile determinare quale ordinamento usare per la funzione initcap()" -#: utils/adt/formatting.c:2122 +#: utils/adt/formatting.c:2114 #, c-format msgid "invalid combination of date conventions" msgstr "la combinazione di convenzioni di date non è valida" -#: utils/adt/formatting.c:2123 +#: utils/adt/formatting.c:2115 #, c-format msgid "Do not mix Gregorian and ISO week date conventions in a formatting template." msgstr "Non è possibile usare la convenzione gregoriana e ISO per settimane in un modello di formattazione." -#: utils/adt/formatting.c:2140 +#: utils/adt/formatting.c:2132 #, c-format msgid "conflicting values for \"%s\" field in formatting string" msgstr "sono presenti valori contraddittori per il campo \"%s\" nella stringa di formattazione" -#: utils/adt/formatting.c:2142 +#: utils/adt/formatting.c:2134 #, c-format msgid "This value contradicts a previous setting for the same field type." msgstr "Questo valore contraddice una impostazione precedente per lo stesso tipo di campo" -#: utils/adt/formatting.c:2203 +#: utils/adt/formatting.c:2195 #, c-format msgid "source string too short for \"%s\" formatting field" msgstr "la stringa di origine è troppo corta per il campo di formattazione \"%s\"" -#: utils/adt/formatting.c:2205 +#: utils/adt/formatting.c:2197 #, c-format msgid "Field requires %d characters, but only %d remain." msgstr "Il campo necessita di %d caratteri ma ne restano solo %d." -#: utils/adt/formatting.c:2208 utils/adt/formatting.c:2222 +#: utils/adt/formatting.c:2200 utils/adt/formatting.c:2214 #, c-format msgid "If your source string is not fixed-width, try using the \"FM\" modifier." msgstr "Se la stringa di partenza non ha lunghezza fissa, prova ad usare il modificatore \"FM\"." -#: utils/adt/formatting.c:2218 utils/adt/formatting.c:2231 -#: utils/adt/formatting.c:2361 +#: utils/adt/formatting.c:2210 utils/adt/formatting.c:2223 +#: utils/adt/formatting.c:2353 #, c-format msgid "invalid value \"%s\" for \"%s\"" msgstr "valore \"%s\" per \"%s\" non valido" -#: utils/adt/formatting.c:2220 +#: utils/adt/formatting.c:2212 #, c-format msgid "Field requires %d characters, but only %d could be parsed." msgstr "Il campo necessita di %d caratteri, ma è stato possibile analizzarne solo %d." -#: utils/adt/formatting.c:2233 +#: utils/adt/formatting.c:2225 #, c-format msgid "Value must be an integer." msgstr "Il valore deve essere un integer." -#: utils/adt/formatting.c:2238 +#: utils/adt/formatting.c:2230 #, c-format msgid "value for \"%s\" in source string is out of range" msgstr "il valore \"%s\" nella stringa di origine è fuori dall'intervallo consentito" -#: utils/adt/formatting.c:2240 +#: utils/adt/formatting.c:2232 #, c-format msgid "Value must be in the range %d to %d." msgstr "Il valore deve essere compreso fra %d e %d." -#: utils/adt/formatting.c:2363 +#: utils/adt/formatting.c:2355 #, c-format msgid "The given value did not match any of the allowed values for this field." msgstr "Il valore fornito non corrisponde a nessuno di quelli consentiti per questo campo." -#: utils/adt/formatting.c:2558 utils/adt/formatting.c:2578 -#: utils/adt/formatting.c:2598 utils/adt/formatting.c:2618 -#: utils/adt/formatting.c:2637 utils/adt/formatting.c:2656 -#: utils/adt/formatting.c:2680 utils/adt/formatting.c:2698 -#: utils/adt/formatting.c:2716 utils/adt/formatting.c:2734 -#: utils/adt/formatting.c:2751 utils/adt/formatting.c:2768 +#: utils/adt/formatting.c:2550 utils/adt/formatting.c:2570 +#: utils/adt/formatting.c:2590 utils/adt/formatting.c:2610 +#: utils/adt/formatting.c:2629 utils/adt/formatting.c:2648 +#: utils/adt/formatting.c:2672 utils/adt/formatting.c:2690 +#: utils/adt/formatting.c:2708 utils/adt/formatting.c:2726 +#: utils/adt/formatting.c:2743 utils/adt/formatting.c:2760 #, c-format msgid "localized string format value too long" msgstr "valore del formato della stringa localizzata troppo lungo" -#: utils/adt/formatting.c:3055 +#: utils/adt/formatting.c:3047 #, c-format msgid "\"TZ\"/\"tz\"/\"OF\" format patterns are not supported in to_date" msgstr "i pattern di formato \"TZ\"/\"tz\"/\"OF\" non sono supportati in to_date" -#: utils/adt/formatting.c:3163 +#: utils/adt/formatting.c:3156 #, c-format msgid "invalid input string for \"Y,YYY\"" msgstr "stringa di input non valida per \"Y,YYY\"" -#: utils/adt/formatting.c:3674 +#: utils/adt/formatting.c:3668 #, c-format msgid "hour \"%d\" is invalid for the 12-hour clock" msgstr "l'ora \"%d\" non è valida su un orologio a 12 ore" -#: utils/adt/formatting.c:3676 +#: utils/adt/formatting.c:3670 #, c-format msgid "Use the 24-hour clock, or give an hour between 1 and 12." msgstr "Usa l'orologio a 24 ore o fornisci un'ora compresa fra 1 e 12." -#: utils/adt/formatting.c:3771 +#: utils/adt/formatting.c:3765 #, c-format msgid "cannot calculate day of year without year information" msgstr "non è possibile calcolare il giorno dell'anno senza informazioni sull'anno" -#: utils/adt/formatting.c:4620 +#: utils/adt/formatting.c:4614 #, c-format msgid "\"EEEE\" not supported for input" msgstr "l'uso di \"EEEE\" non è supportato per l'input" -#: utils/adt/formatting.c:4632 +#: utils/adt/formatting.c:4626 #, c-format msgid "\"RN\" not supported for input" msgstr "l'uso di \"RN\" non è supportato per l'input" @@ -18234,8 +18239,8 @@ msgstr "specificazione di linea non valida: A e B non possono essere entrambi ze msgid "invalid line specification: must be two distinct points" msgstr "specificazione di linea non valida: devono essere due punti distinti" -#: utils/adt/geo_ops.c:1342 utils/adt/geo_ops.c:3432 utils/adt/geo_ops.c:4245 -#: utils/adt/geo_ops.c:5173 +#: utils/adt/geo_ops.c:1342 utils/adt/geo_ops.c:3440 utils/adt/geo_ops.c:4253 +#: utils/adt/geo_ops.c:5181 #, c-format msgid "too many points requested" msgstr "il numero di punti richiesti è eccessivo" @@ -18250,57 +18255,57 @@ msgstr "il numero di punti nel valore del \"path\" esterno non è valido" msgid "function \"dist_lb\" not implemented" msgstr "la funzione \"dist_lb\" non è implementata" -#: utils/adt/geo_ops.c:3007 +#: utils/adt/geo_ops.c:3015 #, c-format msgid "function \"close_sl\" not implemented" msgstr "la funzione \"close_sl\" non è implementata" -#: utils/adt/geo_ops.c:3109 +#: utils/adt/geo_ops.c:3117 #, c-format msgid "function \"close_lb\" not implemented" msgstr "la funzione \"close_lb\" non è implementata" -#: utils/adt/geo_ops.c:3398 +#: utils/adt/geo_ops.c:3406 #, c-format msgid "cannot create bounding box for empty polygon" msgstr "non è possibile creare un bounding box per il poligono vuoto" -#: utils/adt/geo_ops.c:3479 +#: utils/adt/geo_ops.c:3487 #, c-format msgid "invalid number of points in external \"polygon\" value" msgstr "il numero di punti nel valore \"polygon\" esterno non è valido" -#: utils/adt/geo_ops.c:4004 +#: utils/adt/geo_ops.c:4012 #, c-format msgid "function \"poly_distance\" not implemented" msgstr "la funzione \"poly_distance\" non è implementata" -#: utils/adt/geo_ops.c:4357 +#: utils/adt/geo_ops.c:4365 #, c-format msgid "function \"path_center\" not implemented" msgstr "la funzione \"path_center\" non è implementata" -#: utils/adt/geo_ops.c:4374 +#: utils/adt/geo_ops.c:4382 #, c-format msgid "open path cannot be converted to polygon" msgstr "un path aperto non può essere convertito in un poligono" -#: utils/adt/geo_ops.c:4623 +#: utils/adt/geo_ops.c:4631 #, c-format msgid "invalid radius in external \"circle\" value" msgstr "il raggio nel valore esterno di \"circle\" non è valido" -#: utils/adt/geo_ops.c:5159 +#: utils/adt/geo_ops.c:5167 #, c-format msgid "cannot convert circle with radius zero to polygon" msgstr "non è possibile convertire un cerchio con raggio nullo in un poligono" -#: utils/adt/geo_ops.c:5164 +#: utils/adt/geo_ops.c:5172 #, c-format msgid "must request at least 2 points" msgstr "devono essere richiesti almeno 2 punti" -#: utils/adt/geo_ops.c:5208 +#: utils/adt/geo_ops.c:5216 #, c-format msgid "cannot convert empty polygon to circle" msgstr "non è possibile convertire un poligono vuoto in un cerchio" @@ -18320,8 +18325,8 @@ msgstr "dati int2vector non validi" msgid "oidvector has too many elements" msgstr "ci sono troppi elementi nell'oidvector" -#: utils/adt/int.c:1362 utils/adt/int8.c:1460 utils/adt/numeric.c:1355 -#: utils/adt/timestamp.c:5611 utils/adt/timestamp.c:5692 +#: utils/adt/int.c:1362 utils/adt/int8.c:1460 utils/adt/numeric.c:1351 +#: utils/adt/timestamp.c:5561 utils/adt/timestamp.c:5642 #, c-format msgid "step size cannot equal zero" msgstr "il valore del passo non può essere uguale a zero" @@ -18345,8 +18350,8 @@ msgstr "il valore \"%s\" è fuori dall'intervallo consentito per il tipo bigint" #: utils/adt/int8.c:964 utils/adt/int8.c:991 utils/adt/int8.c:1031 #: utils/adt/int8.c:1052 utils/adt/int8.c:1079 utils/adt/int8.c:1112 #: utils/adt/int8.c:1140 utils/adt/int8.c:1161 utils/adt/int8.c:1188 -#: utils/adt/int8.c:1361 utils/adt/int8.c:1400 utils/adt/numeric.c:2959 -#: utils/adt/varbit.c:1645 +#: utils/adt/int8.c:1361 utils/adt/int8.c:1400 utils/adt/numeric.c:2955 +#: utils/adt/varbit.c:1655 #, c-format msgid "bigint out of range" msgstr "bigint fuori dall'intervallo consentito" @@ -18576,14 +18581,14 @@ msgid "total size of jsonb object elements exceeds the maximum of %u bytes" msgstr "la dimensione totale degli elementi dell'oggetto jsonb supera il massimo di %u byte" #: utils/adt/jsonfuncs.c:305 utils/adt/jsonfuncs.c:470 -#: utils/adt/jsonfuncs.c:2065 utils/adt/jsonfuncs.c:2506 -#: utils/adt/jsonfuncs.c:3012 +#: utils/adt/jsonfuncs.c:2057 utils/adt/jsonfuncs.c:2498 +#: utils/adt/jsonfuncs.c:3004 #, c-format msgid "cannot call %s on a scalar" msgstr "non è possibile eseguire %s su uno scalare" #: utils/adt/jsonfuncs.c:310 utils/adt/jsonfuncs.c:457 -#: utils/adt/jsonfuncs.c:2495 +#: utils/adt/jsonfuncs.c:2487 #, c-format msgid "cannot call %s on an array" msgstr "non è possibile eseguire %s su un array" @@ -18603,98 +18608,98 @@ msgstr "non è possibile ottenere la lunghezza di un oggetto che non è un array msgid "cannot call %s on a non-object" msgstr "non è possibile eseguire %s su un argomento che non è un oggetto" -#: utils/adt/jsonfuncs.c:1491 utils/adt/jsonfuncs.c:2178 -#: utils/adt/jsonfuncs.c:2715 +#: utils/adt/jsonfuncs.c:1491 utils/adt/jsonfuncs.c:2170 +#: utils/adt/jsonfuncs.c:2707 #, c-format msgid "function returning record called in context that cannot accept type record" msgstr "funzione che restituisce record eseguita in un contesto che non può accettare il tipo record" -#: utils/adt/jsonfuncs.c:1734 +#: utils/adt/jsonfuncs.c:1730 #, c-format msgid "cannot deconstruct an array as an object" msgstr "non è possibile decostruire un array come un oggetto" -#: utils/adt/jsonfuncs.c:1746 +#: utils/adt/jsonfuncs.c:1742 #, c-format msgid "cannot deconstruct a scalar" msgstr "non è possibile decostruire uno scalare" -#: utils/adt/jsonfuncs.c:1792 +#: utils/adt/jsonfuncs.c:1788 #, c-format msgid "cannot extract elements from a scalar" msgstr "non è possibile estrarre elementi da uno scalare" -#: utils/adt/jsonfuncs.c:1796 +#: utils/adt/jsonfuncs.c:1792 #, c-format msgid "cannot extract elements from an object" msgstr "non è possibile estrarre elementi da un oggetto" -#: utils/adt/jsonfuncs.c:2052 utils/adt/jsonfuncs.c:2811 +#: utils/adt/jsonfuncs.c:2044 utils/adt/jsonfuncs.c:2803 #, c-format msgid "cannot call %s on a non-array" msgstr "non è possibile eseguire %s su un argomento che non è un array" -#: utils/adt/jsonfuncs.c:2139 utils/adt/jsonfuncs.c:2691 +#: utils/adt/jsonfuncs.c:2131 utils/adt/jsonfuncs.c:2683 #, c-format msgid "first argument of %s must be a row type" msgstr "il primo elemento di %s deve essere di tipo riga" -#: utils/adt/jsonfuncs.c:2180 +#: utils/adt/jsonfuncs.c:2172 #, c-format msgid "Try calling the function in the FROM clause using a column definition list." msgstr "Prova ad eseguire la funzione nella clausola FROM usando una lista di definizioni di colonne." -#: utils/adt/jsonfuncs.c:2827 utils/adt/jsonfuncs.c:2994 +#: utils/adt/jsonfuncs.c:2819 utils/adt/jsonfuncs.c:2986 #, c-format msgid "argument of %s must be an array of objects" msgstr "l'argomento di %s deve essere un array di oggetti" -#: utils/adt/jsonfuncs.c:2851 +#: utils/adt/jsonfuncs.c:2843 #, c-format msgid "cannot call %s on an object" msgstr "non è possibile eseguire %s su un oggetto" -#: utils/adt/jsonfuncs.c:3418 utils/adt/jsonfuncs.c:3471 +#: utils/adt/jsonfuncs.c:3410 utils/adt/jsonfuncs.c:3463 #, c-format msgid "cannot delete from scalar" msgstr "non è possibile eliminare da uno scalare" -#: utils/adt/jsonfuncs.c:3476 +#: utils/adt/jsonfuncs.c:3468 #, c-format msgid "cannot delete from object using integer index" msgstr "non è possibile eliminare da un oggetto usando numeri interi come indici" -#: utils/adt/jsonfuncs.c:3542 utils/adt/jsonfuncs.c:3634 +#: utils/adt/jsonfuncs.c:3534 utils/adt/jsonfuncs.c:3626 #, c-format msgid "cannot set path in scalar" msgstr "non è possibile impostare un percorso in uno scalare" -#: utils/adt/jsonfuncs.c:3587 +#: utils/adt/jsonfuncs.c:3579 #, c-format msgid "cannot delete path in scalar" msgstr "non è possibile eliminare un percorso in uno scalare" -#: utils/adt/jsonfuncs.c:3757 +#: utils/adt/jsonfuncs.c:3749 #, c-format msgid "invalid concatenation of jsonb objects" msgstr "concatenazione invalida di oggetti jsonb" -#: utils/adt/jsonfuncs.c:3791 +#: utils/adt/jsonfuncs.c:3783 #, c-format msgid "path element at position %d is null" msgstr "l'elemento di percorso in posizione %d è nullo" -#: utils/adt/jsonfuncs.c:3877 +#: utils/adt/jsonfuncs.c:3869 #, c-format msgid "cannot replace existing key" msgstr "non è possibile sostituire una chiave esistente" -#: utils/adt/jsonfuncs.c:3878 +#: utils/adt/jsonfuncs.c:3870 #, c-format msgid "Try using the function jsonb_set to replace key value." msgstr "Prova ad utilizzare la funzione jsonb_set per rimpiazzare il valore della chiave." -#: utils/adt/jsonfuncs.c:3960 +#: utils/adt/jsonfuncs.c:3952 #, c-format msgid "path element at position %d is not an integer: \"%s\"" msgstr "l'elemento di percorso in posizione %d non è un intero: \"%s\"" @@ -18704,7 +18709,7 @@ msgstr "l'elemento di percorso in posizione %d non è un intero: \"%s\"" msgid "levenshtein argument exceeds maximum length of %d characters" msgstr "L'argomento levenshtein supera la lunghezza massima di %d caratteri" -#: utils/adt/like.c:212 utils/adt/selfuncs.c:5329 +#: utils/adt/like.c:212 utils/adt/selfuncs.c:5333 #, c-format msgid "could not determine which collation to use for ILIKE" msgstr "non è stato possibile determinare quale ordinamento usare per ILIKE" @@ -18818,13 +18823,13 @@ msgstr "L'identificativo non può essere vuoto." #: utils/adt/misc.c:852 #, c-format -msgid "No valid identifier before \".\" symbol." -msgstr "L'identificativo prima del simbolo \".\" non è valido." +msgid "No valid identifier before \".\"." +msgstr "L'identificativo prima del \".\" non è valido." #: utils/adt/misc.c:858 #, c-format -msgid "No valid identifier after \".\" symbol." -msgstr "L'identificativo dopo il simbolo \".\" non è valido." +msgid "No valid identifier after \".\"." +msgstr "L'identificativo dopo il \".\" non è valido." #: utils/adt/nabstime.c:136 #, c-format @@ -18925,94 +18930,90 @@ msgstr "il risultato è fuori dall'intervallo consentito" msgid "cannot subtract inet values of different sizes" msgstr "non è possibile sottrarre valori di tipo inet di dimensione diversa" -#: utils/adt/numeric.c:542 utils/adt/numeric.c:569 utils/adt/numeric.c:5394 -#: utils/adt/numeric.c:5417 utils/adt/numeric.c:5441 utils/adt/numeric.c:5448 +#: utils/adt/numeric.c:542 utils/adt/numeric.c:569 utils/adt/numeric.c:5405 +#: utils/adt/numeric.c:5428 utils/adt/numeric.c:5452 #, c-format msgid "invalid input syntax for type numeric: \"%s\"" msgstr "la sintassi di input non è valida per il tipo numeric: \"%s\"" -#: utils/adt/numeric.c:759 -#, c-format -msgid "invalid length in external \"numeric\" value" -msgstr "la lunghezza nel valore \"numeric\" esterno non è valida" - -#: utils/adt/numeric.c:772 +#: utils/adt/numeric.c:768 #, c-format msgid "invalid sign in external \"numeric\" value" msgstr "il segno nel valore \"numeric\" esterno non è valido" -#: utils/adt/numeric.c:778 +#: utils/adt/numeric.c:774 #, c-format msgid "invalid scale in external \"numeric\" value" msgstr "la scala nel valore \"numeric\" esterno non è valida" -#: utils/adt/numeric.c:787 +#: utils/adt/numeric.c:783 #, c-format msgid "invalid digit in external \"numeric\" value" msgstr "una delle cifre nel valore \"numeric\" esterno non è valida" -#: utils/adt/numeric.c:978 utils/adt/numeric.c:992 +#: utils/adt/numeric.c:974 utils/adt/numeric.c:988 #, c-format msgid "NUMERIC precision %d must be between 1 and %d" msgstr "la precisione di NUMERIC (%d) deve essere compresa fra 1 e %d" -#: utils/adt/numeric.c:983 +#: utils/adt/numeric.c:979 #, c-format msgid "NUMERIC scale %d must be between 0 and precision %d" msgstr "il numero di cifre decimali di NUMERIC (%d) deve essere compreso fra 0 e la precisione %d" -#: utils/adt/numeric.c:1001 +#: utils/adt/numeric.c:997 #, c-format msgid "invalid NUMERIC type modifier" msgstr "modificatore del tipo NUMERIC non valido" -#: utils/adt/numeric.c:1333 +#: utils/adt/numeric.c:1329 #, c-format msgid "start value cannot be NaN" msgstr "il valore d'inizio non può essere NaN" -#: utils/adt/numeric.c:1338 +#: utils/adt/numeric.c:1334 #, c-format msgid "stop value cannot be NaN" msgstr "il valore di fine non può essere NaN" -#: utils/adt/numeric.c:1348 +#: utils/adt/numeric.c:1344 #, c-format msgid "step size cannot be NaN" msgstr "la dimensione dell'intervallo non può essere NaN" -#: utils/adt/numeric.c:2543 utils/adt/numeric.c:5894 utils/adt/numeric.c:7597 -#: utils/adt/numeric.c:8126 utils/adt/numeric.c:8199 +#: utils/adt/numeric.c:2539 utils/adt/numeric.c:5467 utils/adt/numeric.c:5912 +#: utils/adt/numeric.c:7616 utils/adt/numeric.c:8041 utils/adt/numeric.c:8156 +#: utils/adt/numeric.c:8229 #, c-format msgid "value overflows numeric format" msgstr "il valore causa un overflow nel formato numeric" -#: utils/adt/numeric.c:2885 +#: utils/adt/numeric.c:2881 #, c-format msgid "cannot convert NaN to integer" msgstr "non è possibile convertire NaN in un integer" -#: utils/adt/numeric.c:2951 +#: utils/adt/numeric.c:2947 #, c-format msgid "cannot convert NaN to bigint" msgstr "non è possibile convertire NaN in un bigint" -#: utils/adt/numeric.c:2996 +#: utils/adt/numeric.c:2992 #, c-format msgid "cannot convert NaN to smallint" msgstr "non è possibile convertire NaN in uno smallint" -#: utils/adt/numeric.c:5964 +#: utils/adt/numeric.c:5982 #, c-format msgid "numeric field overflow" msgstr "il campo numeric causa un overflow" -#: utils/adt/numeric.c:5965 +#: utils/adt/numeric.c:5983 #, c-format msgid "A field with precision %d, scale %d must round to an absolute value less than %s%d." msgstr "Un campo con precisione %d e %d cifre decimali deve arrotondarsi ad un valore assoluto inferiore a %s%d." -#: utils/adt/numeric.c:6236 utils/adt/numeric.c:6262 +#: utils/adt/numeric.c:6254 utils/adt/numeric.c:6280 #, c-format msgid "invalid input syntax for type double precision: \"%s\"" msgstr "la sintassi in input per il tipo double precision non è valida: \"%s\"" @@ -19073,37 +19074,37 @@ msgstr "non sono consentiti caratteri nulli" msgid "percentile value %g is not between 0 and 1" msgstr "il valore percentile %g non è tra 0 e 1" -#: utils/adt/pg_locale.c:917 +#: utils/adt/pg_locale.c:1029 #, c-format msgid "Apply system library package updates." msgstr "Applica gli aggiornamenti ai pacchetti di sistema." -#: utils/adt/pg_locale.c:1122 +#: utils/adt/pg_locale.c:1234 #, c-format msgid "could not create locale \"%s\": %m" msgstr "creazione del locale \"%s\" fallita: %m" -#: utils/adt/pg_locale.c:1125 +#: utils/adt/pg_locale.c:1237 #, c-format msgid "The operating system could not find any locale data for the locale name \"%s\"." msgstr "Il sistema operativo non ha trovato dati di locale per il locale di nome \"%s\"." -#: utils/adt/pg_locale.c:1212 +#: utils/adt/pg_locale.c:1324 #, c-format msgid "collations with different collate and ctype values are not supported on this platform" msgstr "le collazioni con tipi diversi di ordinamento e ctype non sono supportati su questa piattaforma" -#: utils/adt/pg_locale.c:1227 +#: utils/adt/pg_locale.c:1339 #, c-format msgid "nondefault collations are not supported on this platform" msgstr "le collazioni non predefinite non sono supportate su questa piattaforma" -#: utils/adt/pg_locale.c:1398 +#: utils/adt/pg_locale.c:1510 #, c-format msgid "invalid multibyte character for locale" msgstr "carattere multibyte non valido per il locale" -#: utils/adt/pg_locale.c:1399 +#: utils/adt/pg_locale.c:1511 #, c-format msgid "The server's LC_CTYPE locale is probably incompatible with the database encoding." msgstr "Il locale LC_CTYPE del server probabilmente non è compatibile con la codifica del database." @@ -19118,7 +19119,7 @@ msgstr "sintassi di input non valida per il tipo pg_lsn: \"%s\"" msgid "function can only be called when server is in binary upgrade mode" msgstr "la funzione può essere richiamata solo quando il server è in modalità di aggiornamento binario" -#: utils/adt/pgstatfuncs.c:569 +#: utils/adt/pgstatfuncs.c:571 #, c-format msgid "invalid command name: \"%s\"" msgstr "nome di comando non valido: \"%s\"" @@ -19359,18 +19360,18 @@ msgstr "più di una funzione si chiama \"%s\"" msgid "more than one operator named %s" msgstr "più di un operatore si chiama %s" -#: utils/adt/regproc.c:774 utils/adt/regproc.c:815 gram.y:7292 +#: utils/adt/regproc.c:774 utils/adt/regproc.c:815 gram.y:7302 #, c-format msgid "missing argument" msgstr "argomento mancante" -#: utils/adt/regproc.c:775 utils/adt/regproc.c:816 gram.y:7293 +#: utils/adt/regproc.c:775 utils/adt/regproc.c:816 gram.y:7303 #, c-format msgid "Use NONE to denote the missing argument of a unary operator." msgstr "Usa NONE per indicare l'argomento mancante in un operatore unario." #: utils/adt/regproc.c:779 utils/adt/regproc.c:820 utils/adt/regproc.c:2006 -#: utils/adt/ruleutils.c:8173 utils/adt/ruleutils.c:8298 +#: utils/adt/ruleutils.c:8367 utils/adt/ruleutils.c:8536 #, c-format msgid "too many arguments" msgstr "troppi argomenti" @@ -19407,84 +19408,84 @@ msgstr "era atteso il nome di un tipo" msgid "improper type name" msgstr "il nome del tipo non è corretto" -#: utils/adt/ri_triggers.c:316 utils/adt/ri_triggers.c:373 -#: utils/adt/ri_triggers.c:792 utils/adt/ri_triggers.c:1015 -#: utils/adt/ri_triggers.c:1171 utils/adt/ri_triggers.c:1352 -#: utils/adt/ri_triggers.c:1517 utils/adt/ri_triggers.c:1693 -#: utils/adt/ri_triggers.c:1873 utils/adt/ri_triggers.c:2064 -#: utils/adt/ri_triggers.c:2122 utils/adt/ri_triggers.c:2227 -#: utils/adt/ri_triggers.c:2404 gram.y:3345 +#: utils/adt/ri_triggers.c:314 utils/adt/ri_triggers.c:371 +#: utils/adt/ri_triggers.c:790 utils/adt/ri_triggers.c:1013 +#: utils/adt/ri_triggers.c:1169 utils/adt/ri_triggers.c:1350 +#: utils/adt/ri_triggers.c:1515 utils/adt/ri_triggers.c:1691 +#: utils/adt/ri_triggers.c:1871 utils/adt/ri_triggers.c:2062 +#: utils/adt/ri_triggers.c:2120 utils/adt/ri_triggers.c:2225 +#: utils/adt/ri_triggers.c:2402 gram.y:3343 #, c-format msgid "MATCH PARTIAL not yet implemented" msgstr "il MATCH PARTIAL non è stato ancora implementato" -#: utils/adt/ri_triggers.c:345 utils/adt/ri_triggers.c:2492 -#: utils/adt/ri_triggers.c:3317 +#: utils/adt/ri_triggers.c:343 utils/adt/ri_triggers.c:2490 +#: utils/adt/ri_triggers.c:3315 #, c-format msgid "insert or update on table \"%s\" violates foreign key constraint \"%s\"" msgstr "la INSERT o l'UPDATE sulla tabella \"%s\" viola il vincolo di chiave esterna \"%s\"" -#: utils/adt/ri_triggers.c:348 utils/adt/ri_triggers.c:2495 +#: utils/adt/ri_triggers.c:346 utils/adt/ri_triggers.c:2493 #, c-format msgid "MATCH FULL does not allow mixing of null and nonnull key values." msgstr "MATCH FULL non consente l'uso di valori chiave nulli e non nulli insieme." -#: utils/adt/ri_triggers.c:2734 +#: utils/adt/ri_triggers.c:2732 #, c-format msgid "function \"%s\" must be fired for INSERT" msgstr "la funzione \"%s\" deve essere eseguita per un INSERT" -#: utils/adt/ri_triggers.c:2740 +#: utils/adt/ri_triggers.c:2738 #, c-format msgid "function \"%s\" must be fired for UPDATE" msgstr "la funzione \"%s\" deve essere eseguita per un UPDATE" -#: utils/adt/ri_triggers.c:2746 +#: utils/adt/ri_triggers.c:2744 #, c-format msgid "function \"%s\" must be fired for DELETE" msgstr "la funzione \"%s\" deve essere eseguita per una DELETE" -#: utils/adt/ri_triggers.c:2769 +#: utils/adt/ri_triggers.c:2767 #, c-format msgid "no pg_constraint entry for trigger \"%s\" on table \"%s\"" msgstr "non ci sono elementi pg_constraint per il trigger \"%s\" sulla tabella \"%s\"" -#: utils/adt/ri_triggers.c:2771 +#: utils/adt/ri_triggers.c:2769 #, c-format msgid "Remove this referential integrity trigger and its mates, then do ALTER TABLE ADD CONSTRAINT." msgstr "Rimuovi questo trigger di integrità referenziale e relativi elementi collegati, poi esegui ALTER TABLE ADD CONSTRAINT." -#: utils/adt/ri_triggers.c:3227 +#: utils/adt/ri_triggers.c:3225 #, c-format msgid "referential integrity query on \"%s\" from constraint \"%s\" on \"%s\" gave unexpected result" msgstr "la query di integrità referenziale su \"%s\" dal vincolo \"%s\" su \"%s\" ha restituito un risultato inatteso" -#: utils/adt/ri_triggers.c:3231 +#: utils/adt/ri_triggers.c:3229 #, c-format msgid "This is most likely due to a rule having rewritten the query." msgstr "Ciò è probabilmente dovuto ad una RULE che ha riscritto la query." -#: utils/adt/ri_triggers.c:3321 +#: utils/adt/ri_triggers.c:3319 #, c-format msgid "Key (%s)=(%s) is not present in table \"%s\"." msgstr "La chiave (%s)=(%s) non è presente nella tabella \"%s\"." -#: utils/adt/ri_triggers.c:3324 +#: utils/adt/ri_triggers.c:3322 #, c-format msgid "Key is not present in table \"%s\"." msgstr "La chiave non è presente nella tabella \"%s\"." -#: utils/adt/ri_triggers.c:3330 +#: utils/adt/ri_triggers.c:3328 #, c-format msgid "update or delete on table \"%s\" violates foreign key constraint \"%s\" on table \"%s\"" msgstr "l'istruzione UPDATE o DELETE sulla tabella \"%s\" viola il vincolo di chiave esterna \"%s\" sulla tabella \"%s\"" -#: utils/adt/ri_triggers.c:3335 +#: utils/adt/ri_triggers.c:3333 #, c-format msgid "Key (%s)=(%s) is still referenced from table \"%s\"." msgstr "La chiave (%s)=(%s) è ancora referenziata dalla tabella \"%s\"." -#: utils/adt/ri_triggers.c:3338 +#: utils/adt/ri_triggers.c:3336 #, c-format msgid "Key is still referenced from table \"%s\"." msgstr "La chiave è ancora referenziata dalla tabella \"%s\"." @@ -19535,29 +19536,29 @@ msgstr "il tipo di dati non è corretto, %u invece di %u" msgid "improper binary format in record column %d" msgstr "il formato binario nella colonna %d del record non è corretto" -#: utils/adt/rowtypes.c:902 utils/adt/rowtypes.c:1142 -#: utils/adt/rowtypes.c:1396 utils/adt/rowtypes.c:1673 +#: utils/adt/rowtypes.c:902 utils/adt/rowtypes.c:1142 utils/adt/rowtypes.c:1396 +#: utils/adt/rowtypes.c:1673 #, c-format msgid "cannot compare dissimilar column types %s and %s at record column %d" msgstr "non è possibile confrontare i tipi di colonne dissimili %s e %s alla colonna %d del record" -#: utils/adt/rowtypes.c:991 utils/adt/rowtypes.c:1213 -#: utils/adt/rowtypes.c:1529 utils/adt/rowtypes.c:1769 +#: utils/adt/rowtypes.c:991 utils/adt/rowtypes.c:1213 utils/adt/rowtypes.c:1529 +#: utils/adt/rowtypes.c:1769 #, c-format msgid "cannot compare record types with different numbers of columns" msgstr "non è possibile confrontare tipi di record con diverso numero di colonne" -#: utils/adt/ruleutils.c:4153 +#: utils/adt/ruleutils.c:4289 #, c-format msgid "rule \"%s\" has unsupported event type %d" msgstr "la regola \"%s\" ha un tipo di evento non supportato %d" -#: utils/adt/selfuncs.c:5314 +#: utils/adt/selfuncs.c:5318 #, c-format msgid "case insensitive matching not supported on type bytea" msgstr "il confronto case insensitive sul tipo bytea non è supportato" -#: utils/adt/selfuncs.c:5417 +#: utils/adt/selfuncs.c:5421 #, c-format msgid "regular-expression matching not supported on type bytea" msgstr "il confronto con espressioni regolari sul tipo bytea non è supportato" @@ -19583,7 +19584,7 @@ msgid "timestamp out of range: \"%s\"" msgstr "timestamp fuori dall'intervallo consentito: \"%s\"" #: utils/adt/timestamp.c:188 utils/adt/timestamp.c:463 -#: utils/adt/timestamp.c:993 +#: utils/adt/timestamp.c:990 #, c-format msgid "date/time value \"%s\" is no longer supported" msgstr "il valore \"%s\" per i tipi date/time non è più supportato" @@ -19619,85 +19620,84 @@ msgstr "fuso orario numerico \"%s\" fuori dall'intervallo consentito" msgid "timestamp out of range: %d-%02d-%02d %d:%02d:%02g" msgstr "timestamp fuori dall'intervallo consentito: %d-%02d-%02d %d:%02d:%02g" -#: utils/adt/timestamp.c:770 utils/adt/timestamp.c:776 -#: utils/adt/timestamp.c:791 +#: utils/adt/timestamp.c:772 utils/adt/timestamp.c:788 #, c-format msgid "timestamp out of range: \"%g\"" msgstr "timestamp fuori dall'intervallo consentito: \"%g\" " -#: utils/adt/timestamp.c:987 utils/adt/timestamp.c:1558 -#: utils/adt/timestamp.c:2068 utils/adt/timestamp.c:3220 -#: utils/adt/timestamp.c:3225 utils/adt/timestamp.c:3230 -#: utils/adt/timestamp.c:3280 utils/adt/timestamp.c:3287 -#: utils/adt/timestamp.c:3294 utils/adt/timestamp.c:3314 -#: utils/adt/timestamp.c:3321 utils/adt/timestamp.c:3328 -#: utils/adt/timestamp.c:3358 utils/adt/timestamp.c:3366 -#: utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3751 -#: utils/adt/timestamp.c:3880 utils/adt/timestamp.c:4271 +#: utils/adt/timestamp.c:984 utils/adt/timestamp.c:1608 +#: utils/adt/timestamp.c:2121 utils/adt/timestamp.c:3273 +#: utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3283 +#: utils/adt/timestamp.c:3333 utils/adt/timestamp.c:3340 +#: utils/adt/timestamp.c:3347 utils/adt/timestamp.c:3367 +#: utils/adt/timestamp.c:3374 utils/adt/timestamp.c:3381 +#: utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3419 +#: utils/adt/timestamp.c:3464 utils/adt/timestamp.c:3804 +#: utils/adt/timestamp.c:3933 utils/adt/timestamp.c:4324 #, c-format msgid "interval out of range" msgstr "il valore di interval è fuori dall'intervallo consentito" -#: utils/adt/timestamp.c:1128 utils/adt/timestamp.c:1161 +#: utils/adt/timestamp.c:1125 utils/adt/timestamp.c:1158 #, c-format msgid "invalid INTERVAL type modifier" msgstr "il modificatore di tipo su INTERVAL non è valido" -#: utils/adt/timestamp.c:1144 +#: utils/adt/timestamp.c:1141 #, c-format msgid "INTERVAL(%d) precision must not be negative" msgstr "la precisione di INTERVAL(%d) non può essere negativa" -#: utils/adt/timestamp.c:1150 +#: utils/adt/timestamp.c:1147 #, c-format msgid "INTERVAL(%d) precision reduced to maximum allowed, %d" msgstr "la precisione di INTERVAL(%d) è stata ridotta al massimo consentito %d" -#: utils/adt/timestamp.c:1502 +#: utils/adt/timestamp.c:1552 #, c-format msgid "interval(%d) precision must be between %d and %d" msgstr "la precisione di INTERVAL(%d) deve essere compresa fra %d e %d" -#: utils/adt/timestamp.c:2797 +#: utils/adt/timestamp.c:2850 #, c-format msgid "cannot subtract infinite timestamps" msgstr "non è possibile sottrarre valori infiniti di TIMESTAMP" -#: utils/adt/timestamp.c:4006 utils/adt/timestamp.c:4531 -#: utils/adt/timestamp.c:4715 utils/adt/timestamp.c:4740 +#: utils/adt/timestamp.c:4059 utils/adt/timestamp.c:4584 +#: utils/adt/timestamp.c:4768 utils/adt/timestamp.c:4793 #, c-format msgid "timestamp units \"%s\" not supported" msgstr "unità \"%s\" di timestamp non supportata" -#: utils/adt/timestamp.c:4020 utils/adt/timestamp.c:4485 -#: utils/adt/timestamp.c:4750 +#: utils/adt/timestamp.c:4073 utils/adt/timestamp.c:4538 +#: utils/adt/timestamp.c:4803 #, c-format msgid "timestamp units \"%s\" not recognized" msgstr "unità \"%s\" di timestamp non riconosciuta" -#: utils/adt/timestamp.c:4160 utils/adt/timestamp.c:4526 -#: utils/adt/timestamp.c:4937 utils/adt/timestamp.c:4963 +#: utils/adt/timestamp.c:4213 utils/adt/timestamp.c:4579 +#: utils/adt/timestamp.c:4990 utils/adt/timestamp.c:5016 #, c-format msgid "timestamp with time zone units \"%s\" not supported" msgstr "unità \"%s\" di timestamp with time zone non supportata" -#: utils/adt/timestamp.c:4177 utils/adt/timestamp.c:4480 -#: utils/adt/timestamp.c:4972 +#: utils/adt/timestamp.c:4230 utils/adt/timestamp.c:4533 +#: utils/adt/timestamp.c:5025 #, c-format msgid "timestamp with time zone units \"%s\" not recognized" msgstr "unità \"%s\" di timestamp with time zone non riconosciuta" -#: utils/adt/timestamp.c:4258 +#: utils/adt/timestamp.c:4311 #, c-format msgid "interval units \"%s\" not supported because months usually have fractional weeks" msgstr "le unità di intervallo \"%s\" non sono supportate perché generalmente i mesi hanno settimane frazionali" -#: utils/adt/timestamp.c:4264 utils/adt/timestamp.c:5078 +#: utils/adt/timestamp.c:4317 utils/adt/timestamp.c:5131 #, c-format msgid "interval units \"%s\" not supported" msgstr "unità \"%s\" di interval non supportata" -#: utils/adt/timestamp.c:4280 utils/adt/timestamp.c:5105 +#: utils/adt/timestamp.c:4333 utils/adt/timestamp.c:5158 #, c-format msgid "interval units \"%s\" not recognized" msgstr "unità \"%s\" di interval non riconosciuta" @@ -19758,17 +19758,17 @@ msgstr "l'operando in tsquery è troppo lungo: \"%s\"" msgid "word is too long in tsquery: \"%s\"" msgstr "la parola in tsquery è troppo lunga: \"%s\"" -#: utils/adt/tsquery.c:648 +#: utils/adt/tsquery.c:642 #, c-format msgid "text-search query doesn't contain lexemes: \"%s\"" msgstr "la query di ricerca di testo non contiene alcun lessema: \"%s\"" -#: utils/adt/tsquery.c:659 utils/adt/tsquery_util.c:347 +#: utils/adt/tsquery.c:653 utils/adt/tsquery_util.c:375 #, c-format msgid "tsquery is too large" msgstr "tsquery troppo grande" -#: utils/adt/tsquery_cleanup.c:580 +#: utils/adt/tsquery_cleanup.c:407 #, c-format msgid "text-search query contains only stop words or doesn't contain lexemes, ignored" msgstr "la query di ricerca di testo contiene solo stop word o non contiene lessemi, ignorata" @@ -19778,7 +19778,7 @@ msgstr "la query di ricerca di testo contiene solo stop word o non contiene less msgid "distance in phrase operator should be non-negative and less than %d" msgstr "la distanza nell'operatore di frase deve essere non negativa ed inferiore a %d" -#: utils/adt/tsquery_rewrite.c:292 +#: utils/adt/tsquery_rewrite.c:321 #, c-format msgid "ts_rewrite query must return two tsquery columns" msgstr "la query ts_rewrite deve restituire due colonne tsquery" @@ -19798,7 +19798,7 @@ msgstr "l'array dei pesi è troppo corto" msgid "array of weight must not contain nulls" msgstr "l'array dei pesi non può contenere valori nulli" -#: utils/adt/tsrank.c:431 utils/adt/tsrank.c:862 +#: utils/adt/tsrank.c:431 utils/adt/tsrank.c:868 #, c-format msgid "weight out of range" msgstr "il peso è fuori dall'intervallo consentito" @@ -19813,53 +19813,58 @@ msgstr "la lunghezza della parola (%ld byte) eccede il massimo (%ld byte)" msgid "string is too long for tsvector (%ld bytes, max %ld bytes)" msgstr "la lunghezza della stringa (%ld byte) eccede il massimo per un tsvector (%ld byte)" -#: utils/adt/tsvector_op.c:317 utils/adt/tsvector_op.c:565 -#: utils/adt/tsvector_op.c:731 +#: utils/adt/tsvector_op.c:322 utils/adt/tsvector_op.c:609 +#: utils/adt/tsvector_op.c:777 #, c-format msgid "lexeme array may not contain nulls" msgstr "l'array di lessemi non può contenere null" -#: utils/adt/tsvector_op.c:789 +#: utils/adt/tsvector_op.c:852 #, c-format msgid "weight array may not contain nulls" msgstr "l'array dei pesi non può contenere null" -#: utils/adt/tsvector_op.c:1976 +#: utils/adt/tsvector_op.c:876 +#, c-format +msgid "unrecognized weight: \"%c\"" +msgstr "peso non riconosciuto: \"%c\"" + +#: utils/adt/tsvector_op.c:2313 #, c-format msgid "ts_stat query must return one tsvector column" msgstr "la query ts_stat deve restituire una colonna tsvector" -#: utils/adt/tsvector_op.c:2158 +#: utils/adt/tsvector_op.c:2495 #, c-format msgid "tsvector column \"%s\" does not exist" msgstr "la colonna tsvector \"%s\" non esiste" -#: utils/adt/tsvector_op.c:2164 +#: utils/adt/tsvector_op.c:2501 #, c-format msgid "column \"%s\" is not of tsvector type" msgstr "la colonna \"%s\" non è di tipo tsvector" -#: utils/adt/tsvector_op.c:2176 +#: utils/adt/tsvector_op.c:2513 #, c-format msgid "configuration column \"%s\" does not exist" msgstr "la configurazione della colonna \"%s\" non esiste" -#: utils/adt/tsvector_op.c:2182 +#: utils/adt/tsvector_op.c:2519 #, c-format msgid "column \"%s\" is not of regconfig type" msgstr "la colonna \"%s\" non è di tipo regconfig" -#: utils/adt/tsvector_op.c:2189 +#: utils/adt/tsvector_op.c:2526 #, c-format msgid "configuration column \"%s\" must not be null" msgstr "la colonna di configurazione \"%s\" non può essere nulla" -#: utils/adt/tsvector_op.c:2202 +#: utils/adt/tsvector_op.c:2539 #, c-format msgid "text search configuration name \"%s\" must be schema-qualified" msgstr "la configurazione di ricerca di testo \"%s\" deve avere uno schema" -#: utils/adt/tsvector_op.c:2227 +#: utils/adt/tsvector_op.c:2564 #, c-format msgid "column \"%s\" is not of a character type" msgstr "la colonna \"%s\" non è di tipo carattere" @@ -19956,12 +19961,12 @@ msgstr "non è possibile eseguire l'OR fra stringhe di bit di dimensioni diverse msgid "cannot XOR bit strings of different sizes" msgstr "non è possibile eseguire lo XOR fra stringhe di bit di dimensioni diverse" -#: utils/adt/varbit.c:1793 utils/adt/varbit.c:1851 +#: utils/adt/varbit.c:1803 utils/adt/varbit.c:1861 #, c-format msgid "bit index %d out of valid range (0..%d)" msgstr "l'indice %d è fuori dall'intervallo valido (0..%d)" -#: utils/adt/varbit.c:1802 utils/adt/varlena.c:3002 +#: utils/adt/varbit.c:1812 utils/adt/varlena.c:3002 #, c-format msgid "new bit must be 0 or 1" msgstr "il nuovo bit deve essere 0 o 1" @@ -20017,16 +20022,11 @@ msgstr "Per un singolo \"%%\" usa \"%%%%\"." msgid "unrecognized format() type specifier \"%c\"" msgstr "specifica di tipo per format() \"%c\" non riconosciuta" -#: utils/adt/varlena.c:4950 +#: utils/adt/varlena.c:4950 utils/adt/varlena.c:5007 #, c-format msgid "too few arguments for format()" msgstr "numero di argomenti non sufficiente per format()" -#: utils/adt/varlena.c:5007 -#, c-format -msgid "too few arguments for format" -msgstr "troppi pochi argomenti per il formato" - #: utils/adt/varlena.c:5102 utils/adt/varlena.c:5285 #, c-format msgid "number is out of range" @@ -20127,71 +20127,71 @@ msgstr "impostazione del gestore di errori XML fallita" msgid "This probably indicates that the version of libxml2 being used is not compatible with the libxml2 header files that PostgreSQL was built with." msgstr "Questo vuol dire probabilmente che la versione di libxml2 in uso non è compatibile con i file di header libxml2 con cui PostgreSQL è stato compilato." -#: utils/adt/xml.c:1737 +#: utils/adt/xml.c:1735 msgid "Invalid character value." msgstr "Valore di carattere non valido." -#: utils/adt/xml.c:1740 +#: utils/adt/xml.c:1738 msgid "Space required." msgstr "È necessario uno spazio." -#: utils/adt/xml.c:1743 +#: utils/adt/xml.c:1741 msgid "standalone accepts only 'yes' or 'no'." msgstr "Solo 'yes' o 'no' sono accettati da standalone." -#: utils/adt/xml.c:1746 +#: utils/adt/xml.c:1744 msgid "Malformed declaration: missing version." msgstr "La dichiarazione non è definita correttamente: manca la versione." -#: utils/adt/xml.c:1749 +#: utils/adt/xml.c:1747 msgid "Missing encoding in text declaration." msgstr "Manca la codifica nella dichiarazione del testo." -#: utils/adt/xml.c:1752 +#: utils/adt/xml.c:1750 msgid "Parsing XML declaration: '?>' expected." msgstr "Durante l'analisi XML è stato riscontrato che manca '?>'." -#: utils/adt/xml.c:1755 +#: utils/adt/xml.c:1753 #, c-format msgid "Unrecognized libxml error code: %d." msgstr "Codice di errore di libxml sconosciuto: %d." -#: utils/adt/xml.c:2030 +#: utils/adt/xml.c:2028 #, c-format msgid "XML does not support infinite date values." msgstr "XML non supporta i valori infiniti per il tipo date." -#: utils/adt/xml.c:2052 utils/adt/xml.c:2079 +#: utils/adt/xml.c:2050 utils/adt/xml.c:2077 #, c-format msgid "XML does not support infinite timestamp values." msgstr "XML non supporta i valori infiniti per il tipo timestamp." -#: utils/adt/xml.c:2470 +#: utils/adt/xml.c:2468 #, c-format msgid "invalid query" msgstr "query non valida" -#: utils/adt/xml.c:3795 +#: utils/adt/xml.c:3793 #, c-format msgid "invalid array for XML namespace mapping" msgstr "l'array per il mapping del namespace XML non è valido" -#: utils/adt/xml.c:3796 +#: utils/adt/xml.c:3794 #, c-format msgid "The array must be two-dimensional with length of the second axis equal to 2." msgstr "L'array deve avere due dimensioni e la lunghezza del secondo asse deve essere pari a 2." -#: utils/adt/xml.c:3820 +#: utils/adt/xml.c:3818 #, c-format msgid "empty XPath expression" msgstr "l'espressione XPath è vuota" -#: utils/adt/xml.c:3869 +#: utils/adt/xml.c:3867 #, c-format msgid "neither namespace name nor URI may be null" msgstr "né il nome del namespace né l'URI possono essere nulli" -#: utils/adt/xml.c:3876 +#: utils/adt/xml.c:3874 #, c-format msgid "could not register XML namespace with name \"%s\" and URI \"%s\"" msgstr "registrazione del namespace XML con nome \"%s\" ed URI \"%s\" fallita" @@ -20212,22 +20212,22 @@ msgstr "nessuna funzione di input disponibile per il tipo %s" msgid "no output function available for type %s" msgstr "nessuna funzione di output disponibile per il tipo %s" -#: utils/cache/plancache.c:745 +#: utils/cache/plancache.c:718 #, c-format msgid "cached plan must not change result type" msgstr "il cached plan non deve cambiare il tipo del risultato" -#: utils/cache/relcache.c:5135 +#: utils/cache/relcache.c:5226 #, c-format msgid "could not create relation-cache initialization file \"%s\": %m" msgstr "creazione del file di inizializzazione della cache delle relazioni \"%s\" fallita: %m" -#: utils/cache/relcache.c:5137 +#: utils/cache/relcache.c:5228 #, c-format msgid "Continuing anyway, but there's something wrong." msgstr "Proseguo in ogni caso, ma c'è qualcosa che non funziona." -#: utils/cache/relcache.c:5365 +#: utils/cache/relcache.c:5502 #, c-format msgid "could not remove cache file \"%s\": %m" msgstr "rimozione del file di cache \"%s\" fallita: %m" @@ -20272,12 +20272,12 @@ msgstr "fsync del file della mappa delle relazioni \"%s\" fallito: %m" msgid "could not close relation mapping file \"%s\": %m" msgstr "chiusura del file della mappa delle relazioni \"%s\" fallita: %m" -#: utils/cache/typcache.c:1211 +#: utils/cache/typcache.c:1207 #, c-format msgid "type %s is not composite" msgstr "il tipo %s non è composito" -#: utils/cache/typcache.c:1225 +#: utils/cache/typcache.c:1221 #, c-format msgid "record type has not been registered" msgstr "il tipo del record non è stato registrato" @@ -20297,96 +20297,96 @@ msgstr "TRAP: %s(\"%s\", File: \"%s\", Linea: %d)\n" msgid "error occurred at %s:%d before error message processing is available\n" msgstr "l'errore è avvenuto a %s:%d prima che fosse possibile processare i messaggi d'errore\n" -#: utils/error/elog.c:1880 +#: utils/error/elog.c:1889 #, c-format msgid "could not reopen file \"%s\" as stderr: %m" msgstr "riapertura del file \"%s\" come stderr fallita: %m" -#: utils/error/elog.c:1893 +#: utils/error/elog.c:1902 #, c-format msgid "could not reopen file \"%s\" as stdout: %m" msgstr "riapertura del file \"%s\" come stdout fallita: %m" -#: utils/error/elog.c:2380 utils/error/elog.c:2397 utils/error/elog.c:2413 +#: utils/error/elog.c:2389 utils/error/elog.c:2406 utils/error/elog.c:2422 msgid "[unknown]" msgstr "[sconosciuto]" -#: utils/error/elog.c:2872 utils/error/elog.c:3171 utils/error/elog.c:3279 +#: utils/error/elog.c:2882 utils/error/elog.c:3185 utils/error/elog.c:3293 msgid "missing error text" msgstr "testo dell'errore mancante" -#: utils/error/elog.c:2875 utils/error/elog.c:2878 utils/error/elog.c:3282 -#: utils/error/elog.c:3285 +#: utils/error/elog.c:2885 utils/error/elog.c:2888 utils/error/elog.c:3296 +#: utils/error/elog.c:3299 #, c-format msgid " at character %d" msgstr " al carattere %d" -#: utils/error/elog.c:2888 utils/error/elog.c:2895 +#: utils/error/elog.c:2898 utils/error/elog.c:2905 msgid "DETAIL: " msgstr "DETTAGLI: " -#: utils/error/elog.c:2902 +#: utils/error/elog.c:2912 msgid "HINT: " msgstr "SUGGERIMENTO: " -#: utils/error/elog.c:2909 +#: utils/error/elog.c:2919 msgid "QUERY: " msgstr "QUERY: " -#: utils/error/elog.c:2916 +#: utils/error/elog.c:2926 msgid "CONTEXT: " msgstr "CONTESTO: " -#: utils/error/elog.c:2926 +#: utils/error/elog.c:2936 #, c-format msgid "LOCATION: %s, %s:%d\n" msgstr "POSIZIONE: %s, %s:%d\n" -#: utils/error/elog.c:2933 +#: utils/error/elog.c:2943 #, c-format msgid "LOCATION: %s:%d\n" msgstr "POSIZIONE: %s:%d\n" -#: utils/error/elog.c:2947 +#: utils/error/elog.c:2957 msgid "STATEMENT: " msgstr "ISTRUZIONE: " #. translator: This string will be truncated at 47 #. characters expanded. -#: utils/error/elog.c:3400 +#: utils/error/elog.c:3414 #, c-format msgid "operating system error %d" msgstr "errore del sistema operativo %d" -#: utils/error/elog.c:3595 +#: utils/error/elog.c:3612 msgid "DEBUG" msgstr "DEBUG" -#: utils/error/elog.c:3599 +#: utils/error/elog.c:3616 msgid "LOG" msgstr "LOG" -#: utils/error/elog.c:3602 +#: utils/error/elog.c:3619 msgid "INFO" msgstr "INFO" -#: utils/error/elog.c:3605 +#: utils/error/elog.c:3622 msgid "NOTICE" msgstr "NOTIFICA" -#: utils/error/elog.c:3608 +#: utils/error/elog.c:3625 msgid "WARNING" msgstr "ATTENZIONE" -#: utils/error/elog.c:3611 +#: utils/error/elog.c:3628 msgid "ERROR" msgstr "ERRORE" -#: utils/error/elog.c:3614 +#: utils/error/elog.c:3631 msgid "FATAL" msgstr "FATALE" -#: utils/error/elog.c:3617 +#: utils/error/elog.c:3634 msgid "PANIC" msgstr "PANICO" @@ -20489,32 +20489,32 @@ msgstr "la funzione interna \"%s\" non è nella tabella interna di lookup" msgid "unrecognized API version %d reported by info function \"%s\"" msgstr "versione API sconosciuto %d riportata dalla funzione info \"%s\"" -#: utils/fmgr/fmgr.c:849 utils/fmgr/fmgr.c:2110 +#: utils/fmgr/fmgr.c:849 utils/fmgr/fmgr.c:2106 #, c-format msgid "function %u has too many arguments (%d, maximum is %d)" msgstr "la funzione %u ha troppo argomenti (%d, il massimo è %d)" -#: utils/fmgr/fmgr.c:2531 +#: utils/fmgr/fmgr.c:2527 #, c-format msgid "language validation function %u called for language %u instead of %u" msgstr "funzione di validazione del linguaggio %u chiamata per il linguaggio %u invece di %u" -#: utils/fmgr/funcapi.c:355 +#: utils/fmgr/funcapi.c:353 #, c-format msgid "could not determine actual result type for function \"%s\" declared to return type %s" msgstr "non è stato possibile determinare il tipo reale di risultato della funzione \"%s\" dichiarata con tipo restituito %s" -#: utils/fmgr/funcapi.c:1342 utils/fmgr/funcapi.c:1373 +#: utils/fmgr/funcapi.c:1340 utils/fmgr/funcapi.c:1371 #, c-format msgid "number of aliases does not match number of columns" msgstr "il numero di alias non corrisponde al numero delle colonne" -#: utils/fmgr/funcapi.c:1367 +#: utils/fmgr/funcapi.c:1365 #, c-format msgid "no column alias was provided" msgstr "non è stato fornito nessun alias colonna" -#: utils/fmgr/funcapi.c:1391 +#: utils/fmgr/funcapi.c:1389 #, c-format msgid "could not determine row description for function returning record" msgstr "non è stato possibile determinare la descrizione della riga per la funzione che restituisce record" @@ -20524,7 +20524,7 @@ msgstr "non è stato possibile determinare la descrizione della riga per la funz msgid "could not change directory to \"%s\": %m" msgstr "spostamento nella directory \"%s\" fallito: %m" -#: utils/init/miscinit.c:449 utils/misc/guc.c:6012 +#: utils/init/miscinit.c:449 utils/misc/guc.c:6016 #, c-format msgid "cannot set parameter \"%s\" within security-restricted operation" msgstr "non è possibile impostare il parametro \"%s\" nell'ambito di operazioni a sicurezza ristretta" @@ -20635,7 +20635,7 @@ msgstr "Sembra che il file sia stato abbandonato accidentalmente, ma non può es msgid "could not write lock file \"%s\": %m" msgstr "scrittura del file di lock \"%s\" fallita: %m" -#: utils/init/miscinit.c:1172 utils/init/miscinit.c:1301 utils/misc/guc.c:8806 +#: utils/init/miscinit.c:1172 utils/init/miscinit.c:1301 utils/misc/guc.c:8818 #, c-format msgid "could not read from file \"%s\": %m" msgstr "lettura dal file \"%s\" fallita: %m" @@ -20680,135 +20680,135 @@ msgstr "La directory dati è stata inizializzata da PostgreSQL versione %ld.%ld, msgid "loaded library \"%s\"" msgstr "libreria \"%s\" caricata" -#: utils/init/postinit.c:252 +#: utils/init/postinit.c:251 #, c-format msgid "replication connection authorized: user=%s SSL enabled (protocol=%s, cipher=%s, compression=%s)" msgstr "connessione di replica autorizzata: utente=%s SSL abilitato (protocollo=%s, cifrario=%s, compressione=%s)" -#: utils/init/postinit.c:254 utils/init/postinit.c:268 +#: utils/init/postinit.c:253 utils/init/postinit.c:267 msgid "off" msgstr "disattivato" -#: utils/init/postinit.c:254 utils/init/postinit.c:268 +#: utils/init/postinit.c:253 utils/init/postinit.c:267 msgid "on" msgstr "attivato" -#: utils/init/postinit.c:258 +#: utils/init/postinit.c:257 #, c-format msgid "replication connection authorized: user=%s" msgstr "connessione di replica autorizzata: utente=%s" -#: utils/init/postinit.c:266 +#: utils/init/postinit.c:265 #, c-format msgid "connection authorized: user=%s database=%s SSL enabled (protocol=%s, cipher=%s, compression=%s)" msgstr "connessione autorizzata: utente=%s database=%s SSL abilitato (protocollo=%s, cifrario=%s, compressione=%s)" -#: utils/init/postinit.c:272 +#: utils/init/postinit.c:271 #, c-format msgid "connection authorized: user=%s database=%s" msgstr "connessione autorizzata: utente=%s database=%s" -#: utils/init/postinit.c:304 +#: utils/init/postinit.c:303 #, c-format msgid "database \"%s\" has disappeared from pg_database" msgstr "il database \"%s\" è scomparso da database pg_database" -#: utils/init/postinit.c:306 +#: utils/init/postinit.c:305 #, c-format msgid "Database OID %u now seems to belong to \"%s\"." msgstr "L'OID %u del database ora sembra appartenere a \"%s\"." -#: utils/init/postinit.c:326 +#: utils/init/postinit.c:325 #, c-format msgid "database \"%s\" is not currently accepting connections" msgstr "il database \"%s\" attualmente non accetta connessioni" -#: utils/init/postinit.c:339 +#: utils/init/postinit.c:338 #, c-format msgid "permission denied for database \"%s\"" msgstr "permesso negato per il database \"%s\"" -#: utils/init/postinit.c:340 +#: utils/init/postinit.c:339 #, c-format msgid "User does not have CONNECT privilege." msgstr "L'utente non ha il privilegio CONNECT." -#: utils/init/postinit.c:357 +#: utils/init/postinit.c:356 #, c-format msgid "too many connections for database \"%s\"" msgstr "troppe connessioni al database \"%s\"" -#: utils/init/postinit.c:379 utils/init/postinit.c:386 +#: utils/init/postinit.c:378 utils/init/postinit.c:385 #, c-format msgid "database locale is incompatible with operating system" msgstr "il locale del database è incompatibile col sistema operativo" -#: utils/init/postinit.c:380 +#: utils/init/postinit.c:379 #, c-format msgid "The database was initialized with LC_COLLATE \"%s\", which is not recognized by setlocale()." msgstr "Il database di database è stato inizializzato con LC_COLLATE \"%s\", che non è riconosciuto da setlocale()." -#: utils/init/postinit.c:382 utils/init/postinit.c:389 +#: utils/init/postinit.c:381 utils/init/postinit.c:388 #, c-format msgid "Recreate the database with another locale or install the missing locale." msgstr "Crea di nuovo il database con un altro locale oppure installa il locale mancante." -#: utils/init/postinit.c:387 +#: utils/init/postinit.c:386 #, c-format msgid "The database was initialized with LC_CTYPE \"%s\", which is not recognized by setlocale()." msgstr "Il database è stato inizializzato con LC_CTYPE \"%s\", che non è riconosciuto da setlocale()." -#: utils/init/postinit.c:715 +#: utils/init/postinit.c:714 #, c-format msgid "no roles are defined in this database system" msgstr "nessun ruolo definito in questo database" -#: utils/init/postinit.c:716 +#: utils/init/postinit.c:715 #, c-format msgid "You should immediately run CREATE USER \"%s\" SUPERUSER;." msgstr "Dovresti eseguire immediatamente CREATE USER \"%s\" SUPERUSER;." -#: utils/init/postinit.c:752 +#: utils/init/postinit.c:751 #, c-format msgid "new replication connections are not allowed during database shutdown" msgstr "non sono accettate nuove connessioni di replica durante lo spegnimento del database" -#: utils/init/postinit.c:756 +#: utils/init/postinit.c:755 #, c-format msgid "must be superuser to connect during database shutdown" msgstr "solo un superutente può connettersi durante lo spegnimento del database" -#: utils/init/postinit.c:766 +#: utils/init/postinit.c:765 #, c-format msgid "must be superuser to connect in binary upgrade mode" msgstr "solo un superutente può connettersi in modalità di aggiornamento binario" -#: utils/init/postinit.c:780 +#: utils/init/postinit.c:779 #, c-format msgid "remaining connection slots are reserved for non-replication superuser connections" msgstr "i rimanenti slot di connessione sono riservati a connessioni di superutenti non di replica" -#: utils/init/postinit.c:790 +#: utils/init/postinit.c:789 #, c-format msgid "must be superuser or replication role to start walsender" msgstr "solo un superutente o il ruolo di replica può avviare walsender" -#: utils/init/postinit.c:859 +#: utils/init/postinit.c:858 #, c-format msgid "database %u does not exist" msgstr "il database %u non esiste" -#: utils/init/postinit.c:945 +#: utils/init/postinit.c:944 #, c-format msgid "It seems to have just been dropped or renamed." msgstr "Sembra sia stato appena eliminato o rinominato." -#: utils/init/postinit.c:963 +#: utils/init/postinit.c:962 #, c-format msgid "The database subdirectory \"%s\" is missing." msgstr "La sottodirectory del database \"%s\" risulta mancante." -#: utils/init/postinit.c:968 +#: utils/init/postinit.c:967 #, c-format msgid "could not access directory \"%s\": %m" msgstr "accesso alla directory \"%s\" fallito: %m" @@ -21120,1266 +21120,1266 @@ msgstr "Abilita l'uso da parte del planner di piani di join ad unione." msgid "Enables the planner's use of hash join plans." msgstr "Abilita l'uso da parte del planner di piani di join basati su hash." -#: utils/misc/guc.c:882 -msgid "Enables use of foreign keys for estimating joins." -msgstr "Abilita l'uso delle chiavi esterne per la stima dei join." - -#: utils/misc/guc.c:892 +#: utils/misc/guc.c:883 msgid "Enables genetic query optimization." msgstr "Abilita l'ottimizzatore genetico di query." -#: utils/misc/guc.c:893 +#: utils/misc/guc.c:884 msgid "This algorithm attempts to do planning without exhaustive searching." msgstr "Questo algoritmo cerca di realizzare piani senza effettuare una ricerca esaustiva." -#: utils/misc/guc.c:903 +#: utils/misc/guc.c:894 msgid "Shows whether the current user is a superuser." msgstr "Mostra se l'utente attuale è un superutente o meno." -#: utils/misc/guc.c:913 +#: utils/misc/guc.c:904 msgid "Enables advertising the server via Bonjour." msgstr "Abilita la pubblicazione del server via Bonjour." -#: utils/misc/guc.c:922 +#: utils/misc/guc.c:913 msgid "Collects transaction commit time." msgstr "Raccogli l'ora di commit delle transazioni." -#: utils/misc/guc.c:931 +#: utils/misc/guc.c:922 msgid "Enables SSL connections." msgstr "Abilita le connessioni SSL." -#: utils/misc/guc.c:940 +#: utils/misc/guc.c:931 msgid "Give priority to server ciphersuite order." msgstr "Dai priorità all'ordine di cifrari del server." -#: utils/misc/guc.c:949 +#: utils/misc/guc.c:940 msgid "Forces synchronization of updates to disk." msgstr "Forza la sincronizzazione degli aggiornamenti sul disco." -#: utils/misc/guc.c:950 +#: utils/misc/guc.c:941 msgid "The server will use the fsync() system call in several places to make sure that updates are physically written to disk. This insures that a database cluster will recover to a consistent state after an operating system or hardware crash." msgstr "Il server userà in diversi punti la chiamata di sistema fsync() per assicurarsi che gli aggiornamenti vengano scritti fisicamente sul disco. Questo assicura che un cluster di database possa essere recuperato in uno stato consistente dopo un crash di sistema o dell'hardware." -#: utils/misc/guc.c:961 +#: utils/misc/guc.c:952 msgid "Continues processing after a checksum failure." msgstr "Condinua l'elaborazione dopo un errore in una somma di controllo." -#: utils/misc/guc.c:962 +#: utils/misc/guc.c:953 msgid "Detection of a checksum failure normally causes PostgreSQL to report an error, aborting the current transaction. Setting ignore_checksum_failure to true causes the system to ignore the failure (but still report a warning), and continue processing. This behavior could cause crashes or other serious problems. Only has an effect if checksums are enabled." msgstr "La rilevazione di un errore in una somma di controllo di solito fa generare a PostgreSQL un errore che fa abortire la transazione corrente. Impostare ignore_checksum_failure a \"true\" fa sì che il sistema ignori l'errore (che viene riportato come un avviso), consentendo al processo di continuare. Questo comportamento potrebbe causare crash o altri problemi gravi. Ha effetto solo se se somme di controllo sono abilitate." -#: utils/misc/guc.c:976 +#: utils/misc/guc.c:967 msgid "Continues processing past damaged page headers." msgstr "Continua l'esecuzione oltre le intestazioni di pagina danneggiate." -#: utils/misc/guc.c:977 +#: utils/misc/guc.c:968 msgid "Detection of a damaged page header normally causes PostgreSQL to report an error, aborting the current transaction. Setting zero_damaged_pages to true causes the system to instead report a warning, zero out the damaged page, and continue processing. This behavior will destroy data, namely all the rows on the damaged page." msgstr "Il rilevamento di una intestazione di pagina danneggiata normalmente fa sì che PostgreSQL segnali un errore, interrompendo la transazione corrente. L'attivazione di zero_damaged_pages fa sì che il sistema invece riporti un warning, azzeri la pagina danneggiata e continui l'esecuzione. Questo comportamento può distruggere dei dati, in particolare tutte quelle righe situate nella pagina danneggiata." -#: utils/misc/guc.c:990 +#: utils/misc/guc.c:981 msgid "Writes full pages to WAL when first modified after a checkpoint." msgstr "Scrivi pagine intere nel WAL non appena modificate dopo un checkpoint." -#: utils/misc/guc.c:991 +#: utils/misc/guc.c:982 msgid "A page write in process during an operating system crash might be only partially written to disk. During recovery, the row changes stored in WAL are not enough to recover. This option writes pages when first modified after a checkpoint to WAL so full recovery is possible." msgstr "La scrittura di una pagina durante un crash del sistema operativo potrebbe essere stata scritta su disco solo parzialmente. Durante il ripristino, le variazioni di riga memorizzate nel WAL non sono sufficienti al ripristino. Questa operazione scrive le pagine nel WAL appena modificate dopo un checkpoint nel WAL in maniera da rendere possibile un ripristino completo." -#: utils/misc/guc.c:1004 +#: utils/misc/guc.c:995 msgid "Writes full pages to WAL when first modified after a checkpoint, even for a non-critical modifications." msgstr "Scrivi pagine complete nel WAL appena modificate dopo un checkpoint, anche dopo modifiche non critiche." -#: utils/misc/guc.c:1014 +#: utils/misc/guc.c:1005 msgid "Compresses full-page writes written in WAL file." msgstr "Comprimi le scritture di pagine complete scritte nel file WAL." -#: utils/misc/guc.c:1024 +#: utils/misc/guc.c:1015 msgid "Logs each checkpoint." msgstr "Registra nel log ogni checkpoint." -#: utils/misc/guc.c:1033 +#: utils/misc/guc.c:1024 msgid "Logs each successful connection." msgstr "Registra nel log tutte le connessioni avvenute con successo." -#: utils/misc/guc.c:1042 +#: utils/misc/guc.c:1033 msgid "Logs end of a session, including duration." msgstr "Registra nel log la fine delle sessioni, compresa la sua durata." -#: utils/misc/guc.c:1051 +#: utils/misc/guc.c:1042 msgid "Logs each replication command." msgstr "Registra nel log ogni comando di replica." -#: utils/misc/guc.c:1060 +#: utils/misc/guc.c:1051 msgid "Shows whether the running server has assertion checks enabled." msgstr "Mostra se il server in esecuzione ha i controlli di assert attivi." -#: utils/misc/guc.c:1075 +#: utils/misc/guc.c:1066 msgid "Terminate session on any error." msgstr "Termina la sessione su qualunque errore." -#: utils/misc/guc.c:1084 +#: utils/misc/guc.c:1075 msgid "Reinitialize server after backend crash." msgstr "Reinizializza il server dopo un crash del backend." -#: utils/misc/guc.c:1094 +#: utils/misc/guc.c:1085 msgid "Logs the duration of each completed SQL statement." msgstr "Registra nel log la durata di ogni istruzione SQL completata." -#: utils/misc/guc.c:1103 +#: utils/misc/guc.c:1094 msgid "Logs each query's parse tree." msgstr "Registra nel log l'albero di parsing di tutte le query." -#: utils/misc/guc.c:1112 +#: utils/misc/guc.c:1103 msgid "Logs each query's rewritten parse tree." msgstr "Registra nel log l'albero di parsing riscritto di tutte le query." -#: utils/misc/guc.c:1121 +#: utils/misc/guc.c:1112 msgid "Logs each query's execution plan." msgstr "Registra nel log il piano di esecuzione di tutte le query." -#: utils/misc/guc.c:1130 +#: utils/misc/guc.c:1121 msgid "Indents parse and plan tree displays." msgstr "Indenta gli alberi di parsing e dei piani di esecuzione." -#: utils/misc/guc.c:1139 +#: utils/misc/guc.c:1130 msgid "Writes parser performance statistics to the server log." msgstr "Registra nel log del server le statistiche sulle prestazioni del parser." -#: utils/misc/guc.c:1148 +#: utils/misc/guc.c:1139 msgid "Writes planner performance statistics to the server log." msgstr "Registra nel log del server le statistiche sulle prestazioni del planner." -#: utils/misc/guc.c:1157 +#: utils/misc/guc.c:1148 msgid "Writes executor performance statistics to the server log." msgstr "Registra nel log del server le statistiche sulle prestazioni dell'esecutore." -#: utils/misc/guc.c:1166 +#: utils/misc/guc.c:1157 msgid "Writes cumulative performance statistics to the server log." msgstr "Registra nel log del server le statistiche sulle prestazioni cumulative." -#: utils/misc/guc.c:1176 +#: utils/misc/guc.c:1167 msgid "Logs system resource usage statistics (memory and CPU) on various B-tree operations." msgstr "Registra nel log statistiche sull'uso di risorse di sistema (memoria e CPU) su varie operazioni B-tree." -#: utils/misc/guc.c:1188 +#: utils/misc/guc.c:1179 msgid "Collects information about executing commands." msgstr "Raccogli informazioni sull'esecuzione dei comandi." -#: utils/misc/guc.c:1189 +#: utils/misc/guc.c:1180 msgid "Enables the collection of information on the currently executing command of each session, along with the time at which that command began execution." msgstr "Abilita la raccolta di informazioni sui comandi in esecuzione per ogni sessione, insieme all'orario in cui l'esecuzione del comando è iniziata." -#: utils/misc/guc.c:1199 +#: utils/misc/guc.c:1190 msgid "Collects statistics on database activity." msgstr "Raccogli statistiche sull'attività del database." -#: utils/misc/guc.c:1208 +#: utils/misc/guc.c:1199 msgid "Collects timing statistics for database I/O activity." msgstr "Raccogli statistiche sull'attività di I/O del database." -#: utils/misc/guc.c:1218 +#: utils/misc/guc.c:1209 msgid "Updates the process title to show the active SQL command." msgstr "Aggiorna il titolo del processo per indicare il comando SQL in esecuzione." -#: utils/misc/guc.c:1219 +#: utils/misc/guc.c:1210 msgid "Enables updating of the process title every time a new SQL command is received by the server." msgstr "Abilita l'aggiornamento del titolo del processo ogni volta che un nuovo comando SQL viene ricevuto dal server." -#: utils/misc/guc.c:1228 +#: utils/misc/guc.c:1223 msgid "Starts the autovacuum subprocess." msgstr "Avvia il sottoprocesso autovacuum." -#: utils/misc/guc.c:1238 +#: utils/misc/guc.c:1233 msgid "Generates debugging output for LISTEN and NOTIFY." msgstr "Genera un output di debug per LISTEN e NOTIFY." -#: utils/misc/guc.c:1250 +#: utils/misc/guc.c:1245 msgid "Emits information about lock usage." msgstr "Emette informazioni sull'uso dei lock." -#: utils/misc/guc.c:1260 +#: utils/misc/guc.c:1255 msgid "Emits information about user lock usage." msgstr "Emette informazioni sull'uso dei lock utente." -#: utils/misc/guc.c:1270 +#: utils/misc/guc.c:1265 msgid "Emits information about lightweight lock usage." msgstr "Emette informazioni sull'uso dei lock leggeri." -#: utils/misc/guc.c:1280 +#: utils/misc/guc.c:1275 msgid "Dumps information about all current locks when a deadlock timeout occurs." msgstr "Emette informazioni su tutti i lock attivi quando avviene un timeout di lock." -#: utils/misc/guc.c:1292 +#: utils/misc/guc.c:1287 msgid "Logs long lock waits." msgstr "Inserisci nel log le attese lunghe su lock." -#: utils/misc/guc.c:1302 +#: utils/misc/guc.c:1297 msgid "Logs the host name in the connection logs." msgstr "Inserisci nel log lo host name delle connessioni." -#: utils/misc/guc.c:1303 +#: utils/misc/guc.c:1298 msgid "By default, connection logs only show the IP address of the connecting host. If you want them to show the host name you can turn this on, but depending on your host name resolution setup it might impose a non-negligible performance penalty." msgstr "Normalmente, viene inserito nel log solo l'indirizzo IP dell'host connesso. Se vuoi mostrare anche il nome host puoi attivando questa parametro ma, a seconda di come è definito il sistema di risoluzione dei nomi, ciò potrebbe comportare una penalizzazione delle prestazioni non trascurabile." -#: utils/misc/guc.c:1314 +#: utils/misc/guc.c:1309 msgid "Causes subtables to be included by default in various commands." msgstr "Fa in modo che le sotto-tabelle vengano incluse in maniera predefinita in vari comandi." -#: utils/misc/guc.c:1323 +#: utils/misc/guc.c:1318 msgid "Encrypt passwords." msgstr "Cripta le password." -#: utils/misc/guc.c:1324 +#: utils/misc/guc.c:1319 msgid "When a password is specified in CREATE USER or ALTER USER without writing either ENCRYPTED or UNENCRYPTED, this parameter determines whether the password is to be encrypted." msgstr "Quando si indica una password in CREATE USER o ALTER USER senza indicare ENCRYPTED o UNENCRYPTED, questo parametro determina se la password debba essere criptata o meno." -#: utils/misc/guc.c:1334 +#: utils/misc/guc.c:1329 msgid "Treats \"expr=NULL\" as \"expr IS NULL\"." msgstr "Tratta l'espressione \"expr=NULL\" come \"expr IS NULL\"." -#: utils/misc/guc.c:1335 +#: utils/misc/guc.c:1330 msgid "When turned on, expressions of the form expr = NULL (or NULL = expr) are treated as expr IS NULL, that is, they return true if expr evaluates to the null value, and false otherwise. The correct behavior of expr = NULL is to always return null (unknown)." msgstr "Se abilitato, le espressioni nella forma expr = NULL (o NULL = expr) vengono trattate come expr IS NULL, in modo cioè che restituiscano TRUE se expr viene valutato con valore NULL e falso in ogni altro caso. Il comportamento corretto prevede che expr = NULL valga sempre NULL (sconosciuto)." -#: utils/misc/guc.c:1347 +#: utils/misc/guc.c:1342 msgid "Enables per-database user names." msgstr "Abilita nomi di utenti diversificati per ogni database." -#: utils/misc/guc.c:1356 +#: utils/misc/guc.c:1351 msgid "Sets the default read-only status of new transactions." msgstr "Imposta lo stato predefinito di sola lettura per le nuove transazioni." -#: utils/misc/guc.c:1365 +#: utils/misc/guc.c:1360 msgid "Sets the current transaction's read-only status." msgstr "Imposta lo stato di sola lettura per la transazione corrente." -#: utils/misc/guc.c:1375 +#: utils/misc/guc.c:1370 msgid "Sets the default deferrable status of new transactions." msgstr "Imposta lo stato predefinito deferibile per le nuove transazioni." -#: utils/misc/guc.c:1384 +#: utils/misc/guc.c:1379 msgid "Whether to defer a read-only serializable transaction until it can be executed with no possible serialization failures." msgstr "Indica se deferire una transazione serializzabile in sola lettura finché possa essere eseguita senza possibili fallimenti di serializzazione." -#: utils/misc/guc.c:1394 +#: utils/misc/guc.c:1389 msgid "Enable row security." msgstr "Abilita la sicurezza delle righe." -#: utils/misc/guc.c:1395 +#: utils/misc/guc.c:1390 msgid "When enabled, row security will be applied to all users." msgstr "Quando abilitata, la sicurezza delle righe verrà applicata a tutti gli utenti." -#: utils/misc/guc.c:1403 +#: utils/misc/guc.c:1398 msgid "Check function bodies during CREATE FUNCTION." msgstr "Esegui un controllo sulla definizione del corpo durante la CREATE FUNCTION." -#: utils/misc/guc.c:1412 +#: utils/misc/guc.c:1407 msgid "Enable input of NULL elements in arrays." msgstr "Abilita l'input di elementi NULL negli array." -#: utils/misc/guc.c:1413 +#: utils/misc/guc.c:1408 msgid "When turned on, unquoted NULL in an array input value means a null value; otherwise it is taken literally." msgstr "Se abilitato, un NULL senza apici come valore di input in un array indica un valore nullo; altrimenti è preso letteralmente." -#: utils/misc/guc.c:1423 +#: utils/misc/guc.c:1418 msgid "Create new tables with OIDs by default." msgstr "Crea le nuove tabella con gli OID in maniera predefinita." -#: utils/misc/guc.c:1432 +#: utils/misc/guc.c:1427 msgid "Start a subprocess to capture stderr output and/or csvlogs into log files." msgstr "Avvia un sottoprocesso per catturare in un file di log l'output di stderr e/o di csvlog." -#: utils/misc/guc.c:1441 +#: utils/misc/guc.c:1436 msgid "Truncate existing log files of same name during log rotation." msgstr "Tronca un file di log esistente con lo stesso nome durante la rotazione dei log." -#: utils/misc/guc.c:1452 +#: utils/misc/guc.c:1447 msgid "Emit information about resource usage in sorting." msgstr "Genera informazioni sull'uso delle risorse durante gli ordinamenti." -#: utils/misc/guc.c:1466 +#: utils/misc/guc.c:1461 msgid "Generate debugging output for synchronized scanning." msgstr "Genera output di debug per le scansioni sincronizzate." -#: utils/misc/guc.c:1481 +#: utils/misc/guc.c:1476 msgid "Enable bounded sorting using heap sort." msgstr "Abilita il bounded sorting usando lo heap sort." -#: utils/misc/guc.c:1494 +#: utils/misc/guc.c:1489 msgid "Emit WAL-related debugging output." msgstr "Genera output di debug relativo al WAL." -#: utils/misc/guc.c:1506 +#: utils/misc/guc.c:1501 msgid "Datetimes are integer based." msgstr "I valori di data e tempo sono basati su interi." -#: utils/misc/guc.c:1521 +#: utils/misc/guc.c:1516 msgid "Sets whether Kerberos and GSSAPI user names should be treated as case-insensitive." msgstr "Imposta se i nomi di utente con Kerberos e GSSAPI debbano essere trattati come case-insensitive." -#: utils/misc/guc.c:1531 +#: utils/misc/guc.c:1526 msgid "Warn about backslash escapes in ordinary string literals." msgstr "Avverti sull'uso degli escape con backslash nei letterali stringa ordinarie." -#: utils/misc/guc.c:1541 +#: utils/misc/guc.c:1536 msgid "Causes '...' strings to treat backslashes literally." msgstr "Fa sì che le stringhe '...' trattino i backslash letteralmente." -#: utils/misc/guc.c:1552 +#: utils/misc/guc.c:1547 msgid "Enable synchronized sequential scans." msgstr "Abilita le scansioni sequenziali sincronizzate." -#: utils/misc/guc.c:1562 +#: utils/misc/guc.c:1557 msgid "Allows connections and queries during recovery." msgstr "Consente connessioni e query durante il recupero" -#: utils/misc/guc.c:1572 +#: utils/misc/guc.c:1567 msgid "Allows feedback from a hot standby to the primary that will avoid query conflicts." msgstr "Consente un feedback da un hot standby al primario che eviterà conflitti di query" -#: utils/misc/guc.c:1582 +#: utils/misc/guc.c:1577 msgid "Allows modifications of the structure of system tables." msgstr "Consente le modifiche alla struttura delle tabelle di sistema." -#: utils/misc/guc.c:1593 +#: utils/misc/guc.c:1588 msgid "Disables reading from system indexes." msgstr "Disabilita la lettura dagli indici di sistema." -#: utils/misc/guc.c:1594 +#: utils/misc/guc.c:1589 msgid "It does not prevent updating the indexes, so it is safe to use. The worst consequence is slowness." msgstr "Non impedisce l'aggiornamento degli indici ed è perciò utilizzabile tranquillamente. Al peggio causa rallentamenti." -#: utils/misc/guc.c:1605 +#: utils/misc/guc.c:1600 msgid "Enables backward compatibility mode for privilege checks on large objects." msgstr "Abilita la modalità compatibile col passato del controllo dei privilegi sui large object." -#: utils/misc/guc.c:1606 +#: utils/misc/guc.c:1601 msgid "Skips privilege checks when reading or modifying large objects, for compatibility with PostgreSQL releases prior to 9.0." msgstr "Evita il controllo dei privilegi quando si leggono o modificano large object, per compatibilità con versioni di PostgreSQL precedenti la 9.0." -#: utils/misc/guc.c:1616 +#: utils/misc/guc.c:1611 msgid "Emit a warning for constructs that changed meaning since PostgreSQL 9.4." msgstr "Emetti un avviso per i costrutti che hanno cambiato significato da PostgreSQL 9.4." -#: utils/misc/guc.c:1626 +#: utils/misc/guc.c:1621 msgid "When generating SQL fragments, quote all identifiers." msgstr "Quando vengono generati frammenti SQL, metti tra virgolette tutti gli identificatori." -#: utils/misc/guc.c:1636 +#: utils/misc/guc.c:1631 msgid "Shows whether data checksums are turned on for this cluster." msgstr "Mostra se i checksum di dati sono attivi in questo cluster." -#: utils/misc/guc.c:1647 +#: utils/misc/guc.c:1642 msgid "Add sequence number to syslog messages to avoid duplicate suppression." msgstr "Aggiungi un numero sequenziale ai messaggi syslog per evitare la soppressione di duplicati." -#: utils/misc/guc.c:1657 +#: utils/misc/guc.c:1652 msgid "Split messages sent to syslog by lines and to fit into 1024 bytes." msgstr "Dividi i messaggi inviati a syslog in linee inferiori a 1024 byte." -#: utils/misc/guc.c:1676 +#: utils/misc/guc.c:1671 msgid "Forces a switch to the next xlog file if a new file has not been started within N seconds." msgstr "Forza il passaggio al successivo file xlog se un nuovo file non è avviato entro N secondi." -#: utils/misc/guc.c:1687 +#: utils/misc/guc.c:1682 msgid "Waits N seconds on connection startup after authentication." msgstr "Attendi N secondi all'avvio della connessione dopo l'autenticazione." -#: utils/misc/guc.c:1688 utils/misc/guc.c:2211 +#: utils/misc/guc.c:1683 utils/misc/guc.c:2206 msgid "This allows attaching a debugger to the process." msgstr "Ciò consente di agganciare un debugger al processo." -#: utils/misc/guc.c:1697 +#: utils/misc/guc.c:1692 msgid "Sets the default statistics target." msgstr "Definisce la destinazione delle statistiche di default." -#: utils/misc/guc.c:1698 +#: utils/misc/guc.c:1693 msgid "This applies to table columns that have not had a column-specific target set via ALTER TABLE SET STATISTICS." msgstr "Questo vale per le colonne di tabelle che non hanno definito una destinazione specifica per colonne per mezzo di un ALTER TABLE SET STATISTICS." -#: utils/misc/guc.c:1707 +#: utils/misc/guc.c:1702 msgid "Sets the FROM-list size beyond which subqueries are not collapsed." msgstr "Definisce la dimensione della lista FROM oltre la quale le sottoquery non vengono ridotte." -#: utils/misc/guc.c:1709 +#: utils/misc/guc.c:1704 msgid "The planner will merge subqueries into upper queries if the resulting FROM list would have no more than this many items." msgstr "Il planner fonderà le sottoquery nelle query superiori se la lista FROM risultante avrebbe non più di questi elementi." -#: utils/misc/guc.c:1719 +#: utils/misc/guc.c:1714 msgid "Sets the FROM-list size beyond which JOIN constructs are not flattened." msgstr "Definisce la dimensione della lista FROM oltre la quale i costrutti JOIN non vengono più appiattiti." -#: utils/misc/guc.c:1721 +#: utils/misc/guc.c:1716 msgid "The planner will flatten explicit JOIN constructs into lists of FROM items whenever a list of no more than this many items would result." msgstr "Il planner appiattisce i costrutti di JOIN espliciti in liste di elementi FROM ogni volta che ne risulterebbe una lista con non più di questi elementi." -#: utils/misc/guc.c:1731 +#: utils/misc/guc.c:1726 msgid "Sets the threshold of FROM items beyond which GEQO is used." msgstr "Definisce la soglia di elementi FROM oltre la quale viene usato il GEQO." -#: utils/misc/guc.c:1740 +#: utils/misc/guc.c:1735 msgid "GEQO: effort is used to set the default for other GEQO parameters." msgstr "GEQO: prova a definire i default per gli altri parametri di GEQO." -#: utils/misc/guc.c:1749 +#: utils/misc/guc.c:1744 msgid "GEQO: number of individuals in the population." msgstr "GEQO: numero di individui nella popolazione." -#: utils/misc/guc.c:1750 utils/misc/guc.c:1759 +#: utils/misc/guc.c:1745 utils/misc/guc.c:1754 msgid "Zero selects a suitable default value." msgstr "Lo zero selezione un valore ammissibile come default." -#: utils/misc/guc.c:1758 +#: utils/misc/guc.c:1753 msgid "GEQO: number of iterations of the algorithm." msgstr "GEQO: numero di iterazioni dell'algoritmo." -#: utils/misc/guc.c:1769 +#: utils/misc/guc.c:1764 msgid "Sets the time to wait on a lock before checking for deadlock." msgstr "Definisce il tempo di attesa su un lock prima di verificare si tratti di un deadlock." -#: utils/misc/guc.c:1780 +#: utils/misc/guc.c:1775 msgid "Sets the maximum delay before canceling queries when a hot standby server is processing archived WAL data." msgstr "Imposta l'intervallo massimo prima di annullare le query quando un server in hot standby sta processando dati da un WAL archiviato." -#: utils/misc/guc.c:1791 +#: utils/misc/guc.c:1786 msgid "Sets the maximum delay before canceling queries when a hot standby server is processing streamed WAL data." msgstr "Imposta l'intervallo massimo prima di annullare le query quando un server in hot standby sta processando dati da un WAL streamed." -#: utils/misc/guc.c:1802 +#: utils/misc/guc.c:1797 msgid "Sets the maximum interval between WAL receiver status reports to the primary." msgstr "Imposta l'intervallo massimo tra i rapporti di stato del ricevitore dei WAL al primario." -#: utils/misc/guc.c:1813 +#: utils/misc/guc.c:1808 msgid "Sets the maximum wait time to receive data from the primary." msgstr "Imposta un tempo massimo di attesa per la ricezione di dati dal primario." -#: utils/misc/guc.c:1824 +#: utils/misc/guc.c:1819 msgid "Sets the maximum number of concurrent connections." msgstr "Imposta il numero massimo di connessioni concorrenti." -#: utils/misc/guc.c:1834 +#: utils/misc/guc.c:1829 msgid "Sets the number of connection slots reserved for superusers." msgstr "Imposta il numero di slot per connessioni riservate ai superutenti." -#: utils/misc/guc.c:1848 +#: utils/misc/guc.c:1843 msgid "Sets the number of shared memory buffers used by the server." msgstr "Imposta il numero di buffer di memoria condivisa usati dal server." -#: utils/misc/guc.c:1859 +#: utils/misc/guc.c:1854 msgid "Sets the maximum number of temporary buffers used by each session." msgstr "Definisce il numero massimo di buffer temporanei usati da ogni sessione." -#: utils/misc/guc.c:1870 +#: utils/misc/guc.c:1865 msgid "Sets the TCP port the server listens on." msgstr "Imposta il numero di porta TCP sulla quale il server è in ascolto." -#: utils/misc/guc.c:1880 +#: utils/misc/guc.c:1875 msgid "Sets the access permissions of the Unix-domain socket." msgstr "Imposta i permessi di accesso del socket di dominio Unix." -#: utils/misc/guc.c:1881 +#: utils/misc/guc.c:1876 msgid "Unix-domain sockets use the usual Unix file system permission set. The parameter value is expected to be a numeric mode specification in the form accepted by the chmod and umask system calls. (To use the customary octal format the number must start with a 0 (zero).)" msgstr "I socket di dominio Unix utilizzano i normali permessi dei file system Unix. Il valore del parametro deve essere la specifica numerica dei permessi nella stessa forma accettata dalle chiamate di sistema chmod e umask. (Per usare il classico formato ottale, il valore numerico deve iniziare con 0 (zero).)" -#: utils/misc/guc.c:1895 +#: utils/misc/guc.c:1890 msgid "Sets the file permissions for log files." msgstr "Imposta i permessi dei file di log." -#: utils/misc/guc.c:1896 +#: utils/misc/guc.c:1891 msgid "The parameter value is expected to be a numeric mode specification in the form accepted by the chmod and umask system calls. (To use the customary octal format the number must start with a 0 (zero).)" msgstr "Il valore del parametro deve essere la specifica numerica dei permessi nella stessa forma accettata dalle chiamate di sistema chmod e umask. (Per usare il classico formato ottale, il valore numerico deve iniziare con 0 (zero).)" -#: utils/misc/guc.c:1909 +#: utils/misc/guc.c:1904 msgid "Sets the maximum memory to be used for query workspaces." msgstr "Imposta la quantità massima di memoria utilizzabile per gli spazi di lavoro delle query." -#: utils/misc/guc.c:1910 +#: utils/misc/guc.c:1905 msgid "This much memory can be used by each internal sort operation and hash table before switching to temporary disk files." msgstr "Questa quantità di memoria può essere utilizzata per ogni operazione di ordinamento interno e per ogni tabella hash prima di passare ai file temporanei su disco." -#: utils/misc/guc.c:1922 +#: utils/misc/guc.c:1917 msgid "Sets the maximum memory to be used for maintenance operations." msgstr "Imposta la quantità massima di memoria utilizzabile per le operazioni di manutenzione." -#: utils/misc/guc.c:1923 +#: utils/misc/guc.c:1918 msgid "This includes operations such as VACUUM and CREATE INDEX." msgstr "Queste includono operazioni quali VACUUM e CREATE INDEX." -#: utils/misc/guc.c:1933 +#: utils/misc/guc.c:1928 msgid "Sets the maximum number of tuples to be sorted using replacement selection." msgstr "Imposta il numero massimo di tuple che possono essere ordinate usando il rimpiazzo della selezione." -#: utils/misc/guc.c:1934 +#: utils/misc/guc.c:1929 msgid "When more tuples than this are present, quicksort will be used." msgstr "Quando un è presente un numero maggiore di tuple verrà usato quicksort." -#: utils/misc/guc.c:1948 +#: utils/misc/guc.c:1943 msgid "Sets the maximum stack depth, in kilobytes." msgstr "Imposta la profondità massima dello stack, in kilobyte." -#: utils/misc/guc.c:1959 -msgid "Limits the total size of all temporary files used by each session." -msgstr "Limita la dimensione totale di tutti i file temporanei usata da ogni sessione" +#: utils/misc/guc.c:1954 +msgid "Limits the total size of all temporary files used by each process." +msgstr "Limita la dimensione totale di tutti i file temporanei usata da ogni processo." -#: utils/misc/guc.c:1960 +#: utils/misc/guc.c:1955 msgid "-1 means no limit." msgstr "-1 vuol dire senza limiti." -#: utils/misc/guc.c:1970 +#: utils/misc/guc.c:1965 msgid "Vacuum cost for a page found in the buffer cache." msgstr "Costo del VACUUM per una pagina trovata nella cache dei buffer." -#: utils/misc/guc.c:1980 +#: utils/misc/guc.c:1975 msgid "Vacuum cost for a page not found in the buffer cache." msgstr "Costo del VACUUM per una pagina non trovata nella cache dei buffer." -#: utils/misc/guc.c:1990 +#: utils/misc/guc.c:1985 msgid "Vacuum cost for a page dirtied by vacuum." msgstr "Costo del VACUUM per una pagina resa sporca dal VACUUM." -#: utils/misc/guc.c:2000 +#: utils/misc/guc.c:1995 msgid "Vacuum cost amount available before napping." msgstr "Costo totale del VACUUM prima della pausa." -#: utils/misc/guc.c:2010 +#: utils/misc/guc.c:2005 msgid "Vacuum cost delay in milliseconds." msgstr "Il costo del VACUUM come ritardo in millisecondi." -#: utils/misc/guc.c:2021 +#: utils/misc/guc.c:2016 msgid "Vacuum cost delay in milliseconds, for autovacuum." msgstr "Il costo del VACUUM come ritardo in millisecondi, per l'autovacuum." -#: utils/misc/guc.c:2032 +#: utils/misc/guc.c:2027 msgid "Vacuum cost amount available before napping, for autovacuum." msgstr "Il costo totale del VACUUM prima della pausa, per l'autovacuum." -#: utils/misc/guc.c:2042 +#: utils/misc/guc.c:2037 msgid "Sets the maximum number of simultaneously open files for each server process." msgstr "Imposta il numero massimo di file aperti contemporaneamente per ogni processo server." -#: utils/misc/guc.c:2055 +#: utils/misc/guc.c:2050 msgid "Sets the maximum number of simultaneously prepared transactions." msgstr "Imposta il numero massimo di transazioni preparate contemporanee." -#: utils/misc/guc.c:2066 +#: utils/misc/guc.c:2061 msgid "Sets the minimum OID of tables for tracking locks." msgstr "Imposta l'OID minimo delle tabelle per tracciare i lock." -#: utils/misc/guc.c:2067 +#: utils/misc/guc.c:2062 msgid "Is used to avoid output on system tables." msgstr "È usato per evitare l'output su tabelle di sistema." -#: utils/misc/guc.c:2076 +#: utils/misc/guc.c:2071 msgid "Sets the OID of the table with unconditionally lock tracing." msgstr "Imposta l'OID delle tabelle con tracciamento dei lock non facoltativo." -#: utils/misc/guc.c:2088 +#: utils/misc/guc.c:2083 msgid "Sets the maximum allowed duration of any statement." msgstr "Imposta la durata massima consentita per qualsiasi istruzione." -#: utils/misc/guc.c:2089 utils/misc/guc.c:2100 utils/misc/guc.c:2111 +#: utils/misc/guc.c:2084 utils/misc/guc.c:2095 utils/misc/guc.c:2106 msgid "A value of 0 turns off the timeout." msgstr "Il valore 0 disabilita il timeout." -#: utils/misc/guc.c:2099 +#: utils/misc/guc.c:2094 msgid "Sets the maximum allowed duration of any wait for a lock." msgstr "Imposta la durata massima consentita di qualsiasi attesa per un lock." -#: utils/misc/guc.c:2110 +#: utils/misc/guc.c:2105 msgid "Sets the maximum allowed duration of any idling transaction." msgstr "Imposta la durata massima permessa per ogni transazione inattiva." -#: utils/misc/guc.c:2121 +#: utils/misc/guc.c:2116 msgid "Minimum age at which VACUUM should freeze a table row." msgstr "Anzianità minima alla quale il VACUUM deve congelare una riga di tabella." -#: utils/misc/guc.c:2131 +#: utils/misc/guc.c:2126 msgid "Age at which VACUUM should scan whole table to freeze tuples." msgstr "Anzianità alla quale il VACUUM deve scandire l'intera tabella per congelarne le tuple." -#: utils/misc/guc.c:2141 +#: utils/misc/guc.c:2136 msgid "Minimum age at which VACUUM should freeze a MultiXactId in a table row." msgstr "Anzianità minima alla quale VACUUM deve congelare un MultiXactId in una riga di tabella." -#: utils/misc/guc.c:2151 +#: utils/misc/guc.c:2146 msgid "Multixact age at which VACUUM should scan whole table to freeze tuples." msgstr "Anzianità del multixact alla quale VACUUM deve scandire tutta la tabella per congelare le tuple." -#: utils/misc/guc.c:2161 +#: utils/misc/guc.c:2156 msgid "Number of transactions by which VACUUM and HOT cleanup should be deferred, if any." msgstr "Numero di transazioni per cui VACUUM e pulizia HOT devono essere deferibili, se impostata." -#: utils/misc/guc.c:2174 +#: utils/misc/guc.c:2169 msgid "Sets the maximum number of locks per transaction." msgstr "Definisce il numero massimo di lock per transazione." -#: utils/misc/guc.c:2175 +#: utils/misc/guc.c:2170 msgid "The shared lock table is sized on the assumption that at most max_locks_per_transaction * max_connections distinct objects will need to be locked at any one time." msgstr "La tabella degli shared lock è dimensionata secondo l'assunzione che al massimo max_locks_per_transaction * max_connections distinti oggetti avranno bisogni di essere lockati in un determinato istante." -#: utils/misc/guc.c:2186 +#: utils/misc/guc.c:2181 msgid "Sets the maximum number of predicate locks per transaction." msgstr "Imposta il numero massimo di lock di predicato per transazione." -#: utils/misc/guc.c:2187 +#: utils/misc/guc.c:2182 msgid "The shared predicate lock table is sized on the assumption that at most max_pred_locks_per_transaction * max_connections distinct objects will need to be locked at any one time." msgstr "La tabella dei lock di predicato è dimensionata secondo l'assunzione che al massimo max_pred_locks_per_transaction * max_connections distinti oggetti avranno bisogni di essere lockati in un determinato istante." -#: utils/misc/guc.c:2198 +#: utils/misc/guc.c:2193 msgid "Sets the maximum allowed time to complete client authentication." msgstr "Imposta il tempo massimo consentito per completare l'autenticazione del client." -#: utils/misc/guc.c:2210 +#: utils/misc/guc.c:2205 msgid "Waits N seconds on connection startup before authentication." msgstr "Attendi N secondi all'avvio della connessione prima dell'autenticazione." -#: utils/misc/guc.c:2221 +#: utils/misc/guc.c:2216 msgid "Sets the number of WAL files held for standby servers." msgstr "Imposta il numero di file WAL trattenuti dai server in standby." -#: utils/misc/guc.c:2231 +#: utils/misc/guc.c:2226 msgid "Sets the minimum size to shrink the WAL to." msgstr "Imposta la dimensione minima a cui ridurre il file WAL." -#: utils/misc/guc.c:2242 +#: utils/misc/guc.c:2237 msgid "Sets the WAL size that triggers a checkpoint." msgstr "Imosta la dimensione del WAL che fa scattare un checkpoint." -#: utils/misc/guc.c:2253 +#: utils/misc/guc.c:2248 msgid "Sets the maximum time between automatic WAL checkpoints." msgstr "Imposta il tempo massimo intercorrente fra due checkpoint automatici del WAL." -#: utils/misc/guc.c:2264 +#: utils/misc/guc.c:2259 msgid "Enables warnings if checkpoint segments are filled more frequently than this." msgstr "Abilita gli avvertimenti se i segmenti dei checkpoint sono riempiti più frequentemente di questo valore." -#: utils/misc/guc.c:2266 +#: utils/misc/guc.c:2261 msgid "Write a message to the server log if checkpoints caused by the filling of checkpoint segment files happens more frequently than this number of seconds. Zero turns off the warning." msgstr "Scrive un messaggio nel log del server se i checkpoint dovuti al riempimento dei file dei segmenti dei checkpoint avvengono più frequentemente di questo numero di secondi. Il valore 0 (zero) disabilita questi avvisi." -#: utils/misc/guc.c:2278 +#: utils/misc/guc.c:2273 utils/misc/guc.c:2430 utils/misc/guc.c:2457 +msgid "Number of pages after which previously performed writes are flushed to disk." +msgstr "Numerp di pagine dopo il quale le scritture effettuate in precedenza sono scaricate su disco." + +#: utils/misc/guc.c:2284 msgid "Sets the number of disk-page buffers in shared memory for WAL." msgstr "Imposta il numero di buffer delle pagine su disco in shared memory per il WAL." -#: utils/misc/guc.c:2289 +#: utils/misc/guc.c:2295 msgid "Time between WAL flushes performed in the WAL writer." msgstr "Tempo tra due flush del WAL effettuati dal processo di scrittura WAL." -#: utils/misc/guc.c:2300 -msgid "Amount of WAL written out by WAL writer triggering a flush." -msgstr "Quantità di WAL emessa dal processo di scrittura che ha fatto scattare un flush." +#: utils/misc/guc.c:2306 +msgid "Amount of WAL written out by WAL writer that triggers a flush." +msgstr "Quantità di WAL da emettere dal processo di scrittura per far scattare un flush." -#: utils/misc/guc.c:2312 +#: utils/misc/guc.c:2318 msgid "Sets the maximum number of simultaneously running WAL sender processes." msgstr "Imposta il numero massimo di processi WAL sender in esecuzione simultanea." -#: utils/misc/guc.c:2323 +#: utils/misc/guc.c:2329 msgid "Sets the maximum number of simultaneously defined replication slots." msgstr "Imposta il numero massimo di slot di replica definiti simultaneamente." -#: utils/misc/guc.c:2333 +#: utils/misc/guc.c:2339 msgid "Sets the maximum time to wait for WAL replication." msgstr "Imposta il tempo di attesa massimo per una replica WAL." -#: utils/misc/guc.c:2344 +#: utils/misc/guc.c:2350 msgid "Sets the delay in microseconds between transaction commit and flushing WAL to disk." msgstr "Imposta il ritardo in microsecondi tra il commit della transazione e il flushing del WAL su disco." -#: utils/misc/guc.c:2356 +#: utils/misc/guc.c:2362 msgid "Sets the minimum concurrent open transactions before performing commit_delay." msgstr "Imposta il numero minimo di transazioni concorrenti aperte prima di eseguire un commit_delay" -#: utils/misc/guc.c:2367 +#: utils/misc/guc.c:2373 msgid "Sets the number of digits displayed for floating-point values." msgstr "Imposta il numero di cifre visualizzate per i valori in virgola mobile." -#: utils/misc/guc.c:2368 +#: utils/misc/guc.c:2374 msgid "This affects real, double precision, and geometric data types. The parameter value is added to the standard number of digits (FLT_DIG or DBL_DIG as appropriate)." msgstr "Ciò ha effetto sui tipi di dati real, double precision e geometrici. Il valore del parametro è sommato al numero standard di cifre (FLT_DIG o DBL_DIG a seconda dei casi)." -#: utils/misc/guc.c:2379 +#: utils/misc/guc.c:2385 msgid "Sets the minimum execution time above which statements will be logged." msgstr "Imposta il tempo minimo di esecuzione oltre il quale le istruzioni vengono registrate nel log." -#: utils/misc/guc.c:2381 +#: utils/misc/guc.c:2387 msgid "Zero prints all queries. -1 turns this feature off." msgstr "Il valore 0 (zero) fa sì che tutte le query siano registrate. Il valore -1 disabilita questa caratteristica." -#: utils/misc/guc.c:2391 +#: utils/misc/guc.c:2397 msgid "Sets the minimum execution time above which autovacuum actions will be logged." msgstr "Imposta il tempo minimo di esecuzione oltre il quale le azioni dell'autovacuum vengono registrate nel log." -#: utils/misc/guc.c:2393 +#: utils/misc/guc.c:2399 msgid "Zero prints all actions. -1 turns autovacuum logging off." msgstr "Il valore 0 (zero) fa sì che tutte le azioni siano registrate. Il valore -1 disabilita il logging dell'autovacuum." -#: utils/misc/guc.c:2403 +#: utils/misc/guc.c:2409 msgid "Background writer sleep time between rounds." msgstr "Il tempo di pausa fra due tornate del background writer." -#: utils/misc/guc.c:2414 +#: utils/misc/guc.c:2420 msgid "Background writer maximum number of LRU pages to flush per round." msgstr "Il numero massimo di pagine LRU che il background writer scarica ad ogni tornata." -#: utils/misc/guc.c:2426 +#: utils/misc/guc.c:2443 msgid "Number of simultaneous requests that can be handled efficiently by the disk subsystem." msgstr "Il numero di richieste simultanee che possono essere gestite con efficienza dal sottosistema a dischi." -#: utils/misc/guc.c:2427 +#: utils/misc/guc.c:2444 msgid "For RAID arrays, this should be approximately the number of drive spindles in the array." msgstr "Per i sistemi RAID, questo valore è pari all'incirca al numero di dischi fisici nell'array." -#: utils/misc/guc.c:2440 utils/misc/guc.c:2452 utils/misc/guc.c:2464 -msgid "Number of pages after which previously performed writes are flushed to disk." -msgstr "Numerp di pagine dopo il quale le scritture effettuate in precedenza sono scaricate su disco." - -#: utils/misc/guc.c:2478 +#: utils/misc/guc.c:2470 msgid "Maximum number of concurrent worker processes." msgstr "Numero massimo di processi worker concorrenti." -#: utils/misc/guc.c:2488 +#: utils/misc/guc.c:2480 msgid "Automatic log file rotation will occur after N minutes." msgstr "La rotazione automatica dei log avviene dopo N minuti." -#: utils/misc/guc.c:2499 +#: utils/misc/guc.c:2491 msgid "Automatic log file rotation will occur after N kilobytes." msgstr "La rotazione automatica dei log avviene dopo N kilobyte." -#: utils/misc/guc.c:2510 +#: utils/misc/guc.c:2502 msgid "Shows the maximum number of function arguments." msgstr "Mostra il numero massimo di argomenti delle funzioni." -#: utils/misc/guc.c:2521 +#: utils/misc/guc.c:2513 msgid "Shows the maximum number of index keys." msgstr "Mostra il numero massimo di chiavi degli indici." -#: utils/misc/guc.c:2532 +#: utils/misc/guc.c:2524 msgid "Shows the maximum identifier length." msgstr "Mostra la lunghezza massima per gli identificatori." -#: utils/misc/guc.c:2543 +#: utils/misc/guc.c:2535 msgid "Shows the size of a disk block." msgstr "Mostra la dimensione di un blocco su disco." -#: utils/misc/guc.c:2554 +#: utils/misc/guc.c:2546 msgid "Shows the number of pages per disk file." msgstr "Mostra il numero di pagine per file su disco." -#: utils/misc/guc.c:2565 +#: utils/misc/guc.c:2557 msgid "Shows the block size in the write ahead log." msgstr "Mostra la dimensione del log di write ahead." -#: utils/misc/guc.c:2576 +#: utils/misc/guc.c:2568 msgid "Sets the time to wait before retrying to retrieve WAL after a failed attempt." msgstr "Imposta il tempo di attesa prima di riprovare a recuperare un WAL dopo un tentativo fallito." -#: utils/misc/guc.c:2588 +#: utils/misc/guc.c:2580 msgid "Shows the number of pages per write ahead log segment." msgstr "Mostra il numero di pagine per un segmento del log di write ahead." -#: utils/misc/guc.c:2601 +#: utils/misc/guc.c:2593 msgid "Time to sleep between autovacuum runs." msgstr "Tempo di pausa fra due esecuzioni di autovacuum." -#: utils/misc/guc.c:2611 +#: utils/misc/guc.c:2603 msgid "Minimum number of tuple updates or deletes prior to vacuum." msgstr "Numero minimo di modifiche o cancellazioni di tuple prima dell'esecuzione di un autovacuum." -#: utils/misc/guc.c:2620 +#: utils/misc/guc.c:2612 msgid "Minimum number of tuple inserts, updates, or deletes prior to analyze." msgstr "Numero minimo di inserimenti, modifiche o cancellazioni di tuple prima dell'esecuzione di un analyze." -#: utils/misc/guc.c:2630 +#: utils/misc/guc.c:2622 msgid "Age at which to autovacuum a table to prevent transaction ID wraparound." msgstr "Anzianità alla quale eseguire un autovacuum su una tabella per prevenire il wraparound dell'ID delle transazioni." -#: utils/misc/guc.c:2641 +#: utils/misc/guc.c:2633 msgid "Multixact age at which to autovacuum a table to prevent multixact wraparound." msgstr "Anzianità multixaxt a cui eseguire l'autovacuum di una tabella per prevenire il wraparound del multixact." -#: utils/misc/guc.c:2651 +#: utils/misc/guc.c:2643 msgid "Sets the maximum number of simultaneously running autovacuum worker processes." msgstr "Imposta il numero massimo dei processi worker dell'autovacuum in esecuzione contemporanea." -#: utils/misc/guc.c:2661 +#: utils/misc/guc.c:2653 msgid "Sets the maximum number of parallel processes per executor node." msgstr "Imposta il numero massimo di processi paralleli per nodo di esecuzione." -#: utils/misc/guc.c:2671 +#: utils/misc/guc.c:2663 msgid "Sets the maximum memory to be used by each autovacuum worker process." msgstr "Imposta la memoria massima utilizzabile da ogni processo autovacuum." -#: utils/misc/guc.c:2682 +#: utils/misc/guc.c:2674 msgid "Time before a snapshot is too old to read pages changed after the snapshot was taken." msgstr "Tempo prima che uno snapshot sia troppo vecchio per leggere le pagine cambiate dopo che era stato effettuato." -#: utils/misc/guc.c:2683 +#: utils/misc/guc.c:2675 msgid "A value of -1 disables this feature." msgstr "Il valore -1 disabilita questa feature." -#: utils/misc/guc.c:2693 +#: utils/misc/guc.c:2685 msgid "Time between issuing TCP keepalives." msgstr "Tempo di attesa fra due keepalive TCP." -#: utils/misc/guc.c:2694 utils/misc/guc.c:2705 +#: utils/misc/guc.c:2686 utils/misc/guc.c:2697 msgid "A value of 0 uses the system default." msgstr "Il valore 0 (zero) fa sì che si applichi il valore predefinito di sistema." -#: utils/misc/guc.c:2704 +#: utils/misc/guc.c:2696 msgid "Time between TCP keepalive retransmits." msgstr "Tempo che intercorre fra due ritrasmissioni del keepalive TCP." -#: utils/misc/guc.c:2715 +#: utils/misc/guc.c:2707 msgid "SSL renegotiation is no longer supported; this can only be 0." msgstr "Il rinegoziamento SSL non è più supportato: può essere solo 0." -#: utils/misc/guc.c:2726 +#: utils/misc/guc.c:2718 msgid "Maximum number of TCP keepalive retransmits." msgstr "Numero massimo di ritrasmissioni del keepalive TCP." -#: utils/misc/guc.c:2727 +#: utils/misc/guc.c:2719 msgid "This controls the number of consecutive keepalive retransmits that can be lost before a connection is considered dead. A value of 0 uses the system default." msgstr "Ciò controlla il numero di ritrasmissioni consecutive del keepalive che possono andare perdute prima che una connessione sia considerata morta. Il valore 0 (zero) fa sì che si applichi il valore predefinito di sistema." -#: utils/misc/guc.c:2738 +#: utils/misc/guc.c:2730 msgid "Sets the maximum allowed result for exact search by GIN." msgstr "Imposta il risultato massimo consentito per le ricerche esatte tramite GIN." -#: utils/misc/guc.c:2749 +#: utils/misc/guc.c:2741 msgid "Sets the planner's assumption about the size of the disk cache." msgstr "Imposta le assunzioni del planner in merito alla dimensione della cache dei dischi." -#: utils/misc/guc.c:2750 +#: utils/misc/guc.c:2742 msgid "That is, the portion of the kernel's disk cache that will be used for PostgreSQL data files. This is measured in disk pages, which are normally 8 kB each." msgstr "Cioè la porzione della cache dei dischi nel kernel che sarà usata per i file dati di PostgreSQL. Viene misurata in pagine disco, che normalmente sono da 8 KB ciascuna." -#: utils/misc/guc.c:2763 +#: utils/misc/guc.c:2754 +msgid "Sets the minimum size of relations to be considered for parallel scan." +msgstr "Imposta la dimensione minima delle relazioni da considerare per una scansione parallela." + +#: utils/misc/guc.c:2766 msgid "Shows the server version as an integer." msgstr "Mostra la versione del server come un intero." -#: utils/misc/guc.c:2774 +#: utils/misc/guc.c:2777 msgid "Log the use of temporary files larger than this number of kilobytes." msgstr "Registra nel log l'uso di file temporanei più grandi di questo numero di kilobyte." -#: utils/misc/guc.c:2775 +#: utils/misc/guc.c:2778 msgid "Zero logs all files. The default is -1 (turning this feature off)." msgstr "Il valore 0 (zero) fa registrare tutti i file. Il default è -1 (che disabilita la registrazione)." -#: utils/misc/guc.c:2785 +#: utils/misc/guc.c:2788 msgid "Sets the size reserved for pg_stat_activity.query, in bytes." msgstr "Imposta la dimensione in byte riservata a pg_stat_activity.query." -#: utils/misc/guc.c:2800 +#: utils/misc/guc.c:2803 msgid "Sets the maximum size of the pending list for GIN index." msgstr "Imposta la dimensione massima della lista di attesa per gli indici GIN." -#: utils/misc/guc.c:2820 +#: utils/misc/guc.c:2823 msgid "Sets the planner's estimate of the cost of a sequentially fetched disk page." msgstr "Imposta la stima del planner del costo di una pagina di disco letta sequenzialmente." -#: utils/misc/guc.c:2830 +#: utils/misc/guc.c:2833 msgid "Sets the planner's estimate of the cost of a nonsequentially fetched disk page." msgstr "Imposta la stima del planner del costo di una pagina di disco letta non sequenzialmente." -#: utils/misc/guc.c:2840 +#: utils/misc/guc.c:2843 msgid "Sets the planner's estimate of the cost of processing each tuple (row)." msgstr "Imposta la stima del planner del costo di elaborazione di ogni tupla (riga)." -#: utils/misc/guc.c:2850 +#: utils/misc/guc.c:2853 msgid "Sets the planner's estimate of the cost of processing each index entry during an index scan." msgstr "Imposta la stima del il planner del costo di elaborazione di un singolo elemento di indice durante una scansione di indice." -#: utils/misc/guc.c:2860 +#: utils/misc/guc.c:2863 msgid "Sets the planner's estimate of the cost of processing each operator or function call." msgstr "Imposta la stima del planner del costo di elaborazione di un singolo operatore o chiamata di funzione." -#: utils/misc/guc.c:2870 +#: utils/misc/guc.c:2873 msgid "Sets the planner's estimate of the cost of passing each tuple (row) from worker to master backend." -msgstr "Imposta la stima del planner del costo di passare ogni tupla (riga) dal lavoratore al backend master." +msgstr "Imposta la stima del planner del costo di passare ogni tupla (riga) dal worker al backend master." -#: utils/misc/guc.c:2880 +#: utils/misc/guc.c:2883 msgid "Sets the planner's estimate of the cost of starting up worker processes for parallel query." msgstr "Imposta la stima del planner del costo di avvio dei processi worker per una query parallela." -#: utils/misc/guc.c:2891 +#: utils/misc/guc.c:2894 msgid "Sets the planner's estimate of the fraction of a cursor's rows that will be retrieved." msgstr "Imposta la stima del planner della frazione delle righe di un cursore che verranno lette." -#: utils/misc/guc.c:2902 +#: utils/misc/guc.c:2905 msgid "GEQO: selective pressure within the population." msgstr "GEQO: pressione selettiva all'interno della popolazione." -#: utils/misc/guc.c:2912 +#: utils/misc/guc.c:2915 msgid "GEQO: seed for random path selection." msgstr "GEQO: seme per la selezione casuale dei percorsi." -#: utils/misc/guc.c:2922 +#: utils/misc/guc.c:2925 msgid "Multiple of the average buffer usage to free per round." msgstr "Multiplo dell'utilizzo medio dei buffer da liberarsi ad ogni giro." -#: utils/misc/guc.c:2932 +#: utils/misc/guc.c:2935 msgid "Sets the seed for random-number generation." msgstr "Imposta il seme per la generazione di numeri casuali." -#: utils/misc/guc.c:2943 +#: utils/misc/guc.c:2946 msgid "Number of tuple updates or deletes prior to vacuum as a fraction of reltuples." msgstr "Il numero di modifiche o cancellazioni di tuple prima di un VACUUM, come frazione di reltuples." -#: utils/misc/guc.c:2952 +#: utils/misc/guc.c:2955 msgid "Number of tuple inserts, updates, or deletes prior to analyze as a fraction of reltuples." msgstr "Numero di inserimenti, modifiche o cancellazioni di tuple prima di un ANALYZE, come frazione di reltuples." -#: utils/misc/guc.c:2962 +#: utils/misc/guc.c:2965 msgid "Time spent flushing dirty buffers during checkpoint, as fraction of checkpoint interval." msgstr "Il tempo speso nell'eseguire il flush dei buffer sporchi durante i checkpoint, come frazione dell'intervallo di checkpoint." -#: utils/misc/guc.c:2981 +#: utils/misc/guc.c:2984 msgid "Sets the shell command that will be called to archive a WAL file." msgstr "Imposta il comando di shell che verrà eseguito per archiviare un file WAL." -#: utils/misc/guc.c:2991 +#: utils/misc/guc.c:2994 msgid "Sets the client's character set encoding." msgstr "Imposta la codifica dei caratteri del client." -#: utils/misc/guc.c:3002 +#: utils/misc/guc.c:3005 msgid "Controls information prefixed to each log line." msgstr "Controlla l'informazione usata come prefisso per ogni riga di log." -#: utils/misc/guc.c:3003 +#: utils/misc/guc.c:3006 msgid "If blank, no prefix is used." msgstr "Se lasciata vuota non sarà usato alcun prefisso." -#: utils/misc/guc.c:3012 +#: utils/misc/guc.c:3015 msgid "Sets the time zone to use in log messages." msgstr "Imposta il fuso orario da usarsi nei messaggi di log." -#: utils/misc/guc.c:3022 +#: utils/misc/guc.c:3025 msgid "Sets the display format for date and time values." msgstr "Imposta il formato per la visualizzazione dei valori di data e ora." -#: utils/misc/guc.c:3023 +#: utils/misc/guc.c:3026 msgid "Also controls interpretation of ambiguous date inputs." msgstr "Controlla anche l'interpretazione di input ambigui per le date." -#: utils/misc/guc.c:3034 +#: utils/misc/guc.c:3037 msgid "Sets the default tablespace to create tables and indexes in." msgstr "Imposta il tablespace di default in cui create tabelle e indici." -#: utils/misc/guc.c:3035 +#: utils/misc/guc.c:3038 msgid "An empty string selects the database's default tablespace." msgstr "Una stringa vuota selezione il tablespace predefinito del database." -#: utils/misc/guc.c:3045 +#: utils/misc/guc.c:3048 msgid "Sets the tablespace(s) to use for temporary tables and sort files." msgstr "Definisce i(l) tablespace da usarsi per le tabelle temporanee e i file di ordinamento." -#: utils/misc/guc.c:3056 +#: utils/misc/guc.c:3059 msgid "Sets the path for dynamically loadable modules." msgstr "Definisce il percorso per i moduli caricabili dinamicamente." -#: utils/misc/guc.c:3057 +#: utils/misc/guc.c:3060 msgid "If a dynamically loadable module needs to be opened and the specified name does not have a directory component (i.e., the name does not contain a slash), the system will search this path for the specified file." msgstr "Se si deve aprire un modulo caricabile dinamicamente e il nome specificato non contiene un percorso di directory (se non contiene uno slash) il sistema cercherà il file specificato in questo percorso." -#: utils/misc/guc.c:3070 +#: utils/misc/guc.c:3073 msgid "Sets the location of the Kerberos server key file." msgstr "Imposta la posizione del key file del server Kerberos." -#: utils/misc/guc.c:3081 +#: utils/misc/guc.c:3084 msgid "Sets the Bonjour service name." msgstr "Imposta il nome del servizio Bonjour." -#: utils/misc/guc.c:3093 +#: utils/misc/guc.c:3096 msgid "Shows the collation order locale." msgstr "Mostra la localizzazione dell'ordine di collazione." -#: utils/misc/guc.c:3104 +#: utils/misc/guc.c:3107 msgid "Shows the character classification and case conversion locale." msgstr "Mostra la localizzazione per la classificazione dei caratteri e la conversione maiuscole/minuscole." -#: utils/misc/guc.c:3115 +#: utils/misc/guc.c:3118 msgid "Sets the language in which messages are displayed." msgstr "Mostra la lingua in cui i messaggi sono visualizzati." -#: utils/misc/guc.c:3125 +#: utils/misc/guc.c:3128 msgid "Sets the locale for formatting monetary amounts." msgstr "Imposta la localizzazione per la formattazione delle quantità monetarie." -#: utils/misc/guc.c:3135 +#: utils/misc/guc.c:3138 msgid "Sets the locale for formatting numbers." msgstr "Imposta la localizzazione per la formattazione dei numeri." -#: utils/misc/guc.c:3145 +#: utils/misc/guc.c:3148 msgid "Sets the locale for formatting date and time values." msgstr "Imposta la localizzazione per la formattazione per i valori di tipo data e ora." -#: utils/misc/guc.c:3155 +#: utils/misc/guc.c:3158 msgid "Lists shared libraries to preload into each backend." msgstr "Imposta la lista delle librerie condivise da precaricare on ogni backend." -#: utils/misc/guc.c:3166 +#: utils/misc/guc.c:3169 msgid "Lists shared libraries to preload into server." msgstr "Imposta la lista delle librerie condivise da precaricare nel server." -#: utils/misc/guc.c:3177 +#: utils/misc/guc.c:3180 msgid "Lists unprivileged shared libraries to preload into each backend." msgstr "Imposta la lista delle librarie condivise non privilegiate da precaricare in ogni backend." -#: utils/misc/guc.c:3188 +#: utils/misc/guc.c:3191 msgid "Sets the schema search order for names that are not schema-qualified." msgstr "Imposta l'ordine di ricerca degli schema per i nomi che non hanno un qualifica di schema." -#: utils/misc/guc.c:3200 +#: utils/misc/guc.c:3203 msgid "Sets the server (database) character set encoding." msgstr "Imposta la codifica del set di caratteri per il server (database)." -#: utils/misc/guc.c:3212 +#: utils/misc/guc.c:3215 msgid "Shows the server version." msgstr "Mostra la versione del server." -#: utils/misc/guc.c:3224 +#: utils/misc/guc.c:3227 msgid "Sets the current role." msgstr "Mostra il ruolo corrente." -#: utils/misc/guc.c:3236 +#: utils/misc/guc.c:3239 msgid "Sets the session user name." msgstr "Mostra il nome dell'utente della sessione." -#: utils/misc/guc.c:3247 +#: utils/misc/guc.c:3250 msgid "Sets the destination for server log output." msgstr "Imposta la destinazione per l'output dei log del server." -#: utils/misc/guc.c:3248 +#: utils/misc/guc.c:3251 msgid "Valid values are combinations of \"stderr\", \"syslog\", \"csvlog\", and \"eventlog\", depending on the platform." msgstr "I valori validi sono combinazioni di \"stderr\", \"syslog\", \"csvlog\" ed \"eventlog\", a seconda delle piattaforme." -#: utils/misc/guc.c:3259 +#: utils/misc/guc.c:3262 msgid "Sets the destination directory for log files." msgstr "Imposta la directory di destinazione dei file di log." -#: utils/misc/guc.c:3260 +#: utils/misc/guc.c:3263 msgid "Can be specified as relative to the data directory or as absolute path." msgstr "Può essere specificata sia come relativa alla directory data sia come percorso assoluto." -#: utils/misc/guc.c:3270 +#: utils/misc/guc.c:3273 msgid "Sets the file name pattern for log files." msgstr "Imposta il pattern dei nomi dei file di log." -#: utils/misc/guc.c:3281 +#: utils/misc/guc.c:3284 msgid "Sets the program name used to identify PostgreSQL messages in syslog." msgstr "Imposta il nome del programma da utilizzato per identificare i messaggi di PostgreSQL in syslog." -#: utils/misc/guc.c:3292 +#: utils/misc/guc.c:3295 msgid "Sets the application name used to identify PostgreSQL messages in the event log." msgstr "Imposta il nome del programma da usarsi per identificare i messaggi di PostgreSQL nel registro degli eventi." -#: utils/misc/guc.c:3303 +#: utils/misc/guc.c:3306 msgid "Sets the time zone for displaying and interpreting time stamps." msgstr "Imposta il fuso orario per visualizzare ed interpretare gli orari." -#: utils/misc/guc.c:3313 +#: utils/misc/guc.c:3316 msgid "Selects a file of time zone abbreviations." msgstr "Seleziona un file contenente le abbreviazioni dei fusi orari." -#: utils/misc/guc.c:3323 +#: utils/misc/guc.c:3326 msgid "Sets the current transaction's isolation level." msgstr "Imposta il livello di isolamento per la transazione in corso." -#: utils/misc/guc.c:3334 +#: utils/misc/guc.c:3337 msgid "Sets the owning group of the Unix-domain socket." msgstr "Imposta il gruppo di appartenenza per i socket di dominio Unix." -#: utils/misc/guc.c:3335 +#: utils/misc/guc.c:3338 msgid "The owning user of the socket is always the user that starts the server." msgstr "L'utente che possiede il socket è sempre l'utente che ha avviato il server." -#: utils/misc/guc.c:3345 +#: utils/misc/guc.c:3348 msgid "Sets the directories where Unix-domain sockets will be created." msgstr "Imposta la directory dove i socket di dominio Unix verranno creati." -#: utils/misc/guc.c:3360 +#: utils/misc/guc.c:3363 msgid "Sets the host name or IP address(es) to listen to." msgstr "Imposta il nome host o gli indirizzi IP su cui ascoltare." -#: utils/misc/guc.c:3375 +#: utils/misc/guc.c:3378 msgid "Sets the server's data directory." msgstr "Imposta la posizione della directory dati" -#: utils/misc/guc.c:3386 +#: utils/misc/guc.c:3389 msgid "Sets the server's main configuration file." msgstr "Imposta il file primario di configurazione del server." -#: utils/misc/guc.c:3397 +#: utils/misc/guc.c:3400 msgid "Sets the server's \"hba\" configuration file." msgstr "Imposta il file di configurazione \"hba\" del server." -#: utils/misc/guc.c:3408 +#: utils/misc/guc.c:3411 msgid "Sets the server's \"ident\" configuration file." msgstr "Imposta il file di configurazione \"ident\" del server." -#: utils/misc/guc.c:3419 +#: utils/misc/guc.c:3422 msgid "Writes the postmaster PID to the specified file." msgstr "Scrivi il PID del postmaster nel file specificato." -#: utils/misc/guc.c:3430 +#: utils/misc/guc.c:3433 msgid "Location of the SSL server certificate file." msgstr "Posizione del file di certificati del server SSL." -#: utils/misc/guc.c:3440 +#: utils/misc/guc.c:3443 msgid "Location of the SSL server private key file." msgstr "Posizione del file della chiave privata del server SSL." -#: utils/misc/guc.c:3450 +#: utils/misc/guc.c:3453 msgid "Location of the SSL certificate authority file." msgstr "Posizione del file di autorità dei certificati del server SSL." -#: utils/misc/guc.c:3460 +#: utils/misc/guc.c:3463 msgid "Location of the SSL certificate revocation list file." msgstr "Posizione del file della lista di revoche di certificati SSL." -#: utils/misc/guc.c:3470 +#: utils/misc/guc.c:3473 msgid "Writes temporary statistics files to the specified directory." msgstr "Scrive i file di statistiche temporanee nella directory specificata." -#: utils/misc/guc.c:3481 +#: utils/misc/guc.c:3484 msgid "Number of synchronous standbys and list of names of potential synchronous ones." msgstr "Numero di standby sincroni e lista dei nomi di quelli potenziali sincroni." -#: utils/misc/guc.c:3492 +#: utils/misc/guc.c:3495 msgid "Sets default text search configuration." msgstr "Imposta la configurazione di ricerca di testo predefinita." -#: utils/misc/guc.c:3502 +#: utils/misc/guc.c:3505 msgid "Sets the list of allowed SSL ciphers." msgstr "Imposta la lista di codici SSL consentiti." -#: utils/misc/guc.c:3517 +#: utils/misc/guc.c:3520 msgid "Sets the curve to use for ECDH." msgstr "Imposta la curva da usare per l'ECHD." -#: utils/misc/guc.c:3532 +#: utils/misc/guc.c:3535 msgid "Sets the application name to be reported in statistics and logs." msgstr "Imposta il nome dell'applicazione da riportare nelle statistiche e nei log." -#: utils/misc/guc.c:3543 +#: utils/misc/guc.c:3546 msgid "Sets the name of the cluster, which is included in the process title." msgstr "Imposta il nome del cluster, che è incluso nel titolo del processo." -#: utils/misc/guc.c:3563 +#: utils/misc/guc.c:3566 msgid "Sets whether \"\\'\" is allowed in string literals." msgstr "Imposta se \"\\'\" è consentito nei letterali stringa." -#: utils/misc/guc.c:3573 +#: utils/misc/guc.c:3576 msgid "Sets the output format for bytea." msgstr "Imposta il formato di output di bytea." -#: utils/misc/guc.c:3583 +#: utils/misc/guc.c:3586 msgid "Sets the message levels that are sent to the client." msgstr "Imposta quali livelli di messaggi sono inviati al client" -#: utils/misc/guc.c:3584 utils/misc/guc.c:3637 utils/misc/guc.c:3648 -#: utils/misc/guc.c:3714 +#: utils/misc/guc.c:3587 utils/misc/guc.c:3640 utils/misc/guc.c:3651 +#: utils/misc/guc.c:3717 msgid "Each level includes all the levels that follow it. The later the level, the fewer messages are sent." msgstr "Ogni livello include tutti i livelli che lo seguono. Più avanti il livello, meno messaggi sono inviati." -#: utils/misc/guc.c:3594 +#: utils/misc/guc.c:3597 msgid "Enables the planner to use constraints to optimize queries." msgstr "Permette al planner di usare i vincoli per ottimizzare le query." -#: utils/misc/guc.c:3595 +#: utils/misc/guc.c:3598 msgid "Table scans will be skipped if their constraints guarantee that no rows match the query." msgstr "La scansioni delle tabelle saranno evitate se i loro vincoli garantiscono che nessuna riga corrisponda con la query." -#: utils/misc/guc.c:3605 +#: utils/misc/guc.c:3608 msgid "Sets the transaction isolation level of each new transaction." msgstr "Imposta il livello di isolamento predefinito per ogni nuova transazione." -#: utils/misc/guc.c:3615 +#: utils/misc/guc.c:3618 msgid "Sets the display format for interval values." msgstr "Imposta il formato di visualizzazione per intervalli." -#: utils/misc/guc.c:3626 +#: utils/misc/guc.c:3629 msgid "Sets the verbosity of logged messages." msgstr "Imposta la prolissità dei messaggi registrati." -#: utils/misc/guc.c:3636 +#: utils/misc/guc.c:3639 msgid "Sets the message levels that are logged." msgstr "Imposta i livelli dei messaggi registrati." -#: utils/misc/guc.c:3647 +#: utils/misc/guc.c:3650 msgid "Causes all statements generating error at or above this level to be logged." msgstr "Fa in modo che tutti gli eventi che generano errore a questo livello o a un livello superiore siano registrati nel log." -#: utils/misc/guc.c:3658 +#: utils/misc/guc.c:3661 msgid "Sets the type of statements logged." msgstr "Imposta il tipo di istruzioni registrato nel log." -#: utils/misc/guc.c:3668 +#: utils/misc/guc.c:3671 msgid "Sets the syslog \"facility\" to be used when syslog enabled." msgstr "Imposta la \"facility\" da usare quando syslog è abilitato." -#: utils/misc/guc.c:3683 +#: utils/misc/guc.c:3686 msgid "Sets the session's behavior for triggers and rewrite rules." msgstr "Imposta il comportamento delle sessioni per i trigger e le regole di riscrittura." -#: utils/misc/guc.c:3693 +#: utils/misc/guc.c:3696 msgid "Sets the current transaction's synchronization level." msgstr "Imposta il livello di sincronizzazione della transazione corrente." -#: utils/misc/guc.c:3703 +#: utils/misc/guc.c:3706 msgid "Allows archiving of WAL files using archive_command." msgstr "Consente l'archiviazione dei file WAL con l'uso di archive_command." -#: utils/misc/guc.c:3713 +#: utils/misc/guc.c:3716 msgid "Enables logging of recovery-related debugging information." msgstr "Abilita il logging di informazioni di debug relative al recupero." -#: utils/misc/guc.c:3729 +#: utils/misc/guc.c:3732 msgid "Collects function-level statistics on database activity." msgstr "Raccogli statistiche al livello di funzioni sull'attività del database." -#: utils/misc/guc.c:3739 +#: utils/misc/guc.c:3742 msgid "Set the level of information written to the WAL." msgstr "Imposta il livello delle informazioni scritte nel WAL." -#: utils/misc/guc.c:3749 +#: utils/misc/guc.c:3752 msgid "Selects the dynamic shared memory implementation used." msgstr "Seleziona l'implementazione di memoria dinamica condivisa utilizzata." -#: utils/misc/guc.c:3759 +#: utils/misc/guc.c:3762 msgid "Selects the method used for forcing WAL updates to disk." msgstr "Seleziona il metodo usato per forzare aggiornamenti WAL su disco." -#: utils/misc/guc.c:3769 +#: utils/misc/guc.c:3772 msgid "Sets how binary values are to be encoded in XML." msgstr "imposta come i valori binari devono essere codificati nel formato XML." -#: utils/misc/guc.c:3779 +#: utils/misc/guc.c:3782 msgid "Sets whether XML data in implicit parsing and serialization operations is to be considered as documents or content fragments." msgstr "Imposta se qualunque dato XML nelle operazioni di parsing e serializzazione implicite debba essere considerato come un documento o frammento di un contenuto." -#: utils/misc/guc.c:3790 +#: utils/misc/guc.c:3793 msgid "Use of huge pages on Linux." msgstr "Uso delle pagine huge su Linux." -#: utils/misc/guc.c:3800 +#: utils/misc/guc.c:3803 msgid "Forces use of parallel query facilities." msgstr "Forza l'uso delle query parallele." -#: utils/misc/guc.c:3801 +#: utils/misc/guc.c:3804 msgid "If possible, run query using a parallel worker and with parallel restrictions." msgstr "Se possibile, effettua le query usando worker paralleli e con restrizioni di parallelismo." -#: utils/misc/guc.c:4601 +#: utils/misc/guc.c:4604 #, c-format msgid "%s: could not access directory \"%s\": %s\n" msgstr "%s: accesso alla directory \"%s\" fallito: %s\n" -#: utils/misc/guc.c:4606 +#: utils/misc/guc.c:4609 #, c-format msgid "Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n" msgstr "Esegui initdb o pg_basebackup per inizializzare una directory di dati PostgreSQL.\n" -#: utils/misc/guc.c:4626 +#: utils/misc/guc.c:4629 #, c-format msgid "" "%s does not know where to find the server configuration file.\n" @@ -22388,12 +22388,12 @@ msgstr "" "%s non sa dove trovare il file di configurazione del server.\n" "Devi specificare le opzioni --config-file o -D, oppure impostare la variabile d'ambiente PGDATA.\n" -#: utils/misc/guc.c:4645 +#: utils/misc/guc.c:4648 #, c-format msgid "%s: could not access the server configuration file \"%s\": %s\n" msgstr "%s: accesso al file di configurazione del server \"%s\" fallito: %s\n" -#: utils/misc/guc.c:4671 +#: utils/misc/guc.c:4674 #, c-format msgid "" "%s does not know where to find the database system data.\n" @@ -22402,7 +22402,7 @@ msgstr "" "%s non sa dove trovare i dati di sistema del database.\n" "Possono essere specificati come \"data_directory\" in \"%s\", oppure dall'opzione -D, oppure dalla variabile d'ambiente PGDATA.\n" -#: utils/misc/guc.c:4719 +#: utils/misc/guc.c:4722 #, c-format msgid "" "%s does not know where to find the \"hba\" configuration file.\n" @@ -22411,7 +22411,7 @@ msgstr "" "%s non sa dove trovare il file di configurazione \"hba\".\n" "Può essere specificato come \"hba_file\" in \"%s\", oppure dall'opzione -D, oppure dalla variabile d'ambiente PGDATA.\n" -#: utils/misc/guc.c:4742 +#: utils/misc/guc.c:4745 #, c-format msgid "" "%s does not know where to find the \"ident\" configuration file.\n" @@ -22420,145 +22420,145 @@ msgstr "" "%s non sa dove trovare il file di configurazione \"ident\".\n" "Può essere specificato come \"ident_file\" in \"%s\", oppure dall'opzione -D, oppure dalla variabile d'ambiente PGDATA.\n" -#: utils/misc/guc.c:5416 utils/misc/guc.c:5463 +#: utils/misc/guc.c:5419 utils/misc/guc.c:5466 msgid "Value exceeds integer range." msgstr "Il valore non rientra nel limite possibile per gli interi." -#: utils/misc/guc.c:5686 +#: utils/misc/guc.c:5689 #, c-format msgid "parameter \"%s\" requires a numeric value" msgstr "il parametro \"%s\" richiede un valore numerico" -#: utils/misc/guc.c:5695 +#: utils/misc/guc.c:5698 #, c-format msgid "%g is outside the valid range for parameter \"%s\" (%g .. %g)" msgstr "%g non è compreso nell'intervallo di validità del il parametro \"%s\" (%g .. %g)" -#: utils/misc/guc.c:5848 utils/misc/guc.c:7190 +#: utils/misc/guc.c:5851 utils/misc/guc.c:7194 #, c-format msgid "cannot set parameters during a parallel operation" msgstr "non è possibile impostare parametri durante un'operazione parallela" -#: utils/misc/guc.c:5855 utils/misc/guc.c:6605 utils/misc/guc.c:6657 -#: utils/misc/guc.c:7018 utils/misc/guc.c:7778 utils/misc/guc.c:7946 -#: utils/misc/guc.c:9603 +#: utils/misc/guc.c:5858 utils/misc/guc.c:6609 utils/misc/guc.c:6661 +#: utils/misc/guc.c:7022 utils/misc/guc.c:7782 utils/misc/guc.c:7950 +#: utils/misc/guc.c:9625 #, c-format msgid "unrecognized configuration parameter \"%s\"" msgstr "parametro di configurazione \"%s\" sconosciuto" -#: utils/misc/guc.c:5870 utils/misc/guc.c:7030 +#: utils/misc/guc.c:5873 utils/misc/guc.c:7034 #, c-format msgid "parameter \"%s\" cannot be changed" msgstr "il parametro \"%s\" non può essere cambiato" -#: utils/misc/guc.c:5893 utils/misc/guc.c:6085 utils/misc/guc.c:6175 -#: utils/misc/guc.c:6265 utils/misc/guc.c:6373 utils/misc/guc.c:6468 -#: guc-file.l:352 +#: utils/misc/guc.c:5896 utils/misc/guc.c:6089 utils/misc/guc.c:6179 +#: utils/misc/guc.c:6269 utils/misc/guc.c:6377 utils/misc/guc.c:6472 +#: guc-file.l:350 #, c-format msgid "parameter \"%s\" cannot be changed without restarting the server" msgstr "il parametro \"%s\" non può essere cambiato senza riavviare il server" -#: utils/misc/guc.c:5903 +#: utils/misc/guc.c:5906 #, c-format msgid "parameter \"%s\" cannot be changed now" msgstr "il parametro \"%s\" non può essere cambiato ora" -#: utils/misc/guc.c:5921 utils/misc/guc.c:5966 utils/misc/guc.c:9619 +#: utils/misc/guc.c:5924 utils/misc/guc.c:5970 utils/misc/guc.c:9641 #, c-format msgid "permission denied to set parameter \"%s\"" msgstr "permesso di impostare il parametro \"%s\" negato" -#: utils/misc/guc.c:5956 +#: utils/misc/guc.c:5960 #, c-format msgid "parameter \"%s\" cannot be set after connection start" msgstr "il parametro \"%s\" non può essere impostato dopo l'avvio della connessione" -#: utils/misc/guc.c:6004 +#: utils/misc/guc.c:6008 #, c-format msgid "cannot set parameter \"%s\" within security-definer function" msgstr "il parametro \"%s\" non può essere impostato da una funzione che ha i privilegi del creatore" -#: utils/misc/guc.c:6613 utils/misc/guc.c:6661 utils/misc/guc.c:7952 +#: utils/misc/guc.c:6617 utils/misc/guc.c:6665 utils/misc/guc.c:7956 #, c-format msgid "must be superuser to examine \"%s\"" msgstr "solo un superutente può esaminare \"%s\"" -#: utils/misc/guc.c:6727 +#: utils/misc/guc.c:6731 #, c-format msgid "SET %s takes only one argument" msgstr "SET %s accetta un unico argomento" -#: utils/misc/guc.c:6978 +#: utils/misc/guc.c:6982 #, c-format msgid "must be superuser to execute ALTER SYSTEM command" msgstr "solo un superutente può eseguire il comando ALTER SYSTEM" -#: utils/misc/guc.c:7063 +#: utils/misc/guc.c:7067 #, c-format msgid "parameter value for ALTER SYSTEM must not contain a newline" msgstr "il valore del parametro di ALTER SYSTEM non può contenere un \"a capo\"" -#: utils/misc/guc.c:7108 +#: utils/misc/guc.c:7112 #, c-format msgid "could not parse contents of file \"%s\"" msgstr "non è possibile analizzare il contenuto del file \"%s\"" -#: utils/misc/guc.c:7266 +#: utils/misc/guc.c:7270 #, c-format msgid "SET LOCAL TRANSACTION SNAPSHOT is not implemented" msgstr "SET LOCAL TRANSACTION SNAPSHOT non è implementato" -#: utils/misc/guc.c:7351 +#: utils/misc/guc.c:7355 #, c-format msgid "SET requires parameter name" msgstr "SET richiede il nome del parametro" -#: utils/misc/guc.c:7475 +#: utils/misc/guc.c:7479 #, c-format msgid "attempt to redefine parameter \"%s\"" msgstr "tentativo di ridefinire il parametro \"%s\"" -#: utils/misc/guc.c:9236 +#: utils/misc/guc.c:9258 #, c-format msgid "parameter \"%s\" could not be set" msgstr "il parametro \"%s\" non può essere impostato" -#: utils/misc/guc.c:9323 +#: utils/misc/guc.c:9345 #, c-format msgid "could not parse setting for parameter \"%s\"" msgstr "non è stato possibile interpretare l'impostazione del parametro \"%s\"" -#: utils/misc/guc.c:9681 utils/misc/guc.c:9715 +#: utils/misc/guc.c:9703 utils/misc/guc.c:9737 #, c-format msgid "invalid value for parameter \"%s\": %d" msgstr "valore non valido per il parametro \"%s\": %d" -#: utils/misc/guc.c:9749 +#: utils/misc/guc.c:9771 #, c-format msgid "invalid value for parameter \"%s\": %g" msgstr "valore non valido per il parametro \"%s\": %g" -#: utils/misc/guc.c:9939 +#: utils/misc/guc.c:9961 #, c-format msgid "\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session." msgstr "\"temp_buffers\" non può essere modificato dopo che la sessione ha utilizzato qualsiasi tabella temporanea." -#: utils/misc/guc.c:9951 +#: utils/misc/guc.c:9973 #, c-format msgid "Bonjour is not supported by this build" msgstr "Bonjour non è supportato in questo binario" -#: utils/misc/guc.c:9964 +#: utils/misc/guc.c:9986 #, c-format msgid "SSL is not supported by this build" msgstr "SSL non è supportato in questo binario" -#: utils/misc/guc.c:9976 +#: utils/misc/guc.c:9998 #, c-format msgid "Cannot enable parameter when \"log_statement_stats\" is true." msgstr "Non è possibile abilitare il parametro quando \"log_statement_stats\" è abilitato." -#: utils/misc/guc.c:9988 +#: utils/misc/guc.c:10010 #, c-format msgid "Cannot enable \"log_statement_stats\" when \"log_parser_stats\", \"log_planner_stats\", or \"log_executor_stats\" is true." msgstr "Non è possibile abilitare \"log_statement_stats\" quando \"log_parser_stats\", \"log_planner_stats\" o \"log_executor_stats\" sono abilitati." @@ -22653,40 +22653,40 @@ msgstr "la riga è troppo lunga nel file di fusi orari \"%s\", riga %d" msgid "@INCLUDE without file name in time zone file \"%s\", line %d" msgstr "@INCLUDE senza nome del file nel file di fusi orari \"%s\", riga %d" -#: utils/mmgr/aset.c:506 +#: utils/mmgr/aset.c:510 #, c-format msgid "Failed while creating memory context \"%s\"." msgstr "Errore durante la creazione del contesto di memoria \"%s\"." -#: utils/mmgr/mcxt.c:771 utils/mmgr/mcxt.c:806 utils/mmgr/mcxt.c:843 -#: utils/mmgr/mcxt.c:880 utils/mmgr/mcxt.c:914 utils/mmgr/mcxt.c:943 -#: utils/mmgr/mcxt.c:977 utils/mmgr/mcxt.c:1059 utils/mmgr/mcxt.c:1093 -#: utils/mmgr/mcxt.c:1142 +#: utils/mmgr/mcxt.c:768 utils/mmgr/mcxt.c:803 utils/mmgr/mcxt.c:840 +#: utils/mmgr/mcxt.c:877 utils/mmgr/mcxt.c:911 utils/mmgr/mcxt.c:940 +#: utils/mmgr/mcxt.c:974 utils/mmgr/mcxt.c:1056 utils/mmgr/mcxt.c:1090 +#: utils/mmgr/mcxt.c:1139 #, c-format msgid "Failed on request of size %zu." msgstr "Errore durante la richiesta di dimensione %zu." -#: utils/mmgr/portalmem.c:208 +#: utils/mmgr/portalmem.c:207 #, c-format msgid "cursor \"%s\" already exists" msgstr "il cursore \"%s\" esiste già" -#: utils/mmgr/portalmem.c:212 +#: utils/mmgr/portalmem.c:211 #, c-format msgid "closing existing cursor \"%s\"" msgstr "chiusura del cursore esistente \"%s\"" -#: utils/mmgr/portalmem.c:419 +#: utils/mmgr/portalmem.c:415 #, c-format msgid "portal \"%s\" cannot be run" msgstr "il portale \"%s\" non può essere eseguito" -#: utils/mmgr/portalmem.c:499 +#: utils/mmgr/portalmem.c:495 #, c-format msgid "cannot drop active portal \"%s\"" msgstr "non è possibile eliminare il portale attivo \"%s\"" -#: utils/mmgr/portalmem.c:689 +#: utils/mmgr/portalmem.c:699 #, c-format msgid "cannot PREPARE a transaction that has created a cursor WITH HOLD" msgstr "non è possibile eseguire PREPARE in una transazione che ha creato un cursore WITH HOLD" @@ -22696,22 +22696,22 @@ msgstr "non è possibile eseguire PREPARE in una transazione che ha creato un cu msgid "could not read block %ld of temporary file: %m" msgstr "lettura del blocco %ld dal file temporaneo fallita: %m" -#: utils/sort/tuplesort.c:3360 +#: utils/sort/tuplesort.c:3402 #, c-format msgid "cannot have more than %d runs for an external sort" msgstr "non è possibile avere più di %d esecuzioni per un sort esterno" -#: utils/sort/tuplesort.c:4416 +#: utils/sort/tuplesort.c:4474 #, c-format msgid "could not create unique index \"%s\"" msgstr "creazione dell'indice univoco \"%s\" fallita" -#: utils/sort/tuplesort.c:4418 +#: utils/sort/tuplesort.c:4476 #, c-format msgid "Key %s is duplicated." msgstr "La chiave %s è duplicata." -#: utils/sort/tuplesort.c:4419 +#: utils/sort/tuplesort.c:4477 #, c-format msgid "Duplicate keys exist." msgstr "Esistono chiavi duplicate." @@ -22737,52 +22737,52 @@ msgstr "lettura dal file temporaneo tuplestore fallita: %m" msgid "could not write to tuplestore temporary file: %m" msgstr "scrittura nel file temporaneo tuplestore fallita: %m" -#: utils/time/snapmgr.c:536 +#: utils/time/snapmgr.c:618 #, c-format msgid "The source transaction is not running anymore." msgstr "La transazione di origine non è più in esecuzione." # translator: %s represents an SQL statement name -#: utils/time/snapmgr.c:1090 +#: utils/time/snapmgr.c:1190 #, c-format msgid "cannot export a snapshot from a subtransaction" msgstr "non è possibile esportare uno snapshot da una sotto-transazione" -#: utils/time/snapmgr.c:1239 utils/time/snapmgr.c:1244 -#: utils/time/snapmgr.c:1249 utils/time/snapmgr.c:1264 -#: utils/time/snapmgr.c:1269 utils/time/snapmgr.c:1274 -#: utils/time/snapmgr.c:1373 utils/time/snapmgr.c:1389 -#: utils/time/snapmgr.c:1414 +#: utils/time/snapmgr.c:1339 utils/time/snapmgr.c:1344 +#: utils/time/snapmgr.c:1349 utils/time/snapmgr.c:1364 +#: utils/time/snapmgr.c:1369 utils/time/snapmgr.c:1374 +#: utils/time/snapmgr.c:1473 utils/time/snapmgr.c:1489 +#: utils/time/snapmgr.c:1514 #, c-format msgid "invalid snapshot data in file \"%s\"" msgstr "dati dello snapshot non validi nel file \"%s\"" -#: utils/time/snapmgr.c:1311 +#: utils/time/snapmgr.c:1411 #, c-format msgid "SET TRANSACTION SNAPSHOT must be called before any query" msgstr "SET TRANSACTION SNAPSHOT dev'essere invocato prima di qualunque query" -#: utils/time/snapmgr.c:1320 +#: utils/time/snapmgr.c:1420 #, c-format msgid "a snapshot-importing transaction must have isolation level SERIALIZABLE or REPEATABLE READ" msgstr "una transazione che importa uno snapshot deve avere livello di isolamento SERIALIZABLE o REPEATABLE READ" -#: utils/time/snapmgr.c:1329 utils/time/snapmgr.c:1338 +#: utils/time/snapmgr.c:1429 utils/time/snapmgr.c:1438 #, c-format msgid "invalid snapshot identifier: \"%s\"" msgstr "identificativo di snapshot non valido: \"%s\"" -#: utils/time/snapmgr.c:1427 +#: utils/time/snapmgr.c:1527 #, c-format msgid "a serializable transaction cannot import a snapshot from a non-serializable transaction" msgstr "una transazione serializzabile non può importare uno snapshot da una transazione non serializzabile" -#: utils/time/snapmgr.c:1431 +#: utils/time/snapmgr.c:1531 #, c-format msgid "a non-read-only serializable transaction cannot import a snapshot from a read-only transaction" msgstr "una transazione non di sola lettura non può importare uno snapshot da una transazione di sola lettura" -#: utils/time/snapmgr.c:1446 +#: utils/time/snapmgr.c:1546 #, c-format msgid "cannot import a snapshot from a different database" msgstr "non è possibile importare uno snapshot da un database diverso" @@ -22792,303 +22792,308 @@ msgstr "non è possibile importare uno snapshot da un database diverso" msgid "unrecognized role option \"%s\"" msgstr "opzione di ruolo \"%s\" sconosciuta" -#: gram.y:1280 gram.y:1295 +#: gram.y:1278 gram.y:1293 #, c-format msgid "CREATE SCHEMA IF NOT EXISTS cannot include schema elements" msgstr "CREATE SCHEMA IF NOT EXISTS non può includere elementi dello schema" -#: gram.y:1440 +#: gram.y:1438 #, c-format msgid "current database cannot be changed" msgstr "il database corrente non può essere cambiato" -#: gram.y:1564 +#: gram.y:1562 #, c-format msgid "time zone interval must be HOUR or HOUR TO MINUTE" msgstr "l'intervallo della time zone deve essere HOUR o HOUR TO MINUTE" -#: gram.y:2602 gram.y:2631 +#: gram.y:2600 gram.y:2629 #, c-format msgid "STDIN/STDOUT not allowed with PROGRAM" msgstr "STDIN/STDOUT non sono consentiti con PROGRAM" -#: gram.y:2897 gram.y:2904 gram.y:10275 gram.y:10283 +#: gram.y:2895 gram.y:2902 gram.y:10295 gram.y:10303 #, c-format msgid "GLOBAL is deprecated in temporary table creation" msgstr "GLOBAL è deprecato nella creazione di tabelle temporanee" -#: gram.y:4800 +#: gram.y:4809 msgid "duplicate trigger events specified" msgstr "evento del trigger specificato più volte" -#: gram.y:4900 +#: gram.y:4909 #, c-format msgid "conflicting constraint properties" msgstr "proprietà del vincolo in conflitto" -#: gram.y:5032 +#: gram.y:5041 #, c-format msgid "CREATE ASSERTION is not yet implemented" msgstr "CREATE ASSERTION non è stata ancora implementata" -#: gram.y:5048 +#: gram.y:5057 #, c-format msgid "DROP ASSERTION is not yet implemented" msgstr "DROP ASSERTION non è stata ancora implementata" -#: gram.y:5394 +#: gram.y:5403 #, c-format msgid "RECHECK is no longer required" msgstr "RECHECK non è più richiesto" -#: gram.y:5395 +#: gram.y:5404 #, c-format msgid "Update your data type." msgstr "Aggiorna il tuo tipo di dato." -#: gram.y:6973 +#: gram.y:6983 #, c-format msgid "aggregates cannot have output arguments" msgstr "gli aggregati non possono avere argomenti di output" -#: gram.y:8843 gram.y:8861 +#: gram.y:8853 gram.y:8871 #, c-format msgid "WITH CHECK OPTION not supported on recursive views" msgstr "WITH CHECK OPTION non supportato su viste ricorsive" -#: gram.y:10383 +#: gram.y:9389 +#, c-format +msgid "unrecognized VACUUM option \"%s\"" +msgstr "opzione di VACUUM \"%s\" sconosciuta" + +#: gram.y:10403 #, c-format msgid "LIMIT #,# syntax is not supported" msgstr "La sintassi LIMIT #,# non è supportata" -#: gram.y:10384 +#: gram.y:10404 #, c-format msgid "Use separate LIMIT and OFFSET clauses." msgstr "Usa separatamente le clausole LIMIT ed OFFSET." -#: gram.y:10647 gram.y:10672 +#: gram.y:10667 gram.y:10692 #, c-format msgid "VALUES in FROM must have an alias" msgstr "VALUES nel FROM deve avere un alias" -#: gram.y:10648 gram.y:10673 +#: gram.y:10668 gram.y:10693 #, c-format msgid "For example, FROM (VALUES ...) [AS] foo." msgstr "Per esempio, FROM (VALUES ...) [AS] foo." -#: gram.y:10653 gram.y:10678 +#: gram.y:10673 gram.y:10698 #, c-format msgid "subquery in FROM must have an alias" msgstr "la sottoquery in FROM deve avere un alias" -#: gram.y:10654 gram.y:10679 +#: gram.y:10674 gram.y:10699 #, c-format msgid "For example, FROM (SELECT ...) [AS] foo." msgstr "Per esempio, FROM (SELECT ...) [AS] foo." -#: gram.y:11253 +#: gram.y:11273 #, c-format msgid "precision for type float must be at least 1 bit" msgstr "la precisione per il tipo float dev'essere di almeno un bit" -#: gram.y:11262 +#: gram.y:11282 #, c-format msgid "precision for type float must be less than 54 bits" msgstr "la precisione per il tipo float dev'essere inferiore a 54 bit" -#: gram.y:11766 +#: gram.y:11786 #, c-format msgid "wrong number of parameters on left side of OVERLAPS expression" msgstr "numero errato di parametri a sinistra dell'espressione OVERLAPS" -#: gram.y:11771 +#: gram.y:11791 #, c-format msgid "wrong number of parameters on right side of OVERLAPS expression" msgstr "numero errato di parametri a destra dell'espressione OVERLAPS" -#: gram.y:11948 +#: gram.y:11966 #, c-format msgid "UNIQUE predicate is not yet implemented" msgstr "il predicato UNIQUE non è stato ancora implementato" -#: gram.y:12280 +#: gram.y:12296 #, c-format msgid "cannot use multiple ORDER BY clauses with WITHIN GROUP" msgstr "non si può usare più di una clausola ORDER BY con WITHIN GROUOP" -#: gram.y:12285 +#: gram.y:12301 #, c-format msgid "cannot use DISTINCT with WITHIN GROUP" msgstr "non si può usare DISTINCT con WITHIN GROUP" -#: gram.y:12290 +#: gram.y:12306 #, c-format msgid "cannot use VARIADIC with WITHIN GROUP" msgstr "non si può usare VARIADIC con WITHIN GROUP" -#: gram.y:12796 +#: gram.y:12812 #, c-format msgid "RANGE PRECEDING is only supported with UNBOUNDED" msgstr "RANGE PRECEDING è supportato solo con UNBOUNDED" -#: gram.y:12802 +#: gram.y:12818 #, c-format msgid "RANGE FOLLOWING is only supported with UNBOUNDED" msgstr "RANGE FOLLOWING è supportato solo con UNBOUNDED" -#: gram.y:12829 gram.y:12852 +#: gram.y:12845 gram.y:12868 #, c-format msgid "frame start cannot be UNBOUNDED FOLLOWING" msgstr "l'inizio della finestra non può essere UNBOUNDED FOLLOWING" -#: gram.y:12834 +#: gram.y:12850 #, c-format msgid "frame starting from following row cannot end with current row" msgstr "una finestra che inizia dalla riga seguente non può terminare alla riga corrente" -#: gram.y:12857 +#: gram.y:12873 #, c-format msgid "frame end cannot be UNBOUNDED PRECEDING" msgstr "la fine della finestra non può essere UNBOUNDED PRECEDING" -#: gram.y:12863 +#: gram.y:12879 #, c-format msgid "frame starting from current row cannot have preceding rows" msgstr "una finestra che inizia dalla riga corrente non può avere righe precedenti" -#: gram.y:12870 +#: gram.y:12886 #, c-format msgid "frame starting from following row cannot have preceding rows" msgstr "una finestra che inizia dalla riga seguente non può avere righe precedenti" -#: gram.y:13535 +#: gram.y:13551 #, c-format msgid "type modifier cannot have parameter name" msgstr "un modificatore di tipo non può avere un nome di parametro" -#: gram.y:13541 +#: gram.y:13557 #, c-format msgid "type modifier cannot have ORDER BY" msgstr "un modificatore di tipo non può avere ORDER BY" -#: gram.y:13605 gram.y:13611 +#: gram.y:13621 gram.y:13627 #, c-format msgid "%s cannot be used as a role name here" msgstr "%s non può essere usato come nome di ruolo qui" -#: gram.y:14233 gram.y:14422 +#: gram.y:14249 gram.y:14438 msgid "improper use of \"*\"" msgstr "uso improprio di \"*\"" -#: gram.y:14486 +#: gram.y:14502 #, c-format msgid "an ordered-set aggregate with a VARIADIC direct argument must have one VARIADIC aggregated argument of the same data type" msgstr "un aggregato su insiemi ordinati con un argomento diretto VARIADIC deve avere un argomento aggregato VARIADIC sullo stesso tipo" -#: gram.y:14523 +#: gram.y:14539 #, c-format msgid "multiple ORDER BY clauses not allowed" msgstr "non è possibile avere più di una clausola ORDER BY" -#: gram.y:14534 +#: gram.y:14550 #, c-format msgid "multiple OFFSET clauses not allowed" msgstr "non è possibile avere più di una clausola OFFSET" -#: gram.y:14543 +#: gram.y:14559 #, c-format msgid "multiple LIMIT clauses not allowed" msgstr "non è possibile avere più di una clausola LIMIT" -#: gram.y:14552 +#: gram.y:14568 #, c-format msgid "multiple WITH clauses not allowed" msgstr "non è possibile avere più di una clausola WITH" -#: gram.y:14732 +#: gram.y:14760 #, c-format msgid "OUT and INOUT arguments aren't allowed in TABLE functions" msgstr "gli argomenti OUT e INOUT non sono permessi nelle funzioni TABLE" -#: gram.y:14833 +#: gram.y:14861 #, c-format msgid "multiple COLLATE clauses not allowed" msgstr "non è possibile avere più di una clausola COLLATE" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14871 gram.y:14884 +#: gram.y:14899 gram.y:14912 #, c-format msgid "%s constraints cannot be marked DEFERRABLE" msgstr "un vincolo %s non può essere marcato DEFERRABLE" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14897 +#: gram.y:14925 #, c-format msgid "%s constraints cannot be marked NOT VALID" msgstr "un vincolo %s non può essere marcato NOT VALID" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14910 +#: gram.y:14938 #, c-format msgid "%s constraints cannot be marked NO INHERIT" msgstr "un vincolo %s non può essere marcato NO INHERIT" -#: guc-file.l:315 +#: guc-file.l:313 #, c-format msgid "unrecognized configuration parameter \"%s\" in file \"%s\" line %u" msgstr "parametro di configurazione \"%s\" sconosciuto nel file \"%s\" riga %u" -#: guc-file.l:388 +#: guc-file.l:386 #, c-format msgid "parameter \"%s\" removed from configuration file, reset to default" msgstr "il parametro \"%s\" è stato rimosso dal file di configurazione, valore predefinito ripristinato" -#: guc-file.l:454 +#: guc-file.l:452 #, c-format msgid "parameter \"%s\" changed to \"%s\"" msgstr "il parametro \"%s\" è stato modificato a \"%s\"" -#: guc-file.l:496 +#: guc-file.l:494 #, c-format msgid "configuration file \"%s\" contains errors" msgstr "il file di configurazione \"%s\" contiene errori" -#: guc-file.l:501 +#: guc-file.l:499 #, c-format msgid "configuration file \"%s\" contains errors; unaffected changes were applied" msgstr "il file di configurazione \"%s\" contiene errori; i cambiamenti senza errori sono stati applicati" -#: guc-file.l:506 +#: guc-file.l:504 #, c-format msgid "configuration file \"%s\" contains errors; no changes were applied" msgstr "il file di configurazione \"%s\" contiene errori; nessun cambiamento effettuato" -#: guc-file.l:579 +#: guc-file.l:577 #, c-format msgid "could not open configuration file \"%s\": maximum nesting depth exceeded" msgstr "apertura del file di configurazione \"%s\" fallita: massima profondità di annidamento raggiunta" -#: guc-file.l:606 +#: guc-file.l:604 #, c-format msgid "skipping missing configuration file \"%s\"" msgstr "file di configurazione mancante \"%s\" saltato" -#: guc-file.l:860 +#: guc-file.l:858 #, c-format msgid "syntax error in file \"%s\" line %u, near end of line" msgstr "errore di sintassi nel file \"%s\" riga %u, vicino alla fine della riga" -#: guc-file.l:870 +#: guc-file.l:868 #, c-format msgid "syntax error in file \"%s\" line %u, near token \"%s\"" msgstr "errore di sintassi nel file \"%s\" riga %u, vicino al token \"%s\"" -#: guc-file.l:890 +#: guc-file.l:888 #, c-format msgid "too many syntax errors found, abandoning file \"%s\"" msgstr "troppi errori di sintassi, file \"%s\" abbandonato" -#: guc-file.l:942 +#: guc-file.l:940 #, c-format msgid "could not open configuration directory \"%s\": %m" msgstr "apertura della directory di configurazione \"%s\" fallita: %m" @@ -23102,7 +23107,7 @@ msgstr "timeline %u non valida" msgid "invalid streaming start location" msgstr "posizione di avvio dello streaming non valida" -#: repl_scanner.l:171 scan.l:671 +#: repl_scanner.l:171 scan.l:670 msgid "unterminated quoted string" msgstr "stringa tra virgolette non terminata" @@ -23111,119 +23116,119 @@ msgstr "stringa tra virgolette non terminata" msgid "syntax error: unexpected character \"%s\"" msgstr "errore di sintassi: carattere \"%s\" inaspettato" -#: scan.l:433 +#: scan.l:432 msgid "unterminated /* comment" msgstr "commento /* non terminato" -#: scan.l:462 +#: scan.l:461 msgid "unterminated bit string literal" msgstr "letterale di stringa di bit non terminato" -#: scan.l:483 +#: scan.l:482 msgid "unterminated hexadecimal string literal" msgstr "letterale di stringa esadecimale non terminato" -#: scan.l:533 +#: scan.l:532 #, c-format msgid "unsafe use of string constant with Unicode escapes" msgstr "uso non sicuro di stringa costante con gli escape Unicode" -#: scan.l:534 +#: scan.l:533 #, c-format msgid "String constants with Unicode escapes cannot be used when standard_conforming_strings is off." msgstr "Le stringhe costanti con escape Unicode non possono essere usate quando standard_conforming_strings è disabilitato." -#: scan.l:580 scan.l:779 +#: scan.l:579 scan.l:778 msgid "invalid Unicode escape character" msgstr "carattere escape Unicode non valido" -#: scan.l:606 scan.l:614 scan.l:622 scan.l:623 scan.l:624 scan.l:1338 -#: scan.l:1365 scan.l:1369 scan.l:1407 scan.l:1411 scan.l:1433 +#: scan.l:605 scan.l:613 scan.l:621 scan.l:622 scan.l:623 scan.l:1337 +#: scan.l:1364 scan.l:1368 scan.l:1406 scan.l:1410 scan.l:1432 scan.l:1442 msgid "invalid Unicode surrogate pair" msgstr "coppia surrogata Unicode non valida" -#: scan.l:628 +#: scan.l:627 #, c-format msgid "invalid Unicode escape" msgstr "escape Unicode non valido" -#: scan.l:629 +#: scan.l:628 #, c-format msgid "Unicode escapes must be \\uXXXX or \\UXXXXXXXX." msgstr "Gli escape Unicode devono essere \\uXXXX or \\UXXXXXXXX." -#: scan.l:640 +#: scan.l:639 #, c-format msgid "unsafe use of \\' in a string literal" msgstr "uso non sicuro di \\' in una stringa letterale" -#: scan.l:641 +#: scan.l:640 #, c-format msgid "Use '' to write quotes in strings. \\' is insecure in client-only encodings." msgstr "Usa '' per scrivere gli apici in una stringa. \\' non è sicuro in codifiche solo client." -#: scan.l:716 +#: scan.l:715 msgid "unterminated dollar-quoted string" msgstr "stringa delimitata da dollari non terminata" -#: scan.l:733 scan.l:759 scan.l:774 +#: scan.l:732 scan.l:758 scan.l:773 msgid "zero-length delimited identifier" msgstr "identificativo delimitato di lunghezza zero" -#: scan.l:794 +#: scan.l:793 syncrep_scanner.l:84 msgid "unterminated quoted identifier" msgstr "identificativo tra virgolette non terminato" -#: scan.l:925 +#: scan.l:924 msgid "operator too long" msgstr "operatore troppo lungo" #. translator: %s is typically the translation of "syntax error" -#: scan.l:1078 +#: scan.l:1077 #, c-format msgid "%s at end of input" msgstr "%s alla fine dell'input" #. translator: first %s is typically the translation of "syntax error" -#: scan.l:1086 syncrep_scanner.l:115 +#: scan.l:1085 #, c-format msgid "%s at or near \"%s\"" msgstr "%s a o presso \"%s\"" -#: scan.l:1252 scan.l:1284 +#: scan.l:1251 scan.l:1283 msgid "Unicode escape values cannot be used for code point values above 007F when the server encoding is not UTF8" msgstr "i valori escape Unicode non possono essere usati per code point superiori a 007F se la codifica del server non è UTF8" -#: scan.l:1280 scan.l:1425 +#: scan.l:1279 scan.l:1424 msgid "invalid Unicode escape value" msgstr "valore escape Unicode non valido" -#: scan.l:1482 +#: scan.l:1488 #, c-format msgid "nonstandard use of \\' in a string literal" msgstr "uso non standard di \\' in una stringa letterale" -#: scan.l:1483 +#: scan.l:1489 #, c-format msgid "Use '' to write quotes in strings, or use the escape string syntax (E'...')." msgstr "Usa '' per scrivere gli apici nelle stringhe, oppure usa la sintassi di escape delle stringhe (E'...')." -#: scan.l:1492 +#: scan.l:1498 #, c-format msgid "nonstandard use of \\\\ in a string literal" msgstr "uso non standard di \\\\ in una stringa letterale" -#: scan.l:1493 +#: scan.l:1499 #, c-format msgid "Use the escape string syntax for backslashes, e.g., E'\\\\'." msgstr "Usa la sintassi di escape delle stringhe per i backslash, cioè E'\\\\'." -#: scan.l:1507 +#: scan.l:1513 #, c-format msgid "nonstandard use of escape in a string literal" msgstr "uso non standard dell'escape in una stringa letterale" -#: scan.l:1508 +#: scan.l:1514 #, c-format msgid "Use the escape string syntax for escapes, e.g., E'\\r\\n'." msgstr "Usa la sintassi di escape per le stringhe per effettuare gli escape, cioè, E'\\r\\n'." diff --git a/src/backend/po/ko.po b/src/backend/po/ko.po index 425c8be35a..c5225ffa19 100644 --- a/src/backend/po/ko.po +++ b/src/backend/po/ko.po @@ -5,8 +5,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-11-25 15:32+0900\n" -"PO-Revision-Date: 2016-12-30 16:54+0900\n" +"POT-Creation-Date: 2017-03-02 11:23+0900\n" +"PO-Revision-Date: 2017-03-02 11:28:26+0900\n" "Last-Translator: Ioseph Kim \n" "Language-Team: Korean Team \n" "Language: ko\n" @@ -24,7 +24,7 @@ msgid "not recorded" msgstr "기ë¡ë˜ì–´ 있지 ì•ŠìŒ" #: ../common/controldata_utils.c:52 commands/copy.c:2833 -#: commands/extension.c:3120 utils/adt/genfile.c:134 +#: commands/extension.c:3141 utils/adt/genfile.c:134 #, c-format msgid "could not open file \"%s\" for reading: %m" msgstr "\"%s\" íŒŒì¼ ì¼ê¸° 모드로 열기 실패: %m" @@ -35,11 +35,11 @@ msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: \"%s\" íŒŒì¼ ì½ê¸° 모드로 열기 실패: %s\n" #: ../common/controldata_utils.c:66 access/transam/timeline.c:346 -#: access/transam/xlog.c:3191 access/transam/xlog.c:10348 -#: access/transam/xlog.c:10361 access/transam/xlog.c:10724 -#: access/transam/xlog.c:10767 access/transam/xlog.c:10806 -#: access/transam/xlog.c:10849 access/transam/xlogfuncs.c:665 -#: access/transam/xlogfuncs.c:684 commands/extension.c:3130 +#: access/transam/xlog.c:3220 access/transam/xlog.c:10423 +#: access/transam/xlog.c:10436 access/transam/xlog.c:10828 +#: access/transam/xlog.c:10871 access/transam/xlog.c:10910 +#: access/transam/xlog.c:10953 access/transam/xlogfuncs.c:665 +#: access/transam/xlogfuncs.c:684 commands/extension.c:3151 #: replication/logical/origin.c:665 replication/logical/origin.c:695 #: replication/logical/reorderbuffer.c:3099 replication/walsender.c:499 #: storage/file/copydir.c:176 utils/adt/genfile.c:151 @@ -152,26 +152,27 @@ msgid "could not close directory \"%s\": %s\n" msgstr "\"%s\" 디렉터리를 ë‹«ì„ ìˆ˜ ì—†ìŒ: %s\n" #: ../common/psprintf.c:179 ../port/path.c:630 ../port/path.c:668 -#: ../port/path.c:685 access/transam/twophase.c:1261 -#: access/transam/xlog.c:6079 lib/stringinfo.c:258 libpq/auth.c:850 +#: ../port/path.c:685 access/transam/twophase.c:1262 +#: access/transam/xlog.c:6108 lib/stringinfo.c:258 libpq/auth.c:850 #: libpq/auth.c:1213 libpq/auth.c:1281 libpq/auth.c:1797 #: postmaster/bgworker.c:289 postmaster/bgworker.c:796 -#: postmaster/postmaster.c:2334 postmaster/postmaster.c:2365 -#: postmaster/postmaster.c:3898 postmaster/postmaster.c:4588 -#: postmaster/postmaster.c:4663 postmaster/postmaster.c:5338 -#: postmaster/postmaster.c:5602 +#: postmaster/postmaster.c:2335 postmaster/postmaster.c:2366 +#: postmaster/postmaster.c:3899 postmaster/postmaster.c:4589 +#: postmaster/postmaster.c:4664 postmaster/postmaster.c:5339 +#: postmaster/postmaster.c:5603 #: replication/libpqwalreceiver/libpqwalreceiver.c:143 #: replication/logical/logical.c:168 storage/buffer/localbuf.c:436 -#: storage/file/fd.c:729 storage/file/fd.c:1126 storage/file/fd.c:1244 -#: storage/file/fd.c:1916 storage/ipc/procarray.c:1060 -#: storage/ipc/procarray.c:1546 storage/ipc/procarray.c:1553 -#: storage/ipc/procarray.c:1967 storage/ipc/procarray.c:2570 +#: storage/file/fd.c:736 storage/file/fd.c:1164 storage/file/fd.c:1282 +#: storage/file/fd.c:1993 storage/ipc/procarray.c:1061 +#: storage/ipc/procarray.c:1547 storage/ipc/procarray.c:1554 +#: storage/ipc/procarray.c:1968 storage/ipc/procarray.c:2571 #: utils/adt/formatting.c:1522 utils/adt/formatting.c:1642 -#: utils/adt/formatting.c:1763 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 +#: utils/adt/formatting.c:1763 utils/adt/pg_locale.c:463 +#: utils/adt/pg_locale.c:647 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 #: utils/adt/varlena.c:4461 utils/fmgr/dfmgr.c:216 utils/hash/dynahash.c:429 #: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1047 utils/mb/mbutils.c:376 -#: utils/mb/mbutils.c:709 utils/misc/guc.c:3890 utils/misc/guc.c:3906 -#: utils/misc/guc.c:3919 utils/misc/guc.c:6865 utils/misc/tzparser.c:468 +#: utils/mb/mbutils.c:709 utils/misc/guc.c:3888 utils/misc/guc.c:3904 +#: utils/misc/guc.c:3917 utils/misc/guc.c:6863 utils/misc/tzparser.c:468 #: utils/mmgr/aset.c:509 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 #: utils/mmgr/mcxt.c:839 utils/mmgr/mcxt.c:876 utils/mmgr/mcxt.c:910 #: utils/mmgr/mcxt.c:939 utils/mmgr/mcxt.c:973 utils/mmgr/mcxt.c:1055 @@ -290,7 +291,7 @@ msgid "could not determine encoding for codeset \"%s\"" msgstr "\"%s\" 코드 세트 í™˜ê²½ì— ì‚¬ìš©í•  ì¸ì½”ë”©ì„ ê²°ì •í•  수 없습니다" #: ../port/chklocale.c:294 ../port/chklocale.c:423 -#: postmaster/postmaster.c:4867 +#: postmaster/postmaster.c:4868 #, c-format msgid "Please report this to ." msgstr "ì´ ë‚´ìš©ì„ ì£¼ì†Œë¡œ 보고하십시오." @@ -298,7 +299,8 @@ msgstr "ì´ ë‚´ìš©ì„ ì£¼ì†Œë¡œ 보고하십시오." #: ../port/chklocale.c:415 ../port/chklocale.c:421 #, c-format msgid "could not determine encoding for locale \"%s\": codeset is \"%s\"" -msgstr "\"%s\" ë¡œì¼€ì¼ í™˜ê²½ì—ì„œ 사용할 ì¸ì½”ë”©ì„ ê²°ì •í•  수 없습니다. 코드 세트: \"%s\"" +msgstr "" +"\"%s\" ë¡œì¼€ì¼ í™˜ê²½ì—ì„œ 사용할 ì¸ì½”ë”©ì„ ê²°ì •í•  수 없습니다. 코드 세트: \"%s\"" #: ../port/dirmod.c:218 #, c-format @@ -344,8 +346,8 @@ msgid "" "You might have antivirus, backup, or similar software interfering with the " "database system." msgstr "" -"ë°”ì´ëŸ¬ìŠ¤ 백신 프로그램, 백업 ë˜ëŠ” 유사한 소프트웨어가 ë°ì´í„°ë² ì´ìŠ¤ " -"ì‹œìŠ¤í…œì„ ë°©í•´í•  수 있습니다." +"ë°”ì´ëŸ¬ìŠ¤ 백신 프로그램, 백업 ë˜ëŠ” 유사한 소프트웨어가 ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì„ " +"ë°©í•´í•  수 있습니다." #: ../port/path.c:654 #, c-format @@ -407,7 +409,8 @@ msgid "" "brin operator family \"%s\" contains function %s with wrong signature for " "support number %d" msgstr "" -"\"%s\" brin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s 함수가 ìž˜ëª»ëœ signature 번호(%d)ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" brin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s 함수가 ìž˜ëª»ëœ signature 번호(%d)ë¡œ 지정ë˜ì—ˆìŠµ" +"니다." #: access/brin/brin_validate.c:153 #, c-format @@ -415,7 +418,8 @@ msgid "" "brin operator family \"%s\" contains operator %s with invalid strategy " "number %d" msgstr "" -"\"%s\" brin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ì „ëžµ 번호(%d)ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" brin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ì „ëžµ 번호(%d)ë¡œ 지정ë˜ì—ˆìŠµë‹ˆ" +"다." #: access/brin/brin_validate.c:182 #, c-format @@ -428,8 +432,7 @@ msgstr "" #: access/brin/brin_validate.c:195 #, c-format msgid "brin operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"\"%s\" brin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ signature를 사용합니다." +msgstr "\"%s\" brin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ signature를 사용합니다." #: access/brin/brin_validate.c:233 #, c-format @@ -532,7 +535,9 @@ msgstr "유효한 ê°’ì€ \"%f\"ì—ì„œ \"%f\" 사ì´ìž…니다." #: access/common/tupconvert.c:108 #, c-format msgid "Returned type %s does not match expected type %s in column %d." -msgstr "반환 ìžë£Œí˜•ìœ¼ë¡œ %s í˜•ì„ ì§€ì •í–ˆì§€ë§Œ, ì¹¼ëŸ¼ì€ %s ìžë£Œí˜•ìž…니다. 해당 칼럼: %d 번째 칼럼" +msgstr "" +"반환 ìžë£Œí˜•ìœ¼ë¡œ %s í˜•ì„ ì§€ì •í–ˆì§€ë§Œ, ì¹¼ëŸ¼ì€ %s ìžë£Œí˜•ìž…니다. 해당 칼럼: %d 번" +"째 칼럼" #: access/common/tupconvert.c:136 #, c-format @@ -540,7 +545,7 @@ msgid "" "Number of returned columns (%d) does not match expected column count (%d)." msgstr "반환할 칼럼 수(%d)와 예ìƒë˜ëŠ” 칼럼수(%d)ê°€ 다릅니다." -#: access/common/tupconvert.c:241 +#: access/common/tupconvert.c:314 #, c-format msgid "" "Attribute \"%s\" of type %s does not match corresponding attribute of type " @@ -548,12 +553,12 @@ msgid "" msgstr "" " \"%s\" ì†ì„±(ëŒ€ìƒ ìžë£Œí˜• %s)ì´ %s ìžë£Œí˜•ì˜ ì†ì„± ê°€ìš´ë° ê´€ë ¨ëœ ê²ƒì´ ì—†ìŠµë‹ˆë‹¤" -#: access/common/tupconvert.c:253 +#: access/common/tupconvert.c:326 #, c-format msgid "Attribute \"%s\" of type %s does not exist in type %s." msgstr "\"%s\" ì†ì„±(ëŒ€ìƒ ìžë£Œí˜• %s)ì´ %s ìžë£Œí˜•ì—는 없습니다." -#: access/common/tupdesc.c:635 parser/parse_relation.c:1517 +#: access/common/tupdesc.c:635 parser/parse_relation.c:1518 #, c-format msgid "column \"%s\" cannot be declared SETOF" msgstr "\"%s\" ì—´ì€ SETOF를 지정할 수 없습니다" @@ -575,8 +580,8 @@ msgstr "maintenance_work_mem ì„¤ì •ê°’ì„ ì¤„ì´ì„¸ìš”." msgid "index row size %zu exceeds maximum %zu for index \"%s\"" msgstr "ì¸ë±ìŠ¤ í–‰ í¬ê¸° %zuì´(ê°€) 최대값 %zu(\"%s\" ì¸ë±ìŠ¤)ì„(를) 초과함" -#: access/gin/ginfast.c:989 access/transam/xlog.c:9805 -#: access/transam/xlog.c:10276 access/transam/xlogfuncs.c:293 +#: access/gin/ginfast.c:989 access/transam/xlog.c:9858 +#: access/transam/xlog.c:10362 access/transam/xlogfuncs.c:293 #: access/transam/xlogfuncs.c:320 access/transam/xlogfuncs.c:359 #: access/transam/xlogfuncs.c:380 access/transam/xlogfuncs.c:401 #: access/transam/xlogfuncs.c:471 access/transam/xlogfuncs.c:527 @@ -602,7 +607,9 @@ msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ ì¸ë±ìŠ¤ëŠ” 접근할 수 ì—†ìŒ" #: access/gin/ginscan.c:405 #, c-format msgid "old GIN indexes do not support whole-index scans nor searches for nulls" -msgstr "GIN ì¸ë±ìŠ¤ê°€ 옛날 버전ì´ì–´ì„œ ì¸ë±ìŠ¤ ì „ì²´ íƒìƒ‰, null íƒìƒ‰ ê¸°ëŠ¥ì„ ì‚¬ìš©í•  수 없습니다." +msgstr "" +"GIN ì¸ë±ìŠ¤ê°€ 옛날 버전ì´ì–´ì„œ ì¸ë±ìŠ¤ ì „ì²´ íƒìƒ‰, null íƒìƒ‰ ê¸°ëŠ¥ì„ ì‚¬ìš©í•  수 ì—†" +"습니다." #: access/gin/ginscan.c:406 #, c-format @@ -615,8 +622,8 @@ msgid "" "gin operator family \"%s\" contains support procedure %s with cross-type " "registration" msgstr "" -"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 " -"%s ì§€ì› í”„ë¡œì‹œì ¸ê°€ í¬í•¨ë˜ì–´ 있습니다." +"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 %s ì§€ì› í”„ë¡œì‹œì ¸ê°€ í¬" +"함ë˜ì–´ 있습니다." #: access/gin/ginvalidate.c:148 #, c-format @@ -624,7 +631,8 @@ msgid "" "gin operator family \"%s\" contains function %s with invalid support number " "%d" msgstr "" -"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆìŠµ" +"니다." #: access/gin/ginvalidate.c:160 #, c-format @@ -632,8 +640,8 @@ msgid "" "gin operator family \"%s\" contains function %s with wrong signature for " "support number %d" msgstr "" -"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› " -"번호 %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› ë²ˆí˜¸ %d ë¡œ " +"지정ë˜ì—ˆìŠµë‹ˆë‹¤." #: access/gin/ginvalidate.c:179 #, c-format @@ -641,7 +649,8 @@ msgid "" "gin operator family \"%s\" contains operator %s with invalid strategy number " "%d" msgstr "" -"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆ" +"다." #: access/gin/ginvalidate.c:192 #, c-format @@ -654,14 +663,12 @@ msgstr "" #: access/gin/ginvalidate.c:205 #, c-format msgid "gin operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." +msgstr "\"%s\" gin ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." #: access/gin/ginvalidate.c:246 #, c-format msgid "gin operator class \"%s\" is missing support function %d" -msgstr "" -"\"%s\" gin ì—°ì‚°ìž í´ëž˜ìŠ¤ì— %d ì§€ì› í•¨ìˆ˜ê°€ 빠졌습니다." +msgstr "\"%s\" gin ì—°ì‚°ìž í´ëž˜ìŠ¤ì— %d ì§€ì› í•¨ìˆ˜ê°€ 빠졌습니다." #: access/gin/ginvalidate.c:256 #, c-format @@ -679,8 +686,8 @@ msgid "" "This is caused by an incomplete page split at crash recovery before " "upgrading to PostgreSQL 9.1." msgstr "" -"ì´ ë¬¸ì œëŠ” PostgreSQL 9.1 버전으로 업그레ì´ë“œ 하기 ì „ì— " -"장애 복구 처리ì—ì„œ ìž˜ëª»ëœ íŽ˜ì´ì§€ 분리 ë•Œë¬¸ì— ë°œìƒí–ˆìŠµë‹ˆë‹¤." +"ì´ ë¬¸ì œëŠ” PostgreSQL 9.1 버전으로 업그레ì´ë“œ 하기 ì „ì— ìž¥ì•  복구 처리ì—ì„œ 잘" +"ëª»ëœ íŽ˜ì´ì§€ 분리 ë•Œë¬¸ì— ë°œìƒí–ˆìŠµë‹ˆë‹¤." #: access/gist/gist.c:683 access/gist/gistutil.c:738 #: access/gist/gistutil.c:749 access/gist/gistvacuum.c:261 @@ -717,8 +724,8 @@ msgid "" "The index is not optimal. To optimize it, contact a developer, or try to use " "the column as the second one in the CREATE INDEX command." msgstr "" -"ì¸ë±ìŠ¤ê°€ 최ì í™”ë˜ì§€ 않았습니다. 최ì í™”하려면 개발ìžì—게 문ì˜í•˜ê±°ë‚˜, " -"CREATE INDEX 명령ì—ì„œ 해당 ì—´ì„ ë‘ ë²ˆì§¸ ì¸ë±ìŠ¤ë¡œ 사용하십시오." +"ì¸ë±ìŠ¤ê°€ 최ì í™”ë˜ì§€ 않았습니다. 최ì í™”하려면 개발ìžì—게 문ì˜í•˜ê±°ë‚˜, CREATE " +"INDEX 명령ì—ì„œ 해당 ì—´ì„ ë‘ ë²ˆì§¸ ì¸ë±ìŠ¤ë¡œ 사용하십시오." #: access/gist/gistutil.c:735 access/hash/hashutil.c:169 #: access/nbtree/nbtpage.c:515 @@ -738,8 +745,8 @@ msgid "" "gist operator family \"%s\" contains support procedure %s with cross-type " "registration" msgstr "" -"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 " -"%s ì§€ì› í”„ë¡œì‹œì ¸ê°€ í¬í•¨ë˜ì–´ 있습니다." +"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 %s ì§€ì› í”„ë¡œì‹œì ¸ê°€ " +"í¬í•¨ë˜ì–´ 있습니다." #: access/gist/gistvalidate.c:145 #, c-format @@ -747,7 +754,8 @@ msgid "" "gist operator family \"%s\" contains function %s with invalid support number " "%d" msgstr "" -"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆ" +"습니다." #: access/gist/gistvalidate.c:157 #, c-format @@ -755,8 +763,8 @@ msgid "" "gist operator family \"%s\" contains function %s with wrong signature for " "support number %d" msgstr "" -"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› " -"번호 %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› ë²ˆí˜¸ %d " +"ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." #: access/gist/gistvalidate.c:177 #, c-format @@ -764,7 +772,8 @@ msgid "" "gist operator family \"%s\" contains operator %s with invalid strategy " "number %d" msgstr "" -"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆ" +"다." #: access/gist/gistvalidate.c:195 #, c-format @@ -772,7 +781,8 @@ msgid "" "gist operator family \"%s\" contains unsupported ORDER BY specification for " "operator %s" msgstr "" -"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ 지ì›í•˜ì§€ 않는 ORDER BY 명세를 사용합니다." +"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ 지ì›í•˜ì§€ 않는 ORDER BY 명세를 사용합" +"니다." #: access/gist/gistvalidate.c:206 #, c-format @@ -785,21 +795,19 @@ msgstr "" #: access/gist/gistvalidate.c:225 #, c-format msgid "gist operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." +msgstr "\"%s\" gist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." #: access/gist/gistvalidate.c:264 #, c-format msgid "gist operator class \"%s\" is missing support function %d" -msgstr "" -"\"%s\" gist ì—°ì‚°ìž í´ëž˜ìŠ¤ì— %d ì§€ì› í•¨ìˆ˜ê°€ 빠졌습니다." +msgstr "\"%s\" gist ì—°ì‚°ìž í´ëž˜ìŠ¤ì— %d ì§€ì› í•¨ìˆ˜ê°€ 빠졌습니다." -#: access/hash/hashinsert.c:68 +#: access/hash/hashinsert.c:70 #, c-format msgid "index row size %zu exceeds hash maximum %zu" msgstr "ì¸ë±ìŠ¤ í–‰ í¬ê¸°ê°€ 초과ë¨: 현재값 %zu, 최대값 %zu" -#: access/hash/hashinsert.c:70 access/spgist/spgdoinsert.c:1911 +#: access/hash/hashinsert.c:72 access/spgist/spgdoinsert.c:1911 #: access/spgist/spgutils.c:703 #, c-format msgid "Values larger than a buffer page cannot be indexed." @@ -831,8 +839,8 @@ msgid "" "hash operator family \"%s\" contains support procedure %s with cross-type " "registration" msgstr "" -"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 " -"%s ì§€ì› í”„ë¡œì‹œì ¸ê°€ í¬í•¨ë˜ì–´ 있습니다." +"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 %s ì§€ì› í”„ë¡œì‹œì ¸ê°€ " +"í¬í•¨ë˜ì–´ 있습니다." #: access/hash/hashvalidate.c:113 #, c-format @@ -840,8 +848,8 @@ msgid "" "hash operator family \"%s\" contains function %s with wrong signature for " "support number %d" msgstr "" -"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› " -"번호 %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› ë²ˆí˜¸ %d " +"ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." #: access/hash/hashvalidate.c:130 #, c-format @@ -849,7 +857,8 @@ msgid "" "hash operator family \"%s\" contains function %s with invalid support number " "%d" msgstr "" -"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆ" +"습니다." #: access/hash/hashvalidate.c:151 #, c-format @@ -857,7 +866,8 @@ msgid "" "hash operator family \"%s\" contains operator %s with invalid strategy " "number %d" msgstr "" -"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆ" +"다." #: access/hash/hashvalidate.c:164 #, c-format @@ -870,8 +880,7 @@ msgstr "" #: access/hash/hashvalidate.c:177 #, c-format msgid "hash operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." +msgstr "\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." #: access/hash/hashvalidate.c:189 #, c-format @@ -881,7 +890,8 @@ msgstr "\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžìš© ì§€ì› í•¨ìˆ˜ê°€ ì—† #: access/hash/hashvalidate.c:217 #, c-format msgid "hash operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ìžë£Œí˜•ê³¼ %s ìžë£Œí˜•ì„ 다루는 ì—°ì‚°ìžê°€ ì—†ìŒ" +msgstr "" +"\"%s\" hash ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ìžë£Œí˜•ê³¼ %s ìžë£Œí˜•ì„ 다루는 ì—°ì‚°ìžê°€ ì—†ìŒ" #: access/hash/hashvalidate.c:231 #, c-format @@ -894,14 +904,14 @@ msgid "hash operator family \"%s\" is missing cross-type operator(s)" msgstr "%s hash ì—°ì‚°ìž í´ëž˜ìŠ¤ì— cross-type ì—°ì‚°ìžê°€ ë¹ ì¡ŒìŒ" #: access/heap/heapam.c:1295 access/heap/heapam.c:1323 -#: access/heap/heapam.c:1355 catalog/aclchk.c:1748 +#: access/heap/heapam.c:1355 catalog/aclchk.c:1756 #, c-format msgid "\"%s\" is an index" msgstr "\"%s\" ê°ì²´ëŠ” ì¸ë±ìŠ¤ìž„" #: access/heap/heapam.c:1300 access/heap/heapam.c:1328 -#: access/heap/heapam.c:1360 catalog/aclchk.c:1755 commands/tablecmds.c:8984 -#: commands/tablecmds.c:12053 +#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9081 +#: commands/tablecmds.c:12189 #, c-format msgid "\"%s\" is a composite type" msgstr "\"%s\" ê°ì²´ëŠ” 복합 ìžë£Œí˜•ìž…니다" @@ -932,7 +942,7 @@ msgid "attempted to update invisible tuple" msgstr "ë³¼ 수 없는 íŠœí”Œì„ ë³€ê²½í•˜ë ¤ê³  함" #: access/heap/heapam.c:4963 access/heap/heapam.c:5001 -#: access/heap/heapam.c:5253 executor/execMain.c:2312 +#: access/heap/heapam.c:5253 executor/execMain.c:2314 #, c-format msgid "could not obtain lock on row in relation \"%s\"" msgstr "\"%s\" 릴레ì´ì…˜ì˜ 잠금 정보를 구할 수 ì—†ìŒ" @@ -949,22 +959,22 @@ msgstr "\"%s\" íŒŒì¼ ì“°ê¸° 실패, %d / %d 기ë¡í•¨: %m." #: access/heap/rewriteheap.c:963 access/heap/rewriteheap.c:1175 #: access/heap/rewriteheap.c:1272 access/transam/timeline.c:407 -#: access/transam/timeline.c:483 access/transam/xlog.c:3058 -#: access/transam/xlog.c:3220 replication/logical/snapbuild.c:1605 -#: replication/slot.c:1088 replication/slot.c:1173 storage/file/fd.c:624 -#: storage/file/fd.c:3052 storage/smgr/md.c:1041 storage/smgr/md.c:1274 -#: storage/smgr/md.c:1447 utils/misc/guc.c:6887 +#: access/transam/timeline.c:483 access/transam/xlog.c:3087 +#: access/transam/xlog.c:3249 replication/logical/snapbuild.c:1605 +#: replication/slot.c:1088 replication/slot.c:1173 storage/file/fd.c:631 +#: storage/file/fd.c:3129 storage/smgr/md.c:1041 storage/smgr/md.c:1274 +#: storage/smgr/md.c:1447 utils/misc/guc.c:6885 #, c-format msgid "could not fsync file \"%s\": %m" msgstr "\"%s\" íŒŒì¼ fsync 실패: %m" #: access/heap/rewriteheap.c:1018 access/heap/rewriteheap.c:1138 #: access/transam/timeline.c:315 access/transam/timeline.c:461 -#: access/transam/xlog.c:3014 access/transam/xlog.c:3163 -#: access/transam/xlog.c:10134 access/transam/xlog.c:10172 -#: access/transam/xlog.c:10499 postmaster/postmaster.c:4363 +#: access/transam/xlog.c:3043 access/transam/xlog.c:3192 +#: access/transam/xlog.c:10192 access/transam/xlog.c:10230 +#: access/transam/xlog.c:10603 postmaster/postmaster.c:4364 #: replication/logical/origin.c:542 replication/slot.c:1045 -#: storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1223 +#: storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1275 #, c-format msgid "could not create file \"%s\": %m" msgstr "\"%s\" 파ì¼ì„ 만들 수 ì—†ìŒ: %m" @@ -982,20 +992,20 @@ msgstr "\"%s\" 파ì¼ì˜ ëì„ ì°¾ì„ ìˆ˜ ì—†ìŒ: %m" #: access/heap/rewriteheap.c:1165 access/transam/timeline.c:367 #: access/transam/timeline.c:401 access/transam/timeline.c:477 -#: access/transam/xlog.c:3049 access/transam/xlog.c:3213 -#: postmaster/postmaster.c:4373 postmaster/postmaster.c:4383 +#: access/transam/xlog.c:3078 access/transam/xlog.c:3242 +#: postmaster/postmaster.c:4374 postmaster/postmaster.c:4384 #: replication/logical/origin.c:551 replication/logical/origin.c:587 #: replication/logical/origin.c:603 replication/logical/snapbuild.c:1589 #: replication/slot.c:1074 storage/file/copydir.c:187 #: utils/init/miscinit.c:1228 utils/init/miscinit.c:1237 -#: utils/init/miscinit.c:1244 utils/misc/guc.c:6848 utils/misc/guc.c:6879 -#: utils/misc/guc.c:8729 utils/misc/guc.c:8743 utils/time/snapmgr.c:1228 -#: utils/time/snapmgr.c:1235 +#: utils/init/miscinit.c:1244 utils/misc/guc.c:6846 utils/misc/guc.c:6877 +#: utils/misc/guc.c:8727 utils/misc/guc.c:8741 utils/time/snapmgr.c:1280 +#: utils/time/snapmgr.c:1287 #, c-format msgid "could not write to file \"%s\": %m" msgstr "\"%s\" íŒŒì¼ ì“°ê¸° 실패: %m" -#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10366 +#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10441 #: access/transam/xlogarchive.c:114 access/transam/xlogarchive.c:468 #: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2632 #: replication/logical/reorderbuffer.c:2689 @@ -1008,20 +1018,20 @@ msgstr "\"%s\" 파ì¼ì„ 삭제할 수 ì—†ìŒ: %m" #: access/heap/rewriteheap.c:1262 access/transam/timeline.c:111 #: access/transam/timeline.c:236 access/transam/timeline.c:334 -#: access/transam/xlog.c:2990 access/transam/xlog.c:3107 -#: access/transam/xlog.c:3148 access/transam/xlog.c:3421 -#: access/transam/xlog.c:3499 access/transam/xlogutils.c:701 -#: replication/basebackup.c:401 replication/basebackup.c:1162 +#: access/transam/xlog.c:3019 access/transam/xlog.c:3136 +#: access/transam/xlog.c:3177 access/transam/xlog.c:3450 +#: access/transam/xlog.c:3528 access/transam/xlogutils.c:701 +#: replication/basebackup.c:403 replication/basebackup.c:1150 #: replication/logical/origin.c:658 replication/logical/reorderbuffer.c:2156 #: replication/logical/reorderbuffer.c:2402 #: replication/logical/reorderbuffer.c:3081 #: replication/logical/snapbuild.c:1582 replication/logical/snapbuild.c:1666 #: replication/slot.c:1162 replication/walsender.c:474 -#: replication/walsender.c:2102 storage/file/copydir.c:155 -#: storage/file/fd.c:607 storage/file/fd.c:2964 storage/file/fd.c:3031 +#: replication/walsender.c:2100 storage/file/copydir.c:155 +#: storage/file/fd.c:614 storage/file/fd.c:3041 storage/file/fd.c:3108 #: storage/smgr/md.c:609 utils/error/elog.c:1879 utils/init/miscinit.c:1163 -#: utils/init/miscinit.c:1284 utils/init/miscinit.c:1362 utils/misc/guc.c:7107 -#: utils/misc/guc.c:7140 +#: utils/init/miscinit.c:1284 utils/init/miscinit.c:1362 utils/misc/guc.c:7105 +#: utils/misc/guc.c:7138 #, c-format msgid "could not open file \"%s\": %m" msgstr "\"%s\" 파ì¼ì„ ì—´ 수 ì—†ìŒ: %m" @@ -1037,8 +1047,8 @@ msgid "index access method \"%s\" does not have a handler" msgstr "\"%s\" ì¸ë±ìŠ¤ ì ‘ê·¼ ë°©ë²•ì— ëŒ€í•œ 핸들러가 ì—†ìŒ" #: access/index/indexam.c:155 catalog/objectaddress.c:1196 -#: commands/indexcmds.c:1799 commands/tablecmds.c:241 -#: commands/tablecmds.c:12044 +#: commands/indexcmds.c:1800 commands/tablecmds.c:242 +#: commands/tablecmds.c:12180 #, c-format msgid "\"%s\" is not an index" msgstr "\"%s\" ê°ì²´ëŠ” ì¸ë±ìŠ¤ê°€ 아닙니다" @@ -1071,11 +1081,10 @@ msgid "" "indexing." msgstr "" "ë²„í¼ íŽ˜ì´ì§€ì˜ 1/3보다 í° ê°’ì€ ì¸ë±ì‹±í•  수 없습니다.\n" -"ê°’ì˜ MD5 í•´ì‹œ 함수 ì¸ë±ìŠ¤ë¥¼ 고려하거나 ì „ì²´ í…스트 ì¸ë±ì‹±ì„ 사용하" -"십시오." +"ê°’ì˜ MD5 í•´ì‹œ 함수 ì¸ë±ìŠ¤ë¥¼ 고려하거나 ì „ì²´ í…스트 ì¸ë±ì‹±ì„ 사용하십시오." #: access/nbtree/nbtpage.c:168 access/nbtree/nbtpage.c:371 -#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1717 +#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1702 #, c-format msgid "index \"%s\" is not a btree" msgstr "\"%s\" ì¸ë±ìŠ¤ëŠ” btree ì¸ë±ìŠ¤ê°€ 아닙니다" @@ -1106,7 +1115,8 @@ msgid "" "btree operator family \"%s\" contains function %s with invalid support " "number %d" msgstr "" -"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆ" +"습니다." #: access/nbtree/nbtvalidate.c:112 #, c-format @@ -1114,8 +1124,8 @@ msgid "" "btree operator family \"%s\" contains function %s with wrong signature for " "support number %d" msgstr "" -"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› " -"번호 %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› ë²ˆí˜¸ %d " +"ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." #: access/nbtree/nbtvalidate.c:132 #, c-format @@ -1123,7 +1133,8 @@ msgid "" "btree operator family \"%s\" contains operator %s with invalid strategy " "number %d" msgstr "" -"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµ" +"니다." #: access/nbtree/nbtvalidate.c:145 #, c-format @@ -1136,8 +1147,7 @@ msgstr "" #: access/nbtree/nbtvalidate.c:158 #, c-format msgid "btree operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." +msgstr "\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." #: access/nbtree/nbtvalidate.c:200 #, c-format @@ -1148,7 +1158,8 @@ msgstr "\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì—는 %s ìžë£Œí˜•ê³¼ %s ìžë£Œí˜•ìš© #, c-format msgid "" "btree operator family \"%s\" is missing support function for types %s and %s" -msgstr "\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì—는 %s ìžë£Œí˜•ê³¼ %s ìžë£Œí˜•ìš© ì§€ì› í•¨ìˆ˜ê°€ ë¹ ì¡ŒìŒ" +msgstr "" +"\"%s\" btree ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì—는 %s ìžë£Œí˜•ê³¼ %s ìžë£Œí˜•ìš© ì§€ì› í•¨ìˆ˜ê°€ ë¹ ì¡ŒìŒ" #: access/nbtree/nbtvalidate.c:224 #, c-format @@ -1171,8 +1182,8 @@ msgid "" "spgist operator family \"%s\" contains support procedure %s with cross-type " "registration" msgstr "" -"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 " -"%s ì§€ì› í”„ë¡œì‹œì ¸ê°€ í¬í•¨ë˜ì–´ 있습니다." +"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— cross-type registration 으로 %s ì§€ì› í”„ë¡œì‹œì ¸" +"ê°€ í¬í•¨ë˜ì–´ 있습니다." #: access/spgist/spgvalidate.c:115 #, c-format @@ -1180,7 +1191,8 @@ msgid "" "spgist operator family \"%s\" contains function %s with invalid support " "number %d" msgstr "" -"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ ì§€ì› ë²ˆí˜¸ %d ë¡œ 지정ë˜" +"었습니다." #: access/spgist/spgvalidate.c:127 #, c-format @@ -1188,8 +1200,8 @@ msgid "" "spgist operator family \"%s\" contains function %s with wrong signature for " "support number %d" msgstr "" -"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› " -"번호 %d ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s 함수가 ìž˜ëª»ëœ signature ì§€ì› ë²ˆí˜¸ %d " +"ë¡œ 지정ë˜ì—ˆìŠµë‹ˆë‹¤." #: access/spgist/spgvalidate.c:146 #, c-format @@ -1197,7 +1209,8 @@ msgid "" "spgist operator family \"%s\" contains operator %s with invalid strategy " "number %d" msgstr "" -"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµë‹ˆë‹¤." +"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— í¬í•¨ëœ %s ì—°ì‚°ìžì˜ %d 번 ì „ëžµ 번호가 잘못ë˜ì—ˆìŠµ" +"니다." #: access/spgist/spgvalidate.c:159 #, c-format @@ -1210,21 +1223,20 @@ msgstr "" #: access/spgist/spgvalidate.c:172 #, c-format msgid "spgist operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." +msgstr "\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %s ì—°ì‚°ìžê°€ ìž˜ëª»ëœ ê¸°í˜¸ë¥¼ 사용합니다." #: access/spgist/spgvalidate.c:200 #, c-format msgid "" "spgist operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì—ì„œ %s ìžë£Œí˜•ê³¼ %s ìžë£Œí˜•ìš© ì—°ì‚°ìžê°€ ë¹ ì¡ŒìŒ" +msgstr "" +"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì—ì„œ %s ìžë£Œí˜•ê³¼ %s ìžë£Œí˜•ìš© ì—°ì‚°ìžê°€ ë¹ ì¡ŒìŒ" #: access/spgist/spgvalidate.c:220 #, c-format msgid "" "spgist operator family \"%s\" is missing support function %d for type %s" -msgstr "" -"\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %d ì§€ì› í•¨ìˆ˜ê°€ %s ìžë£Œí˜•ìš©ìœ¼ë¡œ 없습니다." +msgstr "\"%s\" spgist ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì— %d ì§€ì› í•¨ìˆ˜ê°€ %s ìžë£Œí˜•ìš©ìœ¼ë¡œ 없습니다." #: access/spgist/spgvalidate.c:233 #, c-format @@ -1236,24 +1248,23 @@ msgstr "\"%s\" spgist ì—°ì‚°ìž í´ëž˜ìŠ¤ì— ì—°ì‚°ìžê°€ ë¹ ì¡ŒìŒ" msgid "sample percentage must be between 0 and 100" msgstr "샘플 í¼ì„¼íŠ¸ ê°’ì€ 0ì—ì„œ 100 사ì´ì—¬ì•¼ 함" -#: access/transam/commit_ts.c:295 +#: access/transam/commit_ts.c:294 #, c-format msgid "cannot retrieve commit timestamp for transaction %u" msgstr "%u íŠ¸ëžœìž­ì…˜ì˜ ì»¤ë°‹ 타임스탬프를 ì•Œ 수 ì—†ìŒ" -#: access/transam/commit_ts.c:385 +#: access/transam/commit_ts.c:392 #, c-format msgid "could not get commit timestamp data" msgstr "커밋 타임스탬프 ìžë£Œë¥¼ ì°¾ì„ ìˆ˜ ì—†ìŒ" -#: access/transam/commit_ts.c:387 +#: access/transam/commit_ts.c:394 #, c-format msgid "" "Make sure the configuration parameter \"%s\" is set on the master server." -msgstr "" -"ìš´ì˜ ì„œë²„ì—ì„œ \"%s\" 환경 설정 매개 ë³€ìˆ˜ê°’ì„ ì§€ì • 하세요." +msgstr "ìš´ì˜ ì„œë²„ì—ì„œ \"%s\" 환경 설정 매개 ë³€ìˆ˜ê°’ì„ ì§€ì • 하세요." -#: access/transam/commit_ts.c:389 libpq/hba.c:1439 +#: access/transam/commit_ts.c:396 libpq/hba.c:1439 #, c-format msgid "Make sure the configuration parameter \"%s\" is set." msgstr "\"%s\" 환경 설정 매개 변수를 지정하세요." @@ -1264,8 +1275,8 @@ msgid "" "database is not accepting commands that generate new MultiXactIds to avoid " "wraparound data loss in database \"%s\"" msgstr "" -"\"%s\" ë°ì´í„°ë² ì´ìŠ¤ ìžë£Œ ì†ì‹¤ì„ 막기 위해 새로운 MultiXactId " -"만드는 ìž‘ì—…ì„ ë” ì´ìƒ í•  수 없습니다." +"\"%s\" ë°ì´í„°ë² ì´ìŠ¤ ìžë£Œ ì†ì‹¤ì„ 막기 위해 새로운 MultiXactId 만드는 ìž‘ì—…ì„ " +"ë” ì´ìƒ í•  수 없습니다." #: access/transam/multixact.c:1002 access/transam/multixact.c:1009 #: access/transam/multixact.c:1033 access/transam/multixact.c:1042 @@ -1283,8 +1294,8 @@ msgid "" "database is not accepting commands that generate new MultiXactIds to avoid " "wraparound data loss in database with OID %u" msgstr "" -"%u OID ë°ì´í„°ë² ì´ìŠ¤ ìžë£Œ ì†ì‹¤ì„ 막기 위해 새로운 MultiXactId " -"만드는 ìž‘ì—…ì„ ë” ì´ìƒ í•  수 없습니다." +"%u OID ë°ì´í„°ë² ì´ìŠ¤ ìžë£Œ ì†ì‹¤ì„ 막기 위해 새로운 MultiXactId 만드는 ìž‘ì—…ì„ " +"ë” ì´ìƒ í•  수 없습니다." #: access/transam/multixact.c:1028 access/transam/multixact.c:2314 #, c-format @@ -1292,7 +1303,8 @@ msgid "database \"%s\" must be vacuumed before %u more MultiXactId is used" msgid_plural "" "database \"%s\" must be vacuumed before %u more MultiXactIds are used" msgstr[0] "" -"\"%s\" ë°ì´í„°ë² ì´ìŠ¤ëŠ” %uë²ˆì˜ íŠ¸ëžœìž­ì…˜ì´ ë°œìƒë˜ê¸° ì „ì— VACUUM ìž‘ì—…ì„ í•´ì•¼ 합니다." +"\"%s\" ë°ì´í„°ë² ì´ìŠ¤ëŠ” %uë²ˆì˜ íŠ¸ëžœìž­ì…˜ì´ ë°œìƒë˜ê¸° ì „ì— VACUUM ìž‘ì—…ì„ í•´ì•¼ 합니" +"다." #: access/transam/multixact.c:1037 access/transam/multixact.c:2323 #, c-format @@ -1301,7 +1313,8 @@ msgid "" msgid_plural "" "database with OID %u must be vacuumed before %u more MultiXactIds are used" msgstr[0] "" -"%u OID ë°ì´í„°ë² ì´ìŠ¤ëŠ” %uë²ˆì˜ íŠ¸ëžœìž­ì…˜ì´ ë°œìƒë˜ê¸° ì „ì— VACUUM ìž‘ì—…ì„ í•´ì•¼ 합니다." +"%u OID ë°ì´í„°ë² ì´ìŠ¤ëŠ” %uë²ˆì˜ íŠ¸ëžœìž­ì…˜ì´ ë°œìƒë˜ê¸° ì „ì— VACUUM ìž‘ì—…ì„ í•´ì•¼ 합니" +"다." #: access/transam/multixact.c:1098 #, c-format @@ -1317,8 +1330,7 @@ msgid_plural "" "This command would create a multixact with %u members, but the remaining " "space is only enough for %u members." msgstr[0] "" -"ì´ ëª…ë ¹ì€ %u ê°œì˜ multixact를 ì¨ì•¼í•˜ëŠ”ë°, " -"쓸 수 있는 ê³µê°„ì€ %u ê°œ ë¿ìž…니다." +"ì´ ëª…ë ¹ì€ %u ê°œì˜ multixact를 ì¨ì•¼í•˜ëŠ”ë°, 쓸 수 있는 ê³µê°„ì€ %u ê°œ ë¿ìž…니다." #: access/transam/multixact.c:1104 #, c-format @@ -1327,8 +1339,8 @@ msgid "" "vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age " "settings." msgstr "" -"vacuum_multixact_freeze_min_age, vacuum_multixact_freeze_table_age " -"ê°’ì„ ì¡°ì •í•˜ê³ , %u OID ë°ì´í„°ë² ì´ìŠ¤ 대ìƒìœ¼ë¡œ VACUUM ìž‘ì—…ì„ í•˜ì‹­ì‹œì˜¤." +"vacuum_multixact_freeze_min_age, vacuum_multixact_freeze_table_age ê°’ì„ ì¡°ì •" +"하고, %u OID ë°ì´í„°ë² ì´ìŠ¤ 대ìƒìœ¼ë¡œ VACUUM ìž‘ì—…ì„ í•˜ì‹­ì‹œì˜¤." #: access/transam/multixact.c:1135 #, c-format @@ -1338,7 +1350,8 @@ msgid_plural "" "database with OID %u must be vacuumed before %d more multixact members are " "used" msgstr[0] "" -"%u OID ë°ì´í„°ë² ì´ìŠ¤ëŠ” %d ê°œì˜ ë©€í‹°íŠ¸ëžœìž­ì…˜ì„ ì‚¬ìš©í•˜ê¸° ì „ì— vacuum ìž‘ì—…ì„ í•´ì•¼ 합니다." +"%u OID ë°ì´í„°ë² ì´ìŠ¤ëŠ” %d ê°œì˜ ë©€í‹°íŠ¸ëžœìž­ì…˜ì„ ì‚¬ìš©í•˜ê¸° ì „ì— vacuum ìž‘ì—…ì„ í•´" +"야 합니다." #: access/transam/multixact.c:1140 #, c-format @@ -1347,8 +1360,8 @@ msgid "" "vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age " "settings." msgstr "" -"vacuum_multixact_freeze_min_age 설정값과 vacuum_multixact_freeze_table_age ê°’ì„ " -"줄여서 ë°ì´í„°ë² ì´ìŠ¤ 단위로 VACUUM ìž‘ì—…ì„ ì§„í–‰í•˜ì„¸ìš”." +"vacuum_multixact_freeze_min_age 설정값과 vacuum_multixact_freeze_table_age ê°’" +"ì„ ì¤„ì—¬ì„œ ë°ì´í„°ë² ì´ìŠ¤ 단위로 VACUUM ìž‘ì—…ì„ ì§„í–‰í•˜ì„¸ìš”." #: access/transam/multixact.c:1277 #, c-format @@ -1374,8 +1387,8 @@ msgid "" "database.\n" "You might also need to commit or roll back old prepared transactions." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ê°€ 종료ë˜ì§€ ì•Šë„ë¡ í•˜ë ¤ë©´ ë°ì´í„°ë² ì´ìŠ¤ ìˆ˜ì¤€ì˜ " -"VACUUMì„ ì‹¤í–‰í•˜ì‹­ì‹œì˜¤.\n" +"ë°ì´í„°ë² ì´ìŠ¤ê°€ 종료ë˜ì§€ ì•Šë„ë¡ í•˜ë ¤ë©´ ë°ì´í„°ë² ì´ìŠ¤ ìˆ˜ì¤€ì˜ VACUUMì„ ì‹¤í–‰í•˜ì‹­ì‹œ" +"오.\n" "ë˜í•œ ì˜¤ëž˜ëœ íŠ¸ëžœìž­ì…˜ì„ ì»¤ë°‹í•˜ê±°ë‚˜ 롤백할 필요가 있습니다." #: access/transam/multixact.c:2598 @@ -1389,8 +1402,8 @@ msgid "" "MultiXact member wraparound protections are disabled because oldest " "checkpointed MultiXact %u does not exist on disk" msgstr "" -"가장 ì˜¤ëž˜ëœ ì²´í¬í¬ì¸íŠ¸ ìž‘ì—…ì´ ì™„ë£Œëœ %u 멀티 트랜잭션 번호가 디스í¬ì— 없기 때문ì—, " -"멀티 트랜잭션 번호 겹침 방지 ê¸°ëŠ¥ì´ ë¹„í™œì„±í™” ë˜ì–´ 있습니다." +"가장 ì˜¤ëž˜ëœ ì²´í¬í¬ì¸íŠ¸ ìž‘ì—…ì´ ì™„ë£Œëœ %u 멀티 트랜잭션 번호가 디스í¬ì— 없기 ë•Œ" +"문ì—, 멀티 트랜잭션 번호 겹침 방지 ê¸°ëŠ¥ì´ ë¹„í™œì„±í™” ë˜ì–´ 있습니다." #: access/transam/multixact.c:2624 #, c-format @@ -1406,7 +1419,8 @@ msgstr "멀티 트랜잭션 중지 제한 번호는 %u 입니다. (%u 멀티트 #, c-format msgid "" "oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation" -msgstr "가장 ì˜¤ëž˜ëœ ë©€í‹° 트랜잭션 번호는 %u, 가장 최신 ê²ƒì€ %u, truncate ìž‘ì—… 건너뜀" +msgstr "" +"가장 ì˜¤ëž˜ëœ ë©€í‹° 트랜잭션 번호는 %u, 가장 최신 ê²ƒì€ %u, truncate ìž‘ì—… 건너뜀" #: access/transam/multixact.c:3024 #, c-format @@ -1414,8 +1428,8 @@ msgid "" "cannot truncate up to MultiXact %u because it does not exist on disk, " "skipping truncation" msgstr "" -"디스í¬ì— 해당 멀티 트랜잭션 번호가 없어, %u 멀티 트랜잭션 번호로 truncate 못함, " -"truncate ìž‘ì—… 건너뜀" +"디스í¬ì— 해당 멀티 트랜잭션 번호가 없어, %u 멀티 트랜잭션 번호로 truncate 못" +"함, truncate ìž‘ì—… 건너뜀" #: access/transam/multixact.c:3350 #, c-format @@ -1534,7 +1548,7 @@ msgid "Timeline IDs must be less than child timeline's ID." msgstr "타임ë¼ì¸ ID는 하위 타임ë¼ì¸ ID보다 작아야 합니다." #: access/transam/timeline.c:412 access/transam/timeline.c:488 -#: access/transam/xlog.c:3064 access/transam/xlog.c:3225 +#: access/transam/xlog.c:3093 access/transam/xlog.c:3254 #: access/transam/xlogfuncs.c:690 commands/copy.c:1708 #: storage/file/copydir.c:201 #, c-format @@ -1576,98 +1590,98 @@ msgstr "ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ì˜ ìµœëŒ€ 개수를 ëª¨ë‘ ì‚¬ìš©í–ˆìŠµë‹ˆë‹¤" msgid "Increase max_prepared_transactions (currently %d)." msgstr "max_prepared_transactions ê°’ì„ ëŠ˜ë ¤ì£¼ì„¸ìš” (현재 %d)." -#: access/transam/twophase.c:539 +#: access/transam/twophase.c:540 #, c-format msgid "prepared transaction with identifier \"%s\" is busy" msgstr "\"%s\" ì´ë¦„ì˜ ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ ì‹ë³„ìžê°€ 여러 ê³³ì—ì„œ ì“°ì´ê³  있습니다" -#: access/transam/twophase.c:545 +#: access/transam/twophase.c:546 #, c-format msgid "permission denied to finish prepared transaction" msgstr "ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ ë내기 ìž‘ì—… 권한 ì—†ìŒ" -#: access/transam/twophase.c:546 +#: access/transam/twophase.c:547 #, c-format msgid "Must be superuser or the user that prepared the transaction." msgstr "해당 ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ì˜ ì†Œìœ ì£¼ì´ê±°ë‚˜ superuser여야합니다" -#: access/transam/twophase.c:557 +#: access/transam/twophase.c:558 #, c-format msgid "prepared transaction belongs to another database" msgstr "ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ì´ ë‹¤ë¥¸ ë°ì´í„°ë² ì´ìŠ¤ì— ì†í•´ 있ìŒ" -#: access/transam/twophase.c:558 +#: access/transam/twophase.c:559 #, c-format msgid "" "Connect to the database where the transaction was prepared to finish it." msgstr "ìž‘ì—…ì„ ë§ˆì¹˜ë ¤ë©´ ê·¸ ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ì´ ìžˆëŠ” ë°ì´í„°ë² ì´ìŠ¤ì— 연결하십시오." -#: access/transam/twophase.c:573 +#: access/transam/twophase.c:574 #, c-format msgid "prepared transaction with identifier \"%s\" does not exist" msgstr "\"%s\" ì´ë¦„ì˜ ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ì´ ì—†ìŠµë‹ˆë‹¤" -#: access/transam/twophase.c:1042 +#: access/transam/twophase.c:1043 #, c-format msgid "two-phase state file maximum length exceeded" msgstr "2단계 ìƒíƒœ íŒŒì¼ ìµœëŒ€ 길ì´ë¥¼ 초과함" -#: access/transam/twophase.c:1160 +#: access/transam/twophase.c:1161 #, c-format msgid "could not open two-phase state file \"%s\": %m" msgstr "\"%s\" ì´ë¦„ì˜ two-phase ìƒíƒœì •ë³´ 파ì¼ì„ ì—´ 수 ì—†ìŒ: %m" -#: access/transam/twophase.c:1177 +#: access/transam/twophase.c:1178 #, c-format msgid "could not stat two-phase state file \"%s\": %m" msgstr "\"%s\" ì´ë¦„ì˜ two-phase ìƒíƒœì •ë³´ 파ì¼ì˜ 파ì¼ì •ë³´ë¥¼ ì•Œ 수 ì—†ìŒ: %m" -#: access/transam/twophase.c:1209 +#: access/transam/twophase.c:1210 #, c-format msgid "could not read two-phase state file \"%s\": %m" msgstr "\"%s\" ì´ë¦„ì˜ two-phase ìƒíƒœì •ë³´ 파ì¼ì„ ì½ì„ 수 ì—†ìŒ: %m" -#: access/transam/twophase.c:1262 access/transam/xlog.c:6080 +#: access/transam/twophase.c:1263 access/transam/xlog.c:6109 #, c-format msgid "Failed while allocating an XLog reading processor." msgstr "XLog ì½ê¸° 프로세서를 할당하는 ì¤‘ì— ì˜¤ë¥˜ ë°œìƒ" -#: access/transam/twophase.c:1268 +#: access/transam/twophase.c:1269 #, c-format msgid "could not read two-phase state from xlog at %X/%X" msgstr "two-phase ìƒíƒœì •ë³´ì„ ì½ì„ 수 ì—†ìŒ xlog 위치: %X/%X" -#: access/transam/twophase.c:1276 +#: access/transam/twophase.c:1277 #, c-format msgid "expected two-phase state data is not present in xlog at %X/%X" msgstr "xlog %X/%X ìœ„ì¹˜ì— 2단계 커밋 ìƒíƒœ ìžë£Œê°€ 없습니다" -#: access/transam/twophase.c:1511 +#: access/transam/twophase.c:1512 #, c-format msgid "could not remove two-phase state file \"%s\": %m" msgstr "\"%s\" ì´ë¦„ì˜ two-phase ìƒíƒœì •ë³´ 파ì¼ì„ 삭제할 수 ì—†ìŒ: %m" -#: access/transam/twophase.c:1541 +#: access/transam/twophase.c:1542 #, c-format msgid "could not recreate two-phase state file \"%s\": %m" msgstr "\"%s\" ì´ë¦„ì˜ two-phase ìƒíƒœì •ë³´ 파ì¼ì„ 다시 만들 수 ì—†ìŒ: %m" -#: access/transam/twophase.c:1550 access/transam/twophase.c:1557 +#: access/transam/twophase.c:1551 access/transam/twophase.c:1558 #, c-format msgid "could not write two-phase state file: %m" msgstr "two-phase ìƒíƒœì •ë³´ 파ì¼ì„ 쓸 수 ì—†ìŒ: %m" -#: access/transam/twophase.c:1569 +#: access/transam/twophase.c:1570 #, c-format msgid "could not fsync two-phase state file: %m" msgstr "two-phase ìƒíƒœì •ë³´ 파ì¼ì˜ fsync ìž‘ì—… 실패: %m" -#: access/transam/twophase.c:1575 +#: access/transam/twophase.c:1576 #, c-format msgid "could not close two-phase state file: %m" msgstr "two-phase ìƒíƒœì •ë³´ 파ì¼ì„ ë‹«ì„ ìˆ˜ ì—†ìŒ: %m" -#: access/transam/twophase.c:1648 +#: access/transam/twophase.c:1649 #, c-format msgid "" "%u two-phase state file was written for long-running prepared transactions" @@ -1675,24 +1689,24 @@ msgid_plural "" "%u two-phase state files were written for long-running prepared transactions" msgstr[0] "" -#: access/transam/twophase.c:1712 +#: access/transam/twophase.c:1713 #, c-format msgid "removing future two-phase state file \"%s\"" msgstr "\"%s\" ì´ë¦„ì˜ future two-phase ìƒíƒœì •ë³´ 파ì¼ì„ 삭제함" -#: access/transam/twophase.c:1728 access/transam/twophase.c:1739 -#: access/transam/twophase.c:1859 access/transam/twophase.c:1870 -#: access/transam/twophase.c:1947 +#: access/transam/twophase.c:1729 access/transam/twophase.c:1740 +#: access/transam/twophase.c:1860 access/transam/twophase.c:1871 +#: access/transam/twophase.c:1948 #, c-format msgid "removing corrupt two-phase state file \"%s\"" msgstr "\"%s\" ì´ë¦„ì˜ ìž˜ëª»ëœ two-phase ìƒíƒœì •ë³´ 파ì¼ì„ 삭제함" -#: access/transam/twophase.c:1848 access/transam/twophase.c:1936 +#: access/transam/twophase.c:1849 access/transam/twophase.c:1937 #, c-format msgid "removing stale two-phase state file \"%s\"" msgstr "\"%s\" ì´ë¦„ì˜ ì˜¤ëž˜ëœ two-phase ìƒíƒœì •ë³´ 파ì¼ì„ 삭제함" -#: access/transam/twophase.c:1954 +#: access/transam/twophase.c:1955 #, c-format msgid "recovering prepared transaction %u" msgstr "%u ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ì„ ë³µêµ¬í•¨" @@ -1703,8 +1717,8 @@ msgid "" "database is not accepting commands to avoid wraparound data loss in database " "\"%s\"" msgstr "" -"\"%s\" ë°ì´í„°ë² ì´ìŠ¤ 트랜잭션 ID ê²¹ì¹¨ì— ì˜í•œ ìžë£Œ ì†ì‹¤ì„ 방지하기 위해 " -"ë” ì´ìƒ ìžë£Œ ì¡°ìž‘ ìž‘ì—…ì„ í—ˆìš©í•˜ì§€ 않습니다" +"\"%s\" ë°ì´í„°ë² ì´ìŠ¤ 트랜잭션 ID ê²¹ì¹¨ì— ì˜í•œ ìžë£Œ ì†ì‹¤ì„ 방지하기 위해 ë” ì´" +"ìƒ ìžë£Œ ì¡°ìž‘ ìž‘ì—…ì„ í—ˆìš©í•˜ì§€ 않습니다" #: access/transam/varsup.c:126 access/transam/varsup.c:133 #, c-format @@ -1712,8 +1726,8 @@ msgid "" "Stop the postmaster and vacuum that database in single-user mode.\n" "You might also need to commit or roll back old prepared transactions." msgstr "" -"postmaster를 중지하고 ë‹¨ì¼ ì‚¬ìš©ìž ëª¨ë“œë¡œ 서버를 실행한 ë’¤ " -"VACUUM ìž‘ì—…ì„ í•˜ì‹­ì‹œì˜¤.\n" +"postmaster를 중지하고 ë‹¨ì¼ ì‚¬ìš©ìž ëª¨ë“œë¡œ 서버를 실행한 ë’¤ VACUUM ìž‘ì—…ì„ í•˜ì‹­" +"시오.\n" "ë˜í•œ ì˜¤ëž˜ëœ íŠ¸ëžœìž­ì…˜ì„ ì»¤ë°‹í•˜ê±°ë‚˜ 롤백할 필요가 있습니다." #: access/transam/varsup.c:131 @@ -1722,8 +1736,8 @@ msgid "" "database is not accepting commands to avoid wraparound data loss in database " "with OID %u" msgstr "" -"%u OID ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ ìžë£Œ 겹침으로 ë°œìƒí•  수 있는 ìžë£Œ ì†ì‹¤ì„ 방지하기 위해 " -"ëª…ë ¹ì„ ìˆ˜ë½í•˜ì§€ ì•ŠìŒ" +"%u OID ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ ìžë£Œ 겹침으로 ë°œìƒí•  수 있는 ìžë£Œ ì†ì‹¤ì„ 방지하기 위" +"í•´ ëª…ë ¹ì„ ìˆ˜ë½í•˜ì§€ ì•ŠìŒ" #: access/transam/varsup.c:143 access/transam/varsup.c:381 #, c-format @@ -1841,164 +1855,164 @@ msgstr "병렬 처리 중ì—는 í•˜ìœ„íŠ¸ëžœìž­ì…˜ì„ ì»¤ë°‹í•  수 ì—†ìŒ" msgid "cannot have more than 2^32-1 subtransactions in a transaction" msgstr "í•˜ë‚˜ì˜ íŠ¸ëžœìž­ì…˜ 안ì—서는 2^32-1 ê°œì˜ í•˜ìœ„íŠ¸ëžœìž­ì…˜ì„ ì´ˆê³¼í•  수 ì—†ìŒ" -#: access/transam/xlog.c:2270 +#: access/transam/xlog.c:2299 #, c-format msgid "could not seek in log file %s to offset %u: %m" msgstr "%s 파ì¼ì—ì„œ %u 위치를 ì°¾ì„ ìˆ˜ ì—†ìŒ: %m" -#: access/transam/xlog.c:2290 +#: access/transam/xlog.c:2319 #, c-format msgid "could not write to log file %s at offset %u, length %zu: %m" msgstr "%s 로그 íŒŒì¼ ì“°ê¸° 실패, 위치 %u, ê¸¸ì´ %zu: %m" -#: access/transam/xlog.c:2553 +#: access/transam/xlog.c:2582 #, c-format msgid "updated min recovery point to %X/%X on timeline %u" msgstr "최소 복구 지ì : %X/%X, 타임ë¼ì¸: %u 변경 완료" -#: access/transam/xlog.c:3195 +#: access/transam/xlog.c:3224 #, c-format msgid "not enough data in file \"%s\"" msgstr "\"%s\" 파ì¼ì— ìžë£Œê°€ 불충분합니다" -#: access/transam/xlog.c:3336 +#: access/transam/xlog.c:3365 #, c-format msgid "could not open transaction log file \"%s\": %m" msgstr "\"%s\" 트랜잭션 로그 파ì¼ì„ ì—´ 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:3525 access/transam/xlog.c:5310 +#: access/transam/xlog.c:3554 access/transam/xlog.c:5339 #, c-format msgid "could not close log file %s: %m" msgstr "%s 로그 파ì¼ì„ ë‹«ì„ ìˆ˜ ì—†ìŒ: %m" -#: access/transam/xlog.c:3582 access/transam/xlogutils.c:696 -#: replication/walsender.c:2097 +#: access/transam/xlog.c:3611 access/transam/xlogutils.c:696 +#: replication/walsender.c:2095 #, c-format msgid "requested WAL segment %s has already been removed" msgstr "요청한 %s WAL ì¡°ê° íŒŒì¼ì€ ì´ë¯¸ 지워졌ìŒ" -#: access/transam/xlog.c:3642 access/transam/xlog.c:3717 -#: access/transam/xlog.c:3915 +#: access/transam/xlog.c:3671 access/transam/xlog.c:3746 +#: access/transam/xlog.c:3944 #, c-format msgid "could not open transaction log directory \"%s\": %m" msgstr "\"%s\" 트랜잭션 로그 디렉터리 열기 실패: %m" -#: access/transam/xlog.c:3798 +#: access/transam/xlog.c:3827 #, c-format msgid "recycled transaction log file \"%s\"" msgstr "\"%s\" 트랜잭션 로그 íŒŒì¼ ìž¬í™œìš©í•¨" -#: access/transam/xlog.c:3810 +#: access/transam/xlog.c:3839 #, c-format msgid "removing transaction log file \"%s\"" msgstr "\"%s\" 트랜잭션 로그 íŒŒì¼ ì‚­ì œ 중" -#: access/transam/xlog.c:3830 +#: access/transam/xlog.c:3859 #, c-format msgid "could not rename old transaction log file \"%s\": %m" msgstr "ì´ì „ 트랜잭션 로그 íŒŒì¼ \"%s\"ì˜ ì´ë¦„ì„ ë°”ê¿€ 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:3842 +#: access/transam/xlog.c:3871 #, c-format msgid "could not remove old transaction log file \"%s\": %m" msgstr "ì´ì „ 트랜잭션 로그 íŒŒì¼ \"%s\"ì„(를) 제거할 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:3875 access/transam/xlog.c:3885 +#: access/transam/xlog.c:3904 access/transam/xlog.c:3914 #, c-format msgid "required WAL directory \"%s\" does not exist" msgstr "필요한 WAL 디렉터리 \"%s\"ì´(ê°€) ì—†ìŒ" -#: access/transam/xlog.c:3891 +#: access/transam/xlog.c:3920 #, c-format msgid "creating missing WAL directory \"%s\"" msgstr "누ë½ëœ WAL 디렉터리 \"%s\"ì„(를) 만드는 중" -#: access/transam/xlog.c:3894 +#: access/transam/xlog.c:3923 #, c-format msgid "could not create missing directory \"%s\": %m" msgstr "누ë½ëœ \"%s\" 디렉터리를 만들 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:3925 +#: access/transam/xlog.c:3954 #, c-format msgid "removing transaction log backup history file \"%s\"" msgstr "\"%s\" 트랜잭션 로그 백업 히스토리 íŒŒì¼ ì‚­ì œ 중" -#: access/transam/xlog.c:4006 +#: access/transam/xlog.c:4035 #, c-format msgid "unexpected timeline ID %u in log segment %s, offset %u" msgstr "예ìƒì¹˜ 못한 타임ë¼ì¸ ID %u, 로그 ì¡°ê°: %s, 위치: %u" -#: access/transam/xlog.c:4128 +#: access/transam/xlog.c:4157 #, c-format msgid "new timeline %u is not a child of database system timeline %u" msgstr "요청한 %u 타임ë¼ì¸ì€ %u ë°ì´í„°ë² ì´ìŠ¤ 시스템 타임ë¼ì¸ì˜ 하위가 아님" -#: access/transam/xlog.c:4142 +#: access/transam/xlog.c:4171 #, c-format msgid "" "new timeline %u forked off current database system timeline %u before " "current recovery point %X/%X" msgstr "" -#: access/transam/xlog.c:4161 +#: access/transam/xlog.c:4190 #, c-format msgid "new target timeline is %u" msgstr "새 ëŒ€ìƒ íƒ€ìž„ë¼ì¸: %u" -#: access/transam/xlog.c:4241 +#: access/transam/xlog.c:4270 #, c-format msgid "could not create control file \"%s\": %m" msgstr "\"%s\" 컨트롤 íŒŒì¼ ë§Œë“¤ 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:4252 access/transam/xlog.c:4488 +#: access/transam/xlog.c:4281 access/transam/xlog.c:4517 #, c-format msgid "could not write to control file: %m" msgstr "컨트롤 파ì¼ì„ 쓸 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:4258 access/transam/xlog.c:4494 +#: access/transam/xlog.c:4287 access/transam/xlog.c:4523 #, c-format msgid "could not fsync control file: %m" msgstr "컨트롤 íŒŒì¼ fsync 실패: %m" -#: access/transam/xlog.c:4263 access/transam/xlog.c:4499 +#: access/transam/xlog.c:4292 access/transam/xlog.c:4528 #, c-format msgid "could not close control file: %m" msgstr "컨트롤 íŒŒì¼ ë‹«ê¸° 실패: %m" -#: access/transam/xlog.c:4281 access/transam/xlog.c:4477 +#: access/transam/xlog.c:4310 access/transam/xlog.c:4506 #, c-format msgid "could not open control file \"%s\": %m" msgstr "\"%s\" 컨트롤 íŒŒì¼ ì—´ê¸° 실패: %m" -#: access/transam/xlog.c:4287 +#: access/transam/xlog.c:4316 #, c-format msgid "could not read from control file: %m" msgstr "컨트롤 íŒŒì¼ ì½ê¸° 실패: %m" -#: access/transam/xlog.c:4300 access/transam/xlog.c:4309 -#: access/transam/xlog.c:4333 access/transam/xlog.c:4340 -#: access/transam/xlog.c:4347 access/transam/xlog.c:4352 -#: access/transam/xlog.c:4359 access/transam/xlog.c:4366 -#: access/transam/xlog.c:4373 access/transam/xlog.c:4380 -#: access/transam/xlog.c:4387 access/transam/xlog.c:4394 -#: access/transam/xlog.c:4401 access/transam/xlog.c:4410 -#: access/transam/xlog.c:4417 access/transam/xlog.c:4426 -#: access/transam/xlog.c:4433 access/transam/xlog.c:4442 -#: access/transam/xlog.c:4449 utils/init/miscinit.c:1380 +#: access/transam/xlog.c:4329 access/transam/xlog.c:4338 +#: access/transam/xlog.c:4362 access/transam/xlog.c:4369 +#: access/transam/xlog.c:4376 access/transam/xlog.c:4381 +#: access/transam/xlog.c:4388 access/transam/xlog.c:4395 +#: access/transam/xlog.c:4402 access/transam/xlog.c:4409 +#: access/transam/xlog.c:4416 access/transam/xlog.c:4423 +#: access/transam/xlog.c:4430 access/transam/xlog.c:4439 +#: access/transam/xlog.c:4446 access/transam/xlog.c:4455 +#: access/transam/xlog.c:4462 access/transam/xlog.c:4471 +#: access/transam/xlog.c:4478 utils/init/miscinit.c:1380 #, c-format msgid "database files are incompatible with server" msgstr "ë°ì´í„°ë² ì´ìŠ¤ 파ì¼ë“¤ì´ 서버와 í˜¸í™˜ì„±ì´ ì—†ìŠµë‹ˆë‹¤" -#: access/transam/xlog.c:4301 +#: access/transam/xlog.c:4330 #, c-format msgid "" "The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x), " "but the server was compiled with PG_CONTROL_VERSION %d (0x%08x)." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” PG_CONTROL_VERSION %d (0x%08x)(으)ë¡œ 초기화ë˜ì—ˆì§€" -"만 서버는 PG_CONTROL_VERSION %d (0x%08x)(으)ë¡œ 컴파ì¼ë˜ì—ˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” PG_CONTROL_VERSION %d (0x%08x)(으)ë¡œ 초기화ë˜ì—ˆì§€ë§Œ " +"서버는 PG_CONTROL_VERSION %d (0x%08x)(으)ë¡œ 컴파ì¼ë˜ì—ˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4305 +#: access/transam/xlog.c:4334 #, c-format msgid "" "This could be a problem of mismatched byte ordering. It looks like you need " @@ -2006,7 +2020,7 @@ msgid "" msgstr "" "ì´ê²ƒì€ ë°”ì´íŠ¸ 순서 불ì¼ì¹˜ ë¬¸ì œì¼ ìˆ˜ 있습니다. initdb ìž‘ì—…ì´ í•„ìš”í•´ 보입니다." -#: access/transam/xlog.c:4310 +#: access/transam/xlog.c:4339 #, c-format msgid "" "The database cluster was initialized with PG_CONTROL_VERSION %d, but the " @@ -2015,18 +2029,18 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” PG_CONTROL_VERSION %d 버전으로 초기화 ë˜ì—ˆì§€ë§Œ, ì„œ" "버는 PG_CONTROL_VERSION %d 버전으로 ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4313 access/transam/xlog.c:4337 -#: access/transam/xlog.c:4344 access/transam/xlog.c:4349 +#: access/transam/xlog.c:4342 access/transam/xlog.c:4366 +#: access/transam/xlog.c:4373 access/transam/xlog.c:4378 #, c-format msgid "It looks like you need to initdb." msgstr "initdb ëª…ë ¹ì´ í•„ìš”í•œ 듯 합니다" -#: access/transam/xlog.c:4324 +#: access/transam/xlog.c:4353 #, c-format msgid "incorrect checksum in control file" msgstr "컨트롤 파ì¼ì— ìž˜ëª»ëœ ì²´í¬ì„¬ ê°’ì´ ìžˆìŠµë‹ˆë‹¤" -#: access/transam/xlog.c:4334 +#: access/transam/xlog.c:4363 #, c-format msgid "" "The database cluster was initialized with CATALOG_VERSION_NO %d, but the " @@ -2035,7 +2049,7 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” CATALOG_VERSION_NO %d 버전으로 초기화 ë˜ì—ˆì§€ë§Œ, ì„œ" "버는 CATALOG_VERSION_NO %d 버전으로 ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4341 +#: access/transam/xlog.c:4370 #, c-format msgid "" "The database cluster was initialized with MAXALIGN %d, but the server was " @@ -2044,16 +2058,16 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” MAXALIGN %d (으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 " "MAXALIGN %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4348 +#: access/transam/xlog.c:4377 #, c-format msgid "" "The database cluster appears to use a different floating-point number format " "than the server executable." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ì™€ 서버 실행 파ì¼ì´ 서로 다른 ë¶€ë™ ì†Œìˆ˜ì  ìˆ«ìž í˜•ì‹ì„ " -"사용하고 있습니다." +"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ì™€ 서버 실행 파ì¼ì´ 서로 다른 ë¶€ë™ ì†Œìˆ˜ì  ìˆ«ìž í˜•ì‹ì„ 사" +"용하고 있습니다." -#: access/transam/xlog.c:4353 +#: access/transam/xlog.c:4382 #, c-format msgid "" "The database cluster was initialized with BLCKSZ %d, but the server was " @@ -2062,20 +2076,20 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” BLCKSZ %d (으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 BLCKSZ " "%d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4356 access/transam/xlog.c:4363 -#: access/transam/xlog.c:4370 access/transam/xlog.c:4377 -#: access/transam/xlog.c:4384 access/transam/xlog.c:4391 -#: access/transam/xlog.c:4398 access/transam/xlog.c:4405 +#: access/transam/xlog.c:4385 access/transam/xlog.c:4392 +#: access/transam/xlog.c:4399 access/transam/xlog.c:4406 #: access/transam/xlog.c:4413 access/transam/xlog.c:4420 -#: access/transam/xlog.c:4429 access/transam/xlog.c:4436 -#: access/transam/xlog.c:4445 access/transam/xlog.c:4452 +#: access/transam/xlog.c:4427 access/transam/xlog.c:4434 +#: access/transam/xlog.c:4442 access/transam/xlog.c:4449 +#: access/transam/xlog.c:4458 access/transam/xlog.c:4465 +#: access/transam/xlog.c:4474 access/transam/xlog.c:4481 #, c-format msgid "It looks like you need to recompile or initdb." msgstr "" "서버를 새로 ì»´íŒŒì¼ í•˜ê±°ë‚˜ initdb ëª…ë ¹ì„ ì‚¬ìš©í•´ 새로 ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ë¥¼ " "다시 만들거나 해야할 것 같습니다." -#: access/transam/xlog.c:4360 +#: access/transam/xlog.c:4389 #, c-format msgid "" "The database cluster was initialized with RELSEG_SIZE %d, but the server was " @@ -2084,7 +2098,7 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” RELSEG_SIZE %d (으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 " "RELSEG_SIZE %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4367 +#: access/transam/xlog.c:4396 #, c-format msgid "" "The database cluster was initialized with XLOG_BLCKSZ %d, but the server was " @@ -2093,7 +2107,7 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” XLOG_BLCKSZ %d (으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 " "XLOG_BLCKSZ %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4374 +#: access/transam/xlog.c:4403 #, c-format msgid "" "The database cluster was initialized with XLOG_SEG_SIZE %d, but the server " @@ -2102,7 +2116,7 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” XLOG_SEG_SIZE %d (으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 " "XLOG_SEG_SIZE %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4381 +#: access/transam/xlog.c:4410 #, c-format msgid "" "The database cluster was initialized with NAMEDATALEN %d, but the server was " @@ -2111,7 +2125,7 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” NAMEDATALEN %d (으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 " "NAMEDATALEN %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4388 +#: access/transam/xlog.c:4417 #, c-format msgid "" "The database cluster was initialized with INDEX_MAX_KEYS %d, but the server " @@ -2120,25 +2134,25 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” INDEX_MAX_KEYS %d (으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 " "INDEX_MAX_KEYS %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4395 +#: access/transam/xlog.c:4424 #, c-format msgid "" "The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d, but the " "server was compiled with TOAST_MAX_CHUNK_SIZE %d." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” TOAST_MAX_CHUNK_SIZE %d(으)ë¡œ 초기화ë˜ì—ˆì§€ë§Œ " -"서버는 TOAST_MAX_CHUNK_SIZE %d(으)ë¡œ ì»´íŒŒì¼ ë˜ì—ˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” TOAST_MAX_CHUNK_SIZE %d(으)ë¡œ 초기화ë˜ì—ˆì§€ë§Œ 서버는 " +"TOAST_MAX_CHUNK_SIZE %d(으)ë¡œ ì»´íŒŒì¼ ë˜ì—ˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4402 +#: access/transam/xlog.c:4431 #, c-format msgid "" "The database cluster was initialized with LOBLKSIZE %d, but the server was " "compiled with LOBLKSIZE %d." msgstr "" -"ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” LOBLKSIZE %d(으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, " -"서버는 LOBLKSIZE %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." +"ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” LOBLKSIZE %d(으)ë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, 서버는 " +"LOBLKSIZE %d (으)ë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4411 +#: access/transam/xlog.c:4440 #, c-format msgid "" "The database cluster was initialized without HAVE_INT64_TIMESTAMP but the " @@ -2147,7 +2161,7 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” HAVE_INT64_TIMESTAMP ê°’ì´ falseë¡œ 초기화 ë˜ì—ˆì§€" "만, 서버는 HAVE_INT64_TIMESTAMP ê°’ì´ trueë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4418 +#: access/transam/xlog.c:4447 #, c-format msgid "" "The database cluster was initialized with HAVE_INT64_TIMESTAMP but the " @@ -2156,236 +2170,238 @@ msgstr "" "ì´ ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” HAVE_INT64_TIMESTAMP ê°’ì´ trueë¡œ 초기화 ë˜ì—ˆì§€ë§Œ, " "서버는 HAVE_INT64_TIMESTAMP ê°’ì´ falseë¡œ ì»´íŒŒì¼ ë˜ì–´ìžˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4427 +#: access/transam/xlog.c:4456 #, c-format msgid "" "The database cluster was initialized without USE_FLOAT4_BYVAL but the server " "was compiled with USE_FLOAT4_BYVAL." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT4_BYVAL ì—†ì´ ì´ˆê¸°í™”ë˜ì—ˆì§€ë§Œ, " -"서버는 USE_FLOAT4_BYVALì„ ì‚¬ìš©í•˜ì—¬ 컴파ì¼ë˜ì—ˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT4_BYVAL ì—†ì´ ì´ˆê¸°í™”ë˜ì—ˆì§€ë§Œ, 서버는 " +"USE_FLOAT4_BYVALì„ ì‚¬ìš©í•˜ì—¬ 컴파ì¼ë˜ì—ˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4434 +#: access/transam/xlog.c:4463 #, c-format msgid "" "The database cluster was initialized with USE_FLOAT4_BYVAL but the server " "was compiled without USE_FLOAT4_BYVAL." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT4_BYVALì„ ì‚¬ìš©í•˜ì—¬ 초기화ë˜ì—ˆì§€ë§Œ, " -"서버는 USE_FLOAT4_BYVAL ì—†ì´ ì»´íŒŒì¼ë˜ì—ˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT4_BYVALì„ ì‚¬ìš©í•˜ì—¬ 초기화ë˜ì—ˆì§€ë§Œ, 서버는 " +"USE_FLOAT4_BYVAL ì—†ì´ ì»´íŒŒì¼ë˜ì—ˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4443 +#: access/transam/xlog.c:4472 #, c-format msgid "" "The database cluster was initialized without USE_FLOAT8_BYVAL but the server " "was compiled with USE_FLOAT8_BYVAL." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT8_BYVAL ì—†ì´ ì´ˆê¸°í™”ë˜ì—ˆì§€ë§Œ, " -"서버는 USE_FLOAT8_BYVALì„ ì‚¬ìš©í•˜ì—¬ 컴파ì¼ë˜ì—ˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT8_BYVAL ì—†ì´ ì´ˆê¸°í™”ë˜ì—ˆì§€ë§Œ, 서버는 " +"USE_FLOAT8_BYVALì„ ì‚¬ìš©í•˜ì—¬ 컴파ì¼ë˜ì—ˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4450 +#: access/transam/xlog.c:4479 #, c-format msgid "" "The database cluster was initialized with USE_FLOAT8_BYVAL but the server " "was compiled without USE_FLOAT8_BYVAL." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT8_BYVALì„ ì‚¬ìš©í•˜ì—¬ 초기화ë˜ì—ˆì§€ë§Œ, " -"서버는 USE_FLOAT8_BYVAL ì—†ì´ ì»´íŒŒì¼ë˜ì—ˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ í´ëŸ¬ìŠ¤í„°ëŠ” USE_FLOAT8_BYVALì„ ì‚¬ìš©í•˜ì—¬ 초기화ë˜ì—ˆì§€ë§Œ, 서버는 " +"USE_FLOAT8_BYVAL ì—†ì´ ì»´íŒŒì¼ë˜ì—ˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:4871 +#: access/transam/xlog.c:4900 #, c-format msgid "could not write bootstrap transaction log file: %m" msgstr "bootstrap 트랜잭션 로그 파ì¼ì„ 쓸 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:4877 +#: access/transam/xlog.c:4906 #, c-format msgid "could not fsync bootstrap transaction log file: %m" msgstr "bootstrap 트랜잭션 로그 파ì¼ì„ fsyncí•  수 ì—†ìŒ: %m" -#: access/transam/xlog.c:4882 +#: access/transam/xlog.c:4911 #, c-format msgid "could not close bootstrap transaction log file: %m" msgstr "bootstrap 트랜잭션 로그 파ì¼ì„ ë‹«ì„ ìˆ˜ ì—†ìŒ: %m" -#: access/transam/xlog.c:4957 +#: access/transam/xlog.c:4986 #, c-format msgid "could not open recovery command file \"%s\": %m" msgstr "복구명령 íŒŒì¼ \"%s\"ì„ ì—´ 수 없습니다: %m" -#: access/transam/xlog.c:5003 access/transam/xlog.c:5088 +#: access/transam/xlog.c:5032 access/transam/xlog.c:5117 #, c-format msgid "invalid value for recovery parameter \"%s\": \"%s\"" msgstr "ìž˜ëª»ëœ \"%s\" 복구 매개 ë³€ìˆ˜ì˜ ê°’: \"%s\"" -#: access/transam/xlog.c:5006 +#: access/transam/xlog.c:5035 #, c-format msgid "Valid values are \"pause\", \"promote\", and \"shutdown\"." msgstr "사용할 수 있는 ê°’: \"pause\", \"promote\", \"shutdown\"" -#: access/transam/xlog.c:5026 +#: access/transam/xlog.c:5055 #, c-format msgid "recovery_target_timeline is not a valid number: \"%s\"" msgstr "recovery_target_timeline 값으로 ìž˜ëª»ëœ ìˆ«ìž: \"%s\"" -#: access/transam/xlog.c:5043 +#: access/transam/xlog.c:5072 #, c-format msgid "recovery_target_xid is not a valid number: \"%s\"" msgstr "recovery_target_xid 값으로 ìž˜ëª»ëœ ìˆ«ìž: \"%s\"" -#: access/transam/xlog.c:5074 +#: access/transam/xlog.c:5103 #, c-format msgid "recovery_target_name is too long (maximum %d characters)" msgstr "recovery_target_name ì„¤ì •ê°’ì´ ë„ˆë¬´ ê¹ë‹ˆë‹¤ (최대 %d 문ìž)" -#: access/transam/xlog.c:5091 +#: access/transam/xlog.c:5120 #, c-format msgid "The only allowed value is \"immediate\"." msgstr "ì´ ê°’ìœ¼ë¡œëŠ” \"immediate\" 만 허용합니다." -#: access/transam/xlog.c:5104 access/transam/xlog.c:5115 -#: commands/extension.c:533 commands/extension.c:541 utils/misc/guc.c:5642 +#: access/transam/xlog.c:5133 access/transam/xlog.c:5144 +#: commands/extension.c:534 commands/extension.c:542 utils/misc/guc.c:5640 #, c-format msgid "parameter \"%s\" requires a Boolean value" msgstr "\"%s\" 매개 ë³€ìˆ˜ì˜ ê°’ì€ boolean ê°’ì´ì–´ì•¼í•©ë‹ˆë‹¤." -#: access/transam/xlog.c:5150 +#: access/transam/xlog.c:5179 #, c-format msgid "parameter \"%s\" requires a temporal value" msgstr "\"%s\" 매개 ë³€ìˆ˜ì˜ ê°’ì€ ì‹œê°„ê°’ì´ì–´ì•¼ 합니다." -#: access/transam/xlog.c:5152 catalog/dependency.c:991 -#: catalog/dependency.c:992 catalog/dependency.c:998 catalog/dependency.c:999 -#: catalog/dependency.c:1010 catalog/dependency.c:1011 -#: catalog/objectaddress.c:1100 commands/tablecmds.c:795 -#: commands/tablecmds.c:9445 commands/user.c:1045 commands/view.c:470 +#: access/transam/xlog.c:5181 catalog/dependency.c:990 +#: catalog/dependency.c:991 catalog/dependency.c:997 catalog/dependency.c:998 +#: catalog/dependency.c:1009 catalog/dependency.c:1010 +#: catalog/objectaddress.c:1100 commands/tablecmds.c:796 +#: commands/tablecmds.c:9542 commands/user.c:1045 commands/view.c:499 #: libpq/auth.c:307 replication/syncrep.c:919 storage/lmgr/deadlock.c:1139 -#: storage/lmgr/proc.c:1276 utils/adt/acl.c:5281 utils/misc/guc.c:5664 -#: utils/misc/guc.c:5757 utils/misc/guc.c:9700 utils/misc/guc.c:9734 -#: utils/misc/guc.c:9768 utils/misc/guc.c:9802 utils/misc/guc.c:9837 +#: storage/lmgr/proc.c:1278 utils/adt/acl.c:5281 utils/misc/guc.c:5662 +#: utils/misc/guc.c:5755 utils/misc/guc.c:9708 utils/misc/guc.c:9742 +#: utils/misc/guc.c:9776 utils/misc/guc.c:9810 utils/misc/guc.c:9845 #, c-format msgid "%s" msgstr "%s" -#: access/transam/xlog.c:5159 +#: access/transam/xlog.c:5188 #, c-format msgid "unrecognized recovery parameter \"%s\"" msgstr "ì•Œ 수 없는 복구 매개 변수 ì´ë¦„: \"%s\"" -#: access/transam/xlog.c:5170 +#: access/transam/xlog.c:5199 #, c-format msgid "" "recovery command file \"%s\" specified neither primary_conninfo nor " "restore_command" msgstr "" -"복구 명령 íŒŒì¼ \"%s\"ì—ì„œ primary_conninfo 설정ë„, " -"restore_command ì„¤ì •ë„ ì—†ìŠµë‹ˆë‹¤." +"복구 명령 íŒŒì¼ \"%s\"ì—ì„œ primary_conninfo 설정ë„, restore_command ì„¤ì •ë„ ì—†" +"습니다." -#: access/transam/xlog.c:5172 +#: access/transam/xlog.c:5201 #, c-format msgid "" "The database server will regularly poll the pg_xlog subdirectory to check " "for files placed there." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ 서버는 ì¼ë°˜ì ìœ¼ë¡œ 주 서버ì—ì„œ ë°œìƒí•œ 트랜잭션 로그를 ë°˜ì˜í•˜ê¸° 위해 " -"pg_xlog 하위 디렉터리를 조사할 것입니다." +"ë°ì´í„°ë² ì´ìŠ¤ 서버는 ì¼ë°˜ì ìœ¼ë¡œ 주 서버ì—ì„œ ë°œìƒí•œ 트랜잭션 로그를 ë°˜ì˜í•˜ê¸° 위" +"í•´ pg_xlog 하위 디렉터리를 조사할 것입니다." -#: access/transam/xlog.c:5179 +#: access/transam/xlog.c:5208 #, c-format msgid "" "recovery command file \"%s\" must specify restore_command when standby mode " "is not enabled" msgstr "" -"대기 모드를 활성화 하지 않았다면(standby_mode = off), " -"복구 명령 íŒŒì¼ \"%s\"ì—ì„œ restore_command ì„¤ì •ì€ ë°˜ë“œì‹œ 있어야 합니다." +"대기 모드를 활성화 하지 않았다면(standby_mode = off), 복구 명령 íŒŒì¼ \"%s\"ì—" +"ì„œ restore_command ì„¤ì •ì€ ë°˜ë“œì‹œ 있어야 합니다." -#: access/transam/xlog.c:5200 +#: access/transam/xlog.c:5229 #, c-format msgid "standby mode is not supported by single-user servers" msgstr "ë‹¨ì¼ ì‚¬ìš©ìž ì„œë²„ë¥¼ 대ìƒìœ¼ë¡œ 대기 모드를 사용할 수 없습니다." -#: access/transam/xlog.c:5219 +#: access/transam/xlog.c:5248 #, c-format msgid "recovery target timeline %u does not exist" msgstr "%u 복구 ëŒ€ìƒ íƒ€ìž„ë¼ì¸ì´ ì—†ìŒ" -#: access/transam/xlog.c:5340 +#: access/transam/xlog.c:5369 #, c-format msgid "archive recovery complete" msgstr "ì•„ì¹´ì´ë¸Œ 복구 완료" -#: access/transam/xlog.c:5399 access/transam/xlog.c:5627 +#: access/transam/xlog.c:5428 access/transam/xlog.c:5656 #, c-format msgid "recovery stopping after reaching consistency" msgstr "ì¼ê´€ì„±ì„ 다 맞추어 복구 ìž‘ì—…ì„ ì¤‘ì§€í•©ë‹ˆë‹¤." -#: access/transam/xlog.c:5487 +#: access/transam/xlog.c:5516 #, c-format msgid "recovery stopping before commit of transaction %u, time %s" msgstr "%u 트랜잭션 커밋 ì „ 복구 중지함, 시간 %s" -#: access/transam/xlog.c:5494 +#: access/transam/xlog.c:5523 #, c-format msgid "recovery stopping before abort of transaction %u, time %s" msgstr "%u 트랜잭션 중단 ì „ 복구 중지함, 시간 %s" -#: access/transam/xlog.c:5539 +#: access/transam/xlog.c:5568 #, c-format msgid "recovery stopping at restore point \"%s\", time %s" msgstr "복구 중지함, 복구 위치 \"%s\", 시간 %s" -#: access/transam/xlog.c:5607 +#: access/transam/xlog.c:5636 #, c-format msgid "recovery stopping after commit of transaction %u, time %s" msgstr "%u 트랜잭션 커밋 후 복구 중지함, 시간 %s" -#: access/transam/xlog.c:5615 +#: access/transam/xlog.c:5644 #, c-format msgid "recovery stopping after abort of transaction %u, time %s" msgstr "%u 트랜잭션 중단 후 복구 중지함, 시간 %s" -#: access/transam/xlog.c:5654 +#: access/transam/xlog.c:5683 #, c-format msgid "recovery has paused" msgstr "복구 ìž‘ì—…ì´ ì¼ì‹œ 중지 ë¨" -#: access/transam/xlog.c:5655 +#: access/transam/xlog.c:5684 #, c-format msgid "Execute pg_xlog_replay_resume() to continue." msgstr "ê³„ì† ì§„í–‰í•˜ë ¤ë©´, pg_xlog_replay_resume() 함수를 호출하세요." -#: access/transam/xlog.c:5862 +#: access/transam/xlog.c:5891 #, c-format msgid "" "hot standby is not possible because %s = %d is a lower setting than on the " "master server (its value was %d)" msgstr "" -"ì½ê¸° ì „ìš© 대기 서버로 ìš´ì˜ì´ 불가능합니다. 현재 %s = %d ì„¤ì •ì€ ì£¼ ì„œë²„ì˜ " -"설정값(%d)보다 낮게 설정 ë˜ì–´ 있기 때문입니다." +"ì½ê¸° ì „ìš© 대기 서버로 ìš´ì˜ì´ 불가능합니다. 현재 %s = %d ì„¤ì •ì€ ì£¼ ì„œë²„ì˜ ì„¤ì •" +"ê°’(%d)보다 낮게 설정 ë˜ì–´ 있기 때문입니다." -#: access/transam/xlog.c:5888 +#: access/transam/xlog.c:5917 #, c-format msgid "WAL was generated with wal_level=minimal, data may be missing" -msgstr "WAL ë‚´ìš©ì´ wal_level=minimal 설정으로 만들여졌습니다. ìžë£Œê°€ ì†ì‹¤ ë  ìˆ˜ 있습니다." +msgstr "" +"WAL ë‚´ìš©ì´ wal_level=minimal 설정으로 만들여졌습니다. ìžë£Œê°€ ì†ì‹¤ ë  ìˆ˜ 있습" +"니다." -#: access/transam/xlog.c:5889 +#: access/transam/xlog.c:5918 #, c-format msgid "" "This happens if you temporarily set wal_level=minimal without taking a new " "base backup." msgstr "" -"ì´ ë¬¸ì œëŠ” 새 ë² ì´ìŠ¤ ë°±ì—…ì„ ë°›ì§€ ì•Šì€ ìƒíƒœì—ì„œ 서버가 ì¼ì‹œì ìœ¼ë¡œ wal_level=minimal " -"설정으로 ìš´ì˜ëœ ì ì´ 있다면 ë°œìƒí•©ë‹ˆë‹¤." +"ì´ ë¬¸ì œëŠ” 새 ë² ì´ìŠ¤ ë°±ì—…ì„ ë°›ì§€ ì•Šì€ ìƒíƒœì—ì„œ 서버가 ì¼ì‹œì ìœ¼ë¡œ " +"wal_level=minimal 설정으로 ìš´ì˜ëœ ì ì´ 있다면 ë°œìƒí•©ë‹ˆë‹¤." -#: access/transam/xlog.c:5900 +#: access/transam/xlog.c:5929 #, c-format msgid "" "hot standby is not possible because wal_level was not set to \"replica\" or " "higher on the master server" msgstr "" -"주 서버 wal_level ì„¤ì •ì´ \"replica\" ë˜ëŠ” ê·¸ ì´ìƒ 수준으로 설정ë˜ì§€ ì•Šì•„, " -"ì½ê¸° ì „ìš© ë³´ì¡° 서버로 ìš´ì˜ë  수 ì—†ìŒ" +"주 서버 wal_level ì„¤ì •ì´ \"replica\" ë˜ëŠ” ê·¸ ì´ìƒ 수준으로 설정ë˜ì§€ ì•Šì•„, ì½" +"기 ì „ìš© ë³´ì¡° 서버로 ìš´ì˜ë  수 ì—†ìŒ" -#: access/transam/xlog.c:5901 +#: access/transam/xlog.c:5930 #, c-format msgid "" "Either set wal_level to \"replica\" on the master, or turn off hot_standby " @@ -2394,34 +2410,34 @@ msgstr "" "ìš´ì˜ ì„œë²„ì˜ í™˜ê²½ 설정ì—ì„œ wal_leve = \"replica\" 형태로 지정하든가 " "hot_standby = off 형태로 지정하십시오." -#: access/transam/xlog.c:5958 +#: access/transam/xlog.c:5987 #, c-format msgid "control file contains invalid data" msgstr "컨트롤 파ì¼ì— ìž˜ëª»ëœ ë°ì´í„°ê°€ 있습니다" -#: access/transam/xlog.c:5964 +#: access/transam/xlog.c:5993 #, c-format msgid "database system was shut down at %s" msgstr "ë°ì´í„°ë² ì´ìŠ¤ 시스템 마지막 ê°€ë™ ì¤‘ì§€ ì‹œê°: %s" -#: access/transam/xlog.c:5969 +#: access/transam/xlog.c:5998 #, c-format msgid "database system was shut down in recovery at %s" msgstr "복구 중 ë°ì´í„°ë² ì´ìŠ¤ 시스템 마지막 ê°€ë™ ì¤‘ì§€ ì‹œê°: %s" -#: access/transam/xlog.c:5973 +#: access/transam/xlog.c:6002 #, c-format msgid "database system shutdown was interrupted; last known up at %s" msgstr "" "ë°ì´í„°ë² ì´ìŠ¤ 시스템 셧다운 ìž‘ì—…ì´ ë¹„ì •ìƒì ìœ¼ë¡œ 종료ë˜ì—ˆìŒ; 마지막 ìš´ì˜ì‹œê°„: " "%s" -#: access/transam/xlog.c:5977 +#: access/transam/xlog.c:6006 #, c-format msgid "database system was interrupted while in recovery at %s" msgstr "ë°ì´í„°ë² ì´ìŠ¤ 시스템 복구하는 ë„중 비정ìƒì ìœ¼ë¡œ ê°€ë™ ì¤‘ì§€ëœ ì‹œê°: %s" -#: access/transam/xlog.c:5979 +#: access/transam/xlog.c:6008 #, c-format msgid "" "This probably means that some data is corrupted and you will have to use the " @@ -2430,12 +2446,12 @@ msgstr "" "ì´ ì‚¬íƒœëŠ” 몇몇 ë°ì´í„°ê°€ ì†ìƒë˜ì—ˆì„ ì˜ë¯¸í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤. 확ì¸í•´ ë³´ê³ , 필요하" "다면, 마지막 백업 ìžë£Œë¡œ 복구해서 사용하세요." -#: access/transam/xlog.c:5983 +#: access/transam/xlog.c:6012 #, c-format msgid "database system was interrupted while in recovery at log time %s" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ë¡œê·¸ 시간 %sì— ë³µêµ¬ ë„중 중지 ë˜ì—ˆìŒ" -#: access/transam/xlog.c:5985 +#: access/transam/xlog.c:6014 #, c-format msgid "" "If this has occurred more than once some data might be corrupted and you " @@ -2444,52 +2460,52 @@ msgstr "" "ì´ ì‚¬íƒœë¡œ 몇몇 ìžë£Œê°€ ì†ìƒë˜ì—ˆì„ ìˆ˜ë„ ìžˆëŠ”ë°, ì´ëŸ° 경우ë¼ë©´,확ì¸í•´ ë³´ê³ , í•„ìš”" "하다면, 마지막 백업 ìžë£Œë¡œ 복구해서 사용하세요." -#: access/transam/xlog.c:5989 +#: access/transam/xlog.c:6018 #, c-format msgid "database system was interrupted; last known up at %s" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ë¹„ì •ìƒì ìœ¼ë¡œ 종료ë˜ì—ˆìŒ; 마지막 ìš´ì˜ì‹œê°„: %s" -#: access/transam/xlog.c:6045 +#: access/transam/xlog.c:6074 #, c-format msgid "entering standby mode" msgstr "대기 모드로 전환합니다" -#: access/transam/xlog.c:6048 +#: access/transam/xlog.c:6077 #, c-format msgid "starting point-in-time recovery to XID %u" msgstr "%u XID까지 ì‹œì  ê¸°ë°˜ 복구 ìž‘ì—…ì„ ì‹œìž‘í•©ë‹ˆë‹¤" -#: access/transam/xlog.c:6052 +#: access/transam/xlog.c:6081 #, c-format msgid "starting point-in-time recovery to %s" msgstr "%s 까지 ì‹œì  ë³µêµ¬ ìž‘ì—…ì„ ì‹œìž‘í•©ë‹ˆë‹¤" -#: access/transam/xlog.c:6056 +#: access/transam/xlog.c:6085 #, c-format msgid "starting point-in-time recovery to \"%s\"" msgstr "\"%s\" 복구 ëŒ€ìƒ ì´ë¦„까지 ì‹œì  ë³µêµ¬ ìž‘ì—…ì„ ì‹œìž‘í•©ë‹ˆë‹¤" -#: access/transam/xlog.c:6060 +#: access/transam/xlog.c:6089 #, c-format msgid "starting point-in-time recovery to earliest consistent point" msgstr "ë™ê¸°í™” í•  수 있는 마지막 지ì ê¹Œì§€ ì‹œì  ë³µêµ¬ ìž‘ì—…ì„ ì‹œìž‘í•©ë‹ˆë‹¤" -#: access/transam/xlog.c:6063 +#: access/transam/xlog.c:6092 #, c-format msgid "starting archive recovery" msgstr "ì•„ì¹´ì´ë¸Œ 복구 ìž‘ì—…ì„ ì‹œìž‘í•©ë‹ˆë‹¤" -#: access/transam/xlog.c:6107 access/transam/xlog.c:6235 +#: access/transam/xlog.c:6136 access/transam/xlog.c:6264 #, c-format msgid "checkpoint record is at %X/%X" msgstr "ì²´í¬í¬ì¸íŠ¸ 레코드 위치: %X/%X" -#: access/transam/xlog.c:6121 +#: access/transam/xlog.c:6150 #, c-format msgid "could not find redo location referenced by checkpoint record" msgstr "ì²´í¬í¬ì¸íŠ¸ 기ë¡ìœ¼ë¡œ 참조하는 재실행 위치를 ì°¾ì„ ìˆ˜ ì—†ìŒ" -#: access/transam/xlog.c:6122 access/transam/xlog.c:6129 +#: access/transam/xlog.c:6151 access/transam/xlog.c:6158 #, c-format msgid "" "If you are not restoring from a backup, try removing the file \"%s/" @@ -2498,78 +2514,79 @@ msgstr "" "실시간 백업 ìžë£Œë¡œë¶€í„° 복구 ìž‘ì—…ì„ í•˜ì§€ 않으려면, \"%s/backup_lable\" 파ì¼ì„ " "ì‚­ì œ 하세요." -#: access/transam/xlog.c:6128 +#: access/transam/xlog.c:6157 #, c-format msgid "could not locate required checkpoint record" msgstr "ìš”ì²­ëœ ì²´í¬í¬ì¸íŠ¸ ë ˆì½”ë“œì˜ ìœ„ì¹˜ë¥¼ 바르게 ìž¡ì„ ìˆ˜ ì—†ìŒ" -#: access/transam/xlog.c:6154 commands/tablespace.c:641 +#: access/transam/xlog.c:6183 commands/tablespace.c:641 #, c-format msgid "could not create symbolic link \"%s\": %m" msgstr "\"%s\" 심벌릭 ë§í¬ë¥¼ 만들 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:6186 access/transam/xlog.c:6192 +#: access/transam/xlog.c:6215 access/transam/xlog.c:6221 #, c-format msgid "ignoring file \"%s\" because no file \"%s\" exists" msgstr "\"%s\" íŒŒì¼ ë¬´ì‹œí•¨, \"%s\" íŒŒì¼ ì—†ìŒ" -#: access/transam/xlog.c:6188 access/transam/xlog.c:10928 +#: access/transam/xlog.c:6217 access/transam/xlog.c:11032 #, c-format msgid "File \"%s\" was renamed to \"%s\"." msgstr "\"%s\" 파ì¼ì„ \"%s\" 파ì¼ë¡œ ì´ë¦„ì„ ë°”ê¿¨ìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:6194 +#: access/transam/xlog.c:6223 #, c-format msgid "Could not rename file \"%s\" to \"%s\": %m." msgstr "\"%s\" 파ì¼ì„ \"%s\" 파ì¼ë¡œ ì´ë¦„ì„ ë°”ê¿€ 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:6245 access/transam/xlog.c:6260 +#: access/transam/xlog.c:6274 access/transam/xlog.c:6289 #, c-format msgid "could not locate a valid checkpoint record" msgstr "ì²´í¬í¬ì¸íŠ¸ ë ˆì½”ë“œì˜ ìœ„ì¹˜ë¥¼ 바르게 ìž¡ì„ ìˆ˜ ì—†ìŒ" -#: access/transam/xlog.c:6254 +#: access/transam/xlog.c:6283 #, c-format msgid "using previous checkpoint record at %X/%X" msgstr "ì´ì „ ì²´í¬í¬ì¸íŠ¸ 레코드를 사용함, 위치: %X/%X" -#: access/transam/xlog.c:6298 +#: access/transam/xlog.c:6327 #, c-format msgid "requested timeline %u is not a child of this server's history" msgstr "요청한 %u 타임ë¼ì¸ì€ 서버 타임ë¼ì¸ì˜ 하위가 아님" -#: access/transam/xlog.c:6300 +#: access/transam/xlog.c:6329 #, c-format msgid "" "Latest checkpoint is at %X/%X on timeline %u, but in the history of the " "requested timeline, the server forked off from that timeline at %X/%X." msgstr "" -"마지막 ì²´í¬í¬ì¸íŠ¸ 위치는 %X/%X (%u 타임ë¼ì¸)입니다. 하지만, ìš”ì²­ë°›ì€ " -"타임ë¼ì¸ 내역파ì¼ì—는 ê·¸ 타임ë¼ì¸ %X/%X 위치ì—ì„œ 분기ë˜ì—ˆìŠµë‹ˆë‹¤." +"마지막 ì²´í¬í¬ì¸íŠ¸ 위치는 %X/%X (%u 타임ë¼ì¸)입니다. 하지만, ìš”ì²­ë°›ì€ íƒ€ìž„ë¼" +"ì¸ ë‚´ì—­íŒŒì¼ì—는 ê·¸ 타임ë¼ì¸ %X/%X 위치ì—ì„œ 분기ë˜ì—ˆìŠµë‹ˆë‹¤." -#: access/transam/xlog.c:6316 +#: access/transam/xlog.c:6345 #, c-format msgid "" "requested timeline %u does not contain minimum recovery point %X/%X on " "timeline %u" -msgstr "요청한 %u 타임ë¼ì¸ì€ %X/%X 최소 복구 위치가 없습니다, 기존 타임ë¼ì¸: %u" +msgstr "" +"요청한 %u 타임ë¼ì¸ì€ %X/%X 최소 복구 위치가 없습니다, 기존 타임ë¼ì¸: %u" -#: access/transam/xlog.c:6347 +#: access/transam/xlog.c:6376 #, c-format msgid "invalid next transaction ID" msgstr "ìž˜ëª»ëœ ë‹¤ìŒ íŠ¸ëžœìž­ì…˜ ID" -#: access/transam/xlog.c:6430 +#: access/transam/xlog.c:6459 #, c-format msgid "invalid redo in checkpoint record" msgstr "ì²´í¬í¬ì¸íŠ¸ 레코드 ì•ˆì— ìž˜ëª»ëœ redo ì •ë³´ê°€ 있ìŒ" -#: access/transam/xlog.c:6441 +#: access/transam/xlog.c:6470 #, c-format msgid "invalid redo record in shutdown checkpoint" msgstr "ìš´ì˜ ì¤‘ì§€ ì²´í¬í¬ì¸íŠ¸ì—ì„œ ìž˜ëª»ëœ ìž¬ì‹¤í–‰ ì •ë³´ 발견" -#: access/transam/xlog.c:6469 +#: access/transam/xlog.c:6498 #, c-format msgid "" "database system was not properly shut down; automatic recovery in progress" @@ -2577,253 +2594,255 @@ msgstr "" "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ì •ìƒì ìœ¼ë¡œ 종료ë˜ì§€ 못했습니다, ìžë™ 복구 ìž‘ì—…ì„ ì§„í–‰í•©" "니다" -#: access/transam/xlog.c:6473 +#: access/transam/xlog.c:6502 #, c-format msgid "crash recovery starts in timeline %u and has target timeline %u" -msgstr "%u 타임ë¼ì¸ìœ¼ë¡œ ë¹„ì •ìƒ ì¤‘ì§€ì— ëŒ€í•œ ë³µêµ¬ìž‘ì—…ì„ ì‹œìž‘í•¨, 기존 타임ë¼ì¸: %u" +msgstr "" +"%u 타임ë¼ì¸ìœ¼ë¡œ ë¹„ì •ìƒ ì¤‘ì§€ì— ëŒ€í•œ ë³µêµ¬ìž‘ì—…ì„ ì‹œìž‘í•¨, 기존 타임ë¼ì¸: %u" -#: access/transam/xlog.c:6517 +#: access/transam/xlog.c:6546 #, c-format msgid "backup_label contains data inconsistent with control file" msgstr "backup_label íŒŒì¼ ì•ˆì— ì»¨íŠ¸ë¡¤ 파ì¼ê³¼ ì¼ê´€ì„±ì´ 맞지 않는 ìžë£Œê°€ 있ìŒ" -#: access/transam/xlog.c:6518 +#: access/transam/xlog.c:6547 #, c-format msgid "" "This means that the backup is corrupted and you will have to use another " "backup for recovery." msgstr "" -"ì´ ë¬¸ì œëŠ” 백업 ìžë£Œ ìžì²´ê°€ ì†ìƒ ë˜ì—ˆìŒì„ ë§í•©ë‹ˆë‹¤. 다른 백업본으로 " -"복구 ìž‘ì—…ì„ ì§„í–‰í•´ì•¼ 합니다." +"ì´ ë¬¸ì œëŠ” 백업 ìžë£Œ ìžì²´ê°€ ì†ìƒ ë˜ì—ˆìŒì„ ë§í•©ë‹ˆë‹¤. 다른 백업본으로 복구 ìž‘ì—…" +"ì„ ì§„í–‰í•´ì•¼ 합니다." -#: access/transam/xlog.c:6592 +#: access/transam/xlog.c:6621 #, c-format msgid "initializing for hot standby" msgstr "ì½ê¸° ì „ìš© ë³´ì¡° 서버로 초기화 중입니다." -#: access/transam/xlog.c:6724 +#: access/transam/xlog.c:6753 #, c-format msgid "redo starts at %X/%X" msgstr "%X/%Xì—ì„œ redo ìž‘ì—… 시작ë¨" -#: access/transam/xlog.c:6949 +#: access/transam/xlog.c:6978 #, c-format msgid "requested recovery stop point is before consistent recovery point" msgstr "요청한 복구 중지 지ì ì´ ì¼ì¹˜í•˜ëŠ” 복구 ì§€ì  ì•žì— ìžˆìŒ" -#: access/transam/xlog.c:6987 +#: access/transam/xlog.c:7016 #, c-format msgid "redo done at %X/%X" msgstr "%X/%Xì—ì„œ redo ìž‘ì—… 완료" -#: access/transam/xlog.c:6992 access/transam/xlog.c:8916 +#: access/transam/xlog.c:7021 access/transam/xlog.c:8969 #, c-format msgid "last completed transaction was at log time %s" msgstr "마지막 ì™„ë£Œëœ íŠ¸ëžœìž­ì…˜ ê¸°ë¡ ì‹œê°„: %s" -#: access/transam/xlog.c:7001 +#: access/transam/xlog.c:7030 #, c-format msgid "redo is not required" msgstr "재반ì˜í•´ì•¼ í•  íŠ¸ëžœìž­ì…˜ì´ ì—†ìŒ" -#: access/transam/xlog.c:7076 access/transam/xlog.c:7080 +#: access/transam/xlog.c:7105 access/transam/xlog.c:7109 #, c-format msgid "WAL ends before end of online backup" msgstr "온ë¼ì¸ 백업 ìž‘ì—… ëë‚˜ê¸°ì „ì— WAL ìž‘ì—… 종료ë¨" -#: access/transam/xlog.c:7077 +#: access/transam/xlog.c:7106 #, c-format msgid "" "All WAL generated while online backup was taken must be available at " "recovery." msgstr "" -"온ë¼ì¸ 백업 중 만들어진 WAL ì¡°ê° íŒŒì¼ì€ 복구 ìž‘ì—…ì—ì„œ 반드시 " -"ëª¨ë‘ ìžˆì–´ì•¼ 합니다." +"온ë¼ì¸ 백업 중 만들어진 WAL ì¡°ê° íŒŒì¼ì€ 복구 ìž‘ì—…ì—ì„œ 반드시 ëª¨ë‘ ìžˆì–´ì•¼ 합니" +"다." -#: access/transam/xlog.c:7081 +#: access/transam/xlog.c:7110 #, c-format msgid "" "Online backup started with pg_start_backup() must be ended with " "pg_stop_backup(), and all WAL up to that point must be available at recovery." msgstr "" -"pg_start_backup() 함수를 호출해서 시작한 온ë¼ì¸ ë°±ì—…ì€ " -"pg_stop_backup() 함수로 종료ë˜ì–´ì•¼ 하며, ê·¸ ì‚¬ì´ ë§Œë“¤ì–´ì§„ " -"WAL ì¡°ê° íŒŒì¼ì€ 복구 ìž‘ì—…ì—ì„œ ëª¨ë‘ í•„ìš”í•©ë‹ˆë‹¤." +"pg_start_backup() 함수를 호출해서 시작한 온ë¼ì¸ ë°±ì—…ì€ pg_stop_backup() 함수" +"ë¡œ 종료ë˜ì–´ì•¼ 하며, ê·¸ ì‚¬ì´ ë§Œë“¤ì–´ì§„ WAL ì¡°ê° íŒŒì¼ì€ 복구 ìž‘ì—…ì—ì„œ ëª¨ë‘ í•„ìš”" +"합니다." -#: access/transam/xlog.c:7084 +#: access/transam/xlog.c:7113 #, c-format msgid "WAL ends before consistent recovery point" msgstr "WALì´ ì¼ì¹˜í•˜ëŠ” 복구 ì§€ì  ì•žì—ì„œ 종료ë¨" -#: access/transam/xlog.c:7111 +#: access/transam/xlog.c:7140 #, c-format msgid "selected new timeline ID: %u" msgstr "지정한 새 타임ë¼ì¸ ID: %u" -#: access/transam/xlog.c:7522 +#: access/transam/xlog.c:7551 #, c-format msgid "consistent recovery state reached at %X/%X" msgstr "%X/%X 위치ì—ì„œ 복구 ì¼ê´€ì„±ì„ 맞춤" -#: access/transam/xlog.c:7713 +#: access/transam/xlog.c:7742 #, c-format msgid "invalid primary checkpoint link in control file" msgstr "컨트롤 파ì¼ì—ì„œ ìž˜ëª»ëœ primary checkpoint ë§í¬ 발견" -#: access/transam/xlog.c:7717 +#: access/transam/xlog.c:7746 #, c-format msgid "invalid secondary checkpoint link in control file" msgstr "컨트롤 파ì¼ì—ì„œ ìž˜ëª»ëœ secondary checkpoint ë§í¬ 발견" -#: access/transam/xlog.c:7721 +#: access/transam/xlog.c:7750 #, c-format msgid "invalid checkpoint link in backup_label file" msgstr "백업 ë¼ë²¨ 파ì¼ì—ì„œ ìž˜ëª»ëœ ì²´í¬í¬ì¸íŠ¸ ë§í¬ 발견" -#: access/transam/xlog.c:7738 +#: access/transam/xlog.c:7767 #, c-format msgid "invalid primary checkpoint record" msgstr "ìž˜ëª»ëœ primary checkpoint 레코드" -#: access/transam/xlog.c:7742 +#: access/transam/xlog.c:7771 #, c-format msgid "invalid secondary checkpoint record" msgstr "ìž˜ëª»ëœ secondary checkpoint 레코드" -#: access/transam/xlog.c:7746 +#: access/transam/xlog.c:7775 #, c-format msgid "invalid checkpoint record" msgstr "ìž˜ëª»ëœ checkpoint 레코드" -#: access/transam/xlog.c:7757 +#: access/transam/xlog.c:7786 #, c-format msgid "invalid resource manager ID in primary checkpoint record" msgstr "primary checkpoint 레코드ì—ì„œ ìž˜ëª»ëœ ìžì› ê´€ë¦¬ìž ID 발견" -#: access/transam/xlog.c:7761 +#: access/transam/xlog.c:7790 #, c-format msgid "invalid resource manager ID in secondary checkpoint record" msgstr "secondary checkpoint 레코드ì—ì„œ ìž˜ëª»ëœ ìžì› ê´€ë¦¬ìž ID 발견" -#: access/transam/xlog.c:7765 +#: access/transam/xlog.c:7794 #, c-format msgid "invalid resource manager ID in checkpoint record" msgstr "checkpoint 레코드ì—ì„œ ìž˜ëª»ëœ ìžì› ê´€ë¦¬ìž ID 발견" -#: access/transam/xlog.c:7777 +#: access/transam/xlog.c:7806 #, c-format msgid "invalid xl_info in primary checkpoint record" msgstr "primary checkpoint 레코드ì—ì„œ ìž˜ëª»ëœ xl_info 발견" -#: access/transam/xlog.c:7781 +#: access/transam/xlog.c:7810 #, c-format msgid "invalid xl_info in secondary checkpoint record" msgstr "secondary checkpoint 레코드ì—ì„œ ìž˜ëª»ëœ xl_info 발견" -#: access/transam/xlog.c:7785 +#: access/transam/xlog.c:7814 #, c-format msgid "invalid xl_info in checkpoint record" msgstr "checkpoint 레코드ì—ì„œ ìž˜ëª»ëœ xl_info 발견" -#: access/transam/xlog.c:7796 +#: access/transam/xlog.c:7825 #, c-format msgid "invalid length of primary checkpoint record" msgstr "primary checkpoint 레코드 길ì´ê°€ 잘못ë˜ì—ˆìŒ" -#: access/transam/xlog.c:7800 +#: access/transam/xlog.c:7829 #, c-format msgid "invalid length of secondary checkpoint record" msgstr "secondary checkpoint 레코드 길ì´ê°€ 잘못ë˜ì—ˆìŒ" -#: access/transam/xlog.c:7804 +#: access/transam/xlog.c:7833 #, c-format msgid "invalid length of checkpoint record" msgstr "checkpoint 레코드 길ì´ê°€ 잘못ë˜ì—ˆìŒ" -#: access/transam/xlog.c:7972 +#: access/transam/xlog.c:8001 #, c-format msgid "shutting down" msgstr "서비스를 멈추고 있습니다" -#: access/transam/xlog.c:8485 +#: access/transam/xlog.c:8514 #, c-format msgid "" "concurrent transaction log activity while database system is shutting down" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ì¤‘ì§€ë˜ëŠ” ë™ì•ˆ 현재 트랜잭션 로그가 활성화 ë˜ì—ˆìŒ" -#: access/transam/xlog.c:8736 +#: access/transam/xlog.c:8768 #, c-format msgid "skipping restartpoint, recovery has already ended" msgstr "다시 시작 지ì ì„ 건너뜀, 복구가 ì´ë¯¸ 종료ë¨" -#: access/transam/xlog.c:8759 +#: access/transam/xlog.c:8791 #, c-format msgid "skipping restartpoint, already performed at %X/%X" msgstr "다시 시작 지ì ì„ 건너뜀, %X/%Xì—ì„œ ì´ë¯¸ 수행ë¨" -#: access/transam/xlog.c:8914 +#: access/transam/xlog.c:8967 #, c-format msgid "recovery restart point at %X/%X" msgstr "%X/%Xì—ì„œ 복구 ìž‘ì—… 시작함" -#: access/transam/xlog.c:9047 +#: access/transam/xlog.c:9100 #, c-format msgid "restore point \"%s\" created at %X/%X" msgstr "\"%s\" ì´ë¦„ì˜ ë³µêµ¬ 위치는 %X/%Xì— ë§Œë“¤ì—ˆìŒ" -#: access/transam/xlog.c:9177 +#: access/transam/xlog.c:9230 #, c-format msgid "" "unexpected previous timeline ID %u (current timeline ID %u) in checkpoint " "record" -msgstr "ì²´í¬í¬ì¸íŠ¸ ë ˆì½”ë“œì— ì˜ˆê¸°ì¹˜ ì•Šì€ ì´ì „ 타임ë¼ì¸ID %u(현재 타임ë¼ì¸ID: %u)" +msgstr "" +"ì²´í¬í¬ì¸íŠ¸ ë ˆì½”ë“œì— ì˜ˆê¸°ì¹˜ ì•Šì€ ì´ì „ 타임ë¼ì¸ID %u(현재 타임ë¼ì¸ID: %u)" -#: access/transam/xlog.c:9186 +#: access/transam/xlog.c:9239 #, c-format msgid "unexpected timeline ID %u (after %u) in checkpoint record" msgstr "ì²´í¬í¬ì¸íŠ¸ ë ˆì½”ë“œì— ì˜ˆê¸°ì¹˜ ì•Šì€ íƒ€ìž„ë¼ì¸ ID %uì´(ê°€) 있ìŒ(%u ë’¤)" -#: access/transam/xlog.c:9202 +#: access/transam/xlog.c:9255 #, c-format msgid "" "unexpected timeline ID %u in checkpoint record, before reaching minimum " "recovery point %X/%X on timeline %u" msgstr "" -"ì²´í¬í¬ì¸íŠ¸ ë‚´ì—­ ì•ˆì— %u 타임ë¼ì¸ IDê°€ 기대한 것과 다릅니다. ë°œìƒ ìœ„ì¹˜: " -"%X/%X (타임ë¼ì¸: %u) 최소 복구 위치 ì´ì „" +"ì²´í¬í¬ì¸íŠ¸ ë‚´ì—­ ì•ˆì— %u 타임ë¼ì¸ IDê°€ 기대한 것과 다릅니다. ë°œìƒ ìœ„ì¹˜: %X/%X " +"(타임ë¼ì¸: %u) 최소 복구 위치 ì´ì „" -#: access/transam/xlog.c:9273 +#: access/transam/xlog.c:9326 #, c-format msgid "online backup was canceled, recovery cannot continue" msgstr "온ë¼ì¸ ë°±ì–´ì´ ì·¨ì†Œë˜ì—ˆìŒ, 복구를 ê³„ì† í•  수 ì—†ìŒ" -#: access/transam/xlog.c:9329 access/transam/xlog.c:9376 -#: access/transam/xlog.c:9399 +#: access/transam/xlog.c:9382 access/transam/xlog.c:9429 +#: access/transam/xlog.c:9452 #, c-format msgid "unexpected timeline ID %u (should be %u) in checkpoint record" msgstr "ì²´í¬í¬ì¸íŠ¸ ë ˆì½”ë“œì— ì˜ˆê¸°ì¹˜ ì•Šì€ íƒ€ìž„ë¼ì¸ ID %uì´(ê°€) 있ìŒ(%uì´ì–´ì•¼ 함)" -#: access/transam/xlog.c:9674 +#: access/transam/xlog.c:9727 #, c-format msgid "could not fsync log segment %s: %m" msgstr "%s 로그 ì¡°ê° fsync 실패: %m" -#: access/transam/xlog.c:9698 +#: access/transam/xlog.c:9751 #, c-format msgid "could not fsync log file %s: %m" msgstr "\"%s\" 로그 íŒŒì¼ fsync 실패: %m" -#: access/transam/xlog.c:9706 +#: access/transam/xlog.c:9759 #, c-format msgid "could not fsync write-through log file %s: %m" msgstr "write-through 로그 파ì¼(%s)ì„ fsyncí•  수 ì—†ìŒ: %m" -#: access/transam/xlog.c:9715 +#: access/transam/xlog.c:9768 #, c-format msgid "could not fdatasync log file %s: %m" msgstr "%s 로그파ì¼ì„ fdatasyncí•  수 ì—†ìŒ: %m" -#: access/transam/xlog.c:9806 access/transam/xlog.c:10277 +#: access/transam/xlog.c:9859 access/transam/xlog.c:10363 #: access/transam/xlogfuncs.c:294 access/transam/xlogfuncs.c:321 #: access/transam/xlogfuncs.c:360 access/transam/xlogfuncs.c:381 #: access/transam/xlogfuncs.c:402 @@ -2831,87 +2850,87 @@ msgstr "%s 로그파ì¼ì„ fdatasyncí•  수 ì—†ìŒ: %m" msgid "WAL control functions cannot be executed during recovery." msgstr "WAL 제어 함수는 복구 ìž‘ì—… 중ì—는 실행 ë  ìˆ˜ ì—†ìŒ" -#: access/transam/xlog.c:9815 access/transam/xlog.c:10286 +#: access/transam/xlog.c:9868 access/transam/xlog.c:10372 #, c-format msgid "WAL level not sufficient for making an online backup" msgstr "온ë¼ì¸ 백업 ìž‘ì—…ì„ í•˜ê¸° 위한 WAL ìˆ˜ì¤€ì´ ì¶©ë¶„ì¹˜ 않습니다." -#: access/transam/xlog.c:9816 access/transam/xlog.c:10287 +#: access/transam/xlog.c:9869 access/transam/xlog.c:10373 #: access/transam/xlogfuncs.c:327 #, c-format msgid "wal_level must be set to \"replica\" or \"logical\" at server start." msgstr "" "wal_level ê°’ì„ \"replica\" ë˜ëŠ” \"logical\"ë¡œ 지정하고 서버를 실행하십시오." -#: access/transam/xlog.c:9821 +#: access/transam/xlog.c:9874 #, c-format msgid "backup label too long (max %d bytes)" msgstr "백업 ë¼ë²¨ ì´ë¦„ì´ ë„ˆë¬´ 긺(최대 %d ë°”ì´íŠ¸)" -#: access/transam/xlog.c:9853 access/transam/xlog.c:10125 -#: access/transam/xlog.c:10163 +#: access/transam/xlog.c:9911 access/transam/xlog.c:10183 +#: access/transam/xlog.c:10221 #, c-format msgid "a backup is already in progress" msgstr "ì´ë¯¸ 백업 ìž‘ì—…ì´ ì§„í–‰ 중입니다" -#: access/transam/xlog.c:9854 +#: access/transam/xlog.c:9912 #, c-format msgid "Run pg_stop_backup() and try again." msgstr "pg_stop_backup() 함수를 실행하고 나서 다시 ì‹œë„하세요." -#: access/transam/xlog.c:9949 +#: access/transam/xlog.c:10007 #, c-format msgid "" "WAL generated with full_page_writes=off was replayed since last restartpoint" msgstr "" -"마지막 재시작 위치부터 재반ì˜ëœ WAL ë‚´ìš©ì´ full_page_writes=off 설정으로 " -"만들어진 내용입니다." +"마지막 재시작 위치부터 재반ì˜ëœ WAL ë‚´ìš©ì´ full_page_writes=off 설정으로 만들" +"어진 내용입니다." -#: access/transam/xlog.c:9951 access/transam/xlog.c:10450 +#: access/transam/xlog.c:10009 access/transam/xlog.c:10554 #, c-format msgid "" "This means that the backup being taken on the standby is corrupt and should " "not be used. Enable full_page_writes and run CHECKPOINT on the master, and " "then try an online backup again." msgstr "" -"ì´ ê²½ìš° 대기 ì„œë²„ì˜ ìžë£Œê°€ ì†ì‹¤ë˜ì—ˆì„ ê°€ëŠ¥ì„±ì´ ìžˆìŠµë‹ˆë‹¤. full_page_writes " -"ì„¤ì •ì„ í™œì„±í™” 하고, 주 서버ì—ì„œ CHECKPOINT ëª…ë ¹ì„ ì‹¤í–‰í•˜ê³ , " -"온ë¼ì¸ ë°±ì—…ì„ ë‹¤ì‹œ í•´ì„œ 사용하세요." +"ì´ ê²½ìš° 대기 ì„œë²„ì˜ ìžë£Œê°€ ì†ì‹¤ë˜ì—ˆì„ ê°€ëŠ¥ì„±ì´ ìžˆìŠµë‹ˆë‹¤. full_page_writes 설" +"ì •ì„ í™œì„±í™” 하고, 주 서버ì—ì„œ CHECKPOINT ëª…ë ¹ì„ ì‹¤í–‰í•˜ê³ , 온ë¼ì¸ ë°±ì—…ì„ ë‹¤ì‹œ " +"í•´ì„œ 사용하세요." -#: access/transam/xlog.c:10018 replication/basebackup.c:1038 +#: access/transam/xlog.c:10076 replication/basebackup.c:1026 #: utils/adt/misc.c:498 #, c-format msgid "could not read symbolic link \"%s\": %m" msgstr "\"%s\" 심볼릭 ë§í¬ 파ì¼ì„ ì½ì„ 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:10025 replication/basebackup.c:1043 +#: access/transam/xlog.c:10083 replication/basebackup.c:1031 #: utils/adt/misc.c:503 #, c-format msgid "symbolic link \"%s\" target is too long" msgstr "\"%s\" 심볼릭 ë§í¬ì˜ 대ìƒì´ 너무 긺" -#: access/transam/xlog.c:10078 commands/tablespace.c:391 -#: commands/tablespace.c:553 replication/basebackup.c:1059 +#: access/transam/xlog.c:10136 commands/tablespace.c:391 +#: commands/tablespace.c:553 replication/basebackup.c:1047 #: utils/adt/misc.c:511 #, c-format msgid "tablespaces are not supported on this platform" msgstr "í…Œì´ë¸”스페ì´ìŠ¤ ê¸°ëŠ¥ì€ ì´ í”Œëž«í¼ì—서는 지ì›í•˜ì§€ 않습니다." -#: access/transam/xlog.c:10119 access/transam/xlog.c:10157 -#: access/transam/xlog.c:10336 access/transam/xlogarchive.c:106 +#: access/transam/xlog.c:10177 access/transam/xlog.c:10215 +#: access/transam/xlog.c:10411 access/transam/xlogarchive.c:106 #: access/transam/xlogarchive.c:265 commands/copy.c:1815 commands/copy.c:2839 -#: commands/extension.c:3109 commands/tablespace.c:782 -#: commands/tablespace.c:873 replication/basebackup.c:407 -#: replication/basebackup.c:475 replication/logical/snapbuild.c:1491 -#: storage/file/copydir.c:72 storage/file/copydir.c:115 storage/file/fd.c:2826 -#: storage/file/fd.c:2918 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 +#: commands/extension.c:3130 commands/tablespace.c:782 +#: commands/tablespace.c:873 replication/basebackup.c:409 +#: replication/basebackup.c:477 replication/logical/snapbuild.c:1491 +#: storage/file/copydir.c:72 storage/file/copydir.c:115 storage/file/fd.c:2903 +#: storage/file/fd.c:2995 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 #: utils/adt/dbsize.c:300 utils/adt/genfile.c:114 utils/adt/genfile.c:333 -#: guc-file.l:1001 +#: guc-file.l:1002 #, c-format msgid "could not stat file \"%s\": %m" msgstr "\"%s\" 파ì¼ì˜ ìƒíƒœê°’ì„ ì•Œ 수 ì—†ìŒ: %m" -#: access/transam/xlog.c:10126 access/transam/xlog.c:10164 +#: access/transam/xlog.c:10184 access/transam/xlog.c:10222 #, c-format msgid "" "If you're sure there is no backup in progress, remove file \"%s\" and try " @@ -2920,150 +2939,153 @@ msgstr "" "실재로는 백업 ìž‘ì—…ì„ ì•ˆí•˜ê³  있다고 확신한다면, \"%s\" 파ì¼ì„ 삭제하고 다시 ì‹œ" "ë„í•´ 보십시오." -#: access/transam/xlog.c:10143 access/transam/xlog.c:10181 -#: access/transam/xlog.c:10511 +#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 +#: access/transam/xlog.c:10615 #, c-format msgid "could not write file \"%s\": %m" msgstr "\"%s\" íŒŒì¼ ì“°ê¸° 실패: %m" -#: access/transam/xlog.c:10300 +#: access/transam/xlog.c:10388 #, c-format msgid "exclusive backup not in progress" msgstr "exclusive 백업 ìž‘ì—…ì„ í•˜ì§€ ì•Šê³  있습니다" -#: access/transam/xlog.c:10340 +#: access/transam/xlog.c:10415 #, c-format msgid "a backup is not in progress" msgstr "현재 백업 ìž‘ì—…ì„ í•˜ì§€ ì•Šê³  있습니다" -#: access/transam/xlog.c:10385 access/transam/xlog.c:10398 -#: access/transam/xlog.c:10738 access/transam/xlog.c:10744 -#: access/transam/xlog.c:10828 access/transam/xlogfuncs.c:695 +#: access/transam/xlog.c:10489 access/transam/xlog.c:10502 +#: access/transam/xlog.c:10842 access/transam/xlog.c:10848 +#: access/transam/xlog.c:10932 access/transam/xlogfuncs.c:695 #, c-format msgid "invalid data in file \"%s\"" msgstr "\"%s\" 파ì¼ì— 유효하지 ì•Šì€ ìžë£Œê°€ 있습니다" -#: access/transam/xlog.c:10402 replication/basebackup.c:936 +#: access/transam/xlog.c:10506 replication/basebackup.c:938 #, c-format msgid "the standby was promoted during online backup" -msgstr "" -"대기 서버가 온ë¼ì¸ 백업 중 주 서버로 전환ë˜ì—ˆìŠµë‹ˆë‹¤" +msgstr "대기 서버가 온ë¼ì¸ 백업 중 주 서버로 전환ë˜ì—ˆìŠµë‹ˆë‹¤" -#: access/transam/xlog.c:10403 replication/basebackup.c:937 +#: access/transam/xlog.c:10507 replication/basebackup.c:939 #, c-format msgid "" "This means that the backup being taken is corrupt and should not be used. " "Try taking another online backup." msgstr "" -"ì´ëŸ° 경우, 해당 백업 ìžë£Œê°€ ì†ìƒë˜ì—ˆì„ ê°€ëŠ¥ì„±ì´ ìžˆìŠµë‹ˆë‹¤. " -"다른 ë°±ì—…ë³¸ì„ ì´ìš©í•˜ì„¸ìš”." +"ì´ëŸ° 경우, 해당 백업 ìžë£Œê°€ ì†ìƒë˜ì—ˆì„ ê°€ëŠ¥ì„±ì´ ìžˆìŠµë‹ˆë‹¤. 다른 ë°±ì—…ë³¸ì„ ì´ìš©" +"하세요." -#: access/transam/xlog.c:10448 +#: access/transam/xlog.c:10552 #, c-format msgid "" "WAL generated with full_page_writes=off was replayed during online backup" msgstr "" -"온ë¼ì¸ 백업 ë„중 full_page_writes=off 설정으로 만들어진 WAL ë‚´ìš©ì´ ìž¬ë°˜ì˜ë˜ì—ˆìŠµë‹ˆë‹¤." +"온ë¼ì¸ 백업 ë„중 full_page_writes=off 설정으로 만들어진 WAL ë‚´ìš©ì´ ìž¬ë°˜ì˜ë˜ì—ˆ" +"습니다." -#: access/transam/xlog.c:10560 +#: access/transam/xlog.c:10664 #, c-format msgid "" "pg_stop_backup cleanup done, waiting for required WAL segments to be archived" msgstr "" -"pg_stop_backup ìž‘ì—…ì´ ë났습니다. 필요한 WAL ì¡°ê° íŒŒì¼ì´ ì•„ì¹´ì´ë¸Œ ë˜ê¸¸ 기다리고 있습니다." +"pg_stop_backup ìž‘ì—…ì´ ë났습니다. 필요한 WAL ì¡°ê° íŒŒì¼ì´ ì•„ì¹´ì´ë¸Œ ë˜ê¸¸ 기다리" +"ê³  있습니다." -#: access/transam/xlog.c:10570 +#: access/transam/xlog.c:10674 #, c-format msgid "" "pg_stop_backup still waiting for all required WAL segments to be archived " "(%d seconds elapsed)" msgstr "pg_stop_backupì—ì„œ ì•„ì¹´ì´ë¹™ì´ 완료ë˜ê¸°ë¥¼ 기다리고 ìžˆìŒ (%dì´ˆ 경과)" -#: access/transam/xlog.c:10572 +#: access/transam/xlog.c:10676 #, c-format msgid "" "Check that your archive_command is executing properly. pg_stop_backup can " "be canceled safely, but the database backup will not be usable without all " "the WAL segments." msgstr "" -"archive_command ì„¤ì •ì„ ì‚´íŽ´ë³´ì„¸ìš”. pg_stop_backup ìž‘ì—…ì€ ì•ˆì „í•˜ê²Œ 취소 í•  수 " -"있지만, ë°ì´í„°ë² ì´ìŠ¤ ë°±ì—…ì€ ëª¨ë“  WAL ì¡°ê° ì—†ì´ëŠ” ì‚¬ìš©ë  ìˆ˜ 없습니다." +"archive_command ì„¤ì •ì„ ì‚´íŽ´ë³´ì„¸ìš”. pg_stop_backup ìž‘ì—…ì€ ì•ˆì „í•˜ê²Œ 취소 í•  " +"수 있지만, ë°ì´í„°ë² ì´ìŠ¤ ë°±ì—…ì€ ëª¨ë“  WAL ì¡°ê° ì—†ì´ëŠ” ì‚¬ìš©ë  ìˆ˜ 없습니다." -#: access/transam/xlog.c:10579 +#: access/transam/xlog.c:10683 #, c-format msgid "pg_stop_backup complete, all required WAL segments have been archived" msgstr "" -"pg_stop_backup ìž‘ì—…ì´ ë났습니다. 모든 필요한 WAL ì¡°ê°ë“¤ì´ ì•„ì¹´ì´ë¸Œ ë˜ì—ˆìŠµë‹ˆë‹¤." +"pg_stop_backup ìž‘ì—…ì´ ë났습니다. 모든 필요한 WAL ì¡°ê°ë“¤ì´ ì•„ì¹´ì´ë¸Œ ë˜ì—ˆìŠµë‹ˆ" +"다." -#: access/transam/xlog.c:10583 +#: access/transam/xlog.c:10687 #, c-format msgid "" "WAL archiving is not enabled; you must ensure that all required WAL segments " "are copied through other means to complete the backup" msgstr "" "WAL ì•„ì¹´ì´ë¸Œ ê¸°ëŠ¥ì´ ë¹„í™œì„±í™” ë˜ì–´ 있습니다; ì´ ê²½ìš°ëŠ” 백업 ë’¤ ë³µêµ¬ì— í•„ìš”í•œ " -"모든 WAL ì¡°ê° íŒŒì¼ë“¤ì„ ì§ì ‘ 찾아서 ë”°ë¡œ 보관해 ë‘어야 바르게 복구 í•  수 있습니다." +"모든 WAL ì¡°ê° íŒŒì¼ë“¤ì„ ì§ì ‘ 찾아서 ë”°ë¡œ 보관해 ë‘어야 바르게 복구 í•  수 있습" +"니다." #. translator: %s is an XLog record description -#: access/transam/xlog.c:10868 +#: access/transam/xlog.c:10972 #, c-format msgid "xlog redo at %X/%X for %s" msgstr "xlog redo 위치: %X/%X, 대ìƒ: %s" -#: access/transam/xlog.c:10917 +#: access/transam/xlog.c:11021 #, c-format msgid "online backup mode was not canceled" msgstr "온ë¼ì¸ 백업 모드가 취소ë˜ì§€ 않았ìŒ" -#: access/transam/xlog.c:10918 +#: access/transam/xlog.c:11022 #, c-format msgid "File \"%s\" could not be renamed to \"%s\": %m." msgstr "\"%s\" 파ì¼ì„ \"%s\" 파ì¼ë¡œ ì´ë¦„ì„ ë°”ê¿€ 수 ì—†ìŒ: %m." -#: access/transam/xlog.c:10927 access/transam/xlog.c:10939 -#: access/transam/xlog.c:10949 +#: access/transam/xlog.c:11031 access/transam/xlog.c:11043 +#: access/transam/xlog.c:11053 #, c-format msgid "online backup mode canceled" msgstr "온ë¼ì¸ 백업 모드가 취소ë¨" -#: access/transam/xlog.c:10940 +#: access/transam/xlog.c:11044 #, c-format msgid "" "Files \"%s\" and \"%s\" were renamed to \"%s\" and \"%s\", respectively." msgstr "" "예ìƒí•œ 것처럼, \"%s\", \"%s\" 파ì¼ì„ \"%s\", \"%s\" ì´ë¦„으로 바꿨습니다." -#: access/transam/xlog.c:10950 +#: access/transam/xlog.c:11054 #, c-format msgid "" "File \"%s\" was renamed to \"%s\", but file \"%s\" could not be renamed to " "\"%s\": %m." msgstr "" -"\"%s\" 파ì¼ì€ \"%s\" ì´ë¦„으로 바꿨지만, \"%s\" 파ì¼ì€ \"%s\" ì´ë¦„으로 " -"바꾸지 못했습니다: %m." +"\"%s\" 파ì¼ì€ \"%s\" ì´ë¦„으로 바꿨지만, \"%s\" 파ì¼ì€ \"%s\" ì´ë¦„으로 바꾸지 " +"못했습니다: %m." -#: access/transam/xlog.c:11072 access/transam/xlogutils.c:718 -#: replication/walreceiver.c:994 replication/walsender.c:2114 +#: access/transam/xlog.c:11176 access/transam/xlogutils.c:718 +#: replication/walreceiver.c:994 replication/walsender.c:2112 #, c-format msgid "could not seek in log segment %s to offset %u: %m" msgstr "%s 로그 ì¡°ê°ì—ì„œ 해당 위치를 ì°¾ì„ ìˆ˜ ì—†ìŒ: %u: %m" -#: access/transam/xlog.c:11084 +#: access/transam/xlog.c:11188 #, c-format msgid "could not read from log segment %s, offset %u: %m" msgstr "%s 로그 ì¡°ê°ì—ì„œ ì½ê¸° 실패, 위치: %u: %m" -#: access/transam/xlog.c:11558 +#: access/transam/xlog.c:11662 #, c-format msgid "received promote request" msgstr "ìš´ì˜ ì „í™˜ 신호를 받았습니다." -#: access/transam/xlog.c:11571 +#: access/transam/xlog.c:11675 #, c-format msgid "trigger file found: %s" msgstr "트리거 파ì¼ì´ 있ìŒ: %s" -#: access/transam/xlog.c:11580 +#: access/transam/xlog.c:11684 #, c-format msgid "could not stat trigger file \"%s\": %m" msgstr "\"%s\" 트리거 파ì¼ì˜ ìƒíƒœê°’ì„ ì•Œ 수 ì—†ìŒ: %m" @@ -3093,7 +3115,7 @@ msgstr "%s \"%s\": %s" #: access/transam/xlogarchive.c:458 replication/logical/snapbuild.c:1619 #: replication/slot.c:480 replication/slot.c:992 replication/slot.c:1100 -#: storage/file/fd.c:635 storage/file/fd.c:693 utils/time/snapmgr.c:1246 +#: storage/file/fd.c:642 storage/file/fd.c:700 utils/time/snapmgr.c:1298 #, c-format msgid "could not rename file \"%s\" to \"%s\": %m" msgstr "\"%s\" 파ì¼ì„ \"%s\" 파ì¼ë¡œ ì´ë¦„ì„ ë°”ê¿€ 수 ì—†ìŒ: %m" @@ -3111,7 +3133,8 @@ msgstr "\"%s\" archive status 파ì¼ì— 쓸 수 없습니다: %m" #: access/transam/xlogfuncs.c:58 #, c-format msgid "aborting backup due to backend exiting before pg_stop_backup was called" -msgstr "pg_stop_backup ìž‘ì—…ì´ í˜¸ì¶œë˜ê¸° ì „ì— ë°±ì—”ë“œê°€ 종료ë˜ì–´ ë°±ì—…ì„ ì¤‘ì§€í•©ë‹ˆë‹¤." +msgstr "" +"pg_stop_backup ìž‘ì—…ì´ í˜¸ì¶œë˜ê¸° ì „ì— ë°±ì—”ë“œê°€ 종료ë˜ì–´ ë°±ì—…ì„ ì¤‘ì§€í•©ë‹ˆë‹¤." #: access/transam/xlogfuncs.c:88 #, c-format @@ -3120,9 +3143,9 @@ msgstr "ì´ë¯¸ ì´ ì„¸ì…˜ì—ì„œ 백업 ìž‘ì—…ì´ ì§„í–‰ 중입니다" #: access/transam/xlogfuncs.c:94 commands/tablespace.c:705 #: commands/tablespace.c:715 postmaster/postmaster.c:1406 -#: replication/basebackup.c:295 replication/basebackup.c:635 -#: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2292 -#: storage/file/fd.c:2891 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 +#: replication/basebackup.c:297 replication/basebackup.c:637 +#: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2369 +#: storage/file/fd.c:2968 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 #: utils/adt/misc.c:411 utils/misc/tzparser.c:339 #, c-format msgid "could not open directory \"%s\": %m" @@ -3139,16 +3162,16 @@ msgid "Did you mean to use pg_stop_backup('f')?" msgstr "pg_stop_backup('f') 형태로 함수를 호출했나요?" #: access/transam/xlogfuncs.c:200 commands/event_trigger.c:1445 -#: commands/event_trigger.c:1996 commands/extension.c:1728 -#: commands/extension.c:1837 commands/extension.c:2030 commands/prepare.c:702 +#: commands/event_trigger.c:1996 commands/extension.c:1729 +#: commands/extension.c:1838 commands/extension.c:2031 commands/prepare.c:702 #: executor/execQual.c:1757 executor/execQual.c:1782 executor/execQual.c:2157 -#: executor/execQual.c:5423 executor/functions.c:1022 foreign/foreign.c:492 +#: executor/execQual.c:5438 executor/functions.c:1031 foreign/foreign.c:492 #: replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1391 -#: replication/slotfuncs.c:189 replication/walsender.c:2763 +#: replication/slotfuncs.c:189 replication/walsender.c:2761 #: utils/adt/jsonfuncs.c:1483 utils/adt/jsonfuncs.c:1613 #: utils/adt/jsonfuncs.c:1801 utils/adt/jsonfuncs.c:1928 #: utils/adt/jsonfuncs.c:2694 utils/adt/pgstatfuncs.c:554 -#: utils/adt/pgstatfuncs.c:655 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8438 +#: utils/adt/pgstatfuncs.c:655 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8436 #: utils/mmgr/portalmem.c:1074 #, c-format msgid "set-valued function called in context that cannot accept a set" @@ -3157,12 +3180,12 @@ msgstr "" "당 ì—´ alias 지정하세요)" #: access/transam/xlogfuncs.c:204 commands/event_trigger.c:1449 -#: commands/event_trigger.c:2000 commands/extension.c:1732 -#: commands/extension.c:1841 commands/extension.c:2034 commands/prepare.c:706 +#: commands/event_trigger.c:2000 commands/extension.c:1733 +#: commands/extension.c:1842 commands/extension.c:2035 commands/prepare.c:706 #: foreign/foreign.c:497 replication/logical/logicalfuncs.c:179 #: replication/logical/origin.c:1395 replication/slotfuncs.c:193 -#: replication/walsender.c:2767 utils/adt/pgstatfuncs.c:558 -#: utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8442 utils/misc/pg_config.c:44 +#: replication/walsender.c:2765 utils/adt/pgstatfuncs.c:558 +#: utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8440 utils/misc/pg_config.c:44 #: utils/mmgr/portalmem.c:1078 #, c-format msgid "materialize mode required, but it is not allowed in this context" @@ -3367,7 +3390,7 @@ msgstr "ìž˜ëª»ëœ ë ˆì½”ë“œ 길ì´, 위치 %X/%X" msgid "invalid compressed image at %X/%X, block %d" msgstr "ìž˜ëª»ëœ ì••ì¶• ì´ë¯¸ì§€, 위치 %X/%X, ë¸”ë¡ %d" -#: access/transam/xlogutils.c:739 replication/walsender.c:2131 +#: access/transam/xlogutils.c:739 replication/walsender.c:2129 #, c-format msgid "could not read from log segment %s, offset %u, length %lu: %m" msgstr "%s 로그 ì¡°ê° ì½ê¸° 실패, 위치 %u, ê¸¸ì´ %lu: %m" @@ -3393,125 +3416,125 @@ msgstr "ìžì œí•œ ì‚¬í•­ì€ \"%s --help\" 명령으로 살펴보십시오.\n" msgid "%s: invalid command-line arguments\n" msgstr "%s: ìž˜ëª»ëœ ëª…ë ¹í–‰ ì¸ìž\n" -#: catalog/aclchk.c:193 +#: catalog/aclchk.c:201 #, c-format msgid "grant options can only be granted to roles" msgstr "grant ì˜µì…˜ë“¤ì€ ë¡¤ì—서만 ì§€ì •ë  ìˆ˜ 있습니다" -#: catalog/aclchk.c:316 +#: catalog/aclchk.c:324 #, c-format msgid "no privileges were granted for column \"%s\" of relation \"%s\"" msgstr "\"%s\" 칼럼(해당 릴레ì´ì…˜: \"%s\")ì— ëŒ€í•œ ê¶Œí•œì´ ë¶€ì—¬ë˜ì§€ 않았ìŒ" -#: catalog/aclchk.c:321 +#: catalog/aclchk.c:329 #, c-format msgid "no privileges were granted for \"%s\"" msgstr "\"%s\"ì— ëŒ€í•œ ê¶Œí•œì´ ë¶€ì—¬ë˜ì§€ 않았ìŒ" -#: catalog/aclchk.c:329 +#: catalog/aclchk.c:337 #, c-format msgid "not all privileges were granted for column \"%s\" of relation \"%s\"" msgstr "\"%s\" 칼럼(해당 릴레ì´ì…˜: \"%s\")ì— ëŒ€í•œ ì¼ë¶€ ê¶Œí•œì´ ë¶€ì—¬ë˜ì§€ 않았ìŒ" -#: catalog/aclchk.c:334 +#: catalog/aclchk.c:342 #, c-format msgid "not all privileges were granted for \"%s\"" msgstr "\"%s\"ì— ëŒ€í•œ ì¼ë¶€ ê¶Œí•œì´ ë¶€ì—¬ë˜ì§€ 않았ìŒ" -#: catalog/aclchk.c:345 +#: catalog/aclchk.c:353 #, c-format msgid "no privileges could be revoked for column \"%s\" of relation \"%s\"" msgstr "\"%s\" 칼럼(해당 릴레ì´ì…˜: \"%s\")ì— ëŒ€í•œ ê¶Œí•œì„ ì·¨ì†Œí•  수 ì—†ìŒ" -#: catalog/aclchk.c:350 +#: catalog/aclchk.c:358 #, c-format msgid "no privileges could be revoked for \"%s\"" msgstr "\"%s\"ì— ëŒ€í•œ ê¶Œí•œì„ ì·¨ì†Œí•  수 ì—†ìŒ" -#: catalog/aclchk.c:358 +#: catalog/aclchk.c:366 #, c-format msgid "" "not all privileges could be revoked for column \"%s\" of relation \"%s\"" msgstr "\"%s\" 칼럼(해당 릴레ì´ì…˜: \"%s\")ì˜ ì¼ë¶€ ê¶Œí•œì„ ë°•íƒˆí•  수 ì—†ìŒ" -#: catalog/aclchk.c:363 +#: catalog/aclchk.c:371 #, c-format msgid "not all privileges could be revoked for \"%s\"" msgstr "\"%s\"ì— ëŒ€í•œ ì¼ë¶€ ê¶Œí•œì„ ì·¨ì†Œí•  수 ì—†ìŒ" -#: catalog/aclchk.c:445 catalog/aclchk.c:935 +#: catalog/aclchk.c:453 catalog/aclchk.c:943 #, c-format msgid "invalid privilege type %s for relation" msgstr "릴레ì´ì…˜ì˜ %s ê¶Œí•œì€ ìž˜ëª»ëœ ì¢…ë¥˜ìž„" -#: catalog/aclchk.c:449 catalog/aclchk.c:939 +#: catalog/aclchk.c:457 catalog/aclchk.c:947 #, c-format msgid "invalid privilege type %s for sequence" msgstr "ì‹œí€€ìŠ¤ì˜ %s ê¶Œí•œì€ ìž˜ëª»ëœ ì¢…ë¥˜ìž„" -#: catalog/aclchk.c:453 +#: catalog/aclchk.c:461 #, c-format msgid "invalid privilege type %s for database" msgstr "%s ê¶Œí•œì€ ë°ì´í„°ë² ì´ìŠ¤ì—는 사용할 수 ì—†ì€ ê¶Œí•œ 형태임" -#: catalog/aclchk.c:457 +#: catalog/aclchk.c:465 #, c-format msgid "invalid privilege type %s for domain" msgstr "%s ê¶Œí•œì€ ë„ë©”ì¸ì—ì„œ 유효하지 ì•ŠìŒ" -#: catalog/aclchk.c:461 catalog/aclchk.c:943 +#: catalog/aclchk.c:469 catalog/aclchk.c:951 #, c-format msgid "invalid privilege type %s for function" msgstr "%s ê¶Œí•œì€ í•¨ìˆ˜ì—ì„œ 사용할 수 ì—†ì€ ê¶Œí•œ 형태임" -#: catalog/aclchk.c:465 +#: catalog/aclchk.c:473 #, c-format msgid "invalid privilege type %s for language" msgstr "%s ê¶Œí•œì€ í”„ë¡œì‹œì£¼ì–¼ 언어ì—ì„œ 사용할 수 ì—†ì€ ê¶Œí•œ 형태임" -#: catalog/aclchk.c:469 +#: catalog/aclchk.c:477 #, c-format msgid "invalid privilege type %s for large object" msgstr "%s ê¶Œí•œì€ ëŒ€í˜• ê°ì²´ì—ì„œ 사용할 수 ì—†ì€ ê¶Œí•œ 형태임" -#: catalog/aclchk.c:473 +#: catalog/aclchk.c:481 #, c-format msgid "invalid privilege type %s for schema" msgstr "%s ê¶Œí•œì€ ìŠ¤í‚¤ë§ˆ(schema)ì—ì„œ 사용할 수 ì—†ì€ ê¶Œí•œ 형태임" -#: catalog/aclchk.c:477 +#: catalog/aclchk.c:485 #, c-format msgid "invalid privilege type %s for tablespace" msgstr "%s ê¶Œí•œì€ í…Œì´ë¸”스페ì´ìŠ¤ì—ì„œ 사용할 수 ì—†ì€ ê¶Œí•œ 형태임" -#: catalog/aclchk.c:481 catalog/aclchk.c:947 +#: catalog/aclchk.c:489 catalog/aclchk.c:955 #, c-format msgid "invalid privilege type %s for type" msgstr "%s ê¶Œí•œì€ ìžë£Œí˜•ì—ì„œ 사용할 수 ì—†ì€ ê¶Œí•œ 형태임" -#: catalog/aclchk.c:485 +#: catalog/aclchk.c:493 #, c-format msgid "invalid privilege type %s for foreign-data wrapper" msgstr "%s 권한 형ì‹ì€ 외부 ë°ì´í„° 래í¼ì— 유효하지 ì•ŠìŒ" -#: catalog/aclchk.c:489 +#: catalog/aclchk.c:497 #, c-format msgid "invalid privilege type %s for foreign server" msgstr "%s 권한 형ì‹ì€ 외부 ì„œë²„ì— ìœ íš¨í•˜ì§€ ì•ŠìŒ" -#: catalog/aclchk.c:528 +#: catalog/aclchk.c:536 #, c-format msgid "column privileges are only valid for relations" msgstr "칼럼 ê¶Œí•œì€ ë¦´ë ˆì´ì…˜ì—서만 유효함" -#: catalog/aclchk.c:687 catalog/aclchk.c:3915 catalog/aclchk.c:4697 +#: catalog/aclchk.c:695 catalog/aclchk.c:3923 catalog/aclchk.c:4705 #: catalog/objectaddress.c:873 catalog/pg_largeobject.c:113 #: storage/large_object/inv_api.c:291 #, c-format msgid "large object %u does not exist" msgstr "%u large object ì—†ìŒ" -#: catalog/aclchk.c:874 catalog/aclchk.c:882 commands/collationcmds.c:92 +#: catalog/aclchk.c:882 catalog/aclchk.c:890 commands/collationcmds.c:92 #: commands/copy.c:1047 commands/copy.c:1065 commands/copy.c:1073 #: commands/copy.c:1081 commands/copy.c:1089 commands/copy.c:1097 #: commands/copy.c:1105 commands/copy.c:1113 commands/copy.c:1121 @@ -3522,9 +3545,9 @@ msgstr "%u large object ì—†ìŒ" #: commands/dbcommands.c:203 commands/dbcommands.c:211 #: commands/dbcommands.c:219 commands/dbcommands.c:1397 #: commands/dbcommands.c:1405 commands/dbcommands.c:1413 -#: commands/dbcommands.c:1421 commands/extension.c:1218 -#: commands/extension.c:1226 commands/extension.c:1234 -#: commands/extension.c:1242 commands/extension.c:2760 +#: commands/dbcommands.c:1421 commands/extension.c:1219 +#: commands/extension.c:1227 commands/extension.c:1235 +#: commands/extension.c:1243 commands/extension.c:2761 #: commands/foreigncmds.c:539 commands/foreigncmds.c:548 #: commands/functioncmds.c:533 commands/functioncmds.c:649 #: commands/functioncmds.c:657 commands/functioncmds.c:665 @@ -3547,424 +3570,424 @@ msgstr "%u large object ì—†ìŒ" msgid "conflicting or redundant options" msgstr "ìƒì¶©í•˜ê±°ë‚˜ ì¤‘ë³µëœ ì˜µì…˜ë“¤" -#: catalog/aclchk.c:980 +#: catalog/aclchk.c:988 #, c-format msgid "default privileges cannot be set for columns" msgstr "default privileges ì„¤ì •ì€ ì¹¼ëŸ¼ 대ìƒìœ¼ë¡œ í•  수 ì—†ìŒ" -#: catalog/aclchk.c:1494 catalog/objectaddress.c:1390 commands/analyze.c:376 -#: commands/copy.c:4458 commands/sequence.c:1491 commands/tablecmds.c:5197 -#: commands/tablecmds.c:5303 commands/tablecmds.c:5363 -#: commands/tablecmds.c:5476 commands/tablecmds.c:5533 -#: commands/tablecmds.c:5627 commands/tablecmds.c:5723 -#: commands/tablecmds.c:7875 commands/tablecmds.c:8080 -#: commands/tablecmds.c:8500 commands/trigger.c:642 parser/analyze.c:2231 -#: parser/parse_relation.c:2542 parser/parse_relation.c:2604 -#: parser/parse_target.c:940 parser/parse_type.c:127 utils/adt/acl.c:2840 -#: utils/adt/ruleutils.c:1981 +#: catalog/aclchk.c:1502 catalog/objectaddress.c:1390 commands/analyze.c:376 +#: commands/copy.c:4458 commands/sequence.c:1491 commands/tablecmds.c:5198 +#: commands/tablecmds.c:5304 commands/tablecmds.c:5364 +#: commands/tablecmds.c:5477 commands/tablecmds.c:5534 +#: commands/tablecmds.c:5628 commands/tablecmds.c:5724 +#: commands/tablecmds.c:7915 commands/tablecmds.c:8177 +#: commands/tablecmds.c:8597 commands/trigger.c:642 parser/analyze.c:2228 +#: parser/parse_relation.c:2628 parser/parse_relation.c:2690 +#: parser/parse_target.c:951 parser/parse_type.c:127 utils/adt/acl.c:2840 +#: utils/adt/ruleutils.c:1984 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist" msgstr "\"%s\" ì—´ì€ \"%s\" 릴레ì´ì…˜(relation)ì— ì—†ìŒ" -#: catalog/aclchk.c:1763 catalog/objectaddress.c:1203 commands/sequence.c:1078 -#: commands/tablecmds.c:223 commands/tablecmds.c:12018 utils/adt/acl.c:2076 +#: catalog/aclchk.c:1771 catalog/objectaddress.c:1203 commands/sequence.c:1078 +#: commands/tablecmds.c:224 commands/tablecmds.c:12154 utils/adt/acl.c:2076 #: utils/adt/acl.c:2106 utils/adt/acl.c:2138 utils/adt/acl.c:2170 #: utils/adt/acl.c:2198 utils/adt/acl.c:2228 #, c-format msgid "\"%s\" is not a sequence" msgstr "\"%s\" 시퀀스가 아님" -#: catalog/aclchk.c:1801 +#: catalog/aclchk.c:1809 #, c-format msgid "sequence \"%s\" only supports USAGE, SELECT, and UPDATE privileges" msgstr "\"%s\" 시퀀스는 USAGE, SELECT ë° UPDATE 권한만 지ì›í•¨" -#: catalog/aclchk.c:1818 +#: catalog/aclchk.c:1826 #, c-format msgid "invalid privilege type USAGE for table" msgstr "í…Œì´ë¸”ì—ì„œ USAGE ê¶Œí•œì€ ìž˜ëª»ë˜ì—ˆìŒ" -#: catalog/aclchk.c:1986 +#: catalog/aclchk.c:1994 #, c-format msgid "invalid privilege type %s for column" msgstr "%s 권한 형ì‹ì€ 칼럼ì—ì„œ 유효하지 ì•ŠìŒ" -#: catalog/aclchk.c:1999 +#: catalog/aclchk.c:2007 #, c-format msgid "sequence \"%s\" only supports SELECT column privileges" msgstr "\"%s\" 시퀀스는 SELECT ì—´ 권한만 지ì›í•¨" -#: catalog/aclchk.c:2593 +#: catalog/aclchk.c:2601 #, c-format msgid "language \"%s\" is not trusted" msgstr "\"%s\" 프로시주얼 언어는 안전하지 못합니다" -#: catalog/aclchk.c:2595 +#: catalog/aclchk.c:2603 #, c-format msgid "" "GRANT and REVOKE are not allowed on untrusted languages, because only " "superusers can use untrusted languages." msgstr "" -"안전하지 ì•Šì€ í”„ë¡œì‹œì ¸ ì–¸ì–´ì— ëŒ€í•´ì„œëŠ” GRANT ë˜ëŠ” REVOKE ìž‘ì—…ì„ í—ˆìš©í•˜ì§€ " -"않습니다, 안전하지 ì•Šì€ í”„ë¡œì‹œì ¸ 언어는 슈í¼ìœ ì €ë§Œ 사용할 수 있기 때문입니다." +"안전하지 ì•Šì€ í”„ë¡œì‹œì ¸ ì–¸ì–´ì— ëŒ€í•´ì„œëŠ” GRANT ë˜ëŠ” REVOKE ìž‘ì—…ì„ í—ˆìš©í•˜ì§€ 않습" +"니다, 안전하지 ì•Šì€ í”„ë¡œì‹œì ¸ 언어는 슈í¼ìœ ì €ë§Œ 사용할 수 있기 때문입니다." -#: catalog/aclchk.c:3121 +#: catalog/aclchk.c:3129 #, c-format msgid "cannot set privileges of array types" msgstr "배열형 ìžë£Œí˜•ì— 권한 ì„¤ì •ì„ í•  수 ì—†ìŒ" -#: catalog/aclchk.c:3122 +#: catalog/aclchk.c:3130 #, c-format msgid "Set the privileges of the element type instead." msgstr "ê·¸ ë°°ì—´ ìš”ì†Œì— í•´ë‹¹í•˜ëŠ” ìžë£Œí˜•ì— 대해서 ì ‘ê·¼ 권한 ì„¤ì •ì„ í•˜ì„¸ìš”." -#: catalog/aclchk.c:3129 catalog/objectaddress.c:1523 commands/typecmds.c:3146 +#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3146 #, c-format msgid "\"%s\" is not a domain" msgstr "\"%s\" ì´ë¦„ì˜ ê°ì²´ëŠ” ë„ë©”ì¸ì´ 아닙니다" -#: catalog/aclchk.c:3252 +#: catalog/aclchk.c:3260 #, c-format msgid "unrecognized privilege type \"%s\"" msgstr "ì•Œ 수 없는 권한 타입 \"%s\"" -#: catalog/aclchk.c:3301 +#: catalog/aclchk.c:3309 #, c-format msgid "permission denied for column %s" msgstr "%s ì¹¼ëŸ¼ì— ëŒ€í•œ ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3303 +#: catalog/aclchk.c:3311 #, c-format msgid "permission denied for relation %s" msgstr "%s 릴레ì´ì…˜(relation) ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3305 commands/sequence.c:561 commands/sequence.c:786 +#: catalog/aclchk.c:3313 commands/sequence.c:561 commands/sequence.c:786 #: commands/sequence.c:828 commands/sequence.c:865 commands/sequence.c:1543 #, c-format msgid "permission denied for sequence %s" msgstr "%s 시퀀스 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3307 +#: catalog/aclchk.c:3315 #, c-format msgid "permission denied for database %s" msgstr "%s ë°ì´í„°ë² ì´ìŠ¤ ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3309 +#: catalog/aclchk.c:3317 #, c-format msgid "permission denied for function %s" msgstr "%s 함수 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3311 +#: catalog/aclchk.c:3319 #, c-format msgid "permission denied for operator %s" msgstr "%s ì—°ì‚°ìž ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3313 +#: catalog/aclchk.c:3321 #, c-format msgid "permission denied for type %s" msgstr "%s ìžë£Œí˜• ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3315 +#: catalog/aclchk.c:3323 #, c-format msgid "permission denied for language %s" msgstr "%s 프로시주얼 언어 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3317 +#: catalog/aclchk.c:3325 #, c-format msgid "permission denied for large object %s" msgstr "%s 대형 ê°ì²´ ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3319 +#: catalog/aclchk.c:3327 #, c-format msgid "permission denied for schema %s" msgstr "%s 스키마(schema) ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3321 +#: catalog/aclchk.c:3329 #, c-format msgid "permission denied for operator class %s" msgstr "%s ì—°ì‚°ìž í´ëž˜ìŠ¤ ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3323 +#: catalog/aclchk.c:3331 #, c-format msgid "permission denied for operator family %s" msgstr "%s ì—°ì‚°ìž íŒ¨ë°€ë¦¬ ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3325 +#: catalog/aclchk.c:3333 #, c-format msgid "permission denied for collation %s" msgstr "%s 정렬정ì˜(collation) ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3327 +#: catalog/aclchk.c:3335 #, c-format msgid "permission denied for conversion %s" msgstr "%s 문ìžì½”드변환규칙(conversion) ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3329 +#: catalog/aclchk.c:3337 #, c-format msgid "permission denied for tablespace %s" msgstr "%s í…Œì´ë¸”스페ì´ìŠ¤ ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3331 +#: catalog/aclchk.c:3339 #, c-format msgid "permission denied for text search dictionary %s" msgstr "%s 전문 검색 사전 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3333 +#: catalog/aclchk.c:3341 #, c-format msgid "permission denied for text search configuration %s" msgstr "%s 전문 검색 구성 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3335 +#: catalog/aclchk.c:3343 #, c-format msgid "permission denied for foreign-data wrapper %s" msgstr "%s 외부 ë°ì´í„° ëž˜í¼ ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3337 +#: catalog/aclchk.c:3345 #, c-format msgid "permission denied for foreign server %s" msgstr "%s 외부 서버 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3339 +#: catalog/aclchk.c:3347 #, c-format msgid "permission denied for event trigger %s" msgstr "%s ì´ë²¤íŠ¸ 트리거 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3341 +#: catalog/aclchk.c:3349 #, c-format msgid "permission denied for extension %s" msgstr "%s 확장 모듈 ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3347 catalog/aclchk.c:3349 +#: catalog/aclchk.c:3355 catalog/aclchk.c:3357 #, c-format msgid "must be owner of relation %s" msgstr "%s 릴레ì´ì…˜(relation)ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3351 +#: catalog/aclchk.c:3359 #, c-format msgid "must be owner of sequence %s" msgstr "%s ì‹œí€€ìŠ¤ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3353 +#: catalog/aclchk.c:3361 #, c-format msgid "must be owner of database %s" msgstr "%s ë°ì´í„°ë² ì´ìŠ¤ì˜ 소유주여야만 합니다" -#: catalog/aclchk.c:3355 +#: catalog/aclchk.c:3363 #, c-format msgid "must be owner of function %s" msgstr "%s í•¨ìˆ˜ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3357 +#: catalog/aclchk.c:3365 #, c-format msgid "must be owner of operator %s" msgstr "%s ì—°ì‚°ìžì˜ 소유주여야만 합니다" -#: catalog/aclchk.c:3359 +#: catalog/aclchk.c:3367 #, c-format msgid "must be owner of type %s" msgstr "%s ìžë£Œí˜•ì˜ 소유주여야만 합니다" -#: catalog/aclchk.c:3361 +#: catalog/aclchk.c:3369 #, c-format msgid "must be owner of language %s" msgstr "%s 프로시주얼 ì–¸ì–´ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3363 +#: catalog/aclchk.c:3371 #, c-format msgid "must be owner of large object %s" msgstr "%s 대형 ê°ì²´ì˜ 소유주여야만 합니다" -#: catalog/aclchk.c:3365 +#: catalog/aclchk.c:3373 #, c-format msgid "must be owner of schema %s" msgstr "%s 스키마(schema)ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3367 +#: catalog/aclchk.c:3375 #, c-format msgid "must be owner of operator class %s" msgstr "%s ì—°ì‚°ìž í´ëž˜ìŠ¤ì˜ 소유주여야만 합니다" -#: catalog/aclchk.c:3369 +#: catalog/aclchk.c:3377 #, c-format msgid "must be owner of operator family %s" msgstr "%s ì—°ì‚°ìž íŒ¨ë°€ë¦¬ì˜ ì†Œìœ ì£¼ì—¬ì•¼ 함" -#: catalog/aclchk.c:3371 +#: catalog/aclchk.c:3379 #, c-format msgid "must be owner of collation %s" msgstr "%s 정렬정ì˜(collation)ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3373 +#: catalog/aclchk.c:3381 #, c-format msgid "must be owner of conversion %s" msgstr "%s 문ìžì½”드변환규칙(conversion)ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3375 +#: catalog/aclchk.c:3383 #, c-format msgid "must be owner of tablespace %s" msgstr "%s í…Œì´ë¸”스페ì´ìŠ¤ì˜ 소유주여야만 합니다" -#: catalog/aclchk.c:3377 +#: catalog/aclchk.c:3385 #, c-format msgid "must be owner of text search dictionary %s" msgstr "%s 전문 검색 ì‚¬ì „ì˜ ì†Œìœ ì£¼ì—¬ì•¼ 함" -#: catalog/aclchk.c:3379 +#: catalog/aclchk.c:3387 #, c-format msgid "must be owner of text search configuration %s" msgstr "%s 전문 검색 êµ¬ì„±ì˜ ì†Œìœ ì£¼ì—¬ì•¼ 함" -#: catalog/aclchk.c:3381 +#: catalog/aclchk.c:3389 #, c-format msgid "must be owner of foreign-data wrapper %s" msgstr "%s 외부 ë°ì´í„° 래í¼ì˜ 소유주여야 함" -#: catalog/aclchk.c:3383 +#: catalog/aclchk.c:3391 #, c-format msgid "must be owner of foreign server %s" msgstr "%s 외부 ì„œë²„ì˜ ì†Œìœ ì£¼ì—¬ì•¼ 함" -#: catalog/aclchk.c:3385 +#: catalog/aclchk.c:3393 #, c-format msgid "must be owner of event trigger %s" msgstr "%s ì´ë²¤íŠ¸ íŠ¸ë¦¬ê±°ì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3387 +#: catalog/aclchk.c:3395 #, c-format msgid "must be owner of extension %s" msgstr "%s 확장 ëª¨ë“ˆì˜ ì†Œìœ ì£¼ì—¬ì•¼ë§Œ 합니다" -#: catalog/aclchk.c:3429 +#: catalog/aclchk.c:3437 #, c-format msgid "permission denied for column \"%s\" of relation \"%s\"" msgstr "\"%s\" 칼럼(해당 릴레ì´ì…˜: \"%s\") ì ‘ê·¼ 권한 ì—†ìŒ" -#: catalog/aclchk.c:3548 catalog/aclchk.c:3556 +#: catalog/aclchk.c:3556 catalog/aclchk.c:3564 #, c-format msgid "attribute %d of relation with OID %u does not exist" msgstr "%d번째 ì†ì„±(해당 릴레ì´ì…˜ OID: %u)ì´ ì—†ìŒ" -#: catalog/aclchk.c:3629 catalog/aclchk.c:4548 +#: catalog/aclchk.c:3637 catalog/aclchk.c:4556 #, c-format msgid "relation with OID %u does not exist" msgstr "OID %u 릴레ì´ì…˜(relation) ì—†ìŒ" -#: catalog/aclchk.c:3728 catalog/aclchk.c:4966 +#: catalog/aclchk.c:3736 catalog/aclchk.c:4974 #, c-format msgid "database with OID %u does not exist" msgstr "OID %u ë°ì´í„°ë² ì´ìŠ¤ ì—†ìŒ" -#: catalog/aclchk.c:3782 catalog/aclchk.c:4626 tcop/fastpath.c:223 +#: catalog/aclchk.c:3790 catalog/aclchk.c:4634 tcop/fastpath.c:223 #, c-format msgid "function with OID %u does not exist" msgstr "OID %u 함수 ì—†ìŒ" -#: catalog/aclchk.c:3836 catalog/aclchk.c:4652 +#: catalog/aclchk.c:3844 catalog/aclchk.c:4660 #, c-format msgid "language with OID %u does not exist" msgstr "OID %u 언어 ì—†ìŒ" -#: catalog/aclchk.c:4000 catalog/aclchk.c:4724 +#: catalog/aclchk.c:4008 catalog/aclchk.c:4732 #, c-format msgid "schema with OID %u does not exist" msgstr "OID %u 스키마 ì—†ìŒ" -#: catalog/aclchk.c:4054 catalog/aclchk.c:4751 +#: catalog/aclchk.c:4062 catalog/aclchk.c:4759 #, c-format msgid "tablespace with OID %u does not exist" msgstr "OID %u í…Œì´ë¸”스페ì´ìŠ¤ ì—†ìŒ" -#: catalog/aclchk.c:4113 catalog/aclchk.c:4885 commands/foreigncmds.c:325 +#: catalog/aclchk.c:4121 catalog/aclchk.c:4893 commands/foreigncmds.c:325 #, c-format msgid "foreign-data wrapper with OID %u does not exist" msgstr "OIDê°€ %uì¸ ì™¸ë¶€ ë°ì´í„° 래í¼ê°€ ì—†ìŒ" -#: catalog/aclchk.c:4175 catalog/aclchk.c:4912 commands/foreigncmds.c:461 +#: catalog/aclchk.c:4183 catalog/aclchk.c:4920 commands/foreigncmds.c:461 #, c-format msgid "foreign server with OID %u does not exist" msgstr "OIDê°€ %uì¸ ì™¸ë¶€ 서버가 ì—†ìŒ" -#: catalog/aclchk.c:4235 catalog/aclchk.c:4574 +#: catalog/aclchk.c:4243 catalog/aclchk.c:4582 #, c-format msgid "type with OID %u does not exist" msgstr "OID %u ìžë£Œí˜• ì—†ìŒ" -#: catalog/aclchk.c:4600 +#: catalog/aclchk.c:4608 #, c-format msgid "operator with OID %u does not exist" msgstr "OID %u ì—°ì‚°ìž ì—†ìŒ" -#: catalog/aclchk.c:4777 +#: catalog/aclchk.c:4785 #, c-format msgid "operator class with OID %u does not exist" msgstr "OID %u ì—°ì‚°ìž í´ëž˜ìŠ¤ ì—†ìŒ" -#: catalog/aclchk.c:4804 +#: catalog/aclchk.c:4812 #, c-format msgid "operator family with OID %u does not exist" msgstr "OIDê°€ %uì¸ ì—°ì‚°ìž íŒ¨ë°€ë¦¬ê°€ ì—†ìŒ" -#: catalog/aclchk.c:4831 +#: catalog/aclchk.c:4839 #, c-format msgid "text search dictionary with OID %u does not exist" msgstr "OIDê°€ %uì¸ ì „ë¬¸ 검색 ì‚¬ì „ì´ ì—†ìŒ" -#: catalog/aclchk.c:4858 +#: catalog/aclchk.c:4866 #, c-format msgid "text search configuration with OID %u does not exist" msgstr "OIDê°€ %uì¸ í…스트 검색 êµ¬ì„±ì´ ì—†ìŒ" -#: catalog/aclchk.c:4939 commands/event_trigger.c:587 +#: catalog/aclchk.c:4947 commands/event_trigger.c:587 #, c-format msgid "event trigger with OID %u does not exist" msgstr "OID %u ì´ë²¤íŠ¸ 트리거가 ì—†ìŒ" -#: catalog/aclchk.c:4992 +#: catalog/aclchk.c:5000 #, c-format msgid "collation with OID %u does not exist" msgstr "OID %u 정렬정ì˜(collation) ì—†ìŒ" -#: catalog/aclchk.c:5018 +#: catalog/aclchk.c:5026 #, c-format msgid "conversion with OID %u does not exist" msgstr "OID %u ì¸ì½”딩 변환규칙(conversion) ì—†ìŒ" -#: catalog/aclchk.c:5059 +#: catalog/aclchk.c:5067 #, c-format msgid "extension with OID %u does not exist" msgstr "OID %u 확장 ëª¨ë“ˆì´ ì—†ìŒ" -#: catalog/dependency.c:646 +#: catalog/dependency.c:645 #, c-format msgid "cannot drop %s because %s requires it" msgstr "%s 삭제할 수 ì—†ìŒ, %sì—ì„œ 필요로함" -#: catalog/dependency.c:649 +#: catalog/dependency.c:648 #, c-format msgid "You can drop %s instead." msgstr "대신ì—, drop %s ëª…ë ¹ì„ ì‚¬ìš©í•  수 있ìŒ." -#: catalog/dependency.c:811 catalog/pg_shdepend.c:576 +#: catalog/dependency.c:810 catalog/pg_shdepend.c:576 #, c-format msgid "cannot drop %s because it is required by the database system" msgstr "%s ê°ì²´ëŠ” ë°ì´í„°ë² ì´ìŠ¤ 시스템ì—ì„œ 필요하기 ë•Œë¬¸ì— ì‚­ì œ ë  ìˆ˜ ì—†ìŒ" -#: catalog/dependency.c:927 +#: catalog/dependency.c:926 #, c-format msgid "drop auto-cascades to %s" msgstr "%s ê°ì²´ê°€ ìžë™ìœ¼ë¡œ ë©ë‹¬ì•„ ì‚­ì œë¨" -#: catalog/dependency.c:939 catalog/dependency.c:948 +#: catalog/dependency.c:938 catalog/dependency.c:947 #, c-format msgid "%s depends on %s" msgstr "%s ì˜ì¡´ëŒ€ìƒ: %s" -#: catalog/dependency.c:960 catalog/dependency.c:969 +#: catalog/dependency.c:959 catalog/dependency.c:968 #, c-format msgid "drop cascades to %s" msgstr "%s ê°ì²´ê°€ ë©ë‹¬ì•„ ì‚­ì œë¨" -#: catalog/dependency.c:977 catalog/pg_shdepend.c:687 +#: catalog/dependency.c:976 catalog/pg_shdepend.c:687 #, c-format msgid "" "\n" @@ -3975,31 +3998,31 @@ msgid_plural "" msgstr[0] "" msgstr[1] "" -#: catalog/dependency.c:989 +#: catalog/dependency.c:988 #, c-format msgid "cannot drop %s because other objects depend on it" msgstr "기타 다른 ê°ì²´ë“¤ì´ ì´ ê°ì²´ì— ì˜ì¡´í•˜ê³  있어, %s 삭제할 수 ì—†ìŒ" -#: catalog/dependency.c:993 catalog/dependency.c:1000 +#: catalog/dependency.c:992 catalog/dependency.c:999 #, c-format msgid "Use DROP ... CASCADE to drop the dependent objects too." msgstr "" "ì´ ê°ì²´ì™€ ê´€ê³„ëœ ëª¨ë“  ê°ì²´ë“¤ì„ 함께 삭제하려면 DROP ... CASCADE ëª…ë ¹ì„ ì‚¬ìš©í•˜" "십시오" -#: catalog/dependency.c:997 +#: catalog/dependency.c:996 #, c-format msgid "cannot drop desired object(s) because other objects depend on them" msgstr "다른 ê°ì²´ê°€ ì›í•˜ëŠ” ê°ì²´ë¥¼ 사용하고 있으므로 해당 ê°ì²´ë¥¼ 삭제할 수 ì—†ìŒ" #. translator: %d always has a value larger than 1 -#: catalog/dependency.c:1006 +#: catalog/dependency.c:1005 #, c-format msgid "drop cascades to %d other object" msgid_plural "drop cascades to %d other objects" msgstr[0] "%dê°œì˜ ë‹¤ë¥¸ ê°ì²´ì— 대한 관련 항목 ì‚­ì œ" -#: catalog/dependency.c:1634 +#: catalog/dependency.c:1633 #, c-format msgid "constant of the type \"regrole\" cannot be used here" msgstr "\"regrole\" ìžë£Œí˜• ìƒìˆ˜ëŠ” 여기서 사용할 수 ì—†ìŒ" @@ -4014,13 +4037,13 @@ msgstr "\"%s.%s\" 만들 ê¶Œí•œì´ ì—†ìŒ" msgid "System catalog modifications are currently disallowed." msgstr "시스템 카탈로그 ë³€ê²½ì€ í˜„ìž¬ 허용하지 않습니다." -#: catalog/heap.c:415 commands/tablecmds.c:1438 commands/tablecmds.c:1895 -#: commands/tablecmds.c:4819 +#: catalog/heap.c:415 commands/tablecmds.c:1439 commands/tablecmds.c:1896 +#: commands/tablecmds.c:4820 #, c-format msgid "tables can have at most %d columns" msgstr "í•œ í…Œì´ë¸”ì— ì§€ì •í•  수 있는 최대 ì—´ 수는 %d입니다" -#: catalog/heap.c:432 commands/tablecmds.c:5080 +#: catalog/heap.c:432 commands/tablecmds.c:5081 #, c-format msgid "column name \"%s\" conflicts with a system column name" msgstr "\"%s\" ì—´ ì´ë¦„ì€ ì‹œìŠ¤í…œ ì—´ ì´ë¦„ê³¼ 충ëŒí•©ë‹ˆë‹¤" @@ -4054,10 +4077,11 @@ msgstr "%s 복합 ìžë£Œí˜•ì€ ìžê¸° ìžì‹ ì˜ 구성ì›ìœ¼ë¡œ 만들 수 ì—† #, c-format msgid "no collation was derived for column \"%s\" with collatable type %s" msgstr "" -"column \"%s\" ì¹¼ëŸ¼ì— ì‚¬ìš©í•˜ëŠ” %s ìžë£Œí˜•ì—ì„œ 사용할 ì •ë ¬ê·œì¹™ì„ ê²°ì •í•  수 없습니다." +"column \"%s\" ì¹¼ëŸ¼ì— ì‚¬ìš©í•˜ëŠ” %s ìžë£Œí˜•ì—ì„œ 사용할 ì •ë ¬ê·œì¹™ì„ ê²°ì •í•  수 없습" +"니다." #: catalog/heap.c:586 commands/createas.c:204 commands/createas.c:501 -#: commands/indexcmds.c:1132 commands/view.c:105 regex/regc_pg_locale.c:262 +#: commands/indexcmds.c:1133 commands/view.c:103 regex/regc_pg_locale.c:262 #: utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 #: utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 #: utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 @@ -4067,7 +4091,7 @@ msgstr "" msgid "Use the COLLATE clause to set the collation explicitly." msgstr "명시ì ìœ¼ë¡œ ì •ë ¬ ê·œì¹™ì„ ì§€ì •í•˜ë ¤ë©´ COLLATE ì ˆì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: catalog/heap.c:1067 catalog/index.c:792 commands/tablecmds.c:2622 +#: catalog/heap.c:1067 catalog/index.c:792 commands/tablecmds.c:2623 #, c-format msgid "relation \"%s\" already exists" msgstr "\"%s\" ì´ë¦„ì˜ ë¦´ë ˆì´ì…˜(relation)ì´ ì´ë¯¸ 있습니다" @@ -4085,109 +4109,109 @@ msgid "" "A relation has an associated type of the same name, so you must use a name " "that doesn't conflict with any existing type." msgstr "" -"í•˜ë‚˜ì˜ ë¦´ë ˆì´ì…˜ì€ ê·¸ ì´ë¦„ê³¼ ê°™ì€ ìžë£Œí˜•ê³¼ 관계합니다. 그래서, ì´ë¯¸ ê°™ì€ " -"ì´ë¦„ì˜ ìžë£Œí˜•ì´ 있다면 해당 릴레ì´ì…˜ì„ 만들 수 없습니다. 다른 ì´ë¦„ì„ " -"사용하세요." +"í•˜ë‚˜ì˜ ë¦´ë ˆì´ì…˜ì€ ê·¸ ì´ë¦„ê³¼ ê°™ì€ ìžë£Œí˜•ê³¼ 관계합니다. 그래서, ì´ë¯¸ ê°™ì€ ì´ë¦„" +"ì˜ ìžë£Œí˜•ì´ 있다면 해당 릴레ì´ì…˜ì„ 만들 수 없습니다. 다른 ì´ë¦„ì„ ì‚¬ìš©í•˜ì„¸ìš”." #: catalog/heap.c:1112 #, c-format msgid "pg_class heap OID value not set when in binary upgrade mode" msgstr "ì´ì§„ 업그레ì´ë“œ ìž‘ì—… ë•Œ, pg_class ìžë£Œ OID ê°’ì´ ì§€ì •ë˜ì§€ 않았습니다" -#: catalog/heap.c:2290 +#: catalog/heap.c:2291 #, c-format msgid "check constraint \"%s\" already exists" msgstr "\"%s\" ì´ë¦„ì˜ ì²´í¬ ì œì•½ ì¡°ê±´ì´ ì´ë¯¸ 있습니다" -#: catalog/heap.c:2455 catalog/pg_constraint.c:654 commands/tablecmds.c:6068 +#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6069 #, c-format msgid "constraint \"%s\" for relation \"%s\" already exists" msgstr "" "\"%s\" 제약 ì¡°ê±´ì´ ì´ë¯¸ \"%s\" 릴레ì´ì…˜(relation)ì—ì„œ 사용ë˜ê³  있습니다" -#: catalog/heap.c:2462 +#: catalog/heap.c:2463 #, c-format msgid "" "constraint \"%s\" conflicts with non-inherited constraint on relation \"%s\"" -msgstr "\"%s\" 제약 ì¡°ê±´ì´ ë¹„ìƒì† 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤, 해당 릴레ì´ì…˜: \"%s\"" +msgstr "" +"\"%s\" 제약 ì¡°ê±´ì´ ë¹„ìƒì† 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤, 해당 릴레ì´ì…˜: \"%s\"" -#: catalog/heap.c:2473 +#: catalog/heap.c:2474 #, c-format msgid "" "constraint \"%s\" conflicts with inherited constraint on relation \"%s\"" msgstr "\"%s\" 제약 ì¡°ê±´ì´ ìƒì† 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤, 해당 릴레ì´ì…˜: \"%s\"" -#: catalog/heap.c:2483 +#: catalog/heap.c:2484 #, c-format msgid "" "constraint \"%s\" conflicts with NOT VALID constraint on relation \"%s\"" -msgstr "\"%s\" 제약 ì¡°ê±´ì´ NOT VALID 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤, 해당 릴레ì´ì…˜: \"%s\"" +msgstr "" +"\"%s\" 제약 ì¡°ê±´ì´ NOT VALID 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤, 해당 릴레ì´ì…˜: \"%s\"" -#: catalog/heap.c:2488 +#: catalog/heap.c:2489 #, c-format msgid "merging constraint \"%s\" with inherited definition" msgstr "\"%s\" 제약 ì¡°ê±´ì„ ìƒì†ëœ ì •ì˜ì™€ 병합하는 중" -#: catalog/heap.c:2594 +#: catalog/heap.c:2595 #, c-format msgid "cannot use column references in default expression" msgstr "default 표현ì‹ì—서는 ì—´ reference를 사용할 수 ì—†ìŒ" -#: catalog/heap.c:2605 +#: catalog/heap.c:2606 #, c-format msgid "default expression must not return a set" msgstr "default 표현ì‹ì€ í•˜ë‚˜ì˜ setì„ ë°˜í™˜í•˜ë©´ 안ë©ë‹ˆë‹¤" -#: catalog/heap.c:2624 rewrite/rewriteHandler.c:1084 +#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1084 #, c-format msgid "column \"%s\" is of type %s but default expression is of type %s" msgstr "" "\"%s\" ì—´ì˜ ìžë£Œí˜•ì€ %s ì¸ë°, default 표현ì‹ì—서는 %s ìžë£Œí˜•ì„ 사용했습니다" -#: catalog/heap.c:2629 commands/prepare.c:374 parser/parse_node.c:428 -#: parser/parse_target.c:528 parser/parse_target.c:778 -#: parser/parse_target.c:788 rewrite/rewriteHandler.c:1089 +#: catalog/heap.c:2630 commands/prepare.c:374 parser/parse_node.c:428 +#: parser/parse_target.c:539 parser/parse_target.c:789 +#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1089 #, c-format msgid "You will need to rewrite or cast the expression." msgstr "다시 ì •ì˜í•˜ê±°ë‚˜ 형변화ìžë¥¼ 사용해보십시오" -#: catalog/heap.c:2676 +#: catalog/heap.c:2677 #, c-format msgid "only table \"%s\" can be referenced in check constraint" msgstr "\"%s\" í…Œì´ë¸”ë§Œì´ ì²´í¬ ì œì•½ ì¡°ê±´ì—ì„œ ì°¸ì¡°ë  ìˆ˜ 있습니다" -#: catalog/heap.c:2916 +#: catalog/heap.c:2917 #, c-format msgid "unsupported ON COMMIT and foreign key combination" msgstr "ON COMMIT ë° ì™¸ëž˜ 키 ì¡°í•©ì´ ì§€ì›ë˜ì§€ ì•ŠìŒ" -#: catalog/heap.c:2917 +#: catalog/heap.c:2918 #, c-format msgid "" "Table \"%s\" references \"%s\", but they do not have the same ON COMMIT " "setting." msgstr "" -"\"%s\" í…Œì´ë¸”ì—ì„œ \"%s\" í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ëŠ”ë° ON COMMIT ì„¤ì •ì´ ê°™ì§€ ì•Š" -"습니다." +"\"%s\" í…Œì´ë¸”ì—ì„œ \"%s\" í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ëŠ”ë° ON COMMIT ì„¤ì •ì´ ê°™ì§€ 않습니다." -#: catalog/heap.c:2922 +#: catalog/heap.c:2923 #, c-format msgid "cannot truncate a table referenced in a foreign key constraint" msgstr "" "_^_ í…Œì´ë¸” ë‚´ìš©ì„ ëª¨ë‘ ì‚­ì œí•  수 ì—†ìŒ, 참조키(foreign key) 제약 ì¡°ê±´ 안ì—ì„œ" -#: catalog/heap.c:2923 +#: catalog/heap.c:2924 #, c-format msgid "Table \"%s\" references \"%s\"." msgstr "\"%s\" í…Œì´ë¸”ì€ \"%s\" ê°ì²´ë¥¼ 참조합니다." -#: catalog/heap.c:2925 +#: catalog/heap.c:2926 #, c-format msgid "Truncate table \"%s\" at the same time, or use TRUNCATE ... CASCADE." msgstr "" "\"%s\" í…Œì´ë¸”ë„ í•¨ê»˜ ìžë£Œë¥¼ 지우거나, TRUNCATE ... CASCADE êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: catalog/index.c:210 parser/parse_utilcmd.c:1488 parser/parse_utilcmd.c:1574 +#: catalog/index.c:210 parser/parse_utilcmd.c:1473 parser/parse_utilcmd.c:1559 #, c-format msgid "multiple primary keys for table \"%s\" are not allowed" msgstr "\"%s\" í…Œì´ë¸”ì—는 ì´ë¯¸ 기본키가 있습니다" @@ -4215,7 +4239,7 @@ msgstr "" "들 수 없습니다" #: catalog/index.c:784 commands/createas.c:249 commands/sequence.c:141 -#: parser/parse_utilcmd.c:192 +#: parser/parse_utilcmd.c:191 #, c-format msgid "relation \"%s\" already exists, skipping" msgstr "\"%s\" ì´ë¦„ì˜ ë¦´ë ˆì´ì…˜(relation)ì´ ì´ë¯¸ 있습니다, 건너뜀" @@ -4272,19 +4296,19 @@ msgstr "\"%s.%s\" 릴레ì´ì…˜ì˜ 잠금 정보를 구할 수 ì—†ìŒ" msgid "could not obtain lock on relation \"%s\"" msgstr "\"%s\" 릴레ì´ì…˜ì˜ 잠금 정보를 구할 수 ì—†ìŒ" -#: catalog/namespace.c:414 parser/parse_relation.c:1137 +#: catalog/namespace.c:414 parser/parse_relation.c:1138 #, c-format msgid "relation \"%s.%s\" does not exist" msgstr "\"%s.%s\" ì´ë¦„ì˜ ë¦´ë ˆì´ì…˜(relation)ì´ ì—†ìŠµë‹ˆë‹¤" -#: catalog/namespace.c:419 parser/parse_relation.c:1150 -#: parser/parse_relation.c:1158 utils/adt/regproc.c:1034 +#: catalog/namespace.c:419 parser/parse_relation.c:1151 +#: parser/parse_relation.c:1159 utils/adt/regproc.c:1034 #, c-format msgid "relation \"%s\" does not exist" msgstr "\"%s\" ì´ë¦„ì˜ ë¦´ë ˆì´ì…˜(relation)ì´ ì—†ìŠµë‹ˆë‹¤" -#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1382 -#: commands/extension.c:1388 +#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1383 +#: commands/extension.c:1389 #, c-format msgid "no schema has been selected to create in" msgstr "ì„ íƒëœ 스키마 ì—†ìŒ, 대ìƒ:" @@ -4325,13 +4349,13 @@ msgstr "\"%s\" 전문 검색 í…œí”Œë¦¿ì´ ì—†ìŒ" msgid "text search configuration \"%s\" does not exist" msgstr "\"%s\" 전문 검색 êµ¬ì„±ì´ ì—†ìŒ" -#: catalog/namespace.c:2646 parser/parse_expr.c:792 parser/parse_target.c:1130 +#: catalog/namespace.c:2646 parser/parse_expr.c:792 parser/parse_target.c:1141 #, c-format msgid "cross-database references are not implemented: %s" msgstr "서로 다른 ë°ì´í„°ë² ì´ìŠ¤ê°„ì˜ ì°¸ì¡°ëŠ” 구현ë˜ì–´ìžˆì§€ 않습니다: %s" -#: catalog/namespace.c:2652 parser/parse_expr.c:799 parser/parse_target.c:1137 -#: gram.y:13450 gram.y:14819 +#: catalog/namespace.c:2652 parser/parse_expr.c:799 parser/parse_target.c:1148 +#: gram.y:13454 gram.y:14823 #, c-format msgid "improper qualified name (too many dotted names): %s" msgstr "ì ë‹¹í•˜ì§€ ì•Šì€ qualified ì´ë¦„ 입니다 (너무 ë§Žì€ ì ì´ 있네요): %s" @@ -4347,7 +4371,7 @@ msgid "cannot move objects into or out of TOAST schema" msgstr "TOAST 스키마로(ì—ì„œ) ê°ì²´ë¥¼ ì´ë™í•  수 없습니다" #: catalog/namespace.c:2862 commands/schemacmds.c:238 -#: commands/schemacmds.c:317 commands/tablecmds.c:740 +#: commands/schemacmds.c:317 commands/tablecmds.c:741 #, c-format msgid "schema \"%s\" does not exist" msgstr "\"%s\" 스키마(schema) ì—†ìŒ" @@ -4384,7 +4408,7 @@ msgid "cannot create temporary tables in parallel mode" msgstr "병렬 모드ì—서는 ìž„ì‹œ í…Œì´ë¸”ì„ ë§Œë“¤ 수 ì—†ìŒ" #: catalog/namespace.c:3932 commands/tablespace.c:1173 commands/variable.c:63 -#: utils/misc/guc.c:9867 +#: utils/misc/guc.c:9875 #, c-format msgid "List syntax is invalid." msgstr "ëª©ë¡ ë¬¸ë²•ì´ í‹€ë ¸ìŠµë‹ˆë‹¤." @@ -4397,7 +4421,7 @@ msgstr "ì ‘ê·¼ 방법 ì´ë¦„ì´ ì ë‹¹ì¹˜ 않습니다" msgid "database name cannot be qualified" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì´ë¦„ì´ ì ë‹¹ì¹˜ 않습니다" -#: catalog/objectaddress.c:1071 commands/extension.c:2506 +#: catalog/objectaddress.c:1071 commands/extension.c:2507 #, c-format msgid "extension name cannot be qualified" msgstr "확장 모듈 ì´ë¦„으로 ì ë‹¹í•˜ì§€ 않습니다" @@ -4431,27 +4455,27 @@ msgid "event trigger name cannot be qualified" msgstr "ì´ë²¤íŠ¸ 트리거 ì´ë¦„ì´ ì ë‹¹ì¹˜ 않습니다" #: catalog/objectaddress.c:1210 commands/lockcmds.c:94 commands/policy.c:94 -#: commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:217 -#: commands/tablecmds.c:1299 commands/tablecmds.c:4346 -#: commands/tablecmds.c:7977 +#: commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:218 +#: commands/tablecmds.c:1300 commands/tablecmds.c:4347 +#: commands/tablecmds.c:8017 #, c-format msgid "\"%s\" is not a table" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ì´ ì•„ë‹˜" -#: catalog/objectaddress.c:1217 commands/tablecmds.c:229 -#: commands/tablecmds.c:4376 commands/tablecmds.c:12023 commands/view.c:143 +#: catalog/objectaddress.c:1217 commands/tablecmds.c:230 +#: commands/tablecmds.c:4377 commands/tablecmds.c:12159 commands/view.c:141 #, c-format msgid "\"%s\" is not a view" msgstr "\"%s\" ê°ì²´ëŠ” ë·°ê°€ 아님" #: catalog/objectaddress.c:1224 commands/matview.c:174 -#: commands/tablecmds.c:235 commands/tablecmds.c:12028 +#: commands/tablecmds.c:236 commands/tablecmds.c:12164 #, c-format msgid "\"%s\" is not a materialized view" msgstr "\"%s\" ê°ì²´ëŠ” êµ¬ì²´í™”ëœ ë·°(materialized view)ê°€ 아닙니다" -#: catalog/objectaddress.c:1231 commands/tablecmds.c:253 -#: commands/tablecmds.c:4379 commands/tablecmds.c:12033 +#: catalog/objectaddress.c:1231 commands/tablecmds.c:254 +#: commands/tablecmds.c:4380 commands/tablecmds.c:12169 #, c-format msgid "\"%s\" is not a foreign table" msgstr "\"%s\" ê°ì²´ëŠ” 외부 í…Œì´ë¸”ì´ ì•„ë‹˜" @@ -4467,7 +4491,7 @@ msgid "default value for column \"%s\" of relation \"%s\" does not exist" msgstr "\"%s\" 칼럼(해당 릴레ì´ì…˜: \"%s\")ì˜ ê¸°ë³¸ê°’ì„ ì§€ì •í•˜ì§€ 않았ìŒ" #: catalog/objectaddress.c:1512 commands/functioncmds.c:128 -#: commands/tablecmds.c:245 commands/typecmds.c:3214 parser/parse_type.c:226 +#: commands/tablecmds.c:246 commands/typecmds.c:3214 parser/parse_type.c:226 #: parser/parse_type.c:255 parser/parse_type.c:795 utils/adt/acl.c:4374 #: utils/adt/regproc.c:1225 #, c-format @@ -4843,14 +4867,12 @@ msgid "" "An aggregate using a polymorphic transition type must have at least one " "polymorphic argument." msgstr "" -"다형 변환 형ì‹ì„ 사용하는 집계ì—는 다형 ì¸ìžê°€ 하나 ì´ìƒ 있어야 í•©" -"니다." +"다형 변환 형ì‹ì„ 사용하는 집계ì—는 다형 ì¸ìžê°€ 하나 ì´ìƒ 있어야 합니다." #: catalog/pg_aggregate.c:172 #, c-format msgid "a variadic ordered-set aggregate must use VARIADIC type ANY" -msgstr "" -"variadic 순서있는 세트 집계함수는 VARIADIC ANY í˜•ì„ ì‚¬ìš©í•´ì•¼ 합니다" +msgstr "variadic 순서있는 세트 집계함수는 VARIADIC ANY í˜•ì„ ì‚¬ìš©í•´ì•¼ 합니다" #: catalog/pg_aggregate.c:198 #, c-format @@ -4870,15 +4892,15 @@ msgid "" "must not omit initial value when transition function is strict and " "transition type is not compatible with input type" msgstr "" -"변환 함수가 엄격하고 변환 형ì‹ì´ ìž…ë ¥ 형ì‹ê³¼ 호환ë˜ì§€ 않는 경우 ì´ˆ" -"ê¸°ê°’ì„ ìƒëžµí•˜ë©´ 안ë¨" +"변환 함수가 엄격하고 변환 형ì‹ì´ ìž…ë ¥ 형ì‹ê³¼ 호환ë˜ì§€ 않는 경우 ì´ˆê¸°ê°’ì„ ìƒëžµ" +"하면 안ë¨" #: catalog/pg_aggregate.c:334 #, c-format msgid "return type of inverse transition function %s is not %s" msgstr "%s inverse transition í•¨ìˆ˜ì˜ ë°˜í™˜ ìžë£Œí˜•ì´ %s í˜•ì´ ì•„ë‹™ë‹ˆë‹¤." -#: catalog/pg_aggregate.c:351 executor/nodeWindowAgg.c:2301 +#: catalog/pg_aggregate.c:351 executor/nodeWindowAgg.c:2334 #, c-format msgid "" "strictness of aggregate's forward and inverse transition functions must match" @@ -5019,7 +5041,7 @@ msgstr "\"%s\" ì´ë¦„ì˜ ë³€í™˜ê·œì¹™(conversion)ì´ ì´ë¯¸ 있ìŒ" msgid "default conversion for %s to %s already exists" msgstr "%s 코드ì—ì„œ %s 코드로 변환하는 기본 변환규칙(conversion)ì€ ì´ë¯¸ 있ìŒ" -#: catalog/pg_depend.c:165 commands/extension.c:3028 +#: catalog/pg_depend.c:165 commands/extension.c:3029 #, c-format msgid "%s is already a member of extension \"%s\"" msgstr "%s ê°ì²´ëŠ” \"%s\" í™•ìž¥ëª¨ë“ˆì— ì´ë¯¸ 구성ì›ìž…니다" @@ -5062,7 +5084,8 @@ msgstr "ì´ì§„ 업그레ì´ë“œ ìž‘ì—… ë•Œ pg_enum OID ê°’ì´ ì§€ì •ë˜ì§€ 않았 #: catalog/pg_enum.c:359 #, c-format msgid "ALTER TYPE ADD BEFORE/AFTER is incompatible with binary upgrade" -msgstr "ALTER TYPE ADD BEFORE/AFTER êµ¬ë¬¸ì€ ì´ì§„ 업그레ì´ë“œ ìž‘ì—…ì—ì„œ 호환하지 않습니다" +msgstr "" +"ALTER TYPE ADD BEFORE/AFTER êµ¬ë¬¸ì€ ì´ì§„ 업그레ì´ë“œ ìž‘ì—…ì—ì„œ 호환하지 않습니다" #: catalog/pg_namespace.c:61 commands/schemacmds.c:246 #, c-format @@ -5140,8 +5163,7 @@ msgstr[0] "함수는 %dê°œ ì´ìƒì˜ ì¸ìžë¥¼ 사용할 수 ì—†ìŒ" msgid "" "A function returning a polymorphic type must have at least one polymorphic " "argument." -msgstr "" -"다형 형ì‹ì„ 반환하는 함수ì—는 다형 ì¸ìžê°€ 하나 ì´ìƒ 있어야 합니다." +msgstr "다형 형ì‹ì„ 반환하는 함수ì—는 다형 ì¸ìžê°€ 하나 ì´ìƒ 있어야 합니다." #: catalog/pg_proc.c:254 #, c-format @@ -5228,7 +5250,7 @@ msgstr "SQL 함수는 %s ìžë£Œí˜•ì„ 리턴할 수 ì—†ìŒ" msgid "SQL functions cannot have arguments of type %s" msgstr "SQL í•¨ìˆ˜ì˜ ì¸ìžë¡œ %s ìžë£Œí˜•ì€ ì‚¬ìš©ë  ìˆ˜ 없습니다" -#: catalog/pg_proc.c:973 executor/functions.c:1422 +#: catalog/pg_proc.c:973 executor/functions.c:1431 #, c-format msgid "SQL function \"%s\"" msgstr "\"%s\" SQL 함수" @@ -5334,8 +5356,8 @@ msgstr "_^_ ê³ ì •í¬ê¸° ìžë£Œí˜•ì€ PLAIN ì €ìž¥ë°©ë²•ì„ ê°€ì ¸ì•¼ë§Œ 합니 msgid "could not form array type name for type \"%s\"" msgstr "\"%s\" 형ì‹ì˜ ë°°ì—´ í˜•ì‹ ì´ë¦„ì„ ìƒì„±í•  수 ì—†ìŒ" -#: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4358 -#: commands/tablecmds.c:11911 +#: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4359 +#: commands/tablecmds.c:12047 #, c-format msgid "\"%s\" is not a table or materialized view" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ë„ êµ¬ì²´í™”ëœ ë·°ë„ ì•„ë‹™ë‹ˆë‹¤" @@ -5508,7 +5530,7 @@ msgstr "\"%s\" ì´ë¦„ì˜ ì¸ë±ìŠ¤ ì ‘ê·¼ ë°©ë²•ì´ ì´ë¯¸ 있습니다." msgid "must be superuser to drop access methods" msgstr "ì ‘ê·¼ ë°©ë²•ì€ ìŠˆí¼ìœ ì €ë§Œ 삭제할 수 있습니다." -#: commands/amcmds.c:175 commands/indexcmds.c:164 commands/indexcmds.c:495 +#: commands/amcmds.c:175 commands/indexcmds.c:164 commands/indexcmds.c:496 #: commands/opclasscmds.c:365 commands/opclasscmds.c:790 #, c-format msgid "access method \"%s\" does not exist" @@ -5555,7 +5577,8 @@ msgstr "\"%s\" 건너뜀 --- 외부 í…Œì´ë¸”ì€ ë¶„ì„í•  수 ì—†ìŒ" #: commands/analyze.c:241 #, c-format msgid "skipping \"%s\" --- cannot analyze non-tables or special system tables" -msgstr "\"%s\" 건너뜀 --- í…Œì´ë¸”ì´ ì•„ë‹ˆê±°ë‚˜, 특수 시스템 í…Œì´ë¸”ë“¤ì€ ë¶„ì„í•  수 ì—†ìŒ" +msgstr "" +"\"%s\" 건너뜀 --- í…Œì´ë¸”ì´ ì•„ë‹ˆê±°ë‚˜, 특수 시스템 í…Œì´ë¸”ë“¤ì€ ë¶„ì„í•  수 ì—†ìŒ" #: commands/analyze.c:320 #, c-format @@ -5578,8 +5601,8 @@ msgid "" "\"%s\": scanned %d of %u pages, containing %.0f live rows and %.0f dead " "rows; %d rows in sample, %.0f estimated total rows" msgstr "" -"\"%s\": íƒìƒ‰í•œ 페ì´ì§€: %d, 전체페ì´ì§€: %u, 실ìžë£Œ: %.0fê°œ, 쓰레기ìžë£Œ: " -"%.0fê°œ; 표본 추출 ìžë£Œ: %dê°œ, 예ìƒí•œ ì´ ìžë£Œ: %.0fê°œ" +"\"%s\": íƒìƒ‰í•œ 페ì´ì§€: %d, 전체페ì´ì§€: %u, 실ìžë£Œ: %.0fê°œ, 쓰레기ìžë£Œ: %.0f" +"ê°œ; 표본 추출 ìžë£Œ: %dê°œ, 예ìƒí•œ ì´ ìžë£Œ: %.0fê°œ" #: commands/analyze.c:1283 #, c-format @@ -5587,7 +5610,8 @@ msgid "" "skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree " "contains no child tables" msgstr "" -"\"%s.%s\" ìƒì† ë‚˜ë¬´ì˜ í†µê³„ 수집 건너뜀 --- ì´ ìƒì† 나무ì—는 하위 í…Œì´ë¸”ì´ ì—†ìŒ" +"\"%s.%s\" ìƒì† ë‚˜ë¬´ì˜ í†µê³„ 수집 건너뜀 --- ì´ ìƒì† 나무ì—는 하위 í…Œì´ë¸”ì´ ì—†" +"ìŒ" #: commands/analyze.c:1372 #, c-format @@ -5595,9 +5619,10 @@ msgid "" "skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree " "contains no analyzable child tables" msgstr "" -"\"%s.%s\" ìƒì† ë‚˜ë¬´ì˜ í†µê³„ 수집 건너뜀 --- ì´ ìƒì† 나무ì—는 통계 수집할 하위 í…Œì´ë¸”ì´ ì—†ìŒ" +"\"%s.%s\" ìƒì† ë‚˜ë¬´ì˜ í†µê³„ 수집 건너뜀 --- ì´ ìƒì† 나무ì—는 통계 수집할 하위 " +"í…Œì´ë¸”ì´ ì—†ìŒ" -#: commands/analyze.c:1420 executor/execQual.c:2927 +#: commands/analyze.c:1420 commands/tablecmds.c:8079 executor/execQual.c:2927 msgid "could not convert row type" msgstr "로우 ìžë£Œí˜•ì„ 변환 í•  수 ì—†ìŒ" @@ -5621,7 +5646,8 @@ msgstr "payload 문ìžì—´ì´ 너무 긺" #, c-format msgid "" "cannot PREPARE a transaction that has executed LISTEN, UNLISTEN, or NOTIFY" -msgstr "LISTEN, UNLISTEN ë˜ëŠ” NOTIFY 옵션으로 ì‹¤í–‰ëœ íŠ¸ëžœìž­ì…˜ì„ PREPAREí•  수 ì—†ìŒ" +msgstr "" +"LISTEN, UNLISTEN ë˜ëŠ” NOTIFY 옵션으로 ì‹¤í–‰ëœ íŠ¸ëžœìž­ì…˜ì„ PREPAREí•  수 ì—†ìŒ" #: commands/async.c:856 #, c-format @@ -5637,8 +5663,7 @@ msgstr "NOTIFY í 사용률: %.0f%%" #, c-format msgid "" "The server process with PID %d is among those with the oldest transactions." -msgstr "" -"%d PID 서버 프로세스가 가장 ì˜¤ëž˜ëœ íŠ¸ëžœìž­ì…˜ì„ ì‚¬ìš©í•˜ê³  있습니다." +msgstr "%d PID 서버 프로세스가 가장 ì˜¤ëž˜ëœ íŠ¸ëžœìž­ì…˜ì„ ì‚¬ìš©í•˜ê³  있습니다." #: commands/async.c:1491 #, c-format @@ -5658,7 +5683,7 @@ msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸”ì€ cluster ìž‘ì—…ì„ í•  수 없습니 msgid "there is no previously clustered index for table \"%s\"" msgstr "\"%s\" í…Œì´ë¸”ì„ ìœ„í•œ previously clustered ì¸ë±ìŠ¤ê°€ ì—†ìŒ" -#: commands/cluster.c:173 commands/tablecmds.c:9286 commands/tablecmds.c:11013 +#: commands/cluster.c:173 commands/tablecmds.c:9383 commands/tablecmds.c:11143 #, c-format msgid "index \"%s\" for table \"%s\" does not exist" msgstr "\"%s\" ì¸ë±ìŠ¤ëŠ” \"%s\" í…Œì´ë¸”ì— ì—†ìŒ" @@ -5673,7 +5698,7 @@ msgstr "ê³µìœ ëœ ì¹´íƒˆë¡œê·¸ëŠ” í´ëŸ¬ìŠ¤í„° ìž‘ì—…ì„ í•  수 ì—†ìŒ" msgid "cannot vacuum temporary tables of other sessions" msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸”ì€ vacuum ìž‘ì—…ì„ í•  수 ì—†ìŒ" -#: commands/cluster.c:431 commands/tablecmds.c:11023 +#: commands/cluster.c:431 commands/tablecmds.c:11153 #, c-format msgid "\"%s\" is not an index for table \"%s\"" msgstr "\"%s\" ê°ì²´ëŠ” \"%s\" í…Œì´ë¸”ì„ ìœ„í•œ ì¸ë±ìŠ¤ê°€ 아님" @@ -5763,13 +5788,14 @@ msgstr "\"%s\" ì •ë ¬ê·œì¹™ì´ \"%s\" ìŠ¤í‚¤ë§ˆì— ì´ë¯¸ 있습니다" msgid "database \"%s\" does not exist" msgstr "\"%s\" ë°ì´í„°ë² ì´ìŠ¤ ì—†ìŒ" -#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:768 +#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:753 #, c-format msgid "" "\"%s\" is not a table, view, materialized view, composite type, or foreign " "table" msgstr "" -"\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ë„, ë·°ë„, êµ¬ì²´í™”ëœ ë·°ë„, 복합 ìžë£Œí˜•ë„, 외부 í…Œì´ë¸”ë„ ì•„ë‹™ë‹ˆë‹¤." +"\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ë„, ë·°ë„, êµ¬ì²´í™”ëœ ë·°ë„, 복합 ìžë£Œí˜•ë„, 외부 í…Œì´ë¸”ë„ ì•„" +"닙니다." #: commands/constraint.c:60 utils/adt/ri_triggers.c:2715 #, c-format @@ -5867,8 +5893,7 @@ msgstr "" #: commands/copy.c:879 #, c-format msgid "COPY FROM not supported with row-level security" -msgstr "" -"로우 단위 보안 기능으로 COPY FROM ëª…ë ¹ì„ ì‚¬ìš©í•  수 ì—†ìŒ" +msgstr "로우 단위 보안 기능으로 COPY FROM ëª…ë ¹ì„ ì‚¬ìš©í•  수 ì—†ìŒ" #: commands/copy.c:880 #, c-format @@ -5914,9 +5939,7 @@ msgstr "COPY 구분ìžëŠ” 1ë°”ì´íŠ¸ì˜ ë‹¨ì¼ ë¬¸ìžì—¬ì•¼ 함" #: commands/copy.c:1241 #, c-format msgid "COPY delimiter cannot be newline or carriage return" -msgstr "" -"COPY 명령ì—ì„œ 사용할 칼럼 구분ìžë¡œ 줄바꿈 문ìžë“¤ì„ 사용할 수 없습니" -"다" +msgstr "COPY 명령ì—ì„œ 사용할 칼럼 구분ìžë¡œ 줄바꿈 문ìžë“¤ì„ 사용할 수 없습니다" #: commands/copy.c:1247 #, c-format @@ -6174,7 +6197,8 @@ msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ì´ ì•„ë‹Œ 릴레ì´ì…˜(relation)ì´ê¸°ì— ë³µ #: commands/copy.c:2356 #, c-format msgid "cannot perform FREEZE because of prior transaction activity" -msgstr "먼저 시작한 다른 íŠ¸ëžœìž­ì…˜ì´ ì•„ì§ í™œì„± ìƒíƒœì—¬ì„œ FREEZE ìž‘ì—…ì€ ì§„í–‰í•  수 ì—†ìŒ" +msgstr "" +"먼저 시작한 다른 íŠ¸ëžœìž­ì…˜ì´ ì•„ì§ í™œì„± ìƒíƒœì—¬ì„œ FREEZE ìž‘ì—…ì€ ì§„í–‰í•  수 ì—†ìŒ" #: commands/copy.c:2362 #, c-format @@ -6182,8 +6206,8 @@ msgid "" "cannot perform FREEZE because the table was not created or truncated in the " "current subtransaction" msgstr "" -"현재 하위 트랜잭션ì—ì„œ 만들어지거나 비워진 í…Œì´ë¸”ì´ ì•„ë‹ˆê¸° ë•Œë¬¸ì— " -"FREEZE ìž‘ì—…ì„ í•  수 ì—†ìŒ" +"현재 하위 트랜잭션ì—ì„œ 만들어지거나 비워진 í…Œì´ë¸”ì´ ì•„ë‹ˆê¸° ë•Œë¬¸ì— FREEZE ìž‘ì—…" +"ì„ í•  수 ì—†ìŒ" #: commands/copy.c:2865 #, c-format @@ -6316,15 +6340,15 @@ msgstr "ìž˜ëª»ëœ í•„ë“œ í¬ê¸°" msgid "incorrect binary data format" msgstr "ìž˜ëª»ëœ ë°”ì´ë„ˆë¦¬ ìžë£Œ í¬ë§·" -#: commands/copy.c:4463 commands/indexcmds.c:1053 commands/tablecmds.c:1463 -#: commands/tablecmds.c:2290 parser/parse_relation.c:3084 -#: parser/parse_relation.c:3104 utils/adt/tsvector_op.c:2307 +#: commands/copy.c:4463 commands/indexcmds.c:1054 commands/tablecmds.c:1464 +#: commands/tablecmds.c:2291 parser/parse_relation.c:3177 +#: parser/parse_relation.c:3197 utils/adt/tsvector_op.c:2559 #, c-format msgid "column \"%s\" does not exist" msgstr "\"%s\" ì´ë¦„ì˜ ì—´ì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/copy.c:4470 commands/tablecmds.c:1489 commands/trigger.c:651 -#: parser/parse_target.c:956 parser/parse_target.c:967 +#: commands/copy.c:4470 commands/tablecmds.c:1490 commands/trigger.c:651 +#: parser/parse_target.c:967 parser/parse_target.c:978 #, c-format msgid "column \"%s\" specified more than once" msgstr "\"%s\" ì—´ì„ í•˜ë‚˜ ì´ìƒ 지정했ìŒ" @@ -6395,8 +6419,7 @@ msgstr "\"%s\" ë¡œì¼€ì¼ ì´ë¦„ì´ ìž˜ëª»ë¨" msgid "" "new encoding (%s) is incompatible with the encoding of the template database " "(%s)" -msgstr "" -"새 ì¸ì½”딩(%s)ì´ í…œí”Œë¦¿ ë°ì´í„°ë² ì´ìŠ¤ì˜ ì¸ì½”딩(%s)ê³¼ 호환ë˜ì§€ ì•ŠìŒ" +msgstr "새 ì¸ì½”딩(%s)ì´ í…œí”Œë¦¿ ë°ì´í„°ë² ì´ìŠ¤ì˜ ì¸ì½”딩(%s)ê³¼ 호환ë˜ì§€ ì•ŠìŒ" #: commands/dbcommands.c:383 #, c-format @@ -6404,8 +6427,8 @@ msgid "" "Use the same encoding as in the template database, or use template0 as " "template." msgstr "" -"템플릿 ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ì¼í•œ ì¸ì½”ë”©ì„ ì‚¬ìš©í•˜ê±°ë‚˜ template0ì„ í…œí”Œë¦¿" -"으로 사용하십시오." +"템플릿 ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ì¼í•œ ì¸ì½”ë”©ì„ ì‚¬ìš©í•˜ê±°ë‚˜ template0ì„ í…œí”Œë¦¿ìœ¼ë¡œ 사용" +"하십시오." #: commands/dbcommands.c:388 #, c-format @@ -6413,7 +6436,8 @@ msgid "" "new collation (%s) is incompatible with the collation of the template " "database (%s)" msgstr "" -"새 ë°ì´í„° ì •ë ¬ 규칙 (%s)ì´ í…œí”Œë¦¿ ë°ì´í„°ë² ì´ìŠ¤ì˜ ë°ì´í„° ì •ë ¬ 규칙(%s)ê³¼ 호환ë˜ì§€ ì•ŠìŒ" +"새 ë°ì´í„° ì •ë ¬ 규칙 (%s)ì´ í…œí”Œë¦¿ ë°ì´í„°ë² ì´ìŠ¤ì˜ ë°ì´í„° ì •ë ¬ 규칙(%s)ê³¼ 호환" +"ë˜ì§€ ì•ŠìŒ" #: commands/dbcommands.c:390 #, c-format @@ -6421,16 +6445,15 @@ msgid "" "Use the same collation as in the template database, or use template0 as " "template." msgstr "" -"템플릿 ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ì¼í•œ ë°ì´í„° ì •ë ¬ ê·œì¹™ì„ ì‚¬ìš©í•˜ê±°ë‚˜ template0ì„ " -"템플릿으로 사용하십시오." +"템플릿 ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ì¼í•œ ë°ì´í„° ì •ë ¬ ê·œì¹™ì„ ì‚¬ìš©í•˜ê±°ë‚˜ template0ì„ í…œí”Œë¦¿" +"으로 사용하십시오." #: commands/dbcommands.c:395 #, c-format msgid "" "new LC_CTYPE (%s) is incompatible with the LC_CTYPE of the template database " "(%s)" -msgstr "" -"새 LC_CTYPE (%s)ì´ í…œí”Œë¦¿ ë°ì´í„°ë² ì´ìŠ¤ì˜ LC_CTYPE (%s)ê³¼ 호환ë˜ì§€ ì•ŠìŒ" +msgstr "새 LC_CTYPE (%s)ì´ í…œí”Œë¦¿ ë°ì´í„°ë² ì´ìŠ¤ì˜ LC_CTYPE (%s)ê³¼ 호환ë˜ì§€ ì•ŠìŒ" #: commands/dbcommands.c:397 #, c-format @@ -6438,7 +6461,8 @@ msgid "" "Use the same LC_CTYPE as in the template database, or use template0 as " "template." msgstr "" -"템플릿 ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ì¼í•œ LC_CTYPEì„ ì‚¬ìš©í•˜ê±°ë‚˜ template0ì„ í…œí”Œë¦¿ìœ¼ë¡œ 사용하십시오." +"템플릿 ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ì¼í•œ LC_CTYPEì„ ì‚¬ìš©í•˜ê±°ë‚˜ template0ì„ í…œí”Œë¦¿ìœ¼ë¡œ 사" +"용하십시오." #: commands/dbcommands.c:419 commands/dbcommands.c:1113 #, c-format @@ -6534,7 +6558,8 @@ msgstr "현재 ì—´ë ¤ 있는 ë°ì´í„°ë² ì´ìŠ¤ì˜ í…Œì´ë¸”스페ì´ìŠ¤ë¥¼ ë°” #: commands/dbcommands.c:1194 #, c-format msgid "some relations of database \"%s\" are already in tablespace \"%s\"" -msgstr "\"%s\" ë°ì´í„°ë² ì´ìŠ¤ì˜ ì¼ë¶€ 릴레ì´ì…˜ë“¤ì´ \"%s\" í…Œì´ë¸”스페ì´ìŠ¤ì— ì´ë¯¸ 있ìŒ" +msgstr "" +"\"%s\" ë°ì´í„°ë² ì´ìŠ¤ì˜ ì¼ë¶€ 릴레ì´ì…˜ë“¤ì´ \"%s\" í…Œì´ë¸”스페ì´ìŠ¤ì— ì´ë¯¸ 있ìŒ" #: commands/dbcommands.c:1196 #, c-format @@ -6542,8 +6567,8 @@ msgid "" "You must move them back to the database's default tablespace before using " "this command." msgstr "" -"ì´ ëª…ë ¹ì„ ì‚¬ìš©í•˜ê¸° ì „ì— ë°ì´í„°ë² ì´ìŠ¤ì˜ 기본 í…Œì´ë¸”스페ì´ìŠ¤ë¡œ 다시 " -"ì´ë™í•´ì•¼ 합니다." +"ì´ ëª…ë ¹ì„ ì‚¬ìš©í•˜ê¸° ì „ì— ë°ì´í„°ë² ì´ìŠ¤ì˜ 기본 í…Œì´ë¸”스페ì´ìŠ¤ë¡œ 다시 ì´ë™í•´ì•¼ í•©" +"니다." #: commands/dbcommands.c:1325 commands/dbcommands.c:1868 #: commands/dbcommands.c:2072 commands/dbcommands.c:2120 @@ -6574,8 +6599,7 @@ msgid "" "There are %d other session(s) and %d prepared transaction(s) using the " "database." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 사용하는 %dê°œì˜ ë‹¤ë¥¸ 세션과 %dê°œì˜ ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜" -"ì´ ìžˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 사용하는 %dê°œì˜ ë‹¤ë¥¸ 세션과 %dê°œì˜ ì¤€ë¹„ëœ íŠ¸ëžœìž­ì…˜ì´ ìžˆìŠµë‹ˆë‹¤." #: commands/dbcommands.c:1958 #, c-format @@ -6627,7 +6651,7 @@ msgid "invalid argument for %s: \"%s\"" msgstr "%sì˜ ìž˜ëª»ëœ ì¸ìž: \"%s\"" #: commands/dropcmds.c:112 commands/functioncmds.c:1203 -#: utils/adt/ruleutils.c:2077 +#: utils/adt/ruleutils.c:2080 #, c-format msgid "\"%s\" is an aggregate function" msgstr "\"%s\" 함수는 집계 함수입니다" @@ -6637,19 +6661,19 @@ msgstr "\"%s\" 함수는 집계 함수입니다" msgid "Use DROP AGGREGATE to drop aggregate functions." msgstr "집계 함수는 DROP AGGREGATE 명령으로 삭제할 수 있습니다" -#: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2377 -#: commands/tablecmds.c:2528 commands/tablecmds.c:2570 -#: commands/tablecmds.c:11388 tcop/utility.c:1119 +#: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2378 +#: commands/tablecmds.c:2529 commands/tablecmds.c:2571 +#: commands/tablecmds.c:11524 tcop/utility.c:1119 #, c-format msgid "relation \"%s\" does not exist, skipping" msgstr "\"%s\" 릴레ì´ì…˜ ì—†ìŒ, 건너뜀" -#: commands/dropcmds.c:195 commands/dropcmds.c:296 commands/tablecmds.c:745 +#: commands/dropcmds.c:195 commands/dropcmds.c:296 commands/tablecmds.c:746 #, c-format msgid "schema \"%s\" does not exist, skipping" msgstr "\"%s\" 스키마(schema) ì—†ìŒ, 건너뜀" -#: commands/dropcmds.c:237 commands/dropcmds.c:276 commands/tablecmds.c:246 +#: commands/dropcmds.c:237 commands/dropcmds.c:276 commands/tablecmds.c:247 #, c-format msgid "type \"%s\" does not exist, skipping" msgstr "\"%s\" ìžë£Œí˜• ì—†ìŒ, 건너뜀" @@ -6826,7 +6850,8 @@ msgstr "%s ê°ì²´ëŠ” sql_drop ì´ë²¤íŠ¸ 트리거 함수 안ì—서만 호출 ë˜ #: commands/event_trigger.c:1558 commands/event_trigger.c:1579 #, c-format msgid "%s can only be called in a table_rewrite event trigger function" -msgstr "%s ê°ì²´ëŠ” table_rewrite ì´ë²¤íŠ¸ 트리거 함수 안ì—서만 호출 ë˜ì–´ì•¼ 합니다." +msgstr "" +"%s ê°ì²´ëŠ” table_rewrite ì´ë²¤íŠ¸ 트리거 함수 안ì—서만 호출 ë˜ì–´ì•¼ 합니다." #: commands/event_trigger.c:1989 #, c-format @@ -6853,241 +6878,246 @@ msgstr "BUFFERS ì˜µì…˜ì€ EXPLAIN ANALYZEì—서만 쓸 수 있습니다." msgid "EXPLAIN option TIMING requires ANALYZE" msgstr "TIMING ì˜µì…˜ì€ EXPLAIN ANALYZEì—서만 쓸 수 있습니다." -#: commands/extension.c:154 commands/extension.c:2718 +#: commands/extension.c:155 commands/extension.c:2719 #, c-format msgid "extension \"%s\" does not exist" msgstr "\"%s\" ì´ë¦„ì˜ í™•ìž¥ ëª¨ë“ˆì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/extension.c:253 commands/extension.c:262 commands/extension.c:274 -#: commands/extension.c:284 +#: commands/extension.c:254 commands/extension.c:263 commands/extension.c:275 +#: commands/extension.c:285 #, c-format msgid "invalid extension name: \"%s\"" msgstr "ìž˜ëª»ëœ í™•ìž¥ 모듈 ì´ë¦„: \"%s\"" -#: commands/extension.c:254 +#: commands/extension.c:255 #, c-format msgid "Extension names must not be empty." msgstr "확장 모듈 ì´ë¦„ì„ ì§€ì •í•˜ì„¸ìš”." -#: commands/extension.c:263 +#: commands/extension.c:264 #, c-format msgid "Extension names must not contain \"--\"." msgstr "확장 모듈 ì´ë¦„ì— \"--\" 문ìžê°€ í¬í•¨ë  수 없습니다." -#: commands/extension.c:275 +#: commands/extension.c:276 #, c-format msgid "Extension names must not begin or end with \"-\"." msgstr "확장 모듈 ì´ë¦„ì˜ ì‹œìž‘ê³¼ ëì—는 \"-\" 문ìžë¥¼ 사용할 수 없습니다." -#: commands/extension.c:285 +#: commands/extension.c:286 #, c-format msgid "Extension names must not contain directory separator characters." msgstr "확장 모듈 ì´ë¦„ì—는 디렉터리 구분 문ìžë¥¼ 사용할 수 없습니다." -#: commands/extension.c:300 commands/extension.c:309 commands/extension.c:318 -#: commands/extension.c:328 +#: commands/extension.c:301 commands/extension.c:310 commands/extension.c:319 +#: commands/extension.c:329 #, c-format msgid "invalid extension version name: \"%s\"" msgstr "ìž˜ëª»ëœ í™•ìž¥ 모듈 버전 ì´ë¦„: \"%s\"" -#: commands/extension.c:301 +#: commands/extension.c:302 #, c-format msgid "Version names must not be empty." msgstr "버전 ì´ë¦„ì€ ë¹„ì–´ìžˆìœ¼ë©´ 안ë©ë‹ˆë‹¤" -#: commands/extension.c:310 +#: commands/extension.c:311 #, c-format msgid "Version names must not contain \"--\"." msgstr "버전 ì´ë¦„ì— \"--\" 문ìžê°€ í¬í•¨ë  수 없습니다." -#: commands/extension.c:319 +#: commands/extension.c:320 #, c-format msgid "Version names must not begin or end with \"-\"." msgstr "버전 ì´ë¦„ì˜ ì•ž ë’¤ì— \"-\" 문ìžë¥¼ 쓸 수 없습니다." -#: commands/extension.c:329 +#: commands/extension.c:330 #, c-format msgid "Version names must not contain directory separator characters." msgstr "버전 ì´ë¦„ì—는 디렉터리 분리 문ìžë¥¼ 쓸 수 없습니다." -#: commands/extension.c:479 +#: commands/extension.c:480 #, c-format msgid "could not open extension control file \"%s\": %m" msgstr "\"%s\" 확장 모듈 제어 íŒŒì¼ ì—´ê¸° 실패: %m" -#: commands/extension.c:501 commands/extension.c:511 +#: commands/extension.c:502 commands/extension.c:512 #, c-format msgid "parameter \"%s\" cannot be set in a secondary extension control file" msgstr "\"%s\" 매개 변수는 ì´ì°¨ 확장 모듈 제어 파ì¼ì—서는 사용할 수 없습니다." -#: commands/extension.c:550 +#: commands/extension.c:551 #, c-format msgid "\"%s\" is not a valid encoding name" msgstr "\"%s\" ì´ë¦„ì€ ìž˜ëª»ëœ ì¸ì½”딩 ì´ë¦„ìž„" -#: commands/extension.c:564 +#: commands/extension.c:565 #, c-format msgid "parameter \"%s\" must be a list of extension names" msgstr "\"%s\" 매개 변수는 확장 모듈 ì´ë¦„ 목ë¡ì´ì–´ì•¼ 함" -#: commands/extension.c:571 +#: commands/extension.c:572 #, c-format msgid "unrecognized parameter \"%s\" in file \"%s\"" msgstr "ì•Œ 수 없는 \"%s\" 매개 변수가 \"%s\" íŒŒì¼ ì•ˆì— ìžˆìŠµë‹ˆë‹¤." -#: commands/extension.c:580 +#: commands/extension.c:581 #, c-format msgid "parameter \"schema\" cannot be specified when \"relocatable\" is true" -msgstr "\"relocatable\" ê°’ì´ true ì¸ ê²½ìš° \"schema\" 매개 변수는 사용할 수 없습니다." +msgstr "" +"\"relocatable\" ê°’ì´ true ì¸ ê²½ìš° \"schema\" 매개 변수는 사용할 수 없습니다." -#: commands/extension.c:721 +#: commands/extension.c:722 #, c-format msgid "" "transaction control statements are not allowed within an extension script" msgstr "확장 모듈 스í¬ë¦½íŠ¸ 안ì—서는 트랜잭션 제어 êµ¬ë¬¸ì€ ì‚¬ìš©í•  수 없습니다." -#: commands/extension.c:789 +#: commands/extension.c:790 #, c-format msgid "permission denied to create extension \"%s\"" msgstr "\"%s\" 확장 ëª¨ë“ˆì„ ë§Œë“¤ ê¶Œí•œì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/extension.c:791 +#: commands/extension.c:792 #, c-format msgid "Must be superuser to create this extension." msgstr "확장 ëª¨ë“ˆì€ ìŠˆí¼ìœ ì €ë§Œ 만들 수 있습니다." -#: commands/extension.c:795 +#: commands/extension.c:796 #, c-format msgid "permission denied to update extension \"%s\"" msgstr "\"%s\" 확장 ëª¨ë“ˆì„ ì—…ë°ì´íŠ¸í•  ê¶Œí•œì´ ì—†ìŠµë‹ˆë‹¤." -#: commands/extension.c:797 +#: commands/extension.c:798 #, c-format msgid "Must be superuser to update this extension." msgstr "슈í¼ìœ ì €ë§Œ 해당 ëª¨ë“ˆì„ ì—…ë°ì´íŠ¸ í•  수 있습니다." -#: commands/extension.c:1079 +#: commands/extension.c:1080 #, c-format msgid "" "extension \"%s\" has no update path from version \"%s\" to version \"%s\"" -msgstr "\"%s\" 확장 ëª¨ë“ˆì„ \"%s\" 버전ì—ì„œ \"%s\" 버전으로 ì—…ë°ì´íŠ¸í•  ë°©ë²•ì´ ì—†ìŠµë‹ˆë‹¤." +msgstr "" +"\"%s\" 확장 ëª¨ë“ˆì„ \"%s\" 버전ì—ì„œ \"%s\" 버전으로 ì—…ë°ì´íŠ¸í•  ë°©ë²•ì´ ì—†ìŠµë‹ˆ" +"다." -#: commands/extension.c:1261 commands/extension.c:2778 +#: commands/extension.c:1262 commands/extension.c:2779 #, c-format msgid "version to install must be specified" msgstr "설치할 ë²„ì „ì„ ì§€ì •í•´ì•¼ 합니다." -#: commands/extension.c:1278 +#: commands/extension.c:1279 #, c-format msgid "FROM version must be different from installation target version \"%s\"" msgstr "FROM ì ˆì— ì§€ì •í•œ ë²„ì „ì€ ì„¤ì¹˜ëœ \"%s\" 버전과 달ë¼ì•¼ 합니다" -#: commands/extension.c:1343 +#: commands/extension.c:1344 #, c-format msgid "extension \"%s\" must be installed in schema \"%s\"" msgstr "\"%s\" 확장 ëª¨ë“ˆì€ \"%s\" 스키마 ì•ˆì— ì„¤ì¹˜ë˜ì–´ì•¼ 합니다." -#: commands/extension.c:1435 +#: commands/extension.c:1436 #, c-format msgid "cyclic dependency detected between extensions \"%s\" and \"%s\"" msgstr "\"%s\" 확장 모듈과 \"%s\" 확장 ëª¨ë“ˆì´ ì„œë¡œ ì˜ì¡´ 관계입니다" -#: commands/extension.c:1440 +#: commands/extension.c:1441 #, c-format msgid "installing required extension \"%s\"" msgstr "\"%s\" 확장 ëª¨ë“ˆì´ í•„ìš”í•´ì„œ 실치 하는 중" -#: commands/extension.c:1468 commands/extension.c:2923 +#: commands/extension.c:1469 commands/extension.c:2924 #, c-format msgid "required extension \"%s\" is not installed" msgstr "\"%s\" 확장 ëª¨ë“ˆì´ í•„ìš”í•œë°, 설치ë˜ì–´ 있지 않습니다." -#: commands/extension.c:1470 +#: commands/extension.c:1471 #, c-format msgid "Use CREATE EXTENSION ... CASCADE to install required extensions too." -msgstr "필요한 ëª¨ë“ˆì„ í•¨ê»˜ 설치하려면, CREATE EXTENSION ... CASCADE êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ì„¸ìš”." +msgstr "" +"필요한 ëª¨ë“ˆì„ í•¨ê»˜ 설치하려면, CREATE EXTENSION ... CASCADE êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ì„¸" +"ìš”." -#: commands/extension.c:1534 +#: commands/extension.c:1535 #, c-format msgid "extension \"%s\" already exists, skipping" msgstr "\"%s\" 확장 ëª¨ë“ˆì´ ì´ë¯¸ 있ìŒ, 건너뜀" -#: commands/extension.c:1541 +#: commands/extension.c:1542 #, c-format msgid "extension \"%s\" already exists" msgstr "\"%s\" ì´ë¦„ì˜ í™•ìž¥ ëª¨ë“ˆì´ ì´ë¯¸ 있습니다" -#: commands/extension.c:1552 +#: commands/extension.c:1553 #, c-format msgid "nested CREATE EXTENSION is not supported" msgstr "ì¤‘ì²©ëœ CREATE EXTENSION êµ¬ë¬¸ì€ ì§€ì›í•˜ì§€ 않습니다." -#: commands/extension.c:1680 +#: commands/extension.c:1681 #, c-format msgid "cannot drop extension \"%s\" because it is being modified" msgstr "%s ì˜ì¡´ê°ì²´ë“¤ì€ 시스템 ê°ì²´ì´ê¸° ë•Œë¬¸ì— ì‚­ì œ ë  ìˆ˜ 없습니다" -#: commands/extension.c:2151 +#: commands/extension.c:2152 #, c-format msgid "" "pg_extension_config_dump() can only be called from an SQL script executed by " "CREATE EXTENSION" msgstr "" -"pg_extension_config_dump() 함수는 CREATE EXTENSION 명령ì—ì„œ 내부ì ìœ¼ë¡œ 사용하는 " -"SQL 스í¬ë¦½íŠ¸ ë‚´ì—서만 사용할 수 있습니다." +"pg_extension_config_dump() 함수는 CREATE EXTENSION 명령ì—ì„œ 내부ì ìœ¼ë¡œ 사용하" +"는 SQL 스í¬ë¦½íŠ¸ ë‚´ì—서만 사용할 수 있습니다." -#: commands/extension.c:2163 +#: commands/extension.c:2164 #, c-format msgid "OID %u does not refer to a table" msgstr "%u OID ìžë£Œê°€ í…Œì´ë¸”ì— ì—†ìŠµë‹ˆë‹¤" -#: commands/extension.c:2168 +#: commands/extension.c:2169 #, c-format msgid "table \"%s\" is not a member of the extension being created" msgstr "\"%s\" í…Œì´ë¸”ì€ ë§Œë“¤ë ¤ê³  하는 확장 ëª¨ë“ˆì˜ êµ¬ì„± 요소가 아닙니다." -#: commands/extension.c:2533 +#: commands/extension.c:2534 #, c-format msgid "" "cannot move extension \"%s\" into schema \"%s\" because the extension " "contains the schema" -msgstr "" -"\"%s\" 확장 ëª¨ë“ˆì´ \"%s\" ìŠ¤í‚¤ë§ˆì— ì´ë¯¸ 있어 옮길 수 없습니다." +msgstr "\"%s\" 확장 ëª¨ë“ˆì´ \"%s\" ìŠ¤í‚¤ë§ˆì— ì´ë¯¸ 있어 옮길 수 없습니다." -#: commands/extension.c:2573 commands/extension.c:2636 +#: commands/extension.c:2574 commands/extension.c:2637 #, c-format msgid "extension \"%s\" does not support SET SCHEMA" msgstr "\"%s\" 확장 ëª¨ë“ˆì€ SET SCHEMA êµ¬ë¬¸ì„ ì§€ì›í•˜ì§€ ì•ŠìŒ" -#: commands/extension.c:2638 +#: commands/extension.c:2639 #, c-format msgid "%s is not in the extension's schema \"%s\"" msgstr "%s ê°ì²´ê°€ 확장 모듈 ìŠ¤í‚¤ë§ˆì¸ \"%s\" ì•ˆì— ì—†ìŒ" -#: commands/extension.c:2698 +#: commands/extension.c:2699 #, c-format msgid "nested ALTER EXTENSION is not supported" msgstr "ì¤‘ì²©ëœ ALTER EXTENSION êµ¬ë¬¸ì„ ì§€ì›í•˜ì§€ ì•ŠìŒ" -#: commands/extension.c:2789 +#: commands/extension.c:2790 #, c-format msgid "version \"%s\" of extension \"%s\" is already installed" msgstr "\"%s\" ë²„ì „ì˜ \"%s\" 확장 ëª¨ë“ˆì´ ì´ë¯¸ 설치 ë˜ì–´ 있ìŒ" -#: commands/extension.c:3040 +#: commands/extension.c:3041 #, c-format msgid "" "cannot add schema \"%s\" to extension \"%s\" because the schema contains the " "extension" msgstr "" -"\"%s\" ìŠ¤í‚¤ë§ˆì— \"%s\" 확장 ëª¨ë“ˆì„ ì¶”ê°€í•  수 ì—†ìŒ, ì´ë¯¸ 해당 스키마 ì•ˆì— í¬í•¨ë˜ì–´ 있ìŒ" +"\"%s\" ìŠ¤í‚¤ë§ˆì— \"%s\" 확장 ëª¨ë“ˆì„ ì¶”ê°€í•  수 ì—†ìŒ, ì´ë¯¸ 해당 스키마 ì•ˆì— í¬" +"함ë˜ì–´ 있ìŒ" -#: commands/extension.c:3058 +#: commands/extension.c:3069 #, c-format msgid "%s is not a member of extension \"%s\"" msgstr "\"%s\" ê°ì²´ëŠ” \"%s\" 확장 ëª¨ë“ˆì˜ êµ¬ì„± 요소가 아닙니다" -#: commands/extension.c:3114 +#: commands/extension.c:3135 #, c-format msgid "file \"%s\" is too large" msgstr "\"%s\" 파ì¼ì´ 너무 í½ë‹ˆë‹¤." @@ -7148,7 +7178,8 @@ msgid "" "changing the foreign-data wrapper handler can change behavior of existing " "foreign tables" msgstr "" -"외부 ìžë£Œ ëž©í¼ í•¸ë“¤ëŸ¬ë¥¼ 바꾸면, ê·¸ê²ƒì„ ì‚¬ìš©í•˜ëŠ” 외부 í…Œì´ë¸”ì˜ ë‚´ìš©ì´ ë°”ë€” 수 있습니다." +"외부 ìžë£Œ ëž©í¼ í•¸ë“¤ëŸ¬ë¥¼ 바꾸면, ê·¸ê²ƒì„ ì‚¬ìš©í•˜ëŠ” 외부 í…Œì´ë¸”ì˜ ë‚´ìš©ì´ ë°”ë€” 수 " +"있습니다." #: commands/foreigncmds.c:747 #, c-format @@ -7156,8 +7187,8 @@ msgid "" "changing the foreign-data wrapper validator can cause the options for " "dependent objects to become invalid" msgstr "" -"외부 ìžë£Œ ëž˜í¼ ìœ íš¨ì„± 검사기를 바꾸면 ì¢…ì† ê°ì²´ì— 대한 ì˜µì…˜ì´ ìœ " -"효하지 ì•Šì„ ìˆ˜ 있ìŒ" +"외부 ìžë£Œ ëž˜í¼ ìœ íš¨ì„± 검사기를 바꾸면 ì¢…ì† ê°ì²´ì— 대한 ì˜µì…˜ì´ ìœ íš¨í•˜ì§€ ì•Šì„ " +"수 있ìŒ" #: commands/foreigncmds.c:1165 #, c-format @@ -7375,8 +7406,8 @@ msgid "" "argument of cast function must match or be binary-coercible from source data " "type" msgstr "" -"형변환 í•¨ìˆ˜ì˜ ì¸ìžë¡œ 쓸 ìžë£Œí˜•ì€ ì›ë³¸ ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ê±°ë‚˜ " -"ë°”ì´ë„ˆë¦¬ ì°¨ì›ìœ¼ë¡œ ê°™ì€ ìžë£Œí˜•ì´ì–´ì•¼ 함" +"형변환 í•¨ìˆ˜ì˜ ì¸ìžë¡œ 쓸 ìžë£Œí˜•ì€ ì›ë³¸ ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ê±°ë‚˜ ë°”ì´ë„ˆë¦¬ ì°¨ì›ìœ¼ë¡œ " +"ê°™ì€ ìžë£Œí˜•ì´ì–´ì•¼ 함" #: commands/functioncmds.c:1482 #, c-format @@ -7394,8 +7425,8 @@ msgid "" "return data type of cast function must match or be binary-coercible to " "target data type" msgstr "" -"형변환 í•¨ìˆ˜ì˜ ë°˜í™˜ ìžë£Œí˜•ì€ ëŒ€ìƒ ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ê±°ë‚˜ " -"ë°”ì´ë„ˆë¦¬ ì°¨ì›ìœ¼ë¡œ ê°™ì€ ìžë£Œí˜•ì´ì–´ì•¼ 함" +"형변환 í•¨ìˆ˜ì˜ ë°˜í™˜ ìžë£Œí˜•ì€ ëŒ€ìƒ ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ê±°ë‚˜ ë°”ì´ë„ˆë¦¬ ì°¨ì›ìœ¼ë¡œ ê°™ì€ " +"ìžë£Œí˜•ì´ì–´ì•¼ 함" #: commands/functioncmds.c:1501 #, c-format @@ -7505,14 +7536,12 @@ msgstr "%s ìžë£Œí˜•ì€ ë„ë©”ì¸ìž…니다" #: commands/functioncmds.c:1859 #, c-format msgid "return data type of FROM SQL function must be \"internal\"" -msgstr "" -"FROM SQL í•¨ìˆ˜ì˜ ë°˜í™˜ ìžë£Œí˜•ì€ \"internal\" ì´ì–´ì•¼ 함" +msgstr "FROM SQL í•¨ìˆ˜ì˜ ë°˜í™˜ ìžë£Œí˜•ì€ \"internal\" ì´ì–´ì•¼ 함" #: commands/functioncmds.c:1884 #, c-format msgid "return data type of TO SQL function must be the transform data type" -msgstr "" -"TO SQL í•¨ìˆ˜ì˜ ë°˜í™˜ ìžë£Œí˜•ì€ 변환 ìžë£Œí˜•ì´ì–´ì•¼ 함" +msgstr "TO SQL í•¨ìˆ˜ì˜ ë°˜í™˜ ìžë£Œí˜•ì€ 변환 ìžë£Œí˜•ì´ì–´ì•¼ 함" #: commands/functioncmds.c:1911 #, c-format @@ -7559,89 +7588,91 @@ msgstr "\"%s\" 외부 í…Œì´ë¸” 대ìƒìœ¼ë¡œ ì¸ë±ìŠ¤ë¥¼ 만들 수 ì—†ìŒ" msgid "cannot create indexes on temporary tables of other sessions" msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸”ì— ì¸ë±ìŠ¤ë¥¼ 만들 수는 없습니다" -#: commands/indexcmds.c:454 commands/tablecmds.c:545 commands/tablecmds.c:9597 +#: commands/indexcmds.c:455 commands/tablecmds.c:546 commands/tablecmds.c:9694 #, c-format msgid "only shared relations can be placed in pg_global tablespace" msgstr "공유 관계만 pg_global í…Œì´ë¸”스페ì´ìŠ¤ì— 배치할 수 있ìŒ" -#: commands/indexcmds.c:487 +#: commands/indexcmds.c:488 #, c-format msgid "substituting access method \"gist\" for obsolete method \"rtree\"" msgstr "사용하지 않는 \"rtree\" ë°©ë²•ì„ \"gist\" 액세스 방법으로 대체하는 중" -#: commands/indexcmds.c:505 +#: commands/indexcmds.c:506 #, c-format msgid "hash indexes are not WAL-logged and their use is discouraged" msgstr "hash ì¸ë±ìŠ¤ëŠ” WAL 기ë¡ì„ 하지 않습니다. ì´ ì‚¬ìš©ì€ ê¶Œìž¥í•˜ì§€ 않습니다" -#: commands/indexcmds.c:510 +#: commands/indexcmds.c:511 #, c-format msgid "access method \"%s\" does not support unique indexes" msgstr "\"%s\" ì¸ë±ìŠ¤ 액세스 ë°©ë²•ì€ ê³ ìœ  ì¸ë±ìŠ¤ë¥¼ 지ì›í•˜ì§€ 않습니다" -#: commands/indexcmds.c:515 +#: commands/indexcmds.c:516 #, c-format msgid "access method \"%s\" does not support multicolumn indexes" msgstr "\"%s\" ì¸ë±ìŠ¤ 액세스 ë°©ë²•ì€ ë‹¤ì¤‘ ì—´ ì¸ë±ìŠ¤ë¥¼ 지ì›í•˜ì§€ 않습니다" -#: commands/indexcmds.c:520 +#: commands/indexcmds.c:521 #, c-format msgid "access method \"%s\" does not support exclusion constraints" msgstr "\"%s\" ì¸ë±ìŠ¤ ì ‘ê·¼ ë°©ë²•ì€ exclusion 제약 ì¡°ê±´ì„ ì§€ì›í•˜ì§€ 않습니다" -#: commands/indexcmds.c:590 commands/indexcmds.c:610 +#: commands/indexcmds.c:591 commands/indexcmds.c:611 #, c-format msgid "index creation on system columns is not supported" msgstr "시스템 카탈로그 í…Œì´ë¸”ì— ëŒ€í•œ ì¸ë±ìŠ¤ 만들기는 지ì›í•˜ì§€ 않습니다" -#: commands/indexcmds.c:635 +#: commands/indexcmds.c:636 #, c-format msgid "%s %s will create implicit index \"%s\" for table \"%s\"" msgstr "%s %s 명령으로 \"%s\" ì¸ë±ìŠ¤ë¥¼ \"%s\" í…Œì´ë¸”ì— ìžë™ìœ¼ë¡œ 만들었ìŒ" -#: commands/indexcmds.c:982 +#: commands/indexcmds.c:983 #, c-format msgid "functions in index predicate must be marked IMMUTABLE" msgstr "" "ì¸ë±ìŠ¤ 술어(predicate)ì—ì„œ 사용하는 함수는 IMMUTABLE íŠ¹ì„±ì´ ìžˆì–´ì•¼í•©ë‹ˆë‹¤" -#: commands/indexcmds.c:1048 parser/parse_utilcmd.c:1896 +#: commands/indexcmds.c:1049 parser/parse_utilcmd.c:1881 #, c-format msgid "column \"%s\" named in key does not exist" msgstr "키ì—ì„œ 지정한 \"%s\" ì—´ì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/indexcmds.c:1108 +#: commands/indexcmds.c:1109 #, c-format msgid "functions in index expression must be marked IMMUTABLE" msgstr "ì¸ë±ìŠ¤ ì‹(expression)ì— ì‚¬ìš©í•˜ëŠ” 함수는 IMMUTABLE íŠ¹ì„±ì´ ìžˆì–´ì•¼í•©ë‹ˆë‹¤" -#: commands/indexcmds.c:1131 +#: commands/indexcmds.c:1132 #, c-format msgid "could not determine which collation to use for index expression" msgstr "해당 ì¸ë±ìŠ¤ì—ì„œ 사용할 정렬규칙(collation)ì„ ê²°ì •í•  수 없습니다." -#: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2608 -#: parser/parse_type.c:550 parser/parse_utilcmd.c:2822 utils/adt/misc.c:666 +#: commands/indexcmds.c:1140 commands/typecmds.c:827 parser/parse_expr.c:2608 +#: parser/parse_type.c:550 parser/parse_utilcmd.c:2807 utils/adt/misc.c:666 #, c-format msgid "collations are not supported by type %s" msgstr "%s ìžë£Œí˜•ì€ collation ì§€ì› ì•ˆí•¨" -#: commands/indexcmds.c:1177 +#: commands/indexcmds.c:1178 #, c-format msgid "operator %s is not commutative" msgstr "%s ì—°ì‚°ìžëŠ” êµí™˜ë²•ì¹™ì´ 성립하지 않습니다" -#: commands/indexcmds.c:1179 +#: commands/indexcmds.c:1180 #, c-format msgid "Only commutative operators can be used in exclusion constraints." -msgstr "exclude 제약조건용 ì¸ë±ìŠ¤ë¥¼ 만들 때는 êµí™˜ë²•ì¹™ì´ 성립하는 ì—°ì‚°ìžë§Œ 사용할 수 있습니다." +msgstr "" +"exclude 제약조건용 ì¸ë±ìŠ¤ë¥¼ 만들 때는 êµí™˜ë²•ì¹™ì´ 성립하는 ì—°ì‚°ìžë§Œ 사용할 수 " +"있습니다." -#: commands/indexcmds.c:1205 +#: commands/indexcmds.c:1206 #, c-format msgid "operator %s is not a member of operator family \"%s\"" msgstr "%s ì—°ì‚°ìžëŠ” \"%s\" ì—°ì‚°ìž ê°€ì¡± 구성ì›ì´ 아닙니다." -#: commands/indexcmds.c:1208 +#: commands/indexcmds.c:1209 #, c-format msgid "" "The exclusion operator must be related to the index operator class for the " @@ -7649,24 +7680,24 @@ msgid "" msgstr "" "제외 ì—°ì‚°ìžëŠ” 해당 제약 ì¡°ê±´ìš© ì¸ë±ìŠ¤ ì—°ì‚°ìž í´ëž˜ìŠ¤ì˜ 소ì†ì´ì–´ì•¼ 합니다." -#: commands/indexcmds.c:1243 +#: commands/indexcmds.c:1244 #, c-format msgid "access method \"%s\" does not support ASC/DESC options" msgstr "\"%s\" ì ‘ê·¼ ë°©ë²•ì€ ASC/DESC ì˜µì…˜ì„ ì§€ì›í•˜ì§€ ì•ŠìŒ" -#: commands/indexcmds.c:1248 +#: commands/indexcmds.c:1249 #, c-format msgid "access method \"%s\" does not support NULLS FIRST/LAST options" msgstr "\"%s\" ì ‘ê·¼ ë°©ë²•ì€ NULLS FIRST/LAST ì˜µì…˜ì„ ì§€ì›í•˜ì§€ ì•ŠìŒ" -#: commands/indexcmds.c:1304 commands/typecmds.c:1935 +#: commands/indexcmds.c:1305 commands/typecmds.c:1935 #, c-format msgid "data type %s has no default operator class for access method \"%s\"" msgstr "" "%s ìžë£Œí˜•ì€ \"%s\" ì¸ë±ìŠ¤ 액세스 ë°©ë²•ì„ ìœ„í•œ 기본 ì—°ì‚°ìž í´ëž˜ìŠ¤(operator " "class)ê°€ 없습니다. " -#: commands/indexcmds.c:1306 +#: commands/indexcmds.c:1307 #, c-format msgid "" "You must specify an operator class for the index or define a default " @@ -7675,34 +7706,34 @@ msgstr "" "ì´ ì¸ë±ìŠ¤ë¥¼ 위한 ì—°ì‚°ìž í´ëž˜ìŠ¤ë¥¼ 지정하거나 먼저 ì´ ìžë£Œí˜•ì„ 위한 기본 ì—°ì‚°" "ìž í´ëž˜ìŠ¤ë¥¼ ì •ì˜í•´ ë‘어야합니다" -#: commands/indexcmds.c:1335 commands/indexcmds.c:1343 +#: commands/indexcmds.c:1336 commands/indexcmds.c:1344 #: commands/opclasscmds.c:205 #, c-format msgid "operator class \"%s\" does not exist for access method \"%s\"" msgstr "" "\"%s\" ì—°ì‚°ìž í´ëž˜ìŠ¤ëŠ” \"%s\" ì¸ë±ìŠ¤ 액세스 방법ì—ì„œ 사용할 수 없습니다" -#: commands/indexcmds.c:1356 commands/typecmds.c:1923 +#: commands/indexcmds.c:1357 commands/typecmds.c:1923 #, c-format msgid "operator class \"%s\" does not accept data type %s" msgstr "\"%s\" ì—°ì‚°ìž í´ëž˜ìŠ¤ëŠ” %s ìžë£Œí˜•ì„ 사용할 수 없습니다" -#: commands/indexcmds.c:1446 +#: commands/indexcmds.c:1447 #, c-format msgid "there are multiple default operator classes for data type %s" msgstr "%s ìžë£Œí˜•ì„ 위한 기본 ì—°ì‚°ìž í´ëž˜ìŠ¤ê°€ 여러개 있습니다" -#: commands/indexcmds.c:1837 +#: commands/indexcmds.c:1838 #, c-format msgid "table \"%s\" has no indexes" msgstr "\"%s\" í…Œì´ë¸”ì—는 사용할 수 있는 ì¸ë±ìŠ¤ê°€ 없습니다" -#: commands/indexcmds.c:1892 +#: commands/indexcmds.c:1893 #, c-format msgid "can only reindex the currently open database" msgstr "열려있는 현재 ë°ì´í„°ë² ì´ìŠ¤ì—서만 reindex ëª…ë ¹ì„ ì‚¬ìš©í•  수 있습니다" -#: commands/indexcmds.c:1992 +#: commands/indexcmds.c:1993 #, c-format msgid "table \"%s.%s\" was reindexed" msgstr "\"%s.%s\" í…Œì´ë¸”ì˜ ì¸ë±ìŠ¤ë“¤ì„ 다시 만들었습니다." @@ -7710,7 +7741,9 @@ msgstr "\"%s.%s\" í…Œì´ë¸”ì˜ ì¸ë±ìŠ¤ë“¤ì„ 다시 만들었습니다." #: commands/matview.c:181 #, c-format msgid "CONCURRENTLY cannot be used when the materialized view is not populated" -msgstr "êµ¬ì²´í™”ëœ ë·°ì˜ ìžë£Œê°€ 정리ë˜ê³  ìžˆì„ ë•ŒëŠ” CONCURRENTLY ì˜µì…˜ì„ ì‚¬ìš©í•  수 없습니다." +msgstr "" +"êµ¬ì²´í™”ëœ ë·°ì˜ ìžë£Œê°€ 정리ë˜ê³  ìžˆì„ ë•ŒëŠ” CONCURRENTLY ì˜µì…˜ì„ ì‚¬ìš©í•  수 없습니" +"다." #: commands/matview.c:187 #, c-format @@ -7728,7 +7761,8 @@ msgid "" "Create a unique index with no WHERE clause on one or more columns of the " "materialized view." msgstr "" -"êµ¬ì²´í™”ëœ ë·°ì˜ í•˜ë‚˜ ë˜ëŠ” 하나 ì´ìƒì˜ ì¹¼ëŸ¼ì— ëŒ€í•œ WHERE ì ˆ 없는 고유 ì¸ë±ìŠ¤ë¥¼ 만드세요." +"êµ¬ì²´í™”ëœ ë·°ì˜ í•˜ë‚˜ ë˜ëŠ” 하나 ì´ìƒì˜ ì¹¼ëŸ¼ì— ëŒ€í•œ WHERE ì ˆ 없는 고유 ì¸ë±ìŠ¤ë¥¼ " +"만드세요." #: commands/matview.c:657 #, c-format @@ -7736,7 +7770,8 @@ msgid "" "new data for materialized view \"%s\" contains duplicate rows without any " "null columns" msgstr "" -"\"%s\" êµ¬ì²´í™”ëœ ë·°ì˜ ìƒˆ ìžë£Œì— 아무런 null 칼럼 ì—†ì´ ì¤‘ë³µëœ ë¡œìš°ë¥¼ í¬í•¨í•˜ê³  있습니다" +"\"%s\" êµ¬ì²´í™”ëœ ë·°ì˜ ìƒˆ ìžë£Œì— 아무런 null 칼럼 ì—†ì´ ì¤‘ë³µëœ ë¡œìš°ë¥¼ í¬í•¨í•˜ê³  " +"있습니다" #: commands/matview.c:659 #, c-format @@ -7849,7 +7884,8 @@ msgstr "btree ë¹„êµ í”„ë¡œì‹œì €ëŠ” 반드시 integer ìžë£Œí˜•ì„ 반환해야 #: commands/opclasscmds.c:1185 #, c-format msgid "btree sort support procedures must accept type \"internal\"" -msgstr "btree ì •ë ¬ ì§€ì› í”„ë¡œì‹œì €ëŠ” 반드시 \"internal\" ìžë£Œí˜• ìž…ë ¥ ì¸ìžë¡œ 사용해야함" +msgstr "" +"btree ì •ë ¬ ì§€ì› í”„ë¡œì‹œì €ëŠ” 반드시 \"internal\" ìžë£Œí˜• ìž…ë ¥ ì¸ìžë¡œ 사용해야함" #: commands/opclasscmds.c:1189 #, c-format @@ -7915,8 +7951,7 @@ msgstr "" msgid "" "operator family \"%s\" for access method \"%s\" already exists in schema \"%s" "\"" -msgstr "" -"\"%s\" ì—°ì‚°ìž íŒ¨ë°€ë¦¬(ì ‘ê·¼ 방법: \"%s\")ê°€ \"%s\" ìŠ¤í‚¤ë§ˆì— ì´ë¯¸ 있ìŒ" +msgstr "\"%s\" ì—°ì‚°ìž íŒ¨ë°€ë¦¬(ì ‘ê·¼ 방법: \"%s\")ê°€ \"%s\" ìŠ¤í‚¤ë§ˆì— ì´ë¯¸ 있ìŒ" #: commands/operatorcmds.c:114 commands/operatorcmds.c:122 #, c-format @@ -7954,10 +7989,10 @@ msgid "operator attribute \"%s\" cannot be changed" msgstr "\"%s\" ì—°ì‚°ìž ì†ì„± 바꿀 수 ì—†ìŒ" #: commands/policy.c:87 commands/policy.c:388 commands/policy.c:477 -#: commands/tablecmds.c:970 commands/tablecmds.c:1312 -#: commands/tablecmds.c:2184 commands/tablecmds.c:4328 -#: commands/tablecmds.c:6279 commands/tablecmds.c:11944 -#: commands/tablecmds.c:11979 commands/trigger.c:241 commands/trigger.c:1125 +#: commands/tablecmds.c:971 commands/tablecmds.c:1313 +#: commands/tablecmds.c:2185 commands/tablecmds.c:4329 +#: commands/tablecmds.c:6280 commands/tablecmds.c:12080 +#: commands/tablecmds.c:12115 commands/trigger.c:241 commands/trigger.c:1125 #: commands/trigger.c:1233 rewrite/rewriteDefine.c:273 #: rewrite/rewriteDefine.c:917 #, c-format @@ -8119,8 +8154,7 @@ msgstr "ë¡œë“œëœ ë³´ì•ˆ ë¼ë²¨ 제공ìžê°€ ì—†ìŒ" #, c-format msgid "" "must specify provider when multiple security label providers have been loaded" -msgstr "" -"다중 보안 ë ˆì´ë¸” 제공ìžê°€ 로드 ë  ë•Œ 제공ìžë¥¼ 지정해야 합니다." +msgstr "다중 보안 ë ˆì´ë¸” 제공ìžê°€ 로드 ë  ë•Œ 제공ìžë¥¼ 지정해야 합니다." #: commands/seclabel.c:82 #, c-format @@ -8217,162 +8251,162 @@ msgstr "시퀀스 ë° ì´ ì‹œí€€ìŠ¤ê°€ ì—°ê²°ëœ í…Œì´ë¸”ì˜ ì†Œìœ ì£¼ê°€ ê°™ msgid "sequence must be in same schema as table it is linked to" msgstr "시퀀스 ë° ì´ ì‹œí€€ìŠ¤ê°€ ì—°ê²°ëœ í…Œì´ë¸”ì´ ê°™ì€ ìŠ¤í‚¤ë§ˆì— ìžˆì–´ì•¼ 함" -#: commands/tablecmds.c:215 +#: commands/tablecmds.c:216 #, c-format msgid "table \"%s\" does not exist" msgstr "\"%s\" í…Œì´ë¸” ì—†ìŒ" -#: commands/tablecmds.c:216 +#: commands/tablecmds.c:217 #, c-format msgid "table \"%s\" does not exist, skipping" msgstr "\"%s\" í…Œì´ë¸” ì—†ìŒ, 무시함" -#: commands/tablecmds.c:218 +#: commands/tablecmds.c:219 msgid "Use DROP TABLE to remove a table." msgstr "í…Œì´ë¸”ì„ ì‚­ì œí•˜ë ¤ë©´, DROP TABLE ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: commands/tablecmds.c:221 +#: commands/tablecmds.c:222 #, c-format msgid "sequence \"%s\" does not exist" msgstr "\"%s\" 시퀀스 ì—†ìŒ" -#: commands/tablecmds.c:222 +#: commands/tablecmds.c:223 #, c-format msgid "sequence \"%s\" does not exist, skipping" msgstr "\"%s\" 시퀀스 ì—†ìŒ, 무시함" -#: commands/tablecmds.c:224 +#: commands/tablecmds.c:225 msgid "Use DROP SEQUENCE to remove a sequence." msgstr "시퀀스를 삭제하려면 DROP SEQUENCE ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: commands/tablecmds.c:227 +#: commands/tablecmds.c:228 #, c-format msgid "view \"%s\" does not exist" msgstr "\"%s\" ë·°(view) ì—†ìŒ" -#: commands/tablecmds.c:228 +#: commands/tablecmds.c:229 #, c-format msgid "view \"%s\" does not exist, skipping" msgstr "\"%s\" ë·°(view) ì—†ìŒ, 무시함" -#: commands/tablecmds.c:230 +#: commands/tablecmds.c:231 msgid "Use DROP VIEW to remove a view." msgstr "뷰를 삭제하려면, DROP VIEW ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: commands/tablecmds.c:233 +#: commands/tablecmds.c:234 #, c-format msgid "materialized view \"%s\" does not exist" msgstr "\"%s\" ì´ë¦„ì˜ êµ¬ì²´í™”ëœ ë·°ê°€ ì—†ìŒ" -#: commands/tablecmds.c:234 +#: commands/tablecmds.c:235 #, c-format msgid "materialized view \"%s\" does not exist, skipping" msgstr "\"%s\" êµ¬ì²´í™”ëœ ë·° ì—†ìŒ, 건너뜀" -#: commands/tablecmds.c:236 +#: commands/tablecmds.c:237 msgid "Use DROP MATERIALIZED VIEW to remove a materialized view." msgstr "êµ¬ì²´í™”ëœ ë·°ë¥¼ 삭제하려면, DROP MATERIALIZED VIEW ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: commands/tablecmds.c:239 parser/parse_utilcmd.c:1645 +#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1630 #, c-format msgid "index \"%s\" does not exist" msgstr "\"%s\" ì¸ë±ìŠ¤ ì—†ìŒ" -#: commands/tablecmds.c:240 +#: commands/tablecmds.c:241 #, c-format msgid "index \"%s\" does not exist, skipping" msgstr "\"%s\" ì¸ë±ìŠ¤ ì—†ìŒ, 무시함" -#: commands/tablecmds.c:242 +#: commands/tablecmds.c:243 msgid "Use DROP INDEX to remove an index." msgstr "ì¸ë±ìŠ¤ë¥¼ 삭제하려면, DROP INDEX ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: commands/tablecmds.c:247 +#: commands/tablecmds.c:248 #, c-format msgid "\"%s\" is not a type" msgstr "\"%s\" ê°ì²´ëŠ” ìžë£Œí˜•ì´ 아님" -#: commands/tablecmds.c:248 +#: commands/tablecmds.c:249 msgid "Use DROP TYPE to remove a type." msgstr "ìžë£Œí˜•ì„ 삭제하려면 DROP TYPE ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: commands/tablecmds.c:251 commands/tablecmds.c:8486 -#: commands/tablecmds.c:11205 +#: commands/tablecmds.c:252 commands/tablecmds.c:8583 +#: commands/tablecmds.c:11335 #, c-format msgid "foreign table \"%s\" does not exist" msgstr "\"%s\" 외부 í…Œì´ë¸” ì—†ìŒ" -#: commands/tablecmds.c:252 +#: commands/tablecmds.c:253 #, c-format msgid "foreign table \"%s\" does not exist, skipping" msgstr "\"%s\" 외부 í…Œì´ë¸” ì—†ìŒ, 건너뜀" -#: commands/tablecmds.c:254 +#: commands/tablecmds.c:255 msgid "Use DROP FOREIGN TABLE to remove a foreign table." msgstr "외부 í…Œì´ë¸”ì„ ì‚­ì œí•˜ë ¤ë©´, DROP FOREIGN TABLE ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." -#: commands/tablecmds.c:493 +#: commands/tablecmds.c:494 #, c-format msgid "ON COMMIT can only be used on temporary tables" msgstr "ON COMMIT ì˜µì…˜ì€ ìž„ì‹œ í…Œì´ë¸”ì—서만 ì‚¬ìš©ë  ìˆ˜ 있습니다" -#: commands/tablecmds.c:513 +#: commands/tablecmds.c:514 #, c-format msgid "cannot create temporary table within security-restricted operation" msgstr "보안 제한 ìž‘ì—… ë‚´ì—ì„œ ìž„ì‹œ í…Œì´ë¸”ì„ ë§Œë“¤ 수 ì—†ìŒ" -#: commands/tablecmds.c:821 +#: commands/tablecmds.c:822 #, c-format msgid "DROP INDEX CONCURRENTLY does not support dropping multiple objects" msgstr "DROP INDEX CONCURRENTLY ëª…ë ¹ì€ í•˜ë‚˜ì˜ ì¸ë±ìŠ¤ë§Œ 지울 수 있습니다" -#: commands/tablecmds.c:825 +#: commands/tablecmds.c:826 #, c-format msgid "DROP INDEX CONCURRENTLY does not support CASCADE" msgstr "DROP INDEX CONCURRENTLY 명령ì—서는 CASCADE ì˜µì…˜ì„ ì‚¬ìš©í•  수 ì—†ìŒ" -#: commands/tablecmds.c:1084 +#: commands/tablecmds.c:1085 #, c-format msgid "truncate cascades to table \"%s\"" msgstr "\"%s\" ê°ì²´ì˜ ìžë£Œë„ 함께 ì‚­ì œë¨" -#: commands/tablecmds.c:1322 +#: commands/tablecmds.c:1323 #, c-format msgid "cannot truncate temporary tables of other sessions" msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸” ìžë£ŒëŠ” 비울(truncate) 수 없습니다" -#: commands/tablecmds.c:1528 parser/parse_utilcmd.c:1859 +#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1844 #, c-format msgid "inherited relation \"%s\" is not a table or foreign table" msgstr "ìƒì†í•  \"%s\" 릴레ì´ì…˜(relation)ì€ í…Œì´ë¸”ë„, 외부 í…Œì´ë¸”ë„ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:1535 commands/tablecmds.c:10053 +#: commands/tablecmds.c:1536 commands/tablecmds.c:10150 #, c-format msgid "cannot inherit from temporary relation \"%s\"" msgstr "\"%s\" ìž„ì‹œ í…Œì´ë¸”입니다, 그래서 ìƒì† 대ìƒì´ ë  ìˆ˜ 없습니다" -#: commands/tablecmds.c:1543 commands/tablecmds.c:10061 +#: commands/tablecmds.c:1544 commands/tablecmds.c:10158 #, c-format msgid "cannot inherit from temporary relation of another session" msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸”입니다, 그래서 ìƒì† 대ìƒì´ ë  ìˆ˜ 없습니다" -#: commands/tablecmds.c:1559 commands/tablecmds.c:10095 +#: commands/tablecmds.c:1560 commands/tablecmds.c:10192 #, c-format msgid "relation \"%s\" would be inherited from more than once" msgstr "\"%s\" í…Œì´ë¸”ì´ ì—¬ëŸ¬ 번 ìƒì†ë¨" -#: commands/tablecmds.c:1607 +#: commands/tablecmds.c:1608 #, c-format msgid "merging multiple inherited definitions of column \"%s\"" msgstr "\"%s\" ì¹¼ëŸ¼ì´ ì¤‘ë³µë˜ì–´ ìƒì†ë©ë‹ˆë‹¤." -#: commands/tablecmds.c:1615 +#: commands/tablecmds.c:1616 #, c-format msgid "inherited column \"%s\" has a type conflict" msgstr "ìƒìœ„ í…Œì´ë¸”ì—ì„œ 지정한 \"%s\" ì—´ì˜ ìžë£Œí˜•ë“¤ì´ ì¼ì¹˜í•˜ì§€ 않습니다" -#: commands/tablecmds.c:1617 commands/tablecmds.c:1640 -#: commands/tablecmds.c:1838 commands/tablecmds.c:1862 +#: commands/tablecmds.c:1618 commands/tablecmds.c:1641 +#: commands/tablecmds.c:1839 commands/tablecmds.c:1863 #: parser/parse_coerce.c:1630 parser/parse_coerce.c:1650 #: parser/parse_coerce.c:1670 parser/parse_coerce.c:1715 #: parser/parse_coerce.c:1752 parser/parse_param.c:218 @@ -8380,76 +8414,77 @@ msgstr "ìƒìœ„ í…Œì´ë¸”ì—ì„œ 지정한 \"%s\" ì—´ì˜ ìžë£Œí˜•ë“¤ì´ ì¼ì¹˜í•˜ msgid "%s versus %s" msgstr "%s 형과 %s 형" -#: commands/tablecmds.c:1626 +#: commands/tablecmds.c:1627 #, c-format msgid "inherited column \"%s\" has a collation conflict" msgstr "ìƒì† ë°›ì€ \"%s\" ì¹¼ëŸ¼ì˜ ì •ë ¬ê·œì¹™ì—ì„œ 충ëŒí•©ë‹ˆë‹¤." -#: commands/tablecmds.c:1628 commands/tablecmds.c:1850 -#: commands/tablecmds.c:4766 +#: commands/tablecmds.c:1629 commands/tablecmds.c:1851 +#: commands/tablecmds.c:4767 #, c-format msgid "\"%s\" versus \"%s\"" msgstr "\"%s\" 형과 \"%s\" 형" -#: commands/tablecmds.c:1638 +#: commands/tablecmds.c:1639 #, c-format msgid "inherited column \"%s\" has a storage parameter conflict" msgstr "ìƒì† ë°›ì€ \"%s\" ì¹¼ëŸ¼ì˜ ìŠ¤í† ë¦¬ì§€ 설정값ì—ì„œ 충ëŒí•©ë‹ˆë‹¤" -#: commands/tablecmds.c:1751 parser/parse_utilcmd.c:938 -#: parser/parse_utilcmd.c:1289 parser/parse_utilcmd.c:1365 +#: commands/tablecmds.c:1752 commands/tablecmds.c:8088 +#: parser/parse_utilcmd.c:923 parser/parse_utilcmd.c:1274 +#: parser/parse_utilcmd.c:1350 #, c-format msgid "cannot convert whole-row table reference" msgstr "ì „ì²´ 로우 í…Œì´ë¸” 참조형으로 변환할 수 ì—†ìŒ" -#: commands/tablecmds.c:1752 parser/parse_utilcmd.c:939 +#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:924 #, c-format msgid "Constraint \"%s\" contains a whole-row reference to table \"%s\"." msgstr "\"%s\" ì œì•½ì¡°ê±´ì— \"%s\" í…Œì´ë¸” ì „ì²´ 로우 참조가 있습니다" -#: commands/tablecmds.c:1824 +#: commands/tablecmds.c:1825 #, c-format msgid "merging column \"%s\" with inherited definition" msgstr "\"%s\" ì¹¼ëŸ¼ì„ ìƒì†ëœ ì •ì˜ì™€ 병합하는 중" -#: commands/tablecmds.c:1828 +#: commands/tablecmds.c:1829 #, c-format msgid "moving and merging column \"%s\" with inherited definition" msgstr "\"%s\" ì¹¼ëŸ¼ì„ ìƒì†ëœ ì •ì˜ì™€ ì´ë™, 병합하는 중" -#: commands/tablecmds.c:1829 +#: commands/tablecmds.c:1830 #, c-format msgid "User-specified column moved to the position of the inherited column." msgstr "ì‚¬ìš©ìž ì§€ì • ì¹¼ëŸ¼ì´ ìƒì†ëœ ì¹¼ëŸ¼ì˜ ìœ„ì¹˜ë¡œ ì´ë™ë˜ì—ˆìŠµë‹ˆë‹¤" -#: commands/tablecmds.c:1836 +#: commands/tablecmds.c:1837 #, c-format msgid "column \"%s\" has a type conflict" msgstr "\"%s\" ì¹¼ëŸ¼ì˜ ìžë£Œí˜•ì´ 충ëŒí•©ë‹ˆë‹¤" -#: commands/tablecmds.c:1848 +#: commands/tablecmds.c:1849 #, c-format msgid "column \"%s\" has a collation conflict" msgstr "\"%s\" ì¹¼ëŸ¼ì˜ ì •ë ¬ê·œì¹™ì´ ì¶©ëŒí•©ë‹ˆë‹¤" -#: commands/tablecmds.c:1860 +#: commands/tablecmds.c:1861 #, c-format msgid "column \"%s\" has a storage parameter conflict" msgstr "\"%s\" ì¹¼ëŸ¼ì˜ ìŠ¤í† ë¦¬ì§€ ì„¤ì •ê°’ì´ ì¶©ëŒí•©ë‹ˆë‹¤" -#: commands/tablecmds.c:1912 +#: commands/tablecmds.c:1913 #, c-format msgid "column \"%s\" inherits conflicting default values" msgstr "" "ìƒì† 받는 \"%s\" ì—´ ìžë£Œí˜•ê³¼ ì´ ì—´ì— ì§€ì •í•œ default ê°’ì˜ ìžë£Œí˜•ì´ 서로 다릅니" "다" -#: commands/tablecmds.c:1914 +#: commands/tablecmds.c:1915 #, c-format msgid "To resolve the conflict, specify a default explicitly." msgstr "ì´ ì¶©ëŒì„ 피하려면, default ê°’ì„ ë°”ë¥´ê²Œ 지정하십시오." -#: commands/tablecmds.c:1961 +#: commands/tablecmds.c:1962 #, c-format msgid "" "check constraint name \"%s\" appears multiple times but with different " @@ -8457,670 +8492,691 @@ msgid "" msgstr "" "\"%s\" ì²´í¬ ì œì•½ ì¡°ê±´ ì´ë¦„ì´ ì—¬ëŸ¬ 번 나타나지만, ê°ê° 다른 ì‹ìœ¼ë¡œ ë˜ì–´ìžˆìŒ" -#: commands/tablecmds.c:2155 +#: commands/tablecmds.c:2156 #, c-format msgid "cannot rename column of typed table" msgstr "칼럼 ì´ë¦„ì„ ë°”ê¿€ 수 ì—†ìŒ" -#: commands/tablecmds.c:2172 +#: commands/tablecmds.c:2173 #, c-format msgid "" "\"%s\" is not a table, view, materialized view, composite type, index, or " "foreign table" msgstr "" -"\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ë„, ë·°ë„, êµ¬ì²´í™”ëœ ë·°ë„, 복합 ìžë£Œí˜•ë„, ì¸ë±ìŠ¤ë„, 외부 í…Œì´ë¸”ë„ ì•„ë‹™ë‹ˆë‹¤." +"\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ë„, ë·°ë„, êµ¬ì²´í™”ëœ ë·°ë„, 복합 ìžë£Œí˜•ë„, ì¸ë±ìŠ¤ë„, 외부 í…Œ" +"ì´ë¸”ë„ ì•„ë‹™ë‹ˆë‹¤." -#: commands/tablecmds.c:2266 +#: commands/tablecmds.c:2267 #, c-format msgid "inherited column \"%s\" must be renamed in child tables too" msgstr "하위 í…Œì´ë¸”ì—ì„œë„ ìƒì†ëœ \"%s\" ì—´ì˜ ì´ë¦„ì„ ë°”ê¾¸ì–´ì•¼ 함" -#: commands/tablecmds.c:2298 +#: commands/tablecmds.c:2299 #, c-format msgid "cannot rename system column \"%s\"" msgstr "\"%s\" ì´ë¦„ì˜ ì—´ì€ ì‹œìŠ¤í…œ 열입니다, ì´ë¦„ì„ ë°”ê¿€ 수 없습니다" -#: commands/tablecmds.c:2313 +#: commands/tablecmds.c:2314 #, c-format msgid "cannot rename inherited column \"%s\"" msgstr "\"%s\" ì´ë¦„ì˜ ì—´ì€ ìƒì† ë°›ì€ ì—´ìž…ë‹ˆë‹¤, ì´ë¦„ì„ ë°”ê¿€ 수 없습니다" -#: commands/tablecmds.c:2468 +#: commands/tablecmds.c:2469 #, c-format msgid "inherited constraint \"%s\" must be renamed in child tables too" -msgstr "하위 í…Œì´ë¸”ì—ì„œë„ ìƒì†ëœ \"%s\" ì œì•½ì¡°ê±´ì€ í•˜ìœ„ í…Œì´ë¸”ì—ì„œë„ ì´ë¦„ì´ ë°”ë€Œì–´ì•¼ 함" +msgstr "" +"하위 í…Œì´ë¸”ì—ì„œë„ ìƒì†ëœ \"%s\" ì œì•½ì¡°ê±´ì€ í•˜ìœ„ í…Œì´ë¸”ì—ì„œë„ ì´ë¦„ì´ ë°”ë€Œì–´ì•¼ " +"함" -#: commands/tablecmds.c:2475 +#: commands/tablecmds.c:2476 #, c-format msgid "cannot rename inherited constraint \"%s\"" msgstr "\"%s\" ìƒì†ëœ ì œì•½ì¡°ê±´ì€ ì´ë¦„ì„ ë°”ê¿€ 수 없습니다" #. translator: first %s is a SQL command, eg ALTER TABLE -#: commands/tablecmds.c:2701 +#: commands/tablecmds.c:2702 #, c-format msgid "" "cannot %s \"%s\" because it is being used by active queries in this session" msgstr "ì´ ì„¸ì…˜ì˜ í™œì„± 쿼리ì—ì„œ 사용 중ì´ë¯€ë¡œ %s \"%s\" ìž‘ì—…ì„ í•  수 ì—†ìŒ" #. translator: first %s is a SQL command, eg ALTER TABLE -#: commands/tablecmds.c:2710 +#: commands/tablecmds.c:2711 #, c-format msgid "cannot %s \"%s\" because it has pending trigger events" msgstr "보류 ì¤‘ì¸ íŠ¸ë¦¬ê±° ì´ë²¤íŠ¸ê°€ 있으므로 %s \"%s\" ìž‘ì—…ì„ í•  수 ì—†ìŒ" -#: commands/tablecmds.c:3784 +#: commands/tablecmds.c:3785 #, c-format msgid "cannot rewrite system relation \"%s\"" msgstr "\"%s\" 시스템 릴레ì´ì…˜ì„ 다시 쓰기(rewrite) í•  수 ì—†ìŒ" -#: commands/tablecmds.c:3790 +#: commands/tablecmds.c:3791 #, c-format msgid "cannot rewrite table \"%s\" used as a catalog table" msgstr "카탈로그 í…Œì´ë¸”ë¡œ 사용ë˜ì–´ \"%s\" í…Œì´ë¸”ì„ rewrite 못함" -#: commands/tablecmds.c:3800 +#: commands/tablecmds.c:3801 #, c-format msgid "cannot rewrite temporary tables of other sessions" msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸”ì„ ë‹¤ì‹œ 쓰기(rewrite) í•  수 ì—†ìŒ" -#: commands/tablecmds.c:4068 +#: commands/tablecmds.c:4069 #, c-format msgid "rewriting table \"%s\"" msgstr "\"%s\" íŒŒì¼ ë‹¤ì‹œ 쓰는 중" -#: commands/tablecmds.c:4072 +#: commands/tablecmds.c:4073 #, c-format msgid "verifying table \"%s\"" msgstr "\"%s\" íŒŒì¼ ê²€ì‚¬ 중" -#: commands/tablecmds.c:4186 +#: commands/tablecmds.c:4187 #, c-format msgid "column \"%s\" contains null values" msgstr "\"%s\" ì—´ì—는 null ê°’ ìžë£Œê°€ 있습니다" -#: commands/tablecmds.c:4201 commands/tablecmds.c:7366 +#: commands/tablecmds.c:4202 commands/tablecmds.c:7385 #, c-format msgid "check constraint \"%s\" is violated by some row" msgstr "\"%s\" ì²´í¬ ì œì•½ ì¡°ê±´ì„ ìœ„ë°˜í•˜ëŠ” 몇몇 ìžë£Œê°€ ì´ë¯¸ 있습니다" -#: commands/tablecmds.c:4349 commands/trigger.c:235 +#: commands/tablecmds.c:4350 commands/trigger.c:235 #: rewrite/rewriteDefine.c:267 rewrite/rewriteDefine.c:912 #, c-format msgid "\"%s\" is not a table or view" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ë„ ë·°ë„ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:4352 commands/trigger.c:1119 commands/trigger.c:1224 +#: commands/tablecmds.c:4353 commands/trigger.c:1119 commands/trigger.c:1224 #, c-format msgid "\"%s\" is not a table, view, or foreign table" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, ë·°, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:4355 +#: commands/tablecmds.c:4356 #, c-format msgid "\"%s\" is not a table, view, materialized view, or index" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, ë·°, êµ¬ì²´í™”ëœ ë·°, ì¸ë±ìŠ¤ ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:4361 +#: commands/tablecmds.c:4362 #, c-format msgid "\"%s\" is not a table, materialized view, or index" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, êµ¬ì²´í™”ëœ ë·°, ì¸ë±ìŠ¤ ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:4364 +#: commands/tablecmds.c:4365 #, c-format msgid "\"%s\" is not a table, materialized view, or foreign table" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, êµ¬ì²´í™”ëœ ë·°, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤." -#: commands/tablecmds.c:4367 +#: commands/tablecmds.c:4368 #, c-format msgid "\"%s\" is not a table or foreign table" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”ë„ ì™¸ë¶€ í…Œì´ë¸”ë„ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:4370 +#: commands/tablecmds.c:4371 #, c-format msgid "\"%s\" is not a table, composite type, or foreign table" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, 복합 ìžë£Œí˜•, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤." -#: commands/tablecmds.c:4373 commands/tablecmds.c:5425 +#: commands/tablecmds.c:4374 commands/tablecmds.c:5426 #, c-format msgid "\"%s\" is not a table, materialized view, index, or foreign table" -msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, êµ¬ì²´í™”ëœ ë·°, ì¸ë±ìŠ¤, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤." +msgstr "" +"\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, êµ¬ì²´í™”ëœ ë·°, ì¸ë±ìŠ¤, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤." -#: commands/tablecmds.c:4383 +#: commands/tablecmds.c:4384 #, c-format msgid "\"%s\" is of the wrong type" msgstr "\"%s\" ê°ì²´ëŠ” ìž˜ëª»ëœ ê°ì²´í˜•ìž…니다." -#: commands/tablecmds.c:4535 commands/tablecmds.c:4542 +#: commands/tablecmds.c:4536 commands/tablecmds.c:4543 #, c-format msgid "cannot alter type \"%s\" because column \"%s.%s\" uses it" msgstr "\"%s\" ìžë£Œí˜• 변경할 수 ì—†ìŒ(\"%s.%s\" 칼럼ì—ì„œ 해당 형ì‹ì„ 사용함)" -#: commands/tablecmds.c:4549 +#: commands/tablecmds.c:4550 #, c-format msgid "" "cannot alter foreign table \"%s\" because column \"%s.%s\" uses its row type" msgstr "" "\"%s\" 외부 í…Œì´ë¸”ì„ ë³€ê²½í•  수 ì—†ìŒ(\"%s.%s\" 칼럼ì—ì„œ 해당 로우 í˜•ì„ ì‚¬ìš©í•¨)" -#: commands/tablecmds.c:4556 +#: commands/tablecmds.c:4557 #, c-format msgid "cannot alter table \"%s\" because column \"%s.%s\" uses its row type" msgstr "" "\"%s\" í…Œì´ë¸”ì„ ë³€ê²½í•  수 ì—†ìŒ(\"%s.%s\" 칼럼ì—ì„œ 해당 로우 형ì‹ì„ 사용함)" -#: commands/tablecmds.c:4618 +#: commands/tablecmds.c:4619 #, c-format msgid "cannot alter type \"%s\" because it is the type of a typed table" -msgstr "\"%s\" ìžë£Œí˜•ì„ 변경할 수 ì—†ìŒ, ì´ ìžë£Œí˜•ì€ typed í…Œì´ë¸”ì˜ ìžë£Œí˜•ì´ê¸° 때문" +msgstr "" +"\"%s\" ìžë£Œí˜•ì„ 변경할 수 ì—†ìŒ, ì´ ìžë£Œí˜•ì€ typed í…Œì´ë¸”ì˜ ìžë£Œí˜•ì´ê¸° 때문" -#: commands/tablecmds.c:4620 +#: commands/tablecmds.c:4621 #, c-format msgid "Use ALTER ... CASCADE to alter the typed tables too." msgstr "" -"ì´ ê°ì²´ì™€ ê´€ê³„ëœ ëª¨ë“  ê°ì²´ë“¤ì„ 함께 변경하려면 ALTER ... CASCADE ëª…ë ¹ì„ ì‚¬ìš©í•˜" -"십시오" +"ì´ ê°ì²´ì™€ ê´€ê³„ëœ ëª¨ë“  ê°ì²´ë“¤ì„ 함께 변경하려면 ALTER ... CASCADE ëª…ë ¹ì„ ì‚¬ìš©" +"하십시오" -#: commands/tablecmds.c:4664 +#: commands/tablecmds.c:4665 #, c-format msgid "type %s is not a composite type" msgstr "%s ìžë£Œí˜•ì€ 복합 ìžë£Œí˜•ì´ 아닙니다" -#: commands/tablecmds.c:4690 +#: commands/tablecmds.c:4691 #, c-format msgid "cannot add column to typed table" msgstr "typed í…Œì´ë¸”ì—는 ì¹¼ëŸ¼ì„ ì¶”ê°€ í•  수 ì—†ìŒ" -#: commands/tablecmds.c:4758 commands/tablecmds.c:10254 +#: commands/tablecmds.c:4759 commands/tablecmds.c:10351 #, c-format msgid "child table \"%s\" has different type for column \"%s\"" msgstr "" "\"%s\" ìƒì†ëœ í…Œì´ë¸”ì˜ \"%s\" ì—´ ìžë£Œí˜•ì´ ìƒìœ„ í…Œì´ë¸”ì˜ ìžë£Œí˜•ê³¼ 틀립니다" -#: commands/tablecmds.c:4764 commands/tablecmds.c:10261 +#: commands/tablecmds.c:4765 commands/tablecmds.c:10358 #, c-format msgid "child table \"%s\" has different collation for column \"%s\"" msgstr "" -"\"%s\" ìƒì†ëœ í…Œì´ë¸”ì˜ \"%s\" 칼럼 ì •ë ¬ê·œì¹™ì´ ìƒìœ„ í…Œì´ë¸”ì˜ ì •ë ¬ê·œì¹™ê³¼ 틀립니다" +"\"%s\" ìƒì†ëœ í…Œì´ë¸”ì˜ \"%s\" 칼럼 ì •ë ¬ê·œì¹™ì´ ìƒìœ„ í…Œì´ë¸”ì˜ ì •ë ¬ê·œì¹™ê³¼ 틀립니" +"다" -#: commands/tablecmds.c:4774 +#: commands/tablecmds.c:4775 #, c-format msgid "child table \"%s\" has a conflicting \"%s\" column" msgstr "\"%s\" 하위 í…Œì´ë¸”ì— ì¶©ëŒí•˜ëŠ” \"%s\" ì¹¼ëŸ¼ì´ ìžˆìŒ" -#: commands/tablecmds.c:4786 +#: commands/tablecmds.c:4787 #, c-format msgid "merging definition of column \"%s\" for child \"%s\"" msgstr "\"%s\" ì—´(\"%s\" 하위)ì˜ ì •ì˜ë¥¼ 병합하는 중" -#: commands/tablecmds.c:5013 +#: commands/tablecmds.c:5014 #, c-format msgid "column must be added to child tables too" msgstr "하위 í…Œì´ë¸”ì—ë„ ì—´ì„ ì¶”ê°€í•´ì•¼ 함" -#: commands/tablecmds.c:5088 +#: commands/tablecmds.c:5089 #, c-format msgid "column \"%s\" of relation \"%s\" already exists, skipping" msgstr "\"%s\" ì´ë¦„ì˜ ì¹¼ëŸ¼ì´ \"%s\" 릴레ì´ì…˜ì— ì´ë¯¸ 있습니다, 건너뜀" -#: commands/tablecmds.c:5095 +#: commands/tablecmds.c:5096 #, c-format msgid "column \"%s\" of relation \"%s\" already exists" msgstr "\"%s\" ì´ë¦„ì˜ ì—´ì´ \"%s\" 릴레ì´ì…˜ì— ì´ë¯¸ 있습니다" -#: commands/tablecmds.c:5206 commands/tablecmds.c:5312 -#: commands/tablecmds.c:5370 commands/tablecmds.c:5484 -#: commands/tablecmds.c:5541 commands/tablecmds.c:5635 -#: commands/tablecmds.c:7884 commands/tablecmds.c:8509 +#: commands/tablecmds.c:5207 commands/tablecmds.c:5313 +#: commands/tablecmds.c:5371 commands/tablecmds.c:5485 +#: commands/tablecmds.c:5542 commands/tablecmds.c:5636 +#: commands/tablecmds.c:7924 commands/tablecmds.c:8606 #, c-format msgid "cannot alter system column \"%s\"" msgstr "\"%s\" ì—´ì€ ì‹œìŠ¤í…œ 열입니다. 그래서 ë³€ê²½ë  ìˆ˜ 없습니다" -#: commands/tablecmds.c:5242 +#: commands/tablecmds.c:5243 #, c-format msgid "column \"%s\" is in a primary key" msgstr "\"%s\" ì—´ì€ ê¸°ë³¸í‚¤ 열입니다" -#: commands/tablecmds.c:5457 +#: commands/tablecmds.c:5458 #, c-format msgid "statistics target %d is too low" msgstr "ëŒ€ìƒ í†µê³„ê°’(%d)ì´ ë„ˆë¬´ 낮습니다" -#: commands/tablecmds.c:5465 +#: commands/tablecmds.c:5466 #, c-format msgid "lowering statistics target to %d" msgstr "%d 값으로 ëŒ€ìƒ í†µê³„ê°’ì„ ë‚®ì¶¥ë‹ˆë‹¤" -#: commands/tablecmds.c:5615 +#: commands/tablecmds.c:5616 #, c-format msgid "invalid storage type \"%s\"" msgstr "ìž˜ëª»ëœ STORAGE ê°’: \"%s\"" -#: commands/tablecmds.c:5647 +#: commands/tablecmds.c:5648 #, c-format msgid "column data type %s can only have storage PLAIN" msgstr "%s ìžë£Œí˜•ì˜ columnì˜ STORAGE ê°’ì€ ë°˜ë“œì‹œ PLAIN ì´ì–´ì•¼í•©ë‹ˆë‹¤" -#: commands/tablecmds.c:5685 +#: commands/tablecmds.c:5686 #, c-format msgid "cannot drop column from typed table" msgstr "typed í…Œì´ë¸”ì—ì„œ ì¹¼ëŸ¼ì„ ì‚­ì œí•  수 ì—†ìŒ" -#: commands/tablecmds.c:5729 +#: commands/tablecmds.c:5730 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist, skipping" msgstr "\"%s\" ì¹¼ëŸ¼ì€ \"%s\" 릴레ì´ì…˜ì— ì—†ìŒ, 건너뜀" -#: commands/tablecmds.c:5742 +#: commands/tablecmds.c:5743 #, c-format msgid "cannot drop system column \"%s\"" msgstr "\"%s\" ì¹¼ëŸ¼ì€ ì‹œìŠ¤í…œ 칼럼입니다, ì‚­ì œë  ìˆ˜ 없습니다" -#: commands/tablecmds.c:5749 +#: commands/tablecmds.c:5750 #, c-format msgid "cannot drop inherited column \"%s\"" msgstr "\"%s\" ì¹¼ëŸ¼ì€ ìƒì†ë°›ì€ 칼럼입니다, ì‚­ì œë  ìˆ˜ 없습니다" -#: commands/tablecmds.c:5989 +#: commands/tablecmds.c:5990 #, c-format msgid "" "ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index \"%s\" to \"%s\"" msgstr "" -"ALTER TABLE / ADD CONSTRAINT USING INDEX ìž‘ì—…ì€ \"%s\" ì¸ë±ìŠ¤ë¥¼ \"%s\" ì´ë¦„으로 바꿀 것입니다." +"ALTER TABLE / ADD CONSTRAINT USING INDEX ìž‘ì—…ì€ \"%s\" ì¸ë±ìŠ¤ë¥¼ \"%s\" ì´ë¦„으" +"ë¡œ 바꿀 것입니다." -#: commands/tablecmds.c:6202 +#: commands/tablecmds.c:6203 #, c-format msgid "constraint must be added to child tables too" msgstr "하위 í…Œì´ë¸”ì—ë„ ì œì•½ ì¡°ê±´ì„ ì¶”ê°€í•´ì•¼ 함" -#: commands/tablecmds.c:6273 +#: commands/tablecmds.c:6274 #, c-format msgid "referenced relation \"%s\" is not a table" msgstr "참조ë˜ëŠ” \"%s\" 릴레ì´ì…˜ì€ í…Œì´ë¸”ì´ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:6296 +#: commands/tablecmds.c:6297 #, c-format msgid "constraints on permanent tables may reference only permanent tables" msgstr "ì˜êµ¬ 저장용 í…Œì´ë¸”ì˜ ì œì•½ ì¡°ê±´ì€ ì˜êµ¬ 저장용 í…Œì´ë¸”ì„ ì°¸ì¡° 합니다." -#: commands/tablecmds.c:6303 +#: commands/tablecmds.c:6304 #, c-format msgid "" "constraints on unlogged tables may reference only permanent or unlogged " "tables" -msgstr "unlogged í…Œì´ë¸”ì˜ ì œì•½ ì¡°ê±´ì€ ì˜êµ¬ 저장용 í…Œì´ë¸” ë˜ëŠ” unlogged í…Œì´ë¸”ì„ ì°¸ì¡°í•©ë‹ˆë‹¤." +msgstr "" +"unlogged í…Œì´ë¸”ì˜ ì œì•½ ì¡°ê±´ì€ ì˜êµ¬ 저장용 í…Œì´ë¸” ë˜ëŠ” unlogged í…Œì´ë¸”ì„ ì°¸ì¡°" +"합니다." -#: commands/tablecmds.c:6309 +#: commands/tablecmds.c:6310 #, c-format msgid "constraints on temporary tables may reference only temporary tables" msgstr "ìž„ì‹œ í…Œì´ë¸”ì˜ ì œì•½ ì¡°ê±´ì€ ìž„ì‹œ í…Œì´ë¸”ì— ëŒ€í•´ì„œë§Œ 참조할 것입니다." -#: commands/tablecmds.c:6313 +#: commands/tablecmds.c:6314 #, c-format msgid "" "constraints on temporary tables must involve temporary tables of this session" -msgstr "ìž„ì‹œ í…Œì´ë¸”ì˜ ì œì•½ ì¡°ê±´ì€ ì´ ì„¸ì…˜ìš© ìž„ì‹œ í…Œì´ë¸”ì— ëŒ€í•´ì„œë§Œ ì ìš© ë©ë‹ˆë‹¤." +msgstr "" +"ìž„ì‹œ í…Œì´ë¸”ì˜ ì œì•½ ì¡°ê±´ì€ ì´ ì„¸ì…˜ìš© ìž„ì‹œ í…Œì´ë¸”ì— ëŒ€í•´ì„œë§Œ ì ìš© ë©ë‹ˆë‹¤." -#: commands/tablecmds.c:6374 +#: commands/tablecmds.c:6375 #, c-format msgid "number of referencing and referenced columns for foreign key disagree" msgstr "참조키(foreign key) disagree를 위한 참조하는, ë˜ëŠ” 참조ë˜ëŠ” ì—´ 수" -#: commands/tablecmds.c:6481 +#: commands/tablecmds.c:6482 #, c-format msgid "foreign key constraint \"%s\" cannot be implemented" msgstr "\"%s\" 참조키(foreign key) 제약 ì¡°ê±´ì€ êµ¬í˜„ë˜ì–´ì§ˆ 수 없습니다" -#: commands/tablecmds.c:6484 +#: commands/tablecmds.c:6485 #, c-format msgid "Key columns \"%s\" and \"%s\" are of incompatible types: %s and %s." msgstr "" "\"%s\" ì—´ê³¼ \"%s\" ì—´ ì¸ë±ìŠ¤ëŠ” 함께 사용할 수 없는 ìžë£Œí˜•ìž…니다: %s and %s." -#: commands/tablecmds.c:6691 commands/tablecmds.c:6841 -#: commands/tablecmds.c:7723 commands/tablecmds.c:7779 +#: commands/tablecmds.c:6692 commands/tablecmds.c:6860 +#: commands/tablecmds.c:7763 commands/tablecmds.c:7819 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist" msgstr "\"%s\" 제약 ì¡°ê±´ì´ \"%s\" 릴레ì´ì…˜ì— 없습니다." -#: commands/tablecmds.c:6697 +#: commands/tablecmds.c:6698 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key constraint" msgstr "\"%s\" 제약 ì¡°ê±´(해당 í…Œì´ë¸”: \"%s\")ì€ ì°¸ì¡°í‚¤ ì œì•½ì¡°ê±´ì´ ì•„ë‹™ë‹ˆë‹¤." -#: commands/tablecmds.c:6848 +#: commands/tablecmds.c:6867 #, c-format msgid "" "constraint \"%s\" of relation \"%s\" is not a foreign key or check constraint" -msgstr "\"%s\" 제약 ì¡°ê±´(해당 í…Œì´ë¸”: \"%s\")ì€ ì°¸ì¡°í‚¤ë„ ì²´í¬ ì œì•½ ì¡°ê±´ë„ ì•„ë‹™ë‹ˆë‹¤." +msgstr "" +"\"%s\" 제약 ì¡°ê±´(해당 í…Œì´ë¸”: \"%s\")ì€ ì°¸ì¡°í‚¤ë„ ì²´í¬ ì œì•½ ì¡°ê±´ë„ ì•„ë‹™ë‹ˆë‹¤." -#: commands/tablecmds.c:6916 +#: commands/tablecmds.c:6935 #, c-format msgid "constraint must be validated on child tables too" msgstr "하위 í…Œì´ë¸”ì—ë„ ì œì•½ ì¡°ê±´ì´ ìœ íš¨í•´ì•¼ 함" -#: commands/tablecmds.c:6985 +#: commands/tablecmds.c:7004 #, c-format msgid "column \"%s\" referenced in foreign key constraint does not exist" msgstr "참조키(foreign key) 제약 ì¡°ê±´ì—ì„œ 참조하는 \"%s\" ì—´ì´ ì—†ìŒ" -#: commands/tablecmds.c:6990 +#: commands/tablecmds.c:7009 #, c-format msgid "cannot have more than %d keys in a foreign key" msgstr "참조키(foreign key)ì—ì„œ %d 키 개수보다 ë§Žì´ ê°€ì§ˆ 수 ì—†ìŒ" -#: commands/tablecmds.c:7055 +#: commands/tablecmds.c:7074 #, c-format msgid "cannot use a deferrable primary key for referenced table \"%s\"" msgstr "참조ë˜ëŠ” \"%s\" í…Œì´ë¸”ì˜ ì§€ì—° 가능한 기본키를 사용할 수 ì—†ìŒ" -#: commands/tablecmds.c:7072 +#: commands/tablecmds.c:7091 #, c-format msgid "there is no primary key for referenced table \"%s\"" msgstr "참조ë˜ëŠ” \"%s\" í…Œì´ë¸”ì—는 기본키(primary key)ê°€ 없습니다" -#: commands/tablecmds.c:7137 +#: commands/tablecmds.c:7156 #, c-format msgid "foreign key referenced-columns list must not contain duplicates" msgstr "ì°¸ì¡°í‚¤ì˜ ì°¸ì¡° 칼럼 목ë¡ì— ì¹¼ëŸ¼ì´ ì¤‘ë³µë˜ë©´ 안ë©ë‹ˆë‹¤" - -#: commands/tablecmds.c:7231 +#: commands/tablecmds.c:7250 #, c-format msgid "cannot use a deferrable unique constraint for referenced table \"%s\"" msgstr "참조ë˜ëŠ” \"%s\" í…Œì´ë¸”ì˜ ì§€ì—° 가능한 ìœ ë‹ˆí¬ ì œì•½ ì¡°ê±´ì„ ì‚¬ìš©í•  수 ì—†ìŒ" -#: commands/tablecmds.c:7236 +#: commands/tablecmds.c:7255 #, c-format msgid "" "there is no unique constraint matching given keys for referenced table \"%s\"" msgstr "" "참조ë˜ëŠ” \"%s\" í…Œì´ë¸”ì„ ìœ„í•œ 주워진 키와 ì¼ì¹˜í•˜ëŠ” 고유 제약 ì¡°ê±´ì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/tablecmds.c:7399 +#: commands/tablecmds.c:7418 #, c-format msgid "validating foreign key constraint \"%s\"" msgstr "\"%s\" 참조키 제약 ì¡°ê±´ 검사 중" -#: commands/tablecmds.c:7695 +#: commands/tablecmds.c:7717 #, c-format msgid "cannot drop inherited constraint \"%s\" of relation \"%s\"" msgstr "ìƒì†ëœ \"%s\" 제약 ì¡°ê±´(해당 í…Œì´ë¸”: \"%s\")ì„ ì‚­ì œí•  수 ì—†ìŒ" -#: commands/tablecmds.c:7729 +#: commands/tablecmds.c:7769 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist, skipping" msgstr "\"%s\" 제약 ì¡°ê±´(해당 í…Œì´ë¸”: \"%s\")ì´ ì—†ìŒ, 건너뜀" -#: commands/tablecmds.c:7868 +#: commands/tablecmds.c:7908 #, c-format msgid "cannot alter column type of typed table" msgstr "typed í…Œì´ë¸”ì˜ ì¹¼ëŸ¼ ìžë£Œí˜•ì€ 변경할 수 ì—†ìŒ" -#: commands/tablecmds.c:7891 +#: commands/tablecmds.c:7931 #, c-format msgid "cannot alter inherited column \"%s\"" msgstr "\"%s\" ì´ë¦„ì˜ ì—´ì€ ìƒì† ë°›ì€ ì—´ìž…ë‹ˆë‹¤, ì´ë¦„ì„ ë°”ê¿€ 수 없습니다" -#: commands/tablecmds.c:7940 +#: commands/tablecmds.c:7980 #, c-format msgid "" "result of USING clause for column \"%s\" cannot be cast automatically to " "type %s" msgstr "" -"\"%s\" 칼럼ì—ì„œ ì“°ì¸ USING ì ˆì˜ ê²°ê³¼ê°€ %s ìžë£Œí˜•ìœ¼ë¡œ ìžë™ í˜•ë³€í™˜ì„ " -"í•  수 ì—†ìŒ" +"\"%s\" 칼럼ì—ì„œ ì“°ì¸ USING ì ˆì˜ ê²°ê³¼ê°€ %s ìžë£Œí˜•ìœ¼ë¡œ ìžë™ í˜•ë³€í™˜ì„ í•  수 ì—†ìŒ" -#: commands/tablecmds.c:7943 +#: commands/tablecmds.c:7983 #, c-format msgid "You might need to add an explicit cast." msgstr "ëª…ì‹œì  í˜•ë³€í™˜ì„ í•´ì•¼í•  것 같습니다." -#: commands/tablecmds.c:7947 +#: commands/tablecmds.c:7987 #, c-format msgid "column \"%s\" cannot be cast automatically to type %s" msgstr "\"%s\" ì¹¼ëŸ¼ì˜ ìžë£Œí˜•ì„ %s 형으로 형변환할 수 ì—†ìŒ" #. translator: USING is SQL, don't translate it -#: commands/tablecmds.c:7950 +#: commands/tablecmds.c:7990 #, c-format msgid "You might need to specify \"USING %s::%s\"." msgstr "\"USING %s::%s\" êµ¬ë¬¸ì„ ì¶”ê°€í•´ì•¼ í•  것 같습니다." -#: commands/tablecmds.c:8003 +#: commands/tablecmds.c:8089 +#, c-format +msgid "USING expression contains a whole-row table reference." +msgstr "USING 표현ì‹ì—ì„œ ì „ì²´ 로우 í…Œì´ë¸” 참조를 í¬í•¨í•˜ê³  있습니다." + +#: commands/tablecmds.c:8100 #, c-format msgid "type of inherited column \"%s\" must be changed in child tables too" msgstr "하위 í…Œì´ë¸”ì—ì„œë„ ìƒì†ëœ \"%s\" ì—´ì˜ í˜•ì‹ì„ 바꾸어야 함" -#: commands/tablecmds.c:8090 +#: commands/tablecmds.c:8187 #, c-format msgid "cannot alter type of column \"%s\" twice" msgstr "\"%s\" ì—´ì€ ì‹œìŠ¤í…œ 열입니다. 그래서 ë³€ê²½ë  ìˆ˜ 없습니다" -#: commands/tablecmds.c:8126 +#: commands/tablecmds.c:8223 #, c-format msgid "default for column \"%s\" cannot be cast automatically to type %s" msgstr "\"%s\" ì¹¼ëŸ¼ì˜ ê¸°ë³¸ ê°’ì„ %s 형으로 형변환할 수 ì—†ìŒ" -#: commands/tablecmds.c:8252 +#: commands/tablecmds.c:8349 #, c-format msgid "cannot alter type of a column used by a view or rule" msgstr "ë·° ë˜ëŠ” 규칙ì—ì„œ 사용하는 ì—´ì˜ í˜•ì‹ì„ 변경할 수 ì—†ìŒ" -#: commands/tablecmds.c:8253 commands/tablecmds.c:8272 -#: commands/tablecmds.c:8290 +#: commands/tablecmds.c:8350 commands/tablecmds.c:8369 +#: commands/tablecmds.c:8387 #, c-format msgid "%s depends on column \"%s\"" msgstr "%s ì˜ì¡´ëŒ€ìƒ ì—´: \"%s\"" -#: commands/tablecmds.c:8271 +#: commands/tablecmds.c:8368 #, c-format msgid "cannot alter type of a column used in a trigger definition" msgstr "트리거 ì •ì˜ì—ì„œ 사용하는 ì¹¼ëŸ¼ì˜ ìžë£Œí˜•ì„ 변경할 수 ì—†ìŒ" -#: commands/tablecmds.c:8289 +#: commands/tablecmds.c:8386 #, c-format msgid "cannot alter type of a column used in a policy definition" msgstr "ì •ì±… ì •ì˜ì—ì„œ 사용하는 ì¹¼ëŸ¼ì˜ ìžë£Œí˜•ì„ 변경할 수 ì—†ìŒ" -#: commands/tablecmds.c:8954 +#: commands/tablecmds.c:9051 #, c-format msgid "cannot change owner of index \"%s\"" msgstr "\"%s\" ì¸ë±ìŠ¤ì˜ 소유주를 바꿀 수 ì—†ìŒ" -#: commands/tablecmds.c:8956 +#: commands/tablecmds.c:9053 #, c-format msgid "Change the ownership of the index's table, instead." msgstr "ëŒ€ì‹ ì— ê·¸ ì¸ë±ìŠ¤ì˜ 해당 í…Œì´ë¸” 소유ìžì„ 변경하세요." -#: commands/tablecmds.c:8972 +#: commands/tablecmds.c:9069 #, c-format msgid "cannot change owner of sequence \"%s\"" msgstr "\"%s\" ì‹œí€€ìŠ¤ì˜ ì†Œìœ ì£¼ë¥¼ 바꿀 수 ì—†ìŒ" -#: commands/tablecmds.c:8974 commands/tablecmds.c:11407 +#: commands/tablecmds.c:9071 commands/tablecmds.c:11543 #, c-format msgid "Sequence \"%s\" is linked to table \"%s\"." msgstr "\"%s\" 시퀀스는 \"%s\" í…Œì´ë¸”ì— ì¢…ì†ë˜ì–´ 있습니다." -#: commands/tablecmds.c:8986 commands/tablecmds.c:12054 +#: commands/tablecmds.c:9083 commands/tablecmds.c:12190 #, c-format msgid "Use ALTER TYPE instead." msgstr "대신 ALTER TYPEì„ ì‚¬ìš©í•˜ì‹­ì‹œì˜¤." -#: commands/tablecmds.c:8995 +#: commands/tablecmds.c:9092 #, c-format msgid "\"%s\" is not a table, view, sequence, or foreign table" msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, ë·°, 시퀀스, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:9338 +#: commands/tablecmds.c:9435 #, c-format msgid "cannot have multiple SET TABLESPACE subcommands" msgstr "SET TABLESPACE êµ¬ë¬¸ì´ ì¤‘ë³µ 사용ë˜ì—ˆìŠµë‹ˆë‹¤" -#: commands/tablecmds.c:9411 +#: commands/tablecmds.c:9508 #, c-format msgid "\"%s\" is not a table, view, materialized view, index, or TOAST table" -msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, ë·°, êµ¬ì²´í™”ëœ ë·°, ì¸ë±ìŠ¤, TOAST í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤." +msgstr "" +"\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, ë·°, êµ¬ì²´í™”ëœ ë·°, ì¸ë±ìŠ¤, TOAST í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™" +"니다." -#: commands/tablecmds.c:9444 commands/view.c:469 +#: commands/tablecmds.c:9541 commands/view.c:498 #, c-format msgid "WITH CHECK OPTION is supported only on automatically updatable views" -msgstr "WITH CHECK OPTION ì˜µì…˜ì€ ìžë™ 갱신 가능한 ë·°ì— ëŒ€í•´ì„œë§Œ 사용할 수 있습니다" +msgstr "" +"WITH CHECK OPTION ì˜µì…˜ì€ ìžë™ 갱신 가능한 ë·°ì— ëŒ€í•´ì„œë§Œ 사용할 수 있습니다" -#: commands/tablecmds.c:9590 +#: commands/tablecmds.c:9687 #, c-format msgid "cannot move system relation \"%s\"" msgstr "\"%s\" 시스템 릴레ì´ì…˜ìž…니다. ì´ë™í•  수 없습니다" -#: commands/tablecmds.c:9606 +#: commands/tablecmds.c:9703 #, c-format msgid "cannot move temporary tables of other sessions" msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸”ë“¤ì€ ì´ë™í•  수 없습니다" -#: commands/tablecmds.c:9743 +#: commands/tablecmds.c:9840 #, c-format msgid "only tables, indexes, and materialized views exist in tablespaces" msgstr "í…Œì´ë¸”스페ì´ìŠ¤ì— í…Œì´ë¸”ê³¼ ì¸ë±ìŠ¤ì™€ êµ¬ì²´í™”ëœ ë·°ë§Œ 있습니다." -#: commands/tablecmds.c:9755 +#: commands/tablecmds.c:9852 #, c-format msgid "cannot move relations in to or out of pg_global tablespace" -msgstr "해당 ê°ì²´ë¥¼ pg_global í…Œì´ë¸”스페ì´ìŠ¤ë¡œ 옮기거나 ê·¸ 반대로 ìž‘ì—…í•  수 ì—†ìŒ" +msgstr "" +"해당 ê°ì²´ë¥¼ pg_global í…Œì´ë¸”스페ì´ìŠ¤ë¡œ 옮기거나 ê·¸ 반대로 ìž‘ì—…í•  수 ì—†ìŒ" -#: commands/tablecmds.c:9846 +#: commands/tablecmds.c:9943 #, c-format msgid "aborting because lock on relation \"%s.%s\" is not available" msgstr "\"%s.%s\" 릴레ì´ì…˜ì„ 잠글 수 없어 중지 중입니다" -#: commands/tablecmds.c:9862 +#: commands/tablecmds.c:9959 #, c-format msgid "no matching relations in tablespace \"%s\" found" msgstr "ê²€ìƒ‰ì¡°ê±´ì— ì¼ì¹˜í•˜ëŠ” 릴레ì´ì…˜ì´ \"%s\" í…Œì´ë¸”스페ì´ìŠ¤ì— ì—†ìŒ" -#: commands/tablecmds.c:9936 storage/buffer/bufmgr.c:915 +#: commands/tablecmds.c:10033 storage/buffer/bufmgr.c:915 #, c-format msgid "invalid page in block %u of relation %s" msgstr "%u 블ë¡(해당 릴레ì´ì…˜: %s)ì— ìž˜ëª»ëœ íŽ˜ì´ì§€ê°€ 있ìŒ" -#: commands/tablecmds.c:10018 +#: commands/tablecmds.c:10115 #, c-format msgid "cannot change inheritance of typed table" msgstr "typed í…Œì´ë¸”ì˜ ìƒì† 정보는 변경할 수 ì—†ìŒ" -#: commands/tablecmds.c:10068 +#: commands/tablecmds.c:10165 #, c-format msgid "cannot inherit to temporary relation of another session" msgstr "다른 ì„¸ì…˜ì˜ ìž„ì‹œ í…Œì´ë¸”ì„ ìƒì†í•  수 ì—†ìŒ" -#: commands/tablecmds.c:10122 +#: commands/tablecmds.c:10219 #, c-format msgid "circular inheritance not allowed" msgstr "순환 ë˜ëŠ” ìƒì†ì€ 허용하지 않습니다" -#: commands/tablecmds.c:10123 +#: commands/tablecmds.c:10220 #, c-format msgid "\"%s\" is already a child of \"%s\"." msgstr "\"%s\" ê°ì²´ëŠ” ì´ë¯¸ \"%s\" ê°ì²´ë¡œë¶€í„° ìƒì†ë°›ì€ ìƒíƒœìž…니다." -#: commands/tablecmds.c:10131 +#: commands/tablecmds.c:10228 #, c-format msgid "table \"%s\" without OIDs cannot inherit from table \"%s\" with OIDs" msgstr "" "\"%s\" í…Œì´ë¸”ì´ OID ì—´ ì—†ì´ OID 있는 \"%s\" í…Œì´ë¸”ì—ì„œ ìƒì† ë  ìˆ˜ 없습니다." -#: commands/tablecmds.c:10272 +#: commands/tablecmds.c:10369 #, c-format msgid "column \"%s\" in child table must be marked NOT NULL" msgstr "ìžì‹ í…Œì´ë¸”ì˜ \"%s\" ì—´ì€ NOT NULL ì†ì„±ì´ 있어야합니다" -#: commands/tablecmds.c:10288 +#: commands/tablecmds.c:10385 commands/tablecmds.c:10418 #, c-format msgid "child table is missing column \"%s\"" msgstr "ìžì‹ í…Œì´ë¸”ì—는 \"%s\" ì—´ì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/tablecmds.c:10371 +#: commands/tablecmds.c:10501 #, c-format msgid "child table \"%s\" has different definition for check constraint \"%s\"" msgstr "\"%s\" 하위 í…Œì´ë¸”ì— \"%s\" ì²´í¬ ì œì•½ ì¡°ê±´ì— ëŒ€í•œ 다른 ì •ì˜ê°€ 있ìŒ" -#: commands/tablecmds.c:10379 +#: commands/tablecmds.c:10509 #, c-format msgid "" "constraint \"%s\" conflicts with non-inherited constraint on child table \"%s" "\"" -msgstr "\"%s\" 제약 ì¡°ê±´ì´ \"%s\" 하위 í…Œì´ë¸”ì— ìžˆëŠ” 비 ìƒì† 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤" +msgstr "" +"\"%s\" 제약 ì¡°ê±´ì´ \"%s\" 하위 í…Œì´ë¸”ì— ìžˆëŠ” 비 ìƒì† 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤" -#: commands/tablecmds.c:10390 +#: commands/tablecmds.c:10520 #, c-format msgid "" "constraint \"%s\" conflicts with NOT VALID constraint on child table \"%s\"" -msgstr "\"%s\" 제약 ì¡°ê±´ì´ \"%s\" 하위 í…Œì´ë¸”ì— ìžˆëŠ” NOT VALID 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤" +msgstr "" +"\"%s\" 제약 ì¡°ê±´ì´ \"%s\" 하위 í…Œì´ë¸”ì— ìžˆëŠ” NOT VALID 제약 ì¡°ê±´ê³¼ 충ëŒí•©ë‹ˆë‹¤" -#: commands/tablecmds.c:10414 +#: commands/tablecmds.c:10544 #, c-format msgid "child table is missing constraint \"%s\"" msgstr "ìžì‹ í…Œì´ë¸”ì— \"%s\" 제약 ì¡°ê±´ì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/tablecmds.c:10498 +#: commands/tablecmds.c:10628 #, c-format msgid "relation \"%s\" is not a parent of relation \"%s\"" msgstr "\"%s\" 릴레ì´ì…˜ì€ \"%s\" 릴레ì´ì…˜ì˜ 부모가 아닙니다" -#: commands/tablecmds.c:10732 +#: commands/tablecmds.c:10862 #, c-format msgid "typed tables cannot inherit" msgstr "typed í…Œì´ë¸”ì€ ìƒì†í•  수 ì—†ìŒ" -#: commands/tablecmds.c:10763 +#: commands/tablecmds.c:10893 #, c-format msgid "table is missing column \"%s\"" msgstr "í…Œì´ë¸”ì—는 \"%s\" ì¹¼ëŸ¼ì´ ì—†ìŠµë‹ˆë‹¤" -#: commands/tablecmds.c:10773 +#: commands/tablecmds.c:10903 #, c-format msgid "table has column \"%s\" where type requires \"%s\"" msgstr "\"%s\" ì¹¼ëŸ¼ì€ \"%s\" ìžë£Œí˜•ìž…니다." -#: commands/tablecmds.c:10782 +#: commands/tablecmds.c:10912 #, c-format msgid "table \"%s\" has different type for column \"%s\"" msgstr "\"%s\" í…Œì´ë¸”ì˜ \"%s\" 칼럼 ìžë£Œí˜• 틀립니다" -#: commands/tablecmds.c:10795 +#: commands/tablecmds.c:10925 #, c-format msgid "table has extra column \"%s\"" msgstr "\"%s\" ì¹¼ëŸ¼ì€ í™•ìž¥í˜•ìž…ë‹ˆë‹¤" -#: commands/tablecmds.c:10847 +#: commands/tablecmds.c:10977 #, c-format msgid "\"%s\" is not a typed table" msgstr "\"%s\" í…Œì´ë¸”ì€ typed í…Œì´ë¸”ì´ ì•„ë‹™ë‹ˆë‹¤" -#: commands/tablecmds.c:11031 +#: commands/tablecmds.c:11161 #, c-format msgid "cannot use non-unique index \"%s\" as replica identity" msgstr "\"%s\" ì¸ë±ìŠ¤ëŠ” ìœ ë‹ˆí¬ ì¸ë±ìŠ¤ê°€ 아니여서, 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ" -#: commands/tablecmds.c:11037 +#: commands/tablecmds.c:11167 #, c-format msgid "cannot use non-immediate index \"%s\" as replica identity" msgstr "\"%s\" non-immediate ì¸ë±ìŠ¤ëŠ” 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ" -#: commands/tablecmds.c:11043 +#: commands/tablecmds.c:11173 #, c-format msgid "cannot use expression index \"%s\" as replica identity" msgstr "\"%s\" ì¸ë±ìŠ¤ëŠ” expression ì¸ë±ìŠ¤ì—¬ì„œ, 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ" -#: commands/tablecmds.c:11049 +#: commands/tablecmds.c:11179 #, c-format msgid "cannot use partial index \"%s\" as replica identity" msgstr "\"%s\" ì¸ë±ìŠ¤ê°€ 부분ì¸ë±ìŠ¤ì—¬ì„œ, 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ" -#: commands/tablecmds.c:11055 +#: commands/tablecmds.c:11185 #, c-format msgid "cannot use invalid index \"%s\" as replica identity" -msgstr "\"%s\" ì¸ë±ìŠ¤ëŠ” 사용할 수 없는 ì¸ë±ìŠ¤ì—¬ì„œ, 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ" +msgstr "" +"\"%s\" ì¸ë±ìŠ¤ëŠ” 사용할 수 없는 ì¸ë±ìŠ¤ì—¬ì„œ, 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ" -#: commands/tablecmds.c:11076 +#: commands/tablecmds.c:11206 #, c-format msgid "" "index \"%s\" cannot be used as replica identity because column %d is a " @@ -9128,58 +9184,60 @@ msgid "" msgstr "" "\"%s\" ì¸ë±ìŠ¤ëŠ” 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ, %d 번째 ì¹¼ëŸ¼ì´ ì‹œìŠ¤í…œ 칼럼임" -#: commands/tablecmds.c:11083 +#: commands/tablecmds.c:11213 #, c-format msgid "" "index \"%s\" cannot be used as replica identity because column \"%s\" is " "nullable" msgstr "" -"\"%s\" ì¸ë±ìŠ¤ëŠ” 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ, \"%s\" ì¹¼ëŸ¼ì´ null ê°’ 사용가능 ì†ì„±ìž„" +"\"%s\" ì¸ë±ìŠ¤ëŠ” 복제 ì‹ë³„ìžë¡œ 사용할 수 ì—†ìŒ, \"%s\" ì¹¼ëŸ¼ì´ null ê°’ 사용가능 " +"ì†ì„±ìž„" -#: commands/tablecmds.c:11280 +#: commands/tablecmds.c:11416 #, c-format msgid "cannot change logged status of table \"%s\" because it is temporary" msgstr "\"%s\" í…Œì´ë¸”ì€ ìž„ì‹œ í…Œì´ë¸”ì´ê¸°ì—, 통계 정보를 변경 í•  수 ì—†ìŒ" -#: commands/tablecmds.c:11339 +#: commands/tablecmds.c:11475 #, c-format msgid "" "could not change table \"%s\" to logged because it references unlogged table " "\"%s\"" msgstr "" -"\"%s\" í…Œì´ë¸”ì´ \"%s\" unlogged í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ê³  있어 " -"logged ì†ì„±ìœ¼ë¡œ 바꿀 수 ì—†ìŒ" +"\"%s\" í…Œì´ë¸”ì´ \"%s\" unlogged í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ê³  있어 logged ì†ì„±ìœ¼ë¡œ 바꿀 " +"수 ì—†ìŒ" -#: commands/tablecmds.c:11349 +#: commands/tablecmds.c:11485 #, c-format msgid "" "could not change table \"%s\" to unlogged because it references logged table " "\"%s\"" msgstr "" -"\"%s\" í…Œì´ë¸”ì´ \"%s\" logged í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ê³  있어 " -"unlogged ì†ì„±ìœ¼ë¡œ 바꿀 수 ì—†ìŒ" - +"\"%s\" í…Œì´ë¸”ì´ \"%s\" logged í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ê³  있어 unlogged ì†ì„±ìœ¼ë¡œ 바꿀 " +"수 ì—†ìŒ" -#: commands/tablecmds.c:11406 +#: commands/tablecmds.c:11542 #, c-format msgid "cannot move an owned sequence into another schema" msgstr "ì†Œìœ ëœ ì‹œí€€ìŠ¤ë¥¼ 다른 스키마로 ì´ë™í•  수 ì—†ìŒ" -#: commands/tablecmds.c:11511 +#: commands/tablecmds.c:11647 #, c-format msgid "relation \"%s\" already exists in schema \"%s\"" msgstr "\"%s\" 릴레ì´ì…˜ì´ \"%s\" ìŠ¤í‚¤ë§ˆì— ì´ë¯¸ 있습니다" -#: commands/tablecmds.c:12038 +#: commands/tablecmds.c:12174 #, c-format msgid "\"%s\" is not a composite type" msgstr "\"%s\" ê°ì²´ëŠ” 복합 ìžë£Œí˜•ìž…니다" -#: commands/tablecmds.c:12068 +#: commands/tablecmds.c:12204 #, c-format msgid "" "\"%s\" is not a table, view, materialized view, sequence, or foreign table" -msgstr "\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, ë·°, êµ¬ì²´í™”ëœ ë·°, 시퀀스, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™ë‹ˆë‹¤" +msgstr "" +"\"%s\" ê°ì²´ëŠ” í…Œì´ë¸”, ë·°, êµ¬ì²´í™”ëœ ë·°, 시퀀스, 외부 í…Œì´ë¸” ê·¸ ì–´ëŠ ê²ƒë„ ì•„ë‹™" +"니다" #: commands/tablespace.c:162 commands/tablespace.c:179 #: commands/tablespace.c:190 commands/tablespace.c:198 @@ -9455,7 +9513,8 @@ msgstr "BEFORE STATEMENT 트리거는 ë¦¬í„´ê°’ì´ ìžˆìœ¼ë©´ 안ë©ë‹ˆë‹¤" msgid "" "tuple to be updated was already modified by an operation triggered by the " "current command" -msgstr "현재 명령으로 ì‹¤í–‰ëœ íŠ¸ë¦¬ê±° 작업으로 변경해야할 ìžë£Œê°€ ì´ë¯¸ 바뀌었습니다." +msgstr "" +"현재 명령으로 ì‹¤í–‰ëœ íŠ¸ë¦¬ê±° 작업으로 변경해야할 ìžë£Œê°€ ì´ë¯¸ 바뀌었습니다." #: commands/trigger.c:2727 executor/nodeModifyTable.c:680 #: executor/nodeModifyTable.c:973 @@ -9463,9 +9522,11 @@ msgstr "현재 명령으로 ì‹¤í–‰ëœ íŠ¸ë¦¬ê±° 작업으로 변경해야할 ìž msgid "" "Consider using an AFTER trigger instead of a BEFORE trigger to propagate " "changes to other rows." -msgstr "다른 로우를 변경하는 ì¼ì„ BEFORE 트리거 ëŒ€ì‹ ì— AFTER 트리거 ì‚¬ìš©ì„ ê³ ë ¤í•´ 보십시오" +msgstr "" +"다른 로우를 변경하는 ì¼ì„ BEFORE 트리거 ëŒ€ì‹ ì— AFTER 트리거 ì‚¬ìš©ì„ ê³ ë ¤í•´ ë³´" +"십시오" -#: commands/trigger.c:2741 executor/execMain.c:2377 +#: commands/trigger.c:2741 executor/execMain.c:2379 #: executor/nodeLockRows.c:216 executor/nodeModifyTable.c:213 #: executor/nodeModifyTable.c:692 executor/nodeModifyTable.c:985 #: executor/nodeModifyTable.c:1151 @@ -9623,8 +9684,7 @@ msgstr "ìžë£Œí˜• 출력 함수를 지정하십시오" msgid "" "type modifier output function is useless without a type modifier input " "function" -msgstr "" -"í˜•ì‹ í•œì •ìž ìž…ë ¥ 함수가 없으면 í˜•ì‹ í•œì •ìž ì¶œë ¥ 함수는 ì˜ë¯¸ê°€ ì—†ìŒ" +msgstr "í˜•ì‹ í•œì •ìž ìž…ë ¥ 함수가 없으면 í˜•ì‹ í•œì •ìž ì¶œë ¥ 함수는 ì˜ë¯¸ê°€ ì—†ìŒ" #: commands/typecmds.c:453 commands/typecmds.c:470 #, c-format @@ -9744,7 +9804,9 @@ msgstr "range subtypeì€ %s 아니여야 함" #: commands/typecmds.c:1453 #, c-format msgid "range collation specified but subtype does not support collation" -msgstr "range í˜•ì— ì •ë ¬ ê·œì¹™ì„ ì§€ì •í–ˆì§€ë§Œ, ì†Œì† ìžë£Œí˜•ì´ ê·¸ ì •ë ¬ ê·œì¹™ì„ ì§€ì›í•˜ì§€ 않습니다" +msgstr "" +"range í˜•ì— ì •ë ¬ ê·œì¹™ì„ ì§€ì •í–ˆì§€ë§Œ, ì†Œì† ìžë£Œí˜•ì´ ê·¸ ì •ë ¬ ê·œì¹™ì„ ì§€ì›í•˜ì§€ 않습" +"니다" #: commands/typecmds.c:1687 #, c-format @@ -9777,8 +9839,8 @@ msgid "" "You must specify an operator class for the range type or define a default " "operator class for the subtype." msgstr "" -"subtypeì„ ìœ„í•œ 기본 ì—°ì‚°ìž í´ëž˜ìŠ¤ë‚˜ range ìžë£Œí˜•ì„ 위한 í•˜ë‚˜ì˜ " -"ì—°ì‚°ìž í´ëž˜ìŠ¤ë¥¼ 지정해야 합니다" +"subtypeì„ ìœ„í•œ 기본 ì—°ì‚°ìž í´ëž˜ìŠ¤ë‚˜ range ìžë£Œí˜•ì„ 위한 í•˜ë‚˜ì˜ ì—°ì‚°ìž í´ëž˜ìŠ¤" +"를 지정해야 합니다" #: commands/typecmds.c:1968 #, c-format @@ -9899,7 +9961,7 @@ msgid "permission denied to create role" msgstr "롤 만들 권한 ì—†ìŒ" #: commands/user.c:322 commands/user.c:1176 commands/user.c:1183 -#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 gram.y:13615 gram.y:13650 +#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 gram.y:13619 gram.y:13654 #, c-format msgid "role name \"%s\" is reserved" msgstr "\"%s\" 롤 ì´ë¦„ì€ ë‚´ë¶€ì ìœ¼ë¡œ 사용ë˜ê³  있습니다" @@ -10055,7 +10117,9 @@ msgstr "%s ëª…ë ¹ì€ VACUUM, ANALYZE 명령ì—ì„œ 실행 ë  ìˆ˜ ì—†ìŒ" #: commands/vacuum.c:195 #, c-format msgid "VACUUM option DISABLE_PAGE_SKIPPING cannot be used with FULL" -msgstr "VACUUM 명령ì—ì„œ DISABLE_PAGE_SKIPPING 옵션과 FULL ì˜µì…˜ì„ í•¨ê»˜ 사용할 수 없습니다." +msgstr "" +"VACUUM 명령ì—ì„œ DISABLE_PAGE_SKIPPING 옵션과 FULL ì˜µì…˜ì„ í•¨ê»˜ 사용할 수 없습" +"니다." # # search5 부분 #: commands/vacuum.c:535 @@ -10081,7 +10145,8 @@ msgstr "가장 ì˜¤ëž˜ëœ multixact ê°’ì´ ë„ˆë¬´ 옛날 것입니다." msgid "" "Close open transactions with multixacts soon to avoid wraparound problems." msgstr "" -"멀티 트랜잭션 ID 겹침 사고를 막기 위해 빨리 열린 멀티 íŠ¸ëžœìž­ì…˜ë“¤ì„ ë‹«ìœ¼ì‹­ì‹œì˜¤." +"멀티 트랜잭션 ID 겹침 사고를 막기 위해 빨리 열린 멀티 íŠ¸ëžœìž­ì…˜ë“¤ì„ ë‹«ìœ¼ì‹­ì‹œ" +"오." #: commands/vacuum.c:1146 #, c-format @@ -10108,8 +10173,7 @@ msgstr "\"%s\" 건너뜀 --- 슈í¼ìœ ì €ë§Œ 청소할 수 있ìŒ" #: commands/vacuum.c:1298 #, c-format msgid "skipping \"%s\" --- only superuser or database owner can vacuum it" -msgstr "" -"\"%s\" 건너뜀 --- 슈í¼ìœ ì € ë˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ 소유주만 청소할 수 있ìŒ" +msgstr "\"%s\" 건너뜀 --- 슈í¼ìœ ì € ë˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ 소유주만 청소할 수 있ìŒ" #: commands/vacuum.c:1302 #, c-format @@ -10119,7 +10183,9 @@ msgstr "\"%s\" 건너뜀 --- ì´ í…Œì´ë¸”ì´ë‚˜ ë°ì´í„°ë² ì´ìŠ¤ì˜ 소유주 #: commands/vacuum.c:1320 #, c-format msgid "skipping \"%s\" --- cannot vacuum non-tables or special system tables" -msgstr "\"%s\" 건너뜀 --- í…Œì´ë¸”ì´ ì•„ë‹Œ 것 ë˜ëŠ” 특별 시스템 í…Œì´ë¸” ë“±ì€ ì²­ì†Œí•  수 ì—†ìŒ" +msgstr "" +"\"%s\" 건너뜀 --- í…Œì´ë¸”ì´ ì•„ë‹Œ 것 ë˜ëŠ” 특별 시스템 í…Œì´ë¸” ë“±ì€ ì²­ì†Œí•  수 ì—†" +"ìŒ" #: commands/vacuumlazy.c:366 #, c-format @@ -10130,15 +10196,13 @@ msgstr "\"%s.%s.%s\" í…Œì´ë¸” ìžë™ 청소: ì¸ë±ìŠ¤ íƒìƒ‰: %d\n" #, c-format msgid "" "pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n" -msgstr "" -"페ì´ì§€: %u ì‚­ì œë¨, %u 남ìŒ, %u í•€ë‹ìœ¼ë¡œ 건너뜀, %u ë™ê²°ë˜ì–´ 건너뜀\n" +msgstr "페ì´ì§€: %u ì‚­ì œë¨, %u 남ìŒ, %u í•€ë‹ìœ¼ë¡œ 건너뜀, %u ë™ê²°ë˜ì–´ 건너뜀\n" #: commands/vacuumlazy.c:377 #, c-format msgid "" "tuples: %.0f removed, %.0f remain, %.0f are dead but not yet removable\n" -msgstr "" -"튜플: %.0f ì‚­ì œë¨, %.0f 남ìŒ, %.0f 삭제할 수 없는 ì£½ì€ íŠœí”Œ\n" +msgstr "튜플: %.0f ì‚­ì œë¨, %.0f 남ìŒ, %.0f 삭제할 수 없는 ì£½ì€ íŠœí”Œ\n" #: commands/vacuumlazy.c:382 #, c-format @@ -10193,8 +10257,8 @@ msgid "" "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u " "pages" msgstr "" -"\"%s\": 지울 수 있는 ìžë£Œ %.0fê°œ, 지울 수 없는 ìžë£Œ %.0f개를 %u/%uê°œ " -"페ì´ì§€ì—ì„œ 찾았ìŒ" +"\"%s\": 지울 수 있는 ìžë£Œ %.0fê°œ, 지울 수 없는 ìžë£Œ %.0f개를 %u/%uê°œ 페ì´ì§€ì—" +"ì„œ 찾았ìŒ" #: commands/vacuumlazy.c:1411 #, c-format @@ -10237,7 +10301,7 @@ msgstr "\"%s\": %u ì—ì„œ %u 페ì´ì§€ë¡œ 정지했ìŒ" msgid "\"%s\": suspending truncate due to conflicting lock request" msgstr "\"%s\": 잠금 요청 충ëŒë¡œ ìžë£Œ 비우기 ìž‘ì—…ì„ ì§€ì—°í•©ë‹ˆë‹¤" -#: commands/variable.c:164 utils/misc/guc.c:9891 +#: commands/variable.c:164 utils/misc/guc.c:9899 #, c-format msgid "Unrecognized key word: \"%s\"." msgstr "ì•Œ 수 없는 키워드: \"%s\"" @@ -10311,7 +10375,8 @@ msgstr "대신ì—, REPEATABLE READ ëª…ë ¹ì„ ì‚¬ìš©í•  수 있ìŒ." #, c-format msgid "" "SET TRANSACTION [NOT] DEFERRABLE cannot be called within a subtransaction" -msgstr "하위 트랜잭션ì—ì„œ SET TRANSACTION [NOT] DEFERRABLE êµ¬ë¬¸ì€ ì‚¬ìš©í•  수 ì—†ìŒ" +msgstr "" +"하위 트랜잭션ì—ì„œ SET TRANSACTION [NOT] DEFERRABLE êµ¬ë¬¸ì€ ì‚¬ìš©í•  수 ì—†ìŒ" #: commands/variable.c:629 #, c-format @@ -10348,53 +10413,53 @@ msgstr "\"check_option\" ì˜µì…˜ê°’ì´ ìž˜ëª»ë¨" msgid "Valid values are \"local\" and \"cascaded\"." msgstr "사용할 수 있는 ê°’ì€ \"local\" ë˜ëŠ” \"cascaded\" 입니다" -#: commands/view.c:103 +#: commands/view.c:101 #, c-format msgid "could not determine which collation to use for view column \"%s\"" msgstr "\"%s\" 칼럼 ìžë£Œ 처리를 위한 ì •ë ¬ ê·œì¹™ì„ ê²°ì •í•  수 ì—†ìŒ" -#: commands/view.c:117 +#: commands/view.c:115 #, c-format msgid "view must have at least one column" msgstr "ë·°ì—는 ì ì–´ë„ í•œ ê°œ ì´ìƒì˜ ì¹¼ëŸ¼ì´ ìžˆì–´ì•¼ 합니다" -#: commands/view.c:251 commands/view.c:263 +#: commands/view.c:280 commands/view.c:292 #, c-format msgid "cannot drop columns from view" msgstr "ë·°ì—ì„œ ì¹¼ëŸ¼ì„ ì‚­ì œí•  수 ì—†ìŒ" -#: commands/view.c:268 +#: commands/view.c:297 #, c-format msgid "cannot change name of view column \"%s\" to \"%s\"" msgstr "ë·°ì—ì„œ \"%s\" 칼럼 ì´ë¦„ì„ \"%s\"(으)ë¡œ 바꿀 수 ì—†ìŒ" -#: commands/view.c:276 +#: commands/view.c:305 #, c-format msgid "cannot change data type of view column \"%s\" from %s to %s" msgstr "ë·°ì—ì„œ \"%s\" 칼럼 ìžë£Œí˜•ì„ì„ %sì—ì„œ %s(으)ë¡œ 바꿀 수 ì—†ìŒ" -#: commands/view.c:415 +#: commands/view.c:444 #, c-format msgid "views must not contain SELECT INTO" msgstr "ë·°ì—는 SELECT INTO êµ¬ë¬¸ì„ í¬í•¨í•  수 ì—†ìŒ" -#: commands/view.c:428 +#: commands/view.c:457 #, c-format msgid "views must not contain data-modifying statements in WITH" msgstr "ë·°ë¡œ ì‚¬ìš©ë  ì¿¼ë¦¬ì˜ WITH ì ˆì—는 ìžë£Œ 변경 êµ¬ë¬¸ì´ ìžˆìœ¼ë©´ 안ë©ë‹ˆë‹¤." -#: commands/view.c:499 +#: commands/view.c:528 #, c-format msgid "CREATE VIEW specifies more column names than columns" msgstr "CREATE VIEW 는 columns 보다는 ì¢€ë” ë§Žì€ ì—´ ì´ë¦„ì„ ëª…ì‹œí•´ì•¼ 한다" -#: commands/view.c:507 +#: commands/view.c:536 #, c-format msgid "views cannot be unlogged because they do not have storage" -msgstr "뷰는 저장 ê³µê°„ì„ ì‚¬ìš©í•˜ì§€ 않기 ë•Œë¬¸ì— unlogged ì†ì„±ì„ 지정할 수 없습니다." - +msgstr "" +"뷰는 저장 ê³µê°„ì„ ì‚¬ìš©í•˜ì§€ 않기 ë•Œë¬¸ì— unlogged ì†ì„±ì„ 지정할 수 없습니다." -#: commands/view.c:521 +#: commands/view.c:550 #, c-format msgid "view \"%s\" will be a temporary view" msgstr "\"%s\" 뷰는 ìž„ì‹œì ì¸ ë·°ë¡œ 만들어집니다" @@ -10435,7 +10500,8 @@ msgstr "\"%s\" 커서는 \"%s\" í…Œì´ë¸”ì˜ ë‹¨ìˆœ ì—…ë°ì´íŠ¸ 가능한 스 #, c-format msgid "" "type of parameter %d (%s) does not match that when preparing the plan (%s)" -msgstr "%d번째 매개 ë³€ìˆ˜ì˜ ìžë£Œí˜•(%s)ì´ ë¯¸ë¦¬ ì¤€ë¹„ëœ ì‹¤í–‰ê³„íšì˜ ìžë£Œí˜•(%s)ê³¼ 다릅니다" +msgstr "" +"%d번째 매개 ë³€ìˆ˜ì˜ ìžë£Œí˜•(%s)ì´ ë¯¸ë¦¬ ì¤€ë¹„ëœ ì‹¤í–‰ê³„íšì˜ ìžë£Œí˜•(%s)ê³¼ 다릅니다" #: executor/execCurrent.c:243 executor/execQual.c:1190 #, c-format @@ -10447,8 +10513,9 @@ msgstr "%d번째 매개 변수 ê°’ì´ ì—†ìŠµë‹ˆë‹¤" msgid "" "ON CONFLICT does not support deferrable unique constraints/exclusion " "constraints as arbiters" -msgstr "지연 가능한 고유 제약조건ì´ë‚˜ 제외 제약 ì¡°ê±´ì€ ON CONFLICT íŒë³„ìžë¡œ " -"사용할 수 없습니다." +msgstr "" +"지연 가능한 고유 제약조건ì´ë‚˜ 제외 제약 ì¡°ê±´ì€ ON CONFLICT íŒë³„ìžë¡œ 사용할 " +"수 없습니다." #: executor/execIndexing.c:821 #, c-format @@ -10500,8 +10567,9 @@ msgstr "\"%s\" ë·°ì— ìžë£Œë¥¼ 입력할 수 없습니다" msgid "" "To enable inserting into the view, provide an INSTEAD OF INSERT trigger or " "an unconditional ON INSERT DO INSTEAD rule." -msgstr "뷰를 통해 ìžë£Œë¥¼ 입력하려면, INSTEAD OF INSERT 트리거나 " -"ON INSERT DO INSTEAD ë£°ì„ ì‚¬ìš©í•˜ì„¸ìš”" +msgstr "" +"뷰를 통해 ìžë£Œë¥¼ 입력하려면, INSTEAD OF INSERT 트리거나 ON INSERT DO INSTEAD " +"ë£°ì„ ì‚¬ìš©í•˜ì„¸ìš”" #: executor/execMain.c:1059 rewrite/rewriteHandler.c:2656 #, c-format @@ -10514,8 +10582,8 @@ msgid "" "To enable updating the view, provide an INSTEAD OF UPDATE trigger or an " "unconditional ON UPDATE DO INSTEAD rule." msgstr "" -"ë·° ìžë£Œ 갱신 ê¸°ëŠ¥ì€ INSTEAD OF UPDATE 트리거를 사용하거나, " -"ON UPDATE DO INSTEAD ì†ì„±ìœ¼ë¡œ ë£°ì„ ë§Œë“¤ì–´ì„œ 사용해 보세요." +"ë·° ìžë£Œ 갱신 ê¸°ëŠ¥ì€ INSTEAD OF UPDATE 트리거를 사용하거나, ON UPDATE DO " +"INSTEAD ì†ì„±ìœ¼ë¡œ ë£°ì„ ë§Œë“¤ì–´ì„œ 사용해 보세요." #: executor/execMain.c:1067 rewrite/rewriteHandler.c:2664 #, c-format @@ -10528,8 +10596,8 @@ msgid "" "To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an " "unconditional ON DELETE DO INSTEAD rule." msgstr "" -"ë·° ìžë£Œ ì‚­ì œ ê¸°ëŠ¥ì€ INSTEAD OF DELETE 트리거를 사용하거나, " -"ON DELETE DO INSTEAD ì†ì„±ìœ¼ë¡œ ë£°ì„ ë§Œë“¤ì–´ì„œ 사용해 보세요." +"ë·° ìžë£Œ ì‚­ì œ ê¸°ëŠ¥ì€ INSTEAD OF DELETE 트리거를 사용하거나, ON DELETE DO " +"INSTEAD ì†ì„±ìœ¼ë¡œ ë£°ì„ ë§Œë“¤ì–´ì„œ 사용해 보세요." #: executor/execMain.c:1080 #, c-format @@ -10591,7 +10659,7 @@ msgstr "\"%s\" ë·°ì—ì„œ 로우를 잠글 수 ì—†ìŒ" msgid "cannot lock rows in materialized view \"%s\"" msgstr "\"%s\" êµ¬ì²´í™”ëœ ë·°ì—ì„œ 로우를 잠글 수 ì—†ìŒ" -#: executor/execMain.c:1192 executor/execMain.c:2611 +#: executor/execMain.c:1192 executor/execMain.c:2613 #: executor/nodeLockRows.c:132 #, c-format msgid "cannot lock rows in foreign table \"%s\"" @@ -10602,47 +10670,47 @@ msgstr "\"%s\" 외부 í…Œì´ë¸”ì—ì„œ 로우를 잠글 수 ì—†ìŒ" msgid "cannot lock rows in relation \"%s\"" msgstr "\"%s\" 릴레ì´ì…˜ì—ì„œ 로우를 잠글 수 ì—†ìŒ" -#: executor/execMain.c:1729 +#: executor/execMain.c:1731 #, c-format msgid "null value in column \"%s\" violates not-null constraint" msgstr "\"%s\" ì¹¼ëŸ¼ì˜ null ê°’ì´ not null ì œì•½ì¡°ê±´ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤." -#: executor/execMain.c:1731 executor/execMain.c:1757 executor/execMain.c:1846 +#: executor/execMain.c:1733 executor/execMain.c:1759 executor/execMain.c:1848 #, c-format msgid "Failing row contains %s." msgstr "실패한 ìžë£Œ: %s" -#: executor/execMain.c:1755 +#: executor/execMain.c:1757 #, c-format msgid "new row for relation \"%s\" violates check constraint \"%s\"" msgstr "새 ìžë£Œê°€ \"%s\" 릴레ì´ì…˜ì˜ \"%s\" ì²´í¬ ì œì•½ ì¡°ê±´ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤" -#: executor/execMain.c:1844 +#: executor/execMain.c:1846 #, c-format msgid "new row violates check option for view \"%s\"" msgstr "새 ìžë£Œê°€ \"%s\" ë·°ì˜ ì²´í¬ ì œì•½ ì¡°ê±´ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤" -#: executor/execMain.c:1854 +#: executor/execMain.c:1856 #, c-format msgid "new row violates row-level security policy \"%s\" for table \"%s\"" -msgstr "새 ìžë£Œê°€ \"%s\" 로우 단위 보안 ì •ì±…ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤, 해당 í…Œì´ë¸”: \"%s\"" +msgstr "" +"새 ìžë£Œê°€ \"%s\" 로우 단위 보안 ì •ì±…ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤, 해당 í…Œì´ë¸”: \"%s\"" -#: executor/execMain.c:1859 +#: executor/execMain.c:1861 #, c-format msgid "new row violates row-level security policy for table \"%s\"" msgstr "새 ìžë£Œê°€ \"%s\" í…Œì´ë¸”ì˜ ë¡œìš° 단위 보안 ì •ì±…ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤." -#: executor/execMain.c:1866 +#: executor/execMain.c:1868 #, c-format msgid "" "new row violates row-level security policy \"%s\" (USING expression) for " "table \"%s\"" msgstr "" -"새 ìžë£Œê°€ \"%s\" 로우 단위 보안 ì •ì±…(USING ì ˆ 사용)ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤, " -"해당 í…Œì´ë¸”: \"%s\"" +"새 ìžë£Œê°€ \"%s\" 로우 단위 보안 ì •ì±…(USING ì ˆ 사용)ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤, 해당 í…Œì´" +"블: \"%s\"" - -#: executor/execMain.c:1871 +#: executor/execMain.c:1873 #, c-format msgid "" "new row violates row-level security policy (USING expression) for table \"%s" @@ -10650,11 +10718,11 @@ msgid "" msgstr "" "새 ìžë£Œê°€ \"%s\" í…Œì´ë¸”ì˜ ë¡œìš° 단위 보안 ì •ì±…(USING ì ˆ 사용)ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤." -#: executor/execQual.c:302 executor/execQual.c:339 executor/execQual.c:3230 -#: utils/adt/array_userfuncs.c:472 utils/adt/arrayfuncs.c:260 +#: executor/execQual.c:302 executor/execQual.c:339 executor/execQual.c:3236 +#: utils/adt/array_userfuncs.c:484 utils/adt/arrayfuncs.c:260 #: utils/adt/arrayfuncs.c:558 utils/adt/arrayfuncs.c:1288 #: utils/adt/arrayfuncs.c:3361 utils/adt/arrayfuncs.c:5241 -#: utils/adt/arrayfuncs.c:5764 +#: utils/adt/arrayfuncs.c:5758 #, c-format msgid "number of array dimensions (%d) exceeds the maximum allowed (%d)" msgstr "지정한 ë°°ì—´ í¬ê¸°(%d)ê°€ 최대치(%d)를 초과했습니다" @@ -10664,12 +10732,12 @@ msgstr "지정한 ë°°ì—´ í¬ê¸°(%d)ê°€ 최대치(%d)를 초과했습니다" msgid "array subscript in assignment must not be null" msgstr "ë°°ì—´ 하위 스í¬ë¦½íŠ¸ë¡œ 지정하는 값으로 null ê°’ì„ ì‚¬ìš©í•  수 없습니다" -#: executor/execQual.c:657 executor/execQual.c:4170 +#: executor/execQual.c:657 executor/execQual.c:4183 #, c-format msgid "attribute %d has wrong type" msgstr "%d ì†ì„±ì˜ 형ì‹ì´ 잘못ë¨" -#: executor/execQual.c:658 executor/execQual.c:4171 +#: executor/execQual.c:658 executor/execQual.c:4184 #, c-format msgid "Table has type %s, but query expects %s." msgstr "í…Œì´ë¸”ì—는 %s ìžë£Œí˜•ì´ì§€ë§Œ, 쿼리ì—서는 %s ìžë£Œí˜•ìž…니다." @@ -10717,8 +10785,7 @@ msgid "" "function returning setof record called in context that cannot accept type " "record" msgstr "" -"setof 레코드 반환 함수가 type 레코드를 허용하지 않는 컨í…스트ì—ì„œ " -"호출ë¨" +"setof 레코드 반환 함수가 type 레코드를 허용하지 않는 컨í…스트ì—ì„œ 호출ë¨" #: executor/execQual.c:1638 executor/execQual.c:1654 executor/execQual.c:1664 #, c-format @@ -10762,63 +10829,63 @@ msgstr "IS DISTINCT FROM 구문ì—서는 set ì¸ìžë“¤ì„ 지ì›í•˜ì§€ 않습니 msgid "op ANY/ALL (array) does not support set arguments" msgstr "op ANY/ALL (array) ì—서는 set ì¸ìžë“¤ì„ 지ì›í•˜ì§€ 않습니다" -#: executor/execQual.c:3208 +#: executor/execQual.c:3214 #, c-format msgid "cannot merge incompatible arrays" msgstr "ë°°ì—´ 형태가 서로 틀려 병합할 수 없습니다" -#: executor/execQual.c:3209 +#: executor/execQual.c:3215 #, c-format msgid "" "Array with element type %s cannot be included in ARRAY construct with " "element type %s." msgstr "" -"%s ìžë£Œí˜•ì˜ 요소로 êµ¬ì„±ëœ ë°°ì—´ì€ %s ìžë£Œí˜•ì˜ 요소로 êµ¬ì„±ëœ ARRAY êµ¬ë¬¸ì— " -"í¬í•¨ë  수 없습니다." +"%s ìžë£Œí˜•ì˜ 요소로 êµ¬ì„±ëœ ë°°ì—´ì€ %s ìžë£Œí˜•ì˜ 요소로 êµ¬ì„±ëœ ARRAY êµ¬ë¬¸ì— í¬í•¨" +"ë  ìˆ˜ 없습니다." -#: executor/execQual.c:3250 executor/execQual.c:3277 +#: executor/execQual.c:3256 executor/execQual.c:3283 #, c-format msgid "" "multidimensional arrays must have array expressions with matching dimensions" msgstr "ë‹¤ì°¨ì› ë°°ì—´ì—는 ì¼ì¹˜í•˜ëŠ” ì°¨ì›ì´ í¬í•¨ëœ ë°°ì—´ ì‹ì´ 있어야 함" -#: executor/execQual.c:3792 +#: executor/execQual.c:3798 #, c-format msgid "NULLIF does not support set arguments" msgstr "NULLIF는 set ì¸ìžë“¤ì„ 지ì›í•˜ì§€ 않습니다" -#: executor/execQual.c:4040 utils/adt/domains.c:136 +#: executor/execQual.c:4046 utils/adt/domains.c:137 #, c-format msgid "domain %s does not allow null values" msgstr "%s ë„ë©”ì¸ì—서는 null ê°’ì„ í—ˆìš©í•˜ì§€ 않습니다" -#: executor/execQual.c:4070 utils/adt/domains.c:173 +#: executor/execQual.c:4083 utils/adt/domains.c:179 #, c-format msgid "value for domain %s violates check constraint \"%s\"" msgstr "%s ë„ë©”ì¸ìš© ê°’ì´ \"%s\" ì²´í¬ ì œì•½ ì¡°ê±´ì„ ìœ„ë°˜í–ˆìŠµë‹ˆë‹¤" -#: executor/execQual.c:4425 +#: executor/execQual.c:4438 #, c-format msgid "WHERE CURRENT OF is not supported for this table type" msgstr "WHERE CURRENT OF êµ¬ë¬¸ì€ ì´ í…Œì´ë¸” 형 대ìƒìœ¼ë¡œ 지ì›í•˜ì§€ 않습니다." -#: executor/execQual.c:4614 parser/parse_agg.c:758 +#: executor/execQual.c:4627 parser/parse_agg.c:758 #, c-format msgid "window function calls cannot be nested" msgstr "윈ë„ìš° 함수 í˜¸ì¶œì„ ì¤‘ì²©í•  수 ì—†ìŒ" -#: executor/execQual.c:4826 +#: executor/execQual.c:4839 #, c-format msgid "target type is not an array" msgstr "ëŒ€ìƒ ìžë£Œí˜•ì´ ë°°ì—´ì´ ì•„ë‹™ë‹ˆë‹¤." -#: executor/execQual.c:4941 +#: executor/execQual.c:4956 #, c-format msgid "ROW() column has type %s instead of type %s" msgstr "ROW() ì—´ì€ %s ìžë£Œí˜•ì„ 가집니다. %s ìžë£Œí˜• 대신ì—" -#: executor/execQual.c:5076 utils/adt/arrayfuncs.c:3803 -#: utils/adt/arrayfuncs.c:6337 utils/adt/rowtypes.c:927 +#: executor/execQual.c:5091 utils/adt/arrayfuncs.c:3803 +#: utils/adt/arrayfuncs.c:6325 utils/adt/rowtypes.c:927 #, c-format msgid "could not identify a comparison function for type %s" msgstr "%s ìžë£Œí˜•ì—ì„œ 사용할 비êµí•¨ìˆ˜ë¥¼ ì°¾ì„ ìˆ˜ 없습니다." @@ -10838,92 +10905,100 @@ msgstr "REFRESH MATERIALIZED VIEW ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”." msgid "could not determine actual type of argument declared %s" msgstr "%s ì¸ìžì˜ ìžë£Œí˜•ìœ¼ë¡œ 지정한 ìžë£Œí˜•ì˜ 기본 ìžë£Œí˜•ì„ ì°¾ì„ ìˆ˜ 없습니다" +#: executor/functions.c:511 +#, c-format +msgid "cannot COPY to/from client in a SQL function" +msgstr "SQL 함수ì—ì„œ í´ë¼ì´ì–¸íŠ¸ ëŒ€ìƒ COPY ìž‘ì—…ì„ í•  수 ì—†ìŒ" + #. translator: %s is a SQL statement name -#: executor/functions.c:508 +#: executor/functions.c:517 #, c-format msgid "%s is not allowed in a SQL function" msgstr "SQL 함수ì—ì„œ %s 지ì›ë˜ì§€ ì•ŠìŒ" #. translator: %s is a SQL statement name -#: executor/functions.c:515 executor/spi.c:1364 executor/spi.c:2154 +#: executor/functions.c:524 executor/spi.c:1364 executor/spi.c:2154 #, c-format msgid "%s is not allowed in a non-volatile function" msgstr "%s êµ¬ë¬¸ì€ ë¹„íœ˜ë°œì„± 함수(non-volatile function)ì—ì„œ 허용하지 않습니다" -#: executor/functions.c:641 +#: executor/functions.c:650 #, c-format msgid "" "could not determine actual result type for function declared to return type " "%s" msgstr "" -"%s ìžë£Œí˜•ì„ 반환한다고 ì •ì˜í•œ 함수ì¸ë°, 실재 반환 ìžë£Œí˜•ì„ ê²°ì •í•  수 없습니다." +"%s ìžë£Œí˜•ì„ 반환한다고 ì •ì˜í•œ 함수ì¸ë°, 실재 반환 ìžë£Œí˜•ì„ ê²°ì •í•  수 없습니" +"다." -#: executor/functions.c:1406 +#: executor/functions.c:1415 #, c-format msgid "SQL function \"%s\" statement %d" msgstr "SQL 함수 \"%s\"ì˜ ë¬¸ %d" -#: executor/functions.c:1432 +#: executor/functions.c:1441 #, c-format msgid "SQL function \"%s\" during startup" msgstr "시작 중 SQL 함수 \"%s\"" -#: executor/functions.c:1591 executor/functions.c:1628 -#: executor/functions.c:1640 executor/functions.c:1753 -#: executor/functions.c:1786 executor/functions.c:1816 +#: executor/functions.c:1600 executor/functions.c:1637 +#: executor/functions.c:1649 executor/functions.c:1762 +#: executor/functions.c:1795 executor/functions.c:1825 #, c-format msgid "return type mismatch in function declared to return %s" msgstr "리턴 ìžë£Œí˜•ì´ 함수 ì •ì˜ì—ì„œ 지정한 %s 리턴 ìžë£Œí˜•ê³¼ 틀립니다" -#: executor/functions.c:1593 +#: executor/functions.c:1602 #, c-format msgid "" "Function's final statement must be SELECT or INSERT/UPDATE/DELETE RETURNING." msgstr "" -"함수 ë‚´ìš©ì˜ ë§¨ 마지막 êµ¬ë¬¸ì€ SELECT ë˜ëŠ” INSERT/UPDATE/DELETE RETURNINGì´ì–´ì•¼ 합니" -"다." +"함수 ë‚´ìš©ì˜ ë§¨ 마지막 êµ¬ë¬¸ì€ SELECT ë˜ëŠ” INSERT/UPDATE/DELETE RETURNINGì´ì–´" +"야 합니다." -#: executor/functions.c:1630 +#: executor/functions.c:1639 #, c-format msgid "Final statement must return exactly one column." msgstr "맨 마지막 êµ¬ë¬¸ì€ ì •í™•ížˆ í•˜ë‚˜ì˜ ì¹¼ëŸ¼ë§Œ 반환해야 합니다." -#: executor/functions.c:1642 +#: executor/functions.c:1651 #, c-format msgid "Actual return type is %s." msgstr "실재 반환 ìžë£Œí˜•ì€ %s" -#: executor/functions.c:1755 +#: executor/functions.c:1764 #, c-format msgid "Final statement returns too many columns." msgstr "맨 마지막 êµ¬ë¬¸ì´ ë„ˆë¬´ ë§Žì€ ì¹¼ëŸ¼ì„ ë°˜í™˜í•©ë‹ˆë‹¤." -#: executor/functions.c:1788 +#: executor/functions.c:1797 #, c-format msgid "Final statement returns %s instead of %s at column %d." -msgstr "맨 마지막 êµ¬ë¬¸ì´ %s(기대ë˜ëŠ” ìžë£Œí˜•: %s) ìžë£Œí˜•ì„ %d 번째 칼럼ì—ì„œ 반환합니다." +msgstr "" +"맨 마지막 êµ¬ë¬¸ì´ %s(기대ë˜ëŠ” ìžë£Œí˜•: %s) ìžë£Œí˜•ì„ %d 번째 칼럼ì—ì„œ 반환합니" +"다." -#: executor/functions.c:1818 +#: executor/functions.c:1827 #, c-format msgid "Final statement returns too few columns." msgstr "맨 마지막 êµ¬ë¬¸ì´ ë„ˆë¬´ ì ì€ ì¹¼ëŸ¼ì„ ë°˜í™˜í•©ë‹ˆë‹¤." -#: executor/functions.c:1867 +#: executor/functions.c:1876 #, c-format msgid "return type %s is not supported for SQL functions" msgstr "반환 ìžë£Œí˜•ì¸ %s ìžë£Œí˜•ì€ SQL 함수ì—ì„œ 지ì›ë˜ì§€ ì•ŠìŒ" -#: executor/nodeAgg.c:2983 +#: executor/nodeAgg.c:3038 #, c-format msgid "combine function for aggregate %u must be declared as STRICT" msgstr "%u OID 집계함수ì—ì„œ 쓸 ì¡°í•© 함수는 STRICT ì†ì„±ì„ 가져야 합니다" -#: executor/nodeAgg.c:3028 executor/nodeWindowAgg.c:2285 +#: executor/nodeAgg.c:3083 executor/nodeWindowAgg.c:2318 #, c-format msgid "aggregate %u needs to have compatible input type and transition type" msgstr "%u OID ì§‘ê³„í•¨ìˆ˜ì— í˜¸í™˜ 가능한 ìž…ë ¥ 형ì‹ê³¼ 변환 형ì‹ì´ 있어야 함" -#: executor/nodeAgg.c:3094 parser/parse_agg.c:612 parser/parse_agg.c:642 +#: executor/nodeAgg.c:3149 parser/parse_agg.c:612 parser/parse_agg.c:642 #, c-format msgid "aggregate function calls cannot be nested" msgstr "집계 함수는 중첩ë˜ì–´ 호출 í•  수 ì—†ìŒ" @@ -10943,7 +11018,7 @@ msgstr "í•´ì‹œ-ì¡°ì¸ ìž„ì‹œ 파ì¼ì„ ë˜ê°ì„ 수 ì—†ìŒ: %m" msgid "could not write to hash-join temporary file: %m" msgstr "hash-join ìž„ì‹œ 파ì¼ì„ 쓸 수 없습니다: %m" -#: executor/nodeHashjoin.c:928 executor/nodeHashjoin.c:938 +#: executor/nodeHashjoin.c:935 executor/nodeHashjoin.c:945 #, c-format msgid "could not read from hash-join temporary file: %m" msgstr "í•´ì‹œ-ì¡°ì¸ ìž„ì‹œ 파ì¼ì„ ì½ì„ 수 ì—†ìŒ: %m" @@ -11021,22 +11096,22 @@ msgstr "표현ì‹ì— ì‚¬ìš©ëœ ì„œë¸Œì¿¼ë¦¬ 결과가 하나 ì´ìƒì˜ í–‰ì„ msgid "moving-aggregate transition function must not return null" msgstr "moving-aggregate transition 함수는 null ê°’ì„ ë°˜í™˜í•˜ë©´ 안ë©ë‹ˆë‹¤." -#: executor/nodeWindowAgg.c:1609 +#: executor/nodeWindowAgg.c:1642 #, c-format msgid "frame starting offset must not be null" msgstr "프래임 시작 위치값으로 null ê°’ì„ ì‚¬ìš©í•  수 없습니다." -#: executor/nodeWindowAgg.c:1622 +#: executor/nodeWindowAgg.c:1655 #, c-format msgid "frame starting offset must not be negative" msgstr "프래임 시작 위치으로 ìŒìˆ˜ ê°’ì„ ì‚¬ìš©í•  수 없습니다." -#: executor/nodeWindowAgg.c:1635 +#: executor/nodeWindowAgg.c:1668 #, c-format msgid "frame ending offset must not be null" msgstr "프래임 ë 위치값으로 null ê°’ì„ ì‚¬ìš©í•  수 없습니다." -#: executor/nodeWindowAgg.c:1648 +#: executor/nodeWindowAgg.c:1681 #, c-format msgid "frame ending offset must not be negative" msgstr "프래임 ë 위치값으로 ìŒìˆ˜ ê°’ì„ ì‚¬ìš©í•  수 없습니다." @@ -11072,7 +11147,7 @@ msgstr "%s 쿼리로 커서를 ì—´ 수 ì—†ìŒ." msgid "DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE is not supported" msgstr "DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE는 지ì›ë˜ì§€ ì•ŠìŒ" -#: executor/spi.c:1339 parser/analyze.c:2363 +#: executor/spi.c:1339 parser/analyze.c:2360 #, c-format msgid "Scrollable cursors must be READ ONLY." msgstr "스í¬ë¡¤ 가능 커서는 READ ONLY여야 합니다." @@ -11187,8 +11262,8 @@ msgstr "ì—°ê²°ì— ìœ íš¨í•œ í´ë¼ì´ì–¸íŠ¸ ì¸ì¦ì„œê°€ 필요함" msgid "" "pg_hba.conf rejects replication connection for host \"%s\", user \"%s\", %s" msgstr "" -"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", %s ì—°ê²°ì´ ë³µì œìš© 연결로는 pg_hba.conf íŒŒì¼ " -"ì„¤ì •ì— ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" +"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", %s ì—°ê²°ì´ ë³µì œìš© 연결로는 pg_hba.conf íŒŒì¼ ì„¤ì •" +"ì— ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" #: libpq/auth.c:396 libpq/auth.c:412 libpq/auth.c:470 libpq/auth.c:488 msgid "SSL off" @@ -11202,8 +11277,8 @@ msgstr "SSL ë™ìž‘" #, c-format msgid "pg_hba.conf rejects replication connection for host \"%s\", user \"%s\"" msgstr "" -"호스트 \"%s\", ì‚¬ìš©ìž \"%s\" ì—°ê²°ì´ ë³µì œìš© 연결로는 pg_hba.conf íŒŒì¼ " -"ì„¤ì •ì— ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" +"호스트 \"%s\", ì‚¬ìš©ìž \"%s\" ì—°ê²°ì´ ë³µì œìš© 연결로는 pg_hba.conf íŒŒì¼ ì„¤ì •ì— " +"ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" #: libpq/auth.c:409 #, c-format @@ -11211,31 +11286,34 @@ msgid "" "pg_hba.conf rejects connection for host \"%s\", user \"%s\", database \"%s" "\", %s" msgstr "" -"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", ë°ì´í„°ë² ì´ìŠ¤ \"%s\", %s ì—°ê²°ì´ pg_hba.conf íŒŒì¼ " -"ì„¤ì •ì— ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" +"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", ë°ì´í„°ë² ì´ìŠ¤ \"%s\", %s ì—°ê²°ì´ pg_hba.conf 파" +"ì¼ ì„¤ì •ì— ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" #: libpq/auth.c:416 #, c-format msgid "" "pg_hba.conf rejects connection for host \"%s\", user \"%s\", database \"%s\"" msgstr "" -"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", ë°ì´í„°ë² ì´ìŠ¤ \"%s\" ì—°ê²°ì´ pg_hba.conf íŒŒì¼ " -"ì„¤ì •ì— ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" +"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", ë°ì´í„°ë² ì´ìŠ¤ \"%s\" ì—°ê²°ì´ pg_hba.conf íŒŒì¼ ì„¤" +"ì •ì— ë”°ë¼ ê±°ë¶€ë©ë‹ˆë‹¤" #: libpq/auth.c:445 #, c-format msgid "Client IP address resolved to \"%s\", forward lookup matches." -msgstr "í´ë¼ì´ì–¸íŠ¸ IP 주소가 \"%s\" ì´ë¦„으로 확ì¸ë¨, 호스트 ì´ë¦„ í™•ì¸ ê¸°ëŠ¥ìœ¼ë¡œ 맞ìŒ" +msgstr "" +"í´ë¼ì´ì–¸íŠ¸ IP 주소가 \"%s\" ì´ë¦„으로 확ì¸ë¨, 호스트 ì´ë¦„ í™•ì¸ ê¸°ëŠ¥ìœ¼ë¡œ 맞ìŒ" #: libpq/auth.c:448 #, c-format msgid "Client IP address resolved to \"%s\", forward lookup not checked." -msgstr "í´ë¼ì´ì–¸íŠ¸ IP 주소가 \"%s\" ì´ë¦„으로 확ì¸ë¨, 호스트 ì´ë¦„ í™•ì¸ ê¸°ëŠ¥ 사용안함" +msgstr "" +"í´ë¼ì´ì–¸íŠ¸ IP 주소가 \"%s\" ì´ë¦„으로 확ì¸ë¨, 호스트 ì´ë¦„ í™•ì¸ ê¸°ëŠ¥ 사용안함" #: libpq/auth.c:451 #, c-format msgid "Client IP address resolved to \"%s\", forward lookup does not match." -msgstr "í´ë¼ì´ì–¸íŠ¸ IP 주소가 \"%s\" ì´ë¦„으로 확ì¸ë¨, 호스트 ì´ë¦„ í™•ì¸ ê¸°ëŠ¥ìœ¼ë¡œ 틀림" +msgstr "" +"í´ë¼ì´ì–¸íŠ¸ IP 주소가 \"%s\" ì´ë¦„으로 확ì¸ë¨, 호스트 ì´ë¦„ í™•ì¸ ê¸°ëŠ¥ìœ¼ë¡œ 틀림" #: libpq/auth.c:454 #, c-format @@ -11253,16 +11331,16 @@ msgid "" "no pg_hba.conf entry for replication connection from host \"%s\", user \"%s" "\", %s" msgstr "" -"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", %s ì—°ê²°ì´ ë³µì œìš© ì—°ê²°ë¡œ pg_hba.conf 파ì¼ì— " -"설정ë˜ì–´ 있지 않습니다" +"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", %s ì—°ê²°ì´ ë³µì œìš© ì—°ê²°ë¡œ pg_hba.conf 파ì¼ì— 설정" +"ë˜ì–´ 있지 않습니다" #: libpq/auth.c:475 #, c-format msgid "" "no pg_hba.conf entry for replication connection from host \"%s\", user \"%s\"" msgstr "" -"호스트 \"%s\", ì‚¬ìš©ìž \"%s\" ì—°ê²°ì´ ë³µì œìš© ì—°ê²°ë¡œ pg_hba.conf 파ì¼ì— " -"설정ë˜ì–´ 있지 않습니다" +"호스트 \"%s\", ì‚¬ìš©ìž \"%s\" ì—°ê²°ì´ ë³µì œìš© ì—°ê²°ë¡œ pg_hba.conf 파ì¼ì— 설정ë˜" +"ì–´ 있지 않습니다" #: libpq/auth.c:485 #, c-format @@ -11275,8 +11353,8 @@ msgstr "" #, c-format msgid "no pg_hba.conf entry for host \"%s\", user \"%s\", database \"%s\"" msgstr "" -"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", ë°ì´í„°ë² ì´ìŠ¤ \"%s\" ì—°ê²°ì— ëŒ€í•œ ì„¤ì •ì´ " -"pg_hba.conf 파ì¼ì— 없습니다." +"호스트 \"%s\", ì‚¬ìš©ìž \"%s\", ë°ì´í„°ë² ì´ìŠ¤ \"%s\" ì—°ê²°ì— ëŒ€í•œ ì„¤ì •ì´ pg_hba." +"conf 파ì¼ì— 없습니다." #: libpq/auth.c:536 libpq/hba.c:1178 #, c-format @@ -11490,7 +11568,9 @@ msgstr "LDAP ì¸ì¦ì„ 위한 ì‚¬ìš©ìž ì´ë¦„ì— ì‚¬ìš©í•  수 없는 문ìžê°€ msgid "" "could not perform initial LDAP bind for ldapbinddn \"%s\" on server \"%s\": " "%s" -msgstr "\"%s\" ldapbinddn (해당 서버: \"%s\") ì„¤ì •ì— ëŒ€í•œ LDAP ë°”ì¸ë“œ 초기화를 í•  수 ì—†ìŒ: %s" +msgstr "" +"\"%s\" ldapbinddn (해당 서버: \"%s\") ì„¤ì •ì— ëŒ€í•œ LDAP ë°”ì¸ë“œ 초기화를 í•  수 " +"ì—†ìŒ: %s" #: libpq/auth.c:2228 #, c-format @@ -11541,8 +11621,8 @@ msgid "" "certificate authentication failed for user \"%s\": client certificate " "contains no user name" msgstr "" -"\"%s\" 사용ìžì— 대한 ì¸ì¦ì„œ ë¡œê·¸ì¸ ì‹¤íŒ¨: í´ë¼ì´ì–¸íŠ¸ ì¸ì¦ì„œì— 사용" -"ìž ì´ë¦„ì´ ì—†ìŒ" +"\"%s\" 사용ìžì— 대한 ì¸ì¦ì„œ ë¡œê·¸ì¸ ì‹¤íŒ¨: í´ë¼ì´ì–¸íŠ¸ ì¸ì¦ì„œì— ì‚¬ìš©ìž ì´ë¦„ì´ ì—†" +"ìŒ" #: libpq/auth.c:2468 #, c-format @@ -11680,8 +11760,8 @@ msgstr "서버 측 lo_import() í˜¸ì¶œì„ í•˜ë ¤ë©´, 슈í¼ìœ ì €ì—¬ì•¼ 합니다 #, c-format msgid "Anyone can use the client-side lo_import() provided by libpq." msgstr "" -"libpq ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ ì´ìš©í•œ í´ë¼ì´ì–¸íŠ¸ 측 lo_import() í˜¸ì¶œì€ " -"아무나 í•  수 있습니다." +"libpq ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ ì´ìš©í•œ í´ë¼ì´ì–¸íŠ¸ 측 lo_import() í˜¸ì¶œì€ ì•„ë¬´ë‚˜ í•  수 있습" +"니다." #: libpq/be-fsstubs.c:469 #, c-format @@ -11746,7 +11826,8 @@ msgstr "\"%s\" ê°œì¸ í‚¤ 파ì¼ì€ ì¼ë°˜ 파ì¼ì´ 아님" #: libpq/be-secure-openssl.c:229 #, c-format msgid "private key file \"%s\" must be owned by the database user or root" -msgstr "\"%s\" ê°œì¸ í‚¤ 파ì¼ì˜ 소유주는 ë°ì´í„°ë² ì´ìŠ¤ 사용ìžì´ê±°ë‚˜ root 여야 합니다." +msgstr "" +"\"%s\" ê°œì¸ í‚¤ 파ì¼ì˜ 소유주는 ë°ì´í„°ë² ì´ìŠ¤ 사용ìžì´ê±°ë‚˜ root 여야 합니다." #: libpq/be-secure-openssl.c:249 #, c-format @@ -11759,9 +11840,9 @@ msgid "" "File must have permissions u=rw (0600) or less if owned by the database " "user, or permissions u=rw,g=r (0640) or less if owned by root." msgstr "" -"파ì¼ì˜ 소유주가 ë°ì´í„°ë² ì´ìŠ¤ 서버 ìš´ì˜ ê³„ì •ê³¼ 같다면, " -"ì ‘ê·¼ ê¶Œí•œì„ u=rw (0600) ë˜ëŠ” ë” ìž‘ê²Œ 설정하고, rootê°€ 소유주ë¼ë©´ " -"u=rw,g=r (0640) 권한으로 지정하세요" +"파ì¼ì˜ 소유주가 ë°ì´í„°ë² ì´ìŠ¤ 서버 ìš´ì˜ ê³„ì •ê³¼ 같다면, ì ‘ê·¼ ê¶Œí•œì„ u=rw " +"(0600) ë˜ëŠ” ë” ìž‘ê²Œ 설정하고, rootê°€ 소유주ë¼ë©´ u=rw,g=r (0640) 권한으로 지정" +"하세요" #: libpq/be-secure-openssl.c:258 #, c-format @@ -11973,8 +12054,8 @@ msgstr "ì´ ì„œë²„ëŠ” hostssl ì ‘ì† ê¸°ëŠ¥ì„ ì§€ì›í•˜ì§€ 않습니다." #, c-format msgid "Compile with --with-openssl to use SSL connections." msgstr "" -"SSL ì—°ê²°ì„ ì‚¬ìš©í•˜ê¸° 위해 --enable-ssl ì˜µì…˜ì„ ì‚¬ìš©í•´ì„œ " -"서버를 다시 ì»´íŒŒì¼ í•˜ì„¸ìš”" +"SSL ì—°ê²°ì„ ì‚¬ìš©í•˜ê¸° 위해 --enable-ssl ì˜µì…˜ì„ ì‚¬ìš©í•´ì„œ 서버를 다시 ì»´íŒŒì¼ í•˜ì„¸" +"ìš”" #: libpq/hba.c:910 #, c-format @@ -12098,8 +12179,8 @@ msgid "" "cannot use ldapbasedn, ldapbinddn, ldapbindpasswd, ldapsearchattribute, or " "ldapurl together with ldapprefix" msgstr "" -"ldapbasedn, ldapbinddn, ldapbindpasswd, ldapsearchattribute, ldapurl " -"ì˜µì…˜ì€ ldapprefix 옵션과 함께 사용할 수 ì—†ìŒ" +"ldapbasedn, ldapbinddn, ldapbindpasswd, ldapsearchattribute, ldapurl ì˜µì…˜ì€ " +"ldapprefix 옵션과 함께 사용할 수 ì—†ìŒ" #: libpq/hba.c:1371 #, c-format @@ -12107,8 +12188,8 @@ msgid "" "authentication method \"ldap\" requires argument \"ldapbasedn\", \"ldapprefix" "\", or \"ldapsuffix\" to be set" msgstr "" -"\"ldap\" ì¸ì¦ ë°©ë²•ì˜ ê²½ìš° \"ldapbasedn\", \"ldapprefix\", \"ldapsuffix\"" -"ì˜µì…˜ì´ ìžˆì–´ì•¼ 함" +"\"ldap\" ì¸ì¦ ë°©ë²•ì˜ ê²½ìš° \"ldapbasedn\", \"ldapprefix\", \"ldapsuffix\"옵션" +"ì´ ìžˆì–´ì•¼ 함" #: libpq/hba.c:1414 msgid "ident, peer, gssapi, sspi, and cert" @@ -12125,8 +12206,7 @@ msgid "" "client certificates can only be checked if a root certificate store is " "available" msgstr "" -"루트 ì¸ì¦ì„œ 저장소가 사용 가능한 경우ì—만 í´ë¼ì´ì–¸íŠ¸ ì¸ì¦ì„œë¥¼ 검사" -"í•  수 있ìŒ" +"루트 ì¸ì¦ì„œ 저장소가 사용 가능한 경우ì—만 í´ë¼ì´ì–¸íŠ¸ ì¸ì¦ì„œë¥¼ 검사할 수 있ìŒ" #: libpq/hba.c:1452 #, c-format @@ -12176,7 +12256,7 @@ msgstr "RADIUS í¬íŠ¸ 번호가 잘못ë¨: \"%s\"" msgid "unrecognized authentication option name: \"%s\"" msgstr "ì•Œ 수 없는 ì¸ì¦ 옵션 ì´ë¦„: \"%s\"" -#: libpq/hba.c:1806 guc-file.l:593 +#: libpq/hba.c:1806 guc-file.l:594 #, c-format msgid "could not open configuration file \"%s\": %m" msgstr "\"%s\" 설정 íŒŒì¼ ì„ ì—´ìˆ˜ 없습니다: %m" @@ -12201,8 +12281,7 @@ msgstr "\"%s\"ì— ëŒ€í•œ ì •ê·œì‹ ì¼ì¹˜ 실패: %s" msgid "" "regular expression \"%s\" has no subexpressions as requested by " "backreference in \"%s\"" -msgstr "" -"\"%s\" ì •ê·œì‹ì—는 \"%s\"ì˜ backreferenceì—ì„œ ìš”ì²­ëœ í•˜ìœ„ ì‹ì´ ì—†ìŒ" +msgstr "\"%s\" ì •ê·œì‹ì—는 \"%s\"ì˜ backreferenceì—ì„œ ìš”ì²­ëœ í•˜ìœ„ ì‹ì´ ì—†ìŒ" #: libpq/hba.c:2127 #, c-format @@ -12212,7 +12291,8 @@ msgstr "ì œê³µëœ ì‚¬ìš©ìž ì´ë¦„(%s) ë° ì¸ì¦ëœ ì‚¬ìš©ìž ì´ë¦„(%s)ì´ ì¼ #: libpq/hba.c:2147 #, c-format msgid "no match in usermap \"%s\" for user \"%s\" authenticated as \"%s\"" -msgstr "\"%s\" 사용ìžë§µ 파ì¼ì— \"%s\" 사용ìžë¥¼ \"%s\" 사용ìžë¡œ ì¸ì¦í•  ì„¤ì •ì´ ì—†ìŒ" +msgstr "" +"\"%s\" 사용ìžë§µ 파ì¼ì— \"%s\" 사용ìžë¥¼ \"%s\" 사용ìžë¡œ ì¸ì¦í•  ì„¤ì •ì´ ì—†ìŒ" #: libpq/hba.c:2182 #, c-format @@ -12483,8 +12563,8 @@ msgstr " -N MAX-CONNECT 최대 ë™ì‹œ ì—°ê²° 개수\n" msgid "" " -o OPTIONS pass \"OPTIONS\" to each server process (obsolete)\n" msgstr "" -" -o OPTIONS 개별 서버 프로세스를 \"OPTIONS\" 옵션으로 실행 " -"(옛기능)\n" +" -o OPTIONS 개별 서버 프로세스를 \"OPTIONS\" 옵션으로 실행 (옛기" +"능)\n" #: main/main.c:346 #, c-format @@ -12539,7 +12619,8 @@ msgstr " -f s|i|n|m|h 쿼리최ì í™”ê¸°ì˜ ê¸°ëŠ¥ì„ ì œí•œ 함\n" #, c-format msgid "" " -n do not reinitialize shared memory after abnormal exit\n" -msgstr " -n 비정ìƒì  종료 ë’¤ì— ê³µìœ  메모리를 초기화 하지 ì•ŠìŒ\n" +msgstr "" +" -n 비정ìƒì  종료 ë’¤ì— ê³µìœ  메모리를 초기화 하지 ì•ŠìŒ\n" #: main/main.c:357 #, c-format @@ -12567,7 +12648,8 @@ msgstr "" #: main/main.c:361 #, c-format msgid " -W NUM wait NUM seconds to allow attach from a debugger\n" -msgstr " -W NUM 디버그 ìž‘ì—…ì„ ìœ„í•´ 지정한 숫ìžì˜ ì´ˆë§Œí¼ ê¸°ë‹¤ë¦°ë‹¤\n" +msgstr "" +" -W NUM 디버그 ìž‘ì—…ì„ ìœ„í•´ 지정한 숫ìžì˜ ì´ˆë§Œí¼ ê¸°ë‹¤ë¦°ë‹¤\n" #: main/main.c:363 #, c-format @@ -12582,8 +12664,7 @@ msgstr "" #, c-format msgid "" " --single selects single-user mode (must be first argument)\n" -msgstr "" -" --single ë‹¨ì¼ ì‚¬ìš©ìž ëª¨ë“œ ì„ íƒ (ì¸ìžì˜ 첫번째로 와야함)\n" +msgstr " --single ë‹¨ì¼ ì‚¬ìš©ìž ëª¨ë“œ ì„ íƒ (ì¸ìžì˜ 첫번째로 와야함)\n" #: main/main.c:365 #, c-format @@ -12611,7 +12692,9 @@ msgstr "" #: main/main.c:369 main/main.c:374 #, c-format msgid " -r FILENAME send stdout and stderr to given file\n" -msgstr " -r FILENAME stdout, stderr 쪽으로 보내는 ë‚´ìš©ì„ FILENAME 파ì¼ë¡œ 저장함\n" +msgstr "" +" -r FILENAME stdout, stderr 쪽으로 보내는 ë‚´ìš©ì„ FILENAME 파ì¼ë¡œ 저장" +"함\n" #: main/main.c:371 #, c-format @@ -12626,16 +12709,14 @@ msgstr "" #, c-format msgid "" " --boot selects bootstrapping mode (must be first argument)\n" -msgstr "" -" --boot 부트스트랩 모드로 실행 (첫번째 ì¸ìžë¡œ 와야함)\n" +msgstr " --boot 부트스트랩 모드로 실행 (첫번째 ì¸ìžë¡œ 와야함)\n" #: main/main.c:373 #, c-format msgid "" " DBNAME database name (mandatory argument in bootstrapping " "mode)\n" -msgstr "" -" DBNAME ë°ì´í„°ë² ì´ìŠ¤ ì´ë¦„ (부트스트랩 모드ì—ì„œ 필수)\n" +msgstr " DBNAME ë°ì´í„°ë² ì´ìŠ¤ ì´ë¦„ (부트스트랩 모드ì—ì„œ 필수)\n" #: main/main.c:375 #, c-format @@ -12711,14 +12792,17 @@ msgstr "ìžë£Œí˜• %s ì— ëŒ€í•´ì„œëŠ” ë°°ì—´ ìžë£Œí˜•ì„ 사용할 수 없습 #: optimizer/path/allpaths.c:2653 #, c-format msgid "WHERE CURRENT OF is not supported on a view with no underlying relation" -msgstr "no underlying 릴레ì´ì…˜ì´ 있는 ë·°ì—서는 WHERE CURRENT OF êµ¬ë¬¸ì„ ì§€ì›í•˜ì§€ ì•ŠìŒ" +msgstr "" +"no underlying 릴레ì´ì…˜ì´ 있는 ë·°ì—서는 WHERE CURRENT OF êµ¬ë¬¸ì„ ì§€ì›í•˜ì§€ ì•ŠìŒ" #: optimizer/path/allpaths.c:2658 #, c-format msgid "" "WHERE CURRENT OF is not supported on a view with more than one underlying " "relation" -msgstr "WHERE CURRENT OF ì˜µì…˜ì€ í•˜ë‚˜ ì´ìƒì˜ 릴레ì´ì…˜ì„ 사용하는 ë·°ì—서는 사용할 수 ì—†ìŒ" +msgstr "" +"WHERE CURRENT OF ì˜µì…˜ì€ í•˜ë‚˜ ì´ìƒì˜ 릴레ì´ì…˜ì„ 사용하는 ë·°ì—서는 사용할 수 ì—†" +"ìŒ" #: optimizer/path/allpaths.c:2663 #, c-format @@ -12732,60 +12816,58 @@ msgid "" "FULL JOIN is only supported with merge-joinable or hash-joinable join " "conditions" msgstr "" -"FULL JOIN êµ¬ë¬¸ì€ ë¨¸ì§€ ì¡°ì¸ì´ë‚˜, í•´ì‹œ ì¡°ì¸ì´ 가능한 ìƒí™©ì—서만 " -"사용할 수 있습니다" +"FULL JOIN êµ¬ë¬¸ì€ ë¨¸ì§€ ì¡°ì¸ì´ë‚˜, í•´ì‹œ ì¡°ì¸ì´ 가능한 ìƒí™©ì—서만 사용할 수 있습" +"니다" #. translator: %s is a SQL row locking clause such as FOR UPDATE #: optimizer/plan/initsplan.c:1124 #, c-format msgid "%s cannot be applied to the nullable side of an outer join" msgstr "" -"%s êµ¬ë¬¸ì€ outer ì¡°ì¸ìœ¼ë¡œ null ê°’ì´ ì˜¬ 수 있는 ìª½ì— ëŒ€í•´ì„œëŠ” ì ìš©í•  " -"수 없습니다" +"%s êµ¬ë¬¸ì€ outer ì¡°ì¸ìœ¼ë¡œ null ê°’ì´ ì˜¬ 수 있는 ìª½ì— ëŒ€í•´ì„œëŠ” ì ìš©í•  수 없습니" +"다" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: optimizer/plan/planner.c:1497 parser/analyze.c:1552 parser/analyze.c:1750 -#: parser/analyze.c:2531 +#: optimizer/plan/planner.c:1480 parser/analyze.c:1549 parser/analyze.c:1747 +#: parser/analyze.c:2528 #, c-format msgid "%s is not allowed with UNION/INTERSECT/EXCEPT" msgstr "%s êµ¬ë¬¸ì€ UNION/INTERSECT/EXCEPT 예약어들과 함께 사용할 수 없습니다." -#: optimizer/plan/planner.c:3826 +#: optimizer/plan/planner.c:3809 #, c-format msgid "could not implement GROUP BY" msgstr "GROUP BY를 구현할 수 ì—†ìŒ" -#: optimizer/plan/planner.c:3827 optimizer/plan/planner.c:4220 +#: optimizer/plan/planner.c:3810 optimizer/plan/planner.c:4203 #: optimizer/prep/prepunion.c:929 #, c-format msgid "" "Some of the datatypes only support hashing, while others only support " "sorting." -msgstr "" -"해싱만 지ì›í•˜ëŠ” ìžë£Œí˜•ë„ 있고, 정렬만 지ì›í•˜ëŠ” ìžë£Œí˜•ë„ " -"있습니다." +msgstr "해싱만 지ì›í•˜ëŠ” ìžë£Œí˜•ë„ 있고, 정렬만 지ì›í•˜ëŠ” ìžë£Œí˜•ë„ 있습니다." -#: optimizer/plan/planner.c:4219 +#: optimizer/plan/planner.c:4202 #, c-format msgid "could not implement DISTINCT" msgstr "DISTINCT를 구현할 수 ì—†ìŒ" -#: optimizer/plan/planner.c:4849 +#: optimizer/plan/planner.c:4832 #, c-format msgid "could not implement window PARTITION BY" msgstr "ì°½ PARTITION BY를 구현할 수 ì—†ìŒ" -#: optimizer/plan/planner.c:4850 +#: optimizer/plan/planner.c:4833 #, c-format msgid "Window partitioning columns must be of sortable datatypes." msgstr "ì°½ 분할 ì—´ì€ ì •ë ¬ 가능한 ë°ì´í„° 형ì‹ì´ì–´ì•¼ 합니다." -#: optimizer/plan/planner.c:4854 +#: optimizer/plan/planner.c:4837 #, c-format msgid "could not implement window ORDER BY" msgstr "ì°½ ORDER BY를 구현할 수 ì—†ìŒ" -#: optimizer/plan/planner.c:4855 +#: optimizer/plan/planner.c:4838 #, c-format msgid "Window ordering columns must be of sortable datatypes." msgstr "ì°½ 순서 지정 ì—´ì€ ì •ë ¬ 가능한 ë°ì´í„° 형ì‹ì´ì–´ì•¼ 합니다." @@ -12811,32 +12893,32 @@ msgstr "모든 ì—´ ë°ì´í„° 형ì‹ì€ í•´ì‹œ 가능해야 합니다." msgid "could not implement %s" msgstr "%s êµ¬ë¬¸ì€ êµ¬í˜„í•  수 ì—†ìŒ" -#: optimizer/util/clauses.c:4624 +#: optimizer/util/clauses.c:4634 #, c-format msgid "SQL function \"%s\" during inlining" msgstr "" -#: optimizer/util/plancat.c:113 +#: optimizer/util/plancat.c:114 #, c-format msgid "cannot access temporary or unlogged relations during recovery" msgstr "복구 ìž‘ì—… 중ì—는 ìž„ì‹œ í…Œì´ë¸”ì´ë‚˜, 언로그드 í…Œì´ë¸”ì„ ì ‘ê·¼í•  수 ì—†ìŒ" -#: optimizer/util/plancat.c:598 +#: optimizer/util/plancat.c:611 #, c-format msgid "whole row unique index inference specifications are not supported" msgstr "" -#: optimizer/util/plancat.c:615 +#: optimizer/util/plancat.c:628 #, c-format msgid "constraint in ON CONFLICT clause has no associated index" msgstr "ON CONFLICT 처리를 위해 ê´€ë ¨ëœ ì¸ë±ìŠ¤ê°€ 없습니다" -#: optimizer/util/plancat.c:666 +#: optimizer/util/plancat.c:679 #, c-format msgid "ON CONFLICT DO UPDATE not supported with exclusion constraints" msgstr "제외 제약 ì¡°ê±´ì´ ìžˆì–´ ON CONFLICT DO UPDATE ìž‘ì—…ì€ í•  수 없습니다" -#: optimizer/util/plancat.c:771 +#: optimizer/util/plancat.c:784 #, c-format msgid "" "there is no unique or exclusion constraint matching the ON CONFLICT " @@ -12844,7 +12926,7 @@ msgid "" msgstr "" "ON CONFLICT ì ˆì„ ì‚¬ìš©í•˜ëŠ” 경우, unique 나 exclude 제약 ì¡°ê±´ì´ ìžˆì–´ì•¼ 함" -#: parser/analyze.c:663 parser/analyze.c:1324 +#: parser/analyze.c:663 parser/analyze.c:1321 #, c-format msgid "VALUES lists must all be the same length" msgstr "VALUES 목ë¡ì€ ëª¨ë‘ ê°™ì€ ê¸¸ì´ì—¬ì•¼ 함" @@ -12867,184 +12949,186 @@ msgid "" "columns expected by the INSERT. Did you accidentally use extra parentheses?" msgstr "" -#: parser/analyze.c:1145 parser/analyze.c:1525 +#: parser/analyze.c:1142 parser/analyze.c:1522 #, c-format msgid "SELECT ... INTO is not allowed here" msgstr "SELECT ... INTO êµ¬ë¬¸ì€ ì—¬ê¸°ì„œëŠ” 사용할 수 ì—†ìŒ" -#: parser/analyze.c:1338 +#: parser/analyze.c:1335 #, c-format msgid "DEFAULT can only appear in a VALUES list within INSERT" msgstr "DEFAULT는 INSERT ë‚´ì˜ VALUES 목ë¡ì—만 í‘œì‹œë  ìˆ˜ 있ìŒ" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:1457 parser/analyze.c:2701 +#: parser/analyze.c:1454 parser/analyze.c:2698 #, c-format msgid "%s cannot be applied to VALUES" msgstr "%s êµ¬ë¬¸ì€ VALUES ì— ì ìš©í•  수 ì—†ìŒ" -#: parser/analyze.c:1678 +#: parser/analyze.c:1675 #, c-format msgid "invalid UNION/INTERSECT/EXCEPT ORDER BY clause" msgstr "UNION/INTERSECT/EXCEPT ORDER BY ì ˆì´ ìž˜ëª»ë¨" -#: parser/analyze.c:1679 +#: parser/analyze.c:1676 #, c-format msgid "Only result column names can be used, not expressions or functions." msgstr "ê²°ê³¼ ì—´ ì´ë¦„만 사용할 수 있고 ì‹ ë˜ëŠ” 함수는 사용할 수 없습니다." -#: parser/analyze.c:1680 +#: parser/analyze.c:1677 #, c-format msgid "" "Add the expression/function to every SELECT, or move the UNION into a FROM " "clause." -msgstr "" -"모든 SELECTì— ì‹/함수를 추가하거나 UNIONì„ FROM 절로 ì´ë™í•˜ì‹­ì‹œì˜¤." +msgstr "모든 SELECTì— ì‹/함수를 추가하거나 UNIONì„ FROM 절로 ì´ë™í•˜ì‹­ì‹œì˜¤." -#: parser/analyze.c:1740 +#: parser/analyze.c:1737 #, c-format msgid "INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT" msgstr "INTO 는 UNION/INTERSECT/EXCEPT ì˜ ì²«ë²ˆì§¸ SELECT ì—만 허용ëœë‹¤" -#: parser/analyze.c:1804 +#: parser/analyze.c:1801 #, c-format msgid "" "UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of " "same query level" msgstr "" -"UNION/INTERSECT/EXCEPT 멤버 문ì—ì„œ ê°™ì€ ì¿¼ë¦¬ ìˆ˜ì¤€ì˜ ë‹¤ë¥¸ 관계를 ì°¸" -"ì¡°í•  수 ì—†ìŒ" +"UNION/INTERSECT/EXCEPT 멤버 문ì—ì„œ ê°™ì€ ì¿¼ë¦¬ ìˆ˜ì¤€ì˜ ë‹¤ë¥¸ 관계를 참조할 수 ì—†" +"ìŒ" -#: parser/analyze.c:1893 +#: parser/analyze.c:1890 #, c-format msgid "each %s query must have the same number of columns" msgstr "ê°ê°ì˜ %s query 는 ê°™ì€ ìˆ˜ì˜ columns 를 가져야 한다." -#: parser/analyze.c:2286 +#: parser/analyze.c:2283 #, c-format msgid "RETURNING must have at least one column" msgstr "RETURNING ì ˆì—는 ì ì–´ë„ 하나 ì´ìƒì˜ ì¹¼ëŸ¼ì´ ìžˆì–´ì•¼ 합니다" -#: parser/analyze.c:2323 +#: parser/analyze.c:2320 #, c-format msgid "cannot specify both SCROLL and NO SCROLL" msgstr "SCROLL ê³¼ NO SCROLL 둘다를 명시할 수 없다" -#: parser/analyze.c:2341 +#: parser/analyze.c:2338 #, c-format msgid "DECLARE CURSOR must not contain data-modifying statements in WITH" -msgstr "DECLARE CURSOR 구문ì—ì„œ 사용하는 WITH ì ˆ 안ì—는 ìžë£Œ 변경 êµ¬ë¬¸ì´ ì—†ì–´ì•¼ 합니다" +msgstr "" +"DECLARE CURSOR 구문ì—ì„œ 사용하는 WITH ì ˆ 안ì—는 ìžë£Œ 변경 êµ¬ë¬¸ì´ ì—†ì–´ì•¼ 합니" +"다" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2349 +#: parser/analyze.c:2346 #, c-format msgid "DECLARE CURSOR WITH HOLD ... %s is not supported" msgstr "DECLARE CURSOR WITH HOLD ... %s êµ¬ë¬¸ì€ ì§€ì›ë˜ì§€ ì•ŠìŒ" -#: parser/analyze.c:2352 +#: parser/analyze.c:2349 #, c-format msgid "Holdable cursors must be READ ONLY." msgstr "보류 가능 커서는 READ ONLY여야 합니다." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2360 +#: parser/analyze.c:2357 #, c-format msgid "DECLARE SCROLL CURSOR ... %s is not supported" msgstr "DECLARE SCROLL CURSOR ... %s êµ¬ë¬¸ì€ ì§€ì›ë˜ì§€ ì•ŠìŒ" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2371 +#: parser/analyze.c:2368 #, c-format msgid "DECLARE INSENSITIVE CURSOR ... %s is not supported" msgstr "DECLARE INSENSITIVE CURSOR ... %s êµ¬ë¬¸ì€ ì§€ì›ë˜ì§€ ì•ŠìŒ" -#: parser/analyze.c:2374 +#: parser/analyze.c:2371 #, c-format msgid "Insensitive cursors must be READ ONLY." msgstr "민ê°í•˜ì§€ ì•Šì€ ì»¤ì„œëŠ” READ ONLY여야 합니다." -#: parser/analyze.c:2440 +#: parser/analyze.c:2437 #, c-format msgid "materialized views must not use data-modifying statements in WITH" -msgstr "êµ¬ì²´í™”ëœ ë·° ì •ì˜ì— 사용한 WITH ì ˆ 안ì—는 ìžë£Œ 변경 êµ¬ë¬¸ì´ ì—†ì–´ì•¼ 합니다" +msgstr "" +"êµ¬ì²´í™”ëœ ë·° ì •ì˜ì— 사용한 WITH ì ˆ 안ì—는 ìžë£Œ 변경 êµ¬ë¬¸ì´ ì—†ì–´ì•¼ 합니다" -#: parser/analyze.c:2450 +#: parser/analyze.c:2447 #, c-format msgid "materialized views must not use temporary tables or views" msgstr "êµ¬ì²´í™”ëœ ë·°ëŠ” ìž„ì‹œ í…Œì´ë¸”ì´ë‚˜ 뷰를 사용할 수 없습니다" -#: parser/analyze.c:2460 +#: parser/analyze.c:2457 #, c-format msgid "materialized views may not be defined using bound parameters" msgstr "" -#: parser/analyze.c:2472 +#: parser/analyze.c:2469 #, c-format msgid "materialized views cannot be UNLOGGED" msgstr "êµ¬ì²´í™”ëœ ë·°ëŠ” UNLOGGED ì˜µì…˜ì„ ì‚¬ìš©í•  수 없습니다." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2538 +#: parser/analyze.c:2535 #, c-format msgid "%s is not allowed with DISTINCT clause" msgstr "%s ì ˆì€ DISTINCT 절과 함께 사용할 수 없습니다" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2545 +#: parser/analyze.c:2542 #, c-format msgid "%s is not allowed with GROUP BY clause" msgstr "%s ì ˆì€ GROUP BY 절과 함께 사용할 수 없습니다" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2552 +#: parser/analyze.c:2549 #, c-format msgid "%s is not allowed with HAVING clause" msgstr "%s ì ˆì€ HAVING 절과 함께 사용할 수 없습니다" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2559 +#: parser/analyze.c:2556 #, c-format msgid "%s is not allowed with aggregate functions" msgstr "%s ì ˆì€ ì§‘ê³„ 함수와 함께 사용할 수 없습니다" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2566 +#: parser/analyze.c:2563 #, c-format msgid "%s is not allowed with window functions" msgstr "%s ì ˆì€ ìœˆë„ìš° 함수와 함께 사용할 수 없습니다" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2573 +#: parser/analyze.c:2570 #, c-format msgid "%s is not allowed with set-returning functions in the target list" msgstr "%s ì ˆì€ ëŒ€ìƒ ëª©ë¡ì—ì„œ 세트 반환 함수와 함께 사용할 수 없습니다." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2652 +#: parser/analyze.c:2649 #, c-format msgid "%s must specify unqualified relation names" msgstr "%s ì ˆì—는 unqualified 릴레ì´ì…˜ ì´ë¦„ì„ ì§€ì •í•´ì•¼ 합니다." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2683 +#: parser/analyze.c:2680 #, c-format msgid "%s cannot be applied to a join" msgstr "%s ì ˆì€ ì¡°ì¸ì„ ì ìš©í•  수 없습니다." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2692 +#: parser/analyze.c:2689 #, c-format msgid "%s cannot be applied to a function" msgstr "%s ì ˆì€ í•¨ìˆ˜ì— ì ìš©í•  수 없습니다." #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2710 +#: parser/analyze.c:2707 #, c-format msgid "%s cannot be applied to a WITH query" msgstr "%s ì ˆì€ WITH ì¿¼ë¦¬ì— ì ìš©í•  수 ì—†ìŒ" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: parser/analyze.c:2727 +#: parser/analyze.c:2724 #, c-format msgid "relation \"%s\" in %s clause not found in FROM clause" msgstr "\"%s\" 릴레ì´ì…˜ (ëŒ€ìƒ êµ¬ë¬¸: %s) ì´ FROM ì ˆ ë‚´ì— ì—†ìŠµë‹ˆë‹¤" @@ -13057,7 +13141,8 @@ msgstr "%s ìžë£Œí˜•ì—ì„œ 사용할 순서 정하는 ì—°ì‚°ìžë¥¼ ì°¾ì„ ìˆ˜ #: parser/parse_agg.c:225 #, c-format msgid "Aggregates with DISTINCT must be able to sort their inputs." -msgstr "DISTINCT와 함께 작업하는 집계 ìž‘ì—…ì€ ê·¸ ìž…ë ¥ ìžë£Œê°€ ì •ë ¬ë  ìˆ˜ 있어야 합니다" +msgstr "" +"DISTINCT와 함께 작업하는 집계 ìž‘ì—…ì€ ê·¸ ìž…ë ¥ ìžë£Œê°€ ì •ë ¬ë  ìˆ˜ 있어야 합니다" #: parser/parse_agg.c:260 #, c-format @@ -13075,8 +13160,7 @@ msgstr "JOIN 조건문ì—서는 그룹핑 ì—°ì‚°ì´ í—ˆìš©ë˜ì§€ 않습니다" #: parser/parse_agg.c:377 msgid "" "aggregate functions are not allowed in FROM clause of their own query level" -msgstr "" -"집계 함수는 ìžì‹ ì˜ 쿼리 ìˆ˜ì¤€ì˜ FROM ì ˆì—서는 사용할 수 없습니다." +msgstr "집계 함수는 ìžì‹ ì˜ 쿼리 ìˆ˜ì¤€ì˜ FROM ì ˆì—서는 사용할 수 없습니다." #: parser/parse_agg.c:379 msgid "" @@ -13439,8 +13523,8 @@ msgid "" "in an aggregate with DISTINCT, ORDER BY expressions must appear in argument " "list" msgstr "" -"DISTINCT, ORDER BY 표현ì‹ì„ 집계 함수와 쓸 때는, 반드시 select list ì— ë‚˜íƒ€ë‚˜ì•¼ë§Œ í•©" -"니다" +"DISTINCT, ORDER BY 표현ì‹ì„ 집계 함수와 쓸 때는, 반드시 select list ì— ë‚˜íƒ€ë‚˜" +"야만 합니다" #: parser/parse_clause.c:2563 #, c-format @@ -13494,7 +13578,9 @@ msgstr "ON CONFLICT ì ˆì€ ì‹œìŠ¤í…œ 카탈로그 í…Œì´ë¸”ì—서는 사용할 #: parser/parse_clause.c:2880 #, c-format msgid "ON CONFLICT is not supported on table \"%s\" used as a catalog table" -msgstr "\"%s\" í…Œì´ë¸”ì—는 ON CONFLICT ê¸°ëŠ¥ì„ ì‚¬ìš©í•  수 없습니다. ì´ í…Œì´ë¸”ì€ ì¹´íƒˆë¡œê·¸ í…Œì´ë¸”ë¡œ 사용ë©ë‹ˆë‹¤." +msgstr "" +"\"%s\" í…Œì´ë¸”ì—는 ON CONFLICT ê¸°ëŠ¥ì„ ì‚¬ìš©í•  수 없습니다. ì´ í…Œì´ë¸”ì€ ì¹´íƒˆë¡œ" +"ê·¸ í…Œì´ë¸”ë¡œ 사용ë©ë‹ˆë‹¤." #: parser/parse_clause.c:3012 #, c-format @@ -13510,7 +13596,7 @@ msgstr "" #: parser/parse_coerce.c:971 parser/parse_coerce.c:1001 #: parser/parse_coerce.c:1019 parser/parse_coerce.c:1034 -#: parser/parse_expr.c:2053 parser/parse_expr.c:2577 parser/parse_target.c:874 +#: parser/parse_expr.c:2053 parser/parse_expr.c:2577 parser/parse_target.c:885 #, c-format msgid "cannot cast type %s to %s" msgstr "%s ìžë£Œí˜•ì„ %s ìžë£Œí˜•ìœ¼ë¡œ 형변환할 수 없습니다." @@ -13629,7 +13715,8 @@ msgstr "ìžë£Œí˜• %s ì— ëŒ€í•´ì„œëŠ” ë°°ì—´ ìžë£Œí˜•ì„ 사용할 수 없습 #: parser/parse_collate.c:986 #, c-format msgid "collation mismatch between implicit collations \"%s\" and \"%s\"" -msgstr "암묵ì ìœ¼ë¡œ ì„ íƒëœ \"%s\" ì •ë ¬ 규칙와 \"%s\" ì •ë ¬ ê·œì¹™ì´ ë§¤ì¹­ë˜ì§€ 않습니다" +msgstr "" +"암묵ì ìœ¼ë¡œ ì„ íƒëœ \"%s\" ì •ë ¬ 규칙와 \"%s\" ì •ë ¬ ê·œì¹™ì´ ë§¤ì¹­ë˜ì§€ 않습니다" #: parser/parse_collate.c:231 parser/parse_collate.c:478 #: parser/parse_collate.c:989 @@ -13642,15 +13729,15 @@ msgstr "í•œ 쪽 ë˜ëŠ” 서로 COLLATE ì ˆì„ ì´ìš©í•´ ì •ë ¬ ê·œì¹™ì„ ì§€ì • #: parser/parse_collate.c:834 #, c-format msgid "collation mismatch between explicit collations \"%s\" and \"%s\"" -msgstr "명시ì ìœ¼ë¡œ 지정한 \"%s\" 정렬규칙와 \"%s\" ì •ë ¬ê·œì¹™ì´ ë§¤ì¹­ë˜ì§€ 않습니다" +msgstr "" +"명시ì ìœ¼ë¡œ 지정한 \"%s\" 정렬규칙와 \"%s\" ì •ë ¬ê·œì¹™ì´ ë§¤ì¹­ë˜ì§€ 않습니다" #: parser/parse_cte.c:42 #, c-format msgid "" "recursive reference to query \"%s\" must not appear within its non-recursive " "term" -msgstr "" -"\"%s\" ì¿¼ë¦¬ì— ëŒ€í•œ 재귀 참조가 비재귀 구문 안ì—는 없어야 함" +msgstr "\"%s\" ì¿¼ë¦¬ì— ëŒ€í•œ 재귀 참조가 비재귀 구문 안ì—는 없어야 함" #: parser/parse_cte.c:44 #, c-format @@ -13690,8 +13777,8 @@ msgid "" "recursive query \"%s\" column %d has type %s in non-recursive term but type " "%s overall" msgstr "" -"\"%s\" 재귀 ì¿¼ë¦¬ì˜ %d 번째 ì¹¼ëŸ¼ì€ ë¹„ìž¬ê·€ ì¡°ê±´ì— %s ìžë£Œí˜•ì„ í¬í•¨í•˜ëŠ”ë° ì „ì²´ì ìœ¼ë¡œ" -"는 %s ìžë£Œí˜•ìž„" +"\"%s\" 재귀 ì¿¼ë¦¬ì˜ %d 번째 ì¹¼ëŸ¼ì€ ë¹„ìž¬ê·€ ì¡°ê±´ì— %s ìžë£Œí˜•ì„ í¬í•¨í•˜ëŠ”ë° ì „ì²´ì " +"으로는 %s ìžë£Œí˜•ìž„" #: parser/parse_cte.c:319 #, c-format @@ -13704,8 +13791,8 @@ msgid "" "recursive query \"%s\" column %d has collation \"%s\" in non-recursive term " "but collation \"%s\" overall" msgstr "" -"\"%s\" 재귀 ì¿¼ë¦¬ì˜ %d 번째 ì¹¼ëŸ¼ì€ ë¹„ìž¬ê·€ ì¡°ê±´ì— %s ìžë£Œí˜•ì„ í¬í•¨í•˜ëŠ”ë° ì „ì²´ì ìœ¼ë¡œ" -"는 %s ìžë£Œí˜•ìž„" +"\"%s\" 재귀 ì¿¼ë¦¬ì˜ %d 번째 ì¹¼ëŸ¼ì€ ë¹„ìž¬ê·€ ì¡°ê±´ì— %s ìžë£Œí˜•ì„ í¬í•¨í•˜ëŠ”ë° ì „ì²´ì " +"으로는 %s ìžë£Œí˜•ìž„" #: parser/parse_cte.c:328 #, c-format @@ -13715,7 +13802,8 @@ msgstr "" #: parser/parse_cte.c:419 #, c-format msgid "WITH query \"%s\" has %d columns available but %d columns specified" -msgstr "\"%s\" WITH 쿼리ì—는 %dê°œì˜ ì¹¼ëŸ¼ì„ ì‚¬ìš©í•  수 ìžˆëŠ”ë° %dê°œì˜ ì¹¼ëŸ¼ì´ ì§€ì •ë¨" +msgstr "" +"\"%s\" WITH 쿼리ì—는 %dê°œì˜ ì¹¼ëŸ¼ì„ ì‚¬ìš©í•  수 ìžˆëŠ”ë° %dê°œì˜ ì¹¼ëŸ¼ì´ ì§€ì •ë¨" #: parser/parse_cte.c:599 #, c-format @@ -13732,8 +13820,7 @@ msgstr "\"%s\" 재귀 ì¿¼ë¦¬ì— ìžë£Œ 변경 êµ¬ë¬¸ì´ í¬í•¨ë  수 없습니 msgid "" "recursive query \"%s\" does not have the form non-recursive-term UNION [ALL] " "recursive-term" -msgstr "" -"\"%s\" 재귀 ì¿¼ë¦¬ì— ë¹„ìž¬ê·€ ì¡°ê±´ í˜•íƒœì˜ UNION [ALL] 재귀 ì¡°ê±´ì´ ì—†ìŒ" +msgstr "\"%s\" 재귀 ì¿¼ë¦¬ì— ë¹„ìž¬ê·€ ì¡°ê±´ í˜•íƒœì˜ UNION [ALL] 재귀 ì¡°ê±´ì´ ì—†ìŒ" #: parser/parse_cte.c:703 #, c-format @@ -13760,8 +13847,8 @@ msgstr "재귀 ì¿¼ë¦¬ì˜ FOR UPDATE/SHAREê°€ 구현ë˜ì§€ ì•ŠìŒ" msgid "recursive reference to query \"%s\" must not appear more than once" msgstr "\"%s\" ì¿¼ë¦¬ì— ëŒ€í•œ 재귀 참조가 여러 번 표시ë˜ì§€ 않아야 함" -#: parser/parse_expr.c:390 parser/parse_relation.c:3083 -#: parser/parse_relation.c:3103 +#: parser/parse_expr.c:390 parser/parse_relation.c:3176 +#: parser/parse_relation.c:3196 #, c-format msgid "column %s.%s does not exist" msgstr "%s.%s 칼럼 ì—†ìŒ" @@ -13782,13 +13869,13 @@ msgid "column notation .%s applied to type %s, which is not a composite type" msgstr "" ".%s í‘œí˜„ì´ %s ìžë£Œí˜• 사용ë˜ì—ˆëŠ”ë°, ì´ëŠ” 복소수형 (complex type)ì´ ì•„ë‹™ë‹ˆë‹¤" -#: parser/parse_expr.c:444 parser/parse_target.c:660 +#: parser/parse_expr.c:444 parser/parse_target.c:671 #, c-format msgid "row expansion via \"*\" is not supported here" msgstr "\"*\"를 통한 칼럼 í™•ìž¥ì€ ì—¬ê¸°ì„œ 지ì›ë˜ì§€ ì•ŠìŒ" -#: parser/parse_expr.c:770 parser/parse_relation.c:667 -#: parser/parse_relation.c:767 parser/parse_target.c:1109 +#: parser/parse_expr.c:770 parser/parse_relation.c:668 +#: parser/parse_relation.c:768 parser/parse_target.c:1120 #, c-format msgid "column reference \"%s\" is ambiguous" msgstr "칼럼 참조 \"%s\" ê°€ 모호합니다." @@ -14010,7 +14097,9 @@ msgstr "" #: parser/parse_func.c:455 #, c-format msgid "%s is not an ordered-set aggregate, so it cannot have WITHIN GROUP" -msgstr "%s 함수는 순사가 있는 세트 집계함수가 아니여서 WITHIN GROUP ì ˆì„ ì‚¬ìš©í•  수 없습니다" +msgstr "" +"%s 함수는 순사가 있는 세트 집계함수가 아니여서 WITHIN GROUP ì ˆì„ ì‚¬ìš©í•  수 ì—†" +"습니다" #: parser/parse_func.c:468 #, c-format @@ -14033,8 +14122,8 @@ msgid "" "Could not choose a best candidate function. You might need to add explicit " "type casts." msgstr "" -"ì œì¼ ì ë‹¹í•œ 함수를 ì„ íƒí•  수 없습니다. ëª…ì‹œì  í˜•ë³€í™˜ìžë¥¼ 추가해야 " -"í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤." +"ì œì¼ ì ë‹¹í•œ 함수를 ì„ íƒí•  수 없습니다. ëª…ì‹œì  í˜•ë³€í™˜ìžë¥¼ 추가해야 í•  ìˆ˜ë„ ìžˆ" +"습니다." #: parser/parse_func.c:510 #, c-format @@ -14043,9 +14132,9 @@ msgid "" "misplaced ORDER BY; ORDER BY must appear after all regular arguments of the " "aggregate." msgstr "" -"ì§€ì •ëœ ì´ë¦„ ë° ì¸ìž ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ëŠ” 집계 함수가 없습니다. ORDER BY ì ˆì„ " -"바른 ìœ„ì¹˜ì— ì“°ì§€ ì•Šì€ ê²ƒ 같습니다. ORDER BY ì ˆì€ ëª¨ë“  집계용 ì¸ìžë“¤ 맨 ë’¤ì— " -"있어야 합니다." +"ì§€ì •ëœ ì´ë¦„ ë° ì¸ìž ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ëŠ” 집계 함수가 없습니다. ORDER BY ì ˆì„ ë°”" +"른 ìœ„ì¹˜ì— ì“°ì§€ ì•Šì€ ê²ƒ 같습니다. ORDER BY ì ˆì€ ëª¨ë“  집계용 ì¸ìžë“¤ 맨 ë’¤ì— ìžˆ" +"어야 합니다." #: parser/parse_func.c:521 #, c-format @@ -14053,8 +14142,8 @@ msgid "" "No function matches the given name and argument types. You might need to add " "explicit type casts." msgstr "" -"ì§€ì •ëœ ì´ë¦„ ë° ì¸ìž ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ëŠ” 함수가 없습니다. ëª…ì‹œì  í˜•ë³€" -"환ìžë¥¼ 추가해야 í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤." +"ì§€ì •ëœ ì´ë¦„ ë° ì¸ìž ìžë£Œí˜•ê³¼ ì¼ì¹˜í•˜ëŠ” 함수가 없습니다. ëª…ì‹œì  í˜•ë³€í™˜ìžë¥¼ 추가" +"해야 í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤." #: parser/parse_func.c:623 #, c-format @@ -14145,9 +14234,9 @@ msgstr "" "명시ì ìœ¼ë¡œ 순차연산ìž(ordering operator) 를 사용하ë˜ì§€, ë˜ëŠ” query 를 수정하" "ë„ë¡ í•˜ì„¸ìš”." -#: parser/parse_oper.c:226 utils/adt/array_userfuncs.c:782 -#: utils/adt/array_userfuncs.c:920 utils/adt/arrayfuncs.c:3639 -#: utils/adt/arrayfuncs.c:4077 utils/adt/arrayfuncs.c:6051 +#: parser/parse_oper.c:226 utils/adt/array_userfuncs.c:794 +#: utils/adt/array_userfuncs.c:933 utils/adt/arrayfuncs.c:3639 +#: utils/adt/arrayfuncs.c:4077 utils/adt/arrayfuncs.c:6039 #: utils/adt/rowtypes.c:1167 #, c-format msgid "could not identify an equality operator for type %s" @@ -14170,8 +14259,8 @@ msgid "" "Could not choose a best candidate operator. You might need to add explicit " "type casts." msgstr "" -"가장 ì ë‹¹í•œ ì—°ì‚°ìžë¥¼ ì„ íƒí•  수 없습니다. ëª…ì‹œì  í˜•ë³€í™˜ìžë¥¼ 추가해" -"야 í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤." +"가장 ì ë‹¹í•œ ì—°ì‚°ìžë¥¼ ì„ íƒí•  수 없습니다. ëª…ì‹œì  í˜•ë³€í™˜ìžë¥¼ 추가해야 í•  ìˆ˜ë„ " +"있습니다." #: parser/parse_oper.c:724 #, c-format @@ -14179,8 +14268,8 @@ msgid "" "No operator matches the given name and argument type(s). You might need to " "add explicit type casts." msgstr "" -"ì§€ì •ëœ ì´ë¦„ ë° ì¸ìž 형ì‹ê³¼ ì¼ì¹˜í•˜ëŠ” ì—°ì‚°ìžê°€ 없습니다. ëª…ì‹œì  í˜•" -"변환ìžë¥¼ 추가해야 í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤." +"ì§€ì •ëœ ì´ë¦„ ë° ì¸ìž 형ì‹ê³¼ ì¼ì¹˜í•˜ëŠ” ì—°ì‚°ìžê°€ 없습니다. ëª…ì‹œì  í˜•ë³€í™˜ìžë¥¼ 추가" +"해야 í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤." #: parser/parse_oper.c:783 parser/parse_oper.c:897 #, c-format @@ -14207,69 +14296,66 @@ msgstr "op ANY/ALL (array) 는 set ì„ return 하지 않는 ì—°ì‚°ìžê°€ 요구 msgid "inconsistent types deduced for parameter $%d" msgstr "inconsistent types deduced for parameter $%d" -#: parser/parse_relation.c:174 +#: parser/parse_relation.c:175 #, c-format msgid "table reference \"%s\" is ambiguous" msgstr "í…Œì´ë¸” 참조 \"%s\" ê°€ 명확하지 않습니다 (ambiguous)." -#: parser/parse_relation.c:218 +#: parser/parse_relation.c:219 #, c-format msgid "table reference %u is ambiguous" msgstr "í…Œì´ë¸” 참조 %u ê°€ 명확하지 않습니다 (ambiguous)." -#: parser/parse_relation.c:397 +#: parser/parse_relation.c:398 #, c-format msgid "table name \"%s\" specified more than once" msgstr "í…Œì´ë¸” ì´ë¦„ \"%s\" ê°€ 한번 ì´ìƒ 명시ë˜ì–´ 있습니다." -#: parser/parse_relation.c:424 parser/parse_relation.c:3023 +#: parser/parse_relation.c:425 parser/parse_relation.c:3116 #, c-format msgid "invalid reference to FROM-clause entry for table \"%s\"" msgstr "\"%s\" í…Œì´ë¸”ì„ ì‚¬ìš©í•˜ëŠ” FROM ì ˆì— ëŒ€í•œ 참조가 잘못 ë˜ì—ˆìŠµë‹ˆë‹¤." -#: parser/parse_relation.c:427 parser/parse_relation.c:3028 +#: parser/parse_relation.c:428 parser/parse_relation.c:3121 #, c-format msgid "" "There is an entry for table \"%s\", but it cannot be referenced from this " "part of the query." msgstr "" -"\"%s\" í…Œì´ë¸”ì— ëŒ€í•œ í•­ëª©ì´ ìžˆì§€ë§Œ ì´ ì¿¼ë¦¬ 부분ì—ì„œ 참조할 수 없습" -"니다." +"\"%s\" í…Œì´ë¸”ì— ëŒ€í•œ í•­ëª©ì´ ìžˆì§€ë§Œ ì´ ì¿¼ë¦¬ 부분ì—ì„œ 참조할 수 없습니다." -#: parser/parse_relation.c:429 +#: parser/parse_relation.c:430 #, c-format msgid "The combining JOIN type must be INNER or LEFT for a LATERAL reference." msgstr "" -#: parser/parse_relation.c:705 +#: parser/parse_relation.c:706 #, c-format msgid "system column \"%s\" reference in check constraint is invalid" msgstr "제약 ì¡°ê±´ì—ì„œ 참조하는 \"%s\" 시스템 ì¹¼ëŸ¼ì´ ì—†ìŒ" -#: parser/parse_relation.c:1065 parser/parse_relation.c:1345 -#: parser/parse_relation.c:1847 +#: parser/parse_relation.c:1066 parser/parse_relation.c:1346 +#: parser/parse_relation.c:1848 #, c-format msgid "table \"%s\" has %d columns available but %d columns specified" msgstr "í…Œì´ë¸” \"%s\" ì—는 %d ê°œì˜ ì—´ì´ ìžˆëŠ”ë°, %d ê°œì˜ ì—´ë§Œì´ ëª…ì‹œë˜ì—ˆìŠµë‹ˆë‹¤." -#: parser/parse_relation.c:1152 +#: parser/parse_relation.c:1153 #, c-format msgid "" "There is a WITH item named \"%s\", but it cannot be referenced from this " "part of the query." -msgstr "" -"\"%s\"(ì´)ë¼ëŠ” WITH í•­ëª©ì´ ìžˆì§€ë§Œ ì´ ì¿¼ë¦¬ 부분ì—ì„œ 참조할 수 없습니" -"다." +msgstr "\"%s\"(ì´)ë¼ëŠ” WITH í•­ëª©ì´ ìžˆì§€ë§Œ ì´ ì¿¼ë¦¬ 부분ì—ì„œ 참조할 수 없습니다." -#: parser/parse_relation.c:1154 +#: parser/parse_relation.c:1155 #, c-format msgid "" "Use WITH RECURSIVE, or re-order the WITH items to remove forward references." msgstr "" -"WITH RECURSIVE를 사용하거나 WITH í•­ëª©ì˜ ìˆœì„œë¥¼ 변경하여 ì •ë°©í–¥ 참조를 ì œ" -"거하십시오." +"WITH RECURSIVE를 사용하거나 WITH í•­ëª©ì˜ ìˆœì„œë¥¼ 변경하여 ì •ë°©í–¥ 참조를 제거하" +"십시오." -#: parser/parse_relation.c:1465 +#: parser/parse_relation.c:1466 #, c-format msgid "" "a column definition list is only allowed for functions returning \"record\"" @@ -14277,91 +14363,91 @@ msgstr "" "ì—´ ì •ì˜ ë¦¬ìŠ¤íŠ¸ (column definition list) 는 오로지 \"record\" 를 리턴하는 함" "수 ë‚´ì—서만 허용ë©ë‹ˆë‹¤." -#: parser/parse_relation.c:1474 +#: parser/parse_relation.c:1475 #, c-format msgid "a column definition list is required for functions returning \"record\"" msgstr "" "ì—´ ì •ì˜ ë¦¬ìŠ¤íŠ¸(column definition list)는 \"record\" 를 리턴하는 함수를 í•„ìš”" "ë¡œ 합니다" -#: parser/parse_relation.c:1553 +#: parser/parse_relation.c:1554 #, c-format msgid "function \"%s\" in FROM has unsupported return type %s" msgstr "" "FROM ì ˆ ë‚´ì˜ í•¨ìˆ˜ \"%s\" ì— ì§€ì›ë˜ì§€ 않는 return ìžë£Œí˜• %s ì´ ìžˆìŠµë‹ˆë‹¤." -#: parser/parse_relation.c:1675 +#: parser/parse_relation.c:1676 #, c-format msgid "VALUES lists \"%s\" have %d columns available but %d columns specified" msgstr "" "VALUES ë’¤ì— ì˜¤ëŠ” \"%s\" 구문ì—는 %dê°œì˜ ì—´ì´ ìžˆëŠ”ë°, 지정한 ì—´ì€ %dê°œ 입니다" -#: parser/parse_relation.c:1730 +#: parser/parse_relation.c:1731 #, c-format msgid "joins can have at most %d columns" msgstr "ì¡°ì¸ì—는 최대 %dê°œì˜ ì¹¼ëŸ¼ì„ í¬í•¨í•  수 있ìŒ" -#: parser/parse_relation.c:1820 +#: parser/parse_relation.c:1821 #, c-format msgid "WITH query \"%s\" does not have a RETURNING clause" msgstr "" -#: parser/parse_relation.c:2652 parser/parse_relation.c:2807 +#: parser/parse_relation.c:2738 parser/parse_relation.c:2900 #, c-format msgid "column %d of relation \"%s\" does not exist" msgstr "%d번째 ì—´ì´ ì—†ìŠµë‹ˆë‹¤. 해당 릴레ì´ì…˜: \"%s\"" -#: parser/parse_relation.c:3026 +#: parser/parse_relation.c:3119 #, c-format msgid "Perhaps you meant to reference the table alias \"%s\"." msgstr "ì•„ \"%s\" alias를 참조해야 í•  것 같습니다." -#: parser/parse_relation.c:3034 +#: parser/parse_relation.c:3127 #, c-format msgid "missing FROM-clause entry for table \"%s\"" msgstr "í…Œì´ë¸” \"%s\"ì— FROM ì ˆì´ ë¹ ì ¸ 있습니다." -#: parser/parse_relation.c:3086 +#: parser/parse_relation.c:3179 #, c-format msgid "Perhaps you meant to reference the column \"%s.%s\"." msgstr "아마 \"%s.%s\" ì¹¼ëŸ¼ì„ ì°¸ì¡°í•˜ëŠ” 것 같습니다." -#: parser/parse_relation.c:3088 +#: parser/parse_relation.c:3181 #, c-format msgid "" "There is a column named \"%s\" in table \"%s\", but it cannot be referenced " "from this part of the query." msgstr "" -"\"%s\" ì´ë¦„ì˜ ì¹¼ëŸ¼ì´ \"%s\" í…Œì´ë¸”ì— ìžˆì§€ë§Œ, ì´ ì¿¼ë¦¬ì˜ ì´ ë¶€ë¶„ì—서는 " -"ì°¸ì¡°ë  ìˆ˜ 없습니다." +"\"%s\" ì´ë¦„ì˜ ì¹¼ëŸ¼ì´ \"%s\" í…Œì´ë¸”ì— ìžˆì§€ë§Œ, ì´ ì¿¼ë¦¬ì˜ ì´ ë¶€ë¶„ì—서는 ì°¸ì¡°ë  " +"수 없습니다." -#: parser/parse_relation.c:3105 +#: parser/parse_relation.c:3198 #, c-format msgid "" "Perhaps you meant to reference the column \"%s.%s\" or the column \"%s.%s\"." msgstr "아마 \"%s.%s\" 칼럼ì´ë‚˜ \"%s.%s\" ì¹¼ëŸ¼ì„ ì°¸ì¡°í•˜ëŠ” 것 같습니다." -#: parser/parse_target.c:421 parser/parse_target.c:713 +#: parser/parse_target.c:432 parser/parse_target.c:724 #, c-format msgid "cannot assign to system column \"%s\"" msgstr "시스템 ì—´ \"%s\"ì— í• ë‹¹í•  수 없습니다." -#: parser/parse_target.c:449 +#: parser/parse_target.c:460 #, c-format msgid "cannot set an array element to DEFAULT" msgstr "ë°°ì—´ 요소를 DEFAULT ë¡œ 설정할 수 없습니다." -#: parser/parse_target.c:454 +#: parser/parse_target.c:465 #, c-format msgid "cannot set a subfield to DEFAULT" msgstr "하위필드를 DEFAULTë¡œ 설정할 수 없습니다." -#: parser/parse_target.c:523 +#: parser/parse_target.c:534 #, c-format msgid "column \"%s\" is of type %s but expression is of type %s" msgstr "ì—´ \"%s\"ì€(는) %s ìžë£Œí˜•ì¸ë° 표현ì‹ì€ %s ìžë£Œí˜•ìž…니다." -#: parser/parse_target.c:697 +#: parser/parse_target.c:708 #, c-format msgid "" "cannot assign to field \"%s\" of column \"%s\" because its type %s is not a " @@ -14370,7 +14456,7 @@ msgstr "" "\"%s\" í•„ë“œ (ëŒ€ìƒ ì—´ \"%s\")를 지정할 수 ì—†ìŒ, %s ìžë£Œí˜•ì€ 복합ìžë£Œí˜•ì´ 아니" "기 때문" -#: parser/parse_target.c:706 +#: parser/parse_target.c:717 #, c-format msgid "" "cannot assign to field \"%s\" of column \"%s\" because there is no such " @@ -14379,19 +14465,19 @@ msgstr "" "\"%s\" í•„ë“œ (ëŒ€ìƒ ì—´ \"%s\")를 지정할 수 ì—†ìŒ, %s ìžë£Œí˜•ì—ì„œ 그런 ì—´ì„ ì°¾ì„ " "수 ì—†ìŒ" -#: parser/parse_target.c:773 +#: parser/parse_target.c:784 #, c-format msgid "" "array assignment to \"%s\" requires type %s but expression is of type %s" msgstr "" "\"%s\" ì—´ì— ì‚¬ìš©ëœ ìžë£Œí˜•ì€ %s ê°€ 필요하지만, 현재 표현ì‹ì´ %s ìžë£Œí˜•ìž…니다" -#: parser/parse_target.c:783 +#: parser/parse_target.c:794 #, c-format msgid "subfield \"%s\" is of type %s but expression is of type %s" msgstr "하위필드 \"%s\" 는 %s ìžë£Œí˜•ì¸ë° 표현ì‹ì€ %s ìžë£Œí˜•ìž…니다." -#: parser/parse_target.c:1199 +#: parser/parse_target.c:1210 #, c-format msgid "SELECT * with no tables specified is not valid" msgstr "í…Œì´ë¸”ì´ ëª…ì‹œë˜ì§€ ì•Šì€ SELECT * êµ¬ë¬¸ì€ ìœ íš¨í•˜ì§€ 않습니다." @@ -14433,146 +14519,146 @@ msgstr "ìžë£Œí˜• 한정ìžëŠ” 단순 ìƒìˆ˜ ë˜ëŠ” ì‹ë³„ìžì—¬ì•¼ 함" msgid "invalid type name \"%s\"" msgstr "\"%s\" ìžë£Œí˜• ì´ë¦„ì€ ìœ íš¨í•˜ì§€ ì•Šì€ ìžë£Œí˜•ìž…니다." -#: parser/parse_utilcmd.c:399 +#: parser/parse_utilcmd.c:384 #, c-format msgid "array of serial is not implemented" msgstr "serial ë°°ì—´ì´ êµ¬í˜„ë˜ì§€ ì•ŠìŒ" -#: parser/parse_utilcmd.c:447 +#: parser/parse_utilcmd.c:432 #, c-format msgid "%s will create implicit sequence \"%s\" for serial column \"%s.%s\"" msgstr "" "%s 명령으로 \"%s\" 시퀀스가 ìžë™ìœ¼ë¡œ ë§Œë“¤ì–´ì§ (\"%s.%s\" serial ì—´ 때문)" -#: parser/parse_utilcmd.c:541 parser/parse_utilcmd.c:553 +#: parser/parse_utilcmd.c:526 parser/parse_utilcmd.c:538 #, c-format msgid "" "conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"" msgstr "NULL/NOT NULL ì„ ì–¸ì´ ì„œë¡œ 충ëŒí•©ë‹ˆë‹¤ : column \"%s\" of table \"%s\"" -#: parser/parse_utilcmd.c:565 +#: parser/parse_utilcmd.c:550 #, c-format msgid "multiple default values specified for column \"%s\" of table \"%s\"" msgstr "\"%s\" ì—´(\"%s\" í…Œì´ë¸”)ì— ëŒ€í•´ 여러 ê°œì˜ ê¸°ë³¸ ê°’ì´ ì§€ì •ë¨" -#: parser/parse_utilcmd.c:582 parser/parse_utilcmd.c:673 +#: parser/parse_utilcmd.c:567 parser/parse_utilcmd.c:658 #, c-format msgid "primary key constraints are not supported on foreign tables" msgstr "기본키 제약 ì¡°ê±´ì„ ì™¸ë¶€ í…Œì´ë¸”ì—서는 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:591 parser/parse_utilcmd.c:683 +#: parser/parse_utilcmd.c:576 parser/parse_utilcmd.c:668 #, c-format msgid "unique constraints are not supported on foreign tables" msgstr "ìœ ë‹ˆí¬ ì œì•½ ì¡°ê±´ì€ ì™¸ë¶€ í…Œì´ë¸”ì—서는 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:608 parser/parse_utilcmd.c:707 +#: parser/parse_utilcmd.c:593 parser/parse_utilcmd.c:692 #, c-format msgid "foreign key constraints are not supported on foreign tables" msgstr "참조키 제약 ì¡°ê±´ì€ ì™¸ë¶€ í…Œì´ë¸”ì—서는 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:693 +#: parser/parse_utilcmd.c:678 #, c-format msgid "exclusion constraints are not supported on foreign tables" msgstr "제외 제약 ì¡°ê±´ì€ ì™¸ë¶€ í…Œì´ë¸”ì—서는 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:757 +#: parser/parse_utilcmd.c:742 #, c-format msgid "LIKE is not supported for creating foreign tables" msgstr "외부 í…Œì´ë¸”ì„ ë§Œë“¤ 때는 LIKE ì˜µì…˜ì„ ì“¸ 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:1290 parser/parse_utilcmd.c:1366 +#: parser/parse_utilcmd.c:1275 parser/parse_utilcmd.c:1351 #, c-format msgid "Index \"%s\" contains a whole-row table reference." msgstr "" -#: parser/parse_utilcmd.c:1636 +#: parser/parse_utilcmd.c:1621 #, c-format msgid "cannot use an existing index in CREATE TABLE" msgstr "" -#: parser/parse_utilcmd.c:1656 +#: parser/parse_utilcmd.c:1641 #, c-format msgid "index \"%s\" is already associated with a constraint" msgstr "" -#: parser/parse_utilcmd.c:1664 +#: parser/parse_utilcmd.c:1649 #, c-format msgid "index \"%s\" does not belong to table \"%s\"" msgstr "\"%s\" ì¸ë±ìŠ¤ê°€ \"%s\" í…Œì´ë¸”ìš©ì´ ì•„ë‹˜" -#: parser/parse_utilcmd.c:1671 +#: parser/parse_utilcmd.c:1656 #, c-format msgid "index \"%s\" is not valid" msgstr "\"%s\" ì¸ë±ìŠ¤ëŠ” 사용가능 ìƒíƒœê°€ 아님" -#: parser/parse_utilcmd.c:1677 +#: parser/parse_utilcmd.c:1662 #, c-format msgid "\"%s\" is not a unique index" msgstr "\"%s\" ê°ì²´ëŠ” ìœ ë‹ˆí¬ ì¸ë±ìŠ¤ê°€ 아닙니다" -#: parser/parse_utilcmd.c:1678 parser/parse_utilcmd.c:1685 -#: parser/parse_utilcmd.c:1692 parser/parse_utilcmd.c:1762 +#: parser/parse_utilcmd.c:1663 parser/parse_utilcmd.c:1670 +#: parser/parse_utilcmd.c:1677 parser/parse_utilcmd.c:1747 #, c-format msgid "Cannot create a primary key or unique constraint using such an index." msgstr "" -#: parser/parse_utilcmd.c:1684 +#: parser/parse_utilcmd.c:1669 #, c-format msgid "index \"%s\" contains expressions" msgstr "\"%s\" ì¸ë±ìŠ¤ì— 표현ì‹ì´ í¬í•¨ë˜ì–´ 있ìŒ" -#: parser/parse_utilcmd.c:1691 +#: parser/parse_utilcmd.c:1676 #, c-format msgid "\"%s\" is a partial index" msgstr "\"%s\" ê°ì²´ëŠ” 부분 ì¸ë±ìŠ¤ìž„" -#: parser/parse_utilcmd.c:1703 +#: parser/parse_utilcmd.c:1688 #, c-format msgid "\"%s\" is a deferrable index" msgstr "\"%s\" ê°ì²´ëŠ” 지연가능한 ì¸ë±ìŠ¤ìž„" -#: parser/parse_utilcmd.c:1704 +#: parser/parse_utilcmd.c:1689 #, c-format msgid "Cannot create a non-deferrable constraint using a deferrable index." msgstr "" -#: parser/parse_utilcmd.c:1761 +#: parser/parse_utilcmd.c:1746 #, c-format msgid "index \"%s\" does not have default sorting behavior" msgstr "\"%s\" ì¸ë±ìŠ¤ëŠ” 기본 ì •ë ¬ ë°©ë²•ì´ ì—†ìŒ" -#: parser/parse_utilcmd.c:1908 +#: parser/parse_utilcmd.c:1893 #, c-format msgid "column \"%s\" appears twice in primary key constraint" msgstr "기본키 제약 ì¡°ê±´ì—ì„œ \"%s\" ì—´ì´ ë‘ ë²ˆ 지정ë˜ì—ˆìŠµë‹ˆë‹¤" -#: parser/parse_utilcmd.c:1914 +#: parser/parse_utilcmd.c:1899 #, c-format msgid "column \"%s\" appears twice in unique constraint" msgstr "고유 제약 ì¡°ê±´ì—ì„œ \"%s\" ì—´ì´ ë‘ ë²ˆ 지정ë˜ì—ˆìŠµë‹ˆë‹¤" -#: parser/parse_utilcmd.c:2118 +#: parser/parse_utilcmd.c:2103 #, c-format msgid "index expression cannot return a set" msgstr "ì¸ë±ìŠ¤ ì‹ì€ 세트를 반환할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:2129 +#: parser/parse_utilcmd.c:2114 #, c-format msgid "" "index expressions and predicates can refer only to the table being indexed" msgstr "ì¸ë±ìŠ¤ ì‹ ë° ìˆ ì–´ëŠ” ì¸ë±ì‹±ë˜ëŠ” í…Œì´ë¸”만 참조할 수 있ìŒ" -#: parser/parse_utilcmd.c:2175 +#: parser/parse_utilcmd.c:2160 #, c-format msgid "rules on materialized views are not supported" msgstr "êµ¬ì²´í™”ëœ ë·°ì—ì„œì˜ ë£°ì€ ì§€ì›í•˜ì§€ ì•ŠìŒ" -#: parser/parse_utilcmd.c:2236 +#: parser/parse_utilcmd.c:2221 #, c-format msgid "rule WHERE condition cannot contain references to other relations" msgstr "룰ì—ì„œ 지정한 WHERE ì¡°ê±´ì— ë‹¤ë¥¸ 릴레ì´ì…˜ì— 대한 참조를 í¬í•¨í•  수 ì—†ìŒ" -#: parser/parse_utilcmd.c:2308 +#: parser/parse_utilcmd.c:2293 #, c-format msgid "" "rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE " @@ -14581,83 +14667,83 @@ msgstr "" "룰ì—ì„œ 지정한 WHERE ì¡°ê±´ì´ ìžˆëŠ” 규칙ì—는 SELECT, INSERT, UPDATE ë˜ëŠ” DELETE " "작업만 í¬í•¨í•  수 있ìŒ" -#: parser/parse_utilcmd.c:2326 parser/parse_utilcmd.c:2425 +#: parser/parse_utilcmd.c:2311 parser/parse_utilcmd.c:2410 #: rewrite/rewriteHandler.c:485 rewrite/rewriteManip.c:1015 #, c-format msgid "conditional UNION/INTERSECT/EXCEPT statements are not implemented" msgstr "conditional UNION/INTERSECT/EXCEPT êµ¬ë¬¸ì€ êµ¬í˜„ë˜ì–´ 있지 않다" -#: parser/parse_utilcmd.c:2344 +#: parser/parse_utilcmd.c:2329 #, c-format msgid "ON SELECT rule cannot use OLD" msgstr "ON SELECT ë£°ì€ OLD를 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:2348 +#: parser/parse_utilcmd.c:2333 #, c-format msgid "ON SELECT rule cannot use NEW" msgstr "ON SELECT ë£°ì€ NEW를 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:2357 +#: parser/parse_utilcmd.c:2342 #, c-format msgid "ON INSERT rule cannot use OLD" msgstr "ON INSERT ë£°ì€ OLD를 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:2363 +#: parser/parse_utilcmd.c:2348 #, c-format msgid "ON DELETE rule cannot use NEW" msgstr "ON DELETE ë£°ì€ NEW를 사용할 수 ì—†ìŒ" -#: parser/parse_utilcmd.c:2391 +#: parser/parse_utilcmd.c:2376 #, c-format msgid "cannot refer to OLD within WITH query" msgstr "" -#: parser/parse_utilcmd.c:2398 +#: parser/parse_utilcmd.c:2383 #, c-format msgid "cannot refer to NEW within WITH query" msgstr "" -#: parser/parse_utilcmd.c:2601 +#: parser/parse_utilcmd.c:2586 #, c-format msgid "transform expression must not return a set" msgstr "transform 표현ì‹ì€ í•˜ë‚˜ì˜ ì„¸íŠ¸ë¥¼ 리턴하면 안ë©ë‹ˆë‹¤" -#: parser/parse_utilcmd.c:2715 +#: parser/parse_utilcmd.c:2700 #, c-format msgid "misplaced DEFERRABLE clause" msgstr "DEFERABLE ì ˆì´ ìž˜ëª» 놓여져 있습니다" -#: parser/parse_utilcmd.c:2720 parser/parse_utilcmd.c:2735 +#: parser/parse_utilcmd.c:2705 parser/parse_utilcmd.c:2720 #, c-format msgid "multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed" msgstr "여러 ê°œì˜ DEFERRABLE/NOT DEFERRABLEì ˆì€ ì‚¬ìš©í•  수 없습니다" -#: parser/parse_utilcmd.c:2730 +#: parser/parse_utilcmd.c:2715 #, c-format msgid "misplaced NOT DEFERRABLE clause" msgstr "NOT DEFERABLE ì ˆì´ ìž˜ëª» 놓여 있습니다" -#: parser/parse_utilcmd.c:2743 parser/parse_utilcmd.c:2769 gram.y:4902 +#: parser/parse_utilcmd.c:2728 parser/parse_utilcmd.c:2754 gram.y:4902 #, c-format msgid "constraint declared INITIALLY DEFERRED must be DEFERRABLE" msgstr "INITIALLY DEFERRED ë¡œ ì„ ì–¸ëœ ì¡°ê±´ë¬¸ì€ ë°˜ë“œì‹œ DEFERABLE 여야만 한다" -#: parser/parse_utilcmd.c:2751 +#: parser/parse_utilcmd.c:2736 #, c-format msgid "misplaced INITIALLY DEFERRED clause" msgstr "INITIALLY DEFERRED ì ˆì´ ìž˜ëª» 놓여 있습니다" -#: parser/parse_utilcmd.c:2756 parser/parse_utilcmd.c:2782 +#: parser/parse_utilcmd.c:2741 parser/parse_utilcmd.c:2767 #, c-format msgid "multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed" msgstr "여러 ê°œì˜ INITIALLY IMMEDIATE/DEFERRED ì ˆì€ í—ˆìš©ë˜ì§€ 않습니다" -#: parser/parse_utilcmd.c:2777 +#: parser/parse_utilcmd.c:2762 #, c-format msgid "misplaced INITIALLY IMMEDIATE clause" msgstr "INITIALLY IMMEDIATE ì ˆì´ ìž˜ëª» 놓여 있습니다" -#: parser/parse_utilcmd.c:2968 +#: parser/parse_utilcmd.c:2953 #, c-format msgid "" "CREATE specifies a schema (%s) different from the one being created (%s)" @@ -14695,8 +14781,8 @@ msgstr "" "ì´ ì˜¤ë¥˜ëŠ” 시스템ì—ì„œ 지정한 최소 세마í¬ì–´ 수(SEMMNI)ê°€ 너무 í¬ê±°ë‚˜, 최대 세마" "í¬ì–´ 수(SEMMNS)ê°€ 너무 ì ì–´ì„œ 서버를 실행할 수 ì—†ì„ ë•Œ ë°œìƒí•©ë‹ˆë‹¤. ì´ì— ë”°" "ë¼, ì •ìƒì ìœ¼ë¡œ 서버가 실행ë˜ë ¤ë©´, 시스템 ê°’ë“¤ì„ ì¡°ì •í•  필요가 있습니다. 아니" -"ë©´, 다른 방법으로, PostgreSQLì˜ í™˜ê²½ 설정ì—ì„œ max_connections ê°’ì„ ì¤„ì—¬ì„œ " -"세마í¬ì–´ 사용 수를 줄여보십시오.\n" +"ë©´, 다른 방법으로, PostgreSQLì˜ í™˜ê²½ 설정ì—ì„œ max_connections ê°’ì„ ì¤„ì—¬ì„œ 세" +"마í¬ì–´ 사용 수를 줄여보십시오.\n" "보다 ìžì„¸í•œ ë‚´ìš©ì€ PostgreSQL ê´€ë¦¬ìž ë©”ë‰´ì–¼ì„ ì°¸ì¡° 하십시오." #: port/pg_sema.c:148 port/sysv_sema.c:148 @@ -14719,6 +14805,7 @@ msgid "Failed system call was shmget(key=%lu, size=%zu, 0%o)." msgstr "shmget(키=%lu, í¬ê¸°=%zu, 0%o) 시스템 콜 실패" #: port/pg_shmem.c:180 port/sysv_shmem.c:180 +#, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory " "segment exceeded your kernel's SHMMAX parameter, or possibly that it is less " @@ -14726,11 +14813,12 @@ msgid "" "The PostgreSQL documentation contains more information about shared memory " "configuration." msgstr "" -"ì´ ì˜¤ë¥˜ë¥¼ ì¼ë°˜ì ìœ¼ë¡œ PostgreSQLì—ì„œ 사용할 공유 메모리 í¬ê¸°ê°€ " -"커ë„ì˜ SHMMAX 값보다 í¬ê±°ë‚˜, SHMMIN 값보다 ì ì€ 경우 ë°œìƒí•©ë‹ˆë‹¤.\n" +"ì´ ì˜¤ë¥˜ë¥¼ ì¼ë°˜ì ìœ¼ë¡œ PostgreSQLì—ì„œ 사용할 공유 메모리 í¬ê¸°ê°€ 커ë„ì˜ SHMMAX " +"값보다 í¬ê±°ë‚˜, SHMMIN 값보다 ì ì€ 경우 ë°œìƒí•©ë‹ˆë‹¤.\n" "공유 메모리 ì„¤ì •ì— ëŒ€í•œ 보다 ìžì„¸í•œ ë‚´ìš©ì€ PostgreSQL 문서를 참조하십시오." #: port/pg_shmem.c:187 port/sysv_shmem.c:187 +#, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory " "segment exceeded your kernel's SHMALL parameter. You might need to " @@ -14738,12 +14826,12 @@ msgid "" "The PostgreSQL documentation contains more information about shared memory " "configuration." msgstr "" -"ì´ ì˜¤ë¥˜ë¥¼ ì¼ë°˜ì ìœ¼ë¡œ PostgreSQLì—ì„œ 사용할 공유 í¬ê¸°ê°€ " -"커ë„ì˜ SHMALL 값보다 í° ê²½ìš° ë°œìƒí•©ë‹ˆë‹¤. ì»¤ë„ í™˜ê²½ ë³€ìˆ˜ì¸ " -"SHMALL ê°’ì„ ì¢€ ë” í¬ê²Œ 설정하세요.\n" +"ì´ ì˜¤ë¥˜ë¥¼ ì¼ë°˜ì ìœ¼ë¡œ PostgreSQLì—ì„œ 사용할 공유 í¬ê¸°ê°€ 커ë„ì˜ SHMALL 값보다 " +"í° ê²½ìš° ë°œìƒí•©ë‹ˆë‹¤. ì»¤ë„ í™˜ê²½ ë³€ìˆ˜ì¸ SHMALL ê°’ì„ ì¢€ ë” í¬ê²Œ 설정하세요.\n" "공유 메모리 ì„¤ì •ì— ëŒ€í•œ 보다 ìžì„¸í•œ ë‚´ìš©ì€ PostgreSQL 문서를 참조하십시오." #: port/pg_shmem.c:193 port/sysv_shmem.c:193 +#, c-format msgid "" "This error does *not* mean that you have run out of disk space. It occurs " "either if all available shared memory IDs have been taken, in which case you " @@ -14753,8 +14841,8 @@ msgid "" "configuration." msgstr "" "ì´ ì˜¤ë¥˜ëŠ” 서버를 ì‹¤í–‰í•˜ëŠ”ë° í•„ìš”í•œ ë””ìŠ¤í¬ ê³µê°„ì´ ë¶€ì¡±í•´ì„œ ë°œìƒí•œ ê²ƒì´ ì•„ë‹™ë‹ˆ" -"다. ì´ ì˜¤ë¥˜ëŠ” 서버가 사용할 공유 메모리 ID를 ì„ ì í•˜ì§€ ëª»í–ˆì„ ë•Œ ë°œìƒí•©ë‹ˆë‹¤. " -"ì»¤ë„ í™˜ê²½ ì„¤ì •ê°’ì¸ SHMMNI ê°’ì„ ëŠ˜ë¦¬ê±°ë‚˜, ì‹œìŠ¤í…œì˜ ê°€ìš© 공유 ë©”ëª¨ë¦¬ëŸ‰ì„ " +"다. ì´ ì˜¤ë¥˜ëŠ” 서버가 사용할 공유 메모리 ID를 ì„ ì í•˜ì§€ ëª»í–ˆì„ ë•Œ ë°œìƒí•©ë‹ˆ" +"다. ì»¤ë„ í™˜ê²½ ì„¤ì •ê°’ì¸ SHMMNI ê°’ì„ ëŠ˜ë¦¬ê±°ë‚˜, ì‹œìŠ¤í…œì˜ ê°€ìš© 공유 ë©”ëª¨ë¦¬ëŸ‰ì„ " "확보하세요.\n" "공유 메모리 ì„¤ì •ì— ëŒ€í•œ 보다 ìžì„¸í•œ ë‚´ìš©ì€ PostgreSQL 문서를 참조하십시오." @@ -14771,10 +14859,10 @@ msgid "" "request size (currently %zu bytes), reduce PostgreSQL's shared memory usage, " "perhaps by reducing shared_buffers or max_connections." msgstr "" -"ì´ ì˜¤ë¥˜ëŠ” ì¼ë°˜ì ìœ¼ë¡œ PostgreSQLì—ì„œ 사용할 공유 메모리를 확보하지 " -"못 í–ˆì„ ë•Œ ë°œìƒí•©ë‹ˆë‹¤(물리 메모리, 스왑, huge page). " -"현재 요구 í¬ê¸°(%zu ë°”ì´íŠ¸)를 좀 줄여 보십시오. 줄ì´ëŠ” 방법ì€, " -"shared_buffers ê°’ì„ ì¤„ì´ê±°ë‚˜ max_connections ê°’ì„ ì¤„ì—¬ 보십시오." +"ì´ ì˜¤ë¥˜ëŠ” ì¼ë°˜ì ìœ¼ë¡œ PostgreSQLì—ì„œ 사용할 공유 메모리를 확보하지 못 í–ˆì„ ë•Œ " +"ë°œìƒí•©ë‹ˆë‹¤(물리 메모리, 스왑, huge page). 현재 요구 í¬ê¸°(%zu ë°”ì´íŠ¸)를 좀 줄" +"ì—¬ 보십시오. 줄ì´ëŠ” 방법ì€, shared_buffers ê°’ì„ ì¤„ì´ê±°ë‚˜ max_connections ê°’" +"ì„ ì¤„ì—¬ 보십시오." #: port/pg_shmem.c:551 port/sysv_shmem.c:551 port/win32_shmem.c:134 #, c-format @@ -14904,35 +14992,36 @@ msgstr "autovacuum ìž‘ì—…ìž í”„ë¡œì„¸ìŠ¤ë¥¼ 실행할 수 ì—†ìŒ: %m" msgid "autovacuum: processing database \"%s\"" msgstr "autovacuum: \"%s\" ë°ì´í„°ë² ì´ìŠ¤ 처리 중" -#: postmaster/autovacuum.c:2050 +#: postmaster/autovacuum.c:2052 #, c-format msgid "autovacuum: dropping orphan temp table \"%s\".\"%s\" in database \"%s\"" msgstr "" -"autovacuum: \"%s\".\"%s\" 사용 않는 ìž„ì‹œ í…Œì´ë¸”ì„ \"%s\" ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ 삭제하는 " -"중" +"autovacuum: \"%s\".\"%s\" 사용 않는 ìž„ì‹œ í…Œì´ë¸”ì„ \"%s\" ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ ì‚­" +"제하는 중" -#: postmaster/autovacuum.c:2062 +#: postmaster/autovacuum.c:2064 #, c-format msgid "autovacuum: found orphan temp table \"%s\".\"%s\" in database \"%s\"" msgstr "" -"autovacuum: \"%s\".\"%s\" 사용 않는 ìž„ì‹œ í…Œì´ë¸”ì„ \"%s\" ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ 찾았ìŒ" +"autovacuum: \"%s\".\"%s\" 사용 않는 ìž„ì‹œ í…Œì´ë¸”ì„ \"%s\" ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ ì°¾" +"았ìŒ" -#: postmaster/autovacuum.c:2344 +#: postmaster/autovacuum.c:2347 #, c-format msgid "automatic vacuum of table \"%s.%s.%s\"" msgstr "\"%s.%s.%s\" í…Œì´ë¸” 대ìƒìœ¼ë¡œ ìžë™ vacuum ìž‘ì—… 함" -#: postmaster/autovacuum.c:2347 +#: postmaster/autovacuum.c:2350 #, c-format msgid "automatic analyze of table \"%s.%s.%s\"" msgstr "\"%s.%s.%s\" í…Œì´ë¸” ìžë™ 분ì„" -#: postmaster/autovacuum.c:2877 +#: postmaster/autovacuum.c:2899 #, c-format msgid "autovacuum not started because of misconfiguration" msgstr "서버 설정 ì •ë³´ê°€ 잘못ë˜ì–´ ìžë™ 청소 ìž‘ì—…ì´ ì‹¤í–‰ë˜ì§€ 못했습니다." -#: postmaster/autovacuum.c:2878 +#: postmaster/autovacuum.c:2900 #, c-format msgid "Enable the \"track_counts\" option." msgstr "\"track_counts\" ì˜µì…˜ì„ ì‚¬ìš©í•˜ì‹­ì‹œì˜¤." @@ -14976,7 +15065,8 @@ msgstr "ê´€ë¦¬ìž ëª…ë ¹ì— ì˜í•´ \"%s\" 백그ë¼ìš´ë“œ ìž‘ì—…ìžë¥¼ 종료합 msgid "" "background worker \"%s\": must be registered in shared_preload_libraries" msgstr "" -"\"%s\" 백그ë¼ìš´ë“œ ìž‘ì—…ìž: 먼저 shared_preload_libraries 설정값으로 등ë¡ë˜ì–´ì•¼ 합니다." +"\"%s\" 백그ë¼ìš´ë“œ ìž‘ì—…ìž: 먼저 shared_preload_libraries 설정값으로 등ë¡ë˜ì–´" +"야 합니다." #: postmaster/bgworker.c:764 #, c-format @@ -14987,6 +15077,7 @@ msgstr "" "\"%s\" 백그ë¼ìš´ë“œ ìž‘ì—…ìž: ë™ì  백그ë¼ìš´ë“œ ìž‘ì—…ìžë§Œ ì•Œë¦¼ì„ ìš”ì²­í•  수 있ìŒ" #: postmaster/bgworker.c:779 +#, c-format msgid "too many background workers" msgstr "백그ë¼ìš´ë“œ ìž‘ì—…ìžê°€ 너무 많ìŒ" @@ -14995,8 +15086,7 @@ msgstr "백그ë¼ìš´ë“œ ìž‘ì—…ìžê°€ 너무 많ìŒ" msgid "Up to %d background worker can be registered with the current settings." msgid_plural "" "Up to %d background workers can be registered with the current settings." -msgstr[0] "" -"현재 설정으로는 %dê°œì˜ ë°±ê·¸ë¼ìš´ë“œ ìž‘ì—…ìžë¥¼ 사용할 수 있습니다." +msgstr[0] "현재 설정으로는 %dê°œì˜ ë°±ê·¸ë¼ìš´ë“œ ìž‘ì—…ìžë¥¼ 사용할 수 있습니다." #: postmaster/bgworker.c:784 #, c-format @@ -15011,6 +15101,7 @@ msgid_plural "checkpoints are occurring too frequently (%d seconds apart)" msgstr[0] "ì²´í¬í¬ì¸íŠ¸ê°€ 너무 ìžì£¼ ë°œìƒí•¨ (%dì´ˆ 간격)" #: postmaster/checkpointer.c:467 +#, c-format msgid "Consider increasing the configuration parameter \"max_wal_size\"." msgstr "\"max_wal_size\" 환경 매개 변수 ê°’ì„ ì¢€ ëŠë ¤ë³´ì‹­ì‹œì˜¤." @@ -15050,8 +15141,8 @@ msgid "" "archiving transaction log file \"%s\" failed too many times, will try again " "later" msgstr "" -"\"%s\" 트랜잭션 로그 íŒŒì¼ ì•„ì¹´ì´ë¸Œ ìž‘ì—…ì´ ê³„ì† ì‹¤íŒ¨í•˜ê³  있습니다. " -"다ìŒì— ë˜ ì‹œë„í•  것입니다." +"\"%s\" 트랜잭션 로그 íŒŒì¼ ì•„ì¹´ì´ë¸Œ ìž‘ì—…ì´ ê³„ì† ì‹¤íŒ¨í•˜ê³  있습니다. 다ìŒì— ë˜ " +"ì‹œë„í•  것입니다." #: postmaster/pgarch.c:587 #, c-format @@ -15069,12 +15160,11 @@ msgstr "실패한 ì•„ì¹´ì´ë¸Œ 명령: %s" msgid "archive command was terminated by exception 0x%X" msgstr "0x%X 예외로 ì¸í•´ ì•„ì¹´ì´ë¸Œ ëª…ë ¹ì´ ì¢…ë£Œë¨" -#: postmaster/pgarch.c:598 postmaster/postmaster.c:3490 +#: postmaster/pgarch.c:598 postmaster/postmaster.c:3491 #, c-format msgid "" "See C include file \"ntstatus.h\" for a description of the hexadecimal value." -msgstr "" -"16진수 ê°’ì— ëŒ€í•œ ì„¤ëª…ì€ C í¬í•¨ íŒŒì¼ \"ntstatus.h\"를 참조하십시오." +msgstr "16진수 ê°’ì— ëŒ€í•œ ì„¤ëª…ì€ C í¬í•¨ íŒŒì¼ \"ntstatus.h\"를 참조하십시오." #: postmaster/pgarch.c:603 #, c-format @@ -15234,8 +15324,7 @@ msgstr "" #: postmaster/pgstat.c:5103 #, c-format msgid "database hash table corrupted during cleanup --- abort" -msgstr "" -"정리하는 ë™ì•ˆ ë°ì´í„°ë² ì´ìŠ¤ í•´ì‹œ í…Œì´ë¸”ì´ ì†ìƒ ë˜ì—ˆìŠµë‹ˆë‹¤ --- 중지함" +msgstr "정리하는 ë™ì•ˆ ë°ì´í„°ë² ì´ìŠ¤ í•´ì‹œ í…Œì´ë¸”ì´ ì†ìƒ ë˜ì—ˆìŠµë‹ˆë‹¤ --- 중지함" #: postmaster/postmaster.c:684 #, c-format @@ -15261,8 +15350,7 @@ msgstr "" #: postmaster/postmaster.c:865 #, c-format msgid "%s: max_wal_senders must be less than max_connections\n" -msgstr "" -"%s: max_wal_senders ê°’ì€ max_connections 값보다 작아야합니다\n" +msgstr "%s: max_wal_senders ê°’ì€ max_connections 값보다 작아야합니다\n" #: postmaster/postmaster.c:870 #, c-format @@ -15275,8 +15363,8 @@ msgid "" "WAL streaming (max_wal_senders > 0) requires wal_level \"replica\" or " "\"logical\"" msgstr "" -"WAL ìŠ¤íŠ¸ë¦¬ë° ìž‘ì—…(max_wal_senders > 0 ì¸ê²½ìš°)ì€ wal_level ê°’ì´ " -"\"replica\" ë˜ëŠ” \"logical\" ì´ì–´ì•¼ 합니다." +"WAL ìŠ¤íŠ¸ë¦¬ë° ìž‘ì—…(max_wal_senders > 0 ì¸ê²½ìš°)ì€ wal_level ê°’ì´ \"replica\" ë˜" +"는 \"logical\" ì´ì–´ì•¼ 합니다." #: postmaster/postmaster.c:881 #, c-format @@ -15365,8 +15453,8 @@ msgid "" "This may indicate an incomplete PostgreSQL installation, or that the file " "\"%s\" has been moved away from its proper location." msgstr "" -"ì´ ë¬¸ì œëŠ” PostgreSQL 설치가 불완전하게 ë˜ì—ˆê±°ë‚˜, \"%s\" 파ì¼ì´ 올바른 " -"ìœ„ì¹˜ì— ìžˆì§€ ì•Šì•„ì„œ ë°œìƒí–ˆìŠµë‹ˆë‹¤." +"ì´ ë¬¸ì œëŠ” PostgreSQL 설치가 불완전하게 ë˜ì—ˆê±°ë‚˜, \"%s\" 파ì¼ì´ 올바른 ìœ„ì¹˜ì— " +"있지 ì•Šì•„ì„œ ë°œìƒí–ˆìŠµë‹ˆë‹¤." #: postmaster/postmaster.c:1436 #, c-format @@ -15419,363 +15507,363 @@ msgstr "" msgid "select() failed in postmaster: %m" msgstr "postmasterì—ì„œ select() ìž‘ë™ ì‹¤íŒ¨: %m" -#: postmaster/postmaster.c:1827 +#: postmaster/postmaster.c:1828 #, c-format msgid "" "performing immediate shutdown because data directory lock file is invalid" msgstr "" -#: postmaster/postmaster.c:1905 postmaster/postmaster.c:1936 +#: postmaster/postmaster.c:1906 postmaster/postmaster.c:1937 #, c-format msgid "incomplete startup packet" msgstr "ì•„ì§ ì™„ë£Œë˜ì§€ ì•Šì€ ì‹œìž‘ 패킷" -#: postmaster/postmaster.c:1917 +#: postmaster/postmaster.c:1918 #, c-format msgid "invalid length of startup packet" msgstr "시작 íŒ¨í‚·ì˜ ê¸¸ì´ê°€ 잘못 ë˜ì—ˆìŠµë‹ˆë‹¤" -#: postmaster/postmaster.c:1975 +#: postmaster/postmaster.c:1976 #, c-format msgid "failed to send SSL negotiation response: %m" msgstr "SSL ì—°ê²° ìž‘ì—…ì— ì˜¤ë¥˜ê°€ ë°œìƒí–ˆìŠµë‹ˆë‹¤: %m" -#: postmaster/postmaster.c:2004 +#: postmaster/postmaster.c:2005 #, c-format msgid "unsupported frontend protocol %u.%u: server supports %u.0 to %u.%u" msgstr "" "지ì›í•˜ì§€ 않는 frontend 프로토콜 %u.%u: 서버ì—ì„œ 지ì›í•˜ëŠ” 프로토콜 %u.0 .. %u." "%u" -#: postmaster/postmaster.c:2067 utils/misc/guc.c:5662 utils/misc/guc.c:5755 -#: utils/misc/guc.c:7053 utils/misc/guc.c:9797 utils/misc/guc.c:9831 +#: postmaster/postmaster.c:2068 utils/misc/guc.c:5660 utils/misc/guc.c:5753 +#: utils/misc/guc.c:7051 utils/misc/guc.c:9805 utils/misc/guc.c:9839 #, c-format msgid "invalid value for parameter \"%s\": \"%s\"" msgstr "ìž˜ëª»ëœ \"%s\" 매개 ë³€ìˆ˜ì˜ ê°’: \"%s\"" -#: postmaster/postmaster.c:2070 +#: postmaster/postmaster.c:2071 #, c-format msgid "Valid values are: \"false\", 0, \"true\", 1, \"database\"." msgstr "" -#: postmaster/postmaster.c:2090 +#: postmaster/postmaster.c:2091 #, c-format msgid "invalid startup packet layout: expected terminator as last byte" msgstr "ìž˜ëª»ëœ ì‹œìž‘ 패킷 ë ˆì´ì•„웃: 마지막 ë°”ì´íŠ¸ë¡œ 종결문ìžê°€ 발견ë˜ì—ˆìŒ" -#: postmaster/postmaster.c:2118 +#: postmaster/postmaster.c:2119 #, c-format msgid "no PostgreSQL user name specified in startup packet" msgstr "시작 패킷ì—ì„œ 지정한 사용ìžëŠ” PostgreSQL ì‚¬ìš©ìž ì´ë¦„ì´ ì•„ë‹™ë‹ˆë‹¤" -#: postmaster/postmaster.c:2177 +#: postmaster/postmaster.c:2178 #, c-format msgid "the database system is starting up" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ìƒˆë¡œ ê°€ë™ ì¤‘ìž…ë‹ˆë‹¤." -#: postmaster/postmaster.c:2182 +#: postmaster/postmaster.c:2183 #, c-format msgid "the database system is shutting down" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ì¤‘ì§€ 중입니다" -#: postmaster/postmaster.c:2187 +#: postmaster/postmaster.c:2188 #, c-format msgid "the database system is in recovery mode" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ìžë™ 복구 ìž‘ì—… 중입니다." -#: postmaster/postmaster.c:2192 storage/ipc/procarray.c:297 +#: postmaster/postmaster.c:2193 storage/ipc/procarray.c:297 #: storage/ipc/sinvaladt.c:298 storage/lmgr/proc.c:340 #, c-format msgid "sorry, too many clients already" msgstr "최대 ë™ì‹œ ì ‘ì†ìž 수를 초과했습니다." -#: postmaster/postmaster.c:2254 +#: postmaster/postmaster.c:2255 #, c-format msgid "wrong key in cancel request for process %d" msgstr "프로세스 %dì— ëŒ€í•œ 취소 ìš”ì²­ì— ìž˜ëª»ëœ í‚¤ê°€ 있ìŒ" -#: postmaster/postmaster.c:2262 +#: postmaster/postmaster.c:2263 #, c-format msgid "PID %d in cancel request did not match any process" msgstr "취소 ìš”ì²­ì˜ PID %dê³¼(와) ì¼ì¹˜í•˜ëŠ” 프로세스가 ì—†ìŒ" -#: postmaster/postmaster.c:2482 +#: postmaster/postmaster.c:2483 #, c-format msgid "received SIGHUP, reloading configuration files" msgstr "SIGHUP 신호를 받아서, 환경설정파ì¼ì„ 다시 ì½ê³  있습니다." -#: postmaster/postmaster.c:2507 +#: postmaster/postmaster.c:2508 #, c-format msgid "pg_hba.conf not reloaded" msgstr "pg_hba.confê°€ 다시 로드ë˜ì§€ ì•ŠìŒ" -#: postmaster/postmaster.c:2511 +#: postmaster/postmaster.c:2512 #, c-format msgid "pg_ident.conf not reloaded" msgstr "pg_ident.conf 파ì¼ì´ 다시 로드ë˜ì§€ ì•ŠìŒ" -#: postmaster/postmaster.c:2552 +#: postmaster/postmaster.c:2553 #, c-format msgid "received smart shutdown request" msgstr "smart 중지 ìš”ì²­ì„ ë°›ì•˜ìŠµë‹ˆë‹¤." -#: postmaster/postmaster.c:2607 +#: postmaster/postmaster.c:2608 #, c-format msgid "received fast shutdown request" msgstr "fast 중지 ìš”ì²­ì„ ë°›ì•˜ìŠµë‹ˆë‹¤." -#: postmaster/postmaster.c:2637 +#: postmaster/postmaster.c:2638 #, c-format msgid "aborting any active transactions" msgstr "모든 활성화 ë˜ì–´ìžˆëŠ” íŠ¸ëžœìž­ì…˜ì„ ì¤‘ì§€í•˜ê³  있습니다." -#: postmaster/postmaster.c:2671 +#: postmaster/postmaster.c:2672 #, c-format msgid "received immediate shutdown request" msgstr "immediate 중지 ìš”ì²­ì„ ë°›ì•˜ìŠµë‹ˆë‹¤." -#: postmaster/postmaster.c:2735 +#: postmaster/postmaster.c:2736 #, c-format msgid "shutdown at recovery target" msgstr "복구 타겟ì—ì„œ 중지함" -#: postmaster/postmaster.c:2751 postmaster/postmaster.c:2774 +#: postmaster/postmaster.c:2752 postmaster/postmaster.c:2775 msgid "startup process" msgstr "시작 프로세스" -#: postmaster/postmaster.c:2754 +#: postmaster/postmaster.c:2755 #, c-format msgid "aborting startup due to startup process failure" msgstr "시작 프로세스 실패 ë•Œë¬¸ì— ì„œë²„ ì‹œìž‘ì´ ì¤‘ì§€ ë˜ì—ˆìŠµë‹ˆë‹¤" -#: postmaster/postmaster.c:2815 +#: postmaster/postmaster.c:2816 #, c-format msgid "database system is ready to accept connections" msgstr "ì´ì œ ë°ì´í„°ë² ì´ìŠ¤ 서버로 ì ‘ì†í•  수 있습니다" -#: postmaster/postmaster.c:2834 +#: postmaster/postmaster.c:2835 msgid "background writer process" msgstr "백그ë¼ìš´ë“œ writer 프로세스" -#: postmaster/postmaster.c:2888 +#: postmaster/postmaster.c:2889 msgid "checkpointer process" msgstr "ì²´í¬í¬ì¸íŠ¸ 프로세스" -#: postmaster/postmaster.c:2904 +#: postmaster/postmaster.c:2905 msgid "WAL writer process" msgstr "WAL 쓰기 프로세스" -#: postmaster/postmaster.c:2918 +#: postmaster/postmaster.c:2919 msgid "WAL receiver process" msgstr "WAL 수신 프로세스" -#: postmaster/postmaster.c:2933 +#: postmaster/postmaster.c:2934 msgid "autovacuum launcher process" msgstr "autovacuum 실행기 프로세스" -#: postmaster/postmaster.c:2948 +#: postmaster/postmaster.c:2949 msgid "archiver process" msgstr "archiver 프로세스" -#: postmaster/postmaster.c:2964 +#: postmaster/postmaster.c:2965 msgid "statistics collector process" msgstr "통계 수집기 프로세스" -#: postmaster/postmaster.c:2978 +#: postmaster/postmaster.c:2979 msgid "system logger process" msgstr "시스템 로그 프로세스" -#: postmaster/postmaster.c:3040 +#: postmaster/postmaster.c:3041 msgid "worker process" msgstr "ìž‘ì—…ìž í”„ë¡œì„¸ìŠ¤" -#: postmaster/postmaster.c:3123 postmaster/postmaster.c:3143 -#: postmaster/postmaster.c:3150 postmaster/postmaster.c:3168 +#: postmaster/postmaster.c:3124 postmaster/postmaster.c:3144 +#: postmaster/postmaster.c:3151 postmaster/postmaster.c:3169 msgid "server process" msgstr "서버 프로세스" -#: postmaster/postmaster.c:3222 +#: postmaster/postmaster.c:3223 #, c-format msgid "terminating any other active server processes" msgstr "다른 활성화 ë˜ì–´ìžˆëŠ” 서버 프로세스를 마치고 있는 중입니다" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3478 +#: postmaster/postmaster.c:3479 #, c-format msgid "%s (PID %d) exited with exit code %d" msgstr "%s (PID %d) í”„ë¡œê·¸ëž¨ì€ %d 코드로 마쳤습니다" -#: postmaster/postmaster.c:3480 postmaster/postmaster.c:3491 -#: postmaster/postmaster.c:3502 postmaster/postmaster.c:3511 -#: postmaster/postmaster.c:3521 +#: postmaster/postmaster.c:3481 postmaster/postmaster.c:3492 +#: postmaster/postmaster.c:3503 postmaster/postmaster.c:3512 +#: postmaster/postmaster.c:3522 #, c-format msgid "Failed process was running: %s" msgstr "" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3488 +#: postmaster/postmaster.c:3489 #, c-format msgid "%s (PID %d) was terminated by exception 0x%X" msgstr "%s (PID %d) 프로세스가 0x%X 예외로 ì¸í•´ 종료ë¨" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3498 +#: postmaster/postmaster.c:3499 #, c-format msgid "%s (PID %d) was terminated by signal %d: %s" msgstr "%s (PID %d) 프로세스가 %d번 시그ë„ì„ ë°›ì•„ 종료ë¨: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3509 +#: postmaster/postmaster.c:3510 #, c-format msgid "%s (PID %d) was terminated by signal %d" msgstr "%s (PID %d) 프로세스가 %d번 시그ë„ì„ ë°›ì•„ 종료ë¨" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3519 +#: postmaster/postmaster.c:3520 #, c-format msgid "%s (PID %d) exited with unrecognized status %d" msgstr "%s (PID %d) 프로세스가 ì¸ì‹í•  수 없는 %d ìƒíƒœë¡œ 종료ë¨" -#: postmaster/postmaster.c:3706 +#: postmaster/postmaster.c:3707 #, c-format msgid "abnormal database system shutdown" msgstr "비정ìƒì ì¸ ë°ì´í„°ë² ì´ìŠ¤ 시스템 서비스를 중지" -#: postmaster/postmaster.c:3746 +#: postmaster/postmaster.c:3747 #, c-format msgid "all server processes terminated; reinitializing" msgstr "모든 서버 프로세스가 중지 ë˜ì—ˆìŠµë‹ˆë‹¤; 재 초기화 중" -#: postmaster/postmaster.c:3958 +#: postmaster/postmaster.c:3959 #, c-format msgid "could not fork new process for connection: %m" msgstr "ì—°ê²°ì„ ìœ„í•œ 새 프로세스 할당(fork) 실패: %m" -#: postmaster/postmaster.c:4000 +#: postmaster/postmaster.c:4001 msgid "could not fork new process for connection: " msgstr "ì—°ê²°ì„ ìœ„í•œ 새 프로세스 할당(fork) 실패: " -#: postmaster/postmaster.c:4114 +#: postmaster/postmaster.c:4115 #, c-format msgid "connection received: host=%s port=%s" msgstr "ì ‘ì† ìˆ˜ë½: host=%s port=%s" -#: postmaster/postmaster.c:4119 +#: postmaster/postmaster.c:4120 #, c-format msgid "connection received: host=%s" msgstr "ì ‘ì† ìˆ˜ë½: host=%s" -#: postmaster/postmaster.c:4402 +#: postmaster/postmaster.c:4403 #, c-format msgid "could not execute server process \"%s\": %m" msgstr "\"%s\" 서버 프로세스를 실행할 수 ì—†ìŒ: %m" -#: postmaster/postmaster.c:4946 +#: postmaster/postmaster.c:4947 #, c-format msgid "database system is ready to accept read only connections" msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì´ ì½ê¸° 전용으로 ì—°ê²°ì„ ìˆ˜ë½í•  준비가 ë˜ì—ˆìŠµë‹ˆë‹¤." -#: postmaster/postmaster.c:5237 +#: postmaster/postmaster.c:5238 #, c-format msgid "could not fork startup process: %m" msgstr "시작 프로세스 할당(fork) 실패: %m" -#: postmaster/postmaster.c:5241 +#: postmaster/postmaster.c:5242 #, c-format msgid "could not fork background writer process: %m" msgstr "백그ë¼ìš´ writer 프로세스를 할당(fork)í•  수 없습니다: %m" -#: postmaster/postmaster.c:5245 +#: postmaster/postmaster.c:5246 #, c-format msgid "could not fork checkpointer process: %m" msgstr "ì²´í¬í¬ì¸íŠ¸ 프로세스를 할당(fork)í•  수 없습니다: %m" -#: postmaster/postmaster.c:5249 +#: postmaster/postmaster.c:5250 #, c-format msgid "could not fork WAL writer process: %m" msgstr "WAL 쓰기 프로세스를 할당(fork)í•  수 ì—†ìŒ: %m" -#: postmaster/postmaster.c:5253 +#: postmaster/postmaster.c:5254 #, c-format msgid "could not fork WAL receiver process: %m" msgstr "WAL 수신 프로세스를 할당(fork)í•  수 ì—†ìŒ: %m" -#: postmaster/postmaster.c:5257 +#: postmaster/postmaster.c:5258 #, c-format msgid "could not fork process: %m" msgstr "프로세스 할당(fork) 실패: %m" -#: postmaster/postmaster.c:5419 postmaster/postmaster.c:5442 +#: postmaster/postmaster.c:5420 postmaster/postmaster.c:5443 #, c-format msgid "database connection requirement not indicated during registration" msgstr "" -#: postmaster/postmaster.c:5426 postmaster/postmaster.c:5449 +#: postmaster/postmaster.c:5427 postmaster/postmaster.c:5450 #, c-format msgid "invalid processing mode in background worker" msgstr "백그ë¼ìš´ë“œ ìž‘ì—…ìžì—ì„œ ìž˜ëª»ëœ í”„ë¡œì„¸ì‹± 모드가 사용ë¨" -#: postmaster/postmaster.c:5501 +#: postmaster/postmaster.c:5502 #, c-format msgid "starting background worker process \"%s\"" msgstr "\"%s\" 백그ë¼ìš´ë“œ ìž‘ì—…ìž í”„ë¡œì„¸ìŠ¤ë¥¼ 시작합니다." -#: postmaster/postmaster.c:5512 +#: postmaster/postmaster.c:5513 #, c-format msgid "could not fork worker process: %m" msgstr "ìž‘ì—…ìž í”„ë¡œì„¸ìŠ¤ë¥¼ 할당(fork)í•  수 ì—†ìŒ: %m" -#: postmaster/postmaster.c:5900 +#: postmaster/postmaster.c:5901 #, c-format msgid "could not duplicate socket %d for use in backend: error code %d" msgstr "백엔드ì—ì„œ 사용하기 위해 %d ì†Œì¼“ì„ ë³µì‚¬í•  수 ì—†ìŒ: 오류 코드 %d" -#: postmaster/postmaster.c:5932 +#: postmaster/postmaster.c:5933 #, c-format msgid "could not create inherited socket: error code %d\n" msgstr "ìƒì†ëœ ì†Œì¼“ì„ ë§Œë“¤ 수 ì—†ìŒ: 오류 코드 %d\n" -#: postmaster/postmaster.c:5961 +#: postmaster/postmaster.c:5962 #, c-format msgid "could not open backend variables file \"%s\": %s\n" msgstr "\"%s\" 백엔드 변수 파ì¼ì„ ì—´ 수 ì—†ìŒ: %s\n" -#: postmaster/postmaster.c:5968 +#: postmaster/postmaster.c:5969 #, c-format msgid "could not read from backend variables file \"%s\": %s\n" msgstr "\"%s\" 백엔드 변수 파ì¼ì„ ì½ì„ 수 ì—†ìŒ: %s\n" -#: postmaster/postmaster.c:5977 +#: postmaster/postmaster.c:5978 #, c-format msgid "could not remove file \"%s\": %s\n" msgstr "\"%s\" 파ì¼ì„ 삭제할 수 ì—†ìŒ: %s\n" -#: postmaster/postmaster.c:5994 +#: postmaster/postmaster.c:5995 #, c-format msgid "could not map view of backend variables: error code %lu\n" msgstr "백엔드 변수 파ì¼ì˜ view를 mapí•  수 ì—†ìŒ: 오류 코드 %lu\n" -#: postmaster/postmaster.c:6003 +#: postmaster/postmaster.c:6004 #, c-format msgid "could not unmap view of backend variables: error code %lu\n" msgstr "백엔드 변수 파ì¼ì˜ view를 unmapí•  수 ì—†ìŒ: 오류 코드 %lu\n" -#: postmaster/postmaster.c:6010 +#: postmaster/postmaster.c:6011 #, c-format msgid "could not close handle to backend parameter variables: error code %lu\n" msgstr "백엔드 변수 파ì¼ì„ ë‹«ì„ ìˆ˜ ì—†ìŒ: 오류 코드 %lu\n" -#: postmaster/postmaster.c:6171 +#: postmaster/postmaster.c:6172 #, c-format msgid "could not read exit code for process\n" msgstr "í”„ë¡œì„¸ìŠ¤ì˜ ì¢…ë£Œ 코드를 ì½ì„ 수 ì—†ìŒ\n" -#: postmaster/postmaster.c:6176 +#: postmaster/postmaster.c:6177 #, c-format msgid "could not post child completion status\n" msgstr "하위 완료 ìƒíƒœë¥¼ 게시할 수 ì—†ìŒ\n" @@ -15841,67 +15929,68 @@ msgstr "" msgid "could not determine which collation to use for regular expression" msgstr "ì •ê·œì‹ì„ 사용해서 사용할 정렬규칙(collation)ì„ ì°¾ì„ ìˆ˜ ì—†ìŒ" -#: replication/basebackup.c:230 +#: replication/basebackup.c:232 #, c-format msgid "could not stat control file \"%s\": %m" msgstr "\"%s\" 컨트롤 파ì¼ì˜ 정보를 구할 수 ì—†ìŒ: %m" -#: replication/basebackup.c:339 +#: replication/basebackup.c:341 #, c-format msgid "could not find any WAL files" msgstr "ì–´ë–¤ WAL 파ì¼ë„ ì°¾ì„ ìˆ˜ ì—†ìŒ" -#: replication/basebackup.c:352 replication/basebackup.c:366 -#: replication/basebackup.c:375 +#: replication/basebackup.c:354 replication/basebackup.c:368 +#: replication/basebackup.c:377 #, c-format msgid "could not find WAL file \"%s\"" msgstr "\"%s\" WAL íŒŒì¼ ì°¾ê¸° 실패" -#: replication/basebackup.c:414 replication/basebackup.c:440 +#: replication/basebackup.c:416 replication/basebackup.c:442 #, c-format msgid "unexpected WAL file size \"%s\"" msgstr "\"%s\" WAL 파ì¼ì˜ í¬ê¸°ê°€ 알맞지 ì•ŠìŒ" -#: replication/basebackup.c:426 replication/basebackup.c:1172 +#: replication/basebackup.c:428 replication/basebackup.c:1160 #, c-format msgid "base backup could not send data, aborting backup" msgstr "ë² ì´ìŠ¤ 백업ì—ì„œ ìžë£Œë¥¼ 보낼 수 ì—†ìŒ. ë°±ì—…ì„ ì¤‘ì§€í•©ë‹ˆë‹¤." -#: replication/basebackup.c:528 replication/basebackup.c:537 -#: replication/basebackup.c:546 replication/basebackup.c:555 -#: replication/basebackup.c:564 replication/basebackup.c:575 -#: replication/basebackup.c:592 +#: replication/basebackup.c:530 replication/basebackup.c:539 +#: replication/basebackup.c:548 replication/basebackup.c:557 +#: replication/basebackup.c:566 replication/basebackup.c:577 +#: replication/basebackup.c:594 #, c-format msgid "duplicate option \"%s\"" msgstr "\"%s\" ì˜µì…˜ì„ ë‘ ë²ˆ 지정했습니다" -#: replication/basebackup.c:581 utils/misc/guc.c:5672 +#: replication/basebackup.c:583 utils/misc/guc.c:5670 #, c-format msgid "%d is outside the valid range for parameter \"%s\" (%d .. %d)" msgstr "" "%d ê°’ì€ \"%s\" 매개 ë³€ìˆ˜ì˜ ê°’ìœ¼ë¡œ 타당한 범위(%d .. %d)를 벗어났습니다." -#: replication/basebackup.c:855 replication/basebackup.c:957 +#: replication/basebackup.c:857 replication/basebackup.c:959 #, c-format msgid "could not stat file or directory \"%s\": %m" msgstr "íŒŒì¼ ë˜ëŠ” 디렉터리 \"%s\"ì˜ ìƒíƒœë¥¼ 확ì¸í•  수 ì—†ìŒ: %m" -#: replication/basebackup.c:1124 +#: replication/basebackup.c:1112 #, c-format msgid "skipping special file \"%s\"" msgstr "\"%s\" 특수 파ì¼ì„ 건너뜀" -#: replication/basebackup.c:1235 +#: replication/basebackup.c:1223 #, c-format msgid "file name too long for tar format: \"%s\"" msgstr "tar 파ì¼ë¡œ 묶기ì—는 íŒŒì¼ ì´ë¦„ì´ ë„ˆë¬´ 긺: \"%s\"" -#: replication/basebackup.c:1240 +#: replication/basebackup.c:1228 #, c-format msgid "" "symbolic link target too long for tar format: file name \"%s\", target \"%s\"" msgstr "" -"tar í¬ë©§ì„ 사용하기ì—는 심볼릭 ë§í¬ì˜ ëŒ€ìƒ ê²½ë¡œê°€ 너무 ê¹ë‹ˆë‹¤: íŒŒì¼ ì´ë¦„ \"%s\", ëŒ€ìƒ \"%s\"" +"tar í¬ë©§ì„ 사용하기ì—는 심볼릭 ë§í¬ì˜ ëŒ€ìƒ ê²½ë¡œê°€ 너무 ê¹ë‹ˆë‹¤: íŒŒì¼ ì´ë¦„ \"%s" +"\", ëŒ€ìƒ \"%s\"" #: replication/libpqwalreceiver/libpqwalreceiver.c:119 #, c-format @@ -15919,8 +16008,7 @@ msgid "" "could not receive database system identifier and timeline ID from the " "primary server: %s" msgstr "" -"주 서버ì—ì„œ ë°ì´í„°ë² ì´ìŠ¤ 시스템 ì‹ë³„번호와 타임ë¼ì¸ 번호를 ë°›ì„ ìˆ˜ ì—†ìŒ: " -"%s" +"주 서버ì—ì„œ ë°ì´í„°ë² ì´ìŠ¤ 시스템 ì‹ë³„번호와 타임ë¼ì¸ 번호를 ë°›ì„ ìˆ˜ ì—†ìŒ: %s" #: replication/libpqwalreceiver/libpqwalreceiver.c:203 #: replication/libpqwalreceiver/libpqwalreceiver.c:357 @@ -15934,8 +16022,8 @@ msgid "" "Could not identify system: got %d rows and %d fields, expected %d rows and " "%d or more fields." msgstr "" -"ì‹œìŠ¤í…œì„ ì‹ë³„í•  수 ì—†ìŒ: 로우수 %d, 필드수 %d, 예ìƒê°’: 로우수 %d, 필드수 " -"%d ì´ìƒ" +"ì‹œìŠ¤í…œì„ ì‹ë³„í•  수 ì—†ìŒ: 로우수 %d, 필드수 %d, 예ìƒê°’: 로우수 %d, 필드수 %d " +"ì´ìƒ" #: replication/libpqwalreceiver/libpqwalreceiver.c:220 #, c-format @@ -15980,9 +16068,7 @@ msgstr "주 서버ì—ì„œ 타임ë¼ì¸ ë‚´ì—­ 파ì¼ì„ ë°›ì„ ìˆ˜ ì—†ìŒ: %s" #: replication/libpqwalreceiver/libpqwalreceiver.c:358 #, c-format msgid "Expected 1 tuple with 2 fields, got %d tuples with %d fields." -msgstr "" -"2ê°œì˜ ì¹¼ëŸ¼ìœ¼ë¡œ ëœ í•˜ë‚˜ì˜ íŠœí”Œì„ ì˜ˆìƒí•˜ì§€ë§Œ, %d 튜플 (%d 칼럼)ì„ " -"수신함" +msgstr "2ê°œì˜ ì¹¼ëŸ¼ìœ¼ë¡œ ëœ í•˜ë‚˜ì˜ íŠœí”Œì„ ì˜ˆìƒí•˜ì§€ë§Œ, %d 튜플 (%d 칼럼)ì„ ìˆ˜ì‹ í•¨" #: replication/libpqwalreceiver/libpqwalreceiver.c:386 #, c-format @@ -15990,7 +16076,7 @@ msgid "invalid socket: %s" msgstr "ìž˜ëª»ëœ ì†Œì¼“: %s" #: replication/libpqwalreceiver/libpqwalreceiver.c:426 -#: storage/ipc/latch.c:1277 +#: storage/ipc/latch.c:1280 #, c-format msgid "select() failed: %m" msgstr "select() 실패: %m" @@ -16064,7 +16150,9 @@ msgstr "" #: replication/logical/logicalfuncs.c:113 replication/slotfuncs.c:32 #, c-format msgid "must be superuser or replication role to use replication slots" -msgstr "복제 ìŠ¬ë¡¯ì€ superuser ë˜ëŠ” replication 롤 ì˜µì…˜ì„ í¬í•¨í•œ 사용ìžë§Œ 사용할 수 있습니다." +msgstr "" +"복제 ìŠ¬ë¡¯ì€ superuser ë˜ëŠ” replication 롤 ì˜µì…˜ì„ í¬í•¨í•œ 사용ìžë§Œ 사용할 수 있" +"습니다." #: replication/logical/logicalfuncs.c:152 #, c-format @@ -16138,7 +16226,8 @@ msgstr "\"%s\" 파ì¼ì„ ì½ì„ 수 ì—†ìŒ: %d ì½ìŒ, ì „ì²´ %zu" #: replication/logical/origin.c:712 #, c-format msgid "could not find free replication state, increase max_replication_slots" -msgstr "사용 가능한 복제 ìŠ¬ë¡¯ì´ ë¶€ì¡±í•©ë‹ˆë‹¤. max_replication_slots ê°’ì„ ëŠ˜ë¦¬ì„¸ìš”" +msgstr "" +"사용 가능한 복제 ìŠ¬ë¡¯ì´ ë¶€ì¡±í•©ë‹ˆë‹¤. max_replication_slots ê°’ì„ ëŠ˜ë¦¬ì„¸ìš”" #: replication/logical/origin.c:730 #, c-format @@ -16194,7 +16283,8 @@ msgstr "reorderbuffer 처리용 파ì¼ì—ì„œ ì½ê¸° 실패: %m" #, c-format msgid "" "could not read from reorderbuffer spill file: read %d instead of %u bytes" -msgstr "reorderbuffer 처리용 파ì¼ì—ì„œ ì½ê¸° 실패: %d ë°”ì´íŠ¸ ì½ìŒ, 기대값 %u ë°”ì´íŠ¸" +msgstr "" +"reorderbuffer 처리용 파ì¼ì—ì„œ ì½ê¸° 실패: %d ë°”ì´íŠ¸ ì½ìŒ, 기대값 %u ë°”ì´íŠ¸" #: replication/logical/reorderbuffer.c:3106 #, c-format @@ -16287,7 +16377,8 @@ msgid "" "Replication slot names may only contain lower case letters, numbers, and the " "underscore character." msgstr "" -"복제 슬롯 ì´ë¦„으로 사용할 수 있는 문ìžëŠ” ì˜ë¬¸ 소문ìž, 숫ìž, 밑줄(_) 문ìžìž…니다." +"복제 슬롯 ì´ë¦„으로 사용할 수 있는 문ìžëŠ” ì˜ë¬¸ 소문ìž, 숫ìž, 밑줄(_) 문ìžìž…니" +"다." #: replication/slot.c:254 #, c-format @@ -16373,8 +16464,8 @@ msgid "" "The transaction has already committed locally, but might not have been " "replicated to the standby." msgstr "" -"주 서버ì—서는 ì´ íŠ¸ëžœìž­ì…˜ì´ ì»¤ë°‹ë˜ì—ˆì§€ë§Œ, 복제용 대기 서버ì—서는 " -"ì•„ì§ ì»¤ë°‹ ë˜ì§€ ì•Šì•˜ì„ ê°€ëŠ¥ì„±ì´ ìžˆìŠµë‹ˆë‹¤." +"주 서버ì—서는 ì´ íŠ¸ëžœìž­ì…˜ì´ ì»¤ë°‹ë˜ì—ˆì§€ë§Œ, 복제용 대기 서버ì—서는 ì•„ì§ ì»¤ë°‹ ë˜" +"지 ì•Šì•˜ì„ ê°€ëŠ¥ì„±ì´ ìžˆìŠµë‹ˆë‹¤." #: replication/syncrep.c:238 #, c-format @@ -16396,6 +16487,11 @@ msgstr "\"%s\" 대기 ì„œë²„ì˜ ë™ê¸°ì‹ 복제 우선순위가 %u ë¡œ 변경 msgid "synchronous_standby_names parser failed" msgstr "synchronous_standby_names ê°’ì„ ë¶„ì„í•  수 ì—†ìŒ" +#: replication/syncrep.c:927 +#, c-format +msgid "number of synchronous standbys (%d) must be greater than zero" +msgstr "ë™ê¸°ì‹ 대기 서버 수 (%d)는 0보다 커야 합니다." + #: replication/walreceiver.c:173 #, c-format msgid "terminating walreceiver process due to administrator command" @@ -16404,7 +16500,8 @@ msgstr "ê´€ë¦¬ìž ëª…ë ¹ìœ¼ë¡œ ì¸í•´ WAL 수신기를 종료합니다." #: replication/walreceiver.c:344 #, c-format msgid "highest timeline %u of the primary is behind recovery timeline %u" -msgstr "주 ì„œë²„ì˜ ì œì¼ ìµœì‹ ì˜ íƒ€ìž„ë¼ì¸ì€ %u ì¸ë°, 복구 타임ë¼ì¸ %u 보다 옛것입니다" +msgstr "" +"주 ì„œë²„ì˜ ì œì¼ ìµœì‹ ì˜ íƒ€ìž„ë¼ì¸ì€ %u ì¸ë°, 복구 타임ë¼ì¸ %u 보다 옛것입니다" #: replication/walreceiver.c:377 #, c-format @@ -16470,8 +16567,7 @@ msgstr "ë¬¼ë¦¬ì  ë³µì œì—ì„œ ë…¼ë¦¬ì  ë³µì œ ìŠ¬ë¡¯ì„ ì‚¬ìš©í•  수 ì—†ìŒ" #, c-format msgid "" "requested starting point %X/%X on timeline %u is not in this server's history" -msgstr "" -"ìš”ì²­ëœ %X/%X 시작 위치(타임ë¼ì¸ %u)ê°€ ì´ ì„œë²„ ë‚´ì—­ì— ì—†ìŠµë‹ˆë‹¤." +msgstr "ìš”ì²­ëœ %X/%X 시작 위치(타임ë¼ì¸ %u)ê°€ ì´ ì„œë²„ ë‚´ì—­ì— ì—†ìŠµë‹ˆë‹¤." #: replication/walsender.c:603 #, c-format @@ -16485,47 +16581,47 @@ msgid "" "server %X/%X" msgstr "" -#: replication/walsender.c:974 +#: replication/walsender.c:972 #, c-format msgid "terminating walsender process after promotion" msgstr "ìš´ì˜ì „환 ë’¤ wal 송신기 프로세스를 중지합니다." -#: replication/walsender.c:1300 +#: replication/walsender.c:1298 #, c-format msgid "received replication command: %s" msgstr "ìˆ˜ì‹ ëœ ë³µì œ 명령: %s" -#: replication/walsender.c:1391 replication/walsender.c:1407 +#: replication/walsender.c:1397 replication/walsender.c:1413 #, c-format msgid "unexpected EOF on standby connection" msgstr "대기 서버 ì—°ê²°ì—ì„œ 예ìƒì¹˜ 못한 EOF 발견함" -#: replication/walsender.c:1421 +#: replication/walsender.c:1427 #, c-format msgid "unexpected standby message type \"%c\", after receiving CopyDone" msgstr "" -#: replication/walsender.c:1459 +#: replication/walsender.c:1465 #, c-format msgid "invalid standby message type \"%c\"" msgstr "ìž˜ëª»ëœ ëŒ€ê¸° 서버 메시지 형태 \"%c\"" -#: replication/walsender.c:1500 +#: replication/walsender.c:1506 #, c-format msgid "unexpected message type \"%c\"" msgstr "예ìƒì¹˜ 못한 메시지 형태: \"%c\"" -#: replication/walsender.c:1784 +#: replication/walsender.c:1790 #, c-format msgid "terminating walsender process due to replication timeout" msgstr "복제 시간 제한으로 wal 송신기 프로세스를 종료합니다." -#: replication/walsender.c:1877 +#: replication/walsender.c:1875 #, c-format msgid "standby \"%s\" has now caught up with primary" msgstr "\"%s\" 대기 서버가 ìš´ì˜ ì„œë²„ë¡œ 전환합니다" -#: replication/walsender.c:1980 +#: replication/walsender.c:1978 #, c-format msgid "" "number of requested standby connections exceeds max_wal_senders (currently " @@ -16629,14 +16725,14 @@ msgstr "\"%s\" í…Œì´ë¸”ì„ ìƒì† 받는 í…Œì´ë¸”ì´ ìžˆì–´ ë·°ë¡œ 변활할 #, c-format msgid "" "could not convert table \"%s\" to a view because it has row security enabled" -msgstr "로우단위 보안 ê¸°ëŠ¥ì„ ì‚¬ìš©í•˜ê³  있어 \"%s\" í…Œì´ë¸”ì„ ë·°ë¡œ 변환할 수 없습니다" +msgstr "" +"로우단위 보안 ê¸°ëŠ¥ì„ ì‚¬ìš©í•˜ê³  있어 \"%s\" í…Œì´ë¸”ì„ ë·°ë¡œ 변환할 수 없습니다" #: rewrite/rewriteDefine.c:465 #, c-format msgid "" "could not convert table \"%s\" to a view because it has row security policies" -msgstr "" -"로우단위 보안 ì„¤ì •ì´ ë˜ì–´ 있어 \"%s\" í…Œì´ë¸”ì„ ë·°ë¡œ 변환할 수 없습니다" +msgstr "로우단위 보안 ì„¤ì •ì´ ë˜ì–´ 있어 \"%s\" í…Œì´ë¸”ì„ ë·°ë¡œ 변환할 수 없습니다" #: rewrite/rewriteDefine.c:492 #, c-format @@ -16672,7 +16768,8 @@ msgstr "ë·°ì—ì„œ ì‚­ì œëœ ì—´ì„ í¬í•¨í•˜ê³  있는 릴레ì´ì…˜ì„ 변환할 #, c-format msgid "" "cannot create a RETURNING list for a relation containing dropped columns" -msgstr "릴레ì´ì…˜ì— ì‚­ì œëœ ì—´ì„ í¬í•¨í•˜ê³  있는 RETURNING 목ë¡ì„ 만들 수 없습니다." +msgstr "" +"릴레ì´ì…˜ì— ì‚­ì œëœ ì—´ì„ í¬í•¨í•˜ê³  있는 RETURNING 목ë¡ì„ 만들 수 없습니다." #: rewrite/rewriteDefine.c:702 #, c-format @@ -17002,7 +17099,8 @@ msgstr "ì´ ë¬¸ì œëŠ” 커ë„ì˜ ë¬¸ì œë¡œ 알려졌습니다. ì‹œìŠ¤í…œì„ ì—… #: storage/buffer/bufmgr.c:907 #, c-format msgid "invalid page in block %u of relation %s; zeroing out page" -msgstr "%u 블ë¡(해당 릴레ì´ì…˜: %s)ì— ìž˜ëª»ëœ íŽ˜ì´ì§€ í—¤ë”ê°€ 있ìŒ, 페ì´ì§€ë¥¼ 삭제하는 중" +msgstr "" +"%u 블ë¡(해당 릴레ì´ì…˜: %s)ì— ìž˜ëª»ëœ íŽ˜ì´ì§€ í—¤ë”ê°€ 있ìŒ, 페ì´ì§€ë¥¼ 삭제하는 중" #: storage/buffer/bufmgr.c:3952 #, c-format @@ -17034,32 +17132,32 @@ msgstr "비어 있는 로컬 버í¼ê°€ 없습니다" msgid "cannot access temporary tables during a parallel operation" msgstr "병렬 ìž‘ì—… ì¤‘ì— ìž„ì‹œ í…Œì´ë¸”ì— ì•¡ì„¸ìŠ¤í•  수 ì—†ìŒ" -#: storage/file/fd.c:436 storage/file/fd.c:508 storage/file/fd.c:544 +#: storage/file/fd.c:443 storage/file/fd.c:515 storage/file/fd.c:551 #, c-format msgid "could not flush dirty data: %m" msgstr "dirty ìžë£Œë¥¼ flush í•  수 ì—†ìŒ: %m" -#: storage/file/fd.c:466 +#: storage/file/fd.c:473 #, c-format msgid "could not determine dirty data size: %m" msgstr "dirty ìžë£Œ í¬ê¸°ë¥¼ 확ì¸í•  수 ì—†ìŒ: %m" -#: storage/file/fd.c:518 +#: storage/file/fd.c:525 #, c-format msgid "could not munmap() while flushing data: %m" msgstr "ìžë£Œ flush ìž‘ì—… ë„중 munmap() 호출 실패: %m" -#: storage/file/fd.c:682 +#: storage/file/fd.c:689 #, c-format msgid "could not link file \"%s\" to \"%s\": %m" msgstr "\"%s\" 파ì¼ì„ \"%s\" 파ì¼ë¡œ ë§í¬í•  수 ì—†ìŒ: %m" -#: storage/file/fd.c:776 +#: storage/file/fd.c:783 #, c-format msgid "getrlimit failed: %m" msgstr "getrlimit 실패: %m" -#: storage/file/fd.c:866 +#: storage/file/fd.c:873 #, c-format msgid "insufficient file descriptors available to start server process" msgstr "" @@ -17067,45 +17165,45 @@ msgstr "" "그램ì—ì„œ 너무 ë§Žì€ íŒŒì¼ì„ ì—´ì–´ ë‘ê³  있습니다. 다른 í”„ë¡œê·¸ëž¨ë“¤ì„ ì¢€ ë‹«ê³  다시 " "ì‹œë„í•´ 보십시오" -#: storage/file/fd.c:867 +#: storage/file/fd.c:874 #, c-format msgid "System allows %d, we need at least %d." msgstr "시스템 허용치 %d, 서버 최소 허용치 %d." -#: storage/file/fd.c:908 storage/file/fd.c:2001 storage/file/fd.c:2094 -#: storage/file/fd.c:2242 +#: storage/file/fd.c:915 storage/file/fd.c:2078 storage/file/fd.c:2171 +#: storage/file/fd.c:2319 #, c-format msgid "out of file descriptors: %m; release and retry" msgstr "" "ì—´ë ¤ 있는 파ì¼ì´ 너무 많습니다: %m; 다른 í”„ë¡œê·¸ëž¨ë“¤ì„ ì¢€ ë‹«ê³  다시 ì‹œë„í•´ ë³´" "십시오" -#: storage/file/fd.c:1482 +#: storage/file/fd.c:1520 #, c-format msgid "temporary file: path \"%s\", size %lu" msgstr "ìž„ì‹œ 파ì¼: 경로 \"%s\", í¬ê¸° %lu" -#: storage/file/fd.c:1656 +#: storage/file/fd.c:1717 #, c-format msgid "temporary file size exceeds temp_file_limit (%dkB)" msgstr "ìž„ì‹œ íŒŒì¼ í¬ê¸°ê°€ temp_file_limit (%dkB)를 초과했습니다" -#: storage/file/fd.c:1977 storage/file/fd.c:2027 +#: storage/file/fd.c:2054 storage/file/fd.c:2104 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to open file \"%s\"" msgstr "" -#: storage/file/fd.c:2067 +#: storage/file/fd.c:2144 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to execute command \"%s\"" msgstr "" -#: storage/file/fd.c:2218 +#: storage/file/fd.c:2295 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to open directory \"%s\"" msgstr "" -#: storage/file/fd.c:2304 +#: storage/file/fd.c:2381 #, c-format msgid "could not read directory \"%s\": %m" msgstr "\"%s\" 디렉터리를 ì½ì„ 수 ì—†ìŒ: %m" @@ -17187,17 +17285,17 @@ msgstr "\"%s\" 공유 메모리 ì¡°ê°ì„ 만들 수 ì—†ìŒ: %m" msgid "could not duplicate handle for \"%s\": %m" msgstr "\"%s\" ìš© 헨들러를 ì´ì¤‘í™” í•  수 ì—†ìŒ: %m" -#: storage/ipc/latch.c:775 +#: storage/ipc/latch.c:778 #, c-format msgid "epoll_ctl() failed: %m" msgstr "epoll_ctl() 실패: %m" -#: storage/ipc/latch.c:999 +#: storage/ipc/latch.c:1002 #, c-format msgid "epoll_wait() failed: %m" msgstr "epoll_wait() 실패: %m" -#: storage/ipc/latch.c:1119 +#: storage/ipc/latch.c:1122 #, c-format msgid "poll() failed: %m" msgstr "poll() 실패: %m" @@ -17216,8 +17314,7 @@ msgstr "공유 메모리 부족" #, c-format msgid "" "not enough shared memory for data structure \"%s\" (%zu bytes requested)" -msgstr "" -"\"%s\" ìžë£Œ 구조체용 공유 메모리가 부족함 (%zu ë°”ì´íŠ¸ê°€ 필요함)" +msgstr "\"%s\" ìžë£Œ 구조체용 공유 메모리가 부족함 (%zu ë°”ì´íŠ¸ê°€ 필요함)" #: storage/ipc/shmem.c:389 #, c-format @@ -17237,12 +17334,12 @@ msgstr "" msgid "requested shared memory size overflows size_t" msgstr "지정한 공유 메모리 사ì´ì¦ˆê°€ size_t í¬ê¸°ë¥¼ 초과했습니다" -#: storage/ipc/standby.c:528 tcop/postgres.c:2976 +#: storage/ipc/standby.c:530 tcop/postgres.c:2976 #, c-format msgid "canceling statement due to conflict with recovery" msgstr "복구 ìž‘ì—… 중 충ëŒì´ ë°œìƒí•´ ìž‘ì—…ì„ ì¤‘ì§€í•©ë‹ˆë‹¤." -#: storage/ipc/standby.c:529 tcop/postgres.c:2263 +#: storage/ipc/standby.c:531 tcop/postgres.c:2263 #, c-format msgid "User transaction caused buffer deadlock with recovery." msgstr "복구 ìž‘ì—… 중 ì‚¬ìš©ìž íŠ¸ëžœìž­ì…˜ì´ ë²„í¼ ë°ë“œë½ì„ 만들었습니다." @@ -17327,7 +17424,8 @@ msgstr "%u,%u ê°±ì‹ ëœ íŠœí”Œ(해당 릴레ì´ì…˜: \"%s\")ì„ ìž¬í™•ì¸í•˜ëŠ” #: storage/lmgr/lmgr.c:740 #, c-format msgid "while checking exclusion constraint on tuple (%u,%u) in relation \"%s\"" -msgstr "%u,%u 튜플(해당 릴레ì´ì…˜: \"%s\")ì˜ ì œì™¸ 제약 ì¡°ê±´ì„ ê²€ì‚¬í•˜ëŠ” ì¤‘ì— ë°œìƒ" +msgstr "" +"%u,%u 튜플(해당 릴레ì´ì…˜: \"%s\")ì˜ ì œì™¸ 제약 ì¡°ê±´ì„ ê²€ì‚¬í•˜ëŠ” ì¤‘ì— ë°œìƒ" #: storage/lmgr/lmgr.c:960 #, c-format @@ -17470,13 +17568,13 @@ msgstr "" msgid "a snapshot-importing transaction must not be READ ONLY DEFERRABLE" msgstr "" -#: storage/lmgr/predicate.c:1706 utils/time/snapmgr.c:576 -#: utils/time/snapmgr.c:582 +#: storage/lmgr/predicate.c:1706 utils/time/snapmgr.c:617 +#: utils/time/snapmgr.c:623 #, c-format msgid "could not import the requested snapshot" msgstr "" -#: storage/lmgr/predicate.c:1707 utils/time/snapmgr.c:583 +#: storage/lmgr/predicate.c:1707 utils/time/snapmgr.c:624 #, c-format msgid "The source transaction %u is not running anymore." msgstr "%u 소스 íŠ¸ëžœìž­ì…˜ì€ ë”ì´ìƒ 실행 중ì´ì§€ 않습니다." @@ -17495,8 +17593,7 @@ msgstr "max_pred_locks_per_transaction ê°’ì„ ëŠ˜ë ¤ì•¼ í•  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤. #, c-format msgid "" "could not serialize access due to read/write dependencies among transactions" -msgstr "" -"트랜잭션간 ì½ê¸°/쓰기 ì˜ì¡´ì„± ë•Œë¬¸ì— serialize ì ‘ê·¼ì„ í•  수 ì—†ìŒ" +msgstr "트랜잭션간 ì½ê¸°/쓰기 ì˜ì¡´ì„± ë•Œë¬¸ì— serialize ì ‘ê·¼ì„ í•  수 ì—†ìŒ" #: storage/lmgr/predicate.c:3893 storage/lmgr/predicate.c:3982 #: storage/lmgr/predicate.c:3990 storage/lmgr/predicate.c:4029 @@ -17507,49 +17604,47 @@ msgstr "" msgid "The transaction might succeed if retried." msgstr "재시ë„하면 ê·¸ íŠ¸ëžœìž­ì…˜ì´ ì„±ê³µí•  것입니다." -#: storage/lmgr/proc.c:1263 +#: storage/lmgr/proc.c:1265 #, c-format msgid "Process %d waits for %s on %s." msgstr "%d 프로세스가 대기중, 잠금종류: %s, ë‚´ìš©: %s" -#: storage/lmgr/proc.c:1274 +#: storage/lmgr/proc.c:1276 #, c-format msgid "sending cancel to blocking autovacuum PID %d" msgstr "%d PID autovacuum 블럭킹하기 위해 취소 신호를 보냅니다" -#: storage/lmgr/proc.c:1292 utils/adt/misc.c:270 +#: storage/lmgr/proc.c:1294 utils/adt/misc.c:270 #, c-format msgid "could not send signal to process %d: %m" msgstr "%d 프로세스로 시스템신호(signal)를 보낼 수 없습니다: %m" -#: storage/lmgr/proc.c:1394 +#: storage/lmgr/proc.c:1396 #, c-format msgid "" "process %d avoided deadlock for %s on %s by rearranging queue order after " "%ld.%03d ms" msgstr "" -"%d PID 프로세스는 %s(%s)ì— ëŒ€í•´ êµì°© ìƒíƒœê°€ ë°œìƒí•˜ì§€ ì•Šë„ë¡ " -"%ld.%03dms í›„ì— ëŒ€ê¸°ì—´ 순서를 다시 조정함" +"%d PID 프로세스는 %s(%s)ì— ëŒ€í•´ êµì°© ìƒíƒœê°€ ë°œìƒí•˜ì§€ ì•Šë„ë¡ %ld.%03dms í›„ì— " +"대기열 순서를 다시 조정함" -#: storage/lmgr/proc.c:1409 +#: storage/lmgr/proc.c:1411 #, c-format msgid "" "process %d detected deadlock while waiting for %s on %s after %ld.%03d ms" -msgstr "" -"%d PID 프로세스ì—ì„œ %s(%s) 대기중 %ld.%03dms í›„ì— êµì°© ìƒíƒœë¥¼ " -"ê°ì§€í•¨" +msgstr "%d PID 프로세스ì—ì„œ %s(%s) 대기중 %ld.%03dms í›„ì— êµì°© ìƒíƒœë¥¼ ê°ì§€í•¨" -#: storage/lmgr/proc.c:1418 +#: storage/lmgr/proc.c:1420 #, c-format msgid "process %d still waiting for %s on %s after %ld.%03d ms" msgstr "%d PID 프로세스ì—ì„œ 여전히 %s(%s) ìž‘ì—…ì„ ê¸°ë‹¤ë¦¬ê³  있ìŒ(%ld.%03dms 후)" -#: storage/lmgr/proc.c:1425 +#: storage/lmgr/proc.c:1427 #, c-format msgid "process %d acquired %s on %s after %ld.%03d ms" msgstr "%d PID 프로세스가 %s(%s) ìž‘ì—…ì„ ìœ„í•´ 잠금 ì·¨ë“함(%ld.%03dms 후)" -#: storage/lmgr/proc.c:1441 +#: storage/lmgr/proc.c:1443 #, c-format msgid "process %d failed to acquire %s on %s after %ld.%03d ms" msgstr "프로세스 %dì—ì„œ %s(%s)ì„(를) ì·¨ë“하지 못함(%ld.%03dms 후)" @@ -17662,8 +17757,7 @@ msgstr "요청 íê°€ ê°€ë“ì°¨ forward fsync ìš”ì²­ì„ ì²˜ë¦¬í•  수 ì—†ìŒ" msgid "" "could not open file \"%s\" (target block %u): previous segment is only %u " "blocks" -msgstr "" -"\"%s\" 파ì¼ì„ 열기 실패(ëŒ€ìƒ ë¸”ë¡: %u): ì´ì „ ì¡°ê°ì€ %u 블럭 ë¿ìž„" +msgstr "\"%s\" 파ì¼ì„ 열기 실패(ëŒ€ìƒ ë¸”ë¡: %u): ì´ì „ ì¡°ê°ì€ %u 블럭 ë¿ìž„" #: storage/smgr/md.c:1877 #, c-format @@ -17723,7 +17817,7 @@ msgid "unexpected EOF on client connection" msgstr "í´ë¼ì´ì–¸íŠ¸ ì—°ê²°ì—ì„œ 예ìƒì¹˜ ì•Šì€ EOF 발견ë¨" #: tcop/postgres.c:438 tcop/postgres.c:450 tcop/postgres.c:461 -#: tcop/postgres.c:473 tcop/postgres.c:4308 +#: tcop/postgres.c:473 tcop/postgres.c:4314 #, c-format msgid "invalid frontend message type %d" msgstr "ìž˜ëª»ëœ frontend 메시지 형태 %d" @@ -17983,27 +18077,27 @@ msgstr "%s: ìž˜ëª»ëœ ëª…ë ¹í–‰ ì¸ìž: %s" msgid "%s: no database nor user name specified" msgstr "%s: ë°ì´í„°ë² ì´ìŠ¤ì™€ 사용ìžë¥¼ 지정하지 않았습니다" -#: tcop/postgres.c:4216 +#: tcop/postgres.c:4222 #, c-format msgid "invalid CLOSE message subtype %d" msgstr "ìž˜ëª»ëœ CLOSE 메시지 서브타입 %d" -#: tcop/postgres.c:4251 +#: tcop/postgres.c:4257 #, c-format msgid "invalid DESCRIBE message subtype %d" msgstr "ìž˜ëª»ëœ DESCRIBE 메시지 서브타입 %d" -#: tcop/postgres.c:4329 +#: tcop/postgres.c:4335 #, c-format msgid "fastpath function calls not supported in a replication connection" msgstr "복제 ì—°ê²°ì—서는 fastpath 함수 í˜¸ì¶œì„ ì§€ì›í•˜ì§€ 않습니다" -#: tcop/postgres.c:4333 +#: tcop/postgres.c:4339 #, c-format msgid "extended query protocol not supported in a replication connection" msgstr "" -#: tcop/postgres.c:4503 +#: tcop/postgres.c:4509 #, c-format msgid "" "disconnection: session time: %d:%02d:%02d.%03d user=%s database=%s host=%s%s" @@ -18137,8 +18231,7 @@ msgstr "기준어 í•­ëª©ì— ë„ˆë¬´ ë§Žì€ ì–´íœ˜ì†Œê°€ 있ìŒ" #, c-format msgid "" "thesaurus sample word \"%s\" isn't recognized by subdictionary (rule %d)" -msgstr "" -"\"%s\" 기준 단어는 하위 사전ì—ì„œ ì¸ì‹í•  수 ì—†ìŒ(규칙 %d)" +msgstr "\"%s\" 기준 단어는 하위 사전ì—ì„œ ì¸ì‹í•  수 ì—†ìŒ(규칙 %d)" #: tsearch/dict_thesaurus.c:426 #, c-format @@ -18159,8 +18252,7 @@ msgstr "\"%s\" ë™ì˜ì–´ 사전 대체 단어는 중지 단어임(규칙 %d)" #, c-format msgid "" "thesaurus substitute word \"%s\" isn't recognized by subdictionary (rule %d)" -msgstr "" -"\"%s\" ë™ì˜ì–´ 사전 대체 단어는 하위 사전ì—ì„œ ì¸ì‹í•  수 ì—†ìŒ(규칙 %d)" +msgstr "\"%s\" ë™ì˜ì–´ 사전 대체 단어는 하위 사전ì—ì„œ ì¸ì‹í•  수 ì—†ìŒ(규칙 %d)" #: tsearch/dict_thesaurus.c:594 #, c-format @@ -18214,7 +18306,7 @@ msgid "invalid regular expression: %s" msgstr "ìž˜ëª»ëœ ì •ê·œì‹: %s" #: tsearch/spell.c:954 tsearch/spell.c:971 tsearch/spell.c:988 -#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14401 gram.y:14418 +#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14405 gram.y:14422 #, c-format msgid "syntax error" msgstr "구문 오류" @@ -18247,7 +18339,7 @@ msgid "affix file contains both old-style and new-style commands" msgstr "affix 파ì¼ì— 옛방ì‹ê³¼ ìƒˆë°©ì‹ ëª…ë ¹ì´ í•¨ê»˜ 있습니다" #: tsearch/to_tsany.c:170 utils/adt/tsvector.c:270 -#: utils/adt/tsvector_op.c:1132 +#: utils/adt/tsvector_op.c:1133 #, c-format msgid "string is too long for tsvector (%d bytes, max %d bytes)" msgstr "" @@ -18429,27 +18521,27 @@ msgstr "\"%s\" ë¡¤ì˜ êµ¬ì„±ì›ì´ì–´ì•¼ 함" #: utils/adt/array_expanded.c:274 utils/adt/arrayfuncs.c:931 #: utils/adt/arrayfuncs.c:1519 utils/adt/arrayfuncs.c:3251 -#: utils/adt/arrayfuncs.c:3389 utils/adt/arrayfuncs.c:5860 -#: utils/adt/arrayfuncs.c:6171 utils/adt/arrayutils.c:93 +#: utils/adt/arrayfuncs.c:3389 utils/adt/arrayfuncs.c:5848 +#: utils/adt/arrayfuncs.c:6159 utils/adt/arrayutils.c:93 #: utils/adt/arrayutils.c:102 utils/adt/arrayutils.c:109 #, c-format msgid "array size exceeds the maximum allowed (%d)" msgstr "ë°°ì—´ í¬ê¸°ê°€ 최대치 (%d)를 초과했습니다" -#: utils/adt/array_userfuncs.c:67 utils/adt/array_userfuncs.c:529 -#: utils/adt/array_userfuncs.c:609 utils/adt/json.c:1759 utils/adt/json.c:1854 +#: utils/adt/array_userfuncs.c:79 utils/adt/array_userfuncs.c:541 +#: utils/adt/array_userfuncs.c:621 utils/adt/json.c:1759 utils/adt/json.c:1854 #: utils/adt/json.c:1892 utils/adt/jsonb.c:1126 utils/adt/jsonb.c:1155 #: utils/adt/jsonb.c:1591 utils/adt/jsonb.c:1755 utils/adt/jsonb.c:1765 #, c-format msgid "could not determine input data type" msgstr "ìž…ë ¥ ìžë£Œí˜•ì„ ê²°ì •í•  수 ì—†ìŒ" -#: utils/adt/array_userfuncs.c:72 +#: utils/adt/array_userfuncs.c:84 #, c-format msgid "input data type is not an array" msgstr "ìž…ë ¥ ìžë£Œí˜•ì´ ë°°ì—´ì´ ì•„ë‹™ë‹ˆë‹¤." -#: utils/adt/array_userfuncs.c:120 utils/adt/array_userfuncs.c:174 +#: utils/adt/array_userfuncs.c:132 utils/adt/array_userfuncs.c:186 #: utils/adt/arrayfuncs.c:1322 utils/adt/float.c:1228 utils/adt/float.c:1287 #: utils/adt/float.c:3556 utils/adt/float.c:3572 utils/adt/int.c:623 #: utils/adt/int.c:652 utils/adt/int.c:673 utils/adt/int.c:704 @@ -18463,53 +18555,53 @@ msgstr "ìž…ë ¥ ìžë£Œí˜•ì´ ë°°ì—´ì´ ì•„ë‹™ë‹ˆë‹¤." msgid "integer out of range" msgstr "정수 범위를 벗어남" -#: utils/adt/array_userfuncs.c:127 utils/adt/array_userfuncs.c:184 +#: utils/adt/array_userfuncs.c:139 utils/adt/array_userfuncs.c:196 #, c-format msgid "argument must be empty or one-dimensional array" msgstr "ì¸ìžëŠ” 비어있거나 1ì°¨ì› ë°°ì—´ì´ì–´ì•¼ 합니다." -#: utils/adt/array_userfuncs.c:266 utils/adt/array_userfuncs.c:305 -#: utils/adt/array_userfuncs.c:342 utils/adt/array_userfuncs.c:371 -#: utils/adt/array_userfuncs.c:399 +#: utils/adt/array_userfuncs.c:278 utils/adt/array_userfuncs.c:317 +#: utils/adt/array_userfuncs.c:354 utils/adt/array_userfuncs.c:383 +#: utils/adt/array_userfuncs.c:411 #, c-format msgid "cannot concatenate incompatible arrays" msgstr "ì—°ê²°í•  수 없는 배열들 입니다." -#: utils/adt/array_userfuncs.c:267 +#: utils/adt/array_userfuncs.c:279 #, c-format msgid "" "Arrays with element types %s and %s are not compatible for concatenation." msgstr "%s ìžë£Œí˜•ì˜ ë°°ì—´ê³¼ %s ìžë£Œí˜•ì˜ ë°°ì—´ì€ ì—°ê²°í•  수 없습니다." -#: utils/adt/array_userfuncs.c:306 +#: utils/adt/array_userfuncs.c:318 #, c-format msgid "Arrays of %d and %d dimensions are not compatible for concatenation." msgstr "%dì°¨ì›(ë°°ì—´ 깊ì´) ë°°ì—´ê³¼ %dì°¨ì› ë°°ì—´ì€ ì—°ê²°í•  수 없습니다." -#: utils/adt/array_userfuncs.c:343 +#: utils/adt/array_userfuncs.c:355 #, c-format msgid "" "Arrays with differing element dimensions are not compatible for " "concatenation." msgstr "ì°¨ì›(ë°°ì—´ 깊ì´)ì´ ë‹¤ë¥¸ ë°°ì—´ë“¤ì„ ì„œë¡œ í•©ì¹  수 없습니다" -#: utils/adt/array_userfuncs.c:372 utils/adt/array_userfuncs.c:400 +#: utils/adt/array_userfuncs.c:384 utils/adt/array_userfuncs.c:412 #, c-format msgid "Arrays with differing dimensions are not compatible for concatenation." msgstr "ì°¨ì›(ë°°ì—´ 깊ì´)ì´ ë‹¤ë¥¸ ë°°ì—´ë“¤ì„ ì„œë¡œ í•©ì¹  수 없습니다" -#: utils/adt/array_userfuncs.c:468 utils/adt/arrayfuncs.c:1284 -#: utils/adt/arrayfuncs.c:3357 utils/adt/arrayfuncs.c:5760 +#: utils/adt/array_userfuncs.c:480 utils/adt/arrayfuncs.c:1284 +#: utils/adt/arrayfuncs.c:3357 utils/adt/arrayfuncs.c:5754 #, c-format msgid "invalid number of dimensions: %d" msgstr "ìž˜ëª»ëœ ë°°ì—´ ì°¨ì›(ë°°ì—´ 깊ì´): %d" -#: utils/adt/array_userfuncs.c:725 utils/adt/array_userfuncs.c:876 +#: utils/adt/array_userfuncs.c:737 utils/adt/array_userfuncs.c:889 #, c-format msgid "searching for elements in multidimensional arrays is not supported" msgstr "ë‹¤ì°¨ì› ë°°ì—´ì—ì„œ 요소 검색 ê¸°ëŠ¥ì€ ì§€ì›í•˜ì§€ ì•ŠìŒ" -#: utils/adt/array_userfuncs.c:749 +#: utils/adt/array_userfuncs.c:761 #, c-format msgid "initial position must not be null" msgstr "초기 ìœ„ì¹˜ê°’ì€ nullê°’ì´ ì•„ë‹ˆì—¬ì•¼ 함" @@ -18634,7 +18726,7 @@ msgstr "특정 í¬ê¸°ë¡œ ë°°ì—´ì„ ì ˆë‹¨í•˜ëŠ” ê¸°ëŠ¥ì€ êµ¬í˜„ë˜ì§€ 않습니 #: utils/adt/arrayfuncs.c:2230 utils/adt/arrayfuncs.c:2252 #: utils/adt/arrayfuncs.c:2301 utils/adt/arrayfuncs.c:2537 #: utils/adt/arrayfuncs.c:2848 utils/adt/arrayfuncs.c:5740 -#: utils/adt/arrayfuncs.c:5772 utils/adt/arrayfuncs.c:5789 +#: utils/adt/arrayfuncs.c:5766 utils/adt/arrayfuncs.c:5777 #: utils/adt/json.c:2290 utils/adt/json.c:2365 utils/adt/jsonb.c:1369 #: utils/adt/jsonb.c:1455 utils/adt/jsonfuncs.c:3529 #: utils/adt/jsonfuncs.c:3574 utils/adt/jsonfuncs.c:3621 @@ -18656,8 +18748,7 @@ msgstr "ê³ ì • ê¸¸ì´ ë°°ì—´ì˜ ìš”ì†Œì— null ê°’ì„ ì§€ì •í•  수 ì—†ìŒ" #: utils/adt/arrayfuncs.c:2795 #, c-format msgid "updates on slices of fixed-length arrays not implemented" -msgstr "" -"ê³ ì •ëœ í¬ê¸°ì˜ ë°°ì—´ì˜ ì¡°ê°ì„ ì—…ë°ì´íŠ¸ 하는 ê¸°ëŠ¥ì€ êµ¬í˜„ë˜ì§€ 않았습니다." +msgstr "ê³ ì •ëœ í¬ê¸°ì˜ ë°°ì—´ì˜ ì¡°ê°ì„ ì—…ë°ì´íŠ¸ 하는 ê¸°ëŠ¥ì€ êµ¬í˜„ë˜ì§€ 않았습니다." #: utils/adt/arrayfuncs.c:2826 #, c-format @@ -18717,42 +18808,32 @@ msgstr "ë°°ì—´ 차수가 서로 틀린 ë°°ì—´ì€ ëˆ„ì í•  수 ì—†ìŒ" msgid "dimension array or low bound array cannot be null" msgstr "ì°¨ì› ë°°ì—´ ë˜ëŠ” 하한 ë°°ì—´ì€ NULLì¼ ìˆ˜ ì—†ìŒ" -#: utils/adt/arrayfuncs.c:5741 utils/adt/arrayfuncs.c:5773 +#: utils/adt/arrayfuncs.c:5741 utils/adt/arrayfuncs.c:5767 #, c-format msgid "Dimension array must be one dimensional." msgstr "ì°¨ì› ë°°ì—´ì€ ì¼ì°¨ì› ë°°ì—´ì´ì–´ì•¼ 합니다." -#: utils/adt/arrayfuncs.c:5746 utils/adt/arrayfuncs.c:5778 -#, c-format -msgid "wrong range of array subscripts" -msgstr "ë°°ì—´ 하위 스í¬ë¦½íŠ¸ì˜ 범위가 잘못ë¨" - -#: utils/adt/arrayfuncs.c:5747 utils/adt/arrayfuncs.c:5779 -#, c-format -msgid "Lower bound of dimension array must be one." -msgstr "ì°¨ì› ë°°ì—´ì˜ í•˜í•œì€ 1ì´ì–´ì•¼ 합니다." - -#: utils/adt/arrayfuncs.c:5752 utils/adt/arrayfuncs.c:5784 +#: utils/adt/arrayfuncs.c:5746 utils/adt/arrayfuncs.c:5772 #, c-format msgid "dimension values cannot be null" msgstr "ì°¨ì› ê°’ì€ nullì¼ ìˆ˜ ì—†ìŒ" -#: utils/adt/arrayfuncs.c:5790 +#: utils/adt/arrayfuncs.c:5778 #, c-format msgid "Low bound array has different size than dimensions array." msgstr "하한 ë°°ì—´ì˜ í¬ê¸°ê°€ ì°¨ì› ë°°ì—´ê³¼ 다릅니다." -#: utils/adt/arrayfuncs.c:6036 +#: utils/adt/arrayfuncs.c:6024 #, c-format msgid "removing elements from multidimensional arrays is not supported" msgstr "ë‹¤ì°¨ì› ë°°ì—´ì—ì„œ 요소 ì‚­ì œê¸°ëŠ¥ì€ ì§€ì›ë˜ì§€ ì•ŠìŒ" -#: utils/adt/arrayfuncs.c:6313 +#: utils/adt/arrayfuncs.c:6301 #, c-format msgid "thresholds must be one-dimensional array" msgstr "threshold ê°’ì€ 1ì°¨ì› ë°°ì—´ì´ì–´ì•¼ 합니다." -#: utils/adt/arrayfuncs.c:6318 +#: utils/adt/arrayfuncs.c:6306 #, c-format msgid "thresholds array must not contain NULLs" msgstr "threshold ë°°ì—´ì—는 nullì´ í¬í•¨ë˜ì§€ 않아야 함" @@ -18796,7 +18877,7 @@ msgstr "money ìžë£Œí˜•ì— 대한 ìž˜ëª»ëœ ìž…ë ¥: \"%s\"" #: utils/adt/int8.c:657 utils/adt/int8.c:897 utils/adt/int8.c:1005 #: utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6818 #: utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 -#: utils/adt/timestamp.c:3446 +#: utils/adt/timestamp.c:3499 #, c-format msgid "division by zero" msgstr "0으로는 나눌수 없습니다." @@ -18868,25 +18949,25 @@ msgstr "날짜가 타임스탬프 범위를 벗어남" #: utils/adt/jsonb.c:847 utils/adt/nabstime.c:455 utils/adt/nabstime.c:498 #: utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 utils/adt/timestamp.c:224 #: utils/adt/timestamp.c:268 utils/adt/timestamp.c:726 -#: utils/adt/timestamp.c:735 utils/adt/timestamp.c:820 -#: utils/adt/timestamp.c:860 utils/adt/timestamp.c:3021 -#: utils/adt/timestamp.c:3042 utils/adt/timestamp.c:3055 -#: utils/adt/timestamp.c:3064 utils/adt/timestamp.c:3072 -#: utils/adt/timestamp.c:3127 utils/adt/timestamp.c:3150 -#: utils/adt/timestamp.c:3163 utils/adt/timestamp.c:3174 -#: utils/adt/timestamp.c:3182 utils/adt/timestamp.c:3756 -#: utils/adt/timestamp.c:3885 utils/adt/timestamp.c:3926 -#: utils/adt/timestamp.c:4014 utils/adt/timestamp.c:4060 -#: utils/adt/timestamp.c:4171 utils/adt/timestamp.c:4578 -#: utils/adt/timestamp.c:4694 utils/adt/timestamp.c:4704 -#: utils/adt/timestamp.c:4800 utils/adt/timestamp.c:4919 -#: utils/adt/timestamp.c:4929 utils/adt/timestamp.c:5250 -#: utils/adt/timestamp.c:5264 utils/adt/timestamp.c:5269 -#: utils/adt/timestamp.c:5283 utils/adt/timestamp.c:5366 -#: utils/adt/timestamp.c:5398 utils/adt/timestamp.c:5405 -#: utils/adt/timestamp.c:5431 utils/adt/timestamp.c:5435 -#: utils/adt/timestamp.c:5504 utils/adt/timestamp.c:5508 -#: utils/adt/timestamp.c:5522 utils/adt/timestamp.c:5560 utils/adt/xml.c:2049 +#: utils/adt/timestamp.c:735 utils/adt/timestamp.c:817 +#: utils/adt/timestamp.c:857 utils/adt/timestamp.c:3074 +#: utils/adt/timestamp.c:3095 utils/adt/timestamp.c:3108 +#: utils/adt/timestamp.c:3117 utils/adt/timestamp.c:3125 +#: utils/adt/timestamp.c:3180 utils/adt/timestamp.c:3203 +#: utils/adt/timestamp.c:3216 utils/adt/timestamp.c:3227 +#: utils/adt/timestamp.c:3235 utils/adt/timestamp.c:3809 +#: utils/adt/timestamp.c:3938 utils/adt/timestamp.c:3979 +#: utils/adt/timestamp.c:4067 utils/adt/timestamp.c:4113 +#: utils/adt/timestamp.c:4224 utils/adt/timestamp.c:4631 +#: utils/adt/timestamp.c:4747 utils/adt/timestamp.c:4757 +#: utils/adt/timestamp.c:4853 utils/adt/timestamp.c:4972 +#: utils/adt/timestamp.c:4982 utils/adt/timestamp.c:5234 +#: utils/adt/timestamp.c:5248 utils/adt/timestamp.c:5253 +#: utils/adt/timestamp.c:5267 utils/adt/timestamp.c:5316 +#: utils/adt/timestamp.c:5348 utils/adt/timestamp.c:5355 +#: utils/adt/timestamp.c:5381 utils/adt/timestamp.c:5385 +#: utils/adt/timestamp.c:5454 utils/adt/timestamp.c:5458 +#: utils/adt/timestamp.c:5472 utils/adt/timestamp.c:5510 utils/adt/xml.c:2049 #: utils/adt/xml.c:2056 utils/adt/xml.c:2076 utils/adt/xml.c:2083 #, c-format msgid "timestamp out of range" @@ -18930,17 +19011,18 @@ msgstr "\"%s\" 는 \"time with time zone\" ìžë£Œí˜•ì˜ 단위가 아닙니다." #: utils/adt/date.c:2830 utils/adt/datetime.c:995 utils/adt/datetime.c:1917 #: utils/adt/datetime.c:4743 utils/adt/timestamp.c:532 -#: utils/adt/timestamp.c:559 utils/adt/timestamp.c:5275 -#: utils/adt/timestamp.c:5514 +#: utils/adt/timestamp.c:559 utils/adt/timestamp.c:5259 +#: utils/adt/timestamp.c:5464 #, c-format msgid "time zone \"%s\" not recognized" msgstr "\"%s\" ì´ë¦„ì˜ ì‹œê°„ëŒ€ëŠ” 없습니다." -#: utils/adt/date.c:2870 utils/adt/timestamp.c:5351 utils/adt/timestamp.c:5545 +#: utils/adt/date.c:2870 utils/adt/timestamp.c:5301 utils/adt/timestamp.c:5495 #, c-format msgid "interval time zone \"%s\" must not include months or days" msgstr "" -"\"%s\" 시간대 간격(interval time zone) 값으로 달(month) ë˜ëŠ” ì¼(day)ì„ í¬í•¨í•  수 없습니다" +"\"%s\" 시간대 간격(interval time zone) 값으로 달(month) ë˜ëŠ” ì¼(day)ì„ í¬í•¨" +"í•  수 없습니다" #: utils/adt/datetime.c:3878 utils/adt/datetime.c:3885 #, c-format @@ -19004,9 +19086,10 @@ msgstr "ìž˜ëª»ëœ í¬ê¸° 단위: \"%s\"" #: utils/adt/dbsize.c:827 #, c-format msgid "Valid units are \"bytes\", \"kB\", \"MB\", \"GB\", and \"TB\"." -msgstr "ì´ ë§¤ê°œ ë³€ìˆ˜ì— ìœ íš¨í•œ 단위는 \"bytes\",\"kB\", \"MB\", \"GB\", \"TB\"입니다." +msgstr "" +"ì´ ë§¤ê°œ ë³€ìˆ˜ì— ìœ íš¨í•œ 단위는 \"bytes\",\"kB\", \"MB\", \"GB\", \"TB\"입니다." -#: utils/adt/domains.c:85 +#: utils/adt/domains.c:86 #, c-format msgid "type %s is not a domain" msgstr "%s ìžë£Œí˜•ì€ ë„ë©”ì¸ì´ 아닙니다" @@ -19297,8 +19380,7 @@ msgstr "í•„ë“œì— %dìžê°€ í•„ìš”í•œë° %dìžë§Œ 남았습니다." #, c-format msgid "" "If your source string is not fixed-width, try using the \"FM\" modifier." -msgstr "" -"소스 문ìžì—´ì´ ê³ ì • 너비가 ì•„ë‹Œ 경우 \"FM\" 한정ìžë¥¼ 사용해 보십시오." +msgstr "소스 문ìžì—´ì´ ê³ ì • 너비가 ì•„ë‹Œ 경우 \"FM\" 한정ìžë¥¼ 사용해 보십시오." #: utils/adt/formatting.c:2210 utils/adt/formatting.c:2223 #: utils/adt/formatting.c:2353 @@ -19515,7 +19597,7 @@ msgid "oidvector has too many elements" msgstr "oidvectorì— ë„ˆë¬´ ë§Žì€ ìš”ì†Œê°€ 있습니다" #: utils/adt/int.c:1362 utils/adt/int8.c:1460 utils/adt/numeric.c:1351 -#: utils/adt/timestamp.c:5611 utils/adt/timestamp.c:5692 +#: utils/adt/timestamp.c:5561 utils/adt/timestamp.c:5642 #, c-format msgid "step size cannot equal zero" msgstr "단계 í¬ê¸°ëŠ” 0ì¼ ìˆ˜ ì—†ìŒ" @@ -19598,8 +19680,8 @@ msgid "" "Unicode escape values cannot be used for code point values above 007F when " "the server encoding is not UTF8." msgstr "" -"서버 ì¸ì½”ë”©ì´ UTF8ì´ ì•„ë‹Œ 경우 007F보다 í° ì½”ë“œ ì§€ì  ê°’ì—는 유니코드 ì´" -"스케ì´í”„ ê°’ì„ ì‚¬ìš©í•  수 ì—†ìŒ" +"서버 ì¸ì½”ë”©ì´ UTF8ì´ ì•„ë‹Œ 경우 007F보다 í° ì½”ë“œ ì§€ì  ê°’ì—는 유니코드 ì´ìŠ¤ì¼€ì´" +"프 ê°’ì„ ì‚¬ìš©í•  수 ì—†ìŒ" #: utils/adt/json.c:944 utils/adt/json.c:962 #, c-format @@ -19664,7 +19746,8 @@ msgstr "JSON ìžë£Œ, %d 번째 줄: %s%s%s" #: utils/adt/json.c:1469 utils/adt/jsonb.c:724 #, c-format msgid "key value must be scalar, not array, composite, or json" -msgstr "키 ê°’ì€ ìŠ¤ì¹¼ë¼ í˜•ì´ì–´ì•¼ 함. ë°°ì—´, 복합 ìžë£Œí˜•, json í˜•ì€ ì‚¬ìš©í•  수 ì—†ìŒ" +msgstr "" +"키 ê°’ì€ ìŠ¤ì¹¼ë¼ í˜•ì´ì–´ì•¼ 함. ë°°ì—´, 복합 ìžë£Œí˜•, json í˜•ì€ ì‚¬ìš©í•  수 ì—†ìŒ" #: utils/adt/json.c:2006 #, c-format @@ -19734,8 +19817,7 @@ msgstr "jsonb 문ìžì—´ë¡œ 길ì´ë¥¼ 초과함" #, c-format msgid "" "Due to an implementation restriction, jsonb strings cannot exceed %d bytes." -msgstr "" -"êµ¬í˜„ìƒ ì œí•œìœ¼ë¡œ jsonb 문ìžì—´ì€ %d ë°”ì´íŠ¸ë¥¼ ë„˜ì„ ìˆ˜ 없습니다." +msgstr "êµ¬í˜„ìƒ ì œí•œìœ¼ë¡œ jsonb 문ìžì—´ì€ %d ë°”ì´íŠ¸ë¥¼ ë„˜ì„ ìˆ˜ 없습니다." #: utils/adt/jsonb.c:1182 #, c-format @@ -19847,8 +19929,7 @@ msgstr "%sì˜ ì²«ë²ˆì§¸ ì¸ìžëŠ” row 형ì´ì–´ì•¼ 합니다" #, c-format msgid "" "Try calling the function in the FROM clause using a column definition list." -msgstr "" -"함수를 호출 í•  ë•Œ FROM ì ˆì—ì„œ 칼럼 ì •ì˜ ëª©ë¡ë„ 함께 지정해야 합니다." +msgstr "함수를 호출 í•  ë•Œ FROM ì ˆì—ì„œ 칼럼 ì •ì˜ ëª©ë¡ë„ 함께 지정해야 합니다." #: utils/adt/jsonfuncs.c:2819 utils/adt/jsonfuncs.c:2986 #, c-format @@ -19961,7 +20042,8 @@ msgid "" "must be a member of the role whose query is being canceled or member of " "pg_signal_backend" msgstr "" -"쿼리 ìž‘ì—… 취소하려면 ìž‘ì—…ìžì˜ ì†Œì† ë§´ë²„ì´ê±°ë‚˜ pg_signal_backend ì†Œì† ë§´ë²„ì—¬ì•¼ 합니다" +"쿼리 ìž‘ì—… 취소하려면 ìž‘ì—…ìžì˜ ì†Œì† ë§´ë²„ì´ê±°ë‚˜ pg_signal_backend ì†Œì† ë§´ë²„ì—¬" +"야 합니다" #: utils/adt/misc.c:314 #, c-format @@ -19974,7 +20056,8 @@ msgid "" "must be a member of the role whose process is being terminated or member of " "pg_signal_backend" msgstr "" -"ì„¸ì…˜ì„ ì¢…ë£Œí•˜ë ¤ë©´ ì ‘ì†ìžì˜ ì†Œì† ë§´ë²„ì´ê±°ë‚˜ pg_signal_backend ì†Œì† ë§´ë²„ì—¬ì•¼ 합니다" +"ì„¸ì…˜ì„ ì¢…ë£Œí•˜ë ¤ë©´ ì ‘ì†ìžì˜ ì†Œì† ë§´ë²„ì´ê±°ë‚˜ pg_signal_backend ì†Œì† ë§´ë²„ì—¬ì•¼ í•©" +"니다" #: utils/adt/misc.c:336 #, c-format @@ -20221,8 +20304,8 @@ msgid "" "A field with precision %d, scale %d must round to an absolute value less " "than %s%d." msgstr "" -"ì „ì²´ ìžë¦¿ìˆ˜ %d, 소수 ìžë¦¿ìˆ˜ %dì˜ í•„ë“œëŠ” %s%d보다 ìž‘ì€ ì ˆëŒ€ 값으로 " -"반올림해야 합니다." +"ì „ì²´ ìžë¦¿ìˆ˜ %d, 소수 ìžë¦¿ìˆ˜ %dì˜ í•„ë“œëŠ” %s%d보다 ìž‘ì€ ì ˆëŒ€ 값으로 반올림해야 " +"합니다." #: utils/adt/numeric.c:6254 utils/adt/numeric.c:6280 #, c-format @@ -20285,25 +20368,24 @@ msgstr "null 문ìžëŠ” 허용ë˜ì§€ ì•ŠìŒ" msgid "percentile value %g is not between 0 and 1" msgstr "%g í¼ì„¼íŠ¸ ê°’ì´ 0ê³¼ 1사ì´ê°€ 아닙니다." -#: utils/adt/pg_locale.c:917 +#: utils/adt/pg_locale.c:1029 #, c-format msgid "Apply system library package updates." msgstr "OS ë¼ì´ë¸ŒëŸ¬ë¦¬ 패키지를 ì—…ë°ì´íŠ¸ 하세요." -#: utils/adt/pg_locale.c:1122 +#: utils/adt/pg_locale.c:1234 #, c-format msgid "could not create locale \"%s\": %m" msgstr "\"%s\" 로케ì¼ì„ 만들 수 ì—†ìŒ: %m" -#: utils/adt/pg_locale.c:1125 +#: utils/adt/pg_locale.c:1237 #, c-format msgid "" "The operating system could not find any locale data for the locale name \"%s" "\"." -msgstr "" -"ìš´ì˜ì²´ì œì—ì„œ \"%s\" ë¡œì¼€ì¼ ì´ë¦„ì— ëŒ€í•œ ë¡œì¼€ì¼ íŒŒì¼ì„ ì°¾ì„ ìˆ˜ 없습니다." +msgstr "ìš´ì˜ì²´ì œì—ì„œ \"%s\" ë¡œì¼€ì¼ ì´ë¦„ì— ëŒ€í•œ ë¡œì¼€ì¼ íŒŒì¼ì„ ì°¾ì„ ìˆ˜ 없습니다." -#: utils/adt/pg_locale.c:1212 +#: utils/adt/pg_locale.c:1324 #, c-format msgid "" "collations with different collate and ctype values are not supported on this " @@ -20312,17 +20394,18 @@ msgstr "" "ì´ í”Œëž«í¼ì—서는 서로 다른 정렬규칙(collation)ê³¼ 문ìžì§‘í•©(ctype)ì„ í•¨ê»˜ 쓸 수 " "없습니다." -#: utils/adt/pg_locale.c:1227 +#: utils/adt/pg_locale.c:1339 #, c-format msgid "nondefault collations are not supported on this platform" -msgstr "ì´ í”Œëž«í¼ì—서는 ê¸°ë³¸ê°’ì´ ì•„ë‹Œ 정렬규칙(collation)ì„ ì‚¬ìš©í•  수 없습니다." +msgstr "" +"ì´ í”Œëž«í¼ì—서는 ê¸°ë³¸ê°’ì´ ì•„ë‹Œ 정렬규칙(collation)ì„ ì‚¬ìš©í•  수 없습니다." -#: utils/adt/pg_locale.c:1398 +#: utils/adt/pg_locale.c:1510 #, c-format msgid "invalid multibyte character for locale" msgstr "로케ì¼ì„ 위한 ìž˜ëª»ëœ ë©€í‹°ë°”ì´íŠ¸ 문ìž" -#: utils/adt/pg_locale.c:1399 +#: utils/adt/pg_locale.c:1511 #, c-format msgid "" "The server's LC_CTYPE locale is probably incompatible with the database " @@ -20591,7 +20674,7 @@ msgid "Use NONE to denote the missing argument of a unary operator." msgstr "단항 ì—°ì‚°ìžì—ì„œ ì¸ìž ì—†ìŒì„ 표시할 때는 NONE ì¸ìžë¥¼ 사용하세요." #: utils/adt/regproc.c:779 utils/adt/regproc.c:820 utils/adt/regproc.c:2006 -#: utils/adt/ruleutils.c:8364 utils/adt/ruleutils.c:8533 +#: utils/adt/ruleutils.c:8367 utils/adt/ruleutils.c:8536 #, c-format msgid "too many arguments" msgstr "ì¸ìžê°€ 너무 많습니다" @@ -20678,8 +20761,8 @@ msgid "" "Remove this referential integrity trigger and its mates, then do ALTER TABLE " "ADD CONSTRAINT." msgstr "" -"해당 트리거 관련 ê°ì²´ë¥¼ 제거한 후 ALTER TABLE ADD " -"CONSTRAINT 명령으로 추가하세요" +"해당 트리거 관련 ê°ì²´ë¥¼ 제거한 후 ALTER TABLE ADD CONSTRAINT 명령으로 추가하" +"세요" #: utils/adt/ri_triggers.c:3225 #, c-format @@ -20782,7 +20865,7 @@ msgstr "서로 다른 ì—´ í˜•ì‹ %sê³¼(와) %s(레코드 ì—´ %d)ì„(를) ë¹„êµ msgid "cannot compare record types with different numbers of columns" msgstr "칼럼 수가 서로 다른 레코드 ìžë£Œí˜•ì„ 비êµí•  수 ì—†ìŒ" -#: utils/adt/ruleutils.c:4286 +#: utils/adt/ruleutils.c:4289 #, c-format msgid "rule \"%s\" has unsupported event type %d" msgstr "\"%s\" ë£°ì€ %d ì´ë²¤íŠ¸ 형태를 지ì›í•˜ì§€ 않습니다" @@ -20818,7 +20901,7 @@ msgid "timestamp out of range: \"%s\"" msgstr "타임스탬프 ê°’ì´ ë²”ìœ„ë¥¼ 벗어났ìŒ: \"%s\"" #: utils/adt/timestamp.c:188 utils/adt/timestamp.c:463 -#: utils/adt/timestamp.c:993 +#: utils/adt/timestamp.c:990 #, c-format msgid "date/time value \"%s\" is no longer supported" msgstr "날짜/시간 ê°’ \"%s\"ì€(는) ë” ì´ìƒ 지ì›ë˜ì§€ ì•ŠìŒ" @@ -20854,87 +20937,86 @@ msgstr "\"%s\" 숫ìží˜• 타임 ì¡´ 범위 벗어남" msgid "timestamp out of range: %d-%02d-%02d %d:%02d:%02g" msgstr "타임스탬프 ê°’ì´ ë²”ìœ„ë¥¼ 벗어났ìŒ: %d-%02d-%02d %d:%02d:%02g" -#: utils/adt/timestamp.c:770 utils/adt/timestamp.c:776 -#: utils/adt/timestamp.c:791 +#: utils/adt/timestamp.c:772 utils/adt/timestamp.c:788 #, c-format msgid "timestamp out of range: \"%g\"" msgstr "타임스탬프 ê°’ì´ ë²”ìœ„ë¥¼ 벗어났ìŒ: \"%g\"" -#: utils/adt/timestamp.c:987 utils/adt/timestamp.c:1558 -#: utils/adt/timestamp.c:2068 utils/adt/timestamp.c:3220 -#: utils/adt/timestamp.c:3225 utils/adt/timestamp.c:3230 -#: utils/adt/timestamp.c:3280 utils/adt/timestamp.c:3287 -#: utils/adt/timestamp.c:3294 utils/adt/timestamp.c:3314 -#: utils/adt/timestamp.c:3321 utils/adt/timestamp.c:3328 -#: utils/adt/timestamp.c:3358 utils/adt/timestamp.c:3366 -#: utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3751 -#: utils/adt/timestamp.c:3880 utils/adt/timestamp.c:4271 +#: utils/adt/timestamp.c:984 utils/adt/timestamp.c:1608 +#: utils/adt/timestamp.c:2121 utils/adt/timestamp.c:3273 +#: utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3283 +#: utils/adt/timestamp.c:3333 utils/adt/timestamp.c:3340 +#: utils/adt/timestamp.c:3347 utils/adt/timestamp.c:3367 +#: utils/adt/timestamp.c:3374 utils/adt/timestamp.c:3381 +#: utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3419 +#: utils/adt/timestamp.c:3464 utils/adt/timestamp.c:3804 +#: utils/adt/timestamp.c:3933 utils/adt/timestamp.c:4324 #, c-format msgid "interval out of range" msgstr "ê°„ê²©ì´ ë²”ìœ„ë¥¼ 벗어남" -#: utils/adt/timestamp.c:1128 utils/adt/timestamp.c:1161 +#: utils/adt/timestamp.c:1125 utils/adt/timestamp.c:1158 #, c-format msgid "invalid INTERVAL type modifier" msgstr "ìž˜ëª»ëœ INTERVAL í˜•ì‹ í•œì •ìž" -#: utils/adt/timestamp.c:1144 +#: utils/adt/timestamp.c:1141 #, c-format msgid "INTERVAL(%d) precision must not be negative" msgstr "INTERVAL(%d) ì •ë°€ë„ë¡œ ìŒìˆ˜ê°’ì´ ì˜¬ 수 없습니다" -#: utils/adt/timestamp.c:1150 +#: utils/adt/timestamp.c:1147 #, c-format msgid "INTERVAL(%d) precision reduced to maximum allowed, %d" msgstr "INTERVAL(%d) ì •ë°€ë„는 허용 최대치(%d)ë¡œ ê°ì†Œ ë˜ì—ˆìŠµë‹ˆë‹¤" -#: utils/adt/timestamp.c:1502 +#: utils/adt/timestamp.c:1552 #, c-format msgid "interval(%d) precision must be between %d and %d" msgstr "간격(%d) ì •ë°€ë„는 %dì—ì„œ %d 사ì´ì—¬ì•¼ 함" -#: utils/adt/timestamp.c:2797 +#: utils/adt/timestamp.c:2850 #, c-format msgid "cannot subtract infinite timestamps" msgstr "타임스탬프 ë¬´í•œê°’ì„ ì¶”ì¶œ í•  수 ì—†ìŒ" -#: utils/adt/timestamp.c:4006 utils/adt/timestamp.c:4531 -#: utils/adt/timestamp.c:4715 utils/adt/timestamp.c:4740 +#: utils/adt/timestamp.c:4059 utils/adt/timestamp.c:4584 +#: utils/adt/timestamp.c:4768 utils/adt/timestamp.c:4793 #, c-format msgid "timestamp units \"%s\" not supported" msgstr "\"%s\" timestamp ìœ ë‹›ì€ ì§€ì›í•˜ì§€ 않습니다" -#: utils/adt/timestamp.c:4020 utils/adt/timestamp.c:4485 -#: utils/adt/timestamp.c:4750 +#: utils/adt/timestamp.c:4073 utils/adt/timestamp.c:4538 +#: utils/adt/timestamp.c:4803 #, c-format msgid "timestamp units \"%s\" not recognized" msgstr "\"%s\" timestamp ìœ ë‹›ì„ ì²˜ë¦¬í•˜ì§€ 못했습니다" -#: utils/adt/timestamp.c:4160 utils/adt/timestamp.c:4526 -#: utils/adt/timestamp.c:4937 utils/adt/timestamp.c:4963 +#: utils/adt/timestamp.c:4213 utils/adt/timestamp.c:4579 +#: utils/adt/timestamp.c:4990 utils/adt/timestamp.c:5016 #, c-format msgid "timestamp with time zone units \"%s\" not supported" msgstr "\"%s\" 시간대 ìœ ë‹›ì´ ìžˆëŠ” timestamp ìžë£Œí˜•ì€ 지ì›í•˜ì§€ 않습니다" -#: utils/adt/timestamp.c:4177 utils/adt/timestamp.c:4480 -#: utils/adt/timestamp.c:4972 +#: utils/adt/timestamp.c:4230 utils/adt/timestamp.c:4533 +#: utils/adt/timestamp.c:5025 #, c-format msgid "timestamp with time zone units \"%s\" not recognized" msgstr "\"%s\" 시간대 ìœ ë‹›ì´ ìžˆëŠ” timestamp ê°’ì„ ì²˜ë¦¬í•˜ì§€ 못했습니다" -#: utils/adt/timestamp.c:4258 +#: utils/adt/timestamp.c:4311 #, c-format msgid "" "interval units \"%s\" not supported because months usually have fractional " "weeks" msgstr "" -#: utils/adt/timestamp.c:4264 utils/adt/timestamp.c:5078 +#: utils/adt/timestamp.c:4317 utils/adt/timestamp.c:5131 #, c-format msgid "interval units \"%s\" not supported" msgstr "\"%s\" 유닛 간격(interval units)ì€ ì§€ì›í•˜ì§€ 않습니다" -#: utils/adt/timestamp.c:4280 utils/adt/timestamp.c:5105 +#: utils/adt/timestamp.c:4333 utils/adt/timestamp.c:5158 #, c-format msgid "interval units \"%s\" not recognized" msgstr "\"%s\" 유닛 간격(interval units)ì„ ì²˜ë¦¬í•˜ì§€ 못했습니다" @@ -20995,31 +21077,31 @@ msgstr "tsqueryì˜ í”¼ì—°ì‚°ìžê°€ 너무 긺: \"%s\"" msgid "word is too long in tsquery: \"%s\"" msgstr "tsqueryì˜ ë‹¨ì–´ê°€ 너무 긺: \"%s\"" -#: utils/adt/tsquery.c:643 +#: utils/adt/tsquery.c:642 #, c-format msgid "text-search query doesn't contain lexemes: \"%s\"" msgstr "í…스트 검색 ì¿¼ë¦¬ì— ì–´íœ˜ì†Œê°€ í¬í•¨ë˜ì–´ 있지 ì•ŠìŒ: \"%s\"" -#: utils/adt/tsquery.c:654 utils/adt/tsquery_util.c:347 +#: utils/adt/tsquery.c:653 utils/adt/tsquery_util.c:375 #, c-format msgid "tsquery is too large" msgstr "tsquery 길ì´ê°€ 너무 ê¹ë‹ˆë‹¤" -#: utils/adt/tsquery_cleanup.c:601 +#: utils/adt/tsquery_cleanup.c:407 #, c-format msgid "" "text-search query contains only stop words or doesn't contain lexemes, " "ignored" msgstr "" -"í…스트 검색 ì¿¼ë¦¬ì— ì¤‘ì§€ 단어만 í¬í•¨ë˜ì–´ 있거나 어휘소가 í¬í•¨ë˜ì–´ 있지 ì•Š" -"ìŒ, 무시ë¨" +"í…스트 검색 ì¿¼ë¦¬ì— ì¤‘ì§€ 단어만 í¬í•¨ë˜ì–´ 있거나 어휘소가 í¬í•¨ë˜ì–´ 있지 ì•ŠìŒ, " +"무시ë¨" #: utils/adt/tsquery_op.c:122 #, c-format msgid "distance in phrase operator should be non-negative and less than %d" msgstr "ë¶„ì„ ìž‘ì—…ì—ì„œ 사용한 ê±°ë¦¬ê°’ì€ %d 보다 ìž‘ê³  양수값만 사용할 수 있습니다" -#: utils/adt/tsquery_rewrite.c:292 +#: utils/adt/tsquery_rewrite.c:321 #, c-format msgid "ts_rewrite query must return two tsquery columns" msgstr "ts_rewrite 쿼리는 ë‘ ê°œì˜ tsquery ì—´ì„ ë°˜í™˜í•´ì•¼ 함" @@ -21055,58 +21137,58 @@ msgid "string is too long for tsvector (%ld bytes, max %ld bytes)" msgstr "" "문ìžì—´ì´ 너무 길어서 tsvectorì— ì‚¬ìš©í•  수 ì—†ìŒ(%ldë°”ì´íŠ¸, 최대 %ldë°”ì´íŠ¸)" -#: utils/adt/tsvector_op.c:321 utils/adt/tsvector_op.c:608 -#: utils/adt/tsvector_op.c:776 +#: utils/adt/tsvector_op.c:322 utils/adt/tsvector_op.c:609 +#: utils/adt/tsvector_op.c:777 #, c-format msgid "lexeme array may not contain nulls" msgstr "어휘소 ë°°ì—´ì—는 nullì´ í¬í•¨ë˜ì§€ 않아야 함" -#: utils/adt/tsvector_op.c:851 +#: utils/adt/tsvector_op.c:852 #, c-format msgid "weight array may not contain nulls" msgstr "가중치 ë°°ì—´ì—는 nullì´ í¬í•¨ë˜ì§€ 않아야 함" -#: utils/adt/tsvector_op.c:875 +#: utils/adt/tsvector_op.c:876 #, c-format msgid "unrecognized weight: \"%c\"" msgstr "ì•Œ 수 없는 가중치: \"%c\"" -#: utils/adt/tsvector_op.c:2061 +#: utils/adt/tsvector_op.c:2313 #, c-format msgid "ts_stat query must return one tsvector column" msgstr "ts_stat 쿼리는 í•˜ë‚˜ì˜ tsvector ì¹¼ëŸ¼ì„ ë°˜í™˜í•´ì•¼ 함" -#: utils/adt/tsvector_op.c:2243 +#: utils/adt/tsvector_op.c:2495 #, c-format msgid "tsvector column \"%s\" does not exist" msgstr "\"%s\" tsvector ì¹¼ëŸ¼ì´ ì—†ìŒ" -#: utils/adt/tsvector_op.c:2249 +#: utils/adt/tsvector_op.c:2501 #, c-format msgid "column \"%s\" is not of tsvector type" msgstr "\"%s\" ì¹¼ëŸ¼ì€ tsvector 형ì‹ì´ 아님" -#: utils/adt/tsvector_op.c:2261 +#: utils/adt/tsvector_op.c:2513 #, c-format msgid "configuration column \"%s\" does not exist" msgstr "\"%s\" 구성 ì¹¼ëŸ¼ì´ ì—†ìŒ" -#: utils/adt/tsvector_op.c:2267 +#: utils/adt/tsvector_op.c:2519 #, c-format msgid "column \"%s\" is not of regconfig type" msgstr "\"%s\" ì¹¼ëŸ¼ì€ regconfig í˜•ì´ ì•„ë‹˜" -#: utils/adt/tsvector_op.c:2274 +#: utils/adt/tsvector_op.c:2526 #, c-format msgid "configuration column \"%s\" must not be null" msgstr "\"%s\" 구성 ì¹¼ëŸ¼ì€ nullì´ ì•„ë‹ˆì–´ì•¼ 함" -#: utils/adt/tsvector_op.c:2287 +#: utils/adt/tsvector_op.c:2539 #, c-format msgid "text search configuration name \"%s\" must be schema-qualified" msgstr "\"%s\" í…스트 검색 구성 ì´ë¦„ì´ ìŠ¤í‚¤ë§ˆë¡œ 한정ë˜ì–´ì•¼ 함" -#: utils/adt/tsvector_op.c:2312 +#: utils/adt/tsvector_op.c:2564 #, c-format msgid "column \"%s\" is not of a character type" msgstr "\"%s\" ì¹¼ëŸ¼ì€ ë¬¸ìží˜•ì´ 아님" @@ -21278,7 +21360,8 @@ msgstr "수치 범위를 벗어남" #: utils/adt/varlena.c:5166 utils/adt/varlena.c:5194 #, c-format msgid "format specifies argument 0, but arguments are numbered from 1" -msgstr "format 함수ì—ì„œ 사용할 수 있는 ì¸ìž 위치 번호는 0ì´ ì•„ë‹ˆë¼, 1부터 시작합니다" +msgstr "" +"format 함수ì—ì„œ 사용할 수 있는 ì¸ìž 위치 번호는 0ì´ ì•„ë‹ˆë¼, 1부터 시작합니다" #: utils/adt/varlena.c:5187 #, c-format @@ -21360,8 +21443,7 @@ msgstr "XML ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ 초기화할 수 ì—†ìŒ" msgid "" "libxml2 has incompatible char type: sizeof(char)=%u, sizeof(xmlChar)=%u." msgstr "" -"libxml2ì— í˜¸í™˜ë˜ì§€ 않는 ë¬¸ìž ìžë£Œí˜• 있ìŒ: sizeof(char)=%u, " -"sizeof(xmlChar)=%u" +"libxml2ì— í˜¸í™˜ë˜ì§€ 않는 ë¬¸ìž ìžë£Œí˜• 있ìŒ: sizeof(char)=%u, sizeof(xmlChar)=%u" #: utils/adt/xml.c:997 #, c-format @@ -21374,7 +21456,8 @@ msgid "" "This probably indicates that the version of libxml2 being used is not " "compatible with the libxml2 header files that PostgreSQL was built with." msgstr "" -"ì´ ë¬¸ì œëŠ” PostgreSQL 서버를 만들 ë•Œ 사용한 libxml2 í—¤ë” íŒŒì¼ì´ í˜¸í™˜ì„±ì´ ì—†ëŠ” 것 같습니다." +"ì´ ë¬¸ì œëŠ” PostgreSQL 서버를 만들 ë•Œ 사용한 libxml2 í—¤ë” íŒŒì¼ì´ í˜¸í™˜ì„±ì´ ì—†ëŠ” " +"것 같습니다." #: utils/adt/xml.c:1735 msgid "Invalid character value." @@ -21429,7 +21512,8 @@ msgstr "XML 네임스페ì´ìŠ¤ ë§¤í•‘ì— ì‚¬ìš©í•  ë°°ì—´ì´ ìž˜ëª»ë¨" #, c-format msgid "" "The array must be two-dimensional with length of the second axis equal to 2." -msgstr "ì´ ë°°ì—´ì€ key, valueë¡œ êµ¬ì„±ëœ ë°°ì—´ì„ ìš”ì†Œë¡œ 하는 2ì°¨ì› ë°°ì—´ì´ì–´ì•¼ 합니다." +msgstr "" +"ì´ ë°°ì—´ì€ key, valueë¡œ êµ¬ì„±ëœ ë°°ì—´ì„ ìš”ì†Œë¡œ 하는 2ì°¨ì› ë°°ì—´ì´ì–´ì•¼ 합니다." #: utils/adt/xml.c:3818 #, c-format @@ -21464,22 +21548,22 @@ msgstr "%s ìžë£Œí˜•ì„ 위한 ìž…ë ¥ 함수가 없습니다" msgid "no output function available for type %s" msgstr "%s ìžë£Œí˜•ì„ 위한 출력 함수가 없습니다" -#: utils/cache/plancache.c:716 +#: utils/cache/plancache.c:718 #, c-format msgid "cached plan must not change result type" msgstr "ìºì‹œëœ 계íšì—ì„œ ê²°ê³¼ 형ì‹ì„ 바꾸지 않아야 함" -#: utils/cache/relcache.c:5199 +#: utils/cache/relcache.c:5226 #, c-format msgid "could not create relation-cache initialization file \"%s\": %m" msgstr "\"%s\" 릴레ì´ì…˜-ìºì‹œ 초기화 파ì¼ì„ 만들 수 ì—†ìŒ: %m" -#: utils/cache/relcache.c:5201 +#: utils/cache/relcache.c:5228 #, c-format msgid "Continuing anyway, but there's something wrong." msgstr "어쨌든 계ì†í•˜ëŠ”ë°, 뭔가 잘못 ëœ ê²ƒì´ ìžˆìŠµë‹ˆë‹¤." -#: utils/cache/relcache.c:5475 +#: utils/cache/relcache.c:5502 #, c-format msgid "could not remove cache file \"%s\": %m" msgstr "\"%s\" ìºì‰¬ 파ì¼ì„ 삭제할 수 ì—†ìŒ: %m" @@ -21563,82 +21647,82 @@ msgstr "표준출력(stdout)으로 사용하기 위해 \"%s\" 파ì¼ì„ 여는 msgid "[unknown]" msgstr "[알수없ìŒ]" -#: utils/error/elog.c:2881 utils/error/elog.c:3184 utils/error/elog.c:3292 +#: utils/error/elog.c:2882 utils/error/elog.c:3185 utils/error/elog.c:3293 msgid "missing error text" msgstr "오류 ë‚´ìš©ì„ ëºë‹ˆë‹¤" -#: utils/error/elog.c:2884 utils/error/elog.c:2887 utils/error/elog.c:3295 -#: utils/error/elog.c:3298 +#: utils/error/elog.c:2885 utils/error/elog.c:2888 utils/error/elog.c:3296 +#: utils/error/elog.c:3299 #, c-format msgid " at character %d" msgstr " %d 번째 ë¬¸ìž ë¶€ê·¼" -#: utils/error/elog.c:2897 utils/error/elog.c:2904 +#: utils/error/elog.c:2898 utils/error/elog.c:2905 msgid "DETAIL: " msgstr "ìƒì„¸ì •ë³´: " -#: utils/error/elog.c:2911 +#: utils/error/elog.c:2912 msgid "HINT: " msgstr "힌트: " -#: utils/error/elog.c:2918 +#: utils/error/elog.c:2919 msgid "QUERY: " msgstr "쿼리:" -#: utils/error/elog.c:2925 +#: utils/error/elog.c:2926 msgid "CONTEXT: " msgstr "ë‚´ìš©: " -#: utils/error/elog.c:2935 +#: utils/error/elog.c:2936 #, c-format msgid "LOCATION: %s, %s:%d\n" msgstr "위치: %s, %s:%d\n" -#: utils/error/elog.c:2942 +#: utils/error/elog.c:2943 #, c-format msgid "LOCATION: %s:%d\n" msgstr "위치: %s:%d\n" -#: utils/error/elog.c:2956 +#: utils/error/elog.c:2957 msgid "STATEMENT: " msgstr "명령 구문: " #. translator: This string will be truncated at 47 #. characters expanded. -#: utils/error/elog.c:3413 +#: utils/error/elog.c:3414 #, c-format msgid "operating system error %d" msgstr "ìš´ì˜ì²´ì œ 오류 %d" -#: utils/error/elog.c:3611 +#: utils/error/elog.c:3612 msgid "DEBUG" msgstr "디버그" -#: utils/error/elog.c:3615 +#: utils/error/elog.c:3616 msgid "LOG" msgstr "로그" -#: utils/error/elog.c:3618 +#: utils/error/elog.c:3619 msgid "INFO" msgstr "ì •ë³´" -#: utils/error/elog.c:3621 +#: utils/error/elog.c:3622 msgid "NOTICE" msgstr "알림" -#: utils/error/elog.c:3624 +#: utils/error/elog.c:3625 msgid "WARNING" msgstr "경고" -#: utils/error/elog.c:3627 +#: utils/error/elog.c:3628 msgid "ERROR" msgstr "오류" -#: utils/error/elog.c:3630 +#: utils/error/elog.c:3631 msgid "FATAL" msgstr "치명ì ì˜¤ë¥˜" -#: utils/error/elog.c:3633 +#: utils/error/elog.c:3634 msgid "PANIC" msgstr "ì†ìƒ" @@ -21749,7 +21833,9 @@ msgstr "%u 함수는 너무 ë§Žì€ ì¸ìžë¥¼ 사용하고 ìžˆìŒ (%d, 최대 %d) #: utils/fmgr/fmgr.c:2527 #, c-format msgid "language validation function %u called for language %u instead of %u" -msgstr "%u OID 언어 유효성 검사 함수가 %u OID 프로시져 언어용으로 호출ë˜ì—ˆìŒ, ì›ëž˜ 언어는 %u" +msgstr "" +"%u OID 언어 유효성 검사 함수가 %u OID 프로시져 언어용으로 호출ë˜ì—ˆìŒ, ì›ëž˜ ì–¸" +"어는 %u" #: utils/fmgr/funcapi.c:353 #, c-format @@ -21778,7 +21864,7 @@ msgstr "레코드를 리턴하는 함수를 위한 í–‰(row) 구성 정보를 구 msgid "could not change directory to \"%s\": %m" msgstr "\"%s\" ì´ë¦„ì˜ ë””ë ‰í„°ë¦¬ë¡œ ì´ë™í•  수 없습니다: %m" -#: utils/init/miscinit.c:449 utils/misc/guc.c:6018 +#: utils/init/miscinit.c:449 utils/misc/guc.c:6016 #, c-format msgid "cannot set parameter \"%s\" within security-restricted operation" msgstr "보안 제한 ìž‘ì—… ë‚´ì—ì„œ \"%s\" 매개 변수를 설정할 수 ì—†ìŒ" @@ -21882,8 +21968,8 @@ msgid "" "If you're sure there are no old server processes still running, remove the " "shared memory block or just delete the file \"%s\"." msgstr "" -"확실하게 공유 메모리를 사용하는 다른 프로세스가 없다고 íŒë‹¨ë˜ë©´, " -"공유 메모리 ì˜ì—­ì„ 삭제하거나 \"%s\" 파ì¼ì„ 지우십시오." +"확실하게 공유 메모리를 사용하는 다른 프로세스가 없다고 íŒë‹¨ë˜ë©´, 공유 메모리 " +"ì˜ì—­ì„ 삭제하거나 \"%s\" 파ì¼ì„ 지우십시오." #: utils/init/miscinit.c:984 #, c-format @@ -21906,7 +21992,7 @@ msgstr "" msgid "could not write lock file \"%s\": %m" msgstr "\"%s\" 잠금 파ì¼ì— 쓸 수 ì—†ìŒ: %m" -#: utils/init/miscinit.c:1172 utils/init/miscinit.c:1301 utils/misc/guc.c:8820 +#: utils/init/miscinit.c:1172 utils/init/miscinit.c:1301 utils/misc/guc.c:8818 #, c-format msgid "could not read from file \"%s\": %m" msgstr "\"%s\" 파ì¼ì„ ì½ì„ 수 ì—†ìŒ: %m" @@ -21961,8 +22047,7 @@ msgid "" "replication connection authorized: user=%s SSL enabled (protocol=%s, cipher=" "%s, compression=%s)" msgstr "" -"복제 ì—°ê²° ì¸ì¦: 사용ìž=%s SSL 활성화 (프로토콜=%s, 알고리즘=" -"%s, 압축=%s)" +"복제 ì—°ê²° ì¸ì¦: 사용ìž=%s SSL 활성화 (프로토콜=%s, 알고리즘=%s, 압축=%s)" #: utils/init/postinit.c:253 utils/init/postinit.c:267 msgid "off" @@ -21983,8 +22068,8 @@ msgid "" "connection authorized: user=%s database=%s SSL enabled (protocol=%s, cipher=" "%s, compression=%s)" msgstr "" -"ì—°ê²° ì¸ì¦: 사용ìž=%s ë°ì´í„°ë² ì´ìŠ¤=%s SSL 활성화 (프로토콜=%s, 알고리즘=" -"%s, 압축=%s)" +"ì—°ê²° ì¸ì¦: 사용ìž=%s ë°ì´í„°ë² ì´ìŠ¤=%s SSL 활성화 (프로토콜=%s, 알고리즘=%s, ì••" +"축=%s)" #: utils/init/postinit.c:271 #, c-format @@ -22032,8 +22117,8 @@ msgid "" "The database was initialized with LC_COLLATE \"%s\", which is not " "recognized by setlocale()." msgstr "" -"ë°ì´í„°ë² ì´ìŠ¤ê°€ setlocale()ì—ì„œ ì¸ì‹í•  수 없는 LC_COLLATE \"%s\"(으)ë¡œ " -"초기화ë˜ì—ˆìŠµë‹ˆë‹¤." +"ë°ì´í„°ë² ì´ìŠ¤ê°€ setlocale()ì—ì„œ ì¸ì‹í•  수 없는 LC_COLLATE \"%s\"(으)ë¡œ 초기화" +"ë˜ì—ˆìŠµë‹ˆë‹¤." #: utils/init/postinit.c:381 utils/init/postinit.c:388 #, c-format @@ -22048,8 +22133,8 @@ msgid "" "The database was initialized with LC_CTYPE \"%s\", which is not recognized " "by setlocale()." msgstr "" -"setlocale()ì—ì„œ ì¸ì‹í•  수 없는 \"%s\" LC_CTYPE 값으로 " -"ë°ì´í„°ë² ì´ìŠ¤ê°€ 초기화ë˜ì—ˆìŠµë‹ˆë‹¤." +"setlocale()ì—ì„œ ì¸ì‹í•  수 없는 \"%s\" LC_CTYPE 값으로 ë°ì´í„°ë² ì´ìŠ¤ê°€ 초기화ë˜" +"었습니다." #: utils/init/postinit.c:714 #, c-format @@ -22086,7 +22171,9 @@ msgstr "ë‚¨ì€ ì—°ê²° ìŠ¬ë¡¯ì€ non-replication 슈í¼ìœ ì € 연결용으로 남 #: utils/init/postinit.c:789 #, c-format msgid "must be superuser or replication role to start walsender" -msgstr "superuser ë˜ëŠ” replication ê¶Œí•œì„ ê°€ì§„ 롤만 walsender 프로세스를 시작할 수 있ìŒ" +msgstr "" +"superuser ë˜ëŠ” replication ê¶Œí•œì„ ê°€ì§„ 롤만 walsender 프로세스를 시작할 수 있" +"ìŒ" #: utils/init/postinit.c:858 #, c-format @@ -22177,7 +22264,9 @@ msgstr "\"%s\" ì¸ì½”딩ì—ì„œ 사용할 수 없는 문ìžê°€ 있ìŒ: %s" msgid "" "character with byte sequence %s in encoding \"%s\" has no equivalent in " "encoding \"%s\"" -msgstr "%s ë°”ì´íŠ¸ë¡œ ì¡°í•©ëœ ë¬¸ìž(ì¸ì½”딩: \"%s\")와 대ì‘ë˜ëŠ” ë¬¸ìž ì½”ë“œê°€ \"%s\" ì¸ì½”딩ì—는 없습니다" +msgstr "" +"%s ë°”ì´íŠ¸ë¡œ ì¡°í•©ëœ ë¬¸ìž(ì¸ì½”딩: \"%s\")와 대ì‘ë˜ëŠ” ë¬¸ìž ì½”ë“œê°€ \"%s\" ì¸ì½”딩" +"ì—는 없습니다" #: utils/misc/guc.c:548 msgid "Ungrouped" @@ -22478,11 +22567,11 @@ msgid "" "problems. Only has an effect if checksums are enabled." msgstr "" "ì¼ë°˜ì ìœ¼ë¡œ ì†ìƒëœ 페ì´ì§€ í—¤ë”를 발견하게 ë˜ë©´, PostgreSQLì—서는 오류를 ë°œìƒí•˜" -"ê³ , 현재 íŠ¸ëžœìž­ì…˜ì„ ì¤‘ì§€í•©ë‹ˆë‹¤. ignore_checksum_failure ê°’ì„ trueë¡œ 지정하면, " -"ì´ëŸ° ì†ìƒëœ 페ì´ì§€ë¥¼ 발견하면, 경고 메시지를 보여주고, ê³„ì† ì§„í–‰í•©ë‹ˆë‹¤. " -"ì´ ê¸°ëŠ¥ì„ ì‚¬ìš©í•œë‹¤ í•¨ì€ ì„œë²„ ë¹„ì •ìƒ ì¢…ë£Œë‚˜ 기타 심ê°í•œ 문제가 ì¼ì–´ ë‚  수 " -"있습니다. ì´ ì„¤ì •ì€ ë°ì´í„° í´ëŸ¬ìŠ¤í„°ì—ì„œ ì²´í¬ì„¬ ê¸°ëŠ¥ì´ í™œì„±í™” ë˜ì–´ 있는 " -"경우ì—만 ì˜í–¥ì„ 받습니다." +"ê³ , 현재 íŠ¸ëžœìž­ì…˜ì„ ì¤‘ì§€í•©ë‹ˆë‹¤. ignore_checksum_failure ê°’ì„ trueë¡œ 지정하" +"ë©´, ì´ëŸ° ì†ìƒëœ 페ì´ì§€ë¥¼ 발견하면, 경고 메시지를 보여주고, ê³„ì† ì§„í–‰í•©ë‹ˆë‹¤. " +"ì´ ê¸°ëŠ¥ì„ ì‚¬ìš©í•œë‹¤ í•¨ì€ ì„œë²„ ë¹„ì •ìƒ ì¢…ë£Œë‚˜ 기타 심ê°í•œ 문제가 ì¼ì–´ ë‚  수 있습" +"니다. ì´ ì„¤ì •ì€ ë°ì´í„° í´ëŸ¬ìŠ¤í„°ì—ì„œ ì²´í¬ì„¬ ê¸°ëŠ¥ì´ í™œì„±í™” ë˜ì–´ 있는 경우ì—만 " +"ì˜í–¥ì„ 받습니다." #: utils/misc/guc.c:967 msgid "Continues processing past damaged page headers." @@ -22513,18 +22602,18 @@ msgid "" "are not enough to recover. This option writes pages when first modified " "after a checkpoint to WAL so full recovery is possible." msgstr "" -"ìš´ì˜ ì²´ì œê°€ ë¹„ì •ìƒ ì¢…ë£Œë˜ëŠ” 경우 처리 ì¤‘ì¸ íŽ˜ì´ì§€ 쓰기는 디스í¬ì— ì¼ë¶€ë§Œ 기" -"ë¡ë  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤. 복구 중 WALì— ì €ìž¥ëœ ë¡œìš° 변경 ë‚´ìš©ì´ ë¶€ì¡±í•˜ì—¬ 복구" -"í•  수 ì—†ì„ ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤. ì´ ì˜µì…˜ì€ ì•ˆì „í•˜ê²Œ 복구가 가능하ë„ë¡ ì²´í¬í¬ì¸íŠ¸ " -"후 ì²˜ìŒ ìˆ˜ì •í•œ 페ì´ì§€ëŠ” ê·¸ 페ì´ì§€ 전체를 WALì— ì”니다." +"ìš´ì˜ ì²´ì œê°€ ë¹„ì •ìƒ ì¢…ë£Œë˜ëŠ” 경우 처리 ì¤‘ì¸ íŽ˜ì´ì§€ 쓰기는 디스í¬ì— ì¼ë¶€ë§Œ 기ë¡" +"ë  ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤. 복구 중 WALì— ì €ìž¥ëœ ë¡œìš° 변경 ë‚´ìš©ì´ ë¶€ì¡±í•˜ì—¬ 복구할 수 " +"ì—†ì„ ìˆ˜ë„ ìžˆìŠµë‹ˆë‹¤. ì´ ì˜µì…˜ì€ ì•ˆì „í•˜ê²Œ 복구가 가능하ë„ë¡ ì²´í¬í¬ì¸íŠ¸ 후 ì²˜ìŒ " +"수정한 페ì´ì§€ëŠ” ê·¸ 페ì´ì§€ 전체를 WALì— ì”니다." #: utils/misc/guc.c:995 msgid "" "Writes full pages to WAL when first modified after a checkpoint, even for a " "non-critical modifications." msgstr "" -"ì²´í¬í¬ì¸íŠ¸ ìž‘ì—… 후 ìžë£Œ 페ì´ì§€ì— 첫 ë³€ê²½ì´ ìžˆëŠ” 경우, WALì— ë³€ê²½ëœ ë‚´ìš©ë§Œ 기ë¡" -"하는 ê²ƒì´ ì•„ë‹ˆë¼, 해당 페ì´ì§€ 전체를 기ë¡í•©ë‹ˆë‹¤." +"ì²´í¬í¬ì¸íŠ¸ ìž‘ì—… 후 ìžë£Œ 페ì´ì§€ì— 첫 ë³€ê²½ì´ ìžˆëŠ” 경우, WALì— ë³€ê²½ëœ ë‚´ìš©ë§Œ 기" +"ë¡í•˜ëŠ” ê²ƒì´ ì•„ë‹ˆë¼, 해당 페ì´ì§€ 전체를 기ë¡í•©ë‹ˆë‹¤." #: utils/misc/guc.c:1005 msgid "Compresses full-page writes written in WAL file." @@ -22598,8 +22687,7 @@ msgstr "ëˆ„ì  ì„±ëŠ¥ 통계를 서버 ë¡œê·¸ì— ê¸°ë¡í•¨." msgid "" "Logs system resource usage statistics (memory and CPU) on various B-tree " "operations." -msgstr "" -"다양한 B트리 ìž‘ì—…ì— ìžì›(메모리, CPU) 사용 통계를 기ë¡ì— 남기" +msgstr "다양한 B트리 ìž‘ì—…ì— ìžì›(메모리, CPU) 사용 통계를 기ë¡ì— 남기" #: utils/misc/guc.c:1179 msgid "Collects information about executing commands." @@ -22630,8 +22718,7 @@ msgid "" "Enables updating of the process title every time a new SQL command is " "received by the server." msgstr "" -"서버가 새 SQL ëª…ë ¹ì„ ë°›ì„ ë•Œë§ˆë‹¤ 프로세스 ì œëª©ì´ ì—…ë°ì´íŠ¸ë  수 있ë„" -"ë¡ í•©ë‹ˆë‹¤." +"서버가 새 SQL ëª…ë ¹ì„ ë°›ì„ ë•Œë§ˆë‹¤ 프로세스 ì œëª©ì´ ì—…ë°ì´íŠ¸ë  수 있ë„ë¡ í•©ë‹ˆë‹¤." #: utils/misc/guc.c:1223 msgid "Starts the autovacuum subprocess." @@ -22656,8 +22743,7 @@ msgstr "가벼운 잠금 사용 정보를 로그로 남김" #: utils/misc/guc.c:1275 msgid "" "Dumps information about all current locks when a deadlock timeout occurs." -msgstr "" -"êµì°© 잠금 시간 제한 ìƒí™©ì´ ë°œìƒí•˜ë©´ ê·¸ ë•Œì˜ ëª¨ë“  잠금 정보를 보여줌" +msgstr "êµì°© 잠금 시간 제한 ìƒí™©ì´ ë°œìƒí•˜ë©´ ê·¸ ë•Œì˜ ëª¨ë“  잠금 정보를 보여줌" #: utils/misc/guc.c:1287 msgid "Logs long lock waits." @@ -22733,8 +22819,8 @@ msgid "" "Whether to defer a read-only serializable transaction until it can be " "executed with no possible serialization failures." msgstr "" -"ì½ê¸° ì „ìš© ì§ë ¬í™” 가능한 íŠ¸ëžœìž­ì…˜ì´ ì§ë ¬ 처리ì—ì„œ 오류가 ì—†ì„ ë•Œê¹Œì§€ " -"ê·¸ íŠ¸ëžœìž­ì…˜ì„ ì§€ì—°í•  것ì´ì§€ 결정함" +"ì½ê¸° ì „ìš© ì§ë ¬í™” 가능한 íŠ¸ëžœìž­ì…˜ì´ ì§ë ¬ 처리ì—ì„œ 오류가 ì—†ì„ ë•Œê¹Œì§€ ê·¸ 트랜잭" +"ì…˜ì„ ì§€ì—°í•  것ì´ì§€ 결정함" #: utils/misc/guc.c:1389 msgid "Enable row security." @@ -22769,7 +22855,8 @@ msgstr "기본ì ìœ¼ë¡œ OID를 사용하여 새 í…Œì´ë¸”ì„ ë§Œë“­ë‹ˆë‹¤." msgid "" "Start a subprocess to capture stderr output and/or csvlogs into log files." msgstr "" -"로그 ê¸°ë¡ í•˜ìœ„ 프로세스를 시작하여 stderr 출력 ë°/ë˜ëŠ” csvlog를 로그 파ì¼ì— ì”니다." +"로그 ê¸°ë¡ í•˜ìœ„ 프로세스를 시작하여 stderr 출력 ë°/ë˜ëŠ” csvlog를 로그 파ì¼ì— " +"ì”니다." #: utils/misc/guc.c:1436 msgid "Truncate existing log files of same name during log rotation." @@ -22800,8 +22887,8 @@ msgid "" "Sets whether Kerberos and GSSAPI user names should be treated as case-" "insensitive." msgstr "" -"Kerberos ë° GSSAPI ì‚¬ìš©ìž ì´ë¦„ì—ì„œ 대/소문ìžë¥¼ 구분하지 ì•Šì„지 여부를 " -"설정합니다." +"Kerberos ë° GSSAPI ì‚¬ìš©ìž ì´ë¦„ì—ì„œ 대/소문ìžë¥¼ 구분하지 ì•Šì„지 여부를 설정합" +"니다." #: utils/misc/guc.c:1526 msgid "Warn about backslash escapes in ordinary string literals." @@ -22823,7 +22910,8 @@ msgstr "복구 중ì—ì„œë„ ì ‘ì†ê³¼ 쿼리 ì‚¬ìš©ì„ í—ˆìš©í•¨" msgid "" "Allows feedback from a hot standby to the primary that will avoid query " "conflicts." -msgstr "ì½ê¸° ì „ìš© ë³´ì¡° 서버가 보내는 쿼리 충ëŒì„ 피하기 위한 í”¼ë“œë°±ì„ ì£¼ 서버가 ë°›ìŒ" +msgstr "" +"ì½ê¸° ì „ìš© ë³´ì¡° 서버가 보내는 쿼리 충ëŒì„ 피하기 위한 í”¼ë“œë°±ì„ ì£¼ 서버가 ë°›ìŒ" #: utils/misc/guc.c:1577 msgid "Allows modifications of the structure of system tables." @@ -22838,8 +22926,8 @@ msgid "" "It does not prevent updating the indexes, so it is safe to use. The worst " "consequence is slowness." msgstr "" -"ì´ ì„¤ì •ì´ í™œì„±í™” ë˜ì–´ë„ ê·¸ ì¸ë±ìŠ¤ëŠ” 갱신ë˜ì–´ 사용하는ë°ëŠ” 안전합니다. " -"하지만 서버가 ì „ì²´ì ìœ¼ë¡œ 늦어질 수 있습니다." +"ì´ ì„¤ì •ì´ í™œì„±í™” ë˜ì–´ë„ ê·¸ ì¸ë±ìŠ¤ëŠ” 갱신ë˜ì–´ 사용하는ë°ëŠ” 안전합니다. 하지" +"만 서버가 ì „ì²´ì ìœ¼ë¡œ 늦어질 수 있습니다." #: utils/misc/guc.c:1600 msgid "" @@ -22851,8 +22939,8 @@ msgid "" "Skips privilege checks when reading or modifying large objects, for " "compatibility with PostgreSQL releases prior to 9.0." msgstr "" -"PostgreSQL 9.0 ì´ì „ ë²„ì „ì˜ í˜¸í™˜ì„±ì„ ìœ„í•´ 대형 ê°ì²´ì— 대한 ì½ê¸°, 변경 ì‹œ " -"ì ‘ê·¼ 권한 검사를 안 하ë„ë¡ ì„¤ì •í•¨" +"PostgreSQL 9.0 ì´ì „ ë²„ì „ì˜ í˜¸í™˜ì„±ì„ ìœ„í•´ 대형 ê°ì²´ì— 대한 ì½ê¸°, 변경 ì‹œ ì ‘ê·¼ " +"권한 검사를 안 하ë„ë¡ ì„¤ì •í•¨" #: utils/misc/guc.c:1611 msgid "" @@ -22912,8 +23000,8 @@ msgid "" "The planner will merge subqueries into upper queries if the resulting FROM " "list would have no more than this many items." msgstr "" -"ê²°ê³¼ FROM 목ë¡ì— í¬í•¨ëœ í•­ëª©ì´ ì´ ê°œìˆ˜ë¥¼ 넘지 않는 경우 ê³„íš ê´€ë¦¬ìž" -"ê°€ 하위 쿼리를 ìƒìœ„ ì¿¼ë¦¬ì— ë³‘í•©í•©ë‹ˆë‹¤." +"ê²°ê³¼ FROM 목ë¡ì— í¬í•¨ëœ í•­ëª©ì´ ì´ ê°œìˆ˜ë¥¼ 넘지 않는 경우 ê³„íš ê´€ë¦¬ìžê°€ 하" +"위 쿼리를 ìƒìœ„ ì¿¼ë¦¬ì— ë³‘í•©í•©ë‹ˆë‹¤." #: utils/misc/guc.c:1714 msgid "Sets the FROM-list size beyond which JOIN constructs are not flattened." @@ -22925,8 +23013,8 @@ msgid "" "The planner will flatten explicit JOIN constructs into lists of FROM items " "whenever a list of no more than this many items would result." msgstr "" -"ê²°ê³¼ 목ë¡ì— í¬í•¨ëœ í•­ëª©ì´ ì´ ê°œìˆ˜ë¥¼ 넘지 ì•Šì„ ë•Œë§ˆë‹¤ ê³„íš ê´€ë¦¬ìžê°€ " -"ëª…ì‹œì  JOIN êµ¬ë¬¸ì„ FROM 항목 목ë¡ì— 결합합니다." +"ê²°ê³¼ 목ë¡ì— í¬í•¨ëœ í•­ëª©ì´ ì´ ê°œìˆ˜ë¥¼ 넘지 ì•Šì„ ë•Œë§ˆë‹¤ ê³„íš ê´€ë¦¬ìžê°€ 명시" +"ì  JOIN êµ¬ë¬¸ì„ FROM 항목 목ë¡ì— 결합합니다." #: utils/misc/guc.c:1726 msgid "Sets the threshold of FROM items beyond which GEQO is used." @@ -22958,7 +23046,8 @@ msgid "" "Sets the maximum delay before canceling queries when a hot standby server is " "processing archived WAL data." msgstr "" -"ì½ê¸° ì „ìš© ë³´ì¡° 서버가 ì•„ì¹´ì´ë¸Œëœ WAL ìžë£Œë¥¼ 처리할 ë•Œ, ì§€ì—°ë  ìˆ˜ 있는 최대 시간" +"ì½ê¸° ì „ìš© ë³´ì¡° 서버가 ì•„ì¹´ì´ë¸Œëœ WAL ìžë£Œë¥¼ 처리할 ë•Œ, ì§€ì—°ë  ìˆ˜ 있는 최대 ì‹œ" +"ê°„" #: utils/misc/guc.c:1786 msgid "" @@ -22974,7 +23063,8 @@ msgstr "주 서버로 WAL 수신기 ìƒíƒœë¥¼ 보고하는 최대 간격" #: utils/misc/guc.c:1808 msgid "Sets the maximum wait time to receive data from the primary." -msgstr "주 서버ì—ì„œ 보낸 ìžë£Œë¥¼ 받기위해 기다릴 수 있는 최대 허용 ì‹œê°„ì„ ì„¤ì •í•©ë‹ˆë‹¤." +msgstr "" +"주 서버ì—ì„œ 보낸 ìžë£Œë¥¼ 받기위해 기다릴 수 있는 최대 허용 ì‹œê°„ì„ ì„¤ì •í•©ë‹ˆë‹¤." #: utils/misc/guc.c:1819 msgid "Sets the maximum number of concurrent connections." @@ -23007,10 +23097,9 @@ msgid "" "accepted by the chmod and umask system calls. (To use the customary octal " "format the number must start with a 0 (zero).)" msgstr "" -"Unix ë„ë©”ì¸ ì†Œì¼“ì€ ì¼ë°˜ì ì¸ Unix íŒŒì¼ ì‹œìŠ¤í…œ 권한 ì§‘í•©ì„ ì‚¬ìš©í•©ë‹ˆë‹¤. " -"매개 변수 ê°’ì€ chmod ë° umask 시스템 호출ì—ì„œ 수ë½ë˜ëŠ” í˜•íƒœì˜ ìˆ«ìž " -"모드 지정ì´ì–´ì•¼ 합니다. (ì¼ë°˜ì ì¸ 8진수 형ì‹ì„ 사용하려면 숫ìžê°€ 0으로 " -"시작해야 합니다.)" +"Unix ë„ë©”ì¸ ì†Œì¼“ì€ ì¼ë°˜ì ì¸ Unix íŒŒì¼ ì‹œìŠ¤í…œ 권한 ì§‘í•©ì„ ì‚¬ìš©í•©ë‹ˆë‹¤. 매개 ë³€" +"수 ê°’ì€ chmod ë° umask 시스템 호출ì—ì„œ 수ë½ë˜ëŠ” í˜•íƒœì˜ ìˆ«ìž ëª¨ë“œ 지정ì´ì–´ì•¼ " +"합니다. (ì¼ë°˜ì ì¸ 8진수 형ì‹ì„ 사용하려면 숫ìžê°€ 0으로 시작해야 합니다.)" #: utils/misc/guc.c:1890 msgid "Sets the file permissions for log files." @@ -23022,9 +23111,9 @@ msgid "" "form accepted by the chmod and umask system calls. (To use the customary " "octal format the number must start with a 0 (zero).)" msgstr "" -"매개 변수 ê°’ì€ chmod ë° umask 시스템 호출ì—ì„œ 수ë½ë˜ëŠ” í˜•íƒœì˜ ìˆ«ìž " -"모드 지정ì´ì–´ì•¼ 합니다. (ì¼ë°˜ì ì¸ 8진수 형ì‹ì„ 사용하려면 숫ìžê°€ 0으로 " -"시작해야 합니다.)" +"매개 변수 ê°’ì€ chmod ë° umask 시스템 호출ì—ì„œ 수ë½ë˜ëŠ” í˜•íƒœì˜ ìˆ«ìž ëª¨ë“œ 지정" +"ì´ì–´ì•¼ 합니다. (ì¼ë°˜ì ì¸ 8진수 형ì‹ì„ 사용하려면 숫ìžê°€ 0으로 시작해야 합니" +"다.)" #: utils/misc/guc.c:1904 msgid "Sets the maximum memory to be used for query workspaces." @@ -23035,8 +23124,8 @@ msgid "" "This much memory can be used by each internal sort operation and hash table " "before switching to temporary disk files." msgstr "" -"ìž„ì‹œ ë””ìŠ¤í¬ íŒŒì¼ë¡œ 전환하기 ì „ì— ê° ë‚´ë¶€ ì •ë ¬ ìž‘ì—…ê³¼ í•´ì‹œ í…Œì´ë¸”ì—ì„œ " -"ì´ í¬ê¸°ì˜ 메모리를 사용할 수 있습니다." +"ìž„ì‹œ ë””ìŠ¤í¬ íŒŒì¼ë¡œ 전환하기 ì „ì— ê° ë‚´ë¶€ ì •ë ¬ ìž‘ì—…ê³¼ í•´ì‹œ í…Œì´ë¸”ì—ì„œ ì´ í¬ê¸°" +"ì˜ ë©”ëª¨ë¦¬ë¥¼ 사용할 수 있습니다." #: utils/misc/guc.c:1917 msgid "Sets the maximum memory to be used for maintenance operations." @@ -23049,14 +23138,12 @@ msgstr "ê´€ë¦¬ìž‘ì—…ì€ VACUUM, CREATE INDEX ê°™ì€ ìž‘ì—…ì„ ëœ»í•©ë‹ˆë‹¤." #: utils/misc/guc.c:1928 msgid "" "Sets the maximum number of tuples to be sorted using replacement selection." -msgstr "" -"replacement selection ê¸°ëŠ¥ì„ ì´ìš©í•  최대 튜플 수" +msgstr "replacement selection ê¸°ëŠ¥ì„ ì´ìš©í•  최대 튜플 수" #: utils/misc/guc.c:1929 msgid "When more tuples than this are present, quicksort will be used." msgstr "ì´ íŠœí”Œ 수 보다 많으면, quicksort 를 사용함" - #: utils/misc/guc.c:1943 msgid "Sets the maximum stack depth, in kilobytes." msgstr "스íƒê¹Šì´(KB 단위) ìµœëŒ€ê°’ì„ ì§€ì •í•©ë‹ˆë‹¤." @@ -23150,7 +23237,8 @@ msgstr "VACUUMì—ì„œ í…Œì´ë¸” MultiXactId ë™ê²°í•  ë•Œê¹Œì§€ì˜ ìµœì†Œ 기간 #: utils/misc/guc.c:2146 msgid "Multixact age at which VACUUM should scan whole table to freeze tuples." msgstr "" -"VACUUMì—ì„œ íŠœí”Œì„ ë™ê²°í•˜ê¸° 위해 ì „ì²´ í…Œì´ë¸”ì„ ìŠ¤ìº”í•  ë•Œê¹Œì§€ì˜ ë©€í‹°íŠ¸ëžœìž­ì…˜ 기간입니다." +"VACUUMì—ì„œ íŠœí”Œì„ ë™ê²°í•˜ê¸° 위해 ì „ì²´ í…Œì´ë¸”ì„ ìŠ¤ìº”í•  ë•Œê¹Œì§€ì˜ ë©€í‹°íŠ¸ëžœìž­ì…˜ 기" +"간입니다." #: utils/misc/guc.c:2156 msgid "" @@ -23169,8 +23257,8 @@ msgid "" "locked at any one time." msgstr "" "공유 잠금 í…Œì´ë¸”ì€ í•œ ë²ˆì— ìž ê¶ˆì•¼ í•  고유 ê°ì²´ 수가 " -"max_locks_per_transaction * max_connections를 넘지 않는다는 가정 í•˜ì— " -"í¬ê¸°ê°€ 지정ë©ë‹ˆë‹¤." +"max_locks_per_transaction * max_connections를 넘지 않는다는 가정 í•˜ì— í¬ê¸°ê°€ " +"지정ë©ë‹ˆë‹¤." #: utils/misc/guc.c:2181 msgid "Sets the maximum number of predicate locks per transaction." @@ -23183,8 +23271,8 @@ msgid "" "to be locked at any one time." msgstr "" "공유 predicate 잠금 í…Œì´ë¸”ì€ í•œ ë²ˆì— ìž ê¶ˆì•¼ í•  고유 ê°ì²´ 수가 " -"max_pred_locks_per_transaction * max_connections를 넘지 않는다는 가정 í•˜ì— " -"í¬ê¸°ê°€ 지정ë©ë‹ˆë‹¤." +"max_pred_locks_per_transaction * max_connections를 넘지 않는다는 가정 í•˜ì— í¬" +"기가 지정ë©ë‹ˆë‹¤." #: utils/misc/guc.c:2193 msgid "Sets the maximum allowed time to complete client authentication." @@ -23213,8 +23301,7 @@ msgstr "ìžë™ WAL ì²´í¬í¬ì¸íŠ¸ 사ì´ì˜ 최대 ê°„ê²©ì„ ì„¤ì •í•©ë‹ˆë‹¤." #: utils/misc/guc.c:2259 msgid "" "Enables warnings if checkpoint segments are filled more frequently than this." -msgstr "" -"지정 시간 ì•ˆì— ì²´í¬í¬ì¸íŠ¸ ì¡°ê°ì´ ëª¨ë‘ ì±„ì›Œì§€ë©´ 경고를 냄" +msgstr "지정 시간 ì•ˆì— ì²´í¬í¬ì¸íŠ¸ ì¡°ê°ì´ ëª¨ë‘ ì±„ì›Œì§€ë©´ 경고를 냄" #: utils/misc/guc.c:2261 msgid "" @@ -23226,54 +23313,53 @@ msgstr "" "ìš©ì´ ê½‰ 차는 사태가 ë°œìƒí•˜ë©´ 경고 메시지를 서버 ë¡œê·¸ì— ë‚¨ê¹ë‹ˆë‹¤. ì´ ê°’ì„ 0으" "ë¡œ 지정하면 ì´ ê¸°ëŠ¥ ì—†ìŒ" -#: utils/misc/guc.c:2273 utils/misc/guc.c:2431 utils/misc/guc.c:2459 +#: utils/misc/guc.c:2273 utils/misc/guc.c:2430 utils/misc/guc.c:2457 msgid "" "Number of pages after which previously performed writes are flushed to disk." msgstr "" -"" -#: utils/misc/guc.c:2285 +#: utils/misc/guc.c:2284 msgid "Sets the number of disk-page buffers in shared memory for WAL." msgstr "" "WAL ê¸°ëŠ¥ì„ ìœ„í•´ 공유 메모리ì—ì„œ 사용할 ë””ìŠ¤í¬ íŽ˜ì´ì§€ ë²„í¼ ê°œìˆ˜ë¥¼ 지정함." -#: utils/misc/guc.c:2296 +#: utils/misc/guc.c:2295 msgid "Time between WAL flushes performed in the WAL writer." msgstr "WAL 기ë¡ìžê°€ 지정 시간 ë§Œí¼ ì‰¬ê³  쓰기 ìž‘ì—…ì„ ë°˜ë³µí•¨" -#: utils/misc/guc.c:2307 -msgid "Amount of WAL written out by WAL writer triggering a flush." +#: utils/misc/guc.c:2306 +msgid "Amount of WAL written out by WAL writer that triggers a flush." msgstr "" -#: utils/misc/guc.c:2319 +#: utils/misc/guc.c:2318 msgid "Sets the maximum number of simultaneously running WAL sender processes." msgstr "ë™ì‹œì— ìž‘ë™í•  WAL 송신 프로세스 최대 수 지정" -#: utils/misc/guc.c:2330 +#: utils/misc/guc.c:2329 msgid "Sets the maximum number of simultaneously defined replication slots." msgstr "ë™ì‹œì— 사용할 수 있는 복제 슬롯 최대 수 지정" -#: utils/misc/guc.c:2340 +#: utils/misc/guc.c:2339 msgid "Sets the maximum time to wait for WAL replication." msgstr "WAL 복제를 위해 기다릴 최대 시간 설정" -#: utils/misc/guc.c:2351 +#: utils/misc/guc.c:2350 msgid "" "Sets the delay in microseconds between transaction commit and flushing WAL " "to disk." msgstr "" "트랜잭션과 트랜잭션 ë¡œê·¸ì˜ ì ìš© 사ì´ì˜ ê°„ê²©ì„ microsecond 단위로 지정함" -#: utils/misc/guc.c:2363 +#: utils/misc/guc.c:2362 msgid "" "Sets the minimum concurrent open transactions before performing commit_delay." msgstr "commit_delay 처리하기 ì „ì— ìžˆëŠ” 최소 ë™ì‹œ ì—´ë ¤ 있는 트랜잭션 개수." -#: utils/misc/guc.c:2374 +#: utils/misc/guc.c:2373 msgid "Sets the number of digits displayed for floating-point values." msgstr "부ë™ì†Œìˆ˜í˜• ê°’ì„ í‘œê¸°í•  ë•Œ " -#: utils/misc/guc.c:2375 +#: utils/misc/guc.c:2374 msgid "" "This affects real, double precision, and geometric data types. The parameter " "value is added to the standard number of digits (FLT_DIG or DBL_DIG as " @@ -23282,570 +23368,573 @@ msgstr "" "ì´ ê°’ì€ real, duoble ë¶€ë™ ì†Œìˆ«ì ê³¼ 지리정보 ìžë£Œí˜•ì— ì˜í–¥ì„ ë¼ì¹©ë‹ˆë‹¤. ì´ ê°’" "ì€ ì •ìˆ˜ì—¬ì•¼í•©ë‹ˆë‹¤(FLT_DIG or DBL_DIG as appropriate - 무슨 ë§ì¸ì§€)." -#: utils/misc/guc.c:2386 +#: utils/misc/guc.c:2385 msgid "Sets the minimum execution time above which statements will be logged." -msgstr "ì´ ì‹œê°„ì„ ì´ˆê³¼í•  경우 ì¿¼ë¦¬ë¬¸ì„ ë¡œê·¸ë¡œ 남길 최소 실행 ì‹œê°„ì„ ì„¤ì •í•©ë‹ˆë‹¤." +msgstr "" +"ì´ ì‹œê°„ì„ ì´ˆê³¼í•  경우 ì¿¼ë¦¬ë¬¸ì„ ë¡œê·¸ë¡œ 남길 최소 실행 ì‹œê°„ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2388 +#: utils/misc/guc.c:2387 msgid "Zero prints all queries. -1 turns this feature off." msgstr "" "0ì„ ì§€ì •í•˜ë©´ 모든 쿼리가 ì¸ì‡„ë©ë‹ˆë‹¤. -1ì„ ì§€ì •í•˜ë©´ ì´ ê¸°ëŠ¥ì´ í•´ì œë©ë‹ˆë‹¤." -#: utils/misc/guc.c:2398 +#: utils/misc/guc.c:2397 msgid "" "Sets the minimum execution time above which autovacuum actions will be " "logged." msgstr "" -"ì´ ì‹œê°„ì„ ì´ˆê³¼í•  경우 ìžë™ 청소 ìž‘ì—… 로그를 남길 최소 실행 ì‹œê°„ì„ ì„¤ì •" -"합니다." +"ì´ ì‹œê°„ì„ ì´ˆê³¼í•  경우 ìžë™ 청소 ìž‘ì—… 로그를 남길 최소 실행 ì‹œê°„ì„ ì„¤ì •í•©ë‹ˆ" +"다." -#: utils/misc/guc.c:2400 +#: utils/misc/guc.c:2399 msgid "Zero prints all actions. -1 turns autovacuum logging off." msgstr "" "0ì„ ì§€ì •í•˜ë©´ 모든 ìž‘ì—…ì´ ì¸ì‡„ë©ë‹ˆë‹¤. -1ì„ ì§€ì •í•˜ë©´ ìžë™ 청소 기ë¡ì´ í•´ì œë©ë‹ˆ" "다." -#: utils/misc/guc.c:2410 +#: utils/misc/guc.c:2409 msgid "Background writer sleep time between rounds." msgstr "백그ë¼ìš´ë“œ 기ë¡ìžì˜ ìž ìžëŠ” 시간" -#: utils/misc/guc.c:2421 +#: utils/misc/guc.c:2420 msgid "Background writer maximum number of LRU pages to flush per round." msgstr "ë¼ìš´ë“œë‹¹ 플러시할 백그ë¼ìš´ë“œ 작성기 최대 LRU 페ì´ì§€ 수입니다." -#: utils/misc/guc.c:2445 +#: utils/misc/guc.c:2443 msgid "" "Number of simultaneous requests that can be handled efficiently by the disk " "subsystem." msgstr "" -"ë””ìŠ¤í¬ í•˜ìœ„ 시스템ì—ì„œ 효율ì ìœ¼ë¡œ 처리할 수 있는 ë™ì‹œ 요청 수입니" -"다." +"ë””ìŠ¤í¬ í•˜ìœ„ 시스템ì—ì„œ 효율ì ìœ¼ë¡œ 처리할 수 있는 ë™ì‹œ 요청 수입니다." -#: utils/misc/guc.c:2446 +#: utils/misc/guc.c:2444 msgid "" "For RAID arrays, this should be approximately the number of drive spindles " "in the array." -msgstr "" -"RAID ë°°ì—´ì˜ ê²½ìš° ì´ ê°’ì€ ëŒ€ëžµ ë°°ì—´ì˜ ë“œë¼ì´ë¸Œ 스핀들 수입니다." +msgstr "RAID ë°°ì—´ì˜ ê²½ìš° ì´ ê°’ì€ ëŒ€ëžµ ë°°ì—´ì˜ ë“œë¼ì´ë¸Œ 스핀들 수입니다." -#: utils/misc/guc.c:2472 +#: utils/misc/guc.c:2470 msgid "Maximum number of concurrent worker processes." msgstr "ë™ì‹œ ìž‘ì—…ìž í”„ë¡œì„¸ìŠ¤ì˜ ìµœëŒ€ 수" -#: utils/misc/guc.c:2482 +#: utils/misc/guc.c:2480 msgid "Automatic log file rotation will occur after N minutes." msgstr "N분 í›„ì— ìžë™ 로그 íŒŒì¼ íšŒì „ì´ ë°œìƒí•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2493 +#: utils/misc/guc.c:2491 msgid "Automatic log file rotation will occur after N kilobytes." msgstr "N킬로바ì´íŠ¸ í›„ì— ìžë™ 로그 íŒŒì¼ íšŒì „ì´ ë°œìƒí•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2504 +#: utils/misc/guc.c:2502 msgid "Shows the maximum number of function arguments." msgstr "함수 ì¸ìžì˜ 최대 갯수를 ë³´ì—¬ì¤ë‹ˆë‹¤" -#: utils/misc/guc.c:2515 +#: utils/misc/guc.c:2513 msgid "Shows the maximum number of index keys." msgstr "ì¸ë±ìŠ¤ í‚¤ì˜ ìµœëŒ€ê°œìˆ˜ë¥¼ ë³´ì—¬ì¤ë‹ˆë‹¤." -#: utils/misc/guc.c:2526 +#: utils/misc/guc.c:2524 msgid "Shows the maximum identifier length." msgstr "최대 ì‹ë³„ìž ê¸¸ì´ë¥¼ 표시합니다." -#: utils/misc/guc.c:2537 +#: utils/misc/guc.c:2535 msgid "Shows the size of a disk block." msgstr "ë””ìŠ¤í¬ ë¸”ë¡ì˜ í¬ê¸°ë¥¼ 표시합니다." -#: utils/misc/guc.c:2548 +#: utils/misc/guc.c:2546 msgid "Shows the number of pages per disk file." msgstr "ë””ìŠ¤í¬ íŒŒì¼ë‹¹ 페ì´ì§€ 수를 표시합니다." -#: utils/misc/guc.c:2559 +#: utils/misc/guc.c:2557 msgid "Shows the block size in the write ahead log." msgstr "미리 쓰기 ë¡œê·¸ì˜ ë¸”ë¡ í¬ê¸°ë¥¼ 표시합니다." -#: utils/misc/guc.c:2570 +#: utils/misc/guc.c:2568 msgid "" "Sets the time to wait before retrying to retrieve WAL after a failed attempt." msgstr "" -#: utils/misc/guc.c:2582 +#: utils/misc/guc.c:2580 msgid "Shows the number of pages per write ahead log segment." msgstr "미리 쓰기 로그 세그먼트당 페ì´ì§€ 수를 표시합니다." -#: utils/misc/guc.c:2595 +#: utils/misc/guc.c:2593 msgid "Time to sleep between autovacuum runs." msgstr "ìžë™ 청소 실행 사ì´ì˜ 절전 모드 시간입니다." -#: utils/misc/guc.c:2605 +#: utils/misc/guc.c:2603 msgid "Minimum number of tuple updates or deletes prior to vacuum." msgstr "청소 ì „ì˜ ìµœì†Œ 튜플 ì—…ë°ì´íŠ¸ ë˜ëŠ” ì‚­ì œ 수입니다." -#: utils/misc/guc.c:2614 +#: utils/misc/guc.c:2612 msgid "Minimum number of tuple inserts, updates, or deletes prior to analyze." msgstr "통계 ì •ë³´ ìˆ˜ì§‘ì„ ìœ„í•œ 최소 튜플 삽입, ì—…ë°ì´íŠ¸ ë˜ëŠ” ì‚­ì œ 수입니다." -#: utils/misc/guc.c:2624 +#: utils/misc/guc.c:2622 msgid "" "Age at which to autovacuum a table to prevent transaction ID wraparound." msgstr "" -"트랜잭션 ID 겹침 방지를 위해 í…Œì´ë¸”ì— ëŒ€í•´ autovacuum ìž‘ì—…ì„ ìˆ˜í–‰í•  í…Œì´ë¸” 나ì´ë¥¼ 지정합니다." +"트랜잭션 ID 겹침 방지를 위해 í…Œì´ë¸”ì— ëŒ€í•´ autovacuum ìž‘ì—…ì„ ìˆ˜í–‰í•  í…Œì´ë¸” 나" +"ì´ë¥¼ 지정합니다." -#: utils/misc/guc.c:2635 +#: utils/misc/guc.c:2633 msgid "" "Multixact age at which to autovacuum a table to prevent multixact wraparound." msgstr "" -"멀티 트랜잭션 ID 겹침 방지를 위해 í…Œì´ë¸”ì— ëŒ€í•´ autovacuum ìž‘ì—…ì„ ìˆ˜í–‰í•  트랜잭션 나ì´ë¥¼ 지정합니다." +"멀티 트랜잭션 ID 겹침 방지를 위해 í…Œì´ë¸”ì— ëŒ€í•´ autovacuum ìž‘ì—…ì„ ìˆ˜í–‰í•  트랜" +"ìž­ì…˜ 나ì´ë¥¼ 지정합니다." -#: utils/misc/guc.c:2645 +#: utils/misc/guc.c:2643 msgid "" "Sets the maximum number of simultaneously running autovacuum worker " "processes." msgstr "ë™ì‹œì— ìž‘ì—…í•  수 있는 autovacuum ìž‘ì—…ìž ìµœëŒ€ 수 지정" -#: utils/misc/guc.c:2655 +#: utils/misc/guc.c:2653 msgid "Sets the maximum number of parallel processes per executor node." msgstr "실행 노드당 최대 병렬 처리 수 지정" -#: utils/misc/guc.c:2665 +#: utils/misc/guc.c:2663 msgid "Sets the maximum memory to be used by each autovacuum worker process." msgstr "ê° autovacuum ìž‘ì—…ìž í”„ë¡œì„¸ìŠ¤ê°€ 사용할 메모리 최대치" -#: utils/misc/guc.c:2676 +#: utils/misc/guc.c:2674 msgid "" "Time before a snapshot is too old to read pages changed after the snapshot " "was taken." msgstr "" -#: utils/misc/guc.c:2677 +#: utils/misc/guc.c:2675 msgid "A value of -1 disables this feature." msgstr "ì´ ê°’ì´ -1 ì´ë©´ ì´ ê¸°ëŠ¥ 사용 안함" -#: utils/misc/guc.c:2687 +#: utils/misc/guc.c:2685 msgid "Time between issuing TCP keepalives." msgstr "TCP ì—°ê²° 유지 실행 간격입니다." -#: utils/misc/guc.c:2688 utils/misc/guc.c:2699 +#: utils/misc/guc.c:2686 utils/misc/guc.c:2697 msgid "A value of 0 uses the system default." msgstr "ì´ ê°’ì´ 0ì´ë©´ 시스템 기본 ê°’" -#: utils/misc/guc.c:2698 +#: utils/misc/guc.c:2696 msgid "Time between TCP keepalive retransmits." msgstr "TCP keepalive 시간 설정" -#: utils/misc/guc.c:2709 +#: utils/misc/guc.c:2707 msgid "SSL renegotiation is no longer supported; this can only be 0." msgstr "" -#: utils/misc/guc.c:2720 +#: utils/misc/guc.c:2718 msgid "Maximum number of TCP keepalive retransmits." msgstr "TCP keepalive í™•ì¸ ìµœëŒ€ 횟수" -#: utils/misc/guc.c:2721 +#: utils/misc/guc.c:2719 msgid "" "This controls the number of consecutive keepalive retransmits that can be " "lost before a connection is considered dead. A value of 0 uses the system " "default." msgstr "" -"ì´ ê°’ì€ ì—°ê²°ì´ ì¤‘ë‹¨ëœ ê²ƒìœ¼ë¡œ 간주ë˜ê¸° ì „ì— ì†ì‹¤ë  수 있는 ì—°ì† ì—°" -"ê²° 유지 재전송 수를 제어합니다. ê°’ 0ì„ ì§€ì •í•˜ë©´ 시스템 기본 ê°’ì´ ì‚¬ìš©ë©" -"니다." +"ì´ ê°’ì€ ì—°ê²°ì´ ì¤‘ë‹¨ëœ ê²ƒìœ¼ë¡œ 간주ë˜ê¸° ì „ì— ì†ì‹¤ë  수 있는 ì—°ì† ì—°ê²° 유" +"지 재전송 수를 제어합니다. ê°’ 0ì„ ì§€ì •í•˜ë©´ 시스템 기본 ê°’ì´ ì‚¬ìš©ë©ë‹ˆë‹¤." -#: utils/misc/guc.c:2732 +#: utils/misc/guc.c:2730 msgid "Sets the maximum allowed result for exact search by GIN." msgstr "정확한 GIN 기준 ê²€ìƒ‰ì— í—ˆìš©ë˜ëŠ” 최대 ê²°ê³¼ 수를 설정합니다." -#: utils/misc/guc.c:2743 +#: utils/misc/guc.c:2741 msgid "Sets the planner's assumption about the size of the disk cache." msgstr "ë””ìŠ¤í¬ ìºì‹œ í¬ê¸°ì— 대한 ê³„íš ê´€ë¦¬ìžì˜ ê°€ì •ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2744 +#: utils/misc/guc.c:2742 msgid "" "That is, the portion of the kernel's disk cache that will be used for " "PostgreSQL data files. This is measured in disk pages, which are normally 8 " "kB each." msgstr "" -"즉, PostgreSQL ë°ì´í„° 파ì¼ì— ì‚¬ìš©ë  ì»¤ë„ì˜ ë””ìŠ¤í¬ ìºì‹œ 부분입니다. " -"ì´ ê°’ì€ ë””ìŠ¤í¬ íŽ˜ì´ì§€ 단위로 측정ë˜ë©°, ì¼ë°˜ì ìœ¼ë¡œ ê°ê° 8KB입니다." +"즉, PostgreSQL ë°ì´í„° 파ì¼ì— ì‚¬ìš©ë  ì»¤ë„ì˜ ë””ìŠ¤í¬ ìºì‹œ 부분입니다. ì´ ê°’" +"ì€ ë””ìŠ¤í¬ íŽ˜ì´ì§€ 단위로 측정ë˜ë©°, ì¼ë°˜ì ìœ¼ë¡œ ê°ê° 8KB입니다." -#: utils/misc/guc.c:2756 +#: utils/misc/guc.c:2754 msgid "Sets the minimum size of relations to be considered for parallel scan." msgstr "" -#: utils/misc/guc.c:2768 +#: utils/misc/guc.c:2766 msgid "Shows the server version as an integer." msgstr "서버 ë²„ì „ì„ ì •ìˆ˜í˜•ìœ¼ë¡œ ë³´ì—¬ì¤ë‹ˆë‹¤" -#: utils/misc/guc.c:2779 +#: utils/misc/guc.c:2777 msgid "Log the use of temporary files larger than this number of kilobytes." msgstr "ì´ í‚¬ë¡œë°”ì´íŠ¸ 수보다 í° ìž„ì‹œ 파ì¼ì˜ ì‚¬ìš©ì„ ê¸°ë¡í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2780 +#: utils/misc/guc.c:2778 msgid "Zero logs all files. The default is -1 (turning this feature off)." msgstr "" "0ì„ ì§€ì •í•˜ë©´ 모든 파ì¼ì´ 기ë¡ë©ë‹ˆë‹¤. 기본 ê°’ì€ -1ë¡œ, ì´ ê¸°ëŠ¥ì´ í•´ì œë©ë‹ˆë‹¤." -#: utils/misc/guc.c:2790 +#: utils/misc/guc.c:2788 msgid "Sets the size reserved for pg_stat_activity.query, in bytes." msgstr "pg_stat_activity.queryì— ì˜ˆì•½ë˜ëŠ” í¬ê¸°(ë°”ì´íŠ¸)를 설정합니다." -#: utils/misc/guc.c:2805 +#: utils/misc/guc.c:2803 msgid "Sets the maximum size of the pending list for GIN index." msgstr "GIN ì¸ë±ìŠ¤ë¥¼ 위한 팬딩(pending) 목ë¡ì˜ 최대 í¬ê¸° 지정" -#: utils/misc/guc.c:2825 +#: utils/misc/guc.c:2823 msgid "" "Sets the planner's estimate of the cost of a sequentially fetched disk page." msgstr "" -"순차ì ìœ¼ë¡œ 접근하는 ë””ìŠ¤í¬ íŽ˜ì´ì§€ì— 대한 ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ë¹„ìš©ì„ ì„¤ì •" -"합니다." +"순차ì ìœ¼ë¡œ 접근하는 ë””ìŠ¤í¬ íŽ˜ì´ì§€ì— 대한 ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ë¹„ìš©ì„ ì„¤ì •í•©ë‹ˆ" +"다." -#: utils/misc/guc.c:2835 +#: utils/misc/guc.c:2833 msgid "" "Sets the planner's estimate of the cost of a nonsequentially fetched disk " "page." msgstr "" -"비순차ì ìœ¼ë¡œ 접근하는 ë””ìŠ¤í¬ íŽ˜ì´ì§€ì— 대한 ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ë¹„ìš©ì„ " -"설정합니다." +"비순차ì ìœ¼ë¡œ 접근하는 ë””ìŠ¤í¬ íŽ˜ì´ì§€ì— 대한 ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ë¹„ìš©ì„ ì„¤ì •í•©ë‹ˆ" +"다." -#: utils/misc/guc.c:2845 +#: utils/misc/guc.c:2843 msgid "Sets the planner's estimate of the cost of processing each tuple (row)." msgstr "ê° íŠœí”Œ(í–‰)ì— ëŒ€í•œ ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ì²˜ë¦¬ ë¹„ìš©ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2855 +#: utils/misc/guc.c:2853 msgid "" "Sets the planner's estimate of the cost of processing each index entry " "during an index scan." msgstr "" -"실행 계íšê¸°ì˜ 비용 ê³„ì‚°ì— ì‚¬ìš©ë  ì¸ë±ìŠ¤ 스캔으로 ê° ì¸ë±ìŠ¤ í•­ëª©ì„ ì²˜ë¦¬í•˜ëŠ” ì˜ˆìƒ ì²˜ë¦¬ ë¹„ìš©ì„ " -"설정합니다." +"실행 계íšê¸°ì˜ 비용 ê³„ì‚°ì— ì‚¬ìš©ë  ì¸ë±ìŠ¤ 스캔으로 ê° ì¸ë±ìŠ¤ í•­ëª©ì„ ì²˜ë¦¬í•˜ëŠ” 예" +"ìƒ ì²˜ë¦¬ ë¹„ìš©ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2865 +#: utils/misc/guc.c:2863 msgid "" "Sets the planner's estimate of the cost of processing each operator or " "function call." msgstr "" -"실행 계íšê¸°ì˜ 비용 ê³„ì‚°ì— ì‚¬ìš©ë  í•¨ìˆ˜ 호출ì´ë‚˜ ì—°ì‚°ìž ì—°ì‚° 처리하는 ì˜ˆìƒ ì²˜ë¦¬ ë¹„ìš©ì„ " -"설정합니다." +"실행 계íšê¸°ì˜ 비용 ê³„ì‚°ì— ì‚¬ìš©ë  í•¨ìˆ˜ 호출ì´ë‚˜ ì—°ì‚°ìž ì—°ì‚° 처리하는 ì˜ˆìƒ ì²˜" +"리 ë¹„ìš©ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2875 +#: utils/misc/guc.c:2873 msgid "" "Sets the planner's estimate of the cost of passing each tuple (row) from " "worker to master backend." msgstr "ê° íŠœí”Œ(í–‰)ì— ëŒ€í•œ ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ì²˜ë¦¬ ë¹„ìš©ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2885 +#: utils/misc/guc.c:2883 msgid "" "Sets the planner's estimate of the cost of starting up worker processes for " "parallel query." msgstr "" -#: utils/misc/guc.c:2896 +#: utils/misc/guc.c:2894 msgid "" "Sets the planner's estimate of the fraction of a cursor's rows that will be " "retrieved." -msgstr "" -"ê²€ìƒ‰ë  ì»¤ì„œ í–‰ì— ëŒ€í•œ ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ë¶„ìˆ˜ ê°’ì„ ì„¤ì •í•©ë‹ˆë‹¤." +msgstr "ê²€ìƒ‰ë  ì»¤ì„œ í–‰ì— ëŒ€í•œ ê³„íš ê´€ë¦¬ìžì˜ ì˜ˆìƒ ë¶„ìˆ˜ ê°’ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2907 +#: utils/misc/guc.c:2905 msgid "GEQO: selective pressure within the population." msgstr "GEQO: 모집단 ë‚´ì˜ ì„ íƒ ì••ë ¥ìž…ë‹ˆë‹¤." -#: utils/misc/guc.c:2917 +#: utils/misc/guc.c:2915 msgid "GEQO: seed for random path selection." msgstr "GEQO: 무작위 경로 ì„ íƒì„ 위한 씨드" -#: utils/misc/guc.c:2927 +#: utils/misc/guc.c:2925 msgid "Multiple of the average buffer usage to free per round." msgstr "ë¼ìš´ë“œë‹¹ 해제할 í‰ê·  ë²„í¼ ì‚¬ìš©ì˜ ë°°ìˆ˜ìž…ë‹ˆë‹¤." -#: utils/misc/guc.c:2937 +#: utils/misc/guc.c:2935 msgid "Sets the seed for random-number generation." msgstr "난수 ìƒì„± ì†ë„를 설정합니다." -#: utils/misc/guc.c:2948 +#: utils/misc/guc.c:2946 msgid "" "Number of tuple updates or deletes prior to vacuum as a fraction of " "reltuples." msgstr "" -"vacuum ìž‘ì—…ì„ ì§„í–‰í•  update, delete ìž‘ì—…ëŸ‰ì„ ì „ì²´ ìžë£Œì— 대한 분수값으로 지정합니다." +"vacuum ìž‘ì—…ì„ ì§„í–‰í•  update, delete ìž‘ì—…ëŸ‰ì„ ì „ì²´ ìžë£Œì— 대한 분수값으로 지정" +"합니다." -#: utils/misc/guc.c:2957 +#: utils/misc/guc.c:2955 msgid "" "Number of tuple inserts, updates, or deletes prior to analyze as a fraction " "of reltuples." msgstr "" -"통계 수집 ìž‘ì—…ì„ ì§„í–‰í•  insert, update, delete ìž‘ì—…ëŸ‰ì„ ì „ì²´ ìžë£Œì— 대한 분수값으로 지정합니다." +"통계 수집 ìž‘ì—…ì„ ì§„í–‰í•  insert, update, delete ìž‘ì—…ëŸ‰ì„ ì „ì²´ ìžë£Œì— 대한 분수" +"값으로 지정합니다." -#: utils/misc/guc.c:2967 +#: utils/misc/guc.c:2965 msgid "" "Time spent flushing dirty buffers during checkpoint, as fraction of " "checkpoint interval." msgstr "" -"ì²´í¬í¬ì¸íŠ¸ ë„중 ë³€ê²½ëœ ë²„í¼ í”ŒëŸ¬ì‹œì— ì‚¬ìš©ëœ ì‹œê°„ìœ¼ë¡œ, ì²´í¬í¬ì¸íŠ¸ ê°„" -"ê²©ì˜ ë¶„ìˆ˜ 값입니다." +"ì²´í¬í¬ì¸íŠ¸ ë„중 ë³€ê²½ëœ ë²„í¼ í”ŒëŸ¬ì‹œì— ì‚¬ìš©ëœ ì‹œê°„ìœ¼ë¡œ, ì²´í¬í¬ì¸íŠ¸ ê°„ê²©ì˜ " +"분수 값입니다." -#: utils/misc/guc.c:2986 +#: utils/misc/guc.c:2984 msgid "Sets the shell command that will be called to archive a WAL file." msgstr "WAL 파ì¼ì„ ì•„ì¹´ì´ë¹™í•˜ê¸° 위해 í˜¸ì¶œë  ì…¸ ëª…ë ¹ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:2996 +#: utils/misc/guc.c:2994 msgid "Sets the client's character set encoding." msgstr "í´ë¼ì´ì–¸íŠ¸ ë¬¸ìž ì„¸íŠ¸ ì¸ì½”ë”©ì„ ì§€ì •í•¨" -#: utils/misc/guc.c:3007 +#: utils/misc/guc.c:3005 msgid "Controls information prefixed to each log line." msgstr "ê° ë¡œê·¸ 줄 ì•žì— ì¶”ê°€í•  정보를 제어합니다." -#: utils/misc/guc.c:3008 +#: utils/misc/guc.c:3006 msgid "If blank, no prefix is used." msgstr "비워 ë‘ë©´ ì ‘ë‘사가 사용ë˜ì§€ 않습니다." -#: utils/misc/guc.c:3017 +#: utils/misc/guc.c:3015 msgid "Sets the time zone to use in log messages." msgstr "로그 ë©”ì‹œì§€ì— ì‚¬ìš©í•  표준 시간대를 설정합니다." -#: utils/misc/guc.c:3027 +#: utils/misc/guc.c:3025 msgid "Sets the display format for date and time values." msgstr "날짜와 시간 ê°’ì„ ë‚˜íƒ€ë‚´ëŠ” ëª¨ì–‘ì„ ì§€ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3028 +#: utils/misc/guc.c:3026 msgid "Also controls interpretation of ambiguous date inputs." msgstr "ë˜í•œ 모호한 날짜 ìž…ë ¥ì˜ í•´ì„ì„ ì œì–´í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3039 +#: utils/misc/guc.c:3037 msgid "Sets the default tablespace to create tables and indexes in." msgstr "í…Œì´ë¸” ë° ì¸ë±ìŠ¤ë¥¼ 만들 기본 í…Œì´ë¸”스페ì´ìŠ¤ë¥¼ 설정합니다." -#: utils/misc/guc.c:3040 +#: utils/misc/guc.c:3038 msgid "An empty string selects the database's default tablespace." msgstr "빈 문ìžì—´ì„ 지정하면 ë°ì´í„°ë² ì´ìŠ¤ì˜ 기본 í…Œì´ë¸”스페ì´ìŠ¤ê°€ ì„ íƒë©ë‹ˆë‹¤." -#: utils/misc/guc.c:3050 +#: utils/misc/guc.c:3048 msgid "Sets the tablespace(s) to use for temporary tables and sort files." msgstr "ìž„ì‹œ í…Œì´ë¸” ë° ì •ë ¬ 파ì¼ì— 사용할 í…Œì´ë¸”스페ì´ìŠ¤ë¥¼ 설정합니다." -#: utils/misc/guc.c:3061 +#: utils/misc/guc.c:3059 msgid "Sets the path for dynamically loadable modules." msgstr "ë™ì ìœ¼ë¡œ 불러올 수 있는 ëª¨ë“ˆë“¤ì´ ìžˆëŠ” 경로를 지정함." -#: utils/misc/guc.c:3062 +#: utils/misc/guc.c:3060 msgid "" "If a dynamically loadable module needs to be opened and the specified name " "does not have a directory component (i.e., the name does not contain a " "slash), the system will search this path for the specified file." msgstr "" -"ë™ì ìœ¼ë¡œ 로드 가능한 ëª¨ë“ˆì„ ì—´ì–´ì•¼ í•˜ëŠ”ë° ì§€ì •í•œ ì´ë¦„ì— ë””ë ‰í„°ë¦¬ 구" -"성 요소가 없는 경우(즉, ì´ë¦„ì— ìŠ¬ëž˜ì‹œê°€ ì—†ìŒ) ì‹œìŠ¤í…œì€ ì´ ê²½ë¡œì—ì„œ 지정" -"í•œ 파ì¼ì„ 검색합니다." +"ë™ì ìœ¼ë¡œ 로드 가능한 ëª¨ë“ˆì„ ì—´ì–´ì•¼ í•˜ëŠ”ë° ì§€ì •í•œ ì´ë¦„ì— ë””ë ‰í„°ë¦¬ 구성 ìš”" +"소가 없는 경우(즉, ì´ë¦„ì— ìŠ¬ëž˜ì‹œê°€ ì—†ìŒ) ì‹œìŠ¤í…œì€ ì´ ê²½ë¡œì—ì„œ 지정한 파ì¼ì„ " +"검색합니다." -#: utils/misc/guc.c:3075 +#: utils/misc/guc.c:3073 msgid "Sets the location of the Kerberos server key file." msgstr "Kerberos 서버 키 파ì¼ì˜ 위치를 지정함." -#: utils/misc/guc.c:3086 +#: utils/misc/guc.c:3084 msgid "Sets the Bonjour service name." msgstr "Bonjour 서비스 ì´ë¦„ì„ ì§€ì •" -#: utils/misc/guc.c:3098 +#: utils/misc/guc.c:3096 msgid "Shows the collation order locale." msgstr "ë°ì´í„° ì •ë ¬ 순서 로케ì¼ì„ 표시합니다." -#: utils/misc/guc.c:3109 +#: utils/misc/guc.c:3107 msgid "Shows the character classification and case conversion locale." msgstr "ë¬¸ìž ë¶„ë¥˜ ë° ëŒ€/ì†Œë¬¸ìž ë³€í™˜ 로케ì¼ì„ 표시합니다." -#: utils/misc/guc.c:3120 +#: utils/misc/guc.c:3118 msgid "Sets the language in which messages are displayed." msgstr "보여질 메시지로 사용할 언어 지정." -#: utils/misc/guc.c:3130 +#: utils/misc/guc.c:3128 msgid "Sets the locale for formatting monetary amounts." msgstr "통화금액 표현 ì–‘ì‹ìœ¼ë¡œ 사용할 ë¡œì¼€ì¼ ì§€ì •." -#: utils/misc/guc.c:3140 +#: utils/misc/guc.c:3138 msgid "Sets the locale for formatting numbers." msgstr "ìˆ«ìž í‘œí˜„ ì–‘ì‹ìœ¼ë¡œ 사용할 ë¡œì¼€ì¼ ì§€ì •." -#: utils/misc/guc.c:3150 +#: utils/misc/guc.c:3148 msgid "Sets the locale for formatting date and time values." msgstr "날짜와 시간 ê°’ì„ í‘œí˜„í•  ì–‘ì‹ìœ¼ë¡œ 사용할 ë¡œì¼€ì¼ ì§€ì •." -#: utils/misc/guc.c:3160 +#: utils/misc/guc.c:3158 msgid "Lists shared libraries to preload into each backend." msgstr "ê°ê°ì˜ ë°±ì—”ë“œì— ë¯¸ë¦¬ 불러올 공유 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 지정합니다" -#: utils/misc/guc.c:3171 +#: utils/misc/guc.c:3169 msgid "Lists shared libraries to preload into server." msgstr "ì„œë²„ì— ë¯¸ë¦¬ 불러올 공유 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 지정합니다" -#: utils/misc/guc.c:3182 +#: utils/misc/guc.c:3180 msgid "Lists unprivileged shared libraries to preload into each backend." -msgstr "ê°ê°ì˜ ë°±ì—”ë“œì— ë¯¸ë¦¬ 불러올 접근제한 없는 공유 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 지정합니다" +msgstr "" +"ê°ê°ì˜ ë°±ì—”ë“œì— ë¯¸ë¦¬ 불러올 접근제한 없는 공유 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 지정합니다" -#: utils/misc/guc.c:3193 +#: utils/misc/guc.c:3191 msgid "Sets the schema search order for names that are not schema-qualified." msgstr "스키마로 한정ë˜ì§€ ì•Šì€ ì´ë¦„ì˜ ìŠ¤í‚¤ë§ˆ 검색 순서를 설정합니다." -#: utils/misc/guc.c:3205 +#: utils/misc/guc.c:3203 msgid "Sets the server (database) character set encoding." msgstr "서버 ë¬¸ìž ì½”ë“œ 세트 ì¸ì½”딩 지정." -#: utils/misc/guc.c:3217 +#: utils/misc/guc.c:3215 msgid "Shows the server version." msgstr "서버 버전 ë³´ìž„." -#: utils/misc/guc.c:3229 +#: utils/misc/guc.c:3227 msgid "Sets the current role." msgstr "현재 ë¡¤ì„ ì§€ì •" -#: utils/misc/guc.c:3241 +#: utils/misc/guc.c:3239 msgid "Sets the session user name." msgstr "세션 ì‚¬ìš©ìž ì´ë¦„ 지정." -#: utils/misc/guc.c:3252 +#: utils/misc/guc.c:3250 msgid "Sets the destination for server log output." msgstr "서버 로그 ì¶œë ¥ì„ ìœ„í•œ 대ìƒì„ 지정합니다." -#: utils/misc/guc.c:3253 +#: utils/misc/guc.c:3251 msgid "" "Valid values are combinations of \"stderr\", \"syslog\", \"csvlog\", and " "\"eventlog\", depending on the platform." msgstr "" -"유효한 ê°’ì€ í”Œëž«í¼ì— ë”°ë¼ \"stderr\", \"syslog\", \"csvlog\" ë° " -"\"eventlog\"ì˜ ì¡°í•©ìž…ë‹ˆë‹¤." +"유효한 ê°’ì€ í”Œëž«í¼ì— ë”°ë¼ \"stderr\", \"syslog\", \"csvlog\" ë° \"eventlog" +"\"ì˜ ì¡°í•©ìž…ë‹ˆë‹¤." -#: utils/misc/guc.c:3264 +#: utils/misc/guc.c:3262 msgid "Sets the destination directory for log files." msgstr "로그 파ì¼ì˜ ëŒ€ìƒ ë””ë ‰í„°ë¦¬ë¥¼ 설정합니다." -#: utils/misc/guc.c:3265 +#: utils/misc/guc.c:3263 msgid "Can be specified as relative to the data directory or as absolute path." msgstr "ë°ì´í„° ë””ë ‰í„°ë¦¬ì˜ ìƒëŒ€ 경로 ë˜ëŠ” 절대 경로로 지정할 수 있습니다." -#: utils/misc/guc.c:3275 +#: utils/misc/guc.c:3273 msgid "Sets the file name pattern for log files." msgstr "로그 파ì¼ì˜ íŒŒì¼ ì´ë¦„ íŒ¨í„´ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3286 +#: utils/misc/guc.c:3284 msgid "Sets the program name used to identify PostgreSQL messages in syslog." msgstr "syslogì—ì„œ 구분할 PostgreSQL ë©”ì‹œì§€ì— ì‚¬ìš©ë  í”„ë¡œê·¸ëž¨ ì´ë¦„ì„ ì§€ì •." -#: utils/misc/guc.c:3297 +#: utils/misc/guc.c:3295 msgid "" "Sets the application name used to identify PostgreSQL messages in the event " "log." -msgstr "ì´ë²¤íŠ¸ 로그ì—ì„œ PostgreSQL 메시지 ì‹ë³„ìžë¡œ 사용할 ì‘용프로그램 ì´ë¦„ 지정" +msgstr "" +"ì´ë²¤íŠ¸ 로그ì—ì„œ PostgreSQL 메시지 ì‹ë³„ìžë¡œ 사용할 ì‘용프로그램 ì´ë¦„ 지정" -#: utils/misc/guc.c:3308 +#: utils/misc/guc.c:3306 msgid "Sets the time zone for displaying and interpreting time stamps." msgstr "시간대(time zone)를 지정함." -#: utils/misc/guc.c:3318 +#: utils/misc/guc.c:3316 msgid "Selects a file of time zone abbreviations." msgstr "표준 시간대 약어 파ì¼ì„ ì„ íƒí•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3328 +#: utils/misc/guc.c:3326 msgid "Sets the current transaction's isolation level." msgstr "현재 트랜잭션 ë…립성 수준(isolation level)ì„ ì§€ì •í•¨." -#: utils/misc/guc.c:3339 +#: utils/misc/guc.c:3337 msgid "Sets the owning group of the Unix-domain socket." msgstr "유닉스 ë„ë©”ì¸ ì†Œì¼“ì˜ ì†Œìœ ì£¼ë¥¼ 지정" -#: utils/misc/guc.c:3340 +#: utils/misc/guc.c:3338 msgid "" "The owning user of the socket is always the user that starts the server." msgstr "소켓 소유ìžëŠ” í•­ìƒ ì„œë²„ë¥¼ 시작하는 사용ìžìž…니다." -#: utils/misc/guc.c:3350 +#: utils/misc/guc.c:3348 msgid "Sets the directories where Unix-domain sockets will be created." msgstr "유닉스 ë„ë©”ì¸ ì†Œì¼“ì„ ë§Œë“¤ 디렉터리를 지정합니다." -#: utils/misc/guc.c:3365 +#: utils/misc/guc.c:3363 msgid "Sets the host name or IP address(es) to listen to." msgstr "서비스할 호스트ì´ë¦„ì´ë‚˜, IP를 지정함." -#: utils/misc/guc.c:3380 +#: utils/misc/guc.c:3378 msgid "Sets the server's data directory." msgstr "ì„œë²„ì˜ ë°ì´í„° 디렉터리 위치를 지정합니다." -#: utils/misc/guc.c:3391 +#: utils/misc/guc.c:3389 msgid "Sets the server's main configuration file." msgstr "ì„œë²„ì˜ ê¸°ë³¸ 환경설정 íŒŒì¼ ê²½ë¡œë¥¼ 지정합니다." -#: utils/misc/guc.c:3402 +#: utils/misc/guc.c:3400 msgid "Sets the server's \"hba\" configuration file." msgstr "ì„œë²„ì˜ \"hba\" 구성 파ì¼ì„ 설정합니다." -#: utils/misc/guc.c:3413 +#: utils/misc/guc.c:3411 msgid "Sets the server's \"ident\" configuration file." msgstr "ì„œë²„ì˜ \"ident\" 구성 파ì¼ì„ 설정합니다." -#: utils/misc/guc.c:3424 +#: utils/misc/guc.c:3422 msgid "Writes the postmaster PID to the specified file." msgstr "postmaster PIDê°€ 기ë¡ëœ 파ì¼ì˜ 경로를 지정합니다." -#: utils/misc/guc.c:3435 +#: utils/misc/guc.c:3433 msgid "Location of the SSL server certificate file." msgstr "서버 ì¸ì¦ì„œ íŒŒì¼ ìœ„ì¹˜ë¥¼ 지정함" -#: utils/misc/guc.c:3445 +#: utils/misc/guc.c:3443 msgid "Location of the SSL server private key file." msgstr "SSL 서버 ê°œì¸ í‚¤ 파ì¼ì˜ 위치를 지정함." -#: utils/misc/guc.c:3455 +#: utils/misc/guc.c:3453 msgid "Location of the SSL certificate authority file." msgstr "" -#: utils/misc/guc.c:3465 +#: utils/misc/guc.c:3463 msgid "Location of the SSL certificate revocation list file." msgstr "SSL ì¸ì¦ì„œ 파기 ëª©ë¡ íŒŒì¼ì˜ 위치" -#: utils/misc/guc.c:3475 +#: utils/misc/guc.c:3473 msgid "Writes temporary statistics files to the specified directory." msgstr "지정한 ë””ë ‰í„°ë¦¬ì— ìž„ì‹œ 통계 파ì¼ì„ ì”니다." -#: utils/misc/guc.c:3486 +#: utils/misc/guc.c:3484 msgid "" "Number of synchronous standbys and list of names of potential synchronous " "ones." msgstr "" -#: utils/misc/guc.c:3497 +#: utils/misc/guc.c:3495 msgid "Sets default text search configuration." msgstr "기본 í…스트 검색 êµ¬ì„±ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3507 +#: utils/misc/guc.c:3505 msgid "Sets the list of allowed SSL ciphers." msgstr "허용ë˜ëŠ” SSL 암호 목ë¡ì„ 설정합니다." -#: utils/misc/guc.c:3522 +#: utils/misc/guc.c:3520 msgid "Sets the curve to use for ECDH." msgstr "ECDHì— ì‚¬ìš©í•  curve 설정" -#: utils/misc/guc.c:3537 +#: utils/misc/guc.c:3535 msgid "Sets the application name to be reported in statistics and logs." msgstr "" -#: utils/misc/guc.c:3548 +#: utils/misc/guc.c:3546 msgid "Sets the name of the cluster, which is included in the process title." msgstr "" -#: utils/misc/guc.c:3568 +#: utils/misc/guc.c:3566 msgid "Sets whether \"\\'\" is allowed in string literals." msgstr "문ìžì—´ì—ì„œ \"\\'\" ë¬¸ìž ì‚¬ìš©ì„ í—ˆìš©í•  것ì¸ì§€ë¥¼ 정하세요" -#: utils/misc/guc.c:3578 +#: utils/misc/guc.c:3576 msgid "Sets the output format for bytea." msgstr "bytea ê°’ì˜ í‘œì‹œ 형ì‹ì„ 설정합니다." -#: utils/misc/guc.c:3588 +#: utils/misc/guc.c:3586 msgid "Sets the message levels that are sent to the client." msgstr "í´ë¼ì´ì–¸íŠ¸ ì¸¡ì— ë³´ì—¬ì§ˆ 메시지 ìˆ˜ì¤€ì„ ì§€ì •í•¨." -#: utils/misc/guc.c:3589 utils/misc/guc.c:3642 utils/misc/guc.c:3653 -#: utils/misc/guc.c:3719 +#: utils/misc/guc.c:3587 utils/misc/guc.c:3640 utils/misc/guc.c:3651 +#: utils/misc/guc.c:3717 msgid "" "Each level includes all the levels that follow it. The later the level, the " "fewer messages are sent." @@ -23853,118 +23942,120 @@ msgstr "" "ê° ìˆ˜ì¤€ì—는 ì´ ìˆ˜ì¤€ ë’¤ì— ìžˆëŠ” 모든 ìˆ˜ì¤€ì´ í¬í•¨ë©ë‹ˆë‹¤. ìˆ˜ì¤€ì´ ë’¤ì— ìžˆì„수" "ë¡ ì „ì†¡ë˜ëŠ” 메시지 수가 ì ìŠµë‹ˆë‹¤." -#: utils/misc/guc.c:3599 +#: utils/misc/guc.c:3597 msgid "Enables the planner to use constraints to optimize queries." msgstr "실행계íšê¸°ê°€ 쿼리 최ì í™” ìž‘ì—…ì—ì„œ 제약 ì¡°ê±´ì„ ì‚¬ìš©í•˜ë„ë¡ í•¨" -#: utils/misc/guc.c:3600 +#: utils/misc/guc.c:3598 msgid "" "Table scans will be skipped if their constraints guarantee that no rows " "match the query." msgstr "" -"제약 ì¡°ê±´ì— ì˜í•´ 쿼리와 ì¼ì¹˜í•˜ëŠ” í–‰ì´ ì—†ëŠ” 경우 í…Œì´ë¸” ìŠ¤ìº”ì„ ê±´ë„ˆ" -"ëœë‹ˆë‹¤." +"제약 ì¡°ê±´ì— ì˜í•´ 쿼리와 ì¼ì¹˜í•˜ëŠ” í–‰ì´ ì—†ëŠ” 경우 í…Œì´ë¸” ìŠ¤ìº”ì„ ê±´ë„ˆëœë‹ˆ" +"다." -#: utils/misc/guc.c:3610 +#: utils/misc/guc.c:3608 msgid "Sets the transaction isolation level of each new transaction." msgstr "ê° ìƒˆ íŠ¸ëžœìž­ì…˜ì˜ íŠ¸ëžœìž­ì…˜ 격리 ìˆ˜ì¤€ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3620 +#: utils/misc/guc.c:3618 msgid "Sets the display format for interval values." msgstr "간격 ê°’ì˜ í‘œì‹œ 형ì‹ì„ 설정합니다." -#: utils/misc/guc.c:3631 +#: utils/misc/guc.c:3629 msgid "Sets the verbosity of logged messages." msgstr "기ë¡ë˜ëŠ” ë©”ì‹œì§€ì˜ ìƒì„¸ ì •ë„를 지정합니다." -#: utils/misc/guc.c:3641 +#: utils/misc/guc.c:3639 msgid "Sets the message levels that are logged." msgstr "서버 ë¡œê·¸ì— ê¸°ë¡ë  메시지 ìˆ˜ì¤€ì„ ì§€ì •í•¨." -#: utils/misc/guc.c:3652 +#: utils/misc/guc.c:3650 msgid "" "Causes all statements generating error at or above this level to be logged." -msgstr "오류가 있는 모든 쿼리문ì´ë‚˜ 지정한 로그 레벨 ì´ìƒì˜ ì¿¼ë¦¬ë¬¸ì„ ë¡œê·¸ë¡œ 남김" +msgstr "" +"오류가 있는 모든 쿼리문ì´ë‚˜ 지정한 로그 레벨 ì´ìƒì˜ ì¿¼ë¦¬ë¬¸ì„ ë¡œê·¸ë¡œ 남김" -#: utils/misc/guc.c:3663 +#: utils/misc/guc.c:3661 msgid "Sets the type of statements logged." msgstr "ì„œë²„ë¡œê·¸ì— ê¸°ë¡ë  구문 종류를 지정합니다." -#: utils/misc/guc.c:3673 +#: utils/misc/guc.c:3671 msgid "Sets the syslog \"facility\" to be used when syslog enabled." msgstr "syslog ê¸°ëŠ¥ì„ ì‚¬ìš©í•  ë•Œ, 사용할 syslog \"facility\" ê°’ì„ ì§€ì •." -#: utils/misc/guc.c:3688 +#: utils/misc/guc.c:3686 msgid "Sets the session's behavior for triggers and rewrite rules." msgstr "트리거 ë° ë‹¤ì‹œ 쓰기 ê·œì¹™ì— ëŒ€í•œ ì„¸ì…˜ì˜ ë™ìž‘ì„ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3698 +#: utils/misc/guc.c:3696 msgid "Sets the current transaction's synchronization level." msgstr "현재 트랜잭션 격리 수준(isolation level)ì„ ì§€ì •í•¨." -#: utils/misc/guc.c:3708 +#: utils/misc/guc.c:3706 msgid "Allows archiving of WAL files using archive_command." msgstr "archive_command를 사용하여 WAL 파ì¼ì„ ë”°ë¡œ 보관하ë„ë¡ ì„¤ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3718 +#: utils/misc/guc.c:3716 msgid "Enables logging of recovery-related debugging information." msgstr "복구 ìž‘ì—…ê³¼ ê´€ë ¨ëœ ë””ë²„ê¹… 정보를 기ë¡í•˜ë„ë¡ í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3734 +#: utils/misc/guc.c:3732 msgid "Collects function-level statistics on database activity." msgstr "ë°ì´í„°ë² ì´ìŠ¤ 활ë™ì— 대한 함수 수준 통계를 수집합니다." -#: utils/misc/guc.c:3744 +#: utils/misc/guc.c:3742 msgid "Set the level of information written to the WAL." msgstr "WALì— ì €ìž¥í•  ë‚´ìš© ìˆ˜ì¤€ì„ ì§€ì •í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3754 +#: utils/misc/guc.c:3752 msgid "Selects the dynamic shared memory implementation used." msgstr "사용할 ë™ì  공유 메모리 관리방ì‹ì„ ì„ íƒí•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3764 +#: utils/misc/guc.c:3762 msgid "Selects the method used for forcing WAL updates to disk." msgstr "디스í¬ì— 대한 ê°•ì œ WAL ì—…ë°ì´íŠ¸ì— 사용ë˜ëŠ” ë°©ë²•ì„ ì„ íƒí•©ë‹ˆë‹¤." -#: utils/misc/guc.c:3774 +#: utils/misc/guc.c:3772 msgid "Sets how binary values are to be encoded in XML." msgstr "XMLì—ì„œ ë°”ì´ë„ˆë¦¬ ê°’ì´ ì¸ì½”딩ë˜ëŠ” ë°©ì‹ì„ 설정합니다." -#: utils/misc/guc.c:3784 +#: utils/misc/guc.c:3782 msgid "" "Sets whether XML data in implicit parsing and serialization operations is to " "be considered as documents or content fragments." msgstr "" -"ì•”ì‹œì  êµ¬ë¬¸ ë¶„ì„ ë° ì§ë ¬í™” ìž‘ì—…ì˜ XML ë°ì´í„°ë¥¼ 문서 ë˜ëŠ” ë‚´ìš© ì¡°ê°ìœ¼ë¡œ " -"간주할지 여부를 설정합니다." +"ì•”ì‹œì  êµ¬ë¬¸ ë¶„ì„ ë° ì§ë ¬í™” ìž‘ì—…ì˜ XML ë°ì´í„°ë¥¼ 문서 ë˜ëŠ” ë‚´ìš© ì¡°ê°ìœ¼ë¡œ 간주할" +"지 여부를 설정합니다." -#: utils/misc/guc.c:3795 +#: utils/misc/guc.c:3793 msgid "Use of huge pages on Linux." msgstr "리눅스 huge 페ì´ì§€ 사용 여부" -#: utils/misc/guc.c:3805 +#: utils/misc/guc.c:3803 msgid "Forces use of parallel query facilities." msgstr "병렬 쿼리 ê¸°ëŠ¥ì„ í™œì„±í™”" -#: utils/misc/guc.c:3806 +#: utils/misc/guc.c:3804 msgid "" "If possible, run query using a parallel worker and with parallel " "restrictions." msgstr "" -#: utils/misc/guc.c:4606 +#: utils/misc/guc.c:4604 #, c-format msgid "%s: could not access directory \"%s\": %s\n" msgstr "%s: \"%s\" ë””ë ‰í„°ë¦¬ì— ì•¡ì„¸ìŠ¤í•  수 ì—†ìŒ: %s\n" -#: utils/misc/guc.c:4611 +#: utils/misc/guc.c:4609 #, c-format msgid "" "Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n" msgstr "" -"initdb 명령ì´ë‚˜, pg_basebackup 명령으로 PostgreSQL ë°ì´í„° 디렉토리를 초기화 하세요.\n" +"initdb 명령ì´ë‚˜, pg_basebackup 명령으로 PostgreSQL ë°ì´í„° 디렉토리를 초기화 " +"하세요.\n" -#: utils/misc/guc.c:4631 +#: utils/misc/guc.c:4629 #, c-format msgid "" "%s does not know where to find the server configuration file.\n" @@ -23976,12 +24067,12 @@ msgstr "" "PGDATA ì´ë¦„ì˜ í™˜ê²½ 변수를 만들고 ê·¸ 값으로 해당 디렉터리를 지정한 ë’¤,\n" "ì´ í”„ë¡œê·¸ëž¨ì„ ë‹¤ì‹œ 실행해 보십시오.\n" -#: utils/misc/guc.c:4650 +#: utils/misc/guc.c:4648 #, c-format msgid "%s: could not access the server configuration file \"%s\": %s\n" msgstr "%s: \"%s\" 환경 설정 파ì¼ì„ 접근할 수 없습니다: %s\n" -#: utils/misc/guc.c:4676 +#: utils/misc/guc.c:4674 #, c-format msgid "" "%s does not know where to find the database system data.\n" @@ -23994,7 +24085,7 @@ msgstr "" "PGDATA ì´ë¦„ì˜ í™˜ê²½ 변수를 만들고 ê·¸ 값으로 해당 디렉터리를 지정한 ë’¤,\n" "ì´ í”„ë¡œê·¸ëž¨ì„ ë‹¤ì‹œ 실행해 보십시오.\n" -#: utils/misc/guc.c:4724 +#: utils/misc/guc.c:4722 #, c-format msgid "" "%s does not know where to find the \"hba\" configuration file.\n" @@ -24007,7 +24098,7 @@ msgstr "" "PGDATA ì´ë¦„ì˜ í™˜ê²½ 변수를 만들고 ê·¸ 값으로 해당 디렉터리를 지정한 ë’¤,\n" "ì´ í”„ë¡œê·¸ëž¨ì„ ë‹¤ì‹œ 실행해 보십시오.\n" -#: utils/misc/guc.c:4747 +#: utils/misc/guc.c:4745 #, c-format msgid "" "%s does not know where to find the \"ident\" configuration file.\n" @@ -24020,150 +24111,151 @@ msgstr "" "PGDATA ì´ë¦„ì˜ í™˜ê²½ 변수를 만들고 ê·¸ 값으로 해당 디렉터리를 지정한 ë’¤,\n" "ì´ í”„ë¡œê·¸ëž¨ì„ ë‹¤ì‹œ 실행해 보십시오.\n" -#: utils/misc/guc.c:5421 utils/misc/guc.c:5468 +#: utils/misc/guc.c:5419 utils/misc/guc.c:5466 msgid "Value exceeds integer range." msgstr "ê°’ì´ ì •ìˆ˜ 범위를 초과합니다." -#: utils/misc/guc.c:5691 +#: utils/misc/guc.c:5689 #, c-format msgid "parameter \"%s\" requires a numeric value" msgstr "\"%s\" 매개 ë³€ìˆ˜ì˜ ê°’ì€ ìˆ«ìží˜•ì´ì–´ì•¼í•©ë‹ˆë‹¤." -#: utils/misc/guc.c:5700 +#: utils/misc/guc.c:5698 #, c-format msgid "%g is outside the valid range for parameter \"%s\" (%g .. %g)" msgstr "" "%g ê°’ì€ \"%s\" 매개 ë³€ìˆ˜ì˜ ê°’ìœ¼ë¡œ 타당한 범위(%g .. %g)를 벗어났습니다." -#: utils/misc/guc.c:5853 utils/misc/guc.c:7196 +#: utils/misc/guc.c:5851 utils/misc/guc.c:7194 #, c-format msgid "cannot set parameters during a parallel operation" msgstr "병렬 ìž‘ì—… 중ì—는 매개 변수를 설정할 수 ì—†ìŒ" -#: utils/misc/guc.c:5860 utils/misc/guc.c:6611 utils/misc/guc.c:6663 -#: utils/misc/guc.c:7024 utils/misc/guc.c:7784 utils/misc/guc.c:7952 -#: utils/misc/guc.c:9617 +#: utils/misc/guc.c:5858 utils/misc/guc.c:6609 utils/misc/guc.c:6661 +#: utils/misc/guc.c:7022 utils/misc/guc.c:7782 utils/misc/guc.c:7950 +#: utils/misc/guc.c:9625 #, c-format msgid "unrecognized configuration parameter \"%s\"" msgstr "ì•Œ 수 없는 환경 매개 변수 ì´ë¦„: \"%s\"" -#: utils/misc/guc.c:5875 utils/misc/guc.c:7036 +#: utils/misc/guc.c:5873 utils/misc/guc.c:7034 #, c-format msgid "parameter \"%s\" cannot be changed" msgstr "\"%s\" 매개 변수는 ë³€ê²½ë  ìˆ˜ ì—†ìŒ" -#: utils/misc/guc.c:5898 utils/misc/guc.c:6091 utils/misc/guc.c:6181 -#: utils/misc/guc.c:6271 utils/misc/guc.c:6379 utils/misc/guc.c:6474 -#: guc-file.l:350 +#: utils/misc/guc.c:5896 utils/misc/guc.c:6089 utils/misc/guc.c:6179 +#: utils/misc/guc.c:6269 utils/misc/guc.c:6377 utils/misc/guc.c:6472 +#: guc-file.l:351 #, c-format msgid "parameter \"%s\" cannot be changed without restarting the server" msgstr "\"%s\" 매개 변수는 서버 재실행 ì—†ì´ ì§€ê¸ˆ 변경 ë  ìˆ˜ ì—†ìŒ" -#: utils/misc/guc.c:5908 +#: utils/misc/guc.c:5906 #, c-format msgid "parameter \"%s\" cannot be changed now" msgstr "\"%s\" 매개 변수는 지금 변경 ë  ìˆ˜ ì—†ìŒ" -#: utils/misc/guc.c:5926 utils/misc/guc.c:5972 utils/misc/guc.c:9633 +#: utils/misc/guc.c:5924 utils/misc/guc.c:5970 utils/misc/guc.c:9641 #, c-format msgid "permission denied to set parameter \"%s\"" msgstr "\"%s\" 매개 변수를 지정할 ê¶Œí•œì´ ì—†ìŠµë‹ˆë‹¤." -#: utils/misc/guc.c:5962 +#: utils/misc/guc.c:5960 #, c-format msgid "parameter \"%s\" cannot be set after connection start" msgstr "\"%s\" 매개 ë³€ìˆ˜ê°’ì€ ì—°ê²° 시작한 ë’¤ì—는 변경할 수 없습니다" -#: utils/misc/guc.c:6010 +#: utils/misc/guc.c:6008 #, c-format msgid "cannot set parameter \"%s\" within security-definer function" msgstr "보안 ì •ì˜ìž 함수 ë‚´ì—ì„œ \"%s\" 매개 변수를 설정할 수 ì—†ìŒ" -#: utils/misc/guc.c:6619 utils/misc/guc.c:6667 utils/misc/guc.c:7958 +#: utils/misc/guc.c:6617 utils/misc/guc.c:6665 utils/misc/guc.c:7956 #, c-format msgid "must be superuser to examine \"%s\"" msgstr "\"%s\" 검사를 위해서는 superuser여야합니다" -#: utils/misc/guc.c:6733 +#: utils/misc/guc.c:6731 #, c-format msgid "SET %s takes only one argument" msgstr "SET %s ëª…ë ¹ì€ í•˜ë‚˜ì˜ ê°’ë§Œ 지정해야합니다" -#: utils/misc/guc.c:6984 +#: utils/misc/guc.c:6982 #, c-format msgid "must be superuser to execute ALTER SYSTEM command" msgstr "슈í¼ìœ ì €ë§Œ ALTER SYSTEM ëª…ë ¹ì„ ì‹¤í–‰í•  수 있ìŒ" -#: utils/misc/guc.c:7069 +#: utils/misc/guc.c:7067 #, c-format msgid "parameter value for ALTER SYSTEM must not contain a newline" -msgstr "ALTER SYSTEM 명령으로 지정하는 매개 변수 ê°’ì—는 줄바꿈 문ìžê°€ 없어야 합니다" +msgstr "" +"ALTER SYSTEM 명령으로 지정하는 매개 변수 ê°’ì—는 줄바꿈 문ìžê°€ 없어야 합니다" -#: utils/misc/guc.c:7114 +#: utils/misc/guc.c:7112 #, c-format msgid "could not parse contents of file \"%s\"" msgstr "\"%s\" 파ì¼ì˜ ë‚´ìš©ì„ ë¶„ì„í•  수 ì—†ìŒ" -#: utils/misc/guc.c:7272 +#: utils/misc/guc.c:7270 #, c-format msgid "SET LOCAL TRANSACTION SNAPSHOT is not implemented" msgstr "SET LOCAL TRANSACTION SNAPSHOT ëª…ë ¹ì€ ì•„ì§ êµ¬í˜„ ë˜ì§€ 않았습니다" -#: utils/misc/guc.c:7357 +#: utils/misc/guc.c:7355 #, c-format msgid "SET requires parameter name" msgstr "SET ëª…ë ¹ì€ ë§¤ê°œ 변수 ì´ë¦„ì´ í•„ìš”í•©ë‹ˆë‹¤" -#: utils/misc/guc.c:7481 +#: utils/misc/guc.c:7479 #, c-format msgid "attempt to redefine parameter \"%s\"" msgstr "\"%s\" 매개 변수를 다시 ì •ì˜í•˜ë ¤ê³  함" -#: utils/misc/guc.c:9250 +#: utils/misc/guc.c:9258 #, c-format msgid "parameter \"%s\" could not be set" msgstr "\"%s\" 매개 변수는 설정할 수 ì—†ìŒ" -#: utils/misc/guc.c:9337 +#: utils/misc/guc.c:9345 #, c-format msgid "could not parse setting for parameter \"%s\"" msgstr "지정한 \"%s\" 매개 ë³€ìˆ˜ê°’ì˜ êµ¬ë¬¸ë¶„ì„ì„ ì‹¤íŒ¨í–ˆìŠµë‹ˆë‹¤." -#: utils/misc/guc.c:9695 utils/misc/guc.c:9729 +#: utils/misc/guc.c:9703 utils/misc/guc.c:9737 #, c-format msgid "invalid value for parameter \"%s\": %d" msgstr "ìž˜ëª»ëœ \"%s\" 매개 ë³€ìˆ˜ì˜ ê°’: %d" -#: utils/misc/guc.c:9763 +#: utils/misc/guc.c:9771 #, c-format msgid "invalid value for parameter \"%s\": %g" msgstr "ìž˜ëª»ëœ \"%s\" 매개 ë³€ìˆ˜ì˜ ê°’: %g" -#: utils/misc/guc.c:9953 +#: utils/misc/guc.c:9961 #, c-format msgid "" "\"temp_buffers\" cannot be changed after any temporary tables have been " "accessed in the session." msgstr "" -"해당 세션ì—ì„œ ì–´ë–¤ ìž„ì‹œ í…Œì´ë¸”ë„ ì‚¬ìš©í•˜ê³  있지 않아야 \"temp_buffers\" " -"ì„¤ì •ì„ ë³€ê²½í•  수 있습니다." +"해당 세션ì—ì„œ ì–´ë–¤ ìž„ì‹œ í…Œì´ë¸”ë„ ì‚¬ìš©í•˜ê³  있지 않아야 \"temp_buffers\" 설정" +"ì„ ë³€ê²½í•  수 있습니다." -#: utils/misc/guc.c:9965 +#: utils/misc/guc.c:9973 #, c-format msgid "Bonjour is not supported by this build" msgstr "Bonjour ê¸°ëŠ¥ì„ ëº€ 채로 서버가 만들어졌습니다." -#: utils/misc/guc.c:9978 +#: utils/misc/guc.c:9986 #, c-format msgid "SSL is not supported by this build" msgstr "SSL ì ‘ì† ê¸°ëŠ¥ì„ ëº€ 채로 서버가 만들어졌습니다." -#: utils/misc/guc.c:9990 +#: utils/misc/guc.c:9998 #, c-format msgid "Cannot enable parameter when \"log_statement_stats\" is true." msgstr "\"log_statement_stats\" ê°’ì´ true ì¼ ë•ŒëŠ” ì´ ê°’ì„ í™œì„±í™”í•  수 없습니다" -#: utils/misc/guc.c:10002 +#: utils/misc/guc.c:10010 #, c-format msgid "" "Cannot enable \"log_statement_stats\" when \"log_parser_stats\", " @@ -24194,8 +24286,8 @@ msgid "" "To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW " "LEVEL SECURITY." msgstr "" -"í…Œì´ë¸” 소유주를 위해 ì •ì±…ì„ ë¹„í™œì„±í•˜ë ¤ë©´, ALTER TABLE NO FORCE ROW " -"LEVEL SECURITY ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”" +"í…Œì´ë¸” 소유주를 위해 ì •ì±…ì„ ë¹„í™œì„±í•˜ë ¤ë©´, ALTER TABLE NO FORCE ROW LEVEL " +"SECURITY ëª…ë ¹ì„ ì‚¬ìš©í•˜ì„¸ìš”" #: utils/misc/timeout.c:388 #, c-format @@ -24208,15 +24300,15 @@ msgid "" "time zone abbreviation \"%s\" is too long (maximum %d characters) in time " "zone file \"%s\", line %d" msgstr "" -"\"%s\" 타임 ì¡´ ì´ë¦„ì´ ë„ˆë¬´ ê¹ë‹ˆë‹¤(최대 %dìž) (\"%s\" 타임 " -"ì¡´ 파ì¼ì˜ %d번째 ì¤„ì— ìžˆìŒ)." +"\"%s\" 타임 ì¡´ ì´ë¦„ì´ ë„ˆë¬´ ê¹ë‹ˆë‹¤(최대 %dìž) (\"%s\" 타임 ì¡´ 파ì¼ì˜ %d번째 줄" +"ì— ìžˆìŒ)." #: utils/misc/tzparser.c:73 #, c-format msgid "time zone offset %d is out of range in time zone file \"%s\", line %d" msgstr "" -"%d 타임 ì¡´ 오프셋 ê°’ì´ ë²”ìœ„ë¥¼ 벗어났습니다(\"%s\" 타임 ì¡´ 파ì¼ì˜ %d" -"번째 ì¤„ì— ìžˆìŒ)." +"%d 타임 ì¡´ 오프셋 ê°’ì´ ë²”ìœ„ë¥¼ 벗어났습니다(\"%s\" 타임 ì¡´ 파ì¼ì˜ %d번째 ì¤„ì— " +"있ìŒ)." #: utils/misc/tzparser.c:112 #, c-format @@ -24250,8 +24342,8 @@ msgid "" "Entry in time zone file \"%s\", line %d, conflicts with entry in file \"%s" "\", line %d." msgstr "" -"\"%s\" 타임 ì¡´ 파ì¼ì˜ %d번째 ì¤„ì— ìžˆëŠ” í•­ëª©ì´ \"%s\" 파ì¼ì˜ %d" -"번째 ì¤„ì— ìžˆëŠ” 항목과 충ëŒí•©ë‹ˆë‹¤." +"\"%s\" 타임 ì¡´ 파ì¼ì˜ %d번째 ì¤„ì— ìžˆëŠ” í•­ëª©ì´ \"%s\" 파ì¼ì˜ %d번째 ì¤„ì— ìžˆëŠ” " +"항목과 충ëŒí•©ë‹ˆë‹¤." #: utils/misc/tzparser.c:301 #, c-format @@ -24362,52 +24454,54 @@ msgstr "tuplestore ìž„ì‹œ 파ì¼ì„ ì½ì„ 수 ì—†ìŒ: %m" msgid "could not write to tuplestore temporary file: %m" msgstr "tuplestore ìž„ì‹œ 파ì¼ì„ 쓸 수 없습니다: %m" -#: utils/time/snapmgr.c:577 +#: utils/time/snapmgr.c:618 #, c-format msgid "The source transaction is not running anymore." msgstr "소스 íŠ¸ëžœìž­ì…˜ì´ ë” ì´ìƒ 실행중ì´ì§€ ì•ŠìŒ" -#: utils/time/snapmgr.c:1138 +#: utils/time/snapmgr.c:1190 #, c-format msgid "cannot export a snapshot from a subtransaction" msgstr "서브트랜잭션ì—ì„œ ìŠ¤ëƒ…ìƒ·ì„ ë‚´ë³´ë‚¼ 수 ì—†ìŒ" -#: utils/time/snapmgr.c:1287 utils/time/snapmgr.c:1292 -#: utils/time/snapmgr.c:1297 utils/time/snapmgr.c:1312 -#: utils/time/snapmgr.c:1317 utils/time/snapmgr.c:1322 -#: utils/time/snapmgr.c:1421 utils/time/snapmgr.c:1437 -#: utils/time/snapmgr.c:1462 +#: utils/time/snapmgr.c:1339 utils/time/snapmgr.c:1344 +#: utils/time/snapmgr.c:1349 utils/time/snapmgr.c:1364 +#: utils/time/snapmgr.c:1369 utils/time/snapmgr.c:1374 +#: utils/time/snapmgr.c:1473 utils/time/snapmgr.c:1489 +#: utils/time/snapmgr.c:1514 #, c-format msgid "invalid snapshot data in file \"%s\"" msgstr "\"%s\" 파ì¼ì— 유효하지 ì•Šì€ ìŠ¤ëƒ…ìƒ· ìžë£Œê°€ 있습니다" -#: utils/time/snapmgr.c:1359 +#: utils/time/snapmgr.c:1411 #, c-format msgid "SET TRANSACTION SNAPSHOT must be called before any query" msgstr "쿼리보다 먼저 SET TRANSACTION SNAPSHOP ëª…ë ¹ì„ í˜¸ì¶œí•´ì•¼ 함" -#: utils/time/snapmgr.c:1368 +#: utils/time/snapmgr.c:1420 #, c-format msgid "" "a snapshot-importing transaction must have isolation level SERIALIZABLE or " "REPEATABLE READ" msgstr "" -"스냅샷 가져오기 íŠ¸ëžœìž­ì…˜ì€ ê·¸ 격리 ìˆ˜ì¤€ì´ SERIALIZABLE ë˜ëŠ” REPEATABLE READ 여야 함" +"스냅샷 가져오기 íŠ¸ëžœìž­ì…˜ì€ ê·¸ 격리 ìˆ˜ì¤€ì´ SERIALIZABLE ë˜ëŠ” REPEATABLE READ " +"여야 함" -#: utils/time/snapmgr.c:1377 utils/time/snapmgr.c:1386 +#: utils/time/snapmgr.c:1429 utils/time/snapmgr.c:1438 #, c-format msgid "invalid snapshot identifier: \"%s\"" msgstr "ìž˜ëª»ëœ ìŠ¤ëƒ…ìƒ· ì‹ë³„ìž: \"%s\"" -#: utils/time/snapmgr.c:1475 +#: utils/time/snapmgr.c:1527 #, c-format msgid "" "a serializable transaction cannot import a snapshot from a non-serializable " "transaction" msgstr "" -"ì§ë ¬í™” 가능한 íŠ¸ëžœìž­ì…˜ì€ ì§ë ¬í™” 가능하지 ì•Šì€ íŠ¸ëžœìž­ì…˜ì—ì„œ ìŠ¤ëƒ…ìƒ·ì„ ê°€ì ¸ì˜¬ 수 ì—†ìŒ" +"ì§ë ¬í™” 가능한 íŠ¸ëžœìž­ì…˜ì€ ì§ë ¬í™” 가능하지 ì•Šì€ íŠ¸ëžœìž­ì…˜ì—ì„œ ìŠ¤ëƒ…ìƒ·ì„ ê°€ì ¸ì˜¬ " +"수 ì—†ìŒ" -#: utils/time/snapmgr.c:1479 +#: utils/time/snapmgr.c:1531 #, c-format msgid "" "a non-read-only serializable transaction cannot import a snapshot from a " @@ -24415,7 +24509,7 @@ msgid "" msgstr "" "ì½ê¸°-쓰기 ì§ë ¬í™”ëœ íŠ¸ëžœìž­ì…˜ì´ ì½ê¸° ì „ìš© íŠ¸ëžœìž­ì…˜ì˜ ìŠ¤ëƒ…ìƒ·ì„ ê°€ì ¸ì˜¬ 수 ì—†ìŒ" -#: utils/time/snapmgr.c:1494 +#: utils/time/snapmgr.c:1546 #, c-format msgid "cannot import a snapshot from a different database" msgstr "서로 다른 ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 대ìƒìœ¼ë¡œëŠ” ìŠ¤ëƒ…ìƒ·ì„ ê°€ì ¸ì˜¬ 수 ì—†ìŒ" @@ -24428,7 +24522,8 @@ msgstr "ì¸ì‹í•  수 없는 롤 옵션 \"%s\"" #: gram.y:1278 gram.y:1293 #, c-format msgid "CREATE SCHEMA IF NOT EXISTS cannot include schema elements" -msgstr "CREATE SCHEMA IF NOT EXISTS 구문ì—서는 스키마 ìš”ì†Œë“¤ì„ í¬í•¨í•  수 없습니다." +msgstr "" +"CREATE SCHEMA IF NOT EXISTS 구문ì—서는 스키마 ìš”ì†Œë“¤ì„ í¬í•¨í•  수 없습니다." #: gram.y:1438 #, c-format @@ -24551,188 +24646,188 @@ msgstr "OVERLAPS ì‹ì˜ ì˜¤ë¥¸ìª½ì— ìžˆëŠ” 매개 변수 수가 잘못ë¨" msgid "UNIQUE predicate is not yet implemented" msgstr "UNIQUE 술어는 ì•„ì§ êµ¬í˜„ë˜ì§€ 못했습니다" -#: gram.y:12296 +#: gram.y:12300 #, c-format msgid "cannot use multiple ORDER BY clauses with WITHIN GROUP" msgstr "WITHIN GROUP 구문 안ì—ì„œ ì¤‘ë³µëœ ORDER BY êµ¬ë¬¸ì€ í—ˆìš©í•˜ì§€ 않습니다" -#: gram.y:12301 +#: gram.y:12305 #, c-format msgid "cannot use DISTINCT with WITHIN GROUP" msgstr "DISTINCTê³¼ WITHIN GROUPì„ í•¨ê»˜ 쓸 수 없습니다" -#: gram.y:12306 +#: gram.y:12310 #, c-format msgid "cannot use VARIADIC with WITHIN GROUP" msgstr "VARIADICê³¼ WITHIN GROUPì„ í•¨ê»˜ 쓸 수 없습니다" -#: gram.y:12812 +#: gram.y:12816 #, c-format msgid "RANGE PRECEDING is only supported with UNBOUNDED" msgstr "RANGE PRECEDINGì€ UNBOUNDED와 함께 사용해야 합니다" -#: gram.y:12818 +#: gram.y:12822 #, c-format msgid "RANGE FOLLOWING is only supported with UNBOUNDED" msgstr "RANGE FOLLOWINGì€ UNBOUNDED와 함께 사용해야 합니다" -#: gram.y:12845 gram.y:12868 +#: gram.y:12849 gram.y:12872 #, c-format msgid "frame start cannot be UNBOUNDED FOLLOWING" msgstr "프레임 ì‹œìž‘ì€ UNBOUNDED FOLLOWINGì¼ ìˆ˜ ì—†ìŒ" -#: gram.y:12850 +#: gram.y:12854 #, c-format msgid "frame starting from following row cannot end with current row" msgstr "ë”°ë¼ì˜¤ëŠ” ë¡œìš°ì˜ í”„ë ˆìž„ ì‹œìž‘ì€ í˜„ìž¬ ë¡œìš°ì˜ ëì¼ ìˆ˜ 없습니다" -#: gram.y:12873 +#: gram.y:12877 #, c-format msgid "frame end cannot be UNBOUNDED PRECEDING" msgstr "프레임 ëì€ UNBOUNDED PRECEDINGì¼ ìˆ˜ ì—†ìŒ" -#: gram.y:12879 +#: gram.y:12883 #, c-format msgid "frame starting from current row cannot have preceding rows" msgstr "현재 ë¡œìš°ì˜ í”„ë ˆìž„ ì‹œìž‘ì€ ì„ í–‰í•˜ëŠ” 로우를 가질 수 없습니다" -#: gram.y:12886 +#: gram.y:12890 #, c-format msgid "frame starting from following row cannot have preceding rows" msgstr "ë”°ë¼ì˜¤ëŠ” ë¡œìš°ì˜ í”„ë ˆìž„ ì‹œìž‘ì€ ì„ í–‰í•˜ëŠ” 로우를 가질 수 없습니다" -#: gram.y:13551 +#: gram.y:13555 #, c-format msgid "type modifier cannot have parameter name" msgstr "ìžë£Œí˜• 한정ìžëŠ” 매개 변수 ì´ë¦„ì„ ì‚¬ìš©í•  수 ì—†ìŒ" -#: gram.y:13557 +#: gram.y:13561 #, c-format msgid "type modifier cannot have ORDER BY" msgstr "ìžë£Œí˜• 한정ìžëŠ” ORDER BY êµ¬ë¬¸ì„ ì‚¬ìš©í•  수 ì—†ìŒ" -#: gram.y:13621 gram.y:13627 +#: gram.y:13625 gram.y:13631 #, c-format msgid "%s cannot be used as a role name here" msgstr "%s ì´ë¦„ì€ ì—¬ê¸°ì„œ 롤 ì´ë¦„으로 사용할 수 ì—†ìŒ" -#: gram.y:14249 gram.y:14438 +#: gram.y:14253 gram.y:14442 msgid "improper use of \"*\"" msgstr "\"*\" ì‚¬ìš©ì´ ìž˜ëª»ë¨" -#: gram.y:14502 +#: gram.y:14506 #, c-format msgid "" "an ordered-set aggregate with a VARIADIC direct argument must have one " "VARIADIC aggregated argument of the same data type" msgstr "" -#: gram.y:14539 +#: gram.y:14543 #, c-format msgid "multiple ORDER BY clauses not allowed" msgstr "ì¤‘ë³µëœ ORDER BY êµ¬ë¬¸ì€ í—ˆìš©í•˜ì§€ 않습니다" -#: gram.y:14550 +#: gram.y:14554 #, c-format msgid "multiple OFFSET clauses not allowed" msgstr "ì¤‘ë³µëœ OFFSET êµ¬ë¬¸ì€ í—ˆìš©í•˜ì§€ 않습니다" -#: gram.y:14559 +#: gram.y:14563 #, c-format msgid "multiple LIMIT clauses not allowed" msgstr "ì¤‘ë³µëœ LIMIT êµ¬ë¬¸ì€ í—ˆìš©í•˜ì§€ 않습니다" -#: gram.y:14568 +#: gram.y:14572 #, c-format msgid "multiple WITH clauses not allowed" msgstr "ì¤‘ë³µëœ WITH ì ˆì€ í—ˆìš©í•˜ì§€ ì•ŠìŒ" -#: gram.y:14760 +#: gram.y:14764 #, c-format msgid "OUT and INOUT arguments aren't allowed in TABLE functions" msgstr "OUT ë° INOUT ì¸ìžëŠ” TABLE í•¨ìˆ˜ì— ì‚¬ìš©í•  수 ì—†ìŒ" -#: gram.y:14861 +#: gram.y:14865 #, c-format msgid "multiple COLLATE clauses not allowed" msgstr "ì¤‘ë³µëœ COLLATE êµ¬ë¬¸ì€ í—ˆìš©í•˜ì§€ 않습니다" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14899 gram.y:14912 +#: gram.y:14903 gram.y:14916 #, c-format msgid "%s constraints cannot be marked DEFERRABLE" msgstr "%s 제약조건ì—는 DEFERRABLE ì˜µì…˜ì„ ì“¸ 수 ì—†ìŒ" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14925 +#: gram.y:14929 #, c-format msgid "%s constraints cannot be marked NOT VALID" msgstr "%s 제약조건ì—는 NOT VALID ì˜µì…˜ì„ ì“¸ 수 ì—†ìŒ" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14938 +#: gram.y:14942 #, c-format msgid "%s constraints cannot be marked NO INHERIT" msgstr "%s 제약조건ì—는 NO INHERIT ì˜µì…˜ì„ ì“¸ 수 ì—†ìŒ" -#: guc-file.l:313 +#: guc-file.l:314 #, c-format msgid "unrecognized configuration parameter \"%s\" in file \"%s\" line %u" msgstr "ì•Œ 수 없는 환경 매개 변수 ì´ë¦„: \"%s\", 해당 파ì¼: \"%s\", 줄번호: %u" -#: guc-file.l:386 +#: guc-file.l:387 #, c-format msgid "parameter \"%s\" removed from configuration file, reset to default" msgstr "환경설정 파ì¼ì— \"%s\" 매개 변수가 ë¹ ì¡ŒìŒ, ì´ˆê¸°ê°’ì„ ì‚¬ìš©í•¨" -#: guc-file.l:452 +#: guc-file.l:453 #, c-format msgid "parameter \"%s\" changed to \"%s\"" -msgstr "\"%s\" 매개 변수 ê°’ì„ \"%s\"(으)ë¡œ 바꿀 수 ì—†ìŒ" +msgstr "\"%s\" 매개 변수 ê°’ì„ \"%s\"(으)ë¡œ 바꿨ìŒ" -#: guc-file.l:494 +#: guc-file.l:495 #, c-format msgid "configuration file \"%s\" contains errors" msgstr "\"%s\" 환경 설정파ì¼ì— 오류가 있ìŒ" -#: guc-file.l:499 +#: guc-file.l:500 #, c-format msgid "" "configuration file \"%s\" contains errors; unaffected changes were applied" msgstr "\"%s\" 환경 설정 파ì¼ì— 오류가 있어 새로 ë³€ê²½ë  ì„¤ì •ì´ ì—†ìŠµë‹ˆë‹¤" -#: guc-file.l:504 +#: guc-file.l:505 #, c-format msgid "configuration file \"%s\" contains errors; no changes were applied" msgstr "\"%s\" 환경 설정 파ì¼ì— 오류가 있어 아무 ì„¤ì •ë„ ë°˜ì˜ë˜ì§€ 않았습니다." -#: guc-file.l:577 +#: guc-file.l:578 #, c-format msgid "" "could not open configuration file \"%s\": maximum nesting depth exceeded" msgstr "설정 íŒŒì¼ \"%s\"ì„ ì—´ 수 없습니다: 최대 디렉터리 깊ì´ë¥¼ 초과했ìŒ" -#: guc-file.l:604 +#: guc-file.l:605 #, c-format msgid "skipping missing configuration file \"%s\"" msgstr "\"%s\" 환경 설정파ì¼ì´ 없으나 건너뜀" -#: guc-file.l:858 +#: guc-file.l:859 #, c-format msgid "syntax error in file \"%s\" line %u, near end of line" msgstr "\"%s\" íŒŒì¼ %u 줄 ë부분ì—ì„œ 구문 오류 있ìŒ" -#: guc-file.l:868 +#: guc-file.l:869 #, c-format msgid "syntax error in file \"%s\" line %u, near token \"%s\"" msgstr "\"%s\" íŒŒì¼ %u 줄ì—ì„œ 구문 오류 있ìŒ, \"%s\" í† í° ë¶€ê·¼" -#: guc-file.l:888 +#: guc-file.l:889 #, c-format msgid "too many syntax errors found, abandoning file \"%s\"" msgstr "구문 오류가 너무 많습니다. \"%s\" 파ì¼ì„ 무시합니다" -#: guc-file.l:940 +#: guc-file.l:941 #, c-format msgid "could not open configuration directory \"%s\": %m" msgstr "\"%s\" 환경 설정 디렉터리를 ì—´ 수 없습니다: %m" @@ -24779,15 +24874,15 @@ msgid "" "String constants with Unicode escapes cannot be used when " "standard_conforming_strings is off." msgstr "" -"standard_conforming_strings = off ì¸ ê²½ìš° 문ìžì—´ ìƒìˆ˜ 표기ì—ì„œ " -"유니코드 ì´ìŠ¤ì¼€ì´í”„를 사용할 수 없습니다." +"standard_conforming_strings = off ì¸ ê²½ìš° 문ìžì—´ ìƒìˆ˜ 표기ì—ì„œ 유니코드 ì´ìŠ¤" +"ì¼€ì´í”„를 사용할 수 없습니다." #: scan.l:579 scan.l:778 msgid "invalid Unicode escape character" msgstr "ìž˜ëª»ëœ ìœ ë‹ˆì½”ë“œ ì´ìŠ¤ì¼€ì´í”„ 문ìž" -#: scan.l:605 scan.l:613 scan.l:621 scan.l:622 scan.l:623 scan.l:1337 -#: scan.l:1364 scan.l:1368 scan.l:1406 scan.l:1410 scan.l:1432 +#: scan.l:605 scan.l:613 scan.l:621 scan.l:622 scan.l:623 scan.l:1338 +#: scan.l:1365 scan.l:1369 scan.l:1407 scan.l:1411 scan.l:1433 scan.l:1443 msgid "invalid Unicode surrogate pair" msgstr "ìž˜ëª»ëœ ìœ ë‹ˆì½”ë“œ 대리 ìŒ" @@ -24832,57 +24927,56 @@ msgid "operator too long" msgstr "ì—°ì‚°ìžê°€ 너무 ê¹ë‹ˆë‹¤." #. translator: %s is typically the translation of "syntax error" -#: scan.l:1077 +#: scan.l:1078 #, c-format msgid "%s at end of input" msgstr "%s, ìž…ë ¥ ë부분" #. translator: first %s is typically the translation of "syntax error" -#: scan.l:1085 +#: scan.l:1086 #, c-format msgid "%s at or near \"%s\"" msgstr "%s, \"%s\" 부근" -#: scan.l:1251 scan.l:1283 +#: scan.l:1252 scan.l:1284 msgid "" "Unicode escape values cannot be used for code point values above 007F when " "the server encoding is not UTF8" msgstr "" -"서버 ì¸ì½”ë”©ì´ UTF8ì´ ì•„ë‹Œ 경우 007F보다 í° ì½”ë“œ ì§€ì  ê°’ì—는 유니코드 ì´" -"스케ì´í”„ ê°’ì„ ì‚¬ìš©í•  수 ì—†ìŒ" +"서버 ì¸ì½”ë”©ì´ UTF8ì´ ì•„ë‹Œ 경우 007F보다 í° ì½”ë“œ ì§€ì  ê°’ì—는 유니코드 ì´ìŠ¤ì¼€ì´" +"프 ê°’ì„ ì‚¬ìš©í•  수 ì—†ìŒ" -#: scan.l:1279 scan.l:1424 +#: scan.l:1280 scan.l:1425 msgid "invalid Unicode escape value" msgstr "ìž˜ëª»ëœ ìœ ë‹ˆì½”ë“œ ì´ìŠ¤ì¼€ì´í”„ ê°’" -#: scan.l:1481 +#: scan.l:1489 #, c-format msgid "nonstandard use of \\' in a string literal" msgstr "문ìžì—´ ì•ˆì— ìžˆëŠ” \\' 문ìžëŠ” í‘œì¤€ì´ ì•„ë‹™ë‹ˆë‹¤" -#: scan.l:1482 +#: scan.l:1490 #, c-format msgid "" "Use '' to write quotes in strings, or use the escape string syntax (E'...')." msgstr "ìž‘ì€ ë”°ì˜´í‘œëŠ” '' 형태니, ì¸ìš©ë¶€í˜¸ 표기법(E'...') 형태로 사용하십시오." -#: scan.l:1491 +#: scan.l:1499 #, c-format msgid "nonstandard use of \\\\ in a string literal" msgstr "문ìžì—´ ì•ˆì— ìžˆëŠ” \\\\ 문ìžëŠ” í‘œì¤€ì´ ì•„ë‹™ë‹ˆë‹¤" -#: scan.l:1492 +#: scan.l:1500 #, c-format msgid "Use the escape string syntax for backslashes, e.g., E'\\\\'." msgstr "백슬래시 표기는 ì¸ìš©ë¶€í˜¸ 표기법으로 사용하세요, 예, E'\\\\'." -#: scan.l:1506 +#: scan.l:1514 #, c-format msgid "nonstandard use of escape in a string literal" msgstr "문ìžì—´ ì•ˆì— ë¹„í‘œì¤€ escape 문ìžë¥¼ 사용하고 있습니다" -#: scan.l:1507 +#: scan.l:1515 #, c-format msgid "Use the escape string syntax for escapes, e.g., E'\\r\\n'." msgstr "ì¸ìš©ë¶€í˜¸ í‘œê¸°ë²•ì„ ì‚¬ìš©í•˜ì„¸ìš”, 예, E'\\r\\n'." - diff --git a/src/backend/po/ru.po b/src/backend/po/ru.po index c826c24f40..f5d14920fe 100644 --- a/src/backend/po/ru.po +++ b/src/backend/po/ru.po @@ -4,14 +4,14 @@ # Serguei A. Mokhov , 2001-2005. # Oleg Bartunov , 2004-2005. # Dmitriy Olshevskiy , 2014. -# Alexander Lakhin , 2012-2016, 2017. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: postgres (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:08+0000\n" -"PO-Revision-Date: 2017-02-02 15:23+0300\n" +"POT-Creation-Date: 2017-02-09 21:08+0000\n" +"PO-Revision-Date: 2017-04-18 17:11+0300\n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -4226,7 +4226,7 @@ msgstr "" #: utils/adt/selfuncs.c:5334 utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 #, c-format msgid "Use the COLLATE clause to set the collation explicitly." -msgstr "Задайте правило ÑÑ€Ð°Ð²Ð½ÐµÐ½Ð¸Ñ Ñвно в предложении COLLATE." +msgstr "Задайте правило Ñортировки Ñвно в предложении COLLATE." #: catalog/heap.c:1067 catalog/index.c:792 commands/tablecmds.c:2623 #, c-format @@ -7410,12 +7410,12 @@ msgstr "" #: commands/foreigncmds.c:1165 #, c-format msgid "user mapping \"%s\" already exists for server %s" -msgstr "ÑопоÑтавление пользователей \"%s\" Ð´Ð»Ñ Ñервера \"%s\" уже ÑущеÑтвует" +msgstr "ÑопоÑтавление Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" Ð´Ð»Ñ Ñервера \"%s\" уже ÑущеÑтвует" #: commands/foreigncmds.c:1259 commands/foreigncmds.c:1375 #, c-format msgid "user mapping \"%s\" does not exist for the server" -msgstr "ÑопоÑтавление пользователей \"%s\" Ð´Ð»Ñ Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ñервера не ÑущеÑтвует" +msgstr "ÑопоÑтавление Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" Ð´Ð»Ñ Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ñервера не ÑущеÑтвует" #: commands/foreigncmds.c:1362 #, c-format @@ -7426,7 +7426,8 @@ msgstr "Ñервер не ÑущеÑтвует, пропуÑкаетÑÑ" #, c-format msgid "user mapping \"%s\" does not exist for the server, skipping" msgstr "" -"ÑопоÑтавление пользователей \"%s\" не ÑущеÑтвует Ð´Ð»Ñ Ñервера, пропуÑкаетÑÑ" +"ÑопоÑтавление Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" Ð´Ð»Ñ Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ñервера не ÑущеÑтвует, " +"пропуÑкаетÑÑ" #: commands/foreigncmds.c:1532 foreign/foreign.c:361 #, c-format @@ -7867,7 +7868,7 @@ msgstr "функции в индекÑном выражении должны б #: commands/indexcmds.c:1131 #, c-format msgid "could not determine which collation to use for index expression" -msgstr "не удалоÑÑŒ определить правило ÑÑ€Ð°Ð²Ð½ÐµÐ½Ð¸Ñ Ð´Ð»Ñ Ð¸Ð½Ð´ÐµÐºÑного выражениÑ" +msgstr "не удалоÑÑŒ определить правило Ñортировки Ð´Ð»Ñ Ð¸Ð½Ð´ÐµÐºÑного выражениÑ" #: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2608 #: parser/parse_type.c:550 parser/parse_utilcmd.c:2807 utils/adt/misc.c:666 @@ -8608,12 +8609,12 @@ msgstr "DROP INDEX CONCURRENTLY не поддерживает режим CASCADE #: commands/tablecmds.c:1085 #, c-format msgid "truncate cascades to table \"%s\"" -msgstr "удаление раÑпроÑтранÑетÑÑ Ð½Ð° таблицу %s" +msgstr "опуÑтошение раÑпроÑтранÑетÑÑ Ð½Ð° таблицу %s" #: commands/tablecmds.c:1323 #, c-format msgid "cannot truncate temporary tables of other sessions" -msgstr "временные таблицы других ÑеанÑов Ð½ÐµÐ»ÑŒÐ·Ñ Ð¾Ñ‡Ð¸Ñтить" +msgstr "временные таблицы других ÑеанÑов Ð½ÐµÐ»ÑŒÐ·Ñ Ð¾Ð¿ÑƒÑтошить" #: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1844 #, c-format @@ -10882,7 +10883,7 @@ msgid "" "an unconditional ON INSERT DO INSTEAD rule." msgstr "" "Чтобы предÑтавление допуÑкало добавление данных, уÑтановите триггер INSTEAD " -"OF INSERT trigger или безуÑловное правило ON INSERT DO INSTEAD." +"OF INSERT или безуÑловное правило ON INSERT DO INSTEAD." #: executor/execMain.c:1059 rewrite/rewriteHandler.c:2656 #, c-format @@ -11686,8 +11687,8 @@ msgstr "" #, c-format msgid "no pg_hba.conf entry for host \"%s\", user \"%s\", database \"%s\", %s" msgstr "" -"в pg_hba.conf нет запиÑи, разрешающей подключение Ð´Ð»Ñ Ñ€ÐµÐ¿Ð»Ð¸ÐºÐ°Ñ†Ð¸Ð¸ Ñ " -"компьютера \"%s\" Ð´Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\", базы данных \"%s\", %s" +"в pg_hba.conf нет запиÑи Ð´Ð»Ñ ÐºÐ¾Ð¼Ð¿ÑŒÑŽÑ‚ÐµÑ€Ð° \"%s\", Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\", базы " +"\"%s\", %s" #: libpq/auth.c:493 #, c-format @@ -13199,18 +13200,18 @@ msgid "%s cannot be applied to the nullable side of an outer join" msgstr "%s не может применÑÑ‚ÑŒÑÑ Ðº NULL-Ñодержащей Ñтороне внешнего ÑоединениÑ" #. translator: %s is a SQL row locking clause such as FOR UPDATE -#: optimizer/plan/planner.c:1494 parser/analyze.c:1549 parser/analyze.c:1747 +#: optimizer/plan/planner.c:1480 parser/analyze.c:1549 parser/analyze.c:1747 #: parser/analyze.c:2528 #, c-format msgid "%s is not allowed with UNION/INTERSECT/EXCEPT" msgstr "%s неÑовмеÑтимо Ñ UNION/INTERSECT/EXCEPT" -#: optimizer/plan/planner.c:3823 +#: optimizer/plan/planner.c:3809 #, c-format msgid "could not implement GROUP BY" msgstr "не удалоÑÑŒ реализовать GROUP BY" -#: optimizer/plan/planner.c:3824 optimizer/plan/planner.c:4217 +#: optimizer/plan/planner.c:3810 optimizer/plan/planner.c:4203 #: optimizer/prep/prepunion.c:929 #, c-format msgid "" @@ -13220,27 +13221,27 @@ msgstr "" "Одни типы данных поддерживают только хеширование, а другие - только " "Ñортировку." -#: optimizer/plan/planner.c:4216 +#: optimizer/plan/planner.c:4202 #, c-format msgid "could not implement DISTINCT" msgstr "не удалоÑÑŒ реализовать DISTINCT" -#: optimizer/plan/planner.c:4846 +#: optimizer/plan/planner.c:4832 #, c-format msgid "could not implement window PARTITION BY" msgstr "не удалоÑÑŒ реализовать PARTITION BY Ð´Ð»Ñ Ð¾ÐºÐ½Ð°" -#: optimizer/plan/planner.c:4847 +#: optimizer/plan/planner.c:4833 #, c-format msgid "Window partitioning columns must be of sortable datatypes." msgstr "Столбцы, разбивающие окна, должны иметь Ñортируемые типы данных." -#: optimizer/plan/planner.c:4851 +#: optimizer/plan/planner.c:4837 #, c-format msgid "could not implement window ORDER BY" msgstr "не удалоÑÑŒ реализовать ORDER BY Ð´Ð»Ñ Ð¾ÐºÐ½Ð°" -#: optimizer/plan/planner.c:4852 +#: optimizer/plan/planner.c:4838 #, c-format msgid "Window ordering columns must be of sortable datatypes." msgstr "Столбцы, Ñортирующие окна, должны иметь Ñортируемые типы данных." @@ -14091,8 +14092,7 @@ msgstr "" #: parser/parse_coerce.c:1735 parser/parse_coerce.c:1956 #, c-format msgid "argument declared \"anyrange\" is not a range type but type %s" -msgstr "" -"аргумент, объÑвленный как \"anyrange\", оказалÑÑ Ð½Ðµ диапазоном, а типом %s" +msgstr "аргумент, объÑвленный как \"anyrange\", имеет не диапазонный тип, а %s" #: parser/parse_coerce.c:1751 #, c-format @@ -17232,7 +17232,8 @@ msgstr "правило предÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ð´Ð»Ñ \"%s\" должно н #, c-format msgid "could not convert table \"%s\" to a view because it is not empty" msgstr "" -"не удалоÑÑŒ преобразовать таблицу \"%s\" в предÑтавление, так как она не пуÑта" +"не удалоÑÑŒ преобразовать таблицу \"%s\" в предÑтавление, так как она не " +"пуÑта1" #: rewrite/rewriteDefine.c:440 #, c-format @@ -18258,7 +18259,7 @@ msgstr "" #, c-format msgid "page verification failed, calculated checksum %u but expected %u" msgstr "" -"ошибка проверки Ñтраницы: получена ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñумма %u, а ожидалаÑÑŒ — %u" +"ошибка проверки Ñтраницы: получена ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñумма %u, а ожидалаÑÑŒ - %u" #: storage/page/bufpage.c:203 storage/page/bufpage.c:522 #: storage/page/bufpage.c:737 storage/page/bufpage.c:868 @@ -19581,8 +19582,8 @@ msgstr "дата вне диапазона Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° timestamp" #: utils/adt/jsonb.c:847 utils/adt/nabstime.c:455 utils/adt/nabstime.c:498 #: utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 utils/adt/timestamp.c:224 #: utils/adt/timestamp.c:268 utils/adt/timestamp.c:726 -#: utils/adt/timestamp.c:735 utils/adt/timestamp.c:820 -#: utils/adt/timestamp.c:860 utils/adt/timestamp.c:3074 +#: utils/adt/timestamp.c:735 utils/adt/timestamp.c:817 +#: utils/adt/timestamp.c:857 utils/adt/timestamp.c:3074 #: utils/adt/timestamp.c:3095 utils/adt/timestamp.c:3108 #: utils/adt/timestamp.c:3117 utils/adt/timestamp.c:3125 #: utils/adt/timestamp.c:3180 utils/adt/timestamp.c:3203 @@ -21559,7 +21560,7 @@ msgid "timestamp out of range: \"%s\"" msgstr "timestamp вне диапазона: \"%s\"" #: utils/adt/timestamp.c:188 utils/adt/timestamp.c:463 -#: utils/adt/timestamp.c:993 +#: utils/adt/timestamp.c:990 #, c-format msgid "date/time value \"%s\" is no longer supported" msgstr "значение даты/времени \"%s\" более не поддерживаетÑÑ" @@ -21596,13 +21597,12 @@ msgstr "чиÑловой чаÑовой поÑÑ \"%s\" вне диапазон msgid "timestamp out of range: %d-%02d-%02d %d:%02d:%02g" msgstr "timestamp вне диапазона: %d-%02d-%02d %d:%02d:%02g" -#: utils/adt/timestamp.c:770 utils/adt/timestamp.c:776 -#: utils/adt/timestamp.c:791 +#: utils/adt/timestamp.c:772 utils/adt/timestamp.c:788 #, c-format msgid "timestamp out of range: \"%g\"" msgstr "timestamp вне диапазона: \"%g\"" -#: utils/adt/timestamp.c:987 utils/adt/timestamp.c:1611 +#: utils/adt/timestamp.c:984 utils/adt/timestamp.c:1608 #: utils/adt/timestamp.c:2121 utils/adt/timestamp.c:3273 #: utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3283 #: utils/adt/timestamp.c:3333 utils/adt/timestamp.c:3340 @@ -21615,22 +21615,22 @@ msgstr "timestamp вне диапазона: \"%g\"" msgid "interval out of range" msgstr "interval вне диапазона" -#: utils/adt/timestamp.c:1128 utils/adt/timestamp.c:1161 +#: utils/adt/timestamp.c:1125 utils/adt/timestamp.c:1158 #, c-format msgid "invalid INTERVAL type modifier" msgstr "неверный модификатор типа INTERVAL" -#: utils/adt/timestamp.c:1144 +#: utils/adt/timestamp.c:1141 #, c-format msgid "INTERVAL(%d) precision must not be negative" msgstr "INTERVAL(%d): точноÑÑ‚ÑŒ должна быть неотрицательна" -#: utils/adt/timestamp.c:1150 +#: utils/adt/timestamp.c:1147 #, c-format msgid "INTERVAL(%d) precision reduced to maximum allowed, %d" msgstr "INTERVAL(%d): точноÑÑ‚ÑŒ уменьшена до макÑимально возможной: %d" -#: utils/adt/timestamp.c:1555 +#: utils/adt/timestamp.c:1552 #, c-format msgid "interval(%d) precision must be between %d and %d" msgstr "точноÑÑ‚ÑŒ interval(%d) должна быть между %d и %d" @@ -22221,17 +22221,17 @@ msgstr "Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° %s нет функции вывода" msgid "cached plan must not change result type" msgstr "в кешированном плане не должен изменÑÑ‚ÑŒÑÑ Ñ‚Ð¸Ð¿ результата" -#: utils/cache/relcache.c:5199 +#: utils/cache/relcache.c:5226 #, c-format msgid "could not create relation-cache initialization file \"%s\": %m" msgstr "Ñоздать файл инициализации Ð´Ð»Ñ ÐºÐµÑˆÐ° отношений \"%s\" не удалоÑÑŒ: %m" -#: utils/cache/relcache.c:5201 +#: utils/cache/relcache.c:5228 #, c-format msgid "Continuing anyway, but there's something wrong." msgstr "Продолжаем вÑÑ‘ равно, Ñ…Ð¾Ñ‚Ñ Ñ‡Ñ‚Ð¾-то не так." -#: utils/cache/relcache.c:5475 +#: utils/cache/relcache.c:5502 #, c-format msgid "could not remove cache file \"%s\": %m" msgstr "не удалоÑÑŒ Ñтереть файл кеша \"%s\": %m" @@ -25225,19 +25225,19 @@ msgstr "Данные Ñодержат дублирующиеÑÑ ÐºÐ»ÑŽÑ‡Ð¸." #: utils/sort/tuplestore.c:1313 #, c-format msgid "could not seek in tuplestore temporary file: %m" -msgstr "не удалоÑÑŒ перемеÑтитьÑÑ Ð² файле временного хранилища кортежей: %m" +msgstr "не удалоÑÑŒ перемеÑтитьÑÑ Ð²Ð¾ временном файле иÑточника кортежей: %m" #: utils/sort/tuplestore.c:1460 utils/sort/tuplestore.c:1533 #: utils/sort/tuplestore.c:1539 #, c-format msgid "could not read from tuplestore temporary file: %m" -msgstr "не удалоÑÑŒ прочитать файл временного хранилища кортежей: %m" +msgstr "не удалоÑÑŒ прочитать временный файл иÑточника кортежей: %m" #: utils/sort/tuplestore.c:1501 utils/sort/tuplestore.c:1506 #: utils/sort/tuplestore.c:1512 #, c-format msgid "could not write to tuplestore temporary file: %m" -msgstr "не удалоÑÑŒ запиÑать в файл временного хранилища кортежей: %m" +msgstr "не удалоÑÑŒ запиÑать во временный файл иÑточника кортежей: %m" #: utils/time/snapmgr.c:618 #, c-format diff --git a/src/bin/initdb/po/it.po b/src/bin/initdb/po/it.po index c6c824f3f6..08fcfab7e1 100644 --- a/src/bin/initdb/po/it.po +++ b/src/bin/initdb/po/it.po @@ -24,8 +24,8 @@ msgid "" msgstr "" "Project-Id-Version: initdb (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:14+0000\n" -"PO-Revision-Date: 2016-04-17 21:10+0100\n" +"POT-Creation-Date: 2017-02-09 21:13+0000\n" +"PO-Revision-Date: 2017-04-23 03:06+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -34,7 +34,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-SourceCharset: utf-8\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" #: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format @@ -201,107 +201,107 @@ msgstr "non è stato possibile impostare la giunzione per \"%s\": %s\n" msgid "could not get junction for \"%s\": %s\n" msgstr "non è stato possibile ottenere la giunzione per \"%s\": %s\n" -#: initdb.c:349 +#: initdb.c:350 #, c-format msgid "%s: out of memory\n" msgstr "%s: memoria esaurita\n" -#: initdb.c:459 initdb.c:1589 +#: initdb.c:460 initdb.c:1623 #, c-format msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: errore nell'apertura del file \"%s\" per la lettura: %s\n" -#: initdb.c:515 initdb.c:1002 initdb.c:1030 +#: initdb.c:516 initdb.c:1003 initdb.c:1031 #, c-format msgid "%s: could not open file \"%s\" for writing: %s\n" msgstr "%s: errore nell'apertura del file \"%s\" per la scrittura: %s\n" -#: initdb.c:523 initdb.c:531 initdb.c:1009 initdb.c:1036 +#: initdb.c:524 initdb.c:532 initdb.c:1010 initdb.c:1037 #, c-format msgid "%s: could not write file \"%s\": %s\n" msgstr "%s: errore nella scrittura del file \"%s\": %s\n" -#: initdb.c:562 +#: initdb.c:563 #, c-format msgid "%s: could not open directory \"%s\": %s\n" msgstr "%s: apertura della directory \"%s\" fallita: %s\n" -#: initdb.c:586 initdb.c:2334 +#: initdb.c:587 initdb.c:2346 #, c-format msgid "%s: could not stat file \"%s\": %s\n" msgstr "%s: non è stato possibile ottenere informazioni sul file \"%s\": %s\n" -#: initdb.c:598 +#: initdb.c:599 #, c-format msgid "%s: could not read directory \"%s\": %s\n" msgstr "%s: lettura della directory \"%s\" fallita: %s\n" -#: initdb.c:631 initdb.c:690 +#: initdb.c:632 initdb.c:691 #, c-format msgid "%s: could not open file \"%s\": %s\n" msgstr "%s: apertura del file \"%s\" fallita: %s\n" -#: initdb.c:702 +#: initdb.c:703 #, c-format msgid "%s: could not fsync file \"%s\": %s\n" msgstr "%s: fsync del file \"%s\" fallito: %s\n" -#: initdb.c:721 +#: initdb.c:722 #, c-format msgid "%s: could not execute command \"%s\": %s\n" msgstr "%s: esecuzione del comando \"%s\" fallita: %s\n" -#: initdb.c:737 +#: initdb.c:738 #, c-format msgid "%s: removing data directory \"%s\"\n" msgstr "%s: rimozione della directory dati \"%s\"\n" -#: initdb.c:740 +#: initdb.c:741 #, c-format msgid "%s: failed to remove data directory\n" msgstr "%s: rimozione della directory dati fallita\n" -#: initdb.c:746 +#: initdb.c:747 #, c-format msgid "%s: removing contents of data directory \"%s\"\n" msgstr "%s: rimozione dei contenuti della directory dati \"%s\"\n" -#: initdb.c:749 +#: initdb.c:750 #, c-format msgid "%s: failed to remove contents of data directory\n" msgstr "%s: rimozione dei contenuti dalla directory dati fallita\n" -#: initdb.c:755 +#: initdb.c:756 #, c-format msgid "%s: removing transaction log directory \"%s\"\n" msgstr "%s: rimozione della directory dei log delle transazioni \"%s\"\n" -#: initdb.c:758 +#: initdb.c:759 #, c-format msgid "%s: failed to remove transaction log directory\n" msgstr "%s: rimozione della directory dei log delle transazioni fallita\n" -#: initdb.c:764 +#: initdb.c:765 #, c-format msgid "%s: removing contents of transaction log directory \"%s\"\n" msgstr "%s: rimozione dei contenuti della directory dei log delle transazioni \"%s\"\n" -#: initdb.c:767 +#: initdb.c:768 #, c-format msgid "%s: failed to remove contents of transaction log directory\n" msgstr "%s: rimozione dei contenuti della directory dei log delle transazioni fallita\n" -#: initdb.c:776 +#: initdb.c:777 #, c-format msgid "%s: data directory \"%s\" not removed at user's request\n" msgstr "%s: directory dati \"%s\" non rimossa su richiesta dell'utente\n" -#: initdb.c:781 +#: initdb.c:782 #, c-format msgid "%s: transaction log directory \"%s\" not removed at user's request\n" msgstr "%s: directory dei log delle transazioni \"%s\" non rimossa su richiesta dell'utente\n" -#: initdb.c:802 +#: initdb.c:803 #, c-format msgid "" "%s: cannot be run as root\n" @@ -312,17 +312,17 @@ msgstr "" "Effettua il login (usando per esempio \"su\") con l'utente\n" "(non privilegiato) che controllerà il processo server.\n" -#: initdb.c:838 +#: initdb.c:839 #, c-format msgid "%s: \"%s\" is not a valid server encoding name\n" msgstr "%s: \"%s\" non è un nome di codifica per il server valido\n" -#: initdb.c:958 +#: initdb.c:959 #, c-format msgid "%s: file \"%s\" does not exist\n" msgstr "%s: il file \"%s\" non esiste\n" -#: initdb.c:960 initdb.c:969 initdb.c:979 +#: initdb.c:961 initdb.c:970 initdb.c:980 #, c-format msgid "" "This might mean you have a corrupted installation or identified\n" @@ -331,46 +331,46 @@ msgstr "" "Questo potrebbe indica una installazione corrotta oppure\n" "hai indicato la directory errata con l'opzione -L.\n" -#: initdb.c:966 +#: initdb.c:967 #, c-format msgid "%s: could not access file \"%s\": %s\n" msgstr "%s: accesso al file \"%s\" fallito: %s\n" -#: initdb.c:977 +#: initdb.c:978 #, c-format msgid "%s: file \"%s\" is not a regular file\n" msgstr "%s: il file \"%s\" non è un file regolare\n" -#: initdb.c:1122 +#: initdb.c:1123 #, c-format msgid "selecting default max_connections ... " msgstr "selezione del parametro max_connections predefinito ... " -#: initdb.c:1152 +#: initdb.c:1153 #, c-format msgid "selecting default shared_buffers ... " msgstr "selezione di shared_buffers predefinito ... " -#: initdb.c:1185 +#: initdb.c:1186 #, c-format msgid "selecting dynamic shared memory implementation ... " msgstr "selezione dell'implementazione della memoria dinamica ... " -#: initdb.c:1203 +#: initdb.c:1204 msgid "creating configuration files ... " msgstr "creazione dei file di configurazione ... " -#: initdb.c:1300 initdb.c:1320 initdb.c:1404 initdb.c:1420 +#: initdb.c:1328 initdb.c:1348 initdb.c:1432 initdb.c:1448 #, c-format msgid "%s: could not change permissions of \"%s\": %s\n" msgstr "%s: cambio di permesso di \"%s\" fallito: %s\n" -#: initdb.c:1444 +#: initdb.c:1472 #, c-format msgid "running bootstrap script ... " msgstr "esecuzione dello script di bootstrap ... " -#: initdb.c:1460 +#: initdb.c:1488 #, c-format msgid "" "%s: input file \"%s\" does not belong to PostgreSQL %s\n" @@ -380,94 +380,94 @@ msgstr "" "Controlla la correttezza dell'installazione oppure specifica\n" "il percorso corretto con l'opzione -L.\n" -#: initdb.c:1564 +#: initdb.c:1598 msgid "Enter new superuser password: " msgstr "Inserisci la nuova password del superutente: " -#: initdb.c:1565 +#: initdb.c:1599 msgid "Enter it again: " msgstr "Conferma password: " -#: initdb.c:1568 +#: initdb.c:1602 #, c-format msgid "Passwords didn't match.\n" msgstr "Le password non corrispondono.\n" -#: initdb.c:1596 +#: initdb.c:1630 #, c-format msgid "%s: could not read password from file \"%s\": %s\n" msgstr "%s: lettura del file delle password \"%s\" fallita: %s\n" -#: initdb.c:1599 +#: initdb.c:1633 #, c-format msgid "%s: password file \"%s\" is empty\n" msgstr "%s: il file delle password \"%s\" è vuoto\n" -#: initdb.c:1845 +#: initdb.c:1878 #, c-format msgid "%s: locale name too long, skipped: \"%s\"\n" msgstr "%s: nome locale troppo lungo, saltato: \"%s\"\n" -#: initdb.c:1870 +#: initdb.c:1903 #, c-format msgid "%s: locale name has non-ASCII characters, skipped: \"%s\"\n" msgstr "%s: nome locale contiene caratteri non ASCII, saltato: \"%s\"\n" -#: initdb.c:1943 +#: initdb.c:1976 #, c-format msgid "No usable system locales were found.\n" msgstr "Nessun locale di sistema trovato.\n" -#: initdb.c:1944 +#: initdb.c:1977 #, c-format msgid "Use the option \"--debug\" to see details.\n" msgstr "Usa l'opzione \"--debug\" per vedere i dettagli.\n" -#: initdb.c:2317 +#: initdb.c:2329 msgid "syncing data to disk ... " msgstr "sincronizzazione dati sul disco ... " -#: initdb.c:2411 +#: initdb.c:2423 #, c-format msgid "caught signal\n" msgstr "intercettato segnale\n" -#: initdb.c:2417 +#: initdb.c:2429 #, c-format msgid "could not write to child process: %s\n" msgstr "scrittura verso il processo figlio fallita: %s\n" -#: initdb.c:2425 +#: initdb.c:2437 #, c-format msgid "ok\n" msgstr "ok\n" -#: initdb.c:2515 +#: initdb.c:2527 #, c-format msgid "%s: setlocale() failed\n" msgstr "%s: setlocale() fallito\n" -#: initdb.c:2533 +#: initdb.c:2545 #, c-format msgid "%s: failed to restore old locale \"%s\"\n" msgstr "%s: ripristino del locale precedente \"%s\" fallito\n" -#: initdb.c:2543 +#: initdb.c:2555 #, c-format msgid "%s: invalid locale name \"%s\"\n" msgstr "%s: nome locale non valido \"%s\"\n" -#: initdb.c:2555 +#: initdb.c:2567 #, c-format msgid "%s: invalid locale settings; check LANG and LC_* environment variables\n" msgstr "%s: impostazione locale non valida; controlla le variabili d'ambiente LANG e LC_*\n" -#: initdb.c:2583 +#: initdb.c:2595 #, c-format msgid "%s: encoding mismatch\n" msgstr "%s: mancata corrispondenza di codifica\n" -#: initdb.c:2585 +#: initdb.c:2597 #, c-format msgid "" "The encoding you selected (%s) and the encoding that the\n" @@ -482,7 +482,7 @@ msgstr "" "Esegui di nuovo %s senza specificare una codifica esplicitamente\n" "oppure seleziona una combinazione corretta.\n" -#: initdb.c:2657 +#: initdb.c:2669 #, c-format msgid "" "%s initializes a PostgreSQL database cluster.\n" @@ -491,17 +491,17 @@ msgstr "" "%s inizializza un cluster di database PostgreSQL.\n" "\n" -#: initdb.c:2658 +#: initdb.c:2670 #, c-format msgid "Usage:\n" msgstr "Utilizzo:\n" -#: initdb.c:2659 +#: initdb.c:2671 #, c-format msgid " %s [OPTION]... [DATADIR]\n" msgstr " %s [OPZIONE]... [DATADIR]\n" -#: initdb.c:2660 +#: initdb.c:2672 #, c-format msgid "" "\n" @@ -510,47 +510,47 @@ msgstr "" "\n" "Opzioni:\n" -#: initdb.c:2661 +#: initdb.c:2673 #, c-format msgid " -A, --auth=METHOD default authentication method for local connections\n" msgstr "" " -A, --auth=METODO metodo di autenticazione predefinito per le\n" " connessioni locali\n" -#: initdb.c:2662 +#: initdb.c:2674 #, c-format msgid " --auth-host=METHOD default authentication method for local TCP/IP connections\n" msgstr "" " --auth-host=METODO metodo di autenticazione predefinito per le\n" " connessioni TCP/IP\n" -#: initdb.c:2663 +#: initdb.c:2675 #, c-format msgid " --auth-local=METHOD default authentication method for local-socket connections\n" msgstr "" " --auth-local=METODO metodo di autenticazione predefinito per le\n" " connessioni locali\n" -#: initdb.c:2664 +#: initdb.c:2676 #, c-format msgid " [-D, --pgdata=]DATADIR location for this database cluster\n" msgstr " [-D, --pgdata=]DATADIR dove creare questo cluster di database\n" -#: initdb.c:2665 +#: initdb.c:2677 #, c-format msgid " -E, --encoding=ENCODING set default encoding for new databases\n" msgstr "" " -E, --encoding=ENCODING imposta la codifica predefinita per i nuovi\n" " database\n" -#: initdb.c:2666 +#: initdb.c:2678 #, c-format msgid " --locale=LOCALE set default locale for new databases\n" msgstr "" " --locale=LOCALE imposta il locale predefinito per i nuovi\n" " database\n" -#: initdb.c:2667 +#: initdb.c:2679 #, c-format msgid "" " --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n" @@ -565,17 +565,17 @@ msgstr "" " Il valore predefinito viene preso dalle variabili\n" " d'ambiente\n" -#: initdb.c:2671 +#: initdb.c:2683 #, c-format msgid " --no-locale equivalent to --locale=C\n" msgstr " --no-locale equivalente a --locale=C\n" -#: initdb.c:2672 +#: initdb.c:2684 #, c-format msgid " --pwfile=FILE read password for the new superuser from file\n" msgstr " --pwfile=FILE leggi la password per il nuovo superutente dal file\n" -#: initdb.c:2673 +#: initdb.c:2685 #, c-format msgid "" " -T, --text-search-config=CFG\n" @@ -584,24 +584,24 @@ msgstr "" " -T, --text-search-config=CFG\n" " configurazione predefinita per la ricerca di testo\n" -#: initdb.c:2675 +#: initdb.c:2687 #, c-format msgid " -U, --username=NAME database superuser name\n" msgstr " -U, --username=NOME nome del superutente del database\n" -#: initdb.c:2676 +#: initdb.c:2688 #, c-format msgid " -W, --pwprompt prompt for a password for the new superuser\n" msgstr " -W, --pwprompt richiedi la password per il nuovo superutente\n" -#: initdb.c:2677 +#: initdb.c:2689 #, c-format msgid " -X, --xlogdir=XLOGDIR location for the transaction log directory\n" msgstr "" " -X, --xlogdir=XLOGDIR posizione della directory contenente i log\n" " delle transazioni\n" -#: initdb.c:2678 +#: initdb.c:2690 #, c-format msgid "" "\n" @@ -610,44 +610,44 @@ msgstr "" "\n" "Opzioni utilizzate meno frequentemente:\n" -#: initdb.c:2679 +#: initdb.c:2691 #, c-format msgid " -d, --debug generate lots of debugging output\n" msgstr " -d, --debug genera molto output di debug\n" -#: initdb.c:2680 +#: initdb.c:2692 #, c-format msgid " -k, --data-checksums use data page checksums\n" msgstr " -k, --data-checksums usa i checksum delle pagine dati\n" -#: initdb.c:2681 +#: initdb.c:2693 #, c-format msgid " -L DIRECTORY where to find the input files\n" msgstr " -L DIRECTORY dove trovare i file di input\n" -#: initdb.c:2682 +#: initdb.c:2694 #, c-format msgid " -n, --noclean do not clean up after errors\n" msgstr " -n, --noclean non ripulire dopo gli errori\n" -#: initdb.c:2683 +#: initdb.c:2695 #, c-format msgid " -N, --nosync do not wait for changes to be written safely to disk\n" msgstr "" " -N, --nosync non attendere che i cambiamenti siano stati\n" " scritti in sicurezza sul disco\n" -#: initdb.c:2684 +#: initdb.c:2696 #, c-format msgid " -s, --show show internal settings\n" msgstr " -s, --show mostra le impostazioni interne\n" -#: initdb.c:2685 +#: initdb.c:2697 #, c-format msgid " -S, --sync-only only sync data directory\n" msgstr " -S, --sync-only sincronizza solo la directory dei dati\n" -#: initdb.c:2686 +#: initdb.c:2698 #, c-format msgid "" "\n" @@ -656,17 +656,17 @@ msgstr "" "\n" "Altre opzioni:\n" -#: initdb.c:2687 +#: initdb.c:2699 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version mostra informazioni sulla versione ed esci\n" -#: initdb.c:2688 +#: initdb.c:2700 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help mostra questo aiuto ed esci\n" -#: initdb.c:2689 +#: initdb.c:2701 #, c-format msgid "" "\n" @@ -677,7 +677,7 @@ msgstr "" "Se la directory dati non è specificata, viene usata la variabile\n" "d'ambiente PGDATA.\n" -#: initdb.c:2691 +#: initdb.c:2703 #, c-format msgid "" "\n" @@ -686,7 +686,7 @@ msgstr "" "\n" "Puoi segnalare eventuali bug a .\n" -#: initdb.c:2699 +#: initdb.c:2711 msgid "" "\n" "WARNING: enabling \"trust\" authentication for local connections\n" @@ -699,17 +699,17 @@ msgstr "" "pg_hba.conf o utilizzando l'opzione -A oppure --auth-local and --auth-host\n" "alla prossima esecuzione di initdb.\n" -#: initdb.c:2721 +#: initdb.c:2733 #, c-format msgid "%s: invalid authentication method \"%s\" for \"%s\" connections\n" msgstr "%s: metodo di autenticazione \"%s\" non valido per connessioni \"%s\"\n" -#: initdb.c:2735 +#: initdb.c:2747 #, c-format msgid "%s: must specify a password for the superuser to enable %s authentication\n" msgstr "%s: occorre specificare una password per il superutente per abilitare l'autenticazione %s\n" -#: initdb.c:2762 +#: initdb.c:2774 #, c-format msgid "" "%s: no data directory specified\n" @@ -722,7 +722,7 @@ msgstr "" "database. Puoi farlo usando l'opzione -D oppure la variabile globale\n" "PGDATA.\n" -#: initdb.c:2800 +#: initdb.c:2812 #, c-format msgid "" "The program \"postgres\" is needed by %s but was not found in the\n" @@ -733,7 +733,7 @@ msgstr "" "nella stessa directory \"%s\".\n" "Verifica la correttezza dell'installazione.\n" -#: initdb.c:2807 +#: initdb.c:2819 #, c-format msgid "" "The program \"postgres\" was found by \"%s\"\n" @@ -744,17 +744,17 @@ msgstr "" "ma non ha la stessa versione di %s.\n" "Verifica la correttezza dell'installazione.\n" -#: initdb.c:2826 +#: initdb.c:2838 #, c-format msgid "%s: input file location must be an absolute path\n" msgstr "%s: la posizione del file di input deve essere un percorso assoluto\n" -#: initdb.c:2845 +#: initdb.c:2857 #, c-format msgid "The database cluster will be initialized with locale \"%s\".\n" msgstr "Il cluster di database sarà inizializzato con il locale \"%s\".\n" -#: initdb.c:2848 +#: initdb.c:2860 #, c-format msgid "" "The database cluster will be initialized with locales\n" @@ -773,22 +773,22 @@ msgstr "" " NUMERIC: %s\n" " TIME: %s\n" -#: initdb.c:2872 +#: initdb.c:2884 #, c-format msgid "%s: could not find suitable encoding for locale \"%s\"\n" msgstr "%s: nessuna codifica adeguata trovata per il locale \"%s\"\n" -#: initdb.c:2874 +#: initdb.c:2886 #, c-format msgid "Rerun %s with the -E option.\n" msgstr "Esegui di nuovo %s con l'opzione -E.\n" -#: initdb.c:2875 initdb.c:3498 initdb.c:3519 +#: initdb.c:2887 initdb.c:3508 initdb.c:3529 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Prova \"%s --help\" per maggiori informazioni.\n" -#: initdb.c:2887 +#: initdb.c:2899 #, c-format msgid "" "Encoding \"%s\" implied by locale is not allowed as a server-side encoding.\n" @@ -797,12 +797,12 @@ msgstr "" "La codifica \"%s\" implicata dal locale non è consentita come codifica lato server.\n" "La codifica predefinita dei database sarà impostata invece a \"%s\".\n" -#: initdb.c:2895 +#: initdb.c:2907 #, c-format msgid "%s: locale \"%s\" requires unsupported encoding \"%s\"\n" msgstr "%s: il locale \"%s\" richiede la codifica non supportata \"%s\"\n" -#: initdb.c:2898 +#: initdb.c:2910 #, c-format msgid "" "Encoding \"%s\" is not allowed as a server-side encoding.\n" @@ -811,59 +811,59 @@ msgstr "" "La codifica \"%s\" non è disponibile come codifica lato server.\n" "Esegui di nuovo %s con un locale diverso.\n" -#: initdb.c:2907 +#: initdb.c:2919 #, c-format msgid "The default database encoding has accordingly been set to \"%s\".\n" msgstr "La codifica predefinita del database è stata impostata a \"%s\".\n" -#: initdb.c:2978 +#: initdb.c:2990 #, c-format msgid "%s: could not find suitable text search configuration for locale \"%s\"\n" msgstr "%s: nessuna configurazione per la ricerca testo adeguata al locale \"%s\"\n" -#: initdb.c:2989 +#: initdb.c:3001 #, c-format msgid "%s: warning: suitable text search configuration for locale \"%s\" is unknown\n" msgstr "%s: attenzione: non si conosce una configurazione per la ricerca testo adeguata al locale \"%s\"\n" -#: initdb.c:2994 +#: initdb.c:3006 #, c-format msgid "%s: warning: specified text search configuration \"%s\" might not match locale \"%s\"\n" msgstr "" "%s: attenzione: la configurazione specificata per la ricerca testo \"%s\"\n" "potrebbe non corrispondere al locale \"%s\"\n" -#: initdb.c:2999 +#: initdb.c:3011 #, c-format msgid "The default text search configuration will be set to \"%s\".\n" msgstr "La configurazione predefinita di ricerca testo sarà impostata a \"%s\".\n" -#: initdb.c:3043 initdb.c:3129 +#: initdb.c:3055 initdb.c:3141 #, c-format msgid "creating directory %s ... " msgstr "creazione della directory %s ... " -#: initdb.c:3049 initdb.c:3135 initdb.c:3203 initdb.c:3259 +#: initdb.c:3061 initdb.c:3147 initdb.c:3215 initdb.c:3271 #, c-format msgid "%s: could not create directory \"%s\": %s\n" msgstr "%s: creazione della directory \"%s\" fallita: %s\n" -#: initdb.c:3061 initdb.c:3147 +#: initdb.c:3073 initdb.c:3159 #, c-format msgid "fixing permissions on existing directory %s ... " msgstr "correzione dei permessi sulla directory esistente %s ... " -#: initdb.c:3067 initdb.c:3153 +#: initdb.c:3079 initdb.c:3165 #, c-format msgid "%s: could not change permissions of directory \"%s\": %s\n" msgstr "%s: modifica dei permessi della directory \"%s\" fallita: %s\n" -#: initdb.c:3082 initdb.c:3168 +#: initdb.c:3094 initdb.c:3180 #, c-format msgid "%s: directory \"%s\" exists but is not empty\n" msgstr "%s: la directory \"%s\" esiste ma non è vuota\n" -#: initdb.c:3088 +#: initdb.c:3100 #, c-format msgid "" "If you want to create a new database system, either remove or empty\n" @@ -874,17 +874,17 @@ msgstr "" "la directory \"%s\" oppure esegui %s\n" "con un argomento diverso da \"%s\".\n" -#: initdb.c:3096 initdb.c:3181 initdb.c:3532 +#: initdb.c:3108 initdb.c:3193 initdb.c:3542 #, c-format msgid "%s: could not access directory \"%s\": %s\n" msgstr "%s: accesso alla directory \"%s\" fallito: %s\n" -#: initdb.c:3120 +#: initdb.c:3132 #, c-format msgid "%s: transaction log directory location must be an absolute path\n" msgstr "%s: la directory dei log delle transazioni deve essere un percorso assoluto\n" -#: initdb.c:3174 +#: initdb.c:3186 #, c-format msgid "" "If you want to store the transaction log there, either\n" @@ -893,27 +893,27 @@ msgstr "" "Se vuoi salvare lì i log delle transazioni,\n" "elimina oppure svuota la directory \"%s\".\n" -#: initdb.c:3189 +#: initdb.c:3201 #, c-format msgid "%s: could not create symbolic link \"%s\": %s\n" msgstr "%s: creazione del link simbolico \"%s\" fallita: %s\n" -#: initdb.c:3194 +#: initdb.c:3206 #, c-format msgid "%s: symlinks are not supported on this platform" msgstr "%s: i link simbolici non sono supportati su questa piattaforma" -#: initdb.c:3218 +#: initdb.c:3230 #, c-format msgid "It contains a dot-prefixed/invisible file, perhaps due to it being a mount point.\n" msgstr "Contiene un file prefissato con punto o invisibile, forse perché è un punto di montaggio.\n" -#: initdb.c:3221 +#: initdb.c:3233 #, c-format msgid "It contains a lost+found directory, perhaps due to it being a mount point.\n" msgstr "Contiene una directory lost+found, forse perché è un punto di montaggio.\n" -#: initdb.c:3224 +#: initdb.c:3236 #, c-format msgid "" "Using a mount point directly as the data directory is not recommended.\n" @@ -922,38 +922,43 @@ msgstr "" "Usare un punto di montaggio direttamente come directory dati non è\n" "consigliato. Crea una sottodirectory sotto il punto di montaggio.\n" -#: initdb.c:3244 +#: initdb.c:3256 #, c-format msgid "creating subdirectories ... " msgstr "creazione delle sottodirectory ... " -#: initdb.c:3291 +#: initdb.c:3303 msgid "performing post-bootstrap initialization ... " msgstr "esecuzione dell'inizializzazione successiva al bootstrap ... " -#: initdb.c:3442 +#: initdb.c:3452 #, c-format msgid "Running in debug mode.\n" msgstr "Esecuzione in modalità debug\n" -#: initdb.c:3446 +#: initdb.c:3456 #, c-format msgid "Running in noclean mode. Mistakes will not be cleaned up.\n" msgstr "Esecuzione in modalità noclean. Gli errori non verranno ripuliti.\n" -#: initdb.c:3517 +#: initdb.c:3527 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: troppi argomenti nella riga di comando (il primo è \"%s\")\n" -#: initdb.c:3543 +#: initdb.c:3553 #, c-format msgid "%s: password prompt and password file cannot be specified together\n" msgstr "" "%s: il prompt della password ed un file contenente la password non\n" "possono essere specificati contemporaneamente\n" -#: initdb.c:3565 +#: initdb.c:3577 +#, c-format +msgid "%s: superuser name \"%s\" is disallowed; role names cannot begin with \"pg_\"\n" +msgstr "%s: il nome per il superutente \"%s\" non è permesso; i nomi dei ruoli non possono iniziare per \"pg_\"\n" + +#: initdb.c:3581 #, c-format msgid "" "The files belonging to this database system will be owned by user \"%s\".\n" @@ -964,17 +969,17 @@ msgstr "" "Questo utente deve inoltre possedere il processo server.\n" "\n" -#: initdb.c:3581 +#: initdb.c:3597 #, c-format msgid "Data page checksums are enabled.\n" msgstr "La somma di controllo dei dati delle pagine è abilitata.\n" -#: initdb.c:3583 +#: initdb.c:3599 #, c-format msgid "Data page checksums are disabled.\n" msgstr "La somma di controllo dei dati delle pagine è disabilitata.\n" -#: initdb.c:3592 +#: initdb.c:3611 #, c-format msgid "" "\n" @@ -985,7 +990,7 @@ msgstr "" "Sync sul disco saltato.\n" "La directory dei dati potrebbe diventare corrotta in caso di crash del sistema operativo.\n" -#: initdb.c:3601 +#: initdb.c:3620 #, c-format msgid "" "\n" diff --git a/src/bin/pg_basebackup/po/de.po b/src/bin/pg_basebackup/po/de.po index 59e12e3698..1d5c3d99d2 100644 --- a/src/bin/pg_basebackup/po/de.po +++ b/src/bin/pg_basebackup/po/de.po @@ -9,8 +9,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-12 20:14+0000\n" -"PO-Revision-Date: 2016-04-12 20:49-0400\n" +"POT-Creation-Date: 2017-05-07 21:23+0000\n" +"PO-Revision-Date: 2017-05-08 08:27-0400\n" "Last-Translator: Peter Eisentraut \n" "Language-Team: Peter Eisentraut \n" "Language: de\n" @@ -30,32 +30,32 @@ msgstr "Speicher aufgebraucht\n" msgid "cannot duplicate null pointer (internal error)\n" msgstr "kann NULL-Zeiger nicht kopieren (interner Fehler)\n" -#: pg_basebackup.c:154 +#: pg_basebackup.c:156 #, c-format msgid "%s: directory name too long\n" msgstr "%s: Verzeichnisname zu lang\n" -#: pg_basebackup.c:164 +#: pg_basebackup.c:166 #, c-format msgid "%s: multiple \"=\" signs in tablespace mapping\n" msgstr "%s: mehrere »=«-Zeichen im Tablespace-Mapping\n" -#: pg_basebackup.c:177 +#: pg_basebackup.c:179 #, c-format msgid "%s: invalid tablespace mapping format \"%s\", must be \"OLDDIR=NEWDIR\"\n" msgstr "%s: ungültiges Tablespace-Mapping-Format »%s«, muss »ALTES_VERZ=NEUES_VERZ« sein\n" -#: pg_basebackup.c:190 +#: pg_basebackup.c:192 #, c-format msgid "%s: old directory is not an absolute path in tablespace mapping: %s\n" msgstr "%s: altes Verzeichnis im Tablespace-Mapping ist kein absoluter Pfad: %s\n" -#: pg_basebackup.c:197 +#: pg_basebackup.c:199 #, c-format msgid "%s: new directory is not an absolute path in tablespace mapping: %s\n" msgstr "%s: neues Verzeichnis im Tablespace-Mapping ist kein absoluter Pfad: %s\n" -#: pg_basebackup.c:231 +#: pg_basebackup.c:233 #, c-format msgid "" "%s takes a base backup of a running PostgreSQL server.\n" @@ -64,17 +64,17 @@ msgstr "" "%s erzeugt eine Basissicherung eines laufenden PostgreSQL-Servers.\n" "\n" -#: pg_basebackup.c:233 pg_receivexlog.c:66 pg_recvlogical.c:69 +#: pg_basebackup.c:235 pg_receivexlog.c:66 pg_recvlogical.c:72 #, c-format msgid "Usage:\n" msgstr "Aufruf:\n" -#: pg_basebackup.c:234 pg_receivexlog.c:67 pg_recvlogical.c:70 +#: pg_basebackup.c:236 pg_receivexlog.c:67 pg_recvlogical.c:73 #, c-format msgid " %s [OPTION]...\n" msgstr " %s [OPTION]...\n" -#: pg_basebackup.c:235 +#: pg_basebackup.c:237 #, c-format msgid "" "\n" @@ -83,17 +83,17 @@ msgstr "" "\n" "Optionen, die die Ausgabe kontrollieren:\n" -#: pg_basebackup.c:236 +#: pg_basebackup.c:238 #, c-format msgid " -D, --pgdata=DIRECTORY receive base backup into directory\n" msgstr " -D, --pgdata=VERZ Basissicherung in dieses Verzeichnis empfangen\n" -#: pg_basebackup.c:237 +#: pg_basebackup.c:239 #, c-format msgid " -F, --format=p|t output format (plain (default), tar)\n" msgstr " -F, --format=p|t Ausgabeformat (plain (Voreinstellung), tar)\n" -#: pg_basebackup.c:238 +#: pg_basebackup.c:240 #, c-format msgid "" " -r, --max-rate=RATE maximum transfer rate to transfer data directory\n" @@ -102,21 +102,21 @@ msgstr "" " -r, --max-rate=RATE maximale Transferrate für Ãœbertragung des Datenver-\n" " zeichnisses (in kB/s, oder Suffix »k« oder »M« abgeben)\n" -#: pg_basebackup.c:240 +#: pg_basebackup.c:242 #, c-format msgid "" " -R, --write-recovery-conf\n" -" write recovery.conf after backup\n" +" write recovery.conf for replication\n" msgstr "" " -R, --write-recovery-conf\n" -" recovery.conf schreiben nach der Sicherung\n" +" recovery.conf für Replikation schreiben\n" -#: pg_basebackup.c:242 pg_receivexlog.c:74 +#: pg_basebackup.c:244 pg_receivexlog.c:74 #, c-format msgid " -S, --slot=SLOTNAME replication slot to use\n" msgstr " -S, --slot=SLOTNAME zu verwendender Replikations-Slot\n" -#: pg_basebackup.c:243 +#: pg_basebackup.c:245 #, c-format msgid "" " -T, --tablespace-mapping=OLDDIR=NEWDIR\n" @@ -125,14 +125,14 @@ msgstr "" " -T, --tablespace-mapping=ALTES_VERZ=NEUES_VERZ\n" " Tablespace in ALTES_VERZ nach NEUES_VERZ verlagern\n" -#: pg_basebackup.c:245 +#: pg_basebackup.c:247 #, c-format msgid " -x, --xlog include required WAL files in backup (fetch mode)\n" msgstr "" " -x, --xlog benötigte WAL-Dateien in Sicherung einbeziehen\n" " (Fetch-Modus)\n" -#: pg_basebackup.c:246 +#: pg_basebackup.c:248 #, c-format msgid "" " -X, --xlog-method=fetch|stream\n" @@ -141,22 +141,22 @@ msgstr "" " -X, --xlog-method=fetch|stream\n" " benötigte WAL-Dateien mit angegebener Methode einbeziehen\n" -#: pg_basebackup.c:248 +#: pg_basebackup.c:250 #, c-format msgid " --xlogdir=XLOGDIR location for the transaction log directory\n" msgstr " --xlogdir=XLOGVERZ Verzeichnis für das Transaktionslog\n" -#: pg_basebackup.c:249 +#: pg_basebackup.c:251 #, c-format msgid " -z, --gzip compress tar output\n" msgstr " -z, --gzip Tar-Ausgabe komprimieren\n" -#: pg_basebackup.c:250 +#: pg_basebackup.c:252 #, c-format msgid " -Z, --compress=0-9 compress tar output with given compression level\n" msgstr " -Z, --compress=0-9 Tar-Ausgabe mit angegebenem Niveau komprimieren\n" -#: pg_basebackup.c:251 +#: pg_basebackup.c:253 #, c-format msgid "" "\n" @@ -165,7 +165,7 @@ msgstr "" "\n" "Allgemeine Optionen:\n" -#: pg_basebackup.c:252 +#: pg_basebackup.c:254 #, c-format msgid "" " -c, --checkpoint=fast|spread\n" @@ -174,32 +174,32 @@ msgstr "" " -c, --checkpoint=fast|spread\n" " schnelles oder verteiltes Checkpointing einstellen\n" -#: pg_basebackup.c:254 +#: pg_basebackup.c:256 #, c-format msgid " -l, --label=LABEL set backup label\n" msgstr " -l, --label=LABEL Backup-Label setzen\n" -#: pg_basebackup.c:255 +#: pg_basebackup.c:257 #, c-format msgid " -P, --progress show progress information\n" msgstr " -P, --progress Fortschrittsinformationen zeigen\n" -#: pg_basebackup.c:256 pg_receivexlog.c:76 pg_recvlogical.c:89 +#: pg_basebackup.c:258 pg_receivexlog.c:76 pg_recvlogical.c:92 #, c-format msgid " -v, --verbose output verbose messages\n" msgstr " -v, --verbose »Verbose«-Modus\n" -#: pg_basebackup.c:257 pg_receivexlog.c:77 pg_recvlogical.c:90 +#: pg_basebackup.c:259 pg_receivexlog.c:77 pg_recvlogical.c:93 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version Versionsinformationen anzeigen, dann beenden\n" -#: pg_basebackup.c:258 pg_receivexlog.c:78 pg_recvlogical.c:91 +#: pg_basebackup.c:260 pg_receivexlog.c:78 pg_recvlogical.c:94 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help diese Hilfe anzeigen, dann beenden\n" -#: pg_basebackup.c:259 pg_receivexlog.c:79 pg_recvlogical.c:92 +#: pg_basebackup.c:261 pg_receivexlog.c:79 pg_recvlogical.c:95 #, c-format msgid "" "\n" @@ -208,22 +208,22 @@ msgstr "" "\n" "Verbindungsoptionen:\n" -#: pg_basebackup.c:260 pg_receivexlog.c:80 +#: pg_basebackup.c:262 pg_receivexlog.c:80 #, c-format msgid " -d, --dbname=CONNSTR connection string\n" msgstr " -d, --dbname=VERBDG Verbindungsparameter\n" -#: pg_basebackup.c:261 pg_receivexlog.c:81 pg_recvlogical.c:94 +#: pg_basebackup.c:263 pg_receivexlog.c:81 pg_recvlogical.c:97 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory\n" msgstr " -h, --host=HOSTNAME Name des Datenbankservers oder Socket-Verzeichnis\n" -#: pg_basebackup.c:262 pg_receivexlog.c:82 pg_recvlogical.c:95 +#: pg_basebackup.c:264 pg_receivexlog.c:82 pg_recvlogical.c:98 #, c-format msgid " -p, --port=PORT database server port number\n" msgstr " -p, --port=PORT Portnummer des Datenbankservers\n" -#: pg_basebackup.c:263 +#: pg_basebackup.c:265 #, c-format msgid "" " -s, --status-interval=INTERVAL\n" @@ -232,22 +232,22 @@ msgstr "" " -s, --status-interval=INTERVALL\n" " Zeit zwischen an Server gesendeten Statuspaketen (in Sekunden)\n" -#: pg_basebackup.c:265 pg_receivexlog.c:83 pg_recvlogical.c:96 +#: pg_basebackup.c:267 pg_receivexlog.c:83 pg_recvlogical.c:99 #, c-format msgid " -U, --username=NAME connect as specified database user\n" msgstr " -U, --username=NAME Datenbankbenutzername\n" -#: pg_basebackup.c:266 pg_receivexlog.c:84 pg_recvlogical.c:97 +#: pg_basebackup.c:268 pg_receivexlog.c:84 pg_recvlogical.c:100 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password niemals nach Passwort fragen\n" -#: pg_basebackup.c:267 pg_receivexlog.c:85 pg_recvlogical.c:98 +#: pg_basebackup.c:269 pg_receivexlog.c:85 pg_recvlogical.c:101 #, c-format msgid " -W, --password force password prompt (should happen automatically)\n" msgstr " -W, --password nach Passwort fragen (sollte automatisch geschehen)\n" -#: pg_basebackup.c:268 pg_receivexlog.c:89 pg_recvlogical.c:99 +#: pg_basebackup.c:270 pg_receivexlog.c:89 pg_recvlogical.c:102 #, c-format msgid "" "\n" @@ -256,374 +256,384 @@ msgstr "" "\n" "Berichten Sie Fehler an .\n" -#: pg_basebackup.c:311 +#: pg_basebackup.c:313 #, c-format msgid "%s: could not read from ready pipe: %s\n" msgstr "%s: konnte nicht aus bereiter Pipe lesen: %s\n" -#: pg_basebackup.c:319 pg_basebackup.c:422 pg_basebackup.c:1887 -#: streamutil.c:285 +#: pg_basebackup.c:321 pg_basebackup.c:424 pg_basebackup.c:1906 +#: streamutil.c:293 #, c-format msgid "%s: could not parse transaction log location \"%s\"\n" msgstr "%s: konnte Transaktionslogposition »%s« nicht interpretieren\n" -#: pg_basebackup.c:435 +#: pg_basebackup.c:437 #, c-format msgid "%s: could not create pipe for background process: %s\n" msgstr "%s: konnte Pipe für Hintergrundprozess nicht erzeugen: %s\n" -#: pg_basebackup.c:460 pg_basebackup.c:515 pg_basebackup.c:1263 +#: pg_basebackup.c:462 pg_basebackup.c:517 pg_basebackup.c:1265 #, c-format msgid "%s: could not create directory \"%s\": %s\n" msgstr "%s: konnte Verzeichnis »%s« nicht erzeugen: %s\n" -#: pg_basebackup.c:478 +#: pg_basebackup.c:480 #, c-format msgid "%s: could not create background process: %s\n" msgstr "%s: konnte Hintergrundprozess nicht erzeugen: %s\n" -#: pg_basebackup.c:490 +#: pg_basebackup.c:492 #, c-format msgid "%s: could not create background thread: %s\n" msgstr "%s: konnte Hintergrund-Thread nicht erzeugen: %s\n" -#: pg_basebackup.c:534 +#: pg_basebackup.c:536 #, c-format msgid "%s: directory \"%s\" exists but is not empty\n" msgstr "%s: Verzeichnis »%s« existiert aber ist nicht leer\n" -#: pg_basebackup.c:542 +#: pg_basebackup.c:544 #, c-format msgid "%s: could not access directory \"%s\": %s\n" msgstr "%s: konnte nicht auf Verzeichnis »%s« zugreifen: %s\n" -#: pg_basebackup.c:604 +#: pg_basebackup.c:606 #, c-format msgid "%*s/%s kB (100%%), %d/%d tablespace %*s" msgid_plural "%*s/%s kB (100%%), %d/%d tablespaces %*s" msgstr[0] "%*s/%s kB (100%%), %d/%d Tablespace %*s" msgstr[1] "%*s/%s kB (100%%), %d/%d Tablespaces %*s" -#: pg_basebackup.c:616 +#: pg_basebackup.c:618 #, c-format msgid "%*s/%s kB (%d%%), %d/%d tablespace (%s%-*.*s)" msgid_plural "%*s/%s kB (%d%%), %d/%d tablespaces (%s%-*.*s)" msgstr[0] "%*s/%s kB (%d%%), %d/%d Tablespace (%s%-*.*s)" msgstr[1] "%*s/%s kB (%d%%), %d/%d Tablespaces (%s%-*.*s)" -#: pg_basebackup.c:632 +#: pg_basebackup.c:634 #, c-format msgid "%*s/%s kB (%d%%), %d/%d tablespace" msgid_plural "%*s/%s kB (%d%%), %d/%d tablespaces" msgstr[0] "%*s/%s kB (%d%%), %d/%d Tablespace" msgstr[1] "%*s/%s kB (%d%%), %d/%d Tablespaces" -#: pg_basebackup.c:654 +#: pg_basebackup.c:656 #, c-format msgid "%s: transfer rate \"%s\" is not a valid value\n" msgstr "%s: Transferrate »%s« ist kein gültiger Wert\n" -#: pg_basebackup.c:661 +#: pg_basebackup.c:663 #, c-format msgid "%s: invalid transfer rate \"%s\": %s\n" msgstr "%s: ungültige Transferrate »%s«: %s\n" -#: pg_basebackup.c:671 +#: pg_basebackup.c:673 #, c-format msgid "%s: transfer rate must be greater than zero\n" msgstr "%s: Transferrate muss größer als null sein\n" -#: pg_basebackup.c:705 +#: pg_basebackup.c:707 #, c-format msgid "%s: invalid --max-rate unit: \"%s\"\n" msgstr "%s: ungültige Einheit für --max-rate: »%s«\n" -#: pg_basebackup.c:714 +#: pg_basebackup.c:716 #, c-format msgid "%s: transfer rate \"%s\" exceeds integer range\n" msgstr "%s: Transferrate »%s« überschreitet Bereich für ganze Zahlen\n" -#: pg_basebackup.c:726 +#: pg_basebackup.c:728 #, c-format msgid "%s: transfer rate \"%s\" is out of range\n" msgstr "%s: Transferrate »%s« ist außerhalb des gültigen Bereichs\n" -#: pg_basebackup.c:750 +#: pg_basebackup.c:752 #, c-format msgid "%s: could not write to compressed file \"%s\": %s\n" msgstr "%s: konnte nicht in komprimierte Datei »%s« schreiben: %s\n" -#: pg_basebackup.c:760 pg_basebackup.c:1357 pg_basebackup.c:1582 +#: pg_basebackup.c:762 pg_basebackup.c:1359 pg_basebackup.c:1584 #, c-format msgid "%s: could not write to file \"%s\": %s\n" msgstr "%s: konnte nicht in Datei »%s« schreiben: %s\n" -#: pg_basebackup.c:815 pg_basebackup.c:836 pg_basebackup.c:864 +#: pg_basebackup.c:817 pg_basebackup.c:838 pg_basebackup.c:866 #, c-format msgid "%s: could not set compression level %d: %s\n" msgstr "%s: konnte Komprimierungsniveau %d nicht setzen: %s\n" -#: pg_basebackup.c:885 +#: pg_basebackup.c:887 #, c-format msgid "%s: could not create compressed file \"%s\": %s\n" msgstr "%s: konnte komprimierte Datei »%s« nicht erzeugen: %s\n" -#: pg_basebackup.c:896 pg_basebackup.c:1317 pg_basebackup.c:1575 +#: pg_basebackup.c:898 pg_basebackup.c:1319 pg_basebackup.c:1577 #, c-format msgid "%s: could not create file \"%s\": %s\n" msgstr "%s: konnte Datei »%s« nicht erzeugen: %s\n" -#: pg_basebackup.c:908 pg_basebackup.c:1172 +#: pg_basebackup.c:910 pg_basebackup.c:1174 #, c-format msgid "%s: could not get COPY data stream: %s" msgstr "%s: konnte COPY-Datenstrom nicht empfangen: %s" -#: pg_basebackup.c:965 +#: pg_basebackup.c:967 #, c-format msgid "%s: could not close compressed file \"%s\": %s\n" msgstr "%s: konnte komprimierte Datei »%s« nicht schließen: %s\n" -#: pg_basebackup.c:978 pg_recvlogical.c:577 receivelog.c:203 receivelog.c:351 -#: receivelog.c:738 +#: pg_basebackup.c:980 pg_recvlogical.c:580 receivelog.c:206 receivelog.c:354 +#: receivelog.c:743 #, c-format msgid "%s: could not close file \"%s\": %s\n" msgstr "%s: konnte Datei »%s« nicht schließen: %s\n" -#: pg_basebackup.c:989 pg_basebackup.c:1201 pg_recvlogical.c:443 -#: receivelog.c:1019 +#: pg_basebackup.c:991 pg_basebackup.c:1203 pg_recvlogical.c:446 +#: receivelog.c:1024 #, c-format msgid "%s: could not read COPY data: %s" msgstr "%s: konnte COPY-Daten nicht lesen: %s" -#: pg_basebackup.c:1215 +#: pg_basebackup.c:1217 #, c-format msgid "%s: invalid tar block header size: %d\n" msgstr "%s: ungültige Tar-Block-Kopf-Größe: %d\n" -#: pg_basebackup.c:1271 +#: pg_basebackup.c:1273 #, c-format msgid "%s: could not set permissions on directory \"%s\": %s\n" msgstr "%s: konnte Zugriffsrechte des Verzeichnisses »%s« nicht setzen: %s\n" -#: pg_basebackup.c:1295 +#: pg_basebackup.c:1297 #, c-format msgid "%s: could not create symbolic link from \"%s\" to \"%s\": %s\n" msgstr "%s: konnte symbolische Verknüpfung von »%s« nach »%s« nicht erzeugen: %s\n" -#: pg_basebackup.c:1304 +#: pg_basebackup.c:1306 #, c-format msgid "%s: unrecognized link indicator \"%c\"\n" msgstr "%s: unbekannter Verknüpfungsindikator »%c«\n" -#: pg_basebackup.c:1324 +#: pg_basebackup.c:1326 #, c-format msgid "%s: could not set permissions on file \"%s\": %s\n" msgstr "%s: konnte Rechte der Datei »%s« nicht setzen: %s\n" -#: pg_basebackup.c:1383 +#: pg_basebackup.c:1385 #, c-format msgid "%s: COPY stream ended before last file was finished\n" msgstr "%s: COPY-Strom endete vor dem Ende der letzten Datei\n" -#: pg_basebackup.c:1469 pg_basebackup.c:1489 pg_basebackup.c:1496 -#: pg_basebackup.c:1550 +#: pg_basebackup.c:1471 pg_basebackup.c:1491 pg_basebackup.c:1498 +#: pg_basebackup.c:1552 #, c-format msgid "%s: out of memory\n" msgstr "%s: Speicher aufgebraucht\n" -#: pg_basebackup.c:1627 +#: pg_basebackup.c:1629 #, c-format msgid "%s: incompatible server version %s\n" msgstr "%s: inkompatible Serverversion %s\n" -#: pg_basebackup.c:1674 pg_recvlogical.c:261 receivelog.c:536 receivelog.c:587 -#: receivelog.c:627 streamutil.c:255 streamutil.c:359 streamutil.c:405 +#: pg_basebackup.c:1666 +#, c-format +msgid "%s: initiating base backup, waiting for checkpoint to complete\n" +msgstr "%s: Basissicherung eingeleitet, warte auf Abschluss des Checkpoints\n" + +#: pg_basebackup.c:1684 pg_recvlogical.c:264 receivelog.c:541 receivelog.c:592 +#: receivelog.c:632 streamutil.c:263 streamutil.c:367 streamutil.c:413 #, c-format msgid "%s: could not send replication command \"%s\": %s" msgstr "%s: konnte Replikationsbefehl »%s« nicht senden: %s" -#: pg_basebackup.c:1685 +#: pg_basebackup.c:1695 #, c-format msgid "%s: could not initiate base backup: %s" msgstr "%s: konnte Basissicherung nicht starten: %s" -#: pg_basebackup.c:1692 +#: pg_basebackup.c:1702 #, c-format msgid "%s: server returned unexpected response to BASE_BACKUP command; got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: unerwartete Antwort auf Befehl BASE_BACKUP: %d Zeilen und %d Felder erhalten, %d Zeilen und %d Felder erwartet\n" -#: pg_basebackup.c:1712 +#: pg_basebackup.c:1710 +#, c-format +msgid "%s: checkpoint completed\n" +msgstr "%s: Checkpoint abgeschlossen\n" + +#: pg_basebackup.c:1725 #, c-format msgid "transaction log start point: %s on timeline %u\n" msgstr "Transaktionslog-Startpunkt: %s auf Zeitleiste %u\n" -#: pg_basebackup.c:1721 +#: pg_basebackup.c:1734 #, c-format msgid "%s: could not get backup header: %s" msgstr "%s: konnte Kopf der Sicherung nicht empfangen: %s" -#: pg_basebackup.c:1727 +#: pg_basebackup.c:1740 #, c-format msgid "%s: no data returned from server\n" msgstr "%s: keine Daten vom Server zurückgegeben\n" -#: pg_basebackup.c:1759 +#: pg_basebackup.c:1772 #, c-format msgid "%s: can only write single tablespace to stdout, database has %d\n" msgstr "%s: kann nur einen einzelnen Tablespace auf die Standardausgabe schreiben, Datenbank hat %d\n" -#: pg_basebackup.c:1771 +#: pg_basebackup.c:1784 #, c-format msgid "%s: starting background WAL receiver\n" msgstr "%s: Hintergrund-WAL-Receiver wird gestartet\n" -#: pg_basebackup.c:1802 +#: pg_basebackup.c:1815 #, c-format msgid "%s: could not get transaction log end position from server: %s" msgstr "%s: konnte Transaktionslogendposition nicht vom Server empfangen: %s" -#: pg_basebackup.c:1809 +#: pg_basebackup.c:1822 #, c-format msgid "%s: no transaction log end position returned from server\n" msgstr "%s: kein Transaktionslogendpunkt vom Server zurückgegeben\n" -#: pg_basebackup.c:1821 +#: pg_basebackup.c:1834 #, c-format msgid "%s: final receive failed: %s" msgstr "%s: letztes Empfangen fehlgeschlagen: %s" -#: pg_basebackup.c:1839 +#: pg_basebackup.c:1858 #, c-format msgid "%s: waiting for background process to finish streaming ...\n" msgstr "%s: warte bis Hintergrundprozess Streaming beendet hat ...\n" -#: pg_basebackup.c:1845 +#: pg_basebackup.c:1864 #, c-format msgid "%s: could not send command to background pipe: %s\n" msgstr "%s: konnte Befehl nicht an Hintergrund-Pipe senden: %s\n" -#: pg_basebackup.c:1854 +#: pg_basebackup.c:1873 #, c-format msgid "%s: could not wait for child process: %s\n" msgstr "%s: konnte nicht auf Kindprozess warten: %s\n" -#: pg_basebackup.c:1860 +#: pg_basebackup.c:1879 #, c-format msgid "%s: child %d died, expected %d\n" msgstr "%s: Kindprozess %d endete, aber %d wurde erwartet\n" -#: pg_basebackup.c:1866 +#: pg_basebackup.c:1885 #, c-format msgid "%s: child process did not exit normally\n" msgstr "%s: Kindprozess hat nicht normal beendet\n" -#: pg_basebackup.c:1872 +#: pg_basebackup.c:1891 #, c-format msgid "%s: child process exited with error %d\n" msgstr "%s: Kindprozess hat mit Fehler %d beendet\n" -#: pg_basebackup.c:1899 +#: pg_basebackup.c:1918 #, c-format msgid "%s: could not wait for child thread: %s\n" msgstr "%s: konnte nicht auf Kind-Thread warten: %s\n" -#: pg_basebackup.c:1906 +#: pg_basebackup.c:1925 #, c-format msgid "%s: could not get child thread exit status: %s\n" msgstr "%s: konnte Statuscode des Kind-Threads nicht ermitteln: %s\n" -#: pg_basebackup.c:1912 +#: pg_basebackup.c:1931 #, c-format msgid "%s: child thread exited with error %u\n" msgstr "%s: Kind-Thread hat mit Fehler %u beendet\n" -#: pg_basebackup.c:2002 +#: pg_basebackup.c:2021 #, c-format msgid "%s: invalid output format \"%s\", must be \"plain\" or \"tar\"\n" msgstr "%s: ungültiges Ausgabeformat »%s«, muss »plain« oder »tar« sein\n" -#: pg_basebackup.c:2023 pg_basebackup.c:2035 +#: pg_basebackup.c:2042 pg_basebackup.c:2054 #, c-format msgid "%s: cannot specify both --xlog and --xlog-method\n" msgstr "%s: --xlog und --xlog-method können nicht zusammen verwendet werden\n" -#: pg_basebackup.c:2050 +#: pg_basebackup.c:2069 #, c-format msgid "%s: invalid xlog-method option \"%s\", must be \"fetch\" or \"stream\"\n" msgstr "%s: ungültige Option »%s« für --xlog-method, muss »fetch« oder »stream« sein\n" -#: pg_basebackup.c:2072 +#: pg_basebackup.c:2091 #, c-format msgid "%s: invalid compression level \"%s\"\n" msgstr "%s: ungültiges Komprimierungsniveau »%s«\n" -#: pg_basebackup.c:2084 +#: pg_basebackup.c:2103 #, c-format msgid "%s: invalid checkpoint argument \"%s\", must be \"fast\" or \"spread\"\n" msgstr "%s: ungültiges Checkpoint-Argument »%s«, muss »fast« oder »spread« sein\n" -#: pg_basebackup.c:2111 pg_receivexlog.c:445 pg_recvlogical.c:760 +#: pg_basebackup.c:2130 pg_receivexlog.c:445 pg_recvlogical.c:763 #, c-format msgid "%s: invalid status interval \"%s\"\n" msgstr "%s: ungültiges Statusintervall »%s«\n" -#: pg_basebackup.c:2127 pg_basebackup.c:2141 pg_basebackup.c:2152 -#: pg_basebackup.c:2165 pg_basebackup.c:2175 pg_basebackup.c:2185 -#: pg_basebackup.c:2197 pg_basebackup.c:2208 pg_receivexlog.c:477 +#: pg_basebackup.c:2146 pg_basebackup.c:2160 pg_basebackup.c:2171 +#: pg_basebackup.c:2184 pg_basebackup.c:2194 pg_basebackup.c:2204 +#: pg_basebackup.c:2216 pg_basebackup.c:2227 pg_receivexlog.c:477 #: pg_receivexlog.c:491 pg_receivexlog.c:499 pg_receivexlog.c:509 -#: pg_receivexlog.c:520 pg_recvlogical.c:787 pg_recvlogical.c:801 -#: pg_recvlogical.c:812 pg_recvlogical.c:820 pg_recvlogical.c:828 -#: pg_recvlogical.c:836 pg_recvlogical.c:844 pg_recvlogical.c:852 +#: pg_receivexlog.c:520 pg_recvlogical.c:790 pg_recvlogical.c:804 +#: pg_recvlogical.c:815 pg_recvlogical.c:823 pg_recvlogical.c:831 +#: pg_recvlogical.c:839 pg_recvlogical.c:847 pg_recvlogical.c:855 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Versuchen Sie »%s --help« für weitere Informationen.\n" -#: pg_basebackup.c:2139 pg_receivexlog.c:489 pg_recvlogical.c:799 +#: pg_basebackup.c:2158 pg_receivexlog.c:489 pg_recvlogical.c:802 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: zu viele Kommandozeilenargumente (das erste ist »%s«)\n" -#: pg_basebackup.c:2151 pg_receivexlog.c:519 +#: pg_basebackup.c:2170 pg_receivexlog.c:519 #, c-format msgid "%s: no target directory specified\n" msgstr "%s: kein Zielverzeichnis angegeben\n" -#: pg_basebackup.c:2163 +#: pg_basebackup.c:2182 #, c-format msgid "%s: only tar mode backups can be compressed\n" msgstr "%s: nur Sicherungen im Tar-Modus können komprimiert werden\n" -#: pg_basebackup.c:2173 +#: pg_basebackup.c:2192 #, c-format msgid "%s: WAL streaming can only be used in plain mode\n" msgstr "%s: WAL-Streaming kann nur im »plain«-Modus verwendet werden\n" -#: pg_basebackup.c:2183 +#: pg_basebackup.c:2202 #, c-format msgid "%s: replication slots can only be used with WAL streaming\n" msgstr "%s: Replikations-Slots können nur mit WAL-Streaming verwendet werden\n" -#: pg_basebackup.c:2195 +#: pg_basebackup.c:2214 #, c-format msgid "%s: transaction log directory location can only be specified in plain mode\n" msgstr "%s: Transaktionslogverzeichnis kann nur im »plain«-Modus angegeben werden\n" -#: pg_basebackup.c:2206 +#: pg_basebackup.c:2225 #, c-format msgid "%s: transaction log directory location must be an absolute path\n" msgstr "%s: Transaktionslogverzeichnis muss absoluten Pfad haben\n" -#: pg_basebackup.c:2218 +#: pg_basebackup.c:2237 #, c-format msgid "%s: this build does not support compression\n" msgstr "%s: diese Installation unterstützt keine Komprimierung\n" -#: pg_basebackup.c:2245 +#: pg_basebackup.c:2264 #, c-format msgid "%s: could not create symbolic link \"%s\": %s\n" msgstr "%s: konnte symbolische Verknüpfung »%s« nicht erzeugen: %s\n" -#: pg_basebackup.c:2250 +#: pg_basebackup.c:2269 #, c-format msgid "%s: symlinks are not supported on this platform\n" msgstr "%s: symbolische Verknüpfungen werden auf dieser Plattform nicht unterstützt\n" @@ -637,7 +647,7 @@ msgstr "" "%s empfängt PostgreSQL-Streaming-Transaktionslogs.\n" "\n" -#: pg_receivexlog.c:68 pg_recvlogical.c:75 +#: pg_receivexlog.c:68 pg_recvlogical.c:78 #, c-format msgid "" "\n" @@ -651,17 +661,17 @@ msgstr "" msgid " -D, --directory=DIR receive transaction log files into this directory\n" msgstr " -D, --directory=VERZ Transaktionslogdateien in dieses Verzeichnis empfangen\n" -#: pg_receivexlog.c:70 pg_recvlogical.c:79 +#: pg_receivexlog.c:70 pg_recvlogical.c:82 #, c-format msgid " --if-not-exists do not error if slot already exists when creating a slot\n" msgstr " --if-not-exists keinen Fehler ausgeben, wenn Slot beim Erzeugen schon existiert\n" -#: pg_receivexlog.c:71 pg_recvlogical.c:81 +#: pg_receivexlog.c:71 pg_recvlogical.c:84 #, c-format msgid " -n, --no-loop do not loop on connection lost\n" msgstr " -n, --no-loop bei Verbindungsverlust nicht erneut probieren\n" -#: pg_receivexlog.c:72 pg_recvlogical.c:86 +#: pg_receivexlog.c:72 pg_recvlogical.c:89 #, c-format msgid "" " -s, --status-interval=SECS\n" @@ -684,12 +694,12 @@ msgstr "" "\n" "Optionale Aktionen:\n" -#: pg_receivexlog.c:87 pg_recvlogical.c:72 +#: pg_receivexlog.c:87 pg_recvlogical.c:75 #, c-format msgid " --create-slot create a new replication slot (for the slot's name see --slot)\n" msgstr " --create-slot neuen Replikations-Slot erzeugen (Slot-Name siehe --slot)\n" -#: pg_receivexlog.c:88 pg_recvlogical.c:73 +#: pg_receivexlog.c:88 pg_recvlogical.c:76 #, c-format msgid " --drop-slot drop the replication slot (for the slot's name see --slot)\n" msgstr " --drop-slot Replikations-Slot löschen (Slot-Name siehe --slot)\n" @@ -719,7 +729,7 @@ msgstr "%s: konnte Verzeichnis »%s« nicht öffnen: %s\n" msgid "%s: could not close directory \"%s\": %s\n" msgstr "%s: konnte Verzeichnis »%s« nicht schließen: %s\n" -#: pg_receivexlog.c:218 pg_recvlogical.c:343 +#: pg_receivexlog.c:218 pg_recvlogical.c:346 #, c-format msgid "%s: could not stat file \"%s\": %s\n" msgstr "%s: konnte »stat« für Datei »%s« nicht ausführen: %s\n" @@ -739,7 +749,7 @@ msgstr "%s: konnte Verzeichnis »%s« nicht lesen: %s\n" msgid "%s: starting log streaming at %X/%X (timeline %u)\n" msgstr "%s: starte Log-Streaming bei %X/%X (Zeitleiste %u)\n" -#: pg_receivexlog.c:426 pg_recvlogical.c:707 +#: pg_receivexlog.c:426 pg_recvlogical.c:710 #, c-format msgid "%s: invalid port number \"%s\"\n" msgstr "%s: ungültige Portnummer »%s«\n" @@ -760,28 +770,28 @@ msgstr "%s: für %s muss ein Slot mit --slot angegeben werden\n" msgid "%s: replication connection using slot \"%s\" is unexpectedly database specific\n" msgstr "%s: Replikationsverbindung, die Slot »%s« verwendet, ist unerwarteterweise datenbankspezifisch\n" -#: pg_receivexlog.c:574 pg_recvlogical.c:892 +#: pg_receivexlog.c:574 pg_recvlogical.c:895 #, c-format msgid "%s: dropping replication slot \"%s\"\n" msgstr "%s: lösche Replikations-Slot »%s«\n" -#: pg_receivexlog.c:587 pg_recvlogical.c:904 +#: pg_receivexlog.c:587 pg_recvlogical.c:907 #, c-format msgid "%s: creating replication slot \"%s\"\n" msgstr "%s: erzeuge Replikations-Slot »%s«\n" -#: pg_receivexlog.c:614 pg_recvlogical.c:930 +#: pg_receivexlog.c:614 pg_recvlogical.c:933 #, c-format msgid "%s: disconnected\n" msgstr "%s: Verbindung beendet\n" #. translator: check source for value for %d -#: pg_receivexlog.c:621 pg_recvlogical.c:937 +#: pg_receivexlog.c:621 pg_recvlogical.c:940 #, c-format msgid "%s: disconnected; waiting %d seconds to try again\n" msgstr "%s: Verbindung beendet; erneuter Versuch in %d Sekunden\n" -#: pg_recvlogical.c:67 +#: pg_recvlogical.c:70 #, c-format msgid "" "%s controls PostgreSQL logical decoding streams.\n" @@ -790,7 +800,7 @@ msgstr "" "%s kontrolliert logische Dekodierungsströme von PostgreSQL.\n" "\n" -#: pg_recvlogical.c:71 +#: pg_recvlogical.c:74 #, c-format msgid "" "\n" @@ -799,17 +809,17 @@ msgstr "" "\n" "Auszuführende Aktion:\n" -#: pg_recvlogical.c:74 +#: pg_recvlogical.c:77 #, c-format msgid " --start start streaming in a replication slot (for the slot's name see --slot)\n" msgstr " --start Streaming in einem Replikations-Slot starten (Slot-Name siehe --slot)\n" -#: pg_recvlogical.c:76 +#: pg_recvlogical.c:79 #, c-format msgid " -f, --file=FILE receive log into this file, - for stdout\n" msgstr " -f, --file=DATEI Log in diese Datei empfangen, - für Standardausgabe\n" -#: pg_recvlogical.c:77 +#: pg_recvlogical.c:80 #, c-format msgid "" " -F --fsync-interval=SECS\n" @@ -818,12 +828,12 @@ msgstr "" " -F --fsync-interval=SEK\n" " Zeit zwischen Fsyncs der Ausgabedatei (Standard: %d)\n" -#: pg_recvlogical.c:80 +#: pg_recvlogical.c:83 #, c-format msgid " -I, --startpos=LSN where in an existing slot should the streaming start\n" msgstr " -I, --startpos=LSN wo in einem bestehenden Slot das Streaming starten soll\n" -#: pg_recvlogical.c:82 +#: pg_recvlogical.c:85 #, c-format msgid "" " -o, --option=NAME[=VALUE]\n" @@ -834,313 +844,313 @@ msgstr "" " Option NAME mit optionalem Wert WERT an den\n" " Ausgabe-Plugin übergeben\n" -#: pg_recvlogical.c:85 +#: pg_recvlogical.c:88 #, c-format msgid " -P, --plugin=PLUGIN use output plugin PLUGIN (default: %s)\n" msgstr " -P, --plugin=PLUGIN Ausgabe-Plugin PLUGIN verwenden (Standard: %s)\n" -#: pg_recvlogical.c:88 +#: pg_recvlogical.c:91 #, c-format msgid " -S, --slot=SLOTNAME name of the logical replication slot\n" msgstr " -S, --slot=SLOTNAME Name des logischen Replikations-Slots\n" -#: pg_recvlogical.c:93 +#: pg_recvlogical.c:96 #, c-format msgid " -d, --dbname=DBNAME database to connect to\n" msgstr " -d, --dbname=DBNAME Datenbank, mit der verbunden werden soll\n" -#: pg_recvlogical.c:126 +#: pg_recvlogical.c:129 #, c-format msgid "%s: confirming write up to %X/%X, flush to %X/%X (slot %s)\n" msgstr "%s: bestätige Schreiben bis %X/%X, Flush bis %X/%X (Slot %s)\n" -#: pg_recvlogical.c:151 receivelog.c:404 +#: pg_recvlogical.c:154 receivelog.c:407 #, c-format msgid "%s: could not send feedback packet: %s" msgstr "%s: konnte Rückmeldungspaket nicht senden: %s" -#: pg_recvlogical.c:190 +#: pg_recvlogical.c:193 #, c-format msgid "%s: could not fsync log file \"%s\": %s\n" msgstr "%s: konnte Logdatei »%s« nicht fsyncen: %s\n" -#: pg_recvlogical.c:229 +#: pg_recvlogical.c:232 #, c-format msgid "%s: starting log streaming at %X/%X (slot %s)\n" msgstr "%s: starte Log-Streaming bei %X/%X (Slot %s)\n" -#: pg_recvlogical.c:271 +#: pg_recvlogical.c:274 #, c-format msgid "%s: streaming initiated\n" msgstr "%s: Streaming eingeleitet\n" -#: pg_recvlogical.c:336 +#: pg_recvlogical.c:339 #, c-format msgid "%s: could not open log file \"%s\": %s\n" msgstr "%s: konnte Logdatei »%s« nicht öffnen: %s\n" -#: pg_recvlogical.c:366 receivelog.c:933 +#: pg_recvlogical.c:369 receivelog.c:938 #, c-format msgid "%s: invalid socket: %s" msgstr "%s: ungültiges Socket: %s" -#: pg_recvlogical.c:420 receivelog.c:955 +#: pg_recvlogical.c:423 receivelog.c:960 #, c-format msgid "%s: select() failed: %s\n" msgstr "%s: select() fehlgeschlagen: %s\n" -#: pg_recvlogical.c:429 receivelog.c:1005 +#: pg_recvlogical.c:432 receivelog.c:1010 #, c-format msgid "%s: could not receive data from WAL stream: %s" msgstr "%s: konnte keine Daten vom WAL-Stream empfangen: %s" -#: pg_recvlogical.c:470 pg_recvlogical.c:509 receivelog.c:1050 -#: receivelog.c:1117 +#: pg_recvlogical.c:473 pg_recvlogical.c:512 receivelog.c:1055 +#: receivelog.c:1122 #, c-format msgid "%s: streaming header too small: %d\n" msgstr "%s: Streaming-Header zu klein: %d\n" -#: pg_recvlogical.c:492 receivelog.c:898 +#: pg_recvlogical.c:495 receivelog.c:903 #, c-format msgid "%s: unrecognized streaming header: \"%c\"\n" msgstr "%s: unbekannter Streaming-Header: »%c«\n" -#: pg_recvlogical.c:538 pg_recvlogical.c:552 +#: pg_recvlogical.c:541 pg_recvlogical.c:555 #, c-format msgid "%s: could not write %u bytes to log file \"%s\": %s\n" msgstr "%s: konnte %u Bytes nicht in Logdatei »%s« schreiben: %s\n" -#: pg_recvlogical.c:563 receivelog.c:691 receivelog.c:729 +#: pg_recvlogical.c:566 receivelog.c:696 receivelog.c:734 #, c-format msgid "%s: unexpected termination of replication stream: %s" msgstr "%s: unerwarteter Abbruch des Replikations-Streams: %s" -#: pg_recvlogical.c:686 +#: pg_recvlogical.c:689 #, c-format msgid "%s: invalid fsync interval \"%s\"\n" msgstr "%s: ungültiges Fsync-Intervall »%s«\n" -#: pg_recvlogical.c:727 +#: pg_recvlogical.c:730 #, c-format msgid "%s: could not parse start position \"%s\"\n" msgstr "%s: konnte Startposition »%s« nicht parsen\n" -#: pg_recvlogical.c:811 +#: pg_recvlogical.c:814 #, c-format msgid "%s: no slot specified\n" msgstr "%s: kein Slot angegeben\n" -#: pg_recvlogical.c:819 +#: pg_recvlogical.c:822 #, c-format msgid "%s: no target file specified\n" msgstr "%s: keine Zieldatei angegeben\n" -#: pg_recvlogical.c:827 +#: pg_recvlogical.c:830 #, c-format msgid "%s: no database specified\n" msgstr "%s: keine Datenbank angegeben\n" -#: pg_recvlogical.c:835 +#: pg_recvlogical.c:838 #, c-format msgid "%s: at least one action needs to be specified\n" msgstr "%s: mindestens eine Aktion muss angegeben werden\n" -#: pg_recvlogical.c:843 +#: pg_recvlogical.c:846 #, c-format msgid "%s: cannot use --create-slot or --start together with --drop-slot\n" msgstr "%s: --create-slot oder --start kann nicht zusammen mit --drop-slot verwendet werden\n" -#: pg_recvlogical.c:851 +#: pg_recvlogical.c:854 #, c-format msgid "%s: cannot use --create-slot or --drop-slot together with --startpos\n" msgstr "%s: --create-slot oder --drop-slot kann nicht zusammen mit --startpos verwendet werden\n" -#: pg_recvlogical.c:882 +#: pg_recvlogical.c:885 #, c-format msgid "%s: could not establish database-specific replication connection\n" msgstr "%s: konnte keine datenbankspezifische Replikationsverbindung herstellen\n" -#: receivelog.c:66 +#: receivelog.c:69 #, c-format msgid "%s: could not create archive status file \"%s\": %s\n" msgstr "%s: konnte Archivstatusdatei »%s« nicht erzeugen: %s\n" -#: receivelog.c:73 receivelog.c:196 receivelog.c:344 receivelog.c:828 -#: receivelog.c:1071 +#: receivelog.c:76 receivelog.c:199 receivelog.c:347 receivelog.c:833 +#: receivelog.c:1076 #, c-format msgid "%s: could not fsync file \"%s\": %s\n" msgstr "%s: konnte Datei »%s« nicht fsyncen: %s\n" -#: receivelog.c:111 +#: receivelog.c:114 #, c-format msgid "%s: could not open transaction log file \"%s\": %s\n" msgstr "%s: konnte Transaktionslogdatei »%s« nicht öffnen: %s\n" -#: receivelog.c:123 +#: receivelog.c:126 #, c-format msgid "%s: could not stat transaction log file \"%s\": %s\n" msgstr "%s: konnte »stat« für Transaktionslogdatei »%s« nicht ausführen: %s\n" -#: receivelog.c:137 +#: receivelog.c:140 #, c-format msgid "%s: transaction log file \"%s\" has %d bytes, should be 0 or %d\n" msgstr "%s: Transaktionslogdatei »%s« hat %d Bytes, sollte 0 oder %d sein\n" -#: receivelog.c:150 +#: receivelog.c:153 #, c-format msgid "%s: could not pad transaction log file \"%s\": %s\n" msgstr "%s: konnte Transaktionslogdatei »%s« nicht auffüllen: %s\n" -#: receivelog.c:163 +#: receivelog.c:166 #, c-format msgid "%s: could not seek to beginning of transaction log file \"%s\": %s\n" msgstr "%s: konnte Positionszeiger nicht an den Anfang der Transaktionslogdatei »%s« setzen: %s\n" -#: receivelog.c:189 +#: receivelog.c:192 #, c-format msgid "%s: could not determine seek position in file \"%s\": %s\n" msgstr "%s: konnte Positionszeiger in Datei »%s« nicht ermitteln: %s\n" -#: receivelog.c:222 +#: receivelog.c:225 #, c-format msgid "%s: could not rename file \"%s\": %s\n" msgstr "%s: konnte Datei »%s« nicht umbenennen: %s\n" -#: receivelog.c:229 +#: receivelog.c:232 #, c-format msgid "%s: not renaming \"%s%s\", segment is not complete\n" msgstr "%s: »%s%s« wird nicht umbenannt, Segment ist noch nicht vollständig\n" -#: receivelog.c:275 +#: receivelog.c:278 #, c-format msgid "%s: could not open timeline history file \"%s\": %s\n" msgstr "%s: konnte Zeitleisten-History-Datei »%s« nicht öffnen: %s\n" -#: receivelog.c:302 +#: receivelog.c:305 #, c-format msgid "%s: server reported unexpected history file name for timeline %u: %s\n" msgstr "%s: Server berichtete unerwarteten History-Dateinamen für Zeitleiste %u: %s\n" -#: receivelog.c:319 +#: receivelog.c:322 #, c-format msgid "%s: could not create timeline history file \"%s\": %s\n" msgstr "%s: konnte Zeitleisten-History-Datei »%s« nicht erzeugen: %s\n" -#: receivelog.c:336 +#: receivelog.c:339 #, c-format msgid "%s: could not write timeline history file \"%s\": %s\n" msgstr "%s: konnte Zeitleisten-History-Datei »%s« nicht schreiben: %s\n" -#: receivelog.c:361 +#: receivelog.c:364 #, c-format msgid "%s: could not rename file \"%s\" to \"%s\": %s\n" msgstr "%s: konnte Datei »%s« nicht in »%s« umbenennen: %s\n" -#: receivelog.c:438 +#: receivelog.c:441 #, c-format msgid "%s: incompatible server version %s; client does not support streaming from server versions older than %s\n" msgstr "%s: inkompatible Serverversion %s; Client unterstützt Streaming nicht mit Serverversionen älter als %s\n" -#: receivelog.c:448 +#: receivelog.c:451 #, c-format msgid "%s: incompatible server version %s; client does not support streaming from server versions newer than %s\n" msgstr "%s: inkompatible Serverversion %s; Client unterstützt Streaming nicht mit Serverversionen neuer als %s\n" -#: receivelog.c:544 streamutil.c:264 streamutil.c:303 +#: receivelog.c:549 streamutil.c:272 streamutil.c:311 #, c-format msgid "%s: could not identify system: got %d rows and %d fields, expected %d rows and %d or more fields\n" msgstr "%s: konnte System nicht identifizieren: %d Zeilen und %d Felder erhalten, %d Zeilen und %d oder mehr Felder erwartet\n" -#: receivelog.c:552 +#: receivelog.c:557 #, c-format msgid "%s: system identifier does not match between base backup and streaming connection\n" msgstr "%s: Systemidentifikator stimmt nicht zwischen Basissicherung und Streaming-Verbindung überein\n" -#: receivelog.c:560 +#: receivelog.c:565 #, c-format msgid "%s: starting timeline %u is not present in the server\n" msgstr "%s: Startzeitleiste %u ist auf dem Server nicht vorhanden\n" -#: receivelog.c:600 +#: receivelog.c:605 #, c-format msgid "%s: unexpected response to TIMELINE_HISTORY command: got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: unerwartete Antwort auf Befehl TIMELINE_HISTORY: %d Zeilen und %d Felder erhalten, %d Zeilen und %d Felder erwartet\n" -#: receivelog.c:672 +#: receivelog.c:677 #, c-format msgid "%s: server reported unexpected next timeline %u, following timeline %u\n" msgstr "%s: Server berichtete unerwartete nächste Zeitleiste %u, folgend auf Zeitleiste %u\n" -#: receivelog.c:679 +#: receivelog.c:684 #, c-format msgid "%s: server stopped streaming timeline %u at %X/%X, but reported next timeline %u to begin at %X/%X\n" msgstr "%s: Server beendete Streaming von Zeitleiste %u bei %X/%X, aber gab an, dass nächste Zeitleiste %u bei %X/%X beginnt\n" -#: receivelog.c:720 +#: receivelog.c:725 #, c-format msgid "%s: replication stream was terminated before stop point\n" msgstr "%s: Replikationsstrom wurde vor Stopppunkt abgebrochen\n" -#: receivelog.c:769 +#: receivelog.c:774 #, c-format msgid "%s: unexpected result set after end-of-timeline: got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: unerwartete Ergebnismenge nach Ende der Zeitleiste: %d Zeilen und %d Felder erhalten, %d Zeilen und %d Felder erwartet\n" -#: receivelog.c:779 +#: receivelog.c:784 #, c-format msgid "%s: could not parse next timeline's starting point \"%s\"\n" msgstr "%s: konnte Startpunkt der nächsten Zeitleiste (»%s«) nicht interpretieren\n" -#: receivelog.c:1136 +#: receivelog.c:1141 #, c-format msgid "%s: received transaction log record for offset %u with no file open\n" msgstr "%s: Transaktionslogeintrag für Offset %u erhalten ohne offene Datei\n" -#: receivelog.c:1148 +#: receivelog.c:1153 #, c-format msgid "%s: got WAL data offset %08x, expected %08x\n" msgstr "%s: WAL-Daten-Offset %08x erhalten, %08x erwartet\n" -#: receivelog.c:1184 +#: receivelog.c:1189 #, c-format msgid "%s: could not write %u bytes to WAL file \"%s\": %s\n" msgstr "%s: konnte %u Bytes nicht in WAL-Datei »%s« schreiben: %s\n" -#: receivelog.c:1209 receivelog.c:1250 receivelog.c:1281 +#: receivelog.c:1214 receivelog.c:1255 receivelog.c:1286 #, c-format msgid "%s: could not send copy-end packet: %s" msgstr "%s: konnte COPY-Ende-Paket nicht senden: %s" -#: streamutil.c:145 +#: streamutil.c:153 msgid "Password: " msgstr "Passwort: " -#: streamutil.c:169 +#: streamutil.c:177 #, c-format msgid "%s: could not connect to server\n" msgstr "%s: konnte nicht mit Server verbinden\n" -#: streamutil.c:187 +#: streamutil.c:195 #, c-format msgid "%s: could not connect to server: %s" msgstr "%s: konnte nicht mit Server verbinden: %s" -#: streamutil.c:211 +#: streamutil.c:219 #, c-format msgid "%s: could not determine server setting for integer_datetimes\n" msgstr "%s: konnte Servereinstellung für integer_datetimes nicht ermitteln\n" -#: streamutil.c:224 +#: streamutil.c:232 #, c-format msgid "%s: integer_datetimes compile flag does not match server\n" msgstr "%s: Kompilieroption »integer_datetimes« stimmt nicht mit Server überein\n" -#: streamutil.c:371 +#: streamutil.c:379 #, c-format msgid "%s: could not create replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: konnte Replikations-Slot »%s« nicht erzeugen: %d Zeilen und %d Felder erhalten, %d Zeilen und %d Felder erwartet\n" -#: streamutil.c:416 +#: streamutil.c:424 #, c-format msgid "%s: could not drop replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: konnte Replikations-Slot »%s« nicht löschen: %d Zeilen und %d Felder erhalten, %d Zeilen und %d Felder erwartet\n" diff --git a/src/bin/pg_basebackup/po/ja.po b/src/bin/pg_basebackup/po/ja.po index f866a303fe..4248c053ee 100644 --- a/src/bin/pg_basebackup/po/ja.po +++ b/src/bin/pg_basebackup/po/ja.po @@ -7,7 +7,7 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-09-15 20:14+0000\n" +"POT-Creation-Date: 2017-01-30 16:49+0900\n" "PO-Revision-Date: 2013-08-18 11:17+0900\n" "Last-Translator: \n" "Language-Team: jpug-doc \n" @@ -28,51 +28,49 @@ msgstr "メモリä¸è¶³ã§ã™\n" msgid "cannot duplicate null pointer (internal error)\n" msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" -#: pg_basebackup.c:154 +#: pg_basebackup.c:156 #, c-format -#| msgid "directory name too long: \"%s\"\n" msgid "%s: directory name too long\n" msgstr "%s: ディレクトリã®åå‰ãŒé•·ã™ãŽã¾ã™\n" -#: pg_basebackup.c:164 +#: pg_basebackup.c:166 #, c-format msgid "%s: multiple \"=\" signs in tablespace mapping\n" msgstr "%s: 複数ã®\"=\"記å·ãŒãƒ†ãƒ¼ãƒ–ル空間マッピングã«å­˜åœ¨ã—ã¾ã™\n" -#: pg_basebackup.c:177 +#: pg_basebackup.c:179 #, c-format -#| msgid "%s: invalid output format \"%s\", must be \"plain\" or \"tar\"\n" msgid "%s: invalid tablespace mapping format \"%s\", must be \"OLDDIR=NEWDIR\"\n" msgstr "%s: 無効ãªãƒ†ãƒ¼ãƒ–ル空間マッピング形å¼\"%s\"ã§ã™ã€‚\"OLDDIR=NEWDIR\"ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:190 +#: pg_basebackup.c:192 #, c-format msgid "%s: old directory is not an absolute path in tablespace mapping: %s\n" msgstr "%s: å¤ã„ディレクトリã¯ãƒ†ãƒ¼ãƒ–ル空間マッピングã§ã¯çµ¶å¯¾ãƒ‘スã§ã¯ã‚ã‚Šã¾ã›ã‚“: %s\n" -#: pg_basebackup.c:197 +#: pg_basebackup.c:199 #, c-format msgid "%s: new directory is not an absolute path in tablespace mapping: %s\n" msgstr "%s: æ–°ã—ã„ディレクトリã¯ãƒ†ãƒ¼ãƒ–ル空間マッピングã§ã¯çµ¶å¯¾ãƒ‘スã§ã¯ã‚ã‚Šã¾ã›ã‚“: %s\n" -#: pg_basebackup.c:231 +#: pg_basebackup.c:233 #, c-format msgid "" "%s takes a base backup of a running PostgreSQL server.\n" "\n" msgstr "%sã¯å®Ÿè¡Œä¸­ã®PostgreSQLサーãƒã®ãƒ™ãƒ¼ã‚¹ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã‚’å–å¾—ã—ã¾ã™ã€‚\n" -#: pg_basebackup.c:233 pg_receivexlog.c:66 pg_recvlogical.c:69 +#: pg_basebackup.c:235 pg_receivexlog.c:66 pg_recvlogical.c:72 #, c-format msgid "Usage:\n" msgstr "使用方法:\n" -#: pg_basebackup.c:234 pg_receivexlog.c:67 pg_recvlogical.c:70 +#: pg_basebackup.c:236 pg_receivexlog.c:67 pg_recvlogical.c:73 #, c-format msgid " %s [OPTION]...\n" msgstr " %s [OPTION]...\n" -#: pg_basebackup.c:235 +#: pg_basebackup.c:237 #, c-format msgid "" "\n" @@ -81,17 +79,17 @@ msgstr "" "\n" "出力を制御ã™ã‚‹ã‚ªãƒ—ション:\n" -#: pg_basebackup.c:236 +#: pg_basebackup.c:238 #, c-format msgid " -D, --pgdata=DIRECTORY receive base backup into directory\n" msgstr " -D, --pgdata=DIRECTORY ディレクトリ内ã«ãƒ™ãƒ¼ã‚¹ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã‚’æ ¼ç´ã—ã¾ã™\n" -#: pg_basebackup.c:237 +#: pg_basebackup.c:239 #, c-format msgid " -F, --format=p|t output format (plain (default), tar)\n" msgstr " -F, --format=p|t 出力フォーマット（プレイン(デフォルト)ã¾ãŸã¯tar）\n" -#: pg_basebackup.c:238 +#: pg_basebackup.c:240 #, c-format msgid "" " -r, --max-rate=RATE maximum transfer rate to transfer data directory\n" @@ -100,7 +98,7 @@ msgstr "" " -r, --max-rate=RATE データディレクトリã¸è»¢é€ã™ã‚‹éš›ã®æœ€å¤§è»¢é€é€Ÿåº¦\n" " (kB/s ã§,ã¾ãŸã¯ 接尾辞 \"k\" ã‹\"M\" を使用)\n" -#: pg_basebackup.c:240 +#: pg_basebackup.c:242 #, c-format msgid "" " -R, --write-recovery-conf\n" @@ -109,12 +107,12 @@ msgstr "" " -R, --write-recovery-conf\n" " ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã®å¾Œã«recovery.confを書ã出ã™\n" -#: pg_basebackup.c:242 pg_receivexlog.c:74 +#: pg_basebackup.c:244 pg_receivexlog.c:74 #, c-format msgid " -S, --slot=SLOTNAME replication slot to use\n" msgstr " -S, --slot=スロットå 使用ã™ã‚‹ãƒ¬ãƒ—リケーションスロット\n" -#: pg_basebackup.c:243 +#: pg_basebackup.c:245 #, c-format msgid "" " -T, --tablespace-mapping=OLDDIR=NEWDIR\n" @@ -122,12 +120,13 @@ msgid "" msgstr "" " -T, --tablespace-mapping=å¤ã„ディレクトリ=æ–°ã—ã„ディレクトリ\n" "\n" -#: pg_basebackup.c:245 + +#: pg_basebackup.c:247 #, c-format msgid " -x, --xlog include required WAL files in backup (fetch mode)\n" msgstr " -x, --xlog å¿…è¦ãªWALファイルをãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—内ã«å«ã‚ã¾ã™ï¼ˆãƒ•ã‚§ãƒƒãƒãƒ¢ãƒ¼ãƒ‰ï¼‰\n" -#: pg_basebackup.c:246 +#: pg_basebackup.c:248 #, c-format msgid "" " -X, --xlog-method=fetch|stream\n" @@ -136,23 +135,22 @@ msgstr "" " -X, --xlog-method=fetch|stream\n" " å¿…è¦ãªWALファイルを指定ã—ãŸæ–¹æ³•ã§å«ã‚ã¾ã™\n" -#: pg_basebackup.c:248 +#: pg_basebackup.c:250 #, c-format -#| msgid " -X, --xlogdir=XLOGDIR location for the transaction log directory\n" msgid " --xlogdir=XLOGDIR location for the transaction log directory\n" msgstr " --xlogdir=XLOGDIR トランザクションログディレクトリã®å ´æ‰€ã§ã™\n" -#: pg_basebackup.c:249 +#: pg_basebackup.c:251 #, c-format msgid " -z, --gzip compress tar output\n" msgstr " -z, --gzip 出力を圧縮ã—ã¾ã™\n" -#: pg_basebackup.c:250 +#: pg_basebackup.c:252 #, c-format msgid " -Z, --compress=0-9 compress tar output with given compression level\n" msgstr " -Z, --compress=0-9 指定ã—ãŸåœ§ç¸®ãƒ¬ãƒ™ãƒ«ã§tar出力を圧縮ã—ã¾ã™\n" -#: pg_basebackup.c:251 +#: pg_basebackup.c:253 #, c-format msgid "" "\n" @@ -161,7 +159,7 @@ msgstr "" "\n" "汎用ã®ã‚ªãƒ—ション:\n" -#: pg_basebackup.c:252 +#: pg_basebackup.c:254 #, c-format msgid "" " -c, --checkpoint=fast|spread\n" @@ -170,32 +168,32 @@ msgstr "" " -c, --checkpoint=fast|spread\n" " 高速ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆå‡¦ç†ã¾ãŸã¯åˆ†æ•£ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆå‡¦ç†ã®è¨­å®š\n" -#: pg_basebackup.c:254 +#: pg_basebackup.c:256 #, c-format msgid " -l, --label=LABEL set backup label\n" msgstr " -l, --label=LABEL ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ラベルã®è¨­å®š\n" -#: pg_basebackup.c:255 +#: pg_basebackup.c:257 #, c-format msgid " -P, --progress show progress information\n" msgstr " -P, --progress 進行状æ³ã®è¡¨ç¤º\n" -#: pg_basebackup.c:256 pg_receivexlog.c:76 pg_recvlogical.c:89 +#: pg_basebackup.c:258 pg_receivexlog.c:76 pg_recvlogical.c:92 #, c-format msgid " -v, --verbose output verbose messages\n" msgstr " -v, --verbose 冗長メッセージã®å‡ºåŠ›\n" -#: pg_basebackup.c:257 pg_receivexlog.c:77 pg_recvlogical.c:90 +#: pg_basebackup.c:259 pg_receivexlog.c:77 pg_recvlogical.c:93 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_basebackup.c:258 pg_receivexlog.c:78 pg_recvlogical.c:91 +#: pg_basebackup.c:260 pg_receivexlog.c:78 pg_recvlogical.c:94 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_basebackup.c:259 pg_receivexlog.c:79 pg_recvlogical.c:92 +#: pg_basebackup.c:261 pg_receivexlog.c:79 pg_recvlogical.c:95 #, c-format msgid "" "\n" @@ -204,22 +202,22 @@ msgstr "" "\n" "接続オプション:\n" -#: pg_basebackup.c:260 pg_receivexlog.c:80 +#: pg_basebackup.c:262 pg_receivexlog.c:80 #, c-format msgid " -d, --dbname=CONNSTR connection string\n" msgstr " -d, --dbname=CONSTR 接続文字列\n" -#: pg_basebackup.c:261 pg_receivexlog.c:81 pg_recvlogical.c:94 +#: pg_basebackup.c:263 pg_receivexlog.c:81 pg_recvlogical.c:97 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory\n" msgstr " -h, --host=HOSTNAME データベースサーãƒãƒ›ã‚¹ãƒˆã¾ãŸã¯ã‚½ã‚±ãƒƒãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒª\n" -#: pg_basebackup.c:262 pg_receivexlog.c:82 pg_recvlogical.c:95 +#: pg_basebackup.c:264 pg_receivexlog.c:82 pg_recvlogical.c:98 #, c-format msgid " -p, --port=PORT database server port number\n" msgstr " -p, --port=PORT データベースサーãƒã®ãƒãƒ¼ãƒˆç•ªå·\n" -#: pg_basebackup.c:263 +#: pg_basebackup.c:265 #, c-format msgid "" " -s, --status-interval=INTERVAL\n" @@ -228,22 +226,22 @@ msgstr "" " -s, --status-interval=INTERVAL\n" " サーãƒã¸çŠ¶æ…‹ãƒ‘ケットをé€ä¿¡ã™ã‚‹é–“隔（秒å˜ä½ï¼‰\n" -#: pg_basebackup.c:265 pg_receivexlog.c:83 pg_recvlogical.c:96 +#: pg_basebackup.c:267 pg_receivexlog.c:83 pg_recvlogical.c:99 #, c-format msgid " -U, --username=NAME connect as specified database user\n" msgstr " -U, --username=NAME 指定ã—ãŸãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ¦ãƒ¼ã‚¶ã§æŽ¥ç¶š\n" -#: pg_basebackup.c:266 pg_receivexlog.c:84 pg_recvlogical.c:97 +#: pg_basebackup.c:268 pg_receivexlog.c:84 pg_recvlogical.c:100 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password パスワード入力を促ã•ãªã„\n" -#: pg_basebackup.c:267 pg_receivexlog.c:85 pg_recvlogical.c:98 +#: pg_basebackup.c:269 pg_receivexlog.c:85 pg_recvlogical.c:101 #, c-format msgid " -W, --password force password prompt (should happen automatically)\n" msgstr " -W, --password 強制的ã«ãƒ‘スワード入力を促ã™ï¼ˆè‡ªå‹•çš„ã«è¡Œã‚れるã¯ãšã§ã™ï¼‰\n" -#: pg_basebackup.c:268 pg_receivexlog.c:89 pg_recvlogical.c:99 +#: pg_basebackup.c:270 pg_receivexlog.c:89 pg_recvlogical.c:102 #, c-format msgid "" "\n" @@ -252,384 +250,375 @@ msgstr "" "\n" "ä¸å…·åˆã¯ã¾ã§å ±å‘Šãã ã•ã„\n" -#: pg_basebackup.c:311 +#: pg_basebackup.c:313 #, c-format msgid "%s: could not read from ready pipe: %s\n" msgstr "%s: 準備ã•ã‚ŒãŸãƒ‘イプã‹ã‚‰èª­ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:319 pg_basebackup.c:422 pg_basebackup.c:1893 +#: pg_basebackup.c:321 pg_basebackup.c:424 pg_basebackup.c:1895 #: streamutil.c:293 #, c-format msgid "%s: could not parse transaction log location \"%s\"\n" msgstr "%s: トランザクションログä½ç½®\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_basebackup.c:435 +#: pg_basebackup.c:437 #, c-format msgid "%s: could not create pipe for background process: %s\n" msgstr "%s: ãƒãƒƒã‚¯ã‚°ãƒ©ãƒ³ãƒ‰ãƒ—ロセス用ã®ãƒ‘イプを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: \"%s\"\n" -#: pg_basebackup.c:460 pg_basebackup.c:515 pg_basebackup.c:1263 +#: pg_basebackup.c:462 pg_basebackup.c:517 pg_basebackup.c:1265 #, c-format msgid "%s: could not create directory \"%s\": %s\n" msgstr "%s: \"%s\"ディレクトリを作æˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:478 +#: pg_basebackup.c:480 #, c-format msgid "%s: could not create background process: %s\n" msgstr "%s: ãƒãƒƒã‚¯ã‚°ãƒ©ãƒ³ãƒ‰ãƒ—ロセスを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:490 +#: pg_basebackup.c:492 #, c-format msgid "%s: could not create background thread: %s\n" msgstr "%s: ãƒãƒƒã‚¯ã‚°ãƒ©ãƒ³ãƒ‰ã‚¹ãƒ¬ãƒƒãƒ‰ã‚’作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:534 +#: pg_basebackup.c:536 #, c-format msgid "%s: directory \"%s\" exists but is not empty\n" msgstr "%s: \"%s\"ディレクトリã¯å­˜åœ¨ã—ã¾ã™ãŒç©ºã§ã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:542 +#: pg_basebackup.c:544 #, c-format msgid "%s: could not access directory \"%s\": %s\n" msgstr "%s: \"%s\"ディレクトリã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:604 +#: pg_basebackup.c:606 #, c-format msgid "%*s/%s kB (100%%), %d/%d tablespace %*s" msgid_plural "%*s/%s kB (100%%), %d/%d tablespaces %*s" msgstr[0] "%*s/%s kB (100%%), %d/%d テーブル空間 %*s" msgstr[1] "%*s/%s kB (100%%), %d/%d テーブル空間 %*s" -#: pg_basebackup.c:616 +#: pg_basebackup.c:618 #, c-format msgid "%*s/%s kB (%d%%), %d/%d tablespace (%s%-*.*s)" msgid_plural "%*s/%s kB (%d%%), %d/%d tablespaces (%s%-*.*s)" msgstr[0] "%*s/%s kB (%d%%), %d/%d テーブル空間 (%s%-*.*s)" msgstr[1] "%*s/%s kB (%d%%), %d/%d テーブル空間 (%s%-*.*s)" -#: pg_basebackup.c:632 +#: pg_basebackup.c:634 #, c-format msgid "%*s/%s kB (%d%%), %d/%d tablespace" msgid_plural "%*s/%s kB (%d%%), %d/%d tablespaces" msgstr[0] "%*s/%s kB (%d%%), %d/%d テーブル空間" msgstr[1] "%*s/%s kB (%d%%), %d/%d テーブル空間" -#: pg_basebackup.c:654 +#: pg_basebackup.c:656 #, c-format -#| msgid "%s: \"%s\" is not a valid encoding name\n" msgid "%s: transfer rate \"%s\" is not a valid value\n" msgstr "%s: 転é€é€Ÿåº¦\"%s\"ãŒç„¡åŠ¹ãªå€¤ã§ã™\n" -#: pg_basebackup.c:661 +#: pg_basebackup.c:663 #, c-format -#| msgid "%s: invalid locale name \"%s\"\n" msgid "%s: invalid transfer rate \"%s\": %s\n" msgstr "%s: 転é€é€Ÿåº¦\"%s\"ãŒç„¡åŠ¹ãªå€¤ã§ã™: %s\n" -#: pg_basebackup.c:671 +#: pg_basebackup.c:673 #, c-format -#| msgid "count must be greater than zero" msgid "%s: transfer rate must be greater than zero\n" -msgstr "%s: 転é€é€Ÿåº¦ã¯0以上ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" +msgstr "%s: 転é€é€Ÿåº¦ã¯0より大ãããªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:705 +#: pg_basebackup.c:707 #, c-format -#| msgid "%s: invalid argument: \"%s\"\n" msgid "%s: invalid --max-rate unit: \"%s\"\n" -msgstr "%s: 無効㪠--max-rateユニットã§ã™: \"%s\"\n" +msgstr "%s: 無効㪠--max-rateå˜ä½ã§ã™: \"%s\"\n" -#: pg_basebackup.c:714 +#: pg_basebackup.c:716 #, c-format -#| msgid "argument of lo_write exceeds integer range\n" msgid "%s: transfer rate \"%s\" exceeds integer range\n" msgstr "%s: 転é€é€Ÿåº¦\"%s\"ãŒintegerã®ç¯„囲を超ãˆã¦ã„ã¾ã™\n" -#: pg_basebackup.c:726 +#: pg_basebackup.c:728 #, c-format -#| msgid "result is out of range" msgid "%s: transfer rate \"%s\" is out of range\n" msgstr "%s: 転é€é€Ÿåº¦\"%s\"ãŒç¯„囲外ã§ã™\n" -#: pg_basebackup.c:750 +#: pg_basebackup.c:752 #, c-format msgid "%s: could not write to compressed file \"%s\": %s\n" msgstr "%s: \"%s\"圧縮ファイルã«æ›¸ã出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:760 pg_basebackup.c:1357 pg_basebackup.c:1582 +#: pg_basebackup.c:762 pg_basebackup.c:1359 pg_basebackup.c:1584 #, c-format msgid "%s: could not write to file \"%s\": %s\n" msgstr "%s: \"%s\"ファイルã«æ›¸ã出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:815 pg_basebackup.c:836 pg_basebackup.c:864 +#: pg_basebackup.c:817 pg_basebackup.c:838 pg_basebackup.c:866 #, c-format msgid "%s: could not set compression level %d: %s\n" msgstr "%s: 圧縮レベルを%dã«è¨­å®šã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:885 +#: pg_basebackup.c:887 #, c-format msgid "%s: could not create compressed file \"%s\": %s\n" msgstr "%s: \"%s\"圧縮ファイルを作æˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:896 pg_basebackup.c:1317 pg_basebackup.c:1575 +#: pg_basebackup.c:898 pg_basebackup.c:1319 pg_basebackup.c:1577 #, c-format msgid "%s: could not create file \"%s\": %s\n" msgstr "%s: \"%s\"ファイルを作æˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:908 pg_basebackup.c:1172 +#: pg_basebackup.c:910 pg_basebackup.c:1174 #, c-format msgid "%s: could not get COPY data stream: %s" msgstr "%s: COPYデータストリームを入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_basebackup.c:965 +#: pg_basebackup.c:967 #, c-format msgid "%s: could not close compressed file \"%s\": %s\n" msgstr "%s: \"%s\"圧縮ファイルを閉ã˜ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:978 pg_recvlogical.c:577 receivelog.c:203 receivelog.c:351 -#: receivelog.c:740 +#: pg_basebackup.c:980 pg_recvlogical.c:580 receivelog.c:206 receivelog.c:354 +#: receivelog.c:743 #, c-format msgid "%s: could not close file \"%s\": %s\n" msgstr "%s: ファイル\"%s\"ã‚’é–‰ã˜ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:989 pg_basebackup.c:1201 pg_recvlogical.c:443 -#: receivelog.c:1021 +#: pg_basebackup.c:991 pg_basebackup.c:1203 pg_recvlogical.c:446 +#: receivelog.c:1024 #, c-format msgid "%s: could not read COPY data: %s" msgstr "%s: COPYデータを読ã¿å–ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_basebackup.c:1215 +#: pg_basebackup.c:1217 #, c-format msgid "%s: invalid tar block header size: %d\n" msgstr "%s: 無効ãªtarブロックヘッダサイズ: %d\n" -#: pg_basebackup.c:1271 +#: pg_basebackup.c:1273 #, c-format msgid "%s: could not set permissions on directory \"%s\": %s\n" msgstr "%s: \"%s\"ディレクトリã®æ¨©é™ã‚’設定ã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:1295 +#: pg_basebackup.c:1297 #, c-format msgid "%s: could not create symbolic link from \"%s\" to \"%s\": %s\n" msgstr "%s: \"%s\"ã‹ã‚‰\"%s\"ã¸ã®ã‚·ãƒ³ãƒœãƒªãƒƒã‚¯ãƒªãƒ³ã‚¯ã‚’作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:1304 +#: pg_basebackup.c:1306 #, c-format msgid "%s: unrecognized link indicator \"%c\"\n" msgstr "%s: 未知ã®ãƒªãƒ³ã‚¯æŒ‡ç¤ºå­\"%c\"\n" -#: pg_basebackup.c:1324 +#: pg_basebackup.c:1326 #, c-format msgid "%s: could not set permissions on file \"%s\": %s\n" msgstr "%s: \"%s\"ファイルã®æ¨©é™ã‚’設定ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:1383 +#: pg_basebackup.c:1385 #, c-format msgid "%s: COPY stream ended before last file was finished\n" msgstr "%s: 最後ã®ãƒ•ã‚¡ã‚¤ãƒ«ãŒçµ‚ã‚ã‚‹å‰ã«COPYストリームãŒå®Œäº†ã—ã¾ã—ãŸ\n" -#: pg_basebackup.c:1469 pg_basebackup.c:1489 pg_basebackup.c:1496 -#: pg_basebackup.c:1550 +#: pg_basebackup.c:1471 pg_basebackup.c:1491 pg_basebackup.c:1498 +#: pg_basebackup.c:1552 #, c-format msgid "%s: out of memory\n" msgstr "%s: メモリä¸è¶³ã§ã™\n" -#: pg_basebackup.c:1627 +#: pg_basebackup.c:1629 #, c-format msgid "%s: incompatible server version %s\n" msgstr "%s: 互æ›æ€§ãŒãªã„サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³\"%s\"\n" -#: pg_basebackup.c:1674 pg_recvlogical.c:261 receivelog.c:538 receivelog.c:589 -#: receivelog.c:629 streamutil.c:263 streamutil.c:367 streamutil.c:413 +#: pg_basebackup.c:1676 pg_recvlogical.c:264 receivelog.c:541 receivelog.c:592 +#: receivelog.c:632 streamutil.c:263 streamutil.c:367 streamutil.c:413 #, c-format msgid "%s: could not send replication command \"%s\": %s" msgstr "%s: レプリケーションコマンド\"%s\"ã‚’é€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_basebackup.c:1685 +#: pg_basebackup.c:1687 #, c-format msgid "%s: could not initiate base backup: %s" msgstr "%s: ベースãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã‚’åˆæœŸåŒ–ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_basebackup.c:1692 +#: pg_basebackup.c:1694 #, c-format msgid "%s: server returned unexpected response to BASE_BACKUP command; got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: サーãƒã¯BASE_BACKUPコマンドã«æƒ³å®šå¤–ã®å¿œç­”ã‚’è¿”ã—ã¾ã—ãŸ: %dè¡Œã¨%dフィールドを入手ã—ã¾ã—ãŸã€‚想定ã§ã¯%dè¡Œã¨%dフィールドã§ã—ãŸ\n" -#: pg_basebackup.c:1712 +#: pg_basebackup.c:1714 #, c-format msgid "transaction log start point: %s on timeline %u\n" msgstr "トランザクションログã®é–‹å§‹ãƒã‚¤ãƒ³ãƒˆ: タイムライン%2$u上ã®%1$s\n" -#: pg_basebackup.c:1721 +#: pg_basebackup.c:1723 #, c-format msgid "%s: could not get backup header: %s" msgstr "%s: ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ヘッダを入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_basebackup.c:1727 +#: pg_basebackup.c:1729 #, c-format msgid "%s: no data returned from server\n" msgstr "%s: サーãƒã‹ã‚‰è¿”ã•ã‚Œã‚‹ãƒ‡ãƒ¼ã‚¿ãŒã‚ã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:1759 +#: pg_basebackup.c:1761 #, c-format msgid "%s: can only write single tablespace to stdout, database has %d\n" msgstr "%s: データベースã«ã¯%dã‚ã‚Šã¾ã—ãŸãŒã€ï¼‘ã¤ã®ãƒ†ãƒ¼ãƒ–ル空間ã®ã¿æ¨™æº–出力ã«æ›¸ã出ã™ã“ã¨ãŒã§ãã¾ã™\n" -#: pg_basebackup.c:1771 +#: pg_basebackup.c:1773 #, c-format msgid "%s: starting background WAL receiver\n" msgstr "%s: ãƒãƒƒã‚¯ã‚°ãƒ©ãƒ³ãƒ‰WALå—信処ç†ã‚’開始ã—ã¾ã™\n" -#: pg_basebackup.c:1802 +#: pg_basebackup.c:1804 #, c-format msgid "%s: could not get transaction log end position from server: %s" msgstr "%s: サーãƒã‹ã‚‰ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãƒ­ã‚°ã®çµ‚了ä½ç½®ã‚’入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_basebackup.c:1809 +#: pg_basebackup.c:1811 #, c-format msgid "%s: no transaction log end position returned from server\n" msgstr "%s: サーãƒã‹ã‚‰ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãƒ­ã‚°ã®çµ‚了ä½ç½®ãŒè¿”ã•ã‚Œã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_basebackup.c:1821 +#: pg_basebackup.c:1823 #, c-format msgid "%s: final receive failed: %s" msgstr "%s: 最終å—ä¿¡ã«å¤±æ•—ã—ã¾ã—ãŸ: %s" -#: pg_basebackup.c:1845 +#: pg_basebackup.c:1847 #, c-format msgid "%s: waiting for background process to finish streaming ...\n" msgstr "%s: ストリーミング処ç†ãŒçµ‚ã‚ã‚‹ã¾ã§ãƒãƒƒã‚¯ã‚°ãƒ©ãƒ³ãƒ‰ãƒ—ロセスを待機ã—ã¾ã™ ...\n" -#: pg_basebackup.c:1851 +#: pg_basebackup.c:1853 #, c-format msgid "%s: could not send command to background pipe: %s\n" msgstr "%s: ãƒãƒƒã‚¯ã‚°ãƒ©ãƒ³ãƒ‰ãƒ‘イプã«ã‚³ãƒžãƒ³ãƒ‰ã‚’é€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:1860 +#: pg_basebackup.c:1862 #, c-format msgid "%s: could not wait for child process: %s\n" msgstr "%s: å­ãƒ—ロセスを待機ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:1866 +#: pg_basebackup.c:1868 #, c-format msgid "%s: child %d died, expected %d\n" msgstr "%s: å­ãƒ—ロセス%d 終了ã€ãã®æœŸå¾…値ã¯%dã§ã™\n" -#: pg_basebackup.c:1872 +#: pg_basebackup.c:1874 #, c-format msgid "%s: child process did not exit normally\n" msgstr "%s: å­ãƒ—ロセスãŒæ­£å¸¸ã«çµ‚ã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_basebackup.c:1878 +#: pg_basebackup.c:1880 #, c-format msgid "%s: child process exited with error %d\n" msgstr "%s: å­ãƒ—ロセスãŒçµ‚了コード%dã§çµ‚了ã—ã¾ã—ãŸ\n" -#: pg_basebackup.c:1905 +#: pg_basebackup.c:1907 #, c-format msgid "%s: could not wait for child thread: %s\n" msgstr "%s: å­ã‚¹ãƒ¬ãƒƒãƒ‰ã‚’å¾…æ©Ÿã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:1912 +#: pg_basebackup.c:1914 #, c-format msgid "%s: could not get child thread exit status: %s\n" msgstr "%s: å­ã‚¹ãƒ¬ãƒƒãƒ‰ã®çµ‚了ステータスを入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:1918 +#: pg_basebackup.c:1920 #, c-format msgid "%s: child thread exited with error %u\n" msgstr "%s: å­ã‚¹ãƒ¬ãƒƒãƒ‰ãŒã‚¨ãƒ©ãƒ¼%uã§çµ‚了ã—ã¾ã—ãŸ\n" -#: pg_basebackup.c:2008 +#: pg_basebackup.c:2010 #, c-format msgid "%s: invalid output format \"%s\", must be \"plain\" or \"tar\"\n" msgstr "%s: \"%s\"出力フォーマットã¯ç„¡åŠ¹ã§ã™ã€‚\"plain\"ã‹\"tar\"ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:2029 pg_basebackup.c:2041 +#: pg_basebackup.c:2031 pg_basebackup.c:2043 #, c-format msgid "%s: cannot specify both --xlog and --xlog-method\n" msgstr "%s: --xlogã¨--xlog-methodã¯åŒæ™‚ã«æŒ‡å®šã§ãã¾ã›ã‚“\n" -#: pg_basebackup.c:2056 +#: pg_basebackup.c:2058 #, c-format msgid "%s: invalid xlog-method option \"%s\", must be \"fetch\" or \"stream\"\n" msgstr "%s: \"%s\" xlogæ–¹å¼ã¯ç„¡åŠ¹ã§ã™ã€‚\"fetch\"ã€\"stream\"ã®ã„ãšã‚Œã‹ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:2078 +#: pg_basebackup.c:2080 #, c-format msgid "%s: invalid compression level \"%s\"\n" msgstr "%s: \"%s\"圧縮レベルã¯ç„¡åŠ¹ã§ã™\n" -#: pg_basebackup.c:2090 +#: pg_basebackup.c:2092 #, c-format msgid "%s: invalid checkpoint argument \"%s\", must be \"fast\" or \"spread\"\n" msgstr "%s: \"%s\"ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆå¼•æ•°ã¯ç„¡åŠ¹ã§ã™ã€‚\"fast\"ã¾ãŸã¯\"spreadã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:2117 pg_receivexlog.c:445 pg_recvlogical.c:760 +#: pg_basebackup.c:2119 pg_receivexlog.c:445 pg_recvlogical.c:763 #, c-format msgid "%s: invalid status interval \"%s\"\n" msgstr "%s: \"%s\" 状態間隔ã¯ç„¡åŠ¹ã§ã™\n" -#: pg_basebackup.c:2133 pg_basebackup.c:2147 pg_basebackup.c:2158 -#: pg_basebackup.c:2171 pg_basebackup.c:2181 pg_basebackup.c:2191 -#: pg_basebackup.c:2203 pg_basebackup.c:2214 pg_receivexlog.c:477 +#: pg_basebackup.c:2135 pg_basebackup.c:2149 pg_basebackup.c:2160 +#: pg_basebackup.c:2173 pg_basebackup.c:2183 pg_basebackup.c:2193 +#: pg_basebackup.c:2205 pg_basebackup.c:2216 pg_receivexlog.c:477 #: pg_receivexlog.c:491 pg_receivexlog.c:499 pg_receivexlog.c:509 -#: pg_receivexlog.c:520 pg_recvlogical.c:787 pg_recvlogical.c:801 -#: pg_recvlogical.c:812 pg_recvlogical.c:820 pg_recvlogical.c:828 -#: pg_recvlogical.c:836 pg_recvlogical.c:844 pg_recvlogical.c:852 +#: pg_receivexlog.c:520 pg_recvlogical.c:790 pg_recvlogical.c:804 +#: pg_recvlogical.c:815 pg_recvlogical.c:823 pg_recvlogical.c:831 +#: pg_recvlogical.c:839 pg_recvlogical.c:847 pg_recvlogical.c:855 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細ã«ã¤ã„ã¦ã¯\"%s --help\"を実行ã—ã¦ãã ã•ã„。\n" -#: pg_basebackup.c:2145 pg_receivexlog.c:489 pg_recvlogical.c:799 +#: pg_basebackup.c:2147 pg_receivexlog.c:489 pg_recvlogical.c:802 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: コマンドライン引数ãŒå¤šéŽãŽã¾ã™(最åˆã¯\"%s\"ã§ã™)\n" -#: pg_basebackup.c:2157 pg_receivexlog.c:519 +#: pg_basebackup.c:2159 pg_receivexlog.c:519 #, c-format msgid "%s: no target directory specified\n" msgstr "%s: 対象ディレクトリãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_basebackup.c:2169 +#: pg_basebackup.c:2171 #, c-format msgid "%s: only tar mode backups can be compressed\n" msgstr "%s: tarモードã®ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã®ã¿åœ§ç¸®ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™\n" -#: pg_basebackup.c:2179 +#: pg_basebackup.c:2181 #, c-format msgid "%s: WAL streaming can only be used in plain mode\n" msgstr "%s: WALストリーミングã¯ãƒ—レインモードã§ã®ã¿ä½¿ç”¨ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚\n" -#: pg_basebackup.c:2189 +#: pg_basebackup.c:2191 #, c-format -#| msgid "%s: WAL streaming can only be used in plain mode\n" msgid "%s: replication slots can only be used with WAL streaming\n" msgstr "%s: WAL ストリーミングã¯plainモードã§ã®ã¿ä½¿ç”¨ã§ãã¾ã™\n" -#: pg_basebackup.c:2201 +#: pg_basebackup.c:2203 #, c-format -#| msgid "%s: transaction log directory location must be an absolute path\n" msgid "%s: transaction log directory location can only be specified in plain mode\n" msgstr "%s: トランザクションログã®æ ¼ç´ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã®å ´æ‰€ã¯plainモードã§ã®ã¿æŒ‡å®šã§ãã¾ã™\n" -#: pg_basebackup.c:2212 +#: pg_basebackup.c:2214 #, c-format msgid "%s: transaction log directory location must be an absolute path\n" msgstr "%s: トランザクションログã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã®ä½ç½®ã¯ã€çµ¶å¯¾ãƒ‘スã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_basebackup.c:2224 +#: pg_basebackup.c:2226 #, c-format msgid "%s: this build does not support compression\n" msgstr "%s: ã“ã®æ§‹ç¯‰ã§ã¯åœ§ç¸®ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" -#: pg_basebackup.c:2251 +#: pg_basebackup.c:2253 #, c-format msgid "%s: could not create symbolic link \"%s\": %s\n" msgstr "%s: シンボリックリンク\"%s\"を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_basebackup.c:2256 +#: pg_basebackup.c:2258 #, c-format -#| msgid "%s: symlinks are not supported on this platform" msgid "%s: symlinks are not supported on this platform\n" msgstr "%s: シンボリックリンクã¯ã“ã®ãƒ—ラットフォームã§ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" @@ -642,7 +631,7 @@ msgstr "" "%sã¯PostgreSQLã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãƒ­ã‚°ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚’å—ä¿¡ã—ã¾ã™ã€‚\n" "\n" -#: pg_receivexlog.c:68 pg_recvlogical.c:75 +#: pg_receivexlog.c:68 pg_recvlogical.c:78 #, c-format msgid "" "\n" @@ -656,21 +645,18 @@ msgstr "" msgid " -D, --directory=DIR receive transaction log files into this directory\n" msgstr " -D, --directory=DIR å—ä¿¡ã—ãŸãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãƒ­ã‚°ã®æ ¼ç´ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒª\n" -#: pg_receivexlog.c:70 pg_recvlogical.c:79 +#: pg_receivexlog.c:70 pg_recvlogical.c:82 #, c-format msgid " --if-not-exists do not error if slot already exists when creating a slot\n" -msgstr "　　　--if-not-exists スロットを作æˆã—ãŸã¨ãã«ã‚¹ãƒ­ãƒƒãƒˆãŒæ—¢ã«å­˜åœ¨ã—ã¦ã„ã‚‹ãªã‚‰ã‚¨ãƒ©ãƒ¼ã¯ãªã„\n" +msgstr "　　　--if-not-exists スロットを作æˆã—ãŸã¨ãã«ã‚¹ãƒ­ãƒƒãƒˆãŒæ—¢ã«å­˜åœ¨ã—ã¦ã„ã‚‹ãªã‚‰ã‚¨ãƒ©ãƒ¼ã¨ã—ãªã„\n" -#: pg_receivexlog.c:71 pg_recvlogical.c:81 +#: pg_receivexlog.c:71 pg_recvlogical.c:84 #, c-format msgid " -n, --no-loop do not loop on connection lost\n" msgstr " -n, --no-loop 接続ãŒãªããªã£ãŸæ™‚ã«ç¹°ã‚Šè¿”ã•ãªã„\n" -#: pg_receivexlog.c:72 pg_recvlogical.c:86 +#: pg_receivexlog.c:72 pg_recvlogical.c:89 #, c-format -#| msgid "" -#| " -s, --status-interval=INTERVAL\n" -#| " time between status packets sent to server (in seconds)\n" msgid "" " -s, --status-interval=SECS\n" " time between status packets sent to server (default: %d)\n" @@ -685,9 +671,6 @@ msgstr " --synchronous トランザクションログã¯æ›¸ã込㿠#: pg_receivexlog.c:86 #, c-format -#| msgid "" -#| "\n" -#| "Options:\n" msgid "" "\n" "Optional actions:\n" @@ -695,15 +678,15 @@ msgstr "" "\n" "追加æ“作:\n" -#: pg_receivexlog.c:87 pg_recvlogical.c:72 +#: pg_receivexlog.c:87 pg_recvlogical.c:75 #, c-format msgid " --create-slot create a new replication slot (for the slot's name see --slot)\n" -msgstr " --create-slot æ–°ã—ã„レプリケーションスロットを作æˆã™ã‚‹(スロットåを見る --slot)\n" +msgstr " --create-slot æ–°ã—ã„レプリケーションスロットを作æˆã™ã‚‹(スロットåã¯--slotã‚’å‚ç…§)\n" -#: pg_receivexlog.c:88 pg_recvlogical.c:73 +#: pg_receivexlog.c:88 pg_recvlogical.c:76 #, c-format msgid " --drop-slot drop the replication slot (for the slot's name see --slot)\n" -msgstr " --drop-slotp レプリケーションスロットを削除ã™ã‚‹ (スロットåを見るã«ã¯ --slot)\n" +msgstr " --drop-slotp レプリケーションスロットを削除ã™ã‚‹ (スロットåã¯--slotã‚’å‚ç…§)\n" #: pg_receivexlog.c:100 #, c-format @@ -727,11 +710,10 @@ msgstr "%s: ディレクトリ\"%s\"をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\ #: pg_receivexlog.c:160 #, c-format -#| msgid "%s: could not open directory \"%s\": %s\n" msgid "%s: could not close directory \"%s\": %s\n" msgstr "%s: ディレクトリ \"%s\" をクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_receivexlog.c:218 pg_recvlogical.c:343 +#: pg_receivexlog.c:218 pg_recvlogical.c:346 #, c-format msgid "%s: could not stat file \"%s\": %s\n" msgstr "%s: \"%s\"ファイルã®çŠ¶æ…‹ã‚’確èªã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" @@ -751,7 +733,7 @@ msgstr "%s: ディレクトリ\"%s\"を読ã¿å–ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“㧠msgid "%s: starting log streaming at %X/%X (timeline %u)\n" msgstr "%s: %X/%X (タイムライン %u)ã§ãƒ­ã‚°ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚’始ã‚ã¾ã™\n" -#: pg_receivexlog.c:426 pg_recvlogical.c:707 +#: pg_receivexlog.c:426 pg_recvlogical.c:710 #, c-format msgid "%s: invalid port number \"%s\"\n" msgstr "%s: 無効ãªãƒãƒ¼ãƒˆç•ªå·ã§ã™: \"%s\"\n" @@ -772,30 +754,28 @@ msgstr "%s: %sオプションã¯--slot を使用ã—ã¦ã‚¹ãƒ­ãƒƒãƒˆã‚’指定㙠msgid "%s: replication connection using slot \"%s\" is unexpectedly database specific\n" msgstr "%s: スロット \"%s\" を使用ã™ã‚‹ãƒ¬ãƒ—リケーション接続ã¯äºˆæƒ³å¤–ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ç‰¹å®šã§ã™\n" -#: pg_receivexlog.c:574 pg_recvlogical.c:892 +#: pg_receivexlog.c:574 pg_recvlogical.c:895 #, c-format -#| msgid "%s: could not send replication command \"%s\": %s" msgid "%s: dropping replication slot \"%s\"\n" msgstr "%s: レプリケーションスロット\"%s\"を削除ã—ã¦ã„ã¾ã™\n" -#: pg_receivexlog.c:587 pg_recvlogical.c:904 +#: pg_receivexlog.c:587 pg_recvlogical.c:907 #, c-format -#| msgid "%s: unexpected termination of replication stream: %s" msgid "%s: creating replication slot \"%s\"\n" msgstr "%s: レプリケーションスロット\"%s\"を作æˆã—ã¦ã„ã¾ã™\n" -#: pg_receivexlog.c:614 pg_recvlogical.c:930 +#: pg_receivexlog.c:614 pg_recvlogical.c:933 #, c-format msgid "%s: disconnected\n" msgstr "%s: 切断ã—ã¾ã—ãŸ\n" #. translator: check source for value for %d -#: pg_receivexlog.c:621 pg_recvlogical.c:937 +#: pg_receivexlog.c:621 pg_recvlogical.c:940 #, c-format msgid "%s: disconnected; waiting %d seconds to try again\n" msgstr "%s: 切断ã—ã¾ã—ãŸã€‚%d秒待機ã—å†è©¦è¡Œã—ã¾ã™\n" -#: pg_recvlogical.c:67 +#: pg_recvlogical.c:70 #, c-format msgid "" "%s controls PostgreSQL logical decoding streams.\n" @@ -804,7 +784,7 @@ msgstr "" "%s ã¯PostgreSQLロジカルデコーディングストリームを制御ã—ã¾ã™ã€‚\n" "\n" -#: pg_recvlogical.c:71 +#: pg_recvlogical.c:74 #, c-format msgid "" "\n" @@ -813,22 +793,18 @@ msgstr "" "\n" ":実行ã•ã‚Œã‚‹ã¹ãæ“作\n" -#: pg_recvlogical.c:74 +#: pg_recvlogical.c:77 #, c-format msgid " --start start streaming in a replication slot (for the slot's name see --slot)\n" -msgstr " --start レプリケーションスロットã§ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚’開始ã™ã‚‹ (スロットåを見るã«ã¯ --slot)\n" +msgstr " --start レプリケーションスロットã§ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚’開始ã™ã‚‹ (スロットåã¯--slotã‚’å‚ç…§)\n" -#: pg_recvlogical.c:76 +#: pg_recvlogical.c:79 #, c-format -#| msgid " -f, --file=FILENAME output file or directory name\n" msgid " -f, --file=FILE receive log into this file, - for stdout\n" -msgstr " -f, --file=FILE ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã«ãƒ­ã‚°ã‚’å—ã‘å–ã‚Šã¾ã™ã€‚ stdout ã«å‡º>力ã™ã‚‹ã«ã¯ - を使ã„ã¾ã™\n" +msgstr " -f, --file=FILE ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã«ãƒ­ã‚°ã‚’å—ã‘å–ã‚Šã¾ã™ã€‚ stdout ã«å‡ºåŠ›ã™ã‚‹ã«ã¯ - を使ã„ã¾ã™\n" -#: pg_recvlogical.c:77 +#: pg_recvlogical.c:80 #, c-format -#| msgid "" -#| " -s, --status-interval=INTERVAL\n" -#| " time between status packets sent to server (in seconds)\n" msgid "" " -F --fsync-interval=SECS\n" " time between fsyncs to the output file (default: %d)\n" @@ -836,12 +812,12 @@ msgstr "" " -F --fsync-interval=SECS\n" " 出力ファイルã¸ã®fsyncs 時間間隔(デフォルト: %d)\n" -#: pg_recvlogical.c:80 +#: pg_recvlogical.c:83 #, c-format msgid " -I, --startpos=LSN where in an existing slot should the streaming start\n" msgstr " -I, --startpos=LSN 既存スロットã®ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ãŒå§‹ã¾ã‚‹ã¹ã場所\n" -#: pg_recvlogical.c:82 +#: pg_recvlogical.c:85 #, c-format msgid "" " -o, --option=NAME[=VALUE]\n" @@ -849,299 +825,282 @@ msgid "" " output plugin\n" msgstr "" " -o, --option=NAME[=VALUE]\n" -" オプションã®å€¤VALUEã¨å…±ã«ã‚ªãƒ—ションåNAMEを出力プラグインã«\n" -" 渡ã—ã¦ãã ã•ã„\n" +" オプションã®å€¤VALUEã¨å…±ã«ã‚ªãƒ—ションåNAMEã‚’\n" +" 出力プラグインã«æ¸¡ã™\n" -#: pg_recvlogical.c:85 +#: pg_recvlogical.c:88 #, c-format msgid " -P, --plugin=PLUGIN use output plugin PLUGIN (default: %s)\n" -msgstr " -P, --plugin=PLUGIN 出力プラグインPLUGINを使用ã—ã¦ãã ã•ã„(デフォルト: %s)\n" +msgstr " -P, --plugin=PLUGIN 出力プラグインPLUGINを使用ã™ã‚‹(デフォルト: %s)\n" -#: pg_recvlogical.c:88 +#: pg_recvlogical.c:91 #, c-format msgid " -S, --slot=SLOTNAME name of the logical replication slot\n" msgstr " -S, --slot=SLOTå ロジカルレプリケーションスロットå\n" -#: pg_recvlogical.c:93 +#: pg_recvlogical.c:96 #, c-format -#| msgid " -d, --dbname=DBNAME database to cluster\n" msgid " -d, --dbname=DBNAME database to connect to\n" msgstr " -d, --dbname=データベースå 接続ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹\n" -#: pg_recvlogical.c:126 +#: pg_recvlogical.c:129 #, c-format msgid "%s: confirming write up to %X/%X, flush to %X/%X (slot %s)\n" msgstr "%s: %X/%Xã¸ã®æ›¸ã上ã’ã¨, %X/%X (スロット %sã¸ã®ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã‚’確èªã—ã¾ã™\n" -#: pg_recvlogical.c:151 receivelog.c:404 +#: pg_recvlogical.c:154 receivelog.c:407 #, c-format msgid "%s: could not send feedback packet: %s" msgstr "%s: フィードãƒãƒƒã‚¯ãƒ‘ケットをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_recvlogical.c:190 +#: pg_recvlogical.c:193 #, c-format -#| msgid "%s: could not fsync file \"%s\": %s\n" msgid "%s: could not fsync log file \"%s\": %s\n" msgstr "%s: ログファイル\"%s\"ã‚’fsyncã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_recvlogical.c:229 +#: pg_recvlogical.c:232 #, c-format -#| msgid "%s: starting log streaming at %X/%X (timeline %u)\n" msgid "%s: starting log streaming at %X/%X (slot %s)\n" msgstr "%s: %X/%X (スロット %s)ã§ãƒ­ã‚°ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚’始ã‚ã¾ã™\n" -#: pg_recvlogical.c:271 +#: pg_recvlogical.c:274 #, c-format -#| msgid "%s: streaming header too small: %d\n" msgid "%s: streaming initiated\n" msgstr "%s: ストリーミングをåˆæœŸåŒ–ã—ã¾ã—ãŸ\n" -#: pg_recvlogical.c:336 +#: pg_recvlogical.c:339 #, c-format msgid "%s: could not open log file \"%s\": %s\n" msgstr "%s: ログファイル \"%s\" をオープンã§ãã¾ã›ã‚“: %s\n" -#: pg_recvlogical.c:366 receivelog.c:935 +#: pg_recvlogical.c:369 receivelog.c:938 #, c-format -#| msgid "%s: invalid argument: %s\n" msgid "%s: invalid socket: %s" msgstr "%s: 無効ãªã‚½ã‚±ãƒƒãƒˆã§ã™: %s" -#: pg_recvlogical.c:420 receivelog.c:957 +#: pg_recvlogical.c:423 receivelog.c:960 #, c-format msgid "%s: select() failed: %s\n" msgstr "%s: select()ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: pg_recvlogical.c:429 receivelog.c:1007 +#: pg_recvlogical.c:432 receivelog.c:1010 #, c-format msgid "%s: could not receive data from WAL stream: %s" msgstr "%s: WALストリームã‹ã‚‰ãƒ‡ãƒ¼ã‚¿ã‚’å—ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_recvlogical.c:470 pg_recvlogical.c:509 receivelog.c:1052 -#: receivelog.c:1119 +#: pg_recvlogical.c:473 pg_recvlogical.c:512 receivelog.c:1055 +#: receivelog.c:1122 #, c-format msgid "%s: streaming header too small: %d\n" msgstr "%s: ストリーミングヘッダãŒå°ã•éŽãŽã¾ã™: %d\n" -#: pg_recvlogical.c:492 receivelog.c:900 +#: pg_recvlogical.c:495 receivelog.c:903 #, c-format msgid "%s: unrecognized streaming header: \"%c\"\n" msgstr "%s: ストリーミングヘッダ\"%c\"ã¯ä¸æ˜Žã§ã™\n" -#: pg_recvlogical.c:538 pg_recvlogical.c:552 +#: pg_recvlogical.c:541 pg_recvlogical.c:555 #, c-format -#| msgid "%s: could not write %u bytes to WAL file \"%s\": %s\n" msgid "%s: could not write %u bytes to log file \"%s\": %s\n" msgstr "%s: %uãƒã‚¤ãƒˆã‚’ログファイル\"%s\"ã«æ›¸ãè¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_recvlogical.c:563 receivelog.c:693 receivelog.c:731 +#: pg_recvlogical.c:566 receivelog.c:696 receivelog.c:734 #, c-format msgid "%s: unexpected termination of replication stream: %s" msgstr "%s: レプリケーションストリームã®æƒ³å®šå¤–ã®çµ‚了: %s" -#: pg_recvlogical.c:686 +#: pg_recvlogical.c:689 #, c-format -#| msgid "%s: invalid status interval \"%s\"\n" msgid "%s: invalid fsync interval \"%s\"\n" msgstr "%s: 無効ãªfsyncã®é–“éš”\"%s\"ã§ã™\n" -#: pg_recvlogical.c:727 +#: pg_recvlogical.c:730 #, c-format -#| msgid "%s: could not parse version \"%s\"\n" msgid "%s: could not parse start position \"%s\"\n" msgstr "%s: 開始ä½ç½®\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_recvlogical.c:811 +#: pg_recvlogical.c:814 #, c-format -#| msgid "%s: no operation specified\n" msgid "%s: no slot specified\n" msgstr "%s: スロットãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_recvlogical.c:819 +#: pg_recvlogical.c:822 #, c-format -#| msgid "%s: no target directory specified\n" msgid "%s: no target file specified\n" msgstr "%s: ターゲットファイルãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_recvlogical.c:827 +#: pg_recvlogical.c:830 #, c-format -#| msgid "%s: no data directory specified\n" msgid "%s: no database specified\n" msgstr "%s: データベースãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_recvlogical.c:835 +#: pg_recvlogical.c:838 #, c-format -#| msgid "%s: no operation specified\n" msgid "%s: at least one action needs to be specified\n" msgstr "%s: å°‘ãªãã¨ã‚‚一ã¤ã®ã‚¢ã‚¯ã‚·ãƒ§ãƒ³ã‚’指定ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™\n" -#: pg_recvlogical.c:843 +#: pg_recvlogical.c:846 #, c-format msgid "%s: cannot use --create-slot or --start together with --drop-slot\n" msgstr "%s: --create-slotã‚„--startã¯--drop-slotã¨å…±ã«ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_recvlogical.c:851 +#: pg_recvlogical.c:854 #, c-format msgid "%s: cannot use --create-slot or --drop-slot together with --startpos\n" msgstr "%s: --create-slotã‚„--drop-slotã¯--startposã¨å…±ã«ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_recvlogical.c:882 +#: pg_recvlogical.c:885 #, c-format -#| msgid "could not establish SSL connection: %s\n" msgid "%s: could not establish database-specific replication connection\n" msgstr "%s: データベース指定ã®ãƒ¬ãƒ—リケーション接続ãŒç¢ºç«‹ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: receivelog.c:66 +#: receivelog.c:69 #, c-format -#| msgid "could not create archive status file \"%s\": %m" msgid "%s: could not create archive status file \"%s\": %s\n" msgstr "%s: アーカイブ状態ファイル\"%s\"ã®ä½œæˆã«å¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: receivelog.c:73 receivelog.c:196 receivelog.c:344 receivelog.c:830 -#: receivelog.c:1073 +#: receivelog.c:76 receivelog.c:199 receivelog.c:347 receivelog.c:833 +#: receivelog.c:1076 #, c-format msgid "%s: could not fsync file \"%s\": %s\n" msgstr "%s: ファイル\"%s\"ã‚’fsyncã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:111 +#: receivelog.c:114 #, c-format msgid "%s: could not open transaction log file \"%s\": %s\n" msgstr "%s: トランザクションログファイル \"%s\" をオープンã§ãã¾ã›ã‚“: %s\n" -#: receivelog.c:123 +#: receivelog.c:126 #, c-format msgid "%s: could not stat transaction log file \"%s\": %s\n" msgstr "%s: トランザクションログファイル \"%s\" ã®çŠ¶æ…‹ã‚’確èªã§ãã¾ã›ã‚“: %s\n" -#: receivelog.c:137 +#: receivelog.c:140 #, c-format msgid "%s: transaction log file \"%s\" has %d bytes, should be 0 or %d\n" msgstr "%s: トランザクションログファイル\"%s\"ã¯%dãƒã‚¤ãƒˆã§ã™ã€‚0ã¾ãŸã¯%dã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: receivelog.c:150 +#: receivelog.c:153 #, c-format msgid "%s: could not pad transaction log file \"%s\": %s\n" msgstr "%s: トランザクションログファイル\"%s\"を埋ã‚ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:163 +#: receivelog.c:166 #, c-format msgid "%s: could not seek to beginning of transaction log file \"%s\": %s\n" msgstr "%s: トランザクションログファイル\"%s\"ã®å…ˆé ­ã«ã‚·ãƒ¼ã‚¯ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:189 +#: receivelog.c:192 #, c-format msgid "%s: could not determine seek position in file \"%s\": %s\n" msgstr "%s: ファイル\"%s\"ã®ã‚·ãƒ¼ã‚¯ä½ç½®ã‚’決定ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:222 +#: receivelog.c:225 #, c-format msgid "%s: could not rename file \"%s\": %s\n" msgstr "%s: \"%s\"ファイルã®åå‰ã‚’変更ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:229 +#: receivelog.c:232 #, c-format msgid "%s: not renaming \"%s%s\", segment is not complete\n" msgstr "%s: \"%s%s\"ã®åå‰ã‚’変更ã—ã¾ã›ã‚“。セグメントãŒå®Œäº†ã—ã¦ã„ã¾ã›ã‚“。\n" -#: receivelog.c:275 +#: receivelog.c:278 #, c-format msgid "%s: could not open timeline history file \"%s\": %s\n" msgstr "%s: タイムライン履歴ファイル \"%s\" をオープンã§ãã¾ã›ã‚“: %s\n" -#: receivelog.c:302 +#: receivelog.c:305 #, c-format msgid "%s: server reported unexpected history file name for timeline %u: %s\n" msgstr "%s: サーãƒã¯ãƒ©ã‚¤ãƒ ãƒ©ã‚¤ãƒ³%u用ã®å±¥æ­´ãƒ•ã‚¡ã‚¤ãƒ«ãŒæƒ³å®šå¤–ã§ã‚ã‚‹ã“ã¨ã‚’報告ã—ã¾ã—ãŸ: %s\n" -#: receivelog.c:319 +#: receivelog.c:322 #, c-format msgid "%s: could not create timeline history file \"%s\": %s\n" msgstr "%s: \"%s\"タイムライン履歴ファイルを作æˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:336 +#: receivelog.c:339 #, c-format msgid "%s: could not write timeline history file \"%s\": %s\n" msgstr "%s: \"%s\"タイムライン履歴ファイルã«æ›¸ã出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:361 +#: receivelog.c:364 #, c-format msgid "%s: could not rename file \"%s\" to \"%s\": %s\n" msgstr "%s: ファイル\"%s\"ã®åå‰ã‚’\"%s\"ã«å¤‰æ›´ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: receivelog.c:438 +#: receivelog.c:441 #, c-format -#| msgid "%s: incompatible server version %s; streaming is only supported with server version %s\n" msgid "%s: incompatible server version %s; client does not support streaming from server versions older than %s\n" msgstr "%s: 互æ›æ€§ã®ãªã„サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³%sã§ã™; クライアントã¯%sよりå¤ã„サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‹ã‚‰ã®ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" -#: receivelog.c:448 +#: receivelog.c:451 #, c-format -#| msgid "%s: incompatible server version %s; streaming is only supported with server version %s\n" msgid "%s: incompatible server version %s; client does not support streaming from server versions newer than %s\n" msgstr "%s: 互æ›æ€§ã®ãªã„サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³%sã§ã™; クライアントã¯%sより新ã—ã„サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‹ã‚‰ã®ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" -#: receivelog.c:546 streamutil.c:272 streamutil.c:311 +#: receivelog.c:549 streamutil.c:272 streamutil.c:311 #, c-format -#| msgid "%s: could not identify system: got %d rows and %d fields, expected %d rows and %d fields\n" msgid "%s: could not identify system: got %d rows and %d fields, expected %d rows and %d or more fields\n" -msgstr "%s: システムを識別ã§ãã¾ã›ã‚“ã§ã—ãŸ: %d è¡ŒãŠã‚ˆã³ %d フィールドã€æœŸå¾…ã™ã‚‹%d è¡ŒãŠã‚ˆã³ %d ã¾ãŸã¯ãれ以上ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰\n" +msgstr "%s: システムを識別ã§ãã¾ã›ã‚“ã§ã—ãŸ: %dè¡Œã¨%dフィールドをå–å¾—ã—ã¾ã—ãŸãŒã€æœŸå¾…ã—ã¦ã„ãŸã®ã¯%dè¡Œã¨%d以上ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã§ã™\n" -#: receivelog.c:554 +#: receivelog.c:557 #, c-format msgid "%s: system identifier does not match between base backup and streaming connection\n" msgstr "%s: システム識別å­ãŒãƒ™ãƒ¼ã‚¹ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã¨ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°æŽ¥ç¶šã®é–“ã§ä¸€è‡´ã—ã¾ã›ã‚“\n" -#: receivelog.c:562 +#: receivelog.c:565 #, c-format msgid "%s: starting timeline %u is not present in the server\n" msgstr "%s: 開始ã™ã‚‹ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³%uãŒã‚µãƒ¼ãƒä¸Šã«å­˜åœ¨ã—ã¾ã›ã‚“\n" -#: receivelog.c:602 +#: receivelog.c:605 #, c-format msgid "%s: unexpected response to TIMELINE_HISTORY command: got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: TIMELINE_HISTORYコマンドã¸ã®æƒ³å®šå¤–ã®å¿œç­”: %dè¡Œã¨%dフィールドを入手ã—ã¾ã—ãŸã€‚想定ã§ã¯%dè¡Œã¨%dフィールドã§ã—ãŸ\n" -#: receivelog.c:674 +#: receivelog.c:677 #, c-format msgid "%s: server reported unexpected next timeline %u, following timeline %u\n" msgstr "%1$s: サーãƒãŒã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³%3$uã«ç¶šã次ã®ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³%2$uãŒæƒ³å®šå¤–ã§ã‚ã‚‹ã“ã¨ã‚’報告ã—ã¾ã—ãŸ\n" -#: receivelog.c:681 +#: receivelog.c:684 #, c-format msgid "%s: server stopped streaming timeline %u at %X/%X, but reported next timeline %u to begin at %X/%X\n" msgstr "%s: サーãƒã¯ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³%uã‚’%X%Xã§åœæ­¢ã—ã¾ã—ãŸã€‚ã—ã‹ã—次ã®ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³%uãŒ%X%Xã§å§‹ã¾ã‚Šã¾ã—ãŸ\n" -#: receivelog.c:722 +#: receivelog.c:725 #, c-format msgid "%s: replication stream was terminated before stop point\n" msgstr "%s: レプリケーションストリームãŒã‚¹ãƒˆãƒƒãƒ—ãƒã‚¤ãƒ³ãƒˆã®å‰ã«çµ‚了ã—ã¾ã—ãŸ\n" -#: receivelog.c:771 +#: receivelog.c:774 #, c-format msgid "%s: unexpected result set after end-of-timeline: got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: タイムラインã®çµ‚了後ã®æƒ³å®šå¤–ã®çµæžœã‚»ãƒƒãƒˆ: %dè¡Œã€%dフィールドを入手ã—ã¾ã—ãŸãŒã€æƒ³å®šã—ã¦ã„ãŸã®ã¯%dè¡Œã€%dフィールドã§ã—ãŸ\n" -#: receivelog.c:781 +#: receivelog.c:784 #, c-format msgid "%s: could not parse next timeline's starting point \"%s\"\n" msgstr "%s: 次ã®ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³ã®é–‹å§‹ãƒã‚¤ãƒ³ãƒˆ\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: receivelog.c:1138 +#: receivelog.c:1141 #, c-format msgid "%s: received transaction log record for offset %u with no file open\n" msgstr "%s: ファイルオープンãŒãªã„オフセット%uã«å¯¾ã™ã‚‹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãƒ­ã‚°ãƒ¬ã‚³ãƒ¼ãƒ‰ã‚’å—ä¿¡\n" -#: receivelog.c:1150 +#: receivelog.c:1153 #, c-format msgid "%s: got WAL data offset %08x, expected %08x\n" msgstr "%s: WALデータオフセット%08xを入手。想定値ã¯%08x\n" -#: receivelog.c:1186 +#: receivelog.c:1189 #, c-format msgid "%s: could not write %u bytes to WAL file \"%s\": %s\n" msgstr "%1$s: WALファイル\"%3$s\"ã«%2$uãƒã‚¤ãƒˆæ›¸ã出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %4$s\n" -#: receivelog.c:1211 receivelog.c:1252 receivelog.c:1283 +#: receivelog.c:1214 receivelog.c:1255 receivelog.c:1286 #, c-format msgid "%s: could not send copy-end packet: %s" msgstr "%s: コピーエンドパケットをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" @@ -1157,7 +1116,6 @@ msgstr "%s: サーãƒã«æŽ¥ç¶šã§ãã¾ã›ã‚“ã§ã—ãŸ\n" #: streamutil.c:195 #, c-format -#| msgid "%s: could not connect to server: %s\n" msgid "%s: could not connect to server: %s" msgstr "%s: サーãƒã«æŽ¥ç¶šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" @@ -1173,39 +1131,37 @@ msgstr "%s: integer_datetimesコンパイルフラグãŒã‚µãƒ¼ãƒã¨ä¸€è‡´ã—ã¾ #: streamutil.c:379 #, c-format -#| msgid "%s: could not identify system: got %d rows and %d fields, expected %d rows and %d fields\n" msgid "%s: could not create replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: レプリケーションスロット\"%s\"を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ; %dè¡Œã¨%dフィールドをå–å¾—ã—ã¾ã—ãŸãŒã€æœŸå¾…ã—ã¦ã„ãŸã®ã¯%dè¡Œã¨%dフィールドã§ã™\n" #: streamutil.c:424 #, c-format -#| msgid "%s: could not identify system: got %d rows and %d fields, expected %d rows and %d fields\n" msgid "%s: could not drop replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: レプリケーションスロット\"%s\"を削除ã§ãã¾ã›ã‚“ã§ã—ãŸ; %dè¡Œã¨%dフィールドをå–å¾—ã—ã¾ã—ãŸãŒã€æœŸå¾…ã—ã¦ã„ãŸã®ã¯%dè¡Œã¨%dフィールドã§ã™\n" -#~ msgid "%s: timeline does not match between base backup and streaming connection\n" -#~ msgstr "%s: タイムラインãŒãƒ™ãƒ¼ã‚¹ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã¨ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°æŽ¥ç¶šã®é–“ã§ä¸€è‡´ã—ã¾ã›ã‚“\n" +#~ msgid "%s: could not parse file size\n" +#~ msgstr "%s: ファイルサイズã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#~ msgid "%s: keepalive message has incorrect size %d\n" -#~ msgstr "%s: キープアライブメッセージã®ã‚µã‚¤ã‚º%dãŒä¸æ­£ã§ã™\n" +#~ msgid "%s: could not parse file mode\n" +#~ msgstr "%s: ファイルモードã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#~ msgid "%s: no start point returned from server\n" -#~ msgstr "%s: サーãƒã‹ã‚‰ã‚¹ã‚¿ãƒ¼ãƒˆãƒã‚¤ãƒ³ãƒˆãŒè¿”ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" +#~ msgid "%s: could not parse transaction log file name \"%s\"\n" +#~ msgstr "%s: トランザクションログファイルå\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#~ msgid "%s: could not close file %s: %s\n" -#~ msgstr "%s: ファイル%sã‚’é–‰ã˜ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" +#~ msgid " --help show this help, then exit\n" +#~ msgstr " --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—終了ã—ã¾ã™\n" #~ msgid " --version output version information, then exit\n" #~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を出力ã—終了ã—ã¾ã™\n" -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—終了ã—ã¾ã™\n" +#~ msgid "%s: could not close file %s: %s\n" +#~ msgstr "%s: ファイル%sã‚’é–‰ã˜ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#~ msgid "%s: could not parse transaction log file name \"%s\"\n" -#~ msgstr "%s: トランザクションログファイルå\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" +#~ msgid "%s: no start point returned from server\n" +#~ msgstr "%s: サーãƒã‹ã‚‰ã‚¹ã‚¿ãƒ¼ãƒˆãƒã‚¤ãƒ³ãƒˆãŒè¿”ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#~ msgid "%s: could not parse file mode\n" -#~ msgstr "%s: ファイルモードã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" +#~ msgid "%s: keepalive message has incorrect size %d\n" +#~ msgstr "%s: キープアライブメッセージã®ã‚µã‚¤ã‚º%dãŒä¸æ­£ã§ã™\n" -#~ msgid "%s: could not parse file size\n" -#~ msgstr "%s: ファイルサイズã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" +#~ msgid "%s: timeline does not match between base backup and streaming connection\n" +#~ msgstr "%s: タイムラインãŒãƒ™ãƒ¼ã‚¹ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã¨ã‚¹ãƒˆãƒªãƒ¼ãƒŸãƒ³ã‚°æŽ¥ç¶šã®é–“ã§ä¸€è‡´ã—ã¾ã›ã‚“\n" diff --git a/src/bin/pg_config/po/it.po b/src/bin/pg_config/po/it.po index 6a2013fbf0..6491ea42fc 100644 --- a/src/bin/pg_config/po/it.po +++ b/src/bin/pg_config/po/it.po @@ -19,8 +19,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_config (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:14+0000\n" -"PO-Revision-Date: 2012-11-02 13:39+0100\n" +"POT-Creation-Date: 2017-02-09 21:13+0000\n" +"PO-Revision-Date: 2017-04-23 03:04+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -29,7 +29,15 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" "X-Poedit-SourceCharset: utf-8\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" + +#: ../../common/config_info.c:131 ../../common/config_info.c:139 +#: ../../common/config_info.c:147 ../../common/config_info.c:155 +#: ../../common/config_info.c:163 ../../common/config_info.c:171 +#: ../../common/config_info.c:179 ../../common/config_info.c:187 +#: ../../common/config_info.c:195 +msgid "not recorded" +msgstr "non registrato" #: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format diff --git a/src/bin/pg_config/po/ja.po b/src/bin/pg_config/po/ja.po index ec2b4e584e..e1e2867d6b 100644 --- a/src/bin/pg_config/po/ja.po +++ b/src/bin/pg_config/po/ja.po @@ -5,9 +5,9 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.0 beta 3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2013-08-18 11:27+0900\n" -"PO-Revision-Date: 2012-08-11 16:53+0900\n" -"Last-Translator: HOTTA Michihide \n" +"POT-Creation-Date: 2017-04-03 13:41+0900\n" +"PO-Revision-Date: 2017-02-01 16:53+0900\n" +"Last-Translator: Ideriha Takeshi \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -15,49 +15,50 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" -#: ../../port/exec.c:127 ../../port/exec.c:241 ../../port/exec.c:284 +#: ../../common/config_info.c:131 ../../common/config_info.c:139 +#: ../../common/config_info.c:147 ../../common/config_info.c:155 +#: ../../common/config_info.c:163 ../../common/config_info.c:171 +#: ../../common/config_info.c:179 ../../common/config_info.c:187 +#: ../../common/config_info.c:195 +msgid "not recorded" +msgstr "記録ã•ã‚Œã¦ã„ã¾ã›ã‚“" + +#: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format msgid "could not identify current directory: %s" msgstr "ç¾åœ¨ã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’èªè­˜ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: ../../port/exec.c:146 +#: ../../common/exec.c:146 #, c-format msgid "invalid binary \"%s\"" msgstr "ãƒã‚¤ãƒŠãƒª\"%s\"ã¯ç„¡åŠ¹ã§ã™" -#: ../../port/exec.c:195 +#: ../../common/exec.c:195 #, c-format msgid "could not read binary \"%s\"" msgstr "ãƒã‚¤ãƒŠãƒª\"%s\"を読ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ" -#: ../../port/exec.c:202 +#: ../../common/exec.c:202 #, c-format msgid "could not find a \"%s\" to execute" msgstr "実行ã™ã‚‹\"%s\"ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ" -#: ../../port/exec.c:257 ../../port/exec.c:293 +#: ../../common/exec.c:257 ../../common/exec.c:293 #, c-format msgid "could not change directory to \"%s\": %s" msgstr "ディレクトリ\"%s\"ã«ç§»å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: ../../port/exec.c:272 +#: ../../common/exec.c:272 #, c-format msgid "could not read symbolic link \"%s\"" msgstr "シンボリックリンク\"%s\"を読ã¿å–ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: ../../port/exec.c:523 +#: ../../common/exec.c:523 #, c-format msgid "pclose failed: %s" msgstr "pcloseãŒå¤±æ•—ã—ã¾ã—ãŸ: %s" -#: pg_config.c:243 pg_config.c:259 pg_config.c:275 pg_config.c:291 -#: pg_config.c:307 pg_config.c:323 pg_config.c:339 pg_config.c:355 -#: pg_config.c:371 -#, c-format -msgid "not recorded\n" -msgstr "記録ã•ã‚Œã¦ã„ã¾ã›ã‚“\n" - -#: pg_config.c:428 +#: pg_config.c:74 #, c-format msgid "" "\n" @@ -68,12 +69,12 @@ msgstr "" "%sã¯ã‚¤ãƒ³ã‚¹ãƒˆãƒ¼ãƒ«ã•ã‚ŒãŸãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®PostgreSQLã«é–¢ã™ã‚‹æƒ…報をæä¾›ã—ã¾ã™ã€‚\n" "\n" -#: pg_config.c:429 +#: pg_config.c:75 #, c-format msgid "Usage:\n" msgstr "使用方法:\n" -#: pg_config.c:430 +#: pg_config.c:76 #, c-format msgid "" " %s [OPTION]...\n" @@ -82,136 +83,136 @@ msgstr "" " %s [オプション]...\n" "\n" -#: pg_config.c:431 +#: pg_config.c:77 #, c-format msgid "Options:\n" msgstr "オプション:\n" -#: pg_config.c:432 +#: pg_config.c:78 #, c-format msgid " --bindir show location of user executables\n" msgstr " --bindir ユーザ実行ファイルã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:433 +#: pg_config.c:79 #, c-format msgid " --docdir show location of documentation files\n" msgstr " --docdir 文書ファイルã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:434 +#: pg_config.c:80 #, c-format msgid " --htmldir show location of HTML documentation files\n" msgstr " --htmldir html文書ファイルã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:435 +#: pg_config.c:81 #, c-format msgid "" " --includedir show location of C header files of the client\n" " interfaces\n" msgstr " --includedir クライアントインタフェース用Cヘッダファイルã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:437 +#: pg_config.c:83 #, c-format msgid " --pkgincludedir show location of other C header files\n" msgstr " --pkgincludedir ãã®ä»–ã®Cヘッダファイルã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:438 +#: pg_config.c:84 #, c-format msgid " --includedir-server show location of C header files for the server\n" msgstr " --includedir-server サーãƒç”¨Cヘッダファイルã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:439 +#: pg_config.c:85 #, c-format msgid " --libdir show location of object code libraries\n" msgstr " --libdir オブジェクトコードライブラリã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:440 +#: pg_config.c:86 #, c-format msgid " --pkglibdir show location of dynamically loadable modules\n" msgstr " --pkglibdir 動的ロードå¯èƒ½ãƒ¢ã‚¸ãƒ¥ãƒ¼ãƒ«ã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:441 +#: pg_config.c:87 #, c-format msgid " --localedir show location of locale support files\n" msgstr " --localedir ロケールサãƒãƒ¼ãƒˆãƒ•ã‚¡ã‚¤ãƒ«ã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:442 +#: pg_config.c:88 #, c-format msgid " --mandir show location of manual pages\n" msgstr " --mandir マニュアルページã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:443 +#: pg_config.c:89 #, c-format msgid " --sharedir show location of architecture-independent support files\n" msgstr " --sharedir アーキテクãƒãƒ£ã«ä¾å­˜ã—ãªã„サãƒãƒ¼ãƒˆãƒ•ã‚¡ã‚¤ãƒ«ã®å ´æ‰€ã‚’表示ã—ã¾ã™ã€‚\n" -#: pg_config.c:444 +#: pg_config.c:90 #, c-format msgid " --sysconfdir show location of system-wide configuration files\n" msgstr " --sysconfdir システム全体ã®è¨­å®šãƒ•ã‚¡ã‚¤ãƒ«ã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:445 +#: pg_config.c:91 #, c-format msgid " --pgxs show location of extension makefile\n" msgstr " --pgxs æ‹¡å¼µmakefileã®å ´æ‰€ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:446 +#: pg_config.c:92 #, c-format msgid "" " --configure show options given to \"configure\" script when\n" " PostgreSQL was built\n" msgstr " --configure PostgreSQL構築時ã®\"configure\"スクリプトã§æŒ‡å®šã—ãŸã‚ªãƒ—ションを表示ã—ã¾ã™\n" -#: pg_config.c:448 +#: pg_config.c:94 #, c-format msgid " --cc show CC value used when PostgreSQL was built\n" msgstr " --cc PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸCCã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:449 +#: pg_config.c:95 #, c-format msgid " --cppflags show CPPFLAGS value used when PostgreSQL was built\n" msgstr " --cppflags PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸCPPFLAGSã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:450 +#: pg_config.c:96 #, c-format msgid " --cflags show CFLAGS value used when PostgreSQL was built\n" msgstr " --cflags PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸCFLAGSã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:451 +#: pg_config.c:97 #, c-format msgid " --cflags_sl show CFLAGS_SL value used when PostgreSQL was built\n" msgstr " --cflags_sl PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸCFLAGS_SLã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:452 +#: pg_config.c:98 #, c-format msgid " --ldflags show LDFLAGS value used when PostgreSQL was built\n" msgstr " --ldflags PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸLDFLAGSã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:453 +#: pg_config.c:99 #, c-format msgid " --ldflags_ex show LDFLAGS_EX value used when PostgreSQL was built\n" msgstr " --ldflags_ex PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸLDFLAGS_EXã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:454 +#: pg_config.c:100 #, c-format msgid " --ldflags_sl show LDFLAGS_SL value used when PostgreSQL was built\n" msgstr " --ldflags_sl PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸLDFLAGS_SLã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:455 +#: pg_config.c:101 #, c-format msgid " --libs show LIBS value used when PostgreSQL was built\n" msgstr " --libs PostgreSQL構築時ã«ä½¿ç”¨ã—ãŸLIBSã®å€¤ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:456 +#: pg_config.c:102 #, c-format msgid " --version show the PostgreSQL version\n" msgstr " --version PostgreSQLã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’表示ã—ã¾ã™\n" -#: pg_config.c:457 +#: pg_config.c:103 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_config.c:458 +#: pg_config.c:104 #, c-format msgid "" "\n" @@ -222,43 +223,23 @@ msgstr "" "引数ãŒãªã„å ´åˆã€æ—¢çŸ¥ã®é …目をã™ã¹ã¦è¡¨ç¤ºã—ã¾ã™ã€‚\n" "\n" -#: pg_config.c:459 +#: pg_config.c:105 #, c-format msgid "Report bugs to .\n" msgstr "ä¸å…·åˆã¯ã¾ã§å ±å‘Šã—ã¦ãã ã•ã„。\n" -#: pg_config.c:465 +#: pg_config.c:111 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細ã¯\"%s --help\"ã‚’è¡Œã£ã¦ãã ã•ã„\n" -#: pg_config.c:504 +#: pg_config.c:153 #, c-format msgid "%s: could not find own program executable\n" msgstr "%s: 実行ファイル自体ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_config.c:527 +#: pg_config.c:180 #, c-format msgid "%s: invalid argument: %s\n" msgstr "%s: 無効ãªå¼•æ•°ã§ã™: %s\n" -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã€çµ‚了ã—ã¾ã™\n" - -#~ msgid "could not change directory to \"%s\"" -#~ msgstr "ディレクトリ\"%s\"ã«ç§»å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸ" - -#~ msgid "child process was terminated by signal %s" -#~ msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%sã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid "child process was terminated by exception 0x%X" -#~ msgstr "å­ãƒ—ロセスãŒä¾‹å¤–0x%Xã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid "child process exited with exit code %d" -#~ msgstr "å­ãƒ—ロセスãŒçµ‚了コード%dã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid "child process exited with unrecognized status %d" -#~ msgstr "å­ãƒ—ロセスãŒæœªçŸ¥ã®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹%dã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid "child process was terminated by signal %d" -#~ msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%dã§çµ‚了ã—ã¾ã—ãŸ" diff --git a/src/bin/pg_controldata/po/it.po b/src/bin/pg_controldata/po/it.po index 20e1554082..3bdb0deec3 100644 --- a/src/bin/pg_controldata/po/it.po +++ b/src/bin/pg_controldata/po/it.po @@ -23,8 +23,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_controldata (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:15+0000\n" -"PO-Revision-Date: 2016-04-17 20:45+0100\n" +"POT-Creation-Date: 2017-02-09 21:14+0000\n" +"PO-Revision-Date: 2017-04-23 03:02+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -33,7 +33,52 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-SourceCharset: utf-8\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" + +#: ../../common/controldata_utils.c:56 +#, c-format +msgid "%s: could not open file \"%s\" for reading: %s\n" +msgstr "%s: apertura del file \"%s\" per la lettura fallita: %s\n" + +#: ../../common/controldata_utils.c:69 +#, c-format +msgid "%s: could not read file \"%s\": %s\n" +msgstr "%s: lettura del file \"%s\" fallita: %s\n" + +#: ../../common/controldata_utils.c:86 +msgid "calculated CRC checksum does not match value stored in file" +msgstr "il codice di controllo CRC calcolato non combacia con quello memorizzato nel file" + +#: ../../common/controldata_utils.c:88 +#, c-format +msgid "" +"WARNING: Calculated CRC checksum does not match value stored in file.\n" +"Either the file is corrupt, or it has a different layout than this program\n" +"is expecting. The results below are untrustworthy.\n" +"\n" +msgstr "" +"ATTENZIONE: Il codice di controllo CRC calcolato non combacia con quello\n" +"memorizzato nel file. O il file è corrotto o ha un formato diverso da quanto\n" +"questo programma si aspetta. I risultati seguenti non sono affidabili.\n" +"\n" + +#: ../../common/controldata_utils.c:97 +msgid "byte ordering mismatch" +msgstr "ordinamento dei byte non combaciante" + +#: ../../common/controldata_utils.c:99 +#, c-format +msgid "" +"WARNING: possible byte ordering mismatch\n" +"The byte ordering used to store the pg_control file might not match the one\n" +"used by this program. In that case the results below would be incorrect, and\n" +"the PostgreSQL installation would be incompatible with this data directory.\n" +msgstr "" +"ATTENZIONE: possibile differenza nell'ordine dei byte\n" +"L'ordine dei byte usato per memorizzare il file pg_control potrebbe non\n" +"combaciare con quello usato da questo programma. In questo caso i risultati\n" +"seguenti non sarebbero corretti e l'installazione di PostgreSQL sarebbe\n" +"incompatibile con questa directory di dati.\n" #: pg_controldata.c:33 #, c-format diff --git a/src/bin/pg_controldata/po/ja.po b/src/bin/pg_controldata/po/ja.po index 9e3f33215d..cb3ec46eb4 100644 --- a/src/bin/pg_controldata/po/ja.po +++ b/src/bin/pg_controldata/po/ja.po @@ -3,11 +3,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.0 beta 3\n" +"Project-Id-Version: PostgreSQL 9.6.2 \n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2013-08-18 11:29+0900\n" +"POT-Creation-Date: 2017-04-03 13:37+0900\n" "PO-Revision-Date: 2013-08-18 11:36+0900\n" -"Last-Translator: HOTTA Michihide \n" +"Last-Translator: Ideriah Takeshi \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -15,7 +15,51 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" -#: pg_controldata.c:34 +#: ../../common/controldata_utils.c:56 +#, c-format +msgid "%s: could not open file \"%s\" for reading: %s\n" +msgstr "%s: 読ã¿å–り用ã®\"%s\"ファイルã®ã‚ªãƒ¼ãƒ—ンã«å¤±æ•—ã—ã¾ã—ãŸ: %s\n" + +#: ../../common/controldata_utils.c:69 +#, c-format +msgid "%s: could not read file \"%s\": %s\n" +msgstr "%s: \"%s\"ファイルã®èª­ã¿å–ã‚Šã«å¤±æ•—ã—ã¾ã—ãŸ: %s\n" + +#: ../../common/controldata_utils.c:86 +msgid "calculated CRC checksum does not match value stored in file" +msgstr "" + +#: ../../common/controldata_utils.c:88 +#, c-format +msgid "" +"WARNING: Calculated CRC checksum does not match value stored in file.\n" +"Either the file is corrupt, or it has a different layout than this program\n" +"is expecting. The results below are untrustworthy.\n" +"\n" +msgstr "" +"警告: CRCãƒã‚§ãƒƒã‚¯ã‚µãƒ ã®è¨ˆç®—çµæžœãŒãƒ•ã‚¡ã‚¤ãƒ«å†…ã®å€¤ã¨ä¸€è‡´ã—ã¾ã›ã‚“。\n" +"ファイルã®ç ´æã€ã‚ã‚‹ã„ã¯ã€æœ¬ãƒ—ログラムãŒæƒ³å®šã™ã‚‹ãƒ¬ã‚¤ã‚¢ã‚¦ãƒˆã¨ç•°ãªã‚‹\n" +"å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚以下ã®çµæžœã¯ä¿¡ç”¨ã§ãã¾ã›ã‚“。\n" +"\n" + +#: ../../common/controldata_utils.c:97 +msgid "byte ordering mismatch" +msgstr "ãƒã‚¤ãƒˆã‚ªãƒ¼ãƒ€ãŒåˆã„ã¾ã›ã‚“" + +#: ../../common/controldata_utils.c:99 +#, c-format +msgid "" +"WARNING: possible byte ordering mismatch\n" +"The byte ordering used to store the pg_control file might not match the one\n" +"used by this program. In that case the results below would be incorrect, and\n" +"the PostgreSQL installation would be incompatible with this data directory.\n" +msgstr "" +"警告:ãƒã‚¤ãƒˆã‚ªãƒ¼ãƒ€ãŒç•°ãªã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚\n" +"pg_controlファイルを格ç´ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã™ã‚‹ãƒã‚¤ãƒˆã‚ªãƒ¼ãƒ€ãŒæœ¬ãƒ—ログラムã§ä½¿ç”¨\n" +"ã•ã‚Œã‚‹ã‚‚ã®ã¨ç•°ãªã‚Šã¾ã™ã€‚ã“ã®å ´åˆä»¥ä¸‹ã®çµæžœã¯ä¸æ­£ç¢ºã«ãªã‚Šã¾ã™ã€‚ã¾ãŸã€PostgreSQL\n" +"インストレーションã¯ã“ã®ãƒ‡ãƒ¼ã‚¿ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã¨äº’æ›æ€§ãŒãªããªã‚Šã¾ã™ã€‚\n" + +#: pg_controldata.c:33 #, c-format msgid "" "%s displays control information of a PostgreSQL database cluster.\n" @@ -24,17 +68,17 @@ msgstr "" "%s ã¯PostgreSQLデータベースクラスタã®åˆ¶å¾¡æƒ…報を表示ã—ã¾ã™ã€‚\n" "\n" -#: pg_controldata.c:35 +#: pg_controldata.c:34 #, c-format msgid "Usage:\n" msgstr "使用方法:\n" -#: pg_controldata.c:36 +#: pg_controldata.c:35 #, c-format msgid " %s [OPTION] [DATADIR]\n" msgstr " %s [OPTION] [DATADIR]\n" -#: pg_controldata.c:37 +#: pg_controldata.c:36 #, c-format msgid "" "\n" @@ -43,6 +87,11 @@ msgstr "" "\n" "オプション:\n" +#: pg_controldata.c:37 +#, c-format +msgid " [-D] DATADIR data directory\n" +msgstr " [-D] DATADIR データディレクトリ\n" + #: pg_controldata.c:38 #, c-format msgid " -V, --version output version information, then exit\n" @@ -106,327 +155,300 @@ msgstr "未知ã®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹ã‚³ãƒ¼ãƒ‰" msgid "unrecognized wal_level" msgstr "wal_level ã‚’èªè­˜ã§ãã¾ã›ã‚“" -#: pg_controldata.c:126 -#, c-format -msgid "%s: no data directory specified\n" -msgstr "%s: データディレクトリãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" - -#: pg_controldata.c:127 +#: pg_controldata.c:127 pg_controldata.c:145 pg_controldata.c:153 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細ã¯\"%s --help\"を実行ã—ã¦ãã ã•ã„\n" -#: pg_controldata.c:135 +#: pg_controldata.c:143 #, c-format -msgid "%s: could not open file \"%s\" for reading: %s\n" -msgstr "%s: 読ã¿å–り用ã®\"%s\"ファイルã®ã‚ªãƒ¼ãƒ—ンã«å¤±æ•—ã—ã¾ã—ãŸ: %s\n" +msgid "%s: too many command-line arguments (first is \"%s\")\n" +msgstr "%s: コマンドライン引数ãŒå¤šã™ãŽã¾ã™ã€‚(始ã‚ã¯\"%s\")\n" -#: pg_controldata.c:142 +#: pg_controldata.c:152 #, c-format -msgid "%s: could not read file \"%s\": %s\n" -msgstr "%s: \"%s\"ファイルã®èª­ã¿å–ã‚Šã«å¤±æ•—ã—ã¾ã—ãŸ: %s\n" - -#: pg_controldata.c:156 -#, c-format -msgid "" -"WARNING: Calculated CRC checksum does not match value stored in file.\n" -"Either the file is corrupt, or it has a different layout than this program\n" -"is expecting. The results below are untrustworthy.\n" -"\n" -msgstr "" -"警告: CRCãƒã‚§ãƒƒã‚¯ã‚µãƒ ã®è¨ˆç®—çµæžœãŒãƒ•ã‚¡ã‚¤ãƒ«å†…ã®å€¤ã¨ä¸€è‡´ã—ã¾ã›ã‚“。\n" -"ファイルã®ç ´æã€ã‚ã‚‹ã„ã¯ã€æœ¬ãƒ—ログラムãŒæƒ³å®šã™ã‚‹ãƒ¬ã‚¤ã‚¢ã‚¦ãƒˆã¨ç•°ãªã‚‹\n" -"å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚以下ã®çµæžœã¯ä¿¡ç”¨ã§ãã¾ã›ã‚“。\n" -"\n" +msgid "%s: no data directory specified\n" +msgstr "%s: データディレクトリãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" #: pg_controldata.c:190 #, c-format msgid "pg_control version number: %u\n" msgstr "pg_controlãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·: %u\n" -#: pg_controldata.c:193 -#, c-format -msgid "" -"WARNING: possible byte ordering mismatch\n" -"The byte ordering used to store the pg_control file might not match the one\n" -"used by this program. In that case the results below would be incorrect, and\n" -"the PostgreSQL installation would be incompatible with this data directory.\n" -msgstr "" -"警告:ãƒã‚¤ãƒˆã‚ªãƒ¼ãƒ€ãŒç•°ãªã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚\n" -"pg_controlファイルを格ç´ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã™ã‚‹ãƒã‚¤ãƒˆã‚ªãƒ¼ãƒ€ãŒæœ¬ãƒ—ログラムã§ä½¿ç”¨\n" -"ã•ã‚Œã‚‹ã‚‚ã®ã¨ç•°ãªã‚Šã¾ã™ã€‚ã“ã®å ´åˆä»¥ä¸‹ã®çµæžœã¯ä¸æ­£ç¢ºã«ãªã‚Šã¾ã™ã€‚ã¾ãŸã€PostgreSQL\n" -"インストレーションã¯ã“ã®ãƒ‡ãƒ¼ã‚¿ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã¨äº’æ›æ€§ãŒãªããªã‚Šã¾ã™ã€‚\n" - -#: pg_controldata.c:197 +#: pg_controldata.c:192 #, c-format msgid "Catalog version number: %u\n" msgstr "カタログãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·: %u\n" -#: pg_controldata.c:199 +#: pg_controldata.c:194 #, c-format msgid "Database system identifier: %s\n" msgstr "データベースシステム識別å­: %s\n" -#: pg_controldata.c:201 +#: pg_controldata.c:196 #, c-format msgid "Database cluster state: %s\n" msgstr "データベースクラスタã®çŠ¶æ…‹: %s\n" -#: pg_controldata.c:203 +#: pg_controldata.c:198 #, c-format msgid "pg_control last modified: %s\n" msgstr "pg_control最終更新: %s\n" -#: pg_controldata.c:205 +#: pg_controldata.c:200 #, c-format msgid "Latest checkpoint location: %X/%X\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆä½ç½®: %X/%X\n" -#: pg_controldata.c:208 +#: pg_controldata.c:203 #, c-format msgid "Prior checkpoint location: %X/%X\n" msgstr "å‰å›žã®ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆä½ç½®: %X/%X\n" -#: pg_controldata.c:211 +#: pg_controldata.c:206 #, c-format msgid "Latest checkpoint's REDO location: %X/%X\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®REDOä½ç½®: %X/%X\n" -#: pg_controldata.c:214 +#: pg_controldata.c:209 #, c-format -#| msgid "Latest checkpoint's REDO location: %X/%X\n" msgid "Latest checkpoint's REDO WAL file: %s\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®REDO WALファイル: %s\n" -#: pg_controldata.c:216 +#: pg_controldata.c:211 #, c-format msgid "Latest checkpoint's TimeLineID: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®æ™‚系列ID: %u\n" -#: pg_controldata.c:218 +#: pg_controldata.c:213 #, c-format -#| msgid "Latest checkpoint's TimeLineID: %u\n" msgid "Latest checkpoint's PrevTimeLineID: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®PrevTimeLineID: %u\n" -#: pg_controldata.c:220 +#: pg_controldata.c:215 #, c-format msgid "Latest checkpoint's full_page_writes: %s\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®full_page_writes %s\n" -#: pg_controldata.c:221 +#: pg_controldata.c:216 pg_controldata.c:261 pg_controldata.c:271 msgid "off" msgstr "オフ" -#: pg_controldata.c:221 +#: pg_controldata.c:216 pg_controldata.c:261 pg_controldata.c:271 msgid "on" msgstr "オン" -#: pg_controldata.c:222 +#: pg_controldata.c:217 #, c-format -msgid "Latest checkpoint's NextXID: %u/%u\n" -msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®NextXID: %u/%u\n" +msgid "Latest checkpoint's NextXID: %u:%u\n" +msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®NextXID: %u:%u\n" -#: pg_controldata.c:225 +#: pg_controldata.c:220 #, c-format msgid "Latest checkpoint's NextOID: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®NextOID: %u\n" -#: pg_controldata.c:227 +#: pg_controldata.c:222 #, c-format msgid "Latest checkpoint's NextMultiXactId: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®NextMultiXactId: %u\n" -#: pg_controldata.c:229 +#: pg_controldata.c:224 #, c-format msgid "Latest checkpoint's NextMultiOffset: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®NextMultiOffset: %u\n" -#: pg_controldata.c:231 +#: pg_controldata.c:226 #, c-format msgid "Latest checkpoint's oldestXID: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®oldestXID: %u\n" -#: pg_controldata.c:233 +#: pg_controldata.c:228 #, c-format msgid "Latest checkpoint's oldestXID's DB: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®oldestXIDã®DB: %u\n" -#: pg_controldata.c:235 +#: pg_controldata.c:230 #, c-format msgid "Latest checkpoint's oldestActiveXID: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®oldestActiveXID: %u\n" -#: pg_controldata.c:237 +#: pg_controldata.c:232 #, c-format -#| msgid "Latest checkpoint's oldestActiveXID: %u\n" msgid "Latest checkpoint's oldestMultiXid: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®oldestMultiXid: %u\n" -#: pg_controldata.c:239 +#: pg_controldata.c:234 #, c-format -#| msgid "Latest checkpoint's oldestXID's DB: %u\n" msgid "Latest checkpoint's oldestMulti's DB: %u\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®oldestMulti'sã®DB: %u\n" -#: pg_controldata.c:241 +#: pg_controldata.c:236 +#, c-format +msgid "Latest checkpoint's oldestCommitTsXid:%u\n" +msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®oldestCommitTsXid:%u\n" + +#: pg_controldata.c:238 +#, c-format +msgid "Latest checkpoint's newestCommitTsXid:%u\n" +msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã®newestCommitTsXid:%u\n" + +#: pg_controldata.c:240 #, c-format msgid "Time of latest checkpoint: %s\n" msgstr "最終ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆæ™‚刻: %s\n" -#: pg_controldata.c:243 +#: pg_controldata.c:242 #, c-format msgid "Fake LSN counter for unlogged rels: %X/%X\n" msgstr "ログをå–らãªã„リレーションå‘ã‘ã®å½ã®LSNカウンタ: %X/%X\n" -#: pg_controldata.c:246 +#: pg_controldata.c:245 #, c-format msgid "Minimum recovery ending location: %X/%X\n" msgstr "最å°ãƒªã‚«ãƒãƒªçµ‚了ä½ç½®: %X/%X\n" -#: pg_controldata.c:249 +#: pg_controldata.c:248 #, c-format -#| msgid "Minimum recovery ending location: %X/%X\n" msgid "Min recovery ending loc's timeline: %u\n" msgstr "最å°ãƒªã‚«ãƒãƒªçµ‚了ä½ç½®ã®ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³: %u\n" -#: pg_controldata.c:251 +#: pg_controldata.c:250 #, c-format msgid "Backup start location: %X/%X\n" msgstr "ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—開始ä½ç½®: %X/%X\n" -#: pg_controldata.c:254 +#: pg_controldata.c:253 #, c-format msgid "Backup end location: %X/%X\n" msgstr "ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—終了ä½ç½®: %X/%X\n" -#: pg_controldata.c:257 +#: pg_controldata.c:256 #, c-format msgid "End-of-backup record required: %s\n" msgstr "å¿…è¦ãªãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—最終レコード: %s\n" -#: pg_controldata.c:258 +#: pg_controldata.c:257 msgid "no" msgstr "no" -#: pg_controldata.c:258 +#: pg_controldata.c:257 msgid "yes" msgstr "yes" -#: pg_controldata.c:259 +#: pg_controldata.c:258 #, c-format -msgid "Current wal_level setting: %s\n" -msgstr "wal_level ã®ç¾åœ¨è¨­å®š %s\n" +msgid "wal_level setting: %s\n" +msgstr "wal_level ã®è¨­å®šï¼š %s\n" -#: pg_controldata.c:261 +#: pg_controldata.c:260 #, c-format -msgid "Current max_connections setting: %d\n" -msgstr "max_connections ã®ç¾åœ¨è¨­å®šï¼š %d\n" +msgid "wal_log_hints setting: %s\n" +msgstr "wal_log_hints ã®è¨­å®šï¼š %s\n" -#: pg_controldata.c:263 +#: pg_controldata.c:262 #, c-format -#| msgid "Current max_prepared_xacts setting: %d\n" -msgid "Current max_worker_processes setting: %d\n" -msgstr "max_worker_processesã®ç¾åœ¨è¨­å®šï¼š %d\n" +msgid "max_connections setting: %d\n" +msgstr "max_connections ã®è¨­å®šï¼š %d\n" -#: pg_controldata.c:265 +#: pg_controldata.c:264 #, c-format -msgid "Current max_prepared_xacts setting: %d\n" -msgstr "max_prepared_xacts ã®ç¾åœ¨è¨­å®šï¼š %d\n" +msgid "max_worker_processes setting: %d\n" +msgstr "max_worker_processes ã®è¨­å®šï¼š %d\n" -#: pg_controldata.c:267 +#: pg_controldata.c:266 #, c-format -msgid "Current max_locks_per_xact setting: %d\n" -msgstr "max_locks_per_xact ã®ç¾åœ¨è¨­å®šï¼š %d\n" +msgid "max_prepared_xacts setting: %d\n" +msgstr "max_prepared_xacts ã®è¨­å®šï¼š %d\n" -#: pg_controldata.c:269 +#: pg_controldata.c:268 +#, c-format +msgid "max_locks_per_xact setting: %d\n" +msgstr "max_locks_per_xact ã®è¨­å®šï¼š %d\n" + +#: pg_controldata.c:270 +#, c-format +msgid "track_commit_timestamp setting: %s\n" +msgstr "track_commit_timestamp ã®è¨­å®šï¼š %s\n" + +#: pg_controldata.c:272 #, c-format msgid "Maximum data alignment: %u\n" msgstr "最大データアラインメント %u\n" -#: pg_controldata.c:272 +#: pg_controldata.c:275 #, c-format msgid "Database block size: %u\n" msgstr "データベースã®ãƒ–ロックサイズ: %u\n" -#: pg_controldata.c:274 +#: pg_controldata.c:277 #, c-format msgid "Blocks per segment of large relation: %u\n" msgstr "ラージリレーションã®ã‚»ã‚°ãƒ¡ãƒ³ãƒˆå½“ãŸã‚Šã®ãƒ–ロック数: %u\n" -#: pg_controldata.c:276 +#: pg_controldata.c:279 #, c-format msgid "WAL block size: %u\n" msgstr "WALブロックã®ã‚µã‚¤ã‚º: %u\n" -#: pg_controldata.c:278 +#: pg_controldata.c:281 #, c-format msgid "Bytes per WAL segment: %u\n" msgstr "WALセグメント当ãŸã‚Šã®ãƒã‚¤ãƒˆæ•°: %u\n" -#: pg_controldata.c:280 +#: pg_controldata.c:283 #, c-format msgid "Maximum length of identifiers: %u\n" msgstr "識別å­ã®æœ€å¤§é•·: %u\n" -#: pg_controldata.c:282 +#: pg_controldata.c:285 #, c-format msgid "Maximum columns in an index: %u\n" msgstr "インデックス内ã®æœ€å¤§åˆ—æ•°: %u\n" -#: pg_controldata.c:284 +#: pg_controldata.c:287 #, c-format msgid "Maximum size of a TOAST chunk: %u\n" msgstr "TOASTãƒãƒ£ãƒ³ã‚¯ã®æœ€å¤§ã‚µã‚¤ã‚º: %u\n" -#: pg_controldata.c:286 +#: pg_controldata.c:289 +#, c-format +msgid "Size of a large-object chunk: %u\n" +msgstr "ラージオブジェクトãƒãƒ£ãƒ³ã‚¯ã®ã‚µã‚¤ã‚º: %u\n" + +#: pg_controldata.c:291 #, c-format msgid "Date/time type storage: %s\n" msgstr "日付/時刻型ã®æ ¼ç´æ–¹å¼: %s\n" -#: pg_controldata.c:287 +#: pg_controldata.c:292 msgid "64-bit integers" msgstr "64ビット整数" -#: pg_controldata.c:287 +#: pg_controldata.c:292 msgid "floating-point numbers" msgstr "浮動å°æ•°ç‚¹æ•°" -#: pg_controldata.c:288 +#: pg_controldata.c:293 #, c-format msgid "Float4 argument passing: %s\n" msgstr "Float4 引数ã®æ¸¡ã—方： %s\n" -#: pg_controldata.c:289 pg_controldata.c:291 +#: pg_controldata.c:294 pg_controldata.c:296 msgid "by reference" msgstr "å‚照渡ã—" -#: pg_controldata.c:289 pg_controldata.c:291 +#: pg_controldata.c:294 pg_controldata.c:296 msgid "by value" msgstr "値渡ã—" -#: pg_controldata.c:290 +#: pg_controldata.c:295 #, c-format msgid "Float8 argument passing: %s\n" msgstr "Float8 引数ã®æ¸¡ã—方： %s\n" -#: pg_controldata.c:292 +#: pg_controldata.c:297 #, c-format -#| msgid "Catalog version number: %u\n" msgid "Data page checksum version: %u\n" msgstr "データベージãƒã‚§ãƒƒã‚¯ã‚µãƒ ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³: %u\n" -#~ msgid "" -#~ "Usage:\n" -#~ " %s [OPTION] [DATADIR]\n" -#~ "\n" -#~ "Options:\n" -#~ " --help show this help, then exit\n" -#~ " --version output version information, then exit\n" -#~ msgstr "" -#~ "使用方法:\n" -#~ " %s [OPTION] [DATADIR]\n" -#~ "\n" -#~ "オプション:\n" -#~ " --help ヘルプを表示ã—ã€çµ‚了ã—ã¾ã™\n" -#~ " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" diff --git a/src/bin/pg_controldata/po/ru.po b/src/bin/pg_controldata/po/ru.po index f4c1d86eef..d146c99bbb 100644 --- a/src/bin/pg_controldata/po/ru.po +++ b/src/bin/pg_controldata/po/ru.po @@ -10,8 +10,9 @@ msgid "" msgstr "" "Project-Id-Version: pg_controldata (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:14+0000\n" +"POT-Creation-Date: 2017-02-06 22:14+0000\n" "PO-Revision-Date: 2016-12-20 18:28+0300\n" +"Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -19,7 +20,6 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" -"Last-Translator: Alexander Lakhin \n" #: ../../common/controldata_utils.c:56 #, c-format diff --git a/src/bin/pg_ctl/po/ja.po b/src/bin/pg_ctl/po/ja.po index f32ab81a8c..d66a8337e3 100644 --- a/src/bin/pg_ctl/po/ja.po +++ b/src/bin/pg_ctl/po/ja.po @@ -3,11 +3,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.0 beta 3\n" +"Project-Id-Version: PostgreSQL 9.6.3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2013-08-18 11:37+0900\n" +"POT-Creation-Date: 2017-04-04 11:59+0900\n" "PO-Revision-Date: 2013-08-18 11:39+0900\n" -"Last-Translator: HOTTA Michihide \n" +"Last-Translator: Daisuke Higuchi \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -15,104 +15,134 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" -#: ../../common/fe_memutils.c:33 ../../common/fe_memutils.c:60 -#: ../../common/fe_memutils.c:83 -#, c-format -msgid "out of memory\n" -msgstr "メモリä¸è¶³ã§ã™\n" - -#: ../../common/fe_memutils.c:77 -#, c-format -msgid "cannot duplicate null pointer (internal error)\n" -msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" - -#: ../../port/exec.c:127 ../../port/exec.c:241 ../../port/exec.c:284 +#: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format msgid "could not identify current directory: %s" msgstr "ç¾åœ¨ã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’èªè­˜ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: ../../port/exec.c:146 +#: ../../common/exec.c:146 #, c-format msgid "invalid binary \"%s\"" msgstr "ãƒã‚¤ãƒŠãƒª\"%s\"ã¯ç„¡åŠ¹ã§ã™" -#: ../../port/exec.c:195 +#: ../../common/exec.c:195 #, c-format msgid "could not read binary \"%s\"" msgstr "ãƒã‚¤ãƒŠãƒª\"%s\"を読ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ" -#: ../../port/exec.c:202 +#: ../../common/exec.c:202 #, c-format msgid "could not find a \"%s\" to execute" msgstr "実行ã™ã‚‹\"%s\"ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ" -#: ../../port/exec.c:257 ../../port/exec.c:293 +#: ../../common/exec.c:257 ../../common/exec.c:293 #, c-format msgid "could not change directory to \"%s\": %s" msgstr "ディレクトリ\"%s\"ã«ç§»å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: ../../port/exec.c:272 +#: ../../common/exec.c:272 #, c-format msgid "could not read symbolic link \"%s\"" msgstr "シンボリックリンク\"%s\"ã®èª­ã¿å–ã‚Šã«å¤±æ•—ã—ã¾ã—ãŸ" -#: ../../port/exec.c:523 +#: ../../common/exec.c:523 #, c-format msgid "pclose failed: %s" msgstr "pcloseãŒå¤±æ•—ã—ã¾ã—ãŸ: %s" -#: ../../port/wait_error.c:47 +#: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 +#: ../../common/fe_memutils.c:98 ../../port/path.c:632 ../../port/path.c:670 +#: ../../port/path.c:687 +#, c-format +msgid "out of memory\n" +msgstr "メモリä¸è¶³ã§ã™\n" + +#: ../../common/fe_memutils.c:92 +#, c-format +msgid "cannot duplicate null pointer (internal error)\n" +msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" + +#: ../../common/wait_error.c:47 #, c-format msgid "command not executable" msgstr "コマンドã¯å®Ÿè¡Œå½¢å¼ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: ../../port/wait_error.c:51 +#: ../../common/wait_error.c:51 #, c-format msgid "command not found" msgstr "コマンドãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“" -#: ../../port/wait_error.c:56 +#: ../../common/wait_error.c:56 #, c-format msgid "child process exited with exit code %d" msgstr "å­ãƒ—ロセスãŒçµ‚了コード%dã§çµ‚了ã—ã¾ã—ãŸ" -#: ../../port/wait_error.c:63 +#: ../../common/wait_error.c:63 #, c-format msgid "child process was terminated by exception 0x%X" msgstr "å­ãƒ—ロセスãŒä¾‹å¤–0x%Xã§çµ‚了ã—ã¾ã—ãŸ" -#: ../../port/wait_error.c:73 +#: ../../common/wait_error.c:73 #, c-format msgid "child process was terminated by signal %s" msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%sã§çµ‚了ã—ã¾ã—ãŸ" -#: ../../port/wait_error.c:77 +#: ../../common/wait_error.c:77 #, c-format msgid "child process was terminated by signal %d" msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%dã§çµ‚了ã—ã¾ã—ãŸ" -#: ../../port/wait_error.c:82 +#: ../../common/wait_error.c:82 #, c-format msgid "child process exited with unrecognized status %d" msgstr "å­ãƒ—ロセスãŒæœªçŸ¥ã®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹%dã§çµ‚了ã—ã¾ã—ãŸ" -#: pg_ctl.c:253 +#: ../../port/path.c:654 +#, c-format +msgid "could not get current working directory: %s\n" +msgstr "ç¾åœ¨ã®ä½œæ¥­ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’å–å¾—ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: pg_ctl.c:252 +#, c-format +msgid "%s: directory \"%s\" does not exist\n" +msgstr "%s: ディレクトリ \"%s\" ã¯å­˜åœ¨ã—ã¾ã›ã‚“\n" + +#: pg_ctl.c:255 +#, c-format +msgid "%s: could not access directory \"%s\": %s\n" +msgstr "%s: ディレクトリ\"%s\"ã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: pg_ctl.c:269 +#, c-format +msgid "%s: directory \"%s\" is not a database cluster directory\n" +msgstr "%s: ディレクトリ \"%s\" ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¯ãƒ©ã‚¹ã‚¿ã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã§ã¯ã‚ã‚Šã¾ã›ã‚“\n" + +#: pg_ctl.c:282 #, c-format msgid "%s: could not open PID file \"%s\": %s\n" msgstr "%s: PIDファイル\"%s\"をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_ctl.c:262 +#: pg_ctl.c:291 #, c-format -#| msgid "%s: PID file \"%s\" does not exist\n" msgid "%s: the PID file \"%s\" is empty\n" msgstr "%s: PIDファイル\"%s\"ãŒç©ºã§ã™\n" -#: pg_ctl.c:265 +#: pg_ctl.c:294 #, c-format msgid "%s: invalid data in PID file \"%s\"\n" msgstr "%s: PIDファイル\"%s\"内ã«ç„¡åŠ¹ãªãƒ‡ãƒ¼ã‚¿ãŒã‚ã‚Šã¾ã™\n" -#: pg_ctl.c:477 +#: pg_ctl.c:444 pg_ctl.c:472 +#, c-format +msgid "%s: could not start server: %s\n" +msgstr "%s: サーãƒã‚’èµ·å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: pg_ctl.c:496 +#, c-format +msgid "%s: could not start server: error code %lu\n" +msgstr "%s: サーãƒã®èµ·å‹•ã«å¤±æ•—ã—ã¾ã—ãŸ: エラーコード %lu\n" + +#: pg_ctl.c:573 #, c-format msgid "" "\n" @@ -121,7 +151,7 @@ msgstr "" "\n" "%s: 9.1よりå‰ã®ã‚µãƒ¼ãƒã‚’èµ·å‹•ã™ã‚‹éš›ã«-wオプションã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã›ã‚“\n" -#: pg_ctl.c:547 +#: pg_ctl.c:638 #, c-format msgid "" "\n" @@ -130,31 +160,22 @@ msgstr "" "\n" "%s: -wオプションã§ã¯ç›¸å¯¾ã‚½ã‚±ãƒƒãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªæŒ‡å®šã‚’使用ã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“\n" -#: pg_ctl.c:595 -#, c-format -msgid "" -"\n" -"%s: this data directory appears to be running a pre-existing postmaster\n" -msgstr "" -"\n" -"%s: ã“ã®ãƒ‡ãƒ¼ã‚¿ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã§ã¯æ—¢å­˜ã®postmasterãŒå®Ÿè¡Œã—ã¦ã„るよã†ã§ã™ã€‚\n" - -#: pg_ctl.c:645 +#: pg_ctl.c:740 #, c-format msgid "%s: cannot set core file size limit; disallowed by hard limit\n" msgstr "%s: コアファイルã®ã‚µã‚¤ã‚ºåˆ¶é™ã‚’設定ã§ãã¾ã›ã‚“:固定ã®åˆ¶é™ã«ã‚ˆã‚Šè¨±ã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_ctl.c:670 +#: pg_ctl.c:765 #, c-format msgid "%s: could not read file \"%s\"\n" msgstr "%s: ファイル\"%s\"を読ã¿å–ã‚‹ã“ã¨ã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_ctl.c:675 +#: pg_ctl.c:770 #, c-format msgid "%s: option file \"%s\" must have exactly one line\n" msgstr "%s: オプションファイル\"%s\"ã¯1è¡Œã®ã¿ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_ctl.c:723 +#: pg_ctl.c:821 #, c-format msgid "" "The program \"%s\" is needed by %s but was not found in the\n" @@ -165,7 +186,7 @@ msgstr "" "ã«ã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸã€‚\n" "インストール状æ³ã‚’確èªã—ã¦ãã ã•ã„。\n" -#: pg_ctl.c:729 +#: pg_ctl.c:827 #, c-format msgid "" "The program \"%s\" was found by \"%s\"\n" @@ -176,42 +197,37 @@ msgstr "" "ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã§ã¯ã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸã€‚\n" "インストレーションを検査ã—ã¦ãã ã•ã„。\n" -#: pg_ctl.c:762 +#: pg_ctl.c:860 #, c-format msgid "%s: database system initialization failed\n" msgstr "%s: データベースシステムãŒåˆæœŸåŒ–ã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_ctl.c:777 +#: pg_ctl.c:875 #, c-format msgid "%s: another server might be running; trying to start server anyway\n" msgstr "%s: ä»–ã®ã‚µãƒ¼ãƒãŒå‹•ä½œä¸­ã®å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ãŒã€ã¨ã«ã‹ãpostmasterã®èµ·å‹•ã‚’試ã¿ã¾ã™ã€‚\n" -#: pg_ctl.c:814 -#, c-format -msgid "%s: could not start server: exit code was %d\n" -msgstr "%s: サーãƒã‚’èµ·å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚終了コードã¯%dã§ã—ãŸã€‚\n" - -#: pg_ctl.c:821 +#: pg_ctl.c:913 msgid "waiting for server to start..." msgstr "サーãƒã®èµ·å‹•å®Œäº†ã‚’å¾…ã£ã¦ã„ã¾ã™..." -#: pg_ctl.c:826 pg_ctl.c:927 pg_ctl.c:1018 +#: pg_ctl.c:918 pg_ctl.c:1025 pg_ctl.c:1116 msgid " done\n" msgstr "完了\n" -#: pg_ctl.c:827 +#: pg_ctl.c:919 msgid "server started\n" msgstr "サーãƒèµ·å‹•å®Œäº†\n" -#: pg_ctl.c:830 pg_ctl.c:834 +#: pg_ctl.c:922 pg_ctl.c:926 msgid " stopped waiting\n" msgstr " 待機処ç†ãŒåœæ­¢ã•ã‚Œã¾ã—ãŸ\n" -#: pg_ctl.c:831 +#: pg_ctl.c:923 msgid "server is still starting up\n" msgstr "サーãƒã¯ä¾ç„¶èµ·å‹•ä¸­ã§ã™ã€‚\n" -#: pg_ctl.c:835 +#: pg_ctl.c:927 #, c-format msgid "" "%s: could not start server\n" @@ -220,43 +236,43 @@ msgstr "" "%s: サーãƒã‚’èµ·å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚\n" "ログ出力を確èªã—ã¦ãã ã•ã„。\n" -#: pg_ctl.c:841 pg_ctl.c:919 pg_ctl.c:1009 +#: pg_ctl.c:933 pg_ctl.c:1017 pg_ctl.c:1107 msgid " failed\n" msgstr "失敗ã—ã¾ã—ãŸ\n" -#: pg_ctl.c:842 +#: pg_ctl.c:934 #, c-format msgid "%s: could not wait for server because of misconfiguration\n" msgstr "%s: 誤設定ã®ãŸã‚サーãƒã‚’å¾…æ©Ÿã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_ctl.c:848 +#: pg_ctl.c:940 msgid "server starting\n" msgstr "サーãƒã¯èµ·å‹•ä¸­ã§ã™ã€‚\n" -#: pg_ctl.c:863 pg_ctl.c:949 pg_ctl.c:1039 pg_ctl.c:1079 +#: pg_ctl.c:961 pg_ctl.c:1047 pg_ctl.c:1137 pg_ctl.c:1177 #, c-format msgid "%s: PID file \"%s\" does not exist\n" msgstr "%s: PIDファイル\"%s\"ãŒã‚ã‚Šã¾ã›ã‚“\n" -#: pg_ctl.c:864 pg_ctl.c:951 pg_ctl.c:1040 pg_ctl.c:1080 +#: pg_ctl.c:962 pg_ctl.c:1049 pg_ctl.c:1138 pg_ctl.c:1178 msgid "Is server running?\n" msgstr "サーãƒãŒå‹•ä½œã—ã¦ã„ã¾ã™ã‹?\n" -#: pg_ctl.c:870 +#: pg_ctl.c:968 #, c-format msgid "%s: cannot stop server; single-user server is running (PID: %ld)\n" msgstr "%s: サーãƒã‚’åœæ­¢ã§ãã¾ã›ã‚“。シングルユーザサーãƒ(PID: %ld)ãŒå‹•ä½œã—ã¦ã„ã¾ã™ã€‚\n" -#: pg_ctl.c:878 pg_ctl.c:973 +#: pg_ctl.c:976 pg_ctl.c:1071 #, c-format msgid "%s: could not send stop signal (PID: %ld): %s\n" msgstr "%s: åœæ­¢ã‚·ã‚°ãƒŠãƒ«ã‚’é€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚(PID: %ld): %s\n" -#: pg_ctl.c:885 +#: pg_ctl.c:983 msgid "server shutting down\n" msgstr "サーãƒã®åœæ­¢ä¸­ã§ã™\n" -#: pg_ctl.c:900 pg_ctl.c:988 +#: pg_ctl.c:998 pg_ctl.c:1086 msgid "" "WARNING: online backup mode is active\n" "Shutdown will not complete until pg_stop_backup() is called.\n" @@ -266,16 +282,16 @@ msgstr "" "pg_stop_backup()ãŒå‘¼ã³å‡ºã•ã‚Œã‚‹ã¾ã§ã‚·ãƒ£ãƒƒãƒˆãƒ€ã‚¦ãƒ³ã¯å®Œäº†ã—ã¾ã›ã‚“\n" "\n" -#: pg_ctl.c:904 pg_ctl.c:992 +#: pg_ctl.c:1002 pg_ctl.c:1090 msgid "waiting for server to shut down..." msgstr "サーãƒåœæ­¢å‡¦ç†ã®å®Œäº†ã‚’å¾…ã£ã¦ã„ã¾ã™..." -#: pg_ctl.c:921 pg_ctl.c:1011 +#: pg_ctl.c:1019 pg_ctl.c:1109 #, c-format msgid "%s: server does not shut down\n" msgstr "%s: サーãƒã¯åœæ­¢ã—ã¦ã„ã¾ã›ã‚“\n" -#: pg_ctl.c:923 pg_ctl.c:1013 +#: pg_ctl.c:1021 pg_ctl.c:1111 msgid "" "HINT: The \"-m fast\" option immediately disconnects sessions rather than\n" "waiting for session-initiated disconnection.\n" @@ -283,211 +299,211 @@ msgstr "" "ヒント: \"-m fast\"オプションã¯ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³åˆ‡æ–­ãŒå§‹ã¾ã‚‹ã¾ã§å¾…æ©Ÿã™ã‚‹ã®ã§ã¯ãªã\n" "å³åº§ã«ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚’切断ã—ã¾ã™ã€‚\n" -#: pg_ctl.c:929 pg_ctl.c:1019 +#: pg_ctl.c:1027 pg_ctl.c:1117 msgid "server stopped\n" msgstr "サーãƒã¯åœæ­¢ã—ã¾ã—ãŸ\n" -#: pg_ctl.c:952 pg_ctl.c:1025 +#: pg_ctl.c:1050 pg_ctl.c:1123 msgid "starting server anyway\n" msgstr "ã¨ã«ã‹ãサーãƒã‚’èµ·å‹•ã—ã¦ã„ã¾ã™\n" -#: pg_ctl.c:961 +#: pg_ctl.c:1059 #, c-format msgid "%s: cannot restart server; single-user server is running (PID: %ld)\n" msgstr "%s: サーãƒã‚’å†èµ·å‹•ã§ãã¾ã›ã‚“。シングルユーザサーãƒ(PID: %ld)ãŒå‹•ä½œä¸­ã§ã™ã€‚\n" -#: pg_ctl.c:964 pg_ctl.c:1049 +#: pg_ctl.c:1062 pg_ctl.c:1147 msgid "Please terminate the single-user server and try again.\n" msgstr "シングルユーザサーãƒã‚’終了ã•ã›ã¦ã‹ã‚‰ã€å†åº¦å®Ÿè¡Œã—ã¦ãã ã•ã„\n" -#: pg_ctl.c:1023 +#: pg_ctl.c:1121 #, c-format msgid "%s: old server process (PID: %ld) seems to be gone\n" msgstr "%s: å¤ã„サーãƒãƒ—ロセス(PID: %ld)ãŒå‹•ä½œã—ã¦ã„ãªã„よã†ã§ã™\n" -#: pg_ctl.c:1046 +#: pg_ctl.c:1144 #, c-format msgid "%s: cannot reload server; single-user server is running (PID: %ld)\n" msgstr "%s: サーãƒã‚’リロードã§ãã¾ã›ã‚“。シングルユーザサーãƒ(PID: %ld)ãŒå‹•ä½œä¸­ã§ã™\n" -#: pg_ctl.c:1055 +#: pg_ctl.c:1153 #, c-format msgid "%s: could not send reload signal (PID: %ld): %s\n" msgstr "%s: リロードシグナルをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚(PID: %ld): %s\n" -#: pg_ctl.c:1060 +#: pg_ctl.c:1158 msgid "server signaled\n" msgstr "サーãƒã«ã‚·ã‚°ãƒŠãƒ«ã‚’é€ä¿¡ã—ã¾ã—ãŸ\n" -#: pg_ctl.c:1086 +#: pg_ctl.c:1184 #, c-format msgid "%s: cannot promote server; single-user server is running (PID: %ld)\n" msgstr "%s: サーãƒã‚’昇進ã§ãã¾ã›ã‚“。シングルユーザサーãƒ(PID: %ld)ãŒå‹•ä½œä¸­ã§ã™\n" -#: pg_ctl.c:1095 +#: pg_ctl.c:1193 #, c-format msgid "%s: cannot promote server; server is not in standby mode\n" msgstr "%s: サーãƒã‚’昇進ã§ãã¾ã›ã‚“。サーãƒã¯ã‚¹ã‚¿ãƒ³ãƒã‚¤ãƒ¢ãƒ¼ãƒ‰ã§ã¯ã‚ã‚Šã¾ã›ã‚“。\n" -#: pg_ctl.c:1111 +#: pg_ctl.c:1208 #, c-format msgid "%s: could not create promote signal file \"%s\": %s\n" msgstr "%s: \"%s\"昇進通知ファイルを作æˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_ctl.c:1117 +#: pg_ctl.c:1214 #, c-format msgid "%s: could not write promote signal file \"%s\": %s\n" msgstr "%s: \"%s\"昇進通知ファイルを書ã出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_ctl.c:1125 +#: pg_ctl.c:1222 #, c-format msgid "%s: could not send promote signal (PID: %ld): %s\n" msgstr "%s: 昇進シグナルをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚(PID: %ld): %s\n" -#: pg_ctl.c:1128 +#: pg_ctl.c:1225 #, c-format msgid "%s: could not remove promote signal file \"%s\": %s\n" msgstr "%s: \"%s\"昇進通知ファイルを削除ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_ctl.c:1133 +#: pg_ctl.c:1230 msgid "server promoting\n" msgstr "サーãƒã‚’昇進中ã§ã™ã€‚\n" -#: pg_ctl.c:1180 +#: pg_ctl.c:1277 #, c-format msgid "%s: single-user server is running (PID: %ld)\n" msgstr "%s: シングルユーザサーãƒãŒå‹•ä½œä¸­ã§ã™(PID: %ld)\n" -#: pg_ctl.c:1192 +#: pg_ctl.c:1290 #, c-format msgid "%s: server is running (PID: %ld)\n" msgstr "%s: サーãƒãŒå‹•ä½œä¸­ã§ã™(PID: %ld)\n" -#: pg_ctl.c:1203 +#: pg_ctl.c:1306 #, c-format msgid "%s: no server running\n" msgstr "%s: サーãƒãŒå‹•ä½œã—ã¦ã„ã¾ã›ã‚“\n" -#: pg_ctl.c:1220 +#: pg_ctl.c:1324 #, c-format msgid "%s: could not send signal %d (PID: %ld): %s\n" msgstr "%s: シグナル%dã‚’é€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ(PID: %ld): %s\n" -#: pg_ctl.c:1254 +#: pg_ctl.c:1381 #, c-format msgid "%s: could not find own program executable\n" msgstr "%s: 本プログラムã®å®Ÿè¡Œãƒ•ã‚¡ã‚¤ãƒ«ã®æ¤œç´¢ã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_ctl.c:1264 +#: pg_ctl.c:1391 #, c-format msgid "%s: could not find postgres program executable\n" msgstr "%s: postgres ã®å®Ÿè¡Œãƒ•ã‚¡ã‚¤ãƒ«ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: pg_ctl.c:1329 pg_ctl.c:1361 +#: pg_ctl.c:1461 pg_ctl.c:1495 #, c-format msgid "%s: could not open service manager\n" msgstr "%s: サービスマãƒãƒ¼ã‚¸ãƒ£ã®ã‚ªãƒ¼ãƒ—ンã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_ctl.c:1335 +#: pg_ctl.c:1467 #, c-format msgid "%s: service \"%s\" already registered\n" msgstr "%s: サービス\\\"%s\\\"ã¯ç™»éŒ²æ¸ˆã¿ã§ã™\n" -#: pg_ctl.c:1346 +#: pg_ctl.c:1478 #, c-format msgid "%s: could not register service \"%s\": error code %lu\n" msgstr "%s: サービス\"%s\"ã®ç™»éŒ²ã«å¤±æ•—ã—ã¾ã—ãŸ: エラーコード %lu\n" -#: pg_ctl.c:1367 +#: pg_ctl.c:1501 #, c-format msgid "%s: service \"%s\" not registered\n" msgstr "%s: サービス\"%s\"ã¯ç™»éŒ²ã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_ctl.c:1374 +#: pg_ctl.c:1508 #, c-format msgid "%s: could not open service \"%s\": error code %lu\n" msgstr "%s: サービス\"%s\"ã®ã‚ªãƒ¼ãƒ—ンã«å¤±æ•—ã—ã¾ã—ãŸ: エラーコード %lu\n" -#: pg_ctl.c:1381 +#: pg_ctl.c:1517 #, c-format msgid "%s: could not unregister service \"%s\": error code %lu\n" msgstr "%s: サービス\"%s\"ã®ç™»éŒ²å‰Šé™¤ã«å¤±æ•—ã—ã¾ã—ãŸ: エラーコード %lu\n" -#: pg_ctl.c:1466 +#: pg_ctl.c:1604 msgid "Waiting for server startup...\n" msgstr "サーãƒã®èµ·å‹•å®Œäº†ã‚’å¾…ã£ã¦ã„ã¾ã™...\n" -#: pg_ctl.c:1469 +#: pg_ctl.c:1607 msgid "Timed out waiting for server startup\n" msgstr "サーãƒã®èµ·å‹•å¾…æ©ŸãŒã‚¿ã‚¤ãƒ ã‚¢ã‚¦ãƒˆã—ã¾ã—ãŸ\n" -#: pg_ctl.c:1473 +#: pg_ctl.c:1611 msgid "Server started and accepting connections\n" msgstr "サーãƒã¯èµ·å‹•ã—ã€æŽ¥ç¶šã‚’å—ã‘付ã‘ã¦ã„ã¾ã™\n" -#: pg_ctl.c:1517 +#: pg_ctl.c:1666 #, c-format msgid "%s: could not start service \"%s\": error code %lu\n" msgstr "%s: サービス\"%s\"ã®èµ·å‹•ã«å¤±æ•—ã—ã¾ã—ãŸ: エラーコード %lu\n" -#: pg_ctl.c:1589 +#: pg_ctl.c:1740 #, c-format msgid "%s: WARNING: cannot create restricted tokens on this platform\n" msgstr "%s: 警告: ã“ã®ãƒ—ラットフォームã§ã¯åˆ¶é™ä»˜ãトークンを作æˆã§ãã¾ã›ã‚“\n" -#: pg_ctl.c:1598 +#: pg_ctl.c:1753 #, c-format msgid "%s: could not open process token: error code %lu\n" msgstr "%s: プロセストークンをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: エラーコード %lu\n" -#: pg_ctl.c:1611 +#: pg_ctl.c:1767 #, c-format msgid "%s: could not allocate SIDs: error code %lu\n" msgstr "%s: SIDを割り当ã¦ã‚‰ã‚Œã¾ã›ã‚“ã§ã—ãŸ: エラーコード %lu\n" -#: pg_ctl.c:1630 +#: pg_ctl.c:1787 #, c-format msgid "%s: could not create restricted token: error code %lu\n" msgstr "%s: 制é™ä»˜ãトークンを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: エラーコード %lu\n" -#: pg_ctl.c:1668 +#: pg_ctl.c:1818 #, c-format msgid "%s: WARNING: could not locate all job object functions in system API\n" msgstr "%s: 警告: システムAPI内ã«ã™ã¹ã¦ã®ã‚¸ãƒ§ãƒ–オブジェクト関数を格ç´ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_ctl.c:1754 +#: pg_ctl.c:1901 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細ã¯\"%s --help\"を実行ã—ã¦ãã ã•ã„。\n" -#: pg_ctl.c:1762 +#: pg_ctl.c:1909 #, c-format msgid "" "%s is a utility to initialize, start, stop, or control a PostgreSQL server.\n" "\n" msgstr "%sã¯PostgreSQLサーãƒã®åˆæœŸåŒ–ã€èµ·å‹•ã€åœæ­¢ã€åˆ¶å¾¡ã‚’è¡Œã†ãƒ¦ãƒ¼ãƒ†ã‚£ãƒªãƒ†ã‚£ã§ã™ã€‚\n" -#: pg_ctl.c:1763 +#: pg_ctl.c:1910 #, c-format msgid "Usage:\n" msgstr "使用方法:\n" -#: pg_ctl.c:1764 +#: pg_ctl.c:1911 #, c-format msgid " %s init[db] [-D DATADIR] [-s] [-o \"OPTIONS\"]\n" msgstr " %s init[db] [-D DATADIR] [-s] [-o \"オプション\"]\n" -#: pg_ctl.c:1765 +#: pg_ctl.c:1912 #, c-format msgid " %s start [-w] [-t SECS] [-D DATADIR] [-s] [-l FILENAME] [-o \"OPTIONS\"]\n" msgstr " %s start [-w] [-t SECS] [-D DATADIR] [-s] [-l FILENAME] [-o \"OPTIONS\"]\n" -#: pg_ctl.c:1766 +#: pg_ctl.c:1913 #, c-format msgid " %s stop [-W] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n" msgstr " %s stop [-W] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n" -#: pg_ctl.c:1767 +#: pg_ctl.c:1914 #, c-format msgid "" " %s restart [-w] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n" @@ -496,27 +512,27 @@ msgstr "" " %s restart [-w] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n" " [-o \"OPTIONS\"]\n" -#: pg_ctl.c:1769 +#: pg_ctl.c:1916 #, c-format msgid " %s reload [-D DATADIR] [-s]\n" msgstr " %s reload [-D DATADIR] [-s]\n" -#: pg_ctl.c:1770 +#: pg_ctl.c:1917 #, c-format msgid " %s status [-D DATADIR]\n" msgstr " %s status [-D DATADIR]\n" -#: pg_ctl.c:1771 +#: pg_ctl.c:1918 #, c-format msgid " %s promote [-D DATADIR] [-s]\n" msgstr " %s promote [-D DATADIR] [-s]\n" -#: pg_ctl.c:1772 +#: pg_ctl.c:1919 #, c-format msgid " %s kill SIGNALNAME PID\n" msgstr " %s kill SIGNALNAME PID\n" -#: pg_ctl.c:1774 +#: pg_ctl.c:1921 #, c-format msgid "" " %s register [-N SERVICENAME] [-U USERNAME] [-P PASSWORD] [-D DATADIR]\n" @@ -525,12 +541,12 @@ msgstr "" " %s register [-N SERVICENAME] [-U USERNAME] [-P PASSWORD] [-D DATADIR]\n" " [-S START-TYPE] [-w] [-t SECS] [-o \"OPTIONS\"]\n" -#: pg_ctl.c:1776 +#: pg_ctl.c:1923 #, c-format msgid " %s unregister [-N SERVICENAME]\n" msgstr " %s unregister [-N SERVICENAME]\n" -#: pg_ctl.c:1779 +#: pg_ctl.c:1926 #, c-format msgid "" "\n" @@ -539,42 +555,47 @@ msgstr "" "\n" "一般的ãªã‚ªãƒ—ション:\n" -#: pg_ctl.c:1780 +#: pg_ctl.c:1927 #, c-format msgid " -D, --pgdata=DATADIR location of the database storage area\n" msgstr " -D, --pgdata DATADIR データベース格ç´é ˜åŸŸã®å ´æ‰€ã§ã™\n" -#: pg_ctl.c:1781 +#: pg_ctl.c:1929 +#, c-format +msgid " -e SOURCE event source for logging when running as a service\n" +msgstr " -e SOURCE サービスã¨ã—ã¦å®Ÿè¡Œã™ã‚‹æ™‚ã®ãƒ­ã‚°åŽé›†ã®ãŸã‚ã®ã‚¤ãƒ™ãƒ³ãƒˆã‚½ãƒ¼ã‚¹ã§ã™\n" + +#: pg_ctl.c:1931 #, c-format msgid " -s, --silent only print errors, no informational messages\n" msgstr " -s, --silent エラーメッセージã®ã¿ã‚’表示ã—ã€æƒ…報メッセージã¯è¡¨ç¤ºã—ã¾ã›ã‚“\n" -#: pg_ctl.c:1782 +#: pg_ctl.c:1932 #, c-format msgid " -t, --timeout=SECS seconds to wait when using -w option\n" msgstr " -t, --timeout=SECS -wオプションを使用ã™ã‚‹æ™‚ã«å¾…æ©Ÿã™ã‚‹ç§’æ•°\n" -#: pg_ctl.c:1783 +#: pg_ctl.c:1933 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_ctl.c:1784 +#: pg_ctl.c:1934 #, c-format msgid " -w wait until operation completes\n" msgstr " -w 作業ãŒå®Œäº†ã™ã‚‹ã¾ã§å¾…æ©Ÿã—ã¾ã™\n" -#: pg_ctl.c:1785 +#: pg_ctl.c:1935 #, c-format msgid " -W do not wait until operation completes\n" msgstr " -W 作業ã®å®Œäº†ã¾ã§å¾…æ©Ÿã—ã¾ã›ã‚“\n" -#: pg_ctl.c:1786 +#: pg_ctl.c:1936 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_ctl.c:1787 +#: pg_ctl.c:1937 #, c-format msgid "" "(The default is to wait for shutdown, but not for start or restart.)\n" @@ -584,36 +605,36 @@ msgstr "" "ã¾ã›ã‚“。)\n" "\n" -#: pg_ctl.c:1788 +#: pg_ctl.c:1938 #, c-format msgid "If the -D option is omitted, the environment variable PGDATA is used.\n" msgstr "-Dオプションã®çœç•¥æ™‚ã€PGDATA環境変数ãŒä½¿ç”¨ã•ã‚Œã¾ã™ã€‚\n" -#: pg_ctl.c:1790 +#: pg_ctl.c:1940 #, c-format msgid "" "\n" "Options for start or restart:\n" msgstr "" "\n" -"èµ·å‹•ã€å†èµ·å‹•ç”¨ã®ã‚ªãƒ—ション\n" +"èµ·å‹•ã€å†èµ·å‹•ç”¨ã®ã‚ªãƒ—ション:\n" -#: pg_ctl.c:1792 +#: pg_ctl.c:1942 #, c-format msgid " -c, --core-files allow postgres to produce core files\n" msgstr " -c, --core-files postgresã¯ã‚³ã‚¢ãƒ•ã‚¡ã‚¤ãƒ«ã‚’生æˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚\n" -#: pg_ctl.c:1794 +#: pg_ctl.c:1944 #, c-format msgid " -c, --core-files not applicable on this platform\n" msgstr " -c, --core-files ã“ã®ãƒ—ラットフォームã§ã¯å®Ÿè¡Œã§ãã¾ã›ã‚“\n" -#: pg_ctl.c:1796 +#: pg_ctl.c:1946 #, c-format msgid " -l, --log=FILENAME write (or append) server log to FILENAME\n" msgstr " -l, --log FILENAME サーãƒãƒ­ã‚°ã‚’FILENAMEã¸å‡ºåŠ›(ã‚ã‚‹ã„ã¯è¿½åŠ )ã—ã¾ã™\n" -#: pg_ctl.c:1797 +#: pg_ctl.c:1947 #, c-format msgid "" " -o OPTIONS command line options to pass to postgres\n" @@ -622,27 +643,26 @@ msgstr "" " -o オプション postgres(PostgreSQLサーãƒå®Ÿè¡Œãƒ•ã‚¡ã‚¤ãƒ«)ã¾ãŸã¯\n" " initdb ã«æ¸¡ã™ã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ã‚ªãƒ—ション\n" -#: pg_ctl.c:1799 +#: pg_ctl.c:1949 #, c-format msgid " -p PATH-TO-POSTGRES normally not necessary\n" msgstr " -p PATH-TO-POSTGRES 通常ã¯ä¸è¦ã§ã™\n" -#: pg_ctl.c:1800 +#: pg_ctl.c:1950 #, c-format -#| msgid "" -#| "\n" -#| "Options for stop or restart:\n" msgid "" "\n" -"Options for stop, restart, or promote:\n" -msgstr "\nåœæ­¢ã€å†èµ·å‹•ã€æ˜‡é€²ç”¨ã®ã‚ªãƒ—ション:\n" +"Options for stop or restart:\n" +msgstr "" +"\n" +"åœæ­¢ã€å†èµ·å‹•ç”¨ã®ã‚ªãƒ—ション:\n" -#: pg_ctl.c:1801 +#: pg_ctl.c:1951 #, c-format msgid " -m, --mode=MODE MODE can be \"smart\", \"fast\", or \"immediate\"\n" msgstr " -m, --mode=MODE MODEã¯\"smart\"ã€\"fast\"ã€\"immediate\"ã®ã„ãšã‚Œã‹ã§ã™\n" -#: pg_ctl.c:1803 +#: pg_ctl.c:1953 #, c-format msgid "" "\n" @@ -651,22 +671,22 @@ msgstr "" "\n" "シャットダウンモードã¯ä»¥ä¸‹ã®é€šã‚Šã§ã™:\n" -#: pg_ctl.c:1804 +#: pg_ctl.c:1954 #, c-format msgid " smart quit after all clients have disconnected\n" msgstr " smart 全クライアントã®æŽ¥ç¶šåˆ‡æ–­å¾Œã«åœæ­¢ã—ã¾ã™\n" -#: pg_ctl.c:1805 +#: pg_ctl.c:1955 #, c-format msgid " fast quit directly, with proper shutdown\n" msgstr " fast シャットダウン手続ã後ã«åœæ­¢ã—ã¾ã™\n" -#: pg_ctl.c:1806 +#: pg_ctl.c:1956 #, c-format msgid " immediate quit without complete shutdown; will lead to recovery on restart\n" msgstr " immediate シャットダウン手続ãã‚’è¡Œã‚ãšã«åœæ­¢ã—ã¾ã™ã€‚å†èµ·å‹•æ™‚ã«ãƒªã‚«ãƒãƒªçŠ¶æ…‹ã«ãªã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™\n" -#: pg_ctl.c:1808 +#: pg_ctl.c:1958 #, c-format msgid "" "\n" @@ -675,7 +695,7 @@ msgstr "" "\n" "killモードã§åˆ©ç”¨ã§ãるシグナルå:\n" -#: pg_ctl.c:1812 +#: pg_ctl.c:1962 #, c-format msgid "" "\n" @@ -684,27 +704,27 @@ msgstr "" "\n" "登録ã€ç™»éŒ²è§£é™¤ç”¨ã®ã‚ªãƒ—ション:\n" -#: pg_ctl.c:1813 +#: pg_ctl.c:1963 #, c-format msgid " -N SERVICENAME service name with which to register PostgreSQL server\n" msgstr " -N SERVICENAME PostgreSQLサーãƒã‚’登録ã™ã‚‹ãŸã‚ã®ã‚µãƒ¼ãƒ“スåã§ã™\n" -#: pg_ctl.c:1814 +#: pg_ctl.c:1964 #, c-format msgid " -P PASSWORD password of account to register PostgreSQL server\n" msgstr " -P PASSWORD PostgreSQLサーãƒã‚’登録ã™ã‚‹ã‚¢ã‚«ã‚¦ãƒ³ãƒˆã®ãƒ‘スワードã§ã™\n" -#: pg_ctl.c:1815 +#: pg_ctl.c:1965 #, c-format msgid " -U USERNAME user name of account to register PostgreSQL server\n" msgstr " -U USERNAME PostgreSQLサーãƒã‚’登録ã™ã‚‹ã‚¢ã‚«ã‚¦ãƒ³ãƒˆã®ãƒ¦ãƒ¼ã‚¶åã§ã™\n" -#: pg_ctl.c:1816 +#: pg_ctl.c:1966 #, c-format msgid " -S START-TYPE service start type to register PostgreSQL server\n" msgstr " -S START-TYPE PostgreSQLサーãƒã‚’登録ã™ã‚‹ãŸã‚ã®ã‚µãƒ¼ãƒ“ス起動種類ã§ã™\n" -#: pg_ctl.c:1818 +#: pg_ctl.c:1968 #, c-format msgid "" "\n" @@ -713,17 +733,17 @@ msgstr "" "\n" "起動種類ã¯ä»¥ä¸‹ã®é€šã‚Šã§ã™:\n" -#: pg_ctl.c:1819 +#: pg_ctl.c:1969 #, c-format msgid " auto start service automatically during system startup (default)\n" msgstr " auto システムã®èµ·å‹•æ™‚ã«ã‚µãƒ¼ãƒ“スを自動的ã«é–‹å§‹ã—ã¾ã™ï¼ˆãƒ‡ãƒ•ã‚©ãƒ«ãƒˆï¼‰\n" -#: pg_ctl.c:1820 +#: pg_ctl.c:1970 #, c-format msgid " demand start service on demand\n" msgstr " demand å¿…è¦ã«å¿œã˜ã¦ã‚µãƒ¼ãƒ“スを開始ã—ã¾ã™\n" -#: pg_ctl.c:1823 +#: pg_ctl.c:1973 #, c-format msgid "" "\n" @@ -732,27 +752,27 @@ msgstr "" "\n" "ä¸å…·åˆã¯ã¾ã§å ±å‘Šã—ã¦ãã ã•ã„。\n" -#: pg_ctl.c:1848 +#: pg_ctl.c:1998 #, c-format msgid "%s: unrecognized shutdown mode \"%s\"\n" msgstr "%s: シャットダウンモード\"%s\"ã¯ä¸æ˜Žã§ã™\n" -#: pg_ctl.c:1880 +#: pg_ctl.c:2030 #, c-format msgid "%s: unrecognized signal name \"%s\"\n" msgstr "%s: シグナルå\"%s\"ã¯ä¸æ˜Žã§ã™\n" -#: pg_ctl.c:1897 +#: pg_ctl.c:2047 #, c-format msgid "%s: unrecognized start type \"%s\"\n" msgstr "%s: 起動種類\"%s\"ã¯ä¸æ˜Žã§ã™\n" -#: pg_ctl.c:1950 +#: pg_ctl.c:2102 #, c-format msgid "%s: could not determine the data directory using command \"%s\"\n" msgstr "%s: コマンド\"%s\"を使用ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’決定ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_ctl.c:2022 +#: pg_ctl.c:2175 #, c-format msgid "" "%s: cannot be run as root\n" @@ -763,62 +783,34 @@ msgstr "" "サーãƒãƒ—ロセスã®æ‰€æœ‰è€…ã¨ãªã‚‹(éžç‰¹æ¨©)ユーザã¨ã—ã¦(例ãˆã°\"su\"を使用ã—ã¦)\n" "ログインã—ã¦ãã ã•ã„。\n" -#: pg_ctl.c:2093 +#: pg_ctl.c:2258 #, c-format msgid "%s: -S option not supported on this platform\n" msgstr "%s: -Sオプションã¯ã“ã®ãƒ—ラットフォームã§ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_ctl.c:2135 +#: pg_ctl.c:2297 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: コマンドライン引数ãŒå¤šã™ãŽã¾ã™(先頭ã¯\"%s\")\n" -#: pg_ctl.c:2159 +#: pg_ctl.c:2321 #, c-format msgid "%s: missing arguments for kill mode\n" msgstr "%s: killモード用ã®å¼•æ•°ãŒã‚ã‚Šã¾ã›ã‚“\n" -#: pg_ctl.c:2177 +#: pg_ctl.c:2339 #, c-format msgid "%s: unrecognized operation mode \"%s\"\n" msgstr "%s: æ“作モード\"%s\"ã¯ä¸æ˜Žã§ã™\n" -#: pg_ctl.c:2187 +#: pg_ctl.c:2349 #, c-format msgid "%s: no operation specified\n" msgstr "%s: æ“作モードãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_ctl.c:2208 +#: pg_ctl.c:2370 #, c-format msgid "%s: no database directory specified and environment variable PGDATA unset\n" msgstr "%s: データベースã®æŒ‡å®šã‚‚ã€PGDATA環境変数ã®è¨­å®šã‚‚ã‚ã‚Šã¾ã›ã‚“\n" -#~ msgid "%s: could not create restricted token: %lu\n" -#~ msgstr "%s: 制é™ä»˜ãトークンを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %lu\n" - -#~ msgid "could not change directory to \"%s\"" -#~ msgstr "ディレクトリを\"%s\"ã«å¤‰æ›´ã§ãã¾ã›ã‚“ã§ã—ãŸ" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã€çµ‚了ã—ã¾ã™\n" - -#~ msgid "%s: could not open process token: %lu\n" -#~ msgstr "%s: プロセストークンをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %lu\n" - -#~ msgid "" -#~ "%s is a utility to start, stop, restart, reload configuration files,\n" -#~ "report the status of a PostgreSQL server, or signal a PostgreSQL process.\n" -#~ "\n" -#~ msgstr "" -#~ "%sã¯PostgreSQLサーãƒã®èµ·å‹•ã€åœæ­¢ã€å†èµ·å‹•ã€è¨­å®šãƒ•ã‚¡ã‚¤ãƒ«ã®ãƒªãƒ­ãƒ¼ãƒ‰ã€çŠ¶æ³å ±å‘Š\n" -#~ "ã‚’è¡Œã†ãƒ¦ãƒ¼ãƒ†ã‚£ãƒªãƒ†ã‚£ã§ã™ã€‚ã¾ãŸã€PostgreSQLプロセスã¸ã‚·ã‚°ãƒŠãƒ«ã‚‚é€ä¿¡ã—ã¾ã™ã€‚\n" -#~ "\n" - -#~ msgid "%s: out of memory\n" -#~ msgstr "%s: メモリä¸è¶³ã§ã™\n" - -#~ msgid "%s: could not allocate SIDs: %lu\n" -#~ msgstr "%s: SIDを割り当ã¦ã‚‰ã‚Œã¾ã›ã‚“ã§ã—ãŸ: %lu\n" -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" diff --git a/src/bin/pg_dump/po/fr.po b/src/bin/pg_dump/po/fr.po index e647d0035e..48a667138a 100644 --- a/src/bin/pg_dump/po/fr.po +++ b/src/bin/pg_dump/po/fr.po @@ -9,8 +9,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-11-26 18:44+0000\n" -"PO-Revision-Date: 2016-11-26 22:30+0100\n" +"POT-Creation-Date: 2017-02-06 16:13+0000\n" +"PO-Revision-Date: 2017-02-06 19:03+0100\n" "Last-Translator: Guillaume Lelarge \n" "Language-Team: PostgreSQLfr \n" "Language: fr\n" @@ -18,7 +18,7 @@ msgstr "" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n > 1);\n" -"X-Generator: Poedit 1.8.8\n" +"X-Generator: Poedit 1.8.11\n" #: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format @@ -55,9 +55,8 @@ msgstr "n'a pas pu lire le lien symbolique « %s »" msgid "pclose failed: %s" msgstr "échec de pclose : %s" -#: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 -#: ../../common/fe_memutils.c:98 pg_backup_db.c:158 pg_backup_db.c:213 -#: pg_backup_db.c:272 pg_backup_db.c:314 +#: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 ../../common/fe_memutils.c:98 +#: pg_backup_db.c:158 pg_backup_db.c:213 pg_backup_db.c:272 pg_backup_db.c:314 #, c-format msgid "out of memory\n" msgstr "mémoire épuisée\n" @@ -180,8 +179,7 @@ msgstr "lecture des dictionnaires utilisateur pour la recherche plein texte\n" #: common.c:198 #, c-format msgid "reading user-defined text search configurations\n" -msgstr "" -"lecture des configurations utilisateur pour la recherche plein texte\n" +msgstr "lecture des configurations utilisateur pour la recherche plein texte\n" #: common.c:202 #, c-format @@ -275,11 +273,8 @@ msgstr "lecture des politiques\n" #: common.c:908 #, c-format -msgid "" -"failed sanity check, parent OID %u of table \"%s\" (OID %u) not found\n" -msgstr "" -"vérification échouée, OID %u parent de la table « %s » (OID %u) " -"introuvable\n" +msgid "failed sanity check, parent OID %u of table \"%s\" (OID %u) not found\n" +msgstr "vérification échouée, OID %u parent de la table « %s » (OID %u) introuvable\n" #: common.c:950 #, c-format @@ -303,8 +298,7 @@ msgstr "compression_io" msgid "invalid compression code: %d\n" msgstr "code de compression invalide : %d\n" -#: compress_io.c:138 compress_io.c:174 compress_io.c:192 compress_io.c:519 -#: compress_io.c:562 +#: compress_io.c:138 compress_io.c:174 compress_io.c:192 compress_io.c:519 compress_io.c:562 #, c-format msgid "not built with zlib support\n" msgstr "pas construit avec le support de zlib\n" @@ -334,14 +328,13 @@ msgstr "n'a pas pu décompresser les données : %s\n" msgid "could not close compression library: %s\n" msgstr "n'a pas pu fermer la bibliothèque de compression : %s\n" -#: compress_io.c:596 compress_io.c:632 pg_backup_custom.c:591 -#: pg_backup_tar.c:561 +#: compress_io.c:596 compress_io.c:632 pg_backup_custom.c:591 pg_backup_tar.c:561 #, c-format msgid "could not read from input file: %s\n" msgstr "n'a pas pu lire à partir du fichier en entrée : %s\n" -#: compress_io.c:635 pg_backup_custom.c:588 pg_backup_directory.c:548 -#: pg_backup_tar.c:797 pg_backup_tar.c:821 +#: compress_io.c:635 pg_backup_custom.c:588 pg_backup_directory.c:548 pg_backup_tar.c:797 +#: pg_backup_tar.c:821 #, c-format msgid "could not read from input file: end of file\n" msgstr "n'a pas pu lire à partir du fichier en entrée : fin du fichier\n" @@ -369,14 +362,12 @@ msgstr "n'a pas pu créer le processus de travail : %s\n" #, c-format msgid "" "could not obtain lock on relation \"%s\"\n" -"This usually means that someone requested an ACCESS EXCLUSIVE lock on the " -"table after the pg_dump parent process had gotten the initial ACCESS SHARE " -"lock on the table.\n" +"This usually means that someone requested an ACCESS EXCLUSIVE lock on the table after the pg_dump " +"parent process had gotten the initial ACCESS SHARE lock on the table.\n" msgstr "" "impossible d'obtenir un verrou sur la relationn « %s »\n" -"Cela signifie en général que quelqu'un à demandé un verrou ACCESS EXCLUSIVE " -"sur la table après que pg_dump ait obtenu son verrou ACCESS SHARE initial " -"sur la table.\n" +"Cela signifie en général que quelqu'un à demandé un verrou ACCESS EXCLUSIVE sur la table après que " +"pg_dump ait obtenu son verrou ACCESS SHARE initial sur la table.\n" #: parallel.c:1262 #, c-format @@ -456,9 +447,7 @@ msgstr "n'a pas pu fermer le fichier de sortie : %s\n" #: pg_backup_archiver.c:280 pg_backup_archiver.c:285 #, c-format msgid "WARNING: archive items not in correct section order\n" -msgstr "" -"ATTENTION : les éléments de l'archive ne sont pas dans l'ordre correct de " -"la section\n" +msgstr "ATTENTION : les éléments de l'archive ne sont pas dans l'ordre correct de la section\n" #: pg_backup_archiver.c:291 #, c-format @@ -479,17 +468,14 @@ msgstr "" #: pg_backup_archiver.c:341 #, c-format -msgid "" -"parallel restore is not supported with archives made by pre-8.0 pg_dump\n" +msgid "parallel restore is not supported with archives made by pre-8.0 pg_dump\n" msgstr "" "la restauration parallèle n'est pas supportée avec les archives réalisées\n" "par un pg_dump antérieur à la 8.0 d'archive\n" #: pg_backup_archiver.c:359 #, c-format -msgid "" -"cannot restore from compressed archive (compression not supported in this " -"installation)\n" +msgid "cannot restore from compressed archive (compression not supported in this installation)\n" msgstr "" "ne peut pas restaurer à partir de l'archive compressée (compression non\n" "disponible dans cette installation)\n" @@ -518,11 +504,8 @@ msgstr "suppression de %s %s\n" #: pg_backup_archiver.c:586 #, c-format -msgid "" -"WARNING: could not find where to insert IF EXISTS in statement \"%s\"\n" -msgstr "" -"ATTENTION : n'a pas pu trouver où insérer IF EXISTS dans l'instruction « %s " -"»\n" +msgid "WARNING: could not find where to insert IF EXISTS in statement \"%s\"\n" +msgstr "ATTENTION : n'a pas pu trouver où insérer IF EXISTS dans l'instruction « %s »\n" #: pg_backup_archiver.c:662 #, c-format @@ -581,9 +564,7 @@ msgstr "activation des triggers pour %s\n" #: pg_backup_archiver.c:1004 #, c-format -msgid "" -"internal error -- WriteData cannot be called outside the context of a " -"DataDumper routine\n" +msgid "internal error -- WriteData cannot be called outside the context of a DataDumper routine\n" msgstr "" "erreur interne -- WriteData ne peut pas être appelé en dehors du contexte\n" "de la routine DataDumper\n" @@ -591,9 +572,7 @@ msgstr "" #: pg_backup_archiver.c:1173 #, c-format msgid "large-object output not supported in chosen format\n" -msgstr "" -"la sauvegarde des « Large Objects » n'est pas supportée dans le format " -"choisi\n" +msgstr "la sauvegarde des « Large Objects » n'est pas supportée dans le format choisi\n" #: pg_backup_archiver.c:1231 #, c-format @@ -612,7 +591,7 @@ msgstr "restauration du « Large Object » d'OID %u\n" msgid "could not create large object %u: %s" msgstr "n'a pas pu créer le « Large Object » %u : %s" -#: pg_backup_archiver.c:1269 pg_dump.c:3060 +#: pg_backup_archiver.c:1269 pg_dump.c:3070 #, c-format msgid "could not open large object %u: %s" msgstr "n'a pas pu ouvrir le « Large Object » %u : %s" @@ -632,15 +611,13 @@ msgstr "ATTENTION : ligne ignorée : %s\n" msgid "could not find entry for ID %d\n" msgstr "n'a pas pu trouver l'entrée pour l'ID %d\n" -#: pg_backup_archiver.c:1396 pg_backup_directory.c:230 -#: pg_backup_directory.c:597 +#: pg_backup_archiver.c:1396 pg_backup_directory.c:230 pg_backup_directory.c:597 #, c-format msgid "could not close TOC file: %s\n" msgstr "n'a pas pu fermer le fichier TOC : %s\n" #: pg_backup_archiver.c:1505 pg_backup_custom.c:162 pg_backup_directory.c:341 -#: pg_backup_directory.c:583 pg_backup_directory.c:641 -#: pg_backup_directory.c:661 +#: pg_backup_directory.c:583 pg_backup_directory.c:641 pg_backup_directory.c:661 #, c-format msgid "could not open output file \"%s\": %s\n" msgstr "n'a pas pu ouvrir le fichier de sauvegarde « %s » : %s\n" @@ -654,16 +631,13 @@ msgstr "n'a pas pu ouvrir le fichier de sauvegarde : %s\n" #, c-format msgid "wrote %lu byte of large object data (result = %lu)\n" msgid_plural "wrote %lu bytes of large object data (result = %lu)\n" -msgstr[0] "" -"a écrit %lu octet de données d'un « Large Object » (résultat = %lu)\n" -msgstr[1] "" -"a écrit %lu octets de données d'un « Large Object » (résultat = %lu)\n" +msgstr[0] "a écrit %lu octet de données d'un « Large Object » (résultat = %lu)\n" +msgstr[1] "a écrit %lu octets de données d'un « Large Object » (résultat = %lu)\n" #: pg_backup_archiver.c:1620 #, c-format msgid "could not write to large object (result: %lu, expected: %lu)\n" -msgstr "" -"n'a pas pu écrire le « Large Object » (résultat : %lu, attendu : %lu)\n" +msgstr "n'a pas pu écrire le « Large Object » (résultat : %lu, attendu : %lu)\n" #: pg_backup_archiver.c:1713 #, c-format @@ -717,15 +691,11 @@ msgstr "nom du répertoire trop long : « %s »\n" #: pg_backup_archiver.c:2084 #, c-format -msgid "" -"directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does " -"not exist)\n" -msgstr "" -"le répertoire « %s » ne semble pas être une archive valide (« toc.dat » " -"n'existe pas)\n" +msgid "directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does not exist)\n" +msgstr "le répertoire « %s » ne semble pas être une archive valide (« toc.dat » n'existe pas)\n" -#: pg_backup_archiver.c:2092 pg_backup_custom.c:181 pg_backup_custom.c:770 -#: pg_backup_directory.c:214 pg_backup_directory.c:399 +#: pg_backup_archiver.c:2092 pg_backup_custom.c:181 pg_backup_custom.c:770 pg_backup_directory.c:214 +#: pg_backup_directory.c:399 #, c-format msgid "could not open input file \"%s\": %s\n" msgstr "n'a pas pu ouvrir le fichier en entrée « %s » : %s\n" @@ -748,15 +718,12 @@ msgstr "le fichier en entrée est trop petit (%lu lus, 5 attendus)\n" #: pg_backup_archiver.c:2192 #, c-format msgid "input file appears to be a text format dump. Please use psql.\n" -msgstr "" -"Le fichier en entrée semble être une sauvegarde au format texte. Merci " -"d'utiliser psql.\n" +msgstr "Le fichier en entrée semble être une sauvegarde au format texte. Merci d'utiliser psql.\n" #: pg_backup_archiver.c:2198 #, c-format msgid "input file does not appear to be a valid archive (too short?)\n" -msgstr "" -"le fichier en entrée ne semble pas être une archive valide (trop petit ?)\n" +msgstr "le fichier en entrée ne semble pas être une archive valide (trop petit ?)\n" #: pg_backup_archiver.c:2204 #, c-format @@ -781,8 +748,7 @@ msgstr "format de fichier « %d » non reconnu\n" #: pg_backup_archiver.c:2502 #, c-format msgid "entry ID %d out of range -- perhaps a corrupt TOC\n" -msgstr "" -"ID %d de l'entrée en dehors de la plage -- peut-être un TOC corrompu\n" +msgstr "ID %d de l'entrée en dehors de la plage -- peut-être un TOC corrompu\n" #: pg_backup_archiver.c:2618 #, c-format @@ -852,9 +818,7 @@ msgstr "n'a pas pu configurer default_tablespace à %s : %s" #: pg_backup_archiver.c:3276 pg_backup_archiver.c:3470 #, c-format msgid "WARNING: don't know how to set owner for object type %s\n" -msgstr "" -"ATTENTION : ne sait pas comment initialiser le propriétaire du type d'objet " -"%s\n" +msgstr "ATTENTION : ne sait pas comment initialiser le propriétaire du type d'objet %s\n" #: pg_backup_archiver.c:3552 #, c-format @@ -873,9 +837,7 @@ msgstr "échec de la vérification sur la taille de l'entier (%lu)\n" #: pg_backup_archiver.c:3574 #, c-format -msgid "" -"WARNING: archive was made on a machine with larger integers, some " -"operations might fail\n" +msgid "WARNING: archive was made on a machine with larger integers, some operations might fail\n" msgstr "" "ATTENTION : l'archive a été créée sur une machine disposant d'entiers plus\n" "larges, certaines opérations peuvent échouer\n" @@ -888,8 +850,8 @@ msgstr "le format attendu (%d) diffère du format du fichier (%d)\n" #: pg_backup_archiver.c:3600 #, c-format msgid "" -"WARNING: archive is compressed, but this installation does not support " -"compression -- no data will be available\n" +"WARNING: archive is compressed, but this installation does not support compression -- no data will " +"be available\n" msgstr "" "ATTENTION : l'archive est compressée mais cette installation ne supporte\n" "pas la compression -- aucune donnée ne sera disponible\n" @@ -977,9 +939,7 @@ msgstr "réduction des dépendances pour %d\n" #: pg_backup_archiver.c:4428 #, c-format msgid "table \"%s\" could not be created, will not restore its data\n" -msgstr "" -"la table « %s » n'a pas pu être créée, ses données ne seront pas " -"restaurées\n" +msgstr "la table « %s » n'a pas pu être créée, ses données ne seront pas restaurées\n" #. translator: this is a module name #: pg_backup_custom.c:94 @@ -1006,27 +966,23 @@ msgstr "erreur lors du parcours du fichier : %s\n" #: pg_backup_custom.c:476 #, c-format msgid "" -"could not find block ID %d in archive -- possibly due to out-of-order " -"restore request, which cannot be handled due to lack of data offsets in " -"archive\n" +"could not find block ID %d in archive -- possibly due to out-of-order restore request, which cannot " +"be handled due to lack of data offsets in archive\n" msgstr "" "n'a pas pu trouver l'identifiant de bloc %d dans l'archive -\n" -"il est possible que cela soit dû à une demande de restauration dans un " -"ordre\n" +"il est possible que cela soit dû à une demande de restauration dans un ordre\n" "différent, qui n'a pas pu être géré à cause d'un manque d'information de\n" "position dans l'archive\n" #: pg_backup_custom.c:481 #, c-format msgid "" -"could not find block ID %d in archive -- possibly due to out-of-order " -"restore request, which cannot be handled due to non-seekable input file\n" +"could not find block ID %d in archive -- possibly due to out-of-order restore request, which cannot " +"be handled due to non-seekable input file\n" msgstr "" "n'a pas pu trouver l'identifiant de bloc %d dans l'archive -\n" -"il est possible que cela soit dû à une demande de restauration dans un " -"ordre\n" -"différent, ce qui ne peut pas être géré à cause d'un fichier non gérable " -"en\n" +"il est possible que cela soit dû à une demande de restauration dans un ordre\n" +"différent, ce qui ne peut pas être géré à cause d'un fichier non gérable en\n" "recherche\n" #: pg_backup_custom.c:486 @@ -1039,23 +995,17 @@ msgstr "" #: pg_backup_custom.c:493 #, c-format msgid "found unexpected block ID (%d) when reading data -- expected %d\n" -msgstr "" -"ID de bloc inattendu (%d) lors de la lecture des données -- %d attendu\n" +msgstr "ID de bloc inattendu (%d) lors de la lecture des données -- %d attendu\n" #: pg_backup_custom.c:507 #, c-format msgid "unrecognized data block type %d while restoring archive\n" -msgstr "" -"type de bloc de données %d non reconnu lors de la restauration de " -"l'archive\n" +msgstr "type de bloc de données %d non reconnu lors de la restauration de l'archive\n" -#: pg_backup_custom.c:709 pg_backup_custom.c:759 pg_backup_custom.c:908 -#: pg_backup_tar.c:1088 +#: pg_backup_custom.c:709 pg_backup_custom.c:759 pg_backup_custom.c:908 pg_backup_tar.c:1088 #, c-format msgid "could not determine seek position in archive file: %s\n" -msgstr "" -"n'a pas pu déterminer la position de recherche dans le fichier d'archive : " -"%s\n" +msgstr "n'a pas pu déterminer la position de recherche dans le fichier d'archive : %s\n" #: pg_backup_custom.c:727 pg_backup_custom.c:764 #, c-format @@ -1075,16 +1025,12 @@ msgstr "la restauration parallélisée n'est pas supportée à partir de stdin\n #: pg_backup_custom.c:755 #, c-format msgid "parallel restore from non-seekable file is not supported\n" -msgstr "" -"la restauration parallélisée n'est pas supportée à partir de fichiers sans " -"table de matière\n" +msgstr "la restauration parallélisée n'est pas supportée à partir de fichiers sans table de matière\n" #: pg_backup_custom.c:774 #, c-format msgid "could not set seek position in archive file: %s\n" -msgstr "" -"n'a pas pu initialiser la recherche de position dans le fichier d'archive : " -"%s\n" +msgstr "n'a pas pu initialiser la recherche de position dans le fichier d'archive : %s\n" #: pg_backup_custom.c:792 #, c-format @@ -1094,9 +1040,7 @@ msgstr "compression activée\n" #: pg_backup_custom.c:912 #, c-format msgid "WARNING: ftell mismatch with expected position -- ftell used\n" -msgstr "" -"ATTENTION : ftell ne correspond pas à la position attendue -- ftell " -"utilisé\n" +msgstr "ATTENTION : ftell ne correspond pas à la position attendue -- ftell utilisé\n" #. translator: this is a module name #: pg_backup_db.c:31 @@ -1108,12 +1052,12 @@ msgstr "programme d'archivage (db)" msgid "could not get server_version from libpq\n" msgstr "n'a pas pu obtenir server_version de libpq\n" -#: pg_backup_db.c:58 pg_dumpall.c:2067 +#: pg_backup_db.c:58 pg_dumpall.c:2068 #, c-format msgid "server version: %s; %s version: %s\n" msgstr "version du serveur : %s ; %s version : %s\n" -#: pg_backup_db.c:60 pg_dumpall.c:2069 +#: pg_backup_db.c:60 pg_dumpall.c:2070 #, c-format msgid "aborting because of server version mismatch\n" msgstr "annulation à cause de la différence des versions\n" @@ -1123,8 +1067,8 @@ msgstr "annulation à cause de la différence des versions\n" msgid "connecting to database \"%s\" as user \"%s\"\n" msgstr "connexion à la base de données « %s » en tant qu'utilisateur « %s »\n" -#: pg_backup_db.c:156 pg_backup_db.c:208 pg_backup_db.c:270 pg_backup_db.c:312 -#: pg_dumpall.c:1893 pg_dumpall.c:2005 +#: pg_backup_db.c:156 pg_backup_db.c:208 pg_backup_db.c:270 pg_backup_db.c:312 pg_dumpall.c:1894 +#: pg_dumpall.c:2006 msgid "Password: " msgstr "Mot de passe : " @@ -1204,12 +1148,11 @@ msgstr "erreur renvoyée par PQputCopyEnd : %s" msgid "COPY failed for table \"%s\": %s" msgstr "COPY échoué pour la table « %s » : %s" -#: pg_backup_db.c:657 pg_dump.c:1795 +#: pg_backup_db.c:657 pg_dump.c:1805 #, c-format msgid "WARNING: unexpected extra results during COPY of table \"%s\"\n" msgstr "" -"ATTENTION: résultats supplémentaires non attendus durant l'exécution de " -"COPY sur la table « %s »\n" +"ATTENTION: résultats supplémentaires non attendus durant l'exécution de COPY sur la table « %s »\n" #: pg_backup_db.c:669 msgid "could not start database transaction" @@ -1252,9 +1195,7 @@ msgstr "n'a pas pu fermer le fichier de données : %s\n" #: pg_backup_directory.c:453 #, c-format msgid "could not open large object TOC file \"%s\" for input: %s\n" -msgstr "" -"n'a pas pu ouvrir le fichier sommaire « %s » du Large Object en entrée : " -"%s\n" +msgstr "n'a pas pu ouvrir le fichier sommaire « %s » du Large Object en entrée : %s\n" #: pg_backup_directory.c:464 #, c-format @@ -1365,16 +1306,13 @@ msgstr "n'a pas pu ouvrir le fichier temporaire : %s\n" #, c-format msgid "actual file length (%s) does not match expected (%s)\n" msgstr "" -"la longueur réelle du fichier (%s) ne correspond pas à ce qui était " -"attendu\n" +"la longueur réelle du fichier (%s) ne correspond pas à ce qui était attendu\n" "(%s)\n" #: pg_backup_tar.c:1151 #, c-format msgid "moving from position %s to next member at file position %s\n" -msgstr "" -"déplacement de la position %s vers le prochain membre à la position %s du " -"fichier\n" +msgstr "déplacement de la position %s vers le prochain membre à la position %s du fichier\n" #: pg_backup_tar.c:1162 #, c-format @@ -1394,8 +1332,8 @@ msgstr "omission du membre %s du tar\n" #: pg_backup_tar.c:1189 #, c-format msgid "" -"restoring data out of order is not supported in this archive format: \"%s\" " -"is required, but comes before \"%s\" in the archive file.\n" +"restoring data out of order is not supported in this archive format: \"%s\" is required, but comes " +"before \"%s\" in the archive file.\n" msgstr "" "la restauration désordonnée de données n'est pas supportée avec ce format\n" "d'archive : « %s » est requis mais vient avant « %s » dans le fichier\n" @@ -1415,8 +1353,7 @@ msgstr "entrée TOC %s à %s (longueur %s, somme de contrôle %d)\n" #: pg_backup_tar.c:1287 #, c-format -msgid "" -"corrupt tar header found in %s (expected %d, computed %d) file position %s\n" +msgid "corrupt tar header found in %s (expected %d, computed %d) file position %s\n" msgstr "" "en-tête tar corrompu trouvé dans %s (%d attendu, %d calculé ) à la\n" "position %s du fichier\n" @@ -1426,9 +1363,9 @@ msgstr "" msgid "%s: unrecognized section name: \"%s\"\n" msgstr "%s : nom de section non reconnu : « %s »\n" -#: pg_backup_utils.c:56 pg_dump.c:533 pg_dump.c:550 pg_dumpall.c:299 -#: pg_dumpall.c:309 pg_dumpall.c:319 pg_dumpall.c:328 pg_dumpall.c:344 -#: pg_dumpall.c:402 pg_restore.c:279 pg_restore.c:295 pg_restore.c:307 +#: pg_backup_utils.c:56 pg_dump.c:536 pg_dump.c:553 pg_dumpall.c:299 pg_dumpall.c:309 pg_dumpall.c:319 +#: pg_dumpall.c:328 pg_dumpall.c:344 pg_dumpall.c:402 pg_restore.c:279 pg_restore.c:295 +#: pg_restore.c:307 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Essayer « %s --help » pour plus d'informations.\n" @@ -1438,106 +1375,99 @@ msgstr "Essayer « %s --help » pour plus d'informations.\n" msgid "out of on_exit_nicely slots\n" msgstr "plus d'emplacements on_exit_nicely\n" -#: pg_dump.c:503 +#: pg_dump.c:506 #, c-format msgid "compression level must be in range 0..9\n" msgstr "le niveau de compression doit être compris entre 0 et 9\n" -#: pg_dump.c:548 pg_dumpall.c:307 pg_restore.c:293 +#: pg_dump.c:551 pg_dumpall.c:307 pg_restore.c:293 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" -msgstr "" -"%s : trop d'arguments en ligne de commande (le premier étant « %s »)\n" +msgstr "%s : trop d'arguments en ligne de commande (le premier étant « %s »)\n" -#: pg_dump.c:561 +#: pg_dump.c:564 #, c-format msgid "options -s/--schema-only and -a/--data-only cannot be used together\n" msgstr "" "les options « -s/--schema-only » et « -a/--data-only » ne peuvent pas être\n" "utilisées conjointement\n" -#: pg_dump.c:567 +#: pg_dump.c:570 #, c-format msgid "options -c/--clean and -a/--data-only cannot be used together\n" msgstr "" "les options « -c/--clean » et « -a/--data-only » ne peuvent pas être\n" "utilisées conjointement\n" -#: pg_dump.c:573 +#: pg_dump.c:576 #, c-format -msgid "" -"options --inserts/--column-inserts and -o/--oids cannot be used together\n" +msgid "options --inserts/--column-inserts and -o/--oids cannot be used together\n" msgstr "" "les options « --inserts/--column-inserts » et « -o/--oids » ne\n" "peuvent pas être utilisées conjointement\n" -#: pg_dump.c:574 +#: pg_dump.c:577 #, c-format msgid "(The INSERT command cannot set OIDs.)\n" msgstr "(La commande INSERT ne peut pas positionner les OID.)\n" -#: pg_dump.c:579 +#: pg_dump.c:582 #, c-format msgid "option --if-exists requires option -c/--clean\n" msgstr "l'option --if-exists nécessite l'option -c/--clean\n" -#: pg_dump.c:601 +#: pg_dump.c:604 #, c-format msgid "" -"WARNING: requested compression not available in this installation -- " -"archive will be uncompressed\n" +"WARNING: requested compression not available in this installation -- archive will be uncompressed\n" msgstr "" "ATTENTION : la compression requise n'est pas disponible avec cette\n" "installation -- l'archive ne sera pas compressée\n" -#: pg_dump.c:616 +#: pg_dump.c:619 #, c-format -msgid "%s: invalid number of parallel jobs\n" -msgstr "%s : nombre de jobs en parallèle invalide\n" +msgid "invalid number of parallel jobs\n" +msgstr "nombre de jobs parallèles invalide\n" -#: pg_dump.c:620 +#: pg_dump.c:623 #, c-format msgid "parallel backup only supported by the directory format\n" -msgstr "" -"la sauvegarde parallèle n'est supportée qu'avec le format répertoire\n" +msgstr "la sauvegarde parallèle n'est supportée qu'avec le format répertoire\n" -#: pg_dump.c:677 +#: pg_dump.c:680 #, c-format msgid "" "Synchronized snapshots are not supported by this server version.\n" "Run with --no-synchronized-snapshots instead if you do not need\n" "synchronized snapshots.\n" msgstr "" -"Les snapshots synchronisés ne sont pas supportés par cette version " -"serveur.\n" -"Lancez avec --no-synchronized-snapshots à la place si vous n'avez pas " -"besoin\n" +"Les snapshots synchronisés ne sont pas supportés par cette version serveur.\n" +"Lancez avec --no-synchronized-snapshots à la place si vous n'avez pas besoin\n" "de snapshots synchronisés.\n" -#: pg_dump.c:684 +#: pg_dump.c:687 #, c-format msgid "Exported snapshots are not supported by this server version.\n" msgstr "" -"Les images exportées de la base ne sont pas supportées par cette version du " -"serveur.\n" +"Les images exportées de la base ne sont pas supportées par cette version du serveur.\n" "\n" -#: pg_dump.c:695 +#: pg_dump.c:706 #, c-format msgid "last built-in OID is %u\n" msgstr "le dernier OID interne est %u\n" -#: pg_dump.c:705 +#: pg_dump.c:715 #, c-format msgid "no matching schemas were found\n" msgstr "aucun schéma correspondant n'a été trouvé\n" -#: pg_dump.c:719 +#: pg_dump.c:729 #, c-format msgid "no matching tables were found\n" msgstr "aucune table correspondante n'a été trouvée\n" -#: pg_dump.c:878 +#: pg_dump.c:888 #, c-format msgid "" "%s dumps a database as a text file or to other formats.\n" @@ -1547,17 +1477,17 @@ msgstr "" "formats.\n" "\n" -#: pg_dump.c:879 pg_dumpall.c:547 pg_restore.c:437 +#: pg_dump.c:889 pg_dumpall.c:547 pg_restore.c:443 #, c-format msgid "Usage:\n" msgstr "Usage :\n" -#: pg_dump.c:880 +#: pg_dump.c:890 #, c-format msgid " %s [OPTION]... [DBNAME]\n" msgstr " %s [OPTION]... [NOMBASE]\n" -#: pg_dump.c:882 pg_dumpall.c:550 pg_restore.c:440 +#: pg_dump.c:892 pg_dumpall.c:550 pg_restore.c:446 #, c-format msgid "" "\n" @@ -1566,13 +1496,12 @@ msgstr "" "\n" "Options générales :\n" -#: pg_dump.c:883 +#: pg_dump.c:893 #, c-format msgid " -f, --file=FILENAME output file or directory name\n" -msgstr "" -" -f, --file=NOMFICHIER nom du fichier ou du répertoire en sortie\n" +msgstr " -f, --file=NOMFICHIER nom du fichier ou du répertoire en sortie\n" -#: pg_dump.c:884 +#: pg_dump.c:894 #, c-format msgid "" " -F, --format=c|d|t|p output file format (custom, directory, tar,\n" @@ -1581,46 +1510,43 @@ msgstr "" " -F, --format=c|d|t|p format du fichier de sortie (personnalisé,\n" " répertoire, tar, texte (par défaut))\n" -#: pg_dump.c:886 +#: pg_dump.c:896 #, c-format msgid " -j, --jobs=NUM use this many parallel jobs to dump\n" msgstr "" " -j, --jobs=NUMERO utilise ce nombre de jobs en parallèle pour\n" " la sauvegarde\n" -#: pg_dump.c:887 +#: pg_dump.c:897 pg_dumpall.c:552 #, c-format msgid " -v, --verbose verbose mode\n" msgstr " -v, --verbose mode verbeux\n" -#: pg_dump.c:888 pg_dumpall.c:552 +#: pg_dump.c:898 pg_dumpall.c:553 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version affiche la version puis quitte\n" -#: pg_dump.c:889 +#: pg_dump.c:899 #, c-format -msgid "" -" -Z, --compress=0-9 compression level for compressed formats\n" +msgid " -Z, --compress=0-9 compression level for compressed formats\n" msgstr "" " -Z, --compress=0-9 niveau de compression pour les formats\n" " compressés\n" -#: pg_dump.c:890 pg_dumpall.c:553 +#: pg_dump.c:900 pg_dumpall.c:554 #, c-format -msgid "" -" --lock-wait-timeout=TIMEOUT fail after waiting TIMEOUT for a table lock\n" +msgid " --lock-wait-timeout=TIMEOUT fail after waiting TIMEOUT for a table lock\n" msgstr "" -" --lock-wait-timeout=DÉLAI échec après l'attente du DÉLAI pour un " -"verrou\n" +" --lock-wait-timeout=DÉLAI échec après l'attente du DÉLAI pour un verrou\n" " de table\n" -#: pg_dump.c:891 pg_dumpall.c:554 +#: pg_dump.c:901 pg_dumpall.c:555 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help affiche cette aide puis quitte\n" -#: pg_dump.c:893 pg_dumpall.c:555 +#: pg_dump.c:903 pg_dumpall.c:556 #, c-format msgid "" "\n" @@ -1629,267 +1555,225 @@ msgstr "" "\n" "Options contrôlant le contenu en sortie :\n" -#: pg_dump.c:894 pg_dumpall.c:556 +#: pg_dump.c:904 pg_dumpall.c:557 #, c-format msgid " -a, --data-only dump only the data, not the schema\n" msgstr "" " -a, --data-only sauvegarde uniquement les données, pas le\n" " schéma\n" -#: pg_dump.c:895 +#: pg_dump.c:905 #, c-format msgid " -b, --blobs include large objects in dump\n" msgstr "" " -b, --blobs inclut les « Large Objects » dans la\n" " sauvegarde\n" -#: pg_dump.c:896 pg_restore.c:451 +#: pg_dump.c:906 pg_restore.c:457 #, c-format -msgid "" -" -c, --clean clean (drop) database objects before " -"recreating\n" +msgid " -c, --clean clean (drop) database objects before recreating\n" msgstr "" " -c, --clean nettoie/supprime les objets de la base de\n" " données avant de les créer\n" -#: pg_dump.c:897 +#: pg_dump.c:907 #, c-format -msgid "" -" -C, --create include commands to create database in dump\n" +msgid " -C, --create include commands to create database in dump\n" msgstr "" " -C, --create inclut les commandes de création de la base\n" " dans la sauvegarde\n" -#: pg_dump.c:898 +#: pg_dump.c:908 #, c-format msgid " -E, --encoding=ENCODING dump the data in encoding ENCODING\n" msgstr "" " -E, --encoding=ENCODAGE sauvegarde les données dans l'encodage\n" " ENCODAGE\n" -#: pg_dump.c:899 +#: pg_dump.c:909 #, c-format msgid " -n, --schema=SCHEMA dump the named schema(s) only\n" -msgstr "" -" -n, --schema=SCHÉMA sauvegarde uniquement le schéma indiqué\n" +msgstr " -n, --schema=SCHÉMA sauvegarde uniquement le schéma indiqué\n" -#: pg_dump.c:900 +#: pg_dump.c:910 #, c-format msgid " -N, --exclude-schema=SCHEMA do NOT dump the named schema(s)\n" msgstr " -N, --exclude-schema=SCHÉMA ne sauvegarde pas le schéma indiqué\n" -#: pg_dump.c:901 pg_dumpall.c:559 +#: pg_dump.c:911 pg_dumpall.c:560 #, c-format msgid " -o, --oids include OIDs in dump\n" msgstr " -o, --oids inclut les OID dans la sauvegarde\n" -#: pg_dump.c:902 +#: pg_dump.c:912 #, c-format msgid "" " -O, --no-owner skip restoration of object ownership in\n" " plain-text format\n" msgstr "" " -O, --no-owner ne sauvegarde pas les propriétaires des\n" -" objets lors de l'utilisation du format " -"texte\n" +" objets lors de l'utilisation du format texte\n" -#: pg_dump.c:904 pg_dumpall.c:562 +#: pg_dump.c:914 pg_dumpall.c:563 #, c-format msgid " -s, --schema-only dump only the schema, no data\n" msgstr "" " -s, --schema-only sauvegarde uniquement la structure, pas les\n" " données\n" -#: pg_dump.c:905 +#: pg_dump.c:915 #, c-format -msgid "" -" -S, --superuser=NAME superuser user name to use in plain-text " -"format\n" +msgid " -S, --superuser=NAME superuser user name to use in plain-text format\n" msgstr "" " -S, --superuser=NOM indique le nom du super-utilisateur à\n" " utiliser avec le format texte\n" -#: pg_dump.c:906 +#: pg_dump.c:916 #, c-format msgid " -t, --table=TABLE dump the named table(s) only\n" -msgstr "" -" -t, --table=TABLE sauvegarde uniquement la table indiquée\n" +msgstr " -t, --table=TABLE sauvegarde uniquement la table indiquée\n" -#: pg_dump.c:907 +#: pg_dump.c:917 #, c-format msgid " -T, --exclude-table=TABLE do NOT dump the named table(s)\n" msgstr " -T, --exclude-table=TABLE ne sauvegarde pas la table indiquée\n" -#: pg_dump.c:908 pg_dumpall.c:565 +#: pg_dump.c:918 pg_dumpall.c:566 #, c-format msgid " -x, --no-privileges do not dump privileges (grant/revoke)\n" -msgstr "" -" -x, --no-privileges ne sauvegarde pas les droits sur les objets\n" +msgstr " -x, --no-privileges ne sauvegarde pas les droits sur les objets\n" -#: pg_dump.c:909 pg_dumpall.c:566 +#: pg_dump.c:919 pg_dumpall.c:567 #, c-format msgid " --binary-upgrade for use by upgrade utilities only\n" msgstr "" " --binary-upgrade à n'utiliser que par les outils de mise à\n" " jour seulement\n" -#: pg_dump.c:910 pg_dumpall.c:567 +#: pg_dump.c:920 pg_dumpall.c:568 #, c-format -msgid "" -" --column-inserts dump data as INSERT commands with column " -"names\n" +msgid " --column-inserts dump data as INSERT commands with column names\n" msgstr "" " --column-inserts sauvegarde les données avec des commandes\n" " INSERT en précisant les noms des colonnes\n" -#: pg_dump.c:911 pg_dumpall.c:568 +#: pg_dump.c:921 pg_dumpall.c:569 #, c-format -msgid "" -" --disable-dollar-quoting disable dollar quoting, use SQL standard " -"quoting\n" +msgid " --disable-dollar-quoting disable dollar quoting, use SQL standard quoting\n" msgstr "" " --disable-dollar-quoting désactive l'utilisation des guillemets\n" " dollar dans le but de respecter le standard\n" " SQL en matière de guillemets\n" -#: pg_dump.c:912 pg_dumpall.c:569 pg_restore.c:467 +#: pg_dump.c:922 pg_dumpall.c:570 pg_restore.c:473 #, c-format -msgid "" -" --disable-triggers disable triggers during data-only restore\n" +msgid " --disable-triggers disable triggers during data-only restore\n" msgstr "" -" --disable-triggers désactive les triggers en mode de " -"restauration\n" +" --disable-triggers désactive les triggers en mode de restauration\n" " des données seules\n" -#: pg_dump.c:913 +#: pg_dump.c:923 #, c-format msgid "" -" --enable-row-security enable row security (dump only content user " -"has\n" +" --enable-row-security enable row security (dump only content user has\n" " access to)\n" msgstr "" " --enable-row-security active la sécurité niveau ligne (et donc\\n\n" -" sauvegarde uniquement le contenu visible par" -"\\n\n" +" sauvegarde uniquement le contenu visible par\\n\n" " cet utilisateur)\n" -#: pg_dump.c:915 +#: pg_dump.c:925 #, c-format -msgid "" -" --exclude-table-data=TABLE do NOT dump data for the named table(s)\n" +msgid " --exclude-table-data=TABLE do NOT dump data for the named table(s)\n" msgstr " --exclude-table-data=TABLE ne sauvegarde pas la table indiquée\n" -#: pg_dump.c:916 pg_dumpall.c:570 pg_restore.c:469 +#: pg_dump.c:926 pg_dumpall.c:571 pg_restore.c:475 #, c-format msgid " --if-exists use IF EXISTS when dropping objects\n" -msgstr "" -" --if-exists utilise IF EXISTS lors de la suppression des " -"objets\n" +msgstr " --if-exists utilise IF EXISTS lors de la suppression des objets\n" -#: pg_dump.c:917 pg_dumpall.c:571 +#: pg_dump.c:927 pg_dumpall.c:572 #, c-format -msgid "" -" --inserts dump data as INSERT commands, rather than " -"COPY\n" +msgid " --inserts dump data as INSERT commands, rather than COPY\n" msgstr "" -" --inserts sauvegarde les données avec des " -"instructions\n" +" --inserts sauvegarde les données avec des instructions\n" " INSERT plutôt que COPY\n" -#: pg_dump.c:918 pg_dumpall.c:572 +#: pg_dump.c:928 pg_dumpall.c:573 #, c-format -msgid "" -" --no-security-labels do not dump security label assignments\n" +msgid " --no-security-labels do not dump security label assignments\n" msgstr "" -" --no-security-labels ne sauvegarde pas les affectations de labels " -"de\n" +" --no-security-labels ne sauvegarde pas les affectations de labels de\n" " sécurité\n" -#: pg_dump.c:919 +#: pg_dump.c:929 #, c-format -msgid "" -" --no-synchronized-snapshots do not use synchronized snapshots in " -"parallel jobs\n" +msgid " --no-synchronized-snapshots do not use synchronized snapshots in parallel jobs\n" msgstr "" -" --no-synchronized-snapshots n'utilise pas de snapshots synchronisés pour " -"les jobs en parallèle\n" +" --no-synchronized-snapshots n'utilise pas de snapshots synchronisés pour les jobs en parallèle\n" -#: pg_dump.c:920 pg_dumpall.c:573 +#: pg_dump.c:930 pg_dumpall.c:574 #, c-format msgid " --no-tablespaces do not dump tablespace assignments\n" msgstr "" " --no-tablespaces ne sauvegarde pas les affectations de\n" " tablespaces\n" -#: pg_dump.c:921 pg_dumpall.c:574 +#: pg_dump.c:931 pg_dumpall.c:575 #, c-format msgid " --no-unlogged-table-data do not dump unlogged table data\n" msgstr "" -" --no-unlogged-table-data ne sauvegarde pas les données des tables " -"non\n" +" --no-unlogged-table-data ne sauvegarde pas les données des tables non\n" " journalisées\n" -#: pg_dump.c:922 pg_dumpall.c:575 +#: pg_dump.c:932 pg_dumpall.c:576 #, c-format -msgid "" -" --quote-all-identifiers quote all identifiers, even if not key " -"words\n" +msgid " --quote-all-identifiers quote all identifiers, even if not key words\n" msgstr "" " --quote-all-identifiers met entre guillemets tous les identifiants\n" " même s'il ne s'agit pas de mots clés\n" -#: pg_dump.c:923 +#: pg_dump.c:933 #, c-format -msgid "" -" --section=SECTION dump named section (pre-data, data, or post-" -"data)\n" +msgid " --section=SECTION dump named section (pre-data, data, or post-data)\n" msgstr "" -" --section=SECTION sauvegarde la section indiquée (pre-data, " -"data\n" +" --section=SECTION sauvegarde la section indiquée (pre-data, data\n" " ou post-data)\n" -#: pg_dump.c:924 +#: pg_dump.c:934 #, c-format -msgid "" -" --serializable-deferrable wait until the dump can run without " -"anomalies\n" +msgid " --serializable-deferrable wait until the dump can run without anomalies\n" msgstr "" " --serializable-deferrable attend jusqu'à ce que la sauvegarde puisse\n" " s'exécuter sans anomalies\n" -#: pg_dump.c:925 +#: pg_dump.c:935 #, c-format msgid " --snapshot=SNAPSHOT use given snapshot for the dump\n" -msgstr "" -" --snapshot=SNAPSHOT utilise l'image donnée pour la sauvegarde\n" +msgstr " --snapshot=SNAPSHOT utilise l'image donnée pour la sauvegarde\n" -#: pg_dump.c:926 pg_restore.c:475 +#: pg_dump.c:936 pg_restore.c:481 #, c-format msgid "" -" --strict-names require table and/or schema include patterns " -"to\n" +" --strict-names require table and/or schema include patterns to\n" " match at least one entity each\n" msgstr "" -" --strict-names requiert que le motifs de table et/ou " -"schéma\n" -" correspondent à au moins une entité de " -"chaque\n" +" --strict-names requiert que le motifs de table et/ou schéma\n" +" correspondent à au moins une entité de chaque\n" -#: pg_dump.c:928 pg_dumpall.c:576 pg_restore.c:477 +#: pg_dump.c:938 pg_dumpall.c:577 pg_restore.c:483 #, c-format msgid "" " --use-set-session-authorization\n" -" use SET SESSION AUTHORIZATION commands " -"instead of\n" +" use SET SESSION AUTHORIZATION commands instead of\n" " ALTER OWNER commands to set ownership\n" msgstr "" " --use-set-session-authorization\n" -" utilise les commandes SET SESSION " -"AUTHORIZATION\n" +" utilise les commandes SET SESSION AUTHORIZATION\n" " au lieu des commandes ALTER OWNER pour\n" " modifier les propriétaires\n" -#: pg_dump.c:932 pg_dumpall.c:580 pg_restore.c:481 +#: pg_dump.c:942 pg_dumpall.c:581 pg_restore.c:487 #, c-format msgid "" "\n" @@ -1898,50 +1782,48 @@ msgstr "" "\n" "Options de connexion :\n" -#: pg_dump.c:933 +#: pg_dump.c:943 #, c-format msgid " -d, --dbname=DBNAME database to dump\n" msgstr " -d, --dbname=NOMBASE base de données à sauvegarder\n" -#: pg_dump.c:934 pg_dumpall.c:582 pg_restore.c:482 +#: pg_dump.c:944 pg_dumpall.c:583 pg_restore.c:488 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory\n" msgstr "" " -h, --host=NOMHÔTE hôte du serveur de bases de données ou\n" " répertoire des sockets\n" -#: pg_dump.c:935 pg_dumpall.c:584 pg_restore.c:483 +#: pg_dump.c:945 pg_dumpall.c:585 pg_restore.c:489 #, c-format msgid " -p, --port=PORT database server port number\n" msgstr "" " -p, --port=PORT numéro de port du serveur de bases de\n" " données\n" -#: pg_dump.c:936 pg_dumpall.c:585 pg_restore.c:484 +#: pg_dump.c:946 pg_dumpall.c:586 pg_restore.c:490 #, c-format msgid " -U, --username=NAME connect as specified database user\n" msgstr " -U, --username=NOM se connecter avec cet utilisateur\n" -#: pg_dump.c:937 pg_dumpall.c:586 pg_restore.c:485 +#: pg_dump.c:947 pg_dumpall.c:587 pg_restore.c:491 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password ne demande jamais le mot de passe\n" -#: pg_dump.c:938 pg_dumpall.c:587 pg_restore.c:486 +#: pg_dump.c:948 pg_dumpall.c:588 pg_restore.c:492 #, c-format -msgid "" -" -W, --password force password prompt (should happen " -"automatically)\n" +msgid " -W, --password force password prompt (should happen automatically)\n" msgstr "" " -W, --password force la demande du mot de passe (par\n" " défaut)\n" -#: pg_dump.c:939 pg_dumpall.c:588 +#: pg_dump.c:949 pg_dumpall.c:589 #, c-format msgid " --role=ROLENAME do SET ROLE before dump\n" msgstr " --role=NOMROLE exécute SET ROLE avant la sauvegarde\n" -#: pg_dump.c:941 +#: pg_dump.c:951 #, c-format msgid "" "\n" @@ -1954,241 +1836,241 @@ msgstr "" "d'environnement PGDATABASE est alors utilisée.\n" "\n" -#: pg_dump.c:943 pg_dumpall.c:592 pg_restore.c:493 +#: pg_dump.c:953 pg_dumpall.c:593 pg_restore.c:499 #, c-format msgid "Report bugs to .\n" msgstr "Rapporter les bogues à .\n" -#: pg_dump.c:960 +#: pg_dump.c:970 #, c-format msgid "invalid client encoding \"%s\" specified\n" msgstr "encodage client indiqué (« %s ») invalide\n" -#: pg_dump.c:1102 +#: pg_dump.c:1112 #, c-format msgid "" "Synchronized snapshots are not supported on standby servers.\n" "Run with --no-synchronized-snapshots instead if you do not need\n" "synchronized snapshots.\n" msgstr "" -"Les snapshots synchronisés ne sont pas supportés sur les serveurs de " -"stadby.\n" -"Lancez avec --no-synchronized-snapshots à la place si vous n'avez pas " -"besoin\n" +"Les snapshots synchronisés ne sont pas supportés sur les serveurs de stadby.\n" +"Lancez avec --no-synchronized-snapshots à la place si vous n'avez pas besoin\n" "de snapshots synchronisés.\n" -#: pg_dump.c:1171 +#: pg_dump.c:1181 #, c-format msgid "invalid output format \"%s\" specified\n" msgstr "format de sortie « %s » invalide\n" -#: pg_dump.c:1194 +#: pg_dump.c:1204 #, c-format msgid "server version must be at least 7.3 to use schema selection switches\n" msgstr "" -"le serveur doit être de version 7.3 ou supérieure pour utiliser les " -"options\n" +"le serveur doit être de version 7.3 ou supérieure pour utiliser les options\n" "de sélection du schéma\n" -#: pg_dump.c:1212 pg_dump.c:1265 +#: pg_dump.c:1222 +#, c-format +msgid "no matching schemas were found for pattern \"%s\"\n" +msgstr "aucun schéma correspondant n'a été trouvé avec le motif « %s »\n" + +#: pg_dump.c:1275 #, c-format msgid "no matching tables were found for pattern \"%s\"\n" msgstr "aucune table correspondante n'a été trouvée avec le motif « %s »\n" -#: pg_dump.c:1652 +#: pg_dump.c:1662 #, c-format msgid "dumping contents of table \"%s.%s\"\n" msgstr "sauvegarde du contenu de la table « %s.%s »\n" -#: pg_dump.c:1776 +#: pg_dump.c:1786 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.\n" msgstr "" "La sauvegarde du contenu de la table « %s » a échoué : échec de\n" "PQgetCopyData().\n" -#: pg_dump.c:1777 pg_dump.c:1787 +#: pg_dump.c:1787 pg_dump.c:1797 #, c-format msgid "Error message from server: %s" msgstr "Message d'erreur du serveur : %s" -#: pg_dump.c:1778 pg_dump.c:1788 +#: pg_dump.c:1788 pg_dump.c:1798 #, c-format msgid "The command was: %s\n" msgstr "La commande était : %s\n" -#: pg_dump.c:1786 +#: pg_dump.c:1796 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetResult() failed.\n" msgstr "" "La sauvegarde du contenu de la table « %s » a échoué : échec de\n" "PQgetResult().\n" -#: pg_dump.c:2435 +#: pg_dump.c:2445 #, c-format msgid "saving database definition\n" msgstr "sauvegarde de la définition de la base de données\n" -#: pg_dump.c:2769 +#: pg_dump.c:2779 #, c-format msgid "saving encoding = %s\n" msgstr "encodage de la sauvegarde = %s\n" -#: pg_dump.c:2796 +#: pg_dump.c:2806 #, c-format msgid "saving standard_conforming_strings = %s\n" msgstr "standard_conforming_strings de la sauvegarde = %s\n" -#: pg_dump.c:2836 +#: pg_dump.c:2846 #, c-format msgid "reading large objects\n" msgstr "lecture des « Large Objects »\n" -#: pg_dump.c:3023 +#: pg_dump.c:3033 #, c-format msgid "saving large objects\n" msgstr "sauvegarde des « Large Objects »\n" -#: pg_dump.c:3070 +#: pg_dump.c:3080 #, c-format msgid "error reading large object %u: %s" msgstr "erreur lors de la lecture du « Large Object » %u : %s" -#: pg_dump.c:3122 +#: pg_dump.c:3132 #, c-format msgid "reading row security enabled for table \"%s.%s\"\n" -msgstr "" -"lecture de l'activation de la sécurité niveau ligne pour la table « %s.%s " -"»\n" +msgstr "lecture de l'activation de la sécurité niveau ligne pour la table « %s.%s »\n" -#: pg_dump.c:3153 +#: pg_dump.c:3163 #, c-format msgid "reading policies for table \"%s.%s\"\n" msgstr "lecture des politiques pour la table « %s.%s »\n" -#: pg_dump.c:3286 +#: pg_dump.c:3296 #, c-format msgid "unexpected policy command type: \"%s\"\n" msgstr "type de commande inattendu pour la politique : « %s »\n" -#: pg_dump.c:3505 +#: pg_dump.c:3515 #, c-format msgid "could not find parent extension for %s\n" msgstr "n'a pas pu trouver l'extension parent pour %s\n" -#: pg_dump.c:3673 +#: pg_dump.c:3683 #, c-format msgid "WARNING: owner of schema \"%s\" appears to be invalid\n" msgstr "ATTENTION : le propriétaire du schéma « %s » semble être invalide\n" -#: pg_dump.c:3716 +#: pg_dump.c:3726 #, c-format msgid "schema with OID %u does not exist\n" msgstr "le schéma d'OID %u n'existe pas\n" -#: pg_dump.c:4131 +#: pg_dump.c:4141 #, c-format msgid "WARNING: owner of data type \"%s\" appears to be invalid\n" -msgstr "" -"ATTENTION : le propriétaire du type de données « %s » semble être invalide\n" +msgstr "ATTENTION : le propriétaire du type de données « %s » semble être invalide\n" -#: pg_dump.c:4245 +#: pg_dump.c:4255 #, c-format msgid "WARNING: owner of operator \"%s\" appears to be invalid\n" -msgstr "" -"ATTENTION : le propriétaire de l'opérateur « %s » semble être invalide\n" +msgstr "ATTENTION : le propriétaire de l'opérateur « %s » semble être invalide\n" -#: pg_dump.c:4590 +#: pg_dump.c:4600 #, c-format msgid "WARNING: owner of operator class \"%s\" appears to be invalid\n" msgstr "" "ATTENTION : le propriétaire de la classe d'opérateur « %s » semble être\n" "invalide\n" -#: pg_dump.c:4681 +#: pg_dump.c:4691 #, c-format msgid "WARNING: owner of operator family \"%s\" appears to be invalid\n" msgstr "" "ATTENTION : le propriétaire de la famille d'opérateur « %s » semble être\n" "invalide\n" -#: pg_dump.c:4882 +#: pg_dump.c:4892 #, c-format msgid "WARNING: owner of aggregate function \"%s\" appears to be invalid\n" msgstr "" "ATTENTION : le propriétaire de la fonction d'aggrégat « %s » semble être\n" "invalide\n" -#: pg_dump.c:5154 +#: pg_dump.c:5189 #, c-format msgid "WARNING: owner of function \"%s\" appears to be invalid\n" -msgstr "" -"ATTENTION : le propriétaire de la fonction « %s » semble être invalide\n" +msgstr "ATTENTION : le propriétaire de la fonction « %s » semble être invalide\n" -#: pg_dump.c:6016 +#: pg_dump.c:6051 #, c-format msgid "WARNING: owner of table \"%s\" appears to be invalid\n" msgstr "ATTENTION : le propriétaire de la table « %s » semble être invalide\n" -#: pg_dump.c:6182 +#: pg_dump.c:6093 pg_dump.c:16593 +#, c-format +msgid "failed sanity check, parent table OID %u of sequence OID %u not found\n" +msgstr "vérification échouée, OID %u de la table parent de l'OID %u de la séquence introuvable\n" + +#: pg_dump.c:6220 #, c-format msgid "reading indexes for table \"%s.%s\"\n" msgstr "lecture des index de la table « %s.%s »\n" -#: pg_dump.c:6550 +#: pg_dump.c:6588 #, c-format msgid "reading foreign key constraints for table \"%s.%s\"\n" msgstr "lecture des contraintes de clés étrangères pour la table « %s.%s »\n" -#: pg_dump.c:6796 +#: pg_dump.c:6834 #, c-format -msgid "" -"failed sanity check, parent table OID %u of pg_rewrite entry OID %u not " -"found\n" +msgid "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not found\n" msgstr "" "vérification échouée, OID %u de la table parent de l'OID %u de l'entrée de\n" "pg_rewrite introuvable\n" -#: pg_dump.c:6890 +#: pg_dump.c:6928 #, c-format msgid "reading triggers for table \"%s.%s\"\n" msgstr "lecture des triggers pour la table « %s.%s »\n" -#: pg_dump.c:7055 +#: pg_dump.c:7093 #, c-format msgid "" -"query produced null referenced table name for foreign key trigger \"%s\" on " -"table \"%s\" (OID of table: %u)\n" +"query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of " +"table: %u)\n" msgstr "" "la requête a produit une réference de nom de table null pour le trigger de\n" "clé étrangère « %s » sur la table « %s » (OID de la table : %u)\n" -#: pg_dump.c:7710 +#: pg_dump.c:7748 #, c-format msgid "finding the columns and types of table \"%s.%s\"\n" msgstr "recherche des colonnes et types de la table « %s.%s »\n" -#: pg_dump.c:7889 +#: pg_dump.c:7927 #, c-format msgid "invalid column numbering in table \"%s\"\n" msgstr "numérotation des colonnes invalide pour la table « %s »\n" -#: pg_dump.c:7923 +#: pg_dump.c:7961 #, c-format msgid "finding default expressions of table \"%s.%s\"\n" msgstr "recherche des expressions par défaut de la table « %s.%s »\n" -#: pg_dump.c:7976 +#: pg_dump.c:8014 #, c-format msgid "invalid adnum value %d for table \"%s\"\n" msgstr "valeur adnum %d invalide pour la table « %s »\n" -#: pg_dump.c:8048 +#: pg_dump.c:8086 #, c-format msgid "finding check constraints for table \"%s.%s\"\n" msgstr "recherche des contraintes de vérification pour la table « %s.%s »\n" -#: pg_dump.c:8144 +#: pg_dump.c:8182 #, c-format msgid "expected %d check constraint on table \"%s\" but found %d\n" msgid_plural "expected %d check constraints on table \"%s\" but found %d\n" @@ -2199,215 +2081,200 @@ msgstr[1] "" "%d contraintes de vérification attendues pour la table « %s » mais %d\n" "trouvées\n" -#: pg_dump.c:8148 +#: pg_dump.c:8186 #, c-format msgid "(The system catalogs might be corrupted.)\n" msgstr "(Les catalogues système sont peut-être corrompus.)\n" -#: pg_dump.c:9680 +#: pg_dump.c:9764 #, c-format msgid "WARNING: typtype of data type \"%s\" appears to be invalid\n" -msgstr "" -"ATTENTION : la colonne typtype du type de données « %s » semble être " -"invalide\n" +msgstr "ATTENTION : la colonne typtype du type de données « %s » semble être invalide\n" -#: pg_dump.c:11222 +#: pg_dump.c:11306 #, c-format msgid "WARNING: bogus value in proargmodes array\n" msgstr "ATTENTION : valeur erronée dans le tableau proargmodes\n" -#: pg_dump.c:11600 +#: pg_dump.c:11684 #, c-format msgid "WARNING: could not parse proallargtypes array\n" msgstr "ATTENTION : n'a pas pu analyser le tableau proallargtypes\n" -#: pg_dump.c:11616 +#: pg_dump.c:11700 #, c-format msgid "WARNING: could not parse proargmodes array\n" msgstr "ATTENTION : n'a pas pu analyser le tableau proargmodes\n" -#: pg_dump.c:11630 +#: pg_dump.c:11714 #, c-format msgid "WARNING: could not parse proargnames array\n" msgstr "ATTENTION : n'a pas pu analyser le tableau proargnames\n" -#: pg_dump.c:11641 +#: pg_dump.c:11725 #, c-format msgid "WARNING: could not parse proconfig array\n" msgstr "ATTENTION : n'a pas pu analyser le tableau proconfig\n" -#: pg_dump.c:11712 +#: pg_dump.c:11796 #, c-format msgid "unrecognized provolatile value for function \"%s\"\n" msgstr "valeur provolatile non reconnue pour la fonction « %s »\n" -#: pg_dump.c:11756 pg_dump.c:13802 +#: pg_dump.c:11840 pg_dump.c:13889 #, c-format msgid "unrecognized proparallel value for function \"%s\"\n" msgstr "valeur proparallel non reconnue pour la fonction « %s »\n" -#: pg_dump.c:11908 +#: pg_dump.c:11948 pg_dump.c:12058 pg_dump.c:12065 +#, c-format +msgid "could not find function definition for function with OID %u\n" +msgstr "n'a pas pu trouver la définition de la fonction d'OID %u\n" + +#: pg_dump.c:11993 #, c-format msgid "WARNING: bogus value in pg_cast.castfunc or pg_cast.castmethod field\n" -msgstr "" -"ATTENTION : valeur erronée dans le champ pg_cast.castfunc ou pg_cast." -"castmethod\n" +msgstr "ATTENTION : valeur erronée dans le champ pg_cast.castfunc ou pg_cast.castmethod\n" -#: pg_dump.c:11911 +#: pg_dump.c:11996 #, c-format msgid "WARNING: bogus value in pg_cast.castmethod field\n" msgstr "ATTENTION : valeur erronée dans pg_cast.castmethod\n" -#: pg_dump.c:11999 +#: pg_dump.c:12086 #, c-format msgid "" -"WARNING: bogus transform definition, at least one of trffromsql and " -"trftosql should be nonzero\n" +"WARNING: bogus transform definition, at least one of trffromsql and trftosql should be nonzero\n" msgstr "" -"ATTENTION : définition de transformation invalide, au moins un de " -"trffromsql et trftosql ne doit pas valoir 0\n" +"ATTENTION : définition de transformation invalide, au moins un de trffromsql et trftosql ne doit " +"pas valoir 0\n" -#: pg_dump.c:12016 +#: pg_dump.c:12103 #, c-format msgid "WARNING: bogus value in pg_transform.trffromsql field\n" msgstr "ATTENTION : valeur erronée dans pg_transform.trffromsql\n" -#: pg_dump.c:12037 +#: pg_dump.c:12124 #, c-format msgid "WARNING: bogus value in pg_transform.trftosql field\n" msgstr "ATTENTION : valeur erronée dans pg_transform.trftosql\n" -#: pg_dump.c:12428 +#: pg_dump.c:12515 #, c-format msgid "WARNING: could not find operator with OID %s\n" msgstr "ATTENTION : n'a pas pu trouver l'opérateur d'OID %s\n" -#: pg_dump.c:12492 +#: pg_dump.c:12579 #, c-format msgid "WARNING: invalid type \"%c\" of access method \"%s\"\n" msgstr "ATTENTION : type « %c » invalide de la méthode d'accès « %s »\n" -#: pg_dump.c:13693 +#: pg_dump.c:13780 #, c-format msgid "" -"WARNING: aggregate function %s could not be dumped correctly for this " -"database version; ignored\n" +"WARNING: aggregate function %s could not be dumped correctly for this database version; ignored\n" msgstr "" "ATTENTION : la fonction d'aggrégat %s n'a pas pu être sauvegardée\n" " correctement avec cette version de la base de données ; ignorée\n" -#: pg_dump.c:14565 +#: pg_dump.c:14652 #, c-format msgid "unrecognized object type in default privileges: %d\n" msgstr "type d'objet inconnu dans les droits par défaut : %d\n" -#: pg_dump.c:14580 +#: pg_dump.c:14670 #, c-format msgid "could not parse default ACL list (%s)\n" msgstr "n'a pas pu analyser la liste ACL par défaut (%s)\n" -#: pg_dump.c:14651 +#: pg_dump.c:14741 #, c-format msgid "" -"could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) " -"for object \"%s\" (%s)\n" +"could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) for object \"%s\" (%s)\n" msgstr "" -"n'a pas pu analyser la liste GRANT ACL initiale (%s) ou la liste REVOKE ACL " -"initiale (%s) de l'objet « %s » (%s)\n" +"n'a pas pu analyser la liste GRANT ACL initiale (%s) ou la liste REVOKE ACL initiale (%s) de " +"l'objet « %s » (%s)\n" -#: pg_dump.c:14659 +#: pg_dump.c:14749 #, c-format -msgid "" -"could not parse GRANT ACL list (%s) or REVOKE ACL list (%s) for object \"%s" -"\" (%s)\n" -msgstr "" -"n'a pas pu analyser la liste GRANT ACL (%s) ou REVOKE ACL (%s) de l'objet « " -"%s » (%s)\n" +msgid "could not parse GRANT ACL list (%s) or REVOKE ACL list (%s) for object \"%s\" (%s)\n" +msgstr "n'a pas pu analyser la liste GRANT ACL (%s) ou REVOKE ACL (%s) de l'objet « %s » (%s)\n" -#: pg_dump.c:15143 +#: pg_dump.c:15233 #, c-format msgid "query to obtain definition of view \"%s\" returned no data\n" msgstr "" "la requête permettant d'obtenir la définition de la vue « %s » n'a renvoyé\n" "aucune donnée\n" -#: pg_dump.c:15146 +#: pg_dump.c:15236 #, c-format -msgid "" -"query to obtain definition of view \"%s\" returned more than one " -"definition\n" +msgid "query to obtain definition of view \"%s\" returned more than one definition\n" msgstr "" "la requête permettant d'obtenir la définition de la vue « %s » a renvoyé\n" " plusieurs définitions\n" -#: pg_dump.c:15153 +#: pg_dump.c:15243 #, c-format msgid "definition of view \"%s\" appears to be empty (length zero)\n" msgstr "la définition de la vue « %s » semble être vide (longueur nulle)\n" -#: pg_dump.c:15912 +#: pg_dump.c:16002 #, c-format msgid "invalid column number %d for table \"%s\"\n" msgstr "numéro de colonne %d invalide pour la table « %s »\n" -#: pg_dump.c:16041 +#: pg_dump.c:16131 #, c-format msgid "missing index for constraint \"%s\"\n" msgstr "index manquant pour la contrainte « %s »\n" -#: pg_dump.c:16244 +#: pg_dump.c:16334 #, c-format msgid "unrecognized constraint type: %c\n" msgstr "type de contrainte inconnu : %c\n" -#: pg_dump.c:16398 pg_dump.c:16567 +#: pg_dump.c:16488 pg_dump.c:16661 #, c-format msgid "query to get data of sequence \"%s\" returned %d row (expected 1)\n" -msgid_plural "" -"query to get data of sequence \"%s\" returned %d rows (expected 1)\n" +msgid_plural "query to get data of sequence \"%s\" returned %d rows (expected 1)\n" msgstr[0] "" -"la requête permettant d'obtenir les données de la séquence « %s » a " -"renvoyé\n" +"la requête permettant d'obtenir les données de la séquence « %s » a renvoyé\n" "%d ligne (une seule attendue)\n" msgstr[1] "" -"la requête permettant d'obtenir les données de la séquence « %s » a " -"renvoyé\n" +"la requête permettant d'obtenir les données de la séquence « %s » a renvoyé\n" "%d lignes (une seule attendue)\n" -#: pg_dump.c:16409 +#: pg_dump.c:16499 #, c-format msgid "query to get data of sequence \"%s\" returned name \"%s\"\n" msgstr "" -"la requête permettant d'obtenir les données de la séquence « %s » a " -"renvoyé\n" +"la requête permettant d'obtenir les données de la séquence « %s » a renvoyé\n" "le nom « %s »\n" -#: pg_dump.c:16665 +#: pg_dump.c:16759 #, c-format msgid "unexpected tgtype value: %d\n" msgstr "valeur tgtype inattendue : %d\n" -#: pg_dump.c:16747 +#: pg_dump.c:16841 #, c-format msgid "invalid argument string (%s) for trigger \"%s\" on table \"%s\"\n" -msgstr "" -"chaîne argument invalide (%s) pour le trigger « %s » sur la table « %s »\n" +msgstr "chaîne argument invalide (%s) pour le trigger « %s » sur la table « %s »\n" -#: pg_dump.c:16944 +#: pg_dump.c:17038 #, c-format -msgid "" -"query to get rule \"%s\" for table \"%s\" failed: wrong number of rows " -"returned\n" +msgid "query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned\n" msgstr "" "la requête permettant d'obtenir la règle « %s » associée à la table « %s »\n" "a échoué : mauvais nombre de lignes renvoyées\n" -#: pg_dump.c:17333 +#: pg_dump.c:17427 #, c-format msgid "reading dependency data\n" msgstr "lecture des données de dépendance\n" -#: pg_dump.c:17890 +#: pg_dump.c:17984 #, c-format msgid "WARNING: could not parse reloptions array\n" msgstr "ATTENTION : n'a pas pu analyser le tableau reloptions\n" @@ -2435,14 +2302,9 @@ msgstr "n'a pas pu identifier la boucle de dépendance\n" #: pg_dump_sort.c:1262 #, c-format msgid "NOTICE: there are circular foreign-key constraints on this table:\n" -msgid_plural "" -"NOTICE: there are circular foreign-key constraints among these tables:\n" -msgstr[0] "" -"NOTE : il existe des constraintes de clés étrangères circulaires sur cette " -"table :\n" -msgstr[1] "" -"NOTE : il existe des constraintes de clés étrangères circulaires sur ces " -"tables :\n" +msgid_plural "NOTICE: there are circular foreign-key constraints among these tables:\n" +msgstr[0] "NOTE : il existe des constraintes de clés étrangères circulaires sur cette table :\n" +msgstr[1] "NOTE : il existe des constraintes de clés étrangères circulaires sur ces tables :\n" #: pg_dump_sort.c:1266 pg_dump_sort.c:1286 #, c-format @@ -2452,8 +2314,8 @@ msgstr " %s\n" #: pg_dump_sort.c:1267 #, c-format msgid "" -"You might not be able to restore the dump without using --disable-triggers " -"or temporarily dropping the constraints.\n" +"You might not be able to restore the dump without using --disable-triggers or temporarily dropping " +"the constraints.\n" msgstr "" "Il est possible que vous ne puissiez pas restaurer la sauvegarde sans\n" "utiliser --disable-triggers ou sans supprimer temporairement les\n" @@ -2461,20 +2323,15 @@ msgstr "" #: pg_dump_sort.c:1268 #, c-format -msgid "" -"Consider using a full dump instead of a --data-only dump to avoid this " -"problem.\n" +msgid "Consider using a full dump instead of a --data-only dump to avoid this problem.\n" msgstr "" -"Considérez l'utilisation d'une sauvegarde complète au lieu d'une " -"sauvegarde\n" +"Considérez l'utilisation d'une sauvegarde complète au lieu d'une sauvegarde\n" "des données seulement pour éviter ce problème.\n" #: pg_dump_sort.c:1280 #, c-format msgid "WARNING: could not resolve dependency loop among these items:\n" -msgstr "" -"ATTENTION : n'a pas pu résoudre la boucle de dépendances parmi ces " -"éléments :\n" +msgstr "ATTENTION : n'a pas pu résoudre la boucle de dépendances parmi ces éléments :\n" #: pg_dumpall.c:180 #, c-format @@ -2483,8 +2340,7 @@ msgid "" "same directory as \"%s\".\n" "Check your installation.\n" msgstr "" -"Le programme « pg_dump » est nécessaire à %s mais n'a pas été trouvé dans " -"le\n" +"Le programme « pg_dump » est nécessaire à %s mais n'a pas été trouvé dans le\n" "même répertoire que « %s ».\n" "Vérifiez votre installation.\n" @@ -2501,38 +2357,31 @@ msgstr "" #: pg_dumpall.c:317 #, c-format -msgid "" -"%s: options -g/--globals-only and -r/--roles-only cannot be used together\n" +msgid "%s: options -g/--globals-only and -r/--roles-only cannot be used together\n" msgstr "" -"%s : les options « -g/--globals-only » et « -r/--roles-only » ne peuvent " -"pas\n" +"%s : les options « -g/--globals-only » et « -r/--roles-only » ne peuvent pas\n" "être utilisées conjointement\n" #: pg_dumpall.c:326 #, c-format -msgid "" -"%s: options -g/--globals-only and -t/--tablespaces-only cannot be used " -"together\n" +msgid "%s: options -g/--globals-only and -t/--tablespaces-only cannot be used together\n" msgstr "" "%s : les options « -g/--globals-only » et « -t/--tablespaces-only » ne\n" "peuvent pas être utilisées conjointement\n" -#: pg_dumpall.c:335 pg_restore.c:345 +#: pg_dumpall.c:335 pg_restore.c:361 #, c-format msgid "%s: option --if-exists requires option -c/--clean\n" msgstr "%s : l'option --if-exists nécessite l'option -c/--clean\n" #: pg_dumpall.c:342 #, c-format -msgid "" -"%s: options -r/--roles-only and -t/--tablespaces-only cannot be used " -"together\n" +msgid "%s: options -r/--roles-only and -t/--tablespaces-only cannot be used together\n" msgstr "" -"%s : les options « -r/--roles-only » et « -t/--tablespaces-only » ne " -"peuvent\n" +"%s : les options « -r/--roles-only » et « -t/--tablespaces-only » ne peuvent\n" "pas être utilisées conjointement\n" -#: pg_dumpall.c:384 pg_dumpall.c:1994 +#: pg_dumpall.c:384 pg_dumpall.c:1995 #, c-format msgid "%s: could not connect to database \"%s\"\n" msgstr "%s : n'a pas pu se connecter à la base de données « %s »\n" @@ -2571,78 +2420,63 @@ msgstr " %s [OPTION]...\n" msgid " -f, --file=FILENAME output file name\n" msgstr " -f, --file=NOMFICHIER nom du fichier de sortie\n" -#: pg_dumpall.c:557 +#: pg_dumpall.c:558 #, c-format -msgid "" -" -c, --clean clean (drop) databases before recreating\n" +msgid " -c, --clean clean (drop) databases before recreating\n" msgstr "" -" -c, --clean nettoie (supprime) les bases de données " -"avant de\n" +" -c, --clean nettoie (supprime) les bases de données avant de\n" " les créer\n" -#: pg_dumpall.c:558 +#: pg_dumpall.c:559 #, c-format -msgid "" -" -g, --globals-only dump only global objects, no databases\n" +msgid " -g, --globals-only dump only global objects, no databases\n" msgstr "" -" -g, --globals-only sauvegarde uniquement les objets système, " -"pas\n" +" -g, --globals-only sauvegarde uniquement les objets système, pas\n" " le contenu des bases de données\n" -#: pg_dumpall.c:560 pg_restore.c:459 +#: pg_dumpall.c:561 pg_restore.c:465 #, c-format msgid " -O, --no-owner skip restoration of object ownership\n" msgstr "" " -O, --no-owner omet la restauration des propriétaires des\n" " objets\n" -#: pg_dumpall.c:561 +#: pg_dumpall.c:562 #, c-format -msgid "" -" -r, --roles-only dump only roles, no databases or " -"tablespaces\n" +msgid " -r, --roles-only dump only roles, no databases or tablespaces\n" msgstr "" -" -r, --roles-only sauvegarde uniquement les rôles, pas les " -"bases\n" +" -r, --roles-only sauvegarde uniquement les rôles, pas les bases\n" " de données ni les tablespaces\n" -#: pg_dumpall.c:563 +#: pg_dumpall.c:564 #, c-format -msgid "" -" -S, --superuser=NAME superuser user name to use in the dump\n" +msgid " -S, --superuser=NAME superuser user name to use in the dump\n" msgstr "" -" -S, --superuser=NOM indique le nom du super-utilisateur à " -"utiliser\n" +" -S, --superuser=NOM indique le nom du super-utilisateur à utiliser\n" " avec le format texte\n" -#: pg_dumpall.c:564 +#: pg_dumpall.c:565 #, c-format -msgid "" -" -t, --tablespaces-only dump only tablespaces, no databases or " -"roles\n" +msgid " -t, --tablespaces-only dump only tablespaces, no databases or roles\n" msgstr "" -" -t, --tablespaces-only sauvegarde uniquement les tablespaces, pas " -"les\n" +" -t, --tablespaces-only sauvegarde uniquement les tablespaces, pas les\n" " bases de données ni les rôles\n" -#: pg_dumpall.c:581 +#: pg_dumpall.c:582 #, c-format msgid " -d, --dbname=CONNSTR connect using connection string\n" -msgstr "" -" -d, --dbname=CHAINE_CONN connexion à l'aide de la chaîne de " -"connexion\n" +msgstr " -d, --dbname=CHAINE_CONN connexion à l'aide de la chaîne de connexion\n" -#: pg_dumpall.c:583 +#: pg_dumpall.c:584 #, c-format msgid " -l, --database=DBNAME alternative default database\n" msgstr " -l, --database=NOM_BASE indique une autre base par défaut\n" -#: pg_dumpall.c:590 +#: pg_dumpall.c:591 #, c-format msgid "" "\n" -"If -f/--file is not used, then the SQL script will be written to the " -"standard\n" +"If -f/--file is not used, then the SQL script will be written to the standard\n" "output.\n" "\n" msgstr "" @@ -2651,70 +2485,67 @@ msgstr "" "standard.\n" "\n" -#: pg_dumpall.c:791 +#: pg_dumpall.c:792 #, c-format msgid "%s: role name starting with \"pg_\" skipped (%s)\n" msgstr "%s : nom de rôle commençant par « pg_ » ignoré (« %s »)\n" -#: pg_dumpall.c:1168 +#: pg_dumpall.c:1169 #, c-format msgid "%s: could not parse ACL list (%s) for tablespace \"%s\"\n" -msgstr "" -"%s : n'a pas pu analyser la liste d'ACL (%s) pour le tablespace « %s »\n" +msgstr "%s : n'a pas pu analyser la liste d'ACL (%s) pour le tablespace « %s »\n" -#: pg_dumpall.c:1536 +#: pg_dumpall.c:1537 #, c-format msgid "%s: could not parse ACL list (%s) for database \"%s\"\n" -msgstr "" -"%s : n'a pas pu analyser la liste d'ACL (%s) pour la base de données « %s " -"»\n" +msgstr "%s : n'a pas pu analyser la liste d'ACL (%s) pour la base de données « %s »\n" -#: pg_dumpall.c:1754 +#: pg_dumpall.c:1755 #, c-format msgid "%s: dumping database \"%s\"...\n" msgstr "%s : sauvegarde de la base de données « %s »...\n" -#: pg_dumpall.c:1778 +#: pg_dumpall.c:1779 #, c-format msgid "%s: pg_dump failed on database \"%s\", exiting\n" msgstr "%s : échec de pg_dump sur la base de données « %s », quitte\n" -#: pg_dumpall.c:1787 +#: pg_dumpall.c:1788 #, c-format msgid "%s: could not re-open the output file \"%s\": %s\n" msgstr "%s : n'a pas pu rouvrir le fichier de sortie « %s » : %s\n" -#: pg_dumpall.c:1832 +#: pg_dumpall.c:1833 #, c-format msgid "%s: running \"%s\"\n" msgstr "%s : exécute « %s »\n" -#: pg_dumpall.c:2016 +#: pg_dumpall.c:2017 #, c-format msgid "%s: could not connect to database \"%s\": %s\n" msgstr "%s : n'a pas pu se connecter à la base de données « %s » : %s\n" -#: pg_dumpall.c:2046 +#: pg_dumpall.c:2047 #, c-format msgid "%s: could not get server version\n" msgstr "%s : n'a pas pu obtenir la version du serveur\n" -#: pg_dumpall.c:2052 +#: pg_dumpall.c:2053 #, c-format msgid "%s: could not parse server version \"%s\"\n" msgstr "%s : n'a pas pu analyser la version du serveur « %s »\n" -#: pg_dumpall.c:2130 pg_dumpall.c:2156 +#: pg_dumpall.c:2131 pg_dumpall.c:2157 #, c-format msgid "%s: executing %s\n" msgstr "%s : exécute %s\n" -#: pg_dumpall.c:2136 pg_dumpall.c:2162 +#: pg_dumpall.c:2137 pg_dumpall.c:2163 #, c-format msgid "%s: query failed: %s" msgstr "%s : échec de la requête : %s" -#: pg_dumpall.c:2138 pg_dumpall.c:2164 +#: pg_dumpall.c:2139 pg_dumpall.c:2165 #, c-format msgid "%s: query was: %s\n" msgstr "%s : la requête était : %s\n" @@ -2728,11 +2559,9 @@ msgstr "" #: pg_restore.c:316 #, c-format -msgid "" -"%s: options -s/--schema-only and -a/--data-only cannot be used together\n" +msgid "%s: options -s/--schema-only and -a/--data-only cannot be used together\n" msgstr "" -"%s : les options « -s/--schema-only » et « -a/--data-only » ne peuvent pas " -"être\n" +"%s : les options « -s/--schema-only » et « -a/--data-only » ne peuvent pas être\n" "utilisées conjointement\n" #: pg_restore.c:323 @@ -2742,90 +2571,88 @@ msgstr "" "%s : les options « -c/--clean » et « -a/--data-only » ne peuvent pas être\n" "utilisées conjointement\n" -#: pg_restore.c:331 +#: pg_restore.c:330 +#, c-format +msgid "%s: invalid number of parallel jobs\n" +msgstr "%s : nombre de jobs en parallèle invalide\n" + +#: pg_restore.c:338 +#, c-format +msgid "%s: maximum number of parallel jobs is %d\n" +msgstr "%s: le nombre maximum de jobs en parallèle est %d\n" + +#: pg_restore.c:347 #, c-format msgid "%s: cannot specify both --single-transaction and multiple jobs\n" msgstr "" "%s : les options --single-transaction et -j ne peuvent pas être indiquées\n" "simultanément\n" -#: pg_restore.c:372 +#: pg_restore.c:388 #, c-format -msgid "" -"unrecognized archive format \"%s\"; please specify \"c\", \"d\", or \"t\"\n" -msgstr "" -"format d'archive « %s » non reconnu ; merci d'indiquer « c », « d » ou « t " -"»\n" +msgid "unrecognized archive format \"%s\"; please specify \"c\", \"d\", or \"t\"\n" +msgstr "format d'archive « %s » non reconnu ; merci d'indiquer « c », « d » ou « t »\n" -#: pg_restore.c:404 -#, c-format -msgid "%s: maximum number of parallel jobs is %d\n" -msgstr "%s: le nombre maximum de jobs en parallèle est %d\n" - -#: pg_restore.c:422 +#: pg_restore.c:428 #, c-format msgid "WARNING: errors ignored on restore: %d\n" msgstr "ATTENTION : erreurs ignorées lors de la restauration : %d\n" -#: pg_restore.c:436 +#: pg_restore.c:442 #, c-format msgid "" "%s restores a PostgreSQL database from an archive created by pg_dump.\n" "\n" msgstr "" -"%s restaure une base de données PostgreSQL à partir d'une archive créée " -"par\n" +"%s restaure une base de données PostgreSQL à partir d'une archive créée par\n" "pg_dump.\n" "\n" -#: pg_restore.c:438 +#: pg_restore.c:444 #, c-format msgid " %s [OPTION]... [FILE]\n" msgstr " %s [OPTION]... [FICHIER]\n" -#: pg_restore.c:441 +#: pg_restore.c:447 #, c-format msgid " -d, --dbname=NAME connect to database name\n" msgstr "" " -d, --dbname=NOM nom de la base de données utilisée pour la\n" " connexion\n" -#: pg_restore.c:442 +#: pg_restore.c:448 #, c-format msgid " -f, --file=FILENAME output file name\n" msgstr " -f, --file=NOMFICHIER nom du fichier de sortie\n" -#: pg_restore.c:443 +#: pg_restore.c:449 #, c-format msgid " -F, --format=c|d|t backup file format (should be automatic)\n" msgstr "" -" -F, --format=c|d|t format du fichier de sauvegarde (devrait " -"être\n" +" -F, --format=c|d|t format du fichier de sauvegarde (devrait être\n" " automatique)\n" -#: pg_restore.c:444 +#: pg_restore.c:450 #, c-format msgid " -l, --list print summarized TOC of the archive\n" -msgstr "" -" -l, --list affiche la table des matières de l'archive " -"(TOC)\n" +msgstr " -l, --list affiche la table des matières de l'archive (TOC)\n" -#: pg_restore.c:445 +#: pg_restore.c:451 #, c-format msgid " -v, --verbose verbose mode\n" msgstr " -v, --verbose mode verbeux\n" -#: pg_restore.c:446 +#: pg_restore.c:452 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version affiche la version puis quitte\n" -#: pg_restore.c:447 +#: pg_restore.c:453 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help affiche cette aide puis quitte\n" -#: pg_restore.c:449 +#: pg_restore.c:455 #, c-format msgid "" "\n" @@ -2834,38 +2661,36 @@ msgstr "" "\n" "Options contrôlant la restauration :\n" -#: pg_restore.c:450 +#: pg_restore.c:456 #, c-format msgid " -a, --data-only restore only the data, no schema\n" msgstr "" " -a, --data-only restaure uniquement les données, pas la\n" " structure\n" -#: pg_restore.c:452 +#: pg_restore.c:458 #, c-format msgid " -C, --create create the target database\n" msgstr " -C, --create crée la base de données cible\n" -#: pg_restore.c:453 +#: pg_restore.c:459 #, c-format msgid " -e, --exit-on-error exit on error, default is to continue\n" -msgstr "" -" -e, --exit-on-error quitte en cas d'erreur, continue par défaut\n" +msgstr " -e, --exit-on-error quitte en cas d'erreur, continue par défaut\n" -#: pg_restore.c:454 +#: pg_restore.c:460 #, c-format msgid " -I, --index=NAME restore named index\n" msgstr " -I, --index=NOM restaure l'index indiqué\n" -#: pg_restore.c:455 +#: pg_restore.c:461 #, c-format -msgid "" -" -j, --jobs=NUM use this many parallel jobs to restore\n" +msgid " -j, --jobs=NUM use this many parallel jobs to restore\n" msgstr "" " -j, --jobs=NUMERO utilise ce nombre de jobs en parallèle pour\n" " la restauration\n" -#: pg_restore.c:456 +#: pg_restore.c:462 #, c-format msgid "" " -L, --use-list=FILENAME use table of contents from this file for\n" @@ -2875,119 +2700,102 @@ msgstr "" " de ce fichier pour sélectionner/trier\n" " la sortie\n" -#: pg_restore.c:458 +#: pg_restore.c:464 #, c-format msgid " -n, --schema=NAME restore only objects in this schema\n" -msgstr "" -" -n, --schema=NOM restaure uniquement les objets de ce schéma\n" +msgstr " -n, --schema=NOM restaure uniquement les objets de ce schéma\n" -#: pg_restore.c:460 +#: pg_restore.c:466 #, c-format msgid " -P, --function=NAME(args) restore named function\n" msgstr " -P, --function=NOM(args) restaure la fonction indiquée\n" -#: pg_restore.c:461 +#: pg_restore.c:467 #, c-format msgid " -s, --schema-only restore only the schema, no data\n" msgstr "" " -s, --schema-only restaure uniquement la structure, pas les\n" " données\n" -#: pg_restore.c:462 +#: pg_restore.c:468 #, c-format -msgid "" -" -S, --superuser=NAME superuser user name to use for disabling " -"triggers\n" +msgid " -S, --superuser=NAME superuser user name to use for disabling triggers\n" msgstr "" " -S, --superuser=NOM indique le nom du super-utilisateur à\n" " utiliser pour désactiver les triggers\n" -#: pg_restore.c:463 +#: pg_restore.c:469 #, c-format -msgid "" -" -t, --table=NAME restore named relation (table, view, etc.)\n" -msgstr "" -" -t, --table=NOM restaure la relation indiquée (table, vue, " -"etc)\n" +msgid " -t, --table=NAME restore named relation (table, view, etc.)\n" +msgstr " -t, --table=NOM restaure la relation indiquée (table, vue, etc)\n" -#: pg_restore.c:464 +#: pg_restore.c:470 #, c-format msgid " -T, --trigger=NAME restore named trigger\n" msgstr " -T, --trigger=NOM restaure le trigger indiqué\n" -#: pg_restore.c:465 +#: pg_restore.c:471 #, c-format -msgid "" -" -x, --no-privileges skip restoration of access privileges (grant/" -"revoke)\n" +msgid " -x, --no-privileges skip restoration of access privileges (grant/revoke)\n" msgstr "" -" -x, --no-privileges omet la restauration des droits sur les " -"objets\n" +" -x, --no-privileges omet la restauration des droits sur les objets\n" " (grant/revoke)\n" -#: pg_restore.c:466 +#: pg_restore.c:472 #, c-format msgid " -1, --single-transaction restore as a single transaction\n" msgstr " -1, --single-transaction restaure dans une seule transaction\n" -#: pg_restore.c:468 +#: pg_restore.c:474 #, c-format msgid " --enable-row-security enable row security\n" msgstr " --enable-row-security active la sécurité niveau ligne\n" -#: pg_restore.c:470 +#: pg_restore.c:476 #, c-format msgid "" -" --no-data-for-failed-tables do not restore data of tables that could not " -"be\n" +" --no-data-for-failed-tables do not restore data of tables that could not be\n" " created\n" msgstr "" " --no-data-for-failed-tables ne restaure pas les données des tables qui\n" " n'ont pas pu être créées\n" -#: pg_restore.c:472 +#: pg_restore.c:478 #, c-format msgid " --no-security-labels do not restore security labels\n" -msgstr "" -" --no-security-labels ne restaure pas les labels de sécurité\n" +msgstr " --no-security-labels ne restaure pas les labels de sécurité\n" -#: pg_restore.c:473 +#: pg_restore.c:479 #, c-format msgid " --no-tablespaces do not restore tablespace assignments\n" msgstr "" " --no-tablespaces ne restaure pas les affectations de\n" " tablespaces\n" -#: pg_restore.c:474 +#: pg_restore.c:480 #, c-format -msgid "" -" --section=SECTION restore named section (pre-data, data, or " -"post-data)\n" +msgid " --section=SECTION restore named section (pre-data, data, or post-data)\n" msgstr "" -" --section=SECTION restaure la section indiquée (pre-data, " -"data\n" +" --section=SECTION restaure la section indiquée (pre-data, data\n" " ou post-data)\n" -#: pg_restore.c:487 +#: pg_restore.c:493 #, c-format msgid " --role=ROLENAME do SET ROLE before restore\n" -msgstr "" -" --role=NOMROLE exécute SET ROLE avant la restauration\n" +msgstr " --role=NOMROLE exécute SET ROLE avant la restauration\n" -#: pg_restore.c:489 +#: pg_restore.c:495 #, c-format msgid "" "\n" -"The options -I, -n, -P, -t, -T, and --section can be combined and " -"specified\n" +"The options -I, -n, -P, -t, -T, and --section can be combined and specified\n" "multiple times to select multiple objects.\n" msgstr "" "\n" -"Les options -I, -n, -P, -t, -T et --section peuvent être combinées et " -"indiquées\n" +"Les options -I, -n, -P, -t, -T et --section peuvent être combinées et indiquées\n" "plusieurs fois pour sélectionner plusieurs objets.\n" -#: pg_restore.c:492 +#: pg_restore.c:498 #, c-format msgid "" "\n" @@ -2995,116 +2803,139 @@ msgid "" "\n" msgstr "" "\n" -"Si aucun nom de fichier n'est fourni en entrée, alors l'entrée standard " -"est\n" +"Si aucun nom de fichier n'est fourni en entrée, alors l'entrée standard est\n" "utilisée.\n" "\n" -#~ msgid "worker is terminating\n" -#~ msgstr "le worker est en cours d'arrêt\n" - -#~ msgid "could not get relation name for OID %u: %s\n" -#~ msgstr "n'a pas pu obtenir le nom de la relation pour l'OID %u: %s\n" +#~ msgid "could not change directory to \"%s\"" +#~ msgstr "n'a pas pu accéder au répertoire « %s »" -#~ msgid "unrecognized command on communication channel: %s\n" -#~ msgstr "commande inconnue sur le canal de communucation: %s\n" +#~ msgid "cannot duplicate null pointer\n" +#~ msgstr "ne peut pas dupliquer un pointeur nul\n" -#~ msgid "terminated by user\n" -#~ msgstr "terminé par l'utilisateur\n" +#~ msgid "worker process crashed: status %d\n" +#~ msgstr "crash du processus worker : statut %d\n" -#~ msgid "error in ListenToWorkers(): %s\n" -#~ msgstr "erreur dans ListenToWorkers(): %s\n" +#~ msgid "parallel_restore should not return\n" +#~ msgstr "parallel_restore ne devrait pas retourner\n" -#~ msgid "archive member too large for tar format\n" -#~ msgstr "membre de l'archive trop volumineux pour le format tar\n" +#~ msgid "could not create worker thread: %s\n" +#~ msgstr "n'a pas pu créer le fil de travail: %s\n" -#~ msgid "could not open output file \"%s\" for writing\n" -#~ msgstr "n'a pas pu ouvrir le fichier de sauvegarde « %s » en écriture\n" +#~ msgid "could not parse version string \"%s\"\n" +#~ msgstr "n'a pas pu analyser la chaîne de version « %s »\n" -#~ msgid "could not write to output file: %s\n" -#~ msgstr "n'a pas pu écrire dans le fichier de sauvegarde : %s\n" +#~ msgid "%s: could not parse version \"%s\"\n" +#~ msgstr "%s : n'a pas pu analyser la version « %s »\n" -#~ msgid "could not write to custom output routine\n" -#~ msgstr "n'a pas pu écrire vers la routine de sauvegarde personnalisée\n" +#~ msgid "-C and -c are incompatible options\n" +#~ msgstr "-C et -c sont des options incompatibles\n" -#~ msgid "unexpected end of file\n" -#~ msgstr "fin de fichier inattendu\n" +#~ msgid "invalid COPY statement -- could not find \"copy\" in string \"%s\"\n" +#~ msgstr "instruction COPY invalide -- n'a pas pu trouver « copy » dans la chaîne « %s »\n" -#~ msgid "could not write byte: %s\n" -#~ msgstr "n'a pas pu écrire un octet : %s\n" +#~ msgid "" +#~ "invalid COPY statement -- could not find \"from stdin\" in string \"%s\" starting at position " +#~ "%lu\n" +#~ msgstr "" +#~ "instruction COPY invalide -- n'a pas pu trouver « from stdin » dans la\n" +#~ "chaîne « %s » à partir de la position %lu\n" -#~ msgid "could not write byte\n" -#~ msgstr "n'a pas pu écrire l'octet\n" +#~ msgid "requested %d byte, got %d from lookahead and %d from file\n" +#~ msgid_plural "requested %d bytes, got %d from lookahead and %d from file\n" +#~ msgstr[0] "%d octet requis, %d obtenu de « lookahead » et %d du fichier\n" +#~ msgstr[1] "%d octets requis, %d obtenus de « lookahead » et %d du fichier\n" -#~ msgid "could not write null block at end of tar archive\n" -#~ msgstr "n'a pas pu écrire le bloc nul à la fin de l'archive tar\n" +#~ msgid "read %lu byte into lookahead buffer\n" +#~ msgid_plural "read %lu bytes into lookahead buffer\n" +#~ msgstr[0] "lecture de %lu octet dans le tampon prévisionnel\n" +#~ msgstr[1] "lecture de %lu octets dans le tampon prévisionnel\n" -#~ msgid "could not output padding at end of tar member\n" -#~ msgstr "n'a pas pu remplir la fin du membre de tar\n" +#~ msgid "query returned %d rows instead of one: %s\n" +#~ msgstr "la requête a renvoyé %d lignes au lieu d'une seule : %s\n" -#~ msgid "mismatch in actual vs. predicted file position (%s vs. %s)\n" -#~ msgstr "" -#~ "pas de correspondance entre la position réelle et celle prévue du " -#~ "fichier\n" -#~ "(%s vs. %s)\n" +#~ msgid "no label definitions found for enum ID %u\n" +#~ msgstr "aucune définition de label trouvée pour l'ID enum %u\n" -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help affiche cette aide puis quitte\n" +#~ msgid "compression support is disabled in this format\n" +#~ msgstr "le support de la compression est désactivé avec ce format\n" -#~ msgid "" -#~ " --version output version information, then exit\n" -#~ msgstr " --version affiche la version puis quitte\n" +#~ msgid "could not parse ACL (%s) for large object %u" +#~ msgstr "n'a pas pu analyser la liste ACL (%s) du « Large Object » %u" -#~ msgid "*** aborted because of error\n" -#~ msgstr "*** interrompu du fait d'erreurs\n" +#~ msgid "saving large object properties\n" +#~ msgstr "sauvegarde des propriétés des « Large Objects »\n" -#~ msgid "missing pg_database entry for database \"%s\"\n" -#~ msgstr "entrée manquante dans pg_database pour la base de données « %s »\n" +#~ msgid "dumpBlobs(): could not open large object %u: %s" +#~ msgstr "dumpBlobs() : n'a pas pu ouvrir le « Large Object » %u : %s" #~ msgid "" -#~ "query returned more than one (%d) pg_database entry for database \"%s\"\n" +#~ "dumping a specific TOC data block out of order is not supported without ID on this input stream " +#~ "(fseek required)\n" #~ msgstr "" -#~ "la requête a renvoyé plusieurs (%d) entrées pg_database pour la base de\n" -#~ "données « %s »\n" +#~ "la sauvegarde d'un bloc de données spécifique du TOC dans le désordre n'est\n" +#~ "pas supporté sans identifiant sur ce flux d'entrée (fseek requis)\n" -#~ msgid "dumpDatabase(): could not find pg_largeobject.relfrozenxid\n" -#~ msgstr "dumpDatabase() : n'a pas pu trouver pg_largeobject.relfrozenxid\n" +#~ msgid "query returned no rows: %s\n" +#~ msgstr "la requête n'a renvoyé aucune ligne : %s\n" + +#~ msgid "%s: invalid -X option -- %s\n" +#~ msgstr "%s : option -X invalide -- %s\n" + +#~ msgid "cannot reopen non-seekable file\n" +#~ msgstr "ne peut pas rouvrir le fichier non cherchable\n" + +#~ msgid "cannot reopen stdin\n" +#~ msgstr "ne peut pas rouvrir stdin\n" + +#~ msgid "%s: out of memory\n" +#~ msgstr "%s : mémoire épuisée\n" #~ msgid "" -#~ "dumpDatabase(): could not find pg_largeobject_metadata.relfrozenxid\n" +#~ " --use-set-session-authorization\n" +#~ " use SET SESSION AUTHORIZATION commands instead of\n" +#~ " ALTER OWNER commands to set ownership\n" #~ msgstr "" -#~ "dumpDatabase() : n'a pas pu trouver pg_largeobject_metadata." -#~ "relfrozenxid\n" +#~ " --use-set-session-authorization\n" +#~ " utilise les commandes SET SESSION AUTHORIZATION\n" +#~ " au lieu des commandes ALTER OWNER pour les\n" +#~ " modifier les propriétaires\n" -#~ msgid "query returned %d foreign server entry for foreign table \"%s\"\n" -#~ msgid_plural "" -#~ "query returned %d foreign server entries for foreign table \"%s\"\n" -#~ msgstr[0] "" -#~ "la requête a renvoyé %d entrée de serveur distant pour la table distante " -#~ "« %s »\n" -#~ msgstr[1] "" -#~ "la requête a renvoyé %d entrées de serveurs distants pour la table " -#~ "distante « %s »\n" +#~ msgid " --disable-triggers disable triggers during data-only restore\n" +#~ msgstr "" +#~ " --disable-triggers désactiver les déclencheurs lors de la\n" +#~ " restauration des données seules\n" -#~ msgid "missing pg_database entry for this database\n" -#~ msgstr "entrée pg_database manquante pour cette base de données\n" +#~ msgid " -O, --no-owner skip restoration of object ownership\n" +#~ msgstr "" +#~ " -O, --no-owner omettre la restauration des possessions des\n" +#~ " objets\n" -#~ msgid "found more than one pg_database entry for this database\n" +#~ msgid " -c, --clean clean (drop) database objects before recreating\n" #~ msgstr "" -#~ "a trouvé plusieurs entrées dans pg_database pour cette base de données\n" +#~ " -c, --clean nettoie/supprime les bases de données avant de\n" +#~ " les créer\n" -#~ msgid "could not find entry for pg_indexes in pg_class\n" -#~ msgstr "n'a pas pu trouver l'entrée de pg_indexes dans pg_class\n" +#~ msgid " --version output version information, then exit\n" +#~ msgstr " --version affiche la version et quitte\n" -#~ msgid "found more than one entry for pg_indexes in pg_class\n" -#~ msgstr "" -#~ "a trouvé plusieurs entrées pour pg_indexes dans la table pg_class\n" +#~ msgid " --help show this help, then exit\n" +#~ msgstr " --help affiche cette aide et quitte\n" -#~ msgid "SQL command failed\n" -#~ msgstr "la commande SQL a échoué\n" +#~ msgid "restoring large object OID %u\n" +#~ msgstr "restauration du « Large Object » d'OID %u\n" -#~ msgid "file archiver" -#~ msgstr "programme d'archivage de fichiers" +#~ msgid "could not close large object file\n" +#~ msgstr "n'a pas pu fermer le fichier du « Large Object »\n" + +#~ msgid "could not open large object TOC for output: %s\n" +#~ msgstr "n'a pas pu ouvrir la TOC du « Large Object » en sortie : %s\n" + +#~ msgid "could not open large object TOC for input: %s\n" +#~ msgstr "n'a pas pu ouvrir la TOC du « Large Object » en entrée : %s\n" + +#~ msgid "could not close data file after reading\n" +#~ msgstr "n'a pas pu fermer le fichier de données après lecture\n" #~ msgid "" #~ "WARNING:\n" @@ -3112,150 +2943,99 @@ msgstr "" #~ " normal use. Files will be written in the current working directory.\n" #~ msgstr "" #~ "ATTENTION :\n" -#~ " Ce format est présent dans un but de démonstration ; il n'est pas " -#~ "prévu\n" +#~ " Ce format est présent dans un but de démonstration ; il n'est pas prévu\n" #~ " pour une utilisation normale. Les fichiers seront écrits dans le\n" #~ " répertoire actuel.\n" -#~ msgid "could not close data file after reading\n" -#~ msgstr "n'a pas pu fermer le fichier de données après lecture\n" - -#~ msgid "could not open large object TOC for input: %s\n" -#~ msgstr "n'a pas pu ouvrir la TOC du « Large Object » en entrée : %s\n" +#~ msgid "file archiver" +#~ msgstr "programme d'archivage de fichiers" -#~ msgid "could not open large object TOC for output: %s\n" -#~ msgstr "n'a pas pu ouvrir la TOC du « Large Object » en sortie : %s\n" +#~ msgid "SQL command failed\n" +#~ msgstr "la commande SQL a échoué\n" -#~ msgid "could not close large object file\n" -#~ msgstr "n'a pas pu fermer le fichier du « Large Object »\n" +#~ msgid "found more than one entry for pg_indexes in pg_class\n" +#~ msgstr "a trouvé plusieurs entrées pour pg_indexes dans la table pg_class\n" -#~ msgid "restoring large object OID %u\n" -#~ msgstr "restauration du « Large Object » d'OID %u\n" +#~ msgid "could not find entry for pg_indexes in pg_class\n" +#~ msgstr "n'a pas pu trouver l'entrée de pg_indexes dans pg_class\n" -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help affiche cette aide et quitte\n" +#~ msgid "found more than one pg_database entry for this database\n" +#~ msgstr "a trouvé plusieurs entrées dans pg_database pour cette base de données\n" -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version affiche la version et quitte\n" +#~ msgid "missing pg_database entry for this database\n" +#~ msgstr "entrée pg_database manquante pour cette base de données\n" -#~ msgid "" -#~ " -c, --clean clean (drop) database objects before " -#~ "recreating\n" -#~ msgstr "" -#~ " -c, --clean nettoie/supprime les bases de données avant " -#~ "de\n" -#~ " les créer\n" +#~ msgid "query returned %d foreign server entry for foreign table \"%s\"\n" +#~ msgid_plural "query returned %d foreign server entries for foreign table \"%s\"\n" +#~ msgstr[0] "la requête a renvoyé %d entrée de serveur distant pour la table distante « %s »\n" +#~ msgstr[1] "la requête a renvoyé %d entrées de serveurs distants pour la table distante « %s »\n" -#~ msgid " -O, --no-owner skip restoration of object ownership\n" -#~ msgstr "" -#~ " -O, --no-owner omettre la restauration des possessions " -#~ "des\n" -#~ " objets\n" +#~ msgid "dumpDatabase(): could not find pg_largeobject_metadata.relfrozenxid\n" +#~ msgstr "dumpDatabase() : n'a pas pu trouver pg_largeobject_metadata.relfrozenxid\n" -#~ msgid "" -#~ " --disable-triggers disable triggers during data-only restore\n" -#~ msgstr "" -#~ " --disable-triggers désactiver les déclencheurs lors de la\n" -#~ " restauration des données seules\n" +#~ msgid "dumpDatabase(): could not find pg_largeobject.relfrozenxid\n" +#~ msgstr "dumpDatabase() : n'a pas pu trouver pg_largeobject.relfrozenxid\n" -#~ msgid "" -#~ " --use-set-session-authorization\n" -#~ " use SET SESSION AUTHORIZATION commands " -#~ "instead of\n" -#~ " ALTER OWNER commands to set ownership\n" +#~ msgid "query returned more than one (%d) pg_database entry for database \"%s\"\n" #~ msgstr "" -#~ " --use-set-session-authorization\n" -#~ " utilise les commandes SET SESSION " -#~ "AUTHORIZATION\n" -#~ " au lieu des commandes ALTER OWNER pour " -#~ "les\n" -#~ " modifier les propriétaires\n" - -#~ msgid "%s: out of memory\n" -#~ msgstr "%s : mémoire épuisée\n" +#~ "la requête a renvoyé plusieurs (%d) entrées pg_database pour la base de\n" +#~ "données « %s »\n" -#~ msgid "cannot reopen stdin\n" -#~ msgstr "ne peut pas rouvrir stdin\n" +#~ msgid "missing pg_database entry for database \"%s\"\n" +#~ msgstr "entrée manquante dans pg_database pour la base de données « %s »\n" -#~ msgid "cannot reopen non-seekable file\n" -#~ msgstr "ne peut pas rouvrir le fichier non cherchable\n" +#~ msgid "*** aborted because of error\n" +#~ msgstr "*** interrompu du fait d'erreurs\n" -#~ msgid "%s: invalid -X option -- %s\n" -#~ msgstr "%s : option -X invalide -- %s\n" +#~ msgid " --version output version information, then exit\n" +#~ msgstr " --version affiche la version puis quitte\n" -#~ msgid "query returned no rows: %s\n" -#~ msgstr "la requête n'a renvoyé aucune ligne : %s\n" +#~ msgid " --help show this help, then exit\n" +#~ msgstr " --help affiche cette aide puis quitte\n" -#~ msgid "" -#~ "dumping a specific TOC data block out of order is not supported without " -#~ "ID on this input stream (fseek required)\n" +#~ msgid "mismatch in actual vs. predicted file position (%s vs. %s)\n" #~ msgstr "" -#~ "la sauvegarde d'un bloc de données spécifique du TOC dans le désordre " -#~ "n'est\n" -#~ "pas supporté sans identifiant sur ce flux d'entrée (fseek requis)\n" - -#~ msgid "dumpBlobs(): could not open large object %u: %s" -#~ msgstr "dumpBlobs() : n'a pas pu ouvrir le « Large Object » %u : %s" - -#~ msgid "saving large object properties\n" -#~ msgstr "sauvegarde des propriétés des « Large Objects »\n" - -#~ msgid "could not parse ACL (%s) for large object %u" -#~ msgstr "n'a pas pu analyser la liste ACL (%s) du « Large Object » %u" - -#~ msgid "compression support is disabled in this format\n" -#~ msgstr "le support de la compression est désactivé avec ce format\n" +#~ "pas de correspondance entre la position réelle et celle prévue du fichier\n" +#~ "(%s vs. %s)\n" -#~ msgid "no label definitions found for enum ID %u\n" -#~ msgstr "aucune définition de label trouvée pour l'ID enum %u\n" +#~ msgid "could not output padding at end of tar member\n" +#~ msgstr "n'a pas pu remplir la fin du membre de tar\n" -#~ msgid "query returned %d rows instead of one: %s\n" -#~ msgstr "la requête a renvoyé %d lignes au lieu d'une seule : %s\n" +#~ msgid "could not write null block at end of tar archive\n" +#~ msgstr "n'a pas pu écrire le bloc nul à la fin de l'archive tar\n" -#~ msgid "read %lu byte into lookahead buffer\n" -#~ msgid_plural "read %lu bytes into lookahead buffer\n" -#~ msgstr[0] "lecture de %lu octet dans le tampon prévisionnel\n" -#~ msgstr[1] "lecture de %lu octets dans le tampon prévisionnel\n" +#~ msgid "could not write byte\n" +#~ msgstr "n'a pas pu écrire l'octet\n" -#~ msgid "requested %d byte, got %d from lookahead and %d from file\n" -#~ msgid_plural "requested %d bytes, got %d from lookahead and %d from file\n" -#~ msgstr[0] "%d octet requis, %d obtenu de « lookahead » et %d du fichier\n" -#~ msgstr[1] "" -#~ "%d octets requis, %d obtenus de « lookahead » et %d du fichier\n" +#~ msgid "could not write byte: %s\n" +#~ msgstr "n'a pas pu écrire un octet : %s\n" -#~ msgid "" -#~ "invalid COPY statement -- could not find \"from stdin\" in string \"%s\" " -#~ "starting at position %lu\n" -#~ msgstr "" -#~ "instruction COPY invalide -- n'a pas pu trouver « from stdin » dans la\n" -#~ "chaîne « %s » à partir de la position %lu\n" +#~ msgid "unexpected end of file\n" +#~ msgstr "fin de fichier inattendu\n" -#~ msgid "" -#~ "invalid COPY statement -- could not find \"copy\" in string \"%s\"\n" -#~ msgstr "" -#~ "instruction COPY invalide -- n'a pas pu trouver « copy » dans la chaîne " -#~ "« %s »\n" +#~ msgid "could not write to custom output routine\n" +#~ msgstr "n'a pas pu écrire vers la routine de sauvegarde personnalisée\n" -#~ msgid "-C and -c are incompatible options\n" -#~ msgstr "-C et -c sont des options incompatibles\n" +#~ msgid "could not write to output file: %s\n" +#~ msgstr "n'a pas pu écrire dans le fichier de sauvegarde : %s\n" -#~ msgid "%s: could not parse version \"%s\"\n" -#~ msgstr "%s : n'a pas pu analyser la version « %s »\n" +#~ msgid "could not open output file \"%s\" for writing\n" +#~ msgstr "n'a pas pu ouvrir le fichier de sauvegarde « %s » en écriture\n" -#~ msgid "could not parse version string \"%s\"\n" -#~ msgstr "n'a pas pu analyser la chaîne de version « %s »\n" +#~ msgid "archive member too large for tar format\n" +#~ msgstr "membre de l'archive trop volumineux pour le format tar\n" -#~ msgid "could not create worker thread: %s\n" -#~ msgstr "n'a pas pu créer le fil de travail: %s\n" +#~ msgid "error in ListenToWorkers(): %s\n" +#~ msgstr "erreur dans ListenToWorkers(): %s\n" -#~ msgid "parallel_restore should not return\n" -#~ msgstr "parallel_restore ne devrait pas retourner\n" +#~ msgid "terminated by user\n" +#~ msgstr "terminé par l'utilisateur\n" -#~ msgid "worker process crashed: status %d\n" -#~ msgstr "crash du processus worker : statut %d\n" +#~ msgid "unrecognized command on communication channel: %s\n" +#~ msgstr "commande inconnue sur le canal de communucation: %s\n" -#~ msgid "cannot duplicate null pointer\n" -#~ msgstr "ne peut pas dupliquer un pointeur nul\n" +#~ msgid "could not get relation name for OID %u: %s\n" +#~ msgstr "n'a pas pu obtenir le nom de la relation pour l'OID %u: %s\n" -#~ msgid "could not change directory to \"%s\"" -#~ msgstr "n'a pas pu accéder au répertoire « %s »" +#~ msgid "worker is terminating\n" +#~ msgstr "le worker est en cours d'arrêt\n" diff --git a/src/bin/pg_dump/po/it.po b/src/bin/pg_dump/po/it.po index d668a63b55..2e4eae9918 100644 --- a/src/bin/pg_dump/po/it.po +++ b/src/bin/pg_dump/po/it.po @@ -24,8 +24,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_dump (Postgresql) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:14+0000\n" -"PO-Revision-Date: 2016-04-17 20:51+0100\n" +"POT-Creation-Date: 2017-02-09 21:14+0000\n" +"PO-Revision-Date: 2017-04-23 02:51+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -33,7 +33,7 @@ msgstr "" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" #: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format @@ -71,8 +71,8 @@ msgid "pclose failed: %s" msgstr "pclose fallita: %s" #: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 -#: ../../common/fe_memutils.c:98 pg_backup_db.c:137 pg_backup_db.c:188 -#: pg_backup_db.c:245 pg_backup_db.c:287 +#: ../../common/fe_memutils.c:98 pg_backup_db.c:158 pg_backup_db.c:213 +#: pg_backup_db.c:272 pg_backup_db.c:314 #, c-format msgid "out of memory\n" msgstr "memoria esaurita\n" @@ -303,88 +303,78 @@ msgid "could not parse numeric array \"%s\": invalid character in number\n" msgstr "non è stato possibile interpretare l'array numerico \"%s\": caratteri non validi nel numero\n" #. translator: this is a module name -#: compress_io.c:79 +#: compress_io.c:78 msgid "compress_io" msgstr "compress_io" -#: compress_io.c:115 +#: compress_io.c:114 #, c-format msgid "invalid compression code: %d\n" msgstr "codice di compressione non valido: %d\n" -#: compress_io.c:139 compress_io.c:175 compress_io.c:196 compress_io.c:529 -#: compress_io.c:572 +#: compress_io.c:138 compress_io.c:174 compress_io.c:192 compress_io.c:519 +#: compress_io.c:562 #, c-format msgid "not built with zlib support\n" msgstr "compilato senza il supporto a zlib\n" -#: compress_io.c:246 compress_io.c:348 +#: compress_io.c:242 compress_io.c:344 #, c-format msgid "could not initialize compression library: %s\n" msgstr "inizializzazione della libreria di compressione fallita: %s\n" -#: compress_io.c:267 +#: compress_io.c:263 #, c-format msgid "could not close compression stream: %s\n" msgstr "chiusura dello stream di compressione fallita: %s\n" -#: compress_io.c:285 +#: compress_io.c:281 #, c-format msgid "could not compress data: %s\n" msgstr "compressione dei dati fallita: %s\n" -#: compress_io.c:368 compress_io.c:384 +#: compress_io.c:361 compress_io.c:377 #, c-format msgid "could not uncompress data: %s\n" msgstr "decompressione dei dati fallita: %s\n" -#: compress_io.c:392 +#: compress_io.c:385 #, c-format msgid "could not close compression library: %s\n" msgstr "chiusura della libreria di compressione fallita: %s\n" -#: compress_io.c:606 compress_io.c:642 pg_backup_custom.c:591 +#: compress_io.c:596 compress_io.c:632 pg_backup_custom.c:591 #: pg_backup_tar.c:561 #, c-format msgid "could not read from input file: %s\n" msgstr "lettura dal file di input fallita: %s\n" -#: compress_io.c:645 pg_backup_custom.c:588 pg_backup_directory.c:552 +#: compress_io.c:635 pg_backup_custom.c:588 pg_backup_directory.c:548 #: pg_backup_tar.c:797 pg_backup_tar.c:821 #, c-format msgid "could not read from input file: end of file\n" msgstr "lettura dal file di input fallita: fine del file\n" -#: parallel.c:77 +#: parallel.c:167 msgid "parallel archiver" msgstr "archiviatore parallelo" -#: parallel.c:140 +#: parallel.c:231 #, c-format msgid "%s: WSAStartup failed: %d\n" msgstr "%s: WSAStartup fallita: %d\n" -#: parallel.c:340 -#, c-format -msgid "worker is terminating\n" -msgstr "il worker sta terminando\n" - -#: parallel.c:530 +#: parallel.c:934 #, c-format msgid "could not create communication channels: %s\n" msgstr "creazione dei canali di comunicazione fallita: %s\n" -#: parallel.c:602 +#: parallel.c:997 #, c-format msgid "could not create worker process: %s\n" msgstr "creazione del processo worker fallita: %s\n" -#: parallel.c:819 -#, c-format -msgid "could not get relation name for OID %u: %s\n" -msgstr "errore nell'ottenere il nome della relazione per l'OID %u: %s\n" - -#: parallel.c:836 +#: parallel.c:1192 #, c-format msgid "" "could not obtain lock on relation \"%s\"\n" @@ -393,77 +383,67 @@ msgstr "" "errore nell'ottenere un lock sulla relazione \"%s\"\n" "Questo di solito vuol dire che qualcuno ha richiesto un lock ACCESS EXCLUSIVE sulla tabella dopo che il processo padre di pg_dump aveva ottenuto il lock ACCESS SHARE iniziale sulla tabella.\n" -#: parallel.c:920 +#: parallel.c:1262 #, c-format -msgid "unrecognized command on communication channel: %s\n" -msgstr "comando sconosciuto sul canale di comunicazione: %s\n" +msgid "unrecognized command received from master: \"%s\"\n" +msgstr "comando sconosciuto ricevuto dal master: \"%s\"\n" -#: parallel.c:953 +#: parallel.c:1300 #, c-format msgid "a worker process died unexpectedly\n" msgstr "un processo worker è morto inaspettatamente\n" -#: parallel.c:980 parallel.c:989 +#: parallel.c:1326 parallel.c:1332 #, c-format -msgid "invalid message received from worker: %s\n" -msgstr "messaggio non valido ricevuto dal worker: %s\n" +msgid "invalid message received from worker: \"%s\"\n" +msgstr "messaggio non valido ricevuto dal worker: \"%s\"\n" -#: parallel.c:986 pg_backup_db.c:355 -#, c-format -msgid "%s" -msgstr "%s" - -#: parallel.c:1038 parallel.c:1082 +#: parallel.c:1389 parallel.c:1440 #, c-format msgid "error processing a parallel work item\n" msgstr "errore nel processo di una unità di lavoro parallela\n" -#: parallel.c:1110 parallel.c:1248 +#: parallel.c:1469 parallel.c:1587 #, c-format msgid "could not write to the communication channel: %s\n" msgstr "scrittura nel canale di comunicazione fallita: %s\n" -#: parallel.c:1159 +#: parallel.c:1547 #, c-format -msgid "terminated by user\n" -msgstr "terminato dall'utente\n" +msgid "select() failed: %s\n" +msgstr "select() fallita: %s\n" -#: parallel.c:1211 -#, c-format -msgid "error in ListenToWorkers(): %s\n" -msgstr "errore in ListenToWorkers(): %s\n" - -#: parallel.c:1336 +#: parallel.c:1672 #, c-format msgid "pgpipe: could not create socket: error code %d\n" msgstr "pgpipe: errore nella creazione del socket: codice di errore %d\n" -#: parallel.c:1347 +#: parallel.c:1683 #, c-format msgid "pgpipe: could not bind: error code %d\n" msgstr "pgpipe: bind fallito: codice di errore %d\n" -#: parallel.c:1354 +#: parallel.c:1690 #, c-format msgid "pgpipe: could not listen: error code %d\n" msgstr "pgpipe: listen fallito: codice di errore %d\n" -#: parallel.c:1361 +#: parallel.c:1697 #, c-format msgid "pgpipe: getsockname() failed: error code %d\n" msgstr "pgpipe: getsockname() fallito: codice di errore %d\n" -#: parallel.c:1372 +#: parallel.c:1708 #, c-format msgid "pgpipe: could not create second socket: error code %d\n" msgstr "pgpipe: creazione del secondo socket fallita: codice di errore %d\n" -#: parallel.c:1381 +#: parallel.c:1717 #, c-format msgid "pgpipe: could not connect socket: error code %d\n" msgstr "pgpipe: connessione del socket fallita: codice di errore %d\n" -#: parallel.c:1388 +#: parallel.c:1726 #, c-format msgid "pgpipe: could not accept connection: error code %d\n" msgstr "pgpipe: accept della connessione fallito: codice di errore %d\n" @@ -473,7 +453,7 @@ msgstr "pgpipe: accept della connessione fallito: codice di errore %d\n" msgid "archiver" msgstr "archiviatore" -#: pg_backup_archiver.c:234 pg_backup_archiver.c:1512 +#: pg_backup_archiver.c:234 pg_backup_archiver.c:1535 #, c-format msgid "could not close output file: %s\n" msgstr "chiusura del file di output fallita: %s\n" @@ -528,435 +508,435 @@ msgstr "ripristino implicito dei soli dati\n" msgid "dropping %s %s\n" msgstr "cancellazione di %s %s\n" -#: pg_backup_archiver.c:646 +#: pg_backup_archiver.c:586 +#, c-format +msgid "WARNING: could not find where to insert IF EXISTS in statement \"%s\"\n" +msgstr "ATTENZIONE: posizione dove inserire IF EXISTS nell'istruzione \"%s\" non trovata\n" + +#: pg_backup_archiver.c:662 #, c-format msgid "setting owner and privileges for %s \"%s.%s\"\n" msgstr "impostazione di proprietario e permessi per %s \"%s.%s\"\n" -#: pg_backup_archiver.c:649 +#: pg_backup_archiver.c:665 #, c-format msgid "setting owner and privileges for %s \"%s\"\n" msgstr "impostazione di proprietario e permessi per %s \"%s\"\n" -#: pg_backup_archiver.c:715 pg_backup_archiver.c:717 +#: pg_backup_archiver.c:731 pg_backup_archiver.c:733 #, c-format msgid "warning from original dump file: %s\n" msgstr "avvertimento dal file originale scaricato: %s\n" -#: pg_backup_archiver.c:726 +#: pg_backup_archiver.c:742 #, c-format msgid "creating %s \"%s.%s\"\n" msgstr "creazione %s \"%s.%s\"\n" -#: pg_backup_archiver.c:729 +#: pg_backup_archiver.c:745 #, c-format msgid "creating %s \"%s\"\n" msgstr "creazione di %s \"%s\"\n" -#: pg_backup_archiver.c:774 +#: pg_backup_archiver.c:797 #, c-format msgid "connecting to new database \"%s\"\n" msgstr "connessione al nuovo database \"%s\"\n" -#: pg_backup_archiver.c:802 +#: pg_backup_archiver.c:825 #, c-format msgid "processing %s\n" msgstr "elaborazione di %s\n" -#: pg_backup_archiver.c:822 +#: pg_backup_archiver.c:845 #, c-format msgid "processing data for table \"%s.%s\"\n" msgstr "elaborazione dati per la tabella \"%s.%s\".\n" -#: pg_backup_archiver.c:884 +#: pg_backup_archiver.c:907 #, c-format msgid "executing %s %s\n" msgstr "esecuzione di %s %s\n" -#: pg_backup_archiver.c:923 +#: pg_backup_archiver.c:946 #, c-format msgid "disabling triggers for %s\n" msgstr "disabilitazione trigger per %s\n" -#: pg_backup_archiver.c:951 +#: pg_backup_archiver.c:974 #, c-format msgid "enabling triggers for %s\n" msgstr "abilitazione trigger per %s\n" -#: pg_backup_archiver.c:981 +#: pg_backup_archiver.c:1004 #, c-format msgid "internal error -- WriteData cannot be called outside the context of a DataDumper routine\n" msgstr "errore interno -- WriteData non può essere chiamata al di fuori del contesto di una routine DataDumper\n" -#: pg_backup_archiver.c:1150 +#: pg_backup_archiver.c:1173 #, c-format msgid "large-object output not supported in chosen format\n" msgstr "emissione dei large object non supportata nel formato scelto\n" -#: pg_backup_archiver.c:1208 +#: pg_backup_archiver.c:1231 #, c-format msgid "restored %d large object\n" msgid_plural "restored %d large objects\n" msgstr[0] "ripristinato %d large object\n" msgstr[1] "ripristinati %d large object\n" -#: pg_backup_archiver.c:1229 pg_backup_tar.c:739 +#: pg_backup_archiver.c:1252 pg_backup_tar.c:739 #, c-format msgid "restoring large object with OID %u\n" msgstr "ripristino del large object con OID %u\n" -#: pg_backup_archiver.c:1241 +#: pg_backup_archiver.c:1264 #, c-format msgid "could not create large object %u: %s" msgstr "creazione il large object %u fallita: %s" -#: pg_backup_archiver.c:1246 pg_dump.c:2997 +#: pg_backup_archiver.c:1269 pg_dump.c:3070 #, c-format msgid "could not open large object %u: %s" msgstr "apertura del large object %u fallita: %s" -#: pg_backup_archiver.c:1304 +#: pg_backup_archiver.c:1327 #, c-format msgid "could not open TOC file \"%s\": %s\n" msgstr "apertura del file TOC \"%s\" fallita: %s\n" -#: pg_backup_archiver.c:1345 +#: pg_backup_archiver.c:1368 #, c-format msgid "WARNING: line ignored: %s\n" msgstr "ATTENZIONE: la riga è stata ignorata: %s\n" -#: pg_backup_archiver.c:1352 +#: pg_backup_archiver.c:1375 #, c-format msgid "could not find entry for ID %d\n" msgstr "non sono state trovate voci per l'ID %d\n" -#: pg_backup_archiver.c:1373 pg_backup_directory.c:230 -#: pg_backup_directory.c:601 +#: pg_backup_archiver.c:1396 pg_backup_directory.c:230 +#: pg_backup_directory.c:597 #, c-format msgid "could not close TOC file: %s\n" msgstr "chiusura del file TOC fallita: %s\n" -#: pg_backup_archiver.c:1482 pg_backup_custom.c:162 pg_backup_directory.c:341 -#: pg_backup_directory.c:587 pg_backup_directory.c:645 -#: pg_backup_directory.c:665 +#: pg_backup_archiver.c:1505 pg_backup_custom.c:162 pg_backup_directory.c:341 +#: pg_backup_directory.c:583 pg_backup_directory.c:641 +#: pg_backup_directory.c:661 #, c-format msgid "could not open output file \"%s\": %s\n" msgstr "apertura del file di output \"%s\" fallita: %s\n" -#: pg_backup_archiver.c:1485 pg_backup_custom.c:169 +#: pg_backup_archiver.c:1508 pg_backup_custom.c:169 #, c-format msgid "could not open output file: %s\n" msgstr "apertura del file di output fallita: %s\n" -#: pg_backup_archiver.c:1591 +#: pg_backup_archiver.c:1614 #, c-format msgid "wrote %lu byte of large object data (result = %lu)\n" msgid_plural "wrote %lu bytes of large object data (result = %lu)\n" msgstr[0] "scritto %lu byte di dati large object (risultato = %lu)\n" msgstr[1] "scritti %lu byte di dati large object (risultato = %lu)\n" -#: pg_backup_archiver.c:1597 +#: pg_backup_archiver.c:1620 #, c-format msgid "could not write to large object (result: %lu, expected: %lu)\n" msgstr "scrittura del large object fallita (risultato: %lu, previsto: %lu)\n" -#: pg_backup_archiver.c:1690 +#: pg_backup_archiver.c:1713 #, c-format msgid "Error while INITIALIZING:\n" msgstr "Errore durante INIZIALIZZAZIONE:\n" -#: pg_backup_archiver.c:1695 +#: pg_backup_archiver.c:1718 #, c-format msgid "Error while PROCESSING TOC:\n" msgstr "Errore durante ELABORAZIONE TOC:\n" -#: pg_backup_archiver.c:1700 +#: pg_backup_archiver.c:1723 #, c-format msgid "Error while FINALIZING:\n" msgstr "Errore durante FINALIZZAZIONE:\n" -#: pg_backup_archiver.c:1705 +#: pg_backup_archiver.c:1728 #, c-format msgid "Error from TOC entry %d; %u %u %s %s %s\n" msgstr "Errore nella voce TOC %d; %u %u %s %s %s\n" -#: pg_backup_archiver.c:1778 +#: pg_backup_archiver.c:1801 #, c-format msgid "bad dumpId\n" msgstr "dumpId errato\n" -#: pg_backup_archiver.c:1799 +#: pg_backup_archiver.c:1822 #, c-format msgid "bad table dumpId for TABLE DATA item\n" msgstr "dumpId di tabella errato per elemento TABLE DATA\n" -#: pg_backup_archiver.c:1891 +#: pg_backup_archiver.c:1914 #, c-format msgid "unexpected data offset flag %d\n" msgstr "flag di offset dati non previsto %d\n" -#: pg_backup_archiver.c:1904 +#: pg_backup_archiver.c:1927 #, c-format msgid "file offset in dump file is too large\n" msgstr "l'offset del file scaricato è troppo grande\n" -#: pg_backup_archiver.c:2017 +#: pg_backup_archiver.c:2040 #, c-format msgid "attempting to ascertain archive format\n" msgstr "tentativo di accertamento del formato dell'archivio\n" -#: pg_backup_archiver.c:2043 pg_backup_archiver.c:2053 +#: pg_backup_archiver.c:2066 pg_backup_archiver.c:2076 #, c-format msgid "directory name too long: \"%s\"\n" msgstr "nome della directory troppo lungo: \"%s\"\n" -#: pg_backup_archiver.c:2061 +#: pg_backup_archiver.c:2084 #, c-format msgid "directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does not exist)\n" msgstr "la directory \"%s\" non sembra un archivio valido (\"toc.dat\" non esiste)\n" -#: pg_backup_archiver.c:2069 pg_backup_custom.c:181 pg_backup_custom.c:770 -#: pg_backup_directory.c:214 pg_backup_directory.c:402 +#: pg_backup_archiver.c:2092 pg_backup_custom.c:181 pg_backup_custom.c:770 +#: pg_backup_directory.c:214 pg_backup_directory.c:399 #, c-format msgid "could not open input file \"%s\": %s\n" msgstr "apertura del file di input \"%s\" fallita: %s\n" -#: pg_backup_archiver.c:2077 pg_backup_custom.c:188 +#: pg_backup_archiver.c:2100 pg_backup_custom.c:188 #, c-format msgid "could not open input file: %s\n" msgstr "apertura del file di input fallita: %s\n" -#: pg_backup_archiver.c:2084 +#: pg_backup_archiver.c:2107 #, c-format msgid "could not read input file: %s\n" msgstr "lettura del file di input fallita: %s\n" -#: pg_backup_archiver.c:2086 +#: pg_backup_archiver.c:2109 #, c-format msgid "input file is too short (read %lu, expected 5)\n" msgstr "il file di input è troppo corto (letti %lu, previsti 5)\n" -#: pg_backup_archiver.c:2169 +#: pg_backup_archiver.c:2192 #, c-format msgid "input file appears to be a text format dump. Please use psql.\n" msgstr "il file di input sembra un dump in formato testo. Prego usare psql.\n" -#: pg_backup_archiver.c:2175 +#: pg_backup_archiver.c:2198 #, c-format msgid "input file does not appear to be a valid archive (too short?)\n" msgstr "il file di input non sembra essere un archivio valido (è troppo corto?)\n" -#: pg_backup_archiver.c:2181 +#: pg_backup_archiver.c:2204 #, c-format msgid "input file does not appear to be a valid archive\n" msgstr "il file di input non sembra essere un archivio valido\n" -#: pg_backup_archiver.c:2201 +#: pg_backup_archiver.c:2224 #, c-format msgid "could not close input file: %s\n" msgstr "chiusura del file di input fallita: %s\n" -#: pg_backup_archiver.c:2218 +#: pg_backup_archiver.c:2241 #, c-format msgid "allocating AH for %s, format %d\n" msgstr "allocazione AH per %s, formato %d\n" -#: pg_backup_archiver.c:2323 +#: pg_backup_archiver.c:2346 #, c-format msgid "unrecognized file format \"%d\"\n" msgstr "formato di file \"%d\" sconosciuto\n" -#: pg_backup_archiver.c:2473 +#: pg_backup_archiver.c:2502 #, c-format msgid "entry ID %d out of range -- perhaps a corrupt TOC\n" msgstr "la voce ID %d è fuori dall'intervallo consentito -- possibile corruzione della TOC\n" -#: pg_backup_archiver.c:2589 +#: pg_backup_archiver.c:2618 #, c-format msgid "read TOC entry %d (ID %d) for %s %s\n" msgstr "letta voce TOC %d (ID %d) per %s %s\n" -#: pg_backup_archiver.c:2623 +#: pg_backup_archiver.c:2652 #, c-format msgid "unrecognized encoding \"%s\"\n" msgstr "codifica sconosciuta \"%s\"\n" -#: pg_backup_archiver.c:2628 +#: pg_backup_archiver.c:2657 #, c-format msgid "invalid ENCODING item: %s\n" msgstr "elemento ENCODING non valido: %s\n" -#: pg_backup_archiver.c:2646 +#: pg_backup_archiver.c:2675 #, c-format msgid "invalid STDSTRINGS item: %s\n" msgstr "elemento STDSTRINGS non valido: %s\n" -#: pg_backup_archiver.c:2661 +#: pg_backup_archiver.c:2690 #, c-format -msgid "Schema \"%s\" not found.\n" -msgstr "Schema \"%s\" non trovato.\n" +msgid "schema \"%s\" not found\n" +msgstr "schema \"%s\" non trovato\n" -#: pg_backup_archiver.c:2668 +#: pg_backup_archiver.c:2697 #, c-format -msgid "Table \"%s\" not found.\n" -msgstr "Tabella \"%s\" non trovata.\n" +msgid "table \"%s\" not found\n" +msgstr "tabella \"%s\" non trovata\n" -#: pg_backup_archiver.c:2675 +#: pg_backup_archiver.c:2704 #, c-format -msgid "Index \"%s\" not found.\n" -msgstr "Indice \"%s\" non trovato.\n" +msgid "index \"%s\" not found\n" +msgstr "indice \"%s\" non trovato\n" -#: pg_backup_archiver.c:2682 +#: pg_backup_archiver.c:2711 #, c-format -msgid "Function \"%s\" not found.\n" -msgstr "Funzione \"%s\" non trovata.\n" +msgid "function \"%s\" not found\n" +msgstr "funzione \"%s\" non trovata\n" -#: pg_backup_archiver.c:2689 +#: pg_backup_archiver.c:2718 #, c-format -msgid "Trigger \"%s\" not found.\n" -msgstr "Trigger \"%s\" non trovato.\n" +msgid "trigger \"%s\" not found\n" +msgstr "trigger \"%s\" non trovato\n" -#: pg_backup_archiver.c:2920 +#: pg_backup_archiver.c:2950 #, c-format msgid "could not set session user to \"%s\": %s" msgstr "impostazione della sessione utente a \"%s\" fallita: %s" -#: pg_backup_archiver.c:2952 +#: pg_backup_archiver.c:2982 #, c-format msgid "could not set default_with_oids: %s" msgstr "impostazione di default_with_oids fallita: %s" -#: pg_backup_archiver.c:3092 +#: pg_backup_archiver.c:3127 #, c-format msgid "could not set search_path to \"%s\": %s" msgstr "impostazione di search_path a \"%s\" fallita: %s" -#: pg_backup_archiver.c:3154 +#: pg_backup_archiver.c:3189 #, c-format msgid "could not set default_tablespace to %s: %s" msgstr "impostazione di default_tablespace a %s fallita: %s" -#: pg_backup_archiver.c:3241 pg_backup_archiver.c:3428 +#: pg_backup_archiver.c:3276 pg_backup_archiver.c:3470 #, c-format msgid "WARNING: don't know how to set owner for object type %s\n" msgstr "ATTENZIONE: non si sa come impostare il proprietario per il tipo di oggetto %s\n" -#: pg_backup_archiver.c:3481 -#, c-format -msgid "WARNING: requested compression not available in this installation -- archive will be uncompressed\n" -msgstr "ATTENZIONE: la compressione richiesta non è disponibile in questa installazione -- l'archivio non sarà compresso\n" - -#: pg_backup_archiver.c:3520 +#: pg_backup_archiver.c:3552 #, c-format msgid "did not find magic string in file header\n" msgstr "magic string non trovata nell'intestazione del file\n" -#: pg_backup_archiver.c:3533 +#: pg_backup_archiver.c:3565 #, c-format msgid "unsupported version (%d.%d) in file header\n" msgstr "versione (%d.%d) non supportata nell'intestazione del file\n" -#: pg_backup_archiver.c:3538 +#: pg_backup_archiver.c:3570 #, c-format msgid "sanity check on integer size (%lu) failed\n" msgstr "verifica sulla dimensione degli interi (%lu) fallita\n" -#: pg_backup_archiver.c:3542 +#: pg_backup_archiver.c:3574 #, c-format msgid "WARNING: archive was made on a machine with larger integers, some operations might fail\n" msgstr "ATTENZIONE: L'archivio è stato creato su una macchina con interi lunghi, alcune operazioni potrebbero fallire\n" -#: pg_backup_archiver.c:3552 +#: pg_backup_archiver.c:3584 #, c-format msgid "expected format (%d) differs from format found in file (%d)\n" msgstr "il formato previsto (%d) differisce dal formato trovato nel file (%d)\n" -#: pg_backup_archiver.c:3568 +#: pg_backup_archiver.c:3600 #, c-format msgid "WARNING: archive is compressed, but this installation does not support compression -- no data will be available\n" msgstr "ATTENZIONE: l'archivio è compresso, ma questa installazione non supporta la compressione -- nessun dato sarà disponibile\n" -#: pg_backup_archiver.c:3586 +#: pg_backup_archiver.c:3618 #, c-format msgid "WARNING: invalid creation date in header\n" msgstr "ATTENZIONE: la data di creazione nell'intestazione non è valida\n" -#: pg_backup_archiver.c:3661 +#: pg_backup_archiver.c:3693 #, c-format msgid "entering restore_toc_entries_prefork\n" msgstr "inizio di restore_toc_entries_prefork\n" -#: pg_backup_archiver.c:3705 +#: pg_backup_archiver.c:3737 #, c-format msgid "processing item %d %s %s\n" msgstr "elaborazione elemento %d %s %s\n" -#: pg_backup_archiver.c:3757 +#: pg_backup_archiver.c:3789 #, c-format msgid "entering restore_toc_entries_parallel\n" msgstr "immissione restore_toc_entries_parallel\n" -#: pg_backup_archiver.c:3805 +#: pg_backup_archiver.c:3837 #, c-format msgid "entering main parallel loop\n" msgstr "inizio del loop principale parallelo\n" -#: pg_backup_archiver.c:3816 +#: pg_backup_archiver.c:3848 #, c-format msgid "skipping item %d %s %s\n" msgstr "saltato l'elemento %d %s %s\n" -#: pg_backup_archiver.c:3826 +#: pg_backup_archiver.c:3858 #, c-format msgid "launching item %d %s %s\n" msgstr "avvio dell'elemento %d %s %s\n" -#: pg_backup_archiver.c:3884 +#: pg_backup_archiver.c:3914 #, c-format msgid "finished main parallel loop\n" msgstr "loop principale parallelo terminato\n" -#: pg_backup_archiver.c:3893 +#: pg_backup_archiver.c:3923 #, c-format msgid "entering restore_toc_entries_postfork\n" msgstr "inizio di restore_toc_entries_postfork\n" -#: pg_backup_archiver.c:3911 +#: pg_backup_archiver.c:3942 #, c-format msgid "processing missed item %d %s %s\n" msgstr "elaborazione dell'elemento perduto %d %s %s\n" -#: pg_backup_archiver.c:4060 +#: pg_backup_archiver.c:4091 #, c-format msgid "no item ready\n" msgstr "nessun elemento pronto\n" -#: pg_backup_archiver.c:4109 +#: pg_backup_archiver.c:4139 #, c-format msgid "could not find slot of finished worker\n" msgstr "non è stato trovato alcuno slot di worker terminati\n" -#: pg_backup_archiver.c:4111 +#: pg_backup_archiver.c:4141 #, c-format msgid "finished item %d %s %s\n" msgstr "elemento %d %s %s terminato\n" -#: pg_backup_archiver.c:4124 +#: pg_backup_archiver.c:4154 #, c-format msgid "worker process failed: exit code %d\n" msgstr "processo worker fallito: codice di uscita %d\n" -#: pg_backup_archiver.c:4286 +#: pg_backup_archiver.c:4316 #, c-format msgid "transferring dependency %d -> %d to %d\n" msgstr "trasferimento di dipendenza %d -> %d a %d\n" -#: pg_backup_archiver.c:4359 +#: pg_backup_archiver.c:4389 #, c-format msgid "reducing dependencies for %d\n" msgstr "riduzione dipendenze per %d\n" -#: pg_backup_archiver.c:4398 +#: pg_backup_archiver.c:4428 #, c-format msgid "table \"%s\" could not be created, will not restore its data\n" msgstr "creazione della tabella \"%s\" fallita, i suoi dati non verranno ripristinati\n" @@ -1048,104 +1028,121 @@ msgid "WARNING: ftell mismatch with expected position -- ftell used\n" msgstr "ATTENZIONE: ftell non corrisponde alla posizione prevista -- verrà usato il valore restituito da ftell\n" #. translator: this is a module name -#: pg_backup_db.c:29 +#: pg_backup_db.c:31 msgid "archiver (db)" msgstr "archiviatore (db)" -#: pg_backup_db.c:44 +#: pg_backup_db.c:47 #, c-format msgid "could not get server_version from libpq\n" msgstr "non è stato possibile ottenere server_version da libpq\n" -#: pg_backup_db.c:55 pg_dumpall.c:1982 +#: pg_backup_db.c:58 pg_dumpall.c:2068 #, c-format msgid "server version: %s; %s version: %s\n" msgstr "versione del server: %s; %s versione: %s\n" -#: pg_backup_db.c:57 pg_dumpall.c:1984 +#: pg_backup_db.c:60 pg_dumpall.c:2070 #, c-format msgid "aborting because of server version mismatch\n" msgstr "abortito perché la versione del server non corrisponde\n" -#: pg_backup_db.c:128 +#: pg_backup_db.c:149 #, c-format msgid "connecting to database \"%s\" as user \"%s\"\n" msgstr "connessione al database \"%s\" come utente \"%s\"\n" -#: pg_backup_db.c:135 pg_backup_db.c:183 pg_backup_db.c:243 pg_backup_db.c:285 -#: pg_dumpall.c:1812 pg_dumpall.c:1920 +#: pg_backup_db.c:156 pg_backup_db.c:208 pg_backup_db.c:270 pg_backup_db.c:312 +#: pg_dumpall.c:1894 pg_dumpall.c:2006 msgid "Password: " msgstr "Password: " -#: pg_backup_db.c:164 +#: pg_backup_db.c:189 #, c-format msgid "failed to reconnect to database\n" msgstr "riconnessione al database fallita\n" -#: pg_backup_db.c:169 +#: pg_backup_db.c:194 #, c-format msgid "could not reconnect to database: %s" msgstr "riconnessione al database fallita: %s" -#: pg_backup_db.c:185 +#: pg_backup_db.c:210 #, c-format msgid "connection needs password\n" msgstr "la connessione richiede la password\n" -#: pg_backup_db.c:237 +#: pg_backup_db.c:264 #, c-format msgid "already connected to a database\n" msgstr "già connesso ad un database\n" -#: pg_backup_db.c:277 +#: pg_backup_db.c:304 #, c-format msgid "failed to connect to database\n" msgstr "connessione al database fallita\n" -#: pg_backup_db.c:294 +#: pg_backup_db.c:321 #, c-format msgid "connection to database \"%s\" failed: %s" msgstr "connessione al database \"%s\" fallita: %s" -#: pg_backup_db.c:362 +#: pg_backup_db.c:391 +#, c-format +msgid "%s" +msgstr "%s" + +#: pg_backup_db.c:398 #, c-format msgid "query failed: %s" msgstr "query fallita: %s" -#: pg_backup_db.c:364 +#: pg_backup_db.c:400 #, c-format msgid "query was: %s\n" msgstr "la query era: %s\n" -#: pg_backup_db.c:428 +#: pg_backup_db.c:442 +#, c-format +msgid "query returned %d row instead of one: %s\n" +msgid_plural "query returned %d rows instead of one: %s\n" +msgstr[0] "la query ha restituito %d riga invece di una: %s\n" +msgstr[1] "la query ha restituito %d righe invece di una: %s\n" + +#: pg_backup_db.c:487 #, c-format msgid "%s: %s Command was: %s\n" msgstr "%s: %s Il comando era: %s\n" -#: pg_backup_db.c:484 pg_backup_db.c:558 pg_backup_db.c:565 +#: pg_backup_db.c:543 pg_backup_db.c:617 pg_backup_db.c:624 msgid "could not execute query" msgstr "esecuzione della query fallita" -#: pg_backup_db.c:537 +#: pg_backup_db.c:596 #, c-format msgid "error returned by PQputCopyData: %s" msgstr "errore restituito da PQputCopyData: %s" -#: pg_backup_db.c:586 +#: pg_backup_db.c:645 #, c-format msgid "error returned by PQputCopyEnd: %s" msgstr "errore restituito da PQputCopyEnd: %s" -#: pg_backup_db.c:592 +#: pg_backup_db.c:651 #, c-format msgid "COPY failed for table \"%s\": %s" msgstr "COPY fallito per la tabella \"%s\": %s" -#: pg_backup_db.c:605 +#: pg_backup_db.c:657 pg_dump.c:1805 +#, c-format +msgid "WARNING: unexpected extra results during COPY of table \"%s\"\n" +msgstr "ATTENZIONE: risultati aggiuntivi inattesi nel COPY della tabella \"%s\"\n" + +#: pg_backup_db.c:669 msgid "could not start database transaction" msgstr "avvio della transazione database fallito" -#: pg_backup_db.c:613 +#: pg_backup_db.c:677 msgid "could not commit database transaction" msgstr "commit della transazione database fallito" @@ -1174,42 +1171,42 @@ msgstr "chiusura della directory \"%s\" fallita: %s\n" msgid "could not create directory \"%s\": %s\n" msgstr "creazione della directory \"%s\" fallita: %s\n" -#: pg_backup_directory.c:413 +#: pg_backup_directory.c:412 #, c-format msgid "could not close data file: %s\n" msgstr "chiusura del file di dati fallita: %s\n" -#: pg_backup_directory.c:454 +#: pg_backup_directory.c:453 #, c-format msgid "could not open large object TOC file \"%s\" for input: %s\n" msgstr "apertura del file TOC dei large object \"%s\" per l'input fallita: %s\n" -#: pg_backup_directory.c:465 +#: pg_backup_directory.c:464 #, c-format msgid "invalid line in large object TOC file \"%s\": \"%s\"\n" msgstr "riga non valida nel file TOC dei large object \"%s\": \"%s\"\n" -#: pg_backup_directory.c:474 +#: pg_backup_directory.c:473 #, c-format msgid "error reading large object TOC file \"%s\"\n" msgstr "errore in lettura del file TOC dei large object \"%s\"\n" -#: pg_backup_directory.c:478 +#: pg_backup_directory.c:477 #, c-format msgid "could not close large object TOC file \"%s\": %s\n" msgstr "chiusura del file TOC dei large object \"%s\" fallita: %s\n" -#: pg_backup_directory.c:688 +#: pg_backup_directory.c:684 #, c-format msgid "could not write to blobs TOC file\n" msgstr "scrittura nel file TOC dei blob fallita\n" -#: pg_backup_directory.c:720 +#: pg_backup_directory.c:716 #, c-format msgid "file name too long: \"%s\"\n" msgstr "nome del file troppo lungo: \"%s\"\n" -#: pg_backup_directory.c:806 +#: pg_backup_directory.c:802 #, c-format msgid "error during backup\n" msgstr "errore durante il backup\n" @@ -1341,64 +1338,69 @@ msgstr "intestazione tar corrotta in %s (previsti %d, calcolati %d) alla posizio msgid "%s: unrecognized section name: \"%s\"\n" msgstr "%s: nome di sezione sconosciuto: \"%s\"\n" -#: pg_backup_utils.c:56 pg_dump.c:534 pg_dump.c:551 pg_dumpall.c:301 -#: pg_dumpall.c:311 pg_dumpall.c:321 pg_dumpall.c:330 pg_dumpall.c:346 -#: pg_dumpall.c:404 pg_restore.c:279 pg_restore.c:295 pg_restore.c:307 +#: pg_backup_utils.c:56 pg_dump.c:536 pg_dump.c:553 pg_dumpall.c:299 +#: pg_dumpall.c:309 pg_dumpall.c:319 pg_dumpall.c:328 pg_dumpall.c:344 +#: pg_dumpall.c:402 pg_restore.c:279 pg_restore.c:295 pg_restore.c:307 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Prova \"%s --help\" per maggiori informazioni.\n" -#: pg_backup_utils.c:101 +#: pg_backup_utils.c:118 #, c-format msgid "out of on_exit_nicely slots\n" msgstr "slot on_exit_nicely terminati\n" -#: pg_dump.c:504 +#: pg_dump.c:506 #, c-format msgid "compression level must be in range 0..9\n" msgstr "il livello di compressione dev'essere tra 0 e 9\n" -#: pg_dump.c:549 pg_dumpall.c:309 pg_restore.c:293 +#: pg_dump.c:551 pg_dumpall.c:307 pg_restore.c:293 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: troppi argomenti nella riga di comando (il primo è \"%s\")\n" -#: pg_dump.c:562 +#: pg_dump.c:564 #, c-format msgid "options -s/--schema-only and -a/--data-only cannot be used together\n" msgstr "le opzioni -s/--schema-only e -a/--data-only non possono essere usate insieme\n" -#: pg_dump.c:568 +#: pg_dump.c:570 #, c-format msgid "options -c/--clean and -a/--data-only cannot be used together\n" msgstr "le opzioni -c/--clean e -a/--data-only non possono essere usate insieme\n" -#: pg_dump.c:574 +#: pg_dump.c:576 #, c-format msgid "options --inserts/--column-inserts and -o/--oids cannot be used together\n" msgstr "le opzioni --inserts/--column-inserts e -o/--oids non possono essere usate insieme\n" -#: pg_dump.c:575 +#: pg_dump.c:577 #, c-format msgid "(The INSERT command cannot set OIDs.)\n" msgstr "(Il comando INSERT non può impostare OID.)\n" -#: pg_dump.c:580 +#: pg_dump.c:582 #, c-format msgid "option --if-exists requires option -c/--clean\n" msgstr "l'opzione --if-exists richiede l'opzione -c/--clean\n" -#: pg_dump.c:608 +#: pg_dump.c:604 #, c-format -msgid "%s: invalid number of parallel jobs\n" -msgstr "%s: numero di job paralleli non valido\n" +msgid "WARNING: requested compression not available in this installation -- archive will be uncompressed\n" +msgstr "ATTENZIONE: la compressione richiesta non è disponibile in questa installazione -- l'archivio non sarà compresso\n" -#: pg_dump.c:612 +#: pg_dump.c:619 +#, c-format +msgid "invalid number of parallel jobs\n" +msgstr "numero di job paralleli non valido\n" + +#: pg_dump.c:623 #, c-format msgid "parallel backup only supported by the directory format\n" msgstr "il backup parallelo è supportato solo con il formato directory.\n" -#: pg_dump.c:681 +#: pg_dump.c:680 #, c-format msgid "" "Synchronized snapshots are not supported by this server version.\n" @@ -1409,27 +1411,27 @@ msgstr "" "del server. Puoi usare --no-synchronized-snapshots invece se non hai\n" "bisogno di snapshot sincronizzati.\n" -#: pg_dump.c:688 +#: pg_dump.c:687 #, c-format msgid "Exported snapshots are not supported by this server version.\n" msgstr "Gli snapshot esportati non sono supportati da questa versione del server.\n" -#: pg_dump.c:699 +#: pg_dump.c:706 #, c-format msgid "last built-in OID is %u\n" msgstr "l'ultimo OID predefinito è %u\n" -#: pg_dump.c:709 +#: pg_dump.c:715 #, c-format -msgid "No matching schemas were found\n" -msgstr "Non è stato trovato nessuno schema corrispondente\n" +msgid "no matching schemas were found\n" +msgstr "non è stato trovato nessuno schema corrispondente\n" -#: pg_dump.c:723 +#: pg_dump.c:729 #, c-format -msgid "No matching tables were found\n" -msgstr "Non è stata trovata nessuna tabella corrispondente\n" +msgid "no matching tables were found\n" +msgstr "non è stata trovata nessuna tabella corrispondente\n" -#: pg_dump.c:882 +#: pg_dump.c:888 #, c-format msgid "" "%s dumps a database as a text file or to other formats.\n" @@ -1438,17 +1440,17 @@ msgstr "" "%s scarica un database in formato testo o in altri formati.\n" "\n" -#: pg_dump.c:883 pg_dumpall.c:549 pg_restore.c:437 +#: pg_dump.c:889 pg_dumpall.c:547 pg_restore.c:443 #, c-format msgid "Usage:\n" msgstr "Utilizzo:\n" -#: pg_dump.c:884 +#: pg_dump.c:890 #, c-format msgid " %s [OPTION]... [DBNAME]\n" msgstr " %s [OPZIONE]... [NOMEDB]\n" -#: pg_dump.c:886 pg_dumpall.c:552 pg_restore.c:440 +#: pg_dump.c:892 pg_dumpall.c:550 pg_restore.c:446 #, c-format msgid "" "\n" @@ -1457,12 +1459,12 @@ msgstr "" "\n" "Opzioni generali:\n" -#: pg_dump.c:887 +#: pg_dump.c:893 #, c-format msgid " -f, --file=FILENAME output file or directory name\n" msgstr " -f, --file=NOMEFILE nome del file o directory di output\n" -#: pg_dump.c:888 +#: pg_dump.c:894 #, c-format msgid "" " -F, --format=c|d|t|p output file format (custom, directory, tar,\n" @@ -1471,39 +1473,39 @@ msgstr "" " -F, --format=c|d|t|p formato del file di output (custom, directory,\n" " tar, testo in chiaro (predefinito))\n" -#: pg_dump.c:890 +#: pg_dump.c:896 #, c-format msgid " -j, --jobs=NUM use this many parallel jobs to dump\n" msgstr " -j, --jobs=NUM usa NUM job paralleli per il dump\n" -#: pg_dump.c:891 +#: pg_dump.c:897 pg_dumpall.c:552 #, c-format msgid " -v, --verbose verbose mode\n" msgstr " -v, --verbose stampa più informazioni\n" -#: pg_dump.c:892 pg_dumpall.c:554 +#: pg_dump.c:898 pg_dumpall.c:553 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version mostra informazioni sulla versione ed esci\n" -#: pg_dump.c:893 +#: pg_dump.c:899 #, c-format msgid " -Z, --compress=0-9 compression level for compressed formats\n" msgstr " -Z, --compress=0-9 livello di compressione per formati compressi\n" -#: pg_dump.c:894 pg_dumpall.c:555 +#: pg_dump.c:900 pg_dumpall.c:554 #, c-format msgid " --lock-wait-timeout=TIMEOUT fail after waiting TIMEOUT for a table lock\n" msgstr "" " --lock-wait-timeout=TIMEOUT termina con errore dopo un'attesa di TIMEOUT\n" " per un lock di tabella\n" -#: pg_dump.c:895 pg_dumpall.c:556 +#: pg_dump.c:901 pg_dumpall.c:555 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help mostra questo aiuto ed esci\n" -#: pg_dump.c:897 pg_dumpall.c:557 +#: pg_dump.c:903 pg_dumpall.c:556 #, c-format msgid "" "\n" @@ -1512,51 +1514,51 @@ msgstr "" "\n" "Opzioni per il controllo del contenuto dell'output:\n" -#: pg_dump.c:898 pg_dumpall.c:558 +#: pg_dump.c:904 pg_dumpall.c:557 #, c-format msgid " -a, --data-only dump only the data, not the schema\n" msgstr " -a, --data-only scarica solamente i dati, non lo schema\n" -#: pg_dump.c:899 +#: pg_dump.c:905 #, c-format msgid " -b, --blobs include large objects in dump\n" msgstr " -b, --blobs includi nell'archivio i large object\n" -#: pg_dump.c:900 pg_restore.c:451 +#: pg_dump.c:906 pg_restore.c:457 #, c-format msgid " -c, --clean clean (drop) database objects before recreating\n" msgstr "" " -c, --clean svuota (drop) gli oggetti del database prima di\n" " ricrearli\n" -#: pg_dump.c:901 +#: pg_dump.c:907 #, c-format msgid " -C, --create include commands to create database in dump\n" msgstr "" " -C, --create include nell'archivio i comandi per creare\n" " i database\n" -#: pg_dump.c:902 +#: pg_dump.c:908 #, c-format msgid " -E, --encoding=ENCODING dump the data in encoding ENCODING\n" msgstr " -E, --encoding=CODIFICA scarica i dati nella CODIFICA indicata\n" -#: pg_dump.c:903 +#: pg_dump.c:909 #, c-format msgid " -n, --schema=SCHEMA dump the named schema(s) only\n" msgstr " -n, --schema=SCHEMA scarica solo lo schema o gli schemi indicati\n" -#: pg_dump.c:904 +#: pg_dump.c:910 #, c-format msgid " -N, --exclude-schema=SCHEMA do NOT dump the named schema(s)\n" msgstr " -N, --exclude-schema=SCHEMA non scaricare lo schema o gli schemi indicati\n" -#: pg_dump.c:905 pg_dumpall.c:561 +#: pg_dump.c:911 pg_dumpall.c:560 #, c-format msgid " -o, --oids include OIDs in dump\n" msgstr " -o, --oids includi gli OID nel dump\n" -#: pg_dump.c:906 +#: pg_dump.c:912 #, c-format msgid "" " -O, --no-owner skip restoration of object ownership in\n" @@ -1565,60 +1567,60 @@ msgstr "" " -O, --no-owner salta il ripristino del proprietario degli\n" " oggetti nel formato testo in chiaro\n" -#: pg_dump.c:908 pg_dumpall.c:564 +#: pg_dump.c:914 pg_dumpall.c:563 #, c-format msgid " -s, --schema-only dump only the schema, no data\n" msgstr " -s, --schema-only scarica solo lo schema, non i dati\n" -#: pg_dump.c:909 +#: pg_dump.c:915 #, c-format msgid " -S, --superuser=NAME superuser user name to use in plain-text format\n" msgstr "" " -S, --superuser=NOME nome del superutente da usare nel formato testo\n" " in chiaro\n" -#: pg_dump.c:910 +#: pg_dump.c:916 #, c-format msgid " -t, --table=TABLE dump the named table(s) only\n" msgstr " -t, --table=TABELLA scarica solo la tabella o le tabelle indicate\n" -#: pg_dump.c:911 +#: pg_dump.c:917 #, c-format msgid " -T, --exclude-table=TABLE do NOT dump the named table(s)\n" msgstr " -T, --exclude-table=TABELLA NON scaricare la tabella o le tabelle indicate\n" -#: pg_dump.c:912 pg_dumpall.c:567 +#: pg_dump.c:918 pg_dumpall.c:566 #, c-format msgid " -x, --no-privileges do not dump privileges (grant/revoke)\n" msgstr " -x, --no-privileges non scaricare i privilegi (grant/revoke)\n" -#: pg_dump.c:913 pg_dumpall.c:568 +#: pg_dump.c:919 pg_dumpall.c:567 #, c-format msgid " --binary-upgrade for use by upgrade utilities only\n" msgstr " --binary-upgrade da utilizzare solo dall'utilità di aggiornamento\n" -#: pg_dump.c:914 pg_dumpall.c:569 +#: pg_dump.c:920 pg_dumpall.c:568 #, c-format msgid " --column-inserts dump data as INSERT commands with column names\n" msgstr "" " --column-inserts scarica dati come comandi INSERT con nomi\n" " di colonna\n" -#: pg_dump.c:915 pg_dumpall.c:570 +#: pg_dump.c:921 pg_dumpall.c:569 #, c-format msgid " --disable-dollar-quoting disable dollar quoting, use SQL standard quoting\n" msgstr "" " --disable-dollar-quoting disabilita la quotazione con dollari, usa la\n" " quotazione standard SQL\n" -#: pg_dump.c:916 pg_dumpall.c:571 pg_restore.c:467 +#: pg_dump.c:922 pg_dumpall.c:570 pg_restore.c:473 #, c-format msgid " --disable-triggers disable triggers during data-only restore\n" msgstr "" " --disable-triggers disabilita i trigger durante il ripristino\n" " dei soli dati\n" -#: pg_dump.c:917 +#: pg_dump.c:923 #, c-format msgid "" " --enable-row-security enable row security (dump only content user has\n" @@ -1627,70 +1629,70 @@ msgstr "" " --enable-row-security abilita la sicurezza per riga (salva solo i dati\n" " a cui l'utente ha accesso)\n" -#: pg_dump.c:919 +#: pg_dump.c:925 #, c-format msgid " --exclude-table-data=TABLE do NOT dump data for the named table(s)\n" msgstr "" " --exclude-table-data=TABLE NON scaricare i dati per la tabella o le tabelle\n" " indicate\n" -#: pg_dump.c:920 pg_dumpall.c:572 pg_restore.c:469 +#: pg_dump.c:926 pg_dumpall.c:571 pg_restore.c:475 #, c-format msgid " --if-exists use IF EXISTS when dropping objects\n" msgstr " --if-exists usa IF EXISTS nell'eliminare gli oggetti\n" -#: pg_dump.c:921 pg_dumpall.c:573 +#: pg_dump.c:927 pg_dumpall.c:572 #, c-format msgid " --inserts dump data as INSERT commands, rather than COPY\n" msgstr " --inserts scarica i dati come comandi INSERT anziché COPY\n" -#: pg_dump.c:922 pg_dumpall.c:574 +#: pg_dump.c:928 pg_dumpall.c:573 #, c-format msgid " --no-security-labels do not dump security label assignments\n" msgstr " --no-security-labels non scaricare le assegnazioni di sicurezza\n" -#: pg_dump.c:923 +#: pg_dump.c:929 #, c-format msgid " --no-synchronized-snapshots do not use synchronized snapshots in parallel jobs\n" msgstr " --no-synchronized-snapshots non usare snapshot sincronizzati nei job paralleli\n" -#: pg_dump.c:924 pg_dumpall.c:575 +#: pg_dump.c:930 pg_dumpall.c:574 #, c-format msgid " --no-tablespaces do not dump tablespace assignments\n" msgstr " --no-tablespaces non scarica le assegnazioni di tablespace\n" -#: pg_dump.c:925 pg_dumpall.c:576 +#: pg_dump.c:931 pg_dumpall.c:575 #, c-format msgid " --no-unlogged-table-data do not dump unlogged table data\n" msgstr " --no-unlogged-table-data non scaricare i dati delle tabelle non loggate\n" -#: pg_dump.c:926 pg_dumpall.c:577 +#: pg_dump.c:932 pg_dumpall.c:576 #, c-format msgid " --quote-all-identifiers quote all identifiers, even if not key words\n" msgstr "" " --quote-all-identifiers metti tutti gli identificatori tra virgolette,\n" " anche se non sono parole chiave\n" -#: pg_dump.c:927 +#: pg_dump.c:933 #, c-format msgid " --section=SECTION dump named section (pre-data, data, or post-data)\n" msgstr "" " --section=SECTION scarica la sezione con questo nome (pre-data,\n" " data o post-data)\n" -#: pg_dump.c:928 +#: pg_dump.c:934 #, c-format msgid " --serializable-deferrable wait until the dump can run without anomalies\n" msgstr "" " --serializable-deferrable attendi prima che lo scaricamento possa essere\n" " eseguito senza anomalie\n" -#: pg_dump.c:929 +#: pg_dump.c:935 #, c-format msgid " --snapshot=SNAPSHOT use given snapshot for the dump\n" msgstr " --snapshot=SNAPSHOT usa questo snapshot per il salvataggio\n" -#: pg_dump.c:930 pg_restore.c:475 +#: pg_dump.c:936 pg_restore.c:481 #, c-format msgid "" " --strict-names require table and/or schema include patterns to\n" @@ -1699,7 +1701,7 @@ msgstr "" " --strict-names richiede che le tabelle/schemi includano pattern\n" " che combacino con almeno un'entità\n" -#: pg_dump.c:932 pg_dumpall.c:578 pg_restore.c:477 +#: pg_dump.c:938 pg_dumpall.c:577 pg_restore.c:483 #, c-format msgid "" " --use-set-session-authorization\n" @@ -1710,7 +1712,7 @@ msgstr "" " usa i comandi SET SESSION AUTHORIZATION invece\n" " di ALTER OWNER per impostare il proprietario\n" -#: pg_dump.c:936 pg_dumpall.c:582 pg_restore.c:481 +#: pg_dump.c:942 pg_dumpall.c:581 pg_restore.c:487 #, c-format msgid "" "\n" @@ -1719,44 +1721,44 @@ msgstr "" "\n" "Opzioni di connessione:\n" -#: pg_dump.c:937 +#: pg_dump.c:943 #, c-format msgid " -d, --dbname=DBNAME database to dump\n" msgstr " -d, --dbname=NOMEDB database da scaricare\n" -#: pg_dump.c:938 pg_dumpall.c:584 pg_restore.c:482 +#: pg_dump.c:944 pg_dumpall.c:583 pg_restore.c:488 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory\n" msgstr " -h, --host=NOMEHOST host server del database o directory socket\n" -#: pg_dump.c:939 pg_dumpall.c:586 pg_restore.c:483 +#: pg_dump.c:945 pg_dumpall.c:585 pg_restore.c:489 #, c-format msgid " -p, --port=PORT database server port number\n" msgstr " -p, --port=PORTA numero porta del server di database\n" -#: pg_dump.c:940 pg_dumpall.c:587 pg_restore.c:484 +#: pg_dump.c:946 pg_dumpall.c:586 pg_restore.c:490 #, c-format msgid " -U, --username=NAME connect as specified database user\n" msgstr " -U, --username=NOME connessione con l'utente di database specificato\n" -#: pg_dump.c:941 pg_dumpall.c:588 pg_restore.c:485 +#: pg_dump.c:947 pg_dumpall.c:587 pg_restore.c:491 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password non chiedere mai le password\n" -#: pg_dump.c:942 pg_dumpall.c:589 pg_restore.c:486 +#: pg_dump.c:948 pg_dumpall.c:588 pg_restore.c:492 #, c-format msgid " -W, --password force password prompt (should happen automatically)\n" msgstr "" " -W, --password forza la richiesta di una password (dovrebbe essere\n" " automatico)\n" -#: pg_dump.c:943 pg_dumpall.c:590 +#: pg_dump.c:949 pg_dumpall.c:589 #, c-format msgid " --role=ROLENAME do SET ROLE before dump\n" msgstr " --role=NOMERUOLO esegui SET ROLE prima di scaricare\n" -#: pg_dump.c:945 +#: pg_dump.c:951 #, c-format msgid "" "\n" @@ -1769,387 +1771,406 @@ msgstr "" "della variabile di ambiente PGDATABASE.\n" "\n" -#: pg_dump.c:947 pg_dumpall.c:594 pg_restore.c:493 +#: pg_dump.c:953 pg_dumpall.c:593 pg_restore.c:499 #, c-format msgid "Report bugs to .\n" msgstr "Puoi segnalare eventuali bug a .\n" -#: pg_dump.c:967 +#: pg_dump.c:970 #, c-format msgid "invalid client encoding \"%s\" specified\n" msgstr "codifica client specificata \"%s\" non valida\n" -#: pg_dump.c:1152 +#: pg_dump.c:1112 +#, c-format +msgid "" +"Synchronized snapshots are not supported on standby servers.\n" +"Run with --no-synchronized-snapshots instead if you do not need\n" +"synchronized snapshots.\n" +msgstr "" +"Gli snapshot sincronizzati non sono supportati sui server di standby.\n" +"Usa --no-synchronized-snapshots se non ti servono snapshot\n" +"sincronizzati.\n" + +#: pg_dump.c:1181 #, c-format msgid "invalid output format \"%s\" specified\n" msgstr "formato di output specificato \"%s\" non valido\n" -#: pg_dump.c:1175 +#: pg_dump.c:1204 #, c-format msgid "server version must be at least 7.3 to use schema selection switches\n" msgstr "per usare le opzioni di selezione schema la versione del server deve essere almeno 7.3\n" -#: pg_dump.c:1193 pg_dump.c:1246 +#: pg_dump.c:1222 #, c-format -msgid "No matching table(s) were found for pattern \"%s\"\n" -msgstr "Nessuna tabella trovata per il pattern \"%s\"\n" +msgid "no matching schemas were found for pattern \"%s\"\n" +msgstr "nessuno schema trovato per il pattern \"%s\"\n" -#: pg_dump.c:1596 +#: pg_dump.c:1275 +#, c-format +msgid "no matching tables were found for pattern \"%s\"\n" +msgstr "nessuna tabella trovata per il pattern \"%s\"\n" + +#: pg_dump.c:1662 #, c-format msgid "dumping contents of table \"%s.%s\"\n" msgstr "salvataggio del contenuto della tabella \"%s.%s\"\n" -#: pg_dump.c:1720 +#: pg_dump.c:1786 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.\n" msgstr "Lo scarico dei contenuti della tabella \"%s\" è fallito: PQgetCopyData() fallito.\n" -#: pg_dump.c:1721 pg_dump.c:1731 +#: pg_dump.c:1787 pg_dump.c:1797 #, c-format msgid "Error message from server: %s" msgstr "Messaggio di errore dal server: %s" -#: pg_dump.c:1722 pg_dump.c:1732 +#: pg_dump.c:1788 pg_dump.c:1798 #, c-format msgid "The command was: %s\n" msgstr "Il comando era: %s\n" -#: pg_dump.c:1730 +#: pg_dump.c:1796 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetResult() failed.\n" msgstr "Scarico dei contenuti della tabella \"%s\" fallito: PQgetResult() fallito.\n" -#: pg_dump.c:2374 +#: pg_dump.c:2445 #, c-format msgid "saving database definition\n" msgstr "salvataggio definizione del database\n" -#: pg_dump.c:2707 +#: pg_dump.c:2779 #, c-format msgid "saving encoding = %s\n" msgstr "salvataggio codifica = %s\n" -#: pg_dump.c:2734 +#: pg_dump.c:2806 #, c-format msgid "saving standard_conforming_strings = %s\n" msgstr "salvataggio standard_conforming_strings = %s\n" -#: pg_dump.c:2774 +#: pg_dump.c:2846 #, c-format msgid "reading large objects\n" msgstr "lettura dei large object\n" -#: pg_dump.c:2960 +#: pg_dump.c:3033 #, c-format msgid "saving large objects\n" msgstr "salvataggio dei large object\n" -#: pg_dump.c:3007 +#: pg_dump.c:3080 #, c-format msgid "error reading large object %u: %s" msgstr "errore di lettura del large object %u: %s" -#: pg_dump.c:3059 +#: pg_dump.c:3132 #, c-format msgid "reading row security enabled for table \"%s.%s\"\n" msgstr "letture delle regole di sicurezza per riga abilitata per la tabella \"%s.%s\"\n" -#: pg_dump.c:3090 +#: pg_dump.c:3163 #, c-format msgid "reading policies for table \"%s.%s\"\n" msgstr "lettura delle regole di sicurezza per la tabella \"%s.%s\"\n" -#: pg_dump.c:3223 +#: pg_dump.c:3296 #, c-format msgid "unexpected policy command type: \"%s\"\n" msgstr "tipo di comando di regola di sicurezza imprevisto: \"%s\"\n" -#: pg_dump.c:3442 +#: pg_dump.c:3515 #, c-format msgid "could not find parent extension for %s\n" msgstr "estensione genitore di %s non trovata\n" -#: pg_dump.c:3610 +#: pg_dump.c:3683 #, c-format msgid "WARNING: owner of schema \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario dello schema \"%s\" sembra non essere valido\n" -#: pg_dump.c:3653 +#: pg_dump.c:3726 #, c-format msgid "schema with OID %u does not exist\n" msgstr "lo schema con OID %u non esiste\n" -#: pg_dump.c:4068 +#: pg_dump.c:4141 #, c-format msgid "WARNING: owner of data type \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario del tipo dato \"%s\" non sembra essere valido\n" -#: pg_dump.c:4179 +#: pg_dump.c:4255 #, c-format msgid "WARNING: owner of operator \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario dell'operatore \"%s\" non sembra essere valido\n" -#: pg_dump.c:4512 +#: pg_dump.c:4600 #, c-format msgid "WARNING: owner of operator class \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario della classe operatore \"%s\" non sembra essere valido\n" -#: pg_dump.c:4600 +#: pg_dump.c:4691 #, c-format msgid "WARNING: owner of operator family \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario della famiglia di operatori \"%s\" non sembra essere valido\n" -#: pg_dump.c:4805 +#: pg_dump.c:4892 #, c-format msgid "WARNING: owner of aggregate function \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario della funzione di aggregazione \"%s\" non sembra essere valido\n" -#: pg_dump.c:5074 +#: pg_dump.c:5189 #, c-format msgid "WARNING: owner of function \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario della funzione \"%s\" non sembra essere valido\n" -#: pg_dump.c:5874 +#: pg_dump.c:6051 #, c-format msgid "WARNING: owner of table \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il proprietario della tabella \"%s\" non sembra essere valido\n" -#: pg_dump.c:6026 +#: pg_dump.c:6093 pg_dump.c:16593 +#, c-format +msgid "failed sanity check, parent table OID %u of sequence OID %u not found\n" +msgstr "controllo di integrità fallito, tabella con OID %u proprietaria della sequenza con OID %u non trovata\n" + +#: pg_dump.c:6220 #, c-format msgid "reading indexes for table \"%s.%s\"\n" msgstr "lettura degli indici della tabella \"%s.%s\"\n" -#: pg_dump.c:6394 +#: pg_dump.c:6588 #, c-format msgid "reading foreign key constraints for table \"%s.%s\"\n" msgstr "lettura dei vincoli di chiave esterna della tabella \"%s.%s\"\n" -#: pg_dump.c:6640 +#: pg_dump.c:6834 #, c-format msgid "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not found\n" msgstr "controllo integrità fallito, l'OID %u della tabella padre della voce OID %u di pg_rewrite non è stato trovato\n" -#: pg_dump.c:6734 +#: pg_dump.c:6928 #, c-format msgid "reading triggers for table \"%s.%s\"\n" msgstr "lettura dei trigger della tabella \"%s.%s\"\n" -#: pg_dump.c:6899 +#: pg_dump.c:7093 #, c-format msgid "query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of table: %u)\n" msgstr "la query non ha prodotto nessun nome di tabella referenziata per il trigger di chiave esterna \"%s\" sulla tabella \"%s\" (OID della tabella: %u)\n" -#: pg_dump.c:7548 +#: pg_dump.c:7748 #, c-format msgid "finding the columns and types of table \"%s.%s\"\n" msgstr "lettura delle colonne e dei tipi della tabella \"%s.%s\"\n" -#: pg_dump.c:7727 +#: pg_dump.c:7927 #, c-format msgid "invalid column numbering in table \"%s\"\n" msgstr "numerazione delle colonne non valida nella tabella \"%s\"\n" -#: pg_dump.c:7761 +#: pg_dump.c:7961 #, c-format msgid "finding default expressions of table \"%s.%s\"\n" msgstr "lettura delle espressioni di default della tabella \"%s.%s\"\n" -#: pg_dump.c:7814 +#: pg_dump.c:8014 #, c-format msgid "invalid adnum value %d for table \"%s\"\n" msgstr "valore adnum %d non valido per la tabella \"%s\"\n" -#: pg_dump.c:7886 +#: pg_dump.c:8086 #, c-format msgid "finding check constraints for table \"%s.%s\"\n" msgstr "ricerca dei vincoli di controllo della tabella \"%s.%s\"\n" -#: pg_dump.c:7982 +#: pg_dump.c:8182 #, c-format msgid "expected %d check constraint on table \"%s\" but found %d\n" msgid_plural "expected %d check constraints on table \"%s\" but found %d\n" msgstr[0] "previsto %d vincolo di controllo sulla tabella \"%s\" ma trovato %d\n" msgstr[1] "previsti %d vincoli di controllo sulla tabella \"%s\" ma trovati %d\n" -#: pg_dump.c:7986 +#: pg_dump.c:8186 #, c-format msgid "(The system catalogs might be corrupted.)\n" msgstr "(I cataloghi di sistema potrebbero essere corrotti.)\n" -#: pg_dump.c:9506 +#: pg_dump.c:9764 #, c-format msgid "WARNING: typtype of data type \"%s\" appears to be invalid\n" msgstr "ATTENZIONE: il \"typtype\" del tipo dato \"%s\" sembra non essere valido\n" -#: pg_dump.c:11048 +#: pg_dump.c:11306 #, c-format msgid "WARNING: bogus value in proargmodes array\n" msgstr "ATTENZIONE: valore errato nell'array proargmode\n" -#: pg_dump.c:11426 +#: pg_dump.c:11684 #, c-format msgid "WARNING: could not parse proallargtypes array\n" msgstr "ATTENZIONE: non è stato possibile analizzare l'array proallargtype\n" -#: pg_dump.c:11442 +#: pg_dump.c:11700 #, c-format msgid "WARNING: could not parse proargmodes array\n" msgstr "ATTENZIONE: non è stato possibile analizzare l'array proargmode\n" -#: pg_dump.c:11456 +#: pg_dump.c:11714 #, c-format msgid "WARNING: could not parse proargnames array\n" msgstr "ATTENZIONE: non è stato possibile analizzare l'array proargname\n" -#: pg_dump.c:11467 +#: pg_dump.c:11725 #, c-format msgid "WARNING: could not parse proconfig array\n" msgstr "ATTENZIONE: non è stato possibile analizzare l'array preconfig\n" -#: pg_dump.c:11538 +#: pg_dump.c:11796 #, c-format msgid "unrecognized provolatile value for function \"%s\"\n" msgstr "valore provolatile sconosciuto per la funzione \"%s\"\n" -#: pg_dump.c:11582 +#: pg_dump.c:11840 pg_dump.c:13889 #, c-format msgid "unrecognized proparallel value for function \"%s\"\n" msgstr "valore proparallel non riconosciuto per la funzione \"%s\"\n" -#: pg_dump.c:11734 +#: pg_dump.c:11948 pg_dump.c:12058 pg_dump.c:12065 +#, c-format +msgid "could not find function definition for function with OID %u\n" +msgstr "definizione della funzione con OID %u non trovata\n" + +#: pg_dump.c:11993 #, c-format msgid "WARNING: bogus value in pg_cast.castfunc or pg_cast.castmethod field\n" msgstr "ATTENZIONE: valore non corretto nei campi pg_cast.castfunc o pg_cast.castmethod\n" -#: pg_dump.c:11737 +#: pg_dump.c:11996 #, c-format msgid "WARNING: bogus value in pg_cast.castmethod field\n" msgstr "ATTENZIONE: valore non corretto nel campo pg_cast.castmethod\n" -#: pg_dump.c:11825 +#: pg_dump.c:12086 #, c-format msgid "WARNING: bogus transform definition, at least one of trffromsql and trftosql should be nonzero\n" msgstr "ATTENZIONE: definizione della trasformazione non corretta, almeno uno tra trffromsql e trftosql dovrebbe essere non-zero\n" -#: pg_dump.c:11842 +#: pg_dump.c:12103 #, c-format msgid "WARNING: bogus value in pg_transform.trffromsql field\n" msgstr "ATTENZIONE: valore non corretto nel campo pg_transform.trffromsql\n" -#: pg_dump.c:11863 +#: pg_dump.c:12124 #, c-format msgid "WARNING: bogus value in pg_transform.trftosql field\n" msgstr "ATTENZIONE: valore non corretto nel campo pg_transform.trftosql\n" -#: pg_dump.c:12254 +#: pg_dump.c:12515 #, c-format msgid "WARNING: could not find operator with OID %s\n" msgstr "ATTENZIONE: operatore con OID %s non trovato\n" -#: pg_dump.c:12318 +#: pg_dump.c:12579 #, c-format -msgid "WARNING: invalid type %c of access method %s\n" -msgstr "ATTENZIONE: tipo %c non valido del metodo di accesso %s\n" +msgid "WARNING: invalid type \"%c\" of access method \"%s\"\n" +msgstr "ATTENZIONE: tipo \"%c\" non valido del metodo di accesso \"%s\"\n" -#: pg_dump.c:13516 +#: pg_dump.c:13780 #, c-format msgid "WARNING: aggregate function %s could not be dumped correctly for this database version; ignored\n" msgstr "ATTENZIONE: la funzione di aggregazione %s non può essere scaricata correttamente per questa versione database; ignorata\n" -#: pg_dump.c:14384 +#: pg_dump.c:14652 #, c-format msgid "unrecognized object type in default privileges: %d\n" msgstr "tipo di oggetto sconosciuto nei privilegi predefiniti: %d\n" -#: pg_dump.c:14399 +#: pg_dump.c:14670 #, c-format msgid "could not parse default ACL list (%s)\n" msgstr "non è stato possibile interpretare la ACL predefinita (%s)\n" -#: pg_dump.c:14470 +#: pg_dump.c:14741 #, c-format msgid "could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) for object \"%s\" (%s)\n" msgstr "non è stato possibile interpretare il GRANT ACL iniziale (%s) o il REVOKE ACL iniziale (%s) per l'oggetto \"%s\" (%s)\n" -#: pg_dump.c:14478 +#: pg_dump.c:14749 #, c-format msgid "could not parse GRANT ACL list (%s) or REVOKE ACL list (%s) for object \"%s\" (%s)\n" msgstr "non è stato possibile interpretare il GRANT ACL (%s) o il REVOKE ACL (%s) per l'oggetto \"%s\" (%s)\n" -#: pg_dump.c:14954 +#: pg_dump.c:15233 #, c-format msgid "query to obtain definition of view \"%s\" returned no data\n" msgstr "la query per ottenere la definizione della vista \"%s\" non ha restituito dati\n" -#: pg_dump.c:14957 +#: pg_dump.c:15236 #, c-format msgid "query to obtain definition of view \"%s\" returned more than one definition\n" msgstr "la query per ottenere la definizione della vista \"%s\" ha restituito più di una definizione\n" -#: pg_dump.c:14964 +#: pg_dump.c:15243 #, c-format msgid "definition of view \"%s\" appears to be empty (length zero)\n" msgstr "la definizione della vista \"%s\" sembra essere vuota (lunghezza zero)\n" -#: pg_dump.c:15722 +#: pg_dump.c:16002 #, c-format msgid "invalid column number %d for table \"%s\"\n" msgstr "il numero di colonne %d non è valido per la tabella \"%s\"\n" -#: pg_dump.c:15851 +#: pg_dump.c:16131 #, c-format msgid "missing index for constraint \"%s\"\n" msgstr "omesso indice per vincolo \"%s\"\n" -#: pg_dump.c:16054 +#: pg_dump.c:16334 #, c-format msgid "unrecognized constraint type: %c\n" msgstr "tipo di vincolo sconosciuto: %c\n" -#: pg_dump.c:16208 pg_dump.c:16377 +#: pg_dump.c:16488 pg_dump.c:16661 #, c-format msgid "query to get data of sequence \"%s\" returned %d row (expected 1)\n" msgid_plural "query to get data of sequence \"%s\" returned %d rows (expected 1)\n" msgstr[0] "la query per ottenere i dati della sequenza \"%s\" ha restituito %d riga (prevista 1)\n" msgstr[1] "la query per ottenere i dati della sequenza \"%s\" ha restituito %d righe (prevista 1)\n" -#: pg_dump.c:16219 +#: pg_dump.c:16499 #, c-format msgid "query to get data of sequence \"%s\" returned name \"%s\"\n" msgstr "la query per ottenere dati della sequenza \"%s\" ha restituito il nome \"%s\"\n" -#: pg_dump.c:16475 +#: pg_dump.c:16759 #, c-format msgid "unexpected tgtype value: %d\n" msgstr "valore tgtype inatteso: %d\n" -#: pg_dump.c:16557 +#: pg_dump.c:16841 #, c-format msgid "invalid argument string (%s) for trigger \"%s\" on table \"%s\"\n" msgstr "la stringa argomento (%s) non è valida per il trigger \"%s\" sulla tabella \"%s\"\n" -#: pg_dump.c:16754 +#: pg_dump.c:17038 #, c-format msgid "query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned\n" msgstr "la query per ottenere regole \"%s\" per la tabella \"%s\" ha fallito: ha restituito un numero errato di righe\n" -#: pg_dump.c:17143 +#: pg_dump.c:17427 #, c-format msgid "reading dependency data\n" msgstr "lettura dati di dipendenza\n" -#: pg_dump.c:17704 +#: pg_dump.c:17984 #, c-format msgid "WARNING: could not parse reloptions array\n" msgstr "ATTENZIONE: errore di lettura dell'array reloptions\n" -#: pg_dump.c:17768 -#, c-format -msgid "query returned %d row instead of one: %s\n" -msgid_plural "query returned %d rows instead of one: %s\n" -msgstr[0] "la query ha restituito %d riga invece di una: %s\n" -msgstr[1] "la query ha restituito %d righe invece di una: %s\n" - #. translator: this is a module name #: pg_dump_sort.c:23 msgid "sorter" @@ -2170,34 +2191,34 @@ msgstr "dipendenza non valida %d\n" msgid "could not identify dependency loop\n" msgstr "identificazione del ciclo di dipendenze fallito\n" -#: pg_dump_sort.c:1261 +#: pg_dump_sort.c:1262 #, c-format msgid "NOTICE: there are circular foreign-key constraints on this table:\n" msgid_plural "NOTICE: there are circular foreign-key constraints among these tables:\n" msgstr[0] "AVVISO: ci sono vincoli di dipendenza circolari tra chiavi esterne in questa tabella:\n" msgstr[1] "AVVISO: ci sono vincoli di dipendenza circolari tra chiavi esterne tra queste tabelle:\n" -#: pg_dump_sort.c:1265 pg_dump_sort.c:1285 +#: pg_dump_sort.c:1266 pg_dump_sort.c:1286 #, c-format msgid " %s\n" msgstr " %s\n" -#: pg_dump_sort.c:1266 +#: pg_dump_sort.c:1267 #, c-format msgid "You might not be able to restore the dump without using --disable-triggers or temporarily dropping the constraints.\n" msgstr "Potreste non essere in grado di ripristinare l'archivio senza usare --disable-triggers o eliminare temporaneamente i vincoli.\n" -#: pg_dump_sort.c:1267 +#: pg_dump_sort.c:1268 #, c-format msgid "Consider using a full dump instead of a --data-only dump to avoid this problem.\n" msgstr "Considera l'uso di un salvataggio completo invece di uno --data-only per evitare questo problema.\n" -#: pg_dump_sort.c:1279 +#: pg_dump_sort.c:1280 #, c-format msgid "WARNING: could not resolve dependency loop among these items:\n" msgstr "ATTENZIONE: risoluzione del ciclo di dipendenze tra questi elementi fallito:\n" -#: pg_dumpall.c:182 +#: pg_dumpall.c:180 #, c-format msgid "" "The program \"pg_dump\" is needed by %s but was not found in the\n" @@ -2208,7 +2229,7 @@ msgstr "" "stessa directory di \"%s\".\n" "Verifica che l'installazione sia corretta.\n" -#: pg_dumpall.c:189 +#: pg_dumpall.c:187 #, c-format msgid "" "The program \"pg_dump\" was found by \"%s\"\n" @@ -2219,32 +2240,32 @@ msgstr "" "ma non è la stessa versione di %s.\n" "Controllate la vostra installazione.\n" -#: pg_dumpall.c:319 +#: pg_dumpall.c:317 #, c-format msgid "%s: options -g/--globals-only and -r/--roles-only cannot be used together\n" msgstr "%s: le opzioni -g/--globals-only e -r/--roles-only non possono essere usate insieme\n" -#: pg_dumpall.c:328 +#: pg_dumpall.c:326 #, c-format msgid "%s: options -g/--globals-only and -t/--tablespaces-only cannot be used together\n" msgstr "%s: le opzioni -g/--globals-only e -t/--tablespaces-only non possono essere usate insieme\n" -#: pg_dumpall.c:337 pg_restore.c:345 +#: pg_dumpall.c:335 pg_restore.c:361 #, c-format msgid "%s: option --if-exists requires option -c/--clean\n" msgstr "%s: l'opzione --if-exists richiede l'opzione -c/--clean\n" -#: pg_dumpall.c:344 +#: pg_dumpall.c:342 #, c-format msgid "%s: options -r/--roles-only and -t/--tablespaces-only cannot be used together\n" msgstr "%s: la opzioni -r/--roles-only e -t/--tablespaces-only non possono essere usate insieme\n" -#: pg_dumpall.c:386 pg_dumpall.c:1909 +#: pg_dumpall.c:384 pg_dumpall.c:1995 #, c-format msgid "%s: could not connect to database \"%s\"\n" msgstr "%s: connessione al database \"%s\" fallita\n" -#: pg_dumpall.c:401 +#: pg_dumpall.c:399 #, c-format msgid "" "%s: could not connect to databases \"postgres\" or \"template1\"\n" @@ -2253,12 +2274,12 @@ msgstr "" "%s: non stato è possibile connettersi ai database \"postgres\" o \"template1\"\n" "Specificare un database alternativo.\n" -#: pg_dumpall.c:418 +#: pg_dumpall.c:416 #, c-format msgid "%s: could not open the output file \"%s\": %s\n" msgstr "%s: apertura del file di output \"%s\" fallita: %s\n" -#: pg_dumpall.c:548 +#: pg_dumpall.c:546 #, c-format msgid "" "%s extracts a PostgreSQL database cluster into an SQL script file.\n" @@ -2267,57 +2288,57 @@ msgstr "" "%s estrae un cluster di database PostgreSQL in un file script SQL.\n" "\n" -#: pg_dumpall.c:550 +#: pg_dumpall.c:548 #, c-format msgid " %s [OPTION]...\n" msgstr " %s [OPZIONE]...\n" -#: pg_dumpall.c:553 +#: pg_dumpall.c:551 #, c-format msgid " -f, --file=FILENAME output file name\n" msgstr " -f, --file=NOMEFILE nome file di output\n" -#: pg_dumpall.c:559 +#: pg_dumpall.c:558 #, c-format msgid " -c, --clean clean (drop) databases before recreating\n" msgstr " -c, --clean pulisci (drop) i database prima di ricrearli\n" -#: pg_dumpall.c:560 +#: pg_dumpall.c:559 #, c-format msgid " -g, --globals-only dump only global objects, no databases\n" msgstr " -g, --globals-only scarica solo gli oggetti globali e non i database\n" -#: pg_dumpall.c:562 pg_restore.c:459 +#: pg_dumpall.c:561 pg_restore.c:465 #, c-format msgid " -O, --no-owner skip restoration of object ownership\n" msgstr " -O, --no-owner salta il ripristino del proprietario degli oggetti\n" -#: pg_dumpall.c:563 +#: pg_dumpall.c:562 #, c-format msgid " -r, --roles-only dump only roles, no databases or tablespaces\n" msgstr " -r, --roles-only scarica solo i ruoli e non i database o i tablespace\n" -#: pg_dumpall.c:565 +#: pg_dumpall.c:564 #, c-format msgid " -S, --superuser=NAME superuser user name to use in the dump\n" msgstr " -S, --superuser=NOME nome del superutente da usare nel dump\n" -#: pg_dumpall.c:566 +#: pg_dumpall.c:565 #, c-format msgid " -t, --tablespaces-only dump only tablespaces, no databases or roles\n" msgstr " -t, --tablespaces-only scarica solo i tablespace e non i database o i ruoli\n" -#: pg_dumpall.c:583 +#: pg_dumpall.c:582 #, c-format msgid " -d, --dbname=CONNSTR connect using connection string\n" msgstr " -d, --dbname=STRCONN connettiti usando la stringa di connessione\n" -#: pg_dumpall.c:585 +#: pg_dumpall.c:584 #, c-format msgid " -l, --database=DBNAME alternative default database\n" msgstr " -l, --database=NOMEDB database predefinito alternativo\n" -#: pg_dumpall.c:592 +#: pg_dumpall.c:591 #, c-format msgid "" "\n" @@ -2330,67 +2351,67 @@ msgstr "" "output.\n" "\n" -#: pg_dumpall.c:777 +#: pg_dumpall.c:792 #, c-format -msgid "%s: role name starting with 'pg_' skipped (%s)\n" -msgstr "%s: nome di ruolo (%s) saltato perché inizia con 'pg_'\n" +msgid "%s: role name starting with \"pg_\" skipped (%s)\n" +msgstr "%s: nome di ruolo (%s) saltato perché inizia con \"pg_\"\n" -#: pg_dumpall.c:1128 +#: pg_dumpall.c:1169 #, c-format msgid "%s: could not parse ACL list (%s) for tablespace \"%s\"\n" msgstr "%s: non è stato possibile analizzare la lista ACL (%s) per il tablespace \"%s\"\n" -#: pg_dumpall.c:1459 +#: pg_dumpall.c:1537 #, c-format msgid "%s: could not parse ACL list (%s) for database \"%s\"\n" msgstr "%s: non è stato possibile analizzare la lista ACL (%s) per il database \"%s\"\n" -#: pg_dumpall.c:1676 +#: pg_dumpall.c:1755 #, c-format msgid "%s: dumping database \"%s\"...\n" msgstr "%s: scaricamento del database \"%s\"...\n" -#: pg_dumpall.c:1697 +#: pg_dumpall.c:1779 #, c-format msgid "%s: pg_dump failed on database \"%s\", exiting\n" msgstr "%s: pg_dump fallito per il database \"%s\", in uscita\n" -#: pg_dumpall.c:1706 +#: pg_dumpall.c:1788 #, c-format msgid "%s: could not re-open the output file \"%s\": %s\n" msgstr "%s: riapertura del file di output \"%s\" fallita: %s\n" -#: pg_dumpall.c:1751 +#: pg_dumpall.c:1833 #, c-format msgid "%s: running \"%s\"\n" msgstr "%s: in elaborazione \"%s\"\n" -#: pg_dumpall.c:1931 +#: pg_dumpall.c:2017 #, c-format msgid "%s: could not connect to database \"%s\": %s\n" msgstr "%s: connessione al database \"%s\" fallita: %s\n" -#: pg_dumpall.c:1961 +#: pg_dumpall.c:2047 #, c-format msgid "%s: could not get server version\n" msgstr "%s: non è stato possibile ottenere la versione del server\n" -#: pg_dumpall.c:1967 +#: pg_dumpall.c:2053 #, c-format msgid "%s: could not parse server version \"%s\"\n" msgstr "%s: non è stato possibile analizzare la versione del server \"%s\"\n" -#: pg_dumpall.c:2045 pg_dumpall.c:2071 +#: pg_dumpall.c:2131 pg_dumpall.c:2157 #, c-format msgid "%s: executing %s\n" msgstr "%s: esecuzione di %s\n" -#: pg_dumpall.c:2051 pg_dumpall.c:2077 +#: pg_dumpall.c:2137 pg_dumpall.c:2163 #, c-format msgid "%s: query failed: %s" msgstr "%s: query fallita: %s" -#: pg_dumpall.c:2053 pg_dumpall.c:2079 +#: pg_dumpall.c:2139 pg_dumpall.c:2165 #, c-format msgid "%s: query was: %s\n" msgstr "%s: la query era: %s\n" @@ -2410,27 +2431,32 @@ msgstr "%s: le opzioni -s/--schema-only e -a/--data-only non possono essere usat msgid "%s: options -c/--clean and -a/--data-only cannot be used together\n" msgstr "%s: le opzioni -c/--clean e -a/--data-only non possono essere usate insieme\n" -#: pg_restore.c:331 +#: pg_restore.c:330 +#, c-format +msgid "%s: invalid number of parallel jobs\n" +msgstr "%s: numero di job paralleli non valido\n" + +#: pg_restore.c:338 +#, c-format +msgid "%s: maximum number of parallel jobs is %d\n" +msgstr "%s: il numero massimo di job paralleli è %d\n" + +#: pg_restore.c:347 #, c-format msgid "%s: cannot specify both --single-transaction and multiple jobs\n" msgstr "%s: non si può specificare insieme --single-transaction e job multipli\n" -#: pg_restore.c:372 +#: pg_restore.c:388 #, c-format msgid "unrecognized archive format \"%s\"; please specify \"c\", \"d\", or \"t\"\n" msgstr "formato di archivio sconosciuto \"%s\"; specificare \"c\", \"d\" o \"t\"\n" -#: pg_restore.c:404 -#, c-format -msgid "%s: maximum number of parallel jobs is %d\n" -msgstr "%s: il numero massimo di job paralleli è %d\n" - -#: pg_restore.c:422 +#: pg_restore.c:428 #, c-format msgid "WARNING: errors ignored on restore: %d\n" msgstr "ATTENZIONE: errore ignorato durante il ripristino: %d\n" -#: pg_restore.c:436 +#: pg_restore.c:442 #, c-format msgid "" "%s restores a PostgreSQL database from an archive created by pg_dump.\n" @@ -2439,47 +2465,47 @@ msgstr "" "%s ripristino di un database PostgreSQL da un archivio creato con pg_dump.\n" "\n" -#: pg_restore.c:438 +#: pg_restore.c:444 #, c-format msgid " %s [OPTION]... [FILE]\n" msgstr " %s [OPZIONE]... [FILE]\n" -#: pg_restore.c:441 +#: pg_restore.c:447 #, c-format msgid " -d, --dbname=NAME connect to database name\n" msgstr " -d, --dbname=NOME nome del database a cui connettersi\n" -#: pg_restore.c:442 +#: pg_restore.c:448 #, c-format msgid " -f, --file=FILENAME output file name\n" msgstr " -f, --file=NOMEFILE nome del file di output\n" -#: pg_restore.c:443 +#: pg_restore.c:449 #, c-format msgid " -F, --format=c|d|t backup file format (should be automatic)\n" msgstr " -F, --format=c|d|t formato del file di backup (dovrebbe essere automatico)\n" -#: pg_restore.c:444 +#: pg_restore.c:450 #, c-format msgid " -l, --list print summarized TOC of the archive\n" msgstr " -l, --list stampa un riassunto della TOC dell'archivio\n" -#: pg_restore.c:445 +#: pg_restore.c:451 #, c-format msgid " -v, --verbose verbose mode\n" msgstr " -v, --verbose stampa più informazioni\n" -#: pg_restore.c:446 +#: pg_restore.c:452 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version mostra informazioni sulla versione ed esci\n" -#: pg_restore.c:447 +#: pg_restore.c:453 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help mostra questo aiuto ed esci\n" -#: pg_restore.c:449 +#: pg_restore.c:455 #, c-format msgid "" "\n" @@ -2488,32 +2514,32 @@ msgstr "" "\n" "Opzioni per il controllo del ripristino:\n" -#: pg_restore.c:450 +#: pg_restore.c:456 #, c-format msgid " -a, --data-only restore only the data, no schema\n" msgstr " -a, --data-only ripristina solo i dati, non gli schemi\n" -#: pg_restore.c:452 +#: pg_restore.c:458 #, c-format msgid " -C, --create create the target database\n" msgstr " -C, --create crea il database in oggetto\n" -#: pg_restore.c:453 +#: pg_restore.c:459 #, c-format msgid " -e, --exit-on-error exit on error, default is to continue\n" msgstr " -e, --exit-on-error esci in caso di errore, il comportamento predefinito è continuare\n" -#: pg_restore.c:454 +#: pg_restore.c:460 #, c-format msgid " -I, --index=NAME restore named index\n" msgstr " -I, --index=NOME ripristina l'indice indicato\n" -#: pg_restore.c:455 +#: pg_restore.c:461 #, c-format msgid " -j, --jobs=NUM use this many parallel jobs to restore\n" msgstr " -j, --jobs=NUM per il ripristino usa questo numero di job paralleli\n" -#: pg_restore.c:456 +#: pg_restore.c:462 #, c-format msgid "" " -L, --use-list=FILENAME use table of contents from this file for\n" @@ -2522,52 +2548,52 @@ msgstr "" " -L, --use-list=NOMEFILE utilizza la tabella dei contenuti di questo file per\n" " selezionare/ordinare l'output\n" -#: pg_restore.c:458 +#: pg_restore.c:464 #, c-format msgid " -n, --schema=NAME restore only objects in this schema\n" msgstr " -n, --schema=NOME ripristina solo gli oggetti in questo schema\n" -#: pg_restore.c:460 +#: pg_restore.c:466 #, c-format msgid " -P, --function=NAME(args) restore named function\n" msgstr " -P, --function=NOME(arg) ripristina la funzione indicata\n" -#: pg_restore.c:461 +#: pg_restore.c:467 #, c-format msgid " -s, --schema-only restore only the schema, no data\n" msgstr " -s, --schema-only ripristina solo lo schema e non i dati\n" -#: pg_restore.c:462 +#: pg_restore.c:468 #, c-format msgid " -S, --superuser=NAME superuser user name to use for disabling triggers\n" msgstr " -S, --superuser=NOME nome del superutente da usare per disabilitare i trigger\n" -#: pg_restore.c:463 +#: pg_restore.c:469 #, c-format -msgid " -t, --table=NAME restore named relation (table, view, etc)\n" +msgid " -t, --table=NAME restore named relation (table, view, etc.)\n" msgstr " -t, --table=NOME ripristina la relazione indicata (tabella, vista, ecc.)\n" -#: pg_restore.c:464 +#: pg_restore.c:470 #, c-format msgid " -T, --trigger=NAME restore named trigger\n" msgstr " -T, --trigger=NOME ripristina il trigger indicato\n" -#: pg_restore.c:465 +#: pg_restore.c:471 #, c-format msgid " -x, --no-privileges skip restoration of access privileges (grant/revoke)\n" msgstr " -x, --no-privileges salta il ripristino dei privilegi di accesso (grant/revoke)\n" -#: pg_restore.c:466 +#: pg_restore.c:472 #, c-format msgid " -1, --single-transaction restore as a single transaction\n" msgstr " -1, --single-transaction ripristina in un'unica transazione\n" -#: pg_restore.c:468 +#: pg_restore.c:474 #, c-format msgid " --enable-row-security enable row security\n" msgstr " --enable-row-security abilita la sicurezza per riga\n" -#: pg_restore.c:470 +#: pg_restore.c:476 #, c-format msgid "" " --no-data-for-failed-tables do not restore data of tables that could not be\n" @@ -2576,27 +2602,27 @@ msgstr "" " --no-data-for-failed-tables non ripristinare i dati delle tabelle che non\n" " è stato possibile creare\n" -#: pg_restore.c:472 +#: pg_restore.c:478 #, c-format msgid " --no-security-labels do not restore security labels\n" msgstr " --no-security-labels do ripristinare le etichette di sicurezza\n" -#: pg_restore.c:473 +#: pg_restore.c:479 #, c-format msgid " --no-tablespaces do not restore tablespace assignments\n" msgstr " --no-tablespaces non ripristina le assegnazioni dei tablespace\n" -#: pg_restore.c:474 +#: pg_restore.c:480 #, c-format msgid " --section=SECTION restore named section (pre-data, data, or post-data)\n" msgstr " --section=SEZIONE ripristina la sezione indicata (pre-data, data o post-data)\n" -#: pg_restore.c:487 +#: pg_restore.c:493 #, c-format msgid " --role=ROLENAME do SET ROLE before restore\n" msgstr " --role=NOMERUOLO esegui SET ROLE prima del ripristino\n" -#: pg_restore.c:489 +#: pg_restore.c:495 #, c-format msgid "" "\n" @@ -2607,7 +2633,7 @@ msgstr "" "Le opzioni -I, -n, -P, -t, -T e --section possono essere combinate e specificate\n" "più volte per selezionare più oggetti.\n" -#: pg_restore.c:492 +#: pg_restore.c:498 #, c-format msgid "" "\n" diff --git a/src/bin/pg_dump/po/ja.po b/src/bin/pg_dump/po/ja.po index 980eab6967..0ebce479eb 100644 --- a/src/bin/pg_dump/po/ja.po +++ b/src/bin/pg_dump/po/ja.po @@ -3,11 +3,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.1 beta 2\n" +"Project-Id-Version: PostgreSQL 9.6.3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2013-08-18 11:39+0900\n" +"POT-Creation-Date: 2017-04-04 09:28+0900\n" "PO-Revision-Date: 2013-08-18 12:05+0900\n" -"Last-Translator: HOTTA Michihide \n" +"Last-Translator: Okano Naoki \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -15,215 +15,269 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" -#: ../../common/fe_memutils.c:33 ../../common/fe_memutils.c:60 -#: ../../common/fe_memutils.c:83 pg_backup_db.c:134 pg_backup_db.c:189 -#: pg_backup_db.c:233 pg_backup_db.c:279 -#, c-format -msgid "out of memory\n" -msgstr "メモリä¸è¶³ã§ã™\n" - -#: ../../common/fe_memutils.c:77 -#, c-format -msgid "cannot duplicate null pointer (internal error)\n" -msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" - -#: ../../port/exec.c:127 ../../port/exec.c:241 ../../port/exec.c:284 +#: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format msgid "could not identify current directory: %s" msgstr "ç¾åœ¨ã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’èªè­˜ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: ../../port/exec.c:146 +#: ../../common/exec.c:146 #, c-format msgid "invalid binary \"%s\"" msgstr "ãƒã‚¤ãƒŠãƒª\"%s\"ã¯ç„¡åŠ¹ã§ã™" -#: ../../port/exec.c:195 +#: ../../common/exec.c:195 #, c-format msgid "could not read binary \"%s\"" msgstr "ãƒã‚¤ãƒŠãƒª\"%s\"を読ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ" -#: ../../port/exec.c:202 +#: ../../common/exec.c:202 #, c-format msgid "could not find a \"%s\" to execute" msgstr "実行ã™ã‚‹\"%s\"ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ" -#: ../../port/exec.c:257 ../../port/exec.c:293 +#: ../../common/exec.c:257 ../../common/exec.c:293 #, c-format msgid "could not change directory to \"%s\": %s" msgstr "ディレクトリ\"%s\"ã«ç§»å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: ../../port/exec.c:272 +#: ../../common/exec.c:272 #, c-format msgid "could not read symbolic link \"%s\"" msgstr "シンボリックリンク\"%s\"ã®èª­ã¿å–ã‚Šã«å¤±æ•—ã—ã¾ã—ãŸ" -#: ../../port/exec.c:523 +#: ../../common/exec.c:523 #, c-format msgid "pclose failed: %s" msgstr "pcloseãŒå¤±æ•—ã—ã¾ã—ãŸ: %s" -#: common.c:105 +#: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 +#: ../../common/fe_memutils.c:98 pg_backup_db.c:158 pg_backup_db.c:213 +#: pg_backup_db.c:272 pg_backup_db.c:314 #, c-format -msgid "reading schemas\n" -msgstr "スキーマを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" +msgid "out of memory\n" +msgstr "メモリä¸è¶³ã§ã™\n" -#: common.c:116 +#: ../../common/fe_memutils.c:92 #, c-format -msgid "reading user-defined tables\n" -msgstr "ユーザ定義ã®ãƒ†ãƒ¼ãƒ–ルを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" +msgid "cannot duplicate null pointer (internal error)\n" +msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" + +#: ../../common/wait_error.c:47 +#, c-format +msgid "command not executable" +msgstr "コマンドã¯å®Ÿè¡Œå½¢å¼ã§ã¯ã‚ã‚Šã¾ã›ã‚“" + +#: ../../common/wait_error.c:51 +#, c-format +msgid "command not found" +msgstr "コマンドãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“" -#: common.c:124 +#: ../../common/wait_error.c:56 +#, c-format +msgid "child process exited with exit code %d" +msgstr "å­ãƒ—ロセスãŒçµ‚了コード%dã§çµ‚了ã—ã¾ã—ãŸ" + +#: ../../common/wait_error.c:63 +#, c-format +msgid "child process was terminated by exception 0x%X" +msgstr "å­ãƒ—ロセスãŒä¾‹å¤–0x%Xã§çµ‚了ã—ã¾ã—ãŸ" + +#: ../../common/wait_error.c:73 +#, c-format +msgid "child process was terminated by signal %s" +msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%sã§çµ‚了ã—ã¾ã—ãŸ" + +#: ../../common/wait_error.c:77 +#, c-format +msgid "child process was terminated by signal %d" +msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%dã§çµ‚了ã—ã¾ã—ãŸ" + +#: ../../common/wait_error.c:82 +#, c-format +msgid "child process exited with unrecognized status %d" +msgstr "å­ãƒ—ロセスãŒæœªçŸ¥ã®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹%dã§çµ‚了ã—ã¾ã—ãŸ" + +#: common.c:121 #, c-format msgid "reading extensions\n" msgstr "拡張を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:128 +#: common.c:126 +#, c-format +msgid "identifying extension members\n" +msgstr "æ‹¡å¼µã®ãƒ¡ãƒ³ãƒã‚’識別ã—ã¦ã„ã¾ã™\n" + +#: common.c:130 +#, c-format +msgid "reading schemas\n" +msgstr "スキーマを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: common.c:141 +#, c-format +msgid "reading user-defined tables\n" +msgstr "ユーザ定義ã®ãƒ†ãƒ¼ãƒ–ルを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: common.c:149 #, c-format msgid "reading user-defined functions\n" msgstr "ユーザ定義関数を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:134 +#: common.c:155 #, c-format msgid "reading user-defined types\n" msgstr "ユーザ定義型を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:140 +#: common.c:161 #, c-format msgid "reading procedural languages\n" msgstr "手続ã言語を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:144 +#: common.c:165 #, c-format msgid "reading user-defined aggregate functions\n" msgstr "ユーザ定義ã®é›†ç´„関数を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:148 +#: common.c:169 #, c-format msgid "reading user-defined operators\n" msgstr "ユーザ定義演算å­ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:153 +#: common.c:174 +#, c-format +msgid "reading user-defined access methods\n" +msgstr "ユーザ定義ã®ã‚¢ã‚¯ã‚»ã‚¹ãƒ¡ã‚½ãƒƒãƒ‰ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: common.c:178 #, c-format msgid "reading user-defined operator classes\n" msgstr "ユーザ定義ã®æ¼”ç®—å­ã‚¯ãƒ©ã‚¹ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:157 +#: common.c:182 #, c-format msgid "reading user-defined operator families\n" msgstr "ユーザ定義ã®æ¼”ç®—å­ç¾¤ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:161 +#: common.c:186 #, c-format msgid "reading user-defined text search parsers\n" msgstr "ユーザ定義テキスト検索パーサを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:165 +#: common.c:190 #, c-format msgid "reading user-defined text search templates\n" msgstr "ユーザ定義ã®ãƒ†ã‚­ã‚¹ãƒˆæ¤œç´¢ãƒ†ãƒ³ãƒ—レートを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:169 +#: common.c:194 #, c-format msgid "reading user-defined text search dictionaries\n" msgstr "ユーザ定義ã®ãƒ†ã‚­ã‚¹ãƒˆæ¤œç´¢è¾žæ›¸ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:173 +#: common.c:198 #, c-format msgid "reading user-defined text search configurations\n" msgstr "ユーザ定義ã®ãƒ†ã‚­ã‚¹ãƒˆæ¤œç´¢è¨­å®šã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:177 +#: common.c:202 #, c-format msgid "reading user-defined foreign-data wrappers\n" msgstr "ユーザ定義ã®å¤–国語データラッパーを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:181 +#: common.c:206 #, c-format msgid "reading user-defined foreign servers\n" msgstr "ユーザ定義ã®å¤–国語サーãƒãƒ¼ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:185 +#: common.c:210 #, c-format msgid "reading default privileges\n" msgstr "デフォルトã®æ¨©é™è¨­å®šã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:189 +#: common.c:214 #, c-format msgid "reading user-defined collations\n" msgstr "ユーザ定義ã®ç…§åˆé †åºã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:194 +#: common.c:219 #, c-format msgid "reading user-defined conversions\n" msgstr "ユーザ定義ã®å¤‰æ›ãƒ«ãƒ¼ãƒãƒ³ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:198 +#: common.c:223 #, c-format msgid "reading type casts\n" msgstr "型キャストを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:202 +#: common.c:227 +#, c-format +msgid "reading transforms\n" +msgstr "変æ›ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: common.c:231 #, c-format msgid "reading table inheritance information\n" msgstr "テーブルã®ç¶™æ‰¿æƒ…報を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:206 +#: common.c:235 #, c-format -#| msgid "reading triggers\n" msgid "reading event triggers\n" msgstr "イベントトリガを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:215 +#: common.c:240 #, c-format -msgid "finding extension members\n" -msgstr "æ‹¡å¼µã®ãƒ¡ãƒ³ãƒã‚’探ã—ã¦ã„ã¾ã™\n" +msgid "finding extension tables\n" +msgstr "æ‹¡å¼µã®ãƒ†ãƒ¼ãƒ–ルを探ã—ã¦ã„ã¾ã™\n" -#: common.c:220 +#: common.c:245 #, c-format msgid "finding inheritance relationships\n" msgstr "継承関係を検索ã—ã¦ã„ã¾ã™\n" -#: common.c:224 +#: common.c:249 #, c-format msgid "reading column info for interesting tables\n" msgstr "継承テーブル用ã®åˆ—情報を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:228 +#: common.c:253 #, c-format msgid "flagging inherited columns in subtables\n" msgstr "å­ãƒ†ãƒ¼ãƒ–ルã®ç¶™æ‰¿åˆ—ã«ãƒ•ãƒ©ã‚°ã‚’設定ã—ã¦ã„ã¾ã™\n" -#: common.c:232 +#: common.c:257 #, c-format msgid "reading indexes\n" msgstr "インデックスを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:236 +#: common.c:261 #, c-format msgid "reading constraints\n" msgstr "制約を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:240 +#: common.c:265 #, c-format msgid "reading triggers\n" msgstr "トリガを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:244 +#: common.c:269 #, c-format msgid "reading rewrite rules\n" msgstr "書ãæ›ãˆãƒ«ãƒ¼ãƒ«ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: common.c:792 +#: common.c:273 +#, c-format +msgid "reading policies\n" +msgstr "ãƒãƒªã‚·ãƒ¼ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: common.c:908 #, c-format msgid "failed sanity check, parent OID %u of table \"%s\" (OID %u) not found\n" msgstr "å¥å…¨æ€§æ¤œæŸ»ã«å¤±æ•—ã—ã¾ã—ãŸã€‚テーブル\"%2$s\"(OID %3$u)ã®è¦ªã®OID %1$uãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: common.c:834 +#: common.c:950 #, c-format msgid "could not parse numeric array \"%s\": too many numbers\n" msgstr "数値é…列 \"%s\" ã®è§£æžã«å¤±æ•—ã—ã¾ã—ãŸ:æ¡æ•°ãŒå¤§ãã™ãŽã¾ã™\n" -#: common.c:849 +#: common.c:965 #, c-format msgid "could not parse numeric array \"%s\": invalid character in number\n" msgstr "数値é…列 \"%s\" ã®è§£æžã«å¤±æ•—ã—ã¾ã—ãŸ:æ•°ã«ç„¡åŠ¹ãªæ–‡å­—ãŒã‚ã‚Šã¾ã™\n" @@ -238,78 +292,69 @@ msgstr "compress_io" msgid "invalid compression code: %d\n" msgstr "無効ãªåœ§ç¸®ã‚³ãƒ¼ãƒ‰: %d\n" -#: compress_io.c:138 compress_io.c:174 compress_io.c:195 compress_io.c:528 -#: compress_io.c:555 +#: compress_io.c:138 compress_io.c:174 compress_io.c:192 compress_io.c:519 +#: compress_io.c:562 #, c-format msgid "not built with zlib support\n" msgstr "zlibサãƒãƒ¼ãƒˆãŒãªã„ビルドã§ã™ã€‚\n" -#: compress_io.c:243 compress_io.c:352 +#: compress_io.c:242 compress_io.c:344 #, c-format msgid "could not initialize compression library: %s\n" msgstr "圧縮ライブラリをåˆæœŸåŒ–ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: compress_io.c:264 +#: compress_io.c:263 #, c-format msgid "could not close compression stream: %s\n" msgstr "圧縮用ストリームをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: compress_io.c:282 +#: compress_io.c:281 #, c-format msgid "could not compress data: %s\n" msgstr "データを圧縮ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: compress_io.c:303 compress_io.c:440 pg_backup_archiver.c:1437 -#: pg_backup_archiver.c:1460 pg_backup_custom.c:661 pg_backup_directory.c:529 -#: pg_backup_tar.c:598 pg_backup_tar.c:1087 pg_backup_tar.c:1308 -#, c-format -msgid "could not write to output file: %s\n" -msgstr "出力ファイルã«æ›¸ãè¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: compress_io.c:372 compress_io.c:388 +#: compress_io.c:361 compress_io.c:377 #, c-format msgid "could not uncompress data: %s\n" msgstr "データを伸長ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: compress_io.c:396 +#: compress_io.c:385 #, c-format msgid "could not close compression library: %s\n" msgstr "圧縮ライブラリをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: parallel.c:77 -#| msgid "tar archiver" +#: compress_io.c:596 compress_io.c:632 pg_backup_custom.c:591 +#: pg_backup_tar.c:561 +#, c-format +msgid "could not read from input file: %s\n" +msgstr "入力ファイルã‹ã‚‰èª­ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: compress_io.c:635 pg_backup_custom.c:588 pg_backup_directory.c:548 +#: pg_backup_tar.c:797 pg_backup_tar.c:821 +#, c-format +msgid "could not read from input file: end of file\n" +msgstr "入力ファイルã‹ã‚‰èª­ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: ファイルã®çµ‚了ã§ã™\n" + +#: parallel.c:167 msgid "parallel archiver" msgstr "並行アーカイãƒ" -#: parallel.c:143 +#: parallel.c:231 #, c-format msgid "%s: WSAStartup failed: %d\n" msgstr "%s: WSAStartupãŒå¤±æ•—ã—ã¾ã—ãŸ: %d\n" -#: parallel.c:343 +#: parallel.c:934 #, c-format -#| msgid "server is still starting up\n" -msgid "worker is terminating\n" -msgstr "ワーカを終了ã—ã¦ã„ã¾ã™\n" - -#: parallel.c:535 -#, c-format -#| msgid "could not create SSL context: %s\n" msgid "could not create communication channels: %s\n" msgstr "通信ãƒãƒ£ãƒ³ãƒãƒ«ã‚’作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: parallel.c:605 +#: parallel.c:997 #, c-format msgid "could not create worker process: %s\n" msgstr "ワーカープロセスを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: parallel.c:822 -#, c-format -#| msgid "could not get junction for \"%s\": %s\n" -msgid "could not get relation name for OID %u: %s\n" -msgstr "OID %uã®ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³åを入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: parallel.c:839 +#: parallel.c:1192 #, c-format msgid "" "could not obtain lock on relation \"%s\"\n" @@ -318,628 +363,616 @@ msgstr "" "リレーション\"%s\"ã«å¯¾ã™ã‚‹ãƒ­ãƒƒã‚¯ã‚’ç²å¾—ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚\n" "通常ã“ã‚Œã¯ã€pg_dumpã®è¦ªãƒ—ロセスãŒåˆæœŸã®ACCESS SHAREロックを入手ã—ãŸå¾Œã«ã ã‚Œã‹ãŒãƒ†ãƒ¼ãƒ–ルã«å¯¾ã—ã¦ACCESS EXCLUSIVEロックをè¦æ±‚ã—ãŸã“ã¨ã‚’æ„味ã—ã¦ã„ã¾ã™ã€‚\n" -#: parallel.c:923 +#: parallel.c:1262 #, c-format -#| msgid "unrecognized authentication option name: \"%s\"" -msgid "unrecognized command on communication channel: %s\n" -msgstr "通信ãƒãƒ£ãƒ³ãƒãƒ«ä¸Šã§èªè­˜ã§ããªã„コマンド: \"%s\"\n" +msgid "unrecognized command received from master: \"%s\"\n" +msgstr "マスタã‹ã‚‰å—ã‘å–ã£ãŸã‚³ãƒžãƒ³ãƒ‰ãŒä¸æ˜Žã§ã™: \"%s\"\n" -#: parallel.c:956 +#: parallel.c:1300 #, c-format -#| msgid "worker process failed: exit code %d\n" msgid "a worker process died unexpectedly\n" msgstr "ワーカープロセスãŒæƒ³å®šå¤–ã«çµ‚了ã—ã¾ã—ãŸ\n" -#: parallel.c:983 parallel.c:992 +#: parallel.c:1326 parallel.c:1332 #, c-format -#| msgid "could not receive data from server: %s\n" -msgid "invalid message received from worker: %s\n" -msgstr "ワーカã‹ã‚‰ç„¡åŠ¹ãªãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã‚’å—ä¿¡ã—ã¾ã—ãŸ: %s\n" +msgid "invalid message received from worker: \"%s\"\n" +msgstr "ワーカã‹ã‚‰ç„¡åŠ¹ãªãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã‚’å—ä¿¡ã—ã¾ã—ãŸ: \"%s\"\n" -#: parallel.c:989 pg_backup_db.c:336 -#, c-format -msgid "%s" -msgstr "%s" - -#: parallel.c:1041 parallel.c:1085 +#: parallel.c:1389 parallel.c:1440 #, c-format msgid "error processing a parallel work item\n" msgstr "並行作業項目ã®å‡¦ç†ã§ã‚¨ãƒ©ãƒ¼\n" -#: parallel.c:1113 parallel.c:1251 +#: parallel.c:1469 parallel.c:1587 #, c-format -#| msgid "could not write to output file: %s\n" msgid "could not write to the communication channel: %s\n" msgstr "通信ãƒãƒ£ãƒ³ãƒãƒ«ã«æ›¸ãè¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: parallel.c:1162 -#, c-format -#| msgid "unterminated quoted string\n" -msgid "terminated by user\n" -msgstr "ユーザã«ã‚ˆã‚Šçµ‚了ã—ã¾ã—ãŸ\n" - -#: parallel.c:1214 +#: parallel.c:1547 #, c-format -#| msgid "error during file seek: %s\n" -msgid "error in ListenToWorkers(): %s\n" -msgstr "ListenToWorkers()ã§ã®ã‚¨ãƒ©ãƒ¼: %s\n" +msgid "select() failed: %s\n" +msgstr "select()ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: parallel.c:1325 +#: parallel.c:1672 #, c-format -#| msgid "could not create inherited socket: error code %d\n" msgid "pgpipe: could not create socket: error code %d\n" msgstr "pgpipe: ソケットを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: エラーコード %d\n" -#: parallel.c:1336 +#: parallel.c:1683 #, c-format -#| msgid "could not initialize LDAP: error code %d" msgid "pgpipe: could not bind: error code %d\n" msgstr "pgpipe: ãƒã‚¤ãƒ³ãƒ‰ã§ãã¾ã›ã‚“ã§ã—ãŸ: エラーコード %d\n" -#: parallel.c:1343 +#: parallel.c:1690 #, c-format -#| msgid "%s: could not allocate SIDs: error code %lu\n" msgid "pgpipe: could not listen: error code %d\n" msgstr "pgpipe: リッスンã§ãã¾ã›ã‚“ã§ã—ãŸ: エラーコード %d\n" -#: parallel.c:1350 +#: parallel.c:1697 #, c-format -#| msgid "worker process failed: exit code %d\n" msgid "pgpipe: getsockname() failed: error code %d\n" msgstr "pgpipe: getsockname()ãŒå¤±æ•—ã—ã¾ã—ãŸ: エラーコード %d\n" -#: parallel.c:1357 +#: parallel.c:1708 #, c-format -#| msgid "could not create inherited socket: error code %d\n" msgid "pgpipe: could not create second socket: error code %d\n" msgstr "pgpipe: 第二ソケットを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: エラーコード %d\n" -#: parallel.c:1365 +#: parallel.c:1717 #, c-format -#| msgid "could not create inherited socket: error code %d\n" msgid "pgpipe: could not connect socket: error code %d\n" msgstr "pgpipe: ソケットを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: エラーコード %d\n" -#: parallel.c:1372 +#: parallel.c:1726 #, c-format -#| msgid "could not accept SSL connection: %m" msgid "pgpipe: could not accept connection: error code %d\n" msgstr "pgpipe: 接続をå—ã‘付ã‘られã¾ã›ã‚“ã§ã—ãŸ: エラーコード %d\n" #. translator: this is a module name -#: pg_backup_archiver.c:51 +#: pg_backup_archiver.c:55 msgid "archiver" msgstr "アーカイãƒ" -#: pg_backup_archiver.c:169 pg_backup_archiver.c:1300 +#: pg_backup_archiver.c:234 pg_backup_archiver.c:1563 #, c-format msgid "could not close output file: %s\n" msgstr "出力ファイルをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:204 pg_backup_archiver.c:209 +#: pg_backup_archiver.c:280 pg_backup_archiver.c:285 #, c-format msgid "WARNING: archive items not in correct section order\n" msgstr "警告: アーカイブ項目ãŒæ­£ç¢ºã«ã‚»ã‚¯ã‚·ãƒ§ãƒ³é †ã§ã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: pg_backup_archiver.c:215 +#: pg_backup_archiver.c:291 #, c-format msgid "unexpected section code %d\n" msgstr "想定外ã®ã‚»ã‚¯ã‚·ãƒ§ãƒ³ã‚³ãƒ¼ãƒ‰ %d\n" -#: pg_backup_archiver.c:247 +#: pg_backup_archiver.c:327 #, c-format msgid "-C and -1 are incompatible options\n" msgstr "-C 㨠-1 ã¯äº’æ›æ€§ãŒã‚ã‚Šã¾ã›ã‚“\n" -#: pg_backup_archiver.c:257 +#: pg_backup_archiver.c:337 #, c-format msgid "parallel restore is not supported with this archive file format\n" msgstr "ã“ã®ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ファイルフォーマットã§ã¯ä¸¦åˆ—リストアをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_archiver.c:261 +#: pg_backup_archiver.c:341 #, c-format msgid "parallel restore is not supported with archives made by pre-8.0 pg_dump\n" msgstr "8.0 以å‰ã® pg_dump ã§ä½œã‚‰ã‚ŒãŸã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ã§ã¯ä¸¦åˆ—リストアをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_archiver.c:279 +#: pg_backup_archiver.c:359 #, c-format msgid "cannot restore from compressed archive (compression not supported in this installation)\n" msgstr "圧縮ã•ã‚ŒãŸã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ã‹ã‚‰ãƒªã‚¹ãƒˆã‚¢ã§ãã¾ã›ã‚“(å°Žå…¥ã•ã‚ŒãŸãƒã‚¤ãƒŠãƒªã«ã¯åœ§ç¸®æ©Ÿèƒ½ã®ã‚µãƒãƒ¼ãƒˆãŒçµ„ã¿è¾¼ã¾ã‚Œã¦ã„ã¾ã›ã‚“)\n" -#: pg_backup_archiver.c:296 +#: pg_backup_archiver.c:376 #, c-format msgid "connecting to database for restore\n" msgstr "リストアã®ãŸã‚ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«æŽ¥ç¶šã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:298 +#: pg_backup_archiver.c:378 #, c-format msgid "direct database connections are not supported in pre-1.3 archives\n" msgstr "1.3以å‰ã®ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ã§ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¸ã®ç›´æŽ¥æŽ¥ç¶šã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_archiver.c:339 +#: pg_backup_archiver.c:423 #, c-format msgid "implied data-only restore\n" msgstr "データã®ã¿ã®ãƒªã‚¹ãƒˆã‚¢ã‚’目的ã¨ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:408 +#: pg_backup_archiver.c:493 #, c-format msgid "dropping %s %s\n" msgstr "%s %sを削除ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:475 +#: pg_backup_archiver.c:586 +#, c-format +msgid "WARNING: could not find where to insert IF EXISTS in statement \"%s\"\n" +msgstr "警告: æ–‡\"%s\"ã«IF EXISTSを挿入ã™ã‚‹å ´æ‰€ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" + +#: pg_backup_archiver.c:662 #, c-format -msgid "setting owner and privileges for %s %s\n" -msgstr "%s %s用ã®æ‰€æœ‰è€…ã¨æ¨©é™ã‚’設定ã—ã¦ã„ã¾ã™\n" +msgid "setting owner and privileges for %s \"%s.%s\"\n" +msgstr "%s \"%s.%s\"用ã®æ‰€æœ‰è€…ã¨æ¨©é™ã‚’設定ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:541 pg_backup_archiver.c:543 +#: pg_backup_archiver.c:665 +#, c-format +msgid "setting owner and privileges for %s \"%s\"\n" +msgstr "%s \"%s\"用ã®æ‰€æœ‰è€…ã¨æ¨©é™ã‚’設定ã—ã¦ã„ã¾ã™\n" + +#: pg_backup_archiver.c:731 pg_backup_archiver.c:733 #, c-format msgid "warning from original dump file: %s\n" msgstr "オリジナルã®ãƒ€ãƒ³ãƒ—ファイルã®è­¦å‘Š: %s\n" -#: pg_backup_archiver.c:550 +#: pg_backup_archiver.c:742 #, c-format -msgid "creating %s %s\n" -msgstr "%s %sを作æˆã—ã¦ã„ã¾ã™\n" +msgid "creating %s \"%s.%s\"\n" +msgstr "%s \"%s.%s\"を作æˆã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:594 +#: pg_backup_archiver.c:745 +#, c-format +msgid "creating %s \"%s\"\n" +msgstr "%s \"%s\"を作æˆã—ã¦ã„ã¾ã™\n" + +#: pg_backup_archiver.c:797 #, c-format msgid "connecting to new database \"%s\"\n" msgstr "æ–°ã—ã„データベース\"%s\"ã«æŽ¥ç¶šã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:622 +#: pg_backup_archiver.c:825 #, c-format -#| msgid "restoring %s\n" msgid "processing %s\n" msgstr "%sを処ç†ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:636 +#: pg_backup_archiver.c:845 #, c-format -#| msgid "restoring data for table \"%s\"\n" -msgid "processing data for table \"%s\"\n" -msgstr "テーブル\"%s\"ã®ãƒ‡ãƒ¼ã‚¿ã‚’処ç†ã—ã¦ã„ã¾ã™\n" +msgid "processing data for table \"%s.%s\"\n" +msgstr "テーブル \"%s.%s\"ã®ãƒ‡ãƒ¼ã‚¿ã‚’処ç†ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:698 +#: pg_backup_archiver.c:907 #, c-format msgid "executing %s %s\n" msgstr "%s %sを実行ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:735 +#: pg_backup_archiver.c:946 #, c-format msgid "disabling triggers for %s\n" msgstr "%sã®ãƒˆãƒªã‚¬ã‚’無効ã«ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:761 +#: pg_backup_archiver.c:974 #, c-format msgid "enabling triggers for %s\n" msgstr "%sã®ãƒˆãƒªã‚¬ã‚’有効ã«ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:791 +#: pg_backup_archiver.c:1004 #, c-format msgid "internal error -- WriteData cannot be called outside the context of a DataDumper routine\n" msgstr "内部的エラー -- WriteDataã¯DataDumper処ç†ã®ã‚³ãƒ³ãƒ†ã‚­ã‚¹ãƒˆå¤–部ã§ã¯å‘¼ã³å‡ºã™ã“ã¨ãŒã§ãã¾ã›ã‚“\n" -#: pg_backup_archiver.c:948 +#: pg_backup_archiver.c:1201 #, c-format msgid "large-object output not supported in chosen format\n" msgstr "é¸æŠžã—ãŸæ›¸å¼ã§ã¯ãƒ©ãƒ¼ã‚¸ã‚ªãƒ–ジェクト出力をサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_archiver.c:1002 +#: pg_backup_archiver.c:1259 #, c-format msgid "restored %d large object\n" msgid_plural "restored %d large objects\n" msgstr[0] "%d個ã®ãƒ©ãƒ¼ã‚¸ã‚ªãƒ–ジェクトをリストアã—ã¾ã—ãŸ\n" msgstr[1] "%d個ã®ãƒ©ãƒ¼ã‚¸ã‚ªãƒ–ジェクトをリストアã—ã¾ã—ãŸ\n" -#: pg_backup_archiver.c:1023 pg_backup_tar.c:731 +#: pg_backup_archiver.c:1280 pg_backup_tar.c:739 #, c-format msgid "restoring large object with OID %u\n" msgstr "OID %uã®ãƒ©ãƒ¼ã‚¸ã‚ªãƒ–ジェクトをリストアã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:1035 +#: pg_backup_archiver.c:1292 #, c-format msgid "could not create large object %u: %s" msgstr "ラージオブジェクト %u を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_backup_archiver.c:1040 pg_dump.c:2662 +#: pg_backup_archiver.c:1297 pg_dump.c:3093 #, c-format msgid "could not open large object %u: %s" msgstr "ラージオブジェクト %u をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_backup_archiver.c:1097 +#: pg_backup_archiver.c:1355 #, c-format msgid "could not open TOC file \"%s\": %s\n" msgstr "TOCファイル\"%s\"をオープンã§ãã¾ã›ã‚“ã§ã—ãŸï¼š%s\n" -#: pg_backup_archiver.c:1138 +#: pg_backup_archiver.c:1396 #, c-format msgid "WARNING: line ignored: %s\n" msgstr "警告: 行を無視ã—ã¾ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1145 +#: pg_backup_archiver.c:1403 #, c-format msgid "could not find entry for ID %d\n" msgstr "ID %dã®ã‚¨ãƒ³ãƒˆãƒªãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_archiver.c:1166 pg_backup_directory.c:222 -#: pg_backup_directory.c:595 +#: pg_backup_archiver.c:1424 pg_backup_directory.c:230 +#: pg_backup_directory.c:597 #, c-format msgid "could not close TOC file: %s\n" msgstr "TOCファイルをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1270 pg_backup_custom.c:161 pg_backup_directory.c:333 -#: pg_backup_directory.c:581 pg_backup_directory.c:639 -#: pg_backup_directory.c:659 +#: pg_backup_archiver.c:1533 pg_backup_custom.c:162 pg_backup_directory.c:341 +#: pg_backup_directory.c:583 pg_backup_directory.c:641 +#: pg_backup_directory.c:661 #, c-format msgid "could not open output file \"%s\": %s\n" msgstr "出力ファイル \"%s\" をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1273 pg_backup_custom.c:168 +#: pg_backup_archiver.c:1536 pg_backup_custom.c:169 #, c-format msgid "could not open output file: %s\n" msgstr "出力ファイルをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1373 +#: pg_backup_archiver.c:1642 #, c-format msgid "wrote %lu byte of large object data (result = %lu)\n" msgid_plural "wrote %lu bytes of large object data (result = %lu)\n" msgstr[0] "ラージオブジェクトã®%luãƒã‚¤ãƒˆã‚’書ã出ã—ã¾ã—ãŸ(çµæžœã¯%lu)\n" msgstr[1] "ラージオブジェクトã®%luãƒã‚¤ãƒˆã‚’書ã出ã—ã¾ã—ãŸ(çµæžœã¯%lu)\n" -#: pg_backup_archiver.c:1379 +#: pg_backup_archiver.c:1648 #, c-format msgid "could not write to large object (result: %lu, expected: %lu)\n" msgstr "ラージオブジェクトを書ã出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ(çµæžœã¯%luã€æœŸå¾…値ã¯%lu)\n" -#: pg_backup_archiver.c:1445 -#, c-format -msgid "could not write to custom output routine\n" -msgstr "カスタム出力処ç†ã«æ›¸ã出ã›ã¾ã›ã‚“ã§ã—ãŸ\n" - -#: pg_backup_archiver.c:1483 +#: pg_backup_archiver.c:1741 #, c-format msgid "Error while INITIALIZING:\n" msgstr "åˆæœŸå‡¦ç†ä¸­ã«ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã—ãŸ:\n" -#: pg_backup_archiver.c:1488 +#: pg_backup_archiver.c:1746 #, c-format msgid "Error while PROCESSING TOC:\n" msgstr "TOC処ç†ä¸­ã«ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã—ãŸ:\n" -#: pg_backup_archiver.c:1493 +#: pg_backup_archiver.c:1751 #, c-format msgid "Error while FINALIZING:\n" msgstr "後処ç†ä¸­ã«ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã—ãŸ:\n" -#: pg_backup_archiver.c:1498 +#: pg_backup_archiver.c:1756 #, c-format msgid "Error from TOC entry %d; %u %u %s %s %s\n" msgstr "TOCエントリ%d; %u %u %s %s %sã®ã‚¨ãƒ©ãƒ¼ã§ã™\n" -#: pg_backup_archiver.c:1571 +#: pg_backup_archiver.c:1829 #, c-format msgid "bad dumpId\n" msgstr "ä¸è‰¯dumpId\n" -#: pg_backup_archiver.c:1592 +#: pg_backup_archiver.c:1850 #, c-format msgid "bad table dumpId for TABLE DATA item\n" msgstr "TABLE DATAé …ç›®ã«å¯¾ã™ã‚‹ä¸è‰¯ãƒ†ãƒ¼ãƒ–ルdumpId\n" -#: pg_backup_archiver.c:1684 +#: pg_backup_archiver.c:1942 #, c-format msgid "unexpected data offset flag %d\n" msgstr "想定外ã®ãƒ‡ãƒ¼ã‚¿ã‚ªãƒ•ã‚»ãƒƒãƒˆãƒ•ãƒ©ã‚° %d ã§ã™\n" -#: pg_backup_archiver.c:1697 +#: pg_backup_archiver.c:1955 #, c-format msgid "file offset in dump file is too large\n" msgstr "ダンプファイルã®ãƒ•ã‚¡ã‚¤ãƒ«ã‚ªãƒ•ã‚»ãƒƒãƒˆãŒå¤§ãã™ãŽã¾ã™\n" -#: pg_backup_archiver.c:1791 pg_backup_archiver.c:3224 pg_backup_custom.c:639 -#: pg_backup_directory.c:509 pg_backup_tar.c:787 -#, c-format -msgid "unexpected end of file\n" -msgstr "想定外ã®ãƒ•ã‚¡ã‚¤ãƒ«çµ‚端ã§ã™\n" - -#: pg_backup_archiver.c:1808 +#: pg_backup_archiver.c:2068 #, c-format msgid "attempting to ascertain archive format\n" msgstr "アーカイブ書å¼ã®ç¢ºèªã‚’試んã§ã„ã¾ã™\n" -#: pg_backup_archiver.c:1834 pg_backup_archiver.c:1844 +#: pg_backup_archiver.c:2094 pg_backup_archiver.c:2104 #, c-format msgid "directory name too long: \"%s\"\n" msgstr "ディレクトリå称ãŒé•·ã™ãŽã¾ã™: \"%s\"\n" -#: pg_backup_archiver.c:1852 +#: pg_backup_archiver.c:2112 #, c-format msgid "directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does not exist)\n" msgstr "\"%s\"ディレクトリã¯æœ‰åŠ¹ãªã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ã§ã¯ãªã„よã†ã§ã™ï¼ˆ\"\"toc.dat\"ãŒã‚ã‚Šã¾ã›ã‚“）\n" -#: pg_backup_archiver.c:1860 pg_backup_custom.c:180 pg_backup_custom.c:771 -#: pg_backup_directory.c:206 pg_backup_directory.c:394 +#: pg_backup_archiver.c:2120 pg_backup_custom.c:181 pg_backup_custom.c:770 +#: pg_backup_directory.c:214 pg_backup_directory.c:399 #, c-format msgid "could not open input file \"%s\": %s\n" msgstr "入力ファイル \"%s\" をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1868 pg_backup_custom.c:187 +#: pg_backup_archiver.c:2128 pg_backup_custom.c:188 #, c-format msgid "could not open input file: %s\n" msgstr "入力ファイルをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1877 +#: pg_backup_archiver.c:2135 #, c-format msgid "could not read input file: %s\n" msgstr "入力ファイルを読ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1879 +#: pg_backup_archiver.c:2137 #, c-format msgid "input file is too short (read %lu, expected 5)\n" msgstr "入力ファイルãŒå°ã•ã™ãŽã¾ã™(読ã¿å–ã‚Š%luã€æœŸå¾…値 5)\n" -#: pg_backup_archiver.c:1944 +#: pg_backup_archiver.c:2220 #, c-format msgid "input file appears to be a text format dump. Please use psql.\n" msgstr "入力ファイルãŒãƒ†ã‚­ã‚¹ãƒˆå½¢å¼ã®ãƒ€ãƒ³ãƒ—ã®ã‚ˆã†ã§ã™ã€‚psqlを使用ã—ã¦ãã ã•ã„\n" -#: pg_backup_archiver.c:1948 +#: pg_backup_archiver.c:2226 #, c-format msgid "input file does not appear to be a valid archive (too short?)\n" msgstr "入力ファイルãŒæœ‰åŠ¹ãªã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ã§ã¯ãªã„よã†ã§ã™(å°ã•ã™ãŽã‚‹?)\n" -#: pg_backup_archiver.c:1951 +#: pg_backup_archiver.c:2232 #, c-format msgid "input file does not appear to be a valid archive\n" msgstr "入力ファイルãŒæœ‰åŠ¹ãªã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ã§ã¯ãªã„よã†ã§ã™\n" -#: pg_backup_archiver.c:1971 +#: pg_backup_archiver.c:2252 #, c-format msgid "could not close input file: %s\n" msgstr "入力ファイルをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_archiver.c:1988 +#: pg_backup_archiver.c:2269 #, c-format msgid "allocating AH for %s, format %d\n" msgstr "%sã«AHを割り当ã¦ã¦ã„ã¾ã™ã€‚書å¼ã¯%dã§ã™\n" -#: pg_backup_archiver.c:2093 +#: pg_backup_archiver.c:2374 #, c-format msgid "unrecognized file format \"%d\"\n" msgstr "ファイル書å¼\"%d\"ã¯ä¸æ˜Žã§ã™\n" -#: pg_backup_archiver.c:2243 +#: pg_backup_archiver.c:2530 #, c-format msgid "entry ID %d out of range -- perhaps a corrupt TOC\n" msgstr "エントリID %dã¯ç¯„囲外ã§ã™ -- TOCã®ç ´æã®å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™\n" -#: pg_backup_archiver.c:2359 +#: pg_backup_archiver.c:2646 #, c-format msgid "read TOC entry %d (ID %d) for %s %s\n" msgstr "%3$s %4$s用ã«TOCエントリ%1$d(ID %2$d)を読ã¿è¾¼ã¿ã¾ã—ãŸ\n" -#: pg_backup_archiver.c:2393 +#: pg_backup_archiver.c:2680 #, c-format msgid "unrecognized encoding \"%s\"\n" msgstr "エンコーディング \"%s\" ã‚’èªè­˜ã§ãã¾ã›ã‚“\n" -#: pg_backup_archiver.c:2398 +#: pg_backup_archiver.c:2685 #, c-format msgid "invalid ENCODING item: %s\n" msgstr "無効㪠ENCODING 項目：%s\n" -#: pg_backup_archiver.c:2416 +#: pg_backup_archiver.c:2703 #, c-format msgid "invalid STDSTRINGS item: %s\n" msgstr "無効ãªSTDSTRINGS 項目：%s\n" -#: pg_backup_archiver.c:2633 +#: pg_backup_archiver.c:2718 +#, c-format +msgid "schema \"%s\" not found\n" +msgstr "スキーマ \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" + +#: pg_backup_archiver.c:2725 +#, c-format +msgid "table \"%s\" not found\n" +msgstr "テーブル \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" + +#: pg_backup_archiver.c:2732 +#, c-format +msgid "index \"%s\" not found\n" +msgstr "インデックス \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" + +#: pg_backup_archiver.c:2739 +#, c-format +msgid "function \"%s\" not found\n" +msgstr "関数 \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" + +#: pg_backup_archiver.c:2746 +#, c-format +msgid "trigger \"%s\" not found\n" +msgstr "トリガ \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" + +#: pg_backup_archiver.c:2988 #, c-format msgid "could not set session user to \"%s\": %s" msgstr "セッションユーザを\"%s\"ã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_backup_archiver.c:2665 +#: pg_backup_archiver.c:3020 #, c-format msgid "could not set default_with_oids: %s" msgstr "default_with_oidsを設定ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_backup_archiver.c:2803 +#: pg_backup_archiver.c:3165 #, c-format msgid "could not set search_path to \"%s\": %s" msgstr "search_pathã‚’\"%s\"ã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_backup_archiver.c:2864 +#: pg_backup_archiver.c:3227 #, c-format msgid "could not set default_tablespace to %s: %s" msgstr "default_tablespaceã‚’%sã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: pg_backup_archiver.c:2951 pg_backup_archiver.c:3134 +#: pg_backup_archiver.c:3314 pg_backup_archiver.c:3508 #, c-format msgid "WARNING: don't know how to set owner for object type %s\n" msgstr "WARNING: オブジェクト種類%sã«å¯¾ã™ã‚‹æ‰€æœ‰è€…ã®è¨­å®šæ–¹æ³•ãŒä¸æ˜Žã§ã™ã€‚\n" -#: pg_backup_archiver.c:3187 -#, c-format -msgid "WARNING: requested compression not available in this installation -- archive will be uncompressed\n" -msgstr "警告: è¦æ±‚ã•ã‚ŒãŸåœ§ç¸®æ–¹æ³•ã¯ã“ã®ã‚¤ãƒ³ã‚¹ãƒˆãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ã§åˆ©ç”¨ã§ãã¾ã›ã‚“ --アーカイブを圧縮ã—ã¾ã›ã‚“\n" - -#: pg_backup_archiver.c:3227 +#: pg_backup_archiver.c:3591 #, c-format msgid "did not find magic string in file header\n" msgstr "ファイルヘッダã«ãƒžã‚¸ãƒƒã‚¯ç•ªå·ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_archiver.c:3240 +#: pg_backup_archiver.c:3604 #, c-format msgid "unsupported version (%d.%d) in file header\n" msgstr "ファイルヘッダ内ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³(%d.%d)ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_archiver.c:3245 +#: pg_backup_archiver.c:3609 #, c-format msgid "sanity check on integer size (%lu) failed\n" msgstr "æ•´æ•°ã®ã‚µã‚¤ã‚º(%lu)ã«é–¢ã™ã‚‹å¥å…¨æ€§æ¤œæŸ»ãŒå¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_backup_archiver.c:3249 +#: pg_backup_archiver.c:3613 #, c-format msgid "WARNING: archive was made on a machine with larger integers, some operations might fail\n" msgstr "警告: アーカイブã¯ã‚ˆã‚Šå¤§ããªã‚µã‚¤ã‚ºã®æ•´æ•°ã‚’æŒã¤ãƒžã‚·ãƒ³ã§ä½œæˆã•ã‚Œã¾ã—ãŸã€‚一部ã®æ“作ãŒå¤±æ•—ã™ã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™\n" -#: pg_backup_archiver.c:3259 +#: pg_backup_archiver.c:3623 #, c-format msgid "expected format (%d) differs from format found in file (%d)\n" msgstr "想定ã—ãŸæ›¸å¼(%d)ã¯ãƒ•ã‚¡ã‚¤ãƒ«å†…ã®æ›¸å¼(%d)ã¨ç•°ãªã‚Šã¾ã™\n" -#: pg_backup_archiver.c:3275 +#: pg_backup_archiver.c:3639 #, c-format msgid "WARNING: archive is compressed, but this installation does not support compression -- no data will be available\n" msgstr "警告: アーカイブã¯åœ§ç¸®ã•ã‚Œã¦ã„ã¾ã™ãŒã€ã“ã®ã‚¤ãƒ³ã‚¹ãƒˆãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ã§ã¯åœ§ç¸®æ©Ÿèƒ½ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“ -- 利用ã§ãるデータã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: pg_backup_archiver.c:3293 +#: pg_backup_archiver.c:3657 #, c-format msgid "WARNING: invalid creation date in header\n" msgstr "警告: ヘッダ内ã®ä½œæˆæ—¥ä»˜ãŒç„¡åŠ¹ã§ã™\n" -#: pg_backup_archiver.c:3382 +#: pg_backup_archiver.c:3732 #, c-format -#| msgid "entering restore_toc_entries_parallel\n" msgid "entering restore_toc_entries_prefork\n" msgstr "restore_toc_entries_prefork ã«å…¥ã‚Šã¾ã™\n" -#: pg_backup_archiver.c:3426 +#: pg_backup_archiver.c:3776 #, c-format msgid "processing item %d %s %s\n" msgstr "%d %s %s を処ç†ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:3478 +#: pg_backup_archiver.c:3828 #, c-format msgid "entering restore_toc_entries_parallel\n" msgstr "restore_toc_entries_parallel ã«å…¥ã‚Šã¾ã™\n" -#: pg_backup_archiver.c:3526 +#: pg_backup_archiver.c:3876 #, c-format msgid "entering main parallel loop\n" msgstr "メインã®ä¸¦åˆ—ループã«å…¥ã‚Šã¾ã™\n" -#: pg_backup_archiver.c:3537 +#: pg_backup_archiver.c:3887 #, c-format msgid "skipping item %d %s %s\n" msgstr "é …ç›® %d %s %s をスキップã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:3547 +#: pg_backup_archiver.c:3897 #, c-format msgid "launching item %d %s %s\n" msgstr "é …ç›® %d %s %s ã«ç€æ‰‹ã—ã¾ã™\n" -#: pg_backup_archiver.c:3605 +#: pg_backup_archiver.c:3953 #, c-format msgid "finished main parallel loop\n" msgstr "メインã®ä¸¦åˆ—ループを終了ã—ã¾ã™\n" -#: pg_backup_archiver.c:3614 +#: pg_backup_archiver.c:3962 #, c-format -#| msgid "entering restore_toc_entries_parallel\n" msgid "entering restore_toc_entries_postfork\n" msgstr "restore_toc_entries_postfork ã«å…¥ã‚Šã¾ã™\n" -#: pg_backup_archiver.c:3632 +#: pg_backup_archiver.c:3981 #, c-format msgid "processing missed item %d %s %s\n" msgstr "見ã¤ã‹ã‚‰ãªã‹ã£ãŸé …ç›® %d %s %s を処ç†ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:3781 +#: pg_backup_archiver.c:4130 #, c-format msgid "no item ready\n" msgstr "準備ãŒã§ãã¦ã„ã‚‹é …ç›®ã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: pg_backup_archiver.c:3831 +#: pg_backup_archiver.c:4178 #, c-format msgid "could not find slot of finished worker\n" msgstr "終了ã—ãŸãƒ¯ãƒ¼ã‚«ãƒ¼ã®ã‚¹ãƒ­ãƒƒãƒˆã®æ¤œç´¢ã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_backup_archiver.c:3833 +#: pg_backup_archiver.c:4180 #, c-format msgid "finished item %d %s %s\n" msgstr "é …ç›® %d %s %s を完了ã—ã¾ã—ãŸ\n" -#: pg_backup_archiver.c:3846 +#: pg_backup_archiver.c:4193 #, c-format msgid "worker process failed: exit code %d\n" msgstr "ワーカープロセスãŒçµ‚了コード %d ã§çµ‚了ã—ã¾ã—ãŸ\n" -#: pg_backup_archiver.c:4008 +#: pg_backup_archiver.c:4355 #, c-format msgid "transferring dependency %d -> %d to %d\n" msgstr "%d -> %d ã‹ã‚‰ %d ã¸ã®ä¾å­˜é–¢ä¿‚を転é€ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:4077 +#: pg_backup_archiver.c:4428 #, c-format msgid "reducing dependencies for %d\n" msgstr "%d ã®ä¾å­˜é–¢ä¿‚を軽減ã—ã¦ã„ã¾ã™\n" -#: pg_backup_archiver.c:4116 +#: pg_backup_archiver.c:4467 #, c-format msgid "table \"%s\" could not be created, will not restore its data\n" msgstr "テーブル \"%s\" を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸã€‚ãã®ãƒ‡ãƒ¼ã‚¿ã¯å¾©å…ƒã•ã‚Œã¾ã›ã‚“\n" #. translator: this is a module name -#: pg_backup_custom.c:93 +#: pg_backup_custom.c:94 msgid "custom archiver" msgstr "カスタムアーカイãƒ" -#: pg_backup_custom.c:382 pg_backup_null.c:152 +#: pg_backup_custom.c:384 pg_backup_null.c:150 #, c-format msgid "invalid OID for large object\n" msgstr "ラージオブジェクトã®OIDãŒç„¡åŠ¹ã§ã™\n" -#: pg_backup_custom.c:453 +#: pg_backup_custom.c:455 #, c-format msgid "unrecognized data block type (%d) while searching archive\n" msgstr "アーカイブã®æ¤œç´¢ä¸­ã«æœªçŸ¥ã®ãƒ‡ãƒ¼ã‚¿ãƒ–ロック種類(%d)ãŒã‚ã‚Šã¾ã—ãŸ\n" -#: pg_backup_custom.c:464 +#: pg_backup_custom.c:466 #, c-format msgid "error during file seek: %s\n" msgstr "ファイルシーク中ã«ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã—ãŸ: %s\n" -#: pg_backup_custom.c:474 +#: pg_backup_custom.c:476 #, c-format msgid "could not find block ID %d in archive -- possibly due to out-of-order restore request, which cannot be handled due to lack of data offsets in archive\n" msgstr "アーカイブ中ã«ãƒ–ロックID %d ãŒã‚ã‚Šã¾ã›ã‚“ -- ãŠãらãリストアè¦æ±‚ã®é †åºãŒèª¤ã£ã¦ã„ã‚‹ãŸã‚ã§ã™ã€‚ã“ã®å ´åˆã€ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–中ã«ã‚ªãƒ•ã‚»ãƒƒãƒˆã®æƒ…å ±ãŒãªã„ãŸã‚処ç†ã§ãã¾ã›ã‚“\n" -#: pg_backup_custom.c:479 +#: pg_backup_custom.c:481 #, c-format msgid "could not find block ID %d in archive -- possibly due to out-of-order restore request, which cannot be handled due to non-seekable input file\n" msgstr "アーカイブ中ã«ãƒ–ロックID %d ãŒã‚ã‚Šã¾ã›ã‚“ -- ãŠãらãリストアè¦æ±‚ã®é †åºãŒèª¤ã£ã¦ã„ã‚‹ãŸã‚ã§ã™ã€‚ã“ã®å ´åˆã€å…¥åŠ›ãƒ•ã‚¡ã‚¤ãƒ«ãŒã‚·ãƒ¼ã‚¯ä¸èƒ½ã¨ãªã‚‹ã®ã§å‡¦ç†ã§ãã¾ã›ã‚“\n" -#: pg_backup_custom.c:484 +#: pg_backup_custom.c:486 #, c-format msgid "could not find block ID %d in archive -- possibly corrupt archive\n" msgstr "アーカイブ内ã«ãƒ–ロック ID %d ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—㟠-- ãŠãらãアーカイブãŒå£Šã‚Œã¦ã„ã¾ã™\n" -#: pg_backup_custom.c:491 +#: pg_backup_custom.c:493 #, c-format msgid "found unexpected block ID (%d) when reading data -- expected %d\n" msgstr "データ読ã¿è¾¼ã¿æ™‚ã«æƒ³å®šå¤–ã®ãƒ–ロックID(%d)ãŒã‚ã‚Šã¾ã—㟠-- 期待値ã¯%d\n" -#: pg_backup_custom.c:505 +#: pg_backup_custom.c:507 #, c-format msgid "unrecognized data block type %d while restoring archive\n" msgstr "アーカイブã®ã‚Šã‚¹ãƒˆã‚¢ä¸­ã«æœªçŸ¥ã®ãƒ‡ãƒ¼ã‚¿ãƒ–ロック種類%dãŒã‚ã‚Šã¾ã—ãŸ\n" -#: pg_backup_custom.c:587 pg_backup_custom.c:995 +#: pg_backup_custom.c:709 pg_backup_custom.c:759 pg_backup_custom.c:908 +#: pg_backup_tar.c:1088 #, c-format -msgid "could not read from input file: end of file\n" -msgstr "入力ファイルã‹ã‚‰èª­ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: ファイルã®çµ‚了ã§ã™\n" - -#: pg_backup_custom.c:590 pg_backup_custom.c:998 -#, c-format -msgid "could not read from input file: %s\n" -msgstr "入力ファイルã‹ã‚‰èª­ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: pg_backup_custom.c:619 -#, c-format -msgid "could not write byte: %s\n" -msgstr "ãƒã‚¤ãƒˆã‚’書ãè¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" +msgid "could not determine seek position in archive file: %s\n" +msgstr "アーカイブファイルã®ã‚·ãƒ¼ã‚¯ä½ç½®ã‚’決定ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_custom.c:727 pg_backup_custom.c:765 +#: pg_backup_custom.c:727 pg_backup_custom.c:764 #, c-format msgid "could not close archive file: %s\n" msgstr "アーカイブファイルをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" @@ -959,327 +992,323 @@ msgstr "標準入力ã‹ã‚‰ã®ä¸¦è¡Œãƒªã‚¹ãƒˆã‚¢ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã› msgid "parallel restore from non-seekable file is not supported\n" msgstr "シークã§ããªã„ファイルã‹ã‚‰ã®å¹³è¡Œãƒªã‚¹ãƒˆã‚¢ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_custom.c:760 -#, c-format -msgid "could not determine seek position in archive file: %s\n" -msgstr "アーカイブファイルã®ã‚·ãƒ¼ã‚¯ä½ç½®ã‚’決定ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: pg_backup_custom.c:775 +#: pg_backup_custom.c:774 #, c-format msgid "could not set seek position in archive file: %s\n" msgstr "アーカイブファイルã®ã‚·ãƒ¼ã‚¯ä½ç½®ã‚’セットã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_custom.c:793 +#: pg_backup_custom.c:792 #, c-format msgid "compressor active\n" msgstr "圧縮処ç†ãŒæœ‰åŠ¹ã§ã™\n" -#: pg_backup_custom.c:903 +#: pg_backup_custom.c:912 #, c-format msgid "WARNING: ftell mismatch with expected position -- ftell used\n" msgstr "警告: ftellã§æƒ³å®šä½ç½®ã¨ã®ä¸æ•´åˆãŒã‚ã‚Šã¾ã—㟠-- ftellãŒä½¿ç”¨ã•ã‚Œã¾ã—ãŸ\n" #. translator: this is a module name -#: pg_backup_db.c:28 +#: pg_backup_db.c:31 msgid "archiver (db)" msgstr "アーカイãƒ(db)" -#: pg_backup_db.c:43 +#: pg_backup_db.c:47 #, c-format msgid "could not get server_version from libpq\n" msgstr "libpqã‹ã‚‰server_versionã‚’å–り出ã›ã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_db.c:54 pg_dumpall.c:1894 +#: pg_backup_db.c:58 pg_dumpall.c:2068 #, c-format msgid "server version: %s; %s version: %s\n" msgstr "サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³: %sã€%s ãƒãƒ¼ã‚¸ãƒ§ãƒ³: %s\n" -#: pg_backup_db.c:56 pg_dumpall.c:1896 +#: pg_backup_db.c:60 pg_dumpall.c:2070 #, c-format msgid "aborting because of server version mismatch\n" msgstr "サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®ä¸æ•´åˆã®ãŸã‚処ç†ã‚’中断ã—ã¦ã„ã¾ã™\n" -#: pg_backup_db.c:127 +#: pg_backup_db.c:149 #, c-format msgid "connecting to database \"%s\" as user \"%s\"\n" msgstr "データベース\"%s\"ã«ãƒ¦ãƒ¼ã‚¶\"%s\"ã§æŽ¥ç¶šã—ã¦ã„ã¾ã™\n" -#: pg_backup_db.c:132 pg_backup_db.c:184 pg_backup_db.c:231 pg_backup_db.c:277 -#: pg_dumpall.c:1724 pg_dumpall.c:1832 +#: pg_backup_db.c:156 pg_backup_db.c:208 pg_backup_db.c:270 pg_backup_db.c:312 +#: pg_dumpall.c:1894 pg_dumpall.c:2006 msgid "Password: " msgstr "パスワード: " -#: pg_backup_db.c:165 +#: pg_backup_db.c:189 #, c-format msgid "failed to reconnect to database\n" msgstr "データベースã¸ã®å†æŽ¥ç¶šã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_backup_db.c:170 +#: pg_backup_db.c:194 #, c-format msgid "could not reconnect to database: %s" msgstr "データベース%sã¸ã®å†æŽ¥ç¶šãŒã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: pg_backup_db.c:186 +#: pg_backup_db.c:210 #, c-format msgid "connection needs password\n" msgstr "ã“ã®æŽ¥ç¶šã«ã¯ãƒ‘スワードãŒå¿…è¦ã§ã™\n" -#: pg_backup_db.c:227 +#: pg_backup_db.c:264 #, c-format msgid "already connected to a database\n" msgstr "データベースã«æŽ¥ç¶šæ¸ˆã¿ã§ã—ãŸ\n" -#: pg_backup_db.c:269 +#: pg_backup_db.c:304 #, c-format msgid "failed to connect to database\n" msgstr "データベースã¸ã®æŽ¥ç¶šã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: pg_backup_db.c:288 +#: pg_backup_db.c:321 #, c-format msgid "connection to database \"%s\" failed: %s" msgstr "データベース\"%s\"ã¸ã®æŽ¥ç¶šãŒå¤±æ•—ã—ã¾ã—ãŸ: %s" -#: pg_backup_db.c:343 +#: pg_backup_db.c:391 +#, c-format +msgid "%s" +msgstr "%s" + +#: pg_backup_db.c:398 #, c-format msgid "query failed: %s" msgstr "å•ã„åˆã‚ã›ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s" -#: pg_backup_db.c:345 +#: pg_backup_db.c:400 #, c-format msgid "query was: %s\n" msgstr "å•ã„åˆã‚ã›: %s\n" -#: pg_backup_db.c:409 +#: pg_backup_db.c:442 +#, c-format +msgid "query returned %d row instead of one: %s\n" +msgid_plural "query returned %d rows instead of one: %s\n" +msgstr[0] "å•ã„åˆã‚ã›ãŒ1è¡Œã§ã¯ãªã%d行返ã—ã¾ã—ãŸ: %s\n" +msgstr[1] "å•ã„åˆã‚ã›ãŒ1è¡Œã§ã¯ãªã%d行返ã—ã¾ã—ãŸ: %s\n" + +#: pg_backup_db.c:487 #, c-format msgid "%s: %s Command was: %s\n" msgstr "%s: %s コマンド: %s\n" -#: pg_backup_db.c:460 pg_backup_db.c:531 pg_backup_db.c:538 +#: pg_backup_db.c:543 pg_backup_db.c:617 pg_backup_db.c:624 msgid "could not execute query" msgstr "å•ã„åˆã‚ã›ã‚’実行ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: pg_backup_db.c:511 +#: pg_backup_db.c:596 #, c-format msgid "error returned by PQputCopyData: %s" msgstr "PQputCopyData ã‹ã‚‰ã‚¨ãƒ©ãƒ¼ãŒè¿”ã•ã‚Œã¾ã—ãŸ: %s" -#: pg_backup_db.c:557 +#: pg_backup_db.c:645 #, c-format msgid "error returned by PQputCopyEnd: %s" msgstr "PQputCopyEnd ã‹ã‚‰ã‚¨ãƒ©ãƒ¼ãŒè¿”ã•ã‚Œã¾ã—ãŸ: %s" -#: pg_backup_db.c:563 +#: pg_backup_db.c:651 #, c-format msgid "COPY failed for table \"%s\": %s" msgstr "テーブル\"%s\"ã®ã‚³ãƒ”ーã«å¤±æ•—ã—ã¾ã—ãŸ: %s" -#: pg_backup_db.c:574 +#: pg_backup_db.c:657 pg_dump.c:1814 +#, c-format +msgid "WARNING: unexpected extra results during COPY of table \"%s\"\n" +msgstr "警告: テーブル \"%s\" ã®COPY中ã«æƒ³å®šå¤–ã®ä½™åˆ†ãªçµæžœãŒã‚ã‚Šã¾ã™\n" + +#: pg_backup_db.c:669 msgid "could not start database transaction" msgstr "データベーストランザクションを開始ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: pg_backup_db.c:580 +#: pg_backup_db.c:677 msgid "could not commit database transaction" msgstr "データベーストランザクションをコミットã§ãã¾ã›ã‚“ã§ã—ãŸ" #. translator: this is a module name -#: pg_backup_directory.c:63 +#: pg_backup_directory.c:64 msgid "directory archiver" msgstr "ディレクトリアーカイãƒ" -#: pg_backup_directory.c:161 +#: pg_backup_directory.c:162 #, c-format msgid "no output directory specified\n" msgstr "出力ディレクトリãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_directory.c:193 +#: pg_backup_directory.c:191 +#, c-format +msgid "could not read directory \"%s\": %s\n" +msgstr "ディレクトリ\"%s\"を読ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: pg_backup_directory.c:195 +#, c-format +msgid "could not close directory \"%s\": %s\n" +msgstr "ディレクトリ\"%s\"をクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: pg_backup_directory.c:201 #, c-format msgid "could not create directory \"%s\": %s\n" msgstr "ディレクトリ\"%s\"を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_directory.c:405 +#: pg_backup_directory.c:412 #, c-format msgid "could not close data file: %s\n" msgstr "データファイル%sをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_directory.c:446 +#: pg_backup_directory.c:453 #, c-format msgid "could not open large object TOC file \"%s\" for input: %s\n" msgstr "ラージオブジェクトTOCファイル\"%s\"を入力用ã¨ã—ã¦ã‚ªãƒ¼ãƒ—ンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_directory.c:456 +#: pg_backup_directory.c:464 #, c-format msgid "invalid line in large object TOC file \"%s\": \"%s\"\n" msgstr "" "ラージオブジェクトTOCファイル\"%s\"ã®ä¸­ã«ç„¡åŠ¹ãªè¡ŒãŒã‚ã‚Šã¾ã—ãŸ: \"%s\"\n" "\n" -#: pg_backup_directory.c:465 +#: pg_backup_directory.c:473 #, c-format msgid "error reading large object TOC file \"%s\"\n" msgstr "ラージオブジェクトTOCファイル\"%s\"を読ã¿å–り中ã«ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã—ãŸ\n" -#: pg_backup_directory.c:469 +#: pg_backup_directory.c:477 #, c-format msgid "could not close large object TOC file \"%s\": %s\n" msgstr "ラージオブジェクトTOCファイル\"%s\"をクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_directory.c:490 -#, c-format -msgid "could not write byte\n" -msgstr "ãƒã‚¤ãƒˆã‚’書ãè¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ\n" - -#: pg_backup_directory.c:682 +#: pg_backup_directory.c:684 #, c-format msgid "could not write to blobs TOC file\n" msgstr "blobs TOCファイルã«æ›¸ã出ã›ã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_directory.c:714 +#: pg_backup_directory.c:716 #, c-format msgid "file name too long: \"%s\"\n" msgstr "ファイルåãŒé•·ã™ãŽã¾ã™: \"%s\"\n" -#: pg_backup_directory.c:800 +#: pg_backup_directory.c:802 #, c-format -#| msgid "error during file seek: %s\n" msgid "error during backup\n" msgstr "ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—中ã«ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã—ãŸ\n" -#: pg_backup_null.c:77 +#: pg_backup_null.c:75 #, c-format msgid "this format cannot be read\n" msgstr "ã“ã®æ›¸å¼ã¯èª­ã¿è¾¼ã‚ã¾ã›ã‚“\n" #. translator: this is a module name -#: pg_backup_tar.c:109 +#: pg_backup_tar.c:102 msgid "tar archiver" msgstr "tarアーカイãƒ" -#: pg_backup_tar.c:190 +#: pg_backup_tar.c:183 #, c-format msgid "could not open TOC file \"%s\" for output: %s\n" msgstr "出力用ã®TOCファイル\"%s\"をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_tar.c:198 +#: pg_backup_tar.c:191 #, c-format msgid "could not open TOC file for output: %s\n" msgstr "出力用ã®TOCファイルをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_tar.c:226 pg_backup_tar.c:382 +#: pg_backup_tar.c:212 pg_backup_tar.c:368 #, c-format msgid "compression is not supported by tar archive format\n" msgstr "tar アーカイブフォーマットã§ã¯åœ§ç¸®ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" -#: pg_backup_tar.c:234 +#: pg_backup_tar.c:220 #, c-format msgid "could not open TOC file \"%s\" for input: %s\n" msgstr "入力用ã®TOCファイル\"%s\"をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_tar.c:241 +#: pg_backup_tar.c:227 #, c-format msgid "could not open TOC file for input: %s\n" msgstr "入力用ã®TOCファイルをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_tar.c:368 +#: pg_backup_tar.c:354 #, c-format msgid "could not find file \"%s\" in archive\n" msgstr "アーカイブ内ã«ãƒ•ã‚¡ã‚¤ãƒ«\"%s\"ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_tar.c:424 +#: pg_backup_tar.c:420 #, c-format msgid "could not generate temporary file name: %s\n" msgstr "一時ファイルåを生æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_backup_tar.c:433 +#: pg_backup_tar.c:431 #, c-format msgid "could not open temporary file\n" msgstr "一時ファイルをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_tar.c:460 +#: pg_backup_tar.c:458 #, c-format msgid "could not close tar member\n" msgstr "tarメンãƒã‚’クローズã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_tar.c:560 +#: pg_backup_tar.c:571 #, c-format msgid "internal error -- neither th nor fh specified in tarReadRaw()\n" msgstr "内部エラー -- tarReadRaw()ã«ã¦thã‚‚fhも指定ã•ã‚Œã¦ã„ã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_tar.c:686 +#: pg_backup_tar.c:694 #, c-format msgid "unexpected COPY statement syntax: \"%s\"\n" msgstr "想定外ã®COPYæ–‡ã®æ§‹æ–‡: \"%s\"\n" -#: pg_backup_tar.c:889 -#, c-format -msgid "could not write null block at end of tar archive\n" -msgstr "tarアーカイブã®æœ€å¾Œã«ãƒŒãƒ«ãƒ–ロックを書ã出ã›ã¾ã›ã‚“ã§ã—ãŸ\n" - -#: pg_backup_tar.c:944 +#: pg_backup_tar.c:960 #, c-format msgid "invalid OID for large object (%u)\n" msgstr "ラージオブジェクトã®OIDãŒç„¡åŠ¹ã§ã™(%u)\n" -#: pg_backup_tar.c:1078 -#, c-format -msgid "archive member too large for tar format\n" -msgstr "tar書å¼ã®ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–メンãƒãŒå¤§ãã™ãŽã¾ã™\n" - -#: pg_backup_tar.c:1093 +#: pg_backup_tar.c:1104 #, c-format msgid "could not close temporary file: %s\n" msgstr "一時ファイルを開ã‘ã¾ã›ã‚“ã§ã—ãŸï¼š%s\n" -#: pg_backup_tar.c:1103 +#: pg_backup_tar.c:1114 #, c-format msgid "actual file length (%s) does not match expected (%s)\n" msgstr "実際ã®ãƒ•ã‚¡ã‚¤ãƒ«é•·(%s)ãŒæœŸå¾…値(%s)ã¨ä¸€è‡´ã—ã¾ã›ã‚“\n" -#: pg_backup_tar.c:1111 -#, c-format -msgid "could not output padding at end of tar member\n" -msgstr "tarメンãƒã®æœ€å¾Œã«ãƒ‘ディングを出力ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" - -#: pg_backup_tar.c:1140 +#: pg_backup_tar.c:1151 #, c-format msgid "moving from position %s to next member at file position %s\n" msgstr "ä½ç½®%sã‹ã‚‰ãƒ•ã‚¡ã‚¤ãƒ«ä½ç½®%sã®æ¬¡ã®ãƒ¡ãƒ³ãƒã¸ç§»å‹•ã—ã¦ã„ã¾ã™\n" -#: pg_backup_tar.c:1151 +#: pg_backup_tar.c:1162 #, c-format msgid "now at file position %s\n" msgstr "ç¾åœ¨ã®ãƒ•ã‚¡ã‚¤ãƒ«ä½ç½®ã¯%sã§ã™\n" -#: pg_backup_tar.c:1160 pg_backup_tar.c:1190 +#: pg_backup_tar.c:1171 pg_backup_tar.c:1201 #, c-format msgid "could not find header for file \"%s\" in tar archive\n" msgstr "tar アーカイブ内ã§ãƒ•ã‚¡ã‚¤ãƒ«\"%s\"用ã®ãƒ•ã‚¡ã‚¤ãƒ«ãƒ˜ãƒƒãƒ€ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_backup_tar.c:1174 +#: pg_backup_tar.c:1185 #, c-format msgid "skipping tar member %s\n" msgstr "tarメンãƒ%sを飛ã°ã—ã¦ã„ã¾ã™\n" -#: pg_backup_tar.c:1178 +#: pg_backup_tar.c:1189 #, c-format msgid "restoring data out of order is not supported in this archive format: \"%s\" is required, but comes before \"%s\" in the archive file.\n" msgstr "ã“ã®ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–書å¼ã§ã¯ã€é †åºå¤–ã®ãƒ‡ãƒ¼ã‚¿ã®ãƒ€ãƒ³ãƒ—ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“:\"%s\"を想定ã—ã¦ã„ã¾ã—ãŸãŒã€ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ファイル内ã§ã¯\"%s\"ã®å‰ã«ã‚ã‚Šã¾ã—ãŸ\n" -#: pg_backup_tar.c:1224 -#, c-format -msgid "mismatch in actual vs. predicted file position (%s vs. %s)\n" -msgstr "実際ã®ãƒ•ã‚¡ã‚¤ãƒ«ä½ç½®ã¨äºˆæ¸¬ãƒ•ã‚¡ã‚¤ãƒ«ä½ç½®ãŒä¸€è‡´ã—ã¾ã›ã‚“(%s vs. %s)\n" - -#: pg_backup_tar.c:1239 +#: pg_backup_tar.c:1235 #, c-format msgid "incomplete tar header found (%lu byte)\n" msgid_plural "incomplete tar header found (%lu bytes)\n" msgstr[0] "ä¸å®Œå…¨ãªtarヘッダãŒã‚ã‚Šã¾ã—ãŸ(%luãƒã‚¤ãƒˆ)\n" msgstr[1] "ä¸å®Œå…¨ãªtarヘッダãŒã‚ã‚Šã¾ã—ãŸ(%luãƒã‚¤ãƒˆ)\n" -#: pg_backup_tar.c:1277 +#: pg_backup_tar.c:1276 #, c-format -msgid "TOC Entry %s at %s (length %lu, checksum %d)\n" -msgstr "%2$sã®TOCエントリ%1$s(é•·ã• %3$luã€ãƒã‚§ãƒƒã‚¯ã‚µãƒ  %4$d)\n" +msgid "TOC Entry %s at %s (length %s, checksum %d)\n" +msgstr "%2$s ã®TOCエントリ %1$s (é•·ã• %3$sã€ãƒã‚§ãƒƒã‚¯ã‚µãƒ  %4$d)\n" #: pg_backup_tar.c:1287 #, c-format @@ -1291,24 +1320,29 @@ msgstr "ç ´æã—ãŸtarヘッダãŒãƒ•ã‚¡ã‚¤ãƒ«ä½ç½®%4$sã®%1$sã«ã‚ã‚Šã¾ã— msgid "%s: unrecognized section name: \"%s\"\n" msgstr "%s: ä¸æ˜Žãªã‚»ã‚¯ã‚·ãƒ§ãƒ³å: \"%s\"\n" -#: pg_backup_utils.c:56 pg_dump.c:540 pg_dump.c:557 pg_dumpall.c:303 -#: pg_dumpall.c:313 pg_dumpall.c:323 pg_dumpall.c:332 pg_dumpall.c:341 -#: pg_dumpall.c:399 pg_restore.c:282 pg_restore.c:298 pg_restore.c:310 +#: pg_backup_utils.c:56 pg_dump.c:536 pg_dump.c:553 pg_dumpall.c:299 +#: pg_dumpall.c:309 pg_dumpall.c:319 pg_dumpall.c:328 pg_dumpall.c:344 +#: pg_dumpall.c:402 pg_restore.c:279 pg_restore.c:295 pg_restore.c:307 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細㯠\"%s --help\" を実行ã—ã¦ãã ã•ã„\n" -#: pg_backup_utils.c:101 +#: pg_backup_utils.c:118 #, c-format msgid "out of on_exit_nicely slots\n" msgstr "on_exit_nicelyスロットã®ä¸è¶³\n" -#: pg_dump.c:555 pg_dumpall.c:311 pg_restore.c:296 +#: pg_dump.c:506 +#, c-format +msgid "compression level must be in range 0..9\n" +msgstr "圧縮レベル㯠0..9 ã®ç¯„囲ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" + +#: pg_dump.c:551 pg_dumpall.c:307 pg_restore.c:293 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: コマンドライン引数ãŒå¤šã™ãŽã¾ã™(先頭ã¯\"%s\")\n" -#: pg_dump.c:567 +#: pg_dump.c:564 #, c-format msgid "options -s/--schema-only and -a/--data-only cannot be used together\n" msgstr "-s/--schema-only 㨠-a/--data-only ã¯åŒæ™‚ã«ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“\n" @@ -1318,34 +1352,37 @@ msgstr "-s/--schema-only 㨠-a/--data-only ã¯åŒæ™‚ã«ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“ msgid "options -c/--clean and -a/--data-only cannot be used together\n" msgstr "-c/--clean 㨠-a/--data-only ã¯åŒæ™‚ã«ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_dump.c:574 +#: pg_dump.c:576 #, c-format msgid "options --inserts/--column-inserts and -o/--oids cannot be used together\n" msgstr "\"--inserts/--column-insertsã¨-o/--oidsã¯åŒæ™‚ã«ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_dump.c:575 +#: pg_dump.c:577 #, c-format msgid "(The INSERT command cannot set OIDs.)\n" msgstr "(INSERTコマンドã§ã¯OIDを設定ã§ãã¾ã›ã‚“。)\n" -#: pg_dump.c:605 +#: pg_dump.c:582 #, c-format -#| msgid "%s: invalid port number \"%s\"\n" -msgid "%s: invalid number of parallel jobs\n" -msgstr "%s: 無効ãªä¸¦è¡Œã‚¸ãƒ§ãƒ–æ•°ã§ã™\n" +msgid "option --if-exists requires option -c/--clean\n" +msgstr "--if-exists オプション㯠-c/--clean オプションを必è¦ã¨ã—ã¾ã™\n" -#: pg_dump.c:609 +#: pg_dump.c:604 #, c-format -#| msgid "parallel restore is not supported with this archive file format\n" -msgid "parallel backup only supported by the directory format\n" -msgstr "並行ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã¯ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªæ›¸å¼ã§ã®ã¿ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã™\n" +msgid "WARNING: requested compression not available in this installation -- archive will be uncompressed\n" +msgstr "警告: è¦æ±‚ã•ã‚ŒãŸåœ§ç¸®æ–¹æ³•ã¯ã“ã®ã‚¤ãƒ³ã‚¹ãƒˆãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ã§åˆ©ç”¨ã§ãã¾ã›ã‚“ --アーカイブを圧縮ã—ã¾ã›ã‚“\n" #: pg_dump.c:619 #, c-format -msgid "could not open output file \"%s\" for writing\n" -msgstr "出力ファイル\"%s\"を書ãè¾¼ã¿ç”¨ã«ã‚ªãƒ¼ãƒ—ンã§ãã¾ã›ã‚“ã§ã—ãŸ\n" +msgid "invalid number of parallel jobs\n" +msgstr "無効ãªä¸¦è¡Œã‚¸ãƒ§ãƒ–æ•°ã§ã™\n" + +#: pg_dump.c:623 +#, c-format +msgid "parallel backup only supported by the directory format\n" +msgstr "並行ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã¯ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªæ›¸å¼ã§ã®ã¿ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã™\n" -#: pg_dump.c:678 +#: pg_dump.c:680 #, c-format msgid "" "Synchronized snapshots are not supported by this server version.\n" @@ -1356,22 +1393,27 @@ msgstr "" "åŒæœŸåŒ–スナップショットãŒä¸è¦ãªã‚‰ã°--no-synchronized-snapshotsを付ã‘ã¦å®Ÿ\n" "è¡Œã—ã¦ãã ã•ã„。\n" -#: pg_dump.c:691 +#: pg_dump.c:687 +#, c-format +msgid "Exported snapshots are not supported by this server version.\n" +msgstr "ã“ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®ã‚µãƒ¼ãƒãƒ¼ã§ã¯ã€ã‚¨ã‚¯ã‚¹ãƒãƒ¼ãƒˆã•ã‚ŒãŸã‚¹ãƒŠãƒƒãƒ—ショットをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" + +#: pg_dump.c:706 #, c-format msgid "last built-in OID is %u\n" msgstr "最終ã®çµ„ã¿è¾¼ã¿OIDã¯%uã§ã™\n" -#: pg_dump.c:700 +#: pg_dump.c:715 #, c-format -msgid "No matching schemas were found\n" +msgid "no matching schemas were found\n" msgstr "マッãƒã™ã‚‹ã‚¹ã‚­ãƒ¼ãƒžãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: pg_dump.c:712 +#: pg_dump.c:729 #, c-format -msgid "No matching tables were found\n" +msgid "no matching tables were found\n" msgstr "マッãƒã™ã‚‹ãƒ†ãƒ¼ãƒ–ルãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: pg_dump.c:856 +#: pg_dump.c:897 #, c-format msgid "" "%s dumps a database as a text file or to other formats.\n" @@ -1380,17 +1422,17 @@ msgstr "" "%sã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’テキストファイルã¾ãŸã¯ãã®ä»–ã®æ›¸å¼ã§ãƒ€ãƒ³ãƒ—ã—ã¾ã™ã€‚\n" "\n" -#: pg_dump.c:857 pg_dumpall.c:541 pg_restore.c:428 +#: pg_dump.c:898 pg_dumpall.c:547 pg_restore.c:443 #, c-format msgid "Usage:\n" msgstr "使用方法:\n" -#: pg_dump.c:858 +#: pg_dump.c:899 #, c-format msgid " %s [OPTION]... [DBNAME]\n" msgstr " %s [OPTION]... [DBNAME]\n" -#: pg_dump.c:860 pg_dumpall.c:544 pg_restore.c:431 +#: pg_dump.c:901 pg_dumpall.c:550 pg_restore.c:446 #, c-format msgid "" "\n" @@ -1399,12 +1441,12 @@ msgstr "" "\n" "一般的ãªã‚ªãƒ—ション;\n" -#: pg_dump.c:861 +#: pg_dump.c:902 #, c-format msgid " -f, --file=FILENAME output file or directory name\n" msgstr " -f, --file=ファイルå 出力ファイルã¾ãŸã¯ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã®åå‰\n" -#: pg_dump.c:862 +#: pg_dump.c:903 #, c-format msgid "" " -F, --format=c|d|t|p output file format (custom, directory, tar,\n" @@ -1413,38 +1455,37 @@ msgstr "" " -F, --format=c|d|t|p 出力ファイルã®æ›¸å¼(custom, directory, tar, \n" " plain text（デフォルト）)\n" -#: pg_dump.c:864 +#: pg_dump.c:905 #, c-format -#| msgid " -j, --jobs=NUM use this many parallel jobs to restore\n" msgid " -j, --jobs=NUM use this many parallel jobs to dump\n" msgstr " -j, --jobs=NUM ダンプ時ã«æŒ‡å®šã—ãŸæ•°ã®ä¸¦åˆ—ジョブを使用\n" -#: pg_dump.c:865 +#: pg_dump.c:906 pg_dumpall.c:552 #, c-format msgid " -v, --verbose verbose mode\n" msgstr " -v, --verbose 冗長モード\n" -#: pg_dump.c:866 pg_dumpall.c:546 +#: pg_dump.c:907 pg_dumpall.c:553 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_dump.c:867 +#: pg_dump.c:908 #, c-format msgid " -Z, --compress=0-9 compression level for compressed formats\n" msgstr " -Z, --compress=0-9 圧縮形å¼ã«ãŠã‘る圧縮レベル\n" -#: pg_dump.c:868 pg_dumpall.c:547 +#: pg_dump.c:909 pg_dumpall.c:554 #, c-format msgid " --lock-wait-timeout=TIMEOUT fail after waiting TIMEOUT for a table lock\n" msgstr " --lock-wait-timeout=TIMEOUT テーブルロックをTIMEOUTå¾…ã£ã¦ã‹ã‚‰å¤±æ•—\n" -#: pg_dump.c:869 pg_dumpall.c:548 +#: pg_dump.c:910 pg_dumpall.c:555 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_dump.c:871 pg_dumpall.c:549 +#: pg_dump.c:912 pg_dumpall.c:556 #, c-format msgid "" "\n" @@ -1453,47 +1494,47 @@ msgstr "" "\n" "出力内容を制御ã™ã‚‹ãŸã‚ã®ã‚ªãƒ—ション:\n" -#: pg_dump.c:872 pg_dumpall.c:550 +#: pg_dump.c:913 pg_dumpall.c:557 #, c-format msgid " -a, --data-only dump only the data, not the schema\n" msgstr " -a, --data-only データã®ã¿ã‚’ダンプã—ã€ã‚¹ã‚­ãƒ¼ãƒžã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:873 +#: pg_dump.c:914 #, c-format msgid " -b, --blobs include large objects in dump\n" msgstr " -b, --blobs ラージオブジェクトã¨å…±ã«ãƒ€ãƒ³ãƒ—ã—ã¾ã™\n" -#: pg_dump.c:874 pg_restore.c:442 +#: pg_dump.c:915 pg_restore.c:457 #, c-format msgid " -c, --clean clean (drop) database objects before recreating\n" msgstr " -c, --clean å†ä½œæˆå‰ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚ªãƒ–ジェクトを整ç†ï¼ˆå‰Šé™¤ï¼‰\n" -#: pg_dump.c:875 +#: pg_dump.c:916 #, c-format msgid " -C, --create include commands to create database in dump\n" msgstr " -C, --create ダンプã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ç”Ÿæˆç”¨ã‚³ãƒžãƒ³ãƒ‰ã‚’å«ã‚ã¾ã™\n" -#: pg_dump.c:876 +#: pg_dump.c:917 #, c-format msgid " -E, --encoding=ENCODING dump the data in encoding ENCODING\n" msgstr " -E, --encoding=ENCODING ENCODING符å·åŒ–æ–¹å¼ã§ãƒ‡ãƒ¼ã‚¿ã‚’ダンプ\n" -#: pg_dump.c:877 +#: pg_dump.c:918 #, c-format msgid " -n, --schema=SCHEMA dump the named schema(s) only\n" msgstr " -n, --schema=SCHEMA 指åã—ãŸã‚¹ã‚­ãƒ¼ãƒžã®ã¿ã‚’ダンプ\n" -#: pg_dump.c:878 +#: pg_dump.c:919 #, c-format msgid " -N, --exclude-schema=SCHEMA do NOT dump the named schema(s)\n" msgstr " -N, --exclude-schema=SCHEMA 指åã•ã‚ŒãŸã‚¹ã‚­ãƒ¼ãƒžã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:879 pg_dumpall.c:553 +#: pg_dump.c:920 pg_dumpall.c:560 #, c-format msgid " -o, --oids include OIDs in dump\n" msgstr " -o, --oids ダンプã«OIDã‚’å«ã‚ã¾ã™\n" -#: pg_dump.c:880 +#: pg_dump.c:921 #, c-format msgid "" " -O, --no-owner skip restoration of object ownership in\n" @@ -1502,101 +1543,129 @@ msgstr "" " -O, --no-owner プレインテキスト形å¼ã§ã€ã‚ªãƒ–ジェクト所有権ã®\n" " 復元を行ã„ã¾ã›ã‚“\n" -#: pg_dump.c:882 pg_dumpall.c:556 +#: pg_dump.c:923 pg_dumpall.c:563 #, c-format msgid " -s, --schema-only dump only the schema, no data\n" msgstr " -s, --schema-only スキーマã®ã¿ã‚’ダンプã—ã€ãƒ‡ãƒ¼ã‚¿ã¯ãƒ€ãƒ³ãƒ—ã—ã¾ã›ã‚“\n" -#: pg_dump.c:883 +#: pg_dump.c:924 #, c-format msgid " -S, --superuser=NAME superuser user name to use in plain-text format\n" msgstr "" " -S, --superuser=NAME プレインテキスト形å¼ã§ä½¿ç”¨ã™ã‚‹ã‚¹ãƒ¼ãƒ‘ーユーザã®\n" " åå‰\n" -#: pg_dump.c:884 +#: pg_dump.c:925 #, c-format msgid " -t, --table=TABLE dump the named table(s) only\n" msgstr " -t, --table=TABLE 指定ã—ãŸãƒ†ãƒ¼ãƒ–ルã®ã¿ã‚’ダンプ\n" -#: pg_dump.c:885 +#: pg_dump.c:926 #, c-format msgid " -T, --exclude-table=TABLE do NOT dump the named table(s)\n" msgstr " -T, --exclude-table=TABLE 指定ã—ãŸãƒ†ãƒ¼ãƒ–ルをダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:886 pg_dumpall.c:559 +#: pg_dump.c:927 pg_dumpall.c:566 #, c-format msgid " -x, --no-privileges do not dump privileges (grant/revoke)\n" msgstr " -x, --no-privileges 権é™(grant/revoke)をダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:887 pg_dumpall.c:560 +#: pg_dump.c:928 pg_dumpall.c:567 #, c-format msgid " --binary-upgrade for use by upgrade utilities only\n" msgstr " --binary-upgrade 用途ã¯ã‚¢ãƒƒãƒ—グレードユーティリティã®ã¿\n" -#: pg_dump.c:888 pg_dumpall.c:561 +#: pg_dump.c:929 pg_dumpall.c:568 #, c-format msgid " --column-inserts dump data as INSERT commands with column names\n" msgstr "--column-inserts 列å付ãã®INSERTコマンドã§ãƒ‡ãƒ¼ã‚¿ã‚’ダンプ\n" -#: pg_dump.c:889 pg_dumpall.c:562 +#: pg_dump.c:930 pg_dumpall.c:569 #, c-format msgid " --disable-dollar-quoting disable dollar quoting, use SQL standard quoting\n" msgstr "" " --disable-dollar-quoting ドル記å·ã«ã‚ˆã‚‹å¼•ç”¨ç¬¦ä»˜ã‘ã‚’è¡Œã‚ãšã€SQL標準ã®å¼•ç”¨ç¬¦ä»˜ã‘を使ã„\n" " ã¾ã™\n" -#: pg_dump.c:890 pg_dumpall.c:563 pg_restore.c:458 +#: pg_dump.c:931 pg_dumpall.c:570 pg_restore.c:473 #, c-format msgid " --disable-triggers disable triggers during data-only restore\n" msgstr " --disable-triggers データã®ã¿ã®ãƒªã‚¹ãƒˆã‚¢ã‚’ã™ã‚‹éš›ã€ãƒˆãƒªã‚¬ã‚’無効ã«ã—ã¾ã™\n" -#: pg_dump.c:891 +#: pg_dump.c:932 +#, c-format +msgid "" +" --enable-row-security enable row security (dump only content user has\n" +" access to)\n" +msgstr "" +" --enable-row-security 行セキュリティを有効化ã—ã¾ã™\n" +" (ç¾åœ¨ã®ãƒ¦ãƒ¼ã‚¶ãŒã‚¢ã‚¯ã‚»ã‚¹ã§ãる部分ã®ã¿ãƒ€ãƒ³ãƒ—ã—ã¾ã™)\n" + +#: pg_dump.c:934 #, c-format msgid " --exclude-table-data=TABLE do NOT dump data for the named table(s)\n" msgstr " --exclude-table-data=TABLE 指定ã—ãŸãƒ†ãƒ¼ãƒ–ルã®ãƒ‡ãƒ¼ã‚¿ã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:892 pg_dumpall.c:564 +#: pg_dump.c:935 pg_dumpall.c:571 pg_restore.c:475 +#, c-format +msgid " --if-exists use IF EXISTS when dropping objects\n" +msgstr " --if-exists オブジェクトを削除ã™ã‚‹å ´åˆã« IF EXISTS を使用ã—ã¾ã™\n" + +#: pg_dump.c:936 pg_dumpall.c:572 #, c-format msgid " --inserts dump data as INSERT commands, rather than COPY\n" -msgstr " --inserts COPYã§ã¯ãªãINSERTコマンドã§ãƒ‡ãƒ¼ã‚¿ã‚’ダンプã—ã¾ã™\n" +msgstr " --inserts COPYã§ã¯ãªãINSERTコマンドã§ãƒ‡ãƒ¼ã‚¿ã‚’ダンプã—ã¾ã™\n" -#: pg_dump.c:893 pg_dumpall.c:565 +#: pg_dump.c:937 pg_dumpall.c:573 #, c-format msgid " --no-security-labels do not dump security label assignments\n" msgstr " --no-security-labels セキュリティラベルã®å‰²ã‚Šå½“ã¦ã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:894 +#: pg_dump.c:938 #, c-format msgid " --no-synchronized-snapshots do not use synchronized snapshots in parallel jobs\n" msgstr " --no-synchronized-snapshots 並行ジョブã«ãŠã„ã¦åŒæœŸåŒ–スナップショットを使用ã—ã¾ã›ã‚“\n" -#: pg_dump.c:895 pg_dumpall.c:566 +#: pg_dump.c:939 pg_dumpall.c:574 #, c-format msgid " --no-tablespaces do not dump tablespace assignments\n" msgstr " --no-tablespaces テーブルスペースã®å‰²ã‚Šå½“ã¦ã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:896 pg_dumpall.c:567 +#: pg_dump.c:940 pg_dumpall.c:575 #, c-format msgid " --no-unlogged-table-data do not dump unlogged table data\n" msgstr " --no-unlogged-table-data ログをå–らãªã„テーブルã®ãƒ‡ãƒ¼ã‚¿ã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dump.c:897 pg_dumpall.c:568 +#: pg_dump.c:941 pg_dumpall.c:576 #, c-format msgid " --quote-all-identifiers quote all identifiers, even if not key words\n" msgstr " --quote-all-identifiers ã™ã¹ã¦ã®è­˜åˆ¥å­ã‚’キーワードã§ãªã‹ã£ãŸã¨ã—ã¦ã‚‚引用符ã§ããã‚Šã¾ã™\n" -#: pg_dump.c:898 +#: pg_dump.c:942 #, c-format msgid " --section=SECTION dump named section (pre-data, data, or post-data)\n" msgstr " --section=SECTION 指定ã—ãŸã‚»ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆãƒ‡ãƒ¼ã‚¿å‰éƒ¨ã€ãƒ‡ãƒ¼ã‚¿ã€ãƒ‡ãƒ¼ã‚¿å¾Œéƒ¨ï¼‰ã‚’ダンプ\n" -#: pg_dump.c:899 +#: pg_dump.c:943 #, c-format msgid " --serializable-deferrable wait until the dump can run without anomalies\n" msgstr " --serializable-deferrable 例外ãªãダンプを実行ã§ãるよã†ã«ãªã‚‹ã¾ã§å¾…æ©Ÿã—ã¾ã™\n" -#: pg_dump.c:900 pg_dumpall.c:569 pg_restore.c:464 +#: pg_dump.c:944 +#, c-format +msgid " --snapshot=SNAPSHOT use given snapshot for the dump\n" +msgstr " --snapshot=SNAPSHOT ダンプ用ã«ä¸Žãˆã‚‰ã‚ŒãŸã‚¹ãƒŠãƒƒãƒ—ショットを使用ã—ã¾ã™\n" + +#: pg_dump.c:945 pg_restore.c:481 +#, c-format +msgid "" +" --strict-names require table and/or schema include patterns to\n" +" match at least one entity each\n" +msgstr "" +" --strict-names å°‘ãªãã¨ã‚‚1ã¤ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨ãƒžãƒƒãƒã™ã‚‹ãƒ‘ターンをå«ã‚€\n" +" テーブルãŠã‚ˆã³ã‚¹ã‚­ãƒ¼ãƒžãŒå¿…è¦ã§ã™\n" + +#: pg_dump.c:947 pg_dumpall.c:577 pg_restore.c:483 #, c-format msgid "" " --use-set-session-authorization\n" @@ -1604,10 +1673,10 @@ msgid "" " ALTER OWNER commands to set ownership\n" msgstr "" " --use-set-session-authorization\n" -" 所有者をセットã™ã‚‹éš›ã€ALTER OWNER コマンドã®ä»£ã‚ã‚Š\n" -" ã« SET SESSION AUTHORIZATION コマンドを使用ã™ã‚‹\n" +" 所有者をセットã™ã‚‹éš›ã€ALTER OWNER コマンドã®ä»£ã‚ã‚Šã«\n" +" SET SESSION AUTHORIZATION コマンドを使用ã—ã¾ã™\n" -#: pg_dump.c:904 pg_dumpall.c:573 pg_restore.c:468 +#: pg_dump.c:951 pg_dumpall.c:581 pg_restore.c:487 #, c-format msgid "" "\n" @@ -1616,45 +1685,44 @@ msgstr "" "\n" "接続オプション:\n" -#: pg_dump.c:905 +#: pg_dump.c:952 #, c-format -#| msgid " -d, --dbname=DBNAME database to cluster\n" msgid " -d, --dbname=DBNAME database to dump\n" msgstr " -d, --dbname=データベースå ダンプã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹\n" -#: pg_dump.c:906 pg_dumpall.c:575 pg_restore.c:469 +#: pg_dump.c:953 pg_dumpall.c:583 pg_restore.c:488 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory\n" msgstr " -h, --host=HOSTNAME データベースサーãƒã®ãƒ›ã‚¹ãƒˆã¾ãŸã¯ã‚½ã‚±ãƒƒãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã§ã™\n" -#: pg_dump.c:907 pg_dumpall.c:577 pg_restore.c:470 +#: pg_dump.c:954 pg_dumpall.c:585 pg_restore.c:489 #, c-format msgid " -p, --port=PORT database server port number\n" msgstr " -p, --port=PORT データベースサーãƒã®ãƒãƒ¼ãƒˆç•ªå·ã§ã™\n" -#: pg_dump.c:908 pg_dumpall.c:578 pg_restore.c:471 +#: pg_dump.c:955 pg_dumpall.c:586 pg_restore.c:490 #, c-format msgid " -U, --username=NAME connect as specified database user\n" msgstr " -U, --username=NAME 指定ã—ãŸãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ¦ãƒ¼ã‚¶ã§æŽ¥ç¶šã—ã¾ã™\n" -#: pg_dump.c:909 pg_dumpall.c:579 pg_restore.c:472 +#: pg_dump.c:956 pg_dumpall.c:587 pg_restore.c:491 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password パスワード入力をè¦æ±‚ã—ãªã„\n" -#: pg_dump.c:910 pg_dumpall.c:580 pg_restore.c:473 +#: pg_dump.c:957 pg_dumpall.c:588 pg_restore.c:492 #, c-format msgid " -W, --password force password prompt (should happen automatically)\n" msgstr "" " -W, --password パスワードプロンプトを強制表示ã—ã¾ã™\n" " （自動的ã«è¡¨ç¤ºã•ã‚Œã‚‹ã¯ãšã§ã™ï¼‰\n" -#: pg_dump.c:911 pg_dumpall.c:581 +#: pg_dump.c:958 pg_dumpall.c:589 #, c-format msgid " --role=ROLENAME do SET ROLE before dump\n" msgstr " --role=ROLENAME ダンプã®å‰ã« SET ROLE ã‚’è¡Œã„ã¾ã™\n" -#: pg_dump.c:913 +#: pg_dump.c:960 #, c-format msgid "" "\n" @@ -1666,378 +1734,453 @@ msgstr "" "データベースåãŒæŒ‡å®šã•ã‚Œãªã‹ã£ãŸå ´åˆã€ç’°å¢ƒå¤‰æ•°PGDATABASEãŒä½¿ç”¨ã•ã‚Œã¾ã™\n" "\n" -#: pg_dump.c:915 pg_dumpall.c:585 pg_restore.c:477 +#: pg_dump.c:962 pg_dumpall.c:593 pg_restore.c:499 #, c-format msgid "Report bugs to .\n" msgstr "ä¸å…·åˆã¯ã¾ã§å ±å‘Šã—ã¦ãã ã•ã„。\n" -#: pg_dump.c:933 +#: pg_dump.c:979 #, c-format msgid "invalid client encoding \"%s\" specified\n" msgstr "クライアントエンコーディング\"%s\"ã¯ç„¡åŠ¹ã§ã™\n" -#: pg_dump.c:1095 +#: pg_dump.c:1121 +#, c-format +msgid "" +"Synchronized snapshots are not supported on standby servers.\n" +"Run with --no-synchronized-snapshots instead if you do not need\n" +"synchronized snapshots.\n" +msgstr "" +"åŒæœŸåŒ–スナップショットã¯ã‚¹ã‚¿ãƒ³ãƒã‚¤ã‚µãƒ¼ãƒã§ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。\n" +"åŒæœŸåŒ–スナップショットãŒä¸è¦ãªã‚‰ã°--no-synchronized-snapshotsを付ã‘ã¦\n" +"実行ã—ã¦ãã ã•ã„。\n" + +#: pg_dump.c:1190 #, c-format msgid "invalid output format \"%s\" specified\n" msgstr "ä¸æ˜Žãªå‡ºåŠ›æ›¸å¼\"%s\"ãŒæŒ‡å®šã•ã‚Œã¾ã—ãŸ\n" -#: pg_dump.c:1117 +#: pg_dump.c:1213 #, c-format msgid "server version must be at least 7.3 to use schema selection switches\n" msgstr "" "スキーマé¸æŠžã‚¹ã‚¤ãƒƒãƒã‚’使用ã™ã‚‹ã«ã¯ã€ã‚µãƒ¼ãƒã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãŒ\n" "å°‘ãªãã¨ã‚‚ 7.3 以é™ã§ã‚ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚\n" -#: pg_dump.c:1393 +#: pg_dump.c:1231 +#, c-format +msgid "no matching schemas were found for pattern \"%s\"\n" +msgstr "パターン \"%s\" ã«ãƒžãƒƒãƒã™ã‚‹ã‚¹ã‚­ãƒ¼ãƒžãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" + +#: pg_dump.c:1284 +#, c-format +msgid "no matching tables were found for pattern \"%s\"\n" +msgstr "パターン \"%s\" ã«ãƒžãƒƒãƒã™ã‚‹ãƒ†ãƒ¼ãƒ–ルãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" + +#: pg_dump.c:1671 #, c-format -msgid "dumping contents of table %s\n" -msgstr "テーブル%sã®å†…容をダンプã—ã¦ã„ã¾ã™\n" +msgid "dumping contents of table \"%s.%s\"\n" +msgstr "テーブル \"%s.%s\" ã®å†…容をダンプã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:1516 +#: pg_dump.c:1795 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.\n" msgstr "テーブル\"%s\"ã®å†…容ã®ãƒ€ãƒ³ãƒ—ã«å¤±æ•—: PQgetCopyData()ãŒå¤±æ•—ã—ã¾ã—ãŸã€‚\n" -#: pg_dump.c:1517 pg_dump.c:1527 +#: pg_dump.c:1796 pg_dump.c:1806 #, c-format msgid "Error message from server: %s" msgstr "サーãƒã®ã‚¨ãƒ©ãƒ¼ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸: %s" -#: pg_dump.c:1518 pg_dump.c:1528 +#: pg_dump.c:1797 pg_dump.c:1807 #, c-format msgid "The command was: %s\n" msgstr "次ã®ã‚³ãƒžãƒ³ãƒ‰ã§ã—ãŸ: %s\n" -#: pg_dump.c:1526 +#: pg_dump.c:1805 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetResult() failed.\n" msgstr "テーブル\"%s\"ã®å†…容ã®ãƒ€ãƒ³ãƒ—ã«å¤±æ•—: PQgetResult()ãŒå¤±æ•—ã—ã¾ã—ãŸã€‚\n" -#: pg_dump.c:2136 +#: pg_dump.c:2454 #, c-format msgid "saving database definition\n" msgstr "データベース定義をä¿å­˜ã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:2433 +#: pg_dump.c:2788 #, c-format msgid "saving encoding = %s\n" msgstr "encoding = %s ã‚’ä¿å­˜ã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:2460 +#: pg_dump.c:2815 #, c-format msgid "saving standard_conforming_strings = %s\n" msgstr "standard_conforming_strings = %s ã‚’ä¿å­˜ã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:2493 +#: pg_dump.c:2855 #, c-format msgid "reading large objects\n" msgstr "ラージオブジェクトを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: pg_dump.c:2625 +#: pg_dump.c:3056 #, c-format msgid "saving large objects\n" msgstr "ラージオブジェクトをä¿å­˜ã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:2672 +#: pg_dump.c:3103 #, c-format msgid "error reading large object %u: %s" msgstr "ラージオブジェクト %u を読ã¿å–り中ã«ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã—ãŸ: %s" -#: pg_dump.c:2865 +#: pg_dump.c:3155 +#, c-format +msgid "reading row security enabled for table \"%s.%s\"\n" +msgstr "テーブル \"%s.%s\" ã«æœ‰åŠ¹ãªè¡Œã‚»ã‚­ãƒ¥ãƒªãƒ†ã‚£ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: pg_dump.c:3186 +#, c-format +msgid "reading policies for table \"%s.%s\"\n" +msgstr "テーブル\"%s.%s\"用ã®ãƒãƒªã‚·ãƒ¼ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: pg_dump.c:3319 +#, c-format +msgid "unexpected policy command type: \"%s\"\n" +msgstr "想定ã—ãªã„ãƒãƒªã‚·ãƒ¼ã‚³ãƒžãƒ³ãƒ‰ã‚¿ã‚¤ãƒ—: \"%s\"\n" + +#: pg_dump.c:3538 #, c-format msgid "could not find parent extension for %s\n" msgstr "%sã®è¦ªæ‹¡å¼µãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:2968 +#: pg_dump.c:3726 #, c-format msgid "WARNING: owner of schema \"%s\" appears to be invalid\n" msgstr "警告: スキーマ\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:3011 +#: pg_dump.c:3769 #, c-format msgid "schema with OID %u does not exist\n" msgstr "OID %uã®ã‚¹ã‚­ãƒ¼ãƒžãŒå­˜åœ¨ã—ã¾ã›ã‚“\n" -#: pg_dump.c:3361 +#: pg_dump.c:4184 #, c-format msgid "WARNING: owner of data type \"%s\" appears to be invalid\n" msgstr "警告: データ型\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:3472 +#: pg_dump.c:4298 #, c-format msgid "WARNING: owner of operator \"%s\" appears to be invalid\n" msgstr "警告: 演算å­\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:3729 +#: pg_dump.c:4643 #, c-format msgid "WARNING: owner of operator class \"%s\" appears to be invalid\n" msgstr "警告: 演算å­ã‚¯ãƒ©ã‚¹\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:3817 +#: pg_dump.c:4734 #, c-format msgid "WARNING: owner of operator family \"%s\" appears to be invalid\n" msgstr "警告: 演算å­æ—\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:3976 +#: pg_dump.c:4935 #, c-format msgid "WARNING: owner of aggregate function \"%s\" appears to be invalid\n" msgstr "警告: 集約関数\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:4180 +#: pg_dump.c:5232 #, c-format msgid "WARNING: owner of function \"%s\" appears to be invalid\n" msgstr "警告: 関数\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:4742 +#: pg_dump.c:6094 #, c-format msgid "WARNING: owner of table \"%s\" appears to be invalid\n" msgstr "警告: テーブル\"%s\"ã®æ‰€æœ‰è€…ãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:4893 +#: pg_dump.c:6136 pg_dump.c:16638 #, c-format -msgid "reading indexes for table \"%s\"\n" -msgstr "テーブル\"%s\"用ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" +msgid "failed sanity check, parent table OID %u of sequence OID %u not found\n" +msgstr "å¥å…¨æ€§æ¤œæŸ»ã«å¤±æ•—ã—ã¾ã—ãŸã€‚シーケンスOID %2$u ã®è¦ªãƒ†ãƒ¼ãƒ–ルOID %1$u ãŒã‚ã‚Šã¾ã›ã‚“\n" -#: pg_dump.c:5226 +#: pg_dump.c:6263 #, c-format -msgid "reading foreign key constraints for table \"%s\"\n" -msgstr "テーブル\"%s\"用ã®å¤–部キー制約を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" +msgid "reading indexes for table \"%s.%s\"\n" +msgstr "テーブル\"%s.%s\"用ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: pg_dump.c:5471 +#: pg_dump.c:6631 +#, c-format +msgid "reading foreign key constraints for table \"%s.%s\"\n" +msgstr "テーブル\"%s.%s\"用ã®å¤–部キー制約を読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" + +#: pg_dump.c:6877 #, c-format msgid "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not found\n" -msgstr "å¥å…¨æ€§æ¤œæŸ»ã«å¤±æ•—ã—ã¾ã—ãŸã€‚pg_rewriteé …ç›®OID %1$u ã®è¦ªãƒ†ãƒ¼ãƒ–ルOID %2$u ãŒã‚ã‚Šã¾ã›ã‚“\n" +msgstr "å¥å…¨æ€§æ¤œæŸ»ã«å¤±æ•—ã—ã¾ã—ãŸã€‚pg_rewriteé …ç›®OID %2$u ã®è¦ªãƒ†ãƒ¼ãƒ–ルOID %1$u ãŒã‚ã‚Šã¾ã›ã‚“\n" -#: pg_dump.c:5564 +#: pg_dump.c:6971 #, c-format -msgid "reading triggers for table \"%s\"\n" -msgstr "テーブル\"%s\"用ã®ãƒˆãƒªã‚¬ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" +msgid "reading triggers for table \"%s.%s\"\n" +msgstr "テーブル\"%s.%s\"用ã®ãƒˆãƒªã‚¬ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: pg_dump.c:5725 +#: pg_dump.c:7136 #, c-format msgid "query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of table: %u)\n" msgstr "テーブル\"%2$s\"上ã®å¤–部キートリガ\"%1$s\"用ã®éžå‚照テーブルåã®å•ã„åˆã‚ã›ãŒNULLã‚’è¿”ã—ã¾ã—ãŸ(テーブルã®OID: %3$u)\n" -#: pg_dump.c:6177 +#: pg_dump.c:7791 #, c-format -msgid "finding the columns and types of table \"%s\"\n" -msgstr "テーブル\"%s\"ã®åˆ—ã¨åž‹ã‚’検索ã—ã¦ã„ã¾ã™\n" +msgid "finding the columns and types of table \"%s.%s\"\n" +msgstr "テーブル\"%s.%s\"ã®åˆ—ã¨åž‹ã‚’検索ã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:6355 +#: pg_dump.c:7970 #, c-format msgid "invalid column numbering in table \"%s\"\n" msgstr "テーブル\"%s\"ã®åˆ—番å·ãŒç„¡åŠ¹ã§ã™\n" -#: pg_dump.c:6389 +#: pg_dump.c:8004 #, c-format -msgid "finding default expressions of table \"%s\"\n" -msgstr "テーブル\"%s\"ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå¼ã‚’検索ã—ã¦ã„ã¾ã™\n" +msgid "finding default expressions of table \"%s.%s\"\n" +msgstr "テーブル\"%s.%s\"ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå¼ã‚’検索ã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:6441 +#: pg_dump.c:8057 #, c-format msgid "invalid adnum value %d for table \"%s\"\n" msgstr "テーブル\"%2$s\"用ã®adnumã®å€¤%1$dãŒç„¡åŠ¹ã§ã™\n" -#: pg_dump.c:6513 +#: pg_dump.c:8129 #, c-format -msgid "finding check constraints for table \"%s\"\n" -msgstr "テーブル\"%s\"ã®æ¤œæŸ»åˆ¶ç´„を検索ã—ã¦ã„ã¾ã™\n" +msgid "finding check constraints for table \"%s.%s\"\n" +msgstr "テーブル\"%s.%s\"ã®æ¤œæŸ»åˆ¶ç´„を検索ã—ã¦ã„ã¾ã™\n" -#: pg_dump.c:6608 +#: pg_dump.c:8225 #, c-format msgid "expected %d check constraint on table \"%s\" but found %d\n" msgid_plural "expected %d check constraints on table \"%s\" but found %d\n" msgstr[0] "テーブル\"%2$s\"ã®æ¤œæŸ»åˆ¶ç´„ã¯%1$dã¨æœŸå¾…ã—ã¦ã„ã¾ã—ã¾ã—ãŸãŒã€%3$dã‚ã‚Šã¾ã—ãŸ\n" msgstr[1] "テーブル\"%2$s\"ã®æ¤œæŸ»åˆ¶ç´„ã¯%1$dã¨æœŸå¾…ã—ã¦ã„ã¾ã—ã¾ã—ãŸãŒã€%3$dã‚ã‚Šã¾ã—ãŸ\n" -#: pg_dump.c:6612 +#: pg_dump.c:8229 #, c-format msgid "(The system catalogs might be corrupted.)\n" msgstr "(システムカタログãŒç ´æã—ã¦ã„ã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™)\n" -#: pg_dump.c:7978 +#: pg_dump.c:9808 #, c-format msgid "WARNING: typtype of data type \"%s\" appears to be invalid\n" msgstr "警告: データ型\"%s\"ã®typtypeãŒç„¡åŠ¹ãªã‚ˆã†ã§ã™\n" -#: pg_dump.c:9427 +#: pg_dump.c:11350 #, c-format msgid "WARNING: bogus value in proargmodes array\n" msgstr "警告: proargnamesé…列内ã«ãŠã‹ã—ãªå€¤ãŒã‚ã‚Šã¾ã™\n" -#: pg_dump.c:9755 +#: pg_dump.c:11728 #, c-format msgid "WARNING: could not parse proallargtypes array\n" msgstr "警告: proallargtypesé…列ã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:9771 +#: pg_dump.c:11744 #, c-format msgid "WARNING: could not parse proargmodes array\n" msgstr "警告: proargmodesé…列ã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:9785 +#: pg_dump.c:11758 #, c-format msgid "WARNING: could not parse proargnames array\n" msgstr "警告: proargnamesé…列ã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:9796 +#: pg_dump.c:11769 #, c-format msgid "WARNING: could not parse proconfig array\n" msgstr "警告: proconfigé…列ã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:9853 +#: pg_dump.c:11840 #, c-format msgid "unrecognized provolatile value for function \"%s\"\n" msgstr "関数\"%s\"ã®provolatile値ãŒä¸æ˜Žã§ã™\n" -#: pg_dump.c:10073 +#: pg_dump.c:11884 pg_dump.c:13933 +#, c-format +msgid "unrecognized proparallel value for function \"%s\"\n" +msgstr "関数\"%s\"ã®proparallel値ãŒä¸æ˜Žã§ã™\n" + +#: pg_dump.c:11992 pg_dump.c:12102 pg_dump.c:12109 +#, c-format +msgid "could not find function definition for function with OID %u\n" +msgstr "OID %u ã®é–¢æ•°å®šç¾©ã‚’見ã¤ã‘られã¾ã›ã‚“ã§ã—ãŸ\n" + +#: pg_dump.c:12037 #, c-format msgid "WARNING: bogus value in pg_cast.castfunc or pg_cast.castmethod field\n" msgstr "警告: pg_cast.castfuncã¾ãŸã¯pg_cast.castmethodフィールドã«ç„¡åŠ¹ãªå€¤ãŒã‚ã‚Šã¾ã™\n" -#: pg_dump.c:10076 +#: pg_dump.c:12040 #, c-format msgid "WARNING: bogus value in pg_cast.castmethod field\n" msgstr "警告: pg_cast.castmethod フィールドã«ç„¡åŠ¹ãªå€¤ãŒã‚ã‚Šã¾ã™\n" -#: pg_dump.c:10445 +#: pg_dump.c:12130 +#, c-format +msgid "WARNING: bogus transform definition, at least one of trffromsql and trftosql should be nonzero\n" +msgstr "警告: 無効ãªå¤‰æ›å®šç¾©ãŒã‚ã‚Šã¾ã™ã€‚trffromsqlã¨trftosqlã®å°‘ãªãã¨ã‚‚ã©ã¡ã‚‰ã‹ã¯éžã‚¼ãƒ­ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" + +#: pg_dump.c:12147 +#, c-format +msgid "WARNING: bogus value in pg_transform.trffromsql field\n" +msgstr "警告: pg_transform.trffromsql フィールドã«ç„¡åŠ¹ãªå€¤ãŒã‚ã‚Šã¾ã™\n" + +#: pg_dump.c:12168 +#, c-format +msgid "WARNING: bogus value in pg_transform.trftosql field\n" +msgstr "警告: pg_transform.trftosql フィールドã«ç„¡åŠ¹ãªå€¤ãŒã‚ã‚Šã¾ã™\n" + +#: pg_dump.c:12559 #, c-format msgid "WARNING: could not find operator with OID %s\n" msgstr "警告: OID %sã®æ¼”ç®—å­ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:11507 +#: pg_dump.c:12623 +#, c-format +msgid "WARNING: invalid type \"%c\" of access method \"%s\"\n" +msgstr "警告: アクセスメソッド \"%2$s\" ã®åž‹ \"%1$c\" ã¯ç„¡åŠ¹ã§ã™\n" + +#: pg_dump.c:13824 #, c-format msgid "WARNING: aggregate function %s could not be dumped correctly for this database version; ignored\n" msgstr "警告: ã“ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®é›†ç´„関数%sを正確ã«ãƒ€ãƒ³ãƒ—ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚(無視ã—ã¾ã™)\n" -#: pg_dump.c:12283 +#: pg_dump.c:14696 #, c-format -#| msgid "unknown object type (%d) in default privileges\n" msgid "unrecognized object type in default privileges: %d\n" msgstr "デフォルト権é™å†…ã®èªè­˜ã§ããªã„オブジェクト型: %d\n" -#: pg_dump.c:12298 +#: pg_dump.c:14714 #, c-format msgid "could not parse default ACL list (%s)\n" msgstr "デフォルト㮠ACL リスト(%s)を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:12353 +#: pg_dump.c:14785 +#, c-format +msgid "could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) for object \"%s\" (%s)\n" +msgstr "オブジェクト\"%3$s\"(%4$s)用ã®åˆæœŸã®GRANT ACL リスト(%1$s) ã¾ãŸã¯åˆæœŸã®REVOKE ACL リスト(%2$s) を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" + +#: pg_dump.c:14793 #, c-format -msgid "could not parse ACL list (%s) for object \"%s\" (%s)\n" -msgstr "オブジェクト\"%2$s\"(%3$s)用ã®ACLリスト(%1$s)を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" +msgid "could not parse GRANT ACL list (%s) or REVOKE ACL list (%s) for object \"%s\" (%s)\n" +msgstr "オブジェクト\"%3$s\"(%4$s)用ã®GRANT ACL リスト(%1$s) ã¾ãŸã¯REVOKE ACL リスト(%2$s) を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump.c:12771 +#: pg_dump.c:15278 #, c-format msgid "query to obtain definition of view \"%s\" returned no data\n" msgstr "ビュー\"%s\"ã®å®šç¾©ã‚’å–り出ã™ãŸã‚ã®å•ã„åˆã‚ã›ãŒç©ºã‚’è¿”ã—ã¾ã—ãŸ\n" -#: pg_dump.c:12774 +#: pg_dump.c:15281 #, c-format msgid "query to obtain definition of view \"%s\" returned more than one definition\n" msgstr "ビュー\\\"%s\\\"ã®å®šç¾©ã‚’å–り出ã™ãŸã‚ã®å•ã„åˆã‚ã›ãŒè¤‡æ•°ã®å®šç¾©ã‚’è¿”ã—ã¾ã—ãŸ\n" -#: pg_dump.c:12781 +#: pg_dump.c:15288 #, c-format msgid "definition of view \"%s\" appears to be empty (length zero)\n" msgstr "ビュー\\\"%s\\\"ã®å®šç¾©ãŒç©º(é•·ã•ãŒ0)ã®ã‚ˆã†ã§ã™\n" -#: pg_dump.c:13493 +#: pg_dump.c:16047 #, c-format msgid "invalid column number %d for table \"%s\"\n" msgstr "テーブル\"%2$s\"ã®åˆ—番å·%1$dã¯ç„¡åŠ¹ã§ã™\n" -#: pg_dump.c:13608 +#: pg_dump.c:16176 #, c-format msgid "missing index for constraint \"%s\"\n" msgstr "制約\"%s\"用ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: pg_dump.c:13795 +#: pg_dump.c:16379 #, c-format msgid "unrecognized constraint type: %c\n" msgstr "制約種類ãŒä¸æ˜Žã§ã™: %c\n" -#: pg_dump.c:13944 pg_dump.c:14108 +#: pg_dump.c:16533 pg_dump.c:16706 #, c-format msgid "query to get data of sequence \"%s\" returned %d row (expected 1)\n" msgid_plural "query to get data of sequence \"%s\" returned %d rows (expected 1)\n" msgstr[0] "シーケンス\"%s\"ã®ãƒ‡ãƒ¼ã‚¿ã‚’å¾—ã‚‹ãŸã‚ã®å•ã„åˆã‚ã›ãŒ%d行返ã—ã¾ã—ãŸ(想定行数ã¯1)\n" msgstr[1] "シーケンス\"%s\"ã®ãƒ‡ãƒ¼ã‚¿ã‚’å¾—ã‚‹ãŸã‚ã®å•ã„åˆã‚ã›ãŒ%d行返ã—ã¾ã—ãŸ(想定行数ã¯1)\n" -#: pg_dump.c:13955 +#: pg_dump.c:16544 #, c-format msgid "query to get data of sequence \"%s\" returned name \"%s\"\n" msgstr "シーケンス \"%s\"ã®ãƒ‡ãƒ¼ã‚¿ã‚’å¾—ã‚‹ãŸã‚ã®å•ã„åˆã‚ã›ãŒåå‰ \"%s\" ã‚’è¿”ã—ã¾ã—ãŸ\n" -#: pg_dump.c:14195 +#: pg_dump.c:16804 #, c-format msgid "unexpected tgtype value: %d\n" msgstr "想定外ã®tgtype値: %d\n" -#: pg_dump.c:14277 +#: pg_dump.c:16886 #, c-format msgid "invalid argument string (%s) for trigger \"%s\" on table \"%s\"\n" msgstr "テーブル\"%3$s\"ã®ãƒˆãƒªã‚¬\"%2$s\"用ã®å¼•æ•°æ–‡å­—列(%1$s)ãŒç„¡åŠ¹ã§ã™\n" -#: pg_dump.c:14457 +#: pg_dump.c:17083 #, c-format msgid "query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned\n" msgstr "" "テーブル\"%2$s\"用ã®ãƒ«ãƒ¼ãƒ«\"%1$s\"ã‚’å¾—ã‚‹ãŸã‚ã®å•ã„åˆã‚ã›ã«å¤±æ•—ã—ã¾ã—ãŸ:行数ãŒ\n" "é–“é•ã£ã¦ã„ã¾ã™\n" -#: pg_dump.c:14758 +#: pg_dump.c:17472 #, c-format msgid "reading dependency data\n" msgstr "データã®ä¾å­˜æ€§ã‚’読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: pg_dump.c:15303 +#: pg_dump.c:18029 #, c-format -msgid "query returned %d row instead of one: %s\n" -msgid_plural "query returned %d rows instead of one: %s\n" -msgstr[0] "å•ã„åˆã‚ã›ãŒ1è¡Œã§ã¯ãªã%d行返ã—ã¾ã—ãŸ: %s\n" -msgstr[1] "å•ã„åˆã‚ã›ãŒ1è¡Œã§ã¯ãªã%d行返ã—ã¾ã—ãŸ: %s\n" +msgid "WARNING: could not parse reloptions array\n" +msgstr "警告: reloptionsé…列ã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" #. translator: this is a module name -#: pg_dump_sort.c:21 +#: pg_dump_sort.c:23 msgid "sorter" msgstr "sorter" -#: pg_dump_sort.c:465 +#: pg_dump_sort.c:491 #, c-format msgid "invalid dumpId %d\n" msgstr "無効ãªdumpId %d\n" -#: pg_dump_sort.c:471 +#: pg_dump_sort.c:497 #, c-format msgid "invalid dependency %d\n" msgstr "無効ãªä¾å­˜é–¢ä¿‚ %d\n" -#: pg_dump_sort.c:685 +#: pg_dump_sort.c:730 #, c-format msgid "could not identify dependency loop\n" msgstr "ä¾å­˜é–¢ä¿‚ã®ãƒ«ãƒ¼ãƒ—を識別ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dump_sort.c:1135 +#: pg_dump_sort.c:1262 #, c-format -msgid "NOTICE: there are circular foreign-key constraints among these table(s):\n" -msgstr "注æ„: 次ã®ãƒ†ãƒ¼ãƒ–ルã®ä¸­ã§å¤–部キー制約ã®å¾ªç’°ãŒã‚ã‚Šã¾ã™\n" +msgid "NOTICE: there are circular foreign-key constraints on this table:\n" +msgid_plural "NOTICE: there are circular foreign-key constraints among these tables:\n" +msgstr[0] "注æ„: 次ã®ãƒ†ãƒ¼ãƒ–ルã®ä¸­ã§å¤–部キー制約ã®å¾ªç’°ãŒã‚ã‚Šã¾ã™\n" +msgstr[1] "注æ„: 次ã®ãƒ†ãƒ¼ãƒ–ルã®ä¸­ã§å¤–部キー制約ã®å¾ªç’°ãŒã‚ã‚Šã¾ã™\n" -#: pg_dump_sort.c:1137 pg_dump_sort.c:1157 +#: pg_dump_sort.c:1266 pg_dump_sort.c:1286 #, c-format msgid " %s\n" msgstr " %s\n" -#: pg_dump_sort.c:1138 +#: pg_dump_sort.c:1267 #, c-format msgid "You might not be able to restore the dump without using --disable-triggers or temporarily dropping the constraints.\n" msgstr "--disable-triggersã®ä½¿ç”¨ã¾ãŸã¯ä¸€æ™‚çš„ãªåˆ¶ç´„ã®å‰Šé™¤ã‚’è¡Œã‚ãšã«ãƒ€ãƒ³ãƒ—をリストアã™ã‚‹ã“ã¨ã¯ã§ããªã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。\n" -#: pg_dump_sort.c:1139 +#: pg_dump_sort.c:1268 #, c-format msgid "Consider using a full dump instead of a --data-only dump to avoid this problem.\n" msgstr "ã“ã®å•é¡Œã‚’回é¿ã™ã‚‹ãŸã‚ã«--data-onlyダンプã®ä»£ã‚ã‚Šã«å®Œå…¨ãªãƒ€ãƒ³ãƒ—を使用ã™ã‚‹ã“ã¨ã‚’検討ã—ã¦ãã ã•ã„。\n" -#: pg_dump_sort.c:1151 +#: pg_dump_sort.c:1280 #, c-format msgid "WARNING: could not resolve dependency loop among these items:\n" msgstr "警告: ã“れらã®é …ç›®ã®ä¸­ã®ä¾å­˜é–¢ä¿‚ã®ãƒ«ãƒ¼ãƒ—を識別ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" @@ -2064,31 +2207,36 @@ msgstr "" "ã›ã‚“ã§ã—ãŸã€‚\n" "インストールã®çŠ¶æ³ã‚’確èªã—ã¦ãã ã•ã„。\n" -#: pg_dumpall.c:321 +#: pg_dumpall.c:317 #, c-format msgid "%s: options -g/--globals-only and -r/--roles-only cannot be used together\n" msgstr "\"%s: -g/--globals-onlyオプションã¨-r/--roles-onlyオプションã¯åŒæ™‚ã«ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_dumpall.c:330 +#: pg_dumpall.c:326 #, c-format msgid "%s: options -g/--globals-only and -t/--tablespaces-only cannot be used together\n" msgstr "" "\"%s: -g/--globals-onlyオプションã¨-t/--tablespaces-onlyオプションã¯åŒæ™‚\n" "ã«ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_dumpall.c:339 +#: pg_dumpall.c:335 pg_restore.c:361 +#, c-format +msgid "%s: option --if-exists requires option -c/--clean\n" +msgstr "%s: --if-exists オプション㯠-c/--clean オプションを必è¦ã¨ã—ã¾ã™\n" + +#: pg_dumpall.c:342 #, c-format msgid "%s: options -r/--roles-only and -t/--tablespaces-only cannot be used together\n" msgstr "" "\"%s: -r/--roles-onlyオプションã¨-t/--tablespaces-onlyオプション)ã¯åŒæ™‚\n" "ã«ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_dumpall.c:381 pg_dumpall.c:1821 +#: pg_dumpall.c:384 pg_dumpall.c:1995 #, c-format msgid "%s: could not connect to database \"%s\"\n" msgstr "%s: データベース\"%s\"ã¸æŽ¥ç¶šã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dumpall.c:396 +#: pg_dumpall.c:399 #, c-format msgid "" "%s: could not connect to databases \"postgres\" or \"template1\"\n" @@ -2097,12 +2245,12 @@ msgstr "" "%s: \"postgres\"ã¾ãŸã¯\"template1\"データベースã«æŽ¥ç¶šã§ãã¾ã›ã‚“ã§ã—ãŸ\n" "ä»–ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’指定ã—ã¦ãã ã•ã„。\n" -#: pg_dumpall.c:413 +#: pg_dumpall.c:416 #, c-format msgid "%s: could not open the output file \"%s\": %s\n" msgstr "%s: 出力ファイル \"%s\" をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_dumpall.c:540 +#: pg_dumpall.c:546 #, c-format msgid "" "%s extracts a PostgreSQL database cluster into an SQL script file.\n" @@ -2111,60 +2259,59 @@ msgstr "" "%sã¯PostgreSQLデータベースクラスタをSQLスクリプトファイルã«å±•é–‹ã—ã¾ã™ã€‚\n" "\n" -#: pg_dumpall.c:542 +#: pg_dumpall.c:548 #, c-format msgid " %s [OPTION]...\n" msgstr " %s [OPTION]...\n" -#: pg_dumpall.c:545 +#: pg_dumpall.c:551 #, c-format msgid " -f, --file=FILENAME output file name\n" msgstr " -f, --file=ファイルå 出力ファイルå\n" -#: pg_dumpall.c:551 +#: pg_dumpall.c:558 #, c-format msgid " -c, --clean clean (drop) databases before recreating\n" msgstr " -c, --clean å†ä½œæˆå‰ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’æ•´ç†ï¼ˆå‰Šé™¤ï¼‰\n" -#: pg_dumpall.c:552 +#: pg_dumpall.c:559 #, c-format msgid " -g, --globals-only dump only global objects, no databases\n" msgstr " -g, --globals-only グローãƒãƒ«ã‚ªãƒ–ジェクトã®ã¿ã‚’ダンプã—ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dumpall.c:554 pg_restore.c:450 +#: pg_dumpall.c:561 pg_restore.c:465 #, c-format msgid " -O, --no-owner skip restoration of object ownership\n" msgstr " -O, --no-owner オブジェクトã®æ‰€æœ‰æ¨©ã®å¾©å…ƒã‚’çœç•¥\n" -#: pg_dumpall.c:555 +#: pg_dumpall.c:562 #, c-format msgid " -r, --roles-only dump only roles, no databases or tablespaces\n" msgstr "" " -r, --roles-only ロールã®ã¿ã‚’ダンプ。\n" " データベースã¨ãƒ†ãƒ¼ãƒ–ル空間をダンプã—ã¾ã›ã‚“\n" -#: pg_dumpall.c:557 +#: pg_dumpall.c:564 #, c-format msgid " -S, --superuser=NAME superuser user name to use in the dump\n" msgstr " -S, --superuser=NAME ダンプã§ä½¿ç”¨ã™ã‚‹ã‚¹ãƒ¼ãƒ‘ーユーザã®ãƒ¦ãƒ¼ã‚¶åを指定\n" -#: pg_dumpall.c:558 +#: pg_dumpall.c:565 #, c-format msgid " -t, --tablespaces-only dump only tablespaces, no databases or roles\n" msgstr " -t, --tablespaces-only テーブル空間ã®ã¿ã‚’ダンプ。データベースã¨ãƒ­ãƒ¼ãƒ«ã‚’ダンプã—ã¾ã›ã‚“\n" -#: pg_dumpall.c:574 +#: pg_dumpall.c:582 #, c-format -#| msgid " -d, --dbname=CONNSTR connection string\n" msgid " -d, --dbname=CONNSTR connect using connection string\n" msgstr " -d, --dbname=CONSTR 接続文字列を用ã„ãŸæŽ¥ç¶š\n" -#: pg_dumpall.c:576 +#: pg_dumpall.c:584 #, c-format msgid " -l, --database=DBNAME alternative default database\n" msgstr " -l, --database=DBNAME 代替ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’指定\n" -#: pg_dumpall.c:583 +#: pg_dumpall.c:591 #, c-format msgid "" "\n" @@ -2176,105 +2323,112 @@ msgstr "" "-f/--file ãŒæŒ‡å®šã•ã‚Œãªã„å ´åˆã€SQLスクリプトã¯æ¨™æº–出力ã«æ›¸ã出ã•ã‚Œã¾ã™ã€‚\n" "\n" -#: pg_dumpall.c:1083 +#: pg_dumpall.c:792 +#, c-format +msgid "%s: role name starting with \"pg_\" skipped (%s)\n" +msgstr "%s: \"pg_\"ã§å§‹ã¾ã‚‹ãƒ­ãƒ¼ãƒ«å(%s)を飛ã°ã—ã¾ã™\n" + +#: pg_dumpall.c:1169 #, c-format msgid "%s: could not parse ACL list (%s) for tablespace \"%s\"\n" msgstr "%1$s: テーブル空間\"%3$s\"ã®ACLリスト(%2$s)を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dumpall.c:1387 +#: pg_dumpall.c:1537 #, c-format msgid "%s: could not parse ACL list (%s) for database \"%s\"\n" msgstr "%1$s: データベース\"%3$s\"ã®ACLリスト(%2$s)を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dumpall.c:1597 +#: pg_dumpall.c:1755 #, c-format msgid "%s: dumping database \"%s\"...\n" msgstr "%s: データベース\"%s\"をダンプã—ã¦ã„ã¾ã™...\n" -#: pg_dumpall.c:1607 +#: pg_dumpall.c:1779 #, c-format msgid "%s: pg_dump failed on database \"%s\", exiting\n" msgstr "%s: データベース\"%s\"ã«å¯¾ã™ã‚‹pg_dumpãŒå¤±æ•—ã—ã¾ã—ãŸã€‚終了ã—ã¾ã™\n" -#: pg_dumpall.c:1616 +#: pg_dumpall.c:1788 #, c-format msgid "%s: could not re-open the output file \"%s\": %s\n" msgstr "%s: 出力ファイル \"%s\" ã‚’å†ã‚ªãƒ¼ãƒ—ンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_dumpall.c:1663 +#: pg_dumpall.c:1833 #, c-format msgid "%s: running \"%s\"\n" msgstr "%s: \"%s\"を実行ã—ã¦ã„ã¾ã™\n" -#: pg_dumpall.c:1843 +#: pg_dumpall.c:2017 #, c-format msgid "%s: could not connect to database \"%s\": %s\n" msgstr "%s: データベース\"%s\"ã¸æŽ¥ç¶šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: pg_dumpall.c:1873 +#: pg_dumpall.c:2047 #, c-format msgid "%s: could not get server version\n" msgstr "%s: サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’入手ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dumpall.c:1879 +#: pg_dumpall.c:2053 #, c-format msgid "%s: could not parse server version \"%s\"\n" msgstr "%s: サーãƒãƒãƒ¼ã‚¸ãƒ§ãƒ³\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pg_dumpall.c:1957 pg_dumpall.c:1983 +#: pg_dumpall.c:2131 pg_dumpall.c:2157 #, c-format msgid "%s: executing %s\n" msgstr "%s: %sを実行ã—ã¦ã„ã¾ã™\n" -#: pg_dumpall.c:1963 pg_dumpall.c:1989 +#: pg_dumpall.c:2137 pg_dumpall.c:2163 #, c-format msgid "%s: query failed: %s" msgstr "%s: å•ã„åˆã‚ã›ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s" -#: pg_dumpall.c:1965 pg_dumpall.c:1991 +#: pg_dumpall.c:2139 pg_dumpall.c:2165 #, c-format msgid "%s: query was: %s\n" msgstr "%s: å•ã„åˆã‚ã›: %s\n" -#: pg_restore.c:308 +#: pg_restore.c:305 #, c-format msgid "%s: options -d/--dbname and -f/--file cannot be used together\n" msgstr "\"%s: -d/--dbnameオプションã¨-f/--fileオプションã¯åŒæ™‚ã«ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_restore.c:319 +#: pg_restore.c:316 #, c-format -#| msgid "options -s/--schema-only and -a/--data-only cannot be used together\n" msgid "%s: options -s/--schema-only and -a/--data-only cannot be used together\n" msgstr "%s: -s/--schema-only 㨠-a/--data-only ã¯åŒæ™‚ã«ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_restore.c:326 +#: pg_restore.c:323 #, c-format -#| msgid "options -c/--clean and -a/--data-only cannot be used together\n" msgid "%s: options -c/--clean and -a/--data-only cannot be used together\n" msgstr "%s: -c/--clean 㨠-a/--data-only ã¯åŒæ™‚ã«ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“\n" -#: pg_restore.c:334 +#: pg_restore.c:330 +#, c-format +msgid "%s: invalid number of parallel jobs\n" +msgstr "%s: 無効ãªä¸¦è¡Œã‚¸ãƒ§ãƒ–æ•°ã§ã™\n" + +#: pg_restore.c:338 +#, c-format +msgid "%s: maximum number of parallel jobs is %d\n" +msgstr "%s: 並行ジョブã®æœ€å¤§æ•°ã¯%dã§ã™\n" + +#: pg_restore.c:347 #, c-format msgid "%s: cannot specify both --single-transaction and multiple jobs\n" msgstr "%s: --single-transaction ã¨ä¸¦åˆ—ジョブã¯åŒæ™‚ã«ã¯æŒ‡å®šã§ãã¾ã›ã‚“\n" -#: pg_restore.c:365 +#: pg_restore.c:388 #, c-format msgid "unrecognized archive format \"%s\"; please specify \"c\", \"d\", or \"t\"\n" msgstr "未知ã®ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–フォーマット\"%s\"; \"c\"ã€\"d\"ã¾ãŸã¯\"t\"を指定ã—ã¦ãã ã•ã„\n" -#: pg_restore.c:395 -#, c-format -#| msgid "maximum number of prepared transactions reached" -msgid "%s: maximum number of parallel jobs is %d\n" -msgstr "%s: 並行ジョブã®æœ€å¤§æ•°ã¯%dã§ã™\n" - -#: pg_restore.c:413 +#: pg_restore.c:428 #, c-format msgid "WARNING: errors ignored on restore: %d\n" msgstr "警告: リストアã«ã¦ã‚¨ãƒ©ãƒ¼ã‚’無視ã—ã¾ã—ãŸ: %d\n" -#: pg_restore.c:427 +#: pg_restore.c:442 #, c-format msgid "" "%s restores a PostgreSQL database from an archive created by pg_dump.\n" @@ -2283,49 +2437,49 @@ msgstr "" "%sã¯pg_dumpã§ä½œæˆã—ãŸã‚¢ãƒ¼ã‚«ã‚¤ãƒ–ã‹ã‚‰PostgreSQLデータベースをリストアã—ã¾ã™ã€‚\n" "\n" -#: pg_restore.c:429 +#: pg_restore.c:444 #, c-format msgid " %s [OPTION]... [FILE]\n" msgstr " %s [OPTION]... [FILE]\n" -#: pg_restore.c:432 +#: pg_restore.c:447 #, c-format msgid " -d, --dbname=NAME connect to database name\n" msgstr " -d, --dbname=NAME 接続ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å\n" -#: pg_restore.c:433 +#: pg_restore.c:448 #, c-format msgid " -f, --file=FILENAME output file name\n" msgstr " -f, --file=FILENAME 出力ファイルåã§ã™\n" -#: pg_restore.c:434 +#: pg_restore.c:449 #, c-format msgid " -F, --format=c|d|t backup file format (should be automatic)\n" msgstr "" " -F, --format=c|d|t ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ファイルã®æ›¸å¼\n" " （自動的ã«è¨­å®šã•ã‚Œã‚‹ã¯ãšã§ã™ï¼‰\n" -#: pg_restore.c:435 +#: pg_restore.c:450 #, c-format msgid " -l, --list print summarized TOC of the archive\n" msgstr " -l, --list アーカイブã®TOCã®è¦ç´„を表示\n" -#: pg_restore.c:436 +#: pg_restore.c:451 #, c-format msgid " -v, --verbose verbose mode\n" msgstr " -v, --verbose 冗長モードã§ã™\n" -#: pg_restore.c:437 +#: pg_restore.c:452 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_restore.c:438 +#: pg_restore.c:453 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: pg_restore.c:440 +#: pg_restore.c:455 #, c-format msgid "" "\n" @@ -2334,32 +2488,32 @@ msgstr "" "\n" "リストア制御用ã®ã‚ªãƒ—ション:\n" -#: pg_restore.c:441 +#: pg_restore.c:456 #, c-format msgid " -a, --data-only restore only the data, no schema\n" msgstr " -a, --data-only データã®ã¿ã‚’リストア。スキーマをリストアã—ã¾ã›ã‚“\n" -#: pg_restore.c:443 +#: pg_restore.c:458 #, c-format msgid " -C, --create create the target database\n" msgstr " -C, --create 対象ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’作æˆ\n" -#: pg_restore.c:444 +#: pg_restore.c:459 #, c-format msgid " -e, --exit-on-error exit on error, default is to continue\n" msgstr " -e, --exit-on-error エラー時ã«çµ‚了。デフォルトã¯ç¶™ç¶š\n" -#: pg_restore.c:445 +#: pg_restore.c:460 #, c-format msgid " -I, --index=NAME restore named index\n" msgstr " -I, --index=NAME 指åã—ãŸã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’リストア\n" -#: pg_restore.c:446 +#: pg_restore.c:461 #, c-format msgid " -j, --jobs=NUM use this many parallel jobs to restore\n" msgstr " -j, --jobs=NUM リストア時ã«æŒ‡å®šã—ãŸæ•°ã®ä¸¦åˆ—ジョブを使用\n" -#: pg_restore.c:447 +#: pg_restore.c:462 #, c-format msgid "" " -L, --use-list=FILENAME use table of contents from this file for\n" @@ -2368,48 +2522,52 @@ msgstr "" " -L, --use-list=FILENAME ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã®å†…容ã«å¾“ã£ã¦ SELECT ã‚„\n" " 出力ã®ã‚½ãƒ¼ãƒˆã‚’è¡Œã„ã¾ã™\n" -#: pg_restore.c:449 +#: pg_restore.c:464 #, c-format msgid " -n, --schema=NAME restore only objects in this schema\n" msgstr " -n, --schema=NAME 指定ã—ãŸã‚¹ã‚­ãƒ¼ãƒžã®ã‚ªãƒ–ジェクトã®ã¿ã‚’リストア\n" -#: pg_restore.c:451 +#: pg_restore.c:466 #, c-format msgid " -P, --function=NAME(args) restore named function\n" msgstr " -P, --function=NAME(args) 指åã•ã‚ŒãŸé–¢æ•°ã‚’リストア\n" -#: pg_restore.c:452 +#: pg_restore.c:467 #, c-format msgid " -s, --schema-only restore only the schema, no data\n" msgstr " -s, --schema-only スキーマã®ã¿ã‚’リストア。データをリストアã—ã¾ã›ã‚“\n" -#: pg_restore.c:453 +#: pg_restore.c:468 #, c-format msgid " -S, --superuser=NAME superuser user name to use for disabling triggers\n" msgstr " -S, --superuser=NAME トリガを無効ã«ã™ã‚‹ãŸã‚ã®ã‚¹ãƒ¼ãƒ‘ーユーザã®åå‰\n" -#: pg_restore.c:454 +#: pg_restore.c:469 #, c-format -#| msgid " -t, --table=NAME restore named table\n" -msgid " -t, --table=NAME restore named table(s)\n" -msgstr " -t, --table=NAME 指åã—ãŸãƒ†ãƒ¼ãƒ–ル(複数å¯)をリストア\n" +msgid " -t, --table=NAME restore named relation (table, view, etc.)\n" +msgstr " -t, --table=NAME 指定ã•ã‚ŒãŸãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³(テーブルã€ãƒ“ューã€ãªã©)をリストア\n" -#: pg_restore.c:455 +#: pg_restore.c:470 #, c-format msgid " -T, --trigger=NAME restore named trigger\n" msgstr " -T, --trigger=NAME 指åã—ãŸãƒˆãƒªã‚¬ã‚’リストア\n" -#: pg_restore.c:456 +#: pg_restore.c:471 #, c-format msgid " -x, --no-privileges skip restoration of access privileges (grant/revoke)\n" msgstr " -x, --no-privileges アクセス権é™(grant/revoke)ã®å¾©å…ƒã‚’çœç•¥\n" -#: pg_restore.c:457 +#: pg_restore.c:472 #, c-format msgid " -1, --single-transaction restore as a single transaction\n" msgstr " -1, --single-transaction å˜ä¸€ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã¨ã—ã¦ãƒªã‚¹ãƒˆã‚¢\n" -#: pg_restore.c:459 +#: pg_restore.c:474 +#, c-format +msgid " --enable-row-security enable row security\n" +msgstr " --enable-row-security 行セキュリティを有効ã«ã™ã‚‹\n" + +#: pg_restore.c:476 #, c-format msgid "" " --no-data-for-failed-tables do not restore data of tables that could not be\n" @@ -2418,27 +2576,38 @@ msgstr "" " --no-data-for-failed-tables 作æˆã§ããªã‹ã£ãŸãƒ†ãƒ¼ãƒƒãƒ–ルã®ãƒ‡ãƒ¼ã‚¿ã¯ãƒªã‚¹ãƒˆã‚¢\n" " ã—ã¾ã›ã‚“\n" -#: pg_restore.c:461 +#: pg_restore.c:478 #, c-format msgid " --no-security-labels do not restore security labels\n" msgstr " --no-security-labels セキュリティラベルをリストアã—ã¾ã›ã‚“\n" -#: pg_restore.c:462 +#: pg_restore.c:479 #, c-format msgid " --no-tablespaces do not restore tablespace assignments\n" msgstr " --no-tablespaces テーブル空間ã®å‰²ã‚Šå½“ã¦ã‚’リストアã—ã¾ã›ã‚“\n" -#: pg_restore.c:463 +#: pg_restore.c:480 #, c-format msgid " --section=SECTION restore named section (pre-data, data, or post-data)\n" msgstr " --section=SECTION 指定ã•ã‚ŒãŸã‚»ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆãƒ‡ãƒ¼ã‚¿å‰éƒ¨ã€ãƒ‡ãƒ¼ã‚¿ã€ãƒ‡ãƒ¼ã‚¿å¾Œéƒ¨ï¼‰ã‚’リストア\n" -#: pg_restore.c:474 +#: pg_restore.c:493 #, c-format msgid " --role=ROLENAME do SET ROLE before restore\n" msgstr " --role=ROLENAME リストアã«å…ˆç«‹ã£ã¦ SET ROLE ã—ã¾ã™\n" -#: pg_restore.c:476 +#: pg_restore.c:495 +#, c-format +msgid "" +"\n" +"The options -I, -n, -P, -t, -T, and --section can be combined and specified\n" +"multiple times to select multiple objects.\n" +msgstr "" +"\n" +"オプション -I, -n, -P, -t, -T, 㨠--section ã¯è¤‡æ•°ã®ã‚ªãƒ–ジェクトをé¸æŠžã™ã‚‹ãŸã‚ã«\n" +"複数回組ã¿åˆã‚ã›ã¦æŒ‡å®šã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚\n" + +#: pg_restore.c:498 #, c-format msgid "" "\n" @@ -2449,151 +2618,3 @@ msgstr "" "入力ファイルåãŒæŒ‡å®šã•ã‚Œãªã„å ´åˆã€æ¨™æº–入力ãŒä½¿ç”¨ã•ã‚Œã¾ã™ã€‚\n" "\n" -#~ msgid "child process was terminated by signal %d" -#~ msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%dã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid "could not change directory to \"%s\"" -#~ msgstr "ディレクトリを\"%s\"ã«å¤‰æ›´ã§ãã¾ã›ã‚“ã§ã—ãŸ" - -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" - -#~ msgid "file archiver" -#~ msgstr "ファイルアーカイãƒ" - -#~ msgid "could not create worker thread: %s\n" -#~ msgstr "ワーカースレッドを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#~ msgid "*** aborted because of error\n" -#~ msgstr "*** エラーã®ãŸã‚中断\n" - -#~ msgid "found more than one entry for pg_indexes in pg_class\n" -#~ msgstr "pg_class内ã«pg_indexes用ã®ã‚¨ãƒ³ãƒˆãƒªãŒè¤‡æ•°ã‚ã‚Šã¾ã—ãŸ\n" - -#~ msgid "cannot reopen non-seekable file\n" -#~ msgstr "シークã§ããªã„ファイルをå†ã‚ªãƒ¼ãƒ—ンã§ãã¾ã›ã‚“\n" - -#~ msgid "restoring large object OID %u\n" -#~ msgstr "OID %uã®ãƒ©ãƒ¼ã‚¸ã‚ªãƒ–ジェクトをリストアã—ã¦ã„ã¾ã™\n" - -#~ msgid "cannot reopen stdin\n" -#~ msgstr "標準入力をå†ã‚ªãƒ¼ãƒ—ンã§ãã¾ã›ã‚“\n" - -#~ msgid "could not find entry for pg_indexes in pg_class\n" -#~ msgstr "pg_class内ã«pg_indexes用ã®ã‚¨ãƒ³ãƒˆãƒªãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" - -#~ msgid "child process exited with exit code %d" -#~ msgstr "å­ãƒ—ロセスãŒçµ‚了コード%dã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid "could not open large object TOC for output: %s\n" -#~ msgstr "出力用ã®ãƒ©ãƒ¼ã‚¸ã‚ªãƒ–ジェクトTOCをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã€çµ‚了ã—ã¾ã™\n" - -#~ msgid "invalid COPY statement -- could not find \"copy\" in string \"%s\"\n" -#~ msgstr "COPYæ–‡ãŒç„¡åŠ¹ã§ã™ -- 文字列\"%s\"ã«\"copy\"ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" - -#~ msgid "could not open large object TOC for input: %s\n" -#~ msgstr "入力用ã®ãƒ©ãƒ¼ã‚¸ã‚ªãƒ–ジェクトTOCをオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#~ msgid "query returned no rows: %s\n" -#~ msgstr "å•ã„åˆã‚ã›ã®çµæžœè¡ŒãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#~ msgid "dumpDatabase(): could not find pg_largeobject.relfrozenxid\n" -#~ msgstr "dumpDatabase(): pg_largeobject.relfrozenxid ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" - -#~ msgid "missing pg_database entry for database \"%s\"\n" -#~ msgstr "データベース\"%s\"用ã®ã‚¨ãƒ³ãƒˆãƒªãŒpg_databaseã«ã‚ã‚Šã¾ã›ã‚“\n" - -#~ msgid "%s: invalid -X option -- %s\n" -#~ msgstr "%s: 無効㪠-X オプション -- %s\n" - -#~ msgid "" -#~ "WARNING:\n" -#~ " This format is for demonstration purposes; it is not intended for\n" -#~ " normal use. Files will be written in the current working directory.\n" -#~ msgstr "" -#~ "警告:\n" -#~ "ã“ã®æ›¸å¼ã¯ãƒ‡ãƒ¢ã‚’目的ã¨ã—ãŸã‚‚ã®ã§ã™ã€‚通常ã®ä½¿ç”¨ã‚’æ„図ã—ãŸã‚‚ã®ã§ã¯ã‚ã‚Šã¾\n" -#~ "ã›ã‚“。ファイルã¯ç¾åœ¨ã®ä½œæ¥­ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã«æ›¸ã出ã•ã‚Œã¾ã™\n" - -#~ msgid "%s: could not parse version \"%s\"\n" -#~ msgstr "%s: ãƒãƒ¼ã‚¸ãƒ§ãƒ³\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" - -#~ msgid "could not close large object file\n" -#~ msgstr "ラージオブジェクトファイルをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ\n" - -#~ msgid "child process was terminated by exception 0x%X" -#~ msgstr "å­ãƒ—ロセスãŒä¾‹å¤–0x%Xã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid " -O, --no-owner skip restoration of object ownership\n" -#~ msgstr " -O, --no-owner オブジェクトã®æ‰€æœ‰æ¨©ã®å¾©å…ƒã‚’çœç•¥\n" - -#~ msgid "cannot duplicate null pointer\n" -#~ msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“\n" - -#~ msgid "" -#~ " --use-set-session-authorization\n" -#~ " use SET SESSION AUTHORIZATION commands instead of\n" -#~ " ALTER OWNER commands to set ownership\n" -#~ msgstr "" -#~ " --use-set-session-authorization\n" -#~ " 所有者をセットã™ã‚‹éš›ã€ALTER OWNER コマンドã®ä»£ã‚Š\n" -#~ " ã« SET SESSION AUTHORIZATION コマンドを使用ã™ã‚‹\n" - -#~ msgid "%s: out of memory\n" -#~ msgstr "%s: メモリä¸è¶³ã§ã™\n" - -#~ msgid " -c, --clean clean (drop) database objects before recreating\n" -#~ msgstr " -c, --clean å†ä½œæˆå‰ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’削除ã—ã¾ã™\n" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã¦çµ‚了\n" - -#~ msgid "SQL command failed\n" -#~ msgstr "SQLコマンドãŒå¤±æ•—ã—ã¾ã—ãŸ\n" - -#~ msgid " --disable-triggers disable triggers during data-only restore\n" -#~ msgstr "" -#~ " --disable-triggers \n" -#~ " データã®ã¿ã®å¾©å…ƒä¸­ã«ãƒˆãƒªã‚¬ã‚’無効ã«ã—ã¾ã™\n" - -#~ msgid "query returned more than one (%d) pg_database entry for database \"%s\"\n" -#~ msgstr "å•ã„åˆã‚ã›ã«ã‚ˆã‚Šã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹\"%2$s\"用ã®ã‚¨ãƒ³ãƒˆãƒªãŒpg_databaseã‹ã‚‰è¤‡æ•°(%1$d)è¿”ã•ã‚Œã¾ã—ãŸ\n" - -#~ msgid "invalid COPY statement -- could not find \"from stdin\" in string \"%s\" starting at position %lu\n" -#~ msgstr "COPYæ–‡ãŒç„¡åŠ¹ã§ã™ -- 文字列\"%s\"ã®%luä½ç½®ã‹ã‚‰\"from stdin\"ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" - -#~ msgid "found more than one pg_database entry for this database\n" -#~ msgstr "ã“ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ç”¨ã®pg_databaseエントリãŒè¤‡æ•°ã‚ã‚Šã¾ã—ãŸ\n" - -#~ msgid "could not parse version string \"%s\"\n" -#~ msgstr "ãƒãƒ¼ã‚¸ãƒ§ãƒ³æ–‡å­—列\"%s\"を解æžã§ãã¾ã›ã‚“ã§ã—ãŸ\n" - -#~ msgid "dumpDatabase(): could not find pg_largeobject_metadata.relfrozenxid\n" -#~ msgstr "dumpDatabase(): pg_largeobject_metadata.relfrozenxidãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" - -#~ msgid "child process was terminated by signal %s" -#~ msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ«%sã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã¦çµ‚了\n" - -#~ msgid "child process exited with unrecognized status %d" -#~ msgstr "å­ãƒ—ロセスãŒæœªçŸ¥ã®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹%dã§çµ‚了ã—ã¾ã—ãŸ" - -#~ msgid "could not close data file after reading\n" -#~ msgstr "読ã¿è¾¼ã‚“ã å¾Œãƒ‡ãƒ¼ã‚¿ãƒ•ã‚¡ã‚¤ãƒ«ã‚’クローズã§ãã¾ã›ã‚“ã§ã—ãŸ\n" - -#~ msgid "-C and -c are incompatible options\n" -#~ msgstr "オプション-Cã¨-cã¯äº’æ›æ€§ãŒã‚ã‚Šã¾ã›ã‚“\n" - -#~ msgid "missing pg_database entry for this database\n" -#~ msgstr "ã“ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ç”¨ã®pg_databaseエントリãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" - -#~ msgid "parallel_restore should not return\n" -#~ msgstr "parallel_restore 㯠return ã—ã¾ã›ã‚“\n" - -#~ msgid "worker process crashed: status %d\n" -#~ msgstr "ワーカープロセスãŒã‚¯ãƒ©ãƒƒã‚·ãƒ¥ã—ã¾ã—ãŸï¼šã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹ %d\n" diff --git a/src/bin/pg_dump/po/ru.po b/src/bin/pg_dump/po/ru.po index edb9c60467..5d7527d066 100644 --- a/src/bin/pg_dump/po/ru.po +++ b/src/bin/pg_dump/po/ru.po @@ -5,14 +5,15 @@ # Oleg Bartunov , 2004. # Sergey Burladyan , 2012. # Dmitriy Olshevskiy , 2014. -# Alexander Lakhin , 2012-2016, 2017. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: pg_dump (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:14+0000\n" -"PO-Revision-Date: 2017-02-02 15:21+0300\n" +"POT-Creation-Date: 2017-02-09 21:14+0000\n" +"PO-Revision-Date: 2017-04-03 08:42+0300\n" +"Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -20,7 +21,6 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" -"Last-Translator: Alexander Lakhin \n" #: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format @@ -277,7 +277,9 @@ msgstr "чтение политик\n" #: common.c:908 #, c-format msgid "failed sanity check, parent OID %u of table \"%s\" (OID %u) not found\n" -msgstr "родительÑÐºÐ°Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° Ñ OID %u Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\" (OID %u) не найдена\n" +msgstr "" +"нарушение целоÑтноÑти: родительÑÐºÐ°Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° Ñ OID %u Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\" (OID " +"%u) не найдена\n" #: common.c:950 #, c-format @@ -2047,7 +2049,7 @@ msgstr "ПРЕДУПРЕЖДЕÐИЕ: у таблицы \"%s\" по-видимо #, c-format msgid "failed sanity check, parent table OID %u of sequence OID %u not found\n" msgstr "" -"по OID %u не удалоÑÑŒ найти родительÑкую таблицу Ð´Ð»Ñ Ð·Ð°Ð¿Ð¸Ñи " +"нарушение целоÑтноÑти: по OID %u не удалоÑÑŒ найти родительÑкую таблицу " "поÑледовательноÑти Ñ OID %u\n" #: pg_dump.c:6220 @@ -2066,8 +2068,8 @@ msgid "" "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not " "found\n" msgstr "" -"по OID %u не удалоÑÑŒ найти родительÑкую таблицу Ð´Ð»Ñ Ð·Ð°Ð¿Ð¸Ñи pg_rewrite Ñ OID " -"%u\n" +"нарушение целоÑтноÑти: по OID %u не удалоÑÑŒ найти родительÑкую таблицу Ð´Ð»Ñ " +"запиÑи pg_rewrite Ñ OID %u\n" #: pg_dump.c:6928 #, c-format @@ -2169,8 +2171,8 @@ msgstr "недопуÑтимое значение proparallel Ð´Ð»Ñ Ñ„ÑƒÐ½ÐºÑ† #: pg_dump.c:11948 pg_dump.c:12058 pg_dump.c:12065 #, c-format -msgid "unable to find function definition for OID %u" -msgstr "не удалоÑÑŒ найти определение функции Ð´Ð»Ñ OID %u" +msgid "could not find function definition for function with OID %u\n" +msgstr "не удалоÑÑŒ найти определение функции Ð´Ð»Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ð¸ Ñ OID %u\n" #: pg_dump.c:11993 #, c-format diff --git a/src/bin/pg_resetxlog/po/ja.po b/src/bin/pg_resetxlog/po/ja.po index cabfe527ac..4214f3d869 100644 --- a/src/bin/pg_resetxlog/po/ja.po +++ b/src/bin/pg_resetxlog/po/ja.po @@ -5,7 +5,7 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-09-20 16:55+0900\n" +"POT-Creation-Date: 2017-01-30 16:42+0900\n" "PO-Revision-Date: 2013-08-18 12:10+0900\n" "Last-Translator: Okano Naoki \n" "Language-Team: jpug-doc \n" @@ -529,7 +529,7 @@ msgstr "オプション:\n" #: pg_resetxlog.c:1170 #, c-format msgid " -c XID,XID set oldest and newest transactions bearing commit timestamp\n" -msgstr " -c XID,XID コミットタイムスタンプを作æˆã™ã‚‹æœ€ã‚‚å¤ã„トランザクションã¨æœ€ã‚‚æ–°ã—ã„トランザクションを設定ã—ã¾ã™\n" +msgstr " -c XID,XID コミットタイムスタンプをä¿æŒã™ã‚‹æœ€ã‚‚å¤ã„トランザクションã¨æœ€ã‚‚æ–°ã—ã„トランザクションを設定ã—ã¾ã™\n" #: pg_resetxlog.c:1171 #, c-format @@ -601,30 +601,3 @@ msgid "" msgstr "" "\n" "ä¸å…·åˆã¯ã¾ã§å ±å‘Šã—ã¦ãã ã•ã„。\n" - -#~ msgid "First log file ID after reset: %u\n" -#~ msgstr "リセット後ã€ç¾åœ¨ã®ãƒ­ã‚°ãƒ•ã‚¡ã‚¤ãƒ«ID: %u\n" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã€çµ‚了ã—ã¾ã™\n" - -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" - -#~ msgid "%s: could not read from directory \"%s\": %s\n" -#~ msgstr "%s: ディレクトリ\"%s\"ã‹ã‚‰èª­ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#~ msgid "%s: invalid argument for option -l\n" -#~ msgstr "%s: オプション-lã®å¼•æ•°ãŒç„¡åŠ¹ã§ã™\n" - -#~ msgid "%s: invalid argument for option -O\n" -#~ msgstr "%s: オプション-Oã®å¼•æ•°ãŒç„¡åŠ¹ã§ã™\n" - -#~ msgid "%s: invalid argument for option -m\n" -#~ msgstr "%s: オプション-mã®å¼•æ•°ãŒç„¡åŠ¹ã§ã™\n" - -#~ msgid "%s: invalid argument for option -o\n" -#~ msgstr "%s: オプション-oã®å¼•æ•°ãŒç„¡åŠ¹ã§ã™\n" - -#~ msgid "%s: invalid argument for option -x\n" -#~ msgstr "%s: オプション-xã®å¼•æ•°ãŒç„¡åŠ¹ã§ã™\n" diff --git a/src/bin/pg_resetxlog/po/ru.po b/src/bin/pg_resetxlog/po/ru.po index fa14545638..e3b5c77f5d 100644 --- a/src/bin/pg_resetxlog/po/ru.po +++ b/src/bin/pg_resetxlog/po/ru.po @@ -11,8 +11,9 @@ msgid "" msgstr "" "Project-Id-Version: pg_resetxlog (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:13+0000\n" +"POT-Creation-Date: 2017-02-06 22:13+0000\n" "PO-Revision-Date: 2016-12-20 18:26+0300\n" +"Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -20,7 +21,6 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" -"Last-Translator: Alexander Lakhin \n" #: ../../common/restricted_token.c:68 #, c-format diff --git a/src/bin/pg_rewind/po/it.po b/src/bin/pg_rewind/po/it.po index 7e9ba4e627..b6124ba5d6 100644 --- a/src/bin/pg_rewind/po/it.po +++ b/src/bin/pg_rewind/po/it.po @@ -15,8 +15,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_rewind (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:15+0000\n" -"PO-Revision-Date: 2016-04-17 20:53+0100\n" +"POT-Creation-Date: 2017-02-09 21:14+0000\n" +"PO-Revision-Date: 2017-04-23 02:54+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -25,11 +25,10 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" "X-Poedit-SourceCharset: utf-8\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" #: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 -#: ../../common/fe_memutils.c:98 parsexlog.c:74 parsexlog.c:127 -#: parsexlog.c:179 +#: ../../common/fe_memutils.c:98 parsexlog.c:74 parsexlog.c:127 parsexlog.c:179 #, c-format msgid "out of memory\n" msgstr "memoria esaurita\n" @@ -240,142 +239,147 @@ msgstr "modifica di pagina imprevista per la directory o il link simbolico \"%s\ msgid "%s (%s)\n" msgstr "%s (%s)\n" -#: libpq_fetch.c:55 +#: libpq_fetch.c:56 #, c-format msgid "could not connect to server: %s" msgstr "connessione al server fallita: %s" -#: libpq_fetch.c:58 +#: libpq_fetch.c:59 #, c-format msgid "connected to server\n" msgstr "connesso al server\n" -#: libpq_fetch.c:68 +#: libpq_fetch.c:69 #, c-format msgid "source server must not be in recovery mode\n" msgstr "il server di origine non dev'essere in modalità di recupero\n" -#: libpq_fetch.c:78 +#: libpq_fetch.c:79 #, c-format msgid "full_page_writes must be enabled in the source server\n" msgstr "full_page_writes dev'essere abilitato nel server di origine\n" -#: libpq_fetch.c:95 +#: libpq_fetch.c:91 +#, c-format +msgid "could not set up connection context: %s" +msgstr "preparazione del contesto di connessione fallita: %s" + +#: libpq_fetch.c:109 #, c-format msgid "error running query (%s) in source server: %s" msgstr "errore nell'esecuzione della query (%s) nel server di origine: %s" -#: libpq_fetch.c:100 +#: libpq_fetch.c:114 #, c-format msgid "unexpected result set from query\n" msgstr "risultato imprevisto dalla query\n" -#: libpq_fetch.c:123 +#: libpq_fetch.c:137 #, c-format msgid "unrecognized result \"%s\" for current WAL insert location\n" msgstr "risultato \"%s\" non riconosciuto per la locazione di inserimento WAL corrente\n" -#: libpq_fetch.c:173 +#: libpq_fetch.c:187 #, c-format msgid "could not fetch file list: %s" msgstr "ricezione della lista dei file fallita: %s" -#: libpq_fetch.c:178 +#: libpq_fetch.c:192 #, c-format msgid "unexpected result set while fetching file list\n" msgstr "risultato imprevisto ricevendo la lista dei file\n" -#: libpq_fetch.c:226 +#: libpq_fetch.c:240 #, c-format msgid "could not send query: %s" msgstr "invio della query non riuscito: %s" -#: libpq_fetch.c:228 +#: libpq_fetch.c:242 #, c-format msgid "getting file chunks\n" msgstr "ricezione blocchi del file\n" -#: libpq_fetch.c:231 +#: libpq_fetch.c:245 #, c-format msgid "could not set libpq connection to single row mode\n" msgstr "impostazione della connessione libpq in modalità riga singola fallita\n" -#: libpq_fetch.c:251 +#: libpq_fetch.c:265 #, c-format msgid "unexpected result while fetching remote files: %s" msgstr "risultato imprevisto ricevendo i file remoti: %s" -#: libpq_fetch.c:257 +#: libpq_fetch.c:271 #, c-format msgid "unexpected result set size while fetching remote files\n" msgstr "dimensione del risultato imprevisto ricevendo i file remoti\n" -#: libpq_fetch.c:263 +#: libpq_fetch.c:277 #, c-format msgid "unexpected data types in result set while fetching remote files: %u %u %u\n" msgstr "tipo di dati imprevisto nel risultato ricevendo i file remoti: %u %u %u\n" -#: libpq_fetch.c:271 +#: libpq_fetch.c:285 #, c-format msgid "unexpected result format while fetching remote files\n" msgstr "formato del risultato imprevisto ricevendo i file remoti\n" -#: libpq_fetch.c:277 +#: libpq_fetch.c:291 #, c-format msgid "unexpected null values in result while fetching remote files\n" msgstr "valori null non previsti nel risultato ricevendo i file remoti\n" -#: libpq_fetch.c:281 +#: libpq_fetch.c:295 #, c-format msgid "unexpected result length while fetching remote files\n" msgstr "lunghezza del risultato non prevista ricevendo i file remoti\n" -#: libpq_fetch.c:303 +#: libpq_fetch.c:317 #, c-format msgid "received null value for chunk for file \"%s\", file has been deleted\n" msgstr "ricevuto valore null per il blocco del file \"%s\", il file è stato cancellato\n" -#: libpq_fetch.c:310 +#: libpq_fetch.c:324 #, c-format msgid "received chunk for file \"%s\", offset %d, size %d\n" msgstr "ricevuto blocco per il file \"%s\", offset %d, dimensione %d\n" -#: libpq_fetch.c:339 +#: libpq_fetch.c:353 #, c-format msgid "could not fetch remote file \"%s\": %s" msgstr "ricezione del file remoto \"%s\" fallita: %s" -#: libpq_fetch.c:344 +#: libpq_fetch.c:358 #, c-format msgid "unexpected result set while fetching remote file \"%s\"\n" msgstr "risultato inatteso leggendo il file remoto \"%s\"\n" -#: libpq_fetch.c:355 +#: libpq_fetch.c:369 #, c-format msgid "fetched file \"%s\", length %d\n" msgstr "ricevuto il file \"%s\", lunghezza %d\n" -#: libpq_fetch.c:387 +#: libpq_fetch.c:401 #, c-format msgid "could not send COPY data: %s" msgstr "invio dei dati di COPY fallito: %s" -#: libpq_fetch.c:413 +#: libpq_fetch.c:427 #, c-format msgid "could not create temporary table: %s" msgstr "creazione della tabella temporanea fallita: %s" -#: libpq_fetch.c:421 +#: libpq_fetch.c:435 #, c-format msgid "could not send file list: %s" msgstr "invio della lista dei file fallito: %s" -#: libpq_fetch.c:463 +#: libpq_fetch.c:477 #, c-format msgid "could not send end-of-COPY: %s" msgstr "invio del fine-COPY fallito: %s" -#: libpq_fetch.c:469 +#: libpq_fetch.c:483 #, c-format msgid "unexpected result while sending file list: %s" msgstr "risultato imprevisto inviando la lista dei file: %s" @@ -507,7 +511,8 @@ msgstr "" "\n" "Puoi segnalare eventuali bug a .\n" -#: pg_rewind.c:130 pg_rewind.c:161 pg_rewind.c:168 pg_rewind.c:176 +#: pg_rewind.c:130 pg_rewind.c:161 pg_rewind.c:168 pg_rewind.c:175 +#: pg_rewind.c:183 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Prova \"%s --help\" per maggiori informazioni.\n" @@ -519,65 +524,70 @@ msgstr "%s: nessuna origine specificata (--source-pgdata o --source-server)\n" #: pg_rewind.c:167 #, c-format +msgid "%s: only one of --source-pgdata or --source-server can be specified\n" +msgstr "%s: è possibile specificare solo uno tra --source-pgdata e --source-server\n" + +#: pg_rewind.c:174 +#, c-format msgid "%s: no target data directory specified (--target-pgdata)\n" msgstr "%s: nessuna directory di dati di destinazione specificata (--target-pgdata)\n" -#: pg_rewind.c:174 +#: pg_rewind.c:181 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: troppi argomenti nella riga di comando (il primo è \"%s\")\n" -#: pg_rewind.c:189 +#: pg_rewind.c:196 #, c-format msgid "cannot be executed by \"root\"\n" msgstr "non può essere eseguito da \"root\"\n" -#: pg_rewind.c:190 +#: pg_rewind.c:197 #, c-format msgid "You must run %s as the PostgreSQL superuser.\n" msgstr "È obbligatorio eseguire %s come superutente di PostgreSQL.\n" -#: pg_rewind.c:221 +#: pg_rewind.c:228 #, c-format msgid "source and target cluster are on the same timeline\n" msgstr "i cluster di origine e di destinazione sono sulla stessa linea temporale\n" -#: pg_rewind.c:227 +#: pg_rewind.c:234 #, c-format msgid "servers diverged at WAL position %X/%X on timeline %u\n" msgstr "i server sono andati a divergere alla posizione WAL %X/%X sulla timeline %u\n" -#: pg_rewind.c:264 +#: pg_rewind.c:271 #, c-format msgid "no rewind required\n" msgstr "rewind non richiesto\n" -#: pg_rewind.c:271 +#: pg_rewind.c:278 #, c-format msgid "rewinding from last common checkpoint at %X/%X on timeline %u\n" msgstr "riavvolgimento dall'ultimo checkpoint comune a %X/%X sulla timeline %u\n" -#: pg_rewind.c:279 +#: pg_rewind.c:286 #, c-format msgid "reading source file list\n" msgstr "lettura della lista dei file di origine\n" -#: pg_rewind.c:281 +#: pg_rewind.c:288 #, c-format msgid "reading target file list\n" msgstr "lettura della lista dei file di destinazione\n" -#: pg_rewind.c:291 +#: pg_rewind.c:298 #, c-format msgid "reading WAL in target\n" msgstr "lettura del WAL nella destinazione\n" -#: pg_rewind.c:308 +#: pg_rewind.c:315 #, c-format msgid "need to copy %lu MB (total source directory size is %lu MB)\n" msgstr "è necessario copiare %lu MB (la dimensione totale della directory di origine è di %lu MB)\n" -#: pg_rewind.c:325 +#: pg_rewind.c:332 #, c-format msgid "" "\n" @@ -586,94 +596,94 @@ msgstr "" "\n" "creazione dell'etichetta di backup e aggiornamento del file di controllo\n" -#: pg_rewind.c:353 +#: pg_rewind.c:360 #, c-format msgid "syncing target data directory\n" msgstr "sincronizzazione della directory dati di destinazione\n" -#: pg_rewind.c:356 +#: pg_rewind.c:363 #, c-format msgid "Done!\n" msgstr "Fatto!\n" -#: pg_rewind.c:368 +#: pg_rewind.c:375 #, c-format msgid "source and target clusters are from different systems\n" msgstr "i cluster di origine e di destinazione sono di sistemi diversi\n" -#: pg_rewind.c:376 +#: pg_rewind.c:383 #, c-format msgid "clusters are not compatible with this version of pg_rewind\n" msgstr "i cluster non sono compatibili con questa versione di pg_rewind\n" -#: pg_rewind.c:386 +#: pg_rewind.c:393 #, c-format msgid "target server needs to use either data checksums or \"wal_log_hints = on\"\n" msgstr "il server di destinazione deve usare o il checksum dei dati o \"wal_log_hints = on\"\n" -#: pg_rewind.c:397 +#: pg_rewind.c:404 #, c-format msgid "target server must be shut down cleanly\n" msgstr "il server di destinazione dev'essere arrestato in maniera pulita\n" -#: pg_rewind.c:407 +#: pg_rewind.c:414 #, c-format msgid "source data directory must be shut down cleanly\n" msgstr "la directory dei dati di origine deve essere arrestata in maniera pulita\n" -#: pg_rewind.c:462 +#: pg_rewind.c:469 #, c-format -msgid "Invalid control file" +msgid "invalid control file" msgstr "file di controllo non valido" -#: pg_rewind.c:473 +#: pg_rewind.c:480 #, c-format msgid "Source timeline history:\n" msgstr "Storia della timeline di origine:\n" -#: pg_rewind.c:475 +#: pg_rewind.c:482 #, c-format msgid "Target timeline history:\n" msgstr "Storia della timeline di destinazione:\n" #. translator: %d is a timeline number, others are LSN positions -#: pg_rewind.c:489 +#: pg_rewind.c:496 #, c-format msgid "%d: %X/%X - %X/%X\n" msgstr "%d: %X/%X - %X/%X\n" -#: pg_rewind.c:547 +#: pg_rewind.c:555 #, c-format msgid "could not find common ancestor of the source and target cluster's timelines\n" msgstr "impossibile trovare un antenato comune nelle timeline dei cluster di origine e di destinazione\n" -#: pg_rewind.c:588 +#: pg_rewind.c:596 #, c-format msgid "backup label buffer too small\n" msgstr "buffer dell'etichetta di backup troppo piccolo\n" -#: pg_rewind.c:611 +#: pg_rewind.c:619 #, c-format msgid "unexpected control file CRC\n" msgstr "CRC del file di controllo imprevisto\n" -#: pg_rewind.c:621 +#: pg_rewind.c:629 #, c-format msgid "unexpected control file size %d, expected %d\n" msgstr "dimensione del file di controllo %d imprevista, atteso %d\n" -#: pg_rewind.c:688 +#: pg_rewind.c:696 #, c-format msgid "" -"The program \"initdb\" is needed by %s but was \n" +"The program \"initdb\" is needed by %s but was\n" "not found in the same directory as \"%s\".\n" "Check your installation.\n" msgstr "" -"Il programma \"initdb\" è richiesto da %s ma non è \n" +"Il programma \"initdb\" è richiesto da %s ma non è\n" "stato tro vato nella stessa directory di \"%s\".\n" "Controlla la tua installazione.\n" -#: pg_rewind.c:692 +#: pg_rewind.c:700 #, c-format msgid "" "The program \"initdb\" was found by \"%s\"\n" @@ -684,7 +694,7 @@ msgstr "" "ma non è la stessa versione di %s.\n" "Controlla la tua installazione.\n" -#: pg_rewind.c:710 +#: pg_rewind.c:718 #, c-format msgid "sync of target directory failed\n" msgstr "sincronizzazione della directory di destinazione fallita\n" @@ -724,137 +734,137 @@ msgstr "dati non validi nel file di storia\n" msgid "Timeline IDs must be less than child timeline's ID.\n" msgstr "Gli ID della timeline devono essere meno dell'ID della timeline del figlio.\n" -#: xlogreader.c:285 +#: xlogreader.c:276 #, c-format msgid "invalid record offset at %X/%X" msgstr "offset del record non valido a %X/%X" -#: xlogreader.c:293 +#: xlogreader.c:284 #, c-format msgid "contrecord is requested by %X/%X" msgstr "contrecord richiesto da %X/%X" -#: xlogreader.c:334 xlogreader.c:633 +#: xlogreader.c:325 xlogreader.c:624 #, c-format msgid "invalid record length at %X/%X: wanted %u, got %u" msgstr "lunghezza del record a %X/%X non valida: attesa %u, ricevuta %u" -#: xlogreader.c:349 +#: xlogreader.c:340 #, c-format msgid "record length %u at %X/%X too long" msgstr "lunghezza del record %u a %X/%X eccessiva" -#: xlogreader.c:390 +#: xlogreader.c:381 #, c-format msgid "there is no contrecord flag at %X/%X" msgstr "non c'è un flag di contrecord a %X/%X" -#: xlogreader.c:403 +#: xlogreader.c:394 #, c-format msgid "invalid contrecord length %u at %X/%X" msgstr "lunghezza di contrecord %u non valida a %X/%X" -#: xlogreader.c:641 +#: xlogreader.c:632 #, c-format msgid "invalid resource manager ID %u at %X/%X" msgstr "ID di gestione risorse %u non valido a %X/%X" -#: xlogreader.c:655 xlogreader.c:672 +#: xlogreader.c:646 xlogreader.c:663 #, c-format msgid "record with incorrect prev-link %X/%X at %X/%X" msgstr "record con link-precedente %X/%X non corretto a %X/%X" -#: xlogreader.c:709 +#: xlogreader.c:700 #, c-format msgid "incorrect resource manager data checksum in record at %X/%X" msgstr "checksum dei dati del manager di risorse non corretto nel record a %X/%X" -#: xlogreader.c:742 +#: xlogreader.c:733 #, c-format msgid "invalid magic number %04X in log segment %s, offset %u" msgstr "numero magico %04X non valido nel segmento di log %s, offset %u" -#: xlogreader.c:756 xlogreader.c:807 +#: xlogreader.c:747 xlogreader.c:798 #, c-format msgid "invalid info bits %04X in log segment %s, offset %u" msgstr "bit di info %04X non validi nel segmento di log %s, offset %u" -#: xlogreader.c:782 +#: xlogreader.c:773 #, c-format msgid "WAL file is from different database system: WAL file database system identifier is %s, pg_control database system identifier is %s" msgstr "il file WAL è di un database diverso: l'identificativo del database del file WAL è %s, quello del database di pg_control è %s" -#: xlogreader.c:789 +#: xlogreader.c:780 #, c-format msgid "WAL file is from different database system: incorrect XLOG_SEG_SIZE in page header" msgstr "il file WAL è di un database diverso: XLOG_SEG_SIZE non corretto nell'header di pagina" -#: xlogreader.c:795 +#: xlogreader.c:786 #, c-format msgid "WAL file is from different database system: incorrect XLOG_BLCKSZ in page header" msgstr "il file WAL è di un database diverso: XLOG_BLCKSZ non corretto nell'header di pagina" -#: xlogreader.c:821 +#: xlogreader.c:812 #, c-format msgid "unexpected pageaddr %X/%X in log segment %s, offset %u" msgstr "pageaddr inaspettato %X/%X nel segmento di log %s, offset %u" -#: xlogreader.c:846 +#: xlogreader.c:837 #, c-format msgid "out-of-sequence timeline ID %u (after %u) in log segment %s, offset %u" msgstr "ID della timeline %u (dopo %u) fuori sequenza nel segmento di log %s, offset %u" -#: xlogreader.c:1053 +#: xlogreader.c:1081 #, c-format msgid "out-of-order block_id %u at %X/%X" msgstr "block_id fuori sequenza %u a %X/%X" -#: xlogreader.c:1075 +#: xlogreader.c:1103 #, c-format msgid "BKPBLOCK_HAS_DATA set, but no data included at %X/%X" msgstr "BKPBLOCK_HAS_DATA impostato, ma dati non inclusi a %X/%X" -#: xlogreader.c:1082 +#: xlogreader.c:1110 #, c-format msgid "BKPBLOCK_HAS_DATA not set, but data length is %u at %X/%X" msgstr "BKPBLOCK_HAS_DATA non impostato, ma la lunghezza dei dati è %u a %X/%X" -#: xlogreader.c:1115 +#: xlogreader.c:1143 #, c-format msgid "BKPIMAGE_HAS_HOLE set, but hole offset %u length %u block image length %u at %X/%X" msgstr "BKPIMAGE_HAS_HOLE impostato, ma offset buco %u lunghezza %u lunghezza dell'immagine del blocco %u a %X/%X" -#: xlogreader.c:1131 +#: xlogreader.c:1159 #, c-format msgid "BKPIMAGE_HAS_HOLE not set, but hole offset %u length %u at %X/%X" msgstr "BKPIMAGE_HAS_HOLE non impostato, ma offset buco %u lunghezza %u a %X/%X" -#: xlogreader.c:1146 +#: xlogreader.c:1174 #, c-format msgid "BKPIMAGE_IS_COMPRESSED set, but block image length %u at %X/%X" msgstr "BKPIMAGE_IS_COMPRESSED impostato, ma la lunghezza dell'immagine del blocco è %u a %X/%X" -#: xlogreader.c:1161 +#: xlogreader.c:1189 #, c-format msgid "neither BKPIMAGE_HAS_HOLE nor BKPIMAGE_IS_COMPRESSED set, but block image length is %u at %X/%X" msgstr "né BKPIMAGE_HAS_HOLE né BKPIMAGE_IS_COMPRESSED impostati, ma la lunghezza dell'immagine del blocco è %u a %X/%X" -#: xlogreader.c:1177 +#: xlogreader.c:1205 #, c-format msgid "BKPBLOCK_SAME_REL set but no previous rel at %X/%X" msgstr "BKPBLOCK_SAME_REL impostato ma non c'è un rel precedente a %X/%X" -#: xlogreader.c:1189 +#: xlogreader.c:1217 #, c-format msgid "invalid block_id %u at %X/%X" msgstr "block_id %u non valido a %X/%X" -#: xlogreader.c:1254 +#: xlogreader.c:1282 #, c-format msgid "record with invalid length at %X/%X" msgstr "record con lunghezza non valida a %X/%X" -#: xlogreader.c:1343 +#: xlogreader.c:1371 #, c-format msgid "invalid compressed image at %X/%X, block %d" msgstr "immagine compressa non valida a %X/%X, blocco %d" diff --git a/src/bin/pg_rewind/po/ja.po b/src/bin/pg_rewind/po/ja.po index 0343ff45ac..a8ef0c3cba 100644 --- a/src/bin/pg_rewind/po/ja.po +++ b/src/bin/pg_rewind/po/ja.po @@ -3,14 +3,13 @@ # This file is distributed under the same license as the PostgreSQL package. # FIRST AUTHOR , 2016. # - msgid "" msgstr "" -"Project-Id-Version: pg_rewind (PostgreSQL) 9.6\n" +"Project-Id-Version: pg_rewind (PostgreSQL) 9.6.3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-09-21 12:34+0900\n" +"POT-Creation-Date: 2017-04-04 11:59+0900\n" "PO-Revision-Date: 2016-MO-DA HO:MI+ZONE\n" -"Last-Translator: IDERIHA Takeshi \n" +"Last-Translator: Daisuke Higuchi \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -230,142 +229,147 @@ msgstr "ディレクトリã¾ãŸã¯ã‚·ãƒ³ãƒœãƒªãƒƒã‚¯ãƒªãƒ³ã‚¯\"%s\"ã«å¯¾ã™ã‚‹ msgid "%s (%s)\n" msgstr "%s (%s)\n" -#: libpq_fetch.c:55 +#: libpq_fetch.c:56 #, c-format msgid "could not connect to server: %s" msgstr "サーãƒã«æŽ¥ç¶šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: libpq_fetch.c:58 +#: libpq_fetch.c:59 #, c-format msgid "connected to server\n" msgstr "サーãƒã¸æŽ¥ç¶šã—ã¾ã—ãŸ\n" -#: libpq_fetch.c:68 +#: libpq_fetch.c:69 #, c-format msgid "source server must not be in recovery mode\n" msgstr "ソースサーãƒã¯ãƒªã‚«ãƒãƒªãƒ¢ãƒ¼ãƒ‰ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: libpq_fetch.c:78 +#: libpq_fetch.c:79 #, c-format msgid "full_page_writes must be enabled in the source server\n" msgstr "ソースサーãƒã§ã¯full_pate_writesã¯æœ‰åŠ¹ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: libpq_fetch.c:95 +#: libpq_fetch.c:91 +#, c-format +msgid "could not set up connection context: %s" +msgstr "接続コンテキストを設定ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" + +#: libpq_fetch.c:109 #, c-format msgid "error running query (%s) in source server: %s" msgstr "ソースサーãƒã®å®Ÿè¡Œä¸­ã®ã‚¯ã‚¨ãƒª(%s)ã§ã‚¨ãƒ©ãƒ¼ï¼š%s" -#: libpq_fetch.c:100 +#: libpq_fetch.c:114 #, c-format msgid "unexpected result set from query\n" msgstr "クエリã‹ã‚‰æƒ³å®šå¤–ã®çµæžœã‚»ãƒƒãƒˆ\n" -#: libpq_fetch.c:123 +#: libpq_fetch.c:137 #, c-format msgid "unrecognized result \"%s\" for current WAL insert location\n" msgstr "ç¾åœ¨ã®WALã®æŒ¿å…¥å ´æ‰€ã«å¯¾ã™ã‚‹æœªçŸ¥ã®çµæžœ \"%s\" \n" -#: libpq_fetch.c:173 +#: libpq_fetch.c:187 #, c-format msgid "could not fetch file list: %s" msgstr "ファイルリストをフェッãƒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: libpq_fetch.c:178 +#: libpq_fetch.c:192 #, c-format msgid "unexpected result set while fetching file list\n" msgstr "ファイルリストをフェッãƒä¸­ã«æƒ³å®šå¤–ã®çµæžœã‚»ãƒƒãƒˆ\n" -#: libpq_fetch.c:226 +#: libpq_fetch.c:240 #, c-format msgid "could not send query: %s" msgstr "クエリをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: libpq_fetch.c:228 +#: libpq_fetch.c:242 #, c-format msgid "getting file chunks\n" msgstr "ファイルãƒãƒ£ãƒ³ã‚¯ã®å–å¾—\n" -#: libpq_fetch.c:231 +#: libpq_fetch.c:245 #, c-format msgid "could not set libpq connection to single row mode\n" msgstr "libpq接続をå˜ä¸€è¡Œãƒ¢ãƒ¼ãƒ‰ã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: libpq_fetch.c:251 +#: libpq_fetch.c:265 #, c-format msgid "unexpected result while fetching remote files: %s" msgstr "リモートファイルをフェッãƒä¸­ã«æƒ³å®šå¤–ã®çµæžœ: %s" -#: libpq_fetch.c:257 +#: libpq_fetch.c:271 #, c-format msgid "unexpected result set size while fetching remote files\n" msgstr "リモートファイルをフェッãƒä¸­ã«æƒ³å®šå¤–ã®çµæžœã‚»ãƒƒãƒˆã‚µã‚¤ã‚º\n" -#: libpq_fetch.c:263 +#: libpq_fetch.c:277 #, c-format msgid "unexpected data types in result set while fetching remote files: %u %u %u\n" msgstr "リモートファイルをフェッãƒä¸­ã®çµæžœã‚»ãƒƒãƒˆã«æƒ³å®šå¤–ã®ãƒ‡ãƒ¼ã‚¿åž‹: %u %u %u\n" -#: libpq_fetch.c:271 +#: libpq_fetch.c:285 #, c-format msgid "unexpected result format while fetching remote files\n" msgstr "リモートファイルをフェッãƒä¸­ã«æƒ³å®šå¤–ã®çµæžœå½¢å¼\n" -#: libpq_fetch.c:277 +#: libpq_fetch.c:291 #, c-format msgid "unexpected null values in result while fetching remote files\n" msgstr "リモートファイルをフェッãƒä¸­ã®çµæžœã«æƒ³å®šå¤–ã®NULL値\n" -#: libpq_fetch.c:281 +#: libpq_fetch.c:295 #, c-format msgid "unexpected result length while fetching remote files\n" msgstr "リモートファイルをフェッãƒä¸­ã«æƒ³å®šå¤–ã®çµæžœã®é•·ã•\n" -#: libpq_fetch.c:303 +#: libpq_fetch.c:317 #, c-format msgid "received null value for chunk for file \"%s\", file has been deleted\n" msgstr "ファイル\"%s\"ã®NULL値ã®ãƒãƒ£ãƒ³ã‚¯ã‚’å—ã‘å–ã‚Šã¾ã—ãŸã€‚ファイルã¯å‰Šé™¤ã•ã‚Œã¾ã—ãŸã€‚\n" -#: libpq_fetch.c:310 +#: libpq_fetch.c:324 #, c-format msgid "received chunk for file \"%s\", offset %d, size %d\n" msgstr "ファイル \"%s\",オフセット %d, サイズ %dã®ãƒãƒ£ãƒ³ã‚¯ã‚’å—ã‘å–ã‚Šã¾ã—ãŸ\n" -#: libpq_fetch.c:339 +#: libpq_fetch.c:353 #, c-format msgid "could not fetch remote file \"%s\": %s" msgstr "リモートファイル\"%s\"をフェッãƒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: libpq_fetch.c:344 +#: libpq_fetch.c:358 #, c-format msgid "unexpected result set while fetching remote file \"%s\"\n" msgstr "リモートファイル \"%s\"をフェッãƒä¸­ã«æƒ³å®šå¤–ã®çµæžœã‚»ãƒƒãƒˆ\n" -#: libpq_fetch.c:355 +#: libpq_fetch.c:369 #, c-format msgid "fetched file \"%s\", length %d\n" msgstr "フェッãƒã—ãŸãƒ•ã‚¡ã‚¤ãƒ« \"%s\",é•·ã• %d\n" -#: libpq_fetch.c:387 +#: libpq_fetch.c:401 #, c-format msgid "could not send COPY data: %s" msgstr "COPY 対象データをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸï¼š%s" -#: libpq_fetch.c:413 +#: libpq_fetch.c:427 #, c-format msgid "could not create temporary table: %s" msgstr "一時テーブルを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸï¼š%s" -#: libpq_fetch.c:421 +#: libpq_fetch.c:435 #, c-format msgid "could not send file list: %s" msgstr "ファイルリストをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸï¼š%s" -#: libpq_fetch.c:463 +#: libpq_fetch.c:477 #, c-format msgid "could not send end-of-COPY: %s" msgstr "コピー終端をé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸï¼š%s" -#: libpq_fetch.c:469 +#: libpq_fetch.c:483 #, c-format msgid "unexpected result while sending file list: %s" msgstr "ファイルリストをé€ä¿¡ä¸­ã«æƒ³å®šå¤–ã®çµæžœ: %s" @@ -497,7 +501,8 @@ msgstr "" "\n" "ä¸å…·åˆã¯ã¾ã§å ±å‘Šã—ã¦ãã ã•ã„。\n" -#: pg_rewind.c:130 pg_rewind.c:161 pg_rewind.c:168 pg_rewind.c:176 +#: pg_rewind.c:130 pg_rewind.c:161 pg_rewind.c:168 pg_rewind.c:175 +#: pg_rewind.c:183 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細ã¯\"%s --help\"を実行ã—ã¦ãã ã•ã„。\n" @@ -509,65 +514,70 @@ msgstr "%s: ソースãŒç‰¹å®šã•ã‚Œã¦ã„ã¾ã›ã‚“（--source-pgdata or --sourc #: pg_rewind.c:167 #, c-format +msgid "%s: only one of --source-pgdata or --source-server can be specified\n" +msgstr "%s: --source-pgdata ã‹ --source-server ã®ã„ãšã‚Œã‹ã®ã¿ã‚’指定ã—ã¦ãã ã•ã„\n" + +#: pg_rewind.c:174 +#, c-format msgid "%s: no target data directory specified (--target-pgdata)\n" msgstr "%s: データディレクトリ対象ãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“ (--target-pgdata)\n" -#: pg_rewind.c:174 +#: pg_rewind.c:181 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: コマンドライン引数ãŒå¤šã™ãŽã¾ã™ã€‚(始ã‚ã¯\"%s\")\n" -#: pg_rewind.c:189 +#: pg_rewind.c:196 #, c-format msgid "cannot be executed by \"root\"\n" msgstr "\"root\"ã§ã¯å®Ÿè¡Œã§ãã¾ã›ã‚“\n" -#: pg_rewind.c:190 +#: pg_rewind.c:197 #, c-format msgid "You must run %s as the PostgreSQL superuser.\n" msgstr "PostgreSQLã®ã‚¹ãƒ¼ãƒ‘ーユーザã§%sを実行ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_rewind.c:221 +#: pg_rewind.c:228 #, c-format msgid "source and target cluster are on the same timeline\n" msgstr "変æ›å…ƒã¨å¤‰æ›å…ˆã®ã‚¯ãƒ©ã‚¹ã‚¿ãŒåŒä¸€ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³ã«ã‚ã‚Šã¾ã™\n" -#: pg_rewind.c:227 +#: pg_rewind.c:234 #, c-format msgid "servers diverged at WAL position %X/%X on timeline %u\n" msgstr "タイムライン%3$uã® WALã®ä½ç½® %1$X/%2$Xã§ã‚µãƒ¼ãƒãŒåˆ†å²ã—ã¦ã„ã¾ã™\n" -#: pg_rewind.c:264 +#: pg_rewind.c:271 #, c-format msgid "no rewind required\n" msgstr "å·»ã戻ã—ã¯å¿…è¦ã§ã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: pg_rewind.c:271 +#: pg_rewind.c:278 #, c-format msgid "rewinding from last common checkpoint at %X/%X on timeline %u\n" msgstr "タイムライン%3$uã® %1$X/%2$X ã§æœ€æ–°ã®å…±é€šãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã‹ã‚‰å·»ã戻ã—ã¦ã„ã¾ã™\n" -#: pg_rewind.c:279 +#: pg_rewind.c:286 #, c-format msgid "reading source file list\n" msgstr "ソースファイルリストを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: pg_rewind.c:281 +#: pg_rewind.c:288 #, c-format msgid "reading target file list\n" msgstr "ターゲットファイルリストを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: pg_rewind.c:291 +#: pg_rewind.c:298 #, c-format msgid "reading WAL in target\n" msgstr "ターゲットã§WALを読ã¿è¾¼ã‚“ã§ã„ã¾ã™\n" -#: pg_rewind.c:308 +#: pg_rewind.c:315 #, c-format msgid "need to copy %lu MB (total source directory size is %lu MB)\n" msgstr "%lu MBをコピーã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ï¼ˆã‚½ãƒ¼ã‚¹ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚µã‚¤ã‚ºã®åˆè¨ˆã¯%lu MBã§ã™ï¼‰\n" -#: pg_rewind.c:325 +#: pg_rewind.c:332 #, c-format msgid "" "\n" @@ -576,83 +586,83 @@ msgstr "" "\n" "backup labelを作æˆã—ã¦åˆ¶å¾¡ãƒ•ã‚¡ã‚¤ãƒ«ã‚’æ›´æ–°ã—ã¦ã„ã¾ã™\n" -#: pg_rewind.c:353 +#: pg_rewind.c:360 #, c-format msgid "syncing target data directory\n" msgstr "åŒæœŸã—ã¦ã„るターゲットデータディレクトリ\n" -#: pg_rewind.c:356 +#: pg_rewind.c:363 #, c-format msgid "Done!\n" msgstr "完了ï¼\n" -#: pg_rewind.c:368 +#: pg_rewind.c:375 #, c-format msgid "source and target clusters are from different systems\n" msgstr "ソースクラスタã¨ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã‚¯ãƒ©ã‚¹ã‚¿ã¯ç•°ãªã‚‹ã‚·ã‚¹ãƒ†ãƒ ã®ã‚‚ã®ã§ã™\n" -#: pg_rewind.c:376 +#: pg_rewind.c:383 #, c-format msgid "clusters are not compatible with this version of pg_rewind\n" msgstr "クラスタãŒã€pg_rewindã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã¨ä¸€è‡´ã—ã¾ã›ã‚“\n" -#: pg_rewind.c:386 +#: pg_rewind.c:393 #, c-format msgid "target server needs to use either data checksums or \"wal_log_hints = on\"\n" msgstr "ターゲットサーãƒã¯ãƒ‡ãƒ¼ã‚¿ãƒã‚§ãƒƒã‚¯ã‚µãƒ ã‚’利用ã™ã‚‹ã‚ã‚‹ã„ã¯\"wal_log_hints = onã§ã‚ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™\n" -#: pg_rewind.c:397 +#: pg_rewind.c:404 #, c-format msgid "target server must be shut down cleanly\n" msgstr "ターゲットサーãƒã¯ãã‚Œã„ã«ã‚·ãƒ£ãƒƒãƒˆãƒ€ã‚¦ãƒ³ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_rewind.c:407 +#: pg_rewind.c:414 #, c-format msgid "source data directory must be shut down cleanly\n" msgstr "ソースデータディレクトリã¯ãã‚Œã„ã«ã‚·ãƒ£ãƒƒãƒˆãƒ€ã‚¦ãƒ³ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: pg_rewind.c:462 +#: pg_rewind.c:469 #, c-format msgid "invalid control file" msgstr "無効ãªåˆ¶å¾¡ãƒ•ã‚¡ã‚¤ãƒ«" -#: pg_rewind.c:473 +#: pg_rewind.c:480 #, c-format msgid "Source timeline history:\n" msgstr "ソースタイムラインã®å±¥æ­´\n" -#: pg_rewind.c:475 +#: pg_rewind.c:482 #, c-format msgid "Target timeline history:\n" msgstr "ターゲットタイムラインã®å±¥æ­´:\n" #. translator: %d is a timeline number, others are LSN positions -#: pg_rewind.c:489 +#: pg_rewind.c:496 #, c-format msgid "%d: %X/%X - %X/%X\n" msgstr "%d: %X/%X - %X/%X\n" -#: pg_rewind.c:548 +#: pg_rewind.c:555 #, c-format msgid "could not find common ancestor of the source and target cluster's timelines\n" msgstr "ソースクラスタã€ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã‚¯ãƒ©ã‚¹ã‚¿ã®ã‚¿ã‚¤ãƒ ãƒ©ã‚¤ãƒ³ã®å…±é€šã®ç¥–先を見ã¤ã‘られã¾ã›ã‚“\n" -#: pg_rewind.c:589 +#: pg_rewind.c:596 #, c-format msgid "backup label buffer too small\n" msgstr "ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ラベルã®ãƒãƒƒãƒ•ã‚¡ãŒå°ã•ã™ãŽã¾ã™\n" -#: pg_rewind.c:612 +#: pg_rewind.c:619 #, c-format msgid "unexpected control file CRC\n" msgstr "想定外ã®åˆ¶å¾¡ãƒ•ã‚¡ã‚¤ãƒ« CRC ã§ã™\n" -#: pg_rewind.c:622 +#: pg_rewind.c:629 #, c-format msgid "unexpected control file size %d, expected %d\n" msgstr "想定外ã®åˆ¶å¾¡ãƒ•ã‚¡ã‚¤ãƒ«ã®ã‚µã‚¤ã‚º%dã§ã™ã€ãã®æœŸå¾…値ã¯%dã§ã™\n" -#: pg_rewind.c:689 +#: pg_rewind.c:696 #, c-format msgid "" "The program \"initdb\" is needed by %s but was\n" @@ -663,7 +673,7 @@ msgstr "" "ã«ã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸã€‚\n" "インストール状æ³ã‚’確èªã—ã¦ãã ã•ã„。\n" -#: pg_rewind.c:693 +#: pg_rewind.c:700 #, c-format msgid "" "The program \"initdb\" was found by \"%s\"\n" @@ -674,7 +684,7 @@ msgstr "" "ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã§ã¯ã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸã€‚\n" "インストレーションを検査ã—ã¦ãã ã•ã„。\n" -#: pg_rewind.c:711 +#: pg_rewind.c:718 #, c-format msgid "sync of target directory failed\n" msgstr "ターゲットディレクトリã®åŒæœŸãŒå¤±æ•—ã—ã¾ã—ãŸ\n" diff --git a/src/bin/psql/po/it.po b/src/bin/psql/po/it.po index da0d24af27..7b059929bb 100644 --- a/src/bin/psql/po/it.po +++ b/src/bin/psql/po/it.po @@ -24,8 +24,8 @@ msgid "" msgstr "" "Project-Id-Version: psql (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:14+0000\n" -"PO-Revision-Date: 2016-04-17 20:39+0100\n" +"POT-Creation-Date: 2017-02-09 21:13+0000\n" +"PO-Revision-Date: 2017-04-23 02:39+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -34,7 +34,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-SourceCharset: utf-8\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" #: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format @@ -72,7 +72,7 @@ msgid "pclose failed: %s" msgstr "pclose fallita: %s" #: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 -#: ../../common/fe_memutils.c:98 command.c:330 input.c:227 mainloop.c:80 +#: ../../common/fe_memutils.c:98 command.c:342 input.c:227 mainloop.c:80 #: mainloop.c:261 #, c-format msgid "out of memory\n" @@ -88,7 +88,7 @@ msgstr "impossibile duplicare il puntatore nullo (errore interno)\n" msgid "could not look up effective user ID %ld: %s" msgstr "ID utente effettivo %ld non trovato: %s" -#: ../../common/username.c:47 command.c:287 +#: ../../common/username.c:47 command.c:299 msgid "user does not exist" msgstr "l'utente non esiste" @@ -139,22 +139,22 @@ msgid_plural "(%lu rows)" msgstr[0] "(%lu riga)" msgstr[1] "(%lu righe)" -#: ../../fe_utils/print.c:2906 +#: ../../fe_utils/print.c:2914 #, c-format msgid "Interrupted\n" msgstr "Interrotto\n" -#: ../../fe_utils/print.c:2970 +#: ../../fe_utils/print.c:2978 #, c-format msgid "Cannot add header to table content: column count of %d exceeded.\n" msgstr "Non è possibile aggiungere l'intestazione al contenuto della tabella: il numero di colonne %d è stato superato.\n" -#: ../../fe_utils/print.c:3010 +#: ../../fe_utils/print.c:3018 #, c-format msgid "Cannot add cell to table content: total cell count of %d exceeded.\n" msgstr "Non è possibile aggiungere celle al contenuto della tabella: il numero totale di celle %d è stato superato.\n" -#: ../../fe_utils/print.c:3259 +#: ../../fe_utils/print.c:3267 #, c-format msgid "invalid output format (internal error): %d" msgstr "il formato di output non è valido (errore interno): %d" @@ -164,250 +164,250 @@ msgstr "il formato di output non è valido (errore interno): %d" msgid "skipping recursive expansion of variable \"%s\"\n" msgstr "espansione ricorsiva della variabile \"%s\" evitata\n" -#: command.c:128 +#: command.c:129 #, c-format msgid "Invalid command \\%s. Try \\? for help.\n" msgstr "Comando errato \\%s. Prova \\? per la guida.\n" -#: command.c:130 +#: command.c:131 #, c-format msgid "invalid command \\%s\n" msgstr "comando errato \\%s\n" -#: command.c:141 +#: command.c:142 #, c-format msgid "\\%s: extra argument \"%s\" ignored\n" msgstr "\\%s: parametro in eccesso \"%s\" ignorato\n" -#: command.c:285 +#: command.c:297 #, c-format msgid "could not get home directory for user ID %ld: %s\n" msgstr "directory home non trovata per l'ID utente %ld: %s\n" -#: command.c:303 +#: command.c:315 #, c-format msgid "\\%s: could not change directory to \"%s\": %s\n" msgstr "\\%s: spostamento della directory a \"%s\" fallito: %s\n" -#: command.c:318 common.c:548 common.c:606 common.c:1139 +#: command.c:330 common.c:553 common.c:611 common.c:1144 #, c-format msgid "You are currently not connected to a database.\n" msgstr "Al momento non sei connesso ad un database.\n" -#: command.c:343 +#: command.c:355 #, c-format msgid "You are connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n" msgstr "Sei collegato al database \"%s\" con nome utente \"%s\" tramite il socket in \"%s\" porta \"%s\".\n" -#: command.c:346 +#: command.c:358 #, c-format msgid "You are connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n" msgstr "Sei collegato al database \"%s\" con nome utente \"%s\" sull'host \"%s\" porta \"%s\".\n" -#: command.c:559 command.c:629 command.c:725 command.c:1557 +#: command.c:574 command.c:647 command.c:746 command.c:1584 #, c-format msgid "no query buffer\n" msgstr "Nessun buffer query\n" -#: command.c:592 command.c:3408 +#: command.c:607 command.c:3547 #, c-format msgid "invalid line number: %s\n" msgstr "numero di riga non valido: \"%s\"\n" -#: command.c:623 +#: command.c:640 #, c-format -msgid "The server (version %d.%d) does not support editing function source.\n" -msgstr "Il server (versione %d.%d) non supporta la modifica dei sorgenti delle funzioni.\n" +msgid "The server (version %s) does not support editing function source.\n" +msgstr "Il server (versione %s) non supporta la modifica dei sorgenti delle funzioni.\n" -#: command.c:703 command.c:771 +#: command.c:721 command.c:792 msgid "No changes" msgstr "Nessuna modifica" -#: command.c:719 +#: command.c:739 #, c-format -msgid "The server (version %d.%d) does not support editing view definitions.\n" -msgstr "Il server (versione %d.%d) non supporta la modifica della definizione delle viste.\n" +msgid "The server (version %s) does not support editing view definitions.\n" +msgstr "Il server (versione %s) non supporta la modifica della definizione delle viste.\n" -#: command.c:825 +#: command.c:846 #, c-format msgid "%s: invalid encoding name or conversion procedure not found\n" msgstr "%s: nome codifica errato oppure non esiste una procedura di conversione\n" -#: command.c:850 command.c:1897 command.c:3510 common.c:152 common.c:199 -#: common.c:492 common.c:1185 common.c:1210 common.c:1311 copy.c:489 -#: copy.c:699 large_obj.c:156 large_obj.c:191 large_obj.c:253 +#: command.c:871 command.c:1962 command.c:3649 common.c:153 common.c:200 +#: common.c:497 common.c:1190 common.c:1218 common.c:1319 copy.c:489 copy.c:699 +#: large_obj.c:156 large_obj.c:191 large_obj.c:253 #, c-format msgid "%s" msgstr "%s" -#: command.c:854 +#: command.c:875 msgid "out of memory" msgstr "memoria esaurita" -#: command.c:857 -msgid "There was no previous error." +#: command.c:878 +msgid "There is no previous error." msgstr "Non c'è un errore precedente." -#: command.c:951 command.c:1001 command.c:1015 command.c:1032 command.c:1139 -#: command.c:1303 command.c:1537 command.c:1568 +#: command.c:972 command.c:1022 command.c:1036 command.c:1053 command.c:1160 +#: command.c:1324 command.c:1564 command.c:1595 #, c-format msgid "\\%s: missing required argument\n" msgstr "\\%s: parametro richiesto mancante\n" -#: command.c:1064 +#: command.c:1085 msgid "Query buffer is empty." msgstr "Il buffer query è vuoto." -#: command.c:1074 +#: command.c:1095 msgid "Enter new password: " msgstr "Inserire la nuova password: " -#: command.c:1075 +#: command.c:1096 msgid "Enter it again: " msgstr "Conferma password: " -#: command.c:1079 +#: command.c:1100 #, c-format msgid "Passwords didn't match.\n" msgstr "Le password non corrispondono.\n" -#: command.c:1097 +#: command.c:1118 #, c-format msgid "Password encryption failed.\n" msgstr "Criptazione password fallita.\n" -#: command.c:1168 command.c:1284 command.c:1542 +#: command.c:1189 command.c:1305 command.c:1569 #, c-format msgid "\\%s: error while setting variable\n" msgstr "\\%s: errore durante l'assegnamento della variabile\n" -#: command.c:1231 +#: command.c:1252 msgid "Query buffer reset (cleared)." msgstr "Buffer query resettato (svuotato)." -#: command.c:1243 +#: command.c:1264 #, c-format msgid "Wrote history to file \"%s\".\n" msgstr "Storia scritta nel file \"%s\".\n" -#: command.c:1308 +#: command.c:1329 #, c-format msgid "\\%s: environment variable name must not contain \"=\"\n" msgstr "\\%s: il nome della variabile d'ambiente non deve contenere \"=\"\n" -#: command.c:1350 +#: command.c:1373 #, c-format -msgid "The server (version %d.%d) does not support showing function source.\n" -msgstr "Il server (versione %d.%d) non supporta mostrare i sorgenti delle funzioni.\n" +msgid "The server (version %s) does not support showing function source.\n" +msgstr "Il server (versione %s) non supporta la visualizzazione dei sorgenti delle funzioni.\n" -#: command.c:1356 +#: command.c:1380 #, c-format msgid "function name is required\n" msgstr "il nome della funzione è richiesto\n" -#: command.c:1429 +#: command.c:1455 #, c-format -msgid "The server (version %d.%d) does not support showing view definitions.\n" -msgstr "Il server (versione %d.%d) non supporta la visualizzazione della definizione delle viste.\n" +msgid "The server (version %s) does not support showing view definitions.\n" +msgstr "-\"Il server (versione %s) non supporta la visualizzazione della definizione delle viste.\n" -#: command.c:1435 +#: command.c:1462 #, c-format msgid "view name is required\n" msgstr "il nome della vista è richiesto\n" -#: command.c:1522 +#: command.c:1549 msgid "Timing is on." msgstr "Controllo tempo attivato" -#: command.c:1524 +#: command.c:1551 msgid "Timing is off." msgstr "Controllo tempo disattivato." -#: command.c:1586 command.c:1606 command.c:2240 command.c:2243 command.c:2246 -#: command.c:2252 command.c:2254 command.c:2262 command.c:2272 command.c:2281 -#: command.c:2295 command.c:2312 command.c:2370 common.c:67 copy.c:332 -#: copy.c:392 copy.c:405 psqlscanslash.l:692 psqlscanslash.l:703 -#: psqlscanslash.l:713 +#: command.c:1613 command.c:1633 command.c:2311 command.c:2314 command.c:2317 +#: command.c:2323 command.c:2325 command.c:2333 command.c:2343 command.c:2352 +#: command.c:2366 command.c:2383 command.c:2441 common.c:68 copy.c:332 +#: copy.c:392 copy.c:405 psqlscanslash.l:711 psqlscanslash.l:722 +#: psqlscanslash.l:732 #, c-format msgid "%s: %s\n" msgstr "%s: %s\n" -#: command.c:1700 +#: command.c:1727 #, c-format msgid "+ opt(%d) = |%s|\n" msgstr "+ opt(%d) = |%s|\n" -#: command.c:1726 startup.c:207 +#: command.c:1753 startup.c:207 msgid "Password: " msgstr "Password: " -#: command.c:1731 startup.c:209 +#: command.c:1758 startup.c:209 #, c-format msgid "Password for user %s: " msgstr "Inserisci la password per l'utente %s: " -#: command.c:1778 +#: command.c:1809 #, c-format msgid "All connection parameters must be supplied because no database connection exists\n" msgstr "Tutti i parametri di connessione devono essere forniti perché non esiste alcuna connessione di database\n" -#: command.c:1901 +#: command.c:1966 #, c-format msgid "Previous connection kept\n" msgstr "Connessione precedente mantenuta\n" -#: command.c:1905 +#: command.c:1970 #, c-format msgid "\\connect: %s" msgstr "\\connect: %s" -#: command.c:1937 +#: command.c:2006 #, c-format msgid "You are now connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n" msgstr "Adesso sei collegato al database \"%s\" con nome utente \"%s\" tramite socket \"%s\" porta \"%s\".\n" -#: command.c:1940 +#: command.c:2009 #, c-format msgid "You are now connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n" msgstr "Adesso sei collegato al database \"%s\" con nome utente \"%s\" sull'host \"%s\" porta \"%s\".\n" -#: command.c:1944 +#: command.c:2013 #, c-format msgid "You are now connected to database \"%s\" as user \"%s\".\n" msgstr "Sei collegato al database \"%s\" con nome utente \"%s\".\n" -#: command.c:1978 +#: command.c:2046 #, c-format msgid "%s (%s, server %s)\n" msgstr "%s (%s, server %s)\n" -#: command.c:1986 +#: command.c:2054 #, c-format msgid "" -"WARNING: %s major version %d.%d, server major version %d.%d.\n" +"WARNING: %s major version %s, server major version %s.\n" " Some psql features might not work.\n" msgstr "" -"ATTENZIONE: versione maggiore %s %d.%d, versione maggiore server %d.%d.\n" -" Alcune caratteristiche di psql potrebbero non funzionare.\n" +"ATTENZIONE: versione maggiore %s %s, versione maggiore server %s.\n" +" Alcune caratteristiche di psql potrebbero non funzionare.\n" -#: command.c:2020 +#: command.c:2091 #, c-format msgid "SSL connection (protocol: %s, cipher: %s, bits: %s, compression: %s)\n" msgstr "connessione SSL (protocollo: %s, cifrario: %s, bit: %s, compressione: %s)\n" -#: command.c:2021 command.c:2022 command.c:2023 +#: command.c:2092 command.c:2093 command.c:2094 msgid "unknown" msgstr "sconosciuto" -#: command.c:2024 help.c:46 +#: command.c:2095 help.c:46 msgid "off" msgstr "disattivato" -#: command.c:2024 help.c:46 +#: command.c:2095 help.c:46 msgid "on" msgstr "attivato" -#: command.c:2044 +#: command.c:2115 #, c-format msgid "" "WARNING: Console code page (%u) differs from Windows code page (%u)\n" @@ -419,239 +419,239 @@ msgstr "" " funzionare correttamente. Vedi le pagine di riferimento\n" " psql \"Note per utenti Windows\" per i dettagli.\n" -#: command.c:2129 +#: command.c:2200 #, c-format msgid "environment variable PSQL_EDITOR_LINENUMBER_ARG must be set to specify a line number\n" msgstr "la variabile di ambiente PSQL_EDITOR_LINENUMBER_ARG deve specificare un numero di riga\n" -#: command.c:2158 +#: command.c:2229 #, c-format msgid "could not start editor \"%s\"\n" msgstr "avvio dell'editor \"%s\" fallito\n" -#: command.c:2160 +#: command.c:2231 #, c-format msgid "could not start /bin/sh\n" msgstr "avvio di /bin/sh fallito\n" -#: command.c:2198 +#: command.c:2269 #, c-format msgid "could not locate temporary directory: %s\n" msgstr "directory temporanea non trovata: %s\n" -#: command.c:2225 +#: command.c:2296 #, c-format msgid "could not open temporary file \"%s\": %s\n" msgstr "apertura del file temporaneo \"%s\" fallita: %s\n" -#: command.c:2499 +#: command.c:2570 #, c-format msgid "\\pset: allowed formats are unaligned, aligned, wrapped, html, asciidoc, latex, latex-longtable, troff-ms\n" msgstr "\\pset: i formati consentiti sono unaligned, aligned, wrapped, html, asciidoc, latex, latex-longtable, troff-ms\n" -#: command.c:2518 +#: command.c:2589 #, c-format msgid "\\pset: allowed line styles are ascii, old-ascii, unicode\n" msgstr "\\pset: gli stili di linea permessi sono ascii, old-ascii, unicode\n" -#: command.c:2534 +#: command.c:2605 #, c-format msgid "\\pset: allowed Unicode border line styles are single, double\n" msgstr "\\pset: gli stili riga Unicode dei bordi consentiti sono single, double\n" -#: command.c:2549 +#: command.c:2620 #, c-format msgid "\\pset: allowed Unicode column line styles are single, double\n" msgstr "\\pset: gli stili riga Unicode delle colonne consentiti sono single, double\n" -#: command.c:2564 +#: command.c:2635 #, c-format msgid "\\pset: allowed Unicode header line styles are single, double\n" msgstr "\\pset: gli stili riga Unicode delle intestazioni consentiti sono single, double\n" -#: command.c:2716 command.c:2895 +#: command.c:2787 command.c:2966 #, c-format msgid "\\pset: unknown option: %s\n" msgstr "\\pset: opzione sconosciuta: %s\n" -#: command.c:2734 +#: command.c:2805 #, c-format msgid "Border style is %d.\n" msgstr "Lo stile del bordo è %d.\n" -#: command.c:2740 +#: command.c:2811 #, c-format msgid "Target width is unset.\n" msgstr "La lunghezza di destinazione non è impostata.\n" -#: command.c:2742 +#: command.c:2813 #, c-format msgid "Target width is %d.\n" msgstr "La larghezza di destinazione è %d.\n" -#: command.c:2749 +#: command.c:2820 #, c-format msgid "Expanded display is on.\n" msgstr "La visualizzazione espansa è attiva.\n" -#: command.c:2751 +#: command.c:2822 #, c-format msgid "Expanded display is used automatically.\n" msgstr "La visualizzazione espansa è usata automaticamente.\n" -#: command.c:2753 +#: command.c:2824 #, c-format msgid "Expanded display is off.\n" msgstr "La visualizzazione espansa è disattivata.\n" -#: command.c:2760 command.c:2768 +#: command.c:2831 command.c:2839 #, c-format msgid "Field separator is zero byte.\n" msgstr "Il separatore di campo è il byte zero.\n" -#: command.c:2762 +#: command.c:2833 #, c-format msgid "Field separator is \"%s\".\n" msgstr "Il separatore di campo è \"%s\".\n" -#: command.c:2775 +#: command.c:2846 #, c-format msgid "Default footer is on.\n" msgstr "Il piè di pagina di default è attivo.\n" -#: command.c:2777 +#: command.c:2848 #, c-format msgid "Default footer is off.\n" msgstr "Il piè di pagina di default è disattivato.\n" -#: command.c:2783 +#: command.c:2854 #, c-format msgid "Output format is %s.\n" msgstr "Il formato di output è %s.\n" -#: command.c:2789 +#: command.c:2860 #, c-format msgid "Line style is %s.\n" msgstr "Lo stile della linea è %s.\n" -#: command.c:2796 +#: command.c:2867 #, c-format msgid "Null display is \"%s\".\n" msgstr "La visualizzazione dei null è \"%s\".\n" -#: command.c:2804 +#: command.c:2875 #, c-format msgid "Locale-adjusted numeric output is on.\n" msgstr "La correzione dell'output numerico secondo il locale è attiva.\n" -#: command.c:2806 +#: command.c:2877 #, c-format msgid "Locale-adjusted numeric output is off.\n" msgstr "La correzione dell'output numerico secondo il locale è disattivata.\n" -#: command.c:2813 +#: command.c:2884 #, c-format msgid "Pager is used for long output.\n" msgstr "Usa la paginazione per risultati estesi.\n" -#: command.c:2815 +#: command.c:2886 #, c-format msgid "Pager is always used.\n" msgstr "Paginazione sempre attiva.\n" -#: command.c:2817 +#: command.c:2888 #, c-format msgid "Pager usage is off.\n" msgstr "Paginazione disattivata.\n" -#: command.c:2823 +#: command.c:2894 #, c-format msgid "Pager won't be used for less than %d line.\n" msgid_plural "Pager won't be used for less than %d lines.\n" msgstr[0] "La paginazione non verrà usata per meno di %d riga.\n" msgstr[1] "La paginazione non verrà usata per meno di %d righe.\n" -#: command.c:2833 command.c:2843 +#: command.c:2904 command.c:2914 #, c-format msgid "Record separator is zero byte.\n" msgstr "Il separatore di record è il byte zero.\n" -#: command.c:2835 +#: command.c:2906 #, c-format msgid "Record separator is .\n" msgstr "Il separatore di record è .\n" -#: command.c:2837 +#: command.c:2908 #, c-format msgid "Record separator is \"%s\".\n" msgstr "Il separatore di record è \"%s\".\n" -#: command.c:2850 +#: command.c:2921 #, c-format msgid "Table attributes are \"%s\".\n" msgstr "Gli attributi di tabella sono \"%s\".\n" -#: command.c:2853 +#: command.c:2924 #, c-format msgid "Table attributes unset.\n" msgstr "Gli attributi di tabella non sono specificati.\n" -#: command.c:2860 +#: command.c:2931 #, c-format msgid "Title is \"%s\".\n" msgstr "Il titolo è \"%s\".\n" -#: command.c:2862 +#: command.c:2933 #, c-format msgid "Title is unset.\n" msgstr "Il titolo non è assegnato.\n" -#: command.c:2869 +#: command.c:2940 #, c-format msgid "Tuples only is on.\n" msgstr "La visualizzazione dei soli dati è attiva.\n" -#: command.c:2871 +#: command.c:2942 #, c-format msgid "Tuples only is off.\n" msgstr "La visualizzazione dei soli dati è disattivata.\n" -#: command.c:2877 +#: command.c:2948 #, c-format msgid "Unicode border line style is \"%s\".\n" msgstr "Lo stile riga Unicode dei bordi è \"%s\".\n" -#: command.c:2883 +#: command.c:2954 #, c-format msgid "Unicode column line style is \"%s\".\n" msgstr "Lo stile riga Unicode delle colonne è \"%s\".\n" -#: command.c:2889 +#: command.c:2960 #, c-format msgid "Unicode header line style is \"%s\".\n" msgstr "Lo stile riga Unicode delle intestazioni è \"%s\".\n" -#: command.c:3049 +#: command.c:3120 #, c-format msgid "\\!: failed\n" msgstr "\\!: fallita\n" -#: command.c:3073 common.c:654 +#: command.c:3145 common.c:659 #, c-format msgid "\\watch cannot be used with an empty query\n" msgstr "\\watch non può essere usato con una query vuota\n" -#: command.c:3110 +#: command.c:3186 #, c-format msgid "%s\t%s (every %gs)\n" msgstr "%s\t%s (ogni %gs)\n" -#: command.c:3113 +#: command.c:3189 #, c-format msgid "%s (every %gs)\n" msgstr "%s (ogni %gs)\n" -#: command.c:3167 command.c:3174 common.c:554 common.c:561 common.c:1168 +#: command.c:3243 command.c:3250 common.c:559 common.c:566 common.c:1173 #, c-format msgid "" "********* QUERY **********\n" @@ -664,82 +664,87 @@ msgstr "" "**************************\n" "\n" -#: command.c:3325 +#: command.c:3442 #, c-format -msgid "%s.%s is not a view\n" -msgstr "%s.%s non è una vista\n" +msgid "\"%s.%s\" is not a view\n" +msgstr "\"%s.%s\" non è una vista\n" -#: common.c:137 +#: command.c:3458 #, c-format -msgid "can't escape without active connection\n" +msgid "could not parse reloptions array\n" +msgstr "interpretazione dell'array reloptions fallita\n" + +#: common.c:138 +#, c-format +msgid "cannot escape without active connection\n" msgstr "non è possibile effettuare l'escape senza una connessione attiva\n" -#: common.c:366 +#: common.c:371 #, c-format msgid "connection to server was lost\n" msgstr "connessione al server persa\n" -#: common.c:370 +#: common.c:375 #, c-format msgid "The connection to the server was lost. Attempting reset: " msgstr "Connessione al server persa. Tentativo di reset: " -#: common.c:375 +#: common.c:380 #, c-format msgid "Failed.\n" msgstr "Fallito.\n" -#: common.c:382 +#: common.c:387 #, c-format msgid "Succeeded.\n" msgstr "Riuscito.\n" -#: common.c:482 common.c:931 common.c:1103 +#: common.c:487 common.c:936 common.c:1108 #, c-format msgid "unexpected PQresultStatus: %d\n" msgstr "PQresultStatus imprevisto: %d\n" -#: common.c:661 +#: common.c:666 #, c-format msgid "\\watch cannot be used with COPY\n" msgstr "\\watch non può essere usato con COPY\n" -#: common.c:666 +#: common.c:671 #, c-format msgid "unexpected result status for \\watch\n" msgstr "risultato imprevisto per \\watch\n" -#: common.c:677 common.c:1327 +#: common.c:682 common.c:1335 #, c-format msgid "Time: %.3f ms\n" msgstr "Tempo: %.3f ms\n" -#: common.c:695 +#: common.c:700 #, c-format msgid "Asynchronous notification \"%s\" with payload \"%s\" received from server process with PID %d.\n" msgstr "Notifica asincrona \"%s\" con payload \"%s\" ricevuta dal processo server con PID %d.\n" -#: common.c:698 +#: common.c:703 #, c-format msgid "Asynchronous notification \"%s\" received from server process with PID %d.\n" msgstr "Notifica asincrona \"%s\" ricevuta dal processo server con PID %d.\n" -#: common.c:756 +#: common.c:761 #, c-format msgid "no rows returned for \\gset\n" msgstr "nessuna riga restituita per \\gset\n" -#: common.c:761 +#: common.c:766 #, c-format msgid "more than one row returned for \\gset\n" msgstr "più di una riga restituita per \\gset\n" -#: common.c:787 +#: common.c:792 #, c-format msgid "could not set variable \"%s\"\n" msgstr "impostazione della variabile \"%s\" fallita\n" -#: common.c:1148 +#: common.c:1153 #, c-format msgid "" "***(Single step mode: verify command)*******************************************\n" @@ -750,17 +755,17 @@ msgstr "" "%s\n" "***(premi invio per procedere oppure digita x ed invio per annullare)***********\n" -#: common.c:1201 +#: common.c:1208 #, c-format -msgid "The server (version %d.%d) does not support savepoints for ON_ERROR_ROLLBACK.\n" -msgstr "Questa versione (%d.%d) del server non supporta savepoint per ON_ERROR_ROLLBACK..\n" +msgid "The server (version %s) does not support savepoints for ON_ERROR_ROLLBACK.\n" +msgstr "Il server (versione %s) non supporta savepoint per ON_ERROR_ROLLBACK.\n" -#: common.c:1256 +#: common.c:1264 #, c-format msgid "STATEMENT: %s\n" msgstr "COMANDO: %s\n" -#: common.c:1299 +#: common.c:1307 #, c-format msgid "unexpected transaction status (%d)\n" msgstr "stato della transazione imprevisto (%d)\n" @@ -830,40 +835,85 @@ msgstr "interrotto a causa di lettura non riuscita" msgid "trying to exit copy mode" msgstr "tentativo di uscita dalla modalità copy" -#: describe.c:71 describe.c:264 describe.c:496 describe.c:626 describe.c:769 -#: describe.c:886 describe.c:956 describe.c:2931 describe.c:3136 -#: describe.c:3226 describe.c:3471 describe.c:3608 describe.c:3837 -#: describe.c:3909 describe.c:3920 describe.c:3979 describe.c:4387 -#: describe.c:4467 +#: crosstabview.c:125 +#, c-format +msgid "\\crosstabview: statement did not return a result set\n" +msgstr "\\crosstabview: l'istruzione non ha restituito dati\n" + +#: crosstabview.c:131 +#, c-format +msgid "\\crosstabview: query must return at least three columns\n" +msgstr "\\crosstabview: la query deve restituire almeno tre colonne\n" + +#: crosstabview.c:158 +#, c-format +msgid "\\crosstabview: vertical and horizontal headers must be different columns\n" +msgstr "\\crosstabview: le intestazioni verticali ed orizzontali devono essere in colonne diverse\n" + +#: crosstabview.c:174 +#, c-format +msgid "\\crosstabview: data column must be specified when query returns more than three columns\n" +msgstr "\\crosstabview: la colonna dei dati deve essere specificata quando la query restituisce più di tre colonne\n" + +#: crosstabview.c:230 +#, c-format +msgid "\\crosstabview: maximum number of columns (%d) exceeded\n" +msgstr "\\crosstabview: numero massimo di colonne (%d) superato\n" + +#: crosstabview.c:399 +#, c-format +msgid "\\crosstabview: query result contains multiple data values for row \"%s\", column \"%s\"\n" +msgstr "\\crosstabview: i risultati della query contengono più di un valore per la riga \"%s\", colonna \"%s\"\n" + +#: crosstabview.c:647 +#, c-format +msgid "\\crosstabview: column number %d is out of range 1..%d\n" +msgstr "\\crosstabview: il numero di colonna %d è al di fuori dell'intervallo 1..%d\n" + +#: crosstabview.c:672 +#, c-format +msgid "\\crosstabview: ambiguous column name: \"%s\"\n" +msgstr "\\crosstabview: nome di colonna ambiguo: \"%s\"\n" + +#: crosstabview.c:680 +#, c-format +msgid "\\crosstabview: column name not found: \"%s\"\n" +msgstr "\\crosstabview: colonna non trovata: \"%s\"\n" + +#: describe.c:71 describe.c:340 describe.c:597 describe.c:727 describe.c:870 +#: describe.c:990 describe.c:1060 describe.c:3035 describe.c:3240 +#: describe.c:3330 describe.c:3578 describe.c:3718 describe.c:3950 +#: describe.c:4025 describe.c:4036 describe.c:4098 describe.c:4518 +#: describe.c:4601 msgid "Schema" msgstr "Schema" -#: describe.c:72 describe.c:156 describe.c:164 describe.c:265 describe.c:497 -#: describe.c:627 describe.c:688 describe.c:770 describe.c:957 describe.c:2932 -#: describe.c:3058 describe.c:3137 describe.c:3227 describe.c:3306 -#: describe.c:3472 describe.c:3536 describe.c:3609 describe.c:3838 -#: describe.c:3910 describe.c:3921 describe.c:3980 describe.c:4169 -#: describe.c:4250 describe.c:4465 +#: describe.c:72 describe.c:160 describe.c:226 describe.c:234 describe.c:341 +#: describe.c:598 describe.c:728 describe.c:789 describe.c:871 describe.c:1061 +#: describe.c:3036 describe.c:3162 describe.c:3241 describe.c:3331 +#: describe.c:3410 describe.c:3579 describe.c:3643 describe.c:3719 +#: describe.c:3951 describe.c:4026 describe.c:4037 describe.c:4099 +#: describe.c:4291 describe.c:4375 describe.c:4599 msgid "Name" msgstr "Nome" -#: describe.c:73 describe.c:277 describe.c:323 describe.c:340 +#: describe.c:73 describe.c:353 describe.c:399 describe.c:416 msgid "Result data type" msgstr "Tipo dato del risultato" -#: describe.c:81 describe.c:94 describe.c:98 describe.c:278 describe.c:324 -#: describe.c:341 +#: describe.c:81 describe.c:94 describe.c:98 describe.c:354 describe.c:400 +#: describe.c:417 msgid "Argument data types" msgstr "Tipo dato dei parametri" -#: describe.c:105 describe.c:187 describe.c:370 describe.c:545 describe.c:642 -#: describe.c:713 describe.c:959 describe.c:1572 describe.c:2732 -#: describe.c:2965 describe.c:3089 describe.c:3163 describe.c:3236 -#: describe.c:3319 describe.c:3387 describe.c:3479 describe.c:3545 -#: describe.c:3610 describe.c:3746 describe.c:3786 describe.c:3854 -#: describe.c:3913 describe.c:3922 describe.c:3981 describe.c:4195 -#: describe.c:4272 describe.c:4401 describe.c:4468 large_obj.c:289 -#: large_obj.c:299 +#: describe.c:105 describe.c:170 describe.c:257 describe.c:462 describe.c:646 +#: describe.c:743 describe.c:814 describe.c:1063 describe.c:1676 +#: describe.c:2836 describe.c:3069 describe.c:3193 describe.c:3267 +#: describe.c:3340 describe.c:3423 describe.c:3491 describe.c:3586 +#: describe.c:3652 describe.c:3720 describe.c:3856 describe.c:3896 +#: describe.c:3967 describe.c:4029 describe.c:4038 describe.c:4100 +#: describe.c:4317 describe.c:4397 describe.c:4532 describe.c:4602 +#: large_obj.c:289 large_obj.c:299 msgid "Description" msgstr "Descrizione" @@ -871,869 +921,902 @@ msgstr "Descrizione" msgid "List of aggregate functions" msgstr "Lista delle funzione aggregate" -#: describe.c:144 +#: describe.c:147 +#, c-format +msgid "The server (version %s) does not support access methods.\n" +msgstr "Il server (versione %s) non supporta metodi di accesso.\n" + +#: describe.c:161 +msgid "Index" +msgstr "Indice" + +#: describe.c:162 describe.c:360 describe.c:405 describe.c:422 describe.c:877 +#: describe.c:999 describe.c:1645 describe.c:3044 describe.c:3242 +#: describe.c:4394 +msgid "Type" +msgstr "Tipo" + +#: describe.c:169 describe.c:4296 +msgid "Handler" +msgstr "Handler" + +#: describe.c:188 +msgid "List of access methods" +msgstr "Lista dei metodi di accesso" + +#: describe.c:213 #, c-format -msgid "The server (version %d.%d) does not support tablespaces.\n" -msgstr "Il server (versione %d.%d) non supporta i tablespace.\n" +msgid "The server (version %s) does not support tablespaces.\n" +msgstr "Il server (versione %s) non supporta i tablespace.\n" -#: describe.c:157 describe.c:165 describe.c:367 describe.c:535 describe.c:689 -#: describe.c:885 describe.c:2941 describe.c:3062 describe.c:3308 -#: describe.c:3537 describe.c:4170 describe.c:4251 large_obj.c:288 +#: describe.c:227 describe.c:235 describe.c:450 describe.c:636 describe.c:790 +#: describe.c:989 describe.c:3045 describe.c:3166 describe.c:3412 +#: describe.c:3644 describe.c:4292 describe.c:4376 large_obj.c:288 msgid "Owner" msgstr "Proprietario" -#: describe.c:158 describe.c:166 +#: describe.c:228 describe.c:236 msgid "Location" msgstr "Posizione" -#: describe.c:177 describe.c:2543 +#: describe.c:247 describe.c:2647 msgid "Options" msgstr "Opzioni" -#: describe.c:182 describe.c:508 describe.c:705 describe.c:2957 -#: describe.c:2961 +#: describe.c:252 describe.c:609 describe.c:806 describe.c:3061 describe.c:3065 msgid "Size" msgstr "Dimensione" -#: describe.c:204 +#: describe.c:274 msgid "List of tablespaces" msgstr "Lista dei tablespace" -#: describe.c:241 +#: describe.c:314 #, c-format msgid "\\df only takes [antwS+] as options\n" msgstr "\\df accetta come opzione solo [antwS+]\n" -#: describe.c:247 +#: describe.c:322 #, c-format -msgid "\\df does not take a \"w\" option with server version %d.%d\n" -msgstr "\\df non accetta un'opzione \"w\" con la versione del server %d.%d\n" +msgid "\\df does not take a \"w\" option with server version %s\n" +msgstr "\\df non accetta un'opzione \"w\" con il server in versione %s\n" #. translator: "agg" is short for "aggregate" -#: describe.c:280 describe.c:326 describe.c:343 +#: describe.c:356 describe.c:402 describe.c:419 msgid "agg" msgstr "aggr" -#: describe.c:281 +#: describe.c:357 msgid "window" msgstr "finestra" -#: describe.c:282 describe.c:327 describe.c:344 describe.c:1093 +#: describe.c:358 describe.c:403 describe.c:420 describe.c:1197 msgid "trigger" msgstr "trigger" -#: describe.c:283 describe.c:328 describe.c:345 +#: describe.c:359 describe.c:404 describe.c:421 msgid "normal" msgstr "normale" -#: describe.c:284 describe.c:329 describe.c:346 describe.c:776 describe.c:895 -#: describe.c:1541 describe.c:2940 describe.c:3138 describe.c:4269 -msgid "Type" -msgstr "Tipo" - -#: describe.c:360 -msgid "definer" -msgstr "definitore" - -#: describe.c:361 -msgid "invoker" -msgstr "invocatore" - -#: describe.c:362 -msgid "Security" -msgstr "Sicurezza" - -#: describe.c:363 +#: describe.c:432 msgid "immutable" msgstr "immutabile" -#: describe.c:364 +#: describe.c:433 msgid "stable" msgstr "stabile" -#: describe.c:365 +#: describe.c:434 msgid "volatile" msgstr "volatile" -#: describe.c:366 +#: describe.c:435 msgid "Volatility" msgstr "Volatilità" -#: describe.c:368 +#: describe.c:443 +msgid "restricted" +msgstr "ristretta" + +#: describe.c:444 +msgid "safe" +msgstr "sicura" + +#: describe.c:445 +msgid "unsafe" +msgstr "non sicura" + +#: describe.c:446 +msgid "Parallel" +msgstr "Parallela" + +#: describe.c:451 +msgid "definer" +msgstr "definitore" + +#: describe.c:452 +msgid "invoker" +msgstr "invocatore" + +#: describe.c:453 +msgid "Security" +msgstr "Sicurezza" + +#: describe.c:460 msgid "Language" msgstr "Linguaggio" -#: describe.c:369 +#: describe.c:461 msgid "Source code" msgstr "Codice sorgente" -#: describe.c:467 +#: describe.c:560 msgid "List of functions" msgstr "Lista delle funzioni" -#: describe.c:507 +#: describe.c:608 msgid "Internal name" msgstr "Nome interno" -#: describe.c:529 +#: describe.c:630 msgid "Elements" msgstr "Elementi" -#: describe.c:585 +#: describe.c:686 msgid "List of data types" msgstr "Lista dei tipi di dati" -#: describe.c:628 +#: describe.c:729 msgid "Left arg type" msgstr "Argomento sinistro" -#: describe.c:629 +#: describe.c:730 msgid "Right arg type" msgstr "Argomento destro" -#: describe.c:630 +#: describe.c:731 msgid "Result type" msgstr "Tipo di risultato" -#: describe.c:635 describe.c:3378 describe.c:3745 +#: describe.c:736 describe.c:3482 describe.c:3855 msgid "Function" msgstr "Funzione" -#: describe.c:660 +#: describe.c:761 msgid "List of operators" msgstr "Lista degli operatori" -#: describe.c:690 +#: describe.c:791 msgid "Encoding" msgstr "Codifica" -#: describe.c:695 describe.c:3473 +#: describe.c:796 describe.c:3580 msgid "Collate" msgstr "Ordinamento" -#: describe.c:696 describe.c:3474 +#: describe.c:797 describe.c:3581 msgid "Ctype" msgstr "Ctype" -#: describe.c:709 +#: describe.c:810 msgid "Tablespace" msgstr "Tablespace" -#: describe.c:731 +#: describe.c:832 msgid "List of databases" msgstr "Lista dei database" -#: describe.c:771 describe.c:888 describe.c:2933 +#: describe.c:872 describe.c:992 describe.c:3037 msgid "table" msgstr "tabella" -#: describe.c:772 describe.c:2934 +#: describe.c:873 describe.c:3038 msgid "view" msgstr "vista" -#: describe.c:773 describe.c:2935 +#: describe.c:874 describe.c:3039 msgid "materialized view" msgstr "vista materializzata" -#: describe.c:774 describe.c:890 describe.c:2937 +#: describe.c:875 describe.c:994 describe.c:3041 msgid "sequence" msgstr "sequenza" -#: describe.c:775 describe.c:2939 +#: describe.c:876 describe.c:3043 msgid "foreign table" msgstr "tabella esterna" -#: describe.c:787 +#: describe.c:888 msgid "Column privileges" msgstr "Privilegi di colonna" -#: describe.c:818 +#: describe.c:919 msgid "Policies" msgstr "Regole di sicurezza" -#: describe.c:844 describe.c:4612 describe.c:4616 +#: describe.c:945 describe.c:4749 describe.c:4753 msgid "Access privileges" msgstr "Privilegi di accesso" -#: describe.c:873 +#: describe.c:976 #, c-format -msgid "The server (version %d.%d) does not support altering default privileges.\n" -msgstr "Il server (versione %d.%d) non supporta la modifica dei privilegi di default.\n" +msgid "The server (version %s) does not support altering default privileges.\n" +msgstr "Il server (versione %s) non supporta la modifica dei privilegi di default.\n" -#: describe.c:892 +#: describe.c:996 msgid "function" msgstr "funzione" -#: describe.c:894 +#: describe.c:998 msgid "type" msgstr "tipo" -#: describe.c:918 +#: describe.c:1022 msgid "Default access privileges" msgstr "Privilegi di accesso di default" -#: describe.c:958 +#: describe.c:1062 msgid "Object" msgstr "Oggetto" -#: describe.c:972 +#: describe.c:1076 msgid "table constraint" msgstr "vincolo di tabella" -#: describe.c:994 +#: describe.c:1098 msgid "domain constraint" msgstr "vincolo di dominio" -#: describe.c:1022 +#: describe.c:1126 msgid "operator class" msgstr "classe operatori" -#: describe.c:1051 +#: describe.c:1155 msgid "operator family" msgstr "famiglia operatori" -#: describe.c:1073 +#: describe.c:1177 msgid "rule" msgstr "regola" -#: describe.c:1115 +#: describe.c:1219 msgid "Object descriptions" msgstr "Descrizioni oggetti" -#: describe.c:1169 +#: describe.c:1273 #, c-format msgid "Did not find any relation named \"%s\".\n" msgstr "Non ho trovato alcuna relazione di nome \"%s\".\n" -#: describe.c:1379 +#: describe.c:1483 #, c-format msgid "Did not find any relation with OID %s.\n" msgstr "Non ho trovato nessuna relazione con OID %s.\n" -#: describe.c:1485 +#: describe.c:1589 #, c-format msgid "Unlogged table \"%s.%s\"" msgstr "Tabella non loggata \"%s.%s\"" -#: describe.c:1488 +#: describe.c:1592 #, c-format msgid "Table \"%s.%s\"" msgstr "Tabella \"%s.%s\"" -#: describe.c:1492 +#: describe.c:1596 #, c-format msgid "View \"%s.%s\"" msgstr "Vista \"%s.%s\"" -#: describe.c:1497 +#: describe.c:1601 #, c-format msgid "Unlogged materialized view \"%s.%s\"" msgstr "Vista materializzata non loggata \"%s.%s\"" -#: describe.c:1500 +#: describe.c:1604 #, c-format msgid "Materialized view \"%s.%s\"" msgstr "Vista materializzata \"%s.%s\"" -#: describe.c:1504 +#: describe.c:1608 #, c-format msgid "Sequence \"%s.%s\"" msgstr "Sequenza \"%s.%s\"" -#: describe.c:1509 +#: describe.c:1613 #, c-format msgid "Unlogged index \"%s.%s\"" msgstr "Indice non loggato \"%s.%s\"" -#: describe.c:1512 +#: describe.c:1616 #, c-format msgid "Index \"%s.%s\"" msgstr "Indice \"%s.%s\"" -#: describe.c:1517 +#: describe.c:1621 #, c-format msgid "Special relation \"%s.%s\"" msgstr "relazione speciale \"%s.%s\"" -#: describe.c:1521 +#: describe.c:1625 #, c-format msgid "TOAST table \"%s.%s\"" msgstr "Tabella TOAST \"%s.%s\"" -#: describe.c:1525 +#: describe.c:1629 #, c-format msgid "Composite type \"%s.%s\"" msgstr "Tipo composito \"%s.%s\"" -#: describe.c:1529 +#: describe.c:1633 #, c-format msgid "Foreign table \"%s.%s\"" msgstr "Tabella esterna \"%s.%s\"" -#: describe.c:1540 +#: describe.c:1644 msgid "Column" msgstr "Colonna" -#: describe.c:1549 +#: describe.c:1653 msgid "Modifiers" msgstr "Modificatori" -#: describe.c:1554 +#: describe.c:1658 msgid "Value" msgstr "Valore" -#: describe.c:1557 +#: describe.c:1661 msgid "Definition" msgstr "Definizione" -#: describe.c:1560 describe.c:4190 describe.c:4271 describe.c:4339 -#: describe.c:4400 +#: describe.c:1664 describe.c:4312 describe.c:4396 describe.c:4467 +#: describe.c:4531 msgid "FDW Options" msgstr "Opzioni FDW" -#: describe.c:1564 +#: describe.c:1668 msgid "Storage" msgstr "Memorizzazione" -#: describe.c:1567 +#: describe.c:1671 msgid "Stats target" msgstr "Dest. stat." -#: describe.c:1617 +#: describe.c:1721 #, c-format msgid "collate %s" msgstr "ordinamento %s" -#: describe.c:1625 +#: describe.c:1729 msgid "not null" msgstr "non null" #. translator: default values of column definitions -#: describe.c:1635 +#: describe.c:1739 #, c-format msgid "default %s" msgstr "preimpostato %s" -#: describe.c:1750 +#: describe.c:1854 msgid "primary key, " msgstr "chiave primaria, " -#: describe.c:1752 +#: describe.c:1856 msgid "unique, " msgstr "univoco, " -#: describe.c:1758 +#: describe.c:1862 #, c-format msgid "for table \"%s.%s\"" msgstr "per la tabella \"%s.%s\"" -#: describe.c:1762 +#: describe.c:1866 #, c-format msgid ", predicate (%s)" msgstr ", predicato (%s)" -#: describe.c:1765 +#: describe.c:1869 msgid ", clustered" msgstr ", raggruppato" -#: describe.c:1768 +#: describe.c:1872 msgid ", invalid" msgstr ", non valido" -#: describe.c:1771 +#: describe.c:1875 msgid ", deferrable" msgstr ", deferibile" -#: describe.c:1774 +#: describe.c:1878 msgid ", initially deferred" msgstr ", inizialmente deferito" -#: describe.c:1777 +#: describe.c:1881 msgid ", replica identity" msgstr ", identità di replica" -#: describe.c:1812 +#: describe.c:1916 #, c-format msgid "Owned by: %s" msgstr "Proprietario: %s" -#: describe.c:1872 +#: describe.c:1976 msgid "Indexes:" msgstr "Indici:" -#: describe.c:1956 +#: describe.c:2060 msgid "Check constraints:" msgstr "Vincoli di controllo:" -#: describe.c:1987 +#: describe.c:2091 msgid "Foreign-key constraints:" msgstr "Vincoli di integrità referenziale" -#: describe.c:2018 +#: describe.c:2122 msgid "Referenced by:" msgstr "Referenziato da:" -#: describe.c:2063 +#: describe.c:2167 msgid "Policies:" msgstr "Regole di sicurezza:" -#: describe.c:2066 +#: describe.c:2170 msgid "Policies (forced row security enabled):" msgstr "Regole (sicurezza per riga forzata abilitata):" -#: describe.c:2069 +#: describe.c:2173 msgid "Policies (row security enabled): (none)" msgstr "Regole (sicurezza per riga abilitata): (nessuna)" -#: describe.c:2072 +#: describe.c:2176 msgid "Policies (forced row security enabled): (none)" msgstr "Regole (sicurezza per riga forzata abilitata): (nessuna)" -#: describe.c:2075 +#: describe.c:2179 msgid "Policies (row security disabled):" msgstr "Regole (sicurezza per riga disabilitata):" -#: describe.c:2175 describe.c:2225 +#: describe.c:2279 describe.c:2329 msgid "Rules:" msgstr "Regole:" -#: describe.c:2178 +#: describe.c:2282 msgid "Disabled rules:" msgstr "Regole disabilitate:" -#: describe.c:2181 +#: describe.c:2285 msgid "Rules firing always:" msgstr "Regole sempre abilitate:" -#: describe.c:2184 +#: describe.c:2288 msgid "Rules firing on replica only:" msgstr "Regole abilitate solo su replica:" -#: describe.c:2208 +#: describe.c:2312 msgid "View definition:" msgstr "Definizione vista:" -#: describe.c:2343 +#: describe.c:2447 msgid "Triggers:" msgstr "Trigger:" -#: describe.c:2347 +#: describe.c:2451 msgid "Disabled user triggers:" msgstr "Trigger utente disabilitati:" -#: describe.c:2349 +#: describe.c:2453 msgid "Disabled triggers:" msgstr "Trigger disabilitati:" -#: describe.c:2352 +#: describe.c:2456 msgid "Disabled internal triggers:" msgstr "Trigger interni disabilitati:" -#: describe.c:2355 +#: describe.c:2459 msgid "Triggers firing always:" msgstr "Trigger sempre abilitati:" -#: describe.c:2358 +#: describe.c:2462 msgid "Triggers firing on replica only:" msgstr "Trigger abilitati solo su replica." -#: describe.c:2437 +#: describe.c:2541 msgid "Inherits" msgstr "Eredita" -#: describe.c:2476 +#: describe.c:2580 #, c-format msgid "Number of child tables: %d (Use \\d+ to list them.)" msgstr "Numero di tabelle figlio: %d (Usa \\d+ per elencarle.)" -#: describe.c:2483 +#: describe.c:2587 msgid "Child tables" msgstr "Tabelle figlio" -#: describe.c:2505 +#: describe.c:2609 #, c-format msgid "Typed table of type: %s" msgstr "Tabella di tipo: %s" -#: describe.c:2519 +#: describe.c:2623 msgid "Replica Identity" msgstr "Identità di replica" -#: describe.c:2532 +#: describe.c:2636 msgid "Has OIDs: yes" msgstr "Ha OID: sì" -#: describe.c:2620 +#: describe.c:2724 #, c-format msgid "Tablespace: \"%s\"" msgstr "Tablespace: \"%s\"" #. translator: before this string there's an index description like #. '"foo_pkey" PRIMARY KEY, btree (a)' -#: describe.c:2632 +#: describe.c:2736 #, c-format msgid ", tablespace \"%s\"" msgstr ", tablespace \"%s\"" -#: describe.c:2725 +#: describe.c:2829 msgid "List of roles" msgstr "Lista dei ruoli" -#: describe.c:2727 +#: describe.c:2831 msgid "Role name" msgstr "Nome ruolo" -#: describe.c:2728 +#: describe.c:2832 msgid "Attributes" msgstr "Attributi" -#: describe.c:2729 +#: describe.c:2833 msgid "Member of" msgstr "Membro di" -#: describe.c:2740 +#: describe.c:2844 msgid "Superuser" msgstr "Superutente" -#: describe.c:2743 +#: describe.c:2847 msgid "No inheritance" msgstr "Nessuna ereditarietà" -#: describe.c:2746 +#: describe.c:2850 msgid "Create role" msgstr "Crea ruoli" -#: describe.c:2749 +#: describe.c:2853 msgid "Create DB" msgstr "Crea DB" -#: describe.c:2752 +#: describe.c:2856 msgid "Cannot login" msgstr "Login non possibile" -#: describe.c:2756 +#: describe.c:2860 msgid "Replication" msgstr "Replica" -#: describe.c:2760 +#: describe.c:2864 msgid "Bypass RLS" msgstr "Scavalca RLS" -#: describe.c:2769 +#: describe.c:2873 msgid "No connections" msgstr "Niente connessioni" -#: describe.c:2771 +#: describe.c:2875 #, c-format msgid "%d connection" msgid_plural "%d connections" msgstr[0] "%d connessione" msgstr[1] "%d connessioni" -#: describe.c:2781 +#: describe.c:2885 msgid "Password valid until " msgstr "Password valida fino a " -#: describe.c:2837 +#: describe.c:2941 msgid "Role" msgstr "Ruolo" -#: describe.c:2838 +#: describe.c:2942 msgid "Database" msgstr "Database" -#: describe.c:2839 +#: describe.c:2943 msgid "Settings" msgstr "Impostazioni" -#: describe.c:2849 +#: describe.c:2953 #, c-format msgid "No per-database role settings support in this server version.\n" msgstr "Questa versione del server non supporta l'impostazione dei ruoli per database.\n" -#: describe.c:2860 +#: describe.c:2964 #, c-format msgid "No matching settings found.\n" msgstr "Nessuna impostazione corrispondente trovata.\n" -#: describe.c:2862 +#: describe.c:2966 #, c-format msgid "No settings found.\n" msgstr "Nessuna impostazione trovata.\n" -#: describe.c:2867 +#: describe.c:2971 msgid "List of settings" msgstr "Lista delle impostazioni" -#: describe.c:2936 +#: describe.c:3040 msgid "index" msgstr "indice" -#: describe.c:2938 +#: describe.c:3042 msgid "special" msgstr "speciale" -#: describe.c:2946 describe.c:4388 +#: describe.c:3050 describe.c:4519 msgid "Table" msgstr "Tabella" -#: describe.c:3022 +#: describe.c:3126 #, c-format msgid "No matching relations found.\n" msgstr "Nessuna relazione corrispondente trovata.\n" -#: describe.c:3024 +#: describe.c:3128 #, c-format msgid "No relations found.\n" msgstr "Nessuna relazione trovata.\n" -#: describe.c:3029 +#: describe.c:3133 msgid "List of relations" msgstr "Lista delle relazioni" -#: describe.c:3066 +#: describe.c:3170 msgid "Trusted" msgstr "Fidato" -#: describe.c:3074 +#: describe.c:3178 msgid "Internal Language" msgstr "Linguaggio interno" -#: describe.c:3075 +#: describe.c:3179 msgid "Call Handler" msgstr "Gestore Chiamate" -#: describe.c:3076 describe.c:4177 +#: describe.c:3180 describe.c:4299 msgid "Validator" msgstr "Validatore" -#: describe.c:3079 +#: describe.c:3183 msgid "Inline Handler" msgstr "Handler Inline" -#: describe.c:3107 +#: describe.c:3211 msgid "List of languages" msgstr "Lista dei linguaggi" -#: describe.c:3151 +#: describe.c:3255 msgid "Modifier" msgstr "Modificatore" -#: describe.c:3152 +#: describe.c:3256 msgid "Check" msgstr "Controllo" -#: describe.c:3194 +#: describe.c:3298 msgid "List of domains" msgstr "Lista dei domini" -#: describe.c:3228 +#: describe.c:3332 msgid "Source" msgstr "Sorgente" -#: describe.c:3229 +#: describe.c:3333 msgid "Destination" msgstr "Destinazione" -#: describe.c:3230 describe.c:3379 +#: describe.c:3334 describe.c:3483 msgid "no" msgstr "no" -#: describe.c:3230 describe.c:3381 +#: describe.c:3334 describe.c:3485 msgid "yes" msgstr "sì" -#: describe.c:3231 +#: describe.c:3335 msgid "Default?" msgstr "Predefinito?" -#: describe.c:3268 +#: describe.c:3372 msgid "List of conversions" msgstr "Lista delle conversioni" -#: describe.c:3307 +#: describe.c:3411 msgid "Event" msgstr "Evento" -#: describe.c:3309 +#: describe.c:3413 msgid "enabled" msgstr "abilitato" -#: describe.c:3310 +#: describe.c:3414 msgid "replica" msgstr "replica" -#: describe.c:3311 +#: describe.c:3415 msgid "always" msgstr "sempre" -#: describe.c:3312 +#: describe.c:3416 msgid "disabled" msgstr "disabilitato" -#: describe.c:3313 +#: describe.c:3417 msgid "Enabled" msgstr "Abilitato" -#: describe.c:3314 +#: describe.c:3418 msgid "Procedure" msgstr "Procedura" -#: describe.c:3315 +#: describe.c:3419 msgid "Tags" msgstr "Tag" -#: describe.c:3334 +#: describe.c:3438 msgid "List of event triggers" msgstr "Lista di trigger di evento" -#: describe.c:3376 +#: describe.c:3480 msgid "Source type" msgstr "Tipo di partenza" -#: describe.c:3377 +#: describe.c:3481 msgid "Target type" msgstr "Tipo di arrivo" -#: describe.c:3380 +#: describe.c:3484 msgid "in assignment" msgstr "in assegnazione" -#: describe.c:3382 +#: describe.c:3486 msgid "Implicit?" msgstr "Implicito?" -#: describe.c:3433 +#: describe.c:3537 msgid "List of casts" msgstr "Lista delle conversioni di tipo" -#: describe.c:3459 +#: describe.c:3565 #, c-format -msgid "The server (version %d.%d) does not support collations.\n" -msgstr "Il server (versione %d.%d) non supporta gli ordinamenti.\n" +msgid "The server (version %s) does not support collations.\n" +msgstr "Il server (versione %s) non supporta gli ordinamenti.\n" -#: describe.c:3509 +#: describe.c:3616 msgid "List of collations" msgstr "Lista degli ordinamenti" -#: describe.c:3568 +#: describe.c:3675 msgid "List of schemas" msgstr "Lista degli schemi" -#: describe.c:3591 describe.c:3826 describe.c:3894 describe.c:3962 +#: describe.c:3700 describe.c:3938 describe.c:4009 describe.c:4080 #, c-format -msgid "The server (version %d.%d) does not support full text search.\n" -msgstr "Il server (versione %d.%d) non supporta la ricerca full text.\n" +msgid "The server (version %s) does not support full text search.\n" +msgstr "Il server (versione %s) non supporta la ricerca full text.\n" -#: describe.c:3625 +#: describe.c:3735 msgid "List of text search parsers" msgstr "Lista degli analizzatori di ricerca resto" -#: describe.c:3668 +#: describe.c:3778 #, c-format msgid "Did not find any text search parser named \"%s\".\n" msgstr "Non ho trovato alcun analizzatore di ricerca testo chiamato \"%s\".\n" -#: describe.c:3743 +#: describe.c:3853 msgid "Start parse" msgstr "Inizio analisi" -#: describe.c:3744 +#: describe.c:3854 msgid "Method" msgstr "Metodo" -#: describe.c:3748 +#: describe.c:3858 msgid "Get next token" msgstr "Ottiene il token successivo" -#: describe.c:3750 +#: describe.c:3860 msgid "End parse" msgstr "Fine analisi" -#: describe.c:3752 +#: describe.c:3862 msgid "Get headline" msgstr "Ottiene intestazione" -#: describe.c:3754 +#: describe.c:3864 msgid "Get token types" msgstr "Ottieni i tipi token" -#: describe.c:3764 +#: describe.c:3874 #, c-format msgid "Text search parser \"%s.%s\"" msgstr "Analizzatore di ricerca teso \"%s.%s\"" -#: describe.c:3766 +#: describe.c:3876 #, c-format msgid "Text search parser \"%s\"" msgstr "Analizzatore di ricerca testo \"%s\"" -#: describe.c:3785 +#: describe.c:3895 msgid "Token name" msgstr "Nome token" -#: describe.c:3796 +#: describe.c:3906 #, c-format msgid "Token types for parser \"%s.%s\"" msgstr "Tipi token per l'analizzatore \"%s.%s\"" -#: describe.c:3798 +#: describe.c:3908 #, c-format msgid "Token types for parser \"%s\"" msgstr "Tipi token per l'analizzatore \"%s\"" -#: describe.c:3848 +#: describe.c:3961 msgid "Template" msgstr "Modello" -#: describe.c:3849 +#: describe.c:3962 msgid "Init options" msgstr "Opzioni iniziali:" -#: describe.c:3871 +#: describe.c:3984 msgid "List of text search dictionaries" msgstr "Lista dei dizionari di ricerca testo" -#: describe.c:3911 +#: describe.c:4027 msgid "Init" msgstr "Init" -#: describe.c:3912 +#: describe.c:4028 msgid "Lexize" msgstr "Lexize" -#: describe.c:3939 +#: describe.c:4055 msgid "List of text search templates" msgstr "Lista dei modelli di ricerca testo" -#: describe.c:3996 +#: describe.c:4115 msgid "List of text search configurations" msgstr "Lista delle configurazioni di ricerca testo" -#: describe.c:4040 +#: describe.c:4159 #, c-format msgid "Did not find any text search configuration named \"%s\".\n" msgstr "Non trovata alcuna configurazione di ricerca testo chiamata \"%s\".\n" -#: describe.c:4106 +#: describe.c:4225 msgid "Token" msgstr "Token" -#: describe.c:4107 +#: describe.c:4226 msgid "Dictionaries" msgstr "Dizionari" -#: describe.c:4118 +#: describe.c:4237 #, c-format msgid "Text search configuration \"%s.%s\"" msgstr "Configurazione di ricerca testo \"%s.%s\"" -#: describe.c:4121 +#: describe.c:4240 #, c-format msgid "Text search configuration \"%s\"" msgstr "Configurazione di ricerca testo \"%s\"" -#: describe.c:4125 +#: describe.c:4244 #, c-format msgid "" "\n" @@ -1742,7 +1825,7 @@ msgstr "" "\n" "Analizzatore \"%s.%s\"" -#: describe.c:4128 +#: describe.c:4247 #, c-format msgid "" "\n" @@ -1751,86 +1834,82 @@ msgstr "" "\n" "Analizzatore: \"%s\"" -#: describe.c:4160 +#: describe.c:4281 #, c-format -msgid "The server (version %d.%d) does not support foreign-data wrappers.\n" -msgstr "Il server (versione %d.%d) non supporta i wrapper di dati esterni.\n" - -#: describe.c:4174 -msgid "Handler" -msgstr "Handler" +msgid "The server (version %s) does not support foreign-data wrappers.\n" +msgstr "Il server (versione %s) non supporta i wrapper di dati esterni.\n" -#: describe.c:4217 +#: describe.c:4339 msgid "List of foreign-data wrappers" msgstr "Lista dei wrapper di dati esterni" -#: describe.c:4240 +#: describe.c:4364 #, c-format -msgid "The server (version %d.%d) does not support foreign servers.\n" -msgstr "Il server (versione %d.%d) non supporta server esterni.\n" +msgid "The server (version %s) does not support foreign servers.\n" +msgstr "Il server (versione %s) non supporta server esterni.\n" -#: describe.c:4252 +#: describe.c:4377 msgid "Foreign-data wrapper" msgstr "Wrapper per dati esterni" -#: describe.c:4270 describe.c:4466 +#: describe.c:4395 describe.c:4600 msgid "Version" msgstr "Versione" -#: describe.c:4296 +#: describe.c:4421 msgid "List of foreign servers" msgstr "Lista dei server esterni" -#: describe.c:4319 +#: describe.c:4446 #, c-format -msgid "The server (version %d.%d) does not support user mappings.\n" -msgstr "IL server (versione %d.%d) non supporta la mappatura di utenti.\n" +msgid "The server (version %s) does not support user mappings.\n" +msgstr "Il server (versione %s) non supporta la mappatura di utenti.\n" -#: describe.c:4328 describe.c:4389 +#: describe.c:4456 describe.c:4520 msgid "Server" msgstr "Server" -#: describe.c:4329 +#: describe.c:4457 msgid "User name" msgstr "Nome utente" -#: describe.c:4354 +#: describe.c:4482 msgid "List of user mappings" msgstr "Lista delle mappature degli utenti" -#: describe.c:4377 +#: describe.c:4507 #, c-format -msgid "The server (version %d.%d) does not support foreign tables.\n" -msgstr "Il server (versione %d.%d) non supporta tabelle esterne.\n" +msgid "The server (version %s) does not support foreign tables.\n" +msgstr "Il server (versione %s) non supporta tabelle esterne.\n" -#: describe.c:4429 +#: describe.c:4560 msgid "List of foreign tables" msgstr "Lista delle tabelle esterne" -#: describe.c:4452 describe.c:4506 +#: describe.c:4585 describe.c:4642 #, c-format -msgid "The server (version %d.%d) does not support extensions.\n" -msgstr "Il server (versione %d.%d) non supporta le estensioni.\n" +msgid "The server (version %s) does not support extensions.\n" +msgstr "Il server (versione %s) non supporta le estensioni.\n" -#: describe.c:4483 +#: describe.c:4617 msgid "List of installed extensions" msgstr "Lista delle estensioni installate" -#: describe.c:4533 +#: describe.c:4670 #, c-format msgid "Did not find any extension named \"%s\".\n" msgstr "Non ho trovato alcuna estensione nominata \"%s\".\n" -#: describe.c:4536 +#: describe.c:4673 #, c-format msgid "Did not find any extensions.\n" msgstr "Non ho trovato alcuna estensione.\n" -#: describe.c:4580 +#: describe.c:4717 msgid "Object Description" msgstr "Descrizione Oggetto" -#: describe.c:4589 +#: describe.c:4726 #, c-format msgid "Objects in extension \"%s\"" msgstr "Oggetti nell'estensione \"%s\"" @@ -1849,7 +1928,7 @@ msgstr "" "psql è il terminale interattivo per PostgreSQL.\n" "\n" -#: help.c:75 help.c:332 help.c:366 help.c:393 +#: help.c:75 help.c:333 help.c:367 help.c:394 #, c-format msgid "Usage:\n" msgstr "Utilizzo:\n" @@ -2335,221 +2414,226 @@ msgstr " \\da[S] [MODELLO] elenca le funzioni di aggregazione\n" #: help.c:218 #, c-format +msgid " \\dA[+] [PATTERN] list access methods\n" +msgstr " \\dA[+] [MODELLO] elenca i metodi di accesso\n" + +#: help.c:219 +#, c-format msgid " \\db[+] [PATTERN] list tablespaces\n" msgstr " \\db[+] [MODELLO] elenca i tablespace\n" -#: help.c:219 +#: help.c:220 #, c-format msgid " \\dc[S+] [PATTERN] list conversions\n" msgstr " \\dc[S+] [MODELLO] elenca le conversioni di codifica\n" -#: help.c:220 +#: help.c:221 #, c-format msgid " \\dC[+] [PATTERN] list casts\n" msgstr " \\dC[+] [MODELLO] elenca le conversioni di tipo\n" -#: help.c:221 +#: help.c:222 #, c-format msgid " \\dd[S] [PATTERN] show object descriptions not displayed elsewhere\n" msgstr " \\dd[S] [MODELLO] mostra la descrizione di oggetti non elencati altrove\n" -#: help.c:222 +#: help.c:223 #, c-format msgid " \\ddp [PATTERN] list default privileges\n" msgstr " \\ddp [MODELLO] elenca i privilegi predefiniti\n" -#: help.c:223 +#: help.c:224 #, c-format msgid " \\dD[S+] [PATTERN] list domains\n" msgstr " \\dD[S+] [MODELLO] elenca i domini\n" -#: help.c:224 +#: help.c:225 #, c-format msgid " \\det[+] [PATTERN] list foreign tables\n" msgstr " \\det[+] [MODELLO] elenca le tabelle esterne\n" -#: help.c:225 +#: help.c:226 #, c-format msgid " \\des[+] [PATTERN] list foreign servers\n" msgstr " \\des[+] [MODELLO] elenca i server esterni\n" -#: help.c:226 +#: help.c:227 #, c-format msgid " \\deu[+] [PATTERN] list user mappings\n" msgstr " \\deu[+] [MODELLO] elenca le mappature degli utenti\n" -#: help.c:227 +#: help.c:228 #, c-format msgid " \\dew[+] [PATTERN] list foreign-data wrappers\n" msgstr " \\dew[+] [MODELLO] elenca i wrapper di dati esterni\n" -#: help.c:228 +#: help.c:229 #, c-format msgid " \\df[antw][S+] [PATRN] list [only agg/normal/trigger/window] functions\n" msgstr " \\df[antw][S+] [MOD] elenca le funzioni [solo aggr/normali/trigger/finestra]\n" -#: help.c:229 +#: help.c:230 #, c-format msgid " \\dF[+] [PATTERN] list text search configurations\n" msgstr " \\dF[+] [MODELLO] elenca le configurazioni di ricerca testo\n" -#: help.c:230 +#: help.c:231 #, c-format msgid " \\dFd[+] [PATTERN] list text search dictionaries\n" msgstr " \\dFd[+] [MODELLO] elenca i dizionari di ricerca testo\n" -#: help.c:231 +#: help.c:232 #, c-format msgid " \\dFp[+] [PATTERN] list text search parsers\n" msgstr " \\dFp[+] [MODELLO] elenca gli analizzatori di ricerca testo\n" -#: help.c:232 +#: help.c:233 #, c-format msgid " \\dFt[+] [PATTERN] list text search templates\n" msgstr " \\dFt[+] [MODELLO] elenca i modelli di ricerca di testo\n" -#: help.c:233 +#: help.c:234 #, c-format msgid " \\dg[S+] [PATTERN] list roles\n" msgstr " \\dg[S+] [MODELLO] elenca i ruoli\n" -#: help.c:234 +#: help.c:235 #, c-format msgid " \\di[S+] [PATTERN] list indexes\n" msgstr " \\di[S+] [MODELLO] elenca gli indici\n" -#: help.c:235 +#: help.c:236 #, c-format msgid " \\dl list large objects, same as \\lo_list\n" msgstr " \\dl elenca i large object, stesso risultato di \\lo_list\n" -#: help.c:236 +#: help.c:237 #, c-format msgid " \\dL[S+] [PATTERN] list procedural languages\n" msgstr " \\dL[S+] [MODELLO] elenca i linguaggi procedurali\n" -#: help.c:237 +#: help.c:238 #, c-format msgid " \\dm[S+] [PATTERN] list materialized views\n" msgstr " \\dm[S+] [PATTERN] elenca le viste materializzate\n" -#: help.c:238 +#: help.c:239 #, c-format msgid " \\dn[S+] [PATTERN] list schemas\n" msgstr " \\dn[S+] [MODELLO] elenca gli schemi\n" -#: help.c:239 +#: help.c:240 #, c-format msgid " \\do[S] [PATTERN] list operators\n" msgstr " \\do[S] [MODELLO] elenca gli operatori\n" -#: help.c:240 +#: help.c:241 #, c-format msgid " \\dO[S+] [PATTERN] list collations\n" msgstr " \\dO[S+] [MODELLO] elenca gli ordinamenti\n" -#: help.c:241 +#: help.c:242 #, c-format msgid " \\dp [PATTERN] list table, view, and sequence access privileges\n" msgstr "" " \\dp [MODELLO] elenca i permessi di accesso alla tabella, vista\n" " o sequenza\n" -#: help.c:242 +#: help.c:243 #, c-format msgid " \\drds [PATRN1 [PATRN2]] list per-database role settings\n" msgstr " \\drds [MOD1 [MOD2]] elenca le impostazioni dei ruoli per database\n" -#: help.c:243 +#: help.c:244 #, c-format msgid " \\ds[S+] [PATTERN] list sequences\n" msgstr " \\ds[S+] [MODELLO] elenca le sequenze\n" -#: help.c:244 +#: help.c:245 #, c-format msgid " \\dt[S+] [PATTERN] list tables\n" msgstr " \\dt[S+] [MODELLO] elenca le tabelle\n" -#: help.c:245 +#: help.c:246 #, c-format msgid " \\dT[S+] [PATTERN] list data types\n" msgstr " \\dT[S+] [MODELLO] elenca i tipi di dato\n" -#: help.c:246 +#: help.c:247 #, c-format msgid " \\du[S+] [PATTERN] list roles\n" msgstr " \\du[S+] [MODELLO] elenca i ruoli\n" -#: help.c:247 +#: help.c:248 #, c-format msgid " \\dv[S+] [PATTERN] list views\n" msgstr " \\dv[S+] [MODELLO] elenca le viste\n" -#: help.c:248 +#: help.c:249 #, c-format msgid " \\dE[S+] [PATTERN] list foreign tables\n" msgstr " \\dE[S+] [MODELLO] elenca le tabelle esterne\n" -#: help.c:249 +#: help.c:250 #, c-format msgid " \\dx[+] [PATTERN] list extensions\n" msgstr " \\dx[+] [MODELLO] elenca le estensioni\n" -#: help.c:250 +#: help.c:251 #, c-format msgid " \\dy [PATTERN] list event triggers\n" msgstr " \\dy [PATTERN] elenca i trigger di evento\n" -#: help.c:251 +#: help.c:252 #, c-format msgid " \\l[+] [PATTERN] list databases\n" msgstr " \\l[+] [PATTERN] elenca i database\n" -#: help.c:252 +#: help.c:253 #, c-format msgid " \\sf[+] FUNCNAME show a function's definition\n" msgstr " \\sf[+] FUNZIONE mostra la definizione di una funzione\n" -#: help.c:253 +#: help.c:254 #, c-format msgid " \\sv[+] VIEWNAME show a view's definition\n" msgstr " \\sv[+] VISTA mostra la definizione di una vista\n" -#: help.c:254 +#: help.c:255 #, c-format msgid " \\z [PATTERN] same as \\dp\n" msgstr " \\z [MODELLO] uguale a \\dp\n" -#: help.c:257 +#: help.c:258 #, c-format msgid "Formatting\n" msgstr "Formattazione\n" -#: help.c:258 +#: help.c:259 #, c-format msgid " \\a toggle between unaligned and aligned output mode\n" msgstr " \\a alterna tra modalità di output allineata e disallineata\n" -#: help.c:259 +#: help.c:260 #, c-format msgid " \\C [STRING] set table title, or unset if none\n" msgstr "" " \\C [STRINGA] imposta nome tabella oppure elimina se la stringa\n" " non è specificata\n" -#: help.c:260 +#: help.c:261 #, c-format msgid " \\f [STRING] show or set field separator for unaligned query output\n" msgstr "" " \\f [STRINGA] mostra o imposta il separatore di campo per l'output\n" " query disallineato\n" -#: help.c:261 +#: help.c:262 #, c-format msgid " \\H toggle HTML output mode (currently %s)\n" msgstr " \\H cambia modalità HTML (attualmente %s)\n" -#: help.c:263 +#: help.c:264 #, c-format msgid "" " \\pset [NAME [VALUE]] set table output option\n" @@ -2562,31 +2646,31 @@ msgstr "" " numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager|\n" " unicode_border_linestyle|unicode_column_linestyle|unicode_header_linestyle})\n" -#: help.c:267 +#: help.c:268 #, c-format msgid " \\t [on|off] show only rows (currently %s)\n" msgstr " \\t [on|off] mostra solo le righe (attualmente %s)\n" -#: help.c:269 +#: help.c:270 #, c-format msgid " \\T [STRING] set HTML tag attributes, or unset if none\n" msgstr "" " \\T [STRINGA] imposta gli attributi HTML di
, se non\n" " specificato allora annullali\n" -#: help.c:270 +#: help.c:271 #, c-format msgid " \\x [on|off|auto] toggle expanded output (currently %s)\n" msgstr "" " \\x [on|off|auto] cambia modalità output espansa\n" " (attualmente %s)\n" -#: help.c:274 +#: help.c:275 #, c-format msgid "Connection\n" msgstr "Connessione\n" -#: help.c:276 +#: help.c:277 #, c-format msgid "" " \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" @@ -2595,7 +2679,7 @@ msgstr "" " \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" " connetti ad un nuovo database (attualmente \"%s\")\n" -#: help.c:280 +#: help.c:281 #, c-format msgid "" " \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" @@ -2604,78 +2688,78 @@ msgstr "" " \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" " connetti ad un nuovo database (nessuna connessione attiva)\n" -#: help.c:282 +#: help.c:283 #, c-format msgid " \\encoding [ENCODING] show or set client encoding\n" msgstr " \\encoding [CODIFICA] mostra o imposta la codifica del client\n" -#: help.c:283 +#: help.c:284 #, c-format msgid " \\password [USERNAME] securely change the password for a user\n" msgstr " \\password [UTENTE] cambia la password per un utente in sicurezza\n" -#: help.c:284 +#: help.c:285 #, c-format msgid " \\conninfo display information about current connection\n" msgstr " \\conninfo mostra le informazioni su la connessione corrente\n" -#: help.c:287 +#: help.c:288 #, c-format msgid "Operating System\n" msgstr "Sistema operativo\n" -#: help.c:288 +#: help.c:289 #, c-format msgid " \\cd [DIR] change the current working directory\n" msgstr " \\cd [DIRECTORY] cambia la directory di lavoro\n" -#: help.c:289 +#: help.c:290 #, c-format msgid " \\setenv NAME [VALUE] set or unset environment variable\n" msgstr " \\setenv NOME [VALORE] imposta o elimina una variabile d'ambiente\n" -#: help.c:290 +#: help.c:291 #, c-format msgid " \\timing [on|off] toggle timing of commands (currently %s)\n" msgstr "" " \\timing [on|off] imposta cronometro dei comandi\n" " (attualmente %s)\n" -#: help.c:292 +#: help.c:293 #, c-format msgid " \\! [COMMAND] execute command in shell or start interactive shell\n" msgstr "" " \\! [COMANDO] esegui un comando in una shell oppure avvia una shell\n" " interattiva\n" -#: help.c:295 +#: help.c:296 #, c-format msgid "Variables\n" msgstr "Variabili\n" -#: help.c:296 +#: help.c:297 #, c-format msgid " \\prompt [TEXT] NAME prompt user to set internal variable\n" msgstr " \\prompt [TESTO] NOME richiedi all'utente di impostare una variabile interna\n" -#: help.c:297 +#: help.c:298 #, c-format msgid " \\set [NAME [VALUE]] set internal variable, or list all if no parameters\n" msgstr "" " \\set [NOME [VALORE]] imposta una variabile interna, oppure mostrale tutte\n" " se non sono specificati parametri\n" -#: help.c:298 +#: help.c:299 #, c-format msgid " \\unset NAME unset (delete) internal variable\n" msgstr " \\unset NOME cancella una variabile interna\n" -#: help.c:301 +#: help.c:302 #, c-format msgid "Large Objects\n" msgstr "Large Object\n" -#: help.c:302 +#: help.c:303 #, c-format msgid "" " \\lo_export LOBOID FILE\n" @@ -2688,7 +2772,7 @@ msgstr "" " \\lo_list\n" " \\lo_unlink LOBOID operazioni sui large object\n" -#: help.c:329 +#: help.c:330 #, c-format msgid "" "List of specially treated variables\n" @@ -2697,12 +2781,12 @@ msgstr "" "Lista delle variabili speciali\n" "\n" -#: help.c:331 +#: help.c:332 #, c-format msgid "psql variables:\n" msgstr "variabili psql:\n" -#: help.c:333 +#: help.c:334 #, c-format msgid "" " psql --set=NAME=VALUE\n" @@ -2713,12 +2797,12 @@ msgstr "" " oppure \\set NOME VALORE dentro psql\n" "\n" -#: help.c:335 +#: help.c:336 #, c-format msgid " AUTOCOMMIT if set, successful SQL commands are automatically committed\n" msgstr " AUTOCOMMIT se impostato, i comandi SQL riusciti sono salvati automaticamente\n" -#: help.c:336 +#: help.c:337 #, c-format msgid "" " COMP_KEYWORD_CASE determines the case used to complete SQL key words\n" @@ -2727,12 +2811,12 @@ msgstr "" " COMP_KEYWORD_CASE determina il caso usato per completare le parole chiave SQL\n" " [lower, upper, preserve-lower, preserve-upper]\n" -#: help.c:338 +#: help.c:339 #, c-format msgid " DBNAME the currently connected database name\n" msgstr " DBNAME il nome del database attualmente connesso\n" -#: help.c:339 +#: help.c:340 #, c-format msgid "" " ECHO controls what input is written to standard output\n" @@ -2741,7 +2825,7 @@ msgstr "" " ECHO controlla quale input è scritto su stardard output\n" " [all, errors, none, queries]\n" -#: help.c:341 +#: help.c:342 #, c-format msgid "" " ECHO_HIDDEN if set, display internal queries executed by backslash commands;\n" @@ -2750,12 +2834,12 @@ msgstr "" " ECHO_HIDDEN se impostato, mostra le query interne dei comandi backslash;\n" " se impostato a \"noexec\", mostrale solo senza eseguirle\n" -#: help.c:343 +#: help.c:344 #, c-format msgid " ENCODING current client character set encoding\n" msgstr " ENCODING codifica del set di caratteri del client corrente\n" -#: help.c:344 +#: help.c:345 #, c-format msgid "" " FETCH_COUNT the number of result rows to fetch and display at a time\n" @@ -2764,97 +2848,97 @@ msgstr "" " FETCH_COUNT il numero di righe del risultato da leggere e mostrare pr volta\n" " (default: 0=tutte)\n" -#: help.c:346 +#: help.c:347 #, c-format msgid " HISTCONTROL controls command history [ignorespace, ignoredups, ignoreboth]\n" msgstr " HISTCONTROL controlla la storia dei comandi [ignorespace, ignoredups, ignoreboth]\n" -#: help.c:347 +#: help.c:348 #, c-format msgid " HISTFILE file name used to store the command history\n" msgstr " HISTFILE nome del file usato per memorizzare la storia dei comandi\n" -#: help.c:348 +#: help.c:349 #, c-format msgid " HISTSIZE the number of commands to store in the command history\n" msgstr " HISTSIZE il numero di comandi da memorizzare nella storia dei comandi\n" -#: help.c:349 +#: help.c:350 #, c-format msgid " HOST the currently connected database server host\n" msgstr " HOST l'host del server del database attualmente connesso\n" -#: help.c:350 +#: help.c:351 #, c-format msgid " IGNOREEOF if unset, sending an EOF to interactive session terminates application\n" msgstr " IGNOREEOF se non impostato, invare un EOF alla sessione interattiva termina l'applicazione\n" -#: help.c:351 +#: help.c:352 #, c-format msgid " LASTOID value of the last affected OID\n" msgstr " LASTOID valore dell'ultimo OID interessato\n" -#: help.c:352 +#: help.c:353 #, c-format msgid " ON_ERROR_ROLLBACK if set, an error doesn't stop a transaction (uses implicit savepoints)\n" msgstr " ON_ERROR_ROLLBACK se impostato, un errore non termina una transazione (usa punti di salvataggio impliciti)\n" -#: help.c:353 +#: help.c:354 #, c-format msgid " ON_ERROR_STOP stop batch execution after error\n" msgstr " ON_ERROR_STOP termina l'esecuzione batch dopo un errore\n" -#: help.c:354 +#: help.c:355 #, c-format msgid " PORT server port of the current connection\n" msgstr " PORT porta del server attualmente connesso\n" -#: help.c:355 +#: help.c:356 #, c-format msgid " PROMPT1 specifies the standard psql prompt\n" msgstr " PROMPT1 specifica il prompt psql standard\n" -#: help.c:356 +#: help.c:357 #, c-format msgid " PROMPT2 specifies the prompt used when a statement continues from a previous line\n" msgstr " PROMPT2 specifica il prompt usato quando un'istruzione continua da una riga precedente\n" -#: help.c:357 +#: help.c:358 #, c-format msgid " PROMPT3 specifies the prompt used during COPY ... FROM STDIN\n" msgstr " PROMPT3 specifica il prompt usato in COPY ... FROM STDIN\n" -#: help.c:358 +#: help.c:359 #, c-format msgid " QUIET run quietly (same as -q option)\n" msgstr " QUIET esegui silenziosamente (come con l'opzione -q)\n" -#: help.c:359 +#: help.c:360 #, c-format msgid " SHOW_CONTEXT controls display of message context fields [never, errors, always]\n" msgstr " SHOW_CONTEXT controlla la visualizzazione dei campi di contesto dei messaggi [never, errors, always]\n" -#: help.c:360 +#: help.c:361 #, c-format msgid " SINGLELINE end of line terminates SQL command mode (same as -S option)\n" msgstr " SINGLELINE la fine riga termina i comandi SQL (come con l'opzione -S)\n" -#: help.c:361 +#: help.c:362 #, c-format msgid " SINGLESTEP single-step mode (same as -s option)\n" msgstr " SINGLESTEP modalità passo singolo (come con l'opzione -s)\n" -#: help.c:362 +#: help.c:363 #, c-format msgid " USER the currently connected database user\n" msgstr " USER l'utente database attualmente connesso\n" -#: help.c:363 +#: help.c:364 #, c-format msgid " VERBOSITY controls verbosity of error reports [default, verbose, terse]\n" msgstr " VERBOSITY controlla la loquacità della visualizzazione degli errori [default, verbose, terse]\n" -#: help.c:365 +#: help.c:366 #, c-format msgid "" "\n" @@ -2863,7 +2947,7 @@ msgstr "" "\n" "Impostazioni di visualizzazione:\n" -#: help.c:367 +#: help.c:368 #, c-format msgid "" " psql --pset=NAME[=VALUE]\n" @@ -2874,36 +2958,31 @@ msgstr "" " oppure \\pset NOME [VALORE] dentro psql\n" "\n" -#: help.c:369 +#: help.c:370 #, c-format msgid " border border style (number)\n" msgstr " border stile bordo (numero)\n" -#: help.c:370 +#: help.c:371 #, c-format msgid " columns target width for the wrapped format\n" msgstr " columns larghezza destinazione per il formato wrapped\n" -#: help.c:371 +#: help.c:372 #, c-format msgid " expanded (or x) expanded output [on, off, auto]\n" msgstr " expanded (o x) output espanso [on, off, auto]\n" -#: help.c:372 +#: help.c:373 #, c-format msgid " fieldsep field separator for unaligned output (default \"%s\")\n" msgstr " fieldsep separatore di campo per l'output non allineato (default \"%s\")\n" -#: help.c:373 +#: help.c:374 #, c-format msgid " fieldsep_zero set field separator for unaligned output to zero byte\n" msgstr " fieldsep_zero imposta il separatore di campo per l'output non allineato al byte zero\n" -#: help.c:374 -#, c-format -msgid " format set output format [unaligned, aligned, wrapped, html, asciidoc, ...]\n" -msgstr " format imposta il formato di output [unaligned, aligned, wrapped, html, asciidoc, ...]\n" - #: help.c:375 #, c-format msgid " footer enable or disable display of the table footer [on, off]\n" @@ -2911,15 +2990,20 @@ msgstr " footer abilita o disabilita la visualizzazione del piè di #: help.c:376 #, c-format +msgid " format set output format [unaligned, aligned, wrapped, html, asciidoc, ...]\n" +msgstr " format imposta il formato di output [unaligned, aligned, wrapped, html, asciidoc, ...]\n" + +#: help.c:377 +#, c-format msgid " linestyle set the border line drawing style [ascii, old-ascii, unicode]\n" msgstr " linestyle imposta lo stile di disegno delle righe dei bordi [ascii, old-ascii, unicode]\n" -#: help.c:377 +#: help.c:378 #, c-format msgid " null set the string to be printed in place of a null value\n" msgstr " null imposta la stringa da visualizzare al posto dei valori null\n" -#: help.c:378 +#: help.c:379 #, c-format msgid "" " numericlocale enable or disable display of a locale-specific character to separate\n" @@ -2928,22 +3012,22 @@ msgstr "" " numericlocale abilita o disabilita i caratteri specifici per il locale per separare\n" " i gruppi di cifre [on, off]\n" -#: help.c:380 +#: help.c:381 #, c-format msgid " pager control when an external pager is used [yes, no, always]\n" msgstr " pager controlla quando usare la paginazione esterna [yes, no, always]\n" -#: help.c:381 +#: help.c:382 #, c-format msgid " recordsep record (line) separator for unaligned output\n" msgstr " recordsep separatore di record (riga) per l'output non allineato\n" -#: help.c:382 +#: help.c:383 #, c-format msgid " recordsep_zero set record separator for unaligned output to zero byte\n" msgstr " recordsep_zero imposta il separatore di campo per l'output non allineato al byte zero\n" -#: help.c:383 +#: help.c:384 #, c-format msgid "" " tableattr (or T) specify attributes for table tag in html format or proportional\n" @@ -2953,17 +3037,17 @@ msgstr "" " larghezza colonna proporzionale dei dati allineati a sinistra\n" " in formato latex-longtable\n" -#: help.c:385 +#: help.c:386 #, c-format msgid " title set the table title for any subsequently printed tables\n" msgstr " title imposta il titolo della tabella per ogni tabella stampata in seguto\n" -#: help.c:386 +#: help.c:387 #, c-format msgid " tuples_only if set, only actual table data is shown\n" msgstr " tuples_only se impostato, mostra solo i dati della tabella\n" -#: help.c:387 +#: help.c:388 #, c-format msgid "" " unicode_border_linestyle\n" @@ -2976,7 +3060,7 @@ msgstr "" " unicode_header_linestyle\n" " imposta lo stile di disegno delle righe Unicode [single, double]\n" -#: help.c:392 +#: help.c:393 #, c-format msgid "" "\n" @@ -2985,7 +3069,7 @@ msgstr "" "\n" "Variabili d'ambiente:\n" -#: help.c:396 +#: help.c:397 #, c-format msgid "" " NAME=VALUE [NAME=VALUE] psql ...\n" @@ -2996,7 +3080,7 @@ msgstr "" " oppure \\setenv NOME [VALORE] dentro psql\n" "\n" -#: help.c:398 +#: help.c:399 #, c-format msgid "" " set NAME=VALUE\n" @@ -3009,52 +3093,52 @@ msgstr "" " oppure \\setenv NOME [VALORE] dentro psql\n" "\n" -#: help.c:401 +#: help.c:402 #, c-format msgid " COLUMNS number of columns for wrapped format\n" msgstr " COLUMNS numero di colonne per il formato wrapped\n" -#: help.c:402 +#: help.c:403 #, c-format msgid " PAGER name of external pager program\n" msgstr " PAGER nome del programma di paginazione esterno\n" -#: help.c:403 +#: help.c:404 #, c-format msgid " PGAPPNAME same as the application_name connection parameter\n" msgstr " PGAPPNAME come il parametro di connessione application_name\n" -#: help.c:404 +#: help.c:405 #, c-format msgid " PGDATABASE same as the dbname connection parameter\n" msgstr " PGDATABASE come il parametro di connessione dbname\n" -#: help.c:405 +#: help.c:406 #, c-format msgid " PGHOST same as the host connection parameter\n" msgstr " PGHOST come il parametro di connessione host\n" -#: help.c:406 +#: help.c:407 #, c-format msgid " PGPORT same as the port connection parameter\n" msgstr " PGPORT come il parametro di connessione port\n" -#: help.c:407 +#: help.c:408 #, c-format msgid " PGUSER same as the user connection parameter\n" msgstr " PGUSER come il parametro di connessione user\n" -#: help.c:408 +#: help.c:409 #, c-format msgid " PGPASSWORD connection password (not recommended)\n" msgstr " PGPASSWORD password di connessione (uso non raccomandato)\n" -#: help.c:409 +#: help.c:410 #, c-format msgid " PGPASSFILE password file name\n" msgstr " PGPASSFILE nome del file delle password\n" -#: help.c:410 +#: help.c:411 #, c-format msgid "" " PSQL_EDITOR, EDITOR, VISUAL\n" @@ -3063,7 +3147,7 @@ msgstr "" " PSQL_EDITOR, EDITOR, VISUAL\n" " editor usato dai comandi \\e, \\ef, \\ev\n" -#: help.c:412 +#: help.c:413 #, c-format msgid "" " PSQL_EDITOR_LINENUMBER_ARG\n" @@ -3072,31 +3156,31 @@ msgstr "" " PSQL_EDITOR_LINENUMBER_ARG\n" " come specificare un numero di riga quando si invoca l'editor\n" -#: help.c:414 +#: help.c:415 #, c-format msgid " PSQL_HISTORY alternative location for the command history file\n" msgstr " PSQL_HISTORY posizione alternativa del file della storia dei comandi\n" -#: help.c:415 +#: help.c:416 #, c-format msgid " PSQLRC alternative location for the user's .psqlrc file\n" msgstr " PSQLRC posizione alternativa del file .psqlrc dell'utente\n" -#: help.c:416 +#: help.c:417 #, c-format msgid " SHELL shell used by the \\! command\n" msgstr " SHELL shell usata dal comando \\!\n" -#: help.c:417 +#: help.c:418 #, c-format msgid " TMPDIR directory for temporary files\n" msgstr " TMPDIR directory per i file temporanei\n" -#: help.c:460 +#: help.c:461 msgid "Available help:\n" msgstr "Aiuti disponibili:\n" -#: help.c:544 +#: help.c:545 #, c-format msgid "" "Command: %s\n" @@ -3111,7 +3195,7 @@ msgstr "" "%s\n" "\n" -#: help.c:560 +#: help.c:561 #, c-format msgid "" "No help available for \"%s\".\n" @@ -3190,12 +3274,12 @@ msgstr "" " \\g o termina con punto e virgola per eseguire la query\n" " \\q per uscire\n" -#: psqlscanslash.l:611 +#: psqlscanslash.l:584 #, c-format msgid "unterminated quoted string\n" msgstr "stringa tra virgolette non terminata\n" -#: psqlscanslash.l:719 +#: psqlscanslash.l:738 #, c-format msgid "%s: out of memory\n" msgstr "%s: memoria esaurita\n" @@ -3206,12 +3290,12 @@ msgstr "%s: memoria esaurita\n" #: sql_help.c:126 sql_help.c:128 sql_help.c:221 sql_help.c:223 sql_help.c:224 #: sql_help.c:226 sql_help.c:228 sql_help.c:231 sql_help.c:233 sql_help.c:235 #: sql_help.c:237 sql_help.c:249 sql_help.c:250 sql_help.c:251 sql_help.c:253 -#: sql_help.c:299 sql_help.c:301 sql_help.c:303 sql_help.c:305 sql_help.c:365 -#: sql_help.c:370 sql_help.c:372 sql_help.c:415 sql_help.c:417 sql_help.c:420 -#: sql_help.c:422 sql_help.c:489 sql_help.c:494 sql_help.c:499 sql_help.c:504 -#: sql_help.c:509 sql_help.c:558 sql_help.c:560 sql_help.c:562 sql_help.c:564 -#: sql_help.c:567 sql_help.c:569 sql_help.c:580 sql_help.c:582 sql_help.c:624 -#: sql_help.c:626 sql_help.c:628 sql_help.c:631 sql_help.c:633 sql_help.c:635 +#: sql_help.c:300 sql_help.c:302 sql_help.c:304 sql_help.c:306 sql_help.c:367 +#: sql_help.c:372 sql_help.c:374 sql_help.c:417 sql_help.c:419 sql_help.c:422 +#: sql_help.c:424 sql_help.c:491 sql_help.c:496 sql_help.c:501 sql_help.c:506 +#: sql_help.c:511 sql_help.c:560 sql_help.c:562 sql_help.c:564 sql_help.c:566 +#: sql_help.c:569 sql_help.c:571 sql_help.c:582 sql_help.c:584 sql_help.c:625 +#: sql_help.c:627 sql_help.c:629 sql_help.c:632 sql_help.c:634 sql_help.c:636 #: sql_help.c:669 sql_help.c:673 sql_help.c:677 sql_help.c:696 sql_help.c:699 #: sql_help.c:702 sql_help.c:731 sql_help.c:743 sql_help.c:751 sql_help.c:754 #: sql_help.c:757 sql_help.c:772 sql_help.c:775 sql_help.c:819 sql_help.c:842 @@ -3227,38 +3311,38 @@ msgstr "%s: memoria esaurita\n" #: sql_help.c:1190 sql_help.c:1193 sql_help.c:1195 sql_help.c:1197 #: sql_help.c:1247 sql_help.c:1285 sql_help.c:1288 sql_help.c:1290 #: sql_help.c:1292 sql_help.c:1294 sql_help.c:1296 sql_help.c:1299 -#: sql_help.c:1339 sql_help.c:1542 sql_help.c:1613 sql_help.c:1633 -#: sql_help.c:1650 sql_help.c:1705 sql_help.c:1709 sql_help.c:1719 -#: sql_help.c:1739 sql_help.c:1764 sql_help.c:1782 sql_help.c:1811 -#: sql_help.c:1886 sql_help.c:1928 sql_help.c:1950 sql_help.c:1970 -#: sql_help.c:1971 sql_help.c:2006 sql_help.c:2026 sql_help.c:2048 -#: sql_help.c:2061 sql_help.c:2092 sql_help.c:2117 sql_help.c:2161 -#: sql_help.c:2347 sql_help.c:2360 sql_help.c:2377 sql_help.c:2393 -#: sql_help.c:2432 sql_help.c:2483 sql_help.c:2487 sql_help.c:2489 -#: sql_help.c:2495 sql_help.c:2513 sql_help.c:2540 sql_help.c:2575 -#: sql_help.c:2587 sql_help.c:2596 sql_help.c:2640 sql_help.c:2654 -#: sql_help.c:2682 sql_help.c:2690 sql_help.c:2698 sql_help.c:2706 -#: sql_help.c:2714 sql_help.c:2722 sql_help.c:2730 sql_help.c:2738 -#: sql_help.c:2747 sql_help.c:2758 sql_help.c:2766 sql_help.c:2774 -#: sql_help.c:2782 sql_help.c:2790 sql_help.c:2800 sql_help.c:2809 -#: sql_help.c:2818 sql_help.c:2826 sql_help.c:2835 sql_help.c:2843 -#: sql_help.c:2852 sql_help.c:2860 sql_help.c:2868 sql_help.c:2876 -#: sql_help.c:2884 sql_help.c:2892 sql_help.c:2900 sql_help.c:2908 -#: sql_help.c:2916 sql_help.c:2933 sql_help.c:2942 sql_help.c:2950 -#: sql_help.c:2967 sql_help.c:2982 sql_help.c:3247 sql_help.c:3298 -#: sql_help.c:3327 sql_help.c:3335 sql_help.c:3754 sql_help.c:3802 -#: sql_help.c:3943 +#: sql_help.c:1339 sql_help.c:1544 sql_help.c:1608 sql_help.c:1627 +#: sql_help.c:1640 sql_help.c:1694 sql_help.c:1698 sql_help.c:1708 +#: sql_help.c:1728 sql_help.c:1753 sql_help.c:1771 sql_help.c:1800 +#: sql_help.c:1875 sql_help.c:1917 sql_help.c:1939 sql_help.c:1959 +#: sql_help.c:1960 sql_help.c:1995 sql_help.c:2015 sql_help.c:2037 +#: sql_help.c:2050 sql_help.c:2081 sql_help.c:2106 sql_help.c:2150 +#: sql_help.c:2336 sql_help.c:2349 sql_help.c:2366 sql_help.c:2382 +#: sql_help.c:2421 sql_help.c:2472 sql_help.c:2476 sql_help.c:2478 +#: sql_help.c:2484 sql_help.c:2502 sql_help.c:2529 sql_help.c:2564 +#: sql_help.c:2576 sql_help.c:2585 sql_help.c:2629 sql_help.c:2643 +#: sql_help.c:2671 sql_help.c:2679 sql_help.c:2687 sql_help.c:2695 +#: sql_help.c:2703 sql_help.c:2711 sql_help.c:2719 sql_help.c:2727 +#: sql_help.c:2736 sql_help.c:2747 sql_help.c:2755 sql_help.c:2763 +#: sql_help.c:2771 sql_help.c:2779 sql_help.c:2789 sql_help.c:2798 +#: sql_help.c:2807 sql_help.c:2815 sql_help.c:2824 sql_help.c:2832 +#: sql_help.c:2841 sql_help.c:2849 sql_help.c:2857 sql_help.c:2865 +#: sql_help.c:2873 sql_help.c:2881 sql_help.c:2889 sql_help.c:2897 +#: sql_help.c:2905 sql_help.c:2922 sql_help.c:2931 sql_help.c:2939 +#: sql_help.c:2956 sql_help.c:2971 sql_help.c:3236 sql_help.c:3287 +#: sql_help.c:3316 sql_help.c:3324 sql_help.c:3743 sql_help.c:3791 +#: sql_help.c:3932 msgid "name" msgstr "nome" -#: sql_help.c:37 sql_help.c:40 sql_help.c:43 sql_help.c:309 sql_help.c:1403 -#: sql_help.c:2655 sql_help.c:3550 +#: sql_help.c:37 sql_help.c:40 sql_help.c:43 sql_help.c:311 sql_help.c:1405 +#: sql_help.c:2644 sql_help.c:3539 msgid "aggregate_signature" msgstr "signature_aggregato" #: sql_help.c:38 sql_help.c:65 sql_help.c:80 sql_help.c:116 sql_help.c:236 -#: sql_help.c:254 sql_help.c:373 sql_help.c:421 sql_help.c:498 sql_help.c:544 -#: sql_help.c:559 sql_help.c:581 sql_help.c:632 sql_help.c:698 sql_help.c:753 +#: sql_help.c:254 sql_help.c:375 sql_help.c:423 sql_help.c:500 sql_help.c:546 +#: sql_help.c:561 sql_help.c:583 sql_help.c:633 sql_help.c:698 sql_help.c:753 #: sql_help.c:774 sql_help.c:820 sql_help.c:844 sql_help.c:854 sql_help.c:884 #: sql_help.c:904 sql_help.c:996 sql_help.c:1061 sql_help.c:1104 #: sql_help.c:1125 sql_help.c:1139 sql_help.c:1151 sql_help.c:1164 @@ -3267,103 +3351,101 @@ msgid "new_name" msgstr "nuovo_nome" #: sql_help.c:41 sql_help.c:67 sql_help.c:82 sql_help.c:118 sql_help.c:234 -#: sql_help.c:252 sql_help.c:371 sql_help.c:457 sql_help.c:503 sql_help.c:583 -#: sql_help.c:592 sql_help.c:651 sql_help.c:672 sql_help.c:701 sql_help.c:756 -#: sql_help.c:856 sql_help.c:882 sql_help.c:902 sql_help.c:1045 -#: sql_help.c:1063 sql_help.c:1106 sql_help.c:1127 sql_help.c:1189 -#: sql_help.c:1291 sql_help.c:2333 +#: sql_help.c:252 sql_help.c:373 sql_help.c:459 sql_help.c:505 sql_help.c:585 +#: sql_help.c:594 sql_help.c:652 sql_help.c:672 sql_help.c:701 sql_help.c:756 +#: sql_help.c:856 sql_help.c:882 sql_help.c:902 sql_help.c:1045 sql_help.c:1063 +#: sql_help.c:1106 sql_help.c:1127 sql_help.c:1189 sql_help.c:1291 +#: sql_help.c:2322 msgid "new_owner" msgstr "nuovo_proprietario" -#: sql_help.c:44 sql_help.c:69 sql_help.c:84 sql_help.c:238 sql_help.c:302 -#: sql_help.c:423 sql_help.c:508 sql_help.c:634 sql_help.c:676 sql_help.c:704 -#: sql_help.c:759 sql_help.c:886 sql_help.c:998 sql_help.c:1108 -#: sql_help.c:1129 sql_help.c:1141 sql_help.c:1153 sql_help.c:1196 -#: sql_help.c:1295 +#: sql_help.c:44 sql_help.c:69 sql_help.c:84 sql_help.c:238 sql_help.c:303 +#: sql_help.c:425 sql_help.c:510 sql_help.c:635 sql_help.c:676 sql_help.c:704 +#: sql_help.c:759 sql_help.c:886 sql_help.c:998 sql_help.c:1108 sql_help.c:1129 +#: sql_help.c:1141 sql_help.c:1153 sql_help.c:1196 sql_help.c:1295 msgid "new_schema" msgstr "nuovo_schema" -#: sql_help.c:45 sql_help.c:1456 sql_help.c:2656 sql_help.c:3569 +#: sql_help.c:45 sql_help.c:1458 sql_help.c:2645 sql_help.c:3558 msgid "where aggregate_signature is:" msgstr "dove signature_aggregato è:" -#: sql_help.c:46 sql_help.c:49 sql_help.c:52 sql_help.c:319 sql_help.c:344 -#: sql_help.c:347 sql_help.c:350 sql_help.c:490 sql_help.c:495 sql_help.c:500 -#: sql_help.c:505 sql_help.c:510 sql_help.c:1421 sql_help.c:1457 -#: sql_help.c:1460 sql_help.c:1463 sql_help.c:1614 sql_help.c:1634 -#: sql_help.c:1637 sql_help.c:1887 sql_help.c:2657 sql_help.c:2660 -#: sql_help.c:2663 sql_help.c:2748 sql_help.c:3133 sql_help.c:3465 -#: sql_help.c:3556 sql_help.c:3570 sql_help.c:3573 sql_help.c:3576 +#: sql_help.c:46 sql_help.c:49 sql_help.c:52 sql_help.c:321 sql_help.c:346 +#: sql_help.c:349 sql_help.c:352 sql_help.c:492 sql_help.c:497 sql_help.c:502 +#: sql_help.c:507 sql_help.c:512 sql_help.c:1423 sql_help.c:1459 +#: sql_help.c:1462 sql_help.c:1465 sql_help.c:1609 sql_help.c:1628 +#: sql_help.c:1631 sql_help.c:1876 sql_help.c:2646 sql_help.c:2649 +#: sql_help.c:2652 sql_help.c:2737 sql_help.c:3122 sql_help.c:3454 +#: sql_help.c:3545 sql_help.c:3559 sql_help.c:3562 sql_help.c:3565 msgid "argmode" msgstr "modo_arg" -#: sql_help.c:47 sql_help.c:50 sql_help.c:53 sql_help.c:320 sql_help.c:345 -#: sql_help.c:348 sql_help.c:351 sql_help.c:491 sql_help.c:496 sql_help.c:501 -#: sql_help.c:506 sql_help.c:511 sql_help.c:1422 sql_help.c:1458 -#: sql_help.c:1461 sql_help.c:1464 sql_help.c:1615 sql_help.c:1635 -#: sql_help.c:1638 sql_help.c:1888 sql_help.c:2658 sql_help.c:2661 -#: sql_help.c:2664 sql_help.c:2749 sql_help.c:3557 sql_help.c:3571 -#: sql_help.c:3574 sql_help.c:3577 +#: sql_help.c:47 sql_help.c:50 sql_help.c:53 sql_help.c:322 sql_help.c:347 +#: sql_help.c:350 sql_help.c:353 sql_help.c:493 sql_help.c:498 sql_help.c:503 +#: sql_help.c:508 sql_help.c:513 sql_help.c:1424 sql_help.c:1460 +#: sql_help.c:1463 sql_help.c:1466 sql_help.c:1610 sql_help.c:1629 +#: sql_help.c:1632 sql_help.c:1877 sql_help.c:2647 sql_help.c:2650 +#: sql_help.c:2653 sql_help.c:2738 sql_help.c:3546 sql_help.c:3560 +#: sql_help.c:3563 sql_help.c:3566 msgid "argname" msgstr "nome_arg" -#: sql_help.c:48 sql_help.c:51 sql_help.c:54 sql_help.c:321 sql_help.c:346 -#: sql_help.c:349 sql_help.c:352 sql_help.c:492 sql_help.c:497 sql_help.c:502 -#: sql_help.c:507 sql_help.c:512 sql_help.c:1423 sql_help.c:1459 -#: sql_help.c:1462 sql_help.c:1465 sql_help.c:1889 sql_help.c:2659 -#: sql_help.c:2662 sql_help.c:2665 sql_help.c:2750 sql_help.c:3558 -#: sql_help.c:3572 sql_help.c:3575 sql_help.c:3578 +#: sql_help.c:48 sql_help.c:51 sql_help.c:54 sql_help.c:323 sql_help.c:348 +#: sql_help.c:351 sql_help.c:354 sql_help.c:494 sql_help.c:499 sql_help.c:504 +#: sql_help.c:509 sql_help.c:514 sql_help.c:1425 sql_help.c:1461 +#: sql_help.c:1464 sql_help.c:1467 sql_help.c:1878 sql_help.c:2648 +#: sql_help.c:2651 sql_help.c:2654 sql_help.c:2739 sql_help.c:3547 +#: sql_help.c:3561 sql_help.c:3564 sql_help.c:3567 msgid "argtype" msgstr "tipo_arg" -#: sql_help.c:110 sql_help.c:368 sql_help.c:446 sql_help.c:458 sql_help.c:814 +#: sql_help.c:110 sql_help.c:370 sql_help.c:448 sql_help.c:460 sql_help.c:814 #: sql_help.c:899 sql_help.c:1122 sql_help.c:1242 sql_help.c:1270 -#: sql_help.c:1513 sql_help.c:1519 sql_help.c:1814 sql_help.c:1846 -#: sql_help.c:1853 sql_help.c:1929 sql_help.c:2093 sql_help.c:2182 -#: sql_help.c:2362 sql_help.c:2541 sql_help.c:2563 sql_help.c:3001 -#: sql_help.c:3167 +#: sql_help.c:1515 sql_help.c:1521 sql_help.c:1803 sql_help.c:1835 +#: sql_help.c:1842 sql_help.c:1918 sql_help.c:2082 sql_help.c:2171 +#: sql_help.c:2351 sql_help.c:2530 sql_help.c:2552 sql_help.c:2990 +#: sql_help.c:3156 msgid "option" msgstr "opzione" -#: sql_help.c:111 sql_help.c:815 sql_help.c:1243 sql_help.c:1930 -#: sql_help.c:2094 sql_help.c:2542 +#: sql_help.c:111 sql_help.c:815 sql_help.c:1243 sql_help.c:1919 +#: sql_help.c:2083 sql_help.c:2531 msgid "where option can be:" msgstr "dove opzione può essere:" -#: sql_help.c:112 sql_help.c:1746 +#: sql_help.c:112 sql_help.c:1735 msgid "allowconn" msgstr "permetti_conn" -#: sql_help.c:113 sql_help.c:816 sql_help.c:1244 sql_help.c:1747 -#: sql_help.c:2095 sql_help.c:2543 +#: sql_help.c:113 sql_help.c:816 sql_help.c:1244 sql_help.c:1736 +#: sql_help.c:2084 sql_help.c:2532 msgid "connlimit" msgstr "limite_conn" -#: sql_help.c:114 sql_help.c:1748 +#: sql_help.c:114 sql_help.c:1737 msgid "istemplate" msgstr "è_template" -#: sql_help.c:120 sql_help.c:571 sql_help.c:637 sql_help.c:652 sql_help.c:1001 -#: sql_help.c:1038 +#: sql_help.c:120 sql_help.c:573 sql_help.c:638 sql_help.c:1001 sql_help.c:1038 msgid "new_tablespace" msgstr "nuovo_tablespace" -#: sql_help.c:122 sql_help.c:125 sql_help.c:127 sql_help.c:517 sql_help.c:519 -#: sql_help.c:520 sql_help.c:823 sql_help.c:827 sql_help.c:830 sql_help.c:915 +#: sql_help.c:122 sql_help.c:125 sql_help.c:127 sql_help.c:519 sql_help.c:521 +#: sql_help.c:522 sql_help.c:823 sql_help.c:827 sql_help.c:830 sql_help.c:915 #: sql_help.c:918 sql_help.c:1250 sql_help.c:1253 sql_help.c:1255 -#: sql_help.c:1898 sql_help.c:3352 sql_help.c:3743 +#: sql_help.c:1887 sql_help.c:3341 sql_help.c:3732 msgid "configuration_parameter" msgstr "parametro_config" -#: sql_help.c:123 sql_help.c:369 sql_help.c:441 sql_help.c:447 sql_help.c:459 -#: sql_help.c:518 sql_help.c:566 sql_help.c:643 sql_help.c:649 sql_help.c:824 -#: sql_help.c:900 sql_help.c:916 sql_help.c:917 sql_help.c:1020 -#: sql_help.c:1040 sql_help.c:1066 sql_help.c:1123 sql_help.c:1251 -#: sql_help.c:1271 sql_help.c:1815 sql_help.c:1847 sql_help.c:1854 -#: sql_help.c:1899 sql_help.c:1900 sql_help.c:1958 sql_help.c:1990 -#: sql_help.c:2183 sql_help.c:2257 sql_help.c:2265 sql_help.c:2297 -#: sql_help.c:2319 sql_help.c:2336 sql_help.c:2363 sql_help.c:2564 -#: sql_help.c:3168 sql_help.c:3744 sql_help.c:3745 +#: sql_help.c:123 sql_help.c:371 sql_help.c:443 sql_help.c:449 sql_help.c:461 +#: sql_help.c:520 sql_help.c:568 sql_help.c:644 sql_help.c:650 sql_help.c:824 +#: sql_help.c:900 sql_help.c:916 sql_help.c:917 sql_help.c:1020 sql_help.c:1040 +#: sql_help.c:1066 sql_help.c:1123 sql_help.c:1251 sql_help.c:1271 +#: sql_help.c:1804 sql_help.c:1836 sql_help.c:1843 sql_help.c:1888 +#: sql_help.c:1889 sql_help.c:1947 sql_help.c:1979 sql_help.c:2172 +#: sql_help.c:2246 sql_help.c:2254 sql_help.c:2286 sql_help.c:2308 +#: sql_help.c:2325 sql_help.c:2352 sql_help.c:2553 sql_help.c:3157 +#: sql_help.c:3733 sql_help.c:3734 msgid "value" msgstr "valore" @@ -3371,9 +3453,9 @@ msgstr "valore" msgid "target_role" msgstr "ruolo_destinazione" -#: sql_help.c:186 sql_help.c:1798 sql_help.c:2141 sql_help.c:2146 -#: sql_help.c:3115 sql_help.c:3122 sql_help.c:3136 sql_help.c:3142 -#: sql_help.c:3447 sql_help.c:3454 sql_help.c:3468 sql_help.c:3474 +#: sql_help.c:186 sql_help.c:1787 sql_help.c:2130 sql_help.c:2135 +#: sql_help.c:3104 sql_help.c:3111 sql_help.c:3125 sql_help.c:3131 +#: sql_help.c:3436 sql_help.c:3443 sql_help.c:3457 sql_help.c:3463 msgid "schema_name" msgstr "nome_schema" @@ -3386,33 +3468,33 @@ msgid "where abbreviated_grant_or_revoke is one of:" msgstr "dove grant_o_revoke_abbreviato è uno di:" #: sql_help.c:189 sql_help.c:190 sql_help.c:191 sql_help.c:192 sql_help.c:193 -#: sql_help.c:194 sql_help.c:195 sql_help.c:196 sql_help.c:542 sql_help.c:570 -#: sql_help.c:636 sql_help.c:777 sql_help.c:834 sql_help.c:1000 -#: sql_help.c:1258 sql_help.c:1933 sql_help.c:1934 sql_help.c:1935 -#: sql_help.c:1936 sql_help.c:1937 sql_help.c:2063 sql_help.c:2098 -#: sql_help.c:2099 sql_help.c:2100 sql_help.c:2101 sql_help.c:2102 -#: sql_help.c:2546 sql_help.c:2547 sql_help.c:2548 sql_help.c:2549 -#: sql_help.c:2550 sql_help.c:3149 sql_help.c:3150 sql_help.c:3151 -#: sql_help.c:3448 sql_help.c:3452 sql_help.c:3455 sql_help.c:3457 -#: sql_help.c:3459 sql_help.c:3461 sql_help.c:3463 sql_help.c:3469 -#: sql_help.c:3471 sql_help.c:3473 sql_help.c:3475 sql_help.c:3477 -#: sql_help.c:3479 sql_help.c:3480 sql_help.c:3481 sql_help.c:3764 +#: sql_help.c:194 sql_help.c:195 sql_help.c:196 sql_help.c:544 sql_help.c:572 +#: sql_help.c:637 sql_help.c:777 sql_help.c:834 sql_help.c:1000 sql_help.c:1258 +#: sql_help.c:1922 sql_help.c:1923 sql_help.c:1924 sql_help.c:1925 +#: sql_help.c:1926 sql_help.c:2052 sql_help.c:2087 sql_help.c:2088 +#: sql_help.c:2089 sql_help.c:2090 sql_help.c:2091 sql_help.c:2535 +#: sql_help.c:2536 sql_help.c:2537 sql_help.c:2538 sql_help.c:2539 +#: sql_help.c:3138 sql_help.c:3139 sql_help.c:3140 sql_help.c:3437 +#: sql_help.c:3441 sql_help.c:3444 sql_help.c:3446 sql_help.c:3448 +#: sql_help.c:3450 sql_help.c:3452 sql_help.c:3458 sql_help.c:3460 +#: sql_help.c:3462 sql_help.c:3464 sql_help.c:3466 sql_help.c:3468 +#: sql_help.c:3469 sql_help.c:3470 sql_help.c:3753 msgid "role_name" msgstr "nome_ruolo" -#: sql_help.c:222 sql_help.c:434 sql_help.c:1011 sql_help.c:1013 -#: sql_help.c:1287 sql_help.c:1767 sql_help.c:1771 sql_help.c:1857 -#: sql_help.c:1861 sql_help.c:1954 sql_help.c:2269 sql_help.c:2279 -#: sql_help.c:2301 sql_help.c:3198 sql_help.c:3213 sql_help.c:3215 -#: sql_help.c:3629 sql_help.c:3630 sql_help.c:3639 sql_help.c:3680 -#: sql_help.c:3681 sql_help.c:3682 sql_help.c:3683 sql_help.c:3684 -#: sql_help.c:3685 sql_help.c:3718 sql_help.c:3719 sql_help.c:3724 -#: sql_help.c:3729 sql_help.c:3868 sql_help.c:3869 sql_help.c:3878 -#: sql_help.c:3919 sql_help.c:3920 sql_help.c:3921 sql_help.c:3922 -#: sql_help.c:3923 sql_help.c:3924 sql_help.c:3971 sql_help.c:3973 -#: sql_help.c:4006 sql_help.c:4062 sql_help.c:4063 sql_help.c:4072 -#: sql_help.c:4113 sql_help.c:4114 sql_help.c:4115 sql_help.c:4116 -#: sql_help.c:4117 sql_help.c:4118 +#: sql_help.c:222 sql_help.c:436 sql_help.c:1011 sql_help.c:1013 +#: sql_help.c:1287 sql_help.c:1756 sql_help.c:1760 sql_help.c:1846 +#: sql_help.c:1850 sql_help.c:1943 sql_help.c:2258 sql_help.c:2268 +#: sql_help.c:2290 sql_help.c:3187 sql_help.c:3202 sql_help.c:3204 +#: sql_help.c:3618 sql_help.c:3619 sql_help.c:3628 sql_help.c:3669 +#: sql_help.c:3670 sql_help.c:3671 sql_help.c:3672 sql_help.c:3673 +#: sql_help.c:3674 sql_help.c:3707 sql_help.c:3708 sql_help.c:3713 +#: sql_help.c:3718 sql_help.c:3857 sql_help.c:3858 sql_help.c:3867 +#: sql_help.c:3908 sql_help.c:3909 sql_help.c:3910 sql_help.c:3911 +#: sql_help.c:3912 sql_help.c:3913 sql_help.c:3960 sql_help.c:3962 +#: sql_help.c:3995 sql_help.c:4051 sql_help.c:4052 sql_help.c:4061 +#: sql_help.c:4102 sql_help.c:4103 sql_help.c:4104 sql_help.c:4105 +#: sql_help.c:4106 sql_help.c:4107 msgid "expression" msgstr "espressione" @@ -3420,11 +3502,11 @@ msgstr "espressione" msgid "domain_constraint" msgstr "vincolo_di_dominio" -#: sql_help.c:227 sql_help.c:229 sql_help.c:232 sql_help.c:449 sql_help.c:450 +#: sql_help.c:227 sql_help.c:229 sql_help.c:232 sql_help.c:451 sql_help.c:452 #: sql_help.c:993 sql_help.c:1026 sql_help.c:1027 sql_help.c:1028 -#: sql_help.c:1048 sql_help.c:1409 sql_help.c:1411 sql_help.c:1770 -#: sql_help.c:1856 sql_help.c:1860 sql_help.c:2268 sql_help.c:2278 -#: sql_help.c:3210 +#: sql_help.c:1048 sql_help.c:1411 sql_help.c:1413 sql_help.c:1759 +#: sql_help.c:1845 sql_help.c:1849 sql_help.c:2257 sql_help.c:2267 +#: sql_help.c:3199 msgid "constraint_name" msgstr "nome_vincolo" @@ -3432,319 +3514,317 @@ msgstr "nome_vincolo" msgid "new_constraint_name" msgstr "nuovo_nome_vincolo" -#: sql_help.c:300 sql_help.c:898 +#: sql_help.c:301 sql_help.c:898 msgid "new_version" msgstr "nuova_versione" -#: sql_help.c:304 sql_help.c:306 +#: sql_help.c:305 sql_help.c:307 msgid "member_object" msgstr "oggetto_membro" -#: sql_help.c:307 +#: sql_help.c:308 msgid "where member_object is:" msgstr "dove oggetto_membro è:" -#: sql_help.c:308 sql_help.c:1402 sql_help.c:3549 +#: sql_help.c:309 sql_help.c:314 sql_help.c:315 sql_help.c:316 sql_help.c:317 +#: sql_help.c:318 sql_help.c:319 sql_help.c:324 sql_help.c:328 sql_help.c:330 +#: sql_help.c:332 sql_help.c:333 sql_help.c:334 sql_help.c:335 sql_help.c:336 +#: sql_help.c:337 sql_help.c:338 sql_help.c:339 sql_help.c:340 sql_help.c:343 +#: sql_help.c:344 sql_help.c:1403 sql_help.c:1408 sql_help.c:1415 +#: sql_help.c:1416 sql_help.c:1417 sql_help.c:1418 sql_help.c:1419 +#: sql_help.c:1420 sql_help.c:1421 sql_help.c:1426 sql_help.c:1428 +#: sql_help.c:1432 sql_help.c:1434 sql_help.c:1438 sql_help.c:1439 +#: sql_help.c:1442 sql_help.c:1443 sql_help.c:1444 sql_help.c:1445 +#: sql_help.c:1446 sql_help.c:1447 sql_help.c:1448 sql_help.c:1449 +#: sql_help.c:1450 sql_help.c:1455 sql_help.c:1456 sql_help.c:3535 +#: sql_help.c:3540 sql_help.c:3541 sql_help.c:3542 sql_help.c:3543 +#: sql_help.c:3549 sql_help.c:3550 sql_help.c:3551 sql_help.c:3552 +#: sql_help.c:3553 sql_help.c:3554 sql_help.c:3555 sql_help.c:3556 +msgid "object_name" +msgstr "nome_oggetto" + +#: sql_help.c:310 sql_help.c:1404 sql_help.c:3538 msgid "aggregate_name" msgstr "nome_aggregato" -#: sql_help.c:310 sql_help.c:1404 sql_help.c:1685 sql_help.c:1689 -#: sql_help.c:1691 sql_help.c:2673 +#: sql_help.c:312 sql_help.c:1406 sql_help.c:1674 sql_help.c:1678 +#: sql_help.c:1680 sql_help.c:2662 msgid "source_type" msgstr "tipo_sorgente" -#: sql_help.c:311 sql_help.c:1405 sql_help.c:1686 sql_help.c:1690 -#: sql_help.c:1692 sql_help.c:2674 +#: sql_help.c:313 sql_help.c:1407 sql_help.c:1675 sql_help.c:1679 +#: sql_help.c:1681 sql_help.c:2663 msgid "target_type" msgstr "tipo_destinazione" -#: sql_help.c:312 sql_help.c:313 sql_help.c:314 sql_help.c:315 sql_help.c:316 -#: sql_help.c:317 sql_help.c:322 sql_help.c:326 sql_help.c:328 sql_help.c:330 -#: sql_help.c:331 sql_help.c:332 sql_help.c:333 sql_help.c:334 sql_help.c:335 -#: sql_help.c:336 sql_help.c:337 sql_help.c:338 sql_help.c:341 sql_help.c:342 -#: sql_help.c:1406 sql_help.c:1413 sql_help.c:1414 sql_help.c:1415 -#: sql_help.c:1416 sql_help.c:1417 sql_help.c:1418 sql_help.c:1419 -#: sql_help.c:1424 sql_help.c:1426 sql_help.c:1430 sql_help.c:1432 -#: sql_help.c:1436 sql_help.c:1437 sql_help.c:1440 sql_help.c:1441 -#: sql_help.c:1442 sql_help.c:1443 sql_help.c:1444 sql_help.c:1445 -#: sql_help.c:1446 sql_help.c:1447 sql_help.c:1448 sql_help.c:1453 -#: sql_help.c:1454 sql_help.c:3546 sql_help.c:3551 sql_help.c:3552 -#: sql_help.c:3553 sql_help.c:3554 sql_help.c:3560 sql_help.c:3561 -#: sql_help.c:3562 sql_help.c:3563 sql_help.c:3564 sql_help.c:3565 -#: sql_help.c:3566 sql_help.c:3567 -msgid "object_name" -msgstr "nome_oggetto" - -#: sql_help.c:318 sql_help.c:741 sql_help.c:1420 sql_help.c:1687 -#: sql_help.c:1722 sql_help.c:1785 sql_help.c:2007 sql_help.c:2038 -#: sql_help.c:2437 sql_help.c:3132 sql_help.c:3464 sql_help.c:3555 -#: sql_help.c:3658 sql_help.c:3662 sql_help.c:3666 sql_help.c:3669 -#: sql_help.c:3897 sql_help.c:3901 sql_help.c:3905 sql_help.c:3908 -#: sql_help.c:4091 sql_help.c:4095 sql_help.c:4099 sql_help.c:4102 +#: sql_help.c:320 sql_help.c:741 sql_help.c:1422 sql_help.c:1676 +#: sql_help.c:1711 sql_help.c:1774 sql_help.c:1996 sql_help.c:2027 +#: sql_help.c:2426 sql_help.c:3121 sql_help.c:3453 sql_help.c:3544 +#: sql_help.c:3647 sql_help.c:3651 sql_help.c:3655 sql_help.c:3658 +#: sql_help.c:3886 sql_help.c:3890 sql_help.c:3894 sql_help.c:3897 +#: sql_help.c:4080 sql_help.c:4084 sql_help.c:4088 sql_help.c:4091 msgid "function_name" msgstr "nome_funzione" -#: sql_help.c:323 sql_help.c:734 sql_help.c:1427 sql_help.c:2031 +#: sql_help.c:325 sql_help.c:734 sql_help.c:1429 sql_help.c:2020 msgid "operator_name" msgstr "nome_operatore" -#: sql_help.c:324 sql_help.c:670 sql_help.c:674 sql_help.c:678 sql_help.c:1428 -#: sql_help.c:2008 sql_help.c:2791 +#: sql_help.c:326 sql_help.c:670 sql_help.c:674 sql_help.c:678 sql_help.c:1430 +#: sql_help.c:1997 sql_help.c:2780 msgid "left_type" msgstr "tipo_sx" -#: sql_help.c:325 sql_help.c:671 sql_help.c:675 sql_help.c:679 sql_help.c:1429 -#: sql_help.c:2009 sql_help.c:2792 +#: sql_help.c:327 sql_help.c:671 sql_help.c:675 sql_help.c:679 sql_help.c:1431 +#: sql_help.c:1998 sql_help.c:2781 msgid "right_type" msgstr "tipo_dx" -#: sql_help.c:327 sql_help.c:329 sql_help.c:697 sql_help.c:700 sql_help.c:703 +#: sql_help.c:329 sql_help.c:331 sql_help.c:697 sql_help.c:700 sql_help.c:703 #: sql_help.c:732 sql_help.c:744 sql_help.c:752 sql_help.c:755 sql_help.c:758 -#: sql_help.c:1431 sql_help.c:1433 sql_help.c:2028 sql_help.c:2049 -#: sql_help.c:2284 sql_help.c:2801 sql_help.c:2810 +#: sql_help.c:1433 sql_help.c:1435 sql_help.c:2017 sql_help.c:2038 +#: sql_help.c:2273 sql_help.c:2790 sql_help.c:2799 msgid "index_method" msgstr "metodo_indice" -#: sql_help.c:339 sql_help.c:1044 sql_help.c:1449 sql_help.c:1895 -#: sql_help.c:2260 sql_help.c:2406 sql_help.c:2924 sql_help.c:3146 -#: sql_help.c:3478 +#: sql_help.c:341 sql_help.c:1044 sql_help.c:1451 sql_help.c:1884 +#: sql_help.c:2249 sql_help.c:2395 sql_help.c:2913 sql_help.c:3135 +#: sql_help.c:3467 msgid "type_name" msgstr "nome_di_tipo" -#: sql_help.c:340 sql_help.c:1450 sql_help.c:1894 sql_help.c:2407 -#: sql_help.c:2631 sql_help.c:2925 sql_help.c:3138 sql_help.c:3470 +#: sql_help.c:342 sql_help.c:1452 sql_help.c:1883 sql_help.c:2396 +#: sql_help.c:2620 sql_help.c:2914 sql_help.c:3127 sql_help.c:3459 msgid "lang_name" msgstr "nome_linguaggio" -#: sql_help.c:343 +#: sql_help.c:345 msgid "and aggregate_signature is:" msgstr "e signature_aggregato è:" -#: sql_help.c:366 sql_help.c:1544 sql_help.c:1812 +#: sql_help.c:368 sql_help.c:1546 sql_help.c:1801 msgid "handler_function" msgstr "funzione_handler" -#: sql_help.c:367 sql_help.c:1813 +#: sql_help.c:369 sql_help.c:1802 msgid "validator_function" msgstr "funzione_validazione" -#: sql_help.c:416 sql_help.c:493 sql_help.c:625 sql_help.c:988 sql_help.c:1187 -#: sql_help.c:2275 sql_help.c:2276 sql_help.c:2292 sql_help.c:2293 +#: sql_help.c:418 sql_help.c:495 sql_help.c:626 sql_help.c:988 sql_help.c:1187 +#: sql_help.c:2264 sql_help.c:2265 sql_help.c:2281 sql_help.c:2282 msgid "action" msgstr "azione" -#: sql_help.c:418 sql_help.c:425 sql_help.c:429 sql_help.c:430 sql_help.c:433 -#: sql_help.c:435 sql_help.c:436 sql_help.c:437 sql_help.c:439 sql_help.c:442 -#: sql_help.c:444 sql_help.c:445 sql_help.c:629 sql_help.c:639 sql_help.c:641 -#: sql_help.c:644 sql_help.c:646 sql_help.c:880 sql_help.c:990 sql_help.c:1003 +#: sql_help.c:420 sql_help.c:427 sql_help.c:431 sql_help.c:432 sql_help.c:435 +#: sql_help.c:437 sql_help.c:438 sql_help.c:439 sql_help.c:441 sql_help.c:444 +#: sql_help.c:446 sql_help.c:447 sql_help.c:630 sql_help.c:640 sql_help.c:642 +#: sql_help.c:645 sql_help.c:647 sql_help.c:880 sql_help.c:990 sql_help.c:1003 #: sql_help.c:1007 sql_help.c:1008 sql_help.c:1012 sql_help.c:1014 #: sql_help.c:1015 sql_help.c:1016 sql_help.c:1018 sql_help.c:1021 #: sql_help.c:1023 sql_help.c:1286 sql_help.c:1289 sql_help.c:1309 -#: sql_help.c:1408 sql_help.c:1510 sql_help.c:1515 sql_help.c:1529 -#: sql_help.c:1530 sql_help.c:1531 sql_help.c:1844 sql_help.c:1892 -#: sql_help.c:1953 sql_help.c:1988 sql_help.c:2168 sql_help.c:2248 -#: sql_help.c:2261 sql_help.c:2280 sql_help.c:2282 sql_help.c:2289 -#: sql_help.c:2300 sql_help.c:2317 sql_help.c:2440 sql_help.c:2576 -#: sql_help.c:3117 sql_help.c:3118 sql_help.c:3197 sql_help.c:3212 -#: sql_help.c:3214 sql_help.c:3216 sql_help.c:3449 sql_help.c:3450 -#: sql_help.c:3548 sql_help.c:3689 sql_help.c:3928 sql_help.c:3970 -#: sql_help.c:3972 sql_help.c:3974 sql_help.c:3991 sql_help.c:3994 -#: sql_help.c:4122 +#: sql_help.c:1410 sql_help.c:1512 sql_help.c:1517 sql_help.c:1531 +#: sql_help.c:1532 sql_help.c:1533 sql_help.c:1833 sql_help.c:1881 +#: sql_help.c:1942 sql_help.c:1977 sql_help.c:2157 sql_help.c:2237 +#: sql_help.c:2250 sql_help.c:2269 sql_help.c:2271 sql_help.c:2278 +#: sql_help.c:2289 sql_help.c:2306 sql_help.c:2429 sql_help.c:2565 +#: sql_help.c:3106 sql_help.c:3107 sql_help.c:3186 sql_help.c:3201 +#: sql_help.c:3203 sql_help.c:3205 sql_help.c:3438 sql_help.c:3439 +#: sql_help.c:3537 sql_help.c:3678 sql_help.c:3917 sql_help.c:3959 +#: sql_help.c:3961 sql_help.c:3963 sql_help.c:3980 sql_help.c:3983 +#: sql_help.c:4111 msgid "column_name" msgstr "nome_colonna" -#: sql_help.c:419 sql_help.c:630 sql_help.c:991 +#: sql_help.c:421 sql_help.c:631 sql_help.c:991 msgid "new_column_name" msgstr "nuovo_nome_colonna" -#: sql_help.c:424 sql_help.c:514 sql_help.c:638 sql_help.c:1002 -#: sql_help.c:1200 +#: sql_help.c:426 sql_help.c:516 sql_help.c:639 sql_help.c:1002 sql_help.c:1200 msgid "where action is one of:" msgstr "dove azione è una di:" -#: sql_help.c:426 sql_help.c:431 sql_help.c:1004 sql_help.c:1009 -#: sql_help.c:1202 sql_help.c:1206 sql_help.c:1765 sql_help.c:1845 -#: sql_help.c:2027 sql_help.c:2249 sql_help.c:2485 sql_help.c:3299 +#: sql_help.c:428 sql_help.c:433 sql_help.c:1004 sql_help.c:1009 +#: sql_help.c:1202 sql_help.c:1206 sql_help.c:1754 sql_help.c:1834 +#: sql_help.c:2016 sql_help.c:2238 sql_help.c:2474 sql_help.c:3288 msgid "data_type" msgstr "tipo_di_dato" -#: sql_help.c:427 sql_help.c:432 sql_help.c:1005 sql_help.c:1010 -#: sql_help.c:1203 sql_help.c:1207 sql_help.c:1766 sql_help.c:1848 -#: sql_help.c:1955 sql_help.c:2250 sql_help.c:2486 sql_help.c:2492 -#: sql_help.c:3207 +#: sql_help.c:429 sql_help.c:434 sql_help.c:1005 sql_help.c:1010 +#: sql_help.c:1203 sql_help.c:1207 sql_help.c:1755 sql_help.c:1837 +#: sql_help.c:1944 sql_help.c:2239 sql_help.c:2475 sql_help.c:2481 +#: sql_help.c:3196 msgid "collation" msgstr "ordinamento" -#: sql_help.c:428 sql_help.c:1006 sql_help.c:1849 sql_help.c:2251 -#: sql_help.c:2262 +#: sql_help.c:430 sql_help.c:1006 sql_help.c:1838 sql_help.c:2240 +#: sql_help.c:2251 msgid "column_constraint" msgstr "vincolo_di_colonna" -#: sql_help.c:438 sql_help.c:640 sql_help.c:1017 +#: sql_help.c:440 sql_help.c:641 sql_help.c:1017 msgid "integer" msgstr "intero" -#: sql_help.c:440 sql_help.c:443 sql_help.c:642 sql_help.c:645 sql_help.c:1019 +#: sql_help.c:442 sql_help.c:445 sql_help.c:643 sql_help.c:646 sql_help.c:1019 #: sql_help.c:1022 msgid "attribute_option" msgstr "opzione_attributo" -#: sql_help.c:448 sql_help.c:1024 sql_help.c:1850 sql_help.c:2252 -#: sql_help.c:2263 +#: sql_help.c:450 sql_help.c:1024 sql_help.c:1839 sql_help.c:2241 +#: sql_help.c:2252 msgid "table_constraint" msgstr "vincoli_di_tabella" -#: sql_help.c:451 sql_help.c:452 sql_help.c:453 sql_help.c:454 sql_help.c:1029 -#: sql_help.c:1030 sql_help.c:1031 sql_help.c:1032 sql_help.c:1451 +#: sql_help.c:453 sql_help.c:454 sql_help.c:455 sql_help.c:456 sql_help.c:1029 +#: sql_help.c:1030 sql_help.c:1031 sql_help.c:1032 sql_help.c:1453 msgid "trigger_name" msgstr "nome_trigger" -#: sql_help.c:455 sql_help.c:456 sql_help.c:1042 sql_help.c:1043 -#: sql_help.c:1851 sql_help.c:2255 +#: sql_help.c:457 sql_help.c:458 sql_help.c:1042 sql_help.c:1043 +#: sql_help.c:1840 sql_help.c:2244 msgid "parent_table" msgstr "tabella_padre" -#: sql_help.c:513 sql_help.c:563 sql_help.c:627 sql_help.c:1167 -#: sql_help.c:1797 +#: sql_help.c:515 sql_help.c:565 sql_help.c:628 sql_help.c:1167 sql_help.c:1786 msgid "extension_name" msgstr "nome_estensione" -#: sql_help.c:515 sql_help.c:1896 +#: sql_help.c:517 sql_help.c:1885 msgid "execution_cost" msgstr "costo_di_esecuzione" -#: sql_help.c:516 sql_help.c:1897 +#: sql_help.c:518 sql_help.c:1886 msgid "result_rows" msgstr "righe_risultato" -#: sql_help.c:537 sql_help.c:539 sql_help.c:813 sql_help.c:821 sql_help.c:825 +#: sql_help.c:539 sql_help.c:541 sql_help.c:813 sql_help.c:821 sql_help.c:825 #: sql_help.c:828 sql_help.c:831 sql_help.c:1241 sql_help.c:1249 -#: sql_help.c:1252 sql_help.c:1254 sql_help.c:1256 sql_help.c:2142 -#: sql_help.c:2144 sql_help.c:2147 sql_help.c:2148 sql_help.c:3116 -#: sql_help.c:3120 sql_help.c:3123 sql_help.c:3125 sql_help.c:3127 -#: sql_help.c:3129 sql_help.c:3131 sql_help.c:3137 sql_help.c:3139 -#: sql_help.c:3141 sql_help.c:3143 sql_help.c:3145 sql_help.c:3147 +#: sql_help.c:1252 sql_help.c:1254 sql_help.c:1256 sql_help.c:2131 +#: sql_help.c:2133 sql_help.c:2136 sql_help.c:2137 sql_help.c:3105 +#: sql_help.c:3109 sql_help.c:3112 sql_help.c:3114 sql_help.c:3116 +#: sql_help.c:3118 sql_help.c:3120 sql_help.c:3126 sql_help.c:3128 +#: sql_help.c:3130 sql_help.c:3132 sql_help.c:3134 sql_help.c:3136 msgid "role_specification" msgstr "specifica_ruolo" -#: sql_help.c:538 sql_help.c:540 sql_help.c:1268 sql_help.c:1740 -#: sql_help.c:2150 sql_help.c:2561 sql_help.c:2958 sql_help.c:3774 +#: sql_help.c:540 sql_help.c:542 sql_help.c:1268 sql_help.c:1729 +#: sql_help.c:2139 sql_help.c:2550 sql_help.c:2947 sql_help.c:3763 msgid "user_name" msgstr "nome_utente" -#: sql_help.c:541 sql_help.c:833 sql_help.c:1257 sql_help.c:2149 -#: sql_help.c:3148 +#: sql_help.c:543 sql_help.c:833 sql_help.c:1257 sql_help.c:2138 +#: sql_help.c:3137 msgid "where role_specification can be:" msgstr "dove specifica_ruolo può essere:" -#: sql_help.c:543 +#: sql_help.c:545 msgid "group_name" msgstr "nome_gruppo" -#: sql_help.c:561 sql_help.c:1745 sql_help.c:1959 sql_help.c:1991 -#: sql_help.c:2258 sql_help.c:2266 sql_help.c:2298 sql_help.c:2320 -#: sql_help.c:2332 sql_help.c:3144 sql_help.c:3476 +#: sql_help.c:563 sql_help.c:1734 sql_help.c:1948 sql_help.c:1980 +#: sql_help.c:2247 sql_help.c:2255 sql_help.c:2287 sql_help.c:2309 +#: sql_help.c:2321 sql_help.c:3133 sql_help.c:3465 msgid "tablespace_name" msgstr "nome_tablespace" -#: sql_help.c:565 sql_help.c:568 sql_help.c:648 sql_help.c:650 sql_help.c:1039 -#: sql_help.c:1041 sql_help.c:1957 sql_help.c:1989 sql_help.c:2256 -#: sql_help.c:2264 sql_help.c:2296 sql_help.c:2318 +#: sql_help.c:567 sql_help.c:570 sql_help.c:649 sql_help.c:651 sql_help.c:1039 +#: sql_help.c:1041 sql_help.c:1946 sql_help.c:1978 sql_help.c:2245 +#: sql_help.c:2253 sql_help.c:2285 sql_help.c:2307 msgid "storage_parameter" msgstr "parametro_di_memorizzazione" -#: sql_help.c:591 sql_help.c:1425 sql_help.c:3559 +#: sql_help.c:593 sql_help.c:1427 sql_help.c:3548 msgid "large_object_oid" msgstr "oid_large_object" -#: sql_help.c:647 sql_help.c:1037 sql_help.c:1046 sql_help.c:1049 +#: sql_help.c:648 sql_help.c:1037 sql_help.c:1046 sql_help.c:1049 #: sql_help.c:1349 msgid "index_name" msgstr "nome_indice" -#: sql_help.c:680 sql_help.c:2012 +#: sql_help.c:680 sql_help.c:2001 msgid "res_proc" msgstr "res_proc" -#: sql_help.c:681 sql_help.c:2013 +#: sql_help.c:681 sql_help.c:2002 msgid "join_proc" msgstr "proc_join" -#: sql_help.c:733 sql_help.c:745 sql_help.c:2030 +#: sql_help.c:733 sql_help.c:745 sql_help.c:2019 msgid "strategy_number" msgstr "strategia_num" #: sql_help.c:735 sql_help.c:736 sql_help.c:739 sql_help.c:740 sql_help.c:746 -#: sql_help.c:747 sql_help.c:749 sql_help.c:750 sql_help.c:2032 -#: sql_help.c:2033 sql_help.c:2036 sql_help.c:2037 +#: sql_help.c:747 sql_help.c:749 sql_help.c:750 sql_help.c:2021 sql_help.c:2022 +#: sql_help.c:2025 sql_help.c:2026 msgid "op_type" msgstr "tipo_op" -#: sql_help.c:737 sql_help.c:2034 +#: sql_help.c:737 sql_help.c:2023 msgid "sort_family_name" msgstr "nome_famiglia_sort" -#: sql_help.c:738 sql_help.c:748 sql_help.c:2035 +#: sql_help.c:738 sql_help.c:748 sql_help.c:2024 msgid "support_number" msgstr "num_supporto" -#: sql_help.c:742 sql_help.c:1688 sql_help.c:2039 sql_help.c:2409 -#: sql_help.c:2411 +#: sql_help.c:742 sql_help.c:1677 sql_help.c:2028 sql_help.c:2398 +#: sql_help.c:2400 msgid "argument_type" msgstr "tipo_argomento" #: sql_help.c:773 sql_help.c:776 sql_help.c:843 sql_help.c:879 sql_help.c:1163 -#: sql_help.c:1166 sql_help.c:1308 sql_help.c:1348 sql_help.c:1410 -#: sql_help.c:1435 sql_help.c:1439 sql_help.c:1452 sql_help.c:1509 -#: sql_help.c:1514 sql_help.c:1843 sql_help.c:1951 sql_help.c:1987 -#: sql_help.c:2062 sql_help.c:2119 sql_help.c:2167 sql_help.c:2247 -#: sql_help.c:2259 sql_help.c:2316 sql_help.c:2434 sql_help.c:2610 -#: sql_help.c:2827 sql_help.c:2844 sql_help.c:2934 sql_help.c:3114 -#: sql_help.c:3119 sql_help.c:3164 sql_help.c:3195 sql_help.c:3446 -#: sql_help.c:3451 sql_help.c:3547 sql_help.c:3644 sql_help.c:3646 -#: sql_help.c:3695 sql_help.c:3734 sql_help.c:3883 sql_help.c:3885 -#: sql_help.c:3934 sql_help.c:3968 sql_help.c:3990 sql_help.c:3992 -#: sql_help.c:3993 sql_help.c:4077 sql_help.c:4079 sql_help.c:4128 +#: sql_help.c:1166 sql_help.c:1308 sql_help.c:1348 sql_help.c:1412 +#: sql_help.c:1437 sql_help.c:1441 sql_help.c:1454 sql_help.c:1511 +#: sql_help.c:1516 sql_help.c:1832 sql_help.c:1940 sql_help.c:1976 +#: sql_help.c:2051 sql_help.c:2108 sql_help.c:2156 sql_help.c:2236 +#: sql_help.c:2248 sql_help.c:2305 sql_help.c:2423 sql_help.c:2599 +#: sql_help.c:2816 sql_help.c:2833 sql_help.c:2923 sql_help.c:3103 +#: sql_help.c:3108 sql_help.c:3153 sql_help.c:3184 sql_help.c:3435 +#: sql_help.c:3440 sql_help.c:3536 sql_help.c:3633 sql_help.c:3635 +#: sql_help.c:3684 sql_help.c:3723 sql_help.c:3872 sql_help.c:3874 +#: sql_help.c:3923 sql_help.c:3957 sql_help.c:3979 sql_help.c:3981 +#: sql_help.c:3982 sql_help.c:4066 sql_help.c:4068 sql_help.c:4117 msgid "table_name" msgstr "nome_tabella" -#: sql_help.c:778 sql_help.c:2064 +#: sql_help.c:778 sql_help.c:2053 msgid "using_expression" msgstr "espressione_using" -#: sql_help.c:779 sql_help.c:2065 +#: sql_help.c:779 sql_help.c:2054 msgid "check_expression" msgstr "espressione_check" -#: sql_help.c:817 sql_help.c:1245 sql_help.c:1931 sql_help.c:2096 -#: sql_help.c:2544 +#: sql_help.c:817 sql_help.c:1245 sql_help.c:1920 sql_help.c:2085 +#: sql_help.c:2533 msgid "password" msgstr "password" -#: sql_help.c:818 sql_help.c:1246 sql_help.c:1932 sql_help.c:2097 -#: sql_help.c:2545 +#: sql_help.c:818 sql_help.c:1246 sql_help.c:1921 sql_help.c:2086 +#: sql_help.c:2534 msgid "timestamp" msgstr "timestamp" -#: sql_help.c:822 sql_help.c:826 sql_help.c:829 sql_help.c:832 sql_help.c:3124 -#: sql_help.c:3456 +#: sql_help.c:822 sql_help.c:826 sql_help.c:829 sql_help.c:832 sql_help.c:3113 +#: sql_help.c:3445 msgid "database_name" msgstr "nome_database" -#: sql_help.c:873 sql_help.c:2162 +#: sql_help.c:873 sql_help.c:2151 msgid "increment" msgstr "incremento" -#: sql_help.c:874 sql_help.c:2163 +#: sql_help.c:874 sql_help.c:2152 msgid "minvalue" msgstr "valoremin" -#: sql_help.c:875 sql_help.c:2164 +#: sql_help.c:875 sql_help.c:2153 msgid "maxvalue" msgstr "valoremax" -#: sql_help.c:876 sql_help.c:2165 sql_help.c:3642 sql_help.c:3732 -#: sql_help.c:3881 sql_help.c:4010 sql_help.c:4075 +#: sql_help.c:876 sql_help.c:2154 sql_help.c:3631 sql_help.c:3721 +#: sql_help.c:3870 sql_help.c:3999 sql_help.c:4064 msgid "start" msgstr "inizio" @@ -3752,7 +3832,7 @@ msgstr "inizio" msgid "restart" msgstr "riavvio" -#: sql_help.c:878 sql_help.c:2166 +#: sql_help.c:878 sql_help.c:2155 msgid "cache" msgstr "cache" @@ -3768,7 +3848,7 @@ msgstr "nome_regola_di_riscrittura" msgid "and table_constraint_using_index is:" msgstr "e vincolo_di_tabella_con_indice è:" -#: sql_help.c:1065 sql_help.c:1068 sql_help.c:2335 +#: sql_help.c:1065 sql_help.c:1068 sql_help.c:2324 msgid "tablespace_option" msgstr "opzione_tablespace" @@ -3789,7 +3869,7 @@ msgid "new_dictionary" msgstr "nuovo_dizionario" #: sql_help.c:1191 sql_help.c:1201 sql_help.c:1204 sql_help.c:1205 -#: sql_help.c:2484 +#: sql_help.c:2473 msgid "attribute_name" msgstr "nome_attributo" @@ -3805,1421 +3885,1417 @@ msgstr "nuovo_valore_enum" msgid "existing_enum_value" msgstr "valore_enum_esistente" -#: sql_help.c:1269 sql_help.c:1852 sql_help.c:2178 sql_help.c:2562 -#: sql_help.c:2959 sql_help.c:3130 sql_help.c:3165 sql_help.c:3462 +#: sql_help.c:1269 sql_help.c:1841 sql_help.c:2167 sql_help.c:2551 +#: sql_help.c:2948 sql_help.c:3119 sql_help.c:3154 sql_help.c:3451 msgid "server_name" msgstr "nome_server" -#: sql_help.c:1297 sql_help.c:1300 sql_help.c:2577 +#: sql_help.c:1297 sql_help.c:1300 sql_help.c:2566 msgid "view_option_name" msgstr "nome_opzione_vista" -#: sql_help.c:1298 sql_help.c:2578 +#: sql_help.c:1298 sql_help.c:2567 msgid "view_option_value" msgstr "valore_opzione_vista" -#: sql_help.c:1323 sql_help.c:3790 sql_help.c:3792 sql_help.c:3816 +#: sql_help.c:1323 sql_help.c:3779 sql_help.c:3781 sql_help.c:3805 msgid "transaction_mode" msgstr "modalità_transazione" -#: sql_help.c:1324 sql_help.c:3793 sql_help.c:3817 +#: sql_help.c:1324 sql_help.c:3782 sql_help.c:3806 msgid "where transaction_mode is one of:" msgstr "dove modalità_transazione è una di:" -#: sql_help.c:1407 +#: sql_help.c:1409 msgid "relation_name" msgstr "nome_relazione" -#: sql_help.c:1412 sql_help.c:3126 sql_help.c:3458 +#: sql_help.c:1414 sql_help.c:3115 sql_help.c:3447 msgid "domain_name" msgstr "nome_dominio" -#: sql_help.c:1434 +#: sql_help.c:1436 msgid "policy_name" msgstr "nome_regola" -#: sql_help.c:1438 +#: sql_help.c:1440 msgid "rule_name" msgstr "nome_ruolo" -#: sql_help.c:1455 +#: sql_help.c:1457 msgid "text" msgstr "testo" -#: sql_help.c:1480 sql_help.c:3308 sql_help.c:3496 +#: sql_help.c:1482 sql_help.c:3297 sql_help.c:3485 msgid "transaction_id" msgstr "id_transazione" -#: sql_help.c:1511 sql_help.c:1517 sql_help.c:3234 +#: sql_help.c:1513 sql_help.c:1519 sql_help.c:3223 msgid "filename" msgstr "nome_file" -#: sql_help.c:1512 sql_help.c:1518 sql_help.c:2121 sql_help.c:2122 -#: sql_help.c:2123 +#: sql_help.c:1514 sql_help.c:1520 sql_help.c:2110 sql_help.c:2111 +#: sql_help.c:2112 msgid "command" msgstr "comando" -#: sql_help.c:1516 sql_help.c:1992 sql_help.c:2321 sql_help.c:2579 -#: sql_help.c:2597 sql_help.c:3199 +#: sql_help.c:1518 sql_help.c:1981 sql_help.c:2310 sql_help.c:2568 +#: sql_help.c:2586 sql_help.c:3188 msgid "query" msgstr "query" -#: sql_help.c:1520 sql_help.c:3004 +#: sql_help.c:1522 sql_help.c:2993 msgid "where option can be one of:" msgstr "dove opzione può essere una di:" -#: sql_help.c:1521 +#: sql_help.c:1523 msgid "format_name" msgstr "nome_formato" -#: sql_help.c:1522 sql_help.c:1523 sql_help.c:1526 sql_help.c:3005 -#: sql_help.c:3006 sql_help.c:3007 sql_help.c:3008 sql_help.c:3009 +#: sql_help.c:1524 sql_help.c:1525 sql_help.c:1528 sql_help.c:2994 +#: sql_help.c:2995 sql_help.c:2996 sql_help.c:2997 sql_help.c:2998 msgid "boolean" msgstr "booleano" -#: sql_help.c:1524 +#: sql_help.c:1526 msgid "delimiter_character" msgstr "carattere_delimitatore" -#: sql_help.c:1525 +#: sql_help.c:1527 msgid "null_string" msgstr "stringa_nulla" -#: sql_help.c:1527 +#: sql_help.c:1529 msgid "quote_character" msgstr "carattere_virgolette" -#: sql_help.c:1528 +#: sql_help.c:1530 msgid "escape_character" msgstr "carattere_di_escape" -#: sql_help.c:1532 +#: sql_help.c:1534 msgid "encoding_name" msgstr "nome_codifica" -#: sql_help.c:1543 +#: sql_help.c:1545 msgid "access_method_type" msgstr "tipo_metodo_accesso" -#: sql_help.c:1616 sql_help.c:1636 sql_help.c:1639 +#: sql_help.c:1611 sql_help.c:1630 sql_help.c:1633 msgid "arg_data_type" msgstr "topo_dato_argomento" -#: sql_help.c:1617 sql_help.c:1640 sql_help.c:1652 +#: sql_help.c:1612 sql_help.c:1634 sql_help.c:1642 msgid "sfunc" msgstr "sfunz" -#: sql_help.c:1618 sql_help.c:1641 sql_help.c:1653 +#: sql_help.c:1613 sql_help.c:1635 sql_help.c:1643 msgid "state_data_type" msgstr "tipo_dato_stato" -#: sql_help.c:1619 sql_help.c:1642 sql_help.c:1654 +#: sql_help.c:1614 sql_help.c:1636 sql_help.c:1644 msgid "state_data_size" msgstr "dimensione_dato_stato" -#: sql_help.c:1620 sql_help.c:1643 sql_help.c:1655 +#: sql_help.c:1615 sql_help.c:1637 sql_help.c:1645 msgid "ffunc" msgstr "ffunz" -#: sql_help.c:1621 sql_help.c:1644 sql_help.c:1656 +#: sql_help.c:1616 sql_help.c:1646 msgid "combinefunc" msgstr "funz_combine" -#: sql_help.c:1622 sql_help.c:1645 sql_help.c:1657 +#: sql_help.c:1617 sql_help.c:1647 msgid "serialfunc" msgstr "funz_serial" -#: sql_help.c:1623 sql_help.c:1646 sql_help.c:1658 +#: sql_help.c:1618 sql_help.c:1648 msgid "deserialfunc" msgstr "funz_deserial" -#: sql_help.c:1624 sql_help.c:1647 sql_help.c:1659 -msgid "serialtype" -msgstr "tipo_serial" - -#: sql_help.c:1625 sql_help.c:1648 sql_help.c:1660 +#: sql_help.c:1619 sql_help.c:1638 sql_help.c:1649 msgid "initial_condition" msgstr "condizione_iniziale" -#: sql_help.c:1626 sql_help.c:1661 +#: sql_help.c:1620 sql_help.c:1650 msgid "msfunc" msgstr "msfunz" -#: sql_help.c:1627 sql_help.c:1662 +#: sql_help.c:1621 sql_help.c:1651 msgid "minvfunc" msgstr "minvfunz" -#: sql_help.c:1628 sql_help.c:1663 +#: sql_help.c:1622 sql_help.c:1652 msgid "mstate_data_type" msgstr "tipo_dato_mstato" -#: sql_help.c:1629 sql_help.c:1664 +#: sql_help.c:1623 sql_help.c:1653 msgid "mstate_data_size" msgstr "tipo_dato_mstato" -#: sql_help.c:1630 sql_help.c:1665 +#: sql_help.c:1624 sql_help.c:1654 msgid "mffunc" msgstr "mffunz" -#: sql_help.c:1631 sql_help.c:1666 +#: sql_help.c:1625 sql_help.c:1655 msgid "minitial_condition" msgstr "condizione_minima" -#: sql_help.c:1632 sql_help.c:1667 +#: sql_help.c:1626 sql_help.c:1656 msgid "sort_operator" msgstr "operatore_di_ordinamento" -#: sql_help.c:1649 +#: sql_help.c:1639 msgid "or the old syntax" msgstr "o la vecchia sintassi" -#: sql_help.c:1651 +#: sql_help.c:1641 msgid "base_type" msgstr "tipo_base" -#: sql_help.c:1706 +#: sql_help.c:1695 msgid "locale" msgstr "locale" -#: sql_help.c:1707 sql_help.c:1743 +#: sql_help.c:1696 sql_help.c:1732 msgid "lc_collate" msgstr "lc_collate" -#: sql_help.c:1708 sql_help.c:1744 +#: sql_help.c:1697 sql_help.c:1733 msgid "lc_ctype" msgstr "lc_ctype" -#: sql_help.c:1710 +#: sql_help.c:1699 msgid "existing_collation" msgstr "ordinamento_esistente" -#: sql_help.c:1720 +#: sql_help.c:1709 msgid "source_encoding" msgstr "codifica_origine" -#: sql_help.c:1721 +#: sql_help.c:1710 msgid "dest_encoding" msgstr "codifica_destinazione" -#: sql_help.c:1741 sql_help.c:2361 +#: sql_help.c:1730 sql_help.c:2350 msgid "template" msgstr "template" -#: sql_help.c:1742 +#: sql_help.c:1731 msgid "encoding" msgstr "codifica" -#: sql_help.c:1768 +#: sql_help.c:1757 msgid "constraint" msgstr "vincolo" -#: sql_help.c:1769 +#: sql_help.c:1758 msgid "where constraint is:" msgstr "dove vincolo di è:" -#: sql_help.c:1783 sql_help.c:2118 sql_help.c:2433 +#: sql_help.c:1772 sql_help.c:2107 sql_help.c:2422 msgid "event" msgstr "evento" -#: sql_help.c:1784 +#: sql_help.c:1773 msgid "filter_variable" msgstr "valiabile_filtro" -#: sql_help.c:1799 +#: sql_help.c:1788 msgid "version" msgstr "versione" -#: sql_help.c:1800 +#: sql_help.c:1789 msgid "old_version" msgstr "vecchia_versione" -#: sql_help.c:1855 sql_help.c:2267 +#: sql_help.c:1844 sql_help.c:2256 msgid "where column_constraint is:" msgstr "dove vincolo_di_colonna è:" -#: sql_help.c:1858 sql_help.c:1890 sql_help.c:2270 +#: sql_help.c:1847 sql_help.c:1879 sql_help.c:2259 msgid "default_expr" msgstr "expr_default" -#: sql_help.c:1859 sql_help.c:2277 +#: sql_help.c:1848 sql_help.c:2266 msgid "and table_constraint is:" msgstr "e vincolo_di_tabella è:" -#: sql_help.c:1891 +#: sql_help.c:1880 msgid "rettype" msgstr "tipo_ritorno" -#: sql_help.c:1893 +#: sql_help.c:1882 msgid "column_type" msgstr "tipo_colonna" -#: sql_help.c:1901 +#: sql_help.c:1890 msgid "definition" msgstr "definizione" -#: sql_help.c:1902 +#: sql_help.c:1891 msgid "obj_file" msgstr "file_obj" -#: sql_help.c:1903 +#: sql_help.c:1892 msgid "link_symbol" msgstr "simbolo_link" -#: sql_help.c:1904 +#: sql_help.c:1893 msgid "attribute" msgstr "attributo" -#: sql_help.c:1938 sql_help.c:2103 sql_help.c:2551 +#: sql_help.c:1927 sql_help.c:2092 sql_help.c:2540 msgid "uid" msgstr "uid" -#: sql_help.c:1952 +#: sql_help.c:1941 msgid "method" msgstr "metodo" -#: sql_help.c:1956 sql_help.c:2302 sql_help.c:3208 +#: sql_help.c:1945 sql_help.c:2291 sql_help.c:3197 msgid "opclass" msgstr "classe_op" -#: sql_help.c:1960 sql_help.c:2288 +#: sql_help.c:1949 sql_help.c:2277 msgid "predicate" msgstr "predicato" -#: sql_help.c:1972 +#: sql_help.c:1961 msgid "call_handler" msgstr "handler_chiamata" -#: sql_help.c:1973 +#: sql_help.c:1962 msgid "inline_handler" msgstr "handler_inline" -#: sql_help.c:1974 +#: sql_help.c:1963 msgid "valfunction" msgstr "funzione_valid" -#: sql_help.c:2010 +#: sql_help.c:1999 msgid "com_op" msgstr "com_op" -#: sql_help.c:2011 +#: sql_help.c:2000 msgid "neg_op" msgstr "neg_op" -#: sql_help.c:2029 +#: sql_help.c:2018 msgid "family_name" msgstr "nome_famiglia" -#: sql_help.c:2040 +#: sql_help.c:2029 msgid "storage_type" msgstr "tipo_memorizzazione" -#: sql_help.c:2120 sql_help.c:2436 sql_help.c:2613 sql_help.c:3218 -#: sql_help.c:3633 sql_help.c:3635 sql_help.c:3723 sql_help.c:3725 -#: sql_help.c:3872 sql_help.c:3874 sql_help.c:3977 sql_help.c:4066 -#: sql_help.c:4068 +#: sql_help.c:2109 sql_help.c:2425 sql_help.c:2602 sql_help.c:3207 +#: sql_help.c:3622 sql_help.c:3624 sql_help.c:3712 sql_help.c:3714 +#: sql_help.c:3861 sql_help.c:3863 sql_help.c:3966 sql_help.c:4055 +#: sql_help.c:4057 msgid "condition" msgstr "condizione" -#: sql_help.c:2124 sql_help.c:2439 +#: sql_help.c:2113 sql_help.c:2428 msgid "where event can be one of:" msgstr "dove evento può essere uno di:" -#: sql_help.c:2143 sql_help.c:2145 +#: sql_help.c:2132 sql_help.c:2134 msgid "schema_element" msgstr "elemento_di_schema" -#: sql_help.c:2179 +#: sql_help.c:2168 msgid "server_type" msgstr "tipo_di_server" -#: sql_help.c:2180 +#: sql_help.c:2169 msgid "server_version" msgstr "versione_server" -#: sql_help.c:2181 sql_help.c:3128 sql_help.c:3460 +#: sql_help.c:2170 sql_help.c:3117 sql_help.c:3449 msgid "fdw_name" msgstr "nome_fdw" -#: sql_help.c:2253 +#: sql_help.c:2242 msgid "source_table" msgstr "tabella_origine" -#: sql_help.c:2254 +#: sql_help.c:2243 msgid "like_option" msgstr "opzioni_di_like" -#: sql_help.c:2271 sql_help.c:2272 sql_help.c:2281 sql_help.c:2283 -#: sql_help.c:2287 +#: sql_help.c:2260 sql_help.c:2261 sql_help.c:2270 sql_help.c:2272 +#: sql_help.c:2276 msgid "index_parameters" msgstr "parametri_di_indice" -#: sql_help.c:2273 sql_help.c:2290 +#: sql_help.c:2262 sql_help.c:2279 msgid "reftable" msgstr "tabella_ref" -#: sql_help.c:2274 sql_help.c:2291 +#: sql_help.c:2263 sql_help.c:2280 msgid "refcolumn" msgstr "colonna_ref" -#: sql_help.c:2285 +#: sql_help.c:2274 msgid "exclude_element" msgstr "elemento_di_esclusione" -#: sql_help.c:2286 sql_help.c:3640 sql_help.c:3730 sql_help.c:3879 -#: sql_help.c:4008 sql_help.c:4073 +#: sql_help.c:2275 sql_help.c:3629 sql_help.c:3719 sql_help.c:3868 +#: sql_help.c:3997 sql_help.c:4062 msgid "operator" msgstr "operatore" -#: sql_help.c:2294 +#: sql_help.c:2283 msgid "and like_option is:" msgstr "e opzione_like è:" -#: sql_help.c:2295 +#: sql_help.c:2284 msgid "index_parameters in UNIQUE, PRIMARY KEY, and EXCLUDE constraints are:" msgstr "parametri_di_indice nei vincoli UNIQUE, PRIMARY KEY e EXCLUDE sono:" -#: sql_help.c:2299 +#: sql_help.c:2288 msgid "exclude_element in an EXCLUDE constraint is:" msgstr "elemento_di_esclusione in un vincolo EXCLUDE è:" -#: sql_help.c:2334 +#: sql_help.c:2323 msgid "directory" msgstr "directory" -#: sql_help.c:2348 +#: sql_help.c:2337 msgid "parser_name" msgstr "nome_parser" -#: sql_help.c:2349 +#: sql_help.c:2338 msgid "source_config" msgstr "config_origine" -#: sql_help.c:2378 +#: sql_help.c:2367 msgid "start_function" msgstr "funzione_inizio" -#: sql_help.c:2379 +#: sql_help.c:2368 msgid "gettoken_function" msgstr "funzione_gettoken" -#: sql_help.c:2380 +#: sql_help.c:2369 msgid "end_function" msgstr "funzione_fine" -#: sql_help.c:2381 +#: sql_help.c:2370 msgid "lextypes_function" msgstr "funzione_lextypes" -#: sql_help.c:2382 +#: sql_help.c:2371 msgid "headline_function" msgstr "funzione_headline" -#: sql_help.c:2394 +#: sql_help.c:2383 msgid "init_function" msgstr "funzione_init" -#: sql_help.c:2395 +#: sql_help.c:2384 msgid "lexize_function" msgstr "funzione_lexize" -#: sql_help.c:2408 +#: sql_help.c:2397 msgid "from_sql_function_name" msgstr "nome_funzione_from_sql" -#: sql_help.c:2410 +#: sql_help.c:2399 msgid "to_sql_function_name" msgstr "nome_funzione_to_sql" -#: sql_help.c:2435 +#: sql_help.c:2424 msgid "referenced_table_name" msgstr "nome_tabella_referenziata" -#: sql_help.c:2438 +#: sql_help.c:2427 msgid "arguments" msgstr "argomenti" -#: sql_help.c:2488 sql_help.c:3568 +#: sql_help.c:2477 sql_help.c:3557 msgid "label" msgstr "etichetta" -#: sql_help.c:2490 +#: sql_help.c:2479 msgid "subtype" msgstr "sottotipo" -#: sql_help.c:2491 +#: sql_help.c:2480 msgid "subtype_operator_class" msgstr "classe_operatore_sottotipo" -#: sql_help.c:2493 +#: sql_help.c:2482 msgid "canonical_function" msgstr "funzione_canonica" -#: sql_help.c:2494 +#: sql_help.c:2483 msgid "subtype_diff_function" msgstr "funzione_diff_sottotipo" -#: sql_help.c:2496 +#: sql_help.c:2485 msgid "input_function" msgstr "funzione_input" -#: sql_help.c:2497 +#: sql_help.c:2486 msgid "output_function" msgstr "funzione_output" -#: sql_help.c:2498 +#: sql_help.c:2487 msgid "receive_function" msgstr "funzione_receive" -#: sql_help.c:2499 +#: sql_help.c:2488 msgid "send_function" msgstr "funzione_send" -#: sql_help.c:2500 +#: sql_help.c:2489 msgid "type_modifier_input_function" msgstr "funzione_input_modificatore_tipo" -#: sql_help.c:2501 +#: sql_help.c:2490 msgid "type_modifier_output_function" msgstr "funzione_output_modificatore_tipo" -#: sql_help.c:2502 +#: sql_help.c:2491 msgid "analyze_function" msgstr "funzione_analyze" -#: sql_help.c:2503 +#: sql_help.c:2492 msgid "internallength" msgstr "lunghezza_interna" -#: sql_help.c:2504 +#: sql_help.c:2493 msgid "alignment" msgstr "allineamento" -#: sql_help.c:2505 +#: sql_help.c:2494 msgid "storage" msgstr "memorizzazione" -#: sql_help.c:2506 +#: sql_help.c:2495 msgid "like_type" msgstr "tipo_like" -#: sql_help.c:2507 +#: sql_help.c:2496 msgid "category" msgstr "categoria" -#: sql_help.c:2508 +#: sql_help.c:2497 msgid "preferred" msgstr "preferito" -#: sql_help.c:2509 +#: sql_help.c:2498 msgid "default" msgstr "predefinito" -#: sql_help.c:2510 +#: sql_help.c:2499 msgid "element" msgstr "elemento" -#: sql_help.c:2511 +#: sql_help.c:2500 msgid "delimiter" msgstr "delimitatore" -#: sql_help.c:2512 +#: sql_help.c:2501 msgid "collatable" msgstr "ordinabile" -#: sql_help.c:2609 sql_help.c:3194 sql_help.c:3628 sql_help.c:3717 -#: sql_help.c:3867 sql_help.c:3967 sql_help.c:4061 +#: sql_help.c:2598 sql_help.c:3183 sql_help.c:3617 sql_help.c:3706 +#: sql_help.c:3856 sql_help.c:3956 sql_help.c:4050 msgid "with_query" msgstr "query_with" -#: sql_help.c:2611 sql_help.c:3196 sql_help.c:3647 sql_help.c:3653 -#: sql_help.c:3656 sql_help.c:3660 sql_help.c:3664 sql_help.c:3672 -#: sql_help.c:3886 sql_help.c:3892 sql_help.c:3895 sql_help.c:3899 -#: sql_help.c:3903 sql_help.c:3911 sql_help.c:3969 sql_help.c:4080 -#: sql_help.c:4086 sql_help.c:4089 sql_help.c:4093 sql_help.c:4097 -#: sql_help.c:4105 +#: sql_help.c:2600 sql_help.c:3185 sql_help.c:3636 sql_help.c:3642 +#: sql_help.c:3645 sql_help.c:3649 sql_help.c:3653 sql_help.c:3661 +#: sql_help.c:3875 sql_help.c:3881 sql_help.c:3884 sql_help.c:3888 +#: sql_help.c:3892 sql_help.c:3900 sql_help.c:3958 sql_help.c:4069 +#: sql_help.c:4075 sql_help.c:4078 sql_help.c:4082 sql_help.c:4086 +#: sql_help.c:4094 msgid "alias" msgstr "alias" -#: sql_help.c:2612 +#: sql_help.c:2601 msgid "using_list" msgstr "lista_using" -#: sql_help.c:2614 sql_help.c:3035 sql_help.c:3275 sql_help.c:3978 +#: sql_help.c:2603 sql_help.c:3024 sql_help.c:3264 sql_help.c:3967 msgid "cursor_name" msgstr "nome_cursore" -#: sql_help.c:2615 sql_help.c:3202 sql_help.c:3979 +#: sql_help.c:2604 sql_help.c:3191 sql_help.c:3968 msgid "output_expression" msgstr "espressione_output" -#: sql_help.c:2616 sql_help.c:3203 sql_help.c:3631 sql_help.c:3720 -#: sql_help.c:3870 sql_help.c:3980 sql_help.c:4064 +#: sql_help.c:2605 sql_help.c:3192 sql_help.c:3620 sql_help.c:3709 +#: sql_help.c:3859 sql_help.c:3969 sql_help.c:4053 msgid "output_name" msgstr "nome_output" -#: sql_help.c:2632 +#: sql_help.c:2621 msgid "code" msgstr "codice" -#: sql_help.c:2983 +#: sql_help.c:2972 msgid "parameter" msgstr "parametro" -#: sql_help.c:3002 sql_help.c:3003 sql_help.c:3300 +#: sql_help.c:2991 sql_help.c:2992 sql_help.c:3289 msgid "statement" msgstr "istruzione" -#: sql_help.c:3034 sql_help.c:3274 +#: sql_help.c:3023 sql_help.c:3263 msgid "direction" msgstr "direzione" -#: sql_help.c:3036 sql_help.c:3276 +#: sql_help.c:3025 sql_help.c:3265 msgid "where direction can be empty or one of:" msgstr "dove direzione può essere vuota o una di:" -#: sql_help.c:3037 sql_help.c:3038 sql_help.c:3039 sql_help.c:3040 -#: sql_help.c:3041 sql_help.c:3277 sql_help.c:3278 sql_help.c:3279 -#: sql_help.c:3280 sql_help.c:3281 sql_help.c:3641 sql_help.c:3643 -#: sql_help.c:3731 sql_help.c:3733 sql_help.c:3880 sql_help.c:3882 -#: sql_help.c:4009 sql_help.c:4011 sql_help.c:4074 sql_help.c:4076 +#: sql_help.c:3026 sql_help.c:3027 sql_help.c:3028 sql_help.c:3029 +#: sql_help.c:3030 sql_help.c:3266 sql_help.c:3267 sql_help.c:3268 +#: sql_help.c:3269 sql_help.c:3270 sql_help.c:3630 sql_help.c:3632 +#: sql_help.c:3720 sql_help.c:3722 sql_help.c:3869 sql_help.c:3871 +#: sql_help.c:3998 sql_help.c:4000 sql_help.c:4063 sql_help.c:4065 msgid "count" msgstr "conteggio" -#: sql_help.c:3121 sql_help.c:3453 +#: sql_help.c:3110 sql_help.c:3442 msgid "sequence_name" msgstr "nome_sequenza" -#: sql_help.c:3134 sql_help.c:3466 +#: sql_help.c:3123 sql_help.c:3455 msgid "arg_name" msgstr "nome_arg" -#: sql_help.c:3135 sql_help.c:3467 +#: sql_help.c:3124 sql_help.c:3456 msgid "arg_type" msgstr "tipo_arg" -#: sql_help.c:3140 sql_help.c:3472 +#: sql_help.c:3129 sql_help.c:3461 msgid "loid" msgstr "loid" -#: sql_help.c:3163 +#: sql_help.c:3152 msgid "remote_schema" msgstr "schema_remoto" -#: sql_help.c:3166 +#: sql_help.c:3155 msgid "local_schema" msgstr "schema_locale" -#: sql_help.c:3200 +#: sql_help.c:3189 msgid "conflict_target" msgstr "target_conflitto" -#: sql_help.c:3201 +#: sql_help.c:3190 msgid "conflict_action" msgstr "azione_conflitto" -#: sql_help.c:3204 +#: sql_help.c:3193 msgid "where conflict_target can be one of:" msgstr "dove target_conflitto può essere uno di:" -#: sql_help.c:3205 +#: sql_help.c:3194 msgid "index_column_name" msgstr "nome_colonna_indice" -#: sql_help.c:3206 +#: sql_help.c:3195 msgid "index_expression" msgstr "espressione_indice" -#: sql_help.c:3209 +#: sql_help.c:3198 msgid "index_predicate" msgstr "indice_predicato" -#: sql_help.c:3211 +#: sql_help.c:3200 msgid "and conflict_action is one of:" msgstr "e azione_conflitto è una di:" -#: sql_help.c:3217 sql_help.c:3975 +#: sql_help.c:3206 sql_help.c:3964 msgid "sub-SELECT" msgstr "sub-SELECT" -#: sql_help.c:3226 sql_help.c:3289 sql_help.c:3951 +#: sql_help.c:3215 sql_help.c:3278 sql_help.c:3940 msgid "channel" msgstr "canale" -#: sql_help.c:3248 +#: sql_help.c:3237 msgid "lockmode" msgstr "modalità_lock" -#: sql_help.c:3249 +#: sql_help.c:3238 msgid "where lockmode is one of:" msgstr "dove modalità_lock è una di:" -#: sql_help.c:3290 +#: sql_help.c:3279 msgid "payload" msgstr "payload" -#: sql_help.c:3317 +#: sql_help.c:3306 msgid "old_role" msgstr "vecchio_ruolo" -#: sql_help.c:3318 +#: sql_help.c:3307 msgid "new_role" msgstr "nuovo_ruolo" -#: sql_help.c:3343 sql_help.c:3504 sql_help.c:3512 +#: sql_help.c:3332 sql_help.c:3493 sql_help.c:3501 msgid "savepoint_name" msgstr "nome_punto_salvataggio" -#: sql_help.c:3545 +#: sql_help.c:3534 msgid "provider" msgstr "provider" -#: sql_help.c:3632 sql_help.c:3674 sql_help.c:3676 sql_help.c:3722 -#: sql_help.c:3871 sql_help.c:3913 sql_help.c:3915 sql_help.c:4065 -#: sql_help.c:4107 sql_help.c:4109 +#: sql_help.c:3621 sql_help.c:3663 sql_help.c:3665 sql_help.c:3711 +#: sql_help.c:3860 sql_help.c:3902 sql_help.c:3904 sql_help.c:4054 +#: sql_help.c:4096 sql_help.c:4098 msgid "from_item" msgstr "elemento_from" -#: sql_help.c:3634 sql_help.c:3686 sql_help.c:3873 sql_help.c:3925 -#: sql_help.c:4067 sql_help.c:4119 +#: sql_help.c:3623 sql_help.c:3675 sql_help.c:3862 sql_help.c:3914 +#: sql_help.c:4056 sql_help.c:4108 msgid "grouping_element" msgstr "elemento_raggruppante" -#: sql_help.c:3636 sql_help.c:3726 sql_help.c:3875 sql_help.c:4069 +#: sql_help.c:3625 sql_help.c:3715 sql_help.c:3864 sql_help.c:4058 msgid "window_name" msgstr "nome_finestra" -#: sql_help.c:3637 sql_help.c:3727 sql_help.c:3876 sql_help.c:4070 +#: sql_help.c:3626 sql_help.c:3716 sql_help.c:3865 sql_help.c:4059 msgid "window_definition" msgstr "definizione_finestra" -#: sql_help.c:3638 sql_help.c:3652 sql_help.c:3690 sql_help.c:3728 -#: sql_help.c:3877 sql_help.c:3891 sql_help.c:3929 sql_help.c:4071 -#: sql_help.c:4085 sql_help.c:4123 +#: sql_help.c:3627 sql_help.c:3641 sql_help.c:3679 sql_help.c:3717 +#: sql_help.c:3866 sql_help.c:3880 sql_help.c:3918 sql_help.c:4060 +#: sql_help.c:4074 sql_help.c:4112 msgid "select" msgstr "select" -#: sql_help.c:3645 sql_help.c:3884 sql_help.c:4078 +#: sql_help.c:3634 sql_help.c:3873 sql_help.c:4067 msgid "where from_item can be one of:" msgstr "dove from_item può essere uno di:" -#: sql_help.c:3648 sql_help.c:3654 sql_help.c:3657 sql_help.c:3661 -#: sql_help.c:3673 sql_help.c:3887 sql_help.c:3893 sql_help.c:3896 -#: sql_help.c:3900 sql_help.c:3912 sql_help.c:4081 sql_help.c:4087 -#: sql_help.c:4090 sql_help.c:4094 sql_help.c:4106 +#: sql_help.c:3637 sql_help.c:3643 sql_help.c:3646 sql_help.c:3650 +#: sql_help.c:3662 sql_help.c:3876 sql_help.c:3882 sql_help.c:3885 +#: sql_help.c:3889 sql_help.c:3901 sql_help.c:4070 sql_help.c:4076 +#: sql_help.c:4079 sql_help.c:4083 sql_help.c:4095 msgid "column_alias" msgstr "alias_colonna" -#: sql_help.c:3649 sql_help.c:3888 sql_help.c:4082 +#: sql_help.c:3638 sql_help.c:3877 sql_help.c:4071 msgid "sampling_method" msgstr "metodo_di_campionamento" -#: sql_help.c:3650 sql_help.c:3659 sql_help.c:3663 sql_help.c:3667 -#: sql_help.c:3670 sql_help.c:3889 sql_help.c:3898 sql_help.c:3902 -#: sql_help.c:3906 sql_help.c:3909 sql_help.c:4083 sql_help.c:4092 -#: sql_help.c:4096 sql_help.c:4100 sql_help.c:4103 +#: sql_help.c:3639 sql_help.c:3648 sql_help.c:3652 sql_help.c:3656 +#: sql_help.c:3659 sql_help.c:3878 sql_help.c:3887 sql_help.c:3891 +#: sql_help.c:3895 sql_help.c:3898 sql_help.c:4072 sql_help.c:4081 +#: sql_help.c:4085 sql_help.c:4089 sql_help.c:4092 msgid "argument" msgstr "argomento" -#: sql_help.c:3651 sql_help.c:3890 sql_help.c:4084 +#: sql_help.c:3640 sql_help.c:3879 sql_help.c:4073 msgid "seed" msgstr "seme" -#: sql_help.c:3655 sql_help.c:3688 sql_help.c:3894 sql_help.c:3927 -#: sql_help.c:4088 sql_help.c:4121 +#: sql_help.c:3644 sql_help.c:3677 sql_help.c:3883 sql_help.c:3916 +#: sql_help.c:4077 sql_help.c:4110 msgid "with_query_name" msgstr "nome_query_with" -#: sql_help.c:3665 sql_help.c:3668 sql_help.c:3671 sql_help.c:3904 -#: sql_help.c:3907 sql_help.c:3910 sql_help.c:4098 sql_help.c:4101 -#: sql_help.c:4104 +#: sql_help.c:3654 sql_help.c:3657 sql_help.c:3660 sql_help.c:3893 +#: sql_help.c:3896 sql_help.c:3899 sql_help.c:4087 sql_help.c:4090 +#: sql_help.c:4093 msgid "column_definition" msgstr "definizione_colonna" -#: sql_help.c:3675 sql_help.c:3914 sql_help.c:4108 +#: sql_help.c:3664 sql_help.c:3903 sql_help.c:4097 msgid "join_type" msgstr "tipo_join" -#: sql_help.c:3677 sql_help.c:3916 sql_help.c:4110 +#: sql_help.c:3666 sql_help.c:3905 sql_help.c:4099 msgid "join_condition" msgstr "condizione_join" -#: sql_help.c:3678 sql_help.c:3917 sql_help.c:4111 +#: sql_help.c:3667 sql_help.c:3906 sql_help.c:4100 msgid "join_column" msgstr "colonna_join" -#: sql_help.c:3679 sql_help.c:3918 sql_help.c:4112 +#: sql_help.c:3668 sql_help.c:3907 sql_help.c:4101 msgid "and grouping_element can be one of:" msgstr "e elemento_raggruppante può essere uno di:" -#: sql_help.c:3687 sql_help.c:3926 sql_help.c:4120 +#: sql_help.c:3676 sql_help.c:3915 sql_help.c:4109 msgid "and with_query is:" msgstr "e with_query è:" -#: sql_help.c:3691 sql_help.c:3930 sql_help.c:4124 +#: sql_help.c:3680 sql_help.c:3919 sql_help.c:4113 msgid "values" msgstr "valori" -#: sql_help.c:3692 sql_help.c:3931 sql_help.c:4125 +#: sql_help.c:3681 sql_help.c:3920 sql_help.c:4114 msgid "insert" msgstr "insert" -#: sql_help.c:3693 sql_help.c:3932 sql_help.c:4126 +#: sql_help.c:3682 sql_help.c:3921 sql_help.c:4115 msgid "update" msgstr "update" -#: sql_help.c:3694 sql_help.c:3933 sql_help.c:4127 +#: sql_help.c:3683 sql_help.c:3922 sql_help.c:4116 msgid "delete" msgstr "delete" -#: sql_help.c:3721 +#: sql_help.c:3710 msgid "new_table" msgstr "nuova_tabella" -#: sql_help.c:3746 +#: sql_help.c:3735 msgid "timezone" msgstr "timezone" -#: sql_help.c:3791 +#: sql_help.c:3780 msgid "snapshot_id" msgstr "id_snapshot" -#: sql_help.c:3976 +#: sql_help.c:3965 msgid "from_list" msgstr "lista_from" -#: sql_help.c:4007 +#: sql_help.c:3996 msgid "sort_expression" msgstr "espressione_ordinamento" -#: sql_help.c:4134 sql_help.c:4874 +#: sql_help.c:4123 sql_help.c:4863 msgid "abort the current transaction" msgstr "annulla la transazione corrente" -#: sql_help.c:4139 +#: sql_help.c:4128 msgid "change the definition of an aggregate function" msgstr "cambia la definizione di una funzione di aggregazione" -#: sql_help.c:4144 +#: sql_help.c:4133 msgid "change the definition of a collation" msgstr "cambia la definizione di un ordinamento" -#: sql_help.c:4149 +#: sql_help.c:4138 msgid "change the definition of a conversion" msgstr "cambia la definizione di una conversione" -#: sql_help.c:4154 +#: sql_help.c:4143 msgid "change a database" msgstr "cambia un database" -#: sql_help.c:4159 +#: sql_help.c:4148 msgid "define default access privileges" msgstr "definisci i privilegi di accesso di default" -#: sql_help.c:4164 +#: sql_help.c:4153 msgid "change the definition of a domain" msgstr "cambia la definizione di un dominio" -#: sql_help.c:4169 +#: sql_help.c:4158 msgid "change the definition of an event trigger" msgstr "cambia la definizione di un trigger di evento" -#: sql_help.c:4174 +#: sql_help.c:4163 msgid "change the definition of an extension" msgstr "cambia la definizione di una estensione" -#: sql_help.c:4179 +#: sql_help.c:4168 msgid "change the definition of a foreign-data wrapper" msgstr "cambia la definizione di un wrapper di dati esterni" -#: sql_help.c:4184 +#: sql_help.c:4173 msgid "change the definition of a foreign table" msgstr "cambia la definizione di una tabella esterna" -#: sql_help.c:4189 +#: sql_help.c:4178 msgid "change the definition of a function" msgstr "cambia la definizione di una funzione" -#: sql_help.c:4194 +#: sql_help.c:4183 msgid "change role name or membership" msgstr "cambia il nome del ruolo o l'appartenenza" -#: sql_help.c:4199 +#: sql_help.c:4188 msgid "change the definition of an index" msgstr "cambia la definizione di un indice" -#: sql_help.c:4204 +#: sql_help.c:4193 msgid "change the definition of a procedural language" msgstr "cambia la definizione di un linguaggio procedurale" -#: sql_help.c:4209 +#: sql_help.c:4198 msgid "change the definition of a large object" msgstr "cambia la definizione di un large object" -#: sql_help.c:4214 +#: sql_help.c:4203 msgid "change the definition of a materialized view" msgstr "cambia la definizione di una vista materializzata" -#: sql_help.c:4219 +#: sql_help.c:4208 msgid "change the definition of an operator" msgstr "cambia la definizione di un operatore" -#: sql_help.c:4224 +#: sql_help.c:4213 msgid "change the definition of an operator class" msgstr "cambia la definizione di una classe di operatori" -#: sql_help.c:4229 +#: sql_help.c:4218 msgid "change the definition of an operator family" msgstr "cambia la definizione di una famiglia di operatori" -#: sql_help.c:4234 +#: sql_help.c:4223 msgid "change the definition of a row level security policy" msgstr "cambia la definizione di una regola di sicurezza per riga" -#: sql_help.c:4239 sql_help.c:4309 +#: sql_help.c:4228 sql_help.c:4298 msgid "change a database role" msgstr "cambia un ruolo di database" -#: sql_help.c:4244 +#: sql_help.c:4233 msgid "change the definition of a rule" msgstr "cambia la definizione di una regola" -#: sql_help.c:4249 +#: sql_help.c:4238 msgid "change the definition of a schema" msgstr "cambia la definizione di uno schema" -#: sql_help.c:4254 +#: sql_help.c:4243 msgid "change the definition of a sequence generator" msgstr "cambia la definizione di un generatore di sequenza" -#: sql_help.c:4259 +#: sql_help.c:4248 msgid "change the definition of a foreign server" msgstr "cambia la definizione di un server esterno" -#: sql_help.c:4264 +#: sql_help.c:4253 msgid "change a server configuration parameter" msgstr "cambia un parametro di configurazione del server" -#: sql_help.c:4269 +#: sql_help.c:4258 msgid "change the definition of a table" msgstr "cambia la definizione di una tabella" -#: sql_help.c:4274 +#: sql_help.c:4263 msgid "change the definition of a tablespace" msgstr "cambia la definizione di un tablespace" -#: sql_help.c:4279 +#: sql_help.c:4268 msgid "change the definition of a text search configuration" msgstr "cambia la definizione di una configurazione di ricerca testo" -#: sql_help.c:4284 +#: sql_help.c:4273 msgid "change the definition of a text search dictionary" msgstr "cambia la definizione di un dizionario di ricerca testo" -#: sql_help.c:4289 +#: sql_help.c:4278 msgid "change the definition of a text search parser" msgstr "cambia la definizione di un analizzatore di ricerca testo" -#: sql_help.c:4294 +#: sql_help.c:4283 msgid "change the definition of a text search template" msgstr "cambia la definizione di un modello di ricerca testo" -#: sql_help.c:4299 +#: sql_help.c:4288 msgid "change the definition of a trigger" msgstr "cambia la definizione di un trigger" -#: sql_help.c:4304 +#: sql_help.c:4293 msgid "change the definition of a type" msgstr "cambia la definizione di un tipo di dato" -#: sql_help.c:4314 +#: sql_help.c:4303 msgid "change the definition of a user mapping" msgstr "cambia la definizione di una mappatura degli" -#: sql_help.c:4319 +#: sql_help.c:4308 msgid "change the definition of a view" msgstr "cambia la definizione di una vista" -#: sql_help.c:4324 +#: sql_help.c:4313 msgid "collect statistics about a database" msgstr "raccogli statistiche sul database" -#: sql_help.c:4329 sql_help.c:4939 +#: sql_help.c:4318 sql_help.c:4928 msgid "start a transaction block" msgstr "avvia un blocco di transazione" -#: sql_help.c:4334 +#: sql_help.c:4323 msgid "force a transaction log checkpoint" msgstr "forza un punto di controllo nel log delle transazioni" -#: sql_help.c:4339 +#: sql_help.c:4328 msgid "close a cursor" msgstr "chiudi un cursore" -#: sql_help.c:4344 +#: sql_help.c:4333 msgid "cluster a table according to an index" msgstr "raggruppa una tabella in base ad un indice" -#: sql_help.c:4349 +#: sql_help.c:4338 msgid "define or change the comment of an object" msgstr "definisci o modifica il commento di un oggetto" -#: sql_help.c:4354 sql_help.c:4774 +#: sql_help.c:4343 sql_help.c:4763 msgid "commit the current transaction" msgstr "rendi persistente la transazione corrente" -#: sql_help.c:4359 +#: sql_help.c:4348 msgid "commit a transaction that was earlier prepared for two-phase commit" msgstr "concludi transazione che è stata precedentemente preparata per un commit a due fasi" -#: sql_help.c:4364 +#: sql_help.c:4353 msgid "copy data between a file and a table" msgstr "copia i dati tra un file ed una tabella" -#: sql_help.c:4369 +#: sql_help.c:4358 msgid "define a new access method" msgstr "definisci un nuovo metodo di accesso" -#: sql_help.c:4374 +#: sql_help.c:4363 msgid "define a new aggregate function" msgstr "definisci una nuova funzione aggregata" -#: sql_help.c:4379 +#: sql_help.c:4368 msgid "define a new cast" msgstr "definisci una nuova conversione di tipi" -#: sql_help.c:4384 +#: sql_help.c:4373 msgid "define a new collation" msgstr "definisci un nuovo ordinamento" -#: sql_help.c:4389 +#: sql_help.c:4378 msgid "define a new encoding conversion" msgstr "definisci una nuova conversione di codifica" -#: sql_help.c:4394 +#: sql_help.c:4383 msgid "create a new database" msgstr "crea un nuovo database" -#: sql_help.c:4399 +#: sql_help.c:4388 msgid "define a new domain" msgstr "definisci un nuovo dominio" -#: sql_help.c:4404 +#: sql_help.c:4393 msgid "define a new event trigger" msgstr "definisci un nuovo trigger di evento" -#: sql_help.c:4409 +#: sql_help.c:4398 msgid "install an extension" msgstr "installa un'estensione" -#: sql_help.c:4414 +#: sql_help.c:4403 msgid "define a new foreign-data wrapper" msgstr "definisci un nuovo wrapper di dati esterni" -#: sql_help.c:4419 +#: sql_help.c:4408 msgid "define a new foreign table" msgstr "definisci una nuova tabella esterna" -#: sql_help.c:4424 +#: sql_help.c:4413 msgid "define a new function" msgstr "definisci una nuova funzione" -#: sql_help.c:4429 sql_help.c:4469 sql_help.c:4544 +#: sql_help.c:4418 sql_help.c:4458 sql_help.c:4533 msgid "define a new database role" msgstr "definisci un nuovo ruolo database" -#: sql_help.c:4434 +#: sql_help.c:4423 msgid "define a new index" msgstr "crea un nuovo indice" -#: sql_help.c:4439 +#: sql_help.c:4428 msgid "define a new procedural language" msgstr "definisci un nuovo linguaggio procedurale" -#: sql_help.c:4444 +#: sql_help.c:4433 msgid "define a new materialized view" msgstr "definisci una nuova vista materializzata" -#: sql_help.c:4449 +#: sql_help.c:4438 msgid "define a new operator" msgstr "definisci un nuovo operatore" -#: sql_help.c:4454 +#: sql_help.c:4443 msgid "define a new operator class" msgstr "definisci una nuova classe di operatori" -#: sql_help.c:4459 +#: sql_help.c:4448 msgid "define a new operator family" msgstr "definisci una nuova famiglia operatore" -#: sql_help.c:4464 +#: sql_help.c:4453 msgid "define a new row level security policy for a table" msgstr "definisci una nuova regola di sicurezza per riga per una tabella" -#: sql_help.c:4474 +#: sql_help.c:4463 msgid "define a new rewrite rule" msgstr "definisci una nuova regola di riscrittura" -#: sql_help.c:4479 +#: sql_help.c:4468 msgid "define a new schema" msgstr "crea un nuovo schema" -#: sql_help.c:4484 +#: sql_help.c:4473 msgid "define a new sequence generator" msgstr "definisci un nuovo generatore di sequenze" -#: sql_help.c:4489 +#: sql_help.c:4478 msgid "define a new foreign server" msgstr "definisci un nuovo server esterno" -#: sql_help.c:4494 +#: sql_help.c:4483 msgid "define a new table" msgstr "crea una nuova tabella" -#: sql_help.c:4499 sql_help.c:4904 +#: sql_help.c:4488 sql_help.c:4893 msgid "define a new table from the results of a query" msgstr "crea una nuova tabella dai risultati di una query" -#: sql_help.c:4504 +#: sql_help.c:4493 msgid "define a new tablespace" msgstr "crea un nuovo tablespace" -#: sql_help.c:4509 +#: sql_help.c:4498 msgid "define a new text search configuration" msgstr "definisci una nuova configurazione di ricerca testo" -#: sql_help.c:4514 +#: sql_help.c:4503 msgid "define a new text search dictionary" msgstr "definisci un nuovo dizionario di ricerca testo" -#: sql_help.c:4519 +#: sql_help.c:4508 msgid "define a new text search parser" msgstr "definisci un nuovo analizzatore di ricerca testo" -#: sql_help.c:4524 +#: sql_help.c:4513 msgid "define a new text search template" msgstr "definisci un nuovo modello di ricerca testo" -#: sql_help.c:4529 +#: sql_help.c:4518 msgid "define a new transform" msgstr "definisci una nuova trasformazione" -#: sql_help.c:4534 +#: sql_help.c:4523 msgid "define a new trigger" msgstr "definisci un nuovo trigger" -#: sql_help.c:4539 +#: sql_help.c:4528 msgid "define a new data type" msgstr "definisci un nuovo tipo di dato" -#: sql_help.c:4549 +#: sql_help.c:4538 msgid "define a new mapping of a user to a foreign server" msgstr "definisci una nuova mappatura di un utente ad un server esterno" -#: sql_help.c:4554 +#: sql_help.c:4543 msgid "define a new view" msgstr "definisci una nuova vista" -#: sql_help.c:4559 +#: sql_help.c:4548 msgid "deallocate a prepared statement" msgstr "dealloca una istruzione preparata" -#: sql_help.c:4564 +#: sql_help.c:4553 msgid "define a cursor" msgstr "definisci un cursore" -#: sql_help.c:4569 +#: sql_help.c:4558 msgid "delete rows of a table" msgstr "elimina le righe di una tabella" -#: sql_help.c:4574 +#: sql_help.c:4563 msgid "discard session state" msgstr "cancella lo stato della sessione" -#: sql_help.c:4579 +#: sql_help.c:4568 msgid "execute an anonymous code block" msgstr "esegui un blocco di codice anonimo" -#: sql_help.c:4584 +#: sql_help.c:4573 msgid "remove an access method" msgstr "rimuovi un metodo di accesso" -#: sql_help.c:4589 +#: sql_help.c:4578 msgid "remove an aggregate function" msgstr "elimina una funzione aggregata" -#: sql_help.c:4594 +#: sql_help.c:4583 msgid "remove a cast" msgstr "elimina una conversione di tipi" -#: sql_help.c:4599 +#: sql_help.c:4588 msgid "remove a collation" msgstr "elimina un ordinamento" -#: sql_help.c:4604 +#: sql_help.c:4593 msgid "remove a conversion" msgstr "elimina una conversione" -#: sql_help.c:4609 +#: sql_help.c:4598 msgid "remove a database" msgstr "elimina un database" -#: sql_help.c:4614 +#: sql_help.c:4603 msgid "remove a domain" msgstr "elimina un dominio" -#: sql_help.c:4619 +#: sql_help.c:4608 msgid "remove an event trigger" msgstr "elimina un trigger di evento" -#: sql_help.c:4624 +#: sql_help.c:4613 msgid "remove an extension" msgstr "elimina una estensione" -#: sql_help.c:4629 +#: sql_help.c:4618 msgid "remove a foreign-data wrapper" msgstr "elimina un wrapper di dati esterni" -#: sql_help.c:4634 +#: sql_help.c:4623 msgid "remove a foreign table" msgstr "elimina una tabella esterna" -#: sql_help.c:4639 +#: sql_help.c:4628 msgid "remove a function" msgstr "elimina una funzione" -#: sql_help.c:4644 sql_help.c:4689 sql_help.c:4759 +#: sql_help.c:4633 sql_help.c:4678 sql_help.c:4748 msgid "remove a database role" msgstr "elimina un ruolo di database" -#: sql_help.c:4649 +#: sql_help.c:4638 msgid "remove an index" msgstr "elimina un indice" -#: sql_help.c:4654 +#: sql_help.c:4643 msgid "remove a procedural language" msgstr "elimina un linguaggio procedurale" -#: sql_help.c:4659 +#: sql_help.c:4648 msgid "remove a materialized view" msgstr "elimina una vista materializzata" -#: sql_help.c:4664 +#: sql_help.c:4653 msgid "remove an operator" msgstr "elimina un operatore" -#: sql_help.c:4669 +#: sql_help.c:4658 msgid "remove an operator class" msgstr "elimina una classe di operatori" -#: sql_help.c:4674 +#: sql_help.c:4663 msgid "remove an operator family" msgstr "elimina una famiglia operatore" -#: sql_help.c:4679 +#: sql_help.c:4668 msgid "remove database objects owned by a database role" msgstr "elimina gli oggetti database di proprietà di un ruolo di database" -#: sql_help.c:4684 +#: sql_help.c:4673 msgid "remove a row level security policy from a table" msgstr "rimuovi una regola di sicurezza per riga da una tabella" -#: sql_help.c:4694 +#: sql_help.c:4683 msgid "remove a rewrite rule" msgstr "elimina una regola di riscrittura" -#: sql_help.c:4699 +#: sql_help.c:4688 msgid "remove a schema" msgstr "elimina uno schema" -#: sql_help.c:4704 +#: sql_help.c:4693 msgid "remove a sequence" msgstr "elimina una sequenza" -#: sql_help.c:4709 +#: sql_help.c:4698 msgid "remove a foreign server descriptor" msgstr "elimina una descrizione server esterno" -#: sql_help.c:4714 +#: sql_help.c:4703 msgid "remove a table" msgstr "elimina una tabella" -#: sql_help.c:4719 +#: sql_help.c:4708 msgid "remove a tablespace" msgstr "elimina un tablespace" -#: sql_help.c:4724 +#: sql_help.c:4713 msgid "remove a text search configuration" msgstr "elimina una configurazione di ricerca testo" -#: sql_help.c:4729 +#: sql_help.c:4718 msgid "remove a text search dictionary" msgstr "elimina un dizionario di ricerca testo" -#: sql_help.c:4734 +#: sql_help.c:4723 msgid "remove a text search parser" msgstr "elimina un analizzatore di ricerca testo" -#: sql_help.c:4739 +#: sql_help.c:4728 msgid "remove a text search template" msgstr "elimina un modello di ricerca testo" -#: sql_help.c:4744 +#: sql_help.c:4733 msgid "remove a transform" msgstr "elimina una trasformazione" -#: sql_help.c:4749 +#: sql_help.c:4738 msgid "remove a trigger" msgstr "elimina un trigger" -#: sql_help.c:4754 +#: sql_help.c:4743 msgid "remove a data type" msgstr "elimina un tipo di dato" -#: sql_help.c:4764 +#: sql_help.c:4753 msgid "remove a user mapping for a foreign server" msgstr "elimina la mappatura degli utenti per un server esterno" -#: sql_help.c:4769 +#: sql_help.c:4758 msgid "remove a view" msgstr "elimina una vista" -#: sql_help.c:4779 +#: sql_help.c:4768 msgid "execute a prepared statement" msgstr "esegui una istruzione preparata" -#: sql_help.c:4784 +#: sql_help.c:4773 msgid "show the execution plan of a statement" msgstr "mostra il piano di esecuzione di una istruzione" -#: sql_help.c:4789 +#: sql_help.c:4778 msgid "retrieve rows from a query using a cursor" msgstr "estrai delle righe da una query utilizzando un cursore" -#: sql_help.c:4794 +#: sql_help.c:4783 msgid "define access privileges" msgstr "definisci i privilegi di accesso" -#: sql_help.c:4799 +#: sql_help.c:4788 msgid "import table definitions from a foreign server" msgstr "importa le definizioni di tabella da un server remoto" -#: sql_help.c:4804 +#: sql_help.c:4793 msgid "create new rows in a table" msgstr "crea nuove righe in una tabella" -#: sql_help.c:4809 +#: sql_help.c:4798 msgid "listen for a notification" msgstr "attendi l'arrivo di notifiche" -#: sql_help.c:4814 +#: sql_help.c:4803 msgid "load a shared library file" msgstr "carica un file di libreria condivisa" -#: sql_help.c:4819 +#: sql_help.c:4808 msgid "lock a table" msgstr "blocca una tabella" -#: sql_help.c:4824 +#: sql_help.c:4813 msgid "position a cursor" msgstr "posiziona un cursore" -#: sql_help.c:4829 +#: sql_help.c:4818 msgid "generate a notification" msgstr "genera una notifica" -#: sql_help.c:4834 +#: sql_help.c:4823 msgid "prepare a statement for execution" msgstr "prepara una istruzione per l'esecuzione" -#: sql_help.c:4839 +#: sql_help.c:4828 msgid "prepare the current transaction for two-phase commit" msgstr "prepara la transazione corrente per un commit a due fasi" -#: sql_help.c:4844 +#: sql_help.c:4833 msgid "change the ownership of database objects owned by a database role" msgstr "cambia il proprietario degli oggetti del database posseduti da un ruolo" -#: sql_help.c:4849 +#: sql_help.c:4838 msgid "replace the contents of a materialized view" msgstr "sostituisci il contenuto di una vista materializzata" -#: sql_help.c:4854 +#: sql_help.c:4843 msgid "rebuild indexes" msgstr "ricostruisci indici" -#: sql_help.c:4859 +#: sql_help.c:4848 msgid "destroy a previously defined savepoint" msgstr "distruggi un punto di salvataggio precedentemente definito" -#: sql_help.c:4864 +#: sql_help.c:4853 msgid "restore the value of a run-time parameter to the default value" msgstr "ripristina un parametro di esecuzione al suo valore di predefinito" -#: sql_help.c:4869 +#: sql_help.c:4858 msgid "remove access privileges" msgstr "elimina i privilegi di accesso" -#: sql_help.c:4879 +#: sql_help.c:4868 msgid "cancel a transaction that was earlier prepared for two-phase commit" msgstr "annulla una transazione che era stata preparata per un commit a due fasi" -#: sql_help.c:4884 +#: sql_help.c:4873 msgid "roll back to a savepoint" msgstr "annulla le modifiche fino a un punto di salvataggio" -#: sql_help.c:4889 +#: sql_help.c:4878 msgid "define a new savepoint within the current transaction" msgstr "definisci un nuovo punto di salvataggio per la transazione corrente" -#: sql_help.c:4894 +#: sql_help.c:4883 msgid "define or change a security label applied to an object" msgstr "definisci o modifica un'etichetta di sicurezza applicata a un oggetto" -#: sql_help.c:4899 sql_help.c:4944 sql_help.c:4974 +#: sql_help.c:4888 sql_help.c:4933 sql_help.c:4963 msgid "retrieve rows from a table or view" msgstr "estrai righe da una tabella o una vista" -#: sql_help.c:4909 +#: sql_help.c:4898 msgid "change a run-time parameter" msgstr "modifica un parametro di esecuzione" -#: sql_help.c:4914 +#: sql_help.c:4903 msgid "set constraint check timing for the current transaction" msgstr "imposta il momento del controllo dei vincoli per la transazione corrente" -#: sql_help.c:4919 +#: sql_help.c:4908 msgid "set the current user identifier of the current session" msgstr "imposta l'identificativo utente della sessione corrente" -#: sql_help.c:4924 +#: sql_help.c:4913 msgid "set the session user identifier and the current user identifier of the current session" msgstr "imposta l'identificazione utente della sessione e l'identificazione utente corrente della sessione corrente" -#: sql_help.c:4929 +#: sql_help.c:4918 msgid "set the characteristics of the current transaction" msgstr "imposta le caratteristiche della transazione corrente" -#: sql_help.c:4934 +#: sql_help.c:4923 msgid "show the value of a run-time parameter" msgstr "mostra il valore di un parametro di esecuzione" -#: sql_help.c:4949 +#: sql_help.c:4938 msgid "empty a table or set of tables" msgstr "svuota una tabella o una lista di tabelle" -#: sql_help.c:4954 +#: sql_help.c:4943 msgid "stop listening for a notification" msgstr "termina l'attesa di notifiche" -#: sql_help.c:4959 +#: sql_help.c:4948 msgid "update rows of a table" msgstr "modifica le righe di una tabella" -#: sql_help.c:4964 +#: sql_help.c:4953 msgid "garbage-collect and optionally analyze a database" msgstr "pulisci ed eventualmente analizza il database" -#: sql_help.c:4969 +#: sql_help.c:4958 msgid "compute a set of rows" msgstr "genera una sequenza di righe" @@ -5278,7 +5354,7 @@ msgstr "%s: il proprio programma eseguibile non è stato trovato\n" msgid "unrecognized value \"%s\" for \"%s\"; assuming \"%s\"\n" msgstr "valore \"%s\" non riconosciuto per \"%s\"; interpretato come \"%s\"\n" -#: tab-complete.c:3682 +#: tab-complete.c:3743 #, c-format msgid "" "tab completion query failed: %s\n" diff --git a/src/bin/psql/po/ja.po b/src/bin/psql/po/ja.po index 309fbbdf7a..d02a3f35f4 100644 --- a/src/bin/psql/po/ja.po +++ b/src/bin/psql/po/ja.po @@ -3,11 +3,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.4.2\n" +"Project-Id-Version: PostgreSQL 9.6.1\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2015-05-23 22:59+0900\n" +"POT-Creation-Date: 2017-01-09 22:43+0000\n" "PO-Revision-Date: 2015-05-27 18:55+0900\n" -"Last-Translator: KOIZUMI Satoru \n" +"Last-Translator: Okano Naoki \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -50,14 +50,14 @@ msgstr "シンボリックリンク \"%s\" を読ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸã€‚" msgid "pclose failed: %s" msgstr "pcloseãŒå¤±æ•—ã—ã¾ã—ãŸ: %s" -#: ../../common/fe_memutils.c:33 ../../common/fe_memutils.c:60 -#: ../../common/fe_memutils.c:83 command.c:321 input.c:205 mainloop.c:72 -#: mainloop.c:234 +#: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 +#: ../../common/fe_memutils.c:98 command.c:342 input.c:227 mainloop.c:80 +#: mainloop.c:261 #, c-format msgid "out of memory\n" msgstr "メモリä¸è¶³ã§ã™\n" -#: ../../common/fe_memutils.c:77 +#: ../../common/fe_memutils.c:92 #, c-format msgid "cannot duplicate null pointer (internal error)\n" msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" @@ -67,7 +67,7 @@ msgstr "null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" msgid "could not look up effective user ID %ld: %s" msgstr "実効ユーザID %ld ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“ã§ã—ãŸ: %s" -#: ../../common/username.c:47 command.c:276 +#: ../../common/username.c:47 command.c:299 msgid "user does not exist" msgstr "ユーザãŒå­˜åœ¨ã—ã¾ã›ã‚“" @@ -111,227 +111,293 @@ msgstr "å­ãƒ—ロセスãŒã‚·ã‚°ãƒŠãƒ« %d ã§çµ‚了ã•ã›ã‚‰ã‚Œã¾ã—ãŸã€‚" msgid "child process exited with unrecognized status %d" msgstr "å­ãƒ—ロセスãŒä¸æ˜ŽãªçŠ¶æ…‹%dã«ã‚ˆã‚Šçµ‚了ã—ã¾ã—ãŸã€‚" -#: command.c:117 +#: ../../fe_utils/print.c:354 +#, c-format +msgid "(%lu row)" +msgid_plural "(%lu rows)" +msgstr[0] "(%lu è¡Œ)" +msgstr[1] "(%lu è¡Œ)" + +#: ../../fe_utils/print.c:2914 +#, c-format +msgid "Interrupted\n" +msgstr "中断ã•ã‚Œã¾ã—ãŸ\n" + +#: ../../fe_utils/print.c:2978 +#, c-format +msgid "Cannot add header to table content: column count of %d exceeded.\n" +msgstr "テーブルã®å†…容ã«è¦‹å‡ºã—を追加ã§ãã¾ã›ã‚“ã§ã—ãŸï¼šåˆ—æ•° %d ãŒåˆ¶é™ã‚’越ãˆã¦ã„ã¾ã™ã€‚\n" + +#: ../../fe_utils/print.c:3018 +#, c-format +msgid "Cannot add cell to table content: total cell count of %d exceeded.\n" +msgstr "テーブルã®å†…容ã«ã‚»ãƒ«ã‚’追加ã§ãã¾ã›ã‚“ã§ã—ãŸï¼šå…¨ã‚»ãƒ«æ•° %d ãŒåˆ¶é™ã‚’越ãˆã¦ã„ã¾ã™ã€‚\n" + +#: ../../fe_utils/print.c:3267 +#, c-format +msgid "invalid output format (internal error): %d" +msgstr "出力フォーマットãŒç„¡åŠ¹ï¼ˆå†…部エラー）：%d" + +#: ../../fe_utils/psqlscan.l:713 +#, c-format +msgid "skipping recursive expansion of variable \"%s\"\n" +msgstr "変数\"%s\"ã®å†å¸°å±•é–‹ã‚’スキップã—ã¦ã„ã¾ã™\n" + +#: command.c:129 #, c-format msgid "Invalid command \\%s. Try \\? for help.\n" msgstr "\\%sコマンドã¯ç„¡åŠ¹ã§ã™ã€‚\\? ã§ãƒ˜ãƒ«ãƒ—ã‚’å‚ç…§ã—ã¦ãã ã•ã„。\n" -#: command.c:119 +#: command.c:131 #, c-format msgid "invalid command \\%s\n" msgstr "\\%sã¯ç„¡åŠ¹ãªã‚³ãƒžãƒ³ãƒ‰ã§ã™\n" -#: command.c:130 +#: command.c:142 #, c-format msgid "\\%s: extra argument \"%s\" ignored\n" msgstr "\\%s: 余分ãªå¼•æ•° \"%s\" ã¯ç„¡è¦–ã•ã‚Œã¾ã—ãŸã€‚\n" -#: command.c:274 +#: command.c:297 #, c-format msgid "could not get home directory for user ID %ld: %s\n" msgstr "ユーザID %ld ã®ãƒ›ãƒ¼ãƒ ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’特定ã§ãã¾ã›ã‚“: %s\n" -#: command.c:292 +#: command.c:315 #, c-format msgid "\\%s: could not change directory to \"%s\": %s\n" msgstr "\\%s: ディレクトリを \"%s\" ã«å¤‰æ›´ã§ãã¾ã›ã‚“：%s\n" -#: command.c:307 common.c:446 common.c:886 +#: command.c:330 common.c:553 common.c:611 common.c:1144 #, c-format msgid "You are currently not connected to a database.\n" msgstr "ç¾åœ¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã¯æŽ¥ç¶šã—ã¦ã„ã¾ã›ã‚“。\n" -#: command.c:334 +#: command.c:355 #, c-format msgid "You are connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n" msgstr "データベース\"%s\"ã«ãƒ¦ãƒ¼ã‚¶\"%s\"ã§ã‚½ã‚±ãƒƒãƒˆ\"%s\"経由ã®ãƒãƒ¼ãƒˆ\"%s\"ã§æŽ¥ç¶šã—ã¦ã„ã¾ã™ã€‚\n" -#: command.c:337 +#: command.c:358 #, c-format msgid "You are connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n" msgstr "ホスト\"%3$s\"上ã®ãƒãƒ¼ãƒˆ\"%4$s\"ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹\"%1$s\"ã«ãƒ¦ãƒ¼ã‚¶\"%2$s\"ã§æŽ¥ç¶šã—ã¦ã„ã¾ã™\n" -#: command.c:538 command.c:608 command.c:1403 +#: command.c:574 command.c:647 command.c:746 command.c:1584 #, c-format msgid "no query buffer\n" msgstr "å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡ãŒã‚ã‚Šã¾ã›ã‚“。\n" -#: command.c:571 command.c:3035 +#: command.c:607 command.c:3547 #, c-format msgid "invalid line number: %s\n" msgstr "無効ãªè¡Œç•ªå·ã§ã™: %s\n" -#: command.c:602 +#: command.c:640 #, c-format -msgid "The server (version %d.%d) does not support editing function source.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ (%d.%d) ã¯é–¢æ•°ã®ã‚½ãƒ¼ã‚¹ç·¨é›†ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“\n" +#| msgid "The server (version %d.%d) does not support editing function source.\n" +msgid "The server (version %s) does not support editing function source.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯é–¢æ•°ã®ã‚½ãƒ¼ã‚¹ç·¨é›†ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: command.c:682 +#: command.c:721 command.c:792 msgid "No changes" msgstr "変更ãªã—" -#: command.c:736 +#: command.c:739 +#, c-format +#| msgid "The server (version %d.%d) does not support editing function source.\n" +msgid "The server (version %s) does not support editing view definitions.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯é–¢æ•°ã®ã‚½ãƒ¼ã‚¹ç·¨é›†ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" + +#: command.c:846 #, c-format msgid "%s: invalid encoding name or conversion procedure not found\n" msgstr "%s: 符å·åŒ–æ–¹å¼åãŒç„¡åŠ¹ã€ã¾ãŸã¯å¤‰æ›ç”¨ãƒ—ロシージャãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“。\n" -#: command.c:833 command.c:883 command.c:897 command.c:914 command.c:1021 -#: command.c:1180 command.c:1383 command.c:1414 +#: command.c:871 command.c:1962 command.c:3649 common.c:153 common.c:200 +#: common.c:497 common.c:1190 common.c:1218 common.c:1319 copy.c:489 +#: copy.c:699 large_obj.c:156 large_obj.c:191 large_obj.c:253 +#, c-format +msgid "%s" +msgstr "%s" + +#: command.c:875 +msgid "out of memory" +msgstr "メモリä¸è¶³ã§ã™" + +#: command.c:878 +#| msgid "there is no parameter $%d" +msgid "There is no previous error." +msgstr "ç›´å‰ã®ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã›ã‚“。" + +#: command.c:972 command.c:1022 command.c:1036 command.c:1053 command.c:1160 +#: command.c:1324 command.c:1564 command.c:1595 #, c-format msgid "\\%s: missing required argument\n" msgstr "\\%s: å¿…è¦ãªå¼•æ•°ãŒã‚ã‚Šã¾ã›ã‚“\n" -#: command.c:946 +#: command.c:1085 msgid "Query buffer is empty." msgstr "å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡ã¯ç©ºã§ã™ã€‚" -#: command.c:956 +#: command.c:1095 msgid "Enter new password: " msgstr "æ–°ã—ã„パスワード: " -#: command.c:957 +#: command.c:1096 msgid "Enter it again: " msgstr "ã‚‚ã†ä¸€åº¦å…¥åŠ›ã—ã¦ãã ã•ã„：" -#: command.c:961 +#: command.c:1100 #, c-format msgid "Passwords didn't match.\n" msgstr "パスワードãŒä¸€è‡´ã—ã¾ã›ã‚“。\n" -#: command.c:979 +#: command.c:1118 #, c-format msgid "Password encryption failed.\n" msgstr "パスワードã®æš—å·åŒ–ã«å¤±æ•—ã—ã¾ã—ãŸã€‚\n" -#: command.c:1050 command.c:1161 command.c:1388 +#: command.c:1189 command.c:1305 command.c:1569 #, c-format msgid "\\%s: error while setting variable\n" msgstr "\\%s: 変数を設定ã—ã¦ã„る時ã«ã‚¨ãƒ©ãƒ¼\n" -#: command.c:1108 +#: command.c:1252 msgid "Query buffer reset (cleared)." msgstr "å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡ãŒãƒªã‚»ãƒƒãƒˆï¼ˆã‚¯ãƒªã‚¢ï¼‰ã•ã‚Œã¾ã—ãŸã€‚" -#: command.c:1120 +#: command.c:1264 #, c-format msgid "Wrote history to file \"%s\".\n" msgstr "ファイル\"%s\"ã«å±¥æ­´ã‚’出力ã—ã¾ã—ãŸã€‚\n" -#: command.c:1185 +#: command.c:1329 #, c-format msgid "\\%s: environment variable name must not contain \"=\"\n" msgstr "\\%s: 環境変数ã®åå‰ã«ã¯\"=\"ã‚’å«ã‚られã¾ã›ã‚“\n" -#: command.c:1227 +#: command.c:1373 #, c-format -msgid "The server (version %d.%d) does not support showing function source.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒ(ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%d)ã¯é–¢æ•°ã‚½ãƒ¼ã‚¹ã®è¡¨ç¤ºã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support showing function source.\n" +msgid "The server (version %s) does not support showing function source.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯é–¢æ•°ã‚½ãƒ¼ã‚¹ã®è¡¨ç¤ºã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: command.c:1233 +#: command.c:1380 #, c-format msgid "function name is required\n" msgstr "関数åãŒå¿…è¦ã§ã™\n" -#: command.c:1368 +#: command.c:1455 +#, c-format +#| msgid "The server (version %d.%d) does not support showing function source.\n" +msgid "The server (version %s) does not support showing view definitions.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯ãƒ“ュー定義ã®è¡¨ç¤ºã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" + +#: command.c:1462 +#, c-format +#| msgid "function name is required\n" +msgid "view name is required\n" +msgstr "ビューåãŒå¿…è¦ã§ã™\n" + +#: command.c:1549 msgid "Timing is on." msgstr "タイミング㯠on ã§ã™ã€‚" -#: command.c:1370 +#: command.c:1551 msgid "Timing is off." msgstr "タイミング㯠off ã§ã™ã€‚" -#: command.c:1431 command.c:1451 command.c:2072 command.c:2075 command.c:2078 -#: command.c:2084 command.c:2086 command.c:2094 command.c:2104 command.c:2113 -#: command.c:2127 command.c:2144 command.c:2203 common.c:74 copy.c:333 -#: copy.c:393 copy.c:408 psqlscan.l:1677 psqlscan.l:1688 psqlscan.l:1698 +#: command.c:1613 command.c:1633 command.c:2311 command.c:2314 command.c:2317 +#: command.c:2323 command.c:2325 command.c:2333 command.c:2343 command.c:2352 +#: command.c:2366 command.c:2383 command.c:2441 common.c:68 copy.c:332 +#: copy.c:392 copy.c:405 psqlscanslash.l:711 psqlscanslash.l:722 +#: psqlscanslash.l:732 #, c-format msgid "%s: %s\n" msgstr "%s: %s\n" -#: command.c:1530 +#: command.c:1727 #, c-format msgid "+ opt(%d) = |%s|\n" msgstr "+ opt(%d) = |%s|\n" -#: command.c:1556 startup.c:184 +#: command.c:1753 startup.c:207 msgid "Password: " msgstr "パスワード: " -#: command.c:1561 startup.c:186 +#: command.c:1758 startup.c:209 #, c-format msgid "Password for user %s: " msgstr "ユーザ %s ã®ãƒ‘スワード: " -#: command.c:1608 +#: command.c:1809 #, c-format msgid "All connection parameters must be supplied because no database connection exists\n" msgstr "データベース接続ãŒã‚ã‚Šã¾ã›ã‚“ã®ã§ã™ã¹ã¦ã®æŽ¥ç¶šãƒ‘ラメータを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: command.c:1725 command.c:3069 common.c:120 common.c:413 common.c:478 -#: common.c:929 common.c:954 common.c:1051 copy.c:492 copy.c:695 -#: large_obj.c:158 large_obj.c:193 large_obj.c:255 psqlscan.l:1949 -#, c-format -msgid "%s" -msgstr "%s" - -#: command.c:1729 +#: command.c:1966 #, c-format msgid "Previous connection kept\n" msgstr "以å‰ã®æŽ¥ç¶šã¯ä¿æŒã•ã‚Œã¦ã„ã¾ã™ã€‚\n" -#: command.c:1733 +#: command.c:1970 #, c-format msgid "\\connect: %s" msgstr "\\connect: %s" -#: command.c:1766 +#: command.c:2006 #, c-format msgid "You are now connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n" msgstr "ãƒãƒ¼ãƒˆ\"%4$s\"ã®ã‚½ã‚±ãƒƒãƒˆ\"%3$s\"経由ã§ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹\"%1$s\"ã«ãƒ¦ãƒ¼ã‚¶\"%2$s\"ã¨ã—ã¦æŽ¥ç¶šã—ã¾ã—ãŸã€‚\n" -#: command.c:1769 +#: command.c:2009 #, c-format msgid "You are now connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n" msgstr "ホスト\"%3$s\"上ã®ãƒãƒ¼ãƒˆ\"%4$s\"ã§ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹\"%1$s\"ã«ãƒ¦ãƒ¼ã‚¶\"%2$s\"ã¨ã—ã¦æŽ¥ç¶šã—ã¾ã—ãŸã€‚\n" -#: command.c:1773 +#: command.c:2013 #, c-format msgid "You are now connected to database \"%s\" as user \"%s\".\n" msgstr "データベース \"%s\" ã«ãƒ¦ãƒ¼ã‚¶\"%s\"ã¨ã—ã¦æŽ¥ç¶šã—ã¾ã—ãŸã€‚\n" -#: command.c:1807 +#: command.c:2046 #, c-format msgid "%s (%s, server %s)\n" msgstr "%s (%s, サーãƒãƒ¼ %s)\n" -#: command.c:1815 +#: command.c:2054 #, c-format +#| msgid "" +#| "WARNING: %s major version %d.%d, server major version %d.%d.\n" +#| " Some psql features might not work.\n" msgid "" -"WARNING: %s major version %d.%d, server major version %d.%d.\n" +"WARNING: %s major version %s, server major version %s.\n" " Some psql features might not work.\n" msgstr "" -"注æ„： %s メジャーãƒãƒ¼ã‚¸ãƒ§ãƒ³ %d.%d, サーãƒãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %d.%d.\n" +"注æ„： %s メジャーãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s, サーãƒãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s.\n" " psql ã®æ©Ÿèƒ½ã®ä¸­ã§ã€å‹•ä½œã—ãªã„ã‚‚ã®ãŒã‚ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。\n" -#: command.c:1845 +#: command.c:2091 #, c-format -msgid "SSL connection (protocol: %s, cipher: %s, bits: %d, compression: %s)\n" -msgstr "SSL接続(プロトコル: %s, æš—å·åŒ–æ–¹å¼: %s, ビット長: %d, 圧縮: %s)\n" +#| msgid "SSL connection (protocol: %s, cipher: %s, bits: %d, compression: %s)\n" +msgid "SSL connection (protocol: %s, cipher: %s, bits: %s, compression: %s)\n" +msgstr "SSL接続(プロトコル: %s, æš—å·åŒ–æ–¹å¼: %s, ビット長: %s, 圧縮: %s)\n" -#: command.c:1847 help.c:46 +#: command.c:2092 command.c:2093 command.c:2094 +#| msgid "unknown\n" +msgid "unknown" +msgstr "unknown" + +#: command.c:2095 help.c:46 msgid "off" msgstr "オフ" -#: command.c:1847 help.c:46 +#: command.c:2095 help.c:46 msgid "on" msgstr "オン" -#: command.c:1856 -#, c-format -msgid "SSL connection (unknown cipher)\n" -msgstr "SSL 接続 (未定義ã®æš—å·åŒ–æ–¹å¼)\n" - -#: command.c:1877 +#: command.c:2115 #, c-format msgid "" "WARNING: Console code page (%u) differs from Windows code page (%u)\n" @@ -344,270 +410,344 @@ msgstr "" " （ウィンドウズユーザã®ãŸã‚ã«ï¼‰ã‚’å‚ç…§ã—ã¦ãã ã•ã„。\n" "\n" -#: command.c:1961 +#: command.c:2200 #, c-format msgid "environment variable PSQL_EDITOR_LINENUMBER_ARG must be set to specify a line number\n" msgstr "行番å·ã‚’指定ã™ã‚‹ãŸã‚ã«ã¯PSQL_EDITOR_LINENUMBER_ARG変数を設定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: command.c:1990 +#: command.c:2229 #, c-format msgid "could not start editor \"%s\"\n" msgstr "エディタ \"%s\" ã‚’èµ·å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚\n" -#: command.c:1992 +#: command.c:2231 #, c-format msgid "could not start /bin/sh\n" msgstr "/bin/sh ã‚’èµ·å‹•ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚\n" -#: command.c:2030 +#: command.c:2269 #, c-format msgid "could not locate temporary directory: %s\n" msgstr "一時ディレクトリã«ç§»å‹•ã§ãã¾ã›ã‚“: %s\n" -#: command.c:2057 +#: command.c:2296 #, c-format msgid "could not open temporary file \"%s\": %s\n" msgstr "一時ファイル \"%s\" ã‚’é–‹ã‘ã¾ã›ã‚“: %s\n" -#: command.c:2325 +#: command.c:2570 #, c-format -msgid "\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n" -msgstr "\\pset: 有効ãªãƒ•ã‚©ãƒ¼ãƒžãƒƒãƒˆã¯ unaligned, aligned, wrapped, html, latex, troff-ms ã§ã™ã€‚\n" +#| msgid "\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n" +msgid "\\pset: allowed formats are unaligned, aligned, wrapped, html, asciidoc, latex, latex-longtable, troff-ms\n" +msgstr "\\pset: 有効ãªãƒ•ã‚©ãƒ¼ãƒžãƒƒãƒˆã¯ unaligned, aligned, wrapped, html, asciidoc, latex, latex-longtable, troff-ms ã§ã™\n" -#: command.c:2344 +#: command.c:2589 #, c-format msgid "\\pset: allowed line styles are ascii, old-ascii, unicode\n" msgstr "\\pset: 有効ãªè¡Œã‚¹ã‚¿ã‚¤ãƒ«ã¯ ascii, old-ascii, unicode ã§ã™ã€‚\n" -#: command.c:2490 command.c:2641 +#: command.c:2605 +#, c-format +#| msgid "\\pset: allowed line styles are ascii, old-ascii, unicode\n" +msgid "\\pset: allowed Unicode border line styles are single, double\n" +msgstr "\\pset: 有効ãªUnicodeã®å¢ƒç•Œç·šã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ single, double ã§ã™\n" + +#: command.c:2620 +#, c-format +#| msgid "\\pset: allowed line styles are ascii, old-ascii, unicode\n" +msgid "\\pset: allowed Unicode column line styles are single, double\n" +msgstr "\\pset: 有効ãªUnicodeã®åˆ—ã®ç·šã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ single, double ã§ã™\n" + +#: command.c:2635 +#, c-format +#| msgid "\\pset: allowed line styles are ascii, old-ascii, unicode\n" +msgid "\\pset: allowed Unicode header line styles are single, double\n" +msgstr "\\pset: 有効ãªUnicodeã®ãƒ˜ãƒƒãƒ€ã®ç·šã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ single, double ã§ã™\n" + +#: command.c:2787 command.c:2966 #, c-format msgid "\\pset: unknown option: %s\n" msgstr "\\pset: 未定義ã®ã‚ªãƒ—ション：%s\n" -#: command.c:2508 +#: command.c:2805 #, c-format msgid "Border style is %d.\n" msgstr "境界線ã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ %d ã§ã™ã€‚\n" -#: command.c:2514 +#: command.c:2811 #, c-format msgid "Target width is unset.\n" msgstr "対象幅ã¯ã‚»ãƒƒãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。\n" -#: command.c:2516 +#: command.c:2813 #, c-format msgid "Target width is %d.\n" msgstr "対象幅ã¯%dã§ã™ã€‚\n" -#: command.c:2523 +#: command.c:2820 #, c-format msgid "Expanded display is on.\n" msgstr "拡張表示㯠on ã§ã™ã€‚\n" -#: command.c:2525 +#: command.c:2822 #, c-format msgid "Expanded display is used automatically.\n" msgstr "拡張表示ãŒè‡ªå‹•çš„ã«ä½¿ç”¨ã•ã‚Œã¾ã™\n" -#: command.c:2527 +#: command.c:2824 #, c-format msgid "Expanded display is off.\n" msgstr "拡張表示㯠off ã§ã™ã€‚\n" -#: command.c:2534 command.c:2542 +#: command.c:2831 command.c:2839 #, c-format msgid "Field separator is zero byte.\n" msgstr "フィールド区切り文字ã¯ã‚¼ãƒ­ãƒã‚¤ãƒˆã§ã™ã€‚\n" -#: command.c:2536 +#: command.c:2833 #, c-format msgid "Field separator is \"%s\".\n" msgstr "フィールド区切り文字㯠\"%s\" ã§ã™ã€‚\n" -#: command.c:2549 +#: command.c:2846 #, c-format msgid "Default footer is on.\n" msgstr "デフォルトã®ãƒ•ãƒƒã‚¿ã¯ on ã§ã™ã€‚\n" -#: command.c:2551 +#: command.c:2848 #, c-format msgid "Default footer is off.\n" msgstr "デフォルトã®ãƒ•ãƒƒã‚¿ã¯ off ã§ã™ã€‚\n" -#: command.c:2557 +#: command.c:2854 #, c-format msgid "Output format is %s.\n" msgstr "出力フォーマット㯠%s ã§ã™ã€‚\n" -#: command.c:2563 +#: command.c:2860 #, c-format msgid "Line style is %s.\n" msgstr "境界線ã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ %s ã§ã™ã€‚\n" -#: command.c:2570 +#: command.c:2867 #, c-format msgid "Null display is \"%s\".\n" msgstr "Null 表示㯠\"%s\" ã§ã™ã€‚\n" -#: command.c:2578 +#: command.c:2875 #, c-format msgid "Locale-adjusted numeric output is on.\n" msgstr "「数値出力ã®ãƒ­ã‚±ãƒ¼ãƒ«èª¿æ•´ã€ã¯ on ã§ã™ã€‚\n" -#: command.c:2580 +#: command.c:2877 #, c-format msgid "Locale-adjusted numeric output is off.\n" msgstr "「数値出力ã®ãƒ­ã‚±ãƒ¼ãƒ«èª¿æ•´ã€ã¯ off ã§ã™ã€‚\n" -#: command.c:2587 +#: command.c:2884 #, c-format msgid "Pager is used for long output.\n" msgstr "出力ãŒé•·ã„å ´åˆã¯ãƒšãƒ¼ã‚¸ãƒ£ãŒä½¿ã‚ã‚Œã¾ã™ã€‚\n" -#: command.c:2589 +#: command.c:2886 #, c-format msgid "Pager is always used.\n" msgstr "常ã«ãƒšãƒ¼ã‚¸ãƒ£ãŒä½¿ã‚ã‚Œã¾ã™ã€‚\n" -#: command.c:2591 +#: command.c:2888 #, c-format msgid "Pager usage is off.\n" msgstr "「ページャを使ã†ã€ã¯ off ã§ã™ã€‚\n" -#: command.c:2598 command.c:2608 +#: command.c:2894 +#, c-format +msgid "Pager won't be used for less than %d line.\n" +msgid_plural "Pager won't be used for less than %d lines.\n" +msgstr[0] "" +msgstr[1] "" + +#: command.c:2904 command.c:2914 #, c-format msgid "Record separator is zero byte.\n" msgstr "レコード区切り文字ã¯ã‚¼ãƒ­ãƒã‚¤ãƒˆã§ã™ã€‚\n" -#: command.c:2600 +#: command.c:2906 #, c-format msgid "Record separator is .\n" msgstr "レコード区切り文字㯠ã§ã™ã€‚\n" -#: command.c:2602 +#: command.c:2908 #, c-format msgid "Record separator is \"%s\".\n" msgstr "レコード区切り文字㯠\"%s\" ã§ã™ã€‚\n" -#: command.c:2615 +#: command.c:2921 #, c-format msgid "Table attributes are \"%s\".\n" msgstr "テーブル属性㯠\"%s\" ã§ã™ã€‚\n" -#: command.c:2618 +#: command.c:2924 #, c-format msgid "Table attributes unset.\n" msgstr "テーブル属性ã¯ã‚»ãƒƒãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。\n" -#: command.c:2625 +#: command.c:2931 #, c-format msgid "Title is \"%s\".\n" msgstr "タイトル㯠\"%s\" ã§ã™ã€‚\n" -#: command.c:2627 +#: command.c:2933 #, c-format msgid "Title is unset.\n" msgstr "タイトルã¯ã‚»ãƒƒãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。\n" -#: command.c:2634 +#: command.c:2940 #, c-format msgid "Tuples only is on.\n" msgstr "「タプルã®ã¿è¡¨ç¤ºã€ã¯ on ã§ã™ã€‚\n" -#: command.c:2636 +#: command.c:2942 #, c-format msgid "Tuples only is off.\n" msgstr "「タプルã®ã¿è¡¨ç¤ºã€ã¯ off ã§ã™ã€‚\n" -#: command.c:2787 +#: command.c:2948 +#, c-format +#| msgid "Border style is %d.\n" +msgid "Unicode border line style is \"%s\".\n" +msgstr "Unicodeã®å¢ƒç•Œç·šã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ \"%s\" ã§ã™ã€‚\n" + +#: command.c:2954 +#, c-format +#| msgid "Line style is %s.\n" +msgid "Unicode column line style is \"%s\".\n" +msgstr "Unicodeã®åˆ—ã®ç·šã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ \"%s\" ã§ã™ã€‚\n" + +#: command.c:2960 +#, c-format +#| msgid "Line style is %s.\n" +msgid "Unicode header line style is \"%s\".\n" +msgstr "Unicodeã®ãƒ˜ãƒƒãƒ€ã®ç·šã®ã‚¹ã‚¿ã‚¤ãƒ«ã¯ \"%s\" ã§ã™ã€‚\n" + +#: command.c:3120 #, c-format msgid "\\!: failed\n" msgstr "\\!: 失敗\n" -#: command.c:2807 command.c:2865 +#: command.c:3145 common.c:659 #, c-format msgid "\\watch cannot be used with an empty query\n" msgstr "\\watchを空ã®å•ã„åˆã‚ã›ã§ä½¿ç”¨ã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“\n" -#: command.c:2828 +#: command.c:3186 #, c-format -msgid "Watch every %lds\t%s" -msgstr "%ld秒毎ã«ç›£è¦–ã—ã¾ã™\t%s" +#| msgid "%s (%s, server %s)\n" +msgid "%s\t%s (every %gs)\n" +msgstr "%s\t%s (%g秒毎)\n" -#: command.c:2872 +#: command.c:3189 #, c-format -msgid "\\watch cannot be used with COPY\n" -msgstr "\\watchã§ã¯COPYを使用ã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“\n" +#| msgid "%s (%s, server %s)\n" +msgid "%s (every %gs)\n" +msgstr "%s (%g秒毎)\n" -#: command.c:2878 +#: command.c:3243 command.c:3250 common.c:559 common.c:566 common.c:1173 #, c-format -msgid "unexpected result status for \\watch\n" -msgstr "\\watchã«å¯¾ã™ã‚‹æƒ³å®šå¤–ã®çµæžœçŠ¶æ…‹\n" +msgid "" +"********* QUERY **********\n" +"%s\n" +"**************************\n" +"\n" +msgstr "" +"********* å•ã„åˆã‚ã› ********\n" +"%s\n" +"*****************************\n" +"\n" + +#: command.c:3442 +#, c-format +#| msgid "\"%s\" is not a view" +msgid "\"%s.%s\" is not a view\n" +msgstr "\"%s.%s\" ã¯ãƒ“ューã§ã¯ã‚ã‚Šã¾ã›ã‚“\n" + +#: command.c:3458 +#, c-format +#| msgid "WARNING: could not parse proconfig array\n" +msgid "could not parse reloptions array\n" +msgstr "reloptionsé…列ã®è§£æžãŒã§ãã¾ã›ã‚“ã§ã—ãŸ\n" + +#: common.c:138 +#, c-format +#| msgid "can't escape without active connection\n" +msgid "cannot escape without active connection\n" +msgstr "有効ãªæŽ¥ç¶šãªã—ã§ã¯ã‚¨ã‚¹ã‚±ãƒ¼ãƒ—ã§ãã¾ã›ã‚“\n" -#: common.c:287 +#: common.c:371 #, c-format msgid "connection to server was lost\n" msgstr "サーãƒãƒ¼ã¸ã®æŽ¥ç¶šãŒåˆ‡ã‚Œã¾ã—ãŸã€‚\n" -#: common.c:291 +#: common.c:375 #, c-format msgid "The connection to the server was lost. Attempting reset: " msgstr "サーãƒãƒ¼ã¸ã®æŽ¥ç¶šãŒåˆ‡ã‚Œã¾ã—ãŸã€‚リセットã—ã¦ã„ã¾ã™: " -#: common.c:296 +#: common.c:380 #, c-format msgid "Failed.\n" msgstr "失敗。\n" -#: common.c:303 +#: common.c:387 #, c-format msgid "Succeeded.\n" msgstr "æˆåŠŸã€‚\n" -#: common.c:403 common.c:683 common.c:851 +#: common.c:487 common.c:936 common.c:1108 #, c-format msgid "unexpected PQresultStatus: %d\n" msgstr "想定外ã®PQresultStatus: %d\n" -#: common.c:452 common.c:459 common.c:912 +#: common.c:666 #, c-format -msgid "" -"********* QUERY **********\n" -"%s\n" -"**************************\n" -"\n" -msgstr "" -"********* å•ã„åˆã‚ã› ********\n" -"%s\n" -"*****************************\n" -"\n" +msgid "\\watch cannot be used with COPY\n" +msgstr "\\watchã§ã¯COPYを使用ã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“\n" -#: common.c:513 +#: common.c:671 +#, c-format +msgid "unexpected result status for \\watch\n" +msgstr "\\watchã«å¯¾ã™ã‚‹æƒ³å®šå¤–ã®çµæžœçŠ¶æ…‹\n" + +#: common.c:682 common.c:1335 +#, c-format +msgid "Time: %.3f ms\n" +msgstr "時間: %.3f ms\n" + +#: common.c:700 #, c-format msgid "Asynchronous notification \"%s\" with payload \"%s\" received from server process with PID %d.\n" msgstr "PID %3$d ã‚’æŒã¤ã‚µãƒ¼ãƒãƒ¼ãƒ—ロセスã‹ã‚‰ã€ãƒšã‚¤ãƒ­ãƒ¼ãƒ‰ \"%2$s\" ã‚’æŒã¤éžåŒæœŸé€šçŸ¥ \"%1$s\" ã‚’å—ä¿¡ã—ã¾ã—ãŸã€‚\n" -#: common.c:516 +#: common.c:703 #, c-format msgid "Asynchronous notification \"%s\" received from server process with PID %d.\n" msgstr "PID %2$d ã‚’æŒã¤ã‚µãƒ¼ãƒãƒ¼ãƒ—ロセスã‹ã‚‰éžåŒæœŸé€šçŸ¥ \"%1$s\" ã‚’å—ä¿¡ã—ã¾ã—ãŸã€‚\n" -#: common.c:578 +#: common.c:761 #, c-format msgid "no rows returned for \\gset\n" msgstr "\\gsetã«å¯¾ã—ã¦è¡ŒãŒè¿”ã•ã‚Œã¾ã›ã‚“ã§ã—ãŸ\n" -#: common.c:583 +#: common.c:766 #, c-format msgid "more than one row returned for \\gset\n" msgstr "\\gsetã«å¯¾ã—ã¦è¤‡æ•°ã®è¡ŒãŒè¿”ã•ã‚Œã¾ã—ãŸ\n" -#: common.c:609 +#: common.c:792 #, c-format msgid "could not set variable \"%s\"\n" msgstr "変数 \"%s\" をセットã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: common.c:894 +#: common.c:1153 #, c-format msgid "" "***(Single step mode: verify command)*******************************************\n" @@ -618,71 +758,73 @@ msgstr "" "%s\n" "***([Enter] を押ã—ã¦é€²ã‚€ã‹ã€x [Enter] ã§ã‚­ãƒ£ãƒ³ã‚»ãƒ«)**************\n" -#: common.c:945 +#: common.c:1208 #, c-format -msgid "The server (version %d.%d) does not support savepoints for ON_ERROR_ROLLBACK.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼(ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%d)ã§ã¯ã€ON_ERROR_ROLLBACK用ã®ã‚»ãƒ¼ãƒ–ãƒã‚¤ãƒ³ãƒˆã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support savepoints for ON_ERROR_ROLLBACK.\n" +msgid "The server (version %s) does not support savepoints for ON_ERROR_ROLLBACK.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã§ã¯ã€ON_ERROR_ROLLBACK用ã®ã‚»ãƒ¼ãƒ–ãƒã‚¤ãƒ³ãƒˆã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: common.c:1039 +#: common.c:1264 #, c-format -msgid "unexpected transaction status (%d)\n" -msgstr "想定外ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³çŠ¶æ…‹ (%d)\n" +#| msgid "STATEMENT: " +msgid "STATEMENT: %s\n" +msgstr "ステートメント: %s\n" -#: common.c:1067 +#: common.c:1307 #, c-format -msgid "Time: %.3f ms\n" -msgstr "時間: %.3f ms\n" +msgid "unexpected transaction status (%d)\n" +msgstr "想定外ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³çŠ¶æ…‹ (%d)\n" -#: copy.c:98 +#: copy.c:99 #, c-format msgid "\\copy: arguments required\n" msgstr "\\copy: 引数ãŒã‚ã‚Šã¾ã›ã‚“。\n" -#: copy.c:253 +#: copy.c:254 #, c-format msgid "\\copy: parse error at \"%s\"\n" msgstr "\\copy: \"%s\" ã§ãƒ‘ースエラー発生\n" -#: copy.c:255 +#: copy.c:256 #, c-format msgid "\\copy: parse error at end of line\n" msgstr "\\copy: 行末ã§ãƒ‘ースエラー発生\n" -#: copy.c:330 +#: copy.c:329 #, c-format msgid "could not execute command \"%s\": %s\n" msgstr "コマンド\"%s\"を実行ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: copy.c:346 +#: copy.c:345 #, c-format msgid "could not stat file \"%s\": %s\n" msgstr "ファイル\"%s\"ã®statãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: copy.c:350 +#: copy.c:349 #, c-format msgid "%s: cannot copy from/to a directory\n" msgstr "%s: ディレクトリã‹ã‚‰ï¼ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã¸ã®ã‚³ãƒ”ーã¯ã§ãã¾ã›ã‚“。\n" -#: copy.c:387 +#: copy.c:386 #, c-format msgid "could not close pipe to external command: %s\n" msgstr "外部コマンドã«å¯¾ã™ã‚‹ãƒ‘イプをクローズã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: copy.c:455 copy.c:466 +#: copy.c:452 copy.c:463 #, c-format msgid "could not write COPY data: %s\n" msgstr "COPY 対象データを書ãè¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸï¼š%s\n" -#: copy.c:473 +#: copy.c:470 #, c-format msgid "COPY data transfer failed: %s" msgstr "COPY 対象データã®è»¢é€ã«å¤±æ•—ã—ã¾ã—ãŸï¼š%s" -#: copy.c:534 +#: copy.c:531 msgid "canceled by user" msgstr "ユーザã«ã‚ˆã‚Šã‚­ãƒ£ãƒ³ã‚»ãƒ«ã•ã‚Œã¾ã—ãŸ" -#: copy.c:544 +#: copy.c:542 msgid "" "Enter data to be copied followed by a newline.\n" "End with a backslash and a period on a line by itself." @@ -690,48 +832,97 @@ msgstr "" "コピーã™ã‚‹ãƒ‡ãƒ¼ã‚¿ã«ç¶šã„ã¦æ”¹è¡Œã‚’入力ã—ã¾ã™ã€‚\n" "ãƒãƒƒã‚¯ã‚¹ãƒ©ãƒƒã‚·ãƒ¥(\\)ã¨ãƒ”リオドã ã‘ã®è¡Œã§çµ‚了ã—ã¾ã™ã€‚" -#: copy.c:667 +#: copy.c:671 msgid "aborted because of read failure" msgstr "読ã¿è¾¼ã¿ã«å¤±æ•—ã—ãŸãŸã‚異常終了ã—ã¾ã—ãŸ" -#: copy.c:691 +#: copy.c:695 msgid "trying to exit copy mode" msgstr "コピーモードを終了ã—よã†ã¨ã—ã¦ã„ã¾ã™ã€‚" -#: describe.c:71 describe.c:259 describe.c:491 describe.c:615 describe.c:758 -#: describe.c:844 describe.c:914 describe.c:2759 describe.c:2964 -#: describe.c:3054 describe.c:3299 describe.c:3436 describe.c:3665 -#: describe.c:3737 describe.c:3748 describe.c:3807 describe.c:4215 -#: describe.c:4294 +#: crosstabview.c:125 +#, c-format +#| msgid "command did not produce a result set" +msgid "\\crosstabview: statement did not return a result set\n" +msgstr "\\crosstabview: ステートメントã¯çµæžœã‚»ãƒƒãƒˆã‚’è¿”ã—ã¾ã›ã‚“ã§ã—ãŸ\n" + +#: crosstabview.c:131 +#, c-format +#| msgid "ts_stat query must return one tsvector column" +msgid "\\crosstabview: query must return at least three columns\n" +msgstr "\\crosstabview: å•ã„åˆã‚ã›ã¯å°‘ãªãã¨ã‚‚3ã¤ã®åˆ—ã‚’è¿”ã•ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" + +#: crosstabview.c:158 +#, c-format +msgid "\\crosstabview: vertical and horizontal headers must be different columns\n" +msgstr "\\crosstabview: 縦方å‘ã¨æ¨ªæ–¹å‘ã®ãƒ˜ãƒƒãƒ€ã¯ç•°ãªã‚‹åˆ—ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" + +#: crosstabview.c:174 +#, c-format +msgid "\\crosstabview: data column must be specified when query returns more than three columns\n" +msgstr "\\crosstabview: å•ã„åˆã‚ã›ãŒ3ã¤ã‚ˆã‚Šå¤šã列を返ã™ã¨ãã¯å‡ºåŠ›åˆ—ãŒæŒ‡å®šã•ã‚Œãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" + +#: crosstabview.c:230 +#, c-format +#| msgid "maximum number of committed subtransactions (%d) exceeded" +msgid "\\crosstabview: maximum number of columns (%d) exceeded\n" +msgstr "\\crosstabview: 列ã®æœ€å¤§æ•° (%d) ã®åˆ¶é™ã‚’越ãˆã¾ã—ãŸ\n" + +#: crosstabview.c:399 +#, c-format +msgid "\\crosstabview: query result contains multiple data values for row \"%s\", column \"%s\"\n" +msgstr "\\crosstabview: è¡Œ \"%s\", 列 \"%s\" ã«ã¤ã„ã¦å•ã„åˆã‚ã›çµæžœãŒè¤‡æ•°ã®ãƒ‡ãƒ¼ã‚¿å€¤ã‚’å«ã‚“ã§ã„ã¾ã™\n" + +#: crosstabview.c:647 +#, c-format +#| msgid "column number %d is out of range 0..%d" +msgid "\\crosstabview: column number %d is out of range 1..%d\n" +msgstr "\\crosstabview: åˆ—ç•ªå· %d 㯠1..%d ã®ç¯„囲を超ãˆã¦ã„ã¾ã™\n" + +#: crosstabview.c:672 +#, c-format +msgid "\\crosstabview: ambiguous column name: \"%s\"\n" +msgstr "\\crosstabview: 曖昧ãªåˆ—å: \"%s\"\n" + +#: crosstabview.c:680 +#, c-format +msgid "\\crosstabview: column name not found: \"%s\"\n" +msgstr "\\crosstabview: 列åãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“: \"%s\"\n" + +#: describe.c:71 describe.c:340 describe.c:597 describe.c:727 describe.c:870 +#: describe.c:990 describe.c:1060 describe.c:3035 describe.c:3240 +#: describe.c:3330 describe.c:3578 describe.c:3718 describe.c:3950 +#: describe.c:4025 describe.c:4036 describe.c:4098 describe.c:4518 +#: describe.c:4601 msgid "Schema" msgstr "スキーマ" -#: describe.c:72 describe.c:156 describe.c:164 describe.c:260 describe.c:492 -#: describe.c:616 describe.c:677 describe.c:759 describe.c:915 describe.c:2760 -#: describe.c:2886 describe.c:2965 describe.c:3055 describe.c:3134 -#: describe.c:3300 describe.c:3364 describe.c:3437 describe.c:3666 -#: describe.c:3738 describe.c:3749 describe.c:3808 describe.c:3997 -#: describe.c:4078 describe.c:4292 +#: describe.c:72 describe.c:160 describe.c:226 describe.c:234 describe.c:341 +#: describe.c:598 describe.c:728 describe.c:789 describe.c:871 describe.c:1061 +#: describe.c:3036 describe.c:3162 describe.c:3241 describe.c:3331 +#: describe.c:3410 describe.c:3579 describe.c:3643 describe.c:3719 +#: describe.c:3951 describe.c:4026 describe.c:4037 describe.c:4099 +#: describe.c:4291 describe.c:4375 describe.c:4599 msgid "Name" msgstr "åå‰" -#: describe.c:73 describe.c:272 describe.c:318 describe.c:335 +#: describe.c:73 describe.c:353 describe.c:399 describe.c:416 msgid "Result data type" msgstr "çµæžœã®ãƒ‡ãƒ¼ã‚¿åž‹" -#: describe.c:81 describe.c:94 describe.c:98 describe.c:273 describe.c:319 -#: describe.c:336 +#: describe.c:81 describe.c:94 describe.c:98 describe.c:354 describe.c:400 +#: describe.c:417 msgid "Argument data types" msgstr "引数ã®ãƒ‡ãƒ¼ã‚¿åž‹" -#: describe.c:105 describe.c:182 describe.c:365 describe.c:534 describe.c:631 -#: describe.c:702 describe.c:917 describe.c:1486 describe.c:2564 -#: describe.c:2793 describe.c:2917 describe.c:2991 describe.c:3064 -#: describe.c:3147 describe.c:3215 describe.c:3307 describe.c:3373 -#: describe.c:3438 describe.c:3574 describe.c:3614 describe.c:3682 -#: describe.c:3741 describe.c:3750 describe.c:3809 describe.c:4023 -#: describe.c:4100 describe.c:4229 describe.c:4295 large_obj.c:291 -#: large_obj.c:301 +#: describe.c:105 describe.c:170 describe.c:257 describe.c:462 describe.c:646 +#: describe.c:743 describe.c:814 describe.c:1063 describe.c:1676 +#: describe.c:2836 describe.c:3069 describe.c:3193 describe.c:3267 +#: describe.c:3340 describe.c:3423 describe.c:3491 describe.c:3586 +#: describe.c:3652 describe.c:3720 describe.c:3856 describe.c:3896 +#: describe.c:3967 describe.c:4029 describe.c:4038 describe.c:4100 +#: describe.c:4317 describe.c:4397 describe.c:4532 describe.c:4602 +#: large_obj.c:289 large_obj.c:299 msgid "Description" msgstr "説明" @@ -739,836 +930,915 @@ msgstr "説明" msgid "List of aggregate functions" msgstr "集約関数一覧" -#: describe.c:144 +#: describe.c:147 #, c-format -msgid "The server (version %d.%d) does not support tablespaces.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ (%d.%d) ã¯ãƒ†ãƒ¼ãƒ–ルスペースをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support tablespaces.\n" +msgid "The server (version %s) does not support access methods.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯ã‚¢ã‚¯ã‚»ã‚¹ãƒ¡ã‚½ãƒƒãƒ‰ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:157 describe.c:165 describe.c:362 describe.c:678 describe.c:843 -#: describe.c:2769 describe.c:2890 describe.c:3136 describe.c:3365 -#: describe.c:3998 describe.c:4079 large_obj.c:290 +#: describe.c:161 +#| msgid "index" +msgid "Index" +msgstr "インデックス" + +#: describe.c:162 describe.c:360 describe.c:405 describe.c:422 describe.c:877 +#: describe.c:999 describe.c:1645 describe.c:3044 describe.c:3242 +#: describe.c:4394 +msgid "Type" +msgstr "åž‹" + +#: describe.c:169 describe.c:4296 +msgid "Handler" +msgstr "ãƒãƒ³ãƒ‰ãƒ©ãƒ¼" + +#: describe.c:188 +#| msgid "List of casts" +msgid "List of access methods" +msgstr "アクセスメソッド一覧" + +#: describe.c:213 +#, c-format +#| msgid "The server (version %d.%d) does not support tablespaces.\n" +msgid "The server (version %s) does not support tablespaces.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯ãƒ†ãƒ¼ãƒ–ルスペースをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" + +#: describe.c:227 describe.c:235 describe.c:450 describe.c:636 describe.c:790 +#: describe.c:989 describe.c:3045 describe.c:3166 describe.c:3412 +#: describe.c:3644 describe.c:4292 describe.c:4376 large_obj.c:288 msgid "Owner" msgstr "所有者" -#: describe.c:158 describe.c:166 +#: describe.c:228 describe.c:236 msgid "Location" msgstr "場所" -#: describe.c:177 describe.c:2382 +#: describe.c:247 describe.c:2647 msgid "Options" msgstr "オプション" -#: describe.c:199 +#: describe.c:252 describe.c:609 describe.c:806 describe.c:3061 +#: describe.c:3065 +msgid "Size" +msgstr "サイズ" + +#: describe.c:274 msgid "List of tablespaces" msgstr "テーブルスペース一覧" -#: describe.c:236 +#: describe.c:314 #, c-format msgid "\\df only takes [antwS+] as options\n" msgstr "\\dfã¯ã‚ªãƒ—ションã¨ã—ã¦[antwS+]ã®ã¿ã‚’å–ã‚‹ã“ã¨ãŒã§ãã¾ã™\n" -#: describe.c:242 +#: describe.c:322 #, c-format -msgid "\\df does not take a \"w\" option with server version %d.%d\n" -msgstr "サーãƒãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%dã§ã¯\\dfã¯\"w\"オプションをå—ã‘付ã‘ã¾ã›ã‚“\n" +#| msgid "\\df does not take a \"w\" option with server version %d.%d\n" +msgid "\\df does not take a \"w\" option with server version %s\n" +msgstr "サーãƒãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s ã§ã¯\\dfã¯\"w\"オプションをå—ã‘付ã‘ã¾ã›ã‚“\n" #. translator: "agg" is short for "aggregate" -#: describe.c:275 describe.c:321 describe.c:338 +#: describe.c:356 describe.c:402 describe.c:419 msgid "agg" msgstr "agg（集約）" -#: describe.c:276 +#: describe.c:357 msgid "window" msgstr "window（ウィンドウ）" -#: describe.c:277 describe.c:322 describe.c:339 describe.c:1028 +#: describe.c:358 describe.c:403 describe.c:420 describe.c:1197 msgid "trigger" msgstr "trigger（トリガ）" -#: describe.c:278 describe.c:323 describe.c:340 +#: describe.c:359 describe.c:404 describe.c:421 msgid "normal" msgstr "normal（通常）" -#: describe.c:279 describe.c:324 describe.c:341 describe.c:765 describe.c:853 -#: describe.c:1455 describe.c:2768 describe.c:2966 describe.c:4097 -msgid "Type" -msgstr "åž‹" - -#: describe.c:355 -msgid "definer" -msgstr "定義元" - -#: describe.c:356 -msgid "invoker" -msgstr "呼ã³å‡ºã—å…ƒ" - -#: describe.c:357 -msgid "Security" -msgstr "セキュリティ" - -#: describe.c:358 +#: describe.c:432 msgid "immutable" msgstr "ä¸å¤‰" -#: describe.c:359 +#: describe.c:433 msgid "stable" msgstr "安定" -#: describe.c:360 +#: describe.c:434 msgid "volatile" msgstr "æ®ç™ºæ€§" -#: describe.c:361 +#: describe.c:435 msgid "Volatility" msgstr "æ®ç™ºæ€§" -#: describe.c:363 +#: describe.c:443 +#| msgid "restart" +msgid "restricted" +msgstr "restricted (制é™)" + +#: describe.c:444 +msgid "safe" +msgstr "safe (安全)" + +#: describe.c:445 +msgid "unsafe" +msgstr "unsafe (éžå®‰å…¨)" + +#: describe.c:446 +msgid "Parallel" +msgstr "パラレル" + +#: describe.c:451 +msgid "definer" +msgstr "定義元" + +#: describe.c:452 +msgid "invoker" +msgstr "呼ã³å‡ºã—å…ƒ" + +#: describe.c:453 +msgid "Security" +msgstr "セキュリティ" + +#: describe.c:460 msgid "Language" msgstr "言語" -#: describe.c:364 +#: describe.c:461 msgid "Source code" msgstr "ソースコード" -#: describe.c:462 +#: describe.c:560 msgid "List of functions" msgstr "関数一覧" -#: describe.c:502 +#: describe.c:608 msgid "Internal name" msgstr "内部å" -#: describe.c:503 describe.c:694 describe.c:2785 describe.c:2789 -msgid "Size" -msgstr "サイズ" - -#: describe.c:524 +#: describe.c:630 msgid "Elements" msgstr "è¦ç´ " -#: describe.c:574 +#: describe.c:686 msgid "List of data types" msgstr "データ型一覧" -#: describe.c:617 +#: describe.c:729 msgid "Left arg type" msgstr "左辺ã®åž‹" -#: describe.c:618 +#: describe.c:730 msgid "Right arg type" msgstr "å³è¾ºã®åž‹" -#: describe.c:619 +#: describe.c:731 msgid "Result type" msgstr "çµæžœã®åž‹" -#: describe.c:624 describe.c:3206 describe.c:3573 +#: describe.c:736 describe.c:3482 describe.c:3855 msgid "Function" msgstr "関数" -#: describe.c:649 +#: describe.c:761 msgid "List of operators" msgstr "演算å­ä¸€è¦§" -#: describe.c:679 +#: describe.c:791 msgid "Encoding" msgstr "エンコーディング" -#: describe.c:684 describe.c:3301 +#: describe.c:796 describe.c:3580 msgid "Collate" msgstr "ç…§åˆé †åº" -#: describe.c:685 describe.c:3302 +#: describe.c:797 describe.c:3581 msgid "Ctype" msgstr "Ctype(変æ›æ¼”ç®—å­)" -#: describe.c:698 +#: describe.c:810 msgid "Tablespace" msgstr "テーブルスペース" -#: describe.c:720 +#: describe.c:832 msgid "List of databases" msgstr "データベース一覧" -#: describe.c:760 describe.c:846 describe.c:2761 +#: describe.c:872 describe.c:992 describe.c:3037 msgid "table" msgstr "テーブル" -#: describe.c:761 describe.c:2762 +#: describe.c:873 describe.c:3038 msgid "view" msgstr "ビュー" -#: describe.c:762 describe.c:2763 +#: describe.c:874 describe.c:3039 msgid "materialized view" msgstr "マテリアライズドビュー" -#: describe.c:763 describe.c:848 describe.c:2765 +#: describe.c:875 describe.c:994 describe.c:3041 msgid "sequence" msgstr "シーケンス" -#: describe.c:764 describe.c:2767 +#: describe.c:876 describe.c:3043 msgid "foreign table" msgstr "外部テーブル" -#: describe.c:776 -msgid "Column access privileges" -msgstr "列ã®ã‚¢ã‚¯ã‚»ã‚¹æ¨©é™" +#: describe.c:888 +#| msgid "Column access privileges" +msgid "Column privileges" +msgstr "列ã®æ¨©é™" -#: describe.c:802 describe.c:4439 describe.c:4443 +#: describe.c:919 +msgid "Policies" +msgstr "ãƒãƒªã‚·ãƒ¼" + +#: describe.c:945 describe.c:4749 describe.c:4753 msgid "Access privileges" msgstr "アクセス権" -#: describe.c:831 +#: describe.c:976 #, c-format -msgid "The server (version %d.%d) does not support altering default privileges.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼(ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%d)ã¯ä»£æ›¿ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆæ¨©é™ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support altering default privileges.\n" +msgid "The server (version %s) does not support altering default privileges.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯ä»£æ›¿ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆæ¨©é™ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:850 +#: describe.c:996 msgid "function" msgstr "関数" -#: describe.c:852 +#: describe.c:998 msgid "type" msgstr "åž‹" -#: describe.c:876 +#: describe.c:1022 msgid "Default access privileges" msgstr "デフォルトã®ã‚¢ã‚¯ã‚»ã‚¹æ¨©é™" -#: describe.c:916 +#: describe.c:1062 msgid "Object" msgstr "オブジェクト" -#: describe.c:930 sql_help.c:1595 -msgid "constraint" -msgstr "制約" +#: describe.c:1076 +#| msgid "table_constraint" +msgid "table constraint" +msgstr "テーブル制約" -#: describe.c:957 +#: describe.c:1098 +#| msgid "domain_constraint" +msgid "domain constraint" +msgstr "ドメイン制約" + +#: describe.c:1126 msgid "operator class" msgstr "演算å­ã‚¯ãƒ©ã‚¹" -#: describe.c:986 +#: describe.c:1155 msgid "operator family" msgstr "演算å­æ—" -#: describe.c:1008 +#: describe.c:1177 msgid "rule" msgstr "ルール" -#: describe.c:1050 +#: describe.c:1219 msgid "Object descriptions" msgstr "オブジェクトã®èª¬æ˜Ž" -#: describe.c:1104 +#: describe.c:1273 #, c-format msgid "Did not find any relation named \"%s\".\n" msgstr "\"%s\" ã¨ã„ã†åå‰ã®ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“。\n" -#: describe.c:1295 +#: describe.c:1483 #, c-format msgid "Did not find any relation with OID %s.\n" msgstr "OID %s ã‚’æŒã¤ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“。\n" -#: describe.c:1399 +#: describe.c:1589 #, c-format msgid "Unlogged table \"%s.%s\"" msgstr "ログをå–らãªã„テーブル \"%s.%s\"" -#: describe.c:1402 +#: describe.c:1592 #, c-format msgid "Table \"%s.%s\"" msgstr "テーブル \"%s.%s\"" -#: describe.c:1406 +#: describe.c:1596 #, c-format msgid "View \"%s.%s\"" msgstr "ビュー \"%s.%s\"" -#: describe.c:1411 +#: describe.c:1601 #, c-format msgid "Unlogged materialized view \"%s.%s\"" msgstr "ログをå–らãªã„マテリアライズドビュー \"%s.%s\"" -#: describe.c:1414 +#: describe.c:1604 #, c-format msgid "Materialized view \"%s.%s\"" msgstr "マテリアライズドビュー \"%s.%s\"" -#: describe.c:1418 +#: describe.c:1608 #, c-format msgid "Sequence \"%s.%s\"" msgstr "シーケンス \"%s.%s\"" -#: describe.c:1423 +#: describe.c:1613 #, c-format msgid "Unlogged index \"%s.%s\"" msgstr "ログをå–らãªã„インデックス \"%s.%s\"" -#: describe.c:1426 +#: describe.c:1616 #, c-format msgid "Index \"%s.%s\"" msgstr "インデックス \"%s.%s\"" -#: describe.c:1431 +#: describe.c:1621 #, c-format msgid "Special relation \"%s.%s\"" msgstr "特殊ãªãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ \"%s.%s\"" -#: describe.c:1435 +#: describe.c:1625 #, c-format msgid "TOAST table \"%s.%s\"" msgstr "TOAST テーブル \"%s.%s\"" -#: describe.c:1439 +#: describe.c:1629 #, c-format msgid "Composite type \"%s.%s\"" msgstr "複åˆåž‹ \"%s.%s\"" -#: describe.c:1443 +#: describe.c:1633 #, c-format msgid "Foreign table \"%s.%s\"" msgstr "外部テーブル \"%s.%s\"" -#: describe.c:1454 +#: describe.c:1644 msgid "Column" msgstr "列" -#: describe.c:1463 +#: describe.c:1653 msgid "Modifiers" msgstr "修飾語" -#: describe.c:1468 +#: describe.c:1658 msgid "Value" msgstr "値" -#: describe.c:1471 +#: describe.c:1661 msgid "Definition" msgstr "定義" -#: describe.c:1474 describe.c:4018 describe.c:4099 describe.c:4167 -#: describe.c:4228 +#: describe.c:1664 describe.c:4312 describe.c:4396 describe.c:4467 +#: describe.c:4531 msgid "FDW Options" msgstr "FDWオプション" -#: describe.c:1478 +#: describe.c:1668 msgid "Storage" msgstr "ストレージ" -#: describe.c:1481 +#: describe.c:1671 msgid "Stats target" msgstr "対象統計情報" -#: describe.c:1531 +#: describe.c:1721 #, c-format msgid "collate %s" msgstr "ç…§åˆé †åº %s" -#: describe.c:1539 +#: describe.c:1729 msgid "not null" msgstr "not null" #. translator: default values of column definitions -#: describe.c:1549 +#: describe.c:1739 #, c-format msgid "default %s" msgstr "default %s" -#: describe.c:1664 +#: describe.c:1854 msgid "primary key, " msgstr "プライマリキー, " -#: describe.c:1666 +#: describe.c:1856 msgid "unique, " msgstr "ユニーク, " -#: describe.c:1672 +#: describe.c:1862 #, c-format msgid "for table \"%s.%s\"" msgstr "テーブル \"%s.%s\" 用" -#: describe.c:1676 +#: describe.c:1866 #, c-format msgid ", predicate (%s)" msgstr ", 述語 (%s)" -#: describe.c:1679 +#: describe.c:1869 msgid ", clustered" msgstr ", クラスタ化済ã¿" -#: describe.c:1682 +#: describe.c:1872 msgid ", invalid" msgstr ", 無効" -#: describe.c:1685 +#: describe.c:1875 msgid ", deferrable" msgstr ", é…延å¯èƒ½" -#: describe.c:1688 +#: describe.c:1878 msgid ", initially deferred" msgstr ", 最åˆã‹ã‚‰é…延ã•ã‚Œã¦ã„ã‚‹" -#: describe.c:1691 +#: describe.c:1881 msgid ", replica identity" msgstr "レプリカ特性" -#: describe.c:1726 +#: describe.c:1916 #, c-format msgid "Owned by: %s" msgstr "所有者: %s" -#: describe.c:1786 +#: describe.c:1976 msgid "Indexes:" msgstr "インデックス:" -#: describe.c:1870 +#: describe.c:2060 msgid "Check constraints:" msgstr "検査制約:" -#: describe.c:1901 +#: describe.c:2091 msgid "Foreign-key constraints:" msgstr "外部キー制約:" -#: describe.c:1932 +#: describe.c:2122 msgid "Referenced by:" msgstr "å‚照元：" -#: describe.c:2014 describe.c:2064 +#: describe.c:2167 +msgid "Policies:" +msgstr "ãƒãƒªã‚·ãƒ¼:" + +#: describe.c:2170 +msgid "Policies (forced row security enabled):" +msgstr "ãƒãƒªã‚·ãƒ¼ (FORCE指定ã•ã‚ŒãŸè¡Œã‚»ã‚­ãƒ¥ãƒªãƒ†ã‚£ãŒæœ‰åŠ¹):" + +#: describe.c:2173 +msgid "Policies (row security enabled): (none)" +msgstr "ãƒãƒªã‚·ãƒ¼ (行セキュリティãŒæœ‰åŠ¹): (ãƒãƒªã‚·ãƒ¼ãŒã‚ã‚Šã¾ã›ã‚“)" + +#: describe.c:2176 +msgid "Policies (forced row security enabled): (none)" +msgstr "ãƒãƒªã‚·ãƒ¼ (FORCE指定ã•ã‚ŒãŸè¡Œã‚»ã‚­ãƒ¥ãƒªãƒ†ã‚£ãŒæœ‰åŠ¹): (ãƒãƒªã‚·ãƒ¼ãŒã‚ã‚Šã¾ã›ã‚“)" + +#: describe.c:2179 +msgid "Policies (row security disabled):" +msgstr "ãƒãƒªã‚·ãƒ¼ (行セキュリティãŒç„¡åŠ¹):" + +#: describe.c:2279 describe.c:2329 msgid "Rules:" msgstr "ルール:" -#: describe.c:2017 +#: describe.c:2282 msgid "Disabled rules:" msgstr "無効ã«ã•ã‚ŒãŸãƒ«ãƒ¼ãƒ«ï¼š" -#: describe.c:2020 +#: describe.c:2285 msgid "Rules firing always:" msgstr "常ã«ç„¡è¦–ã•ã‚Œã‚‹ãƒ«ãƒ¼ãƒ«" -#: describe.c:2023 +#: describe.c:2288 msgid "Rules firing on replica only:" msgstr "レプリカã§ã®ã¿ç„¡è¦–ã•ã‚Œã‚‹ãƒ«ãƒ¼ãƒ«" -#: describe.c:2047 +#: describe.c:2312 msgid "View definition:" msgstr "ビュー定義:" -#: describe.c:2182 +#: describe.c:2447 msgid "Triggers:" msgstr "トリガ:" -#: describe.c:2186 +#: describe.c:2451 msgid "Disabled user triggers:" msgstr "無効ã«ã•ã‚ŒãŸãƒ¦ãƒ¼ã‚¶ãƒˆãƒªã‚¬ï¼š" -#: describe.c:2188 +#: describe.c:2453 msgid "Disabled triggers:" msgstr "無効ã«ã•ã‚ŒãŸãƒˆãƒªã‚¬ï¼š" -#: describe.c:2191 +#: describe.c:2456 msgid "Disabled internal triggers:" msgstr "無効ã«ã•ã‚ŒãŸå†…部トリガ：" -#: describe.c:2194 +#: describe.c:2459 msgid "Triggers firing always:" msgstr "常ã«ç„¡è¦–ã•ã‚Œã‚‹ãƒˆãƒªã‚¬" -#: describe.c:2197 +#: describe.c:2462 msgid "Triggers firing on replica only:" msgstr "レプリカã§ã®ã¿ç„¡è¦–ã•ã‚Œã‚‹ãƒˆãƒªã‚¬" -#: describe.c:2276 +#: describe.c:2541 msgid "Inherits" msgstr "継承" -#: describe.c:2315 +#: describe.c:2580 #, c-format msgid "Number of child tables: %d (Use \\d+ to list them.)" msgstr "å­ãƒ†ãƒ¼ãƒ–ルã®æ•°ï¼š%d（\\d+ ã§ä¸€è¦§è¡¨ç¤ºï¼‰" -#: describe.c:2322 +#: describe.c:2587 msgid "Child tables" msgstr "å­ãƒ†ãƒ¼ãƒ–ル" -#: describe.c:2344 +#: describe.c:2609 #, c-format msgid "Typed table of type: %s" msgstr "型付ã‘ã•ã‚ŒãŸãƒ†ãƒ¼ãƒ–ルã®åž‹ï¼š%s" -#: describe.c:2358 +#: describe.c:2623 msgid "Replica Identity" msgstr "レプリカ特性" -#: describe.c:2371 +#: describe.c:2636 msgid "Has OIDs: yes" msgstr "OID ã‚’æŒã¤: ã¯ã„" -#: describe.c:2460 +#: describe.c:2724 #, c-format msgid "Tablespace: \"%s\"" msgstr "テーブルスペース \"%s\"" #. translator: before this string there's an index description like #. '"foo_pkey" PRIMARY KEY, btree (a)' -#: describe.c:2472 +#: describe.c:2736 #, c-format msgid ", tablespace \"%s\"" msgstr "テーブルスペース \"%s\"" -#: describe.c:2557 +#: describe.c:2829 msgid "List of roles" msgstr "ロール一覧" -#: describe.c:2559 +#: describe.c:2831 msgid "Role name" msgstr "ロールå" -#: describe.c:2560 +#: describe.c:2832 msgid "Attributes" msgstr "属性" -#: describe.c:2561 +#: describe.c:2833 msgid "Member of" msgstr "メンãƒãƒ¼" -#: describe.c:2572 +#: describe.c:2844 msgid "Superuser" msgstr "スーパーユーザ" -#: describe.c:2575 +#: describe.c:2847 msgid "No inheritance" msgstr "継承ãªã—" -#: describe.c:2578 +#: describe.c:2850 msgid "Create role" msgstr "ロールを作æˆã§ãã‚‹" -#: describe.c:2581 +#: describe.c:2853 msgid "Create DB" msgstr "DBを作æˆã§ãã‚‹" -#: describe.c:2584 +#: describe.c:2856 msgid "Cannot login" msgstr "ログインã§ããªã„" -#: describe.c:2588 +#: describe.c:2860 msgid "Replication" msgstr "レプリケーション" -#: describe.c:2597 +#: describe.c:2864 +msgid "Bypass RLS" +msgstr "è¡Œå˜ä½ã‚»ã‚­ãƒ¥ãƒªãƒ†ã‚£ã‚’無視" + +#: describe.c:2873 msgid "No connections" msgstr "接続ãªã—" -#: describe.c:2599 +#: describe.c:2875 #, c-format msgid "%d connection" msgid_plural "%d connections" msgstr[0] "%d 個ã®æŽ¥ç¶š" msgstr[1] "%d 個ã®æŽ¥ç¶š" -#: describe.c:2609 +#: describe.c:2885 msgid "Password valid until " msgstr "パスワード有効期é™" -#: describe.c:2665 +#: describe.c:2941 msgid "Role" msgstr "ロール" -#: describe.c:2666 +#: describe.c:2942 msgid "Database" msgstr "データベース" -#: describe.c:2667 +#: describe.c:2943 msgid "Settings" msgstr "設定" -#: describe.c:2677 +#: describe.c:2953 #, c-format msgid "No per-database role settings support in this server version.\n" msgstr "ã“ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®ã‚µãƒ¼ãƒãƒ¼ã§ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹æ¯Žã®ãƒ­ãƒ¼ãƒ«è¨­å®šã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:2688 +#: describe.c:2964 #, c-format msgid "No matching settings found.\n" msgstr "マッãƒã™ã‚‹è¨­å®šãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: describe.c:2690 +#: describe.c:2966 #, c-format msgid "No settings found.\n" msgstr "設定ãŒã‚ã‚Šã¾ã›ã‚“。\n" -#: describe.c:2695 +#: describe.c:2971 msgid "List of settings" msgstr "設定ã®ä¸€è¦§" -#: describe.c:2764 +#: describe.c:3040 msgid "index" msgstr "インデックス" -#: describe.c:2766 +#: describe.c:3042 msgid "special" msgstr "特殊" -#: describe.c:2774 describe.c:4216 +#: describe.c:3050 describe.c:4519 msgid "Table" msgstr "テーブル" -#: describe.c:2850 +#: describe.c:3126 #, c-format msgid "No matching relations found.\n" msgstr "マッãƒã™ã‚‹ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: describe.c:2852 +#: describe.c:3128 #, c-format msgid "No relations found.\n" msgstr "リレーションãŒã‚ã‚Šã¾ã›ã‚“。\n" -#: describe.c:2857 +#: describe.c:3133 msgid "List of relations" msgstr "リレーションã®ä¸€è¦§" -#: describe.c:2894 +#: describe.c:3170 msgid "Trusted" msgstr "ä¿¡é ¼?" -#: describe.c:2902 +#: describe.c:3178 msgid "Internal Language" msgstr "内部言語" -#: describe.c:2903 +#: describe.c:3179 msgid "Call Handler" msgstr "呼ã³å‡ºã—ãƒãƒ³ãƒ‰ãƒ©ãƒ¼" -#: describe.c:2904 describe.c:4005 +#: describe.c:3180 describe.c:4299 msgid "Validator" msgstr "ãƒãƒªãƒ‡ãƒ¼ã‚¿" -#: describe.c:2907 +#: describe.c:3183 msgid "Inline Handler" msgstr "インラインãƒãƒ³ãƒ‰ãƒ©ãƒ¼" -#: describe.c:2935 +#: describe.c:3211 msgid "List of languages" msgstr "言語一覧" -#: describe.c:2979 +#: describe.c:3255 msgid "Modifier" msgstr "修飾語" -#: describe.c:2980 +#: describe.c:3256 msgid "Check" msgstr "ãƒã‚§ãƒƒã‚¯" -#: describe.c:3022 +#: describe.c:3298 msgid "List of domains" msgstr "ドメイン一覧" -#: describe.c:3056 +#: describe.c:3332 msgid "Source" msgstr "ソース" -#: describe.c:3057 +#: describe.c:3333 msgid "Destination" msgstr "宛先" -#: describe.c:3058 describe.c:3207 +#: describe.c:3334 describe.c:3483 msgid "no" msgstr "no" -#: describe.c:3058 describe.c:3209 +#: describe.c:3334 describe.c:3485 msgid "yes" msgstr "yes" -#: describe.c:3059 +#: describe.c:3335 msgid "Default?" msgstr "デフォルト？" -#: describe.c:3096 +#: describe.c:3372 msgid "List of conversions" msgstr "変æ›ãƒ«ãƒ¼ãƒ«ä¸€è¦§" -#: describe.c:3135 +#: describe.c:3411 msgid "Event" msgstr "イベント" -#: describe.c:3137 +#: describe.c:3413 msgid "enabled" msgstr "有効" -#: describe.c:3138 +#: describe.c:3414 msgid "replica" msgstr "レプリカ" -#: describe.c:3139 +#: describe.c:3415 msgid "always" msgstr "常ã«" -#: describe.c:3140 +#: describe.c:3416 msgid "disabled" msgstr "無効" -#: describe.c:3141 +#: describe.c:3417 msgid "Enabled" msgstr "有効" -#: describe.c:3142 +#: describe.c:3418 msgid "Procedure" msgstr "プロシージャ" -#: describe.c:3143 +#: describe.c:3419 msgid "Tags" msgstr "ã‚¿ã‚°" -#: describe.c:3162 +#: describe.c:3438 msgid "List of event triggers" msgstr "イベントトリガã®ä¸€è¦§" -#: describe.c:3204 +#: describe.c:3480 msgid "Source type" msgstr "ソースã®åž‹" -#: describe.c:3205 +#: describe.c:3481 msgid "Target type" msgstr "ターゲットã®åž‹" -#: describe.c:3208 +#: describe.c:3484 msgid "in assignment" msgstr "代入" -#: describe.c:3210 +#: describe.c:3486 msgid "Implicit?" msgstr "æš—é»™?" -#: describe.c:3261 +#: describe.c:3537 msgid "List of casts" msgstr "キャスト一覧" -#: describe.c:3287 +#: describe.c:3565 #, c-format -msgid "The server (version %d.%d) does not support collations.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ (%d.%d) ã¯ç…§åˆé †åºã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support collations.\n" +msgid "The server (version %s) does not support collations.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯ç…§åˆé †åºã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:3337 +#: describe.c:3616 msgid "List of collations" msgstr "ç…§åˆé †åºä¸€è¦§" -#: describe.c:3396 +#: describe.c:3675 msgid "List of schemas" msgstr "スキーマ一覧" -#: describe.c:3419 describe.c:3654 describe.c:3722 describe.c:3790 +#: describe.c:3700 describe.c:3938 describe.c:4009 describe.c:4080 #, c-format -msgid "The server (version %d.%d) does not support full text search.\n" -msgstr "ã“ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ (%d.%d) ã®ã‚µãƒ¼ãƒãƒ¼ã¯å…¨æ–‡æ¤œç´¢ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support full text search.\n" +msgid "The server (version %s) does not support full text search.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯å…¨æ–‡æ¤œç´¢ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:3453 +#: describe.c:3735 msgid "List of text search parsers" msgstr "テキスト検索用パーサ一覧" -#: describe.c:3496 +#: describe.c:3778 #, c-format msgid "Did not find any text search parser named \"%s\".\n" msgstr "テキスト検索用パーサ \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“。\n" -#: describe.c:3571 +#: describe.c:3853 msgid "Start parse" msgstr "パース起動" -#: describe.c:3572 +#: describe.c:3854 msgid "Method" msgstr "メソッド" -#: describe.c:3576 +#: describe.c:3858 msgid "Get next token" msgstr "次ã®ãƒˆãƒ¼ã‚¯ãƒ³ã‚’å–å¾—" -#: describe.c:3578 +#: describe.c:3860 msgid "End parse" msgstr "パース終了" -#: describe.c:3580 +#: describe.c:3862 msgid "Get headline" msgstr "見出ã—ã®å–å¾—" -#: describe.c:3582 +#: describe.c:3864 msgid "Get token types" msgstr "トークンタイプã®å–å¾—" -#: describe.c:3592 +#: describe.c:3874 #, c-format msgid "Text search parser \"%s.%s\"" msgstr "テキスト検索用パーサ \"%s.%s\"" -#: describe.c:3594 +#: describe.c:3876 #, c-format msgid "Text search parser \"%s\"" msgstr "テキスト検索用パーサ \"%s\"" -#: describe.c:3613 +#: describe.c:3895 msgid "Token name" msgstr "トークンå" -#: describe.c:3624 +#: describe.c:3906 #, c-format msgid "Token types for parser \"%s.%s\"" msgstr "パーサ \"%s.%s\" ã®ãƒˆãƒ¼ã‚¯ãƒ³ã‚¿ã‚¤ãƒ—" -#: describe.c:3626 +#: describe.c:3908 #, c-format msgid "Token types for parser \"%s\"" msgstr "パーサ \"%s\" ã®ãƒˆãƒ¼ã‚¯ãƒ³ã‚¿ã‚¤ãƒ—" -#: describe.c:3676 +#: describe.c:3961 msgid "Template" msgstr "テンプレート" -#: describe.c:3677 +#: describe.c:3962 msgid "Init options" msgstr "åˆæœŸåŒ–オプション:" -#: describe.c:3699 +#: describe.c:3984 msgid "List of text search dictionaries" msgstr "テキスト検索用辞書ã®ä¸€è¦§" -#: describe.c:3739 +#: describe.c:4027 msgid "Init" msgstr "åˆæœŸåŒ–" -#: describe.c:3740 +#: describe.c:4028 msgid "Lexize" msgstr "Lex 処ç†" -#: describe.c:3767 +#: describe.c:4055 msgid "List of text search templates" msgstr "テキスト検索用テンプレート一覧" -#: describe.c:3824 +#: describe.c:4115 msgid "List of text search configurations" msgstr "テキスト検索用設定一覧" -#: describe.c:3868 +#: describe.c:4159 #, c-format msgid "Did not find any text search configuration named \"%s\".\n" msgstr "テキスト検索用設定 \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“。\n" -#: describe.c:3934 +#: describe.c:4225 msgid "Token" msgstr "トークン" -#: describe.c:3935 +#: describe.c:4226 msgid "Dictionaries" msgstr "辞書" -#: describe.c:3946 +#: describe.c:4237 #, c-format msgid "Text search configuration \"%s.%s\"" msgstr "テキスト検索用設定 \"%s.%s\"" -#: describe.c:3949 +#: describe.c:4240 #, c-format msgid "Text search configuration \"%s\"" msgstr "テキスト検索用設定 \"%s\"" -#: describe.c:3953 +#: describe.c:4244 #, c-format msgid "" "\n" @@ -1577,7 +1847,7 @@ msgstr "" "\n" "パーサ： \"%s.%s\"" -#: describe.c:3956 +#: describe.c:4247 #, c-format msgid "" "\n" @@ -1586,96 +1856,97 @@ msgstr "" "\n" "パーサ：\"%s\"" -#: describe.c:3988 +#: describe.c:4281 #, c-format -msgid "The server (version %d.%d) does not support foreign-data wrappers.\n" -msgstr "ã“ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ (%d.%d) ã®ã‚µãƒ¼ãƒãƒ¼ã¯å¤–部データラッパーをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support foreign-data wrappers.\n" +msgid "The server (version %s) does not support foreign-data wrappers.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯å¤–部データラッパーをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:4002 -msgid "Handler" -msgstr "ãƒãƒ³ãƒ‰ãƒ©ãƒ¼" - -#: describe.c:4045 +#: describe.c:4339 msgid "List of foreign-data wrappers" msgstr "外部データラッパーã®ä¸€è¦§" -#: describe.c:4068 +#: describe.c:4364 #, c-format -msgid "The server (version %d.%d) does not support foreign servers.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼(ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%d)ã¯å¤–部サーãƒãƒ¼ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support foreign servers.\n" +msgid "The server (version %s) does not support foreign servers.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯å¤–部サーãƒãƒ¼ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:4080 +#: describe.c:4377 msgid "Foreign-data wrapper" msgstr "外部データラッパー" -#: describe.c:4098 describe.c:4293 +#: describe.c:4395 describe.c:4600 msgid "Version" msgstr "ãƒãƒ¼ã‚¸ãƒ§ãƒ³" -#: describe.c:4124 +#: describe.c:4421 msgid "List of foreign servers" msgstr "外部サーãƒãƒ¼ä¸€è¦§" -#: describe.c:4147 +#: describe.c:4446 #, c-format -msgid "The server (version %d.%d) does not support user mappings.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼(ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%d)ã¯ãƒ¦ãƒ¼ã‚¶ãƒžãƒƒãƒ—をサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support user mappings.\n" +msgid "The server (version %s) does not support user mappings.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯ãƒ¦ãƒ¼ã‚¶ãƒžãƒƒãƒ—をサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:4156 describe.c:4217 +#: describe.c:4456 describe.c:4520 msgid "Server" msgstr "サーãƒãƒ¼" -#: describe.c:4157 +#: describe.c:4457 msgid "User name" msgstr "ユーザå" -#: describe.c:4182 +#: describe.c:4482 msgid "List of user mappings" msgstr "ユーザマッピングã®ä¸€è¦§" -#: describe.c:4205 +#: describe.c:4507 #, c-format -msgid "The server (version %d.%d) does not support foreign tables.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼(ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%d)ã¯å¤–部テーブルをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support foreign tables.\n" +msgid "The server (version %s) does not support foreign tables.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯å¤–部テーブルをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:4256 +#: describe.c:4560 msgid "List of foreign tables" msgstr "外部テーブル一覧" -#: describe.c:4279 describe.c:4333 +#: describe.c:4585 describe.c:4642 #, c-format -msgid "The server (version %d.%d) does not support extensions.\n" -msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ (%d.%d) ã¯æ‹¡å¼µã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" +#| msgid "The server (version %d.%d) does not support extensions.\n" +msgid "The server (version %s) does not support extensions.\n" +msgstr "ã“ã®ã‚µãƒ¼ãƒãƒ¼ (ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %s) ã¯æ‹¡å¼µã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: describe.c:4310 +#: describe.c:4617 msgid "List of installed extensions" msgstr "インストール済ã¿ã®æ‹¡å¼µã®ä¸€è¦§" -#: describe.c:4360 +#: describe.c:4670 #, c-format msgid "Did not find any extension named \"%s\".\n" msgstr "\"%s\" ã¨ã„ã†åå‰ã®æ‹¡å¼µãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“。\n" -#: describe.c:4363 +#: describe.c:4673 #, c-format msgid "Did not find any extensions.\n" msgstr "æ‹¡å¼µãŒã¾ã£ãŸã見ã¤ã‹ã‚Šã¾ã›ã‚“。\n" -#: describe.c:4407 +#: describe.c:4717 msgid "Object Description" msgstr "オブジェクトã®èª¬æ˜Ž" -#: describe.c:4416 +#: describe.c:4726 #, c-format msgid "Objects in extension \"%s\"" msgstr "æ‹¡å¼µ\"%s\"内ã®ã‚ªãƒ–ジェクト" -#: help.c:62 +#: help.c:63 #, c-format msgid "%s\n" msgstr "%s\n" -#: help.c:67 +#: help.c:74 #, c-format msgid "" "psql is the PostgreSQL interactive terminal.\n" @@ -1684,12 +1955,12 @@ msgstr "" "psql 㯠PostgreSQL ã®ä¼šè©±åž‹ã‚¿ãƒ¼ãƒŸãƒŠãƒ«ã§ã™ã€‚\n" "\n" -#: help.c:68 +#: help.c:75 help.c:333 help.c:367 help.c:394 #, c-format msgid "Usage:\n" msgstr "使用方法:\n" -#: help.c:69 +#: help.c:76 #, c-format msgid "" " psql [OPTION]... [DBNAME [USERNAME]]\n" @@ -1698,51 +1969,56 @@ msgstr "" " psql [オプション]... [データベースå [ユーザå]]\n" "\n" -#: help.c:71 +#: help.c:78 #, c-format msgid "General options:\n" msgstr "一般的ãªã‚ªãƒ—ション：\n" -#: help.c:76 +#: help.c:83 #, c-format msgid " -c, --command=COMMAND run only single command (SQL or internal) and exit\n" msgstr " -c, --command=コマンド (SQLã¾ãŸã¯å†…部ã®)å˜ä¸€ã‚³ãƒžãƒ³ãƒ‰ã‚’一ã¤ã ã‘実行ã—ã¦çµ‚了\n" -#: help.c:77 +#: help.c:84 #, c-format msgid " -d, --dbname=DBNAME database name to connect to (default: \"%s\")\n" msgstr " -d, --dbname=DBå 接続ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹åを指定(デフォルト: \"%s\")\n" -#: help.c:78 +#: help.c:85 #, c-format msgid " -f, --file=FILENAME execute commands from file, then exit\n" msgstr " -f, --file=ファイルå ファイルã‹ã‚‰ã‚³ãƒžãƒ³ãƒ‰ã‚’読ã¿è¾¼ã‚“ã§å®Ÿè¡Œå¾Œã€çµ‚了\n" -#: help.c:79 +#: help.c:86 #, c-format msgid " -l, --list list available databases, then exit\n" msgstr " -l(エル), --list 使用å¯èƒ½ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ä¸€è¦§ã‚’表示ã—ã¦çµ‚了\n" -#: help.c:80 +#: help.c:87 #, c-format +#| msgid "" +#| " -v, --set=, --variable=NAME=VALUE\n" +#| " set psql variable NAME to VALUE\n" msgid "" " -v, --set=, --variable=NAME=VALUE\n" " set psql variable NAME to VALUE\n" +" (e.g., -v ON_ERROR_STOP=1)\n" msgstr "" " -v, --set=, --variable=åå‰=値\n" " psql 変数 'åå‰' ã« '値' をセット\n" +" (-v ON_ERROR_STOP=1 ç­‰)\n" -#: help.c:82 +#: help.c:90 #, c-format msgid " -V, --version output version information, then exit\n" -msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" +msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã¦çµ‚了\n" -#: help.c:83 +#: help.c:91 #, c-format msgid " -X, --no-psqlrc do not read startup file (~/.psqlrc)\n" msgstr " -X, --no-psqlrc åˆæœŸåŒ–ファイル (~/.psqlrc) を読ã¿ã“ã¾ãªã„\n" -#: help.c:84 +#: help.c:92 #, c-format msgid "" " -1 (\"one\"), --single-transaction\n" @@ -1751,12 +2027,24 @@ msgstr "" " -1(æ•°å­—ã®ï¼‘), --single-transaction\n" " å˜ä¸€ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã¨ã—ã¦å®Ÿè¡Œ(対話å¼ã§ãªã„å ´åˆ)\n" -#: help.c:86 +#: help.c:94 +#, c-format +#| msgid " -?, --help show this help, then exit\n" +msgid " -?, --help[=options] show this help, then exit\n" +msgstr " -?, --help[=options] ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã¦çµ‚了\n" + +#: help.c:95 #, c-format -msgid " -?, --help show this help, then exit\n" -msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" +msgid " --help=commands list backslash commands, then exit\n" +msgstr " --help=commands ãƒãƒƒã‚¯ã‚¹ãƒ©ãƒƒã‚·ãƒ¥ã‚³ãƒžãƒ³ãƒ‰ä¸€è¦§ã‚’表示ã—ã¦çµ‚了\n" -#: help.c:88 +#: help.c:96 +#, c-format +#| msgid " -l, --list list available databases, then exit\n" +msgid " --help=variables list special variables, then exit\n" +msgstr " --help=variables 特別ãªå¤‰æ•°ä¸€è¦§ã‚’表示ã—ã¦çµ‚了\n" + +#: help.c:98 #, c-format msgid "" "\n" @@ -1765,52 +2053,58 @@ msgstr "" "\n" "入出力オプション：\n" -#: help.c:89 +#: help.c:99 #, c-format msgid " -a, --echo-all echo all input from script\n" msgstr " -a, --echo-all スクリプトã‹ã‚‰ã®ã™ã¹ã¦ã®å…¥åŠ›ã‚’表示\n" -#: help.c:90 +#: help.c:100 +#, c-format +#| msgid " -e, --echo-queries echo commands sent to server\n" +msgid " -b, --echo-errors echo failed commands\n" +msgstr " -b, --echo-errors 失敗ã—ãŸã‚³ãƒžãƒ³ãƒ‰ã‚’表示\n" + +#: help.c:101 #, c-format msgid " -e, --echo-queries echo commands sent to server\n" msgstr " -e, --echo-queries サーãƒãƒ¼ã¸é€ä¿¡ã—ãŸã‚³ãƒžãƒ³ãƒ‰ã‚’表示\n" -#: help.c:91 +#: help.c:102 #, c-format msgid " -E, --echo-hidden display queries that internal commands generate\n" msgstr " -E, --echo-hidden 内部コマンドãŒç”Ÿæˆã—ãŸå•ã„åˆã‚ã›ã‚’表示\n" -#: help.c:92 +#: help.c:103 #, c-format msgid " -L, --log-file=FILENAME send session log to file\n" msgstr " -L, --log-file=ファイルå セッションログをファイルã«æ›¸ã込む\n" -#: help.c:93 +#: help.c:104 #, c-format msgid " -n, --no-readline disable enhanced command line editing (readline)\n" msgstr " -n, --no-readline 拡張コマンドライン編集機能(readline)を無効ã«ã™ã‚‹\n" -#: help.c:94 +#: help.c:105 #, c-format msgid " -o, --output=FILENAME send query results to file (or |pipe)\n" msgstr " -o, --output=ファイルå å•ã„åˆã‚ã›çµæžœã‚’ファイル(ã¾ãŸã¯ |パイプ)ã«é€ã‚‹\n" -#: help.c:95 +#: help.c:106 #, c-format msgid " -q, --quiet run quietly (no messages, only query output)\n" msgstr " -q, --quiet é™ã‹ã«å®Ÿè¡Œ(メッセージãªã—ã§ã€å•ã„åˆã‚ã›ã®å‡ºåŠ›ã®ã¿)\n" -#: help.c:96 +#: help.c:107 #, c-format msgid " -s, --single-step single-step mode (confirm each query)\n" msgstr " -s, --single-step シングルステップモード(å„å•ã„åˆã‚ã›ã”ã¨ã«ç¢ºèª)\n" -#: help.c:97 +#: help.c:108 #, c-format msgid " -S, --single-line single-line mode (end of line terminates SQL command)\n" msgstr " -S, --single-line å˜ä¸€è¡Œãƒ¢ãƒ¼ãƒ‰(行末を SQL コマンドã®çµ‚了ã¨ã¿ãªã™)\n" -#: help.c:99 +#: help.c:110 #, c-format msgid "" "\n" @@ -1819,12 +2113,12 @@ msgstr "" "\n" "出力フォーマットオプション:\n" -#: help.c:100 +#: help.c:111 #, c-format msgid " -A, --no-align unaligned table output mode\n" msgstr " -A, --no-align æ¡æƒãˆãªã—ã®ãƒ†ãƒ¼ãƒ–ル出力モード\n" -#: help.c:101 +#: help.c:112 #, c-format msgid "" " -F, --field-separator=STRING\n" @@ -1833,17 +2127,17 @@ msgstr "" " -F, --field-separator=文字列\n" " æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰åŒºåˆ‡ã‚Šæ–‡å­—(デフォルト: \"%s\")\n" -#: help.c:104 +#: help.c:115 #, c-format msgid " -H, --html HTML table output mode\n" msgstr " -H, --html HTML テーブル出力モード\n" -#: help.c:105 +#: help.c:116 #, c-format msgid " -P, --pset=VAR[=ARG] set printing option VAR to ARG (see \\pset command)\n" msgstr " -P, --pset=変数[=値] 表示オプション '変数' ã‚’ '値' ã«ã‚»ãƒƒãƒˆ (\\pset コマンドをå‚ç…§)\n" -#: help.c:106 +#: help.c:117 #, c-format msgid "" " -R, --record-separator=STRING\n" @@ -1852,22 +2146,22 @@ msgstr "" " -R, --record-separator=文字列\n" " æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ¬ã‚³ãƒ¼ãƒ‰åŒºåˆ‡ã‚Šæ–‡å­—(デフォルト：改行)\n" -#: help.c:108 +#: help.c:119 #, c-format msgid " -t, --tuples-only print rows only\n" msgstr " -t, --tuples-only è¡Œã®ã¿ã‚’表示\n" -#: help.c:109 +#: help.c:120 #, c-format msgid " -T, --table-attr=TEXT set HTML table tag attributes (e.g., width, border)\n" msgstr " -T, --table-attr=TEXT HTMLテーブルã®ã‚¿ã‚°å±žæ€§ã‚’セット(width, borderç­‰)\n" -#: help.c:110 +#: help.c:121 #, c-format msgid " -x, --expanded turn on expanded table output\n" msgstr " -x, --expanded 拡張テーブル出力を有効ã«ã™ã‚‹\n" -#: help.c:111 +#: help.c:122 #, c-format msgid "" " -z, --field-separator-zero\n" @@ -1876,7 +2170,7 @@ msgstr "" " -z, --field-separator-zero\n" " æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰åŒºåˆ‡ã‚Šæ–‡å­—をゼロãƒã‚¤ãƒˆã«è¨­å®š\n" -#: help.c:113 +#: help.c:124 #, c-format msgid "" " -0, --record-separator-zero\n" @@ -1885,7 +2179,7 @@ msgstr "" " -0, --record-separator-zero\n" " æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ¬ã‚³ãƒ¼ãƒ‰åŒºåˆ‡ã‚Šæ–‡å­—をゼロãƒã‚¤ãƒˆã«è¨­å®š\n" -#: help.c:116 +#: help.c:127 #, c-format msgid "" "\n" @@ -1894,38 +2188,38 @@ msgstr "" "\n" "接続オプション:\n" -#: help.c:119 +#: help.c:130 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory (default: \"%s\")\n" msgstr " -h, --host=ホストå データベースサーãƒãƒ¼ã®ãƒ›ã‚¹ãƒˆã¾ãŸã¯ã‚½ã‚±ãƒƒãƒˆã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒª(デフォルト: \"%s\")\n" -#: help.c:120 +#: help.c:131 msgid "local socket" msgstr "ローカルソケット" -#: help.c:123 +#: help.c:134 #, c-format msgid " -p, --port=PORT database server port (default: \"%s\")\n" msgstr " -p, --port=ãƒãƒ¼ãƒˆç•ªå· データベースサーãƒãƒ¼ã®ãƒãƒ¼ãƒˆç•ªå·(デフォルト： \"%s\")\n" -#: help.c:129 +#: help.c:140 #, c-format msgid " -U, --username=USERNAME database user name (default: \"%s\")\n" msgstr " -U, --username=ユーザーå データベースã®ãƒ¦ãƒ¼ã‚¶å(デフォルト: \"%s\")\n" -#: help.c:130 +#: help.c:141 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password パスワード入力をè¦æ±‚ã—ãªã„\n" -#: help.c:131 +#: help.c:142 #, c-format msgid " -W, --password force password prompt (should happen automatically)\n" msgstr "" " -W, --password パスワードプロンプトを強制表示ã™ã‚‹\n" " （本æ¥ã¯è‡ªå‹•çš„ã«è¡¨ç¤ºã•ã‚Œã‚‹ã¯ãšã§ã™ï¼‰\n" -#: help.c:133 +#: help.c:144 #, c-format msgid "" "\n" @@ -1940,482 +2234,977 @@ msgstr "" "セクションをå‚ç…§ã®ã“ã¨ã€‚\n" "\n" -#: help.c:136 +#: help.c:147 #, c-format msgid "Report bugs to .\n" msgstr "ä¸å…·åˆã¯ã¾ã§å ±å‘Šã—ã¦ãã ã•ã„。\n" -#: help.c:157 +#: help.c:173 #, c-format msgid "General\n" msgstr "一般\n" -#: help.c:158 +#: help.c:174 #, c-format msgid " \\copyright show PostgreSQL usage and distribution terms\n" msgstr " \\copyright PostgreSQL ã®ä½¿ã„æ–¹ã¨é…布æ¡ä»¶ã‚’表示\n" -#: help.c:159 +#: help.c:175 +#, c-format +msgid " \\errverbose show most recent error message at maximum verbosity\n" +msgstr " \\errverbose 最も最近ã®ã‚¨ãƒ©ãƒ¼ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã‚’最大ã®å†—é•·ã•ã§è¡¨ç¤º\n" + +#: help.c:176 #, c-format msgid " \\g [FILE] or ; execute query (and send results to file or |pipe)\n" msgstr " \\g [ファイル] ã¾ãŸã¯ ';' å•ã„åˆã‚ã›ã‚’実行（ã—ã€çµæžœã‚’ファイルã¾ãŸã¯ |パイプ ã¸æ›¸ã出ã™)\n" -#: help.c:160 +#: help.c:177 +#, c-format +#| msgid " \\gset [PREFIX] execute query and store results in psql variables\n" +msgid " \\gexec execute query, then execute each value in its result\n" +msgstr " \\gexec å•ã„åˆã‚ã›ã‚’実行ã—ã¦çµæžœã®å„値を実行\n" + +#: help.c:178 #, c-format msgid " \\gset [PREFIX] execute query and store results in psql variables\n" msgstr "\\gset [PREFIX] å•ã„åˆã‚ã›ã‚’実行ã—çµæžœã‚’psql変数ã«æ ¼ç´\n" -#: help.c:161 -#, c-format -msgid " \\h [NAME] help on syntax of SQL commands, * for all commands\n" -msgstr " \\h [åå‰] SQL コマンドã®æ–‡æ³•ãƒ˜ãƒ«ãƒ—ã€* ã§å…¨ã‚³ãƒžãƒ³ãƒ‰\n" - -#: help.c:162 +#: help.c:179 #, c-format msgid " \\q quit psql\n" msgstr " \\q psql を終了ã™ã‚‹\n" -#: help.c:163 +#: help.c:180 +#, c-format +msgid " \\crosstabview [COLUMNS] execute query and display results in crosstab\n" +msgstr " \\crosstabview [COLUMNS] å•ã„åˆã‚ã›ã‚’実行ã—ã¦ã‚¯ãƒ­ã‚¹è¡¨å½¢å¼ã§çµæžœã‚’表示\n" + +#: help.c:181 #, c-format msgid " \\watch [SEC] execute query every SEC seconds\n" msgstr " \\watch [SEC] SEC秒毎ã«å•ã„åˆã‚ã›ã‚’実行ã™ã‚‹\n" -#: help.c:166 +#: help.c:184 +#, c-format +msgid "Help\n" +msgstr "ヘルプ\n" + +#: help.c:186 +#, c-format +msgid " \\? [commands] show help on backslash commands\n" +msgstr " \\? [commands] ãƒãƒƒã‚¯ã‚¹ãƒ©ãƒƒã‚·ãƒ¥ã‚³ãƒžãƒ³ãƒ‰ã®ãƒ˜ãƒ«ãƒ—を表示\n" + +#: help.c:187 +#, c-format +msgid " \\? options show help on psql command-line options\n" +msgstr " \\? options psqlコマンドラインオプションã®ãƒ˜ãƒ«ãƒ—を表示\n" + +#: help.c:188 +#, c-format +msgid " \\? variables show help on special variables\n" +msgstr " \\? variables 特別ãªå¤‰æ•°ã®ãƒ˜ãƒ«ãƒ—を表示\n" + +#: help.c:189 +#, c-format +msgid " \\h [NAME] help on syntax of SQL commands, * for all commands\n" +msgstr " \\h [åå‰] SQL コマンドã®æ–‡æ³•ãƒ˜ãƒ«ãƒ—ã€* ã§å…¨ã‚³ãƒžãƒ³ãƒ‰\n" + +#: help.c:192 #, c-format msgid "Query Buffer\n" msgstr "å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡\n" -#: help.c:167 +#: help.c:193 #, c-format msgid " \\e [FILE] [LINE] edit the query buffer (or file) with external editor\n" msgstr " \\e [ファイル] [行番å·] ç¾åœ¨ã®å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡(やファイル)を外部エディタã§ç·¨é›†ã™ã‚‹\n" -#: help.c:168 +#: help.c:194 #, c-format msgid " \\ef [FUNCNAME [LINE]] edit function definition with external editor\n" msgstr " \\ef [関数å [行番å·]] 関数定義を外部エディタã§ç·¨é›†ã™ã‚‹\n" -#: help.c:169 +#: help.c:195 +#, c-format +#| msgid " \\ef [FUNCNAME [LINE]] edit function definition with external editor\n" +msgid " \\ev [VIEWNAME [LINE]] edit view definition with external editor\n" +msgstr " \\ev [ビューå [行番å·]] ビュー定義を外部エディタã§ç·¨é›†ã™ã‚‹\n" + +#: help.c:196 #, c-format msgid " \\p show the contents of the query buffer\n" msgstr " \\p å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡ã®å†…容を表示ã™ã‚‹\n" -#: help.c:170 +#: help.c:197 #, c-format msgid " \\r reset (clear) the query buffer\n" msgstr " \\r å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡ã‚’リセット（クリア）ã™ã‚‹\n" -#: help.c:172 +#: help.c:199 #, c-format msgid " \\s [FILE] display history or save it to file\n" msgstr " \\s [ファイル] ヒストリを表示ã¾ãŸã¯ãƒ•ã‚¡ã‚¤ãƒ«ã«ä¿å­˜ã™ã‚‹\n" -#: help.c:174 +#: help.c:201 #, c-format msgid " \\w FILE write query buffer to file\n" msgstr " \\w ファイル å•ã„åˆã‚ã›ãƒãƒƒãƒ•ã‚¡ã®å†…容をファイルã«æ›¸ã出ã™\n" -#: help.c:177 +#: help.c:204 #, c-format msgid "Input/Output\n" msgstr "入出力\n" -#: help.c:178 +#: help.c:205 #, c-format msgid " \\copy ... perform SQL COPY with data stream to the client host\n" msgstr " \\copy ... クライアントホストã«å¯¾ã—ã€ãƒ‡ãƒ¼ã‚¿ã‚¹ãƒˆãƒªãƒ¼ãƒ ã‚’使ã£ã¦SQLコピーを行ã†\n" -#: help.c:179 +#: help.c:206 #, c-format msgid " \\echo [STRING] write string to standard output\n" msgstr " \\echo [文字列] 文字列を標準出力ã«æ›¸ã出ã™\n" -#: help.c:180 +#: help.c:207 #, c-format msgid " \\i FILE execute commands from file\n" msgstr " \\i ファイル ファイルã‹ã‚‰ã‚³ãƒžãƒ³ãƒ‰ã‚’読ã¿è¾¼ã‚“ã§å®Ÿè¡Œã™ã‚‹\n" -#: help.c:181 +#: help.c:208 #, c-format msgid " \\ir FILE as \\i, but relative to location of current script\n" msgstr " \\ir ファイル \\iã¨åŒã˜ã€‚ãŸã ã—ç¾åœ¨ã®ã‚¹ã‚¯ãƒªãƒ—トã®å ´æ‰€ã‹ã‚‰ã®ç›¸å¯¾ãƒ‘ス\n" -#: help.c:182 +#: help.c:209 #, c-format msgid " \\o [FILE] send all query results to file or |pipe\n" msgstr " \\o [ファイル] ã™ã¹ã¦ã®å•ã„åˆã‚ã›ã®çµæžœã‚’ファイルã¾ãŸã¯ |パイプ ã¸é€ã‚‹\n" -#: help.c:183 +#: help.c:210 #, c-format msgid " \\qecho [STRING] write string to query output stream (see \\o)\n" msgstr " \\qecho [文字列] 文字列をå•ã„åˆã‚ã›å‡ºåŠ›ã‚¹ãƒˆãƒªãƒ¼ãƒ ã«å‡ºåŠ›(\\o ã‚’å‚ç…§)\n" -#: help.c:186 +#: help.c:213 #, c-format msgid "Informational\n" msgstr "情報\n" -#: help.c:187 +#: help.c:214 #, c-format msgid " (options: S = show system objects, + = additional detail)\n" msgstr " (修飾å­: S = システムオブジェクトを表示 + = 付加情報)\n" -#: help.c:188 +#: help.c:215 #, c-format msgid " \\d[S+] list tables, views, and sequences\n" msgstr " \\d[S+] テーブルã€ãƒ“ューã€ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:189 +#: help.c:216 #, c-format msgid " \\d[S+] NAME describe table, view, sequence, or index\n" msgstr " \\d[S+] åå‰ ãƒ†ãƒ¼ãƒ–ãƒ«ã€ãƒ“ューã€ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã€ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã®èª¬æ˜Žã‚’表示ã™ã‚‹\n" -#: help.c:190 +#: help.c:217 #, c-format msgid " \\da[S] [PATTERN] list aggregates\n" msgstr " \\da[S] [パターン] 集約関数ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:191 +#: help.c:218 +#, c-format +#| msgid " \\dC[+] [PATTERN] list casts\n" +msgid " \\dA[+] [PATTERN] list access methods\n" +msgstr " \\dA[+] [パターン] アクセスメソッドã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" + +#: help.c:219 #, c-format msgid " \\db[+] [PATTERN] list tablespaces\n" msgstr " \\db[+] [パターン] テーブルスペースã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:192 +#: help.c:220 #, c-format msgid " \\dc[S+] [PATTERN] list conversions\n" -msgstr " \\dc[S+] [パターン] 変æ›ãƒ«ãƒ¼ãƒ«ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" +msgstr " \\dc[S+] [パターン] 変æ›ãƒ«ãƒ¼ãƒ«ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:193 +#: help.c:221 #, c-format msgid " \\dC[+] [PATTERN] list casts\n" -msgstr " \\dC[+] [パターン] キャストã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" +msgstr " \\dC[+] [パターン] キャストã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:194 +#: help.c:222 #, c-format msgid " \\dd[S] [PATTERN] show object descriptions not displayed elsewhere\n" msgstr " \\dd[S] [パターン] ä»–ã§ã¯è¡¨ç¤ºã•ã‚Œãªã„オブジェクトã®èª¬æ˜Žã‚’表示ã™ã‚‹\n" -#: help.c:195 +#: help.c:223 #, c-format msgid " \\ddp [PATTERN] list default privileges\n" msgstr " \\ddp [パターン] デフォルト権é™ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:196 +#: help.c:224 #, c-format msgid " \\dD[S+] [PATTERN] list domains\n" msgstr " \\dD[S+] [パターン] ドメインã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:197 +#: help.c:225 #, c-format msgid " \\det[+] [PATTERN] list foreign tables\n" msgstr " \\det[+] [パターン] 外部テーブルã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:198 +#: help.c:226 #, c-format msgid " \\des[+] [PATTERN] list foreign servers\n" msgstr " \\des[+] [パターン] 外部サーãƒãƒ¼ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:199 +#: help.c:227 #, c-format msgid " \\deu[+] [PATTERN] list user mappings\n" msgstr " \\deu[+] [パターン] ユーザマッピングã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:200 +#: help.c:228 #, c-format msgid " \\dew[+] [PATTERN] list foreign-data wrappers\n" msgstr " \\dew[+] [パターン] 外部データラッパーã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:201 +#: help.c:229 #, c-format msgid " \\df[antw][S+] [PATRN] list [only agg/normal/trigger/window] functions\n" msgstr " \\df[antw][S+] [パターン] 関数（集約/通常/トリガー/ウィンドウã®ã¿ï¼‰ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:202 +#: help.c:230 #, c-format msgid " \\dF[+] [PATTERN] list text search configurations\n" msgstr " \\dF[+] [パターン] テキスト検索設定ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:203 +#: help.c:231 #, c-format msgid " \\dFd[+] [PATTERN] list text search dictionaries\n" msgstr " \\dFd[+] [パターン] テキスト検索用辞書ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:204 +#: help.c:232 #, c-format msgid " \\dFp[+] [PATTERN] list text search parsers\n" msgstr " \\dFp[+] [パターン] テキスト検索用パーサーã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:205 +#: help.c:233 #, c-format msgid " \\dFt[+] [PATTERN] list text search templates\n" msgstr " \\dFt[+] [パターン] テキスト検索用テンプレートã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:206 +#: help.c:234 #, c-format -msgid " \\dg[+] [PATTERN] list roles\n" -msgstr " \\dg[+] [パターン] ロールã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" +#| msgid " \\dg[+] [PATTERN] list roles\n" +msgid " \\dg[S+] [PATTERN] list roles\n" +msgstr " \\dg[S+] [パターン] ロールã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:207 +#: help.c:235 #, c-format msgid " \\di[S+] [PATTERN] list indexes\n" msgstr " \\di[S+] [パターン] インデックスã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:208 +#: help.c:236 #, c-format msgid " \\dl list large objects, same as \\lo_list\n" msgstr " \\dl ラージオブジェクトã®ä¸€è¦§ã‚’表示ã™ã‚‹ã€‚\\lo_list ã¨åŒã˜ã€‚\n" -#: help.c:209 +#: help.c:237 #, c-format msgid " \\dL[S+] [PATTERN] list procedural languages\n" msgstr " \\dL[S+] [パターン] 手続ã言語ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:210 +#: help.c:238 #, c-format msgid " \\dm[S+] [PATTERN] list materialized views\n" msgstr " \\dm[S+] [パターン] マテリアライズドビューã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:211 +#: help.c:239 #, c-format msgid " \\dn[S+] [PATTERN] list schemas\n" msgstr " \\dn[S+] [パターン] スキーマã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:212 +#: help.c:240 #, c-format msgid " \\do[S] [PATTERN] list operators\n" msgstr " \\do[S] [åå‰] 演算å­ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:213 +#: help.c:241 #, c-format msgid " \\dO[S+] [PATTERN] list collations\n" -msgstr " \\dO[S+] [パターン] ç…§åˆé †åºã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" +msgstr " \\dO[S+] [パターン] ç…§åˆé †åºã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:214 +#: help.c:242 #, c-format msgid " \\dp [PATTERN] list table, view, and sequence access privileges\n" msgstr " \\dp [パターン] テーブルã€ãƒ“ューã€ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã®ã‚¢ã‚¯ã‚»ã‚¹æ¨©ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:215 +#: help.c:243 #, c-format msgid " \\drds [PATRN1 [PATRN2]] list per-database role settings\n" msgstr " \\drds [パターン1 [パターン2]] データベース毎ã®ãƒ­ãƒ¼ãƒ«ï¼ˆãƒ¦ãƒ¼ã‚¶ãƒ¼ï¼‰è¨­å®šã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:216 +#: help.c:244 #, c-format msgid " \\ds[S+] [PATTERN] list sequences\n" msgstr " \\ds[S+] [パターン] シーケンスã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:217 +#: help.c:245 #, c-format msgid " \\dt[S+] [PATTERN] list tables\n" msgstr " \\dt[S+] [パターン] テーブルã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:218 +#: help.c:246 #, c-format msgid " \\dT[S+] [PATTERN] list data types\n" msgstr " \\dT[S+] [パターン] データ型ã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:219 +#: help.c:247 #, c-format -msgid " \\du[+] [PATTERN] list roles\n" -msgstr " \\du[+] [パターン] ロールã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" +#| msgid " \\du[+] [PATTERN] list roles\n" +msgid " \\du[S+] [PATTERN] list roles\n" +msgstr " \\du[S+] [パターン] ロールã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:220 +#: help.c:248 #, c-format msgid " \\dv[S+] [PATTERN] list views\n" msgstr " \\dv[S+] [パターン] ビューã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:221 +#: help.c:249 #, c-format msgid " \\dE[S+] [PATTERN] list foreign tables\n" msgstr " \\dE[S+] [パターン] 外部テーブルã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:222 +#: help.c:250 #, c-format msgid " \\dx[+] [PATTERN] list extensions\n" msgstr " \\dx[+] [パターン] æ‹¡å¼µã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:223 +#: help.c:251 #, c-format msgid " \\dy [PATTERN] list event triggers\n" msgstr " \\dy [パターン] イベントトリガã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:224 +#: help.c:252 #, c-format msgid " \\l[+] [PATTERN] list databases\n" msgstr " \\l[+] [パターン] データベースã®ä¸€è¦§ã‚’表示ã™ã‚‹\n" -#: help.c:225 +#: help.c:253 #, c-format -msgid " \\sf[+] FUNCNAME show a function's definition\n" -msgstr " \\sf[+] 関数å 関数定義を表示ã™ã‚‹\n" +#| msgid " \\sf[+] FUNCNAME show a function's definition\n" +msgid " \\sf[+] FUNCNAME show a function's definition\n" +msgstr " \\sf[+] 関数å 関数定義を表示ã™ã‚‹\n" -#: help.c:226 +#: help.c:254 +#, c-format +#| msgid " \\sf[+] FUNCNAME show a function's definition\n" +msgid " \\sv[+] VIEWNAME show a view's definition\n" +msgstr " \\sv[+] ビューå ビュー定義を表示ã™ã‚‹\n" + +#: help.c:255 #, c-format msgid " \\z [PATTERN] same as \\dp\n" msgstr " \\z [パターン] \\dp ã¨åŒã˜\n" -#: help.c:229 +#: help.c:258 #, c-format msgid "Formatting\n" msgstr "書å¼è¨­å®š\n" -#: help.c:230 +#: help.c:259 +#, c-format +msgid " \\a toggle between unaligned and aligned output mode\n" +msgstr " \\a 出力モード㮠'unaligned' / 'aligned' を切り替ãˆã‚‹\n" + +#: help.c:260 +#, c-format +msgid " \\C [STRING] set table title, or unset if none\n" +msgstr " \\C タイトル テーブルã®ã‚¿ã‚¤ãƒˆãƒ«ã‚’設定ã™ã‚‹ã€‚指定ãŒãªã‘ã‚Œã°è§£é™¤\n" + +#: help.c:261 +#, c-format +msgid " \\f [STRING] show or set field separator for unaligned query output\n" +msgstr " \\f [文字列] æ¡æƒãˆã‚’è¡Œã‚ãªã„(unaligned)å•ã„åˆã‚ã›å‡ºåŠ›ã«ãŠã‘るフィールド区切り文字を表示ã¾ãŸã¯è¨­å®š\n" + +#: help.c:262 +#, c-format +msgid " \\H toggle HTML output mode (currently %s)\n" +msgstr " \\H HTML ã®å‡ºåŠ›ãƒ¢ãƒ¼ãƒ‰ã‚’切り替ãˆã‚‹(ç¾åœ¨: %s)\n" + +#: help.c:264 +#, c-format +#| msgid "" +#| " \\pset [NAME [VALUE]] set table output option\n" +#| " (NAME := {format|border|expanded|fieldsep|fieldsep_zero|footer|null|\n" +#| " numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager})\n" +msgid "" +" \\pset [NAME [VALUE]] set table output option\n" +" (NAME := {format|border|expanded|fieldsep|fieldsep_zero|footer|null|\n" +" numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager|\n" +" unicode_border_linestyle|unicode_column_linestyle|unicode_header_linestyle})\n" +msgstr "" +" \\pset [åå‰ [値]] テーブル出力ã®ã‚ªãƒ—ションを設定ã™ã‚‹\n" +" (åå‰ := {format|border|expanded|fieldsep|fieldsep_zero|footer|null|\n" +" numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager|\n" +" unicode_border_linestyle|unicode_column_linestyle|unicode_header_linestyle})\n" + +#: help.c:268 +#, c-format +msgid " \\t [on|off] show only rows (currently %s)\n" +msgstr " \\t [on|off] è¡Œã®ã¿ã‚’表示ã™ã‚‹ã‹ï¼Ÿ (ç¾åœ¨: %s)\n" + +#: help.c:270 +#, c-format +msgid " \\T [STRING] set HTML
tag attributes, or unset if none\n" +msgstr " \\T [文字列] HTML ã®
ã‚¿ã‚°ã®å±žæ€§ã‚’セット。引数ãŒãªã‘ã‚Œã°è§£é™¤\n" + +#: help.c:271 +#, c-format +msgid " \\x [on|off|auto] toggle expanded output (currently %s)\n" +msgstr " \\x [on|off|auto] 拡張出力ã®åˆ‡ã‚Šæ›¿ãˆ(ç¾åœ¨: %s)\n" + +#: help.c:275 +#, c-format +msgid "Connection\n" +msgstr "接続\n" + +#: help.c:277 +#, c-format +msgid "" +" \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" +" connect to new database (currently \"%s\")\n" +msgstr "" +" \\c[onnect] {[DBå|- ユーザå|- ホストå|- ãƒãƒ¼ãƒˆç•ªå·|-] | conninfo}\n" +" æ–°ã—ã„データベースã«æŽ¥ç¶šã™ã‚‹ (ç¾åœ¨: \"%s\")\n" + +#: help.c:281 +#, c-format +msgid "" +" \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" +" connect to new database (currently no connection)\n" +msgstr "" +" \\c[onnect] {[DBå|- ユーザå|- ホストå|- ãƒãƒ¼ãƒˆç•ªå·|-] | conninfo}\n" +" æ–°ã—ã„データベースã«æŽ¥ç¶šã™ã‚‹ (ç¾åœ¨: 接続無ã—)\n" + +#: help.c:283 +#, c-format +msgid " \\encoding [ENCODING] show or set client encoding\n" +msgstr "" +" \\encoding [エンコーディング]\n" +" クライアントã®ã‚¨ãƒ³ã‚³ãƒ¼ãƒ‡ã‚£ãƒ³ã‚°ã‚’表示ã¾ãŸã¯ã‚»ãƒƒãƒˆ\n" + +#: help.c:284 +#, c-format +msgid " \\password [USERNAME] securely change the password for a user\n" +msgstr " \\password [ユーザå] ユーザã®ãƒ‘スワードを安全ã«å¤‰æ›´ã™ã‚‹\n" + +#: help.c:285 +#, c-format +msgid " \\conninfo display information about current connection\n" +msgstr " \\conninfo ç¾åœ¨ã®æŽ¥ç¶šã«é–¢ã™ã‚‹æƒ…報を表示ã™ã‚‹\n" + +#: help.c:288 +#, c-format +msgid "Operating System\n" +msgstr "オペレーティングシステム\n" + +#: help.c:289 +#, c-format +msgid " \\cd [DIR] change the current working directory\n" +msgstr " \\cd [DIR] カレントディレクトリを変更\n" + +#: help.c:290 +#, c-format +msgid " \\setenv NAME [VALUE] set or unset environment variable\n" +msgstr " \\setenv NAME [VALUE] 環境変数ã®è¨­å®šã€è¨­å®šè§£é™¤ã‚’è¡Œã†\n" + +#: help.c:291 +#, c-format +msgid " \\timing [on|off] toggle timing of commands (currently %s)\n" +msgstr " \\timing [on|off] コマンドã®ã‚¿ã‚¤ãƒŸãƒ³ã‚°ã‚’切り替ãˆã‚‹(ç¾åœ¨: %s)\n" + +#: help.c:293 +#, c-format +msgid " \\! [COMMAND] execute command in shell or start interactive shell\n" +msgstr " \\! [コマンド] シェルã§ã‚³ãƒžãƒ³ãƒ‰ã‚’実行ã€ã‚‚ã—ãã¯ä¼šè©±åž‹ã‚·ã‚§ãƒ«ã‚’èµ·å‹•\n" + +#: help.c:296 +#, c-format +msgid "Variables\n" +msgstr "変数\n" + +#: help.c:297 +#, c-format +msgid " \\prompt [TEXT] NAME prompt user to set internal variable\n" +msgstr " \\prompt [テキスト] 変数å ユーザã«å†…部変数をセットã™ã‚‹ã‚ˆã†ä¿ƒã™\n" + +#: help.c:298 +#, c-format +msgid " \\set [NAME [VALUE]] set internal variable, or list all if no parameters\n" +msgstr "" +" \\set [変数å [値]]\n" +" 内部変数ã®å€¤ã‚’セット。引数ãŒãªã„å ´åˆã¯ä¸€è¦§è¡¨ç¤ºã€‚\n" + +#: help.c:299 +#, c-format +msgid " \\unset NAME unset (delete) internal variable\n" +msgstr " \\unset 変数å 内部変数を削除ã™ã‚‹\n" + +#: help.c:302 +#, c-format +msgid "Large Objects\n" +msgstr "ラージオブジェクト\n" + +#: help.c:303 +#, c-format +msgid "" +" \\lo_export LOBOID FILE\n" +" \\lo_import FILE [COMMENT]\n" +" \\lo_list\n" +" \\lo_unlink LOBOID large object operations\n" +msgstr "" +" \\lo_export LOBOID ファイルå\n" +" \\lo_import ファイルå [コメント]\n" +" \\lo_list\n" +" \\lo_unlink LOBOID ラージオブジェクトã®æ“作\n" + +#: help.c:330 +#, c-format +msgid "" +"List of specially treated variables\n" +"\n" +msgstr "" +"特別ã«æ‰±ã‚れる変数ã®ä¸€è¦§\n" +"\n" + +#: help.c:332 +#, c-format +#| msgid "Variables\n" +msgid "psql variables:\n" +msgstr "psql 変数:\n" + +#: help.c:334 +#, c-format +msgid "" +" psql --set=NAME=VALUE\n" +" or \\set NAME VALUE inside psql\n" +"\n" +msgstr "" +" psql --set=NAME=VALUE\n" +" ã¾ãŸã¯ psql ã®ä¸­ã§ \\set NAME VALUE\n" +"\n" + +#: help.c:336 +#, c-format +msgid " AUTOCOMMIT if set, successful SQL commands are automatically committed\n" +msgstr " AUTOCOMMIT 設定ã™ã‚‹ã¨ã€æˆåŠŸã—ãŸSQLコマンドã¯è‡ªå‹•çš„ã«ã‚³ãƒŸãƒƒãƒˆã•ã‚Œã‚‹\n" + +#: help.c:337 +#, c-format +msgid "" +" COMP_KEYWORD_CASE determines the case used to complete SQL key words\n" +" [lower, upper, preserve-lower, preserve-upper]\n" +msgstr "" +" COMP_KEYWORD_CASE SQLキーワードを補完ã™ã‚‹æ™‚ã«å¤§æ–‡å­—å°æ–‡å­—ã®ã©ã¡ã‚‰ã‚’使用ã™ã‚‹ã‹æ±ºå®šã™ã‚‹\n" +" [lower, upper, preserve-lower, preserve-upper]\n" + +#: help.c:339 +#, c-format +#| msgid " -d, --dbname=NAME connect to database name\n" +msgid " DBNAME the currently connected database name\n" +msgstr " DBNAME ç¾åœ¨æŽ¥ç¶šã—ã¦ã„るデータベースå\n" + +#: help.c:340 +#, c-format +msgid "" +" ECHO controls what input is written to standard output\n" +" [all, errors, none, queries]\n" +msgstr "" +" ECHO ã©ã®å…¥åŠ›ã‚’標準出力ã¸å‡ºåŠ›ã™ã‚‹ã‹ã‚’制御ã™ã‚‹\n" +" [all, errors, none, queries]\n" + +#: help.c:342 +#, c-format +msgid "" +" ECHO_HIDDEN if set, display internal queries executed by backslash commands;\n" +" if set to \"noexec\", just show without execution\n" +msgstr "" +" ECHO_HIDDEN 設定ã™ã‚‹ã¨ã€ãƒãƒƒã‚¯ã‚¹ãƒ©ãƒƒã‚·ãƒ¥ã‚³ãƒžãƒ³ãƒ‰ã«ã‚ˆã£ã¦å®Ÿè¡Œã•ã‚Œã‚‹å†…部å•ã„åˆã‚ã›ã‚’表示ã™ã‚‹;\n" +" \"noexec\" ã«è¨­å®šã™ã‚‹ã¨ã€å®Ÿè¡Œã›ãšã«è¡¨ç¤ºã®ã¿è¡Œã†\n" + +#: help.c:344 +#, c-format +#| msgid "Sets the client's character set encoding." +msgid " ENCODING current client character set encoding\n" +msgstr " ENCODING ç¾åœ¨ã®ã‚¯ãƒ©ã‚¤ã‚¢ãƒ³ãƒˆã®æ–‡å­—セット符å·åŒ–æ–¹å¼\n" + +#: help.c:345 +#, c-format +msgid "" +" FETCH_COUNT the number of result rows to fetch and display at a time\n" +" (default: 0=unlimited)\n" +msgstr "" +" FETCH_COUNT 一度ã«ãƒ•ã‚§ãƒƒãƒã—ã¦è¡¨ç¤ºã™ã‚‹è¡Œæ•°\n" +" (デフォルト: 0=ç„¡é™)\n" + +#: help.c:347 +#, c-format +msgid " HISTCONTROL controls command history [ignorespace, ignoredups, ignoreboth]\n" +msgstr " HISTCONTROL コマンド履歴ã®åˆ¶å¾¡ [ignorespace, ignoredups, ignoreboth]\n" + +#: help.c:348 +#, c-format +msgid " HISTFILE file name used to store the command history\n" +msgstr " HISTFILE コマンド履歴を格ç´ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã•ã‚Œã‚‹ãƒ•ã‚¡ã‚¤ãƒ«å\n" + +#: help.c:349 +#, c-format +msgid " HISTSIZE the number of commands to store in the command history\n" +msgstr " HISTSIZE コマンド履歴ã«æ ¼ç´ã™ã‚‹ã‚³ãƒžãƒ³ãƒ‰æ•°\n" + +#: help.c:350 +#, c-format +#| msgid " -p, --port=PORT database server port\n" +msgid " HOST the currently connected database server host\n" +msgstr " HOST ç¾åœ¨æŽ¥ç¶šã—ã¦ã„るデータベースサーãƒã®ãƒ›ã‚¹ãƒˆ\n" + +#: help.c:351 +#, c-format +msgid " IGNOREEOF if unset, sending an EOF to interactive session terminates application\n" +msgstr " IGNOREEOF 未設定ã®å ´åˆã€å¯¾è©±ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«EOFã‚’é€ä¿¡ã™ã‚‹ã¨ã‚¢ãƒ—リケーションãŒçµ‚了\n" + +#: help.c:352 +#, c-format +#| msgid " -o OID set next OID\n" +msgid " LASTOID value of the last affected OID\n" +msgstr " LASTOID 最後ã«å½±éŸ¿ã‚’å—ã‘ãŸOIDã®å€¤\n" + +#: help.c:353 +#, c-format +msgid " ON_ERROR_ROLLBACK if set, an error doesn't stop a transaction (uses implicit savepoints)\n" +msgstr " ON_ERROR_ROLLBACK 設定ã™ã‚‹ã¨ã€ã‚¨ãƒ©ãƒ¼ã§ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒåœæ­¢ã—ãªã„ (暗黙的ã«ã‚»ãƒ¼ãƒ–ãƒã‚¤ãƒ³ãƒˆã‚’使用)\n" + +#: help.c:354 +#, c-format +msgid " ON_ERROR_STOP stop batch execution after error\n" +msgstr " ON_ERROR_STOP エラー後ã®ãƒãƒƒãƒå®Ÿè¡Œã‚’åœæ­¢\n" + +#: help.c:355 +#, c-format +#| msgid " \\conninfo display information about current connection\n" +msgid " PORT server port of the current connection\n" +msgstr " PORT ç¾åœ¨ã®æŽ¥ç¶šã®ã‚µãƒ¼ãƒã®ãƒãƒ¼ãƒˆç•ªå·\n" + +#: help.c:356 +#, c-format +msgid " PROMPT1 specifies the standard psql prompt\n" +msgstr " PROMPT1 標準psqlプロンプトを指定\n" + +#: help.c:357 +#, c-format +msgid " PROMPT2 specifies the prompt used when a statement continues from a previous line\n" +msgstr " PROMPT2 å‰ã®è¡Œã‹ã‚‰æ–‡ãŒç¶šã„ã¦ã„ã‚‹ã¨ãã«ä½¿ç”¨ã™ã‚‹ãƒ—ロンプトを指定\n" + +#: help.c:358 +#, c-format +msgid " PROMPT3 specifies the prompt used during COPY ... FROM STDIN\n" +msgstr " PROMPT3 COPY ... FROM STDIN ã®å®Ÿè¡Œä¸­ã«ä½¿ç”¨ã•ã‚Œã‚‹ãƒ—ロンプトを指定\n" + +#: help.c:359 +#, c-format +#| msgid " -q, --quiet run quietly (no messages, only query output)\n" +msgid " QUIET run quietly (same as -q option)\n" +msgstr " QUIET é™ã‹ã«å®Ÿè¡Œ (-qオプションã¨åŒã˜)\n" + +#: help.c:360 +#, c-format +msgid " SHOW_CONTEXT controls display of message context fields [never, errors, always]\n" +msgstr " SHOW_CONTEXT メッセージコンテキストフィールドã®è¡¨ç¤ºã‚’制御 [never, errors, always]\n" + +#: help.c:361 +#, c-format +msgid " SINGLELINE end of line terminates SQL command mode (same as -S option)\n" +msgstr " SINGLELINE è¡Œã®çµ‚端ã§SQLコマンドモードを終了 (-Sオプションã¨åŒã˜)\n" + +#: help.c:362 +#, c-format +msgid " SINGLESTEP single-step mode (same as -s option)\n" +msgstr " SINGLESTEP シングルステップモード (-s オプションã¨åŒã˜)\n" + +#: help.c:363 +#, c-format +#| msgid " -C, --create create the target database\n" +msgid " USER the currently connected database user\n" +msgstr " USER ç¾åœ¨æŽ¥ç¶šã—ã¦ã„るデータベースユーザー\n" + +#: help.c:364 +#, c-format +msgid " VERBOSITY controls verbosity of error reports [default, verbose, terse]\n" +msgstr " VERBOSITY エラー報告ã®å†—長性を制御 [default, verbose, terse]\n" + +#: help.c:366 +#, c-format +#| msgid "List of settings" +msgid "" +"\n" +"Display settings:\n" +msgstr "" +"\n" +"設定を表示:\n" + +#: help.c:368 +#, c-format +msgid "" +" psql --pset=NAME[=VALUE]\n" +" or \\pset NAME [VALUE] inside psql\n" +"\n" +msgstr "" +" psql --pset=NAME[=VALUE]\n" +" ã¾ãŸã¯ã€psql ã®ä¸­ã§ \\pset NAME [VALUE]\n" +"\n" + +#: help.c:370 +#, c-format +msgid " border border style (number)\n" +msgstr " border 境界線ã®å½¢å¼ (æ•°)\n" + +#: help.c:371 +#, c-format +msgid " columns target width for the wrapped format\n" +msgstr " columns wrapped書å¼ã®å¯¾è±¡å¹…\n" + +#: help.c:372 +#, c-format +msgid " expanded (or x) expanded output [on, off, auto]\n" +msgstr " expanded (or x) 拡張表示 [on, off, auto]\n" + +#: help.c:373 +#, c-format +#| msgid "" +#| " -F, --field-separator=STRING\n" +#| " field separator for unaligned output (default: \"%s\")\n" +msgid " fieldsep field separator for unaligned output (default \"%s\")\n" +msgstr " fieldsep æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰åŒºåˆ‡ã‚Šæ–‡å­—(デフォルト \"%s\")\n" + +#: help.c:374 +#, c-format +#| msgid "" +#| " -z, --field-separator-zero\n" +#| " set field separator for unaligned output to zero byte\n" +msgid " fieldsep_zero set field separator for unaligned output to zero byte\n" +msgstr " fieldsep_zero æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰åŒºåˆ‡ã‚Šæ–‡å­—をゼロãƒã‚¤ãƒˆã«è¨­å®š\n" + +#: help.c:375 +#, c-format +msgid " footer enable or disable display of the table footer [on, off]\n" +msgstr " footer テーブルフッタã®è¡¨ç¤ºã‚’有効化ã¾ãŸã¯ç„¡åŠ¹åŒ– [on, off]\n" + +#: help.c:376 +#, c-format +#| msgid "\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n" +msgid " format set output format [unaligned, aligned, wrapped, html, asciidoc, ...]\n" +msgstr " format 出力形å¼ã‚’設定 [unaligned, aligned, wrapped, html, asciidoc, ...]\n" + +#: help.c:377 +#, c-format +#| msgid "\\pset: allowed line styles are ascii, old-ascii, unicode\n" +msgid " linestyle set the border line drawing style [ascii, old-ascii, unicode]\n" +msgstr " linestyle 境界線ã®è¡¨ç¤ºå½¢å¼ã‚’設定 [ascii, old-ascii, unicode]\n" + +#: help.c:378 +#, c-format +msgid " null set the string to be printed in place of a null value\n" +msgstr " null null値ã®ä»£ã‚ã‚Šã«è¡¨ç¤ºã™ã‚‹æ–‡å­—列を設定\n" + +#: help.c:379 #, c-format -msgid " \\a toggle between unaligned and aligned output mode\n" -msgstr " \\a 出力モード㮠'unaligned' / 'aligned' を切り替ãˆã‚‹\n" +msgid "" +" numericlocale enable or disable display of a locale-specific character to separate\n" +" groups of digits [on, off]\n" +msgstr "" +" numericlocale æ¡ã®ããりを分離ã™ã‚‹ãƒ­ã‚±ãƒ¼ãƒ«å›ºæœ‰ã®æ–‡å­—ã®è¡¨ç¤ºã‚’\n" +"有効化ã¾ãŸã¯ç„¡åŠ¹åŒ– [on, off]\n" -#: help.c:231 +#: help.c:381 #, c-format -msgid " \\C [STRING] set table title, or unset if none\n" -msgstr " \\C タイトル テーブルã®ã‚¿ã‚¤ãƒˆãƒ«ã‚’設定ã™ã‚‹ã€‚指定ãŒãªã‘ã‚Œã°è§£é™¤\n" +msgid " pager control when an external pager is used [yes, no, always]\n" +msgstr " pager ã„ã¤å¤–部ページャãŒä½¿ç”¨ã•ã‚Œã‚‹ã‹åˆ¶å¾¡ [yes, no, always]\n" -#: help.c:232 +#: help.c:382 #, c-format -msgid " \\f [STRING] show or set field separator for unaligned query output\n" -msgstr " \\f [文字列] æ¡æƒãˆã‚’è¡Œã‚ãªã„(unaligned)å•ã„åˆã‚ã›å‡ºåŠ›ã«ãŠã‘るフィールド区切り文字を表示ã¾ãŸã¯è¨­å®š\n" +#| msgid " \\f [STRING] show or set field separator for unaligned query output\n" +msgid " recordsep record (line) separator for unaligned output\n" +msgstr " recordsep æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ¬ã‚³ãƒ¼ãƒ‰(è¡Œ)ã®åŒºåˆ‡ã‚Šæ–‡å­—\n" -#: help.c:233 +#: help.c:383 #, c-format -msgid " \\H toggle HTML output mode (currently %s)\n" -msgstr " \\H HTML ã®å‡ºåŠ›ãƒ¢ãƒ¼ãƒ‰ã‚’切り替ãˆã‚‹(ç¾åœ¨: %s)\n" +#| msgid "" +#| " -0, --record-separator-zero\n" +#| " set record separator for unaligned output to zero byte\n" +msgid " recordsep_zero set record separator for unaligned output to zero byte\n" +msgstr " recordsep_zero æ¡æƒãˆãªã—ã®å‡ºåŠ›ã§ã®ãƒ¬ã‚³ãƒ¼ãƒ‰ã®åŒºåˆ‡ã‚Šæ–‡å­—をゼロãƒã‚¤ãƒˆã«è¨­å®š\n" -#: help.c:235 +#: help.c:384 #, c-format msgid "" -" \\pset [NAME [VALUE]] set table output option\n" -" (NAME := {format|border|expanded|fieldsep|fieldsep_zero|footer|null|\n" -" numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager})\n" +" tableattr (or T) specify attributes for table tag in html format or proportional\n" +" column widths for left-aligned data types in latex-longtable format\n" msgstr "" -" \\pset [åå‰ [値]] テーブル出力ã®ã‚ªãƒ—ションを設定ã™ã‚‹\n" -" (åå‰ := {format|border|expanded|fieldsep|fieldsep_zero|footer|null|\n" -" numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager})\n" +" tableattr (ã¾ãŸã¯ T) htmlå½¢å¼ã§ã®ãƒ†ãƒ¼ãƒ–ルタグã®å±žæ€§ã‚„\n" +" latex-longtable書å¼ã§ã®å·¦æƒãˆã•ã‚ŒãŸãƒ‡ãƒ¼ã‚¿åž‹ã®åˆ—å¹…ã®æ¯”率を指定\n" -#: help.c:238 +#: help.c:386 #, c-format -msgid " \\t [on|off] show only rows (currently %s)\n" -msgstr " \\t [on|off] è¡Œã®ã¿ã‚’表示ã™ã‚‹ã‹ï¼Ÿ (ç¾åœ¨: %s)\n" +#| msgid " \\C [STRING] set table title, or unset if none\n" +msgid " title set the table title for any subsequently printed tables\n" +msgstr " title 今後表示ã•ã‚Œã‚‹å…¨ã¦ã®ãƒ†ãƒ¼ãƒ–ル用ã«ãƒ†ãƒ¼ãƒ–ルタイトルを設定\n" -#: help.c:240 +#: help.c:387 #, c-format -msgid " \\T [STRING] set HTML
tag attributes, or unset if none\n" -msgstr " \\T [文字列] HTML ã®
ã‚¿ã‚°ã®å±žæ€§ã‚’セット。引数ãŒãªã‘ã‚Œã°è§£é™¤\n" +msgid " tuples_only if set, only actual table data is shown\n" +msgstr " tuples_only 設定ã™ã‚‹ã¨ã€å®Ÿãƒ†ãƒ¼ãƒ–ルデータã®ã¿ã‚’表示\n" -#: help.c:241 +#: help.c:388 #, c-format -msgid " \\x [on|off|auto] toggle expanded output (currently %s)\n" -msgstr " \\x [on|off|auto] 拡張出力ã®åˆ‡ã‚Šæ›¿ãˆ(ç¾åœ¨: %s)\n" +msgid "" +" unicode_border_linestyle\n" +" unicode_column_linestyle\n" +" unicode_header_linestyle\n" +" set the style of Unicode line drawing [single, double]\n" +msgstr "" +" unicode_border_linestyle\n" +" unicode_column_linestyle\n" +" unicode_header_linestyle\n" +" Unicodeã®ç·šã®å½¢å¼ã‚’設定 [single, double]\n" -#: help.c:245 +#: help.c:393 #, c-format -msgid "Connection\n" -msgstr "接続\n" +msgid "" +"\n" +"Environment variables:\n" +msgstr "" +"\n" +"環境変数:\n" -#: help.c:247 +#: help.c:397 #, c-format msgid "" -" \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" -" connect to new database (currently \"%s\")\n" +" NAME=VALUE [NAME=VALUE] psql ...\n" +" or \\setenv NAME [VALUE] inside psql\n" +"\n" msgstr "" -" \\c[onnect] {[DBå|- ユーザå|- ホストå|- ãƒãƒ¼ãƒˆç•ªå·|-] | conninfo}\n" -" æ–°ã—ã„データベースã«æŽ¥ç¶šã™ã‚‹ (ç¾åœ¨: \"%s\")\n" +" NAME=VALUE [NAME=VALUE] psql ...\n" +" ã¾ãŸã¯ã€psqlã®ä¸­ã§ \\setenv NAME [VALUE]\n" +"\n" -#: help.c:251 +#: help.c:399 #, c-format msgid "" -" \\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}\n" -" connect to new database (currently no connection)\n" +" set NAME=VALUE\n" +" psql ...\n" +" or \\setenv NAME [VALUE] inside psql\n" +"\n" msgstr "" -" \\c[onnect] {[DBå|- ユーザå|- ホストå|- ãƒãƒ¼ãƒˆç•ªå·|-] | conninfo}\n" -" æ–°ã—ã„データベースã«æŽ¥ç¶šã™ã‚‹ (ç¾åœ¨: 接続無ã—)\n" +" set NAME=VALUE\n" +" psql ...\n" +" ã¾ãŸã¯ã€psqlã®ä¸­ã§ \\setenv NAME [VALUE]\n" +"\n" -#: help.c:253 +#: help.c:402 #, c-format -msgid " \\encoding [ENCODING] show or set client encoding\n" -msgstr "" -" \\encoding [エンコーディング]\n" -" クライアントã®ã‚¨ãƒ³ã‚³ãƒ¼ãƒ‡ã‚£ãƒ³ã‚°ã‚’表示ã¾ãŸã¯ã‚»ãƒƒãƒˆ\n" +msgid " COLUMNS number of columns for wrapped format\n" +msgstr " COLUMNS wrappedå½¢å¼ã®åˆ—æ•°\n" -#: help.c:254 +#: help.c:403 #, c-format -msgid " \\password [USERNAME] securely change the password for a user\n" -msgstr " \\password [ユーザå] ユーザã®ãƒ‘スワードを安全ã«å¤‰æ›´ã™ã‚‹\n" +#| msgid " -x NUM internal use\n" +msgid " PAGER name of external pager program\n" +msgstr " PAGER 外部ã®ãƒšãƒ¼ã‚¸ãƒ£ãƒ—ログラムå\n" -#: help.c:255 +#: help.c:404 #, c-format -msgid " \\conninfo display information about current connection\n" -msgstr " \\conninfo ç¾åœ¨ã®æŽ¥ç¶šã«é–¢ã™ã‚‹æƒ…報を表示ã™ã‚‹\n" +msgid " PGAPPNAME same as the application_name connection parameter\n" +msgstr " PGAPPNAME application_name接続パラメータã¨åŒã˜\n" -#: help.c:258 +#: help.c:405 #, c-format -msgid "Operating System\n" -msgstr "オペレーティングシステム\n" +msgid " PGDATABASE same as the dbname connection parameter\n" +msgstr " PGDATABASE dbname接続パラメータã¨åŒã˜\n" -#: help.c:259 +#: help.c:406 #, c-format -msgid " \\cd [DIR] change the current working directory\n" -msgstr " \\cd [DIR] カレントディレクトリを変更\n" +#| msgid " -l enable SSL connections\n" +msgid " PGHOST same as the host connection parameter\n" +msgstr " PGHOST host接続パラメータã¨åŒã˜\n" -#: help.c:260 +#: help.c:407 #, c-format -msgid " \\setenv NAME [VALUE] set or unset environment variable\n" -msgstr " \\setenv NAME [VALUE] 環境変数ã®è¨­å®šã€è¨­å®šè§£é™¤ã‚’è¡Œã†\n" +#| msgid " -l enable SSL connections\n" +msgid " PGPORT same as the port connection parameter\n" +msgstr " PGPORT port接続パラメータã¨åŒã˜\n" -#: help.c:261 +#: help.c:408 #, c-format -msgid " \\timing [on|off] toggle timing of commands (currently %s)\n" -msgstr " \\timing [on|off] コマンドã®ã‚¿ã‚¤ãƒŸãƒ³ã‚°ã‚’切り替ãˆã‚‹(ç¾åœ¨: %s)\n" +#| msgid " DBNAME database name (defaults to user name)\n" +msgid " PGUSER same as the user connection parameter\n" +msgstr " PGUSER user接続パラメータã¨åŒã˜\n" -#: help.c:263 +#: help.c:409 #, c-format -msgid " \\! [COMMAND] execute command in shell or start interactive shell\n" -msgstr " \\! [コマンド] シェルã§ã‚³ãƒžãƒ³ãƒ‰ã‚’実行ã€ã‚‚ã—ãã¯ä¼šè©±åž‹ã‚·ã‚§ãƒ«ã‚’èµ·å‹•\n" +msgid " PGPASSWORD connection password (not recommended)\n" +msgstr " PGPASSWORD 接続パスワード (推奨ã•ã‚Œã¦ã„ã¾ã›ã‚“)\n" -#: help.c:266 +#: help.c:410 #, c-format -msgid "Variables\n" -msgstr "変数\n" +#| msgid " -f, --file=FILENAME output file name\n" +msgid " PGPASSFILE password file name\n" +msgstr " PGPASSFILE パスワードファイルå\n" -#: help.c:267 +#: help.c:411 #, c-format -msgid " \\prompt [TEXT] NAME prompt user to set internal variable\n" -msgstr " \\prompt [テキスト] 変数å ユーザã«å†…部変数をセットã™ã‚‹ã‚ˆã†ä¿ƒã™\n" +msgid "" +" PSQL_EDITOR, EDITOR, VISUAL\n" +" editor used by the \\e, \\ef, and \\ev commands\n" +msgstr "" +" PSQL_EDITOR, EDITOR, VISUAL\n" +" \\eコマンドã€\\efコマンドã€\\evコマンドã§ä½¿ç”¨ã•ã‚Œã‚‹ã‚¨ãƒ‡ã‚£ã‚¿\n" -#: help.c:268 +#: help.c:413 #, c-format -msgid " \\set [NAME [VALUE]] set internal variable, or list all if no parameters\n" +#| msgid "environment variable PSQL_EDITOR_LINENUMBER_ARG must be set to specify a line number\n" +msgid "" +" PSQL_EDITOR_LINENUMBER_ARG\n" +" how to specify a line number when invoking the editor\n" msgstr "" -" \\set [変数å [値]]\n" -" 内部変数ã®å€¤ã‚’セット。引数ãŒãªã„å ´åˆã¯ä¸€è¦§è¡¨ç¤ºã€‚\n" +" PSQL_EDITOR_LINENUMBER_ARG\n" +" エディタを呼ã³å‡ºã™ã¨ãã®è¡Œç•ªå·ã®æŒ‡å®šæ–¹æ³•\n" -#: help.c:269 +#: help.c:415 #, c-format -msgid " \\unset NAME unset (delete) internal variable\n" -msgstr " \\unset 変数å 内部変数を削除ã™ã‚‹\n" +msgid " PSQL_HISTORY alternative location for the command history file\n" +msgstr " PSQL_HISTORY コマンド履歴ファイルã®å ´æ‰€ã‚’指定\n" -#: help.c:272 +#: help.c:416 #, c-format -msgid "Large Objects\n" -msgstr "ラージオブジェクト\n" +msgid " PSQLRC alternative location for the user's .psqlrc file\n" +msgstr " PSQLRC ユーザã®.psqlrcファイルã®å ´æ‰€ã‚’指定\n" -#: help.c:273 +#: help.c:417 #, c-format -msgid "" -" \\lo_export LOBOID FILE\n" -" \\lo_import FILE [COMMENT]\n" -" \\lo_list\n" -" \\lo_unlink LOBOID large object operations\n" -msgstr "" -" \\lo_export LOBOID ファイルå\n" -" \\lo_import ファイルå [コメント]\n" -" \\lo_list\n" -" \\lo_unlink LOBOID ラージオブジェクトã®æ“作\n" +msgid " SHELL shell used by the \\! command\n" +msgstr " SHELL \\!コマンドã§ä½¿ç”¨ã•ã‚Œã‚‹ã‚·ã‚§ãƒ«\n" + +#: help.c:418 +#, c-format +#| msgid " -L DIRECTORY where to find the input files\n" +msgid " TMPDIR directory for temporary files\n" +msgstr " TMPDIR 一時ファイル用ã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒª\n" -#: help.c:320 +#: help.c:461 msgid "Available help:\n" msgstr "利用å¯èƒ½ãªãƒ˜ãƒ«ãƒ—:\n" -#: help.c:404 +#: help.c:545 #, c-format msgid "" "Command: %s\n" @@ -2430,7 +3219,7 @@ msgstr "" "%s\n" "\n" -#: help.c:420 +#: help.c:561 #, c-format msgid "" "No help available for \"%s\".\n" @@ -2439,54 +3228,62 @@ msgstr "" "\"%s\" ã«ã¤ã„ã¦ã¯ãƒ˜ãƒ«ãƒ—情報ãŒã‚ã‚Šã¾ã›ã‚“。\n" "引数ãªã—㧠\\h ã¨ã‚¿ã‚¤ãƒ—ã™ã‚‹ã¨ã€ãƒ˜ãƒ«ãƒ—ã®ä¸€è¦§ãŒè¡¨ç¤ºã•ã‚Œã¾ã™ã€‚\n" -#: input.c:194 +#: input.c:216 #, c-format msgid "could not read from input file: %s\n" msgstr "入力ファイルã‹ã‚‰èª­ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: input.c:446 input.c:485 +#: input.c:471 input.c:510 #, c-format msgid "could not save history to file \"%s\": %s\n" msgstr "ファイル \"%s\" ã«ãƒ’ストリをä¿å­˜ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: input.c:505 +#: input.c:530 #, c-format msgid "history is not supported by this installation\n" msgstr "ã“ã®ç’°å¢ƒã§ã¯ãƒ’ストリ機能をサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。\n" -#: large_obj.c:66 +#: large_obj.c:64 #, c-format msgid "%s: not connected to a database\n" msgstr "%s: ã©ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã‚‚接続ã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: large_obj.c:85 +#: large_obj.c:83 #, c-format msgid "%s: current transaction is aborted\n" msgstr "%s: トランザクションを中断ã—ã¾ã—ãŸ\n" -#: large_obj.c:88 +#: large_obj.c:86 #, c-format msgid "%s: unknown transaction status\n" msgstr "%s: トランザクションã®çŠ¶æ…‹ãŒä¸æ˜Žã§ã™ã€‚\n" -#: large_obj.c:289 large_obj.c:300 +#: large_obj.c:287 large_obj.c:298 msgid "ID" msgstr "ID" -#: large_obj.c:310 +#: large_obj.c:308 msgid "Large objects" msgstr "ラージオブジェクト" -#: mainloop.c:159 +#: mainloop.c:168 #, c-format msgid "Use \"\\q\" to leave %s.\n" msgstr "\"\\q\" 㧠%s を抜ã‘ã¾ã™ã€‚\n" -#: mainloop.c:189 +#: mainloop.c:190 +msgid "" +"The input is a PostgreSQL custom-format dump.\n" +"Use the pg_restore command-line client to restore this dump to a database.\n" +msgstr "" +"入力ã¯PostgreSQLã®ã‚«ã‚¹ã‚¿ãƒ æ›¸å¼ã®ãƒ€ãƒ³ãƒ—ã§ã™ã€‚\n" +"データベースã¸ã“ã®ãƒ€ãƒ³ãƒ—をリストアã™ã‚‹ã«ã¯ pg_restore コマンドライン・クライアントを使用ã—ã¦ãã ã•ã„。\n" + +#: mainloop.c:210 msgid "You are using psql, the command-line interface to PostgreSQL." msgstr "PostgreSQL ã¸ã®ã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ãƒ»ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ãƒ¼ã‚¹ã€psql ã¸ã‚ˆã†ã“ã。" -#: mainloop.c:190 +#: mainloop.c:211 #, c-format msgid "" "Type: \\copyright for distribution terms\n" @@ -2501,1912 +3298,2073 @@ msgstr "" " \\g ã¨æ‰“ã¤ã‹ã‚»ãƒŸã‚³ãƒ­ãƒ³ã§é–‰ã˜ã‚‹ã¨ã€å•ã„åˆã‚ã›ã‚’実行ã—ã¾ã™ã€‚\n" " \\q ã§çµ‚了ã—ã¾ã™ã€‚\n" -#: print.c:272 -#, c-format -msgid "(%lu row)" -msgid_plural "(%lu rows)" -msgstr[0] "(%lu è¡Œ)" -msgstr[1] "(%lu è¡Œ)" - -#: print.c:1174 -#, c-format -msgid "(No rows)\n" -msgstr "(è¡ŒãŒã‚ã‚Šã¾ã›ã‚“)\n" - -#: print.c:2238 -#, c-format -msgid "Interrupted\n" -msgstr "中断ã•ã‚Œã¾ã—ãŸ\n" - -#: print.c:2304 -#, c-format -msgid "Cannot add header to table content: column count of %d exceeded.\n" -msgstr "テーブルã®å†…容ã«è¦‹å‡ºã—を追加ã§ãã¾ã›ã‚“ã§ã—ãŸï¼šåˆ—æ•° %d ãŒåˆ¶é™ã‚’越ãˆã¦ã„ã¾ã™ã€‚\n" - -#: print.c:2344 -#, c-format -msgid "Cannot add cell to table content: total cell count of %d exceeded.\n" -msgstr "テーブルã®å†…容ã«ã‚»ãƒ«ã‚’追加ã§ãã¾ã›ã‚“ã§ã—ãŸï¼šå…¨ã‚»ãƒ«æ•° %d ãŒåˆ¶é™ã‚’越ãˆã¦ã„ã¾ã™ã€‚\n" - -#: print.c:2570 -#, c-format -msgid "invalid output format (internal error): %d" -msgstr "出力フォーマットãŒç„¡åŠ¹ï¼ˆå†…部エラー）：%d" - -#: psqlscan.l:727 -#, c-format -msgid "skipping recursive expansion of variable \"%s\"\n" -msgstr "変数\"%s\"ã®å†å¸°å±•é–‹ã‚’スキップã—ã¦ã„ã¾ã™\n" - -#: psqlscan.l:1604 +#: psqlscanslash.l:584 #, c-format msgid "unterminated quoted string\n" msgstr "文字列ã®å¼•ç”¨ç¬¦ãŒé–‰ã˜ã¦ã„ã¾ã›ã‚“\n" -#: psqlscan.l:1704 +#: psqlscanslash.l:738 #, c-format msgid "%s: out of memory\n" msgstr "%s: メモリä¸è¶³ã§ã™\n" -#: psqlscan.l:1933 -#, c-format -msgid "can't escape without active connection\n" -msgstr "有効ãªæŽ¥ç¶šãªã—ã§ã¯ã‚¨ã‚¹ã‚±ãƒ¼ãƒ—ã§ãã¾ã›ã‚“\n" - -#: sql_help.c:32 sql_help.c:35 sql_help.c:38 sql_help.c:60 sql_help.c:62 -#: sql_help.c:64 sql_help.c:75 sql_help.c:77 sql_help.c:79 sql_help.c:103 -#: sql_help.c:107 sql_help.c:109 sql_help.c:111 sql_help.c:113 sql_help.c:116 -#: sql_help.c:118 sql_help.c:120 sql_help.c:213 sql_help.c:215 sql_help.c:216 -#: sql_help.c:218 sql_help.c:220 sql_help.c:223 sql_help.c:225 sql_help.c:227 -#: sql_help.c:229 sql_help.c:241 sql_help.c:242 sql_help.c:243 sql_help.c:245 -#: sql_help.c:290 sql_help.c:292 sql_help.c:294 sql_help.c:296 sql_help.c:354 -#: sql_help.c:359 sql_help.c:361 sql_help.c:396 sql_help.c:398 sql_help.c:401 -#: sql_help.c:403 sql_help.c:460 sql_help.c:465 sql_help.c:470 sql_help.c:475 -#: sql_help.c:515 sql_help.c:517 sql_help.c:519 sql_help.c:522 sql_help.c:524 -#: sql_help.c:535 sql_help.c:537 sql_help.c:577 sql_help.c:579 sql_help.c:582 -#: sql_help.c:584 sql_help.c:586 sql_help.c:612 sql_help.c:616 sql_help.c:629 -#: sql_help.c:632 sql_help.c:635 sql_help.c:655 sql_help.c:667 sql_help.c:675 -#: sql_help.c:678 sql_help.c:681 sql_help.c:711 sql_help.c:717 sql_help.c:719 -#: sql_help.c:723 sql_help.c:726 sql_help.c:729 sql_help.c:738 sql_help.c:749 -#: sql_help.c:751 sql_help.c:768 sql_help.c:777 sql_help.c:779 sql_help.c:781 -#: sql_help.c:793 sql_help.c:797 sql_help.c:799 sql_help.c:878 sql_help.c:880 -#: sql_help.c:883 sql_help.c:886 sql_help.c:888 sql_help.c:890 sql_help.c:951 -#: sql_help.c:953 sql_help.c:955 sql_help.c:958 sql_help.c:979 sql_help.c:982 -#: sql_help.c:985 sql_help.c:988 sql_help.c:992 sql_help.c:994 sql_help.c:996 -#: sql_help.c:998 sql_help.c:1012 sql_help.c:1015 sql_help.c:1017 -#: sql_help.c:1019 sql_help.c:1029 sql_help.c:1031 sql_help.c:1041 -#: sql_help.c:1043 sql_help.c:1052 sql_help.c:1073 sql_help.c:1075 -#: sql_help.c:1077 sql_help.c:1080 sql_help.c:1082 sql_help.c:1084 -#: sql_help.c:1122 sql_help.c:1128 sql_help.c:1130 sql_help.c:1133 -#: sql_help.c:1135 sql_help.c:1137 sql_help.c:1164 sql_help.c:1167 -#: sql_help.c:1169 sql_help.c:1171 sql_help.c:1173 sql_help.c:1175 -#: sql_help.c:1178 sql_help.c:1218 sql_help.c:1456 sql_help.c:1472 -#: sql_help.c:1485 sql_help.c:1536 sql_help.c:1540 sql_help.c:1550 -#: sql_help.c:1568 sql_help.c:1591 sql_help.c:1609 sql_help.c:1637 -#: sql_help.c:1696 sql_help.c:1738 sql_help.c:1760 sql_help.c:1780 -#: sql_help.c:1781 sql_help.c:1816 sql_help.c:1836 sql_help.c:1858 -#: sql_help.c:1886 sql_help.c:1911 sql_help.c:1947 sql_help.c:2133 -#: sql_help.c:2146 sql_help.c:2163 sql_help.c:2179 sql_help.c:2202 -#: sql_help.c:2253 sql_help.c:2257 sql_help.c:2259 sql_help.c:2265 -#: sql_help.c:2283 sql_help.c:2310 sql_help.c:2345 sql_help.c:2357 -#: sql_help.c:2366 sql_help.c:2416 sql_help.c:2444 sql_help.c:2452 -#: sql_help.c:2460 sql_help.c:2468 sql_help.c:2476 sql_help.c:2484 -#: sql_help.c:2492 sql_help.c:2500 sql_help.c:2509 sql_help.c:2520 -#: sql_help.c:2528 sql_help.c:2536 sql_help.c:2544 sql_help.c:2552 -#: sql_help.c:2562 sql_help.c:2571 sql_help.c:2580 sql_help.c:2588 -#: sql_help.c:2596 sql_help.c:2605 sql_help.c:2613 sql_help.c:2621 -#: sql_help.c:2629 sql_help.c:2637 sql_help.c:2645 sql_help.c:2653 -#: sql_help.c:2661 sql_help.c:2669 sql_help.c:2677 sql_help.c:2686 -#: sql_help.c:2694 sql_help.c:2711 sql_help.c:2726 sql_help.c:2932 -#: sql_help.c:2983 sql_help.c:3011 sql_help.c:3019 sql_help.c:3417 -#: sql_help.c:3465 sql_help.c:3585 +#: sql_help.c:36 sql_help.c:39 sql_help.c:42 sql_help.c:64 sql_help.c:66 +#: sql_help.c:68 sql_help.c:79 sql_help.c:81 sql_help.c:83 sql_help.c:109 +#: sql_help.c:115 sql_help.c:117 sql_help.c:119 sql_help.c:121 sql_help.c:124 +#: sql_help.c:126 sql_help.c:128 sql_help.c:221 sql_help.c:223 sql_help.c:224 +#: sql_help.c:226 sql_help.c:228 sql_help.c:231 sql_help.c:233 sql_help.c:235 +#: sql_help.c:237 sql_help.c:249 sql_help.c:250 sql_help.c:251 sql_help.c:253 +#: sql_help.c:300 sql_help.c:302 sql_help.c:304 sql_help.c:306 sql_help.c:367 +#: sql_help.c:372 sql_help.c:374 sql_help.c:417 sql_help.c:419 sql_help.c:422 +#: sql_help.c:424 sql_help.c:491 sql_help.c:496 sql_help.c:501 sql_help.c:506 +#: sql_help.c:511 sql_help.c:560 sql_help.c:562 sql_help.c:564 sql_help.c:566 +#: sql_help.c:569 sql_help.c:571 sql_help.c:582 sql_help.c:584 sql_help.c:625 +#: sql_help.c:627 sql_help.c:629 sql_help.c:632 sql_help.c:634 sql_help.c:636 +#: sql_help.c:669 sql_help.c:673 sql_help.c:677 sql_help.c:696 sql_help.c:699 +#: sql_help.c:702 sql_help.c:731 sql_help.c:743 sql_help.c:751 sql_help.c:754 +#: sql_help.c:757 sql_help.c:772 sql_help.c:775 sql_help.c:819 sql_help.c:842 +#: sql_help.c:853 sql_help.c:855 sql_help.c:872 sql_help.c:881 sql_help.c:883 +#: sql_help.c:885 sql_help.c:897 sql_help.c:901 sql_help.c:903 sql_help.c:987 +#: sql_help.c:989 sql_help.c:992 sql_help.c:995 sql_help.c:997 sql_help.c:999 +#: sql_help.c:1060 sql_help.c:1062 sql_help.c:1064 sql_help.c:1067 +#: sql_help.c:1088 sql_help.c:1091 sql_help.c:1094 sql_help.c:1097 +#: sql_help.c:1101 sql_help.c:1103 sql_help.c:1105 sql_help.c:1107 +#: sql_help.c:1121 sql_help.c:1124 sql_help.c:1126 sql_help.c:1128 +#: sql_help.c:1138 sql_help.c:1140 sql_help.c:1150 sql_help.c:1152 +#: sql_help.c:1162 sql_help.c:1165 sql_help.c:1186 sql_help.c:1188 +#: sql_help.c:1190 sql_help.c:1193 sql_help.c:1195 sql_help.c:1197 +#: sql_help.c:1247 sql_help.c:1285 sql_help.c:1288 sql_help.c:1290 +#: sql_help.c:1292 sql_help.c:1294 sql_help.c:1296 sql_help.c:1299 +#: sql_help.c:1339 sql_help.c:1544 sql_help.c:1608 sql_help.c:1627 +#: sql_help.c:1640 sql_help.c:1694 sql_help.c:1698 sql_help.c:1708 +#: sql_help.c:1728 sql_help.c:1753 sql_help.c:1771 sql_help.c:1800 +#: sql_help.c:1875 sql_help.c:1917 sql_help.c:1939 sql_help.c:1959 +#: sql_help.c:1960 sql_help.c:1995 sql_help.c:2015 sql_help.c:2037 +#: sql_help.c:2050 sql_help.c:2081 sql_help.c:2106 sql_help.c:2150 +#: sql_help.c:2336 sql_help.c:2349 sql_help.c:2366 sql_help.c:2382 +#: sql_help.c:2421 sql_help.c:2472 sql_help.c:2476 sql_help.c:2478 +#: sql_help.c:2484 sql_help.c:2502 sql_help.c:2529 sql_help.c:2564 +#: sql_help.c:2576 sql_help.c:2585 sql_help.c:2629 sql_help.c:2643 +#: sql_help.c:2671 sql_help.c:2679 sql_help.c:2687 sql_help.c:2695 +#: sql_help.c:2703 sql_help.c:2711 sql_help.c:2719 sql_help.c:2727 +#: sql_help.c:2736 sql_help.c:2747 sql_help.c:2755 sql_help.c:2763 +#: sql_help.c:2771 sql_help.c:2779 sql_help.c:2789 sql_help.c:2798 +#: sql_help.c:2807 sql_help.c:2815 sql_help.c:2824 sql_help.c:2832 +#: sql_help.c:2841 sql_help.c:2849 sql_help.c:2857 sql_help.c:2865 +#: sql_help.c:2873 sql_help.c:2881 sql_help.c:2889 sql_help.c:2897 +#: sql_help.c:2905 sql_help.c:2922 sql_help.c:2931 sql_help.c:2939 +#: sql_help.c:2956 sql_help.c:2971 sql_help.c:3236 sql_help.c:3287 +#: sql_help.c:3316 sql_help.c:3324 sql_help.c:3743 sql_help.c:3791 +#: sql_help.c:3932 msgid "name" msgstr "åå‰" -#: sql_help.c:33 sql_help.c:36 sql_help.c:39 sql_help.c:300 sql_help.c:1279 -#: sql_help.c:2417 sql_help.c:3234 +#: sql_help.c:37 sql_help.c:40 sql_help.c:43 sql_help.c:311 sql_help.c:1405 +#: sql_help.c:2644 sql_help.c:3539 msgid "aggregate_signature" msgstr "集約関数ã®å‘¼å‡ºã—情報" -#: sql_help.c:34 sql_help.c:61 sql_help.c:76 sql_help.c:108 sql_help.c:228 -#: sql_help.c:246 sql_help.c:362 sql_help.c:402 sql_help.c:469 sql_help.c:502 -#: sql_help.c:516 sql_help.c:536 sql_help.c:583 sql_help.c:631 sql_help.c:677 -#: sql_help.c:718 sql_help.c:740 sql_help.c:750 sql_help.c:780 sql_help.c:800 -#: sql_help.c:887 sql_help.c:952 sql_help.c:995 sql_help.c:1016 -#: sql_help.c:1030 sql_help.c:1042 sql_help.c:1054 sql_help.c:1081 -#: sql_help.c:1129 sql_help.c:1172 +#: sql_help.c:38 sql_help.c:65 sql_help.c:80 sql_help.c:116 sql_help.c:236 +#: sql_help.c:254 sql_help.c:375 sql_help.c:423 sql_help.c:500 sql_help.c:546 +#: sql_help.c:561 sql_help.c:583 sql_help.c:633 sql_help.c:698 sql_help.c:753 +#: sql_help.c:774 sql_help.c:820 sql_help.c:844 sql_help.c:854 sql_help.c:884 +#: sql_help.c:904 sql_help.c:996 sql_help.c:1061 sql_help.c:1104 +#: sql_help.c:1125 sql_help.c:1139 sql_help.c:1151 sql_help.c:1164 +#: sql_help.c:1194 sql_help.c:1248 sql_help.c:1293 msgid "new_name" msgstr "æ–°ã—ã„åå‰" -#: sql_help.c:37 sql_help.c:63 sql_help.c:78 sql_help.c:110 sql_help.c:226 -#: sql_help.c:244 sql_help.c:360 sql_help.c:431 sql_help.c:474 sql_help.c:538 -#: sql_help.c:547 sql_help.c:602 sql_help.c:615 sql_help.c:634 sql_help.c:680 -#: sql_help.c:752 sql_help.c:778 sql_help.c:798 sql_help.c:935 sql_help.c:954 -#: sql_help.c:997 sql_help.c:1018 sql_help.c:1076 sql_help.c:1170 +#: sql_help.c:41 sql_help.c:67 sql_help.c:82 sql_help.c:118 sql_help.c:234 +#: sql_help.c:252 sql_help.c:373 sql_help.c:459 sql_help.c:505 sql_help.c:585 +#: sql_help.c:594 sql_help.c:652 sql_help.c:672 sql_help.c:701 sql_help.c:756 +#: sql_help.c:856 sql_help.c:882 sql_help.c:902 sql_help.c:1045 +#: sql_help.c:1063 sql_help.c:1106 sql_help.c:1127 sql_help.c:1189 +#: sql_help.c:1291 sql_help.c:2322 msgid "new_owner" msgstr "æ–°ã—ã„所有者" -#: sql_help.c:40 sql_help.c:65 sql_help.c:80 sql_help.c:230 sql_help.c:293 -#: sql_help.c:404 sql_help.c:479 sql_help.c:585 sql_help.c:619 sql_help.c:637 -#: sql_help.c:683 sql_help.c:782 sql_help.c:889 sql_help.c:999 sql_help.c:1020 -#: sql_help.c:1032 sql_help.c:1044 sql_help.c:1083 sql_help.c:1174 +#: sql_help.c:44 sql_help.c:69 sql_help.c:84 sql_help.c:238 sql_help.c:303 +#: sql_help.c:425 sql_help.c:510 sql_help.c:635 sql_help.c:676 sql_help.c:704 +#: sql_help.c:759 sql_help.c:886 sql_help.c:998 sql_help.c:1108 +#: sql_help.c:1129 sql_help.c:1141 sql_help.c:1153 sql_help.c:1196 +#: sql_help.c:1295 msgid "new_schema" msgstr "æ–°ã—ã„スキーマ" -#: sql_help.c:41 sql_help.c:1326 sql_help.c:2418 sql_help.c:3253 +#: sql_help.c:45 sql_help.c:1458 sql_help.c:2645 sql_help.c:3558 msgid "where aggregate_signature is:" msgstr "集約関数ã®å‘¼å‡ºã—情報ã¯ä»¥ä¸‹ã®é€šã‚Šï¼š" -#: sql_help.c:42 sql_help.c:45 sql_help.c:48 sql_help.c:310 sql_help.c:333 -#: sql_help.c:336 sql_help.c:339 sql_help.c:461 sql_help.c:466 sql_help.c:471 -#: sql_help.c:476 sql_help.c:1295 sql_help.c:1327 sql_help.c:1330 -#: sql_help.c:1333 sql_help.c:1457 sql_help.c:1473 sql_help.c:1476 -#: sql_help.c:1697 sql_help.c:2419 sql_help.c:2422 sql_help.c:2425 -#: sql_help.c:2510 sql_help.c:2870 sql_help.c:3149 sql_help.c:3240 -#: sql_help.c:3254 sql_help.c:3257 sql_help.c:3260 +#: sql_help.c:46 sql_help.c:49 sql_help.c:52 sql_help.c:321 sql_help.c:346 +#: sql_help.c:349 sql_help.c:352 sql_help.c:492 sql_help.c:497 sql_help.c:502 +#: sql_help.c:507 sql_help.c:512 sql_help.c:1423 sql_help.c:1459 +#: sql_help.c:1462 sql_help.c:1465 sql_help.c:1609 sql_help.c:1628 +#: sql_help.c:1631 sql_help.c:1876 sql_help.c:2646 sql_help.c:2649 +#: sql_help.c:2652 sql_help.c:2737 sql_help.c:3122 sql_help.c:3454 +#: sql_help.c:3545 sql_help.c:3559 sql_help.c:3562 sql_help.c:3565 msgid "argmode" msgstr "引数ã®ãƒ¢ãƒ¼ãƒ‰" -#: sql_help.c:43 sql_help.c:46 sql_help.c:49 sql_help.c:311 sql_help.c:334 -#: sql_help.c:337 sql_help.c:340 sql_help.c:462 sql_help.c:467 sql_help.c:472 -#: sql_help.c:477 sql_help.c:1296 sql_help.c:1328 sql_help.c:1331 -#: sql_help.c:1334 sql_help.c:1458 sql_help.c:1474 sql_help.c:1477 -#: sql_help.c:1698 sql_help.c:2420 sql_help.c:2423 sql_help.c:2426 -#: sql_help.c:2511 sql_help.c:3241 sql_help.c:3255 sql_help.c:3258 -#: sql_help.c:3261 +#: sql_help.c:47 sql_help.c:50 sql_help.c:53 sql_help.c:322 sql_help.c:347 +#: sql_help.c:350 sql_help.c:353 sql_help.c:493 sql_help.c:498 sql_help.c:503 +#: sql_help.c:508 sql_help.c:513 sql_help.c:1424 sql_help.c:1460 +#: sql_help.c:1463 sql_help.c:1466 sql_help.c:1610 sql_help.c:1629 +#: sql_help.c:1632 sql_help.c:1877 sql_help.c:2647 sql_help.c:2650 +#: sql_help.c:2653 sql_help.c:2738 sql_help.c:3546 sql_help.c:3560 +#: sql_help.c:3563 sql_help.c:3566 msgid "argname" msgstr "引数å" -#: sql_help.c:44 sql_help.c:47 sql_help.c:50 sql_help.c:312 sql_help.c:335 -#: sql_help.c:338 sql_help.c:341 sql_help.c:463 sql_help.c:468 sql_help.c:473 -#: sql_help.c:478 sql_help.c:1297 sql_help.c:1329 sql_help.c:1332 -#: sql_help.c:1335 sql_help.c:1699 sql_help.c:2421 sql_help.c:2424 -#: sql_help.c:2427 sql_help.c:2512 sql_help.c:3242 sql_help.c:3256 -#: sql_help.c:3259 sql_help.c:3262 +#: sql_help.c:48 sql_help.c:51 sql_help.c:54 sql_help.c:323 sql_help.c:348 +#: sql_help.c:351 sql_help.c:354 sql_help.c:494 sql_help.c:499 sql_help.c:504 +#: sql_help.c:509 sql_help.c:514 sql_help.c:1425 sql_help.c:1461 +#: sql_help.c:1464 sql_help.c:1467 sql_help.c:1878 sql_help.c:2648 +#: sql_help.c:2651 sql_help.c:2654 sql_help.c:2739 sql_help.c:3547 +#: sql_help.c:3561 sql_help.c:3564 sql_help.c:3567 msgid "argtype" msgstr "引数ã®åž‹" -#: sql_help.c:104 sql_help.c:357 sql_help.c:425 sql_help.c:432 sql_help.c:712 -#: sql_help.c:795 sql_help.c:1013 sql_help.c:1123 sql_help.c:1149 -#: sql_help.c:1383 sql_help.c:1389 sql_help.c:1640 sql_help.c:1664 -#: sql_help.c:1669 sql_help.c:1739 sql_help.c:1887 sql_help.c:1968 -#: sql_help.c:2148 sql_help.c:2311 sql_help.c:2333 sql_help.c:2745 +#: sql_help.c:110 sql_help.c:370 sql_help.c:448 sql_help.c:460 sql_help.c:814 +#: sql_help.c:899 sql_help.c:1122 sql_help.c:1242 sql_help.c:1270 +#: sql_help.c:1515 sql_help.c:1521 sql_help.c:1803 sql_help.c:1835 +#: sql_help.c:1842 sql_help.c:1918 sql_help.c:2082 sql_help.c:2171 +#: sql_help.c:2351 sql_help.c:2530 sql_help.c:2552 sql_help.c:2990 +#: sql_help.c:3156 msgid "option" msgstr "オプション" -#: sql_help.c:105 sql_help.c:713 sql_help.c:1124 sql_help.c:1740 -#: sql_help.c:1888 sql_help.c:2312 +#: sql_help.c:111 sql_help.c:815 sql_help.c:1243 sql_help.c:1919 +#: sql_help.c:2083 sql_help.c:2531 msgid "where option can be:" msgstr "オプションã¯ä»¥ä¸‹ã®é€šã‚Šï¼š" -#: sql_help.c:106 sql_help.c:714 sql_help.c:1125 sql_help.c:1575 -#: sql_help.c:1889 sql_help.c:2313 +#: sql_help.c:112 sql_help.c:1735 +msgid "allowconn" +msgstr "接続許å¯" + +#: sql_help.c:113 sql_help.c:816 sql_help.c:1244 sql_help.c:1736 +#: sql_help.c:2084 sql_help.c:2532 msgid "connlimit" msgstr "最大接続数" -#: sql_help.c:112 sql_help.c:526 sql_help.c:588 sql_help.c:603 sql_help.c:892 -#: sql_help.c:936 +#: sql_help.c:114 sql_help.c:1737 +#| msgid "template" +msgid "istemplate" +msgstr "テンプレートã‹" + +#: sql_help.c:120 sql_help.c:573 sql_help.c:638 sql_help.c:1001 +#: sql_help.c:1038 msgid "new_tablespace" msgstr "テーブルスペース" -#: sql_help.c:114 sql_help.c:117 sql_help.c:119 sql_help.c:483 sql_help.c:485 -#: sql_help.c:486 sql_help.c:721 sql_help.c:725 sql_help.c:728 sql_help.c:811 -#: sql_help.c:814 sql_help.c:1131 sql_help.c:1134 sql_help.c:1136 -#: sql_help.c:1707 sql_help.c:3036 sql_help.c:3406 +#: sql_help.c:122 sql_help.c:125 sql_help.c:127 sql_help.c:519 sql_help.c:521 +#: sql_help.c:522 sql_help.c:823 sql_help.c:827 sql_help.c:830 sql_help.c:915 +#: sql_help.c:918 sql_help.c:1250 sql_help.c:1253 sql_help.c:1255 +#: sql_help.c:1887 sql_help.c:3341 sql_help.c:3732 msgid "configuration_parameter" msgstr "設定パラメータ" -#: sql_help.c:115 sql_help.c:358 sql_help.c:421 sql_help.c:426 sql_help.c:433 -#: sql_help.c:484 sql_help.c:521 sql_help.c:594 sql_help.c:600 sql_help.c:722 -#: sql_help.c:796 sql_help.c:812 sql_help.c:813 sql_help.c:911 sql_help.c:930 -#: sql_help.c:957 sql_help.c:1014 sql_help.c:1132 sql_help.c:1150 -#: sql_help.c:1641 sql_help.c:1665 sql_help.c:1670 sql_help.c:1708 -#: sql_help.c:1709 sql_help.c:1768 sql_help.c:1800 sql_help.c:1969 -#: sql_help.c:2043 sql_help.c:2051 sql_help.c:2083 sql_help.c:2105 -#: sql_help.c:2122 sql_help.c:2149 sql_help.c:2334 sql_help.c:3407 -#: sql_help.c:3408 +#: sql_help.c:123 sql_help.c:371 sql_help.c:443 sql_help.c:449 sql_help.c:461 +#: sql_help.c:520 sql_help.c:568 sql_help.c:644 sql_help.c:650 sql_help.c:824 +#: sql_help.c:900 sql_help.c:916 sql_help.c:917 sql_help.c:1020 +#: sql_help.c:1040 sql_help.c:1066 sql_help.c:1123 sql_help.c:1251 +#: sql_help.c:1271 sql_help.c:1804 sql_help.c:1836 sql_help.c:1843 +#: sql_help.c:1888 sql_help.c:1889 sql_help.c:1947 sql_help.c:1979 +#: sql_help.c:2172 sql_help.c:2246 sql_help.c:2254 sql_help.c:2286 +#: sql_help.c:2308 sql_help.c:2325 sql_help.c:2352 sql_help.c:2553 +#: sql_help.c:3157 sql_help.c:3733 sql_help.c:3734 msgid "value" msgstr "値" -#: sql_help.c:177 +#: sql_help.c:185 msgid "target_role" msgstr "対象ã®ãƒ­ãƒ¼ãƒ«" -#: sql_help.c:178 sql_help.c:1624 sql_help.c:1929 sql_help.c:1934 -#: sql_help.c:2852 sql_help.c:2859 sql_help.c:2873 sql_help.c:2879 -#: sql_help.c:3131 sql_help.c:3138 sql_help.c:3152 sql_help.c:3158 +#: sql_help.c:186 sql_help.c:1787 sql_help.c:2130 sql_help.c:2135 +#: sql_help.c:3104 sql_help.c:3111 sql_help.c:3125 sql_help.c:3131 +#: sql_help.c:3436 sql_help.c:3443 sql_help.c:3457 sql_help.c:3463 msgid "schema_name" msgstr "スキーマå" -#: sql_help.c:179 +#: sql_help.c:187 msgid "abbreviated_grant_or_revoke" msgstr "権é™ä»˜ä¸Žï¼å‰¥å¥ªã®çœç•¥å½¢" -#: sql_help.c:180 +#: sql_help.c:188 msgid "where abbreviated_grant_or_revoke is one of:" msgstr "権é™ä»˜ä¸Žï¼å‰¥å¥ªã®çœç•¥å½¢ã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:181 sql_help.c:182 sql_help.c:183 sql_help.c:184 sql_help.c:185 -#: sql_help.c:186 sql_help.c:187 sql_help.c:188 sql_help.c:525 sql_help.c:587 -#: sql_help.c:891 sql_help.c:1743 sql_help.c:1744 sql_help.c:1745 -#: sql_help.c:1746 sql_help.c:1747 sql_help.c:1892 sql_help.c:1893 -#: sql_help.c:1894 sql_help.c:1895 sql_help.c:1896 sql_help.c:2316 -#: sql_help.c:2317 sql_help.c:2318 sql_help.c:2319 sql_help.c:2320 -#: sql_help.c:2853 sql_help.c:2857 sql_help.c:2860 sql_help.c:2862 -#: sql_help.c:2864 sql_help.c:2866 sql_help.c:2868 sql_help.c:2874 -#: sql_help.c:2876 sql_help.c:2878 sql_help.c:2880 sql_help.c:2882 -#: sql_help.c:2884 sql_help.c:2885 sql_help.c:2886 sql_help.c:3132 -#: sql_help.c:3136 sql_help.c:3139 sql_help.c:3141 sql_help.c:3143 -#: sql_help.c:3145 sql_help.c:3147 sql_help.c:3153 sql_help.c:3155 -#: sql_help.c:3157 sql_help.c:3159 sql_help.c:3161 sql_help.c:3163 -#: sql_help.c:3164 sql_help.c:3165 sql_help.c:3427 +#: sql_help.c:189 sql_help.c:190 sql_help.c:191 sql_help.c:192 sql_help.c:193 +#: sql_help.c:194 sql_help.c:195 sql_help.c:196 sql_help.c:544 sql_help.c:572 +#: sql_help.c:637 sql_help.c:777 sql_help.c:834 sql_help.c:1000 +#: sql_help.c:1258 sql_help.c:1922 sql_help.c:1923 sql_help.c:1924 +#: sql_help.c:1925 sql_help.c:1926 sql_help.c:2052 sql_help.c:2087 +#: sql_help.c:2088 sql_help.c:2089 sql_help.c:2090 sql_help.c:2091 +#: sql_help.c:2535 sql_help.c:2536 sql_help.c:2537 sql_help.c:2538 +#: sql_help.c:2539 sql_help.c:3138 sql_help.c:3139 sql_help.c:3140 +#: sql_help.c:3437 sql_help.c:3441 sql_help.c:3444 sql_help.c:3446 +#: sql_help.c:3448 sql_help.c:3450 sql_help.c:3452 sql_help.c:3458 +#: sql_help.c:3460 sql_help.c:3462 sql_help.c:3464 sql_help.c:3466 +#: sql_help.c:3468 sql_help.c:3469 sql_help.c:3470 sql_help.c:3753 msgid "role_name" msgstr "ロールå" -#: sql_help.c:214 sql_help.c:414 sql_help.c:902 sql_help.c:904 sql_help.c:1166 -#: sql_help.c:1594 sql_help.c:1598 sql_help.c:1764 sql_help.c:2055 -#: sql_help.c:2065 sql_help.c:2087 sql_help.c:2900 sql_help.c:3303 -#: sql_help.c:3304 sql_help.c:3308 sql_help.c:3313 sql_help.c:3381 -#: sql_help.c:3382 sql_help.c:3387 sql_help.c:3392 sql_help.c:3521 -#: sql_help.c:3522 sql_help.c:3526 sql_help.c:3531 sql_help.c:3611 -#: sql_help.c:3613 sql_help.c:3644 sql_help.c:3690 sql_help.c:3691 -#: sql_help.c:3695 sql_help.c:3700 +#: sql_help.c:222 sql_help.c:436 sql_help.c:1011 sql_help.c:1013 +#: sql_help.c:1287 sql_help.c:1756 sql_help.c:1760 sql_help.c:1846 +#: sql_help.c:1850 sql_help.c:1943 sql_help.c:2258 sql_help.c:2268 +#: sql_help.c:2290 sql_help.c:3187 sql_help.c:3202 sql_help.c:3204 +#: sql_help.c:3618 sql_help.c:3619 sql_help.c:3628 sql_help.c:3669 +#: sql_help.c:3670 sql_help.c:3671 sql_help.c:3672 sql_help.c:3673 +#: sql_help.c:3674 sql_help.c:3707 sql_help.c:3708 sql_help.c:3713 +#: sql_help.c:3718 sql_help.c:3857 sql_help.c:3858 sql_help.c:3867 +#: sql_help.c:3908 sql_help.c:3909 sql_help.c:3910 sql_help.c:3911 +#: sql_help.c:3912 sql_help.c:3913 sql_help.c:3960 sql_help.c:3962 +#: sql_help.c:3995 sql_help.c:4051 sql_help.c:4052 sql_help.c:4061 +#: sql_help.c:4102 sql_help.c:4103 sql_help.c:4104 sql_help.c:4105 +#: sql_help.c:4106 sql_help.c:4107 msgid "expression" msgstr "評価å¼" -#: sql_help.c:217 +#: sql_help.c:225 msgid "domain_constraint" msgstr "ドメイン制約" -#: sql_help.c:219 sql_help.c:221 sql_help.c:224 sql_help.c:884 sql_help.c:917 -#: sql_help.c:918 sql_help.c:919 sql_help.c:939 sql_help.c:1285 -#: sql_help.c:1597 sql_help.c:1672 sql_help.c:2054 sql_help.c:2064 +#: sql_help.c:227 sql_help.c:229 sql_help.c:232 sql_help.c:451 sql_help.c:452 +#: sql_help.c:993 sql_help.c:1026 sql_help.c:1027 sql_help.c:1028 +#: sql_help.c:1048 sql_help.c:1411 sql_help.c:1413 sql_help.c:1759 +#: sql_help.c:1845 sql_help.c:1849 sql_help.c:2257 sql_help.c:2267 +#: sql_help.c:3199 msgid "constraint_name" msgstr "制約å" -#: sql_help.c:222 sql_help.c:885 +#: sql_help.c:230 sql_help.c:994 msgid "new_constraint_name" msgstr "æ–°ã—ã„制約å" -#: sql_help.c:291 sql_help.c:794 +#: sql_help.c:301 sql_help.c:898 msgid "new_version" msgstr "æ–°ã—ã„ãƒãƒ¼ã‚¸ãƒ§ãƒ³" -#: sql_help.c:295 sql_help.c:297 +#: sql_help.c:305 sql_help.c:307 msgid "member_object" msgstr "メンãƒã‚ªãƒ–ジェクト" -#: sql_help.c:298 +#: sql_help.c:308 msgid "where member_object is:" msgstr "メンãƒã‚ªãƒ–ジェクトã¯ä»¥ä¸‹ã®é€šã‚Š:" -#: sql_help.c:299 sql_help.c:1278 sql_help.c:3233 +#: sql_help.c:309 sql_help.c:314 sql_help.c:315 sql_help.c:316 sql_help.c:317 +#: sql_help.c:318 sql_help.c:319 sql_help.c:324 sql_help.c:328 sql_help.c:330 +#: sql_help.c:332 sql_help.c:333 sql_help.c:334 sql_help.c:335 sql_help.c:336 +#: sql_help.c:337 sql_help.c:338 sql_help.c:339 sql_help.c:340 sql_help.c:343 +#: sql_help.c:344 sql_help.c:1403 sql_help.c:1408 sql_help.c:1415 +#: sql_help.c:1416 sql_help.c:1417 sql_help.c:1418 sql_help.c:1419 +#: sql_help.c:1420 sql_help.c:1421 sql_help.c:1426 sql_help.c:1428 +#: sql_help.c:1432 sql_help.c:1434 sql_help.c:1438 sql_help.c:1439 +#: sql_help.c:1442 sql_help.c:1443 sql_help.c:1444 sql_help.c:1445 +#: sql_help.c:1446 sql_help.c:1447 sql_help.c:1448 sql_help.c:1449 +#: sql_help.c:1450 sql_help.c:1455 sql_help.c:1456 sql_help.c:3535 +#: sql_help.c:3540 sql_help.c:3541 sql_help.c:3542 sql_help.c:3543 +#: sql_help.c:3549 sql_help.c:3550 sql_help.c:3551 sql_help.c:3552 +#: sql_help.c:3553 sql_help.c:3554 sql_help.c:3555 sql_help.c:3556 +msgid "object_name" +msgstr "オブジェクトå" + +#: sql_help.c:310 sql_help.c:1404 sql_help.c:3538 msgid "aggregate_name" msgstr "集約関数ã®åå‰" -#: sql_help.c:301 sql_help.c:1280 sql_help.c:1516 sql_help.c:1520 -#: sql_help.c:1522 sql_help.c:2435 +#: sql_help.c:312 sql_help.c:1406 sql_help.c:1674 sql_help.c:1678 +#: sql_help.c:1680 sql_help.c:2662 msgid "source_type" msgstr "ソースã®åž‹" -#: sql_help.c:302 sql_help.c:1281 sql_help.c:1517 sql_help.c:1521 -#: sql_help.c:1523 sql_help.c:2436 +#: sql_help.c:313 sql_help.c:1407 sql_help.c:1675 sql_help.c:1679 +#: sql_help.c:1681 sql_help.c:2663 msgid "target_type" msgstr "ターゲットã®åž‹" -#: sql_help.c:303 sql_help.c:304 sql_help.c:305 sql_help.c:306 sql_help.c:307 -#: sql_help.c:308 sql_help.c:313 sql_help.c:317 sql_help.c:319 sql_help.c:321 -#: sql_help.c:322 sql_help.c:323 sql_help.c:324 sql_help.c:325 sql_help.c:326 -#: sql_help.c:327 sql_help.c:328 sql_help.c:329 sql_help.c:330 sql_help.c:331 -#: sql_help.c:1282 sql_help.c:1287 sql_help.c:1288 sql_help.c:1289 -#: sql_help.c:1290 sql_help.c:1291 sql_help.c:1292 sql_help.c:1293 -#: sql_help.c:1298 sql_help.c:1300 sql_help.c:1304 sql_help.c:1306 -#: sql_help.c:1308 sql_help.c:1309 sql_help.c:1312 sql_help.c:1313 -#: sql_help.c:1314 sql_help.c:1315 sql_help.c:1316 sql_help.c:1317 -#: sql_help.c:1318 sql_help.c:1319 sql_help.c:1320 sql_help.c:1323 -#: sql_help.c:1324 sql_help.c:3230 sql_help.c:3235 sql_help.c:3236 -#: sql_help.c:3237 sql_help.c:3238 sql_help.c:3244 sql_help.c:3245 -#: sql_help.c:3246 sql_help.c:3247 sql_help.c:3248 sql_help.c:3249 -#: sql_help.c:3250 sql_help.c:3251 -msgid "object_name" -msgstr "オブジェクトå" - -#: sql_help.c:309 sql_help.c:665 sql_help.c:1294 sql_help.c:1518 -#: sql_help.c:1553 sql_help.c:1612 sql_help.c:1817 sql_help.c:1848 -#: sql_help.c:2207 sql_help.c:2869 sql_help.c:3148 sql_help.c:3239 -#: sql_help.c:3329 sql_help.c:3333 sql_help.c:3337 sql_help.c:3340 -#: sql_help.c:3547 sql_help.c:3551 sql_help.c:3555 sql_help.c:3558 -#: sql_help.c:3716 sql_help.c:3720 sql_help.c:3724 sql_help.c:3727 +#: sql_help.c:320 sql_help.c:741 sql_help.c:1422 sql_help.c:1676 +#: sql_help.c:1711 sql_help.c:1774 sql_help.c:1996 sql_help.c:2027 +#: sql_help.c:2426 sql_help.c:3121 sql_help.c:3453 sql_help.c:3544 +#: sql_help.c:3647 sql_help.c:3651 sql_help.c:3655 sql_help.c:3658 +#: sql_help.c:3886 sql_help.c:3890 sql_help.c:3894 sql_help.c:3897 +#: sql_help.c:4080 sql_help.c:4084 sql_help.c:4088 sql_help.c:4091 msgid "function_name" msgstr "関数å" -#: sql_help.c:314 sql_help.c:658 sql_help.c:1301 sql_help.c:1841 +#: sql_help.c:325 sql_help.c:734 sql_help.c:1429 sql_help.c:2020 msgid "operator_name" msgstr "演算å­å" -#: sql_help.c:315 sql_help.c:613 sql_help.c:617 sql_help.c:1302 -#: sql_help.c:1818 sql_help.c:2553 +#: sql_help.c:326 sql_help.c:670 sql_help.c:674 sql_help.c:678 sql_help.c:1430 +#: sql_help.c:1997 sql_help.c:2780 msgid "left_type" msgstr "左辺ã®åž‹" -#: sql_help.c:316 sql_help.c:614 sql_help.c:618 sql_help.c:1303 -#: sql_help.c:1819 sql_help.c:2554 +#: sql_help.c:327 sql_help.c:671 sql_help.c:675 sql_help.c:679 sql_help.c:1431 +#: sql_help.c:1998 sql_help.c:2781 msgid "right_type" msgstr "å³è¾ºã®åž‹" -#: sql_help.c:318 sql_help.c:320 sql_help.c:630 sql_help.c:633 sql_help.c:636 -#: sql_help.c:656 sql_help.c:668 sql_help.c:676 sql_help.c:679 sql_help.c:682 -#: sql_help.c:1305 sql_help.c:1307 sql_help.c:1838 sql_help.c:1859 -#: sql_help.c:2070 sql_help.c:2563 sql_help.c:2572 +#: sql_help.c:329 sql_help.c:331 sql_help.c:697 sql_help.c:700 sql_help.c:703 +#: sql_help.c:732 sql_help.c:744 sql_help.c:752 sql_help.c:755 sql_help.c:758 +#: sql_help.c:1433 sql_help.c:1435 sql_help.c:2017 sql_help.c:2038 +#: sql_help.c:2273 sql_help.c:2790 sql_help.c:2799 msgid "index_method" msgstr "インデックスメソッド" -#: sql_help.c:332 +#: sql_help.c:341 sql_help.c:1044 sql_help.c:1451 sql_help.c:1884 +#: sql_help.c:2249 sql_help.c:2395 sql_help.c:2913 sql_help.c:3135 +#: sql_help.c:3467 +msgid "type_name" +msgstr "åž‹å" + +#: sql_help.c:342 sql_help.c:1452 sql_help.c:1883 sql_help.c:2396 +#: sql_help.c:2620 sql_help.c:2914 sql_help.c:3127 sql_help.c:3459 +msgid "lang_name" +msgstr "言語" + +#: sql_help.c:345 msgid "and aggregate_signature is:" msgstr "集約関数ã®å‘¼å‡ºã—情報ã¯ä»¥ä¸‹ã®é€šã‚Š" -#: sql_help.c:355 sql_help.c:1638 +#: sql_help.c:368 sql_help.c:1546 sql_help.c:1801 msgid "handler_function" msgstr "ãƒãƒ³ãƒ‰ãƒ©é–¢æ•°" -#: sql_help.c:356 sql_help.c:1639 +#: sql_help.c:369 sql_help.c:1802 msgid "validator_function" msgstr "ãƒãƒªãƒ‡ãƒ¼ã‚¿é–¢æ•°" -#: sql_help.c:397 sql_help.c:464 sql_help.c:578 sql_help.c:879 sql_help.c:1074 -#: sql_help.c:2061 sql_help.c:2062 sql_help.c:2078 sql_help.c:2079 +#: sql_help.c:418 sql_help.c:495 sql_help.c:626 sql_help.c:988 sql_help.c:1187 +#: sql_help.c:2264 sql_help.c:2265 sql_help.c:2281 sql_help.c:2282 msgid "action" msgstr "アクション" -#: sql_help.c:399 sql_help.c:406 sql_help.c:410 sql_help.c:411 sql_help.c:413 -#: sql_help.c:415 sql_help.c:416 sql_help.c:417 sql_help.c:419 sql_help.c:422 -#: sql_help.c:424 sql_help.c:580 sql_help.c:590 sql_help.c:592 sql_help.c:595 -#: sql_help.c:597 sql_help.c:776 sql_help.c:881 sql_help.c:894 sql_help.c:898 -#: sql_help.c:899 sql_help.c:903 sql_help.c:905 sql_help.c:906 sql_help.c:907 -#: sql_help.c:909 sql_help.c:912 sql_help.c:914 sql_help.c:1165 -#: sql_help.c:1168 sql_help.c:1188 sql_help.c:1284 sql_help.c:1380 -#: sql_help.c:1385 sql_help.c:1399 sql_help.c:1400 sql_help.c:1401 -#: sql_help.c:1662 sql_help.c:1702 sql_help.c:1763 sql_help.c:1798 -#: sql_help.c:1954 sql_help.c:2034 sql_help.c:2047 sql_help.c:2066 -#: sql_help.c:2068 sql_help.c:2075 sql_help.c:2086 sql_help.c:2103 -#: sql_help.c:2210 sql_help.c:2346 sql_help.c:2854 sql_help.c:2855 -#: sql_help.c:2899 sql_help.c:3133 sql_help.c:3134 sql_help.c:3232 -#: sql_help.c:3352 sql_help.c:3570 sql_help.c:3610 sql_help.c:3612 -#: sql_help.c:3629 sql_help.c:3632 sql_help.c:3739 +#: sql_help.c:420 sql_help.c:427 sql_help.c:431 sql_help.c:432 sql_help.c:435 +#: sql_help.c:437 sql_help.c:438 sql_help.c:439 sql_help.c:441 sql_help.c:444 +#: sql_help.c:446 sql_help.c:447 sql_help.c:630 sql_help.c:640 sql_help.c:642 +#: sql_help.c:645 sql_help.c:647 sql_help.c:880 sql_help.c:990 sql_help.c:1003 +#: sql_help.c:1007 sql_help.c:1008 sql_help.c:1012 sql_help.c:1014 +#: sql_help.c:1015 sql_help.c:1016 sql_help.c:1018 sql_help.c:1021 +#: sql_help.c:1023 sql_help.c:1286 sql_help.c:1289 sql_help.c:1309 +#: sql_help.c:1410 sql_help.c:1512 sql_help.c:1517 sql_help.c:1531 +#: sql_help.c:1532 sql_help.c:1533 sql_help.c:1833 sql_help.c:1881 +#: sql_help.c:1942 sql_help.c:1977 sql_help.c:2157 sql_help.c:2237 +#: sql_help.c:2250 sql_help.c:2269 sql_help.c:2271 sql_help.c:2278 +#: sql_help.c:2289 sql_help.c:2306 sql_help.c:2429 sql_help.c:2565 +#: sql_help.c:3106 sql_help.c:3107 sql_help.c:3186 sql_help.c:3201 +#: sql_help.c:3203 sql_help.c:3205 sql_help.c:3438 sql_help.c:3439 +#: sql_help.c:3537 sql_help.c:3678 sql_help.c:3917 sql_help.c:3959 +#: sql_help.c:3961 sql_help.c:3963 sql_help.c:3980 sql_help.c:3983 +#: sql_help.c:4111 msgid "column_name" msgstr "列å" -#: sql_help.c:400 sql_help.c:581 sql_help.c:882 +#: sql_help.c:421 sql_help.c:631 sql_help.c:991 msgid "new_column_name" msgstr "æ–°ã—ã„列å" -#: sql_help.c:405 sql_help.c:480 sql_help.c:589 sql_help.c:893 sql_help.c:1087 +#: sql_help.c:426 sql_help.c:516 sql_help.c:639 sql_help.c:1002 +#: sql_help.c:1200 msgid "where action is one of:" msgstr "アクションã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:407 sql_help.c:412 sql_help.c:895 sql_help.c:900 sql_help.c:1089 -#: sql_help.c:1093 sql_help.c:1592 sql_help.c:1663 sql_help.c:1837 -#: sql_help.c:2035 sql_help.c:2255 sql_help.c:2984 +#: sql_help.c:428 sql_help.c:433 sql_help.c:1004 sql_help.c:1009 +#: sql_help.c:1202 sql_help.c:1206 sql_help.c:1754 sql_help.c:1834 +#: sql_help.c:2016 sql_help.c:2238 sql_help.c:2474 sql_help.c:3288 msgid "data_type" msgstr "データ型" -#: sql_help.c:408 sql_help.c:896 sql_help.c:901 sql_help.c:1090 -#: sql_help.c:1094 sql_help.c:1593 sql_help.c:1666 sql_help.c:1765 -#: sql_help.c:2036 sql_help.c:2256 sql_help.c:2262 +#: sql_help.c:429 sql_help.c:434 sql_help.c:1005 sql_help.c:1010 +#: sql_help.c:1203 sql_help.c:1207 sql_help.c:1755 sql_help.c:1837 +#: sql_help.c:1944 sql_help.c:2239 sql_help.c:2475 sql_help.c:2481 +#: sql_help.c:3196 msgid "collation" msgstr "ç…§åˆé †åº" -#: sql_help.c:409 sql_help.c:897 sql_help.c:1667 sql_help.c:2037 -#: sql_help.c:2048 +#: sql_help.c:430 sql_help.c:1006 sql_help.c:1838 sql_help.c:2240 +#: sql_help.c:2251 msgid "column_constraint" msgstr "列制約" -#: sql_help.c:418 sql_help.c:591 sql_help.c:908 +#: sql_help.c:440 sql_help.c:641 sql_help.c:1017 msgid "integer" msgstr "æ•´æ•°" -#: sql_help.c:420 sql_help.c:423 sql_help.c:593 sql_help.c:596 sql_help.c:910 -#: sql_help.c:913 +#: sql_help.c:442 sql_help.c:445 sql_help.c:643 sql_help.c:646 sql_help.c:1019 +#: sql_help.c:1022 msgid "attribute_option" msgstr "属性オプション" -#: sql_help.c:427 sql_help.c:428 sql_help.c:429 sql_help.c:430 sql_help.c:920 -#: sql_help.c:921 sql_help.c:922 sql_help.c:923 sql_help.c:1321 +#: sql_help.c:450 sql_help.c:1024 sql_help.c:1839 sql_help.c:2241 +#: sql_help.c:2252 +msgid "table_constraint" +msgstr "テーブル制約" + +#: sql_help.c:453 sql_help.c:454 sql_help.c:455 sql_help.c:456 sql_help.c:1029 +#: sql_help.c:1030 sql_help.c:1031 sql_help.c:1032 sql_help.c:1453 msgid "trigger_name" msgstr "トリガーå" -#: sql_help.c:481 sql_help.c:1705 +#: sql_help.c:457 sql_help.c:458 sql_help.c:1042 sql_help.c:1043 +#: sql_help.c:1840 sql_help.c:2244 +msgid "parent_table" +msgstr "親テーブル" + +#: sql_help.c:515 sql_help.c:565 sql_help.c:628 sql_help.c:1167 +#: sql_help.c:1786 +msgid "extension_name" +msgstr "æ‹¡å¼µå" + +#: sql_help.c:517 sql_help.c:1885 msgid "execution_cost" msgstr "実行コスト" -#: sql_help.c:482 sql_help.c:1706 +#: sql_help.c:518 sql_help.c:1886 msgid "result_rows" msgstr "çµæžœã®è¡Œæ•°" -#: sql_help.c:497 sql_help.c:499 sql_help.c:501 -msgid "group_name" -msgstr "グループå" - -#: sql_help.c:498 sql_help.c:500 sql_help.c:1147 sql_help.c:1569 -#: sql_help.c:1930 sql_help.c:1932 sql_help.c:1935 sql_help.c:1936 -#: sql_help.c:2119 sql_help.c:2331 sql_help.c:2702 sql_help.c:3437 +#: sql_help.c:539 sql_help.c:541 sql_help.c:813 sql_help.c:821 sql_help.c:825 +#: sql_help.c:828 sql_help.c:831 sql_help.c:1241 sql_help.c:1249 +#: sql_help.c:1252 sql_help.c:1254 sql_help.c:1256 sql_help.c:2131 +#: sql_help.c:2133 sql_help.c:2136 sql_help.c:2137 sql_help.c:3105 +#: sql_help.c:3109 sql_help.c:3112 sql_help.c:3114 sql_help.c:3116 +#: sql_help.c:3118 sql_help.c:3120 sql_help.c:3126 sql_help.c:3128 +#: sql_help.c:3130 sql_help.c:3132 sql_help.c:3134 sql_help.c:3136 +#| msgid "Replication" +msgid "role_specification" +msgstr "ロールã®æŒ‡å®š" + +#: sql_help.c:540 sql_help.c:542 sql_help.c:1268 sql_help.c:1729 +#: sql_help.c:2139 sql_help.c:2550 sql_help.c:2947 sql_help.c:3763 msgid "user_name" msgstr "ユーザå" -#: sql_help.c:518 sql_help.c:1574 sql_help.c:1769 sql_help.c:1801 -#: sql_help.c:2044 sql_help.c:2052 sql_help.c:2084 sql_help.c:2106 -#: sql_help.c:2118 sql_help.c:2881 sql_help.c:3160 +#: sql_help.c:543 sql_help.c:833 sql_help.c:1257 sql_help.c:2138 +#: sql_help.c:3137 +#| msgid "where option can be:" +msgid "where role_specification can be:" +msgstr "ロールã®æŒ‡å®šã¯ä»¥ä¸‹ã®é€šã‚Š:" + +#: sql_help.c:545 +msgid "group_name" +msgstr "グループå" + +#: sql_help.c:563 sql_help.c:1734 sql_help.c:1948 sql_help.c:1980 +#: sql_help.c:2247 sql_help.c:2255 sql_help.c:2287 sql_help.c:2309 +#: sql_help.c:2321 sql_help.c:3133 sql_help.c:3465 msgid "tablespace_name" msgstr "テーブルスペースå" -#: sql_help.c:520 sql_help.c:523 sql_help.c:599 sql_help.c:601 sql_help.c:929 -#: sql_help.c:931 sql_help.c:1767 sql_help.c:1799 sql_help.c:2042 -#: sql_help.c:2050 sql_help.c:2082 sql_help.c:2104 +#: sql_help.c:567 sql_help.c:570 sql_help.c:649 sql_help.c:651 sql_help.c:1039 +#: sql_help.c:1041 sql_help.c:1946 sql_help.c:1978 sql_help.c:2245 +#: sql_help.c:2253 sql_help.c:2285 sql_help.c:2307 msgid "storage_parameter" msgstr "ストレージパラメーター" -#: sql_help.c:546 sql_help.c:1299 sql_help.c:3243 +#: sql_help.c:593 sql_help.c:1427 sql_help.c:3548 msgid "large_object_oid" msgstr "ラージオブジェクトã®oid" -#: sql_help.c:598 sql_help.c:928 sql_help.c:937 sql_help.c:940 sql_help.c:1228 +#: sql_help.c:648 sql_help.c:1037 sql_help.c:1046 sql_help.c:1049 +#: sql_help.c:1349 msgid "index_name" msgstr "インデックスå" -#: sql_help.c:657 sql_help.c:669 sql_help.c:1840 +#: sql_help.c:680 sql_help.c:2001 +msgid "res_proc" +msgstr "制約手続ã" + +#: sql_help.c:681 sql_help.c:2002 +msgid "join_proc" +msgstr "JOIN手続ã" + +#: sql_help.c:733 sql_help.c:745 sql_help.c:2019 msgid "strategy_number" msgstr "ストラテジー番å·" -#: sql_help.c:659 sql_help.c:660 sql_help.c:663 sql_help.c:664 sql_help.c:670 -#: sql_help.c:671 sql_help.c:673 sql_help.c:674 sql_help.c:1842 -#: sql_help.c:1843 sql_help.c:1846 sql_help.c:1847 +#: sql_help.c:735 sql_help.c:736 sql_help.c:739 sql_help.c:740 sql_help.c:746 +#: sql_help.c:747 sql_help.c:749 sql_help.c:750 sql_help.c:2021 +#: sql_help.c:2022 sql_help.c:2025 sql_help.c:2026 msgid "op_type" msgstr "演算å­ã®åž‹" -#: sql_help.c:661 sql_help.c:1844 +#: sql_help.c:737 sql_help.c:2023 msgid "sort_family_name" msgstr "ソートファミリーå" -#: sql_help.c:662 sql_help.c:672 sql_help.c:1845 +#: sql_help.c:738 sql_help.c:748 sql_help.c:2024 msgid "support_number" msgstr "サãƒãƒ¼ãƒˆç•ªå·" -#: sql_help.c:666 sql_help.c:1519 sql_help.c:1849 +#: sql_help.c:742 sql_help.c:1677 sql_help.c:2028 sql_help.c:2398 +#: sql_help.c:2400 msgid "argument_type" msgstr "引数ã®åž‹" -#: sql_help.c:715 sql_help.c:1126 sql_help.c:1741 sql_help.c:1890 -#: sql_help.c:2314 +#: sql_help.c:773 sql_help.c:776 sql_help.c:843 sql_help.c:879 sql_help.c:1163 +#: sql_help.c:1166 sql_help.c:1308 sql_help.c:1348 sql_help.c:1412 +#: sql_help.c:1437 sql_help.c:1441 sql_help.c:1454 sql_help.c:1511 +#: sql_help.c:1516 sql_help.c:1832 sql_help.c:1940 sql_help.c:1976 +#: sql_help.c:2051 sql_help.c:2108 sql_help.c:2156 sql_help.c:2236 +#: sql_help.c:2248 sql_help.c:2305 sql_help.c:2423 sql_help.c:2599 +#: sql_help.c:2816 sql_help.c:2833 sql_help.c:2923 sql_help.c:3103 +#: sql_help.c:3108 sql_help.c:3153 sql_help.c:3184 sql_help.c:3435 +#: sql_help.c:3440 sql_help.c:3536 sql_help.c:3633 sql_help.c:3635 +#: sql_help.c:3684 sql_help.c:3723 sql_help.c:3872 sql_help.c:3874 +#: sql_help.c:3923 sql_help.c:3957 sql_help.c:3979 sql_help.c:3981 +#: sql_help.c:3982 sql_help.c:4066 sql_help.c:4068 sql_help.c:4117 +msgid "table_name" +msgstr "テーブルå" + +#: sql_help.c:778 sql_help.c:2053 +#| msgid "missing expression" +msgid "using_expression" +msgstr "USING評価å¼" + +#: sql_help.c:779 sql_help.c:2054 +#| msgid "expression" +msgid "check_expression" +msgstr "CHECK評価å¼" + +#: sql_help.c:817 sql_help.c:1245 sql_help.c:1920 sql_help.c:2085 +#: sql_help.c:2533 msgid "password" msgstr "パスワード" -#: sql_help.c:716 sql_help.c:1127 sql_help.c:1742 sql_help.c:1891 -#: sql_help.c:2315 +#: sql_help.c:818 sql_help.c:1246 sql_help.c:1921 sql_help.c:2086 +#: sql_help.c:2534 msgid "timestamp" msgstr "タイムスタンプ" -#: sql_help.c:720 sql_help.c:724 sql_help.c:727 sql_help.c:730 sql_help.c:2861 -#: sql_help.c:3140 +#: sql_help.c:822 sql_help.c:826 sql_help.c:829 sql_help.c:832 sql_help.c:3113 +#: sql_help.c:3445 msgid "database_name" msgstr "データベースå" -#: sql_help.c:739 sql_help.c:775 sql_help.c:1053 sql_help.c:1187 -#: sql_help.c:1227 sql_help.c:1286 sql_help.c:1311 sql_help.c:1322 -#: sql_help.c:1379 sql_help.c:1384 sql_help.c:1661 sql_help.c:1761 -#: sql_help.c:1797 sql_help.c:1913 sql_help.c:1953 sql_help.c:2033 -#: sql_help.c:2045 sql_help.c:2102 sql_help.c:2204 sql_help.c:2380 -#: sql_help.c:2597 sql_help.c:2678 sql_help.c:2851 sql_help.c:2856 -#: sql_help.c:2898 sql_help.c:3130 sql_help.c:3135 sql_help.c:3231 -#: sql_help.c:3318 sql_help.c:3320 sql_help.c:3358 sql_help.c:3397 -#: sql_help.c:3536 sql_help.c:3538 sql_help.c:3576 sql_help.c:3608 -#: sql_help.c:3628 sql_help.c:3630 sql_help.c:3631 sql_help.c:3705 -#: sql_help.c:3707 sql_help.c:3745 -msgid "table_name" -msgstr "テーブルå" - -#: sql_help.c:769 sql_help.c:1948 +#: sql_help.c:873 sql_help.c:2151 msgid "increment" msgstr "増分" -#: sql_help.c:770 sql_help.c:1949 +#: sql_help.c:874 sql_help.c:2152 msgid "minvalue" msgstr "最å°å€¤" -#: sql_help.c:771 sql_help.c:1950 +#: sql_help.c:875 sql_help.c:2153 msgid "maxvalue" msgstr "最大値" -#: sql_help.c:772 sql_help.c:1951 sql_help.c:3316 sql_help.c:3395 -#: sql_help.c:3534 sql_help.c:3648 sql_help.c:3703 +#: sql_help.c:876 sql_help.c:2154 sql_help.c:3631 sql_help.c:3721 +#: sql_help.c:3870 sql_help.c:3999 sql_help.c:4064 msgid "start" msgstr "開始値" -#: sql_help.c:773 +#: sql_help.c:877 msgid "restart" msgstr "å†é–‹å§‹å€¤" -#: sql_help.c:774 sql_help.c:1952 +#: sql_help.c:878 sql_help.c:2155 msgid "cache" msgstr "キャッシュ" -#: sql_help.c:915 sql_help.c:2038 sql_help.c:2049 -msgid "table_constraint" -msgstr "テーブル制約" - -#: sql_help.c:916 +#: sql_help.c:1025 msgid "table_constraint_using_index" msgstr "インデックスを使用ã™ã‚‹ãƒ†ãƒ¼ãƒ–ル制約" -#: sql_help.c:924 sql_help.c:925 sql_help.c:926 sql_help.c:927 +#: sql_help.c:1033 sql_help.c:1034 sql_help.c:1035 sql_help.c:1036 msgid "rewrite_rule_name" msgstr "書ãæ›ãˆãƒ«ãƒ¼ãƒ«å" -#: sql_help.c:932 sql_help.c:933 sql_help.c:2041 -msgid "parent_table" -msgstr "親テーブル" - -#: sql_help.c:934 sql_help.c:2046 sql_help.c:2883 sql_help.c:3162 -msgid "type_name" -msgstr "åž‹å" - -#: sql_help.c:938 +#: sql_help.c:1047 msgid "and table_constraint_using_index is:" msgstr "ã¾ãŸã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’使用ã™ã‚‹ãƒ†ãƒ¼ãƒ–ルã®åˆ¶ç´„æ¡ä»¶ã¯ä»¥ä¸‹ã®é€šã‚Š:" -#: sql_help.c:956 sql_help.c:959 sql_help.c:2121 +#: sql_help.c:1065 sql_help.c:1068 sql_help.c:2324 msgid "tablespace_option" msgstr "テーブルスペース・オプション" -#: sql_help.c:980 sql_help.c:983 sql_help.c:989 sql_help.c:993 +#: sql_help.c:1089 sql_help.c:1092 sql_help.c:1098 sql_help.c:1102 msgid "token_type" msgstr "トークンã®åž‹" -#: sql_help.c:981 sql_help.c:984 +#: sql_help.c:1090 sql_help.c:1093 msgid "dictionary_name" msgstr "辞書å" -#: sql_help.c:986 sql_help.c:990 +#: sql_help.c:1095 sql_help.c:1099 msgid "old_dictionary" msgstr "å…ƒã®è¾žæ›¸" -#: sql_help.c:987 sql_help.c:991 +#: sql_help.c:1096 sql_help.c:1100 msgid "new_dictionary" msgstr "æ–°ã—ã„辞書" -#: sql_help.c:1078 sql_help.c:1088 sql_help.c:1091 sql_help.c:1092 -#: sql_help.c:2254 +#: sql_help.c:1191 sql_help.c:1201 sql_help.c:1204 sql_help.c:1205 +#: sql_help.c:2473 msgid "attribute_name" msgstr "属性å" -#: sql_help.c:1079 +#: sql_help.c:1192 msgid "new_attribute_name" msgstr "æ–°ã—ã„属性å" -#: sql_help.c:1085 +#: sql_help.c:1198 msgid "new_enum_value" msgstr "æ–°ã—ã„列挙値" -#: sql_help.c:1086 +#: sql_help.c:1199 msgid "existing_enum_value" msgstr "既存ã®åˆ—挙値" -#: sql_help.c:1148 sql_help.c:1668 sql_help.c:1964 sql_help.c:2332 -#: sql_help.c:2703 sql_help.c:2867 sql_help.c:3146 +#: sql_help.c:1269 sql_help.c:1841 sql_help.c:2167 sql_help.c:2551 +#: sql_help.c:2948 sql_help.c:3119 sql_help.c:3154 sql_help.c:3451 msgid "server_name" msgstr "サーãƒãƒ¼å" -#: sql_help.c:1176 sql_help.c:1179 sql_help.c:2347 +#: sql_help.c:1297 sql_help.c:1300 sql_help.c:2566 msgid "view_option_name" msgstr "ビューã®ã‚ªãƒ—ションå" -#: sql_help.c:1177 sql_help.c:2348 +#: sql_help.c:1298 sql_help.c:2567 msgid "view_option_value" msgstr "ビューã®ã‚ªãƒ—ション値" -#: sql_help.c:1202 sql_help.c:3453 sql_help.c:3455 sql_help.c:3479 +#: sql_help.c:1323 sql_help.c:3779 sql_help.c:3781 sql_help.c:3805 msgid "transaction_mode" msgstr "トランザクションã®ãƒ¢ãƒ¼ãƒ‰" -#: sql_help.c:1203 sql_help.c:3456 sql_help.c:3480 +#: sql_help.c:1324 sql_help.c:3782 sql_help.c:3806 msgid "where transaction_mode is one of:" msgstr "トランザクションã®ãƒ¢ãƒ¼ãƒ‰ã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:1283 +#: sql_help.c:1409 msgid "relation_name" msgstr "æ‹¡å¼µå" -#: sql_help.c:1310 +#: sql_help.c:1414 sql_help.c:3115 sql_help.c:3447 +msgid "domain_name" +msgstr "ドメインå" + +#: sql_help.c:1436 +#| msgid "role_name" +msgid "policy_name" +msgstr "ãƒãƒªã‚·ãƒ¼å" + +#: sql_help.c:1440 msgid "rule_name" msgstr "ロールå" -#: sql_help.c:1325 +#: sql_help.c:1457 msgid "text" msgstr "テキスト" -#: sql_help.c:1350 sql_help.c:2993 sql_help.c:3180 +#: sql_help.c:1482 sql_help.c:3297 sql_help.c:3485 msgid "transaction_id" msgstr "トランザクション ID" -#: sql_help.c:1381 sql_help.c:1387 sql_help.c:2919 +#: sql_help.c:1513 sql_help.c:1519 sql_help.c:3223 msgid "filename" msgstr "ファイルå" -#: sql_help.c:1382 sql_help.c:1388 sql_help.c:1915 sql_help.c:1916 -#: sql_help.c:1917 +#: sql_help.c:1514 sql_help.c:1520 sql_help.c:2110 sql_help.c:2111 +#: sql_help.c:2112 msgid "command" msgstr "コマンド" -#: sql_help.c:1386 sql_help.c:1802 sql_help.c:2107 sql_help.c:2349 -#: sql_help.c:2367 sql_help.c:2901 +#: sql_help.c:1518 sql_help.c:1981 sql_help.c:2310 sql_help.c:2568 +#: sql_help.c:2586 sql_help.c:3188 msgid "query" msgstr "å•ã„åˆã‚ã›" -#: sql_help.c:1390 sql_help.c:2748 +#: sql_help.c:1522 sql_help.c:2993 msgid "where option can be one of:" msgstr "オプションã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:1391 +#: sql_help.c:1523 msgid "format_name" msgstr "フォーマットå" -#: sql_help.c:1392 sql_help.c:1393 sql_help.c:1396 sql_help.c:2749 -#: sql_help.c:2750 sql_help.c:2751 sql_help.c:2752 sql_help.c:2753 +#: sql_help.c:1524 sql_help.c:1525 sql_help.c:1528 sql_help.c:2994 +#: sql_help.c:2995 sql_help.c:2996 sql_help.c:2997 sql_help.c:2998 msgid "boolean" msgstr "ブール値" -#: sql_help.c:1394 +#: sql_help.c:1526 msgid "delimiter_character" msgstr "区切り文字" -#: sql_help.c:1395 +#: sql_help.c:1527 msgid "null_string" msgstr "null文字列" -#: sql_help.c:1397 +#: sql_help.c:1529 msgid "quote_character" msgstr "引用符文字" -#: sql_help.c:1398 +#: sql_help.c:1530 msgid "escape_character" msgstr "エスケープ文字" -#: sql_help.c:1402 +#: sql_help.c:1534 msgid "encoding_name" msgstr "エンコーディングå" -#: sql_help.c:1459 sql_help.c:1475 sql_help.c:1478 +#: sql_help.c:1545 +msgid "access_method_type" +msgstr "アクセスメソッド型" + +#: sql_help.c:1611 sql_help.c:1630 sql_help.c:1633 msgid "arg_data_type" msgstr "入力データ型" -#: sql_help.c:1460 sql_help.c:1479 sql_help.c:1487 +#: sql_help.c:1612 sql_help.c:1634 sql_help.c:1642 msgid "sfunc" msgstr "状態é·ç§»é–¢æ•°" -#: sql_help.c:1461 sql_help.c:1480 sql_help.c:1488 +#: sql_help.c:1613 sql_help.c:1635 sql_help.c:1643 msgid "state_data_type" msgstr "状態データã®åž‹" -#: sql_help.c:1462 sql_help.c:1481 sql_help.c:1489 +#: sql_help.c:1614 sql_help.c:1636 sql_help.c:1644 msgid "state_data_size" msgstr "状態データã®å¤§ãã•" -#: sql_help.c:1463 sql_help.c:1482 sql_help.c:1490 +#: sql_help.c:1615 sql_help.c:1637 sql_help.c:1645 msgid "ffunc" msgstr "終了関数" -#: sql_help.c:1464 sql_help.c:1483 sql_help.c:1491 +#: sql_help.c:1616 sql_help.c:1646 +#| msgid "minvfunc" +msgid "combinefunc" +msgstr "çµåˆé–¢æ•°" + +#: sql_help.c:1617 sql_help.c:1647 +#| msgid "sfunc" +msgid "serialfunc" +msgstr "シリアライズ関数" + +#: sql_help.c:1618 sql_help.c:1648 +msgid "deserialfunc" +msgstr "デシリアライズ関数" + +#: sql_help.c:1619 sql_help.c:1638 sql_help.c:1649 msgid "initial_condition" msgstr "åˆæœŸæ¡ä»¶" -#: sql_help.c:1465 sql_help.c:1492 +#: sql_help.c:1620 sql_help.c:1650 msgid "msfunc" msgstr "å‰æ–¹çŠ¶æ…‹é·ç§»é–¢æ•°" -#: sql_help.c:1466 sql_help.c:1493 +#: sql_help.c:1621 sql_help.c:1651 msgid "minvfunc" msgstr "逆状態é·ç§»é–¢æ•°" -#: sql_help.c:1467 sql_help.c:1494 +#: sql_help.c:1622 sql_help.c:1652 msgid "mstate_data_type" msgstr "移動集約モードã§ã®çŠ¶æ…‹ãƒ‡ãƒ¼ã‚¿ã®åž‹" -#: sql_help.c:1468 sql_help.c:1495 +#: sql_help.c:1623 sql_help.c:1653 msgid "mstate_data_size" msgstr "移動集約モードã§ã®çŠ¶æ…‹ãƒ‡ãƒ¼ã‚¿ã®å¤§ãã•" -#: sql_help.c:1469 sql_help.c:1496 +#: sql_help.c:1624 sql_help.c:1654 msgid "mffunc" msgstr "移動集約モードã§ã®çµ‚了関数" -#: sql_help.c:1470 sql_help.c:1497 +#: sql_help.c:1625 sql_help.c:1655 msgid "minitial_condition" msgstr "移動集約モードã§ã®åˆæœŸæ¡ä»¶" -#: sql_help.c:1471 sql_help.c:1498 +#: sql_help.c:1626 sql_help.c:1656 msgid "sort_operator" msgstr "ソート演算å­" -#: sql_help.c:1484 +#: sql_help.c:1639 msgid "or the old syntax" msgstr "ã¾ãŸã¯å¤ã„構文" -#: sql_help.c:1486 +#: sql_help.c:1641 msgid "base_type" msgstr "基本ã®åž‹" -#: sql_help.c:1537 +#: sql_help.c:1695 msgid "locale" msgstr "ロケール" -#: sql_help.c:1538 sql_help.c:1572 +#: sql_help.c:1696 sql_help.c:1732 msgid "lc_collate" msgstr "ç…§åˆé †åº" -#: sql_help.c:1539 sql_help.c:1573 +#: sql_help.c:1697 sql_help.c:1733 msgid "lc_ctype" msgstr "Ctype(変æ›æ¼”ç®—å­)" -#: sql_help.c:1541 +#: sql_help.c:1699 msgid "existing_collation" msgstr "既存ã®ç…§åˆé †åº" -#: sql_help.c:1551 +#: sql_help.c:1709 msgid "source_encoding" msgstr "変æ›å…ƒã®ã‚¨ãƒ³ã‚³ãƒ¼ãƒ‡ã‚£ãƒ³ã‚°" -#: sql_help.c:1552 +#: sql_help.c:1710 msgid "dest_encoding" msgstr "変æ›å…ˆã®ã‚¨ãƒ³ã‚³ãƒ¼ãƒ‡ã‚£ãƒ³ã‚°" -#: sql_help.c:1570 sql_help.c:2147 +#: sql_help.c:1730 sql_help.c:2350 msgid "template" msgstr "テンプレート" -#: sql_help.c:1571 +#: sql_help.c:1731 msgid "encoding" msgstr "エンコーディング" -#: sql_help.c:1596 +#: sql_help.c:1757 +msgid "constraint" +msgstr "制約" + +#: sql_help.c:1758 msgid "where constraint is:" msgstr "制約æ¡ä»¶ï¼š" -#: sql_help.c:1610 sql_help.c:1912 sql_help.c:2203 +#: sql_help.c:1772 sql_help.c:2107 sql_help.c:2422 msgid "event" msgstr "イベント" -#: sql_help.c:1611 +#: sql_help.c:1773 msgid "filter_variable" msgstr "フィルタ変数" -#: sql_help.c:1623 -msgid "extension_name" -msgstr "æ‹¡å¼µå" - -#: sql_help.c:1625 +#: sql_help.c:1788 msgid "version" msgstr "ãƒãƒ¼ã‚¸ãƒ§ãƒ³" -#: sql_help.c:1626 +#: sql_help.c:1789 msgid "old_version" msgstr "å¤ã„ãƒãƒ¼ã‚¸ãƒ§ãƒ³" -#: sql_help.c:1671 sql_help.c:2053 +#: sql_help.c:1844 sql_help.c:2256 msgid "where column_constraint is:" msgstr "列制約：" -#: sql_help.c:1673 sql_help.c:1700 sql_help.c:2056 +#: sql_help.c:1847 sql_help.c:1879 sql_help.c:2259 msgid "default_expr" msgstr "デフォルトã®è©•ä¾¡å¼" -#: sql_help.c:1701 +#: sql_help.c:1848 sql_help.c:2266 +msgid "and table_constraint is:" +msgstr "テーブル制約:" + +#: sql_help.c:1880 msgid "rettype" msgstr "戻り値ã®åž‹" -#: sql_help.c:1703 +#: sql_help.c:1882 msgid "column_type" msgstr "列ã®åž‹" -#: sql_help.c:1704 sql_help.c:2401 sql_help.c:2875 sql_help.c:3154 -msgid "lang_name" -msgstr "言語" - -#: sql_help.c:1710 +#: sql_help.c:1890 msgid "definition" msgstr "定義" -#: sql_help.c:1711 +#: sql_help.c:1891 msgid "obj_file" msgstr "オブジェクトファイルå" -#: sql_help.c:1712 +#: sql_help.c:1892 msgid "link_symbol" msgstr "リンクシンボル" -#: sql_help.c:1713 +#: sql_help.c:1893 msgid "attribute" msgstr "属性" -#: sql_help.c:1748 sql_help.c:1897 sql_help.c:2321 +#: sql_help.c:1927 sql_help.c:2092 sql_help.c:2540 msgid "uid" msgstr "ユーザーID" -#: sql_help.c:1762 +#: sql_help.c:1941 msgid "method" msgstr "メソッド" -#: sql_help.c:1766 sql_help.c:2088 +#: sql_help.c:1945 sql_help.c:2291 sql_help.c:3197 msgid "opclass" msgstr "演算å­ã‚¯ãƒ©ã‚¹" -#: sql_help.c:1770 sql_help.c:2074 +#: sql_help.c:1949 sql_help.c:2277 msgid "predicate" msgstr "述語" -#: sql_help.c:1782 +#: sql_help.c:1961 msgid "call_handler" msgstr "呼ã³å‡ºã—ãƒãƒ³ãƒ‰ãƒ©ãƒ¼" -#: sql_help.c:1783 +#: sql_help.c:1962 msgid "inline_handler" msgstr "インラインãƒãƒ³ãƒ‰ãƒ©ãƒ¼" -#: sql_help.c:1784 +#: sql_help.c:1963 msgid "valfunction" msgstr "ãƒãƒªãƒ‡ãƒ¼ã‚¿é–¢æ•°" -#: sql_help.c:1820 +#: sql_help.c:1999 msgid "com_op" msgstr "交æ›ç”¨æ¼”ç®—å­" -#: sql_help.c:1821 +#: sql_help.c:2000 msgid "neg_op" msgstr "å¦å®šç”¨æ¼”ç®—å­" -#: sql_help.c:1822 -msgid "res_proc" -msgstr "制約手続ã" - -#: sql_help.c:1823 -msgid "join_proc" -msgstr "JOIN手続ã" - -#: sql_help.c:1839 +#: sql_help.c:2018 msgid "family_name" msgstr "ファミリーå" -#: sql_help.c:1850 +#: sql_help.c:2029 msgid "storage_type" msgstr "ストレージã®åž‹" -#: sql_help.c:1914 sql_help.c:2206 sql_help.c:2383 sql_help.c:3307 -#: sql_help.c:3309 sql_help.c:3386 sql_help.c:3388 sql_help.c:3525 -#: sql_help.c:3527 sql_help.c:3615 sql_help.c:3694 sql_help.c:3696 +#: sql_help.c:2109 sql_help.c:2425 sql_help.c:2602 sql_help.c:3207 +#: sql_help.c:3622 sql_help.c:3624 sql_help.c:3712 sql_help.c:3714 +#: sql_help.c:3861 sql_help.c:3863 sql_help.c:3966 sql_help.c:4055 +#: sql_help.c:4057 msgid "condition" msgstr "æ¡ä»¶" -#: sql_help.c:1918 sql_help.c:2209 +#: sql_help.c:2113 sql_help.c:2428 msgid "where event can be one of:" msgstr "イベントã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:1931 sql_help.c:1933 +#: sql_help.c:2132 sql_help.c:2134 msgid "schema_element" msgstr "スキーマè¦ç´ " -#: sql_help.c:1965 +#: sql_help.c:2168 msgid "server_type" msgstr "サーãƒãƒ¼ã®ã‚¿ã‚¤ãƒ—" -#: sql_help.c:1966 +#: sql_help.c:2169 msgid "server_version" msgstr "サーãƒãƒ¼ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³" -#: sql_help.c:1967 sql_help.c:2865 sql_help.c:3144 +#: sql_help.c:2170 sql_help.c:3117 sql_help.c:3449 msgid "fdw_name" msgstr "外部データラッパー" -#: sql_help.c:2039 +#: sql_help.c:2242 msgid "source_table" msgstr "ソースã®ãƒ†ãƒ¼ãƒ–ル" -#: sql_help.c:2040 +#: sql_help.c:2243 msgid "like_option" msgstr "LIKE オプション:" -#: sql_help.c:2057 sql_help.c:2058 sql_help.c:2067 sql_help.c:2069 -#: sql_help.c:2073 +#: sql_help.c:2260 sql_help.c:2261 sql_help.c:2270 sql_help.c:2272 +#: sql_help.c:2276 msgid "index_parameters" msgstr "インデックスã®ãƒ‘ラメーター" -#: sql_help.c:2059 sql_help.c:2076 +#: sql_help.c:2262 sql_help.c:2279 msgid "reftable" msgstr "å‚照テーブル" -#: sql_help.c:2060 sql_help.c:2077 +#: sql_help.c:2263 sql_help.c:2280 msgid "refcolumn" msgstr "å‚照列" -#: sql_help.c:2063 -msgid "and table_constraint is:" -msgstr "テーブル制約:" - -#: sql_help.c:2071 +#: sql_help.c:2274 msgid "exclude_element" msgstr "排他è¦ç´ " -#: sql_help.c:2072 sql_help.c:3314 sql_help.c:3393 sql_help.c:3532 -#: sql_help.c:3646 sql_help.c:3701 +#: sql_help.c:2275 sql_help.c:3629 sql_help.c:3719 sql_help.c:3868 +#: sql_help.c:3997 sql_help.c:4062 msgid "operator" msgstr "演算å­" -#: sql_help.c:2080 +#: sql_help.c:2283 msgid "and like_option is:" msgstr "LIKE オプション：" -#: sql_help.c:2081 +#: sql_help.c:2284 msgid "index_parameters in UNIQUE, PRIMARY KEY, and EXCLUDE constraints are:" msgstr "UNIQUE, PRIMARY KEY, EXCLUDE ã«ãŠã‘るインデックスパラメーターã®åˆ¶ç´„æ¡ä»¶ï¼š" -#: sql_help.c:2085 +#: sql_help.c:2288 msgid "exclude_element in an EXCLUDE constraint is:" msgstr "EXCLUDE ã«ãŠã‘る排他è¦ç´ ã®åˆ¶ç´„æ¡ä»¶ï¼š" -#: sql_help.c:2120 +#: sql_help.c:2323 msgid "directory" msgstr "ディレクトリー" -#: sql_help.c:2134 +#: sql_help.c:2337 msgid "parser_name" msgstr "パーサーå" -#: sql_help.c:2135 +#: sql_help.c:2338 msgid "source_config" msgstr "ソース設定" -#: sql_help.c:2164 +#: sql_help.c:2367 msgid "start_function" msgstr "開始関数" -#: sql_help.c:2165 +#: sql_help.c:2368 msgid "gettoken_function" msgstr "トークンå–得用関数" -#: sql_help.c:2166 +#: sql_help.c:2369 msgid "end_function" msgstr "終了関数" -#: sql_help.c:2167 +#: sql_help.c:2370 msgid "lextypes_function" msgstr "LEX åž‹ã®é–¢æ•°" -#: sql_help.c:2168 +#: sql_help.c:2371 msgid "headline_function" msgstr "見出ã—関数" -#: sql_help.c:2180 +#: sql_help.c:2383 msgid "init_function" msgstr "åˆæœŸå‡¦ç†é–¢æ•°" -#: sql_help.c:2181 +#: sql_help.c:2384 msgid "lexize_function" msgstr "LEX 処ç†é–¢æ•°" -#: sql_help.c:2205 +#: sql_help.c:2397 +#| msgid "function_name" +msgid "from_sql_function_name" +msgstr "SQLã®åž‹ã‹ã‚‰å¤‰æ›ã™ã‚‹é–¢æ•°å" + +#: sql_help.c:2399 +#| msgid "function_name" +msgid "to_sql_function_name" +msgstr "SQLã®åž‹ã¸å¤‰æ›ã™ã‚‹é–¢æ•°å" + +#: sql_help.c:2424 msgid "referenced_table_name" msgstr "éžå‚照テーブルå" -#: sql_help.c:2208 +#: sql_help.c:2427 msgid "arguments" msgstr "引数" -#: sql_help.c:2258 sql_help.c:3252 +#: sql_help.c:2477 sql_help.c:3557 msgid "label" msgstr "ラベル" -#: sql_help.c:2260 +#: sql_help.c:2479 msgid "subtype" msgstr "派生元型" -#: sql_help.c:2261 +#: sql_help.c:2480 msgid "subtype_operator_class" msgstr "派生元型ã®æ¼”ç®—å­ã‚¯ãƒ©ã‚¹" -#: sql_help.c:2263 +#: sql_help.c:2482 msgid "canonical_function" msgstr "æ­£è¦åŒ–関数" -#: sql_help.c:2264 +#: sql_help.c:2483 msgid "subtype_diff_function" msgstr "派生元型差異関数" -#: sql_help.c:2266 +#: sql_help.c:2485 msgid "input_function" msgstr "入力関数" -#: sql_help.c:2267 +#: sql_help.c:2486 msgid "output_function" msgstr "出力関数" -#: sql_help.c:2268 +#: sql_help.c:2487 msgid "receive_function" msgstr "å—信関数" -#: sql_help.c:2269 +#: sql_help.c:2488 msgid "send_function" msgstr "é€ä¿¡é–¢æ•°" -#: sql_help.c:2270 +#: sql_help.c:2489 msgid "type_modifier_input_function" msgstr "型修飾å­ã®å…¥åŠ›é–¢æ•°" -#: sql_help.c:2271 +#: sql_help.c:2490 msgid "type_modifier_output_function" msgstr "型修飾å­ã®å‡ºåŠ›é–¢æ•°" -#: sql_help.c:2272 +#: sql_help.c:2491 msgid "analyze_function" msgstr "分æžé–¢æ•°" -#: sql_help.c:2273 +#: sql_help.c:2492 msgid "internallength" msgstr "内部長" -#: sql_help.c:2274 +#: sql_help.c:2493 msgid "alignment" msgstr "アラインメント" -#: sql_help.c:2275 +#: sql_help.c:2494 msgid "storage" msgstr "ストレージ" -#: sql_help.c:2276 +#: sql_help.c:2495 msgid "like_type" msgstr "LIKEã®åž‹" -#: sql_help.c:2277 +#: sql_help.c:2496 msgid "category" msgstr "カテゴリー" -#: sql_help.c:2278 +#: sql_help.c:2497 msgid "preferred" msgstr "推奨" -#: sql_help.c:2279 +#: sql_help.c:2498 msgid "default" msgstr "デフォルト" -#: sql_help.c:2280 +#: sql_help.c:2499 msgid "element" msgstr "è¦ç´ " -#: sql_help.c:2281 +#: sql_help.c:2500 msgid "delimiter" msgstr "デリミタ" -#: sql_help.c:2282 +#: sql_help.c:2501 msgid "collatable" msgstr "ç…§åˆé †åº" -#: sql_help.c:2379 sql_help.c:2897 sql_help.c:3302 sql_help.c:3380 -#: sql_help.c:3520 sql_help.c:3607 sql_help.c:3689 +#: sql_help.c:2598 sql_help.c:3183 sql_help.c:3617 sql_help.c:3706 +#: sql_help.c:3856 sql_help.c:3956 sql_help.c:4050 msgid "with_query" msgstr "WITHå•ã„åˆã‚ã›" -#: sql_help.c:2381 sql_help.c:3321 sql_help.c:3324 sql_help.c:3327 -#: sql_help.c:3331 sql_help.c:3335 sql_help.c:3343 sql_help.c:3539 -#: sql_help.c:3542 sql_help.c:3545 sql_help.c:3549 sql_help.c:3553 -#: sql_help.c:3561 sql_help.c:3609 sql_help.c:3708 sql_help.c:3711 -#: sql_help.c:3714 sql_help.c:3718 sql_help.c:3722 sql_help.c:3730 +#: sql_help.c:2600 sql_help.c:3185 sql_help.c:3636 sql_help.c:3642 +#: sql_help.c:3645 sql_help.c:3649 sql_help.c:3653 sql_help.c:3661 +#: sql_help.c:3875 sql_help.c:3881 sql_help.c:3884 sql_help.c:3888 +#: sql_help.c:3892 sql_help.c:3900 sql_help.c:3958 sql_help.c:4069 +#: sql_help.c:4075 sql_help.c:4078 sql_help.c:4082 sql_help.c:4086 +#: sql_help.c:4094 msgid "alias" msgstr "別å" -#: sql_help.c:2382 +#: sql_help.c:2601 msgid "using_list" msgstr "USING リスト" -#: sql_help.c:2384 sql_help.c:2779 sql_help.c:2960 sql_help.c:3616 +#: sql_help.c:2603 sql_help.c:3024 sql_help.c:3264 sql_help.c:3967 msgid "cursor_name" msgstr "カーソルå" -#: sql_help.c:2385 sql_help.c:2902 sql_help.c:3617 +#: sql_help.c:2604 sql_help.c:3191 sql_help.c:3968 msgid "output_expression" msgstr "出力表ç¾" -#: sql_help.c:2386 sql_help.c:2903 sql_help.c:3305 sql_help.c:3383 -#: sql_help.c:3523 sql_help.c:3618 sql_help.c:3692 +#: sql_help.c:2605 sql_help.c:3192 sql_help.c:3620 sql_help.c:3709 +#: sql_help.c:3859 sql_help.c:3969 sql_help.c:4053 msgid "output_name" msgstr "出力å" -#: sql_help.c:2402 +#: sql_help.c:2621 msgid "code" msgstr "コード" -#: sql_help.c:2727 +#: sql_help.c:2972 msgid "parameter" msgstr "パラメータ" -#: sql_help.c:2746 sql_help.c:2747 sql_help.c:2985 +#: sql_help.c:2991 sql_help.c:2992 sql_help.c:3289 msgid "statement" msgstr "ステートメント" -#: sql_help.c:2778 sql_help.c:2959 +#: sql_help.c:3023 sql_help.c:3263 msgid "direction" msgstr "æ–¹å‘" -#: sql_help.c:2780 sql_help.c:2961 +#: sql_help.c:3025 sql_help.c:3265 msgid "where direction can be empty or one of:" msgstr "æ–¹å‘ã¯ç„¡æŒ‡å®šã‚‚ã—ãã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:2781 sql_help.c:2782 sql_help.c:2783 sql_help.c:2784 -#: sql_help.c:2785 sql_help.c:2962 sql_help.c:2963 sql_help.c:2964 -#: sql_help.c:2965 sql_help.c:2966 sql_help.c:3315 sql_help.c:3317 -#: sql_help.c:3394 sql_help.c:3396 sql_help.c:3533 sql_help.c:3535 -#: sql_help.c:3647 sql_help.c:3649 sql_help.c:3702 sql_help.c:3704 +#: sql_help.c:3026 sql_help.c:3027 sql_help.c:3028 sql_help.c:3029 +#: sql_help.c:3030 sql_help.c:3266 sql_help.c:3267 sql_help.c:3268 +#: sql_help.c:3269 sql_help.c:3270 sql_help.c:3630 sql_help.c:3632 +#: sql_help.c:3720 sql_help.c:3722 sql_help.c:3869 sql_help.c:3871 +#: sql_help.c:3998 sql_help.c:4000 sql_help.c:4063 sql_help.c:4065 msgid "count" msgstr "カウント" -#: sql_help.c:2858 sql_help.c:3137 +#: sql_help.c:3110 sql_help.c:3442 msgid "sequence_name" msgstr "シーケンスå" -#: sql_help.c:2863 sql_help.c:3142 -msgid "domain_name" -msgstr "ドメインå" - -#: sql_help.c:2871 sql_help.c:3150 +#: sql_help.c:3123 sql_help.c:3455 msgid "arg_name" msgstr "引数å" -#: sql_help.c:2872 sql_help.c:3151 +#: sql_help.c:3124 sql_help.c:3456 msgid "arg_type" msgstr "引数ã®åž‹" -#: sql_help.c:2877 sql_help.c:3156 +#: sql_help.c:3129 sql_help.c:3461 msgid "loid" msgstr "ラージオブジェクトid" -#: sql_help.c:2911 sql_help.c:2974 sql_help.c:3593 +#: sql_help.c:3152 +#| msgid "remove a schema" +msgid "remote_schema" +msgstr "リモートスキーマ" + +#: sql_help.c:3155 +#| msgid "local socket" +msgid "local_schema" +msgstr "ローカルスキーマ" + +#: sql_help.c:3189 +msgid "conflict_target" +msgstr "競åˆå¯¾è±¡" + +#: sql_help.c:3190 +#| msgid "canonical_function" +msgid "conflict_action" +msgstr "競åˆæ™‚ã®å‹•ä½œ" + +#: sql_help.c:3193 +#| msgid "where from_item can be one of:" +msgid "where conflict_target can be one of:" +msgstr "競åˆå¯¾è±¡ã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹:" + +#: sql_help.c:3194 +#| msgid "new_column_name" +msgid "index_column_name" +msgstr "インデックスã®åˆ—å" + +#: sql_help.c:3195 +#| msgid "expression" +msgid "index_expression" +msgstr "インデックスã®è©•ä¾¡å¼" + +#: sql_help.c:3198 +#| msgid "predicate" +msgid "index_predicate" +msgstr "インデックスã®è¿°èªž" + +#: sql_help.c:3200 +#| msgid "where action is one of:" +msgid "and conflict_action is one of:" +msgstr "競åˆæ™‚ã®å‹•ä½œã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹:" + +#: sql_help.c:3206 sql_help.c:3964 +msgid "sub-SELECT" +msgstr "副å•ã„åˆã‚ã›" + +#: sql_help.c:3215 sql_help.c:3278 sql_help.c:3940 msgid "channel" msgstr "ãƒãƒ£ãƒãƒ«" -#: sql_help.c:2933 +#: sql_help.c:3237 msgid "lockmode" msgstr "ロックモード" -#: sql_help.c:2934 +#: sql_help.c:3238 msgid "where lockmode is one of:" msgstr "ロックモードã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:2975 +#: sql_help.c:3279 msgid "payload" msgstr "ペイロード" -#: sql_help.c:3001 +#: sql_help.c:3306 msgid "old_role" msgstr "å…ƒã®ãƒ­ãƒ¼ãƒ«" -#: sql_help.c:3002 +#: sql_help.c:3307 msgid "new_role" msgstr "æ–°ã—ã„ロール" -#: sql_help.c:3027 sql_help.c:3188 sql_help.c:3196 +#: sql_help.c:3332 sql_help.c:3493 sql_help.c:3501 msgid "savepoint_name" msgstr "セーブãƒã‚¤ãƒ³ãƒˆå" -#: sql_help.c:3229 +#: sql_help.c:3534 msgid "provider" msgstr "プロãƒã‚¤ãƒ€" -#: sql_help.c:3306 sql_help.c:3345 sql_help.c:3347 sql_help.c:3385 -#: sql_help.c:3524 sql_help.c:3563 sql_help.c:3565 sql_help.c:3693 -#: sql_help.c:3732 sql_help.c:3734 +#: sql_help.c:3621 sql_help.c:3663 sql_help.c:3665 sql_help.c:3711 +#: sql_help.c:3860 sql_help.c:3902 sql_help.c:3904 sql_help.c:4054 +#: sql_help.c:4096 sql_help.c:4098 msgid "from_item" msgstr "FROM é …ç›®" -#: sql_help.c:3310 sql_help.c:3389 sql_help.c:3528 sql_help.c:3697 +#: sql_help.c:3623 sql_help.c:3675 sql_help.c:3862 sql_help.c:3914 +#: sql_help.c:4056 sql_help.c:4108 +#| msgid "wrong element type" +msgid "grouping_element" +msgstr "グループ化ã®è¦ç´ " + +#: sql_help.c:3625 sql_help.c:3715 sql_help.c:3864 sql_help.c:4058 msgid "window_name" msgstr "ウィンドウå" -#: sql_help.c:3311 sql_help.c:3390 sql_help.c:3529 sql_help.c:3698 +#: sql_help.c:3626 sql_help.c:3716 sql_help.c:3865 sql_help.c:4059 msgid "window_definition" msgstr "ウィンドウ定義" -#: sql_help.c:3312 sql_help.c:3323 sql_help.c:3353 sql_help.c:3391 -#: sql_help.c:3530 sql_help.c:3541 sql_help.c:3571 sql_help.c:3699 -#: sql_help.c:3710 sql_help.c:3740 +#: sql_help.c:3627 sql_help.c:3641 sql_help.c:3679 sql_help.c:3717 +#: sql_help.c:3866 sql_help.c:3880 sql_help.c:3918 sql_help.c:4060 +#: sql_help.c:4074 sql_help.c:4112 msgid "select" msgstr "SELECTå¥" -#: sql_help.c:3319 sql_help.c:3537 sql_help.c:3706 +#: sql_help.c:3634 sql_help.c:3873 sql_help.c:4067 msgid "where from_item can be one of:" msgstr "FROMé …ç›®ã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹ï¼š" -#: sql_help.c:3322 sql_help.c:3325 sql_help.c:3328 sql_help.c:3332 -#: sql_help.c:3344 sql_help.c:3540 sql_help.c:3543 sql_help.c:3546 -#: sql_help.c:3550 sql_help.c:3562 sql_help.c:3709 sql_help.c:3712 -#: sql_help.c:3715 sql_help.c:3719 sql_help.c:3731 +#: sql_help.c:3637 sql_help.c:3643 sql_help.c:3646 sql_help.c:3650 +#: sql_help.c:3662 sql_help.c:3876 sql_help.c:3882 sql_help.c:3885 +#: sql_help.c:3889 sql_help.c:3901 sql_help.c:4070 sql_help.c:4076 +#: sql_help.c:4079 sql_help.c:4083 sql_help.c:4095 msgid "column_alias" msgstr "列ã®åˆ¥å" -#: sql_help.c:3326 sql_help.c:3351 sql_help.c:3544 sql_help.c:3569 -#: sql_help.c:3713 sql_help.c:3738 -msgid "with_query_name" -msgstr "WITHå•ã„åˆã‚ã›å" +#: sql_help.c:3638 sql_help.c:3877 sql_help.c:4071 +#| msgid "index_method" +msgid "sampling_method" +msgstr "サンプリングメソッド" -#: sql_help.c:3330 sql_help.c:3334 sql_help.c:3338 sql_help.c:3341 -#: sql_help.c:3548 sql_help.c:3552 sql_help.c:3556 sql_help.c:3559 -#: sql_help.c:3717 sql_help.c:3721 sql_help.c:3725 sql_help.c:3728 +#: sql_help.c:3639 sql_help.c:3648 sql_help.c:3652 sql_help.c:3656 +#: sql_help.c:3659 sql_help.c:3878 sql_help.c:3887 sql_help.c:3891 +#: sql_help.c:3895 sql_help.c:3898 sql_help.c:4072 sql_help.c:4081 +#: sql_help.c:4085 sql_help.c:4089 sql_help.c:4092 msgid "argument" msgstr "引数" -#: sql_help.c:3336 sql_help.c:3339 sql_help.c:3342 sql_help.c:3554 -#: sql_help.c:3557 sql_help.c:3560 sql_help.c:3723 sql_help.c:3726 -#: sql_help.c:3729 +#: sql_help.c:3640 sql_help.c:3879 sql_help.c:4073 +msgid "seed" +msgstr "シード" + +#: sql_help.c:3644 sql_help.c:3677 sql_help.c:3883 sql_help.c:3916 +#: sql_help.c:4077 sql_help.c:4110 +msgid "with_query_name" +msgstr "WITHå•ã„åˆã‚ã›å" + +#: sql_help.c:3654 sql_help.c:3657 sql_help.c:3660 sql_help.c:3893 +#: sql_help.c:3896 sql_help.c:3899 sql_help.c:4087 sql_help.c:4090 +#: sql_help.c:4093 msgid "column_definition" msgstr "列定義" -#: sql_help.c:3346 sql_help.c:3564 sql_help.c:3733 +#: sql_help.c:3664 sql_help.c:3903 sql_help.c:4097 msgid "join_type" msgstr "çµåˆç¨®é¡ž" -#: sql_help.c:3348 sql_help.c:3566 sql_help.c:3735 +#: sql_help.c:3666 sql_help.c:3905 sql_help.c:4099 msgid "join_condition" msgstr "çµåˆæ¡ä»¶" -#: sql_help.c:3349 sql_help.c:3567 sql_help.c:3736 +#: sql_help.c:3667 sql_help.c:3906 sql_help.c:4100 msgid "join_column" msgstr "çµåˆåˆ—" -#: sql_help.c:3350 sql_help.c:3568 sql_help.c:3737 +#: sql_help.c:3668 sql_help.c:3907 sql_help.c:4101 +#| msgid "where event can be one of:" +msgid "and grouping_element can be one of:" +msgstr "グループ化ã®è¦ç´ ã¯ä»¥ä¸‹ã®ã„ãšã‚Œã‹:" + +#: sql_help.c:3676 sql_help.c:3915 sql_help.c:4109 msgid "and with_query is:" msgstr "WITHå•ã„åˆã‚ã›ï¼š" -#: sql_help.c:3354 sql_help.c:3572 sql_help.c:3741 +#: sql_help.c:3680 sql_help.c:3919 sql_help.c:4113 msgid "values" msgstr "VALUESå¥" -#: sql_help.c:3355 sql_help.c:3573 sql_help.c:3742 +#: sql_help.c:3681 sql_help.c:3920 sql_help.c:4114 msgid "insert" msgstr "INSERTå¥" -#: sql_help.c:3356 sql_help.c:3574 sql_help.c:3743 +#: sql_help.c:3682 sql_help.c:3921 sql_help.c:4115 msgid "update" msgstr "UPDATEå¥" -#: sql_help.c:3357 sql_help.c:3575 sql_help.c:3744 +#: sql_help.c:3683 sql_help.c:3922 sql_help.c:4116 msgid "delete" msgstr "DELETEå¥" -#: sql_help.c:3384 +#: sql_help.c:3710 msgid "new_table" msgstr "æ–°ã—ã„テーブル" -#: sql_help.c:3409 +#: sql_help.c:3735 msgid "timezone" msgstr "タイムゾーン" -#: sql_help.c:3454 +#: sql_help.c:3780 msgid "snapshot_id" msgstr "スナップショットID" -#: sql_help.c:3614 +#: sql_help.c:3965 msgid "from_list" msgstr "FROM リスト" -#: sql_help.c:3645 +#: sql_help.c:3996 msgid "sort_expression" msgstr "ソート表ç¾" -#: sql_help.h:191 sql_help.h:891 +#: sql_help.c:4123 sql_help.c:4863 msgid "abort the current transaction" msgstr "ç¾åœ¨ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’中断ã™ã‚‹" -#: sql_help.h:196 +#: sql_help.c:4128 msgid "change the definition of an aggregate function" msgstr "集約関数ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:201 +#: sql_help.c:4133 msgid "change the definition of a collation" msgstr "ç…§åˆé †åºã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:206 +#: sql_help.c:4138 msgid "change the definition of a conversion" msgstr "エンコーディング変æ›ãƒ«ãƒ¼ãƒ«ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:211 +#: sql_help.c:4143 msgid "change a database" msgstr "データベースを変更ã™ã‚‹" -#: sql_help.h:216 +#: sql_help.c:4148 msgid "define default access privileges" msgstr "デフォルトã®ã‚¢ã‚¯ã‚»ã‚¹æ¨©é™ã‚’定義ã™ã‚‹" -#: sql_help.h:221 +#: sql_help.c:4153 msgid "change the definition of a domain" msgstr "ドメインã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:226 +#: sql_help.c:4158 msgid "change the definition of an event trigger" msgstr "イベントトリガã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:231 +#: sql_help.c:4163 msgid "change the definition of an extension" msgstr "æ‹¡å¼µã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:236 +#: sql_help.c:4168 msgid "change the definition of a foreign-data wrapper" msgstr "外部データラッパーã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:241 +#: sql_help.c:4173 msgid "change the definition of a foreign table" msgstr "外部テーブルã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:246 +#: sql_help.c:4178 msgid "change the definition of a function" msgstr "関数ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:251 +#: sql_help.c:4183 msgid "change role name or membership" msgstr "ロールã®åå‰ã¾ãŸã¯ãƒ¡ãƒ³ãƒãƒ¼ã‚·ãƒƒãƒ—を変更ã™ã‚‹" -#: sql_help.h:256 +#: sql_help.c:4188 msgid "change the definition of an index" msgstr "インデックスã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:261 +#: sql_help.c:4193 msgid "change the definition of a procedural language" msgstr "手続ã言語ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:266 +#: sql_help.c:4198 msgid "change the definition of a large object" msgstr "ラージオブジェクトã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:271 +#: sql_help.c:4203 msgid "change the definition of a materialized view" msgstr "マテリアライズドビューã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:276 +#: sql_help.c:4208 msgid "change the definition of an operator" msgstr "演算å­ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:281 +#: sql_help.c:4213 msgid "change the definition of an operator class" msgstr "演算å­ã‚¯ãƒ©ã‚¹ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:286 +#: sql_help.c:4218 msgid "change the definition of an operator family" msgstr "演算å­ãƒ•ã‚¡ãƒŸãƒªã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:291 sql_help.h:361 +#: sql_help.c:4223 +#| msgid "change the definition of a conversion" +msgid "change the definition of a row level security policy" +msgstr "行レベルセキュリティãƒãƒªã‚·ãƒ¼ã®å®šç¾©ã‚’変更ã™ã‚‹" + +#: sql_help.c:4228 sql_help.c:4298 msgid "change a database role" msgstr "データベースã®ãƒ­ãƒ¼ãƒ«ã‚’変更ã™ã‚‹" -#: sql_help.h:296 +#: sql_help.c:4233 msgid "change the definition of a rule" msgstr "ルールã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:301 +#: sql_help.c:4238 msgid "change the definition of a schema" msgstr "スキーマã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:306 +#: sql_help.c:4243 msgid "change the definition of a sequence generator" msgstr "シーケンスジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:311 +#: sql_help.c:4248 msgid "change the definition of a foreign server" msgstr "外部サーãƒãƒ¼ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:316 +#: sql_help.c:4253 msgid "change a server configuration parameter" msgstr "サーãƒè¨­å®šãƒ‘ラメータを変更ã™ã‚‹" -#: sql_help.h:321 +#: sql_help.c:4258 msgid "change the definition of a table" msgstr "テーブルã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:326 +#: sql_help.c:4263 msgid "change the definition of a tablespace" msgstr "テーブルスペースã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:331 +#: sql_help.c:4268 msgid "change the definition of a text search configuration" msgstr "テキスト検索設定ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:336 +#: sql_help.c:4273 msgid "change the definition of a text search dictionary" msgstr "テキスト検索辞書ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:341 +#: sql_help.c:4278 msgid "change the definition of a text search parser" msgstr "テキスト検索パーサã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:346 +#: sql_help.c:4283 msgid "change the definition of a text search template" msgstr "テキスト検索テンプレートã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:351 +#: sql_help.c:4288 msgid "change the definition of a trigger" msgstr "トリガã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:356 +#: sql_help.c:4293 msgid "change the definition of a type" msgstr "åž‹ã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:366 +#: sql_help.c:4303 msgid "change the definition of a user mapping" msgstr "ユーザマッピングã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:371 +#: sql_help.c:4308 msgid "change the definition of a view" msgstr "ビューã®å®šç¾©ã‚’変更ã™ã‚‹" -#: sql_help.h:376 +#: sql_help.c:4313 msgid "collect statistics about a database" msgstr "データベースã®çµ±è¨ˆæƒ…報をåŽé›†ã™ã‚‹" -#: sql_help.h:381 sql_help.h:956 +#: sql_help.c:4318 sql_help.c:4928 msgid "start a transaction block" msgstr "トランザクションブロックを開始ã™ã‚‹" -#: sql_help.h:386 +#: sql_help.c:4323 msgid "force a transaction log checkpoint" msgstr "トランザクションログã®ãƒã‚§ãƒƒã‚¯ãƒã‚¤ãƒ³ãƒˆã‚’強制設定ã™ã‚‹" -#: sql_help.h:391 +#: sql_help.c:4328 msgid "close a cursor" msgstr "カーソルを閉ã˜ã‚‹" -#: sql_help.h:396 +#: sql_help.c:4333 msgid "cluster a table according to an index" msgstr "インデックスã«å¾“ã£ã¦ãƒ†ãƒ¼ãƒ–ルをクラスタ化ã™ã‚‹" -#: sql_help.h:401 +#: sql_help.c:4338 msgid "define or change the comment of an object" msgstr "オブジェクトã®ã‚³ãƒ¡ãƒ³ãƒˆã‚’定義ã¾ãŸã¯å¤‰æ›´ã™ã‚‹" -#: sql_help.h:406 sql_help.h:796 +#: sql_help.c:4343 sql_help.c:4763 msgid "commit the current transaction" msgstr "ç¾åœ¨ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’コミットã™ã‚‹" -#: sql_help.h:411 +#: sql_help.c:4348 msgid "commit a transaction that was earlier prepared for two-phase commit" msgstr "２フェーズコミットã®ãŸã‚ã«äº‹å‰ã«æº–å‚™ã•ã‚ŒãŸãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’コミットã™ã‚‹" -#: sql_help.h:416 +#: sql_help.c:4353 msgid "copy data between a file and a table" msgstr "ファイルã¨ãƒ†ãƒ¼ãƒ–ル間ã§ãƒ‡ãƒ¼ã‚¿ã‚’コピーã™ã‚‹" -#: sql_help.h:421 +#: sql_help.c:4358 +#| msgid "define a new cast" +msgid "define a new access method" +msgstr "æ–°ã—ã„アクセスメソッドを定義ã™ã‚‹" + +#: sql_help.c:4363 msgid "define a new aggregate function" msgstr "æ–°ã—ã„集約関数を定義ã™ã‚‹" -#: sql_help.h:426 +#: sql_help.c:4368 msgid "define a new cast" msgstr "æ–°ã—ã„キャストを定義ã™ã‚‹" -#: sql_help.h:431 +#: sql_help.c:4373 msgid "define a new collation" msgstr "æ–°ã—ã„ç…§åˆé †åºã‚’定義ã™ã‚‹" -#: sql_help.h:436 +#: sql_help.c:4378 msgid "define a new encoding conversion" msgstr "æ–°ã—ã„エンコーディングã®å¤‰æ›ãƒ«ãƒ¼ãƒ«ã‚’定義ã™ã‚‹" -#: sql_help.h:441 +#: sql_help.c:4383 msgid "create a new database" msgstr "æ–°ã—ã„データベースを作æˆã™ã‚‹" -#: sql_help.h:446 +#: sql_help.c:4388 msgid "define a new domain" msgstr "æ–°ã—ã„ドメインを定義ã™ã‚‹" -#: sql_help.h:451 +#: sql_help.c:4393 msgid "define a new event trigger" msgstr "æ–°ã—ã„イベントトリガを定義ã™ã‚‹" -#: sql_help.h:456 +#: sql_help.c:4398 msgid "install an extension" msgstr "拡張をインストールã™ã‚‹" -#: sql_help.h:461 +#: sql_help.c:4403 msgid "define a new foreign-data wrapper" msgstr "æ–°ã—ã„外部データラッパーを定義ã™ã‚‹" -#: sql_help.h:466 +#: sql_help.c:4408 msgid "define a new foreign table" msgstr "æ–°ã—ã„外部テーブルを定義ã™ã‚‹" -#: sql_help.h:471 +#: sql_help.c:4413 msgid "define a new function" msgstr "æ–°ã—ã„関数を定義ã™ã‚‹" -#: sql_help.h:476 sql_help.h:511 sql_help.h:581 +#: sql_help.c:4418 sql_help.c:4458 sql_help.c:4533 msgid "define a new database role" msgstr "データベースã®æ–°ã—ã„ロールを定義ã™ã‚‹" -#: sql_help.h:481 +#: sql_help.c:4423 msgid "define a new index" msgstr "æ–°ã—ã„インデックスを定義ã™ã‚‹" -#: sql_help.h:486 +#: sql_help.c:4428 msgid "define a new procedural language" msgstr "æ–°ã—ã„手続ã言語を定義ã™ã‚‹" -#: sql_help.h:491 +#: sql_help.c:4433 msgid "define a new materialized view" msgstr "æ–°ã—ã„マテリアライズドビューを定義ã™ã‚‹" -#: sql_help.h:496 +#: sql_help.c:4438 msgid "define a new operator" msgstr "æ–°ã—ã„演算å­ã‚’定義ã™ã‚‹" -#: sql_help.h:501 +#: sql_help.c:4443 msgid "define a new operator class" msgstr "æ–°ã—ã„演算å­ã‚¯ãƒ©ã‚¹ã‚’定義ã™ã‚‹" -#: sql_help.h:506 +#: sql_help.c:4448 msgid "define a new operator family" msgstr "æ–°ã—ã„演算å­ãƒ•ã‚¡ãƒŸãƒªã‚’定義ã™ã‚‹" -#: sql_help.h:516 +#: sql_help.c:4453 +msgid "define a new row level security policy for a table" +msgstr "テーブルã«æ–°ã—ã„行レベルセキュリティãƒãƒªã‚·ãƒ¼ã‚’定義ã™ã‚‹" + +#: sql_help.c:4463 msgid "define a new rewrite rule" msgstr "æ–°ã—ã„書ãæ›ãˆãƒ«ãƒ¼ãƒ«ã‚’定義ã™ã‚‹" -#: sql_help.h:521 +#: sql_help.c:4468 msgid "define a new schema" msgstr "æ–°ã—ã„スキーマを定義ã™ã‚‹" -#: sql_help.h:526 +#: sql_help.c:4473 msgid "define a new sequence generator" msgstr "æ–°ã—ã„シーケンスジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã‚’定義ã™ã‚‹" -#: sql_help.h:531 +#: sql_help.c:4478 msgid "define a new foreign server" msgstr "æ–°ã—ã„外部サーãƒãƒ¼ã‚’定義ã™ã‚‹" -#: sql_help.h:536 +#: sql_help.c:4483 msgid "define a new table" msgstr "æ–°ã—ã„テーブルを定義ã™ã‚‹" -#: sql_help.h:541 sql_help.h:921 +#: sql_help.c:4488 sql_help.c:4893 msgid "define a new table from the results of a query" msgstr "å•ã„åˆã‚ã›çµæžœã‹ã‚‰æ–°ã—ã„テーブルを生æˆã™ã‚‹" -#: sql_help.h:546 +#: sql_help.c:4493 msgid "define a new tablespace" msgstr "æ–°ã—ã„テーブルスペースを定義ã™ã‚‹" -#: sql_help.h:551 +#: sql_help.c:4498 msgid "define a new text search configuration" msgstr "æ–°ã—ã„テキスト検索設定を定義ã™ã‚‹" -#: sql_help.h:556 +#: sql_help.c:4503 msgid "define a new text search dictionary" msgstr "æ–°ã—ã„テキスト検索用辞書を定義ã™ã‚‹" -#: sql_help.h:561 +#: sql_help.c:4508 msgid "define a new text search parser" msgstr "æ–°ã—ã„テキスト検索用パーサを定義ã™ã‚‹" -#: sql_help.h:566 +#: sql_help.c:4513 msgid "define a new text search template" msgstr "æ–°ã—ã„テキスト検索テンプレートを定義ã™ã‚‹" -#: sql_help.h:571 +#: sql_help.c:4518 +#| msgid "define a new operator" +msgid "define a new transform" +msgstr "æ–°ã—ã„変æ›ã‚’定義ã™ã‚‹" + +#: sql_help.c:4523 msgid "define a new trigger" msgstr "æ–°ã—ã„トリガを定義ã™ã‚‹" -#: sql_help.h:576 +#: sql_help.c:4528 msgid "define a new data type" msgstr "æ–°ã—ã„データ型を定義ã™ã‚‹" -#: sql_help.h:586 +#: sql_help.c:4538 msgid "define a new mapping of a user to a foreign server" msgstr "外部サーãƒãƒ¼ã«å¯¾ã—ã¦ãƒ¦ãƒ¼ã‚¶ã®æ–°ã—ã„マッピングを定義ã™ã‚‹" -#: sql_help.h:591 +#: sql_help.c:4543 msgid "define a new view" msgstr "æ–°ã—ã„ビューを定義ã™ã‚‹" -#: sql_help.h:596 +#: sql_help.c:4548 msgid "deallocate a prepared statement" msgstr "プリペアドステートメントを開放ã™ã‚‹" -#: sql_help.h:601 +#: sql_help.c:4553 msgid "define a cursor" msgstr "カーソルを定義ã™ã‚‹" -#: sql_help.h:606 +#: sql_help.c:4558 msgid "delete rows of a table" msgstr "テーブルã®è¡Œã‚’削除ã™ã‚‹" -#: sql_help.h:611 +#: sql_help.c:4563 msgid "discard session state" msgstr "セッションã®çŠ¶æ…‹ã‚’破棄ã™ã‚‹" -#: sql_help.h:616 +#: sql_help.c:4568 msgid "execute an anonymous code block" msgstr "ç„¡åコードブロックを実行ã™ã‚‹" -#: sql_help.h:621 +#: sql_help.c:4573 +#| msgid "remove a cast" +msgid "remove an access method" +msgstr "アクセスメソッドを削除ã™ã‚‹" + +#: sql_help.c:4578 msgid "remove an aggregate function" msgstr "集約関数を削除ã™ã‚‹" -#: sql_help.h:626 +#: sql_help.c:4583 msgid "remove a cast" msgstr "キャストを削除ã™ã‚‹" -#: sql_help.h:631 +#: sql_help.c:4588 msgid "remove a collation" msgstr "ç…§åˆé †åºã‚’削除ã™ã‚‹" -#: sql_help.h:636 +#: sql_help.c:4593 msgid "remove a conversion" msgstr "エンコーディング変æ›ãƒ«ãƒ¼ãƒ«ã‚’削除ã™ã‚‹" -#: sql_help.h:641 +#: sql_help.c:4598 msgid "remove a database" msgstr "データベースを削除ã™ã‚‹" -#: sql_help.h:646 +#: sql_help.c:4603 msgid "remove a domain" msgstr "ドメインを削除ã™ã‚‹" -#: sql_help.h:651 +#: sql_help.c:4608 msgid "remove an event trigger" msgstr "イベントトリガを削除ã™ã‚‹" -#: sql_help.h:656 +#: sql_help.c:4613 msgid "remove an extension" msgstr "拡張を削除ã™ã‚‹" -#: sql_help.h:661 +#: sql_help.c:4618 msgid "remove a foreign-data wrapper" msgstr "外部データラッパーを削除ã™ã‚‹" -#: sql_help.h:666 +#: sql_help.c:4623 msgid "remove a foreign table" msgstr "外部テーブルを削除ã™ã‚‹" -#: sql_help.h:671 +#: sql_help.c:4628 msgid "remove a function" msgstr "関数を削除ã™ã‚‹" -#: sql_help.h:676 sql_help.h:716 sql_help.h:781 +#: sql_help.c:4633 sql_help.c:4678 sql_help.c:4748 msgid "remove a database role" msgstr "データベースã®ãƒ­ãƒ¼ãƒ«ã‚’削除ã™ã‚‹" -#: sql_help.h:681 +#: sql_help.c:4638 msgid "remove an index" msgstr "インデックスを削除ã™ã‚‹" -#: sql_help.h:686 +#: sql_help.c:4643 msgid "remove a procedural language" msgstr "手続ã言語を削除ã™ã‚‹" -#: sql_help.h:691 +#: sql_help.c:4648 msgid "remove a materialized view" msgstr "マテリアライズドビューを削除ã™ã‚‹" -#: sql_help.h:696 +#: sql_help.c:4653 msgid "remove an operator" msgstr "演算å­ã‚’削除ã™ã‚‹" -#: sql_help.h:701 +#: sql_help.c:4658 msgid "remove an operator class" msgstr "演算å­ã‚¯ãƒ©ã‚¹ã‚’削除ã™ã‚‹" -#: sql_help.h:706 +#: sql_help.c:4663 msgid "remove an operator family" msgstr "演算å­ãƒ•ã‚¡ãƒŸãƒªã‚’削除ã™ã‚‹" -#: sql_help.h:711 +#: sql_help.c:4668 msgid "remove database objects owned by a database role" msgstr "特定ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ­ãƒ¼ãƒ«ãŒæ‰€æœ‰ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚ªãƒ–ジェクトを削除ã™ã‚‹" -#: sql_help.h:721 +#: sql_help.c:4673 +msgid "remove a row level security policy from a table" +msgstr "テーブルã‹ã‚‰è¡Œãƒ¬ãƒ™ãƒ«ã‚»ã‚­ãƒ¥ãƒªãƒ†ã‚£ãƒãƒªã‚·ãƒ¼ã‚’削除ã™ã‚‹" + +#: sql_help.c:4683 msgid "remove a rewrite rule" msgstr "書ãæ›ãˆãƒ«ãƒ¼ãƒ«ã‚’削除ã™ã‚‹" -#: sql_help.h:726 +#: sql_help.c:4688 msgid "remove a schema" msgstr "スキーマを削除ã™ã‚‹" -#: sql_help.h:731 +#: sql_help.c:4693 msgid "remove a sequence" msgstr "シーケンスを削除ã™ã‚‹" -#: sql_help.h:736 +#: sql_help.c:4698 msgid "remove a foreign server descriptor" msgstr "外部サーãƒãƒ¼è­˜åˆ¥å­ã‚’削除ã™ã‚‹" -#: sql_help.h:741 +#: sql_help.c:4703 msgid "remove a table" msgstr "テーブルを削除ã™ã‚‹" -#: sql_help.h:746 +#: sql_help.c:4708 msgid "remove a tablespace" msgstr "テーブルスペースを削除ã™ã‚‹" -#: sql_help.h:751 +#: sql_help.c:4713 msgid "remove a text search configuration" msgstr "テキスト検索設定を削除ã™ã‚‹" -#: sql_help.h:756 +#: sql_help.c:4718 msgid "remove a text search dictionary" msgstr "テキスト検索用辞書を削除ã™ã‚‹" -#: sql_help.h:761 +#: sql_help.c:4723 msgid "remove a text search parser" msgstr "テキスト検索用パーサを削除ã™ã‚‹" -#: sql_help.h:766 +#: sql_help.c:4728 msgid "remove a text search template" msgstr "テキスト検索用テンプレートを削除ã™ã‚‹" -#: sql_help.h:771 +#: sql_help.c:4733 +#| msgid "remove an operator" +msgid "remove a transform" +msgstr "変æ›ã‚’削除ã™ã‚‹" + +#: sql_help.c:4738 msgid "remove a trigger" msgstr "トリガを削除ã™ã‚‹" -#: sql_help.h:776 +#: sql_help.c:4743 msgid "remove a data type" msgstr "データ型を削除ã™ã‚‹" -#: sql_help.h:786 +#: sql_help.c:4753 msgid "remove a user mapping for a foreign server" msgstr "外部サーãƒãƒ¼ã®ãƒ¦ãƒ¼ã‚¶ãƒžãƒƒãƒ”ングを削除" -#: sql_help.h:791 +#: sql_help.c:4758 msgid "remove a view" msgstr "ビューを削除ã™ã‚‹" -#: sql_help.h:801 +#: sql_help.c:4768 msgid "execute a prepared statement" msgstr "プリペアドステートメントを実行ã™ã‚‹" -#: sql_help.h:806 +#: sql_help.c:4773 msgid "show the execution plan of a statement" msgstr "ステートメントã®å®Ÿè¡Œãƒ—ランを表示ã™ã‚‹" -#: sql_help.h:811 +#: sql_help.c:4778 msgid "retrieve rows from a query using a cursor" msgstr "カーソルを使ã£ã¦å•ã„åˆã‚ã›ã‹ã‚‰è¡Œã‚’å–り出ã™" -#: sql_help.h:816 +#: sql_help.c:4783 msgid "define access privileges" msgstr "アクセス権é™ã‚’定義ã™ã‚‹" -#: sql_help.h:821 +#: sql_help.c:4788 +#| msgid "change the definition of a foreign server" +msgid "import table definitions from a foreign server" +msgstr "外部サーãƒãƒ¼ã‹ã‚‰ãƒ†ãƒ¼ãƒ–ル定義をインãƒãƒ¼ãƒˆã™ã‚‹" + +#: sql_help.c:4793 msgid "create new rows in a table" msgstr "テーブルã«æ–°ã—ã„行を作æˆã™ã‚‹" -#: sql_help.h:826 +#: sql_help.c:4798 msgid "listen for a notification" msgstr "通知メッセージを監視ã™ã‚‹" -#: sql_help.h:831 +#: sql_help.c:4803 msgid "load a shared library file" msgstr "共有ライブラリファイルをロードã™ã‚‹" -#: sql_help.h:836 +#: sql_help.c:4808 msgid "lock a table" msgstr "テーブルをロックã™ã‚‹" -#: sql_help.h:841 +#: sql_help.c:4813 msgid "position a cursor" msgstr "カーソルをä½ç½®ä»˜ã‘ã‚‹" -#: sql_help.h:846 +#: sql_help.c:4818 msgid "generate a notification" msgstr "通知メッセージを生æˆã™ã‚‹" -#: sql_help.h:851 +#: sql_help.c:4823 msgid "prepare a statement for execution" msgstr "実行ã«å…ˆç«‹ã£ã¦ã‚¹ãƒ†ãƒ¼ãƒˆãƒ¡ãƒ³ãƒˆã‚’準備ã™ã‚‹" -#: sql_help.h:856 +#: sql_help.c:4828 msgid "prepare the current transaction for two-phase commit" msgstr "２フェーズコミット用ã«ç¾åœ¨ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’準備ã™ã‚‹" -#: sql_help.h:861 +#: sql_help.c:4833 msgid "change the ownership of database objects owned by a database role" msgstr "ã‚るデータベースロールãŒæ‰€æœ‰ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚ªãƒ–ジェクトã®æ‰€æœ‰è€…を変更ã™ã‚‹" -#: sql_help.h:866 +#: sql_help.c:4838 msgid "replace the contents of a materialized view" msgstr "マテリアライズドビューã®å†…容を置ãæ›ãˆã‚‹" -#: sql_help.h:871 +#: sql_help.c:4843 msgid "rebuild indexes" msgstr "インデックスをå†æ§‹ç¯‰ã™ã‚‹" -#: sql_help.h:876 +#: sql_help.c:4848 msgid "destroy a previously defined savepoint" msgstr "å‰å›žå®šç¾©ã—ãŸã‚»ãƒ¼ãƒ–ãƒã‚¤ãƒ³ãƒˆã‚’削除ã™ã‚‹" -#: sql_help.h:881 +#: sql_help.c:4853 msgid "restore the value of a run-time parameter to the default value" msgstr "実行時パラメータã®å€¤ã‚’デフォルト値ã«æˆ»ã™" -#: sql_help.h:886 +#: sql_help.c:4858 msgid "remove access privileges" msgstr "アクセス権é™ã‚’剥奪ã™ã‚‹" -#: sql_help.h:896 +#: sql_help.c:4868 msgid "cancel a transaction that was earlier prepared for two-phase commit" msgstr "２フェーズコミット用ã«äº‹å‰æº–å‚™ã•ã‚ŒãŸãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’キャンセルã™ã‚‹" -#: sql_help.h:901 +#: sql_help.c:4873 msgid "roll back to a savepoint" msgstr "セーブãƒã‚¤ãƒ³ãƒˆã¾ã§ãƒ­ãƒ¼ãƒ«ãƒãƒƒã‚¯ã™ã‚‹" -#: sql_help.h:906 +#: sql_help.c:4878 msgid "define a new savepoint within the current transaction" msgstr "ç¾åœ¨ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«å¯¾ã—ã¦æ–°ã—ã„セーブãƒã‚¤ãƒ³ãƒˆã‚’定義ã™ã‚‹" -#: sql_help.h:911 +#: sql_help.c:4883 msgid "define or change a security label applied to an object" msgstr "オブジェクトã«é©ç”¨ã•ã‚Œã‚‹ã‚»ã‚­ãƒ¥ãƒªãƒ†ã‚£ãƒ©ãƒ™ãƒ«ã‚’定義ã¾ãŸã¯å¤‰æ›´ã™ã‚‹" -#: sql_help.h:916 sql_help.h:961 sql_help.h:991 +#: sql_help.c:4888 sql_help.c:4933 sql_help.c:4963 msgid "retrieve rows from a table or view" msgstr "テーブルもã—ãã¯ãƒ“ューã‹ã‚‰è¡Œã‚’å–り出ã™" -#: sql_help.h:926 +#: sql_help.c:4898 msgid "change a run-time parameter" msgstr "実行時パラメータを変更ã™ã‚‹" -#: sql_help.h:931 +#: sql_help.c:4903 msgid "set constraint check timing for the current transaction" msgstr "ç¾åœ¨ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«å¯¾ã—ã¦åˆ¶ç´„検査ã®ã‚¿ã‚¤ãƒŸãƒ³ã‚°ã‚’設定ã™ã‚‹" -#: sql_help.h:936 +#: sql_help.c:4908 msgid "set the current user identifier of the current session" msgstr "ç¾åœ¨ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«ãŠã‘ã‚‹ç¾åœ¨ã®ãƒ¦ãƒ¼ã‚¶è­˜åˆ¥ã‚’設定ã™ã‚‹" -#: sql_help.h:941 +#: sql_help.c:4913 msgid "set the session user identifier and the current user identifier of the current session" msgstr "セッションã®ãƒ¦ãƒ¼ã‚¶è­˜åˆ¥ã€ãŠã‚ˆã³ç¾åœ¨ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«ãŠã‘ã‚‹ç¾åœ¨ã®ãƒ¦ãƒ¼ã‚¶è­˜åˆ¥ã‚’設定ã™ã‚‹" -#: sql_help.h:946 +#: sql_help.c:4918 msgid "set the characteristics of the current transaction" msgstr "ç¾åœ¨ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ç‰¹æ€§ã‚’設定ã—ã¾ã™" -#: sql_help.h:951 +#: sql_help.c:4923 msgid "show the value of a run-time parameter" msgstr "実行時パラメータã®å€¤ã‚’表示ã™ã‚‹" -#: sql_help.h:966 +#: sql_help.c:4938 msgid "empty a table or set of tables" msgstr "テーブルもã—ãã¯ãƒ†ãƒ¼ãƒ–ルã®ã‚»ãƒƒãƒˆã‚’ 0 件ã«åˆ‡ã‚Šè©°ã‚ã‚‹" -#: sql_help.h:971 +#: sql_help.c:4943 msgid "stop listening for a notification" msgstr "通知メッセージã®ç›£è¦–を中止ã™ã‚‹" -#: sql_help.h:976 +#: sql_help.c:4948 msgid "update rows of a table" msgstr "テーブルã®è¡Œã‚’æ›´æ–°ã™ã‚‹" -#: sql_help.h:981 +#: sql_help.c:4953 msgid "garbage-collect and optionally analyze a database" msgstr "ガーベジコレクションを行ã„ã€ã‚ªãƒ—ションã§ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®åˆ†æžã‚’ã—ã¾ã™" -#: sql_help.h:986 +#: sql_help.c:4958 msgid "compute a set of rows" msgstr "行セットを計算ã—ã¾ã™" -#: startup.c:166 +#: startup.c:189 #, c-format msgid "%s: -1 can only be used in non-interactive mode\n" msgstr "%s: -1ã¯å¯¾è©±å¼ãƒ¢ãƒ¼ãƒ‰ä»¥å¤–ã§ã®ã¿ä½¿ç”¨ã§ãã¾ã™\n" -#: startup.c:266 +#: startup.c:289 #, c-format msgid "%s: could not open log file \"%s\": %s\n" msgstr "%s: ログファイル \"%s\" をオープンã§ãã¾ã›ã‚“: %s\n" -#: startup.c:328 +#: startup.c:389 #, c-format msgid "" "Type \"help\" for help.\n" @@ -4415,42 +5373,43 @@ msgstr "" "\"help\" ã§ãƒ˜ãƒ«ãƒ—を表示ã—ã¾ã™.\n" "\n" -#: startup.c:471 +#: startup.c:538 #, c-format msgid "%s: could not set printing parameter \"%s\"\n" msgstr "%s: 表示用パラメータ \"%s\" をセットã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: startup.c:511 +#: startup.c:578 #, c-format msgid "%s: could not delete variable \"%s\"\n" msgstr "%s: 変数 \"%s\" を削除ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: startup.c:521 +#: startup.c:588 #, c-format msgid "%s: could not set variable \"%s\"\n" msgstr "%s: 変数 \"%s\" をセットã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: startup.c:564 startup.c:570 +#: startup.c:648 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細㯠'%s --help' ã‚’ã”らんãã ã•ã„\n" -#: startup.c:587 +#: startup.c:665 #, c-format msgid "%s: warning: extra command-line argument \"%s\" ignored\n" msgstr "%s: 警告：余分ãªã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ã‚ªãƒ—ション \"%s\" ã¯ç„¡è¦–ã•ã‚Œã¾ã™\n" -#: startup.c:609 +#: startup.c:714 #, c-format msgid "%s: could not find own program executable\n" msgstr "%s: 実行ファイル自体ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: startup.c:729 startup.c:776 startup.c:797 startup.c:834 variables.c:121 +#: startup.c:836 startup.c:883 startup.c:904 startup.c:941 startup.c:963 +#: variables.c:121 #, c-format msgid "unrecognized value \"%s\" for \"%s\"; assuming \"%s\"\n" msgstr "\"%2$s\" ã®ä¸æ˜Žãªå€¤ \"%1$s\"。\"%3$s\"ã¨ä»®å®šã—ã¾ã™\n" -#: tab-complete.c:4098 +#: tab-complete.c:3743 #, c-format msgid "" "tab completion query failed: %s\n" @@ -4460,3 +5419,15 @@ msgstr "" "å•ã„åˆã‚ã›ã®ã‚¿ãƒ–補完ã«å¤±æ•—: %s\n" "å•ã„åˆã‚ã›ã¯\n" "%s\n" + +#~ msgid "(No rows)\n" +#~ msgstr "(è¡ŒãŒã‚ã‚Šã¾ã›ã‚“)\n" + +#~ msgid " -?, --help show this help, then exit\n" +#~ msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" + +#~ msgid "Watch every %lds\t%s" +#~ msgstr "%ld秒毎ã«ç›£è¦–ã—ã¾ã™\t%s" + +#~ msgid "SSL connection (unknown cipher)\n" +#~ msgstr "SSL 接続 (未定義ã®æš—å·åŒ–æ–¹å¼)\n" diff --git a/src/bin/scripts/po/ja.po b/src/bin/scripts/po/ja.po index 6764cab974..d673020e5a 100644 --- a/src/bin/scripts/po/ja.po +++ b/src/bin/scripts/po/ja.po @@ -3,11 +3,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.6\n" +"Project-Id-Version: PostgreSQL 9.6.3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-09-20 17:10+0900\n" +"POT-Creation-Date: 2017-04-04 09:37+0900\n" "PO-Revision-Date: 2013-08-18 17:27+0900\n" -"Last-Translator: IDERIHA Takeshi \n" +"Last-Translator: Daisuke Higuchi \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -47,22 +47,22 @@ msgid_plural "(%lu rows)" msgstr[0] "(%lu è¡Œ)" msgstr[1] "(%lu è¡Œ)" -#: ../../fe_utils/print.c:2906 +#: ../../fe_utils/print.c:2914 #, c-format msgid "Interrupted\n" msgstr "中断ã•ã‚Œã¾ã—ãŸ\n" -#: ../../fe_utils/print.c:2970 +#: ../../fe_utils/print.c:2978 #, c-format msgid "Cannot add header to table content: column count of %d exceeded.\n" msgstr "テーブルã®å†…容ã«è¦‹å‡ºã—を追加ã§ãã¾ã›ã‚“ã§ã—ãŸï¼šåˆ—æ•° %d ãŒåˆ¶é™ã‚’越ãˆã¦ã„ã¾ã™ã€‚\n" -#: ../../fe_utils/print.c:3010 +#: ../../fe_utils/print.c:3018 #, c-format msgid "Cannot add cell to table content: total cell count of %d exceeded.\n" msgstr "テーブルã®å†…容ã«ã‚»ãƒ«ã‚’追加ã§ãã¾ã›ã‚“ã§ã—ãŸï¼šå…¨ã‚»ãƒ«æ•° %d ãŒåˆ¶é™ã‚’越ãˆã¦ã„ã¾ã™ã€‚\n" -#: ../../fe_utils/print.c:3259 +#: ../../fe_utils/print.c:3267 #, c-format msgid "invalid output format (internal error): %d" msgstr "出力フォーマットãŒç„¡åŠ¹ï¼ˆå†…部エラー）：%d" @@ -72,14 +72,14 @@ msgstr "出力フォーマットãŒç„¡åŠ¹ï¼ˆå†…部エラー）：%d" #: createuser.c:184 dropdb.c:94 dropdb.c:103 dropdb.c:111 droplang.c:88 #: droplang.c:118 droplang.c:174 dropuser.c:89 dropuser.c:104 dropuser.c:115 #: pg_isready.c:93 pg_isready.c:107 reindexdb.c:131 reindexdb.c:150 -#: vacuumdb.c:207 vacuumdb.c:226 +#: vacuumdb.c:211 vacuumdb.c:230 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細ã¯\"%s --help\"を実行ã—ã¦ãã ã•ã„。\n" #: clusterdb.c:128 createdb.c:136 createlang.c:117 createuser.c:182 #: dropdb.c:109 droplang.c:116 dropuser.c:102 pg_isready.c:105 reindexdb.c:148 -#: vacuumdb.c:224 +#: vacuumdb.c:228 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: コマンドライン引数ãŒå¤šã™ãŽã¾ã™ã€‚(始ã‚ã¯\"%s\")\n" @@ -118,19 +118,19 @@ msgstr "%sã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å†…ã§äº‹å‰ã«ã‚¯ãƒ©ã‚¹ã‚¿åŒ–ã•ã‚Œã¦ã„ã‚‹ã™ #: clusterdb.c:270 createdb.c:252 createlang.c:236 createuser.c:349 #: dropdb.c:155 droplang.c:237 dropuser.c:156 pg_isready.c:222 reindexdb.c:401 -#: vacuumdb.c:942 +#: vacuumdb.c:946 #, c-format msgid "Usage:\n" msgstr "使用方法:\n" -#: clusterdb.c:271 reindexdb.c:402 vacuumdb.c:943 +#: clusterdb.c:271 reindexdb.c:402 vacuumdb.c:947 #, c-format msgid " %s [OPTION]... [DBNAME]\n" msgstr " %s [オプション]... [データベースå]\n" #: clusterdb.c:272 createdb.c:254 createlang.c:238 createuser.c:351 #: dropdb.c:157 droplang.c:239 dropuser.c:158 pg_isready.c:225 reindexdb.c:403 -#: vacuumdb.c:944 +#: vacuumdb.c:948 #, c-format msgid "" "\n" @@ -184,7 +184,7 @@ msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ #: clusterdb.c:281 createdb.c:265 createlang.c:244 createuser.c:375 #: dropdb.c:163 droplang.c:245 dropuser.c:165 pg_isready.c:231 reindexdb.c:415 -#: vacuumdb.c:960 +#: vacuumdb.c:964 #, c-format msgid "" "\n" @@ -194,36 +194,36 @@ msgstr "" "接続オプション:\n" #: clusterdb.c:282 createlang.c:245 createuser.c:376 dropdb.c:164 -#: droplang.c:246 dropuser.c:166 reindexdb.c:416 vacuumdb.c:961 +#: droplang.c:246 dropuser.c:166 reindexdb.c:416 vacuumdb.c:965 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory\n" msgstr " -h, --host=ホストå データベースサーãƒã®ãƒ›ã‚¹ãƒˆã¾ãŸã¯ã‚½ã‚±ãƒƒãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒª\n" #: clusterdb.c:283 createlang.c:246 createuser.c:377 dropdb.c:165 -#: droplang.c:247 dropuser.c:167 reindexdb.c:417 vacuumdb.c:962 +#: droplang.c:247 dropuser.c:167 reindexdb.c:417 vacuumdb.c:966 #, c-format msgid " -p, --port=PORT database server port\n" msgstr " -p, --port=ãƒãƒ¼ãƒˆç•ªå· データベースサーãƒã®ãƒãƒ¼ãƒˆç•ªå·\n" #: clusterdb.c:284 createlang.c:247 dropdb.c:166 droplang.c:248 -#: reindexdb.c:418 vacuumdb.c:963 +#: reindexdb.c:418 vacuumdb.c:967 #, c-format msgid " -U, --username=USERNAME user name to connect as\n" msgstr " -U, --username=ユーザå ã“ã®ãƒ¦ãƒ¼ã‚¶åã§æŽ¥ç¶šã™ã‚‹\n" #: clusterdb.c:285 createlang.c:248 createuser.c:379 dropdb.c:167 -#: droplang.c:249 dropuser.c:169 reindexdb.c:419 vacuumdb.c:964 +#: droplang.c:249 dropuser.c:169 reindexdb.c:419 vacuumdb.c:968 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password パスワード入力をè¦æ±‚ã—ãªã„\n" #: clusterdb.c:286 createlang.c:249 createuser.c:380 dropdb.c:168 -#: droplang.c:250 dropuser.c:170 reindexdb.c:420 vacuumdb.c:965 +#: droplang.c:250 dropuser.c:170 reindexdb.c:420 vacuumdb.c:969 #, c-format msgid " -W, --password force password prompt\n" msgstr " -W, --password パスワードプロンプトを強制表示ã™ã‚‹\n" -#: clusterdb.c:287 dropdb.c:169 reindexdb.c:421 vacuumdb.c:966 +#: clusterdb.c:287 dropdb.c:169 reindexdb.c:421 vacuumdb.c:970 #, c-format msgid " --maintenance-db=DBNAME alternate maintenance database\n" msgstr " --maintenance-db=DBNAME 別ã®ä¿å®ˆç”¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’指定ã™ã‚‹\n" @@ -239,7 +239,7 @@ msgstr "" #: clusterdb.c:289 createdb.c:273 createlang.c:250 createuser.c:381 #: dropdb.c:170 droplang.c:251 dropuser.c:171 pg_isready.c:236 reindexdb.c:423 -#: vacuumdb.c:968 +#: vacuumdb.c:972 #, c-format msgid "" "\n" @@ -748,7 +748,7 @@ msgstr "" #: dropuser.c:163 #, c-format msgid " --if-exists don't report error if user doesn't exist\n" -msgstr " --if-exists ユーザãŒæŒ‡å®šã—ãªã„å ´åˆã«ã‚¨ãƒ©ãƒ¼ã‚’報告ã—ãªã„\n" +msgstr " --if-exists ユーザãŒå­˜åœ¨ã—ãªã„å ´åˆã«ã‚¨ãƒ©ãƒ¼ã‚’報告ã—ãªã„\n" #: dropuser.c:168 #, c-format @@ -962,149 +962,150 @@ msgstr "" "\n" "詳細㯠SQL コマンド REINDEX ã«é–¢ã™ã‚‹èª¬æ˜Žã‚’å‚ç…§ã—ã¦ãã ã•ã„。\n" -#: vacuumdb.c:189 +#: vacuumdb.c:193 #, c-format msgid "%s: number of parallel jobs must be at least 1\n" msgstr "%s: 並行ジョブã®æ•°ã¯å°‘ãªãã¨ã‚‚1ã§ã™\n" -#: vacuumdb.c:195 +#: vacuumdb.c:199 #, c-format msgid "%s: too many parallel jobs requested (maximum: %d)\n" msgstr "%s: è¦æ±‚ã•ã‚ŒãŸä¸¦åˆ—ジョブãŒå¤šã™ãŽã¾ã™ (最大: %d)\n" -#: vacuumdb.c:234 vacuumdb.c:240 +#: vacuumdb.c:238 vacuumdb.c:244 #, c-format msgid "%s: cannot use the \"%s\" option when performing only analyze\n" msgstr "%s: analyze ã®ã¿ã‚’実行ã™ã‚‹å ´åˆ \"%s\" ã¯ä½¿ãˆã¾ã›ã‚“\n" -#: vacuumdb.c:257 +#: vacuumdb.c:261 #, c-format msgid "%s: cannot vacuum all databases and a specific one at the same time\n" msgstr "%s: 全データベースã¨ç‰¹å®šã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’åŒæ™‚ã« vacuum ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“\n" -#: vacuumdb.c:263 +#: vacuumdb.c:267 #, c-format msgid "%s: cannot vacuum specific table(s) in all databases\n" msgstr "%s: 全データベースã®ã†ã¡ç‰¹å®šã®ãƒ†ãƒ¼ãƒ–ルを vacuum ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“\n" -#: vacuumdb.c:349 +#: vacuumdb.c:353 msgid "Generating minimal optimizer statistics (1 target)" msgstr "最é©åŒ–ã®ãŸã‚ã®æƒ…報を最å°é™ç”Ÿæˆã—ã¾ã™ (1対象)" -#: vacuumdb.c:350 +#: vacuumdb.c:354 msgid "Generating medium optimizer statistics (10 targets)" msgstr "最é©åŒ–ã®ãŸã‚ã®æƒ…報を複数生æˆã—ã¾ã™ (10対象)" -#: vacuumdb.c:351 +#: vacuumdb.c:355 msgid "Generating default (full) optimizer statistics" msgstr "最é©åŒ–ã®ãŸã‚ã®æƒ…報をデフォルト数(å…¨ã¦)生æˆã—ã¾ã™" -#: vacuumdb.c:363 +#: vacuumdb.c:367 #, c-format msgid "%s: processing database \"%s\": %s\n" msgstr "%s: データベース\"%s\"ã®å‡¦ç†ä¸­ã§ã™: %s\n" -#: vacuumdb.c:366 +#: vacuumdb.c:370 #, c-format msgid "%s: vacuuming database \"%s\"\n" msgstr "%s: データベース\"%s\"ã‚’ vacuum ã—ã¦ã„ã¾ã™\n" -#: vacuumdb.c:698 +#: vacuumdb.c:702 #, c-format msgid "%s: vacuuming of table \"%s\" in database \"%s\" failed: %s" msgstr "%1$s: データベース \"%3$s\" ã§ãƒ†ãƒ¼ãƒ–ル\"%2$sã® vacuum ã«å¤±æ•—ã—ã¾ã—ãŸï¼š%4$ss" -#: vacuumdb.c:701 vacuumdb.c:818 +#: vacuumdb.c:705 vacuumdb.c:822 #, c-format msgid "%s: vacuuming of database \"%s\" failed: %s" msgstr "%s: データベース\"%s\"ã® vacuum ã«å¤±æ•—ã—ã¾ã—ãŸ: %s" -#: vacuumdb.c:932 +#: vacuumdb.c:936 #, c-format -#| msgid "%s: invalid argument: %s\n" msgid "%s: invalid socket: %s" msgstr "%s: 無効ãªã‚½ã‚±ãƒƒãƒˆã§ã™: %s" -#: vacuumdb.c:941 +#: vacuumdb.c:945 #, c-format msgid "" "%s cleans and analyzes a PostgreSQL database.\n" "\n" msgstr "%sã¯PostgreSQLデータベースを clean ãŠã‚ˆã³ analyse ã—ã¾ã™ã€‚\n" -#: vacuumdb.c:945 +#: vacuumdb.c:949 #, c-format msgid " -a, --all vacuum all databases\n" msgstr " -a, --all 全データベースを vacuum ã—ã¾ã™\n" -#: vacuumdb.c:946 +#: vacuumdb.c:950 #, c-format msgid " -d, --dbname=DBNAME database to vacuum\n" msgstr " -d, --dbname=データベースå vacuum ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å\n" -#: vacuumdb.c:947 +#: vacuumdb.c:951 #, c-format msgid " -e, --echo show the commands being sent to the server\n" msgstr " -e, --echo サーãƒã«é€ã‚‰ã‚Œã‚‹ã‚³ãƒžãƒ³ãƒ‰ã‚’表示ã—ã¾ã™\n" -#: vacuumdb.c:948 +#: vacuumdb.c:952 #, c-format msgid " -f, --full do full vacuuming\n" msgstr " -f, --full full vacuum ã‚’è¡Œãªã„ã¾ã™\n" -#: vacuumdb.c:949 +#: vacuumdb.c:953 #, c-format msgid " -F, --freeze freeze row transaction information\n" msgstr " -F, --freeze 行トランザクション情報を更新ã›ãšã«ä¿æŒã—ã¾ã™\n" -#: vacuumdb.c:950 +#: vacuumdb.c:954 #, c-format msgid " -j, --jobs=NUM use this many concurrent connections to vacuum\n" msgstr " -j, --jobs=NUM ãƒã‚­ãƒ¥ãƒ¼ãƒ æ™‚ã«æŒ‡å®šã—ãŸåŒæ™‚接続数を使用\n" -#: vacuumdb.c:951 +#: vacuumdb.c:955 #, c-format msgid " -q, --quiet don't write any messages\n" msgstr " -q, --quiet メッセージを出力ã—ã¾ã›ã‚“\n" -#: vacuumdb.c:952 +#: vacuumdb.c:956 #, c-format msgid " -t, --table='TABLE[(COLUMNS)]' vacuum specific table(s) only\n" msgstr " -t, --table='TABLE[(COLUMNS)]' 指定ã—ãŸãƒ†ãƒ¼ãƒ–ル(複数å¯)ã®ã¿ã‚’ vacuum ã—ã¾ã™\n" -#: vacuumdb.c:953 +#: vacuumdb.c:957 #, c-format msgid " -v, --verbose write a lot of output\n" msgstr " -v, --verbose 多ãã®ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã‚’出力ã—ã¾ã™\n" -#: vacuumdb.c:954 +#: vacuumdb.c:958 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: vacuumdb.c:955 +#: vacuumdb.c:959 #, c-format msgid " -z, --analyze update optimizer statistics\n" msgstr " -z, --analyze 最é©åŒ–ã®ãŸã‚ã®æƒ…報を更新ã—ã¾ã™\n" -#: vacuumdb.c:956 +#: vacuumdb.c:960 #, c-format msgid " -Z, --analyze-only only update optimizer statistics; no vacuum\n" msgstr " -Z, --analyze-only 最é©åŒ–ã®ãŸã‚ã®æƒ…å ±ã ã‘ã‚’æ›´æ–°ã—ã¾ã™; ãƒã‚­ãƒ¥ãƒ¼ãƒ ã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: vacuumdb.c:957 +#: vacuumdb.c:961 #, c-format msgid "" " --analyze-in-stages only update optimizer statistics, in multiple\n" " stages for faster results; no vacuum\n" msgstr "" +" --analyze-in-stages オプティマイザã®çµ±è¨ˆæƒ…å ±ã®æ›´æ–°ã®ã¿ã‚’è¡Œã„ã¾ã™ã€‚高速ã«çµæžœã‚’å¾—ã‚‹ãŸã‚ã«\n" +" 複数回実行ã—ã¾ã™; ãƒã‚­ãƒ¥ãƒ¼ãƒ ã‚’è¡Œã„ã¾ã›ã‚“\n" -#: vacuumdb.c:959 +#: vacuumdb.c:963 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" -#: vacuumdb.c:967 +#: vacuumdb.c:971 #, c-format msgid "" "\n" @@ -1113,46 +1114,3 @@ msgstr "" "\n" "詳細㯠SQL コマンド㮠VACUUM ã®èª¬æ˜Žã‚’å‚ç…§ã—ã¦ãã ã•ã„。\n" -#~ msgid "%s: could not obtain information about current user: %s\n" -#~ msgstr "%s: ç¾åœ¨ã®ãƒ¦ãƒ¼ã‚¶ã«é–¢ã™ã‚‹æƒ…報をå–å¾—ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#~ msgid "%s: could not get current user name: %s\n" -#~ msgstr "%s: ç¾åœ¨ã®ãƒ¦ãƒ¼ã‚¶åã‚’å–å¾—ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#~ msgid "%s: cannot use the \"freeze\" option when performing only analyze\n" -#~ msgstr "%s: analyze ã®ã¿ã‚’実行ã™ã‚‹å ´åˆ \"freeze\" ã¯ä½¿ãˆã¾ã›ã‚“\n" - -#~ msgid "%s: still %s functions declared in language \"%s\"; language not removed\n" -#~ msgstr "%s: ã¾ã é–¢æ•°%sãŒè¨€èªž\"%s\"内ã§å®£è¨€ã•ã‚Œã¦ã„ã¾ã™ã€‚言語ã¯å‰Šé™¤ã•ã‚Œã¾ã›ã‚“\n" - -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã¦çµ‚了\n" - -#~ msgid "%s: out of memory\n" -#~ msgstr "%s: メモリä¸è¶³ã§ã™\n" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã¦çµ‚了ã—ã¾ã™\n" - -#~ msgid "" -#~ "\n" -#~ "If one of -d, -D, -r, -R, -s, -S, and ROLENAME is not specified, you will\n" -#~ "be prompted interactively.\n" -#~ msgstr "" -#~ "\n" -#~ "-d, -D, -r, -R, -s, -S ã§ãƒ­ãƒ¼ãƒ«åãŒæŒ‡å®šã•ã‚Œãªã„å ´åˆã€ãƒ­ãƒ¼ãƒ«åã‚’ãã®å ´ã§å…¥åŠ›ã§ãã¾ã™\n" - -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã¦çµ‚了ã—ã¾ã™\n" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã¦çµ‚了\n" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ヘルプを表示ã—ã¦çµ‚了ã—ã¾ã™\n" - -#~ msgid "pg_strdup: cannot duplicate null pointer (internal error)\n" -#~ msgstr "pg_strdup: null ãƒã‚¤ãƒ³ã‚¿ã‚’複製ã§ãã¾ã›ã‚“（内部エラー）。\n" - -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã¦çµ‚了ã—ã¾ã™\n" diff --git a/src/interfaces/ecpg/preproc/po/it.po b/src/interfaces/ecpg/preproc/po/it.po index fae3283421..b2589c5758 100644 --- a/src/interfaces/ecpg/preproc/po/it.po +++ b/src/interfaces/ecpg/preproc/po/it.po @@ -18,10 +18,10 @@ # msgid "" msgstr "" -"Project-Id-Version: ecpg (PostgreSQL) 9.4\n" +"Project-Id-Version: ecpg (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2014-07-30 04:08+0000\n" -"PO-Revision-Date: 2014-07-30 22:37+0100\n" +"POT-Creation-Date: 2017-02-09 21:08+0000\n" +"PO-Revision-Date: 2017-04-23 03:03+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -30,7 +30,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" "X-Poedit-SourceCharset: utf-8\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" #: descriptor.c:64 #, c-format @@ -42,27 +42,27 @@ msgstr "la variabile \"%s\" deve essere di tipo numerico" msgid "descriptor \"%s\" does not exist" msgstr "il descrittore \"%s\" non esiste" -#: descriptor.c:161 descriptor.c:210 +#: descriptor.c:161 descriptor.c:213 #, c-format msgid "descriptor header item \"%d\" does not exist" msgstr "la voce \"%d\" dell'header del descrittore non esiste" -#: descriptor.c:182 +#: descriptor.c:183 #, c-format msgid "nullable is always 1" msgstr "nullable è sempre 1" -#: descriptor.c:185 +#: descriptor.c:186 #, c-format msgid "key_member is always 0" msgstr "key_member è sempre 0" -#: descriptor.c:277 +#: descriptor.c:280 #, c-format msgid "descriptor item \"%s\" is not implemented" msgstr "la voce \"%s\" del descrittore non è implementata" -#: descriptor.c:287 +#: descriptor.c:290 #, c-format msgid "descriptor item \"%s\" cannot be set" msgstr "la voce \"%s\" del descrittore non può essere impostata" @@ -161,8 +161,8 @@ msgstr " -t attiva il commit automatico delle transazioni\n" #: ecpg.c:57 #, c-format -msgid " --version output version information, then exit\n" -msgstr " --version mostra informazioni sulla versione ed esci\n" +msgid " -V, --version output version information, then exit\n" +msgstr " -V --version mostra informazioni sulla versione ed esci\n" #: ecpg.c:58 #, c-format @@ -189,154 +189,154 @@ msgstr "" "\n" "Puoi segnalare eventuali bug a .\n" -#: ecpg.c:143 +#: ecpg.c:139 #, c-format msgid "%s: could not locate my own executable path\n" msgstr "%s: percorso del proprio eseguibile non trovato\n" -#: ecpg.c:186 ecpg.c:337 ecpg.c:347 +#: ecpg.c:175 ecpg.c:327 ecpg.c:337 #, c-format msgid "%s: could not open file \"%s\": %s\n" msgstr "%s: apertura del file \"%s\" fallita: %s\n" -#: ecpg.c:225 ecpg.c:238 ecpg.c:254 ecpg.c:279 +#: ecpg.c:214 ecpg.c:227 ecpg.c:243 ecpg.c:268 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Prova \"%s --help\" per maggiori informazioni.\n" -#: ecpg.c:249 +#: ecpg.c:238 #, c-format msgid "%s: parser debug support (-d) not available\n" msgstr "%s: il supporto al debug del parser (-d) non è disponibile\n" -#: ecpg.c:267 +#: ecpg.c:256 #, c-format msgid "%s, the PostgreSQL embedded C preprocessor, version %d.%d.%d\n" msgstr "%s, preprocessore embedded C PostgreSQL, versione %d.%d.%d\n" -#: ecpg.c:269 +#: ecpg.c:258 #, c-format msgid "EXEC SQL INCLUDE ... search starts here:\n" msgstr "EXEC SQL INCLUDE ... la ricerca inizia da qui:\n" -#: ecpg.c:272 +#: ecpg.c:261 #, c-format msgid "end of search list\n" msgstr "fine della lista di ricerca\n" -#: ecpg.c:278 +#: ecpg.c:267 #, c-format msgid "%s: no input files specified\n" msgstr "%s: non è stato specificato nessun file di input\n" -#: ecpg.c:470 +#: ecpg.c:460 #, c-format msgid "cursor \"%s\" has been declared but not opened" msgstr "il cursore \"%s\" è stato dichiarato, ma non aperto" -#: ecpg.c:483 preproc.y:125 +#: ecpg.c:473 preproc.y:127 #, c-format msgid "could not remove output file \"%s\"\n" msgstr "rimozione del file di output \"%s\" fallita\n" -#: pgc.l:421 +#: pgc.l:432 #, c-format msgid "unterminated /* comment" msgstr "commento /* non terminato" # string literal sarebbe intraducubile infatti è come la stringa viene rappresentata nel linguaggio di programmazione, ma come si fa a tradurlo?.... # Secondo me "stringa letterale" -- Daniele -#: pgc.l:434 +#: pgc.l:445 #, c-format msgid "invalid bit string literal" msgstr "bit nella stringa letterale non valido" -#: pgc.l:443 +#: pgc.l:454 #, c-format msgid "unterminated bit string literal" msgstr "letterale di stringa di bit non terminato" -#: pgc.l:459 +#: pgc.l:470 #, c-format msgid "unterminated hexadecimal string literal" msgstr "letterale di stringa esadecimale non terminato" -#: pgc.l:537 +#: pgc.l:548 #, c-format msgid "unterminated quoted string" msgstr "stringa tra virgolette non terminata" -#: pgc.l:592 pgc.l:605 +#: pgc.l:605 pgc.l:618 #, c-format msgid "zero-length delimited identifier" msgstr "identificativo delimitato di lunghezza zero" -#: pgc.l:613 +#: pgc.l:626 #, c-format msgid "unterminated quoted identifier" msgstr "identificativo tra virgolette non terminato" -#: pgc.l:867 +#: pgc.l:881 #, c-format msgid "nested /* ... */ comments" msgstr "commenti /* ... */ annidati" -#: pgc.l:960 +#: pgc.l:974 #, c-format msgid "missing identifier in EXEC SQL UNDEF command" msgstr "identificativo mancante nel comando EXEC SQL UNDEF" -#: pgc.l:1006 pgc.l:1020 +#: pgc.l:1020 pgc.l:1034 #, c-format msgid "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"" msgstr "mancata corrispondenza fra \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"" -#: pgc.l:1009 pgc.l:1022 pgc.l:1198 +#: pgc.l:1023 pgc.l:1036 pgc.l:1212 #, c-format msgid "missing \"EXEC SQL ENDIF;\"" msgstr "manca \"EXEC SQL ENDIF;\"" -#: pgc.l:1038 pgc.l:1057 +#: pgc.l:1052 pgc.l:1071 #, c-format msgid "more than one EXEC SQL ELSE" msgstr "più di un EXEC SQL ELSE" -#: pgc.l:1079 pgc.l:1093 +#: pgc.l:1093 pgc.l:1107 #, c-format msgid "unmatched EXEC SQL ENDIF" msgstr "EXEC SQL ENDIF non corrispondente" -#: pgc.l:1113 +#: pgc.l:1127 #, c-format msgid "too many nested EXEC SQL IFDEF conditions" msgstr "troppe condizioni EXEC SQL IFDEF annidate" -#: pgc.l:1146 +#: pgc.l:1160 #, c-format msgid "missing identifier in EXEC SQL IFDEF command" msgstr "identificativo mancante nel comando EXEC SQL IFDEF" -#: pgc.l:1155 +#: pgc.l:1169 #, c-format msgid "missing identifier in EXEC SQL DEFINE command" msgstr "identificativo mancante nel comando EXEC SQL DEFINE" -#: pgc.l:1188 +#: pgc.l:1202 #, c-format msgid "syntax error in EXEC SQL INCLUDE command" msgstr "errore di sintassi nel comando EXEC SQL INCLUDE" -#: pgc.l:1237 +#: pgc.l:1251 #, c-format msgid "internal error: unreachable state; please report this to " msgstr "errore interno: stato non raggiungibile, si prega di segnalarlo a " -#: pgc.l:1362 +#: pgc.l:1375 #, c-format msgid "Error: include path \"%s/%s\" is too long on line %d, skipping\n" msgstr "Errore: il percorso delle inclusioni \"%s/%s\" è troppo lungo alla riga %d, perciò viene saltato\n" -#: pgc.l:1385 +#: pgc.l:1398 #, c-format msgid "could not open include file \"%s\" on line %d" msgstr "apertura del file di include \"%s\" alla riga %d fallita" @@ -345,210 +345,210 @@ msgstr "apertura del file di include \"%s\" alla riga %d fallita" msgid "syntax error" msgstr "errore di sintassi" -#: preproc.y:79 +#: preproc.y:81 #, c-format msgid "WARNING: " msgstr "ATTENZIONE: " -#: preproc.y:82 +#: preproc.y:84 #, c-format msgid "ERROR: " msgstr "ERRORE: " -#: preproc.y:506 +#: preproc.y:508 #, c-format msgid "cursor \"%s\" does not exist" msgstr "il cursore \"%s\" non esiste" -#: preproc.y:535 +#: preproc.y:537 #, c-format msgid "initializer not allowed in type definition" msgstr "l'inizializzatore non è permesso nella definizione del tipo di dato" -#: preproc.y:537 +#: preproc.y:539 #, c-format msgid "type name \"string\" is reserved in Informix mode" msgstr "il nome di tipo \"string\" è riservato alla modalità Informix" -#: preproc.y:544 preproc.y:13853 +#: preproc.y:546 preproc.y:14626 #, c-format msgid "type \"%s\" is already defined" msgstr "il tipo \"%s\" è già definito" -#: preproc.y:568 preproc.y:14511 preproc.y:14832 variable.c:618 +#: preproc.y:570 preproc.y:15284 preproc.y:15604 variable.c:620 #, c-format msgid "multidimensional arrays for simple data types are not supported" msgstr "gli array multidimensionali per tipi dato semplici non sono supportati" -#: preproc.y:1577 +#: preproc.y:1634 #, c-format msgid "AT option not allowed in CLOSE DATABASE statement" msgstr "l'opzione AT non è permessa nell'istruzione CLOSE DATABASE" -#: preproc.y:1780 +#: preproc.y:1849 #, c-format msgid "AT option not allowed in CONNECT statement" msgstr "l'opzione AT non è permessa nell'istruzione CONNECT" -#: preproc.y:1814 +#: preproc.y:1883 #, c-format msgid "AT option not allowed in DISCONNECT statement" msgstr "l'opzione AT non è permessa nell'istruzione DISCONNECT" -#: preproc.y:1869 +#: preproc.y:1938 #, c-format msgid "AT option not allowed in SET CONNECTION statement" msgstr "l'opzione AT non è permessa nell'istruzione SET CONNECTION" -#: preproc.y:1891 +#: preproc.y:1960 #, c-format msgid "AT option not allowed in TYPE statement" msgstr "l'opzione AT non è permessa nell'istruzione TYPE" -#: preproc.y:1900 +#: preproc.y:1969 #, c-format msgid "AT option not allowed in VAR statement" msgstr "l'opzione AT non è permessa nell'istruzione VAR" -#: preproc.y:1907 +#: preproc.y:1976 #, c-format msgid "AT option not allowed in WHENEVER statement" msgstr "l'opzione AT non è permessa nell'istruzione WHENEVER" -#: preproc.y:2155 preproc.y:2160 preproc.y:2276 preproc.y:3614 preproc.y:4866 -#: preproc.y:4875 preproc.y:5159 preproc.y:6562 preproc.y:7683 preproc.y:7688 -#: preproc.y:10142 preproc.y:10739 +#: preproc.y:2228 preproc.y:2233 preproc.y:2349 preproc.y:3759 preproc.y:5173 +#: preproc.y:5182 preproc.y:5466 preproc.y:6902 preproc.y:8140 preproc.y:8145 +#: preproc.y:10776 preproc.y:11393 #, c-format msgid "unsupported feature will be passed to server" msgstr "al server è stata richiesta una funzionalità non supportata" -#: preproc.y:2518 +#: preproc.y:2607 #, c-format msgid "SHOW ALL is not implemented" msgstr "SHOW ALL non è implementato" -#: preproc.y:3002 +#: preproc.y:3147 #, c-format msgid "COPY FROM STDIN is not implemented" msgstr "COPY FROM STDIN non è implementato" -#: preproc.y:8520 preproc.y:13442 +#: preproc.y:9035 preproc.y:14215 #, c-format msgid "using variable \"%s\" in different declare statements is not supported" msgstr "usare la variabile \"%s\" in una diversa istruzione declare non è supportato" -#: preproc.y:8522 preproc.y:13444 +#: preproc.y:9037 preproc.y:14217 #, c-format msgid "cursor \"%s\" is already defined" msgstr "il cursore \"%s\" è già definito" -#: preproc.y:8940 +#: preproc.y:9467 #, c-format msgid "no longer supported LIMIT #,# syntax passed to server" msgstr "la sintassi LIMIT #,# passata al server non è più supportata" -#: preproc.y:9176 preproc.y:9183 +#: preproc.y:9775 preproc.y:9782 #, c-format msgid "subquery in FROM must have an alias" msgstr "la sottoquery in FROM deve avere un alias" -#: preproc.y:13172 +#: preproc.y:13945 #, c-format msgid "CREATE TABLE AS cannot specify INTO" msgstr "CREATE TABLE AS non può specificare INTO" -#: preproc.y:13208 +#: preproc.y:13981 #, c-format msgid "expected \"@\", found \"%s\"" msgstr "atteso \"@\", trovato \"%s\"" -#: preproc.y:13220 +#: preproc.y:13993 #, c-format msgid "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are supported" msgstr "soltanto i protocolli \"tcp\" e \"unix\" ed il tipo database \"postgresql\" sono supportati" -#: preproc.y:13223 +#: preproc.y:13996 #, c-format msgid "expected \"://\", found \"%s\"" msgstr "atteso \"://\", trovato \"%s\"" -#: preproc.y:13228 +#: preproc.y:14001 #, c-format msgid "Unix-domain sockets only work on \"localhost\" but not on \"%s\"" msgstr "i socket di dominio Unix funzionano solo con \"localhost\" ma non con \"%s\"" -#: preproc.y:13254 +#: preproc.y:14027 #, c-format msgid "expected \"postgresql\", found \"%s\"" msgstr "atteso \"postgresql\", trovato \"%s\"" -#: preproc.y:13257 +#: preproc.y:14030 #, c-format msgid "invalid connection type: %s" msgstr "tipo di connessione non valido: %s" -#: preproc.y:13266 +#: preproc.y:14039 #, c-format msgid "expected \"@\" or \"://\", found \"%s\"" msgstr "atteso \"@\" oppure \"://\", trovato \"%s\"" -#: preproc.y:13341 preproc.y:13359 +#: preproc.y:14114 preproc.y:14132 #, c-format msgid "invalid data type" msgstr "tipo dato non valido" -#: preproc.y:13370 preproc.y:13387 +#: preproc.y:14143 preproc.y:14160 #, c-format msgid "incomplete statement" msgstr "istruzione incompleta" -#: preproc.y:13373 preproc.y:13390 +#: preproc.y:14146 preproc.y:14163 #, c-format msgid "unrecognized token \"%s\"" msgstr "token \"%s\" sconosciuto" -#: preproc.y:13664 +#: preproc.y:14437 #, c-format msgid "only data types numeric and decimal have precision/scale argument" msgstr "solo i dati di tipo numeric e decimal hanno argomento precisione/scala" -#: preproc.y:13676 +#: preproc.y:14449 #, c-format msgid "interval specification not allowed here" msgstr "specificazione di intervallo non permessa qui" -#: preproc.y:13828 preproc.y:13880 +#: preproc.y:14601 preproc.y:14653 #, c-format msgid "too many levels in nested structure/union definition" msgstr "troppi livelli nidificati nella definizione della struttura/unione" -#: preproc.y:14019 +#: preproc.y:14792 #, c-format msgid "pointers to varchar are not implemented" msgstr "i puntatori a varchar non sono implementati" -#: preproc.y:14206 preproc.y:14231 +#: preproc.y:14979 preproc.y:15004 #, c-format msgid "using unsupported DESCRIBE statement" msgstr "si sta utilizzando una istruzione DESCRIBE non supportata" -#: preproc.y:14478 +#: preproc.y:15251 #, c-format msgid "initializer not allowed in EXEC SQL VAR command" msgstr "initializer non è permesso nel comando EXEC SQL VAR" -#: preproc.y:14790 +#: preproc.y:15562 #, c-format msgid "arrays of indicators are not allowed on input" msgstr "array di indicatori non sono permessi" -#: preproc.y:15011 +#: preproc.y:15783 #, c-format msgid "operator not allowed in variable definition" msgstr "operatore non permesso nella definizione di variabile" #. translator: %s is typically the translation of "syntax error" -#: preproc.y:15049 +#: preproc.y:15821 #, c-format msgid "%s at or near \"%s\"" msgstr "%s a o presso \"%s\"" @@ -639,34 +639,34 @@ msgstr "la variabile \"%s\" non è un array" msgid "variable \"%s\" is not declared" msgstr "la variabile \"%s\" non è stata dichiarata" -#: variable.c:492 +#: variable.c:494 #, c-format msgid "indicator variable must have an integer type" msgstr "il tipo di variabile di un indicatore deve essere intero" -#: variable.c:504 +#: variable.c:506 #, c-format msgid "unrecognized data type name \"%s\"" msgstr "tipo di dato chiamato \"%s\" è sconosciuto" -#: variable.c:515 variable.c:523 variable.c:540 variable.c:543 +#: variable.c:517 variable.c:525 variable.c:542 variable.c:545 #, c-format msgid "multidimensional arrays are not supported" msgstr "gli array multidimensionali non sono supportati" -#: variable.c:532 +#: variable.c:534 #, c-format msgid "multilevel pointers (more than 2 levels) are not supported; found %d level" msgid_plural "multilevel pointers (more than 2 levels) are not supported; found %d levels" msgstr[0] "puntatori a più livelli (più di 2) non sono supportati; trovato %d livello" msgstr[1] "puntatori a più livelli (più di 2) non sono supportati; trovati %d livelli" -#: variable.c:537 +#: variable.c:539 #, c-format msgid "pointer to pointer is not supported for this data type" msgstr "il puntatore a puntatore non è supportato per questo tipo di dato" -#: variable.c:557 +#: variable.c:559 #, c-format msgid "multidimensional arrays for structures are not supported" msgstr "gli array multidimensionali per strutture non sono supportati" diff --git a/src/interfaces/ecpg/preproc/po/ja.po b/src/interfaces/ecpg/preproc/po/ja.po index 68aa91caa4..e5abc66181 100644 --- a/src/interfaces/ecpg/preproc/po/ja.po +++ b/src/interfaces/ecpg/preproc/po/ja.po @@ -5,11 +5,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.0 beta 3\n" +"Project-Id-Version: PostgreSQL 9.6.3 \n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2013-08-18 09:56+0900\n" -"PO-Revision-Date: 2010-07-21 18:37+0900\n" -"Last-Translator: HOTTA Michihide \n" +"POT-Creation-Date: 2017-04-03 13:17+0900\n" +"PO-Revision-Date: 2017-02-01 18:37+0900\n" +"Last-Translator: Ideriha Takeshi \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -27,27 +27,27 @@ msgstr "変数\"%s\"ã¯æ•°å€¤åž‹ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" msgid "descriptor \"%s\" does not exist" msgstr "%s記述å­ã¯å­˜åœ¨ã—ã¾ã›ã‚“" -#: descriptor.c:161 descriptor.c:210 +#: descriptor.c:161 descriptor.c:213 #, c-format msgid "descriptor header item \"%d\" does not exist" msgstr "記述å­ãƒ˜ãƒƒãƒ€é …ç›®%dã¯å­˜åœ¨ã—ã¾ã›ã‚“" -#: descriptor.c:182 +#: descriptor.c:183 #, c-format msgid "nullable is always 1" msgstr "nullableã¯å¸¸ã«1ã§ã™" -#: descriptor.c:185 +#: descriptor.c:186 #, c-format msgid "key_member is always 0" msgstr "key_memberã¯å¸¸ã«0ã§ã™" -#: descriptor.c:277 +#: descriptor.c:280 #, c-format msgid "descriptor item \"%s\" is not implemented" msgstr "記述å­é …ç›®%sã¯å®Ÿè£…ã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: descriptor.c:287 +#: descriptor.c:290 #, c-format msgid "descriptor item \"%s\" cannot be set" msgstr "記述å­é …ç›®%sã¯è¨­å®šã§ãã¾ã›ã‚“" @@ -146,8 +146,8 @@ msgstr " -t トランザクションã®è‡ªå‹•ã‚³ãƒŸãƒƒãƒˆã‚’有効 #: ecpg.c:57 #, c-format -msgid " --version output version information, then exit\n" -msgstr " --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を出力ã—ã€çµ‚了ã—ã¾ã™\n" +msgid " -V, --version output version information, then exit\n" +msgstr " -V, --version ãƒãƒ¼ã‚¸ãƒ§ãƒ³æƒ…報を表示ã—ã€çµ‚了ã—ã¾ã™\n" #: ecpg.c:58 #, c-format @@ -174,142 +174,152 @@ msgstr "" "\n" "ä¸å…·åˆã¯ã«å ±å‘Šã—ã¦ãã ã•ã„。\n" -#: ecpg.c:182 ecpg.c:333 ecpg.c:343 +#: ecpg.c:139 +#, c-format +msgid "%s: could not locate my own executable path\n" +msgstr "%s: 自身ã®å®Ÿè¡Œå¯èƒ½ãƒ‘スを見ã¤ã‘られã¾ã›ã‚“ã§ã—ãŸ\n" + +#: ecpg.c:175 ecpg.c:327 ecpg.c:337 #, c-format msgid "%s: could not open file \"%s\": %s\n" msgstr "%s: ファイル\"%s\"をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: ecpg.c:221 ecpg.c:234 ecpg.c:250 ecpg.c:275 +#: ecpg.c:214 ecpg.c:227 ecpg.c:243 ecpg.c:268 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "詳細ã¯\"%s --help\"を実行ã—ã¦ãã ã•ã„。\n" -#: ecpg.c:245 +#: ecpg.c:238 #, c-format msgid "%s: parser debug support (-d) not available\n" msgstr "%s: パーサデãƒãƒƒã‚°ã®ã‚µãƒãƒ¼ãƒˆ(-d)を利用ã§ãã¾ã›ã‚“\n" -#: ecpg.c:263 +#: ecpg.c:256 #, c-format msgid "%s, the PostgreSQL embedded C preprocessor, version %d.%d.%d\n" msgstr "%s PostgreSQL埋込ã¿C言語プリプロセッサ ãƒãƒ¼ã‚¸ãƒ§ãƒ³%d.%d.%d\n" -#: ecpg.c:265 +#: ecpg.c:258 #, c-format msgid "EXEC SQL INCLUDE ... search starts here:\n" msgstr "EXEC SQL INCLUDE ... 検索ãŒå§‹ã¾ã‚Šã¾ã™\n" -#: ecpg.c:268 +#: ecpg.c:261 #, c-format msgid "end of search list\n" msgstr "検索リストã®çµ‚端ã§ã™\n" -#: ecpg.c:274 +#: ecpg.c:267 #, c-format msgid "%s: no input files specified\n" msgstr "%s: 入力ファイルãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: ecpg.c:466 +#: ecpg.c:460 #, c-format msgid "cursor \"%s\" has been declared but not opened" msgstr "カーソル%sã¯å®£è¨€ã•ã‚Œã¾ã—ãŸãŒã€ã‚ªãƒ¼ãƒ—ンã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: ecpg.c:479 preproc.y:109 +#: ecpg.c:473 preproc.y:127 #, c-format msgid "could not remove output file \"%s\"\n" msgstr "出力ファイル\"%s\"を削除ã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: pgc.l:403 +#: pgc.l:432 #, c-format msgid "unterminated /* comment" msgstr "/*コメントãŒé–‰ã˜ã¦ã„ã¾ã›ã‚“" -#: pgc.l:416 +#: pgc.l:445 #, c-format msgid "invalid bit string literal" msgstr "無効ãªãƒ“ット列リテラルã§ã™" -#: pgc.l:425 +#: pgc.l:454 #, c-format msgid "unterminated bit string literal" msgstr "ビット文字列リテラルã®çµ‚端ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:441 +#: pgc.l:470 #, c-format msgid "unterminated hexadecimal string literal" msgstr "16進数文字列リテラルã®çµ‚端ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:519 +#: pgc.l:548 #, c-format msgid "unterminated quoted string" msgstr "文字列ã®å¼•ç”¨ç¬¦ãŒé–‰ã˜ã¦ã„ã¾ã›ã‚“" -#: pgc.l:574 pgc.l:587 +#: pgc.l:606 pgc.l:619 #, c-format msgid "zero-length delimited identifier" msgstr "区切りã¤ã識別å­ã®é•·ã•ãŒã‚¼ãƒ­ã§ã™" -#: pgc.l:595 +#: pgc.l:627 #, c-format msgid "unterminated quoted identifier" msgstr "識別å­ã®å¼•ç”¨ç¬¦ãŒé–‰ã˜ã¦ã„ã¾ã›ã‚“" -#: pgc.l:941 +#: pgc.l:882 +#, c-format +msgid "nested /* ... */ comments" +msgstr "入れå­ã«ãªã£ãŸã‚³ãƒ¡ãƒ³ãƒˆ /* ... */ ã§ã™" + +#: pgc.l:975 #, c-format msgid "missing identifier in EXEC SQL UNDEF command" msgstr "EXEC SQL UNDEFコマンドã«ãŠã„ã¦è­˜åˆ¥å­ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:987 pgc.l:1001 +#: pgc.l:1021 pgc.l:1035 #, c-format msgid "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"" msgstr "対応ã™ã‚‹\"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:990 pgc.l:1003 pgc.l:1179 +#: pgc.l:1024 pgc.l:1037 pgc.l:1213 #, c-format msgid "missing \"EXEC SQL ENDIF;\"" msgstr "\"EXEC SQL ENDIF;\"ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:1019 pgc.l:1038 +#: pgc.l:1053 pgc.l:1072 #, c-format msgid "more than one EXEC SQL ELSE" msgstr "1ã¤ä»¥ä¸Šã®EXEC SQL ELSE\"ãŒå­˜åœ¨ã—ã¾ã™" -#: pgc.l:1060 pgc.l:1074 +#: pgc.l:1094 pgc.l:1108 #, c-format msgid "unmatched EXEC SQL ENDIF" msgstr "EXEC SQL ENDIFã«å¯¾å¿œã™ã‚‹ã‚‚ã®ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:1094 +#: pgc.l:1128 #, c-format msgid "too many nested EXEC SQL IFDEF conditions" msgstr "入れå­çŠ¶ã®EXEC SQL IFDEFæ¡ä»¶ãŒå¤šã™ãŽã¾ã™" -#: pgc.l:1127 +#: pgc.l:1161 #, c-format msgid "missing identifier in EXEC SQL IFDEF command" msgstr "EXEC SQL IFDEFコマンドã«ãŠã„ã¦è­˜åˆ¥å­ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:1136 +#: pgc.l:1170 #, c-format msgid "missing identifier in EXEC SQL DEFINE command" msgstr "EXEC SQL DEFINEコマンドã«ãŠã„ã¦è­˜åˆ¥å­ãŒã‚ã‚Šã¾ã›ã‚“" -#: pgc.l:1169 +#: pgc.l:1203 #, c-format msgid "syntax error in EXEC SQL INCLUDE command" msgstr "EXEC SQL INCLUDEコマンドã«ãŠã„ã¦æ§‹æ–‡ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã™" -#: pgc.l:1218 +#: pgc.l:1252 #, c-format msgid "internal error: unreachable state; please report this to " msgstr "内部エラー: 到é”ã—ãªã„ã¯ãšã®çŠ¶æ…‹ã§ã™ã€‚ã¾ã§å ±å‘Šã—ã¦ãã ã•ã„" -#: pgc.l:1343 +#: pgc.l:1377 #, c-format msgid "Error: include path \"%s/%s\" is too long on line %d, skipping\n" msgstr "エラー:行番å·%3$dã®ã‚¤ãƒ³ã‚¯ãƒ«ãƒ¼ãƒ‰ãƒ‘ス\"%1$s/%2$s\"ãŒé•·ã™ãŽã¾ã™ã€‚無視ã—ã¾ã—ãŸã€‚\n" -#: pgc.l:1365 +#: pgc.l:1400 #, c-format msgid "could not open include file \"%s\" on line %d" msgstr "行番å·%2$dã®ã‚¤ãƒ³ã‚¯ãƒ«ãƒ¼ãƒ‰ãƒ•ã‚¡ã‚¤ãƒ«\"%1$s\"をオープンã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ" @@ -323,200 +333,205 @@ msgstr "構文エラー" msgid "WARNING: " msgstr "警告: " -#: preproc.y:85 +#: preproc.y:84 #, c-format msgid "ERROR: " msgstr "エラー: " -#: preproc.y:491 +#: preproc.y:508 #, c-format msgid "cursor \"%s\" does not exist" msgstr "カーソル\"%s\"ã¯å­˜åœ¨ã—ã¾ã›ã‚“" -#: preproc.y:520 +#: preproc.y:537 #, c-format msgid "initializer not allowed in type definition" msgstr "型定義ã§ã¯ã‚¤ãƒ‹ã‚·ãƒ£ãƒ©ã‚¤ã‚¶ã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:522 +#: preproc.y:539 #, c-format msgid "type name \"string\" is reserved in Informix mode" msgstr "åž‹å\"string\"ã¯Informixモードã§ã™ã§ã«äºˆç´„ã•ã‚Œã¦ã„ã¾ã™" -#: preproc.y:529 preproc.y:13638 +#: preproc.y:546 preproc.y:14626 #, c-format msgid "type \"%s\" is already defined" msgstr "\"%s\"åž‹ã¯ã™ã§ã«å®šç¾©ã•ã‚Œã¦ã„ã¾ã™" -#: preproc.y:553 preproc.y:14291 preproc.y:14612 variable.c:614 +#: preproc.y:570 preproc.y:15284 preproc.y:15604 variable.c:620 #, c-format msgid "multidimensional arrays for simple data types are not supported" msgstr "å˜ç´”ãªãƒ‡ãƒ¼ã‚¿åž‹ã®å¤šæ¬¡å…ƒé…列ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: preproc.y:1544 +#: preproc.y:1634 #, c-format msgid "AT option not allowed in CLOSE DATABASE statement" msgstr "CLOSE DATABASEæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:1747 +#: preproc.y:1849 #, c-format msgid "AT option not allowed in CONNECT statement" msgstr "CONNECTæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:1781 +#: preproc.y:1883 #, c-format msgid "AT option not allowed in DISCONNECT statement" msgstr "DISCONNECTæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:1836 +#: preproc.y:1938 #, c-format msgid "AT option not allowed in SET CONNECTION statement" msgstr "SET CONNECTIONæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:1858 +#: preproc.y:1960 #, c-format msgid "AT option not allowed in TYPE statement" msgstr "TYPEæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:1867 +#: preproc.y:1969 #, c-format msgid "AT option not allowed in VAR statement" msgstr "VARæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:1874 +#: preproc.y:1976 #, c-format msgid "AT option not allowed in WHENEVER statement" msgstr "WHENEVERæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:2122 preproc.y:2127 preproc.y:2242 preproc.y:3548 preproc.y:4800 -#: preproc.y:4809 preproc.y:5105 preproc.y:7552 preproc.y:7557 preproc.y:9965 -#: preproc.y:10555 +#: preproc.y:2228 preproc.y:2233 preproc.y:2349 preproc.y:3759 preproc.y:5173 +#: preproc.y:5182 preproc.y:5466 preproc.y:6902 preproc.y:8140 preproc.y:8145 +#: preproc.y:10776 preproc.y:11393 #, c-format msgid "unsupported feature will be passed to server" msgstr "サーãƒã«æœªã‚µãƒãƒ¼ãƒˆæ©Ÿèƒ½ãŒæ¸¡ã•ã‚Œã¾ã™" -#: preproc.y:2484 +#: preproc.y:2607 #, c-format msgid "SHOW ALL is not implemented" msgstr "SHOW ALLã¯å®Ÿè£…ã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: preproc.y:2940 +#: preproc.y:3147 #, c-format msgid "COPY FROM STDIN is not implemented" msgstr "COPY FROM STDINã¯å®Ÿè£…ã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: preproc.y:8381 preproc.y:13227 +#: preproc.y:9035 preproc.y:14215 #, c-format msgid "using variable \"%s\" in different declare statements is not supported" msgstr "ç•°ãªã£ãŸdeclareステートメントã«ãŠã‘る変数\"%s\"ã®ä½¿ç”¨ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: preproc.y:8383 preproc.y:13229 +#: preproc.y:9037 preproc.y:14217 #, c-format msgid "cursor \"%s\" is already defined" msgstr "カーソル\"%s\"ã¯ã™ã§ã«å®šç¾©ã•ã‚Œã¦ã„ã¾ã™" -#: preproc.y:8801 +#: preproc.y:9467 #, c-format msgid "no longer supported LIMIT #,# syntax passed to server" msgstr "サーãƒã«æ¸¡ã•ã‚Œã‚‹LIMIT #,#構文ã¯ã‚‚ã¯ã‚„サãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: preproc.y:9045 preproc.y:9052 +#: preproc.y:9775 preproc.y:9782 #, c-format msgid "subquery in FROM must have an alias" msgstr "FROMå¥ã®å‰¯å•ã„åˆã‚ã›ã¯åˆ¥åã‚’æŒãŸãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: preproc.y:12957 +#: preproc.y:13945 #, c-format msgid "CREATE TABLE AS cannot specify INTO" msgstr "CREATE TABLE ASã¯INTOを指定ã§ãã¾ã›ã‚“" -#: preproc.y:12993 +#: preproc.y:13981 #, c-format msgid "expected \"@\", found \"%s\"" msgstr "想定ã§ã¯\"@\"ã€çµæžœã§ã¯\"%s\"" -#: preproc.y:13005 +#: preproc.y:13993 #, c-format msgid "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are supported" msgstr "プロトコルã§ã¯\"tcp\"ãŠã‚ˆã³\"unix\"ã®ã¿ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ç¨®é¡žã§ã¯\"postgresql\"ã®ã¿ãŒã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã™" -#: preproc.y:13008 +#: preproc.y:13996 #, c-format msgid "expected \"://\", found \"%s\"" msgstr "想定ã§ã¯\"://\"ã€çµæžœã§ã¯\"%s\"" -#: preproc.y:13013 +#: preproc.y:14001 #, c-format msgid "Unix-domain sockets only work on \"localhost\" but not on \"%s\"" msgstr "Unixドメインソケットã¯\"localhost\"ã§ã®ã¿ã§å‹•ä½œã—ã€\"%s\"ã§ã¯å‹•ä½œã—ã¾ã›ã‚“" -#: preproc.y:13039 +#: preproc.y:14027 #, c-format msgid "expected \"postgresql\", found \"%s\"" msgstr "想定ã§ã¯\"postgresql\"ã€çµæžœã§ã¯\"%s\"" -#: preproc.y:13042 +#: preproc.y:14030 #, c-format msgid "invalid connection type: %s" msgstr "無効ãªæŽ¥ç¶šç¨®é¡ž: %s" -#: preproc.y:13051 +#: preproc.y:14039 #, c-format msgid "expected \"@\" or \"://\", found \"%s\"" msgstr "想定ã§ã¯\"@ã¾ãŸã¯\"\"://\"ã€çµæžœã§ã¯\"%s\"" -#: preproc.y:13126 preproc.y:13144 +#: preproc.y:14114 preproc.y:14132 #, c-format msgid "invalid data type" msgstr "無効ãªãƒ‡ãƒ¼ã‚¿åž‹" -#: preproc.y:13155 preproc.y:13172 +#: preproc.y:14143 preproc.y:14160 #, c-format msgid "incomplete statement" msgstr "ä¸å®Œå…¨ãªæ–‡" -#: preproc.y:13158 preproc.y:13175 +#: preproc.y:14146 preproc.y:14163 #, c-format msgid "unrecognized token \"%s\"" msgstr "èªè­˜ã§ããªã„トークン\"%s\"" -#: preproc.y:13449 +#: preproc.y:14437 #, c-format msgid "only data types numeric and decimal have precision/scale argument" msgstr "数値データ型ã¾ãŸã¯10進数データ型ã®ã¿ãŒç²¾åº¦/ä½å–り引数ã¨å–ã‚‹ã“ã¨ãŒã§ãã¾ã™" -#: preproc.y:13461 +#: preproc.y:14449 #, c-format msgid "interval specification not allowed here" msgstr "時間間隔ã®æŒ‡å®šã¯ã“ã“ã§ã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:13613 preproc.y:13665 +#: preproc.y:14601 preproc.y:14653 #, c-format msgid "too many levels in nested structure/union definition" msgstr "構造体/ユニオンã®å®šç¾©ã®å…¥ã‚Œå­ãƒ¬ãƒ™ãƒ«ãŒæ·±ã™ãŽã¾ã™" -#: preproc.y:13799 +#: preproc.y:14792 #, c-format msgid "pointers to varchar are not implemented" msgstr "varcharを指ã—示ã™ãƒã‚¤ãƒ³ã‚¿ã¯å®Ÿè£…ã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: preproc.y:13986 preproc.y:14011 +#: preproc.y:14979 preproc.y:15004 #, c-format msgid "using unsupported DESCRIBE statement" msgstr "未サãƒãƒ¼ãƒˆã®DESCRIBEæ–‡ã®ä½¿ç”¨" -#: preproc.y:14258 +#: preproc.y:15251 #, c-format msgid "initializer not allowed in EXEC SQL VAR command" msgstr "EXEC SQL VARコマンドã§ã¯ã‚¤ãƒ‹ã‚·ãƒ£ãƒ©ã‚¤ã‚¶ã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: preproc.y:14570 +#: preproc.y:15562 #, c-format msgid "arrays of indicators are not allowed on input" msgstr "指示å­é…列ã¯å…¥åŠ›ã¨ã—ã¦è¨±ã•ã‚Œã¾ã›ã‚“" +#: preproc.y:15783 +#, c-format +msgid "operator not allowed in variable definition" +msgstr "変数定義ã§ã¯æ¼”ç®—å­ã¯è¨±ã•ã‚Œã¾ã›ã‚“" + #. translator: %s is typically the translation of "syntax error" -#: preproc.y:14824 +#: preproc.y:15821 #, c-format msgid "%s at or near \"%s\"" msgstr "\"%2$s\"ã¾ãŸã¯ãã®è¿‘辺ã§%1$s" @@ -526,7 +541,7 @@ msgstr "\"%2$s\"ã¾ãŸã¯ãã®è¿‘辺ã§%1$s" msgid "out of memory" msgstr "メモリä¸è¶³ã§ã™" -#: type.c:212 type.c:593 +#: type.c:212 type.c:664 #, c-format msgid "unrecognized variable type code %d" msgstr "èªè­˜ã§ããªã„変数型コード%d" @@ -561,17 +576,17 @@ msgstr "é…列/ãƒã‚¤ãƒ³ã‚¿ç”¨ã®æŒ‡ç¤ºå­ã¯é…列/ãƒã‚¤ãƒ³ã‚¿ã§ãªã‘れ㰠msgid "nested arrays are not supported (except strings)" msgstr "入れå­çŠ¶ã®é…列ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã›ã‚“（文字列ã¯é™¤ãã¾ã™ï¼‰" -#: type.c:322 +#: type.c:331 #, c-format msgid "indicator for struct has to be a struct" msgstr "構造体用ã®æŒ‡ç¤ºå­ã¯æ§‹é€ ä½“ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: type.c:331 type.c:339 type.c:347 +#: type.c:351 type.c:372 type.c:392 #, c-format msgid "indicator for simple data type has to be simple" msgstr "å˜ç´”ãªãƒ‡ãƒ¼ã‚¿åž‹ç”¨ã®æŒ‡ç¤ºå­ã¯å˜ç´”ãªã‚‚ã®ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: type.c:652 +#: type.c:723 #, c-format msgid "unrecognized descriptor item code %d" msgstr "èªè­˜ã§ããªã„記述å­é …目コード%dã§ã™" @@ -606,49 +621,35 @@ msgstr "変数\"%s\"ã¯é…列ã§ã¯ã‚ã‚Šã¾ã›ã‚“" msgid "variable \"%s\" is not declared" msgstr "変数\"%s\"ã¯å®£è¨€ã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: variable.c:488 +#: variable.c:494 #, c-format msgid "indicator variable must have an integer type" msgstr "指示å­å¤‰æ•°ã¯æ•´æ•°åž‹ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: variable.c:500 +#: variable.c:506 #, c-format msgid "unrecognized data type name \"%s\"" msgstr "データ型å\"%s\"ã¯èªè­˜ã§ãã¾ã›ã‚“" -#: variable.c:511 variable.c:519 variable.c:536 variable.c:539 +#: variable.c:517 variable.c:525 variable.c:542 variable.c:545 #, c-format msgid "multidimensional arrays are not supported" msgstr "多次元é…列ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã›ã‚“" -#: variable.c:528 +#: variable.c:534 #, c-format msgid "multilevel pointers (more than 2 levels) are not supported; found %d level" msgid_plural "multilevel pointers (more than 2 levels) are not supported; found %d levels" msgstr[0] "複数レベルã®ãƒã‚¤ãƒ³ã‚¿ï¼ˆ2レベル以上）ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã›ã‚“。%dレベルã‚ã‚Šã¾ã™" msgstr[1] "複数レベルã®ãƒã‚¤ãƒ³ã‚¿ï¼ˆ2レベル以上）ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã›ã‚“。%dレベルã‚ã‚Šã¾ã™" -#: variable.c:533 +#: variable.c:539 #, c-format msgid "pointer to pointer is not supported for this data type" msgstr "ã“ã®ãƒ‡ãƒ¼ã‚¿åž‹ã§ã¯ã€ãƒã‚¤ãƒ³ã‚¿ã‚’指ã—示ã™ãƒã‚¤ãƒ³ã‚¿ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: variable.c:553 +#: variable.c:559 #, c-format msgid "multidimensional arrays for structures are not supported" msgstr "構造体ã®å¤šæ¬¡å…ƒé…列ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" -#~ msgid "AT option not allowed in DEALLOCATE statement" -#~ msgstr "DEALLOCATEæ–‡ã§ã¯ATオプションã¯è¨±ã•ã‚Œã¾ã›ã‚“" - -#~ msgid "COPY TO STDIN is not possible" -#~ msgstr "COPY TO STDINã¯ã§ãã¾ã›ã‚“" - -#~ msgid "COPY FROM STDOUT is not possible" -#~ msgstr "COPY FROM STDOUTã¯ã§ãã¾ã›ã‚“" - -#~ msgid "constraint declared INITIALLY DEFERRED must be DEFERRABLE" -#~ msgstr "INITIALLY DEFERREDã¨å®£è¨€ã•ã‚ŒãŸåˆ¶ç´„ã¯DEFERRABLEã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" - -#~ msgid " --help show this help, then exit\n" -#~ msgstr " --help ã“ã®ãƒ˜ãƒ«ãƒ—を表示ã—ã€çµ‚了ã—ã¾ã™\n" diff --git a/src/interfaces/libpq/po/de.po b/src/interfaces/libpq/po/de.po index 0b602fb6e0..b3cf79631b 100644 --- a/src/interfaces/libpq/po/de.po +++ b/src/interfaces/libpq/po/de.po @@ -7,8 +7,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-23 21:08+0000\n" -"PO-Revision-Date: 2016-04-23 21:21-0400\n" +"POT-Creation-Date: 2017-05-07 21:18+0000\n" +"PO-Revision-Date: 2017-05-08 08:22-0400\n" "Last-Translator: Peter Eisentraut \n" "Language-Team: German \n" "Language: de\n" @@ -29,13 +29,13 @@ msgid "duplicate GSS authentication request\n" msgstr "doppelte GSSAPI-Authentifizierungsanfrage\n" #: fe-auth.c:197 fe-auth.c:309 fe-auth.c:383 fe-auth.c:418 fe-auth.c:514 -#: fe-auth.c:780 fe-connect.c:707 fe-connect.c:904 fe-connect.c:1080 +#: fe-auth.c:793 fe-connect.c:707 fe-connect.c:904 fe-connect.c:1080 #: fe-connect.c:2091 fe-connect.c:3484 fe-connect.c:3736 fe-connect.c:3855 -#: fe-connect.c:4095 fe-connect.c:4175 fe-connect.c:4274 fe-connect.c:4526 -#: fe-connect.c:4555 fe-connect.c:4627 fe-connect.c:4645 fe-connect.c:4741 -#: fe-connect.c:5075 fe-connect.c:5225 fe-exec.c:2634 fe-exec.c:3381 -#: fe-exec.c:3546 fe-lobj.c:896 fe-protocol2.c:1206 fe-protocol3.c:992 -#: fe-protocol3.c:1678 fe-secure-openssl.c:551 fe-secure-openssl.c:1093 +#: fe-connect.c:4095 fe-connect.c:4175 fe-connect.c:4274 fe-connect.c:4530 +#: fe-connect.c:4559 fe-connect.c:4631 fe-connect.c:4649 fe-connect.c:4745 +#: fe-connect.c:5079 fe-connect.c:5229 fe-exec.c:2651 fe-exec.c:3398 +#: fe-exec.c:3563 fe-lobj.c:896 fe-protocol2.c:1206 fe-protocol3.c:992 +#: fe-protocol3.c:1678 fe-secure-openssl.c:515 fe-secure-openssl.c:1139 msgid "out of memory\n" msgstr "Speicher aufgebraucht\n" @@ -75,22 +75,26 @@ msgstr "Authentifizierung mit SSPI nicht unterstützt\n" msgid "Crypt authentication not supported\n" msgstr "Authentifizierung mit Crypt nicht unterstützt\n" -#: fe-auth.c:708 +#: fe-auth.c:716 +msgid "SCRAM authentication requires libpq version 10 or above\n" +msgstr "SCRAM-Authentifizierung benötigt libpq Version 10 oder neuer\n" + +#: fe-auth.c:721 #, c-format msgid "authentication method %u not supported\n" msgstr "Authentifizierungsmethode %u nicht unterstützt\n" -#: fe-auth.c:755 +#: fe-auth.c:768 #, c-format msgid "user name lookup failure: error code %lu\n" msgstr "Fehler beim Nachschlagen des Benutzernamens: Fehlercode %lu\n" -#: fe-auth.c:765 fe-connect.c:2018 +#: fe-auth.c:778 fe-connect.c:2018 #, c-format msgid "could not look up local user ID %d: %s\n" msgstr "konnte lokale Benutzer-ID %d nicht nachschlagen: %s\n" -#: fe-auth.c:770 fe-connect.c:2023 +#: fe-auth.c:783 fe-connect.c:2023 #, c-format msgid "local user with ID %d does not exist\n" msgstr "lokaler Benutzer mit ID %d existiert nicht\n" @@ -339,7 +343,7 @@ msgstr "Attribut hat keine Werte bei LDAP-Suche\n" msgid "missing \"=\" after \"%s\" in connection info string\n" msgstr "fehlendes »=« nach »%s« in der Zeichenkette der Verbindungsdaten\n" -#: fe-connect.c:3867 fe-connect.c:4494 fe-connect.c:5208 +#: fe-connect.c:3867 fe-connect.c:4498 fe-connect.c:5212 #, c-format msgid "invalid connection option \"%s\"\n" msgstr "ungültige Verbindungsoption »%s«\n" @@ -377,66 +381,66 @@ msgstr "Syntaxfehler in Servicedatei »%s«, Zeile %d\n" msgid "nested service specifications not supported in service file \"%s\", line %d\n" msgstr "geschachtelte »service«-Definitionen werden nicht unterstützt in Servicedatei »%s«, Zeile %d\n" -#: fe-connect.c:4752 +#: fe-connect.c:4756 #, c-format msgid "invalid URI propagated to internal parser routine: \"%s\"\n" msgstr "ungültige URI an interne Parserroutine weitergeleitet: »%s«\n" -#: fe-connect.c:4822 +#: fe-connect.c:4826 #, c-format msgid "end of string reached when looking for matching \"]\" in IPv6 host address in URI: \"%s\"\n" msgstr "Ende der Eingabezeichenkette gefunden beim Suchen nach passendem »]« in IPv6-Hostadresse in URI: »%s«\n" -#: fe-connect.c:4829 +#: fe-connect.c:4833 #, c-format msgid "IPv6 host address may not be empty in URI: \"%s\"\n" msgstr "IPv6-Hostadresse darf nicht leer sein in URI: »%s«\n" -#: fe-connect.c:4844 +#: fe-connect.c:4848 #, c-format msgid "unexpected character \"%c\" at position %d in URI (expected \":\" or \"/\"): \"%s\"\n" msgstr "unerwartetes Zeichen »%c« an Position %d in URI (»:« oder »/« erwartet): »%s«\n" -#: fe-connect.c:4958 +#: fe-connect.c:4962 #, c-format msgid "extra key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "zusätzliches Schlüssel/Wert-Trennzeichen »=« in URI-Query-Parameter: »%s«\n" -#: fe-connect.c:4978 +#: fe-connect.c:4982 #, c-format msgid "missing key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "fehlendes Schlüssel/Wert-Trennzeichen »=« in URI-Query-Parameter: »%s«\n" -#: fe-connect.c:5029 +#: fe-connect.c:5033 #, c-format msgid "invalid URI query parameter: \"%s\"\n" msgstr "ungültiger URI-Query-Parameter: »%s«\n" -#: fe-connect.c:5103 +#: fe-connect.c:5107 #, c-format msgid "invalid percent-encoded token: \"%s\"\n" msgstr "ungültiges Prozent-kodiertes Token: »%s«\n" -#: fe-connect.c:5113 +#: fe-connect.c:5117 #, c-format msgid "forbidden value %%00 in percent-encoded value: \"%s\"\n" msgstr "verbotener Wert %%00 in Prozent-kodiertem Wert: »%s«\n" -#: fe-connect.c:5447 +#: fe-connect.c:5451 msgid "connection pointer is NULL\n" msgstr "Verbindung ist ein NULL-Zeiger\n" -#: fe-connect.c:5745 +#: fe-connect.c:5749 #, c-format msgid "WARNING: password file \"%s\" is not a plain file\n" msgstr "WARNUNG: Passwortdatei »%s« ist keine normale Datei\n" -#: fe-connect.c:5754 +#: fe-connect.c:5758 #, c-format msgid "WARNING: password file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n" msgstr "WARNUNG: Passwortdatei »%s« erlaubt Lesezugriff für Gruppe oder Andere; Rechte sollten u=rw (0600) oder weniger sein\n" -#: fe-connect.c:5860 +#: fe-connect.c:5872 #, c-format msgid "password retrieved from file \"%s\"\n" msgstr "Passwort wurde aus Datei »%s« gelesen\n" @@ -445,98 +449,98 @@ msgstr "Passwort wurde aus Datei »%s« gelesen\n" msgid "NOTICE" msgstr "HINWEIS" -#: fe-exec.c:1123 fe-exec.c:1181 fe-exec.c:1227 +#: fe-exec.c:1141 fe-exec.c:1199 fe-exec.c:1245 msgid "command string is a null pointer\n" msgstr "Befehlszeichenkette ist ein NULL-Zeiger\n" -#: fe-exec.c:1187 fe-exec.c:1233 fe-exec.c:1328 +#: fe-exec.c:1205 fe-exec.c:1251 fe-exec.c:1346 msgid "number of parameters must be between 0 and 65535\n" msgstr "Anzahl der Parameter muss zwischen 0 und 65535 sein\n" -#: fe-exec.c:1221 fe-exec.c:1322 +#: fe-exec.c:1239 fe-exec.c:1340 msgid "statement name is a null pointer\n" msgstr "Anweisungsname ist ein NULL-Zeiger\n" -#: fe-exec.c:1241 fe-exec.c:1405 fe-exec.c:2123 fe-exec.c:2322 +#: fe-exec.c:1259 fe-exec.c:1422 fe-exec.c:2140 fe-exec.c:2339 msgid "function requires at least protocol version 3.0\n" msgstr "Funktion erfordert mindestens Protokollversion 3.0\n" -#: fe-exec.c:1359 +#: fe-exec.c:1377 msgid "no connection to the server\n" msgstr "keine Verbindung mit dem Server\n" -#: fe-exec.c:1366 +#: fe-exec.c:1384 msgid "another command is already in progress\n" msgstr "ein anderer Befehl ist bereits in Ausführung\n" -#: fe-exec.c:1481 +#: fe-exec.c:1498 msgid "length must be given for binary parameter\n" msgstr "für binäre Parameter muss eine Länge angegeben werden\n" -#: fe-exec.c:1753 +#: fe-exec.c:1770 #, c-format msgid "unexpected asyncStatus: %d\n" msgstr "unerwarteter asyncStatus: %d\n" -#: fe-exec.c:1773 +#: fe-exec.c:1790 #, c-format msgid "PGEventProc \"%s\" failed during PGEVT_RESULTCREATE event\n" msgstr "PGEventProc »%s« während PGEVT_RESULTCREATE-Ereignis fehlgeschlagen\n" -#: fe-exec.c:1933 +#: fe-exec.c:1950 msgid "COPY terminated by new PQexec" msgstr "COPY von neuem PQexec beendet" -#: fe-exec.c:1941 +#: fe-exec.c:1958 msgid "COPY IN state must be terminated first\n" msgstr "COPY-IN-Zustand muss erst beendet werden\n" -#: fe-exec.c:1961 +#: fe-exec.c:1978 msgid "COPY OUT state must be terminated first\n" msgstr "COPY-OUT-Zustand muss erst beendet werden\n" -#: fe-exec.c:1969 +#: fe-exec.c:1986 msgid "PQexec not allowed during COPY BOTH\n" msgstr "PQexec ist während COPY BOTH nicht erlaubt\n" -#: fe-exec.c:2212 fe-exec.c:2279 fe-exec.c:2369 fe-protocol2.c:1352 +#: fe-exec.c:2229 fe-exec.c:2296 fe-exec.c:2386 fe-protocol2.c:1352 #: fe-protocol3.c:1817 msgid "no COPY in progress\n" msgstr "keine COPY in Ausführung\n" -#: fe-exec.c:2559 +#: fe-exec.c:2576 msgid "connection in wrong state\n" msgstr "Verbindung im falschen Zustand\n" -#: fe-exec.c:2590 +#: fe-exec.c:2607 msgid "invalid ExecStatusType code" msgstr "ungültiger ExecStatusType-Kode" -#: fe-exec.c:2617 +#: fe-exec.c:2634 msgid "PGresult is not an error result\n" msgstr "PGresult ist kein Fehlerresultat\n" -#: fe-exec.c:2692 fe-exec.c:2715 +#: fe-exec.c:2709 fe-exec.c:2732 #, c-format msgid "column number %d is out of range 0..%d" msgstr "Spaltennummer %d ist außerhalb des zulässigen Bereichs 0..%d" -#: fe-exec.c:2708 +#: fe-exec.c:2725 #, c-format msgid "row number %d is out of range 0..%d" msgstr "Zeilennummer %d ist außerhalb des zulässigen Bereichs 0..%d" -#: fe-exec.c:2730 +#: fe-exec.c:2747 #, c-format msgid "parameter number %d is out of range 0..%d" msgstr "Parameternummer %d ist außerhalb des zulässigen Bereichs 0..%d" -#: fe-exec.c:3040 +#: fe-exec.c:3057 #, c-format msgid "could not interpret result from server: %s" msgstr "konnte Ergebnis vom Server nicht interpretieren: %s" -#: fe-exec.c:3279 fe-exec.c:3363 +#: fe-exec.c:3296 fe-exec.c:3380 msgid "incomplete multibyte character\n" msgstr "unvollständiges Mehrbyte-Zeichen\n" @@ -637,7 +641,7 @@ msgstr "Integer der Größe %lu wird von pqPutInt nicht unterstützt" msgid "connection not open\n" msgstr "Verbindung nicht offen\n" -#: fe-misc.c:812 fe-secure-openssl.c:270 fe-secure-openssl.c:379 +#: fe-misc.c:812 fe-secure-openssl.c:231 fe-secure-openssl.c:340 #: fe-secure.c:253 fe-secure.c:362 msgid "" "server closed the connection unexpectedly\n" @@ -837,153 +841,148 @@ msgstr "ZEILE %d: " msgid "PQgetline: not doing text COPY OUT\n" msgstr "PQgetline: Text COPY OUT nicht ausgeführt\n" -#: fe-secure-openssl.c:146 fe-secure-openssl.c:1030 fe-secure-openssl.c:1250 -#, c-format -msgid "could not acquire mutex: %s\n" -msgstr "konnte Mutex nicht sperren: %s\n" - -#: fe-secure-openssl.c:158 -#, c-format -msgid "could not establish SSL connection: %s\n" -msgstr "konnte SSL-Verbindung nicht aufbauen: %s\n" - -#: fe-secure-openssl.c:275 fe-secure-openssl.c:384 fe-secure-openssl.c:1376 +#: fe-secure-openssl.c:236 fe-secure-openssl.c:345 fe-secure-openssl.c:1323 #, c-format msgid "SSL SYSCALL error: %s\n" msgstr "SSL-SYSCALL-Fehler: %s\n" -#: fe-secure-openssl.c:282 fe-secure-openssl.c:391 fe-secure-openssl.c:1380 +#: fe-secure-openssl.c:243 fe-secure-openssl.c:352 fe-secure-openssl.c:1327 msgid "SSL SYSCALL error: EOF detected\n" msgstr "SSL-SYSCALL-Fehler: Dateiende entdeckt\n" -#: fe-secure-openssl.c:293 fe-secure-openssl.c:402 fe-secure-openssl.c:1389 +#: fe-secure-openssl.c:254 fe-secure-openssl.c:363 fe-secure-openssl.c:1336 #, c-format msgid "SSL error: %s\n" msgstr "SSL-Fehler: %s\n" -#: fe-secure-openssl.c:308 fe-secure-openssl.c:417 +#: fe-secure-openssl.c:269 fe-secure-openssl.c:378 msgid "SSL connection has been closed unexpectedly\n" msgstr "SSL-Verbindung wurde unerwartet geschlossen\n" -#: fe-secure-openssl.c:314 fe-secure-openssl.c:423 fe-secure-openssl.c:1398 +#: fe-secure-openssl.c:275 fe-secure-openssl.c:384 fe-secure-openssl.c:1345 #, c-format msgid "unrecognized SSL error code: %d\n" msgstr "unbekannter SSL-Fehlercode: %d\n" -#: fe-secure-openssl.c:535 +#: fe-secure-openssl.c:495 msgid "SSL certificate's name entry is missing\n" msgstr "Namenseintrag fehlt im SSL-Zertifikat\n" -#: fe-secure-openssl.c:565 +#: fe-secure-openssl.c:529 msgid "SSL certificate's name contains embedded null\n" msgstr "Name im SSL-Zertifikat enthält Null-Byte\n" -#: fe-secure-openssl.c:616 +#: fe-secure-openssl.c:580 msgid "host name must be specified for a verified SSL connection\n" msgstr "Hostname muss angegeben werden für eine verifizierte SSL-Verbindung\n" -#: fe-secure-openssl.c:716 +#: fe-secure-openssl.c:680 #, c-format msgid "server certificate for \"%s\" does not match host name \"%s\"\n" msgstr "Server-Zertifikat für »%s« stimmt nicht mit dem Hostnamen »%s« überein\n" -#: fe-secure-openssl.c:722 +#: fe-secure-openssl.c:686 msgid "could not get server's host name from server certificate\n" msgstr "konnte Hostnamen des Servers nicht aus dem Serverzertifikat ermitteln\n" -#: fe-secure-openssl.c:869 +#: fe-secure-openssl.c:930 #, c-format msgid "could not create SSL context: %s\n" msgstr "konnte SSL-Kontext nicht erzeugen: %s\n" -#: fe-secure-openssl.c:1000 +#: fe-secure-openssl.c:967 +#, c-format +msgid "could not read root certificate file \"%s\": %s\n" +msgstr "konnte Root-Zertifikat-Datei »%s« nicht lesen: %s\n" + +#: fe-secure-openssl.c:995 +#, c-format +msgid "SSL library does not support CRL certificates (file \"%s\")\n" +msgstr "SSL-Bibliothek unterstützt keine CRL-Zertifikate (Datei »%s«)\n" + +#: fe-secure-openssl.c:1023 +msgid "" +"could not get home directory to locate root certificate file\n" +"Either provide the file or change sslmode to disable server certificate verification.\n" +msgstr "" +"konnte Home-Verzeichnis nicht ermitteln, um Root-Zertifikat-Datei zu finden\n" +"Legen Sie entweder die Datei an oder ändern Sie sslmode, um die Ãœberprüfung der Serverzertifikate abzuschalten.\n" + +#: fe-secure-openssl.c:1027 +#, c-format +msgid "" +"root certificate file \"%s\" does not exist\n" +"Either provide the file or change sslmode to disable server certificate verification.\n" +msgstr "" +"Root-Zertifikat-Datei »%s« existiert nicht\n" +"Legen Sie entweder die Datei an oder ändern Sie sslmode, um die Ãœberprüfung der Serverzertifikate abzuschalten.\n" + +#: fe-secure-openssl.c:1058 #, c-format msgid "could not open certificate file \"%s\": %s\n" msgstr "konnte Zertifikatdatei »%s« nicht öffnen: %s\n" -#: fe-secure-openssl.c:1039 fe-secure-openssl.c:1054 +#: fe-secure-openssl.c:1077 #, c-format msgid "could not read certificate file \"%s\": %s\n" msgstr "konnte Zertifikatdatei »%s« nicht lesen: %s\n" -#: fe-secure-openssl.c:1109 +#: fe-secure-openssl.c:1101 +#, c-format +msgid "could not establish SSL connection: %s\n" +msgstr "konnte SSL-Verbindung nicht aufbauen: %s\n" + +#: fe-secure-openssl.c:1155 #, c-format msgid "could not load SSL engine \"%s\": %s\n" msgstr "konnte SSL-Engine »%s« nicht laden: %s\n" -#: fe-secure-openssl.c:1121 +#: fe-secure-openssl.c:1167 #, c-format msgid "could not initialize SSL engine \"%s\": %s\n" msgstr "konnte SSL-Engine »%s« nicht initialisieren: %s\n" -#: fe-secure-openssl.c:1137 +#: fe-secure-openssl.c:1183 #, c-format msgid "could not read private SSL key \"%s\" from engine \"%s\": %s\n" msgstr "konnte privaten SSL-Schlüssel »%s« nicht von Engine »%s« lesen: %s\n" -#: fe-secure-openssl.c:1151 +#: fe-secure-openssl.c:1197 #, c-format msgid "could not load private SSL key \"%s\" from engine \"%s\": %s\n" msgstr "konnte privaten SSL-Schlüssel »%s« nicht von Engine »%s« laden: %s\n" -#: fe-secure-openssl.c:1188 +#: fe-secure-openssl.c:1234 #, c-format msgid "certificate present, but not private key file \"%s\"\n" msgstr "Zertifikat vorhanden, aber keine private Schlüsseldatei »%s«\n" -#: fe-secure-openssl.c:1196 +#: fe-secure-openssl.c:1242 #, c-format msgid "private key file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n" msgstr "WARNUNG: private Schlüsseldatei »%s« erlaubt Lesezugriff für Gruppe oder Andere; Rechte sollten u=rw (0600) oder weniger sein\n" -#: fe-secure-openssl.c:1207 +#: fe-secure-openssl.c:1253 #, c-format msgid "could not load private key file \"%s\": %s\n" msgstr "konnte private Schlüsseldatei »%s« nicht laden: %s\n" -#: fe-secure-openssl.c:1221 +#: fe-secure-openssl.c:1267 #, c-format msgid "certificate does not match private key file \"%s\": %s\n" msgstr "Zertifikat passt nicht zur privaten Schlüsseldatei »%s«: %s\n" -#: fe-secure-openssl.c:1259 -#, c-format -msgid "could not read root certificate file \"%s\": %s\n" -msgstr "konnte Root-Zertifikat-Datei »%s« nicht lesen: %s\n" - -#: fe-secure-openssl.c:1289 -#, c-format -msgid "SSL library does not support CRL certificates (file \"%s\")\n" -msgstr "SSL-Bibliothek unterstützt keine CRL-Zertifikate (Datei »%s«)\n" - -#: fe-secure-openssl.c:1322 -msgid "" -"could not get home directory to locate root certificate file\n" -"Either provide the file or change sslmode to disable server certificate verification.\n" -msgstr "" -"konnte Home-Verzeichnis nicht ermitteln, um Root-Zertifikat-Datei zu finden\n" -"Legen Sie entweder die Datei an oder ändern Sie sslmode, um die Ãœberprüfung der Serverzertifikate abzuschalten.\n" - -#: fe-secure-openssl.c:1326 -#, c-format -msgid "" -"root certificate file \"%s\" does not exist\n" -"Either provide the file or change sslmode to disable server certificate verification.\n" -msgstr "" -"Root-Zertifikat-Datei »%s« existiert nicht\n" -"Legen Sie entweder die Datei an oder ändern Sie sslmode, um die Ãœberprüfung der Serverzertifikate abzuschalten.\n" - -#: fe-secure-openssl.c:1419 +#: fe-secure-openssl.c:1366 #, c-format msgid "certificate could not be obtained: %s\n" msgstr "Zertifikat konnte nicht ermittelt werden: %s\n" -#: fe-secure-openssl.c:1511 +#: fe-secure-openssl.c:1458 #, c-format msgid "no SSL error reported" msgstr "kein SSL-Fehler berichtet" -#: fe-secure-openssl.c:1520 +#: fe-secure-openssl.c:1467 #, c-format msgid "SSL error code %lu" msgstr "SSL-Fehlercode %lu" diff --git a/src/interfaces/libpq/po/it.po b/src/interfaces/libpq/po/it.po index cc3217dbec..db09aa300b 100644 --- a/src/interfaces/libpq/po/it.po +++ b/src/interfaces/libpq/po/it.po @@ -40,7 +40,7 @@ msgid "" msgstr "" "Project-Id-Version: libpq (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:08+0000\n" +"POT-Creation-Date: 2017-02-09 21:08+0000\n" "PO-Revision-Date: 2016-04-17 20:43+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" @@ -68,11 +68,11 @@ msgstr "richiesta di autenticazione GSS duplicata\n" #: fe-auth.c:197 fe-auth.c:309 fe-auth.c:383 fe-auth.c:418 fe-auth.c:514 #: fe-auth.c:780 fe-connect.c:707 fe-connect.c:904 fe-connect.c:1080 #: fe-connect.c:2091 fe-connect.c:3484 fe-connect.c:3736 fe-connect.c:3855 -#: fe-connect.c:4095 fe-connect.c:4175 fe-connect.c:4274 fe-connect.c:4526 -#: fe-connect.c:4555 fe-connect.c:4627 fe-connect.c:4645 fe-connect.c:4741 -#: fe-connect.c:5075 fe-connect.c:5225 fe-exec.c:2634 fe-exec.c:3381 -#: fe-exec.c:3546 fe-lobj.c:896 fe-protocol2.c:1206 fe-protocol3.c:992 -#: fe-protocol3.c:1678 fe-secure-openssl.c:551 fe-secure-openssl.c:1093 +#: fe-connect.c:4095 fe-connect.c:4175 fe-connect.c:4274 fe-connect.c:4530 +#: fe-connect.c:4559 fe-connect.c:4631 fe-connect.c:4649 fe-connect.c:4745 +#: fe-connect.c:5079 fe-connect.c:5229 fe-exec.c:2651 fe-exec.c:3398 +#: fe-exec.c:3563 fe-lobj.c:896 fe-protocol2.c:1206 fe-protocol3.c:992 +#: fe-protocol3.c:1678 fe-secure-openssl.c:515 fe-secure-openssl.c:1139 msgid "out of memory\n" msgstr "memoria esaurita\n" @@ -377,7 +377,7 @@ msgstr "l'attributo non ha valori nella ricerca LDAP\n" msgid "missing \"=\" after \"%s\" in connection info string\n" msgstr "manca \"=\" dopo \"%s\" nella stringa di connessione\n" -#: fe-connect.c:3867 fe-connect.c:4494 fe-connect.c:5208 +#: fe-connect.c:3867 fe-connect.c:4498 fe-connect.c:5212 #, c-format msgid "invalid connection option \"%s\"\n" msgstr "opzione di connessione errata \"%s\"\n" @@ -415,68 +415,68 @@ msgstr "errore di sintassi del file di servizio \"%s\", alla riga %d\n" msgid "nested service specifications not supported in service file \"%s\", line %d\n" msgstr "specifiche di servizio annidate non supportate nel file di servizio \"%s\", linea %d\n" -#: fe-connect.c:4752 +#: fe-connect.c:4756 #, c-format msgid "invalid URI propagated to internal parser routine: \"%s\"\n" msgstr "URI invalida propagata alla routine di parsing interna: \"%s\"\n" -#: fe-connect.c:4822 +#: fe-connect.c:4826 #, c-format msgid "end of string reached when looking for matching \"]\" in IPv6 host address in URI: \"%s\"\n" msgstr "fine stringa raggiunta cercando un \"]\" corrispondente nell'indirizzo host IPv6 nella URI: \"%s\"\n" -#: fe-connect.c:4829 +#: fe-connect.c:4833 #, c-format msgid "IPv6 host address may not be empty in URI: \"%s\"\n" msgstr "l'indirizzo host IPv6 non dev'essere assente nella URI: \"%s\"\n" -#: fe-connect.c:4844 +#: fe-connect.c:4848 #, c-format msgid "unexpected character \"%c\" at position %d in URI (expected \":\" or \"/\"): \"%s\"\n" msgstr "carattere inatteso \"%c\" in posizione %d nella uri URI (atteso \":\" oppure \"/\"): \"%s\"\n" -#: fe-connect.c:4958 +#: fe-connect.c:4962 #, c-format msgid "extra key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "separatore chiave/valore \"=\" in eccesso nei parametri della URI: \"%s\"\n" -#: fe-connect.c:4978 +#: fe-connect.c:4982 #, c-format msgid "missing key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "separatore chiave/valore \"=\" mancante nei parametri della URI: \"%s\"\n" -#: fe-connect.c:5029 +#: fe-connect.c:5033 #, c-format msgid "invalid URI query parameter: \"%s\"\n" msgstr "parametro URI non valido: \"%s\"\n" -#: fe-connect.c:5103 +#: fe-connect.c:5107 #, c-format msgid "invalid percent-encoded token: \"%s\"\n" msgstr "simbolo percent-encoded non valido \"%s\"\n" -#: fe-connect.c:5113 +#: fe-connect.c:5117 #, c-format msgid "forbidden value %%00 in percent-encoded value: \"%s\"\n" msgstr "valore non ammesso %%00 nel valore percent-encoded: \"%s\"\n" -#: fe-connect.c:5447 +#: fe-connect.c:5451 msgid "connection pointer is NULL\n" msgstr "il puntatore della connessione è NULL\n" -#: fe-connect.c:5745 +#: fe-connect.c:5749 #, c-format msgid "WARNING: password file \"%s\" is not a plain file\n" msgstr "ATTENZIONE: il file delle password \"%s\" non è un file regolare\n" -#: fe-connect.c:5754 +#: fe-connect.c:5758 #, c-format msgid "WARNING: password file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n" msgstr "" "ATTENZIONE: Il file delle password %s ha privilegi di accesso in lettura e scrittura per tutti;\n" "i permessi dovrebbero essere u=rw (0600) o inferiori\n" -#: fe-connect.c:5860 +#: fe-connect.c:5872 #, c-format msgid "password retrieved from file \"%s\"\n" msgstr "password ottenuta dal file \"%s\"\n" @@ -485,99 +485,99 @@ msgstr "password ottenuta dal file \"%s\"\n" msgid "NOTICE" msgstr "NOTIFICA" -#: fe-exec.c:1123 fe-exec.c:1181 fe-exec.c:1227 +#: fe-exec.c:1141 fe-exec.c:1199 fe-exec.c:1245 msgid "command string is a null pointer\n" msgstr "il testo del comando è un puntatore nullo\n" -#: fe-exec.c:1187 fe-exec.c:1233 fe-exec.c:1328 +#: fe-exec.c:1205 fe-exec.c:1251 fe-exec.c:1346 msgid "number of parameters must be between 0 and 65535\n" msgstr "il numero di parametri deve essere tra 0 e 65535\n" -#: fe-exec.c:1221 fe-exec.c:1322 +#: fe-exec.c:1239 fe-exec.c:1340 msgid "statement name is a null pointer\n" msgstr "il nome dell'istruzione è un puntatore nullo\n" -#: fe-exec.c:1241 fe-exec.c:1405 fe-exec.c:2123 fe-exec.c:2322 +#: fe-exec.c:1259 fe-exec.c:1422 fe-exec.c:2140 fe-exec.c:2339 msgid "function requires at least protocol version 3.0\n" msgstr "la funzione richiede almeno il protocollo versione 3.0\n" -#: fe-exec.c:1359 +#: fe-exec.c:1377 msgid "no connection to the server\n" msgstr "nessuna connessione al server\n" -#: fe-exec.c:1366 +#: fe-exec.c:1384 msgid "another command is already in progress\n" msgstr "un altro comando è in esecuzione\n" -#: fe-exec.c:1481 +#: fe-exec.c:1498 msgid "length must be given for binary parameter\n" msgstr "la lunghezza deve essere fornita per i parametri binari\n" -#: fe-exec.c:1753 +#: fe-exec.c:1770 #, c-format msgid "unexpected asyncStatus: %d\n" msgstr "asyncStatus imprevisto: %d\n" -#: fe-exec.c:1773 +#: fe-exec.c:1790 #, c-format msgid "PGEventProc \"%s\" failed during PGEVT_RESULTCREATE event\n" msgstr "PGEventProc \"%s\" fallito durante l'evento PGEVT_RESULTCREATE\n" -#: fe-exec.c:1933 +#: fe-exec.c:1950 msgid "COPY terminated by new PQexec" msgstr "COPY terminato da una nuova PQexec" -#: fe-exec.c:1941 +#: fe-exec.c:1958 msgid "COPY IN state must be terminated first\n" msgstr "lo stato COPY IN deve prima essere terminato\n" -#: fe-exec.c:1961 +#: fe-exec.c:1978 msgid "COPY OUT state must be terminated first\n" msgstr "lo stato COPY OUT deve prima essere terminato\n" # NON SONO ASSOLUTAMENTE CONVINTO! -#: fe-exec.c:1969 +#: fe-exec.c:1986 msgid "PQexec not allowed during COPY BOTH\n" msgstr "PQexec not consentito durante COPY BOTH\n" -#: fe-exec.c:2212 fe-exec.c:2279 fe-exec.c:2369 fe-protocol2.c:1352 +#: fe-exec.c:2229 fe-exec.c:2296 fe-exec.c:2386 fe-protocol2.c:1352 #: fe-protocol3.c:1817 msgid "no COPY in progress\n" msgstr "nessun comando COPY in corso\n" -#: fe-exec.c:2559 +#: fe-exec.c:2576 msgid "connection in wrong state\n" msgstr "la connessione è in uno stato errato\n" -#: fe-exec.c:2590 +#: fe-exec.c:2607 msgid "invalid ExecStatusType code" msgstr "codice ExecStatusType errato" -#: fe-exec.c:2617 +#: fe-exec.c:2634 msgid "PGresult is not an error result\n" msgstr "PGresult non è un risultato di errore\n" -#: fe-exec.c:2692 fe-exec.c:2715 +#: fe-exec.c:2709 fe-exec.c:2732 #, c-format msgid "column number %d is out of range 0..%d" msgstr "la colonna numero %d non è compreso tra 0 e %d" -#: fe-exec.c:2708 +#: fe-exec.c:2725 #, c-format msgid "row number %d is out of range 0..%d" msgstr "la riga numero %d non è compreso tra 0 e %d" -#: fe-exec.c:2730 +#: fe-exec.c:2747 #, c-format msgid "parameter number %d is out of range 0..%d" msgstr "il parametro numero %d non è compreso tra 0 e %d" -#: fe-exec.c:3040 +#: fe-exec.c:3057 #, c-format msgid "could not interpret result from server: %s" msgstr "errore nell'interpretazione del risultato dal server: %s" -#: fe-exec.c:3279 fe-exec.c:3363 +#: fe-exec.c:3296 fe-exec.c:3380 msgid "incomplete multibyte character\n" msgstr "carattere multibyte incompleto\n" @@ -678,7 +678,7 @@ msgstr "intero di dimensione %lu non supportato da pqPutInt" msgid "connection not open\n" msgstr "connessione non aperta\n" -#: fe-misc.c:812 fe-secure-openssl.c:270 fe-secure-openssl.c:379 +#: fe-misc.c:812 fe-secure-openssl.c:231 fe-secure-openssl.c:340 #: fe-secure.c:253 fe-secure.c:362 msgid "" "server closed the connection unexpectedly\n" @@ -717,9 +717,9 @@ msgstr "stato %c non valido, probabilmente indica una corruzione di memoria\n" msgid "message type 0x%02x arrived from server while idle" msgstr "messaggio tipo 0x%02x arrivato dal server mentre era inattivo" -#: fe-protocol2.c:503 fe-protocol2.c:538 fe-protocol2.c:1049 -#: fe-protocol3.c:209 fe-protocol3.c:236 fe-protocol3.c:253 fe-protocol3.c:333 -#: fe-protocol3.c:728 fe-protocol3.c:951 +#: fe-protocol2.c:503 fe-protocol2.c:538 fe-protocol2.c:1049 fe-protocol3.c:209 +#: fe-protocol3.c:236 fe-protocol3.c:253 fe-protocol3.c:333 fe-protocol3.c:728 +#: fe-protocol3.c:951 msgid "out of memory" msgstr "memoria esaurita" @@ -878,153 +878,148 @@ msgstr "RIGA %d: " msgid "PQgetline: not doing text COPY OUT\n" msgstr "PQgetline: COPY OUT testuale ignorato\n" -#: fe-secure-openssl.c:146 fe-secure-openssl.c:1030 fe-secure-openssl.c:1250 -#, c-format -msgid "could not acquire mutex: %s\n" -msgstr "acquisizione del mutex fallita: %s\n" - -#: fe-secure-openssl.c:158 -#, c-format -msgid "could not establish SSL connection: %s\n" -msgstr "non è stato possibile stabilire una connessione SSL: %s\n" - -#: fe-secure-openssl.c:275 fe-secure-openssl.c:384 fe-secure-openssl.c:1376 +#: fe-secure-openssl.c:236 fe-secure-openssl.c:345 fe-secure-openssl.c:1323 #, c-format msgid "SSL SYSCALL error: %s\n" msgstr "errore SSL SYSCALL: %s\n" -#: fe-secure-openssl.c:282 fe-secure-openssl.c:391 fe-secure-openssl.c:1380 +#: fe-secure-openssl.c:243 fe-secure-openssl.c:352 fe-secure-openssl.c:1327 msgid "SSL SYSCALL error: EOF detected\n" msgstr "errore SSL SYSCALL: rilevato EOF\n" -#: fe-secure-openssl.c:293 fe-secure-openssl.c:402 fe-secure-openssl.c:1389 +#: fe-secure-openssl.c:254 fe-secure-openssl.c:363 fe-secure-openssl.c:1336 #, c-format msgid "SSL error: %s\n" msgstr "errore SSL: %s\n" -#: fe-secure-openssl.c:308 fe-secure-openssl.c:417 +#: fe-secure-openssl.c:269 fe-secure-openssl.c:378 msgid "SSL connection has been closed unexpectedly\n" msgstr "la connessione SSL è stata chiusa inaspettatamente\n" -#: fe-secure-openssl.c:314 fe-secure-openssl.c:423 fe-secure-openssl.c:1398 +#: fe-secure-openssl.c:275 fe-secure-openssl.c:384 fe-secure-openssl.c:1345 #, c-format msgid "unrecognized SSL error code: %d\n" msgstr "codice di errore SSL sconosciuto: %d\n" -#: fe-secure-openssl.c:535 +#: fe-secure-openssl.c:495 msgid "SSL certificate's name entry is missing\n" msgstr "manca il nome del certificato SSL\n" -#: fe-secure-openssl.c:565 +#: fe-secure-openssl.c:529 msgid "SSL certificate's name contains embedded null\n" msgstr "Il nome del certificato SSL contiene null\n" -#: fe-secure-openssl.c:616 +#: fe-secure-openssl.c:580 msgid "host name must be specified for a verified SSL connection\n" msgstr "il nome dell'host dev'essere specificato per una connessione SSL verificata\n" -#: fe-secure-openssl.c:716 +#: fe-secure-openssl.c:680 #, c-format msgid "server certificate for \"%s\" does not match host name \"%s\"\n" msgstr "il certificato per il server \"%s\" non combacia col nome host \"%s\"\n" -#: fe-secure-openssl.c:722 +#: fe-secure-openssl.c:686 msgid "could not get server's host name from server certificate\n" msgstr "impossibile ottenere il nome dell'host del server dal certificato del server\n" -#: fe-secure-openssl.c:869 +#: fe-secure-openssl.c:930 #, c-format msgid "could not create SSL context: %s\n" msgstr "creazione del contesto SSL fallita: %s\n" -#: fe-secure-openssl.c:1000 +#: fe-secure-openssl.c:967 +#, c-format +msgid "could not read root certificate file \"%s\": %s\n" +msgstr "lettura del file di certificato radice \"%s\" fallita: %s\n" + +#: fe-secure-openssl.c:995 +#, c-format +msgid "SSL library does not support CRL certificates (file \"%s\")\n" +msgstr "la libreria SSL non supporta i certificati di tipo CRL (file \"%s\")\n" + +#: fe-secure-openssl.c:1023 +msgid "" +"could not get home directory to locate root certificate file\n" +"Either provide the file or change sslmode to disable server certificate verification.\n" +msgstr "" +"directory utente non trovata per la locazione del file di certificato radice\n" +"Per favore fornisci il file oppure cambia sslmode per disabilitare la verifica del certificato del server.\n" + +#: fe-secure-openssl.c:1027 +#, c-format +msgid "" +"root certificate file \"%s\" does not exist\n" +"Either provide the file or change sslmode to disable server certificate verification.\n" +msgstr "" +"il file \"%s\" del certificato radice non esiste\n" +"Per favore fornisci il file oppure cambia sslmode per disabilitare la verifica del certificato del server.\n" + +#: fe-secure-openssl.c:1058 #, c-format msgid "could not open certificate file \"%s\": %s\n" msgstr "apertura del file di certificato \"%s\" fallita: %s\n" -#: fe-secure-openssl.c:1039 fe-secure-openssl.c:1054 +#: fe-secure-openssl.c:1077 #, c-format msgid "could not read certificate file \"%s\": %s\n" msgstr "lettura del file di certificato \"%s\" fallita: %s\n" -#: fe-secure-openssl.c:1109 +#: fe-secure-openssl.c:1101 +#, c-format +msgid "could not establish SSL connection: %s\n" +msgstr "non è stato possibile stabilire una connessione SSL: %s\n" + +#: fe-secure-openssl.c:1155 #, c-format msgid "could not load SSL engine \"%s\": %s\n" msgstr "caricamento del motore SSL \"%s\" fallito: %s\n" -#: fe-secure-openssl.c:1121 +#: fe-secure-openssl.c:1167 #, c-format msgid "could not initialize SSL engine \"%s\": %s\n" msgstr "inizializzazione del motore SSL \"%s\" fallita: %s\n" -#: fe-secure-openssl.c:1137 +#: fe-secure-openssl.c:1183 #, c-format msgid "could not read private SSL key \"%s\" from engine \"%s\": %s\n" msgstr "lettura del file della chiave privata SSL \"%s\" dal motore \"%s\" fallita: %s\n" -#: fe-secure-openssl.c:1151 +#: fe-secure-openssl.c:1197 #, c-format msgid "could not load private SSL key \"%s\" from engine \"%s\": %s\n" msgstr "caricamento della chiave privata SSL \"%s\" dal motore \"%s\" fallito: %s\n" -#: fe-secure-openssl.c:1188 +#: fe-secure-openssl.c:1234 #, c-format msgid "certificate present, but not private key file \"%s\"\n" msgstr "certificato trovato, ma non la chiave privata \"%s\"\n" -#: fe-secure-openssl.c:1196 +#: fe-secure-openssl.c:1242 #, c-format msgid "private key file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n" msgstr "Il file della chiave privata \"%s\" ha privilegi di accesso in lettura e scrittura per tutti; i permessi dovrebbero essere u=rw (0600) o inferiori\n" -#: fe-secure-openssl.c:1207 +#: fe-secure-openssl.c:1253 #, c-format msgid "could not load private key file \"%s\": %s\n" msgstr "caricamento del file della chiave privata \"%s\" fallito: %s\n" -#: fe-secure-openssl.c:1221 +#: fe-secure-openssl.c:1267 #, c-format msgid "certificate does not match private key file \"%s\": %s\n" msgstr "il certificato non corrisponde con il file della chiave privata \"%s\": %s\n" -#: fe-secure-openssl.c:1259 -#, c-format -msgid "could not read root certificate file \"%s\": %s\n" -msgstr "lettura del file di certificato radice \"%s\" fallita: %s\n" - -#: fe-secure-openssl.c:1289 -#, c-format -msgid "SSL library does not support CRL certificates (file \"%s\")\n" -msgstr "la libreria SSL non supporta i certificati di tipo CRL (file \"%s\")\n" - -#: fe-secure-openssl.c:1322 -msgid "" -"could not get home directory to locate root certificate file\n" -"Either provide the file or change sslmode to disable server certificate verification.\n" -msgstr "" -"directory utente non trovata per la locazione del file di certificato radice\n" -"Per favore fornisci il file oppure cambia sslmode per disabilitare la verifica del certificato del server.\n" - -#: fe-secure-openssl.c:1326 -#, c-format -msgid "" -"root certificate file \"%s\" does not exist\n" -"Either provide the file or change sslmode to disable server certificate verification.\n" -msgstr "" -"il file \"%s\" del certificato radice non esiste\n" -"Per favore fornisci il file oppure cambia sslmode per disabilitare la verifica del certificato del server.\n" - -#: fe-secure-openssl.c:1419 +#: fe-secure-openssl.c:1366 #, c-format msgid "certificate could not be obtained: %s\n" msgstr "non è stato possibile possibile ottenere il certificato: %s\n" -#: fe-secure-openssl.c:1511 +#: fe-secure-openssl.c:1458 #, c-format msgid "no SSL error reported" msgstr "nessun errore SSL riportato" -#: fe-secure-openssl.c:1520 +#: fe-secure-openssl.c:1467 #, c-format msgid "SSL error code %lu" msgstr "codice di errore SSL: %lu" diff --git a/src/interfaces/libpq/po/ja.po b/src/interfaces/libpq/po/ja.po index b7335b639b..be9bf4bf01 100644 --- a/src/interfaces/libpq/po/ja.po +++ b/src/interfaces/libpq/po/ja.po @@ -3,11 +3,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.1 beta 2\n" +"Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2013-08-18 12:53+0900\n" +"POT-Creation-Date: 2017-04-11 10:23+0900\n" "PO-Revision-Date: 2014-08-16 16:38+0900\n" -"Last-Translator: HOTTA Michihide \n" +"Last-Translator: OkanoNaoki \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -15,100 +15,101 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" -#: fe-auth.c:210 fe-auth.c:429 fe-auth.c:656 -msgid "host name must be specified\n" -msgstr "ホストåを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" - -#: fe-auth.c:240 -#, c-format -msgid "could not set socket to blocking mode: %s\n" -msgstr "ソケットをブロッキングモードã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: fe-auth.c:258 fe-auth.c:262 -#, c-format -msgid "Kerberos 5 authentication rejected: %*s\n" -msgstr "Kerberos 5èªè¨¼ãŒæ‹’絶ã•ã‚Œã¾ã—ãŸ: %*s\n" - -#: fe-auth.c:288 -#, c-format -#| msgid "could not restore non-blocking mode on socket: %s\n" -msgid "could not restore nonblocking mode on socket: %s\n" -msgstr "ソケットをéžãƒ–ロッキングモードã«æˆ»ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: fe-auth.c:400 +#: fe-auth.c:148 msgid "GSSAPI continuation error" msgstr "GSSAI続行エラー" -#: fe-auth.c:436 +#: fe-auth.c:177 fe-auth.c:412 +msgid "host name must be specified\n" +msgstr "ホストåを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" + +#: fe-auth.c:184 msgid "duplicate GSS authentication request\n" msgstr "é‡è¤‡ã™ã‚‹GSSèªè¨¼è¦æ±‚\n" -#: fe-auth.c:456 +#: fe-auth.c:197 fe-auth.c:309 fe-auth.c:383 fe-auth.c:418 fe-auth.c:514 +#: fe-auth.c:780 fe-connect.c:707 fe-connect.c:904 fe-connect.c:1080 +#: fe-connect.c:2091 fe-connect.c:3484 fe-connect.c:3736 fe-connect.c:3855 +#: fe-connect.c:4095 fe-connect.c:4175 fe-connect.c:4274 fe-connect.c:4530 +#: fe-connect.c:4559 fe-connect.c:4631 fe-connect.c:4649 fe-connect.c:4745 +#: fe-connect.c:5079 fe-connect.c:5229 fe-exec.c:2651 fe-exec.c:3398 +#: fe-exec.c:3563 fe-lobj.c:896 fe-protocol2.c:1206 fe-protocol3.c:992 +#: fe-protocol3.c:1678 fe-secure-openssl.c:515 fe-secure-openssl.c:1139 +msgid "out of memory\n" +msgstr "メモリä¸è¶³ã§ã™\n" + +#: fe-auth.c:210 msgid "GSSAPI name import error" msgstr "GSSAPIåã®ã‚¤ãƒ³ãƒãƒ¼ãƒˆã‚¨ãƒ©ãƒ¼" -#: fe-auth.c:542 +#: fe-auth.c:298 msgid "SSPI continuation error" msgstr "SSPI続行エラー" -#: fe-auth.c:553 fe-auth.c:627 fe-auth.c:662 fe-auth.c:758 fe-connect.c:2005 -#: fe-connect.c:3393 fe-connect.c:3611 fe-connect.c:4023 fe-connect.c:4118 -#: fe-connect.c:4383 fe-connect.c:4452 fe-connect.c:4469 fe-connect.c:4560 -#: fe-connect.c:4910 fe-connect.c:5060 fe-exec.c:3296 fe-exec.c:3461 -#: fe-lobj.c:896 fe-protocol2.c:1181 fe-protocol3.c:1544 fe-secure.c:786 -#: fe-secure.c:1184 -msgid "out of memory\n" -msgstr "メモリä¸è¶³ã§ã™\n" - -#: fe-auth.c:642 +#: fe-auth.c:398 msgid "could not acquire SSPI credentials" msgstr "SSPI資格を入手ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: fe-auth.c:733 +#: fe-auth.c:489 msgid "SCM_CRED authentication method not supported\n" msgstr "SCM_CREDèªè¨¼æ–¹å¼ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-auth.c:809 +#: fe-auth.c:565 msgid "Kerberos 4 authentication not supported\n" msgstr "Kerberos 4èªè¨¼ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-auth.c:825 +#: fe-auth.c:570 msgid "Kerberos 5 authentication not supported\n" msgstr "Kerberos 5èªè¨¼ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-auth.c:897 +#: fe-auth.c:641 msgid "GSSAPI authentication not supported\n" msgstr "GSSAPIèªè¨¼ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-auth.c:929 +#: fe-auth.c:673 msgid "SSPI authentication not supported\n" msgstr "SSPIèªè¨¼ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-auth.c:937 +#: fe-auth.c:681 msgid "Crypt authentication not supported\n" msgstr "Cryptèªè¨¼ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-auth.c:964 +#: fe-auth.c:708 #, c-format msgid "authentication method %u not supported\n" msgstr "èªè¨¼æ–¹å¼%uã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-connect.c:798 +#: fe-auth.c:755 +#, c-format +msgid "user name lookup failure: error code %lu\n" +msgstr "ユーザåã®æ¤œç´¢ã«å¤±æ•—: エラーコード %lu\n" + +#: fe-auth.c:765 fe-connect.c:2018 +#, c-format +msgid "could not look up local user ID %d: %s\n" +msgstr "ローカルユーザID %d ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: fe-auth.c:770 fe-connect.c:2023 +#, c-format +msgid "local user with ID %d does not exist\n" +msgstr "ID %d ã‚’æŒã¤ãƒ­ãƒ¼ã‚«ãƒ«ãƒ¦ãƒ¼ã‚¶ã¯å­˜åœ¨ã—ã¾ã›ã‚“\n" + +#: fe-connect.c:846 #, c-format msgid "invalid sslmode value: \"%s\"\n" msgstr "sslmodeã®å€¤ãŒç„¡åŠ¹ã§ã™: \"%s\"\n" -#: fe-connect.c:819 +#: fe-connect.c:867 #, c-format msgid "sslmode value \"%s\" invalid when SSL support is not compiled in\n" msgstr "SSLサãƒãƒ¼ãƒˆãŒçµ„ã¿è¾¼ã¾ã‚Œã¦ã„ãªã„å ´åˆsslmodeã®å€¤\"%s\"ã¯ç„¡åŠ¹ã§ã™\n" -#: fe-connect.c:1023 +#: fe-connect.c:1104 #, c-format msgid "could not set socket to TCP no delay mode: %s\n" msgstr "TCPソケットをéžé…延モードã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1053 +#: fe-connect.c:1134 #, c-format msgid "" "could not connect to server: %s\n" @@ -119,7 +120,7 @@ msgstr "" " ローカルã«ã‚µãƒ¼ãƒãŒç¨¼å‹•ã—ã¦ã„ã¾ã™ã‹?\n" " Unixドメインソケット\"%s\"ã§é€šä¿¡ã‚’å—ã‘付ã‘ã¦ã„ã¾ã™ã‹?\n" -#: fe-connect.c:1108 +#: fe-connect.c:1189 #, c-format msgid "" "could not connect to server: %s\n" @@ -130,7 +131,7 @@ msgstr "" "\tサーãƒã¯ãƒ›ã‚¹ãƒˆ \"%s\" (%s) ã§ç¨¼å‹•ã—ã¦ãŠã‚Šã€\n" "\tã¾ãŸã€ãƒãƒ¼ãƒˆ %s 㧠TCP/IP 接続をå—ã‘付ã‘ã¦ã„ã¾ã™ã‹?\n" -#: fe-connect.c:1117 +#: fe-connect.c:1198 #, c-format msgid "" "could not connect to server: %s\n" @@ -141,399 +142,400 @@ msgstr "" "\tサーãƒã¯ãƒ›ã‚¹ãƒˆ\"%s\"ã§ç¨¼å‹•ã—ã¦ã„ã¾ã™ã‹?\n" "\tã¾ãŸã€ãƒãƒ¼ãƒˆ%sã§TCP/IP接続をå—ã‘付ã‘ã¦ã„ã¾ã™ã‹?\n" -#: fe-connect.c:1168 +#: fe-connect.c:1249 #, c-format msgid "setsockopt(TCP_KEEPIDLE) failed: %s\n" msgstr "setsockopt(TCP_KEEPIDLE)ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: fe-connect.c:1181 +#: fe-connect.c:1262 #, c-format msgid "setsockopt(TCP_KEEPALIVE) failed: %s\n" msgstr "setsockopt(TCP_KEEPALIVE)ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: fe-connect.c:1213 +#: fe-connect.c:1294 #, c-format msgid "setsockopt(TCP_KEEPINTVL) failed: %s\n" msgstr "setsockopt(TCP_KEEPINTVL)ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: fe-connect.c:1245 +#: fe-connect.c:1326 #, c-format msgid "setsockopt(TCP_KEEPCNT) failed: %s\n" msgstr "setsockopt(TCP_KEEPCNT)ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: fe-connect.c:1293 +#: fe-connect.c:1374 #, c-format msgid "WSAIoctl(SIO_KEEPALIVE_VALS) failed: %ui\n" msgstr "WSAIoctl(SIO_KEEPALIVE_VALS)ã«å¤±æ•—ã—ã¾ã—ãŸ:%ui\n" -#: fe-connect.c:1345 +#: fe-connect.c:1426 #, c-format msgid "invalid port number: \"%s\"\n" msgstr "無効ãªãƒãƒ¼ãƒˆç•ªå·ã§ã™: \"%s\"\n" -#: fe-connect.c:1378 +#: fe-connect.c:1459 #, c-format -#| msgid "backup label too long (max %d bytes)" msgid "Unix-domain socket path \"%s\" is too long (maximum %d bytes)\n" msgstr "Unixドメインソケットã®ãƒ‘ス\"%s\"ãŒé•·ã™ãŽã¾ã™(最大 %d ãƒã‚¤ãƒˆ)\n" -#: fe-connect.c:1397 +#: fe-connect.c:1478 #, c-format msgid "could not translate host name \"%s\" to address: %s\n" msgstr "ホストå\"%s\"をアドレスã«å¤‰æ›ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1401 +#: fe-connect.c:1482 #, c-format msgid "could not translate Unix-domain socket path \"%s\" to address: %s\n" msgstr "Unixドメインソケットã®ãƒ‘ス\"%s\"をアドレスã«å¤‰æ›ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1606 +#: fe-connect.c:1687 msgid "invalid connection state, probably indicative of memory corruption\n" msgstr "接続状態ãŒç„¡åŠ¹ã§ã™ã€‚メモリ障害ã®å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™\n" -#: fe-connect.c:1647 +#: fe-connect.c:1727 #, c-format msgid "could not create socket: %s\n" msgstr "ソケットを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1669 +#: fe-connect.c:1749 #, c-format -#| msgid "could not set socket to non-blocking mode: %s\n" msgid "could not set socket to nonblocking mode: %s\n" msgstr "ソケットをéžãƒ–ロッキングモードã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1680 +#: fe-connect.c:1760 #, c-format msgid "could not set socket to close-on-exec mode: %s\n" msgstr "ソケットをclose-on-execモードã«è¨­å®šã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1699 +#: fe-connect.c:1779 msgid "keepalives parameter must be an integer\n" msgstr "keepaliveã®ãƒ‘ラメータã¯æ•´æ•°ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:1712 +#: fe-connect.c:1792 #, c-format msgid "setsockopt(SO_KEEPALIVE) failed: %s\n" msgstr "setsockopt(SO_KEEPALIVE)ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: fe-connect.c:1849 +#: fe-connect.c:1929 #, c-format msgid "could not get socket error status: %s\n" msgstr "ソケットã®ã‚¨ãƒ©ãƒ¼çŠ¶æ…‹ã‚’入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1883 +#: fe-connect.c:1963 #, c-format msgid "could not get client address from socket: %s\n" msgstr "ソケットã‹ã‚‰ã‚¯ãƒ©ã‚¤ã‚¢ãƒ³ãƒˆã‚¢ãƒ‰ãƒ¬ã‚¹ã‚’入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1924 +#: fe-connect.c:2005 msgid "requirepeer parameter is not supported on this platform\n" msgstr "ã“ã®ãƒ—ラットフォームã§ã¯ requirepeer パラメータã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-connect.c:1927 +#: fe-connect.c:2008 #, c-format msgid "could not get peer credentials: %s\n" msgstr "ピアã®è³‡æ ¼è¨¼æ˜Žã‚’入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:1937 -#, c-format -msgid "local user with ID %d does not exist\n" -msgstr "ID %d ã‚’æŒã¤ãƒ­ãƒ¼ã‚«ãƒ«ãƒ¦ãƒ¼ã‚¶ã¯å­˜åœ¨ã—ã¾ã›ã‚“\n" - -#: fe-connect.c:1945 +#: fe-connect.c:2031 #, c-format msgid "requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n" msgstr "requirepeerã¯\"%s\"を指定ã—ã¦ã„ã¾ã™ãŒã€å®Ÿéš›ã®ãƒ”ã‚¢åã¯\"%s\"ã§ã™\n" -#: fe-connect.c:1979 +#: fe-connect.c:2065 #, c-format msgid "could not send SSL negotiation packet: %s\n" msgstr "SSL調åœãƒ‘ケットをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:2018 +#: fe-connect.c:2104 #, c-format msgid "could not send startup packet: %s\n" msgstr "開始パケットをé€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-connect.c:2088 +#: fe-connect.c:2174 msgid "server does not support SSL, but SSL was required\n" msgstr "サーãƒã¯SSLをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“ãŒã€SSLãŒè¦æ±‚ã•ã‚Œã¾ã—ãŸ\n" -#: fe-connect.c:2114 +#: fe-connect.c:2200 #, c-format msgid "received invalid response to SSL negotiation: %c\n" msgstr "SSL調åœã«å¯¾ã—ã¦ç„¡åŠ¹ãªå¿œç­”ã‚’å—ä¿¡ã—ã¾ã—ãŸ: %c\n" -#: fe-connect.c:2189 fe-connect.c:2222 +#: fe-connect.c:2275 fe-connect.c:2308 #, c-format msgid "expected authentication request from server, but received %c\n" msgstr "サーãƒã‹ã‚‰ã®èªè¨¼è¦æ±‚を想定ã—ã¦ã„ã¾ã—ãŸãŒã€%cã‚’å—ä¿¡ã—ã¾ã—ãŸ\n" -#: fe-connect.c:2389 +#: fe-connect.c:2475 #, c-format msgid "out of memory allocating GSSAPI buffer (%d)" msgstr "GSSAPIãƒãƒƒãƒ•ã‚¡ã®å‰²ã‚Šå½“ã¦æ™‚ã®ãƒ¡ãƒ¢ãƒªä¸è¶³(%d)" -#: fe-connect.c:2474 +#: fe-connect.c:2560 msgid "unexpected message from server during startup\n" msgstr "起動時ã«ã‚µãƒ¼ãƒã‹ã‚‰æƒ³å®šå¤–ã®ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ãŒã‚ã‚Šã¾ã—ãŸ\n" -#: fe-connect.c:2568 +#: fe-connect.c:2654 #, c-format msgid "invalid connection state %d, probably indicative of memory corruption\n" msgstr "接続状態%dãŒç„¡åŠ¹ã§ã™ã€‚メモリ障害ã®å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™\n" -#: fe-connect.c:3001 fe-connect.c:3061 +#: fe-connect.c:3090 fe-connect.c:3150 #, c-format msgid "PGEventProc \"%s\" failed during PGEVT_CONNRESET event\n" msgstr "PGEVT_CONNRESETイベント中ã«PGEventProc \"%s\"ã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: fe-connect.c:3406 +#: fe-connect.c:3497 #, c-format msgid "invalid LDAP URL \"%s\": scheme must be ldap://\n" msgstr "無効ãªLDAP URL\"%s\":スキーマã¯ldap://ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:3421 +#: fe-connect.c:3512 #, c-format msgid "invalid LDAP URL \"%s\": missing distinguished name\n" msgstr "無効ãªLDAP URL \"%s\": 区別åãŒã‚ã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:3432 fe-connect.c:3485 +#: fe-connect.c:3523 fe-connect.c:3576 #, c-format msgid "invalid LDAP URL \"%s\": must have exactly one attribute\n" msgstr "無効ãªLDAP URL \"%s\": 正確ã«1ã¤ã®å±žæ€§ã‚’æŒãŸãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:3442 fe-connect.c:3499 +#: fe-connect.c:3533 fe-connect.c:3590 #, c-format msgid "invalid LDAP URL \"%s\": must have search scope (base/one/sub)\n" msgstr "無効ãªLDAP URL \"%s\": 検索スコープ(base/one/sub)ã‚’æŒãŸãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:3453 +#: fe-connect.c:3544 #, c-format msgid "invalid LDAP URL \"%s\": no filter\n" msgstr "無効ãªLDAP URL \"%s\": フィルタãŒã‚ã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:3474 +#: fe-connect.c:3565 #, c-format msgid "invalid LDAP URL \"%s\": invalid port number\n" msgstr "無効ãªLDAP URL \"%s\": ãƒãƒ¼ãƒˆç•ªå·ãŒç„¡åŠ¹ã§ã™\n" -#: fe-connect.c:3508 +#: fe-connect.c:3599 msgid "could not create LDAP structure\n" msgstr "LDAP構造体を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ\n" -#: fe-connect.c:3550 +#: fe-connect.c:3675 #, c-format msgid "lookup on LDAP server failed: %s\n" msgstr "LDAPサーãƒã§æ¤œç´¢ã«å¤±æ•—ã—ã¾ã—ãŸ: %s\n" -#: fe-connect.c:3561 +#: fe-connect.c:3686 msgid "more than one entry found on LDAP lookup\n" msgstr "LDAP検索çµæžœãŒè¤‡æ•°ã‚ã‚Šã¾ã—ãŸ\n" -#: fe-connect.c:3562 fe-connect.c:3574 +#: fe-connect.c:3687 fe-connect.c:3699 msgid "no entry found on LDAP lookup\n" msgstr "LDAP検索çµæžœãŒç©ºã§ã—ãŸ\n" -#: fe-connect.c:3585 fe-connect.c:3598 +#: fe-connect.c:3710 fe-connect.c:3723 msgid "attribute has no values on LDAP lookup\n" msgstr "LDAP検索ã§å±žæ€§ã«å€¤ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: fe-connect.c:3650 fe-connect.c:3669 fe-connect.c:4157 +#: fe-connect.c:3775 fe-connect.c:3794 fe-connect.c:4313 #, c-format msgid "missing \"=\" after \"%s\" in connection info string\n" msgstr "接続情報文字列ã«ãŠã„ã¦\"%s\"ã®å¾Œã«\"=\"ãŒã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: fe-connect.c:3733 fe-connect.c:4337 fe-connect.c:5042 +#: fe-connect.c:3867 fe-connect.c:4498 fe-connect.c:5212 #, c-format msgid "invalid connection option \"%s\"\n" msgstr "接続オプション\"%s\"ã¯ç„¡åŠ¹ã§ã™\n" -#: fe-connect.c:3749 fe-connect.c:4206 +#: fe-connect.c:3883 fe-connect.c:4362 msgid "unterminated quoted string in connection info string\n" msgstr "接続情報文字列ã«ãŠã„ã¦é–‰ã˜ã¦ã„ãªã„引用符ãŒã‚ã‚Šã¾ã—ãŸ\n" -#: fe-connect.c:3788 +#: fe-connect.c:3923 msgid "could not get home directory to locate service definition file" msgstr "サーãƒè¨­å®šãƒ•ã‚¡ã‚¤ãƒ«ã®å ´æ‰€ã‚’特定ã—よã†ã¨ã—ã¾ã—ãŸãŒã€ãƒ›ãƒ¼ãƒ ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’å–å¾—ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚" -#: fe-connect.c:3821 +#: fe-connect.c:3956 #, c-format msgid "definition of service \"%s\" not found\n" msgstr "サービス定義\"%s\"ãŒã¿ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:3844 +#: fe-connect.c:3979 #, c-format msgid "service file \"%s\" not found\n" msgstr "サービスファイル\"%s\"ãŒã¿ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:3857 +#: fe-connect.c:3992 #, c-format msgid "line %d too long in service file \"%s\"\n" msgstr "サービスファイル\"%2$s\"ã®è¡Œ%1$dãŒé•·ã™ãŽã¾ã™ã€‚\n" -#: fe-connect.c:3928 fe-connect.c:3955 +#: fe-connect.c:4063 fe-connect.c:4107 #, c-format msgid "syntax error in service file \"%s\", line %d\n" msgstr "サービスファイル\"%s\"ã®è¡Œ%dã«æ§‹æ–‡ã‚¨ãƒ©ãƒ¼ãŒã‚ã‚Šã¾ã™\n" -#: fe-connect.c:4570 +#: fe-connect.c:4074 +#, c-format +msgid "nested service specifications not supported in service file \"%s\", line %d\n" +msgstr "サービスファイル\"%s\"ã®è¡Œ%dã«ãŠã„ã¦ã€å…¥ã‚Œå­ã®ã‚µãƒ¼ãƒ“ス指定ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“\n" + +#: fe-connect.c:4756 #, c-format msgid "invalid URI propagated to internal parser routine: \"%s\"\n" msgstr "内部パーサ処ç†ã¸ä¼ã‚ã£ãŸç„¡åŠ¹ãªURI: \"%s\"\n" -#: fe-connect.c:4640 +#: fe-connect.c:4826 #, c-format msgid "end of string reached when looking for matching \"]\" in IPv6 host address in URI: \"%s\"\n" msgstr "URI \"%s\"内ã®IPv6ホストアドレスã«ãŠã„ã¦å¯¾å¿œã™ã‚‹\"]\"を探ã—ã¦ã„ã‚‹é–“ã«æ–‡å­—列ãŒçµ‚ã‚ã‚Šã¾ã—ãŸ\n" -#: fe-connect.c:4647 +#: fe-connect.c:4833 #, c-format msgid "IPv6 host address may not be empty in URI: \"%s\"\n" msgstr "URI \"%s\"内ã®IPv6ホストアドレスãŒç©ºã§ã‚ã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™\n" -#: fe-connect.c:4662 +#: fe-connect.c:4848 #, c-format msgid "unexpected character \"%c\" at position %d in URI (expected \":\" or \"/\"): \"%s\"\n" msgstr "URI（\":\"ã¨\"/\"を除ã）内ã®ä½ç½®%2$dã«æƒ³å®šå¤–ã®\"%1$c\"文字ãŒã‚ã‚Šã¾ã™: \"%3$s\"\n" -#: fe-connect.c:4776 +#: fe-connect.c:4962 #, c-format msgid "extra key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "URIå•ã„åˆã‚ã›ãƒ‘ラメータ内ã«ä½™åˆ†ãªã‚­ãƒ¼ã¨å€¤ã‚’分ã‘ã‚‹\"=\"ãŒã‚ã‚Šã¾ã™: \"%s\"\n" -#: fe-connect.c:4796 +#: fe-connect.c:4982 #, c-format msgid "missing key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "URIå•ã„åˆã‚ã›ãƒ‘ラメータ内ã«ã‚­ãƒ¼ã¨å€¤ã‚’分ã‘ã‚‹\\\"=\\\"ãŒã‚ã‚Šã¾ã¾ã›ã‚“: \"%s\"\n" -#: fe-connect.c:4867 +#: fe-connect.c:5033 #, c-format msgid "invalid URI query parameter: \"%s\"\n" msgstr "無効ãªURIå•ã„åˆã‚ã›ãƒ‘ラメータ:\"%s\"\n" -#: fe-connect.c:4937 +#: fe-connect.c:5107 #, c-format msgid "invalid percent-encoded token: \"%s\"\n" msgstr "無効ãªãƒ‘ーセント符å·åŒ–トークン: \"%s\"\n" -#: fe-connect.c:4947 +#: fe-connect.c:5117 #, c-format msgid "forbidden value %%00 in percent-encoded value: \"%s\"\n" msgstr "パーセント符å·åŒ–ã•ã‚ŒãŸå€¤ã§ã¯%%00値ã¯è¨±ã•ã‚Œã¾ã›ã‚“: \"%s\"\n" -#: fe-connect.c:5270 +#: fe-connect.c:5451 msgid "connection pointer is NULL\n" msgstr "接続ãƒã‚¤ãƒ³ã‚¿ã¯NULLã§ã™\n" -#: fe-connect.c:5547 +#: fe-connect.c:5749 #, c-format msgid "WARNING: password file \"%s\" is not a plain file\n" msgstr "WARNING: パスワードファイル\"%s\"ãŒãƒ†ã‚­ã‚¹ãƒˆãƒ•ã‚¡ã‚¤ãƒ«ã§ã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: fe-connect.c:5556 +#: fe-connect.c:5758 #, c-format msgid "WARNING: password file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n" msgstr "警告: パスワードファイル \"%s\" ãŒã‚°ãƒ«ãƒ¼ãƒ—メンãƒã‚‚ã—ãã¯ä»–ã®ãƒ¦ãƒ¼ã‚¶ã‹ã‚‰èª­ã‚る状態ã«ãªã£ã¦ã„ã¾ã™ã€‚ã“ã®æ¨©é™ã¯u=rw (0600)以下ã«ã™ã¹ãã§ã™\n" -#: fe-connect.c:5656 +#: fe-connect.c:5872 #, c-format msgid "password retrieved from file \"%s\"\n" msgstr "ファイル\"%s\"ã‹ã‚‰ãƒ‘スワードを読ã¿è¾¼ã¿ã¾ã—ãŸ\n" -#: fe-exec.c:824 +#: fe-exec.c:826 msgid "NOTICE" msgstr "注æ„" -#: fe-exec.c:1120 fe-exec.c:1178 fe-exec.c:1224 +#: fe-exec.c:1141 fe-exec.c:1199 fe-exec.c:1245 msgid "command string is a null pointer\n" msgstr "コマンド文字列ãŒãƒŒãƒ«ãƒã‚¤ãƒ³ã‚¿ã§ã™\n" -#: fe-exec.c:1184 fe-exec.c:1230 fe-exec.c:1325 -#| msgid "interval(%d) precision must be between %d and %d" +#: fe-exec.c:1205 fe-exec.c:1251 fe-exec.c:1346 msgid "number of parameters must be between 0 and 65535\n" msgstr "パラメータ数ã¯0ã‹ã‚‰65535ã¾ã§ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-exec.c:1218 fe-exec.c:1319 +#: fe-exec.c:1239 fe-exec.c:1340 msgid "statement name is a null pointer\n" msgstr "æ–‡ã®åå‰ãŒãƒŒãƒ«ãƒã‚¤ãƒ³ã‚¿ã§ã™\n" -#: fe-exec.c:1238 fe-exec.c:1402 fe-exec.c:2096 fe-exec.c:2295 +#: fe-exec.c:1259 fe-exec.c:1422 fe-exec.c:2140 fe-exec.c:2339 msgid "function requires at least protocol version 3.0\n" msgstr "関数ã¯å°‘ãªãã¨ã‚‚プロトコルãƒãƒ¼ã‚¸ãƒ§ãƒ³3.0ãŒå¿…è¦ã§ã™\n" -#: fe-exec.c:1356 +#: fe-exec.c:1377 msgid "no connection to the server\n" msgstr "サーãƒã¸ã®æŽ¥ç¶šãŒã‚ã‚Šã¾ã›ã‚“\n" -#: fe-exec.c:1363 +#: fe-exec.c:1384 msgid "another command is already in progress\n" msgstr "ä»–ã®ã‚³ãƒžãƒ³ãƒ‰ã‚’処ç†ã—ã¦ã„ã¾ã™\n" -#: fe-exec.c:1478 +#: fe-exec.c:1498 msgid "length must be given for binary parameter\n" msgstr "ãƒã‚¤ãƒŠãƒªãƒ‘ラメータã«ã¯é•·ã•ã‚’指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-exec.c:1756 +#: fe-exec.c:1770 #, c-format msgid "unexpected asyncStatus: %d\n" msgstr "想定外ã®asyncStatus: %d\n" -#: fe-exec.c:1776 +#: fe-exec.c:1790 #, c-format msgid "PGEventProc \"%s\" failed during PGEVT_RESULTCREATE event\n" msgstr "PGEVT_RESULTCREATEイベント中ã«PGEventProc \"%s\"ã«å¤±æ•—ã—ã¾ã—ãŸ\n" -#: fe-exec.c:1906 +#: fe-exec.c:1950 msgid "COPY terminated by new PQexec" msgstr "æ–°ãŸãªPQexec\"ã«ã‚ˆã‚ŠCOPYãŒçµ‚了ã—ã¾ã—ãŸ" -#: fe-exec.c:1914 +#: fe-exec.c:1958 msgid "COPY IN state must be terminated first\n" msgstr "ã¾ãšCOPY IN状態を終了ã•ã›ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-exec.c:1934 +#: fe-exec.c:1978 msgid "COPY OUT state must be terminated first\n" msgstr "ã¾ãšCOPY OUT状態を終了ã•ã›ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-exec.c:1942 +#: fe-exec.c:1986 msgid "PQexec not allowed during COPY BOTH\n" msgstr "COPY BOTH 実行中㮠PQexec ã¯è¨±å¯ã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-exec.c:2185 fe-exec.c:2252 fe-exec.c:2342 fe-protocol2.c:1327 -#: fe-protocol3.c:1683 +#: fe-exec.c:2229 fe-exec.c:2296 fe-exec.c:2386 fe-protocol2.c:1352 +#: fe-protocol3.c:1817 msgid "no COPY in progress\n" msgstr "実行中ã®COPYã¯ã‚ã‚Šã¾ã›ã‚“\n" -#: fe-exec.c:2534 +#: fe-exec.c:2576 msgid "connection in wrong state\n" msgstr "接続状態ãŒç•°å¸¸ã§ã™\n" -#: fe-exec.c:2565 +#: fe-exec.c:2607 msgid "invalid ExecStatusType code" msgstr "ExecStatusTypeコードãŒç„¡åŠ¹ã§ã™" -#: fe-exec.c:2629 fe-exec.c:2652 +#: fe-exec.c:2634 +msgid "PGresult is not an error result\n" +msgstr "PGresultã¯ã‚¨ãƒ©ãƒ¼ã®çµæžœã§ã¯ã‚ã‚Šã¾ã›ã‚“\n" + +#: fe-exec.c:2709 fe-exec.c:2732 #, c-format msgid "column number %d is out of range 0..%d" msgstr "列番å·%dã¯0..%dã®ç¯„囲を超ãˆã¦ã„ã¾ã™" -#: fe-exec.c:2645 +#: fe-exec.c:2725 #, c-format msgid "row number %d is out of range 0..%d" msgstr "行番å·%dã¯0..%dã®ç¯„囲を超ãˆã¦ã„ã¾ã™" -#: fe-exec.c:2667 +#: fe-exec.c:2747 #, c-format msgid "parameter number %d is out of range 0..%d" msgstr "パラメータ%dã¯0..%dã®ç¯„囲を超ãˆã¦ã„ã¾ã™" -#: fe-exec.c:2955 +#: fe-exec.c:3057 #, c-format msgid "could not interpret result from server: %s" msgstr "サーãƒã‹ã‚‰ã®çµæžœã‚’解釈ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s" -#: fe-exec.c:3194 fe-exec.c:3278 +#: fe-exec.c:3296 fe-exec.c:3380 msgid "incomplete multibyte character\n" msgstr "ä¸å®Œå…¨ãªãƒžãƒ«ãƒãƒã‚¤ãƒˆæ–‡å­—\n" @@ -542,27 +544,22 @@ msgid "cannot determine OID of function lo_truncate\n" msgstr "lo_truncate関数ã®OIDを決定ã§ãã¾ã›ã‚“\n" #: fe-lobj.c:171 -#| msgid "Value exceeds integer range." msgid "argument of lo_truncate exceeds integer range\n" msgstr "lo_truncateã¸ã®å¼•æ•°ãŒæ•´æ•°ç¯„囲を超ãˆã¦ã„ã¾ã™ã€‚\n" #: fe-lobj.c:222 -#| msgid "cannot determine OID of function lo_truncate\n" msgid "cannot determine OID of function lo_truncate64\n" msgstr "lo_truncate64関数ã®OIDを決定ã§ãã¾ã›ã‚“\n" #: fe-lobj.c:280 -#| msgid "Value exceeds integer range." msgid "argument of lo_read exceeds integer range\n" msgstr "lo_readã¸ã®å¼•æ•°ãŒæ•´æ•°ç¯„囲を超ãˆã¦ã„ã¾ã™ã€‚\n" #: fe-lobj.c:335 -#| msgid "Value exceeds integer range." msgid "argument of lo_write exceeds integer range\n" msgstr "lo_writeã¸ã®å¼•æ•°ãŒæ•´æ•°ç¯„囲を超ãˆã¦ã„ã¾ã™ã€‚\n" #: fe-lobj.c:426 -#| msgid "cannot determine OID of function lo_lseek\n" msgid "cannot determine OID of function lo_lseek64\n" msgstr "lo_lseek64関数ã®OIDを決定ã§ãã¾ã›ã‚“\n" @@ -571,7 +568,6 @@ msgid "cannot determine OID of function lo_create\n" msgstr "lo_create関数ã®OIDを決定ã§ãã¾ã›ã‚“\n" #: fe-lobj.c:601 -#| msgid "cannot determine OID of function lo_tell\n" msgid "cannot determine OID of function lo_tell64\n" msgstr "lo_tell64関数ã®OIDを決定ã§ãã¾ã›ã‚“\n" @@ -636,12 +632,12 @@ msgstr "サイズ%luã®æ•´æ•°ã¯pqGetIntã§ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" msgid "integer of size %lu not supported by pqPutInt" msgstr "サイズ%luã®æ•´æ•°ã¯pqPutIntã§ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: fe-misc.c:610 fe-misc.c:806 +#: fe-misc.c:642 fe-misc.c:843 msgid "connection not open\n" msgstr "接続ã¯ã‚ªãƒ¼ãƒ—ンã•ã‚Œã¦ã„ã¾ã›ã‚“\n" -#: fe-misc.c:736 fe-secure.c:382 fe-secure.c:462 fe-secure.c:543 -#: fe-secure.c:652 +#: fe-misc.c:812 fe-secure-openssl.c:231 fe-secure-openssl.c:340 +#: fe-secure.c:253 fe-secure.c:362 msgid "" "server closed the connection unexpectedly\n" "\tThis probably means the server terminated abnormally\n" @@ -651,15 +647,15 @@ msgstr "" " ãŠãらãè¦æ±‚ã®å‡¦ç†å‰ã¾ãŸã¯å‡¦ç†ä¸­ã«ã‚µãƒ¼ãƒãŒç•°å¸¸çµ‚了\n" " ã—ãŸã“ã¨ã‚’æ„味ã—ã¦ã„ã¾ã™ã€‚\n" -#: fe-misc.c:970 +#: fe-misc.c:1016 msgid "timeout expired\n" msgstr "タイムアウト期間ãŒéŽãŽã¾ã—ãŸ\n" -#: fe-misc.c:1015 -msgid "socket not open\n" -msgstr "ソケットãŒã‚ªãƒ¼ãƒ—ンã•ã‚Œã¦ã„ã¾ã›ã‚“\n" +#: fe-misc.c:1061 +msgid "invalid socket\n" +msgstr "無効ãªã‚½ã‚±ãƒƒãƒˆã§ã™\n" -#: fe-misc.c:1038 +#: fe-misc.c:1084 #, c-format msgid "select() failed: %s\n" msgstr "select()ãŒå¤±æ•—ã—ã¾ã—ãŸ: %s\n" @@ -679,317 +675,325 @@ msgstr "状態%cã¯ç„¡åŠ¹ã§ã™ã€‚メモリ障害ã®å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™\n" msgid "message type 0x%02x arrived from server while idle" msgstr "待機中ã«ã‚µãƒ¼ãƒã‹ã‚‰ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ç¨®é¡ž0x%02xãŒå±Šãã¾ã—ãŸ" -#: fe-protocol2.c:522 +#: fe-protocol2.c:503 fe-protocol2.c:538 fe-protocol2.c:1049 +#: fe-protocol3.c:209 fe-protocol3.c:236 fe-protocol3.c:253 fe-protocol3.c:333 +#: fe-protocol3.c:728 fe-protocol3.c:951 +msgid "out of memory" +msgstr "メモリä¸è¶³ã§ã™" + +#: fe-protocol2.c:529 #, c-format msgid "unexpected character %c following empty query response (\"I\" message)" msgstr "空ã®å•ã„åˆã‚ã›å¿œç­”(\"I\"メッセージ)ã®å¾Œã«æƒ³å®šå¤–ã®æ–‡å­—%cãŒã‚ã‚Šã¾ã—ãŸ" -#: fe-protocol2.c:580 +#: fe-protocol2.c:595 #, c-format msgid "server sent data (\"D\" message) without prior row description (\"T\" message)" msgstr "サーãƒãŒäº‹å‰ã®è¡Œè¨˜è¿°(\"T\"メッセージ)ãªã—ã«ãƒ‡ãƒ¼ã‚¿(\"D\"メッセージ)ã‚’é€ä¿¡ã—ã¾ã—ãŸ" -#: fe-protocol2.c:598 +#: fe-protocol2.c:613 #, c-format msgid "server sent binary data (\"B\" message) without prior row description (\"T\" message)" msgstr "サーãƒãŒäº‹å‰ã®è¡Œè¨˜è¿°(\"T\"メッセージ)ãªã—ã«ãƒã‚¤ãƒŠãƒªãƒ‡ãƒ¼ã‚¿(\"B\"メッセージ)ã‚’é€ä¿¡ã—ã¾ã—ãŸ" -#: fe-protocol2.c:618 fe-protocol3.c:385 +#: fe-protocol2.c:633 fe-protocol3.c:412 #, c-format msgid "unexpected response from server; first received character was \"%c\"\n" msgstr "サーãƒã‹ã‚‰æƒ³å®šå¤–ã®å¿œç­”ãŒã‚ã‚Šã¾ã—ãŸã€‚å—ã‘付ã‘ãŸå…ˆé ­æ–‡å­—ã¯\"%c\"ã§ã™\n" -#: fe-protocol2.c:747 fe-protocol2.c:922 fe-protocol3.c:600 fe-protocol3.c:782 +#: fe-protocol2.c:762 fe-protocol2.c:937 fe-protocol3.c:627 fe-protocol3.c:854 msgid "out of memory for query result" msgstr "å•ã„åˆã‚ã›çµæžœç”¨ã®ãƒ¡ãƒ¢ãƒªãŒä¸è¶³ã—ã¦ã„ã¾ã™" -#: fe-protocol2.c:1370 fe-protocol3.c:1752 +#: fe-protocol2.c:1395 fe-protocol3.c:1886 #, c-format msgid "%s" msgstr "%s" -#: fe-protocol2.c:1382 +#: fe-protocol2.c:1407 #, c-format msgid "lost synchronization with server, resetting connection" msgstr "サーãƒã¨ã®å‹•æ©ŸãŒå¤±ã‚ã‚Œã¾ã—ãŸã€‚接続をリセットã—ã¦ã„ã¾ã™" -#: fe-protocol2.c:1516 fe-protocol2.c:1548 fe-protocol3.c:1955 +#: fe-protocol2.c:1541 fe-protocol2.c:1573 fe-protocol3.c:2089 #, c-format msgid "protocol error: id=0x%x\n" msgstr "プロトコルエラー: id=0x%x\n" -#: fe-protocol3.c:341 +#: fe-protocol3.c:368 msgid "server sent data (\"D\" message) without prior row description (\"T\" message)\n" msgstr "サーãƒãŒäº‹å‰ã®è¡Œè¨˜è¿°(\"T\"メッセージ)ãªã—ã«ãƒ‡ãƒ¼ã‚¿(\"D\"メッセージ)ã‚’é€ä¿¡ã—ã¾ã—ãŸ\"\n" -#: fe-protocol3.c:406 +#: fe-protocol3.c:433 #, c-format msgid "message contents do not agree with length in message type \"%c\"\n" msgstr "メッセージã®å†…容ãŒãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ç¨®é¡ž\"%c\"ã®é•·ã•ã«åˆã„ã¾ã›ã‚“\n" -#: fe-protocol3.c:427 +#: fe-protocol3.c:454 #, c-format msgid "lost synchronization with server: got message type \"%c\", length %d\n" msgstr "サーãƒã¨ã®åŒæœŸãŒå¤±ã‚ã‚Œã¾ã—ãŸã€‚å—ä¿¡ã—ãŸãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ç¨®é¡žã¯\"%c\"ã€é•·ã•ã¯%d\n" -#: fe-protocol3.c:478 fe-protocol3.c:518 +#: fe-protocol3.c:505 fe-protocol3.c:545 msgid "insufficient data in \"T\" message" msgstr "\"T\"メッセージ内ã®ãƒ‡ãƒ¼ã‚¿ãŒä¸å分ã§ã™" -#: fe-protocol3.c:551 +#: fe-protocol3.c:578 msgid "extraneous data in \"T\" message" msgstr "\"T\"メッセージ内ã®ãƒ‡ãƒ¼ã‚¿ãŒç„¡é–¢ä¿‚ã§ã™" -#: fe-protocol3.c:690 fe-protocol3.c:722 fe-protocol3.c:740 +#: fe-protocol3.c:691 +msgid "extraneous data in \"t\" message" +msgstr "\"t\"メッセージ内ã®ãƒ‡ãƒ¼ã‚¿ãŒç„¡é–¢ä¿‚ã§ã™" + +#: fe-protocol3.c:762 fe-protocol3.c:794 fe-protocol3.c:812 msgid "insufficient data in \"D\" message" msgstr "\"D\"\"メッセージ内ã®ãƒ‡ãƒ¼ã‚¿ãŒä¸å分ã§ã™" -#: fe-protocol3.c:696 +#: fe-protocol3.c:768 msgid "unexpected field count in \"D\" message" msgstr "\"D\"メッセージ内ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰æ•°ãŒæƒ³å®šå¤–ã§ã™ã€‚" -#: fe-protocol3.c:749 +#: fe-protocol3.c:821 msgid "extraneous data in \"D\" message" msgstr "â€D\"メッセージ内ã®ãƒ‡ãƒ¼ã‚¿ãŒç„¡é–¢ä¿‚ã§ã™" +#: fe-protocol3.c:1005 +msgid "no error message available\n" +msgstr "エラーメッセージãŒåˆ©ç”¨ã§ãã¾ã›ã‚“\n" + #. translator: %s represents a digit string -#: fe-protocol3.c:878 fe-protocol3.c:897 +#: fe-protocol3.c:1035 fe-protocol3.c:1054 #, c-format msgid " at character %s" msgstr "(文字ä½ç½®: %s)" -#: fe-protocol3.c:910 +#: fe-protocol3.c:1067 #, c-format msgid "DETAIL: %s\n" msgstr "DETAIL: %s\n" -#: fe-protocol3.c:913 +#: fe-protocol3.c:1070 #, c-format msgid "HINT: %s\n" msgstr "HINT: %s\n" -#: fe-protocol3.c:916 +#: fe-protocol3.c:1073 #, c-format msgid "QUERY: %s\n" msgstr "QUERY: %s\n" -#: fe-protocol3.c:919 +#: fe-protocol3.c:1080 #, c-format msgid "CONTEXT: %s\n" msgstr "CONTEXT: %s\n" -#: fe-protocol3.c:926 +#: fe-protocol3.c:1089 #, c-format -#| msgid "CONTEXT: %s\n" msgid "SCHEMA NAME: %s\n" msgstr "SCHEMA NAME: %s\n" -#: fe-protocol3.c:930 +#: fe-protocol3.c:1093 #, c-format -#| msgid "DETAIL: %s\n" msgid "TABLE NAME: %s\n" msgstr "TABLE NAME: %s\n" -#: fe-protocol3.c:934 +#: fe-protocol3.c:1097 #, c-format -#| msgid "CONTEXT: %s\n" msgid "COLUMN NAME: %s\n" msgstr "COLUMN NAME: %s\n" -#: fe-protocol3.c:938 +#: fe-protocol3.c:1101 #, c-format msgid "DATATYPE NAME: %s\n" msgstr "DATATYPE NAME: %s\n" -#: fe-protocol3.c:942 +#: fe-protocol3.c:1105 #, c-format -#| msgid "CONTEXT: %s\n" msgid "CONSTRAINT NAME: %s\n" msgstr "CONSTRAINT NAME: %s\n" -#: fe-protocol3.c:954 +#: fe-protocol3.c:1117 msgid "LOCATION: " msgstr "LOCATION: " -#: fe-protocol3.c:956 +#: fe-protocol3.c:1119 #, c-format msgid "%s, " msgstr "%s, " -#: fe-protocol3.c:958 +#: fe-protocol3.c:1121 #, c-format msgid "%s:%s" msgstr "%s:%s" -#: fe-protocol3.c:1182 +#: fe-protocol3.c:1316 #, c-format msgid "LINE %d: " msgstr "è¡Œ %d: " -#: fe-protocol3.c:1577 +#: fe-protocol3.c:1711 msgid "PQgetline: not doing text COPY OUT\n" msgstr "PQgetline: テキストã®COPY OUTã‚’è¡Œã£ã¦ã„ã¾ã›ã‚“\n" -#: fe-secure.c:266 fe-secure.c:1121 fe-secure.c:1339 -msgid "unable to acquire mutex\n" -msgstr "ミューテックスをç²å¾—ã§ãã¾ã›ã‚“\n" - -#: fe-secure.c:278 -#, c-format -msgid "could not establish SSL connection: %s\n" -msgstr "SSL接続を確立ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: fe-secure.c:387 fe-secure.c:548 fe-secure.c:1468 +#: fe-secure-openssl.c:236 fe-secure-openssl.c:345 fe-secure-openssl.c:1323 #, c-format msgid "SSL SYSCALL error: %s\n" msgstr "SSL SYSCALLエラー: %s\n" -#: fe-secure.c:394 fe-secure.c:555 fe-secure.c:1472 +#: fe-secure-openssl.c:243 fe-secure-openssl.c:352 fe-secure-openssl.c:1327 msgid "SSL SYSCALL error: EOF detected\n" msgstr "SSL SYSCALLエラー: EOFを検知\n" -#: fe-secure.c:405 fe-secure.c:566 fe-secure.c:1481 +#: fe-secure-openssl.c:254 fe-secure-openssl.c:363 fe-secure-openssl.c:1336 #, c-format msgid "SSL error: %s\n" msgstr "SSLエラー: %s\n" -#: fe-secure.c:420 fe-secure.c:581 +#: fe-secure-openssl.c:269 fe-secure-openssl.c:378 msgid "SSL connection has been closed unexpectedly\n" msgstr "SSL接続ãŒæ„図ã›ãšã«ã‚¯ãƒ­ãƒ¼ã‚ºã•ã‚Œã¾ã—ãŸ\n" -#: fe-secure.c:426 fe-secure.c:587 fe-secure.c:1490 +#: fe-secure-openssl.c:275 fe-secure-openssl.c:384 fe-secure-openssl.c:1345 #, c-format msgid "unrecognized SSL error code: %d\n" msgstr "ä¸æ˜Žã®SSLエラーコード: %d\n" -#: fe-secure.c:470 -#, c-format -msgid "could not receive data from server: %s\n" -msgstr "サーãƒã‹ã‚‰ãƒ‡ãƒ¼ã‚¿ã‚’å—ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: fe-secure.c:659 -#, c-format -msgid "could not send data to server: %s\n" -msgstr "サーãƒã«ãƒ‡ãƒ¼ã‚¿ã‚’é€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" +#: fe-secure-openssl.c:495 +msgid "SSL certificate's name entry is missing\n" +msgstr "SSL 証明書åé …ç›®ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“\n" -#: fe-secure.c:779 fe-secure.c:796 -msgid "could not get server common name from server certificate\n" -msgstr "サーãƒè¨¼æ˜Žæ›¸ã‹ã‚‰ã‚µãƒ¼ãƒã®ã‚³ãƒ¢ãƒ³ãƒãƒ¼ãƒ ã‚’å–り出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸã€‚\n" +#: fe-secure-openssl.c:529 +msgid "SSL certificate's name contains embedded null\n" +msgstr "SSL 証明書å項目㫠null ãŒå«ã¾ã‚Œã¦ã„ã¾ã™\n" -#: fe-secure.c:809 -msgid "SSL certificate's common name contains embedded null\n" -msgstr "SSL 証明書ã®ã‚³ãƒ¢ãƒ³ãƒãƒ¼ãƒ ã« null ãŒå«ã¾ã‚Œã¦ã„ã¾ã™\n" - -#: fe-secure.c:821 +#: fe-secure-openssl.c:580 msgid "host name must be specified for a verified SSL connection\n" msgstr "SSL 接続を検証ã™ã‚‹ãŸã‚ã«ãƒ›ã‚¹ãƒˆåを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“\n" -#: fe-secure.c:835 +#: fe-secure-openssl.c:680 #, c-format -msgid "server common name \"%s\" does not match host name \"%s\"\n" -msgstr "サーãƒã®æ­£å¼å(common name)\"%s\"ãŒãƒ›ã‚¹ãƒˆå\"%s\"ã¨ä¸€è‡´ã—ã¾ã›ã‚“\n" +msgid "server certificate for \"%s\" does not match host name \"%s\"\n" +msgstr "\"%s\"ã®ã‚µãƒ¼ãƒè¨¼æ˜Žæ›¸ãŒãƒ›ã‚¹ãƒˆå\"%s\"ã¨ä¸€è‡´ã—ã¾ã›ã‚“\n" + +#: fe-secure-openssl.c:686 +msgid "could not get server's host name from server certificate\n" +msgstr "サーãƒè¨¼æ˜Žæ›¸ã‹ã‚‰ã‚µãƒ¼ãƒã®ãƒ›ã‚¹ãƒˆåã‚’å–り出ã™ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸã€‚\n" -#: fe-secure.c:970 +#: fe-secure-openssl.c:930 #, c-format msgid "could not create SSL context: %s\n" msgstr "SSLコンテキストを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1093 +#: fe-secure-openssl.c:967 +#, c-format +msgid "could not read root certificate file \"%s\": %s\n" +msgstr "ルート証明書\"%s\"を読ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: fe-secure-openssl.c:995 +#, c-format +msgid "SSL library does not support CRL certificates (file \"%s\")\n" +msgstr "SSLライブラリãŒCRL証明書（\"%s\"）をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ\n" + +#: fe-secure-openssl.c:1023 +msgid "" +"could not get home directory to locate root certificate file\n" +"Either provide the file or change sslmode to disable server certificate verification.\n" +msgstr "" +"ルート証明書ファイルを置ããŸã‚ã®ãƒ›ãƒ¼ãƒ ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªãŒå­˜åœ¨ã—ã¾ã›ã‚“。\n" +"ファイルを用æ„ã™ã‚‹ã‹ã€ã‚µãƒ¼ãƒè¨¼æ˜Žæ›¸ã®æ¤œè¨¼ã‚’無効ã«ã™ã‚‹ã‚ˆã†ã« sslmode を変更ã—ã¦ãã ã•ã„\n" + +#: fe-secure-openssl.c:1027 +#, c-format +msgid "" +"root certificate file \"%s\" does not exist\n" +"Either provide the file or change sslmode to disable server certificate verification.\n" +msgstr "" +"ルート証明書ファイル\"%s\"ãŒå­˜åœ¨ã—ã¾ã›ã‚“。\n" +"ファイルを用æ„ã™ã‚‹ã‹ã‚µãƒ¼ãƒè¨¼æ˜Žæ›¸ã®æ¤œè¨¼ã‚’無効ã«ã™ã‚‹ã‚ˆã†ã«sslmodeを変更ã—ã¦ãã ã•ã„\n" + +#: fe-secure-openssl.c:1058 #, c-format msgid "could not open certificate file \"%s\": %s\n" msgstr "証明書ファイル\"%s\"をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1130 fe-secure.c:1145 +#: fe-secure-openssl.c:1077 #, c-format msgid "could not read certificate file \"%s\": %s\n" msgstr "証明書ファイル\"%s\"を読ã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1200 +#: fe-secure-openssl.c:1101 +#, c-format +msgid "could not establish SSL connection: %s\n" +msgstr "SSL接続を確立ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: fe-secure-openssl.c:1155 #, c-format msgid "could not load SSL engine \"%s\": %s\n" msgstr "SSLエンジン\"%s\"を読ã¿è¾¼ã¿ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1212 +#: fe-secure-openssl.c:1167 #, c-format msgid "could not initialize SSL engine \"%s\": %s\n" msgstr "SSLエンジン\"%s\"ã‚’åˆæœŸåŒ–ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1228 +#: fe-secure-openssl.c:1183 #, c-format msgid "could not read private SSL key \"%s\" from engine \"%s\": %s\n" msgstr "SSL秘密キーファイル\"%s\"をエンジン\"%s\"ã‹ã‚‰èª­ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1242 +#: fe-secure-openssl.c:1197 #, c-format msgid "could not load private SSL key \"%s\" from engine \"%s\": %s\n" msgstr "SSL秘密キー\"%s\"をエンジン\"%s\"ã‹ã‚‰èª­ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1279 +#: fe-secure-openssl.c:1234 #, c-format msgid "certificate present, but not private key file \"%s\"\n" msgstr "証明書ã¯ã‚ã‚Šã¾ã—ãŸãŒã€ç§˜å¯†ã‚­ãƒ¼ãƒ•ã‚¡ã‚¤ãƒ«\"%s\"ã¯ã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ\n" -#: fe-secure.c:1287 +#: fe-secure-openssl.c:1242 #, c-format msgid "private key file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n" msgstr "警告：秘密キーファイル \"%s\" ãŒã‚°ãƒ«ãƒ¼ãƒ—メンãƒã‚„第三者ã‹ã‚‰èª­ã‚る状態ã«ãªã£ã¦ã„ã¾ã™ã€‚ã“ã®æ¨©é™ã¯u=rw (0600)ã¾ãŸã¯ãれ以下ã¨ã™ã¹ãã§ã™\n" -#: fe-secure.c:1298 +#: fe-secure-openssl.c:1253 #, c-format msgid "could not load private key file \"%s\": %s\n" msgstr "秘密キーファイル\"%s\"をロードã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1312 +#: fe-secure-openssl.c:1267 #, c-format msgid "certificate does not match private key file \"%s\": %s\n" msgstr "証明書ã¨ç§˜å¯†ã‚­ãƒ¼ãƒ•ã‚¡ã‚¤ãƒ«\"%s\"ãŒä¸€è‡´ã—ã¾ã›ã‚“: %s\n" -#: fe-secure.c:1348 -#, c-format -msgid "could not read root certificate file \"%s\": %s\n" -msgstr "ルート証明書\"%s\"を読ã¿å–ã‚Œã¾ã›ã‚“ã§ã—ãŸ: %s\n" - -#: fe-secure.c:1378 -#, c-format -msgid "SSL library does not support CRL certificates (file \"%s\")\n" -msgstr "SSLライブラリãŒCRL証明書（\"%s\"）をオープンã§ãã¾ã›ã‚“ã§ã—ãŸ\n" - -#: fe-secure.c:1411 -msgid "" -"could not get home directory to locate root certificate file\n" -"Either provide the file or change sslmode to disable server certificate verification.\n" -msgstr "" -"ルート証明書ファイルを置ããŸã‚ã®ãƒ›ãƒ¼ãƒ ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªãŒå­˜åœ¨ã—ã¾ã›ã‚“。\n" -"ファイルを用æ„ã™ã‚‹ã‹ã€ã‚µãƒ¼ãƒè¨¼æ˜Žæ›¸ã®æ¤œè¨¼ã‚’無効ã«ã™ã‚‹ã‚ˆã†ã« sslmode を変更ã—ã¦ãã ã•ã„\n" - -#: fe-secure.c:1415 -#, c-format -msgid "" -"root certificate file \"%s\" does not exist\n" -"Either provide the file or change sslmode to disable server certificate verification.\n" -msgstr "" -"ルート証明書ファイル\"%s\"ãŒå­˜åœ¨ã—ã¾ã›ã‚“。\n" -"ファイルを用æ„ã™ã‚‹ã‹ã‚µãƒ¼ãƒè¨¼æ˜Žæ›¸ã®æ¤œè¨¼ã‚’無効ã«ã™ã‚‹ã‚ˆã†ã«sslmodeを変更ã—ã¦ãã ã•ã„\n" - -#: fe-secure.c:1509 +#: fe-secure-openssl.c:1366 #, c-format msgid "certificate could not be obtained: %s\n" msgstr "証明書を入手ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" -#: fe-secure.c:1586 +#: fe-secure-openssl.c:1458 #, c-format msgid "no SSL error reported" msgstr "SSLエラーã¯ã‚ã‚Šã¾ã›ã‚“ã§ã—ãŸ" -#: fe-secure.c:1595 +#: fe-secure-openssl.c:1467 #, c-format msgid "SSL error code %lu" msgstr "SSLエラーコード: %lu" -#: win32.c:322 +#: fe-secure.c:261 +#, c-format +msgid "could not receive data from server: %s\n" +msgstr "サーãƒã‹ã‚‰ãƒ‡ãƒ¼ã‚¿ã‚’å—ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: fe-secure.c:369 +#, c-format +msgid "could not send data to server: %s\n" +msgstr "サーãƒã«ãƒ‡ãƒ¼ã‚¿ã‚’é€ä¿¡ã§ãã¾ã›ã‚“ã§ã—ãŸ: %s\n" + +#: win32.c:317 #, c-format msgid "unrecognized socket error: 0x%08X/%d" msgstr "ä¸æ˜Žãªã‚½ã‚±ãƒƒãƒˆã‚¨ãƒ©ãƒ¼ 0x%08X/%d" -#~ msgid "verified SSL connections are only supported when connecting to a host name\n" -#~ msgstr "検証ã•ã‚ŒãŸSSL接続ã¯ãƒ›ã‚¹ãƒˆåã¸ã®æŽ¥ç¶šæ™‚ã®ã¿ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã™\n" diff --git a/src/pl/plperl/po/ja.po b/src/pl/plperl/po/ja.po index cab0253534..db28352dbb 100644 --- a/src/pl/plperl/po/ja.po +++ b/src/pl/plperl/po/ja.po @@ -5,11 +5,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.1 beta 2\n" +"Project-Id-Version: PostgreSQL 9.6.3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2012-08-11 17:49+0900\n" +"POT-Creation-Date: 2017-04-04 11:46+0900\n" "PO-Revision-Date: 2012-08-11 17:51+0900\n" -"Last-Translator: Honda Shigehiro\n" +"Last-Translator: Daisuke Higuchi \n" "Language-Team: jpug-doc \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -17,177 +17,206 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" -#: plperl.c:365 +#: plperl.c:405 msgid "If true, trusted and untrusted Perl code will be compiled in strict mode." msgstr "真ãªã‚‰ã°ä¿¡é ¼ã—ã€ä¿¡é ¼ã•ã‚Œãªã„Perlã®ã‚³ãƒ¼ãƒ‰ã¯strictモードã§ã‚³ãƒ³ãƒ‘イルã•ã‚Œã¾ã™ã€‚" -#: plperl.c:379 +#: plperl.c:419 msgid "Perl initialization code to execute when a Perl interpreter is initialized." msgstr "Perl ã®ã‚¤ãƒ³ã‚¿ãƒ—リタãŒåˆæœŸåŒ–ã•ã‚Œã‚‹éš›ã«å®Ÿè¡Œã•ã‚Œã‚‹ã¹ã Perl åˆæœŸåŒ–コード" -#: plperl.c:401 +#: plperl.c:441 msgid "Perl initialization code to execute once when plperl is first used." msgstr "plperl ãŒæœ€åˆã«ä½¿ç”¨ã•ã‚Œã‚‹éš›ã«ä¸€åº¦å®Ÿè¡Œã•ã‚Œã‚‹ã¹ã Perl åˆæœŸåŒ–コード" -#: plperl.c:409 +#: plperl.c:449 msgid "Perl initialization code to execute once when plperlu is first used." msgstr "plperlu ãŒæœ€åˆã«ä½¿ç”¨ã•ã‚Œã‚‹éš›ã«ä¸€åº¦å®Ÿè¡Œã•ã‚Œã‚‹ã¹ã Perl åˆæœŸåŒ–コード" -#: plperl.c:626 plperl.c:788 plperl.c:793 plperl.c:897 plperl.c:908 -#: plperl.c:949 plperl.c:970 plperl.c:1943 plperl.c:2038 plperl.c:2100 +#: plperl.c:646 +#, c-format +msgid "cannot allocate multiple Perl interpreters on this platform" +msgstr "ã“ã®ãƒ—ラットフォームã§ã¯è¤‡æ•°ã®Perlインタプリタを割り当ã¦ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“" + +#: plperl.c:666 plperl.c:841 plperl.c:847 plperl.c:961 plperl.c:973 +#: plperl.c:1016 plperl.c:1037 plperl.c:2080 plperl.c:2189 plperl.c:2256 +#: plperl.c:2318 #, c-format msgid "%s" msgstr "%s" -#: plperl.c:627 +#: plperl.c:667 #, c-format msgid "while executing PostgreSQL::InServer::SPI::bootstrap" msgstr "PostgreSQL::InServer::SPI::bootstrap ã®å®Ÿè¡Œä¸­ã«" -#: plperl.c:789 +#: plperl.c:842 #, c-format msgid "while parsing Perl initialization" msgstr "Perl åˆæœŸåŒ–処ç†ã®ãƒ‘ース中ã«" -#: plperl.c:794 +#: plperl.c:848 #, c-format msgid "while running Perl initialization" msgstr "Perl åˆæœŸåŒ–処ç†ã®å®Ÿè¡Œä¸­ã«" -#: plperl.c:898 +#: plperl.c:962 #, c-format msgid "while executing PLC_TRUSTED" msgstr "PLC_TRUSTED ã®å®Ÿè¡Œä¸­ã«" -#: plperl.c:909 +#: plperl.c:974 #, c-format msgid "while executing utf8fix" msgstr "utf8fix ã®å®Ÿè¡Œä¸­ã«" -#: plperl.c:950 +#: plperl.c:1017 #, c-format msgid "while executing plperl.on_plperl_init" msgstr "plperl.on_plperl_init ã®å®Ÿè¡Œä¸­ã«" -#: plperl.c:971 +#: plperl.c:1038 #, c-format msgid "while executing plperl.on_plperlu_init" msgstr "plperl.on_plperlu_init ã®å®Ÿè¡Œä¸­ã«" -#: plperl.c:1015 plperl.c:1615 +#: plperl.c:1082 plperl.c:1722 #, c-format msgid "Perl hash contains nonexistent column \"%s\"" msgstr "Perlãƒãƒƒã‚·ãƒ¥ã«å­˜åœ¨ã—ãªã„列\"%s\"ãŒå«ã¾ã‚Œã¾ã™" -#: plperl.c:1100 +#: plperl.c:1167 #, c-format msgid "number of array dimensions (%d) exceeds the maximum allowed (%d)" msgstr "é…列ã®æ¬¡æ•°(%d)ãŒä¸Šé™(%d)を超ãˆã¦ã„ã¾ã™" -#: plperl.c:1112 plperl.c:1129 +#: plperl.c:1179 plperl.c:1196 #, c-format msgid "multidimensional arrays must have array expressions with matching dimensions" msgstr "多次元é…列ã¯æ¬¡æ•°ã«åˆã£ãŸé…列å¼ã‚’æŒãŸãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: plperl.c:1166 +#: plperl.c:1231 #, c-format msgid "cannot convert Perl array to non-array type %s" msgstr "Perlé…列をéžé…列型%sã«å¤‰æ›ã§ãã¾ã›ã‚“" -#: plperl.c:1262 +#: plperl.c:1333 #, c-format msgid "cannot convert Perl hash to non-composite type %s" msgstr "Perlãƒãƒƒã‚·ãƒ¥ã‚’éžè¤‡åˆåž‹%sã«å¤‰æ›ã§ãã¾ã›ã‚“" -#: plperl.c:1273 +#: plperl.c:1344 #, c-format msgid "function returning record called in context that cannot accept type record" msgstr "レコード型をå—ã‘付ã‘られãªã„コンテキストã§ãƒ¬ã‚³ãƒ¼ãƒ‰ã‚’è¿”ã™é–¢æ•°ãŒå‘¼ã³å‡ºã•ã‚Œã¾ã—ãŸ" -#: plperl.c:1288 +#: plperl.c:1359 #, c-format msgid "PL/Perl function must return reference to hash or array" msgstr "PL/Perl関数ã¯ãƒãƒƒã‚·ãƒ¥ã¾ãŸã¯é…列ã¸ã®å‚照を返ã™å¿…è¦ãŒã‚ã‚Šã¾ã™" -#: plperl.c:1592 +#: plperl.c:1396 +#, c-format +msgid "lookup failed for type %s" +msgstr "%såž‹ã®æ¤œç´¢ã«å¤±æ•—ã—ã¾ã—ãŸ" + +#: plperl.c:1699 #, c-format msgid "$_TD->{new} does not exist" msgstr "$_TD->{new}ã¯å­˜åœ¨ã—ã¾ã›ã‚“" -#: plperl.c:1596 +#: plperl.c:1703 #, c-format msgid "$_TD->{new} is not a hash reference" msgstr "$_TD->{new}ã¯ãƒãƒƒã‚·ãƒ¥ã¸ã®å‚ç…§ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: plperl.c:1820 plperl.c:2518 +#: plperl.c:1956 plperl.c:2790 #, c-format msgid "PL/Perl functions cannot return type %s" msgstr "PL/Perl関数ã¯%såž‹ã‚’è¿”ã™ã“ã¨ãŒã§ãã¾ã›ã‚“" -#: plperl.c:1833 plperl.c:2565 +#: plperl.c:1969 plperl.c:2835 #, c-format msgid "PL/Perl functions cannot accept type %s" msgstr "PL/Perl関数ã¯%såž‹ã‚’å—ã‘付ã‘られã¾ã›ã‚“" -#: plperl.c:1947 +#: plperl.c:2085 #, c-format msgid "didn't get a CODE reference from compiling function \"%s\"" msgstr "関数 \"%s\" ã®ã‚³ãƒ³ãƒ‘イルã‹ã‚‰ã¯ã‚³ãƒ¼ãƒ‰å‚照をå–å¾—ã—ã¾ã›ã‚“ã§ã—ãŸ" -#: plperl.c:2151 +#: plperl.c:2177 +#, c-format +msgid "didn't get a return item from function" +msgstr "関数ã‹ã‚‰æˆ»ã‚Šå€¤ã‚’å–å¾—ã—ã¾ã›ã‚“ã§ã—ãŸ" + +#: plperl.c:2220 plperl.c:2286 +#, c-format +msgid "couldn't fetch $_TD" +msgstr "$_TD をフェッãƒã§ãã¾ã›ã‚“ã§ã—ãŸ" + +#: plperl.c:2244 plperl.c:2306 +#, c-format +msgid "didn't get a return item from trigger function" +msgstr "トリガ関数ã‹ã‚‰æˆ»ã‚Šå€¤ã‚’å–å¾—ã—ã¾ã›ã‚“ã§ã—ãŸ" + +#: plperl.c:2363 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "ã“ã®ã‚³ãƒ³ãƒ†ã‚­ã‚¹ãƒˆã§é›†åˆå€¤ã®é–¢æ•°ã¯é›†åˆã‚’å—ã‘付ã‘られã¾ã›ã‚“" -#: plperl.c:2195 +#: plperl.c:2407 #, c-format msgid "set-returning PL/Perl function must return reference to array or use return_next" msgstr "集åˆã‚’è¿”ã™PL/Perl関数ã¯é…列ã¸ã®å‚照を返ã™ã€ã¾ãŸã¯ã€return_nextを使用ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™" -#: plperl.c:2315 +#: plperl.c:2521 #, c-format msgid "ignoring modified row in DELETE trigger" msgstr "DELETEトリガã«ã¦å¤‰æ›´ã•ã‚ŒãŸè¡Œã‚’無視ã—ã¾ã™" -#: plperl.c:2323 +#: plperl.c:2529 #, c-format msgid "result of PL/Perl trigger function must be undef, \"SKIP\", or \"MODIFY\"" msgstr "PL/Perlトリガ関数ã®çµæžœã¯\"SKIP\"ã¾ãŸã¯\"MODIFY\"ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: plperl.c:2449 plperl.c:2455 +#: plperl.c:2708 plperl.c:2718 #, c-format msgid "out of memory" msgstr "メモリä¸è¶³ã§ã™" -#: plperl.c:2509 +#: plperl.c:2782 #, c-format msgid "trigger functions can only be called as triggers" msgstr "トリガー関数ã¯ãƒˆãƒªã‚¬ãƒ¼ã¨ã—ã¦ã®ã¿ã‚³ãƒ¼ãƒ«ã§ãã¾ã™" -#: plperl.c:2885 +#: plperl.c:3121 +#, c-format +msgid "query result has too many rows to fit in a Perl array" +msgstr "å•ã„åˆã‚ã›çµæžœã®è¡ŒãŒå¤šã™ãŽã¦Perlé…列ã«åŽã¾ã‚Šã¾ã›ã‚“" + +#: plperl.c:3166 #, c-format msgid "cannot use return_next in a non-SETOF function" msgstr "SETOF関数以外ã§ã¯return_nextを使用ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“" -#: plperl.c:2941 +#: plperl.c:3220 #, c-format msgid "SETOF-composite-returning PL/Perl function must call return_next with reference to hash" msgstr "複åˆåž‹ã®SETOFã‚’è¿”ã™PL/Perl関数ã¯ãƒãƒƒã‚·ãƒ¥ã¸ã®å‚照をæŒã¤return_nextを呼ã³å‡ºã•ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: plperl.c:3652 +#: plperl.c:3948 #, c-format msgid "PL/Perl function \"%s\"" msgstr "PL/Perl 関数 \"%s\"" -#: plperl.c:3664 +#: plperl.c:3960 #, c-format msgid "compilation of PL/Perl function \"%s\"" msgstr "PL/Perl 関数 \"%s\" ã®ã‚³ãƒ³ãƒ‘イル" -#: plperl.c:3673 +#: plperl.c:3969 #, c-format msgid "PL/Perl anonymous code block" msgstr "PL/Perl ã®ç„¡åコードブロック" -#~ msgid "composite-returning PL/Perl function must return reference to hash" -#~ msgstr "複åˆåž‹ã‚’è¿”ã™PL/Perl関数ã¯ãƒãƒƒã‚·ãƒ¥ã¸ã®å‚照を返ã™å¿…è¦ãŒã‚ã‚Šã¾ã™" diff --git a/src/pl/plpgsql/src/po/ja.po b/src/pl/plpgsql/src/po/ja.po index efb8aa9a53..f189c96622 100644 --- a/src/pl/plpgsql/src/po/ja.po +++ b/src/pl/plpgsql/src/po/ja.po @@ -1,10 +1,10 @@ msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.0 beta 3\n" +"Project-Id-Version: PostgreSQL 9.6.3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2013-08-18 13:02+0900\n" +"POT-Creation-Date: 2017-04-04 11:47+0900\n" "PO-Revision-Date: 2013-08-18 13:04+0900\n" -"Last-Translator: HOTTA Michihde \n" +"Last-Translator: Daisuke Higuchi \n" "Language-Team: Japan PostgreSQL Users Group \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -14,785 +14,800 @@ msgstr "" "X-Poedit-Country: JAPAN\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" -#: pl_comp.c:432 pl_handler.c:276 +#: pl_comp.c:430 pl_handler.c:450 #, c-format msgid "PL/pgSQL functions cannot accept type %s" msgstr "PL/pgSQL 関数ã§ã¯ %s åž‹ã¯æŒ‡å®šã§ãã¾ã›ã‚“" -#: pl_comp.c:513 +#: pl_comp.c:511 #, c-format msgid "could not determine actual return type for polymorphic function \"%s\"" msgstr "関数 \"%s\" ãŒå¤šæ§˜ãªå½¢ã‚’æŒã¤ãŸã‚ã€å®Ÿéš›ã®æˆ»ã‚Šå€¤ã®åž‹ã‚’特定ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: pl_comp.c:543 +#: pl_comp.c:541 #, c-format msgid "trigger functions can only be called as triggers" msgstr "トリガー関数ã¯ãƒˆãƒªã‚¬ãƒ¼ã¨ã—ã¦ã®ã¿ã‚³ãƒ¼ãƒ«ã§ãã¾ã™" -#: pl_comp.c:547 pl_handler.c:261 +#: pl_comp.c:545 pl_handler.c:435 #, c-format msgid "PL/pgSQL functions cannot return type %s" msgstr "PL/pgSQL 関数㯠%s åž‹ã‚’è¿”ã›ã¾ã›ã‚“" -#: pl_comp.c:590 +#: pl_comp.c:586 #, c-format msgid "trigger functions cannot have declared arguments" msgstr "トリガー関数ã«ã¯å¼•æ•°ã‚’宣言ã§ãã¾ã›ã‚“" -#: pl_comp.c:591 +#: pl_comp.c:587 #, c-format msgid "The arguments of the trigger can be accessed through TG_NARGS and TG_ARGV instead." msgstr "ãã®ä»£ã‚ã‚Šã€ãƒˆãƒªã‚¬ãƒ¼ã®å¼•æ•°ã«ã¯ TG_NARGS 㨠TG_ARGV を通ã—ã¦ã®ã¿ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã™" -#: pl_comp.c:693 +#: pl_comp.c:689 #, c-format -#| msgid "trigger functions cannot have declared arguments" msgid "event trigger functions cannot have declared arguments" msgstr "イベントトリガー関数ã«ã¯å¼•æ•°ã‚’宣言ã§ãã¾ã›ã‚“" -#: pl_comp.c:950 +#: pl_comp.c:940 #, c-format msgid "compilation of PL/pgSQL function \"%s\" near line %d" msgstr "PL/pgSQL 関数 \"%s\" ã® %d 行目付近ã§ã®ã‚³ãƒ³ãƒ‘イル" -#: pl_comp.c:973 +#: pl_comp.c:963 #, c-format msgid "parameter name \"%s\" used more than once" msgstr "パラメータ \"%s\" ãŒè¤‡æ•°æŒ‡å®šã•ã‚Œã¾ã—ãŸ" -#: pl_comp.c:1083 +#: pl_comp.c:1073 #, c-format msgid "column reference \"%s\" is ambiguous" msgstr "列å‚ç…§\"%s\"ã¯æ›–昧ã§ã™" -#: pl_comp.c:1085 +#: pl_comp.c:1075 #, c-format msgid "It could refer to either a PL/pgSQL variable or a table column." msgstr "PL/pgSQL変数もã—ãã¯ãƒ†ãƒ¼ãƒ–ルã®ã‚«ãƒ©ãƒ åã„ãšã‚Œã‹ã‚’å‚ç…§ã—ã¦ã„ãŸå¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™" -#: pl_comp.c:1265 pl_comp.c:1293 pl_exec.c:4107 pl_exec.c:4462 pl_exec.c:4547 -#: pl_exec.c:4638 +#: pl_comp.c:1255 pl_comp.c:1283 pl_exec.c:4393 pl_exec.c:4742 pl_exec.c:4827 +#: pl_exec.c:4918 #, c-format msgid "record \"%s\" has no field \"%s\"" msgstr "レコード \"%s\" ã«ã¯åˆ— \"%s\" ã¯ã‚ã‚Šã¾ã›ã‚“" -#: pl_comp.c:1824 +#: pl_comp.c:1814 #, c-format msgid "relation \"%s\" does not exist" msgstr "リレーション \"%s\" ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_comp.c:1933 +#: pl_comp.c:1923 #, c-format msgid "variable \"%s\" has pseudo-type %s" msgstr "変数 \"%s\" ã®åž‹ã¯æ“¬ä¼¼ã‚¿ã‚¤ãƒ— %s ã§ã™" -#: pl_comp.c:1999 +#: pl_comp.c:1990 #, c-format msgid "relation \"%s\" is not a table" msgstr "リレーション \"%s\" ã¯ãƒ†ãƒ¼ãƒ–ルã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: pl_comp.c:2159 +#: pl_comp.c:2150 #, c-format msgid "type \"%s\" is only a shell" msgstr "åž‹ \"%s\" ã¯ã‚·ã‚§ãƒ«ã§ã®ã¿ä½¿ãˆã¾ã™" -#: pl_comp.c:2233 pl_comp.c:2286 +#: pl_comp.c:2244 pl_comp.c:2297 #, c-format msgid "unrecognized exception condition \"%s\"" msgstr "例外æ¡ä»¶ \"%s\" ãŒèªè­˜ã§ãã¾ã›ã‚“" -#: pl_comp.c:2444 +#: pl_comp.c:2504 #, c-format msgid "could not determine actual argument type for polymorphic function \"%s\"" msgstr "関数 \"%s\" ãŒå¤šæ§˜ãªå½¢ã‚’æŒã¤ãŸã‚ã€å®Ÿéš›ã®å¼•æ•°ã®åž‹ã‚’特定ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: pl_exec.c:254 pl_exec.c:514 pl_exec.c:793 +#: pl_exec.c:324 pl_exec.c:612 pl_exec.c:872 msgid "during initialization of execution state" msgstr "実行状態ã®åˆæœŸåŒ–中ã«" -#: pl_exec.c:261 +#: pl_exec.c:331 msgid "while storing call arguments into local variables" msgstr "引数をローカル変数ã«æ ¼ç´ã™ã‚‹éš›ã«" -#: pl_exec.c:303 pl_exec.c:671 +#: pl_exec.c:416 pl_exec.c:760 msgid "during function entry" msgstr "関数登録ã®éš›ã«" -#: pl_exec.c:334 pl_exec.c:702 pl_exec.c:834 -#, c-format -msgid "CONTINUE cannot be used outside a loop" -msgstr "CONTINUE ã¯ãƒ«ãƒ¼ãƒ—ã®å¤–ã§ã¯ä½¿ãˆã¾ã›ã‚“" - -#: pl_exec.c:338 +#: pl_exec.c:441 #, c-format msgid "control reached end of function without RETURN" msgstr "RETURN ãŒç¾ã‚Œã‚‹å‰ã«ã€åˆ¶å¾¡ãŒé–¢æ•°ã®çµ‚ã‚ã‚Šã«é”ã—ã¾ã—ãŸ" -#: pl_exec.c:345 +#: pl_exec.c:448 msgid "while casting return value to function's return type" msgstr "戻り値を関数ã®æˆ»ã‚Šå€¤ã®åž‹ã¸ã‚­ãƒ£ã‚¹ãƒˆã™ã‚‹éš›ã«" -#: pl_exec.c:358 pl_exec.c:2820 +#: pl_exec.c:461 pl_exec.c:2938 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "値ã®ã‚»ãƒƒãƒˆã‚’å—ã‘付ã‘ãªã„よã†ãªæ–‡è„ˆã§ã€ã‚»ãƒƒãƒˆå€¤ã‚’è¿”ã™é–¢æ•°ãŒå‘¼ã°ã‚Œã¾ã—ãŸ" -#: pl_exec.c:396 pl_exec.c:2663 +#: pl_exec.c:499 pl_exec.c:2779 msgid "returned record type does not match expected record type" msgstr "戻りレコードã®åž‹ãŒæœŸå¾…ã™ã‚‹ãƒ¬ã‚³ãƒ¼ãƒ‰ã®åž‹ã¨ä¸€è‡´ã—ã¾ã›ã‚“" -#: pl_exec.c:456 pl_exec.c:710 pl_exec.c:842 +#: pl_exec.c:554 pl_exec.c:789 pl_exec.c:907 msgid "during function exit" msgstr "関数を抜ã‘ã‚‹éš›ã«" -#: pl_exec.c:706 pl_exec.c:838 +#: pl_exec.c:785 pl_exec.c:903 #, c-format msgid "control reached end of trigger procedure without RETURN" msgstr "RETURN ãŒç¾ã‚Œã‚‹å‰ã«ã€åˆ¶å¾¡ãŒãƒˆãƒªã‚¬ãƒ¼æ‰‹ç¶šãã®çµ‚ã‚ã‚Šã«é”ã—ã¾ã—ãŸ" -#: pl_exec.c:715 +#: pl_exec.c:794 #, c-format msgid "trigger procedure cannot return a set" msgstr "トリガー手続ãã¯ã‚»ãƒƒãƒˆã‚’è¿”ã™ã“ã¨ãŒã§ãã¾ã›ã‚“" -#: pl_exec.c:737 +#: pl_exec.c:816 msgid "returned row structure does not match the structure of the triggering table" msgstr "è¿”ã•ã‚ŒãŸè¡Œã®æ§‹é€ ãŒã€ãƒˆãƒªã‚¬ãƒ¼ã—ã¦ã„るテーブルã®æ§‹é€ ã¨ãƒžãƒƒãƒã—ã¾ã›ã‚“" -#: pl_exec.c:893 +#: pl_exec.c:954 #, c-format msgid "PL/pgSQL function %s line %d %s" msgstr "PL/pgSQL関数%sã®%d行目ã§%s" -#: pl_exec.c:904 +#: pl_exec.c:965 #, c-format msgid "PL/pgSQL function %s %s" msgstr "PL/pgSQL関数%sã§%s" #. translator: last %s is a plpgsql statement type name -#: pl_exec.c:912 +#: pl_exec.c:973 #, c-format msgid "PL/pgSQL function %s line %d at %s" msgstr "PL/pgSQL関数%sã®%d行目ã®åž‹%s" -#: pl_exec.c:918 +#: pl_exec.c:979 #, c-format msgid "PL/pgSQL function %s" msgstr "PL/pgSQL関数%s" -#: pl_exec.c:1027 +#: pl_exec.c:1089 msgid "during statement block local variable initialization" msgstr "ステートメントブロックã§ãƒ­ãƒ¼ã‚«ãƒ«å¤‰æ•°ã‚’åˆæœŸåŒ–ã™ã‚‹éš›ã«" -#: pl_exec.c:1069 +#: pl_exec.c:1128 #, c-format msgid "variable \"%s\" declared NOT NULL cannot default to NULL" msgstr "変数 \"%s\" 㯠NOT NULL ã¨ã—ã¦å®£è¨€ã•ã‚Œã¦ã„ã‚‹ãŸã‚ã€åˆæœŸå€¤ã‚’ NULL ã«ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“" -#: pl_exec.c:1119 +#: pl_exec.c:1178 msgid "during statement block entry" msgstr "ステートメントブロックを登録ã™ã‚‹éš›ã«" -#: pl_exec.c:1140 +#: pl_exec.c:1199 msgid "during statement block exit" msgstr "ステートメントブロックを抜ã‘ã‚‹éš›ã«" -#: pl_exec.c:1183 +#: pl_exec.c:1242 msgid "during exception cleanup" msgstr "例外をクリーンアップã™ã‚‹éš›ã«" -#: pl_exec.c:1536 +#: pl_exec.c:1593 #, c-format msgid "GET STACKED DIAGNOSTICS cannot be used outside an exception handler" msgstr "GET STACKED DIAGNOSTICSã¯ä¾‹å¤–ãƒãƒ³ãƒ‰ãƒ©ã®å¤–ã§ã¯ä½¿ãˆã¾ã›ã‚“" -#: pl_exec.c:1737 +#: pl_exec.c:1789 #, c-format msgid "case not found" msgstr "case ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“" -#: pl_exec.c:1738 +#: pl_exec.c:1790 #, c-format msgid "CASE statement is missing ELSE part." msgstr "CASE ステートメント㫠ELSE 部分ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_exec.c:1890 +#: pl_exec.c:1944 #, c-format msgid "lower bound of FOR loop cannot be null" msgstr "FOR ループã®ä¸‹é™ã‚’ NULL ã«ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“" -#: pl_exec.c:1905 +#: pl_exec.c:1960 #, c-format msgid "upper bound of FOR loop cannot be null" msgstr "FOR ループã®ä¸Šé™ã‚’ NULL ã«ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“" -#: pl_exec.c:1922 +#: pl_exec.c:1978 #, c-format msgid "BY value of FOR loop cannot be null" msgstr "FOR ループã«ãŠã‘ã‚‹ BY ã®å€¤ã‚’ NULL ã«ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“" -#: pl_exec.c:1928 +#: pl_exec.c:1984 #, c-format msgid "BY value of FOR loop must be greater than zero" msgstr "FOR ループã«ãŠã‘ã‚‹ BY ã®å€¤ã¯ã‚¼ãƒ­ã‚ˆã‚Šå¤§ãããªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_exec.c:2098 pl_exec.c:3658 +#: pl_exec.c:2153 pl_exec.c:3910 #, c-format msgid "cursor \"%s\" already in use" msgstr "カーソル \"%s\" ã¯ã™ã§ã«ä½¿ã‚ã‚Œã¦ã„ã¾ã™" -#: pl_exec.c:2121 pl_exec.c:3720 +#: pl_exec.c:2176 pl_exec.c:3972 #, c-format msgid "arguments given for cursor without arguments" msgstr "引数ãªã—ã®ã‚«ãƒ¼ã‚½ãƒ«ã«å¼•æ•°ãŒä¸Žãˆã‚‰ã‚Œã¾ã—ãŸ" -#: pl_exec.c:2140 pl_exec.c:3739 +#: pl_exec.c:2195 pl_exec.c:3991 #, c-format msgid "arguments required for cursor" msgstr "カーソルã«ã¯å¼•æ•°ãŒå¿…è¦ã§ã™" -#: pl_exec.c:2227 +#: pl_exec.c:2280 #, c-format msgid "FOREACH expression must not be null" msgstr "FOREACHå¼ã¯NULLã§ã¯ã„ã‘ã¾ã›ã‚“" -#: pl_exec.c:2233 +#: pl_exec.c:2286 #, c-format msgid "FOREACH expression must yield an array, not type %s" msgstr "FOREACHå¼ã¯%såž‹ã§ã¯ãªãé…列を生æˆã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_exec.c:2250 +#: pl_exec.c:2303 #, c-format msgid "slice dimension (%d) is out of the valid range 0..%d" msgstr "範囲次元%dã¯æœ‰åŠ¹ç¯„囲0ã‹ã‚‰%dã¾ã§ã®é–“ã«ã‚ã‚Šã¾ã›ã‚“" -#: pl_exec.c:2277 +#: pl_exec.c:2330 #, c-format msgid "FOREACH ... SLICE loop variable must be of an array type" msgstr "FOREACH ... SLICEループ変数ã¯é…列型ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_exec.c:2281 +#: pl_exec.c:2334 #, c-format msgid "FOREACH loop variable must not be of an array type" msgstr "FOREACHループ変数ã¯é…列型ã§ã¯ã„ã‘ã¾ã›ã‚“" -#: pl_exec.c:2502 pl_exec.c:2655 +#: pl_exec.c:2522 pl_exec.c:2604 pl_exec.c:2771 #, c-format -#| msgid "while casting return value to function's return type" msgid "cannot return non-composite value from function returning composite type" msgstr "複åˆåž‹ã‚’è¿”ã™é–¢æ•°ã‹ã‚‰è¤‡åˆåž‹ä»¥å¤–ã®å€¤ã‚’è¿”ã™ã“ã¨ã¯ã§ãã¾ã›ã‚“" -#: pl_exec.c:2546 pl_gram.y:3020 +#: pl_exec.c:2648 pl_gram.y:3190 #, c-format msgid "cannot use RETURN NEXT in a non-SETOF function" msgstr "SETOF ã§ãªã„関数ã§ã¯ RETURN NEXT ã¯ä½¿ãˆã¾ã›ã‚“" -#: pl_exec.c:2574 pl_exec.c:2697 +#: pl_exec.c:2682 pl_exec.c:2813 #, c-format msgid "wrong result type supplied in RETURN NEXT" msgstr "RETURN NEXT ã«ãŠã„ã¦èª¤ã£ãŸæˆ»ã‚Šå€¤ã®åž‹ãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã™" -#: pl_exec.c:2597 pl_exec.c:4094 pl_exec.c:4420 pl_exec.c:4455 pl_exec.c:4521 -#: pl_exec.c:4540 pl_exec.c:4608 pl_exec.c:4631 +#: pl_exec.c:2711 pl_exec.c:4380 pl_exec.c:4709 pl_exec.c:4735 pl_exec.c:4801 +#: pl_exec.c:4820 pl_exec.c:4888 pl_exec.c:4911 #, c-format msgid "record \"%s\" is not assigned yet" msgstr "レコード \"%s\" ã«ã¯ã€ã¾ã å€¤ãŒä»£å…¥ã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: pl_exec.c:2599 pl_exec.c:4096 pl_exec.c:4422 pl_exec.c:4457 pl_exec.c:4523 -#: pl_exec.c:4542 pl_exec.c:4610 pl_exec.c:4633 +#: pl_exec.c:2713 pl_exec.c:4382 pl_exec.c:4711 pl_exec.c:4737 pl_exec.c:4803 +#: pl_exec.c:4822 pl_exec.c:4890 pl_exec.c:4913 #, c-format msgid "The tuple structure of a not-yet-assigned record is indeterminate." msgstr "ã¾ã ä»£å…¥ã•ã‚Œã¦ã„ãªã„レコードã®ã‚¿ãƒ—ル構造ã¯ä¸å®šã§ã™" -#: pl_exec.c:2603 pl_exec.c:2623 +#: pl_exec.c:2717 pl_exec.c:2737 #, c-format msgid "wrong record type supplied in RETURN NEXT" msgstr "RETURN NEXT ã«ãŠã„ã¦ã€èª¤ã£ãŸãƒ¬ã‚³ãƒ¼ãƒ‰åž‹ãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã™" -#: pl_exec.c:2715 +#: pl_exec.c:2832 #, c-format msgid "RETURN NEXT must have a parameter" msgstr "RETURN NEXT ã«ã¯ãƒ‘ラメーターãŒå¿…è¦ã§ã™" -#: pl_exec.c:2748 pl_gram.y:3078 +#: pl_exec.c:2865 pl_gram.y:3252 #, c-format msgid "cannot use RETURN QUERY in a non-SETOF function" msgstr "SETOF ã§ãªã„関数ã§ã¯ RETURN QUERY ã¯ä½¿ãˆã¾ã›ã‚“" -#: pl_exec.c:2768 +#: pl_exec.c:2886 msgid "structure of query does not match function result type" msgstr "クエリーã®æ§‹é€ ãŒé–¢æ•°ã®æˆ»ã‚Šå€¤ã®åž‹ã¨ä¸€è‡´ã—ã¾ã›ã‚“" -#: pl_exec.c:2848 pl_exec.c:2980 +#: pl_exec.c:2966 pl_exec.c:3096 #, c-format msgid "RAISE option already specified: %s" msgstr "RAISE オプションã¯æ—¢ã«æŒ‡å®šã•ã‚Œã¦ã„ã¾ã™: %s" -#: pl_exec.c:2881 +#: pl_exec.c:2999 #, c-format msgid "RAISE without parameters cannot be used outside an exception handler" msgstr "引数ã®ç„¡ã„ RAISE ã¯ã€ä¾‹å¤–ãƒãƒ³ãƒ‰ãƒ©ã®å¤–ã§ã¯ä½¿ãˆã¾ã›ã‚“" -#: pl_exec.c:2922 -#, c-format -msgid "too few parameters specified for RAISE" -msgstr "RAISE ã«æŒ‡å®šã•ã‚ŒãŸãƒ‘ラメーターã®æ•°ãŒè¶³ã‚Šã¾ã›ã‚“" - -#: pl_exec.c:2950 -#, c-format -msgid "too many parameters specified for RAISE" -msgstr "RAISE ã«æŒ‡å®šã•ã‚ŒãŸãƒ‘ラメーターã®æ•°ãŒå¤šã™ãŽã¾ã™" - -#: pl_exec.c:2970 +#: pl_exec.c:3086 #, c-format msgid "RAISE statement option cannot be null" msgstr "RAISE ステートメントã®ã‚ªãƒ—ションã«ã¯ NULL ã¯æŒ‡å®šã§ãã¾ã›ã‚“" -#: pl_exec.c:3041 +#: pl_exec.c:3155 #, c-format msgid "%s" msgstr "%s" -#: pl_exec.c:3211 pl_exec.c:3348 pl_exec.c:3521 +#: pl_exec.c:3226 +#, c-format +msgid "assertion failed" +msgstr "アサーションã«å¤±æ•—ã—ã¾ã—ãŸ" + +#: pl_exec.c:3416 pl_exec.c:3560 pl_exec.c:3749 #, c-format msgid "cannot COPY to/from client in PL/pgSQL" msgstr "PL/pgSQL 内ã§ã¯ COPY to/from ã¯ä½¿ãˆã¾ã›ã‚“" -#: pl_exec.c:3215 pl_exec.c:3352 pl_exec.c:3525 +#: pl_exec.c:3420 pl_exec.c:3564 pl_exec.c:3753 #, c-format msgid "cannot begin/end transactions in PL/pgSQL" msgstr "PL/pgSQL 内ã§ã¯ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’開始ï¼çµ‚了ã§ãã¾ã›ã‚“" -#: pl_exec.c:3216 pl_exec.c:3353 pl_exec.c:3526 +#: pl_exec.c:3421 pl_exec.c:3565 pl_exec.c:3754 #, c-format msgid "Use a BEGIN block with an EXCEPTION clause instead." msgstr "代ã‚ã‚Šã« EXCEPTION å¥ã‚’伴ㆠBEGIN ブロックを使用ã—ã¦ãã ã•ã„" -#: pl_exec.c:3376 pl_exec.c:3550 +#: pl_exec.c:3588 pl_exec.c:3778 #, c-format msgid "INTO used with a command that cannot return data" msgstr "データを返ã›ãªã„命令㧠INTO ãŒä½¿ã‚ã‚Œã¾ã—ãŸ" -#: pl_exec.c:3396 pl_exec.c:3570 +#: pl_exec.c:3616 pl_exec.c:3806 #, c-format msgid "query returned no rows" msgstr "クエリーã¯è¡Œã‚’è¿”ã—ã¾ã›ã‚“ã§ã—ãŸ" -#: pl_exec.c:3405 pl_exec.c:3579 +#: pl_exec.c:3635 pl_exec.c:3825 #, c-format msgid "query returned more than one row" msgstr "クエリーãŒè¤‡æ•°ã®è¡Œã‚’è¿”ã—ã¾ã—ãŸ" -#: pl_exec.c:3420 +#: pl_exec.c:3652 #, c-format msgid "query has no destination for result data" msgstr "クエリーã«çµæžœãƒ‡ãƒ¼ã‚¿ã®è¿”å´å…ˆãŒæŒ‡å®šã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: pl_exec.c:3421 +#: pl_exec.c:3653 #, c-format msgid "If you want to discard the results of a SELECT, use PERFORM instead." msgstr "SELECT ã®çµæžœã‚’破棄ã—ãŸã„å ´åˆã¯ã€ä»£ã‚ã‚Šã« PERFORM を使ã£ã¦ãã ã•ã„" -#: pl_exec.c:3454 pl_exec.c:6414 +#: pl_exec.c:3685 pl_exec.c:7130 #, c-format msgid "query string argument of EXECUTE is null" msgstr "EXECUTE ã®ã‚¯ã‚¨ãƒªãƒ¼æ–‡å­—列ã®å¼•æ•°ãŒ NULL ã§ã™" -#: pl_exec.c:3513 +#: pl_exec.c:3741 #, c-format msgid "EXECUTE of SELECT ... INTO is not implemented" msgstr "SELECT ... INTO ã® EXECUTE ã¯å®Ÿè£…ã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: pl_exec.c:3514 +#: pl_exec.c:3742 #, c-format msgid "You might want to use EXECUTE ... INTO or EXECUTE CREATE TABLE ... AS instead." msgstr "代ã‚ã‚Šã«EXECUTE ... INTOã¾ãŸã¯EXECUTE CREATE TABLE ... ASを使用ã™ã‚‹æ–¹ãŒã‚ˆã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。" -#: pl_exec.c:3802 pl_exec.c:3894 +#: pl_exec.c:4054 pl_exec.c:4146 #, c-format msgid "cursor variable \"%s\" is null" msgstr "カーソル変数 \"%s\" ㌠NULL ã§ã™" -#: pl_exec.c:3809 pl_exec.c:3901 +#: pl_exec.c:4061 pl_exec.c:4153 #, c-format msgid "cursor \"%s\" does not exist" msgstr "カーソル \"%s\" ã¯å­˜åœ¨ã—ã¾ã›ã‚“" -#: pl_exec.c:3823 +#: pl_exec.c:4075 #, c-format msgid "relative or absolute cursor position is null" msgstr "相対もã—ãã¯çµ¶å¯¾ã‚«ãƒ¼ã‚½ãƒ«ä½ç½®ãŒ NULL ã§ã™" -#: pl_exec.c:3990 +#: pl_exec.c:4255 #, c-format msgid "null value cannot be assigned to variable \"%s\" declared NOT NULL" msgstr "NOT NULL ã¨ã—ã¦å®£è¨€ã•ã‚ŒãŸå¤‰æ•° \"%s\" ã«ã¯ NULL を代入ã§ãã¾ã›ã‚“" -#: pl_exec.c:4037 +#: pl_exec.c:4324 #, c-format msgid "cannot assign non-composite value to a row variable" msgstr "複åˆå€¤ã§ãªã„値を行変数ã«ä»£å…¥ã§ãã¾ã›ã‚“" -#: pl_exec.c:4061 +#: pl_exec.c:4348 #, c-format msgid "cannot assign non-composite value to a record variable" msgstr "複åˆå€¤ã§ãªã„値をレコード変数ã«ä»£å…¥ã§ãã¾ã›ã‚“" -#: pl_exec.c:4206 +#: pl_exec.c:4491 #, c-format msgid "number of array dimensions (%d) exceeds the maximum allowed (%d)" msgstr "é…列ã®æ¬¡å…ƒæ•°(%d)ãŒæŒ‡å®šå¯èƒ½ãªæœ€å¤§å€¤(%d)を超ãˆã¦ã„ã¾ã™" -#: pl_exec.c:4238 +#: pl_exec.c:4523 #, c-format msgid "subscripted object is not an array" msgstr "添字ã¤ãオブジェクトã¯é…列ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: pl_exec.c:4275 +#: pl_exec.c:4560 #, c-format msgid "array subscript in assignment must not be null" msgstr "代入ã«ãŠã‘ã‚‹é…列ã®æ·»å­—㌠NULL ã§ã‚ã£ã¦ã¯ãªã‚Šã¾ã›ã‚“" -#: pl_exec.c:4744 +#: pl_exec.c:5027 #, c-format msgid "query \"%s\" did not return data" msgstr "クエリー \"%s\" ãŒãƒ‡ãƒ¼ã‚¿ã‚’è¿”ã—ã¾ã›ã‚“ã§ã—ãŸ" -#: pl_exec.c:4752 +#: pl_exec.c:5035 #, c-format msgid "query \"%s\" returned %d column" msgid_plural "query \"%s\" returned %d columns" msgstr[0] "クエリー \"%s\" ㌠%d 個ã®åˆ—ã‚’è¿”ã—ã¾ã—ãŸ" msgstr[1] "クエリー \"%s\" ㌠%d 個ã®åˆ—ã‚’è¿”ã—ã¾ã—ãŸ" -#: pl_exec.c:4778 +#: pl_exec.c:5062 #, c-format msgid "query \"%s\" returned more than one row" msgstr "クエリー \"%s\" ãŒè¤‡æ•°ã®è¡Œã‚’è¿”ã—ã¾ã—ãŸ" -#: pl_exec.c:4835 +#: pl_exec.c:5126 #, c-format msgid "query \"%s\" is not a SELECT" msgstr "クエリー \"%s\" ㌠SELECT ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: pl_funcs.c:218 +#: pl_funcs.c:237 msgid "statement block" msgstr "ステートメントブロック" -#: pl_funcs.c:220 +#: pl_funcs.c:239 msgid "assignment" msgstr "代入" -#: pl_funcs.c:230 +#: pl_funcs.c:249 msgid "FOR with integer loop variable" msgstr "æ•´æ•°ã®ãƒ«ãƒ¼ãƒ—変数を伴ㆠFOR" -#: pl_funcs.c:232 +#: pl_funcs.c:251 msgid "FOR over SELECT rows" msgstr "SELECT 行を制御ã™ã‚‹ FOR" -#: pl_funcs.c:234 +#: pl_funcs.c:253 msgid "FOR over cursor" msgstr "カーソルを制御ã™ã‚‹ FOR" -#: pl_funcs.c:236 +#: pl_funcs.c:255 msgid "FOREACH over array" msgstr "é…列全体ã«å¯¾ã™ã‚‹FOREACH" -#: pl_funcs.c:248 +#: pl_funcs.c:269 msgid "SQL statement" msgstr "SQL ステートメント" -#: pl_funcs.c:250 -msgid "EXECUTE statement" -msgstr "EXECUTE ステートメント" - -#: pl_funcs.c:252 +#: pl_funcs.c:273 msgid "FOR over EXECUTE statement" msgstr "EXECUTE ステートメントを制御ã™ã‚‹ FOR" -#: pl_gram.y:450 +#: pl_gram.y:474 #, c-format msgid "block label must be placed before DECLARE, not after" msgstr "ブロックラベル㯠DECLARE ã®å¾Œã§ã¯ãªãå‰ã«ç½®ã‹ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_gram.y:470 +#: pl_gram.y:494 #, c-format msgid "collations are not supported by type %s" msgstr "%såž‹ã§ã¯ç…§åˆé †åºã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã›ã‚“" -#: pl_gram.y:485 +#: pl_gram.y:509 #, c-format msgid "row or record variable cannot be CONSTANT" msgstr "è¡Œã¾ãŸã¯ãƒ¬ã‚³ãƒ¼ãƒ‰å¤‰æ•°ã‚’ CONSTANT ã«ã¯ã§ãã¾ã›ã‚“" -#: pl_gram.y:495 +#: pl_gram.y:519 #, c-format msgid "row or record variable cannot be NOT NULL" msgstr "è¡Œã¾ãŸã¯ãƒ¬ã‚³ãƒ¼ãƒ‰å¤‰æ•°ã‚’ NOT NULL ã«ã¯ã§ãã¾ã›ã‚“" -#: pl_gram.y:506 +#: pl_gram.y:530 #, c-format msgid "default value for row or record variable is not supported" msgstr "è¡Œã¾ãŸã¯ãƒ¬ã‚³ãƒ¼ãƒ‰å¤‰æ•°ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤æŒ‡å®šã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“" -#: pl_gram.y:651 pl_gram.y:666 pl_gram.y:692 +#: pl_gram.y:675 pl_gram.y:690 pl_gram.y:716 #, c-format msgid "variable \"%s\" does not exist" msgstr "変数\"%s\"ã¯å­˜åœ¨ã—ã¾ã›ã‚“" -#: pl_gram.y:710 pl_gram.y:723 +#: pl_gram.y:734 pl_gram.y:762 msgid "duplicate declaration" msgstr "é‡è¤‡ã—ãŸå®£è¨€ã§ã™ã€‚" -#: pl_gram.y:901 +#: pl_gram.y:745 pl_gram.y:773 +#, c-format +msgid "variable \"%s\" shadows a previously defined variable" +msgstr "変数\"%s\"ã¯ä»¥å‰ã«å®šç¾©ã—ãŸå¤‰æ•°ã‚’éš ã—ã¾ã™" + +#: pl_gram.y:952 #, c-format msgid "diagnostics item %s is not allowed in GET STACKED DIAGNOSTICS" msgstr "GET STACKED DIAGNOSTICSã§ã¯è¨ºæ–­é …ç›®%sã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: pl_gram.y:919 +#: pl_gram.y:970 #, c-format msgid "diagnostics item %s is not allowed in GET CURRENT DIAGNOSTICS" msgstr "GET CURRENT DIAGNOSTICSã§ã¯è¨ºæ–­é …ç›®%sã¯è¨±ã•ã‚Œã¾ã›ã‚“" -#: pl_gram.y:1017 +#: pl_gram.y:1068 msgid "unrecognized GET DIAGNOSTICS item" msgstr "GET DIAGNOSTICS é …ç›®ãŒèªè­˜ã§ãã¾ã›ã‚“" -#: pl_gram.y:1028 pl_gram.y:3265 +#: pl_gram.y:1079 pl_gram.y:3439 #, c-format msgid "\"%s\" is not a scalar variable" msgstr "\"%s\" ã¯ã‚¹ã‚«ãƒ©ãƒ¼å¤‰æ•°ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:1280 pl_gram.y:1474 +#: pl_gram.y:1331 pl_gram.y:1525 #, c-format msgid "loop variable of loop over rows must be a record or row variable or list of scalar variables" msgstr "行をã¾ãŸãŒã‚‹ãƒ«ãƒ¼ãƒ—ã«ãŠã‘るループ変数ã¯ã€ãƒ¬ã‚³ãƒ¼ãƒ‰ã€è¡Œå¤‰æ•°ã€ã‚¹ã‚«ãƒ©ãƒ¼å¤‰æ•°ä¸¦ã³ã®ã„ãšã‚Œã‹ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_gram.y:1314 +#: pl_gram.y:1365 #, c-format msgid "cursor FOR loop must have only one target variable" msgstr "カーソルを使ã£ãŸ FOR ループã«ã¯ã€ã‚¿ãƒ¼ã‚²ãƒƒãƒˆå¤‰æ•°ãŒï¼‘個ã ã‘å¿…è¦ã§ã™" -#: pl_gram.y:1321 +#: pl_gram.y:1372 #, c-format msgid "cursor FOR loop must use a bound cursor variable" msgstr "カーソルを使ã£ãŸ FOR ループã§ã¯ã€ãã‚Œã«é–¢é€£ä»˜ã‘られãŸã‚«ãƒ¼ã‚½ãƒ«å¤‰æ•°ã‚’使用ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_gram.y:1405 +#: pl_gram.y:1456 #, c-format msgid "integer FOR loop must have only one target variable" msgstr "整数を使ã£ãŸ FOR ループã«ã¯ã€ã‚¿ãƒ¼ã‚²ãƒƒãƒˆå¤‰æ•°ãŒï¼‘個ã ã‘å¿…è¦ã§ã™" -#: pl_gram.y:1441 +#: pl_gram.y:1492 #, c-format msgid "cannot specify REVERSE in query FOR loop" msgstr "クエリーを使ã£ãŸ FOR ループã®ä¸­ã§ã¯ REVERSE ã¯æŒ‡å®šã§ãã¾ã›ã‚“" -#: pl_gram.y:1588 +#: pl_gram.y:1639 #, c-format msgid "loop variable of FOREACH must be a known variable or list of variables" msgstr "FOREACHã®ãƒ«ãƒ¼ãƒ—変数ã¯æ—¢çŸ¥ã®å¤‰æ•°ã¾ãŸã¯å¤‰æ•°ã®ãƒªã‚¹ãƒˆã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_gram.y:1640 pl_gram.y:1677 pl_gram.y:1725 pl_gram.y:2721 pl_gram.y:2802 -#: pl_gram.y:2913 pl_gram.y:3666 +#: pl_gram.y:1680 +#, c-format +msgid "there is no label \"%s\" attached to any block or loop enclosing this statement" +msgstr "ã“ã®ã‚¹ãƒ†ãƒ¼ãƒˆãƒ¡ãƒ³ãƒˆã‚’囲むブロックã¾ãŸã¯ãƒ«ãƒ¼ãƒ—ã«ãƒ©ãƒ™ãƒ« \"%s\" ã¯ã‚ã‚Šã¾ã›ã‚“" + +#: pl_gram.y:1688 +#, c-format +msgid "block label \"%s\" cannot be used in CONTINUE" +msgstr "ブロックラベル \"%s\" ã¯CONTINUEã®ä¸­ã§ã¯ä½¿ãˆã¾ã›ã‚“" + +#: pl_gram.y:1703 +#, c-format +msgid "EXIT cannot be used outside a loop, unless it has a label" +msgstr "ラベルãŒãªã„é™ã‚Šã€EXIT ã¯ãƒ«ãƒ¼ãƒ—ã®å¤–ã§ã¯ä½¿ãˆã¾ã›ã‚“" + +#: pl_gram.y:1704 +#, c-format +msgid "CONTINUE cannot be used outside a loop" +msgstr "CONTINUE ã¯ãƒ«ãƒ¼ãƒ—ã®å¤–ã§ã¯ä½¿ãˆã¾ã›ã‚“" + +#: pl_gram.y:1728 pl_gram.y:1765 pl_gram.y:1813 pl_gram.y:2889 pl_gram.y:2974 +#: pl_gram.y:3085 pl_gram.y:3841 msgid "unexpected end of function definition" msgstr "予期ã—ãªã„関数定義ã®çµ‚端ã«é”ã—ã¾ã—ãŸ" -#: pl_gram.y:1745 pl_gram.y:1769 pl_gram.y:1785 pl_gram.y:1791 pl_gram.y:1880 -#: pl_gram.y:1888 pl_gram.y:1902 pl_gram.y:1997 pl_gram.y:2178 pl_gram.y:2261 -#: pl_gram.y:2394 pl_gram.y:3508 pl_gram.y:3569 pl_gram.y:3647 +#: pl_gram.y:1833 pl_gram.y:1857 pl_gram.y:1873 pl_gram.y:1879 pl_gram.y:1997 +#: pl_gram.y:2005 pl_gram.y:2019 pl_gram.y:2114 pl_gram.y:2295 pl_gram.y:2389 +#: pl_gram.y:2541 pl_gram.y:3682 pl_gram.y:3743 pl_gram.y:3822 msgid "syntax error" msgstr "構文エラー" -#: pl_gram.y:1773 pl_gram.y:1775 pl_gram.y:2182 pl_gram.y:2184 +#: pl_gram.y:1861 pl_gram.y:1863 pl_gram.y:2299 pl_gram.y:2301 msgid "invalid SQLSTATE code" msgstr "無効㪠SQLSTATE コードã§ã™" -#: pl_gram.y:1944 +#: pl_gram.y:2061 msgid "syntax error, expected \"FOR\"" msgstr "構文エラー。\"FOR\" を期待ã—ã¦ã„ã¾ã—ãŸ" -#: pl_gram.y:2006 +#: pl_gram.y:2123 #, c-format msgid "FETCH statement cannot return multiple rows" msgstr "FETCH ステートメントã¯è¤‡æ•°è¡Œã‚’è¿”ã›ã¾ã›ã‚“" -#: pl_gram.y:2062 +#: pl_gram.y:2179 #, c-format msgid "cursor variable must be a simple variable" msgstr "カーソル変数ã¯å˜ç´”変数ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_gram.y:2068 +#: pl_gram.y:2185 #, c-format msgid "variable \"%s\" must be of type cursor or refcursor" msgstr "変数 \"%s\" 㯠cursor åž‹ã¾ãŸã¯ refcursor åž‹ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: pl_gram.y:2236 -msgid "label does not exist" -msgstr "ラベルãŒå­˜åœ¨ã—ã¾ã›ã‚“" - -#: pl_gram.y:2365 pl_gram.y:2376 +#: pl_gram.y:2512 pl_gram.y:2523 #, c-format msgid "\"%s\" is not a known variable" msgstr "\"%s\"ã¯æ—¢çŸ¥ã®å¤‰æ•°ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:2480 pl_gram.y:2490 pl_gram.y:2645 +#: pl_gram.y:2627 pl_gram.y:2637 pl_gram.y:2793 msgid "mismatched parentheses" msgstr "カッコãŒå¯¾å¿œã—ã¦ã„ã¾ã›ã‚“" -#: pl_gram.y:2494 +#: pl_gram.y:2641 #, c-format msgid "missing \"%s\" at end of SQL expression" msgstr "SQL 表ç¾å¼ã®çµ‚端㫠\"%s\" ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:2500 +#: pl_gram.y:2647 #, c-format msgid "missing \"%s\" at end of SQL statement" msgstr "SQL ステートメントã®çµ‚端㫠\"%s\" ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:2517 +#: pl_gram.y:2664 msgid "missing expression" msgstr "表ç¾å¼ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:2519 +#: pl_gram.y:2666 msgid "missing SQL statement" msgstr "SQLステートメントãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:2647 +#: pl_gram.y:2795 msgid "incomplete data type declaration" msgstr "データ型ã®å®šç¾©ãŒä¸å®Œå…¨ã§ã™" -#: pl_gram.y:2670 +#: pl_gram.y:2818 msgid "missing data type declaration" msgstr "データ型ã®å®šç¾©ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:2726 +#: pl_gram.y:2897 msgid "INTO specified more than once" msgstr "INTO ãŒè¤‡æ•°å›žæŒ‡å®šã•ã‚Œã¦ã„ã¾ã™" -#: pl_gram.y:2894 +#: pl_gram.y:3066 msgid "expected FROM or IN" msgstr "FROM ã‚‚ã—ã㯠IN を期待ã—ã¦ã„ã¾ã—ãŸ" -#: pl_gram.y:2954 +#: pl_gram.y:3126 #, c-format msgid "RETURN cannot have a parameter in function returning set" msgstr "値ã®ã‚»ãƒƒãƒˆã‚’è¿”ã™é–¢æ•°ã§ã¯ã€RETURNã«ãƒ‘ラメータを指定ã§ãã¾ã›ã‚“" -#: pl_gram.y:2955 +#: pl_gram.y:3127 #, c-format msgid "Use RETURN NEXT or RETURN QUERY." msgstr "RETURN NEXT ã‚‚ã—ã㯠RETURN QUERY を使用ã—ã¦ãã ã•ã„" -#: pl_gram.y:2963 +#: pl_gram.y:3135 #, c-format msgid "RETURN cannot have a parameter in function with OUT parameters" msgstr "OUT パラメータã®ãªã„関数ã§ã¯ã€RETURN ã«ã¯ãƒ‘ラメータを指定ã§ãã¾ã›ã‚“" -#: pl_gram.y:2972 +#: pl_gram.y:3144 #, c-format msgid "RETURN cannot have a parameter in function returning void" msgstr "void ã‚’è¿”ã™é–¢æ•°ã§ã¯ã€RETURN ã«ã¯ãƒ‘ラメータを指定ã§ãã¾ã›ã‚“" -#: pl_gram.y:3034 +#: pl_gram.y:3204 #, c-format msgid "RETURN NEXT cannot have a parameter in function with OUT parameters" msgstr "OUT パラメータã®ãªã„関数ã§ã¯ã€RETURN NEXT ã«ã¯ãƒ‘ラメータを指定ã§ãã¾ã›ã‚“" -#: pl_gram.y:3134 +#: pl_gram.y:3308 #, c-format msgid "\"%s\" is declared CONSTANT" msgstr "\"%s\" 㯠CONSTANT ã¨ã—ã¦å®£è¨€ã•ã‚Œã¦ã„ã¾ã™" -#: pl_gram.y:3196 pl_gram.y:3208 +#: pl_gram.y:3370 pl_gram.y:3382 #, c-format msgid "record or row variable cannot be part of multiple-item INTO list" msgstr "レコードもã—ãã¯è¡Œå¤‰æ•°ã¯ã€è¤‡æ•°é …目をæŒã¤ INTO リストã®ä¸€éƒ¨åˆ†ã¨ã—ã¦ã¯æŒ‡å®šã§ãã¾ã›ã‚“" -#: pl_gram.y:3253 +#: pl_gram.y:3427 #, c-format msgid "too many INTO variables specified" msgstr "INTO 変数ã®æŒ‡å®šãŒå¤šã™ãŽã¾ã™" -#: pl_gram.y:3461 +#: pl_gram.y:3635 #, c-format msgid "end label \"%s\" specified for unlabelled block" msgstr "ラベル無ã—ブロックã§çµ‚端ラベル \"%s\" ãŒæŒ‡å®šã•ã‚Œã¾ã—ãŸ" -#: pl_gram.y:3468 +#: pl_gram.y:3642 #, c-format msgid "end label \"%s\" differs from block's label \"%s\"" msgstr "終端ラベル \"%s\" ãŒãƒ–ロックã®ãƒ©ãƒ™ãƒ« \"%s\" ã¨ç•°ãªã‚Šã¾ã™" -#: pl_gram.y:3503 +#: pl_gram.y:3677 #, c-format msgid "cursor \"%s\" has no arguments" msgstr "カーソル \"%s\" ã«å¼•æ•°ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:3517 +#: pl_gram.y:3691 #, c-format msgid "cursor \"%s\" has arguments" msgstr "カーソル \"%s\" ã«å¼•æ•°ãŒã¤ã„ã¦ã„ã¾ã™" -#: pl_gram.y:3559 +#: pl_gram.y:3733 #, c-format msgid "cursor \"%s\" has no argument named \"%s\"" msgstr "カーソル\"%s\"ã«\"%s\"ã¨ã„ã†åå‰ã®å¼•æ•°ãŒã‚ã‚Šã¾ã›ã‚“" -#: pl_gram.y:3579 +#: pl_gram.y:3753 #, c-format msgid "value for parameter \"%s\" of cursor \"%s\" specified more than once" msgstr "カーソル\"%2$s\"ã®ãƒ‘ラメータ\"%1$s\"ã®å€¤ãŒè¤‡æ•°æŒ‡å®šã•ã‚Œã¾ã—ãŸ" -#: pl_gram.y:3604 +#: pl_gram.y:3778 #, c-format msgid "not enough arguments for cursor \"%s\"" msgstr "カーソル\"%s\"ã®å¼•æ•°ãŒä¸è¶³ã—ã¦ã„ã¾ã™" -#: pl_gram.y:3611 +#: pl_gram.y:3785 #, c-format msgid "too many arguments for cursor \"%s\"" msgstr "カーソル\"%s\"ã«å¯¾ã™ã‚‹å¼•æ•°ãŒå¤šã™ãŽã¾ã™" -#: pl_gram.y:3698 +#: pl_gram.y:3873 msgid "unrecognized RAISE statement option" msgstr "RAISE ステートメントã®ã‚ªãƒ—ションをèªè­˜ã§ãã¾ã›ã‚“" -#: pl_gram.y:3702 +#: pl_gram.y:3877 msgid "syntax error, expected \"=\"" msgstr "構文エラー。\"=\" を期待ã—ã¦ã„ã¾ã—ãŸ" -#: pl_handler.c:61 +#: pl_gram.y:3918 +#, c-format +msgid "too many parameters specified for RAISE" +msgstr "RAISE ã«æŒ‡å®šã•ã‚ŒãŸãƒ‘ラメーターã®æ•°ãŒå¤šã™ãŽã¾ã™" + +#: pl_gram.y:3922 +#, c-format +msgid "too few parameters specified for RAISE" +msgstr "RAISE ã«æŒ‡å®šã•ã‚ŒãŸãƒ‘ラメーターã®æ•°ãŒè¶³ã‚Šã¾ã›ã‚“" + +#: pl_handler.c:151 msgid "Sets handling of conflicts between PL/pgSQL variable names and table column names." msgstr "PL/pgSQL変数åã¨ãƒ†ãƒ¼ãƒ–ルã®ã‚«ãƒ©ãƒ åã®é–“ã®è¡çªå‡¦ç†ã‚’設定ã—ã¦ãã ã•ã„" +#: pl_handler.c:160 +msgid "Print information about parameters in the DETAIL part of the error messages generated on INTO ... STRICT failures." +msgstr "INTO ... STRICT ã®å¤±æ•—ã§ç™ºç”Ÿã—ãŸã‚¨ãƒ©ãƒ¼ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã®DETAIL部分ã§ã€ãƒ‘ラメータã«ã¤ã„ã¦ã®æƒ…報を表示ã—ã¾ã™ã€‚" + +#: pl_handler.c:168 +msgid "Perform checks given in ASSERT statements." +msgstr "ASSERTæ–‡ã§ã®æ¤œæŸ»ã‚’実行ã—ã¾ã™ã€‚" + +#: pl_handler.c:176 +msgid "List of programming constructs that should produce a warning." +msgstr "警告を生æˆã™ã‚‹ãƒ—ログラミング構造ã®ä¸€è¦§ã§ã™ã€‚" + +#: pl_handler.c:186 +msgid "List of programming constructs that should produce an error." +msgstr "エラーを生æˆã™ã‚‹ãƒ—ログラミング構造ã®ä¸€è¦§ã§ã™ã€‚" + #. translator: %s is typically the translation of "syntax error" -#: pl_scanner.c:553 +#: pl_scanner.c:622 #, c-format msgid "%s at end of input" msgstr "入力ã®æœ€å¾Œã§ %s" #. translator: first %s is typically the translation of "syntax error" -#: pl_scanner.c:569 +#: pl_scanner.c:638 #, c-format msgid "%s at or near \"%s\"" msgstr "\"%2$s\" ã‚‚ã—ãã¯ãã®è¿‘辺㧠%1$s" -#~ msgid "RETURN must specify a record or row variable in function returning row" -#~ msgstr "行を返ã™é–¢æ•°ã§ã¯ã€RETURN ã«ãƒ¬ã‚³ãƒ¼ãƒ‰ã¾ãŸã¯è¡Œå¤‰æ•°ã‚’指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" - -#~ msgid "syntax error; also virtual memory exhausted" -#~ msgstr "構文エラー: 仮想メモリも枯渇ã—ã¾ã—ãŸ" - -#~ msgid "parser stack overflow" -#~ msgstr "パーサã®ã‚¹ã‚¿ãƒƒã‚¯ãŒã‚ªãƒ¼ãƒãƒ¼ãƒ•ãƒ­ãƒ¼ã—ã¾ã—ãŸ" - -#~ msgid "relation \"%s.%s\" does not exist" -#~ msgstr "リレーション \"%s.%s\" ãŒã‚ã‚Šã¾ã›ã‚“" - -#~ msgid "RETURN NEXT must specify a record or row variable in function returning row" -#~ msgstr "行を返ã™é–¢æ•°ã§ã¯ã€RETURN NEXT ã«ãƒ¬ã‚³ãƒ¼ãƒ‰ã¾ãŸã¯è¡Œå¤‰æ•°ã‚’指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#~ msgid "syntax error: cannot back up" -#~ msgstr "構文エラー: ãƒãƒƒã‚¯ã‚¢ãƒƒãƒ—ã§ãã¾ã›ã‚“" diff --git a/src/pl/plpython/po/fr.po b/src/pl/plpython/po/fr.po index 9784517018..2db977f6d6 100644 --- a/src/pl/plpython/po/fr.po +++ b/src/pl/plpython/po/fr.po @@ -8,8 +8,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-09-23 20:07+0000\n" -"PO-Revision-Date: 2016-09-24 18:10+0200\n" +"POT-Creation-Date: 2017-02-06 16:07+0000\n" +"PO-Revision-Date: 2017-02-06 19:02+0100\n" "Last-Translator: Guillaume Lelarge \n" "Language-Team: French \n" "Language: fr\n" @@ -17,7 +17,7 @@ msgstr "" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n > 1);\n" -"X-Generator: Poedit 1.8.7\n" +"X-Generator: Poedit 1.8.11\n" #: plpy_cursorobject.c:101 #, c-format @@ -66,7 +66,7 @@ msgstr "le résultat de la requête contient trop de lignes pour être intégré msgid "closing a cursor in an aborted subtransaction" msgstr "fermeture d'un curseur dans une sous-transaction annulée" -#: plpy_elog.c:127 plpy_elog.c:128 plpy_plpymodule.c:527 +#: plpy_elog.c:127 plpy_elog.c:128 plpy_plpymodule.c:548 #, c-format msgid "%s" msgstr "%s" @@ -233,46 +233,51 @@ msgstr "bloc de code PL/Python anonyme" msgid "plan.status takes no arguments" msgstr "plan.status ne prends pas d'arguments" -#: plpy_plpymodule.c:178 plpy_plpymodule.c:181 +#: plpy_plpymodule.c:181 plpy_plpymodule.c:184 #, c-format msgid "could not import \"plpy\" module" msgstr "n'a pas pu importer le module « plpy »" -#: plpy_plpymodule.c:196 +#: plpy_plpymodule.c:199 +#, c-format +msgid "could not create the spiexceptions module" +msgstr "n'a pas pu créer le module « spiexceptions »" + +#: plpy_plpymodule.c:207 #, c-format msgid "could not add the spiexceptions module" msgstr "n'a pas pu ajouter le module « spiexceptions »" -#: plpy_plpymodule.c:217 +#: plpy_plpymodule.c:236 #, c-format -msgid "could not create the base SPI exceptions" -msgstr "n'a pas pu créer les exceptions SPI de base" +msgid "could not create exception \"%s\"" +msgstr "n'a pas pu créer l'exception « %s »" -#: plpy_plpymodule.c:252 plpy_plpymodule.c:256 +#: plpy_plpymodule.c:271 plpy_plpymodule.c:275 #, c-format msgid "could not generate SPI exceptions" msgstr "n'a pas pu générer les exceptions SPI" -#: plpy_plpymodule.c:422 +#: plpy_plpymodule.c:443 #, c-format msgid "could not unpack arguments in plpy.elog" msgstr "n'a pas pu déballer les arguments dans plpy.elog" -#: plpy_plpymodule.c:431 +#: plpy_plpymodule.c:452 msgid "could not parse error message in plpy.elog" msgstr "n'a pas pu analyser le message d'erreur dans plpy.elog" -#: plpy_plpymodule.c:448 +#: plpy_plpymodule.c:469 #, c-format msgid "Argument 'message' given by name and position" msgstr "Argument 'message' donn\" par nom et position" -#: plpy_plpymodule.c:475 +#: plpy_plpymodule.c:496 #, c-format msgid "'%s' is an invalid keyword argument for this function" msgstr "'%s' est une argument mot-clé invalide pour cette fonction" -#: plpy_plpymodule.c:486 plpy_plpymodule.c:492 +#: plpy_plpymodule.c:507 plpy_plpymodule.c:513 #, c-format msgid "invalid SQLSTATE code" msgstr "code SQLSTATE invalide" @@ -453,74 +458,77 @@ msgstr "n'a pas pu convertir l'objet Unicode Python en octets" msgid "could not extract bytes from encoded string" msgstr "n'a pas pu extraire les octets de la chaîne encodée" -#~ msgid "Python major version mismatch in session" -#~ msgstr "Différence de version majeure de Python dans la session" +#~ msgid "the message is already specified" +#~ msgstr "le message est déjà spécifié" -#~ msgid "This session has previously used Python major version %d, and it is now attempting to use Python major version %d." -#~ msgstr "" -#~ "Cette session a auparavant utilisé la version majeure %d de Python et elle\n" -#~ "essaie maintenant d'utiliser la version majeure %d." +#~ msgid "plpy.prepare does not support composite types" +#~ msgstr "plpy.prepare ne supporte pas les types composites" -#~ msgid "Start a new session to use a different Python major version." -#~ msgstr "" -#~ "Lancez une nouvelle session pour utiliser une version majeure différente de\n" -#~ "Python." +#~ msgid "PL/Python does not support conversion to arrays of row types." +#~ msgstr "PL/Python ne supporte pas les conversions vers des tableaux de types row." -#~ msgid "PL/Python function \"%s\" could not execute plan" -#~ msgstr "la fonction PL/python « %s » n'a pas pu exécuter un plan" +#~ msgid "unrecognized error in PLy_spi_execute_fetch_result" +#~ msgstr "erreur inconnue dans PLy_spi_execute_fetch_result" -#~ msgid "could not create string representation of Python object in PL/Python function \"%s\" while creating return value" -#~ msgstr "" -#~ "n'a pas pu créer la représentation en chaîne de caractère de l'objet\n" -#~ "Python dans la fonction PL/python « %s » lors de la création de la valeur\n" -#~ "de retour" +#~ msgid "PyCObject_AsVoidPtr() failed" +#~ msgstr "échec de PyCObject_AsVoidPtr()" -#~ msgid "could not compute string representation of Python object in PL/Python function \"%s\" while modifying trigger row" -#~ msgstr "" -#~ "n'a pas pu traiter la représentation de la chaîne d'un objet Python dans\n" -#~ "la fonction PL/Python « %s » lors de la modification de la ligne du trigger" +#~ msgid "PyCObject_FromVoidPtr() failed" +#~ msgstr "échec de PyCObject_FromVoidPtr()" -#~ msgid "PL/Python function \"%s\" failed" -#~ msgstr "échec de la fonction PL/python « %s »" +#~ msgid "transaction aborted" +#~ msgstr "transaction annulée" -#~ msgid "out of memory" -#~ msgstr "mémoire épuisée" +#~ msgid "invalid arguments for plpy.prepare" +#~ msgstr "arguments invalides pour plpy.prepare" -#~ msgid "PL/Python: %s" -#~ msgstr "PL/python : %s" +#~ msgid "unrecognized error in PLy_spi_prepare" +#~ msgstr "erreur inconnue dans PLy_spi_prepare" -#~ msgid "could not create procedure cache" -#~ msgstr "n'a pas pu créer le cache de procédure" +#~ msgid "unrecognized error in PLy_spi_execute_plan" +#~ msgstr "erreur inconnue dans PLy_spi_execute_plan" #~ msgid "unrecognized error in PLy_spi_execute_query" #~ msgstr "erreur inconnue dans PLy_spi_execute_query" -#~ msgid "unrecognized error in PLy_spi_execute_plan" -#~ msgstr "erreur inconnue dans PLy_spi_execute_plan" +#~ msgid "could not create procedure cache" +#~ msgstr "n'a pas pu créer le cache de procédure" -#~ msgid "unrecognized error in PLy_spi_prepare" -#~ msgstr "erreur inconnue dans PLy_spi_prepare" +#~ msgid "PL/Python: %s" +#~ msgstr "PL/python : %s" -#~ msgid "invalid arguments for plpy.prepare" -#~ msgstr "arguments invalides pour plpy.prepare" +#~ msgid "out of memory" +#~ msgstr "mémoire épuisée" -#~ msgid "transaction aborted" -#~ msgstr "transaction annulée" +#~ msgid "PL/Python function \"%s\" failed" +#~ msgstr "échec de la fonction PL/python « %s »" -#~ msgid "PyCObject_FromVoidPtr() failed" -#~ msgstr "échec de PyCObject_FromVoidPtr()" +#~ msgid "could not compute string representation of Python object in PL/Python function \"%s\" while modifying trigger row" +#~ msgstr "" +#~ "n'a pas pu traiter la représentation de la chaîne d'un objet Python dans\n" +#~ "la fonction PL/Python « %s » lors de la modification de la ligne du trigger" -#~ msgid "PyCObject_AsVoidPtr() failed" -#~ msgstr "échec de PyCObject_AsVoidPtr()" +#~ msgid "could not create string representation of Python object in PL/Python function \"%s\" while creating return value" +#~ msgstr "" +#~ "n'a pas pu créer la représentation en chaîne de caractère de l'objet\n" +#~ "Python dans la fonction PL/python « %s » lors de la création de la valeur\n" +#~ "de retour" -#~ msgid "unrecognized error in PLy_spi_execute_fetch_result" -#~ msgstr "erreur inconnue dans PLy_spi_execute_fetch_result" +#~ msgid "PL/Python function \"%s\" could not execute plan" +#~ msgstr "la fonction PL/python « %s » n'a pas pu exécuter un plan" -#~ msgid "PL/Python does not support conversion to arrays of row types." -#~ msgstr "PL/Python ne supporte pas les conversions vers des tableaux de types row." +#~ msgid "Start a new session to use a different Python major version." +#~ msgstr "" +#~ "Lancez une nouvelle session pour utiliser une version majeure différente de\n" +#~ "Python." -#~ msgid "plpy.prepare does not support composite types" -#~ msgstr "plpy.prepare ne supporte pas les types composites" +#~ msgid "This session has previously used Python major version %d, and it is now attempting to use Python major version %d." +#~ msgstr "" +#~ "Cette session a auparavant utilisé la version majeure %d de Python et elle\n" +#~ "essaie maintenant d'utiliser la version majeure %d." -#~ msgid "the message is already specified" -#~ msgstr "le message est déjà spécifié" +#~ msgid "Python major version mismatch in session" +#~ msgstr "Différence de version majeure de Python dans la session" + +#~ msgid "could not create the base SPI exceptions" +#~ msgstr "n'a pas pu créer les exceptions SPI de base" diff --git a/src/pl/plpython/po/it.po b/src/pl/plpython/po/it.po index 173d182bb3..27387b3b38 100644 --- a/src/pl/plpython/po/it.po +++ b/src/pl/plpython/po/it.po @@ -19,8 +19,8 @@ msgid "" msgstr "" "Project-Id-Version: plpython (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-04-17 00:07+0000\n" -"PO-Revision-Date: 2016-04-17 20:40+0100\n" +"POT-Creation-Date: 2017-02-09 21:07+0000\n" +"PO-Revision-Date: 2017-04-23 02:56+0100\n" "Last-Translator: Daniele Varrazzo \n" "Language-Team: Gruppo traduzioni ITPUG \n" "Language: it\n" @@ -28,56 +28,56 @@ msgstr "" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" -"X-Generator: Poedit 1.5.4\n" +"X-Generator: Poedit 1.8.7.1\n" #: plpy_cursorobject.c:101 #, c-format msgid "plpy.cursor expected a query or a plan" msgstr "plpy.cursor richiede una query o un piano" -#: plpy_cursorobject.c:179 +#: plpy_cursorobject.c:177 #, c-format msgid "plpy.cursor takes a sequence as its second argument" msgstr "plpy.cursor richiede una sequenza come secondo argomento" -#: plpy_cursorobject.c:195 plpy_spi.c:229 +#: plpy_cursorobject.c:193 plpy_spi.c:227 #, c-format msgid "could not execute plan" msgstr "esecuzione del piano fallita" -#: plpy_cursorobject.c:198 plpy_spi.c:232 +#: plpy_cursorobject.c:196 plpy_spi.c:230 #, c-format msgid "Expected sequence of %d argument, got %d: %s" msgid_plural "Expected sequence of %d arguments, got %d: %s" msgstr[0] "Attesa sequenza di %d argomento, ricevuti %d: %s" msgstr[1] "Attesa sequenza di %d argomenti, ricevuti %d: %s" -#: plpy_cursorobject.c:354 +#: plpy_cursorobject.c:350 #, c-format msgid "iterating a closed cursor" msgstr "iterazione di un cursore chiuso" -#: plpy_cursorobject.c:362 plpy_cursorobject.c:427 +#: plpy_cursorobject.c:358 plpy_cursorobject.c:423 #, c-format msgid "iterating a cursor in an aborted subtransaction" msgstr "iterazione di un cursore in una sotto-transazione interrotta" -#: plpy_cursorobject.c:419 +#: plpy_cursorobject.c:415 #, c-format msgid "fetch from a closed cursor" msgstr "lettura da un cursore chiuso" -#: plpy_cursorobject.c:467 plpy_spi.c:438 +#: plpy_cursorobject.c:463 plpy_spi.c:434 #, c-format msgid "query result has too many rows to fit in a Python list" msgstr "il risultato della query ha troppe righe per una lista Python" -#: plpy_cursorobject.c:508 +#: plpy_cursorobject.c:504 #, c-format msgid "closing a cursor in an aborted subtransaction" msgstr "chiusura di un cursore in una sotto-transazione interrotta" -#: plpy_elog.c:127 plpy_elog.c:128 plpy_plpymodule.c:513 +#: plpy_elog.c:127 plpy_elog.c:128 plpy_plpymodule.c:548 #, c-format msgid "%s" msgstr "%s" @@ -217,12 +217,12 @@ msgstr "creazione delle variabili globali fallita" msgid "could not initialize globals" msgstr "inizializzazione delle variabili globali fallita" -#: plpy_main.c:389 +#: plpy_main.c:387 #, c-format msgid "PL/Python function \"%s\"" msgstr "funzione PL/Python \"%s\"" -#: plpy_main.c:396 +#: plpy_main.c:394 #, c-format msgid "PL/Python anonymous code block" msgstr "blocco di codice anonimo in PL/Python" @@ -232,71 +232,76 @@ msgstr "blocco di codice anonimo in PL/Python" msgid "plan.status takes no arguments" msgstr "plan.status non accetta argomenti" -#: plpy_plpymodule.c:178 plpy_plpymodule.c:181 +#: plpy_plpymodule.c:181 plpy_plpymodule.c:184 #, c-format msgid "could not import \"plpy\" module" msgstr "importazione del modulo \"plpy\" fallita" -#: plpy_plpymodule.c:196 +#: plpy_plpymodule.c:199 +#, c-format +msgid "could not create the spiexceptions module" +msgstr "creazione del modulo spiexceptions fallita" + +#: plpy_plpymodule.c:207 #, c-format msgid "could not add the spiexceptions module" msgstr "aggiunta del modulo spiexceptions fallita" -#: plpy_plpymodule.c:217 +#: plpy_plpymodule.c:236 #, c-format -msgid "could not create the base SPI exceptions" -msgstr "creazione delle eccezioni SPI di base fallita" +msgid "could not create exception \"%s\"" +msgstr "creazione dell'eccezione \"%s\" fallita" -#: plpy_plpymodule.c:252 plpy_plpymodule.c:256 +#: plpy_plpymodule.c:271 plpy_plpymodule.c:275 #, c-format msgid "could not generate SPI exceptions" msgstr "generazione delle eccezioni SPI fallita" -#: plpy_plpymodule.c:421 +#: plpy_plpymodule.c:443 #, c-format msgid "could not unpack arguments in plpy.elog" msgstr "non è stato possibile espandere gli argomenti in plpy.elog" -#: plpy_plpymodule.c:430 +#: plpy_plpymodule.c:452 msgid "could not parse error message in plpy.elog" msgstr "non è stato possibile interpretare il messaggio di errore in plpy.elog" -#: plpy_plpymodule.c:446 +#: plpy_plpymodule.c:469 #, c-format -msgid "the message is already specified" -msgstr "il messaggio è già specificato" +msgid "Argument 'message' given by name and position" +msgstr "Parametro 'message' dato con nome e posizione" -#: plpy_plpymodule.c:469 +#: plpy_plpymodule.c:496 #, c-format msgid "'%s' is an invalid keyword argument for this function" msgstr "'%s' è un nome di argomento non valido per questa funzione" -#: plpy_plpymodule.c:477 plpy_plpymodule.c:480 +#: plpy_plpymodule.c:507 plpy_plpymodule.c:513 #, c-format msgid "invalid SQLSTATE code" msgstr "codice SQLSTATE non valido" -#: plpy_procedure.c:232 +#: plpy_procedure.c:230 #, c-format msgid "trigger functions can only be called as triggers" msgstr "le funzioni trigger possono essere chiamate esclusivamente da trigger" -#: plpy_procedure.c:237 +#: plpy_procedure.c:235 #, c-format msgid "PL/Python functions cannot return type %s" msgstr "le funzioni PL/Python non possono restituire il tipo %s" -#: plpy_procedure.c:318 +#: plpy_procedure.c:316 #, c-format msgid "PL/Python functions cannot accept type %s" msgstr "le funzioni PL/Python non possono accettare il tipo %s" -#: plpy_procedure.c:414 +#: plpy_procedure.c:412 #, c-format msgid "could not compile PL/Python function \"%s\"" msgstr "compilazione della funzione PL/Python \"%s\" fallita" -#: plpy_procedure.c:417 +#: plpy_procedure.c:415 #, c-format msgid "could not compile anonymous PL/Python code block" msgstr "compilazione del blocco di codice anonimo PL/Python fallita" @@ -311,27 +316,27 @@ msgstr "il comando non ha prodotto risultati" msgid "second argument of plpy.prepare must be a sequence" msgstr "il secondo argomento di plpy.prepare deve essere una sequenza" -#: plpy_spi.c:118 +#: plpy_spi.c:116 #, c-format msgid "plpy.prepare: type name at ordinal position %d is not a string" msgstr "plpy.prepare: il nome del tipo nella posizione %d non è una stringa" -#: plpy_spi.c:194 +#: plpy_spi.c:192 #, c-format msgid "plpy.execute expected a query or a plan" msgstr "plpy.execute si aspetta una query o un plan" -#: plpy_spi.c:213 +#: plpy_spi.c:211 #, c-format msgid "plpy.execute takes a sequence as its second argument" msgstr "plpy.execute richiede una sequenza come secondo argomento" -#: plpy_spi.c:337 +#: plpy_spi.c:335 #, c-format msgid "SPI_execute_plan failed: %s" msgstr "SPI_execute_plan ha fallito: %s" -#: plpy_spi.c:379 +#: plpy_spi.c:377 #, c-format msgid "SPI_execute failed: %s" msgstr "SPI_execute ha fallito: %s" @@ -396,42 +401,42 @@ msgstr "creazione della nuova lista Python fallita" msgid "could not create bytes representation of Python object" msgstr "creazione della rappresentazione in byte dell'oggetto Python fallita" -#: plpy_typeio.c:822 +#: plpy_typeio.c:820 #, c-format msgid "could not create string representation of Python object" msgstr "creazione della rappresentazione stringa dell'oggetto Python fallita" -#: plpy_typeio.c:833 +#: plpy_typeio.c:831 #, c-format msgid "could not convert Python object into cstring: Python string representation appears to contain null bytes" msgstr "conversione dell'oggetto Python in cstring fallita: la rappresentazione stringa Python sembra contenere byte null" -#: plpy_typeio.c:879 +#: plpy_typeio.c:877 #, c-format msgid "return value of function with array return type is not a Python sequence" msgstr "il valore restituito dalla funzione con tipo restituito array non è una sequenza Python" -#: plpy_typeio.c:1000 +#: plpy_typeio.c:996 #, c-format msgid "key \"%s\" not found in mapping" msgstr "la chiave \"%s\" non è stata trovata nel dizionario" -#: plpy_typeio.c:1001 +#: plpy_typeio.c:997 #, c-format msgid "To return null in a column, add the value None to the mapping with the key named after the column." msgstr "Per restituire null in una colonna, inserire nella mappa il valore None con una chiave chiamata come la colonna." -#: plpy_typeio.c:1052 +#: plpy_typeio.c:1048 #, c-format msgid "length of returned sequence did not match number of columns in row" msgstr "la lunghezza della sequenza ritornata non rispetta il numero di colonne presenti nella riga" -#: plpy_typeio.c:1163 +#: plpy_typeio.c:1159 #, c-format msgid "attribute \"%s\" does not exist in Python object" msgstr "l'attributo \"%s\" non esiste nell'oggetto Python" -#: plpy_typeio.c:1164 +#: plpy_typeio.c:1160 #, c-format msgid "To return null in a column, let the returned object have an attribute named after column with value None." msgstr "Per restituire null in una colonna, l'oggetto restituito deve avere un attributo chiamato come la colonna con valore None." diff --git a/src/pl/plpython/po/ja.po b/src/pl/plpython/po/ja.po index 5a5040ee0b..aacf23903e 100644 --- a/src/pl/plpython/po/ja.po +++ b/src/pl/plpython/po/ja.po @@ -4,11 +4,11 @@ # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.1 beta2\n" +"Project-Id-Version: PostgreSQL 9.6.3\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2012-08-11 16:28+0900\n" +"POT-Creation-Date: 2017-04-04 11:54+0900\n" "PO-Revision-Date: 2012-08-11 16:37+0900\n" -"Last-Translator: Honda Shigehiro \n" +"Last-Translator: Daisuke Higuchi \n" "Language-Team: Japan PostgreSQL Users Group \n" "Language: ja\n" "MIME-Version: 1.0\n" @@ -16,257 +16,277 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" -#: plpy_cursorobject.c:98 +#: plpy_cursorobject.c:101 #, c-format msgid "plpy.cursor expected a query or a plan" msgstr "plpy.cursorã¯ã‚¯ã‚¨ãƒªãƒ¼ã‚‚ã—ãã¯å®Ÿè¡Œè¨ˆç”»ã‚’期待ã—ã¦ã„ã¾ã—ãŸ" -#: plpy_cursorobject.c:171 +#: plpy_cursorobject.c:177 #, c-format msgid "plpy.cursor takes a sequence as its second argument" msgstr "plpy.cursorã¯ç¬¬äºŒå¼•æ•°ã¨ã—ã¦ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã‚’å–ã‚Šã¾ã™" -#: plpy_cursorobject.c:187 plpy_spi.c:222 +#: plpy_cursorobject.c:193 plpy_spi.c:227 #, c-format msgid "could not execute plan" msgstr "プランを実行ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_cursorobject.c:190 plpy_spi.c:225 +#: plpy_cursorobject.c:196 plpy_spi.c:230 #, c-format msgid "Expected sequence of %d argument, got %d: %s" msgid_plural "Expected sequence of %d arguments, got %d: %s" msgstr[0] "%d 番目ã®å¼•æ•°ã¯ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã‚’期待ã—ã¦ã„ã¾ã—ãŸãŒã€%d ãŒç¾ã‚Œã¾ã—ãŸï¼š%s" -#: plpy_cursorobject.c:340 +#: plpy_cursorobject.c:350 #, c-format msgid "iterating a closed cursor" -msgstr "クローズã•ã‚ŒãŸã‚«ãƒ¼sã‚‹ã®å復" +msgstr "クローズã•ã‚ŒãŸã‚«ãƒ¼ã‚½ãƒ«ã®å復" -#: plpy_cursorobject.c:348 plpy_cursorobject.c:415 +#: plpy_cursorobject.c:358 plpy_cursorobject.c:423 #, c-format msgid "iterating a cursor in an aborted subtransaction" msgstr "アボートã•ã‚ŒãŸã‚µãƒ–トランザクション内ã®ã‚«ãƒ¼ã‚½ãƒ«ã®å復" -#: plpy_cursorobject.c:407 +#: plpy_cursorobject.c:415 #, c-format msgid "fetch from a closed cursor" msgstr "クローズã•ã‚ŒãŸã‚«ãƒ¼ã‚½ãƒ«ã‹ã‚‰ã®ãƒ•ã‚§ãƒƒãƒ" -#: plpy_cursorobject.c:486 +#: plpy_cursorobject.c:463 plpy_spi.c:434 +#, c-format +msgid "query result has too many rows to fit in a Python list" +msgstr "å•ã„åˆã‚ã›çµæžœã®è¡ŒãŒå¤šã™ãŽã¦Pythonリストã«åŽã¾ã‚Šã¾ã›ã‚“" + +#: plpy_cursorobject.c:504 #, c-format msgid "closing a cursor in an aborted subtransaction" msgstr "アボートã•ã‚ŒãŸã‚µãƒ–トランザクションã«ãŠã‘るカーソルクローズ" -#: plpy_elog.c:103 plpy_elog.c:104 plpy_plpymodule.c:420 +#: plpy_elog.c:127 plpy_elog.c:128 plpy_plpymodule.c:548 #, c-format msgid "%s" msgstr "%s" -#: plpy_exec.c:90 +#: plpy_exec.c:140 #, c-format msgid "unsupported set function return mode" msgstr "未サãƒãƒ¼ãƒˆã®é›†åˆé–¢æ•°ãƒªã‚¿ãƒ¼ãƒ³ãƒ¢ãƒ¼ãƒ‰ã§ã™" -#: plpy_exec.c:91 +#: plpy_exec.c:141 #, c-format -msgid "PL/Python set-returning functions only support returning only value per call." -msgstr "PL/Python ã®é›†åˆã‚’è¿”ã™é–¢æ•°ã§ã¯ã€ï¼‘回ã®ã‚³ãƒ¼ãƒ«ã®ãŸã³ã«å€¤ã ã‘ã‚’è¿”ã™ã“ã¨ãŒã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã™" +msgid "PL/Python set-returning functions only support returning one value per call." +msgstr "PL/Python ã®é›†åˆã‚’è¿”ã™é–¢æ•°ã§ã¯ã€ï¼‘回ã®ã‚³ãƒ¼ãƒ«ã®ãŸã³ã«å€¤ã‚’一ã¤è¿”ã™ã“ã¨ã ã‘ãŒã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã™" -#: plpy_exec.c:103 +#: plpy_exec.c:154 #, c-format msgid "returned object cannot be iterated" msgstr "è¿”ã•ã‚ŒãŸã‚ªãƒ–ジェクトã¯å復é©ç”¨ã§ãã¾ã›ã‚“" -#: plpy_exec.c:104 +#: plpy_exec.c:155 #, c-format msgid "PL/Python set-returning functions must return an iterable object." msgstr "PL/Python ã®é›†åˆã‚’è¿”ã™é–¢æ•°ã§ã¯ã€ã‚¤ãƒ†ãƒ¬ãƒ¼ã‚¿ï¼ˆå復å­ï¼‰ã‚ªãƒ–ジェクトを返ã•ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: plpy_exec.c:129 +#: plpy_exec.c:169 #, c-format msgid "error fetching next item from iterator" msgstr "イテレータ（å復å­ï¼‰ã‹ã‚‰æ¬¡ã®é …目をフェッãƒï¼ˆå–り出ã—）ã§ãã¾ã›ã‚“" -#: plpy_exec.c:164 +#: plpy_exec.c:210 #, c-format msgid "PL/Python function with return type \"void\" did not return None" msgstr "\"void\" 型を返㙠PL/Python 関数㯠None åž‹ã‚’è¿”ã—ã¾ã›ã‚“" -#: plpy_exec.c:288 plpy_exec.c:314 +#: plpy_exec.c:374 plpy_exec.c:400 #, c-format msgid "unexpected return value from trigger procedure" msgstr "トリガー手続ãã‹ã‚‰æœŸå¾…ã—ãªã„戻り値ãŒè¿”ã•ã‚Œã¾ã—ãŸ" -#: plpy_exec.c:289 +#: plpy_exec.c:375 #, c-format msgid "Expected None or a string." msgstr "None ã‚‚ã—ãã¯æ–‡å­—列を期待ã—ã¦ã„ã¾ã—ãŸã€‚" -#: plpy_exec.c:304 +#: plpy_exec.c:390 #, c-format msgid "PL/Python trigger function returned \"MODIFY\" in a DELETE trigger -- ignored" msgstr "PL/Python トリガー関数ãŒã€DELETE トリガー㧠\"MODIFY\" ã‚’è¿”ã—ã¾ã—ãŸ-- 無視ã—ã¾ã—ãŸ" -#: plpy_exec.c:315 +#: plpy_exec.c:401 #, c-format msgid "Expected None, \"OK\", \"SKIP\", or \"MODIFY\"." msgstr "None, \"OK\", \"SKIP\", \"MODIFY\" ã®ã„ãšã‚Œã‹ã‚’期待ã—ã¦ã„ã¾ã—ãŸã€‚" -#: plpy_exec.c:396 +#: plpy_exec.c:482 #, c-format msgid "PyList_SetItem() failed, while setting up arguments" msgstr "引数を設定ã™ã‚‹éš›ã«ã€PyList_SetItem() ã«å¤±æ•—ã—ã¾ã—ãŸ" -#: plpy_exec.c:400 +#: plpy_exec.c:486 #, c-format msgid "PyDict_SetItemString() failed, while setting up arguments" msgstr "引数を設定ã™ã‚‹éš›ã«ã€PyDict_SetItemString() ã«å¤±æ•—ã—ã¾ã—ãŸ" -#: plpy_exec.c:412 +#: plpy_exec.c:498 #, c-format msgid "function returning record called in context that cannot accept type record" msgstr "レコード型をå—ã‘付ã‘られãªã„コンテキストã§ãƒ¬ã‚³ãƒ¼ãƒ‰ã‚’è¿”ã™é–¢æ•°ãŒå‘¼ã³å‡ºã•ã‚Œã¾ã—ãŸ" -#: plpy_exec.c:450 +#: plpy_exec.c:714 #, c-format msgid "while creating return value" msgstr "戻り値を生æˆã™ã‚‹éš›ã«" -#: plpy_exec.c:474 +#: plpy_exec.c:738 #, c-format msgid "could not create new dictionary while building trigger arguments" msgstr "トリガーã®å¼•æ•°ã‚’構æˆä¸­ã«ã€æ–°ã—ã„辞書を生æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_exec.c:664 +#: plpy_exec.c:927 #, c-format msgid "TD[\"new\"] deleted, cannot modify row" msgstr "TD[\"new\"] ã¯å‰Šé™¤ã•ã‚Œã¾ã—ãŸã€‚ã‚‚ã¯ã‚„変更ã§ãã¾ã›ã‚“" -#: plpy_exec.c:667 +#: plpy_exec.c:932 #, c-format msgid "TD[\"new\"] is not a dictionary" msgstr "TD[\"new\"] ã¯è¾žæ›¸ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: plpy_exec.c:691 +#: plpy_exec.c:957 #, c-format msgid "TD[\"new\"] dictionary key at ordinal position %d is not a string" msgstr "TD[\"new\"] 辞書ã®%d番目ã®ã‚­ãƒ¼ãŒæ–‡å­—列ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: plpy_exec.c:697 +#: plpy_exec.c:964 #, c-format msgid "key \"%s\" found in TD[\"new\"] does not exist as a column in the triggering row" msgstr "TD[\"new\"] ã§è¦‹ã¤ã‹ã£ãŸã‚­ãƒ¼ \"%s\" ã¯ã€è¡Œãƒ¬ãƒ™ãƒ«ãƒˆãƒªã‚¬ãƒ¼ã«ãŠã‘るカラムã¨ã—ã¦ã¯å­˜åœ¨ã—ã¾ã›ã‚“" -#: plpy_exec.c:778 +#: plpy_exec.c:1044 #, c-format msgid "while modifying trigger row" msgstr "トリガー行を変更ã™ã‚‹éš›ã«" -#: plpy_exec.c:839 +#: plpy_exec.c:1105 #, c-format msgid "forcibly aborting a subtransaction that has not been exited" msgstr "終了ã—ã¦ã„ãªã„サブトランザクションを強制的ã«ã‚¢ãƒœãƒ¼ãƒˆã—ã¦ã„ã¾ã™" -#: plpy_main.c:100 -#, c-format -msgid "Python major version mismatch in session" -msgstr "セッションã«ãŠã„㦠Python ã®ãƒ¡ã‚¸ãƒ£ãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãŒåˆè‡´ã—ã¾ã›ã‚“" - -#: plpy_main.c:101 +#: plpy_main.c:125 #, c-format -msgid "This session has previously used Python major version %d, and it is now attempting to use Python major version %d." -msgstr "ã“ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã§ã¯ã™ã§ã« Python ã®ãƒ¡ã‚¸ãƒ£ãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %d ãŒä½¿ã‚ã‚Œã¦ã„ã¾ã—ãŸãŒã€ã“ã“㧠Python ã®ãƒ¡ã‚¸ãƒ£ãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ %d を使ãŠã†ã¨ã—ã¦ã„ã¾ã™ã€‚" +msgid "multiple Python libraries are present in session" +msgstr "セッション内ã«è¤‡æ•°ã® Python ライブラリãŒå­˜åœ¨ã—ã¾ã™" -#: plpy_main.c:103 +#: plpy_main.c:126 #, c-format -msgid "Start a new session to use a different Python major version." -msgstr "Python ã®ç•°ãªã£ãŸãƒ¡ã‚¸ãƒ£ãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’使ã†å ´åˆã¯ã€æ–°ã—ã„セッションを開始ã—ã¦ãã ã•ã„" +msgid "Only one Python major version can be used in one session." +msgstr "一ã¤ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«ãŠã„ã¦ä½¿ã†ã“ã¨ãŒã§ãã‚‹ Python ã®ãƒ¡ã‚¸ãƒ£ãƒ¼ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã¯ä¸€ã¤ã ã‘ã§ã™ã€‚" -#: plpy_main.c:118 +#: plpy_main.c:142 #, c-format msgid "untrapped error in initialization" msgstr "åˆæœŸåŒ–中ã«æ•ç²ã§ããªã„エラーãŒã‚ã‚Šã¾ã—ãŸ" -#: plpy_main.c:141 +#: plpy_main.c:165 #, c-format msgid "could not import \"__main__\" module" msgstr "\"__main__\" モジュールをインãƒãƒ¼ãƒˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_main.c:146 +#: plpy_main.c:170 #, c-format msgid "could not create globals" msgstr "globalsを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_main.c:150 +#: plpy_main.c:174 #, c-format msgid "could not initialize globals" msgstr "グローãƒãƒ«å¤‰æ•°(globals)ã‚’åˆæœŸåŒ–ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_main.c:347 +#: plpy_main.c:387 #, c-format msgid "PL/Python function \"%s\"" msgstr "PL/Python 関数 \"%s\"" -#: plpy_main.c:354 +#: plpy_main.c:394 #, c-format msgid "PL/Python anonymous code block" msgstr "PL/Python ã®ç„¡åコードブロック" -#: plpy_planobject.c:126 +#: plpy_planobject.c:123 #, c-format msgid "plan.status takes no arguments" msgstr "plan.status ã¯å¼•æ•°ã‚’å–ã‚Šã¾ã›ã‚“" -#: plpy_plpymodule.c:178 plpy_plpymodule.c:181 +#: plpy_plpymodule.c:181 plpy_plpymodule.c:184 #, c-format msgid "could not import \"plpy\" module" msgstr "\"plpy\"モジュールをインãƒãƒ¼ãƒˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_plpymodule.c:196 +#: plpy_plpymodule.c:199 +#, c-format +msgid "could not create the spiexceptions module" +msgstr "spiexceptionsモジュールを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" + +#: plpy_plpymodule.c:207 #, c-format msgid "could not add the spiexceptions module" msgstr "spiexceptionsモジュールを追加ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_plpymodule.c:217 +#: plpy_plpymodule.c:236 #, c-format -msgid "could not create the base SPI exceptions" -msgstr "基本SPI例外を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" +msgid "could not create exception \"%s\"" +msgstr "例外 \"%s\" を作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_plpymodule.c:253 plpy_plpymodule.c:257 +#: plpy_plpymodule.c:271 plpy_plpymodule.c:275 #, c-format msgid "could not generate SPI exceptions" msgstr "SPI例外を生æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_plpymodule.c:388 +#: plpy_plpymodule.c:443 #, c-format msgid "could not unpack arguments in plpy.elog" msgstr "plpy.elogã§å¼•æ•°ã‚’展開ã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_plpymodule.c:396 +#: plpy_plpymodule.c:452 msgid "could not parse error message in plpy.elog" msgstr "plpy.elog ã§ã‚¨ãƒ©ãƒ¼ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã‚’パースã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_procedure.c:194 +#: plpy_plpymodule.c:469 +#, c-format +msgid "Argument 'message' given by name and position" +msgstr "åå‰ã¨ä½ç½®ã§ä¸Žãˆã‚‰ã‚Œã‚‹å¼•æ•° 'message'" + +#: plpy_plpymodule.c:496 +#, c-format +msgid "'%s' is an invalid keyword argument for this function" +msgstr "'%s' ã¯ã“ã®é–¢æ•°ã«ã¯ç„¡åŠ¹ãªã‚­ãƒ¼ãƒ¯ãƒ¼ãƒ‰å¼•æ•°ã§ã™" + +#: plpy_plpymodule.c:507 plpy_plpymodule.c:513 +#, c-format +msgid "invalid SQLSTATE code" +msgstr "無効㪠SQLSTATE コードã§ã™" + +#: plpy_procedure.c:230 #, c-format msgid "trigger functions can only be called as triggers" msgstr "トリガー関数ã¯ãƒˆãƒªã‚¬ãƒ¼ã¨ã—ã¦ã®ã¿ã‚³ãƒ¼ãƒ«ã§ãã¾ã™" -#: plpy_procedure.c:199 plpy_typeio.c:406 +#: plpy_procedure.c:235 #, c-format msgid "PL/Python functions cannot return type %s" msgstr "PL/Python 関数㯠%s åž‹ã‚’è¿”ã›ã¾ã›ã‚“" -#: plpy_procedure.c:281 +#: plpy_procedure.c:316 #, c-format msgid "PL/Python functions cannot accept type %s" msgstr "PL/Python 関数㯠%s åž‹ã‚’å—ã‘付ã‘ã¾ã›ã‚“" -#: plpy_procedure.c:377 +#: plpy_procedure.c:412 #, c-format msgid "could not compile PL/Python function \"%s\"" msgstr "PL/Python 関数 \"%s\" をコンパイルã§ãã¾ã›ã‚“" -#: plpy_procedure.c:380 +#: plpy_procedure.c:415 #, c-format msgid "could not compile anonymous PL/Python code block" msgstr "PL/Python匿åコードブロックをコンパイルã§ãã¾ã›ã‚“" @@ -276,172 +296,143 @@ msgstr "PL/Python匿åコードブロックをコンパイルã§ãã¾ã›ã‚“" msgid "command did not produce a result set" msgstr "コマンドã¯çµæžœã‚»ãƒƒãƒˆã‚’生æˆã—ã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_spi.c:56 +#: plpy_spi.c:60 #, c-format msgid "second argument of plpy.prepare must be a sequence" msgstr "plpy.prepare ã®ç¬¬äºŒå¼•æ•°ã¯ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“" -#: plpy_spi.c:105 +#: plpy_spi.c:116 #, c-format msgid "plpy.prepare: type name at ordinal position %d is not a string" msgstr "plpy.prepare: %d 番目ã®åž‹åãŒæ–‡å­—列ã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: plpy_spi.c:137 -#, c-format -msgid "plpy.prepare does not support composite types" -msgstr "plpy.prepare ã¯è¤‡åˆåž‹ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“" - -#: plpy_spi.c:187 +#: plpy_spi.c:192 #, c-format msgid "plpy.execute expected a query or a plan" msgstr "plpy.execute ã¯ã‚¯ã‚¨ãƒªãƒ¼ã‚‚ã—ãã¯å®Ÿè¡Œè¨ˆç”»ã‚’期待ã—ã¦ã„ã¾ã—ãŸ" -#: plpy_spi.c:206 +#: plpy_spi.c:211 #, c-format msgid "plpy.execute takes a sequence as its second argument" msgstr "plpy.execute ã¯ç¬¬äºŒå¼•æ•°ã¨ã—ã¦ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã‚’å–ã‚Šã¾ã™" -#: plpy_spi.c:330 +#: plpy_spi.c:335 #, c-format msgid "SPI_execute_plan failed: %s" msgstr "SPI_execute_plan ãŒå¤±æ•—ã—ã¾ã—ãŸï¼š%s" -#: plpy_spi.c:372 +#: plpy_spi.c:377 #, c-format msgid "SPI_execute failed: %s" msgstr "SPI_execute ãŒå¤±æ•—ã—ã¾ã—ãŸï¼š%s" -#: plpy_spi.c:439 -#, c-format -msgid "unrecognized error in PLy_spi_execute_fetch_result" -msgstr "PLy_spi_execute_fetch_result ã§èªè­˜ã§ããªã„エラーを検出ã—ã¾ã—ãŸ" - -#: plpy_subxactobject.c:122 +#: plpy_subxactobject.c:123 #, c-format msgid "this subtransaction has already been entered" msgstr "ã“ã®ã‚µãƒ–トランザクションã¯åˆ°é”済ã¿ã§ã™" -#: plpy_subxactobject.c:128 plpy_subxactobject.c:180 +#: plpy_subxactobject.c:129 plpy_subxactobject.c:187 #, c-format msgid "this subtransaction has already been exited" msgstr "ã“ã®ã‚µãƒ–トランザクションã¯çµ‚了済ã¿ã§ã™" -#: plpy_subxactobject.c:174 +#: plpy_subxactobject.c:181 #, c-format msgid "this subtransaction has not been entered" msgstr "ã“ã®ã‚µãƒ–トランザクションã«ã¯åˆ°é”ã—ã¾ã›ã‚“" -#: plpy_subxactobject.c:186 +#: plpy_subxactobject.c:193 #, c-format msgid "there is no subtransaction to exit from" msgstr "終了ã™ã‚‹ãŸã‚ã®ã‚µãƒ–トランザクションãŒã‚ã‚Šã¾ã›ã‚“" -#: plpy_typeio.c:291 +#: plpy_typeio.c:286 #, c-format msgid "could not create new dictionary" msgstr "æ–°ã—ã„ディレクトリを作れã¾ã›ã‚“" -#: plpy_typeio.c:408 +#: plpy_typeio.c:560 +#, c-format +msgid "could not import a module for Decimal constructor" +msgstr "Decimalコンストラクタã«ãƒ¢ã‚¸ãƒ¥ãƒ¼ãƒ«ã‚’インãƒãƒ¼ãƒˆã§ãã¾ã›ã‚“ã§ã—ãŸ" + +#: plpy_typeio.c:564 #, c-format -msgid "PL/Python does not support conversion to arrays of row types." -msgstr "PL/Python ã¯è¡Œã‚¿ã‚¤ãƒ—é…列ã¸ã®å¤‰æ›ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“" +msgid "no Decimal attribute in module" +msgstr "モジュールã®ä¸­ã«Decimal属性ãŒã‚ã‚Šã¾ã›ã‚“" -#: plpy_typeio.c:584 +#: plpy_typeio.c:570 +#, c-format +msgid "conversion from numeric to Decimal failed" +msgstr "numericã‹ã‚‰Decimalã¸ã®å¤‰æ›ãŒå¤±æ•—ã—ã¾ã—ãŸ" + +#: plpy_typeio.c:645 #, c-format msgid "cannot convert multidimensional array to Python list" msgstr "多次元é…列を Python ã® list ã«å¤‰æ›ã§ãã¾ã›ã‚“" -#: plpy_typeio.c:585 +#: plpy_typeio.c:646 #, c-format msgid "PL/Python only supports one-dimensional arrays." msgstr "PL/Python ã§ã‚µãƒãƒ¼ãƒˆã—ã¦ã„ã‚‹ã®ã¯ä¸€æ¬¡å…ƒé…列ã®ã¿ã§ã™ã€‚" -#: plpy_typeio.c:591 +#: plpy_typeio.c:652 #, c-format msgid "could not create new Python list" msgstr "æ–°ã—ã„Pythonリストを作æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_typeio.c:650 +#: plpy_typeio.c:711 #, c-format msgid "could not create bytes representation of Python object" msgstr "ãƒã‚¤ãƒˆè¡¨ç¾ã® Python オブジェクトを生æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_typeio.c:742 +#: plpy_typeio.c:820 #, c-format msgid "could not create string representation of Python object" msgstr "文字列表ç¾ã® Python オブジェクトを生æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_typeio.c:753 +#: plpy_typeio.c:831 #, c-format msgid "could not convert Python object into cstring: Python string representation appears to contain null bytes" msgstr "Python オブジェクトを cstring ã«å¤‰æ›ã§ãã¾ã›ã‚“ã§ã—ãŸï¼šPython ã®æ–‡å­—列表ç¾ãŒ null ãƒã‚¤ãƒˆã‚’æŒã¤ã“ã¨ã«ãªã£ã¦ã—ã¾ã„ã¾ã™" -#: plpy_typeio.c:787 +#: plpy_typeio.c:877 #, c-format msgid "return value of function with array return type is not a Python sequence" msgstr "戻り値ãŒé…列ã§ã‚る関数ã®æˆ»ã‚Šå€¤ãŒ Python シーケンスã§ã¯ã‚ã‚Šã¾ã›ã‚“" -#: plpy_typeio.c:886 +#: plpy_typeio.c:996 #, c-format msgid "key \"%s\" not found in mapping" msgstr "マッピング上ã«ã‚­ãƒ¼ \"%s\" ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“" -#: plpy_typeio.c:887 +#: plpy_typeio.c:997 #, c-format msgid "To return null in a column, add the value None to the mapping with the key named after the column." msgstr "カラム㫠null を入れã¦è¿”ã™ã«ã¯ã€ã‚«ãƒ©ãƒ ã®å¾Œã«ã¤ã‘ãŸåå‰ã‚’キーã¨ã—ã¦ã€ãƒžãƒƒãƒ”ング㫠None 値を追加ã—ã¦ãã ã•ã„" -#: plpy_typeio.c:935 +#: plpy_typeio.c:1048 #, c-format msgid "length of returned sequence did not match number of columns in row" msgstr "è¿”ã•ã‚ŒãŸã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã®é•·ã•ãŒã€ãã®è¡Œã®ã‚«ãƒ©ãƒ æ•°ã¨ç•°ãªã‚Šã¾ã™" -#: plpy_typeio.c:1043 +#: plpy_typeio.c:1159 #, c-format msgid "attribute \"%s\" does not exist in Python object" msgstr "属性 \"%s\" ㌠Python オブジェクト中ã«å­˜åœ¨ã—ã¾ã›ã‚“" -#: plpy_typeio.c:1044 +#: plpy_typeio.c:1160 #, c-format msgid "To return null in a column, let the returned object have an attribute named after column with value None." msgstr "カラム㫠null を入れã¦è¿”ã™å ´åˆã¯ã€ãã®ã‚«ãƒ©ãƒ ã®å¾Œã«ã¤ã‘ãŸåå‰ã§è¡¨ã•ã‚Œã‚‹å±žæ€§ãŒå€¤ã¨ã—㦠None ã‚’æŒã¡ã€è¿”ã•ã‚Œã‚‹ã‚ªãƒ–ジェクトãŒãã®å±žæ€§ã‚’å«ã‚€ã‚ˆã†ã«ã—ã¦ãã ã•ã„" -#: plpy_util.c:70 +#: plpy_util.c:36 #, c-format msgid "could not convert Python Unicode object to bytes" msgstr "Pythonã®Unicodeオブジェクトをãƒã‚¤ãƒˆã«å¤‰æ›ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#: plpy_util.c:75 +#: plpy_util.c:42 #, c-format msgid "could not extract bytes from encoded string" msgstr "符å·åŒ–ã•ã‚ŒãŸæ–‡å­—列ã‹ã‚‰ãƒã‚¤ãƒˆã‚’抽出ã§ãã¾ã›ã‚“ã§ã—ãŸ" -#~ msgid "PyCObject_AsVoidPtr() failed" -#~ msgstr "PyCObject_AsVoidPtr() ã«å¤±æ•—ã—ã¾ã—ãŸ" - -#~ msgid "invalid arguments for plpy.prepare" -#~ msgstr "plpy.prepare ã®å¼•æ•°ãŒä¸æ­£ã§ã™" - -#~ msgid "PyCObject_FromVoidPtr() failed" -#~ msgstr "PyCObject_FromVoidPtr() ã«å¤±æ•—ã—ã¾ã—ãŸ" - -#~ msgid "unrecognized error in PLy_spi_prepare" -#~ msgstr "PLy_spi_prepare ã§èªè­˜ã§ããªã„エラーを検出ã—ã¾ã—ãŸ" - -#~ msgid "transaction aborted" -#~ msgstr "トランザクションãŒã‚¢ãƒœãƒ¼ãƒˆã—ã¾ã—ãŸ" - -#~ msgid "could not create procedure cache" -#~ msgstr "手続ã用キャッシュ(procedure cache)を生æˆã§ãã¾ã›ã‚“ã§ã—ãŸ" - -#~ msgid "PL/Python: %s" -#~ msgstr "PL/Python: %s" - -#~ msgid "out of memory" -#~ msgstr "メモリä¸è¶³ã§ã™" - -#~ msgid "unrecognized error in PLy_spi_execute_plan" -#~ msgstr "PLy_spi_execute_plan ã§èªè­˜ã§ããªã„エラーを検出ã—ã¾ã—ãŸ" - -#~ msgid "unrecognized error in PLy_spi_execute_query" -#~ msgstr "PLy_spi_execute_query ã§èªè­˜ã§ããªã„エラーを検出ã—ã¾ã—ãŸ" diff --git a/src/pl/plpython/po/ru.po b/src/pl/plpython/po/ru.po index fcca12acbb..a038e9d554 100644 --- a/src/pl/plpython/po/ru.po +++ b/src/pl/plpython/po/ru.po @@ -7,8 +7,9 @@ msgid "" msgstr "" "Project-Id-Version: plpython (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:07+0000\n" +"POT-Creation-Date: 2017-02-06 22:07+0000\n" "PO-Revision-Date: 2017-02-02 15:21+0300\n" +"Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -16,7 +17,6 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n" -"Last-Translator: Alexander Lakhin \n" #: plpy_cursorobject.c:101 #, c-format From aafbd1df969135c185947c596c46608fc9f4a67c Mon Sep 17 00:00:00 2001 From: Noah Misch Date: Mon, 8 May 2017 07:24:24 -0700 Subject: [PATCH 0049/1139] Restore PGREQUIRESSL recognition in libpq. Commit 65c3bf19fd3e1f6a591618e92eb4c54d0b217564 moved handling of the, already then, deprecated requiressl parameter into conninfo_storeval(). The default PGREQUIRESSL environment variable was however lost in the change resulting in a potentially silent accept of a non-SSL connection even when set. Its documentation remained. Restore its implementation. Also amend the documentation to mark PGREQUIRESSL as deprecated for those not following the link to requiressl. Back-patch to 9.3, where commit 65c3bf1 first appeared. Behavior has been more complex when the user provides both deprecated and non-deprecated settings. Before commit 65c3bf1, libpq operated according to the first of these found: requiressl=1 PGREQUIRESSL=1 sslmode=* PGSSLMODE=* (Note requiressl=0 didn't override sslmode=*; it would only suppress PGREQUIRESSL=1 or a previous requiressl=1. PGREQUIRESSL=0 had no effect whatsoever.) Starting with commit 65c3bf1, libpq ignored PGREQUIRESSL, and order of precedence changed to this: last of requiressl=* or sslmode=* PGSSLMODE=* Starting now, adopt the following order of precedence: last of requiressl=* or sslmode=* PGSSLMODE=* PGREQUIRESSL=1 This retains the 65c3bf1 behavior for connection strings that contain both requiressl=* and sslmode=*. It retains the 65c3bf1 change that either connection string option overrides both environment variables. For the first time, PGSSLMODE has precedence over PGREQUIRESSL; this avoids reducing security of "PGREQUIRESSL=1 PGSSLMODE=verify-full" configurations originating under v9.3 and later. Daniel Gustafsson Security: CVE-2017-7485 --- doc/src/sgml/libpq.sgml | 3 +++ src/interfaces/libpq/fe-connect.c | 24 ++++++++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml index 2f9350b10e..3a470fefac 100644 --- a/doc/src/sgml/libpq.sgml +++ b/doc/src/sgml/libpq.sgml @@ -6944,6 +6944,9 @@ myEventProc(PGEventId evtId, void *evtInfo, void *passThrough) PGREQUIRESSL behaves the same as the connection parameter. + This environment variable is deprecated in favor of the + PGSSLMODE variable; setting both variables suppresses the + effect of this one. diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c index 4f13624017..8c7169e171 100644 --- a/src/interfaces/libpq/fe-connect.c +++ b/src/interfaces/libpq/fe-connect.c @@ -4635,6 +4635,30 @@ conninfo_add_defaults(PQconninfoOption *options, PQExpBuffer errorMessage) } } + /* + * Interpret the deprecated PGREQUIRESSL environment variable. Per + * tradition, translate values starting with "1" to sslmode=require, + * and ignore other values. Given both PGREQUIRESSL=1 and PGSSLMODE, + * PGSSLMODE takes precedence; the opposite was true before v9.3. + */ + if (strcmp(option->keyword, "sslmode") == 0) + { + const char *requiresslenv = getenv("PGREQUIRESSL"); + + if (requiresslenv != NULL && requiresslenv[0] == '1') + { + option->val = strdup("require"); + if (!option->val) + { + if (errorMessage) + printfPQExpBuffer(errorMessage, + libpq_gettext("out of memory\n")); + return false; + } + continue; + } + } + /* * No environment variable specified or the variable isn't set - try * compiled-in default From c928addfccd7f9905472dddd94e9cd10bc3f6808 Mon Sep 17 00:00:00 2001 From: Noah Misch Date: Mon, 8 May 2017 07:24:24 -0700 Subject: [PATCH 0050/1139] Match pg_user_mappings limits to information_schema.user_mapping_options. Both views replace the umoptions field with NULL when the user does not meet qualifications to see it. They used different qualifications, and pg_user_mappings documented qualifications did not match its implemented qualifications. Make its documentation and implementation match those of user_mapping_options. One might argue for stronger qualifications, but these have long, documented tenure. pg_user_mappings has always exhibited this problem, so back-patch to 9.2 (all supported versions). Michael Paquier and Feike Steenbergen. Reviewed by Jeff Janes. Reported by Andrew Wheelwright. Security: CVE-2017-7486 --- doc/src/sgml/catalogs.sgml | 7 ++- src/backend/catalog/system_views.sql | 10 ++-- src/test/regress/expected/foreign_data.out | 54 ++++++++++++++++++++++ src/test/regress/expected/rules.out | 4 +- src/test/regress/sql/foreign_data.sql | 15 ++++++ 5 files changed, 82 insertions(+), 8 deletions(-) diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml index 93deda4db9..71c86142a6 100644 --- a/doc/src/sgml/catalogs.sgml +++ b/doc/src/sgml/catalogs.sgml @@ -10051,8 +10051,11 @@ SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xacts ppx User mapping specific options, as keyword=value - strings, if the current user is the owner of the foreign - server, else null + strings. This column will show as null unless the current user + is the user being mapped, or the mapping is for + PUBLIC and the current user is the server + owner, or the current user is a superuser. The intent is + to protect password information stored as user mapping option. diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index 4fc5d5a065..b769c6f066 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -826,11 +826,11 @@ CREATE VIEW pg_user_mappings AS ELSE A.rolname END AS usename, - CASE WHEN pg_has_role(S.srvowner, 'USAGE') OR has_server_privilege(S.oid, 'USAGE') THEN - U.umoptions - ELSE - NULL - END AS umoptions + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions FROM pg_user_mapping U LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN pg_foreign_server S ON (U.umserver = S.oid); diff --git a/src/test/regress/expected/foreign_data.out b/src/test/regress/expected/foreign_data.out index d6c1900c32..fea02b6faf 100644 --- a/src/test/regress/expected/foreign_data.out +++ b/src/test/regress/expected/foreign_data.out @@ -1194,7 +1194,61 @@ WARNING: no privileges were granted for "s9" CREATE USER MAPPING FOR current_user SERVER s9; DROP SERVER s9 CASCADE; -- ERROR ERROR: must be owner of foreign server s9 +-- Check visibility of user mapping data +SET ROLE regress_test_role; +CREATE SERVER s10 FOREIGN DATA WRAPPER foo; +CREATE USER MAPPING FOR public SERVER s10 OPTIONS (user 'secret'); +GRANT USAGE ON FOREIGN SERVER s10 TO regress_unprivileged_role; +-- owner of server can see option fields +\deu+ + List of user mappings + Server | User name | FDW Options +--------+---------------------------+------------------- + s10 | public | ("user" 'secret') + s4 | regress_foreign_data_user | + s5 | regress_test_role | (modified '1') + s6 | regress_test_role | + s8 | public | + s8 | regress_foreign_data_user | + s9 | regress_unprivileged_role | + t1 | public | (modified '1') +(8 rows) + +RESET ROLE; +-- superuser can see option fields +\deu+ + List of user mappings + Server | User name | FDW Options +--------+---------------------------+--------------------- + s10 | public | ("user" 'secret') + s4 | regress_foreign_data_user | + s5 | regress_test_role | (modified '1') + s6 | regress_test_role | + s8 | public | + s8 | regress_foreign_data_user | (password 'public') + s9 | regress_unprivileged_role | + t1 | public | (modified '1') +(8 rows) + +-- unprivileged user cannot see option fields +SET ROLE regress_unprivileged_role; +\deu+ + List of user mappings + Server | User name | FDW Options +--------+---------------------------+------------- + s10 | public | + s4 | regress_foreign_data_user | + s5 | regress_test_role | + s6 | regress_test_role | + s8 | public | + s8 | regress_foreign_data_user | + s9 | regress_unprivileged_role | + t1 | public | +(8 rows) + RESET ROLE; +DROP SERVER s10 CASCADE; +NOTICE: drop cascades to user mapping for public on server s10 -- Triggers CREATE FUNCTION dummy_trigger() RETURNS TRIGGER AS $$ BEGIN diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index cf8bccac8c..d27b1f9305 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -2151,7 +2151,9 @@ pg_user_mappings| SELECT u.oid AS umid, ELSE a.rolname END AS usename, CASE - WHEN (pg_has_role(s.srvowner, 'USAGE'::text) OR has_server_privilege(s.oid, 'USAGE'::text)) THEN u.umoptions + WHEN (((u.umuser <> (0)::oid) AND (a.rolname = "current_user"())) OR ((u.umuser = (0)::oid) AND pg_has_role(s.srvowner, 'USAGE'::text)) OR ( SELECT pg_authid.rolsuper + FROM pg_authid + WHERE (pg_authid.rolname = "current_user"()))) THEN u.umoptions ELSE NULL::text[] END AS umoptions FROM ((pg_user_mapping u diff --git a/src/test/regress/sql/foreign_data.sql b/src/test/regress/sql/foreign_data.sql index 38e1d41a5f..ce66d9955a 100644 --- a/src/test/regress/sql/foreign_data.sql +++ b/src/test/regress/sql/foreign_data.sql @@ -490,7 +490,22 @@ ALTER SERVER s9 VERSION '1.2'; -- ERROR GRANT USAGE ON FOREIGN SERVER s9 TO regress_test_role; -- WARNING CREATE USER MAPPING FOR current_user SERVER s9; DROP SERVER s9 CASCADE; -- ERROR + +-- Check visibility of user mapping data +SET ROLE regress_test_role; +CREATE SERVER s10 FOREIGN DATA WRAPPER foo; +CREATE USER MAPPING FOR public SERVER s10 OPTIONS (user 'secret'); +GRANT USAGE ON FOREIGN SERVER s10 TO regress_unprivileged_role; +-- owner of server can see option fields +\deu+ +RESET ROLE; +-- superuser can see option fields +\deu+ +-- unprivileged user cannot see option fields +SET ROLE regress_unprivileged_role; +\deu+ RESET ROLE; +DROP SERVER s10 CASCADE; -- Triggers CREATE FUNCTION dummy_trigger() RETURNS TRIGGER AS $$ From cad15943225adbcadea51602b38b04d71d1183d2 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 8 May 2017 11:18:40 -0400 Subject: [PATCH 0051/1139] Fix possibly-uninitialized variable. Oversight in e2d4ef8de et al (my fault not Peter's). Per buildfarm. Security: CVE-2017-7484 --- src/backend/utils/adt/rangetypes_selfuncs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/backend/utils/adt/rangetypes_selfuncs.c b/src/backend/utils/adt/rangetypes_selfuncs.c index 90c78fc3c2..b06b67010a 100644 --- a/src/backend/utils/adt/rangetypes_selfuncs.c +++ b/src/backend/utils/adt/rangetypes_selfuncs.c @@ -374,8 +374,8 @@ calc_hist_selectivity(TypeCacheEntry *typcache, VariableStatData *vardata, { Datum *hist_values; int nhist; - Datum *length_hist_values; - int length_nhist; + Datum *length_hist_values = NULL; + int length_nhist = 0; RangeBound *hist_lower; RangeBound *hist_upper; int i; From 2d5e7b4a912d55d90c01732d318b94e4ae47027b Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 8 May 2017 12:57:27 -0400 Subject: [PATCH 0052/1139] Last-minute updates for release notes. Security: CVE-2017-7484, CVE-2017-7485, CVE-2017-7486 --- doc/src/sgml/release-9.2.sgml | 125 +++++++++++++++++++++++- doc/src/sgml/release-9.3.sgml | 143 ++++++++++++++++++++++++++- doc/src/sgml/release-9.4.sgml | 145 +++++++++++++++++++++++++++- doc/src/sgml/release-9.5.sgml | 145 +++++++++++++++++++++++++++- doc/src/sgml/release-9.6.sgml | 177 +++++++++++++++++++++++++++++++++- 5 files changed, 727 insertions(+), 8 deletions(-) diff --git a/doc/src/sgml/release-9.2.sgml b/doc/src/sgml/release-9.2.sgml index ea86c8a42d..62be52d098 100644 --- a/doc/src/sgml/release-9.2.sgml +++ b/doc/src/sgml/release-9.2.sgml @@ -29,7 +29,12 @@ - However, if you are upgrading from a version earlier than 9.2.20, + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.2.20, see . @@ -40,6 +45,124 @@ + + + Restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Michael Paquier, Feike Steenbergen) + + + + The previous coding allowed the owner of a foreign server object, + or anyone he has granted server USAGE permission to, + to see the options for all user mappings associated with that server. + This might well include passwords for other users. + Adjust the view definition to match the behavior of + information_schema.user_mapping_options, namely that + these options are visible to the user being mapped, or if the mapping + is for PUBLIC and the current user is the server + owner, or if the current user is a superuser. + (CVE-2017-7486) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Prevent exposure of statistical information via leaky operators + (Peter Eisentraut) + + + + Some selectivity estimation functions in the planner will apply + user-defined operators to values obtained + from pg_statistic, such as most common values and + histogram entries. This occurs before table permissions are checked, + so a nefarious user could exploit the behavior to obtain these values + for table columns he does not have permission to read. To fix, + fall back to a default estimate if the operator's implementation + function is not certified leak-proof and the calling user does not have + permission to read the table column whose statistics are needed. + At least one of these criteria is satisfied in most cases in practice. + (CVE-2017-7484) + + + Fix possible corruption of init forks of unlogged indexes diff --git a/doc/src/sgml/release-9.3.sgml b/doc/src/sgml/release-9.3.sgml index 0bf5648be7..c5a5342afc 100644 --- a/doc/src/sgml/release-9.3.sgml +++ b/doc/src/sgml/release-9.3.sgml @@ -23,7 +23,12 @@ - However, if you are upgrading from a version earlier than 9.3.16, + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.3.16, see . @@ -34,6 +39,142 @@ + + + Restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Michael Paquier, Feike Steenbergen) + + + + The previous coding allowed the owner of a foreign server object, + or anyone he has granted server USAGE permission to, + to see the options for all user mappings associated with that server. + This might well include passwords for other users. + Adjust the view definition to match the behavior of + information_schema.user_mapping_options, namely that + these options are visible to the user being mapped, or if the mapping + is for PUBLIC and the current user is the server + owner, or if the current user is a superuser. + (CVE-2017-7486) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Prevent exposure of statistical information via leaky operators + (Peter Eisentraut) + + + + Some selectivity estimation functions in the planner will apply + user-defined operators to values obtained + from pg_statistic, such as most common values and + histogram entries. This occurs before table permissions are checked, + so a nefarious user could exploit the behavior to obtain these values + for table columns he does not have permission to read. To fix, + fall back to a default estimate if the operator's implementation + function is not certified leak-proof and the calling user does not have + permission to read the table column whose statistics are needed. + At least one of these criteria is satisfied in most cases in practice. + (CVE-2017-7484) + + + + + + Restore libpq's recognition of + the PGREQUIRESSL environment variable (Daniel Gustafsson) + + + + Processing of this environment variable was unintentionally dropped + in PostgreSQL 9.3, but its documentation remained. + This creates a security hazard, since users might be relying on the + environment variable to force SSL-encrypted connections, but that + would no longer be guaranteed. Restore handling of the variable, + but give it lower priority than PGSSLMODE, to avoid + breaking configurations that work correctly with post-9.3 code. + (CVE-2017-7485) + + + Fix possible corruption of init forks of unlogged indexes diff --git a/doc/src/sgml/release-9.4.sgml b/doc/src/sgml/release-9.4.sgml index 5bc6f68fd1..2835776d77 100644 --- a/doc/src/sgml/release-9.4.sgml +++ b/doc/src/sgml/release-9.4.sgml @@ -23,8 +23,13 @@ - However, if you are using third-party replication tools that depend - on logical decoding, see the first changelog entry below. + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are using third-party replication tools that depend + on logical decoding, see the fourth changelog entry below. @@ -38,6 +43,142 @@ + + + Restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Michael Paquier, Feike Steenbergen) + + + + The previous coding allowed the owner of a foreign server object, + or anyone he has granted server USAGE permission to, + to see the options for all user mappings associated with that server. + This might well include passwords for other users. + Adjust the view definition to match the behavior of + information_schema.user_mapping_options, namely that + these options are visible to the user being mapped, or if the mapping + is for PUBLIC and the current user is the server + owner, or if the current user is a superuser. + (CVE-2017-7486) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Prevent exposure of statistical information via leaky operators + (Peter Eisentraut) + + + + Some selectivity estimation functions in the planner will apply + user-defined operators to values obtained + from pg_statistic, such as most common values and + histogram entries. This occurs before table permissions are checked, + so a nefarious user could exploit the behavior to obtain these values + for table columns he does not have permission to read. To fix, + fall back to a default estimate if the operator's implementation + function is not certified leak-proof and the calling user does not have + permission to read the table column whose statistics are needed. + At least one of these criteria is satisfied in most cases in practice. + (CVE-2017-7484) + + + + + + Restore libpq's recognition of + the PGREQUIRESSL environment variable (Daniel Gustafsson) + + + + Processing of this environment variable was unintentionally dropped + in PostgreSQL 9.3, but its documentation remained. + This creates a security hazard, since users might be relying on the + environment variable to force SSL-encrypted connections, but that + would no longer be guaranteed. Restore handling of the variable, + but give it lower priority than PGSSLMODE, to avoid + breaking configurations that work correctly with post-9.3 code. + (CVE-2017-7485) + + + Fix possibly-invalid initial snapshot during logical decoding diff --git a/doc/src/sgml/release-9.5.sgml b/doc/src/sgml/release-9.5.sgml index b00b1e64ea..6a76463e78 100644 --- a/doc/src/sgml/release-9.5.sgml +++ b/doc/src/sgml/release-9.5.sgml @@ -23,8 +23,13 @@ - However, if you are using third-party replication tools that depend - on logical decoding, see the first changelog entry below. + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are using third-party replication tools that depend + on logical decoding, see the fourth changelog entry below. @@ -38,6 +43,142 @@ + + + Restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Michael Paquier, Feike Steenbergen) + + + + The previous coding allowed the owner of a foreign server object, + or anyone he has granted server USAGE permission to, + to see the options for all user mappings associated with that server. + This might well include passwords for other users. + Adjust the view definition to match the behavior of + information_schema.user_mapping_options, namely that + these options are visible to the user being mapped, or if the mapping + is for PUBLIC and the current user is the server + owner, or if the current user is a superuser. + (CVE-2017-7486) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Prevent exposure of statistical information via leaky operators + (Peter Eisentraut) + + + + Some selectivity estimation functions in the planner will apply + user-defined operators to values obtained + from pg_statistic, such as most common values and + histogram entries. This occurs before table permissions are checked, + so a nefarious user could exploit the behavior to obtain these values + for table columns he does not have permission to read. To fix, + fall back to a default estimate if the operator's implementation + function is not certified leak-proof and the calling user does not have + permission to read the table column whose statistics are needed. + At least one of these criteria is satisfied in most cases in practice. + (CVE-2017-7484) + + + + + + Restore libpq's recognition of + the PGREQUIRESSL environment variable (Daniel Gustafsson) + + + + Processing of this environment variable was unintentionally dropped + in PostgreSQL 9.3, but its documentation remained. + This creates a security hazard, since users might be relying on the + environment variable to force SSL-encrypted connections, but that + would no longer be guaranteed. Restore handling of the variable, + but give it lower priority than PGSSLMODE, to avoid + breaking configurations that work correctly with post-9.3 code. + (CVE-2017-7485) + + + Fix possibly-invalid initial snapshot during logical decoding diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml index 1ec705c71b..b32826f210 100644 --- a/doc/src/sgml/release-9.6.sgml +++ b/doc/src/sgml/release-9.6.sgml @@ -23,8 +23,13 @@ - However, if you are using third-party replication tools that depend - on logical decoding, see the first changelog entry below. + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are using third-party replication tools that depend + on logical decoding, see the fourth changelog entry below. @@ -40,6 +45,174 @@ + + Restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Michael Paquier, Feike Steenbergen) + + + + The previous coding allowed the owner of a foreign server object, + or anyone he has granted server USAGE permission to, + to see the options for all user mappings associated with that server. + This might well include passwords for other users. + Adjust the view definition to match the behavior of + information_schema.user_mapping_options, namely that + these options are visible to the user being mapped, or if the mapping + is for PUBLIC and the current user is the server + owner, or if the current user is a superuser. + (CVE-2017-7486) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + + Prevent exposure of statistical information via leaky operators + (Peter Eisentraut) + + + + Some selectivity estimation functions in the planner will apply + user-defined operators to values obtained + from pg_statistic, such as most common values and + histogram entries. This occurs before table permissions are checked, + so a nefarious user could exploit the behavior to obtain these values + for table columns he does not have permission to read. To fix, + fall back to a default estimate if the operator's implementation + function is not certified leak-proof and the calling user does not have + permission to read the table column whose statistics are needed. + At least one of these criteria is satisfied in most cases in practice. + (CVE-2017-7484) + + + + + + + Restore libpq's recognition of + the PGREQUIRESSL environment variable (Daniel Gustafsson) + + + + Processing of this environment variable was unintentionally dropped + in PostgreSQL 9.3, but its documentation remained. + This creates a security hazard, since users might be relying on the + environment variable to force SSL-encrypted connections, but that + would no longer be guaranteed. Restore handling of the variable, + but give it lower priority than PGSSLMODE, to avoid + breaking configurations that work correctly with post-9.3 code. + (CVE-2017-7485) + + + + +| + * | | BUILDING_SNAPSHOT |------------>| * | +-------------------------+ | + * | | | + * | | | + * | running_xacts #2, xacts from #1 finished | + * | | | + * | | | + * | v | + * | +-------------------------+ v + * | | FULL_SNAPSHOT |------------>| + * | +-------------------------+ | + * | | | * running_xacts | saved snapshot * with zero xacts | at running_xacts's lsn * | | | - * | all running toplevel TXNs finished | + * | running_xacts with xacts from #2 finished | * | | | * | v | * | +-------------------------+ | @@ -82,8 +93,8 @@ * Initially the machinery is in the START stage. When an xl_running_xacts * record is read that is sufficiently new (above the safe xmin horizon), * there's a state transition. If there were no running xacts when the - * runnign_xacts record was generated, we'll directly go into CONSISTENT - * state, otherwise we'll switch to the FULL_SNAPSHOT state. Having a full + * running_xacts record was generated, we'll directly go into CONSISTENT + * state, otherwise we'll switch to the BUILDING_SNAPSHOT state. Having a full * snapshot means that all transactions that start henceforth can be decoded * in their entirety, but transactions that started previously can't. In * FULL_SNAPSHOT we'll switch into CONSISTENT once all those previously @@ -183,26 +194,24 @@ struct SnapBuild ReorderBuffer *reorder; /* - * Information about initially running transactions - * - * When we start building a snapshot there already may be transactions in - * progress. Those are stored in running.xip. We don't have enough - * information about those to decode their contents, so until they are - * finished (xcnt=0) we cannot switch to a CONSISTENT state. + * Outdated: This struct isn't used for its original purpose anymore, but + * can't be removed / changed in a minor version, because it's stored + * on-disk. */ struct { /* - * As long as running.xcnt all XIDs < running.xmin and > running.xmax - * have to be checked whether they still are running. + * NB: This field is misused, until a major version can break on-disk + * compatibility. See SnapBuildNextPhaseAt() / + * SnapBuildStartNextPhaseAt(). */ - TransactionId xmin; - TransactionId xmax; + TransactionId was_xmin; + TransactionId was_xmax; - size_t xcnt; /* number of used xip entries */ - size_t xcnt_space; /* allocated size of xip */ - TransactionId *xip; /* running xacts array, xidComparator-sorted */ - } running; + size_t was_xcnt; /* number of used xip entries */ + size_t was_xcnt_space; /* allocated size of xip */ + TransactionId *was_xip; /* running xacts array, xidComparator-sorted */ + } was_running; /* * Array of transactions which could have catalog changes that committed @@ -248,12 +257,6 @@ struct SnapBuild static ResourceOwner SavedResourceOwnerDuringExport = NULL; static bool ExportInProgress = false; -/* transaction state manipulation functions */ -static void SnapBuildEndTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid); - -/* ->running manipulation */ -static bool SnapBuildTxnIsRunning(SnapBuild *builder, TransactionId xid); - /* ->committed manipulation */ static void SnapBuildPurgeCommittedTxn(SnapBuild *builder); @@ -268,11 +271,39 @@ static void SnapBuildDistributeNewCatalogSnapshot(SnapBuild *builder, XLogRecPtr /* xlog reading helper functions for SnapBuildProcessRecord */ static bool SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *running); +static void SnapBuildWaitSnapshot(xl_running_xacts *running, TransactionId cutoff); /* serialization functions */ static void SnapBuildSerialize(SnapBuild *builder, XLogRecPtr lsn); static bool SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn); +/* + * Return TransactionId after which the next phase of initial snapshot + * building will happen. + */ +static inline TransactionId +SnapBuildNextPhaseAt(SnapBuild *builder) +{ + /* + * For backward compatibility reasons this has to be stored in the wrongly + * named field. Will be fixed in next major version. + */ + return builder->was_running.was_xmax; +} + +/* + * Set TransactionId after which the next phase of initial snapshot building + * will happen. + */ +static inline void +SnapBuildStartNextPhaseAt(SnapBuild *builder, TransactionId at) +{ + /* + * For backward compatibility reasons this has to be stored in the wrongly + * named field. Will be fixed in next major version. + */ + builder->was_running.was_xmax = at; +} /* * Allocate a new snapshot builder. @@ -682,7 +713,7 @@ SnapBuildProcessChange(SnapBuild *builder, TransactionId xid, XLogRecPtr lsn) * we got into the SNAPBUILD_FULL_SNAPSHOT state. */ if (builder->state < SNAPBUILD_CONSISTENT && - SnapBuildTxnIsRunning(builder, xid)) + TransactionIdPrecedes(xid, SnapBuildNextPhaseAt(builder))) return false; /* @@ -750,38 +781,6 @@ SnapBuildProcessNewCid(SnapBuild *builder, TransactionId xid, ReorderBufferAddNewCommandId(builder->reorder, xid, lsn, cid + 1); } -/* - * Check whether `xid` is currently 'running'. - * - * Running transactions in our parlance are transactions which we didn't - * observe from the start so we can't properly decode their contents. They - * only exist after we freshly started from an < CONSISTENT snapshot. - */ -static bool -SnapBuildTxnIsRunning(SnapBuild *builder, TransactionId xid) -{ - Assert(builder->state < SNAPBUILD_CONSISTENT); - Assert(TransactionIdIsNormal(builder->running.xmin)); - Assert(TransactionIdIsNormal(builder->running.xmax)); - - if (builder->running.xcnt && - NormalTransactionIdFollows(xid, builder->running.xmin) && - NormalTransactionIdPrecedes(xid, builder->running.xmax)) - { - TransactionId *search = - bsearch(&xid, builder->running.xip, builder->running.xcnt_space, - sizeof(TransactionId), xidComparator); - - if (search != NULL) - { - Assert(*search == xid); - return true; - } - } - - return false; -} - /* * Add a new Snapshot to all transactions we're decoding that currently are * in-progress so they can see new catalog contents made by the transaction @@ -903,63 +902,6 @@ SnapBuildPurgeCommittedTxn(SnapBuild *builder) pfree(workspace); } -/* - * Common logic for SnapBuildAbortTxn and SnapBuildCommitTxn dealing with - * keeping track of the amount of running transactions. - */ -static void -SnapBuildEndTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid) -{ - if (builder->state == SNAPBUILD_CONSISTENT) - return; - - /* - * NB: This handles subtransactions correctly even if we started from - * suboverflowed xl_running_xacts because we only keep track of toplevel - * transactions. Since the latter are always allocated before their - * subxids and since they end at the same time it's sufficient to deal - * with them here. - */ - if (SnapBuildTxnIsRunning(builder, xid)) - { - Assert(builder->running.xcnt > 0); - - if (!--builder->running.xcnt) - { - /* - * None of the originally running transaction is running anymore, - * so our incrementally built snapshot now is consistent. - */ - ereport(LOG, - (errmsg("logical decoding found consistent point at %X/%X", - (uint32) (lsn >> 32), (uint32) lsn), - errdetail("Transaction ID %u finished; no more running transactions.", - xid))); - builder->state = SNAPBUILD_CONSISTENT; - } - } -} - -/* - * Abort a transaction, throw away all state we kept. - */ -void -SnapBuildAbortTxn(SnapBuild *builder, XLogRecPtr lsn, - TransactionId xid, - int nsubxacts, TransactionId *subxacts) -{ - int i; - - for (i = 0; i < nsubxacts; i++) - { - TransactionId subxid = subxacts[i]; - - SnapBuildEndTxn(builder, lsn, subxid); - } - - SnapBuildEndTxn(builder, lsn, xid); -} - /* * Handle everything that needs to be done when a transaction commits */ @@ -1003,11 +945,6 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, { TransactionId subxid = subxacts[nxact]; - /* - * make sure txn is not tracked in running txn's anymore, switch state - */ - SnapBuildEndTxn(builder, lsn, subxid); - /* * If we're forcing timetravel we also need visibility information * about subtransaction, so keep track of subtransaction's state. @@ -1037,12 +974,6 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, } } - /* - * Make sure toplevel txn is not tracked in running txn's anymore, switch - * state to consistent if possible. - */ - SnapBuildEndTxn(builder, lsn, xid); - if (forced_timetravel) { elog(DEBUG2, "forced transaction %u to do timetravel.", xid); @@ -1232,25 +1163,20 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn * * a) There were no running transactions when the xl_running_xacts record * was inserted, jump to CONSISTENT immediately. We might find such a - * state we were waiting for b) or c). - * - * b) Wait for all toplevel transactions that were running to end. We - * simply track the number of in-progress toplevel transactions and - * lower it whenever one commits or aborts. When that number - * (builder->running.xcnt) reaches zero, we can go from FULL_SNAPSHOT - * to CONSISTENT. - * NB: We need to search running.xip when seeing a transaction's end to - * make sure it's a toplevel transaction and it's been one of the - * initially running ones. - * Interestingly, in contrast to HS, this allows us not to care about - * subtransactions - and by extension suboverflowed xl_running_xacts - - * at all. + * state while waiting on c)'s sub-states. * - * c) This (in a previous run) or another decoding slot serialized a + * b) This (in a previous run) or another decoding slot serialized a * snapshot to disk that we can use. Can't use this method for the * initial snapshot when slot is being created and needs full snapshot * for export or direct use, as that snapshot will only contain catalog * modifying transactions. + * + * c) First incrementally build a snapshot for catalog tuples + * (BUILDING_SNAPSHOT), that requires all, already in-progress, + * transactions to finish. Every transaction starting after that + * (FULL_SNAPSHOT state), has enough information to be decoded. But + * for older running transactions no viable snapshot exists yet, so + * CONSISTENT will only be reached once all of those have finished. * --- */ @@ -1267,16 +1193,23 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn (uint32) (lsn >> 32), (uint32) lsn), errdetail_internal("initial xmin horizon of %u vs the snapshot's %u", builder->initial_xmin_horizon, running->oldestRunningXid))); + + + SnapBuildWaitSnapshot(running, builder->initial_xmin_horizon); + return true; } /* * a) No transaction were running, we can jump to consistent. * + * This is not affected by races around xl_running_xacts, because we can + * miss transaction commits, but currently not transactions starting. + * * NB: We might have already started to incrementally assemble a snapshot, * so we need to be careful to deal with that. */ - if (running->xcnt == 0) + if (running->oldestRunningXid == running->nextXid) { if (builder->start_decoding_at == InvalidXLogRecPtr || builder->start_decoding_at <= lsn) @@ -1291,12 +1224,8 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn Assert(TransactionIdIsNormal(builder->xmin)); Assert(TransactionIdIsNormal(builder->xmax)); - /* no transactions running now */ - builder->running.xcnt = 0; - builder->running.xmin = InvalidTransactionId; - builder->running.xmax = InvalidTransactionId; - builder->state = SNAPBUILD_CONSISTENT; + SnapBuildStartNextPhaseAt(builder, InvalidTransactionId); ereport(LOG, (errmsg("logical decoding found consistent point at %X/%X", @@ -1305,30 +1234,29 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn return false; } - /* c) valid on disk state and not building full snapshot */ + /* b) valid on disk state and not building full snapshot */ else if (!builder->building_full_snapshot && SnapBuildRestore(builder, lsn)) { /* there won't be any state to cleanup */ return false; } - /* - * b) first encounter of a useable xl_running_xacts record. If we had - * found one earlier we would either track running transactions (i.e. - * builder->running.xcnt != 0) or be consistent (this function wouldn't - * get called). + * c) transition from START to BUILDING_SNAPSHOT. + * + * In START state, and a xl_running_xacts record with running xacts is + * encountered. In that case, switch to BUILDING_SNAPSHOT state, and + * record xl_running_xacts->nextXid. Once all running xacts have finished + * (i.e. they're all >= nextXid), we have a complete catalog snapshot. It + * might look that we could use xl_running_xact's ->xids information to + * get there quicker, but that is problematic because transactions marked + * as running, might already have inserted their commit record - it's + * infeasible to change that with locking. */ - else if (!builder->running.xcnt) + else if (builder->state == SNAPBUILD_START) { - int off; - - /* - * We only care about toplevel xids as those are the ones we - * definitely see in the wal stream. As snapbuild.c tracks committed - * instead of running transactions we don't need to know anything - * about uncommitted subtransactions. - */ + builder->state = SNAPBUILD_BUILDING_SNAPSHOT; + SnapBuildStartNextPhaseAt(builder, running->nextXid); /* * Start with an xmin/xmax that's correct for future, when all the @@ -1342,59 +1270,57 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn Assert(TransactionIdIsNormal(builder->xmin)); Assert(TransactionIdIsNormal(builder->xmax)); - builder->running.xcnt = running->xcnt; - builder->running.xcnt_space = running->xcnt; - builder->running.xip = - MemoryContextAlloc(builder->context, - builder->running.xcnt * sizeof(TransactionId)); - memcpy(builder->running.xip, running->xids, - builder->running.xcnt * sizeof(TransactionId)); - - /* sort so we can do a binary search */ - qsort(builder->running.xip, builder->running.xcnt, - sizeof(TransactionId), xidComparator); - - builder->running.xmin = builder->running.xip[0]; - builder->running.xmax = builder->running.xip[running->xcnt - 1]; - - /* makes comparisons cheaper later */ - TransactionIdRetreat(builder->running.xmin); - TransactionIdAdvance(builder->running.xmax); - - builder->state = SNAPBUILD_FULL_SNAPSHOT; - ereport(LOG, (errmsg("logical decoding found initial starting point at %X/%X", (uint32) (lsn >> 32), (uint32) lsn), - errdetail_plural("%u transaction needs to finish.", - "%u transactions need to finish.", - builder->running.xcnt, - (uint32) builder->running.xcnt))); + errdetail("Waiting for transactions (approximately %d) older than %u to end.", + running->xcnt, running->nextXid))); - /* - * Iterate through all xids, wait for them to finish. - * - * This isn't required for the correctness of decoding, but to allow - * isolationtester to notice that we're currently waiting for - * something. - */ - for (off = 0; off < builder->running.xcnt; off++) - { - TransactionId xid = builder->running.xip[off]; + SnapBuildWaitSnapshot(running, running->nextXid); + } + /* + * c) transition from BUILDING_SNAPSHOT to FULL_SNAPSHOT. + * + * In BUILDING_SNAPSHOT state, and this xl_running_xacts' oldestRunningXid + * is >= than nextXid from when we switched to BUILDING_SNAPSHOT. This + * means all transactions starting afterwards have enough information to + * be decoded. Switch to FULL_SNAPSHOT. + */ + else if (builder->state == SNAPBUILD_BUILDING_SNAPSHOT && + TransactionIdPrecedesOrEquals(SnapBuildNextPhaseAt(builder), + running->oldestRunningXid)) + { + builder->state = SNAPBUILD_FULL_SNAPSHOT; + SnapBuildStartNextPhaseAt(builder, running->nextXid); - /* - * Upper layers should prevent that we ever need to wait on - * ourselves. Check anyway, since failing to do so would either - * result in an endless wait or an Assert() failure. - */ - if (TransactionIdIsCurrentTransactionId(xid)) - elog(ERROR, "waiting for ourselves"); + ereport(LOG, + (errmsg("logical decoding found initial consistent point at %X/%X", + (uint32) (lsn >> 32), (uint32) lsn), + errdetail("Waiting for transactions (approximately %d) older than %u to end.", + running->xcnt, running->nextXid))); - XactLockTableWait(xid, NULL, NULL, XLTW_None); - } + SnapBuildWaitSnapshot(running, running->nextXid); + } + /* + * c) transition from FULL_SNAPSHOT to CONSISTENT. + * + * In FULL_SNAPSHOT state (see d) ), and this xl_running_xacts' + * oldestRunningXid is >= than nextXid from when we switched to + * FULL_SNAPSHOT. This means all transactions that are currently in + * progress have a catalog snapshot, and all their changes have been + * collected. Switch to CONSISTENT. + */ + else if (builder->state == SNAPBUILD_FULL_SNAPSHOT && + TransactionIdPrecedesOrEquals(SnapBuildNextPhaseAt(builder), + running->oldestRunningXid)) + { + builder->state = SNAPBUILD_CONSISTENT; + SnapBuildStartNextPhaseAt(builder, InvalidTransactionId); - /* nothing could have built up so far, so don't perform cleanup */ - return false; + ereport(LOG, + (errmsg("logical decoding found consistent point at %X/%X", + (uint32) (lsn >> 32), (uint32) lsn), + errdetail("There are no old transactions anymore."))); } /* @@ -1403,8 +1329,54 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn * records so incremental cleanup can be performed. */ return true; + } +/* --- + * Iterate through xids in record, wait for all older than the cutoff to + * finish. Then, if possible, log a new xl_running_xacts record. + * + * This isn't required for the correctness of decoding, but to: + * a) allow isolationtester to notice that we're currently waiting for + * something. + * b) log a new xl_running_xacts record where it'd be helpful, without having + * to write for bgwriter or checkpointer. + * --- + */ +static void +SnapBuildWaitSnapshot(xl_running_xacts *running, TransactionId cutoff) +{ + int off; + + for (off = 0; off < running->xcnt; off++) + { + TransactionId xid = running->xids[off]; + + /* + * Upper layers should prevent that we ever need to wait on + * ourselves. Check anyway, since failing to do so would either + * result in an endless wait or an Assert() failure. + */ + if (TransactionIdIsCurrentTransactionId(xid)) + elog(ERROR, "waiting for ourselves"); + + if (TransactionIdFollows(xid, cutoff)) + continue; + + XactLockTableWait(xid, NULL, NULL, XLTW_None); + } + + /* + * All transactions we needed to finish finished - try to ensure there is + * another xl_running_xacts record in a timely manner, without having to + * write for bgwriter or checkpointer to log one. During recovery we + * can't enforce that, so we'll have to wait. + */ + if (!RecoveryInProgress()) + { + LogStandbySnapshot(); + } +} /* ----------------------------------- * Snapshot serialization support @@ -1554,7 +1526,6 @@ SnapBuildSerialize(SnapBuild *builder, XLogRecPtr lsn) errmsg("could not remove file \"%s\": %m", path))); needed_length = sizeof(SnapBuildOnDisk) + - sizeof(TransactionId) * builder->running.xcnt_space + sizeof(TransactionId) * builder->committed.xcnt; ondisk_c = MemoryContextAllocZero(builder->context, needed_length); @@ -1573,18 +1544,14 @@ SnapBuildSerialize(SnapBuild *builder, XLogRecPtr lsn) ondisk->builder.context = NULL; ondisk->builder.snapshot = NULL; ondisk->builder.reorder = NULL; - ondisk->builder.running.xip = NULL; ondisk->builder.committed.xip = NULL; COMP_CRC32C(ondisk->checksum, &ondisk->builder, sizeof(SnapBuild)); - /* copy running xacts */ - sz = sizeof(TransactionId) * builder->running.xcnt_space; - memcpy(ondisk_c, builder->running.xip, sz); - COMP_CRC32C(ondisk->checksum, ondisk_c, sz); - ondisk_c += sz; + /* there shouldn't be any running xacts */ + Assert(builder->was_running.was_xcnt == 0); /* copy committed xacts */ sz = sizeof(TransactionId) * builder->committed.xcnt; @@ -1736,10 +1703,11 @@ SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn) } COMP_CRC32C(checksum, &ondisk.builder, sizeof(SnapBuild)); - /* restore running xacts information */ - sz = sizeof(TransactionId) * ondisk.builder.running.xcnt_space; - ondisk.builder.running.xip = MemoryContextAllocZero(builder->context, sz); - readBytes = read(fd, ondisk.builder.running.xip, sz); + /* restore running xacts (dead, but kept for backward compat) */ + sz = sizeof(TransactionId) * ondisk.builder.was_running.was_xcnt_space; + ondisk.builder.was_running.was_xip = + MemoryContextAllocZero(builder->context, sz); + readBytes = read(fd, ondisk.builder.was_running.was_xip, sz); if (readBytes != sz) { CloseTransientFile(fd); @@ -1748,7 +1716,7 @@ SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn) errmsg("could not read file \"%s\", read %d of %d: %m", path, readBytes, (int) sz))); } - COMP_CRC32C(checksum, ondisk.builder.running.xip, sz); + COMP_CRC32C(checksum, ondisk.builder.was_running.was_xip, sz); /* restore committed xacts information */ sz = sizeof(TransactionId) * ondisk.builder.committed.xcnt; @@ -1812,12 +1780,6 @@ SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn) } ondisk.builder.committed.xip = NULL; - builder->running.xcnt = ondisk.builder.running.xcnt; - if (builder->running.xip) - pfree(builder->running.xip); - builder->running.xcnt_space = ondisk.builder.running.xcnt_space; - builder->running.xip = ondisk.builder.running.xip; - /* our snapshot is not interesting anymore, build a new one */ if (builder->snapshot != NULL) { @@ -1837,8 +1799,6 @@ SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn) return true; snapshot_not_interesting: - if (ondisk.builder.running.xip != NULL) - pfree(ondisk.builder.running.xip); if (ondisk.builder.committed.xip != NULL) pfree(ondisk.builder.committed.xip); return false; diff --git a/src/include/replication/snapbuild.h b/src/include/replication/snapbuild.h index 1df4f37634..80e91c9c25 100644 --- a/src/include/replication/snapbuild.h +++ b/src/include/replication/snapbuild.h @@ -20,24 +20,30 @@ typedef enum /* * Initial state, we can't do much yet. */ - SNAPBUILD_START, + SNAPBUILD_START = -1, + + /* + * Collecting committed transactions, to build the initial catalog + * snapshot. + */ + SNAPBUILD_BUILDING_SNAPSHOT = 0, /* * We have collected enough information to decode tuples in transactions * that started after this. * * Once we reached this we start to collect changes. We cannot apply them - * yet because the might be based on transactions that were still running - * when we reached them yet. + * yet, because they might be based on transactions that were still running + * when FULL_SNAPSHOT was reached. */ - SNAPBUILD_FULL_SNAPSHOT, + SNAPBUILD_FULL_SNAPSHOT = 1, /* - * Found a point after hitting built_full_snapshot where all transactions - * that were running at that point finished. Till we reach that we hold - * off calling any commit callbacks. + * Found a point after SNAPBUILD_FULL_SNAPSHOT where all transactions that + * were running at that point finished. Till we reach that we hold off + * calling any commit callbacks. */ - SNAPBUILD_CONSISTENT + SNAPBUILD_CONSISTENT = 2 } SnapBuildState; /* forward declare so we don't have to expose the struct to the public */ @@ -72,9 +78,6 @@ extern bool SnapBuildXactNeedsSkip(SnapBuild *snapstate, XLogRecPtr ptr); extern void SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, int nsubxacts, TransactionId *subxacts); -extern void SnapBuildAbortTxn(SnapBuild *builder, XLogRecPtr lsn, - TransactionId xid, int nsubxacts, - TransactionId *subxacts); extern bool SnapBuildProcessChange(SnapBuild *builder, TransactionId xid, XLogRecPtr lsn); extern void SnapBuildProcessNewCid(SnapBuild *builder, TransactionId xid, From bd619fcfe046d01662fe500ccf5f3e763b81706a Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Sat, 13 May 2017 14:47:41 -0700 Subject: [PATCH 0066/1139] Avoid superfluous work for commits during logical slot creation. Before 955a684e0401 logical decoding snapshot maintenance needed to cope with transactions it might not have seen in their entirety. For such transactions we'd to assume they modified the catalog (could have happened before we were watching), and thus a new snapshot had to be built, and distributed to concurrently running transactions. That's problematic because building a new snapshot isn't that cheap , especially as the the array of committed transactions needs to be sorted. When creating a slot on a server with a lot of transactions, this could make logical slot creation infeasibly expensive. After 955a684e0401 there's no need to deal with transaction that aren't guaranteed to be fully observable. That allows to avoid building snapshots for transactions that haven't modified catalog, even before reaching consistency. While this isn't necessarily a bugfix, slot creation being impossible in some production workloads, is severe enough to warrant backpatching. Author: Andres Freund, based on a quite different patch from Petr Jelinek Analyzed-By: Petr Jelinek Reviewed-By: Petr Jelinek Discussion: https://postgr.es/m/f37e975c-908f-858e-707f-058d3b1eb214@2ndquadrant.com Backpatch: 9.4-, where logical decoding has been introduced --- src/backend/replication/logical/snapbuild.c | 124 +++++++++++--------- 1 file changed, 68 insertions(+), 56 deletions(-) diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c index 8001f5b1f0..536f7620ce 100644 --- a/src/backend/replication/logical/snapbuild.c +++ b/src/backend/replication/logical/snapbuild.c @@ -911,21 +911,26 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, { int nxact; - bool forced_timetravel = false; + bool needs_snapshot = false; + bool needs_timetravel = false; bool sub_needs_timetravel = false; - bool top_needs_timetravel = false; TransactionId xmax = xid; /* - * If we couldn't observe every change of a transaction because it was - * already running at the point we started to observe we have to assume it - * made catalog changes. - * - * This has the positive benefit that we afterwards have enough - * information to build an exportable snapshot that's usable by pg_dump et - * al. + * Transactions preceding BUILDING_SNAPSHOT will neither be decoded, nor + * will they be part of a snapshot. So we don't need to record anything. */ + if (builder->state == SNAPBUILD_START || + (builder->state == SNAPBUILD_BUILDING_SNAPSHOT && + TransactionIdPrecedes(xid, SnapBuildNextPhaseAt(builder)))) + { + /* ensure that only commits after this are getting replayed */ + if (builder->start_decoding_at <= lsn) + builder->start_decoding_at = lsn + 1; + return; + } + if (builder->state < SNAPBUILD_CONSISTENT) { /* ensure that only commits after this are getting replayed */ @@ -933,12 +938,13 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, builder->start_decoding_at = lsn + 1; /* - * We could avoid treating !SnapBuildTxnIsRunning transactions as - * timetravel ones, but we want to be able to export a snapshot when - * we reached consistency. + * If building an exportable snapshot, force xid to be tracked, even + * if the transaction didn't modify the catalog. */ - forced_timetravel = true; - elog(DEBUG1, "forced to assume catalog changes for xid %u because it was running too early", xid); + if (builder->building_full_snapshot) + { + needs_timetravel = true; + } } for (nxact = 0; nxact < nsubxacts; nxact++) @@ -946,70 +952,81 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, TransactionId subxid = subxacts[nxact]; /* - * If we're forcing timetravel we also need visibility information - * about subtransaction, so keep track of subtransaction's state. + * Add subtransaction to base snapshot if catalog modifying, we don't + * distinguish to toplevel transactions there. */ - if (forced_timetravel) + if (ReorderBufferXidHasCatalogChanges(builder->reorder, subxid)) { + sub_needs_timetravel = true; + needs_snapshot = true; + + elog(DEBUG1, "found subtransaction %u:%u with catalog changes", + xid, subxid); + SnapBuildAddCommittedTxn(builder, subxid); + if (NormalTransactionIdFollows(subxid, xmax)) xmax = subxid; } - /* - * Add subtransaction to base snapshot if it DDL, we don't distinguish - * to toplevel transactions there. + * If we're forcing timetravel we also need visibility information + * about subtransaction, so keep track of subtransaction's state, even + * if not catalog modifying. Don't need to distribute a snapshot in + * that case. */ - else if (ReorderBufferXidHasCatalogChanges(builder->reorder, subxid)) + else if (needs_timetravel) { - sub_needs_timetravel = true; - - elog(DEBUG1, "found subtransaction %u:%u with catalog changes.", - xid, subxid); - SnapBuildAddCommittedTxn(builder, subxid); - if (NormalTransactionIdFollows(subxid, xmax)) xmax = subxid; } } - if (forced_timetravel) + /* if top-level modified catalog, it'll need a snapshot */ + if (ReorderBufferXidHasCatalogChanges(builder->reorder, xid)) { - elog(DEBUG2, "forced transaction %u to do timetravel.", xid); - + elog(DEBUG2, "found top level transaction %u, with catalog changes", + xid); + needs_snapshot = true; + needs_timetravel = true; SnapBuildAddCommittedTxn(builder, xid); } - /* add toplevel transaction to base snapshot */ - else if (ReorderBufferXidHasCatalogChanges(builder->reorder, xid)) + else if (sub_needs_timetravel) { - elog(DEBUG2, "found top level transaction %u, with catalog changes!", - xid); - - top_needs_timetravel = true; + /* track toplevel txn as well, subxact alone isn't meaningful */ SnapBuildAddCommittedTxn(builder, xid); } - else if (sub_needs_timetravel) + else if (needs_timetravel) { - /* mark toplevel txn as timetravel as well */ + elog(DEBUG2, "forced transaction %u to do timetravel", xid); + SnapBuildAddCommittedTxn(builder, xid); } - /* if there's any reason to build a historic snapshot, do so now */ - if (forced_timetravel || top_needs_timetravel || sub_needs_timetravel) + if (!needs_timetravel) { - /* - * Adjust xmax of the snapshot builder, we only do that for committed, - * catalog modifying, transactions, everything else isn't interesting - * for us since we'll never look at the respective rows. - */ - if (!TransactionIdIsValid(builder->xmax) || - TransactionIdFollowsOrEquals(xmax, builder->xmax)) - { - builder->xmax = xmax; - TransactionIdAdvance(builder->xmax); - } + /* record that we cannot export a general snapshot anymore */ + builder->committed.includes_all_transactions = false; + } + + Assert(!needs_snapshot || needs_timetravel); + /* + * Adjust xmax of the snapshot builder, we only do that for committed, + * catalog modifying, transactions, everything else isn't interesting + * for us since we'll never look at the respective rows. + */ + if (needs_timetravel && + (!TransactionIdIsValid(builder->xmax) || + TransactionIdFollowsOrEquals(xmax, builder->xmax))) + { + builder->xmax = xmax; + TransactionIdAdvance(builder->xmax); + } + + /* if there's any reason to build a historic snapshot, do so now */ + if (needs_snapshot) + { /* * If we haven't built a complete snapshot yet there's no need to hand * it out, it wouldn't (and couldn't) be used anyway. @@ -1041,11 +1058,6 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, /* add a new Snapshot to all currently running transactions */ SnapBuildDistributeNewCatalogSnapshot(builder, lsn); } - else - { - /* record that we cannot export a general snapshot anymore */ - builder->committed.includes_all_transactions = false; - } } From 69db3b0cfccc0687dfbdf56afcfb2f8e536053c6 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Sun, 14 May 2017 01:10:18 -0400 Subject: [PATCH 0067/1139] Suppress indentation from Data::Dumper in regression tests Ultra-modern versions of the perl Data::Dumper module have apparently changed how they indent output. Instead of trying to keep up we choose to tell it to supporess all indentation in the hstore_plperl regression tests. Backpatch to 9.5 where this feature was introduced. --- .../hstore_plperl/expected/hstore_plperlu.out | 44 +++++-------------- contrib/hstore_plperl/sql/hstore_plperlu.sql | 6 +++ 2 files changed, 17 insertions(+), 33 deletions(-) diff --git a/contrib/hstore_plperl/expected/hstore_plperlu.out b/contrib/hstore_plperl/expected/hstore_plperlu.out index b09fb78af9..d719d29f72 100644 --- a/contrib/hstore_plperl/expected/hstore_plperlu.out +++ b/contrib/hstore_plperl/expected/hstore_plperlu.out @@ -20,15 +20,12 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0])); return scalar(keys %{$_[0]}); $$; SELECT test1('aa=>bb, cc=>NULL'::hstore); -INFO: $VAR1 = { - 'aa' => 'bb', - 'cc' => undef - }; - +INFO: $VAR1 = {'aa' => 'bb','cc' => undef}; test1 ------- 2 @@ -39,12 +36,12 @@ LANGUAGE plperlu AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0])); return scalar(keys %{$_[0]}); $$; SELECT test1none('aa=>bb, cc=>NULL'::hstore); INFO: $VAR1 = '"aa"=>"bb", "cc"=>NULL'; - test1none ----------- 0 @@ -56,15 +53,12 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0])); return scalar(keys %{$_[0]}); $$; SELECT test1list('aa=>bb, cc=>NULL'::hstore); -INFO: $VAR1 = { - 'aa' => 'bb', - 'cc' => undef - }; - +INFO: $VAR1 = {'aa' => 'bb','cc' => undef}; test1list ----------- 2 @@ -77,18 +71,12 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0]->[0], $_[0]->[1])); return scalar(keys %{$_[0]}); $$; SELECT test1arr(array['aa=>bb, cc=>NULL'::hstore, 'dd=>ee']); -INFO: $VAR1 = { - 'aa' => 'bb', - 'cc' => undef - }; -$VAR2 = { - 'dd' => 'ee' - }; - +INFO: $VAR1 = {'aa' => 'bb','cc' => undef};$VAR2 = {'dd' => 'ee'}; test1arr ---------- 2 @@ -101,6 +89,7 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; $rv = spi_exec_query(q{SELECT 'aa=>bb, cc=>NULL'::hstore AS col1}); elog(INFO, Dumper($rv->{rows}[0]->{col1})); @@ -111,13 +100,8 @@ $rv = spi_exec_prepared($plan, {}, $val); elog(INFO, Dumper($rv->{rows}[0]->{col1})); $$; SELECT test3(); -INFO: $VAR1 = { - 'aa' => 'bb', - 'cc' => undef - }; - +INFO: $VAR1 = {'aa' => 'bb','cc' => undef}; INFO: $VAR1 = '"a"=>"1", "b"=>"boo", "c"=>NULL'; - test3 ------- @@ -138,6 +122,7 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_TD->{new})); if ($_TD->{new}{a} == 1) { $_TD->{new}{b} = {a => 1, b => 'boo', c => undef}; @@ -147,14 +132,7 @@ return "MODIFY"; $$; CREATE TRIGGER test4 BEFORE UPDATE ON test1 FOR EACH ROW EXECUTE PROCEDURE test4(); UPDATE test1 SET a = a; -INFO: $VAR1 = { - 'a' => '1', - 'b' => { - 'aa' => 'bb', - 'cc' => undef - } - }; - +INFO: $VAR1 = {'a' => '1','b' => {'aa' => 'bb','cc' => undef}}; SELECT * FROM test1; a | b ---+--------------------------------- diff --git a/contrib/hstore_plperl/sql/hstore_plperlu.sql b/contrib/hstore_plperl/sql/hstore_plperlu.sql index 8d8508cf29..c714b35322 100644 --- a/contrib/hstore_plperl/sql/hstore_plperlu.sql +++ b/contrib/hstore_plperl/sql/hstore_plperlu.sql @@ -15,6 +15,7 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0])); return scalar(keys %{$_[0]}); $$; @@ -26,6 +27,7 @@ LANGUAGE plperlu AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0])); return scalar(keys %{$_[0]}); $$; @@ -38,6 +40,7 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0])); return scalar(keys %{$_[0]}); $$; @@ -52,6 +55,7 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_[0]->[0], $_[0]->[1])); return scalar(keys %{$_[0]}); $$; @@ -66,6 +70,7 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; $rv = spi_exec_query(q{SELECT 'aa=>bb, cc=>NULL'::hstore AS col1}); elog(INFO, Dumper($rv->{rows}[0]->{col1})); @@ -90,6 +95,7 @@ TRANSFORM FOR TYPE hstore AS $$ use Data::Dumper; $Data::Dumper::Sortkeys = 1; +$Data::Dumper::Indent = 0; elog(INFO, Dumper($_TD->{new})); if ($_TD->{new}{a} == 1) { $_TD->{new}{b} = {a => 1, b => 'boo', c => undef}; From c4118d3b9bf4273a2877ea20ff6ccb337dbb5abf Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 14 May 2017 21:39:10 -0400 Subject: [PATCH 0068/1139] Make stats regression test more robust in the face of parallel query. Commit 60690a6fe attempted to fix the wait_for_stats() function in this test so that it would wait properly if the tenk2 scans were done in parallel workers instead of the main session (typically as a consequence of force_parallel_mode being turned on). However, we made it test for whether the main session's actions had been reported by looking for inserts on 'trunc_stats_test'. This is the Wrong Thing, because those aren't the last updates we expect the main session to do. As shown by recent failures on buildfarm member frogmouth, it's entirely likely that the trunc_stats_test updates will be reported in a separate message from later updates, which means there can be a window in which wait_for_stats() will exit but not all the updates we are expecting to see will have arrived. We should test for the last updates we're expecting, namely those on 'trunc_stats_test4'. Unfortunately, I doubt that this explains frogmouth's failures, because there's no reason to believe that it's running the tenk2 queries in parallel. Still, the test is wrong on its own terms, so fix and back-patch to 9.6 where parallel query came in. --- src/test/regress/expected/stats.out | 4 ++-- src/test/regress/sql/stats.sql | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/test/regress/expected/stats.out b/src/test/regress/expected/stats.out index a811265d69..4f397a3280 100644 --- a/src/test/regress/expected/stats.out +++ b/src/test/regress/expected/stats.out @@ -59,9 +59,9 @@ begin FROM pg_stat_user_tables AS st, pg_class AS cl, prevstats AS pr WHERE st.relname='tenk2' AND cl.relname='tenk2'; - -- check to see if updates have been sensed + -- check to see if all updates have been sensed SELECT (n_tup_ins > 0) INTO updated3 - FROM pg_stat_user_tables WHERE relname='trunc_stats_test'; + FROM pg_stat_user_tables WHERE relname='trunc_stats_test4'; exit when updated1 and updated2 and updated3; diff --git a/src/test/regress/sql/stats.sql b/src/test/regress/sql/stats.sql index b3e2efa535..521dc4d6a3 100644 --- a/src/test/regress/sql/stats.sql +++ b/src/test/regress/sql/stats.sql @@ -54,9 +54,9 @@ begin FROM pg_stat_user_tables AS st, pg_class AS cl, prevstats AS pr WHERE st.relname='tenk2' AND cl.relname='tenk2'; - -- check to see if updates have been sensed + -- check to see if all updates have been sensed SELECT (n_tup_ins > 0) INTO updated3 - FROM pg_stat_user_tables WHERE relname='trunc_stats_test'; + FROM pg_stat_user_tables WHERE relname='trunc_stats_test4'; exit when updated1 and updated2 and updated3; From b35cce914cd3eef7d4a2471073c80f709d724e5a Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 15 May 2017 11:33:44 -0400 Subject: [PATCH 0069/1139] Fix unsafe reference into relcache in constructed CommentStmt. The CommentStmt made by RebuildConstraintComment() has to pstrdup the relation name, else it will contain a dangling pointer after that relcache entry is flushed. (I'm less sure that pstrdup'ing conname is necessary, but let's be safe.) Failure to do this leads to weird errors or crashes, as reported by Marko Elezovic. Bug introduced by commit e42375fc8, so back-patch to 9.5 as that was. Fix by David Rowley, regression test by Michael Paquier Discussion: https://postgr.es/m/DB6PR03MB30775D58E732D4EB0C13725B9AE00@DB6PR03MB3077.eurprd03.prod.outlook.com --- src/backend/commands/tablecmds.c | 4 +-- src/test/regress/expected/alter_table.out | 33 +++++++++++++++++++++++ src/test/regress/sql/alter_table.sql | 18 +++++++++++++ 3 files changed, 53 insertions(+), 2 deletions(-) diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 5fe367d46b..050ec6b841 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -8917,8 +8917,8 @@ RebuildConstraintComment(AlteredTableInfo *tab, int pass, Oid objid, cmd->objtype = OBJECT_TABCONSTRAINT; cmd->objname = list_make3( makeString(get_namespace_name(RelationGetNamespace(rel))), - makeString(RelationGetRelationName(rel)), - makeString(conname)); + makeString(pstrdup(RelationGetRelationName(rel))), + makeString(pstrdup(conname))); cmd->objargs = NIL; cmd->comment = comment_str; diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out index 513d9e20f6..3886d4e6bc 100644 --- a/src/test/regress/expected/alter_table.out +++ b/src/test/regress/expected/alter_table.out @@ -2788,6 +2788,39 @@ SELECT conname as constraint, obj_description(oid, 'pg_constraint') as comment F comment_test_positive_col_check | CHECK constraint on comment_test.positive_col (2 rows) +-- Check compatibility for foreign keys and comments. This is done +-- separately as rebuilding the column type of the parent leads +-- to an error and would reduce the test scope. +CREATE TABLE comment_test_child ( + id text CONSTRAINT comment_test_child_fk REFERENCES comment_test); +CREATE INDEX comment_test_child_fk ON comment_test_child(id); +COMMENT ON COLUMN comment_test_child.id IS 'Column ''id'' on comment_test_child'; +COMMENT ON INDEX comment_test_child_fk IS 'Index backing the FOREIGN KEY of comment_test_child'; +COMMENT ON CONSTRAINT comment_test_child_fk ON comment_test_child IS 'FOREIGN KEY constraint of comment_test_child'; +-- Change column type of parent +ALTER TABLE comment_test ALTER COLUMN id SET DATA TYPE text; +ALTER TABLE comment_test ALTER COLUMN id SET DATA TYPE int USING id::integer; +ERROR: foreign key constraint "comment_test_child_fk" cannot be implemented +DETAIL: Key columns "id" and "id" are of incompatible types: text and integer. +-- Comments should be intact +SELECT col_description('comment_test_child'::regclass, 1) as comment; + comment +----------------------------------- + Column 'id' on comment_test_child +(1 row) + +SELECT indexrelid::regclass::text as index, obj_description(indexrelid, 'pg_class') as comment FROM pg_index where indrelid = 'comment_test_child'::regclass ORDER BY 1, 2; + index | comment +-----------------------+----------------------------------------------------- + comment_test_child_fk | Index backing the FOREIGN KEY of comment_test_child +(1 row) + +SELECT conname as constraint, obj_description(oid, 'pg_constraint') as comment FROM pg_constraint where conrelid = 'comment_test_child'::regclass ORDER BY 1, 2; + constraint | comment +-----------------------+---------------------------------------------- + comment_test_child_fk | FOREIGN KEY constraint of comment_test_child +(1 row) + -- Check that we map relation oids to filenodes and back correctly. Only -- display bad mappings so the test output doesn't change all the time. A -- filenode function call can return NULL for a relation dropped concurrently diff --git a/src/test/regress/sql/alter_table.sql b/src/test/regress/sql/alter_table.sql index 9b3615b4dd..d01b8b0be3 100644 --- a/src/test/regress/sql/alter_table.sql +++ b/src/test/regress/sql/alter_table.sql @@ -1786,6 +1786,24 @@ SELECT col_description('comment_test'::regclass, 1) as comment; SELECT indexrelid::regclass::text as index, obj_description(indexrelid, 'pg_class') as comment FROM pg_index where indrelid = 'comment_test'::regclass ORDER BY 1, 2; SELECT conname as constraint, obj_description(oid, 'pg_constraint') as comment FROM pg_constraint where conrelid = 'comment_test'::regclass ORDER BY 1, 2; +-- Check compatibility for foreign keys and comments. This is done +-- separately as rebuilding the column type of the parent leads +-- to an error and would reduce the test scope. +CREATE TABLE comment_test_child ( + id text CONSTRAINT comment_test_child_fk REFERENCES comment_test); +CREATE INDEX comment_test_child_fk ON comment_test_child(id); +COMMENT ON COLUMN comment_test_child.id IS 'Column ''id'' on comment_test_child'; +COMMENT ON INDEX comment_test_child_fk IS 'Index backing the FOREIGN KEY of comment_test_child'; +COMMENT ON CONSTRAINT comment_test_child_fk ON comment_test_child IS 'FOREIGN KEY constraint of comment_test_child'; + +-- Change column type of parent +ALTER TABLE comment_test ALTER COLUMN id SET DATA TYPE text; +ALTER TABLE comment_test ALTER COLUMN id SET DATA TYPE int USING id::integer; + +-- Comments should be intact +SELECT col_description('comment_test_child'::regclass, 1) as comment; +SELECT indexrelid::regclass::text as index, obj_description(indexrelid, 'pg_class') as comment FROM pg_index where indrelid = 'comment_test_child'::regclass ORDER BY 1, 2; +SELECT conname as constraint, obj_description(oid, 'pg_constraint') as comment FROM pg_constraint where conrelid = 'comment_test_child'::regclass ORDER BY 1, 2; -- Check that we map relation oids to filenodes and back correctly. Only -- display bad mappings so the test output doesn't change all the time. A From 21c2c3d75e888a578176616aa1411552f43b4908 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 15 May 2017 23:27:51 -0400 Subject: [PATCH 0070/1139] In SSL tests, don't scribble on permissions of a repo file. Modifying the permissions of a persistent file isn't really much nicer than modifying its contents, even if git doesn't currently notice it. Adjust the test script to make a copy and set the permissions of that instead. Michael Paquier, per a gripe from me. Back-patch to 9.5 where these tests were introduced. Discussion: https://postgr.es/m/14836.1494885946@sss.pgh.pa.us --- src/test/ssl/ssl/.gitignore | 5 +++-- src/test/ssl/t/001_ssltests.pl | 17 ++++++++++------- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/test/ssl/ssl/.gitignore b/src/test/ssl/ssl/.gitignore index 8feb8643ff..10b74f0848 100644 --- a/src/test/ssl/ssl/.gitignore +++ b/src/test/ssl/ssl/.gitignore @@ -1,2 +1,3 @@ -*.old -new_certs_dir +/*.old +/new_certs_dir/ +/client_tmp.key diff --git a/src/test/ssl/t/001_ssltests.pl b/src/test/ssl/t/001_ssltests.pl index dc8e064b25..598a5fe07a 100644 --- a/src/test/ssl/t/001_ssltests.pl +++ b/src/test/ssl/t/001_ssltests.pl @@ -66,10 +66,10 @@ sub test_connect_fails ok(!$result, "$connstr (should fail)"); } -# The client's private key must not be world-readable. Git doesn't track -# permissions (except for the executable bit), so they might be wrong after -# a checkout. -chmod 0600, "ssl/client.key"; +# The client's private key must not be world-readable, so take a copy +# of the key stored in the code tree and update its permissions. +copy("ssl/client.key", "ssl/client_tmp.key"); +chmod 0600, "ssl/client_tmp.key"; #### Part 0. Set up the server. @@ -229,11 +229,11 @@ sub test_connect_fails # correct client cert test_connect_ok( - "user=ssltestuser sslcert=ssl/client.crt sslkey=ssl/client.key"); + "user=ssltestuser sslcert=ssl/client.crt sslkey=ssl/client_tmp.key"); # client cert belonging to another user test_connect_fails( - "user=anotheruser sslcert=ssl/client.crt sslkey=ssl/client.key"); + "user=anotheruser sslcert=ssl/client.crt sslkey=ssl/client_tmp.key"); # revoked client cert test_connect_fails( @@ -243,7 +243,10 @@ sub test_connect_fails # intermediate client_ca.crt is provided by client, and isn't in server's ssl_ca_file switch_server_cert($node, 'server-cn-only', 'root_ca'); $common_connstr = -"user=ssltestuser dbname=certdb sslkey=ssl/client.key sslrootcert=ssl/root+server_ca.crt hostaddr=$SERVERHOSTADDR"; +"user=ssltestuser dbname=certdb sslkey=ssl/client_tmp.key sslrootcert=ssl/root+server_ca.crt hostaddr=$SERVERHOSTADDR"; test_connect_ok("sslmode=require sslcert=ssl/client+client_ca.crt"); test_connect_fails("sslmode=require sslcert=ssl/client.crt"); + +# clean up +unlink "ssl/client_tmp.key"; From 47b4913050a320bfba55fa65d52d9ba15488bc70 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Tue, 11 Apr 2017 14:13:31 -0400 Subject: [PATCH 0071/1139] Fix new warnings from GCC 7 This addresses the new warning types -Wformat-truncation -Wformat-overflow that are part of -Wall, via -Wformat, in GCC 7. --- contrib/pg_standby/pg_standby.c | 6 +++--- src/backend/access/heap/rewriteheap.c | 4 ++-- src/backend/access/transam/xlog.c | 6 +++--- src/backend/postmaster/pgstat.c | 4 ++-- src/backend/replication/basebackup.c | 4 ++-- src/backend/replication/logical/reorderbuffer.c | 2 +- src/backend/replication/logical/snapbuild.c | 4 ++-- src/backend/replication/slot.c | 6 +++--- src/backend/storage/file/copydir.c | 10 +++++----- src/backend/storage/file/fd.c | 12 ++++++------ src/backend/storage/file/reinit.c | 8 ++++---- src/backend/storage/ipc/dsm.c | 4 ++-- src/backend/utils/adt/dbsize.c | 14 +++++++------- src/backend/utils/cache/relcache.c | 4 ++-- src/backend/utils/error/elog.c | 2 +- src/backend/utils/time/snapmgr.c | 4 ++-- src/bin/initdb/initdb.c | 4 ++-- src/bin/pg_archivecleanup/pg_archivecleanup.c | 4 ++-- src/bin/pg_basebackup/pg_receivexlog.c | 2 +- src/bin/pg_resetxlog/pg_resetxlog.c | 12 ++++++------ src/bin/pg_rewind/copy_fetch.c | 10 +++++----- src/timezone/pgtz.c | 4 ++-- 22 files changed, 65 insertions(+), 65 deletions(-) diff --git a/contrib/pg_standby/pg_standby.c b/contrib/pg_standby/pg_standby.c index bfbb953428..481e728547 100644 --- a/contrib/pg_standby/pg_standby.c +++ b/contrib/pg_standby/pg_standby.c @@ -57,7 +57,7 @@ char *xlogFilePath; /* where we are going to restore to */ char *nextWALFileName; /* the file we need to get from archive */ char *restartWALFileName; /* the file from which we can restart restore */ char *priorWALFileName; /* the file we need to get from archive */ -char WALFilePath[MAXPGPATH]; /* the file path including archive */ +char WALFilePath[MAXPGPATH * 2]; /* the file path including archive */ char restoreCommand[MAXPGPATH]; /* run this to restore */ char exclusiveCleanupFileName[MAXFNAMELEN]; /* the file we need to * get from archive */ @@ -259,9 +259,9 @@ CustomizableCleanupPriorWALFiles(void) strcmp(xlde->d_name + 8, exclusiveCleanupFileName + 8) < 0) { #ifdef WIN32 - snprintf(WALFilePath, MAXPGPATH, "%s\\%s", archiveLocation, xlde->d_name); + snprintf(WALFilePath, sizeof(WALFilePath), "%s\\%s", archiveLocation, xlde->d_name); #else - snprintf(WALFilePath, MAXPGPATH, "%s/%s", archiveLocation, xlde->d_name); + snprintf(WALFilePath, sizeof(WALFilePath), "%s/%s", archiveLocation, xlde->d_name); #endif if (debug) diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c index 300b075af7..674b1bd2e6 100644 --- a/src/backend/access/heap/rewriteheap.c +++ b/src/backend/access/heap/rewriteheap.c @@ -1194,7 +1194,7 @@ CheckPointLogicalRewriteHeap(void) XLogRecPtr redo; DIR *mappings_dir; struct dirent *mapping_de; - char path[MAXPGPATH]; + char path[MAXPGPATH + 20]; /* * We start of with a minimum of the last redo pointer. No new decoding @@ -1225,7 +1225,7 @@ CheckPointLogicalRewriteHeap(void) strcmp(mapping_de->d_name, "..") == 0) continue; - snprintf(path, MAXPGPATH, "pg_logical/mappings/%s", mapping_de->d_name); + snprintf(path, sizeof(path), "pg_logical/mappings/%s", mapping_de->d_name); if (lstat(path, &statbuf) == 0 && !S_ISREG(statbuf.st_mode)) continue; diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index 184ea2d4b9..b5aa9158be 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -3941,7 +3941,7 @@ CleanupBackupHistory(void) { DIR *xldir; struct dirent *xlde; - char path[MAXPGPATH]; + char path[MAXPGPATH + sizeof(XLOGDIR)]; xldir = AllocateDir(XLOGDIR); if (xldir == NULL) @@ -3959,7 +3959,7 @@ CleanupBackupHistory(void) ereport(DEBUG2, (errmsg("removing transaction log backup history file \"%s\"", xlde->d_name))); - snprintf(path, MAXPGPATH, XLOGDIR "/%s", xlde->d_name); + snprintf(path, sizeof(path), XLOGDIR "/%s", xlde->d_name); unlink(path); XLogArchiveCleanup(xlde->d_name); } @@ -10061,7 +10061,7 @@ do_pg_start_backup(const char *backupidstr, bool fast, TimeLineID *starttli_p, /* Collect information about all tablespaces */ while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL) { - char fullpath[MAXPGPATH]; + char fullpath[MAXPGPATH + 10]; char linkpath[MAXPGPATH]; char *relpath = NULL; int rllen; diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c index 2818e6f421..620ccdeb38 100644 --- a/src/backend/postmaster/pgstat.c +++ b/src/backend/postmaster/pgstat.c @@ -569,7 +569,7 @@ pgstat_reset_remove_files(const char *directory) { DIR *dir; struct dirent *entry; - char fname[MAXPGPATH]; + char fname[MAXPGPATH * 2]; dir = AllocateDir(directory); while ((entry = ReadDir(dir, directory)) != NULL) @@ -599,7 +599,7 @@ pgstat_reset_remove_files(const char *directory) strcmp(entry->d_name + nchars, "stat") != 0) continue; - snprintf(fname, MAXPGPATH, "%s/%s", directory, + snprintf(fname, sizeof(fname), "%s/%s", directory, entry->d_name); unlink(fname); } diff --git a/src/backend/replication/basebackup.c b/src/backend/replication/basebackup.c index 08d6733259..87a753787f 100644 --- a/src/backend/replication/basebackup.c +++ b/src/backend/replication/basebackup.c @@ -888,7 +888,7 @@ sendDir(char *path, int basepathlen, bool sizeonly, List *tablespaces, { DIR *dir; struct dirent *de; - char pathbuf[MAXPGPATH]; + char pathbuf[MAXPGPATH * 2]; struct stat statbuf; int64 size = 0; @@ -940,7 +940,7 @@ sendDir(char *path, int basepathlen, bool sizeonly, List *tablespaces, "and should not be used. " "Try taking another online backup."))); - snprintf(pathbuf, MAXPGPATH, "%s/%s", path, de->d_name); + snprintf(pathbuf, sizeof(pathbuf), "%s/%s", path, de->d_name); /* Skip postmaster.pid and postmaster.opts in the data directory */ if (strcmp(pathbuf, "./postmaster.pid") == 0 || diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index 10798aee44..72c70585bc 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -2650,7 +2650,7 @@ StartupReorderBuffer(void) while ((logical_de = ReadDir(logical_dir, "pg_replslot")) != NULL) { struct stat statbuf; - char path[MAXPGPATH]; + char path[MAXPGPATH * 2 + 12]; if (strcmp(logical_de->d_name, ".") == 0 || strcmp(logical_de->d_name, "..") == 0) diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c index 536f7620ce..43ec8e4943 100644 --- a/src/backend/replication/logical/snapbuild.c +++ b/src/backend/replication/logical/snapbuild.c @@ -1831,7 +1831,7 @@ CheckPointSnapBuild(void) XLogRecPtr redo; DIR *snap_dir; struct dirent *snap_de; - char path[MAXPGPATH]; + char path[MAXPGPATH + 21]; /* * We start of with a minimum of the last redo pointer. No new replication @@ -1858,7 +1858,7 @@ CheckPointSnapBuild(void) strcmp(snap_de->d_name, "..") == 0) continue; - snprintf(path, MAXPGPATH, "pg_logical/snapshots/%s", snap_de->d_name); + snprintf(path, sizeof(path), "pg_logical/snapshots/%s", snap_de->d_name); if (lstat(path, &statbuf) == 0 && !S_ISREG(statbuf.st_mode)) { diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index d64cfc6dc9..ca0b8c65c6 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -918,13 +918,13 @@ StartupReplicationSlots(void) while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL) { struct stat statbuf; - char path[MAXPGPATH]; + char path[MAXPGPATH + 12]; if (strcmp(replication_de->d_name, ".") == 0 || strcmp(replication_de->d_name, "..") == 0) continue; - snprintf(path, MAXPGPATH, "pg_replslot/%s", replication_de->d_name); + snprintf(path, sizeof(path), "pg_replslot/%s", replication_de->d_name); /* we're only creating directories here, skip if it's not our's */ if (lstat(path, &statbuf) == 0 && !S_ISDIR(statbuf.st_mode)) @@ -1148,7 +1148,7 @@ RestoreSlotFromDisk(const char *name) { ReplicationSlotOnDisk cp; int i; - char path[MAXPGPATH]; + char path[MAXPGPATH + 22]; int fd; bool restored = false; int readBytes; diff --git a/src/backend/storage/file/copydir.c b/src/backend/storage/file/copydir.c index a51ee81566..a964e47f50 100644 --- a/src/backend/storage/file/copydir.c +++ b/src/backend/storage/file/copydir.c @@ -38,8 +38,8 @@ copydir(char *fromdir, char *todir, bool recurse) { DIR *xldir; struct dirent *xlde; - char fromfile[MAXPGPATH]; - char tofile[MAXPGPATH]; + char fromfile[MAXPGPATH * 2]; + char tofile[MAXPGPATH * 2]; if (mkdir(todir, S_IRWXU) != 0) ereport(ERROR, @@ -63,8 +63,8 @@ copydir(char *fromdir, char *todir, bool recurse) strcmp(xlde->d_name, "..") == 0) continue; - snprintf(fromfile, MAXPGPATH, "%s/%s", fromdir, xlde->d_name); - snprintf(tofile, MAXPGPATH, "%s/%s", todir, xlde->d_name); + snprintf(fromfile, sizeof(fromfile), "%s/%s", fromdir, xlde->d_name); + snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name); if (lstat(fromfile, &fst) < 0) ereport(ERROR, @@ -103,7 +103,7 @@ copydir(char *fromdir, char *todir, bool recurse) strcmp(xlde->d_name, "..") == 0) continue; - snprintf(tofile, MAXPGPATH, "%s/%s", todir, xlde->d_name); + snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name); /* * We don't need to sync subdirectories here since the recursive diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c index 170e773c4a..b07628fd7b 100644 --- a/src/backend/storage/file/fd.c +++ b/src/backend/storage/file/fd.c @@ -2654,7 +2654,7 @@ CleanupTempFiles(bool isProcExit) void RemovePgTempFiles(void) { - char temp_path[MAXPGPATH]; + char temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)]; DIR *spc_dir; struct dirent *spc_de; @@ -2702,7 +2702,7 @@ RemovePgTempFilesInDir(const char *tmpdirname) { DIR *temp_dir; struct dirent *temp_de; - char rm_path[MAXPGPATH]; + char rm_path[MAXPGPATH * 2]; temp_dir = AllocateDir(tmpdirname); if (temp_dir == NULL) @@ -2743,7 +2743,7 @@ RemovePgTempRelationFiles(const char *tsdirname) { DIR *ts_dir; struct dirent *de; - char dbspace_path[MAXPGPATH]; + char dbspace_path[MAXPGPATH * 2]; ts_dir = AllocateDir(tsdirname); if (ts_dir == NULL) @@ -2784,7 +2784,7 @@ RemovePgTempRelationFilesInDbspace(const char *dbspacedirname) { DIR *dbspace_dir; struct dirent *de; - char rm_path[MAXPGPATH]; + char rm_path[MAXPGPATH * 2]; dbspace_dir = AllocateDir(dbspacedirname); if (dbspace_dir == NULL) @@ -2971,7 +2971,7 @@ walkdir(const char *path, while ((de = ReadDirExtended(dir, path, elevel)) != NULL) { - char subpath[MAXPGPATH]; + char subpath[MAXPGPATH * 2]; struct stat fst; int sret; @@ -2981,7 +2981,7 @@ walkdir(const char *path, strcmp(de->d_name, "..") == 0) continue; - snprintf(subpath, MAXPGPATH, "%s/%s", path, de->d_name); + snprintf(subpath, sizeof(subpath), "%s/%s", path, de->d_name); if (process_symlinks) sret = stat(subpath, &fst); diff --git a/src/backend/storage/file/reinit.c b/src/backend/storage/file/reinit.c index 6b98131e54..934cac2deb 100644 --- a/src/backend/storage/file/reinit.c +++ b/src/backend/storage/file/reinit.c @@ -48,7 +48,7 @@ typedef struct void ResetUnloggedRelations(int op) { - char temp_path[MAXPGPATH]; + char temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)]; DIR *spc_dir; struct dirent *spc_de; MemoryContext tmpctx, @@ -104,7 +104,7 @@ ResetUnloggedRelationsInTablespaceDir(const char *tsdirname, int op) { DIR *ts_dir; struct dirent *de; - char dbspace_path[MAXPGPATH]; + char dbspace_path[MAXPGPATH * 2]; ts_dir = AllocateDir(tsdirname); if (ts_dir == NULL) @@ -145,7 +145,7 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) { DIR *dbspace_dir; struct dirent *de; - char rm_path[MAXPGPATH]; + char rm_path[MAXPGPATH * 2]; /* Caller must specify at least one operation. */ Assert((op & (UNLOGGED_RELATION_CLEANUP | UNLOGGED_RELATION_INIT)) != 0); @@ -308,7 +308,7 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) ForkNumber forkNum; int oidchars; char oidbuf[OIDCHARS + 1]; - char srcpath[MAXPGPATH]; + char srcpath[MAXPGPATH * 2]; char dstpath[MAXPGPATH]; /* Skip anything that doesn't look like a relation data file. */ diff --git a/src/backend/storage/ipc/dsm.c b/src/backend/storage/ipc/dsm.c index 47f2bea0be..8affe6711d 100644 --- a/src/backend/storage/ipc/dsm.c +++ b/src/backend/storage/ipc/dsm.c @@ -306,9 +306,9 @@ dsm_cleanup_for_mmap(void) if (strncmp(dent->d_name, PG_DYNSHMEM_MMAP_FILE_PREFIX, strlen(PG_DYNSHMEM_MMAP_FILE_PREFIX)) == 0) { - char buf[MAXPGPATH]; + char buf[MAXPGPATH + sizeof(PG_DYNSHMEM_DIR)]; - snprintf(buf, MAXPGPATH, PG_DYNSHMEM_DIR "/%s", dent->d_name); + snprintf(buf, sizeof(buf), PG_DYNSHMEM_DIR "/%s", dent->d_name); elog(DEBUG2, "removing file \"%s\"", buf); diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c index 3167bad92b..74cdbb0551 100644 --- a/src/backend/utils/adt/dbsize.c +++ b/src/backend/utils/adt/dbsize.c @@ -41,7 +41,7 @@ db_dir_size(const char *path) int64 dirsize = 0; struct dirent *direntry; DIR *dirdesc; - char filename[MAXPGPATH]; + char filename[MAXPGPATH * 2]; dirdesc = AllocateDir(path); @@ -58,7 +58,7 @@ db_dir_size(const char *path) strcmp(direntry->d_name, "..") == 0) continue; - snprintf(filename, MAXPGPATH, "%s/%s", path, direntry->d_name); + snprintf(filename, sizeof(filename), "%s/%s", path, direntry->d_name); if (stat(filename, &fst) < 0) { @@ -86,7 +86,7 @@ calculate_database_size(Oid dbOid) DIR *dirdesc; struct dirent *direntry; char dirpath[MAXPGPATH]; - char pathname[MAXPGPATH]; + char pathname[MAXPGPATH + 12 + sizeof(TABLESPACE_VERSION_DIRECTORY)]; AclResult aclresult; /* User must have connect privilege for target database */ @@ -98,7 +98,7 @@ calculate_database_size(Oid dbOid) /* Shared storage in pg_global is not counted */ /* Include pg_default storage */ - snprintf(pathname, MAXPGPATH, "base/%u", dbOid); + snprintf(pathname, sizeof(pathname), "base/%u", dbOid); totalsize = db_dir_size(pathname); /* Scan the non-default tablespaces */ @@ -118,7 +118,7 @@ calculate_database_size(Oid dbOid) strcmp(direntry->d_name, "..") == 0) continue; - snprintf(pathname, MAXPGPATH, "pg_tblspc/%s/%s/%u", + snprintf(pathname, sizeof(pathname), "pg_tblspc/%s/%s/%u", direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid); totalsize += db_dir_size(pathname); } @@ -166,7 +166,7 @@ static int64 calculate_tablespace_size(Oid tblspcOid) { char tblspcPath[MAXPGPATH]; - char pathname[MAXPGPATH]; + char pathname[MAXPGPATH * 2]; int64 totalsize = 0; DIR *dirdesc; struct dirent *direntry; @@ -208,7 +208,7 @@ calculate_tablespace_size(Oid tblspcOid) strcmp(direntry->d_name, "..") == 0) continue; - snprintf(pathname, MAXPGPATH, "%s/%s", tblspcPath, direntry->d_name); + snprintf(pathname, sizeof(pathname), "%s/%s", tblspcPath, direntry->d_name); if (stat(pathname, &fst) < 0) { diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8c8ef66c8f..95ff838cea 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -5525,7 +5525,7 @@ RelationCacheInitFileRemove(void) const char *tblspcdir = "pg_tblspc"; DIR *dir; struct dirent *de; - char path[MAXPGPATH]; + char path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)]; /* * We zap the shared cache file too. In theory it can't get out of sync @@ -5567,7 +5567,7 @@ RelationCacheInitFileRemoveInDir(const char *tblspcpath) { DIR *dir; struct dirent *de; - char initfilename[MAXPGPATH]; + char initfilename[MAXPGPATH * 2]; /* Scan the tablespace directory to find per-database directories */ dir = AllocateDir(tblspcpath); diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c index 69649290da..eace0ac100 100644 --- a/src/backend/utils/error/elog.c +++ b/src/backend/utils/error/elog.c @@ -2228,7 +2228,7 @@ static void setup_formatted_log_time(void) { pg_time_t stamp_time; - char msbuf[8]; + char msbuf[13]; if (!saved_timeval_set) { diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c index 2b7fda7c63..de6441b270 100644 --- a/src/backend/utils/time/snapmgr.c +++ b/src/backend/utils/time/snapmgr.c @@ -1569,7 +1569,7 @@ XactHasExportedSnapshots(void) void DeleteAllExportedSnapshotFiles(void) { - char buf[MAXPGPATH]; + char buf[MAXPGPATH + sizeof(SNAPSHOT_EXPORT_DIR)]; DIR *s_dir; struct dirent *s_de; @@ -1590,7 +1590,7 @@ DeleteAllExportedSnapshotFiles(void) strcmp(s_de->d_name, "..") == 0) continue; - snprintf(buf, MAXPGPATH, SNAPSHOT_EXPORT_DIR "/%s", s_de->d_name); + snprintf(buf, sizeof(buf), SNAPSHOT_EXPORT_DIR "/%s", s_de->d_name); /* Again, unlink failure is not worthy of FATAL */ if (unlink(buf)) elog(LOG, "could not unlink file \"%s\": %m", buf); diff --git a/src/bin/initdb/initdb.c b/src/bin/initdb/initdb.c index 27d134e17d..d758a5d596 100644 --- a/src/bin/initdb/initdb.c +++ b/src/bin/initdb/initdb.c @@ -567,7 +567,7 @@ walkdir(const char *path, while (errno = 0, (de = readdir(dir)) != NULL) { - char subpath[MAXPGPATH]; + char subpath[MAXPGPATH * 2]; struct stat fst; int sret; @@ -575,7 +575,7 @@ walkdir(const char *path, strcmp(de->d_name, "..") == 0) continue; - snprintf(subpath, MAXPGPATH, "%s/%s", path, de->d_name); + snprintf(subpath, sizeof(subpath), "%s/%s", path, de->d_name); if (process_symlinks) sret = stat(subpath, &fst); diff --git a/src/bin/pg_archivecleanup/pg_archivecleanup.c b/src/bin/pg_archivecleanup/pg_archivecleanup.c index 2b3d15dd58..c5ce4ecd3c 100644 --- a/src/bin/pg_archivecleanup/pg_archivecleanup.c +++ b/src/bin/pg_archivecleanup/pg_archivecleanup.c @@ -32,7 +32,7 @@ char *additional_ext = NULL; /* Extension to remove from filenames */ char *archiveLocation; /* where to find the archive? */ char *restartWALFileName; /* the file from which we can restart restore */ -char WALFilePath[MAXPGPATH]; /* the file path including archive */ +char WALFilePath[MAXPGPATH * 2]; /* the file path including archive */ char exclusiveCleanupFileName[MAXFNAMELEN]; /* the oldest file we * want to remain in * archive */ @@ -133,7 +133,7 @@ CleanupPriorWALFiles(void) * extension that might have been chopped off before testing * the sequence. */ - snprintf(WALFilePath, MAXPGPATH, "%s/%s", + snprintf(WALFilePath, sizeof(WALFilePath), "%s/%s", archiveLocation, xlde->d_name); if (dryrun) diff --git a/src/bin/pg_basebackup/pg_receivexlog.c b/src/bin/pg_basebackup/pg_receivexlog.c index 7f7ee9dc9b..11f2b794ff 100644 --- a/src/bin/pg_basebackup/pg_receivexlog.c +++ b/src/bin/pg_basebackup/pg_receivexlog.c @@ -210,7 +210,7 @@ FindStreamingStart(uint32 *tli) if (!ispartial) { struct stat statbuf; - char fullpath[MAXPGPATH]; + char fullpath[MAXPGPATH * 2]; snprintf(fullpath, sizeof(fullpath), "%s/%s", basedir, dirent->d_name); if (stat(fullpath, &statbuf) != 0) diff --git a/src/bin/pg_resetxlog/pg_resetxlog.c b/src/bin/pg_resetxlog/pg_resetxlog.c index 013c26bd6d..3ffff22daa 100644 --- a/src/bin/pg_resetxlog/pg_resetxlog.c +++ b/src/bin/pg_resetxlog/pg_resetxlog.c @@ -963,7 +963,7 @@ KillExistingXLOG(void) { DIR *xldir; struct dirent *xlde; - char path[MAXPGPATH]; + char path[MAXPGPATH + sizeof(XLOGDIR)]; xldir = opendir(XLOGDIR); if (xldir == NULL) @@ -978,7 +978,7 @@ KillExistingXLOG(void) if (IsXLogFileName(xlde->d_name) || IsPartialXLogFileName(xlde->d_name)) { - snprintf(path, MAXPGPATH, "%s/%s", XLOGDIR, xlde->d_name); + snprintf(path, sizeof(path), "%s/%s", XLOGDIR, xlde->d_name); if (unlink(path) < 0) { fprintf(stderr, _("%s: could not delete file \"%s\": %s\n"), @@ -1010,11 +1010,11 @@ KillExistingXLOG(void) static void KillExistingArchiveStatus(void) { +#define ARCHSTATDIR XLOGDIR "/archive_status" + DIR *xldir; struct dirent *xlde; - char path[MAXPGPATH]; - -#define ARCHSTATDIR XLOGDIR "/archive_status" + char path[MAXPGPATH + sizeof(ARCHSTATDIR)]; xldir = opendir(ARCHSTATDIR); if (xldir == NULL) @@ -1032,7 +1032,7 @@ KillExistingArchiveStatus(void) strcmp(xlde->d_name + XLOG_FNAME_LEN, ".partial.ready") == 0 || strcmp(xlde->d_name + XLOG_FNAME_LEN, ".partial.done") == 0)) { - snprintf(path, MAXPGPATH, "%s/%s", ARCHSTATDIR, xlde->d_name); + snprintf(path, sizeof(path), "%s/%s", ARCHSTATDIR, xlde->d_name); if (unlink(path) < 0) { fprintf(stderr, _("%s: could not delete file \"%s\": %s\n"), diff --git a/src/bin/pg_rewind/copy_fetch.c b/src/bin/pg_rewind/copy_fetch.c index 327e7ef541..d7ce8ef2fc 100644 --- a/src/bin/pg_rewind/copy_fetch.c +++ b/src/bin/pg_rewind/copy_fetch.c @@ -67,14 +67,14 @@ recurse_dir(const char *datadir, const char *parentpath, while (errno = 0, (xlde = readdir(xldir)) != NULL) { struct stat fst; - char fullpath[MAXPGPATH]; - char path[MAXPGPATH]; + char fullpath[MAXPGPATH * 2]; + char path[MAXPGPATH * 2]; if (strcmp(xlde->d_name, ".") == 0 || strcmp(xlde->d_name, "..") == 0) continue; - snprintf(fullpath, MAXPGPATH, "%s/%s", fullparentpath, xlde->d_name); + snprintf(fullpath, sizeof(fullpath), "%s/%s", fullparentpath, xlde->d_name); if (lstat(fullpath, &fst) < 0) { @@ -95,9 +95,9 @@ recurse_dir(const char *datadir, const char *parentpath, } if (parentpath) - snprintf(path, MAXPGPATH, "%s/%s", parentpath, xlde->d_name); + snprintf(path, sizeof(path), "%s/%s", parentpath, xlde->d_name); else - snprintf(path, MAXPGPATH, "%s", xlde->d_name); + snprintf(path, sizeof(path), "%s", xlde->d_name); if (S_ISREG(fst.st_mode)) callback(path, FILE_TYPE_REGULAR, fst.st_size, NULL); diff --git a/src/timezone/pgtz.c b/src/timezone/pgtz.c index b2a4a2d356..fbfadfa6f8 100644 --- a/src/timezone/pgtz.c +++ b/src/timezone/pgtz.c @@ -437,7 +437,7 @@ pg_tzenumerate_next(pg_tzenum *dir) while (dir->depth >= 0) { struct dirent *direntry; - char fullname[MAXPGPATH]; + char fullname[MAXPGPATH * 2]; struct stat statbuf; direntry = ReadDir(dir->dirdesc[dir->depth], dir->dirname[dir->depth]); @@ -454,7 +454,7 @@ pg_tzenumerate_next(pg_tzenum *dir) if (direntry->d_name[0] == '.') continue; - snprintf(fullname, MAXPGPATH, "%s/%s", + snprintf(fullname, sizeof(fullname), "%s/%s", dir->dirname[dir->depth], direntry->d_name); if (stat(fullname, &statbuf) != 0) ereport(ERROR, From bee9e8698404da6cc6a1e6dd08c1b22e6ca1ca13 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 17 May 2017 12:24:19 -0400 Subject: [PATCH 0072/1139] Make psql handle EOF during COPY FROM STDIN properly on all platforms. When stdin is a terminal, it's possible to end a COPY FROM STDIN with a keyboard EOF signal (typically control-D), and then keep on issuing SQL commands. One would expect another COPY FROM STDIN to work as well, but on some platforms it did not. This turns out to be because we were not resetting the stream's feof() flag, and BSD-ish versions of fread() and fgets() won't attempt to read more data if that's set. The misbehavior is observed on BSDen (including macOS), but not Linux, Windows, or SysV-ish Unixen, which makes this a portability bug not just a missing feature. Add a clearerr() call to fix the behavior, and improve the prompt that's issued when copying from a TTY to mention that EOF signals work. It's been like this forever, so back-patch to all supported branches. Thomas Munro Discussion: https://postgr.es/m/CAEepm=0MCGfYf=JAMiYhO6JPtv9-3ZfBo8fcGeCZ8oMzaw+Z+Q@mail.gmail.com --- src/bin/psql/copy.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/bin/psql/copy.c b/src/bin/psql/copy.c index 942264fbf9..827f4df3b2 100644 --- a/src/bin/psql/copy.c +++ b/src/bin/psql/copy.c @@ -540,7 +540,7 @@ handleCopyIn(PGconn *conn, FILE *copystream, bool isbinary, PGresult **res) showprompt = true; if (!pset.quiet) puts(_("Enter data to be copied followed by a newline.\n" - "End with a backslash and a period on a line by itself.")); + "End with a backslash and a period on a line by itself, or an EOF signal.")); } else showprompt = false; @@ -673,6 +673,16 @@ handleCopyIn(PGconn *conn, FILE *copystream, bool isbinary, PGresult **res) copyin_cleanup: + /* + * Clear the EOF flag on the stream, in case copying ended due to an EOF + * signal. This allows an interactive TTY session to perform another COPY + * FROM STDIN later. (In non-STDIN cases, we're about to close the file + * anyway, so it doesn't matter.) Although we don't ever test the flag + * with feof(), some fread() implementations won't read more data if it's + * set. This also clears the error flag, but we already checked that. + */ + clearerr(copystream); + /* * Check command status and return to normal libpq state. * From dbf71771befac89cd38df3cd03c15172836a0e13 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Thu, 18 May 2017 10:33:16 +0300 Subject: [PATCH 0073/1139] Fix typo in comment. Daniel Gustafsson --- src/backend/utils/adt/json.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/utils/adt/json.c b/src/backend/utils/adt/json.c index f704418603..c73044b806 100644 --- a/src/backend/utils/adt/json.c +++ b/src/backend/utils/adt/json.c @@ -323,7 +323,7 @@ makeJsonLexContextCstringLen(char *json, int len, bool need_escapes) * Publicly visible entry point for the JSON parser. * * lex is a lexing context, set up for the json to be processed by calling - * makeJsonLexContext(). sem is a strucure of function pointers to semantic + * makeJsonLexContext(). sem is a structure of function pointers to semantic * action routines to be called at appropriate spots during parsing, and a * pointer to a state object to be passed to those routines. */ From 7c7095c2d754d34461f123963a2f0c1d16f64f37 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 19 May 2017 17:15:49 +0300 Subject: [PATCH 0074/1139] Update autoprepare algorithm --- contrib/postgres_fdw/tests/dtmbench.cpp | 2 +- src/backend/tcop/postgres.c | 877 +++++++++++++----------- src/backend/utils/misc/guc.c | 2 +- 3 files changed, 463 insertions(+), 418 deletions(-) diff --git a/contrib/postgres_fdw/tests/dtmbench.cpp b/contrib/postgres_fdw/tests/dtmbench.cpp index 05421db584..1919e9a307 100644 --- a/contrib/postgres_fdw/tests/dtmbench.cpp +++ b/contrib/postgres_fdw/tests/dtmbench.cpp @@ -138,7 +138,7 @@ void* writer(void* arg) { work txn(conn); int srcAcc = random() % cfg.nAccounts; - int dstAcc = (cfg.local ? srcAcc + 1 : random()) % cfg.nAccounts; + int dstAcc = (cfg.local ? srcAcc /*+ 1*/ : random()) % cfg.nAccounts; try { if (random() % 100 < cfg.updatePercent) { diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 94cbbf8a64..7ff3715432 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -76,6 +76,7 @@ #include "utils/snapmgr.h" #include "utils/timeout.h" #include "utils/timestamp.h" +#include "utils/int8.h" #include "mb/pg_wchar.h" @@ -191,7 +192,10 @@ static bool IsTransactionStmtList(List *parseTrees); static void drop_unnamed_stmt(void); static void SigHupHandler(SIGNAL_ARGS); static void log_disconnections(int code, Datum arg); -static bool exec_cached_query(const char* query, Node* parse_tree); +static bool exec_cached_query(const char* query, List *parsetree_list); +static void exec_prepared_plan(Portal portal, const char *portal_name, long max_rows, CommandDest dest); +static void begin_exec_simple(void); +static void end_exec_simple(void); /* ---------------------------------------------------------------- @@ -954,10 +958,15 @@ exec_simple_query(const char *query_string) */ isTopLevel = (list_length(parsetree_list) == 1); + /* + * Inform autoprepare about start of simple query execution to record elapsed time + */ + begin_exec_simple(); + /* * Try to find cached plan */ - if (isTopLevel && autoprepare_threshold != 0 && exec_cached_query(query_string, linitial(parsetree_list))) + if (isTopLevel && autoprepare_threshold != 0 && exec_cached_query(query_string, parsetree_list)) { return; } @@ -1165,6 +1174,11 @@ exec_simple_query(const char *query_string) if (!parsetree_list) NullCommand(dest); + /* + * Inform autoprepare about end of completion of simple query execution to record elapsed time + */ + end_exec_simple(); + /* * Emit duration logging if appropriate. */ @@ -1844,9 +1858,28 @@ exec_bind_message(StringInfo input_message) static void exec_execute_message(const char *portal_name, long max_rows) { - CommandDest dest; + Portal portal = GetPortalByName(portal_name); + CommandDest dest = whereToSendOutput; + + /* Adjust destination to tell printtup.c what to do */ + if (dest == DestRemote) + dest = DestRemoteExecute; + + if (!PortalIsValid(portal)) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_CURSOR), + errmsg("portal \"%s\" does not exist", portal_name))); + + exec_prepared_plan(portal, portal_name, max_rows, dest); +} + +/* + * Execute prepared plan. + */ +static void +exec_prepared_plan(Portal portal, const char *portal_name, long max_rows, CommandDest dest) +{ DestReceiver *receiver; - Portal portal; bool completed; char completionTag[COMPLETION_TAG_BUFSIZE]; const char *sourceText; @@ -1858,17 +1891,6 @@ exec_execute_message(const char *portal_name, long max_rows) bool was_logged = false; char msec_str[32]; - /* Adjust destination to tell printtup.c what to do */ - dest = whereToSendOutput; - if (dest == DestRemote) - dest = DestRemoteExecute; - - portal = GetPortalByName(portal_name); - if (!PortalIsValid(portal)) - ereport(ERROR, - (errcode(ERRCODE_UNDEFINED_CURSOR), - errmsg("portal \"%s\" does not exist", portal_name))); - /* * If the original query was a null string, just return * EmptyQueryResponse. @@ -1931,7 +1953,7 @@ exec_execute_message(const char *portal_name, long max_rows) * context, because that may get deleted if portal contains VACUUM). */ receiver = CreateDestReceiver(dest); - if (dest == DestRemoteExecute) + if (dest == DestRemoteExecute || dest == DestRemote) SetRemoteDestReceiverParams(receiver, portal); /* @@ -4513,23 +4535,43 @@ log_disconnections(int code, Datum arg) port->remote_port[0] ? " port=" : "", port->remote_port))); } + /* * Autoprepare implementation. - * It combines exec_parse_message + exec_bind_message + exec_execute_message + * Autoprepare consists of raw parse tree mutator, hash table of cached plans and exec_cached_query function + * which combines exec_parse_message + exec_bind_message + exec_execute_message + */ + +/* + * Mapping between parameters and replaced literals */ +typedef struct ParamBinding +{ + A_Const* literal; /* Original literal */ + ParamRef* paramref;/* Constructed parameter reference */ + Param* param; /* Constructed parameter */ + Node** ref; /* Pointer to pointer to literal node (used to revert raw parse tree update) */ + Oid raw_type;/* Parameter raw type */ + Oid type; /* Parameter type after analysis */ + struct ParamBinding* next; /* L1-list of query parameter bindings */ +} ParamBinding; /* * Plan cache entry */ -typedef struct { - Node* parse_tree; /* tree is used as hash key */ - dlist_node lru; /* double linked list to implement LRU */ - int64 exec_count; /* counter of execution of this query */ +typedef struct +{ + Node* parse_tree; /* tree is used as hash key */ + dlist_node lru; /* double linked list to implement LRU */ + int64 exec_count; /* counter of execution of this query */ CachedPlanSource* plan; - uint32 hash; /* hash calculated for this parsed tree */ - int n_params; /* number of parameters extracted for this query */ - int16 format; /* portal output format */ - bool disable_autoprepare; /* disable preparing of this query */ + uint32 hash; /* hash calculated for this parsed tree */ + Oid* param_types;/* types of parameters */ + int n_params; /* number of parameters extracted for this query */ + int16 format; /* portal output format */ + bool disable_autoprepare; /* disable preparing of this query */ + uint64 non_prepared_time; /* averge time of original (non-prepared) query execution (sum of autoprepare_threshold query execution times) */ + uint64 prepared_time; /* averge time of prepared query execution (sum of autoprepare_threshold query execution times) */ } plan_cache_entry; static uint32 plan_cache_hash_fn(const void *key, Size keysize) @@ -4539,7 +4581,11 @@ static uint32 plan_cache_hash_fn(const void *key, Size keysize) static int plan_cache_match_fn(const void *key1, const void *key2, Size keysize) { - return !equal(((plan_cache_entry*)key1)->parse_tree, ((plan_cache_entry*)key2)->parse_tree); + plan_cache_entry* e1 = (plan_cache_entry*)key1; + plan_cache_entry* e2 = (plan_cache_entry*)key2; + + return equal(e1->parse_tree, e2->parse_tree) + && memcmp(e1->param_types, e2->param_types, sizeof(Oid)*e1->n_params) == 0 ? 0 : 1; } static void* plan_cache_keycopy_fn(void *dest, const void *src, Size keysize) @@ -4547,8 +4593,11 @@ static void* plan_cache_keycopy_fn(void *dest, const void *src, Size keysize) plan_cache_entry* dst_entry = (plan_cache_entry*)dest; plan_cache_entry* src_entry = (plan_cache_entry*)src; dst_entry->parse_tree = copyObject(src_entry->parse_tree); + dst_entry->param_types = palloc(src_entry->n_params*sizeof(Oid)); + dst_entry->n_params = src_entry->n_params; + memcpy(dst_entry->param_types, src_entry->param_types, src_entry->n_params*sizeof(Oid)); dst_entry->hash = src_entry->hash; - return dest; + return dest; } #define PLAN_CACHE_SIZE 113 @@ -4556,29 +4605,62 @@ static void* plan_cache_keycopy_fn(void *dest, const void *src, Size keysize) /* * Plan cache access statistic */ -size_t n_plan_cache_hits; -size_t n_plan_cache_misses; -size_t n_cached_queries; +size_t autoprepare_hits; +size_t autoprepare_misses; +size_t autoprepare_cached_plans; /* - * Mapping between parameters and replaced literals + * Currently executed plan entry */ -typedef struct ConstParam { - A_Const* literal; /* Original literal */ - ParamRef* param; /* Constructed parameter reference */ - Node** ref; /* Pointer to pointer to literal node (used to revert parse tree update) */ - struct ConstParam* next; /* L1-list of query parameters */ -} ConstParam; +static plan_cache_entry* current_plan_entry; +static TimestampTz exec_start_timestamp; /* * Context for raw_expression_tree_mutator */ typedef struct { - int n_params; /* Number of extracted parameters */ - uint32 hash; /* We calculate hash for parse tree during plan traversal */ - ConstParam** param_list_tail; /* pointer to last element "next" field address, used to contruct L1 list of parameters */ + int n_params; /* Number of extracted parameters */ + uint32 hash; /* We calculate hash for parse tree during plan traversal */ + ParamBinding** param_list_tail; /* pointer to last element "next" field address, used to construct L1 list of parameters */ } GeneralizerCtx; + +static HTAB* plan_cache_hash; /* hash table for plan cache */ +static dlist_head plan_cache_lru; /* LRU L2-list for cached queries */ +static MemoryContext plan_cache_context; /* memory context used for plan cache */ + +/* + * Callback called on start of exec_simple_query. + * Clear current_plan_entry which can be set + * exec_cached_query to the current plan entry if this query is executed + * less or equal than autoprepare_threshold times. + */ +static void begin_exec_simple(void) +{ + current_plan_entry = NULL; +} + +/* + * Callback called on end of exec_simple_query. + * Collect time of simple (non-prepared) query execution to compare it with + * time of prepared query execution. + */ +static void end_exec_simple(void) +{ + plan_cache_entry* entry = current_plan_entry; + if (entry != NULL && entry->exec_count <= autoprepare_threshold) + { + long secs; + int usecs; + TimestampDifference(exec_start_timestamp, + GetCurrentTimestamp(), + &secs, &usecs); + + entry->non_prepared_time += secs * USECS_PER_SEC + usecs; + } +} + + /* * Check if expression is constant (used to eliminate substitution of literals with parameters in such expressions */ @@ -4592,10 +4674,68 @@ static bool is_constant_expression(Node* node) } /* - * Callback for raw_expression_tree_mutator performing susbtitution of literals with paramaters + * Infer type of literal expression. Null literals should not be replaced with parameters. + */ +static Oid get_literal_type(Value* val) +{ + int64 val64; + switch (val->type) + { + case T_Integer: + return INT4OID; + case T_Float: + /* could be an oversize integer as well as a float ... */ + if (scanint8(strVal(val), true, &val64)) + { + /* + * It might actually fit in int32. Probably only INT_MIN can + * occur, but we'll code the test generally just to be sure. + */ + int32 val32 = (int32) val64; + return (val64 == (int64)val32) ? INT4OID : INT8OID; + } + else + { + return NUMERICOID; + } + case T_BitString: + return BITOID; + case T_String: + return UNKNOWNOID; + default: + Assert(false); + return InvalidOid; + } +} + +static Datum get_param_value(Oid type, Value* val) +{ + if (val->type == T_Integer && type == INT4OID) + { + /* + * Integer constant + */ + return Int32GetDatum((int32)val->val.ival); + } + else + { + /* + * Convert from string literal + */ + Oid typinput; + Oid typioparam; + + getTypeInputInfo(type, &typinput, &typioparam); + return OidInputFunctionCall(typinput, val->val.str, typioparam, -1); + } +} + + +/* + * Callback for raw_expression_tree_mutator performing substitution of literals with parameters */ static bool -query_plan_generalizer(Node** ref, void *context) +raw_parse_tree_generalizer(Node** ref, void *context) { Node* node = *ref; GeneralizerCtx* ctx = (GeneralizerCtx*)context; @@ -4604,10 +4744,10 @@ query_plan_generalizer(Node** ref, void *context) return false; } /* - * Calculate hash for parse tree. We consider only node tags here, precise comparion of trees is done using equal() function. + * Calculate hash for parse tree. We consider only node tags here, precise comparison of trees is done using equal() function. * Here we calculate hash for original (unpatched) tree, without ParamRef nodes. - * It is non priniciple, because hash calculation doesn't take in account types and values of Const nodes. So the same generalized queries - * will have the same hash value. There are about 1000 dirrent nodes tags, this is why we rotate hash on 10 bits. + * It is non principle, because hash calculation doesn't take in account types and values of Const nodes. So the same generalized queries + * will have the same hash value. There are about 1000 different nodes tags, this is why we rotate hash on 10 bits. */ ctx->hash = (ctx->hash << 10) ^ (ctx->hash >> 22) ^ nodeTag(node); @@ -4616,54 +4756,63 @@ query_plan_generalizer(Node** ref, void *context) case T_A_Expr: { /* - * Do not perform substitution of literals in constant expression (which is likely to be the the same for all queries and optimized by compiler) + * Do not perform substitution of literals in constant expression (which is likely to be the same for all queries and optimized by compiler) */ - if (!is_constant_expression(node)) + if (!is_constant_expression(node)) { A_Expr *expr = (A_Expr *) node; - if (query_plan_generalizer((Node**)&expr->lexpr, context)) + if (raw_parse_tree_generalizer((Node**)&expr->lexpr, context)) return true; - if (query_plan_generalizer((Node**)&expr->rexpr, context)) + if (raw_parse_tree_generalizer((Node**)&expr->rexpr, context)) return true; } break; } - case T_A_Const: + case T_A_Const: { /* - * Do sunstitution of literals with parameters here + * Do substitution of literals with parameters here */ A_Const* literal = (A_Const*)node; - ConstParam* cp = palloc(sizeof(ConstParam)); - ParamRef* param = makeNode(ParamRef); - param->number = ++ctx->n_params; - param->location = literal->location; - cp->ref = ref; - cp->param = param; - cp->literal = literal; - *ctx->param_list_tail = cp; - ctx->param_list_tail = &cp->next; - *ref = (Node*)param; + if (literal->val.type != T_Null) + { + /* + * Do not substitute null literals with parameters + */ + ParamBinding* cp = palloc0(sizeof(ParamBinding)); + ParamRef* param = makeNode(ParamRef); + param->number = ++ctx->n_params; + param->location = literal->location; + cp->ref = ref; + cp->paramref = param; + cp->literal = literal; + cp->raw_type = get_literal_type(&literal->val); + *ctx->param_list_tail = cp; + ctx->param_list_tail = &cp->next; + *ref = (Node*)param; + } break; } case T_SelectStmt: { /* - * Substitute literals onlu in WHERE, VALUES and WITH clause, + * Substitute literals only in target list, WHERE, VALUES and WITH clause, * skipping target and from lists, which is unlikely contains some parameterized values */ SelectStmt *stmt = (SelectStmt *) node; - if (query_plan_generalizer((Node**)&stmt->targetList, context)) + if (stmt->intoClause) + return true; /* Utility statement can not be prepared */ + if (raw_parse_tree_generalizer((Node**)&stmt->targetList, context)) return true; - if (query_plan_generalizer((Node**)&stmt->whereClause, context)) + if (raw_parse_tree_generalizer((Node**)&stmt->whereClause, context)) return true; - if (query_plan_generalizer((Node**)&stmt->valuesLists, context)) + if (raw_parse_tree_generalizer((Node**)&stmt->valuesLists, context)) return true; - if (query_plan_generalizer((Node**)&stmt->withClause, context)) + if (raw_parse_tree_generalizer((Node**)&stmt->withClause, context)) return true; - if (query_plan_generalizer((Node**)&stmt->larg, context)) + if (raw_parse_tree_generalizer((Node**)&stmt->larg, context)) return true; - if (query_plan_generalizer((Node**)&stmt->rarg, context)) + if (raw_parse_tree_generalizer((Node**)&stmt->rarg, context)) return true; break; } @@ -4671,6 +4820,7 @@ query_plan_generalizer(Node** ref, void *context) case T_SortGroupClause: case T_SortBy: case T_A_ArrayExpr: + case T_TypeCast: /* * Literals in this clauses should not be replaced with parameters */ @@ -4678,29 +4828,76 @@ query_plan_generalizer(Node** ref, void *context) default: /* * Default traversal. raw_expression_tree_mutator returns true for all not recognized nodes, for example right now - * all transaction control statements are not covered by raw_expression_tree_mutator and so will not pe autoprepared. + * all transaction control statements are not covered by raw_expression_tree_mutator and so will not auto prepared. * My experiments show that effect of non-preparing start/commit transaction statements is positive. */ - return raw_expression_tree_mutator(node, query_plan_generalizer, context); + return raw_expression_tree_mutator(node, raw_parse_tree_generalizer, context); } return false; } +static Node* +parse_tree_generalizer(Node *node, void *context) +{ + ParamBinding* binding; + ParamBinding* binding_list = (ParamBinding*)context; + if (node == NULL) + { + return NULL; + } + if (IsA(node, Query)) + { + return (Node*)query_tree_mutator((Query*)node, + parse_tree_generalizer, + context, + QTW_DONT_COPY_QUERY); + } + if (IsA(node, Const)) + { + Const* c = (Const*)node; + int paramno = 1; + for (binding = binding_list; binding != NULL && binding->literal->location != c->location; binding = binding->next, paramno++); + if (binding != NULL) + { + if (binding->param != NULL) + { + /* Parameter can be used only once */ + binding->type = UNKNOWNOID; + //return (Node*)binding->param; + } + else + { + Param* param = makeNode(Param); + param->paramkind = PARAM_EXTERN; + param->paramid = paramno; + param->paramtype = c->consttype; + param->paramtypmod = c->consttypmod; + param->paramcollid = c->constcollid; + param->location = c->location; + binding->type = c->consttype; + binding->param = param; + return (Node*)param; + } + } + return node; + } + return expression_tree_mutator(node, parse_tree_generalizer, context); +} + /* * Restore original parse tree, replacing all ParamRef back with Const nodes. * Such undo operation seems to be more efficient than copying the whole parse tree by raw_expression_tree_mutator */ -static void undo_query_plan_changes(Node* parse_tree, ConstParam* cp) +static void undo_query_plan_changes(ParamBinding* cp) { while (cp != NULL) { *cp->ref = (Node*)cp->literal; cp = cp->next; } - n_plan_cache_misses += 1; } /* - * Callback for raw_expression_tree_walker droping parse tree + * Callback for raw_expression_tree_walker dropping parse tree */ static bool drop_tree_node(Node* node, void* context) { @@ -4730,59 +4927,60 @@ prepare_error_callback(void *arg) (void)errposition(pos); } } - /* * Try to generalize query, find cached plan for it and execute */ - static bool exec_cached_query(const char *query_string, Node* parse_tree) +static bool exec_cached_query(const char *query_string, List *parsetree_list) { - CommandDest dest = whereToSendOutput; - DestReceiver *receiver; - int n_params; + int n_params; plan_cache_entry *entry; - bool found; - MemoryContext old_context; + bool found; + MemoryContext old_context; CachedPlanSource *psrc; - ParamListInfo params; - int paramno; - CachedPlan *cplan; - Portal portal; - bool was_logged = false; - bool is_xact_command; - bool execute_is_fetch; - char completion_tag[COMPLETION_TAG_BUFSIZE]; - bool save_log_statement_stats = log_statement_stats; - ParamListInfo portal_params; - const char *source_text; - char msec_str[32]; - bool snapshot_set = false; - GeneralizerCtx ctx; - ConstParam* const_param; - ConstParam* const_param_list; + ParamListInfo params; + int paramno; + CachedPlan *cplan; + Portal portal; + bool snapshot_set = false; + GeneralizerCtx ctx; + ParamBinding* binding; + ParamBinding* binding_list; plan_cache_entry pattern; + Oid* param_types; + Node *raw_parse_tree; - static HTAB* plan_cache; /* hash table for plan cache */ - static dlist_head lru; /* LRU L2-list for cached queries */ - static MemoryContext plan_cache_context; /* memory context used for plan cache */ + raw_parse_tree = linitial(parsetree_list); /* - * Substitute literals with parameters and calculate hash for parse tree + * Substitute literals with parameters and calculate hash for raw parse tree */ - ctx.param_list_tail = &const_param_list; + ctx.param_list_tail = &binding_list; ctx.n_params = 0; ctx.hash = 0; - if (query_plan_generalizer((Node**)&parse_tree, &ctx)) { + if (raw_parse_tree_generalizer(&raw_parse_tree, &ctx)) + { *ctx.param_list_tail = NULL; - undo_query_plan_changes(parse_tree, const_param_list); + undo_query_plan_changes(binding_list); + autoprepare_misses += 1; return false; } *ctx.param_list_tail = NULL; n_params = ctx.n_params; + /* + * Extract array of parameters types: it is needed for cached plan lookup + */ + param_types = (Oid*)palloc(sizeof(Oid)*n_params); + for (paramno = 0, binding = binding_list; paramno < n_params; paramno++, binding = binding->next) + { + param_types[paramno] = binding->raw_type; + } + /* * Construct plan cache context if not constructed yet. */ - if (plan_cache_context == NULL) { + if (plan_cache_context == NULL) + { plan_cache_context = AllocSetContextCreate(TopMemoryContext, "plan cache context", ALLOCSET_DEFAULT_SIZES); @@ -4793,7 +4991,7 @@ prepare_error_callback(void *arg) /* * Initialize hash table if not initialized yet */ - if (plan_cache == NULL) + if (plan_cache_hash == NULL) { static HASHCTL info; info.keysize = sizeof(plan_cache_entry); @@ -4801,86 +4999,114 @@ prepare_error_callback(void *arg) info.hash = plan_cache_hash_fn; info.match = plan_cache_match_fn; info.keycopy = plan_cache_keycopy_fn; - plan_cache = hash_create("plan_cache", autoprepare_limit != 0 ? autoprepare_limit : PLAN_CACHE_SIZE, - &info, HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_KEYCOPY); - dlist_init(&lru); + plan_cache_hash = hash_create("plan_cache", autoprepare_limit != 0 ? autoprepare_limit : PLAN_CACHE_SIZE, + &info, HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_KEYCOPY); + dlist_init(&plan_cache_lru); } /* * Lookup generalized query */ - pattern.parse_tree = parse_tree; + pattern.parse_tree = raw_parse_tree; pattern.hash = ctx.hash; - entry = (plan_cache_entry*)hash_search(plan_cache, &pattern, HASH_ENTER, &found); + pattern.n_params = n_params; + pattern.param_types = param_types; + entry = (plan_cache_entry*)hash_search(plan_cache_hash, &pattern, HASH_ENTER, &found); if (!found) { /* Check number of cached queries */ - if (++n_cached_queries > autoprepare_limit && autoprepare_limit != 0) + if (++autoprepare_cached_plans > autoprepare_limit && autoprepare_limit != 0) { - /* Drop least recently access query */ - plan_cache_entry* victim = dlist_container(plan_cache_entry, lru, lru.head.prev); + /* Drop least recently accessed query */ + plan_cache_entry* victim = dlist_container(plan_cache_entry, lru, plan_cache_lru.head.prev); Node* dropped_tree = victim->parse_tree; dlist_delete(&victim->lru); - DropCachedPlan(victim->plan); - hash_search(plan_cache, victim, HASH_REMOVE, NULL); + if (victim->plan) + { + DropCachedPlan(victim->plan); + } + pfree(victim->param_types); + hash_search(plan_cache_hash, victim, HASH_REMOVE, NULL); raw_expression_tree_walker(dropped_tree, drop_tree_node, NULL); - n_cached_queries -= 1; + autoprepare_cached_plans -= 1; } entry->exec_count = 0; + entry->prepared_time = 0; + entry->non_prepared_time = 0; entry->plan = NULL; entry->disable_autoprepare = false; } else { dlist_delete(&entry->lru); /* accessed entry will be moved to the head of LRU list */ - if (entry->plan != NULL && !entry->plan->is_valid) { + if (entry->plan != NULL && !entry->plan->is_valid) + { /* Drop invalidated plan: it will be reconstructed later */ DropCachedPlan(entry->plan); entry->plan = NULL; } } - dlist_insert_after(&lru.head, &entry->lru); /* prepend entry to the head of LRU list */ + dlist_insert_after(&plan_cache_lru.head, &entry->lru); /* prepend entry to the head of LRU list */ MemoryContextSwitchTo(old_context); /* Done with plan_cache_context memory context */ + /* * Prepare query only when it is executed more than autoprepare_threshold times */ if (entry->disable_autoprepare || entry->exec_count++ < autoprepare_threshold) { - undo_query_plan_changes(parse_tree, const_param_list); + undo_query_plan_changes(binding_list); + autoprepare_misses += 1; + + if (!entry->disable_autoprepare) + { + /* + * Store timestamp to calculate average execution time for non-prepared query. + * We collect statistic about autoprepare_threshold exec_simple_query runs. + */ + exec_start_timestamp = GetCurrentTimestamp(); + current_plan_entry = entry; + } return false; + } + else if (entry->exec_count <= autoprepare_threshold*2) + { + /* + * Measure time of prepared query execution + * if prepared query is executed less or equal than autoprepare_threshold times. + */ + exec_start_timestamp = GetCurrentTimestamp(); } + if (entry->plan == NULL) { - /* - * Prepare new plan - */ - const char *command_tag; - Query *query; + bool snapshot_set = false; + const char *commandTag; List *querytree_list; - Oid *param_types = NULL; - int num_params = 0; /* - * Switch to appropriate context for constructing parsetrees. + * Switch to appropriate context for preparing plan. */ old_context = MemoryContextSwitchTo(MessageContext); /* - * Get the command name for possible use in status display. + * Get the command name for use in status display (it also becomes the + * default completion tag, down inside PortalRun). Set ps_status and + * do any special start-of-SQL-command processing needed by the + * destination. */ - command_tag = CreateCommandTag(parse_tree); + commandTag = CreateCommandTag(raw_parse_tree); /* * If we are in an aborted transaction, reject all commands except - * COMMIT/ROLLBACK. It is important that this test occur before we - * try to do parse analysis, rewrite, or planning, since all those - * phases try to do database accesses, which may fail in abort state. - * (It might be safe to allow some additional utility commands in this + * COMMIT/ABORT. It is important that this test occur before we try + * to do parse analysis, rewrite, or planning, since all those phases + * try to do database accesses, which may fail in abort state. (It + * might be safe to allow some additional utility commands in this * state, but not many...) */ if (IsAbortedTransactionBlockState() && - !IsTransactionExitStmt(parse_tree)) + !IsTransactionExitStmt(raw_parse_tree)) ereport(ERROR, (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), errmsg("current transaction is aborted, " @@ -4891,92 +5117,52 @@ prepare_error_callback(void *arg) * Create the CachedPlanSource before we do parse analysis, since it * needs to see the unmodified raw parse tree. */ - psrc = CreateCachedPlan(parse_tree, query_string, command_tag); + psrc = CreateCachedPlan(raw_parse_tree, query_string, commandTag); /* - * Set up a snapshot if parse analysis will need one. + * Revert raw plan to use literals */ - if (analyze_requires_snapshot(parse_tree)) + undo_query_plan_changes(binding_list); + + /* + * Set up a snapshot if parse analysis/planning will need one. + */ + if (analyze_requires_snapshot(raw_parse_tree)) { PushActiveSnapshot(GetTransactionSnapshot()); snapshot_set = true; } + querytree_list = pg_analyze_and_rewrite(raw_parse_tree, query_string, + NULL, 0); /* - * Analyze and rewrite the query. Note that the originally specified - * parameter set is not required to be complete, so we have to use - * parse_analyze_varparams(). + * Replace Const with Param nodes */ - if (log_parser_stats) { - ResetUsage(); - } - - PG_TRY(); - { - query = parse_analyze_varparams(parse_tree, - query_string, - ¶m_types, - &num_params); - } - PG_CATCH(); - { - /* - * In case of analyze errors revert back to original query processing - * and disable autoprepare for this query to avoid such problems in future. - */ - FlushErrorState(); - if (snapshot_set) { - PopActiveSnapshot(); - } - entry->disable_autoprepare = true; - undo_query_plan_changes(parse_tree, const_param_list); - MemoryContextSwitchTo(old_context); - return false; - } - PG_END_TRY(); + (void)query_tree_mutator((Query*)linitial(querytree_list), + parse_tree_generalizer, + binding_list, + QTW_DONT_COPY_QUERY); - Assert(num_params == n_params); + /* Done with the snapshot used for parsing/planning */ + if (snapshot_set) + PopActiveSnapshot(); - /* - * Check all parameter types got determined. - */ - for (paramno = 0, const_param = const_param_list; - paramno < n_params; - paramno++, const_param = const_param->next) + param_types = (Oid*)palloc(sizeof(Oid)*n_params); + psrc->param_types = param_types; + for (paramno = 0, binding = binding_list; paramno < n_params; paramno++, binding = binding->next) { - Oid ptype = param_types[paramno]; - - /* - * Check if type of parameter can be infered from query and is compatible with actual literal type. - * We explicitly exclude some cases when parameter type is wrongly assumed to be TEXT. - * Hopefully there will be few such misdetections in real queries. - */ - if (ptype == InvalidOid || ptype == UNKNOWNOID - || (ptype == TEXTOID && (const_param->literal->val.type == T_BitString || const_param->literal->val.type == T_Integer))) + if (binding->param == NULL || binding->type == UNKNOWNOID) { - /* Type of parameter can not be determined: disable autoprepare for this query. */ - if (snapshot_set) { - PopActiveSnapshot(); - } + /* Failed to resolve parameter type */ entry->disable_autoprepare = true; - undo_query_plan_changes(parse_tree, const_param_list); + autoprepare_misses += 1; MemoryContextSwitchTo(old_context); return false; } + param_types[paramno] = binding->type; } - if (log_parser_stats) { - ShowUsage("PARSE ANALYSIS STATISTICS"); - } - - querytree_list = pg_rewrite_query(query); - - /* Done with the snapshot used for parsing */ - if (snapshot_set) { - PopActiveSnapshot(); - snapshot_set = false; - } - + /* Finish filling in the CachedPlanSource */ CompleteCachedPlan(psrc, querytree_list, NULL, @@ -4990,10 +5176,26 @@ prepare_error_callback(void *arg) /* If we got a cancel signal during analysis, quit */ CHECK_FOR_INTERRUPTS(); + SaveCachedPlan(psrc); + + /* + * We do NOT close the open transaction command here; that only happens + * when the client sends Sync. Instead, do CommandCounterIncrement just + * in case something happened during parse/plan. + */ + CommandCounterIncrement(); + + MemoryContextSwitchTo(old_context); /* Done with MessageContext memory context */ + + entry->plan = psrc; + + /* + * Determine output format + */ entry->format = 0; /* TEXT is default */ - if (IsA(parse_tree, FetchStmt)) + if (IsA(raw_parse_tree, FetchStmt)) { - FetchStmt *stmt = (FetchStmt *)parse_tree; + FetchStmt *stmt = (FetchStmt *)raw_parse_tree; if (!stmt->ismove) { @@ -5004,22 +5206,6 @@ prepare_error_callback(void *arg) entry->format = 1; /* BINARY */ } } - - /* - * Register cached plan for invalidation mechanism - */ - SaveCachedPlan(psrc); - entry->plan = psrc; - entry->n_params = n_params; - - MemoryContextSwitchTo(old_context); /* Done with message context */ - - /* - * We do NOT close the open transaction command here; that only happens - * when the client sends Sync. Instead, do CommandCounterIncrement just - * in case something happened during parse/plan. - */ - CommandCounterIncrement(); } else { @@ -5032,7 +5218,7 @@ prepare_error_callback(void *arg) * If we are in aborted transaction state, the only portals we can * actually run are those containing COMMIT or ROLLBACK commands. We * disallow binding anything else to avoid problems with infrastructure - * that expects to run inside a valid transaction. We also disallow + * that expects to run inside a valid transaction. We also disallow * binding any parameters, since we can't risk calling user-defined I/O * functions. */ @@ -5054,7 +5240,7 @@ prepare_error_callback(void *arg) portal->visible = false; /* - * Prepare to copy stuff into the portal's memory context. We do all this + * Prepare to copy stuff into the portal's memory context. We do all this * copying first, because it could possibly fail (out-of-memory) and we * don't want a failure to occur between GetCachedPlan and * PortalDefineQuery; that would result in leaking our plancache refcount. @@ -5085,9 +5271,10 @@ prepare_error_callback(void *arg) if (n_params > 0) { ErrorContextCallback errcallback; - Oid typinput; - Oid typioparam; - char buf[64]; + + params = (ParamListInfo) palloc0(offsetof(ParamListInfoData, params) + + n_params * sizeof(ParamExternData)); + params->numParams = n_params; /* * Register error callback to precisely report error in case of conversion error while storig parameter value. @@ -5097,86 +5284,27 @@ prepare_error_callback(void *arg) errcallback.previous = error_context_stack; error_context_stack = &errcallback; - params = (ParamListInfo) palloc(offsetof(ParamListInfoData, params) + - n_params * sizeof(ParamExternData)); - params->paramFetch = NULL; - params->paramFetchArg = NULL; - params->parserSetup = NULL; - params->parserSetupArg = NULL; - params->numParams = n_params; - params->paramMask = NULL; - - for (paramno = 0, const_param = const_param_list; + for (paramno = 0, binding = binding_list; paramno < n_params; - paramno++, const_param = const_param->next) + paramno++, binding = binding->next) { Oid ptype = psrc->param_types[paramno]; - - param_location = const_param->literal->location; + param_location = binding->literal->location; params->params[paramno].isnull = false; - - /* Convert literal value to parameter value */ - switch (const_param->literal->val.type) - { - /* - * Convert from integer literal - */ - case T_Integer: - switch (ptype) { - case INT8OID: - params->params[paramno].value = Int64GetDatum((int64)const_param->literal->val.val.ival); - break; - case INT4OID: - params->params[paramno].value = Int32GetDatum((int32)const_param->literal->val.val.ival); - break; - case INT2OID: - if (const_param->literal->val.val.ival < SHRT_MIN - || const_param->literal->val.val.ival > SHRT_MAX) - { - ereport(ERROR, - (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), - errmsg("smallint out of range"))); - } - params->params[paramno].value = Int16GetDatum((int16)const_param->literal->val.val.ival); - break; - case FLOAT4OID: - params->params[paramno].value = Float4GetDatum((float)const_param->literal->val.val.ival); - break; - case FLOAT8OID: - params->params[paramno].value = Float8GetDatum((double)const_param->literal->val.val.ival); - break; - case INT4RANGEOID: - sprintf(buf, "[%ld,%ld]", const_param->literal->val.val.ival, const_param->literal->val.val.ival); - getTypeInputInfo(ptype, &typinput, &typioparam); - params->params[paramno].value = OidInputFunctionCall(typinput, buf, typioparam, -1); - break; - default: - pg_lltoa(const_param->literal->val.val.ival, buf); - getTypeInputInfo(ptype, &typinput, &typioparam); - params->params[paramno].value = OidInputFunctionCall(typinput, buf, typioparam, -1); - } - break; - case T_Null: - params->params[paramno].isnull = true; - break; - default: - /* - * Convert from string literal - */ - getTypeInputInfo(ptype, &typinput, &typioparam); - params->params[paramno].value = OidInputFunctionCall(typinput, const_param->literal->val.val.str, typioparam, -1); - } + params->params[paramno].value = get_param_value(ptype, &binding->literal->val); /* - * We mark the params as CONST. This ensures that any custom plan + * We mark the params as CONST. This ensures that any custom plan * makes full use of the parameter values. */ params->params[paramno].pflags = PARAM_FLAG_CONST; params->params[paramno].ptype = ptype; } error_context_stack = errcallback.previous; - } else { + } + else + { params = NULL; } @@ -5184,8 +5312,8 @@ prepare_error_callback(void *arg) MemoryContextSwitchTo(old_context); /* - * Obtain a plan from the CachedPlanSource. Any cruft from (re)planning - * will be generated in MessageContext. The plan refcount will be + * Obtain a plan from the CachedPlanSource. Any cruft from (re)planning + * will be generated in MessageContext. The plan refcount will be * assigned to the Portal, so it will be released at portal destruction. */ cplan = GetCachedPlan(psrc, params, false); @@ -5204,7 +5332,8 @@ prepare_error_callback(void *arg) cplan); /* Done with the snapshot used for parameter I/O and parsing/planning */ - if (snapshot_set) { + if (snapshot_set) + { PopActiveSnapshot(); } @@ -5218,142 +5347,58 @@ prepare_error_callback(void *arg) */ PortalSetResultFormat(portal, 1, &entry->format); - /* Does the portal contain a transaction command? */ - is_xact_command = IsTransactionStmtList(portal->stmts); - /* - * We must copy the sourceText into MessageContext in - * case the portal is destroyed during finish_xact_command. Can avoid the - * copy if it's not an xact command, though. + * Finally execute prepared statement */ - if (is_xact_command) - { - source_text = pstrdup(portal->sourceText); - /* - * An xact command shouldn't have any parameters, which is a good - * thing because they wouldn't be around after finish_xact_command. - */ - portal_params = NULL; - } - else - { - source_text = portal->sourceText; - portal_params = portal->portalParams; - } + exec_prepared_plan(portal, "", FETCH_ALL, whereToSendOutput); - /* - * Report query to various monitoring facilities. - */ - debug_query_string = source_text; - - pgstat_report_activity(STATE_RUNNING, source_text); - - set_ps_display(portal->commandTag, false); - - if (save_log_statement_stats) { - ResetUsage(); - } - - BeginCommand(portal->commandTag, dest); - - PortalSetResultFormat(portal, 1, &entry->format); - - - /* - * Create dest receiver in MessageContext (we don't want it in transaction - * context, because that may get deleted if portal contains VACUUM). - */ - receiver = CreateDestReceiver(dest); - if (dest == DestRemote) { - SetRemoteDestReceiverParams(receiver, portal); - } + /* Collect statistic about time of prepared query execution during autoprepare_threshold runs */ + if (entry->exec_count <= autoprepare_threshold*2) + { + /* Calculate average time of execution of prepared query */ + long secs; + int usecs; + TimestampDifference(exec_start_timestamp, + GetCurrentTimestamp(), + &secs, &usecs); - /* - * If we re-issue an Execute protocol request against an existing portal, - * then we are only fetching more rows rather than completely re-executing - * the query from the start. atStart is never reset for a v3 portal, so we - * are safe to use this check. - */ - execute_is_fetch = !portal->atStart; + entry->prepared_time += secs * USECS_PER_SEC + usecs; - /* Log immediately if dictated by log_statement */ - if (check_log_statement(portal->stmts)) - { - ereport(LOG, - (errmsg("%s %s%s%s: %s", - execute_is_fetch ? - _("execute fetch from") : - _("execute"), - "", - "", - "", - source_text), - errhidestmt(true), - errdetail_params(portal_params))); - was_logged = true; + if (entry->exec_count == autoprepare_threshold*2) + { + /* Now we can compare average times of prepared and non-prepared queries execution */ + if (entry->prepared_time > entry->non_prepared_time) + { + /* + * Disable autoprepare if average time of execution of prepared query + * is worser than of non-prepared query + */ + entry->disable_autoprepare = true; + elog(LOG, "Disable autoprepared plan for %s because its average time %ld is greater than time of non-prepared query %ld", + query_string, entry->prepared_time, entry->non_prepared_time); + } + } } - /* Check for cancel signal before we start execution */ - CHECK_FOR_INTERRUPTS(); - /* - * Run the portal to completion, and then drop it (and the receiver). + * Close down transaction statement, if one is open. */ - (void) PortalRun(portal, - FETCH_ALL, - true, - receiver, - receiver, - completion_tag); - - (*receiver->rDestroy) (receiver); + finish_xact_command(); - PortalDrop(portal, false); + autoprepare_hits += 1; - /* - * Tell client that we're done with this query. Note we emit exactly - * one EndCommand report for each raw parsetree, thus one for each SQL - * command the client sent, regardless of rewriting. (But a command - * aborted by error will not send an EndCommand report at all.) - */ - EndCommand(completion_tag, dest); + return true; +} - /* - * Close down transaction statement, if one is open. - */ - finish_xact_command(); - /* - * Emit duration logging if appropriate. - */ - switch (check_log_duration(msec_str, was_logged)) +void ResetAutoprepareCache(void) +{ + if (plan_cache_hash != NULL) { - case 1: - ereport(LOG, - (errmsg("duration: %s ms", msec_str), - errhidestmt(true))); - break; - case 2: - ereport(LOG, - (errmsg("duration: %s ms %s %s%s%s: %s", - msec_str, - execute_is_fetch ? - _("execute fetch from") : - _("execute"), - "", - "", - "", - source_text), - errhidestmt(true), - errdetail_params(portal_params))); - break; + hash_destroy(plan_cache_hash); + MemoryContextReset(plan_cache_context); + dlist_init(&plan_cache_lru); + autoprepare_cached_plans = 0; + plan_cache_hash = 0; } - - if (save_log_statement_stats) { - ShowUsage("EXECUTE MESSAGE STATISTICS"); - } - debug_query_string = NULL; - n_plan_cache_hits += 1; - - return true; } diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index 859476fdc8..20275aa3c0 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -1971,7 +1971,7 @@ static struct config_int ConfigureNamesInt[] = gettext_noop("0 means unlimited number of autoprepared queries."), }, &autoprepare_limit, - 0, 0, INT_MAX, + 113, 0, INT_MAX, NULL, NULL, NULL }, From cb6a498e64374dbeb5688de02af2e020bad88305 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 20 May 2017 21:50:47 -0400 Subject: [PATCH 0075/1139] Change documentation references to PG website to use https: not http: This is more secure, and saves a redirect since we no longer accept plain HTTP connections on the website. References in code comments should probably be updated too, but that doesn't seem to need back-patching, whereas this does. Also, in the 9.2 branch, remove suggestion that you can get the source code via FTP, since that service will be shut down soon. Daniel Gustafsson, with a few additional changes by me Discussion: https://postgr.es/m/9A2C89A7-0BB8-41A8-B288-8B7BD09D7D44@yesql.se --- HISTORY | 2 +- README | 6 +++--- README.git | 2 +- doc/TODO | 2 +- doc/bug.template | 2 +- doc/src/sgml/acronyms.sgml | 2 +- doc/src/sgml/advanced.sgml | 2 +- doc/src/sgml/contacts.sgml | 2 +- doc/src/sgml/docguide.sgml | 2 +- doc/src/sgml/external-projects.sgml | 2 +- doc/src/sgml/info.sgml | 8 ++++---- doc/src/sgml/installation.sgml | 8 ++++---- doc/src/sgml/problems.sgml | 2 +- doc/src/sgml/release.sgml | 4 ++-- doc/src/sgml/sepgsql.sgml | 2 +- doc/src/sgml/sourcerepo.sgml | 6 +++--- doc/src/sgml/stylesheet.xsl | 2 +- 17 files changed, 28 insertions(+), 28 deletions(-) diff --git a/HISTORY b/HISTORY index dcfd713c15..18d7b1b724 100644 --- a/HISTORY +++ b/HISTORY @@ -1,5 +1,5 @@ Release notes for all versions of PostgreSQL can be found on-line at -http://www.postgresql.org/docs/current/static/release.html +https://www.postgresql.org/docs/current/static/release.html Distribution file sets include release notes for their version and preceding versions. Visit the file doc/src/sgml/html/release.html in an HTML browser. diff --git a/README b/README index 302028e992..12de3f1d73 100644 --- a/README +++ b/README @@ -11,7 +11,7 @@ and functions. This distribution also contains C language bindings. PostgreSQL has many language interfaces, many of which are listed here: - http://www.postgresql.org/download + https://www.postgresql.org/download See the file INSTALL for instructions on how to build and install PostgreSQL. That file also lists supported operating systems and @@ -23,5 +23,5 @@ distribution; it can be read as described in the installation instructions. The latest version of this software may be obtained at -http://www.postgresql.org/download/. For more information look at our -web site located at http://www.postgresql.org/. +https://www.postgresql.org/download/. For more information look at our +web site located at https://www.postgresql.org/. diff --git a/README.git b/README.git index 0bf2b56cb3..52cb7223df 100644 --- a/README.git +++ b/README.git @@ -6,7 +6,7 @@ git and so will not be present if you are using a git checkout. If you are using a git checkout, you can view the most recent installation instructions at: - http://www.postgresql.org/docs/devel/static/installation.html + https://www.postgresql.org/docs/devel/static/installation.html Users compiling from git will also need compatible versions of Bison, Flex, and Perl, as discussed in the install documentation. These programs are not diff --git a/doc/TODO b/doc/TODO index 4b7b3da476..d9d0c0cc52 100644 --- a/doc/TODO +++ b/doc/TODO @@ -1,3 +1,3 @@ The TODO list is now maintained at: - http://wiki.postgresql.org/wiki/Todo + https://wiki.postgresql.org/wiki/Todo diff --git a/doc/bug.template b/doc/bug.template index 55f1fd9011..4e1467c225 100644 --- a/doc/bug.template +++ b/doc/bug.template @@ -9,7 +9,7 @@ If you not only found the problem but solved it and generated a patch then e-mail it to pgsql-hackers@postgresql.org instead. Please use the command "diff -c" to generate the patch. -You may also enter a bug report at http://www.postgresql.org/ instead of +You may also enter a bug report at https://www.postgresql.org/ instead of e-mailing this form. ============================================================================ diff --git a/doc/src/sgml/acronyms.sgml b/doc/src/sgml/acronyms.sgml index 38f111ef9d..8bde44e5af 100644 --- a/doc/src/sgml/acronyms.sgml +++ b/doc/src/sgml/acronyms.sgml @@ -300,7 +300,7 @@ Heap-Only + url="https://git.postgresql.org/gitweb?p=postgresql.git;a=blob;f=src/backend/access/heap/README.HOT;hb=HEAD">Heap-Only Tuples diff --git a/doc/src/sgml/advanced.sgml b/doc/src/sgml/advanced.sgml index 1e45511cc6..55ab445b04 100644 --- a/doc/src/sgml/advanced.sgml +++ b/doc/src/sgml/advanced.sgml @@ -712,7 +712,7 @@ SELECT name, altitude If you feel you need more introductory material, please visit the PostgreSQL - web site + web site for links to more resources. diff --git a/doc/src/sgml/contacts.sgml b/doc/src/sgml/contacts.sgml index a981625027..308eb418a5 100644 --- a/doc/src/sgml/contacts.sgml +++ b/doc/src/sgml/contacts.sgml @@ -16,7 +16,7 @@ and the mailing lists themselves. Refer to the introduction in this manual or to the PostgreSQL -web page +web page for subscription information to the no-cost mailing lists. diff --git a/doc/src/sgml/docguide.sgml b/doc/src/sgml/docguide.sgml index 6f896b565f..f8389c74c1 100644 --- a/doc/src/sgml/docguide.sgml +++ b/doc/src/sgml/docguide.sgml @@ -585,7 +585,7 @@ checking for osx... osx To produce HTML documentation with the stylesheet used on postgresql.org instead of the + url="https://www.postgresql.org/docs/current">postgresql.org instead of the default simple style use: doc/src/sgml$ make STYLE=website html diff --git a/doc/src/sgml/external-projects.sgml b/doc/src/sgml/external-projects.sgml index 3b51e480f7..8457426545 100644 --- a/doc/src/sgml/external-projects.sgml +++ b/doc/src/sgml/external-projects.sgml @@ -72,7 +72,7 @@ JDBC JDBC Type 4 JDBC driver - + diff --git a/doc/src/sgml/info.sgml b/doc/src/sgml/info.sgml index a59d0c8a43..233ba0e668 100644 --- a/doc/src/sgml/info.sgml +++ b/doc/src/sgml/info.sgml @@ -14,10 +14,10 @@ The PostgreSQL wiki contains the project's FAQ + url="https://wiki.postgresql.org">wiki contains the project's FAQ (Frequently Asked Questions) list, TODO list, and + url="https://wiki.postgresql.org/wiki/Todo">TODO list, and detailed information about many more topics. @@ -28,7 +28,7 @@ The PostgreSQL - web site + web site carries details on the latest release and other information to make your work or play with PostgreSQL more productive. diff --git a/doc/src/sgml/installation.sgml b/doc/src/sgml/installation.sgml index 7483731053..59762b0a93 100644 --- a/doc/src/sgml/installation.sgml +++ b/doc/src/sgml/installation.sgml @@ -343,7 +343,7 @@ su - postgres The PostgreSQL &version; sources can be obtained from the download section of our - website: . You + website: . You should get a file named postgresql-&version;.tar.gz or postgresql-&version;.tar.bz2. After you have obtained the file, unpack it: @@ -2011,7 +2011,7 @@ kill `cat /usr/local/pgsql/data/postmaster.pid` it has recently been verified to build and pass its regression tests on that platform. Currently, most testing of platform compatibility is done automatically by test machines in the - PostgreSQL Build Farm. + PostgreSQL Build Farm. If you are interested in using PostgreSQL on a platform that is not represented in the build farm, but on which the code works or can be made to work, you are strongly encouraged to set up a build @@ -2187,7 +2187,7 @@ kill `cat /usr/local/pgsql/data/postmaster.pid` should take care of it. - + One user reports: @@ -2249,7 +2249,7 @@ hosts=local4,bind4 Memory Management - + AIX can be somewhat peculiar with regards to the way it does diff --git a/doc/src/sgml/problems.sgml b/doc/src/sgml/problems.sgml index 3f79c6ef90..6bf74bb399 100644 --- a/doc/src/sgml/problems.sgml +++ b/doc/src/sgml/problems.sgml @@ -304,7 +304,7 @@ Another method is to fill in the bug report web-form available at the project's - web site. + web site. Entering a bug report this way causes it to be mailed to the pgsql-bugs@postgresql.org mailing list. diff --git a/doc/src/sgml/release.sgml b/doc/src/sgml/release.sgml index 472c1f6f12..1f8cd8ef17 100644 --- a/doc/src/sgml/release.sgml +++ b/doc/src/sgml/release.sgml @@ -55,9 +55,9 @@ For new features, add links to the documentation sections. A complete list of changes for each release can be obtained by viewing the Git logs for each release. The pgsql-committers + url="https://archives.postgresql.org/pgsql-committers/">pgsql-committers email list records all source code changes as well. There is also - a web + a web interface that shows changes to specific files. diff --git a/doc/src/sgml/sepgsql.sgml b/doc/src/sgml/sepgsql.sgml index 6f80933abd..0b611eeeca 100644 --- a/doc/src/sgml/sepgsql.sgml +++ b/doc/src/sgml/sepgsql.sgml @@ -753,7 +753,7 @@ ERROR: SELinux: security policy violation External Resources - SE-PostgreSQL Introduction + SE-PostgreSQL Introduction This wiki page provides a brief overview, security design, architecture, diff --git a/doc/src/sgml/sourcerepo.sgml b/doc/src/sgml/sourcerepo.sgml index d82706b40b..f8f6bf2de1 100644 --- a/doc/src/sgml/sourcerepo.sgml +++ b/doc/src/sgml/sourcerepo.sgml @@ -12,7 +12,7 @@ Our wiki, , + url="https://wiki.postgresql.org/wiki/Working_with_Git">, has some discussion on working with Git. @@ -64,10 +64,10 @@ git clone git://git.postgresql.org/git/postgresql.git The Git mirror can also be reached via the HTTP protocol, if for example a firewall is blocking access to the Git protocol. Just change the URL - prefix to http, as in: + prefix to https, as in: -git clone http://git.postgresql.org/git/postgresql.git +git clone https://git.postgresql.org/git/postgresql.git The HTTP protocol is less efficient than the Git protocol, so it will be diff --git a/doc/src/sgml/stylesheet.xsl b/doc/src/sgml/stylesheet.xsl index 7967b361dd..8fd870a2e2 100644 --- a/doc/src/sgml/stylesheet.xsl +++ b/doc/src/sgml/stylesheet.xsl @@ -24,7 +24,7 @@ stylesheet.css - http://www.postgresql.org/media/css/docs.css + https://www.postgresql.org/media/css/docs.css From c101d83a3dd6d23f33bfbbbd696c0ea11abcbaf9 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 21 May 2017 13:05:17 -0400 Subject: [PATCH 0076/1139] Fix precision and rounding issues in money multiplication and division. The cash_div_intX functions applied rint() to the result of the division. That's not merely useless (because the result is already an integer) but it causes precision loss for values larger than 2^52 or so, because of the forced conversion to float8. On the other hand, the cash_mul_fltX functions neglected to apply rint() to their multiplication results, thus possibly causing off-by-one outputs. Per C standard, arithmetic between any integral value and a float value is performed in float format. Thus, cash_mul_flt4 and cash_div_flt4 produced answers good to only about six digits, even when the float value is exact. We can improve matters noticeably by widening the float inputs to double. (It's tempting to consider using "long double" arithmetic if available, but that's probably too much of a stretch for a back-patched fix.) Also, document that cash_div_intX operators truncate rather than round. Per bug #14663 from Richard Pistole. Back-patch to all supported branches. Discussion: https://postgr.es/m/22403.1495223615@sss.pgh.pa.us --- doc/src/sgml/datatype.sgml | 5 ++++ src/backend/utils/adt/cash.c | 16 ++++++------ src/test/regress/expected/money.out | 38 +++++++++++++++++++++++++++++ src/test/regress/sql/money.sql | 10 ++++++++ 4 files changed, 61 insertions(+), 8 deletions(-) diff --git a/doc/src/sgml/datatype.sgml b/doc/src/sgml/datatype.sgml index 464ce83d30..39bbd87e67 100644 --- a/doc/src/sgml/datatype.sgml +++ b/doc/src/sgml/datatype.sgml @@ -977,6 +977,11 @@ SELECT '52093.89'::money::numeric::float8; + Division of a money value by an integer value is performed + with truncation of the fractional part towards zero. To get a rounded + result, divide by a floating-point value, or cast the money + value to numeric before dividing and back to money + afterwards. (The latter is preferable to avoid risking precision loss.) When a money value is divided by another money value, the result is double precision (i.e., a pure number, not money); the currency units cancel each other out in the division. diff --git a/src/backend/utils/adt/cash.c b/src/backend/utils/adt/cash.c index b336185df7..d329efaa9a 100644 --- a/src/backend/utils/adt/cash.c +++ b/src/backend/utils/adt/cash.c @@ -621,7 +621,7 @@ cash_mul_flt8(PG_FUNCTION_ARGS) float8 f = PG_GETARG_FLOAT8(1); Cash result; - result = c * f; + result = rint(c * f); PG_RETURN_CASH(result); } @@ -636,7 +636,7 @@ flt8_mul_cash(PG_FUNCTION_ARGS) Cash c = PG_GETARG_CASH(1); Cash result; - result = f * c; + result = rint(f * c); PG_RETURN_CASH(result); } @@ -671,7 +671,7 @@ cash_mul_flt4(PG_FUNCTION_ARGS) float4 f = PG_GETARG_FLOAT4(1); Cash result; - result = c * f; + result = rint(c * (float8) f); PG_RETURN_CASH(result); } @@ -686,7 +686,7 @@ flt4_mul_cash(PG_FUNCTION_ARGS) Cash c = PG_GETARG_CASH(1); Cash result; - result = f * c; + result = rint((float8) f * c); PG_RETURN_CASH(result); } @@ -707,7 +707,7 @@ cash_div_flt4(PG_FUNCTION_ARGS) (errcode(ERRCODE_DIVISION_BY_ZERO), errmsg("division by zero"))); - result = rint(c / f); + result = rint(c / (float8) f); PG_RETURN_CASH(result); } @@ -756,7 +756,7 @@ cash_div_int8(PG_FUNCTION_ARGS) (errcode(ERRCODE_DIVISION_BY_ZERO), errmsg("division by zero"))); - result = rint(c / i); + result = c / i; PG_RETURN_CASH(result); } @@ -808,7 +808,7 @@ cash_div_int4(PG_FUNCTION_ARGS) (errcode(ERRCODE_DIVISION_BY_ZERO), errmsg("division by zero"))); - result = rint(c / i); + result = c / i; PG_RETURN_CASH(result); } @@ -858,7 +858,7 @@ cash_div_int2(PG_FUNCTION_ARGS) (errcode(ERRCODE_DIVISION_BY_ZERO), errmsg("division by zero"))); - result = rint(c / s); + result = c / s; PG_RETURN_CASH(result); } diff --git a/src/test/regress/expected/money.out b/src/test/regress/expected/money.out index 538235c4cc..efb48f1acd 100644 --- a/src/test/regress/expected/money.out +++ b/src/test/regress/expected/money.out @@ -185,6 +185,44 @@ SELECT * FROM money_data; $123.46 (1 row) +-- rounding vs. truncation in division +SELECT '878.08'::money / 11::float8; + ?column? +---------- + $79.83 +(1 row) + +SELECT '878.08'::money / 11::float4; + ?column? +---------- + $79.83 +(1 row) + +SELECT '878.08'::money / 11::int; + ?column? +---------- + $79.82 +(1 row) + +SELECT '878.08'::money / 11::smallint; + ?column? +---------- + $79.82 +(1 row) + +-- check for precision loss in division +SELECT '90000000000000099.00'::money / 10::int; + ?column? +--------------------------- + $9,000,000,000,000,009.90 +(1 row) + +SELECT '90000000000000099.00'::money / 10::smallint; + ?column? +--------------------------- + $9,000,000,000,000,009.90 +(1 row) + -- Cast int4/int8 to money SELECT 1234567890::money; money diff --git a/src/test/regress/sql/money.sql b/src/test/regress/sql/money.sql index 09b9476b70..f0db5fa432 100644 --- a/src/test/regress/sql/money.sql +++ b/src/test/regress/sql/money.sql @@ -57,6 +57,16 @@ DELETE FROM money_data; INSERT INTO money_data VALUES ('$123.459'); SELECT * FROM money_data; +-- rounding vs. truncation in division +SELECT '878.08'::money / 11::float8; +SELECT '878.08'::money / 11::float4; +SELECT '878.08'::money / 11::int; +SELECT '878.08'::money / 11::smallint; + +-- check for precision loss in division +SELECT '90000000000000099.00'::money / 10::int; +SELECT '90000000000000099.00'::money / 10::smallint; + -- Cast int4/int8 to money SELECT 1234567890::money; SELECT 12345678901234567::money; From a12fc4f5e6a5556abe065fe44e118da2f99af0f1 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 22 May 2017 13:26:47 +0300 Subject: [PATCH 0077/1139] Remove EE dependencies from multimaster --- contrib/mmts/pglogical_apply.c | 6 +++--- src/backend/tcop/postgres.c | 36 +++++++++++++++++++++++----------- 2 files changed, 28 insertions(+), 14 deletions(-) diff --git a/contrib/mmts/pglogical_apply.c b/contrib/mmts/pglogical_apply.c index c69404b55e..8092add151 100644 --- a/contrib/mmts/pglogical_apply.c +++ b/contrib/mmts/pglogical_apply.c @@ -101,13 +101,13 @@ find_pkey_tuple(ScanKey skey, Relation rel, Relation idxrel, InitDirtySnapshot(snap); scan = index_beginscan(rel, idxrel, &snap, - IndexRelationGetNumberOfKeyAttributes(idxrel), + IndexRelationGetNumberOfAttributes(idxrel), 0); retry: found = false; - index_rescan(scan, skey, IndexRelationGetNumberOfKeyAttributes(idxrel), NULL, 0); + index_rescan(scan, skey, RelationGetNumberOfAttributes(idxrel), NULL, 0); if ((scantuple = index_getnext(scan, ForwardScanDirection)) != NULL) { @@ -236,7 +236,7 @@ build_index_scan_key(ScanKey skey, Relation rel, Relation idxrel, TupleData *tup indkey = (int2vector *) DatumGetPointer(indkeyDatum); - for (attoff = 0; attoff < IndexRelationGetNumberOfKeyAttributes(idxrel); attoff++) + for (attoff = 0; attoff < RelationGetNumberOfAttributes(idxrel); attoff++) { Oid operator; Oid opfamily; diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 7ff3715432..26accb4f9a 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -4570,8 +4570,10 @@ typedef struct int n_params; /* number of parameters extracted for this query */ int16 format; /* portal output format */ bool disable_autoprepare; /* disable preparing of this query */ - uint64 non_prepared_time; /* averge time of original (non-prepared) query execution (sum of autoprepare_threshold query execution times) */ - uint64 prepared_time; /* averge time of prepared query execution (sum of autoprepare_threshold query execution times) */ + uint64 non_prepared_time_sum; /* sum of times of non-prepared query execution (up to autoprepare_threshold measurements) */ + uint64 prepared_time_sum; /* sum of times of prepared query execution (up to autoprepare_threshold measurements) */ + double non_prepared_time_sum2; /* sum of squares of non-prepared query execution (up to autoprepare_threshold measurements) */ + double prepared_time_sum2; /* sum of squares of prepared query execution (up to autoprepare_threshold measurements) */ } plan_cache_entry; static uint32 plan_cache_hash_fn(const void *key, Size keysize) @@ -4652,11 +4654,13 @@ static void end_exec_simple(void) { long secs; int usecs; + uint64 elapsed; TimestampDifference(exec_start_timestamp, GetCurrentTimestamp(), &secs, &usecs); - - entry->non_prepared_time += secs * USECS_PER_SEC + usecs; + elapsed = secs * USECS_PER_SEC + usecs; + entry->non_prepared_time_sum += elapsed; + entry->non_prepared_time_sum2 += elapsed*elapsed; } } @@ -5031,8 +5035,10 @@ static bool exec_cached_query(const char *query_string, List *parsetree_list) autoprepare_cached_plans -= 1; } entry->exec_count = 0; - entry->prepared_time = 0; - entry->non_prepared_time = 0; + entry->prepared_time_sum = 0; + entry->non_prepared_time_sum = 0; + entry->prepared_time_sum2 = 0; + entry->non_prepared_time_sum2 = 0; entry->plan = NULL; entry->disable_autoprepare = false; } @@ -5358,24 +5364,32 @@ static bool exec_cached_query(const char *query_string, List *parsetree_list) /* Calculate average time of execution of prepared query */ long secs; int usecs; + uint64 elapsed; TimestampDifference(exec_start_timestamp, GetCurrentTimestamp(), &secs, &usecs); - - entry->prepared_time += secs * USECS_PER_SEC + usecs; + elapsed = secs * USECS_PER_SEC + usecs; + entry->prepared_time_sum += elapsed; + entry->prepared_time_sum2 += elapsed*elapsed; if (entry->exec_count == autoprepare_threshold*2) { /* Now we can compare average times of prepared and non-prepared queries execution */ - if (entry->prepared_time > entry->non_prepared_time) + int n = autoprepare_threshold; + double prepared_time_deviation = sqrt((entry->prepared_time_sum2 - (double)entry->prepared_time_sum*entry->prepared_time_sum/n)/n); + double non_prepared_time_deviation = sqrt((entry->non_prepared_time_sum2 - (double)entry->non_prepared_time_sum*entry->non_prepared_time_sum/n)/n); + if (entry->prepared_time_sum - prepared_time_deviation*n > entry->non_prepared_time_sum + non_prepared_time_deviation*n) { /* * Disable autoprepare if average time of execution of prepared query * is worser than of non-prepared query */ entry->disable_autoprepare = true; - elog(LOG, "Disable autoprepared plan for %s because its average time %ld is greater than time of non-prepared query %ld", - query_string, entry->prepared_time, entry->non_prepared_time); + elog(LOG, "Disable autoprepared plan for %s (generic cost=%lg, avg custom cost=%lg, avg=%lg, dev=%lg) because its worser than non-prepared plan (avg=%lg, dev=%lg)", + query_string, + psrc->generic_cost, psrc->num_custom_plans != 0 ? psrc->total_custom_cost/psrc->num_custom_plans : 0, + (double)entry->prepared_time_sum/n, prepared_time_deviation, + (double)entry->non_prepared_time_sum/n, non_prepared_time_deviation); } } } From 28aa4525d02320144c53a70954cc218c029de0f4 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 22 May 2017 15:03:47 +0300 Subject: [PATCH 0078/1139] Fix multimaster build --- contrib/mmts/pglogical_apply.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contrib/mmts/pglogical_apply.c b/contrib/mmts/pglogical_apply.c index 8092add151..39ad5cec53 100644 --- a/contrib/mmts/pglogical_apply.c +++ b/contrib/mmts/pglogical_apply.c @@ -101,7 +101,7 @@ find_pkey_tuple(ScanKey skey, Relation rel, Relation idxrel, InitDirtySnapshot(snap); scan = index_beginscan(rel, idxrel, &snap, - IndexRelationGetNumberOfAttributes(idxrel), + RelationGetNumberOfAttributes(idxrel), 0); retry: From d8ba357db1382315f7746d98d6b67db47640366c Mon Sep 17 00:00:00 2001 From: Magnus Hagander Date: Tue, 23 May 2017 13:58:11 -0400 Subject: [PATCH 0079/1139] Update URLs in pgindent source and README Website and buildfarm is https, not http, and the ftp protocol will be shut down shortly. --- src/tools/pgindent/README | 6 +++--- src/tools/pgindent/pgindent | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/tools/pgindent/README b/src/tools/pgindent/README index 8e91697bd1..8f86afc5c0 100644 --- a/src/tools/pgindent/README +++ b/src/tools/pgindent/README @@ -30,9 +30,9 @@ DOING THE INDENT RUN: 3) Download the latest typedef file from the buildfarm: - wget -O src/tools/pgindent/typedefs.list http://buildfarm.postgresql.org/cgi-bin/typedefs.pl + wget -O src/tools/pgindent/typedefs.list https://buildfarm.postgresql.org/cgi-bin/typedefs.pl - (See http://www.pgbuildfarm.org/cgi-bin/typedefs.pl?show_list for a full + (See https://www.pgbuildfarm.org/cgi-bin/typedefs.pl?show_list for a full list of typedef files, if you want to indent some back branch.) 4) Run pgindent on the C files: @@ -108,7 +108,7 @@ BSD indent We have standardized on NetBSD's indent, and renamed it pg_bsd_indent. We have fixed a few bugs which requre the NetBSD source to be patched with indent.bsd.patch patch. A fully patched version is available at -ftp://ftp.postgresql.org/pub/dev. +https://ftp.postgresql.org/pub/dev. GNU indent, version 2.2.6, has several problems, and is not recommended. These bugs become pretty major when you are doing >500k lines of code. diff --git a/src/tools/pgindent/pgindent b/src/tools/pgindent/pgindent index 0d3859d029..85ce57079d 100755 --- a/src/tools/pgindent/pgindent +++ b/src/tools/pgindent/pgindent @@ -453,7 +453,7 @@ sub run_build chdir "$code_base/src/tools/pgindent"; my $typedefs_list_url = - "http://buildfarm.postgresql.org/cgi-bin/typedefs.pl"; + "https://buildfarm.postgresql.org/cgi-bin/typedefs.pl"; my $rv = getstore($typedefs_list_url, "tmp_typedefs.list"); @@ -463,7 +463,7 @@ sub run_build $ENV{PGTYPEDEFS} = abs_path('tmp_typedefs.list'); my $pg_bsd_indent_url = - "ftp://ftp.postgresql.org/pub/dev/pg_bsd_indent-" + "https://ftp.postgresql.org/pub/dev/pg_bsd_indent-" . $INDENT_VERSION . ".tar.gz"; From 8527132e52782e36b81abb53fc56fd111739dbbf Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 24 May 2017 15:28:34 -0400 Subject: [PATCH 0080/1139] Tighten checks for whitespace in functions that parse identifiers etc. This patch replaces isspace() calls with scanner_isspace() in functions that are likely to be presented with non-ASCII input. isspace() has the small advantage that it will correctly recognize no-break space in single-byte encodings (such as LATIN1); but it cannot work successfully for any multibyte character, and depending on platform it might return false positive results for some fragments of multibyte characters. That's disastrous for functions that are trying to discard whitespace between valid strings, as noted in bug #14662 from Justin Muise. Even treating no-break space as whitespace is pretty questionable for the usages touched here, because the core scanner would think it is an identifier character. Affected functions are parse_ident(), parseNameAndArgTypes (underlying regprocedurein() and siblings), SplitIdentifierString (used for parsing GUCs and options that are qualified names or lists of names), and SplitDirectoriesString (used for parsing GUCs that are lists of directories). All the functions adjusted here are parsing SQL identifiers and similar constructs, so it's reasonable to insist that their definition of whitespace match the core scanner. So we can hope that this won't cause many backwards-compatibility problems. I've left alone isspace() calls in places that aren't really expecting any non-ASCII input characters, such as float8in(). Back-patch to all supported branches. Discussion: https://postgr.es/m/10129.1495302480@sss.pgh.pa.us --- src/backend/utils/adt/misc.c | 6 +++--- src/backend/utils/adt/regproc.c | 7 ++++--- src/backend/utils/adt/varlena.c | 16 ++++++++-------- 3 files changed, 15 insertions(+), 14 deletions(-) diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c index 5e705e9308..3aff7caf9e 100644 --- a/src/backend/utils/adt/misc.c +++ b/src/backend/utils/adt/misc.c @@ -775,7 +775,7 @@ parse_ident(PG_FUNCTION_ARGS) nextp = qualname_str; /* skip leading whitespace */ - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; for (;;) @@ -863,14 +863,14 @@ parse_ident(PG_FUNCTION_ARGS) text_to_cstring(qualname)))); } - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; if (*nextp == '.') { after_dot = true; nextp++; - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; } else if (*nextp == '\0') diff --git a/src/backend/utils/adt/regproc.c b/src/backend/utils/adt/regproc.c index 394042cbba..210253cf42 100644 --- a/src/backend/utils/adt/regproc.c +++ b/src/backend/utils/adt/regproc.c @@ -35,6 +35,7 @@ #include "lib/stringinfo.h" #include "miscadmin.h" #include "parser/parse_type.h" +#include "parser/scansup.h" #include "utils/builtins.h" #include "utils/fmgroids.h" #include "utils/lsyscache.h" @@ -1911,7 +1912,7 @@ parseNameAndArgTypes(const char *string, bool allowNone, List **names, ptr2 = ptr + strlen(ptr); while (--ptr2 > ptr) { - if (!isspace((unsigned char) *ptr2)) + if (!scanner_isspace(*ptr2)) break; } if (*ptr2 != ')') @@ -1928,7 +1929,7 @@ parseNameAndArgTypes(const char *string, bool allowNone, List **names, for (;;) { /* allow leading whitespace */ - while (isspace((unsigned char) *ptr)) + while (scanner_isspace(*ptr)) ptr++; if (*ptr == '\0') { @@ -1984,7 +1985,7 @@ parseNameAndArgTypes(const char *string, bool allowNone, List **names, /* Lop off trailing whitespace */ while (--ptr2 >= typename) { - if (!isspace((unsigned char) *ptr2)) + if (!scanner_isspace(*ptr2)) break; *ptr2 = '\0'; } diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c index bf7c0cd735..55876bb795 100644 --- a/src/backend/utils/adt/varlena.c +++ b/src/backend/utils/adt/varlena.c @@ -3133,7 +3133,7 @@ SplitIdentifierString(char *rawstring, char separator, *namelist = NIL; - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; /* skip leading whitespace */ if (*nextp == '\0') @@ -3171,7 +3171,7 @@ SplitIdentifierString(char *rawstring, char separator, curname = nextp; while (*nextp && *nextp != separator && - !isspace((unsigned char) *nextp)) + !scanner_isspace(*nextp)) nextp++; endp = nextp; if (curname == nextp) @@ -3193,13 +3193,13 @@ SplitIdentifierString(char *rawstring, char separator, pfree(downname); } - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; /* skip trailing whitespace */ if (*nextp == separator) { nextp++; - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; /* skip leading whitespace for next */ /* we expect another name, so done remains false */ } @@ -3258,7 +3258,7 @@ SplitDirectoriesString(char *rawstring, char separator, *namelist = NIL; - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; /* skip leading whitespace */ if (*nextp == '\0') @@ -3295,7 +3295,7 @@ SplitDirectoriesString(char *rawstring, char separator, while (*nextp && *nextp != separator) { /* trailing whitespace should not be included in name */ - if (!isspace((unsigned char) *nextp)) + if (!scanner_isspace(*nextp)) endp = nextp + 1; nextp++; } @@ -3303,13 +3303,13 @@ SplitDirectoriesString(char *rawstring, char separator, return false; /* empty unquoted name not allowed */ } - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; /* skip trailing whitespace */ if (*nextp == separator) { nextp++; - while (isspace((unsigned char) *nextp)) + while (scanner_isspace(*nextp)) nextp++; /* skip leading whitespace for next */ /* we expect another name, so done remains false */ } From 50d9476920b5c0dac159247c4e640a1519396cee Mon Sep 17 00:00:00 2001 From: Magnus Hagander Date: Fri, 26 May 2017 10:58:15 -0400 Subject: [PATCH 0081/1139] Remove docs mention of PGREALM variable This variable was only used with Kerberos v4. That support was removed in 2005, but we forgot to remove the documentation. Noted by Shinichi Matsuda --- doc/src/sgml/libpq.sgml | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml index 3a470fefac..983cf0d386 100644 --- a/doc/src/sgml/libpq.sgml +++ b/doc/src/sgml/libpq.sgml @@ -6891,22 +6891,6 @@ myEventProc(PGEventId evtId, void *evtInfo, void *passThrough) - - - - PGREALM - - PGREALM sets the Kerberos realm to use with - PostgreSQL, if it is different from the - local realm. If PGREALM is set, - libpq applications will attempt - authentication with servers for this realm and use separate ticket - files to avoid conflicts with local ticket files. This - environment variable is only used if GSSAPI authentication is - selected by the server. - - - From 5886c7d5893f88efe5de0bf78d9a1439d09c004a Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 26 May 2017 12:51:05 -0400 Subject: [PATCH 0082/1139] Fix pg_dump to not emit invalid SQL for an empty operator class. If an operator class has no operators or functions, and doesn't need a STORAGE clause, we emitted "CREATE OPERATOR CLASS ... AS ;" which is syntactically invalid. Fix by forcing a STORAGE clause to be emitted anyway in this case. (At some point we might consider changing the grammar to allow CREATE OPERATOR CLASS without an opclass_item_list. But probably we'd want to omit the AS in that case, so that wouldn't fix this pg_dump issue anyway.) It's been like this all along, so back-patch to all supported branches. Daniel Gustafsson, tweaked by me to avoid a dangling-pointer bug Discussion: https://postgr.es/m/D9E5FC64-7A37-4F3D-B946-7E4FB468F88A@yesql.se --- src/bin/pg_dump/pg_dump.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 1148d6a164..27a2a0c0a5 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -12771,7 +12771,8 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo) i_opcfamilynsp = PQfnumber(res, "opcfamilynsp"); i_amname = PQfnumber(res, "amname"); - opcintype = PQgetvalue(res, 0, i_opcintype); + /* opcintype may still be needed after we PQclear res */ + opcintype = pg_strdup(PQgetvalue(res, 0, i_opcintype)); opckeytype = PQgetvalue(res, 0, i_opckeytype); opcdefault = PQgetvalue(res, 0, i_opcdefault); /* opcfamily will still be needed after we PQclear res */ @@ -13005,6 +13006,15 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo) PQclear(res); + /* + * If needComma is still false it means we haven't added anything after + * the AS keyword. To avoid printing broken SQL, append a dummy STORAGE + * clause with the same datatype. This isn't sanctioned by the + * documentation, but actually DefineOpClass will treat it as a no-op. + */ + if (!needComma) + appendPQExpBuffer(q, "STORAGE %s", opcintype); + appendPQExpBufferStr(q, ";\n"); appendPQExpBuffer(labelq, "OPERATOR CLASS %s", @@ -13032,6 +13042,8 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo) opcinfo->dobj.namespace->dobj.name, opcinfo->rolname, opcinfo->dobj.catId, 0, opcinfo->dobj.dumpId); + free(opcintype); + free(opcfamily); free(amname); destroyPQExpBuffer(query); destroyPQExpBuffer(q); From acab87ece1a471290ff275541687dd5b843eec23 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 26 May 2017 15:16:59 -0400 Subject: [PATCH 0083/1139] Move autogenerated array types out of the way during ALTER ... RENAME. Commit 9aa3c782c added code to allow CREATE TABLE/CREATE TYPE to not fail when the desired type name conflicts with an autogenerated array type, by dint of renaming the array type out of the way. But I (tgl) overlooked that the same case arises in ALTER TABLE/TYPE RENAME. Fix that too. Back-patch to all supported branches. Report and patch by Vik Fearing, modified a bit by me Discussion: https://postgr.es/m/0f4ade49-4f0b-a9a3-c120-7589f01d1eb8@2ndquadrant.com --- src/backend/catalog/pg_type.c | 38 +++++++++++++----- src/test/regress/expected/alter_table.out | 49 +++++++++++++++++++++++ src/test/regress/sql/alter_table.sql | 20 +++++++++ 3 files changed, 98 insertions(+), 9 deletions(-) diff --git a/src/backend/catalog/pg_type.c b/src/backend/catalog/pg_type.c index 4b2d281f2c..525273ef3e 100644 --- a/src/backend/catalog/pg_type.c +++ b/src/backend/catalog/pg_type.c @@ -700,6 +700,7 @@ RenameTypeInternal(Oid typeOid, const char *newTypeName, Oid typeNamespace) HeapTuple tuple; Form_pg_type typ; Oid arrayOid; + Oid oldTypeOid; pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock); @@ -713,13 +714,28 @@ RenameTypeInternal(Oid typeOid, const char *newTypeName, Oid typeNamespace) arrayOid = typ->typarray; - /* Just to give a more friendly error than unique-index violation */ - if (SearchSysCacheExists2(TYPENAMENSP, - CStringGetDatum(newTypeName), - ObjectIdGetDatum(typeNamespace))) - ereport(ERROR, - (errcode(ERRCODE_DUPLICATE_OBJECT), - errmsg("type \"%s\" already exists", newTypeName))); + /* Check for a conflicting type name. */ + oldTypeOid = GetSysCacheOid2(TYPENAMENSP, + CStringGetDatum(newTypeName), + ObjectIdGetDatum(typeNamespace)); + + /* + * If there is one, see if it's an autogenerated array type, and if so + * rename it out of the way. (But we must skip that for a shell type + * because moveArrayTypeName will do the wrong thing in that case.) + * Otherwise, we can at least give a more friendly error than unique-index + * violation. + */ + if (OidIsValid(oldTypeOid)) + { + if (get_typisdefined(oldTypeOid) && + moveArrayTypeName(oldTypeOid, newTypeName, typeNamespace)) + /* successfully dodged the problem */ ; + else + ereport(ERROR, + (errcode(ERRCODE_DUPLICATE_OBJECT), + errmsg("type \"%s\" already exists", newTypeName))); + } /* OK, do the rename --- tuple is a copy, so OK to scribble on it */ namestrcpy(&(typ->typname), newTypeName); @@ -734,8 +750,12 @@ RenameTypeInternal(Oid typeOid, const char *newTypeName, Oid typeNamespace) heap_freetuple(tuple); heap_close(pg_type_desc, RowExclusiveLock); - /* If the type has an array type, recurse to handle that */ - if (OidIsValid(arrayOid)) + /* + * If the type has an array type, recurse to handle that. But we don't + * need to do anything more if we already renamed that array type above + * (which would happen when, eg, renaming "foo" to "_foo"). + */ + if (OidIsValid(arrayOid) && arrayOid != oldTypeOid) { char *arrname = makeArrayTypeName(newTypeName, typeNamespace); diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out index 3886d4e6bc..de9677c5b7 100644 --- a/src/test/regress/expected/alter_table.out +++ b/src/test/regress/expected/alter_table.out @@ -128,6 +128,55 @@ SELECT * FROM tmp_new2; DROP TABLE tmp_new; DROP TABLE tmp_new2; +-- +-- check renaming to a table's array type's autogenerated name +-- (the array type's name should get out of the way) +-- +CREATE TABLE tmp_array (id int); +CREATE TABLE tmp_array2 (id int); +SELECT typname FROM pg_type WHERE oid = 'tmp_array[]'::regtype; + typname +------------ + _tmp_array +(1 row) + +SELECT typname FROM pg_type WHERE oid = 'tmp_array2[]'::regtype; + typname +------------- + _tmp_array2 +(1 row) + +ALTER TABLE tmp_array2 RENAME TO _tmp_array; +SELECT typname FROM pg_type WHERE oid = 'tmp_array[]'::regtype; + typname +------------- + __tmp_array +(1 row) + +SELECT typname FROM pg_type WHERE oid = '_tmp_array[]'::regtype; + typname +-------------- + ___tmp_array +(1 row) + +DROP TABLE _tmp_array; +DROP TABLE tmp_array; +-- renaming to table's own array type's name is an interesting corner case +CREATE TABLE tmp_array (id int); +SELECT typname FROM pg_type WHERE oid = 'tmp_array[]'::regtype; + typname +------------ + _tmp_array +(1 row) + +ALTER TABLE tmp_array RENAME TO _tmp_array; +SELECT typname FROM pg_type WHERE oid = '_tmp_array[]'::regtype; + typname +------------- + __tmp_array +(1 row) + +DROP TABLE _tmp_array; -- ALTER TABLE ... RENAME on non-table relations -- renaming indexes (FIXME: this should probably test the index's functionality) ALTER INDEX IF EXISTS __onek_unique1 RENAME TO tmp_onek_unique1; diff --git a/src/test/regress/sql/alter_table.sql b/src/test/regress/sql/alter_table.sql index d01b8b0be3..fe78067ae7 100644 --- a/src/test/regress/sql/alter_table.sql +++ b/src/test/regress/sql/alter_table.sql @@ -165,6 +165,26 @@ SELECT * FROM tmp_new2; DROP TABLE tmp_new; DROP TABLE tmp_new2; +-- +-- check renaming to a table's array type's autogenerated name +-- (the array type's name should get out of the way) +-- +CREATE TABLE tmp_array (id int); +CREATE TABLE tmp_array2 (id int); +SELECT typname FROM pg_type WHERE oid = 'tmp_array[]'::regtype; +SELECT typname FROM pg_type WHERE oid = 'tmp_array2[]'::regtype; +ALTER TABLE tmp_array2 RENAME TO _tmp_array; +SELECT typname FROM pg_type WHERE oid = 'tmp_array[]'::regtype; +SELECT typname FROM pg_type WHERE oid = '_tmp_array[]'::regtype; +DROP TABLE _tmp_array; +DROP TABLE tmp_array; + +-- renaming to table's own array type's name is an interesting corner case +CREATE TABLE tmp_array (id int); +SELECT typname FROM pg_type WHERE oid = 'tmp_array[]'::regtype; +ALTER TABLE tmp_array RENAME TO _tmp_array; +SELECT typname FROM pg_type WHERE oid = '_tmp_array[]'::regtype; +DROP TABLE _tmp_array; -- ALTER TABLE ... RENAME on non-table relations -- renaming indexes (FIXME: this should probably test the index's functionality) From dd1daa03bc8e49f463f2d852f7afe6506f0bb612 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 29 May 2017 15:19:07 -0400 Subject: [PATCH 0084/1139] Allow NumericOnly to be "+ FCONST". The NumericOnly grammar production accepted ICONST, + ICONST, - ICONST, FCONST, and - FCONST, but for some reason not + FCONST. This led to strange inconsistencies like regression=# set random_page_cost = +4; SET regression=# set random_page_cost = 4000000000; SET regression=# set random_page_cost = +4000000000; ERROR: syntax error at or near "4000000000" (because 4000000000 is too large to be an ICONST). While there's no actual functional reason to need to write a "+", if we allow it for integers it seems like we should allow it for numerics too. It's been like that forever, so back-patch to all supported branches. Discussion: https://postgr.es/m/30908.1496006184@sss.pgh.pa.us --- src/backend/parser/gram.y | 1 + 1 file changed, 1 insertion(+) diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index ab189a3df2..c080cf9ea0 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -3688,6 +3688,7 @@ opt_by: BY {} NumericOnly: FCONST { $$ = makeFloat($1); } + | '+' FCONST { $$ = makeFloat($2); } | '-' FCONST { $$ = makeFloat($2); From 98bff290747e50b53f0076d69f239a13e032c7e1 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 29 May 2017 17:08:16 -0400 Subject: [PATCH 0085/1139] Prevent running pg_resetwal/pg_resetxlog against wrong-version data dirs. pg_resetwal (formerly pg_resetxlog) doesn't insist on finding a matching version number in pg_control, and that seems like an important thing to preserve since recovering from corrupt pg_control is a prime reason to need to run it. However, that means you can try to run it against a data directory of a different major version, which is at best useless and at worst disastrous. So as to provide some protection against that type of pilot error, inspect PG_VERSION at startup and refuse to do anything if it doesn't match. PG_VERSION is read-only after initdb, so it's unlikely to get corrupted, and even if it were corrupted it would be easy to fix by hand. This hazard has been there all along, so back-patch to all supported branches. Michael Paquier, with some kibitzing by me Discussion: https://postgr.es/m/f4b8eb91-b934-8a0d-b3cc-68f06e2279d1@enterprisedb.com --- doc/src/sgml/ref/pg_resetxlog.sgml | 5 +++ src/bin/pg_resetxlog/pg_resetxlog.c | 70 ++++++++++++++++++++++++++++- 2 files changed, 74 insertions(+), 1 deletion(-) diff --git a/doc/src/sgml/ref/pg_resetxlog.sgml b/doc/src/sgml/ref/pg_resetxlog.sgml index fd9d0be6f4..9758fa652a 100644 --- a/doc/src/sgml/ref/pg_resetxlog.sgml +++ b/doc/src/sgml/ref/pg_resetxlog.sgml @@ -281,6 +281,11 @@ PostgreSQL documentation pg_resetxlog to run. But before you do so, make doubly certain that there is no server process still alive. + + + pg_resetxlog works only with servers of the same + major version. + diff --git a/src/bin/pg_resetxlog/pg_resetxlog.c b/src/bin/pg_resetxlog/pg_resetxlog.c index 3ffff22daa..fdd75044de 100644 --- a/src/bin/pg_resetxlog/pg_resetxlog.c +++ b/src/bin/pg_resetxlog/pg_resetxlog.c @@ -72,6 +72,7 @@ static MultiXactOffset set_mxoff = (MultiXactOffset) -1; static uint32 minXlogTli = 0; static XLogSegNo minXlogSegNo = 0; +static void CheckDataVersion(void); static bool ReadControlFile(void); static void GuessControlValues(void); static void PrintControlValues(bool guessed); @@ -320,6 +321,9 @@ main(int argc, char *argv[]) exit(1); } + /* Check that data directory matches our server version */ + CheckDataVersion(); + /* * Check for a postmaster lock file --- if there is one, refuse to * proceed, on grounds we might be interfering with a live installation. @@ -453,6 +457,70 @@ main(int argc, char *argv[]) } +/* + * Look at the version string stored in PG_VERSION and decide if this utility + * can be run safely or not. + * + * We don't want to inject pg_control and WAL files that are for a different + * major version; that can't do anything good. Note that we don't treat + * mismatching version info in pg_control as a reason to bail out, because + * recovering from a corrupted pg_control is one of the main reasons for this + * program to exist at all. However, PG_VERSION is unlikely to get corrupted, + * and if it were it would be easy to fix by hand. So let's make this check + * to prevent simple user errors. + */ +static void +CheckDataVersion(void) +{ + const char *ver_file = "PG_VERSION"; + FILE *ver_fd; + char rawline[64]; + int len; + + if ((ver_fd = fopen(ver_file, "r")) == NULL) + { + fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"), + progname, ver_file, strerror(errno)); + exit(1); + } + + /* version number has to be the first line read */ + if (!fgets(rawline, sizeof(rawline), ver_fd)) + { + if (!ferror(ver_fd)) + { + fprintf(stderr, _("%s: unexpected empty file \"%s\"\n"), + progname, ver_file); + } + else + { + fprintf(stderr, _("%s: could not read file \"%s\": %s\n"), + progname, ver_file, strerror(errno)); + } + exit(1); + } + + /* remove trailing newline, handling Windows newlines as well */ + len = strlen(rawline); + if (len > 0 && rawline[len - 1] == '\n') + { + rawline[--len] = '\0'; + if (len > 0 && rawline[len - 1] == '\r') + rawline[--len] = '\0'; + } + + if (strcmp(rawline, PG_MAJORVERSION) != 0) + { + fprintf(stderr, _("%s: data directory is of wrong version\n" + "File \"%s\" contains \"%s\", which is not compatible with this program's version \"%s\".\n"), + progname, ver_file, rawline, PG_MAJORVERSION); + exit(1); + } + + fclose(ver_fd); +} + + /* * Try to read the existing pg_control file. * @@ -522,7 +590,7 @@ ReadControlFile(void) } /* Looks like it's a mess. */ - fprintf(stderr, _("%s: pg_control exists but is broken or unknown version; ignoring it\n"), + fprintf(stderr, _("%s: pg_control exists but is broken or wrong version; ignoring it\n"), progname); return false; } From 34782a348d0ea8bddc92844d24d9e75a06673ac0 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 29 May 2017 20:27:45 -0400 Subject: [PATCH 0086/1139] Try to ensure that stats collector's receive buffer size is at least 100KB. Back-patch of commit 8b0b6303e991079726e83d17401405e94da11564. Discussion: https://postgr.es/m/22173.1494788088@sss.pgh.pa.us --- src/backend/postmaster/pgstat.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c index 620ccdeb38..a3edfedc6f 100644 --- a/src/backend/postmaster/pgstat.c +++ b/src/backend/postmaster/pgstat.c @@ -92,6 +92,9 @@ #define PGSTAT_POLL_LOOP_COUNT (PGSTAT_MAX_WAIT_TIME / PGSTAT_RETRY_DELAY) #define PGSTAT_INQ_LOOP_COUNT (PGSTAT_INQ_INTERVAL / PGSTAT_RETRY_DELAY) +/* Minimum receive buffer size for the collector's socket. */ +#define PGSTAT_MIN_RCVBUF (100 * 1024) + /* ---------- * The initial size hints for the hash tables used in the collector. @@ -537,6 +540,35 @@ pgstat_init(void) goto startup_failed; } + /* + * Try to ensure that the socket's receive buffer is at least + * PGSTAT_MIN_RCVBUF bytes, so that it won't easily overflow and lose + * data. Use of UDP protocol means that we are willing to lose data under + * heavy load, but we don't want it to happen just because of ridiculously + * small default buffer sizes (such as 8KB on older Windows versions). + */ + { + int old_rcvbuf; + int new_rcvbuf; + ACCEPT_TYPE_ARG3 rcvbufsize = sizeof(old_rcvbuf); + + if (getsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF, + (char *) &old_rcvbuf, &rcvbufsize) < 0) + { + elog(LOG, "getsockopt(SO_RCVBUF) failed: %m"); + /* if we can't get existing size, always try to set it */ + old_rcvbuf = 0; + } + + new_rcvbuf = PGSTAT_MIN_RCVBUF; + if (old_rcvbuf < new_rcvbuf) + { + if (setsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF, + (char *) &new_rcvbuf, sizeof(new_rcvbuf)) < 0) + elog(LOG, "setsockopt(SO_RCVBUF) failed: %m"); + } + } + pg_freeaddrinfo_all(hints.ai_family, addrs); return; From 1849b72169cdfb60794766c6fc6593bcc7c9a936 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Tue, 30 May 2017 15:45:42 -0400 Subject: [PATCH 0087/1139] Fix wording in amvalidate error messages Remove some gratuituous message differences by making the AM name previously embedded in each message be a %s instead. While at it, get rid of terminology that's unclear and unnecessary in one message. Discussion: https://postgr.es/m/20170523001557.bq2hbq7hxyvyw62q@alvherre.pgsql --- src/backend/access/brin/brin_validate.c | 36 +++++++++++----------- src/backend/access/gin/ginvalidate.c | 32 ++++++++++---------- src/backend/access/gist/gistvalidate.c | 32 ++++++++++---------- src/backend/access/hash/hashvalidate.c | 40 ++++++++++++------------- src/backend/access/nbtree/nbtvalidate.c | 36 +++++++++++----------- src/backend/access/spgist/spgvalidate.c | 36 +++++++++++----------- 6 files changed, 106 insertions(+), 106 deletions(-) diff --git a/src/backend/access/brin/brin_validate.c b/src/backend/access/brin/brin_validate.c index 1f1011e0ac..083fcbebed 100644 --- a/src/backend/access/brin/brin_validate.c +++ b/src/backend/access/brin/brin_validate.c @@ -112,8 +112,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator family \"%s\" contains function %s with invalid support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d", + opfamilyname, "brin", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -128,8 +128,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator family \"%s\" contains function %s with wrong signature for support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d", + opfamilyname, "brin", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -150,8 +150,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator family \"%s\" contains operator %s with invalid strategy number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d", + opfamilyname, "brin", format_operator(oprform->amopopr), oprform->amopstrategy))); result = false; @@ -179,8 +179,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator family \"%s\" contains invalid ORDER BY specification for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s", + opfamilyname, "brin", format_operator(oprform->amopopr)))); result = false; } @@ -192,8 +192,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator family \"%s\" contains operator %s with wrong signature", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature", + opfamilyname, "brin", format_operator(oprform->amopopr)))); result = false; } @@ -230,8 +230,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator family \"%s\" is missing operator(s) for types %s and %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s", + opfamilyname, "brin", format_type_be(thisgroup->lefttype), format_type_be(thisgroup->righttype)))); result = false; @@ -240,8 +240,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator family \"%s\" is missing support function(s) for types %s and %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s is missing support function(s) for types %s and %s", + opfamilyname, "brin", format_type_be(thisgroup->lefttype), format_type_be(thisgroup->righttype)))); result = false; @@ -253,8 +253,8 @@ brinvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator class \"%s\" is missing operator(s)", - opclassname))); + errmsg("operator class \"%s\" of access method %s is missing operator(s)", + opclassname, "brin"))); result = false; } for (i = 1; i <= BRIN_MANDATORY_NPROCS; i++) @@ -264,8 +264,8 @@ brinvalidate(Oid opclassoid) continue; /* got it */ ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("brin operator class \"%s\" is missing support function %d", - opclassname, i))); + errmsg("operator class \"%s\" of access method %s is missing support function %d", + opclassname, "brin", i))); result = false; } diff --git a/src/backend/access/gin/ginvalidate.c b/src/backend/access/gin/ginvalidate.c index 032508387d..3451809ac2 100644 --- a/src/backend/access/gin/ginvalidate.c +++ b/src/backend/access/gin/ginvalidate.c @@ -89,8 +89,8 @@ ginvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator family \"%s\" contains support procedure %s with cross-type registration", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains support procedure %s with different left and right input types", + opfamilyname, "gin", format_procedure(procform->amproc)))); result = false; } @@ -145,8 +145,8 @@ ginvalidate(Oid opclassoid) default: ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator family \"%s\" contains function %s with invalid support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d", + opfamilyname, "gin", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -157,8 +157,8 @@ ginvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator family \"%s\" contains function %s with wrong signature for support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d", + opfamilyname, "gin", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -176,8 +176,8 @@ ginvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator family \"%s\" contains operator %s with invalid strategy number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d", + opfamilyname, "gin", format_operator(oprform->amopopr), oprform->amopstrategy))); result = false; @@ -189,8 +189,8 @@ ginvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator family \"%s\" contains invalid ORDER BY specification for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s", + opfamilyname, "gin", format_operator(oprform->amopopr)))); result = false; } @@ -202,8 +202,8 @@ ginvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator family \"%s\" contains operator %s with wrong signature", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature", + opfamilyname, "gin", format_operator(oprform->amopopr)))); result = false; } @@ -243,8 +243,8 @@ ginvalidate(Oid opclassoid) continue; /* don't need both, see check below loop */ ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator class \"%s\" is missing support function %d", - opclassname, i))); + errmsg("operator class \"%s\" of access method %s is missing support function %d", + opclassname, "gin", i))); result = false; } if (!opclassgroup || @@ -253,8 +253,8 @@ ginvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gin operator class \"%s\" is missing support function %d or %d", - opclassname, + errmsg("operator class \"%s\" of access method %s is missing support function %d or %d", + opclassname, "gin", GIN_CONSISTENT_PROC, GIN_TRICONSISTENT_PROC))); result = false; } diff --git a/src/backend/access/gist/gistvalidate.c b/src/backend/access/gist/gistvalidate.c index ffd7fd631b..a8b49cd4ba 100644 --- a/src/backend/access/gist/gistvalidate.c +++ b/src/backend/access/gist/gistvalidate.c @@ -89,8 +89,8 @@ gistvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator family \"%s\" contains support procedure %s with cross-type registration", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains support procedure %s with different left and right input types", + opfamilyname, "gist", format_procedure(procform->amproc)))); result = false; } @@ -142,8 +142,8 @@ gistvalidate(Oid opclassoid) default: ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator family \"%s\" contains function %s with invalid support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d", + opfamilyname, "gist", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -154,8 +154,8 @@ gistvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator family \"%s\" contains function %s with wrong signature for support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d", + opfamilyname, "gist", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -174,8 +174,8 @@ gistvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator family \"%s\" contains operator %s with invalid strategy number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d", + opfamilyname, "gist", format_operator(oprform->amopopr), oprform->amopstrategy))); result = false; @@ -192,8 +192,8 @@ gistvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator family \"%s\" contains unsupported ORDER BY specification for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains unsupported ORDER BY specification for operator %s", + opfamilyname, "gist", format_operator(oprform->amopopr)))); result = false; } @@ -203,8 +203,8 @@ gistvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator family \"%s\" contains incorrect ORDER BY opfamily specification for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains incorrect ORDER BY opfamily specification for operator %s", + opfamilyname, "gist", format_operator(oprform->amopopr)))); result = false; } @@ -222,8 +222,8 @@ gistvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator family \"%s\" contains operator %s with wrong signature", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature", + opfamilyname, "gist", format_operator(oprform->amopopr)))); result = false; } @@ -261,8 +261,8 @@ gistvalidate(Oid opclassoid) continue; /* optional methods */ ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("gist operator class \"%s\" is missing support function %d", - opclassname, i))); + errmsg("operator class \"%s\" of access method %s is missing support function %d", + opclassname, "gist", i))); result = false; } diff --git a/src/backend/access/hash/hashvalidate.c b/src/backend/access/hash/hashvalidate.c index d8c5ed4d98..e05284befd 100644 --- a/src/backend/access/hash/hashvalidate.c +++ b/src/backend/access/hash/hashvalidate.c @@ -95,8 +95,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" contains support procedure %s with cross-type registration", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains support procedure %s with different left and right input types", + opfamilyname, "hash", format_procedure(procform->amproc)))); result = false; } @@ -110,8 +110,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" contains function %s with wrong signature for support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d", + opfamilyname, "hash", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -127,8 +127,8 @@ hashvalidate(Oid opclassoid) default: ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" contains function %s with invalid support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d", + opfamilyname, "hash", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -148,8 +148,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" contains operator %s with invalid strategy number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d", + opfamilyname, "hash", format_operator(oprform->amopopr), oprform->amopstrategy))); result = false; @@ -161,8 +161,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" contains invalid ORDER BY specification for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s", + opfamilyname, "hash", format_operator(oprform->amopopr)))); result = false; } @@ -174,8 +174,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" contains operator %s with wrong signature", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature", + opfamilyname, "hash", format_operator(oprform->amopopr)))); result = false; } @@ -186,8 +186,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" lacks support function for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s lacks support function for operator %s", + opfamilyname, "hash", format_operator(oprform->amopopr)))); result = false; } @@ -214,8 +214,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" is missing operator(s) for types %s and %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s", + opfamilyname, "hash", format_type_be(thisgroup->lefttype), format_type_be(thisgroup->righttype)))); result = false; @@ -228,8 +228,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator class \"%s\" is missing operator(s)", - opclassname))); + errmsg("operator class \"%s\" of access method %s is missing operator(s)", + opclassname, "hash"))); result = false; } @@ -244,8 +244,8 @@ hashvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("hash operator family \"%s\" is missing cross-type operator(s)", - opfamilyname))); + errmsg("operator family \"%s\" of access method %s is missing cross-type operator(s)", + opfamilyname, "hash"))); result = false; } diff --git a/src/backend/access/nbtree/nbtvalidate.c b/src/backend/access/nbtree/nbtvalidate.c index 7d0bdabc1d..5c7192fbbd 100644 --- a/src/backend/access/nbtree/nbtvalidate.c +++ b/src/backend/access/nbtree/nbtvalidate.c @@ -97,8 +97,8 @@ btvalidate(Oid opclassoid) default: ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" contains function %s with invalid support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d", + opfamilyname, "btree", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -109,8 +109,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" contains function %s with wrong signature for support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d", + opfamilyname, "btree", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -129,8 +129,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" contains operator %s with invalid strategy number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d", + opfamilyname, "btree", format_operator(oprform->amopopr), oprform->amopstrategy))); result = false; @@ -142,8 +142,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" contains invalid ORDER BY specification for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s", + opfamilyname, "btree", format_operator(oprform->amopopr)))); result = false; } @@ -155,8 +155,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" contains operator %s with wrong signature", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature", + opfamilyname, "btree", format_operator(oprform->amopopr)))); result = false; } @@ -197,8 +197,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" is missing operator(s) for types %s and %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s", + opfamilyname, "btree", format_type_be(thisgroup->lefttype), format_type_be(thisgroup->righttype)))); result = false; @@ -207,8 +207,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" is missing support function for types %s and %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s is missing support function for types %s and %s", + opfamilyname, "btree", format_type_be(thisgroup->lefttype), format_type_be(thisgroup->righttype)))); result = false; @@ -221,8 +221,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator class \"%s\" is missing operator(s)", - opclassname))); + errmsg("operator class \"%s\" of access method %s is missing operator(s)", + opclassname, "btree"))); result = false; } @@ -238,8 +238,8 @@ btvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("btree operator family \"%s\" is missing cross-type operator(s)", - opfamilyname))); + errmsg("operator family \"%s\" of access method %s is missing cross-type operator(s)", + opfamilyname, "btree"))); result = false; } diff --git a/src/backend/access/spgist/spgvalidate.c b/src/backend/access/spgist/spgvalidate.c index 6297111a7c..9cee2f27c9 100644 --- a/src/backend/access/spgist/spgvalidate.c +++ b/src/backend/access/spgist/spgvalidate.c @@ -89,8 +89,8 @@ spgvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" contains support procedure %s with cross-type registration", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains support procedure %s with different left and right input types", + opfamilyname, "spgist", format_procedure(procform->amproc)))); result = false; } @@ -112,8 +112,8 @@ spgvalidate(Oid opclassoid) default: ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" contains function %s with invalid support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d", + opfamilyname, "spgist", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -124,8 +124,8 @@ spgvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" contains function %s with wrong signature for support number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d", + opfamilyname, "spgist", format_procedure(procform->amproc), procform->amprocnum))); result = false; @@ -143,8 +143,8 @@ spgvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" contains operator %s with invalid strategy number %d", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d", + opfamilyname, "spgist", format_operator(oprform->amopopr), oprform->amopstrategy))); result = false; @@ -156,8 +156,8 @@ spgvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" contains invalid ORDER BY specification for operator %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s", + opfamilyname, "spgist", format_operator(oprform->amopopr)))); result = false; } @@ -169,8 +169,8 @@ spgvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" contains operator %s with wrong signature", - opfamilyname, + errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature", + opfamilyname, "spgist", format_operator(oprform->amopopr)))); result = false; } @@ -197,8 +197,8 @@ spgvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" is missing operator(s) for types %s and %s", - opfamilyname, + errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s", + opfamilyname, "spgist", format_type_be(thisgroup->lefttype), format_type_be(thisgroup->righttype)))); result = false; @@ -217,8 +217,8 @@ spgvalidate(Oid opclassoid) continue; /* got it */ ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator family \"%s\" is missing support function %d for type %s", - opfamilyname, i, + errmsg("operator family \"%s\" of access method %s is missing support function %d for type %s", + opfamilyname, "spgist", i, format_type_be(thisgroup->lefttype)))); result = false; } @@ -230,8 +230,8 @@ spgvalidate(Oid opclassoid) { ereport(INFO, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("spgist operator class \"%s\" is missing operator(s)", - opclassname))); + errmsg("operator class \"%s\" of access method %s is missing operator(s)", + opclassname, "spgist"))); result = false; } From 8d9b4fe01b5e717ad85d3a3beeabf8e212524b04 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 1 Jun 2017 13:32:56 -0400 Subject: [PATCH 0088/1139] Always use -fPIC, not -fpic, when building shared libraries with gcc. On some platforms, -fpic fails for sufficiently large shared libraries. We've mostly not hit that boundary yet, but there are some extensions such as Citus and pglogical where it's becoming a problem. A bit of research suggests that the penalty for -fPIC is small, in the single-digit-percentage range --- and there's none at all on popular platforms such as x86_64. So let's just default to -fPIC everywhere and provide one less thing for extension developers to worry about. Per complaint from Christoph Berg. Back-patch to all supported branches. (I did not bother to touch the recently-removed Makefiles for sco and unixware in the back branches, though. We'd have no way to test that it doesn't break anything on those platforms.) Discussion: https://postgr.es/m/20170529155850.qojdfrwkkqnjb3ap@msg.df7cb.de --- doc/src/sgml/dfunc.sgml | 26 ++++++++++++-------------- src/makefiles/Makefile.linux | 7 +++---- src/makefiles/Makefile.netbsd | 4 ---- src/makefiles/Makefile.openbsd | 4 ---- 4 files changed, 15 insertions(+), 26 deletions(-) diff --git a/doc/src/sgml/dfunc.sgml b/doc/src/sgml/dfunc.sgml index 5a368f6df0..ebc85bf54b 100644 --- a/doc/src/sgml/dfunc.sgml +++ b/doc/src/sgml/dfunc.sgml @@ -63,10 +63,10 @@ The compiler flag to create PIC is - . To create shared libraries the compiler + . To create shared libraries the compiler flag is . -gcc -fpic -c foo.c +gcc -fPIC -c foo.c gcc -shared -o foo.so foo.o This is applicable as of version 3.0 of @@ -84,14 +84,14 @@ gcc -shared -o foo.so foo.o The compiler flag of the system compiler to create PIC is . When using - GCC it's . The + GCC it's . The linker flag for shared libraries is . So: cc +z -c foo.c or: -gcc -fpic -c foo.c +gcc -fPIC -c foo.c and then: @@ -112,13 +112,11 @@ ld -b -o foo.sl foo.o The compiler flag to create PIC is - . On some platforms in some situations - must be used if - does not work. Refer to the GCC manual for more information. + . The compiler flag to create a shared library is . A complete example looks like this: -cc -fpic -c foo.c +cc -fPIC -c foo.c cc -shared -o foo.so foo.o @@ -149,12 +147,12 @@ cc -bundle -flat_namespace -undefined suppress -o foo.so foo.o The compiler flag to create PIC is - . For ELF systems, the + . For ELF systems, the compiler with the flag is used to link shared libraries. On the older non-ELF systems, ld -Bshareable is used. -gcc -fpic -c foo.c +gcc -fPIC -c foo.c gcc -shared -o foo.so foo.o @@ -169,10 +167,10 @@ gcc -shared -o foo.so foo.o The compiler flag to create PIC is - . ld -Bshareable is + . ld -Bshareable is used to link shared libraries. -gcc -fpic -c foo.c +gcc -fPIC -c foo.c ld -Bshareable -o foo.so foo.o @@ -188,7 +186,7 @@ ld -Bshareable -o foo.so foo.o The compiler flag to create PIC is with the Sun compiler and - with GCC. To + with GCC. To link shared libraries, the compiler option is with either compiler or alternatively with GCC. @@ -198,7 +196,7 @@ cc -G -o foo.so foo.o or -gcc -fpic -c foo.c +gcc -fPIC -c foo.c gcc -G -o foo.so foo.o diff --git a/src/makefiles/Makefile.linux b/src/makefiles/Makefile.linux index 52bf0b1e2b..f4f091caef 100644 --- a/src/makefiles/Makefile.linux +++ b/src/makefiles/Makefile.linux @@ -1,15 +1,14 @@ AROPT = crs + export_dynamic = -Wl,-E # Use --enable-new-dtags to generate DT_RUNPATH instead of DT_RPATH. # This allows LD_LIBRARY_PATH to still work when needed. rpath = -Wl,-rpath,'$(rpathdir)',--enable-new-dtags + DLSUFFIX = .so -ifeq "$(findstring sparc,$(host_cpu))" "sparc" CFLAGS_SL = -fPIC -else -CFLAGS_SL = -fpic -endif + # Rule for building a shared library from a single .o file %.so: %.o diff --git a/src/makefiles/Makefile.netbsd b/src/makefiles/Makefile.netbsd index 31a52601af..43841c1597 100644 --- a/src/makefiles/Makefile.netbsd +++ b/src/makefiles/Makefile.netbsd @@ -9,11 +9,7 @@ endif DLSUFFIX = .so -ifeq ($(findstring sparc,$(host_cpu)), sparc) CFLAGS_SL = -fPIC -DPIC -else -CFLAGS_SL = -fpic -DPIC -endif # Rule for building a shared library from a single .o file diff --git a/src/makefiles/Makefile.openbsd b/src/makefiles/Makefile.openbsd index 7bf5493309..d8fde49d5c 100644 --- a/src/makefiles/Makefile.openbsd +++ b/src/makefiles/Makefile.openbsd @@ -7,11 +7,7 @@ endif DLSUFFIX = .so -ifeq ($(findstring sparc,$(host_cpu)), sparc) CFLAGS_SL = -fPIC -DPIC -else -CFLAGS_SL = -fpic -DPIC -endif # Rule for building a shared library from a single .o file From 8a7cd781ee9486584c1262b0f8598b1162ceb73a Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Fri, 2 Jun 2017 19:05:57 -0700 Subject: [PATCH 0089/1139] Allow parallelism in COPY (query) TO ...; Previously this was not allowed, as copy.c didn't set the CURSOR_OPT_PARALLEL_OK flag when planning the query. Set it. While the lack of parallel query for COPY isn't strictly speaking a bug, it does prevent parallelism from being used in a facility commonly used to run long running queries. Thus backpatch to 9.6. Author: Andres Freund Discussion: https://postgr.es/m/20170531231958.ihanapplorptykzm@alap3.anarazel.de Backpatch: 9.6, where parallelism was introduced. --- src/backend/commands/copy.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c index db6ef78314..41a828c2fe 100644 --- a/src/backend/commands/copy.c +++ b/src/backend/commands/copy.c @@ -1491,7 +1491,7 @@ BeginCopy(bool is_from, } /* plan the query */ - plan = pg_plan_query(query, 0, NULL); + plan = pg_plan_query(query, CURSOR_OPT_PARALLEL_OK, NULL); /* * With row level security and a user using "COPY relation TO", we From 55cd9a8ff6a7cc244a33776c447cb0f0f10b6b94 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Sun, 4 Jun 2017 11:41:16 -0400 Subject: [PATCH 0090/1139] Assorted translatable string fixes Mark our rusage reportage string translatable; remove quotes from type names; unify formatting of very similar messages. --- src/backend/access/brin/brin_pageops.c | 20 +++++++------------- src/backend/catalog/index.c | 2 +- src/backend/catalog/namespace.c | 2 +- src/backend/catalog/pg_aggregate.c | 2 +- src/backend/commands/vacuumlazy.c | 10 ++++------ src/backend/commands/variable.c | 2 +- src/backend/storage/page/bufpage.c | 2 +- src/backend/utils/adt/json.c | 4 ++-- src/backend/utils/adt/jsonb.c | 6 +++--- src/backend/utils/misc/pg_rusage.c | 4 +++- 10 files changed, 24 insertions(+), 30 deletions(-) diff --git a/src/backend/access/brin/brin_pageops.c b/src/backend/access/brin/brin_pageops.c index 4878f8b776..987e6005cb 100644 --- a/src/backend/access/brin/brin_pageops.c +++ b/src/backend/access/brin/brin_pageops.c @@ -73,10 +73,8 @@ brin_doupdate(Relation idxrel, BlockNumber pagesPerRange, { ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), - errmsg("index row size %lu exceeds maximum %lu for index \"%s\"", - (unsigned long) newsz, - (unsigned long) BrinMaxItemSize, - RelationGetRelationName(idxrel)))); + errmsg("index row size %zu exceeds maximum %zu for index \"%s\"", + newsz, BrinMaxItemSize, RelationGetRelationName(idxrel)))); return false; /* keep compiler quiet */ } @@ -359,10 +357,8 @@ brin_doinsert(Relation idxrel, BlockNumber pagesPerRange, { ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), - errmsg("index row size %lu exceeds maximum %lu for index \"%s\"", - (unsigned long) itemsz, - (unsigned long) BrinMaxItemSize, - RelationGetRelationName(idxrel)))); + errmsg("index row size %zu exceeds maximum %zu for index \"%s\"", + itemsz, BrinMaxItemSize, RelationGetRelationName(idxrel)))); return InvalidOffsetNumber; /* keep compiler quiet */ } @@ -669,7 +665,7 @@ brin_getinsertbuffer(Relation irel, Buffer oldbuf, Size itemsz, BlockNumber oldblk; BlockNumber newblk; Page page; - int freespace; + Size freespace; /* callers must have checked */ Assert(itemsz <= BrinMaxItemSize); @@ -825,10 +821,8 @@ brin_getinsertbuffer(Relation irel, Buffer oldbuf, Size itemsz, ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), - errmsg("index row size %lu exceeds maximum %lu for index \"%s\"", - (unsigned long) itemsz, - (unsigned long) freespace, - RelationGetRelationName(irel)))); + errmsg("index row size %zu exceeds maximum %zu for index \"%s\"", + itemsz, freespace, RelationGetRelationName(irel)))); return InvalidBuffer; /* keep compiler quiet */ } diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index b0b43cf02d..6aae1ab6fd 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -3453,7 +3453,7 @@ reindex_index(Oid indexId, bool skip_constraint_checks, char persistence, ereport(INFO, (errmsg("index \"%s\" was reindexed", get_rel_name(indexId)), - errdetail("%s.", + errdetail_internal("%s", pg_rusage_show(&ru0)))); /* Close rels, but keep locks */ diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c index 8fd4c3136b..8092381ae5 100644 --- a/src/backend/catalog/namespace.c +++ b/src/backend/catalog/namespace.c @@ -3685,7 +3685,7 @@ InitTempTableNamespace(void) if (IsParallelWorker()) ereport(ERROR, (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION), - errmsg("cannot create temporary tables in parallel mode"))); + errmsg("cannot create temporary tables during a parallel operation"))); snprintf(namespaceName, sizeof(namespaceName), "pg_temp_%d", MyBackendId); diff --git a/src/backend/catalog/pg_aggregate.c b/src/backend/catalog/pg_aggregate.c index 959d3845df..ada6e6171b 100644 --- a/src/backend/catalog/pg_aggregate.c +++ b/src/backend/catalog/pg_aggregate.c @@ -433,7 +433,7 @@ AggregateCreate(const char *aggName, if (aggTransType == INTERNALOID && func_strict(combinefn)) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), - errmsg("combine function with \"%s\" transition type must not be declared STRICT", + errmsg("combine function with transition type %s must not be declared STRICT", format_type_be(aggTransType)))); } diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c index e1e39dfb4e..0506a9340c 100644 --- a/src/backend/commands/vacuumlazy.c +++ b/src/backend/commands/vacuumlazy.c @@ -1342,8 +1342,7 @@ lazy_scan_heap(Relation onerel, int options, LVRelStats *vacrelstats, "%u pages are entirely empty.\n", empty_pages), empty_pages); - appendStringInfo(&buf, _("%s."), - pg_rusage_show(&ru0)); + appendStringInfo(&buf, "%s.", pg_rusage_show(&ru0)); ereport(elevel, (errmsg("\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u pages", @@ -1418,8 +1417,7 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats) (errmsg("\"%s\": removed %d row versions in %d pages", RelationGetRelationName(onerel), tupindex, npages), - errdetail("%s.", - pg_rusage_show(&ru0)))); + errdetail_internal("%s", pg_rusage_show(&ru0)))); } /* @@ -1607,7 +1605,7 @@ lazy_vacuum_index(Relation indrel, (errmsg("scanned index \"%s\" to remove %d row versions", RelationGetRelationName(indrel), vacrelstats->num_dead_tuples), - errdetail("%s.", pg_rusage_show(&ru0)))); + errdetail_internal("%s", pg_rusage_show(&ru0)))); } /* @@ -1817,7 +1815,7 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats) (errmsg("\"%s\": truncated %u to %u pages", RelationGetRelationName(onerel), old_rel_pages, new_rel_pages), - errdetail("%s.", + errdetail_internal("%s", pg_rusage_show(&ru0)))); old_rel_pages = new_rel_pages; } while (new_rel_pages > vacrelstats->nonempty_pages && diff --git a/src/backend/commands/variable.c b/src/backend/commands/variable.c index defafa54b2..1f72d7bee9 100644 --- a/src/backend/commands/variable.c +++ b/src/backend/commands/variable.c @@ -776,7 +776,7 @@ assign_client_encoding(const char *newval, void *extra) */ ereport(ERROR, (errcode(ERRCODE_INVALID_TRANSACTION_STATE), - errmsg("cannot change client_encoding in a parallel worker"))); + errmsg("cannot change client_encoding during a parallel operation"))); } /* We do not expect an error if PrepareClientEncoding succeeded */ diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c index f2a07f2111..11607827d8 100644 --- a/src/backend/storage/page/bufpage.c +++ b/src/backend/storage/page/bufpage.c @@ -889,7 +889,7 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems) offset != MAXALIGN(offset)) ereport(ERROR, (errcode(ERRCODE_DATA_CORRUPTED), - errmsg("corrupted item pointer: offset = %u, size = %u", + errmsg("corrupted item pointer: offset = %u, length = %u", offset, (unsigned int) size))); if (nextitm < nitems && offnum == itemnos[nextitm]) diff --git a/src/backend/utils/adt/json.c b/src/backend/utils/adt/json.c index c73044b806..2b6a8391d8 100644 --- a/src/backend/utils/adt/json.c +++ b/src/backend/utils/adt/json.c @@ -2003,7 +2003,7 @@ json_object_agg_transfn(PG_FUNCTION_ARGS) if (arg_type == InvalidOid) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("could not determine data type for argument 1"))); + errmsg("could not determine data type for argument %d", 1))); json_categorize_type(arg_type, &state->key_category, &state->key_output_func); @@ -2013,7 +2013,7 @@ json_object_agg_transfn(PG_FUNCTION_ARGS) if (arg_type == InvalidOid) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("could not determine data type for argument 2"))); + errmsg("could not determine data type for argument %d", 2))); json_categorize_type(arg_type, &state->val_category, &state->val_output_func); diff --git a/src/backend/utils/adt/jsonb.c b/src/backend/utils/adt/jsonb.c index 987cfd1862..d560e4edbc 100644 --- a/src/backend/utils/adt/jsonb.c +++ b/src/backend/utils/adt/jsonb.c @@ -1211,7 +1211,7 @@ jsonb_build_object(PG_FUNCTION_ARGS) if (val_type == InvalidOid || val_type == UNKNOWNOID) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("argument %d: could not determine data type", i + 1))); + errmsg("could not determine data type for argument %d", i + 1))); add_jsonb(arg, false, &result, val_type, true); @@ -1234,7 +1234,7 @@ jsonb_build_object(PG_FUNCTION_ARGS) if (val_type == InvalidOid || val_type == UNKNOWNOID) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("argument %d: could not determine data type", i + 2))); + errmsg("could not determine data type for argument %d", i + 2))); add_jsonb(arg, PG_ARGISNULL(i + 1), &result, val_type, false); } @@ -1294,7 +1294,7 @@ jsonb_build_array(PG_FUNCTION_ARGS) if (val_type == InvalidOid || val_type == UNKNOWNOID) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("argument %d: could not determine data type", i + 1))); + errmsg("could not determine data type for argument %d", i + 1))); add_jsonb(arg, PG_ARGISNULL(i), &result, val_type, false); } diff --git a/src/backend/utils/misc/pg_rusage.c b/src/backend/utils/misc/pg_rusage.c index 8781a383c0..c21b950151 100644 --- a/src/backend/utils/misc/pg_rusage.c +++ b/src/backend/utils/misc/pg_rusage.c @@ -61,7 +61,9 @@ pg_rusage_show(const PGRUsage *ru0) } snprintf(result, sizeof(result), - "CPU %d.%02ds/%d.%02du sec elapsed %d.%02d sec", + /*--- + * translator: %d.%02ds is system CPU time, %d.%02du is user CPU time */ + _("CPU %d.%02ds/%d.%02du sec elapsed %d.%02d sec"), (int) (ru1.ru.ru_stime.tv_sec - ru0->ru.ru_stime.tv_sec), (int) (ru1.ru.ru_stime.tv_usec - ru0->ru.ru_stime.tv_usec) / 10000, (int) (ru1.ru.ru_utime.tv_sec - ru0->ru.ru_utime.tv_sec), From b64ff9c5af1e7e8c665f6fd76cecb0e3e82b0921 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Mon, 5 Jun 2017 14:24:42 -0400 Subject: [PATCH 0091/1139] Find openssl lib files in right directory for MSVC Some openssl builds put their lib files in a VC subdirectory, others do not. Cater for both cases. Backpatch to all live branches. From an offline discussion with Leonardo Cecchi. --- src/tools/msvc/Solution.pm | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/src/tools/msvc/Solution.pm b/src/tools/msvc/Solution.pm index 666605b47b..8191a40ea5 100644 --- a/src/tools/msvc/Solution.pm +++ b/src/tools/msvc/Solution.pm @@ -523,10 +523,20 @@ sub AddProject if ($self->{options}->{openssl}) { $proj->AddIncludeDir($self->{options}->{openssl} . '\include'); - $proj->AddLibrary( - $self->{options}->{openssl} . '\lib\VC\ssleay32.lib', 1); - $proj->AddLibrary( - $self->{options}->{openssl} . '\lib\VC\libeay32.lib', 1); + if (-e "$self->{options}->{openssl}/lib/VC/ssleayMD.lib") + { + $proj->AddLibrary( + $self->{options}->{openssl} . '\lib\VC\ssleay32.lib', 1); + $proj->AddLibrary( + $self->{options}->{openssl} . '\lib\VC\libeay32.lib', 1); + } + else + { + $proj->AddLibrary( + $self->{options}->{openssl} . '\lib\ssleay32.lib', 1); + $proj->AddLibrary( + $self->{options}->{openssl} . '\lib\libeay32.lib', 1); + } } if ($self->{options}->{nls}) { From d3ca4b4b454fcd26de071f1556ec7b5e693514d4 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Mon, 5 Jun 2017 15:56:58 -0700 Subject: [PATCH 0092/1139] Fix record length computation in pg_waldump/xlogdump. The current method of computing the record length (excluding the lenght of full-page images) has been wrong since the WAL format has been revamped in 2c03216d831160bedd72d45f712601b6f7d03f1c. Only the main record's length was counted, but that can be significantly too little if there's data associated with further blocks. Fix by computing the record length as total_lenght - fpi_length. Reported-By: Chen Huajun Bug: #14687 Reviewed-By: Heikki Linnakangas Discussion: https://postgr.es/m/20170603165939.1436.58887@wrigleys.postgresql.org Backpatch: 9.5- --- src/bin/pg_xlogdump/pg_xlogdump.c | 49 +++++++++++++++++++++---------- 1 file changed, 34 insertions(+), 15 deletions(-) diff --git a/src/bin/pg_xlogdump/pg_xlogdump.c b/src/bin/pg_xlogdump/pg_xlogdump.c index ac5f161243..f0c0636286 100644 --- a/src/bin/pg_xlogdump/pg_xlogdump.c +++ b/src/bin/pg_xlogdump/pg_xlogdump.c @@ -363,23 +363,13 @@ XLogDumpReadPage(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen, } /* - * Store per-rmgr and per-record statistics for a given record. + * Calculate the size of a record, split into !FPI and FPI parts. */ static void -XLogDumpCountRecord(XLogDumpConfig *config, XLogDumpStats *stats, - XLogReaderState *record) +XLogDumpRecordLen(XLogReaderState *record, uint32 *rec_len, uint32 *fpi_len) { - RmgrId rmid; - uint8 recid; - uint32 rec_len; - uint32 fpi_len; int block_id; - stats->count++; - - rmid = XLogRecGetRmid(record); - rec_len = XLogRecGetDataLen(record) + SizeOfXLogRecord; - /* * Calculate the amount of FPI data in the record. * @@ -387,13 +377,38 @@ XLogDumpCountRecord(XLogDumpConfig *config, XLogDumpStats *stats, * bimg_len indicating the length of FPI data. It doesn't seem worth it to * add an accessor macro for this. */ - fpi_len = 0; + *fpi_len = 0; for (block_id = 0; block_id <= record->max_block_id; block_id++) { if (XLogRecHasBlockImage(record, block_id)) - fpi_len += record->blocks[block_id].bimg_len; + *fpi_len += record->blocks[block_id].bimg_len; } + /* + * Calculate the length of the record as the total length - the length of + * all the block images. + */ + *rec_len = XLogRecGetTotalLen(record) - *fpi_len; +} + +/* + * Store per-rmgr and per-record statistics for a given record. + */ +static void +XLogDumpCountRecord(XLogDumpConfig *config, XLogDumpStats *stats, + XLogReaderState *record) +{ + RmgrId rmid; + uint8 recid; + uint32 rec_len; + uint32 fpi_len; + + stats->count++; + + rmid = XLogRecGetRmid(record); + + XLogDumpRecordLen(record, &rec_len, &fpi_len); + /* Update per-rmgr statistics */ stats->rmgr_stats[rmid].count++; @@ -422,6 +437,8 @@ XLogDumpDisplayRecord(XLogDumpConfig *config, XLogReaderState *record) { const char *id; const RmgrDescData *desc = &RmgrDescTable[XLogRecGetRmid(record)]; + uint32 rec_len; + uint32 fpi_len; RelFileNode rnode; ForkNumber forknum; BlockNumber blk; @@ -429,13 +446,15 @@ XLogDumpDisplayRecord(XLogDumpConfig *config, XLogReaderState *record) uint8 info = XLogRecGetInfo(record); XLogRecPtr xl_prev = XLogRecGetPrev(record); + XLogDumpRecordLen(record, &rec_len, &fpi_len); + id = desc->rm_identify(info); if (id == NULL) id = psprintf("UNKNOWN (%x)", info & ~XLR_INFO_MASK); printf("rmgr: %-11s len (rec/tot): %6u/%6u, tx: %10u, lsn: %X/%08X, prev %X/%08X, ", desc->rm_name, - XLogRecGetDataLen(record), XLogRecGetTotalLen(record), + rec_len, XLogRecGetTotalLen(record), XLogRecGetXid(record), (uint32) (record->ReadRecPtr >> 32), (uint32) record->ReadRecPtr, (uint32) (xl_prev >> 32), (uint32) xl_prev); From ec504aff740993560d8d1ca16f70cbf8147cc622 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Mon, 5 Jun 2017 20:38:46 -0400 Subject: [PATCH 0093/1139] Fix thinko in previous openssl change --- src/tools/msvc/Solution.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/msvc/Solution.pm b/src/tools/msvc/Solution.pm index 8191a40ea5..c155c5f3ca 100644 --- a/src/tools/msvc/Solution.pm +++ b/src/tools/msvc/Solution.pm @@ -523,7 +523,7 @@ sub AddProject if ($self->{options}->{openssl}) { $proj->AddIncludeDir($self->{options}->{openssl} . '\include'); - if (-e "$self->{options}->{openssl}/lib/VC/ssleayMD.lib") + if (-e "$self->{options}->{openssl}/lib/VC/ssleay32MD.lib") { $proj->AddLibrary( $self->{options}->{openssl} . '\lib\VC\ssleay32.lib', 1); From b3d5b6833f460debde53a122709c3deb07056561 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Mon, 5 Jun 2017 18:53:41 -0700 Subject: [PATCH 0094/1139] Have walsenders participate in procsignal infrastructure. The non-participation in procsignal was a problem for both changes in master, e.g. parallelism not working for normal statements run in walsender backends, and older branches, e.g. recovery conflicts and catchup interrupts not working for logical decoding walsenders. This commit thus replaces the previous WalSndXLogSendHandler with procsignal_sigusr1_handler. In branches since db0f6cad48 that can lead to additional SetLatch calls, but that only rarely seems to make a difference. Author: Andres Freund Reviewed-By: Michael Paquier Discussion: https://postgr.es/m/20170421014030.fdzvvvbrz4nckrow@alap3.anarazel.de Backpatch: 9.4, earlier commits don't seem to benefit sufficiently --- src/backend/replication/walsender.c | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index 834bf947a3..b7acedc0c6 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -186,7 +186,6 @@ static XLogRecPtr logical_startptr = InvalidXLogRecPtr; /* Signal handlers */ static void WalSndSigHupHandler(SIGNAL_ARGS); -static void WalSndXLogSendHandler(SIGNAL_ARGS); static void WalSndLastCycleHandler(SIGNAL_ARGS); /* Prototypes for private functions */ @@ -2577,17 +2576,6 @@ WalSndSigHupHandler(SIGNAL_ARGS) errno = save_errno; } -/* SIGUSR1: set flag to send WAL records */ -static void -WalSndXLogSendHandler(SIGNAL_ARGS) -{ - int save_errno = errno; - - latch_sigusr1_handler(); - - errno = save_errno; -} - /* SIGUSR2: set flag to do a last cycle and shut down afterwards */ static void WalSndLastCycleHandler(SIGNAL_ARGS) @@ -2621,7 +2609,7 @@ WalSndSignals(void) pqsignal(SIGQUIT, quickdie); /* hard crash time */ InitializeTimeouts(); /* establishes SIGALRM handler */ pqsignal(SIGPIPE, SIG_IGN); - pqsignal(SIGUSR1, WalSndXLogSendHandler); /* request WAL sending */ + pqsignal(SIGUSR1, procsignal_sigusr1_handler); pqsignal(SIGUSR2, WalSndLastCycleHandler); /* request a last cycle and * shutdown */ From 862204aaceb1199afeda96af9579e7cb553fe00b Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Mon, 5 Jun 2017 18:53:41 -0700 Subject: [PATCH 0095/1139] Prevent possibility of panics during shutdown checkpoint. When the checkpointer writes the shutdown checkpoint, it checks afterwards whether any WAL has been written since it started and throws a PANIC if so. At that point, only walsenders are still active, so one might think this could not happen, but walsenders can also generate WAL, for instance in BASE_BACKUP and logical decoding related commands (e.g. via hint bits). So they can trigger this panic if such a command is run while the shutdown checkpoint is being written. To fix this, divide the walsender shutdown into two phases. First, checkpointer, itself triggered by postmaster, sends a PROCSIG_WALSND_INIT_STOPPING signal to all walsenders. If the backend is idle or runs an SQL query this causes the backend to shutdown, if logical replication is in progress all existing WAL records are processed followed by a shutdown. Otherwise this causes the walsender to switch to the "stopping" state. In this state, the walsender will reject any further replication commands. The checkpointer begins the shutdown checkpoint once all walsenders are confirmed as stopping. When the shutdown checkpoint finishes, the postmaster sends us SIGUSR2. This instructs walsender to send any outstanding WAL, including the shutdown checkpoint record, wait for it to be replicated to the standby, and then exit. Author: Andres Freund, based on an earlier patch by Michael Paquier Reported-By: Fujii Masao, Andres Freund Reviewed-By: Michael Paquier Discussion: https://postgr.es/m/20170602002912.tqlwn4gymzlxpvs2@alap3.anarazel.de Backpatch: 9.4, where logical decoding was introduced --- src/backend/access/transam/xlog.c | 11 ++ src/backend/replication/walsender.c | 187 +++++++++++++++++--- src/backend/storage/ipc/procsignal.c | 4 + src/include/replication/walsender.h | 3 + src/include/replication/walsender_private.h | 3 +- src/include/storage/procsignal.h | 1 + 6 files changed, 181 insertions(+), 28 deletions(-) diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index b5aa9158be..dab9e68d3b 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -8006,6 +8006,17 @@ ShutdownXLOG(int code, Datum arg) ereport(IsPostmasterEnvironment ? LOG : NOTICE, (errmsg("shutting down"))); + /* + * Signal walsenders to move to stopping state. + */ + WalSndInitStopping(); + + /* + * Wait for WAL senders to be in stopping state. This prevents commands + * from writing new WAL. + */ + WalSndWaitStopping(); + if (RecoveryInProgress()) CreateRestartPoint(CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_IMMEDIATE); else diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index b7acedc0c6..9cb8444558 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -24,11 +24,17 @@ * are treated as not a crash but approximately normal termination; * the walsender will exit quickly without sending any more XLOG records. * - * If the server is shut down, postmaster sends us SIGUSR2 after all - * regular backends have exited and the shutdown checkpoint has been written. - * This instructs walsender to send any outstanding WAL, including the - * shutdown checkpoint record, wait for it to be replicated to the standby, - * and then exit. + * If the server is shut down, checkpointer sends us + * PROCSIG_WALSND_INIT_STOPPING after all regular backends have exited. If + * the backend is idle or runs an SQL query this causes the backend to + * shutdown, if logical replication is in progress all existing WAL records + * are processed followed by a shutdown. Otherwise this causes the walsender + * to switch to the "stopping" state. In this state, the walsender will reject + * any further replication commands. The checkpointer begins the shutdown + * checkpoint once all walsenders are confirmed as stopping. When the shutdown + * checkpoint finishes, the postmaster sends us SIGUSR2. This instructs + * walsender to send any outstanding WAL, including the shutdown checkpoint + * record, wait for it to be replicated to the standby, and then exit. * * * Portions Copyright (c) 2010-2016, PostgreSQL Global Development Group @@ -171,13 +177,14 @@ static bool WalSndCaughtUp = false; /* Flags set by signal handlers for later service in main loop */ static volatile sig_atomic_t got_SIGHUP = false; -static volatile sig_atomic_t walsender_ready_to_stop = false; +static volatile sig_atomic_t got_SIGUSR2 = false; +static volatile sig_atomic_t got_STOPPING = false; /* - * This is set while we are streaming. When not set, SIGUSR2 signal will be - * handled like SIGTERM. When set, the main loop is responsible for checking - * walsender_ready_to_stop and terminating when it's set (after streaming any - * remaining WAL). + * This is set while we are streaming. When not set + * PROCSIG_WALSND_INIT_STOPPING signal will be handled like SIGTERM. When set, + * the main loop is responsible for checking got_STOPPING and terminating when + * it's set (after streaming any remaining WAL). */ static volatile sig_atomic_t replication_active = false; @@ -264,7 +271,8 @@ WalSndErrorCleanup(void) ReplicationSlotRelease(); replication_active = false; - if (walsender_ready_to_stop) + + if (got_STOPPING || got_SIGUSR2) proc_exit(0); /* Revert back to startup state */ @@ -671,7 +679,7 @@ StartReplication(StartReplicationCmd *cmd) WalSndLoop(XLogSendPhysical); replication_active = false; - if (walsender_ready_to_stop) + if (got_STOPPING) proc_exit(0); WalSndSetState(WALSNDSTATE_STARTUP); @@ -970,7 +978,7 @@ StartLogicalReplication(StartReplicationCmd *cmd) { ereport(LOG, (errmsg("terminating walsender process after promotion"))); - walsender_ready_to_stop = true; + got_STOPPING = true; } WalSndSetState(WALSNDSTATE_CATCHUP); @@ -1024,7 +1032,7 @@ StartLogicalReplication(StartReplicationCmd *cmd) ReplicationSlotRelease(); replication_active = false; - if (walsender_ready_to_stop) + if (got_STOPPING) proc_exit(0); WalSndSetState(WALSNDSTATE_STARTUP); @@ -1204,6 +1212,14 @@ WalSndWaitForWal(XLogRecPtr loc) /* Check for input from the client */ ProcessRepliesIfAny(); + /* + * If we're shutting down, trigger pending WAL to be written out, + * otherwise we'd possibly end up waiting for WAL that never gets + * written, because walwriter has shut down already. + */ + if (got_STOPPING) + XLogBackgroundFlush(); + /* Update our idea of the currently flushed position. */ if (!RecoveryInProgress()) RecentFlushPtr = GetFlushRecPtr(); @@ -1219,7 +1235,7 @@ WalSndWaitForWal(XLogRecPtr loc) * RecentFlushPtr, so we can send all remaining data before shutting * down. */ - if (walsender_ready_to_stop) + if (got_STOPPING) break; /* @@ -1289,6 +1305,22 @@ exec_replication_command(const char *cmd_string) MemoryContext cmd_context; MemoryContext old_context; + /* + * If WAL sender has been told that shutdown is getting close, switch its + * status accordingly to handle the next replication commands correctly. + */ + if (got_STOPPING) + WalSndSetState(WALSNDSTATE_STOPPING); + + /* + * Throw error if in stopping mode. We need prevent commands that could + * generate WAL while the shutdown checkpoint is being written. To be + * safe, we just prohibit all new commands. + */ + if (MyWalSnd->state == WALSNDSTATE_STOPPING) + ereport(ERROR, + (errmsg("cannot execute new commands while WAL sender is in stopping mode"))); + /* * Log replication command if log_replication_commands is enabled. Even * when it's disabled, log the command with DEBUG1 level for backward @@ -1884,7 +1916,7 @@ WalSndLoop(WalSndSendDataCallback send_data) * normal termination at shutdown, or a promotion, the walsender * is not sure which. */ - if (walsender_ready_to_stop) + if (got_SIGUSR2) WalSndDone(send_data); } @@ -2193,6 +2225,10 @@ XLogSendPhysical(void) XLogRecPtr endptr; Size nbytes; + /* If requested switch the WAL sender to the stopping state. */ + if (got_STOPPING) + WalSndSetState(WALSNDSTATE_STOPPING); + if (streamingDoneSending) { WalSndCaughtUp = true; @@ -2452,7 +2488,16 @@ XLogSendLogical(void) * point, then we're caught up. */ if (logical_decoding_ctx->reader->EndRecPtr >= GetFlushRecPtr()) + { WalSndCaughtUp = true; + + /* + * Have WalSndLoop() terminate the connection in an orderly + * manner, after writing out all the pending data. + */ + if (got_STOPPING) + got_SIGUSR2 = true; + } } /* Update shared memory status */ @@ -2563,6 +2608,26 @@ WalSndRqstFileReload(void) } } +/* + * Handle PROCSIG_WALSND_INIT_STOPPING signal. + */ +void +HandleWalSndInitStopping(void) +{ + Assert(am_walsender); + + /* + * If replication has not yet started, die like with SIGTERM. If + * replication is active, only set a flag and wake up the main loop. It + * will send any outstanding WAL, wait for it to be replicated to the + * standby, and then exit gracefully. + */ + if (!replication_active) + kill(MyProcPid, SIGTERM); + else + got_STOPPING = true; +} + /* SIGHUP: set flag to re-read config file at next convenient time */ static void WalSndSigHupHandler(SIGNAL_ARGS) @@ -2576,22 +2641,17 @@ WalSndSigHupHandler(SIGNAL_ARGS) errno = save_errno; } -/* SIGUSR2: set flag to do a last cycle and shut down afterwards */ +/* + * SIGUSR2: set flag to do a last cycle and shut down afterwards. The WAL + * sender should already have been switched to WALSNDSTATE_STOPPING at + * this point. + */ static void WalSndLastCycleHandler(SIGNAL_ARGS) { int save_errno = errno; - /* - * If replication has not yet started, die like with SIGTERM. If - * replication is active, only set a flag and wake up the main loop. It - * will send any outstanding WAL, wait for it to be replicated to the - * standby, and then exit gracefully. - */ - if (!replication_active) - kill(MyProcPid, SIGTERM); - - walsender_ready_to_stop = true; + got_SIGUSR2 = true; SetLatch(MyLatch); errno = save_errno; @@ -2689,6 +2749,77 @@ WalSndWakeup(void) } } +/* + * Signal all walsenders to move to stopping state. + * + * This will trigger walsenders to move to a state where no further WAL can be + * generated. See this file's header for details. + */ +void +WalSndInitStopping(void) +{ + int i; + + for (i = 0; i < max_wal_senders; i++) + { + WalSnd *walsnd = &WalSndCtl->walsnds[i]; + pid_t pid; + + SpinLockAcquire(&walsnd->mutex); + pid = walsnd->pid; + SpinLockRelease(&walsnd->mutex); + + if (pid == 0) + continue; + + SendProcSignal(pid, PROCSIG_WALSND_INIT_STOPPING, InvalidBackendId); + } +} + +/* + * Wait that all the WAL senders have quit or reached the stopping state. This + * is used by the checkpointer to control when the shutdown checkpoint can + * safely be performed. + */ +void +WalSndWaitStopping(void) +{ + for (;;) + { + int i; + bool all_stopped = true; + + for (i = 0; i < max_wal_senders; i++) + { + WalSndState state; + WalSnd *walsnd = &WalSndCtl->walsnds[i]; + + SpinLockAcquire(&walsnd->mutex); + + if (walsnd->pid == 0) + { + SpinLockRelease(&walsnd->mutex); + continue; + } + + state = walsnd->state; + SpinLockRelease(&walsnd->mutex); + + if (state != WALSNDSTATE_STOPPING) + { + all_stopped = false; + break; + } + } + + /* safe to leave if confirmation is done for all WAL senders */ + if (all_stopped) + return; + + pg_usleep(10000L); /* wait for 10 msec */ + } +} + /* Set state for current walsender (only called in walsender) */ void WalSndSetState(WalSndState state) @@ -2722,6 +2853,8 @@ WalSndGetStateString(WalSndState state) return "catchup"; case WALSNDSTATE_STREAMING: return "streaming"; + case WALSNDSTATE_STOPPING: + return "stopping"; } return "UNKNOWN"; } diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c index a3d6ac5318..7611283eaa 100644 --- a/src/backend/storage/ipc/procsignal.c +++ b/src/backend/storage/ipc/procsignal.c @@ -20,6 +20,7 @@ #include "access/parallel.h" #include "commands/async.h" #include "miscadmin.h" +#include "replication/walsender.h" #include "storage/latch.h" #include "storage/ipc.h" #include "storage/proc.h" @@ -270,6 +271,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS) if (CheckProcSignal(PROCSIG_PARALLEL_MESSAGE)) HandleParallelMessageInterrupt(); + if (CheckProcSignal(PROCSIG_WALSND_INIT_STOPPING)) + HandleWalSndInitStopping(); + if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_DATABASE)) RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_DATABASE); diff --git a/src/include/replication/walsender.h b/src/include/replication/walsender.h index de7338638e..b4dfd61378 100644 --- a/src/include/replication/walsender.h +++ b/src/include/replication/walsender.h @@ -34,6 +34,9 @@ extern void WalSndSignals(void); extern Size WalSndShmemSize(void); extern void WalSndShmemInit(void); extern void WalSndWakeup(void); +extern void WalSndInitStopping(void); +extern void WalSndWaitStopping(void); +extern void HandleWalSndInitStopping(void); extern void WalSndRqstFileReload(void); extern Datum pg_stat_get_wal_senders(PG_FUNCTION_ARGS); diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h index 7794aa567e..188a3ce9ed 100644 --- a/src/include/replication/walsender_private.h +++ b/src/include/replication/walsender_private.h @@ -24,7 +24,8 @@ typedef enum WalSndState WALSNDSTATE_STARTUP = 0, WALSNDSTATE_BACKUP, WALSNDSTATE_CATCHUP, - WALSNDSTATE_STREAMING + WALSNDSTATE_STREAMING, + WALSNDSTATE_STOPPING } WalSndState; /* diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h index f67b9821f2..104f4c198e 100644 --- a/src/include/storage/procsignal.h +++ b/src/include/storage/procsignal.h @@ -32,6 +32,7 @@ typedef enum PROCSIG_CATCHUP_INTERRUPT, /* sinval catchup interrupt */ PROCSIG_NOTIFY_INTERRUPT, /* listen/notify interrupt */ PROCSIG_PARALLEL_MESSAGE, /* message from cooperating parallel backend */ + PROCSIG_WALSND_INIT_STOPPING, /* ask walsenders to prepare for shutdown */ /* Recovery conflict reasons */ PROCSIG_RECOVERY_CONFLICT_DATABASE, From b8bd32a51f2dd451644175af7ae32f9bec3153f1 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Mon, 5 Jun 2017 18:53:41 -0700 Subject: [PATCH 0096/1139] Unify SIGHUP handling between normal and walsender backends. Because walsender and normal backends share the same main loop it's problematic to have two different flag variables, set in signal handlers, indicating a pending configuration reload. Only certain walsender commands reach code paths checking for the variable (START_[LOGICAL_]REPLICATION, CREATE_REPLICATION_SLOT ... LOGICAL, notably not base backups). This is a bug present since the introduction of walsender, but has gotten worse in releases since then which allow walsender to do more. A later patch, not slated for v10, will similarly unify SIGHUP handling in other types of processes as well. Author: Petr Jelinek, Andres Freund Reviewed-By: Michael Paquier Discussion: https://postgr.es/m/20170423235941.qosiuoyqprq4nu7v@alap3.anarazel.de Backpatch: 9.2-, bug is present since 9.0 --- src/backend/replication/walsender.c | 29 +++++++--------------------- src/backend/tcop/postgres.c | 30 ++++++++++++++--------------- src/backend/utils/init/globals.c | 1 + src/include/miscadmin.h | 5 +++++ 4 files changed, 27 insertions(+), 38 deletions(-) diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index 9cb8444558..e4ecbe37ee 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -176,7 +176,6 @@ static bool streamingDoneReceiving; static bool WalSndCaughtUp = false; /* Flags set by signal handlers for later service in main loop */ -static volatile sig_atomic_t got_SIGHUP = false; static volatile sig_atomic_t got_SIGUSR2 = false; static volatile sig_atomic_t got_STOPPING = false; @@ -192,7 +191,6 @@ static LogicalDecodingContext *logical_decoding_ctx = NULL; static XLogRecPtr logical_startptr = InvalidXLogRecPtr; /* Signal handlers */ -static void WalSndSigHupHandler(SIGNAL_ARGS); static void WalSndLastCycleHandler(SIGNAL_ARGS); /* Prototypes for private functions */ @@ -1119,9 +1117,9 @@ WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, CHECK_FOR_INTERRUPTS(); /* Process any requests or signals received recently */ - if (got_SIGHUP) + if (ConfigReloadPending) { - got_SIGHUP = false; + ConfigReloadPending = false; ProcessConfigFile(PGC_SIGHUP); SyncRepInitConfig(); } @@ -1202,9 +1200,9 @@ WalSndWaitForWal(XLogRecPtr loc) CHECK_FOR_INTERRUPTS(); /* Process any requests or signals received recently */ - if (got_SIGHUP) + if (ConfigReloadPending) { - got_SIGHUP = false; + ConfigReloadPending = false; ProcessConfigFile(PGC_SIGHUP); SyncRepInitConfig(); } @@ -1857,9 +1855,9 @@ WalSndLoop(WalSndSendDataCallback send_data) CHECK_FOR_INTERRUPTS(); /* Process any requests or signals received recently */ - if (got_SIGHUP) + if (ConfigReloadPending) { - got_SIGHUP = false; + ConfigReloadPending = false; ProcessConfigFile(PGC_SIGHUP); SyncRepInitConfig(); } @@ -2628,19 +2626,6 @@ HandleWalSndInitStopping(void) got_STOPPING = true; } -/* SIGHUP: set flag to re-read config file at next convenient time */ -static void -WalSndSigHupHandler(SIGNAL_ARGS) -{ - int save_errno = errno; - - got_SIGHUP = true; - - SetLatch(MyLatch); - - errno = save_errno; -} - /* * SIGUSR2: set flag to do a last cycle and shut down afterwards. The WAL * sender should already have been switched to WALSNDSTATE_STOPPING at @@ -2662,7 +2647,7 @@ void WalSndSignals(void) { /* Set up signal handlers */ - pqsignal(SIGHUP, WalSndSigHupHandler); /* set flag to read config + pqsignal(SIGHUP, PostgresSigHupHandler); /* set flag to read config * file */ pqsignal(SIGINT, SIG_IGN); /* not used */ pqsignal(SIGTERM, die); /* request shutdown */ diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index f6be98bdd4..02bbfda3a2 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -121,13 +121,6 @@ char *stack_base_ptr = NULL; char *register_stack_base_ptr = NULL; #endif -/* - * Flag to mark SIGHUP. Whenever the main loop comes around it - * will reread the configuration file. (Better than doing the - * reading in the signal handler, ey?) - */ -static volatile sig_atomic_t got_SIGHUP = false; - /* * Flag to keep track of whether we have started a transaction. * For extended query protocol this has to be remembered across messages. @@ -186,7 +179,6 @@ static bool IsTransactionExitStmt(Node *parsetree); static bool IsTransactionExitStmtList(List *parseTrees); static bool IsTransactionStmtList(List *parseTrees); static void drop_unnamed_stmt(void); -static void SigHupHandler(SIGNAL_ARGS); static void log_disconnections(int code, Datum arg); @@ -2689,13 +2681,19 @@ FloatExceptionHandler(SIGNAL_ARGS) "invalid operation, such as division by zero."))); } -/* SIGHUP: set flag to re-read config file at next convenient time */ -static void -SigHupHandler(SIGNAL_ARGS) +/* + * SIGHUP: set flag to re-read config file at next convenient time. + * + * Sets the ConfigReloadPending flag, which should be checked at convenient + * places inside main loops. (Better than doing the reading in the signal + * handler, ey?) + */ +void +PostgresSigHupHandler(SIGNAL_ARGS) { int save_errno = errno; - got_SIGHUP = true; + ConfigReloadPending = true; SetLatch(MyLatch); errno = save_errno; @@ -3633,8 +3631,8 @@ PostgresMain(int argc, char *argv[], WalSndSignals(); else { - pqsignal(SIGHUP, SigHupHandler); /* set flag to read config - * file */ + pqsignal(SIGHUP, PostgresSigHupHandler); /* set flag to read config + * file */ pqsignal(SIGINT, StatementCancelHandler); /* cancel current query */ pqsignal(SIGTERM, die); /* cancel current query and exit */ @@ -4045,9 +4043,9 @@ PostgresMain(int argc, char *argv[], * (6) check for any other interesting events that happened while we * slept. */ - if (got_SIGHUP) + if (ConfigReloadPending) { - got_SIGHUP = false; + ConfigReloadPending = false; ProcessConfigFile(PGC_SIGHUP); } diff --git a/src/backend/utils/init/globals.c b/src/backend/utils/init/globals.c index f23208353c..00c323aab2 100644 --- a/src/backend/utils/init/globals.c +++ b/src/backend/utils/init/globals.c @@ -31,6 +31,7 @@ volatile bool QueryCancelPending = false; volatile bool ProcDiePending = false; volatile bool ClientConnectionLost = false; volatile bool IdleInTransactionSessionTimeoutPending = false; +volatile sig_atomic_t ConfigReloadPending = false; volatile uint32 InterruptHoldoffCount = 0; volatile uint32 QueryCancelHoldoffCount = 0; volatile uint32 CritSectionCount = 0; diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h index 78545daece..196f3d172b 100644 --- a/src/include/miscadmin.h +++ b/src/include/miscadmin.h @@ -23,6 +23,8 @@ #ifndef MISCADMIN_H #define MISCADMIN_H +#include + #include "pgtime.h" /* for pg_time_t */ @@ -81,6 +83,7 @@ extern PGDLLIMPORT volatile bool InterruptPending; extern PGDLLIMPORT volatile bool QueryCancelPending; extern PGDLLIMPORT volatile bool ProcDiePending; extern PGDLLIMPORT volatile bool IdleInTransactionSessionTimeoutPending; +extern PGDLLIMPORT volatile sig_atomic_t ConfigReloadPending; extern volatile bool ClientConnectionLost; @@ -272,6 +275,8 @@ extern void restore_stack_base(pg_stack_base_t base); extern void check_stack_depth(void); extern bool stack_is_too_deep(void); +extern void PostgresSigHupHandler(SIGNAL_ARGS); + /* in tcop/utility.c */ extern void PreventCommandIfReadOnly(const char *cmdname); extern void PreventCommandIfParallelMode(const char *cmdname); From f44c609ea014fc642431bb5b0adbb120033f8cb1 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Wed, 7 Jun 2017 14:01:46 +0300 Subject: [PATCH 0097/1139] Clear auth context correctly when re-connecting after failed auth attempt. If authentication over an SSL connection fails, with sslmode=prefer, libpq will reconnect without SSL and retry. However, we did not clear the variables related to GSS, SSPI, and SASL authentication state, when reconnecting. Because of that, the second authentication attempt would always fail with a "duplicate GSS/SASL authentication request" error. pg_SSPI_startup did not check for duplicate authentication requests like the corresponding GSS and SASL functions, so with SSPI, you would leak some memory instead. Another way this could manifest itself, on version 10, is if you list multiple hostnames in the "host" parameter. If the first server requests Kerberos or SCRAM authentication, but it fails, the attempts to connect to the other servers will also fail with "duplicate authentication request" errors. To fix, move the clearing of authentication state from closePGconn to pgDropConnection, so that it is cleared also when re-connecting. Patch by Michael Paquier, with some kibitzing by me. Backpatch down to 9.3. 9.2 has the same bug, but the code around closing the connection is somewhat different, so that this patch doesn't apply. To fix this in 9.2, I think we would need to back-port commit 210eb9b743 first, and then apply this patch. However, given that we only bumped into this in our own testing, we haven't heard any reports from users about this, and that 9.2 will be end-of-lifed in a couple of months anyway, it doesn't seem worth the risk and trouble. Discussion: https://www.postgresql.org/message-id/CAB7nPqRuOUm0MyJaUy9L3eXYJU3AKCZ-0-03=-aDTZJGV4GyWw@mail.gmail.com --- src/interfaces/libpq/fe-auth.c | 7 ++- src/interfaces/libpq/fe-connect.c | 76 +++++++++++++++++-------------- 2 files changed, 47 insertions(+), 36 deletions(-) diff --git a/src/interfaces/libpq/fe-auth.c b/src/interfaces/libpq/fe-auth.c index 493ef82d4a..ab057e945a 100644 --- a/src/interfaces/libpq/fe-auth.c +++ b/src/interfaces/libpq/fe-auth.c @@ -372,7 +372,12 @@ pg_SSPI_startup(PGconn *conn, int use_negotiate) SECURITY_STATUS r; TimeStamp expire; - conn->sspictx = NULL; + if (conn->sspictx) + { + printfPQExpBuffer(&conn->errorMessage, + libpq_gettext("duplicate SSPI authentication request\n")); + return STATUS_ERROR; + } /* * Retrieve credentials handle diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c index 8c7169e171..ec468870d2 100644 --- a/src/interfaces/libpq/fe-connect.c +++ b/src/interfaces/libpq/fe-connect.c @@ -401,15 +401,56 @@ pqDropConnection(PGconn *conn, bool flushInput) { /* Drop any SSL state */ pqsecure_close(conn); + /* Close the socket itself */ if (conn->sock != PGINVALID_SOCKET) closesocket(conn->sock); conn->sock = PGINVALID_SOCKET; + /* Optionally discard any unread data */ if (flushInput) conn->inStart = conn->inCursor = conn->inEnd = 0; + /* Always discard any unsent data */ conn->outCount = 0; + + /* Free authentication state */ +#ifdef ENABLE_GSS + { + OM_uint32 min_s; + + if (conn->gctx) + gss_delete_sec_context(&min_s, &conn->gctx, GSS_C_NO_BUFFER); + if (conn->gtarg_nam) + gss_release_name(&min_s, &conn->gtarg_nam); + if (conn->ginbuf.length) + gss_release_buffer(&min_s, &conn->ginbuf); + if (conn->goutbuf.length) + gss_release_buffer(&min_s, &conn->goutbuf); + } +#endif +#ifdef ENABLE_SSPI + if (conn->ginbuf.length) + free(conn->ginbuf.value); + conn->ginbuf.length = 0; + conn->ginbuf.value = NULL; + if (conn->sspitarget) + free(conn->sspitarget); + conn->sspitarget = NULL; + if (conn->sspicred) + { + FreeCredentialsHandle(conn->sspicred); + free(conn->sspicred); + conn->sspicred = NULL; + } + if (conn->sspictx) + { + DeleteSecurityContext(conn->sspictx); + free(conn->sspictx); + conn->sspictx = NULL; + } + conn->usesspi = 0; +#endif } @@ -3007,41 +3048,6 @@ closePGconn(PGconn *conn) if (conn->lobjfuncs) free(conn->lobjfuncs); conn->lobjfuncs = NULL; -#ifdef ENABLE_GSS - { - OM_uint32 min_s; - - if (conn->gctx) - gss_delete_sec_context(&min_s, &conn->gctx, GSS_C_NO_BUFFER); - if (conn->gtarg_nam) - gss_release_name(&min_s, &conn->gtarg_nam); - if (conn->ginbuf.length) - gss_release_buffer(&min_s, &conn->ginbuf); - if (conn->goutbuf.length) - gss_release_buffer(&min_s, &conn->goutbuf); - } -#endif -#ifdef ENABLE_SSPI - if (conn->ginbuf.length) - free(conn->ginbuf.value); - conn->ginbuf.length = 0; - conn->ginbuf.value = NULL; - if (conn->sspitarget) - free(conn->sspitarget); - conn->sspitarget = NULL; - if (conn->sspicred) - { - FreeCredentialsHandle(conn->sspicred); - free(conn->sspicred); - conn->sspicred = NULL; - } - if (conn->sspictx) - { - DeleteSecurityContext(conn->sspictx); - free(conn->sspictx); - conn->sspictx = NULL; - } -#endif } /* From 32afb2b5628455a8de2f5169211651cfe7e4815f Mon Sep 17 00:00:00 2001 From: Michael Meskes Date: Tue, 6 Jun 2017 12:19:28 +0200 Subject: [PATCH 0098/1139] Fix docs to not claim ECPG's SET CONNECTION is not thread-aware. Changed by: Tsunakawa, Takayuki --- doc/src/sgml/ecpg.sgml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/doc/src/sgml/ecpg.sgml b/doc/src/sgml/ecpg.sgml index cb9ab34dbf..8cdc852a04 100644 --- a/doc/src/sgml/ecpg.sgml +++ b/doc/src/sgml/ecpg.sgml @@ -240,8 +240,7 @@ EXEC SQL AT connection-name SELECT ...; If your application uses multiple threads of execution, they cannot share a connection concurrently. You must either explicitly control access to the connection - (using mutexes) or use a connection for each thread. If each thread uses its own connection, - you will need to use the AT clause to specify which connection the thread will use. + (using mutexes) or use a connection for each thread. @@ -251,7 +250,7 @@ EXEC SQL AT connection-name SELECT ...; EXEC SQL SET CONNECTION connection-name; This option is particularly convenient if many statements are to be - executed on the same connection. It is not thread-aware. + executed on the same connection. From fd849956cc717f13c42c711b1ee13ba24337c512 Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Wed, 7 Jun 2017 15:14:55 -0400 Subject: [PATCH 0099/1139] postgres_fdw: Allow cancellation of transaction control commands. Commit f039eaac7131ef2a4cf63a10cf98486f8bcd09d2, later back-patched with commit 1b812afb0eafe125b820cc3b95e7ca03821aa675, allowed many of the queries issued by postgres_fdw to fetch remote data to respond to cancel interrupts in a timely fashion. However, it didn't do anything about the transaction control commands, which remained noninterruptible. Improve the situation by changing do_sql_command() to retrieve query results using pgfdw_get_result(), which uses the asynchronous interface to libpq so that it can check for interrupts every time libpq returns control. Since this might result in a situation where we can no longer be sure that the remote transaction state matches the local transaction state, add a facility to force all levels of the local transaction to abort if we've lost track of the remote state; without this, an apparently-successful commit of the local transaction might fail to commit changes made on the remote side. Also, add a 60-second timeout for queries issue during transaction abort; if that expires, give up and mark the state of the connection as unknown. Drop all such connections when we exit the local transaction. Together, these changes mean that if we're aborting the local toplevel transaction anyway, we can just drop the remote connection in lieu of waiting (possibly for a very long time) for it to complete an abort. This still leaves quite a bit of room for improvement. PQcancel() has no asynchronous interface, so if we get stuck sending the cancel request we'll still hang. Also, PQsetnonblocking() is not used, which means we could block uninterruptibly when sending a query. There might be some other optimizations possible as well. Nonetheless, this allows us to escape a wait for an unresponsive remote server quickly in many more cases than previously. Report by Suraj Kharage. Patch by me and Rafia Sabih. Review and testing by Amit Kapila and Tushar Ahuja. Discussion: http://postgr.es/m/CAF1DzPU8Kx+fMXEbFoP289xtm3bz3t+ZfxhmKavr98Bh-C0TqQ@mail.gmail.com --- contrib/postgres_fdw/connection.c | 361 +++++++++++++++++++++++++----- 1 file changed, 308 insertions(+), 53 deletions(-) diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c index ff04f43cf2..a3b7bf8c22 100644 --- a/contrib/postgres_fdw/connection.c +++ b/contrib/postgres_fdw/connection.c @@ -14,12 +14,15 @@ #include "postgres_fdw.h" +#include "access/htup_details.h" +#include "catalog/pg_user_mapping.h" #include "access/xact.h" #include "mb/pg_wchar.h" #include "miscadmin.h" #include "storage/latch.h" #include "utils/hsearch.h" #include "utils/memutils.h" +#include "utils/syscache.h" /* @@ -48,6 +51,7 @@ typedef struct ConnCacheEntry * one level of subxact open, etc */ bool have_prep_stmt; /* have we prepared any stmts in this xact? */ bool have_error; /* have any subxacts aborted in this xact? */ + bool changing_xact_state; /* xact state change in process */ } ConnCacheEntry; /* @@ -73,6 +77,12 @@ static void pgfdw_subxact_callback(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg); +static void pgfdw_reject_incomplete_xact_state_change(ConnCacheEntry *entry); +static bool pgfdw_cancel_query(PGconn *conn); +static bool pgfdw_exec_cleanup_query(PGconn *conn, const char *query, + bool ignore_errors); +static bool pgfdw_get_cleanup_result(PGconn *conn, TimestampTz endtime, + PGresult **result); /* @@ -138,8 +148,12 @@ GetConnection(UserMapping *user, bool will_prep_stmt) entry->xact_depth = 0; entry->have_prep_stmt = false; entry->have_error = false; + entry->changing_xact_state = false; } + /* Reject further use of connections which failed abort cleanup. */ + pgfdw_reject_incomplete_xact_state_change(entry); + /* * We don't check the health of cached connection here, because it would * require some overhead. Broken connection will be detected when the @@ -352,7 +366,9 @@ do_sql_command(PGconn *conn, const char *sql) { PGresult *res; - res = PQexec(conn, sql); + if (!PQsendQuery(conn, sql)) + pgfdw_report_error(ERROR, NULL, conn, false, sql); + res = pgfdw_get_result(conn, sql); if (PQresultStatus(res) != PGRES_COMMAND_OK) pgfdw_report_error(ERROR, res, conn, true, sql); PQclear(res); @@ -385,8 +401,10 @@ begin_remote_xact(ConnCacheEntry *entry) sql = "START TRANSACTION ISOLATION LEVEL SERIALIZABLE"; else sql = "START TRANSACTION ISOLATION LEVEL REPEATABLE READ"; + entry->changing_xact_state = true; do_sql_command(entry->conn, sql); entry->xact_depth = 1; + entry->changing_xact_state = false; } /* @@ -399,8 +417,10 @@ begin_remote_xact(ConnCacheEntry *entry) char sql[64]; snprintf(sql, sizeof(sql), "SAVEPOINT s%d", entry->xact_depth + 1); + entry->changing_xact_state = true; do_sql_command(entry->conn, sql); entry->xact_depth++; + entry->changing_xact_state = false; } } @@ -613,6 +633,8 @@ pgfdw_xact_callback(XactEvent event, void *arg) /* If it has an open remote transaction, try to close it */ if (entry->xact_depth > 0) { + bool abort_cleanup_failure = false; + elog(DEBUG3, "closing remote transaction on connection %p", entry->conn); @@ -620,8 +642,17 @@ pgfdw_xact_callback(XactEvent event, void *arg) { case XACT_EVENT_PARALLEL_PRE_COMMIT: case XACT_EVENT_PRE_COMMIT: + + /* + * If abort cleanup previously failed for this connection, + * we can't issue any more commands against it. + */ + pgfdw_reject_incomplete_xact_state_change(entry); + /* Commit all remote transactions during pre-commit */ + entry->changing_xact_state = true; do_sql_command(entry->conn, "COMMIT TRANSACTION"); + entry->changing_xact_state = false; /* * If there were any errors in subtransactions, and we @@ -669,6 +700,27 @@ pgfdw_xact_callback(XactEvent event, void *arg) break; case XACT_EVENT_PARALLEL_ABORT: case XACT_EVENT_ABORT: + + /* + * Don't try to clean up the connection if we're already + * in error recursion trouble. + */ + if (in_error_recursion_trouble()) + entry->changing_xact_state = true; + + /* + * If connection is already unsalvageable, don't touch it + * further. + */ + if (entry->changing_xact_state) + break; + + /* + * Mark this connection as in the process of changing + * transaction state. + */ + entry->changing_xact_state = true; + /* Assume we might have lost track of prepared statements */ entry->have_error = true; @@ -679,40 +731,35 @@ pgfdw_xact_callback(XactEvent event, void *arg) * command is still being processed by the remote server, * and if so, request cancellation of the command. */ - if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE) + if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE && + !pgfdw_cancel_query(entry->conn)) { - PGcancel *cancel; - char errbuf[256]; - - if ((cancel = PQgetCancel(entry->conn))) - { - if (!PQcancel(cancel, errbuf, sizeof(errbuf))) - ereport(WARNING, - (errcode(ERRCODE_CONNECTION_FAILURE), - errmsg("could not send cancel request: %s", - errbuf))); - PQfreeCancel(cancel); - } + /* Unable to cancel running query. */ + abort_cleanup_failure = true; + } + else if (!pgfdw_exec_cleanup_query(entry->conn, + "ABORT TRANSACTION", + false)) + { + /* Unable to abort remote transaction. */ + abort_cleanup_failure = true; + } + else if (entry->have_prep_stmt && entry->have_error && + !pgfdw_exec_cleanup_query(entry->conn, + "DEALLOCATE ALL", + true)) + { + /* Trouble clearing prepared statements. */ + abort_cleanup_failure = true; } - - /* If we're aborting, abort all remote transactions too */ - res = PQexec(entry->conn, "ABORT TRANSACTION"); - /* Note: can't throw ERROR, it would be infinite loop */ - if (PQresultStatus(res) != PGRES_COMMAND_OK) - pgfdw_report_error(WARNING, res, entry->conn, true, - "ABORT TRANSACTION"); else { - PQclear(res); - /* As above, make sure to clear any prepared stmts */ - if (entry->have_prep_stmt && entry->have_error) - { - res = PQexec(entry->conn, "DEALLOCATE ALL"); - PQclear(res); - } entry->have_prep_stmt = false; entry->have_error = false; } + + /* Disarm changing_xact_state if it all worked. */ + entry->changing_xact_state = abort_cleanup_failure; break; } } @@ -725,11 +772,13 @@ pgfdw_xact_callback(XactEvent event, void *arg) * recover. Next GetConnection will open a new connection. */ if (PQstatus(entry->conn) != CONNECTION_OK || - PQtransactionStatus(entry->conn) != PQTRANS_IDLE) + PQtransactionStatus(entry->conn) != PQTRANS_IDLE || + entry->changing_xact_state) { elog(DEBUG3, "discarding connection %p", entry->conn); PQfinish(entry->conn); entry->conn = NULL; + entry->changing_xact_state = false; } } @@ -772,7 +821,6 @@ pgfdw_subxact_callback(SubXactEvent event, SubTransactionId mySubid, hash_seq_init(&scan, ConnectionHash); while ((entry = (ConnCacheEntry *) hash_seq_search(&scan))) { - PGresult *res; char sql[100]; /* @@ -788,12 +836,33 @@ pgfdw_subxact_callback(SubXactEvent event, SubTransactionId mySubid, if (event == SUBXACT_EVENT_PRE_COMMIT_SUB) { + /* + * If abort cleanup previously failed for this connection, we + * can't issue any more commands against it. + */ + pgfdw_reject_incomplete_xact_state_change(entry); + /* Commit all remote subtransactions during pre-commit */ snprintf(sql, sizeof(sql), "RELEASE SAVEPOINT s%d", curlevel); + entry->changing_xact_state = true; do_sql_command(entry->conn, sql); + entry->changing_xact_state = false; } - else + else if (in_error_recursion_trouble()) + { + /* + * Don't try to clean up the connection if we're already in error + * recursion trouble. + */ + entry->changing_xact_state = true; + } + else if (!entry->changing_xact_state) { + bool abort_cleanup_failure = false; + + /* Remember that abort cleanup is in progress. */ + entry->changing_xact_state = true; + /* Assume we might have lost track of prepared statements */ entry->have_error = true; @@ -804,34 +873,220 @@ pgfdw_subxact_callback(SubXactEvent event, SubTransactionId mySubid, * processed by the remote server, and if so, request cancellation * of the command. */ - if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE) + if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE && + !pgfdw_cancel_query(entry->conn)) + abort_cleanup_failure = true; + else { - PGcancel *cancel; - char errbuf[256]; - - if ((cancel = PQgetCancel(entry->conn))) - { - if (!PQcancel(cancel, errbuf, sizeof(errbuf))) - ereport(WARNING, - (errcode(ERRCODE_CONNECTION_FAILURE), - errmsg("could not send cancel request: %s", - errbuf))); - PQfreeCancel(cancel); - } + /* Rollback all remote subtransactions during abort */ + snprintf(sql, sizeof(sql), + "ROLLBACK TO SAVEPOINT s%d; RELEASE SAVEPOINT s%d", + curlevel, curlevel); + if (!pgfdw_exec_cleanup_query(entry->conn, sql, false)) + abort_cleanup_failure = true; } - /* Rollback all remote subtransactions during abort */ - snprintf(sql, sizeof(sql), - "ROLLBACK TO SAVEPOINT s%d; RELEASE SAVEPOINT s%d", - curlevel, curlevel); - res = PQexec(entry->conn, sql); - if (PQresultStatus(res) != PGRES_COMMAND_OK) - pgfdw_report_error(WARNING, res, entry->conn, true, sql); - else - PQclear(res); + /* Disarm changing_xact_state if it all worked. */ + entry->changing_xact_state = abort_cleanup_failure; } /* OK, we're outta that level of subtransaction */ entry->xact_depth--; } } + +/* + * Raise an error if the given connection cache entry is marked as being + * in the middle of an xact state change. This should be called at which no + * such change is expected to be in progress; if one is found to be in + * progress, it means that we aborted in the middle of a previous state change + * and now don't know what the remote transaction state actually is. + * Such connections can't safely be further used. Re-establishing the + * connection would change the snapshot and roll back any writes already + * performed, so that's not an option, either. Thus, we must abort. + */ +static void +pgfdw_reject_incomplete_xact_state_change(ConnCacheEntry *entry) +{ + HeapTuple tup; + Form_pg_user_mapping umform; + ForeignServer *server; + + if (!entry->changing_xact_state) + return; + + tup = SearchSysCache1(USERMAPPINGOID, + ObjectIdGetDatum(entry->key)); + if (!HeapTupleIsValid(tup)) + elog(ERROR, "cache lookup failed for user mapping %u", entry->key); + umform = (Form_pg_user_mapping) GETSTRUCT(tup); + server = GetForeignServer(umform->umserver); + ReleaseSysCache(tup); + + ereport(ERROR, + (errcode(ERRCODE_CONNECTION_EXCEPTION), + errmsg("connection to server \"%s\" was lost", + server->servername))); +} + +/* + * Cancel the currently-in-progress query (whose query text we do not have) + * and ignore the result. Returns true if we successfully cancel the query + * and discard any pending result, and false if not. + */ +static bool +pgfdw_cancel_query(PGconn *conn) +{ + PGcancel *cancel; + char errbuf[256]; + PGresult *result = NULL; + TimestampTz endtime; + + /* + * If it takes too long to cancel the query and discard the result, assume + * the connection is dead. + */ + endtime = TimestampTzPlusMilliseconds(GetCurrentTimestamp(), 30000); + + /* + * Issue cancel request. Unfortunately, there's no good way to limit the + * amount of time that we might block inside PQgetCancel(). + */ + if ((cancel = PQgetCancel(conn))) + { + if (!PQcancel(cancel, errbuf, sizeof(errbuf))) + { + ereport(WARNING, + (errcode(ERRCODE_CONNECTION_FAILURE), + errmsg("could not send cancel request: %s", + errbuf))); + PQfreeCancel(cancel); + return false; + } + PQfreeCancel(cancel); + } + + /* Get and discard the result of the query. */ + if (pgfdw_get_cleanup_result(conn, endtime, &result)) + return false; + PQclear(result); + + return true; +} + +/* + * Submit a query during (sub)abort cleanup and wait up to 30 seconds for the + * result. If the query is executed without error, the return value is true. + * If the query is executed successfully but returns an error, the return + * value is true if and only if ignore_errors is set. If the query can't be + * sent or times out, the return value is false. + */ +static bool +pgfdw_exec_cleanup_query(PGconn *conn, const char *query, bool ignore_errors) +{ + PGresult *result = NULL; + TimestampTz endtime; + + /* + * If it takes too long to execute a cleanup query, assume the connection + * is dead. It's fairly likely that this is why we aborted in the first + * place (e.g. statement timeout, user cancel), so the timeout shouldn't + * be too long. + */ + endtime = TimestampTzPlusMilliseconds(GetCurrentTimestamp(), 30000); + + /* + * Submit a query. Since we don't use non-blocking mode, this also can + * block. But its risk is relatively small, so we ignore that for now. + */ + if (!PQsendQuery(conn, query)) + { + pgfdw_report_error(WARNING, NULL, conn, false, query); + return false; + } + + /* Get the result of the query. */ + if (pgfdw_get_cleanup_result(conn, endtime, &result)) + return false; + + /* Issue a warning if not successful. */ + if (PQresultStatus(result) != PGRES_COMMAND_OK) + { + pgfdw_report_error(WARNING, result, conn, true, query); + return ignore_errors; + } + + return true; +} + +/* + * Get, during abort cleanup, the result of a query that is in progress. This + * might be a query that is being interrupted by transaction abort, or it might + * be a query that was initiated as part of transaction abort to get the remote + * side back to the appropriate state. + * + * It's not a huge problem if we throw an ERROR here, but if we get into error + * recursion trouble, we'll end up slamming the connection shut, which will + * necessitate failing the entire toplevel transaction even if subtransactions + * were used. Try to use WARNING where we can. + * + * endtime is the time at which we should give up and assume the remote + * side is dead. Returns true if the timeout expired, otherwise false. + * Sets *result except in case of a timeout. + */ +static bool +pgfdw_get_cleanup_result(PGconn *conn, TimestampTz endtime, PGresult **result) +{ + PGresult *last_res = NULL; + + for (;;) + { + PGresult *res; + + while (PQisBusy(conn)) + { + int wc; + TimestampTz now = GetCurrentTimestamp(); + long secs; + int microsecs; + long cur_timeout; + + /* If timeout has expired, give up, else get sleep time. */ + if (now >= endtime) + return true; + TimestampDifference(now, endtime, &secs, µsecs); + + /* To protect against clock skew, limit sleep to one minute. */ + cur_timeout = Min(60000, secs * USECS_PER_SEC + microsecs); + + /* Sleep until there's something to do */ + wc = WaitLatchOrSocket(MyLatch, + WL_LATCH_SET | WL_SOCKET_READABLE | WL_TIMEOUT, + PQsocket(conn), + cur_timeout); + ResetLatch(MyLatch); + + CHECK_FOR_INTERRUPTS(); + + /* Data available in socket */ + if (wc & WL_SOCKET_READABLE) + { + if (!PQconsumeInput(conn)) + { + *result = NULL; + return false; + } + } + } + + res = PQgetResult(conn); + if (res == NULL) + break; /* query is complete */ + + PQclear(last_res); + last_res = res; + } + + *result = last_res; + return false; +} From 3c017a545f9c6e658e59baab636315c386b09d0b Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Sat, 10 Jun 2017 10:19:06 -0400 Subject: [PATCH 0100/1139] Take PROVE_FLAGS from the command line but not the environment This reverts commit 56b6ef893fee9e9bf47d927a02f4d1ea911f4d9c and instead makes vcregress.pl parse out PROVE_FLAGS from a command line argument when doing a TAP test, thus making it consistent with the makefile treatment. Discussion: https://postgr.es/m/c26a7416-2fb9-34ab-7991-618c922f896e%402ndquadrant.com Backpatch to 9.4 like previous patch. --- src/Makefile.global.in | 2 +- src/tools/msvc/vcregress.pl | 12 +++++++++--- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/Makefile.global.in b/src/Makefile.global.in index 1c9fc2bb87..8ac7ca7d2b 100644 --- a/src/Makefile.global.in +++ b/src/Makefile.global.in @@ -336,7 +336,7 @@ PROVE = @PROVE@ # extra perl modules in their own directory. PG_PROVE_FLAGS = -I $(top_srcdir)/src/test/perl/ -I $(srcdir) # User-supplied prove flags such as --verbose can be provided in PROVE_FLAGS. - +PROVE_FLAGS = # prepend to path if already set, else just set it define add_to_path diff --git a/src/tools/msvc/vcregress.pl b/src/tools/msvc/vcregress.pl index dc976d0072..3acb9c0ee8 100644 --- a/src/tools/msvc/vcregress.pl +++ b/src/tools/msvc/vcregress.pl @@ -177,12 +177,18 @@ sub tap_check die "Tap tests not enabled in configuration" unless $config->{tap_tests}; + my @flags; + foreach my $arg (0 .. scalar(@_)) + { + next unless $_[$arg] =~ /^PROVE_FLAGS=(.*)/; + @flags = split(/\s+/, $1); + splice(@_,$arg,1); + last; + } + my $dir = shift; chdir $dir; - my @flags; - @flags = split(/\s+/,$ENV{PROVE_FLAGS}) if exists $ENV{PROVE_FLAGS}; - my @args = ("prove", @flags, "t/*.pl"); # adjust the environment for just this test From 318fd99ce7e775158c87b8515780f2663d2df429 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 12 Jun 2017 20:04:33 -0400 Subject: [PATCH 0101/1139] Assert that we don't invent relfilenodes or type OIDs in binary upgrade. During pg_upgrade's restore run, all relfilenode choices should be overridden by commands in the dump script. If we ever find ourselves choosing a relfilenode in the ordinary way, someone blew it. Likewise for pg_type OIDs. Since pg_upgrade might well succeed anyway, if there happens not to be a conflict during the regression test run, we need assertions here to keep us on the straight and narrow. We might someday be able to remove the assertion in GetNewRelFileNode, if pg_upgrade is rewritten to remove its assumption that old and new relfilenodes always match. But it's hard to see how to get rid of the pg_type OID constraint, since those OIDs are embedded in user tables in some cases. Back-patch as far as 9.5, because of the risk of back-patches breaking something here even if it works in HEAD. I'd prefer to go back further, but 9.4 fails both assertions due to get_rel_infos()'s use of a temporary table. We can't use the later-branch solution of a CTE for compatibility reasons (cf commit 5d16332e9), and it doesn't seem worth inventing some other way to do the query. (I did check, by dint of changing the Asserts to elog(WARNING), that there are no other cases of unwanted OID assignments during 9.4's regression test run.) Discussion: https://postgr.es/m/19785.1497215827@sss.pgh.pa.us --- src/backend/catalog/catalog.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/backend/catalog/catalog.c b/src/backend/catalog/catalog.c index 1baaa0bb89..809524819d 100644 --- a/src/backend/catalog/catalog.c +++ b/src/backend/catalog/catalog.c @@ -37,6 +37,7 @@ #include "catalog/pg_shdescription.h" #include "catalog/pg_shseclabel.h" #include "catalog/pg_tablespace.h" +#include "catalog/pg_type.h" #include "catalog/toasting.h" #include "miscadmin.h" #include "storage/fd.h" @@ -336,6 +337,14 @@ GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn) ScanKeyData key; bool collides; + /* + * We should never be asked to generate a new pg_type OID during + * pg_upgrade; doing so would risk collisions with the OIDs it wants to + * assign. Hitting this assert means there's some path where we failed to + * ensure that a type OID is determined by commands in the dump script. + */ + Assert(!IsBinaryUpgrade || RelationGetRelid(relation) != TypeRelationId); + InitDirtySnapshot(SnapshotDirty); /* Generate new OIDs until we find one not in the table */ @@ -387,6 +396,13 @@ GetNewRelFileNode(Oid reltablespace, Relation pg_class, char relpersistence) bool collides; BackendId backend; + /* + * If we ever get here during pg_upgrade, there's something wrong; all + * relfilenode assignments during a binary-upgrade run should be + * determined by commands in the dump script. + */ + Assert(!IsBinaryUpgrade); + switch (relpersistence) { case RELPERSISTENCE_TEMP: From e3f87aae9316d42ece1912d1cae34ec0ba8142c8 Mon Sep 17 00:00:00 2001 From: Tatsuo Ishii Date: Thu, 15 Jun 2017 10:01:39 +0900 Subject: [PATCH 0102/1139] Fix document bug regarding read only transactions. It was explained that read only transactions (not in standby) allow to update sequences. This had been wrong since the commit: 05d8a561ff85db1545f5768fe8d8dc9d99ad2ef7 Discussion: https://www.postgresql.org/message-id/20170614.110826.425627939780392324.t-ishii%40sraoss.co.jp --- doc/src/sgml/high-availability.sgml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/src/sgml/high-availability.sgml b/doc/src/sgml/high-availability.sgml index a1960299c0..774d2b4bce 100644 --- a/doc/src/sgml/high-availability.sgml +++ b/doc/src/sgml/high-availability.sgml @@ -1783,7 +1783,7 @@ if (!triggered) In normal operation, read-only transactions are allowed to - update sequences and to use LISTEN, UNLISTEN, and + use LISTEN, UNLISTEN, and NOTIFY, so Hot Standby sessions operate under slightly tighter restrictions than ordinary read-only sessions. It is possible that some of these restrictions might be loosened in a future release. From a0873fbabb9e9eebb65cf1891c6f1b11290fcd4e Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Thu, 15 Jun 2017 12:30:02 -0400 Subject: [PATCH 0103/1139] docs: Fix pg_upgrade standby server upgrade docs It was unsafe to instruct users to start/stop the server after pg_upgrade was run but before the standby servers were rsync'ed. The new instructions avoid this. RELEASE NOTES: This fix should be mentioned in the minor release notes. Reported-by: Dmitriy Sarafannikov and Sergey Burladyan Discussion: https://postgr.es/m/87wp8o506b.fsf@seb.koffice.internal Backpatch-through: 9.5, where standby server upgrade instructions first appeared --- doc/src/sgml/ref/pgupgrade.sgml | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index bbb606d1ca..8b05b22c98 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -317,15 +317,22 @@ NET STOP postgresql-9.0 - Verify standby servers + Prepare for standby server upgrades - If you are upgrading Streaming Replication and Log-Shipping standby - servers, verify that the old standby servers are caught up by running - pg_controldata against the old primary and standby - clusters. Verify that the Latest checkpoint location - values match in all clusters. (There will be a mismatch if old - standby servers were shut down before the old primary.) + If you are upgrading standby servers (as outlined in section ), verify that the old standby + servers are caught up by running pg_controldata + against the old primary and standby clusters. Verify that the + Latest checkpoint location values match in all clusters. + (There will be a mismatch if old standby servers were shut down + before the old primary.) + + + + Also, if upgrading standby servers, change wal_level + to replica in the postgresql.conf file on + the new master cluster. @@ -410,7 +417,7 @@ pg_upgrade.exe - + Upgrade Streaming Replication and Log-Shipping standby servers @@ -471,16 +478,6 @@ pg_upgrade.exe - - Start and stop the new master cluster - - - In the new master cluster, change wal_level to - replica in the postgresql.conf file - and then start and stop the cluster. - - - Run <application>rsync</> From 1798dd153d6f513c56c2888bcd72f3de854f4d78 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Thu, 15 Jun 2017 13:25:45 -0400 Subject: [PATCH 0104/1139] doc: remove mention of Windows junction points by pg_upgrade pg_upgrade never used Windows junction points but instead always used Windows hard links. Reported-by: Adrian Klaver Discussion: https://postgr.es/m/6a638c60-90bb-4921-8ee4-5fdad68f8b09@aklaver.com Backpatch-through: 9.3, where the mention first appeared --- doc/src/sgml/ref/pgupgrade.sgml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index 8b05b22c98..b4f775ff8e 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -123,7 +123,7 @@ use hard links instead of copying files to the new - cluster (use junction points on Windows) + cluster From b2174598775f4bfbc1ff0d7f30e1e2659421afb9 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 15 Jun 2017 15:03:39 -0400 Subject: [PATCH 0105/1139] Fix low-probability leaks of PGresult objects in the backend. We had three occurrences of essentially the same coding pattern wherein we tried to retrieve a query result from a libpq connection without blocking. In the case where PQconsumeInput failed (typically indicating a lost connection), all three loops simply gave up and returned, forgetting to clear any previously-collected PGresult object. Since those are malloc'd not palloc'd, the oversight results in a process-lifespan memory leak. One instance, in libpqwalreceiver, is of little significance because the walreceiver process would just quit anyway if its connection fails. But we might as well fix it. The other two instances, in postgres_fdw, are somewhat more worrisome because at least in principle the scenario could be repeated, allowing the amount of memory leaked to build up to something worth worrying about. Moreover, in these cases the loops contain CHECK_FOR_INTERRUPTS calls, as well as other calls that could potentially elog(ERROR), providing another way to exit without having cleared the PGresult. Here we need to add PG_TRY logic similar to what exists in quite a few other places in postgres_fdw. Coverity noted the libpqwalreceiver bug; I found the other two cases by checking all calls of PQconsumeInput. Back-patch to all supported versions as appropriate (9.2 lacks postgres_fdw, so this is really quite unexciting for that branch). Discussion: https://postgr.es/m/22620.1497486981@sss.pgh.pa.us --- contrib/postgres_fdw/connection.c | 154 +++++++++++------- .../libpqwalreceiver/libpqwalreceiver.c | 14 +- 2 files changed, 102 insertions(+), 66 deletions(-) diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c index a3b7bf8c22..4023471434 100644 --- a/contrib/postgres_fdw/connection.c +++ b/contrib/postgres_fdw/connection.c @@ -494,7 +494,7 @@ pgfdw_exec_query(PGconn *conn, const char *query) * * This function offers quick responsiveness by checking for any interruptions. * - * This function emulates the PQexec()'s behavior of returning the last result + * This function emulates PQexec()'s behavior of returning the last result * when there are many. * * Caller is responsible for the error handling on the result. @@ -502,40 +502,50 @@ pgfdw_exec_query(PGconn *conn, const char *query) PGresult * pgfdw_get_result(PGconn *conn, const char *query) { - PGresult *last_res = NULL; + PGresult *volatile last_res = NULL; - for (;;) + /* In what follows, do not leak any PGresults on an error. */ + PG_TRY(); { - PGresult *res; - - while (PQisBusy(conn)) + for (;;) { - int wc; + PGresult *res; - /* Sleep until there's something to do */ - wc = WaitLatchOrSocket(MyLatch, - WL_LATCH_SET | WL_SOCKET_READABLE, - PQsocket(conn), - -1L); - ResetLatch(MyLatch); + while (PQisBusy(conn)) + { + int wc; - CHECK_FOR_INTERRUPTS(); + /* Sleep until there's something to do */ + wc = WaitLatchOrSocket(MyLatch, + WL_LATCH_SET | WL_SOCKET_READABLE, + PQsocket(conn), + -1L); + ResetLatch(MyLatch); - /* Data available in socket */ - if (wc & WL_SOCKET_READABLE) - { - if (!PQconsumeInput(conn)) - pgfdw_report_error(ERROR, NULL, conn, false, query); + CHECK_FOR_INTERRUPTS(); + + /* Data available in socket? */ + if (wc & WL_SOCKET_READABLE) + { + if (!PQconsumeInput(conn)) + pgfdw_report_error(ERROR, NULL, conn, false, query); + } } - } - res = PQgetResult(conn); - if (res == NULL) - break; /* query is complete */ + res = PQgetResult(conn); + if (res == NULL) + break; /* query is complete */ + PQclear(last_res); + last_res = res; + } + } + PG_CATCH(); + { PQclear(last_res); - last_res = res; + PG_RE_THROW(); } + PG_END_TRY(); return last_res; } @@ -1015,6 +1025,7 @@ pgfdw_exec_cleanup_query(PGconn *conn, const char *query, bool ignore_errors) pgfdw_report_error(WARNING, result, conn, true, query); return ignore_errors; } + PQclear(result); return true; } @@ -1037,56 +1048,75 @@ pgfdw_exec_cleanup_query(PGconn *conn, const char *query, bool ignore_errors) static bool pgfdw_get_cleanup_result(PGconn *conn, TimestampTz endtime, PGresult **result) { - PGresult *last_res = NULL; + volatile bool timed_out = false; + PGresult *volatile last_res = NULL; - for (;;) + /* In what follows, do not leak any PGresults on an error. */ + PG_TRY(); { - PGresult *res; - - while (PQisBusy(conn)) + for (;;) { - int wc; - TimestampTz now = GetCurrentTimestamp(); - long secs; - int microsecs; - long cur_timeout; - - /* If timeout has expired, give up, else get sleep time. */ - if (now >= endtime) - return true; - TimestampDifference(now, endtime, &secs, µsecs); - - /* To protect against clock skew, limit sleep to one minute. */ - cur_timeout = Min(60000, secs * USECS_PER_SEC + microsecs); - - /* Sleep until there's something to do */ - wc = WaitLatchOrSocket(MyLatch, + PGresult *res; + + while (PQisBusy(conn)) + { + int wc; + TimestampTz now = GetCurrentTimestamp(); + long secs; + int microsecs; + long cur_timeout; + + /* If timeout has expired, give up, else get sleep time. */ + if (now >= endtime) + { + timed_out = true; + goto exit; + } + TimestampDifference(now, endtime, &secs, µsecs); + + /* To protect against clock skew, limit sleep to one minute. */ + cur_timeout = Min(60000, secs * USECS_PER_SEC + microsecs); + + /* Sleep until there's something to do */ + wc = WaitLatchOrSocket(MyLatch, WL_LATCH_SET | WL_SOCKET_READABLE | WL_TIMEOUT, - PQsocket(conn), - cur_timeout); - ResetLatch(MyLatch); + PQsocket(conn), + cur_timeout); + ResetLatch(MyLatch); - CHECK_FOR_INTERRUPTS(); + CHECK_FOR_INTERRUPTS(); - /* Data available in socket */ - if (wc & WL_SOCKET_READABLE) - { - if (!PQconsumeInput(conn)) + /* Data available in socket? */ + if (wc & WL_SOCKET_READABLE) { - *result = NULL; - return false; + if (!PQconsumeInput(conn)) + { + /* connection trouble; treat the same as a timeout */ + timed_out = true; + goto exit; + } } } - } - res = PQgetResult(conn); - if (res == NULL) - break; /* query is complete */ + res = PQgetResult(conn); + if (res == NULL) + break; /* query is complete */ + PQclear(last_res); + last_res = res; + } +exit: ; + } + PG_CATCH(); + { PQclear(last_res); - last_res = res; + PG_RE_THROW(); } + PG_END_TRY(); - *result = last_res; - return false; + if (timed_out) + PQclear(last_res); + else + *result = last_res; + return timed_out; } diff --git a/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c b/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c index f1c843e868..3e8ae1c12f 100644 --- a/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c +++ b/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c @@ -478,14 +478,20 @@ libpqrcv_PQexec(const char *query) */ if (!libpq_select(-1)) continue; /* interrupted */ + + /* Consume whatever data is available from the socket */ if (PQconsumeInput(streamConn) == 0) - return NULL; /* trouble */ + { + /* trouble; drop whatever we had and return NULL */ + PQclear(lastResult); + return NULL; + } } /* - * Emulate the PQexec()'s behavior of returning the last result when - * there are many. Since walsender will never generate multiple - * results, we skip the concatenation of error messages. + * Emulate PQexec()'s behavior of returning the last result when there + * are many. Since walsender will never generate multiple results, we + * skip the concatenation of error messages. */ result = PQgetResult(streamConn); if (result == NULL) From a9a5eb32b38443540def8f2d47f0b118601acbf5 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Thu, 15 Jun 2017 10:42:10 +0300 Subject: [PATCH 0106/1139] Fix dependency, when changing a function's argument/return type. When a new base type is created using the old-style procedure of first creating the input/output functions with "opaque" in place of the base type, the "opaque" argument/return type is changed to the final base type, on CREATE TYPE. However, we did not create a pg_depend record when doing that, so the functions were left not depending on the type. Fixes bug #14706, reported by Karen Huddleston. Discussion: https://www.postgresql.org/message-id/20170614232259.1424.82774@wrigleys.postgresql.org --- src/backend/commands/functioncmds.c | 20 ++++++++++++++++++ src/test/regress/expected/create_type.out | 25 +++++++++++++++++++++++ src/test/regress/sql/create_type.sql | 11 ++++++++++ 3 files changed, 56 insertions(+) diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c index e161cd9fcd..6f8900ac49 100644 --- a/src/backend/commands/functioncmds.c +++ b/src/backend/commands/functioncmds.c @@ -1318,6 +1318,8 @@ SetFunctionReturnType(Oid funcOid, Oid newRetType) Relation pg_proc_rel; HeapTuple tup; Form_pg_proc procForm; + ObjectAddress func_address; + ObjectAddress type_address; pg_proc_rel = heap_open(ProcedureRelationId, RowExclusiveLock); @@ -1338,6 +1340,14 @@ SetFunctionReturnType(Oid funcOid, Oid newRetType) CatalogUpdateIndexes(pg_proc_rel, tup); heap_close(pg_proc_rel, RowExclusiveLock); + + /* + * Also update the dependency to the new type. Opaque is a pinned type, so + * there is no old dependency record for it that we would need to remove. + */ + ObjectAddressSet(type_address, TypeRelationId, newRetType); + ObjectAddressSet(func_address, ProcedureRelationId, funcOid); + recordDependencyOn(&func_address, &type_address, DEPENDENCY_NORMAL); } @@ -1352,6 +1362,8 @@ SetFunctionArgType(Oid funcOid, int argIndex, Oid newArgType) Relation pg_proc_rel; HeapTuple tup; Form_pg_proc procForm; + ObjectAddress func_address; + ObjectAddress type_address; pg_proc_rel = heap_open(ProcedureRelationId, RowExclusiveLock); @@ -1373,6 +1385,14 @@ SetFunctionArgType(Oid funcOid, int argIndex, Oid newArgType) CatalogUpdateIndexes(pg_proc_rel, tup); heap_close(pg_proc_rel, RowExclusiveLock); + + /* + * Also update the dependency to the new type. Opaque is a pinned type, so + * there is no old dependency record for it that we would need to remove. + */ + ObjectAddressSet(type_address, TypeRelationId, newArgType); + ObjectAddressSet(func_address, ProcedureRelationId, funcOid); + recordDependencyOn(&func_address, &type_address, DEPENDENCY_NORMAL); } diff --git a/src/test/regress/expected/create_type.out b/src/test/regress/expected/create_type.out index 7bdad4e9bb..5886a1f37f 100644 --- a/src/test/regress/expected/create_type.out +++ b/src/test/regress/expected/create_type.out @@ -115,6 +115,31 @@ CREATE TYPE not_existing_type (INPUT = array_in, ELEMENT = int, INTERNALLENGTH = 32); ERROR: function array_out(not_existing_type) does not exist +-- Check dependency transfer of opaque functions when creating a new type +CREATE FUNCTION base_fn_in(cstring) RETURNS opaque AS 'boolin' + LANGUAGE internal IMMUTABLE STRICT; +CREATE FUNCTION base_fn_out(opaque) RETURNS opaque AS 'boolout' + LANGUAGE internal IMMUTABLE STRICT; +CREATE TYPE base_type(INPUT = base_fn_in, OUTPUT = base_fn_out); +WARNING: changing argument type of function base_fn_out from "opaque" to base_type +WARNING: changing return type of function base_fn_in from opaque to base_type +WARNING: changing return type of function base_fn_out from opaque to cstring +DROP FUNCTION base_fn_in(cstring); -- error +ERROR: cannot drop function base_fn_in(cstring) because other objects depend on it +DETAIL: type base_type depends on function base_fn_in(cstring) +function base_fn_out(base_type) depends on type base_type +HINT: Use DROP ... CASCADE to drop the dependent objects too. +DROP FUNCTION base_fn_out(opaque); -- error +ERROR: function base_fn_out(opaque) does not exist +DROP TYPE base_type; -- error +ERROR: cannot drop type base_type because other objects depend on it +DETAIL: function base_fn_out(base_type) depends on type base_type +function base_fn_in(cstring) depends on type base_type +HINT: Use DROP ... CASCADE to drop the dependent objects too. +DROP TYPE base_type CASCADE; +NOTICE: drop cascades to 2 other objects +DETAIL: drop cascades to function base_fn_out(base_type) +drop cascades to function base_fn_in(cstring) -- Check usage of typmod with a user-defined type -- (we have borrowed numeric's typmod functions) CREATE TEMP TABLE mytab (foo widget(42,13,7)); -- should fail diff --git a/src/test/regress/sql/create_type.sql b/src/test/regress/sql/create_type.sql index a1839ef9e7..a28303aa6a 100644 --- a/src/test/regress/sql/create_type.sql +++ b/src/test/regress/sql/create_type.sql @@ -115,6 +115,17 @@ CREATE TYPE not_existing_type (INPUT = array_in, ELEMENT = int, INTERNALLENGTH = 32); +-- Check dependency transfer of opaque functions when creating a new type +CREATE FUNCTION base_fn_in(cstring) RETURNS opaque AS 'boolin' + LANGUAGE internal IMMUTABLE STRICT; +CREATE FUNCTION base_fn_out(opaque) RETURNS opaque AS 'boolout' + LANGUAGE internal IMMUTABLE STRICT; +CREATE TYPE base_type(INPUT = base_fn_in, OUTPUT = base_fn_out); +DROP FUNCTION base_fn_in(cstring); -- error +DROP FUNCTION base_fn_out(opaque); -- error +DROP TYPE base_type; -- error +DROP TYPE base_type CASCADE; + -- Check usage of typmod with a user-defined type -- (we have borrowed numeric's typmod functions) From 810344436db69eb29ca5761fbed872c42de9e7d5 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Sun, 18 Jun 2017 18:48:22 -0700 Subject: [PATCH 0107/1139] Fix leaking of small spilled subtransactions during logical decoding. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When, during logical decoding, a transaction gets too big, it's contents get spilled to disk. Not just the top-transaction gets spilled, but *also* all of its subtransactions, even if they're not that large themselves. Unfortunately we didn't clean up such small spilled subtransactions from disk. Fix that, by keeping better track of whether a transaction has been spilled to disk. Author: Andres Freund Reported-By: Dmitriy Sarafannikov, Fabrízio de Royes Mello Discussion: https://postgr.es/m/1457621358.355011041@f382.i.mail.ru https://postgr.es/m/CAFcNs+qNMhNYii4nxpO6gqsndiyxNDYV0S=JNq0v_sEE+9PHXg@mail.gmail.com Backpatch: 9.4-, where logical decoding was introduced --- src/backend/replication/logical/reorderbuffer.c | 7 ++++--- src/include/replication/reorderbuffer.h | 9 +++++++++ 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index 72c70585bc..81bab8cf14 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -934,7 +934,7 @@ ReorderBufferIterTXNInit(ReorderBuffer *rb, ReorderBufferTXN *txn) { ReorderBufferChange *cur_change; - if (txn->nentries != txn->nentries_mem) + if (txn->serialized) { /* serialize remaining changes */ ReorderBufferSerializeTXN(rb, txn); @@ -963,7 +963,7 @@ ReorderBufferIterTXNInit(ReorderBuffer *rb, ReorderBufferTXN *txn) { ReorderBufferChange *cur_change; - if (cur_txn->nentries != cur_txn->nentries_mem) + if (cur_txn->serialized) { /* serialize remaining changes */ ReorderBufferSerializeTXN(rb, cur_txn); @@ -1185,7 +1185,7 @@ ReorderBufferCleanupTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) Assert(found); /* remove entries spilled to disk */ - if (txn->nentries != txn->nentries_mem) + if (txn->serialized) ReorderBufferRestoreCleanup(rb, txn); /* deallocate */ @@ -2167,6 +2167,7 @@ ReorderBufferSerializeTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) Assert(spilled == txn->nentries_mem); Assert(dlist_is_empty(&txn->changes)); txn->nentries_mem = 0; + txn->serialized = true; if (fd != -1) CloseTransientFile(fd); diff --git a/src/include/replication/reorderbuffer.h b/src/include/replication/reorderbuffer.h index 9e209aef4f..a7ebf29382 100644 --- a/src/include/replication/reorderbuffer.h +++ b/src/include/replication/reorderbuffer.h @@ -212,6 +212,15 @@ typedef struct ReorderBufferTXN */ uint64 nentries_mem; + /* + * Has this transaction been spilled to disk? It's not always possible to + * deduce that fact by comparing nentries with nentries_mem, because + * e.g. subtransactions of a large transaction might get serialized + * together with the parent - if they're restored to memory they'd have + * nentries_mem == nentries. + */ + bool serialized; + /* * List of ReorderBufferChange structs, including new Snapshots and new * CommandIds From 3ef40dcec621672fb5e4f0c1893b95811044bf6a Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 19 Jun 2017 11:02:45 -0400 Subject: [PATCH 0108/1139] On Windows, make pg_dump use binary mode for compressed plain text output. The combination of -Z -Fp and output to stdout resulted in corrupted output data, because we left stdout in text mode, resulting in newline conversion being done on the compressed stream. Switch stdout to binary mode for this case, at the same place where we do it for non-text output formats. Report and patch by Kuntal Ghosh, tested by Ashutosh Sharma and Neha Sharma. Back-patch to all supported branches. Discussion: https://postgr.es/m/CAGz5QCJPvbBjXAmJuGx1B_41yVCetAJhp7rtaDf7XQGWuB1GSw@mail.gmail.com --- src/bin/pg_dump/pg_backup_archiver.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c index c360b92dd6..a23b070c0e 100644 --- a/src/bin/pg_dump/pg_backup_archiver.c +++ b/src/bin/pg_dump/pg_backup_archiver.c @@ -2328,12 +2328,12 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt, AH->OF = stdout; /* - * On Windows, we need to use binary mode to read/write non-text archive - * formats. Force stdin/stdout into binary mode if that is what we are - * using. + * On Windows, we need to use binary mode to read/write non-text files, + * which include all archive formats as well as compressed plain text. + * Force stdin/stdout into binary mode if that is what we are using. */ #ifdef WIN32 - if (fmt != archNull && + if ((fmt != archNull || compression != 0) && (AH->fSpec == NULL || strcmp(AH->fSpec, "") == 0)) { if (mode == archModeWrite) From 1f184426b7637a64c1f43d3c70a3db3f9b949893 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 19 Jun 2017 15:33:41 -0400 Subject: [PATCH 0109/1139] Avoid regressions in foreign-key-based selectivity estimates. David Rowley found that the "use the smallest per-column selectivity" heuristic applied in some cases by get_foreign_key_join_selectivity() was badly off if the FK columns are independent, producing estimates much worse than we got before that code was added in 9.6. One case where that heuristic was used was for LEFT and FULL outer joins with the referenced rel on the outside of the join. But we should not really need to special-case those here. eqjoinsel() never has had such a special case; the correction is applied by calc_joinrel_size_estimate() instead. Let's just estimate such cases like inner joins and rely on that later adjustment. (I think there was something of a thinko here, in that the comments seem to be thinking about the selectivity as defined for semi/anti joins; but that shouldn't apply to left/full joins.) Add a regression test exercising such a case to show that this is sane in at least some cases. The other case where we used that heuristic was for SEMI/ANTI outer joins, either if the referenced rel was on the outside, or if it was on the inside but was part of a join within the RHS. In either case, the FK doesn't give us a lot of traction towards estimating the selectivity. To ensure that we don't have regressions from what happened before 9.6, let's punt by ignoring the FK in such cases and applying the traditional selectivity calculation. (We might be able to improve on that later, but for now I just want to be sure it's not worse than 9.5.) Report and patch by David Rowley, simplified a bit by me. Back-patch to 9.6 where this code was added. Discussion: https://postgr.es/m/CAKJS1f8NO8oCDcxrteohG6O72uU1saEVT9qX=R8pENr5QWerXw@mail.gmail.com --- src/backend/optimizer/path/costsize.c | 97 +++++++++------------------ src/test/regress/expected/join.out | 35 ++++++++++ src/test/regress/sql/join.sql | 28 ++++++++ 3 files changed, 93 insertions(+), 67 deletions(-) diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c index 3b5576694e..fa9b322610 100644 --- a/src/backend/optimizer/path/costsize.c +++ b/src/backend/optimizer/path/costsize.c @@ -4095,7 +4095,6 @@ get_foreign_key_join_selectivity(PlannerInfo *root, { ForeignKeyOptInfo *fkinfo = (ForeignKeyOptInfo *) lfirst(lc); bool ref_is_outer; - bool use_smallest_selectivity = false; List *removedlist; ListCell *cell; ListCell *prev; @@ -4114,6 +4113,22 @@ get_foreign_key_join_selectivity(PlannerInfo *root, else continue; + /* + * If we're dealing with a semi/anti join, and the FK's referenced + * relation is on the outside, then knowledge of the FK doesn't help + * us figure out what we need to know (which is the fraction of outer + * rows that have matches). On the other hand, if the referenced rel + * is on the inside, then all outer rows must have matches in the + * referenced table (ignoring nulls). But any restriction or join + * clauses that filter that table will reduce the fraction of matches. + * We can account for restriction clauses, but it's too hard to guess + * how many table rows would get through a join that's inside the RHS. + * Hence, if either case applies, punt and ignore the FK. + */ + if ((jointype == JOIN_SEMI || jointype == JOIN_ANTI) && + (ref_is_outer || bms_membership(inner_relids) != BMS_SINGLETON)) + continue; + /* * Modify the restrictlist by removing clauses that match the FK (and * putting them into removedlist instead). It seems unsafe to modify @@ -4214,10 +4229,7 @@ get_foreign_key_join_selectivity(PlannerInfo *root, * However (1) if there are any strict restriction clauses for the * referencing column(s) elsewhere in the query, derating here would * be double-counting the null fraction, and (2) it's not very clear - * how to combine null fractions for multiple referencing columns. - * - * In the use_smallest_selectivity code below, null derating is done - * implicitly by relying on clause_selectivity(); in the other cases, + * how to combine null fractions for multiple referencing columns. So * we do nothing for now about correcting for nulls. * * XXX another point here is that if either side of an FK constraint @@ -4230,52 +4242,23 @@ get_foreign_key_join_selectivity(PlannerInfo *root, * work, it is uncommon in practice to have an FK referencing a parent * table. So, at least for now, disregard inheritance here. */ - if (ref_is_outer && jointype != JOIN_INNER) + if (jointype == JOIN_SEMI || jointype == JOIN_ANTI) { /* - * When the referenced table is on the outer side of a non-inner - * join, knowing that each inner row has exactly one match is not - * as useful as one could wish, since we really need to know the - * fraction of outer rows with a match. Still, we can avoid the - * folly of multiplying the per-column estimates together. Take - * the smallest per-column selectivity, instead. (This should - * correspond to the FK column with the most nulls.) + * For JOIN_SEMI and JOIN_ANTI, we only get here when the FK's + * referenced table is exactly the inside of the join. The join + * selectivity is defined as the fraction of LHS rows that have + * matches. The FK implies that every LHS row has a match *in the + * referenced table*; but any restriction clauses on it will + * reduce the number of matches. Hence we take the join + * selectivity as equal to the selectivity of the table's + * restriction clauses, which is rows / tuples; but we must guard + * against tuples == 0. */ - use_smallest_selectivity = true; - } - else if (jointype == JOIN_SEMI || jointype == JOIN_ANTI) - { - /* - * For JOIN_SEMI and JOIN_ANTI, the selectivity is defined as the - * fraction of LHS rows that have matches. The referenced table - * is on the inner side (we already handled the other case above), - * so the FK implies that every LHS row has a match *in the - * referenced table*. But any restriction or join clauses below - * here will reduce the number of matches. - */ - if (bms_membership(inner_relids) == BMS_SINGLETON) - { - /* - * When the inner side of the semi/anti join is just the - * referenced table, we may take the FK selectivity as equal - * to the selectivity of the table's restriction clauses. - */ - RelOptInfo *ref_rel = find_base_rel(root, fkinfo->ref_relid); - double ref_tuples = Max(ref_rel->tuples, 1.0); + RelOptInfo *ref_rel = find_base_rel(root, fkinfo->ref_relid); + double ref_tuples = Max(ref_rel->tuples, 1.0); - fkselec *= ref_rel->rows / ref_tuples; - } - else - { - /* - * When the inner side of the semi/anti join is itself a join, - * it's hard to guess what fraction of the referenced table - * will get through the join. But we still don't want to - * multiply per-column estimates together. Take the smallest - * per-column selectivity, instead. - */ - use_smallest_selectivity = true; - } + fkselec *= ref_rel->rows / ref_tuples; } else { @@ -4289,26 +4272,6 @@ get_foreign_key_join_selectivity(PlannerInfo *root, fkselec *= 1.0 / ref_tuples; } - - /* - * Common code for cases where we should use the smallest selectivity - * that would be computed for any one of the FK's clauses. - */ - if (use_smallest_selectivity) - { - Selectivity thisfksel = 1.0; - - foreach(cell, removedlist) - { - RestrictInfo *rinfo = (RestrictInfo *) lfirst(cell); - Selectivity csel; - - csel = clause_selectivity(root, (Node *) rinfo, - 0, jointype, sjinfo); - thisfksel = Min(thisfksel, csel); - } - fkselec *= thisfksel; - } } *restrictlist = worklist; diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out index c3bb4fe767..eafc933e8f 100644 --- a/src/test/regress/expected/join.out +++ b/src/test/regress/expected/join.out @@ -5323,3 +5323,38 @@ ERROR: invalid reference to FROM-clause entry for table "xx1" LINE 1: ...xx1 using lateral (select * from int4_tbl where f1 = x1) ss; ^ HINT: There is an entry for table "xx1", but it cannot be referenced from this part of the query. +-- +-- test that foreign key join estimation performs sanely for outer joins +-- +begin; +create table fkest (a int, b int, c int unique, primary key(a,b)); +create table fkest1 (a int, b int, primary key(a,b)); +insert into fkest select x/10, x%10, x from generate_series(1,1000) x; +insert into fkest1 select x/10, x%10 from generate_series(1,1000) x; +alter table fkest1 + add constraint fkest1_a_b_fkey foreign key (a,b) references fkest; +analyze fkest; +analyze fkest1; +explain (costs off) +select * +from fkest f + left join fkest1 f1 on f.a = f1.a and f.b = f1.b + left join fkest1 f2 on f.a = f2.a and f.b = f2.b + left join fkest1 f3 on f.a = f3.a and f.b = f3.b +where f.c = 1; + QUERY PLAN +------------------------------------------------------------------ + Nested Loop Left Join + -> Nested Loop Left Join + -> Nested Loop Left Join + -> Index Scan using fkest_c_key on fkest f + Index Cond: (c = 1) + -> Index Only Scan using fkest1_pkey on fkest1 f1 + Index Cond: ((a = f.a) AND (b = f.b)) + -> Index Only Scan using fkest1_pkey on fkest1 f2 + Index Cond: ((a = f.a) AND (b = f.b)) + -> Index Only Scan using fkest1_pkey on fkest1 f3 + Index Cond: ((a = f.a) AND (b = f.b)) +(11 rows) + +rollback; diff --git a/src/test/regress/sql/join.sql b/src/test/regress/sql/join.sql index bf18a8f6c4..af6d6129c8 100644 --- a/src/test/regress/sql/join.sql +++ b/src/test/regress/sql/join.sql @@ -1730,3 +1730,31 @@ update xx1 set x2 = f1 from xx1, lateral (select * from int4_tbl where f1 = x1) delete from xx1 using (select * from int4_tbl where f1 = x1) ss; delete from xx1 using (select * from int4_tbl where f1 = xx1.x1) ss; delete from xx1 using lateral (select * from int4_tbl where f1 = x1) ss; + +-- +-- test that foreign key join estimation performs sanely for outer joins +-- + +begin; + +create table fkest (a int, b int, c int unique, primary key(a,b)); +create table fkest1 (a int, b int, primary key(a,b)); + +insert into fkest select x/10, x%10, x from generate_series(1,1000) x; +insert into fkest1 select x/10, x%10 from generate_series(1,1000) x; + +alter table fkest1 + add constraint fkest1_a_b_fkey foreign key (a,b) references fkest; + +analyze fkest; +analyze fkest1; + +explain (costs off) +select * +from fkest f + left join fkest1 f1 on f.a = f1.a and f.b = f1.b + left join fkest1 f2 on f.a = f2.a and f.b = f2.b + left join fkest1 f3 on f.a = f3.a and f.b = f3.b +where f.c = 1; + +rollback; From 1dce0536497d12957c2c71498ca893672f1135c0 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 19 Jun 2017 18:32:22 -0400 Subject: [PATCH 0110/1139] Fix materialized-view documentation oversights. When materialized views were added, psql's \d commands were made to treat them as a separate object category ... but not everyplace in the documentation or comments got the memo. Noted by David Johnston. Back-patch to 9.3 where matviews came in. Discussion: https://postgr.es/m/CAKFQuwb27M3VXRhHErjCpkWwN9eKThbqWb1=trtoXi9_ejqPXQ@mail.gmail.com --- doc/src/sgml/ref/psql-ref.sgml | 12 +++++++----- src/bin/psql/describe.c | 2 +- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml index 0c846e1452..d74d025bee 100644 --- a/doc/src/sgml/ref/psql-ref.sgml +++ b/doc/src/sgml/ref/psql-ref.sgml @@ -1071,7 +1071,8 @@ testdb=> - For each relation (table, view, index, sequence, or foreign table) + For each relation (table, view, materialized view, index, sequence, + or foreign table) or composite type matching the pattern, show all columns, their types, the tablespace (if not the default) and any @@ -1086,8 +1087,8 @@ testdb=> For some types of relation, \d shows additional information - for each column: column values for sequences, indexed expression for - indexes and foreign data wrapper options for foreign tables. + for each column: column values for sequences, indexed expressions for + indexes, and foreign data wrapper options for foreign tables. @@ -1109,8 +1110,9 @@ testdb=> If \d is used without a pattern argument, it is - equivalent to \dtvsE which will show a list of - all visible tables, views, sequences and foreign tables. + equivalent to \dtvmsE which will show a list of + all visible tables, views, materialized views, sequences and + foreign tables. This is purely a convenience measure. diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c index e48f347031..6b1436cdbd 100644 --- a/src/bin/psql/describe.c +++ b/src/bin/psql/describe.c @@ -2993,7 +2993,6 @@ listDbRoleSettings(const char *pattern, const char *pattern2) * s - sequences * E - foreign table (Note: different from 'f', the relkind value) * (any order of the above is fine) - * If tabtypes is empty, we default to \dtvsE. */ bool listTables(const char *tabtypes, const char *pattern, bool verbose, bool showSystem) @@ -3010,6 +3009,7 @@ listTables(const char *tabtypes, const char *pattern, bool verbose, bool showSys printQueryOpt myopt = pset.popt; static const bool translate_columns[] = {false, false, true, false, false, false, false}; + /* If tabtypes is empty, we default to \dtvmsE (but see also command.c) */ if (!(showTables || showIndexes || showViews || showMatViews || showSeq || showForeign)) showTables = showViews = showMatViews = showSeq = showForeign = true; From 0efdbd323e53091779ddc3f048123214612a76f9 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Tue, 20 Jun 2017 13:20:02 -0400 Subject: [PATCH 0111/1139] pg_upgrade: start/stop new server after pg_resetwal When commit 0f33a719fdbb5d8c43839ea0d2c90cd03e2af2d2 removed the instructions to start/stop the new cluster before running rsync, it was now possible for pg_resetwal/pg_resetxlog to leave the final WAL record at wal_level=minimum, preventing upgraded standby servers from reconnecting. This patch fixes that by having pg_upgrade unconditionally start/stop the new cluster after pg_resetwal/pg_resetxlog has run. Backpatch through 9.2 since, though the instructions were added in PG 9.5, they worked all the way back to 9.2. Discussion: https://postgr.es/m/20170620171844.GC24975@momjian.us Backpatch-through: 9.2 --- src/bin/pg_upgrade/check.c | 16 +++++++++++----- src/bin/pg_upgrade/pg_upgrade.c | 2 +- src/bin/pg_upgrade/pg_upgrade.h | 2 +- 3 files changed, 13 insertions(+), 7 deletions(-) diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c index a3ee116a8c..a26e55ca7f 100644 --- a/src/bin/pg_upgrade/check.c +++ b/src/bin/pg_upgrade/check.c @@ -164,15 +164,21 @@ report_clusters_compatible(void) void -issue_warnings(void) +issue_warnings_and_set_wal_level(void) { + /* + * We unconditionally start/stop the new server because pg_resetwal -o + * set wal_level to 'minimum'. If the user is upgrading standby + * servers using the rsync instructions, they will need pg_upgrade + * to write its final WAL record showing wal_level as 'replica'. + */ + start_postmaster(&new_cluster, true); + /* Create dummy large object permissions for old < PG 9.0? */ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804) - { - start_postmaster(&new_cluster, true); new_9_0_populate_pg_largeobject_metadata(&new_cluster, false); - stop_postmaster(false); - } + + stop_postmaster(false); } diff --git a/src/bin/pg_upgrade/pg_upgrade.c b/src/bin/pg_upgrade/pg_upgrade.c index 90c07205bf..710b8efb87 100644 --- a/src/bin/pg_upgrade/pg_upgrade.c +++ b/src/bin/pg_upgrade/pg_upgrade.c @@ -160,7 +160,7 @@ main(int argc, char **argv) create_script_for_cluster_analyze(&analyze_script_file_name); create_script_for_old_cluster_deletion(&deletion_script_file_name); - issue_warnings(); + issue_warnings_and_set_wal_level(); pg_log(PG_REPORT, "\nUpgrade Complete\n"); pg_log(PG_REPORT, "----------------\n"); diff --git a/src/bin/pg_upgrade/pg_upgrade.h b/src/bin/pg_upgrade/pg_upgrade.h index 19dca83386..439552c5da 100644 --- a/src/bin/pg_upgrade/pg_upgrade.h +++ b/src/bin/pg_upgrade/pg_upgrade.h @@ -334,7 +334,7 @@ void output_check_banner(bool live_check); void check_and_dump_old_cluster(bool live_check); void check_new_cluster(void); void report_clusters_compatible(void); -void issue_warnings(void); +void issue_warnings_and_set_wal_level(void); void output_completion_banner(char *analyze_script_file_name, char *deletion_script_file_name); void check_cluster_versions(void); From 6fd9930e68a3de6a05e6f60b08b16f219982ad05 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Wed, 21 Jun 2017 11:55:07 +0300 Subject: [PATCH 0112/1139] Fix typo in comment. Etsuro Fujita --- src/backend/executor/execMain.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index d406ee9783..9bc255ea0c 100644 --- a/src/backend/executor/execMain.c +++ b/src/backend/executor/execMain.c @@ -1828,8 +1828,8 @@ ExecWithCheckOptions(WCOKind kind, ResultRelInfo *resultRelInfo, * the permissions on the relation (that is, if the user * could view it directly anyway). For RLS violations, we * don't include the data since we don't know if the user - * should be able to view the tuple as as that depends on - * the USING policy. + * should be able to view the tuple as that depends on the + * USING policy. */ case WCO_VIEW_CHECK: insertedCols = GetInsertedColumns(resultRelInfo, estate); From 39e30cbc16cf8d2bd8fb8c5697d02eb220d26ffc Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Wed, 21 Jun 2017 14:14:38 -0700 Subject: [PATCH 0113/1139] Fix possibility of creating a "phantom" segment after promotion. When promoting a standby just after a XLOG_SWITCH record was replayed, and next segment(s) are already are locally available (via walsender, restore_command + trigger/recovery target), that segment could accidentally be recycled onto the past of the new timeline. Later checkpointer would create a .ready file for it, assuming there was an error during creation, and it would get archived. That causes trouble if another standby is later brought up from a basebackup from before the timeline creation, because it would try to read the segment, because XLogFileReadAnyTLI just tries all possible timelines, which doesn't have valid contents. Thus replay would fail. The problem, if already occurred, can be fixed by removing the segment and/or having restore_command filter it out. The reason for the creation of such "phantom" segments was, that after an XLOG_SWITCH record the EndOfLog variable points to the beginning of the next segment, and RemoveXlogFile() used XLByteToPrevSeg(). Normally RemoveXlogFile() doing so is harmless, because the last segment will still exist preventing InstallXLogFileSegment() from causing harm, but just after promotion there's no previous segment on the new timeline. Fix that by using XLByteToSeg() instead of XLByteToPrevSeg(). Author: Andres Freund Reported-By: Greg Burek Discussion: https://postgr.es/m/20170619073026.zcwpe6mydsaz5ygd@alap3.anarazel.de Backpatch: 9.2-, bug older than all supported versions --- src/backend/access/transam/xlog.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index dab9e68d3b..f7e76f2f7e 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -3811,7 +3811,7 @@ RemoveXlogFile(const char *segname, XLogRecPtr PriorRedoPtr, XLogRecPtr endptr) /* * Initialize info about where to try to recycle to. */ - XLByteToPrevSeg(endptr, endlogSegNo); + XLByteToSeg(endptr, endlogSegNo); if (PriorRedoPtr == InvalidXLogRecPtr) recycleSegNo = endlogSegNo + 10; else From 4947fced73c2ba43aaddaaba24320aaf5702307e Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Thu, 22 Jun 2017 16:42:38 -0400 Subject: [PATCH 0114/1139] Fix typo in comment Once upon a time, WAL pointers could be NULL, but no longer. We talk about "valid" now. Reported-by: Amit Langote Discussion: https://postgr.es/m/33e9617d-27f1-eee8-3311-e27af98eaf2b@lab.ntt.co.jp --- src/backend/access/transam/xlog.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index f7e76f2f7e..68109e2541 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -3972,7 +3972,7 @@ CleanupBackupHistory(void) /* * Attempt to read an XLOG record. * - * If RecPtr is not NULL, try to read a record at that position. Otherwise + * If RecPtr is valid, try to read a record at that position. Otherwise * try to read a record just after the last one previously read. * * If no valid record is available, returns NULL, or fails if emode is PANIC. From 9bfb1f2d64c4cab108a69e4bf66da4c2464dcaaf Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 26 Jun 2017 10:31:10 -0400 Subject: [PATCH 0115/1139] Minor code review for parse_phrase_operator(). Fix its header comment, which described the old behavior of the phrase distance operator; we missed updating that in commit 028350f61. Also, reset errno before strtol() call, to defend against the possibility that it was already ERANGE at entry. (The lack of complaints says that it generally isn't, but this is at least a latent bug.) Very minor stylistic improvements as well. Victor Drobny noted the obsolete comment, I noted the errno issue. Back-patch to 9.6 where this code was added, just in case the errno issue is a live bug in some cases. Discussion: https://postgr.es/m/2b5382fdff9b1f79d5eb2c99c4d2cbe2@postgrespro.ru --- src/backend/utils/adt/tsquery.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/backend/utils/adt/tsquery.c b/src/backend/utils/adt/tsquery.c index f0bd52877f..df75ee4f1e 100644 --- a/src/backend/utils/adt/tsquery.c +++ b/src/backend/utils/adt/tsquery.c @@ -113,7 +113,7 @@ get_modifiers(char *buf, int16 *weight, bool *prefix) * Parse phrase operator. The operator * may take the following forms: * - * a b (distance is no greater than X) + * a b (distance is exactly N lexemes) * a <-> b (default distance = 1) * * The buffer should begin with '<' char @@ -129,10 +129,9 @@ parse_phrase_operator(char *buf, int16 *distance) PHRASE_ERR, PHRASE_FINISH } state = PHRASE_OPEN; - char *ptr = buf; char *endptr; - long l = 1; + long l = 1; /* default distance */ while (*ptr) { @@ -151,16 +150,17 @@ parse_phrase_operator(char *buf, int16 *distance) ptr++; break; } - else if (!t_isdigit(ptr)) + if (!t_isdigit(ptr)) { state = PHRASE_ERR; break; } + errno = 0; l = strtol(ptr, &endptr, 10); if (ptr == endptr) state = PHRASE_ERR; - else if (errno == ERANGE || l > MAXENTRYPOS) + else if (errno == ERANGE || l < 0 || l > MAXENTRYPOS) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("distance in phrase operator should not be greater than %d", From f6af9c749de0ee53232565cb54a765fe253814df Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 26 Jun 2017 16:17:05 -0400 Subject: [PATCH 0116/1139] Ignore old stats file timestamps when starting the stats collector. The stats collector disregards inquiry messages that bear a cutoff_time before when it last wrote the relevant stats file. That's fine, but at startup when it reads the "permanent" stats files, it absorbed their timestamps as if they were the times at which the corresponding temporary stats files had been written. In reality, of course, there's no data out there at all. This led to disregarding inquiry messages soon after startup if the postmaster had been shut down and restarted within less than PGSTAT_STAT_INTERVAL; which is a pretty common scenario, both for testing and in the field. Requesting backends would hang for 10 seconds and then report failure to read statistics, unless they got bailed out by some other backend coming along and making a newer request within that interval. I came across this through investigating unexpected delays in the src/test/recovery TAP tests: it manifests there because the autovacuum launcher hangs for 10 seconds when it can't get statistics at startup, thus preventing a second shutdown from occurring promptly. We might want to do some things in the autovac code to make it less prone to getting stuck that way, but this change is a good bug fix regardless. In passing, also fix pgstat_read_statsfiles() to ensure that it re-zeroes its global stats variables if they are corrupted by a short read from the stats file. (Other reads in that function go into temp variables, so that the issue doesn't arise.) This has been broken since we created the separation between permanent and temporary stats files in 8.4, so back-patch to all supported branches. Discussion: https://postgr.es/m/16860.1498442626@sss.pgh.pa.us --- src/backend/postmaster/pgstat.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c index a3edfedc6f..480d3b1876 100644 --- a/src/backend/postmaster/pgstat.c +++ b/src/backend/postmaster/pgstat.c @@ -4278,9 +4278,20 @@ pgstat_read_statsfiles(Oid onlydb, bool permanent, bool deep) { ereport(pgStatRunningInCollector ? LOG : WARNING, (errmsg("corrupted statistics file \"%s\"", statfile))); + memset(&globalStats, 0, sizeof(globalStats)); goto done; } + /* + * In the collector, disregard the timestamp we read from the permanent + * stats file; we should be willing to write a temp stats file immediately + * upon the first request from any backend. This only matters if the old + * file's timestamp is less than PGSTAT_STAT_INTERVAL ago, but that's not + * an unusual scenario. + */ + if (pgStatRunningInCollector) + globalStats.stats_timestamp = 0; + /* * Read archiver stats struct */ @@ -4288,6 +4299,7 @@ pgstat_read_statsfiles(Oid onlydb, bool permanent, bool deep) { ereport(pgStatRunningInCollector ? LOG : WARNING, (errmsg("corrupted statistics file \"%s\"", statfile))); + memset(&archiverStats, 0, sizeof(archiverStats)); goto done; } @@ -4332,6 +4344,15 @@ pgstat_read_statsfiles(Oid onlydb, bool permanent, bool deep) dbentry->tables = NULL; dbentry->functions = NULL; + /* + * In the collector, disregard the timestamp we read from the + * permanent stats file; we should be willing to write a temp + * stats file immediately upon the first request from any + * backend. + */ + if (pgStatRunningInCollector) + dbentry->stats_timestamp = 0; + /* * Don't create tables/functions hashtables for uninteresting * databases. From a4d1ce095bbebeefe055c74fafbb6ea736058e11 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 26 Jun 2017 17:31:56 -0400 Subject: [PATCH 0117/1139] Don't lose walreceiver start requests due to race condition in postmaster. When a walreceiver dies, the startup process will notice that and send a PMSIGNAL_START_WALRECEIVER signal to the postmaster, asking for a new walreceiver to be launched. There's a race condition, which at least in HEAD is very easy to hit, whereby the postmaster might see that signal before it processes the SIGCHLD from the walreceiver process. In that situation, sigusr1_handler() just dropped the start request on the floor, reasoning that it must be redundant. Eventually, after 10 seconds (WALRCV_STARTUP_TIMEOUT), the startup process would make a fresh request --- but that's a long time if the connection could have been re-established almost immediately. Fix it by setting a state flag inside the postmaster that we won't clear until we do launch a walreceiver. In cases where that results in an extra walreceiver launch, it's up to the walreceiver to realize it's unwanted and go away --- but we have, and need, that logic anyway for the opposite race case. I came across this through investigating unexpected delays in the src/test/recovery TAP tests: it manifests there in test cases where a master server is stopped and restarted while leaving streaming slaves active. This logic has been broken all along, so back-patch to all supported branches. Discussion: https://postgr.es/m/21344.1498494720@sss.pgh.pa.us --- src/backend/postmaster/postmaster.c | 39 +++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 7 deletions(-) diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 6f923bdbdb..c0cdc23227 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -354,6 +354,9 @@ static volatile sig_atomic_t start_autovac_launcher = false; /* the launcher needs to be signalled to communicate some condition */ static volatile bool avlauncher_needs_signal = false; +/* received START_WALRECEIVER signal */ +static volatile sig_atomic_t WalReceiverRequested = false; + /* set when there's a worker that needs to be started up */ static volatile bool StartWorkerNeeded = true; static volatile bool HaveCrashedWorker = false; @@ -417,6 +420,7 @@ static void maybe_start_bgworkers(void); static bool CreateOptsFile(int argc, char *argv[], char *fullprogname); static pid_t StartChildProcess(AuxProcType type); static void StartAutovacuumWorker(void); +static void MaybeStartWalReceiver(void); static void InitPostmasterDeathWatchHandle(void); /* @@ -1783,6 +1787,10 @@ ServerLoop(void) kill(AutoVacPID, SIGUSR2); } + /* If we need to start a WAL receiver, try to do that now */ + if (WalReceiverRequested) + MaybeStartWalReceiver(); + /* Get other worker processes running, if needed */ if (StartWorkerNeeded || HaveCrashedWorker) maybe_start_bgworkers(); @@ -2923,7 +2931,8 @@ reaper(SIGNAL_ARGS) /* * Was it the wal receiver? If exit status is zero (normal) or one * (FATAL exit), we assume everything is all right just like normal - * backends. + * backends. (If we need a new wal receiver, we'll start one at the + * next iteration of the postmaster's main loop.) */ if (pid == WalReceiverPID) { @@ -5011,14 +5020,12 @@ sigusr1_handler(SIGNAL_ARGS) StartAutovacuumWorker(); } - if (CheckPostmasterSignal(PMSIGNAL_START_WALRECEIVER) && - WalReceiverPID == 0 && - (pmState == PM_STARTUP || pmState == PM_RECOVERY || - pmState == PM_HOT_STANDBY || pmState == PM_WAIT_READONLY) && - Shutdown == NoShutdown) + if (CheckPostmasterSignal(PMSIGNAL_START_WALRECEIVER)) { /* Startup Process wants us to start the walreceiver process. */ - WalReceiverPID = StartWalReceiver(); + /* Start immediately if possible, else remember request for later. */ + WalReceiverRequested = true; + MaybeStartWalReceiver(); } if (CheckPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE) && @@ -5369,6 +5376,24 @@ StartAutovacuumWorker(void) } } +/* + * MaybeStartWalReceiver + * Start the WAL receiver process, if not running and our state allows. + */ +static void +MaybeStartWalReceiver(void) +{ + if (WalReceiverPID == 0 && + (pmState == PM_STARTUP || pmState == PM_RECOVERY || + pmState == PM_HOT_STANDBY || pmState == PM_WAIT_READONLY) && + Shutdown == NoShutdown) + { + WalReceiverPID = StartWalReceiver(); + WalReceiverRequested = false; + } +} + + /* * Create the opts file */ From df31a9fc66f11e824872dc09d22f389cbd5bc803 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 26 Jun 2017 19:01:26 -0400 Subject: [PATCH 0118/1139] Reduce wal_retrieve_retry_interval in applicable TAP tests. By default, wal_retrieve_retry_interval is five seconds, which is far more than is needed in any of our TAP tests, leaving the test cases just twiddling their thumbs for significant stretches. Moreover, because it's so large, we get basically no testing of the retry-before- master-is-ready code path. Hence, make PostgresNode::init set up wal_retrieve_retry_interval = '500ms' as part of its customization of test clusters' postgresql.conf. This shaves quite a few seconds off the runtime of the recovery TAP tests. Back-patch into 9.6. We have wal_retrieve_retry_interval in 9.5, but the test infrastructure isn't there. Discussion: https://postgr.es/m/31624.1498500416@sss.pgh.pa.us --- src/test/perl/PostgresNode.pm | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm index 65c4a88045..711d0deae8 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgresNode.pm @@ -413,6 +413,7 @@ sub init print $conf "fsync = off\n"; print $conf "restart_after_crash = off\n"; print $conf "log_statement = all\n"; + print $conf "wal_retrieve_retry_interval = '500ms'\n"; print $conf "port = $port\n"; if ($params{allows_streaming}) From 7b25e2620e30ce722b78628c67b258407b8eeae2 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 27 Jun 2017 13:15:31 +0300 Subject: [PATCH 0119/1139] hide debug GUC variables --- contrib/mmts/multimaster.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/contrib/mmts/multimaster.c b/contrib/mmts/multimaster.c index ea14f92b8c..a23f4672da 100644 --- a/contrib/mmts/multimaster.c +++ b/contrib/mmts/multimaster.c @@ -2751,7 +2751,7 @@ _PG_init(void) 1, INT_MAX, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2795,7 +2795,7 @@ _PG_init(void) 1, INT_MAX, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2866,7 +2866,7 @@ _PG_init(void) &MtmUseDtm, true, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2879,7 +2879,7 @@ _PG_init(void) &MtmPreserveCommitOrder, true, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2892,7 +2892,7 @@ _PG_init(void) &MtmVolksWagenMode, false, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2907,7 +2907,7 @@ _PG_init(void) 1, INT_MAX, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2937,7 +2937,7 @@ _PG_init(void) 1, INT_MAX, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2952,7 +2952,7 @@ _PG_init(void) 1, INT_MAX, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL @@ -2968,7 +2968,7 @@ _PG_init(void) 1, INT_MAX, PGC_BACKEND, - 0, + GUC_NO_SHOW_ALL, NULL, NULL, NULL From 3a7bd59c4496b5b9a7cec9ab6f1eb6b111a8b046 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 27 Jun 2017 17:51:11 -0400 Subject: [PATCH 0120/1139] Re-allow SRFs and window functions within sub-selects within aggregates. check_agg_arguments_walker threw an error upon seeing a SRF or window function, but that is too aggressive: if the function is within a sub-select then it's perfectly fine. I broke the SRF case in commit 0436f6bde by copying the logic for window functions ... but that was broken too, and had been since commit eaccfded9. Repair both cases in HEAD, and the window function case back to 9.3. 9.2 gets this right. --- src/backend/parser/parse_agg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c index 481a4ddc48..f7975abe09 100644 --- a/src/backend/parser/parse_agg.c +++ b/src/backend/parser/parse_agg.c @@ -700,7 +700,7 @@ check_agg_arguments_walker(Node *node, /* Continue and descend into subtree */ } /* We can throw error on sight for a window function */ - if (IsA(node, WindowFunc)) + if (IsA(node, WindowFunc) && context->sublevels_up == 0) ereport(ERROR, (errcode(ERRCODE_GROUPING_ERROR), errmsg("aggregate function calls cannot contain window function calls"), From 55968ed89496d215e86abf0b913b0464cac90edf Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 27 Jun 2017 18:47:57 -0400 Subject: [PATCH 0121/1139] Support tcp_keepalives_idle option on Solaris. Turns out that the socket option for this is named TCP_KEEPALIVE_THRESHOLD, at least according to the tcp(7P) man page for Solaris 11. (But since that text refers to "SunOS", it's likely pretty ancient.) It appears that the symbol TCP_KEEPALIVE does get defined on that platform, but it doesn't seem to represent a valid protocol-level socket option. This leads to bleats in the postmaster log, and no tcp_keepalives_idle functionality. Per bug #14720 from Andrey Lizenko, as well as an earlier report from Dhiraj Chawla that nobody had followed up on. The issue's been there since we added the TCP_KEEPALIVE code path in commit 5acd417c8, so back-patch to all supported branches. Discussion: https://postgr.es/m/20170627163757.25161.528@wrigleys.postgresql.org --- src/backend/libpq/pqcomm.c | 40 ++++++++++++++++++++++++------- src/interfaces/libpq/fe-connect.c | 23 +++++++++++++----- 2 files changed, 48 insertions(+), 15 deletions(-) diff --git a/src/backend/libpq/pqcomm.c b/src/backend/libpq/pqcomm.c index ba42753c06..65b0206038 100644 --- a/src/backend/libpq/pqcomm.c +++ b/src/backend/libpq/pqcomm.c @@ -1653,7 +1653,7 @@ pq_setkeepaliveswin32(Port *port, int idle, int interval) int pq_getkeepalivesidle(Port *port) { -#if defined(TCP_KEEPIDLE) || defined(TCP_KEEPALIVE) || defined(WIN32) +#if defined(TCP_KEEPIDLE) || defined(TCP_KEEPALIVE_THRESHOLD) || defined(TCP_KEEPALIVE) || defined(WIN32) if (port == NULL || IS_AF_UNIX(port->laddr.addr.ss_family)) return 0; @@ -1665,7 +1665,8 @@ pq_getkeepalivesidle(Port *port) #ifndef WIN32 ACCEPT_TYPE_ARG3 size = sizeof(port->default_keepalives_idle); -#ifdef TCP_KEEPIDLE +#if defined(TCP_KEEPIDLE) + /* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPIDLE, (char *) &port->default_keepalives_idle, &size) < 0) @@ -1673,7 +1674,17 @@ pq_getkeepalivesidle(Port *port) elog(LOG, "getsockopt(TCP_KEEPIDLE) failed: %m"); port->default_keepalives_idle = -1; /* don't know */ } -#else +#elif defined(TCP_KEEPALIVE_THRESHOLD) + /* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris */ + if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, + (char *) &port->default_keepalives_idle, + &size) < 0) + { + elog(LOG, "getsockopt(TCP_KEEPALIVE_THRESHOLD) failed: %m"); + port->default_keepalives_idle = -1; /* don't know */ + } +#else /* must have TCP_KEEPALIVE */ + /* TCP_KEEPALIVE is the name of this option on macOS */ if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE, (char *) &port->default_keepalives_idle, &size) < 0) @@ -1681,7 +1692,7 @@ pq_getkeepalivesidle(Port *port) elog(LOG, "getsockopt(TCP_KEEPALIVE) failed: %m"); port->default_keepalives_idle = -1; /* don't know */ } -#endif /* TCP_KEEPIDLE */ +#endif /* KEEPIDLE/KEEPALIVE_THRESHOLD/KEEPALIVE */ #else /* WIN32 */ /* We can't get the defaults on Windows, so return "don't know" */ port->default_keepalives_idle = -1; @@ -1700,7 +1711,8 @@ pq_setkeepalivesidle(int idle, Port *port) if (port == NULL || IS_AF_UNIX(port->laddr.addr.ss_family)) return STATUS_OK; -#if defined(TCP_KEEPIDLE) || defined(TCP_KEEPALIVE) || defined(SIO_KEEPALIVE_VALS) +/* check SIO_KEEPALIVE_VALS here, not just WIN32, as some toolchains lack it */ +#if defined(TCP_KEEPIDLE) || defined(TCP_KEEPALIVE_THRESHOLD) || defined(TCP_KEEPALIVE) || defined(SIO_KEEPALIVE_VALS) if (idle == port->keepalives_idle) return STATUS_OK; @@ -1719,14 +1731,24 @@ pq_setkeepalivesidle(int idle, Port *port) if (idle == 0) idle = port->default_keepalives_idle; -#ifdef TCP_KEEPIDLE +#if defined(TCP_KEEPIDLE) + /* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPIDLE, (char *) &idle, sizeof(idle)) < 0) { elog(LOG, "setsockopt(TCP_KEEPIDLE) failed: %m"); return STATUS_ERROR; } -#else +#elif defined(TCP_KEEPALIVE_THRESHOLD) + /* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris */ + if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, + (char *) &idle, sizeof(idle)) < 0) + { + elog(LOG, "setsockopt(TCP_KEEPALIVE_THRESHOLD) failed: %m"); + return STATUS_ERROR; + } +#else /* must have TCP_KEEPALIVE */ + /* TCP_KEEPALIVE is the name of this option on macOS */ if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE, (char *) &idle, sizeof(idle)) < 0) { @@ -1739,7 +1761,7 @@ pq_setkeepalivesidle(int idle, Port *port) #else /* WIN32 */ return pq_setkeepaliveswin32(port, idle, port->keepalives_interval); #endif -#else /* TCP_KEEPIDLE || SIO_KEEPALIVE_VALS */ +#else /* no way to set it */ if (idle != 0) { elog(LOG, "setting the keepalive idle time is not supported"); @@ -1789,7 +1811,7 @@ pq_setkeepalivesinterval(int interval, Port *port) if (port == NULL || IS_AF_UNIX(port->laddr.addr.ss_family)) return STATUS_OK; -#if defined(TCP_KEEPINTVL) || defined (SIO_KEEPALIVE_VALS) +#if defined(TCP_KEEPINTVL) || defined(SIO_KEEPALIVE_VALS) if (interval == port->keepalives_interval) return STATUS_OK; diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c index ec468870d2..443b4fb3e2 100644 --- a/src/interfaces/libpq/fe-connect.c +++ b/src/interfaces/libpq/fe-connect.c @@ -1280,7 +1280,8 @@ setKeepalivesIdle(PGconn *conn) if (idle < 0) idle = 0; -#ifdef TCP_KEEPIDLE +#if defined(TCP_KEEPIDLE) + /* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ if (setsockopt(conn->sock, IPPROTO_TCP, TCP_KEEPIDLE, (char *) &idle, sizeof(idle)) < 0) { @@ -1291,9 +1292,20 @@ setKeepalivesIdle(PGconn *conn) SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); return 0; } -#else -#ifdef TCP_KEEPALIVE - /* Darwin uses TCP_KEEPALIVE rather than TCP_KEEPIDLE */ +#elif defined(TCP_KEEPALIVE_THRESHOLD) + /* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris */ + if (setsockopt(conn->sock, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, + (char *) &idle, sizeof(idle)) < 0) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("setsockopt(TCP_KEEPALIVE_THRESHOLD) failed: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + return 0; + } +#elif defined(TCP_KEEPALIVE) + /* TCP_KEEPALIVE is the name of this option on macOS */ if (setsockopt(conn->sock, IPPROTO_TCP, TCP_KEEPALIVE, (char *) &idle, sizeof(idle)) < 0) { @@ -1304,7 +1316,6 @@ setKeepalivesIdle(PGconn *conn) SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); return 0; } -#endif #endif return 1; @@ -1372,7 +1383,7 @@ setKeepalivesCount(PGconn *conn) return 1; } -#else /* Win32 */ +#else /* WIN32 */ #ifdef SIO_KEEPALIVE_VALS /* * Enable keepalives and set the keepalive values on Win32, From a2de017b30157c99e33cbc6457140e062a5ca26f Mon Sep 17 00:00:00 2001 From: Stephen Frost Date: Wed, 28 Jun 2017 10:34:01 -0400 Subject: [PATCH 0122/1139] Do not require 'public' to exist for pg_dump -c Commit 330b84d8c4 didn't contemplate the case where the public schema has been dropped and introduced a query which fails when there is no public schema into pg_dump (when used with -c). Adjust the query used by pg_dump to handle the case where the public schema doesn't exist and add tests to check that such a case no longer fails. Back-patch the specific fix to 9.6, as the prior commit was. Adding tests for this case involved adding support to the pg_dump TAP tests to work with multiple databases, which, while not a large change, is a bit much to back-patch, so that's only done in master. Addresses bug #14650 Discussion: https://www.postgresql.org/message-id/20170512181801.1795.47483%40wrigleys.postgresql.org --- src/bin/pg_dump/pg_dump.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 27a2a0c0a5..d1db3702be 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -3659,9 +3659,14 @@ getNamespaces(Archive *fout, int *numNamespaces) * essentially a no-op because the new public schema won't have an * entry in pg_init_privs anyway, as the entry will be removed when * the public schema is dropped. + * + * Further, we have to handle the case where the public schema does + * not exist at all. */ if (dopt->outputClean) - appendPQExpBuffer(query," AND pip.objoid <> 'public'::regnamespace"); + appendPQExpBuffer(query," AND pip.objoid <> " + "coalesce((select oid from pg_namespace " + "where nspname = 'public'),0)"); appendPQExpBuffer(query,") "); From 43c67e32fb2920233e680af7a7e979ebb762c7e8 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 28 Jun 2017 12:30:16 -0400 Subject: [PATCH 0123/1139] Second try at fixing tcp_keepalives_idle option on Solaris. Buildfarm evidence shows that TCP_KEEPALIVE_THRESHOLD doesn't exist after all on Solaris < 11. This means we need to take positive action to prevent the TCP_KEEPALIVE code path from being taken on that platform. I've chosen to limit it with "&& defined(__darwin__)", since it's unclear that anyone else would follow Apple's precedent of spelling the symbol that way. Also, follow a suggestion from Michael Paquier of eliminating code duplication by defining a couple of intermediate symbols for the socket option. In passing, make some effort to reduce the number of translatable messages by replacing "setsockopt(foo) failed" with "setsockopt(%s) failed", etc, throughout the affected files. And update relevant documentation so that it doesn't claim to provide an exhaustive list of the possible socket option names. Like the previous commit (f0256c774), back-patch to all supported branches. Discussion: https://postgr.es/m/20170627163757.25161.528@wrigleys.postgresql.org --- doc/src/sgml/config.sgml | 19 ++++--- doc/src/sgml/libpq.sgml | 19 ++++--- src/backend/libpq/pqcomm.c | 94 ++++++++++++------------------- src/interfaces/libpq/fe-connect.c | 60 ++++++++++---------- 4 files changed, 86 insertions(+), 106 deletions(-) diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml index fc15b33ba4..0baa79bb80 100644 --- a/doc/src/sgml/config.sgml +++ b/doc/src/sgml/config.sgml @@ -856,8 +856,8 @@ include_dir 'conf.d' Specifies the number of seconds of inactivity after which TCP should send a keepalive message to the client. A value of 0 uses the system default. - This parameter is supported only on systems that support the - TCP_KEEPIDLE or TCP_KEEPALIVE symbols, and on + This parameter is supported only on systems that support + TCP_KEEPIDLE or an equivalent socket option, and on Windows; on other systems, it must be zero. In sessions connected via a Unix-domain socket, this parameter is ignored and always reads as zero. @@ -882,9 +882,9 @@ include_dir 'conf.d' Specifies the number of seconds after which a TCP keepalive message that is not acknowledged by the client should be retransmitted. A value of 0 uses the system default. - This parameter is supported only on systems that support the - TCP_KEEPINTVL symbol, and on Windows; on other systems, it - must be zero. + This parameter is supported only on systems that support + TCP_KEEPINTVL or an equivalent socket option, and on + Windows; on other systems, it must be zero. In sessions connected via a Unix-domain socket, this parameter is ignored and always reads as zero. @@ -906,10 +906,11 @@ include_dir 'conf.d' Specifies the number of TCP keepalives that can be lost before - the server's connection to the client is considered dead. A value of 0 - uses the system default. This parameter is - supported only on systems that support the TCP_KEEPCNT - symbol; on other systems, it must be zero. + the server's connection to the client is considered dead. + A value of 0 uses the system default. + This parameter is supported only on systems that support + TCP_KEEPCNT or an equivalent socket option; + on other systems, it must be zero. In sessions connected via a Unix-domain socket, this parameter is ignored and always reads as zero. diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml index 983cf0d386..84590a0a6f 100644 --- a/doc/src/sgml/libpq.sgml +++ b/doc/src/sgml/libpq.sgml @@ -1073,10 +1073,10 @@ postgresql://%2Fvar%2Flib%2Fpostgresql/dbname Controls the number of seconds of inactivity after which TCP should send a keepalive message to the server. A value of zero uses the system default. This parameter is ignored for connections made via a - Unix-domain socket, or if keepalives are disabled. It is only supported - on systems where the TCP_KEEPIDLE or TCP_KEEPALIVE - socket option is available, and on Windows; on other systems, it has no - effect. + Unix-domain socket, or if keepalives are disabled. + It is only supported on systems where TCP_KEEPIDLE or + an equivalent socket option is available, and on Windows; on other + systems, it has no effect. @@ -1089,9 +1089,9 @@ postgresql://%2Fvar%2Flib%2Fpostgresql/dbname that is not acknowledged by the server should be retransmitted. A value of zero uses the system default. This parameter is ignored for connections made via a Unix-domain socket, or if keepalives are disabled. - It is only supported on systems where the TCP_KEEPINTVL - socket option is available, and on Windows; on other systems, it has no - effect. + It is only supported on systems where TCP_KEEPINTVL or + an equivalent socket option is available, and on Windows; on other + systems, it has no effect. @@ -1104,8 +1104,9 @@ postgresql://%2Fvar%2Flib%2Fpostgresql/dbname client's connection to the server is considered dead. A value of zero uses the system default. This parameter is ignored for connections made via a Unix-domain socket, or if keepalives are disabled. - It is only supported on systems where the TCP_KEEPCNT - socket option is available; on other systems, it has no effect. + It is only supported on systems where TCP_KEEPCNT or + an equivalent socket option is available; on other systems, it has no + effect. diff --git a/src/backend/libpq/pqcomm.c b/src/backend/libpq/pqcomm.c index 65b0206038..6a870b8973 100644 --- a/src/backend/libpq/pqcomm.c +++ b/src/backend/libpq/pqcomm.c @@ -96,6 +96,25 @@ #include "utils/guc.h" #include "utils/memutils.h" +/* + * Cope with the various platform-specific ways to spell TCP keepalive socket + * options. This doesn't cover Windows, which as usual does its own thing. + */ +#if defined(TCP_KEEPIDLE) +/* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ +#define PG_TCP_KEEPALIVE_IDLE TCP_KEEPIDLE +#define PG_TCP_KEEPALIVE_IDLE_STR "TCP_KEEPIDLE" +#elif defined(TCP_KEEPALIVE_THRESHOLD) +/* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris >= 11 */ +#define PG_TCP_KEEPALIVE_IDLE TCP_KEEPALIVE_THRESHOLD +#define PG_TCP_KEEPALIVE_IDLE_STR "TCP_KEEPALIVE_THRESHOLD" +#elif defined(TCP_KEEPALIVE) && defined(__darwin__) +/* TCP_KEEPALIVE is the name of this option on macOS */ +/* Caution: Solaris has this symbol but it means something different */ +#define PG_TCP_KEEPALIVE_IDLE TCP_KEEPALIVE +#define PG_TCP_KEEPALIVE_IDLE_STR "TCP_KEEPALIVE" +#endif + /* * Configuration options */ @@ -719,7 +738,7 @@ StreamConnection(pgsocket server_fd, Port *port) if (setsockopt(port->sock, IPPROTO_TCP, TCP_NODELAY, (char *) &on, sizeof(on)) < 0) { - elog(LOG, "setsockopt(TCP_NODELAY) failed: %m"); + elog(LOG, "setsockopt(%s) failed: %m", "TCP_NODELAY"); return STATUS_ERROR; } #endif @@ -727,7 +746,7 @@ StreamConnection(pgsocket server_fd, Port *port) if (setsockopt(port->sock, SOL_SOCKET, SO_KEEPALIVE, (char *) &on, sizeof(on)) < 0) { - elog(LOG, "setsockopt(SO_KEEPALIVE) failed: %m"); + elog(LOG, "setsockopt(%s) failed: %m", "SO_KEEPALIVE"); return STATUS_ERROR; } @@ -758,7 +777,7 @@ StreamConnection(pgsocket server_fd, Port *port) if (getsockopt(port->sock, SOL_SOCKET, SO_SNDBUF, (char *) &oldopt, &optlen) < 0) { - elog(LOG, "getsockopt(SO_SNDBUF) failed: %m"); + elog(LOG, "getsockopt(%s) failed: %m", "SO_SNDBUF"); return STATUS_ERROR; } newopt = PQ_SEND_BUFFER_SIZE * 4; @@ -767,7 +786,7 @@ StreamConnection(pgsocket server_fd, Port *port) if (setsockopt(port->sock, SOL_SOCKET, SO_SNDBUF, (char *) &newopt, sizeof(newopt)) < 0) { - elog(LOG, "setsockopt(SO_SNDBUF) failed: %m"); + elog(LOG, "setsockopt(%s) failed: %m", "SO_SNDBUF"); return STATUS_ERROR; } } @@ -1653,7 +1672,7 @@ pq_setkeepaliveswin32(Port *port, int idle, int interval) int pq_getkeepalivesidle(Port *port) { -#if defined(TCP_KEEPIDLE) || defined(TCP_KEEPALIVE_THRESHOLD) || defined(TCP_KEEPALIVE) || defined(WIN32) +#if defined(PG_TCP_KEEPALIVE_IDLE) || defined(SIO_KEEPALIVE_VALS) if (port == NULL || IS_AF_UNIX(port->laddr.addr.ss_family)) return 0; @@ -1665,34 +1684,13 @@ pq_getkeepalivesidle(Port *port) #ifndef WIN32 ACCEPT_TYPE_ARG3 size = sizeof(port->default_keepalives_idle); -#if defined(TCP_KEEPIDLE) - /* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ - if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPIDLE, - (char *) &port->default_keepalives_idle, - &size) < 0) - { - elog(LOG, "getsockopt(TCP_KEEPIDLE) failed: %m"); - port->default_keepalives_idle = -1; /* don't know */ - } -#elif defined(TCP_KEEPALIVE_THRESHOLD) - /* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris */ - if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, + if (getsockopt(port->sock, IPPROTO_TCP, PG_TCP_KEEPALIVE_IDLE, (char *) &port->default_keepalives_idle, &size) < 0) { - elog(LOG, "getsockopt(TCP_KEEPALIVE_THRESHOLD) failed: %m"); + elog(LOG, "getsockopt(%s) failed: %m", PG_TCP_KEEPALIVE_IDLE_STR); port->default_keepalives_idle = -1; /* don't know */ } -#else /* must have TCP_KEEPALIVE */ - /* TCP_KEEPALIVE is the name of this option on macOS */ - if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE, - (char *) &port->default_keepalives_idle, - &size) < 0) - { - elog(LOG, "getsockopt(TCP_KEEPALIVE) failed: %m"); - port->default_keepalives_idle = -1; /* don't know */ - } -#endif /* KEEPIDLE/KEEPALIVE_THRESHOLD/KEEPALIVE */ #else /* WIN32 */ /* We can't get the defaults on Windows, so return "don't know" */ port->default_keepalives_idle = -1; @@ -1712,7 +1710,7 @@ pq_setkeepalivesidle(int idle, Port *port) return STATUS_OK; /* check SIO_KEEPALIVE_VALS here, not just WIN32, as some toolchains lack it */ -#if defined(TCP_KEEPIDLE) || defined(TCP_KEEPALIVE_THRESHOLD) || defined(TCP_KEEPALIVE) || defined(SIO_KEEPALIVE_VALS) +#if defined(PG_TCP_KEEPALIVE_IDLE) || defined(SIO_KEEPALIVE_VALS) if (idle == port->keepalives_idle) return STATUS_OK; @@ -1731,43 +1729,25 @@ pq_setkeepalivesidle(int idle, Port *port) if (idle == 0) idle = port->default_keepalives_idle; -#if defined(TCP_KEEPIDLE) - /* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ - if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPIDLE, - (char *) &idle, sizeof(idle)) < 0) - { - elog(LOG, "setsockopt(TCP_KEEPIDLE) failed: %m"); - return STATUS_ERROR; - } -#elif defined(TCP_KEEPALIVE_THRESHOLD) - /* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris */ - if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, + if (setsockopt(port->sock, IPPROTO_TCP, PG_TCP_KEEPALIVE_IDLE, (char *) &idle, sizeof(idle)) < 0) { - elog(LOG, "setsockopt(TCP_KEEPALIVE_THRESHOLD) failed: %m"); + elog(LOG, "setsockopt(%s) failed: %m", PG_TCP_KEEPALIVE_IDLE_STR); return STATUS_ERROR; } -#else /* must have TCP_KEEPALIVE */ - /* TCP_KEEPALIVE is the name of this option on macOS */ - if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPALIVE, - (char *) &idle, sizeof(idle)) < 0) - { - elog(LOG, "setsockopt(TCP_KEEPALIVE) failed: %m"); - return STATUS_ERROR; - } -#endif port->keepalives_idle = idle; #else /* WIN32 */ return pq_setkeepaliveswin32(port, idle, port->keepalives_interval); #endif -#else /* no way to set it */ +#else if (idle != 0) { elog(LOG, "setting the keepalive idle time is not supported"); return STATUS_ERROR; } #endif + return STATUS_OK; } @@ -1790,7 +1770,7 @@ pq_getkeepalivesinterval(Port *port) (char *) &port->default_keepalives_interval, &size) < 0) { - elog(LOG, "getsockopt(TCP_KEEPINTVL) failed: %m"); + elog(LOG, "getsockopt(%s) failed: %m", "TCP_KEEPINTVL"); port->default_keepalives_interval = -1; /* don't know */ } #else @@ -1833,7 +1813,7 @@ pq_setkeepalivesinterval(int interval, Port *port) if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPINTVL, (char *) &interval, sizeof(interval)) < 0) { - elog(LOG, "setsockopt(TCP_KEEPINTVL) failed: %m"); + elog(LOG, "setsockopt(%s) failed: %m", "TCP_KEEPINTVL"); return STATUS_ERROR; } @@ -1844,7 +1824,7 @@ pq_setkeepalivesinterval(int interval, Port *port) #else if (interval != 0) { - elog(LOG, "setsockopt(TCP_KEEPINTVL) not supported"); + elog(LOG, "setsockopt(%s) not supported", "TCP_KEEPINTVL"); return STATUS_ERROR; } #endif @@ -1870,7 +1850,7 @@ pq_getkeepalivescount(Port *port) (char *) &port->default_keepalives_count, &size) < 0) { - elog(LOG, "getsockopt(TCP_KEEPCNT) failed: %m"); + elog(LOG, "getsockopt(%s) failed: %m", "TCP_KEEPCNT"); port->default_keepalives_count = -1; /* don't know */ } } @@ -1908,7 +1888,7 @@ pq_setkeepalivescount(int count, Port *port) if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPCNT, (char *) &count, sizeof(count)) < 0) { - elog(LOG, "setsockopt(TCP_KEEPCNT) failed: %m"); + elog(LOG, "setsockopt(%s) failed: %m", "TCP_KEEPCNT"); return STATUS_ERROR; } @@ -1916,7 +1896,7 @@ pq_setkeepalivescount(int count, Port *port) #else if (count != 0) { - elog(LOG, "setsockopt(TCP_KEEPCNT) not supported"); + elog(LOG, "setsockopt(%s) not supported", "TCP_KEEPCNT"); return STATUS_ERROR; } #endif diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c index 443b4fb3e2..e61ed7dc28 100644 --- a/src/interfaces/libpq/fe-connect.c +++ b/src/interfaces/libpq/fe-connect.c @@ -99,6 +99,25 @@ static int ldapServiceLookup(const char *purl, PQconninfoOption *options, /* This too */ #define ERRCODE_CANNOT_CONNECT_NOW "57P03" +/* + * Cope with the various platform-specific ways to spell TCP keepalive socket + * options. This doesn't cover Windows, which as usual does its own thing. + */ +#if defined(TCP_KEEPIDLE) +/* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ +#define PG_TCP_KEEPALIVE_IDLE TCP_KEEPIDLE +#define PG_TCP_KEEPALIVE_IDLE_STR "TCP_KEEPIDLE" +#elif defined(TCP_KEEPALIVE_THRESHOLD) +/* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris >= 11 */ +#define PG_TCP_KEEPALIVE_IDLE TCP_KEEPALIVE_THRESHOLD +#define PG_TCP_KEEPALIVE_IDLE_STR "TCP_KEEPALIVE_THRESHOLD" +#elif defined(TCP_KEEPALIVE) && defined(__darwin__) +/* TCP_KEEPALIVE is the name of this option on macOS */ +/* Caution: Solaris has this symbol but it means something different */ +#define PG_TCP_KEEPALIVE_IDLE TCP_KEEPALIVE +#define PG_TCP_KEEPALIVE_IDLE_STR "TCP_KEEPALIVE" +#endif + /* * fall back options if they are not specified by arguments or defined * by environment variables @@ -1280,39 +1299,15 @@ setKeepalivesIdle(PGconn *conn) if (idle < 0) idle = 0; -#if defined(TCP_KEEPIDLE) - /* TCP_KEEPIDLE is the name of this option on Linux and *BSD */ - if (setsockopt(conn->sock, IPPROTO_TCP, TCP_KEEPIDLE, - (char *) &idle, sizeof(idle)) < 0) - { - char sebuf[256]; - - appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("setsockopt(TCP_KEEPIDLE) failed: %s\n"), - SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); - return 0; - } -#elif defined(TCP_KEEPALIVE_THRESHOLD) - /* TCP_KEEPALIVE_THRESHOLD is the name of this option on Solaris */ - if (setsockopt(conn->sock, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, - (char *) &idle, sizeof(idle)) < 0) - { - char sebuf[256]; - - appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("setsockopt(TCP_KEEPALIVE_THRESHOLD) failed: %s\n"), - SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); - return 0; - } -#elif defined(TCP_KEEPALIVE) - /* TCP_KEEPALIVE is the name of this option on macOS */ - if (setsockopt(conn->sock, IPPROTO_TCP, TCP_KEEPALIVE, +#ifdef PG_TCP_KEEPALIVE_IDLE + if (setsockopt(conn->sock, IPPROTO_TCP, PG_TCP_KEEPALIVE_IDLE, (char *) &idle, sizeof(idle)) < 0) { char sebuf[256]; appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("setsockopt(TCP_KEEPALIVE) failed: %s\n"), + libpq_gettext("setsockopt(%s) failed: %s\n"), + PG_TCP_KEEPALIVE_IDLE_STR, SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); return 0; } @@ -1343,7 +1338,8 @@ setKeepalivesInterval(PGconn *conn) char sebuf[256]; appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("setsockopt(TCP_KEEPINTVL) failed: %s\n"), + libpq_gettext("setsockopt(%s) failed: %s\n"), + "TCP_KEEPINTVL", SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); return 0; } @@ -1375,7 +1371,8 @@ setKeepalivesCount(PGconn *conn) char sebuf[256]; appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("setsockopt(TCP_KEEPCNT) failed: %s\n"), + libpq_gettext("setsockopt(%s) failed: %s\n"), + "TCP_KEEPCNT", SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); return 0; } @@ -1841,7 +1838,8 @@ PQconnectPoll(PGconn *conn) (char *) &on, sizeof(on)) < 0) { appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("setsockopt(SO_KEEPALIVE) failed: %s\n"), + libpq_gettext("setsockopt(%s) failed: %s\n"), + "SO_KEEPALIVE", SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); err = 1; } From e9d4aa594f2caa8c28d55c41c9926420b1efdb79 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 30 Jun 2017 12:00:03 -0400 Subject: [PATCH 0124/1139] Fix walsender to exit promptly if client requests shutdown. It's possible for WalSndWaitForWal to be asked to wait for WAL that doesn't exist yet. That's fine, in fact it's the normal situation if we're caught up; but when the client requests shutdown we should not keep waiting. The previous coding could wait indefinitely if the source server was idle. In passing, improve the rather weak comments in this area, and slightly rearrange some related code for better readability. Back-patch to 9.4 where this code was introduced. Discussion: https://postgr.es/m/14154.1498781234@sss.pgh.pa.us --- src/backend/replication/walsender.c | 48 +++++++++++++++++++---------- 1 file changed, 31 insertions(+), 17 deletions(-) diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index e4ecbe37ee..9c320ff1ed 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -764,15 +764,14 @@ logical_read_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr, int req /* make sure we have enough WAL available */ flushptr = WalSndWaitForWal(targetPagePtr + reqLen); - /* more than one block available */ - if (targetPagePtr + XLOG_BLCKSZ <= flushptr) - count = XLOG_BLCKSZ; - /* not enough WAL synced, that can happen during shutdown */ - else if (targetPagePtr + reqLen > flushptr) + /* fail if not (implies we are going to shut down) */ + if (flushptr < targetPagePtr + reqLen) return -1; - /* part of the page available */ + + if (targetPagePtr + XLOG_BLCKSZ <= flushptr) + count = XLOG_BLCKSZ; /* more than one block available */ else - count = flushptr - targetPagePtr; + count = flushptr - targetPagePtr; /* part of the page available */ /* now actually read the data, we know it's there */ XLogRead(cur_page, targetPagePtr, XLOG_BLCKSZ); @@ -1158,7 +1157,11 @@ WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, } /* - * Wait till WAL < loc is flushed to disk so it can be safely read. + * Wait till WAL < loc is flushed to disk so it can be safely sent to client. + * + * Returns end LSN of flushed WAL. Normally this will be >= loc, but + * if we detect a shutdown request (either from postmaster or client) + * we will return early, so caller must always check. */ static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc) @@ -1225,9 +1228,7 @@ WalSndWaitForWal(XLogRecPtr loc) RecentFlushPtr = GetXLogReplayRecPtr(NULL); /* - * If postmaster asked us to stop, don't wait here anymore. This will - * cause the xlogreader to return without reading a full record, which - * is the fastest way to reach the mainloop which then can quit. + * If postmaster asked us to stop, don't wait anymore. * * It's important to do this check after the recomputation of * RecentFlushPtr, so we can send all remaining data before shutting @@ -1258,14 +1259,20 @@ WalSndWaitForWal(XLogRecPtr loc) WalSndCaughtUp = true; /* - * Try to flush pending output to the client. Also wait for the socket - * becoming writable, if there's still pending output after an attempt - * to flush. Otherwise we might just sit on output data while waiting - * for new WAL being generated. + * Try to flush any pending output to the client. */ if (pq_flush_if_writable() != 0) WalSndShutdown(); + /* + * If we have received CopyDone from the client, sent CopyDone + * ourselves, and the output buffer is empty, it's time to exit + * streaming, so fail the current WAL fetch request. + */ + if (streamingDoneReceiving && streamingDoneSending && + !pq_is_send_pending()) + break; + now = GetCurrentTimestamp(); /* die if timeout was reached */ @@ -1274,6 +1281,13 @@ WalSndWaitForWal(XLogRecPtr loc) /* Send keepalive if the time has come */ WalSndKeepaliveIfNecessary(now); + /* + * Sleep until something happens or we time out. Also wait for the + * socket becoming writable, if there's still pending output. + * Otherwise we might sit on sendable output data while waiting for + * new WAL to be generated. (But if we have nothing to send, we don't + * want to wake on socket-writable.) + */ sleeptime = WalSndComputeSleeptime(now); wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH | @@ -1282,7 +1296,6 @@ WalSndWaitForWal(XLogRecPtr loc) if (pq_is_send_pending()) wakeEvents |= WL_SOCKET_WRITEABLE; - /* Sleep until something happens or we time out */ WaitLatchOrSocket(MyLatch, wakeEvents, MyProcPort->sock, sleeptime); } @@ -1870,7 +1883,8 @@ WalSndLoop(WalSndSendDataCallback send_data) * ourselves, and the output buffer is empty, it's time to exit * streaming. */ - if (!pq_is_send_pending() && streamingDoneSending && streamingDoneReceiving) + if (streamingDoneReceiving && streamingDoneSending && + !pq_is_send_pending()) break; /* From f73382877e3ec2ff4b3fcedfd2566ccd90ef3e1c Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Mon, 3 Jul 2017 14:51:51 +0300 Subject: [PATCH 0125/1139] Treat clean shutdown of an SSL connection same as the non-SSL case. If the client closes an SSL connection, treat it the same as EOF on a non-SSL connection. In particular, don't write a message in the log about that. Michael Paquier. Discussion: https://www.postgresql.org/message-id/CAB7nPqSfyVV42Q2acFo%3DvrvF2gxoZAMJLAPq3S3KkjhZAYi7aw@mail.gmail.com --- src/backend/libpq/be-secure-openssl.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/backend/libpq/be-secure-openssl.c b/src/backend/libpq/be-secure-openssl.c index 3a39cb7dc6..2ff9d1cf85 100644 --- a/src/backend/libpq/be-secure-openssl.c +++ b/src/backend/libpq/be-secure-openssl.c @@ -582,11 +582,13 @@ be_tls_read(Port *port, void *ptr, size_t len, int *waitfor) ereport(COMMERROR, (errcode(ERRCODE_PROTOCOL_VIOLATION), errmsg("SSL error: %s", SSLerrmessage(ecode)))); - /* fall through */ - case SSL_ERROR_ZERO_RETURN: errno = ECONNRESET; n = -1; break; + case SSL_ERROR_ZERO_RETURN: + /* connection was cleanly shut down by peer */ + n = 0; + break; default: ereport(COMMERROR, (errcode(ERRCODE_PROTOCOL_VIOLATION), @@ -642,8 +644,14 @@ be_tls_write(Port *port, void *ptr, size_t len, int *waitfor) ereport(COMMERROR, (errcode(ERRCODE_PROTOCOL_VIOLATION), errmsg("SSL error: %s", SSLerrmessage(ecode)))); - /* fall through */ + errno = ECONNRESET; + n = -1; + break; case SSL_ERROR_ZERO_RETURN: + /* + * the SSL connnection was closed, leave it to the caller + * to ereport it + */ errno = ECONNRESET; n = -1; break; From 42f62e4c976e1cf90f5e5a6381c4ee656260f230 Mon Sep 17 00:00:00 2001 From: Teodor Sigaev Date: Thu, 6 Jul 2017 17:19:44 +0300 Subject: [PATCH 0126/1139] Fix potential data corruption during freeze Fix oversight in 3b97e6823b94 bug fix. Bitwise AND is used instead of OR and it cleans all bits in t_infomask heap tuple field. Backpatch to 9.3 --- src/backend/access/heap/heapam.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index b019bc1a0d..dc93b1e881 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -6653,7 +6653,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid, frz->t_infomask &= ~HEAP_XMAX_BITS; frz->xmax = newxmax; if (flags & FRM_MARK_COMMITTED) - frz->t_infomask &= HEAP_XMAX_COMMITTED; + frz->t_infomask |= HEAP_XMAX_COMMITTED; changed = true; totally_frozen = false; } From d61b39c7e2f945854551ef087c48c294a265d88d Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Fri, 7 Jul 2017 17:10:36 -0400 Subject: [PATCH 0127/1139] Fix typo Noticed while reviewing code. --- src/backend/commands/vacuumlazy.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c index 0506a9340c..7748b3986b 100644 --- a/src/backend/commands/vacuumlazy.c +++ b/src/backend/commands/vacuumlazy.c @@ -523,7 +523,7 @@ lazy_scan_heap(Relation onerel, int options, LVRelStats *vacrelstats, * safely set for relfrozenxid or relminmxid. * * Before entering the main loop, establish the invariant that - * next_unskippable_block is the next block number >= blkno that's not we + * next_unskippable_block is the next block number >= blkno that we * can't skip based on the visibility map, either all-visible for a * regular scan or all-frozen for an aggressive scan. We set it to * nblocks if there's no such block. We also set up the skipping_blocks From eb01287c9d799fd4867cbe850b8ad8b4d3b4f8eb Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 9 Jul 2017 12:51:15 -0400 Subject: [PATCH 0128/1139] Doc: fix backwards description of visibility map's all-frozen data. Thinko in commit a892234f8. Vik Fearing Discussion: https://postgr.es/m/b6aaa23d-e26f-6404-a30d-e89431492d5d@2ndquadrant.com --- doc/src/sgml/storage.sgml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/src/sgml/storage.sgml b/doc/src/sgml/storage.sgml index 1b812bd0a9..75a87a504a 100644 --- a/doc/src/sgml/storage.sgml +++ b/doc/src/sgml/storage.sgml @@ -624,7 +624,7 @@ can be used to examine the information stored in free space maps. Each heap relation has a Visibility Map (VM) to keep track of which pages contain only tuples that are known to be visible to all active transactions; it also keeps track of which pages contain -only unfrozen tuples. It's stored +only frozen tuples. It's stored alongside the main relation data in a separate relation fork, named after the filenode number of the relation, plus a _vm suffix. For example, if the filenode of a relation is 12345, the VM is stored in a file called From ef68c9f6eb62da53525967ea4a18c593819a2436 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 10 Jul 2017 00:08:19 -0400 Subject: [PATCH 0129/1139] Doc: clarify wording about tool requirements in sourcerepo.sgml. Original wording had confusingly vague antecedent for "they", so replace that with a more repetitive but clearer formulation. In passing, make the link to the installation requirements section more specific. Per gripe from Martin Mai, though this is not the fix he initially proposed. Discussion: https://postgr.es/m/CAN_NWRu-cWuNaiXUjV3m4H-riWURuPW=j21bSaLADs6rjjzXgQ@mail.gmail.com --- doc/src/sgml/sourcerepo.sgml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/src/sgml/sourcerepo.sgml b/doc/src/sgml/sourcerepo.sgml index f8f6bf2de1..dd9da5a7b0 100644 --- a/doc/src/sgml/sourcerepo.sgml +++ b/doc/src/sgml/sourcerepo.sgml @@ -20,9 +20,9 @@ Note that building PostgreSQL from the source repository requires reasonably up-to-date versions of bison, flex, and Perl. These tools are not needed - to build from a distribution tarball since the files they are used to build - are included in the tarball. Other tool requirements are the same as shown - in . + to build from a distribution tarball, because the files that these tools + are used to build are included in the tarball. Other tool requirements + are the same as shown in . From c0077f7383e3a9cd36d566fd8f6f4eb9fd55e0e6 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 10 Jul 2017 11:00:09 -0400 Subject: [PATCH 0130/1139] On Windows, retry process creation if we fail to reserve shared memory. We've heard occasional reports of backend launch failing because pgwin32_ReserveSharedMemoryRegion() fails, indicating that something has already used that address space in the child process. It's not very clear what, given that we disable ASLR in Windows builds, but suspicion falls on antivirus products. It'd be better if we didn't have to disable ASLR, anyway. So let's try to ameliorate the problem by retrying the process launch after such a failure, up to 100 times. Patch by me, based on previous work by Amit Kapila and others. This is a longstanding issue, so back-patch to all supported branches. Discussion: https://postgr.es/m/CAA4eK1+R6hSx6t_yvwtx+NRzneVp+MRqXAdGJZChcau8Uij-8g@mail.gmail.com --- src/backend/postmaster/postmaster.c | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index c0cdc23227..9b31ddc970 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -4447,6 +4447,7 @@ internal_forkexec(int argc, char *argv[], Port *port) static pid_t internal_forkexec(int argc, char *argv[], Port *port) { + int retry_count = 0; STARTUPINFO si; PROCESS_INFORMATION pi; int i; @@ -4464,6 +4465,9 @@ internal_forkexec(int argc, char *argv[], Port *port) Assert(strncmp(argv[1], "--fork", 6) == 0); Assert(argv[2] == NULL); + /* Resume here if we need to retry */ +retry: + /* Set up shared memory for parameter passing */ ZeroMemory(&sa, sizeof(sa)); sa.nLength = sizeof(sa); @@ -4555,22 +4559,26 @@ internal_forkexec(int argc, char *argv[], Port *port) /* * Reserve the memory region used by our main shared memory segment before - * we resume the child process. + * we resume the child process. Normally this should succeed, but if ASLR + * is active then it might sometimes fail due to the stack or heap having + * gotten mapped into that range. In that case, just terminate the + * process and retry. */ if (!pgwin32_ReserveSharedMemoryRegion(pi.hProcess)) { - /* - * Failed to reserve the memory, so terminate the newly created - * process and give up. - */ + /* pgwin32_ReserveSharedMemoryRegion already made a log entry */ if (!TerminateProcess(pi.hProcess, 255)) ereport(LOG, (errmsg_internal("could not terminate process that failed to reserve memory: error code %lu", GetLastError()))); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); - return -1; /* logging done made by - * pgwin32_ReserveSharedMemoryRegion() */ + if (++retry_count < 100) + goto retry; + ereport(LOG, + (errmsg("giving up after too many tries to reserve shared memory"), + errhint("This might be caused by ASLR or antivirus software."))); + return -1; } /* From 123368061188ebc8dc99346be2167e3f7a7b618c Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 11 Jul 2017 16:48:59 -0400 Subject: [PATCH 0131/1139] Fix multiple assignments to a column of a domain type. We allow INSERT and UPDATE commands to assign to the same column more than once, as long as the assignments are to subfields or elements rather than the whole column. However, this failed when the target column was a domain over array rather than plain array. Fix by teaching process_matched_tle() to look through CoerceToDomain nodes, and add relevant test cases. Also add a group of test cases exercising domains over array of composite. It's doubtless accidental that CREATE DOMAIN allows this case while not allowing straight domain over composite; but it does, so we'd better make sure we don't break it. (I could not find any documentation mentioning either side of that, so no doc changes.) It's been like this for a long time, so back-patch to all supported branches. Discussion: https://postgr.es/m/4206.1499798337@sss.pgh.pa.us --- src/backend/rewrite/rewriteHandler.c | 31 ++++++++ src/test/regress/expected/domain.out | 110 ++++++++++++++++++++++++++- src/test/regress/sql/domain.sql | 48 ++++++++++++ 3 files changed, 185 insertions(+), 4 deletions(-) diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c index a22a11e2c1..6e799f721d 100644 --- a/src/backend/rewrite/rewriteHandler.c +++ b/src/backend/rewrite/rewriteHandler.c @@ -878,6 +878,7 @@ process_matched_tle(TargetEntry *src_tle, const char *attrName) { TargetEntry *result; + CoerceToDomain *coerce_expr = NULL; Node *src_expr; Node *prior_expr; Node *src_input; @@ -914,10 +915,30 @@ process_matched_tle(TargetEntry *src_tle, * For FieldStore, instead of nesting we can generate a single * FieldStore with multiple target fields. We must nest when * ArrayRefs are involved though. + * + * As a further complication, the destination column might be a domain, + * resulting in each assignment containing a CoerceToDomain node over a + * FieldStore or ArrayRef. These should have matching target domains, + * so we strip them and reconstitute a single CoerceToDomain over the + * combined FieldStore/ArrayRef nodes. (Notice that this has the result + * that the domain's checks are applied only after we do all the field or + * element updates, not after each one. This is arguably desirable.) *---------- */ src_expr = (Node *) src_tle->expr; prior_expr = (Node *) prior_tle->expr; + + if (src_expr && IsA(src_expr, CoerceToDomain) && + prior_expr && IsA(prior_expr, CoerceToDomain) && + ((CoerceToDomain *) src_expr)->resulttype == + ((CoerceToDomain *) prior_expr)->resulttype) + { + /* we assume without checking that resulttypmod/resultcollid match */ + coerce_expr = (CoerceToDomain *) src_expr; + src_expr = (Node *) ((CoerceToDomain *) src_expr)->arg; + prior_expr = (Node *) ((CoerceToDomain *) prior_expr)->arg; + } + src_input = get_assignment_input(src_expr); prior_input = get_assignment_input(prior_expr); if (src_input == NULL || @@ -986,6 +1007,16 @@ process_matched_tle(TargetEntry *src_tle, newexpr = NULL; } + if (coerce_expr) + { + /* put back the CoerceToDomain */ + CoerceToDomain *newcoerce = makeNode(CoerceToDomain); + + memcpy(newcoerce, coerce_expr, sizeof(CoerceToDomain)); + newcoerce->arg = (Expr *) newexpr; + newexpr = (Node *) newcoerce; + } + result = flatCopyTargetEntry(src_tle); result->expr = (Expr *) newexpr; return result; diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out index 41b70e287b..9fb750d2d3 100644 --- a/src/test/regress/expected/domain.out +++ b/src/test/regress/expected/domain.out @@ -107,6 +107,7 @@ INSERT INTO domarrtest values ('{2,2}', '{{"a"},{"c"}}'); INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}'); INSERT INTO domarrtest values (NULL, '{{"toolong","b","c"},{"d","e","f"}}'); ERROR: value too long for type character varying(4) +INSERT INTO domarrtest (testint4arr[1], testint4arr[3]) values (11,22); select * from domarrtest; testint4arr | testchar4arr ---------------+--------------------- @@ -115,7 +116,8 @@ select * from domarrtest; {2,2} | {{a,b},{c,d},{e,f}} {2,2} | {{a},{c}} | {{a,b,c},{d,e,f}} -(5 rows) + {11,NULL,22} | +(6 rows) select testint4arr[1], testchar4arr[2:2] from domarrtest; testint4arr | testchar4arr @@ -125,7 +127,8 @@ select testint4arr[1], testchar4arr[2:2] from domarrtest; 2 | {{c,d}} 2 | {{c}} | {{d,e,f}} -(5 rows) + 11 | +(6 rows) select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest; array_dims | array_dims @@ -135,7 +138,8 @@ select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest; [1:2] | [1:3][1:2] [1:2] | [1:2][1:1] | [1:2][1:3] -(5 rows) + [1:3] | +(6 rows) COPY domarrtest FROM stdin; COPY domarrtest FROM stdin; -- fail @@ -149,9 +153,21 @@ select * from domarrtest; {2,2} | {{a,b},{c,d},{e,f}} {2,2} | {{a},{c}} | {{a,b,c},{d,e,f}} + {11,NULL,22} | {3,4} | {q,w,e} | -(7 rows) +(8 rows) + +update domarrtest set + testint4arr[1] = testint4arr[1] + 1, + testint4arr[3] = testint4arr[3] - 1 +where testchar4arr is null; +select * from domarrtest where testchar4arr is null; + testint4arr | testchar4arr +------------------+-------------- + {12,NULL,21} | + {NULL,NULL,NULL} | +(2 rows) drop table domarrtest; drop domain domainint4arr restrict; @@ -182,6 +198,92 @@ select pg_typeof('{1,2,3}'::dia || 42); -- should be int[] not dia (1 row) drop domain dia; +-- Test domains over arrays of composite +create type comptype as (r float8, i float8); +create domain dcomptypea as comptype[]; +create table dcomptable (d1 dcomptypea unique); +insert into dcomptable values (array[row(1,2)]::dcomptypea); +insert into dcomptable values (array[row(3,4), row(5,6)]::comptype[]); +insert into dcomptable values (array[row(7,8)::comptype, row(9,10)::comptype]); +insert into dcomptable values (array[row(1,2)]::dcomptypea); -- fail on uniqueness +ERROR: duplicate key value violates unique constraint "dcomptable_d1_key" +DETAIL: Key (d1)=({"(1,2)"}) already exists. +insert into dcomptable (d1[1]) values(row(9,10)); +insert into dcomptable (d1[1].r) values(11); +select * from dcomptable; + d1 +-------------------- + {"(1,2)"} + {"(3,4)","(5,6)"} + {"(7,8)","(9,10)"} + {"(9,10)"} + {"(11,)"} +(5 rows) + +select d1[2], d1[1].r, d1[1].i from dcomptable; + d1 | r | i +--------+----+---- + | 1 | 2 + (5,6) | 3 | 4 + (9,10) | 7 | 8 + | 9 | 10 + | 11 | +(5 rows) + +update dcomptable set d1[2] = row(d1[2].i, d1[2].r); +select * from dcomptable; + d1 +-------------------- + {"(1,2)","(,)"} + {"(3,4)","(6,5)"} + {"(7,8)","(10,9)"} + {"(9,10)","(,)"} + {"(11,)","(,)"} +(5 rows) + +update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0; +select * from dcomptable; + d1 +-------------------- + {"(11,)","(,)"} + {"(2,2)","(,)"} + {"(4,4)","(6,5)"} + {"(8,8)","(10,9)"} + {"(10,10)","(,)"} +(5 rows) + +alter domain dcomptypea add constraint c1 check (value[1].r <= value[1].i); +alter domain dcomptypea add constraint c2 check (value[1].r > value[1].i); -- fail +ERROR: column "d1" of table "dcomptable" contains values that violate the new constraint +select array[row(2,1)]::dcomptypea; -- fail +ERROR: value for domain dcomptypea violates check constraint "c1" +insert into dcomptable values (array[row(1,2)]::comptype[]); +insert into dcomptable values (array[row(2,1)]::comptype[]); -- fail +ERROR: value for domain dcomptypea violates check constraint "c1" +insert into dcomptable (d1[1].r) values(99); +insert into dcomptable (d1[1].r, d1[1].i) values(99, 100); +insert into dcomptable (d1[1].r, d1[1].i) values(100, 99); -- fail +ERROR: value for domain dcomptypea violates check constraint "c1" +update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0; -- fail +ERROR: value for domain dcomptypea violates check constraint "c1" +update dcomptable set d1[1].r = d1[1].r - 1 where d1[1].i > 0; +select * from dcomptable; + d1 +-------------------- + {"(11,)","(,)"} + {"(99,)"} + {"(1,2)","(,)"} + {"(3,4)","(6,5)"} + {"(7,8)","(10,9)"} + {"(9,10)","(,)"} + {"(0,2)"} + {"(98,100)"} +(8 rows) + +drop table dcomptable; +drop type comptype cascade; +NOTICE: drop cascades to type dcomptypea +-- Test not-null restrictions create domain dnotnull varchar(15) NOT NULL; create domain dnull varchar(15); create domain dcheck varchar(15) NOT NULL CHECK (VALUE = 'a' OR VALUE = 'c' OR VALUE = 'd'); diff --git a/src/test/regress/sql/domain.sql b/src/test/regress/sql/domain.sql index 407d3efc35..1fd7b11fd4 100644 --- a/src/test/regress/sql/domain.sql +++ b/src/test/regress/sql/domain.sql @@ -85,6 +85,7 @@ INSERT INTO domarrtest values ('{2,2}', '{{"a","b"},{"c","d"},{"e","f"}}'); INSERT INTO domarrtest values ('{2,2}', '{{"a"},{"c"}}'); INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}'); INSERT INTO domarrtest values (NULL, '{{"toolong","b","c"},{"d","e","f"}}'); +INSERT INTO domarrtest (testint4arr[1], testint4arr[3]) values (11,22); select * from domarrtest; select testint4arr[1], testchar4arr[2:2] from domarrtest; select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest; @@ -100,6 +101,13 @@ COPY domarrtest FROM stdin; -- fail select * from domarrtest; +update domarrtest set + testint4arr[1] = testint4arr[1] + 1, + testint4arr[3] = testint4arr[3] - 1 +where testchar4arr is null; + +select * from domarrtest where testchar4arr is null; + drop table domarrtest; drop domain domainint4arr restrict; drop domain domainchar4arr restrict; @@ -111,6 +119,46 @@ select pg_typeof('{1,2,3}'::dia); select pg_typeof('{1,2,3}'::dia || 42); -- should be int[] not dia drop domain dia; + +-- Test domains over arrays of composite + +create type comptype as (r float8, i float8); +create domain dcomptypea as comptype[]; +create table dcomptable (d1 dcomptypea unique); + +insert into dcomptable values (array[row(1,2)]::dcomptypea); +insert into dcomptable values (array[row(3,4), row(5,6)]::comptype[]); +insert into dcomptable values (array[row(7,8)::comptype, row(9,10)::comptype]); +insert into dcomptable values (array[row(1,2)]::dcomptypea); -- fail on uniqueness +insert into dcomptable (d1[1]) values(row(9,10)); +insert into dcomptable (d1[1].r) values(11); + +select * from dcomptable; +select d1[2], d1[1].r, d1[1].i from dcomptable; +update dcomptable set d1[2] = row(d1[2].i, d1[2].r); +select * from dcomptable; +update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0; +select * from dcomptable; + +alter domain dcomptypea add constraint c1 check (value[1].r <= value[1].i); +alter domain dcomptypea add constraint c2 check (value[1].r > value[1].i); -- fail + +select array[row(2,1)]::dcomptypea; -- fail +insert into dcomptable values (array[row(1,2)]::comptype[]); +insert into dcomptable values (array[row(2,1)]::comptype[]); -- fail +insert into dcomptable (d1[1].r) values(99); +insert into dcomptable (d1[1].r, d1[1].i) values(99, 100); +insert into dcomptable (d1[1].r, d1[1].i) values(100, 99); -- fail +update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0; -- fail +update dcomptable set d1[1].r = d1[1].r - 1 where d1[1].i > 0; +select * from dcomptable; + +drop table dcomptable; +drop type comptype cascade; + + +-- Test not-null restrictions + create domain dnotnull varchar(15) NOT NULL; create domain dnull varchar(15); create domain dcheck varchar(15) NOT NULL CHECK (VALUE = 'a' OR VALUE = 'c' OR VALUE = 'd'); From f1edf84580b1df647ae8b9b37c63f2a5612f8610 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Wed, 12 Jul 2017 12:30:50 +0300 Subject: [PATCH 0132/1139] Remove unnecessary braces, to match the surrounding style. Mostly in the new subscription-related commands. Backport the few that were also present in older versions. Thomas Munro Discussion: https://www.postgresql.org/message-id/CAEepm=3CyW1QmXcXJXmqiJXtXzFDc8SvSfnxkEGD3Bkv2SrkeQ@mail.gmail.com --- src/bin/psql/tab-complete.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c index 4fa21050a5..b5d49ea40d 100644 --- a/src/bin/psql/tab-complete.c +++ b/src/bin/psql/tab-complete.c @@ -3083,13 +3083,9 @@ psql_completion(const char *text, int start, int end) COMPLETE_WITH_LIST_CS2("single", "double"); } else if (TailMatchesCS1("\\unset")) - { matches = complete_from_variables(text, "", "", true); - } else if (TailMatchesCS1("\\set")) - { matches = complete_from_variables(text, "", "", false); - } else if (TailMatchesCS2("\\set", MatchAny)) { if (TailMatchesCS1("AUTOCOMMIT|ON_ERROR_STOP|QUIET|" From 941188a5ff49c4e042ddd4234c35cf0e1bfd7f19 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Wed, 12 Jul 2017 15:30:52 +0300 Subject: [PATCH 0133/1139] Fix ordering of operations in SyncRepWakeQueue to avoid assertion failure. Commit 14e8803f1 removed the locking in SyncRepWaitForLSN, but that introduced a race condition, where SyncRepWaitForLSN might see syncRepState already set to SYNC_REP_WAIT_COMPLETE, but the process was not yet removed from the queue. That tripped the assertion, that the process should no longer be in the uqeue. Reorder the operations in SyncRepWakeQueue to remove the process from the queue first, and update syncRepState only after that, and add a memory barrier in between to make sure the operations are made visible to other processes in that order. Fixes bug #14721 reported by Const Zhang. Analysis and fix by Thomas Munro. Backpatch down to 9.5, where the locking was removed. Discussion: https://www.postgresql.org/message-id/20170629023623.1480.26508%40wrigleys.postgresql.org --- src/backend/replication/syncrep.c | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/src/backend/replication/syncrep.c b/src/backend/replication/syncrep.c index 3dfff04405..04663748ed 100644 --- a/src/backend/replication/syncrep.c +++ b/src/backend/replication/syncrep.c @@ -265,8 +265,11 @@ SyncRepWaitForLSN(XLogRecPtr lsn, bool commit) * WalSender has checked our LSN and has removed us from queue. Clean up * state and leave. It's OK to reset these shared memory fields without * holding SyncRepLock, because any walsenders will ignore us anyway when - * we're not on the queue. + * we're not on the queue. We need a read barrier to make sure we see + * the changes to the queue link (this might be unnecessary without + * assertions, but better safe than sorry). */ + pg_read_barrier(); Assert(SHMQueueIsDetached(&(MyProc->syncRepLinks))); MyProc->syncRepState = SYNC_REP_NOT_WAITING; MyProc->waitLSN = 0; @@ -791,15 +794,22 @@ SyncRepWakeQueue(bool all, int mode) offsetof(PGPROC, syncRepLinks)); /* - * Set state to complete; see SyncRepWaitForLSN() for discussion of - * the various states. + * Remove thisproc from queue. */ - thisproc->syncRepState = SYNC_REP_WAIT_COMPLETE; + SHMQueueDelete(&(thisproc->syncRepLinks)); /* - * Remove thisproc from queue. + * SyncRepWaitForLSN() reads syncRepState without holding the lock, so + * make sure that it sees the queue link being removed before the + * syncRepState change. */ - SHMQueueDelete(&(thisproc->syncRepLinks)); + pg_write_barrier(); + + /* + * Set state to complete; see SyncRepWaitForLSN() for discussion of + * the various states. + */ + thisproc->syncRepState = SYNC_REP_WAIT_COMPLETE; /* * Wake only when we have set state and removed from queue. From 0a2d07cf1ed8bd1d16991fdda5c955903d30d8c8 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Wed, 12 Jul 2017 17:07:35 +0300 Subject: [PATCH 0134/1139] Fix variable and type name in comment. Kyotaro Horiguchi Discussion: https://www.postgresql.org/message-id/20170711.163441.241981736.horiguchi.kyotaro@lab.ntt.co.jp --- src/backend/storage/ipc/standby.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c index 174e42a16b..8e42e5745f 100644 --- a/src/backend/storage/ipc/standby.c +++ b/src/backend/storage/ipc/standby.c @@ -586,14 +586,14 @@ StandbyLockTimeoutHandler(void) * one transaction on one relation. * * We keep a single dynamically expandible list of locks in local memory, - * RelationLockList, so we can keep track of the various entries made by + * RecoveryLockList, so we can keep track of the various entries made by * the Startup process's virtual xid in the shared lock table. * * We record the lock against the top-level xid, rather than individual * subtransaction xids. This means AccessExclusiveLocks held by aborted * subtransactions are not released as early as possible on standbys. * - * List elements use type xl_rel_lock, since the WAL record type exactly + * List elements use type xl_standby_lock, since the WAL record type exactly * matches the information that we need to keep track of. * * We use session locks rather than normal locks so we don't need From 09c5988981668257705fb7a4f32f252876878f2d Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 12 Jul 2017 13:24:16 -0400 Subject: [PATCH 0135/1139] Avoid integer overflow while sifting-up a heap in tuplesort.c. If the number of tuples in the heap exceeds approximately INT_MAX/2, this loop's calculation "2*i+1" could overflow, resulting in a crash. Fix it by using unsigned int rather than int for the relevant local variables; that shouldn't cost anything extra on any popular hardware. Per bug #14722 from Sergey Koposov. Original patch by Sergey Koposov, modified by me per a suggestion from Heikki Linnakangas to use unsigned int not int64. Back-patch to 9.4, where tuplesort.c grew the ability to sort as many as INT_MAX tuples in-memory (commit 263865a48). Discussion: https://postgr.es/m/20170629161637.1478.93109@wrigleys.postgresql.org --- src/backend/utils/sort/tuplesort.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c index 64ef6e5032..4dd5407f74 100644 --- a/src/backend/utils/sort/tuplesort.c +++ b/src/backend/utils/sort/tuplesort.c @@ -3800,7 +3800,7 @@ tuplesort_heap_siftup(Tuplesortstate *state, bool checkIndex) { SortTuple *memtuples = state->memtuples; SortTuple *tuple; - int i, + unsigned int i, n; Assert(!checkIndex || state->currentRun == RUN_FIRST); @@ -3809,12 +3809,17 @@ tuplesort_heap_siftup(Tuplesortstate *state, bool checkIndex) CHECK_FOR_INTERRUPTS(); + /* + * state->memtupcount is "int", but we use "unsigned int" for i, j, n. + * This prevents overflow in the "2 * i + 1" calculation, since at the top + * of the loop we must have i < n <= INT_MAX <= UINT_MAX/2. + */ n = state->memtupcount; tuple = &memtuples[n]; /* tuple that must be reinserted */ i = 0; /* i is where the "hole" is */ for (;;) { - int j = 2 * i + 1; + unsigned int j = 2 * i + 1; if (j >= n) break; From 832d3dce5a3a5ca35f6861cb573bff7a6a8835dc Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Wed, 12 Jul 2017 14:39:44 -0400 Subject: [PATCH 0136/1139] commit_ts test: Set node name in test Otherwise, the script output has a lot of pointless warnings. This was forgotten in 9def031bd2821f35b5f506260d922482648a8bb0 --- src/test/modules/commit_ts/t/001_base.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/modules/commit_ts/t/001_base.pl b/src/test/modules/commit_ts/t/001_base.pl index 427092cfc5..9290a85d89 100644 --- a/src/test/modules/commit_ts/t/001_base.pl +++ b/src/test/modules/commit_ts/t/001_base.pl @@ -7,7 +7,7 @@ use Test::More tests => 2; use PostgresNode; -my $node = get_new_node(); +my $node = get_new_node('foxtrot'); $node->init; $node->append_conf('postgresql.conf', 'track_commit_timestamp = on'); $node->start; From bbeec3c749bcbd9b75fc1f036979fed516f9a2c8 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Wed, 12 Jul 2017 22:03:38 +0300 Subject: [PATCH 0137/1139] Reduce memory usage of tsvector type analyze function. compute_tsvector_stats() detoasted and kept in memory every tsvector value in the sample, but that can be a lot of memory. The original bug report described a case using over 10 gigabytes, with statistics target of 10000 (the maximum). To fix, allocate a separate copy of just the lexemes that we keep around, and free the detoasted tsvector values as we go. This adds some palloc/pfree overhead, when you have a lot of distinct lexemes in the sample, but it's better than running out of memory. Fixes bug #14654 reported by James C. Reviewed by Tom Lane. Backport to all supported versions. Discussion: https://www.postgresql.org/message-id/20170514200602.1451.46797@wrigleys.postgresql.org --- src/backend/tsearch/ts_typanalyze.c | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/src/backend/tsearch/ts_typanalyze.c b/src/backend/tsearch/ts_typanalyze.c index 817453ce01..fd89ea0eac 100644 --- a/src/backend/tsearch/ts_typanalyze.c +++ b/src/backend/tsearch/ts_typanalyze.c @@ -232,9 +232,7 @@ compute_tsvector_stats(VacAttrStats *stats, /* * We loop through the lexemes in the tsvector and add them to our - * tracking hashtable. Note: the hashtable entries will point into - * the (detoasted) tsvector value, therefore we cannot free that - * storage until we're done. + * tracking hashtable. */ lexemesptr = STRPTR(vector); curentryptr = ARRPTR(vector); @@ -242,7 +240,12 @@ compute_tsvector_stats(VacAttrStats *stats, { bool found; - /* Construct a hash key */ + /* + * Construct a hash key. The key points into the (detoasted) + * tsvector value at this point, but if a new entry is created, we + * make a copy of it. This way we can free the tsvector value + * once we've processed all its lexemes. + */ hash_key.lexeme = lexemesptr + curentryptr->pos; hash_key.length = curentryptr->len; @@ -261,6 +264,9 @@ compute_tsvector_stats(VacAttrStats *stats, /* Initialize new tracking list element */ item->frequency = 1; item->delta = b_current - 1; + + item->key.lexeme = palloc(hash_key.length); + memcpy(item->key.lexeme, hash_key.lexeme, hash_key.length); } /* lexeme_no is the number of elements processed (ie N) */ @@ -276,6 +282,10 @@ compute_tsvector_stats(VacAttrStats *stats, /* Advance to the next WordEntry in the tsvector */ curentryptr++; } + + /* If the vector was toasted, free the detoasted copy. */ + if (TSVectorGetDatum(vector) != value) + pfree(vector); } /* We can only compute real stats if we found some non-null values. */ @@ -447,9 +457,12 @@ prune_lexemes_hashtable(HTAB *lexemes_tab, int b_current) { if (item->frequency + item->delta <= b_current) { + char *lexeme = item->key.lexeme; + if (hash_search(lexemes_tab, (const void *) &item->key, HASH_REMOVE, NULL) == NULL) elog(ERROR, "hash table corrupted"); + pfree(lexeme); } } } From ff2d5372235dae339cbfa04aa55a8458cd6bfab8 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 12 Jul 2017 18:00:04 -0400 Subject: [PATCH 0138/1139] Fix ruleutils.c for domain-over-array cases, too. Further investigation shows that ruleutils isn't quite up to speed either for cases where we have a domain-over-array: it needs to be prepared to look past a CoerceToDomain at the top level of field and element assignments, else it decompiles them incorrectly. Potentially this would result in failure to dump/reload a rule, if it looked like the one in the new test case. (I also added a test for EXPLAIN; that output isn't broken, but clearly we need more test coverage here.) Like commit b1cb32fb6, this bug is reachable in cases we already support, so back-patch all the way. --- src/backend/utils/adt/ruleutils.c | 41 +++++++++++++++++++++++++--- src/test/regress/expected/domain.out | 41 +++++++++++++++++++++++----- src/test/regress/sql/domain.sql | 11 +++++++- 3 files changed, 81 insertions(+), 12 deletions(-) diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index bc85a34739..6a58b7e1ff 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -5832,8 +5832,11 @@ get_update_query_targetlist_def(Query *query, List *targetList, /* * We must dig down into the expr to see if it's a PARAM_MULTIEXPR * Param. That could be buried under FieldStores and ArrayRefs - * (cf processIndirection()), and underneath those there could be - * an implicit type coercion. + * and CoerceToDomains (cf processIndirection()), and underneath + * those there could be an implicit type coercion. Because we + * would ignore implicit type coercions anyway, we don't need to + * be as careful as processIndirection() is about descending past + * implicit CoerceToDomains. */ expr = (Node *) tle->expr; while (expr) @@ -5852,6 +5855,14 @@ get_update_query_targetlist_def(Query *query, List *targetList, break; expr = (Node *) aref->refassgnexpr; } + else if (IsA(expr, CoerceToDomain)) + { + CoerceToDomain *cdomain = (CoerceToDomain *) expr; + + if (cdomain->coercionformat != COERCE_IMPLICIT_CAST) + break; + expr = (Node *) cdomain->arg; + } else break; } @@ -9553,13 +9564,17 @@ get_opclass_name(Oid opclass, Oid actual_datatype, * * We strip any top-level FieldStore or assignment ArrayRef nodes that * appear in the input, printing them as decoration for the base column - * name (which we assume the caller just printed). Return the subexpression - * that's to be assigned. + * name (which we assume the caller just printed). We might also need to + * strip CoerceToDomain nodes, but only ones that appear above assignment + * nodes. + * + * Returns the subexpression that's to be assigned. */ static Node * processIndirection(Node *node, deparse_context *context) { StringInfo buf = context->buf; + CoerceToDomain *cdomain = NULL; for (;;) { @@ -9607,10 +9622,28 @@ processIndirection(Node *node, deparse_context *context) */ node = (Node *) aref->refassgnexpr; } + else if (IsA(node, CoerceToDomain)) + { + cdomain = (CoerceToDomain *) node; + /* If it's an explicit domain coercion, we're done */ + if (cdomain->coercionformat != COERCE_IMPLICIT_CAST) + break; + /* Tentatively descend past the CoerceToDomain */ + node = (Node *) cdomain->arg; + } else break; } + /* + * If we descended past a CoerceToDomain whose argument turned out not to + * be a FieldStore or array assignment, back up to the CoerceToDomain. + * (This is not enough to be fully correct if there are nested implicit + * CoerceToDomains, but such cases shouldn't ever occur.) + */ + if (cdomain && node == (Node *) cdomain->arg) + node = (Node *) cdomain; + return node; } diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out index 9fb750d2d3..d8fe5e4c8a 100644 --- a/src/test/regress/expected/domain.out +++ b/src/test/regress/expected/domain.out @@ -266,20 +266,47 @@ insert into dcomptable (d1[1].r, d1[1].i) values(100, 99); -- fail ERROR: value for domain dcomptypea violates check constraint "c1" update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0; -- fail ERROR: value for domain dcomptypea violates check constraint "c1" -update dcomptable set d1[1].r = d1[1].r - 1 where d1[1].i > 0; +update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1 + where d1[1].i > 0; select * from dcomptable; d1 -------------------- {"(11,)","(,)"} {"(99,)"} - {"(1,2)","(,)"} - {"(3,4)","(6,5)"} - {"(7,8)","(10,9)"} - {"(9,10)","(,)"} - {"(0,2)"} - {"(98,100)"} + {"(1,3)","(,)"} + {"(3,5)","(6,5)"} + {"(7,9)","(10,9)"} + {"(9,11)","(,)"} + {"(0,3)"} + {"(98,101)"} (8 rows) +explain (verbose, costs off) + update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1 + where d1[1].i > 0; + QUERY PLAN +---------------------------------------------------------------------------------------------------------------- + Update on public.dcomptable + -> Seq Scan on public.dcomptable + Output: (d1[1].r := (d1[1].r - '1'::double precision))[1].i := (d1[1].i + '1'::double precision), ctid + Filter: (dcomptable.d1[1].i > '0'::double precision) +(4 rows) + +create rule silly as on delete to dcomptable do instead + update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1 + where d1[1].i > 0; +\d+ dcomptable + Table "public.dcomptable" + Column | Type | Modifiers | Storage | Stats target | Description +--------+------------+-----------+----------+--------------+------------- + d1 | dcomptypea | | extended | | +Indexes: + "dcomptable_d1_key" UNIQUE CONSTRAINT, btree (d1) +Rules: + silly AS + ON DELETE TO dcomptable DO INSTEAD UPDATE dcomptable SET d1[1].r = dcomptable.d1[1].r - 1::double precision, d1[1].i = dcomptable.d1[1].i + 1::double precision + WHERE dcomptable.d1[1].i > 0::double precision + drop table dcomptable; drop type comptype cascade; NOTICE: drop cascades to type dcomptypea diff --git a/src/test/regress/sql/domain.sql b/src/test/regress/sql/domain.sql index 1fd7b11fd4..5ec128dd25 100644 --- a/src/test/regress/sql/domain.sql +++ b/src/test/regress/sql/domain.sql @@ -150,9 +150,18 @@ insert into dcomptable (d1[1].r) values(99); insert into dcomptable (d1[1].r, d1[1].i) values(99, 100); insert into dcomptable (d1[1].r, d1[1].i) values(100, 99); -- fail update dcomptable set d1[1].r = d1[1].r + 1 where d1[1].i > 0; -- fail -update dcomptable set d1[1].r = d1[1].r - 1 where d1[1].i > 0; +update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1 + where d1[1].i > 0; select * from dcomptable; +explain (verbose, costs off) + update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1 + where d1[1].i > 0; +create rule silly as on delete to dcomptable do instead + update dcomptable set d1[1].r = d1[1].r - 1, d1[1].i = d1[1].i + 1 + where d1[1].i > 0; +\d+ dcomptable + drop table dcomptable; drop type comptype cascade; From cb02cbc9d7dbf061e9a4862584481513253a0db5 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Thu, 13 Jul 2017 15:47:02 +0300 Subject: [PATCH 0139/1139] Fix race between GetNewTransactionId and GetOldestActiveTransactionId. The race condition goes like this: 1. GetNewTransactionId advances nextXid e.g. from 100 to 101 2. GetOldestActiveTransactionId reads the new nextXid, 101 3. GetOldestActiveTransactionId loops through the proc array. There are no active XIDs there, so it returns 101 as the oldest active XID. 4. GetNewTransactionid stores XID 100 to MyPgXact->xid So, GetOldestActiveTransactionId returned XID 101, even though 100 only just started and is surely still running. This would be hard to hit in practice, and even harder to spot any ill effect if it happens. GetOldestActiveTransactionId is only used when creating a checkpoint in a master server, and the race condition can only happen on an online checkpoint, as there are no backends running during a shutdown checkpoint. The oldestActiveXid value of an online checkpoint is only used when starting up a hot standby server, to determine the starting point where pg_subtrans is initialized from. For the race condition to happen, there must be no other XIDs in the proc array that would hold back the oldest-active XID value, which means that the missed XID must be a top transaction's XID. However, pg_subtrans is not used for top XIDs, so I believe an off-by-one error is in fact inconsequential. Nevertheless, let's fix it, as it's clearly wrong and the fix is simple. This has been wrong ever since hot standby was introduced, so backport to all supported versions. Discussion: https://www.postgresql.org/message-id/e7258662-82b6-7a45-56d4-99b337a32bf7@iki.fi --- src/backend/storage/ipc/procarray.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index a3a0207872..03c8c933b1 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -2095,20 +2095,21 @@ GetOldestActiveTransactionId(void) Assert(!RecoveryInProgress()); - LWLockAcquire(ProcArrayLock, LW_SHARED); - /* - * It's okay to read nextXid without acquiring XidGenLock because (1) we - * assume TransactionIds can be read atomically and (2) we don't care if - * we get a slightly stale value. It can't be very stale anyway, because - * the LWLockAcquire above will have done any necessary memory - * interlocking. + * Read nextXid, as the upper bound of what's still active. + * + * Reading a TransactionId is atomic, but we must grab the lock to make + * sure that all XIDs < nextXid are already present in the proc array (or + * have already completed), when we spin over it. */ + LWLockAcquire(XidGenLock, LW_SHARED); oldestRunningXid = ShmemVariableCache->nextXid; + LWLockRelease(XidGenLock); /* * Spin over procArray collecting all xids and subxids. */ + LWLockAcquire(ProcArrayLock, LW_SHARED); for (index = 0; index < arrayP->numProcs; index++) { int pgprocno = arrayP->pgprocnos[index]; @@ -2130,7 +2131,6 @@ GetOldestActiveTransactionId(void) * smaller than oldestRunningXid */ } - LWLockRelease(ProcArrayLock); return oldestRunningXid; From 3b0c2dbed07e52b73a87d94ed128784eb5c25de7 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 13 Jul 2017 19:24:44 -0400 Subject: [PATCH 0140/1139] Fix dumping of FUNCTION RTEs that contain non-function-call expressions. The grammar will only accept something syntactically similar to a function call in a function-in-FROM expression. However, there are various ways to input something that ruleutils.c won't deparse that way, potentially leading to a view or rule that fails dump/reload. Fix by inserting a dummy CAST around anything that isn't going to deparse as a function (which is one of the ways to get something like that in there in the first place). In HEAD, also make use of the infrastructure added by this to avoid emitting unnecessary parentheses in CREATE INDEX deparsing. I did not change that in back branches, thinking that people might find it to be unexpected/unnecessary behavioral change. In HEAD, also fix incorrect logic for when to add extra parens to partition key expressions. Somebody apparently thought they could get away with simpler logic than pg_get_indexdef_worker has, but they were wrong --- a counterexample is PARTITION BY LIST ((a[1])). Ignoring the prettyprint flag for partition expressions isn't exactly a nice solution anyway. This has been broken all along, so back-patch to all supported branches. Discussion: https://postgr.es/m/10477.1499970459@sss.pgh.pa.us --- src/backend/utils/adt/ruleutils.c | 64 ++++++++++++++++++++++- src/test/regress/expected/create_view.out | 23 ++++++++ src/test/regress/sql/create_view.sql | 11 ++++ 3 files changed, 96 insertions(+), 2 deletions(-) diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 6a58b7e1ff..a364602b22 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -409,6 +409,9 @@ static void get_rule_expr(Node *node, deparse_context *context, bool showimplicit); static void get_rule_expr_toplevel(Node *node, deparse_context *context, bool showimplicit); +static void get_rule_expr_funccall(Node *node, deparse_context *context, + bool showimplicit); +static bool looks_like_function(Node *node); static void get_oper_expr(OpExpr *expr, deparse_context *context); static void get_func_expr(FuncExpr *expr, deparse_context *context, bool showimplicit); @@ -8259,6 +8262,63 @@ get_rule_expr_toplevel(Node *node, deparse_context *context, get_rule_expr(node, context, showimplicit); } +/* + * get_rule_expr_funccall - Parse back a function-call expression + * + * Same as get_rule_expr(), except that we guarantee that the output will + * look like a function call, or like one of the things the grammar treats as + * equivalent to a function call (see the func_expr_windowless production). + * This is needed in places where the grammar uses func_expr_windowless and + * you can't substitute a parenthesized a_expr. If what we have isn't going + * to look like a function call, wrap it in a dummy CAST() expression, which + * will satisfy the grammar --- and, indeed, is likely what the user wrote to + * produce such a thing. + */ +static void +get_rule_expr_funccall(Node *node, deparse_context *context, + bool showimplicit) +{ + if (looks_like_function(node)) + get_rule_expr(node, context, showimplicit); + else + { + StringInfo buf = context->buf; + + appendStringInfoString(buf, "CAST("); + /* no point in showing any top-level implicit cast */ + get_rule_expr(node, context, false); + appendStringInfo(buf, " AS %s)", + format_type_with_typemod(exprType(node), + exprTypmod(node))); + } +} + +/* + * Helper function to identify node types that satisfy func_expr_windowless. + * If in doubt, "false" is always a safe answer. + */ +static bool +looks_like_function(Node *node) +{ + if (node == NULL) + return false; /* probably shouldn't happen */ + switch (nodeTag(node)) + { + case T_FuncExpr: + /* OK, unless it's going to deparse as a cast */ + return (((FuncExpr *) node)->funcformat == COERCE_EXPLICIT_CALL); + case T_NullIfExpr: + case T_CoalesceExpr: + case T_MinMaxExpr: + case T_XmlExpr: + /* these are all accepted by func_expr_common_subexpr */ + return true; + default: + break; + } + return false; +} + /* * get_oper_expr - Parse back an OpExpr node @@ -9120,7 +9180,7 @@ get_from_clause_item(Node *jtnode, Query *query, deparse_context *context) if (list_length(rte->functions) == 1 && (rtfunc1->funccolnames == NIL || !rte->funcordinality)) { - get_rule_expr(rtfunc1->funcexpr, context, true); + get_rule_expr_funccall(rtfunc1->funcexpr, context, true); /* we'll print the coldeflist below, if it has one */ } else @@ -9183,7 +9243,7 @@ get_from_clause_item(Node *jtnode, Query *query, deparse_context *context) if (funcno > 0) appendStringInfoString(buf, ", "); - get_rule_expr(rtfunc->funcexpr, context, true); + get_rule_expr_funccall(rtfunc->funcexpr, context, true); if (rtfunc->funccolnames != NIL) { /* Reconstruct the column definition list */ diff --git a/src/test/regress/expected/create_view.out b/src/test/regress/expected/create_view.out index b1c3cff931..049fe0d778 100644 --- a/src/test/regress/expected/create_view.out +++ b/src/test/regress/expected/create_view.out @@ -1567,6 +1567,29 @@ select pg_get_viewdef('tt19v', true); 'foo'::text = ANY ((( SELECT ARRAY['abc'::text, 'def'::text, 'foo'::text] AS "array"))::text[]) AS c2; (1 row) +-- check display of assorted RTE_FUNCTION expressions +create view tt20v as +select * from + coalesce(1,2) as c, + collation for ('x'::text) col, + current_date as d, + cast(1+2 as int4) as i4, + cast(1+2 as int8) as i8; +select pg_get_viewdef('tt20v', true); + pg_get_viewdef +--------------------------------------------- + SELECT c.c, + + col.col, + + d.d, + + i4.i4, + + i8.i8 + + FROM COALESCE(1, 2) c(c), + + pg_collation_for('x'::text) col(col), + + CAST('now'::text::date AS date) d(d), + + CAST(1 + 2 AS integer) i4(i4), + + CAST((1 + 2)::bigint AS bigint) i8(i8); +(1 row) + -- clean up all the random objects we made above set client_min_messages = warning; DROP SCHEMA temp_view_test CASCADE; diff --git a/src/test/regress/sql/create_view.sql b/src/test/regress/sql/create_view.sql index 5fe8b94aae..d7b461f8d4 100644 --- a/src/test/regress/sql/create_view.sql +++ b/src/test/regress/sql/create_view.sql @@ -520,6 +520,17 @@ select 'foo'::text = any(array['abc','def','foo']::text[]) c1, 'foo'::text = any((select array['abc','def','foo']::text[])::text[]) c2; select pg_get_viewdef('tt19v', true); +-- check display of assorted RTE_FUNCTION expressions + +create view tt20v as +select * from + coalesce(1,2) as c, + collation for ('x'::text) col, + current_date as d, + cast(1+2 as int4) as i4, + cast(1+2 as int8) as i8; +select pg_get_viewdef('tt20v', true); + -- clean up all the random objects we made above set client_min_messages = warning; DROP SCHEMA temp_view_test CASCADE; From cedd25ae8877cb7a465c3b42db7dab20873e162c Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Fri, 14 Jul 2017 16:02:53 +0300 Subject: [PATCH 0141/1139] Fix pg_basebackup output to stdout on Windows. When writing a backup to stdout with pg_basebackup on Windows, put stdout to binary mode. Any CR bytes in the output will otherwise be output incorrectly as CR+LF. In the passing, standardize on using "_setmode" instead of "setmode", for the sake of consistency. They both do the same thing, but according to MSDN documentation, setmode is deprecated. Fixes bug #14634, reported by Henry Boehlert. Patch by Haribabu Kommi. Backpatch to all supported versions. Discussion: https://www.postgresql.org/message-id/20170428082818.24366.13134@wrigleys.postgresql.org --- src/bin/pg_basebackup/pg_basebackup.c | 4 ++++ src/bin/pg_dump/pg_backup_archiver.c | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/bin/pg_basebackup/pg_basebackup.c b/src/bin/pg_basebackup/pg_basebackup.c index 613f2e159c..4e3a45f989 100644 --- a/src/bin/pg_basebackup/pg_basebackup.c +++ b/src/bin/pg_basebackup/pg_basebackup.c @@ -806,6 +806,10 @@ ReceiveTarFile(PGconn *conn, PGresult *res, int rownum) */ if (strcmp(basedir, "-") == 0) { +#ifdef WIN32 + _setmode(fileno(stdout), _O_BINARY); +#endif + #ifdef HAVE_LIBZ if (compresslevel != 0) { diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c index a23b070c0e..6483563f3d 100644 --- a/src/bin/pg_dump/pg_backup_archiver.c +++ b/src/bin/pg_dump/pg_backup_archiver.c @@ -2337,9 +2337,9 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt, (AH->fSpec == NULL || strcmp(AH->fSpec, "") == 0)) { if (mode == archModeWrite) - setmode(fileno(stdout), O_BINARY); + _setmode(fileno(stdout), O_BINARY); else - setmode(fileno(stdin), O_BINARY); + _setmode(fileno(stdin), O_BINARY); } #endif From 4e763fb6f6345c44752ed87ffff41894d1d9c191 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 14 Jul 2017 12:26:53 -0400 Subject: [PATCH 0142/1139] Fix broken link-command-line ordering for libpgfeutils. In the frontend Makefiles that pull in libpgfeutils, we'd generally done it like this: LDFLAGS += -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport) That method is badly broken, as seen in bug #14742 from Chris Ruprecht. The -L flag for src/fe_utils ends up being placed after whatever random -L flags are in LDFLAGS already. That puts us at risk of pulling in libpgfeutils.a from some previous installation rather than the freshly built one in src/fe_utils. Also, the lack of an "override" is hazardous if someone tries to specify some LDFLAGS on the make command line. The correct way to do it is like this: override LDFLAGS := -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport) $(LDFLAGS) so that libpgfeutils, along with libpq, libpgport, and libpgcommon, are guaranteed to be pulled in from the build tree and not from any referenced system directory, because their -L flags will appear first. In some places we'd been even lazier and done it like this: LDFLAGS += -L$(top_builddir)/src/fe_utils -lpgfeutils -lpq which is subtly wrong in an additional way: on platforms where we can't restrict the symbols exported by libpq.so, it allows libpgfeutils to latch onto libpgport and libpgcommon symbols from libpq.so, rather than directly from those static libraries as intended. This carries hazards like those explained in the comments for the libpq_pgport macro. In addition to fixing the broken libpgfeutils usages, I tried to standardize on using $(libpq_pgport) like so: override LDFLAGS := $(libpq_pgport) $(LDFLAGS) even where libpgfeutils is not in the picture. This makes no difference right now but will hopefully discourage future mistakes of the same ilk. And it's more like the way we handle CPPFLAGS in libpq-using Makefiles. In passing, just for consistency, make pgbench include PTHREAD_LIBS the same way everyplace else does, ie just after LIBS rather than in some random place in the command line. This might have practical effect if there are -L switches in that macro on some platform. It looks to me like the MSVC build scripts are not affected by this error, but someone more familiar with them than I might want to double check. Back-patch to 9.6 where libpgfeutils was introduced. In 9.6, the hazard this error creates is that a reinstallation might link to the prior installation's copy of libpgfeutils.a and thereby fail to absorb a minor-version bug fix. Discussion: https://postgr.es/m/20170714125106.9231.13772@wrigleys.postgresql.org --- src/bin/pg_dump/Makefile | 8 ++++---- src/bin/pg_rewind/Makefile | 6 ++---- src/bin/pg_upgrade/Makefile | 4 ++-- src/bin/pgbench/Makefile | 5 +++-- src/bin/psql/Makefile | 4 ++-- src/bin/scripts/Makefile | 4 ++-- src/tools/findoidjoins/Makefile | 3 ++- 7 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/bin/pg_dump/Makefile b/src/bin/pg_dump/Makefile index 25336a5f25..f63412e2c5 100644 --- a/src/bin/pg_dump/Makefile +++ b/src/bin/pg_dump/Makefile @@ -17,7 +17,7 @@ top_builddir = ../../.. include $(top_builddir)/src/Makefile.global override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS) -LDFLAGS += -L$(top_builddir)/src/fe_utils -lpgfeutils -lpq +override LDFLAGS := -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport) $(LDFLAGS) OBJS= pg_backup_archiver.o pg_backup_db.o pg_backup_custom.o \ pg_backup_null.o pg_backup_tar.o pg_backup_directory.o \ @@ -26,13 +26,13 @@ OBJS= pg_backup_archiver.o pg_backup_db.o pg_backup_custom.o \ all: pg_dump pg_restore pg_dumpall pg_dump: pg_dump.o common.o pg_dump_sort.o $(OBJS) | submake-libpq submake-libpgport submake-libpgfeutils - $(CC) $(CFLAGS) pg_dump.o common.o pg_dump_sort.o $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) pg_dump.o common.o pg_dump_sort.o $(OBJS) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) pg_restore: pg_restore.o $(OBJS) | submake-libpq submake-libpgport submake-libpgfeutils - $(CC) $(CFLAGS) pg_restore.o $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) pg_restore.o $(OBJS) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) pg_dumpall: pg_dumpall.o dumputils.o | submake-libpq submake-libpgport submake-libpgfeutils - $(CC) $(CFLAGS) pg_dumpall.o dumputils.o $(WIN32RES) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) pg_dumpall.o dumputils.o $(WIN32RES) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) install: all installdirs $(INSTALL_PROGRAM) pg_dump$(X) '$(DESTDIR)$(bindir)'/pg_dump$(X) diff --git a/src/bin/pg_rewind/Makefile b/src/bin/pg_rewind/Makefile index d03a0a2eae..8c8d8e0578 100644 --- a/src/bin/pg_rewind/Makefile +++ b/src/bin/pg_rewind/Makefile @@ -15,10 +15,8 @@ subdir = src/bin/pg_rewind top_builddir = ../../.. include $(top_builddir)/src/Makefile.global -PG_CPPFLAGS = -I$(libpq_srcdir) -PG_LIBS = $(libpq_pgport) - override CPPFLAGS := -I$(libpq_srcdir) -DFRONTEND $(CPPFLAGS) +override LDFLAGS := $(libpq_pgport) $(LDFLAGS) OBJS = pg_rewind.o parsexlog.o xlogreader.o datapagemap.o timeline.o \ fetch.o file_ops.o copy_fetch.o libpq_fetch.o filemap.o logging.o \ @@ -29,7 +27,7 @@ EXTRA_CLEAN = xlogreader.c all: pg_rewind pg_rewind: $(OBJS) | submake-libpq submake-libpgport - $(CC) $(CFLAGS) $^ $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) $^ $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) xlogreader.c: % : $(top_srcdir)/src/backend/access/transam/% rm -f $@ && $(LN_S) $< . diff --git a/src/bin/pg_upgrade/Makefile b/src/bin/pg_upgrade/Makefile index 8823288708..737740cda1 100644 --- a/src/bin/pg_upgrade/Makefile +++ b/src/bin/pg_upgrade/Makefile @@ -12,13 +12,13 @@ OBJS = check.o controldata.o dump.o exec.o file.o function.o info.o \ tablespace.o util.o version.o $(WIN32RES) override CPPFLAGS := -DDLSUFFIX=\"$(DLSUFFIX)\" -I$(srcdir) -I$(libpq_srcdir) $(CPPFLAGS) -LDFLAGS += -L$(top_builddir)/src/fe_utils -lpgfeutils -lpq +override LDFLAGS := -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport) $(LDFLAGS) all: pg_upgrade pg_upgrade: $(OBJS) | submake-libpq submake-libpgport submake-libpgfeutils - $(CC) $(CFLAGS) $^ $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) $^ $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) install: all installdirs $(INSTALL_PROGRAM) pg_upgrade$(X) '$(DESTDIR)$(bindir)/pg_upgrade$(X)' diff --git a/src/bin/pgbench/Makefile b/src/bin/pgbench/Makefile index 1503d00e12..8a8e516896 100644 --- a/src/bin/pgbench/Makefile +++ b/src/bin/pgbench/Makefile @@ -10,17 +10,18 @@ include $(top_builddir)/src/Makefile.global OBJS = pgbench.o exprparse.o $(WIN32RES) override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) $(CPPFLAGS) -LDFLAGS += -L$(top_builddir)/src/fe_utils -lpgfeutils -lpq +override LDFLAGS := -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport) $(LDFLAGS) ifneq ($(PORTNAME), win32) override CFLAGS += $(PTHREAD_CFLAGS) endif +LIBS += $(PTHREAD_LIBS) all: pgbench pgbench: $(OBJS) | submake-libpq submake-libpgport submake-libpgfeutils - $(CC) $(CFLAGS) $^ $(libpq_pgport) $(PTHREAD_LIBS) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) $^ $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) # exprscan is compiled as part of exprparse exprparse.o: exprscan.c diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile index 1f6a289ea0..4295154cae 100644 --- a/src/bin/psql/Makefile +++ b/src/bin/psql/Makefile @@ -19,7 +19,7 @@ include $(top_builddir)/src/Makefile.global REFDOCDIR= $(top_srcdir)/doc/src/sgml/ref override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) $(CPPFLAGS) -LDFLAGS += -L$(top_builddir)/src/fe_utils -lpgfeutils -lpq +override LDFLAGS := -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport) $(LDFLAGS) OBJS= command.o common.o help.o input.o stringutils.o mainloop.o copy.o \ startup.o prompt.o variables.o large_obj.o describe.o \ @@ -31,7 +31,7 @@ OBJS= command.o common.o help.o input.o stringutils.o mainloop.o copy.o \ all: psql psql: $(OBJS) | submake-libpq submake-libpgport submake-libpgfeutils - $(CC) $(CFLAGS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) help.o: sql_help.h diff --git a/src/bin/scripts/Makefile b/src/bin/scripts/Makefile index c6ad4e7552..b98dbc7d30 100644 --- a/src/bin/scripts/Makefile +++ b/src/bin/scripts/Makefile @@ -19,12 +19,12 @@ include $(top_builddir)/src/Makefile.global PROGRAMS = createdb createlang createuser dropdb droplang dropuser clusterdb vacuumdb reindexdb pg_isready override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS) -LDFLAGS += -L$(top_builddir)/src/fe_utils -lpgfeutils -lpq +override LDFLAGS := -L$(top_builddir)/src/fe_utils -lpgfeutils $(libpq_pgport) $(LDFLAGS) all: $(PROGRAMS) %: %.o $(WIN32RES) - $(CC) $(CFLAGS) $^ $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) $^ $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) createdb: createdb.o common.o | submake-libpq submake-libpgport submake-libpgfeutils createlang: createlang.o common.o | submake-libpq submake-libpgport submake-libpgfeutils diff --git a/src/tools/findoidjoins/Makefile b/src/tools/findoidjoins/Makefile index b1785ced6b..a067b33af2 100644 --- a/src/tools/findoidjoins/Makefile +++ b/src/tools/findoidjoins/Makefile @@ -13,13 +13,14 @@ top_builddir = ../../.. include $(top_builddir)/src/Makefile.global override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS) +override LDFLAGS := $(libpq_pgport) $(LDFLAGS) OBJS= findoidjoins.o all: findoidjoins findoidjoins: findoidjoins.o | submake-libpq submake-libpgport - $(CC) $(CFLAGS) findoidjoins.o $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) findoidjoins.o $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X) clean distclean maintainer-clean: rm -f findoidjoins$(X) $(OBJS) From b4a1d69ed4da83d25639f5bdb129ee83aa19c242 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Sun, 16 Jul 2017 11:24:29 -0400 Subject: [PATCH 0143/1139] Fix vcregress.pl PROVE_FLAGS bug in commit 93b7d9731f This change didn't adjust the publicly visible taptest function, causing buildfarm failures on bowerbird. Backpatch to 9.4 like previous change. --- src/tools/msvc/vcregress.pl | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/tools/msvc/vcregress.pl b/src/tools/msvc/vcregress.pl index 3acb9c0ee8..0d0cff9185 100644 --- a/src/tools/msvc/vcregress.pl +++ b/src/tools/msvc/vcregress.pl @@ -226,11 +226,20 @@ sub bincheck sub taptest { my $dir = shift; + my @args; + + if ($dir =~ /^PROVE_FLAGS=/) + { + push(@args, $dir); + $dir = shift; + } die "no tests found!" unless -d "$topdir/$dir/t"; + push(@args,"$topdir/$dir); + InstallTemp(); - my $status = tap_check("$topdir/$dir"); + my $status = tap_check(@args); exit $status if $status; } From 220a9b5e55070c9c37017914f456a9a4c6f46145 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Sun, 16 Jul 2017 12:00:23 -0400 Subject: [PATCH 0144/1139] fix typo --- src/tools/msvc/vcregress.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/msvc/vcregress.pl b/src/tools/msvc/vcregress.pl index 0d0cff9185..1ec595af36 100644 --- a/src/tools/msvc/vcregress.pl +++ b/src/tools/msvc/vcregress.pl @@ -236,7 +236,7 @@ sub taptest die "no tests found!" unless -d "$topdir/$dir/t"; - push(@args,"$topdir/$dir); + push(@args,"$topdir/$dir"); InstallTemp(); my $status = tap_check(@args); From d46403d2f30327775b1819f84430a573450c9deb Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 17 Jul 2017 15:28:16 -0400 Subject: [PATCH 0145/1139] Merge large_object.sql test into largeobject.source. It seems pretty confusing to have tests named both largeobject and large_object. The latter is of very recent vintage (commit ff992c074), so get rid of it in favor of merging into the former. Also, enable the LO comment test that was added by commit 70ad7ed4e, since the later commit added the then-missing pg_upgrade functionality. The large_object.sql test case is almost completely redundant with that, but not quite: it seems like creating a user-defined LO with an OID in the system range might be an interesting case for pg_upgrade, so let's keep it. Like the earlier patch, back-patch to all supported branches. Discussion: https://postgr.es/m/18665.1500306372@sss.pgh.pa.us --- src/test/regress/expected/large_object.out | 15 --------------- src/test/regress/input/largeobject.source | 13 +++++++++---- src/test/regress/output/largeobject.source | 16 ++++++++++++---- src/test/regress/output/largeobject_1.source | 16 ++++++++++++---- src/test/regress/parallel_schedule | 2 +- src/test/regress/serial_schedule | 1 - src/test/regress/sql/large_object.sql | 8 -------- 7 files changed, 34 insertions(+), 37 deletions(-) delete mode 100644 src/test/regress/expected/large_object.out delete mode 100644 src/test/regress/sql/large_object.sql diff --git a/src/test/regress/expected/large_object.out b/src/test/regress/expected/large_object.out deleted file mode 100644 index b00d47cc75..0000000000 --- a/src/test/regress/expected/large_object.out +++ /dev/null @@ -1,15 +0,0 @@ --- This is more-or-less DROP IF EXISTS LARGE OBJECT 3001; -WITH unlink AS (SELECT lo_unlink(loid) FROM pg_largeobject WHERE loid = 3001) SELECT 1; - ?column? ----------- - 1 -(1 row) - --- Test creation of a large object and leave it for testing pg_upgrade -SELECT lo_create(3001); - lo_create ------------ - 3001 -(1 row) - -COMMENT ON LARGE OBJECT 3001 IS 'testing comments'; diff --git a/src/test/regress/input/largeobject.source b/src/test/regress/input/largeobject.source index 96d75bccfb..b7a9d052bd 100644 --- a/src/test/regress/input/largeobject.source +++ b/src/test/regress/input/largeobject.source @@ -86,10 +86,8 @@ END; SELECT lo_from_bytea(0, lo_get(loid)) AS newloid FROM lotest_stash_values \gset --- Ideally we'd put a comment on this object for pg_dump testing purposes. --- But since pg_upgrade fails to preserve large object comments, doing so --- would break pg_upgrade's regression test. --- COMMENT ON LARGE OBJECT :newloid IS 'I Wandered Lonely as a Cloud'; +-- Add a comment to it, as well, for pg_dump/pg_upgrade testing. +COMMENT ON LARGE OBJECT :newloid IS 'I Wandered Lonely as a Cloud'; -- Read out a portion BEGIN; @@ -253,6 +251,13 @@ SELECT lo_from_bytea(0, E'\\xdeadbeef') AS newloid SET bytea_output TO hex; SELECT lo_get(:newloid); +-- Create one more object that we leave behind for testing pg_dump/pg_upgrade; +-- this one intentionally has an OID in the system range +SELECT lo_create(3001); + +COMMENT ON LARGE OBJECT 3001 IS 'testing comments'; + +-- Clean up DROP TABLE lotest_stash_values; DROP ROLE regress_lo_user; diff --git a/src/test/regress/output/largeobject.source b/src/test/regress/output/largeobject.source index 906a24eac4..e29f5423aa 100644 --- a/src/test/regress/output/largeobject.source +++ b/src/test/regress/output/largeobject.source @@ -90,10 +90,8 @@ END; -- it's left behind to help test pg_dump. SELECT lo_from_bytea(0, lo_get(loid)) AS newloid FROM lotest_stash_values \gset --- Ideally we'd put a comment on this object for pg_dump testing purposes. --- But since pg_upgrade fails to preserve large object comments, doing so --- would break pg_upgrade's regression test. --- COMMENT ON LARGE OBJECT :newloid IS 'I Wandered Lonely as a Cloud'; +-- Add a comment to it, as well, for pg_dump/pg_upgrade testing. +COMMENT ON LARGE OBJECT :newloid IS 'I Wandered Lonely as a Cloud'; -- Read out a portion BEGIN; UPDATE lotest_stash_values SET fd=lo_open(loid, CAST(x'20000' | x'40000' AS integer)); @@ -469,5 +467,15 @@ SELECT lo_get(:newloid); \xdeadbeef (1 row) +-- Create one more object that we leave behind for testing pg_dump/pg_upgrade; +-- this one intentionally has an OID in the system range +SELECT lo_create(3001); + lo_create +----------- + 3001 +(1 row) + +COMMENT ON LARGE OBJECT 3001 IS 'testing comments'; +-- Clean up DROP TABLE lotest_stash_values; DROP ROLE regress_lo_user; diff --git a/src/test/regress/output/largeobject_1.source b/src/test/regress/output/largeobject_1.source index cec35d70d5..6fd8cbe098 100644 --- a/src/test/regress/output/largeobject_1.source +++ b/src/test/regress/output/largeobject_1.source @@ -90,10 +90,8 @@ END; -- it's left behind to help test pg_dump. SELECT lo_from_bytea(0, lo_get(loid)) AS newloid FROM lotest_stash_values \gset --- Ideally we'd put a comment on this object for pg_dump testing purposes. --- But since pg_upgrade fails to preserve large object comments, doing so --- would break pg_upgrade's regression test. --- COMMENT ON LARGE OBJECT :newloid IS 'I Wandered Lonely as a Cloud'; +-- Add a comment to it, as well, for pg_dump/pg_upgrade testing. +COMMENT ON LARGE OBJECT :newloid IS 'I Wandered Lonely as a Cloud'; -- Read out a portion BEGIN; UPDATE lotest_stash_values SET fd=lo_open(loid, CAST(x'20000' | x'40000' AS integer)); @@ -469,5 +467,15 @@ SELECT lo_get(:newloid); \xdeadbeef (1 row) +-- Create one more object that we leave behind for testing pg_dump/pg_upgrade; +-- this one intentionally has an OID in the system range +SELECT lo_create(3001); + lo_create +----------- + 3001 +(1 row) + +COMMENT ON LARGE OBJECT 3001 IS 'testing comments'; +-- Clean up DROP TABLE lotest_stash_values; DROP ROLE regress_lo_user; diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule index 0d68bcf9a4..3815182fe7 100644 --- a/src/test/regress/parallel_schedule +++ b/src/test/regress/parallel_schedule @@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi # ---------- # Another group of parallel tests # ---------- -test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator large_object +test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator # ---------- # Another group of parallel tests diff --git a/src/test/regress/serial_schedule b/src/test/regress/serial_schedule index 17f1d855bc..8958d8cdb9 100644 --- a/src/test/regress/serial_schedule +++ b/src/test/regress/serial_schedule @@ -116,7 +116,6 @@ test: object_address test: tablesample test: groupingsets test: drop_operator -test: large_object test: alter_generic test: alter_operator test: misc diff --git a/src/test/regress/sql/large_object.sql b/src/test/regress/sql/large_object.sql deleted file mode 100644 index a9e18b7c60..0000000000 --- a/src/test/regress/sql/large_object.sql +++ /dev/null @@ -1,8 +0,0 @@ - --- This is more-or-less DROP IF EXISTS LARGE OBJECT 3001; -WITH unlink AS (SELECT lo_unlink(loid) FROM pg_largeobject WHERE loid = 3001) SELECT 1; - --- Test creation of a large object and leave it for testing pg_upgrade -SELECT lo_create(3001); - -COMMENT ON LARGE OBJECT 3001 IS 'testing comments'; From 236bdae543d9ecd6a413b9e5b5c9d1237c6774c5 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 17 Jul 2017 16:43:03 -0400 Subject: [PATCH 0146/1139] Doc: explain dollar quoting in the intro part of the pl/pgsql chapter. We're throwing people into the guts of the syntax with not much context; let's back up one step and point out that this goes inside a literal in a CREATE FUNCTION command. Per suggestion from Kurt Kartaltepe. Discussion: https://postgr.es/m/CACawnnyWAmH+au8nfZhLiFfWKjXy4d0kY+eZWfcxPRnjVfaa_Q@mail.gmail.com --- doc/src/sgml/plpgsql.sgml | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/doc/src/sgml/plpgsql.sgml b/doc/src/sgml/plpgsql.sgml index d3272e1209..eb1e786200 100644 --- a/doc/src/sgml/plpgsql.sgml +++ b/doc/src/sgml/plpgsql.sgml @@ -179,9 +179,27 @@ Structure of <application>PL/pgSQL</application> + + Functions written in PL/pgSQL are defined + to the server by executing commands. + Such a command would normally look like, say, + +CREATE FUNCTION somefunc(integer, text) RETURNS integer +AS 'function body text' +LANGUAGE plpgsql; + + The function body is simply a string literal so far as CREATE + FUNCTION is concerned. It is often helpful to use dollar quoting + (see ) to write the function + body, rather than the normal single quote syntax. Without dollar quoting, + any single quotes or backslashes in the function body must be escaped by + doubling them. Almost all the examples in this chapter use dollar-quoted + literals for their function bodies. + + PL/pgSQL is a block-structured language. - The complete text of a function definition must be a + The complete text of a function body must be a block. A block is defined as: From 0e8448bbfd2de5bf17b3fd379e1d28a14f1e9b02 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 19 Jul 2017 12:58:36 -0400 Subject: [PATCH 0147/1139] Doc: add missing note about permissions needed to change log_lock_waits. log_lock_waits is PGC_SUSET, but config.sgml lacked the standard boilerplate sentence noting that. Report: https://postgr.es/m/20170719100838.19352.16320@wrigleys.postgresql.org --- doc/src/sgml/config.sgml | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml index 0baa79bb80..ce5a05a779 100644 --- a/doc/src/sgml/config.sgml +++ b/doc/src/sgml/config.sgml @@ -5161,6 +5161,7 @@ FROM pg_stat_activity; longer than to acquire a lock. This is useful in determining if lock waits are causing poor performance. The default is off. + Only superusers can change this setting. From 41ada83774929c3bbb069a90f2aa3a8ac508e876 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 20 Jul 2017 11:29:36 -0400 Subject: [PATCH 0148/1139] Fix dumping of outer joins with empty qual lists. Normally, a JoinExpr would have empty "quals" only if it came from CROSS JOIN syntax. However, it's possible to get to this state by specifying NATURAL JOIN between two tables with no common column names, and there might be other ways too. The code previously printed no ON clause if "quals" was empty; that's right for CROSS JOIN but syntactically invalid if it's some type of outer join. Fix by printing ON TRUE in that case. This got broken by commit 2ffa740be, which stopped using NATURAL JOIN syntax in ruleutils output due to its brittleness in the face of column renamings. Back-patch to 9.3 where that commit appeared. Per report from Tushar Ahuja. Discussion: https://postgr.es/m/98b283cd-6dda-5d3f-f8ac-87db8c76a3da@enterprisedb.com --- src/backend/utils/adt/ruleutils.c | 5 ++++ src/test/regress/expected/create_view.out | 29 +++++++++++++++++++++++ src/test/regress/sql/create_view.sql | 10 ++++++++ 3 files changed, 44 insertions(+) diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index a364602b22..ea129c8212 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -9428,6 +9428,11 @@ get_from_clause_item(Node *jtnode, Query *query, deparse_context *context) if (!PRETTY_PAREN(context)) appendStringInfoChar(buf, ')'); } + else if (j->jointype != JOIN_INNER) + { + /* If we didn't say CROSS JOIN above, we must provide an ON */ + appendStringInfoString(buf, " ON TRUE"); + } if (!PRETTY_PAREN(context) || j->alias != NULL) appendStringInfoChar(buf, ')'); diff --git a/src/test/regress/expected/create_view.out b/src/test/regress/expected/create_view.out index 049fe0d778..bec0627650 100644 --- a/src/test/regress/expected/create_view.out +++ b/src/test/regress/expected/create_view.out @@ -1590,6 +1590,35 @@ select pg_get_viewdef('tt20v', true); CAST((1 + 2)::bigint AS bigint) i8(i8); (1 row) +-- corner cases with empty join conditions +create view tt21v as +select * from tt5 natural inner join tt6; +select pg_get_viewdef('tt21v', true); + pg_get_viewdef +---------------------- + SELECT tt5.a, + + tt5.b, + + tt5.cc, + + tt6.c, + + tt6.d + + FROM tt5 + + CROSS JOIN tt6; +(1 row) + +create view tt22v as +select * from tt5 natural left join tt6; +select pg_get_viewdef('tt22v', true); + pg_get_viewdef +----------------------------- + SELECT tt5.a, + + tt5.b, + + tt5.cc, + + tt6.c, + + tt6.d + + FROM tt5 + + LEFT JOIN tt6 ON TRUE; +(1 row) + -- clean up all the random objects we made above set client_min_messages = warning; DROP SCHEMA temp_view_test CASCADE; diff --git a/src/test/regress/sql/create_view.sql b/src/test/regress/sql/create_view.sql index d7b461f8d4..2246bade46 100644 --- a/src/test/regress/sql/create_view.sql +++ b/src/test/regress/sql/create_view.sql @@ -531,6 +531,16 @@ select * from cast(1+2 as int8) as i8; select pg_get_viewdef('tt20v', true); +-- corner cases with empty join conditions + +create view tt21v as +select * from tt5 natural inner join tt6; +select pg_get_viewdef('tt21v', true); + +create view tt22v as +select * from tt5 natural left join tt6; +select pg_get_viewdef('tt22v', true); + -- clean up all the random objects we made above set client_min_messages = warning; DROP SCHEMA temp_view_test CASCADE; From 5512427b19e79ac95535e7c942bd479db807f7be Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 20 Jul 2017 12:41:26 -0400 Subject: [PATCH 0149/1139] Doc: clarify description of degenerate NATURAL joins. Claiming that NATURAL JOIN is equivalent to CROSS JOIN when there are no common column names is only strictly correct if it's an inner join; you can't say e.g. CROSS LEFT JOIN. Better to explain it as meaning JOIN ON TRUE, instead. Per a suggestion from David Johnston. Discussion: https://postgr.es/m/CAKFQuwb+mYszQhDS9f_dqRrk1=Pe-S6D=XMkAXcDf4ykKPmgKQ@mail.gmail.com --- doc/src/sgml/queries.sgml | 4 ++-- doc/src/sgml/ref/select.sgml | 7 +++++-- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/doc/src/sgml/queries.sgml b/doc/src/sgml/queries.sgml index 5cc6dbce11..b851d134b7 100644 --- a/doc/src/sgml/queries.sgml +++ b/doc/src/sgml/queries.sgml @@ -393,8 +393,8 @@ FROM table_reference , table_r consisting of all column names that appear in both input tables. As with USING, these columns appear only once in the output table. If there are no common - column names, NATURAL behaves like - CROSS JOIN. + column names, NATURAL JOIN behaves like + JOIN ... ON TRUE, producing a cross-product join. diff --git a/doc/src/sgml/ref/select.sgml b/doc/src/sgml/ref/select.sgml index 211e4c320c..57f11e66fb 100644 --- a/doc/src/sgml/ref/select.sgml +++ b/doc/src/sgml/ref/select.sgml @@ -603,9 +603,12 @@ TABLE [ ONLY ] table_name [ * ] NATURAL - NATURAL is shorthand for a + + NATURAL is shorthand for a USING list that mentions all columns in the two - tables that have the same names. + tables that have matching names. If there are no common + column names, NATURAL is equivalent + to ON TRUE. From 38a4a5349c8f54a8d835675d395365d11628afac Mon Sep 17 00:00:00 2001 From: Teodor Sigaev Date: Fri, 21 Jul 2017 13:31:49 +0300 Subject: [PATCH 0150/1139] Fix double shared memory allocation. SLRU buffer lwlocks are allocated twice by oversight in commit fe702a7b3f9f2bc5bf6d173166d7d55226af82c8 where that locks were moved to separate tranche. The bug doesn't have user-visible effects except small overspending of shared memory. Backpatch to 9.6 where it was introduced. Alexander Korotkov with small editorization by me. --- src/backend/access/transam/slru.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c index bbae5847f2..ee111ca539 100644 --- a/src/backend/access/transam/slru.c +++ b/src/backend/access/transam/slru.c @@ -204,15 +204,16 @@ SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, shared->page_lru_count = (int *) (ptr + offset); offset += MAXALIGN(nslots * sizeof(int)); + /* Initialize LWLocks */ + shared->buffer_locks = (LWLockPadded *) (ptr + offset); + offset += MAXALIGN(nslots * sizeof(LWLockPadded)); + if (nlsns > 0) { shared->group_lsn = (XLogRecPtr *) (ptr + offset); offset += MAXALIGN(nslots * nlsns * sizeof(XLogRecPtr)); } - /* Initialize LWLocks */ - shared->buffer_locks = (LWLockPadded *) ShmemAlloc(sizeof(LWLockPadded) * nslots); - Assert(strlen(name) + 1 < SLRU_MAX_NAME_LENGTH); strlcpy(shared->lwlock_tranche_name, name, SLRU_MAX_NAME_LENGTH); shared->lwlock_tranche_id = tranche_id; @@ -232,6 +233,9 @@ SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, shared->page_lru_count[slotno] = 0; ptr += BLCKSZ; } + + /* Should fit to estimated shmem size */ + Assert(ptr - (char *) shared <= SimpleLruShmemSize(nslots, nlsns)); } else Assert(found); From d86a2b7b58bc9e5455a77f37690bf4588f4d2836 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 21 Jul 2017 12:51:38 -0400 Subject: [PATCH 0151/1139] Re-establish postgres_fdw connections after server or user mapping changes. Previously, postgres_fdw would keep on using an existing connection even if the user did ALTER SERVER or ALTER USER MAPPING commands that should affect connection parameters. Teach it to watch for catcache invals on these catalogs and re-establish connections when the relevant catalog entries change. Per bug #14738 from Michal Lis. In passing, clean up some rather crufty decisions in commit ae9bfc5d6 about where fields of ConnCacheEntry should be reset. We now reset all the fields whenever we open a new connection. Kyotaro Horiguchi, reviewed by Ashutosh Bapat and myself. Back-patch to 9.3 where postgres_fdw appeared. Discussion: https://postgr.es/m/20170710113917.7727.10247@wrigleys.postgresql.org --- contrib/postgres_fdw/connection.c | 118 +++++++++++++++--- .../postgres_fdw/expected/postgres_fdw.out | 37 ++++++ contrib/postgres_fdw/sql/postgres_fdw.sql | 20 +++ 3 files changed, 157 insertions(+), 18 deletions(-) diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c index 4023471434..2243ca2a36 100644 --- a/contrib/postgres_fdw/connection.c +++ b/contrib/postgres_fdw/connection.c @@ -21,6 +21,7 @@ #include "miscadmin.h" #include "storage/latch.h" #include "utils/hsearch.h" +#include "utils/inval.h" #include "utils/memutils.h" #include "utils/syscache.h" @@ -47,11 +48,15 @@ typedef struct ConnCacheEntry { ConnCacheKey key; /* hash key (must be first) */ PGconn *conn; /* connection to foreign server, or NULL */ + /* Remaining fields are invalid when conn is NULL: */ int xact_depth; /* 0 = no xact open, 1 = main xact open, 2 = * one level of subxact open, etc */ bool have_prep_stmt; /* have we prepared any stmts in this xact? */ bool have_error; /* have any subxacts aborted in this xact? */ bool changing_xact_state; /* xact state change in process */ + bool invalidated; /* true if reconnect is pending */ + uint32 server_hashvalue; /* hash value of foreign server OID */ + uint32 mapping_hashvalue; /* hash value of user mapping OID */ } ConnCacheEntry; /* @@ -68,6 +73,7 @@ static bool xact_got_connection = false; /* prototypes of private functions */ static PGconn *connect_pg_server(ForeignServer *server, UserMapping *user); +static void disconnect_pg_server(ConnCacheEntry *entry); static void check_conn_params(const char **keywords, const char **values); static void configure_remote_session(PGconn *conn); static void do_sql_command(PGconn *conn, const char *sql); @@ -77,6 +83,7 @@ static void pgfdw_subxact_callback(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg); +static void pgfdw_inval_callback(Datum arg, int cacheid, uint32 hashvalue); static void pgfdw_reject_incomplete_xact_state_change(ConnCacheEntry *entry); static bool pgfdw_cancel_query(PGconn *conn); static bool pgfdw_exec_cleanup_query(PGconn *conn, const char *query, @@ -94,13 +101,6 @@ static bool pgfdw_get_cleanup_result(PGconn *conn, TimestampTz endtime, * will_prep_stmt must be true if caller intends to create any prepared * statements. Since those don't go away automatically at transaction end * (not even on error), we need this flag to cue manual cleanup. - * - * XXX Note that caching connections theoretically requires a mechanism to - * detect change of FDW objects to invalidate already established connections. - * We could manage that by watching for invalidation events on the relevant - * syscaches. For the moment, though, it's not clear that this would really - * be useful and not mere pedantry. We could not flush any active connections - * mid-transaction anyway. */ PGconn * GetConnection(UserMapping *user, bool will_prep_stmt) @@ -129,6 +129,10 @@ GetConnection(UserMapping *user, bool will_prep_stmt) */ RegisterXactCallback(pgfdw_xact_callback, NULL); RegisterSubXactCallback(pgfdw_subxact_callback, NULL); + CacheRegisterSyscacheCallback(FOREIGNSERVEROID, + pgfdw_inval_callback, (Datum) 0); + CacheRegisterSyscacheCallback(USERMAPPINGOID, + pgfdw_inval_callback, (Datum) 0); } /* Set flag that we did GetConnection during the current transaction */ @@ -143,17 +147,27 @@ GetConnection(UserMapping *user, bool will_prep_stmt) entry = hash_search(ConnectionHash, &key, HASH_ENTER, &found); if (!found) { - /* initialize new hashtable entry (key is already filled in) */ + /* + * We need only clear "conn" here; remaining fields will be filled + * later when "conn" is set. + */ entry->conn = NULL; - entry->xact_depth = 0; - entry->have_prep_stmt = false; - entry->have_error = false; - entry->changing_xact_state = false; } /* Reject further use of connections which failed abort cleanup. */ pgfdw_reject_incomplete_xact_state_change(entry); + /* + * If the connection needs to be remade due to invalidation, disconnect as + * soon as we're out of all transactions. + */ + if (entry->conn != NULL && entry->invalidated && entry->xact_depth == 0) + { + elog(DEBUG3, "closing connection %p for option changes to take effect", + entry->conn); + disconnect_pg_server(entry); + } + /* * We don't check the health of cached connection here, because it would * require some overhead. Broken connection will be detected when the @@ -163,15 +177,26 @@ GetConnection(UserMapping *user, bool will_prep_stmt) /* * If cache entry doesn't have a connection, we have to establish a new * connection. (If connect_pg_server throws an error, the cache entry - * will be left in a valid empty state.) + * will remain in a valid empty state, ie conn == NULL.) */ if (entry->conn == NULL) { ForeignServer *server = GetForeignServer(user->serverid); - entry->xact_depth = 0; /* just to be sure */ + /* Reset all transient state fields, to be sure all are clean */ + entry->xact_depth = 0; entry->have_prep_stmt = false; entry->have_error = false; + entry->changing_xact_state = false; + entry->invalidated = false; + entry->server_hashvalue = + GetSysCacheHashValue1(FOREIGNSERVEROID, + ObjectIdGetDatum(server->serverid)); + entry->mapping_hashvalue = + GetSysCacheHashValue1(USERMAPPINGOID, + ObjectIdGetDatum(user->umid)); + + /* Now try to make the connection */ entry->conn = connect_pg_server(server, user); elog(DEBUG3, "new postgres_fdw connection %p for server \"%s\" (user mapping oid %u, userid %u)", @@ -285,6 +310,19 @@ connect_pg_server(ForeignServer *server, UserMapping *user) return conn; } +/* + * Disconnect any open connection for a connection cache entry. + */ +static void +disconnect_pg_server(ConnCacheEntry *entry) +{ + if (entry->conn != NULL) + { + PQfinish(entry->conn); + entry->conn = NULL; + } +} + /* * For non-superusers, insist that the connstr specify a password. This * prevents a password from being picked up from .pgpass, a service file, @@ -786,9 +824,7 @@ pgfdw_xact_callback(XactEvent event, void *arg) entry->changing_xact_state) { elog(DEBUG3, "discarding connection %p", entry->conn); - PQfinish(entry->conn); - entry->conn = NULL; - entry->changing_xact_state = false; + disconnect_pg_server(entry); } } @@ -905,6 +941,47 @@ pgfdw_subxact_callback(SubXactEvent event, SubTransactionId mySubid, } } +/* + * Connection invalidation callback function + * + * After a change to a pg_foreign_server or pg_user_mapping catalog entry, + * mark connections depending on that entry as needing to be remade. + * We can't immediately destroy them, since they might be in the midst of + * a transaction, but we'll remake them at the next opportunity. + * + * Although most cache invalidation callbacks blow away all the related stuff + * regardless of the given hashvalue, connections are expensive enough that + * it's worth trying to avoid that. + * + * NB: We could avoid unnecessary disconnection more strictly by examining + * individual option values, but it seems too much effort for the gain. + */ +static void +pgfdw_inval_callback(Datum arg, int cacheid, uint32 hashvalue) +{ + HASH_SEQ_STATUS scan; + ConnCacheEntry *entry; + + Assert(cacheid == FOREIGNSERVEROID || cacheid == USERMAPPINGOID); + + /* ConnectionHash must exist already, if we're registered */ + hash_seq_init(&scan, ConnectionHash); + while ((entry = (ConnCacheEntry *) hash_seq_search(&scan))) + { + /* Ignore invalid entries */ + if (entry->conn == NULL) + continue; + + /* hashvalue == 0 means a cache reset, must clear all state */ + if (hashvalue == 0 || + (cacheid == FOREIGNSERVEROID && + entry->server_hashvalue == hashvalue) || + (cacheid == USERMAPPINGOID && + entry->mapping_hashvalue == hashvalue)) + entry->invalidated = true; + } +} + /* * Raise an error if the given connection cache entry is marked as being * in the middle of an xact state change. This should be called at which no @@ -922,9 +999,14 @@ pgfdw_reject_incomplete_xact_state_change(ConnCacheEntry *entry) Form_pg_user_mapping umform; ForeignServer *server; - if (!entry->changing_xact_state) + /* nothing to do for inactive entries and entries of sane state */ + if (entry->conn == NULL || !entry->changing_xact_state) return; + /* make sure this entry is inactive */ + disconnect_pg_server(entry); + + /* find server name to be shown in the message below */ tup = SearchSysCache1(USERMAPPINGOID, ObjectIdGetDatum(entry->key)); if (!HeapTupleIsValid(tup)) diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out index eb6124cccd..00b2e53fa9 100644 --- a/contrib/postgres_fdw/expected/postgres_fdw.out +++ b/contrib/postgres_fdw/expected/postgres_fdw.out @@ -183,6 +183,43 @@ ALTER FOREIGN TABLE ft2 ALTER COLUMN c1 OPTIONS (column_name 'C 1'); public | ft6 | loopback2 | (schema_name 'S 1', table_name 'T 4') | (5 rows) +-- Test that alteration of server options causes reconnection +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work + c3 | c4 +-------+------------------------------ + 00001 | Fri Jan 02 00:00:00 1970 PST +(1 row) + +ALTER SERVER loopback OPTIONS (SET dbname 'no such database'); +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail +ERROR: could not connect to server "loopback" +DETAIL: FATAL: database "no such database" does not exist +DO $d$ + BEGIN + EXECUTE $$ALTER SERVER loopback + OPTIONS (SET dbname '$$||current_database()||$$')$$; + END; +$d$; +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work again + c3 | c4 +-------+------------------------------ + 00001 | Fri Jan 02 00:00:00 1970 PST +(1 row) + +-- Test that alteration of user mapping options causes reconnection +ALTER USER MAPPING FOR CURRENT_USER SERVER loopback + OPTIONS (ADD user 'no such user'); +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail +ERROR: could not connect to server "loopback" +DETAIL: FATAL: role "no such user" does not exist +ALTER USER MAPPING FOR CURRENT_USER SERVER loopback + OPTIONS (DROP user); +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work again + c3 | c4 +-------+------------------------------ + 00001 | Fri Jan 02 00:00:00 1970 PST +(1 row) + -- Now we should be able to run ANALYZE. -- To exercise multiple code paths, we use local stats on ft1 -- and remote-estimate mode on ft2. diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql index 176b3a32a8..920f6a3155 100644 --- a/contrib/postgres_fdw/sql/postgres_fdw.sql +++ b/contrib/postgres_fdw/sql/postgres_fdw.sql @@ -187,6 +187,26 @@ ALTER FOREIGN TABLE ft1 ALTER COLUMN c1 OPTIONS (column_name 'C 1'); ALTER FOREIGN TABLE ft2 ALTER COLUMN c1 OPTIONS (column_name 'C 1'); \det+ +-- Test that alteration of server options causes reconnection +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work +ALTER SERVER loopback OPTIONS (SET dbname 'no such database'); +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail +DO $d$ + BEGIN + EXECUTE $$ALTER SERVER loopback + OPTIONS (SET dbname '$$||current_database()||$$')$$; + END; +$d$; +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work again + +-- Test that alteration of user mapping options causes reconnection +ALTER USER MAPPING FOR CURRENT_USER SERVER loopback + OPTIONS (ADD user 'no such user'); +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail +ALTER USER MAPPING FOR CURRENT_USER SERVER loopback + OPTIONS (DROP user); +SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work again + -- Now we should be able to run ANALYZE. -- To exercise multiple code paths, we use local stats on ft1 -- and remote-estimate mode on ft2. From 0fe21602e27fab20845e2345691b5522edd53c02 Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Fri, 21 Jul 2017 12:48:22 -0400 Subject: [PATCH 0152/1139] pg_rewind: Fix busted sanity check. As written, the code would only fail the sanity check if none of the columns returned by the server were of the expected type, but we want it to fail if even one column is not of the expected type. Discussion: http://postgr.es/m/CA+TgmoYuY5zW7JEs+1hSS1D=V5K8h1SQuESrq=bMNeo0B71Sfw@mail.gmail.com --- src/bin/pg_rewind/libpq_fetch.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/bin/pg_rewind/libpq_fetch.c b/src/bin/pg_rewind/libpq_fetch.c index 5128e1c250..fdb4198154 100644 --- a/src/bin/pg_rewind/libpq_fetch.c +++ b/src/bin/pg_rewind/libpq_fetch.c @@ -270,8 +270,8 @@ receiveFileChunks(const char *sql) if (PQnfields(res) != 3 || PQntuples(res) != 1) pg_fatal("unexpected result set size while fetching remote files\n"); - if (PQftype(res, 0) != TEXTOID && - PQftype(res, 1) != INT4OID && + if (PQftype(res, 0) != TEXTOID || + PQftype(res, 1) != INT4OID || PQftype(res, 2) != BYTEAOID) { pg_fatal("unexpected data types in result set while fetching remote files: %u %u %u\n", From 0d503dd1ff316882ac4698d7ff1e0bf2a3222cfb Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 21 Jul 2017 14:20:43 -0400 Subject: [PATCH 0153/1139] Stabilize postgres_fdw regression tests. The new test cases added in commit 8bf58c0d9 turn out to have output that can vary depending on the lc_messages setting prevailing on the test server. Hide the remote end's error messages to ensure stable output. This isn't a terribly desirable solution; we'd rather know that the connection failed for the expected reason and not some other one. But there seems little choice for the moment. Per buildfarm. Discussion: https://postgr.es/m/18419.1500658570@sss.pgh.pa.us --- contrib/postgres_fdw/expected/postgres_fdw.out | 5 +++-- contrib/postgres_fdw/sql/postgres_fdw.sql | 3 +++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out index 00b2e53fa9..e9addade26 100644 --- a/contrib/postgres_fdw/expected/postgres_fdw.out +++ b/contrib/postgres_fdw/expected/postgres_fdw.out @@ -184,6 +184,8 @@ ALTER FOREIGN TABLE ft2 ALTER COLUMN c1 OPTIONS (column_name 'C 1'); (5 rows) -- Test that alteration of server options causes reconnection +-- Remote's errors might be non-English, so hide them to ensure stable results +\set VERBOSITY terse SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work c3 | c4 -------+------------------------------ @@ -193,7 +195,6 @@ SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work ALTER SERVER loopback OPTIONS (SET dbname 'no such database'); SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail ERROR: could not connect to server "loopback" -DETAIL: FATAL: database "no such database" does not exist DO $d$ BEGIN EXECUTE $$ALTER SERVER loopback @@ -211,7 +212,6 @@ ALTER USER MAPPING FOR CURRENT_USER SERVER loopback OPTIONS (ADD user 'no such user'); SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail ERROR: could not connect to server "loopback" -DETAIL: FATAL: role "no such user" does not exist ALTER USER MAPPING FOR CURRENT_USER SERVER loopback OPTIONS (DROP user); SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work again @@ -220,6 +220,7 @@ SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work again 00001 | Fri Jan 02 00:00:00 1970 PST (1 row) +\set VERBOSITY default -- Now we should be able to run ANALYZE. -- To exercise multiple code paths, we use local stats on ft1 -- and remote-estimate mode on ft2. diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql index 920f6a3155..a43115a35a 100644 --- a/contrib/postgres_fdw/sql/postgres_fdw.sql +++ b/contrib/postgres_fdw/sql/postgres_fdw.sql @@ -188,6 +188,8 @@ ALTER FOREIGN TABLE ft2 ALTER COLUMN c1 OPTIONS (column_name 'C 1'); \det+ -- Test that alteration of server options causes reconnection +-- Remote's errors might be non-English, so hide them to ensure stable results +\set VERBOSITY terse SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work ALTER SERVER loopback OPTIONS (SET dbname 'no such database'); SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail @@ -206,6 +208,7 @@ SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should fail ALTER USER MAPPING FOR CURRENT_USER SERVER loopback OPTIONS (DROP user); SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1; -- should work again +\set VERBOSITY default -- Now we should be able to run ANALYZE. -- To exercise multiple code paths, we use local stats on ft1 From afd56b8521c562f7ed20d04159aa597516d74bf5 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Mon, 17 Jul 2017 09:51:42 -0400 Subject: [PATCH 0154/1139] Fix typo in comment Commit fd31cd265138 renamed the variable to skipping_blocks, but forgot to update this comment. Noticed while inspecting code. --- src/backend/commands/vacuumlazy.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c index 7748b3986b..c5c194a7a6 100644 --- a/src/backend/commands/vacuumlazy.c +++ b/src/backend/commands/vacuumlazy.c @@ -633,8 +633,7 @@ lazy_scan_heap(Relation onerel, int options, LVRelStats *vacrelstats, /* * We know we can't skip the current block. But set up - * skipping_all_visible_blocks to do the right thing at the - * following blocks. + * skipping_blocks to do the right thing at the following blocks. */ if (next_unskippable_block - blkno > SKIP_PAGES_THRESHOLD) skipping_blocks = true; From 73fbf3d3d0a59d79f75a8202e03863fe462d052f Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Fri, 21 Jul 2017 14:25:36 -0400 Subject: [PATCH 0155/1139] pg_rewind: Fix some problems when copying files >2GB. When incrementally updating a file larger than 2GB, the old code could either fail outright (if the client asked the server for bytes beyond the 2GB boundary) or fail to copy all the blocks that had actually been modified (if the server reported a file size to the client in excess of 2GB), resulting in data corruption. Generally, such files won't occur anyway, but they might if using a non-default segment size or if there the directory contains stray files unrelated to PostgreSQL. Fix by a more prudent choice of data types. Even with these improvements, this code still uses a mix of different types (off_t, size_t, uint64, int64) to represent file sizes and offsets, not all of which necessarily have the same width or signedness, so further cleanup might be in order here. However, at least now they all have the potential to be 64 bits wide on 64-bit platforms. Kuntal Ghosh and Michael Paquier, with a tweak by me. Discussion: http://postgr.es/m/CAGz5QC+8gbkz=Brp0TgoKNqHWTzonbPtPex80U0O6Uh_bevbaA@mail.gmail.com --- src/bin/pg_rewind/libpq_fetch.c | 47 ++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 12 deletions(-) diff --git a/src/bin/pg_rewind/libpq_fetch.c b/src/bin/pg_rewind/libpq_fetch.c index fdb4198154..e90907bd38 100644 --- a/src/bin/pg_rewind/libpq_fetch.c +++ b/src/bin/pg_rewind/libpq_fetch.c @@ -195,7 +195,7 @@ libpqProcessFileList(void) for (i = 0; i < PQntuples(res); i++) { char *path = PQgetvalue(res, i, 0); - int filesize = atoi(PQgetvalue(res, i, 1)); + int64 filesize = atol(PQgetvalue(res, i, 1)); bool isdir = (strcmp(PQgetvalue(res, i, 2), "t") == 0); char *link_target = PQgetvalue(res, i, 3); file_type_t type; @@ -221,13 +221,35 @@ libpqProcessFileList(void) PQclear(res); } +/* + * Converts an int64 from network byte order to native format. + */ +static int64 +pg_recvint64(int64 value) +{ + union + { + int64 i64; + uint32 i32[2]; + } swap; + int64 result; + + swap.i64 = value; + + result = (uint32) ntohl(swap.i32[0]); + result <<= 32; + result |= (uint32) ntohl(swap.i32[1]); + + return result; +} + /*---- * Runs a query, which returns pieces of files from the remote source data * directory, and overwrites the corresponding parts of target files with * the received parts. The result set is expected to be of format: * * path text -- path in the data directory, e.g "base/1/123" - * begin int4 -- offset within the file + * begin int8 -- offset within the file * chunk bytea -- file content *---- */ @@ -248,7 +270,7 @@ receiveFileChunks(const char *sql) { char *filename; int filenamelen; - int chunkoff; + int64 chunkoff; int chunksize; char *chunk; @@ -271,7 +293,7 @@ receiveFileChunks(const char *sql) pg_fatal("unexpected result set size while fetching remote files\n"); if (PQftype(res, 0) != TEXTOID || - PQftype(res, 1) != INT4OID || + PQftype(res, 1) != INT8OID || PQftype(res, 2) != BYTEAOID) { pg_fatal("unexpected data types in result set while fetching remote files: %u %u %u\n", @@ -291,12 +313,12 @@ receiveFileChunks(const char *sql) pg_fatal("unexpected null values in result while fetching remote files\n"); } - if (PQgetlength(res, 0, 1) != sizeof(int32)) + if (PQgetlength(res, 0, 1) != sizeof(int64)) pg_fatal("unexpected result length while fetching remote files\n"); /* Read result set to local variables */ - memcpy(&chunkoff, PQgetvalue(res, 0, 1), sizeof(int32)); - chunkoff = ntohl(chunkoff); + memcpy(&chunkoff, PQgetvalue(res, 0, 1), sizeof(int64)); + chunkoff = pg_recvint64(chunkoff); chunksize = PQgetlength(res, 0, 2); filenamelen = PQgetlength(res, 0, 0); @@ -321,7 +343,7 @@ receiveFileChunks(const char *sql) continue; } - pg_log(PG_DEBUG, "received chunk for file \"%s\", offset %d, size %d\n", + pg_log(PG_DEBUG, "received chunk for file \"%s\", offset " INT64_FORMAT ", size %d\n", filename, chunkoff, chunksize); open_target_file(filename, false); @@ -381,7 +403,7 @@ libpqGetFile(const char *filename, size_t *filesize) * function to actually fetch the data. */ static void -fetch_file_range(const char *path, unsigned int begin, unsigned int end) +fetch_file_range(const char *path, uint64 begin, uint64 end) { char linebuf[MAXPGPATH + 23]; @@ -390,12 +412,13 @@ fetch_file_range(const char *path, unsigned int begin, unsigned int end) { unsigned int len; + /* Fine as long as CHUNKSIZE is not bigger than UINT32_MAX */ if (end - begin > CHUNKSIZE) len = CHUNKSIZE; else - len = end - begin; + len = (unsigned int) (end - begin); - snprintf(linebuf, sizeof(linebuf), "%s\t%u\t%u\n", path, begin, len); + snprintf(linebuf, sizeof(linebuf), "%s\t" UINT64_FORMAT "\t%u\n", path, begin, len); if (PQputCopyData(conn, linebuf, strlen(linebuf)) != 1) pg_fatal("could not send COPY data: %s", @@ -420,7 +443,7 @@ libpq_executeFileMap(filemap_t *map) * First create a temporary table, and load it with the blocks that we * need to fetch. */ - sql = "CREATE TEMPORARY TABLE fetchchunks(path text, begin int4, len int4);"; + sql = "CREATE TEMPORARY TABLE fetchchunks(path text, begin int8, len int4);"; res = PQexec(conn, sql); if (PQresultStatus(res) != PGRES_COMMAND_OK) From 82ebda7fffac8f4c796ef7d36d377bebca620528 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 22 Jul 2017 20:20:09 -0400 Subject: [PATCH 0156/1139] Fix pg_dump's handling of event triggers. pg_dump with the --clean option failed to emit DROP EVENT TRIGGER commands for event triggers. In a closely related oversight, it also did not emit ALTER OWNER commands for event triggers. Since only superusers can create event triggers, the latter oversight is of little practical consequence ... but if we're going to record an owner for event triggers, then surely pg_dump should preserve it. Per complaint from Greg Atkins. Back-patch to 9.3 where event triggers were introduced. Discussion: https://postgr.es/m/20170722191142.yi4e7tzcg3iacclg@gmail.com --- src/bin/pg_dump/pg_backup_archiver.c | 6 ++++-- src/bin/pg_dump/pg_dump.c | 14 ++++++++++++-- src/bin/pg_dump/t/002_pg_dump.pl | 16 ++++++++-------- 3 files changed, 24 insertions(+), 12 deletions(-) diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c index 6483563f3d..f2b544871e 100644 --- a/src/bin/pg_dump/pg_backup_archiver.c +++ b/src/bin/pg_dump/pg_backup_archiver.c @@ -3267,6 +3267,7 @@ _getObjectDescription(PQExpBuffer buf, TocEntry *te, ArchiveHandle *AH) strcmp(type, "DATABASE") == 0 || strcmp(type, "PROCEDURAL LANGUAGE") == 0 || strcmp(type, "SCHEMA") == 0 || + strcmp(type, "EVENT TRIGGER") == 0 || strcmp(type, "FOREIGN DATA WRAPPER") == 0 || strcmp(type, "SERVER") == 0 || strcmp(type, "USER MAPPING") == 0) @@ -3311,7 +3312,7 @@ _getObjectDescription(PQExpBuffer buf, TocEntry *te, ArchiveHandle *AH) return; } - write_msg(modulename, "WARNING: don't know how to set owner for object type %s\n", + write_msg(modulename, "WARNING: don't know how to set owner for object type \"%s\"\n", type); } @@ -3470,6 +3471,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData, bool acl_pass) strcmp(te->desc, "OPERATOR FAMILY") == 0 || strcmp(te->desc, "PROCEDURAL LANGUAGE") == 0 || strcmp(te->desc, "SCHEMA") == 0 || + strcmp(te->desc, "EVENT TRIGGER") == 0 || strcmp(te->desc, "TABLE") == 0 || strcmp(te->desc, "TYPE") == 0 || strcmp(te->desc, "VIEW") == 0 || @@ -3505,7 +3507,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData, bool acl_pass) } else { - write_msg(modulename, "WARNING: don't know how to set owner for object type %s\n", + write_msg(modulename, "WARNING: don't know how to set owner for object type \"%s\"\n", te->desc); } } diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index d1db3702be..479fd89e17 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -16978,6 +16978,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo) { DumpOptions *dopt = fout->dopt; PQExpBuffer query; + PQExpBuffer delqry; PQExpBuffer labelq; /* Skip if not to be dumped */ @@ -16985,6 +16986,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo) return; query = createPQExpBuffer(); + delqry = createPQExpBuffer(); labelq = createPQExpBuffer(); appendPQExpBufferStr(query, "CREATE EVENT TRIGGER "); @@ -17024,14 +17026,21 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo) } appendPQExpBufferStr(query, ";\n"); } + + appendPQExpBuffer(delqry, "DROP EVENT TRIGGER %s;\n", + fmtId(evtinfo->dobj.name)); + appendPQExpBuffer(labelq, "EVENT TRIGGER %s", fmtId(evtinfo->dobj.name)); if (evtinfo->dobj.dump & DUMP_COMPONENT_DEFINITION) ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId, - evtinfo->dobj.name, NULL, NULL, evtinfo->evtowner, false, + evtinfo->dobj.name, NULL, NULL, + evtinfo->evtowner, false, "EVENT TRIGGER", SECTION_POST_DATA, - query->data, "", NULL, NULL, 0, NULL, NULL); + query->data, delqry->data, NULL, + NULL, 0, + NULL, NULL); if (evtinfo->dobj.dump & DUMP_COMPONENT_COMMENT) dumpComment(fout, labelq->data, @@ -17039,6 +17048,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo) evtinfo->dobj.catId, 0, evtinfo->dobj.dumpId); destroyPQExpBuffer(query); + destroyPQExpBuffer(delqry); destroyPQExpBuffer(labelq); } diff --git a/src/bin/pg_dump/t/002_pg_dump.pl b/src/bin/pg_dump/t/002_pg_dump.pl index 1f8db16cf1..d5bfbc797c 100644 --- a/src/bin/pg_dump/t/002_pg_dump.pl +++ b/src/bin/pg_dump/t/002_pg_dump.pl @@ -516,18 +516,19 @@ only_dump_test_table => 1, test_schema_plus_blobs => 1, }, }, - # catch-all for ALTER ... OWNER (except LARGE OBJECTs) - 'ALTER ... OWNER commands (except LARGE OBJECTs)' => { - regexp => qr/^ALTER (?!LARGE OBJECT)(.*) OWNER TO .*;/m, + # catch-all for ALTER ... OWNER (except post-data objects) + 'ALTER ... OWNER commands (except post-data objects)' => { + regexp => qr/^ALTER (?!EVENT TRIGGER|LARGE OBJECT)(.*) OWNER TO .*;/m, like => {}, # use more-specific options above unlike => { column_inserts => 1, data_only => 1, - section_data => 1, }, }, + section_data => 1, + section_post_data => 1, }, }, - # catch-all for ALTER TABLE ... + # catch-all for ALTER TABLE ... (except OWNER TO) 'ALTER TABLE ... commands' => { - regexp => qr/^ALTER TABLE .*;/m, + regexp => qr/^ALTER TABLE .* (?!OWNER TO)(.*);/m, like => {}, # use more-specific options above unlike => { column_inserts => 1, @@ -543,8 +544,7 @@ unlike => { no_owner => 1, pg_dumpall_globals => 1, - pg_dumpall_globals_clean => 1, - section_post_data => 1, }, }, + pg_dumpall_globals_clean => 1, }, }, # 'BLOB load (contents are of test_table)' => { # create_order => 14, From bcc2c3b4572491fef845de30b0ed369f09635586 Mon Sep 17 00:00:00 2001 From: Noah Misch Date: Sun, 23 Jul 2017 23:53:27 -0700 Subject: [PATCH 0157/1139] MSVC: Accept tcl86.lib in addition to tcl86t.lib. ActiveTcl8.6.4.1.299124-win32-x86_64-threaded.exe ships just tcl86.lib. Back-patch to 9.2, like the commit recognizing tcl86t.lib. --- src/tools/msvc/Mkvcbuild.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/msvc/Mkvcbuild.pm b/src/tools/msvc/Mkvcbuild.pm index 57af0a0a95..6285aab2b6 100644 --- a/src/tools/msvc/Mkvcbuild.pm +++ b/src/tools/msvc/Mkvcbuild.pm @@ -200,7 +200,7 @@ sub mkvcbuild $pltcl->AddIncludeDir($solution->{options}->{tcl} . '/include'); $pltcl->AddReference($postgres); - for my $tclver (qw(86t 85 84)) + for my $tclver (qw(86t 86 85 84)) { my $tcllib = $solution->{options}->{tcl} . "/lib/tcl$tclver.lib"; if (-e $tcllib) From 3a07ba128581dac2f5e6b3eb0b568e2cb09dba33 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 24 Jul 2017 15:16:31 -0400 Subject: [PATCH 0158/1139] Ensure that pg_get_ruledef()'s output matches pg_get_viewdef()'s. Various cases involving renaming of view columns are handled by having make_viewdef pass down the view's current relation tupledesc to get_query_def, which then takes care to use the column names from the tupledesc for the output column names of the SELECT. For some reason though, we'd missed teaching make_ruledef to do similarly when it is printing an ON SELECT rule, even though this is exactly the same case. The results from pg_get_ruledef would then be different and arguably wrong. In particular, this breaks pre-v10 versions of pg_dump, which in some situations would define views by means of emitting a CREATE RULE ... ON SELECT command. Third-party tools might not be happy either. In passing, clean up some crufty code in make_viewdef; we'd apparently modernized the equivalent code in make_ruledef somewhere along the way, and missed this copy. Per report from Gilles Darold. Back-patch to all supported versions. Discussion: https://postgr.es/m/ec05659a-40ff-4510-fc45-ca9d965d0838@dalibo.com --- src/backend/utils/adt/ruleutils.c | 25 +++++++++++++++---- src/test/regress/expected/create_view.out | 29 +++++++++++++++++++++++ src/test/regress/sql/create_view.sql | 11 +++++++++ 3 files changed, 60 insertions(+), 5 deletions(-) diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index ea129c8212..416c333f3a 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -4220,6 +4220,8 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, char *ev_qual; char *ev_action; List *actions = NIL; + Relation ev_relation; + TupleDesc viewResultDesc = NULL; int fno; Datum dat; bool isnull; @@ -4256,6 +4258,8 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, if (ev_action != NULL) actions = (List *) stringToNode(ev_action); + ev_relation = heap_open(ev_class, AccessShareLock); + /* * Build the rules definition text */ @@ -4272,6 +4276,7 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, { case '1': appendStringInfoString(buf, "SELECT"); + viewResultDesc = RelationGetDescr(ev_relation); break; case '2': @@ -4361,7 +4366,7 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, foreach(action, actions) { query = (Query *) lfirst(action); - get_query_def(query, buf, NIL, NULL, + get_query_def(query, buf, NIL, viewResultDesc, prettyFlags, WRAP_COLUMN_DEFAULT, 0); if (prettyFlags) appendStringInfoString(buf, ";\n"); @@ -4379,10 +4384,12 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, Query *query; query = (Query *) linitial(actions); - get_query_def(query, buf, NIL, NULL, + get_query_def(query, buf, NIL, viewResultDesc, prettyFlags, WRAP_COLUMN_DEFAULT, 0); appendStringInfoChar(buf, ';'); } + + heap_close(ev_relation, AccessShareLock); } @@ -4404,20 +4411,28 @@ make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, List *actions = NIL; Relation ev_relation; int fno; + Datum dat; bool isnull; /* * Get the attribute values from the rules tuple */ fno = SPI_fnumber(rulettc, "ev_type"); - ev_type = (char) SPI_getbinval(ruletup, rulettc, fno, &isnull); + dat = SPI_getbinval(ruletup, rulettc, fno, &isnull); + Assert(!isnull); + ev_type = DatumGetChar(dat); fno = SPI_fnumber(rulettc, "ev_class"); - ev_class = (Oid) SPI_getbinval(ruletup, rulettc, fno, &isnull); + dat = SPI_getbinval(ruletup, rulettc, fno, &isnull); + Assert(!isnull); + ev_class = DatumGetObjectId(dat); fno = SPI_fnumber(rulettc, "is_instead"); - is_instead = (bool) SPI_getbinval(ruletup, rulettc, fno, &isnull); + dat = SPI_getbinval(ruletup, rulettc, fno, &isnull); + Assert(!isnull); + is_instead = DatumGetBool(dat); + /* these could be nulls */ fno = SPI_fnumber(rulettc, "ev_qual"); ev_qual = SPI_getvalue(ruletup, rulettc, fno); diff --git a/src/test/regress/expected/create_view.out b/src/test/regress/expected/create_view.out index bec0627650..e9a017fecb 100644 --- a/src/test/regress/expected/create_view.out +++ b/src/test/regress/expected/create_view.out @@ -1619,6 +1619,35 @@ select pg_get_viewdef('tt22v', true); LEFT JOIN tt6 ON TRUE; (1 row) +-- check handling of views with immediately-renamed columns +create view tt23v (col_a, col_b) as +select q1 as other_name1, q2 as other_name2 from int8_tbl +union +select 42, 43; +select pg_get_viewdef('tt23v', true); + pg_get_viewdef +------------------------------- + SELECT int8_tbl.q1 AS col_a,+ + int8_tbl.q2 AS col_b + + FROM int8_tbl + + UNION + + SELECT 42 AS col_a, + + 43 AS col_b; +(1 row) + +select pg_get_ruledef(oid, true) from pg_rewrite + where ev_class = 'tt23v'::regclass and ev_type = '1'; + pg_get_ruledef +----------------------------------------------------------------- + CREATE RULE "_RETURN" AS + + ON SELECT TO tt23v DO INSTEAD SELECT int8_tbl.q1 AS col_a,+ + int8_tbl.q2 AS col_b + + FROM int8_tbl + + UNION + + SELECT 42 AS col_a, + + 43 AS col_b; +(1 row) + -- clean up all the random objects we made above set client_min_messages = warning; DROP SCHEMA temp_view_test CASCADE; diff --git a/src/test/regress/sql/create_view.sql b/src/test/regress/sql/create_view.sql index 2246bade46..8a365749fc 100644 --- a/src/test/regress/sql/create_view.sql +++ b/src/test/regress/sql/create_view.sql @@ -541,6 +541,17 @@ create view tt22v as select * from tt5 natural left join tt6; select pg_get_viewdef('tt22v', true); +-- check handling of views with immediately-renamed columns + +create view tt23v (col_a, col_b) as +select q1 as other_name1, q2 as other_name2 from int8_tbl +union +select 42, 43; + +select pg_get_viewdef('tt23v', true); +select pg_get_ruledef(oid, true) from pg_rewrite + where ev_class = 'tt23v'::regclass and ev_type = '1'; + -- clean up all the random objects we made above set client_min_messages = warning; DROP SCHEMA temp_view_test CASCADE; From 971faefc240bf214076e529773c7ca690c5e053d Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Mon, 24 Jul 2017 15:57:24 -0400 Subject: [PATCH 0159/1139] When WCOs are present, disable direct foreign table modification. If the user modifies a view that has CHECK OPTIONs and this gets translated into a modification to an underlying relation which happens to be a foreign table, the check options should be enforced. In the normal code path, that was happening properly, but it was not working properly for "direct" modification because the whole operation gets pushed to the remote side in that case and we never have an option to enforce the constraint against individual tuples. Fix by disabling direct modification when there is a need to enforce CHECK OPTIONs. Etsuro Fujita, reviewed by Kyotaro Horiguchi and by me. Discussion: http://postgr.es/m/f8a48f54-6f02-9c8a-5250-9791603171ee@lab.ntt.co.jp --- .../postgres_fdw/expected/postgres_fdw.out | 60 +++++++++++++++++++ contrib/postgres_fdw/sql/postgres_fdw.sql | 24 ++++++++ doc/src/sgml/postgres-fdw.sgml | 6 +- src/backend/optimizer/plan/createplan.c | 7 ++- 4 files changed, 93 insertions(+), 4 deletions(-) diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out index e9addade26..20ea7c0308 100644 --- a/contrib/postgres_fdw/expected/postgres_fdw.out +++ b/contrib/postgres_fdw/expected/postgres_fdw.out @@ -4653,6 +4653,66 @@ INSERT INTO ft1(c1, c2) VALUES(1111, 2); UPDATE ft1 SET c2 = c2 + 1 WHERE c1 = 1; ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2negative; -- =================================================================== +-- test WITH CHECK OPTION constraints +-- =================================================================== +CREATE TABLE base_tbl (a int, b int); +CREATE FOREIGN TABLE foreign_tbl (a int, b int) + SERVER loopback OPTIONS(table_name 'base_tbl'); +CREATE VIEW rw_view AS SELECT * FROM foreign_tbl + WHERE a < b WITH CHECK OPTION; +\d+ rw_view + View "public.rw_view" + Column | Type | Modifiers | Storage | Description +--------+---------+-----------+---------+------------- + a | integer | | plain | + b | integer | | plain | +View definition: + SELECT foreign_tbl.a, + foreign_tbl.b + FROM foreign_tbl + WHERE foreign_tbl.a < foreign_tbl.b; +Options: check_option=cascaded + +INSERT INTO rw_view VALUES (0, 10); -- ok +INSERT INTO rw_view VALUES (10, 0); -- should fail +ERROR: new row violates check option for view "rw_view" +DETAIL: Failing row contains (10, 0). +EXPLAIN (VERBOSE, COSTS OFF) +UPDATE rw_view SET b = 20 WHERE a = 0; -- not pushed down + QUERY PLAN +-------------------------------------------------------------------------------------------------- + Update on public.foreign_tbl + Remote SQL: UPDATE public.base_tbl SET b = $2 WHERE ctid = $1 + -> Foreign Scan on public.foreign_tbl + Output: foreign_tbl.a, 20, foreign_tbl.ctid + Remote SQL: SELECT a, ctid FROM public.base_tbl WHERE ((a < b)) AND ((a = 0)) FOR UPDATE +(5 rows) + +UPDATE rw_view SET b = 20 WHERE a = 0; -- ok +EXPLAIN (VERBOSE, COSTS OFF) +UPDATE rw_view SET b = -20 WHERE a = 0; -- not pushed down + QUERY PLAN +-------------------------------------------------------------------------------------------------- + Update on public.foreign_tbl + Remote SQL: UPDATE public.base_tbl SET b = $2 WHERE ctid = $1 + -> Foreign Scan on public.foreign_tbl + Output: foreign_tbl.a, '-20'::integer, foreign_tbl.ctid + Remote SQL: SELECT a, ctid FROM public.base_tbl WHERE ((a < b)) AND ((a = 0)) FOR UPDATE +(5 rows) + +UPDATE rw_view SET b = -20 WHERE a = 0; -- should fail +ERROR: new row violates check option for view "rw_view" +DETAIL: Failing row contains (0, -20). +SELECT * FROM foreign_tbl; + a | b +---+---- + 0 | 20 +(1 row) + +DROP FOREIGN TABLE foreign_tbl CASCADE; +NOTICE: drop cascades to view rw_view +DROP TABLE base_tbl; +-- =================================================================== -- test serial columns (ie, sequence-based defaults) -- =================================================================== create table loc1 (f1 serial, f2 text); diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql index a43115a35a..525da8c95f 100644 --- a/contrib/postgres_fdw/sql/postgres_fdw.sql +++ b/contrib/postgres_fdw/sql/postgres_fdw.sql @@ -842,6 +842,30 @@ INSERT INTO ft1(c1, c2) VALUES(1111, 2); UPDATE ft1 SET c2 = c2 + 1 WHERE c1 = 1; ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2negative; +-- =================================================================== +-- test WITH CHECK OPTION constraints +-- =================================================================== + +CREATE TABLE base_tbl (a int, b int); +CREATE FOREIGN TABLE foreign_tbl (a int, b int) + SERVER loopback OPTIONS(table_name 'base_tbl'); +CREATE VIEW rw_view AS SELECT * FROM foreign_tbl + WHERE a < b WITH CHECK OPTION; +\d+ rw_view + +INSERT INTO rw_view VALUES (0, 10); -- ok +INSERT INTO rw_view VALUES (10, 0); -- should fail +EXPLAIN (VERBOSE, COSTS OFF) +UPDATE rw_view SET b = 20 WHERE a = 0; -- not pushed down +UPDATE rw_view SET b = 20 WHERE a = 0; -- ok +EXPLAIN (VERBOSE, COSTS OFF) +UPDATE rw_view SET b = -20 WHERE a = 0; -- not pushed down +UPDATE rw_view SET b = -20 WHERE a = 0; -- should fail +SELECT * FROM foreign_tbl; + +DROP FOREIGN TABLE foreign_tbl CASCADE; +DROP TABLE base_tbl; + -- =================================================================== -- test serial columns (ie, sequence-based defaults) -- =================================================================== diff --git a/doc/src/sgml/postgres-fdw.sgml b/doc/src/sgml/postgres-fdw.sgml index b31f3731e4..a6c56d1f63 100644 --- a/doc/src/sgml/postgres-fdw.sgml +++ b/doc/src/sgml/postgres-fdw.sgml @@ -488,8 +488,10 @@ postgres_fdw attempts to optimize the query execution by sending the whole query to the remote server if there are no query WHERE clauses that cannot be sent to the remote server, - no local joins for the query, and no row-level local BEFORE or - AFTER triggers on the target table. In UPDATE, + no local joins for the query, no row-level local BEFORE or + AFTER triggers on the target table, and no + CHECK OPTION constraints from parent views. + In UPDATE, expressions to assign to target columns must use only built-in data types, IMMUTABLE operators, or IMMUTABLE functions, to reduce the risk of misexecution of the query. diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index 6f1166b703..e230329a45 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -6145,8 +6145,10 @@ make_modifytable(PlannerInfo *root, } /* - * If the target foreign table has any row-level triggers, we can't - * modify the foreign table directly. + * Try to modify the foreign table directly if (1) the FDW provides + * callback functions needed for that, (2) there are no row-level + * triggers on the foreign table, and (3) there are no WITH CHECK + * OPTIONs from parent views. */ direct_modify = false; if (fdwroutine != NULL && @@ -6154,6 +6156,7 @@ make_modifytable(PlannerInfo *root, fdwroutine->BeginDirectModify != NULL && fdwroutine->IterateDirectModify != NULL && fdwroutine->EndDirectModify != NULL && + withCheckOptionLists == NIL && !has_row_triggers(root, rti, operation)) direct_modify = fdwroutine->PlanDirectModify(root, node, rti, i); if (direct_modify) From 51865a0a01417448c5211ab99c1e721b503c3570 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 24 Jul 2017 16:45:46 -0400 Subject: [PATCH 0160/1139] Fix race condition in predicate-lock init code in EXEC_BACKEND builds. Trading a little too heavily on letting the code path be the same whether we were creating shared data structures or only attaching to them, InitPredicateLocks() inserted the "scratch" PredicateLockTargetHash entry unconditionally. This is just wrong if we're in a postmaster child, which would only reach this code in EXEC_BACKEND builds. Most of the time, the hash_search(HASH_ENTER) call would simply report that the entry already existed, causing no visible effect since the code did not bother to check for that possibility. However, if this happened while some other backend had transiently removed the "scratch" entry, then that other backend's eventual RestoreScratchTarget would suffer an assert failure; this appears to be the explanation for a recent failure on buildfarm member culicidae. In non-assert builds, there would be no visible consequences there either. But nonetheless this is a pretty bad bug for EXEC_BACKEND builds, for two reasons: 1. Each new backend would perform the hash_search(HASH_ENTER) call without holding any lock that would prevent concurrent access to the PredicateLockTargetHash hash table. This creates a low but certainly nonzero risk of corruption of that hash table. 2. In the event that the race condition occurred, by reinserting the scratch entry too soon, we were defeating the entire purpose of the scratch entry, namely to guarantee that transaction commit could move hash table entries around with no risk of out-of-memory failure. The odds of an actual OOM failure are quite low, but not zero, and if it did happen it would again result in corruption of the hash table. The user-visible symptoms of such corruption are a little hard to predict, but would presumably amount to misbehavior of SERIALIZABLE transactions that'd require a crash or postmaster restart to fix. To fix, just skip the hash insertion if IsUnderPostmaster. I also inserted a bunch of assertions that the expected things happen depending on whether IsUnderPostmaster is true. That might be overkill, since most comparable code in other functions isn't quite that paranoid, but once burnt twice shy. In passing, also move a couple of lines to places where they seemed to make more sense. Diagnosis of problem by Thomas Munro, patch by me. Back-patch to all supported branches. Discussion: https://postgr.es/m/10593.1500670709@sss.pgh.pa.us --- src/backend/storage/lmgr/predicate.c | 29 ++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c index ceb2695a25..cc837ea087 100644 --- a/src/backend/storage/lmgr/predicate.c +++ b/src/backend/storage/lmgr/predicate.c @@ -806,6 +806,7 @@ OldSerXidInit(void) oldSerXidControl = (OldSerXidControl) ShmemInitStruct("OldSerXidControlData", sizeof(OldSerXidControlData), &found); + Assert(found == IsUnderPostmaster); if (!found) { /* @@ -1100,6 +1101,10 @@ InitPredicateLocks(void) Size requestSize; bool found; +#ifndef EXEC_BACKEND + Assert(!IsUnderPostmaster); +#endif + /* * Compute size of predicate lock target hashtable. Note these * calculations must agree with PredicateLockShmemSize! @@ -1122,16 +1127,22 @@ InitPredicateLocks(void) HASH_ELEM | HASH_BLOBS | HASH_PARTITION | HASH_FIXED_SIZE); - /* Assume an average of 2 xacts per target */ - max_table_size *= 2; - /* * Reserve a dummy entry in the hash table; we use it to make sure there's * always one entry available when we need to split or combine a page, * because running out of space there could mean aborting a * non-serializable transaction. */ - hash_search(PredicateLockTargetHash, &ScratchTargetTag, HASH_ENTER, NULL); + if (!IsUnderPostmaster) + { + (void) hash_search(PredicateLockTargetHash, &ScratchTargetTag, + HASH_ENTER, &found); + Assert(!found); + } + + /* Pre-calculate the hash and partition lock of the scratch entry */ + ScratchTargetTagHash = PredicateLockTargetTagHashCode(&ScratchTargetTag); + ScratchPartitionLock = PredicateLockHashPartitionLock(ScratchTargetTagHash); /* * Allocate hash table for PREDICATELOCK structs. This stores per @@ -1143,6 +1154,9 @@ InitPredicateLocks(void) info.hash = predicatelock_hash; info.num_partitions = NUM_PREDICATELOCK_PARTITIONS; + /* Assume an average of 2 xacts per target */ + max_table_size *= 2; + PredicateLockHash = ShmemInitHash("PREDICATELOCK hash", max_table_size, max_table_size, @@ -1169,6 +1183,7 @@ InitPredicateLocks(void) PredXact = ShmemInitStruct("PredXactList", PredXactListDataSize, &found); + Assert(found == IsUnderPostmaster); if (!found) { int i; @@ -1247,6 +1262,7 @@ InitPredicateLocks(void) RWConflictPool = ShmemInitStruct("RWConflictPool", RWConflictPoolHeaderDataSize, &found); + Assert(found == IsUnderPostmaster); if (!found) { int i; @@ -1278,6 +1294,7 @@ InitPredicateLocks(void) ShmemInitStruct("FinishedSerializableTransactions", sizeof(SHM_QUEUE), &found); + Assert(found == IsUnderPostmaster); if (!found) SHMQueueInit(FinishedSerializableTransactions); @@ -1286,10 +1303,6 @@ InitPredicateLocks(void) * transactions. */ OldSerXidInit(); - - /* Pre-calculate the hash and partition lock of the scratch entry */ - ScratchTargetTagHash = PredicateLockTargetTagHashCode(&ScratchTargetTag); - ScratchPartitionLock = PredicateLockHashPartitionLock(ScratchTargetTagHash); } /* From 3b7bbee7b661536713df3f6c93a8f446bdbfd0ae Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Tue, 25 Jul 2017 18:39:44 -0400 Subject: [PATCH 0161/1139] Make PostgresNode easily subclassable This module becomes much more useful if we allow it to be used as base class for external projects. To achieve this, change the exported get_new_node function into a class method instead, and use the standard Perl idiom of accepting the class as first argument. This method works as expected for subclasses. The standalone function is kept for backwards compatibility, though it could be removed in pg11. Author: Chap Flackman, based on an earlier patch from Craig Ringer Discussion: https://postgr.es/m/CAMsr+YF8kO+4+K-_U4PtN==2FndJ+5Bn6A19XHhMiBykEwv0wA@mail.gmail.com --- src/test/perl/PostgresNode.pm | 20 ++++++++++++-------- src/test/perl/README | 2 +- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm index 711d0deae8..8ec843edea 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgresNode.pm @@ -9,7 +9,7 @@ PostgresNode - class representing PostgreSQL server instance use PostgresNode; - my $node = get_new_node('mynode'); + my $node = PostgresNode->get_new_node('mynode'); # Create a data directory with initdb $node->init(); @@ -845,20 +845,24 @@ sub _update_pid =pod -=item get_new_node(node_name) +=item PostgresNode->get_new_node(node_name) -Build a new PostgresNode object, assigning a free port number. Standalone -function that's automatically imported. +Build a new object of class C (or of a subclass, if you have +one), assigning a free port number. Remembers the node, to prevent its port +number from being reused for another node, and to ensure that it gets +shut down when the test script exits. -Remembers the node, to prevent its port number from being reused for another -node, and to ensure that it gets shut down when the test script exits. +You should generally use this instead of C. -You should generally use this instead of PostgresNode::new(...). +For backwards compatibility, it is also exported as a standalone function, +which can only create objects of class C. =cut sub get_new_node { + my $class = 'PostgresNode'; + $class = shift if 1 < scalar @_; my $name = shift; my $found = 0; my $port = $last_port_assigned; @@ -903,7 +907,7 @@ sub get_new_node print "# Found free port $port\n"; # Lock port number found by creating a new node - my $node = new PostgresNode($name, $test_pghost, $port); + my $node = $class->new($name, $test_pghost, $port); # Add node to list of nodes push(@all_nodes, $node); diff --git a/src/test/perl/README b/src/test/perl/README index 4279d316c4..cbee418e14 100644 --- a/src/test/perl/README +++ b/src/test/perl/README @@ -42,7 +42,7 @@ Each test script should begin with: then it will generally need to set up one or more nodes, run commands against them and evaluate the results. For example: - my $node = get_new_node('master'); + my $node = PostgresNode->get_new_node('master'); $node->init; $node->start; From 8c348765f95e97a9a7774467c744a33da21206fd Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Wed, 26 Jul 2017 17:24:16 -0400 Subject: [PATCH 0162/1139] Fix concurrent locking of tuple update chain If several sessions are concurrently locking a tuple update chain with nonconflicting lock modes using an old snapshot, and they all succeed, it may happen that some of them fail because of restarting the loop (due to a concurrent Xmax change) and getting an error in the subsequent pass while trying to obtain a tuple lock that they already have in some tuple version. This can only happen with very high concurrency (where a row is being both updated and FK-checked by multiple transactions concurrently), but it's been observed in the field and can have unpleasant consequences such as an FK check failing to see a tuple that definitely exists: ERROR: insert or update on table "child_table" violates foreign key constraint "fk_constraint_name" DETAIL: Key (keyid)=(123456) is not present in table "parent_table". (where the key is observably present in the table). Discussion: https://postgr.es/m/20170714210011.r25mrff4nxjhmf3g@alvherre.pgsql --- src/backend/access/heap/heapam.c | 41 ++++++++++++++++++++++++++++---- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index dc93b1e881..84b59c3410 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -5550,8 +5550,10 @@ compute_new_xmax_infomask(TransactionId xmax, uint16 old_infomask, * with the given xid, does the current transaction need to wait, fail, or can * it continue if it wanted to acquire a lock of the given mode? "needwait" * is set to true if waiting is necessary; if it can continue, then - * HeapTupleMayBeUpdated is returned. In case of a conflict, a different - * HeapTupleSatisfiesUpdate return code is returned. + * HeapTupleMayBeUpdated is returned. If the lock is already held by the + * current transaction, return HeapTupleSelfUpdated. In case of a conflict + * with another transaction, a different HeapTupleSatisfiesUpdate return code + * is returned. * * The held status is said to be hypothetical because it might correspond to a * lock held by a single Xid, i.e. not a real MultiXactId; we express it this @@ -5574,8 +5576,9 @@ test_lockmode_for_conflict(MultiXactStatus status, TransactionId xid, if (TransactionIdIsCurrentTransactionId(xid)) { /* - * Updated by our own transaction? Just return failure. This - * shouldn't normally happen. + * The tuple has already been locked by our own transaction. This is + * very rare but can happen if multiple transactions are trying to + * lock an ancient version of the same tuple. */ return HeapTupleSelfUpdated; } @@ -5774,6 +5777,22 @@ heap_lock_updated_tuple_rec(Relation rel, ItemPointer tid, TransactionId xid, members[i].xid, mode, &needwait); + /* + * If the tuple was already locked by ourselves in a + * previous iteration of this (say heap_lock_tuple was + * forced to restart the locking loop because of a change + * in xmax), then we hold the lock already on this tuple + * version and we don't need to do anything; and this is + * not an error condition either. We just need to skip + * this tuple and continue locking the next version in the + * update chain. + */ + if (result == HeapTupleSelfUpdated) + { + pfree(members); + goto next; + } + if (needwait) { LockBuffer(buf, BUFFER_LOCK_UNLOCK); @@ -5834,6 +5853,19 @@ heap_lock_updated_tuple_rec(Relation rel, ItemPointer tid, TransactionId xid, result = test_lockmode_for_conflict(status, rawxmax, mode, &needwait); + + /* + * If the tuple was already locked by ourselves in a previous + * iteration of this (say heap_lock_tuple was forced to + * restart the locking loop because of a change in xmax), then + * we hold the lock already on this tuple version and we don't + * need to do anything; and this is not an error condition + * either. We just need to skip this tuple and continue + * locking the next version in the update chain. + */ + if (result == HeapTupleSelfUpdated) + goto next; + if (needwait) { LockBuffer(buf, BUFFER_LOCK_UNLOCK); @@ -5894,6 +5926,7 @@ heap_lock_updated_tuple_rec(Relation rel, ItemPointer tid, TransactionId xid, END_CRIT_SECTION(); +next: /* if we find the end of update chain, we're done. */ if (mytup.t_data->t_infomask & HEAP_XMAX_INVALID || ItemPointerEquals(&mytup.t_self, &mytup.t_data->t_ctid) || From a2fc3431c35504c022d9e1671d228f734eddcbcf Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 26 Jul 2017 19:35:35 -0400 Subject: [PATCH 0163/1139] Clean up SQL emitted by psql/describe.c. Fix assorted places that had not bothered with the convention of prefixing catalog and function names with "pg_catalog.". That could possibly result in query failure when running with a nondefault search_path. Also fix two places that weren't quoting OID literals. I think the latter hasn't mattered much since about 7.3, but it's still a bad idea to be doing it in 99 places and not in 2 others. Also remove a useless EXISTS sub-select that someone had stuck into describeOneTableDetails' queries for child tables. We just got the OID out of pg_class, so I hardly see how checking that it exists in pg_class was doing anything helpful. In passing, try to improve the emitted formatting of a couple of these queries, though I didn't work really hard on that. And merge unnecessarily duplicative coding in some other places. Much of this was new in HEAD, but some was quite old; back-patch as appropriate. --- src/bin/psql/describe.c | 68 ++++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c index 6b1436cdbd..8f4008183d 100644 --- a/src/bin/psql/describe.c +++ b/src/bin/psql/describe.c @@ -1553,8 +1553,8 @@ describeOneTableDetails(const char *schemaname, appendPQExpBufferStr(&buf, ",\n NULL AS indexdef"); if (tableinfo.relkind == 'f' && pset.sversion >= 90200) appendPQExpBufferStr(&buf, ",\n CASE WHEN attfdwoptions IS NULL THEN '' ELSE " - " '(' || array_to_string(ARRAY(SELECT quote_ident(option_name) || ' ' || quote_literal(option_value) FROM " - " pg_options_to_table(attfdwoptions)), ', ') || ')' END AS attfdwoptions"); + " '(' || pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value) FROM " + " pg_catalog.pg_options_to_table(attfdwoptions)), ', ') || ')' END AS attfdwoptions"); else appendPQExpBufferStr(&buf, ",\n NULL AS attfdwoptions"); if (verbose) @@ -1904,7 +1904,7 @@ describeOneTableDetails(const char *schemaname, "\n a.attnum=d.refobjsubid)" "\nWHERE d.classid='pg_catalog.pg_class'::pg_catalog.regclass" "\n AND d.refclassid='pg_catalog.pg_class'::pg_catalog.regclass" - "\n AND d.objid=%s" + "\n AND d.objid='%s'" "\n AND d.deptype='a'", oid); @@ -2138,7 +2138,7 @@ describeOneTableDetails(const char *schemaname, { printfPQExpBuffer(&buf, "SELECT pol.polname,\n" - "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE array_to_string(array(select rolname from pg_roles where oid = any (pol.polroles) order by 1),',') END,\n" + "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE pg_catalog.array_to_string(array(select rolname from pg_catalog.pg_roles where oid = any (pol.polroles) order by 1),',') END,\n" "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid),\n" "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid),\n" "CASE pol.polcmd \n" @@ -2498,13 +2498,13 @@ describeOneTableDetails(const char *schemaname, /* Footer information about foreign table */ printfPQExpBuffer(&buf, "SELECT s.srvname,\n" - " array_to_string(ARRAY(SELECT " - " quote_ident(option_name) || ' ' || " - " quote_literal(option_value) FROM " - " pg_options_to_table(ftoptions)), ', ') " + " pg_catalog.array_to_string(ARRAY(\n" + " SELECT pg_catalog.quote_ident(option_name)" + " || ' ' || pg_catalog.quote_literal(option_value)\n" + " FROM pg_catalog.pg_options_to_table(ftoptions)), ', ')\n" "FROM pg_catalog.pg_foreign_table f,\n" " pg_catalog.pg_foreign_server s\n" - "WHERE f.ftrelid = %s AND s.oid = f.ftserver;", + "WHERE f.ftrelid = '%s' AND s.oid = f.ftserver;", oid); result = PSQLexec(buf.data); if (!result) @@ -2935,16 +2935,16 @@ listDbRoleSettings(const char *pattern, const char *pattern2) printfPQExpBuffer(&buf, "SELECT rolname AS \"%s\", datname AS \"%s\",\n" "pg_catalog.array_to_string(setconfig, E'\\n') AS \"%s\"\n" - "FROM pg_db_role_setting AS s\n" - "LEFT JOIN pg_database ON pg_database.oid = setdatabase\n" - "LEFT JOIN pg_roles ON pg_roles.oid = setrole\n", + "FROM pg_catalog.pg_db_role_setting s\n" + "LEFT JOIN pg_catalog.pg_database d ON d.oid = setdatabase\n" + "LEFT JOIN pg_catalog.pg_roles r ON r.oid = setrole\n", gettext_noop("Role"), gettext_noop("Database"), gettext_noop("Settings")); havewhere = processSQLNamePattern(pset.db, &buf, pattern, false, false, - NULL, "pg_roles.rolname", NULL, NULL); + NULL, "r.rolname", NULL, NULL); processSQLNamePattern(pset.db, &buf, pattern2, havewhere, false, - NULL, "pg_database.datname", NULL, NULL); + NULL, "d.datname", NULL, NULL); appendPQExpBufferStr(&buf, "ORDER BY 1, 2;"); } else @@ -3173,13 +3173,13 @@ listLanguages(const char *pattern, bool verbose, bool showSystem) { appendPQExpBuffer(&buf, ",\n NOT l.lanispl AS \"%s\",\n" - " l.lanplcallfoid::regprocedure AS \"%s\",\n" - " l.lanvalidator::regprocedure AS \"%s\",\n ", + " l.lanplcallfoid::pg_catalog.regprocedure AS \"%s\",\n" + " l.lanvalidator::pg_catalog.regprocedure AS \"%s\",\n ", gettext_noop("Internal Language"), gettext_noop("Call Handler"), gettext_noop("Validator")); if (pset.sversion >= 90000) - appendPQExpBuffer(&buf, "l.laninline::regprocedure AS \"%s\",\n ", + appendPQExpBuffer(&buf, "l.laninline::pg_catalog.regprocedure AS \"%s\",\n ", gettext_noop("Inline Handler")); printACLColumn(&buf, "l.lanacl"); } @@ -4304,10 +4304,10 @@ listForeignDataWrappers(const char *pattern, bool verbose) printACLColumn(&buf, "fdwacl"); appendPQExpBuffer(&buf, ",\n CASE WHEN fdwoptions IS NULL THEN '' ELSE " - " '(' || array_to_string(ARRAY(SELECT " - " quote_ident(option_name) || ' ' || " - " quote_literal(option_value) FROM " - " pg_options_to_table(fdwoptions)), ', ') || ')' " + " '(' || pg_catalog.array_to_string(ARRAY(SELECT " + " pg_catalog.quote_ident(option_name) || ' ' || " + " pg_catalog.quote_literal(option_value) FROM " + " pg_catalog.pg_options_to_table(fdwoptions)), ', ') || ')' " " END AS \"%s\"", gettext_noop("FDW Options")); @@ -4385,10 +4385,10 @@ listForeignServers(const char *pattern, bool verbose) " s.srvtype AS \"%s\",\n" " s.srvversion AS \"%s\",\n" " CASE WHEN srvoptions IS NULL THEN '' ELSE " - " '(' || array_to_string(ARRAY(SELECT " - " quote_ident(option_name) || ' ' || " - " quote_literal(option_value) FROM " - " pg_options_to_table(srvoptions)), ', ') || ')' " + " '(' || pg_catalog.array_to_string(ARRAY(SELECT " + " pg_catalog.quote_ident(option_name) || ' ' || " + " pg_catalog.quote_literal(option_value) FROM " + " pg_catalog.pg_options_to_table(srvoptions)), ', ') || ')' " " END AS \"%s\",\n" " d.description AS \"%s\"", gettext_noop("Type"), @@ -4403,7 +4403,7 @@ listForeignServers(const char *pattern, bool verbose) if (verbose) appendPQExpBufferStr(&buf, - "LEFT JOIN pg_description d\n " + "LEFT JOIN pg_catalog.pg_description d\n " "ON d.classoid = s.tableoid AND d.objoid = s.oid " "AND d.objsubid = 0\n"); @@ -4459,10 +4459,10 @@ listUserMappings(const char *pattern, bool verbose) if (verbose) appendPQExpBuffer(&buf, ",\n CASE WHEN umoptions IS NULL THEN '' ELSE " - " '(' || array_to_string(ARRAY(SELECT " - " quote_ident(option_name) || ' ' || " - " quote_literal(option_value) FROM " - " pg_options_to_table(umoptions)), ', ') || ')' " + " '(' || pg_catalog.array_to_string(ARRAY(SELECT " + " pg_catalog.quote_ident(option_name) || ' ' || " + " pg_catalog.quote_literal(option_value) FROM " + " pg_catalog.pg_options_to_table(umoptions)), ', ') || ')' " " END AS \"%s\"", gettext_noop("FDW Options")); @@ -4522,10 +4522,10 @@ listForeignTables(const char *pattern, bool verbose) if (verbose) appendPQExpBuffer(&buf, ",\n CASE WHEN ftoptions IS NULL THEN '' ELSE " - " '(' || array_to_string(ARRAY(SELECT " - " quote_ident(option_name) || ' ' || " - " quote_literal(option_value) FROM " - " pg_options_to_table(ftoptions)), ', ') || ')' " + " '(' || pg_catalog.array_to_string(ARRAY(SELECT " + " pg_catalog.quote_ident(option_name) || ' ' || " + " pg_catalog.quote_literal(option_value) FROM " + " pg_catalog.pg_options_to_table(ftoptions)), ', ') || ')' " " END AS \"%s\",\n" " d.description AS \"%s\"", gettext_noop("FDW Options"), From 157adfdf4adc83c2779de234a415eeb4d1bbb38c Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 27 Jul 2017 14:13:15 -0400 Subject: [PATCH 0164/1139] Fix psql tab completion for CREATE USER MAPPING. After typing CREATE USER M..., it would not fill in MAPPING FOR, even though that was clearly intended behavior. Jeff Janes Discussion: https://postgr.es/m/CAMkU=1wo2iQ6jWnN=egqOb5NxEPn0PpANEtKHr3uPooQ+nYPtw@mail.gmail.com --- src/bin/psql/tab-complete.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c index b5d49ea40d..90d950b236 100644 --- a/src/bin/psql/tab-complete.c +++ b/src/bin/psql/tab-complete.c @@ -921,7 +921,7 @@ static const pgsql_thing_t words_after_create[] = { {"UNIQUE", NULL, NULL, THING_NO_DROP}, /* for CREATE UNIQUE INDEX ... */ {"UNLOGGED", NULL, NULL, THING_NO_DROP}, /* for CREATE UNLOGGED TABLE * ... */ - {"USER", Query_for_list_of_roles}, + {"USER", Query_for_list_of_roles " UNION SELECT 'MAPPING FOR'"}, {"USER MAPPING FOR", NULL, NULL}, {"VIEW", NULL, &Query_for_list_of_views}, {NULL} /* end of list */ From bb19bcd426769a568f3ed4025430af1573386322 Mon Sep 17 00:00:00 2001 From: Tatsuo Ishii Date: Mon, 31 Jul 2017 11:06:37 +0900 Subject: [PATCH 0165/1139] Add missing comment in postgresql.conf. dynamic_shared_memory_type requires to restart server to reflect the new value. Per Yugo Nagata and Masahiko Sawada. Back pached to 9.4 and beyond. --- src/backend/utils/misc/postgresql.conf.sample | 1 + 1 file changed, 1 insertion(+) diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample index fa6c0eaa80..f2cb7de03f 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -131,6 +131,7 @@ # windows # mmap # use none to disable dynamic shared memory + # (change requires restart) # - Disk - From bc37d2460f8e39170f72a064450281ef0f50822e Mon Sep 17 00:00:00 2001 From: Tatsuo Ishii Date: Mon, 31 Jul 2017 11:24:51 +0900 Subject: [PATCH 0166/1139] Add missing comment in postgresql.conf. current_source requires to restart server to reflect the new value. Per Yugo Nagata and Masahiko Sawada. Back patched to 9.2 and beyond. --- src/backend/utils/misc/postgresql.conf.sample | 1 + 1 file changed, 1 insertion(+) diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample index f2cb7de03f..9a999c9359 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -368,6 +368,7 @@ #syslog_split_messages = on # This is only relevant when logging to eventlog (win32): +# (change requires restart) #event_source = 'PostgreSQL' # - When to Log - From d38e706ff149eb0937502cc0be27645e70bbfec6 Mon Sep 17 00:00:00 2001 From: Stephen Frost Date: Mon, 31 Jul 2017 10:37:12 -0400 Subject: [PATCH 0167/1139] Fix function comment for dumpACL() The comment for dumpACL() got neglected when initacls and initracls were added and the discussion of what 'racls' is wasn't very clear either. Per complaint from Tom. --- src/bin/pg_dump/pg_dump.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 479fd89e17..104a9f14d8 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -14759,10 +14759,20 @@ dumpDefaultACL(Archive *fout, DefaultACLInfo *daclinfo) * 'tag' is the tag for the archive entry (typ. unquoted name of object). * 'nspname' is the namespace the object is in (NULL if none). * 'owner' is the owner, NULL if there is no owner (for languages). - * 'acls' is the string read out of the fooacl system catalog field; - * it will be parsed here. - * 'racls' contains any initial ACLs that the object had which have now been - * revoked by the user, it will also be parsed here. + * 'acls' contains the ACL string of the object from the appropriate system + * catalog field; it will be passed to buildACLCommands for building the + * appropriate GRANT commands. + * 'racls' contains the ACL string of any initial-but-now-revoked ACLs of the + * object; it will be passed to buildACLCommands for building the + * appropriate REVOKE commands. + * 'initacls' In binary-upgrade mode, ACL string of the object's initial + * privileges, to be recorded into pg_init_privs + * 'initracls' In binary-upgrade mode, ACL string of the object's + * revoked-from-default privileges, to be recorded into pg_init_privs + * + * NB: initacls/initracls are needed because extensions can set privileges on + * an object during the extension's script file and we record those into + * pg_init_privs as that object's initial privileges. *---------- */ static void From 30a5c8bfbd7bec07385c7d40305b06385d700b3f Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 31 Jul 2017 12:10:36 -0400 Subject: [PATCH 0168/1139] PL/Perl portability fix: avoid including XSUB.h in plperl.c. Back-patch of commit bebe174bb4462ef079a1d7eeafb82ff969f160a4, which see for more info. Patch by me, with some help from Ashutosh Sharma Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com --- contrib/hstore_plperl/hstore_plperl.c | 6 +- src/pl/plperl/SPI.xs | 32 +--- src/pl/plperl/Util.xs | 44 +---- src/pl/plperl/plperl.c | 244 +++++++++++++++++++------- src/pl/plperl/plperl.h | 17 +- src/pl/plperl/plperl_helpers.h | 4 + 6 files changed, 210 insertions(+), 137 deletions(-) diff --git a/contrib/hstore_plperl/hstore_plperl.c b/contrib/hstore_plperl/hstore_plperl.c index d40a792730..e5303b3b92 100644 --- a/contrib/hstore_plperl/hstore_plperl.c +++ b/contrib/hstore_plperl/hstore_plperl.c @@ -13,6 +13,7 @@ PG_FUNCTION_INFO_V1(hstore_to_plperl); Datum hstore_to_plperl(PG_FUNCTION_ARGS) { + dTHX; HStore *in = PG_GETARG_HS(0); int i; int count = HS_COUNT(in); @@ -45,7 +46,8 @@ PG_FUNCTION_INFO_V1(plperl_to_hstore); Datum plperl_to_hstore(PG_FUNCTION_ARGS) { - HV *hv; + dTHX; + HV *hv = (HV *) SvRV((SV *) PG_GETARG_POINTER(0)); HE *he; int32 buflen; int32 i; @@ -53,8 +55,6 @@ plperl_to_hstore(PG_FUNCTION_ARGS) HStore *out; Pairs *pairs; - hv = (HV *) SvRV((SV *) PG_GETARG_POINTER(0)); - pcount = hv_iterinit(hv); pairs = palloc(pcount * sizeof(Pairs)); diff --git a/src/pl/plperl/SPI.xs b/src/pl/plperl/SPI.xs index 0447c50df1..d9e6f579d4 100644 --- a/src/pl/plperl/SPI.xs +++ b/src/pl/plperl/SPI.xs @@ -9,44 +9,16 @@ /* this must be first: */ #include "postgres.h" -#include "mb/pg_wchar.h" /* for GetDatabaseEncoding */ /* Defined by Perl */ #undef _ /* perl stuff */ +#define PG_NEED_PERL_XSUB_H #include "plperl.h" #include "plperl_helpers.h" -/* - * Interface routine to catch ereports and punt them to Perl - */ -static void -do_plperl_return_next(SV *sv) -{ - MemoryContext oldcontext = CurrentMemoryContext; - - PG_TRY(); - { - plperl_return_next(sv); - } - PG_CATCH(); - { - ErrorData *edata; - - /* Must reset elog.c's state */ - MemoryContextSwitchTo(oldcontext); - edata = CopyErrorData(); - FlushErrorState(); - - /* Punt the error to Perl */ - croak_cstr(edata->message); - } - PG_END_TRY(); -} - - MODULE = PostgreSQL::InServer::SPI PREFIX = spi_ PROTOTYPES: ENABLE @@ -76,7 +48,7 @@ void spi_return_next(rv) SV *rv; CODE: - do_plperl_return_next(rv); + plperl_return_next(rv); SV * spi_spi_query(sv) diff --git a/src/pl/plperl/Util.xs b/src/pl/plperl/Util.xs index 8c3c47fec9..629d12aaaf 100644 --- a/src/pl/plperl/Util.xs +++ b/src/pl/plperl/Util.xs @@ -15,53 +15,15 @@ #include "fmgr.h" #include "utils/builtins.h" #include "utils/bytea.h" /* for byteain & byteaout */ -#include "mb/pg_wchar.h" /* for GetDatabaseEncoding */ + /* Defined by Perl */ #undef _ /* perl stuff */ +#define PG_NEED_PERL_XSUB_H #include "plperl.h" #include "plperl_helpers.h" -/* - * Implementation of plperl's elog() function - * - * If the error level is less than ERROR, we'll just emit the message and - * return. When it is ERROR, elog() will longjmp, which we catch and - * turn into a Perl croak(). Note we are assuming that elog() can't have - * any internal failures that are so bad as to require a transaction abort. - * - * This is out-of-line to suppress "might be clobbered by longjmp" warnings. - */ -static void -do_util_elog(int level, SV *msg) -{ - MemoryContext oldcontext = CurrentMemoryContext; - char * volatile cmsg = NULL; - - PG_TRY(); - { - cmsg = sv2cstr(msg); - elog(level, "%s", cmsg); - pfree(cmsg); - } - PG_CATCH(); - { - ErrorData *edata; - - /* Must reset elog.c's state */ - MemoryContextSwitchTo(oldcontext); - edata = CopyErrorData(); - FlushErrorState(); - - if (cmsg) - pfree(cmsg); - - /* Punt the error to Perl */ - croak_cstr(edata->message); - } - PG_END_TRY(); -} static text * sv2text(SV *sv) @@ -105,7 +67,7 @@ util_elog(level, msg) level = ERROR; if (level < DEBUG5) level = DEBUG5; - do_util_elog(level, msg); + plperl_util_elog(level, msg); SV * util_quote_literal(sv) diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c index 2cd761496d..e58c85c7b4 100644 --- a/src/pl/plperl/plperl.c +++ b/src/pl/plperl/plperl.c @@ -6,6 +6,7 @@ **********************************************************************/ #include "postgres.h" + /* Defined by Perl */ #undef _ @@ -283,6 +284,7 @@ static void plperl_init_shared_libs(pTHX); static void plperl_trusted_init(void); static void plperl_untrusted_init(void); static HV *plperl_spi_execute_fetch_result(SPITupleTable *, uint64, int); +static void plperl_return_next_internal(SV *sv); static char *hek2cstr(HE *he); static SV **hv_store_string(HV *hv, const char *key, SV *val); static SV **hv_fetch_string(HV *hv, const char *key); @@ -300,12 +302,27 @@ static void activate_interpreter(plperl_interp_desc *interp_desc); static char *setlocale_perl(int category, char *locale); #endif +/* + * Decrement the refcount of the given SV within the active Perl interpreter + * + * This is handy because it reloads the active-interpreter pointer, saving + * some notation in callers that switch the active interpreter. + */ +static inline void +SvREFCNT_dec_current(SV *sv) +{ + dTHX; + + SvREFCNT_dec(sv); +} + /* * convert a HE (hash entry) key to a cstr in the current database encoding */ static char * hek2cstr(HE *he) { + dTHX; char *ret; SV *sv; @@ -656,15 +673,19 @@ select_perl_context(bool trusted) * to the database AFTER on_*_init code has run. See * http://archives.postgresql.org/pgsql-hackers/2010-01/msg02669.php */ - newXS("PostgreSQL::InServer::SPI::bootstrap", - boot_PostgreSQL__InServer__SPI, __FILE__); + { + dTHX; - eval_pv("PostgreSQL::InServer::SPI::bootstrap()", FALSE); - if (SvTRUE(ERRSV)) - ereport(ERROR, - (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), - errmsg("%s", strip_trailing_ws(sv2cstr(ERRSV))), - errcontext("while executing PostgreSQL::InServer::SPI::bootstrap"))); + newXS("PostgreSQL::InServer::SPI::bootstrap", + boot_PostgreSQL__InServer__SPI, __FILE__); + + eval_pv("PostgreSQL::InServer::SPI::bootstrap()", FALSE); + if (SvTRUE(ERRSV)) + ereport(ERROR, + (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), + errmsg("%s", strip_trailing_ws(sv2cstr(ERRSV))), + errcontext("while executing PostgreSQL::InServer::SPI::bootstrap"))); + } /* Fully initialized, so mark the hashtable entry valid */ interp_desc->interp = interp; @@ -807,53 +828,62 @@ plperl_init_interp(void) PERL_SET_CONTEXT(plperl); perl_construct(plperl); - /* run END blocks in perl_destruct instead of perl_run */ - PL_exit_flags |= PERL_EXIT_DESTRUCT_END; - /* - * Record the original function for the 'require' and 'dofile' opcodes. - * (They share the same implementation.) Ensure it's used for new - * interpreters. + * Run END blocks in perl_destruct instead of perl_run. Note that dTHX + * loads up a pointer to the current interpreter, so we have to postpone + * it to here rather than put it at the function head. */ - if (!pp_require_orig) - pp_require_orig = PL_ppaddr[OP_REQUIRE]; - else { - PL_ppaddr[OP_REQUIRE] = pp_require_orig; - PL_ppaddr[OP_DOFILE] = pp_require_orig; - } + dTHX; + + PL_exit_flags |= PERL_EXIT_DESTRUCT_END; + + /* + * Record the original function for the 'require' and 'dofile' + * opcodes. (They share the same implementation.) Ensure it's used + * for new interpreters. + */ + if (!pp_require_orig) + pp_require_orig = PL_ppaddr[OP_REQUIRE]; + else + { + PL_ppaddr[OP_REQUIRE] = pp_require_orig; + PL_ppaddr[OP_DOFILE] = pp_require_orig; + } #ifdef PLPERL_ENABLE_OPMASK_EARLY - /* - * For regression testing to prove that the PLC_PERLBOOT and PLC_TRUSTED - * code doesn't even compile any unsafe ops. In future there may be a - * valid need for them to do so, in which case this could be softened - * (perhaps moved to plperl_trusted_init()) or removed. - */ - PL_op_mask = plperl_opmask; + /* + * For regression testing to prove that the PLC_PERLBOOT and + * PLC_TRUSTED code doesn't even compile any unsafe ops. In future + * there may be a valid need for them to do so, in which case this + * could be softened (perhaps moved to plperl_trusted_init()) or + * removed. + */ + PL_op_mask = plperl_opmask; #endif - if (perl_parse(plperl, plperl_init_shared_libs, - nargs, embedding, NULL) != 0) - ereport(ERROR, - (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), - errmsg("%s", strip_trailing_ws(sv2cstr(ERRSV))), - errcontext("while parsing Perl initialization"))); + if (perl_parse(plperl, plperl_init_shared_libs, + nargs, embedding, NULL) != 0) + ereport(ERROR, + (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), + errmsg("%s", strip_trailing_ws(sv2cstr(ERRSV))), + errcontext("while parsing Perl initialization"))); - if (perl_run(plperl) != 0) - ereport(ERROR, - (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), - errmsg("%s", strip_trailing_ws(sv2cstr(ERRSV))), - errcontext("while running Perl initialization"))); + if (perl_run(plperl) != 0) + ereport(ERROR, + (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), + errmsg("%s", strip_trailing_ws(sv2cstr(ERRSV))), + errcontext("while running Perl initialization"))); #ifdef PLPERL_RESTORE_LOCALE - PLPERL_RESTORE_LOCALE(LC_COLLATE, save_collate); - PLPERL_RESTORE_LOCALE(LC_CTYPE, save_ctype); - PLPERL_RESTORE_LOCALE(LC_MONETARY, save_monetary); - PLPERL_RESTORE_LOCALE(LC_NUMERIC, save_numeric); - PLPERL_RESTORE_LOCALE(LC_TIME, save_time); + PLPERL_RESTORE_LOCALE(LC_COLLATE, save_collate); + PLPERL_RESTORE_LOCALE(LC_CTYPE, save_ctype); + PLPERL_RESTORE_LOCALE(LC_MONETARY, save_monetary); + PLPERL_RESTORE_LOCALE(LC_NUMERIC, save_numeric); + PLPERL_RESTORE_LOCALE(LC_TIME, save_time); #endif + } return plperl; } @@ -919,6 +949,7 @@ plperl_destroy_interp(PerlInterpreter **interp) * public API so isn't portably available.) Meanwhile END blocks can * be used to perform manual cleanup. */ + dTHX; /* Run END blocks - based on perl's perl_destruct() */ if (PL_exit_flags & PERL_EXIT_DESTRUCT_END) @@ -945,6 +976,7 @@ plperl_destroy_interp(PerlInterpreter **interp) static void plperl_trusted_init(void) { + dTHX; HV *stash; SV *sv; char *key; @@ -1025,6 +1057,8 @@ plperl_trusted_init(void) static void plperl_untrusted_init(void) { + dTHX; + /* * Nothing to do except execute plperl.on_plperlu_init */ @@ -1060,6 +1094,7 @@ strip_trailing_ws(const char *msg) static HeapTuple plperl_build_tuple_result(HV *perlhash, TupleDesc td) { + dTHX; Datum *values; bool *nulls; HE *he; @@ -1116,6 +1151,8 @@ plperl_hash_to_datum(SV *src, TupleDesc td) static SV * get_perl_array_ref(SV *sv) { + dTHX; + if (SvOK(sv) && SvROK(sv)) { if (SvTYPE(SvRV(sv)) == SVt_PVAV) @@ -1144,6 +1181,7 @@ array_to_datum_internal(AV *av, ArrayBuildState *astate, Oid arraytypid, Oid elemtypid, int32 typmod, FmgrInfo *finfo, Oid typioparam) { + dTHX; int i; int len = av_len(av) + 1; @@ -1215,6 +1253,7 @@ array_to_datum_internal(AV *av, ArrayBuildState *astate, static Datum plperl_array_to_datum(SV *src, Oid typid, int32 typmod) { + dTHX; ArrayBuildState *astate; Oid elemtypid; FmgrInfo finfo; @@ -1417,6 +1456,7 @@ plperl_sv_to_literal(SV *sv, char *fqtypename) static SV * plperl_ref_from_pg_array(Datum arg, Oid typid) { + dTHX; ArrayType *ar = DatumGetArrayTypeP(arg); Oid elementtype = ARR_ELEMTYPE(ar); int16 typlen; @@ -1485,6 +1525,7 @@ plperl_ref_from_pg_array(Datum arg, Oid typid) static SV * split_array(plperl_array_info *info, int first, int last, int nest) { + dTHX; int i; AV *result; @@ -1518,6 +1559,7 @@ split_array(plperl_array_info *info, int first, int last, int nest) static SV * make_array_ref(plperl_array_info *info, int first, int last) { + dTHX; int i; AV *result = newAV(); @@ -1555,6 +1597,7 @@ make_array_ref(plperl_array_info *info, int first, int last) static SV * plperl_trigger_build_args(FunctionCallInfo fcinfo) { + dTHX; TriggerData *tdata; TupleDesc tupdesc; int i; @@ -1661,6 +1704,7 @@ plperl_trigger_build_args(FunctionCallInfo fcinfo) static SV * plperl_event_trigger_build_args(FunctionCallInfo fcinfo) { + dTHX; EventTriggerData *tdata; HV *hv; @@ -1679,6 +1723,7 @@ plperl_event_trigger_build_args(FunctionCallInfo fcinfo) static HeapTuple plperl_modify_tuple(HV *hvTD, TriggerData *tdata, HeapTuple otup) { + dTHX; SV **svp; HV *hvNew; HE *he; @@ -1880,7 +1925,7 @@ plperl_inline_handler(PG_FUNCTION_ARGS) perlret = plperl_call_perl_func(&desc, &fake_fcinfo); - SvREFCNT_dec(perlret); + SvREFCNT_dec_current(perlret); if (SPI_finish() != SPI_OK_FINISH) elog(ERROR, "SPI_finish() failed"); @@ -1888,7 +1933,7 @@ plperl_inline_handler(PG_FUNCTION_ARGS) PG_CATCH(); { if (desc.reference) - SvREFCNT_dec(desc.reference); + SvREFCNT_dec_current(desc.reference); current_call_data = save_call_data; activate_interpreter(oldinterp); PG_RE_THROW(); @@ -1896,7 +1941,7 @@ plperl_inline_handler(PG_FUNCTION_ARGS) PG_END_TRY(); if (desc.reference) - SvREFCNT_dec(desc.reference); + SvREFCNT_dec_current(desc.reference); current_call_data = save_call_data; activate_interpreter(oldinterp); @@ -2024,6 +2069,7 @@ plperlu_validator(PG_FUNCTION_ARGS) static void plperl_create_sub(plperl_proc_desc *prodesc, char *s, Oid fn_oid) { + dTHX; dSP; char subname[NAMEDATALEN + 40]; HV *pragma_hv = newHV(); @@ -2110,6 +2156,7 @@ plperl_init_shared_libs(pTHX) static SV * plperl_call_perl_func(plperl_proc_desc *desc, FunctionCallInfo fcinfo) { + dTHX; dSP; SV *retval; int i; @@ -2203,6 +2250,7 @@ static SV * plperl_call_perl_trigger_func(plperl_proc_desc *desc, FunctionCallInfo fcinfo, SV *td) { + dTHX; dSP; SV *retval, *TDsv; @@ -2271,6 +2319,7 @@ plperl_call_perl_event_trigger_func(plperl_proc_desc *desc, FunctionCallInfo fcinfo, SV *td) { + dTHX; dSP; SV *retval, *TDsv; @@ -2390,13 +2439,14 @@ plperl_func_handler(PG_FUNCTION_ARGS) sav = get_perl_array_ref(perlret); if (sav) { + dTHX; int i = 0; SV **svp = 0; AV *rav = (AV *) SvRV(sav); while ((svp = av_fetch(rav, i, FALSE)) != NULL) { - plperl_return_next(*svp); + plperl_return_next_internal(*svp); i++; } } @@ -2433,7 +2483,7 @@ plperl_func_handler(PG_FUNCTION_ARGS) /* Restore the previous error callback */ error_context_stack = pl_error_context.previous; - SvREFCNT_dec(perlret); + SvREFCNT_dec_current(perlret); return retval; } @@ -2537,9 +2587,9 @@ plperl_trigger_handler(PG_FUNCTION_ARGS) /* Restore the previous error callback */ error_context_stack = pl_error_context.previous; - SvREFCNT_dec(svTD); + SvREFCNT_dec_current(svTD); if (perlret) - SvREFCNT_dec(perlret); + SvREFCNT_dec_current(perlret); return retval; } @@ -2578,9 +2628,7 @@ plperl_event_trigger_handler(PG_FUNCTION_ARGS) /* Restore the previous error callback */ error_context_stack = pl_error_context.previous; - SvREFCNT_dec(svTD); - - return; + SvREFCNT_dec_current(svTD); } @@ -2623,7 +2671,7 @@ free_plperl_function(plperl_proc_desc *prodesc) plperl_interp_desc *oldinterp = plperl_active_interp; activate_interpreter(prodesc->interp); - SvREFCNT_dec(prodesc->reference); + SvREFCNT_dec_current(prodesc->reference); activate_interpreter(oldinterp); } /* Get rid of what we conveniently can of our own structs */ @@ -2937,6 +2985,7 @@ plperl_hash_from_datum(Datum attr) static SV * plperl_hash_from_tuple(HeapTuple tuple, TupleDesc tupdesc) { + dTHX; HV *hv; int i; @@ -3095,6 +3144,7 @@ static HV * plperl_spi_execute_fetch_result(SPITupleTable *tuptable, uint64 processed, int status) { + dTHX; HV *result; check_spi_usage_allowed(); @@ -3138,15 +3188,40 @@ plperl_spi_execute_fetch_result(SPITupleTable *tuptable, uint64 processed, /* - * Note: plperl_return_next is called both in Postgres and Perl contexts. - * We report any errors in Postgres fashion (via ereport). If called in - * Perl context, it is SPI.xs's responsibility to catch the error and - * convert to a Perl error. We assume (perhaps without adequate justification) - * that we need not abort the current transaction if the Perl code traps the - * error. + * plperl_return_next catches any error and converts it to a Perl error. + * We assume (perhaps without adequate justification) that we need not abort + * the current transaction if the Perl code traps the error. */ void plperl_return_next(SV *sv) +{ + MemoryContext oldcontext = CurrentMemoryContext; + + PG_TRY(); + { + plperl_return_next_internal(sv); + } + PG_CATCH(); + { + ErrorData *edata; + + /* Must reset elog.c's state */ + MemoryContextSwitchTo(oldcontext); + edata = CopyErrorData(); + FlushErrorState(); + + /* Punt the error to Perl */ + croak_cstr(edata->message); + } + PG_END_TRY(); +} + +/* + * plperl_return_next_internal reports any errors in Postgres fashion + * (via ereport). + */ +static void +plperl_return_next_internal(SV *sv) { plperl_proc_desc *prodesc; FunctionCallInfo fcinfo; @@ -3350,6 +3425,7 @@ plperl_spi_fetchrow(char *cursor) PG_TRY(); { + dTHX; Portal p = SPI_cursor_find(cursor); if (!p) @@ -3617,6 +3693,8 @@ plperl_spi_exec_prepared(char *query, HV *attr, int argc, SV **argv) PG_TRY(); { + dTHX; + /************************************************************ * Fetch the saved plan descriptor, see if it's o.k. ************************************************************/ @@ -3887,6 +3965,47 @@ plperl_spi_freeplan(char *query) SPI_freeplan(plan); } +/* + * Implementation of plperl's elog() function + * + * If the error level is less than ERROR, we'll just emit the message and + * return. When it is ERROR, elog() will longjmp, which we catch and + * turn into a Perl croak(). Note we are assuming that elog() can't have + * any internal failures that are so bad as to require a transaction abort. + * + * The main reason this is out-of-line is to avoid conflicts between XSUB.h + * and the PG_TRY macros. + */ +void +plperl_util_elog(int level, SV *msg) +{ + MemoryContext oldcontext = CurrentMemoryContext; + char *volatile cmsg = NULL; + + PG_TRY(); + { + cmsg = sv2cstr(msg); + elog(level, "%s", cmsg); + pfree(cmsg); + } + PG_CATCH(); + { + ErrorData *edata; + + /* Must reset elog.c's state */ + MemoryContextSwitchTo(oldcontext); + edata = CopyErrorData(); + FlushErrorState(); + + if (cmsg) + pfree(cmsg); + + /* Punt the error to Perl */ + croak_cstr(edata->message); + } + PG_END_TRY(); +} + /* * Store an SV into a hash table under a key that is a string assumed to be * in the current database's encoding. @@ -3894,6 +4013,7 @@ plperl_spi_freeplan(char *query) static SV ** hv_store_string(HV *hv, const char *key, SV *val) { + dTHX; int32 hlen; char *hkey; SV **ret; @@ -3920,6 +4040,7 @@ hv_store_string(HV *hv, const char *key, SV *val) static SV ** hv_fetch_string(HV *hv, const char *key) { + dTHX; int32 hlen; char *hkey; SV **ret; @@ -3978,6 +4099,7 @@ plperl_inline_callback(void *arg) static char * setlocale_perl(int category, char *locale) { + dTHX; char *RETVAL = setlocale(category, locale); if (RETVAL) @@ -4042,4 +4164,4 @@ setlocale_perl(int category, char *locale) return RETVAL; } -#endif +#endif /* WIN32 */ diff --git a/src/pl/plperl/plperl.h b/src/pl/plperl/plperl.h index 0146d60a11..a4593cac37 100644 --- a/src/pl/plperl/plperl.h +++ b/src/pl/plperl/plperl.h @@ -24,7 +24,7 @@ #ifdef isnan #undef isnan #endif -#endif +#endif /* WIN32 */ /* * Supply a value of PERL_UNUSED_DECL that will satisfy gcc - the one @@ -43,10 +43,22 @@ #endif -/* required for perl API */ +/* + * Get the basic Perl API. We use PERL_NO_GET_CONTEXT mode so that our code + * can compile against MULTIPLICITY Perl builds without including XSUB.h. + */ +#define PERL_NO_GET_CONTEXT #include "EXTERN.h" #include "perl.h" + +/* + * We want to include XSUB.h only within .xs files, because on some platforms + * it undesirably redefines a lot of libc functions. But it must appear + * before ppport.h, so use a #define flag to control inclusion here. + */ +#ifdef PG_NEED_PERL_XSUB_H #include "XSUB.h" +#endif /* put back our snprintf and vsnprintf */ #ifdef USE_REPL_SNPRINTF @@ -106,5 +118,6 @@ SV *plperl_spi_query_prepared(char *, int, SV **); void plperl_spi_freeplan(char *); void plperl_spi_cursor_close(char *); char *plperl_sv_to_literal(SV *, char *); +void plperl_util_elog(int level, SV *msg); #endif /* PL_PERL_H */ diff --git a/src/pl/plperl/plperl_helpers.h b/src/pl/plperl/plperl_helpers.h index f8aa06835c..8861736f9c 100644 --- a/src/pl/plperl/plperl_helpers.h +++ b/src/pl/plperl/plperl_helpers.h @@ -50,6 +50,7 @@ utf_e2u(const char *str) static inline char * sv2cstr(SV *sv) { + dTHX; char *val, *res; STRLEN len; @@ -107,6 +108,7 @@ sv2cstr(SV *sv) static inline SV * cstr2sv(const char *str) { + dTHX; SV *sv; char *utf8_str; @@ -134,6 +136,8 @@ cstr2sv(const char *str) static inline void croak_cstr(const char *str) { + dTHX; + #ifdef croak_sv /* Use sv_2mortal() to be sure the transient SV gets freed */ croak_sv(sv_2mortal(cstr2sv(str))); From 1e58c503ec46ec78ddf19aa5bad7d095f14e042b Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 31 Jul 2017 12:38:35 -0400 Subject: [PATCH 0169/1139] PL/Perl portability fix: absorb relevant -D switches from Perl. Back-patch of commit 3c163a7fc76debbbdad1bdd3c43721cffe72f4db, which see for more info. Also throw in commit b4cc35fbb709bd6fcae8998f041fd731c9acbf42, so Coverity doesn't whine about the back branches. Ashutosh Sharma, some adjustments by me Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com --- config/perl.m4 | 25 +++++++++++++++++++++++++ configure | 13 +++++++++++++ configure.in | 1 + contrib/hstore_plperl/Makefile | 2 +- src/Makefile.global.in | 1 + src/pl/plperl/GNUmakefile | 6 +++++- src/pl/plperl/plperl.c | 28 +++++++++++++++++----------- src/tools/msvc/Mkvcbuild.pm | 27 +++++++++++++++++++++++++-- 8 files changed, 88 insertions(+), 15 deletions(-) diff --git a/config/perl.m4 b/config/perl.m4 index bed2eae57f..9706c4de6a 100644 --- a/config/perl.m4 +++ b/config/perl.m4 @@ -49,6 +49,31 @@ AC_DEFUN([PGAC_CHECK_PERL_CONFIGS], [m4_foreach([pgac_item], [$1], [PGAC_CHECK_PERL_CONFIG(pgac_item)])]) +# PGAC_CHECK_PERL_EMBED_CCFLAGS +# ----------------------------- +# We selectively extract stuff from $Config{ccflags}. We don't really need +# anything except -D switches, and other sorts of compiler switches can +# actively break things if Perl was compiled with a different compiler. +# Moreover, although Perl likes to put stuff like -D_LARGEFILE_SOURCE and +# -D_FILE_OFFSET_BITS=64 here, it would be fatal to try to compile PL/Perl +# to a different libc ABI than core Postgres uses. The available information +# says that all the symbols that affect Perl's own ABI begin with letters, +# so it should be sufficient to adopt -D switches for symbols not beginning +# with underscore. +# For debugging purposes, let's have the configure output report the raw +# ccflags value as well as the set of flags we chose to adopt. +AC_DEFUN([PGAC_CHECK_PERL_EMBED_CCFLAGS], +[AC_REQUIRE([PGAC_PATH_PERL]) +AC_MSG_CHECKING([for CFLAGS recommended by Perl]) +perl_ccflags=`$PERL -MConfig -e ['print $Config{ccflags}']` +AC_MSG_RESULT([$perl_ccflags]) +AC_MSG_CHECKING([for CFLAGS to compile embedded Perl]) +perl_embed_ccflags=`$PERL -MConfig -e ['foreach $f (split(" ",$Config{ccflags})) {print $f, " " if ($f =~ /^-D[^_]/)}']` +AC_SUBST(perl_embed_ccflags)dnl +AC_MSG_RESULT([$perl_embed_ccflags]) +])# PGAC_CHECK_PERL_EMBED_CCFLAGS + + # PGAC_CHECK_PERL_EMBED_LDFLAGS # ----------------------------- # We are after Embed's ldopts, but without the subset mentioned in diff --git a/configure b/configure index 50461e2faa..190027bafb 100755 --- a/configure +++ b/configure @@ -670,6 +670,7 @@ python_version python_majorversion PYTHON perl_embed_ldflags +perl_embed_ccflags perl_useshrplib perl_privlibexp perl_archlibexp @@ -7511,6 +7512,18 @@ documentation for details. Use --without-perl to disable building PL/Perl." "$LINENO" 5 fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CFLAGS recommended by Perl" >&5 +$as_echo_n "checking for CFLAGS recommended by Perl... " >&6; } +perl_ccflags=`$PERL -MConfig -e 'print $Config{ccflags}'` +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $perl_ccflags" >&5 +$as_echo "$perl_ccflags" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CFLAGS to compile embedded Perl" >&5 +$as_echo_n "checking for CFLAGS to compile embedded Perl... " >&6; } +perl_embed_ccflags=`$PERL -MConfig -e 'foreach $f (split(" ",$Config{ccflags})) {print $f, " " if ($f =~ /^-D[^_]/)}'` +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $perl_embed_ccflags" >&5 +$as_echo "$perl_embed_ccflags" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for flags to link embedded Perl" >&5 $as_echo_n "checking for flags to link embedded Perl... " >&6; } if test "$PORTNAME" = "win32" ; then diff --git a/configure.in b/configure.in index 35f3a7d0c7..53c9674780 100644 --- a/configure.in +++ b/configure.in @@ -928,6 +928,7 @@ You might have to rebuild your Perl installation. Refer to the documentation for details. Use --without-perl to disable building PL/Perl.]) fi + PGAC_CHECK_PERL_EMBED_CCFLAGS PGAC_CHECK_PERL_EMBED_LDFLAGS fi diff --git a/contrib/hstore_plperl/Makefile b/contrib/hstore_plperl/Makefile index b3b8654bc8..8fdca04bfb 100644 --- a/contrib/hstore_plperl/Makefile +++ b/contrib/hstore_plperl/Makefile @@ -43,4 +43,4 @@ endif # last, probably because it sometimes contains some header files with names # that clash with some of ours, or with some that we include, notably on # Windows. -override CPPFLAGS := $(CPPFLAGS) -I$(perl_archlibexp)/CORE +override CPPFLAGS := $(CPPFLAGS) $(perl_embed_ccflags) -I$(perl_archlibexp)/CORE diff --git a/src/Makefile.global.in b/src/Makefile.global.in index 8ac7ca7d2b..cb939b5855 100644 --- a/src/Makefile.global.in +++ b/src/Makefile.global.in @@ -298,6 +298,7 @@ else endif perl_archlibexp = @perl_archlibexp@ perl_privlibexp = @perl_privlibexp@ +perl_embed_ccflags = @perl_embed_ccflags@ perl_embed_ldflags = @perl_embed_ldflags@ # Miscellaneous diff --git a/src/pl/plperl/GNUmakefile b/src/pl/plperl/GNUmakefile index b8e3585254..191f74067a 100644 --- a/src/pl/plperl/GNUmakefile +++ b/src/pl/plperl/GNUmakefile @@ -12,7 +12,11 @@ override CPPFLAGS += -DPLPERL_HAVE_UID_GID override CPPFLAGS += -Wno-comment endif -override CPPFLAGS := -I. -I$(srcdir) $(CPPFLAGS) -I$(perl_archlibexp)/CORE +# Note: we need to make sure that the CORE directory is included last, +# probably because it sometimes contains some header files with names +# that clash with some of ours, or with some that we include, notably on +# Windows. +override CPPFLAGS := -I. -I$(srcdir) $(CPPFLAGS) $(perl_embed_ccflags) -I$(perl_archlibexp)/CORE rpathdir = $(perl_archlibexp)/CORE diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c index e58c85c7b4..f4180117a5 100644 --- a/src/pl/plperl/plperl.c +++ b/src/pl/plperl/plperl.c @@ -3248,12 +3248,18 @@ plperl_return_next_internal(SV *sv) /* * This is the first call to return_next in the current PL/Perl - * function call, so memoize some lookups + * function call, so identify the output tuple descriptor and create a + * tuplestore to hold the result rows. */ if (prodesc->fn_retistuple) (void) get_call_result_type(fcinfo, NULL, &tupdesc); else + { tupdesc = rsi->expectedDesc; + /* Protect assumption below that we return exactly one column */ + if (tupdesc == NULL || tupdesc->natts != 1) + elog(ERROR, "expected single-column result descriptor for non-composite SETOF result"); + } /* * Make sure the tuple_store and ret_tdesc are sufficiently @@ -3301,20 +3307,20 @@ plperl_return_next_internal(SV *sv) } else { - Datum ret; - bool isNull; + Datum ret[1]; + bool isNull[1]; - ret = plperl_sv_to_datum(sv, - prodesc->result_oid, - -1, - fcinfo, - &prodesc->result_in_func, - prodesc->result_typioparam, - &isNull); + ret[0] = plperl_sv_to_datum(sv, + prodesc->result_oid, + -1, + fcinfo, + &prodesc->result_in_func, + prodesc->result_typioparam, + &isNull[0]); tuplestore_putvalues(current_call_data->tuple_store, current_call_data->ret_tdesc, - &ret, &isNull); + ret, isNull); } MemoryContextSwitchTo(old_cxt); diff --git a/src/tools/msvc/Mkvcbuild.pm b/src/tools/msvc/Mkvcbuild.pm index 6285aab2b6..f3bd30540a 100644 --- a/src/tools/msvc/Mkvcbuild.pm +++ b/src/tools/msvc/Mkvcbuild.pm @@ -516,7 +516,26 @@ sub mkvcbuild my $plperl = $solution->AddProject('plperl', 'dll', 'PLs', 'src/pl/plperl'); $plperl->AddIncludeDir($solution->{options}->{perl} . '/lib/CORE'); - $plperl->AddDefine('PLPERL_HAVE_UID_GID'); + + # Add defines from Perl's ccflags; see PGAC_CHECK_PERL_EMBED_CCFLAGS + my @perl_embed_ccflags; + foreach my $f (split(" ",$Config{ccflags})) + { + if ($f =~ /^-D[^_]/) + { + $f =~ s/\-D//; + push(@perl_embed_ccflags, $f); + } + } + + # XXX this probably is redundant now? + push(@perl_embed_ccflags, 'PLPERL_HAVE_UID_GID'); + + foreach my $f (@perl_embed_ccflags) + { + $plperl->AddDefine($f); + } + foreach my $xs ('SPI.xs', 'Util.xs') { (my $xsc = $xs) =~ s/\.xs/.c/; @@ -599,7 +618,11 @@ sub mkvcbuild 'hstore_plperl', 'contrib/hstore_plperl', 'plperl', 'src/pl/plperl', 'hstore', 'contrib/hstore'); - $hstore_plperl->AddDefine('PLPERL_HAVE_UID_GID'); + + foreach my $f (@perl_embed_ccflags) + { + $hstore_plperl->AddDefine($f); + } } $mf = From 3521131cb120ab5fb2f5a5b9cbf15003ef6b98ab Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 31 Jul 2017 13:42:48 -0400 Subject: [PATCH 0170/1139] Doc: specify that the minimum supported version of Perl is 5.8.3. Previously the docs just said "5.8 or later". Experimentation shows that while you can build on Unix from a git checkout with 5.8.0, compiling recent PL/Perl requires at least 5.8.1, and you won't be able to run the TAP tests with less than 5.8.3 because that's when they added "prove". (I do not have any information on just what the MSVC build scripts require.) Since all these versions are quite ancient, let's not split hairs in the docs, but just say that 5.8.3 is the minimum requirement. Discussion: https://postgr.es/m/16894.1501392088@sss.pgh.pa.us --- doc/src/sgml/install-windows.sgml | 3 ++- doc/src/sgml/installation.sgml | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/install-windows.sgml b/doc/src/sgml/install-windows.sgml index 9322a627e3..3bdcc75079 100644 --- a/doc/src/sgml/install-windows.sgml +++ b/doc/src/sgml/install-windows.sgml @@ -180,7 +180,8 @@ $ENV{PATH}=$ENV{PATH} . ';c:\some\where\bison\bin'; ActiveState Perl is required to run the build generation scripts. MinGW or Cygwin Perl will not work. It must also be present in the PATH. Binaries can be downloaded from - (Note: version 5.8 or later is required, + + (Note: version 5.8.3 or later is required, the free Standard Distribution is sufficient). diff --git a/doc/src/sgml/installation.sgml b/doc/src/sgml/installation.sgml index 59762b0a93..d3088a3101 100644 --- a/doc/src/sgml/installation.sgml +++ b/doc/src/sgml/installation.sgml @@ -163,6 +163,7 @@ su - postgres PL/Perl you need a full Perl installation, including the libperl library and the header files. + The minimum required version is Perl 5.8.3. Since PL/Perl will be a shared library, the libperl libperl library must be a shared library @@ -306,7 +307,7 @@ su - postgres perl - Perl 5.8 or later is needed to build from a Git checkout, + Perl 5.8.3 or later is needed to build from a Git checkout, or if you changed the input files for any of the build steps that use Perl scripts. If building on Windows you will need Perl in any case. Perl is From bd8ff38760080362aa3ee126ed9a5e4b0d32c2a8 Mon Sep 17 00:00:00 2001 From: Tatsuo Ishii Date: Tue, 1 Aug 2017 08:00:11 +0900 Subject: [PATCH 0171/1139] Fix comment. XLByteToSeg and XLByteToPrevSeg calculate only a segment number. The definition of these macros were modified by commit dfda6ebaec6763090fb78b458a979b558c50b39b but the comment remain unchanged. Patch by Yugo Nagata. Back patched to 9.3 and beyond. --- src/include/access/xlog_internal.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/access/xlog_internal.h b/src/include/access/xlog_internal.h index 0a595ccc48..5733cfb77e 100644 --- a/src/include/access/xlog_internal.h +++ b/src/include/access/xlog_internal.h @@ -96,7 +96,7 @@ typedef XLogLongPageHeaderData *XLogLongPageHeader; (dest) = (segno) * XLOG_SEG_SIZE + (offset) /* - * Compute ID and segment from an XLogRecPtr. + * Compute a segment number from an XLogRecPtr. * * For XLByteToSeg, do the computation at face value. For XLByteToPrevSeg, * a boundary byte is taken to be in the previous segment. This is suitable From ac219b92d3aa94641cc9628b59b478d0e1b7f542 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Tue, 1 Aug 2017 14:33:55 -0400 Subject: [PATCH 0172/1139] doc: Fix typo Author: Fabien COELHO --- doc/src/sgml/ref/pgbench.sgml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/src/sgml/ref/pgbench.sgml b/doc/src/sgml/ref/pgbench.sgml index 285608d508..2c9f483932 100644 --- a/doc/src/sgml/ref/pgbench.sgml +++ b/doc/src/sgml/ref/pgbench.sgml @@ -1037,7 +1037,7 @@ f(x) = exp(-parameter * (x - min) / (max - min + 1)) / (1 - exp(-parameter)) Then value i between min and max inclusive is drawn with probability: - f(x) - f(x + 1). + f(i) - f(i + 1). From cf9da98600f1874d2046bfbc9439ff311370d7db Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 2 Aug 2017 12:16:50 -0400 Subject: [PATCH 0173/1139] Remove broken and useless entry-count printing in HASH_DEBUG code. init_htab(), with #define HASH_DEBUG, prints a bunch of hashtable parameters. It used to also print nentries, but commit 44ca4022f changed that to "hash_get_num_entries(hctl)", which is wrong (the parameter should be "hashp"). Rather than correct the coding, though, let's just remove that field from the printout. The table must be empty, since we just finished building it, so expensively calculating the number of entries is rather pointless. Moreover hash_get_num_entries makes assumptions (about not needing locks) which we could do without in debugging code. Noted by Choi Doo-Won in bug #14764. Back-patch to 9.6 where the faulty code was introduced. Discussion: https://postgr.es/m/20170802032353.8424.12274@wrigleys.postgresql.org --- src/backend/utils/hash/dynahash.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/backend/utils/hash/dynahash.c b/src/backend/utils/hash/dynahash.c index bb835ba946..6a05e34590 100644 --- a/src/backend/utils/hash/dynahash.c +++ b/src/backend/utils/hash/dynahash.c @@ -685,7 +685,7 @@ init_htab(HTAB *hashp, long nelem) hctl->nelem_alloc = choose_nelem_alloc(hctl->entrysize); #if HASH_DEBUG - fprintf(stderr, "init_htab:\n%s%p\n%s%ld\n%s%ld\n%s%d\n%s%ld\n%s%u\n%s%x\n%s%x\n%s%ld\n%s%ld\n", + fprintf(stderr, "init_htab:\n%s%p\n%s%ld\n%s%ld\n%s%d\n%s%ld\n%s%u\n%s%x\n%s%x\n%s%ld\n", "TABLE POINTER ", hashp, "DIRECTORY SIZE ", hctl->dsize, "SEGMENT SIZE ", hctl->ssize, @@ -694,8 +694,7 @@ init_htab(HTAB *hashp, long nelem) "MAX BUCKET ", hctl->max_bucket, "HIGH MASK ", hctl->high_mask, "LOW MASK ", hctl->low_mask, - "NSEGS ", hctl->nsegs, - "NENTRIES ", hash_get_num_entries(hctl)); + "NSEGS ", hctl->nsegs); #endif return true; } From e5c87d5e1d9cad9019e2c4e4f392ba687bc58d02 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 2 Aug 2017 16:55:03 -0400 Subject: [PATCH 0174/1139] Add pgtcl back to the list of externally-maintained client interfaces. FlightAware is still maintaining this, and indeed is seemingly being more active with it than the pgtclng fork is. List both, for the time being anyway. In the back branches, also back-port commit e20f679f6 and other recent updates to the client-interfaces list. I think these are probably of current interest to users of back branches. I did not touch the list of externally maintained PLs in the back branches, though. Those are much more likely to be server version sensitive, and I don't know which of these PLs work all the way back. Discussion: https://postgr.es/m/20170730162612.1449.58796@wrigleys.postgresql.org --- doc/src/sgml/external-projects.sgml | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/doc/src/sgml/external-projects.sgml b/doc/src/sgml/external-projects.sgml index 8457426545..c9c9fc0307 100644 --- a/doc/src/sgml/external-projects.sgml +++ b/doc/src/sgml/external-projects.sgml @@ -70,7 +70,7 @@ JDBC - JDBC + Java Type 4 JDBC driver @@ -82,6 +82,13 @@ + + node-postgres + JavaScript + Node.js driver + + + Npgsql .NET @@ -89,6 +96,13 @@ + + pgtcl + Tcl + + + + pgtclng Tcl @@ -96,6 +110,13 @@ + + pq + Go + Pure Go driver for Go's database/sql + + + psqlODBC ODBC From 060393f2a13651bf53c7626a3587baaf82942023 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Wed, 2 Aug 2017 18:26:26 -0400 Subject: [PATCH 0175/1139] Fix pg_dump's errno checking for zlib I/O MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Some error reports were reporting strerror(errno), which for some error conditions coming from zlib are wrong, resulting in confusing reports such as pg_restore: [compress_io] could not read from input file: Success which makes no sense. To correctly extract the error message we need to use gzerror(), so let's do that. This isn't as comprehensive or as neat as I would like, but at least it should improve things in many common cases. The zlib abstraction in compress_io does not seem to be applied consistently enough; we could perhaps improve that, but it seems master-only material, not a bug fix for back-patching. This problem goes back all the way, but I decided to apply back to 9.4 only, because older branches don't contain commit 14ea89366 which this change depends on. Authors: Vladimir Kunschikov, Ãlvaro Herrera Discussion: https://postgr.es/m/1498120508308.9826@infotecs.ru --- src/bin/pg_dump/compress_io.c | 24 +++++++++++++++++++++++- src/bin/pg_dump/compress_io.h | 1 + src/bin/pg_dump/pg_backup_directory.c | 10 +++++++--- src/bin/pg_dump/pg_backup_tar.c | 8 +++++++- 4 files changed, 38 insertions(+), 5 deletions(-) diff --git a/src/bin/pg_dump/compress_io.c b/src/bin/pg_dump/compress_io.c index e0ef9cd60a..eb590c348c 100644 --- a/src/bin/pg_dump/compress_io.c +++ b/src/bin/pg_dump/compress_io.c @@ -592,8 +592,14 @@ cfread(void *ptr, int size, cfp *fp) { ret = gzread(fp->compressedfp, ptr, size); if (ret != size && !gzeof(fp->compressedfp)) + { + int errnum; + const char *errmsg = gzerror(fp->compressedfp, &errnum); + exit_horribly(modulename, - "could not read from input file: %s\n", strerror(errno)); + "could not read from input file: %s\n", + errnum == Z_ERRNO ? strerror(errno) : errmsg); + } } else #endif @@ -695,6 +701,22 @@ cfeof(cfp *fp) return feof(fp->uncompressedfp); } +const char * +get_cfp_error(cfp *fp) +{ +#ifdef HAVE_LIBZ + if (fp->compressedfp) + { + int errnum; + const char *errmsg = gzerror(fp->compressedfp, &errnum); + + if (errnum != Z_ERRNO) + return errmsg; + } +#endif + return strerror(errno); +} + #ifdef HAVE_LIBZ static int hasSuffix(const char *filename, const char *suffix) diff --git a/src/bin/pg_dump/compress_io.h b/src/bin/pg_dump/compress_io.h index 2a45600943..89be583d45 100644 --- a/src/bin/pg_dump/compress_io.h +++ b/src/bin/pg_dump/compress_io.h @@ -65,5 +65,6 @@ extern int cfgetc(cfp *fp); extern char *cfgets(cfp *fp, char *buf, int len); extern int cfclose(cfp *fp); extern int cfeof(cfp *fp); +extern const char *get_cfp_error(cfp *fp); #endif diff --git a/src/bin/pg_dump/pg_backup_directory.c b/src/bin/pg_dump/pg_backup_directory.c index e52f12258a..6673d4a3cd 100644 --- a/src/bin/pg_dump/pg_backup_directory.c +++ b/src/bin/pg_dump/pg_backup_directory.c @@ -357,7 +357,9 @@ _WriteData(ArchiveHandle *AH, const void *data, size_t dLen) lclContext *ctx = (lclContext *) AH->formatData; if (dLen > 0 && cfwrite(data, dLen, ctx->dataFH) != dLen) - WRITE_ERROR_EXIT; + exit_horribly(modulename, "could not write to output file: %s\n", + get_cfp_error(ctx->dataFH)); + return; } @@ -495,7 +497,8 @@ _WriteByte(ArchiveHandle *AH, const int i) lclContext *ctx = (lclContext *) AH->formatData; if (cfwrite(&c, 1, ctx->dataFH) != 1) - WRITE_ERROR_EXIT; + exit_horribly(modulename, "could not write to output file: %s\n", + get_cfp_error(ctx->dataFH)); return 1; } @@ -524,7 +527,8 @@ _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len) lclContext *ctx = (lclContext *) AH->formatData; if (cfwrite(buf, len, ctx->dataFH) != len) - WRITE_ERROR_EXIT; + exit_horribly(modulename, "could not write to output file: %s\n", + get_cfp_error(ctx->dataFH)); return; } diff --git a/src/bin/pg_dump/pg_backup_tar.c b/src/bin/pg_dump/pg_backup_tar.c index 8dfc6a98de..befbb4ade4 100644 --- a/src/bin/pg_dump/pg_backup_tar.c +++ b/src/bin/pg_dump/pg_backup_tar.c @@ -557,8 +557,14 @@ _tarReadRaw(ArchiveHandle *AH, void *buf, size_t len, TAR_MEMBER *th, FILE *fh) { res = GZREAD(&((char *) buf)[used], 1, len, th->zFH); if (res != len && !GZEOF(th->zFH)) + { + int errnum; + const char *errmsg = gzerror(th->zFH, &errnum); + exit_horribly(modulename, - "could not read from input file: %s\n", strerror(errno)); + "could not read from input file: %s\n", + errnum == Z_ERRNO ? strerror(errno) : errmsg); + } } else { From 1f220c39072bcbee25c247bf7923c009032c3b08 Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Thu, 3 Aug 2017 13:09:15 -0400 Subject: [PATCH 0176/1139] Allow a foreign table CHECK constraint to be initially NOT VALID. For a table, the constraint can be considered validated immediately, because the table must be empty. But for a foreign table this is not necessarily the case. Fixes a bug in commit f27a6b15e6566fba7748d0d9a3fc5bcfd52c4a1b. Amit Langote, with some changes by me. Discussion: http://postgr.es/m/d2b7419f-4a71-cf86-cc99-bfd0f359a1ea@lab.ntt.co.jp --- src/backend/parser/parse_utilcmd.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c index e9e8ef3b44..e4dc508682 100644 --- a/src/backend/parser/parse_utilcmd.c +++ b/src/backend/parser/parse_utilcmd.c @@ -156,6 +156,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString) Oid existing_relid; ParseCallbackState pcbstate; bool like_found = false; + bool is_foreign_table = IsA(stmt, CreateForeignTableStmt); /* * We must not scribble on the passed-in CreateStmt, so copy it. (This is @@ -312,7 +313,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString) /* * Postprocess check constraints. */ - transformCheckConstraints(&cxt, true); + transformCheckConstraints(&cxt, !is_foreign_table ? true : false); /* * Output results. @@ -1935,9 +1936,9 @@ transformCheckConstraints(CreateStmtContext *cxt, bool skipValidation) return; /* - * If creating a new table, we can safely skip validation of check - * constraints, and nonetheless mark them valid. (This will override any - * user-supplied NOT VALID flag.) + * If creating a new table (but not a foreign table), we can safely skip + * validation of check constraints, and nonetheless mark them valid. + * (This will override any user-supplied NOT VALID flag.) */ if (skipValidation) { From 611840074a9a7f3348ed419e31fc47063228e4b8 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Thu, 3 Aug 2017 14:48:54 -0400 Subject: [PATCH 0177/1139] Fix build on zlib-less environments Commit 4d57e8381677 added support for getting I/O errors out of zlib, but it introduced a portability problem for systems without zlib. Repair by wrapping the zlib call inside #ifdef and restore the original code in the other branch. This serves to illustrate the inadequacy of the zlib abstraction in pg_backup_archiver: there is no way to call gzerror() in that abstraction. This means that the several places that call GZREAD and GZWRITE are currently doing error reporting wrongly, but ENOTIME to get it fixed before next week's release set. Backpatch to 9.4, like the commit that introduced the problem. --- src/bin/pg_dump/pg_backup_tar.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/bin/pg_dump/pg_backup_tar.c b/src/bin/pg_dump/pg_backup_tar.c index befbb4ade4..e9d54354ad 100644 --- a/src/bin/pg_dump/pg_backup_tar.c +++ b/src/bin/pg_dump/pg_backup_tar.c @@ -558,12 +558,18 @@ _tarReadRaw(ArchiveHandle *AH, void *buf, size_t len, TAR_MEMBER *th, FILE *fh) res = GZREAD(&((char *) buf)[used], 1, len, th->zFH); if (res != len && !GZEOF(th->zFH)) { +#ifdef HAVE_LIBZ int errnum; const char *errmsg = gzerror(th->zFH, &errnum); exit_horribly(modulename, "could not read from input file: %s\n", errnum == Z_ERRNO ? strerror(errno) : errmsg); +#else + exit_horribly(modulename, + "could not read from input file: %s\n", + strerror(errno)); +#endif } } else From 3d76328298caa1dbcd2104196db26884d9981b3e Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 3 Aug 2017 17:36:23 -0400 Subject: [PATCH 0178/1139] Fix pg_dump/pg_restore to emit REFRESH MATERIALIZED VIEW commands last. Because we push all ACL (i.e. GRANT/REVOKE) restore steps to the end, materialized view refreshes were occurring while the permissions on referenced objects were still at defaults. This led to failures if, say, an MV owned by user A reads from a table owned by user B, even if B had granted the necessary privileges to A. We've had multiple complaints about that type of restore failure, most recently from Jordan Gigov. The ideal fix for this would be to start treating ACLs as dependency- sortable objects, rather than hard-wiring anything about their dump order (the existing approach is a messy kluge dating to commit dc0e76ca3). But that's going to be a rather major change, and it certainly wouldn't lead to a back-patchable fix. As a short-term solution, convert the existing two-pass hack (ie, normal objects then ACLs) to a three-pass hack, ie, normal objects then ACLs then matview refreshes. Because this happens in RestoreArchive(), it will also fix the problem when restoring from an existing archive-format dump. (Note this means that if a matview refresh would have failed under the permissions prevailing at dump time, it'll fail during restore as well. We'll define that as user error rather than something we should try to work around.) To avoid performance loss in parallel restore, we need the matview refreshes to still be parallelizable. Hence, clean things up enough so that both ACLs and matviews are handled by the parallel restore infrastructure, instead of reverting back to serial restore for ACLs. There is still a final serial step, but it shouldn't normally have to do anything; it's only there to try to recover if we get stuck due to some problem like unresolved circular dependencies. Patch by me, but it owes something to an earlier attempt by Kevin Grittner. Back-patch to 9.3 where materialized views were introduced. Discussion: https://postgr.es/m/28572.1500912583@sss.pgh.pa.us --- src/bin/pg_dump/pg_backup_archiver.c | 372 +++++++++++++++++---------- src/bin/pg_dump/pg_backup_archiver.h | 25 ++ 2 files changed, 266 insertions(+), 131 deletions(-) diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c index f2b544871e..3b8b950f6d 100644 --- a/src/bin/pg_dump/pg_backup_archiver.c +++ b/src/bin/pg_dump/pg_backup_archiver.c @@ -59,7 +59,7 @@ static ArchiveHandle *_allocAH(const char *FileSpec, const ArchiveFormat fmt, const int compression, ArchiveMode mode, SetupWorkerPtr setupWorkerPtr); static void _getObjectDescription(PQExpBuffer buf, TocEntry *te, ArchiveHandle *AH); -static void _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData, bool acl_pass); +static void _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData); static char *replace_line_endings(const char *str); static void _doSetFixedOutputState(ArchiveHandle *AH); static void _doSetSessionAuth(ArchiveHandle *AH, const char *user); @@ -72,6 +72,7 @@ static void _selectTablespace(ArchiveHandle *AH, const char *tablespace); static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te); static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te); static teReqs _tocEntryRequired(TocEntry *te, teSection curSection, RestoreOptions *ropt); +static RestorePass _tocEntryRestorePass(TocEntry *te); static bool _tocEntryIsACL(TocEntry *te); static void _disableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te); static void _enableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te); @@ -87,13 +88,18 @@ static OutputContext SaveOutput(ArchiveHandle *AH); static void RestoreOutput(ArchiveHandle *AH, OutputContext savedContext); static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel); -static void restore_toc_entries_prefork(ArchiveHandle *AH); -static void restore_toc_entries_parallel(ArchiveHandle *AH, ParallelState *pstate, +static void restore_toc_entries_prefork(ArchiveHandle *AH, + TocEntry *pending_list); +static void restore_toc_entries_parallel(ArchiveHandle *AH, + ParallelState *pstate, + TocEntry *pending_list); +static void restore_toc_entries_postfork(ArchiveHandle *AH, TocEntry *pending_list); -static void restore_toc_entries_postfork(ArchiveHandle *AH, TocEntry *pending_list); static void par_list_header_init(TocEntry *l); static void par_list_append(TocEntry *l, TocEntry *te); static void par_list_remove(TocEntry *te); +static void move_to_ready_list(TocEntry *pending_list, TocEntry *ready_list, + RestorePass pass); static TocEntry *get_next_work_item(ArchiveHandle *AH, TocEntry *ready_list, ParallelState *pstate); @@ -616,20 +622,18 @@ RestoreArchive(Archive *AHX) AH->currSchema = NULL; } - /* - * In serial mode, we now process each non-ACL TOC entry. - * - * In parallel mode, turn control over to the parallel-restore logic. - */ if (parallel_mode) { + /* + * In parallel mode, turn control over to the parallel-restore logic. + */ ParallelState *pstate; TocEntry pending_list; par_list_header_init(&pending_list); /* This runs PRE_DATA items and then disconnects from the database */ - restore_toc_entries_prefork(AH); + restore_toc_entries_prefork(AH, &pending_list); Assert(AH->connection == NULL); /* ParallelBackupStart() will actually fork the processes */ @@ -643,28 +647,51 @@ RestoreArchive(Archive *AHX) } else { + /* + * In serial mode, process everything in three phases: normal items, + * then ACLs, then matview refresh items. We might be able to skip + * one or both extra phases in some cases, eg data-only restores. + */ + bool haveACL = false; + bool haveRefresh = false; + for (te = AH->toc->next; te != AH->toc; te = te->next) - (void) restore_toc_entry(AH, te, false); - } + { + if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) == 0) + continue; /* ignore if not to be dumped at all */ - /* - * Scan TOC again to output ownership commands and ACLs - */ - for (te = AH->toc->next; te != AH->toc; te = te->next) - { - AH->currentTE = te; + switch (_tocEntryRestorePass(te)) + { + case RESTORE_PASS_MAIN: + (void) restore_toc_entry(AH, te, false); + break; + case RESTORE_PASS_ACL: + haveACL = true; + break; + case RESTORE_PASS_REFRESH: + haveRefresh = true; + break; + } + } - /* Both schema and data objects might now have ownership/ACLs */ - if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0) + if (haveACL) { - /* Show namespace if available */ - if (te->namespace) - ahlog(AH, 1, "setting owner and privileges for %s \"%s.%s\"\n", - te->desc, te->namespace, te->tag); - else - ahlog(AH, 1, "setting owner and privileges for %s \"%s\"\n", - te->desc, te->tag); - _printTocEntry(AH, te, false, true); + for (te = AH->toc->next; te != AH->toc; te = te->next) + { + if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0 && + _tocEntryRestorePass(te) == RESTORE_PASS_ACL) + (void) restore_toc_entry(AH, te, false); + } + } + + if (haveRefresh) + { + for (te = AH->toc->next; te != AH->toc; te = te->next) + { + if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0 && + _tocEntryRestorePass(te) == RESTORE_PASS_REFRESH) + (void) restore_toc_entry(AH, te, false); + } } } @@ -711,10 +738,7 @@ restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel) AH->currentTE = te; /* Work out what, if anything, we want from this entry */ - if (_tocEntryIsACL(te)) - reqs = 0; /* ACLs are never restored here */ - else - reqs = te->reqs; + reqs = te->reqs; /* * Ignore DATABASE entry unless we should create it. We must check this @@ -735,17 +759,19 @@ restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel) defnDumped = false; - if ((reqs & REQ_SCHEMA) != 0) /* We want the schema */ + /* + * If it has a schema component that we want, then process that + */ + if ((reqs & REQ_SCHEMA) != 0) { - /* Show namespace if available */ + /* Show namespace in log message if available */ if (te->namespace) ahlog(AH, 1, "creating %s \"%s.%s\"\n", te->desc, te->namespace, te->tag); else ahlog(AH, 1, "creating %s \"%s\"\n", te->desc, te->tag); - - _printTocEntry(AH, te, false, false); + _printTocEntry(AH, te, false); defnDumped = true; if (strcmp(te->desc, "TABLE") == 0) @@ -801,7 +827,7 @@ restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel) } /* - * If we have a data component, then process it + * If it has a data component that we want, then process that */ if ((reqs & REQ_DATA) != 0) { @@ -817,7 +843,7 @@ restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel) */ if (AH->PrintTocDataPtr !=NULL) { - _printTocEntry(AH, te, true, false); + _printTocEntry(AH, te, true); if (strcmp(te->desc, "BLOBS") == 0 || strcmp(te->desc, "BLOB COMMENTS") == 0) @@ -905,7 +931,7 @@ restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel) { /* If we haven't already dumped the defn part, do so now */ ahlog(AH, 1, "executing %s %s\n", te->desc, te->tag); - _printTocEntry(AH, te, false, false); + _printTocEntry(AH, te, false); } } @@ -2897,8 +2923,30 @@ _tocEntryRequired(TocEntry *te, teSection curSection, RestoreOptions *ropt) return res; } +/* + * Identify which pass we should restore this TOC entry in. + * + * See notes with the RestorePass typedef in pg_backup_archiver.h. + */ +static RestorePass +_tocEntryRestorePass(TocEntry *te) +{ + /* "ACL LANGUAGE" was a crock emitted only in PG 7.4 */ + if (strcmp(te->desc, "ACL") == 0 || + strcmp(te->desc, "ACL LANGUAGE") == 0 || + strcmp(te->desc, "DEFAULT ACL") == 0) + return RESTORE_PASS_ACL; + if (strcmp(te->desc, "MATERIALIZED VIEW DATA") == 0) + return RESTORE_PASS_REFRESH; + return RESTORE_PASS_MAIN; +} + /* * Identify TOC entries that are ACLs. + * + * Note: it seems worth duplicating some code here to avoid a hard-wired + * assumption that these are exactly the same entries that we restore during + * the RESTORE_PASS_ACL phase. */ static bool _tocEntryIsACL(TocEntry *te) @@ -3316,23 +3364,18 @@ _getObjectDescription(PQExpBuffer buf, TocEntry *te, ArchiveHandle *AH) type); } +/* + * Emit the SQL commands to create the object represented by a TOC entry + * + * This now also includes issuing an ALTER OWNER command to restore the + * object's ownership, if wanted. But note that the object's permissions + * will remain at default, until the matching ACL TOC entry is restored. + */ static void -_printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData, bool acl_pass) +_printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData) { RestoreOptions *ropt = AH->public.ropt; - /* ACLs are dumped only during acl pass */ - if (acl_pass) - { - if (!_tocEntryIsACL(te)) - return; - } - else - { - if (_tocEntryIsACL(te)) - return; - } - /* * Avoid dumping the public schema, as it will already be created ... * unless we are using --clean mode (and *not* --create mode), in which @@ -3516,7 +3559,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData, bool acl_pass) * If it's an ACL entry, it might contain SET SESSION AUTHORIZATION * commands, so we can no longer assume we know the current auth setting. */ - if (acl_pass) + if (_tocEntryIsACL(te)) { if (AH->currUser) free(AH->currUser); @@ -3546,6 +3589,9 @@ replace_line_endings(const char *str) return result; } +/* + * Write the file header for a custom-format archive + */ void WriteHead(ArchiveHandle *AH) { @@ -3717,16 +3763,14 @@ dumpTimestamp(ArchiveHandle *AH, const char *msg, time_t tim) /* * Main engine for parallel restore. * - * Work is done in three phases. - * First we process all SECTION_PRE_DATA tocEntries, in a single connection, - * just as for a standard restore. Second we process the remaining non-ACL - * steps in parallel worker children (threads on Windows, processes on Unix), - * each of which connects separately to the database. Finally we process all - * the ACL entries in a single connection (that happens back in - * RestoreArchive). + * Parallel restore is done in three phases. In this first phase, + * we'll process all SECTION_PRE_DATA TOC entries that are allowed to be + * processed in the RESTORE_PASS_MAIN pass. (In practice, that's all + * PRE_DATA items other than ACLs.) Entries we can't process now are + * added to the pending_list for later phases to deal with. */ static void -restore_toc_entries_prefork(ArchiveHandle *AH) +restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list) { bool skipped_some; TocEntry *next_work_item; @@ -3744,23 +3788,31 @@ restore_toc_entries_prefork(ArchiveHandle *AH) * about showing all the dependencies of SECTION_PRE_DATA items, so we do * not risk trying to process them out-of-order. * + * Stuff that we can't do immediately gets added to the pending_list. + * Note: we don't yet filter out entries that aren't going to be restored. + * They might participate in dependency chains connecting entries that + * should be restored, so we treat them as live until we actually process + * them. + * * Note: as of 9.2, it should be guaranteed that all PRE_DATA items appear * before DATA items, and all DATA items before POST_DATA items. That is * not certain to be true in older archives, though, so this loop is coded * to not assume it. */ + AH->restorePass = RESTORE_PASS_MAIN; skipped_some = false; for (next_work_item = AH->toc->next; next_work_item != AH->toc; next_work_item = next_work_item->next) { - /* NB: process-or-continue logic must be the inverse of loop below */ + bool do_now = true; + if (next_work_item->section != SECTION_PRE_DATA) { /* DATA and POST_DATA items are just ignored for now */ if (next_work_item->section == SECTION_DATA || next_work_item->section == SECTION_POST_DATA) { + do_now = false; skipped_some = true; - continue; } else { @@ -3771,18 +3823,35 @@ restore_toc_entries_prefork(ArchiveHandle *AH) * comment's dependencies are satisfied, so skip it for now. */ if (skipped_some) - continue; + do_now = false; } } - ahlog(AH, 1, "processing item %d %s %s\n", - next_work_item->dumpId, - next_work_item->desc, next_work_item->tag); + /* + * Also skip items that need to be forced into later passes. We need + * not set skipped_some in this case, since by assumption no main-pass + * items could depend on these. + */ + if (_tocEntryRestorePass(next_work_item) != RESTORE_PASS_MAIN) + do_now = false; + + if (do_now) + { + /* OK, restore the item and update its dependencies */ + ahlog(AH, 1, "processing item %d %s %s\n", + next_work_item->dumpId, + next_work_item->desc, next_work_item->tag); - (void) restore_toc_entry(AH, next_work_item, false); + (void) restore_toc_entry(AH, next_work_item, false); - /* there should be no touch of ready_list here, so pass NULL */ - reduce_dependencies(AH, next_work_item, NULL); + /* there should be no touch of ready_list here, so pass NULL */ + reduce_dependencies(AH, next_work_item, NULL); + } + else + { + /* Nope, so add it to pending_list */ + par_list_append(pending_list, next_work_item); + } } /* @@ -3808,91 +3877,60 @@ restore_toc_entries_prefork(ArchiveHandle *AH) /* * Main engine for parallel restore. * - * Work is done in three phases. - * First we process all SECTION_PRE_DATA tocEntries, in a single connection, - * just as for a standard restore. This is done in restore_toc_entries_prefork(). - * Second we process the remaining non-ACL steps in parallel worker children - * (threads on Windows, processes on Unix), these fork off and set up their - * connections before we call restore_toc_entries_parallel_forked. - * Finally we process all the ACL entries in a single connection (that happens - * back in RestoreArchive). + * Parallel restore is done in three phases. In this second phase, + * we process entries by dispatching them to parallel worker children + * (processes on Unix, threads on Windows), each of which connects + * separately to the database. Inter-entry dependencies are respected, + * and so is the RestorePass multi-pass structure. When we can no longer + * make any entries ready to process, we exit. Normally, there will be + * nothing left to do; but if there is, the third phase will mop up. */ static void restore_toc_entries_parallel(ArchiveHandle *AH, ParallelState *pstate, TocEntry *pending_list) { - int work_status; - bool skipped_some; TocEntry ready_list; TocEntry *next_work_item; - int ret_child; ahlog(AH, 2, "entering restore_toc_entries_parallel\n"); /* - * Initialize the lists of ready items, the list for pending items has - * already been initialized in the caller. After this setup, the pending - * list is everything that needs to be done but is blocked by one or more - * dependencies, while the ready list contains items that have no - * remaining dependencies. Note: we don't yet filter out entries that - * aren't going to be restored. They might participate in dependency - * chains connecting entries that should be restored, so we treat them as - * live until we actually process them. + * The pending_list contains all items that we need to restore. Move all + * items that are available to process immediately into the ready_list. + * After this setup, the pending list is everything that needs to be done + * but is blocked by one or more dependencies, while the ready list + * contains items that have no remaining dependencies and are OK to + * process in the current restore pass. */ par_list_header_init(&ready_list); - skipped_some = false; - for (next_work_item = AH->toc->next; next_work_item != AH->toc; next_work_item = next_work_item->next) - { - /* NB: process-or-continue logic must be the inverse of loop above */ - if (next_work_item->section == SECTION_PRE_DATA) - { - /* All PRE_DATA items were dealt with above */ - continue; - } - if (next_work_item->section == SECTION_DATA || - next_work_item->section == SECTION_POST_DATA) - { - /* set this flag at same point that previous loop did */ - skipped_some = true; - } - else - { - /* SECTION_NONE items must be processed if previous loop didn't */ - if (!skipped_some) - continue; - } - - if (next_work_item->depCount > 0) - par_list_append(pending_list, next_work_item); - else - par_list_append(&ready_list, next_work_item); - } + AH->restorePass = RESTORE_PASS_MAIN; + move_to_ready_list(pending_list, &ready_list, AH->restorePass); /* * main parent loop * * Keep going until there is no worker still running AND there is no work - * left to be done. + * left to be done. Note invariant: at top of loop, there should always + * be at least one worker available to dispatch a job to. */ - ahlog(AH, 1, "entering main parallel loop\n"); - while ((next_work_item = get_next_work_item(AH, &ready_list, pstate)) != NULL || - !IsEveryWorkerIdle(pstate)) + for (;;) { + /* Look for an item ready to be dispatched to a worker */ + next_work_item = get_next_work_item(AH, &ready_list, pstate); if (next_work_item != NULL) { /* If not to be restored, don't waste time launching a worker */ - if ((next_work_item->reqs & (REQ_SCHEMA | REQ_DATA)) == 0 || - _tocEntryIsACL(next_work_item)) + if ((next_work_item->reqs & (REQ_SCHEMA | REQ_DATA)) == 0) { ahlog(AH, 1, "skipping item %d %s %s\n", next_work_item->dumpId, next_work_item->desc, next_work_item->tag); - + /* Drop it from ready_list, and update its dependencies */ par_list_remove(next_work_item); reduce_dependencies(AH, next_work_item, &ready_list); - + /* Loop around to see if anything else can be dispatched */ continue; } @@ -3900,18 +3938,40 @@ restore_toc_entries_parallel(ArchiveHandle *AH, ParallelState *pstate, next_work_item->dumpId, next_work_item->desc, next_work_item->tag); + /* Remove it from ready_list, and dispatch to some worker */ par_list_remove(next_work_item); DispatchJobForTocEntry(AH, pstate, next_work_item, ACT_RESTORE); } + else if (IsEveryWorkerIdle(pstate)) + { + /* + * Nothing is ready and no worker is running, so we're done with + * the current pass or maybe with the whole process. + */ + if (AH->restorePass == RESTORE_PASS_LAST) + break; /* No more parallel processing is possible */ + + /* Advance to next restore pass */ + AH->restorePass++; + /* That probably allows some stuff to be made ready */ + move_to_ready_list(pending_list, &ready_list, AH->restorePass); + /* Loop around to see if anything's now ready */ + continue; + } else { - /* at least one child is working and we have nothing ready. */ + /* + * We have nothing ready, but at least one child is working, so + * wait for some subjob to finish. + */ } for (;;) { int nTerm = 0; + int ret_child; + int work_status; /* * In order to reduce dependencies as soon as possible and @@ -3952,9 +4012,21 @@ restore_toc_entries_parallel(ArchiveHandle *AH, ParallelState *pstate, } } + /* There should now be nothing in ready_list. */ + Assert(ready_list.par_next == &ready_list); + ahlog(AH, 1, "finished main parallel loop\n"); } +/* + * Main engine for parallel restore. + * + * Parallel restore is done in three phases. In this third phase, + * we mop up any remaining TOC entries by processing them serially. + * This phase normally should have nothing to do, but if we've somehow + * gotten stuck due to circular dependencies or some such, this provides + * at least some chance of completing the restore successfully. + */ static void restore_toc_entries_postfork(ArchiveHandle *AH, TocEntry *pending_list) { @@ -3974,9 +4046,10 @@ restore_toc_entries_postfork(ArchiveHandle *AH, TocEntry *pending_list) _doSetFixedOutputState(AH); /* - * Make sure there is no non-ACL work left due to, say, circular - * dependencies, or some other pathological condition. If so, do it in the - * single parent connection. + * Make sure there is no work left due to, say, circular dependencies, or + * some other pathological condition. If so, do it in the single parent + * connection. We don't sweat about RestorePass ordering; it's likely we + * already violated that. */ for (te = pending_list->par_next; te != pending_list; te = te->par_next) { @@ -3984,8 +4057,6 @@ restore_toc_entries_postfork(ArchiveHandle *AH, TocEntry *pending_list) te->dumpId, te->desc, te->tag); (void) restore_toc_entry(AH, te, false); } - - /* The ACLs will be handled back in RestoreArchive. */ } /* @@ -4044,6 +4115,36 @@ par_list_remove(TocEntry *te) } +/* + * Move all immediately-ready items from pending_list to ready_list. + * + * Items are considered ready if they have no remaining dependencies and + * they belong in the current restore pass. (See also reduce_dependencies, + * which applies the same logic one-at-a-time.) + */ +static void +move_to_ready_list(TocEntry *pending_list, TocEntry *ready_list, + RestorePass pass) +{ + TocEntry *te; + TocEntry *next_te; + + for (te = pending_list->par_next; te != pending_list; te = next_te) + { + /* must save list link before possibly moving te to other list */ + next_te = te->par_next; + + if (te->depCount == 0 && + _tocEntryRestorePass(te) == pass) + { + /* Remove it from pending_list ... */ + par_list_remove(te); + /* ... and add to ready_list */ + par_list_append(ready_list, te); + } + } +} + /* * Find the next work item (if any) that is capable of being run now. * @@ -4433,8 +4534,17 @@ reduce_dependencies(ArchiveHandle *AH, TocEntry *te, TocEntry *ready_list) { TocEntry *otherte = AH->tocsByDumpId[te->revDeps[i]]; + Assert(otherte->depCount > 0); otherte->depCount--; - if (otherte->depCount == 0 && otherte->par_prev != NULL) + + /* + * It's ready if it has no remaining dependencies and it belongs in + * the current restore pass. However, don't move it if it has not yet + * been put into the pending list. + */ + if (otherte->depCount == 0 && + _tocEntryRestorePass(otherte) == AH->restorePass && + otherte->par_prev != NULL) { /* It must be in the pending list, so remove it ... */ par_list_remove(otherte); diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h index 0376f2bff7..5eb1fc4949 100644 --- a/src/bin/pg_dump/pg_backup_archiver.h +++ b/src/bin/pg_dump/pg_backup_archiver.h @@ -200,6 +200,30 @@ typedef enum OUTPUT_OTHERDATA /* writing data as INSERT commands */ } ArchiverOutput; +/* + * For historical reasons, ACL items are interspersed with everything else in + * a dump file's TOC; typically they're right after the object they're for. + * However, we need to restore data before ACLs, as otherwise a read-only + * table (ie one where the owner has revoked her own INSERT privilege) causes + * data restore failures. On the other hand, matview REFRESH commands should + * come out after ACLs, as otherwise non-superuser-owned matviews might not + * be able to execute. (If the permissions at the time of dumping would not + * allow a REFRESH, too bad; we won't fix that for you.) These considerations + * force us to make three passes over the TOC, restoring the appropriate + * subset of items in each pass. We assume that the dependency sort resulted + * in an appropriate ordering of items within each subset. + * XXX This mechanism should be superseded by tracking dependencies on ACLs + * properly; but we'll still need it for old dump files even after that. + */ +typedef enum +{ + RESTORE_PASS_MAIN = 0, /* Main pass (most TOC item types) */ + RESTORE_PASS_ACL, /* ACL item types */ + RESTORE_PASS_REFRESH /* Matview REFRESH items */ + +#define RESTORE_PASS_LAST RESTORE_PASS_REFRESH +} RestorePass; + typedef enum { REQ_SCHEMA = 0x01, /* want schema */ @@ -331,6 +355,7 @@ struct _archiveHandle int noTocComments; ArchiverStage stage; ArchiverStage lastErrorStage; + RestorePass restorePass; /* used only during parallel restore */ struct _tocEntry *currentTE; struct _tocEntry *lastErrorTE; }; From df04db0413589491e5261d229c448e9faec1342e Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Thu, 3 Aug 2017 20:49:07 -0400 Subject: [PATCH 0179/1139] Add missing ALTER USER variants ALTER USER ... SET did not support all the syntax variants of ALTER ROLE ... SET. Reported-by: Pavel Golub --- doc/src/sgml/ref/alter_user.sgml | 8 ++++---- src/backend/parser/gram.y | 14 +++++++++++--- src/test/regress/expected/rolenames.out | 10 ++-------- 3 files changed, 17 insertions(+), 15 deletions(-) diff --git a/doc/src/sgml/ref/alter_user.sgml b/doc/src/sgml/ref/alter_user.sgml index 5962a8e166..50bfae6cc3 100644 --- a/doc/src/sgml/ref/alter_user.sgml +++ b/doc/src/sgml/ref/alter_user.sgml @@ -38,10 +38,10 @@ ALTER USER role_specification [ WIT ALTER USER name RENAME TO new_name -ALTER USER role_specification SET configuration_parameter { TO | = } { value | DEFAULT } -ALTER USER role_specification SET configuration_parameter FROM CURRENT -ALTER USER role_specification RESET configuration_parameter -ALTER USER role_specification RESET ALL +ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter { TO | = } { value | DEFAULT } +ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter FROM CURRENT +ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] RESET configuration_parameter +ALTER USER { role_specification | ALL } [ IN DATABASE database_name ] RESET ALL where role_specification can be: diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index c080cf9ea0..9e170f7536 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -1111,12 +1111,20 @@ AlterUserStmt: AlterUserSetStmt: - ALTER USER RoleSpec SetResetClause + ALTER USER RoleSpec opt_in_database SetResetClause { AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt); n->role = $3; - n->database = NULL; - n->setstmt = $4; + n->database = $4; + n->setstmt = $5; + $$ = (Node *)n; + } + | ALTER USER ALL opt_in_database SetResetClause + { + AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt); + n->role = NULL; + n->database = $4; + n->setstmt = $5; $$ = (Node *)n; } ; diff --git a/src/test/regress/expected/rolenames.out b/src/test/regress/expected/rolenames.out index fd058e4f7d..dce82f5de7 100644 --- a/src/test/regress/expected/rolenames.out +++ b/src/test/regress/expected/rolenames.out @@ -310,9 +310,9 @@ ERROR: syntax error at or near "CURRENT_ROLE" LINE 1: ALTER USER CURRENT_ROLE WITH LOGIN; ^ ALTER USER ALL WITH REPLICATION; -- error -ERROR: syntax error at or near "ALL" +ERROR: syntax error at or near "WITH" LINE 1: ALTER USER ALL WITH REPLICATION; - ^ + ^ ALTER USER SESSION_ROLE WITH NOREPLICATION; -- error ERROR: role "session_role" does not exist ALTER USER PUBLIC WITH NOREPLICATION; -- error @@ -392,9 +392,6 @@ ALTER USER SESSION_USER SET application_name to 'BAR'; ALTER USER "current_user" SET application_name to 'FOOFOO'; ALTER USER "Public" SET application_name to 'BARBAR'; ALTER USER ALL SET application_name to 'SLAP'; -ERROR: syntax error at or near "ALL" -LINE 1: ALTER USER ALL SET application_name to 'SLAP'; - ^ SELECT * FROM chksetconfig(); db | role | rolkeyword | setconfig -----+------------------+--------------+--------------------------- @@ -419,9 +416,6 @@ ALTER USER SESSION_USER RESET application_name; ALTER USER "current_user" RESET application_name; ALTER USER "Public" RESET application_name; ALTER USER ALL RESET application_name; -ERROR: syntax error at or near "ALL" -LINE 1: ALTER USER ALL RESET application_name; - ^ SELECT * FROM chksetconfig(); db | role | rolkeyword | setconfig ----+------+------------+----------- From b798ea88ac6e924363b7b12b6b847b302a76fb31 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 4 Aug 2017 11:07:10 -0400 Subject: [PATCH 0180/1139] Disallow SSL session tickets. We don't actually support session tickets, since we do not create an SSL session identifier. But it seems that OpenSSL will issue a session ticket on-demand anyway, which will then fail when used. This results in reconnection failures when using ticket-aware client-side SSL libraries (such as the Npgsql .NET driver), as reported by Shay Rojansky. To fix, just tell OpenSSL not to issue tickets. At some point in the far future, we might consider enabling tickets instead. But the security implications of that aren't entirely clear; and besides it would have little benefit except for very short-lived database connections, which is Something We're Bad At anyhow. It would take a lot of other work to get to a point where that would really be an exciting thing to do. While at it, also tell OpenSSL not to use a session cache. This doesn't really do anything, since a backend would never populate the cache anyway, but it might gain some micro-efficiencies and/or reduce security exposures. Patch by me, per discussion with Heikki Linnakangas and Shay Rojansky. Back-patch to all supported versions. Discussion: https://postgr.es/m/CADT4RqBU8N-csyZuzaook-c795dt22Zcwg1aHWB6tfVdAkodZA@mail.gmail.com --- src/backend/libpq/be-secure-openssl.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/backend/libpq/be-secure-openssl.c b/src/backend/libpq/be-secure-openssl.c index 2ff9d1cf85..5a174bbe84 100644 --- a/src/backend/libpq/be-secure-openssl.c +++ b/src/backend/libpq/be-secure-openssl.c @@ -270,6 +270,14 @@ be_tls_init(void) SSL_OP_SINGLE_DH_USE | SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3); + /* disallow SSL session tickets */ +#ifdef SSL_OP_NO_TICKET /* added in openssl 0.9.8f */ + SSL_CTX_set_options(SSL_context, SSL_OP_NO_TICKET); +#endif + + /* disallow SSL session caching, too */ + SSL_CTX_set_session_cache_mode(SSL_context, SSL_SESS_CACHE_OFF); + /* set up ephemeral ECDH keys */ initialize_ecdh(); From f27449fcca947c5a7340a0e41d105584d6505adb Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Sat, 5 Aug 2017 14:41:40 -0700 Subject: [PATCH 0181/1139] Add regression test for wide REPLICA IDENTITY FULL updates. This just contains the regression tests added by a fix for a 9.4 specific bug regarding $subject. Author: Andres Freund Backpatch: 9.5- --- contrib/test_decoding/expected/toast.out | 8 +++++++- contrib/test_decoding/sql/toast.sql | 3 ++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/contrib/test_decoding/expected/toast.out b/contrib/test_decoding/expected/toast.out index 389748ff8c..91a9a1e86d 100644 --- a/contrib/test_decoding/expected/toast.out +++ b/contrib/test_decoding/expected/toast.out @@ -305,7 +305,13 @@ ALTER TABLE toasted_several REPLICA IDENTITY FULL; ALTER TABLE toasted_several ALTER COLUMN toasted_key SET STORAGE EXTERNAL; ALTER TABLE toasted_several ALTER COLUMN toasted_col1 SET STORAGE EXTERNAL; ALTER TABLE toasted_several ALTER COLUMN toasted_col2 SET STORAGE EXTERNAL; -INSERT INTO toasted_several(toasted_key) VALUES(repeat('9876543210', 2000)); +INSERT INTO toasted_several(toasted_key) VALUES(repeat('9876543210', 10000)); +SELECT pg_column_size(toasted_key) > 2^16 FROM toasted_several; + ?column? +---------- + t +(1 row) + SELECT regexp_replace(data, '^(.{100}).*(.{100})$', '\1..\2') FROM pg_logical_slot_peek_changes('regression_slot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1'); regexp_replace ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ diff --git a/contrib/test_decoding/sql/toast.sql b/contrib/test_decoding/sql/toast.sql index dcb74e38c7..ef11d2bfff 100644 --- a/contrib/test_decoding/sql/toast.sql +++ b/contrib/test_decoding/sql/toast.sql @@ -279,7 +279,8 @@ ALTER TABLE toasted_several ALTER COLUMN toasted_key SET STORAGE EXTERNAL; ALTER TABLE toasted_several ALTER COLUMN toasted_col1 SET STORAGE EXTERNAL; ALTER TABLE toasted_several ALTER COLUMN toasted_col2 SET STORAGE EXTERNAL; -INSERT INTO toasted_several(toasted_key) VALUES(repeat('9876543210', 2000)); +INSERT INTO toasted_several(toasted_key) VALUES(repeat('9876543210', 10000)); +SELECT pg_column_size(toasted_key) > 2^16 FROM toasted_several; SELECT regexp_replace(data, '^(.{100}).*(.{100})$', '\1..\2') FROM pg_logical_slot_peek_changes('regression_slot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1'); From 32d7480e02eef139265ece8c2b8842c0b3cb1127 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Sat, 5 Aug 2017 20:52:53 -0700 Subject: [PATCH 0182/1139] Fix thinko introduced in 2bef06d516460 et al. The callers for GetOldestSafeDecodingTransactionId() all inverted the argument for the argument introduced in 2bef06d516460. Luckily this appears to be inconsequential for the moment, as we wait for concurrent in-progress transaction when assembling a snapshot. Additionally this could only make a difference when adding a second logical slot, because only a pre-existing slot could cause an issue by lowering the returned xid dangerously much. Reported-By: Antonin Houska Discussion: https://postgr.es/m/32704.1496993134@localhost Backport: 9.4-, where 2bef06d516460 was backpatched to. --- src/backend/replication/logical/logical.c | 2 +- src/backend/replication/logical/snapbuild.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c index 3ea80253d3..f44533eb7f 100644 --- a/src/backend/replication/logical/logical.c +++ b/src/backend/replication/logical/logical.c @@ -284,7 +284,7 @@ CreateInitDecodingContext(char *plugin, */ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); - xmin_horizon = GetOldestSafeDecodingTransactionId(need_full_snapshot); + xmin_horizon = GetOldestSafeDecodingTransactionId(!need_full_snapshot); slot->effective_catalog_xmin = xmin_horizon; slot->data.catalog_xmin = xmin_horizon; diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c index 43ec8e4943..901e95ede4 100644 --- a/src/backend/replication/logical/snapbuild.c +++ b/src/backend/replication/logical/snapbuild.c @@ -592,7 +592,7 @@ SnapBuildExportSnapshot(SnapBuild *builder) TransactionId safeXid; LWLockAcquire(ProcArrayLock, LW_SHARED); - safeXid = GetOldestSafeDecodingTransactionId(true); + safeXid = GetOldestSafeDecodingTransactionId(false); LWLockRelease(ProcArrayLock); Assert(TransactionIdPrecedesOrEquals(safeXid, snap->xmin)); From 49c19351071a59dd4843c577056f89eb2a358f1a Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 6 Aug 2017 17:56:49 -0400 Subject: [PATCH 0183/1139] Release notes for 9.6.4, 9.5.8, 9.4.13, 9.3.18, 9.2.22. --- doc/src/sgml/release-9.2.sgml | 341 ++++++++++ doc/src/sgml/release-9.3.sgml | 434 +++++++++++++ doc/src/sgml/release-9.4.sgml | 534 ++++++++++++++++ doc/src/sgml/release-9.5.sgml | 568 +++++++++++++++++ doc/src/sgml/release-9.6.sgml | 1117 +++++++++++++++++++++++++++++++++ 5 files changed, 2994 insertions(+) diff --git a/doc/src/sgml/release-9.2.sgml b/doc/src/sgml/release-9.2.sgml index 804882bd2e..96b073f81e 100644 --- a/doc/src/sgml/release-9.2.sgml +++ b/doc/src/sgml/release-9.2.sgml @@ -1,6 +1,347 @@ + + Release 9.2.22 + + + Release date: + 2017-08-10 + + + + This release contains a variety of fixes from 9.2.21. + For information about new features in the 9.2 major release, see + . + + + + The PostgreSQL community will stop releasing updates + for the 9.2.X release series in September 2017. + Users are encouraged to update to a newer release branch soon. + + + + Migration to Version 9.2.22 + + + A dump/restore is not required for those running 9.2.X. + + + + However, if you are upgrading from a version earlier than 9.2.20, + see . + + + + + + Changes + + + + + + On Windows, retry process creation if we fail to reserve the address + range for our shared memory in the new process (Tom Lane, Amit + Kapila) + + + + This is expected to fix infrequent child-process-launch failures that + are probably due to interference from antivirus products. + + + + + + Fix low-probability corruption of shared predicate-lock hash table + in Windows builds (Thomas Munro, Tom Lane) + + + + + + Avoid logging clean closure of an SSL connection as though + it were a connection reset (Michael Paquier) + + + + + + Prevent sending SSL session tickets to clients (Tom Lane) + + + + This fix prevents reconnection failures with ticket-aware client-side + SSL code. + + + + + + Fix code for setting on + Solaris (Tom Lane) + + + + + + Fix statistics collector to honor inquiry messages issued just after + a postmaster shutdown and immediate restart (Tom Lane) + + + + Statistics inquiries issued within half a second of the previous + postmaster shutdown were effectively ignored. + + + + + + Ensure that the statistics collector's receive buffer size is at + least 100KB (Tom Lane) + + + + This reduces the risk of dropped statistics data on older platforms + whose default receive buffer size is less than that. + + + + + + Fix possible creation of an invalid WAL segment when a standby is + promoted just after it processes an XLOG_SWITCH WAL + record (Andres Freund) + + + + + + Fix SIGHUP and SIGUSR1 handling in + walsender processes (Petr Jelinek, Andres Freund) + + + + + + Fix unnecessarily slow restarts of walreceiver + processes due to race condition in postmaster (Tom Lane) + + + + + + Fix cases where an INSERT or UPDATE assigns + to more than one element of a column that is of domain-over-array + type (Tom Lane) + + + + + + Move autogenerated array types out of the way during + ALTER ... RENAME (Vik Fearing) + + + + Previously, we would rename a conflicting autogenerated array type + out of the way during CREATE; this fix extends that + behavior to renaming operations. + + + + + + Ensure that ALTER USER ... SET accepts all the syntax + variants that ALTER ROLE ... SET does (Peter Eisentraut) + + + + + + Properly update dependency info when changing a datatype I/O + function's argument or return type from opaque to the + correct type (Heikki Linnakangas) + + + + CREATE TYPE updates I/O functions declared in this + long-obsolete style, but it forgot to record a dependency on the + type, allowing a subsequent DROP TYPE to leave broken + function definitions behind. + + + + + + Reduce memory usage when ANALYZE processes + a tsvector column (Heikki Linnakangas) + + + + + + Fix unnecessary precision loss and sloppy rounding when multiplying + or dividing money values by integers or floats (Tom Lane) + + + + + + Tighten checks for whitespace in functions that parse identifiers, + such as regprocedurein() (Tom Lane) + + + + Depending on the prevailing locale, these functions could + misinterpret fragments of multibyte characters as whitespace. + + + + + + Use relevant #define symbols from Perl while + compiling PL/Perl (Ashutosh Sharma, Tom Lane) + + + + This avoids portability problems, typically manifesting as + a handshake mismatch during library load, when working with + recent Perl versions. + + + + + + In psql, fix failure when COPY FROM STDIN + is ended with a keyboard EOF signal and then another COPY + FROM STDIN is attempted (Thomas Munro) + + + + This misbehavior was observed on BSD-derived platforms (including + macOS), but not on most others. + + + + + + Fix pg_dump to not emit invalid SQL for an empty + operator class (Daniel Gustafsson) + + + + + + Fix pg_dump output to stdout on Windows (Kuntal Ghosh) + + + + A compressed plain-text dump written to stdout would contain corrupt + data due to failure to put the file descriptor into binary mode. + + + + + + Fix pg_get_ruledef() to print correct output for + the ON SELECT rule of a view whose columns have been + renamed (Tom Lane) + + + + In some corner cases, pg_dump relies + on pg_get_ruledef() to dump views, so that this error + could result in dump/reload failures. + + + + + + Fix dumping of function expressions in the FROM clause in + cases where the expression does not deparse into something that looks + like a function call (Tom Lane) + + + + + + Fix pg_basebackup output to stdout on Windows + (Haribabu Kommi) + + + + A backup written to stdout would contain corrupt data due to failure + to put the file descriptor into binary mode. + + + + + + Fix pg_upgrade to ensure that the ending WAL record + does not have = minimum + (Bruce Momjian) + + + + This condition could prevent upgraded standby servers from + reconnecting. + + + + + + Always use + + + This supports larger extension libraries on platforms where it makes + a difference. + + + + + + Fix unescaped-braces issue in our build scripts for Microsoft MSVC, + to avoid a warning or error from recent Perl versions (Andrew + Dunstan) + + + + + + In MSVC builds, handle the case where the openssl + library is not within a VC subdirectory (Andrew Dunstan) + + + + + + In MSVC builds, add proper include path for libxml2 + header files (Andrew Dunstan) + + + + This fixes a former need to move things around in standard Windows + installations of libxml2. + + + + + + In MSVC builds, recognize a Tcl library that is + named tcl86.lib (Noah Misch) + + + + + + + + Release 9.2.21 diff --git a/doc/src/sgml/release-9.3.sgml b/doc/src/sgml/release-9.3.sgml index 700ca08114..80d4864230 100644 --- a/doc/src/sgml/release-9.3.sgml +++ b/doc/src/sgml/release-9.3.sgml @@ -1,6 +1,440 @@ + + Release 9.3.18 + + + Release date: + 2017-08-10 + + + + This release contains a variety of fixes from 9.3.17. + For information about new features in the 9.3 major release, see + . + + + + Migration to Version 9.3.18 + + + A dump/restore is not required for those running 9.3.X. + + + + However, if you are upgrading from a version earlier than 9.3.16, + see . + + + + + + Changes + + + + + + Fix concurrent locking of tuple update chains (Álvaro Herrera) + + + + If several sessions concurrently lock a tuple update chain with + nonconflicting lock modes using an old snapshot, and they all + succeed, it was possible for some of them to nonetheless fail (and + conclude there is no live tuple version) due to a race condition. + This had consequences such as foreign-key checks failing to see a + tuple that definitely exists but is being updated concurrently. + + + + + + Fix potential data corruption when freezing a tuple whose XMAX is a + multixact with exactly one still-interesting member (Teodor Sigaev) + + + + + + On Windows, retry process creation if we fail to reserve the address + range for our shared memory in the new process (Tom Lane, Amit + Kapila) + + + + This is expected to fix infrequent child-process-launch failures that + are probably due to interference from antivirus products. + + + + + + Fix low-probability corruption of shared predicate-lock hash table + in Windows builds (Thomas Munro, Tom Lane) + + + + + + Avoid logging clean closure of an SSL connection as though + it were a connection reset (Michael Paquier) + + + + + + Prevent sending SSL session tickets to clients (Tom Lane) + + + + This fix prevents reconnection failures with ticket-aware client-side + SSL code. + + + + + + Fix code for setting on + Solaris (Tom Lane) + + + + + + Fix statistics collector to honor inquiry messages issued just after + a postmaster shutdown and immediate restart (Tom Lane) + + + + Statistics inquiries issued within half a second of the previous + postmaster shutdown were effectively ignored. + + + + + + Ensure that the statistics collector's receive buffer size is at + least 100KB (Tom Lane) + + + + This reduces the risk of dropped statistics data on older platforms + whose default receive buffer size is less than that. + + + + + + Fix possible creation of an invalid WAL segment when a standby is + promoted just after it processes an XLOG_SWITCH WAL + record (Andres Freund) + + + + + + Fix SIGHUP and SIGUSR1 handling in + walsender processes (Petr Jelinek, Andres Freund) + + + + + + Fix unnecessarily slow restarts of walreceiver + processes due to race condition in postmaster (Tom Lane) + + + + + + Fix cases where an INSERT or UPDATE assigns + to more than one element of a column that is of domain-over-array + type (Tom Lane) + + + + + + Allow window functions to be used in sub-SELECTs that + are within the arguments of an aggregate function (Tom Lane) + + + + + + Move autogenerated array types out of the way during + ALTER ... RENAME (Vik Fearing) + + + + Previously, we would rename a conflicting autogenerated array type + out of the way during CREATE; this fix extends that + behavior to renaming operations. + + + + + + Ensure that ALTER USER ... SET accepts all the syntax + variants that ALTER ROLE ... SET does (Peter Eisentraut) + + + + + + Properly update dependency info when changing a datatype I/O + function's argument or return type from opaque to the + correct type (Heikki Linnakangas) + + + + CREATE TYPE updates I/O functions declared in this + long-obsolete style, but it forgot to record a dependency on the + type, allowing a subsequent DROP TYPE to leave broken + function definitions behind. + + + + + + Reduce memory usage when ANALYZE processes + a tsvector column (Heikki Linnakangas) + + + + + + Fix unnecessary precision loss and sloppy rounding when multiplying + or dividing money values by integers or floats (Tom Lane) + + + + + + Tighten checks for whitespace in functions that parse identifiers, + such as regprocedurein() (Tom Lane) + + + + Depending on the prevailing locale, these functions could + misinterpret fragments of multibyte characters as whitespace. + + + + + + Use relevant #define symbols from Perl while + compiling PL/Perl (Ashutosh Sharma, Tom Lane) + + + + This avoids portability problems, typically manifesting as + a handshake mismatch during library load, when working with + recent Perl versions. + + + + + + In libpq, reset GSS/SASL and SSPI authentication + state properly after a failed connection attempt (Michael Paquier) + + + + Failure to do this meant that when falling back from SSL to non-SSL + connections, a GSS/SASL failure in the SSL attempt would always cause + the non-SSL attempt to fail. SSPI did not fail, but it leaked memory. + + + + + + In psql, fix failure when COPY FROM STDIN + is ended with a keyboard EOF signal and then another COPY + FROM STDIN is attempted (Thomas Munro) + + + + This misbehavior was observed on BSD-derived platforms (including + macOS), but not on most others. + + + + + + Fix pg_dump and pg_restore to + emit REFRESH MATERIALIZED VIEW commands last (Tom Lane) + + + + This prevents errors during dump/restore when a materialized view + refers to tables owned by a different user. + + + + + + Fix pg_dump with the + + + It also now correctly assigns ownership of event triggers; before, + they were restored as being owned by the superuser running the + restore script. + + + + + + Fix pg_dump to not emit invalid SQL for an empty + operator class (Daniel Gustafsson) + + + + + + Fix pg_dump output to stdout on Windows (Kuntal Ghosh) + + + + A compressed plain-text dump written to stdout would contain corrupt + data due to failure to put the file descriptor into binary mode. + + + + + + Fix pg_get_ruledef() to print correct output for + the ON SELECT rule of a view whose columns have been + renamed (Tom Lane) + + + + In some corner cases, pg_dump relies + on pg_get_ruledef() to dump views, so that this error + could result in dump/reload failures. + + + + + + Fix dumping of outer joins with empty constraints, such as the result + of a NATURAL LEFT JOIN with no common columns (Tom Lane) + + + + + + Fix dumping of function expressions in the FROM clause in + cases where the expression does not deparse into something that looks + like a function call (Tom Lane) + + + + + + Fix pg_basebackup output to stdout on Windows + (Haribabu Kommi) + + + + A backup written to stdout would contain corrupt data due to failure + to put the file descriptor into binary mode. + + + + + + Fix pg_upgrade to ensure that the ending WAL record + does not have = minimum + (Bruce Momjian) + + + + This condition could prevent upgraded standby servers from + reconnecting. + + + + + + In postgres_fdw, re-establish connections to remote + servers after ALTER SERVER or ALTER USER + MAPPING commands (Kyotaro Horiguchi) + + + + This ensures that option changes affecting connection parameters will + be applied promptly. + + + + + + In postgres_fdw, allow cancellation of remote + transaction control commands (Robert Haas, Rafia Sabih) + + + + This change allows us to quickly escape a wait for an unresponsive + remote server in many more cases than previously. + + + + + + Always use + + + This supports larger extension libraries on platforms where it makes + a difference. + + + + + + Fix unescaped-braces issue in our build scripts for Microsoft MSVC, + to avoid a warning or error from recent Perl versions (Andrew + Dunstan) + + + + + + In MSVC builds, handle the case where the openssl + library is not within a VC subdirectory (Andrew Dunstan) + + + + + + In MSVC builds, add proper include path for libxml2 + header files (Andrew Dunstan) + + + + This fixes a former need to move things around in standard Windows + installations of libxml2. + + + + + + In MSVC builds, recognize a Tcl library that is + named tcl86.lib (Noah Misch) + + + + + + + + Release 9.3.17 diff --git a/doc/src/sgml/release-9.4.sgml b/doc/src/sgml/release-9.4.sgml index 41644de682..54265e677a 100644 --- a/doc/src/sgml/release-9.4.sgml +++ b/doc/src/sgml/release-9.4.sgml @@ -1,6 +1,540 @@ + + Release 9.4.13 + + + Release date: + 2017-08-10 + + + + This release contains a variety of fixes from 9.4.12. + For information about new features in the 9.4 major release, see + . + + + + Migration to Version 9.4.13 + + + A dump/restore is not required for those running 9.4.X. + + + + However, if you are upgrading from a version earlier than 9.4.12, + see . + + + + + Changes + + + + + + Fix concurrent locking of tuple update chains (Álvaro Herrera) + + + + If several sessions concurrently lock a tuple update chain with + nonconflicting lock modes using an old snapshot, and they all + succeed, it was possible for some of them to nonetheless fail (and + conclude there is no live tuple version) due to a race condition. + This had consequences such as foreign-key checks failing to see a + tuple that definitely exists but is being updated concurrently. + + + + + + Fix potential data corruption when freezing a tuple whose XMAX is a + multixact with exactly one still-interesting member (Teodor Sigaev) + + + + + + Avoid integer overflow and ensuing crash when sorting more than one + billion tuples in-memory (Sergey Koposov) + + + + + + On Windows, retry process creation if we fail to reserve the address + range for our shared memory in the new process (Tom Lane, Amit + Kapila) + + + + This is expected to fix infrequent child-process-launch failures that + are probably due to interference from antivirus products. + + + + + + Fix low-probability corruption of shared predicate-lock hash table + in Windows builds (Thomas Munro, Tom Lane) + + + + + + Avoid logging clean closure of an SSL connection as though + it were a connection reset (Michael Paquier) + + + + + + Prevent sending SSL session tickets to clients (Tom Lane) + + + + This fix prevents reconnection failures with ticket-aware client-side + SSL code. + + + + + + Fix code for setting on + Solaris (Tom Lane) + + + + + + Fix statistics collector to honor inquiry messages issued just after + a postmaster shutdown and immediate restart (Tom Lane) + + + + Statistics inquiries issued within half a second of the previous + postmaster shutdown were effectively ignored. + + + + + + Ensure that the statistics collector's receive buffer size is at + least 100KB (Tom Lane) + + + + This reduces the risk of dropped statistics data on older platforms + whose default receive buffer size is less than that. + + + + + + Fix possible creation of an invalid WAL segment when a standby is + promoted just after it processes an XLOG_SWITCH WAL + record (Andres Freund) + + + + + + Fix walsender to exit promptly when client requests + shutdown (Tom Lane) + + + + + + Fix SIGHUP and SIGUSR1 handling in + walsender processes (Petr Jelinek, Andres Freund) + + + + + + Prevent walsender-triggered panics during shutdown checkpoints + (Andres Freund, Michael Paquier) + + + + + + Fix unnecessarily slow restarts of walreceiver + processes due to race condition in postmaster (Tom Lane) + + + + + + + Fix logical decoding failure with very wide tuples (Andres Freund) + + + + Logical decoding crashed on tuples that are wider than 64KB (after + compression, but with all data in-line). The case arises only + when REPLICA IDENTITY FULL is enabled for a table + containing such tuples. + + + + + + Fix leakage of small subtransactions spilled to disk during logical + decoding (Andres Freund) + + + + This resulted in temporary files consuming excessive disk space. + + + + + + Reduce the work needed to build snapshots during creation of + logical-decoding slots (Andres Freund, Petr Jelinek) + + + + The previous algorithm was infeasibly expensive on a server with a + lot of open transactions. + + + + + + Fix race condition that could indefinitely delay creation of + logical-decoding slots (Andres Freund, Petr Jelinek) + + + + + + Reduce overhead in processing syscache invalidation events (Tom Lane) + + + + This is particularly helpful for logical decoding, which triggers + frequent cache invalidation. + + + + + + Fix cases where an INSERT or UPDATE assigns + to more than one element of a column that is of domain-over-array + type (Tom Lane) + + + + + + Allow window functions to be used in sub-SELECTs that + are within the arguments of an aggregate function (Tom Lane) + + + + + + Move autogenerated array types out of the way during + ALTER ... RENAME (Vik Fearing) + + + + Previously, we would rename a conflicting autogenerated array type + out of the way during CREATE; this fix extends that + behavior to renaming operations. + + + + + + Ensure that ALTER USER ... SET accepts all the syntax + variants that ALTER ROLE ... SET does (Peter Eisentraut) + + + + + + Properly update dependency info when changing a datatype I/O + function's argument or return type from opaque to the + correct type (Heikki Linnakangas) + + + + CREATE TYPE updates I/O functions declared in this + long-obsolete style, but it forgot to record a dependency on the + type, allowing a subsequent DROP TYPE to leave broken + function definitions behind. + + + + + + Reduce memory usage when ANALYZE processes + a tsvector column (Heikki Linnakangas) + + + + + + Fix unnecessary precision loss and sloppy rounding when multiplying + or dividing money values by integers or floats (Tom Lane) + + + + + + Tighten checks for whitespace in functions that parse identifiers, + such as regprocedurein() (Tom Lane) + + + + Depending on the prevailing locale, these functions could + misinterpret fragments of multibyte characters as whitespace. + + + + + + Use relevant #define symbols from Perl while + compiling PL/Perl (Ashutosh Sharma, Tom Lane) + + + + This avoids portability problems, typically manifesting as + a handshake mismatch during library load, when working with + recent Perl versions. + + + + + + In libpq, reset GSS/SASL and SSPI authentication + state properly after a failed connection attempt (Michael Paquier) + + + + Failure to do this meant that when falling back from SSL to non-SSL + connections, a GSS/SASL failure in the SSL attempt would always cause + the non-SSL attempt to fail. SSPI did not fail, but it leaked memory. + + + + + + In psql, fix failure when COPY FROM STDIN + is ended with a keyboard EOF signal and then another COPY + FROM STDIN is attempted (Thomas Munro) + + + + This misbehavior was observed on BSD-derived platforms (including + macOS), but not on most others. + + + + + + Fix pg_dump and pg_restore to + emit REFRESH MATERIALIZED VIEW commands last (Tom Lane) + + + + This prevents errors during dump/restore when a materialized view + refers to tables owned by a different user. + + + + + + Improve pg_dump/pg_restore's + reporting of error conditions originating in zlib + (Vladimir Kunschikov, Álvaro Herrera) + + + + + + Fix pg_dump with the + + + It also now correctly assigns ownership of event triggers; before, + they were restored as being owned by the superuser running the + restore script. + + + + + + Fix pg_dump to not emit invalid SQL for an empty + operator class (Daniel Gustafsson) + + + + + + Fix pg_dump output to stdout on Windows (Kuntal Ghosh) + + + + A compressed plain-text dump written to stdout would contain corrupt + data due to failure to put the file descriptor into binary mode. + + + + + + Fix pg_get_ruledef() to print correct output for + the ON SELECT rule of a view whose columns have been + renamed (Tom Lane) + + + + In some corner cases, pg_dump relies + on pg_get_ruledef() to dump views, so that this error + could result in dump/reload failures. + + + + + + Fix dumping of outer joins with empty constraints, such as the result + of a NATURAL LEFT JOIN with no common columns (Tom Lane) + + + + + + Fix dumping of function expressions in the FROM clause in + cases where the expression does not deparse into something that looks + like a function call (Tom Lane) + + + + + + Fix pg_basebackup output to stdout on Windows + (Haribabu Kommi) + + + + A backup written to stdout would contain corrupt data due to failure + to put the file descriptor into binary mode. + + + + + + Fix pg_upgrade to ensure that the ending WAL record + does not have = minimum + (Bruce Momjian) + + + + This condition could prevent upgraded standby servers from + reconnecting. + + + + + + In postgres_fdw, re-establish connections to remote + servers after ALTER SERVER or ALTER USER + MAPPING commands (Kyotaro Horiguchi) + + + + This ensures that option changes affecting connection parameters will + be applied promptly. + + + + + + In postgres_fdw, allow cancellation of remote + transaction control commands (Robert Haas, Rafia Sabih) + + + + This change allows us to quickly escape a wait for an unresponsive + remote server in many more cases than previously. + + + + + + Increase MAX_SYSCACHE_CALLBACKS to provide more room for + extensions (Tom Lane) + + + + + + Always use + + + This supports larger extension libraries on platforms where it makes + a difference. + + + + + + Fix unescaped-braces issue in our build scripts for Microsoft MSVC, + to avoid a warning or error from recent Perl versions (Andrew + Dunstan) + + + + + + In MSVC builds, handle the case where the openssl + library is not within a VC subdirectory (Andrew Dunstan) + + + + + + In MSVC builds, add proper include path for libxml2 + header files (Andrew Dunstan) + + + + This fixes a former need to move things around in standard Windows + installations of libxml2. + + + + + + In MSVC builds, recognize a Tcl library that is + named tcl86.lib (Noah Misch) + + + + + + In MSVC builds, honor PROVE_FLAGS settings + on vcregress.pl's command line (Andrew Dunstan) + + + + + + + + Release 9.4.12 diff --git a/doc/src/sgml/release-9.5.sgml b/doc/src/sgml/release-9.5.sgml index cefb364945..41b512038a 100644 --- a/doc/src/sgml/release-9.5.sgml +++ b/doc/src/sgml/release-9.5.sgml @@ -1,6 +1,574 @@ + + Release 9.5.8 + + + Release date: + 2017-08-10 + + + + This release contains a variety of fixes from 9.5.7. + For information about new features in the 9.5 major release, see + . + + + + Migration to Version 9.5.8 + + + A dump/restore is not required for those running 9.5.X. + + + + However, if you are upgrading from a version earlier than 9.5.7, + see . + + + + + Changes + + + + + + Correct the documentation about the process for upgrading standby + servers with pg_upgrade (Bruce Momjian) + + + + The previous documentation instructed users to start/stop the primary + server after running pg_upgrade but before syncing + the standby servers. This sequence is unsafe. + + + + + + Fix concurrent locking of tuple update chains (Álvaro Herrera) + + + + If several sessions concurrently lock a tuple update chain with + nonconflicting lock modes using an old snapshot, and they all + succeed, it was possible for some of them to nonetheless fail (and + conclude there is no live tuple version) due to a race condition. + This had consequences such as foreign-key checks failing to see a + tuple that definitely exists but is being updated concurrently. + + + + + + Fix potential data corruption when freezing a tuple whose XMAX is a + multixact with exactly one still-interesting member (Teodor Sigaev) + + + + + + Avoid integer overflow and ensuing crash when sorting more than one + billion tuples in-memory (Sergey Koposov) + + + + + + On Windows, retry process creation if we fail to reserve the address + range for our shared memory in the new process (Tom Lane, Amit + Kapila) + + + + This is expected to fix infrequent child-process-launch failures that + are probably due to interference from antivirus products. + + + + + + Fix low-probability corruption of shared predicate-lock hash table + in Windows builds (Thomas Munro, Tom Lane) + + + + + + Avoid logging clean closure of an SSL connection as though + it were a connection reset (Michael Paquier) + + + + + + Prevent sending SSL session tickets to clients (Tom Lane) + + + + This fix prevents reconnection failures with ticket-aware client-side + SSL code. + + + + + + Fix code for setting on + Solaris (Tom Lane) + + + + + + Fix statistics collector to honor inquiry messages issued just after + a postmaster shutdown and immediate restart (Tom Lane) + + + + Statistics inquiries issued within half a second of the previous + postmaster shutdown were effectively ignored. + + + + + + Ensure that the statistics collector's receive buffer size is at + least 100KB (Tom Lane) + + + + This reduces the risk of dropped statistics data on older platforms + whose default receive buffer size is less than that. + + + + + + Fix possible creation of an invalid WAL segment when a standby is + promoted just after it processes an XLOG_SWITCH WAL + record (Andres Freund) + + + + + + Fix walsender to exit promptly when client requests + shutdown (Tom Lane) + + + + + + Fix SIGHUP and SIGUSR1 handling in + walsender processes (Petr Jelinek, Andres Freund) + + + + + + Prevent walsender-triggered panics during shutdown checkpoints + (Andres Freund, Michael Paquier) + + + + + + Fix unnecessarily slow restarts of walreceiver + processes due to race condition in postmaster (Tom Lane) + + + + + + Fix leakage of small subtransactions spilled to disk during logical + decoding (Andres Freund) + + + + This resulted in temporary files consuming excessive disk space. + + + + + + Reduce the work needed to build snapshots during creation of + logical-decoding slots (Andres Freund, Petr Jelinek) + + + + The previous algorithm was infeasibly expensive on a server with a + lot of open transactions. + + + + + + Fix race condition that could indefinitely delay creation of + logical-decoding slots (Andres Freund, Petr Jelinek) + + + + + + Reduce overhead in processing syscache invalidation events (Tom Lane) + + + + This is particularly helpful for logical decoding, which triggers + frequent cache invalidation. + + + + + + Fix cases where an INSERT or UPDATE assigns + to more than one element of a column that is of domain-over-array + type (Tom Lane) + + + + + + Allow window functions to be used in sub-SELECTs that + are within the arguments of an aggregate function (Tom Lane) + + + + + + Move autogenerated array types out of the way during + ALTER ... RENAME (Vik Fearing) + + + + Previously, we would rename a conflicting autogenerated array type + out of the way during CREATE; this fix extends that + behavior to renaming operations. + + + + + + Fix dangling pointer in ALTER TABLE when there is a + comment on a constraint belonging to the table (David Rowley) + + + + Re-applying the comment to the reconstructed constraint could fail + with a weird error message, or even crash. + + + + + + Ensure that ALTER USER ... SET accepts all the syntax + variants that ALTER ROLE ... SET does (Peter Eisentraut) + + + + + + Properly update dependency info when changing a datatype I/O + function's argument or return type from opaque to the + correct type (Heikki Linnakangas) + + + + CREATE TYPE updates I/O functions declared in this + long-obsolete style, but it forgot to record a dependency on the + type, allowing a subsequent DROP TYPE to leave broken + function definitions behind. + + + + + + Reduce memory usage when ANALYZE processes + a tsvector column (Heikki Linnakangas) + + + + + + Fix unnecessary precision loss and sloppy rounding when multiplying + or dividing money values by integers or floats (Tom Lane) + + + + + + Tighten checks for whitespace in functions that parse identifiers, + such as regprocedurein() (Tom Lane) + + + + Depending on the prevailing locale, these functions could + misinterpret fragments of multibyte characters as whitespace. + + + + + + Use relevant #define symbols from Perl while + compiling PL/Perl (Ashutosh Sharma, Tom Lane) + + + + This avoids portability problems, typically manifesting as + a handshake mismatch during library load, when working with + recent Perl versions. + + + + + + In libpq, reset GSS/SASL and SSPI authentication + state properly after a failed connection attempt (Michael Paquier) + + + + Failure to do this meant that when falling back from SSL to non-SSL + connections, a GSS/SASL failure in the SSL attempt would always cause + the non-SSL attempt to fail. SSPI did not fail, but it leaked memory. + + + + + + In psql, fix failure when COPY FROM STDIN + is ended with a keyboard EOF signal and then another COPY + FROM STDIN is attempted (Thomas Munro) + + + + This misbehavior was observed on BSD-derived platforms (including + macOS), but not on most others. + + + + + + Fix pg_dump and pg_restore to + emit REFRESH MATERIALIZED VIEW commands last (Tom Lane) + + + + This prevents errors during dump/restore when a materialized view + refers to tables owned by a different user. + + + + + + Improve pg_dump/pg_restore's + reporting of error conditions originating in zlib + (Vladimir Kunschikov, Álvaro Herrera) + + + + + + Fix pg_dump with the + + + It also now correctly assigns ownership of event triggers; before, + they were restored as being owned by the superuser running the + restore script. + + + + + + Fix pg_dump to not emit invalid SQL for an empty + operator class (Daniel Gustafsson) + + + + + + Fix pg_dump output to stdout on Windows (Kuntal Ghosh) + + + + A compressed plain-text dump written to stdout would contain corrupt + data due to failure to put the file descriptor into binary mode. + + + + + + Fix pg_get_ruledef() to print correct output for + the ON SELECT rule of a view whose columns have been + renamed (Tom Lane) + + + + In some corner cases, pg_dump relies + on pg_get_ruledef() to dump views, so that this error + could result in dump/reload failures. + + + + + + Fix dumping of outer joins with empty constraints, such as the result + of a NATURAL LEFT JOIN with no common columns (Tom Lane) + + + + + + Fix dumping of function expressions in the FROM clause in + cases where the expression does not deparse into something that looks + like a function call (Tom Lane) + + + + + + Fix pg_basebackup output to stdout on Windows + (Haribabu Kommi) + + + + A backup written to stdout would contain corrupt data due to failure + to put the file descriptor into binary mode. + + + + + + Fix pg_rewind to correctly handle files exceeding 2GB + (Kuntal Ghosh, Michael Paquier) + + + + Ordinarily such files won't appear in PostgreSQL data + directories, but they could be present in some cases. + + + + + + Fix pg_upgrade to ensure that the ending WAL record + does not have = minimum + (Bruce Momjian) + + + + This condition could prevent upgraded standby servers from + reconnecting. + + + + + + Fix pg_xlogdump's computation of WAL record length + (Andres Freund) + + + + + + In postgres_fdw, re-establish connections to remote + servers after ALTER SERVER or ALTER USER + MAPPING commands (Kyotaro Horiguchi) + + + + This ensures that option changes affecting connection parameters will + be applied promptly. + + + + + + In postgres_fdw, allow cancellation of remote + transaction control commands (Robert Haas, Rafia Sabih) + + + + This change allows us to quickly escape a wait for an unresponsive + remote server in many more cases than previously. + + + + + + Increase MAX_SYSCACHE_CALLBACKS to provide more room for + extensions (Tom Lane) + + + + + + Always use + + + This supports larger extension libraries on platforms where it makes + a difference. + + + + + + + Fix unescaped-braces issue in our build scripts for Microsoft MSVC, + to avoid a warning or error from recent Perl versions (Andrew + Dunstan) + + + + + + In MSVC builds, handle the case where the openssl + library is not within a VC subdirectory (Andrew Dunstan) + + + + + + In MSVC builds, add proper include path for libxml2 + header files (Andrew Dunstan) + + + + This fixes a former need to move things around in standard Windows + installations of libxml2. + + + + + + In MSVC builds, recognize a Tcl library that is + named tcl86.lib (Noah Misch) + + + + + + In MSVC builds, honor PROVE_FLAGS settings + on vcregress.pl's command line (Andrew Dunstan) + + + + + + + + Release 9.5.7 diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml index 0ee995e5f0..93a24a383f 100644 --- a/doc/src/sgml/release-9.6.sgml +++ b/doc/src/sgml/release-9.6.sgml @@ -1,6 +1,1123 @@ + + Release 9.6.4 + + + Release date: + 2017-08-10 + + + + This release contains a variety of fixes from 9.6.3. + For information about new features in the 9.6 major release, see + . + + + + Migration to Version 9.6.4 + + + A dump/restore is not required for those running 9.6.X. + + + + However, if you are upgrading from a version earlier than 9.6.3, + see . + + + + + Changes + + + + + + + Correct the documentation about the process for upgrading standby + servers with pg_upgrade (Bruce Momjian) + + + + The previous documentation instructed users to start/stop the primary + server after running pg_upgrade but before syncing + the standby servers. This sequence is unsafe. + + + + + + + Fix concurrent locking of tuple update chains (Álvaro Herrera) + + + + If several sessions concurrently lock a tuple update chain with + nonconflicting lock modes using an old snapshot, and they all + succeed, it was possible for some of them to nonetheless fail (and + conclude there is no live tuple version) due to a race condition. + This had consequences such as foreign-key checks failing to see a + tuple that definitely exists but is being updated concurrently. + + + + + + + Fix potential data corruption when freezing a tuple whose XMAX is a + multixact with exactly one still-interesting member (Teodor Sigaev) + + + + + + + Avoid integer overflow and ensuing crash when sorting more than one + billion tuples in-memory (Sergey Koposov) + + + + + + + On Windows, retry process creation if we fail to reserve the address + range for our shared memory in the new process (Tom Lane, Amit + Kapila) + + + + This is expected to fix infrequent child-process-launch failures that + are probably due to interference from antivirus products. + + + + + + + Fix low-probability corruption of shared predicate-lock hash table + in Windows builds (Thomas Munro, Tom Lane) + + + + + + + Avoid logging clean closure of an SSL connection as though + it were a connection reset (Michael Paquier) + + + + + + + Prevent sending SSL session tickets to clients (Tom Lane) + + + + This fix prevents reconnection failures with ticket-aware client-side + SSL code. + + + + + + + Fix code for setting on + Solaris (Tom Lane) + + + + + + + Fix statistics collector to honor inquiry messages issued just after + a postmaster shutdown and immediate restart (Tom Lane) + + + + Statistics inquiries issued within half a second of the previous + postmaster shutdown were effectively ignored. + + + + + + + Ensure that the statistics collector's receive buffer size is at + least 100KB (Tom Lane) + + + + This reduces the risk of dropped statistics data on older platforms + whose default receive buffer size is less than that. + + + + + + + Fix possible creation of an invalid WAL segment when a standby is + promoted just after it processes an XLOG_SWITCH WAL + record (Andres Freund) + + + + + + + Fix walsender to exit promptly when client requests + shutdown (Tom Lane) + + + + + + + Fix SIGHUP and SIGUSR1 handling in + walsender processes (Petr Jelinek, Andres Freund) + + + + + + + Prevent walsender-triggered panics during shutdown checkpoints + (Andres Freund, Michael Paquier) + + + + + + + Fix unnecessarily slow restarts of walreceiver + processes due to race condition in postmaster (Tom Lane) + + + + + + + Fix leakage of small subtransactions spilled to disk during logical + decoding (Andres Freund) + + + + This resulted in temporary files consuming excessive disk space. + + + + + + + Reduce the work needed to build snapshots during creation of + logical-decoding slots (Andres Freund, Petr Jelinek) + + + + The previous algorithm was infeasibly expensive on a server with a + lot of open transactions. + + + + + + + Fix race condition that could indefinitely delay creation of + logical-decoding slots (Andres Freund, Petr Jelinek) + + + + + + + Reduce overhead in processing syscache invalidation events (Tom Lane) + + + + This is particularly helpful for logical decoding, which triggers + frequent cache invalidation. + + + + + + + Remove incorrect heuristic used in some cases to estimate join + selectivity based on the presence of foreign-key constraints + (David Rowley) + + + + In some cases where a multi-column foreign key constraint existed but + did not exactly match a query's join structure, the planner used an + estimation heuristic that turns out not to work well at all. Revert + such cases to the way they were estimated before 9.6. + + + + + + + Fix cases where an INSERT or UPDATE assigns + to more than one element of a column that is of domain-over-array + type (Tom Lane) + + + + + + + Allow window functions to be used in sub-SELECTs that + are within the arguments of an aggregate function (Tom Lane) + + + + + + + Ensure that a view's CHECK OPTIONS clause is enforced + properly when the underlying table is a foreign table (Etsuro Fujita) + + + + Previously, the update might get pushed entirely to the foreign + server, but the need to verify the view conditions was missed if so. + + + + + + + Move autogenerated array types out of the way during + ALTER ... RENAME (Vik Fearing) + + + + Previously, we would rename a conflicting autogenerated array type + out of the way during CREATE; this fix extends that + behavior to renaming operations. + + + + + + + Fix dangling pointer in ALTER TABLE when there is a + comment on a constraint belonging to the table (David Rowley) + + + + Re-applying the comment to the reconstructed constraint could fail + with a weird error message, or even crash. + + + + + + + Ensure that ALTER USER ... SET accepts all the syntax + variants that ALTER ROLE ... SET does (Peter Eisentraut) + + + + + + + Allow a foreign table's CHECK constraints to be + initially NOT VALID (Amit Langote) + + + + CREATE TABLE silently drops NOT VALID + specifiers for CHECK constraints, reasoning that the + table must be empty so the constraint can be validated immediately. + But this is wrong for CREATE FOREIGN TABLE, where there's + no reason to suppose that the underlying table is empty, and even if + it is it's no business of ours to decide that the constraint can be + treated as valid going forward. Skip this optimization for + foreign tables. + + + + + + + Properly update dependency info when changing a datatype I/O + function's argument or return type from opaque to the + correct type (Heikki Linnakangas) + + + + CREATE TYPE updates I/O functions declared in this + long-obsolete style, but it forgot to record a dependency on the + type, allowing a subsequent DROP TYPE to leave broken + function definitions behind. + + + + + + + Allow parallelism in the query plan when COPY copies from + a query's result (Andres Freund) + + + + + + + Reduce memory usage when ANALYZE processes + a tsvector column (Heikki Linnakangas) + + + + + + + Fix unnecessary precision loss and sloppy rounding when multiplying + or dividing money values by integers or floats (Tom Lane) + + + + + + + Tighten checks for whitespace in functions that parse identifiers, + such as regprocedurein() (Tom Lane) + + + + Depending on the prevailing locale, these functions could + misinterpret fragments of multibyte characters as whitespace. + + + + + + + Use relevant #define symbols from Perl while + compiling PL/Perl (Ashutosh Sharma, Tom Lane) + + + + This avoids portability problems, typically manifesting as + a handshake mismatch during library load, when working with + recent Perl versions. + + + + + + + In libpq, reset GSS/SASL and SSPI authentication + state properly after a failed connection attempt (Michael Paquier) + + + + Failure to do this meant that when falling back from SSL to non-SSL + connections, a GSS/SASL failure in the SSL attempt would always cause + the non-SSL attempt to fail. SSPI did not fail, but it leaked memory. + + + + + + + In psql, fix failure when COPY FROM STDIN + is ended with a keyboard EOF signal and then another COPY + FROM STDIN is attempted (Thomas Munro) + + + + This misbehavior was observed on BSD-derived platforms (including + macOS), but not on most others. + + + + + + + Fix pg_dump and pg_restore to + emit REFRESH MATERIALIZED VIEW commands last (Tom Lane) + + + + This prevents errors during dump/restore when a materialized view + refers to tables owned by a different user. + + + + + + + Improve pg_dump/pg_restore's + reporting of error conditions originating in zlib + (Vladimir Kunschikov, Álvaro Herrera) + + + + + + + Fix pg_dump with the + + + It also now correctly assigns ownership of event triggers; before, + they were restored as being owned by the superuser running the + restore script. + + + + + + + Fix pg_dump with the + + + + + + Fix pg_dump to not emit invalid SQL for an empty + operator class (Daniel Gustafsson) + + + + + + + Fix pg_dump output to stdout on Windows (Kuntal Ghosh) + + + + A compressed plain-text dump written to stdout would contain corrupt + data due to failure to put the file descriptor into binary mode. + + + + + + + Fix pg_get_ruledef() to print correct output for + the ON SELECT rule of a view whose columns have been + renamed (Tom Lane) + + + + In some corner cases, pg_dump relies + on pg_get_ruledef() to dump views, so that this error + could result in dump/reload failures. + + + + + + + Fix dumping of outer joins with empty constraints, such as the result + of a NATURAL LEFT JOIN with no common columns (Tom Lane) + + + + + + + Fix dumping of function expressions in the FROM clause in + cases where the expression does not deparse into something that looks + like a function call (Tom Lane) + + + + + + + Fix pg_basebackup output to stdout on Windows + (Haribabu Kommi) + + + + A backup written to stdout would contain corrupt data due to failure + to put the file descriptor into binary mode. + + + + + + + Fix pg_rewind to correctly handle files exceeding 2GB + (Kuntal Ghosh, Michael Paquier) + + + + Ordinarily such files won't appear in PostgreSQL data + directories, but they could be present in some cases. + + + + + + + Fix pg_upgrade to ensure that the ending WAL record + does not have = minimum + (Bruce Momjian) + + + + This condition could prevent upgraded standby servers from + reconnecting. + + + + + + + Fix pg_xlogdump's computation of WAL record length + (Andres Freund) + + + + + + + In postgres_fdw, re-establish connections to remote + servers after ALTER SERVER or ALTER USER + MAPPING commands (Kyotaro Horiguchi) + + + + This ensures that option changes affecting connection parameters will + be applied promptly. + + + + + + + In postgres_fdw, allow cancellation of remote + transaction control commands (Robert Haas, Rafia Sabih) + + + + This change allows us to quickly escape a wait for an unresponsive + remote server in many more cases than previously. + + + + + + + Increase MAX_SYSCACHE_CALLBACKS to provide more room for + extensions (Tom Lane) + + + + + + + Always use + + + This supports larger extension libraries on platforms where it makes + a difference. + + + + + + + In MSVC builds, handle the case where the openssl + library is not within a VC subdirectory (Andrew Dunstan) + + + + + + + In MSVC builds, add proper include path for libxml2 + header files (Andrew Dunstan) + + + + This fixes a former need to move things around in standard Windows + installations of libxml2. + + + + + + + In MSVC builds, recognize a Tcl library that is + named tcl86.lib (Noah Misch) + + + + + + + In MSVC builds, honor PROVE_FLAGS settings + on vcregress.pl's command line (Andrew Dunstan) + + + + + + + + Release 9.6.3 From f6fc72cb697295c1807d14ee5c52d2086d1864af Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Mon, 7 Aug 2017 17:03:42 +0300 Subject: [PATCH 0184/1139] Don't allow logging in with empty password. Some authentication methods allowed it, others did not. In the client-side, libpq does not even try to authenticate with an empty password, which makes using empty passwords hazardous: an administrator might think that an account with an empty password cannot be used to log in, because psql doesn't allow it, and not realize that a different client would in fact allow it. To clear that confusion and to be be consistent, disallow empty passwords in all authentication methods. All the authentication methods that used plaintext authentication over the wire, except for BSD authentication, already checked that the password received from the user was not empty. To avoid forgetting it in the future again, move the check to the recv_password_packet function. That only forbids using an empty password with plaintext authentication, however. MD5 and SCRAM need a different fix: * In stable branches, check that the MD5 hash stored for the user does not not correspond to an empty string. This adds some overhead to MD5 authentication, because the server needs to compute an extra MD5 hash, but it is not noticeable in practice. * In HEAD, modify CREATE and ALTER ROLE to clear the password if an empty string, or a password hash that corresponds to an empty string, is specified. The user-visible behavior is the same as in the stable branches, the user cannot log in, but it seems better to stop the empty password from entering the system in the first place. Secondly, it is fairly expensive to check that a SCRAM hash doesn't correspond to an empty string, because computing a SCRAM hash is much more expensive than an MD5 hash by design, so better avoid doing that on every authentication. We could clear the password on CREATE/ALTER ROLE also in stable branches, but we would still need to check at authentication time, because even if we prevent empty passwords from being stored in pg_authid, there might be existing ones there already. Reported by Jeroen van der Ham, Ben de Graaff and Jelte Fennema. Security: CVE-2017-7546 --- src/backend/libpq/auth.c | 36 ++++++++++++++++-------------------- src/backend/libpq/crypt.c | 25 +++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 20 deletions(-) diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c index f585ae0aed..ba64bcf913 100644 --- a/src/backend/libpq/auth.c +++ b/src/backend/libpq/auth.c @@ -697,6 +697,20 @@ recv_password_packet(Port *port) (errcode(ERRCODE_PROTOCOL_VIOLATION), errmsg("invalid password packet size"))); + /* + * Don't allow an empty password. Libpq treats an empty password the same + * as no password at all, and won't even try to authenticate. But other + * clients might, so allowing it would be confusing. + * + * Note that this only catches an empty password sent by the client in + * plaintext. There's another check in md5_crypt_verify to prevent an + * empty password from being used with MD5 authentication. + */ + if (buf.data[0] == '\0') + ereport(ERROR, + (errcode(ERRCODE_INVALID_PASSWORD), + errmsg("empty password returned by client"))); + /* Do not echo password to logs, for security. */ elog(DEBUG5, "received password packet"); @@ -1820,12 +1834,6 @@ pam_passwd_conv_proc(int num_msg, const struct pam_message ** msg, */ goto fail; } - if (strlen(passwd) == 0) - { - ereport(LOG, - (errmsg("empty password returned by client"))); - goto fail; - } } if ((reply[i].resp = strdup(passwd)) == NULL) goto fail; @@ -2146,16 +2154,11 @@ CheckLDAPAuth(Port *port) if (passwd == NULL) return STATUS_EOF; /* client wouldn't send password */ - if (strlen(passwd) == 0) - { - ereport(LOG, - (errmsg("empty password returned by client"))); - return STATUS_ERROR; - } - if (InitializeLDAPConnection(port, &ldap) == STATUS_ERROR) + { /* Error message already sent */ return STATUS_ERROR; + } if (port->hba->ldapbasedn) { @@ -2509,13 +2512,6 @@ CheckRADIUSAuth(Port *port) if (passwd == NULL) return STATUS_EOF; /* client wouldn't send password */ - if (strlen(passwd) == 0) - { - ereport(LOG, - (errmsg("empty password returned by client"))); - return STATUS_ERROR; - } - if (strlen(passwd) > RADIUS_MAX_PASSWORD_LENGTH) { ereport(LOG, diff --git a/src/backend/libpq/crypt.c b/src/backend/libpq/crypt.c index d79f5a2496..9cd7f787cc 100644 --- a/src/backend/libpq/crypt.c +++ b/src/backend/libpq/crypt.c @@ -74,12 +74,37 @@ md5_crypt_verify(const Port *port, const char *role, char *client_pass, ReleaseSysCache(roleTup); + /* + * Don't allow an empty password. Libpq treats an empty password the same + * as no password at all, and won't even try to authenticate. But other + * clients might, so allowing it would be confusing. + * + * For a plaintext password, we can simply check that it's not an empty + * string. For an encrypted password, check that it does not match the MD5 + * hash of an empty string. + */ if (*shadow_pass == '\0') { *logdetail = psprintf(_("User \"%s\" has an empty password."), role); return STATUS_ERROR; /* empty password */ } + if (isMD5(shadow_pass)) + { + char crypt_empty[MD5_PASSWD_LEN + 1]; + + if (!pg_md5_encrypt("", + port->user_name, + strlen(port->user_name), + crypt_empty)) + return STATUS_ERROR; + if (strcmp(shadow_pass, crypt_empty) == 0) + { + *logdetail = psprintf(_("User \"%s\" has an empty password."), + role); + return STATUS_ERROR; /* empty password */ + } + } /* * Compare with the encrypted or plain password depending on the From 156099630320fcb72d41ae90b91f15ed0dfbc271 Mon Sep 17 00:00:00 2001 From: Noah Misch Date: Mon, 7 Aug 2017 07:09:28 -0700 Subject: [PATCH 0185/1139] Again match pg_user_mappings to information_schema.user_mapping_options. Commit 3eefc51053f250837c3115c12f8119d16881a2d7 claimed to make pg_user_mappings enforce the qualifications user_mapping_options had been enforcing, but its removal of a longstanding restriction left them distinct when the current user is the subject of a mapping yet has no server privileges. user_mapping_options emits no rows for such a mapping, but pg_user_mappings includes full umoptions. Change pg_user_mappings to show null for umoptions. Back-patch to 9.2, like the above commit. Reviewed by Tom Lane. Reported by Jeff Janes. Security: CVE-2017-7547 --- doc/src/sgml/catalogs.sgml | 32 ++++++++++++++---- src/backend/catalog/system_views.sql | 4 ++- src/test/regress/expected/foreign_data.out | 39 +++++++++++----------- src/test/regress/expected/rules.out | 2 +- src/test/regress/sql/foreign_data.sql | 19 +++++++---- 5 files changed, 61 insertions(+), 35 deletions(-) diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml index 71c86142a6..138125c0bf 100644 --- a/doc/src/sgml/catalogs.sgml +++ b/doc/src/sgml/catalogs.sgml @@ -10050,17 +10050,37 @@ SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xacts ppx text[] - User mapping specific options, as keyword=value - strings. This column will show as null unless the current user - is the user being mapped, or the mapping is for - PUBLIC and the current user is the server - owner, or the current user is a superuser. The intent is - to protect password information stored as user mapping option. + User mapping specific options, as keyword=value strings
+ + + To protect password information stored as a user mapping option, + the umoptions column will read as null + unless one of the following applies: + + + + current user is the user being mapped, and owns the server or + holds USAGE privilege on it + + + + + current user is the server owner and mapping is for PUBLIC + + + + + current user is a superuser + + + + + diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index b769c6f066..57535a2dea 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -826,7 +826,9 @@ CREATE VIEW pg_user_mappings AS ELSE A.rolname END AS usename, - CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user + AND (pg_has_role(S.srvowner, 'USAGE') + OR has_server_privilege(S.oid, 'USAGE'))) OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) THEN U.umoptions diff --git a/src/test/regress/expected/foreign_data.out b/src/test/regress/expected/foreign_data.out index fea02b6faf..10e52613a4 100644 --- a/src/test/regress/expected/foreign_data.out +++ b/src/test/regress/expected/foreign_data.out @@ -1179,10 +1179,11 @@ ERROR: permission denied for foreign-data wrapper foo ALTER SERVER s9 VERSION '1.1'; GRANT USAGE ON FOREIGN SERVER s9 TO regress_test_role; CREATE USER MAPPING FOR current_user SERVER s9; +-- We use terse mode to avoid ordering issues in cascade detail output. +\set VERBOSITY terse DROP SERVER s9 CASCADE; NOTICE: drop cascades to 2 other objects -DETAIL: drop cascades to user mapping for public on server s9 -drop cascades to user mapping for regress_unprivileged_role on server s9 +\set VERBOSITY default RESET ROLE; CREATE SERVER s9 FOREIGN DATA WRAPPER foo; GRANT USAGE ON FOREIGN SERVER s9 TO regress_unprivileged_role; @@ -1198,13 +1199,14 @@ ERROR: must be owner of foreign server s9 SET ROLE regress_test_role; CREATE SERVER s10 FOREIGN DATA WRAPPER foo; CREATE USER MAPPING FOR public SERVER s10 OPTIONS (user 'secret'); -GRANT USAGE ON FOREIGN SERVER s10 TO regress_unprivileged_role; --- owner of server can see option fields +CREATE USER MAPPING FOR regress_unprivileged_role SERVER s10 OPTIONS (user 'secret'); +-- owner of server can see some option fields \deu+ List of user mappings Server | User name | FDW Options --------+---------------------------+------------------- s10 | public | ("user" 'secret') + s10 | regress_unprivileged_role | s4 | regress_foreign_data_user | s5 | regress_test_role | (modified '1') s6 | regress_test_role | @@ -1212,15 +1214,16 @@ GRANT USAGE ON FOREIGN SERVER s10 TO regress_unprivileged_role; s8 | regress_foreign_data_user | s9 | regress_unprivileged_role | t1 | public | (modified '1') -(8 rows) +(9 rows) RESET ROLE; --- superuser can see option fields +-- superuser can see all option fields \deu+ List of user mappings Server | User name | FDW Options --------+---------------------------+--------------------- s10 | public | ("user" 'secret') + s10 | regress_unprivileged_role | ("user" 'secret') s4 | regress_foreign_data_user | s5 | regress_test_role | (modified '1') s6 | regress_test_role | @@ -1228,15 +1231,16 @@ RESET ROLE; s8 | regress_foreign_data_user | (password 'public') s9 | regress_unprivileged_role | t1 | public | (modified '1') -(8 rows) +(9 rows) --- unprivileged user cannot see option fields +-- unprivileged user cannot see any option field SET ROLE regress_unprivileged_role; \deu+ List of user mappings Server | User name | FDW Options --------+---------------------------+------------- s10 | public | + s10 | regress_unprivileged_role | s4 | regress_foreign_data_user | s5 | regress_test_role | s6 | regress_test_role | @@ -1244,11 +1248,13 @@ SET ROLE regress_unprivileged_role; s8 | regress_foreign_data_user | s9 | regress_unprivileged_role | t1 | public | -(8 rows) +(9 rows) RESET ROLE; +\set VERBOSITY terse DROP SERVER s10 CASCADE; -NOTICE: drop cascades to user mapping for public on server s10 +NOTICE: drop cascades to 2 other objects +\set VERBOSITY default -- Triggers CREATE FUNCTION dummy_trigger() RETURNS TRIGGER AS $$ BEGIN @@ -1583,15 +1589,12 @@ Inherits: pt1 Child tables: ct3, ft3 +\set VERBOSITY terse DROP FOREIGN TABLE ft2; -- ERROR ERROR: cannot drop foreign table ft2 because other objects depend on it -DETAIL: table ct3 depends on foreign table ft2 -foreign table ft3 depends on foreign table ft2 -HINT: Use DROP ... CASCADE to drop the dependent objects too. DROP FOREIGN TABLE ft2 CASCADE; NOTICE: drop cascades to 2 other objects -DETAIL: drop cascades to table ct3 -drop cascades to foreign table ft3 +\set VERBOSITY default CREATE FOREIGN TABLE ft2 ( c1 integer NOT NULL, c2 text, @@ -1815,16 +1818,12 @@ owner of user mapping for regress_test_role on server s6 DROP SERVER t1 CASCADE; NOTICE: drop cascades to user mapping for public on server t1 DROP USER MAPPING FOR regress_test_role SERVER s6; --- This test causes some order dependent cascade detail output, --- so switch to terse mode for it. \set VERBOSITY terse DROP FOREIGN DATA WRAPPER foo CASCADE; NOTICE: drop cascades to 5 other objects -\set VERBOSITY default DROP SERVER s8 CASCADE; NOTICE: drop cascades to 2 other objects -DETAIL: drop cascades to user mapping for regress_foreign_data_user on server s8 -drop cascades to user mapping for public on server s8 +\set VERBOSITY default DROP ROLE regress_test_indirect; DROP ROLE regress_test_role; DROP ROLE regress_unprivileged_role; -- ERROR diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index d27b1f9305..e827e4b912 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -2151,7 +2151,7 @@ pg_user_mappings| SELECT u.oid AS umid, ELSE a.rolname END AS usename, CASE - WHEN (((u.umuser <> (0)::oid) AND (a.rolname = "current_user"())) OR ((u.umuser = (0)::oid) AND pg_has_role(s.srvowner, 'USAGE'::text)) OR ( SELECT pg_authid.rolsuper + WHEN (((u.umuser <> (0)::oid) AND (a.rolname = "current_user"()) AND (pg_has_role(s.srvowner, 'USAGE'::text) OR has_server_privilege(s.oid, 'USAGE'::text))) OR ((u.umuser = (0)::oid) AND pg_has_role(s.srvowner, 'USAGE'::text)) OR ( SELECT pg_authid.rolsuper FROM pg_authid WHERE (pg_authid.rolname = "current_user"()))) THEN u.umoptions ELSE NULL::text[] diff --git a/src/test/regress/sql/foreign_data.sql b/src/test/regress/sql/foreign_data.sql index ce66d9955a..f3371f4fe1 100644 --- a/src/test/regress/sql/foreign_data.sql +++ b/src/test/regress/sql/foreign_data.sql @@ -481,7 +481,10 @@ CREATE SERVER s10 FOREIGN DATA WRAPPER foo; -- ERROR ALTER SERVER s9 VERSION '1.1'; GRANT USAGE ON FOREIGN SERVER s9 TO regress_test_role; CREATE USER MAPPING FOR current_user SERVER s9; +-- We use terse mode to avoid ordering issues in cascade detail output. +\set VERBOSITY terse DROP SERVER s9 CASCADE; +\set VERBOSITY default RESET ROLE; CREATE SERVER s9 FOREIGN DATA WRAPPER foo; GRANT USAGE ON FOREIGN SERVER s9 TO regress_unprivileged_role; @@ -495,17 +498,19 @@ DROP SERVER s9 CASCADE; -- ERROR SET ROLE regress_test_role; CREATE SERVER s10 FOREIGN DATA WRAPPER foo; CREATE USER MAPPING FOR public SERVER s10 OPTIONS (user 'secret'); -GRANT USAGE ON FOREIGN SERVER s10 TO regress_unprivileged_role; --- owner of server can see option fields +CREATE USER MAPPING FOR regress_unprivileged_role SERVER s10 OPTIONS (user 'secret'); +-- owner of server can see some option fields \deu+ RESET ROLE; --- superuser can see option fields +-- superuser can see all option fields \deu+ --- unprivileged user cannot see option fields +-- unprivileged user cannot see any option field SET ROLE regress_unprivileged_role; \deu+ RESET ROLE; +\set VERBOSITY terse DROP SERVER s10 CASCADE; +\set VERBOSITY default -- Triggers CREATE FUNCTION dummy_trigger() RETURNS TRIGGER AS $$ @@ -629,8 +634,10 @@ SELECT relname, conname, contype, conislocal, coninhcount, connoinherit -- child does not inherit NO INHERIT constraints \d+ pt1 \d+ ft2 +\set VERBOSITY terse DROP FOREIGN TABLE ft2; -- ERROR DROP FOREIGN TABLE ft2 CASCADE; +\set VERBOSITY default CREATE FOREIGN TABLE ft2 ( c1 integer NOT NULL, c2 text, @@ -704,12 +711,10 @@ DROP SCHEMA foreign_schema CASCADE; DROP ROLE regress_test_role; -- ERROR DROP SERVER t1 CASCADE; DROP USER MAPPING FOR regress_test_role SERVER s6; --- This test causes some order dependent cascade detail output, --- so switch to terse mode for it. \set VERBOSITY terse DROP FOREIGN DATA WRAPPER foo CASCADE; -\set VERBOSITY default DROP SERVER s8 CASCADE; +\set VERBOSITY default DROP ROLE regress_test_indirect; DROP ROLE regress_test_role; DROP ROLE regress_unprivileged_role; -- ERROR From 52a414387e192a89f5fec19d9876159d03cf112b Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 7 Aug 2017 10:19:01 -0400 Subject: [PATCH 0186/1139] Require update permission for the large object written by lo_put(). lo_put() surely should require UPDATE permission, the same as lowrite(), but it failed to check for that, as reported by Chapman Flack. Oversight in commit c50b7c09d; backpatch to 9.4 where that was introduced. Tom Lane and Michael Paquier Security: CVE-2017-7548 --- src/backend/libpq/be-fsstubs.c | 12 ++++++++++++ src/test/regress/expected/privileges.out | 10 ++++++++++ src/test/regress/sql/privileges.sql | 4 ++++ 3 files changed, 26 insertions(+) diff --git a/src/backend/libpq/be-fsstubs.c b/src/backend/libpq/be-fsstubs.c index 764f602aaa..50e416da79 100644 --- a/src/backend/libpq/be-fsstubs.c +++ b/src/backend/libpq/be-fsstubs.c @@ -896,6 +896,18 @@ lo_put(PG_FUNCTION_ARGS) CreateFSContext(); loDesc = inv_open(loOid, INV_WRITE, fscxt); + + /* Permission check */ + if (!lo_compat_privileges && + pg_largeobject_aclcheck_snapshot(loDesc->id, + GetUserId(), + ACL_UPDATE, + loDesc->snapshot) != ACLCHECK_OK) + ereport(ERROR, + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + errmsg("permission denied for large object %u", + loDesc->id))); + inv_seek(loDesc, offset, SEEK_SET); written = inv_write(loDesc, VARDATA_ANY(str), VARSIZE_ANY_EXHDR(str)); Assert(written == VARSIZE_ANY_EXHDR(str)); diff --git a/src/test/regress/expected/privileges.out b/src/test/regress/expected/privileges.out index 52ba77f822..b845fdd842 100644 --- a/src/test/regress/expected/privileges.out +++ b/src/test/regress/expected/privileges.out @@ -1219,6 +1219,14 @@ SELECT lo_create(2002); 2002 (1 row) +SELECT loread(lo_open(1001, x'20000'::int), 32); -- allowed, for now + loread +-------- + \x +(1 row) + +SELECT lowrite(lo_open(1001, x'40000'::int), 'abcd'); -- fail, wrong mode +ERROR: large object descriptor 0 was not opened for writing SELECT loread(lo_open(1001, x'40000'::int), 32); loread -------- @@ -1314,6 +1322,8 @@ SELECT lowrite(lo_open(1002, x'20000'::int), 'abcd'); -- to be denied ERROR: permission denied for large object 1002 SELECT lo_truncate(lo_open(1002, x'20000'::int), 10); -- to be denied ERROR: permission denied for large object 1002 +SELECT lo_put(1002, 1, 'abcd'); -- to be denied +ERROR: permission denied for large object 1002 SELECT lo_unlink(1002); -- to be denied ERROR: must be owner of large object 1002 SELECT lo_export(1001, '/dev/null'); -- to be denied diff --git a/src/test/regress/sql/privileges.sql b/src/test/regress/sql/privileges.sql index 5622f7e4a8..b86c145285 100644 --- a/src/test/regress/sql/privileges.sql +++ b/src/test/regress/sql/privileges.sql @@ -770,6 +770,9 @@ SET SESSION AUTHORIZATION regress_user2; SELECT lo_create(2001); SELECT lo_create(2002); +SELECT loread(lo_open(1001, x'20000'::int), 32); -- allowed, for now +SELECT lowrite(lo_open(1001, x'40000'::int), 'abcd'); -- fail, wrong mode + SELECT loread(lo_open(1001, x'40000'::int), 32); SELECT loread(lo_open(1002, x'40000'::int), 32); -- to be denied SELECT loread(lo_open(1003, x'40000'::int), 32); @@ -809,6 +812,7 @@ SET SESSION AUTHORIZATION regress_user4; SELECT loread(lo_open(1002, x'40000'::int), 32); -- to be denied SELECT lowrite(lo_open(1002, x'20000'::int), 'abcd'); -- to be denied SELECT lo_truncate(lo_open(1002, x'20000'::int), 10); -- to be denied +SELECT lo_put(1002, 1, 'abcd'); -- to be denied SELECT lo_unlink(1002); -- to be denied SELECT lo_export(1001, '/dev/null'); -- to be denied From 57b995a9a4650cd294e1017946af54aabbbfe146 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 7 Aug 2017 11:46:20 -0400 Subject: [PATCH 0187/1139] Last-minute updates for release notes. Security: CVE-2017-7546, CVE-2017-7547, CVE-2017-7548 --- doc/src/sgml/release-9.2.sgml | 199 ++++++++++++++++++---------- doc/src/sgml/release-9.3.sgml | 199 ++++++++++++++++++---------- doc/src/sgml/release-9.4.sgml | 213 ++++++++++++++++++++---------- doc/src/sgml/release-9.5.sgml | 213 ++++++++++++++++++++---------- doc/src/sgml/release-9.6.sgml | 238 ++++++++++++++++++++++++---------- 5 files changed, 707 insertions(+), 355 deletions(-) diff --git a/doc/src/sgml/release-9.2.sgml b/doc/src/sgml/release-9.2.sgml index 96b073f81e..8ff752c33b 100644 --- a/doc/src/sgml/release-9.2.sgml +++ b/doc/src/sgml/release-9.2.sgml @@ -29,7 +29,12 @@ - However, if you are upgrading from a version earlier than 9.2.20, + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.2.20, see . @@ -40,6 +45,126 @@ + + + Further restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Noah Misch) + + + + The fix for CVE-2017-7486 was incorrect: it allowed a user + to see the options in her own user mapping, even if she did not + have USAGE permission on the associated foreign server. + Such options might include a password that had been provided by the + server owner rather than the user herself. + Since information_schema.user_mapping_options does not + show the options in such cases, pg_user_mappings + should not either. + (CVE-2017-7547) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user + AND (pg_has_role(S.srvowner, 'USAGE') + OR has_server_privilege(S.oid, 'USAGE'))) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Disallow empty passwords in all password-based authentication methods + (Heikki Linnakangas) + + + + libpq ignores empty password specifications, and does + not transmit them to the server. So, if a user's password has been + set to the empty string, it's impossible to log in with that password + via psql or other libpq-based + clients. An administrator might therefore believe that setting the + password to empty is equivalent to disabling password login. + However, with a modified or non-libpq-based client, + logging in could be possible, depending on which authentication + method is configured. In particular the most common + method, md5, accepted empty passwords. + Change the server to reject empty passwords in all cases. + (CVE-2017-7546) + + + On Windows, retry process creation if we fail to reserve the address @@ -410,77 +535,9 @@ By itself, this patch will only fix the behavior in newly initdb'd databases. If you wish to apply this change in an existing database, - you will need to do the following: + follow the corrected procedure shown in the changelog entry for + CVE-2017-7547, in . - - - - - Restart the postmaster after adding allow_system_table_mods - = true to postgresql.conf. (In versions - supporting ALTER SYSTEM, you can use that to make the - configuration change, but you'll still need a restart.) - - - - - - In each database of the cluster, - run the following commands as superuser: - -SET search_path = pg_catalog; -CREATE OR REPLACE VIEW pg_user_mappings AS - SELECT - U.oid AS umid, - S.oid AS srvid, - S.srvname AS srvname, - U.umuser AS umuser, - CASE WHEN U.umuser = 0 THEN - 'public' - ELSE - A.rolname - END AS usename, - CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) - OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) - OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) - THEN U.umoptions - ELSE NULL END AS umoptions - FROM pg_user_mapping U - LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN - pg_foreign_server S ON (U.umserver = S.oid); - - - - - - - Do not forget to include the template0 - and template1 databases, or the vulnerability will still - exist in databases you create later. To fix template0, - you'll need to temporarily make it accept connections. - In PostgreSQL 9.5 and later, you can use - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; - - and then after fixing template0, undo that with - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; - - In prior versions, instead use - -UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; -UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; - - - - - - - Finally, remove the allow_system_table_mods configuration - setting, and again restart the postmaster. - - - diff --git a/doc/src/sgml/release-9.3.sgml b/doc/src/sgml/release-9.3.sgml index 80d4864230..abbfe5eaa4 100644 --- a/doc/src/sgml/release-9.3.sgml +++ b/doc/src/sgml/release-9.3.sgml @@ -23,7 +23,12 @@ - However, if you are upgrading from a version earlier than 9.3.16, + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.3.16, see . @@ -34,6 +39,126 @@ + + + Further restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Noah Misch) + + + + The fix for CVE-2017-7486 was incorrect: it allowed a user + to see the options in her own user mapping, even if she did not + have USAGE permission on the associated foreign server. + Such options might include a password that had been provided by the + server owner rather than the user herself. + Since information_schema.user_mapping_options does not + show the options in such cases, pg_user_mappings + should not either. + (CVE-2017-7547) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user + AND (pg_has_role(S.srvowner, 'USAGE') + OR has_server_privilege(S.oid, 'USAGE'))) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Disallow empty passwords in all password-based authentication methods + (Heikki Linnakangas) + + + + libpq ignores empty password specifications, and does + not transmit them to the server. So, if a user's password has been + set to the empty string, it's impossible to log in with that password + via psql or other libpq-based + clients. An administrator might therefore believe that setting the + password to empty is equivalent to disabling password login. + However, with a modified or non-libpq-based client, + logging in could be possible, depending on which authentication + method is configured. In particular the most common + method, md5, accepted empty passwords. + Change the server to reject empty passwords in all cases. + (CVE-2017-7546) + + + Fix concurrent locking of tuple update chains (Álvaro Herrera) @@ -497,77 +622,9 @@ By itself, this patch will only fix the behavior in newly initdb'd databases. If you wish to apply this change in an existing database, - you will need to do the following: + follow the corrected procedure shown in the changelog entry for + CVE-2017-7547, in . - - - - - Restart the postmaster after adding allow_system_table_mods - = true to postgresql.conf. (In versions - supporting ALTER SYSTEM, you can use that to make the - configuration change, but you'll still need a restart.) - - - - - - In each database of the cluster, - run the following commands as superuser: - -SET search_path = pg_catalog; -CREATE OR REPLACE VIEW pg_user_mappings AS - SELECT - U.oid AS umid, - S.oid AS srvid, - S.srvname AS srvname, - U.umuser AS umuser, - CASE WHEN U.umuser = 0 THEN - 'public' - ELSE - A.rolname - END AS usename, - CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) - OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) - OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) - THEN U.umoptions - ELSE NULL END AS umoptions - FROM pg_user_mapping U - LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN - pg_foreign_server S ON (U.umserver = S.oid); - - - - - - - Do not forget to include the template0 - and template1 databases, or the vulnerability will still - exist in databases you create later. To fix template0, - you'll need to temporarily make it accept connections. - In PostgreSQL 9.5 and later, you can use - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; - - and then after fixing template0, undo that with - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; - - In prior versions, instead use - -UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; -UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; - - - - - - - Finally, remove the allow_system_table_mods configuration - setting, and again restart the postmaster. - - - diff --git a/doc/src/sgml/release-9.4.sgml b/doc/src/sgml/release-9.4.sgml index 54265e677a..52d56d5f74 100644 --- a/doc/src/sgml/release-9.4.sgml +++ b/doc/src/sgml/release-9.4.sgml @@ -23,7 +23,12 @@ - However, if you are upgrading from a version earlier than 9.4.12, + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.4.12, see . @@ -33,6 +38,140 @@ + + + Further restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Noah Misch) + + + + The fix for CVE-2017-7486 was incorrect: it allowed a user + to see the options in her own user mapping, even if she did not + have USAGE permission on the associated foreign server. + Such options might include a password that had been provided by the + server owner rather than the user herself. + Since information_schema.user_mapping_options does not + show the options in such cases, pg_user_mappings + should not either. + (CVE-2017-7547) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user + AND (pg_has_role(S.srvowner, 'USAGE') + OR has_server_privilege(S.oid, 'USAGE'))) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Disallow empty passwords in all password-based authentication methods + (Heikki Linnakangas) + + + + libpq ignores empty password specifications, and does + not transmit them to the server. So, if a user's password has been + set to the empty string, it's impossible to log in with that password + via psql or other libpq-based + clients. An administrator might therefore believe that setting the + password to empty is equivalent to disabling password login. + However, with a modified or non-libpq-based client, + logging in could be possible, depending on which authentication + method is configured. In particular the most common + method, md5, accepted empty passwords. + Change the server to reject empty passwords in all cases. + (CVE-2017-7546) + + + + + + Make lo_put() check for UPDATE privilege on + the target large object (Tom Lane, Michael Paquier) + + + + lo_put() should surely require the same permissions + as lowrite(), but the check was missing, allowing any + user to change the data in a large object. + (CVE-2017-7548) + + + Fix concurrent locking of tuple update chains (Álvaro Herrera) @@ -601,77 +740,9 @@ Branch: REL9_4_STABLE [23a2b818f] 2017-08-05 14:56:40 -0700 By itself, this patch will only fix the behavior in newly initdb'd databases. If you wish to apply this change in an existing database, - you will need to do the following: + follow the corrected procedure shown in the changelog entry for + CVE-2017-7547, in . - - - - - Restart the postmaster after adding allow_system_table_mods - = true to postgresql.conf. (In versions - supporting ALTER SYSTEM, you can use that to make the - configuration change, but you'll still need a restart.) - - - - - - In each database of the cluster, - run the following commands as superuser: - -SET search_path = pg_catalog; -CREATE OR REPLACE VIEW pg_user_mappings AS - SELECT - U.oid AS umid, - S.oid AS srvid, - S.srvname AS srvname, - U.umuser AS umuser, - CASE WHEN U.umuser = 0 THEN - 'public' - ELSE - A.rolname - END AS usename, - CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) - OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) - OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) - THEN U.umoptions - ELSE NULL END AS umoptions - FROM pg_user_mapping U - LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN - pg_foreign_server S ON (U.umserver = S.oid); - - - - - - - Do not forget to include the template0 - and template1 databases, or the vulnerability will still - exist in databases you create later. To fix template0, - you'll need to temporarily make it accept connections. - In PostgreSQL 9.5 and later, you can use - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; - - and then after fixing template0, undo that with - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; - - In prior versions, instead use - -UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; -UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; - - - - - - - Finally, remove the allow_system_table_mods configuration - setting, and again restart the postmaster. - - - diff --git a/doc/src/sgml/release-9.5.sgml b/doc/src/sgml/release-9.5.sgml index 41b512038a..582e628082 100644 --- a/doc/src/sgml/release-9.5.sgml +++ b/doc/src/sgml/release-9.5.sgml @@ -23,7 +23,12 @@ - However, if you are upgrading from a version earlier than 9.5.7, + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.5.7, see . @@ -33,6 +38,140 @@ + + + Further restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Noah Misch) + + + + The fix for CVE-2017-7486 was incorrect: it allowed a user + to see the options in her own user mapping, even if she did not + have USAGE permission on the associated foreign server. + Such options might include a password that had been provided by the + server owner rather than the user herself. + Since information_schema.user_mapping_options does not + show the options in such cases, pg_user_mappings + should not either. + (CVE-2017-7547) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user + AND (pg_has_role(S.srvowner, 'USAGE') + OR has_server_privilege(S.oid, 'USAGE'))) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + Disallow empty passwords in all password-based authentication methods + (Heikki Linnakangas) + + + + libpq ignores empty password specifications, and does + not transmit them to the server. So, if a user's password has been + set to the empty string, it's impossible to log in with that password + via psql or other libpq-based + clients. An administrator might therefore believe that setting the + password to empty is equivalent to disabling password login. + However, with a modified or non-libpq-based client, + logging in could be possible, depending on which authentication + method is configured. In particular the most common + method, md5, accepted empty passwords. + Change the server to reject empty passwords in all cases. + (CVE-2017-7546) + + + + + + Make lo_put() check for UPDATE privilege on + the target large object (Tom Lane, Michael Paquier) + + + + lo_put() should surely require the same permissions + as lowrite(), but the check was missing, allowing any + user to change the data in a large object. + (CVE-2017-7548) + + + Correct the documentation about the process for upgrading standby @@ -635,77 +774,9 @@ Branch: REL9_2_STABLE [1188b9b2c] 2017-08-02 15:07:21 -0400 By itself, this patch will only fix the behavior in newly initdb'd databases. If you wish to apply this change in an existing database, - you will need to do the following: + follow the corrected procedure shown in the changelog entry for + CVE-2017-7547, in . - - - - - Restart the postmaster after adding allow_system_table_mods - = true to postgresql.conf. (In versions - supporting ALTER SYSTEM, you can use that to make the - configuration change, but you'll still need a restart.) - - - - - - In each database of the cluster, - run the following commands as superuser: - -SET search_path = pg_catalog; -CREATE OR REPLACE VIEW pg_user_mappings AS - SELECT - U.oid AS umid, - S.oid AS srvid, - S.srvname AS srvname, - U.umuser AS umuser, - CASE WHEN U.umuser = 0 THEN - 'public' - ELSE - A.rolname - END AS usename, - CASE WHEN (U.umuser <> 0 AND A.rolname = current_user) - OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) - OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) - THEN U.umoptions - ELSE NULL END AS umoptions - FROM pg_user_mapping U - LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN - pg_foreign_server S ON (U.umserver = S.oid); - - - - - - - Do not forget to include the template0 - and template1 databases, or the vulnerability will still - exist in databases you create later. To fix template0, - you'll need to temporarily make it accept connections. - In PostgreSQL 9.5 and later, you can use - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; - - and then after fixing template0, undo that with - -ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; - - In prior versions, instead use - -UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; -UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; - - - - - - - Finally, remove the allow_system_table_mods configuration - setting, and again restart the postmaster. - - - diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml index 93a24a383f..fbf8a0221e 100644 --- a/doc/src/sgml/release-9.6.sgml +++ b/doc/src/sgml/release-9.6.sgml @@ -23,7 +23,12 @@ - However, if you are upgrading from a version earlier than 9.6.3, + However, if you use foreign data servers that make use of user + passwords for authentication, see the first changelog entry below. + + + + Also, if you are upgrading from a version earlier than 9.6.3, see . @@ -35,6 +40,165 @@ + + Further restrict visibility + of pg_user_mappings.umoptions, to + protect passwords stored as user mapping options + (Noah Misch) + + + + The fix for CVE-2017-7486 was incorrect: it allowed a user + to see the options in her own user mapping, even if she did not + have USAGE permission on the associated foreign server. + Such options might include a password that had been provided by the + server owner rather than the user herself. + Since information_schema.user_mapping_options does not + show the options in such cases, pg_user_mappings + should not either. + (CVE-2017-7547) + + + + By itself, this patch will only fix the behavior in newly initdb'd + databases. If you wish to apply this change in an existing database, + you will need to do the following: + + + + + + Restart the postmaster after adding allow_system_table_mods + = true to postgresql.conf. (In versions + supporting ALTER SYSTEM, you can use that to make the + configuration change, but you'll still need a restart.) + + + + + + In each database of the cluster, + run the following commands as superuser: + +SET search_path = pg_catalog; +CREATE OR REPLACE VIEW pg_user_mappings AS + SELECT + U.oid AS umid, + S.oid AS srvid, + S.srvname AS srvname, + U.umuser AS umuser, + CASE WHEN U.umuser = 0 THEN + 'public' + ELSE + A.rolname + END AS usename, + CASE WHEN (U.umuser <> 0 AND A.rolname = current_user + AND (pg_has_role(S.srvowner, 'USAGE') + OR has_server_privilege(S.oid, 'USAGE'))) + OR (U.umuser = 0 AND pg_has_role(S.srvowner, 'USAGE')) + OR (SELECT rolsuper FROM pg_authid WHERE rolname = current_user) + THEN U.umoptions + ELSE NULL END AS umoptions + FROM pg_user_mapping U + LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN + pg_foreign_server S ON (U.umserver = S.oid); + + + + + + + Do not forget to include the template0 + and template1 databases, or the vulnerability will still + exist in databases you create later. To fix template0, + you'll need to temporarily make it accept connections. + In PostgreSQL 9.5 and later, you can use + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS true; + + and then after fixing template0, undo that with + +ALTER DATABASE template0 WITH ALLOW_CONNECTIONS false; + + In prior versions, instead use + +UPDATE pg_database SET datallowconn = true WHERE datname = 'template0'; +UPDATE pg_database SET datallowconn = false WHERE datname = 'template0'; + + + + + + + Finally, remove the allow_system_table_mods configuration + setting, and again restart the postmaster. + + + + + + + + + Disallow empty passwords in all password-based authentication methods + (Heikki Linnakangas) + + + + libpq ignores empty password specifications, and does + not transmit them to the server. So, if a user's password has been + set to the empty string, it's impossible to log in with that password + via psql or other libpq-based + clients. An administrator might therefore believe that setting the + password to empty is equivalent to disabling password login. + However, with a modified or non-libpq-based client, + logging in could be possible, depending on which authentication + method is configured. In particular the most common + method, md5, accepted empty passwords. + Change the server to reject empty passwords in all cases. + (CVE-2017-7546) + + + + + + + Make lo_put() check for UPDATE privilege on + the target large object (Tom Lane, Michael Paquier) + + + + lo_put() should surely require the same permissions + as lowrite(), but the check was missing, allowing any + user to change the data in a large object. + (CVE-2017-7548) + + + + + + + Release 9.2.23 + + + Release date: + 2017-08-31 + + + + This release contains a small number of fixes from 9.2.22. + For information about new features in the 9.2 major release, see + . + + + + The PostgreSQL community will stop releasing updates + for the 9.2.X release series in September 2017. + Users are encouraged to update to a newer release branch soon. + + + + Migration to Version 9.2.23 + + + A dump/restore is not required for those running 9.2.X. + + + + However, if you are upgrading from a version earlier than 9.2.22, + see . + + + + + + Changes + + + + + + Show foreign tables + in information_schema.table_privileges + view (Peter Eisentraut) + + + + All other relevant information_schema views include + foreign tables, but this one ignored them. + + + + Since this view definition is installed by initdb, + merely upgrading will not fix the problem. If you need to fix this + in an existing installation, you can, as a superuser, do this + in psql: + +BEGIN; +DROP SCHEMA information_schema CASCADE; +\i SHAREDIR/information_schema.sql +COMMIT; + + (Run pg_config --sharedir if you're uncertain + where SHAREDIR is.) This must be repeated in each + database to be fixed. + + + + + + Clean up handling of a fatal exit (e.g., due to receipt + of SIGTERM) that occurs while trying to execute + a ROLLBACK of a failed transaction (Tom Lane) + + + + This situation could result in an assertion failure. In production + builds, the exit would still occur, but it would log an unexpected + message about cannot drop active portal. + + + + + + Remove assertion that could trigger during a fatal exit (Tom Lane) + + + + + + Correctly identify columns that are of a range type or domain type over + a composite type or domain type being searched for (Tom Lane) + + + + Certain ALTER commands that change the definition of a + composite type or domain type are supposed to fail if there are any + stored values of that type in the database, because they lack the + infrastructure needed to update or check such values. Previously, + these checks could miss relevant values that are wrapped inside range + types or sub-domains, possibly allowing the database to become + inconsistent. + + + + + + Change ecpg's parser to allow RETURNING + clauses without attached C variables (Michael Meskes) + + + + This allows ecpg programs to contain SQL constructs + that use RETURNING internally (for example, inside a CTE) + rather than using it to define values to be returned to the client. + + + + + + Improve selection of compiler flags for PL/Perl on Windows (Tom Lane) + + + + This fix avoids possible crashes of PL/Perl due to inconsistent + assumptions about the width of time_t values. + A side-effect that may be visible to extension developers is + that _USE_32BIT_TIME_T is no longer defined globally + in PostgreSQL Windows builds. This is not expected + to cause problems, because type time_t is not used + in any PostgreSQL API definitions. + + + + + + + + Release 9.2.22 diff --git a/doc/src/sgml/release-9.3.sgml b/doc/src/sgml/release-9.3.sgml index abbfe5eaa4..ef86abb6ec 100644 --- a/doc/src/sgml/release-9.3.sgml +++ b/doc/src/sgml/release-9.3.sgml @@ -1,6 +1,146 @@ + + Release 9.3.19 + + + Release date: + 2017-08-31 + + + + This release contains a small number of fixes from 9.3.18. + For information about new features in the 9.3 major release, see + . + + + + Migration to Version 9.3.19 + + + A dump/restore is not required for those running 9.3.X. + + + + However, if you are upgrading from a version earlier than 9.3.18, + see . + + + + + + Changes + + + + + + Show foreign tables + in information_schema.table_privileges + view (Peter Eisentraut) + + + + All other relevant information_schema views include + foreign tables, but this one ignored them. + + + + Since this view definition is installed by initdb, + merely upgrading will not fix the problem. If you need to fix this + in an existing installation, you can, as a superuser, do this + in psql: + +BEGIN; +DROP SCHEMA information_schema CASCADE; +\i SHAREDIR/information_schema.sql +COMMIT; + + (Run pg_config --sharedir if you're uncertain + where SHAREDIR is.) This must be repeated in each + database to be fixed. + + + + + + Clean up handling of a fatal exit (e.g., due to receipt + of SIGTERM) that occurs while trying to execute + a ROLLBACK of a failed transaction (Tom Lane) + + + + This situation could result in an assertion failure. In production + builds, the exit would still occur, but it would log an unexpected + message about cannot drop active portal. + + + + + + Remove assertion that could trigger during a fatal exit (Tom Lane) + + + + + + Correctly identify columns that are of a range type or domain type over + a composite type or domain type being searched for (Tom Lane) + + + + Certain ALTER commands that change the definition of a + composite type or domain type are supposed to fail if there are any + stored values of that type in the database, because they lack the + infrastructure needed to update or check such values. Previously, + these checks could miss relevant values that are wrapped inside range + types or sub-domains, possibly allowing the database to become + inconsistent. + + + + + + Fix crash in pg_restore when using parallel mode and + using a list file to select a subset of items to restore (Tom Lane) + + + + + + Change ecpg's parser to allow RETURNING + clauses without attached C variables (Michael Meskes) + + + + This allows ecpg programs to contain SQL constructs + that use RETURNING internally (for example, inside a CTE) + rather than using it to define values to be returned to the client. + + + + + + Improve selection of compiler flags for PL/Perl on Windows (Tom Lane) + + + + This fix avoids possible crashes of PL/Perl due to inconsistent + assumptions about the width of time_t values. + A side-effect that may be visible to extension developers is + that _USE_32BIT_TIME_T is no longer defined globally + in PostgreSQL Windows builds. This is not expected + to cause problems, because type time_t is not used + in any PostgreSQL API definitions. + + + + + + + + Release 9.3.18 diff --git a/doc/src/sgml/release-9.4.sgml b/doc/src/sgml/release-9.4.sgml index 52d56d5f74..310e287c5b 100644 --- a/doc/src/sgml/release-9.4.sgml +++ b/doc/src/sgml/release-9.4.sgml @@ -1,6 +1,162 @@ + + Release 9.4.14 + + + Release date: + 2017-08-31 + + + + This release contains a small number of fixes from 9.4.13. + For information about new features in the 9.4 major release, see + . + + + + Migration to Version 9.4.14 + + + A dump/restore is not required for those running 9.4.X. + + + + However, if you are upgrading from a version earlier than 9.4.13, + see . + + + + + Changes + + + + + + + Fix failure of walsender processes to respond to shutdown signals + (Marco Nenciarini) + + + + A missed flag update resulted in walsenders continuing to run as long + as they had a standby server connected, preventing primary-server + shutdown unless immediate shutdown mode is used. + + + + + + Show foreign tables + in information_schema.table_privileges + view (Peter Eisentraut) + + + + All other relevant information_schema views include + foreign tables, but this one ignored them. + + + + Since this view definition is installed by initdb, + merely upgrading will not fix the problem. If you need to fix this + in an existing installation, you can, as a superuser, do this + in psql: + +BEGIN; +DROP SCHEMA information_schema CASCADE; +\i SHAREDIR/information_schema.sql +COMMIT; + + (Run pg_config --sharedir if you're uncertain + where SHAREDIR is.) This must be repeated in each + database to be fixed. + + + + + + Clean up handling of a fatal exit (e.g., due to receipt + of SIGTERM) that occurs while trying to execute + a ROLLBACK of a failed transaction (Tom Lane) + + + + This situation could result in an assertion failure. In production + builds, the exit would still occur, but it would log an unexpected + message about cannot drop active portal. + + + + + + Remove assertion that could trigger during a fatal exit (Tom Lane) + + + + + + Correctly identify columns that are of a range type or domain type over + a composite type or domain type being searched for (Tom Lane) + + + + Certain ALTER commands that change the definition of a + composite type or domain type are supposed to fail if there are any + stored values of that type in the database, because they lack the + infrastructure needed to update or check such values. Previously, + these checks could miss relevant values that are wrapped inside range + types or sub-domains, possibly allowing the database to become + inconsistent. + + + + + + Fix crash in pg_restore when using parallel mode and + using a list file to select a subset of items to restore (Tom Lane) + + + + + + Change ecpg's parser to allow RETURNING + clauses without attached C variables (Michael Meskes) + + + + This allows ecpg programs to contain SQL constructs + that use RETURNING internally (for example, inside a CTE) + rather than using it to define values to be returned to the client. + + + + + + Improve selection of compiler flags for PL/Perl on Windows (Tom Lane) + + + + This fix avoids possible crashes of PL/Perl due to inconsistent + assumptions about the width of time_t values. + A side-effect that may be visible to extension developers is + that _USE_32BIT_TIME_T is no longer defined globally + in PostgreSQL Windows builds. This is not expected + to cause problems, because type time_t is not used + in any PostgreSQL API definitions. + + + + + + + + Release 9.4.13 diff --git a/doc/src/sgml/release-9.5.sgml b/doc/src/sgml/release-9.5.sgml index 582e628082..37beac8b27 100644 --- a/doc/src/sgml/release-9.5.sgml +++ b/doc/src/sgml/release-9.5.sgml @@ -1,6 +1,152 @@ + + Release 9.5.9 + + + Release date: + 2017-08-31 + + + + This release contains a small number of fixes from 9.5.8. + For information about new features in the 9.5 major release, see + . + + + + Migration to Version 9.5.9 + + + A dump/restore is not required for those running 9.5.X. + + + + However, if you are upgrading from a version earlier than 9.5.8, + see . + + + + + Changes + + + + + + Show foreign tables + in information_schema.table_privileges + view (Peter Eisentraut) + + + + All other relevant information_schema views include + foreign tables, but this one ignored them. + + + + Since this view definition is installed by initdb, + merely upgrading will not fix the problem. If you need to fix this + in an existing installation, you can, as a superuser, do this + in psql: + +BEGIN; +DROP SCHEMA information_schema CASCADE; +\i SHAREDIR/information_schema.sql +COMMIT; + + (Run pg_config --sharedir if you're uncertain + where SHAREDIR is.) This must be repeated in each + database to be fixed. + + + + + + Clean up handling of a fatal exit (e.g., due to receipt + of SIGTERM) that occurs while trying to execute + a ROLLBACK of a failed transaction (Tom Lane) + + + + This situation could result in an assertion failure. In production + builds, the exit would still occur, but it would log an unexpected + message about cannot drop active portal. + + + + + + Remove assertion that could trigger during a fatal exit (Tom Lane) + + + + + + Correctly identify columns that are of a range type or domain type over + a composite type or domain type being searched for (Tom Lane) + + + + Certain ALTER commands that change the definition of a + composite type or domain type are supposed to fail if there are any + stored values of that type in the database, because they lack the + infrastructure needed to update or check such values. Previously, + these checks could miss relevant values that are wrapped inside range + types or sub-domains, possibly allowing the database to become + inconsistent. + + + + + + Fix crash in pg_restore when using parallel mode and + using a list file to select a subset of items to restore (Tom Lane) + + + + + + Change ecpg's parser to allow RETURNING + clauses without attached C variables (Michael Meskes) + + + + This allows ecpg programs to contain SQL constructs + that use RETURNING internally (for example, inside a CTE) + rather than using it to define values to be returned to the client. + + + + + + Improve selection of compiler flags for PL/Perl on Windows (Tom Lane) + + + + This fix avoids possible crashes of PL/Perl due to inconsistent + assumptions about the width of time_t values. + A side-effect that may be visible to extension developers is + that _USE_32BIT_TIME_T is no longer defined globally + in PostgreSQL Windows builds. This is not expected + to cause problems, because type time_t is not used + in any PostgreSQL API definitions. + + + + + + Fix make check to behave correctly when invoked via a + non-GNU make program (Thomas Munro) + + + + + + + + Release 9.5.8 diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml index fbf8a0221e..03be048938 100644 --- a/doc/src/sgml/release-9.6.sgml +++ b/doc/src/sgml/release-9.6.sgml @@ -1,6 +1,254 @@ + + Release 9.6.5 + + + Release date: + 2017-08-31 + + + + This release contains a small number of fixes from 9.6.4. + For information about new features in the 9.6 major release, see + . + + + + Migration to Version 9.6.5 + + + A dump/restore is not required for those running 9.6.X. + + + + However, if you are upgrading from a version earlier than 9.6.4, + see . + + + + + Changes + + + + + + + Show foreign tables + in information_schema.table_privileges + view (Peter Eisentraut) + + + + All other relevant information_schema views include + foreign tables, but this one ignored them. + + + + Since this view definition is installed by initdb, + merely upgrading will not fix the problem. If you need to fix this + in an existing installation, you can, as a superuser, do this + in psql: + +BEGIN; +DROP SCHEMA information_schema CASCADE; +\i SHAREDIR/information_schema.sql +COMMIT; + + (Run pg_config --sharedir if you're uncertain + where SHAREDIR is.) This must be repeated in each + database to be fixed. + + + + + + + Clean up handling of a fatal exit (e.g., due to receipt + of SIGTERM) that occurs while trying to execute + a ROLLBACK of a failed transaction (Tom Lane) + + + + This situation could result in an assertion failure. In production + builds, the exit would still occur, but it would log an unexpected + message about cannot drop active portal. + + + + + + + Remove assertion that could trigger during a fatal exit (Tom Lane) + + + + + + + Correctly identify columns that are of a range type or domain type over + a composite type or domain type being searched for (Tom Lane) + + + + Certain ALTER commands that change the definition of a + composite type or domain type are supposed to fail if there are any + stored values of that type in the database, because they lack the + infrastructure needed to update or check such values. Previously, + these checks could miss relevant values that are wrapped inside range + types or sub-domains, possibly allowing the database to become + inconsistent. + + + + + + + Prevent crash when passing fixed-length pass-by-reference data types + to parallel worker processes (Tom Lane) + + + + + + + Fix crash in pg_restore when using parallel mode and + using a list file to select a subset of items to restore (Tom Lane) + + + + + + + Change ecpg's parser to allow RETURNING + clauses without attached C variables (Michael Meskes) + + + + This allows ecpg programs to contain SQL constructs + that use RETURNING internally (for example, inside a CTE) + rather than using it to define values to be returned to the client. + + + + + + + Change ecpg's parser to recognize backslash + continuation of C preprocessor command lines (Michael Meskes) + + + + + + + Improve selection of compiler flags for PL/Perl on Windows (Tom Lane) + + + + This fix avoids possible crashes of PL/Perl due to inconsistent + assumptions about the width of time_t values. + A side-effect that may be visible to extension developers is + that _USE_32BIT_TIME_T is no longer defined globally + in PostgreSQL Windows builds. This is not expected + to cause problems, because type time_t is not used + in any PostgreSQL API definitions. + + + + + + + Fix make check to behave correctly when invoked via a + non-GNU make program (Thomas Munro) + + + + + + + + Release 9.6.4 From 8e80a5e25e85db2f1b9918cc230e4e198e653dc0 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Mon, 28 Aug 2017 10:17:39 -0400 Subject: [PATCH 0211/1139] Translation updates Source-Git-URL: git://git.postgresql.org/git/pgtranslation/messages.git Source-Git-Hash: d8e8b1a6b85b2fc2d39dcf97f8f8ec436554cc91 --- src/backend/po/de.po | 3564 +++++++++++------------ src/backend/po/es.po | 2289 +++++++-------- src/backend/po/ru.po | 3946 +++++++++++++------------- src/bin/initdb/po/es.po | 52 +- src/bin/initdb/po/ru.po | 6 +- src/bin/pg_basebackup/po/es.po | 133 +- src/bin/pg_basebackup/po/ru.po | 138 +- src/bin/pg_config/po/es.po | 2 +- src/bin/pg_controldata/po/es.po | 2 +- src/bin/pg_controldata/po/ru.po | 2 +- src/bin/pg_controldata/po/sv.po | 322 ++- src/bin/pg_ctl/po/es.po | 21 +- src/bin/pg_ctl/po/ru.po | 2 +- src/bin/pg_dump/po/es.po | 405 ++- src/bin/pg_dump/po/ru.po | 551 ++-- src/bin/pg_resetxlog/po/es.po | 238 +- src/bin/pg_resetxlog/po/ru.po | 244 +- src/bin/pg_rewind/po/es.po | 47 +- src/bin/pg_rewind/po/ru.po | 50 +- src/bin/psql/po/es.po | 1203 ++++---- src/bin/psql/po/ru.po | 1192 ++++---- src/bin/scripts/po/es.po | 6 +- src/bin/scripts/po/ru.po | 2 +- src/interfaces/ecpg/ecpglib/po/es.po | 2 +- src/interfaces/ecpg/ecpglib/po/ru.po | 2 +- src/interfaces/ecpg/preproc/po/es.po | 83 +- src/interfaces/ecpg/preproc/po/ru.po | 110 +- src/interfaces/libpq/po/es.po | 210 +- src/interfaces/libpq/po/ru.po | 221 +- src/pl/plperl/po/es.po | 88 +- src/pl/plperl/po/ru.po | 90 +- src/pl/plpgsql/src/po/es.po | 7 +- src/pl/plpgsql/src/po/ru.po | 2 +- src/pl/plpython/po/es.po | 22 +- src/pl/plpython/po/ru.po | 2 +- src/pl/tcl/po/es.po | 2 +- src/pl/tcl/po/ru.po | 2 +- 37 files changed, 7429 insertions(+), 7831 deletions(-) diff --git a/src/backend/po/de.po b/src/backend/po/de.po index 5ef5fc1455..ebaf875c91 100644 --- a/src/backend/po/de.po +++ b/src/backend/po/de.po @@ -7,8 +7,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-06 10:08+0000\n" -"PO-Revision-Date: 2017-02-06 09:10-0500\n" +"POT-Creation-Date: 2017-08-23 18:48+0000\n" +"PO-Revision-Date: 2017-08-27 11:58-0400\n" "Last-Translator: Peter Eisentraut \n" "Language-Team: German \n" "Language: de\n" @@ -25,8 +25,8 @@ msgstr "" msgid "not recorded" msgstr "nicht aufgezeichnet" -#: ../common/controldata_utils.c:52 commands/copy.c:2833 -#: commands/extension.c:3141 utils/adt/genfile.c:134 +#: ../common/controldata_utils.c:52 commands/copy.c:2834 +#: commands/extension.c:3144 utils/adt/genfile.c:134 #, c-format msgid "could not open file \"%s\" for reading: %m" msgstr "konnte Datei »%s« nicht zum Lesen öffnen: %m" @@ -37,13 +37,13 @@ msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: konnte Datei »%s« nicht zum Lesen öffnen: %s\n" #: ../common/controldata_utils.c:66 access/transam/timeline.c:346 -#: access/transam/xlog.c:3220 access/transam/xlog.c:10423 -#: access/transam/xlog.c:10436 access/transam/xlog.c:10828 -#: access/transam/xlog.c:10871 access/transam/xlog.c:10910 -#: access/transam/xlog.c:10953 access/transam/xlogfuncs.c:665 -#: access/transam/xlogfuncs.c:684 commands/extension.c:3151 -#: replication/logical/origin.c:665 replication/logical/origin.c:695 -#: replication/logical/reorderbuffer.c:3099 replication/walsender.c:499 +#: access/transam/xlog.c:3226 access/transam/xlog.c:10453 +#: access/transam/xlog.c:10466 access/transam/xlog.c:10861 +#: access/transam/xlog.c:10904 access/transam/xlog.c:10943 +#: access/transam/xlog.c:10986 access/transam/xlogfuncs.c:660 +#: access/transam/xlogfuncs.c:679 commands/extension.c:3154 +#: replication/logical/origin.c:668 replication/logical/origin.c:698 +#: replication/logical/reorderbuffer.c:3100 replication/walsender.c:504 #: storage/file/copydir.c:176 utils/adt/genfile.c:151 #, c-format msgid "could not read file \"%s\": %m" @@ -154,27 +154,27 @@ msgstr "konnte Verzeichnis »%s« nicht schließen: %s\n" #: ../common/psprintf.c:179 ../port/path.c:630 ../port/path.c:668 #: ../port/path.c:685 access/transam/twophase.c:1262 -#: access/transam/xlog.c:6108 lib/stringinfo.c:258 libpq/auth.c:850 -#: libpq/auth.c:1213 libpq/auth.c:1281 libpq/auth.c:1797 -#: postmaster/bgworker.c:289 postmaster/bgworker.c:796 -#: postmaster/postmaster.c:2335 postmaster/postmaster.c:2366 -#: postmaster/postmaster.c:3899 postmaster/postmaster.c:4589 -#: postmaster/postmaster.c:4664 postmaster/postmaster.c:5339 -#: postmaster/postmaster.c:5603 +#: access/transam/xlog.c:6114 lib/stringinfo.c:258 libpq/auth.c:864 +#: libpq/auth.c:1227 libpq/auth.c:1295 libpq/auth.c:1811 +#: postmaster/bgworker.c:310 postmaster/bgworker.c:813 +#: postmaster/postmaster.c:2357 postmaster/postmaster.c:2388 +#: postmaster/postmaster.c:3922 postmaster/postmaster.c:4620 +#: postmaster/postmaster.c:4695 postmaster/postmaster.c:5368 +#: postmaster/postmaster.c:5690 #: replication/libpqwalreceiver/libpqwalreceiver.c:143 -#: replication/logical/logical.c:168 storage/buffer/localbuf.c:436 -#: storage/file/fd.c:729 storage/file/fd.c:1126 storage/file/fd.c:1244 -#: storage/file/fd.c:1916 storage/ipc/procarray.c:1061 -#: storage/ipc/procarray.c:1547 storage/ipc/procarray.c:1554 -#: storage/ipc/procarray.c:1968 storage/ipc/procarray.c:2571 +#: replication/logical/logical.c:169 storage/buffer/localbuf.c:436 +#: storage/file/fd.c:736 storage/file/fd.c:1164 storage/file/fd.c:1282 +#: storage/file/fd.c:1993 storage/ipc/procarray.c:1062 +#: storage/ipc/procarray.c:1548 storage/ipc/procarray.c:1555 +#: storage/ipc/procarray.c:1969 storage/ipc/procarray.c:2580 #: utils/adt/formatting.c:1522 utils/adt/formatting.c:1642 #: utils/adt/formatting.c:1763 utils/adt/pg_locale.c:463 #: utils/adt/pg_locale.c:647 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 #: utils/adt/varlena.c:4461 utils/fmgr/dfmgr.c:216 utils/hash/dynahash.c:429 -#: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1047 utils/mb/mbutils.c:376 +#: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1046 utils/mb/mbutils.c:376 #: utils/mb/mbutils.c:709 utils/misc/guc.c:3888 utils/misc/guc.c:3904 #: utils/misc/guc.c:3917 utils/misc/guc.c:6863 utils/misc/tzparser.c:468 -#: utils/mmgr/aset.c:509 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 +#: utils/mmgr/aset.c:510 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 #: utils/mmgr/mcxt.c:839 utils/mmgr/mcxt.c:876 utils/mmgr/mcxt.c:910 #: utils/mmgr/mcxt.c:939 utils/mmgr/mcxt.c:973 utils/mmgr/mcxt.c:1055 #: utils/mmgr/mcxt.c:1089 utils/mmgr/mcxt.c:1138 @@ -242,7 +242,7 @@ msgstr "konnte Datei oder Verzeichnis »%s« nicht entfernen: %s\n" msgid "could not look up effective user ID %ld: %s" msgstr "konnte effektive Benutzer-ID %ld nicht nachschlagen: %s" -#: ../common/username.c:47 libpq/auth.c:1744 +#: ../common/username.c:47 libpq/auth.c:1758 msgid "user does not exist" msgstr "Benutzer existiert nicht" @@ -292,7 +292,7 @@ msgid "could not determine encoding for codeset \"%s\"" msgstr "konnte Kodierung für Codeset »%s« nicht bestimmen" #: ../port/chklocale.c:294 ../port/chklocale.c:423 -#: postmaster/postmaster.c:4868 +#: postmaster/postmaster.c:4899 #, c-format msgid "Please report this to ." msgstr "Bitte berichten Sie das an ." @@ -380,61 +380,76 @@ msgstr "»%s« ist kein BRIN-Index" msgid "could not open parent table of index %s" msgstr "konnte Basistabelle von Index %s nicht öffnen" -#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:362 -#: access/brin/brin_pageops.c:828 +#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:360 +#: access/brin/brin_pageops.c:824 access/gin/ginentrypage.c:109 +#: access/gist/gist.c:1337 access/nbtree/nbtinsert.c:576 +#: access/nbtree/nbtsort.c:488 access/spgist/spgdoinsert.c:1907 #, c-format -msgid "index row size %lu exceeds maximum %lu for index \"%s\"" -msgstr "Größe %lu der Indexzeile überschreitet Maximum %lu für Index »%s«" +msgid "index row size %zu exceeds maximum %zu for index \"%s\"" +msgstr "Größe %zu der Indexzeile überschreitet Maximum %zu für Index »%s«" #: access/brin/brin_revmap.c:459 #, c-format msgid "unexpected page type 0x%04X in BRIN index \"%s\" block %u" msgstr "unerwarteter Seitentyp 0x%04X in BRIN-Index »%s« Block %u" -#: access/brin/brin_validate.c:115 +#: access/brin/brin_validate.c:115 access/gin/ginvalidate.c:148 +#: access/gist/gistvalidate.c:145 access/hash/hashvalidate.c:130 +#: access/nbtree/nbtvalidate.c:100 access/spgist/spgvalidate.c:115 #, c-format -msgid "brin operator family \"%s\" contains function %s with invalid support number %d" -msgstr "BRIN-Operatorfamilie »%s« enthält Funktion %s mit ungültiger Support-Nummer %d" +msgid "operator family \"%s\" of access method %s contains function %s with invalid support number %d" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält Funktion %s mit ungültiger Support-Nummer %d" -#: access/brin/brin_validate.c:131 +#: access/brin/brin_validate.c:131 access/gin/ginvalidate.c:160 +#: access/gist/gistvalidate.c:157 access/hash/hashvalidate.c:113 +#: access/nbtree/nbtvalidate.c:112 access/spgist/spgvalidate.c:127 #, c-format -msgid "brin operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "BRIN-Operatorfamilie »%s« enthält Funktion %s mit falscher Signatur für Support-Nummer %d" +msgid "operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält Funktion %s mit falscher Signatur für Support-Nummer %d" -#: access/brin/brin_validate.c:153 +#: access/brin/brin_validate.c:153 access/gin/ginvalidate.c:179 +#: access/gist/gistvalidate.c:177 access/hash/hashvalidate.c:151 +#: access/nbtree/nbtvalidate.c:132 access/spgist/spgvalidate.c:146 #, c-format -msgid "brin operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "BRIN-Operatorfamilie »%s« enthält Operator %s mit ungültiger Strategienummer %d" +msgid "operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält Operator %s mit ungültiger Strategienummer %d" -#: access/brin/brin_validate.c:182 +#: access/brin/brin_validate.c:182 access/gin/ginvalidate.c:192 +#: access/hash/hashvalidate.c:164 access/nbtree/nbtvalidate.c:145 +#: access/spgist/spgvalidate.c:159 #, c-format -msgid "brin operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "BRIN-Operatorfamilie »%s« enthält ungültige ORDER-BY-Angabe für Operator %s" +msgid "operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält ungültige ORDER-BY-Angabe für Operator %s" -#: access/brin/brin_validate.c:195 +#: access/brin/brin_validate.c:195 access/gin/ginvalidate.c:205 +#: access/gist/gistvalidate.c:225 access/hash/hashvalidate.c:177 +#: access/nbtree/nbtvalidate.c:158 access/spgist/spgvalidate.c:172 #, c-format -msgid "brin operator family \"%s\" contains operator %s with wrong signature" -msgstr "BRIN-Operatorfamilie »%s« enthält Operator %s mit falscher Signatur" +msgid "operator family \"%s\" of access method %s contains operator %s with wrong signature" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält Operator %s mit falscher Signatur" -#: access/brin/brin_validate.c:233 +#: access/brin/brin_validate.c:233 access/hash/hashvalidate.c:217 +#: access/nbtree/nbtvalidate.c:200 access/spgist/spgvalidate.c:200 #, c-format -msgid "brin operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "in BRIN-Operatorfamilie »%s« fehlen Operatoren für Typen %s und %s" +msgid "operator family \"%s\" of access method %s is missing operator(s) for types %s and %s" +msgstr "in Operatorfamilie »%s« für Zugriffsmethode %s fehlen Operatoren für Typen %s und %s" #: access/brin/brin_validate.c:243 #, c-format -msgid "brin operator family \"%s\" is missing support function(s) for types %s and %s" -msgstr "in BRIN-Operatorfamilie »%s« fehlen Support-Funktionen für Typen %s und %s" +msgid "operator family \"%s\" of access method %s is missing support function(s) for types %s and %s" +msgstr "in Operatorfamilie »%s« für Zugriffsmethode %s fehlen Support-Funktionen für Typen %s und %s" -#: access/brin/brin_validate.c:256 +#: access/brin/brin_validate.c:256 access/hash/hashvalidate.c:231 +#: access/nbtree/nbtvalidate.c:224 access/spgist/spgvalidate.c:233 #, c-format -msgid "brin operator class \"%s\" is missing operator(s)" -msgstr "in BRIN-Operatorklasse »%s« fehlen Operatoren" +msgid "operator class \"%s\" of access method %s is missing operator(s)" +msgstr "in Operatorklasse »%s« für Zugriffsmethode %s fehlen Operatoren" -#: access/brin/brin_validate.c:267 +#: access/brin/brin_validate.c:267 access/gin/ginvalidate.c:246 +#: access/gist/gistvalidate.c:264 #, c-format -msgid "brin operator class \"%s\" is missing support function %d" -msgstr "in BRIN-Operatorklasse »%s« fehlt Support-Funktion %d" +msgid "operator class \"%s\" of access method %s is missing support function %d" +msgstr "in Operatorklasse »%s« für Zugriffsmethode %s fehlt Support-Funktion %d" #: access/common/heaptuple.c:708 access/common/heaptuple.c:1339 #, c-format @@ -451,8 +466,8 @@ msgstr "Anzahl der Indexspalten (%d) überschreitet Maximum (%d)" msgid "index row requires %zu bytes, maximum size is %zu" msgstr "Indexzeile benötigt %zu Bytes, Maximalgröße ist %zu" -#: access/common/printtup.c:292 tcop/fastpath.c:182 tcop/fastpath.c:544 -#: tcop/postgres.c:1719 +#: access/common/printtup.c:292 tcop/fastpath.c:182 tcop/fastpath.c:532 +#: tcop/postgres.c:1711 #, c-format msgid "unsupported format code: %d" msgstr "nicht unterstützter Formatcode: %d" @@ -547,18 +562,11 @@ msgstr "Posting-Liste ist zu lang" msgid "Reduce maintenance_work_mem." msgstr "Reduzieren Sie maintenance_work_mem." -#: access/gin/ginentrypage.c:109 access/gist/gist.c:1337 -#: access/nbtree/nbtinsert.c:576 access/nbtree/nbtsort.c:488 -#: access/spgist/spgdoinsert.c:1907 -#, c-format -msgid "index row size %zu exceeds maximum %zu for index \"%s\"" -msgstr "Größe %zu der Indexzeile überschreitet Maximum %zu für Index »%s«" - -#: access/gin/ginfast.c:989 access/transam/xlog.c:9858 -#: access/transam/xlog.c:10362 access/transam/xlogfuncs.c:293 -#: access/transam/xlogfuncs.c:320 access/transam/xlogfuncs.c:359 -#: access/transam/xlogfuncs.c:380 access/transam/xlogfuncs.c:401 -#: access/transam/xlogfuncs.c:471 access/transam/xlogfuncs.c:527 +#: access/gin/ginfast.c:989 access/transam/xlog.c:9875 +#: access/transam/xlog.c:10392 access/transam/xlogfuncs.c:288 +#: access/transam/xlogfuncs.c:315 access/transam/xlogfuncs.c:354 +#: access/transam/xlogfuncs.c:375 access/transam/xlogfuncs.c:396 +#: access/transam/xlogfuncs.c:466 access/transam/xlogfuncs.c:522 #, c-format msgid "recovery is in progress" msgstr "Wiederherstellung läuft" @@ -588,45 +596,16 @@ msgstr "alte GIN-Indexe unterstützen keine Scans des ganzen Index oder Suchen n msgid "To fix this, do REINDEX INDEX \"%s\"." msgstr "Um das zu reparieren, führen Sie REINDEX INDEX \"%s\" aus." -#: access/gin/ginvalidate.c:92 -#, c-format -msgid "gin operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "GIN-Operatorfamilie »%s« enthält Support-Prozedur %s mit typübergreifender Registrierung" - -#: access/gin/ginvalidate.c:148 -#, c-format -msgid "gin operator family \"%s\" contains function %s with invalid support number %d" -msgstr "GIN-Operatorfamilie »%s« enthält Funktion %s mit ungültiger Support-Nummer %d" - -#: access/gin/ginvalidate.c:160 -#, c-format -msgid "gin operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "GIN-Operatorfamilie »%s« enthält Funktion %s mit falscher Signatur für Support-Nummer %d" - -#: access/gin/ginvalidate.c:179 -#, c-format -msgid "gin operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "GIN-Operatorfamilie »%s« enthält Operator %s mit ungültiger Strategienummer %d" - -#: access/gin/ginvalidate.c:192 -#, c-format -msgid "gin operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "GIN-Operatorfamilie »%s« enthält ungültige ORDER-BY-Angabe für Operator %s" - -#: access/gin/ginvalidate.c:205 -#, c-format -msgid "gin operator family \"%s\" contains operator %s with wrong signature" -msgstr "GIN-Operatorfamilie »%s« enthält Operator %s mit falscher Signatur" - -#: access/gin/ginvalidate.c:246 +#: access/gin/ginvalidate.c:92 access/gist/gistvalidate.c:92 +#: access/hash/hashvalidate.c:98 access/spgist/spgvalidate.c:92 #, c-format -msgid "gin operator class \"%s\" is missing support function %d" -msgstr "in GIN-Operatorklasse »%s« fehlt Support-Funktion %d" +msgid "operator family \"%s\" of access method %s contains support procedure %s with different left and right input types" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält Support-Prozedur %s mit unterschiedlichen linken und rechten Eingabetypen" #: access/gin/ginvalidate.c:256 #, c-format -msgid "gin operator class \"%s\" is missing support function %d or %d" -msgstr "in GIN-Operatorklasse »%s« fehlt Support-Funktion %d oder %d" +msgid "operator class \"%s\" of access method %s is missing support function %d or %d" +msgstr "in Operatorklasse »%s« für Zugriffsmethode %s fehlt Support-Funktion %d oder %d" #: access/gist/gist.c:680 access/gist/gistvacuum.c:258 #, c-format @@ -684,45 +663,15 @@ msgstr "Index »%s« enthält unerwartete Nullseite bei Block %u" msgid "index \"%s\" contains corrupted page at block %u" msgstr "Index »%s« enthält korrupte Seite bei Block %u" -#: access/gist/gistvalidate.c:92 -#, c-format -msgid "gist operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "GiST-Operatorfamilie »%s« enthält Support-Prozedur %s mit typübergreifender Registrierung" - -#: access/gist/gistvalidate.c:145 -#, c-format -msgid "gist operator family \"%s\" contains function %s with invalid support number %d" -msgstr "GiST-Operatorfamilie »%s« enthält Funktion %s mit ungültiger Support-Nummer %d" - -#: access/gist/gistvalidate.c:157 -#, c-format -msgid "gist operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "GiST-Operatorfamilie »%s« enthält Funktion %s mit falscher Signatur für Support-Nummer %d" - -#: access/gist/gistvalidate.c:177 -#, c-format -msgid "gist operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "GiST-Operatorfamilie »%s« enthält Operator %s mit ungültiger Strategienummer %d" - #: access/gist/gistvalidate.c:195 #, c-format -msgid "gist operator family \"%s\" contains unsupported ORDER BY specification for operator %s" -msgstr "GiST-Operatorfamilie »%s« enthält nicht unterstützte ORDER-BY-Angabe für Operator %s" +msgid "operator family \"%s\" of access method %s contains unsupported ORDER BY specification for operator %s" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält nicht unterstützte ORDER-BY-Angabe für Operator %s" #: access/gist/gistvalidate.c:206 #, c-format -msgid "gist operator family \"%s\" contains incorrect ORDER BY opfamily specification for operator %s" -msgstr "GiST-Operatorfamilie »%s« enthält ungültige ORDER-BY-Operatorfamilienangabe für Operator %s" - -#: access/gist/gistvalidate.c:225 -#, c-format -msgid "gist operator family \"%s\" contains operator %s with wrong signature" -msgstr "GiST-Operatorfamilie »%s« enthält Operator %s mit falscher Signatur" - -#: access/gist/gistvalidate.c:264 -#, c-format -msgid "gist operator class \"%s\" is missing support function %d" -msgstr "in GiST-Operatorklasse »%s« fehlt Support-Funktion %d" +msgid "operator family \"%s\" of access method %s contains incorrect ORDER BY opfamily specification for operator %s" +msgstr "Operatorfamilie »%s« für Zugriffsmethode %s enthält ungültige ORDER-BY-Operatorfamilienangabe für Operator %s" #: access/hash/hashinsert.c:70 #, c-format @@ -755,55 +704,15 @@ msgstr "Index »%s« ist kein Hash-Index" msgid "index \"%s\" has wrong hash version" msgstr "Index »%s« hat falsche Hash-Version" -#: access/hash/hashvalidate.c:98 -#, c-format -msgid "hash operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "Hash-Operatorfamilie »%s« enthält Support-Prozedur %s mit typübergreifender Registrierung" - -#: access/hash/hashvalidate.c:113 -#, c-format -msgid "hash operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "Hash-Operatorfamilie »%s« enthält Funktion %s mit falscher Signatur für Support-Nummer %d" - -#: access/hash/hashvalidate.c:130 -#, c-format -msgid "hash operator family \"%s\" contains function %s with invalid support number %d" -msgstr "Hash-Operatorfamilie »%s« enthält Funktion %s mit ungültiger Support-Nummer %d" - -#: access/hash/hashvalidate.c:151 -#, c-format -msgid "hash operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "Hash-Operatorfamilie »%s« enthält Operator %s mit ungültiger Strategienummer %d" - -#: access/hash/hashvalidate.c:164 -#, c-format -msgid "hash operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "Hash-Operatorfamilie »%s« enthält ungültige ORDER-BY-Angabe für Operator %s" - -#: access/hash/hashvalidate.c:177 -#, c-format -msgid "hash operator family \"%s\" contains operator %s with wrong signature" -msgstr "Hash-Operatorfamilie »%s« enthält Operator %s mit falscher Signatur" - #: access/hash/hashvalidate.c:189 #, c-format -msgid "hash operator family \"%s\" lacks support function for operator %s" -msgstr "in Hash-Operatorfamilie »%s« fehlt Support-Funktion für Operator %s" +msgid "operator family \"%s\" of access method %s lacks support function for operator %s" +msgstr "in Operatorfamilie »%s« für Zugriffsmethode %s fehlt Support-Funktion für Operator %s" -#: access/hash/hashvalidate.c:217 +#: access/hash/hashvalidate.c:247 access/nbtree/nbtvalidate.c:241 #, c-format -msgid "hash operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "in Hash-Operatorfamilie »%s« fehlen Operatoren für Typen %s und %s" - -#: access/hash/hashvalidate.c:231 -#, c-format -msgid "hash operator class \"%s\" is missing operator(s)" -msgstr "in Hash-Operatorklasse »%s« fehlen Operatoren" - -#: access/hash/hashvalidate.c:247 -#, c-format -msgid "hash operator family \"%s\" is missing cross-type operator(s)" -msgstr "in Hash-Operatorfamilie »%s« fehlen typübergreifende Operatoren" +msgid "operator family \"%s\" of access method %s is missing cross-type operator(s)" +msgstr "in Operatorfamilie »%s« für Zugriffsmethode %s fehlen typübergreifende Operatoren" #: access/heap/heapam.c:1295 access/heap/heapam.c:1323 #: access/heap/heapam.c:1355 catalog/aclchk.c:1756 @@ -812,8 +721,8 @@ msgid "\"%s\" is an index" msgstr "»%s« ist ein Index" #: access/heap/heapam.c:1300 access/heap/heapam.c:1328 -#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9081 -#: commands/tablecmds.c:12189 +#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9095 +#: commands/tablecmds.c:12203 #, c-format msgid "\"%s\" is a composite type" msgstr "»%s« ist ein zusammengesetzter Typ" @@ -833,7 +742,7 @@ msgstr "während einer parallelen Operation können keine Tupel gelöscht werden msgid "attempted to delete invisible tuple" msgstr "Versuch ein unsichtbares Tupel zu löschen" -#: access/heap/heapam.c:3489 access/heap/heapam.c:6240 +#: access/heap/heapam.c:3489 access/heap/heapam.c:6274 #, c-format msgid "cannot update tuples during a parallel operation" msgstr "während einer parallelen Operation können keine Tupel aktualisiert werden" @@ -843,8 +752,8 @@ msgstr "während einer parallelen Operation können keine Tupel aktualisiert wer msgid "attempted to update invisible tuple" msgstr "Versuch ein unsichtbares Tupel zu aktualisieren" -#: access/heap/heapam.c:4963 access/heap/heapam.c:5001 -#: access/heap/heapam.c:5253 executor/execMain.c:2314 +#: access/heap/heapam.c:4964 access/heap/heapam.c:5002 +#: access/heap/heapam.c:5254 executor/execMain.c:2314 #, c-format msgid "could not obtain lock on row in relation \"%s\"" msgstr "konnte Sperre für Zeile in Relation »%s« nicht setzen" @@ -861,10 +770,10 @@ msgstr "konnte nicht in Datei »%s« schreiben, %d von %d geschrieben: %m" #: access/heap/rewriteheap.c:963 access/heap/rewriteheap.c:1175 #: access/heap/rewriteheap.c:1272 access/transam/timeline.c:407 -#: access/transam/timeline.c:483 access/transam/xlog.c:3087 -#: access/transam/xlog.c:3249 replication/logical/snapbuild.c:1605 -#: replication/slot.c:1088 replication/slot.c:1173 storage/file/fd.c:624 -#: storage/file/fd.c:3052 storage/smgr/md.c:1041 storage/smgr/md.c:1274 +#: access/transam/timeline.c:483 access/transam/xlog.c:3093 +#: access/transam/xlog.c:3255 replication/logical/snapbuild.c:1605 +#: replication/slot.c:1105 replication/slot.c:1190 storage/file/fd.c:631 +#: storage/file/fd.c:3129 storage/smgr/md.c:1041 storage/smgr/md.c:1274 #: storage/smgr/md.c:1447 utils/misc/guc.c:6885 #, c-format msgid "could not fsync file \"%s\": %m" @@ -872,10 +781,10 @@ msgstr "konnte Datei »%s« nicht fsyncen: %m" #: access/heap/rewriteheap.c:1018 access/heap/rewriteheap.c:1138 #: access/transam/timeline.c:315 access/transam/timeline.c:461 -#: access/transam/xlog.c:3043 access/transam/xlog.c:3192 -#: access/transam/xlog.c:10192 access/transam/xlog.c:10230 -#: access/transam/xlog.c:10603 postmaster/postmaster.c:4364 -#: replication/logical/origin.c:542 replication/slot.c:1045 +#: access/transam/xlog.c:3049 access/transam/xlog.c:3198 +#: access/transam/xlog.c:10209 access/transam/xlog.c:10247 +#: access/transam/xlog.c:10636 postmaster/postmaster.c:4387 +#: replication/logical/origin.c:542 replication/slot.c:1062 #: storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1275 #, c-format msgid "could not create file \"%s\": %m" @@ -886,7 +795,7 @@ msgstr "konnte Datei »%s« nicht erstellen: %m" msgid "could not truncate file \"%s\" to %u: %m" msgstr "konnte Datei »%s« nicht auf %u kürzen: %m" -#: access/heap/rewriteheap.c:1154 replication/walsender.c:481 +#: access/heap/rewriteheap.c:1154 replication/walsender.c:486 #: storage/smgr/md.c:1899 #, c-format msgid "could not seek to end of file \"%s\": %m" @@ -894,11 +803,11 @@ msgstr "konnte Positionszeiger nicht ans Ende der Datei »%s« setzen: %m" #: access/heap/rewriteheap.c:1165 access/transam/timeline.c:367 #: access/transam/timeline.c:401 access/transam/timeline.c:477 -#: access/transam/xlog.c:3078 access/transam/xlog.c:3242 -#: postmaster/postmaster.c:4374 postmaster/postmaster.c:4384 -#: replication/logical/origin.c:551 replication/logical/origin.c:587 -#: replication/logical/origin.c:603 replication/logical/snapbuild.c:1589 -#: replication/slot.c:1074 storage/file/copydir.c:187 +#: access/transam/xlog.c:3084 access/transam/xlog.c:3248 +#: postmaster/postmaster.c:4397 postmaster/postmaster.c:4407 +#: replication/logical/origin.c:551 replication/logical/origin.c:590 +#: replication/logical/origin.c:606 replication/logical/snapbuild.c:1589 +#: replication/slot.c:1091 storage/file/copydir.c:187 #: utils/init/miscinit.c:1228 utils/init/miscinit.c:1237 #: utils/init/miscinit.c:1244 utils/misc/guc.c:6846 utils/misc/guc.c:6877 #: utils/misc/guc.c:8727 utils/misc/guc.c:8741 utils/time/snapmgr.c:1280 @@ -907,12 +816,12 @@ msgstr "konnte Positionszeiger nicht ans Ende der Datei »%s« setzen: %m" msgid "could not write to file \"%s\": %m" msgstr "konnte nicht in Datei »%s« schreiben: %m" -#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10441 +#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10471 #: access/transam/xlogarchive.c:114 access/transam/xlogarchive.c:468 -#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2632 -#: replication/logical/reorderbuffer.c:2689 -#: replication/logical/snapbuild.c:1533 replication/logical/snapbuild.c:1908 -#: replication/slot.c:1147 storage/ipc/dsm.c:326 storage/smgr/md.c:427 +#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2633 +#: replication/logical/reorderbuffer.c:2690 +#: replication/logical/snapbuild.c:1538 replication/logical/snapbuild.c:1901 +#: replication/slot.c:1164 storage/ipc/dsm.c:326 storage/smgr/md.c:427 #: storage/smgr/md.c:476 storage/smgr/md.c:1394 #, c-format msgid "could not remove file \"%s\": %m" @@ -920,17 +829,17 @@ msgstr "konnte Datei »%s« nicht löschen: %m" #: access/heap/rewriteheap.c:1262 access/transam/timeline.c:111 #: access/transam/timeline.c:236 access/transam/timeline.c:334 -#: access/transam/xlog.c:3019 access/transam/xlog.c:3136 -#: access/transam/xlog.c:3177 access/transam/xlog.c:3450 -#: access/transam/xlog.c:3528 access/transam/xlogutils.c:701 +#: access/transam/xlog.c:3025 access/transam/xlog.c:3142 +#: access/transam/xlog.c:3183 access/transam/xlog.c:3456 +#: access/transam/xlog.c:3534 access/transam/xlogutils.c:701 #: replication/basebackup.c:403 replication/basebackup.c:1150 -#: replication/logical/origin.c:658 replication/logical/reorderbuffer.c:2156 -#: replication/logical/reorderbuffer.c:2402 -#: replication/logical/reorderbuffer.c:3081 +#: replication/logical/origin.c:661 replication/logical/reorderbuffer.c:2156 +#: replication/logical/reorderbuffer.c:2403 +#: replication/logical/reorderbuffer.c:3082 #: replication/logical/snapbuild.c:1582 replication/logical/snapbuild.c:1666 -#: replication/slot.c:1162 replication/walsender.c:474 -#: replication/walsender.c:2102 storage/file/copydir.c:155 -#: storage/file/fd.c:607 storage/file/fd.c:2964 storage/file/fd.c:3031 +#: replication/slot.c:1179 replication/walsender.c:479 +#: replication/walsender.c:2144 storage/file/copydir.c:155 +#: storage/file/fd.c:614 storage/file/fd.c:3041 storage/file/fd.c:3108 #: storage/smgr/md.c:609 utils/error/elog.c:1879 utils/init/miscinit.c:1163 #: utils/init/miscinit.c:1284 utils/init/miscinit.c:1362 utils/misc/guc.c:7105 #: utils/misc/guc.c:7138 @@ -949,8 +858,8 @@ msgid "index access method \"%s\" does not have a handler" msgstr "Indexzugriffsmethode »%s« hat keinen Handler" #: access/index/indexam.c:155 catalog/objectaddress.c:1196 -#: commands/indexcmds.c:1799 commands/tablecmds.c:242 -#: commands/tablecmds.c:12180 +#: commands/indexcmds.c:1800 commands/tablecmds.c:242 +#: commands/tablecmds.c:12194 #, c-format msgid "\"%s\" is not an index" msgstr "»%s« ist kein Index" @@ -985,7 +894,7 @@ msgstr "" "Erstellen Sie eventuell einen Funktionsindex auf einen MD5-Hash oder verwenden Sie Volltextindizierung." #: access/nbtree/nbtpage.c:168 access/nbtree/nbtpage.c:371 -#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1702 +#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1703 #, c-format msgid "index \"%s\" is not a btree" msgstr "Index »%s« ist kein B-Tree" @@ -1006,100 +915,20 @@ msgstr "Index »%s« enthält eine halbtote interne Seite" msgid "This can be caused by an interrupted VACUUM in version 9.3 or older, before upgrade. Please REINDEX it." msgstr "Die Ursache kann ein unterbrochenes VACUUM in Version 9.3 oder älter vor dem Upgrade sein. Bitte REINDEX durchführen." -#: access/nbtree/nbtvalidate.c:100 -#, c-format -msgid "btree operator family \"%s\" contains function %s with invalid support number %d" -msgstr "B-Tree-Operatorfamilie »%s« enthält Funktion %s mit ungültiger Support-Nummer %d" - -#: access/nbtree/nbtvalidate.c:112 -#, c-format -msgid "btree operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "B-Tree-Operatorfamilie »%s« enthält Funktion %s mit falscher Signatur für Support-Nummer %d" - -#: access/nbtree/nbtvalidate.c:132 -#, c-format -msgid "btree operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "B-Tree-Operatorfamilie »%s« enthält Operator %s mit ungültiger Strategienummer %d" - -#: access/nbtree/nbtvalidate.c:145 -#, c-format -msgid "btree operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "B-Tree-Operatorfamilie »%s« enthält ungültige ORDER-BY-Angabe für Operator %s" - -#: access/nbtree/nbtvalidate.c:158 -#, c-format -msgid "btree operator family \"%s\" contains operator %s with wrong signature" -msgstr "B-Tree-Operatorfamilie »%s« enthält Operator %s mit falscher Signatur" - -#: access/nbtree/nbtvalidate.c:200 -#, c-format -msgid "btree operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "in B-Tree-Operatorfamilie »%s« fehlen Operatoren für Typen %s und %s" - #: access/nbtree/nbtvalidate.c:210 #, c-format -msgid "btree operator family \"%s\" is missing support function for types %s and %s" -msgstr "in B-Tree-Operatorfamilie »%s« fehlen Support-Funktionen für Typen %s und %s" - -#: access/nbtree/nbtvalidate.c:224 -#, c-format -msgid "btree operator class \"%s\" is missing operator(s)" -msgstr "in B-Tree-Operatorklasse »%s« fehlen Operatoren" - -#: access/nbtree/nbtvalidate.c:241 -#, c-format -msgid "btree operator family \"%s\" is missing cross-type operator(s)" -msgstr "in B-Tree-Operatorfamilie »%s« fehlen typübergreifende Operatoren" +msgid "operator family \"%s\" of access method %s is missing support function for types %s and %s" +msgstr "in Operatorfamilie »%s« für Zugriffsmethode %s fehlt Support-Funktion für Typen %s und %s" #: access/spgist/spgutils.c:700 #, c-format msgid "SP-GiST inner tuple size %zu exceeds maximum %zu" msgstr "innere Tupelgröße %zu überschreitet SP-GiST-Maximum %zu" -#: access/spgist/spgvalidate.c:92 -#, c-format -msgid "spgist operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "SPGiST-Operatorfamilie »%s« enthält Support-Prozedur %s mit typübergreifender Registrierung" - -#: access/spgist/spgvalidate.c:115 -#, c-format -msgid "spgist operator family \"%s\" contains function %s with invalid support number %d" -msgstr "SPGiST-Operatorfamilie »%s« enthält Funktion %s mit ungültiger Support-Nummer %d" - -#: access/spgist/spgvalidate.c:127 -#, c-format -msgid "spgist operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "SPGiST-Operatorfamilie »%s« enthält Funktion %s mit falscher Signatur für Support-Nummer %d" - -#: access/spgist/spgvalidate.c:146 -#, c-format -msgid "spgist operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "SPGiST-Operatorfamilie »%s« enthält Operator %s mit ungültiger Strategienummer %d" - -#: access/spgist/spgvalidate.c:159 -#, c-format -msgid "spgist operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "SPGiST-Operatorfamilie »%s« enthält ungültige ORDER-BY-Angabe für Operator %s" - -#: access/spgist/spgvalidate.c:172 -#, c-format -msgid "spgist operator family \"%s\" contains operator %s with wrong signature" -msgstr "SPGiST-Operatorfamilie »%s« enthält Operator %s mit falscher Signatur" - -#: access/spgist/spgvalidate.c:200 -#, c-format -msgid "spgist operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "in SPGiST-Operatorfamilie »%s« fehlen Operatoren für Typen %s und %s" - #: access/spgist/spgvalidate.c:220 #, c-format -msgid "spgist operator family \"%s\" is missing support function %d for type %s" -msgstr "in SPGiST-Operatorfamilie »%s« fehlt Support-Funktion %d für Typ %s" - -#: access/spgist/spgvalidate.c:233 -#, c-format -msgid "spgist operator class \"%s\" is missing operator(s)" -msgstr "in SPGiST-Operatorklasse »%s« fehlen Operatoren" +msgid "operator family \"%s\" of access method %s is missing support function %d for type %s" +msgstr "in Operatorfamilie »%s« für Zugriffsmethode %s fehlt Support-Funktion %d für Typ %s" #: access/tablesample/bernoulli.c:152 access/tablesample/system.c:156 #, c-format @@ -1250,78 +1079,78 @@ msgstr "kann nicht bis MultiXact %u trunkieren, weil sie nicht auf der Festplatt msgid "invalid MultiXactId: %u" msgstr "ungültige MultiXactId: %u" -#: access/transam/parallel.c:589 +#: access/transam/parallel.c:610 #, c-format msgid "postmaster exited during a parallel transaction" msgstr "Postmaster beendete während einer parallelen Transaktion" -#: access/transam/parallel.c:774 +#: access/transam/parallel.c:799 #, c-format msgid "lost connection to parallel worker" msgstr "Verbindung mit parallelem Arbeitsprozess verloren" -#: access/transam/parallel.c:833 access/transam/parallel.c:835 +#: access/transam/parallel.c:858 access/transam/parallel.c:860 msgid "parallel worker" msgstr "paralleler Arbeitsprozess" -#: access/transam/parallel.c:974 +#: access/transam/parallel.c:1001 #, c-format msgid "could not map dynamic shared memory segment" msgstr "konnte dynamisches Shared-Memory-Segment nicht mappen" -#: access/transam/parallel.c:979 +#: access/transam/parallel.c:1006 #, c-format msgid "invalid magic number in dynamic shared memory segment" msgstr "ungültige magische Zahl in dynamischem Shared-Memory-Segment" -#: access/transam/slru.c:665 +#: access/transam/slru.c:669 #, c-format msgid "file \"%s\" doesn't exist, reading as zeroes" msgstr "Datei »%s« existiert nicht, wird als Nullen eingelesen" -#: access/transam/slru.c:895 access/transam/slru.c:901 -#: access/transam/slru.c:908 access/transam/slru.c:915 -#: access/transam/slru.c:922 access/transam/slru.c:929 +#: access/transam/slru.c:899 access/transam/slru.c:905 +#: access/transam/slru.c:912 access/transam/slru.c:919 +#: access/transam/slru.c:926 access/transam/slru.c:933 #, c-format msgid "could not access status of transaction %u" msgstr "konnte auf den Status von Transaktion %u nicht zugreifen" -#: access/transam/slru.c:896 +#: access/transam/slru.c:900 #, c-format msgid "Could not open file \"%s\": %m." msgstr "Konnte Datei »%s« nicht öffnen: %m." -#: access/transam/slru.c:902 +#: access/transam/slru.c:906 #, c-format msgid "Could not seek in file \"%s\" to offset %u: %m." msgstr "Konnte Positionszeiger in Datei »%s« nicht auf %u setzen: %m." -#: access/transam/slru.c:909 +#: access/transam/slru.c:913 #, c-format msgid "Could not read from file \"%s\" at offset %u: %m." msgstr "Konnte nicht aus Datei »%s« bei Position %u lesen: %m." -#: access/transam/slru.c:916 +#: access/transam/slru.c:920 #, c-format msgid "Could not write to file \"%s\" at offset %u: %m." msgstr "Konnte nicht in Datei »%s« bei Position %u schreiben: %m." -#: access/transam/slru.c:923 +#: access/transam/slru.c:927 #, c-format msgid "Could not fsync file \"%s\": %m." msgstr "Konnte Datei »%s« nicht fsyncen: %m." -#: access/transam/slru.c:930 +#: access/transam/slru.c:934 #, c-format msgid "Could not close file \"%s\": %m." msgstr "Konnte Datei »%s« nicht schließen: %m." -#: access/transam/slru.c:1185 +#: access/transam/slru.c:1189 #, c-format msgid "could not truncate directory \"%s\": apparent wraparound" msgstr "konnte Verzeichnis »%s« nicht leeren: anscheinender Ãœberlauf" -#: access/transam/slru.c:1240 access/transam/slru.c:1296 +#: access/transam/slru.c:1244 access/transam/slru.c:1300 #, c-format msgid "removing file \"%s\"" msgstr "entferne Datei »%s«" @@ -1362,8 +1191,8 @@ msgid "Timeline IDs must be less than child timeline's ID." msgstr "Zeitleisten-IDs müssen kleiner als die Zeitleisten-ID des Kindes sein." #: access/transam/timeline.c:412 access/transam/timeline.c:488 -#: access/transam/xlog.c:3093 access/transam/xlog.c:3254 -#: access/transam/xlogfuncs.c:690 commands/copy.c:1708 +#: access/transam/xlog.c:3099 access/transam/xlog.c:3260 +#: access/transam/xlogfuncs.c:685 commands/copy.c:1709 #: storage/file/copydir.c:201 #, c-format msgid "could not close file \"%s\": %m" @@ -1454,7 +1283,7 @@ msgstr "konnte »stat« für Zweiphasen-Statusdatei »%s« nicht ausführen: %m" msgid "could not read two-phase state file \"%s\": %m" msgstr "konnte Zweiphasen-Statusdatei »%s« nicht lesen: %m" -#: access/transam/twophase.c:1263 access/transam/xlog.c:6109 +#: access/transam/twophase.c:1263 access/transam/xlog.c:6115 #, c-format msgid "Failed while allocating an XLog reading processor." msgstr "Fehlgeschlagen beim Anlegen eines XLog-Leseprozessors." @@ -1567,432 +1396,432 @@ msgstr "kann nicht mehr als 2^32-2 Befehle in einer Transaktion ausführen" msgid "maximum number of committed subtransactions (%d) exceeded" msgstr "maximale Anzahl committeter Subtransaktionen (%d) überschritten" -#: access/transam/xact.c:2263 +#: access/transam/xact.c:2260 #, c-format msgid "cannot PREPARE a transaction that has operated on temporary tables" msgstr "PREPARE kann nicht für eine Transaktion ausgeführt werden, die temporäre Tabellen bearbeitet hat" -#: access/transam/xact.c:2273 +#: access/transam/xact.c:2270 #, c-format msgid "cannot PREPARE a transaction that has exported snapshots" msgstr "PREPARE kann nicht für eine Transaktion ausgeführt werden, die Snapshots exportiert hat" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3155 +#: access/transam/xact.c:3148 #, c-format msgid "%s cannot run inside a transaction block" msgstr "%s kann nicht in einem Transaktionsblock laufen" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3165 +#: access/transam/xact.c:3158 #, c-format msgid "%s cannot run inside a subtransaction" msgstr "%s kann nicht in einer Subtransaktion laufen" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3175 +#: access/transam/xact.c:3168 #, c-format msgid "%s cannot be executed from a function or multi-command string" msgstr "%s kann nicht aus einer Funktion oder einer mehrbefehligen Zeichenkette heraus ausgeführt werden" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3246 +#: access/transam/xact.c:3239 #, c-format msgid "%s can only be used in transaction blocks" msgstr "%s kann nur in Transaktionsblöcken verwendet werden" -#: access/transam/xact.c:3430 +#: access/transam/xact.c:3423 #, c-format msgid "there is already a transaction in progress" msgstr "eine Transaktion ist bereits begonnen" -#: access/transam/xact.c:3598 access/transam/xact.c:3701 +#: access/transam/xact.c:3591 access/transam/xact.c:3694 #, c-format msgid "there is no transaction in progress" msgstr "keine Transaktion offen" -#: access/transam/xact.c:3609 +#: access/transam/xact.c:3602 #, c-format msgid "cannot commit during a parallel operation" msgstr "während einer parallelen Operation kann nicht committet werden" -#: access/transam/xact.c:3712 +#: access/transam/xact.c:3705 #, c-format msgid "cannot abort during a parallel operation" msgstr "während einer parallelen Operation kann nicht abgebrochen werden" -#: access/transam/xact.c:3754 +#: access/transam/xact.c:3747 #, c-format msgid "cannot define savepoints during a parallel operation" msgstr "während einer parallelen Operation können keine Sicherungspunkte definiert werden" -#: access/transam/xact.c:3821 +#: access/transam/xact.c:3814 #, c-format msgid "cannot release savepoints during a parallel operation" msgstr "während einer parallelen Operation können keine Sicherungspunkte freigegeben werden" -#: access/transam/xact.c:3832 access/transam/xact.c:3884 -#: access/transam/xact.c:3890 access/transam/xact.c:3946 -#: access/transam/xact.c:3996 access/transam/xact.c:4002 +#: access/transam/xact.c:3825 access/transam/xact.c:3877 +#: access/transam/xact.c:3883 access/transam/xact.c:3939 +#: access/transam/xact.c:3989 access/transam/xact.c:3995 #, c-format msgid "no such savepoint" msgstr "Sicherungspunkt existiert nicht" -#: access/transam/xact.c:3934 +#: access/transam/xact.c:3927 #, c-format msgid "cannot rollback to savepoints during a parallel operation" msgstr "während einer parallelen Operation kann nicht auf einen Sicherungspunkt zurückgerollt werden" -#: access/transam/xact.c:4062 +#: access/transam/xact.c:4055 #, c-format msgid "cannot start subtransactions during a parallel operation" msgstr "während einer parallelen Operation können keine Subtransaktionen gestartet werden" -#: access/transam/xact.c:4129 +#: access/transam/xact.c:4122 #, c-format msgid "cannot commit subtransactions during a parallel operation" msgstr "während einer parallelen Operation können keine Subtransaktionen committet werden" -#: access/transam/xact.c:4737 +#: access/transam/xact.c:4751 #, c-format msgid "cannot have more than 2^32-1 subtransactions in a transaction" msgstr "kann nicht mehr als 2^32-1 Subtransaktionen in einer Transaktion haben" -#: access/transam/xlog.c:2299 +#: access/transam/xlog.c:2305 #, c-format msgid "could not seek in log file %s to offset %u: %m" msgstr "konnte Positionszeiger in Logdatei %s nicht auf %u setzen: %m" -#: access/transam/xlog.c:2319 +#: access/transam/xlog.c:2325 #, c-format msgid "could not write to log file %s at offset %u, length %zu: %m" msgstr "konnte nicht in Logdatei %s bei Position %u, Länge %zu schreiben: %m" -#: access/transam/xlog.c:2582 +#: access/transam/xlog.c:2588 #, c-format msgid "updated min recovery point to %X/%X on timeline %u" msgstr "minimaler Recovery-Punkt auf %X/%X auf Zeitleiste %u aktualisiert" -#: access/transam/xlog.c:3224 +#: access/transam/xlog.c:3230 #, c-format msgid "not enough data in file \"%s\"" msgstr "nicht genug Daten in Datei »%s«" -#: access/transam/xlog.c:3365 +#: access/transam/xlog.c:3371 #, c-format msgid "could not open transaction log file \"%s\": %m" msgstr "konnte Transaktionslogdatei »%s« nicht öffnen: %m" -#: access/transam/xlog.c:3554 access/transam/xlog.c:5339 +#: access/transam/xlog.c:3560 access/transam/xlog.c:5345 #, c-format msgid "could not close log file %s: %m" msgstr "konnte Logdatei %s nicht schließen: %m" -#: access/transam/xlog.c:3611 access/transam/xlogutils.c:696 -#: replication/walsender.c:2097 +#: access/transam/xlog.c:3617 access/transam/xlogutils.c:696 +#: replication/walsender.c:2139 #, c-format msgid "requested WAL segment %s has already been removed" msgstr "das angeforderte WAL-Segment %s wurde schon entfernt" -#: access/transam/xlog.c:3671 access/transam/xlog.c:3746 -#: access/transam/xlog.c:3944 +#: access/transam/xlog.c:3677 access/transam/xlog.c:3752 +#: access/transam/xlog.c:3950 #, c-format msgid "could not open transaction log directory \"%s\": %m" msgstr "konnte Transaktionslog-Verzeichnis »%s« nicht öffnen: %m" -#: access/transam/xlog.c:3827 +#: access/transam/xlog.c:3833 #, c-format msgid "recycled transaction log file \"%s\"" msgstr "Transaktionslogdatei »%s« wird wiederverwendet" -#: access/transam/xlog.c:3839 +#: access/transam/xlog.c:3845 #, c-format msgid "removing transaction log file \"%s\"" msgstr "entferne Transaktionslogdatei »%s«" -#: access/transam/xlog.c:3859 +#: access/transam/xlog.c:3865 #, c-format msgid "could not rename old transaction log file \"%s\": %m" msgstr "konnte alte Transaktionslogdatei »%s« nicht umbenennen: %m" -#: access/transam/xlog.c:3871 +#: access/transam/xlog.c:3877 #, c-format msgid "could not remove old transaction log file \"%s\": %m" msgstr "konnte alte Transaktionslogdatei »%s« nicht löschen: %m" -#: access/transam/xlog.c:3904 access/transam/xlog.c:3914 +#: access/transam/xlog.c:3910 access/transam/xlog.c:3920 #, c-format msgid "required WAL directory \"%s\" does not exist" msgstr "benötigtes WAL-Verzeichnis »%s« existiert nicht" -#: access/transam/xlog.c:3920 +#: access/transam/xlog.c:3926 #, c-format msgid "creating missing WAL directory \"%s\"" msgstr "erzeuge fehlendes WAL-Verzeichnis »%s«" -#: access/transam/xlog.c:3923 +#: access/transam/xlog.c:3929 #, c-format msgid "could not create missing directory \"%s\": %m" msgstr "konnte fehlendes Verzeichnis »%s« nicht erzeugen: %m" -#: access/transam/xlog.c:3954 +#: access/transam/xlog.c:3960 #, c-format msgid "removing transaction log backup history file \"%s\"" msgstr "entferne Transaktionslog-Backup-History-Datei »%s«" -#: access/transam/xlog.c:4035 +#: access/transam/xlog.c:4041 #, c-format msgid "unexpected timeline ID %u in log segment %s, offset %u" msgstr "unerwartete Zeitleisten-ID %u in Logsegment %s, Offset %u" -#: access/transam/xlog.c:4157 +#: access/transam/xlog.c:4163 #, c-format msgid "new timeline %u is not a child of database system timeline %u" msgstr "neue Zeitleiste %u ist kein Kind der Datenbanksystemzeitleiste %u" -#: access/transam/xlog.c:4171 +#: access/transam/xlog.c:4177 #, c-format msgid "new timeline %u forked off current database system timeline %u before current recovery point %X/%X" msgstr "neue Zeitleiste %u zweigte von der aktuellen Datenbanksystemzeitleiste %u vor dem aktuellen Wiederherstellungspunkt %X/%X ab" -#: access/transam/xlog.c:4190 +#: access/transam/xlog.c:4196 #, c-format msgid "new target timeline is %u" msgstr "neue Zielzeitleiste ist %u" -#: access/transam/xlog.c:4270 +#: access/transam/xlog.c:4276 #, c-format msgid "could not create control file \"%s\": %m" msgstr "konnte Kontrolldatei »%s« nicht erzeugen: %m" -#: access/transam/xlog.c:4281 access/transam/xlog.c:4517 +#: access/transam/xlog.c:4287 access/transam/xlog.c:4523 #, c-format msgid "could not write to control file: %m" msgstr "konnte nicht in Kontrolldatei schreiben: %m" -#: access/transam/xlog.c:4287 access/transam/xlog.c:4523 +#: access/transam/xlog.c:4293 access/transam/xlog.c:4529 #, c-format msgid "could not fsync control file: %m" msgstr "konnte Kontrolldatei nicht fsyncen: %m" -#: access/transam/xlog.c:4292 access/transam/xlog.c:4528 +#: access/transam/xlog.c:4298 access/transam/xlog.c:4534 #, c-format msgid "could not close control file: %m" msgstr "konnte Kontrolldatei nicht schließen: %m" -#: access/transam/xlog.c:4310 access/transam/xlog.c:4506 +#: access/transam/xlog.c:4316 access/transam/xlog.c:4512 #, c-format msgid "could not open control file \"%s\": %m" msgstr "konnte Kontrolldatei »%s« nicht öffnen: %m" -#: access/transam/xlog.c:4316 +#: access/transam/xlog.c:4322 #, c-format msgid "could not read from control file: %m" msgstr "konnte nicht aus Kontrolldatei lesen: %m" -#: access/transam/xlog.c:4329 access/transam/xlog.c:4338 -#: access/transam/xlog.c:4362 access/transam/xlog.c:4369 -#: access/transam/xlog.c:4376 access/transam/xlog.c:4381 -#: access/transam/xlog.c:4388 access/transam/xlog.c:4395 -#: access/transam/xlog.c:4402 access/transam/xlog.c:4409 -#: access/transam/xlog.c:4416 access/transam/xlog.c:4423 -#: access/transam/xlog.c:4430 access/transam/xlog.c:4439 -#: access/transam/xlog.c:4446 access/transam/xlog.c:4455 -#: access/transam/xlog.c:4462 access/transam/xlog.c:4471 -#: access/transam/xlog.c:4478 utils/init/miscinit.c:1380 +#: access/transam/xlog.c:4335 access/transam/xlog.c:4344 +#: access/transam/xlog.c:4368 access/transam/xlog.c:4375 +#: access/transam/xlog.c:4382 access/transam/xlog.c:4387 +#: access/transam/xlog.c:4394 access/transam/xlog.c:4401 +#: access/transam/xlog.c:4408 access/transam/xlog.c:4415 +#: access/transam/xlog.c:4422 access/transam/xlog.c:4429 +#: access/transam/xlog.c:4436 access/transam/xlog.c:4445 +#: access/transam/xlog.c:4452 access/transam/xlog.c:4461 +#: access/transam/xlog.c:4468 access/transam/xlog.c:4477 +#: access/transam/xlog.c:4484 utils/init/miscinit.c:1380 #, c-format msgid "database files are incompatible with server" msgstr "Datenbankdateien sind inkompatibel mit Server" -#: access/transam/xlog.c:4330 +#: access/transam/xlog.c:4336 #, c-format msgid "The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x), but the server was compiled with PG_CONTROL_VERSION %d (0x%08x)." msgstr "Der Datenbank-Cluster wurde mit PG_CONTROL_VERSION %d (0x%08x) initialisiert, aber der Server wurde mit PG_CONTROL_VERSION %d (0x%08x) kompiliert." -#: access/transam/xlog.c:4334 +#: access/transam/xlog.c:4340 #, c-format msgid "This could be a problem of mismatched byte ordering. It looks like you need to initdb." msgstr "Das Problem könnte eine falsche Byte-Reihenfolge sein. Es sieht so aus, dass Sie initdb ausführen müssen." -#: access/transam/xlog.c:4339 +#: access/transam/xlog.c:4345 #, c-format msgid "The database cluster was initialized with PG_CONTROL_VERSION %d, but the server was compiled with PG_CONTROL_VERSION %d." msgstr "Der Datenbank-Cluster wurde mit PG_CONTROL_VERSION %d initialisiert, aber der Server wurde mit PG_CONTROL_VERSION %d kompiliert." -#: access/transam/xlog.c:4342 access/transam/xlog.c:4366 -#: access/transam/xlog.c:4373 access/transam/xlog.c:4378 +#: access/transam/xlog.c:4348 access/transam/xlog.c:4372 +#: access/transam/xlog.c:4379 access/transam/xlog.c:4384 #, c-format msgid "It looks like you need to initdb." msgstr "Es sieht so aus, dass Sie initdb ausführen müssen." -#: access/transam/xlog.c:4353 +#: access/transam/xlog.c:4359 #, c-format msgid "incorrect checksum in control file" msgstr "falsche Prüfsumme in Kontrolldatei" -#: access/transam/xlog.c:4363 +#: access/transam/xlog.c:4369 #, c-format msgid "The database cluster was initialized with CATALOG_VERSION_NO %d, but the server was compiled with CATALOG_VERSION_NO %d." msgstr "Der Datenbank-Cluster wurde mit CATALOG_VERSION_NO %d initialisiert, aber der Server wurde mit CATALOG_VERSION_NO %d kompiliert." -#: access/transam/xlog.c:4370 +#: access/transam/xlog.c:4376 #, c-format msgid "The database cluster was initialized with MAXALIGN %d, but the server was compiled with MAXALIGN %d." msgstr "Der Datenbank-Cluster wurde mit MAXALIGN %d initialisiert, aber der Server wurde mit MAXALIGN %d kompiliert." -#: access/transam/xlog.c:4377 +#: access/transam/xlog.c:4383 #, c-format msgid "The database cluster appears to use a different floating-point number format than the server executable." msgstr "Der Datenbank-Cluster verwendet anscheinend ein anderes Fließkommazahlenformat als das Serverprogramm." -#: access/transam/xlog.c:4382 +#: access/transam/xlog.c:4388 #, c-format msgid "The database cluster was initialized with BLCKSZ %d, but the server was compiled with BLCKSZ %d." msgstr "Der Datenbank-Cluster wurde mit BLCKSZ %d initialisiert, aber der Server wurde mit BLCKSZ %d kompiliert." -#: access/transam/xlog.c:4385 access/transam/xlog.c:4392 -#: access/transam/xlog.c:4399 access/transam/xlog.c:4406 -#: access/transam/xlog.c:4413 access/transam/xlog.c:4420 -#: access/transam/xlog.c:4427 access/transam/xlog.c:4434 -#: access/transam/xlog.c:4442 access/transam/xlog.c:4449 -#: access/transam/xlog.c:4458 access/transam/xlog.c:4465 -#: access/transam/xlog.c:4474 access/transam/xlog.c:4481 +#: access/transam/xlog.c:4391 access/transam/xlog.c:4398 +#: access/transam/xlog.c:4405 access/transam/xlog.c:4412 +#: access/transam/xlog.c:4419 access/transam/xlog.c:4426 +#: access/transam/xlog.c:4433 access/transam/xlog.c:4440 +#: access/transam/xlog.c:4448 access/transam/xlog.c:4455 +#: access/transam/xlog.c:4464 access/transam/xlog.c:4471 +#: access/transam/xlog.c:4480 access/transam/xlog.c:4487 #, c-format msgid "It looks like you need to recompile or initdb." msgstr "Es sieht so aus, dass Sie neu kompilieren oder initdb ausführen müssen." -#: access/transam/xlog.c:4389 +#: access/transam/xlog.c:4395 #, c-format msgid "The database cluster was initialized with RELSEG_SIZE %d, but the server was compiled with RELSEG_SIZE %d." msgstr "Der Datenbank-Cluster wurde mit RELSEG_SIZE %d initialisiert, aber der Server wurde mit RELSEGSIZE %d kompiliert." -#: access/transam/xlog.c:4396 +#: access/transam/xlog.c:4402 #, c-format msgid "The database cluster was initialized with XLOG_BLCKSZ %d, but the server was compiled with XLOG_BLCKSZ %d." msgstr "Der Datenbank-Cluster wurde mit XLOG_BLCKSZ %d initialisiert, aber der Server wurde mit XLOG_BLCKSZ %d kompiliert." -#: access/transam/xlog.c:4403 +#: access/transam/xlog.c:4409 #, c-format msgid "The database cluster was initialized with XLOG_SEG_SIZE %d, but the server was compiled with XLOG_SEG_SIZE %d." msgstr "Der Datenbank-Cluster wurde mit XLOG_SEG_SIZE %d initialisiert, aber der Server wurde mit XLOG_SEG_SIZE %d kompiliert." -#: access/transam/xlog.c:4410 +#: access/transam/xlog.c:4416 #, c-format msgid "The database cluster was initialized with NAMEDATALEN %d, but the server was compiled with NAMEDATALEN %d." msgstr "Der Datenbank-Cluster wurde mit NAMEDATALEN %d initialisiert, aber der Server wurde mit NAMEDATALEN %d kompiliert." -#: access/transam/xlog.c:4417 +#: access/transam/xlog.c:4423 #, c-format msgid "The database cluster was initialized with INDEX_MAX_KEYS %d, but the server was compiled with INDEX_MAX_KEYS %d." msgstr "Der Datenbank-Cluster wurde mit INDEX_MAX_KEYS %d initialisiert, aber der Server wurde mit INDEX_MAX_KEYS %d kompiliert." -#: access/transam/xlog.c:4424 +#: access/transam/xlog.c:4430 #, c-format msgid "The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d, but the server was compiled with TOAST_MAX_CHUNK_SIZE %d." msgstr "Der Datenbank-Cluster wurde mit TOAST_MAX_CHUNK_SIZE %d initialisiert, aber der Server wurde mit TOAST_MAX_CHUNK_SIZE %d kompiliert." -#: access/transam/xlog.c:4431 +#: access/transam/xlog.c:4437 #, c-format msgid "The database cluster was initialized with LOBLKSIZE %d, but the server was compiled with LOBLKSIZE %d." msgstr "Der Datenbank-Cluster wurde mit LOBLKSIZE %d initialisiert, aber der Server wurde mit LOBLKSIZE %d kompiliert." -#: access/transam/xlog.c:4440 +#: access/transam/xlog.c:4446 #, c-format msgid "The database cluster was initialized without HAVE_INT64_TIMESTAMP but the server was compiled with HAVE_INT64_TIMESTAMP." msgstr "Der Datenbank-Cluster wurde ohne HAVE_INT64_TIMESTAMP initialisiert, aber der Server wurde mit HAE_INT64_TIMESTAMP kompiliert." -#: access/transam/xlog.c:4447 +#: access/transam/xlog.c:4453 #, c-format msgid "The database cluster was initialized with HAVE_INT64_TIMESTAMP but the server was compiled without HAVE_INT64_TIMESTAMP." msgstr "Der Datenbank-Cluster wurde mit HAVE_INT64_TIMESTAMP initialisiert, aber der Server wurde ohne HAE_INT64_TIMESTAMP kompiliert." -#: access/transam/xlog.c:4456 +#: access/transam/xlog.c:4462 #, c-format msgid "The database cluster was initialized without USE_FLOAT4_BYVAL but the server was compiled with USE_FLOAT4_BYVAL." msgstr "Der Datenbank-Cluster wurde ohne USE_FLOAT4_BYVAL initialisiert, aber der Server wurde mit USE_FLOAT4_BYVAL kompiliert." -#: access/transam/xlog.c:4463 +#: access/transam/xlog.c:4469 #, c-format msgid "The database cluster was initialized with USE_FLOAT4_BYVAL but the server was compiled without USE_FLOAT4_BYVAL." msgstr "Der Datenbank-Cluster wurde mit USE_FLOAT4_BYVAL initialisiert, aber der Server wurde ohne USE_FLOAT4_BYVAL kompiliert." -#: access/transam/xlog.c:4472 +#: access/transam/xlog.c:4478 #, c-format msgid "The database cluster was initialized without USE_FLOAT8_BYVAL but the server was compiled with USE_FLOAT8_BYVAL." msgstr "Der Datenbank-Cluster wurde ohne USE_FLOAT8_BYVAL initialisiert, aber der Server wurde mit USE_FLOAT8_BYVAL kompiliert." -#: access/transam/xlog.c:4479 +#: access/transam/xlog.c:4485 #, c-format msgid "The database cluster was initialized with USE_FLOAT8_BYVAL but the server was compiled without USE_FLOAT8_BYVAL." msgstr "Der Datenbank-Cluster wurde mit USE_FLOAT8_BYVAL initialisiert, aber der Server wurde ohne USE_FLOAT8_BYVAL kompiliert." -#: access/transam/xlog.c:4900 +#: access/transam/xlog.c:4906 #, c-format msgid "could not write bootstrap transaction log file: %m" msgstr "konnte Bootstrap-Transaktionslogdatei nicht schreiben: %m" -#: access/transam/xlog.c:4906 +#: access/transam/xlog.c:4912 #, c-format msgid "could not fsync bootstrap transaction log file: %m" msgstr "konnte Bootstrap-Transaktionslogdatei nicht fsyncen: %m" -#: access/transam/xlog.c:4911 +#: access/transam/xlog.c:4917 #, c-format msgid "could not close bootstrap transaction log file: %m" msgstr "konnte Bootstrap-Transaktionslogdatei nicht schließen: %m" -#: access/transam/xlog.c:4986 +#: access/transam/xlog.c:4992 #, c-format msgid "could not open recovery command file \"%s\": %m" msgstr "konnte Recovery-Kommandodatei »%s« nicht öffnen: %m" -#: access/transam/xlog.c:5032 access/transam/xlog.c:5117 +#: access/transam/xlog.c:5038 access/transam/xlog.c:5123 #, c-format msgid "invalid value for recovery parameter \"%s\": \"%s\"" msgstr "ungültiger Wert für Recovery-Parameter »%s«: »%s«" -#: access/transam/xlog.c:5035 +#: access/transam/xlog.c:5041 #, c-format msgid "Valid values are \"pause\", \"promote\", and \"shutdown\"." msgstr "Gültige Werte sind »pause«, »promote« und »shutdown«." -#: access/transam/xlog.c:5055 +#: access/transam/xlog.c:5061 #, c-format msgid "recovery_target_timeline is not a valid number: \"%s\"" msgstr "recovery_target_timeline ist keine gültige Zahl: »%s«" -#: access/transam/xlog.c:5072 +#: access/transam/xlog.c:5078 #, c-format msgid "recovery_target_xid is not a valid number: \"%s\"" msgstr "recovery_target_xid ist keine gültige Zahl: »%s«" -#: access/transam/xlog.c:5103 +#: access/transam/xlog.c:5109 #, c-format msgid "recovery_target_name is too long (maximum %d characters)" msgstr "recovery_target_name ist zu lang (maximal %d Zeichen)" -#: access/transam/xlog.c:5120 +#: access/transam/xlog.c:5126 #, c-format msgid "The only allowed value is \"immediate\"." msgstr "Der einzige erlaubte Wert ist »immediate«." -#: access/transam/xlog.c:5133 access/transam/xlog.c:5144 +#: access/transam/xlog.c:5139 access/transam/xlog.c:5150 #: commands/extension.c:534 commands/extension.c:542 utils/misc/guc.c:5640 #, c-format msgid "parameter \"%s\" requires a Boolean value" msgstr "Parameter »%s« erfordert einen Boole’schen Wert" -#: access/transam/xlog.c:5179 +#: access/transam/xlog.c:5185 #, c-format msgid "parameter \"%s\" requires a temporal value" msgstr "Parameter »%s« erfordert einen Zeitwert" -#: access/transam/xlog.c:5181 catalog/dependency.c:990 +#: access/transam/xlog.c:5187 catalog/dependency.c:990 #: catalog/dependency.c:991 catalog/dependency.c:997 catalog/dependency.c:998 #: catalog/dependency.c:1009 catalog/dependency.c:1010 #: catalog/objectaddress.c:1100 commands/tablecmds.c:796 -#: commands/tablecmds.c:9542 commands/user.c:1045 commands/view.c:499 -#: libpq/auth.c:307 replication/syncrep.c:919 storage/lmgr/deadlock.c:1139 +#: commands/tablecmds.c:9556 commands/user.c:1045 commands/view.c:499 +#: libpq/auth.c:307 replication/syncrep.c:929 storage/lmgr/deadlock.c:1139 #: storage/lmgr/proc.c:1278 utils/adt/acl.c:5281 utils/misc/guc.c:5662 #: utils/misc/guc.c:5755 utils/misc/guc.c:9708 utils/misc/guc.c:9742 #: utils/misc/guc.c:9776 utils/misc/guc.c:9810 utils/misc/guc.c:9845 @@ -2000,691 +1829,691 @@ msgstr "Parameter »%s« erfordert einen Zeitwert" msgid "%s" msgstr "%s" -#: access/transam/xlog.c:5188 +#: access/transam/xlog.c:5194 #, c-format msgid "unrecognized recovery parameter \"%s\"" msgstr "unbekannter Recovery-Parameter »%s«" -#: access/transam/xlog.c:5199 +#: access/transam/xlog.c:5205 #, c-format msgid "recovery command file \"%s\" specified neither primary_conninfo nor restore_command" msgstr "Recovery-Kommandodatei »%s« hat weder primary_conninfo noch restore_command angegeben" -#: access/transam/xlog.c:5201 +#: access/transam/xlog.c:5207 #, c-format msgid "The database server will regularly poll the pg_xlog subdirectory to check for files placed there." msgstr "Der Datenbankserver prüft das Unterverzeichnis pg_xlog regelmäßig auf dort abgelegte Dateien." -#: access/transam/xlog.c:5208 +#: access/transam/xlog.c:5214 #, c-format msgid "recovery command file \"%s\" must specify restore_command when standby mode is not enabled" msgstr "Recovery-Kommandodatei »%s« muss restore_command angeben, wenn der Standby-Modus nicht eingeschaltet ist" -#: access/transam/xlog.c:5229 +#: access/transam/xlog.c:5235 #, c-format msgid "standby mode is not supported by single-user servers" msgstr "Standby-Modus wird von Servern im Einzelbenutzermodus nicht unterstützt" -#: access/transam/xlog.c:5248 +#: access/transam/xlog.c:5254 #, c-format msgid "recovery target timeline %u does not exist" msgstr "recovery_target_timeline %u existiert nicht" -#: access/transam/xlog.c:5369 +#: access/transam/xlog.c:5375 #, c-format msgid "archive recovery complete" msgstr "Wiederherstellung aus Archiv abgeschlossen" -#: access/transam/xlog.c:5428 access/transam/xlog.c:5656 +#: access/transam/xlog.c:5434 access/transam/xlog.c:5662 #, c-format msgid "recovery stopping after reaching consistency" msgstr "Wiederherstellung beendet nachdem Konsistenz erreicht wurde" -#: access/transam/xlog.c:5516 +#: access/transam/xlog.c:5522 #, c-format msgid "recovery stopping before commit of transaction %u, time %s" msgstr "Wiederherstellung beendet vor Commit der Transaktion %u, Zeit %s" -#: access/transam/xlog.c:5523 +#: access/transam/xlog.c:5529 #, c-format msgid "recovery stopping before abort of transaction %u, time %s" msgstr "Wiederherstellung beendet vor Abbruch der Transaktion %u, Zeit %s" -#: access/transam/xlog.c:5568 +#: access/transam/xlog.c:5574 #, c-format msgid "recovery stopping at restore point \"%s\", time %s" msgstr "Wiederherstellung beendet bei Restore-Punkt »%s«, Zeit %s" -#: access/transam/xlog.c:5636 +#: access/transam/xlog.c:5642 #, c-format msgid "recovery stopping after commit of transaction %u, time %s" msgstr "Wiederherstellung beendet nach Commit der Transaktion %u, Zeit %s" -#: access/transam/xlog.c:5644 +#: access/transam/xlog.c:5650 #, c-format msgid "recovery stopping after abort of transaction %u, time %s" msgstr "Wiederherstellung beendet nach Abbruch der Transaktion %u, Zeit %s" -#: access/transam/xlog.c:5683 +#: access/transam/xlog.c:5689 #, c-format msgid "recovery has paused" msgstr "Wiederherstellung wurde pausiert" -#: access/transam/xlog.c:5684 +#: access/transam/xlog.c:5690 #, c-format msgid "Execute pg_xlog_replay_resume() to continue." msgstr "Führen Sie pg_xlog_replay_resume() aus um fortzusetzen." -#: access/transam/xlog.c:5891 +#: access/transam/xlog.c:5897 #, c-format msgid "hot standby is not possible because %s = %d is a lower setting than on the master server (its value was %d)" msgstr "Hot Standby ist nicht möglich, weil %s = %d eine niedrigere Einstellung als auf dem Masterserver ist (Wert dort war %d)" -#: access/transam/xlog.c:5917 +#: access/transam/xlog.c:5923 #, c-format msgid "WAL was generated with wal_level=minimal, data may be missing" msgstr "WAL wurde mit wal_level=minimal erzeugt, eventuell fehlen Daten" -#: access/transam/xlog.c:5918 +#: access/transam/xlog.c:5924 #, c-format msgid "This happens if you temporarily set wal_level=minimal without taking a new base backup." msgstr "Das passiert, wenn vorübergehend wal_level=minimal gesetzt wurde, ohne ein neues Base-Backup zu erzeugen." -#: access/transam/xlog.c:5929 +#: access/transam/xlog.c:5935 #, c-format msgid "hot standby is not possible because wal_level was not set to \"replica\" or higher on the master server" msgstr "Hot Standby ist nicht möglich, weil wal_level auf dem Masterserver nicht auf »replica« oder höher gesetzt wurde" -#: access/transam/xlog.c:5930 +#: access/transam/xlog.c:5936 #, c-format msgid "Either set wal_level to \"replica\" on the master, or turn off hot_standby here." msgstr "Setzen Sie entweder wal_level auf »replica« auf dem Master oder schalten Sie hot_standby hier aus." -#: access/transam/xlog.c:5987 +#: access/transam/xlog.c:5993 #, c-format msgid "control file contains invalid data" msgstr "Kontrolldatei enthält ungültige Daten" -#: access/transam/xlog.c:5993 +#: access/transam/xlog.c:5999 #, c-format msgid "database system was shut down at %s" msgstr "Datenbanksystem wurde am %s heruntergefahren" -#: access/transam/xlog.c:5998 +#: access/transam/xlog.c:6004 #, c-format msgid "database system was shut down in recovery at %s" msgstr "Datenbanksystem wurde während der Wiederherstellung am %s heruntergefahren" -#: access/transam/xlog.c:6002 +#: access/transam/xlog.c:6008 #, c-format msgid "database system shutdown was interrupted; last known up at %s" msgstr "Datenbanksystem wurde beim Herunterfahren unterbrochen; letzte bekannte Aktion am %s" -#: access/transam/xlog.c:6006 +#: access/transam/xlog.c:6012 #, c-format msgid "database system was interrupted while in recovery at %s" msgstr "Datenbanksystem wurde während der Wiederherstellung am %s unterbrochen" -#: access/transam/xlog.c:6008 +#: access/transam/xlog.c:6014 #, c-format msgid "This probably means that some data is corrupted and you will have to use the last backup for recovery." msgstr "Das bedeutet wahrscheinlich, dass einige Daten verfälscht sind und Sie die letzte Datensicherung zur Wiederherstellung verwenden müssen." -#: access/transam/xlog.c:6012 +#: access/transam/xlog.c:6018 #, c-format msgid "database system was interrupted while in recovery at log time %s" msgstr "Datenbanksystem wurde während der Wiederherstellung bei Logzeit %s unterbrochen" -#: access/transam/xlog.c:6014 +#: access/transam/xlog.c:6020 #, c-format msgid "If this has occurred more than once some data might be corrupted and you might need to choose an earlier recovery target." msgstr "Wenn dies mehr als einmal vorgekommen ist, dann sind einige Daten möglicherweise verfälscht und Sie müssen ein früheres Wiederherstellungsziel wählen." -#: access/transam/xlog.c:6018 +#: access/transam/xlog.c:6024 #, c-format msgid "database system was interrupted; last known up at %s" msgstr "Datenbanksystem wurde unterbrochen; letzte bekannte Aktion am %s" -#: access/transam/xlog.c:6074 +#: access/transam/xlog.c:6080 #, c-format msgid "entering standby mode" msgstr "Standby-Modus eingeschaltet" -#: access/transam/xlog.c:6077 +#: access/transam/xlog.c:6083 #, c-format msgid "starting point-in-time recovery to XID %u" msgstr "starte Point-in-Time-Recovery bis XID %u" -#: access/transam/xlog.c:6081 +#: access/transam/xlog.c:6087 #, c-format msgid "starting point-in-time recovery to %s" msgstr "starte Point-in-Time-Recovery bis %s" -#: access/transam/xlog.c:6085 +#: access/transam/xlog.c:6091 #, c-format msgid "starting point-in-time recovery to \"%s\"" msgstr "starte Point-in-Time-Recovery bis »%s«" -#: access/transam/xlog.c:6089 +#: access/transam/xlog.c:6095 #, c-format msgid "starting point-in-time recovery to earliest consistent point" msgstr "starte Point-in-Time-Recovery bis zum frühesten konsistenten Punkt" -#: access/transam/xlog.c:6092 +#: access/transam/xlog.c:6098 #, c-format msgid "starting archive recovery" msgstr "starte Wiederherstellung aus Archiv" -#: access/transam/xlog.c:6136 access/transam/xlog.c:6264 +#: access/transam/xlog.c:6142 access/transam/xlog.c:6270 #, c-format msgid "checkpoint record is at %X/%X" msgstr "Checkpoint-Eintrag ist bei %X/%X" -#: access/transam/xlog.c:6150 +#: access/transam/xlog.c:6156 #, c-format msgid "could not find redo location referenced by checkpoint record" msgstr "konnte die vom Checkpoint-Datensatz referenzierte Redo-Position nicht finden" -#: access/transam/xlog.c:6151 access/transam/xlog.c:6158 +#: access/transam/xlog.c:6157 access/transam/xlog.c:6164 #, c-format msgid "If you are not restoring from a backup, try removing the file \"%s/backup_label\"." msgstr "Wenn Sie gerade keine Sicherung wiederherstellen, versuchen Sie, die Datei »%s/backup_label« zu löschen." -#: access/transam/xlog.c:6157 +#: access/transam/xlog.c:6163 #, c-format msgid "could not locate required checkpoint record" msgstr "konnte den nötigen Checkpoint-Datensatz nicht finden" -#: access/transam/xlog.c:6183 commands/tablespace.c:641 +#: access/transam/xlog.c:6189 commands/tablespace.c:641 #, c-format msgid "could not create symbolic link \"%s\": %m" msgstr "konnte symbolische Verknüpfung »%s« nicht erstellen: %m" -#: access/transam/xlog.c:6215 access/transam/xlog.c:6221 +#: access/transam/xlog.c:6221 access/transam/xlog.c:6227 #, c-format msgid "ignoring file \"%s\" because no file \"%s\" exists" msgstr "ignoriere Datei »%s«, weil keine Datei »%s« existiert" -#: access/transam/xlog.c:6217 access/transam/xlog.c:11032 +#: access/transam/xlog.c:6223 access/transam/xlog.c:11065 #, c-format msgid "File \"%s\" was renamed to \"%s\"." msgstr "Datei »%s« wurde in »%s« umbenannt." -#: access/transam/xlog.c:6223 +#: access/transam/xlog.c:6229 #, c-format msgid "Could not rename file \"%s\" to \"%s\": %m." msgstr "Konnte Datei »%s« nicht in »%s« umbenennen: %m." -#: access/transam/xlog.c:6274 access/transam/xlog.c:6289 +#: access/transam/xlog.c:6280 access/transam/xlog.c:6295 #, c-format msgid "could not locate a valid checkpoint record" msgstr "konnte keinen gültigen Checkpoint-Datensatz finden" -#: access/transam/xlog.c:6283 +#: access/transam/xlog.c:6289 #, c-format msgid "using previous checkpoint record at %X/%X" msgstr "verwende vorherigen Checkpoint-Eintrag bei %X/%X" -#: access/transam/xlog.c:6327 +#: access/transam/xlog.c:6333 #, c-format msgid "requested timeline %u is not a child of this server's history" msgstr "angeforderte Zeitleiste %u ist kein Kind der History dieses Servers" -#: access/transam/xlog.c:6329 +#: access/transam/xlog.c:6335 #, c-format msgid "Latest checkpoint is at %X/%X on timeline %u, but in the history of the requested timeline, the server forked off from that timeline at %X/%X." msgstr "Neuester Checkpoint ist bei %X/%X auf Zeitleiste %u, aber in der History der angeforderten Zeitleiste zweigte der Server von dieser Zeitleiste bei %X/%X ab." -#: access/transam/xlog.c:6345 +#: access/transam/xlog.c:6351 #, c-format msgid "requested timeline %u does not contain minimum recovery point %X/%X on timeline %u" msgstr "angeforderte Zeitleiste %u enthält nicht den minimalen Wiederherstellungspunkt %X/%X auf Zeitleiste %u" -#: access/transam/xlog.c:6376 +#: access/transam/xlog.c:6382 #, c-format msgid "invalid next transaction ID" msgstr "ungültige nächste Transaktions-ID" -#: access/transam/xlog.c:6459 +#: access/transam/xlog.c:6465 #, c-format msgid "invalid redo in checkpoint record" msgstr "ungültiges Redo im Checkpoint-Datensatz" -#: access/transam/xlog.c:6470 +#: access/transam/xlog.c:6476 #, c-format msgid "invalid redo record in shutdown checkpoint" msgstr "ungültiger Redo-Datensatz im Shutdown-Checkpoint" -#: access/transam/xlog.c:6498 +#: access/transam/xlog.c:6504 #, c-format msgid "database system was not properly shut down; automatic recovery in progress" msgstr "Datenbanksystem wurde nicht richtig heruntergefahren; automatische Wiederherstellung läuft" -#: access/transam/xlog.c:6502 +#: access/transam/xlog.c:6508 #, c-format msgid "crash recovery starts in timeline %u and has target timeline %u" msgstr "Wiederherstellung nach Absturz beginnt in Zeitleiste %u und hat Zielzeitleiste %u" -#: access/transam/xlog.c:6546 +#: access/transam/xlog.c:6552 #, c-format msgid "backup_label contains data inconsistent with control file" msgstr "Daten in backup_label stimmen nicht mit Kontrolldatei überein" -#: access/transam/xlog.c:6547 +#: access/transam/xlog.c:6553 #, c-format msgid "This means that the backup is corrupted and you will have to use another backup for recovery." msgstr "Das bedeutet, dass die Datensicherung verfälscht ist und Sie eine andere Datensicherung zur Wiederherstellung verwenden werden müssen." -#: access/transam/xlog.c:6621 +#: access/transam/xlog.c:6627 #, c-format msgid "initializing for hot standby" msgstr "initialisiere für Hot Standby" -#: access/transam/xlog.c:6753 +#: access/transam/xlog.c:6759 #, c-format msgid "redo starts at %X/%X" msgstr "Redo beginnt bei %X/%X" -#: access/transam/xlog.c:6978 +#: access/transam/xlog.c:6984 #, c-format msgid "requested recovery stop point is before consistent recovery point" msgstr "angeforderter Recovery-Endpunkt ist vor konsistentem Recovery-Punkt" -#: access/transam/xlog.c:7016 +#: access/transam/xlog.c:7022 #, c-format msgid "redo done at %X/%X" msgstr "Redo fertig bei %X/%X" -#: access/transam/xlog.c:7021 access/transam/xlog.c:8969 +#: access/transam/xlog.c:7027 access/transam/xlog.c:8986 #, c-format msgid "last completed transaction was at log time %s" msgstr "letzte vollständige Transaktion war bei Logzeit %s" -#: access/transam/xlog.c:7030 +#: access/transam/xlog.c:7036 #, c-format msgid "redo is not required" msgstr "Redo nicht nötig" -#: access/transam/xlog.c:7105 access/transam/xlog.c:7109 +#: access/transam/xlog.c:7111 access/transam/xlog.c:7115 #, c-format msgid "WAL ends before end of online backup" msgstr "WAL endet vor dem Ende der Online-Sicherung" -#: access/transam/xlog.c:7106 +#: access/transam/xlog.c:7112 #, c-format msgid "All WAL generated while online backup was taken must be available at recovery." msgstr "Der komplette WAL, der während der Online-Sicherung erzeugt wurde, muss bei der Wiederherstellung verfügbar sein." -#: access/transam/xlog.c:7110 +#: access/transam/xlog.c:7116 #, c-format msgid "Online backup started with pg_start_backup() must be ended with pg_stop_backup(), and all WAL up to that point must be available at recovery." msgstr "Die mit pg_start_backup() begonnene Online-Sicherung muss mit pg_stop_backup() beendet werden und der ganze WAL bis zu diesem Punkt muss bei der Wiederherstellung verfügbar sein." -#: access/transam/xlog.c:7113 +#: access/transam/xlog.c:7119 #, c-format msgid "WAL ends before consistent recovery point" msgstr "WAL endet vor einem konsistenten Wiederherstellungspunkt" -#: access/transam/xlog.c:7140 +#: access/transam/xlog.c:7146 #, c-format msgid "selected new timeline ID: %u" msgstr "gewählte neue Zeitleisten-ID: %u" -#: access/transam/xlog.c:7551 +#: access/transam/xlog.c:7557 #, c-format msgid "consistent recovery state reached at %X/%X" msgstr "konsistenter Wiederherstellungszustand erreicht bei %X/%X" -#: access/transam/xlog.c:7742 +#: access/transam/xlog.c:7748 #, c-format msgid "invalid primary checkpoint link in control file" msgstr "ungültige primäre Checkpoint-Verknüpfung in Kontrolldatei" -#: access/transam/xlog.c:7746 +#: access/transam/xlog.c:7752 #, c-format msgid "invalid secondary checkpoint link in control file" msgstr "ungültige sekundäre Checkpoint-Verknüpfung in Kontrolldatei" -#: access/transam/xlog.c:7750 +#: access/transam/xlog.c:7756 #, c-format msgid "invalid checkpoint link in backup_label file" msgstr "ungültige Checkpoint-Verknüpfung in backup_label-Datei" -#: access/transam/xlog.c:7767 +#: access/transam/xlog.c:7773 #, c-format msgid "invalid primary checkpoint record" msgstr "ungültiger primärer Checkpoint-Datensatz" -#: access/transam/xlog.c:7771 +#: access/transam/xlog.c:7777 #, c-format msgid "invalid secondary checkpoint record" msgstr "ungültiger sekundärer Checkpoint-Datensatz" -#: access/transam/xlog.c:7775 +#: access/transam/xlog.c:7781 #, c-format msgid "invalid checkpoint record" msgstr "ungültiger Checkpoint-Datensatz" -#: access/transam/xlog.c:7786 +#: access/transam/xlog.c:7792 #, c-format msgid "invalid resource manager ID in primary checkpoint record" msgstr "ungültige Resource-Manager-ID im primären Checkpoint-Datensatz" -#: access/transam/xlog.c:7790 +#: access/transam/xlog.c:7796 #, c-format msgid "invalid resource manager ID in secondary checkpoint record" msgstr "ungültige Resource-Manager-ID im sekundären Checkpoint-Datensatz" -#: access/transam/xlog.c:7794 +#: access/transam/xlog.c:7800 #, c-format msgid "invalid resource manager ID in checkpoint record" msgstr "ungültige Resource-Manager-ID im Checkpoint-Datensatz" -#: access/transam/xlog.c:7806 +#: access/transam/xlog.c:7812 #, c-format msgid "invalid xl_info in primary checkpoint record" msgstr "ungültige xl_info im primären Checkpoint-Datensatz" -#: access/transam/xlog.c:7810 +#: access/transam/xlog.c:7816 #, c-format msgid "invalid xl_info in secondary checkpoint record" msgstr "ungültige xl_info im sekundären Checkpoint-Datensatz" -#: access/transam/xlog.c:7814 +#: access/transam/xlog.c:7820 #, c-format msgid "invalid xl_info in checkpoint record" msgstr "ungültige xl_info im Checkpoint-Datensatz" -#: access/transam/xlog.c:7825 +#: access/transam/xlog.c:7831 #, c-format msgid "invalid length of primary checkpoint record" msgstr "ungültige Länge des primären Checkpoint-Datensatzes" -#: access/transam/xlog.c:7829 +#: access/transam/xlog.c:7835 #, c-format msgid "invalid length of secondary checkpoint record" msgstr "ungültige Länge des sekundären Checkpoint-Datensatzes" -#: access/transam/xlog.c:7833 +#: access/transam/xlog.c:7839 #, c-format msgid "invalid length of checkpoint record" msgstr "ungültige Länge des Checkpoint-Datensatzes" -#: access/transam/xlog.c:8001 +#: access/transam/xlog.c:8007 #, c-format msgid "shutting down" msgstr "fahre herunter" -#: access/transam/xlog.c:8514 +#: access/transam/xlog.c:8531 #, c-format msgid "concurrent transaction log activity while database system is shutting down" msgstr "gleichzeitige Transaktionslog-Aktivität während das Datenbanksystem herunterfährt" -#: access/transam/xlog.c:8768 +#: access/transam/xlog.c:8785 #, c-format msgid "skipping restartpoint, recovery has already ended" msgstr "Restart-Punkt übersprungen, Wiederherstellung ist bereits beendet" -#: access/transam/xlog.c:8791 +#: access/transam/xlog.c:8808 #, c-format msgid "skipping restartpoint, already performed at %X/%X" msgstr "Restart-Punkt wird übersprungen, schon bei %X/%X erledigt" -#: access/transam/xlog.c:8967 +#: access/transam/xlog.c:8984 #, c-format msgid "recovery restart point at %X/%X" msgstr "Recovery-Restart-Punkt bei %X/%X" -#: access/transam/xlog.c:9100 +#: access/transam/xlog.c:9117 #, c-format msgid "restore point \"%s\" created at %X/%X" msgstr "Restore-Punkt »%s« erzeugt bei %X/%X" -#: access/transam/xlog.c:9230 +#: access/transam/xlog.c:9247 #, c-format msgid "unexpected previous timeline ID %u (current timeline ID %u) in checkpoint record" msgstr "unerwartete vorherige Zeitleisten-ID %u (aktuelle Zeitleisten-ID %u) im Checkpoint-Datensatz" -#: access/transam/xlog.c:9239 +#: access/transam/xlog.c:9256 #, c-format msgid "unexpected timeline ID %u (after %u) in checkpoint record" msgstr "unerwartete Zeitleisten-ID %u (nach %u) im Checkpoint-Datensatz" -#: access/transam/xlog.c:9255 +#: access/transam/xlog.c:9272 #, c-format msgid "unexpected timeline ID %u in checkpoint record, before reaching minimum recovery point %X/%X on timeline %u" msgstr "unerwartete Zeitleisten-ID %u in Checkpoint-Datensatz, bevor der minimale Wiederherstellungspunkt %X/%X auf Zeitleiste %u erreicht wurde" -#: access/transam/xlog.c:9326 +#: access/transam/xlog.c:9343 #, c-format msgid "online backup was canceled, recovery cannot continue" msgstr "Online-Sicherung wurde storniert, Wiederherstellung kann nicht fortgesetzt werden" -#: access/transam/xlog.c:9382 access/transam/xlog.c:9429 -#: access/transam/xlog.c:9452 +#: access/transam/xlog.c:9399 access/transam/xlog.c:9446 +#: access/transam/xlog.c:9469 #, c-format msgid "unexpected timeline ID %u (should be %u) in checkpoint record" msgstr "unerwartete Zeitleisten-ID %u (sollte %u sein) im Checkpoint-Datensatz" -#: access/transam/xlog.c:9727 +#: access/transam/xlog.c:9744 #, c-format msgid "could not fsync log segment %s: %m" msgstr "konnte Logsegment %s nicht fsyncen: %m" -#: access/transam/xlog.c:9751 +#: access/transam/xlog.c:9768 #, c-format msgid "could not fsync log file %s: %m" msgstr "konnte Logdatei %s nicht fsyncen: %m" -#: access/transam/xlog.c:9759 +#: access/transam/xlog.c:9776 #, c-format msgid "could not fsync write-through log file %s: %m" msgstr "konnte Write-Through-Logdatei %s nicht fsyncen: %m" -#: access/transam/xlog.c:9768 +#: access/transam/xlog.c:9785 #, c-format msgid "could not fdatasync log file %s: %m" msgstr "konnte Logdatei %s nicht fdatasyncen: %m" -#: access/transam/xlog.c:9859 access/transam/xlog.c:10363 -#: access/transam/xlogfuncs.c:294 access/transam/xlogfuncs.c:321 -#: access/transam/xlogfuncs.c:360 access/transam/xlogfuncs.c:381 -#: access/transam/xlogfuncs.c:402 +#: access/transam/xlog.c:9876 access/transam/xlog.c:10393 +#: access/transam/xlogfuncs.c:289 access/transam/xlogfuncs.c:316 +#: access/transam/xlogfuncs.c:355 access/transam/xlogfuncs.c:376 +#: access/transam/xlogfuncs.c:397 #, c-format msgid "WAL control functions cannot be executed during recovery." msgstr "Während der Wiederherstellung können keine WAL-Kontrollfunktionen ausgeführt werden." -#: access/transam/xlog.c:9868 access/transam/xlog.c:10372 +#: access/transam/xlog.c:9885 access/transam/xlog.c:10402 #, c-format msgid "WAL level not sufficient for making an online backup" msgstr "WAL-Level nicht ausreichend, um Online-Sicherung durchzuführen" -#: access/transam/xlog.c:9869 access/transam/xlog.c:10373 -#: access/transam/xlogfuncs.c:327 +#: access/transam/xlog.c:9886 access/transam/xlog.c:10403 +#: access/transam/xlogfuncs.c:322 #, c-format msgid "wal_level must be set to \"replica\" or \"logical\" at server start." msgstr "wal_level muss beim Serverstart auf »replica« oder »logical« gesetzt werden." -#: access/transam/xlog.c:9874 +#: access/transam/xlog.c:9891 #, c-format msgid "backup label too long (max %d bytes)" msgstr "Backup-Label zu lang (maximal %d Bytes)" -#: access/transam/xlog.c:9911 access/transam/xlog.c:10183 -#: access/transam/xlog.c:10221 +#: access/transam/xlog.c:9928 access/transam/xlog.c:10200 +#: access/transam/xlog.c:10238 #, c-format msgid "a backup is already in progress" msgstr "ein Backup läuft bereits" -#: access/transam/xlog.c:9912 +#: access/transam/xlog.c:9929 #, c-format msgid "Run pg_stop_backup() and try again." msgstr "Führen Sie pg_stop_backup() aus und versuchen Sie es nochmal." -#: access/transam/xlog.c:10007 +#: access/transam/xlog.c:10024 #, c-format msgid "WAL generated with full_page_writes=off was replayed since last restartpoint" msgstr "mit full_page_writes=off erzeugtes WAL wurde seit dem letzten Restart-Punkt zurückgespielt" -#: access/transam/xlog.c:10009 access/transam/xlog.c:10554 +#: access/transam/xlog.c:10026 access/transam/xlog.c:10587 #, c-format msgid "This means that the backup being taken on the standby is corrupt and should not be used. Enable full_page_writes and run CHECKPOINT on the master, and then try an online backup again." msgstr "Das bedeutet, dass die aktuelle Datensicherung auf dem Standby-Server verfälscht ist und nicht verwendet werden sollte. Schalten Sie full_page_writes ein, führen Sie CHECKPOINT aus und versuchen Sie dann die Online-Sicherung erneut." -#: access/transam/xlog.c:10076 replication/basebackup.c:1026 +#: access/transam/xlog.c:10093 replication/basebackup.c:1026 #: utils/adt/misc.c:498 #, c-format msgid "could not read symbolic link \"%s\": %m" msgstr "konnte symbolische Verknüpfung »%s« nicht lesen: %m" -#: access/transam/xlog.c:10083 replication/basebackup.c:1031 +#: access/transam/xlog.c:10100 replication/basebackup.c:1031 #: utils/adt/misc.c:503 #, c-format msgid "symbolic link \"%s\" target is too long" msgstr "Ziel für symbolische Verknüpfung »%s« ist zu lang" -#: access/transam/xlog.c:10136 commands/tablespace.c:391 +#: access/transam/xlog.c:10153 commands/tablespace.c:391 #: commands/tablespace.c:553 replication/basebackup.c:1047 #: utils/adt/misc.c:511 #, c-format msgid "tablespaces are not supported on this platform" msgstr "Tablespaces werden auf dieser Plattform nicht unterstützt" -#: access/transam/xlog.c:10177 access/transam/xlog.c:10215 -#: access/transam/xlog.c:10411 access/transam/xlogarchive.c:106 -#: access/transam/xlogarchive.c:265 commands/copy.c:1815 commands/copy.c:2839 -#: commands/extension.c:3130 commands/tablespace.c:782 +#: access/transam/xlog.c:10194 access/transam/xlog.c:10232 +#: access/transam/xlog.c:10441 access/transam/xlogarchive.c:106 +#: access/transam/xlogarchive.c:265 commands/copy.c:1816 commands/copy.c:2840 +#: commands/extension.c:3133 commands/tablespace.c:782 #: commands/tablespace.c:873 guc-file.l:1001 replication/basebackup.c:409 -#: replication/basebackup.c:477 replication/logical/snapbuild.c:1491 -#: storage/file/copydir.c:72 storage/file/copydir.c:115 storage/file/fd.c:2826 -#: storage/file/fd.c:2918 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 +#: replication/basebackup.c:477 replication/logical/snapbuild.c:1496 +#: storage/file/copydir.c:72 storage/file/copydir.c:115 storage/file/fd.c:2903 +#: storage/file/fd.c:2995 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 #: utils/adt/dbsize.c:300 utils/adt/genfile.c:114 utils/adt/genfile.c:333 #, c-format msgid "could not stat file \"%s\": %m" msgstr "konnte »stat« für Datei »%s« nicht ausführen: %m" -#: access/transam/xlog.c:10184 access/transam/xlog.c:10222 +#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 #, c-format msgid "If you're sure there is no backup in progress, remove file \"%s\" and try again." msgstr "Wenn Sie sicher sind, dass noch kein Backup läuft, entfernen Sie die Datei »%s« und versuchen Sie es noch einmal." -#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 -#: access/transam/xlog.c:10615 +#: access/transam/xlog.c:10218 access/transam/xlog.c:10256 +#: access/transam/xlog.c:10648 #, c-format msgid "could not write file \"%s\": %m" msgstr "konnte Datei »%s« nicht schreiben: %m" -#: access/transam/xlog.c:10388 +#: access/transam/xlog.c:10418 #, c-format msgid "exclusive backup not in progress" msgstr "es läuft kein exklusives Backup" -#: access/transam/xlog.c:10415 +#: access/transam/xlog.c:10445 #, c-format msgid "a backup is not in progress" msgstr "es läuft kein Backup" -#: access/transam/xlog.c:10489 access/transam/xlog.c:10502 -#: access/transam/xlog.c:10842 access/transam/xlog.c:10848 -#: access/transam/xlog.c:10932 access/transam/xlogfuncs.c:695 +#: access/transam/xlog.c:10522 access/transam/xlog.c:10535 +#: access/transam/xlog.c:10875 access/transam/xlog.c:10881 +#: access/transam/xlog.c:10965 access/transam/xlogfuncs.c:690 #, c-format msgid "invalid data in file \"%s\"" msgstr "ungültige Daten in Datei »%s«" -#: access/transam/xlog.c:10506 replication/basebackup.c:938 +#: access/transam/xlog.c:10539 replication/basebackup.c:938 #, c-format msgid "the standby was promoted during online backup" msgstr "der Standby-Server wurde während der Online-Sicherung zum Primärserver befördert" -#: access/transam/xlog.c:10507 replication/basebackup.c:939 +#: access/transam/xlog.c:10540 replication/basebackup.c:939 #, c-format msgid "This means that the backup being taken is corrupt and should not be used. Try taking another online backup." msgstr "Das bedeutet, dass die aktuelle Online-Sicherung verfälscht ist und nicht verwendet werden sollte. Versuchen Sie, eine neue Online-Sicherung durchzuführen." -#: access/transam/xlog.c:10552 +#: access/transam/xlog.c:10585 #, c-format msgid "WAL generated with full_page_writes=off was replayed during online backup" msgstr "mit full_page_writes=off erzeugtes WAL wurde während der Online-Sicherung zurückgespielt" -#: access/transam/xlog.c:10664 +#: access/transam/xlog.c:10697 #, c-format msgid "pg_stop_backup cleanup done, waiting for required WAL segments to be archived" msgstr "Aufräumen nach pg_stop_backup beendet, warte bis die benötigten WAL-Segmente archiviert sind" -#: access/transam/xlog.c:10674 +#: access/transam/xlog.c:10707 #, c-format msgid "pg_stop_backup still waiting for all required WAL segments to be archived (%d seconds elapsed)" msgstr "pg_stop_backup wartet immer noch, bis alle benötigten WAL-Segmente archiviert sind (%d Sekunden abgelaufen)" -#: access/transam/xlog.c:10676 +#: access/transam/xlog.c:10709 #, c-format msgid "Check that your archive_command is executing properly. pg_stop_backup can be canceled safely, but the database backup will not be usable without all the WAL segments." msgstr "Prüfen Sie, ob das archive_command korrekt ausgeführt wird. pg_stop_backup kann gefahrlos abgebrochen werden, aber die Datenbanksicherung wird ohne die fehlenden WAL-Segmente nicht benutzbar sein." -#: access/transam/xlog.c:10683 +#: access/transam/xlog.c:10716 #, c-format msgid "pg_stop_backup complete, all required WAL segments have been archived" msgstr "pg_stop_backup abgeschlossen, alle benötigten WAL-Segmente wurden archiviert" -#: access/transam/xlog.c:10687 +#: access/transam/xlog.c:10720 #, c-format msgid "WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup" msgstr "WAL-Archivierung ist nicht eingeschaltet; Sie müssen dafür sorgen, dass alle benötigten WAL-Segmente auf andere Art kopiert werden, um die Sicherung abzuschließen" #. translator: %s is an XLog record description -#: access/transam/xlog.c:10972 +#: access/transam/xlog.c:11005 #, c-format msgid "xlog redo at %X/%X for %s" msgstr "xlog redo bei %X/%X für %s" -#: access/transam/xlog.c:11021 +#: access/transam/xlog.c:11054 #, c-format msgid "online backup mode was not canceled" msgstr "Online-Sicherungsmodus wurde nicht storniert" -#: access/transam/xlog.c:11022 +#: access/transam/xlog.c:11055 #, c-format msgid "File \"%s\" could not be renamed to \"%s\": %m." msgstr "Konnte Datei »%s« nicht in »%s« umbenennen: %m." -#: access/transam/xlog.c:11031 access/transam/xlog.c:11043 -#: access/transam/xlog.c:11053 +#: access/transam/xlog.c:11064 access/transam/xlog.c:11076 +#: access/transam/xlog.c:11086 #, c-format msgid "online backup mode canceled" msgstr "Online-Sicherungsmodus storniert" -#: access/transam/xlog.c:11044 +#: access/transam/xlog.c:11077 #, c-format msgid "Files \"%s\" and \"%s\" were renamed to \"%s\" and \"%s\", respectively." msgstr "Dateien »%s« und »%s« wurden in »%s« und »%s« umbenannt." -#: access/transam/xlog.c:11054 +#: access/transam/xlog.c:11087 #, c-format msgid "File \"%s\" was renamed to \"%s\", but file \"%s\" could not be renamed to \"%s\": %m." msgstr "Datei »%s« wurde in »%s« umbenannt, aber Datei »%s« konnte nicht in »%s« umbenannt werden: %m." -#: access/transam/xlog.c:11176 access/transam/xlogutils.c:718 -#: replication/walreceiver.c:994 replication/walsender.c:2114 +#: access/transam/xlog.c:11209 access/transam/xlogutils.c:718 +#: replication/walreceiver.c:994 replication/walsender.c:2156 #, c-format msgid "could not seek in log segment %s to offset %u: %m" msgstr "konnte Positionszeiger von Logsegment %s nicht auf %u setzen: %m" -#: access/transam/xlog.c:11188 +#: access/transam/xlog.c:11221 #, c-format msgid "could not read from log segment %s, offset %u: %m" msgstr "konnte nicht aus Logsegment %s, Position %u lesen: %m" -#: access/transam/xlog.c:11662 +#: access/transam/xlog.c:11695 #, c-format msgid "received promote request" msgstr "Anforderung zum Befördern empfangen" -#: access/transam/xlog.c:11675 +#: access/transam/xlog.c:11708 #, c-format msgid "trigger file found: %s" msgstr "Triggerdatei gefunden: %s" -#: access/transam/xlog.c:11684 +#: access/transam/xlog.c:11717 #, c-format msgid "could not stat trigger file \"%s\": %m" msgstr "konnte »stat« für Trigger-Datei »%s« nicht ausführen: %m" @@ -2713,8 +2542,8 @@ msgid "%s \"%s\": %s" msgstr "%s »%s«: %s" #: access/transam/xlogarchive.c:458 replication/logical/snapbuild.c:1619 -#: replication/slot.c:480 replication/slot.c:992 replication/slot.c:1100 -#: storage/file/fd.c:635 storage/file/fd.c:693 utils/time/snapmgr.c:1298 +#: replication/slot.c:496 replication/slot.c:1009 replication/slot.c:1117 +#: storage/file/fd.c:642 storage/file/fd.c:700 utils/time/snapmgr.c:1298 #, c-format msgid "could not rename file \"%s\" to \"%s\": %m" msgstr "konnte Datei »%s« nicht in »%s« umbenennen: %m" @@ -2729,102 +2558,102 @@ msgstr "konnte Archivstatusdatei »%s« nicht erstellen: %m" msgid "could not write archive status file \"%s\": %m" msgstr "konnte Archivstatusdatei »%s« nicht schreiben: %m" -#: access/transam/xlogfuncs.c:58 +#: access/transam/xlogfuncs.c:56 #, c-format msgid "aborting backup due to backend exiting before pg_stop_backup was called" msgstr "Backup wird abgebrochen, weil Backend-Prozess beendete, bevor pg_stop_backup aufgerufen wurde" -#: access/transam/xlogfuncs.c:88 +#: access/transam/xlogfuncs.c:87 #, c-format msgid "a backup is already in progress in this session" msgstr "ein Backup läuft bereits in dieser Sitzung" -#: access/transam/xlogfuncs.c:94 commands/tablespace.c:705 -#: commands/tablespace.c:715 postmaster/postmaster.c:1406 +#: access/transam/xlogfuncs.c:93 commands/tablespace.c:705 +#: commands/tablespace.c:715 postmaster/postmaster.c:1424 #: replication/basebackup.c:297 replication/basebackup.c:637 -#: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2292 -#: storage/file/fd.c:2891 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 +#: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2369 +#: storage/file/fd.c:2968 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 #: utils/adt/misc.c:411 utils/misc/tzparser.c:339 #, c-format msgid "could not open directory \"%s\": %m" msgstr "konnte Verzeichnis »%s« nicht öffnen: %m" -#: access/transam/xlogfuncs.c:155 access/transam/xlogfuncs.c:229 +#: access/transam/xlogfuncs.c:153 access/transam/xlogfuncs.c:226 #, c-format msgid "non-exclusive backup in progress" msgstr "es läuft ein nicht-exklusives Backup" -#: access/transam/xlogfuncs.c:156 access/transam/xlogfuncs.c:230 +#: access/transam/xlogfuncs.c:154 access/transam/xlogfuncs.c:227 #, c-format msgid "Did you mean to use pg_stop_backup('f')?" msgstr "Meinten Sie pg_stop_backup('f')?" -#: access/transam/xlogfuncs.c:200 commands/event_trigger.c:1445 -#: commands/event_trigger.c:1996 commands/extension.c:1729 -#: commands/extension.c:1838 commands/extension.c:2031 commands/prepare.c:702 +#: access/transam/xlogfuncs.c:197 commands/event_trigger.c:1445 +#: commands/event_trigger.c:1996 commands/extension.c:1732 +#: commands/extension.c:1841 commands/extension.c:2034 commands/prepare.c:702 #: executor/execQual.c:1757 executor/execQual.c:1782 executor/execQual.c:2157 #: executor/execQual.c:5438 executor/functions.c:1031 foreign/foreign.c:492 -#: replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1391 -#: replication/slotfuncs.c:189 replication/walsender.c:2763 +#: replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1394 +#: replication/slotfuncs.c:189 replication/walsender.c:2882 #: utils/adt/jsonfuncs.c:1483 utils/adt/jsonfuncs.c:1613 #: utils/adt/jsonfuncs.c:1801 utils/adt/jsonfuncs.c:1928 #: utils/adt/jsonfuncs.c:2694 utils/adt/pgstatfuncs.c:554 #: utils/adt/pgstatfuncs.c:655 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8436 -#: utils/mmgr/portalmem.c:1074 +#: utils/mmgr/portalmem.c:1088 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "Funktion mit Mengenergebnis in einem Zusammenhang aufgerufen, der keine Mengenergebnisse verarbeiten kann" -#: access/transam/xlogfuncs.c:204 commands/event_trigger.c:1449 -#: commands/event_trigger.c:2000 commands/extension.c:1733 -#: commands/extension.c:1842 commands/extension.c:2035 commands/prepare.c:706 +#: access/transam/xlogfuncs.c:201 commands/event_trigger.c:1449 +#: commands/event_trigger.c:2000 commands/extension.c:1736 +#: commands/extension.c:1845 commands/extension.c:2038 commands/prepare.c:706 #: foreign/foreign.c:497 replication/logical/logicalfuncs.c:179 -#: replication/logical/origin.c:1395 replication/slotfuncs.c:193 -#: replication/walsender.c:2767 utils/adt/pgstatfuncs.c:558 +#: replication/logical/origin.c:1398 replication/slotfuncs.c:193 +#: replication/walsender.c:2886 utils/adt/pgstatfuncs.c:558 #: utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8440 utils/misc/pg_config.c:44 -#: utils/mmgr/portalmem.c:1078 +#: utils/mmgr/portalmem.c:1092 #, c-format msgid "materialize mode required, but it is not allowed in this context" msgstr "Materialisierungsmodus wird benötigt, ist aber in diesem Zusammenhang nicht erlaubt" -#: access/transam/xlogfuncs.c:247 +#: access/transam/xlogfuncs.c:243 #, c-format msgid "non-exclusive backup is not in progress" msgstr "es läuft kein nicht-exklusives Backup" -#: access/transam/xlogfuncs.c:248 +#: access/transam/xlogfuncs.c:244 #, c-format msgid "Did you mean to use pg_stop_backup('t')?" msgstr "Meinten Sie pg_stop_backup('t')?" -#: access/transam/xlogfuncs.c:326 +#: access/transam/xlogfuncs.c:321 #, c-format msgid "WAL level not sufficient for creating a restore point" msgstr "WAL-Level nicht ausreichend, um Restore-Punkt anzulegen" -#: access/transam/xlogfuncs.c:334 +#: access/transam/xlogfuncs.c:329 #, c-format msgid "value too long for restore point (maximum %d characters)" msgstr "Wert zu lang für Restore-Punkt (maximal %d Zeichen)" -#: access/transam/xlogfuncs.c:472 +#: access/transam/xlogfuncs.c:467 #, c-format msgid "pg_xlogfile_name_offset() cannot be executed during recovery." msgstr "pg_xlogfile_name_offset() kann nicht während der Wiederherstellung ausgeführt werden." -#: access/transam/xlogfuncs.c:528 +#: access/transam/xlogfuncs.c:523 #, c-format msgid "pg_xlogfile_name() cannot be executed during recovery." msgstr "pg_xlogfile_name() kann nicht während der Wiederherstellung ausgeführt werden." -#: access/transam/xlogfuncs.c:548 access/transam/xlogfuncs.c:568 -#: access/transam/xlogfuncs.c:585 +#: access/transam/xlogfuncs.c:543 access/transam/xlogfuncs.c:563 +#: access/transam/xlogfuncs.c:580 #, c-format msgid "recovery is not in progress" msgstr "Wiederherstellung läuft nicht" -#: access/transam/xlogfuncs.c:549 access/transam/xlogfuncs.c:569 -#: access/transam/xlogfuncs.c:586 +#: access/transam/xlogfuncs.c:544 access/transam/xlogfuncs.c:564 +#: access/transam/xlogfuncs.c:581 #, c-format msgid "Recovery control functions can only be executed during recovery." msgstr "Wiederherstellungskontrollfunktionen können nur während der Wiederherstellung ausgeführt werden." @@ -2964,23 +2793,23 @@ msgstr "Datensatz mit ungültiger Länge bei %X/%X" msgid "invalid compressed image at %X/%X, block %d" msgstr "ungültiges komprimiertes Abbild bei %X/%X, Block %d" -#: access/transam/xlogutils.c:739 replication/walsender.c:2131 +#: access/transam/xlogutils.c:739 replication/walsender.c:2173 #, c-format msgid "could not read from log segment %s, offset %u, length %lu: %m" msgstr "konnte nicht aus Logsegment %s bei Position %u, Länge %lu lesen: %m" -#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:793 tcop/postgres.c:3501 +#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:811 tcop/postgres.c:3499 #, c-format msgid "--%s requires a value" msgstr "--%s benötigt einen Wert" -#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:798 tcop/postgres.c:3506 +#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:816 tcop/postgres.c:3504 #, c-format msgid "-c %s requires a value" msgstr "-c %s benötigt einen Wert" -#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:810 -#: postmaster/postmaster.c:823 +#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:828 +#: postmaster/postmaster.c:841 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Versuchen Sie »%s --help« für weitere Informationen.\n" @@ -3108,24 +2937,24 @@ msgid "large object %u does not exist" msgstr "Large Object %u existiert nicht" #: catalog/aclchk.c:882 catalog/aclchk.c:890 commands/collationcmds.c:92 -#: commands/copy.c:1047 commands/copy.c:1065 commands/copy.c:1073 -#: commands/copy.c:1081 commands/copy.c:1089 commands/copy.c:1097 -#: commands/copy.c:1105 commands/copy.c:1113 commands/copy.c:1121 -#: commands/copy.c:1137 commands/copy.c:1151 commands/copy.c:1170 -#: commands/copy.c:1185 commands/dbcommands.c:155 commands/dbcommands.c:163 +#: commands/copy.c:1048 commands/copy.c:1066 commands/copy.c:1074 +#: commands/copy.c:1082 commands/copy.c:1090 commands/copy.c:1098 +#: commands/copy.c:1106 commands/copy.c:1114 commands/copy.c:1122 +#: commands/copy.c:1138 commands/copy.c:1152 commands/copy.c:1171 +#: commands/copy.c:1186 commands/dbcommands.c:155 commands/dbcommands.c:163 #: commands/dbcommands.c:171 commands/dbcommands.c:179 #: commands/dbcommands.c:187 commands/dbcommands.c:195 #: commands/dbcommands.c:203 commands/dbcommands.c:211 #: commands/dbcommands.c:219 commands/dbcommands.c:1397 #: commands/dbcommands.c:1405 commands/dbcommands.c:1413 -#: commands/dbcommands.c:1421 commands/extension.c:1219 -#: commands/extension.c:1227 commands/extension.c:1235 -#: commands/extension.c:1243 commands/extension.c:2761 +#: commands/dbcommands.c:1421 commands/extension.c:1222 +#: commands/extension.c:1230 commands/extension.c:1238 +#: commands/extension.c:1246 commands/extension.c:2764 #: commands/foreigncmds.c:539 commands/foreigncmds.c:548 #: commands/functioncmds.c:533 commands/functioncmds.c:649 #: commands/functioncmds.c:657 commands/functioncmds.c:665 -#: commands/functioncmds.c:673 commands/functioncmds.c:2085 -#: commands/functioncmds.c:2093 commands/sequence.c:1189 +#: commands/functioncmds.c:673 commands/functioncmds.c:2105 +#: commands/functioncmds.c:2113 commands/sequence.c:1189 #: commands/sequence.c:1197 commands/sequence.c:1205 commands/sequence.c:1213 #: commands/sequence.c:1221 commands/sequence.c:1229 commands/sequence.c:1237 #: commands/sequence.c:1245 commands/typecmds.c:295 commands/typecmds.c:1382 @@ -3149,21 +2978,21 @@ msgid "default privileges cannot be set for columns" msgstr "Vorgabeprivilegien können nicht für Spalten gesetzt werden" #: catalog/aclchk.c:1502 catalog/objectaddress.c:1390 commands/analyze.c:376 -#: commands/copy.c:4458 commands/sequence.c:1491 commands/tablecmds.c:5198 -#: commands/tablecmds.c:5304 commands/tablecmds.c:5364 -#: commands/tablecmds.c:5477 commands/tablecmds.c:5534 -#: commands/tablecmds.c:5628 commands/tablecmds.c:5724 -#: commands/tablecmds.c:7915 commands/tablecmds.c:8177 -#: commands/tablecmds.c:8597 commands/trigger.c:642 parser/analyze.c:2228 +#: commands/copy.c:4459 commands/sequence.c:1491 commands/tablecmds.c:5211 +#: commands/tablecmds.c:5317 commands/tablecmds.c:5377 +#: commands/tablecmds.c:5490 commands/tablecmds.c:5547 +#: commands/tablecmds.c:5641 commands/tablecmds.c:5737 +#: commands/tablecmds.c:7929 commands/tablecmds.c:8191 +#: commands/tablecmds.c:8611 commands/trigger.c:642 parser/analyze.c:2228 #: parser/parse_relation.c:2628 parser/parse_relation.c:2690 #: parser/parse_target.c:951 parser/parse_type.c:127 utils/adt/acl.c:2840 -#: utils/adt/ruleutils.c:1984 +#: utils/adt/ruleutils.c:1987 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist" msgstr "Spalte »%s« von Relation »%s« existiert nicht" #: catalog/aclchk.c:1771 catalog/objectaddress.c:1203 commands/sequence.c:1078 -#: commands/tablecmds.c:224 commands/tablecmds.c:12154 utils/adt/acl.c:2076 +#: commands/tablecmds.c:224 commands/tablecmds.c:12168 utils/adt/acl.c:2076 #: utils/adt/acl.c:2106 utils/adt/acl.c:2138 utils/adt/acl.c:2170 #: utils/adt/acl.c:2198 utils/adt/acl.c:2228 #, c-format @@ -3210,7 +3039,7 @@ msgstr "für Array-Typen können keine Privilegien gesetzt werden" msgid "Set the privileges of the element type instead." msgstr "Setzen Sie stattdessen die Privilegien des Elementtyps." -#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3146 +#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3161 #, c-format msgid "\"%s\" is not a domain" msgstr "»%s« ist keine Domäne" @@ -3610,12 +3439,12 @@ msgid "System catalog modifications are currently disallowed." msgstr "Änderungen an Systemkatalogen sind gegenwärtig nicht erlaubt." #: catalog/heap.c:415 commands/tablecmds.c:1439 commands/tablecmds.c:1896 -#: commands/tablecmds.c:4820 +#: commands/tablecmds.c:4833 #, c-format msgid "tables can have at most %d columns" msgstr "Tabellen können höchstens %d Spalten haben" -#: catalog/heap.c:432 commands/tablecmds.c:5081 +#: catalog/heap.c:432 commands/tablecmds.c:5094 #, c-format msgid "column name \"%s\" conflicts with a system column name" msgstr "Spaltenname »%s« steht im Konflikt mit dem Namen einer Systemspalte" @@ -3651,11 +3480,11 @@ msgid "no collation was derived for column \"%s\" with collatable type %s" msgstr "für Spalte »%s« mit sortierbarem Typ %s wurde keine Sortierfolge abgeleitet" #: catalog/heap.c:586 commands/createas.c:204 commands/createas.c:501 -#: commands/indexcmds.c:1132 commands/view.c:103 regex/regc_pg_locale.c:262 +#: commands/indexcmds.c:1133 commands/view.c:103 regex/regc_pg_locale.c:262 #: utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 #: utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 #: utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 -#: utils/adt/like.c:213 utils/adt/selfuncs.c:5334 utils/adt/varlena.c:1421 +#: utils/adt/like.c:213 utils/adt/selfuncs.c:5434 utils/adt/varlena.c:1421 #: utils/adt/varlena.c:1826 #, c-format msgid "Use the COLLATE clause to set the collation explicitly." @@ -3666,7 +3495,7 @@ msgstr "Verwenden Sie die COLLATE-Klausel, um die Sortierfolge explizit zu setze msgid "relation \"%s\" already exists" msgstr "Relation »%s« existiert bereits" -#: catalog/heap.c:1083 catalog/pg_type.c:412 catalog/pg_type.c:722 +#: catalog/heap.c:1083 catalog/pg_type.c:412 catalog/pg_type.c:737 #: commands/typecmds.c:237 commands/typecmds.c:784 commands/typecmds.c:1135 #: commands/typecmds.c:1357 commands/typecmds.c:2113 #, c-format @@ -3688,7 +3517,7 @@ msgstr "Heap-OID-Wert für pg_class ist im Binary-Upgrade-Modus nicht gesetzt" msgid "check constraint \"%s\" already exists" msgstr "Check-Constraint »%s« existiert bereits" -#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6069 +#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6082 #, c-format msgid "constraint \"%s\" for relation \"%s\" already exists" msgstr "Constraint »%s« existiert bereits für Relation »%s«" @@ -3723,14 +3552,14 @@ msgstr "Spaltenverweise können nicht in Vorgabeausdrücken verwendet werden" msgid "default expression must not return a set" msgstr "Vorgabeausdruck kann keine Ergebnismenge zurückgeben" -#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1084 +#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1115 #, c-format msgid "column \"%s\" is of type %s but default expression is of type %s" msgstr "Spalte »%s« hat Typ %s, aber der Vorgabeausdruck hat Typ %s" #: catalog/heap.c:2630 commands/prepare.c:374 parser/parse_node.c:428 #: parser/parse_target.c:539 parser/parse_target.c:789 -#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1089 +#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1120 #, c-format msgid "You will need to rewrite or cast the expression." msgstr "Sie müssen den Ausdruck umschreiben oder eine Typumwandlung vornehmen." @@ -3765,7 +3594,7 @@ msgstr "Tabelle »%s« verweist auf »%s«." msgid "Truncate table \"%s\" at the same time, or use TRUNCATE ... CASCADE." msgstr "Leeren Sie die Tabelle »%s« gleichzeitig oder verwenden Sie TRUNCATE ... CASCADE." -#: catalog/index.c:210 parser/parse_utilcmd.c:1473 parser/parse_utilcmd.c:1559 +#: catalog/index.c:210 parser/parse_utilcmd.c:1474 parser/parse_utilcmd.c:1560 #, c-format msgid "multiple primary keys for table \"%s\" are not allowed" msgstr "mehrere Primärschlüssel für Tabelle »%s« nicht erlaubt" @@ -3791,7 +3620,7 @@ msgid "shared indexes cannot be created after initdb" msgstr "Cluster-globale Indexe können nicht nach initdb erzeugt werden" #: catalog/index.c:784 commands/createas.c:249 commands/sequence.c:141 -#: parser/parse_utilcmd.c:191 +#: parser/parse_utilcmd.c:192 #, c-format msgid "relation \"%s\" already exists, skipping" msgstr "Relation »%s« existiert bereits, wird übersprungen" @@ -3821,12 +3650,6 @@ msgstr "kann temporäre Tabellen anderer Sitzungen nicht reindizieren" msgid "index \"%s\" was reindexed" msgstr "Index »%s« wurde neu indiziert" -#: catalog/index.c:3456 commands/vacuumlazy.c:1338 commands/vacuumlazy.c:1414 -#: commands/vacuumlazy.c:1603 commands/vacuumlazy.c:1813 -#, c-format -msgid "%s." -msgstr "%s." - #: catalog/namespace.c:249 catalog/namespace.c:447 catalog/namespace.c:541 #: commands/trigger.c:4523 #, c-format @@ -3854,13 +3677,13 @@ msgid "relation \"%s.%s\" does not exist" msgstr "Relation »%s.%s« existiert nicht" #: catalog/namespace.c:419 parser/parse_relation.c:1151 -#: parser/parse_relation.c:1159 utils/adt/regproc.c:1034 +#: parser/parse_relation.c:1159 utils/adt/regproc.c:1035 #, c-format msgid "relation \"%s\" does not exist" msgstr "Relation »%s« existiert nicht" -#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1383 -#: commands/extension.c:1389 +#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1386 +#: commands/extension.c:1392 #, c-format msgid "no schema has been selected to create in" msgstr "kein Schema für die Objekterzeugung ausgewählt" @@ -3906,7 +3729,7 @@ msgstr "Textsuchekonfiguration »%s« existiert nicht" msgid "cross-database references are not implemented: %s" msgstr "Verweise auf andere Datenbanken sind nicht implementiert: %s" -#: catalog/namespace.c:2652 gram.y:13450 gram.y:14819 parser/parse_expr.c:799 +#: catalog/namespace.c:2652 gram.y:13463 gram.y:14832 parser/parse_expr.c:799 #: parser/parse_target.c:1148 #, c-format msgid "improper qualified name (too many dotted names): %s" @@ -3955,8 +3778,8 @@ msgstr "während der Wiederherstellung können keine temporären Tabellen erzeug #: catalog/namespace.c:3688 #, c-format -msgid "cannot create temporary tables in parallel mode" -msgstr "im Parallelmodus können keine temporären Tabellen erzeugt werden" +msgid "cannot create temporary tables during a parallel operation" +msgstr "während einer parallelen Operation können keine temporären Tabellen erzeugt werden" #: catalog/namespace.c:3932 commands/tablespace.c:1173 commands/variable.c:63 #: utils/misc/guc.c:9875 @@ -3972,7 +3795,7 @@ msgstr "Zugriffsmethodenname kann nicht qualifiziert werden" msgid "database name cannot be qualified" msgstr "Datenbankname kann nicht qualifiziert werden" -#: catalog/objectaddress.c:1071 commands/extension.c:2507 +#: catalog/objectaddress.c:1071 commands/extension.c:2510 #, c-format msgid "extension name cannot be qualified" msgstr "Erweiterungsname kann nicht qualifiziert werden" @@ -4008,25 +3831,25 @@ msgstr "Ereignistriggername kann nicht qualifiziert werden" #: catalog/objectaddress.c:1210 commands/lockcmds.c:94 commands/policy.c:94 #: commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:218 #: commands/tablecmds.c:1300 commands/tablecmds.c:4347 -#: commands/tablecmds.c:8017 +#: commands/tablecmds.c:8031 #, c-format msgid "\"%s\" is not a table" msgstr "»%s« ist keine Tabelle" #: catalog/objectaddress.c:1217 commands/tablecmds.c:230 -#: commands/tablecmds.c:4377 commands/tablecmds.c:12159 commands/view.c:141 +#: commands/tablecmds.c:4377 commands/tablecmds.c:12173 commands/view.c:141 #, c-format msgid "\"%s\" is not a view" msgstr "»%s« ist keine Sicht" #: catalog/objectaddress.c:1224 commands/matview.c:174 -#: commands/tablecmds.c:236 commands/tablecmds.c:12164 +#: commands/tablecmds.c:236 commands/tablecmds.c:12178 #, c-format msgid "\"%s\" is not a materialized view" msgstr "»%s« ist keine materialisierte Sicht" #: catalog/objectaddress.c:1231 commands/tablecmds.c:254 -#: commands/tablecmds.c:4380 commands/tablecmds.c:12169 +#: commands/tablecmds.c:4380 commands/tablecmds.c:12183 #, c-format msgid "\"%s\" is not a foreign table" msgstr "»%s« ist keine Fremdtabelle" @@ -4042,9 +3865,9 @@ msgid "default value for column \"%s\" of relation \"%s\" does not exist" msgstr "Vorgabewert für Spalte »%s« von Relation »%s« existiert nicht" #: catalog/objectaddress.c:1512 commands/functioncmds.c:128 -#: commands/tablecmds.c:246 commands/typecmds.c:3214 parser/parse_type.c:226 +#: commands/tablecmds.c:246 commands/typecmds.c:3229 parser/parse_type.c:226 #: parser/parse_type.c:255 parser/parse_type.c:795 utils/adt/acl.c:4374 -#: utils/adt/regproc.c:1225 +#: utils/adt/regproc.c:1226 #, c-format msgid "type \"%s\" does not exist" msgstr "Typ »%s« existiert nicht" @@ -4054,161 +3877,161 @@ msgstr "Typ »%s« existiert nicht" msgid "operator %d (%s, %s) of %s does not exist" msgstr "Operator %d (%s, %s) von %s existiert nicht" -#: catalog/objectaddress.c:1658 +#: catalog/objectaddress.c:1660 #, c-format msgid "function %d (%s, %s) of %s does not exist" msgstr "Funktion %d (%s, %s) von %s existiert nicht" -#: catalog/objectaddress.c:1707 catalog/objectaddress.c:1733 +#: catalog/objectaddress.c:1711 catalog/objectaddress.c:1737 #, c-format msgid "user mapping for user \"%s\" on server \"%s\" does not exist" msgstr "Benutzerabbildung für Benutzer »%s« auf Server »%s« existiert nicht" -#: catalog/objectaddress.c:1722 commands/foreigncmds.c:430 +#: catalog/objectaddress.c:1726 commands/foreigncmds.c:430 #: commands/foreigncmds.c:997 commands/foreigncmds.c:1359 #: foreign/foreign.c:692 #, c-format msgid "server \"%s\" does not exist" msgstr "Server »%s« existiert nicht" -#: catalog/objectaddress.c:1794 +#: catalog/objectaddress.c:1798 #, c-format msgid "unrecognized default ACL object type %c" msgstr "unbekannter Standard-ACL-Objekttyp %c" -#: catalog/objectaddress.c:1795 +#: catalog/objectaddress.c:1799 #, c-format msgid "Valid object types are \"r\", \"S\", \"f\", and \"T\"." msgstr "Gültige Objekttypen sind »r«, »S«, »f« und »T«." -#: catalog/objectaddress.c:1841 +#: catalog/objectaddress.c:1845 #, c-format msgid "default ACL for user \"%s\" in schema \"%s\" on %s does not exist" msgstr "Standard-ACL für Benutzer »%s« in Schema »%s« für %s existiert nicht" -#: catalog/objectaddress.c:1846 +#: catalog/objectaddress.c:1850 #, c-format msgid "default ACL for user \"%s\" on %s does not exist" msgstr "Standard-ACL für Benutzer »%s« für %s existiert nicht" -#: catalog/objectaddress.c:1873 catalog/objectaddress.c:1929 -#: catalog/objectaddress.c:1984 +#: catalog/objectaddress.c:1877 catalog/objectaddress.c:1933 +#: catalog/objectaddress.c:1988 #, c-format msgid "name or argument lists may not contain nulls" msgstr "Namens- oder Argumentlisten dürfen keine NULL-Werte enthalten" -#: catalog/objectaddress.c:1905 +#: catalog/objectaddress.c:1909 #, c-format msgid "unsupported object type \"%s\"" msgstr "nicht unterstützter Objekttyp »%s«" -#: catalog/objectaddress.c:1925 catalog/objectaddress.c:1943 +#: catalog/objectaddress.c:1929 catalog/objectaddress.c:1947 #, c-format msgid "name list length must be exactly %d" msgstr "Länge der Namensliste muss genau %d sein" -#: catalog/objectaddress.c:1947 +#: catalog/objectaddress.c:1951 #, c-format msgid "large object OID may not be null" msgstr "Large-Object-OID darf nicht NULL sein" -#: catalog/objectaddress.c:1956 catalog/objectaddress.c:2016 -#: catalog/objectaddress.c:2023 +#: catalog/objectaddress.c:1960 catalog/objectaddress.c:2020 +#: catalog/objectaddress.c:2027 #, c-format msgid "name list length must be at least %d" msgstr "Länge der Namensliste muss mindestens %d sein" -#: catalog/objectaddress.c:2009 catalog/objectaddress.c:2029 +#: catalog/objectaddress.c:2013 catalog/objectaddress.c:2033 #, c-format msgid "argument list length must be exactly %d" msgstr "Länge der Argumentliste muss genau %d sein" -#: catalog/objectaddress.c:2165 libpq/be-fsstubs.c:350 +#: catalog/objectaddress.c:2169 libpq/be-fsstubs.c:350 #, c-format msgid "must be owner of large object %u" msgstr "Berechtigung nur für Eigentümer des Large Object %u" -#: catalog/objectaddress.c:2180 commands/functioncmds.c:1426 +#: catalog/objectaddress.c:2184 commands/functioncmds.c:1446 #, c-format msgid "must be owner of type %s or type %s" msgstr "Berechtigung nur für Eigentümer des Typs %s oder des Typs %s" -#: catalog/objectaddress.c:2220 catalog/objectaddress.c:2237 +#: catalog/objectaddress.c:2224 catalog/objectaddress.c:2241 #, c-format msgid "must be superuser" msgstr "Berechtigung nur für Superuser" -#: catalog/objectaddress.c:2227 +#: catalog/objectaddress.c:2231 #, c-format msgid "must have CREATEROLE privilege" msgstr "Berechtigung nur mit CREATEROLE-Privileg" -#: catalog/objectaddress.c:2302 +#: catalog/objectaddress.c:2306 #, c-format msgid "unrecognized object type \"%s\"" msgstr "unbekannter Objekttyp »%s«" -#: catalog/objectaddress.c:2497 +#: catalog/objectaddress.c:2501 #, c-format msgid " column %s" msgstr " Spalte %s" -#: catalog/objectaddress.c:2503 +#: catalog/objectaddress.c:2507 #, c-format msgid "function %s" msgstr "Funktion %s" -#: catalog/objectaddress.c:2508 +#: catalog/objectaddress.c:2512 #, c-format msgid "type %s" msgstr "Typ %s" -#: catalog/objectaddress.c:2538 +#: catalog/objectaddress.c:2542 #, c-format msgid "cast from %s to %s" msgstr "Typumwandlung von %s in %s" -#: catalog/objectaddress.c:2558 +#: catalog/objectaddress.c:2562 #, c-format msgid "collation %s" msgstr "Sortierfolge %s" -#: catalog/objectaddress.c:2582 +#: catalog/objectaddress.c:2586 #, c-format msgid "constraint %s on %s" msgstr "Constraint %s für %s" -#: catalog/objectaddress.c:2588 +#: catalog/objectaddress.c:2592 #, c-format msgid "constraint %s" msgstr "Constraint %s" -#: catalog/objectaddress.c:2605 +#: catalog/objectaddress.c:2609 #, c-format msgid "conversion %s" msgstr "Konversion %s" -#: catalog/objectaddress.c:2642 +#: catalog/objectaddress.c:2646 #, c-format msgid "default for %s" msgstr "Vorgabewert für %s" -#: catalog/objectaddress.c:2651 +#: catalog/objectaddress.c:2655 #, c-format msgid "language %s" msgstr "Sprache %s" -#: catalog/objectaddress.c:2656 +#: catalog/objectaddress.c:2660 #, c-format msgid "large object %u" msgstr "Large Object %u" -#: catalog/objectaddress.c:2661 +#: catalog/objectaddress.c:2665 #, c-format msgid "operator %s" msgstr "Operator %s" -#: catalog/objectaddress.c:2693 +#: catalog/objectaddress.c:2697 #, c-format msgid "operator class %s for access method %s" msgstr "Operatorklasse %s für Zugriffsmethode %s" @@ -4217,7 +4040,7 @@ msgstr "Operatorklasse %s für Zugriffsmethode %s" #. first two %s's are data type names, the third %s is the #. description of the operator family, and the last %s is the #. textual form of the operator with arguments. -#: catalog/objectaddress.c:2743 +#: catalog/objectaddress.c:2747 #, c-format msgid "operator %d (%s, %s) of %s: %s" msgstr "Operator %d (%s, %s) von %s: %s" @@ -4226,177 +4049,177 @@ msgstr "Operator %d (%s, %s) von %s: %s" #. are data type names, the third %s is the description of the #. operator family, and the last %s is the textual form of the #. function with arguments. -#: catalog/objectaddress.c:2793 +#: catalog/objectaddress.c:2797 #, c-format msgid "function %d (%s, %s) of %s: %s" msgstr "Funktion %d (%s, %s) von %s: %s" -#: catalog/objectaddress.c:2833 +#: catalog/objectaddress.c:2837 #, c-format msgid "rule %s on " msgstr "Regel %s für " -#: catalog/objectaddress.c:2855 +#: catalog/objectaddress.c:2859 #, c-format msgid "transform for %s language %s" msgstr "Transformation %s für Sprache %s" -#: catalog/objectaddress.c:2889 +#: catalog/objectaddress.c:2893 #, c-format msgid "trigger %s on " msgstr "Trigger %s für " -#: catalog/objectaddress.c:2906 +#: catalog/objectaddress.c:2910 #, c-format msgid "schema %s" msgstr "Schema %s" -#: catalog/objectaddress.c:2919 +#: catalog/objectaddress.c:2923 #, c-format msgid "text search parser %s" msgstr "Textsucheparser %s" -#: catalog/objectaddress.c:2934 +#: catalog/objectaddress.c:2938 #, c-format msgid "text search dictionary %s" msgstr "Textsuchewörterbuch %s" -#: catalog/objectaddress.c:2949 +#: catalog/objectaddress.c:2953 #, c-format msgid "text search template %s" msgstr "Textsuchevorlage %s" -#: catalog/objectaddress.c:2964 +#: catalog/objectaddress.c:2968 #, c-format msgid "text search configuration %s" msgstr "Textsuchekonfiguration %s" -#: catalog/objectaddress.c:2972 +#: catalog/objectaddress.c:2976 #, c-format msgid "role %s" msgstr "Rolle %s" -#: catalog/objectaddress.c:2985 +#: catalog/objectaddress.c:2989 #, c-format msgid "database %s" msgstr "Datenbank %s" -#: catalog/objectaddress.c:2997 +#: catalog/objectaddress.c:3001 #, c-format msgid "tablespace %s" msgstr "Tablespace %s" -#: catalog/objectaddress.c:3006 +#: catalog/objectaddress.c:3010 #, c-format msgid "foreign-data wrapper %s" msgstr "Fremddaten-Wrapper %s" -#: catalog/objectaddress.c:3015 +#: catalog/objectaddress.c:3019 #, c-format msgid "server %s" msgstr "Server %s" -#: catalog/objectaddress.c:3043 +#: catalog/objectaddress.c:3047 #, c-format msgid "user mapping for %s on server %s" msgstr "Benutzerabbildung für %s auf Server %s" -#: catalog/objectaddress.c:3078 +#: catalog/objectaddress.c:3082 #, c-format msgid "default privileges on new relations belonging to role %s" msgstr "Vorgabeprivilegien für neue Relationen von Rolle %s" -#: catalog/objectaddress.c:3083 +#: catalog/objectaddress.c:3087 #, c-format msgid "default privileges on new sequences belonging to role %s" msgstr "Vorgabeprivilegien für neue Sequenzen von Rolle %s" -#: catalog/objectaddress.c:3088 +#: catalog/objectaddress.c:3092 #, c-format msgid "default privileges on new functions belonging to role %s" msgstr "Vorgabeprivilegien für neue Funktionen von Rolle %s" -#: catalog/objectaddress.c:3093 +#: catalog/objectaddress.c:3097 #, c-format msgid "default privileges on new types belonging to role %s" msgstr "Vorgabeprivilegien für neue Typen von Rolle %s" -#: catalog/objectaddress.c:3099 +#: catalog/objectaddress.c:3103 #, c-format msgid "default privileges belonging to role %s" msgstr "Vorgabeprivilegien von Rolle %s" -#: catalog/objectaddress.c:3107 +#: catalog/objectaddress.c:3111 #, c-format msgid " in schema %s" msgstr " in Schema %s" -#: catalog/objectaddress.c:3124 +#: catalog/objectaddress.c:3128 #, c-format msgid "extension %s" msgstr "Erweiterung %s" -#: catalog/objectaddress.c:3137 +#: catalog/objectaddress.c:3141 #, c-format msgid "event trigger %s" msgstr "Ereignistrigger %s" -#: catalog/objectaddress.c:3169 +#: catalog/objectaddress.c:3173 #, c-format msgid "policy %s on " msgstr "Policy %s für " -#: catalog/objectaddress.c:3187 +#: catalog/objectaddress.c:3191 #, c-format msgid "access method %s" msgstr "Zugriffsmethode %s" -#: catalog/objectaddress.c:3247 +#: catalog/objectaddress.c:3251 #, c-format msgid "table %s" msgstr "Tabelle %s" -#: catalog/objectaddress.c:3251 +#: catalog/objectaddress.c:3255 #, c-format msgid "index %s" msgstr "Index %s" -#: catalog/objectaddress.c:3255 +#: catalog/objectaddress.c:3259 #, c-format msgid "sequence %s" msgstr "Sequenz %s" -#: catalog/objectaddress.c:3259 +#: catalog/objectaddress.c:3263 #, c-format msgid "toast table %s" msgstr "TOAST-Tabelle %s" -#: catalog/objectaddress.c:3263 +#: catalog/objectaddress.c:3267 #, c-format msgid "view %s" msgstr "Sicht %s" -#: catalog/objectaddress.c:3267 +#: catalog/objectaddress.c:3271 #, c-format msgid "materialized view %s" msgstr "materialisierte Sicht %s" -#: catalog/objectaddress.c:3271 +#: catalog/objectaddress.c:3275 #, c-format msgid "composite type %s" msgstr "zusammengesetzter Typ %s" -#: catalog/objectaddress.c:3275 +#: catalog/objectaddress.c:3279 #, c-format msgid "foreign table %s" msgstr "Fremdtabelle %s" -#: catalog/objectaddress.c:3280 +#: catalog/objectaddress.c:3284 #, c-format msgid "relation %s" msgstr "Relation %s" -#: catalog/objectaddress.c:3317 +#: catalog/objectaddress.c:3321 #, c-format msgid "operator family %s for access method %s" msgstr "Operatorfamilie %s für Zugriffsmethode %s" @@ -4460,8 +4283,8 @@ msgstr "Rückgabetyp der Kombinierfunktion %s ist nicht %s" #: catalog/pg_aggregate.c:436 #, c-format -msgid "combine function with \"%s\" transition type must not be declared STRICT" -msgstr "Kombinierfunktion mit Ãœbergangstyp »%s« darf nicht als STRICT deklariert sein" +msgid "combine function with transition type %s must not be declared STRICT" +msgstr "Kombinierfunktion mit Ãœbergangstyp %s darf nicht als STRICT deklariert sein" #: catalog/pg_aggregate.c:455 #, c-format @@ -4573,7 +4396,7 @@ msgstr "Konversion »%s« existiert bereits" msgid "default conversion for %s to %s already exists" msgstr "Standardumwandlung von %s nach %s existiert bereits" -#: catalog/pg_depend.c:165 commands/extension.c:3029 +#: catalog/pg_depend.c:165 commands/extension.c:3032 #, c-format msgid "%s is already a member of extension \"%s\"" msgstr "%s ist schon Mitglied der Erweiterung »%s«" @@ -4875,13 +4698,13 @@ msgstr "Ausrichtung »%c« ist ungültig für Typen variabler Länge" msgid "fixed-size types must have storage PLAIN" msgstr "Typen mit fester Größe müssen Storage-Typ PLAIN haben" -#: catalog/pg_type.c:789 +#: catalog/pg_type.c:809 #, c-format msgid "could not form array type name for type \"%s\"" msgstr "konnte keinen Arraytypnamen für Datentyp »%s« erzeugen" #: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4359 -#: commands/tablecmds.c:12047 +#: commands/tablecmds.c:12061 #, c-format msgid "\"%s\" is not a table or materialized view" msgstr "»%s« ist keine Tabelle oder materialisierte Sicht" @@ -5051,7 +4874,7 @@ msgstr "Zugriffsmethode »%s« existiert bereits" msgid "must be superuser to drop access methods" msgstr "nur Superuser können Zugriffsmethoden löschen" -#: commands/amcmds.c:175 commands/indexcmds.c:164 commands/indexcmds.c:495 +#: commands/amcmds.c:175 commands/indexcmds.c:164 commands/indexcmds.c:496 #: commands/opclasscmds.c:365 commands/opclasscmds.c:790 #, c-format msgid "access method \"%s\" does not exist" @@ -5129,7 +4952,7 @@ msgstr "überspringe Analysieren des Vererbungsbaums »%s.%s« --- dieser Vererb msgid "skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no analyzable child tables" msgstr "überspringe Analysieren des Vererbungsbaums »%s.%s« --- dieser Vererbungsbaum enthält keine analysierbaren abgeleiteten Tabellen" -#: commands/analyze.c:1420 commands/tablecmds.c:8079 executor/execQual.c:2927 +#: commands/analyze.c:1420 commands/tablecmds.c:8093 executor/execQual.c:2927 msgid "could not convert row type" msgstr "konnte Zeilentyp nicht umwandeln" @@ -5183,7 +5006,7 @@ msgstr "kann temporäre Tabellen anderer Sitzungen nicht clustern" msgid "there is no previously clustered index for table \"%s\"" msgstr "es gibt keinen bereits geclusterten Index für Tabelle »%s«" -#: commands/cluster.c:173 commands/tablecmds.c:9383 commands/tablecmds.c:11143 +#: commands/cluster.c:173 commands/tablecmds.c:9397 commands/tablecmds.c:11157 #, c-format msgid "index \"%s\" for table \"%s\" does not exist" msgstr "Index »%s« für Tabelle »%s« existiert nicht" @@ -5198,7 +5021,7 @@ msgstr "globaler Katalog kann nicht geclustert werden" msgid "cannot vacuum temporary tables of other sessions" msgstr "temporäre Tabellen anderer Sitzungen können nicht gevacuumt werden" -#: commands/cluster.c:431 commands/tablecmds.c:11153 +#: commands/cluster.c:431 commands/tablecmds.c:11167 #, c-format msgid "\"%s\" is not an index for table \"%s\"" msgstr "»%s« ist kein Index für Tabelle »%s«" @@ -5218,27 +5041,27 @@ msgstr "kann nicht anhand des partiellen Index »%s« clustern" msgid "cannot cluster on invalid index \"%s\"" msgstr "kann nicht anhand des ungültigen Index »%s« clustern" -#: commands/cluster.c:918 +#: commands/cluster.c:920 #, c-format msgid "clustering \"%s.%s\" using index scan on \"%s\"" msgstr "clustere »%s.%s« durch Index-Scan von »%s«" -#: commands/cluster.c:924 +#: commands/cluster.c:926 #, c-format msgid "clustering \"%s.%s\" using sequential scan and sort" msgstr "clustere »%s.%s« durch sequenziellen Scan und Sortieren" -#: commands/cluster.c:929 commands/vacuumlazy.c:479 +#: commands/cluster.c:931 commands/vacuumlazy.c:484 #, c-format msgid "vacuuming \"%s.%s\"" msgstr "vacuume »%s.%s«" -#: commands/cluster.c:1088 +#: commands/cluster.c:1090 #, c-format msgid "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u pages" msgstr "»%s«: %.0f entfernbare, %.0f nicht entfernbare Zeilenversionen in %u Seiten gefunden" -#: commands/cluster.c:1092 +#: commands/cluster.c:1094 #, c-format msgid "" "%.0f dead row versions cannot be removed yet.\n" @@ -5281,7 +5104,7 @@ msgstr "Sortierfolge »%s« existiert bereits in Schema »%s«" msgid "database \"%s\" does not exist" msgstr "Datenbank »%s« existiert nicht" -#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:753 +#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:754 #, c-format msgid "\"%s\" is not a table, view, materialized view, composite type, or foreign table" msgstr "»%s« ist weder Tabelle, Sicht, materialisierte Sicht, zusammengesetzter Typ noch Fremdtabelle" @@ -5343,7 +5166,7 @@ msgid "could not read from COPY file: %m" msgstr "konnte nicht aus COPY-Datei lesen: %m" #: commands/copy.c:595 commands/copy.c:616 commands/copy.c:620 -#: tcop/postgres.c:341 tcop/postgres.c:377 tcop/postgres.c:404 +#: tcop/postgres.c:333 tcop/postgres.c:369 tcop/postgres.c:396 #, c-format msgid "unexpected EOF on client connection with an open transaction" msgstr "unerwartetes EOF auf Client-Verbindung mit einer offenen Transaktion" @@ -5383,445 +5206,445 @@ msgstr "COPY FROM wird nicht unterstützt mit Sicherheit auf Zeilenebene" msgid "Use INSERT statements instead." msgstr "Verwenden Sie stattdessen INSERT-Anweisungen." -#: commands/copy.c:1058 +#: commands/copy.c:1059 #, c-format msgid "COPY format \"%s\" not recognized" msgstr "COPY-Format »%s« nicht erkannt" -#: commands/copy.c:1129 commands/copy.c:1143 commands/copy.c:1157 -#: commands/copy.c:1177 +#: commands/copy.c:1130 commands/copy.c:1144 commands/copy.c:1158 +#: commands/copy.c:1178 #, c-format msgid "argument to option \"%s\" must be a list of column names" msgstr "Argument von Option »%s« muss eine Liste aus Spaltennamen sein" -#: commands/copy.c:1190 +#: commands/copy.c:1191 #, c-format msgid "argument to option \"%s\" must be a valid encoding name" msgstr "Argument von Option »%s« muss ein gültiger Kodierungsname sein" -#: commands/copy.c:1196 commands/dbcommands.c:232 commands/dbcommands.c:1427 +#: commands/copy.c:1197 commands/dbcommands.c:232 commands/dbcommands.c:1427 #, c-format msgid "option \"%s\" not recognized" msgstr "Option »%s« nicht erkannt" -#: commands/copy.c:1207 +#: commands/copy.c:1208 #, c-format msgid "cannot specify DELIMITER in BINARY mode" msgstr "DELIMITER kann nicht im BINARY-Modus angegeben werden" -#: commands/copy.c:1212 +#: commands/copy.c:1213 #, c-format msgid "cannot specify NULL in BINARY mode" msgstr "NULL kann nicht im BINARY-Modus angegeben werden" -#: commands/copy.c:1234 +#: commands/copy.c:1235 #, c-format msgid "COPY delimiter must be a single one-byte character" msgstr "DELIMITER für COPY muss ein einzelnes Ein-Byte-Zeichen sein" -#: commands/copy.c:1241 +#: commands/copy.c:1242 #, c-format msgid "COPY delimiter cannot be newline or carriage return" msgstr "COPY-Trennzeichen kann nicht Newline oder Carriage Return sein" -#: commands/copy.c:1247 +#: commands/copy.c:1248 #, c-format msgid "COPY null representation cannot use newline or carriage return" msgstr "COPY NULL-Darstellung kann nicht Newline oder Carriage Return enthalten" -#: commands/copy.c:1264 +#: commands/copy.c:1265 #, c-format msgid "COPY delimiter cannot be \"%s\"" msgstr "DELIMITER für COPY darf nicht »%s« sein" -#: commands/copy.c:1270 +#: commands/copy.c:1271 #, c-format msgid "COPY HEADER available only in CSV mode" msgstr "COPY HEADER ist nur im CSV-Modus verfügbar" -#: commands/copy.c:1276 +#: commands/copy.c:1277 #, c-format msgid "COPY quote available only in CSV mode" msgstr "Quote-Zeichen für COPY ist nur im CSV-Modus verfügbar" -#: commands/copy.c:1281 +#: commands/copy.c:1282 #, c-format msgid "COPY quote must be a single one-byte character" msgstr "Quote-Zeichen für COPY muss ein einzelnes Ein-Byte-Zeichen sein" -#: commands/copy.c:1286 +#: commands/copy.c:1287 #, c-format msgid "COPY delimiter and quote must be different" msgstr "DELIMITER und QUOTE für COPY müssen verschieden sein" -#: commands/copy.c:1292 +#: commands/copy.c:1293 #, c-format msgid "COPY escape available only in CSV mode" msgstr "Escape-Zeichen für COPY ist nur im CSV-Modus verfügbar" -#: commands/copy.c:1297 +#: commands/copy.c:1298 #, c-format msgid "COPY escape must be a single one-byte character" msgstr "Escape-Zeichen für COPY muss ein einzelnes Ein-Byte-Zeichen sein" -#: commands/copy.c:1303 +#: commands/copy.c:1304 #, c-format msgid "COPY force quote available only in CSV mode" msgstr "FORCE_QUOTE für COPY ist nur im CSV-Modus verfügbar" -#: commands/copy.c:1307 +#: commands/copy.c:1308 #, c-format msgid "COPY force quote only available using COPY TO" msgstr "FORCE_QUOTE ist nur bei COPY TO verfügbar" -#: commands/copy.c:1313 +#: commands/copy.c:1314 #, c-format msgid "COPY force not null available only in CSV mode" msgstr "FORCE_NOT_NULL für COPY ist nur im CSV-Modus verfügbar" -#: commands/copy.c:1317 +#: commands/copy.c:1318 #, c-format msgid "COPY force not null only available using COPY FROM" msgstr "FORCE_NOT_NULL ist nur bei COPY FROM verfügbar" -#: commands/copy.c:1323 +#: commands/copy.c:1324 #, c-format msgid "COPY force null available only in CSV mode" msgstr "FORCE_NULL für COPY ist nur im CSV-Modus verfügbar" -#: commands/copy.c:1328 +#: commands/copy.c:1329 #, c-format msgid "COPY force null only available using COPY FROM" msgstr "FORCE_NULL ist nur bei COPY FROM verfügbar" -#: commands/copy.c:1334 +#: commands/copy.c:1335 #, c-format msgid "COPY delimiter must not appear in the NULL specification" msgstr "Trennzeichen für COPY darf nicht in der NULL-Darstellung erscheinen" -#: commands/copy.c:1341 +#: commands/copy.c:1342 #, c-format msgid "CSV quote character must not appear in the NULL specification" msgstr "CSV-Quote-Zeichen darf nicht in der NULL-Darstellung erscheinen" -#: commands/copy.c:1402 +#: commands/copy.c:1403 #, c-format msgid "table \"%s\" does not have OIDs" msgstr "Tabelle »%s« hat keine OIDs" -#: commands/copy.c:1419 +#: commands/copy.c:1420 #, c-format msgid "COPY (query) WITH OIDS is not supported" msgstr "COPY (Anfrage) WITH OIDS wird nicht unterstützt" -#: commands/copy.c:1439 +#: commands/copy.c:1440 #, c-format msgid "DO INSTEAD NOTHING rules are not supported for COPY" msgstr "DO INSTEAD NOTHING-Regeln werden für COPY nicht unterstützt" -#: commands/copy.c:1453 +#: commands/copy.c:1454 #, c-format msgid "conditional DO INSTEAD rules are not supported for COPY" msgstr "Do INSTEAD-Regeln mit Bedingung werden für COPY nicht unterstützt" -#: commands/copy.c:1457 +#: commands/copy.c:1458 #, c-format msgid "DO ALSO rules are not supported for the COPY" msgstr "DO ALSO-Regeln werden für COPY nicht unterstützt" -#: commands/copy.c:1462 +#: commands/copy.c:1463 #, c-format msgid "multi-statement DO INSTEAD rules are not supported for COPY" msgstr "DO INSTEAD-Regeln mit mehreren Anweisungen werden für COPY nicht unterstützt" -#: commands/copy.c:1472 +#: commands/copy.c:1473 #, c-format msgid "COPY (SELECT INTO) is not supported" msgstr "COPY (SELECT INTO) wird nicht unterstützt" -#: commands/copy.c:1489 +#: commands/copy.c:1490 #, c-format msgid "COPY query must have a RETURNING clause" msgstr "COPY-Anfrage muss eine RETURNING-Klausel haben" -#: commands/copy.c:1517 +#: commands/copy.c:1518 #, c-format msgid "relation referenced by COPY statement has changed" msgstr "die von der COPY-Anweisung verwendete Relation hat sich geändert" -#: commands/copy.c:1575 +#: commands/copy.c:1576 #, c-format msgid "FORCE_QUOTE column \"%s\" not referenced by COPY" msgstr "FORCE_QUOTE-Spalte »%s« wird von COPY nicht verwendet" -#: commands/copy.c:1597 +#: commands/copy.c:1598 #, c-format msgid "FORCE_NOT_NULL column \"%s\" not referenced by COPY" msgstr "Spalte »%s« mit FORCE_NOT_NULL wird von COPY nicht verwendet" -#: commands/copy.c:1619 +#: commands/copy.c:1620 #, c-format msgid "FORCE_NULL column \"%s\" not referenced by COPY" msgstr "Spalte »%s« mit FORCE_NULL wird von COPY nicht verwendet" -#: commands/copy.c:1684 +#: commands/copy.c:1685 #, c-format msgid "could not close pipe to external command: %m" msgstr "konnte Pipe zu externem Programm nicht schließen: %m" -#: commands/copy.c:1688 +#: commands/copy.c:1689 #, c-format msgid "program \"%s\" failed" msgstr "Programm »%s« fehlgeschlagen" -#: commands/copy.c:1738 +#: commands/copy.c:1739 #, c-format msgid "cannot copy from view \"%s\"" msgstr "kann nicht aus Sicht »%s« kopieren" -#: commands/copy.c:1740 commands/copy.c:1746 commands/copy.c:1752 +#: commands/copy.c:1741 commands/copy.c:1747 commands/copy.c:1753 #, c-format msgid "Try the COPY (SELECT ...) TO variant." msgstr "Versuchen Sie die Variante COPY (SELECT ...) TO." -#: commands/copy.c:1744 +#: commands/copy.c:1745 #, c-format msgid "cannot copy from materialized view \"%s\"" msgstr "kann nicht aus materialisierter Sicht »%s« kopieren" -#: commands/copy.c:1750 +#: commands/copy.c:1751 #, c-format msgid "cannot copy from foreign table \"%s\"" msgstr "kann nicht aus Fremdtabelle »%s« kopieren" -#: commands/copy.c:1756 +#: commands/copy.c:1757 #, c-format msgid "cannot copy from sequence \"%s\"" msgstr "kann nicht aus Sequenz »%s« kopieren" -#: commands/copy.c:1761 +#: commands/copy.c:1762 #, c-format msgid "cannot copy from non-table relation \"%s\"" msgstr "kann nicht aus Relation »%s«, die keine Tabelle ist, kopieren" -#: commands/copy.c:1786 commands/copy.c:2822 +#: commands/copy.c:1787 commands/copy.c:2823 #, c-format msgid "could not execute command \"%s\": %m" msgstr "konnte Befehl »%s« nicht ausführen: %m" -#: commands/copy.c:1801 +#: commands/copy.c:1802 #, c-format msgid "relative path not allowed for COPY to file" msgstr "relativer Pfad bei COPY in Datei nicht erlaubt" -#: commands/copy.c:1809 +#: commands/copy.c:1810 #, c-format msgid "could not open file \"%s\" for writing: %m" msgstr "konnte Datei »%s« nicht zum Schreiben öffnen: %m" -#: commands/copy.c:1821 commands/copy.c:2845 +#: commands/copy.c:1822 commands/copy.c:2846 #, c-format msgid "\"%s\" is a directory" msgstr "»%s« ist ein Verzeichnis" -#: commands/copy.c:2144 +#: commands/copy.c:2145 #, c-format msgid "COPY %s, line %d, column %s" msgstr "COPY %s, Zeile %d, Spalte %s" -#: commands/copy.c:2148 commands/copy.c:2195 +#: commands/copy.c:2149 commands/copy.c:2196 #, c-format msgid "COPY %s, line %d" msgstr "COPY %s, Zeile %d" -#: commands/copy.c:2159 +#: commands/copy.c:2160 #, c-format msgid "COPY %s, line %d, column %s: \"%s\"" msgstr "COPY %s, Zeile %d, Spalte %s: »%s«" -#: commands/copy.c:2167 +#: commands/copy.c:2168 #, c-format msgid "COPY %s, line %d, column %s: null input" msgstr "COPY %s, Zeile %d, Spalte %s: NULL Eingabe" -#: commands/copy.c:2189 +#: commands/copy.c:2190 #, c-format msgid "COPY %s, line %d: \"%s\"" msgstr "COPY %s, Zeile %d: »%s«" -#: commands/copy.c:2273 +#: commands/copy.c:2274 #, c-format msgid "cannot copy to view \"%s\"" msgstr "kann nicht in Sicht »%s« kopieren" -#: commands/copy.c:2278 +#: commands/copy.c:2279 #, c-format msgid "cannot copy to materialized view \"%s\"" msgstr "kann nicht in materialisierte Sicht »%s« kopieren" -#: commands/copy.c:2283 +#: commands/copy.c:2284 #, c-format msgid "cannot copy to foreign table \"%s\"" msgstr "kann nicht in Fremdtabelle »%s« kopieren" -#: commands/copy.c:2288 +#: commands/copy.c:2289 #, c-format msgid "cannot copy to sequence \"%s\"" msgstr "kann nicht in Sequenz »%s« kopieren" -#: commands/copy.c:2293 +#: commands/copy.c:2294 #, c-format msgid "cannot copy to non-table relation \"%s\"" msgstr "kann nicht in Relation »%s« kopieren, die keine Tabelle ist" -#: commands/copy.c:2356 +#: commands/copy.c:2357 #, c-format msgid "cannot perform FREEZE because of prior transaction activity" msgstr "FREEZE kann nicht durchgeführt werden wegen vorheriger Aktivität in dieser Transaktion" -#: commands/copy.c:2362 +#: commands/copy.c:2363 #, c-format msgid "cannot perform FREEZE because the table was not created or truncated in the current subtransaction" msgstr "FREEZE kann nicht durchgeführt werden, weil die Tabelle nicht in der aktuellen Transaktion erzeugt oder geleert wurde" -#: commands/copy.c:2865 +#: commands/copy.c:2866 #, c-format msgid "COPY file signature not recognized" msgstr "COPY-Datei-Signatur nicht erkannt" -#: commands/copy.c:2870 +#: commands/copy.c:2871 #, c-format msgid "invalid COPY file header (missing flags)" msgstr "ungültiger COPY-Dateikopf (Flags fehlen)" -#: commands/copy.c:2876 +#: commands/copy.c:2877 #, c-format msgid "unrecognized critical flags in COPY file header" msgstr "unbekannte kritische Flags im COPY-Dateikopf" -#: commands/copy.c:2882 +#: commands/copy.c:2883 #, c-format msgid "invalid COPY file header (missing length)" msgstr "ungültiger COPY-Dateikopf (Länge fehlt)" -#: commands/copy.c:2889 +#: commands/copy.c:2890 #, c-format msgid "invalid COPY file header (wrong length)" msgstr "ungültiger COPY-Dateikopf (falsche Länge)" -#: commands/copy.c:3022 commands/copy.c:3729 commands/copy.c:3959 +#: commands/copy.c:3023 commands/copy.c:3730 commands/copy.c:3960 #, c-format msgid "extra data after last expected column" msgstr "zusätzliche Daten nach letzter erwarteter Spalte" -#: commands/copy.c:3032 +#: commands/copy.c:3033 #, c-format msgid "missing data for OID column" msgstr "fehlende Daten für OID-Spalte" -#: commands/copy.c:3038 +#: commands/copy.c:3039 #, c-format msgid "null OID in COPY data" msgstr "OID ist NULL in COPY-Daten" -#: commands/copy.c:3048 commands/copy.c:3171 +#: commands/copy.c:3049 commands/copy.c:3172 #, c-format msgid "invalid OID in COPY data" msgstr "ungültige OID in COPY-Daten" -#: commands/copy.c:3063 +#: commands/copy.c:3064 #, c-format msgid "missing data for column \"%s\"" msgstr "fehlende Daten für Spalte »%s«" -#: commands/copy.c:3146 +#: commands/copy.c:3147 #, c-format msgid "received copy data after EOF marker" msgstr "COPY-Daten nach EOF-Markierung empfangen" -#: commands/copy.c:3153 +#: commands/copy.c:3154 #, c-format msgid "row field count is %d, expected %d" msgstr "Feldanzahl in Zeile ist %d, erwartet wurden %d" -#: commands/copy.c:3493 commands/copy.c:3510 +#: commands/copy.c:3494 commands/copy.c:3511 #, c-format msgid "literal carriage return found in data" msgstr "Carriage-Return-Zeichen in Daten gefunden" -#: commands/copy.c:3494 commands/copy.c:3511 +#: commands/copy.c:3495 commands/copy.c:3512 #, c-format msgid "unquoted carriage return found in data" msgstr "ungequotetes Carriage-Return-Zeichen in Daten gefunden" -#: commands/copy.c:3496 commands/copy.c:3513 +#: commands/copy.c:3497 commands/copy.c:3514 #, c-format msgid "Use \"\\r\" to represent carriage return." msgstr "Verwenden Sie »\\r«, um ein Carriage-Return-Zeichen darzustellen." -#: commands/copy.c:3497 commands/copy.c:3514 +#: commands/copy.c:3498 commands/copy.c:3515 #, c-format msgid "Use quoted CSV field to represent carriage return." msgstr "Verwenden Sie ein gequotetes CSV-Feld, um ein Carriage-Return-Zeichen darzustellen." -#: commands/copy.c:3526 +#: commands/copy.c:3527 #, c-format msgid "literal newline found in data" msgstr "Newline-Zeichen in Daten gefunden" -#: commands/copy.c:3527 +#: commands/copy.c:3528 #, c-format msgid "unquoted newline found in data" msgstr "ungequotetes Newline-Zeichen in Daten gefunden" -#: commands/copy.c:3529 +#: commands/copy.c:3530 #, c-format msgid "Use \"\\n\" to represent newline." msgstr "Verwenden Sie »\\n«, um ein Newline-Zeichen darzustellen." -#: commands/copy.c:3530 +#: commands/copy.c:3531 #, c-format msgid "Use quoted CSV field to represent newline." msgstr "Verwenden Sie ein gequotetes CSV-Feld, um ein Newline-Zeichen darzustellen." -#: commands/copy.c:3576 commands/copy.c:3612 +#: commands/copy.c:3577 commands/copy.c:3613 #, c-format msgid "end-of-copy marker does not match previous newline style" msgstr "COPY-Ende-Markierung stimmt nicht mit vorherigem Newline-Stil überein" -#: commands/copy.c:3585 commands/copy.c:3601 +#: commands/copy.c:3586 commands/copy.c:3602 #, c-format msgid "end-of-copy marker corrupt" msgstr "COPY-Ende-Markierung verfälscht" -#: commands/copy.c:4043 +#: commands/copy.c:4044 #, c-format msgid "unterminated CSV quoted field" msgstr "Quotes in CSV-Feld nicht abgeschlossen" -#: commands/copy.c:4120 commands/copy.c:4139 +#: commands/copy.c:4121 commands/copy.c:4140 #, c-format msgid "unexpected EOF in COPY data" msgstr "unerwartetes EOF in COPY-Daten" -#: commands/copy.c:4129 +#: commands/copy.c:4130 #, c-format msgid "invalid field size" msgstr "ungültige Feldgröße" -#: commands/copy.c:4152 +#: commands/copy.c:4153 #, c-format msgid "incorrect binary data format" msgstr "falsches Binärdatenformat" -#: commands/copy.c:4463 commands/indexcmds.c:1053 commands/tablecmds.c:1464 +#: commands/copy.c:4464 commands/indexcmds.c:1054 commands/tablecmds.c:1464 #: commands/tablecmds.c:2291 parser/parse_relation.c:3177 #: parser/parse_relation.c:3197 utils/adt/tsvector_op.c:2559 #, c-format msgid "column \"%s\" does not exist" msgstr "Spalte »%s« existiert nicht" -#: commands/copy.c:4470 commands/tablecmds.c:1490 commands/trigger.c:651 +#: commands/copy.c:4471 commands/tablecmds.c:1490 commands/trigger.c:651 #: parser/parse_target.c:967 parser/parse_target.c:978 #, c-format msgid "column \"%s\" specified more than once" @@ -6095,7 +5918,7 @@ msgid "invalid argument for %s: \"%s\"" msgstr "ungültiges Argument für %s: »%s«" #: commands/dropcmds.c:112 commands/functioncmds.c:1203 -#: utils/adt/ruleutils.c:2080 +#: utils/adt/ruleutils.c:2083 #, c-format msgid "\"%s\" is an aggregate function" msgstr "»%s« ist eine Aggregatfunktion" @@ -6107,7 +5930,7 @@ msgstr "Verwenden Sie DROP AGGREGATE, um Aggregatfunktionen zu löschen." #: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2378 #: commands/tablecmds.c:2529 commands/tablecmds.c:2571 -#: commands/tablecmds.c:11524 tcop/utility.c:1119 +#: commands/tablecmds.c:11538 tcop/utility.c:1119 #, c-format msgid "relation \"%s\" does not exist, skipping" msgstr "Relation »%s« existiert nicht, wird übersprungen" @@ -6319,7 +6142,7 @@ msgstr "EXPLAIN-Option BUFFERS erfordert ANALYZE" msgid "EXPLAIN option TIMING requires ANALYZE" msgstr "EXPLAIN-Option TIMING erfordert ANALYZE" -#: commands/extension.c:155 commands/extension.c:2719 +#: commands/extension.c:155 commands/extension.c:2722 #, c-format msgid "extension \"%s\" does not exist" msgstr "Erweiterung »%s« existiert nicht" @@ -6406,142 +6229,142 @@ msgstr "unbekannter Parameter »%s« in Datei »%s«" msgid "parameter \"schema\" cannot be specified when \"relocatable\" is true" msgstr "Parameter »schema« kann nicht angegeben werden, wenn »relocatable« an ist" -#: commands/extension.c:722 +#: commands/extension.c:725 #, c-format msgid "transaction control statements are not allowed within an extension script" msgstr "Transaktionskontrollanweisungen sind nicht in einem Erweiterungsskript erlaubt" -#: commands/extension.c:790 +#: commands/extension.c:793 #, c-format msgid "permission denied to create extension \"%s\"" msgstr "keine Berechtigung, um Erweiterung »%s« zu erzeugen" -#: commands/extension.c:792 +#: commands/extension.c:795 #, c-format msgid "Must be superuser to create this extension." msgstr "Nur Superuser können diese Erweiterung anlegen." -#: commands/extension.c:796 +#: commands/extension.c:799 #, c-format msgid "permission denied to update extension \"%s\"" msgstr "keine Berechtigung, um Erweiterung »%s« zu aktualisieren" -#: commands/extension.c:798 +#: commands/extension.c:801 #, c-format msgid "Must be superuser to update this extension." msgstr "Nur Superuser können diese Erweiterung aktualisieren." -#: commands/extension.c:1080 +#: commands/extension.c:1083 #, c-format msgid "extension \"%s\" has no update path from version \"%s\" to version \"%s\"" msgstr "Erweiterung »%s« hat keinen Aktualisierungspfad von Version »%s« auf Version »%s«" -#: commands/extension.c:1262 commands/extension.c:2779 +#: commands/extension.c:1265 commands/extension.c:2782 #, c-format msgid "version to install must be specified" msgstr "die zu installierende Version muss angegeben werden" -#: commands/extension.c:1279 +#: commands/extension.c:1282 #, c-format msgid "FROM version must be different from installation target version \"%s\"" msgstr "FROM-Version muss verschieden von der zu installierenden Version »%s« sein" -#: commands/extension.c:1344 +#: commands/extension.c:1347 #, c-format msgid "extension \"%s\" must be installed in schema \"%s\"" msgstr "Erweiterung »%s« muss in Schema »%s« installiert werden" -#: commands/extension.c:1436 +#: commands/extension.c:1439 #, c-format msgid "cyclic dependency detected between extensions \"%s\" and \"%s\"" msgstr "zyklische Abhängigkeit zwischen Erweiterungen »%s« und »%s« entdeckt" -#: commands/extension.c:1441 +#: commands/extension.c:1444 #, c-format msgid "installing required extension \"%s\"" msgstr "installiere benötigte Erweiterung »%s«" -#: commands/extension.c:1469 commands/extension.c:2924 +#: commands/extension.c:1472 commands/extension.c:2927 #, c-format msgid "required extension \"%s\" is not installed" msgstr "benötigte Erweiterung »%s« ist nicht installiert" -#: commands/extension.c:1471 +#: commands/extension.c:1474 #, c-format msgid "Use CREATE EXTENSION ... CASCADE to install required extensions too." msgstr "Verwenden Sie CREATE EXTENSION ... CASCADE, um die benötigten Erweiterungen ebenfalls zu installieren." -#: commands/extension.c:1535 +#: commands/extension.c:1538 #, c-format msgid "extension \"%s\" already exists, skipping" msgstr "Erweiterung »%s« existiert bereits, wird übersprungen" -#: commands/extension.c:1542 +#: commands/extension.c:1545 #, c-format msgid "extension \"%s\" already exists" msgstr "Erweiterung »%s« existiert bereits" -#: commands/extension.c:1553 +#: commands/extension.c:1556 #, c-format msgid "nested CREATE EXTENSION is not supported" msgstr "geschachteltes CREATE EXTENSION wird nicht unterstützt" -#: commands/extension.c:1681 +#: commands/extension.c:1684 #, c-format msgid "cannot drop extension \"%s\" because it is being modified" msgstr "Erweiterung »%s« kann nicht gelöscht werden, weil sie gerade geändert wird" -#: commands/extension.c:2152 +#: commands/extension.c:2155 #, c-format msgid "pg_extension_config_dump() can only be called from an SQL script executed by CREATE EXTENSION" msgstr "pg_extension_config_dump() kann nur von einem SQL-Skript aufgerufen werden, das von CREATE EXTENSION ausgeführt wird" -#: commands/extension.c:2164 +#: commands/extension.c:2167 #, c-format msgid "OID %u does not refer to a table" msgstr "OID %u bezieht sich nicht auf eine Tabelle" -#: commands/extension.c:2169 +#: commands/extension.c:2172 #, c-format msgid "table \"%s\" is not a member of the extension being created" msgstr "Tabelle »%s« ist kein Mitglied der anzulegenden Erweiterung" -#: commands/extension.c:2534 +#: commands/extension.c:2537 #, c-format msgid "cannot move extension \"%s\" into schema \"%s\" because the extension contains the schema" msgstr "kann Erweiterung »%s« nicht in Schema »%s« verschieben, weil die Erweiterung das Schema enthält" -#: commands/extension.c:2574 commands/extension.c:2637 +#: commands/extension.c:2577 commands/extension.c:2640 #, c-format msgid "extension \"%s\" does not support SET SCHEMA" msgstr "Erweiterung »%s« unterstützt SET SCHEMA nicht" -#: commands/extension.c:2639 +#: commands/extension.c:2642 #, c-format msgid "%s is not in the extension's schema \"%s\"" msgstr "%s ist nicht im Schema der Erweiterung (»%s«)" -#: commands/extension.c:2699 +#: commands/extension.c:2702 #, c-format msgid "nested ALTER EXTENSION is not supported" msgstr "geschachteltes ALTER EXTENSION wird nicht unterstützt" -#: commands/extension.c:2790 +#: commands/extension.c:2793 #, c-format msgid "version \"%s\" of extension \"%s\" is already installed" msgstr "Version »%s« von Erweiterung »%s« ist bereits installiert" -#: commands/extension.c:3041 +#: commands/extension.c:3044 #, c-format msgid "cannot add schema \"%s\" to extension \"%s\" because the schema contains the extension" msgstr "kann Schema »%s« nicht zu Erweiterung »%s« hinzufügen, weil das Schema die Erweiterung enthält" -#: commands/extension.c:3069 +#: commands/extension.c:3072 #, c-format msgid "%s is not a member of extension \"%s\"" msgstr "%s ist kein Mitglied der Erweiterung »%s«" -#: commands/extension.c:3135 +#: commands/extension.c:3138 #, c-format msgid "file \"%s\" is too large" msgstr "Datei »%s« ist zu groß" @@ -6756,13 +6579,13 @@ msgstr "unbekanntes Funktionsattribut »%s« ignoriert" msgid "only one AS item needed for language \"%s\"" msgstr "nur ein AS-Element benötigt für Sprache »%s«" -#: commands/functioncmds.c:929 commands/functioncmds.c:2119 +#: commands/functioncmds.c:929 commands/functioncmds.c:2139 #: commands/proclang.c:563 #, c-format msgid "language \"%s\" does not exist" msgstr "Sprache »%s« existiert nicht" -#: commands/functioncmds.c:931 commands/functioncmds.c:2121 +#: commands/functioncmds.c:931 commands/functioncmds.c:2141 #, c-format msgid "Use CREATE LANGUAGE to load the language into the database." msgstr "Sie müssen CREATE LANGUAGE verwenden, um die Sprache in die Datenbank zu laden." @@ -6787,187 +6610,187 @@ msgstr "Ergebnistyp der Funktion muss angegeben werden" msgid "ROWS is not applicable when function does not return a set" msgstr "ROWS ist nicht anwendbar, wenn die Funktion keine Ergebnismenge zurückgibt" -#: commands/functioncmds.c:1412 +#: commands/functioncmds.c:1432 #, c-format msgid "source data type %s is a pseudo-type" msgstr "Quelldatentyp %s ist ein Pseudotyp" -#: commands/functioncmds.c:1418 +#: commands/functioncmds.c:1438 #, c-format msgid "target data type %s is a pseudo-type" msgstr "Zieldatentyp %s ist ein Pseudotyp" -#: commands/functioncmds.c:1442 +#: commands/functioncmds.c:1462 #, c-format msgid "cast will be ignored because the source data type is a domain" msgstr "Typumwandlung wird ignoriert werden, weil der Quelldatentyp eine Domäne ist" -#: commands/functioncmds.c:1447 +#: commands/functioncmds.c:1467 #, c-format msgid "cast will be ignored because the target data type is a domain" msgstr "Typumwandlung wird ignoriert werden, weil der Zieldatentyp eine Domäne ist" -#: commands/functioncmds.c:1474 +#: commands/functioncmds.c:1494 #, c-format msgid "cast function must take one to three arguments" msgstr "Typumwandlungsfunktion muss ein bis drei Argumente haben" -#: commands/functioncmds.c:1478 +#: commands/functioncmds.c:1498 #, c-format msgid "argument of cast function must match or be binary-coercible from source data type" msgstr "Argument der Typumwandlungsfunktion muss mit Quelldatentyp übereinstimmen oder in ihn binär-umwandelbar sein" -#: commands/functioncmds.c:1482 +#: commands/functioncmds.c:1502 #, c-format msgid "second argument of cast function must be type integer" msgstr "zweites Argument der Typumwandlungsfunktion muss Typ integer haben" -#: commands/functioncmds.c:1486 +#: commands/functioncmds.c:1506 #, c-format msgid "third argument of cast function must be type boolean" msgstr "drittes Argument der Typumwandlungsfunktion muss Typ boolean haben" -#: commands/functioncmds.c:1490 +#: commands/functioncmds.c:1510 #, c-format msgid "return data type of cast function must match or be binary-coercible to target data type" msgstr "Rückgabetyp der Typumwandlungsfunktion muss mit Zieldatentyp übereinstimmen oder in ihn binär-umwandelbar sein" -#: commands/functioncmds.c:1501 +#: commands/functioncmds.c:1521 #, c-format msgid "cast function must not be volatile" msgstr "Typumwandlungsfunktion darf nicht VOLATILE sein" -#: commands/functioncmds.c:1506 +#: commands/functioncmds.c:1526 #, c-format msgid "cast function must not be an aggregate function" msgstr "Typumwandlungsfunktion darf keine Aggregatfunktion sein" -#: commands/functioncmds.c:1510 +#: commands/functioncmds.c:1530 #, c-format msgid "cast function must not be a window function" msgstr "Typumwandlungsfunktion darf keine Fensterfunktion sein" -#: commands/functioncmds.c:1514 +#: commands/functioncmds.c:1534 #, c-format msgid "cast function must not return a set" msgstr "Typumwandlungsfunktion darf keine Ergebnismenge zurückgeben" -#: commands/functioncmds.c:1540 +#: commands/functioncmds.c:1560 #, c-format msgid "must be superuser to create a cast WITHOUT FUNCTION" msgstr "nur Superuser können Typumwandlungen mit WITHOUT FUNCTION erzeugen" -#: commands/functioncmds.c:1555 +#: commands/functioncmds.c:1575 #, c-format msgid "source and target data types are not physically compatible" msgstr "Quelldatentyp und Zieldatentyp sind nicht physikalisch kompatibel" -#: commands/functioncmds.c:1570 +#: commands/functioncmds.c:1590 #, c-format msgid "composite data types are not binary-compatible" msgstr "zusammengesetzte Datentypen sind nicht binärkompatibel" -#: commands/functioncmds.c:1576 +#: commands/functioncmds.c:1596 #, c-format msgid "enum data types are not binary-compatible" msgstr "Enum-Datentypen sind nicht binärkompatibel" -#: commands/functioncmds.c:1582 +#: commands/functioncmds.c:1602 #, c-format msgid "array data types are not binary-compatible" msgstr "Array-Datentypen sind nicht binärkompatibel" -#: commands/functioncmds.c:1599 +#: commands/functioncmds.c:1619 #, c-format msgid "domain data types must not be marked binary-compatible" msgstr "Domänendatentypen dürfen nicht als binärkompatibel markiert werden" -#: commands/functioncmds.c:1609 +#: commands/functioncmds.c:1629 #, c-format msgid "source data type and target data type are the same" msgstr "Quelldatentyp und Zieldatentyp sind der selbe" -#: commands/functioncmds.c:1642 +#: commands/functioncmds.c:1662 #, c-format msgid "cast from type %s to type %s already exists" msgstr "Typumwandlung von Typ %s in Typ %s existiert bereits" -#: commands/functioncmds.c:1717 +#: commands/functioncmds.c:1737 #, c-format msgid "cast from type %s to type %s does not exist" msgstr "Typumwandlung von Typ %s in Typ %s existiert nicht" -#: commands/functioncmds.c:1756 +#: commands/functioncmds.c:1776 #, c-format msgid "transform function must not be volatile" msgstr "Transformationsfunktion darf nicht VOLATILE sein" -#: commands/functioncmds.c:1760 +#: commands/functioncmds.c:1780 #, c-format msgid "transform function must not be an aggregate function" msgstr "Transformationsfunktion darf keine Aggregatfunktion sein" -#: commands/functioncmds.c:1764 +#: commands/functioncmds.c:1784 #, c-format msgid "transform function must not be a window function" msgstr "Transformationsfunktion darf keine Fensterfunktion sein" -#: commands/functioncmds.c:1768 +#: commands/functioncmds.c:1788 #, c-format msgid "transform function must not return a set" msgstr "Transformationsfunktion darf keine Ergebnismenge zurückgeben" -#: commands/functioncmds.c:1772 +#: commands/functioncmds.c:1792 #, c-format msgid "transform function must take one argument" msgstr "Transformationsfunktion muss ein Argument haben" -#: commands/functioncmds.c:1776 +#: commands/functioncmds.c:1796 #, c-format msgid "first argument of transform function must be type \"internal\"" msgstr "erstes Argument der Transformationsfunktion muss Typ »internal« haben" -#: commands/functioncmds.c:1813 +#: commands/functioncmds.c:1833 #, c-format msgid "data type %s is a pseudo-type" msgstr "Datentyp %s ist ein Pseudotyp" -#: commands/functioncmds.c:1819 +#: commands/functioncmds.c:1839 #, c-format msgid "data type %s is a domain" msgstr "Datentyp %s ist eine Domäne" -#: commands/functioncmds.c:1859 +#: commands/functioncmds.c:1879 #, c-format msgid "return data type of FROM SQL function must be \"internal\"" msgstr "Rückgabetyp der FROM-SQL-Funktion muss »internal« sein" -#: commands/functioncmds.c:1884 +#: commands/functioncmds.c:1904 #, c-format msgid "return data type of TO SQL function must be the transform data type" msgstr "Rückgabetyp der TO-SQL-Funktion muss der zu transformierende Datentyp sein" -#: commands/functioncmds.c:1911 +#: commands/functioncmds.c:1931 #, c-format msgid "transform for type %s language \"%s\" already exists" msgstr "Transformation für Typ %s Sprache »%s« existiert bereits" -#: commands/functioncmds.c:2002 +#: commands/functioncmds.c:2022 #, c-format msgid "transform for type %s language \"%s\" does not exist" msgstr "Transformation für Typ %s Sprache »%s« existiert nicht" -#: commands/functioncmds.c:2053 +#: commands/functioncmds.c:2073 #, c-format msgid "function %s already exists in schema \"%s\"" msgstr "Funktion %s existiert bereits in Schema »%s«" -#: commands/functioncmds.c:2106 +#: commands/functioncmds.c:2126 #, c-format msgid "no inline code specified" msgstr "kein Inline-Code angegeben" -#: commands/functioncmds.c:2151 +#: commands/functioncmds.c:2171 #, c-format msgid "language \"%s\" does not support inline code execution" msgstr "Sprache »%s« unterstützt das Ausführen von Inline-Code nicht" @@ -6992,139 +6815,139 @@ msgstr "kann keinen Index für Fremdtabelle »%s« erzeugen" msgid "cannot create indexes on temporary tables of other sessions" msgstr "kann keine Indexe für temporäre Tabellen anderer Sitzungen erzeugen" -#: commands/indexcmds.c:454 commands/tablecmds.c:546 commands/tablecmds.c:9694 +#: commands/indexcmds.c:455 commands/tablecmds.c:546 commands/tablecmds.c:9708 #, c-format msgid "only shared relations can be placed in pg_global tablespace" msgstr "nur geteilte Relationen können in den Tablespace »pg_global« gelegt werden" -#: commands/indexcmds.c:487 +#: commands/indexcmds.c:488 #, c-format msgid "substituting access method \"gist\" for obsolete method \"rtree\"" msgstr "ersetze Zugriffsmethode »gist« für obsolete Methode »rtree«" -#: commands/indexcmds.c:505 +#: commands/indexcmds.c:506 #, c-format msgid "hash indexes are not WAL-logged and their use is discouraged" msgstr "Hash-Indexe werden nicht im WAL geloggt und von ihrer Verwendung wird abgeraten." -#: commands/indexcmds.c:510 +#: commands/indexcmds.c:511 #, c-format msgid "access method \"%s\" does not support unique indexes" msgstr "Zugriffsmethode »%s« unterstützt keine Unique Indexe" -#: commands/indexcmds.c:515 +#: commands/indexcmds.c:516 #, c-format msgid "access method \"%s\" does not support multicolumn indexes" msgstr "Zugriffsmethode »%s« unterstützt keine mehrspaltigen Indexe" -#: commands/indexcmds.c:520 +#: commands/indexcmds.c:521 #, c-format msgid "access method \"%s\" does not support exclusion constraints" msgstr "Zugriffsmethode »%s« unterstützt keine Exclusion-Constraints" -#: commands/indexcmds.c:590 commands/indexcmds.c:610 +#: commands/indexcmds.c:591 commands/indexcmds.c:611 #, c-format msgid "index creation on system columns is not supported" msgstr "Indexerzeugung für Systemspalten wird nicht unterstützt" -#: commands/indexcmds.c:635 +#: commands/indexcmds.c:636 #, c-format msgid "%s %s will create implicit index \"%s\" for table \"%s\"" msgstr "%s %s erstellt implizit einen Index »%s« für Tabelle »%s«" -#: commands/indexcmds.c:982 +#: commands/indexcmds.c:983 #, c-format msgid "functions in index predicate must be marked IMMUTABLE" msgstr "Funktionen im Indexprädikat müssen als IMMUTABLE markiert sein" -#: commands/indexcmds.c:1048 parser/parse_utilcmd.c:1881 +#: commands/indexcmds.c:1049 parser/parse_utilcmd.c:1882 #, c-format msgid "column \"%s\" named in key does not exist" msgstr "Spalte »%s«, die im Schlüssel verwendet wird, existiert nicht" -#: commands/indexcmds.c:1108 +#: commands/indexcmds.c:1109 #, c-format msgid "functions in index expression must be marked IMMUTABLE" msgstr "Funktionen im Indexausdruck müssen als IMMUTABLE markiert sein" -#: commands/indexcmds.c:1131 +#: commands/indexcmds.c:1132 #, c-format msgid "could not determine which collation to use for index expression" msgstr "konnte die für den Indexausdruck zu verwendende Sortierfolge nicht bestimmen" -#: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2608 -#: parser/parse_type.c:550 parser/parse_utilcmd.c:2807 utils/adt/misc.c:666 +#: commands/indexcmds.c:1140 commands/typecmds.c:827 parser/parse_expr.c:2608 +#: parser/parse_type.c:550 parser/parse_utilcmd.c:2808 utils/adt/misc.c:666 #, c-format msgid "collations are not supported by type %s" msgstr "Sortierfolgen werden von Typ %s nicht unterstützt" -#: commands/indexcmds.c:1177 +#: commands/indexcmds.c:1178 #, c-format msgid "operator %s is not commutative" msgstr "Operator %s ist nicht kommutativ" -#: commands/indexcmds.c:1179 +#: commands/indexcmds.c:1180 #, c-format msgid "Only commutative operators can be used in exclusion constraints." msgstr "In Exclusion-Constraints können nur kommutative Operatoren verwendet werden." -#: commands/indexcmds.c:1205 +#: commands/indexcmds.c:1206 #, c-format msgid "operator %s is not a member of operator family \"%s\"" msgstr "Operator %s ist kein Mitglied der Operatorfamilie »%s«" -#: commands/indexcmds.c:1208 +#: commands/indexcmds.c:1209 #, c-format msgid "The exclusion operator must be related to the index operator class for the constraint." msgstr "Der Exklusionsoperator muss in Beziehung zur Indexoperatorklasse des Constraints stehen." -#: commands/indexcmds.c:1243 +#: commands/indexcmds.c:1244 #, c-format msgid "access method \"%s\" does not support ASC/DESC options" msgstr "Zugriffsmethode »%s« unterstützt die Optionen ASC/DESC nicht" -#: commands/indexcmds.c:1248 +#: commands/indexcmds.c:1249 #, c-format msgid "access method \"%s\" does not support NULLS FIRST/LAST options" msgstr "Zugriffsmethode »%s« unterstützt die Optionen NULLS FIRST/LAST nicht" -#: commands/indexcmds.c:1304 commands/typecmds.c:1935 +#: commands/indexcmds.c:1305 commands/typecmds.c:1935 #, c-format msgid "data type %s has no default operator class for access method \"%s\"" msgstr "Datentyp %s hat keine Standardoperatorklasse für Zugriffsmethode »%s«" -#: commands/indexcmds.c:1306 +#: commands/indexcmds.c:1307 #, c-format msgid "You must specify an operator class for the index or define a default operator class for the data type." msgstr "Sie müssen für den Index eine Operatorklasse angeben oder eine Standardoperatorklasse für den Datentyp definieren." -#: commands/indexcmds.c:1335 commands/indexcmds.c:1343 +#: commands/indexcmds.c:1336 commands/indexcmds.c:1344 #: commands/opclasscmds.c:205 #, c-format msgid "operator class \"%s\" does not exist for access method \"%s\"" msgstr "Operatorklasse »%s« existiert nicht für Zugriffsmethode »%s«" -#: commands/indexcmds.c:1356 commands/typecmds.c:1923 +#: commands/indexcmds.c:1357 commands/typecmds.c:1923 #, c-format msgid "operator class \"%s\" does not accept data type %s" msgstr "Operatorklasse »%s« akzeptiert Datentyp %s nicht" -#: commands/indexcmds.c:1446 +#: commands/indexcmds.c:1447 #, c-format msgid "there are multiple default operator classes for data type %s" msgstr "es gibt mehrere Standardoperatorklassen für Datentyp %s" -#: commands/indexcmds.c:1837 +#: commands/indexcmds.c:1838 #, c-format msgid "table \"%s\" has no indexes" msgstr "Tabelle »%s« hat keine Indexe" -#: commands/indexcmds.c:1892 +#: commands/indexcmds.c:1893 #, c-format msgid "can only reindex the currently open database" msgstr "aktuell geöffnete Datenbank kann nicht reindiziert werden" -#: commands/indexcmds.c:1992 +#: commands/indexcmds.c:1993 #, c-format msgid "table \"%s.%s\" was reindexed" msgstr "Tabelle »%s.%s« wurde neu indiziert" @@ -7364,8 +7187,8 @@ msgstr "Operator-Attribut »%s« kann nicht geändert werden" #: commands/policy.c:87 commands/policy.c:388 commands/policy.c:477 #: commands/tablecmds.c:971 commands/tablecmds.c:1313 #: commands/tablecmds.c:2185 commands/tablecmds.c:4329 -#: commands/tablecmds.c:6280 commands/tablecmds.c:12080 -#: commands/tablecmds.c:12115 commands/trigger.c:241 commands/trigger.c:1125 +#: commands/tablecmds.c:6293 commands/tablecmds.c:12094 +#: commands/tablecmds.c:12129 commands/trigger.c:241 commands/trigger.c:1125 #: commands/trigger.c:1233 rewrite/rewriteDefine.c:273 #: rewrite/rewriteDefine.c:917 #, c-format @@ -7419,7 +7242,7 @@ msgid "invalid cursor name: must not be empty" msgstr "ungültiger Cursorname: darf nicht leer sein" #: commands/portalcmds.c:168 commands/portalcmds.c:222 -#: executor/execCurrent.c:67 utils/adt/xml.c:2389 utils/adt/xml.c:2556 +#: executor/execCurrent.c:67 utils/adt/xml.c:2399 utils/adt/xml.c:2569 #, c-format msgid "cursor \"%s\" does not exist" msgstr "Cursor »%s« existiert nicht" @@ -7429,7 +7252,7 @@ msgstr "Cursor »%s« existiert nicht" msgid "invalid statement name: must not be empty" msgstr "ungültiger Anweisungsname: darf nicht leer sein" -#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1343 +#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1335 #, c-format msgid "could not determine data type of parameter $%d" msgstr "konnte Datentyp von Parameter $%d nicht ermitteln" @@ -7675,7 +7498,7 @@ msgstr "materialisierte Sicht »%s« existiert nicht, wird übersprungen" msgid "Use DROP MATERIALIZED VIEW to remove a materialized view." msgstr "Verwenden Sie DROP MATERIALIZED VIEW, um eine materialisierte Sicht zu löschen." -#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1630 +#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1631 #, c-format msgid "index \"%s\" does not exist" msgstr "Index »%s« existiert nicht" @@ -7698,8 +7521,8 @@ msgstr "»%s« ist kein Typ" msgid "Use DROP TYPE to remove a type." msgstr "Verwenden Sie DROP TYPE, um einen Typen zu löschen." -#: commands/tablecmds.c:252 commands/tablecmds.c:8583 -#: commands/tablecmds.c:11335 +#: commands/tablecmds.c:252 commands/tablecmds.c:8597 +#: commands/tablecmds.c:11349 #, c-format msgid "foreign table \"%s\" does not exist" msgstr "Fremdtabelle »%s« existiert nicht" @@ -7743,22 +7566,22 @@ msgstr "Truncate-Vorgang leert ebenfalls Tabelle »%s«" msgid "cannot truncate temporary tables of other sessions" msgstr "kann temporäre Tabellen anderer Sitzungen nicht leeren" -#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1844 +#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1845 #, c-format msgid "inherited relation \"%s\" is not a table or foreign table" msgstr "geerbte Relation »%s« ist keine Tabelle oder Fremdtabelle" -#: commands/tablecmds.c:1536 commands/tablecmds.c:10150 +#: commands/tablecmds.c:1536 commands/tablecmds.c:10164 #, c-format msgid "cannot inherit from temporary relation \"%s\"" msgstr "von temporärer Relation »%s« kann nicht geerbt werden" -#: commands/tablecmds.c:1544 commands/tablecmds.c:10158 +#: commands/tablecmds.c:1544 commands/tablecmds.c:10172 #, c-format msgid "cannot inherit from temporary relation of another session" msgstr "von temporärer Relation einer anderen Sitzung kann nicht geerbt werden" -#: commands/tablecmds.c:1560 commands/tablecmds.c:10192 +#: commands/tablecmds.c:1560 commands/tablecmds.c:10206 #, c-format msgid "relation \"%s\" would be inherited from more than once" msgstr "von der Relation »%s« würde mehrmals geerbt werden" @@ -7788,7 +7611,7 @@ msgid "inherited column \"%s\" has a collation conflict" msgstr "geerbte Spalte »%s« hat Sortierfolgenkonflikt" #: commands/tablecmds.c:1629 commands/tablecmds.c:1851 -#: commands/tablecmds.c:4767 +#: commands/tablecmds.c:4780 #, c-format msgid "\"%s\" versus \"%s\"" msgstr "»%s« gegen »%s«" @@ -7798,14 +7621,14 @@ msgstr "»%s« gegen »%s«" msgid "inherited column \"%s\" has a storage parameter conflict" msgstr "geerbte Spalte »%s« hat einen Konflikt bei einem Storage-Parameter" -#: commands/tablecmds.c:1752 commands/tablecmds.c:8088 -#: parser/parse_utilcmd.c:923 parser/parse_utilcmd.c:1274 -#: parser/parse_utilcmd.c:1350 +#: commands/tablecmds.c:1752 commands/tablecmds.c:8102 +#: parser/parse_utilcmd.c:924 parser/parse_utilcmd.c:1275 +#: parser/parse_utilcmd.c:1351 #, c-format msgid "cannot convert whole-row table reference" msgstr "kann Verweis auf ganze Zeile der Tabelle nicht umwandeln" -#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:924 +#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:925 #, c-format msgid "Constraint \"%s\" contains a whole-row reference to table \"%s\"." msgstr "Constraint »%s« enthält einen Verweis auf die ganze Zeile der Tabelle »%s«." @@ -7932,7 +7755,7 @@ msgstr "überprüfe Tabelle »%s«" msgid "column \"%s\" contains null values" msgstr "Spalte »%s« enthält NULL-Werte" -#: commands/tablecmds.c:4202 commands/tablecmds.c:7385 +#: commands/tablecmds.c:4202 commands/tablecmds.c:7399 #, c-format msgid "check constraint \"%s\" is violated by some row" msgstr "Check-Constraint »%s« wird von irgendeiner Zeile verletzt" @@ -7973,7 +7796,7 @@ msgstr "»%s« ist keine Tabelle oder Fremdtabelle" msgid "\"%s\" is not a table, composite type, or foreign table" msgstr "»%s« ist weder Tabelle, Sicht, zusammengesetzter Typ noch Fremdtabelle" -#: commands/tablecmds.c:4374 commands/tablecmds.c:5426 +#: commands/tablecmds.c:4374 commands/tablecmds.c:5439 #, c-format msgid "\"%s\" is not a table, materialized view, index, or foreign table" msgstr "»%s« ist weder Tabelle, materialisierte Sicht, Index noch Fremdtabelle" @@ -7983,565 +7806,565 @@ msgstr "»%s« ist weder Tabelle, materialisierte Sicht, Index noch Fremdtabelle msgid "\"%s\" is of the wrong type" msgstr "»%s« hat den falschen Typ" -#: commands/tablecmds.c:4536 commands/tablecmds.c:4543 +#: commands/tablecmds.c:4557 commands/tablecmds.c:4564 #, c-format msgid "cannot alter type \"%s\" because column \"%s.%s\" uses it" msgstr "kann Typ »%s« nicht ändern, weil Spalte »%s.%s« ihn verwendet" -#: commands/tablecmds.c:4550 +#: commands/tablecmds.c:4571 #, c-format msgid "cannot alter foreign table \"%s\" because column \"%s.%s\" uses its row type" msgstr "kann Fremdtabelle »%s« nicht ändern, weil Spalte »%s.%s« ihren Zeilentyp verwendet" -#: commands/tablecmds.c:4557 +#: commands/tablecmds.c:4578 #, c-format msgid "cannot alter table \"%s\" because column \"%s.%s\" uses its row type" msgstr "kann Tabelle »%s« nicht ändern, weil Spalte »%s.%s« ihren Zeilentyp verwendet" -#: commands/tablecmds.c:4619 +#: commands/tablecmds.c:4632 #, c-format msgid "cannot alter type \"%s\" because it is the type of a typed table" msgstr "kann Typ »%s« nicht ändern, weil er der Typ einer getypten Tabelle ist" -#: commands/tablecmds.c:4621 +#: commands/tablecmds.c:4634 #, c-format msgid "Use ALTER ... CASCADE to alter the typed tables too." msgstr "Verwenden Sie ALTER ... CASCADE, um die getypten Tabellen ebenfalls zu ändern." -#: commands/tablecmds.c:4665 +#: commands/tablecmds.c:4678 #, c-format msgid "type %s is not a composite type" msgstr "Typ %s ist kein zusammengesetzter Typ" -#: commands/tablecmds.c:4691 +#: commands/tablecmds.c:4704 #, c-format msgid "cannot add column to typed table" msgstr "zu einer getypten Tabelle kann keine Spalte hinzugefügt werden" -#: commands/tablecmds.c:4759 commands/tablecmds.c:10351 +#: commands/tablecmds.c:4772 commands/tablecmds.c:10365 #, c-format msgid "child table \"%s\" has different type for column \"%s\"" msgstr "abgeleitete Tabelle »%s« hat unterschiedlichen Typ für Spalte »%s«" -#: commands/tablecmds.c:4765 commands/tablecmds.c:10358 +#: commands/tablecmds.c:4778 commands/tablecmds.c:10372 #, c-format msgid "child table \"%s\" has different collation for column \"%s\"" msgstr "abgeleitete Tabelle »%s« hat unterschiedliche Sortierfolge für Spalte »%s«" -#: commands/tablecmds.c:4775 +#: commands/tablecmds.c:4788 #, c-format msgid "child table \"%s\" has a conflicting \"%s\" column" msgstr "abgeleitete Tabelle »%s« hat eine widersprüchliche Spalte »%s«" -#: commands/tablecmds.c:4787 +#: commands/tablecmds.c:4800 #, c-format msgid "merging definition of column \"%s\" for child \"%s\"" msgstr "Definition von Spalte »%s« für abgeleitete Tabelle »%s« wird zusammengeführt" -#: commands/tablecmds.c:5014 +#: commands/tablecmds.c:5027 #, c-format msgid "column must be added to child tables too" msgstr "Spalte muss ebenso in den abgeleiteten Tabellen hinzugefügt werden" -#: commands/tablecmds.c:5089 +#: commands/tablecmds.c:5102 #, c-format msgid "column \"%s\" of relation \"%s\" already exists, skipping" msgstr "Spalte »%s« von Relation »%s« existiert bereits, wird übersprungen" -#: commands/tablecmds.c:5096 +#: commands/tablecmds.c:5109 #, c-format msgid "column \"%s\" of relation \"%s\" already exists" msgstr "Spalte »%s« von Relation »%s« existiert bereits" -#: commands/tablecmds.c:5207 commands/tablecmds.c:5313 -#: commands/tablecmds.c:5371 commands/tablecmds.c:5485 -#: commands/tablecmds.c:5542 commands/tablecmds.c:5636 -#: commands/tablecmds.c:7924 commands/tablecmds.c:8606 +#: commands/tablecmds.c:5220 commands/tablecmds.c:5326 +#: commands/tablecmds.c:5384 commands/tablecmds.c:5498 +#: commands/tablecmds.c:5555 commands/tablecmds.c:5649 +#: commands/tablecmds.c:7938 commands/tablecmds.c:8620 #, c-format msgid "cannot alter system column \"%s\"" msgstr "Systemspalte »%s« kann nicht geändert werden" -#: commands/tablecmds.c:5243 +#: commands/tablecmds.c:5256 #, c-format msgid "column \"%s\" is in a primary key" msgstr "Spalte »%s« ist in einem Primärschlüssel" -#: commands/tablecmds.c:5458 +#: commands/tablecmds.c:5471 #, c-format msgid "statistics target %d is too low" msgstr "Statistikziel %d ist zu niedrig" -#: commands/tablecmds.c:5466 +#: commands/tablecmds.c:5479 #, c-format msgid "lowering statistics target to %d" msgstr "setze Statistikziel auf %d herab" -#: commands/tablecmds.c:5616 +#: commands/tablecmds.c:5629 #, c-format msgid "invalid storage type \"%s\"" msgstr "ungültiger Storage-Typ »%s«" -#: commands/tablecmds.c:5648 +#: commands/tablecmds.c:5661 #, c-format msgid "column data type %s can only have storage PLAIN" msgstr "Spaltendatentyp %s kann nur Storage-Typ PLAIN" -#: commands/tablecmds.c:5686 +#: commands/tablecmds.c:5699 #, c-format msgid "cannot drop column from typed table" msgstr "aus einer getypten Tabelle können keine Spalten gelöscht werden" -#: commands/tablecmds.c:5730 +#: commands/tablecmds.c:5743 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist, skipping" msgstr "Spalte »%s« von Relation »%s« existiert nicht, wird übersprungen" -#: commands/tablecmds.c:5743 +#: commands/tablecmds.c:5756 #, c-format msgid "cannot drop system column \"%s\"" msgstr "Systemspalte »%s« kann nicht gelöscht werden" -#: commands/tablecmds.c:5750 +#: commands/tablecmds.c:5763 #, c-format msgid "cannot drop inherited column \"%s\"" msgstr "geerbte Spalte »%s« kann nicht gelöscht werden" -#: commands/tablecmds.c:5990 +#: commands/tablecmds.c:6003 #, c-format msgid "ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index \"%s\" to \"%s\"" msgstr "ALTER TABLE / ADD CONSTRAINT USING INDEX benennt Index »%s« um in »%s«" -#: commands/tablecmds.c:6203 +#: commands/tablecmds.c:6216 #, c-format msgid "constraint must be added to child tables too" msgstr "Constraint muss ebenso in den abgeleiteten Tabellen hinzugefügt werden" -#: commands/tablecmds.c:6274 +#: commands/tablecmds.c:6287 #, c-format msgid "referenced relation \"%s\" is not a table" msgstr "Relation »%s«, auf die verwiesen wird, ist keine Tabelle" -#: commands/tablecmds.c:6297 +#: commands/tablecmds.c:6310 #, c-format msgid "constraints on permanent tables may reference only permanent tables" msgstr "Constraints für permanente Tabellen dürfen nur auf permanente Tabellen verweisen" -#: commands/tablecmds.c:6304 +#: commands/tablecmds.c:6317 #, c-format msgid "constraints on unlogged tables may reference only permanent or unlogged tables" msgstr "Constraints für ungeloggte Tabellen dürfen nur auf permanente oder ungeloggte Tabellen verweisen" -#: commands/tablecmds.c:6310 +#: commands/tablecmds.c:6323 #, c-format msgid "constraints on temporary tables may reference only temporary tables" msgstr "Constraints für temporäre Tabellen dürfen nur auf temporäre Tabellen verweisen" -#: commands/tablecmds.c:6314 +#: commands/tablecmds.c:6327 #, c-format msgid "constraints on temporary tables must involve temporary tables of this session" msgstr "Constraints für temporäre Tabellen müssen temporäre Tabellen dieser Sitzung beinhalten" -#: commands/tablecmds.c:6375 +#: commands/tablecmds.c:6388 #, c-format msgid "number of referencing and referenced columns for foreign key disagree" msgstr "Anzahl der Quell- und Zielspalten im Fremdschlüssel stimmt nicht überein" -#: commands/tablecmds.c:6482 +#: commands/tablecmds.c:6495 #, c-format msgid "foreign key constraint \"%s\" cannot be implemented" msgstr "Fremdschlüssel-Constraint »%s« kann nicht implementiert werden" -#: commands/tablecmds.c:6485 +#: commands/tablecmds.c:6498 #, c-format msgid "Key columns \"%s\" and \"%s\" are of incompatible types: %s and %s." msgstr "Schlüsselspalten »%s« und »%s« haben inkompatible Typen: %s und %s." -#: commands/tablecmds.c:6692 commands/tablecmds.c:6860 -#: commands/tablecmds.c:7763 commands/tablecmds.c:7819 +#: commands/tablecmds.c:6705 commands/tablecmds.c:6873 +#: commands/tablecmds.c:7777 commands/tablecmds.c:7833 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist" msgstr "Constraint »%s« von Relation »%s« existiert nicht" -#: commands/tablecmds.c:6698 +#: commands/tablecmds.c:6711 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key constraint" msgstr "Constraint »%s« von Relation »%s« ist kein Fremdschlüssel-Constraint" -#: commands/tablecmds.c:6867 +#: commands/tablecmds.c:6880 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key or check constraint" msgstr "Constraint »%s« von Relation »%s« ist kein Fremdschlüssel- oder Check-Constraint" -#: commands/tablecmds.c:6935 +#: commands/tablecmds.c:6949 #, c-format msgid "constraint must be validated on child tables too" msgstr "Constraint muss ebenso in den abgeleiteten Tabellen validiert werden" -#: commands/tablecmds.c:7004 +#: commands/tablecmds.c:7018 #, c-format msgid "column \"%s\" referenced in foreign key constraint does not exist" msgstr "Spalte »%s«, die im Fremdschlüssel verwendet wird, existiert nicht" -#: commands/tablecmds.c:7009 +#: commands/tablecmds.c:7023 #, c-format msgid "cannot have more than %d keys in a foreign key" msgstr "Fremdschlüssel kann nicht mehr als %d Schlüssel haben" -#: commands/tablecmds.c:7074 +#: commands/tablecmds.c:7088 #, c-format msgid "cannot use a deferrable primary key for referenced table \"%s\"" msgstr "aufschiebbarer Primärschlüssel kann nicht für Tabelle »%s«, auf die verwiesen wird, verwendet werden" -#: commands/tablecmds.c:7091 +#: commands/tablecmds.c:7105 #, c-format msgid "there is no primary key for referenced table \"%s\"" msgstr "in Tabelle »%s«, auf die verwiesen wird, gibt es keinen Primärschlüssel" -#: commands/tablecmds.c:7156 +#: commands/tablecmds.c:7170 #, c-format msgid "foreign key referenced-columns list must not contain duplicates" msgstr "die Liste der Spalten, auf die ein Fremdschlüssel verweist, darf keine doppelten Einträge enthalten" -#: commands/tablecmds.c:7250 +#: commands/tablecmds.c:7264 #, c-format msgid "cannot use a deferrable unique constraint for referenced table \"%s\"" msgstr "aufschiebbarer Unique-Constraint kann nicht für Tabelle »%s«, auf die verwiesen wird, verwendet werden" -#: commands/tablecmds.c:7255 +#: commands/tablecmds.c:7269 #, c-format msgid "there is no unique constraint matching given keys for referenced table \"%s\"" msgstr "in Tabelle »%s«, auf die verwiesen wird, gibt es keinen Unique-Constraint, der auf die angegebenen Schlüssel passt" -#: commands/tablecmds.c:7418 +#: commands/tablecmds.c:7432 #, c-format msgid "validating foreign key constraint \"%s\"" msgstr "validiere Fremdschlüssel-Constraint »%s«" -#: commands/tablecmds.c:7717 +#: commands/tablecmds.c:7731 #, c-format msgid "cannot drop inherited constraint \"%s\" of relation \"%s\"" msgstr "geerbter Constraint »%s« von Relation »%s« kann nicht gelöscht werden" -#: commands/tablecmds.c:7769 +#: commands/tablecmds.c:7783 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist, skipping" msgstr "Constraint »%s« von Relation »%s« existiert nicht, wird übersprungen" -#: commands/tablecmds.c:7908 +#: commands/tablecmds.c:7922 #, c-format msgid "cannot alter column type of typed table" msgstr "Spaltentyp einer getypten Tabelle kann nicht geändert werden" -#: commands/tablecmds.c:7931 +#: commands/tablecmds.c:7945 #, c-format msgid "cannot alter inherited column \"%s\"" msgstr "kann vererbte Spalte »%s« nicht ändern" -#: commands/tablecmds.c:7980 +#: commands/tablecmds.c:7994 #, c-format msgid "result of USING clause for column \"%s\" cannot be cast automatically to type %s" msgstr "Ergebnis der USING-Klausel für Spalte »%s« kann nicht automatisch in Typ %s umgewandelt werden" -#: commands/tablecmds.c:7983 +#: commands/tablecmds.c:7997 #, c-format msgid "You might need to add an explicit cast." msgstr "Sie müssen möglicherweise eine ausdrückliche Typumwandlung hinzufügen." -#: commands/tablecmds.c:7987 +#: commands/tablecmds.c:8001 #, c-format msgid "column \"%s\" cannot be cast automatically to type %s" msgstr "Spalte »%s« kann nicht automatisch in Typ %s umgewandelt werden" #. translator: USING is SQL, don't translate it -#: commands/tablecmds.c:7990 +#: commands/tablecmds.c:8004 #, c-format msgid "You might need to specify \"USING %s::%s\"." msgstr "Sie müssen möglicherweise »USING %s::%s« angeben." -#: commands/tablecmds.c:8089 +#: commands/tablecmds.c:8103 #, c-format msgid "USING expression contains a whole-row table reference." msgstr "USING-Ausdruck enthält einen Verweis auf die ganze Zeile der Tabelle." -#: commands/tablecmds.c:8100 +#: commands/tablecmds.c:8114 #, c-format msgid "type of inherited column \"%s\" must be changed in child tables too" msgstr "Typ der vererbten Spalte »%s« muss ebenso in den abgeleiteten Tabellen geändert werden" -#: commands/tablecmds.c:8187 +#: commands/tablecmds.c:8201 #, c-format msgid "cannot alter type of column \"%s\" twice" msgstr "Typ der Spalte »%s« kann nicht zweimal geändert werden" -#: commands/tablecmds.c:8223 +#: commands/tablecmds.c:8237 #, c-format msgid "default for column \"%s\" cannot be cast automatically to type %s" msgstr "Vorgabewert der Spalte »%s« kann nicht automatisch in Typ %s umgewandelt werden" -#: commands/tablecmds.c:8349 +#: commands/tablecmds.c:8363 #, c-format msgid "cannot alter type of a column used by a view or rule" msgstr "Typ einer Spalte, die von einer Sicht oder Regel verwendet wird, kann nicht geändert werden" -#: commands/tablecmds.c:8350 commands/tablecmds.c:8369 -#: commands/tablecmds.c:8387 +#: commands/tablecmds.c:8364 commands/tablecmds.c:8383 +#: commands/tablecmds.c:8401 #, c-format msgid "%s depends on column \"%s\"" msgstr "%s hängt von Spalte »%s« ab" -#: commands/tablecmds.c:8368 +#: commands/tablecmds.c:8382 #, c-format msgid "cannot alter type of a column used in a trigger definition" msgstr "Typ einer Spalte, die in einer Trigger-Definition verwendet wird, kann nicht geändert werden" -#: commands/tablecmds.c:8386 +#: commands/tablecmds.c:8400 #, c-format msgid "cannot alter type of a column used in a policy definition" msgstr "Typ einer Spalte, die in einer Policy-Definition verwendet wird, kann nicht geändert werden" -#: commands/tablecmds.c:9051 +#: commands/tablecmds.c:9065 #, c-format msgid "cannot change owner of index \"%s\"" msgstr "kann Eigentümer des Index »%s« nicht ändern" -#: commands/tablecmds.c:9053 +#: commands/tablecmds.c:9067 #, c-format msgid "Change the ownership of the index's table, instead." msgstr "Ändern Sie stattdessen den Eigentümer der Tabelle des Index." -#: commands/tablecmds.c:9069 +#: commands/tablecmds.c:9083 #, c-format msgid "cannot change owner of sequence \"%s\"" msgstr "kann Eigentümer der Sequenz »%s« nicht ändern" -#: commands/tablecmds.c:9071 commands/tablecmds.c:11543 +#: commands/tablecmds.c:9085 commands/tablecmds.c:11557 #, c-format msgid "Sequence \"%s\" is linked to table \"%s\"." msgstr "Sequenz »%s« ist mit Tabelle »%s« verknüpft." -#: commands/tablecmds.c:9083 commands/tablecmds.c:12190 +#: commands/tablecmds.c:9097 commands/tablecmds.c:12204 #, c-format msgid "Use ALTER TYPE instead." msgstr "Verwenden Sie stattdessen ALTER TYPE." -#: commands/tablecmds.c:9092 +#: commands/tablecmds.c:9106 #, c-format msgid "\"%s\" is not a table, view, sequence, or foreign table" msgstr "»%s« ist keine Tabelle, Sicht, Sequenz oder Fremdtabelle" -#: commands/tablecmds.c:9435 +#: commands/tablecmds.c:9449 #, c-format msgid "cannot have multiple SET TABLESPACE subcommands" msgstr "mehrere SET TABLESPACE Unterbefehle sind ungültig" -#: commands/tablecmds.c:9508 +#: commands/tablecmds.c:9522 #, c-format msgid "\"%s\" is not a table, view, materialized view, index, or TOAST table" msgstr "»%s« ist weder Tabelle, Sicht, materialisierte Sicht, Index noch TOAST-Tabelle" -#: commands/tablecmds.c:9541 commands/view.c:498 +#: commands/tablecmds.c:9555 commands/view.c:498 #, c-format msgid "WITH CHECK OPTION is supported only on automatically updatable views" msgstr "WITH CHECK OPTION wird nur für automatisch aktualisierbare Sichten unterstützt" -#: commands/tablecmds.c:9687 +#: commands/tablecmds.c:9701 #, c-format msgid "cannot move system relation \"%s\"" msgstr "Systemrelation »%s« kann nicht verschoben werden" -#: commands/tablecmds.c:9703 +#: commands/tablecmds.c:9717 #, c-format msgid "cannot move temporary tables of other sessions" msgstr "temporäre Tabellen anderer Sitzungen können nicht verschoben werden" -#: commands/tablecmds.c:9840 +#: commands/tablecmds.c:9854 #, c-format msgid "only tables, indexes, and materialized views exist in tablespaces" msgstr "nur Tabellen, Indexe und materialisierte Sichten existieren in Tablespaces" -#: commands/tablecmds.c:9852 +#: commands/tablecmds.c:9866 #, c-format msgid "cannot move relations in to or out of pg_global tablespace" msgstr "Relationen können nicht in den oder aus dem Tablespace »pg_global« verschoben werden" -#: commands/tablecmds.c:9943 +#: commands/tablecmds.c:9957 #, c-format msgid "aborting because lock on relation \"%s.%s\" is not available" msgstr "Abbruch weil Sperre für Relation »%s.%s« nicht verfügbar ist" -#: commands/tablecmds.c:9959 +#: commands/tablecmds.c:9973 #, c-format msgid "no matching relations in tablespace \"%s\" found" msgstr "keine passenden Relationen in Tablespace »%s« gefunden" -#: commands/tablecmds.c:10033 storage/buffer/bufmgr.c:915 +#: commands/tablecmds.c:10047 storage/buffer/bufmgr.c:915 #, c-format msgid "invalid page in block %u of relation %s" msgstr "ungültige Seite in Block %u von Relation %s" -#: commands/tablecmds.c:10115 +#: commands/tablecmds.c:10129 #, c-format msgid "cannot change inheritance of typed table" msgstr "Vererbung einer getypten Tabelle kann nicht geändert werden" -#: commands/tablecmds.c:10165 +#: commands/tablecmds.c:10179 #, c-format msgid "cannot inherit to temporary relation of another session" msgstr "an temporäre Relation einer anderen Sitzung kann nicht vererbt werden" -#: commands/tablecmds.c:10219 +#: commands/tablecmds.c:10233 #, c-format msgid "circular inheritance not allowed" msgstr "zirkuläre Vererbung ist nicht erlaubt" -#: commands/tablecmds.c:10220 +#: commands/tablecmds.c:10234 #, c-format msgid "\"%s\" is already a child of \"%s\"." msgstr "»%s« ist schon von »%s« abgeleitet." -#: commands/tablecmds.c:10228 +#: commands/tablecmds.c:10242 #, c-format msgid "table \"%s\" without OIDs cannot inherit from table \"%s\" with OIDs" msgstr "Tabelle »%s« ohne OIDs kann nicht von Tabelle »%s« mit OIDs erben" -#: commands/tablecmds.c:10369 +#: commands/tablecmds.c:10383 #, c-format msgid "column \"%s\" in child table must be marked NOT NULL" msgstr "Spalte »%s« in abgeleiteter Tabelle muss als NOT NULL markiert sein" -#: commands/tablecmds.c:10385 commands/tablecmds.c:10418 +#: commands/tablecmds.c:10399 commands/tablecmds.c:10432 #, c-format msgid "child table is missing column \"%s\"" msgstr "Spalte »%s« fehlt in abgeleiteter Tabelle" -#: commands/tablecmds.c:10501 +#: commands/tablecmds.c:10515 #, c-format msgid "child table \"%s\" has different definition for check constraint \"%s\"" msgstr "abgeleitete Tabelle »%s« hat unterschiedliche Definition für Check-Constraint »%s«" -#: commands/tablecmds.c:10509 +#: commands/tablecmds.c:10523 #, c-format msgid "constraint \"%s\" conflicts with non-inherited constraint on child table \"%s\"" msgstr "Constraint »%s« kollidiert mit nicht vererbtem Constraint für abgeleitete Tabelle »%s«" -#: commands/tablecmds.c:10520 +#: commands/tablecmds.c:10534 #, c-format msgid "constraint \"%s\" conflicts with NOT VALID constraint on child table \"%s\"" msgstr "Constraint »%s« kollidiert mit NOT-VALID-Constraint für abgeleitete Tabelle »%s«" -#: commands/tablecmds.c:10544 +#: commands/tablecmds.c:10558 #, c-format msgid "child table is missing constraint \"%s\"" msgstr "Constraint »%s« fehlt in abgeleiteter Tabelle" -#: commands/tablecmds.c:10628 +#: commands/tablecmds.c:10642 #, c-format msgid "relation \"%s\" is not a parent of relation \"%s\"" msgstr "Relation »%s« ist keine Basisrelation von Relation »%s«" -#: commands/tablecmds.c:10862 +#: commands/tablecmds.c:10876 #, c-format msgid "typed tables cannot inherit" msgstr "getypte Tabellen können nicht erben" -#: commands/tablecmds.c:10893 +#: commands/tablecmds.c:10907 #, c-format msgid "table is missing column \"%s\"" msgstr "Spalte »%s« fehlt in Tabelle" -#: commands/tablecmds.c:10903 +#: commands/tablecmds.c:10917 #, c-format msgid "table has column \"%s\" where type requires \"%s\"" msgstr "Tabelle hat Spalte »%s«, aber Typ benötigt »%s«" -#: commands/tablecmds.c:10912 +#: commands/tablecmds.c:10926 #, c-format msgid "table \"%s\" has different type for column \"%s\"" msgstr "Tabelle »%s« hat unterschiedlichen Typ für Spalte »%s«" -#: commands/tablecmds.c:10925 +#: commands/tablecmds.c:10939 #, c-format msgid "table has extra column \"%s\"" msgstr "Tabelle hat zusätzliche Spalte »%s«" -#: commands/tablecmds.c:10977 +#: commands/tablecmds.c:10991 #, c-format msgid "\"%s\" is not a typed table" msgstr "»%s« ist keine getypte Tabelle" -#: commands/tablecmds.c:11161 +#: commands/tablecmds.c:11175 #, c-format msgid "cannot use non-unique index \"%s\" as replica identity" msgstr "nicht eindeutiger Index »%s« kann nicht als Replik-Identität verwendet werden" -#: commands/tablecmds.c:11167 +#: commands/tablecmds.c:11181 #, c-format msgid "cannot use non-immediate index \"%s\" as replica identity" msgstr "Index »%s« kann nicht als Replik-Identität verwendet werden, weil er nicht IMMEDIATE ist" -#: commands/tablecmds.c:11173 +#: commands/tablecmds.c:11187 #, c-format msgid "cannot use expression index \"%s\" as replica identity" msgstr "Ausdrucksindex »%s« kann nicht als Replik-Identität verwendet werden" -#: commands/tablecmds.c:11179 +#: commands/tablecmds.c:11193 #, c-format msgid "cannot use partial index \"%s\" as replica identity" msgstr "partieller Index »%s« kann nicht als Replik-Identität verwendet werden" -#: commands/tablecmds.c:11185 +#: commands/tablecmds.c:11199 #, c-format msgid "cannot use invalid index \"%s\" as replica identity" msgstr "ungültiger Index »%s« kann nicht als Replik-Identität verwendet werden" -#: commands/tablecmds.c:11206 +#: commands/tablecmds.c:11220 #, c-format msgid "index \"%s\" cannot be used as replica identity because column %d is a system column" msgstr "Index »%s« kann nicht als Replik-Identität verwendet werden, weil Spalte %d eine Systemspalte ist" -#: commands/tablecmds.c:11213 +#: commands/tablecmds.c:11227 #, c-format msgid "index \"%s\" cannot be used as replica identity because column \"%s\" is nullable" msgstr "Index »%s« kann nicht als Replik-Identität verwendet werden, weil Spalte »%s« NULL-Werte akzeptiert" -#: commands/tablecmds.c:11416 +#: commands/tablecmds.c:11430 #, c-format msgid "cannot change logged status of table \"%s\" because it is temporary" msgstr "kann den geloggten Status der Tabelle »%s« nicht ändern, weil sie temporär ist" -#: commands/tablecmds.c:11475 +#: commands/tablecmds.c:11489 #, c-format msgid "could not change table \"%s\" to logged because it references unlogged table \"%s\"" msgstr "konnte Tabelle »%s« nicht in geloggt ändern, weil sie auf die ungeloggte Tabelle »%s« verweist" -#: commands/tablecmds.c:11485 +#: commands/tablecmds.c:11499 #, c-format msgid "could not change table \"%s\" to unlogged because it references logged table \"%s\"" msgstr "konnte Tabelle »%s« nicht in ungeloggt ändern, weil sie auf die geloggte Tabelle »%s« verweist" -#: commands/tablecmds.c:11542 +#: commands/tablecmds.c:11556 #, c-format msgid "cannot move an owned sequence into another schema" msgstr "einer Tabelle zugeordnete Sequenz kann nicht in ein anderes Schema verschoben werden" -#: commands/tablecmds.c:11647 +#: commands/tablecmds.c:11661 #, c-format msgid "relation \"%s\" already exists in schema \"%s\"" msgstr "Relation »%s« existiert bereits in Schema »%s«" -#: commands/tablecmds.c:12174 +#: commands/tablecmds.c:12188 #, c-format msgid "\"%s\" is not a composite type" msgstr "»%s« ist kein zusammengesetzter Typ" -#: commands/tablecmds.c:12204 +#: commands/tablecmds.c:12218 #, c-format msgid "\"%s\" is not a table, view, materialized view, sequence, or foreign table" msgstr "»%s« ist weder Tabelle, Sicht, materialisierte Sicht, Sequenz noch Fremdtabelle" #: commands/tablespace.c:162 commands/tablespace.c:179 #: commands/tablespace.c:190 commands/tablespace.c:198 -#: commands/tablespace.c:625 replication/slot.c:980 storage/file/copydir.c:47 +#: commands/tablespace.c:625 replication/slot.c:997 storage/file/copydir.c:47 #, c-format msgid "could not create directory \"%s\": %m" msgstr "konnte Verzeichnis »%s« nicht erzeugen: %m" @@ -9177,42 +9000,42 @@ msgstr "Constraint »%s« von Domäne »%s« ist kein Check-Constraint" msgid "column \"%s\" of table \"%s\" contains values that violate the new constraint" msgstr "Spalte »%s« von Tabelle »%s« enthält Werte, die den neuen Constraint verletzen" -#: commands/typecmds.c:2971 commands/typecmds.c:3228 commands/typecmds.c:3417 +#: commands/typecmds.c:2986 commands/typecmds.c:3243 commands/typecmds.c:3432 #, c-format msgid "%s is not a domain" msgstr "%s ist keine Domäne" -#: commands/typecmds.c:3005 +#: commands/typecmds.c:3020 #, c-format msgid "constraint \"%s\" for domain \"%s\" already exists" msgstr "Constraint »%s« für Domäne »%s« existiert bereits" -#: commands/typecmds.c:3055 +#: commands/typecmds.c:3070 #, c-format msgid "cannot use table references in domain check constraint" msgstr "Tabellenverweise können in Domänen-Check-Constraints nicht verwendet werden" -#: commands/typecmds.c:3158 commands/typecmds.c:3240 commands/typecmds.c:3534 +#: commands/typecmds.c:3173 commands/typecmds.c:3255 commands/typecmds.c:3549 #, c-format msgid "%s is a table's row type" msgstr "%s ist der Zeilentyp einer Tabelle" -#: commands/typecmds.c:3160 commands/typecmds.c:3242 commands/typecmds.c:3536 +#: commands/typecmds.c:3175 commands/typecmds.c:3257 commands/typecmds.c:3551 #, c-format msgid "Use ALTER TABLE instead." msgstr "Verwenden Sie stattdessen ALTER TABLE." -#: commands/typecmds.c:3167 commands/typecmds.c:3249 commands/typecmds.c:3449 +#: commands/typecmds.c:3182 commands/typecmds.c:3264 commands/typecmds.c:3464 #, c-format msgid "cannot alter array type %s" msgstr "Array-Typ %s kann nicht verändert werden" -#: commands/typecmds.c:3169 commands/typecmds.c:3251 commands/typecmds.c:3451 +#: commands/typecmds.c:3184 commands/typecmds.c:3266 commands/typecmds.c:3466 #, c-format msgid "You can alter type %s, which will alter the array type as well." msgstr "Sie können den Typ %s ändern, wodurch der Array-Typ ebenfalls geändert wird." -#: commands/typecmds.c:3519 +#: commands/typecmds.c:3534 #, c-format msgid "type \"%s\" already exists in schema \"%s\"" msgstr "Typ %s existiert bereits in Schema »%s«" @@ -9242,8 +9065,8 @@ msgstr "nur Superuser können das Attribut »bypassrls« ändern" msgid "permission denied to create role" msgstr "keine Berechtigung, um Rolle zu erzeugen" -#: commands/user.c:322 commands/user.c:1176 commands/user.c:1183 gram.y:13615 -#: gram.y:13650 utils/adt/acl.c:5279 utils/adt/acl.c:5285 +#: commands/user.c:322 commands/user.c:1176 commands/user.c:1183 gram.y:13628 +#: gram.y:13663 utils/adt/acl.c:5279 utils/adt/acl.c:5285 #, c-format msgid "role name \"%s\" is reserved" msgstr "Rollenname »%s« ist reserviert" @@ -9456,91 +9279,96 @@ msgstr "überspringe »%s« --- nur Eigentümer der Tabelle oder der Datenbank k msgid "skipping \"%s\" --- cannot vacuum non-tables or special system tables" msgstr "überspringe »%s« --- kann Nicht-Tabellen oder besondere Systemtabellen nicht vacuumen" -#: commands/vacuumlazy.c:366 +#: commands/vacuumlazy.c:371 #, c-format msgid "automatic vacuum of table \"%s.%s.%s\": index scans: %d\n" msgstr "automatisches Vacuum der Tabelle »%s.%s.%s«: Index-Scans: %d\n" -#: commands/vacuumlazy.c:371 +#: commands/vacuumlazy.c:376 #, c-format msgid "pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n" msgstr "Seiten: %u entfernt, %u verbleiben, %u übersprungen wegen Pins, %u übersprungen weil eingefroren\n" -#: commands/vacuumlazy.c:377 +#: commands/vacuumlazy.c:382 #, c-format msgid "tuples: %.0f removed, %.0f remain, %.0f are dead but not yet removable\n" msgstr "Tupel: %.0f entfernt, %.0f verbleiben, %.0f sind tot aber noch nicht entfernbar\n" -#: commands/vacuumlazy.c:382 +#: commands/vacuumlazy.c:387 #, c-format msgid "buffer usage: %d hits, %d misses, %d dirtied\n" msgstr "Puffer-Verwendung: %d Treffer, %d Verfehlen, %d geändert\n" -#: commands/vacuumlazy.c:386 +#: commands/vacuumlazy.c:391 #, c-format msgid "avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n" msgstr "durchschn. Leserate: %.3f MB/s, durchschn. Schreibrate: %.3f MB/s\n" -#: commands/vacuumlazy.c:388 +#: commands/vacuumlazy.c:393 #, c-format msgid "system usage: %s" msgstr "Systembenutzung: %s" -#: commands/vacuumlazy.c:846 +#: commands/vacuumlazy.c:852 #, c-format msgid "relation \"%s\" page %u is uninitialized --- fixing" msgstr "Seite %2$u in Relation »%1$s« ist nicht initialisiert --- wird repariert" -#: commands/vacuumlazy.c:1316 +#: commands/vacuumlazy.c:1322 #, c-format msgid "\"%s\": removed %.0f row versions in %u pages" msgstr "»%s«: %.0f Zeilenversionen in %u Seiten entfernt" -#: commands/vacuumlazy.c:1326 +#: commands/vacuumlazy.c:1332 #, c-format msgid "%.0f dead row versions cannot be removed yet.\n" msgstr "%.0f tote Zeilenversionen können noch nicht entfernt werden.\n" -#: commands/vacuumlazy.c:1328 +#: commands/vacuumlazy.c:1334 #, c-format msgid "There were %.0f unused item pointers.\n" msgstr "Es gab %.0f unbenutzte Itemzeiger.\n" -#: commands/vacuumlazy.c:1330 +#: commands/vacuumlazy.c:1336 #, c-format msgid "Skipped %u page due to buffer pins.\n" msgid_plural "Skipped %u pages due to buffer pins.\n" msgstr[0] "%u Seite wegen Buffer-Pins übersprungen.\n" msgstr[1] "%u Seiten wegen Buffer-Pins übersprungen.\n" -#: commands/vacuumlazy.c:1334 +#: commands/vacuumlazy.c:1340 #, c-format msgid "%u page is entirely empty.\n" msgid_plural "%u pages are entirely empty.\n" msgstr[0] "%u Seite ist vollkommen leer.\n" msgstr[1] "%u Seiten sind vollkommen leer.\n" -#: commands/vacuumlazy.c:1342 +#: commands/vacuumlazy.c:1344 +#, c-format +msgid "%s." +msgstr "%s." + +#: commands/vacuumlazy.c:1347 #, c-format msgid "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u pages" msgstr "»%s«: %.0f entfernbare, %.0f nicht entfernbare Zeilenversionen in %u von %u Seiten gefunden" -#: commands/vacuumlazy.c:1411 +#: commands/vacuumlazy.c:1416 #, c-format msgid "\"%s\": removed %d row versions in %d pages" msgstr "»%s«: %d Zeilenversionen in %d Seiten entfernt" -#: commands/vacuumlazy.c:1600 +#: commands/vacuumlazy.c:1604 #, c-format msgid "scanned index \"%s\" to remove %d row versions" msgstr "Index »%s« gelesen und %d Zeilenversionen entfernt" -#: commands/vacuumlazy.c:1646 +#: commands/vacuumlazy.c:1650 #, c-format msgid "index \"%s\" now contains %.0f row versions in %u pages" msgstr "Index »%s« enthält %.0f Zeilenversionen in %u Seiten" -#: commands/vacuumlazy.c:1650 +#: commands/vacuumlazy.c:1654 #, c-format msgid "" "%.0f index row versions were removed.\n" @@ -9551,17 +9379,17 @@ msgstr "" "%u Indexseiten wurden gelöscht, %u sind gegenwärtig wiederverwendbar.\n" "%s." -#: commands/vacuumlazy.c:1745 +#: commands/vacuumlazy.c:1749 #, c-format msgid "\"%s\": stopping truncate due to conflicting lock request" msgstr "»%s«: Truncate wird gestoppt wegen Sperrkonflikt" -#: commands/vacuumlazy.c:1810 +#: commands/vacuumlazy.c:1814 #, c-format msgid "\"%s\": truncated %u to %u pages" msgstr "»%s«: von %u auf %u Seiten verkürzt" -#: commands/vacuumlazy.c:1866 +#: commands/vacuumlazy.c:1870 #, c-format msgid "\"%s\": suspending truncate due to conflicting lock request" msgstr "»%s«: Truncate wird ausgesetzt wegen Sperrkonflikt" @@ -9626,7 +9454,7 @@ msgstr "SET TRANSACTION ISOLATION LEVEL muss vor allen Anfragen aufgerufen werde msgid "SET TRANSACTION ISOLATION LEVEL must not be called in a subtransaction" msgstr "SET TRANSACTION ISOLATION LEVEL kann nicht in einer Subtransaktion aufgerufen werden" -#: commands/variable.c:574 storage/lmgr/predicate.c:1587 +#: commands/variable.c:574 storage/lmgr/predicate.c:1602 #, c-format msgid "cannot use serializable mode in a hot standby" msgstr "kann serialisierbaren Modus nicht in einem Hot Standby verwenden" @@ -9658,8 +9486,8 @@ msgstr "»client_encoding« kann jetzt nicht geändert werden." #: commands/variable.c:779 #, c-format -msgid "cannot change client_encoding in a parallel worker" -msgstr "client_encoding kann nicht in einem parallelen Arbeitsprozess geändert werden" +msgid "cannot change client_encoding during a parallel operation" +msgstr "client_encoding kann nicht während einer parallelen Operation geändert werden" #: commands/variable.c:915 #, c-format @@ -9811,32 +9639,32 @@ msgstr "kann Sequenz »%s« nicht ändern" msgid "cannot change TOAST relation \"%s\"" msgstr "kann TOAST-Relation »%s« nicht ändern" -#: executor/execMain.c:1051 rewrite/rewriteHandler.c:2648 +#: executor/execMain.c:1051 rewrite/rewriteHandler.c:2679 #, c-format msgid "cannot insert into view \"%s\"" msgstr "kann nicht in Sicht »%s« einfügen" -#: executor/execMain.c:1053 rewrite/rewriteHandler.c:2651 +#: executor/execMain.c:1053 rewrite/rewriteHandler.c:2682 #, c-format msgid "To enable inserting into the view, provide an INSTEAD OF INSERT trigger or an unconditional ON INSERT DO INSTEAD rule." msgstr "Um Einfügen in die Sicht zu ermöglichen, richten Sie einen INSTEAD OF INSERT Trigger oder eine ON INSERT DO INSTEAD Regel ohne Bedingung ein." -#: executor/execMain.c:1059 rewrite/rewriteHandler.c:2656 +#: executor/execMain.c:1059 rewrite/rewriteHandler.c:2687 #, c-format msgid "cannot update view \"%s\"" msgstr "kann Sicht »%s« nicht aktualisieren" -#: executor/execMain.c:1061 rewrite/rewriteHandler.c:2659 +#: executor/execMain.c:1061 rewrite/rewriteHandler.c:2690 #, c-format msgid "To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule." msgstr "Um Aktualisieren der Sicht zu ermöglichen, richten Sie einen INSTEAD OF UPDATE Trigger oder eine ON UPDATE DO INSTEAD Regel ohne Bedingung ein." -#: executor/execMain.c:1067 rewrite/rewriteHandler.c:2664 +#: executor/execMain.c:1067 rewrite/rewriteHandler.c:2695 #, c-format msgid "cannot delete from view \"%s\"" msgstr "kann nicht aus Sicht »%s« löschen" -#: executor/execMain.c:1069 rewrite/rewriteHandler.c:2667 +#: executor/execMain.c:1069 rewrite/rewriteHandler.c:2698 #, c-format msgid "To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an unconditional ON DELETE DO INSTEAD rule." msgstr "Um Löschen aus der Sicht zu ermöglichen, richten Sie einen INSTEAD OF DELETE Trigger oder eine ON DELETE DO INSTEAD Regel ohne Bedingung ein." @@ -10235,7 +10063,7 @@ msgstr "konnte Position in temporärer Datei für Hash-Verbund nicht auf Anfang msgid "could not write to hash-join temporary file: %m" msgstr "konnte nicht in temporäre Datei für Hash-Verbund schreiben: %m" -#: executor/nodeHashjoin.c:928 executor/nodeHashjoin.c:938 +#: executor/nodeHashjoin.c:935 executor/nodeHashjoin.c:945 #, c-format msgid "could not read from hash-join temporary file: %m" msgstr "konnte nicht aus temporärer Datei für Hash-Verbund lesen: %m" @@ -10397,32 +10225,32 @@ msgstr "Gültige Optionen in diesem Zusammenhang sind: %s" msgid "unrecognized role option \"%s\"" msgstr "unbekannte Rollenoption »%s«" -#: gram.y:1278 gram.y:1293 +#: gram.y:1286 gram.y:1301 #, c-format msgid "CREATE SCHEMA IF NOT EXISTS cannot include schema elements" msgstr "CREATE SCHEMA IF NOT EXISTS kann keine Schemaelemente enthalten" -#: gram.y:1438 +#: gram.y:1446 #, c-format msgid "current database cannot be changed" msgstr "aktuelle Datenbank kann nicht geändert werden" -#: gram.y:1562 +#: gram.y:1570 #, c-format msgid "time zone interval must be HOUR or HOUR TO MINUTE" msgstr "Zeitzonenintervall muss HOUR oder HOUR TO MINUTE sein" -#: gram.y:2600 gram.y:2629 +#: gram.y:2608 gram.y:2637 #, c-format msgid "STDIN/STDOUT not allowed with PROGRAM" msgstr "STDIN/STDOUT sind nicht mit PROGRAM erlaubt" -#: gram.y:2895 gram.y:2902 gram.y:10295 gram.y:10303 +#: gram.y:2903 gram.y:2910 gram.y:10304 gram.y:10312 #, c-format msgid "GLOBAL is deprecated in temporary table creation" msgstr "die Verwendung von GLOBAL beim Erzeugen einer temporären Tabelle ist veraltet" -#: gram.y:3343 utils/adt/ri_triggers.c:314 utils/adt/ri_triggers.c:371 +#: gram.y:3351 utils/adt/ri_triggers.c:314 utils/adt/ri_triggers.c:371 #: utils/adt/ri_triggers.c:790 utils/adt/ri_triggers.c:1013 #: utils/adt/ri_triggers.c:1169 utils/adt/ri_triggers.c:1350 #: utils/adt/ri_triggers.c:1515 utils/adt/ri_triggers.c:1691 @@ -10433,249 +10261,249 @@ msgstr "die Verwendung von GLOBAL beim Erzeugen einer temporären Tabelle ist ve msgid "MATCH PARTIAL not yet implemented" msgstr "MATCH PARTIAL ist noch nicht implementiert" -#: gram.y:4809 +#: gram.y:4818 msgid "duplicate trigger events specified" msgstr "mehrere Trigger-Ereignisse angegeben" -#: gram.y:4902 parser/parse_utilcmd.c:2728 parser/parse_utilcmd.c:2754 +#: gram.y:4911 parser/parse_utilcmd.c:2729 parser/parse_utilcmd.c:2755 #, c-format msgid "constraint declared INITIALLY DEFERRED must be DEFERRABLE" msgstr "Constraint, der als INITIALLY DEFERRED deklariert wurde, muss DEFERRABLE sein" -#: gram.y:4909 +#: gram.y:4918 #, c-format msgid "conflicting constraint properties" msgstr "widersprüchliche Constraint-Eigentschaften" -#: gram.y:5041 +#: gram.y:5050 #, c-format msgid "CREATE ASSERTION is not yet implemented" msgstr "CREATE ASSERTION ist noch nicht implementiert" -#: gram.y:5057 +#: gram.y:5066 #, c-format msgid "DROP ASSERTION is not yet implemented" msgstr "DROP ASSERTION ist noch nicht implementiert" -#: gram.y:5403 +#: gram.y:5412 #, c-format msgid "RECHECK is no longer required" msgstr "RECHECK wird nicht mehr benötigt" -#: gram.y:5404 +#: gram.y:5413 #, c-format msgid "Update your data type." msgstr "Aktualisieren Sie Ihren Datentyp." -#: gram.y:6983 +#: gram.y:6992 #, c-format msgid "aggregates cannot have output arguments" msgstr "Aggregatfunktionen können keine OUT-Argumente haben" -#: gram.y:7302 utils/adt/regproc.c:774 utils/adt/regproc.c:815 +#: gram.y:7311 utils/adt/regproc.c:775 utils/adt/regproc.c:816 #, c-format msgid "missing argument" msgstr "Argument fehlt" -#: gram.y:7303 utils/adt/regproc.c:775 utils/adt/regproc.c:816 +#: gram.y:7312 utils/adt/regproc.c:776 utils/adt/regproc.c:817 #, c-format msgid "Use NONE to denote the missing argument of a unary operator." msgstr "Verwenden Sie NONE, um das fehlende Argument eines unären Operators anzugeben." -#: gram.y:8853 gram.y:8871 +#: gram.y:8862 gram.y:8880 #, c-format msgid "WITH CHECK OPTION not supported on recursive views" msgstr "WITH CHECK OPTION wird für rekursive Sichten nicht unterstützt" -#: gram.y:9389 +#: gram.y:9398 #, c-format msgid "unrecognized VACUUM option \"%s\"" msgstr "unbekannte VACUUM-Option »%s«" -#: gram.y:9887 parser/parse_expr.c:1501 +#: gram.y:9896 parser/parse_expr.c:1501 #, c-format msgid "number of columns does not match number of values" msgstr "Anzahl der Spalten stimmt nicht mit der Anzahl der Werte überein" -#: gram.y:10403 +#: gram.y:10412 #, c-format msgid "LIMIT #,# syntax is not supported" msgstr "Syntax LIMIT x,y wird nicht unterstützt" -#: gram.y:10404 +#: gram.y:10413 #, c-format msgid "Use separate LIMIT and OFFSET clauses." msgstr "Verwenden Sie die getrennten Klauseln LIMIT und OFFSET." -#: gram.y:10667 gram.y:10692 +#: gram.y:10676 gram.y:10701 #, c-format msgid "VALUES in FROM must have an alias" msgstr "VALUES in FROM muss Aliasnamen erhalten" -#: gram.y:10668 gram.y:10693 +#: gram.y:10677 gram.y:10702 #, c-format msgid "For example, FROM (VALUES ...) [AS] foo." msgstr "Zum Beispiel FROM (VALUES ...) [AS] xyz." -#: gram.y:10673 gram.y:10698 +#: gram.y:10682 gram.y:10707 #, c-format msgid "subquery in FROM must have an alias" msgstr "Unteranfrage in FROM muss Aliasnamen erhalten" -#: gram.y:10674 gram.y:10699 +#: gram.y:10683 gram.y:10708 #, c-format msgid "For example, FROM (SELECT ...) [AS] foo." msgstr "Zum Beispiel FROM (SELECT ...) [AS] xyz." -#: gram.y:11273 +#: gram.y:11282 #, c-format msgid "precision for type float must be at least 1 bit" msgstr "Präzision von Typ float muss mindestens 1 Bit sein" -#: gram.y:11282 +#: gram.y:11291 #, c-format msgid "precision for type float must be less than 54 bits" msgstr "Präzision von Typ float muss weniger als 54 Bits sein" -#: gram.y:11786 +#: gram.y:11795 #, c-format msgid "wrong number of parameters on left side of OVERLAPS expression" msgstr "falsche Anzahl Parameter auf linker Seite von OVERLAPS-Ausdruck" -#: gram.y:11791 +#: gram.y:11800 #, c-format msgid "wrong number of parameters on right side of OVERLAPS expression" msgstr "falsche Anzahl Parameter auf rechter Seite von OVERLAPS-Ausdruck" -#: gram.y:11966 +#: gram.y:11975 #, c-format msgid "UNIQUE predicate is not yet implemented" msgstr "UNIQUE-Prädikat ist noch nicht implementiert" -#: gram.y:12296 +#: gram.y:12309 #, c-format msgid "cannot use multiple ORDER BY clauses with WITHIN GROUP" msgstr "in WITHIN GROUP können nicht mehrere ORDER-BY-Klauseln verwendet werden" -#: gram.y:12301 +#: gram.y:12314 #, c-format msgid "cannot use DISTINCT with WITHIN GROUP" msgstr "DISTINCT kann nicht mit WITHIN GROUP verwendet werden" -#: gram.y:12306 +#: gram.y:12319 #, c-format msgid "cannot use VARIADIC with WITHIN GROUP" msgstr "VARIADIC kann nicht mit WITHIN GROUP verwendet werden" -#: gram.y:12812 +#: gram.y:12825 #, c-format msgid "RANGE PRECEDING is only supported with UNBOUNDED" msgstr "RANGE PRECEDING wird nur mit UNBOUNDED unterstützt" -#: gram.y:12818 +#: gram.y:12831 #, c-format msgid "RANGE FOLLOWING is only supported with UNBOUNDED" msgstr "RANGE FOLLOWING wird nur mit UNBOUNDED unterstützt" -#: gram.y:12845 gram.y:12868 +#: gram.y:12858 gram.y:12881 #, c-format msgid "frame start cannot be UNBOUNDED FOLLOWING" msgstr "Frame-Beginn kann nicht UNBOUNDED FOLLOWING sein" -#: gram.y:12850 +#: gram.y:12863 #, c-format msgid "frame starting from following row cannot end with current row" msgstr "Frame der in der folgenden Zeile beginnt kann nicht in der aktuellen Zeile enden" -#: gram.y:12873 +#: gram.y:12886 #, c-format msgid "frame end cannot be UNBOUNDED PRECEDING" msgstr "Frame-Ende kann nicht UNBOUNDED PRECEDING sein" -#: gram.y:12879 +#: gram.y:12892 #, c-format msgid "frame starting from current row cannot have preceding rows" msgstr "Frame der in der aktuellen Zeile beginnt kann keine vorhergehenden Zeilen haben" -#: gram.y:12886 +#: gram.y:12899 #, c-format msgid "frame starting from following row cannot have preceding rows" msgstr "Frame der in der folgenden Zeile beginnt kann keine vorhergehenden Zeilen haben" -#: gram.y:13551 +#: gram.y:13564 #, c-format msgid "type modifier cannot have parameter name" msgstr "Typmodifikator kann keinen Parameternamen haben" -#: gram.y:13557 +#: gram.y:13570 #, c-format msgid "type modifier cannot have ORDER BY" msgstr "Typmodifikator kann kein ORDER BY haben" -#: gram.y:13621 gram.y:13627 +#: gram.y:13634 gram.y:13640 #, c-format msgid "%s cannot be used as a role name here" msgstr "%s kann hier nicht als Rollenname verwendet werden" -#: gram.y:14249 gram.y:14438 +#: gram.y:14262 gram.y:14451 msgid "improper use of \"*\"" msgstr "unzulässige Verwendung von »*«" -#: gram.y:14401 gram.y:14418 tsearch/spell.c:954 tsearch/spell.c:971 +#: gram.y:14414 gram.y:14431 tsearch/spell.c:954 tsearch/spell.c:971 #: tsearch/spell.c:988 tsearch/spell.c:1005 tsearch/spell.c:1070 #, c-format msgid "syntax error" msgstr "Syntaxfehler" -#: gram.y:14502 +#: gram.y:14515 #, c-format msgid "an ordered-set aggregate with a VARIADIC direct argument must have one VARIADIC aggregated argument of the same data type" msgstr "eine Ordered-Set-Aggregatfunktion mit einem direkten VARIADIC-Argument muss ein aggregiertes VARIADIC-Argument des selben Datentyps haben" -#: gram.y:14539 +#: gram.y:14552 #, c-format msgid "multiple ORDER BY clauses not allowed" msgstr "mehrere ORDER-BY-Klauseln sind nicht erlaubt" -#: gram.y:14550 +#: gram.y:14563 #, c-format msgid "multiple OFFSET clauses not allowed" msgstr "mehrere OFFSET-Klauseln sind nicht erlaubt" -#: gram.y:14559 +#: gram.y:14572 #, c-format msgid "multiple LIMIT clauses not allowed" msgstr "mehrere LIMIT-Klauseln sind nicht erlaubt" -#: gram.y:14568 +#: gram.y:14581 #, c-format msgid "multiple WITH clauses not allowed" msgstr "mehrere WITH-Klauseln sind nicht erlaubt" -#: gram.y:14760 +#: gram.y:14773 #, c-format msgid "OUT and INOUT arguments aren't allowed in TABLE functions" msgstr "OUT- und INOUT-Argumente sind in TABLE-Funktionen nicht erlaubt" -#: gram.y:14861 +#: gram.y:14874 #, c-format msgid "multiple COLLATE clauses not allowed" msgstr "mehrere COLLATE-Klauseln sind nicht erlaubt" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14899 gram.y:14912 +#: gram.y:14912 gram.y:14925 #, c-format msgid "%s constraints cannot be marked DEFERRABLE" msgstr "%s-Constraints können nicht als DEFERRABLE markiert werden" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14925 +#: gram.y:14938 #, c-format msgid "%s constraints cannot be marked NOT VALID" msgstr "%s-Constraints können nicht als NOT VALID markiert werden" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14938 +#: gram.y:14951 #, c-format msgid "%s constraints cannot be marked NO INHERIT" msgstr "%s-Constraints können nicht als NO INHERIT markiert werden" @@ -10920,339 +10748,339 @@ msgstr "Passwort-Antwort erwartet, Message-Typ %d empfangen" msgid "invalid password packet size" msgstr "ungültige Größe des Passwortpakets" -#: libpq/auth.c:828 +#: libpq/auth.c:712 +#, c-format +msgid "empty password returned by client" +msgstr "Client gab leeres Passwort zurück" + +#: libpq/auth.c:842 #, c-format msgid "GSSAPI is not supported in protocol version 2" msgstr "GSSAPI wird in Protokollversion 2 nicht unterstützt" -#: libpq/auth.c:888 +#: libpq/auth.c:902 #, c-format msgid "expected GSS response, got message type %d" msgstr "GSS-Antwort erwartet, Message-Typ %d empfangen" -#: libpq/auth.c:949 +#: libpq/auth.c:963 msgid "accepting GSS security context failed" msgstr "Annahme des GSS-Sicherheitskontexts fehlgeschlagen" -#: libpq/auth.c:975 +#: libpq/auth.c:989 msgid "retrieving GSS user name failed" msgstr "Abfrage des GSS-Benutzernamens fehlgeschlagen" -#: libpq/auth.c:1094 +#: libpq/auth.c:1108 #, c-format msgid "SSPI is not supported in protocol version 2" msgstr "SSL wird in Protokollversion 2 nicht unterstützt" -#: libpq/auth.c:1109 +#: libpq/auth.c:1123 msgid "could not acquire SSPI credentials" msgstr "konnte SSPI-Credentials nicht erhalten" -#: libpq/auth.c:1127 +#: libpq/auth.c:1141 #, c-format msgid "expected SSPI response, got message type %d" msgstr "SSPI-Antwort erwartet, Message-Typ %d empfangen" -#: libpq/auth.c:1199 +#: libpq/auth.c:1213 msgid "could not accept SSPI security context" msgstr "konnte SSPI-Sicherheitskontext nicht akzeptieren" -#: libpq/auth.c:1261 +#: libpq/auth.c:1275 msgid "could not get token from SSPI security context" msgstr "konnte kein Token vom SSPI-Sicherheitskontext erhalten" -#: libpq/auth.c:1380 libpq/auth.c:1399 +#: libpq/auth.c:1394 libpq/auth.c:1413 #, c-format msgid "could not translate name" msgstr "konnte Namen nicht umwandeln" -#: libpq/auth.c:1412 +#: libpq/auth.c:1426 #, c-format msgid "realm name too long" msgstr "Realm-Name zu lang" -#: libpq/auth.c:1427 +#: libpq/auth.c:1441 #, c-format msgid "translated account name too long" msgstr "umgewandelter Account-Name zu lang" -#: libpq/auth.c:1613 +#: libpq/auth.c:1627 #, c-format msgid "could not create socket for Ident connection: %m" msgstr "konnte Socket für Ident-Verbindung nicht erzeugen: %m" -#: libpq/auth.c:1628 +#: libpq/auth.c:1642 #, c-format msgid "could not bind to local address \"%s\": %m" msgstr "konnte nicht mit lokaler Adresse »%s« verbinden: %m" -#: libpq/auth.c:1640 +#: libpq/auth.c:1654 #, c-format msgid "could not connect to Ident server at address \"%s\", port %s: %m" msgstr "konnte nicht mit Ident-Server auf Adresse »%s«, Port %s verbinden: %m" -#: libpq/auth.c:1662 +#: libpq/auth.c:1676 #, c-format msgid "could not send query to Ident server at address \"%s\", port %s: %m" msgstr "konnte Anfrage an Ident-Server auf Adresse »%s«, Port %s nicht senden: %m" -#: libpq/auth.c:1679 +#: libpq/auth.c:1693 #, c-format msgid "could not receive response from Ident server at address \"%s\", port %s: %m" msgstr "konnte Antwort von Ident-Server auf Adresse »%s«, Port %s nicht empfangen: %m" -#: libpq/auth.c:1689 +#: libpq/auth.c:1703 #, c-format msgid "invalidly formatted response from Ident server: \"%s\"" msgstr "ungültig formatierte Antwort vom Ident-Server: »%s«" -#: libpq/auth.c:1729 +#: libpq/auth.c:1743 #, c-format msgid "peer authentication is not supported on this platform" msgstr "Peer-Authentifizierung wird auf dieser Plattform nicht unterstützt" -#: libpq/auth.c:1733 +#: libpq/auth.c:1747 #, c-format msgid "could not get peer credentials: %m" msgstr "konnte Credentials von Gegenstelle nicht ermitteln: %m" -#: libpq/auth.c:1742 +#: libpq/auth.c:1756 #, c-format msgid "could not look up local user ID %ld: %s" msgstr "konnte lokale Benutzer-ID %ld nicht nachschlagen: %s" -#: libpq/auth.c:1826 libpq/auth.c:2152 libpq/auth.c:2512 -#, c-format -msgid "empty password returned by client" -msgstr "Client gab leeres Passwort zurück" - -#: libpq/auth.c:1836 +#: libpq/auth.c:1844 #, c-format msgid "error from underlying PAM layer: %s" msgstr "Fehler von der unteren PAM-Ebene: %s" -#: libpq/auth.c:1917 +#: libpq/auth.c:1925 #, c-format msgid "could not create PAM authenticator: %s" msgstr "konnte PAM-Authenticator nicht erzeugen: %s" -#: libpq/auth.c:1928 +#: libpq/auth.c:1936 #, c-format msgid "pam_set_item(PAM_USER) failed: %s" msgstr "pam_set_item(PAM_USER) fehlgeschlagen: %s" -#: libpq/auth.c:1939 +#: libpq/auth.c:1947 #, c-format msgid "pam_set_item(PAM_RHOST) failed: %s" msgstr "pam_set_item(PAM_RHOST) fehlgeschlagen: %s" -#: libpq/auth.c:1950 +#: libpq/auth.c:1958 #, c-format msgid "pam_set_item(PAM_CONV) failed: %s" msgstr "pam_set_item(PAM_CONV) fehlgeschlagen: %s" -#: libpq/auth.c:1961 +#: libpq/auth.c:1969 #, c-format msgid "pam_authenticate failed: %s" msgstr "pam_authenticate fehlgeschlagen: %s" -#: libpq/auth.c:1972 +#: libpq/auth.c:1980 #, c-format msgid "pam_acct_mgmt failed: %s" msgstr "pam_acct_mgmt fehlgeschlagen: %s" -#: libpq/auth.c:1983 +#: libpq/auth.c:1991 #, c-format msgid "could not release PAM authenticator: %s" msgstr "konnte PAM-Authenticator nicht freigeben: %s" -#: libpq/auth.c:2048 +#: libpq/auth.c:2056 #, c-format msgid "could not initialize LDAP: %m" msgstr "konnte LDAP nicht initialisieren: %m" -#: libpq/auth.c:2051 +#: libpq/auth.c:2059 #, c-format msgid "could not initialize LDAP: error code %d" msgstr "konnte LDAP nicht initialisieren: Fehlercode %d" -#: libpq/auth.c:2061 +#: libpq/auth.c:2069 #, c-format msgid "could not set LDAP protocol version: %s" msgstr "konnte LDAP-Protokollversion nicht setzen: %s" -#: libpq/auth.c:2090 +#: libpq/auth.c:2098 #, c-format msgid "could not load wldap32.dll" msgstr "konnte wldap32.dll nicht laden" -#: libpq/auth.c:2098 +#: libpq/auth.c:2106 #, c-format msgid "could not load function _ldap_start_tls_sA in wldap32.dll" msgstr "konnte Funktion _ldap_start_tls_sA in wldap32.dll nicht laden" -#: libpq/auth.c:2099 +#: libpq/auth.c:2107 #, c-format msgid "LDAP over SSL is not supported on this platform." msgstr "LDAP über SSL wird auf dieser Plattform nicht unterstützt." -#: libpq/auth.c:2114 +#: libpq/auth.c:2122 #, c-format msgid "could not start LDAP TLS session: %s" msgstr "konnte LDAP-TLS-Sitzung nicht starten: %s" -#: libpq/auth.c:2136 +#: libpq/auth.c:2144 #, c-format msgid "LDAP server not specified" msgstr "LDAP-Server nicht angegeben" -#: libpq/auth.c:2189 +#: libpq/auth.c:2192 #, c-format msgid "invalid character in user name for LDAP authentication" msgstr "ungültiges Zeichen im Benutzernamen für LDAP-Authentifizierung" -#: libpq/auth.c:2204 +#: libpq/auth.c:2207 #, c-format msgid "could not perform initial LDAP bind for ldapbinddn \"%s\" on server \"%s\": %s" msgstr "erstes LDAP-Binden für ldapbinddn »%s« auf Server »%s« fehlgeschlagen: %s" -#: libpq/auth.c:2228 +#: libpq/auth.c:2231 #, c-format msgid "could not search LDAP for filter \"%s\" on server \"%s\": %s" msgstr "konnte LDAP nicht mit Filter »%s« auf Server »%s« durchsuchen: %s" -#: libpq/auth.c:2239 +#: libpq/auth.c:2242 #, c-format msgid "LDAP user \"%s\" does not exist" msgstr "LDAP-Benutzer »%s« existiert nicht" -#: libpq/auth.c:2240 +#: libpq/auth.c:2243 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned no entries." msgstr "LDAP-Suche nach Filter »%s« auf Server »%s« gab keine Einträge zurück." -#: libpq/auth.c:2244 +#: libpq/auth.c:2247 #, c-format msgid "LDAP user \"%s\" is not unique" msgstr "LDAP-Benutzer »%s« ist nicht eindeutig" -#: libpq/auth.c:2245 +#: libpq/auth.c:2248 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned %d entry." msgid_plural "LDAP search for filter \"%s\" on server \"%s\" returned %d entries." msgstr[0] "LDAP-Suche nach Filter »%s« auf Server »%s« gab %d Eintrag zurück." msgstr[1] "LDAP-Suche nach Filter »%s« auf Server »%s« gab %d Einträge zurück." -#: libpq/auth.c:2263 +#: libpq/auth.c:2266 #, c-format msgid "could not get dn for the first entry matching \"%s\" on server \"%s\": %s" msgstr "konnte DN fÅ©r den ersten Treffer für »%s« auf Server »%s« nicht lesen: %s" -#: libpq/auth.c:2283 +#: libpq/auth.c:2286 #, c-format msgid "could not unbind after searching for user \"%s\" on server \"%s\": %s" msgstr "Losbinden fehlgeschlagen nach Suche nach Benutzer »%s« auf Server »%s«: %s" -#: libpq/auth.c:2313 +#: libpq/auth.c:2316 #, c-format msgid "LDAP login failed for user \"%s\" on server \"%s\": %s" msgstr "LDAP-Login fehlgeschlagen für Benutzer »%s« auf Server »%s«: %s" -#: libpq/auth.c:2341 +#: libpq/auth.c:2344 #, c-format msgid "certificate authentication failed for user \"%s\": client certificate contains no user name" msgstr "Zertifikatauthentifizierung für Benutzer »%s« fehlgeschlagen: Client-Zertifikat enthält keinen Benutzernamen" -#: libpq/auth.c:2468 +#: libpq/auth.c:2474 #, c-format msgid "RADIUS server not specified" msgstr "RADIUS-Server nicht angegeben" -#: libpq/auth.c:2475 +#: libpq/auth.c:2481 #, c-format msgid "RADIUS secret not specified" msgstr "RADIUS-Geheimnis nicht angegeben" -#: libpq/auth.c:2491 libpq/hba.c:1632 +#: libpq/auth.c:2497 libpq/hba.c:1632 #, c-format msgid "could not translate RADIUS server name \"%s\" to address: %s" msgstr "konnte RADIUS-Servername »%s« nicht in Adresse übersetzen: %s" -#: libpq/auth.c:2519 +#: libpq/auth.c:2518 #, c-format msgid "RADIUS authentication does not support passwords longer than %d characters" msgstr "RADIUS-Authentifizierung unterstützt keine Passwörter länger als %d Zeichen" -#: libpq/auth.c:2531 +#: libpq/auth.c:2530 #, c-format msgid "could not generate random encryption vector" msgstr "konnte zufälligen Verschlüsselungsvektor nicht erzeugen" -#: libpq/auth.c:2569 +#: libpq/auth.c:2568 #, c-format msgid "could not perform MD5 encryption of password" msgstr "konnte MD5-Verschlüsselung des Passworts nicht durchführen" -#: libpq/auth.c:2594 +#: libpq/auth.c:2593 #, c-format msgid "could not create RADIUS socket: %m" msgstr "konnte RADIUS-Socket nicht erstellen: %m" -#: libpq/auth.c:2615 +#: libpq/auth.c:2614 #, c-format msgid "could not bind local RADIUS socket: %m" msgstr "konnte lokales RADIUS-Socket nicht binden: %m" -#: libpq/auth.c:2625 +#: libpq/auth.c:2624 #, c-format msgid "could not send RADIUS packet: %m" msgstr "konnte RADIUS-Paket nicht senden: %m" -#: libpq/auth.c:2658 libpq/auth.c:2683 +#: libpq/auth.c:2657 libpq/auth.c:2682 #, c-format msgid "timeout waiting for RADIUS response" msgstr "Zeitüberschreitung beim Warten auf RADIUS-Antwort" -#: libpq/auth.c:2676 +#: libpq/auth.c:2675 #, c-format msgid "could not check status on RADIUS socket: %m" msgstr "konnte Status des RADIUS-Sockets nicht prüfen: %m" -#: libpq/auth.c:2705 +#: libpq/auth.c:2704 #, c-format msgid "could not read RADIUS response: %m" msgstr "konnte RADIUS-Antwort nicht lesen: %m" -#: libpq/auth.c:2717 libpq/auth.c:2721 +#: libpq/auth.c:2716 libpq/auth.c:2720 #, c-format msgid "RADIUS response was sent from incorrect port: %d" msgstr "RADIUS-Antwort wurde von falschem Port gesendet: %d" -#: libpq/auth.c:2730 +#: libpq/auth.c:2729 #, c-format msgid "RADIUS response too short: %d" msgstr "RADIUS-Antwort zu kurz: %d" -#: libpq/auth.c:2737 +#: libpq/auth.c:2736 #, c-format msgid "RADIUS response has corrupt length: %d (actual length %d)" msgstr "RADIUS-Antwort hat verfälschte Länge: %d (tatsächliche Länge %d)" -#: libpq/auth.c:2745 +#: libpq/auth.c:2744 #, c-format msgid "RADIUS response is to a different request: %d (should be %d)" msgstr "RADIUS-Antwort unterscheidet sich von Anfrage: %d (sollte %d sein)" -#: libpq/auth.c:2770 +#: libpq/auth.c:2769 #, c-format msgid "could not perform MD5 encryption of received packet" msgstr "konnte MD5-Verschlüsselung des empfangenen Pakets nicht durchführen" -#: libpq/auth.c:2779 +#: libpq/auth.c:2778 #, c-format msgid "RADIUS response has incorrect MD5 signature" msgstr "RADIUS-Antwort hat falsche MD5-Signatur" -#: libpq/auth.c:2796 +#: libpq/auth.c:2795 #, c-format msgid "RADIUS response has invalid code (%d) for user \"%s\"" msgstr "RADIUS-Antwort hat ungültigen Code (%d) für Benutzer »%s«" @@ -11265,7 +11093,7 @@ msgid "invalid large-object descriptor: %d" msgstr "ungültiger Large-Object-Deskriptor: %d" #: libpq/be-fsstubs.c:178 libpq/be-fsstubs.c:216 libpq/be-fsstubs.c:600 -#: libpq/be-fsstubs.c:788 +#: libpq/be-fsstubs.c:788 libpq/be-fsstubs.c:908 #, c-format msgid "permission denied for large object %u" msgstr "keine Berechtigung für Large Object %u" @@ -11380,87 +11208,87 @@ msgstr "konnte private Schlüsseldatei »%s« nicht laden: %s" msgid "check of private key failed: %s" msgstr "Ãœberprüfung des privaten Schlüssels fehlgeschlagen: %s" -#: libpq/be-secure-openssl.c:292 +#: libpq/be-secure-openssl.c:300 #, c-format msgid "could not load root certificate file \"%s\": %s" msgstr "konnte Root-Zertifikat-Datei »%s« nicht laden: %s" -#: libpq/be-secure-openssl.c:316 +#: libpq/be-secure-openssl.c:324 #, c-format msgid "SSL certificate revocation list file \"%s\" ignored" msgstr "SSL-Certificate-Revocation-List-Datei »%s« ignoriert" -#: libpq/be-secure-openssl.c:318 +#: libpq/be-secure-openssl.c:326 #, c-format msgid "SSL library does not support certificate revocation lists." msgstr "SSL-Bibliothek unterstützt keine Certificate-Revocation-Lists." -#: libpq/be-secure-openssl.c:323 +#: libpq/be-secure-openssl.c:331 #, c-format msgid "could not load SSL certificate revocation list file \"%s\": %s" msgstr "konnte SSL-Certificate-Revocation-List-Datei »%s« nicht laden: %s" -#: libpq/be-secure-openssl.c:370 +#: libpq/be-secure-openssl.c:378 #, c-format msgid "could not initialize SSL connection: %s" msgstr "konnte SSL-Verbindung nicht initialisieren: %s" -#: libpq/be-secure-openssl.c:378 +#: libpq/be-secure-openssl.c:386 #, c-format msgid "could not set SSL socket: %s" msgstr "konnte SSL-Socket nicht setzen: %s" -#: libpq/be-secure-openssl.c:432 +#: libpq/be-secure-openssl.c:440 #, c-format msgid "could not accept SSL connection: %m" msgstr "konnte SSL-Verbindung nicht annehmen: %m" -#: libpq/be-secure-openssl.c:436 libpq/be-secure-openssl.c:447 +#: libpq/be-secure-openssl.c:444 libpq/be-secure-openssl.c:455 #, c-format msgid "could not accept SSL connection: EOF detected" msgstr "konnte SSL-Verbindung nicht annehmen: EOF entdeckt" -#: libpq/be-secure-openssl.c:441 +#: libpq/be-secure-openssl.c:449 #, c-format msgid "could not accept SSL connection: %s" msgstr "konnte SSL-Verbindung nicht annehmen: %s" -#: libpq/be-secure-openssl.c:452 libpq/be-secure-openssl.c:593 -#: libpq/be-secure-openssl.c:653 +#: libpq/be-secure-openssl.c:460 libpq/be-secure-openssl.c:603 +#: libpq/be-secure-openssl.c:669 #, c-format msgid "unrecognized SSL error code: %d" msgstr "unbekannter SSL-Fehlercode: %d" -#: libpq/be-secure-openssl.c:496 +#: libpq/be-secure-openssl.c:504 #, c-format msgid "SSL certificate's common name contains embedded null" msgstr "Common-Name im SSL-Zertifikat enthält Null-Byte" -#: libpq/be-secure-openssl.c:507 +#: libpq/be-secure-openssl.c:515 #, c-format msgid "SSL connection from \"%s\"" msgstr "SSL-Verbindung von »%s«" -#: libpq/be-secure-openssl.c:584 libpq/be-secure-openssl.c:644 +#: libpq/be-secure-openssl.c:592 libpq/be-secure-openssl.c:654 #, c-format msgid "SSL error: %s" msgstr "SSL-Fehler: %s" -#: libpq/be-secure-openssl.c:1055 +#: libpq/be-secure-openssl.c:1071 #, c-format msgid "ECDH: unrecognized curve name: %s" msgstr "ECDH: unbekannter Kurvenname: %s" -#: libpq/be-secure-openssl.c:1060 +#: libpq/be-secure-openssl.c:1076 #, c-format msgid "ECDH: could not create key" msgstr "ECDH: konnte Schlüssel nicht erzeugen" -#: libpq/be-secure-openssl.c:1084 +#: libpq/be-secure-openssl.c:1100 msgid "no SSL error reported" msgstr "kein SSL-Fehler berichtet" -#: libpq/be-secure-openssl.c:1088 +#: libpq/be-secure-openssl.c:1104 #, c-format msgid "SSL error code %lu" msgstr "SSL-Fehlercode %lu" @@ -11480,17 +11308,17 @@ msgstr "Rolle »%s« existiert nicht." msgid "User \"%s\" has no password assigned." msgstr "Benutzer »%s« hat kein Passwort zugewiesen." -#: libpq/crypt.c:79 +#: libpq/crypt.c:88 libpq/crypt.c:103 #, c-format msgid "User \"%s\" has an empty password." msgstr "Benutzer »%s« hat ein leeres Passwort." -#: libpq/crypt.c:159 +#: libpq/crypt.c:184 #, c-format msgid "User \"%s\" has an expired password." msgstr "Benutzer »%s« hat ein abgelaufenes Passwort." -#: libpq/crypt.c:167 +#: libpq/crypt.c:192 #, c-format msgid "Password does not match for user \"%s\"." msgstr "Passwort stimmt nicht überein für Benutzer »%s«." @@ -11802,137 +11630,137 @@ msgstr "kein passender Eintrag in Usermap »%s« für Benutzer »%s«, authentif msgid "could not open usermap file \"%s\": %m" msgstr "konnte Usermap-Datei »%s« nicht öffnen: %m" -#: libpq/pqcomm.c:202 +#: libpq/pqcomm.c:221 #, c-format msgid "could not set socket to nonblocking mode: %m" msgstr "konnte Socket nicht auf nicht-blockierenden Modus umstellen: %m" -#: libpq/pqcomm.c:354 +#: libpq/pqcomm.c:373 #, c-format msgid "Unix-domain socket path \"%s\" is too long (maximum %d bytes)" msgstr "Unix-Domain-Socket-Pfad »%s« ist zu lang (maximal %d Bytes)" -#: libpq/pqcomm.c:375 +#: libpq/pqcomm.c:394 #, c-format msgid "could not translate host name \"%s\", service \"%s\" to address: %s" msgstr "konnte Hostname »%s«, Dienst »%s« nicht in Adresse übersetzen: %s" -#: libpq/pqcomm.c:379 +#: libpq/pqcomm.c:398 #, c-format msgid "could not translate service \"%s\" to address: %s" msgstr "konnte Dienst »%s« nicht in Adresse übersetzen: %s" -#: libpq/pqcomm.c:406 +#: libpq/pqcomm.c:425 #, c-format msgid "could not bind to all requested addresses: MAXLISTEN (%d) exceeded" msgstr "konnte nicht an alle verlangten Adressen binden: MAXLISTEN (%d) überschritten" -#: libpq/pqcomm.c:415 +#: libpq/pqcomm.c:434 msgid "IPv4" msgstr "IPv4" -#: libpq/pqcomm.c:419 +#: libpq/pqcomm.c:438 msgid "IPv6" msgstr "IPv6" -#: libpq/pqcomm.c:424 +#: libpq/pqcomm.c:443 msgid "Unix" msgstr "Unix" -#: libpq/pqcomm.c:429 +#: libpq/pqcomm.c:448 #, c-format msgid "unrecognized address family %d" msgstr "unbekannte Adressfamilie %d" #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:440 +#: libpq/pqcomm.c:459 #, c-format msgid "could not create %s socket: %m" msgstr "konnte %s-Socket nicht erstellen: %m" -#: libpq/pqcomm.c:465 +#: libpq/pqcomm.c:484 #, c-format msgid "setsockopt(SO_REUSEADDR) failed: %m" msgstr "setsockopt(SO_REUSEADDR) fehlgeschlagen: %m" -#: libpq/pqcomm.c:480 +#: libpq/pqcomm.c:499 #, c-format msgid "setsockopt(IPV6_V6ONLY) failed: %m" msgstr "setsockopt(IPV6_V6ONLY) fehlgeschlagen: %m" #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:499 +#: libpq/pqcomm.c:518 #, c-format msgid "could not bind %s socket: %m" msgstr "konnte %s-Socket nicht binden: %m" -#: libpq/pqcomm.c:502 +#: libpq/pqcomm.c:521 #, c-format msgid "Is another postmaster already running on port %d? If not, remove socket file \"%s\" and retry." msgstr "Läuft bereits ein anderer Postmaster auf Port %d? Wenn nicht, entfernen Sie die Socketdatei »%s« und versuchen Sie erneut." -#: libpq/pqcomm.c:505 +#: libpq/pqcomm.c:524 #, c-format msgid "Is another postmaster already running on port %d? If not, wait a few seconds and retry." msgstr "Läuft bereits ein anderer Postmaster auf Port %d? Wenn nicht, warten Sie einige Sekunden und versuchen Sie erneut." #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:538 +#: libpq/pqcomm.c:557 #, c-format msgid "could not listen on %s socket: %m" msgstr "konnte nicht auf %s-Socket hören: %m" -#: libpq/pqcomm.c:623 +#: libpq/pqcomm.c:642 #, c-format msgid "group \"%s\" does not exist" msgstr "Gruppe »%s« existiert nicht" -#: libpq/pqcomm.c:633 +#: libpq/pqcomm.c:652 #, c-format msgid "could not set group of file \"%s\": %m" msgstr "konnte Gruppe von Datei »%s« nicht setzen: %m" -#: libpq/pqcomm.c:644 +#: libpq/pqcomm.c:663 #, c-format msgid "could not set permissions of file \"%s\": %m" msgstr "konnte Zugriffsrechte von Datei »%s« nicht setzen: %m" -#: libpq/pqcomm.c:674 +#: libpq/pqcomm.c:693 #, c-format msgid "could not accept new connection: %m" msgstr "konnte neue Verbindung nicht akzeptieren: %m" -#: libpq/pqcomm.c:885 +#: libpq/pqcomm.c:904 #, c-format msgid "there is no client connection" msgstr "es besteht keine Client-Verbindung" -#: libpq/pqcomm.c:936 libpq/pqcomm.c:1032 +#: libpq/pqcomm.c:955 libpq/pqcomm.c:1051 #, c-format msgid "could not receive data from client: %m" msgstr "konnte Daten vom Client nicht empfangen: %m" -#: libpq/pqcomm.c:1177 tcop/postgres.c:3917 +#: libpq/pqcomm.c:1196 tcop/postgres.c:3915 #, c-format msgid "terminating connection because protocol synchronization was lost" msgstr "Verbindung wird abgebrochen, weil Protokollsynchronisierung verloren wurde" -#: libpq/pqcomm.c:1243 +#: libpq/pqcomm.c:1262 #, c-format msgid "unexpected EOF within message length word" msgstr "unerwartetes EOF im Message-Längenwort" -#: libpq/pqcomm.c:1254 +#: libpq/pqcomm.c:1273 #, c-format msgid "invalid message length" msgstr "ungültige Message-Länge" -#: libpq/pqcomm.c:1276 libpq/pqcomm.c:1289 +#: libpq/pqcomm.c:1295 libpq/pqcomm.c:1308 #, c-format msgid "incomplete message from client" msgstr "unvollständige Message vom Client" -#: libpq/pqcomm.c:1422 +#: libpq/pqcomm.c:1441 #, c-format msgid "could not send data to client: %m" msgstr "konnte Daten nicht an den Client senden: %m" @@ -12304,7 +12132,7 @@ msgid "could not implement GROUP BY" msgstr "konnte GROUP BY nicht implementieren" #: optimizer/plan/planner.c:3810 optimizer/plan/planner.c:4203 -#: optimizer/prep/prepunion.c:929 +#: optimizer/prep/prepunion.c:939 #, c-format msgid "Some of the datatypes only support hashing, while others only support sorting." msgstr "Einige Datentypen unterstützen nur Hashing, während andere nur Sortieren unterstützen." @@ -12339,18 +12167,18 @@ msgstr "Fenstersortierspalten müssen sortierbare Datentypen haben." msgid "too many range table entries" msgstr "zu viele Range-Table-Einträge" -#: optimizer/prep/prepunion.c:484 +#: optimizer/prep/prepunion.c:494 #, c-format msgid "could not implement recursive UNION" msgstr "konnte rekursive UNION nicht implementieren" -#: optimizer/prep/prepunion.c:485 +#: optimizer/prep/prepunion.c:495 #, c-format msgid "All column datatypes must be hashable." msgstr "Alle Spaltendatentypen müssen hashbar sein." #. translator: %s is UNION, INTERSECT, or EXCEPT -#: optimizer/prep/prepunion.c:928 +#: optimizer/prep/prepunion.c:938 #, c-format msgid "could not implement %s" msgstr "konnte %s nicht implementieren" @@ -13579,8 +13407,8 @@ msgstr "Arrayindex muss Typ integer haben" msgid "array assignment requires type %s but expression is of type %s" msgstr "Arrayzuweisung erfordert Typ %s, aber Ausdruck hat Typ %s" -#: parser/parse_oper.c:125 parser/parse_oper.c:722 utils/adt/regproc.c:583 -#: utils/adt/regproc.c:603 utils/adt/regproc.c:787 +#: parser/parse_oper.c:125 parser/parse_oper.c:722 utils/adt/regproc.c:584 +#: utils/adt/regproc.c:604 utils/adt/regproc.c:788 #, c-format msgid "operator does not exist: %s" msgstr "Operator existiert nicht: %s" @@ -13834,219 +13662,219 @@ msgstr "Typmodifikatoren müssen einfache Konstanten oder Bezeichner sein" msgid "invalid type name \"%s\"" msgstr "ungültiger Typname: »%s«" -#: parser/parse_utilcmd.c:384 +#: parser/parse_utilcmd.c:385 #, c-format msgid "array of serial is not implemented" msgstr "Array aus Typ serial ist nicht implementiert" -#: parser/parse_utilcmd.c:432 +#: parser/parse_utilcmd.c:433 #, c-format msgid "%s will create implicit sequence \"%s\" for serial column \"%s.%s\"" msgstr "%s erstellt implizit eine Sequenz »%s« für die »serial«-Spalte »%s.%s«" -#: parser/parse_utilcmd.c:526 parser/parse_utilcmd.c:538 +#: parser/parse_utilcmd.c:527 parser/parse_utilcmd.c:539 #, c-format msgid "conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"" msgstr "widersprüchliche NULL/NOT NULL-Deklarationen für Spalte »%s« von Tabelle »%s«" -#: parser/parse_utilcmd.c:550 +#: parser/parse_utilcmd.c:551 #, c-format msgid "multiple default values specified for column \"%s\" of table \"%s\"" msgstr "mehrere Vorgabewerte angegeben für Spalte »%s« von Tabelle »%s«" -#: parser/parse_utilcmd.c:567 parser/parse_utilcmd.c:658 +#: parser/parse_utilcmd.c:568 parser/parse_utilcmd.c:659 #, c-format msgid "primary key constraints are not supported on foreign tables" msgstr "Primärschlüssel für Fremdtabellen werden nicht unterstützt" -#: parser/parse_utilcmd.c:576 parser/parse_utilcmd.c:668 +#: parser/parse_utilcmd.c:577 parser/parse_utilcmd.c:669 #, c-format msgid "unique constraints are not supported on foreign tables" msgstr "Unique-Constraints auf Fremdtabellen werden nicht unterstützt" -#: parser/parse_utilcmd.c:593 parser/parse_utilcmd.c:692 +#: parser/parse_utilcmd.c:594 parser/parse_utilcmd.c:693 #, c-format msgid "foreign key constraints are not supported on foreign tables" msgstr "Fremdschlüssel-Constraints auf Fremdtabellen werden nicht unterstützt" -#: parser/parse_utilcmd.c:678 +#: parser/parse_utilcmd.c:679 #, c-format msgid "exclusion constraints are not supported on foreign tables" msgstr "Exclusion-Constraints auf Fremdtabellen werden nicht unterstützt" -#: parser/parse_utilcmd.c:742 +#: parser/parse_utilcmd.c:743 #, c-format msgid "LIKE is not supported for creating foreign tables" msgstr "LIKE wird für das Erzeugen von Fremdtabellen nicht unterstützt" -#: parser/parse_utilcmd.c:1275 parser/parse_utilcmd.c:1351 +#: parser/parse_utilcmd.c:1276 parser/parse_utilcmd.c:1352 #, c-format msgid "Index \"%s\" contains a whole-row table reference." msgstr "Index »%s« enthält einen Verweis auf die ganze Zeile der Tabelle." -#: parser/parse_utilcmd.c:1621 +#: parser/parse_utilcmd.c:1622 #, c-format msgid "cannot use an existing index in CREATE TABLE" msgstr "bestehender Index kann nicht in CREATE TABLE verwendet werden" -#: parser/parse_utilcmd.c:1641 +#: parser/parse_utilcmd.c:1642 #, c-format msgid "index \"%s\" is already associated with a constraint" msgstr "Index »%s« gehört bereits zu einem Constraint" -#: parser/parse_utilcmd.c:1649 +#: parser/parse_utilcmd.c:1650 #, c-format msgid "index \"%s\" does not belong to table \"%s\"" msgstr "Index »%s« gehört nicht zu Tabelle »%s«" -#: parser/parse_utilcmd.c:1656 +#: parser/parse_utilcmd.c:1657 #, c-format msgid "index \"%s\" is not valid" msgstr "Index »%s« ist nicht gültig" -#: parser/parse_utilcmd.c:1662 +#: parser/parse_utilcmd.c:1663 #, c-format msgid "\"%s\" is not a unique index" msgstr "»%s« ist kein Unique Index" -#: parser/parse_utilcmd.c:1663 parser/parse_utilcmd.c:1670 -#: parser/parse_utilcmd.c:1677 parser/parse_utilcmd.c:1747 +#: parser/parse_utilcmd.c:1664 parser/parse_utilcmd.c:1671 +#: parser/parse_utilcmd.c:1678 parser/parse_utilcmd.c:1748 #, c-format msgid "Cannot create a primary key or unique constraint using such an index." msgstr "Ein Primärschlüssel oder Unique-Constraint kann nicht mit einem solchen Index erzeugt werden." -#: parser/parse_utilcmd.c:1669 +#: parser/parse_utilcmd.c:1670 #, c-format msgid "index \"%s\" contains expressions" msgstr "Index »%s« enthält Ausdrücke" -#: parser/parse_utilcmd.c:1676 +#: parser/parse_utilcmd.c:1677 #, c-format msgid "\"%s\" is a partial index" msgstr "»%s« ist ein partieller Index" -#: parser/parse_utilcmd.c:1688 +#: parser/parse_utilcmd.c:1689 #, c-format msgid "\"%s\" is a deferrable index" msgstr "»%s« ist ein aufschiebbarer Index" -#: parser/parse_utilcmd.c:1689 +#: parser/parse_utilcmd.c:1690 #, c-format msgid "Cannot create a non-deferrable constraint using a deferrable index." msgstr "Ein nicht aufschiebbarer Constraint kann nicht mit einem aufschiebbaren Index erzeugt werden." -#: parser/parse_utilcmd.c:1746 +#: parser/parse_utilcmd.c:1747 #, c-format msgid "index \"%s\" does not have default sorting behavior" msgstr "Index »%s« hat nicht das Standardsortierverhalten" -#: parser/parse_utilcmd.c:1893 +#: parser/parse_utilcmd.c:1894 #, c-format msgid "column \"%s\" appears twice in primary key constraint" msgstr "Spalte »%s« erscheint zweimal im Primärschlüssel-Constraint" -#: parser/parse_utilcmd.c:1899 +#: parser/parse_utilcmd.c:1900 #, c-format msgid "column \"%s\" appears twice in unique constraint" msgstr "Spalte »%s« erscheint zweimal im Unique-Constraint" -#: parser/parse_utilcmd.c:2103 +#: parser/parse_utilcmd.c:2104 #, c-format msgid "index expression cannot return a set" msgstr "Indexausdruck kann keine Ergebnismenge zurückgeben" -#: parser/parse_utilcmd.c:2114 +#: parser/parse_utilcmd.c:2115 #, c-format msgid "index expressions and predicates can refer only to the table being indexed" msgstr "Indexausdrücke und -prädikate können nur auf die zu indizierende Tabelle verweisen" -#: parser/parse_utilcmd.c:2160 +#: parser/parse_utilcmd.c:2161 #, c-format msgid "rules on materialized views are not supported" msgstr "Regeln für materialisierte Sichten werden nicht unterstützt" -#: parser/parse_utilcmd.c:2221 +#: parser/parse_utilcmd.c:2222 #, c-format msgid "rule WHERE condition cannot contain references to other relations" msgstr "WHERE-Bedingung einer Regel kann keine Verweise auf andere Relationen enthalten" -#: parser/parse_utilcmd.c:2293 +#: parser/parse_utilcmd.c:2294 #, c-format msgid "rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE actions" msgstr "Regeln mit WHERE-Bedingungen können als Aktion nur SELECT, INSERT, UPDATE oder DELETE haben" -#: parser/parse_utilcmd.c:2311 parser/parse_utilcmd.c:2410 +#: parser/parse_utilcmd.c:2312 parser/parse_utilcmd.c:2411 #: rewrite/rewriteHandler.c:485 rewrite/rewriteManip.c:1015 #, c-format msgid "conditional UNION/INTERSECT/EXCEPT statements are not implemented" msgstr "UNION/INTERSECTION/EXCEPT mit Bedingung sind nicht implementiert" -#: parser/parse_utilcmd.c:2329 +#: parser/parse_utilcmd.c:2330 #, c-format msgid "ON SELECT rule cannot use OLD" msgstr "ON-SELECT-Regel kann nicht OLD verwenden" -#: parser/parse_utilcmd.c:2333 +#: parser/parse_utilcmd.c:2334 #, c-format msgid "ON SELECT rule cannot use NEW" msgstr "ON-SELECT-Regel kann nicht NEW verwenden" -#: parser/parse_utilcmd.c:2342 +#: parser/parse_utilcmd.c:2343 #, c-format msgid "ON INSERT rule cannot use OLD" msgstr "ON-INSERT-Regel kann nicht OLD verwenden" -#: parser/parse_utilcmd.c:2348 +#: parser/parse_utilcmd.c:2349 #, c-format msgid "ON DELETE rule cannot use NEW" msgstr "ON-DELETE-Regel kann nicht NEW verwenden" -#: parser/parse_utilcmd.c:2376 +#: parser/parse_utilcmd.c:2377 #, c-format msgid "cannot refer to OLD within WITH query" msgstr "in WITH-Anfrage kann nicht auf OLD verweisen werden" -#: parser/parse_utilcmd.c:2383 +#: parser/parse_utilcmd.c:2384 #, c-format msgid "cannot refer to NEW within WITH query" msgstr "in WITH-Anfrage kann nicht auf NEW verwiesen werden" -#: parser/parse_utilcmd.c:2586 +#: parser/parse_utilcmd.c:2587 #, c-format msgid "transform expression must not return a set" msgstr "Umwandlungsausdruck kann keine Ergebnismenge zurückgeben" -#: parser/parse_utilcmd.c:2700 +#: parser/parse_utilcmd.c:2701 #, c-format msgid "misplaced DEFERRABLE clause" msgstr "falsch platzierte DEFERRABLE-Klausel" -#: parser/parse_utilcmd.c:2705 parser/parse_utilcmd.c:2720 +#: parser/parse_utilcmd.c:2706 parser/parse_utilcmd.c:2721 #, c-format msgid "multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed" msgstr "mehrere DEFERRABLE/NOT DEFERRABLE-Klauseln sind nicht erlaubt" -#: parser/parse_utilcmd.c:2715 +#: parser/parse_utilcmd.c:2716 #, c-format msgid "misplaced NOT DEFERRABLE clause" msgstr "falsch platzierte NOT DEFERRABLE-Klausel" -#: parser/parse_utilcmd.c:2736 +#: parser/parse_utilcmd.c:2737 #, c-format msgid "misplaced INITIALLY DEFERRED clause" msgstr "falsch platzierte INITIALLY DEFERRED-Klausel" -#: parser/parse_utilcmd.c:2741 parser/parse_utilcmd.c:2767 +#: parser/parse_utilcmd.c:2742 parser/parse_utilcmd.c:2768 #, c-format msgid "multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed" msgstr "mehrere INITIALLY IMMEDIATE/DEFERRED-Klauseln sind nicht erlaubt" -#: parser/parse_utilcmd.c:2762 +#: parser/parse_utilcmd.c:2763 #, c-format msgid "misplaced INITIALLY IMMEDIATE clause" msgstr "falsch platzierte INITIALLY IMMEDIATE-Klausel" -#: parser/parse_utilcmd.c:2953 +#: parser/parse_utilcmd.c:2954 #, c-format msgid "CREATE specifies a schema (%s) different from the one being created (%s)" msgstr "CREATE gibt ein Schema an (%s) welches nicht gleich dem zu erzeugenden Schema ist (%s)" @@ -14080,17 +13908,17 @@ msgstr "" msgid "You possibly need to raise your kernel's SEMVMX value to be at least %d. Look into the PostgreSQL documentation for details." msgstr "Sie müssen möglicherweise den Kernelparameter SEMVMX auf mindestens %d erhöhen. Weitere Informationen finden Sie in der PostgreSQL-Dokumentation." -#: port/pg_shmem.c:175 port/sysv_shmem.c:175 +#: port/pg_shmem.c:195 port/sysv_shmem.c:195 #, c-format msgid "could not create shared memory segment: %m" msgstr "konnte Shared-Memory-Segment nicht erzeugen: %m" -#: port/pg_shmem.c:176 port/sysv_shmem.c:176 +#: port/pg_shmem.c:196 port/sysv_shmem.c:196 #, c-format msgid "Failed system call was shmget(key=%lu, size=%zu, 0%o)." msgstr "Fehlgeschlagener Systemaufruf war shmget(Key=%lu, Größe=%zu, 0%o)." -#: port/pg_shmem.c:180 port/sysv_shmem.c:180 +#: port/pg_shmem.c:200 port/sysv_shmem.c:200 #, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter, or possibly that it is less than your kernel's SHMMIN parameter.\n" @@ -14099,7 +13927,7 @@ msgstr "" "Dieser Fehler bedeutet gewöhnlich, dass das von PostgreSQL angeforderte Shared-Memory-Segment den Kernel-Parameter SHMMAX überschreitet, oder eventuell, dass es kleiner als der Kernel-Parameter SHMMIN ist.\n" "Die PostgreSQL-Dokumentation enthält weitere Informationen über die Konfiguration von Shared Memory." -#: port/pg_shmem.c:187 port/sysv_shmem.c:187 +#: port/pg_shmem.c:207 port/sysv_shmem.c:207 #, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMALL parameter. You might need to reconfigure the kernel with larger SHMALL.\n" @@ -14108,7 +13936,7 @@ msgstr "" "Dieser Fehler bedeutet gewöhnlich, dass das von PostgreSQL angeforderte Shared-Memory-Segment den Kernel-Parameter SHMALL überschreitet. Sie müssen eventuell den Kernel mit einem größeren SHMALL neu konfigurieren.\n" "Die PostgreSQL-Dokumentation enthält weitere Informationen über die Konfiguration von Shared Memory." -#: port/pg_shmem.c:193 port/sysv_shmem.c:193 +#: port/pg_shmem.c:213 port/sysv_shmem.c:213 #, c-format msgid "" "This error does *not* mean that you have run out of disk space. It occurs either if all available shared memory IDs have been taken, in which case you need to raise the SHMMNI parameter in your kernel, or because the system's overall limit for shared memory has been reached.\n" @@ -14117,24 +13945,24 @@ msgstr "" "Dieser Fehler bedeutet *nicht*, dass kein Platz mehr auf der Festplatte ist. Er tritt auf, wenn entweder alle verfügbaren Shared-Memory-IDs aufgebraucht sind, dann müssen den Kernelparameter SHMMNI erhöhen, oder weil die Systemhöchstgrenze für Shared Memory insgesamt erreicht wurde.\n" "Die PostgreSQL-Dokumentation enthält weitere Informationen über die Konfiguration von Shared Memory." -#: port/pg_shmem.c:483 port/sysv_shmem.c:483 +#: port/pg_shmem.c:504 port/sysv_shmem.c:504 #, c-format msgid "could not map anonymous shared memory: %m" msgstr "konnte anonymes Shared Memory nicht mappen: %m" -#: port/pg_shmem.c:485 port/sysv_shmem.c:485 +#: port/pg_shmem.c:506 port/sysv_shmem.c:506 #, c-format msgid "This error usually means that PostgreSQL's request for a shared memory segment exceeded available memory, swap space, or huge pages. To reduce the request size (currently %zu bytes), reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections." msgstr "" "Dieser Fehler bedeutet gewöhnlich, dass das von PostgreSQL angeforderte Shared-Memory-Segment den verfügbaren Speicher, Swap-Space oder Huge Pages überschreitet. Um die benötigte Shared-Memory-Größe zu reduzieren (aktuell %zu Bytes), reduzieren Sie den Shared-Memory-Verbrauch von PostgreSQL, beispielsweise indem Sie »shared_buffers« oder »max_connections« reduzieren.\n" "Die PostgreSQL-Dokumentation enthält weitere Informationen über die Konfiguration von Shared Memory." -#: port/pg_shmem.c:551 port/sysv_shmem.c:551 port/win32_shmem.c:134 +#: port/pg_shmem.c:572 port/sysv_shmem.c:572 port/win32_shmem.c:134 #, c-format msgid "huge pages not supported on this platform" msgstr "Huge Pages werden auf dieser Plattform nicht unterstützt" -#: port/pg_shmem.c:646 port/sysv_shmem.c:646 +#: port/pg_shmem.c:667 port/sysv_shmem.c:667 #, c-format msgid "could not stat data directory \"%s\": %m" msgstr "konnte »stat« für Datenverzeichnis »%s« nicht ausführen: %m" @@ -14284,59 +14112,59 @@ msgstr "Autovacuum wegen Fehlkonfiguration nicht gestartet" msgid "Enable the \"track_counts\" option." msgstr "Schalten Sie die Option »track_counts« ein." -#: postmaster/bgworker.c:346 postmaster/bgworker.c:745 +#: postmaster/bgworker.c:367 postmaster/bgworker.c:762 #, c-format msgid "registering background worker \"%s\"" msgstr "registriere Background-Worker »%s«" -#: postmaster/bgworker.c:375 +#: postmaster/bgworker.c:396 #, c-format msgid "unregistering background worker \"%s\"" msgstr "deregistriere Background-Worker »%s«" -#: postmaster/bgworker.c:484 +#: postmaster/bgworker.c:505 #, c-format msgid "background worker \"%s\": must attach to shared memory in order to request a database connection" msgstr "Background-Worker »%s«: muss mit Shared Memory verbinden, um eine Datenbankverbindung anzufordern" -#: postmaster/bgworker.c:493 +#: postmaster/bgworker.c:514 #, c-format msgid "background worker \"%s\": cannot request database access if starting at postmaster start" msgstr "Background-Worker »%s«: kann kein Datenbankzugriff anfordern, wenn er nach Postmaster-Start gestartet hat" -#: postmaster/bgworker.c:507 +#: postmaster/bgworker.c:528 #, c-format msgid "background worker \"%s\": invalid restart interval" msgstr "Background-Worker »%s«: ungültiges Neustart-Intervall" -#: postmaster/bgworker.c:552 +#: postmaster/bgworker.c:573 #, c-format msgid "terminating background worker \"%s\" due to administrator command" msgstr "Background-Worker »%s« wird abgebrochen aufgrund von Anweisung des Administrators" -#: postmaster/bgworker.c:752 +#: postmaster/bgworker.c:769 #, c-format msgid "background worker \"%s\": must be registered in shared_preload_libraries" msgstr "Background-Worker »%s«: muss in shared_preload_libraries registriert sein" -#: postmaster/bgworker.c:764 +#: postmaster/bgworker.c:781 #, c-format msgid "background worker \"%s\": only dynamic background workers can request notification" msgstr "Background-Worker »%s«: nur dynamische Background-Worker können Benachrichtigung verlangen" -#: postmaster/bgworker.c:779 +#: postmaster/bgworker.c:796 #, c-format msgid "too many background workers" msgstr "zu viele Background-Worker" -#: postmaster/bgworker.c:780 +#: postmaster/bgworker.c:797 #, c-format msgid "Up to %d background worker can be registered with the current settings." msgid_plural "Up to %d background workers can be registered with the current settings." msgstr[0] "Mit den aktuellen Einstellungen können bis zu %d Background-Worker registriert werden." msgstr[1] "Mit den aktuellen Einstellungen können bis zu %d Background-Worker registriert werden." -#: postmaster/bgworker.c:784 +#: postmaster/bgworker.c:801 #, c-format msgid "Consider increasing the configuration parameter \"max_worker_processes\"." msgstr "Erhöhen Sie eventuell den Konfigurationsparameter »max_worker_processes«." @@ -14404,7 +14232,7 @@ msgstr "Der fehlgeschlagene Archivbefehl war: %s" msgid "archive command was terminated by exception 0x%X" msgstr "Archivbefehl wurde durch Ausnahme 0x%X beendet" -#: postmaster/pgarch.c:598 postmaster/postmaster.c:3491 +#: postmaster/pgarch.c:598 postmaster/postmaster.c:3514 #, c-format msgid "See C include file \"ntstatus.h\" for a description of the hexadecimal value." msgstr "Sehen Sie die Beschreibung des Hexadezimalwerts in der C-Include-Datei »ntstatus.h« nach." @@ -14434,293 +14262,293 @@ msgstr "archivierte Transaktionslogdatei »%s«" msgid "could not open archive status directory \"%s\": %m" msgstr "konnte Archivstatusverzeichnis »%s« nicht öffnen: %m" -#: postmaster/pgstat.c:355 +#: postmaster/pgstat.c:358 #, c-format msgid "could not resolve \"localhost\": %s" msgstr "konnte »localhost« nicht auflösen: %s" -#: postmaster/pgstat.c:378 +#: postmaster/pgstat.c:381 #, c-format msgid "trying another address for the statistics collector" msgstr "andere Adresse für Statistiksammelprozess wird versucht" -#: postmaster/pgstat.c:387 +#: postmaster/pgstat.c:390 #, c-format msgid "could not create socket for statistics collector: %m" msgstr "konnte Socket für Statistiksammelprozess nicht erzeugen: %m" -#: postmaster/pgstat.c:399 +#: postmaster/pgstat.c:402 #, c-format msgid "could not bind socket for statistics collector: %m" msgstr "konnte Socket für Statistiksammelprozess nicht binden: %m" -#: postmaster/pgstat.c:410 +#: postmaster/pgstat.c:413 #, c-format msgid "could not get address of socket for statistics collector: %m" msgstr "konnte Adresse für Socket für Statistiksammelprozess nicht ermitteln: %m" -#: postmaster/pgstat.c:426 +#: postmaster/pgstat.c:429 #, c-format msgid "could not connect socket for statistics collector: %m" msgstr "konnte nicht mit Socket für Statistiksammelprozess verbinden: %m" -#: postmaster/pgstat.c:447 +#: postmaster/pgstat.c:450 #, c-format msgid "could not send test message on socket for statistics collector: %m" msgstr "konnte Testnachricht auf Socket für Statistiksammelprozess nicht senden: %m" -#: postmaster/pgstat.c:473 +#: postmaster/pgstat.c:476 #, c-format msgid "select() failed in statistics collector: %m" msgstr "select() im Statistiksammelprozess fehlgeschlagen: %m" -#: postmaster/pgstat.c:488 +#: postmaster/pgstat.c:491 #, c-format msgid "test message did not get through on socket for statistics collector" msgstr "Testnachricht auf Socket für Statistiksammelprozess kam nicht durch" -#: postmaster/pgstat.c:503 +#: postmaster/pgstat.c:506 #, c-format msgid "could not receive test message on socket for statistics collector: %m" msgstr "konnte Testnachricht auf Socket für Statistiksammelprozess nicht empfangen: %m" -#: postmaster/pgstat.c:513 +#: postmaster/pgstat.c:516 #, c-format msgid "incorrect test message transmission on socket for statistics collector" msgstr "fehlerhafte Ãœbertragung der Testnachricht auf Socket für Statistiksammelprozess" -#: postmaster/pgstat.c:536 +#: postmaster/pgstat.c:539 #, c-format msgid "could not set statistics collector socket to nonblocking mode: %m" msgstr "konnte Socket von Statistiksammelprozess nicht auf nicht blockierenden Modus setzen: %m" -#: postmaster/pgstat.c:546 +#: postmaster/pgstat.c:578 #, c-format msgid "disabling statistics collector for lack of working socket" msgstr "Statistiksammelprozess abgeschaltet wegen nicht funkionierender Socket" -#: postmaster/pgstat.c:693 +#: postmaster/pgstat.c:725 #, c-format msgid "could not fork statistics collector: %m" msgstr "konnte Statistiksammelprozess nicht starten (fork-Fehler): %m" -#: postmaster/pgstat.c:1261 +#: postmaster/pgstat.c:1293 #, c-format msgid "unrecognized reset target: \"%s\"" msgstr "unbekanntes Reset-Ziel: »%s«" -#: postmaster/pgstat.c:1262 +#: postmaster/pgstat.c:1294 #, c-format msgid "Target must be \"archiver\" or \"bgwriter\"." msgstr "Das Reset-Ziel muss »archiver« oder »bgwriter« sein." -#: postmaster/pgstat.c:3587 +#: postmaster/pgstat.c:3619 #, c-format msgid "could not read statistics message: %m" msgstr "konnte Statistiknachricht nicht lesen: %m" -#: postmaster/pgstat.c:3918 postmaster/pgstat.c:4075 +#: postmaster/pgstat.c:3950 postmaster/pgstat.c:4107 #, c-format msgid "could not open temporary statistics file \"%s\": %m" msgstr "konnte temporäre Statistikdatei »%s« nicht öffnen: %m" -#: postmaster/pgstat.c:3985 postmaster/pgstat.c:4120 +#: postmaster/pgstat.c:4017 postmaster/pgstat.c:4152 #, c-format msgid "could not write temporary statistics file \"%s\": %m" msgstr "konnte temporäre Statistikdatei »%s« nicht schreiben: %m" -#: postmaster/pgstat.c:3994 postmaster/pgstat.c:4129 +#: postmaster/pgstat.c:4026 postmaster/pgstat.c:4161 #, c-format msgid "could not close temporary statistics file \"%s\": %m" msgstr "konnte temporäre Statistikdatei »%s« nicht schließen: %m" -#: postmaster/pgstat.c:4002 postmaster/pgstat.c:4137 +#: postmaster/pgstat.c:4034 postmaster/pgstat.c:4169 #, c-format msgid "could not rename temporary statistics file \"%s\" to \"%s\": %m" msgstr "konnte temporäre Statistikdatei »%s« nicht in »%s« umbenennen: %m" -#: postmaster/pgstat.c:4226 postmaster/pgstat.c:4411 postmaster/pgstat.c:4564 +#: postmaster/pgstat.c:4258 postmaster/pgstat.c:4464 postmaster/pgstat.c:4617 #, c-format msgid "could not open statistics file \"%s\": %m" msgstr "konnte Statistikdatei »%s« nicht öffnen: %m" -#: postmaster/pgstat.c:4238 postmaster/pgstat.c:4248 postmaster/pgstat.c:4258 -#: postmaster/pgstat.c:4279 postmaster/pgstat.c:4294 postmaster/pgstat.c:4348 -#: postmaster/pgstat.c:4423 postmaster/pgstat.c:4443 postmaster/pgstat.c:4461 -#: postmaster/pgstat.c:4477 postmaster/pgstat.c:4495 postmaster/pgstat.c:4511 -#: postmaster/pgstat.c:4576 postmaster/pgstat.c:4588 postmaster/pgstat.c:4600 -#: postmaster/pgstat.c:4625 postmaster/pgstat.c:4647 +#: postmaster/pgstat.c:4270 postmaster/pgstat.c:4280 postmaster/pgstat.c:4301 +#: postmaster/pgstat.c:4323 postmaster/pgstat.c:4338 postmaster/pgstat.c:4401 +#: postmaster/pgstat.c:4476 postmaster/pgstat.c:4496 postmaster/pgstat.c:4514 +#: postmaster/pgstat.c:4530 postmaster/pgstat.c:4548 postmaster/pgstat.c:4564 +#: postmaster/pgstat.c:4629 postmaster/pgstat.c:4641 postmaster/pgstat.c:4653 +#: postmaster/pgstat.c:4678 postmaster/pgstat.c:4700 #, c-format msgid "corrupted statistics file \"%s\"" msgstr "verfälschte Statistikdatei »%s«" -#: postmaster/pgstat.c:4776 +#: postmaster/pgstat.c:4829 #, c-format msgid "using stale statistics instead of current ones because stats collector is not responding" msgstr "verwende veraltete Statistiken anstatt aktueller, weil der Statistiksammelprozess nicht antwortet" -#: postmaster/pgstat.c:5103 +#: postmaster/pgstat.c:5156 #, c-format msgid "database hash table corrupted during cleanup --- abort" msgstr "Datenbank-Hash-Tabelle beim Aufräumen verfälscht --- Abbruch" -#: postmaster/postmaster.c:684 +#: postmaster/postmaster.c:702 #, c-format msgid "%s: invalid argument for option -f: \"%s\"\n" msgstr "%s: ungültiges Argument für Option -f: »%s«\n" -#: postmaster/postmaster.c:770 +#: postmaster/postmaster.c:788 #, c-format msgid "%s: invalid argument for option -t: \"%s\"\n" msgstr "%s: ungültiges Argument für Option -t: »%s«\n" -#: postmaster/postmaster.c:821 +#: postmaster/postmaster.c:839 #, c-format msgid "%s: invalid argument: \"%s\"\n" msgstr "%s: ungültiges Argument: »%s«\n" -#: postmaster/postmaster.c:860 +#: postmaster/postmaster.c:878 #, c-format msgid "%s: superuser_reserved_connections must be less than max_connections\n" msgstr "%s: superuser_reserved_connections muss kleiner als max_connections sein\n" -#: postmaster/postmaster.c:865 +#: postmaster/postmaster.c:883 #, c-format msgid "%s: max_wal_senders must be less than max_connections\n" msgstr "%s: max_wal_senders muss kleiner als max_connections sein\n" -#: postmaster/postmaster.c:870 +#: postmaster/postmaster.c:888 #, c-format msgid "WAL archival cannot be enabled when wal_level is \"minimal\"" msgstr "WAL-Archivierung kann nicht eingeschaltet werden, wenn wal_level »minimal« ist" -#: postmaster/postmaster.c:873 +#: postmaster/postmaster.c:891 #, c-format msgid "WAL streaming (max_wal_senders > 0) requires wal_level \"replica\" or \"logical\"" msgstr "WAL-Streaming (max_wal_senders > 0) benötigt wal_level »replica« oder »logical«" -#: postmaster/postmaster.c:881 +#: postmaster/postmaster.c:899 #, c-format msgid "%s: invalid datetoken tables, please fix\n" msgstr "%s: ungültige datetoken-Tabellen, bitte reparieren\n" -#: postmaster/postmaster.c:973 postmaster/postmaster.c:1071 +#: postmaster/postmaster.c:991 postmaster/postmaster.c:1089 #: utils/init/miscinit.c:1429 #, c-format msgid "invalid list syntax in parameter \"%s\"" msgstr "ungültige Listensyntax für Parameter »%s«" -#: postmaster/postmaster.c:1004 +#: postmaster/postmaster.c:1022 #, c-format msgid "could not create listen socket for \"%s\"" msgstr "konnte Listen-Socket für »%s« nicht erzeugen" -#: postmaster/postmaster.c:1010 +#: postmaster/postmaster.c:1028 #, c-format msgid "could not create any TCP/IP sockets" msgstr "konnte keine TCP/IP-Sockets erstellen" -#: postmaster/postmaster.c:1093 +#: postmaster/postmaster.c:1111 #, c-format msgid "could not create Unix-domain socket in directory \"%s\"" msgstr "konnte Unix-Domain-Socket in Verzeichnis »%s« nicht erzeugen" -#: postmaster/postmaster.c:1099 +#: postmaster/postmaster.c:1117 #, c-format msgid "could not create any Unix-domain sockets" msgstr "konnte keine Unix-Domain-Sockets erzeugen" -#: postmaster/postmaster.c:1111 +#: postmaster/postmaster.c:1129 #, c-format msgid "no socket created for listening" msgstr "keine Listen-Socket erzeugt" -#: postmaster/postmaster.c:1151 +#: postmaster/postmaster.c:1169 #, c-format msgid "could not create I/O completion port for child queue" msgstr "konnte Ein-/Ausgabe-Completion-Port für Child-Queue nicht erzeugen" -#: postmaster/postmaster.c:1180 +#: postmaster/postmaster.c:1198 #, c-format msgid "%s: could not change permissions of external PID file \"%s\": %s\n" msgstr "%s: konnte Rechte der externen PID-Datei »%s« nicht ändern: %s\n" -#: postmaster/postmaster.c:1184 +#: postmaster/postmaster.c:1202 #, c-format msgid "%s: could not write external PID file \"%s\": %s\n" msgstr "%s: konnte externe PID-Datei »%s« nicht schreiben: %s\n" -#: postmaster/postmaster.c:1234 +#: postmaster/postmaster.c:1252 #, c-format msgid "ending log output to stderr" msgstr "Logausgabe nach stderr endet" -#: postmaster/postmaster.c:1235 +#: postmaster/postmaster.c:1253 #, c-format msgid "Future log output will go to log destination \"%s\"." msgstr "Die weitere Logausgabe geht an Logziel »%s«." -#: postmaster/postmaster.c:1261 utils/init/postinit.c:213 +#: postmaster/postmaster.c:1279 utils/init/postinit.c:213 #, c-format msgid "could not load pg_hba.conf" msgstr "konnte pg_hba.conf nicht laden" -#: postmaster/postmaster.c:1287 +#: postmaster/postmaster.c:1305 #, c-format msgid "postmaster became multithreaded during startup" msgstr "Postmaster ist während des Starts multithreaded geworden" -#: postmaster/postmaster.c:1288 +#: postmaster/postmaster.c:1306 #, c-format msgid "Set the LC_ALL environment variable to a valid locale." msgstr "Setzen Sie die Umgebungsvariable LC_ALL auf eine gültige Locale." -#: postmaster/postmaster.c:1385 +#: postmaster/postmaster.c:1403 #, c-format msgid "%s: could not locate matching postgres executable" msgstr "%s: konnte kein passendes Programm »postgres« finden" -#: postmaster/postmaster.c:1408 utils/misc/tzparser.c:341 +#: postmaster/postmaster.c:1426 utils/misc/tzparser.c:341 #, c-format msgid "This may indicate an incomplete PostgreSQL installation, or that the file \"%s\" has been moved away from its proper location." msgstr "Dies kann auf eine unvollständige PostgreSQL-Installation hindeuten, oder darauf, dass die Datei »%s« von ihrer richtigen Stelle verschoben worden ist." -#: postmaster/postmaster.c:1436 +#: postmaster/postmaster.c:1454 #, c-format msgid "data directory \"%s\" does not exist" msgstr "Datenverzeichnis »%s« existiert nicht" -#: postmaster/postmaster.c:1441 +#: postmaster/postmaster.c:1459 #, c-format msgid "could not read permissions of directory \"%s\": %m" msgstr "konnte Zugriffsrechte von Verzeichnis »%s« nicht lesen: %m" -#: postmaster/postmaster.c:1449 +#: postmaster/postmaster.c:1467 #, c-format msgid "specified data directory \"%s\" is not a directory" msgstr "angegebenes Datenverzeichnis »%s« ist kein Verzeichnis" -#: postmaster/postmaster.c:1465 +#: postmaster/postmaster.c:1483 #, c-format msgid "data directory \"%s\" has wrong ownership" msgstr "Datenverzeichnis »%s« hat falschen Eigentümer" -#: postmaster/postmaster.c:1467 +#: postmaster/postmaster.c:1485 #, c-format msgid "The server must be started by the user that owns the data directory." msgstr "Der Server muss von dem Benutzer gestartet werden, dem das Datenverzeichnis gehört." -#: postmaster/postmaster.c:1487 +#: postmaster/postmaster.c:1505 #, c-format msgid "data directory \"%s\" has group or world access" msgstr "Datenverzeichnis »%s« erlaubt Zugriff von Gruppe oder Welt" -#: postmaster/postmaster.c:1489 +#: postmaster/postmaster.c:1507 #, c-format msgid "Permissions should be u=rwx (0700)." msgstr "Rechte sollten u=rwx (0700) sein." -#: postmaster/postmaster.c:1500 +#: postmaster/postmaster.c:1518 #, c-format msgid "" "%s: could not find the database system\n" @@ -14731,365 +14559,375 @@ msgstr "" "Es wurde im Verzeichnis »%s« erwartet,\n" "aber die Datei »%s« konnte nicht geöffnet werden: %s\n" -#: postmaster/postmaster.c:1677 +#: postmaster/postmaster.c:1695 #, c-format msgid "select() failed in postmaster: %m" msgstr "select() fehlgeschlagen im Postmaster: %m" -#: postmaster/postmaster.c:1828 +#: postmaster/postmaster.c:1850 #, c-format msgid "performing immediate shutdown because data directory lock file is invalid" msgstr "führe sofortiges Herunterfahren durch, weil Sperrdatei im Datenverzeichnis ungültig ist" -#: postmaster/postmaster.c:1906 postmaster/postmaster.c:1937 +#: postmaster/postmaster.c:1928 postmaster/postmaster.c:1959 #, c-format msgid "incomplete startup packet" msgstr "unvollständiges Startpaket" -#: postmaster/postmaster.c:1918 +#: postmaster/postmaster.c:1940 #, c-format msgid "invalid length of startup packet" msgstr "ungültige Länge des Startpakets" -#: postmaster/postmaster.c:1976 +#: postmaster/postmaster.c:1998 #, c-format msgid "failed to send SSL negotiation response: %m" msgstr "konnte SSL-Verhandlungsantwort nicht senden: %m" -#: postmaster/postmaster.c:2005 +#: postmaster/postmaster.c:2027 #, c-format msgid "unsupported frontend protocol %u.%u: server supports %u.0 to %u.%u" msgstr "nicht unterstütztes Frontend-Protokoll %u.%u: Server unterstützt %u.0 bis %u.%u" -#: postmaster/postmaster.c:2068 utils/misc/guc.c:5660 utils/misc/guc.c:5753 +#: postmaster/postmaster.c:2090 utils/misc/guc.c:5660 utils/misc/guc.c:5753 #: utils/misc/guc.c:7051 utils/misc/guc.c:9805 utils/misc/guc.c:9839 #, c-format msgid "invalid value for parameter \"%s\": \"%s\"" msgstr "ungültiger Wert für Parameter »%s«: »%s«" -#: postmaster/postmaster.c:2071 +#: postmaster/postmaster.c:2093 #, c-format msgid "Valid values are: \"false\", 0, \"true\", 1, \"database\"." msgstr "Gültige Werte sind: »false«, 0, »true«, 1, »database«." -#: postmaster/postmaster.c:2091 +#: postmaster/postmaster.c:2113 #, c-format msgid "invalid startup packet layout: expected terminator as last byte" msgstr "ungültiges Layout des Startpakets: Abschluss als letztes Byte erwartet" -#: postmaster/postmaster.c:2119 +#: postmaster/postmaster.c:2141 #, c-format msgid "no PostgreSQL user name specified in startup packet" msgstr "kein PostgreSQL-Benutzername im Startpaket angegeben" -#: postmaster/postmaster.c:2178 +#: postmaster/postmaster.c:2200 #, c-format msgid "the database system is starting up" msgstr "das Datenbanksystem startet" -#: postmaster/postmaster.c:2183 +#: postmaster/postmaster.c:2205 #, c-format msgid "the database system is shutting down" msgstr "das Datenbanksystem fährt herunter" -#: postmaster/postmaster.c:2188 +#: postmaster/postmaster.c:2210 #, c-format msgid "the database system is in recovery mode" msgstr "das Datenbanksystem ist im Wiederherstellungsmodus" -#: postmaster/postmaster.c:2193 storage/ipc/procarray.c:297 +#: postmaster/postmaster.c:2215 storage/ipc/procarray.c:298 #: storage/ipc/sinvaladt.c:298 storage/lmgr/proc.c:340 #, c-format msgid "sorry, too many clients already" msgstr "tut mir leid, schon zu viele Verbindungen" -#: postmaster/postmaster.c:2255 +#: postmaster/postmaster.c:2277 #, c-format msgid "wrong key in cancel request for process %d" msgstr "falscher Schlüssel in Stornierungsanfrage für Prozess %d" -#: postmaster/postmaster.c:2263 +#: postmaster/postmaster.c:2285 #, c-format msgid "PID %d in cancel request did not match any process" msgstr "PID %d in Stornierungsanfrage stimmte mit keinem Prozess überein" -#: postmaster/postmaster.c:2483 +#: postmaster/postmaster.c:2505 #, c-format msgid "received SIGHUP, reloading configuration files" msgstr "SIGHUP empfangen, Konfigurationsdateien werden neu geladen" -#: postmaster/postmaster.c:2508 +#: postmaster/postmaster.c:2530 #, c-format msgid "pg_hba.conf not reloaded" msgstr "pg_hba.conf nicht neu geladen" -#: postmaster/postmaster.c:2512 +#: postmaster/postmaster.c:2534 #, c-format msgid "pg_ident.conf not reloaded" msgstr "pg_ident.conf nicht neu geladen" -#: postmaster/postmaster.c:2553 +#: postmaster/postmaster.c:2575 #, c-format msgid "received smart shutdown request" msgstr "intelligentes Herunterfahren verlangt" -#: postmaster/postmaster.c:2608 +#: postmaster/postmaster.c:2630 #, c-format msgid "received fast shutdown request" msgstr "schnelles Herunterfahren verlangt" -#: postmaster/postmaster.c:2638 +#: postmaster/postmaster.c:2660 #, c-format msgid "aborting any active transactions" msgstr "etwaige aktive Transaktionen werden abgebrochen" -#: postmaster/postmaster.c:2672 +#: postmaster/postmaster.c:2694 #, c-format msgid "received immediate shutdown request" msgstr "sofortiges Herunterfahren verlangt" -#: postmaster/postmaster.c:2736 +#: postmaster/postmaster.c:2758 #, c-format msgid "shutdown at recovery target" msgstr "Herunterfahren beim Wiederherstellungsziel" -#: postmaster/postmaster.c:2752 postmaster/postmaster.c:2775 +#: postmaster/postmaster.c:2774 postmaster/postmaster.c:2797 msgid "startup process" msgstr "Startprozess" -#: postmaster/postmaster.c:2755 +#: postmaster/postmaster.c:2777 #, c-format msgid "aborting startup due to startup process failure" msgstr "Serverstart abgebrochen wegen Startprozessfehler" -#: postmaster/postmaster.c:2816 +#: postmaster/postmaster.c:2838 #, c-format msgid "database system is ready to accept connections" msgstr "Datenbanksystem ist bereit, um Verbindungen anzunehmen" -#: postmaster/postmaster.c:2835 +#: postmaster/postmaster.c:2857 msgid "background writer process" msgstr "Background-Writer-Prozess" -#: postmaster/postmaster.c:2889 +#: postmaster/postmaster.c:2911 msgid "checkpointer process" msgstr "Checkpointer-Prozess" -#: postmaster/postmaster.c:2905 +#: postmaster/postmaster.c:2927 msgid "WAL writer process" msgstr "WAL-Schreibprozess" -#: postmaster/postmaster.c:2919 +#: postmaster/postmaster.c:2942 msgid "WAL receiver process" msgstr "WAL-Receiver-Prozess" -#: postmaster/postmaster.c:2934 +#: postmaster/postmaster.c:2957 msgid "autovacuum launcher process" msgstr "Autovacuum-Launcher-Prozess" -#: postmaster/postmaster.c:2949 +#: postmaster/postmaster.c:2972 msgid "archiver process" msgstr "Archivierprozess" -#: postmaster/postmaster.c:2965 +#: postmaster/postmaster.c:2988 msgid "statistics collector process" msgstr "Statistiksammelprozess" -#: postmaster/postmaster.c:2979 +#: postmaster/postmaster.c:3002 msgid "system logger process" msgstr "Systemlogger-Prozess" -#: postmaster/postmaster.c:3041 +#: postmaster/postmaster.c:3064 msgid "worker process" msgstr "Worker-Prozess" -#: postmaster/postmaster.c:3124 postmaster/postmaster.c:3144 -#: postmaster/postmaster.c:3151 postmaster/postmaster.c:3169 +#: postmaster/postmaster.c:3147 postmaster/postmaster.c:3167 +#: postmaster/postmaster.c:3174 postmaster/postmaster.c:3192 msgid "server process" msgstr "Serverprozess" -#: postmaster/postmaster.c:3223 +#: postmaster/postmaster.c:3246 #, c-format msgid "terminating any other active server processes" msgstr "aktive Serverprozesse werden abgebrochen" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3479 +#: postmaster/postmaster.c:3502 #, c-format msgid "%s (PID %d) exited with exit code %d" msgstr "%s (PID %d) beendete mit Status %d" -#: postmaster/postmaster.c:3481 postmaster/postmaster.c:3492 -#: postmaster/postmaster.c:3503 postmaster/postmaster.c:3512 -#: postmaster/postmaster.c:3522 +#: postmaster/postmaster.c:3504 postmaster/postmaster.c:3515 +#: postmaster/postmaster.c:3526 postmaster/postmaster.c:3535 +#: postmaster/postmaster.c:3545 #, c-format msgid "Failed process was running: %s" msgstr "Der fehlgeschlagene Prozess führte aus: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3489 +#: postmaster/postmaster.c:3512 #, c-format msgid "%s (PID %d) was terminated by exception 0x%X" msgstr "%s (PID %d) wurde durch Ausnahme 0x%X beendet" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3499 +#: postmaster/postmaster.c:3522 #, c-format msgid "%s (PID %d) was terminated by signal %d: %s" msgstr "%s (PID %d) wurde von Signal %d beendet: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3510 +#: postmaster/postmaster.c:3533 #, c-format msgid "%s (PID %d) was terminated by signal %d" msgstr "%s (PID %d) wurde von Signal %d beendet" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3520 +#: postmaster/postmaster.c:3543 #, c-format msgid "%s (PID %d) exited with unrecognized status %d" msgstr "%s (PID %d) beendete mit unbekanntem Status %d" -#: postmaster/postmaster.c:3707 +#: postmaster/postmaster.c:3730 #, c-format msgid "abnormal database system shutdown" msgstr "abnormales Herunterfahren des Datenbanksystems" -#: postmaster/postmaster.c:3747 +#: postmaster/postmaster.c:3770 #, c-format msgid "all server processes terminated; reinitializing" msgstr "alle Serverprozesse beendet; initialisiere neu" -#: postmaster/postmaster.c:3959 +#: postmaster/postmaster.c:3982 #, c-format msgid "could not fork new process for connection: %m" msgstr "konnte neuen Prozess für Verbindung nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:4001 +#: postmaster/postmaster.c:4024 msgid "could not fork new process for connection: " msgstr "konnte neuen Prozess für Verbindung nicht starten (fork-Fehler): " -#: postmaster/postmaster.c:4115 +#: postmaster/postmaster.c:4138 #, c-format msgid "connection received: host=%s port=%s" msgstr "Verbindung empfangen: Host=%s Port=%s" -#: postmaster/postmaster.c:4120 +#: postmaster/postmaster.c:4143 #, c-format msgid "connection received: host=%s" msgstr "Verbindung empfangen: Host=%s" -#: postmaster/postmaster.c:4403 +#: postmaster/postmaster.c:4426 #, c-format msgid "could not execute server process \"%s\": %m" msgstr "konnte Serverprozess »%s« nicht ausführen: %m" -#: postmaster/postmaster.c:4947 +#: postmaster/postmaster.c:4579 +#, c-format +msgid "giving up after too many tries to reserve shared memory" +msgstr "Aufgabe nach zu vielen Versuchen, Shared Memory zu reservieren" + +#: postmaster/postmaster.c:4580 +#, c-format +msgid "This might be caused by ASLR or antivirus software." +msgstr "Dies kann durch ASLR oder Antivirus-Software verursacht werden." + +#: postmaster/postmaster.c:4978 #, c-format msgid "database system is ready to accept read only connections" msgstr "Datenbanksystem ist bereit, um lesende Verbindungen anzunehmen" -#: postmaster/postmaster.c:5238 +#: postmaster/postmaster.c:5267 #, c-format msgid "could not fork startup process: %m" msgstr "konnte Startprozess nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:5242 +#: postmaster/postmaster.c:5271 #, c-format msgid "could not fork background writer process: %m" msgstr "konnte Background-Writer-Prozess nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:5246 +#: postmaster/postmaster.c:5275 #, c-format msgid "could not fork checkpointer process: %m" msgstr "konnte Checkpointer-Prozess nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:5250 +#: postmaster/postmaster.c:5279 #, c-format msgid "could not fork WAL writer process: %m" msgstr "konnte WAL-Writer-Prozess nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:5254 +#: postmaster/postmaster.c:5283 #, c-format msgid "could not fork WAL receiver process: %m" msgstr "konnte WAL-Receiver-Prozess nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:5258 +#: postmaster/postmaster.c:5287 #, c-format msgid "could not fork process: %m" msgstr "konnte Prozess nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:5420 postmaster/postmaster.c:5443 +#: postmaster/postmaster.c:5467 postmaster/postmaster.c:5490 #, c-format msgid "database connection requirement not indicated during registration" msgstr "die Notwendigkeit, Datenbankverbindungen zu erzeugen, wurde bei der Registrierung nicht angezeigt" -#: postmaster/postmaster.c:5427 postmaster/postmaster.c:5450 +#: postmaster/postmaster.c:5474 postmaster/postmaster.c:5497 #, c-format msgid "invalid processing mode in background worker" msgstr "ungültiger Verarbeitungsmodus in Background-Worker" -#: postmaster/postmaster.c:5502 +#: postmaster/postmaster.c:5569 #, c-format msgid "starting background worker process \"%s\"" msgstr "starte Background-Worker-Prozess »%s«" -#: postmaster/postmaster.c:5513 +#: postmaster/postmaster.c:5581 #, c-format msgid "could not fork worker process: %m" msgstr "konnte Worker-Prozess nicht starten (fork-Fehler): %m" -#: postmaster/postmaster.c:5901 +#: postmaster/postmaster.c:5998 #, c-format msgid "could not duplicate socket %d for use in backend: error code %d" msgstr "konnte Socket %d nicht für Verwendung in Backend duplizieren: Fehlercode %d" -#: postmaster/postmaster.c:5933 +#: postmaster/postmaster.c:6030 #, c-format msgid "could not create inherited socket: error code %d\n" msgstr "konnte geerbtes Socket nicht erzeugen: Fehlercode %d\n" -#: postmaster/postmaster.c:5962 +#: postmaster/postmaster.c:6059 #, c-format msgid "could not open backend variables file \"%s\": %s\n" msgstr "konnte Servervariablendatei »%s« nicht öffnen: %s\n" -#: postmaster/postmaster.c:5969 +#: postmaster/postmaster.c:6066 #, c-format msgid "could not read from backend variables file \"%s\": %s\n" msgstr "konnte nicht aus Servervariablendatei »%s« lesen: %s\n" -#: postmaster/postmaster.c:5978 +#: postmaster/postmaster.c:6075 #, c-format msgid "could not remove file \"%s\": %s\n" msgstr "konnte Datei »%s« nicht löschen: %s\n" -#: postmaster/postmaster.c:5995 +#: postmaster/postmaster.c:6092 #, c-format msgid "could not map view of backend variables: error code %lu\n" msgstr "konnte Sicht der Backend-Variablen nicht mappen: Fehlercode %lu\n" -#: postmaster/postmaster.c:6004 +#: postmaster/postmaster.c:6101 #, c-format msgid "could not unmap view of backend variables: error code %lu\n" msgstr "konnte Sicht der Backend-Variablen nicht unmappen: Fehlercode %lu\n" -#: postmaster/postmaster.c:6011 +#: postmaster/postmaster.c:6108 #, c-format msgid "could not close handle to backend parameter variables: error code %lu\n" msgstr "konnte Handle für Backend-Parametervariablen nicht schließen: Fehlercode %lu\n" -#: postmaster/postmaster.c:6172 +#: postmaster/postmaster.c:6269 #, c-format msgid "could not read exit code for process\n" msgstr "konnte Exitcode des Prozesses nicht lesen\n" -#: postmaster/postmaster.c:6177 +#: postmaster/postmaster.c:6274 #, c-format msgid "could not post child completion status\n" msgstr "konnte Child-Completion-Status nicht versenden\n" @@ -15308,19 +15146,19 @@ msgid "invalid socket: %s" msgstr "ungültiges Socket: %s" #: replication/libpqwalreceiver/libpqwalreceiver.c:426 -#: storage/ipc/latch.c:1280 +#: storage/ipc/latch.c:1343 #, c-format msgid "select() failed: %m" msgstr "select() fehlgeschlagen: %m" -#: replication/libpqwalreceiver/libpqwalreceiver.c:549 -#: replication/libpqwalreceiver/libpqwalreceiver.c:576 +#: replication/libpqwalreceiver/libpqwalreceiver.c:555 #: replication/libpqwalreceiver/libpqwalreceiver.c:582 +#: replication/libpqwalreceiver/libpqwalreceiver.c:588 #, c-format msgid "could not receive data from WAL stream: %s" msgstr "konnte keine Daten vom WAL-Stream empfangen: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:601 +#: replication/libpqwalreceiver/libpqwalreceiver.c:607 #, c-format msgid "could not send data to WAL stream: %s" msgstr "konnte keine Daten an den WAL-Stream senden: %s" @@ -15340,37 +15178,37 @@ msgstr "logische Dekodierung benötigt eine Datenbankverbindung" msgid "logical decoding cannot be used while in recovery" msgstr "logische Dekodierung kann nicht während der Wiederherstellung verwendet werden" -#: replication/logical/logical.c:236 replication/logical/logical.c:348 +#: replication/logical/logical.c:239 replication/logical/logical.c:360 #, c-format msgid "cannot use physical replication slot for logical decoding" msgstr "physischer Replikations-Slot kann nicht für logisches Dekodieren verwendet werden" -#: replication/logical/logical.c:241 replication/logical/logical.c:353 +#: replication/logical/logical.c:244 replication/logical/logical.c:365 #, c-format msgid "replication slot \"%s\" was not created in this database" msgstr "Replikations-Slot »%s« wurde nicht in dieser Datenbank erzeugt" -#: replication/logical/logical.c:248 +#: replication/logical/logical.c:251 #, c-format msgid "cannot create logical replication slot in transaction that has performed writes" msgstr "logischer Replikations-Slot kann nicht in einer Transaktion erzeugt werden, die Schreibvorgänge ausgeführt hat" -#: replication/logical/logical.c:390 +#: replication/logical/logical.c:402 #, c-format msgid "starting logical decoding for slot \"%s\"" msgstr "starte logisches Dekodieren für Slot »%s«" -#: replication/logical/logical.c:392 +#: replication/logical/logical.c:404 #, c-format msgid "streaming transactions committing after %X/%X, reading WAL from %X/%X" msgstr "Streaming beginnt bei Transaktionen, die nach %X/%X committen; lese WAL ab %X/%X" -#: replication/logical/logical.c:527 +#: replication/logical/logical.c:539 #, c-format msgid "slot \"%s\", output plugin \"%s\", in the %s callback, associated LSN %X/%X" msgstr "Slot »%s«, Ausgabe-Plugin »%s«, im Callback %s, zugehörige LSN %X/%X" -#: replication/logical/logical.c:534 +#: replication/logical/logical.c:546 #, c-format msgid "slot \"%s\", output plugin \"%s\", in the %s callback" msgstr "Slot »%s«, Ausgabe-Plugin »%s«, im Callback %s" @@ -15436,117 +15274,120 @@ msgstr "konnte keine freie Replication-Origin-OID finden" msgid "could not drop replication origin with OID %d, in use by PID %d" msgstr "konnte Replication-Origin mit OID %d nicht löschen, wird von PID %d verwendet" -#: replication/logical/origin.c:671 +#: replication/logical/origin.c:674 #, c-format msgid "replication checkpoint has wrong magic %u instead of %u" msgstr "Replikations-Checkpoint hat falsche magische Zahl %u statt %u" -#: replication/logical/origin.c:703 +#: replication/logical/origin.c:706 #, c-format msgid "could not read file \"%s\": read %d of %zu" msgstr "konnte Datei »%s« nicht lesen: %d von %zu gelesen" -#: replication/logical/origin.c:712 +#: replication/logical/origin.c:715 #, c-format msgid "could not find free replication state, increase max_replication_slots" msgstr "konnte keinen freien Replication-State finden, erhöhen Sie max_replication_slots" -#: replication/logical/origin.c:730 +#: replication/logical/origin.c:733 #, c-format msgid "replication slot checkpoint has wrong checksum %u, expected %u" msgstr "Replikations-Slot-Checkpoint hat falsche Prüfsumme %u, erwartet wurde %u" -#: replication/logical/origin.c:854 +#: replication/logical/origin.c:857 #, c-format msgid "replication origin with OID %d is already active for PID %d" msgstr "Replication-Origin mit OID %d ist bereits aktiv für PID %d" -#: replication/logical/origin.c:865 replication/logical/origin.c:1045 +#: replication/logical/origin.c:868 replication/logical/origin.c:1048 #, c-format msgid "could not find free replication state slot for replication origin with OID %u" msgstr "konnte keinen freien Replication-State-Slot für Replication-Origin mit OID %u finden" -#: replication/logical/origin.c:867 replication/logical/origin.c:1047 -#: replication/slot.c:1299 +#: replication/logical/origin.c:870 replication/logical/origin.c:1050 +#: replication/slot.c:1316 #, c-format msgid "Increase max_replication_slots and try again." msgstr "Erhöhen Sie max_replication_slots und versuchen Sie es erneut." -#: replication/logical/origin.c:1004 +#: replication/logical/origin.c:1007 #, c-format msgid "cannot setup replication origin when one is already setup" msgstr "kann Replication-Origin nicht einrichten, wenn schon einer eingerichtet ist" -#: replication/logical/origin.c:1033 +#: replication/logical/origin.c:1036 #, c-format msgid "replication identifier %d is already active for PID %d" msgstr "Replikationsidentifikator %d ist bereits aktiv für PID %d" -#: replication/logical/origin.c:1079 replication/logical/origin.c:1274 -#: replication/logical/origin.c:1294 +#: replication/logical/origin.c:1082 replication/logical/origin.c:1277 +#: replication/logical/origin.c:1297 #, c-format msgid "no replication origin is configured" msgstr "kein Replication-Origin konfiguriert" -#: replication/logical/reorderbuffer.c:2330 +#: replication/logical/reorderbuffer.c:2331 #, c-format msgid "could not write to data file for XID %u: %m" msgstr "konnte nicht in Datendatei für XID %u schreiben: %m" -#: replication/logical/reorderbuffer.c:2426 -#: replication/logical/reorderbuffer.c:2446 +#: replication/logical/reorderbuffer.c:2427 +#: replication/logical/reorderbuffer.c:2447 #, c-format msgid "could not read from reorderbuffer spill file: %m" msgstr "konnte nicht aus Reorder-Buffer-Spill-Datei lesen: %m" -#: replication/logical/reorderbuffer.c:2430 -#: replication/logical/reorderbuffer.c:2450 +#: replication/logical/reorderbuffer.c:2431 +#: replication/logical/reorderbuffer.c:2451 #, c-format msgid "could not read from reorderbuffer spill file: read %d instead of %u bytes" msgstr "konnte nicht aus Reorder-Buffer-Spill-Datei lesen: %d statt %u Bytes gelesen" -#: replication/logical/reorderbuffer.c:3106 +#: replication/logical/reorderbuffer.c:3107 #, c-format msgid "could not read from file \"%s\": read %d instead of %d bytes" msgstr "konnte nicht aus Datei »%s« lesen: %d statt %d Bytes gelesen" -#: replication/logical/snapbuild.c:598 +#: replication/logical/snapbuild.c:646 #, c-format msgid "exported logical decoding snapshot: \"%s\" with %u transaction ID" msgid_plural "exported logical decoding snapshot: \"%s\" with %u transaction IDs" msgstr[0] "logischer Dekodierungs-Snapshot exportiert: »%s« mit %u Transaktions-ID" msgstr[1] "logischer Dekodierungs-Snapshot exportiert: »%s« mit %u Transaktions-IDs" -#: replication/logical/snapbuild.c:917 replication/logical/snapbuild.c:1282 -#: replication/logical/snapbuild.c:1813 +#: replication/logical/snapbuild.c:1243 replication/logical/snapbuild.c:1333 +#: replication/logical/snapbuild.c:1808 #, c-format msgid "logical decoding found consistent point at %X/%X" msgstr "logisches Dekodieren fand konsistenten Punkt bei %X/%X" -#: replication/logical/snapbuild.c:919 -#, c-format -msgid "Transaction ID %u finished; no more running transactions." -msgstr "Transaktions-ID %u beendet; keine laufenden Transaktionen mehr." - -#: replication/logical/snapbuild.c:1284 +#: replication/logical/snapbuild.c:1245 #, c-format msgid "There are no running transactions." msgstr "Keine laufenden Transaktionen." -#: replication/logical/snapbuild.c:1346 +#: replication/logical/snapbuild.c:1286 #, c-format msgid "logical decoding found initial starting point at %X/%X" msgstr "logisches Dekodieren fand initialen Startpunkt bei %X/%X" -#: replication/logical/snapbuild.c:1348 +#: replication/logical/snapbuild.c:1288 replication/logical/snapbuild.c:1311 +#, c-format +msgid "Waiting for transactions (approximately %d) older than %u to end." +msgstr "Warten auf Abschluss der Transaktionen (ungefähr %d), die älter als %u sind." + +#: replication/logical/snapbuild.c:1309 #, c-format -msgid "%u transaction needs to finish." -msgid_plural "%u transactions need to finish." -msgstr[0] "%u Transaktion muss noch abschließen." -msgstr[1] "%u Transaktionen müssen noch abschließen." +msgid "logical decoding found initial consistent point at %X/%X" +msgstr "logisches Dekodieren fand initialen konsistenten Punkt bei %X/%X" + +#: replication/logical/snapbuild.c:1335 +#, c-format +msgid "There are no old transactions anymore." +msgstr "Es laufen keine alten Transaktionen mehr." #: replication/logical/snapbuild.c:1687 replication/logical/snapbuild.c:1713 -#: replication/logical/snapbuild.c:1727 replication/logical/snapbuild.c:1741 +#: replication/logical/snapbuild.c:1728 replication/logical/snapbuild.c:1742 #, c-format msgid "could not read file \"%s\", read %d of %d: %m" msgstr "konnte Datei »%s« nicht lesen, %d von %d gelesen: %m" @@ -15561,17 +15402,17 @@ msgstr "Scanbuild-State-Datei »%s« hat falsche magische Zahl %u statt %u" msgid "snapbuild state file \"%s\" has unsupported version: %u instead of %u" msgstr "Snapbuild-State-Datei »%s« hat nicht unterstützte Version: %u statt %u" -#: replication/logical/snapbuild.c:1754 +#: replication/logical/snapbuild.c:1755 #, c-format msgid "checksum mismatch for snapbuild state file \"%s\": is %u, should be %u" msgstr "Prüfsummenfehler bei Snapbuild-State-Datei »%s«: ist %u, sollte %u sein" -#: replication/logical/snapbuild.c:1815 +#: replication/logical/snapbuild.c:1810 #, c-format msgid "Logical decoding will begin using saved snapshot." msgstr "Logische Dekodierung beginnt mit gespeichertem Snapshot." -#: replication/logical/snapbuild.c:1888 +#: replication/logical/snapbuild.c:1881 #, c-format msgid "could not parse file name \"%s\"" msgstr "konnte Dateinamen »%s« nicht parsen" @@ -15621,47 +15462,47 @@ msgstr "Replikations-Slot »%s« existiert nicht" msgid "replication slot \"%s\" is active for PID %d" msgstr "Replikations-Slot »%s« ist aktiv für PID %d" -#: replication/slot.c:511 replication/slot.c:923 replication/slot.c:1260 +#: replication/slot.c:527 replication/slot.c:940 replication/slot.c:1277 #, c-format msgid "could not remove directory \"%s\"" msgstr "konnte Verzeichnis »%s« nicht löschen" -#: replication/slot.c:772 +#: replication/slot.c:789 #, c-format msgid "replication slots can only be used if max_replication_slots > 0" msgstr "Replikations-Slots können nur verwendet werden, wenn max_replication_slots > 0" -#: replication/slot.c:777 +#: replication/slot.c:794 #, c-format msgid "replication slots can only be used if wal_level >= replica" msgstr "Replikations-Slots können nur verwendet werden, wenn wal_level >= replica" -#: replication/slot.c:1192 replication/slot.c:1230 +#: replication/slot.c:1209 replication/slot.c:1247 #, c-format msgid "could not read file \"%s\", read %d of %u: %m" msgstr "konnte Datei »%s« nicht lesen, %d von %u gelesen: %m" -#: replication/slot.c:1201 +#: replication/slot.c:1218 #, c-format msgid "replication slot file \"%s\" has wrong magic number: %u instead of %u" msgstr "Replikations-Slot-Datei »%s« hat falsche magische Zahl: %u statt %u" -#: replication/slot.c:1208 +#: replication/slot.c:1225 #, c-format msgid "replication slot file \"%s\" has unsupported version %u" msgstr "Replikations-Slot-Datei »%s« hat nicht unterstützte Version %u" -#: replication/slot.c:1215 +#: replication/slot.c:1232 #, c-format msgid "replication slot file \"%s\" has corrupted length %u" msgstr "Replikations-Slot-Datei »%s« hat falsche Länge %u" -#: replication/slot.c:1245 +#: replication/slot.c:1262 #, c-format msgid "checksum mismatch for replication slot file \"%s\": is %u, should be %u" msgstr "Prüfsummenfehler bei Replikations-Slot-Datei »%s«: ist %u, sollte %u sein" -#: replication/slot.c:1298 +#: replication/slot.c:1315 #, c-format msgid "too many replication slots active before shutdown" msgstr "zu viele aktive Replikations-Slots vor dem Herunterfahren" @@ -15681,22 +15522,22 @@ msgstr "Die Transaktion wurde lokal bereits committet, aber möglicherweise noch msgid "canceling wait for synchronous replication due to user request" msgstr "storniere Warten auf synchrone Replikation wegen Benutzeraufforderung" -#: replication/syncrep.c:368 +#: replication/syncrep.c:371 #, c-format msgid "standby \"%s\" now has synchronous standby priority %u" msgstr "Standby »%s« hat jetzt synchrone Standby-Priorität %u" -#: replication/syncrep.c:428 +#: replication/syncrep.c:431 #, c-format msgid "standby \"%s\" is now a synchronous standby with priority %u" msgstr "Standby »%s« ist jetzt ein synchroner Standby mit Priorität %u" -#: replication/syncrep.c:921 +#: replication/syncrep.c:931 #, c-format msgid "synchronous_standby_names parser failed" msgstr "Parser für synchronous_standby_names fehlgeschlagen" -#: replication/syncrep.c:927 +#: replication/syncrep.c:937 #, c-format msgid "number of synchronous standbys (%d) must be greater than zero" msgstr "Anzahl synchroner Standbys (%d) muss größer als null sein" @@ -15761,72 +15602,77 @@ msgstr "hole Zeitleisten-History-Datei für Zeitleiste %u vom Primärserver" msgid "could not write to log segment %s at offset %u, length %lu: %m" msgstr "konnte nicht in Logsegment %s bei Position %u, Länge %lu schreiben: %m" -#: replication/walsender.c:485 +#: replication/walsender.c:490 #, c-format msgid "could not seek to beginning of file \"%s\": %m" msgstr "konnte Positionszeiger nicht den Anfang der Datei »%s« setzen: %m" -#: replication/walsender.c:536 +#: replication/walsender.c:541 #, c-format msgid "cannot use a logical replication slot for physical replication" msgstr "logischer Replikations-Slot kann nicht für physische Replikation verwendet werden" -#: replication/walsender.c:599 +#: replication/walsender.c:604 #, c-format msgid "requested starting point %X/%X on timeline %u is not in this server's history" msgstr "angeforderter Startpunkt %X/%X auf Zeitleiste %u ist nicht in der History dieses Servers" -#: replication/walsender.c:603 +#: replication/walsender.c:608 #, c-format msgid "This server's history forked from timeline %u at %X/%X." msgstr "Die History dieses Servers zweigte von Zeitleiste %u bei %X/%X ab." -#: replication/walsender.c:648 +#: replication/walsender.c:653 #, c-format msgid "requested starting point %X/%X is ahead of the WAL flush position of this server %X/%X" msgstr "angeforderter Startpunkt %X/%X ist vor der WAL-Flush-Position dieses Servers %X/%X" -#: replication/walsender.c:974 +#: replication/walsender.c:977 #, c-format msgid "terminating walsender process after promotion" msgstr "WAL-Sender-Prozess wird nach Beförderung abgebrochen" -#: replication/walsender.c:1300 +#: replication/walsender.c:1333 +#, c-format +msgid "cannot execute new commands while WAL sender is in stopping mode" +msgstr "während der WAL-Sender im Stoppmodus ist können keine neuen Befehle ausgeführt werden" + +#: replication/walsender.c:1341 #, c-format msgid "received replication command: %s" msgstr "Replikationsbefehl empfangen: %s" -#: replication/walsender.c:1391 replication/walsender.c:1407 +#: replication/walsender.c:1440 replication/walsender.c:1456 #, c-format msgid "unexpected EOF on standby connection" msgstr "unerwartetes EOF auf Standby-Verbindung" -#: replication/walsender.c:1421 +#: replication/walsender.c:1470 #, c-format msgid "unexpected standby message type \"%c\", after receiving CopyDone" msgstr "unerwarteter Standby-Message-Typ »%c«, nach Empfang von CopyDone" -#: replication/walsender.c:1459 +#: replication/walsender.c:1508 #, c-format msgid "invalid standby message type \"%c\"" msgstr "ungültiger Standby-Message-Typ »%c«" -#: replication/walsender.c:1500 +#: replication/walsender.c:1549 #, c-format msgid "unexpected message type \"%c\"" msgstr "unerwarteter Message-Typ »%c«" -#: replication/walsender.c:1784 +#: replication/walsender.c:1833 #, c-format msgid "terminating walsender process due to replication timeout" msgstr "WAL-Sender-Prozess wird abgebrochen wegen Zeitüberschreitung bei der Replikation" -#: replication/walsender.c:1877 +#: replication/walsender.c:1919 #, c-format msgid "standby \"%s\" has now caught up with primary" msgstr "Standby-Server »%s« hat jetzt den Primärserver eingeholt" -#: replication/walsender.c:1980 +#: replication/walsender.c:2022 #, c-format msgid "number of requested standby connections exceeds max_wal_senders (currently %d)" msgstr "Anzahl angeforderter Standby-Verbindungen überschreitet max_wal_senders (aktuell %d)" @@ -16037,152 +15883,152 @@ msgstr "WITH-Anfragename »%s« erscheint sowohl in der Regelaktion als auch in msgid "cannot have RETURNING lists in multiple rules" msgstr "RETURNING-Listen können nicht in mehreren Regeln auftreten" -#: rewrite/rewriteHandler.c:928 rewrite/rewriteHandler.c:946 +#: rewrite/rewriteHandler.c:949 rewrite/rewriteHandler.c:967 #, c-format msgid "multiple assignments to same column \"%s\"" msgstr "mehrere Zuweisungen zur selben Spalte »%s«" -#: rewrite/rewriteHandler.c:1721 rewrite/rewriteHandler.c:3331 +#: rewrite/rewriteHandler.c:1752 rewrite/rewriteHandler.c:3362 #, c-format msgid "infinite recursion detected in rules for relation \"%s\"" msgstr "unendliche Rekursion entdeckt in Regeln für Relation »%s«" -#: rewrite/rewriteHandler.c:1806 +#: rewrite/rewriteHandler.c:1837 #, c-format msgid "infinite recursion detected in policy for relation \"%s\"" msgstr "unendliche Rekursion entdeckt in Policys für Relation »%s«" -#: rewrite/rewriteHandler.c:2123 +#: rewrite/rewriteHandler.c:2154 msgid "Junk view columns are not updatable." msgstr "Junk-Sichtspalten sind nicht aktualisierbar." -#: rewrite/rewriteHandler.c:2128 +#: rewrite/rewriteHandler.c:2159 msgid "View columns that are not columns of their base relation are not updatable." msgstr "Sichtspalten, die nicht Spalten ihrer Basisrelation sind, sind nicht aktualisierbar." -#: rewrite/rewriteHandler.c:2131 +#: rewrite/rewriteHandler.c:2162 msgid "View columns that refer to system columns are not updatable." msgstr "Sichtspalten, die auf Systemspalten verweisen, sind nicht aktualisierbar." -#: rewrite/rewriteHandler.c:2134 +#: rewrite/rewriteHandler.c:2165 msgid "View columns that return whole-row references are not updatable." msgstr "Sichtspalten, die Verweise auf ganze Zeilen zurückgeben, sind nicht aktualisierbar." -#: rewrite/rewriteHandler.c:2192 +#: rewrite/rewriteHandler.c:2223 msgid "Views containing DISTINCT are not automatically updatable." msgstr "Sichten, die DISTINCT enthalten, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2195 +#: rewrite/rewriteHandler.c:2226 msgid "Views containing GROUP BY are not automatically updatable." msgstr "Sichten, die GROUP BY enthalten, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2198 +#: rewrite/rewriteHandler.c:2229 msgid "Views containing HAVING are not automatically updatable." msgstr "Sichten, die HAVING enthalten, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2201 +#: rewrite/rewriteHandler.c:2232 msgid "Views containing UNION, INTERSECT, or EXCEPT are not automatically updatable." msgstr "Sichten, die UNION, INTERSECT oder EXCEPT enthalten, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2204 +#: rewrite/rewriteHandler.c:2235 msgid "Views containing WITH are not automatically updatable." msgstr "Sichten, die WITH enthalten, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2207 +#: rewrite/rewriteHandler.c:2238 msgid "Views containing LIMIT or OFFSET are not automatically updatable." msgstr "Sichten, die LIMIT oder OFFSET enthalten, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2219 +#: rewrite/rewriteHandler.c:2250 msgid "Views that return aggregate functions are not automatically updatable." msgstr "Sichten, die Aggregatfunktionen zurückgeben, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2222 +#: rewrite/rewriteHandler.c:2253 msgid "Views that return window functions are not automatically updatable." msgstr "Sichten, die Fensterfunktionen zurückgeben, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2225 +#: rewrite/rewriteHandler.c:2256 msgid "Views that return set-returning functions are not automatically updatable." msgstr "Sichten, die Funktionen mit Ergebnismenge zurückgeben, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2232 rewrite/rewriteHandler.c:2236 -#: rewrite/rewriteHandler.c:2243 +#: rewrite/rewriteHandler.c:2263 rewrite/rewriteHandler.c:2267 +#: rewrite/rewriteHandler.c:2274 msgid "Views that do not select from a single table or view are not automatically updatable." msgstr "Sichten, die nicht aus einer einzigen Tabelle oder Sicht lesen, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2246 +#: rewrite/rewriteHandler.c:2277 msgid "Views containing TABLESAMPLE are not automatically updatable." msgstr "Sichten, die TABLESAMPLE enthalten, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2270 +#: rewrite/rewriteHandler.c:2301 msgid "Views that have no updatable columns are not automatically updatable." msgstr "Sichten, die keine aktualisierbaren Spalten haben, sind nicht automatisch aktualisierbar." -#: rewrite/rewriteHandler.c:2724 +#: rewrite/rewriteHandler.c:2755 #, c-format msgid "cannot insert into column \"%s\" of view \"%s\"" msgstr "kann nicht in Spalte »%s« von Sicht »%s« einfügen" -#: rewrite/rewriteHandler.c:2732 +#: rewrite/rewriteHandler.c:2763 #, c-format msgid "cannot update column \"%s\" of view \"%s\"" msgstr "kann Spalte »%s« von Sicht »%s« nicht aktualisieren" -#: rewrite/rewriteHandler.c:3130 +#: rewrite/rewriteHandler.c:3161 #, c-format msgid "DO INSTEAD NOTHING rules are not supported for data-modifying statements in WITH" msgstr "DO INSTEAD NOTHING-Regeln werden für datenmodifizierende Anweisungen in WITH nicht unterstützt" -#: rewrite/rewriteHandler.c:3144 +#: rewrite/rewriteHandler.c:3175 #, c-format msgid "conditional DO INSTEAD rules are not supported for data-modifying statements in WITH" msgstr "Do INSTEAD-Regeln mit Bedingung werden für datenmodifizierende Anweisungen in WITH nicht unterstützt" -#: rewrite/rewriteHandler.c:3148 +#: rewrite/rewriteHandler.c:3179 #, c-format msgid "DO ALSO rules are not supported for data-modifying statements in WITH" msgstr "DO ALSO-Regeln werden für datenmodifizierende Anweisungen in WITH nicht unterstützt" -#: rewrite/rewriteHandler.c:3153 +#: rewrite/rewriteHandler.c:3184 #, c-format msgid "multi-statement DO INSTEAD rules are not supported for data-modifying statements in WITH" msgstr "DO INSTEAD-Regeln mit mehreren Anweisungen werden für datenmodifizierende Anweisungen in WITH nicht unterstützt" -#: rewrite/rewriteHandler.c:3368 +#: rewrite/rewriteHandler.c:3399 #, c-format msgid "cannot perform INSERT RETURNING on relation \"%s\"" msgstr "INSERT RETURNING kann in Relation »%s« nicht ausgeführt werden" -#: rewrite/rewriteHandler.c:3370 +#: rewrite/rewriteHandler.c:3401 #, c-format msgid "You need an unconditional ON INSERT DO INSTEAD rule with a RETURNING clause." msgstr "Sie benötigen eine ON INSERT DO INSTEAD Regel ohne Bedingung, mit RETURNING-Klausel." -#: rewrite/rewriteHandler.c:3375 +#: rewrite/rewriteHandler.c:3406 #, c-format msgid "cannot perform UPDATE RETURNING on relation \"%s\"" msgstr "UPDATE RETURNING kann in Relation »%s« nicht ausgeführt werden" -#: rewrite/rewriteHandler.c:3377 +#: rewrite/rewriteHandler.c:3408 #, c-format msgid "You need an unconditional ON UPDATE DO INSTEAD rule with a RETURNING clause." msgstr "Sie benötigen eine ON UPDATE DO INSTEAD Regel ohne Bedingung, mit RETURNING-Klausel." -#: rewrite/rewriteHandler.c:3382 +#: rewrite/rewriteHandler.c:3413 #, c-format msgid "cannot perform DELETE RETURNING on relation \"%s\"" msgstr "DELETE RETURNING kann in Relation »%s« nicht ausgeführt werden" -#: rewrite/rewriteHandler.c:3384 +#: rewrite/rewriteHandler.c:3415 #, c-format msgid "You need an unconditional ON DELETE DO INSTEAD rule with a RETURNING clause." msgstr "Sie benötigen eine ON DELETE DO INSTEAD Regel ohne Bedingung, mit RETURNING-Klausel." -#: rewrite/rewriteHandler.c:3402 +#: rewrite/rewriteHandler.c:3433 #, c-format msgid "INSERT with ON CONFLICT clause cannot be used with table that has INSERT or UPDATE rules" msgstr "INSERT mit ON-CONFLICT-Klausel kann nicht mit Tabelle verwendet werden, die INSERT- oder UPDATE-Regeln hat" -#: rewrite/rewriteHandler.c:3459 +#: rewrite/rewriteHandler.c:3490 #, c-format msgid "WITH cannot be used in a query that is rewritten by rules into multiple queries" msgstr "WITH kann nicht in einer Anfrage verwendet werden, die durch Regeln in mehrere Anfragen umgeschrieben wird" @@ -16380,22 +16226,22 @@ msgstr "Das scheint mit fehlerhaften Kernels vorzukommen; Sie sollten eine Syste msgid "invalid page in block %u of relation %s; zeroing out page" msgstr "ungültige Seite in Block %u von Relation %s; fülle Seite mit Nullen" -#: storage/buffer/bufmgr.c:3952 +#: storage/buffer/bufmgr.c:3969 #, c-format msgid "could not write block %u of %s" msgstr "konnte Block %u von %s nicht schreiben" -#: storage/buffer/bufmgr.c:3954 +#: storage/buffer/bufmgr.c:3971 #, c-format msgid "Multiple failures --- write error might be permanent." msgstr "Mehrere Fehlschläge --- Schreibfehler ist möglicherweise dauerhaft." -#: storage/buffer/bufmgr.c:3975 storage/buffer/bufmgr.c:3994 +#: storage/buffer/bufmgr.c:3992 storage/buffer/bufmgr.c:4011 #, c-format msgid "writing block %u of relation %s" msgstr "schreibe Block %u von Relation %s" -#: storage/buffer/bufmgr.c:4295 +#: storage/buffer/bufmgr.c:4312 #, c-format msgid "snapshot too old" msgstr "Snapshot zu alt" @@ -16410,73 +16256,73 @@ msgstr "kein leerer lokaler Puffer verfügbar" msgid "cannot access temporary tables during a parallel operation" msgstr "während einer parallelen Operation kann nicht auf temporäre Tabellen zugegriffen werden" -#: storage/file/fd.c:436 storage/file/fd.c:508 storage/file/fd.c:544 +#: storage/file/fd.c:443 storage/file/fd.c:515 storage/file/fd.c:551 #, c-format msgid "could not flush dirty data: %m" msgstr "konnte schmutzige Daten nicht flushen: %m" -#: storage/file/fd.c:466 +#: storage/file/fd.c:473 #, c-format msgid "could not determine dirty data size: %m" msgstr "konnte Größe der schmutzigen Daten nicht bestimmen: %m" -#: storage/file/fd.c:518 +#: storage/file/fd.c:525 #, c-format msgid "could not munmap() while flushing data: %m" msgstr "munmap() fehlgeschlagen beim Flushen von Daten: %m" -#: storage/file/fd.c:682 +#: storage/file/fd.c:689 #, c-format msgid "could not link file \"%s\" to \"%s\": %m" msgstr "konnte Datei »%s« nicht nach »%s« linken: %m" -#: storage/file/fd.c:776 +#: storage/file/fd.c:783 #, c-format msgid "getrlimit failed: %m" msgstr "getrlimit fehlgeschlagen: %m" -#: storage/file/fd.c:866 +#: storage/file/fd.c:873 #, c-format msgid "insufficient file descriptors available to start server process" msgstr "nicht genug Dateideskriptoren verfügbar, um Serverprozess zu starten" -#: storage/file/fd.c:867 +#: storage/file/fd.c:874 #, c-format msgid "System allows %d, we need at least %d." msgstr "System erlaubt %d, wir benötigen mindestens %d." -#: storage/file/fd.c:908 storage/file/fd.c:2001 storage/file/fd.c:2094 -#: storage/file/fd.c:2242 +#: storage/file/fd.c:915 storage/file/fd.c:2078 storage/file/fd.c:2171 +#: storage/file/fd.c:2319 #, c-format msgid "out of file descriptors: %m; release and retry" msgstr "keine Dateideskriptoren mehr: %m; freigeben und nochmal versuchen" -#: storage/file/fd.c:1482 +#: storage/file/fd.c:1520 #, c-format msgid "temporary file: path \"%s\", size %lu" msgstr "temporäre Datei: Pfad »%s«, Größe %lu" -#: storage/file/fd.c:1656 +#: storage/file/fd.c:1717 #, c-format msgid "temporary file size exceeds temp_file_limit (%dkB)" msgstr "Größe der temporären Datei überschreitet temp_file_limit (%dkB)" -#: storage/file/fd.c:1977 storage/file/fd.c:2027 +#: storage/file/fd.c:2054 storage/file/fd.c:2104 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to open file \"%s\"" msgstr "maxAllocatedDescs (%d) überschritten beim Versuch, die Datei »%s« zu öffnen" -#: storage/file/fd.c:2067 +#: storage/file/fd.c:2144 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to execute command \"%s\"" msgstr "maxAllocatedDescs (%d) überschritten beim Versuch, den Befehl »%s« auszuführen" -#: storage/file/fd.c:2218 +#: storage/file/fd.c:2295 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to open directory \"%s\"" msgstr "maxAllocatedDescs (%d) überschritten beim Versuch, das Verzeichnis »%s« zu öffnen" -#: storage/file/fd.c:2304 +#: storage/file/fd.c:2381 #, c-format msgid "could not read directory \"%s\": %m" msgstr "konnte Verzeichnis »%s« nicht lesen: %m" @@ -16558,17 +16404,17 @@ msgstr "konnte Shared-Memory-Segment »%s« nicht erzeugen: %m" msgid "could not duplicate handle for \"%s\": %m" msgstr "konnte Handle für »%s« nicht duplizieren: %m" -#: storage/ipc/latch.c:778 +#: storage/ipc/latch.c:841 #, c-format msgid "epoll_ctl() failed: %m" msgstr "epoll_ctl() fehlgeschlagen: %m" -#: storage/ipc/latch.c:1002 +#: storage/ipc/latch.c:1065 #, c-format msgid "epoll_wait() failed: %m" msgstr "epoll_wait() fehlgeschlagen: %m" -#: storage/ipc/latch.c:1122 +#: storage/ipc/latch.c:1185 #, c-format msgid "poll() failed: %m" msgstr "poll() fehlgeschlagen: %m" @@ -16576,9 +16422,9 @@ msgstr "poll() fehlgeschlagen: %m" #: storage/ipc/shm_toc.c:108 storage/ipc/shm_toc.c:189 storage/ipc/shmem.c:212 #: storage/lmgr/lock.c:883 storage/lmgr/lock.c:917 storage/lmgr/lock.c:2682 #: storage/lmgr/lock.c:4007 storage/lmgr/lock.c:4072 storage/lmgr/lock.c:4364 -#: storage/lmgr/predicate.c:2329 storage/lmgr/predicate.c:2344 -#: storage/lmgr/predicate.c:3736 storage/lmgr/predicate.c:4879 -#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1043 +#: storage/lmgr/predicate.c:2344 storage/lmgr/predicate.c:2359 +#: storage/lmgr/predicate.c:3751 storage/lmgr/predicate.c:4894 +#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1042 #, c-format msgid "out of shared memory" msgstr "Shared Memory aufgebraucht" @@ -16603,12 +16449,12 @@ msgstr "ShmemIndex-Eintraggröße ist falsch für Datenstruktur »%s«: erwartet msgid "requested shared memory size overflows size_t" msgstr "angeforderte Shared-Memory-Größe übersteigt Kapazität von size_t" -#: storage/ipc/standby.c:530 tcop/postgres.c:2976 +#: storage/ipc/standby.c:530 tcop/postgres.c:2974 #, c-format msgid "canceling statement due to conflict with recovery" msgstr "storniere Anfrage wegen Konflikt mit der Wiederherstellung" -#: storage/ipc/standby.c:531 tcop/postgres.c:2263 +#: storage/ipc/standby.c:531 tcop/postgres.c:2255 #, c-format msgid "User transaction caused buffer deadlock with recovery." msgstr "Benutzertransaktion hat Verklemmung (Deadlock) mit Wiederherstellung verursacht." @@ -16769,87 +16615,87 @@ msgstr "Sie müssen möglicherweise max_locks_per_transaction erhöhen." msgid "cannot PREPARE while holding both session-level and transaction-level locks on the same object" msgstr "PREPARE kann nicht ausgeführt werden, wenn für das selbe Objekt Sperren auf Sitzungsebene und auf Transaktionsebene gehalten werden" -#: storage/lmgr/predicate.c:675 +#: storage/lmgr/predicate.c:677 #, c-format msgid "not enough elements in RWConflictPool to record a read/write conflict" msgstr "nicht genügend Elemente in RWConflictPool, um einen Lese-/Schreibkonflikt aufzuzeichnen" -#: storage/lmgr/predicate.c:676 storage/lmgr/predicate.c:704 +#: storage/lmgr/predicate.c:678 storage/lmgr/predicate.c:706 #, c-format msgid "You might need to run fewer transactions at a time or increase max_connections." msgstr "Sie müssten entweder weniger Transaktionen auf einmal ausführen oder max_connections erhöhen." -#: storage/lmgr/predicate.c:703 +#: storage/lmgr/predicate.c:705 #, c-format msgid "not enough elements in RWConflictPool to record a potential read/write conflict" msgstr "nicht genügend Elemente in RWConflictPool, um einen möglichen Lese-/Schreibkonflikt aufzuzeichnen" -#: storage/lmgr/predicate.c:909 +#: storage/lmgr/predicate.c:912 #, c-format msgid "memory for serializable conflict tracking is nearly exhausted" msgstr "Speicher für die Verfolgung von Serialisierungskonflikten ist fast aufgebraucht" -#: storage/lmgr/predicate.c:910 +#: storage/lmgr/predicate.c:913 #, c-format msgid "There might be an idle transaction or a forgotten prepared transaction causing this." msgstr "Möglicherweise gibt es eine stillliegende Transaktion oder eine vergessene vorbereitete Transaktion, die der Grund dafür ist." -#: storage/lmgr/predicate.c:1190 storage/lmgr/predicate.c:1261 +#: storage/lmgr/predicate.c:1207 storage/lmgr/predicate.c:1279 #, c-format msgid "not enough shared memory for elements of data structure \"%s\" (%zu bytes requested)" msgstr "nicht genug Shared-Memory für Elemente der Datenstruktur »%s« (%zu Bytes angefordert)" -#: storage/lmgr/predicate.c:1549 +#: storage/lmgr/predicate.c:1564 #, c-format msgid "deferrable snapshot was unsafe; trying a new one" msgstr "aufschiebbarer Snapshot war unsicher; versuche einen neuen" -#: storage/lmgr/predicate.c:1588 +#: storage/lmgr/predicate.c:1603 #, c-format msgid "\"default_transaction_isolation\" is set to \"serializable\"." msgstr "»default_transaction_isolation« ist auf »serializable« gesetzt." -#: storage/lmgr/predicate.c:1589 +#: storage/lmgr/predicate.c:1604 #, c-format msgid "You can use \"SET default_transaction_isolation = 'repeatable read'\" to change the default." msgstr "Mit »SET default_transaction_isolation = 'repeatable read'« können Sie die Voreinstellung ändern." -#: storage/lmgr/predicate.c:1628 +#: storage/lmgr/predicate.c:1643 #, c-format msgid "a snapshot-importing transaction must not be READ ONLY DEFERRABLE" msgstr "eine Transaktion, die einen Snapshot importiert, must READ ONLY DEFERRABLE sein" -#: storage/lmgr/predicate.c:1706 utils/time/snapmgr.c:617 +#: storage/lmgr/predicate.c:1721 utils/time/snapmgr.c:617 #: utils/time/snapmgr.c:623 #, c-format msgid "could not import the requested snapshot" msgstr "konnte den angeforderten Snapshot nicht importieren" -#: storage/lmgr/predicate.c:1707 utils/time/snapmgr.c:624 +#: storage/lmgr/predicate.c:1722 utils/time/snapmgr.c:624 #, c-format msgid "The source transaction %u is not running anymore." msgstr "Die Quelltransaktion %u läuft nicht mehr." -#: storage/lmgr/predicate.c:2330 storage/lmgr/predicate.c:2345 -#: storage/lmgr/predicate.c:3737 +#: storage/lmgr/predicate.c:2345 storage/lmgr/predicate.c:2360 +#: storage/lmgr/predicate.c:3752 #, c-format msgid "You might need to increase max_pred_locks_per_transaction." msgstr "Sie müssen möglicherweise max_pred_locks_per_transaction erhöhen." -#: storage/lmgr/predicate.c:3891 storage/lmgr/predicate.c:3980 -#: storage/lmgr/predicate.c:3988 storage/lmgr/predicate.c:4027 -#: storage/lmgr/predicate.c:4266 storage/lmgr/predicate.c:4603 -#: storage/lmgr/predicate.c:4615 storage/lmgr/predicate.c:4657 -#: storage/lmgr/predicate.c:4695 +#: storage/lmgr/predicate.c:3906 storage/lmgr/predicate.c:3995 +#: storage/lmgr/predicate.c:4003 storage/lmgr/predicate.c:4042 +#: storage/lmgr/predicate.c:4281 storage/lmgr/predicate.c:4618 +#: storage/lmgr/predicate.c:4630 storage/lmgr/predicate.c:4672 +#: storage/lmgr/predicate.c:4710 #, c-format msgid "could not serialize access due to read/write dependencies among transactions" msgstr "konnte Zugriff nicht serialisieren wegen Lese-/Schreib-Abhängigkeiten zwischen Transaktionen" -#: storage/lmgr/predicate.c:3893 storage/lmgr/predicate.c:3982 -#: storage/lmgr/predicate.c:3990 storage/lmgr/predicate.c:4029 -#: storage/lmgr/predicate.c:4268 storage/lmgr/predicate.c:4605 -#: storage/lmgr/predicate.c:4617 storage/lmgr/predicate.c:4659 -#: storage/lmgr/predicate.c:4697 +#: storage/lmgr/predicate.c:3908 storage/lmgr/predicate.c:3997 +#: storage/lmgr/predicate.c:4005 storage/lmgr/predicate.c:4044 +#: storage/lmgr/predicate.c:4283 storage/lmgr/predicate.c:4620 +#: storage/lmgr/predicate.c:4632 storage/lmgr/predicate.c:4674 +#: storage/lmgr/predicate.c:4712 #, c-format msgid "The transaction might succeed if retried." msgstr "Die Transaktion könnte erfolgreich sein, wenn sie erneut versucht würde." @@ -16917,12 +16763,12 @@ msgstr "verfälschter Item-Zeiger: %u" msgid "corrupted item lengths: total %u, available space %u" msgstr "verfälschte Item-Längen: gesamt %u, verfügbarer Platz %u" -#: storage/page/bufpage.c:756 storage/page/bufpage.c:892 +#: storage/page/bufpage.c:756 #, c-format msgid "corrupted item pointer: offset = %u, size = %u" msgstr "verfälschter Item-Zeiger: offset = %u, size = %u" -#: storage/page/bufpage.c:997 +#: storage/page/bufpage.c:892 storage/page/bufpage.c:997 #, c-format msgid "corrupted item pointer: offset = %u, length = %u" msgstr "verfälschter Item-Zeiger: offset = %u, length = %u" @@ -17008,314 +16854,314 @@ msgstr "konnte Datei »%s« nicht öffnen (Zielblock %u): vorhergehendes Segment msgid "could not open file \"%s\" (target block %u): %m" msgstr "konnte Datei »%s« nicht öffnen (Zielblock %u): %m" -#: tcop/fastpath.c:111 tcop/fastpath.c:475 tcop/fastpath.c:605 +#: tcop/fastpath.c:111 tcop/fastpath.c:463 tcop/fastpath.c:593 #, c-format msgid "invalid argument size %d in function call message" msgstr "ungültige Argumentgröße %d in Funktionsaufruf-Message" -#: tcop/fastpath.c:291 tcop/postgres.c:992 tcop/postgres.c:1301 -#: tcop/postgres.c:1559 tcop/postgres.c:1964 tcop/postgres.c:2331 -#: tcop/postgres.c:2406 +#: tcop/fastpath.c:281 tcop/postgres.c:984 tcop/postgres.c:1293 +#: tcop/postgres.c:1551 tcop/postgres.c:1956 tcop/postgres.c:2323 +#: tcop/postgres.c:2398 #, c-format msgid "current transaction is aborted, commands ignored until end of transaction block" msgstr "aktuelle Transaktion wurde abgebrochen, Befehle werden bis zum Ende der Transaktion ignoriert" -#: tcop/fastpath.c:319 +#: tcop/fastpath.c:309 #, c-format msgid "fastpath function call: \"%s\" (OID %u)" msgstr "Fastpath-Funktionsaufruf: »%s« (OID %u)" -#: tcop/fastpath.c:401 tcop/postgres.c:1163 tcop/postgres.c:1426 -#: tcop/postgres.c:1805 tcop/postgres.c:2022 +#: tcop/fastpath.c:391 tcop/postgres.c:1155 tcop/postgres.c:1418 +#: tcop/postgres.c:1797 tcop/postgres.c:2014 #, c-format msgid "duration: %s ms" msgstr "Dauer: %s ms" -#: tcop/fastpath.c:405 +#: tcop/fastpath.c:395 #, c-format msgid "duration: %s ms fastpath function call: \"%s\" (OID %u)" msgstr "Dauer: %s ms Fastpath-Funktionsaufruf: »%s« (OID %u)" -#: tcop/fastpath.c:443 tcop/fastpath.c:570 +#: tcop/fastpath.c:431 tcop/fastpath.c:558 #, c-format msgid "function call message contains %d arguments but function requires %d" msgstr "Funktionsaufruf-Message enthält %d Argumente, aber Funktion benötigt %d" -#: tcop/fastpath.c:451 +#: tcop/fastpath.c:439 #, c-format msgid "function call message contains %d argument formats but %d arguments" msgstr "Funktionsaufruf-Message enthält %d Argumentformate aber %d Argumente" -#: tcop/fastpath.c:538 tcop/fastpath.c:621 +#: tcop/fastpath.c:526 tcop/fastpath.c:609 #, c-format msgid "incorrect binary data format in function argument %d" msgstr "falsches Binärdatenformat in Funktionsargument %d" -#: tcop/postgres.c:352 tcop/postgres.c:388 tcop/postgres.c:415 +#: tcop/postgres.c:344 tcop/postgres.c:380 tcop/postgres.c:407 #, c-format msgid "unexpected EOF on client connection" msgstr "unerwartetes EOF auf Client-Verbindung" -#: tcop/postgres.c:438 tcop/postgres.c:450 tcop/postgres.c:461 -#: tcop/postgres.c:473 tcop/postgres.c:4314 +#: tcop/postgres.c:430 tcop/postgres.c:442 tcop/postgres.c:453 +#: tcop/postgres.c:465 tcop/postgres.c:4300 #, c-format msgid "invalid frontend message type %d" msgstr "ungültiger Frontend-Message-Typ %d" -#: tcop/postgres.c:933 +#: tcop/postgres.c:925 #, c-format msgid "statement: %s" msgstr "Anweisung: %s" -#: tcop/postgres.c:1168 +#: tcop/postgres.c:1160 #, c-format msgid "duration: %s ms statement: %s" msgstr "Dauer: %s ms Anweisung: %s" -#: tcop/postgres.c:1218 +#: tcop/postgres.c:1210 #, c-format msgid "parse %s: %s" msgstr "Parsen %s: %s" -#: tcop/postgres.c:1274 +#: tcop/postgres.c:1266 #, c-format msgid "cannot insert multiple commands into a prepared statement" msgstr "kann nicht mehrere Befehle in vorbereitete Anweisung einfügen" -#: tcop/postgres.c:1431 +#: tcop/postgres.c:1423 #, c-format msgid "duration: %s ms parse %s: %s" msgstr "Dauer: %s ms Parsen %s: %s" -#: tcop/postgres.c:1476 +#: tcop/postgres.c:1468 #, c-format msgid "bind %s to %s" msgstr "Binden %s an %s" -#: tcop/postgres.c:1495 tcop/postgres.c:2312 +#: tcop/postgres.c:1487 tcop/postgres.c:2304 #, c-format msgid "unnamed prepared statement does not exist" msgstr "unbenannte vorbereitete Anweisung existiert nicht" -#: tcop/postgres.c:1537 +#: tcop/postgres.c:1529 #, c-format msgid "bind message has %d parameter formats but %d parameters" msgstr "Binden-Nachricht hat %d Parameterformate aber %d Parameter" -#: tcop/postgres.c:1543 +#: tcop/postgres.c:1535 #, c-format msgid "bind message supplies %d parameters, but prepared statement \"%s\" requires %d" msgstr "Binden-Nachricht enthält %d Parameter, aber vorbereitete Anweisung »%s« erfordert %d" -#: tcop/postgres.c:1712 +#: tcop/postgres.c:1704 #, c-format msgid "incorrect binary data format in bind parameter %d" msgstr "falsches Binärdatenformat in Binden-Parameter %d" -#: tcop/postgres.c:1810 +#: tcop/postgres.c:1802 #, c-format msgid "duration: %s ms bind %s%s%s: %s" msgstr "Dauer: %s ms Binden %s%s%s: %s" -#: tcop/postgres.c:1858 tcop/postgres.c:2392 +#: tcop/postgres.c:1850 tcop/postgres.c:2384 #, c-format msgid "portal \"%s\" does not exist" msgstr "Portal »%s« existiert nicht" -#: tcop/postgres.c:1943 +#: tcop/postgres.c:1935 #, c-format msgid "%s %s%s%s: %s" msgstr "%s %s%s%s: %s" -#: tcop/postgres.c:1945 tcop/postgres.c:2030 +#: tcop/postgres.c:1937 tcop/postgres.c:2022 msgid "execute fetch from" msgstr "Ausführen Fetch von" -#: tcop/postgres.c:1946 tcop/postgres.c:2031 +#: tcop/postgres.c:1938 tcop/postgres.c:2023 msgid "execute" msgstr "Ausführen" -#: tcop/postgres.c:2027 +#: tcop/postgres.c:2019 #, c-format msgid "duration: %s ms %s %s%s%s: %s" msgstr "Dauer: %s ms %s %s%s%s: %s" -#: tcop/postgres.c:2153 +#: tcop/postgres.c:2145 #, c-format msgid "prepare: %s" msgstr "Vorbereiten: %s" -#: tcop/postgres.c:2216 +#: tcop/postgres.c:2208 #, c-format msgid "parameters: %s" msgstr "Parameter: %s" -#: tcop/postgres.c:2235 +#: tcop/postgres.c:2227 #, c-format msgid "abort reason: recovery conflict" msgstr "Abbruchgrund: Konflikt bei Wiederherstellung" -#: tcop/postgres.c:2251 +#: tcop/postgres.c:2243 #, c-format msgid "User was holding shared buffer pin for too long." msgstr "Benutzer hat Shared-Buffer-Pin zu lange gehalten." -#: tcop/postgres.c:2254 +#: tcop/postgres.c:2246 #, c-format msgid "User was holding a relation lock for too long." msgstr "Benutzer hat Relationssperre zu lange gehalten." -#: tcop/postgres.c:2257 +#: tcop/postgres.c:2249 #, c-format msgid "User was or might have been using tablespace that must be dropped." msgstr "Benutzer hat (möglicherweise) einen Tablespace verwendet, der gelöscht werden muss." -#: tcop/postgres.c:2260 +#: tcop/postgres.c:2252 #, c-format msgid "User query might have needed to see row versions that must be removed." msgstr "Benutzeranfrage hat möglicherweise Zeilenversionen sehen müssen, die entfernt werden müssen." -#: tcop/postgres.c:2266 +#: tcop/postgres.c:2258 #, c-format msgid "User was connected to a database that must be dropped." msgstr "Benutzer war mit einer Datenbank verbunden, die gelöscht werden muss." -#: tcop/postgres.c:2595 +#: tcop/postgres.c:2587 #, c-format msgid "terminating connection because of crash of another server process" msgstr "Verbindung wird abgebrochen wegen Absturz eines anderen Serverprozesses" -#: tcop/postgres.c:2596 +#: tcop/postgres.c:2588 #, c-format msgid "The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory." msgstr "Der Postmaster hat diesen Serverprozess angewiesen, die aktuelle Transaktion zurückzurollen und die Sitzung zu beenden, weil ein anderer Serverprozess abnormal beendet wurde und möglicherweise das Shared Memory verfälscht hat." -#: tcop/postgres.c:2600 tcop/postgres.c:2904 +#: tcop/postgres.c:2592 tcop/postgres.c:2902 #, c-format msgid "In a moment you should be able to reconnect to the database and repeat your command." msgstr "In einem Moment sollten Sie wieder mit der Datenbank verbinden und Ihren Befehl wiederholen können." -#: tcop/postgres.c:2686 +#: tcop/postgres.c:2678 #, c-format msgid "floating-point exception" msgstr "Fließkommafehler" -#: tcop/postgres.c:2687 +#: tcop/postgres.c:2679 #, c-format msgid "An invalid floating-point operation was signaled. This probably means an out-of-range result or an invalid operation, such as division by zero." msgstr "Eine ungültige Fließkommaoperation wurde signalisiert. Das bedeutet wahrscheinlich ein Ergebnis außerhalb des gültigen Bereichs oder eine ungültige Operation, zum Beispiel Division durch null." -#: tcop/postgres.c:2849 +#: tcop/postgres.c:2847 #, c-format msgid "canceling authentication due to timeout" msgstr "storniere Authentifizierung wegen Zeitüberschreitung" -#: tcop/postgres.c:2853 +#: tcop/postgres.c:2851 #, c-format msgid "terminating autovacuum process due to administrator command" msgstr "Autovacuum-Prozess wird abgebrochen aufgrund von Anweisung des Administrators" -#: tcop/postgres.c:2859 tcop/postgres.c:2869 tcop/postgres.c:2902 +#: tcop/postgres.c:2857 tcop/postgres.c:2867 tcop/postgres.c:2900 #, c-format msgid "terminating connection due to conflict with recovery" msgstr "Verbindung wird abgebrochen wegen Konflikt mit der Wiederherstellung" -#: tcop/postgres.c:2875 +#: tcop/postgres.c:2873 #, c-format msgid "terminating connection due to administrator command" msgstr "Verbindung wird abgebrochen aufgrund von Anweisung des Administrators" -#: tcop/postgres.c:2885 +#: tcop/postgres.c:2883 #, c-format msgid "connection to client lost" msgstr "Verbindung zum Client wurde verloren" -#: tcop/postgres.c:2953 +#: tcop/postgres.c:2951 #, c-format msgid "canceling statement due to lock timeout" msgstr "storniere Anfrage wegen Zeitüberschreitung einer Sperre" -#: tcop/postgres.c:2960 +#: tcop/postgres.c:2958 #, c-format msgid "canceling statement due to statement timeout" msgstr "storniere Anfrage wegen Zeitüberschreitung der Anfrage" -#: tcop/postgres.c:2967 +#: tcop/postgres.c:2965 #, c-format msgid "canceling autovacuum task" msgstr "storniere Autovacuum-Aufgabe" -#: tcop/postgres.c:2990 +#: tcop/postgres.c:2988 #, c-format msgid "canceling statement due to user request" msgstr "storniere Anfrage wegen Benutzeraufforderung" -#: tcop/postgres.c:3000 +#: tcop/postgres.c:2998 #, c-format msgid "terminating connection due to idle-in-transaction timeout" msgstr "Verbindung wird abgebrochen wegen Zeitüberschreitung in inaktiver Transaktion" -#: tcop/postgres.c:3114 +#: tcop/postgres.c:3112 #, c-format msgid "stack depth limit exceeded" msgstr "Grenze für Stacktiefe überschritten" -#: tcop/postgres.c:3115 +#: tcop/postgres.c:3113 #, c-format msgid "Increase the configuration parameter \"max_stack_depth\" (currently %dkB), after ensuring the platform's stack depth limit is adequate." msgstr "Erhöhen Sie den Konfigurationsparameter »max_stack_depth« (aktuell %dkB), nachdem Sie sichergestellt haben, dass die Stacktiefenbegrenzung Ihrer Plattform ausreichend ist." -#: tcop/postgres.c:3178 +#: tcop/postgres.c:3176 #, c-format msgid "\"max_stack_depth\" must not exceed %ldkB." msgstr "»max_stack_depth« darf %ldkB nicht überschreiten." -#: tcop/postgres.c:3180 +#: tcop/postgres.c:3178 #, c-format msgid "Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent." msgstr "Erhöhen Sie die Stacktiefenbegrenzung Ihrer Plattform mit »ulimit -s« oder der lokalen Entsprechung." -#: tcop/postgres.c:3540 +#: tcop/postgres.c:3538 #, c-format msgid "invalid command-line argument for server process: %s" msgstr "ungültiges Kommandozeilenargument für Serverprozess: %s" -#: tcop/postgres.c:3541 tcop/postgres.c:3547 +#: tcop/postgres.c:3539 tcop/postgres.c:3545 #, c-format msgid "Try \"%s --help\" for more information." msgstr "Versuchen Sie »%s --help« für weitere Informationen." -#: tcop/postgres.c:3545 +#: tcop/postgres.c:3543 #, c-format msgid "%s: invalid command-line argument: %s" msgstr "%s: ungültiges Kommandozeilenargument: %s" -#: tcop/postgres.c:3607 +#: tcop/postgres.c:3605 #, c-format msgid "%s: no database nor user name specified" msgstr "%s: weder Datenbankname noch Benutzername angegeben" -#: tcop/postgres.c:4222 +#: tcop/postgres.c:4208 #, c-format msgid "invalid CLOSE message subtype %d" msgstr "ungültiger Subtyp %d von CLOSE-Message" -#: tcop/postgres.c:4257 +#: tcop/postgres.c:4243 #, c-format msgid "invalid DESCRIBE message subtype %d" msgstr "ungültiger Subtyp %d von DESCRIBE-Message" -#: tcop/postgres.c:4335 +#: tcop/postgres.c:4321 #, c-format msgid "fastpath function calls not supported in a replication connection" msgstr "Fastpath-Funktionsaufrufe werden auf einer Replikationsverbindung nicht unterstützt" -#: tcop/postgres.c:4339 +#: tcop/postgres.c:4325 #, c-format msgid "extended query protocol not supported in a replication connection" msgstr "erweitertes Anfrageprotokoll wird nicht auf einer Replikationsverbindung unterstützt" -#: tcop/postgres.c:4509 +#: tcop/postgres.c:4495 #, c-format msgid "disconnection: session time: %d:%02d:%02d.%03d user=%s database=%s host=%s%s%s" msgstr "Verbindungsende: Sitzungszeit: %d:%02d:%02d.%03d Benutzer=%s Datenbank=%s Host=%s%s%s" @@ -17708,8 +17554,8 @@ msgstr "aclremove wird nicht mehr unterstützt" msgid "unrecognized privilege type: \"%s\"" msgstr "unbekannter Privilegtyp: »%s«" -#: utils/adt/acl.c:3427 utils/adt/regproc.c:123 utils/adt/regproc.c:144 -#: utils/adt/regproc.c:319 +#: utils/adt/acl.c:3427 utils/adt/regproc.c:124 utils/adt/regproc.c:145 +#: utils/adt/regproc.c:320 #, c-format msgid "function \"%s\" does not exist" msgstr "Funktion »%s« existiert nicht" @@ -18072,7 +17918,7 @@ msgstr "ungültige Eingabesyntax für Typ money: »%s«" #: utils/adt/int8.c:657 utils/adt/int8.c:897 utils/adt/int8.c:1005 #: utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6818 #: utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 -#: utils/adt/timestamp.c:3499 +#: utils/adt/timestamp.c:3542 #, c-format msgid "division by zero" msgstr "Division durch Null" @@ -18082,7 +17928,7 @@ msgstr "Division durch Null" msgid "\"char\" out of range" msgstr "\"char\" ist außerhalb des gültigen Bereichs" -#: utils/adt/date.c:67 utils/adt/timestamp.c:94 utils/adt/varbit.c:52 +#: utils/adt/date.c:67 utils/adt/timestamp.c:95 utils/adt/varbit.c:52 #: utils/adt/varchar.c:45 #, c-format msgid "invalid type modifier" @@ -18110,17 +17956,17 @@ msgid "date out of range: \"%s\"" msgstr "date ist außerhalb des gültigen Bereichs: »%s«" #: utils/adt/date.c:222 utils/adt/date.c:456 utils/adt/date.c:480 -#: utils/adt/xml.c:2027 +#: utils/adt/xml.c:2031 #, c-format msgid "date out of range" msgstr "date ist außerhalb des gültigen Bereichs" -#: utils/adt/date.c:264 utils/adt/timestamp.c:593 +#: utils/adt/date.c:264 utils/adt/timestamp.c:594 #, c-format msgid "date field value out of range: %d-%02d-%02d" msgstr "Datum-Feldwert ist außerhalb des gültigen Bereichs: %d-%02d-%02d" -#: utils/adt/date.c:271 utils/adt/date.c:280 utils/adt/timestamp.c:599 +#: utils/adt/date.c:271 utils/adt/date.c:280 utils/adt/timestamp.c:600 #, c-format msgid "date out of range: %d-%02d-%02d" msgstr "date ist außerhalb des gültigen Bereichs: %d-%02d-%02d" @@ -18142,28 +17988,28 @@ msgstr "Datum ist außerhalb des gültigen Bereichs für Typ »timestamp«" #: utils/adt/formatting.c:3436 utils/adt/formatting.c:3504 #: utils/adt/json.c:1534 utils/adt/json.c:1556 utils/adt/jsonb.c:823 #: utils/adt/jsonb.c:847 utils/adt/nabstime.c:455 utils/adt/nabstime.c:498 -#: utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 utils/adt/timestamp.c:224 -#: utils/adt/timestamp.c:268 utils/adt/timestamp.c:726 -#: utils/adt/timestamp.c:735 utils/adt/timestamp.c:820 -#: utils/adt/timestamp.c:860 utils/adt/timestamp.c:3074 -#: utils/adt/timestamp.c:3095 utils/adt/timestamp.c:3108 -#: utils/adt/timestamp.c:3117 utils/adt/timestamp.c:3125 -#: utils/adt/timestamp.c:3180 utils/adt/timestamp.c:3203 -#: utils/adt/timestamp.c:3216 utils/adt/timestamp.c:3227 -#: utils/adt/timestamp.c:3235 utils/adt/timestamp.c:3809 -#: utils/adt/timestamp.c:3938 utils/adt/timestamp.c:3979 -#: utils/adt/timestamp.c:4067 utils/adt/timestamp.c:4113 -#: utils/adt/timestamp.c:4224 utils/adt/timestamp.c:4631 -#: utils/adt/timestamp.c:4747 utils/adt/timestamp.c:4757 -#: utils/adt/timestamp.c:4853 utils/adt/timestamp.c:4972 -#: utils/adt/timestamp.c:4982 utils/adt/timestamp.c:5234 -#: utils/adt/timestamp.c:5248 utils/adt/timestamp.c:5253 -#: utils/adt/timestamp.c:5267 utils/adt/timestamp.c:5316 -#: utils/adt/timestamp.c:5348 utils/adt/timestamp.c:5355 -#: utils/adt/timestamp.c:5381 utils/adt/timestamp.c:5385 -#: utils/adt/timestamp.c:5454 utils/adt/timestamp.c:5458 -#: utils/adt/timestamp.c:5472 utils/adt/timestamp.c:5510 utils/adt/xml.c:2049 -#: utils/adt/xml.c:2056 utils/adt/xml.c:2076 utils/adt/xml.c:2083 +#: utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 utils/adt/timestamp.c:225 +#: utils/adt/timestamp.c:269 utils/adt/timestamp.c:727 +#: utils/adt/timestamp.c:736 utils/adt/timestamp.c:818 +#: utils/adt/timestamp.c:858 utils/adt/timestamp.c:3117 +#: utils/adt/timestamp.c:3138 utils/adt/timestamp.c:3151 +#: utils/adt/timestamp.c:3160 utils/adt/timestamp.c:3168 +#: utils/adt/timestamp.c:3223 utils/adt/timestamp.c:3246 +#: utils/adt/timestamp.c:3259 utils/adt/timestamp.c:3270 +#: utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3852 +#: utils/adt/timestamp.c:3981 utils/adt/timestamp.c:4022 +#: utils/adt/timestamp.c:4110 utils/adt/timestamp.c:4156 +#: utils/adt/timestamp.c:4267 utils/adt/timestamp.c:4674 +#: utils/adt/timestamp.c:4790 utils/adt/timestamp.c:4800 +#: utils/adt/timestamp.c:4896 utils/adt/timestamp.c:5015 +#: utils/adt/timestamp.c:5025 utils/adt/timestamp.c:5277 +#: utils/adt/timestamp.c:5291 utils/adt/timestamp.c:5296 +#: utils/adt/timestamp.c:5310 utils/adt/timestamp.c:5359 +#: utils/adt/timestamp.c:5391 utils/adt/timestamp.c:5398 +#: utils/adt/timestamp.c:5424 utils/adt/timestamp.c:5428 +#: utils/adt/timestamp.c:5497 utils/adt/timestamp.c:5501 +#: utils/adt/timestamp.c:5515 utils/adt/timestamp.c:5553 utils/adt/xml.c:2053 +#: utils/adt/xml.c:2060 utils/adt/xml.c:2080 utils/adt/xml.c:2087 #, c-format msgid "timestamp out of range" msgstr "timestamp ist außerhalb des gültigen Bereichs" @@ -18184,7 +18030,7 @@ msgstr "abstime ist außerhalb des gültigen Bereichs für Typ »date«" msgid "time out of range" msgstr "time ist außerhalb des gültigen Bereichs" -#: utils/adt/date.c:1326 utils/adt/timestamp.c:618 +#: utils/adt/date.c:1326 utils/adt/timestamp.c:619 #, c-format msgid "time field value out of range: %d:%02d:%02g" msgstr "Zeit-Feldwert ist außerhalb des gültigen Bereichs: %d:%02d:%02g" @@ -18205,14 +18051,14 @@ msgid "\"time with time zone\" units \"%s\" not recognized" msgstr "»time with time zone«-Einheit »%s« nicht erkannt" #: utils/adt/date.c:2830 utils/adt/datetime.c:995 utils/adt/datetime.c:1917 -#: utils/adt/datetime.c:4743 utils/adt/timestamp.c:532 -#: utils/adt/timestamp.c:559 utils/adt/timestamp.c:5259 -#: utils/adt/timestamp.c:5464 +#: utils/adt/datetime.c:4743 utils/adt/timestamp.c:533 +#: utils/adt/timestamp.c:560 utils/adt/timestamp.c:5302 +#: utils/adt/timestamp.c:5507 #, c-format msgid "time zone \"%s\" not recognized" msgstr "Zeitzone »%s« nicht erkannt" -#: utils/adt/date.c:2870 utils/adt/timestamp.c:5301 utils/adt/timestamp.c:5495 +#: utils/adt/date.c:2870 utils/adt/timestamp.c:5344 utils/adt/timestamp.c:5538 #, c-format msgid "interval time zone \"%s\" must not include months or days" msgstr "Intervall-Zeitzone »%s« darf keine Monate oder Tage enthalten" @@ -18783,7 +18629,7 @@ msgid "oidvector has too many elements" msgstr "oidvector-Wert hat zu viele Elemente" #: utils/adt/int.c:1362 utils/adt/int8.c:1460 utils/adt/numeric.c:1351 -#: utils/adt/timestamp.c:5561 utils/adt/timestamp.c:5642 +#: utils/adt/timestamp.c:5604 utils/adt/timestamp.c:5685 #, c-format msgid "step size cannot equal zero" msgstr "Schrittgröße kann nicht gleich null sein" @@ -18930,15 +18776,12 @@ msgstr "JSON-Daten, Zeile %d: %s%s%s" msgid "key value must be scalar, not array, composite, or json" msgstr "Schlüsselwert muss skalar sein, nicht Array, zusammengesetzt oder json" -#: utils/adt/json.c:2006 +#: utils/adt/json.c:2006 utils/adt/json.c:2016 utils/adt/json.c:2142 +#: utils/adt/json.c:2163 utils/adt/json.c:2222 utils/adt/jsonb.c:1214 +#: utils/adt/jsonb.c:1237 utils/adt/jsonb.c:1297 #, c-format -msgid "could not determine data type for argument 1" -msgstr "konnte Datentyp von Argument 1 nicht ermitteln" - -#: utils/adt/json.c:2016 -#, c-format -msgid "could not determine data type for argument 2" -msgstr "konnte Datentyp von Argument 2 nicht ermitteln" +msgid "could not determine data type for argument %d" +msgstr "konnte Datentyp von Argument %d nicht ermitteln" #: utils/adt/json.c:2040 utils/adt/jsonb.c:1781 #, c-format @@ -18955,11 +18798,6 @@ msgstr "Argumentliste muss gerade Anzahl Elemente haben" msgid "The arguments of json_build_object() must consist of alternating keys and values." msgstr "Die Argumente von json_build_object() müssen abwechselnd Schlüssel und Werte sein." -#: utils/adt/json.c:2142 utils/adt/json.c:2163 utils/adt/json.c:2222 -#, c-format -msgid "could not determine data type for argument %d" -msgstr "konnte Datentyp von Argument %d nicht ermitteln" - #: utils/adt/json.c:2148 #, c-format msgid "argument %d cannot be null" @@ -19006,11 +18844,6 @@ msgstr "ungültige Anzahl Argumente: Objekt muss aus Schlüssel-Wert-Paaren best msgid "argument %d: key must not be null" msgstr "Argument %d: Schlüssel darf nicht NULL sein" -#: utils/adt/jsonb.c:1214 utils/adt/jsonb.c:1237 utils/adt/jsonb.c:1297 -#, c-format -msgid "argument %d: could not determine data type" -msgstr "Argument %d: konnte Datentypen nicht bestimmen" - #: utils/adt/jsonb.c:1834 #, c-format msgid "object keys must be strings" @@ -19166,7 +18999,7 @@ msgstr "Pfadelement auf Position %d ist keine ganze Zahl: »%s«" msgid "levenshtein argument exceeds maximum length of %d characters" msgstr "Levenshtein-Argument überschreitet die maximale Länge von %d Zeichen" -#: utils/adt/like.c:212 utils/adt/selfuncs.c:5333 +#: utils/adt/like.c:212 utils/adt/selfuncs.c:5433 #, c-format msgid "could not determine which collation to use for ILIKE" msgstr "konnte die für ILIKE zu verwendende Sortierfolge nicht bestimmen" @@ -19807,50 +19640,50 @@ msgstr "ungültige Option für regulären Ausdruck: »%c«" msgid "regexp_split does not support the global option" msgstr "regexp_split unterstützt die »Global«-Option nicht" -#: utils/adt/regproc.c:128 utils/adt/regproc.c:148 +#: utils/adt/regproc.c:129 utils/adt/regproc.c:149 #, c-format msgid "more than one function named \"%s\"" msgstr "es gibt mehrere Funktionen namens »%s«" -#: utils/adt/regproc.c:587 utils/adt/regproc.c:607 +#: utils/adt/regproc.c:588 utils/adt/regproc.c:608 #, c-format msgid "more than one operator named %s" msgstr "es gibt mehrere Operatoren namens %s" -#: utils/adt/regproc.c:779 utils/adt/regproc.c:820 utils/adt/regproc.c:2006 -#: utils/adt/ruleutils.c:8367 utils/adt/ruleutils.c:8536 +#: utils/adt/regproc.c:780 utils/adt/regproc.c:821 utils/adt/regproc.c:2007 +#: utils/adt/ruleutils.c:8453 utils/adt/ruleutils.c:8622 #, c-format msgid "too many arguments" msgstr "zu viele Argumente" -#: utils/adt/regproc.c:780 utils/adt/regproc.c:821 +#: utils/adt/regproc.c:781 utils/adt/regproc.c:822 #, c-format msgid "Provide two argument types for operator." msgstr "Geben Sie zwei Argumente für den Operator an." -#: utils/adt/regproc.c:1594 utils/adt/regproc.c:1618 utils/adt/regproc.c:1715 -#: utils/adt/regproc.c:1739 utils/adt/regproc.c:1841 utils/adt/regproc.c:1846 +#: utils/adt/regproc.c:1595 utils/adt/regproc.c:1619 utils/adt/regproc.c:1716 +#: utils/adt/regproc.c:1740 utils/adt/regproc.c:1842 utils/adt/regproc.c:1847 #: utils/adt/varlena.c:3084 utils/adt/varlena.c:3089 #, c-format msgid "invalid name syntax" msgstr "ungültige Namenssyntax" -#: utils/adt/regproc.c:1904 +#: utils/adt/regproc.c:1905 #, c-format msgid "expected a left parenthesis" msgstr "linke Klammer erwartet" -#: utils/adt/regproc.c:1920 +#: utils/adt/regproc.c:1921 #, c-format msgid "expected a right parenthesis" msgstr "rechte Klammer erwartet" -#: utils/adt/regproc.c:1939 +#: utils/adt/regproc.c:1940 #, c-format msgid "expected a type name" msgstr "Typname erwartet" -#: utils/adt/regproc.c:1971 +#: utils/adt/regproc.c:1972 #, c-format msgid "improper type name" msgstr "falscher Typname" @@ -19984,17 +19817,17 @@ msgstr "kann unterschiedliche Spaltentyp %s und %s in Record-Spalte %d nicht ver msgid "cannot compare record types with different numbers of columns" msgstr "kann Record-Typen mit unterschiedlicher Anzahl Spalten nicht vergleichen" -#: utils/adt/ruleutils.c:4289 +#: utils/adt/ruleutils.c:4297 #, c-format msgid "rule \"%s\" has unsupported event type %d" msgstr "Regel »%s« hat nicht unterstützten Ereignistyp %d" -#: utils/adt/selfuncs.c:5318 +#: utils/adt/selfuncs.c:5418 #, c-format msgid "case insensitive matching not supported on type bytea" msgstr "Mustersuche ohne Rücksicht auf Groß-/Kleinschreibung wird für Typ bytea nicht unterstützt" -#: utils/adt/selfuncs.c:5421 +#: utils/adt/selfuncs.c:5521 #, c-format msgid "regular-expression matching not supported on type bytea" msgstr "Mustersuche mit regulären Ausdrücken wird für Typ bytea nicht unterstützt" @@ -20004,137 +19837,136 @@ msgstr "Mustersuche mit regulären Ausdrücken wird für Typ bytea nicht unterst msgid "invalid input syntax for type tid: \"%s\"" msgstr "ungültige Eingabesyntax für Typ tid: »%s«" -#: utils/adt/timestamp.c:99 +#: utils/adt/timestamp.c:100 #, c-format msgid "TIMESTAMP(%d)%s precision must not be negative" msgstr "Präzision von TIMESTAMP(%d)%s darf nicht negativ sein" -#: utils/adt/timestamp.c:105 +#: utils/adt/timestamp.c:106 #, c-format msgid "TIMESTAMP(%d)%s precision reduced to maximum allowed, %d" msgstr "Präzision von TIMESTAMP(%d)%s auf erlaubten Höchstwert %d reduziert" -#: utils/adt/timestamp.c:170 utils/adt/timestamp.c:445 +#: utils/adt/timestamp.c:171 utils/adt/timestamp.c:446 #, c-format msgid "timestamp out of range: \"%s\"" msgstr "timestamp ist außerhalb des gültigen Bereichs: »%s«" -#: utils/adt/timestamp.c:188 utils/adt/timestamp.c:463 -#: utils/adt/timestamp.c:993 +#: utils/adt/timestamp.c:189 utils/adt/timestamp.c:464 +#: utils/adt/timestamp.c:991 #, c-format msgid "date/time value \"%s\" is no longer supported" msgstr "Datum/Zeit-Wert »%s« wird nicht mehr unterstützt" -#: utils/adt/timestamp.c:258 utils/adt/timestamp.c:754 +#: utils/adt/timestamp.c:259 utils/adt/timestamp.c:755 #, c-format msgid "timestamp cannot be NaN" msgstr "timestamp kann nicht NaN sein" -#: utils/adt/timestamp.c:380 +#: utils/adt/timestamp.c:381 #, c-format msgid "timestamp(%d) precision must be between %d and %d" msgstr "Präzision von timestamp(%d) muss zwischen %d und %d sein" -#: utils/adt/timestamp.c:513 +#: utils/adt/timestamp.c:514 #, c-format msgid "invalid input syntax for numeric time zone: \"%s\"" msgstr "ungültige Eingabesyntax für numerische Zeitzone: »%s«" -#: utils/adt/timestamp.c:515 +#: utils/adt/timestamp.c:516 #, c-format msgid "Numeric time zones must have \"-\" or \"+\" as first character." msgstr "Numerische Zeitzonen müssen »-« oder »+« als erstes Zeichen haben." -#: utils/adt/timestamp.c:528 +#: utils/adt/timestamp.c:529 #, c-format msgid "numeric time zone \"%s\" out of range" msgstr "numerische Zeitzone »%s« ist außerhalb des gültigen Bereichs" -#: utils/adt/timestamp.c:631 utils/adt/timestamp.c:641 -#: utils/adt/timestamp.c:653 +#: utils/adt/timestamp.c:632 utils/adt/timestamp.c:642 +#: utils/adt/timestamp.c:654 #, c-format msgid "timestamp out of range: %d-%02d-%02d %d:%02d:%02g" msgstr "timestamp ist außerhalb des gültigen Bereichs: %d-%02d-%02d %d:%02d:%02g" -#: utils/adt/timestamp.c:770 utils/adt/timestamp.c:776 -#: utils/adt/timestamp.c:791 +#: utils/adt/timestamp.c:773 utils/adt/timestamp.c:789 #, c-format msgid "timestamp out of range: \"%g\"" msgstr "timestamp ist außerhalb des gültigen Bereichs: »%g«" -#: utils/adt/timestamp.c:987 utils/adt/timestamp.c:1611 -#: utils/adt/timestamp.c:2121 utils/adt/timestamp.c:3273 -#: utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3283 -#: utils/adt/timestamp.c:3333 utils/adt/timestamp.c:3340 -#: utils/adt/timestamp.c:3347 utils/adt/timestamp.c:3367 -#: utils/adt/timestamp.c:3374 utils/adt/timestamp.c:3381 -#: utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3419 -#: utils/adt/timestamp.c:3464 utils/adt/timestamp.c:3804 -#: utils/adt/timestamp.c:3933 utils/adt/timestamp.c:4324 +#: utils/adt/timestamp.c:985 utils/adt/timestamp.c:1609 +#: utils/adt/timestamp.c:2122 utils/adt/timestamp.c:3316 +#: utils/adt/timestamp.c:3321 utils/adt/timestamp.c:3326 +#: utils/adt/timestamp.c:3376 utils/adt/timestamp.c:3383 +#: utils/adt/timestamp.c:3390 utils/adt/timestamp.c:3410 +#: utils/adt/timestamp.c:3417 utils/adt/timestamp.c:3424 +#: utils/adt/timestamp.c:3454 utils/adt/timestamp.c:3462 +#: utils/adt/timestamp.c:3507 utils/adt/timestamp.c:3847 +#: utils/adt/timestamp.c:3976 utils/adt/timestamp.c:4367 #, c-format msgid "interval out of range" msgstr "interval-Wert ist außerhalb des gültigen Bereichs" -#: utils/adt/timestamp.c:1128 utils/adt/timestamp.c:1161 +#: utils/adt/timestamp.c:1126 utils/adt/timestamp.c:1159 #, c-format msgid "invalid INTERVAL type modifier" msgstr "ungültiger Modifikator für Typ INTERVAL" -#: utils/adt/timestamp.c:1144 +#: utils/adt/timestamp.c:1142 #, c-format msgid "INTERVAL(%d) precision must not be negative" msgstr "INTERVAL(%d)-Präzision darf nicht negativ sein" -#: utils/adt/timestamp.c:1150 +#: utils/adt/timestamp.c:1148 #, c-format msgid "INTERVAL(%d) precision reduced to maximum allowed, %d" msgstr "INTERVAL(%d)-Präzision auf erlaubtes Maximum %d reduziert" -#: utils/adt/timestamp.c:1555 +#: utils/adt/timestamp.c:1553 #, c-format msgid "interval(%d) precision must be between %d and %d" msgstr "Präzision von interval(%d) muss zwischen %d und %d sein" -#: utils/adt/timestamp.c:2850 +#: utils/adt/timestamp.c:2893 #, c-format msgid "cannot subtract infinite timestamps" msgstr "kann unendliche timestamp-Werte nicht subtrahieren" -#: utils/adt/timestamp.c:4059 utils/adt/timestamp.c:4584 -#: utils/adt/timestamp.c:4768 utils/adt/timestamp.c:4793 +#: utils/adt/timestamp.c:4102 utils/adt/timestamp.c:4627 +#: utils/adt/timestamp.c:4811 utils/adt/timestamp.c:4836 #, c-format msgid "timestamp units \"%s\" not supported" msgstr "»timestamp«-Einheit »%s« nicht unterstützt" -#: utils/adt/timestamp.c:4073 utils/adt/timestamp.c:4538 -#: utils/adt/timestamp.c:4803 +#: utils/adt/timestamp.c:4116 utils/adt/timestamp.c:4581 +#: utils/adt/timestamp.c:4846 #, c-format msgid "timestamp units \"%s\" not recognized" msgstr "»timestamp«-Einheit »%s« nicht erkannt" -#: utils/adt/timestamp.c:4213 utils/adt/timestamp.c:4579 -#: utils/adt/timestamp.c:4990 utils/adt/timestamp.c:5016 +#: utils/adt/timestamp.c:4256 utils/adt/timestamp.c:4622 +#: utils/adt/timestamp.c:5033 utils/adt/timestamp.c:5059 #, c-format msgid "timestamp with time zone units \"%s\" not supported" msgstr "»timestamp with time zone«-Einheit »%s« nicht unterstützt" -#: utils/adt/timestamp.c:4230 utils/adt/timestamp.c:4533 -#: utils/adt/timestamp.c:5025 +#: utils/adt/timestamp.c:4273 utils/adt/timestamp.c:4576 +#: utils/adt/timestamp.c:5068 #, c-format msgid "timestamp with time zone units \"%s\" not recognized" msgstr "»timestamp with time zone«-Einheit »%s« nicht erkannt" -#: utils/adt/timestamp.c:4311 +#: utils/adt/timestamp.c:4354 #, c-format msgid "interval units \"%s\" not supported because months usually have fractional weeks" msgstr "»interval«-Einheit »%s« wird nicht unterstützt, weil Monate gewöhnlich partielle Wochen haben" -#: utils/adt/timestamp.c:4317 utils/adt/timestamp.c:5131 +#: utils/adt/timestamp.c:4360 utils/adt/timestamp.c:5174 #, c-format msgid "interval units \"%s\" not supported" msgstr "»interval«-Einheit »%s« nicht unterstützt" -#: utils/adt/timestamp.c:4333 utils/adt/timestamp.c:5158 +#: utils/adt/timestamp.c:4376 utils/adt/timestamp.c:5201 #, c-format msgid "interval units \"%s\" not recognized" msgstr "»interval«-Einheit »%s« nicht erkannt" @@ -20494,141 +20326,141 @@ msgstr "Argument von ntile muss größer als null sein" msgid "argument of nth_value must be greater than zero" msgstr "Argument von nth_value muss größer als null sein" -#: utils/adt/xml.c:171 +#: utils/adt/xml.c:175 #, c-format msgid "unsupported XML feature" msgstr "nicht unterstützte XML-Funktionalität" -#: utils/adt/xml.c:172 +#: utils/adt/xml.c:176 #, c-format msgid "This functionality requires the server to be built with libxml support." msgstr "Diese Funktionalität verlangt, dass der Server mit Libxml-Unterstützung gebaut wird." -#: utils/adt/xml.c:173 +#: utils/adt/xml.c:177 #, c-format msgid "You need to rebuild PostgreSQL using --with-libxml." msgstr "Sie müssen PostgreSQL mit --with-libxml neu bauen." -#: utils/adt/xml.c:192 utils/mb/mbutils.c:523 +#: utils/adt/xml.c:196 utils/mb/mbutils.c:523 #, c-format msgid "invalid encoding name \"%s\"" msgstr "ungültiger Kodierungsname »%s«" -#: utils/adt/xml.c:435 utils/adt/xml.c:440 +#: utils/adt/xml.c:439 utils/adt/xml.c:444 #, c-format msgid "invalid XML comment" msgstr "ungültiger XML-Kommentar" -#: utils/adt/xml.c:569 +#: utils/adt/xml.c:573 #, c-format msgid "not an XML document" msgstr "kein XML-Dokument" -#: utils/adt/xml.c:728 utils/adt/xml.c:751 +#: utils/adt/xml.c:732 utils/adt/xml.c:755 #, c-format msgid "invalid XML processing instruction" msgstr "ungültige XML-Verarbeitungsanweisung" -#: utils/adt/xml.c:729 +#: utils/adt/xml.c:733 #, c-format msgid "XML processing instruction target name cannot be \"%s\"." msgstr "Die Zielangabe der XML-Verarbeitungsanweisung darf nicht »%s« sein." -#: utils/adt/xml.c:752 +#: utils/adt/xml.c:756 #, c-format msgid "XML processing instruction cannot contain \"?>\"." msgstr "XML-Verarbeitungsanweisung darf nicht »?>« enthalten." -#: utils/adt/xml.c:831 +#: utils/adt/xml.c:835 #, c-format msgid "xmlvalidate is not implemented" msgstr "xmlvalidate ist nicht implementiert" -#: utils/adt/xml.c:910 +#: utils/adt/xml.c:914 #, c-format msgid "could not initialize XML library" msgstr "konnte XML-Bibliothek nicht initialisieren" -#: utils/adt/xml.c:911 +#: utils/adt/xml.c:915 #, c-format msgid "libxml2 has incompatible char type: sizeof(char)=%u, sizeof(xmlChar)=%u." msgstr "libxml2 hat inkompatiblen char-Typ: sizeof(char)=%u, sizeof(xmlChar)=%u." -#: utils/adt/xml.c:997 +#: utils/adt/xml.c:1001 #, c-format msgid "could not set up XML error handler" msgstr "konnte XML-Fehlerbehandlung nicht einrichten" -#: utils/adt/xml.c:998 +#: utils/adt/xml.c:1002 #, c-format msgid "This probably indicates that the version of libxml2 being used is not compatible with the libxml2 header files that PostgreSQL was built with." msgstr "Das deutet wahrscheinlich darauf hin, dass die verwendete Version von libxml2 nicht mit den Header-Dateien der Version, mit der PostgreSQL gebaut wurde, kompatibel ist." -#: utils/adt/xml.c:1735 +#: utils/adt/xml.c:1739 msgid "Invalid character value." msgstr "Ungültiger Zeichenwert." -#: utils/adt/xml.c:1738 +#: utils/adt/xml.c:1742 msgid "Space required." msgstr "Leerzeichen benötigt." -#: utils/adt/xml.c:1741 +#: utils/adt/xml.c:1745 msgid "standalone accepts only 'yes' or 'no'." msgstr "standalone akzeptiert nur »yes« oder »no«." -#: utils/adt/xml.c:1744 +#: utils/adt/xml.c:1748 msgid "Malformed declaration: missing version." msgstr "Fehlerhafte Deklaration: Version fehlt." -#: utils/adt/xml.c:1747 +#: utils/adt/xml.c:1751 msgid "Missing encoding in text declaration." msgstr "Fehlende Kodierung in Textdeklaration." -#: utils/adt/xml.c:1750 +#: utils/adt/xml.c:1754 msgid "Parsing XML declaration: '?>' expected." msgstr "Beim Parsen der XML-Deklaration: »?>« erwartet." -#: utils/adt/xml.c:1753 +#: utils/adt/xml.c:1757 #, c-format msgid "Unrecognized libxml error code: %d." msgstr "Unbekannter Libxml-Fehlercode: %d." -#: utils/adt/xml.c:2028 +#: utils/adt/xml.c:2032 #, c-format msgid "XML does not support infinite date values." msgstr "XML unterstützt keine unendlichen Datumswerte." -#: utils/adt/xml.c:2050 utils/adt/xml.c:2077 +#: utils/adt/xml.c:2054 utils/adt/xml.c:2081 #, c-format msgid "XML does not support infinite timestamp values." msgstr "XML unterstützt keine unendlichen timestamp-Werte." -#: utils/adt/xml.c:2468 +#: utils/adt/xml.c:2481 #, c-format msgid "invalid query" msgstr "ungültige Anfrage" -#: utils/adt/xml.c:3793 +#: utils/adt/xml.c:3806 #, c-format msgid "invalid array for XML namespace mapping" msgstr "ungültiges Array for XML-Namensraumabbildung" -#: utils/adt/xml.c:3794 +#: utils/adt/xml.c:3807 #, c-format msgid "The array must be two-dimensional with length of the second axis equal to 2." msgstr "Das Array muss zweidimensional sein und die Länge der zweiten Achse muss gleich 2 sein." -#: utils/adt/xml.c:3818 +#: utils/adt/xml.c:3831 #, c-format msgid "empty XPath expression" msgstr "leerer XPath-Ausdruck" -#: utils/adt/xml.c:3867 +#: utils/adt/xml.c:3880 #, c-format msgid "neither namespace name nor URI may be null" msgstr "weder Namensraumname noch URI dürfen NULL sein" -#: utils/adt/xml.c:3874 +#: utils/adt/xml.c:3887 #, c-format msgid "could not register XML namespace with name \"%s\" and URI \"%s\"" msgstr "konnte XML-Namensraum mit Namen »%s« und URI »%s« nicht registrieren" @@ -20654,17 +20486,17 @@ msgstr "keine Ausgabefunktion verfügbar für Typ %s" msgid "cached plan must not change result type" msgstr "gecachter Plan darf den Ergebnistyp nicht ändern" -#: utils/cache/relcache.c:5199 +#: utils/cache/relcache.c:5226 #, c-format msgid "could not create relation-cache initialization file \"%s\": %m" msgstr "konnte Initialisierungsdatei für Relationscache »%s« nicht erzeugen: %m" -#: utils/cache/relcache.c:5201 +#: utils/cache/relcache.c:5228 #, c-format msgid "Continuing anyway, but there's something wrong." msgstr "Setze trotzdem fort, aber irgendwas stimmt nicht." -#: utils/cache/relcache.c:5475 +#: utils/cache/relcache.c:5502 #, c-format msgid "could not remove cache file \"%s\": %m" msgstr "konnte Cache-Datei »%s« nicht löschen: %m" @@ -23007,6 +22839,12 @@ msgstr "interner Fehler: unbekannter Parametertyp\n" msgid "query-specified return tuple and function return type are not compatible" msgstr "in der Anfrage angegebenes Rückgabetupel und Rückgabetyp der Funktion sind nicht kompatibel" +#. translator: %d.%02ds is system CPU time, %d.%02du is user CPU time +#: utils/misc/pg_rusage.c:66 +#, c-format +msgid "CPU %d.%02ds/%d.%02du sec elapsed %d.%02d sec" +msgstr "CPU %d.%02ds/%d.%02du sek abgelaufen %d.%02d sek" + #: utils/misc/rls.c:127 #, c-format msgid "query would be affected by row-level security policy for table \"%s\"" @@ -23087,7 +22925,7 @@ msgstr "Zeile ist zu lang in Zeitzonendatei »%s«, Zeile %d" msgid "@INCLUDE without file name in time zone file \"%s\", line %d" msgstr "@INCLUDE ohne Dateiname in Zeitzonendatei »%s«, Zeile %d" -#: utils/mmgr/aset.c:510 +#: utils/mmgr/aset.c:511 #, c-format msgid "Failed while creating memory context \"%s\"." msgstr "Fehler während der Erzeugung des Speicherkontexts »%s«." @@ -23135,17 +22973,17 @@ msgstr "konnte Block %ld von temporärer Datei nicht lesen: %m" msgid "cannot have more than %d runs for an external sort" msgstr "ein externer Sortiervorgang kann nicht mehr als %d Durchgänge haben" -#: utils/sort/tuplesort.c:4474 +#: utils/sort/tuplesort.c:4479 #, c-format msgid "could not create unique index \"%s\"" msgstr "konnte Unique Index »%s« nicht erstellen" -#: utils/sort/tuplesort.c:4476 +#: utils/sort/tuplesort.c:4481 #, c-format msgid "Key %s is duplicated." msgstr "Schlüssel %s ist doppelt vorhanden." -#: utils/sort/tuplesort.c:4477 +#: utils/sort/tuplesort.c:4482 #, c-format msgid "Duplicate keys exist." msgstr "Es existieren doppelte Schlüssel." diff --git a/src/backend/po/es.po b/src/backend/po/es.po index 02d7c388ef..3121705f70 100644 --- a/src/backend/po/es.po +++ b/src/backend/po/es.po @@ -61,8 +61,8 @@ msgid "" msgstr "" "Project-Id-Version: PostgreSQL server 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:49+0000\n" -"PO-Revision-Date: 2017-05-21 21:10-0400\n" +"POT-Creation-Date: 2017-08-27 21:47+0000\n" +"PO-Revision-Date: 2017-08-28 11:37+0200\n" "Last-Translator: Ãlvaro Herrera \n" "Language-Team: PgSQL Español \n" "Language: es\n" @@ -91,13 +91,13 @@ msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: no se pudo abrir el archivo «%s» para lectura: %s\n" #: ../common/controldata_utils.c:66 access/transam/timeline.c:346 -#: access/transam/xlog.c:3226 access/transam/xlog.c:10442 -#: access/transam/xlog.c:10455 access/transam/xlog.c:10850 -#: access/transam/xlog.c:10893 access/transam/xlog.c:10932 -#: access/transam/xlog.c:10975 access/transam/xlogfuncs.c:660 +#: access/transam/xlog.c:3226 access/transam/xlog.c:10453 +#: access/transam/xlog.c:10466 access/transam/xlog.c:10861 +#: access/transam/xlog.c:10904 access/transam/xlog.c:10943 +#: access/transam/xlog.c:10986 access/transam/xlogfuncs.c:660 #: access/transam/xlogfuncs.c:679 commands/extension.c:3154 #: replication/logical/origin.c:668 replication/logical/origin.c:698 -#: replication/logical/reorderbuffer.c:3099 replication/walsender.c:499 +#: replication/logical/reorderbuffer.c:3100 replication/walsender.c:504 #: storage/file/copydir.c:176 utils/adt/genfile.c:151 #, c-format msgid "could not read file \"%s\": %m" @@ -207,25 +207,24 @@ msgid "could not close directory \"%s\": %s\n" msgstr "no se pudo cerrar el directorio «%s»: %s\n" #: ../common/psprintf.c:179 ../port/path.c:630 ../port/path.c:668 -#: ../port/path.c:685 access/transam/twophase.c:1262 -#: access/transam/xlog.c:6114 lib/stringinfo.c:258 libpq/auth.c:850 -#: libpq/auth.c:1213 libpq/auth.c:1281 libpq/auth.c:1797 -#: postmaster/bgworker.c:310 postmaster/bgworker.c:813 -#: postmaster/postmaster.c:2349 postmaster/postmaster.c:2380 -#: postmaster/postmaster.c:3913 postmaster/postmaster.c:4603 -#: postmaster/postmaster.c:4678 postmaster/postmaster.c:5353 -#: postmaster/postmaster.c:5657 +#: ../port/path.c:685 access/transam/twophase.c:1262 access/transam/xlog.c:6114 +#: lib/stringinfo.c:258 libpq/auth.c:864 libpq/auth.c:1227 libpq/auth.c:1295 +#: libpq/auth.c:1811 postmaster/bgworker.c:310 postmaster/bgworker.c:813 +#: postmaster/postmaster.c:2357 postmaster/postmaster.c:2388 +#: postmaster/postmaster.c:3922 postmaster/postmaster.c:4620 +#: postmaster/postmaster.c:4695 postmaster/postmaster.c:5368 +#: postmaster/postmaster.c:5690 #: replication/libpqwalreceiver/libpqwalreceiver.c:143 #: replication/logical/logical.c:169 storage/buffer/localbuf.c:436 #: storage/file/fd.c:736 storage/file/fd.c:1164 storage/file/fd.c:1282 -#: storage/file/fd.c:1993 storage/ipc/procarray.c:1061 -#: storage/ipc/procarray.c:1547 storage/ipc/procarray.c:1554 -#: storage/ipc/procarray.c:1968 storage/ipc/procarray.c:2579 +#: storage/file/fd.c:1993 storage/ipc/procarray.c:1062 +#: storage/ipc/procarray.c:1548 storage/ipc/procarray.c:1555 +#: storage/ipc/procarray.c:1969 storage/ipc/procarray.c:2580 #: utils/adt/formatting.c:1522 utils/adt/formatting.c:1642 #: utils/adt/formatting.c:1763 utils/adt/pg_locale.c:463 #: utils/adt/pg_locale.c:647 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 #: utils/adt/varlena.c:4461 utils/fmgr/dfmgr.c:216 utils/hash/dynahash.c:429 -#: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1047 utils/mb/mbutils.c:376 +#: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1046 utils/mb/mbutils.c:376 #: utils/mb/mbutils.c:709 utils/misc/guc.c:3888 utils/misc/guc.c:3904 #: utils/misc/guc.c:3917 utils/misc/guc.c:6863 utils/misc/tzparser.c:468 #: utils/mmgr/aset.c:510 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 @@ -296,7 +295,7 @@ msgstr "no se pudo eliminar el directorio «%s»: %s\n" msgid "could not look up effective user ID %ld: %s" msgstr "no se pudo encontrar el ID de usuario efectivo %ld: %s" -#: ../common/username.c:47 libpq/auth.c:1744 +#: ../common/username.c:47 libpq/auth.c:1758 msgid "user does not exist" msgstr "usuario no existe" @@ -345,8 +344,7 @@ msgstr "el proceso hijo terminó con código no reconocido %d" msgid "could not determine encoding for codeset \"%s\"" msgstr "no se pudo determinar la codificación para el codeset «%s»" -#: ../port/chklocale.c:294 ../port/chklocale.c:423 -#: postmaster/postmaster.c:4882 +#: ../port/chklocale.c:294 ../port/chklocale.c:423 postmaster/postmaster.c:4899 #, c-format msgid "Please report this to ." msgstr "Por favor reporte esto a ." @@ -434,61 +432,76 @@ msgstr "«%s» no es un índice BRIN" msgid "could not open parent table of index %s" msgstr "no se pudo abrir la tabla padre del índice %s" -#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:362 -#: access/brin/brin_pageops.c:828 +#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:360 +#: access/brin/brin_pageops.c:824 access/gin/ginentrypage.c:109 +#: access/gist/gist.c:1337 access/nbtree/nbtinsert.c:576 +#: access/nbtree/nbtsort.c:488 access/spgist/spgdoinsert.c:1907 #, c-format -msgid "index row size %lu exceeds maximum %lu for index \"%s\"" -msgstr "el tamaño de fila de índice %lu excede el máximo %lu para el índice «%s»" +msgid "index row size %zu exceeds maximum %zu for index \"%s\"" +msgstr "el tamaño de fila de índice %zu excede el máximo %zu para el índice «%s»" #: access/brin/brin_revmap.c:459 #, c-format msgid "unexpected page type 0x%04X in BRIN index \"%s\" block %u" msgstr "tipo de página 0x%04X inesperado en el índice BRIN «%s» bloque %u" -#: access/brin/brin_validate.c:115 +#: access/brin/brin_validate.c:115 access/gin/ginvalidate.c:148 +#: access/gist/gistvalidate.c:145 access/hash/hashvalidate.c:130 +#: access/nbtree/nbtvalidate.c:100 access/spgist/spgvalidate.c:115 #, c-format -msgid "brin operator family \"%s\" contains function %s with invalid support number %d" -msgstr "familia de operadores brin «%s» contiene la función %s con número de soporte %d no válido" +msgid "operator family \"%s\" of access method %s contains function %s with invalid support number %d" +msgstr "familia de operadores «%s» de método de acceso %s contiene la función %s con número de soporte %d no válido" -#: access/brin/brin_validate.c:131 +#: access/brin/brin_validate.c:131 access/gin/ginvalidate.c:160 +#: access/gist/gistvalidate.c:157 access/hash/hashvalidate.c:113 +#: access/nbtree/nbtvalidate.c:112 access/spgist/spgvalidate.c:127 #, c-format -msgid "brin operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "familia de operadores brin «%s» contiene la función %s con signatura incorrecta para el número de soporte %d" +msgid "operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d" +msgstr "familia de operadores «%s» del método de acceso %s contiene la función %s con signatura incorrecta para el número de soporte %d" -#: access/brin/brin_validate.c:153 +#: access/brin/brin_validate.c:153 access/gin/ginvalidate.c:179 +#: access/gist/gistvalidate.c:177 access/hash/hashvalidate.c:151 +#: access/nbtree/nbtvalidate.c:132 access/spgist/spgvalidate.c:146 #, c-format -msgid "brin operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "familia de operadores brin «%s» contiene el operador %s con número de estrategia %d no válido" +msgid "operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d" +msgstr "familia de operadores «%s» del método de acceso %s contiene el operador %s con número de estrategia %d no válido" -#: access/brin/brin_validate.c:182 +#: access/brin/brin_validate.c:182 access/gin/ginvalidate.c:192 +#: access/hash/hashvalidate.c:164 access/nbtree/nbtvalidate.c:145 +#: access/spgist/spgvalidate.c:159 #, c-format -msgid "brin operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "familia de operadores brin «%s» contiene especificación ORDER BY no válida para el operador %s" +msgid "operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s" +msgstr "familia de operadores «%s» del método de acceso %s contiene especificación ORDER BY no válida para el operador %s" -#: access/brin/brin_validate.c:195 +#: access/brin/brin_validate.c:195 access/gin/ginvalidate.c:205 +#: access/gist/gistvalidate.c:225 access/hash/hashvalidate.c:177 +#: access/nbtree/nbtvalidate.c:158 access/spgist/spgvalidate.c:172 #, c-format -msgid "brin operator family \"%s\" contains operator %s with wrong signature" -msgstr "familia de operadores brin «%s» contiene el operador %s con signatura incorrecta" +msgid "operator family \"%s\" of access method %s contains operator %s with wrong signature" +msgstr "familia de operadores «%s» del método de acceso %s contiene el operador %s con signatura incorrecta" -#: access/brin/brin_validate.c:233 +#: access/brin/brin_validate.c:233 access/hash/hashvalidate.c:217 +#: access/nbtree/nbtvalidate.c:200 access/spgist/spgvalidate.c:200 #, c-format -msgid "brin operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "el/los operador(es) para los tipos %2$s y %3$s faltan de la familia de operadores brin «%1$s»" +msgid "operator family \"%s\" of access method %s is missing operator(s) for types %s and %s" +msgstr "el/los operador(es) para los tipos %3$s y %4$s faltan de la familia de operadores «%1$s» del método de acceso %2$s" #: access/brin/brin_validate.c:243 #, c-format -msgid "brin operator family \"%s\" is missing support function(s) for types %s and %s" -msgstr "la(s) función/funciones de soporte para los tipos %2$s y %3$s faltan de la familia de operadores brin «%1$s»" +msgid "operator family \"%s\" of access method %s is missing support function(s) for types %s and %s" +msgstr "la(s) función/funciones de soporte para los tipos %3$s y %4$s faltan de la familia de operadores «%1$s» del método de acceso %2$s" -#: access/brin/brin_validate.c:256 +#: access/brin/brin_validate.c:256 access/hash/hashvalidate.c:231 +#: access/nbtree/nbtvalidate.c:224 access/spgist/spgvalidate.c:233 #, c-format -msgid "brin operator class \"%s\" is missing operator(s)" -msgstr "faltan operadores de la clase de operadores brin «%s»" +msgid "operator class \"%s\" of access method %s is missing operator(s)" +msgstr "faltan operadores de la clase de operadores «%s» del método de acceso %s" -#: access/brin/brin_validate.c:267 +#: access/brin/brin_validate.c:267 access/gin/ginvalidate.c:246 +#: access/gist/gistvalidate.c:264 #, c-format -msgid "brin operator class \"%s\" is missing support function %d" -msgstr "falta la función de soporte %2$d de la clase de operadores brin «%1$s»" +msgid "operator class \"%s\" of access method %s is missing support function %d" +msgstr "falta la función de soporte %3$d de la clase de operadores «%1$s» del método de acceso %2$s" #: access/common/heaptuple.c:708 access/common/heaptuple.c:1339 #, c-format @@ -506,7 +519,7 @@ msgid "index row requires %zu bytes, maximum size is %zu" msgstr "fila de índice requiere %zu bytes, tamaño máximo es %zu" #: access/common/printtup.c:292 tcop/fastpath.c:182 tcop/fastpath.c:532 -#: tcop/postgres.c:1719 +#: tcop/postgres.c:1711 #, c-format msgid "unsupported format code: %d" msgstr "código de formato no soportado: %d" @@ -601,15 +614,8 @@ msgstr "la «posting list» es demasiado larga" msgid "Reduce maintenance_work_mem." msgstr "Reduzca maintenance_work_mem." -#: access/gin/ginentrypage.c:109 access/gist/gist.c:1337 -#: access/nbtree/nbtinsert.c:576 access/nbtree/nbtsort.c:488 -#: access/spgist/spgdoinsert.c:1907 -#, c-format -msgid "index row size %zu exceeds maximum %zu for index \"%s\"" -msgstr "el tamaño de fila de índice %zu excede el máximo %zu para el índice «%s»" - -#: access/gin/ginfast.c:989 access/transam/xlog.c:9864 -#: access/transam/xlog.c:10381 access/transam/xlogfuncs.c:288 +#: access/gin/ginfast.c:989 access/transam/xlog.c:9875 +#: access/transam/xlog.c:10392 access/transam/xlogfuncs.c:288 #: access/transam/xlogfuncs.c:315 access/transam/xlogfuncs.c:354 #: access/transam/xlogfuncs.c:375 access/transam/xlogfuncs.c:396 #: access/transam/xlogfuncs.c:466 access/transam/xlogfuncs.c:522 @@ -642,45 +648,16 @@ msgstr "los índices GIN antiguos no soportan recorridos del índice completo ni msgid "To fix this, do REINDEX INDEX \"%s\"." msgstr "Para corregir esto, ejecute REINDEX INDEX \"%s\"." -#: access/gin/ginvalidate.c:92 -#, c-format -msgid "gin operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "la familia de operadores gin «%s» contiene el procedimiento de soporte %s registrado entre tipos distintos" - -#: access/gin/ginvalidate.c:148 -#, c-format -msgid "gin operator family \"%s\" contains function %s with invalid support number %d" -msgstr "familia de operadores gin «%s» contiene la función %s con número de soporte %d no válido" - -#: access/gin/ginvalidate.c:160 -#, c-format -msgid "gin operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "familia de operadores gin «%s» contiene la función %s con signatura incorrecta para el número de soporte %d" - -#: access/gin/ginvalidate.c:179 -#, c-format -msgid "gin operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "familia de operadores gin «%s» contiene el operador %s con número de estrategia %d no válido" - -#: access/gin/ginvalidate.c:192 -#, c-format -msgid "gin operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "familia de operadores gin «%s» contiene especificación ORDER BY no válida para el operador %s" - -#: access/gin/ginvalidate.c:205 -#, c-format -msgid "gin operator family \"%s\" contains operator %s with wrong signature" -msgstr "familia de operadores gin «%s» contiene el operador %s con signatura incorrecta" - -#: access/gin/ginvalidate.c:246 +#: access/gin/ginvalidate.c:92 access/gist/gistvalidate.c:92 +#: access/hash/hashvalidate.c:98 access/spgist/spgvalidate.c:92 #, c-format -msgid "gin operator class \"%s\" is missing support function %d" -msgstr "falta la función de soporte %2$d de la clase de operadores gin «%1$s»" +msgid "operator family \"%s\" of access method %s contains support procedure %s with different left and right input types" +msgstr "la familia de operadores «%s» del método de acceso «%s» contiene el procedimiento de soporte %s con tipos izquierdo y derecho distintos" #: access/gin/ginvalidate.c:256 #, c-format -msgid "gin operator class \"%s\" is missing support function %d or %d" -msgstr "falta la función de soporte %2$d o %3$d de la clase de operadores gin «%1$s»" +msgid "operator class \"%s\" of access method %s is missing support function %d or %d" +msgstr "falta la función de soporte %3$d o %4$d de la clase de operadores «%1$s» del método de acceso «%2$s»" #: access/gist/gist.c:680 access/gist/gistvacuum.c:258 #, c-format @@ -692,11 +669,11 @@ msgstr "el índice «%s» contiene una tupla interna marcada como no válida" msgid "This is caused by an incomplete page split at crash recovery before upgrading to PostgreSQL 9.1." msgstr "Esto es causado por una división de página incompleta durante una recuperación antes de actualizar a PostgreSQL 9.1." -#: access/gist/gist.c:683 access/gist/gistutil.c:738 -#: access/gist/gistutil.c:749 access/gist/gistvacuum.c:261 -#: access/hash/hashutil.c:172 access/hash/hashutil.c:183 -#: access/hash/hashutil.c:195 access/hash/hashutil.c:216 -#: access/nbtree/nbtpage.c:518 access/nbtree/nbtpage.c:529 +#: access/gist/gist.c:683 access/gist/gistutil.c:738 access/gist/gistutil.c:749 +#: access/gist/gistvacuum.c:261 access/hash/hashutil.c:172 +#: access/hash/hashutil.c:183 access/hash/hashutil.c:195 +#: access/hash/hashutil.c:216 access/nbtree/nbtpage.c:518 +#: access/nbtree/nbtpage.c:529 #, c-format msgid "Please REINDEX it." msgstr "Por favor aplíquele REINDEX." @@ -738,45 +715,15 @@ msgstr "índice «%s» contiene páginas vacías no esperadas en el bloque %u" msgid "index \"%s\" contains corrupted page at block %u" msgstr "el índice «%s» contiene una página corrupta en el bloque %u" -#: access/gist/gistvalidate.c:92 -#, c-format -msgid "gist operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "la familia de operadores gist «%s» contiene el procedimiento de soporte %s registrado entre distintos tipos" - -#: access/gist/gistvalidate.c:145 -#, c-format -msgid "gist operator family \"%s\" contains function %s with invalid support number %d" -msgstr "la familia de operadores gist «%s» contiene la función %s con número de soporte %d no válido" - -#: access/gist/gistvalidate.c:157 -#, c-format -msgid "gist operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "la familia de operadores gist «%s» contiene la función %s con signatura incorrecta para el número de soporte %d" - -#: access/gist/gistvalidate.c:177 -#, c-format -msgid "gist operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "la familia de operadores gist «%s» contiene el operador %s con número de estrategia %d no válido" - #: access/gist/gistvalidate.c:195 #, c-format -msgid "gist operator family \"%s\" contains unsupported ORDER BY specification for operator %s" -msgstr "la familia de operadores gist «%s» contiene una especificación ORDER BY no soportada para el operador %s" +msgid "operator family \"%s\" of access method %s contains unsupported ORDER BY specification for operator %s" +msgstr "la familia de operadores «%s» del método de acceso %s contiene una especificación ORDER BY no soportada para el operador %s" #: access/gist/gistvalidate.c:206 #, c-format -msgid "gist operator family \"%s\" contains incorrect ORDER BY opfamily specification for operator %s" -msgstr "la familia de operadores gist «%s» contiene una especificación de familia en ORDER BY incorrecta para el operador %s" - -#: access/gist/gistvalidate.c:225 -#, c-format -msgid "gist operator family \"%s\" contains operator %s with wrong signature" -msgstr "la familia de operadores gist «%s» contiene un operador %s con la signatura incorrecta" - -#: access/gist/gistvalidate.c:264 -#, c-format -msgid "gist operator class \"%s\" is missing support function %d" -msgstr "falta la función de soporte %2$d de la clase de operadores gist «%1$s»" +msgid "operator family \"%s\" of access method %s contains incorrect ORDER BY opfamily specification for operator %s" +msgstr "la familia de operadores «%s» del método de acceso %s contiene una especificación de familia en ORDER BY incorrecta para el operador %s" #: access/hash/hashinsert.c:70 #, c-format @@ -809,55 +756,15 @@ msgstr "el índice «%s» no es un índice hash" msgid "index \"%s\" has wrong hash version" msgstr "el índice «%s» tiene una versión de hash incorrecta" -#: access/hash/hashvalidate.c:98 -#, c-format -msgid "hash operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "la familia de operadores hash «%s» contiene el procedimiento de soporte %s registrado entre tipos distintos" - -#: access/hash/hashvalidate.c:113 -#, c-format -msgid "hash operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "la familia de operadores hash «%s» contiene la función %s con signatura incorrecta para el número de soporte %d" - -#: access/hash/hashvalidate.c:130 -#, c-format -msgid "hash operator family \"%s\" contains function %s with invalid support number %d" -msgstr "la familia de operadores hash «%s» contiene la función %s con número de soporte %d no válido" - -#: access/hash/hashvalidate.c:151 -#, c-format -msgid "hash operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "la familia de operadores hash «%s» contiene el operador %s con número de estrategia %d no válido" - -#: access/hash/hashvalidate.c:164 -#, c-format -msgid "hash operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "la familia de operadores hash «%s» contiene una especificación no válida de ORDER BY para el operador %s" - -#: access/hash/hashvalidate.c:177 -#, c-format -msgid "hash operator family \"%s\" contains operator %s with wrong signature" -msgstr "la familia de operadores hash «%s» contiene la función %s con signatura incorrecta" - #: access/hash/hashvalidate.c:189 #, c-format -msgid "hash operator family \"%s\" lacks support function for operator %s" -msgstr "la familia de operadores hash «%s» no tiene función de soporte para el operador %s" - -#: access/hash/hashvalidate.c:217 -#, c-format -msgid "hash operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "faltan operadores para los tipos %2$s y %3$s en la familia de operadores hash «%1$s»" - -#: access/hash/hashvalidate.c:231 -#, c-format -msgid "hash operator class \"%s\" is missing operator(s)" -msgstr "faltan operadores en la clase de de operadores hash «%s»" +msgid "operator family \"%s\" of access method %s lacks support function for operator %s" +msgstr "la familia de operadores «%s» del método de acceso %s no tiene función de soporte para el operador %s" -#: access/hash/hashvalidate.c:247 +#: access/hash/hashvalidate.c:247 access/nbtree/nbtvalidate.c:241 #, c-format -msgid "hash operator family \"%s\" is missing cross-type operator(s)" -msgstr "faltan operadores entre tipos en la familia de operadores hash «%s»" +msgid "operator family \"%s\" of access method %s is missing cross-type operator(s)" +msgstr "faltan operadores entre tipos en la familia de operadores «%s» del método de acceso %s" #: access/heap/heapam.c:1295 access/heap/heapam.c:1323 #: access/heap/heapam.c:1355 catalog/aclchk.c:1756 @@ -866,8 +773,8 @@ msgid "\"%s\" is an index" msgstr "«%s» es un índice" #: access/heap/heapam.c:1300 access/heap/heapam.c:1328 -#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9082 -#: commands/tablecmds.c:12190 +#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9095 +#: commands/tablecmds.c:12203 #, c-format msgid "\"%s\" is a composite type" msgstr "«%s» es un tipo compuesto" @@ -887,7 +794,7 @@ msgstr "no se pueden eliminar tuplas durante una operación paralela" msgid "attempted to delete invisible tuple" msgstr "se intentó eliminar una tupla invisible" -#: access/heap/heapam.c:3489 access/heap/heapam.c:6240 +#: access/heap/heapam.c:3489 access/heap/heapam.c:6274 #, c-format msgid "cannot update tuples during a parallel operation" msgstr "no se pueden actualizar tuplas durante una operación paralela" @@ -897,8 +804,8 @@ msgstr "no se pueden actualizar tuplas durante una operación paralela" msgid "attempted to update invisible tuple" msgstr "se intentó actualizar una tupla invisible" -#: access/heap/heapam.c:4963 access/heap/heapam.c:5001 -#: access/heap/heapam.c:5253 executor/execMain.c:2314 +#: access/heap/heapam.c:4964 access/heap/heapam.c:5002 +#: access/heap/heapam.c:5254 executor/execMain.c:2314 #, c-format msgid "could not obtain lock on row in relation \"%s\"" msgstr "no se pudo obtener un lock en la fila de la relación «%s»" @@ -927,8 +834,8 @@ msgstr "no se pudo sincronizar (fsync) archivo «%s»: %m" #: access/heap/rewriteheap.c:1018 access/heap/rewriteheap.c:1138 #: access/transam/timeline.c:315 access/transam/timeline.c:461 #: access/transam/xlog.c:3049 access/transam/xlog.c:3198 -#: access/transam/xlog.c:10198 access/transam/xlog.c:10236 -#: access/transam/xlog.c:10625 postmaster/postmaster.c:4378 +#: access/transam/xlog.c:10209 access/transam/xlog.c:10247 +#: access/transam/xlog.c:10636 postmaster/postmaster.c:4387 #: replication/logical/origin.c:542 replication/slot.c:1062 #: storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1275 #, c-format @@ -940,7 +847,7 @@ msgstr "no se pudo crear archivo «%s»: %m" msgid "could not truncate file \"%s\" to %u: %m" msgstr "no se pudo truncar el archivo «%s» a %u: %m" -#: access/heap/rewriteheap.c:1154 replication/walsender.c:481 +#: access/heap/rewriteheap.c:1154 replication/walsender.c:486 #: storage/smgr/md.c:1899 #, c-format msgid "could not seek to end of file \"%s\": %m" @@ -949,7 +856,7 @@ msgstr "no se pudo posicionar (seek) al fin del archivo «%s»: %m" #: access/heap/rewriteheap.c:1165 access/transam/timeline.c:367 #: access/transam/timeline.c:401 access/transam/timeline.c:477 #: access/transam/xlog.c:3084 access/transam/xlog.c:3248 -#: postmaster/postmaster.c:4388 postmaster/postmaster.c:4398 +#: postmaster/postmaster.c:4397 postmaster/postmaster.c:4407 #: replication/logical/origin.c:551 replication/logical/origin.c:590 #: replication/logical/origin.c:606 replication/logical/snapbuild.c:1589 #: replication/slot.c:1091 storage/file/copydir.c:187 @@ -961,10 +868,10 @@ msgstr "no se pudo posicionar (seek) al fin del archivo «%s»: %m" msgid "could not write to file \"%s\": %m" msgstr "no se pudo escribir a archivo «%s»: %m" -#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10460 +#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10471 #: access/transam/xlogarchive.c:114 access/transam/xlogarchive.c:468 -#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2632 -#: replication/logical/reorderbuffer.c:2689 +#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2633 +#: replication/logical/reorderbuffer.c:2690 #: replication/logical/snapbuild.c:1538 replication/logical/snapbuild.c:1901 #: replication/slot.c:1164 storage/ipc/dsm.c:326 storage/smgr/md.c:427 #: storage/smgr/md.c:476 storage/smgr/md.c:1394 @@ -979,11 +886,11 @@ msgstr "no se pudo eliminar el archivo «%s»: %m" #: access/transam/xlog.c:3534 access/transam/xlogutils.c:701 #: replication/basebackup.c:403 replication/basebackup.c:1150 #: replication/logical/origin.c:661 replication/logical/reorderbuffer.c:2156 -#: replication/logical/reorderbuffer.c:2402 -#: replication/logical/reorderbuffer.c:3081 +#: replication/logical/reorderbuffer.c:2403 +#: replication/logical/reorderbuffer.c:3082 #: replication/logical/snapbuild.c:1582 replication/logical/snapbuild.c:1666 -#: replication/slot.c:1179 replication/walsender.c:474 -#: replication/walsender.c:2101 storage/file/copydir.c:155 +#: replication/slot.c:1179 replication/walsender.c:479 +#: replication/walsender.c:2144 storage/file/copydir.c:155 #: storage/file/fd.c:614 storage/file/fd.c:3041 storage/file/fd.c:3108 #: storage/smgr/md.c:609 utils/error/elog.c:1879 utils/init/miscinit.c:1163 #: utils/init/miscinit.c:1284 utils/init/miscinit.c:1362 utils/misc/guc.c:7105 @@ -1004,7 +911,7 @@ msgstr "el método de acceso «%s» no tiene manejador" #: access/index/indexam.c:155 catalog/objectaddress.c:1196 #: commands/indexcmds.c:1800 commands/tablecmds.c:242 -#: commands/tablecmds.c:12181 +#: commands/tablecmds.c:12194 #, c-format msgid "\"%s\" is not an index" msgstr "«%s» no es un índice" @@ -1039,7 +946,7 @@ msgstr "" "Considere un índice sobre una función que genere un hash MD5 del valor, o utilice un esquema de indexación de texto completo." #: access/nbtree/nbtpage.c:168 access/nbtree/nbtpage.c:371 -#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1702 +#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1703 #, c-format msgid "index \"%s\" is not a btree" msgstr "el índice «%s» no es un btree" @@ -1060,100 +967,20 @@ msgstr "el índice «%s» contiene una página interna parcialmente muerta" msgid "This can be caused by an interrupted VACUUM in version 9.3 or older, before upgrade. Please REINDEX it." msgstr "Esto puede ser causado por la interrupción de un VACUUM en la versión 9.3 o anteriores, antes de actualizar. Ejecute REINDEX por favor." -#: access/nbtree/nbtvalidate.c:100 -#, c-format -msgid "btree operator family \"%s\" contains function %s with invalid support number %d" -msgstr "la familia de operadores btree «%s» contiene la función %s con número de soporte no válido %d" - -#: access/nbtree/nbtvalidate.c:112 -#, c-format -msgid "btree operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "la familia de operadores btree «%s» contiene la función %s con signatura incorrecta para el número de soporte %d" - -#: access/nbtree/nbtvalidate.c:132 -#, c-format -msgid "btree operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "la familia de operadores btree «%s» contiene operador %s con número de estrategia %d no válido" - -#: access/nbtree/nbtvalidate.c:145 -#, c-format -msgid "btree operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "la familia de operadores btree «%s» contiene una especificación ORDER BY no válida para el operador %s" - -#: access/nbtree/nbtvalidate.c:158 -#, c-format -msgid "btree operator family \"%s\" contains operator %s with wrong signature" -msgstr "la familia de operadores btree «%s» contiene al operador %s con signatura incorrecta" - -#: access/nbtree/nbtvalidate.c:200 -#, c-format -msgid "btree operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "faltan operadores para los tipos %2$s y %3$s en la familia de operadores btree «%1$s»" - #: access/nbtree/nbtvalidate.c:210 #, c-format -msgid "btree operator family \"%s\" is missing support function for types %s and %s" -msgstr "faltan funciones de soporte para los tipos %2$s y %3$s en la familia de operadores btree «%1$s»" - -#: access/nbtree/nbtvalidate.c:224 -#, c-format -msgid "btree operator class \"%s\" is missing operator(s)" -msgstr "faltan operadores en la clase de operadores btree «%s»" - -#: access/nbtree/nbtvalidate.c:241 -#, c-format -msgid "btree operator family \"%s\" is missing cross-type operator(s)" -msgstr "faltan operadores entre tipos en la familia de operadores btree «%s»" +msgid "operator family \"%s\" of access method %s is missing support function for types %s and %s" +msgstr "faltan funciones de soporte para los tipos %3$s y %4$s en la familia de operadores «%1$s» del método de acceso %2$s" #: access/spgist/spgutils.c:700 #, c-format msgid "SP-GiST inner tuple size %zu exceeds maximum %zu" msgstr "el tamaño de tupla interna SP-GiST %zu excede el máximo %zu" -#: access/spgist/spgvalidate.c:92 -#, c-format -msgid "spgist operator family \"%s\" contains support procedure %s with cross-type registration" -msgstr "la familia de operadores spgist «%s» contiene el procedimiento de soporte %s registrado entre tipos distintos" - -#: access/spgist/spgvalidate.c:115 -#, c-format -msgid "spgist operator family \"%s\" contains function %s with invalid support number %d" -msgstr "la familia de operadores spgist «%s» contiene la función %s con número de soporte no válido %d" - -#: access/spgist/spgvalidate.c:127 -#, c-format -msgid "spgist operator family \"%s\" contains function %s with wrong signature for support number %d" -msgstr "la familia de operadores spgist «%s» contiene la función %s con signatura incorrecta para el número de soporte %d" - -#: access/spgist/spgvalidate.c:146 -#, c-format -msgid "spgist operator family \"%s\" contains operator %s with invalid strategy number %d" -msgstr "la familia de operadores spgist «%s» contiene operador %s con número de estrategia %d no válido" - -#: access/spgist/spgvalidate.c:159 -#, c-format -msgid "spgist operator family \"%s\" contains invalid ORDER BY specification for operator %s" -msgstr "la familia de operadores spgist «%s» contiene una especificación ORDER BY no válida para el operador %s" - -#: access/spgist/spgvalidate.c:172 -#, c-format -msgid "spgist operator family \"%s\" contains operator %s with wrong signature" -msgstr "la familia de operadores spgist «%s» contiene al operador %s con signatura incorrecta" - -#: access/spgist/spgvalidate.c:200 -#, c-format -msgid "spgist operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "faltan operadores para los tipos %2$s y %3$s en la familia de operadores spgist «%1$s»" - #: access/spgist/spgvalidate.c:220 #, c-format -msgid "spgist operator family \"%s\" is missing support function %d for type %s" -msgstr "falta la función de soporte %2$d para el tipo %3$s de la clase de operadores spgist «%1$s»" - -#: access/spgist/spgvalidate.c:233 -#, c-format -msgid "spgist operator class \"%s\" is missing operator(s)" -msgstr "faltan operadores en la clase de de operadores spgist «%s»" +msgid "operator family \"%s\" of access method %s is missing support function %d for type %s" +msgstr "falta la función de soporte %3$d para el tipo %4$s de la clase de operadores «%1$s» del método de acceso %2$s" #: access/tablesample/bernoulli.c:152 access/tablesample/system.c:156 #, c-format @@ -1328,54 +1155,54 @@ msgstr "no se pudo mapear el segmento de memoria compartida dinámica" msgid "invalid magic number in dynamic shared memory segment" msgstr "número mágico no válido en segmento de memoria compartida dinámica" -#: access/transam/slru.c:665 +#: access/transam/slru.c:669 #, c-format msgid "file \"%s\" doesn't exist, reading as zeroes" msgstr "el archivo «%s» no existe, leyendo como ceros" -#: access/transam/slru.c:895 access/transam/slru.c:901 -#: access/transam/slru.c:908 access/transam/slru.c:915 -#: access/transam/slru.c:922 access/transam/slru.c:929 +#: access/transam/slru.c:899 access/transam/slru.c:905 +#: access/transam/slru.c:912 access/transam/slru.c:919 +#: access/transam/slru.c:926 access/transam/slru.c:933 #, c-format msgid "could not access status of transaction %u" msgstr "no se pudo encontrar el estado de la transacción %u" -#: access/transam/slru.c:896 +#: access/transam/slru.c:900 #, c-format msgid "Could not open file \"%s\": %m." msgstr "No se pudo abrir el archivo «%s»: %m." -#: access/transam/slru.c:902 +#: access/transam/slru.c:906 #, c-format msgid "Could not seek in file \"%s\" to offset %u: %m." msgstr "No se pudo posicionar (seek) en el archivo «%s» a la posición %u: %m." -#: access/transam/slru.c:909 +#: access/transam/slru.c:913 #, c-format msgid "Could not read from file \"%s\" at offset %u: %m." msgstr "No se pudo leer desde el archivo «%s» en la posición %u: %m." -#: access/transam/slru.c:916 +#: access/transam/slru.c:920 #, c-format msgid "Could not write to file \"%s\" at offset %u: %m." msgstr "No se pudo escribir al archivo «%s» en la posición %u: %m." -#: access/transam/slru.c:923 +#: access/transam/slru.c:927 #, c-format msgid "Could not fsync file \"%s\": %m." msgstr "No se pudo sincronizar (fsync) archivo «%s»: %m." -#: access/transam/slru.c:930 +#: access/transam/slru.c:934 #, c-format msgid "Could not close file \"%s\": %m." msgstr "No se pudo cerrar el archivo «%s»: %m." -#: access/transam/slru.c:1185 +#: access/transam/slru.c:1189 #, c-format msgid "could not truncate directory \"%s\": apparent wraparound" msgstr "no se pudo truncar el directorio «%s»: aparente problema por reciclaje de transacciones" -#: access/transam/slru.c:1240 access/transam/slru.c:1296 +#: access/transam/slru.c:1244 access/transam/slru.c:1300 #, c-format msgid "removing file \"%s\"" msgstr "eliminando el archivo «%s»" @@ -1622,93 +1449,93 @@ msgstr "no se pueden tener más de 2^32-2 órdenes en una transacción" msgid "maximum number of committed subtransactions (%d) exceeded" msgstr "se superó el número máximo de subtransacciones comprometidas (%d)" -#: access/transam/xact.c:2263 +#: access/transam/xact.c:2260 #, c-format msgid "cannot PREPARE a transaction that has operated on temporary tables" msgstr "no se puede hacer PREPARE de una transacción que ha operado en tablas temporales" -#: access/transam/xact.c:2273 +#: access/transam/xact.c:2270 #, c-format msgid "cannot PREPARE a transaction that has exported snapshots" msgstr "no se puede hacer PREPARE de una transacción que ha exportado snapshots" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3155 +#: access/transam/xact.c:3148 #, c-format msgid "%s cannot run inside a transaction block" msgstr "%s no puede ser ejecutado dentro de un bloque de transacción" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3165 +#: access/transam/xact.c:3158 #, c-format msgid "%s cannot run inside a subtransaction" msgstr "%s no puede ser ejecutado dentro de una subtransacción" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3175 +#: access/transam/xact.c:3168 #, c-format msgid "%s cannot be executed from a function or multi-command string" msgstr "la orden %s no puede ser ejecutada desde una función o una línea con múltiples órdenes" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3246 +#: access/transam/xact.c:3239 #, c-format msgid "%s can only be used in transaction blocks" msgstr "la orden %s sólo puede ser usada en bloques de transacción" -#: access/transam/xact.c:3430 +#: access/transam/xact.c:3423 #, c-format msgid "there is already a transaction in progress" msgstr "ya hay una transacción en curso" -#: access/transam/xact.c:3598 access/transam/xact.c:3701 +#: access/transam/xact.c:3591 access/transam/xact.c:3694 #, c-format msgid "there is no transaction in progress" msgstr "no hay una transacción en curso" -#: access/transam/xact.c:3609 +#: access/transam/xact.c:3602 #, c-format msgid "cannot commit during a parallel operation" msgstr "no se puede comprometer una transacción durante una operación paralela" -#: access/transam/xact.c:3712 +#: access/transam/xact.c:3705 #, c-format msgid "cannot abort during a parallel operation" msgstr "no se puede abortar durante una operación paralela" -#: access/transam/xact.c:3754 +#: access/transam/xact.c:3747 #, c-format msgid "cannot define savepoints during a parallel operation" msgstr "no se pueden definir savepoints durante una operación paralela" -#: access/transam/xact.c:3821 +#: access/transam/xact.c:3814 #, c-format msgid "cannot release savepoints during a parallel operation" msgstr "no se pueden liberar savepoints durante una operación paralela" -#: access/transam/xact.c:3832 access/transam/xact.c:3884 -#: access/transam/xact.c:3890 access/transam/xact.c:3946 -#: access/transam/xact.c:3996 access/transam/xact.c:4002 +#: access/transam/xact.c:3825 access/transam/xact.c:3877 +#: access/transam/xact.c:3883 access/transam/xact.c:3939 +#: access/transam/xact.c:3989 access/transam/xact.c:3995 #, c-format msgid "no such savepoint" msgstr "no hay un savepoint con ese nombre" -#: access/transam/xact.c:3934 +#: access/transam/xact.c:3927 #, c-format msgid "cannot rollback to savepoints during a parallel operation" msgstr "no se puede hacer rollback a un savepoint durante una operación paralela" -#: access/transam/xact.c:4062 +#: access/transam/xact.c:4055 #, c-format msgid "cannot start subtransactions during a parallel operation" msgstr "no se pueden iniciar subtransacciones durante una operación paralela" -#: access/transam/xact.c:4129 +#: access/transam/xact.c:4122 #, c-format msgid "cannot commit subtransactions during a parallel operation" msgstr "no se pueden comprometer subtransacciones durante una operación paralela" -#: access/transam/xact.c:4737 +#: access/transam/xact.c:4751 #, c-format msgid "cannot have more than 2^32-1 subtransactions in a transaction" msgstr "no se pueden tener más de 2^32-1 subtransacciones en una transacción" @@ -1744,7 +1571,7 @@ msgid "could not close log file %s: %m" msgstr "no se pudo cerrar el archivo de registro %s: %m" #: access/transam/xlog.c:3617 access/transam/xlogutils.c:696 -#: replication/walsender.c:2096 +#: replication/walsender.c:2139 #, c-format msgid "requested WAL segment %s has already been removed" msgstr "el segmento de WAL solicitado %s ya ha sido eliminado" @@ -2042,15 +1869,15 @@ msgstr "el parámetro «%s» requiere un valor lógico (booleano)" msgid "parameter \"%s\" requires a temporal value" msgstr "el parámetro «%s» requiere un valor de tiempo" -#: access/transam/xlog.c:5187 catalog/dependency.c:990 -#: catalog/dependency.c:991 catalog/dependency.c:997 catalog/dependency.c:998 -#: catalog/dependency.c:1009 catalog/dependency.c:1010 -#: catalog/objectaddress.c:1100 commands/tablecmds.c:796 -#: commands/tablecmds.c:9543 commands/user.c:1045 commands/view.c:499 -#: libpq/auth.c:307 replication/syncrep.c:919 storage/lmgr/deadlock.c:1139 -#: storage/lmgr/proc.c:1278 utils/adt/acl.c:5281 utils/misc/guc.c:5662 -#: utils/misc/guc.c:5755 utils/misc/guc.c:9708 utils/misc/guc.c:9742 -#: utils/misc/guc.c:9776 utils/misc/guc.c:9810 utils/misc/guc.c:9845 +#: access/transam/xlog.c:5187 catalog/dependency.c:990 catalog/dependency.c:991 +#: catalog/dependency.c:997 catalog/dependency.c:998 catalog/dependency.c:1009 +#: catalog/dependency.c:1010 catalog/objectaddress.c:1100 +#: commands/tablecmds.c:796 commands/tablecmds.c:9556 commands/user.c:1045 +#: commands/view.c:499 libpq/auth.c:307 replication/syncrep.c:929 +#: storage/lmgr/deadlock.c:1139 storage/lmgr/proc.c:1278 utils/adt/acl.c:5281 +#: utils/misc/guc.c:5662 utils/misc/guc.c:5755 utils/misc/guc.c:9708 +#: utils/misc/guc.c:9742 utils/misc/guc.c:9776 utils/misc/guc.c:9810 +#: utils/misc/guc.c:9845 #, c-format msgid "%s" msgstr "%s" @@ -2260,7 +2087,7 @@ msgstr "no se pudo crear el enlace simbólico «%s»: %m" msgid "ignoring file \"%s\" because no file \"%s\" exists" msgstr "ignorando el archivo «%s» porque no existe un archivo «%s»" -#: access/transam/xlog.c:6223 access/transam/xlog.c:11054 +#: access/transam/xlog.c:6223 access/transam/xlog.c:11065 #, c-format msgid "File \"%s\" was renamed to \"%s\"." msgstr "El archivo «%s» fue renombrado a «%s»." @@ -2350,7 +2177,7 @@ msgstr "el punto de detención de recuperación pedido es antes del punto de rec msgid "redo done at %X/%X" msgstr "redo listo en %X/%X" -#: access/transam/xlog.c:7027 access/transam/xlog.c:8975 +#: access/transam/xlog.c:7027 access/transam/xlog.c:8986 #, c-format msgid "last completed transaction was at log time %s" msgstr "última transacción completada al tiempo de registro %s" @@ -2470,78 +2297,78 @@ msgstr "longitud del registro de checkpoint no válida" msgid "shutting down" msgstr "apagando" -#: access/transam/xlog.c:8520 +#: access/transam/xlog.c:8531 #, c-format msgid "concurrent transaction log activity while database system is shutting down" msgstr "hay actividad en el registro de transacción mientras el sistema se está apagando" -#: access/transam/xlog.c:8774 +#: access/transam/xlog.c:8785 #, c-format msgid "skipping restartpoint, recovery has already ended" msgstr "saltando el punto-de-reinicio; la recuperación ya ha terminado" -#: access/transam/xlog.c:8797 +#: access/transam/xlog.c:8808 #, c-format msgid "skipping restartpoint, already performed at %X/%X" msgstr "saltando el punto-de-reinicio; ya fue llevado a cabo en %X/%X" -#: access/transam/xlog.c:8973 +#: access/transam/xlog.c:8984 #, c-format msgid "recovery restart point at %X/%X" msgstr "punto-de-reinicio de recuperación en %X/%X" -#: access/transam/xlog.c:9106 +#: access/transam/xlog.c:9117 #, c-format msgid "restore point \"%s\" created at %X/%X" msgstr "punto de recuperación «%s» creado en %X/%X" -#: access/transam/xlog.c:9236 +#: access/transam/xlog.c:9247 #, c-format msgid "unexpected previous timeline ID %u (current timeline ID %u) in checkpoint record" msgstr "ID de timeline previo %u inesperado (timeline actual %u) en el registro de checkpoint" -#: access/transam/xlog.c:9245 +#: access/transam/xlog.c:9256 #, c-format msgid "unexpected timeline ID %u (after %u) in checkpoint record" msgstr "ID de timeline %u inesperado (después de %u) en el registro de checkpoint" -#: access/transam/xlog.c:9261 +#: access/transam/xlog.c:9272 #, c-format msgid "unexpected timeline ID %u in checkpoint record, before reaching minimum recovery point %X/%X on timeline %u" msgstr "timeline ID %u inesperado en registro de checkpoint, antes de alcanzar el punto mínimo de recuperación %X/%X en el timeline %u" -#: access/transam/xlog.c:9332 +#: access/transam/xlog.c:9343 #, c-format msgid "online backup was canceled, recovery cannot continue" msgstr "el respaldo en línea fue cancelado, la recuperación no puede continuar" -#: access/transam/xlog.c:9388 access/transam/xlog.c:9435 -#: access/transam/xlog.c:9458 +#: access/transam/xlog.c:9399 access/transam/xlog.c:9446 +#: access/transam/xlog.c:9469 #, c-format msgid "unexpected timeline ID %u (should be %u) in checkpoint record" msgstr "ID de timeline %u inesperado (debería ser %u) en el registro de checkpoint" -#: access/transam/xlog.c:9733 +#: access/transam/xlog.c:9744 #, c-format msgid "could not fsync log segment %s: %m" msgstr "no se pudo sincronizar (fsync) el archivo de registro %s: %m" -#: access/transam/xlog.c:9757 +#: access/transam/xlog.c:9768 #, c-format msgid "could not fsync log file %s: %m" msgstr "no se pudo sincronizar (fsync) archivo de registro «%s»: %m" -#: access/transam/xlog.c:9765 +#: access/transam/xlog.c:9776 #, c-format msgid "could not fsync write-through log file %s: %m" msgstr "no se pudo sincronizar (fsync write-through) el archivo de registro %s: %m" -#: access/transam/xlog.c:9774 +#: access/transam/xlog.c:9785 #, c-format msgid "could not fdatasync log file %s: %m" msgstr "no se pudo sincronizar (fdatasync) el archivo de registro %s: %m" -#: access/transam/xlog.c:9865 access/transam/xlog.c:10382 +#: access/transam/xlog.c:9876 access/transam/xlog.c:10393 #: access/transam/xlogfuncs.c:289 access/transam/xlogfuncs.c:316 #: access/transam/xlogfuncs.c:355 access/transam/xlogfuncs.c:376 #: access/transam/xlogfuncs.c:397 @@ -2549,64 +2376,63 @@ msgstr "no se pudo sincronizar (fdatasync) el archivo de registro %s: %m" msgid "WAL control functions cannot be executed during recovery." msgstr "Las funciones de control de WAL no pueden ejecutarse durante la recuperación." -#: access/transam/xlog.c:9874 access/transam/xlog.c:10391 +#: access/transam/xlog.c:9885 access/transam/xlog.c:10402 #, c-format msgid "WAL level not sufficient for making an online backup" msgstr "el nivel de WAL no es suficiente para hacer un respaldo en línea" -#: access/transam/xlog.c:9875 access/transam/xlog.c:10392 +#: access/transam/xlog.c:9886 access/transam/xlog.c:10403 #: access/transam/xlogfuncs.c:322 #, c-format msgid "wal_level must be set to \"replica\" or \"logical\" at server start." msgstr "wal_level debe ser definido a «replica» o «logical» al inicio del servidor." -#: access/transam/xlog.c:9880 +#: access/transam/xlog.c:9891 #, c-format msgid "backup label too long (max %d bytes)" msgstr "la etiqueta de respaldo es demasiado larga (máximo %d bytes)" -#: access/transam/xlog.c:9917 access/transam/xlog.c:10189 -#: access/transam/xlog.c:10227 +#: access/transam/xlog.c:9928 access/transam/xlog.c:10200 +#: access/transam/xlog.c:10238 #, c-format msgid "a backup is already in progress" msgstr "ya hay un respaldo en curso" -#: access/transam/xlog.c:9918 +#: access/transam/xlog.c:9929 #, c-format msgid "Run pg_stop_backup() and try again." msgstr "Ejecute pg_stop_backup() e intente nuevamente." -#: access/transam/xlog.c:10013 +#: access/transam/xlog.c:10024 #, c-format msgid "WAL generated with full_page_writes=off was replayed since last restartpoint" msgstr "el WAL generado con full_page_writes=off fue restaurado desde el último punto-de-reinicio" -#: access/transam/xlog.c:10015 access/transam/xlog.c:10576 +#: access/transam/xlog.c:10026 access/transam/xlog.c:10587 #, c-format msgid "This means that the backup being taken on the standby is corrupt and should not be used. Enable full_page_writes and run CHECKPOINT on the master, and then try an online backup again." msgstr "Esto significa que el respaldo que estaba siendo tomado en el standby está corrupto y no debería usarse. Active full_page_writes y ejecute CHECKPOINT en el maestro, luego trate de ejecutar un respaldo en línea nuevamente." -#: access/transam/xlog.c:10082 replication/basebackup.c:1026 +#: access/transam/xlog.c:10093 replication/basebackup.c:1026 #: utils/adt/misc.c:498 #, c-format msgid "could not read symbolic link \"%s\": %m" msgstr "no se pudo leer el enlace simbólico «%s»: %m" -#: access/transam/xlog.c:10089 replication/basebackup.c:1031 +#: access/transam/xlog.c:10100 replication/basebackup.c:1031 #: utils/adt/misc.c:503 #, c-format msgid "symbolic link \"%s\" target is too long" msgstr "la ruta «%s» del enlace simbólico es demasiado larga" -#: access/transam/xlog.c:10142 commands/tablespace.c:391 -#: commands/tablespace.c:553 replication/basebackup.c:1047 -#: utils/adt/misc.c:511 +#: access/transam/xlog.c:10153 commands/tablespace.c:391 +#: commands/tablespace.c:553 replication/basebackup.c:1047 utils/adt/misc.c:511 #, c-format msgid "tablespaces are not supported on this platform" msgstr "tablespaces no están soportados en esta plataforma" -#: access/transam/xlog.c:10183 access/transam/xlog.c:10221 -#: access/transam/xlog.c:10430 access/transam/xlogarchive.c:106 +#: access/transam/xlog.c:10194 access/transam/xlog.c:10232 +#: access/transam/xlog.c:10441 access/transam/xlogarchive.c:106 #: access/transam/xlogarchive.c:265 commands/copy.c:1816 commands/copy.c:2840 #: commands/extension.c:3133 commands/tablespace.c:782 #: commands/tablespace.c:873 replication/basebackup.c:409 @@ -2619,130 +2445,130 @@ msgstr "tablespaces no están soportados en esta plataforma" msgid "could not stat file \"%s\": %m" msgstr "no se pudo hacer stat al archivo «%s»: %m" -#: access/transam/xlog.c:10190 access/transam/xlog.c:10228 +#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 #, c-format msgid "If you're sure there is no backup in progress, remove file \"%s\" and try again." msgstr "Si está seguro que no hay un respaldo en curso, elimine el archivo «%s» e intente nuevamente." -#: access/transam/xlog.c:10207 access/transam/xlog.c:10245 -#: access/transam/xlog.c:10637 +#: access/transam/xlog.c:10218 access/transam/xlog.c:10256 +#: access/transam/xlog.c:10648 #, c-format msgid "could not write file \"%s\": %m" msgstr "no se pudo escribir el archivo «%s»: %m" -#: access/transam/xlog.c:10407 +#: access/transam/xlog.c:10418 #, c-format msgid "exclusive backup not in progress" msgstr "no hay un respaldo exclusivo en curso" -#: access/transam/xlog.c:10434 +#: access/transam/xlog.c:10445 #, c-format msgid "a backup is not in progress" msgstr "no hay un respaldo en curso" -#: access/transam/xlog.c:10511 access/transam/xlog.c:10524 -#: access/transam/xlog.c:10864 access/transam/xlog.c:10870 -#: access/transam/xlog.c:10954 access/transam/xlogfuncs.c:690 +#: access/transam/xlog.c:10522 access/transam/xlog.c:10535 +#: access/transam/xlog.c:10875 access/transam/xlog.c:10881 +#: access/transam/xlog.c:10965 access/transam/xlogfuncs.c:690 #, c-format msgid "invalid data in file \"%s\"" msgstr "datos no válidos en archivo «%s»" -#: access/transam/xlog.c:10528 replication/basebackup.c:938 +#: access/transam/xlog.c:10539 replication/basebackup.c:938 #, c-format msgid "the standby was promoted during online backup" msgstr "el standby fue promovido durante el respaldo en línea" -#: access/transam/xlog.c:10529 replication/basebackup.c:939 +#: access/transam/xlog.c:10540 replication/basebackup.c:939 #, c-format msgid "This means that the backup being taken is corrupt and should not be used. Try taking another online backup." msgstr "Esto significa que el respaldo que se estaba tomando está corrupto y no debería ser usado. Trate de ejecutar un nuevo respaldo en línea." -#: access/transam/xlog.c:10574 +#: access/transam/xlog.c:10585 #, c-format msgid "WAL generated with full_page_writes=off was replayed during online backup" msgstr "el WAL generado con full_page_writes=off fue restaurado durante el respaldo en línea" -#: access/transam/xlog.c:10686 +#: access/transam/xlog.c:10697 #, c-format msgid "pg_stop_backup cleanup done, waiting for required WAL segments to be archived" msgstr "finalización de pg_stop_backup completa, esperando que se archiven los segmentos WAL requeridos" -#: access/transam/xlog.c:10696 +#: access/transam/xlog.c:10707 #, c-format msgid "pg_stop_backup still waiting for all required WAL segments to be archived (%d seconds elapsed)" msgstr "pg_stop_backup todavía espera que todos los segmentos WAL requeridos sean archivados (han pasado %d segundos)" -#: access/transam/xlog.c:10698 +#: access/transam/xlog.c:10709 #, c-format msgid "Check that your archive_command is executing properly. pg_stop_backup can be canceled safely, but the database backup will not be usable without all the WAL segments." msgstr "Verifique que su archive_command se esté ejecutando con normalidad. pg_stop_backup puede ser abortado confiablemente, pero el respaldo de la base de datos no será utilizable a menos que disponga de todos los segmentos de WAL." -#: access/transam/xlog.c:10705 +#: access/transam/xlog.c:10716 #, c-format msgid "pg_stop_backup complete, all required WAL segments have been archived" msgstr "pg_stop_backup completado, todos los segmentos de WAL requeridos han sido archivados" -#: access/transam/xlog.c:10709 +#: access/transam/xlog.c:10720 #, c-format msgid "WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup" msgstr "el archivado de WAL no está activo; debe asegurarse que todos los segmentos WAL requeridos se copian por algún otro mecanismo para completar el respaldo" #. translator: %s is an XLog record description -#: access/transam/xlog.c:10994 +#: access/transam/xlog.c:11005 #, c-format msgid "xlog redo at %X/%X for %s" msgstr "xlog redo en %X/%X para %s" -#: access/transam/xlog.c:11043 +#: access/transam/xlog.c:11054 #, c-format msgid "online backup mode was not canceled" msgstr "el modo de respaldo en línea no fue cancelado" -#: access/transam/xlog.c:11044 +#: access/transam/xlog.c:11055 #, c-format msgid "File \"%s\" could not be renamed to \"%s\": %m." msgstr "El archivo «%s» no se pudo renombrar a «%s»: %m." -#: access/transam/xlog.c:11053 access/transam/xlog.c:11065 -#: access/transam/xlog.c:11075 +#: access/transam/xlog.c:11064 access/transam/xlog.c:11076 +#: access/transam/xlog.c:11086 #, c-format msgid "online backup mode canceled" msgstr "el modo de respaldo en línea fue cancelado" -#: access/transam/xlog.c:11066 +#: access/transam/xlog.c:11077 #, c-format msgid "Files \"%s\" and \"%s\" were renamed to \"%s\" and \"%s\", respectively." msgstr "Los archivos «%s» y «%s» fueron renombrados a «%s» y «%s», respectivamente." -#: access/transam/xlog.c:11076 +#: access/transam/xlog.c:11087 #, c-format msgid "File \"%s\" was renamed to \"%s\", but file \"%s\" could not be renamed to \"%s\": %m." msgstr "El archivo «%s» fue renombrado a «%s», pero el archivo «%s» no pudo ser renombrado a «%s»: %m." # XXX why talk about "log segment" instead of "file"? -#: access/transam/xlog.c:11198 access/transam/xlogutils.c:718 -#: replication/walreceiver.c:994 replication/walsender.c:2113 +#: access/transam/xlog.c:11209 access/transam/xlogutils.c:718 +#: replication/walreceiver.c:994 replication/walsender.c:2156 #, c-format msgid "could not seek in log segment %s to offset %u: %m" msgstr "no se pudo posicionar (seek) en segmento %s a la posición %u: %m" # XXX why talk about "log segment" instead of "file"? -#: access/transam/xlog.c:11210 +#: access/transam/xlog.c:11221 #, c-format msgid "could not read from log segment %s, offset %u: %m" msgstr "no se pudo leer del archivo de segmento %s, posición %u: %m" -#: access/transam/xlog.c:11684 +#: access/transam/xlog.c:11695 #, c-format msgid "received promote request" msgstr "se recibió petición de promoción" -#: access/transam/xlog.c:11697 +#: access/transam/xlog.c:11708 #, c-format msgid "trigger file found: %s" msgstr "se encontró el archivo disparador: %s" -#: access/transam/xlog.c:11706 +#: access/transam/xlog.c:11717 #, c-format msgid "could not stat trigger file \"%s\": %m" msgstr "no se pudo hacer stat al archivo disparador «%s»: %m" @@ -2798,7 +2624,7 @@ msgid "a backup is already in progress in this session" msgstr "ya hay un respaldo en curso en esta sesión" #: access/transam/xlogfuncs.c:93 commands/tablespace.c:705 -#: commands/tablespace.c:715 postmaster/postmaster.c:1420 +#: commands/tablespace.c:715 postmaster/postmaster.c:1424 #: replication/basebackup.c:297 replication/basebackup.c:637 #: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2369 #: storage/file/fd.c:2968 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 @@ -2823,12 +2649,12 @@ msgstr "¿Quiso usar pg_stop_backup('f')?" #: executor/execQual.c:1757 executor/execQual.c:1782 executor/execQual.c:2157 #: executor/execQual.c:5438 executor/functions.c:1031 foreign/foreign.c:492 #: replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1394 -#: replication/slotfuncs.c:189 replication/walsender.c:2762 +#: replication/slotfuncs.c:189 replication/walsender.c:2882 #: utils/adt/jsonfuncs.c:1483 utils/adt/jsonfuncs.c:1613 #: utils/adt/jsonfuncs.c:1801 utils/adt/jsonfuncs.c:1928 #: utils/adt/jsonfuncs.c:2694 utils/adt/pgstatfuncs.c:554 #: utils/adt/pgstatfuncs.c:655 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8436 -#: utils/mmgr/portalmem.c:1074 +#: utils/mmgr/portalmem.c:1088 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "se llamó una función que retorna un conjunto en un contexto que no puede aceptarlo" @@ -2838,9 +2664,9 @@ msgstr "se llamó una función que retorna un conjunto en un contexto que no pue #: commands/extension.c:1845 commands/extension.c:2038 commands/prepare.c:706 #: foreign/foreign.c:497 replication/logical/logicalfuncs.c:179 #: replication/logical/origin.c:1398 replication/slotfuncs.c:193 -#: replication/walsender.c:2766 utils/adt/pgstatfuncs.c:558 +#: replication/walsender.c:2886 utils/adt/pgstatfuncs.c:558 #: utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8440 utils/misc/pg_config.c:44 -#: utils/mmgr/portalmem.c:1078 +#: utils/mmgr/portalmem.c:1092 #, c-format msgid "materialize mode required, but it is not allowed in this context" msgstr "se requiere un nodo «materialize», pero no está permitido en este contexto" @@ -3022,23 +2848,23 @@ msgstr "registro con largo no válido en %X/%X" msgid "invalid compressed image at %X/%X, block %d" msgstr "imagen comprimida no válida en %X/%X, bloque %d" -#: access/transam/xlogutils.c:739 replication/walsender.c:2130 +#: access/transam/xlogutils.c:739 replication/walsender.c:2173 #, c-format msgid "could not read from log segment %s, offset %u, length %lu: %m" msgstr "no se pudo leer desde el segmento %s, posición %u, largo %lu: %m" -#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:807 tcop/postgres.c:3501 +#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:811 tcop/postgres.c:3499 #, c-format msgid "--%s requires a value" msgstr "--%s requiere un valor" -#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:812 tcop/postgres.c:3506 +#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:816 tcop/postgres.c:3504 #, c-format msgid "-c %s requires a value" msgstr "-c %s requiere un valor" -#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:824 -#: postmaster/postmaster.c:837 +#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:828 +#: postmaster/postmaster.c:841 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Pruebe «%s --help» para mayor información.\n" @@ -3182,8 +3008,8 @@ msgstr "no existe el objeto grande %u" #: commands/foreigncmds.c:539 commands/foreigncmds.c:548 #: commands/functioncmds.c:533 commands/functioncmds.c:649 #: commands/functioncmds.c:657 commands/functioncmds.c:665 -#: commands/functioncmds.c:673 commands/functioncmds.c:2085 -#: commands/functioncmds.c:2093 commands/sequence.c:1189 +#: commands/functioncmds.c:673 commands/functioncmds.c:2105 +#: commands/functioncmds.c:2113 commands/sequence.c:1189 #: commands/sequence.c:1197 commands/sequence.c:1205 commands/sequence.c:1213 #: commands/sequence.c:1221 commands/sequence.c:1229 commands/sequence.c:1237 #: commands/sequence.c:1245 commands/typecmds.c:295 commands/typecmds.c:1382 @@ -3207,21 +3033,21 @@ msgid "default privileges cannot be set for columns" msgstr "los privilegios por omisión no pueden definirse para columnas" #: catalog/aclchk.c:1502 catalog/objectaddress.c:1390 commands/analyze.c:376 -#: commands/copy.c:4459 commands/sequence.c:1491 commands/tablecmds.c:5198 -#: commands/tablecmds.c:5304 commands/tablecmds.c:5364 -#: commands/tablecmds.c:5477 commands/tablecmds.c:5534 -#: commands/tablecmds.c:5628 commands/tablecmds.c:5724 -#: commands/tablecmds.c:7916 commands/tablecmds.c:8178 -#: commands/tablecmds.c:8598 commands/trigger.c:642 parser/analyze.c:2228 +#: commands/copy.c:4459 commands/sequence.c:1491 commands/tablecmds.c:5211 +#: commands/tablecmds.c:5317 commands/tablecmds.c:5377 +#: commands/tablecmds.c:5490 commands/tablecmds.c:5547 +#: commands/tablecmds.c:5641 commands/tablecmds.c:5737 +#: commands/tablecmds.c:7929 commands/tablecmds.c:8191 +#: commands/tablecmds.c:8611 commands/trigger.c:642 parser/analyze.c:2228 #: parser/parse_relation.c:2628 parser/parse_relation.c:2690 #: parser/parse_target.c:951 parser/parse_type.c:127 utils/adt/acl.c:2840 -#: utils/adt/ruleutils.c:1984 +#: utils/adt/ruleutils.c:1987 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist" msgstr "no existe la columna «%s» en la relación «%s»" #: catalog/aclchk.c:1771 catalog/objectaddress.c:1203 commands/sequence.c:1078 -#: commands/tablecmds.c:224 commands/tablecmds.c:12155 utils/adt/acl.c:2076 +#: commands/tablecmds.c:224 commands/tablecmds.c:12168 utils/adt/acl.c:2076 #: utils/adt/acl.c:2106 utils/adt/acl.c:2138 utils/adt/acl.c:2170 #: utils/adt/acl.c:2198 utils/adt/acl.c:2228 #, c-format @@ -3268,7 +3094,7 @@ msgstr "no se puede definir privilegios para tipos de array" msgid "Set the privileges of the element type instead." msgstr "Defina los privilegios del tipo elemento en su lugar." -#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3146 +#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3161 #, c-format msgid "\"%s\" is not a domain" msgstr "«%s» no es un dominio" @@ -3668,12 +3494,12 @@ msgid "System catalog modifications are currently disallowed." msgstr "Las modificaciones al catálogo del sistema están actualmente deshabilitadas." #: catalog/heap.c:415 commands/tablecmds.c:1439 commands/tablecmds.c:1896 -#: commands/tablecmds.c:4820 +#: commands/tablecmds.c:4833 #, c-format msgid "tables can have at most %d columns" msgstr "las tablas pueden tener a lo más %d columnas" -#: catalog/heap.c:432 commands/tablecmds.c:5081 +#: catalog/heap.c:432 commands/tablecmds.c:5094 #, c-format msgid "column name \"%s\" conflicts with a system column name" msgstr "el nombre de columna «%s» colisiona con nombre de una columna de sistema" @@ -3712,9 +3538,8 @@ msgstr "no se derivó ningún ordenamiento (collate) para la columna «%s» con #: commands/indexcmds.c:1133 commands/view.c:103 regex/regc_pg_locale.c:262 #: utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 #: utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 -#: utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 -#: utils/adt/like.c:213 utils/adt/selfuncs.c:5434 utils/adt/varlena.c:1421 -#: utils/adt/varlena.c:1826 +#: utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 utils/adt/like.c:213 +#: utils/adt/selfuncs.c:5434 utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 #, c-format msgid "Use the COLLATE clause to set the collation explicitly." msgstr "Use la cláusula COLLATE para establecer el ordenamiento explícitamente." @@ -3724,7 +3549,7 @@ msgstr "Use la cláusula COLLATE para establecer el ordenamiento explícitamente msgid "relation \"%s\" already exists" msgstr "la relación «%s» ya existe" -#: catalog/heap.c:1083 catalog/pg_type.c:412 catalog/pg_type.c:722 +#: catalog/heap.c:1083 catalog/pg_type.c:412 catalog/pg_type.c:737 #: commands/typecmds.c:237 commands/typecmds.c:784 commands/typecmds.c:1135 #: commands/typecmds.c:1357 commands/typecmds.c:2113 #, c-format @@ -3746,7 +3571,7 @@ msgstr "el valor de OID de heap de pg_class no se definió en modo de actualizac msgid "check constraint \"%s\" already exists" msgstr "la restricción «check» «%s» ya existe" -#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6069 +#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6082 #, c-format msgid "constraint \"%s\" for relation \"%s\" already exists" msgstr "la restricción «%s» para la relación «%s» ya existe" @@ -3781,14 +3606,14 @@ msgstr "no se pueden usar referencias a columnas en una cláusula default" msgid "default expression must not return a set" msgstr "expresiones default no pueden retornar conjuntos" -#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1084 +#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1115 #, c-format msgid "column \"%s\" is of type %s but default expression is of type %s" msgstr "la columna «%s» es de tipo %s pero la expresión default es de tipo %s" #: catalog/heap.c:2630 commands/prepare.c:374 parser/parse_node.c:428 #: parser/parse_target.c:539 parser/parse_target.c:789 -#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1089 +#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1120 #, c-format msgid "You will need to rewrite or cast the expression." msgstr "Necesitará reescribir la expresión o aplicarle una conversión de tipo." @@ -3823,7 +3648,7 @@ msgstr "La tabla «%s» hace referencia a «%s»." msgid "Truncate table \"%s\" at the same time, or use TRUNCATE ... CASCADE." msgstr "Trunque la tabla «%s» al mismo tiempo, o utilice TRUNCATE ... CASCADE." -#: catalog/index.c:210 parser/parse_utilcmd.c:1473 parser/parse_utilcmd.c:1559 +#: catalog/index.c:210 parser/parse_utilcmd.c:1474 parser/parse_utilcmd.c:1560 #, c-format msgid "multiple primary keys for table \"%s\" are not allowed" msgstr "no se permiten múltiples llaves primarias para la tabla «%s»" @@ -3849,7 +3674,7 @@ msgid "shared indexes cannot be created after initdb" msgstr "no se pueden crear índices compartidos después de initdb" #: catalog/index.c:784 commands/createas.c:249 commands/sequence.c:141 -#: parser/parse_utilcmd.c:191 +#: parser/parse_utilcmd.c:192 #, c-format msgid "relation \"%s\" already exists, skipping" msgstr "la relación «%s» ya existe, ignorando" @@ -3879,12 +3704,6 @@ msgstr "no se puede hacer reindex de tablas temporales de otras sesiones" msgid "index \"%s\" was reindexed" msgstr "el índice «%s» fue reindexado" -#: catalog/index.c:3456 commands/vacuumlazy.c:1345 commands/vacuumlazy.c:1421 -#: commands/vacuumlazy.c:1610 commands/vacuumlazy.c:1820 -#, c-format -msgid "%s." -msgstr "%s." - #: catalog/namespace.c:249 catalog/namespace.c:447 catalog/namespace.c:541 #: commands/trigger.c:4523 #, c-format @@ -3912,7 +3731,7 @@ msgid "relation \"%s.%s\" does not exist" msgstr "no existe la relación «%s.%s»" #: catalog/namespace.c:419 parser/parse_relation.c:1151 -#: parser/parse_relation.c:1159 utils/adt/regproc.c:1034 +#: parser/parse_relation.c:1159 utils/adt/regproc.c:1035 #, c-format msgid "relation \"%s\" does not exist" msgstr "no existe la relación «%s»" @@ -3965,7 +3784,7 @@ msgid "cross-database references are not implemented: %s" msgstr "no están implementadas las referencias entre bases de datos: %s" #: catalog/namespace.c:2652 parser/parse_expr.c:799 parser/parse_target.c:1148 -#: gram.y:13454 gram.y:14823 +#: gram.y:13463 gram.y:14832 #, c-format msgid "improper qualified name (too many dotted names): %s" msgstr "el nombre no es válido (demasiados puntos): %s" @@ -3980,8 +3799,8 @@ msgstr "no se puede mover objetos hacia o desde esquemas temporales" msgid "cannot move objects into or out of TOAST schema" msgstr "no se puede mover objetos hacia o desde el esquema TOAST" -#: catalog/namespace.c:2862 commands/schemacmds.c:238 -#: commands/schemacmds.c:317 commands/tablecmds.c:741 +#: catalog/namespace.c:2862 commands/schemacmds.c:238 commands/schemacmds.c:317 +#: commands/tablecmds.c:741 #, c-format msgid "schema \"%s\" does not exist" msgstr "no existe el esquema «%s»" @@ -4013,8 +3832,8 @@ msgstr "no se pueden crear tablas temporales durante la recuperación" #: catalog/namespace.c:3688 #, c-format -msgid "cannot create temporary tables in parallel mode" -msgstr "no se pueden crear tablas temporales en modo paralelo" +msgid "cannot create temporary tables during a parallel operation" +msgstr "no se pueden acceder tablas temporales durante una operación paralela" #: catalog/namespace.c:3932 commands/tablespace.c:1173 commands/variable.c:63 #: utils/misc/guc.c:9875 @@ -4066,25 +3885,25 @@ msgstr "un nombre de disparador por eventos no puede ser calificado" #: catalog/objectaddress.c:1210 commands/lockcmds.c:94 commands/policy.c:94 #: commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:218 #: commands/tablecmds.c:1300 commands/tablecmds.c:4347 -#: commands/tablecmds.c:8018 +#: commands/tablecmds.c:8031 #, c-format msgid "\"%s\" is not a table" msgstr "«%s» no es una tabla" #: catalog/objectaddress.c:1217 commands/tablecmds.c:230 -#: commands/tablecmds.c:4377 commands/tablecmds.c:12160 commands/view.c:141 +#: commands/tablecmds.c:4377 commands/tablecmds.c:12173 commands/view.c:141 #, c-format msgid "\"%s\" is not a view" msgstr "«%s» no es una vista" -#: catalog/objectaddress.c:1224 commands/matview.c:174 -#: commands/tablecmds.c:236 commands/tablecmds.c:12165 +#: catalog/objectaddress.c:1224 commands/matview.c:174 commands/tablecmds.c:236 +#: commands/tablecmds.c:12178 #, c-format msgid "\"%s\" is not a materialized view" msgstr "«%s» no es una vista materializada" #: catalog/objectaddress.c:1231 commands/tablecmds.c:254 -#: commands/tablecmds.c:4380 commands/tablecmds.c:12170 +#: commands/tablecmds.c:4380 commands/tablecmds.c:12183 #, c-format msgid "\"%s\" is not a foreign table" msgstr "«%s» no es una tabla foránea" @@ -4100,9 +3919,9 @@ msgid "default value for column \"%s\" of relation \"%s\" does not exist" msgstr "no existe el valor por omisión para la columna «%s» de la relación «%s»" #: catalog/objectaddress.c:1512 commands/functioncmds.c:128 -#: commands/tablecmds.c:246 commands/typecmds.c:3214 parser/parse_type.c:226 +#: commands/tablecmds.c:246 commands/typecmds.c:3229 parser/parse_type.c:226 #: parser/parse_type.c:255 parser/parse_type.c:795 utils/adt/acl.c:4374 -#: utils/adt/regproc.c:1225 +#: utils/adt/regproc.c:1226 #, c-format msgid "type \"%s\" does not exist" msgstr "no existe el tipo «%s»" @@ -4123,8 +3942,7 @@ msgid "user mapping for user \"%s\" on server \"%s\" does not exist" msgstr "no existe el mapeo para el usuario «%s» en el servidor «%s»" #: catalog/objectaddress.c:1726 commands/foreigncmds.c:430 -#: commands/foreigncmds.c:997 commands/foreigncmds.c:1359 -#: foreign/foreign.c:692 +#: commands/foreigncmds.c:997 commands/foreigncmds.c:1359 foreign/foreign.c:692 #, c-format msgid "server \"%s\" does not exist" msgstr "no existe el servidor «%s»" @@ -4186,7 +4004,7 @@ msgstr "el largo de la lista de argumentos debe ser exactamente %d" msgid "must be owner of large object %u" msgstr "debe ser dueño del objeto grande %u" -#: catalog/objectaddress.c:2184 commands/functioncmds.c:1426 +#: catalog/objectaddress.c:2184 commands/functioncmds.c:1446 #, c-format msgid "must be owner of type %s or type %s" msgstr "debe ser dueño del tipo %s o el tipo %s" @@ -4518,7 +4336,7 @@ msgstr "el tipo de retorno de la función «combine» %s no es %s" #: catalog/pg_aggregate.c:436 #, c-format -msgid "combine function with \"%s\" transition type must not be declared STRICT" +msgid "combine function with transition type %s must not be declared STRICT" msgstr "la función «combine» con tipo de transición %s no debe declararse STRICT" #: catalog/pg_aggregate.c:455 @@ -4561,12 +4379,12 @@ msgstr "la implementación de la función de agregación en modo «moving» devu msgid "sort operator can only be specified for single-argument aggregates" msgstr "el operador de ordenamiento sólo puede ser especificado para funciones de agregación de un solo argumento" -#: catalog/pg_aggregate.c:812 commands/typecmds.c:1705 -#: commands/typecmds.c:1756 commands/typecmds.c:1787 commands/typecmds.c:1810 -#: commands/typecmds.c:1831 commands/typecmds.c:1858 commands/typecmds.c:1885 -#: commands/typecmds.c:1962 commands/typecmds.c:2004 parser/parse_func.c:364 -#: parser/parse_func.c:393 parser/parse_func.c:418 parser/parse_func.c:432 -#: parser/parse_func.c:507 parser/parse_func.c:518 parser/parse_func.c:1923 +#: catalog/pg_aggregate.c:812 commands/typecmds.c:1705 commands/typecmds.c:1756 +#: commands/typecmds.c:1787 commands/typecmds.c:1810 commands/typecmds.c:1831 +#: commands/typecmds.c:1858 commands/typecmds.c:1885 commands/typecmds.c:1962 +#: commands/typecmds.c:2004 parser/parse_func.c:364 parser/parse_func.c:393 +#: parser/parse_func.c:418 parser/parse_func.c:432 parser/parse_func.c:507 +#: parser/parse_func.c:518 parser/parse_func.c:1923 #, c-format msgid "function %s does not exist" msgstr "no existe la función %s" @@ -4933,13 +4751,13 @@ msgstr "el alineamiento «%c» no es válido para un tipo de largo variable" msgid "fixed-size types must have storage PLAIN" msgstr "los tipos de tamaño fijo deben tener almacenamiento PLAIN" -#: catalog/pg_type.c:789 +#: catalog/pg_type.c:809 #, c-format msgid "could not form array type name for type \"%s\"" msgstr "no se pudo formar un nombre de tipo de array para el tipo «%s»" #: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4359 -#: commands/tablecmds.c:12048 +#: commands/tablecmds.c:12061 #, c-format msgid "\"%s\" is not a table or materialized view" msgstr "«%s» no es una tabla o vista materializada" @@ -5187,7 +5005,7 @@ msgstr "saltando el análisis del árbol de herencia «%s.%s» --- este árbol n msgid "skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no analyzable child tables" msgstr "saltando el análisis del árbol de herencia «%s.%s» --- este árbol no contiene tablas hijas analizables" -#: commands/analyze.c:1420 commands/tablecmds.c:8080 executor/execQual.c:2927 +#: commands/analyze.c:1420 commands/tablecmds.c:8093 executor/execQual.c:2927 msgid "could not convert row type" msgstr "no se pudo convertir el tipo de registro" @@ -5241,7 +5059,7 @@ msgstr "no se pueden reordenar tablas temporales de otras sesiones" msgid "there is no previously clustered index for table \"%s\"" msgstr "no hay un índice de ordenamiento definido para la tabla «%s»" -#: commands/cluster.c:173 commands/tablecmds.c:9384 commands/tablecmds.c:11144 +#: commands/cluster.c:173 commands/tablecmds.c:9397 commands/tablecmds.c:11157 #, c-format msgid "index \"%s\" for table \"%s\" does not exist" msgstr "no existe el índice «%s» en la tabla «%s»" @@ -5256,7 +5074,7 @@ msgstr "no se puede reordenar un catálogo compartido" msgid "cannot vacuum temporary tables of other sessions" msgstr "no se puede hacer vacuum a tablas temporales de otras sesiones" -#: commands/cluster.c:431 commands/tablecmds.c:11154 +#: commands/cluster.c:431 commands/tablecmds.c:11167 #, c-format msgid "\"%s\" is not an index for table \"%s\"" msgstr "«%s» no es un índice de la tabla «%s»" @@ -5339,7 +5157,7 @@ msgstr "ya existe un ordenamiento llamado «%s» en el esquema «%s»" msgid "database \"%s\" does not exist" msgstr "no existe la base de datos «%s»" -#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:753 +#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:754 #, c-format msgid "\"%s\" is not a table, view, materialized view, composite type, or foreign table" msgstr "«%s» no es una tabla, vista, vista materializada, tipo compuesto, o tabla foránea" @@ -5401,7 +5219,7 @@ msgid "could not read from COPY file: %m" msgstr "no se pudo leer desde archivo COPY: %m" #: commands/copy.c:595 commands/copy.c:616 commands/copy.c:620 -#: tcop/postgres.c:341 tcop/postgres.c:377 tcop/postgres.c:404 +#: tcop/postgres.c:333 tcop/postgres.c:369 tcop/postgres.c:396 #, c-format msgid "unexpected EOF on client connection with an open transaction" msgstr "se encontró fin de archivo inesperado en una conexión con una transacción abierta" @@ -6153,7 +5971,7 @@ msgid "invalid argument for %s: \"%s\"" msgstr "argumento no válido para %s: «%s»" #: commands/dropcmds.c:112 commands/functioncmds.c:1203 -#: utils/adt/ruleutils.c:2080 +#: utils/adt/ruleutils.c:2083 #, c-format msgid "\"%s\" is an aggregate function" msgstr "«%s» es una función de agregación" @@ -6165,7 +5983,7 @@ msgstr "Use DROP AGGREGATE para eliminar funciones de agregación." #: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2378 #: commands/tablecmds.c:2529 commands/tablecmds.c:2571 -#: commands/tablecmds.c:11525 tcop/utility.c:1119 +#: commands/tablecmds.c:11538 tcop/utility.c:1119 #, c-format msgid "relation \"%s\" does not exist, skipping" msgstr "no existe la relación «%s», ignorando" @@ -6814,13 +6632,13 @@ msgstr "se ignoró el atributo de función no reconocido «%s»" msgid "only one AS item needed for language \"%s\"" msgstr "sólo se requiere un item AS para el lenguaje «%s»" -#: commands/functioncmds.c:929 commands/functioncmds.c:2119 +#: commands/functioncmds.c:929 commands/functioncmds.c:2139 #: commands/proclang.c:563 #, c-format msgid "language \"%s\" does not exist" msgstr "no existe el lenguaje «%s»" -#: commands/functioncmds.c:931 commands/functioncmds.c:2121 +#: commands/functioncmds.c:931 commands/functioncmds.c:2141 #, c-format msgid "Use CREATE LANGUAGE to load the language into the database." msgstr "Usar CREATE LANGUAGE para instalar el lenguaje en la base de datos." @@ -6845,187 +6663,187 @@ msgstr "el tipo de retorno de la función debe ser especificado" msgid "ROWS is not applicable when function does not return a set" msgstr "ROWS no es aplicable cuando una función no retorna un conjunto" -#: commands/functioncmds.c:1412 +#: commands/functioncmds.c:1432 #, c-format msgid "source data type %s is a pseudo-type" msgstr "el tipo de origen %s es un pseudo-tipo" -#: commands/functioncmds.c:1418 +#: commands/functioncmds.c:1438 #, c-format msgid "target data type %s is a pseudo-type" msgstr "el tipo de retorno %s es un pseudo-tipo" -#: commands/functioncmds.c:1442 +#: commands/functioncmds.c:1462 #, c-format msgid "cast will be ignored because the source data type is a domain" msgstr "el cast será ignorado porque el tipo de datos de origen es un dominio" -#: commands/functioncmds.c:1447 +#: commands/functioncmds.c:1467 #, c-format msgid "cast will be ignored because the target data type is a domain" msgstr "el cast será ignorado porque el tipo de datos de destino es un dominio" -#: commands/functioncmds.c:1474 +#: commands/functioncmds.c:1494 #, c-format msgid "cast function must take one to three arguments" msgstr "la función de conversión lleva de uno a tres argumentos" -#: commands/functioncmds.c:1478 +#: commands/functioncmds.c:1498 #, c-format msgid "argument of cast function must match or be binary-coercible from source data type" msgstr "el argumento de la función de conversión debe coincidir o ser binario-convertible con el tipo de origen" -#: commands/functioncmds.c:1482 +#: commands/functioncmds.c:1502 #, c-format msgid "second argument of cast function must be type integer" msgstr "el segundo argumento de la función de conversión debe ser entero" -#: commands/functioncmds.c:1486 +#: commands/functioncmds.c:1506 #, c-format msgid "third argument of cast function must be type boolean" msgstr "el tercer argumento de la función de conversión debe ser de tipo boolean" -#: commands/functioncmds.c:1490 +#: commands/functioncmds.c:1510 #, c-format msgid "return data type of cast function must match or be binary-coercible to target data type" msgstr "el tipo de salida de la función de conversión debe coincidir o ser binario-convertible con el tipo de retorno" -#: commands/functioncmds.c:1501 +#: commands/functioncmds.c:1521 #, c-format msgid "cast function must not be volatile" msgstr "la función de conversión no debe ser volatile" -#: commands/functioncmds.c:1506 +#: commands/functioncmds.c:1526 #, c-format msgid "cast function must not be an aggregate function" msgstr "la función de conversión no debe ser una función de agregación" -#: commands/functioncmds.c:1510 +#: commands/functioncmds.c:1530 #, c-format msgid "cast function must not be a window function" msgstr "la función de conversión no debe ser una función de ventana deslizante" -#: commands/functioncmds.c:1514 +#: commands/functioncmds.c:1534 #, c-format msgid "cast function must not return a set" msgstr "la función de conversión no debe retornar un conjunto" -#: commands/functioncmds.c:1540 +#: commands/functioncmds.c:1560 #, c-format msgid "must be superuser to create a cast WITHOUT FUNCTION" msgstr "debe ser superusuario para crear una conversión sin especificar función" -#: commands/functioncmds.c:1555 +#: commands/functioncmds.c:1575 #, c-format msgid "source and target data types are not physically compatible" msgstr "los tipos de datos de origen y destino no son físicamente compatibles" -#: commands/functioncmds.c:1570 +#: commands/functioncmds.c:1590 #, c-format msgid "composite data types are not binary-compatible" msgstr "los tipos de datos compuestos no son binario-compatibles" -#: commands/functioncmds.c:1576 +#: commands/functioncmds.c:1596 #, c-format msgid "enum data types are not binary-compatible" msgstr "los tipos de datos enum no son binario-compatibles" -#: commands/functioncmds.c:1582 +#: commands/functioncmds.c:1602 #, c-format msgid "array data types are not binary-compatible" msgstr "los tipos de datos de array no son binario-compatibles" -#: commands/functioncmds.c:1599 +#: commands/functioncmds.c:1619 #, c-format msgid "domain data types must not be marked binary-compatible" msgstr "los tipos de dato de dominio no deben ser marcados binario-compatibles" -#: commands/functioncmds.c:1609 +#: commands/functioncmds.c:1629 #, c-format msgid "source data type and target data type are the same" msgstr "el tipo de origen y el tipo de retorno son el mismo" -#: commands/functioncmds.c:1642 +#: commands/functioncmds.c:1662 #, c-format msgid "cast from type %s to type %s already exists" msgstr "la conversión del tipo %s al tipo %s ya existe" -#: commands/functioncmds.c:1717 +#: commands/functioncmds.c:1737 #, c-format msgid "cast from type %s to type %s does not exist" msgstr "no existe la conversión del tipo %s al tipo %s" -#: commands/functioncmds.c:1756 +#: commands/functioncmds.c:1776 #, c-format msgid "transform function must not be volatile" msgstr "la función de transformación no debe ser volatile" -#: commands/functioncmds.c:1760 +#: commands/functioncmds.c:1780 #, c-format msgid "transform function must not be an aggregate function" msgstr "la función de transformación no debe ser una función de agregación" -#: commands/functioncmds.c:1764 +#: commands/functioncmds.c:1784 #, c-format msgid "transform function must not be a window function" msgstr "la función de transformación no debe ser una función de ventana deslizante" -#: commands/functioncmds.c:1768 +#: commands/functioncmds.c:1788 #, c-format msgid "transform function must not return a set" msgstr "la función de transformación no debe retornar un conjunto" -#: commands/functioncmds.c:1772 +#: commands/functioncmds.c:1792 #, c-format msgid "transform function must take one argument" msgstr "la función de transformación debe recibir un argumento" -#: commands/functioncmds.c:1776 +#: commands/functioncmds.c:1796 #, c-format msgid "first argument of transform function must be type \"internal\"" msgstr "el primer argumento de la función de transformación debe ser «internal»" -#: commands/functioncmds.c:1813 +#: commands/functioncmds.c:1833 #, c-format msgid "data type %s is a pseudo-type" msgstr "el tipo de dato %s es un pseudo-tipo" -#: commands/functioncmds.c:1819 +#: commands/functioncmds.c:1839 #, c-format msgid "data type %s is a domain" msgstr "tipo de dato «%s» es un dominio" -#: commands/functioncmds.c:1859 +#: commands/functioncmds.c:1879 #, c-format msgid "return data type of FROM SQL function must be \"internal\"" msgstr "el tipo de retorno de la función FROM SQL debe ser «internal»" -#: commands/functioncmds.c:1884 +#: commands/functioncmds.c:1904 #, c-format msgid "return data type of TO SQL function must be the transform data type" msgstr "el tipo de retorn de la función TO SQL debe ser el tipo de dato de la transformación" -#: commands/functioncmds.c:1911 +#: commands/functioncmds.c:1931 #, c-format msgid "transform for type %s language \"%s\" already exists" msgstr "la transformación para el tipo %s lenguaje «%s» ya existe" -#: commands/functioncmds.c:2002 +#: commands/functioncmds.c:2022 #, c-format msgid "transform for type %s language \"%s\" does not exist" msgstr "la transformación para el tipo %s lenguaje «%s» no existe" -#: commands/functioncmds.c:2053 +#: commands/functioncmds.c:2073 #, c-format msgid "function %s already exists in schema \"%s\"" msgstr "la función %s ya existe en el esquema «%s»" -#: commands/functioncmds.c:2106 +#: commands/functioncmds.c:2126 #, c-format msgid "no inline code specified" msgstr "no se ha especificado código" -#: commands/functioncmds.c:2151 +#: commands/functioncmds.c:2171 #, c-format msgid "language \"%s\" does not support inline code execution" msgstr "el lenguaje «%s» no soporta ejecución de código en línea" @@ -7050,7 +6868,7 @@ msgstr "no se puede crear un índice en la tabla foránea «%s»" msgid "cannot create indexes on temporary tables of other sessions" msgstr "no se pueden crear índices en tablas temporales de otras sesiones" -#: commands/indexcmds.c:455 commands/tablecmds.c:546 commands/tablecmds.c:9695 +#: commands/indexcmds.c:455 commands/tablecmds.c:546 commands/tablecmds.c:9708 #, c-format msgid "only shared relations can be placed in pg_global tablespace" msgstr "sólo relaciones compartidas pueden ser puestas en el tablespace pg_global" @@ -7095,7 +6913,7 @@ msgstr "%s %s creará el índice implícito «%s» para la tabla «%s»" msgid "functions in index predicate must be marked IMMUTABLE" msgstr "las funciones utilizadas en predicados de índice deben estar marcadas IMMUTABLE" -#: commands/indexcmds.c:1049 parser/parse_utilcmd.c:1881 +#: commands/indexcmds.c:1049 parser/parse_utilcmd.c:1882 #, c-format msgid "column \"%s\" named in key does not exist" msgstr "no existe la columna «%s» en la llave" @@ -7111,7 +6929,7 @@ msgid "could not determine which collation to use for index expression" msgstr "no se pudo determinar qué ordenamiento (collation) usar para la expresión de índice" #: commands/indexcmds.c:1140 commands/typecmds.c:827 parser/parse_expr.c:2608 -#: parser/parse_type.c:550 parser/parse_utilcmd.c:2807 utils/adt/misc.c:666 +#: parser/parse_type.c:550 parser/parse_utilcmd.c:2808 utils/adt/misc.c:666 #, c-format msgid "collations are not supported by type %s" msgstr "los ordenamientos (collation) no están soportados por el tipo %s" @@ -7420,11 +7238,10 @@ msgid "operator attribute \"%s\" cannot be changed" msgstr "el atributo de operador «%s» no puede ser cambiado" #: commands/policy.c:87 commands/policy.c:388 commands/policy.c:477 -#: commands/tablecmds.c:971 commands/tablecmds.c:1313 -#: commands/tablecmds.c:2185 commands/tablecmds.c:4329 -#: commands/tablecmds.c:6280 commands/tablecmds.c:12081 -#: commands/tablecmds.c:12116 commands/trigger.c:241 commands/trigger.c:1125 -#: commands/trigger.c:1233 rewrite/rewriteDefine.c:273 +#: commands/tablecmds.c:971 commands/tablecmds.c:1313 commands/tablecmds.c:2185 +#: commands/tablecmds.c:4329 commands/tablecmds.c:6293 +#: commands/tablecmds.c:12094 commands/tablecmds.c:12129 commands/trigger.c:241 +#: commands/trigger.c:1125 commands/trigger.c:1233 rewrite/rewriteDefine.c:273 #: rewrite/rewriteDefine.c:917 #, c-format msgid "permission denied: \"%s\" is a system catalog" @@ -7470,8 +7287,7 @@ msgstr "no existe la política «%s» para la tabla «%s»" msgid "only USING expression allowed for SELECT, DELETE" msgstr "sólo se permite una expresión USING para SELECT, DELETE" -#: commands/portalcmds.c:61 commands/portalcmds.c:160 -#: commands/portalcmds.c:212 +#: commands/portalcmds.c:61 commands/portalcmds.c:160 commands/portalcmds.c:212 #, c-format msgid "invalid cursor name: must not be empty" msgstr "el nombre de cursor no es válido: no debe ser vacío" @@ -7487,7 +7303,7 @@ msgstr "no existe el cursor «%s»" msgid "invalid statement name: must not be empty" msgstr "el nombre de sentencia no es válido: no debe ser vacío" -#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1343 +#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1335 #, c-format msgid "could not determine data type of parameter $%d" msgstr "no se pudo determinar el tipo del parámetro $%d" @@ -7733,7 +7549,7 @@ msgstr "la vista materializada «%s» no existe, ignorando" msgid "Use DROP MATERIALIZED VIEW to remove a materialized view." msgstr "Use DROP MATERIALIZED VIEW para eliminar una vista materializada." -#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1630 +#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1631 #, c-format msgid "index \"%s\" does not exist" msgstr "no existe el índice «%s»" @@ -7756,8 +7572,8 @@ msgstr "«%s» no es un tipo" msgid "Use DROP TYPE to remove a type." msgstr "Use DROP TYPE para eliminar un tipo." -#: commands/tablecmds.c:252 commands/tablecmds.c:8584 -#: commands/tablecmds.c:11336 +#: commands/tablecmds.c:252 commands/tablecmds.c:8597 +#: commands/tablecmds.c:11349 #, c-format msgid "foreign table \"%s\" does not exist" msgstr "no existe la tabla foránea «%s»" @@ -7801,22 +7617,22 @@ msgstr "truncando además la tabla «%s»" msgid "cannot truncate temporary tables of other sessions" msgstr "no se pueden truncar tablas temporales de otras sesiones" -#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1844 +#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1845 #, c-format msgid "inherited relation \"%s\" is not a table or foreign table" msgstr "la relación heredada «%s» no es una tabla o tabla foránea" -#: commands/tablecmds.c:1536 commands/tablecmds.c:10151 +#: commands/tablecmds.c:1536 commands/tablecmds.c:10164 #, c-format msgid "cannot inherit from temporary relation \"%s\"" msgstr "no se puede heredar de la tabla temporal «%s»" -#: commands/tablecmds.c:1544 commands/tablecmds.c:10159 +#: commands/tablecmds.c:1544 commands/tablecmds.c:10172 #, c-format msgid "cannot inherit from temporary relation of another session" msgstr "no se puede heredar de una tabla temporal de otra sesión" -#: commands/tablecmds.c:1560 commands/tablecmds.c:10193 +#: commands/tablecmds.c:1560 commands/tablecmds.c:10206 #, c-format msgid "relation \"%s\" would be inherited from more than once" msgstr "se heredaría de la relación «%s» más de una vez" @@ -7846,7 +7662,7 @@ msgid "inherited column \"%s\" has a collation conflict" msgstr "columna heredada «%s» tiene conflicto de ordenamiento (collation)" #: commands/tablecmds.c:1629 commands/tablecmds.c:1851 -#: commands/tablecmds.c:4767 +#: commands/tablecmds.c:4780 #, c-format msgid "\"%s\" versus \"%s\"" msgstr "«%s» versus «%s»" @@ -7856,14 +7672,14 @@ msgstr "«%s» versus «%s»" msgid "inherited column \"%s\" has a storage parameter conflict" msgstr "columna heredada «%s» tiene conflicto de parámetros de almacenamiento" -#: commands/tablecmds.c:1752 commands/tablecmds.c:8089 -#: parser/parse_utilcmd.c:923 parser/parse_utilcmd.c:1274 -#: parser/parse_utilcmd.c:1350 +#: commands/tablecmds.c:1752 commands/tablecmds.c:8102 +#: parser/parse_utilcmd.c:924 parser/parse_utilcmd.c:1275 +#: parser/parse_utilcmd.c:1351 #, c-format msgid "cannot convert whole-row table reference" msgstr "no se puede convertir una referencia a la fila completa (whole-row)" -#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:924 +#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:925 #, c-format msgid "Constraint \"%s\" contains a whole-row reference to table \"%s\"." msgstr "La restricción «%s» contiene una referencia a la fila completa (whole-row) de la tabla «%s»." @@ -7990,13 +7806,13 @@ msgstr "verificando tabla «%s»" msgid "column \"%s\" contains null values" msgstr "la columna «%s» contiene valores nulos" -#: commands/tablecmds.c:4202 commands/tablecmds.c:7386 +#: commands/tablecmds.c:4202 commands/tablecmds.c:7399 #, c-format msgid "check constraint \"%s\" is violated by some row" msgstr "la restricción «check» «%s» es violada por alguna fila" -#: commands/tablecmds.c:4350 commands/trigger.c:235 -#: rewrite/rewriteDefine.c:267 rewrite/rewriteDefine.c:912 +#: commands/tablecmds.c:4350 commands/trigger.c:235 rewrite/rewriteDefine.c:267 +#: rewrite/rewriteDefine.c:912 #, c-format msgid "\"%s\" is not a table or view" msgstr "«%s» no es una tabla o vista" @@ -8031,7 +7847,7 @@ msgstr "«%s» no es una tabla o tabla foránea" msgid "\"%s\" is not a table, composite type, or foreign table" msgstr "«%s» no es una tabla, tipo compuesto, o tabla foránea" -#: commands/tablecmds.c:4374 commands/tablecmds.c:5426 +#: commands/tablecmds.c:4374 commands/tablecmds.c:5439 #, c-format msgid "\"%s\" is not a table, materialized view, index, or foreign table" msgstr "«%s» no es una tabla, vista materializada, índice o tabla foránea" @@ -8041,558 +7857,558 @@ msgstr "«%s» no es una tabla, vista materializada, índice o tabla foránea" msgid "\"%s\" is of the wrong type" msgstr "«%s» es tipo equivocado" -#: commands/tablecmds.c:4536 commands/tablecmds.c:4543 +#: commands/tablecmds.c:4557 commands/tablecmds.c:4564 #, c-format msgid "cannot alter type \"%s\" because column \"%s.%s\" uses it" msgstr "no se puede alterar el tipo «%s» porque la columna «%s.%s» lo usa" -#: commands/tablecmds.c:4550 +#: commands/tablecmds.c:4571 #, c-format msgid "cannot alter foreign table \"%s\" because column \"%s.%s\" uses its row type" msgstr "no se puede alterar la tabla foránea «%s» porque la columna «%s.%s» usa su tipo de registro" -#: commands/tablecmds.c:4557 +#: commands/tablecmds.c:4578 #, c-format msgid "cannot alter table \"%s\" because column \"%s.%s\" uses its row type" msgstr "no se puede alterar la tabla «%s» porque la columna «%s.%s» usa su tipo de registro" -#: commands/tablecmds.c:4619 +#: commands/tablecmds.c:4632 #, c-format msgid "cannot alter type \"%s\" because it is the type of a typed table" msgstr "no se puede cambiar el tipo «%s» porque es el tipo de una tabla tipada" -#: commands/tablecmds.c:4621 +#: commands/tablecmds.c:4634 #, c-format msgid "Use ALTER ... CASCADE to alter the typed tables too." msgstr "Use ALTER ... CASCADE para eliminar además las tablas tipadas." -#: commands/tablecmds.c:4665 +#: commands/tablecmds.c:4678 #, c-format msgid "type %s is not a composite type" msgstr "el tipo %s no es un tipo compuesto" -#: commands/tablecmds.c:4691 +#: commands/tablecmds.c:4704 #, c-format msgid "cannot add column to typed table" msgstr "no se puede agregar una columna a una tabla tipada" -#: commands/tablecmds.c:4759 commands/tablecmds.c:10352 +#: commands/tablecmds.c:4772 commands/tablecmds.c:10365 #, c-format msgid "child table \"%s\" has different type for column \"%s\"" msgstr "la tabla hija «%s» tiene un tipo diferente para la columna «%s»" -#: commands/tablecmds.c:4765 commands/tablecmds.c:10359 +#: commands/tablecmds.c:4778 commands/tablecmds.c:10372 #, c-format msgid "child table \"%s\" has different collation for column \"%s\"" msgstr "la tabla hija «%s» tiene un ordenamiento (collation) diferente para la columna «%s»" -#: commands/tablecmds.c:4775 +#: commands/tablecmds.c:4788 #, c-format msgid "child table \"%s\" has a conflicting \"%s\" column" msgstr "tabla hija «%s» tiene una columna «%s» que entra en conflicto" -#: commands/tablecmds.c:4787 +#: commands/tablecmds.c:4800 #, c-format msgid "merging definition of column \"%s\" for child \"%s\"" msgstr "mezclando la definición de la columna «%s» en la tabla hija «%s»" -#: commands/tablecmds.c:5014 +#: commands/tablecmds.c:5027 #, c-format msgid "column must be added to child tables too" msgstr "la columna debe ser agregada a las tablas hijas también" -#: commands/tablecmds.c:5089 +#: commands/tablecmds.c:5102 #, c-format msgid "column \"%s\" of relation \"%s\" already exists, skipping" msgstr "la columna «%s» de la relación «%s» ya existe, ignorando" -#: commands/tablecmds.c:5096 +#: commands/tablecmds.c:5109 #, c-format msgid "column \"%s\" of relation \"%s\" already exists" msgstr "la columna «%s» en la relación «%s» ya existe" -#: commands/tablecmds.c:5207 commands/tablecmds.c:5313 -#: commands/tablecmds.c:5371 commands/tablecmds.c:5485 -#: commands/tablecmds.c:5542 commands/tablecmds.c:5636 -#: commands/tablecmds.c:7925 commands/tablecmds.c:8607 +#: commands/tablecmds.c:5220 commands/tablecmds.c:5326 +#: commands/tablecmds.c:5384 commands/tablecmds.c:5498 +#: commands/tablecmds.c:5555 commands/tablecmds.c:5649 +#: commands/tablecmds.c:7938 commands/tablecmds.c:8620 #, c-format msgid "cannot alter system column \"%s\"" msgstr "no se puede alterar columna de sistema «%s»" -#: commands/tablecmds.c:5243 +#: commands/tablecmds.c:5256 #, c-format msgid "column \"%s\" is in a primary key" msgstr "la columna «%s» está en la llave primaria" -#: commands/tablecmds.c:5458 +#: commands/tablecmds.c:5471 #, c-format msgid "statistics target %d is too low" msgstr "el valor de estadísticas %d es demasiado bajo" -#: commands/tablecmds.c:5466 +#: commands/tablecmds.c:5479 #, c-format msgid "lowering statistics target to %d" msgstr "bajando el valor de estadísticas a %d" -#: commands/tablecmds.c:5616 +#: commands/tablecmds.c:5629 #, c-format msgid "invalid storage type \"%s\"" msgstr "tipo de almacenamiento no válido «%s»" -#: commands/tablecmds.c:5648 +#: commands/tablecmds.c:5661 #, c-format msgid "column data type %s can only have storage PLAIN" msgstr "el tipo de datos %s de la columna sólo puede tener almacenamiento PLAIN" -#: commands/tablecmds.c:5686 +#: commands/tablecmds.c:5699 #, c-format msgid "cannot drop column from typed table" msgstr "no se pueden eliminar columnas de una tabla tipada" -#: commands/tablecmds.c:5730 +#: commands/tablecmds.c:5743 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist, skipping" msgstr "no existe la columna «%s» en la relación «%s», ignorando" -#: commands/tablecmds.c:5743 +#: commands/tablecmds.c:5756 #, c-format msgid "cannot drop system column \"%s\"" msgstr "no se puede eliminar la columna de sistema «%s»" -#: commands/tablecmds.c:5750 +#: commands/tablecmds.c:5763 #, c-format msgid "cannot drop inherited column \"%s\"" msgstr "no se puede eliminar la columna heredada «%s»" -#: commands/tablecmds.c:5990 +#: commands/tablecmds.c:6003 #, c-format msgid "ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index \"%s\" to \"%s\"" msgstr "ALTER TABLE / ADD CONSTRAINT USING INDEX renombrará el índice «%s» a «%s»" -#: commands/tablecmds.c:6203 +#: commands/tablecmds.c:6216 #, c-format msgid "constraint must be added to child tables too" msgstr "la restricción debe ser agregada a las tablas hijas también" -#: commands/tablecmds.c:6274 +#: commands/tablecmds.c:6287 #, c-format msgid "referenced relation \"%s\" is not a table" msgstr "la relación referida «%s» no es una tabla" -#: commands/tablecmds.c:6297 +#: commands/tablecmds.c:6310 #, c-format msgid "constraints on permanent tables may reference only permanent tables" msgstr "las restricciones en tablas permanentes sólo pueden hacer referencia a tablas permanentes" -#: commands/tablecmds.c:6304 +#: commands/tablecmds.c:6317 #, c-format msgid "constraints on unlogged tables may reference only permanent or unlogged tables" msgstr "las restricciones en tablas unlogged sólo pueden hacer referencia a tablas permanentes o unlogged" -#: commands/tablecmds.c:6310 +#: commands/tablecmds.c:6323 #, c-format msgid "constraints on temporary tables may reference only temporary tables" msgstr "las restricciones en tablas temporales sólo pueden hacer referencia a tablas temporales" -#: commands/tablecmds.c:6314 +#: commands/tablecmds.c:6327 #, c-format msgid "constraints on temporary tables must involve temporary tables of this session" msgstr "las restricciones en tablas temporales sólo pueden hacer referencia a tablas temporales de esta sesión" -#: commands/tablecmds.c:6375 +#: commands/tablecmds.c:6388 #, c-format msgid "number of referencing and referenced columns for foreign key disagree" msgstr "el número de columnas referidas en la llave foránea no coincide con el número de columnas de referencia" -#: commands/tablecmds.c:6482 +#: commands/tablecmds.c:6495 #, c-format msgid "foreign key constraint \"%s\" cannot be implemented" msgstr "la restricción de llave foránea «%s» no puede ser implementada" -#: commands/tablecmds.c:6485 +#: commands/tablecmds.c:6498 #, c-format msgid "Key columns \"%s\" and \"%s\" are of incompatible types: %s and %s." msgstr "Las columnas llave «%s» y «%s» son de tipos incompatibles: %s y %s" -#: commands/tablecmds.c:6692 commands/tablecmds.c:6860 -#: commands/tablecmds.c:7764 commands/tablecmds.c:7820 +#: commands/tablecmds.c:6705 commands/tablecmds.c:6873 +#: commands/tablecmds.c:7777 commands/tablecmds.c:7833 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist" msgstr "no existe la restricción «%s» en la relación «%s»" -#: commands/tablecmds.c:6698 +#: commands/tablecmds.c:6711 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key constraint" msgstr "la restricción «%s» de la relación «%s» no es una restriccion de llave foránea" -#: commands/tablecmds.c:6867 +#: commands/tablecmds.c:6880 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key or check constraint" msgstr "la restricción «%s» de la relación «%s» no es una llave foránea o restricción «check»" -#: commands/tablecmds.c:6936 +#: commands/tablecmds.c:6949 #, c-format msgid "constraint must be validated on child tables too" msgstr "la restricción debe ser validada en las tablas hijas también" -#: commands/tablecmds.c:7005 +#: commands/tablecmds.c:7018 #, c-format msgid "column \"%s\" referenced in foreign key constraint does not exist" msgstr "no existe la columna «%s» referida en la llave foránea" -#: commands/tablecmds.c:7010 +#: commands/tablecmds.c:7023 #, c-format msgid "cannot have more than %d keys in a foreign key" msgstr "no se puede tener más de %d columnas en una llave foránea" -#: commands/tablecmds.c:7075 +#: commands/tablecmds.c:7088 #, c-format msgid "cannot use a deferrable primary key for referenced table \"%s\"" msgstr "no se puede usar una llave primaria postergable para la tabla referenciada «%s»" -#: commands/tablecmds.c:7092 +#: commands/tablecmds.c:7105 #, c-format msgid "there is no primary key for referenced table \"%s\"" msgstr "no hay llave primaria para la tabla referida «%s»" -#: commands/tablecmds.c:7157 +#: commands/tablecmds.c:7170 #, c-format msgid "foreign key referenced-columns list must not contain duplicates" msgstr "la lista de columnas referidas en una llave foránea no debe contener duplicados" -#: commands/tablecmds.c:7251 +#: commands/tablecmds.c:7264 #, c-format msgid "cannot use a deferrable unique constraint for referenced table \"%s\"" msgstr "no se puede usar una restricción unique postergable para la tabla referenciada «%s»" -#: commands/tablecmds.c:7256 +#: commands/tablecmds.c:7269 #, c-format msgid "there is no unique constraint matching given keys for referenced table \"%s\"" msgstr "no hay restricción unique que coincida con las columnas dadas en la tabla referida «%s»" -#: commands/tablecmds.c:7419 +#: commands/tablecmds.c:7432 #, c-format msgid "validating foreign key constraint \"%s\"" msgstr "validando restricción de llave foránea «%s»" -#: commands/tablecmds.c:7718 +#: commands/tablecmds.c:7731 #, c-format msgid "cannot drop inherited constraint \"%s\" of relation \"%s\"" msgstr "no se puede eliminar la restricción «%s» heredada de la relación «%s»" -#: commands/tablecmds.c:7770 +#: commands/tablecmds.c:7783 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist, skipping" msgstr "la restricción «%s» en la relación «%s» no existe, ignorando" -#: commands/tablecmds.c:7909 +#: commands/tablecmds.c:7922 #, c-format msgid "cannot alter column type of typed table" msgstr "no se puede cambiar el tipo de una columna de una tabla tipada" -#: commands/tablecmds.c:7932 +#: commands/tablecmds.c:7945 #, c-format msgid "cannot alter inherited column \"%s\"" msgstr "no se puede alterar la columna heredada «%s»" -#: commands/tablecmds.c:7981 +#: commands/tablecmds.c:7994 #, c-format msgid "result of USING clause for column \"%s\" cannot be cast automatically to type %s" msgstr "el resultado de la cláusula USING para la columna «%s» no puede ser convertido automáticamente al tipo %s" -#: commands/tablecmds.c:7984 +#: commands/tablecmds.c:7997 #, c-format msgid "You might need to add an explicit cast." msgstr "Puede ser necesario agregar un cast explícito." -#: commands/tablecmds.c:7988 +#: commands/tablecmds.c:8001 #, c-format msgid "column \"%s\" cannot be cast automatically to type %s" msgstr "la columna «%s» no puede convertirse automáticamente al tipo %s" #. translator: USING is SQL, don't translate it -#: commands/tablecmds.c:7991 +#: commands/tablecmds.c:8004 #, c-format msgid "You might need to specify \"USING %s::%s\"." msgstr "Puede ser necesario especificar «USING %s::%s»." -#: commands/tablecmds.c:8090 +#: commands/tablecmds.c:8103 #, c-format msgid "USING expression contains a whole-row table reference." msgstr "La expresión USING contiene una referencia a la fila completa (whole-row)." -#: commands/tablecmds.c:8101 +#: commands/tablecmds.c:8114 #, c-format msgid "type of inherited column \"%s\" must be changed in child tables too" msgstr "debe cambiar el tipo a la columna heredada «%s» en las tablas hijas también" -#: commands/tablecmds.c:8188 +#: commands/tablecmds.c:8201 #, c-format msgid "cannot alter type of column \"%s\" twice" msgstr "no se puede alterar el tipo de la columna «%s» dos veces" -#: commands/tablecmds.c:8224 +#: commands/tablecmds.c:8237 #, c-format msgid "default for column \"%s\" cannot be cast automatically to type %s" msgstr "el valor por omisión para la columna «%s» no puede ser convertido automáticamente al tipo %s" -#: commands/tablecmds.c:8350 +#: commands/tablecmds.c:8363 #, c-format msgid "cannot alter type of a column used by a view or rule" msgstr "no se puede alterar el tipo de una columna usada en una regla o vista" -#: commands/tablecmds.c:8351 commands/tablecmds.c:8370 -#: commands/tablecmds.c:8388 +#: commands/tablecmds.c:8364 commands/tablecmds.c:8383 +#: commands/tablecmds.c:8401 #, c-format msgid "%s depends on column \"%s\"" msgstr "%s depende de la columna «%s»" -#: commands/tablecmds.c:8369 +#: commands/tablecmds.c:8382 #, c-format msgid "cannot alter type of a column used in a trigger definition" msgstr "no se puede alterar el tipo de una columna usada en una definición de trigger" -#: commands/tablecmds.c:8387 +#: commands/tablecmds.c:8400 #, c-format msgid "cannot alter type of a column used in a policy definition" msgstr "no se puede alterar el tipo de una columna usada en una definición de política" -#: commands/tablecmds.c:9052 +#: commands/tablecmds.c:9065 #, c-format msgid "cannot change owner of index \"%s\"" msgstr "no se puede cambiar el dueño del índice «%s»" -#: commands/tablecmds.c:9054 +#: commands/tablecmds.c:9067 #, c-format msgid "Change the ownership of the index's table, instead." msgstr "Considere cambiar el dueño de la tabla en vez de cambiar el dueño del índice." -#: commands/tablecmds.c:9070 +#: commands/tablecmds.c:9083 #, c-format msgid "cannot change owner of sequence \"%s\"" msgstr "no se puede cambiar el dueño de la secuencia «%s»" -#: commands/tablecmds.c:9072 commands/tablecmds.c:11544 +#: commands/tablecmds.c:9085 commands/tablecmds.c:11557 #, c-format msgid "Sequence \"%s\" is linked to table \"%s\"." msgstr "La secuencia «%s» está enlazada a la tabla «%s»." -#: commands/tablecmds.c:9084 commands/tablecmds.c:12191 +#: commands/tablecmds.c:9097 commands/tablecmds.c:12204 #, c-format msgid "Use ALTER TYPE instead." msgstr "Considere usar ALTER TYPE." -#: commands/tablecmds.c:9093 +#: commands/tablecmds.c:9106 #, c-format msgid "\"%s\" is not a table, view, sequence, or foreign table" msgstr "«%s» no es una tabla, vista, secuencia o tabla foránea" -#: commands/tablecmds.c:9436 +#: commands/tablecmds.c:9449 #, c-format msgid "cannot have multiple SET TABLESPACE subcommands" msgstr "no se pueden tener múltiples subórdenes SET TABLESPACE" -#: commands/tablecmds.c:9509 +#: commands/tablecmds.c:9522 #, c-format msgid "\"%s\" is not a table, view, materialized view, index, or TOAST table" msgstr "«%s» no es una tabla, vista, tabla materializada, índice o tabla TOAST" -#: commands/tablecmds.c:9542 commands/view.c:498 +#: commands/tablecmds.c:9555 commands/view.c:498 #, c-format msgid "WITH CHECK OPTION is supported only on automatically updatable views" msgstr "WITH CHECK OPTION sólo puede usarse en vistas automáticamente actualizables" -#: commands/tablecmds.c:9688 +#: commands/tablecmds.c:9701 #, c-format msgid "cannot move system relation \"%s\"" msgstr "no se puede mover la relación de sistema «%s»" -#: commands/tablecmds.c:9704 +#: commands/tablecmds.c:9717 #, c-format msgid "cannot move temporary tables of other sessions" msgstr "no se pueden mover tablas temporales de otras sesiones" -#: commands/tablecmds.c:9841 +#: commands/tablecmds.c:9854 #, c-format msgid "only tables, indexes, and materialized views exist in tablespaces" msgstr "solamente tablas, índices y vistas materializadas existen en tablespaces" -#: commands/tablecmds.c:9853 +#: commands/tablecmds.c:9866 #, c-format msgid "cannot move relations in to or out of pg_global tablespace" msgstr "no se puede mover objetos hacia o desde el tablespace pg_global" -#: commands/tablecmds.c:9944 +#: commands/tablecmds.c:9957 #, c-format msgid "aborting because lock on relation \"%s.%s\" is not available" msgstr "cancelando porque el lock en la relación «%s.%s» no está disponible" -#: commands/tablecmds.c:9960 +#: commands/tablecmds.c:9973 #, c-format msgid "no matching relations in tablespace \"%s\" found" msgstr "no se encontraron relaciones coincidentes en el tablespace «%s»" -#: commands/tablecmds.c:10034 storage/buffer/bufmgr.c:915 +#: commands/tablecmds.c:10047 storage/buffer/bufmgr.c:915 #, c-format msgid "invalid page in block %u of relation %s" msgstr "la página no es válida en el bloque %u de la relación %s" -#: commands/tablecmds.c:10116 +#: commands/tablecmds.c:10129 #, c-format msgid "cannot change inheritance of typed table" msgstr "no se puede cambiar la herencia de una tabla tipada" -#: commands/tablecmds.c:10166 +#: commands/tablecmds.c:10179 #, c-format msgid "cannot inherit to temporary relation of another session" msgstr "no se puede agregar herencia a tablas temporales de otra sesión" -#: commands/tablecmds.c:10220 +#: commands/tablecmds.c:10233 #, c-format msgid "circular inheritance not allowed" msgstr "la herencia circular no está permitida" -#: commands/tablecmds.c:10221 +#: commands/tablecmds.c:10234 #, c-format msgid "\"%s\" is already a child of \"%s\"." msgstr "«%s» ya es un hijo de «%s»." -#: commands/tablecmds.c:10229 +#: commands/tablecmds.c:10242 #, c-format msgid "table \"%s\" without OIDs cannot inherit from table \"%s\" with OIDs" msgstr "tabla «%s» sin OIDs no puede heredar de tabla «%s» con OIDs" -#: commands/tablecmds.c:10370 +#: commands/tablecmds.c:10383 #, c-format msgid "column \"%s\" in child table must be marked NOT NULL" msgstr "columna «%s» en tabla hija debe marcarse como NOT NULL" -#: commands/tablecmds.c:10386 commands/tablecmds.c:10419 +#: commands/tablecmds.c:10399 commands/tablecmds.c:10432 #, c-format msgid "child table is missing column \"%s\"" msgstr "tabla hija no tiene la columna «%s»" -#: commands/tablecmds.c:10502 +#: commands/tablecmds.c:10515 #, c-format msgid "child table \"%s\" has different definition for check constraint \"%s\"" msgstr "la tabla hija «%s» tiene una definición diferente para la restricción «check» «%s»" -#: commands/tablecmds.c:10510 +#: commands/tablecmds.c:10523 #, c-format msgid "constraint \"%s\" conflicts with non-inherited constraint on child table \"%s\"" msgstr "la restricción «%s» está en conflicto con la restricción no heredada en la tabla hija «%s»" -#: commands/tablecmds.c:10521 +#: commands/tablecmds.c:10534 #, c-format msgid "constraint \"%s\" conflicts with NOT VALID constraint on child table \"%s\"" msgstr "la restricción «%s» está en conflicto con la restricción NOT VALID en la tabla hija «%s»" -#: commands/tablecmds.c:10545 +#: commands/tablecmds.c:10558 #, c-format msgid "child table is missing constraint \"%s\"" msgstr "tabla hija no tiene la restricción «%s»" -#: commands/tablecmds.c:10629 +#: commands/tablecmds.c:10642 #, c-format msgid "relation \"%s\" is not a parent of relation \"%s\"" msgstr "relación «%s» no es un padre de la relación «%s»" -#: commands/tablecmds.c:10863 +#: commands/tablecmds.c:10876 #, c-format msgid "typed tables cannot inherit" msgstr "las tablas tipadas no pueden heredar" -#: commands/tablecmds.c:10894 +#: commands/tablecmds.c:10907 #, c-format msgid "table is missing column \"%s\"" msgstr "la tabla no tiene la columna «%s»" -#: commands/tablecmds.c:10904 +#: commands/tablecmds.c:10917 #, c-format msgid "table has column \"%s\" where type requires \"%s\"" msgstr "la tabla tiene columna «%s» en la posición en que el tipo requiere «%s»." -#: commands/tablecmds.c:10913 +#: commands/tablecmds.c:10926 #, c-format msgid "table \"%s\" has different type for column \"%s\"" msgstr "la tabla «%s» tiene un tipo diferente para la columna «%s»" -#: commands/tablecmds.c:10926 +#: commands/tablecmds.c:10939 #, c-format msgid "table has extra column \"%s\"" msgstr "tabla tiene la columna extra «%s»" -#: commands/tablecmds.c:10978 +#: commands/tablecmds.c:10991 #, c-format msgid "\"%s\" is not a typed table" msgstr "«%s» no es una tabla tipada" -#: commands/tablecmds.c:11162 +#: commands/tablecmds.c:11175 #, c-format msgid "cannot use non-unique index \"%s\" as replica identity" msgstr "no se puede usar el índice no-único «%s» como identidad de réplica" -#: commands/tablecmds.c:11168 +#: commands/tablecmds.c:11181 #, c-format msgid "cannot use non-immediate index \"%s\" as replica identity" msgstr "no puede usar el índice no-inmediato «%s» como identidad de réplica" -#: commands/tablecmds.c:11174 +#: commands/tablecmds.c:11187 #, c-format msgid "cannot use expression index \"%s\" as replica identity" msgstr "no se puede usar el índice funcional «%s» como identidad de réplica" -#: commands/tablecmds.c:11180 +#: commands/tablecmds.c:11193 #, c-format msgid "cannot use partial index \"%s\" as replica identity" msgstr "no se puede usar el índice parcial «%s» como identidad de réplica" -#: commands/tablecmds.c:11186 +#: commands/tablecmds.c:11199 #, c-format msgid "cannot use invalid index \"%s\" as replica identity" msgstr "no se puede usar el índice no válido «%s» como identidad de réplica" -#: commands/tablecmds.c:11207 +#: commands/tablecmds.c:11220 #, c-format msgid "index \"%s\" cannot be used as replica identity because column %d is a system column" msgstr "el índice «%s» no puede usarse como identidad de réplica porque la column %d es una columna de sistema" -#: commands/tablecmds.c:11214 +#: commands/tablecmds.c:11227 #, c-format msgid "index \"%s\" cannot be used as replica identity because column \"%s\" is nullable" msgstr "el índice «%s» no puede usarse como identidad de réplica porque la column «%s» acepta valores nulos" -#: commands/tablecmds.c:11417 +#: commands/tablecmds.c:11430 #, c-format msgid "cannot change logged status of table \"%s\" because it is temporary" msgstr "no se puede cambiar el estado «logged» de la tabla «%s» porque es temporal" -#: commands/tablecmds.c:11476 +#: commands/tablecmds.c:11489 #, c-format msgid "could not change table \"%s\" to logged because it references unlogged table \"%s\"" msgstr "no se pudo cambiar la tabla «%s» a «logged» porque hace referencia a la tabla «unlogged» «%s»" -#: commands/tablecmds.c:11486 +#: commands/tablecmds.c:11499 #, c-format msgid "could not change table \"%s\" to unlogged because it references logged table \"%s\"" msgstr "no se pudo cambiar la tabla «%s» a «unlogged» porque hace referencia a la tabla «logged» «%s»" -#: commands/tablecmds.c:11543 +#: commands/tablecmds.c:11556 #, c-format msgid "cannot move an owned sequence into another schema" msgstr "no se puede mover una secuencia enlazada a una tabla hacia otro esquema" -#: commands/tablecmds.c:11648 +#: commands/tablecmds.c:11661 #, c-format msgid "relation \"%s\" already exists in schema \"%s\"" msgstr "ya relación «%s» ya existe en el esquema «%s»" -#: commands/tablecmds.c:12175 +#: commands/tablecmds.c:12188 #, c-format msgid "\"%s\" is not a composite type" msgstr "«%s» no es un tipo compuesto" -#: commands/tablecmds.c:12205 +#: commands/tablecmds.c:12218 #, c-format msgid "\"%s\" is not a table, view, materialized view, sequence, or foreign table" msgstr "«%s» no es una tabla, vista, vista materializada, secuencia o tabla foránea" @@ -8877,10 +8693,9 @@ msgstr "el registro a ser actualizado ya fue modificado por una operación dispa msgid "Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." msgstr "Considere usar un disparador AFTER en lugar de un disparador BEFORE para propagar cambios a otros registros." -#: commands/trigger.c:2741 executor/execMain.c:2379 -#: executor/nodeLockRows.c:216 executor/nodeModifyTable.c:213 -#: executor/nodeModifyTable.c:692 executor/nodeModifyTable.c:985 -#: executor/nodeModifyTable.c:1151 +#: commands/trigger.c:2741 executor/execMain.c:2379 executor/nodeLockRows.c:216 +#: executor/nodeModifyTable.c:213 executor/nodeModifyTable.c:692 +#: executor/nodeModifyTable.c:985 executor/nodeModifyTable.c:1151 #, c-format msgid "could not serialize access due to concurrent update" msgstr "no se pudo serializar el acceso debido a un update concurrente" @@ -9235,42 +9050,42 @@ msgstr "la restricción «%s» en el dominio «%s» no es una restricción «che msgid "column \"%s\" of table \"%s\" contains values that violate the new constraint" msgstr "la columna «%s» de la relación «%s» contiene valores que violan la nueva restricción" -#: commands/typecmds.c:2971 commands/typecmds.c:3228 commands/typecmds.c:3417 +#: commands/typecmds.c:2986 commands/typecmds.c:3243 commands/typecmds.c:3432 #, c-format msgid "%s is not a domain" msgstr "%s no es un dominio" -#: commands/typecmds.c:3005 +#: commands/typecmds.c:3020 #, c-format msgid "constraint \"%s\" for domain \"%s\" already exists" msgstr "la restricción «%s» para el dominio «%s» ya existe" -#: commands/typecmds.c:3055 +#: commands/typecmds.c:3070 #, c-format msgid "cannot use table references in domain check constraint" msgstr "no se pueden usar referencias a tablas en restricción «check» para un dominio" -#: commands/typecmds.c:3158 commands/typecmds.c:3240 commands/typecmds.c:3534 +#: commands/typecmds.c:3173 commands/typecmds.c:3255 commands/typecmds.c:3549 #, c-format msgid "%s is a table's row type" msgstr "%s es el tipo de registro de una tabla" -#: commands/typecmds.c:3160 commands/typecmds.c:3242 commands/typecmds.c:3536 +#: commands/typecmds.c:3175 commands/typecmds.c:3257 commands/typecmds.c:3551 #, c-format msgid "Use ALTER TABLE instead." msgstr "Considere usar ALTER TABLE." -#: commands/typecmds.c:3167 commands/typecmds.c:3249 commands/typecmds.c:3449 +#: commands/typecmds.c:3182 commands/typecmds.c:3264 commands/typecmds.c:3464 #, c-format msgid "cannot alter array type %s" msgstr "no se puede alterar el tipo de array «%s»" -#: commands/typecmds.c:3169 commands/typecmds.c:3251 commands/typecmds.c:3451 +#: commands/typecmds.c:3184 commands/typecmds.c:3266 commands/typecmds.c:3466 #, c-format msgid "You can alter type %s, which will alter the array type as well." msgstr "Puede alterar el tipo %s, lo cual alterará el tipo de array también." -#: commands/typecmds.c:3519 +#: commands/typecmds.c:3534 #, c-format msgid "type \"%s\" already exists in schema \"%s\"" msgstr "el tipo «%s» ya existe en el esquema «%s»" @@ -9301,7 +9116,7 @@ msgid "permission denied to create role" msgstr "se ha denegado el permiso para crear el rol" #: commands/user.c:322 commands/user.c:1176 commands/user.c:1183 -#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 gram.y:13619 gram.y:13654 +#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 gram.y:13628 gram.y:13663 #, c-format msgid "role name \"%s\" is reserved" msgstr "el nombre de rol «%s» está reservado" @@ -9544,61 +9359,66 @@ msgstr "tasa lectura promedio: %.3f MB/s, tasa escritura promedio: %.3f MB/s\n" msgid "system usage: %s" msgstr "uso de sistema: %s" -#: commands/vacuumlazy.c:853 +#: commands/vacuumlazy.c:852 #, c-format msgid "relation \"%s\" page %u is uninitialized --- fixing" msgstr "la página %2$u de la relación «%1$s» no está inicializada --- arreglando" -#: commands/vacuumlazy.c:1323 +#: commands/vacuumlazy.c:1322 #, c-format msgid "\"%s\": removed %.0f row versions in %u pages" msgstr "«%s»: se eliminaron %.0f versiones de filas en %u páginas" -#: commands/vacuumlazy.c:1333 +#: commands/vacuumlazy.c:1332 #, c-format msgid "%.0f dead row versions cannot be removed yet.\n" msgstr "%.0f versiones muertas de filas no pueden ser eliminadas aún.\n" -#: commands/vacuumlazy.c:1335 +#: commands/vacuumlazy.c:1334 #, c-format msgid "There were %.0f unused item pointers.\n" msgstr "Hubo %.0f punteros de ítem sin uso.\n" -#: commands/vacuumlazy.c:1337 +#: commands/vacuumlazy.c:1336 #, c-format msgid "Skipped %u page due to buffer pins.\n" msgid_plural "Skipped %u pages due to buffer pins.\n" msgstr[0] "Saltada %u página debido a «pins» de búfers.\n" msgstr[1] "Saltadas %u páginas debido a «pins» de búfers.\n" -#: commands/vacuumlazy.c:1341 +#: commands/vacuumlazy.c:1340 #, c-format msgid "%u page is entirely empty.\n" msgid_plural "%u pages are entirely empty.\n" msgstr[0] "%u página está completamente vacía.\n" msgstr[1] "%u páginas están completamente vacías.\n" -#: commands/vacuumlazy.c:1349 +#: commands/vacuumlazy.c:1344 +#, c-format +msgid "%s." +msgstr "%s." + +#: commands/vacuumlazy.c:1347 #, c-format msgid "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u pages" msgstr "«%s»: se encontraron %.0f versiones de filas eliminables y %.0f no eliminables en %u de %u páginas" -#: commands/vacuumlazy.c:1418 +#: commands/vacuumlazy.c:1416 #, c-format msgid "\"%s\": removed %d row versions in %d pages" msgstr "«%s»: se eliminaron %d versiones de filas en %d páginas" -#: commands/vacuumlazy.c:1607 +#: commands/vacuumlazy.c:1604 #, c-format msgid "scanned index \"%s\" to remove %d row versions" msgstr "se recorrió el índice «%s» para eliminar %d versiones de filas" -#: commands/vacuumlazy.c:1653 +#: commands/vacuumlazy.c:1650 #, c-format msgid "index \"%s\" now contains %.0f row versions in %u pages" msgstr "el índice «%s» ahora contiene %.0f versiones de filas en %u páginas" -#: commands/vacuumlazy.c:1657 +#: commands/vacuumlazy.c:1654 #, c-format msgid "" "%.0f index row versions were removed.\n" @@ -9609,17 +9429,17 @@ msgstr "" "%u páginas de índice han sido eliminadas, %u son reusables.\n" "%s." -#: commands/vacuumlazy.c:1752 +#: commands/vacuumlazy.c:1749 #, c-format msgid "\"%s\": stopping truncate due to conflicting lock request" msgstr "«%s»: suspendiendo el truncado debido a una petición de lock en conflicto" -#: commands/vacuumlazy.c:1817 +#: commands/vacuumlazy.c:1814 #, c-format msgid "\"%s\": truncated %u to %u pages" msgstr "«%s»: truncadas %u a %u páginas" -#: commands/vacuumlazy.c:1873 +#: commands/vacuumlazy.c:1870 #, c-format msgid "\"%s\": suspending truncate due to conflicting lock request" msgstr "«%s»: suspendiendo el truncado debido a una petición de lock en conflicto" @@ -9684,7 +9504,7 @@ msgstr "SET TRANSACTION ISOLATION LEVEL debe ser llamado antes de cualquier cons msgid "SET TRANSACTION ISOLATION LEVEL must not be called in a subtransaction" msgstr "SET TRANSACTION ISOLATION LEVEL no debe ser llamado en una subtransacción" -#: commands/variable.c:574 storage/lmgr/predicate.c:1587 +#: commands/variable.c:574 storage/lmgr/predicate.c:1602 #, c-format msgid "cannot use serializable mode in a hot standby" msgstr "no se puede utilizar el modo serializable en un hot standby" @@ -9716,8 +9536,8 @@ msgstr "No se puede cambiar «client_encoding» ahora." #: commands/variable.c:779 #, c-format -msgid "cannot change client_encoding in a parallel worker" -msgstr "no se puede cambiar «client_encoding» en un trabajador paralelo" +msgid "cannot change client_encoding during a parallel operation" +msgstr "no se puede cambiar client_encoding en un trabajador paralelo" #: commands/variable.c:915 #, c-format @@ -9869,32 +9689,32 @@ msgstr "no se puede cambiar la secuencia «%s»" msgid "cannot change TOAST relation \"%s\"" msgstr "no se puede cambiar la relación TOAST «%s»" -#: executor/execMain.c:1051 rewrite/rewriteHandler.c:2648 +#: executor/execMain.c:1051 rewrite/rewriteHandler.c:2679 #, c-format msgid "cannot insert into view \"%s\"" msgstr "no se puede insertar en la vista «%s»" -#: executor/execMain.c:1053 rewrite/rewriteHandler.c:2651 +#: executor/execMain.c:1053 rewrite/rewriteHandler.c:2682 #, c-format msgid "To enable inserting into the view, provide an INSTEAD OF INSERT trigger or an unconditional ON INSERT DO INSTEAD rule." msgstr "Para activar las inserciones en la vista, provea un disparador INSTEAD OF INSERT un una regla incodicional ON INSERT DO INSTEAD." -#: executor/execMain.c:1059 rewrite/rewriteHandler.c:2656 +#: executor/execMain.c:1059 rewrite/rewriteHandler.c:2687 #, c-format msgid "cannot update view \"%s\"" msgstr "no se puede actualizar la vista «%s»" -#: executor/execMain.c:1061 rewrite/rewriteHandler.c:2659 +#: executor/execMain.c:1061 rewrite/rewriteHandler.c:2690 #, c-format msgid "To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule." msgstr "Para activar las actualizaciones en la vista, provea un disparador INSTEAD OF UPDATE o una regla incondicional ON UPDATE DO INSTEAD." -#: executor/execMain.c:1067 rewrite/rewriteHandler.c:2664 +#: executor/execMain.c:1067 rewrite/rewriteHandler.c:2695 #, c-format msgid "cannot delete from view \"%s\"" msgstr "no se puede eliminar de la vista «%s»" -#: executor/execMain.c:1069 rewrite/rewriteHandler.c:2667 +#: executor/execMain.c:1069 rewrite/rewriteHandler.c:2698 #, c-format msgid "To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an unconditional ON DELETE DO INSTEAD rule." msgstr "Para activar las eliminaciones en la vista, provea un disparador INSTEAD OF DELETE o una regla incondicional ON DELETE DO INSTEAD." @@ -10618,339 +10438,339 @@ msgstr "se esperaba una respuesta de contraseña, se obtuvo mensaje de tipo %d" msgid "invalid password packet size" msgstr "el tamaño del paquete de contraseña no es válido" -#: libpq/auth.c:828 +#: libpq/auth.c:712 +#, c-format +msgid "empty password returned by client" +msgstr "el cliente retornó una contraseña vacía" + +#: libpq/auth.c:842 #, c-format msgid "GSSAPI is not supported in protocol version 2" msgstr "GSSAPI no está soportado por el protocolo versión 2" -#: libpq/auth.c:888 +#: libpq/auth.c:902 #, c-format msgid "expected GSS response, got message type %d" msgstr "se esperaba una respuesta GSS, se obtuvo mensaje de tipo %d" -#: libpq/auth.c:949 +#: libpq/auth.c:963 msgid "accepting GSS security context failed" msgstr "falló la aceptación del contexto de seguridad GSS" -#: libpq/auth.c:975 +#: libpq/auth.c:989 msgid "retrieving GSS user name failed" msgstr "falló la obtención del nombre de usuario GSS" -#: libpq/auth.c:1094 +#: libpq/auth.c:1108 #, c-format msgid "SSPI is not supported in protocol version 2" msgstr "SSPI no está soportado por el protocolo versión 2" -#: libpq/auth.c:1109 +#: libpq/auth.c:1123 msgid "could not acquire SSPI credentials" msgstr "no se pudo obtener las credenciales SSPI" -#: libpq/auth.c:1127 +#: libpq/auth.c:1141 #, c-format msgid "expected SSPI response, got message type %d" msgstr "se esperaba una respuesta SSPI, se obtuvo mensaje de tipo %d" -#: libpq/auth.c:1199 +#: libpq/auth.c:1213 msgid "could not accept SSPI security context" msgstr "no se pudo aceptar un contexto SSPI" -#: libpq/auth.c:1261 +#: libpq/auth.c:1275 msgid "could not get token from SSPI security context" msgstr "no se pudo obtener un testigo (token) desde el contexto de seguridad SSPI" -#: libpq/auth.c:1380 libpq/auth.c:1399 +#: libpq/auth.c:1394 libpq/auth.c:1413 #, c-format msgid "could not translate name" msgstr "no se pudo traducir el nombre" -#: libpq/auth.c:1412 +#: libpq/auth.c:1426 #, c-format msgid "realm name too long" msgstr "nombre de «realm» demasiado largo" -#: libpq/auth.c:1427 +#: libpq/auth.c:1441 #, c-format msgid "translated account name too long" msgstr "nombre de cuenta traducido demasiado largo" -#: libpq/auth.c:1613 +#: libpq/auth.c:1627 #, c-format msgid "could not create socket for Ident connection: %m" msgstr "no se pudo crear un socket para conexión Ident: %m" -#: libpq/auth.c:1628 +#: libpq/auth.c:1642 #, c-format msgid "could not bind to local address \"%s\": %m" msgstr "no se pudo enlazar a la dirección local «%s»: %m" -#: libpq/auth.c:1640 +#: libpq/auth.c:1654 #, c-format msgid "could not connect to Ident server at address \"%s\", port %s: %m" msgstr "no se pudo conectar al servidor Ident «%s», port %s: %m" -#: libpq/auth.c:1662 +#: libpq/auth.c:1676 #, c-format msgid "could not send query to Ident server at address \"%s\", port %s: %m" msgstr "no se pudo enviar consulta Ident al servidor «%s», port %s: %m" -#: libpq/auth.c:1679 +#: libpq/auth.c:1693 #, c-format msgid "could not receive response from Ident server at address \"%s\", port %s: %m" msgstr "no se pudo recibir respuesta Ident desde el servidor «%s», port %s: %m" -#: libpq/auth.c:1689 +#: libpq/auth.c:1703 #, c-format msgid "invalidly formatted response from Ident server: \"%s\"" msgstr "respuesta del servidor Ident en formato no válido: «%s»" -#: libpq/auth.c:1729 +#: libpq/auth.c:1743 #, c-format msgid "peer authentication is not supported on this platform" msgstr "método de autentificación peer no está soportado en esta plataforma" -#: libpq/auth.c:1733 +#: libpq/auth.c:1747 #, c-format msgid "could not get peer credentials: %m" msgstr "no se pudo recibir credenciales: %m" -#: libpq/auth.c:1742 +#: libpq/auth.c:1756 #, c-format msgid "could not look up local user ID %ld: %s" msgstr "no se pudo encontrar el ID del usuario local %ld: %s" -#: libpq/auth.c:1826 libpq/auth.c:2152 libpq/auth.c:2515 -#, c-format -msgid "empty password returned by client" -msgstr "el cliente retornó una contraseña vacía" - -#: libpq/auth.c:1836 +#: libpq/auth.c:1844 #, c-format msgid "error from underlying PAM layer: %s" msgstr "se ha recibido un error de la biblioteca PAM: %s" -#: libpq/auth.c:1917 +#: libpq/auth.c:1925 #, c-format msgid "could not create PAM authenticator: %s" msgstr "no se pudo crear autenticador PAM: %s" -#: libpq/auth.c:1928 +#: libpq/auth.c:1936 #, c-format msgid "pam_set_item(PAM_USER) failed: %s" msgstr "pam_set_item(PAM_USER) falló: %s" -#: libpq/auth.c:1939 +#: libpq/auth.c:1947 #, c-format msgid "pam_set_item(PAM_RHOST) failed: %s" msgstr "pam_set_item(PAM_RHOST) falló: %s" -#: libpq/auth.c:1950 +#: libpq/auth.c:1958 #, c-format msgid "pam_set_item(PAM_CONV) failed: %s" msgstr "pam_set_item(PAM_CONV) falló: %s" -#: libpq/auth.c:1961 +#: libpq/auth.c:1969 #, c-format msgid "pam_authenticate failed: %s" msgstr "pam_authenticate falló: %s" -#: libpq/auth.c:1972 +#: libpq/auth.c:1980 #, c-format msgid "pam_acct_mgmt failed: %s" msgstr "pam_acct_mgmt falló: %s" -#: libpq/auth.c:1983 +#: libpq/auth.c:1991 #, c-format msgid "could not release PAM authenticator: %s" msgstr "no se pudo liberar autenticador PAM: %s" -#: libpq/auth.c:2048 +#: libpq/auth.c:2056 #, c-format msgid "could not initialize LDAP: %m" msgstr "no se pudo inicializar LDAP: %m" -#: libpq/auth.c:2051 +#: libpq/auth.c:2059 #, c-format msgid "could not initialize LDAP: error code %d" msgstr "no se pudo inicializar LDAP: código de error %d" -#: libpq/auth.c:2061 +#: libpq/auth.c:2069 #, c-format msgid "could not set LDAP protocol version: %s" msgstr "no se pudo definir la versión de protocolo LDAP: %s" -#: libpq/auth.c:2090 +#: libpq/auth.c:2098 #, c-format msgid "could not load wldap32.dll" msgstr "no se pudo cargar wldap32.dll" -#: libpq/auth.c:2098 +#: libpq/auth.c:2106 #, c-format msgid "could not load function _ldap_start_tls_sA in wldap32.dll" msgstr "no se pudo cargar la función _ldap_start_tls_sA en wldap32.dll" -#: libpq/auth.c:2099 +#: libpq/auth.c:2107 #, c-format msgid "LDAP over SSL is not supported on this platform." msgstr "LDAP sobre SSL no está soportado en esta plataforma." -#: libpq/auth.c:2114 +#: libpq/auth.c:2122 #, c-format msgid "could not start LDAP TLS session: %s" msgstr "no se pudo iniciar sesión de LDAP TLS: %s" -#: libpq/auth.c:2136 +#: libpq/auth.c:2144 #, c-format msgid "LDAP server not specified" msgstr "servidor LDAP no especificado" -#: libpq/auth.c:2189 +#: libpq/auth.c:2192 #, c-format msgid "invalid character in user name for LDAP authentication" msgstr "carácter no válido en nombre de usuario para autentificación LDAP" -#: libpq/auth.c:2204 +#: libpq/auth.c:2207 #, c-format msgid "could not perform initial LDAP bind for ldapbinddn \"%s\" on server \"%s\": %s" msgstr "no se pudo hacer el enlace LDAP inicial para el ldapbinddb «%s» en el servidor «%s»: %s" -#: libpq/auth.c:2228 +#: libpq/auth.c:2231 #, c-format msgid "could not search LDAP for filter \"%s\" on server \"%s\": %s" msgstr "no se pudo hacer la búsqueda LDAP para el filtro «%s» en el servidor «%s»: %s" -#: libpq/auth.c:2239 +#: libpq/auth.c:2242 #, c-format msgid "LDAP user \"%s\" does not exist" msgstr "no existe el usuario LDAP «%s»" -#: libpq/auth.c:2240 +#: libpq/auth.c:2243 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned no entries." msgstr "La búsqueda LDAP para el filtro «%s» en el servidor «%s» no retornó elementos." -#: libpq/auth.c:2244 +#: libpq/auth.c:2247 #, c-format msgid "LDAP user \"%s\" is not unique" msgstr "el usuario LDAP «%s» no es única" -#: libpq/auth.c:2245 +#: libpq/auth.c:2248 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned %d entry." msgid_plural "LDAP search for filter \"%s\" on server \"%s\" returned %d entries." msgstr[0] "La búsqueda LDAP para el filtro «%s» en el servidor «%s» retornó %d elemento." msgstr[1] "La búsqueda LDAP para el filtro «%s» en el servidor «%s» retornó %d elementos." -#: libpq/auth.c:2263 +#: libpq/auth.c:2266 #, c-format msgid "could not get dn for the first entry matching \"%s\" on server \"%s\": %s" msgstr "no se pudo obtener el dn para la primera entrada que coincide con «%s» en el servidor «%s»: %s" -#: libpq/auth.c:2283 +#: libpq/auth.c:2286 #, c-format msgid "could not unbind after searching for user \"%s\" on server \"%s\": %s" msgstr "no se pudo desconectar después de buscar al usuario «%s» en el servidor «%s»: %s" -#: libpq/auth.c:2313 +#: libpq/auth.c:2316 #, c-format msgid "LDAP login failed for user \"%s\" on server \"%s\": %s" msgstr "falló el inicio de sesión LDAP para el usuario «%s» en el servidor «%s»: %s" -#: libpq/auth.c:2341 +#: libpq/auth.c:2344 #, c-format msgid "certificate authentication failed for user \"%s\": client certificate contains no user name" msgstr "la autentificación con certificado falló para el usuario «%s»: el certificado de cliente no contiene un nombre de usuario" -#: libpq/auth.c:2471 +#: libpq/auth.c:2474 #, c-format msgid "RADIUS server not specified" msgstr "servidor RADIUS no especificado" -#: libpq/auth.c:2478 +#: libpq/auth.c:2481 #, c-format msgid "RADIUS secret not specified" msgstr "secreto RADIUS no especificado" -#: libpq/auth.c:2494 libpq/hba.c:1632 +#: libpq/auth.c:2497 libpq/hba.c:1632 #, c-format msgid "could not translate RADIUS server name \"%s\" to address: %s" msgstr "no se pudo traducir el nombre de servidor RADIUS «%s» a dirección: %s" -#: libpq/auth.c:2522 +#: libpq/auth.c:2518 #, c-format msgid "RADIUS authentication does not support passwords longer than %d characters" msgstr "la autentificación RADIUS no soporta contraseñas más largas de %d caracteres" -#: libpq/auth.c:2534 +#: libpq/auth.c:2530 #, c-format msgid "could not generate random encryption vector" msgstr "no se pudo generar un vector aleatorio de encriptación" -#: libpq/auth.c:2572 +#: libpq/auth.c:2568 #, c-format msgid "could not perform MD5 encryption of password" msgstr "no se pudo efectuar cifrado MD5 de la contraseña" -#: libpq/auth.c:2597 +#: libpq/auth.c:2593 #, c-format msgid "could not create RADIUS socket: %m" msgstr "no se pudo crear el socket RADIUS: %m" -#: libpq/auth.c:2618 +#: libpq/auth.c:2614 #, c-format msgid "could not bind local RADIUS socket: %m" msgstr "no se pudo enlazar el socket RADIUS local: %m" -#: libpq/auth.c:2628 +#: libpq/auth.c:2624 #, c-format msgid "could not send RADIUS packet: %m" msgstr "no se pudo enviar el paquete RADIUS: %m" -#: libpq/auth.c:2661 libpq/auth.c:2686 +#: libpq/auth.c:2657 libpq/auth.c:2682 #, c-format msgid "timeout waiting for RADIUS response" msgstr "se agotó el tiempo de espera de la respuesta RADIUS" -#: libpq/auth.c:2679 +#: libpq/auth.c:2675 #, c-format msgid "could not check status on RADIUS socket: %m" msgstr "no se pudo verificar el estado en el socket %m" -#: libpq/auth.c:2708 +#: libpq/auth.c:2704 #, c-format msgid "could not read RADIUS response: %m" msgstr "no se pudo leer la respuesta RADIUS: %m" -#: libpq/auth.c:2720 libpq/auth.c:2724 +#: libpq/auth.c:2716 libpq/auth.c:2720 #, c-format msgid "RADIUS response was sent from incorrect port: %d" msgstr "la respuesta RADIUS fue enviada desde el port incorrecto: %d" -#: libpq/auth.c:2733 +#: libpq/auth.c:2729 #, c-format msgid "RADIUS response too short: %d" msgstr "la respuesta RADIUS es demasiado corta: %d" -#: libpq/auth.c:2740 +#: libpq/auth.c:2736 #, c-format msgid "RADIUS response has corrupt length: %d (actual length %d)" msgstr "la respuesta RADIUS tiene largo corrupto: %d (largo real %d)" -#: libpq/auth.c:2748 +#: libpq/auth.c:2744 #, c-format msgid "RADIUS response is to a different request: %d (should be %d)" msgstr "la respuesta RADIUS es a una petición diferente: %d (debería ser %d)" -#: libpq/auth.c:2773 +#: libpq/auth.c:2769 #, c-format msgid "could not perform MD5 encryption of received packet" msgstr "no se pudo realizar cifrado MD5 del paquete recibido" -#: libpq/auth.c:2782 +#: libpq/auth.c:2778 #, c-format msgid "RADIUS response has incorrect MD5 signature" msgstr "la respuesta RADIUS tiene firma MD5 incorrecta" -#: libpq/auth.c:2799 +#: libpq/auth.c:2795 #, c-format msgid "RADIUS response has invalid code (%d) for user \"%s\"" msgstr "la respuesta RADIUS tiene código no válido (%d) para el usuario «%s»" @@ -10963,7 +10783,7 @@ msgid "invalid large-object descriptor: %d" msgstr "el descriptor de objeto grande no es válido: %d" #: libpq/be-fsstubs.c:178 libpq/be-fsstubs.c:216 libpq/be-fsstubs.c:600 -#: libpq/be-fsstubs.c:788 +#: libpq/be-fsstubs.c:788 libpq/be-fsstubs.c:908 #, c-format msgid "permission denied for large object %u" msgstr "permiso denegado al objeto grande %u" @@ -11078,87 +10898,87 @@ msgstr "no se pudo cargar el archivo de la llave privada «%s»: %s" msgid "check of private key failed: %s" msgstr "falló la revisión de la llave privada: %s" -#: libpq/be-secure-openssl.c:292 +#: libpq/be-secure-openssl.c:300 #, c-format msgid "could not load root certificate file \"%s\": %s" msgstr "no se pudo cargar el archivo del certificado raíz «%s»: %s" -#: libpq/be-secure-openssl.c:316 +#: libpq/be-secure-openssl.c:324 #, c-format msgid "SSL certificate revocation list file \"%s\" ignored" msgstr "ignorando lista de revocación de certificados SSL «%s»" -#: libpq/be-secure-openssl.c:318 +#: libpq/be-secure-openssl.c:326 #, c-format msgid "SSL library does not support certificate revocation lists." msgstr "La libreria SSL no soporta listas de revocación de certificados." -#: libpq/be-secure-openssl.c:323 +#: libpq/be-secure-openssl.c:331 #, c-format msgid "could not load SSL certificate revocation list file \"%s\": %s" msgstr "no se pudo cargar el archivo de lista de revocación de certificados SSL «%s»: %s" -#: libpq/be-secure-openssl.c:370 +#: libpq/be-secure-openssl.c:378 #, c-format msgid "could not initialize SSL connection: %s" msgstr "no se pudo inicializar la conexión SSL: %s" -#: libpq/be-secure-openssl.c:378 +#: libpq/be-secure-openssl.c:386 #, c-format msgid "could not set SSL socket: %s" msgstr "no se definir un socket SSL: %s" -#: libpq/be-secure-openssl.c:432 +#: libpq/be-secure-openssl.c:440 #, c-format msgid "could not accept SSL connection: %m" msgstr "no se pudo aceptar una conexión SSL: %m" -#: libpq/be-secure-openssl.c:436 libpq/be-secure-openssl.c:447 +#: libpq/be-secure-openssl.c:444 libpq/be-secure-openssl.c:455 #, c-format msgid "could not accept SSL connection: EOF detected" msgstr "no se pudo aceptar una conexión SSL: se detectó EOF" -#: libpq/be-secure-openssl.c:441 +#: libpq/be-secure-openssl.c:449 #, c-format msgid "could not accept SSL connection: %s" msgstr "no se pudo aceptar una conexión SSL: %s" -#: libpq/be-secure-openssl.c:452 libpq/be-secure-openssl.c:593 -#: libpq/be-secure-openssl.c:653 +#: libpq/be-secure-openssl.c:460 libpq/be-secure-openssl.c:603 +#: libpq/be-secure-openssl.c:669 #, c-format msgid "unrecognized SSL error code: %d" msgstr "código de error SSL no reconocido: %d" -#: libpq/be-secure-openssl.c:496 +#: libpq/be-secure-openssl.c:504 #, c-format msgid "SSL certificate's common name contains embedded null" msgstr "el «common name» del certificado SSL contiene un carácter null" -#: libpq/be-secure-openssl.c:507 +#: libpq/be-secure-openssl.c:515 #, c-format msgid "SSL connection from \"%s\"" msgstr "conexión SSL desde «%s»" -#: libpq/be-secure-openssl.c:584 libpq/be-secure-openssl.c:644 +#: libpq/be-secure-openssl.c:592 libpq/be-secure-openssl.c:654 #, c-format msgid "SSL error: %s" msgstr "error de SSL: %s" -#: libpq/be-secure-openssl.c:1055 +#: libpq/be-secure-openssl.c:1071 #, c-format msgid "ECDH: unrecognized curve name: %s" msgstr "ECDH: nombre de curva no reconocida: %s" -#: libpq/be-secure-openssl.c:1060 +#: libpq/be-secure-openssl.c:1076 #, c-format msgid "ECDH: could not create key" msgstr "ECDH: no se pudo crear la llave" -#: libpq/be-secure-openssl.c:1084 +#: libpq/be-secure-openssl.c:1100 msgid "no SSL error reported" msgstr "código de error SSL no reportado" -#: libpq/be-secure-openssl.c:1088 +#: libpq/be-secure-openssl.c:1104 #, c-format msgid "SSL error code %lu" msgstr "código de error SSL %lu" @@ -11178,17 +10998,17 @@ msgstr "No existe el rol «%s»." msgid "User \"%s\" has no password assigned." msgstr "El usuario «%s» no tiene una contraseña asignada." -#: libpq/crypt.c:79 +#: libpq/crypt.c:88 libpq/crypt.c:103 #, c-format msgid "User \"%s\" has an empty password." msgstr "El usuario «%s» tiene contraseña vacía." -#: libpq/crypt.c:159 +#: libpq/crypt.c:184 #, c-format msgid "User \"%s\" has an expired password." msgstr "El usuario «%s» tiene contraseña expirada." -#: libpq/crypt.c:167 +#: libpq/crypt.c:192 #, c-format msgid "Password does not match for user \"%s\"." msgstr "La contraseña no coincide para el usuario «%s»." @@ -11505,137 +11325,137 @@ msgstr "no hay coincidencia en el mapa «%s» para el usuario «%s» autentifica msgid "could not open usermap file \"%s\": %m" msgstr "no se pudo abrir el archivo de mapa de usuarios «%s»: %m" -#: libpq/pqcomm.c:202 +#: libpq/pqcomm.c:221 #, c-format msgid "could not set socket to nonblocking mode: %m" msgstr "no se pudo establecer el socket en modo no bloqueante: %m" -#: libpq/pqcomm.c:354 +#: libpq/pqcomm.c:373 #, c-format msgid "Unix-domain socket path \"%s\" is too long (maximum %d bytes)" msgstr "la ruta al socket de dominio Unix «%s» es demasiado larga (máximo %d bytes)" -#: libpq/pqcomm.c:375 +#: libpq/pqcomm.c:394 #, c-format msgid "could not translate host name \"%s\", service \"%s\" to address: %s" msgstr "no se pudo traducir el nombre de host «%s», servicio «%s» a dirección: %s" -#: libpq/pqcomm.c:379 +#: libpq/pqcomm.c:398 #, c-format msgid "could not translate service \"%s\" to address: %s" msgstr "no se pudo traducir el servicio «%s» a dirección: %s" -#: libpq/pqcomm.c:406 +#: libpq/pqcomm.c:425 #, c-format msgid "could not bind to all requested addresses: MAXLISTEN (%d) exceeded" msgstr "no se pudo enlazar a todas las direcciones pedidas: MAXLISTEN (%d) fue excedido" -#: libpq/pqcomm.c:415 +#: libpq/pqcomm.c:434 msgid "IPv4" msgstr "IPv4" -#: libpq/pqcomm.c:419 +#: libpq/pqcomm.c:438 msgid "IPv6" msgstr "IPv6" -#: libpq/pqcomm.c:424 +#: libpq/pqcomm.c:443 msgid "Unix" msgstr "Unix" -#: libpq/pqcomm.c:429 +#: libpq/pqcomm.c:448 #, c-format msgid "unrecognized address family %d" msgstr "la familia de direcciones %d no es reconocida" #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:440 +#: libpq/pqcomm.c:459 #, c-format msgid "could not create %s socket: %m" msgstr "no se pudo crear el socket %s: %m" -#: libpq/pqcomm.c:465 +#: libpq/pqcomm.c:484 #, c-format msgid "setsockopt(SO_REUSEADDR) failed: %m" msgstr "setsockopt(SO_REUSEADDR) falló: %m" -#: libpq/pqcomm.c:480 +#: libpq/pqcomm.c:499 #, c-format msgid "setsockopt(IPV6_V6ONLY) failed: %m" msgstr "setsockopt(IPV6_V6ONLY) falló: %m" #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:499 +#: libpq/pqcomm.c:518 #, c-format msgid "could not bind %s socket: %m" msgstr "no se pudo enlazar al socket %s: %m" -#: libpq/pqcomm.c:502 +#: libpq/pqcomm.c:521 #, c-format msgid "Is another postmaster already running on port %d? If not, remove socket file \"%s\" and retry." msgstr "¿Hay otro postmaster corriendo en el puerto %d? Si no, elimine el socket «%s» y reintente." -#: libpq/pqcomm.c:505 +#: libpq/pqcomm.c:524 #, c-format msgid "Is another postmaster already running on port %d? If not, wait a few seconds and retry." msgstr "¿Hay otro postmaster corriendo en el puerto %d? Si no, aguarde unos segundos y reintente." #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:538 +#: libpq/pqcomm.c:557 #, c-format msgid "could not listen on %s socket: %m" msgstr "no se pudo escuchar en el socket %s: %m" -#: libpq/pqcomm.c:623 +#: libpq/pqcomm.c:642 #, c-format msgid "group \"%s\" does not exist" msgstr "no existe el grupo «%s»" -#: libpq/pqcomm.c:633 +#: libpq/pqcomm.c:652 #, c-format msgid "could not set group of file \"%s\": %m" msgstr "no se pudo definir el grupo del archivo «%s»: %m" -#: libpq/pqcomm.c:644 +#: libpq/pqcomm.c:663 #, c-format msgid "could not set permissions of file \"%s\": %m" msgstr "no se pudo definir los permisos del archivo «%s»: %m" -#: libpq/pqcomm.c:674 +#: libpq/pqcomm.c:693 #, c-format msgid "could not accept new connection: %m" msgstr "no se pudo aceptar una nueva conexión: %m" -#: libpq/pqcomm.c:885 +#: libpq/pqcomm.c:904 #, c-format msgid "there is no client connection" msgstr "no hay conexión de cliente" -#: libpq/pqcomm.c:936 libpq/pqcomm.c:1032 +#: libpq/pqcomm.c:955 libpq/pqcomm.c:1051 #, c-format msgid "could not receive data from client: %m" msgstr "no se pudo recibir datos del cliente: %m" -#: libpq/pqcomm.c:1177 tcop/postgres.c:3917 +#: libpq/pqcomm.c:1196 tcop/postgres.c:3915 #, c-format msgid "terminating connection because protocol synchronization was lost" msgstr "terminando la conexión por pérdida de sincronía del protocolo" -#: libpq/pqcomm.c:1243 +#: libpq/pqcomm.c:1262 #, c-format msgid "unexpected EOF within message length word" msgstr "EOF inesperado dentro de la palabra de tamaño del mensaje" -#: libpq/pqcomm.c:1254 +#: libpq/pqcomm.c:1273 #, c-format msgid "invalid message length" msgstr "el largo de mensaje no es válido" -#: libpq/pqcomm.c:1276 libpq/pqcomm.c:1289 +#: libpq/pqcomm.c:1295 libpq/pqcomm.c:1308 #, c-format msgid "incomplete message from client" msgstr "mensaje incompleto del cliente" -#: libpq/pqcomm.c:1422 +#: libpq/pqcomm.c:1441 #, c-format msgid "could not send data to client: %m" msgstr "no se pudo enviar datos al cliente: %m" @@ -12986,7 +12806,7 @@ msgstr "no hay parámetro $%d" msgid "NULLIF requires = operator to yield boolean" msgstr "NULLIF requiere que el operador = retorne boolean" -#: parser/parse_expr.c:1501 gram.y:9887 +#: parser/parse_expr.c:1501 gram.y:9896 #, c-format msgid "number of columns does not match number of values" msgstr "el número de columnas no coincide con el número de valores" @@ -13289,8 +13109,8 @@ msgstr "los subíndices de arrays deben tener tipo entero" msgid "array assignment requires type %s but expression is of type %s" msgstr "la asignación de array debe tener tipo %s pero la expresión es de tipo %s" -#: parser/parse_oper.c:125 parser/parse_oper.c:722 utils/adt/regproc.c:583 -#: utils/adt/regproc.c:603 utils/adt/regproc.c:787 +#: parser/parse_oper.c:125 parser/parse_oper.c:722 utils/adt/regproc.c:584 +#: utils/adt/regproc.c:604 utils/adt/regproc.c:788 #, c-format msgid "operator does not exist: %s" msgstr "el operador no existe: %s" @@ -13544,224 +13364,224 @@ msgstr "los modificadores de tipo deben ser constantes simples o identificadores msgid "invalid type name \"%s\"" msgstr "el nombre de tipo «%s» no es válido" -#: parser/parse_utilcmd.c:384 +#: parser/parse_utilcmd.c:385 #, c-format msgid "array of serial is not implemented" msgstr "array de serial no está implementado" -#: parser/parse_utilcmd.c:432 +#: parser/parse_utilcmd.c:433 #, c-format msgid "%s will create implicit sequence \"%s\" for serial column \"%s.%s\"" msgstr "%s creará una secuencia implícita «%s» para la columna serial «%s.%s»" -#: parser/parse_utilcmd.c:526 parser/parse_utilcmd.c:538 +#: parser/parse_utilcmd.c:527 parser/parse_utilcmd.c:539 #, c-format msgid "conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"" msgstr "las declaraciones NULL/NOT NULL no son coincidentes para la columna «%s» de la tabla «%s»" -#: parser/parse_utilcmd.c:550 +#: parser/parse_utilcmd.c:551 #, c-format msgid "multiple default values specified for column \"%s\" of table \"%s\"" msgstr "múltiples valores default especificados para columna «%s» de tabla «%s»" -#: parser/parse_utilcmd.c:567 parser/parse_utilcmd.c:658 +#: parser/parse_utilcmd.c:568 parser/parse_utilcmd.c:659 #, c-format msgid "primary key constraints are not supported on foreign tables" msgstr "las restricciones de llave primaria no están soportadas en tablas foráneas" -#: parser/parse_utilcmd.c:576 parser/parse_utilcmd.c:668 +#: parser/parse_utilcmd.c:577 parser/parse_utilcmd.c:669 #, c-format msgid "unique constraints are not supported on foreign tables" msgstr "las restricciones unique no están soportadas en tablas foráneas" -#: parser/parse_utilcmd.c:593 parser/parse_utilcmd.c:692 +#: parser/parse_utilcmd.c:594 parser/parse_utilcmd.c:693 #, c-format msgid "foreign key constraints are not supported on foreign tables" msgstr "las restricciones de llave foránea no están soportadas en tablas foráneas" -#: parser/parse_utilcmd.c:678 +#: parser/parse_utilcmd.c:679 #, c-format msgid "exclusion constraints are not supported on foreign tables" msgstr "las restricciones exclusion no están soportadas en tablas foráneas" -#: parser/parse_utilcmd.c:742 +#: parser/parse_utilcmd.c:743 #, c-format msgid "LIKE is not supported for creating foreign tables" msgstr "LIKE no está soportado para la creación de tablas foráneas" -#: parser/parse_utilcmd.c:1275 parser/parse_utilcmd.c:1351 +#: parser/parse_utilcmd.c:1276 parser/parse_utilcmd.c:1352 #, c-format msgid "Index \"%s\" contains a whole-row table reference." msgstr "El índice «%s» contiene una referencia a la fila completa (whole-row)." -#: parser/parse_utilcmd.c:1621 +#: parser/parse_utilcmd.c:1622 #, c-format msgid "cannot use an existing index in CREATE TABLE" msgstr "no se puede usar un índice existente en CREATE TABLE" -#: parser/parse_utilcmd.c:1641 +#: parser/parse_utilcmd.c:1642 #, c-format msgid "index \"%s\" is already associated with a constraint" msgstr "el índice «%s» ya está asociado a una restricción" -#: parser/parse_utilcmd.c:1649 +#: parser/parse_utilcmd.c:1650 #, c-format msgid "index \"%s\" does not belong to table \"%s\"" msgstr "el índice «%s» no pertenece a la tabla «%s»" -#: parser/parse_utilcmd.c:1656 +#: parser/parse_utilcmd.c:1657 #, c-format msgid "index \"%s\" is not valid" msgstr "el índice «%s» no es válido" -#: parser/parse_utilcmd.c:1662 +#: parser/parse_utilcmd.c:1663 #, c-format msgid "\"%s\" is not a unique index" msgstr "«%s» no es un índice único" -#: parser/parse_utilcmd.c:1663 parser/parse_utilcmd.c:1670 -#: parser/parse_utilcmd.c:1677 parser/parse_utilcmd.c:1747 +#: parser/parse_utilcmd.c:1664 parser/parse_utilcmd.c:1671 +#: parser/parse_utilcmd.c:1678 parser/parse_utilcmd.c:1748 #, c-format msgid "Cannot create a primary key or unique constraint using such an index." msgstr "No se puede crear una restricción de llave primaria o única usando un índice así." -#: parser/parse_utilcmd.c:1669 +#: parser/parse_utilcmd.c:1670 #, c-format msgid "index \"%s\" contains expressions" msgstr "el índice «%s» contiene expresiones" -#: parser/parse_utilcmd.c:1676 +#: parser/parse_utilcmd.c:1677 #, c-format msgid "\"%s\" is a partial index" msgstr "«%s» es un índice parcial" -#: parser/parse_utilcmd.c:1688 +#: parser/parse_utilcmd.c:1689 #, c-format msgid "\"%s\" is a deferrable index" msgstr "«%s» no es un índice postergable (deferrable)" -#: parser/parse_utilcmd.c:1689 +#: parser/parse_utilcmd.c:1690 #, c-format msgid "Cannot create a non-deferrable constraint using a deferrable index." msgstr "No se puede crear una restricción no postergable usando un índice postergable." -#: parser/parse_utilcmd.c:1746 +#: parser/parse_utilcmd.c:1747 #, c-format msgid "index \"%s\" does not have default sorting behavior" msgstr "el índice «%s» no tiene el comportamiento de ordenamiento por omisión" -#: parser/parse_utilcmd.c:1893 +#: parser/parse_utilcmd.c:1894 #, c-format msgid "column \"%s\" appears twice in primary key constraint" msgstr "la columna «%s» aparece dos veces en llave primaria" -#: parser/parse_utilcmd.c:1899 +#: parser/parse_utilcmd.c:1900 #, c-format msgid "column \"%s\" appears twice in unique constraint" msgstr "la columna «%s» aparece dos veces en restricción unique" -#: parser/parse_utilcmd.c:2103 +#: parser/parse_utilcmd.c:2104 #, c-format msgid "index expression cannot return a set" msgstr "las expresiones de índice no pueden retornar conjuntos" -#: parser/parse_utilcmd.c:2114 +#: parser/parse_utilcmd.c:2115 #, c-format msgid "index expressions and predicates can refer only to the table being indexed" msgstr "las expresiones y predicados de índice sólo pueden referirse a la tabla en indexación" -#: parser/parse_utilcmd.c:2160 +#: parser/parse_utilcmd.c:2161 #, c-format msgid "rules on materialized views are not supported" msgstr "las reglas en vistas materializadas no están soportadas" -#: parser/parse_utilcmd.c:2221 +#: parser/parse_utilcmd.c:2222 #, c-format msgid "rule WHERE condition cannot contain references to other relations" msgstr "la condición WHERE de la regla no puede contener referencias a otras relaciones" -#: parser/parse_utilcmd.c:2293 +#: parser/parse_utilcmd.c:2294 #, c-format msgid "rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE actions" msgstr "las reglas con condiciones WHERE sólo pueden tener acciones SELECT, INSERT, UPDATE o DELETE" -#: parser/parse_utilcmd.c:2311 parser/parse_utilcmd.c:2410 +#: parser/parse_utilcmd.c:2312 parser/parse_utilcmd.c:2411 #: rewrite/rewriteHandler.c:485 rewrite/rewriteManip.c:1015 #, c-format msgid "conditional UNION/INTERSECT/EXCEPT statements are not implemented" msgstr "las sentencias UNION/INTERSECT/EXCEPT condicionales no están implementadas" -#: parser/parse_utilcmd.c:2329 +#: parser/parse_utilcmd.c:2330 #, c-format msgid "ON SELECT rule cannot use OLD" msgstr "una regla ON SELECT no puede usar OLD" -#: parser/parse_utilcmd.c:2333 +#: parser/parse_utilcmd.c:2334 #, c-format msgid "ON SELECT rule cannot use NEW" msgstr "una regla ON SELECT no puede usar NEW" -#: parser/parse_utilcmd.c:2342 +#: parser/parse_utilcmd.c:2343 #, c-format msgid "ON INSERT rule cannot use OLD" msgstr "una regla ON INSERT no puede usar OLD" -#: parser/parse_utilcmd.c:2348 +#: parser/parse_utilcmd.c:2349 #, c-format msgid "ON DELETE rule cannot use NEW" msgstr "una regla ON DELETE no puede usar NEW" -#: parser/parse_utilcmd.c:2376 +#: parser/parse_utilcmd.c:2377 #, c-format msgid "cannot refer to OLD within WITH query" msgstr "no se puede hacer referencia a OLD dentro de una consulta WITH" -#: parser/parse_utilcmd.c:2383 +#: parser/parse_utilcmd.c:2384 #, c-format msgid "cannot refer to NEW within WITH query" msgstr "no se puede hacer referencia a NEW dentro de una consulta WITH" -#: parser/parse_utilcmd.c:2586 +#: parser/parse_utilcmd.c:2587 #, c-format msgid "transform expression must not return a set" msgstr "la expresión de transformación no puede retornar conjuntos" -#: parser/parse_utilcmd.c:2700 +#: parser/parse_utilcmd.c:2701 #, c-format msgid "misplaced DEFERRABLE clause" msgstr "cláusula DEFERRABLE mal puesta" -#: parser/parse_utilcmd.c:2705 parser/parse_utilcmd.c:2720 +#: parser/parse_utilcmd.c:2706 parser/parse_utilcmd.c:2721 #, c-format msgid "multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed" msgstr "no se permiten múltiples cláusulas DEFERRABLE/NOT DEFERRABLE" -#: parser/parse_utilcmd.c:2715 +#: parser/parse_utilcmd.c:2716 #, c-format msgid "misplaced NOT DEFERRABLE clause" msgstr "la cláusula NOT DEFERRABLE está mal puesta" -#: parser/parse_utilcmd.c:2728 parser/parse_utilcmd.c:2754 gram.y:4902 +#: parser/parse_utilcmd.c:2729 parser/parse_utilcmd.c:2755 gram.y:4911 #, c-format msgid "constraint declared INITIALLY DEFERRED must be DEFERRABLE" msgstr "una restricción declarada INITIALLY DEFERRED debe ser DEFERRABLE" -#: parser/parse_utilcmd.c:2736 +#: parser/parse_utilcmd.c:2737 #, c-format msgid "misplaced INITIALLY DEFERRED clause" msgstr "la cláusula INITIALLY DEFERRED está mal puesta" -#: parser/parse_utilcmd.c:2741 parser/parse_utilcmd.c:2767 +#: parser/parse_utilcmd.c:2742 parser/parse_utilcmd.c:2768 #, c-format msgid "multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed" msgstr "no se permiten múltiples cláusulas INITIALLY IMMEDIATE/DEFERRED" -#: parser/parse_utilcmd.c:2762 +#: parser/parse_utilcmd.c:2763 #, c-format msgid "misplaced INITIALLY IMMEDIATE clause" msgstr "la cláusula INITIALLY IMMEDIATE está mal puesta" -#: parser/parse_utilcmd.c:2953 +#: parser/parse_utilcmd.c:2954 #, c-format msgid "CREATE specifies a schema (%s) different from the one being created (%s)" msgstr "CREATE especifica un esquema (%s) diferente del que se está creando (%s)" @@ -14120,7 +13940,7 @@ msgstr "La orden fallida era: «%s»" msgid "archive command was terminated by exception 0x%X" msgstr "la orden de archivado fue terminada por una excepción 0x%X" -#: postmaster/pgarch.c:598 postmaster/postmaster.c:3505 +#: postmaster/pgarch.c:598 postmaster/postmaster.c:3514 #, c-format msgid "See C include file \"ntstatus.h\" for a description of the hexadecimal value." msgstr "Vea el archivo «ntstatus.h» para una descripción del valor hexadecimal." @@ -14150,293 +13970,293 @@ msgstr "el archivo de registro «%s» ha sido archivado" msgid "could not open archive status directory \"%s\": %m" msgstr "no se pudo abrir el directorio de estado de archivado «%s»: %m" -#: postmaster/pgstat.c:355 +#: postmaster/pgstat.c:358 #, c-format msgid "could not resolve \"localhost\": %s" msgstr "no se pudo resolver «localhost»: %s" -#: postmaster/pgstat.c:378 +#: postmaster/pgstat.c:381 #, c-format msgid "trying another address for the statistics collector" msgstr "intentando otra dirección para el recolector de estadísticas" -#: postmaster/pgstat.c:387 +#: postmaster/pgstat.c:390 #, c-format msgid "could not create socket for statistics collector: %m" msgstr "no se pudo crear el socket para el recolector de estadísticas: %m" -#: postmaster/pgstat.c:399 +#: postmaster/pgstat.c:402 #, c-format msgid "could not bind socket for statistics collector: %m" msgstr "no se pudo enlazar (bind) el socket para el recolector de estadísticas: %m" -#: postmaster/pgstat.c:410 +#: postmaster/pgstat.c:413 #, c-format msgid "could not get address of socket for statistics collector: %m" msgstr "no se pudo obtener la dirección del socket de estadísticas: %m" -#: postmaster/pgstat.c:426 +#: postmaster/pgstat.c:429 #, c-format msgid "could not connect socket for statistics collector: %m" msgstr "no se pudo conectar el socket para el recolector de estadísticas: %m" -#: postmaster/pgstat.c:447 +#: postmaster/pgstat.c:450 #, c-format msgid "could not send test message on socket for statistics collector: %m" msgstr "no se pudo enviar el mensaje de prueba al recolector de estadísticas: %m" -#: postmaster/pgstat.c:473 +#: postmaster/pgstat.c:476 #, c-format msgid "select() failed in statistics collector: %m" msgstr "select() falló en el recolector de estadísticas: %m" -#: postmaster/pgstat.c:488 +#: postmaster/pgstat.c:491 #, c-format msgid "test message did not get through on socket for statistics collector" msgstr "el mensaje de prueba al recolector de estadísticas no ha sido recibido en el socket" -#: postmaster/pgstat.c:503 +#: postmaster/pgstat.c:506 #, c-format msgid "could not receive test message on socket for statistics collector: %m" msgstr "no se pudo recibir el mensaje de prueba en el socket del recolector de estadísticas: %m" -#: postmaster/pgstat.c:513 +#: postmaster/pgstat.c:516 #, c-format msgid "incorrect test message transmission on socket for statistics collector" msgstr "transmisión del mensaje de prueba incorrecta en el socket del recolector de estadísticas" -#: postmaster/pgstat.c:536 +#: postmaster/pgstat.c:539 #, c-format msgid "could not set statistics collector socket to nonblocking mode: %m" msgstr "no se pudo poner el socket de estadísticas en modo no bloqueante: %m" -#: postmaster/pgstat.c:546 +#: postmaster/pgstat.c:578 #, c-format msgid "disabling statistics collector for lack of working socket" msgstr "desactivando el recolector de estadísticas por falla del socket" -#: postmaster/pgstat.c:693 +#: postmaster/pgstat.c:725 #, c-format msgid "could not fork statistics collector: %m" msgstr "no se pudo crear el proceso para el recolector de estadísticas: %m" -#: postmaster/pgstat.c:1261 +#: postmaster/pgstat.c:1293 #, c-format msgid "unrecognized reset target: \"%s\"" msgstr "destino de reset no reconocido: «%s»" -#: postmaster/pgstat.c:1262 +#: postmaster/pgstat.c:1294 #, c-format msgid "Target must be \"archiver\" or \"bgwriter\"." msgstr "El destino debe ser «archiver» o «bgwriter»." -#: postmaster/pgstat.c:3587 +#: postmaster/pgstat.c:3619 #, c-format msgid "could not read statistics message: %m" msgstr "no se pudo leer un mensaje de estadísticas: %m" -#: postmaster/pgstat.c:3918 postmaster/pgstat.c:4075 +#: postmaster/pgstat.c:3950 postmaster/pgstat.c:4107 #, c-format msgid "could not open temporary statistics file \"%s\": %m" msgstr "no se pudo abrir el archivo temporal de estadísticas «%s»: %m" -#: postmaster/pgstat.c:3985 postmaster/pgstat.c:4120 +#: postmaster/pgstat.c:4017 postmaster/pgstat.c:4152 #, c-format msgid "could not write temporary statistics file \"%s\": %m" msgstr "no se pudo escribir el archivo temporal de estadísticas «%s»: %m" -#: postmaster/pgstat.c:3994 postmaster/pgstat.c:4129 +#: postmaster/pgstat.c:4026 postmaster/pgstat.c:4161 #, c-format msgid "could not close temporary statistics file \"%s\": %m" msgstr "no se pudo cerrar el archivo temporal de estadísticas «%s»: %m" -#: postmaster/pgstat.c:4002 postmaster/pgstat.c:4137 +#: postmaster/pgstat.c:4034 postmaster/pgstat.c:4169 #, c-format msgid "could not rename temporary statistics file \"%s\" to \"%s\": %m" msgstr "no se pudo cambiar el nombre al archivo temporal de estadísticas de «%s» a «%s»: %m" -#: postmaster/pgstat.c:4226 postmaster/pgstat.c:4411 postmaster/pgstat.c:4564 +#: postmaster/pgstat.c:4258 postmaster/pgstat.c:4464 postmaster/pgstat.c:4617 #, c-format msgid "could not open statistics file \"%s\": %m" msgstr "no se pudo abrir el archivo de estadísticas «%s»: %m" -#: postmaster/pgstat.c:4238 postmaster/pgstat.c:4248 postmaster/pgstat.c:4258 -#: postmaster/pgstat.c:4279 postmaster/pgstat.c:4294 postmaster/pgstat.c:4348 -#: postmaster/pgstat.c:4423 postmaster/pgstat.c:4443 postmaster/pgstat.c:4461 -#: postmaster/pgstat.c:4477 postmaster/pgstat.c:4495 postmaster/pgstat.c:4511 -#: postmaster/pgstat.c:4576 postmaster/pgstat.c:4588 postmaster/pgstat.c:4600 -#: postmaster/pgstat.c:4625 postmaster/pgstat.c:4647 +#: postmaster/pgstat.c:4270 postmaster/pgstat.c:4280 postmaster/pgstat.c:4301 +#: postmaster/pgstat.c:4323 postmaster/pgstat.c:4338 postmaster/pgstat.c:4401 +#: postmaster/pgstat.c:4476 postmaster/pgstat.c:4496 postmaster/pgstat.c:4514 +#: postmaster/pgstat.c:4530 postmaster/pgstat.c:4548 postmaster/pgstat.c:4564 +#: postmaster/pgstat.c:4629 postmaster/pgstat.c:4641 postmaster/pgstat.c:4653 +#: postmaster/pgstat.c:4678 postmaster/pgstat.c:4700 #, c-format msgid "corrupted statistics file \"%s\"" msgstr "el archivo de estadísticas «%s» está corrupto" -#: postmaster/pgstat.c:4776 +#: postmaster/pgstat.c:4829 #, c-format msgid "using stale statistics instead of current ones because stats collector is not responding" msgstr "usando estadísticas añejas en vez de actualizadas porque el recolector de estadísticas no está respondiendo" -#: postmaster/pgstat.c:5103 +#: postmaster/pgstat.c:5156 #, c-format msgid "database hash table corrupted during cleanup --- abort" msgstr "el hash de bases de datos se corrompió durante la finalización; abortando" -#: postmaster/postmaster.c:698 +#: postmaster/postmaster.c:702 #, c-format msgid "%s: invalid argument for option -f: \"%s\"\n" msgstr "%s: argumento no válido para la opción -f: «%s»\n" -#: postmaster/postmaster.c:784 +#: postmaster/postmaster.c:788 #, c-format msgid "%s: invalid argument for option -t: \"%s\"\n" msgstr "%s: argumento no válido para la opción -t: «%s»\n" -#: postmaster/postmaster.c:835 +#: postmaster/postmaster.c:839 #, c-format msgid "%s: invalid argument: \"%s\"\n" msgstr "%s: argumento no válido: «%s»\n" -#: postmaster/postmaster.c:874 +#: postmaster/postmaster.c:878 #, c-format msgid "%s: superuser_reserved_connections must be less than max_connections\n" msgstr "%s: superuser_reserved_connections debe ser menor que max_connections\n" -#: postmaster/postmaster.c:879 +#: postmaster/postmaster.c:883 #, c-format msgid "%s: max_wal_senders must be less than max_connections\n" msgstr "%s: max_wal_senders debe ser menor que max_connections\n" -#: postmaster/postmaster.c:884 +#: postmaster/postmaster.c:888 #, c-format msgid "WAL archival cannot be enabled when wal_level is \"minimal\"" msgstr "el archivador de WAL no puede activarse cuando wal_level es «minimal»" -#: postmaster/postmaster.c:887 +#: postmaster/postmaster.c:891 #, c-format msgid "WAL streaming (max_wal_senders > 0) requires wal_level \"replica\" or \"logical\"" msgstr "el flujo de WAL (max_wal_senders > 0) requiere wal_level «replica» o «logical»" -#: postmaster/postmaster.c:895 +#: postmaster/postmaster.c:899 #, c-format msgid "%s: invalid datetoken tables, please fix\n" msgstr "%s: las tablas de palabras clave de fecha no son válidas, arréglelas\n" -#: postmaster/postmaster.c:987 postmaster/postmaster.c:1085 +#: postmaster/postmaster.c:991 postmaster/postmaster.c:1089 #: utils/init/miscinit.c:1429 #, c-format msgid "invalid list syntax in parameter \"%s\"" msgstr "la sintaxis de lista no es válida para el parámetro «%s»" -#: postmaster/postmaster.c:1018 +#: postmaster/postmaster.c:1022 #, c-format msgid "could not create listen socket for \"%s\"" msgstr "no se pudo crear el socket de escucha para «%s»" -#: postmaster/postmaster.c:1024 +#: postmaster/postmaster.c:1028 #, c-format msgid "could not create any TCP/IP sockets" msgstr "no se pudo crear ningún socket TCP/IP" -#: postmaster/postmaster.c:1107 +#: postmaster/postmaster.c:1111 #, c-format msgid "could not create Unix-domain socket in directory \"%s\"" msgstr "no se pudo crear el socket de dominio Unix en el directorio «%s»" -#: postmaster/postmaster.c:1113 +#: postmaster/postmaster.c:1117 #, c-format msgid "could not create any Unix-domain sockets" msgstr "no se pudo crear ningún socket de dominio Unix" -#: postmaster/postmaster.c:1125 +#: postmaster/postmaster.c:1129 #, c-format msgid "no socket created for listening" msgstr "no se creó el socket de atención" -#: postmaster/postmaster.c:1165 +#: postmaster/postmaster.c:1169 #, c-format msgid "could not create I/O completion port for child queue" msgstr "no se pudo crear el port E/S de reporte de completitud para la cola de procesos hijos" -#: postmaster/postmaster.c:1194 +#: postmaster/postmaster.c:1198 #, c-format msgid "%s: could not change permissions of external PID file \"%s\": %s\n" msgstr "%s: no se pudo cambiar los permisos del archivo de PID externo «%s»: %s\n" -#: postmaster/postmaster.c:1198 +#: postmaster/postmaster.c:1202 #, c-format msgid "%s: could not write external PID file \"%s\": %s\n" msgstr "%s: no pudo escribir en el archivo externo de PID «%s»: %s\n" -#: postmaster/postmaster.c:1248 +#: postmaster/postmaster.c:1252 #, c-format msgid "ending log output to stderr" msgstr "terminando la salida de registro a stderr" -#: postmaster/postmaster.c:1249 +#: postmaster/postmaster.c:1253 #, c-format msgid "Future log output will go to log destination \"%s\"." msgstr "La salida futura del registro será enviada al destino de log «%s»." -#: postmaster/postmaster.c:1275 utils/init/postinit.c:213 +#: postmaster/postmaster.c:1279 utils/init/postinit.c:213 #, c-format msgid "could not load pg_hba.conf" msgstr "no se pudo cargar pg_hba.conf" -#: postmaster/postmaster.c:1301 +#: postmaster/postmaster.c:1305 #, c-format msgid "postmaster became multithreaded during startup" msgstr "postmaster se volvió multi-hilo durante la partida" -#: postmaster/postmaster.c:1302 +#: postmaster/postmaster.c:1306 #, c-format msgid "Set the LC_ALL environment variable to a valid locale." msgstr "Defina la variable de ambiente LC_ALL a un valor válido." -#: postmaster/postmaster.c:1399 +#: postmaster/postmaster.c:1403 #, c-format msgid "%s: could not locate matching postgres executable" msgstr "%s: no se pudo localizar el ejecutable postgres correspondiente" -#: postmaster/postmaster.c:1422 utils/misc/tzparser.c:341 +#: postmaster/postmaster.c:1426 utils/misc/tzparser.c:341 #, c-format msgid "This may indicate an incomplete PostgreSQL installation, or that the file \"%s\" has been moved away from its proper location." msgstr "Esto puede indicar una instalación de PostgreSQL incompleta, o que el archivo «%s» ha sido movido de la ubicación adecuada." -#: postmaster/postmaster.c:1450 +#: postmaster/postmaster.c:1454 #, c-format msgid "data directory \"%s\" does not exist" msgstr "no existe el directorio de datos «%s»" -#: postmaster/postmaster.c:1455 +#: postmaster/postmaster.c:1459 #, c-format msgid "could not read permissions of directory \"%s\": %m" msgstr "no se pudo obtener los permisos del directorio «%s»: %m" -#: postmaster/postmaster.c:1463 +#: postmaster/postmaster.c:1467 #, c-format msgid "specified data directory \"%s\" is not a directory" msgstr "el directorio de datos especificado «%s» no es un directorio" -#: postmaster/postmaster.c:1479 +#: postmaster/postmaster.c:1483 #, c-format msgid "data directory \"%s\" has wrong ownership" msgstr "el directorio de datos «%s» tiene dueño equivocado" -#: postmaster/postmaster.c:1481 +#: postmaster/postmaster.c:1485 #, c-format msgid "The server must be started by the user that owns the data directory." msgstr "El servidor debe ser iniciado por el usuario dueño del directorio de datos." -#: postmaster/postmaster.c:1501 +#: postmaster/postmaster.c:1505 #, c-format msgid "data directory \"%s\" has group or world access" msgstr "el directorio de datos «%s» tiene acceso para el grupo u otros" -#: postmaster/postmaster.c:1503 +#: postmaster/postmaster.c:1507 #, c-format msgid "Permissions should be u=rwx (0700)." msgstr "Los permisos deberían ser u=rwx (0700)." -#: postmaster/postmaster.c:1514 +#: postmaster/postmaster.c:1518 #, c-format msgid "" "%s: could not find the database system\n" @@ -14447,365 +14267,375 @@ msgstr "" "Se esperaba encontrar en el directorio PGDATA «%s»,\n" "pero no se pudo abrir el archivo «%s»: %s\n" -#: postmaster/postmaster.c:1691 +#: postmaster/postmaster.c:1695 #, c-format msgid "select() failed in postmaster: %m" msgstr "select() falló en postmaster: %m" -#: postmaster/postmaster.c:1842 +#: postmaster/postmaster.c:1850 #, c-format msgid "performing immediate shutdown because data directory lock file is invalid" msgstr "ejecutando un apagado inmediato porque el archivo de bloqueo del directorio de datos no es válido" -#: postmaster/postmaster.c:1920 postmaster/postmaster.c:1951 +#: postmaster/postmaster.c:1928 postmaster/postmaster.c:1959 #, c-format msgid "incomplete startup packet" msgstr "el paquete de inicio está incompleto" -#: postmaster/postmaster.c:1932 +#: postmaster/postmaster.c:1940 #, c-format msgid "invalid length of startup packet" msgstr "el de paquete de inicio tiene largo incorrecto" -#: postmaster/postmaster.c:1990 +#: postmaster/postmaster.c:1998 #, c-format msgid "failed to send SSL negotiation response: %m" msgstr "no se pudo enviar la respuesta de negociación SSL: %m" -#: postmaster/postmaster.c:2019 +#: postmaster/postmaster.c:2027 #, c-format msgid "unsupported frontend protocol %u.%u: server supports %u.0 to %u.%u" msgstr "el protocolo %u.%u no está soportado: servidor soporta %u.0 hasta %u.%u" -#: postmaster/postmaster.c:2082 utils/misc/guc.c:5660 utils/misc/guc.c:5753 +#: postmaster/postmaster.c:2090 utils/misc/guc.c:5660 utils/misc/guc.c:5753 #: utils/misc/guc.c:7051 utils/misc/guc.c:9805 utils/misc/guc.c:9839 #, c-format msgid "invalid value for parameter \"%s\": \"%s\"" msgstr "valor no válido para el parámetro «%s»: «%s»" -#: postmaster/postmaster.c:2085 +#: postmaster/postmaster.c:2093 #, c-format msgid "Valid values are: \"false\", 0, \"true\", 1, \"database\"." msgstr "Los valores válidos son: «false», 0, «true», 1, «database»." -#: postmaster/postmaster.c:2105 +#: postmaster/postmaster.c:2113 #, c-format msgid "invalid startup packet layout: expected terminator as last byte" msgstr "el paquete de inicio no es válido: se esperaba un terminador en el último byte" -#: postmaster/postmaster.c:2133 +#: postmaster/postmaster.c:2141 #, c-format msgid "no PostgreSQL user name specified in startup packet" msgstr "no se especifica un nombre de usuario en el paquete de inicio" -#: postmaster/postmaster.c:2192 +#: postmaster/postmaster.c:2200 #, c-format msgid "the database system is starting up" msgstr "el sistema de base de datos está iniciándose" -#: postmaster/postmaster.c:2197 +#: postmaster/postmaster.c:2205 #, c-format msgid "the database system is shutting down" msgstr "el sistema de base de datos está apagándose" -#: postmaster/postmaster.c:2202 +#: postmaster/postmaster.c:2210 #, c-format msgid "the database system is in recovery mode" msgstr "el sistema de base de datos está en modo de recuperación" -#: postmaster/postmaster.c:2207 storage/ipc/procarray.c:297 +#: postmaster/postmaster.c:2215 storage/ipc/procarray.c:298 #: storage/ipc/sinvaladt.c:298 storage/lmgr/proc.c:340 #, c-format msgid "sorry, too many clients already" msgstr "lo siento, ya tenemos demasiados clientes" -#: postmaster/postmaster.c:2269 +#: postmaster/postmaster.c:2277 #, c-format msgid "wrong key in cancel request for process %d" msgstr "llave incorrecta en la petición de cancelación para el proceso %d" -#: postmaster/postmaster.c:2277 +#: postmaster/postmaster.c:2285 #, c-format msgid "PID %d in cancel request did not match any process" msgstr "el PID %d en la petición de cancelación no coincidió con ningún proceso" -#: postmaster/postmaster.c:2497 +#: postmaster/postmaster.c:2505 #, c-format msgid "received SIGHUP, reloading configuration files" msgstr "se recibió SIGHUP, releyendo el archivo de configuración" -#: postmaster/postmaster.c:2522 +#: postmaster/postmaster.c:2530 #, c-format msgid "pg_hba.conf not reloaded" msgstr "pg_hba.conf no ha sido recargado" -#: postmaster/postmaster.c:2526 +#: postmaster/postmaster.c:2534 #, c-format msgid "pg_ident.conf not reloaded" msgstr "pg_ident.conf no ha sido recargado" -#: postmaster/postmaster.c:2567 +#: postmaster/postmaster.c:2575 #, c-format msgid "received smart shutdown request" msgstr "se recibió petición de apagado inteligente" -#: postmaster/postmaster.c:2622 +#: postmaster/postmaster.c:2630 #, c-format msgid "received fast shutdown request" msgstr "se recibió petición de apagado rápido" -#: postmaster/postmaster.c:2652 +#: postmaster/postmaster.c:2660 #, c-format msgid "aborting any active transactions" msgstr "abortando transacciones activas" -#: postmaster/postmaster.c:2686 +#: postmaster/postmaster.c:2694 #, c-format msgid "received immediate shutdown request" msgstr "se recibió petición de apagado inmediato" -#: postmaster/postmaster.c:2750 +#: postmaster/postmaster.c:2758 #, c-format msgid "shutdown at recovery target" msgstr "apagándose al alcanzar el destino de recuperación" -#: postmaster/postmaster.c:2766 postmaster/postmaster.c:2789 +#: postmaster/postmaster.c:2774 postmaster/postmaster.c:2797 msgid "startup process" msgstr "proceso de inicio" -#: postmaster/postmaster.c:2769 +#: postmaster/postmaster.c:2777 #, c-format msgid "aborting startup due to startup process failure" msgstr "abortando el inicio debido a una falla en el procesamiento de inicio" -#: postmaster/postmaster.c:2830 +#: postmaster/postmaster.c:2838 #, c-format msgid "database system is ready to accept connections" msgstr "el sistema de bases de datos está listo para aceptar conexiones" -#: postmaster/postmaster.c:2849 +#: postmaster/postmaster.c:2857 msgid "background writer process" msgstr "proceso background writer" -#: postmaster/postmaster.c:2903 +#: postmaster/postmaster.c:2911 msgid "checkpointer process" msgstr "proceso checkpointer" -#: postmaster/postmaster.c:2919 +#: postmaster/postmaster.c:2927 msgid "WAL writer process" msgstr "proceso escritor de WAL" -#: postmaster/postmaster.c:2933 +#: postmaster/postmaster.c:2942 msgid "WAL receiver process" msgstr "proceso receptor de WAL" -#: postmaster/postmaster.c:2948 +#: postmaster/postmaster.c:2957 msgid "autovacuum launcher process" msgstr "proceso lanzador de autovacuum" -#: postmaster/postmaster.c:2963 +#: postmaster/postmaster.c:2972 msgid "archiver process" msgstr "proceso de archivado" -#: postmaster/postmaster.c:2979 +#: postmaster/postmaster.c:2988 msgid "statistics collector process" msgstr "recolector de estadísticas" -#: postmaster/postmaster.c:2993 +#: postmaster/postmaster.c:3002 msgid "system logger process" msgstr "proceso de log" -#: postmaster/postmaster.c:3055 +#: postmaster/postmaster.c:3064 msgid "worker process" msgstr "proceso «background worker»" -#: postmaster/postmaster.c:3138 postmaster/postmaster.c:3158 -#: postmaster/postmaster.c:3165 postmaster/postmaster.c:3183 +#: postmaster/postmaster.c:3147 postmaster/postmaster.c:3167 +#: postmaster/postmaster.c:3174 postmaster/postmaster.c:3192 msgid "server process" msgstr "proceso de servidor" -#: postmaster/postmaster.c:3237 +#: postmaster/postmaster.c:3246 #, c-format msgid "terminating any other active server processes" msgstr "terminando todos los otros procesos de servidor activos" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3493 +#: postmaster/postmaster.c:3502 #, c-format msgid "%s (PID %d) exited with exit code %d" msgstr "%s (PID %d) terminó con código de salida %d" -#: postmaster/postmaster.c:3495 postmaster/postmaster.c:3506 -#: postmaster/postmaster.c:3517 postmaster/postmaster.c:3526 -#: postmaster/postmaster.c:3536 +#: postmaster/postmaster.c:3504 postmaster/postmaster.c:3515 +#: postmaster/postmaster.c:3526 postmaster/postmaster.c:3535 +#: postmaster/postmaster.c:3545 #, c-format msgid "Failed process was running: %s" msgstr "El proceso que falló estaba ejecutando: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3503 +#: postmaster/postmaster.c:3512 #, c-format msgid "%s (PID %d) was terminated by exception 0x%X" msgstr "%s (PID %d) fue terminado por una excepción 0x%X" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3513 +#: postmaster/postmaster.c:3522 #, c-format msgid "%s (PID %d) was terminated by signal %d: %s" msgstr "%s (PID %d) fue terminado por una señal %d: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3524 +#: postmaster/postmaster.c:3533 #, c-format msgid "%s (PID %d) was terminated by signal %d" msgstr "%s (PID %d) fue terminado por una señal %d" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3534 +#: postmaster/postmaster.c:3543 #, c-format msgid "%s (PID %d) exited with unrecognized status %d" msgstr "%s (PID %d) terminó con código no reconocido %d" -#: postmaster/postmaster.c:3721 +#: postmaster/postmaster.c:3730 #, c-format msgid "abnormal database system shutdown" msgstr "apagado anormal del sistema de bases de datos" -#: postmaster/postmaster.c:3761 +#: postmaster/postmaster.c:3770 #, c-format msgid "all server processes terminated; reinitializing" msgstr "todos los procesos fueron terminados; reinicializando" -#: postmaster/postmaster.c:3973 +#: postmaster/postmaster.c:3982 #, c-format msgid "could not fork new process for connection: %m" msgstr "no se pudo lanzar el nuevo proceso para la conexión: %m" -#: postmaster/postmaster.c:4015 +#: postmaster/postmaster.c:4024 msgid "could not fork new process for connection: " msgstr "no se pudo lanzar el nuevo proceso para la conexión: " -#: postmaster/postmaster.c:4129 +#: postmaster/postmaster.c:4138 #, c-format msgid "connection received: host=%s port=%s" msgstr "conexión recibida: host=%s port=%s" -#: postmaster/postmaster.c:4134 +#: postmaster/postmaster.c:4143 #, c-format msgid "connection received: host=%s" msgstr "conexión recibida: host=%s" -#: postmaster/postmaster.c:4417 +#: postmaster/postmaster.c:4426 #, c-format msgid "could not execute server process \"%s\": %m" msgstr "no se pudo lanzar el proceso servidor «%s»: %m" -#: postmaster/postmaster.c:4961 +#: postmaster/postmaster.c:4579 +#, c-format +msgid "giving up after too many tries to reserve shared memory" +msgstr "abandonando luego de demasiados reintentos de reservar memoria compartida" + +#: postmaster/postmaster.c:4580 +#, c-format +msgid "This might be caused by ASLR or antivirus software." +msgstr "Esto podría ser causado por ASLR o software antivirus" + +#: postmaster/postmaster.c:4978 #, c-format msgid "database system is ready to accept read only connections" msgstr "el sistema de bases de datos está listo para aceptar conexiones de sólo lectura" -#: postmaster/postmaster.c:5252 +#: postmaster/postmaster.c:5267 #, c-format msgid "could not fork startup process: %m" msgstr "no se pudo lanzar el proceso de inicio: %m" -#: postmaster/postmaster.c:5256 +#: postmaster/postmaster.c:5271 #, c-format msgid "could not fork background writer process: %m" msgstr "no se pudo lanzar el background writer: %m" -#: postmaster/postmaster.c:5260 +#: postmaster/postmaster.c:5275 #, c-format msgid "could not fork checkpointer process: %m" msgstr "no se pudo lanzar el checkpointer: %m" -#: postmaster/postmaster.c:5264 +#: postmaster/postmaster.c:5279 #, c-format msgid "could not fork WAL writer process: %m" msgstr "no se pudo lanzar el proceso escritor de WAL: %m" -#: postmaster/postmaster.c:5268 +#: postmaster/postmaster.c:5283 #, c-format msgid "could not fork WAL receiver process: %m" msgstr "no se pudo lanzar el proceso receptor de WAL: %m" -#: postmaster/postmaster.c:5272 +#: postmaster/postmaster.c:5287 #, c-format msgid "could not fork process: %m" msgstr "no se pudo lanzar el proceso: %m" -#: postmaster/postmaster.c:5434 postmaster/postmaster.c:5457 +#: postmaster/postmaster.c:5467 postmaster/postmaster.c:5490 #, c-format msgid "database connection requirement not indicated during registration" msgstr "el requerimiento de conexión a base de datos no fue indicado durante el registro" -#: postmaster/postmaster.c:5441 postmaster/postmaster.c:5464 +#: postmaster/postmaster.c:5474 postmaster/postmaster.c:5497 #, c-format msgid "invalid processing mode in background worker" msgstr "modo de procesamiento no válido en «background worker»" -#: postmaster/postmaster.c:5536 +#: postmaster/postmaster.c:5569 #, c-format msgid "starting background worker process \"%s\"" msgstr "iniciando el proceso «background worker» «%s»" -#: postmaster/postmaster.c:5548 +#: postmaster/postmaster.c:5581 #, c-format msgid "could not fork worker process: %m" msgstr "no se pudo lanzar el proceso «background worker»: %m" -#: postmaster/postmaster.c:5965 +#: postmaster/postmaster.c:5998 #, c-format msgid "could not duplicate socket %d for use in backend: error code %d" msgstr "no se pudo duplicar el socket %d para su empleo en el backend: código de error %d" -#: postmaster/postmaster.c:5997 +#: postmaster/postmaster.c:6030 #, c-format msgid "could not create inherited socket: error code %d\n" msgstr "no se pudo crear el socket heradado: código de error %d\n" -#: postmaster/postmaster.c:6026 +#: postmaster/postmaster.c:6059 #, c-format msgid "could not open backend variables file \"%s\": %s\n" msgstr "no se pudo abrir el archivo de variables de servidor «%s»: %s\n" -#: postmaster/postmaster.c:6033 +#: postmaster/postmaster.c:6066 #, c-format msgid "could not read from backend variables file \"%s\": %s\n" msgstr "no se pudo leer el archivo de variables de servidor «%s»: %s\n" -#: postmaster/postmaster.c:6042 +#: postmaster/postmaster.c:6075 #, c-format msgid "could not remove file \"%s\": %s\n" msgstr "no se pudo eliminar el archivo «%s»: %s\n" -#: postmaster/postmaster.c:6059 +#: postmaster/postmaster.c:6092 #, c-format msgid "could not map view of backend variables: error code %lu\n" msgstr "no se pudo mapear la vista del archivo de variables: código de error %lu\n" -#: postmaster/postmaster.c:6068 +#: postmaster/postmaster.c:6101 #, c-format msgid "could not unmap view of backend variables: error code %lu\n" msgstr "no se pudo desmapear la vista del archivo de variables: código de error %lu\n" -#: postmaster/postmaster.c:6075 +#: postmaster/postmaster.c:6108 #, c-format msgid "could not close handle to backend parameter variables: error code %lu\n" msgstr "no se pudo cerrar el archivo de variables de servidor: código de error %lu\n" -#: postmaster/postmaster.c:6236 +#: postmaster/postmaster.c:6269 #, c-format msgid "could not read exit code for process\n" msgstr "no se pudo leer el código de salida del proceso\n" -#: postmaster/postmaster.c:6241 +#: postmaster/postmaster.c:6274 #, c-format msgid "could not post child completion status\n" msgstr "no se pudo publicar el estado de completitud del proceso hijo\n" @@ -15005,20 +14835,19 @@ msgstr "Se esperaba 1 tupla con 2 campos, se obtuvieron %d tuplas con %d campos. msgid "invalid socket: %s" msgstr "soclet no válido: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:426 -#: storage/ipc/latch.c:1343 +#: replication/libpqwalreceiver/libpqwalreceiver.c:426 storage/ipc/latch.c:1343 #, c-format msgid "select() failed: %m" msgstr "select() fallida: %m" -#: replication/libpqwalreceiver/libpqwalreceiver.c:549 -#: replication/libpqwalreceiver/libpqwalreceiver.c:576 +#: replication/libpqwalreceiver/libpqwalreceiver.c:555 #: replication/libpqwalreceiver/libpqwalreceiver.c:582 +#: replication/libpqwalreceiver/libpqwalreceiver.c:588 #, c-format msgid "could not receive data from WAL stream: %s" msgstr "no se pudo recibir datos desde el flujo de WAL: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:601 +#: replication/libpqwalreceiver/libpqwalreceiver.c:607 #, c-format msgid "could not send data to WAL stream: %s" msgstr "no se pudo enviar datos al flujo de WAL: %s" @@ -15188,25 +15017,25 @@ msgstr "el identificador de replicación %d ya está activo para el PID %d" msgid "no replication origin is configured" msgstr "no hay un destino de replicación configurado" -#: replication/logical/reorderbuffer.c:2330 +#: replication/logical/reorderbuffer.c:2331 #, c-format msgid "could not write to data file for XID %u: %m" msgstr "no se pudo escribir al archivo de datos para el XID %u: %m" -#: replication/logical/reorderbuffer.c:2426 -#: replication/logical/reorderbuffer.c:2446 +#: replication/logical/reorderbuffer.c:2427 +#: replication/logical/reorderbuffer.c:2447 #, c-format msgid "could not read from reorderbuffer spill file: %m" msgstr "no se pudo leer desde el archivo de desborde de reorderbuffer: %m" -#: replication/logical/reorderbuffer.c:2430 -#: replication/logical/reorderbuffer.c:2450 +#: replication/logical/reorderbuffer.c:2431 +#: replication/logical/reorderbuffer.c:2451 #, c-format msgid "could not read from reorderbuffer spill file: read %d instead of %u bytes" msgstr "no se pudo leer desde el archivo de desborde de reorderbuffer: se leyeron sólo %d en ve de %u bytes" # FIXME almost duplicated again!? -#: replication/logical/reorderbuffer.c:3106 +#: replication/logical/reorderbuffer.c:3107 #, c-format msgid "could not read from file \"%s\": read %d instead of %d bytes" msgstr "no se pudo leer del archivo «%s»: se leyeron %d en lugar de %d bytes" @@ -15388,22 +15217,22 @@ msgstr "La transacción ya fue comprometida localmente, pero pudo no haber sido msgid "canceling wait for synchronous replication due to user request" msgstr "cancelando espera para la replicación sincrónica debido a una petición del usuario" -#: replication/syncrep.c:368 +#: replication/syncrep.c:371 #, c-format msgid "standby \"%s\" now has synchronous standby priority %u" msgstr "el standby «%s» ahora tiene prioridad sincrónica %u" -#: replication/syncrep.c:428 +#: replication/syncrep.c:431 #, c-format msgid "standby \"%s\" is now a synchronous standby with priority %u" msgstr "el standby «%s» es ahora un standby sincrónico con prioridad %u" -#: replication/syncrep.c:921 +#: replication/syncrep.c:931 #, c-format msgid "synchronous_standby_names parser failed" msgstr "falló la interpretación de «synchronous_standby_names»" -#: replication/syncrep.c:927 +#: replication/syncrep.c:937 #, c-format msgid "number of synchronous standbys (%d) must be greater than zero" msgstr "el argumento de standby sincrónicos (%d) debe ser mayor que cero" @@ -15468,72 +15297,77 @@ msgstr "trayendo el archivo de historia del timeline para el timeline %u desde e msgid "could not write to log segment %s at offset %u, length %lu: %m" msgstr "no se pudo escribir al segmento de log %s en la posición %u, largo %lu: %m" -#: replication/walsender.c:485 +#: replication/walsender.c:490 #, c-format msgid "could not seek to beginning of file \"%s\": %m" msgstr "no se pudo posicionar (seek) al comienzo del archivo «%s»: %m" -#: replication/walsender.c:536 +#: replication/walsender.c:541 #, c-format msgid "cannot use a logical replication slot for physical replication" msgstr "no se puede usar un slot de replicación lógica para replicación física" -#: replication/walsender.c:599 +#: replication/walsender.c:604 #, c-format msgid "requested starting point %X/%X on timeline %u is not in this server's history" msgstr "el punto de inicio solicitado %X/%X del timeline %u no está en la historia de este servidor" -#: replication/walsender.c:603 +#: replication/walsender.c:608 #, c-format msgid "This server's history forked from timeline %u at %X/%X." msgstr "La historia de este servidor bifurcó desde el timeline %u en %X/%X." -#: replication/walsender.c:648 +#: replication/walsender.c:653 #, c-format msgid "requested starting point %X/%X is ahead of the WAL flush position of this server %X/%X" msgstr "el punto de inicio solicitado %X/%X está más adelante que la posición de sincronización (flush) de WAL de este servidor %X/%X" -#: replication/walsender.c:973 +#: replication/walsender.c:977 #, c-format msgid "terminating walsender process after promotion" msgstr "terminando el proceso walsender luego de la promoción" -#: replication/walsender.c:1299 +#: replication/walsender.c:1333 +#, c-format +msgid "cannot execute new commands while WAL sender is in stopping mode" +msgstr "no se pueden ejecutar nuevas órdenes mientras el «WAL sender» está en modo de detención" + +#: replication/walsender.c:1341 #, c-format msgid "received replication command: %s" msgstr "se recibió orden de replicación: %s" -#: replication/walsender.c:1398 replication/walsender.c:1414 +#: replication/walsender.c:1440 replication/walsender.c:1456 #, c-format msgid "unexpected EOF on standby connection" msgstr "se encontró fin de archivo inesperado en la conexión standby" -#: replication/walsender.c:1428 +#: replication/walsender.c:1470 #, c-format msgid "unexpected standby message type \"%c\", after receiving CopyDone" msgstr "mensaje de standby de tipo «%c» inesperado, después de recibir CopyDone" -#: replication/walsender.c:1466 +#: replication/walsender.c:1508 #, c-format msgid "invalid standby message type \"%c\"" msgstr "el tipo «%c» de mensaje del standby no es válido" -#: replication/walsender.c:1507 +#: replication/walsender.c:1549 #, c-format msgid "unexpected message type \"%c\"" msgstr "mensaje de tipo «%c» inesperado" -#: replication/walsender.c:1791 +#: replication/walsender.c:1833 #, c-format msgid "terminating walsender process due to replication timeout" msgstr "terminando el proceso walsender debido a que se agotó el tiempo de espera de replicación" -#: replication/walsender.c:1876 +#: replication/walsender.c:1919 #, c-format msgid "standby \"%s\" has now caught up with primary" msgstr "el standby «%s» ahora está actualizado respecto del primario" -#: replication/walsender.c:1979 +#: replication/walsender.c:2022 #, c-format msgid "number of requested standby connections exceeds max_wal_senders (currently %d)" msgstr "la cantidad de conexiones standby pedidas excede max_wal_senders (actualmente %d)" @@ -15744,153 +15578,153 @@ msgstr "el nombre de consulta WITH «%s» aparece tanto en una acción de regla msgid "cannot have RETURNING lists in multiple rules" msgstr "no se puede usar RETURNING en múltiples reglas" -#: rewrite/rewriteHandler.c:928 rewrite/rewriteHandler.c:946 +#: rewrite/rewriteHandler.c:949 rewrite/rewriteHandler.c:967 #, c-format msgid "multiple assignments to same column \"%s\"" msgstr "hay múltiples asignaciones a la misma columna «%s»" -#: rewrite/rewriteHandler.c:1721 rewrite/rewriteHandler.c:3331 +#: rewrite/rewriteHandler.c:1752 rewrite/rewriteHandler.c:3362 #, c-format msgid "infinite recursion detected in rules for relation \"%s\"" msgstr "se detectó recursión infinita en las reglas de la relación «%s»" -#: rewrite/rewriteHandler.c:1806 +#: rewrite/rewriteHandler.c:1837 #, c-format msgid "infinite recursion detected in policy for relation \"%s\"" msgstr "se detectó recursión infinita en la política para la relación «%s»" -#: rewrite/rewriteHandler.c:2123 +#: rewrite/rewriteHandler.c:2154 msgid "Junk view columns are not updatable." msgstr "Las columnas «basura» de vistas no son actualizables." -#: rewrite/rewriteHandler.c:2128 +#: rewrite/rewriteHandler.c:2159 msgid "View columns that are not columns of their base relation are not updatable." msgstr "Las columnas de vistas que no son columnas de su relación base no son actualizables." -#: rewrite/rewriteHandler.c:2131 +#: rewrite/rewriteHandler.c:2162 msgid "View columns that refer to system columns are not updatable." msgstr "Las columnas de vistas que se refieren a columnas de sistema no son actualizables." -#: rewrite/rewriteHandler.c:2134 +#: rewrite/rewriteHandler.c:2165 msgid "View columns that return whole-row references are not updatable." msgstr "Las columnas de vistas que retornan referencias a la fila completa (whole-row) no son actualizables." # XXX a %s here would be nice ... -#: rewrite/rewriteHandler.c:2192 +#: rewrite/rewriteHandler.c:2223 msgid "Views containing DISTINCT are not automatically updatable." msgstr "Las vistas que contienen DISTINCT no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2195 +#: rewrite/rewriteHandler.c:2226 msgid "Views containing GROUP BY are not automatically updatable." msgstr "Las vistas que contienen GROUP BY no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2198 +#: rewrite/rewriteHandler.c:2229 msgid "Views containing HAVING are not automatically updatable." msgstr "Las vistas que contienen HAVING no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2201 +#: rewrite/rewriteHandler.c:2232 msgid "Views containing UNION, INTERSECT, or EXCEPT are not automatically updatable." msgstr "Las vistas que contienen UNION, INTERSECT o EXCEPT no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2204 +#: rewrite/rewriteHandler.c:2235 msgid "Views containing WITH are not automatically updatable." msgstr "Las vistas que contienen WITH no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2207 +#: rewrite/rewriteHandler.c:2238 msgid "Views containing LIMIT or OFFSET are not automatically updatable." msgstr "Las vistas que contienen LIMIT u OFFSET no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2219 +#: rewrite/rewriteHandler.c:2250 msgid "Views that return aggregate functions are not automatically updatable." msgstr "Las vistas que retornan funciones de agregación no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2222 +#: rewrite/rewriteHandler.c:2253 msgid "Views that return window functions are not automatically updatable." msgstr "Las vistas que retornan funciones ventana no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2225 +#: rewrite/rewriteHandler.c:2256 msgid "Views that return set-returning functions are not automatically updatable." msgstr "Las vistas que retornan funciones-que-retornan-conjuntos no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2232 rewrite/rewriteHandler.c:2236 -#: rewrite/rewriteHandler.c:2243 +#: rewrite/rewriteHandler.c:2263 rewrite/rewriteHandler.c:2267 +#: rewrite/rewriteHandler.c:2274 msgid "Views that do not select from a single table or view are not automatically updatable." msgstr "Las vistas que no extraen desde una única tabla o vista no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2246 +#: rewrite/rewriteHandler.c:2277 msgid "Views containing TABLESAMPLE are not automatically updatable." msgstr "Las vistas que contienen TABLESAMPLE no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2270 +#: rewrite/rewriteHandler.c:2301 msgid "Views that have no updatable columns are not automatically updatable." msgstr "Las vistas que no tienen columnas actualizables no son automáticamente actualizables." -#: rewrite/rewriteHandler.c:2724 +#: rewrite/rewriteHandler.c:2755 #, c-format msgid "cannot insert into column \"%s\" of view \"%s\"" msgstr "no se puede insertar en la columna «%s» de la vista «%s»" -#: rewrite/rewriteHandler.c:2732 +#: rewrite/rewriteHandler.c:2763 #, c-format msgid "cannot update column \"%s\" of view \"%s\"" msgstr "no se puede actualizar la columna «%s» vista «%s»" -#: rewrite/rewriteHandler.c:3130 +#: rewrite/rewriteHandler.c:3161 #, c-format msgid "DO INSTEAD NOTHING rules are not supported for data-modifying statements in WITH" msgstr "las reglas DO INSTEAD NOTHING no están soportadas para sentencias que modifiquen datos en WITH" -#: rewrite/rewriteHandler.c:3144 +#: rewrite/rewriteHandler.c:3175 #, c-format msgid "conditional DO INSTEAD rules are not supported for data-modifying statements in WITH" msgstr "las reglas DO INSTEAD condicionales no están soportadas para sentencias que modifiquen datos en WITH" -#: rewrite/rewriteHandler.c:3148 +#: rewrite/rewriteHandler.c:3179 #, c-format msgid "DO ALSO rules are not supported for data-modifying statements in WITH" msgstr "las reglas DO ALSO no están soportadas para sentencias que modifiquen datos en WITH" -#: rewrite/rewriteHandler.c:3153 +#: rewrite/rewriteHandler.c:3184 #, c-format msgid "multi-statement DO INSTEAD rules are not supported for data-modifying statements in WITH" msgstr "las reglas DO INSTEAD de múltiples sentencias no están soportadas para sentencias que modifiquen datos en WITH" -#: rewrite/rewriteHandler.c:3368 +#: rewrite/rewriteHandler.c:3399 #, c-format msgid "cannot perform INSERT RETURNING on relation \"%s\"" msgstr "no se puede hacer INSERT RETURNING a la relación «%s»" -#: rewrite/rewriteHandler.c:3370 +#: rewrite/rewriteHandler.c:3401 #, c-format msgid "You need an unconditional ON INSERT DO INSTEAD rule with a RETURNING clause." msgstr "Necesita un regla incondicional ON INSERT DO INSTEAD con una cláusula RETURNING." -#: rewrite/rewriteHandler.c:3375 +#: rewrite/rewriteHandler.c:3406 #, c-format msgid "cannot perform UPDATE RETURNING on relation \"%s\"" msgstr "no se puede hacer UPDATE RETURNING a la relación «%s»" -#: rewrite/rewriteHandler.c:3377 +#: rewrite/rewriteHandler.c:3408 #, c-format msgid "You need an unconditional ON UPDATE DO INSTEAD rule with a RETURNING clause." msgstr "Necesita un regla incondicional ON UPDATE DO INSTEAD con una cláusula RETURNING." -#: rewrite/rewriteHandler.c:3382 +#: rewrite/rewriteHandler.c:3413 #, c-format msgid "cannot perform DELETE RETURNING on relation \"%s\"" msgstr "no se puede hacer DELETE RETURNING a la relación «%s»" -#: rewrite/rewriteHandler.c:3384 +#: rewrite/rewriteHandler.c:3415 #, c-format msgid "You need an unconditional ON DELETE DO INSTEAD rule with a RETURNING clause." msgstr "Necesita un regla incondicional ON DELETE DO INSTEAD con una clásula RETURNING." -#: rewrite/rewriteHandler.c:3402 +#: rewrite/rewriteHandler.c:3433 #, c-format msgid "INSERT with ON CONFLICT clause cannot be used with table that has INSERT or UPDATE rules" msgstr "INSERT con una cláusula ON CONFLICT no puede usarse con una tabla que tiene reglas INSERT o UPDATE" -#: rewrite/rewriteHandler.c:3459 +#: rewrite/rewriteHandler.c:3490 #, c-format msgid "WITH cannot be used in a query that is rewritten by rules into multiple queries" msgstr "WITH no puede ser usado en una consulta que está siendo convertida en múltiples consultas a través de reglas" @@ -16167,9 +16001,9 @@ msgstr "poll() fallida: %m" #: storage/ipc/shm_toc.c:108 storage/ipc/shm_toc.c:189 storage/ipc/shmem.c:212 #: storage/lmgr/lock.c:883 storage/lmgr/lock.c:917 storage/lmgr/lock.c:2682 #: storage/lmgr/lock.c:4007 storage/lmgr/lock.c:4072 storage/lmgr/lock.c:4364 -#: storage/lmgr/predicate.c:2329 storage/lmgr/predicate.c:2344 -#: storage/lmgr/predicate.c:3736 storage/lmgr/predicate.c:4879 -#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1043 +#: storage/lmgr/predicate.c:2344 storage/lmgr/predicate.c:2359 +#: storage/lmgr/predicate.c:3751 storage/lmgr/predicate.c:4894 +#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1042 #, c-format msgid "out of shared memory" msgstr "memoria compartida agotada" @@ -16194,12 +16028,12 @@ msgstr "el tamaño de la entrada ShmemIndex es incorrecto para la estructura «% msgid "requested shared memory size overflows size_t" msgstr "la petición de tamaño de memoria compartida desborda size_t" -#: storage/ipc/standby.c:530 tcop/postgres.c:2976 +#: storage/ipc/standby.c:530 tcop/postgres.c:2974 #, c-format msgid "canceling statement due to conflict with recovery" msgstr "cancelando la sentencia debido a un conflicto con la recuperación" -#: storage/ipc/standby.c:531 tcop/postgres.c:2263 +#: storage/ipc/standby.c:531 tcop/postgres.c:2255 #, c-format msgid "User transaction caused buffer deadlock with recovery." msgstr "La transacción del usuario causó un «deadlock» con la recuperación." @@ -16360,87 +16194,87 @@ msgstr "Puede ser necesario incrementar max_locks_per_transaction." msgid "cannot PREPARE while holding both session-level and transaction-level locks on the same object" msgstr "no se puede hacer PREPARE mientras se mantienen locks a nivel de sesión y transacción simultáneamente sobre el mismo objeto" -#: storage/lmgr/predicate.c:675 +#: storage/lmgr/predicate.c:677 #, c-format msgid "not enough elements in RWConflictPool to record a read/write conflict" msgstr "no hay suficientes elementos en RWConflictPool para registrar un conflicto read/write" -#: storage/lmgr/predicate.c:676 storage/lmgr/predicate.c:704 +#: storage/lmgr/predicate.c:678 storage/lmgr/predicate.c:706 #, c-format msgid "You might need to run fewer transactions at a time or increase max_connections." msgstr "Puede ser necesario ejecutar menos transacciones al mismo tiempo, o incrementar max_connections." -#: storage/lmgr/predicate.c:703 +#: storage/lmgr/predicate.c:705 #, c-format msgid "not enough elements in RWConflictPool to record a potential read/write conflict" msgstr "no hay suficientes elementos en RWConflictPool para registrar un potencial conflicto read/write" -#: storage/lmgr/predicate.c:909 +#: storage/lmgr/predicate.c:912 #, c-format msgid "memory for serializable conflict tracking is nearly exhausted" msgstr "la memoria para el seguimiento de conflictos de serialización está casi agotada" -#: storage/lmgr/predicate.c:910 +#: storage/lmgr/predicate.c:913 #, c-format msgid "There might be an idle transaction or a forgotten prepared transaction causing this." msgstr "Puede haber una transacción inactiva o una transacción preparada olvidada que esté causando este problema." -#: storage/lmgr/predicate.c:1190 storage/lmgr/predicate.c:1261 +#: storage/lmgr/predicate.c:1207 storage/lmgr/predicate.c:1279 #, c-format msgid "not enough shared memory for elements of data structure \"%s\" (%zu bytes requested)" msgstr "el espacio de memoria compartida es insuficiente para los elementos de la estructura «%s» (%zu bytes solicitados)" -#: storage/lmgr/predicate.c:1549 +#: storage/lmgr/predicate.c:1564 #, c-format msgid "deferrable snapshot was unsafe; trying a new one" msgstr "el snapshot postergado era inseguro; intentando con uno nuevo" -#: storage/lmgr/predicate.c:1588 +#: storage/lmgr/predicate.c:1603 #, c-format msgid "\"default_transaction_isolation\" is set to \"serializable\"." msgstr "«default_transaction_isolation» está definido a «serializable»." -#: storage/lmgr/predicate.c:1589 +#: storage/lmgr/predicate.c:1604 #, c-format msgid "You can use \"SET default_transaction_isolation = 'repeatable read'\" to change the default." msgstr "Puede usar «SET default_transaction_isolation = 'repeatable read'» para cambiar el valor por omisión." -#: storage/lmgr/predicate.c:1628 +#: storage/lmgr/predicate.c:1643 #, c-format msgid "a snapshot-importing transaction must not be READ ONLY DEFERRABLE" msgstr "una transacción que importa un snapshot no debe ser READ ONLY DEFERRABLE" -#: storage/lmgr/predicate.c:1706 utils/time/snapmgr.c:617 +#: storage/lmgr/predicate.c:1721 utils/time/snapmgr.c:617 #: utils/time/snapmgr.c:623 #, c-format msgid "could not import the requested snapshot" msgstr "no se pudo importar el snapshot solicitado" -#: storage/lmgr/predicate.c:1707 utils/time/snapmgr.c:624 +#: storage/lmgr/predicate.c:1722 utils/time/snapmgr.c:624 #, c-format msgid "The source transaction %u is not running anymore." msgstr "La transacción de origen %u ya no está en ejecución." -#: storage/lmgr/predicate.c:2330 storage/lmgr/predicate.c:2345 -#: storage/lmgr/predicate.c:3737 +#: storage/lmgr/predicate.c:2345 storage/lmgr/predicate.c:2360 +#: storage/lmgr/predicate.c:3752 #, c-format msgid "You might need to increase max_pred_locks_per_transaction." msgstr "Puede ser necesario incrementar max_pred_locks_per_transaction." -#: storage/lmgr/predicate.c:3891 storage/lmgr/predicate.c:3980 -#: storage/lmgr/predicate.c:3988 storage/lmgr/predicate.c:4027 -#: storage/lmgr/predicate.c:4266 storage/lmgr/predicate.c:4603 -#: storage/lmgr/predicate.c:4615 storage/lmgr/predicate.c:4657 -#: storage/lmgr/predicate.c:4695 +#: storage/lmgr/predicate.c:3906 storage/lmgr/predicate.c:3995 +#: storage/lmgr/predicate.c:4003 storage/lmgr/predicate.c:4042 +#: storage/lmgr/predicate.c:4281 storage/lmgr/predicate.c:4618 +#: storage/lmgr/predicate.c:4630 storage/lmgr/predicate.c:4672 +#: storage/lmgr/predicate.c:4710 #, c-format msgid "could not serialize access due to read/write dependencies among transactions" msgstr "no se pudo serializar el acceso debido a dependencias read/write entre transacciones" -#: storage/lmgr/predicate.c:3893 storage/lmgr/predicate.c:3982 -#: storage/lmgr/predicate.c:3990 storage/lmgr/predicate.c:4029 -#: storage/lmgr/predicate.c:4268 storage/lmgr/predicate.c:4605 -#: storage/lmgr/predicate.c:4617 storage/lmgr/predicate.c:4659 -#: storage/lmgr/predicate.c:4697 +#: storage/lmgr/predicate.c:3908 storage/lmgr/predicate.c:3997 +#: storage/lmgr/predicate.c:4005 storage/lmgr/predicate.c:4044 +#: storage/lmgr/predicate.c:4283 storage/lmgr/predicate.c:4620 +#: storage/lmgr/predicate.c:4632 storage/lmgr/predicate.c:4674 +#: storage/lmgr/predicate.c:4712 #, c-format msgid "The transaction might succeed if retried." msgstr "La transacción podría tener éxito si es reintentada." @@ -16508,12 +16342,12 @@ msgstr "el puntero de item está corrupto: %u" msgid "corrupted item lengths: total %u, available space %u" msgstr "los largos de ítem están corruptos: total %u, espacio disponible %u" -#: storage/page/bufpage.c:756 storage/page/bufpage.c:892 +#: storage/page/bufpage.c:756 #, c-format msgid "corrupted item pointer: offset = %u, size = %u" msgstr "el puntero de ítem está corrupto: posición = %u, tamaño = %u" -#: storage/page/bufpage.c:997 +#: storage/page/bufpage.c:892 storage/page/bufpage.c:997 #, c-format msgid "corrupted item pointer: offset = %u, length = %u" msgstr "el puntero de ítem está corrupto: posición = %u, largo = %u" @@ -16603,9 +16437,9 @@ msgstr "no se pudo abrir el archivo «%s» (bloque buscado %u): %m" msgid "invalid argument size %d in function call message" msgstr "el tamaño de argumento %d no es válido en el mensaje de llamada a función" -#: tcop/fastpath.c:281 tcop/postgres.c:992 tcop/postgres.c:1301 -#: tcop/postgres.c:1559 tcop/postgres.c:1964 tcop/postgres.c:2331 -#: tcop/postgres.c:2406 +#: tcop/fastpath.c:281 tcop/postgres.c:984 tcop/postgres.c:1293 +#: tcop/postgres.c:1551 tcop/postgres.c:1956 tcop/postgres.c:2323 +#: tcop/postgres.c:2398 #, c-format msgid "current transaction is aborted, commands ignored until end of transaction block" msgstr "transacción abortada, las órdenes serán ignoradas hasta el fin de bloque de transacción" @@ -16615,8 +16449,8 @@ msgstr "transacción abortada, las órdenes serán ignoradas hasta el fin de blo msgid "fastpath function call: \"%s\" (OID %u)" msgstr "llamada a función fastpath: «%s» (OID %u)" -#: tcop/fastpath.c:391 tcop/postgres.c:1163 tcop/postgres.c:1426 -#: tcop/postgres.c:1805 tcop/postgres.c:2022 +#: tcop/fastpath.c:391 tcop/postgres.c:1155 tcop/postgres.c:1418 +#: tcop/postgres.c:1797 tcop/postgres.c:2014 #, c-format msgid "duration: %s ms" msgstr "duración: %s ms" @@ -16641,271 +16475,271 @@ msgstr "el mensaje de llamada a función contiene %d formatos de argumento pero msgid "incorrect binary data format in function argument %d" msgstr "el formato de datos binarios es incorrecto en argumento %d a función" -#: tcop/postgres.c:352 tcop/postgres.c:388 tcop/postgres.c:415 +#: tcop/postgres.c:344 tcop/postgres.c:380 tcop/postgres.c:407 #, c-format msgid "unexpected EOF on client connection" msgstr "se encontró fin de archivo inesperado en la conexión del cliente" -#: tcop/postgres.c:438 tcop/postgres.c:450 tcop/postgres.c:461 -#: tcop/postgres.c:473 tcop/postgres.c:4302 +#: tcop/postgres.c:430 tcop/postgres.c:442 tcop/postgres.c:453 +#: tcop/postgres.c:465 tcop/postgres.c:4300 #, c-format msgid "invalid frontend message type %d" msgstr "el tipo de mensaje de frontend %d no es válido" -#: tcop/postgres.c:933 +#: tcop/postgres.c:925 #, c-format msgid "statement: %s" msgstr "sentencia: %s" -#: tcop/postgres.c:1168 +#: tcop/postgres.c:1160 #, c-format msgid "duration: %s ms statement: %s" msgstr "duración: %s ms sentencia: %s" -#: tcop/postgres.c:1218 +#: tcop/postgres.c:1210 #, c-format msgid "parse %s: %s" msgstr "parse %s: %s" -#: tcop/postgres.c:1274 +#: tcop/postgres.c:1266 #, c-format msgid "cannot insert multiple commands into a prepared statement" msgstr "no se pueden insertar múltiples órdenes en una sentencia preparada" -#: tcop/postgres.c:1431 +#: tcop/postgres.c:1423 #, c-format msgid "duration: %s ms parse %s: %s" msgstr "duración: %s ms parse: %s: %s" -#: tcop/postgres.c:1476 +#: tcop/postgres.c:1468 #, c-format msgid "bind %s to %s" msgstr "bind %s a %s" -#: tcop/postgres.c:1495 tcop/postgres.c:2312 +#: tcop/postgres.c:1487 tcop/postgres.c:2304 #, c-format msgid "unnamed prepared statement does not exist" msgstr "no existe una sentencia preparada sin nombre" -#: tcop/postgres.c:1537 +#: tcop/postgres.c:1529 #, c-format msgid "bind message has %d parameter formats but %d parameters" msgstr "el mensaje de enlace (bind) tiene %d formatos de parámetro pero %d parámetros" -#: tcop/postgres.c:1543 +#: tcop/postgres.c:1535 #, c-format msgid "bind message supplies %d parameters, but prepared statement \"%s\" requires %d" msgstr "el mensaje de enlace (bind) entrega %d parámetros, pero la sentencia preparada «%s» requiere %d" -#: tcop/postgres.c:1712 +#: tcop/postgres.c:1704 #, c-format msgid "incorrect binary data format in bind parameter %d" msgstr "el formato de datos binarios es incorrecto en el parámetro de enlace %d" -#: tcop/postgres.c:1810 +#: tcop/postgres.c:1802 #, c-format msgid "duration: %s ms bind %s%s%s: %s" msgstr "duración: %s ms bind %s%s%s: %s" -#: tcop/postgres.c:1858 tcop/postgres.c:2392 +#: tcop/postgres.c:1850 tcop/postgres.c:2384 #, c-format msgid "portal \"%s\" does not exist" msgstr "no existe el portal «%s»" -#: tcop/postgres.c:1943 +#: tcop/postgres.c:1935 #, c-format msgid "%s %s%s%s: %s" msgstr "%s %s%s%s: %s" -#: tcop/postgres.c:1945 tcop/postgres.c:2030 +#: tcop/postgres.c:1937 tcop/postgres.c:2022 msgid "execute fetch from" msgstr "ejecutar fetch desde" -#: tcop/postgres.c:1946 tcop/postgres.c:2031 +#: tcop/postgres.c:1938 tcop/postgres.c:2023 msgid "execute" msgstr "ejecutar" -#: tcop/postgres.c:2027 +#: tcop/postgres.c:2019 #, c-format msgid "duration: %s ms %s %s%s%s: %s" msgstr "duración: %s ms %s %s%s%s: %s" -#: tcop/postgres.c:2153 +#: tcop/postgres.c:2145 #, c-format msgid "prepare: %s" msgstr "prepare: %s" -#: tcop/postgres.c:2216 +#: tcop/postgres.c:2208 #, c-format msgid "parameters: %s" msgstr "parámetros: %s" -#: tcop/postgres.c:2235 +#: tcop/postgres.c:2227 #, c-format msgid "abort reason: recovery conflict" msgstr "razón para abortar: conflicto en la recuperación" -#: tcop/postgres.c:2251 +#: tcop/postgres.c:2243 #, c-format msgid "User was holding shared buffer pin for too long." msgstr "El usuario mantuvo el búfer compartido «clavado» por demasiado tiempo." -#: tcop/postgres.c:2254 +#: tcop/postgres.c:2246 #, c-format msgid "User was holding a relation lock for too long." msgstr "El usuario mantuvo una relación bloqueada por demasiado tiempo." -#: tcop/postgres.c:2257 +#: tcop/postgres.c:2249 #, c-format msgid "User was or might have been using tablespace that must be dropped." msgstr "El usuario estaba o pudo haber estado usando un tablespace que debía ser eliminado." -#: tcop/postgres.c:2260 +#: tcop/postgres.c:2252 #, c-format msgid "User query might have needed to see row versions that must be removed." msgstr "La consulta del usuario pudo haber necesitado examinar versiones de tuplas que debían eliminarse." -#: tcop/postgres.c:2266 +#: tcop/postgres.c:2258 #, c-format msgid "User was connected to a database that must be dropped." msgstr "El usuario estaba conectado a una base de datos que debía ser eliminada." -#: tcop/postgres.c:2595 +#: tcop/postgres.c:2587 #, c-format msgid "terminating connection because of crash of another server process" msgstr "terminando la conexión debido a una falla en otro proceso servidor" -#: tcop/postgres.c:2596 +#: tcop/postgres.c:2588 #, c-format msgid "The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory." msgstr "Postmaster ha ordenado que este proceso servidor cancele la transacción en curso y finalice la conexión, porque otro proceso servidor ha terminado anormalmente y podría haber corrompido la memoria compartida." -#: tcop/postgres.c:2600 tcop/postgres.c:2904 +#: tcop/postgres.c:2592 tcop/postgres.c:2902 #, c-format msgid "In a moment you should be able to reconnect to the database and repeat your command." msgstr "Dentro de un momento debería poder reconectarse y repetir la consulta." -#: tcop/postgres.c:2686 +#: tcop/postgres.c:2678 #, c-format msgid "floating-point exception" msgstr "excepción de coma flotante" -#: tcop/postgres.c:2687 +#: tcop/postgres.c:2679 #, c-format msgid "An invalid floating-point operation was signaled. This probably means an out-of-range result or an invalid operation, such as division by zero." msgstr "Se ha recibido una señal de una operación de coma flotante no válida. Esto puede significar un resultado fuera de rango o una operación no válida, como una división por cero." -#: tcop/postgres.c:2849 +#: tcop/postgres.c:2847 #, c-format msgid "canceling authentication due to timeout" msgstr "cancelando la autentificación debido a que se agotó el tiempo de espera" -#: tcop/postgres.c:2853 +#: tcop/postgres.c:2851 #, c-format msgid "terminating autovacuum process due to administrator command" msgstr "terminando el proceso autovacuum debido a una orden del administrador" -#: tcop/postgres.c:2859 tcop/postgres.c:2869 tcop/postgres.c:2902 +#: tcop/postgres.c:2857 tcop/postgres.c:2867 tcop/postgres.c:2900 #, c-format msgid "terminating connection due to conflict with recovery" msgstr "terminando la conexión debido a un conflicto con la recuperación" -#: tcop/postgres.c:2875 +#: tcop/postgres.c:2873 #, c-format msgid "terminating connection due to administrator command" msgstr "terminando la conexión debido a una orden del administrador" -#: tcop/postgres.c:2885 +#: tcop/postgres.c:2883 #, c-format msgid "connection to client lost" msgstr "se ha perdido la conexión al cliente" -#: tcop/postgres.c:2953 +#: tcop/postgres.c:2951 #, c-format msgid "canceling statement due to lock timeout" msgstr "cancelando la sentencia debido a que se agotó el tiempo de espera de locks" -#: tcop/postgres.c:2960 +#: tcop/postgres.c:2958 #, c-format msgid "canceling statement due to statement timeout" msgstr "cancelando la sentencia debido a que se agotó el tiempo de espera de sentencias" -#: tcop/postgres.c:2967 +#: tcop/postgres.c:2965 #, c-format msgid "canceling autovacuum task" msgstr "cancelando tarea de autovacuum" -#: tcop/postgres.c:2990 +#: tcop/postgres.c:2988 #, c-format msgid "canceling statement due to user request" msgstr "cancelando la sentencia debido a una petición del usuario" -#: tcop/postgres.c:3000 +#: tcop/postgres.c:2998 #, c-format msgid "terminating connection due to idle-in-transaction timeout" msgstr "terminando la conexión debido a que se agotó el tiempo de espera para transacciones abiertas inactivas" -#: tcop/postgres.c:3114 +#: tcop/postgres.c:3112 #, c-format msgid "stack depth limit exceeded" msgstr "límite de profundidad de stack alcanzado" -#: tcop/postgres.c:3115 +#: tcop/postgres.c:3113 #, c-format msgid "Increase the configuration parameter \"max_stack_depth\" (currently %dkB), after ensuring the platform's stack depth limit is adequate." msgstr "Incremente el parámetro de configuración «max_stack_depth» (actualmente %dkB), después de asegurarse que el límite de profundidad de stack de la plataforma es adecuado." -#: tcop/postgres.c:3178 +#: tcop/postgres.c:3176 #, c-format msgid "\"max_stack_depth\" must not exceed %ldkB." msgstr "«max_stack_depth» no debe exceder %ldkB." -#: tcop/postgres.c:3180 +#: tcop/postgres.c:3178 #, c-format msgid "Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent." msgstr "Incremente el límite de profundidad del stack del sistema usando «ulimit -s» o el equivalente de su sistema." -#: tcop/postgres.c:3540 +#: tcop/postgres.c:3538 #, c-format msgid "invalid command-line argument for server process: %s" msgstr "argumentos de línea de órdenes no válidos para proceso servidor: %s" -#: tcop/postgres.c:3541 tcop/postgres.c:3547 +#: tcop/postgres.c:3539 tcop/postgres.c:3545 #, c-format msgid "Try \"%s --help\" for more information." msgstr "Pruebe «%s --help» para mayor información." -#: tcop/postgres.c:3545 +#: tcop/postgres.c:3543 #, c-format msgid "%s: invalid command-line argument: %s" msgstr "%s: argumento de línea de órdenes no válido: %s" -#: tcop/postgres.c:3607 +#: tcop/postgres.c:3605 #, c-format msgid "%s: no database nor user name specified" msgstr "%s: no se ha especificado base de datos ni usuario" -#: tcop/postgres.c:4210 +#: tcop/postgres.c:4208 #, c-format msgid "invalid CLOSE message subtype %d" msgstr "subtipo %d de mensaje CLOSE no válido" -#: tcop/postgres.c:4245 +#: tcop/postgres.c:4243 #, c-format msgid "invalid DESCRIBE message subtype %d" msgstr "subtipo %d de mensaje DESCRIBE no válido" -#: tcop/postgres.c:4323 +#: tcop/postgres.c:4321 #, c-format msgid "fastpath function calls not supported in a replication connection" msgstr "la invocación «fastpath» de funciones no está soportada en conexiones de replicación" -#: tcop/postgres.c:4327 +#: tcop/postgres.c:4325 #, c-format msgid "extended query protocol not supported in a replication connection" msgstr "el protocolo extendido de consultas no está soportado en conexiones de replicación" -#: tcop/postgres.c:4497 +#: tcop/postgres.c:4495 #, c-format msgid "disconnection: session time: %d:%02d:%02d.%03d user=%s database=%s host=%s%s%s" msgstr "desconexión: duración de sesión: %d:%02d:%02d.%03d usuario=%s base=%s host=%s%s%s" @@ -17109,7 +16943,7 @@ msgid "invalid regular expression: %s" msgstr "la expresión regular no es válida: %s" #: tsearch/spell.c:954 tsearch/spell.c:971 tsearch/spell.c:988 -#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14405 gram.y:14422 +#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14414 gram.y:14431 #, c-format msgid "syntax error" msgstr "error de sintaxis" @@ -17139,8 +16973,7 @@ msgstr "número no válido de alias de opciones" msgid "affix file contains both old-style and new-style commands" msgstr "el archivo de «affix» contiene órdenes en estilos antiguo y nuevo" -#: tsearch/to_tsany.c:170 utils/adt/tsvector.c:270 -#: utils/adt/tsvector_op.c:1133 +#: tsearch/to_tsany.c:170 utils/adt/tsvector.c:270 utils/adt/tsvector_op.c:1133 #, c-format msgid "string is too long for tsvector (%d bytes, max %d bytes)" msgstr "la cadena es demasiado larga para tsvector (%d bytes, máximo %d bytes)" @@ -17307,8 +17140,8 @@ msgstr "aclremove ya no está soportado" msgid "unrecognized privilege type: \"%s\"" msgstr "tipo de privilegio no reconocido: «%s»" -#: utils/adt/acl.c:3427 utils/adt/regproc.c:123 utils/adt/regproc.c:144 -#: utils/adt/regproc.c:319 +#: utils/adt/acl.c:3427 utils/adt/regproc.c:124 utils/adt/regproc.c:145 +#: utils/adt/regproc.c:320 #, c-format msgid "function \"%s\" does not exist" msgstr "no existe la función «%s»" @@ -17524,8 +17357,8 @@ msgstr "no está implementada la obtención de segmentos de arrays de largo fijo #: utils/adt/arrayfuncs.c:2848 utils/adt/arrayfuncs.c:5740 #: utils/adt/arrayfuncs.c:5766 utils/adt/arrayfuncs.c:5777 #: utils/adt/json.c:2290 utils/adt/json.c:2365 utils/adt/jsonb.c:1369 -#: utils/adt/jsonb.c:1455 utils/adt/jsonfuncs.c:3529 -#: utils/adt/jsonfuncs.c:3574 utils/adt/jsonfuncs.c:3621 +#: utils/adt/jsonb.c:1455 utils/adt/jsonfuncs.c:3529 utils/adt/jsonfuncs.c:3574 +#: utils/adt/jsonfuncs.c:3621 #, c-format msgid "wrong number of array subscripts" msgstr "número incorrecto de subíndices del array" @@ -17670,8 +17503,7 @@ msgstr "la sintaxis de entrada no es válida para tipo money: «%s»" #: utils/adt/int.c:1097 utils/adt/int.c:1125 utils/adt/int8.c:597 #: utils/adt/int8.c:657 utils/adt/int8.c:897 utils/adt/int8.c:1005 #: utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6818 -#: utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 -#: utils/adt/timestamp.c:3542 +#: utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 utils/adt/timestamp.c:3542 #, c-format msgid "division by zero" msgstr "división por cero" @@ -18529,15 +18361,12 @@ msgstr "Datos JSON, línea %d: %s%s%s" msgid "key value must be scalar, not array, composite, or json" msgstr "el valor de llave debe ser escalar, no array, composite o json" -#: utils/adt/json.c:2006 -#, c-format -msgid "could not determine data type for argument 1" -msgstr "no se pudo determinar el tipo de dato para el argumento 1" - -#: utils/adt/json.c:2016 +#: utils/adt/json.c:2006 utils/adt/json.c:2016 utils/adt/json.c:2142 +#: utils/adt/json.c:2163 utils/adt/json.c:2222 utils/adt/jsonb.c:1214 +#: utils/adt/jsonb.c:1237 utils/adt/jsonb.c:1297 #, c-format -msgid "could not determine data type for argument 2" -msgstr "no se pudo determinar el tipo de dato para el argumento 2" +msgid "could not determine data type for argument %d" +msgstr "no se pudo determinar el tipo de dato para el argumento %d" #: utils/adt/json.c:2040 utils/adt/jsonb.c:1781 #, c-format @@ -18554,11 +18383,6 @@ msgstr "la lista de argumentos debe tener un número par de elementos" msgid "The arguments of json_build_object() must consist of alternating keys and values." msgstr "Los argumentos de json_build_object() deben consistir de llaves y valores alternados." -#: utils/adt/json.c:2142 utils/adt/json.c:2163 utils/adt/json.c:2222 -#, c-format -msgid "could not determine data type for argument %d" -msgstr "no se pudo determinar el tipo de dato para el argumento %d" - #: utils/adt/json.c:2148 #, c-format msgid "argument %d cannot be null" @@ -18605,11 +18429,6 @@ msgstr "número no válido de argumentos: los objetos deben formar pares llave/v msgid "argument %d: key must not be null" msgstr "argumento %d: la llave no puede ser null" -#: utils/adt/jsonb.c:1214 utils/adt/jsonb.c:1237 utils/adt/jsonb.c:1297 -#, c-format -msgid "argument %d: could not determine data type" -msgstr "argumento %d: no se pudo determinar el tipo de dato" - #: utils/adt/jsonb.c:1834 #, c-format msgid "object keys must be strings" @@ -19406,60 +19225,60 @@ msgstr "la opción de expresión regular no es válida: «%c»" msgid "regexp_split does not support the global option" msgstr "regex_split no soporta la opción «global»" -#: utils/adt/regproc.c:128 utils/adt/regproc.c:148 +#: utils/adt/regproc.c:129 utils/adt/regproc.c:149 #, c-format msgid "more than one function named \"%s\"" msgstr "existe más de una función llamada «%s»" -#: utils/adt/regproc.c:587 utils/adt/regproc.c:607 +#: utils/adt/regproc.c:588 utils/adt/regproc.c:608 #, c-format msgid "more than one operator named %s" msgstr "existe más de un operador llamado %s" -#: utils/adt/regproc.c:774 utils/adt/regproc.c:815 gram.y:7302 +#: utils/adt/regproc.c:775 utils/adt/regproc.c:816 gram.y:7311 #, c-format msgid "missing argument" msgstr "falta un argumento" -#: utils/adt/regproc.c:775 utils/adt/regproc.c:816 gram.y:7303 +#: utils/adt/regproc.c:776 utils/adt/regproc.c:817 gram.y:7312 #, c-format msgid "Use NONE to denote the missing argument of a unary operator." msgstr "Use NONE para denotar el argumento faltante de un operador unario." -#: utils/adt/regproc.c:779 utils/adt/regproc.c:820 utils/adt/regproc.c:2006 -#: utils/adt/ruleutils.c:8367 utils/adt/ruleutils.c:8536 +#: utils/adt/regproc.c:780 utils/adt/regproc.c:821 utils/adt/regproc.c:2007 +#: utils/adt/ruleutils.c:8453 utils/adt/ruleutils.c:8622 #, c-format msgid "too many arguments" msgstr "demasiados argumentos" -#: utils/adt/regproc.c:780 utils/adt/regproc.c:821 +#: utils/adt/regproc.c:781 utils/adt/regproc.c:822 #, c-format msgid "Provide two argument types for operator." msgstr "Provea dos tipos de argumento para un operador." -#: utils/adt/regproc.c:1594 utils/adt/regproc.c:1618 utils/adt/regproc.c:1715 -#: utils/adt/regproc.c:1739 utils/adt/regproc.c:1841 utils/adt/regproc.c:1846 +#: utils/adt/regproc.c:1595 utils/adt/regproc.c:1619 utils/adt/regproc.c:1716 +#: utils/adt/regproc.c:1740 utils/adt/regproc.c:1842 utils/adt/regproc.c:1847 #: utils/adt/varlena.c:3084 utils/adt/varlena.c:3089 #, c-format msgid "invalid name syntax" msgstr "la sintaxis de nombre no es válida" -#: utils/adt/regproc.c:1904 +#: utils/adt/regproc.c:1905 #, c-format msgid "expected a left parenthesis" msgstr "se esperaba un paréntesis izquierdo" -#: utils/adt/regproc.c:1920 +#: utils/adt/regproc.c:1921 #, c-format msgid "expected a right parenthesis" msgstr "se esperaba un paréntesis derecho" -#: utils/adt/regproc.c:1939 +#: utils/adt/regproc.c:1940 #, c-format msgid "expected a type name" msgstr "se esperaba un nombre de tipo" -#: utils/adt/regproc.c:1971 +#: utils/adt/regproc.c:1972 #, c-format msgid "improper type name" msgstr "el nombre de tipo no es válido" @@ -19470,7 +19289,7 @@ msgstr "el nombre de tipo no es válido" #: utils/adt/ri_triggers.c:1515 utils/adt/ri_triggers.c:1691 #: utils/adt/ri_triggers.c:1871 utils/adt/ri_triggers.c:2062 #: utils/adt/ri_triggers.c:2120 utils/adt/ri_triggers.c:2225 -#: utils/adt/ri_triggers.c:2402 gram.y:3343 +#: utils/adt/ri_triggers.c:2402 gram.y:3351 #, c-format msgid "MATCH PARTIAL not yet implemented" msgstr "MATCH PARTIAL no está implementada" @@ -19592,19 +19411,19 @@ msgstr "tipo de dato erróneo: %u, se esperaba %u" msgid "improper binary format in record column %d" msgstr "formato binario incorrecto en la columna record %d" -#: utils/adt/rowtypes.c:902 utils/adt/rowtypes.c:1142 -#: utils/adt/rowtypes.c:1396 utils/adt/rowtypes.c:1673 +#: utils/adt/rowtypes.c:902 utils/adt/rowtypes.c:1142 utils/adt/rowtypes.c:1396 +#: utils/adt/rowtypes.c:1673 #, c-format msgid "cannot compare dissimilar column types %s and %s at record column %d" msgstr "no se pueden comparar los tipos de columnas disímiles %s y %s en la columna %d" -#: utils/adt/rowtypes.c:991 utils/adt/rowtypes.c:1213 -#: utils/adt/rowtypes.c:1529 utils/adt/rowtypes.c:1769 +#: utils/adt/rowtypes.c:991 utils/adt/rowtypes.c:1213 utils/adt/rowtypes.c:1529 +#: utils/adt/rowtypes.c:1769 #, c-format msgid "cannot compare record types with different numbers of columns" msgstr "no se pueden comparar registros con cantidad distinta de columnas" -#: utils/adt/ruleutils.c:4289 +#: utils/adt/ruleutils.c:4297 #, c-format msgid "rule \"%s\" has unsupported event type %d" msgstr "la regla «%s» tiene el tipo de evento no soportado %d" @@ -22629,6 +22448,12 @@ msgstr "error interno: tipo parámetro no reconocido\n" msgid "query-specified return tuple and function return type are not compatible" msgstr "tupla de retorno especificada por la consulta y el tipo retornado por la función no son compatibles" +#. translator: %d.%02ds is system CPU time, %d.%02du is user CPU time +#: utils/misc/pg_rusage.c:66 +#, c-format +msgid "CPU %d.%02ds/%d.%02du sec elapsed %d.%02d sec" +msgstr "CPU %d.%02ds/%d.%02du seg, transcurridos %d.%02d seg" + #: utils/misc/rls.c:127 #, c-format msgid "query would be affected by row-level security policy for table \"%s\"" @@ -22757,17 +22582,17 @@ msgstr "no se pudo leer el bloque %ld del archivo temporal: %m" msgid "cannot have more than %d runs for an external sort" msgstr "no se pueden tener más de %d pasadas para un ordenamiento externo" -#: utils/sort/tuplesort.c:4474 +#: utils/sort/tuplesort.c:4479 #, c-format msgid "could not create unique index \"%s\"" msgstr "no se pudo crear el índice único «%s»" -#: utils/sort/tuplesort.c:4476 +#: utils/sort/tuplesort.c:4481 #, c-format msgid "Key %s is duplicated." msgstr "La llave %s está duplicada." -#: utils/sort/tuplesort.c:4477 +#: utils/sort/tuplesort.c:4482 #, c-format msgid "Duplicate keys exist." msgstr "Existe una llave duplicada." @@ -22847,248 +22672,248 @@ msgstr "no se puede importar un snapshot desde una base de datos diferente" msgid "unrecognized role option \"%s\"" msgstr "opción de rol no reconocida «%s»" -#: gram.y:1278 gram.y:1293 +#: gram.y:1286 gram.y:1301 #, c-format msgid "CREATE SCHEMA IF NOT EXISTS cannot include schema elements" msgstr "CREATE SCHEMA IF NOT EXISTS no puede incluir elementos de esquema" -#: gram.y:1438 +#: gram.y:1446 #, c-format msgid "current database cannot be changed" msgstr "no se puede cambiar la base de datos activa" -#: gram.y:1562 +#: gram.y:1570 #, c-format msgid "time zone interval must be HOUR or HOUR TO MINUTE" msgstr "el intervalo de huso horario debe ser HOUR o HOUR TO MINUTE" -#: gram.y:2600 gram.y:2629 +#: gram.y:2608 gram.y:2637 #, c-format msgid "STDIN/STDOUT not allowed with PROGRAM" msgstr "STDIN/STDOUT no están permitidos con PROGRAM" -#: gram.y:2895 gram.y:2902 gram.y:10295 gram.y:10303 +#: gram.y:2903 gram.y:2910 gram.y:10304 gram.y:10312 #, c-format msgid "GLOBAL is deprecated in temporary table creation" msgstr "GLOBAL está obsoleto para la creación de tablas temporales" -#: gram.y:4809 +#: gram.y:4818 msgid "duplicate trigger events specified" msgstr "se han especificado eventos de disparador duplicados" -#: gram.y:4909 +#: gram.y:4918 #, c-format msgid "conflicting constraint properties" msgstr "propiedades de restricción contradictorias" -#: gram.y:5041 +#: gram.y:5050 #, c-format msgid "CREATE ASSERTION is not yet implemented" msgstr "CREATE ASSERTION no está implementado" -#: gram.y:5057 +#: gram.y:5066 #, c-format msgid "DROP ASSERTION is not yet implemented" msgstr "DROP ASSERTION no está implementado" -#: gram.y:5403 +#: gram.y:5412 #, c-format msgid "RECHECK is no longer required" msgstr "RECHECK ya no es requerido" -#: gram.y:5404 +#: gram.y:5413 #, c-format msgid "Update your data type." msgstr "Actualice su tipo de datos." -#: gram.y:6983 +#: gram.y:6992 #, c-format msgid "aggregates cannot have output arguments" msgstr "las funciones de agregación no pueden tener argumentos de salida" -#: gram.y:8853 gram.y:8871 +#: gram.y:8862 gram.y:8880 #, c-format msgid "WITH CHECK OPTION not supported on recursive views" msgstr "WITH CHECK OPTION no está soportado con vistas recursivas" -#: gram.y:9389 +#: gram.y:9398 #, c-format msgid "unrecognized VACUUM option \"%s\"" msgstr "opción de VACUUM «%s» no reconocida" -#: gram.y:10403 +#: gram.y:10412 #, c-format msgid "LIMIT #,# syntax is not supported" msgstr "la sintaxis LIMIT #,# no está soportada" -#: gram.y:10404 +#: gram.y:10413 #, c-format msgid "Use separate LIMIT and OFFSET clauses." msgstr "Use cláusulas LIMIT y OFFSET separadas." -#: gram.y:10667 gram.y:10692 +#: gram.y:10676 gram.y:10701 #, c-format msgid "VALUES in FROM must have an alias" msgstr "VALUES en FROM debe tener un alias" -#: gram.y:10668 gram.y:10693 +#: gram.y:10677 gram.y:10702 #, c-format msgid "For example, FROM (VALUES ...) [AS] foo." msgstr "Por ejemplo, FROM (VALUES ...) [AS] foo." -#: gram.y:10673 gram.y:10698 +#: gram.y:10682 gram.y:10707 #, c-format msgid "subquery in FROM must have an alias" msgstr "las subconsultas en FROM deben tener un alias" -#: gram.y:10674 gram.y:10699 +#: gram.y:10683 gram.y:10708 #, c-format msgid "For example, FROM (SELECT ...) [AS] foo." msgstr "Por ejemplo, FROM (SELECT ...) [AS] foo." -#: gram.y:11273 +#: gram.y:11282 #, c-format msgid "precision for type float must be at least 1 bit" msgstr "la precisión para el tipo float debe ser al menos 1 bit" -#: gram.y:11282 +#: gram.y:11291 #, c-format msgid "precision for type float must be less than 54 bits" msgstr "la precisión para el tipo float debe ser menor de 54 bits" -#: gram.y:11786 +#: gram.y:11795 #, c-format msgid "wrong number of parameters on left side of OVERLAPS expression" msgstr "el número de parámetros es incorrecto al lado izquierdo de la expresión OVERLAPS" -#: gram.y:11791 +#: gram.y:11800 #, c-format msgid "wrong number of parameters on right side of OVERLAPS expression" msgstr "el número de parámetros es incorrecto al lado derecho de la expresión OVERLAPS" -#: gram.y:11966 +#: gram.y:11975 #, c-format msgid "UNIQUE predicate is not yet implemented" msgstr "el predicado UNIQUE no está implementado" -#: gram.y:12300 +#: gram.y:12309 #, c-format msgid "cannot use multiple ORDER BY clauses with WITHIN GROUP" msgstr "no se permiten múltiples cláusulas ORDER BY con WITHIN GROUP" -#: gram.y:12305 +#: gram.y:12314 #, c-format msgid "cannot use DISTINCT with WITHIN GROUP" msgstr "no se permite DISTINCT con WITHIN GROUP" -#: gram.y:12310 +#: gram.y:12319 #, c-format msgid "cannot use VARIADIC with WITHIN GROUP" msgstr "no se permite VARIADIC con WITHIN GROUP" -#: gram.y:12816 +#: gram.y:12825 #, c-format msgid "RANGE PRECEDING is only supported with UNBOUNDED" msgstr "RANGE PRECEDING sólo está soportado con UNBOUNDED" -#: gram.y:12822 +#: gram.y:12831 #, c-format msgid "RANGE FOLLOWING is only supported with UNBOUNDED" msgstr "RANGE FOLLOWING sólo está soportado con UNBOUNDED" -#: gram.y:12849 gram.y:12872 +#: gram.y:12858 gram.y:12881 #, c-format msgid "frame start cannot be UNBOUNDED FOLLOWING" msgstr "el inicio de «frame» no puede ser UNBOUNDED FOLLOWING" -#: gram.y:12854 +#: gram.y:12863 #, c-format msgid "frame starting from following row cannot end with current row" msgstr "el «frame» que se inicia desde la siguiente fila no puede terminar en la fila actual" -#: gram.y:12877 +#: gram.y:12886 #, c-format msgid "frame end cannot be UNBOUNDED PRECEDING" msgstr "el fin de «frame» no puede ser UNBOUNDED PRECEDING" -#: gram.y:12883 +#: gram.y:12892 #, c-format msgid "frame starting from current row cannot have preceding rows" msgstr "el «frame» que se inicia desde la fila actual no puede tener filas precedentes" -#: gram.y:12890 +#: gram.y:12899 #, c-format msgid "frame starting from following row cannot have preceding rows" msgstr "el «frame» que se inicia desde la fila siguiente no puede tener filas precedentes" -#: gram.y:13555 +#: gram.y:13564 #, c-format msgid "type modifier cannot have parameter name" msgstr "el modificador de tipo no puede tener nombre de parámetro" -#: gram.y:13561 +#: gram.y:13570 #, c-format msgid "type modifier cannot have ORDER BY" msgstr "el modificador de tipo no puede tener ORDER BY" -#: gram.y:13625 gram.y:13631 +#: gram.y:13634 gram.y:13640 #, c-format msgid "%s cannot be used as a role name here" msgstr "%s no puede ser usado como nombre de rol aquí" -#: gram.y:14253 gram.y:14442 +#: gram.y:14262 gram.y:14451 msgid "improper use of \"*\"" msgstr "uso impropio de «*»" -#: gram.y:14506 +#: gram.y:14515 #, c-format msgid "an ordered-set aggregate with a VARIADIC direct argument must have one VARIADIC aggregated argument of the same data type" msgstr "una agregación de conjunto-ordenado con un argumento directo VARIADIC debe tener al menos un argumento agregado VARIADIC del mismo tipo de datos" -#: gram.y:14543 +#: gram.y:14552 #, c-format msgid "multiple ORDER BY clauses not allowed" msgstr "no se permiten múltiples cláusulas ORDER BY" -#: gram.y:14554 +#: gram.y:14563 #, c-format msgid "multiple OFFSET clauses not allowed" msgstr "no se permiten múltiples cláusulas OFFSET" -#: gram.y:14563 +#: gram.y:14572 #, c-format msgid "multiple LIMIT clauses not allowed" msgstr "no se permiten múltiples cláusulas LIMIT" -#: gram.y:14572 +#: gram.y:14581 #, c-format msgid "multiple WITH clauses not allowed" msgstr "no se permiten múltiples cláusulas WITH" -#: gram.y:14764 +#: gram.y:14773 #, c-format msgid "OUT and INOUT arguments aren't allowed in TABLE functions" msgstr "los argumentos OUT e INOUT no están permitidos en funciones TABLE" -#: gram.y:14865 +#: gram.y:14874 #, c-format msgid "multiple COLLATE clauses not allowed" msgstr "no se permiten múltiples cláusulas COLLATE" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14903 gram.y:14916 +#: gram.y:14912 gram.y:14925 #, c-format msgid "%s constraints cannot be marked DEFERRABLE" msgstr "las restricciones %s no pueden ser marcadas DEFERRABLE" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14929 +#: gram.y:14938 #, c-format msgid "%s constraints cannot be marked NOT VALID" msgstr "las restricciones %s no pueden ser marcadas NOT VALID" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14942 +#: gram.y:14951 #, c-format msgid "%s constraints cannot be marked NO INHERIT" msgstr "las restricciones %s no pueden ser marcadas NO INHERIT" diff --git a/src/backend/po/ru.po b/src/backend/po/ru.po index f5d14920fe..4866037a23 100644 --- a/src/backend/po/ru.po +++ b/src/backend/po/ru.po @@ -10,8 +10,8 @@ msgid "" msgstr "" "Project-Id-Version: postgres (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-09 21:08+0000\n" -"PO-Revision-Date: 2017-04-18 17:11+0300\n" +"POT-Creation-Date: 2017-08-17 17:47+0000\n" +"PO-Revision-Date: 2017-08-23 11:31+0300\n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -29,8 +29,8 @@ msgstr "" msgid "not recorded" msgstr "не запиÑано" -#: ../common/controldata_utils.c:52 commands/copy.c:2833 -#: commands/extension.c:3141 utils/adt/genfile.c:134 +#: ../common/controldata_utils.c:52 commands/copy.c:2834 +#: commands/extension.c:3144 utils/adt/genfile.c:134 #, c-format msgid "could not open file \"%s\" for reading: %m" msgstr "не удалоÑÑŒ открыть файл \"%s\" Ð´Ð»Ñ Ñ‡Ñ‚ÐµÐ½Ð¸Ñ: %m" @@ -41,13 +41,13 @@ msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: не удалоÑÑŒ открыть файл \"%s\" Ð´Ð»Ñ Ñ‡Ñ‚ÐµÐ½Ð¸Ñ: %s\n" #: ../common/controldata_utils.c:66 access/transam/timeline.c:346 -#: access/transam/xlog.c:3220 access/transam/xlog.c:10423 -#: access/transam/xlog.c:10436 access/transam/xlog.c:10828 -#: access/transam/xlog.c:10871 access/transam/xlog.c:10910 -#: access/transam/xlog.c:10953 access/transam/xlogfuncs.c:665 -#: access/transam/xlogfuncs.c:684 commands/extension.c:3151 -#: replication/logical/origin.c:665 replication/logical/origin.c:695 -#: replication/logical/reorderbuffer.c:3099 replication/walsender.c:499 +#: access/transam/xlog.c:3226 access/transam/xlog.c:10453 +#: access/transam/xlog.c:10466 access/transam/xlog.c:10861 +#: access/transam/xlog.c:10904 access/transam/xlog.c:10943 +#: access/transam/xlog.c:10986 access/transam/xlogfuncs.c:660 +#: access/transam/xlogfuncs.c:679 commands/extension.c:3154 +#: replication/logical/origin.c:668 replication/logical/origin.c:698 +#: replication/logical/reorderbuffer.c:3100 replication/walsender.c:504 #: storage/file/copydir.c:176 utils/adt/genfile.c:151 #, c-format msgid "could not read file \"%s\": %m" @@ -159,27 +159,27 @@ msgid "could not close directory \"%s\": %s\n" msgstr "не удалоÑÑŒ закрыть каталог \"%s\": %s\n" #: ../common/psprintf.c:179 ../port/path.c:630 ../port/path.c:668 -#: ../port/path.c:685 access/transam/twophase.c:1262 access/transam/xlog.c:6108 -#: lib/stringinfo.c:258 libpq/auth.c:850 libpq/auth.c:1213 libpq/auth.c:1281 -#: libpq/auth.c:1797 postmaster/bgworker.c:289 postmaster/bgworker.c:796 -#: postmaster/postmaster.c:2335 postmaster/postmaster.c:2366 -#: postmaster/postmaster.c:3899 postmaster/postmaster.c:4589 -#: postmaster/postmaster.c:4664 postmaster/postmaster.c:5339 -#: postmaster/postmaster.c:5603 +#: ../port/path.c:685 access/transam/twophase.c:1262 access/transam/xlog.c:6114 +#: lib/stringinfo.c:258 libpq/auth.c:864 libpq/auth.c:1227 libpq/auth.c:1295 +#: libpq/auth.c:1811 postmaster/bgworker.c:310 postmaster/bgworker.c:813 +#: postmaster/postmaster.c:2357 postmaster/postmaster.c:2388 +#: postmaster/postmaster.c:3922 postmaster/postmaster.c:4620 +#: postmaster/postmaster.c:4695 postmaster/postmaster.c:5368 +#: postmaster/postmaster.c:5690 #: replication/libpqwalreceiver/libpqwalreceiver.c:143 -#: replication/logical/logical.c:168 storage/buffer/localbuf.c:436 -#: storage/file/fd.c:729 storage/file/fd.c:1126 storage/file/fd.c:1244 -#: storage/file/fd.c:1916 storage/ipc/procarray.c:1061 -#: storage/ipc/procarray.c:1547 storage/ipc/procarray.c:1554 -#: storage/ipc/procarray.c:1968 storage/ipc/procarray.c:2571 +#: replication/logical/logical.c:169 storage/buffer/localbuf.c:436 +#: storage/file/fd.c:736 storage/file/fd.c:1164 storage/file/fd.c:1282 +#: storage/file/fd.c:1993 storage/ipc/procarray.c:1062 +#: storage/ipc/procarray.c:1548 storage/ipc/procarray.c:1555 +#: storage/ipc/procarray.c:1969 storage/ipc/procarray.c:2580 #: utils/adt/formatting.c:1522 utils/adt/formatting.c:1642 #: utils/adt/formatting.c:1763 utils/adt/pg_locale.c:463 #: utils/adt/pg_locale.c:647 utils/adt/regexp.c:219 utils/adt/varlena.c:4440 #: utils/adt/varlena.c:4461 utils/fmgr/dfmgr.c:216 utils/hash/dynahash.c:429 -#: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1047 utils/mb/mbutils.c:376 +#: utils/hash/dynahash.c:535 utils/hash/dynahash.c:1046 utils/mb/mbutils.c:376 #: utils/mb/mbutils.c:709 utils/misc/guc.c:3888 utils/misc/guc.c:3904 #: utils/misc/guc.c:3917 utils/misc/guc.c:6863 utils/misc/tzparser.c:468 -#: utils/mmgr/aset.c:509 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 +#: utils/mmgr/aset.c:510 utils/mmgr/mcxt.c:767 utils/mmgr/mcxt.c:802 #: utils/mmgr/mcxt.c:839 utils/mmgr/mcxt.c:876 utils/mmgr/mcxt.c:910 #: utils/mmgr/mcxt.c:939 utils/mmgr/mcxt.c:973 utils/mmgr/mcxt.c:1055 #: utils/mmgr/mcxt.c:1089 utils/mmgr/mcxt.c:1138 @@ -249,7 +249,7 @@ msgstr "ошибка при удалении файла или каталога msgid "could not look up effective user ID %ld: %s" msgstr "выÑÑнить Ñффективный идентификатор Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ (%ld) не удалоÑÑŒ: %s" -#: ../common/username.c:47 libpq/auth.c:1744 +#: ../common/username.c:47 libpq/auth.c:1758 msgid "user does not exist" msgstr "пользователь не ÑущеÑтвует" @@ -298,7 +298,7 @@ msgstr "дочерний процеÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐ¸Ð»ÑÑ Ñ Ð½ÐµÑ€Ð°Ñпоз msgid "could not determine encoding for codeset \"%s\"" msgstr "не удалоÑÑŒ определить кодировку Ð´Ð»Ñ Ð½Ð°Ð±Ð¾Ñ€Ð° Ñимволов \"%s\"" -#: ../port/chklocale.c:294 ../port/chklocale.c:423 postmaster/postmaster.c:4868 +#: ../port/chklocale.c:294 ../port/chklocale.c:423 postmaster/postmaster.c:4899 #, c-format msgid "Please report this to ." msgstr "" @@ -393,83 +393,106 @@ msgstr "\"%s\" - Ñто не Ð¸Ð½Ð´ÐµÐºÑ BRIN" msgid "could not open parent table of index %s" msgstr "не удалоÑÑŒ родительÑкую таблицу индекÑа %s" -#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:362 -#: access/brin/brin_pageops.c:828 +#: access/brin/brin_pageops.c:76 access/brin/brin_pageops.c:360 +#: access/brin/brin_pageops.c:824 access/gin/ginentrypage.c:109 +#: access/gist/gist.c:1337 access/nbtree/nbtinsert.c:576 +#: access/nbtree/nbtsort.c:488 access/spgist/spgdoinsert.c:1907 #, c-format -msgid "index row size %lu exceeds maximum %lu for index \"%s\"" +msgid "index row size %zu exceeds maximum %zu for index \"%s\"" msgstr "" -"размер Ñтроки индекÑа (%lu) больше предельного размера (%lu) (Ð¸Ð½Ð´ÐµÐºÑ \"%s\")" +"размер Ñтроки индекÑа (%zu) больше предельного размера (%zu) (Ð¸Ð½Ð´ÐµÐºÑ \"%s\")" #: access/brin/brin_revmap.c:459 #, c-format msgid "unexpected page type 0x%04X in BRIN index \"%s\" block %u" msgstr "неожиданный тип Ñтраницы 0x%04X в BRIN-индекÑе \"%s\" (блок: %u)" -#: access/brin/brin_validate.c:115 +#: access/brin/brin_validate.c:115 access/gin/ginvalidate.c:148 +#: access/gist/gistvalidate.c:145 access/hash/hashvalidate.c:130 +#: access/nbtree/nbtvalidate.c:100 access/spgist/spgvalidate.c:115 #, c-format msgid "" -"brin operator family \"%s\" contains function %s with invalid support number " -"%d" +"operator family \"%s\" of access method %s contains function %s with invalid " +"support number %d" msgstr "" -"ÑемейÑтво операторов brin \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ опорным " -"номером %d" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит функцию %s Ñ " +"неправильным опорным номером %d" -#: access/brin/brin_validate.c:131 +#: access/brin/brin_validate.c:131 access/gin/ginvalidate.c:160 +#: access/gist/gistvalidate.c:157 access/hash/hashvalidate.c:113 +#: access/nbtree/nbtvalidate.c:112 access/spgist/spgvalidate.c:127 #, c-format msgid "" -"brin operator family \"%s\" contains function %s with wrong signature for " -"support number %d" +"operator family \"%s\" of access method %s contains function %s with wrong " +"signature for support number %d" msgstr "" -"ÑемейÑтво операторов brin \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит функцию %s Ñ " +"неподходÑщим объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" -#: access/brin/brin_validate.c:153 +#: access/brin/brin_validate.c:153 access/gin/ginvalidate.c:179 +#: access/gist/gistvalidate.c:177 access/hash/hashvalidate.c:151 +#: access/nbtree/nbtvalidate.c:132 access/spgist/spgvalidate.c:146 #, c-format msgid "" -"brin operator family \"%s\" contains operator %s with invalid strategy " -"number %d" +"operator family \"%s\" of access method %s contains operator %s with invalid " +"strategy number %d" msgstr "" -"ÑемейÑтво операторов brin \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ номером " -"Ñтратегии %d" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит оператор %s Ñ " +"неправильным номером Ñтратегии %d" -#: access/brin/brin_validate.c:182 +#: access/brin/brin_validate.c:182 access/gin/ginvalidate.c:192 +#: access/hash/hashvalidate.c:164 access/nbtree/nbtvalidate.c:145 +#: access/spgist/spgvalidate.c:159 #, c-format msgid "" -"brin operator family \"%s\" contains invalid ORDER BY specification for " -"operator %s" +"operator family \"%s\" of access method %s contains invalid ORDER BY " +"specification for operator %s" msgstr "" -"ÑемейÑтво операторов brin \"%s\" Ñодержит некорректное определение ORDER BY " -"Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит некорректное " +"определение ORDER BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" -#: access/brin/brin_validate.c:195 +#: access/brin/brin_validate.c:195 access/gin/ginvalidate.c:205 +#: access/gist/gistvalidate.c:225 access/hash/hashvalidate.c:177 +#: access/nbtree/nbtvalidate.c:158 access/spgist/spgvalidate.c:172 #, c-format -msgid "brin operator family \"%s\" contains operator %s with wrong signature" +msgid "" +"operator family \"%s\" of access method %s contains operator %s with wrong " +"signature" msgstr "" -"ÑемейÑтво операторов brin \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит оператор %s Ñ " +"неподходÑщим объÑвлением" -#: access/brin/brin_validate.c:233 +#: access/brin/brin_validate.c:233 access/hash/hashvalidate.c:217 +#: access/nbtree/nbtvalidate.c:200 access/spgist/spgvalidate.c:200 #, c-format -msgid "brin operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "в ÑемейÑтве операторов brin \"%s\" нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" +msgid "" +"operator family \"%s\" of access method %s is missing operator(s) for types " +"%s and %s" +msgstr "" +"в ÑемейÑтве операторов \"%s\" метода доÑтупа %s нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² " +"%s и %s" #: access/brin/brin_validate.c:243 #, c-format msgid "" -"brin operator family \"%s\" is missing support function(s) for types %s and " -"%s" +"operator family \"%s\" of access method %s is missing support function(s) " +"for types %s and %s" msgstr "" -"в ÑемейÑтве операторов brin \"%s\" нет опорных функций Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" +"в ÑемейÑтве операторов \"%s\" метода доÑтупа %s нет опорных функций Ð´Ð»Ñ " +"типов %s и %s" -#: access/brin/brin_validate.c:256 +#: access/brin/brin_validate.c:256 access/hash/hashvalidate.c:231 +#: access/nbtree/nbtvalidate.c:224 access/spgist/spgvalidate.c:233 #, c-format -msgid "brin operator class \"%s\" is missing operator(s)" -msgstr "в клаÑÑе операторов brin \"%s\" нет оператора(ов)" +msgid "operator class \"%s\" of access method %s is missing operator(s)" +msgstr "в клаÑÑе операторов \"%s\" метода доÑтупа %s нет оператора(ов)" -#: access/brin/brin_validate.c:267 +#: access/brin/brin_validate.c:267 access/gin/ginvalidate.c:246 +#: access/gist/gistvalidate.c:264 #, c-format -msgid "brin operator class \"%s\" is missing support function %d" -msgstr "в клаÑÑе операторов brin \"%s\" нет опорной функции %d" +msgid "" +"operator class \"%s\" of access method %s is missing support function %d" +msgstr "в клаÑÑе операторов \"%s\" метода доÑтупа %s нет опорной функции %d" #: access/common/heaptuple.c:708 access/common/heaptuple.c:1339 #, c-format @@ -486,8 +509,8 @@ msgstr "чиÑло Ñтолбцов индекÑа (%d) превышает пр msgid "index row requires %zu bytes, maximum size is %zu" msgstr "Ñтрока индекÑа требует байт: %zu, при макÑимуме: %zu" -#: access/common/printtup.c:292 tcop/fastpath.c:182 tcop/fastpath.c:544 -#: tcop/postgres.c:1719 +#: access/common/printtup.c:292 tcop/fastpath.c:182 tcop/fastpath.c:532 +#: tcop/postgres.c:1711 #, c-format msgid "unsupported format code: %d" msgstr "неподдерживаемый код формата: %d" @@ -587,19 +610,11 @@ msgstr "Ñлишком длинный ÑпиÑок указателей" msgid "Reduce maintenance_work_mem." msgstr "Уменьшите maintenance_work_mem." -#: access/gin/ginentrypage.c:109 access/gist/gist.c:1337 -#: access/nbtree/nbtinsert.c:576 access/nbtree/nbtsort.c:488 -#: access/spgist/spgdoinsert.c:1907 -#, c-format -msgid "index row size %zu exceeds maximum %zu for index \"%s\"" -msgstr "" -"размер Ñтроки индекÑа (%zu) больше предельного размера (%zu) (Ð¸Ð½Ð´ÐµÐºÑ \"%s\")" - -#: access/gin/ginfast.c:989 access/transam/xlog.c:9858 -#: access/transam/xlog.c:10362 access/transam/xlogfuncs.c:293 -#: access/transam/xlogfuncs.c:320 access/transam/xlogfuncs.c:359 -#: access/transam/xlogfuncs.c:380 access/transam/xlogfuncs.c:401 -#: access/transam/xlogfuncs.c:471 access/transam/xlogfuncs.c:527 +#: access/gin/ginfast.c:989 access/transam/xlog.c:9875 +#: access/transam/xlog.c:10392 access/transam/xlogfuncs.c:288 +#: access/transam/xlogfuncs.c:315 access/transam/xlogfuncs.c:354 +#: access/transam/xlogfuncs.c:375 access/transam/xlogfuncs.c:396 +#: access/transam/xlogfuncs.c:466 access/transam/xlogfuncs.c:522 #, c-format msgid "recovery is in progress" msgstr "идёт процеÑÑ Ð²Ð¾ÑÑтановлениÑ" @@ -630,67 +645,23 @@ msgstr "" msgid "To fix this, do REINDEX INDEX \"%s\"." msgstr "Ð”Ð»Ñ Ð¸ÑÐ¿Ñ€Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ð²Ñ‹Ð¿Ð¾Ð»Ð½Ð¸Ñ‚Ðµ REINDEX INDEX \"%s\"." -#: access/gin/ginvalidate.c:92 -#, c-format -msgid "" -"gin operator family \"%s\" contains support procedure %s with cross-type " -"registration" -msgstr "" -"ÑемейÑтво операторов gin \"%s\" Ñодержит опорную процедуру %s Ñ Ð¼ÐµÐ¶Ñ‚Ð¸Ð¿Ð¾Ð²Ð¾Ð¹ " -"региÑтрацией" - -#: access/gin/ginvalidate.c:148 -#, c-format -msgid "" -"gin operator family \"%s\" contains function %s with invalid support number " -"%d" -msgstr "" -"ÑемейÑтво операторов gin \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ опорным " -"номером %d" - -#: access/gin/ginvalidate.c:160 +#: access/gin/ginvalidate.c:92 access/gist/gistvalidate.c:92 +#: access/hash/hashvalidate.c:98 access/spgist/spgvalidate.c:92 #, c-format msgid "" -"gin operator family \"%s\" contains function %s with wrong signature for " -"support number %d" +"operator family \"%s\" of access method %s contains support procedure %s " +"with different left and right input types" msgstr "" -"ÑемейÑтво операторов gin \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит опорную процедуру %s " +"Ñ Ð¼ÐµÐ¶Ñ‚Ð¸Ð¿Ð¾Ð²Ð¾Ð¹ региÑтрацией" -#: access/gin/ginvalidate.c:179 +#: access/gin/ginvalidate.c:256 #, c-format msgid "" -"gin operator family \"%s\" contains operator %s with invalid strategy number " +"operator class \"%s\" of access method %s is missing support function %d or " "%d" msgstr "" -"ÑемейÑтво операторов gin \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ номером " -"Ñтратегии %d" - -#: access/gin/ginvalidate.c:192 -#, c-format -msgid "" -"gin operator family \"%s\" contains invalid ORDER BY specification for " -"operator %s" -msgstr "" -"ÑемейÑтво операторов gin \"%s\" Ñодержит некорректное определение ORDER BY " -"Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" - -#: access/gin/ginvalidate.c:205 -#, c-format -msgid "gin operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"ÑемейÑтво операторов gin \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением" - -#: access/gin/ginvalidate.c:246 -#, c-format -msgid "gin operator class \"%s\" is missing support function %d" -msgstr "в клаÑÑе операторов gin \"%s\" нет опорной функции %d" - -#: access/gin/ginvalidate.c:256 -#, c-format -msgid "gin operator class \"%s\" is missing support function %d or %d" -msgstr "в клаÑÑе операторов gin \"%s\" нет опорной функции %d или %d" +"в клаÑÑе операторов \"%s\" метода доÑтупа %s нет опорной функции %d или %d" #: access/gist/gist.c:680 access/gist/gistvacuum.c:258 #, c-format @@ -757,71 +728,23 @@ msgstr "в индекÑе \"%s\" неожиданно оказалаÑÑŒ нул msgid "index \"%s\" contains corrupted page at block %u" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" Ñодержит иÑпорченную Ñтраницу в блоке %u" -#: access/gist/gistvalidate.c:92 -#, c-format -msgid "" -"gist operator family \"%s\" contains support procedure %s with cross-type " -"registration" -msgstr "" -"ÑемейÑтво операторов gist \"%s\" Ñодержит опорную процедуру %s Ñ Ð¼ÐµÐ¶Ñ‚Ð¸Ð¿Ð¾Ð²Ð¾Ð¹ " -"региÑтрацией" - -#: access/gist/gistvalidate.c:145 -#, c-format -msgid "" -"gist operator family \"%s\" contains function %s with invalid support number " -"%d" -msgstr "" -"ÑемейÑтво операторов gist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ опорным " -"номером %d" - -#: access/gist/gistvalidate.c:157 -#, c-format -msgid "" -"gist operator family \"%s\" contains function %s with wrong signature for " -"support number %d" -msgstr "" -"ÑемейÑтво операторов gist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" - -#: access/gist/gistvalidate.c:177 -#, c-format -msgid "" -"gist operator family \"%s\" contains operator %s with invalid strategy " -"number %d" -msgstr "" -"ÑемейÑтво операторов gist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ номером " -"Ñтратегии %d" - #: access/gist/gistvalidate.c:195 #, c-format msgid "" -"gist operator family \"%s\" contains unsupported ORDER BY specification for " -"operator %s" +"operator family \"%s\" of access method %s contains unsupported ORDER BY " +"specification for operator %s" msgstr "" -"ÑемейÑтво операторов gist \"%s\" Ñодержит неподдерживаемое определение ORDER " -"BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит неподдерживаемое " +"определение ORDER BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" #: access/gist/gistvalidate.c:206 #, c-format msgid "" -"gist operator family \"%s\" contains incorrect ORDER BY opfamily " -"specification for operator %s" -msgstr "" -"ÑемейÑтво операторов gist \"%s\" Ñодержит некорректное определение ORDER BY " -"Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" - -#: access/gist/gistvalidate.c:225 -#, c-format -msgid "gist operator family \"%s\" contains operator %s with wrong signature" +"operator family \"%s\" of access method %s contains incorrect ORDER BY " +"opfamily specification for operator %s" msgstr "" -"ÑемейÑтво операторов gist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением" - -#: access/gist/gistvalidate.c:264 -#, c-format -msgid "gist operator class \"%s\" is missing support function %d" -msgstr "в клаÑÑе операторов gist \"%s\" нет опорной функции %d" +"ÑемейÑтво операторов \"%s\" метода доÑтупа %s Ñодержит некорректное " +"определение ORDER BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" #: access/hash/hashinsert.c:70 #, c-format @@ -854,79 +777,21 @@ msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" не ÑвлÑетÑÑ Ñ…ÐµÑˆ-индекÑом" msgid "index \"%s\" has wrong hash version" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" имеет неправильную верÑию хеша" -#: access/hash/hashvalidate.c:98 -#, c-format -msgid "" -"hash operator family \"%s\" contains support procedure %s with cross-type " -"registration" -msgstr "" -"ÑемейÑтво операторов hash \"%s\" Ñодержит опорную процедуру %s Ñ Ð¼ÐµÐ¶Ñ‚Ð¸Ð¿Ð¾Ð²Ð¾Ð¹ " -"региÑтрацией" - -#: access/hash/hashvalidate.c:113 -#, c-format -msgid "" -"hash operator family \"%s\" contains function %s with wrong signature for " -"support number %d" -msgstr "" -"ÑемейÑтво операторов hash \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" - -#: access/hash/hashvalidate.c:130 -#, c-format -msgid "" -"hash operator family \"%s\" contains function %s with invalid support number " -"%d" -msgstr "" -"ÑемейÑтво операторов hash \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ опорным " -"номером %d" - -#: access/hash/hashvalidate.c:151 -#, c-format -msgid "" -"hash operator family \"%s\" contains operator %s with invalid strategy " -"number %d" -msgstr "" -"ÑемейÑтво операторов hash \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ номером " -"Ñтратегии %d" - -#: access/hash/hashvalidate.c:164 +#: access/hash/hashvalidate.c:189 #, c-format msgid "" -"hash operator family \"%s\" contains invalid ORDER BY specification for " +"operator family \"%s\" of access method %s lacks support function for " "operator %s" msgstr "" -"ÑемейÑтво операторов hash \"%s\" Ñодержит некорректное определение ORDER BY " +"в ÑемейÑтве операторов \"%s\" метода доÑтупа %s не хватает опорной функции " "Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" -#: access/hash/hashvalidate.c:177 -#, c-format -msgid "hash operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"ÑемейÑтво операторов hash \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением" - -#: access/hash/hashvalidate.c:189 +#: access/hash/hashvalidate.c:247 access/nbtree/nbtvalidate.c:241 #, c-format -msgid "hash operator family \"%s\" lacks support function for operator %s" +msgid "" +"operator family \"%s\" of access method %s is missing cross-type operator(s)" msgstr "" -"в ÑемейÑтве операторов hash \"%s\" не хватает опорной функции Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° " -"%s" - -#: access/hash/hashvalidate.c:217 -#, c-format -msgid "hash operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "в ÑемейÑтве операторов hash \"%s\" нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" - -#: access/hash/hashvalidate.c:231 -#, c-format -msgid "hash operator class \"%s\" is missing operator(s)" -msgstr "в клаÑÑе операторов hash \"%s\" нет оператора(ов)" - -#: access/hash/hashvalidate.c:247 -#, c-format -msgid "hash operator family \"%s\" is missing cross-type operator(s)" -msgstr "в ÑемейÑтве операторов hash \"%s\" нет межтипового оператора(ов)" +"в ÑемейÑтве операторов \"%s\" метода доÑтупа %s нет межтипового оператора(ов)" #: access/heap/heapam.c:1295 access/heap/heapam.c:1323 #: access/heap/heapam.c:1355 catalog/aclchk.c:1756 @@ -935,8 +800,8 @@ msgid "\"%s\" is an index" msgstr "\"%s\" - Ñто индекÑ" #: access/heap/heapam.c:1300 access/heap/heapam.c:1328 -#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9081 -#: commands/tablecmds.c:12189 +#: access/heap/heapam.c:1360 catalog/aclchk.c:1763 commands/tablecmds.c:9095 +#: commands/tablecmds.c:12203 #, c-format msgid "\"%s\" is a composite type" msgstr "\"%s\" - Ñто ÑоÑтавной тип" @@ -956,7 +821,7 @@ msgstr "удалÑÑ‚ÑŒ кортежи во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… msgid "attempted to delete invisible tuple" msgstr "попытка ÑƒÐ´Ð°Ð»ÐµÐ½Ð¸Ñ Ð½ÐµÐ²Ð¸Ð´Ð¸Ð¼Ð¾Ð³Ð¾ кортежа" -#: access/heap/heapam.c:3489 access/heap/heapam.c:6240 +#: access/heap/heapam.c:3489 access/heap/heapam.c:6274 #, c-format msgid "cannot update tuples during a parallel operation" msgstr "изменÑÑ‚ÑŒ кортежи во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" @@ -966,8 +831,8 @@ msgstr "изменÑÑ‚ÑŒ кортежи во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… msgid "attempted to update invisible tuple" msgstr "попытка Ð¸Ð·Ð¼ÐµÐ½ÐµÐ½Ð¸Ñ Ð½ÐµÐ²Ð¸Ð´Ð¸Ð¼Ð¾Ð³Ð¾ кортежа" -#: access/heap/heapam.c:4963 access/heap/heapam.c:5001 -#: access/heap/heapam.c:5253 executor/execMain.c:2314 +#: access/heap/heapam.c:4964 access/heap/heapam.c:5002 +#: access/heap/heapam.c:5254 executor/execMain.c:2314 #, c-format msgid "could not obtain lock on row in relation \"%s\"" msgstr "не удалоÑÑŒ получить блокировку Ñтроки в таблице \"%s\"" @@ -984,10 +849,10 @@ msgstr "не удалоÑÑŒ запиÑать в файл \"%s\" (запиÑан #: access/heap/rewriteheap.c:963 access/heap/rewriteheap.c:1175 #: access/heap/rewriteheap.c:1272 access/transam/timeline.c:407 -#: access/transam/timeline.c:483 access/transam/xlog.c:3087 -#: access/transam/xlog.c:3249 replication/logical/snapbuild.c:1605 -#: replication/slot.c:1088 replication/slot.c:1173 storage/file/fd.c:624 -#: storage/file/fd.c:3052 storage/smgr/md.c:1041 storage/smgr/md.c:1274 +#: access/transam/timeline.c:483 access/transam/xlog.c:3093 +#: access/transam/xlog.c:3255 replication/logical/snapbuild.c:1605 +#: replication/slot.c:1105 replication/slot.c:1190 storage/file/fd.c:631 +#: storage/file/fd.c:3129 storage/smgr/md.c:1041 storage/smgr/md.c:1274 #: storage/smgr/md.c:1447 utils/misc/guc.c:6885 #, c-format msgid "could not fsync file \"%s\": %m" @@ -995,10 +860,10 @@ msgstr "не удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ файл \" #: access/heap/rewriteheap.c:1018 access/heap/rewriteheap.c:1138 #: access/transam/timeline.c:315 access/transam/timeline.c:461 -#: access/transam/xlog.c:3043 access/transam/xlog.c:3192 -#: access/transam/xlog.c:10192 access/transam/xlog.c:10230 -#: access/transam/xlog.c:10603 postmaster/postmaster.c:4364 -#: replication/logical/origin.c:542 replication/slot.c:1045 +#: access/transam/xlog.c:3049 access/transam/xlog.c:3198 +#: access/transam/xlog.c:10209 access/transam/xlog.c:10247 +#: access/transam/xlog.c:10636 postmaster/postmaster.c:4387 +#: replication/logical/origin.c:542 replication/slot.c:1062 #: storage/file/copydir.c:162 storage/smgr/md.c:327 utils/time/snapmgr.c:1275 #, c-format msgid "could not create file \"%s\": %m" @@ -1009,7 +874,7 @@ msgstr "Ñоздать файл \"%s\" не удалоÑÑŒ: %m" msgid "could not truncate file \"%s\" to %u: %m" msgstr "не удалоÑÑŒ обрезать файл \"%s\" до нужного размера (%u): %m" -#: access/heap/rewriteheap.c:1154 replication/walsender.c:481 +#: access/heap/rewriteheap.c:1154 replication/walsender.c:486 #: storage/smgr/md.c:1899 #, c-format msgid "could not seek to end of file \"%s\": %m" @@ -1017,11 +882,11 @@ msgstr "не удалоÑÑŒ перейти к концу файла \"%s\": %m" #: access/heap/rewriteheap.c:1165 access/transam/timeline.c:367 #: access/transam/timeline.c:401 access/transam/timeline.c:477 -#: access/transam/xlog.c:3078 access/transam/xlog.c:3242 -#: postmaster/postmaster.c:4374 postmaster/postmaster.c:4384 -#: replication/logical/origin.c:551 replication/logical/origin.c:587 -#: replication/logical/origin.c:603 replication/logical/snapbuild.c:1589 -#: replication/slot.c:1074 storage/file/copydir.c:187 +#: access/transam/xlog.c:3084 access/transam/xlog.c:3248 +#: postmaster/postmaster.c:4397 postmaster/postmaster.c:4407 +#: replication/logical/origin.c:551 replication/logical/origin.c:590 +#: replication/logical/origin.c:606 replication/logical/snapbuild.c:1589 +#: replication/slot.c:1091 storage/file/copydir.c:187 #: utils/init/miscinit.c:1228 utils/init/miscinit.c:1237 #: utils/init/miscinit.c:1244 utils/misc/guc.c:6846 utils/misc/guc.c:6877 #: utils/misc/guc.c:8727 utils/misc/guc.c:8741 utils/time/snapmgr.c:1280 @@ -1030,12 +895,12 @@ msgstr "не удалоÑÑŒ перейти к концу файла \"%s\": %m" msgid "could not write to file \"%s\": %m" msgstr "запиÑать в файл \"%s\" не удалоÑÑŒ: %m" -#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10441 +#: access/heap/rewriteheap.c:1248 access/transam/xlog.c:10471 #: access/transam/xlogarchive.c:114 access/transam/xlogarchive.c:468 -#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2632 -#: replication/logical/reorderbuffer.c:2689 -#: replication/logical/snapbuild.c:1533 replication/logical/snapbuild.c:1908 -#: replication/slot.c:1147 storage/ipc/dsm.c:326 storage/smgr/md.c:427 +#: replication/logical/origin.c:529 replication/logical/reorderbuffer.c:2633 +#: replication/logical/reorderbuffer.c:2690 +#: replication/logical/snapbuild.c:1538 replication/logical/snapbuild.c:1901 +#: replication/slot.c:1164 storage/ipc/dsm.c:326 storage/smgr/md.c:427 #: storage/smgr/md.c:476 storage/smgr/md.c:1394 #, c-format msgid "could not remove file \"%s\": %m" @@ -1043,17 +908,17 @@ msgstr "не удалоÑÑŒ Ñтереть файл \"%s\": %m" #: access/heap/rewriteheap.c:1262 access/transam/timeline.c:111 #: access/transam/timeline.c:236 access/transam/timeline.c:334 -#: access/transam/xlog.c:3019 access/transam/xlog.c:3136 -#: access/transam/xlog.c:3177 access/transam/xlog.c:3450 -#: access/transam/xlog.c:3528 access/transam/xlogutils.c:701 +#: access/transam/xlog.c:3025 access/transam/xlog.c:3142 +#: access/transam/xlog.c:3183 access/transam/xlog.c:3456 +#: access/transam/xlog.c:3534 access/transam/xlogutils.c:701 #: replication/basebackup.c:403 replication/basebackup.c:1150 -#: replication/logical/origin.c:658 replication/logical/reorderbuffer.c:2156 -#: replication/logical/reorderbuffer.c:2402 -#: replication/logical/reorderbuffer.c:3081 +#: replication/logical/origin.c:661 replication/logical/reorderbuffer.c:2156 +#: replication/logical/reorderbuffer.c:2403 +#: replication/logical/reorderbuffer.c:3082 #: replication/logical/snapbuild.c:1582 replication/logical/snapbuild.c:1666 -#: replication/slot.c:1162 replication/walsender.c:474 -#: replication/walsender.c:2102 storage/file/copydir.c:155 -#: storage/file/fd.c:607 storage/file/fd.c:2964 storage/file/fd.c:3031 +#: replication/slot.c:1179 replication/walsender.c:479 +#: replication/walsender.c:2144 storage/file/copydir.c:155 +#: storage/file/fd.c:614 storage/file/fd.c:3041 storage/file/fd.c:3108 #: storage/smgr/md.c:609 utils/error/elog.c:1879 utils/init/miscinit.c:1163 #: utils/init/miscinit.c:1284 utils/init/miscinit.c:1362 utils/misc/guc.c:7105 #: utils/misc/guc.c:7138 @@ -1072,8 +937,8 @@ msgid "index access method \"%s\" does not have a handler" msgstr "Ð´Ð»Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð° доÑтупа индекÑа \"%s\" не задан обработчик" #: access/index/indexam.c:155 catalog/objectaddress.c:1196 -#: commands/indexcmds.c:1799 commands/tablecmds.c:242 -#: commands/tablecmds.c:12180 +#: commands/indexcmds.c:1800 commands/tablecmds.c:242 +#: commands/tablecmds.c:12194 #, c-format msgid "\"%s\" is not an index" msgstr "\"%s\" - Ñто не индекÑ" @@ -1111,7 +976,7 @@ msgstr "" "полнотекÑтовую индекÑацию." #: access/nbtree/nbtpage.c:168 access/nbtree/nbtpage.c:371 -#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1702 +#: access/nbtree/nbtpage.c:458 parser/parse_utilcmd.c:1703 #, c-format msgid "index \"%s\" is not a btree" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" не ÑвлÑетÑÑ b-деревом" @@ -1137,148 +1002,28 @@ msgstr "" "Причиной тому могло быть прерывание операции VACUUM в верÑии 9.3 или Ñтарее, " "до обновлениÑ. Этот Ð¸Ð½Ð´ÐµÐºÑ Ð½ÑƒÐ¶Ð½Ð¾ переÑтроить (REINDEX)." -#: access/nbtree/nbtvalidate.c:100 -#, c-format -msgid "" -"btree operator family \"%s\" contains function %s with invalid support " -"number %d" -msgstr "" -"ÑемейÑтво операторов btree \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ опорным " -"номером %d" - -#: access/nbtree/nbtvalidate.c:112 -#, c-format -msgid "" -"btree operator family \"%s\" contains function %s with wrong signature for " -"support number %d" -msgstr "" -"ÑемейÑтво операторов btree \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" - -#: access/nbtree/nbtvalidate.c:132 -#, c-format -msgid "" -"btree operator family \"%s\" contains operator %s with invalid strategy " -"number %d" -msgstr "" -"ÑемейÑтво операторов btree \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " -"номером Ñтратегии %d" - -#: access/nbtree/nbtvalidate.c:145 -#, c-format -msgid "" -"btree operator family \"%s\" contains invalid ORDER BY specification for " -"operator %s" -msgstr "" -"ÑемейÑтво операторов btree \"%s\" Ñодержит некорректное определение ORDER BY " -"Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" - -#: access/nbtree/nbtvalidate.c:158 -#, c-format -msgid "btree operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"ÑемейÑтво операторов btree \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением" - -#: access/nbtree/nbtvalidate.c:200 -#, c-format -msgid "btree operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "" -"в ÑемейÑтве операторов btree \"%s\" нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" - #: access/nbtree/nbtvalidate.c:210 #, c-format msgid "" -"btree operator family \"%s\" is missing support function for types %s and %s" +"operator family \"%s\" of access method %s is missing support function for " +"types %s and %s" msgstr "" -"в ÑемейÑтве операторов btree \"%s\" нет опорных функций Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" - -#: access/nbtree/nbtvalidate.c:224 -#, c-format -msgid "btree operator class \"%s\" is missing operator(s)" -msgstr "в клаÑÑе операторов btree \"%s\" нет оператора(ов)" - -#: access/nbtree/nbtvalidate.c:241 -#, c-format -msgid "btree operator family \"%s\" is missing cross-type operator(s)" -msgstr "в ÑемейÑтве операторов btree \"%s\" нет межтипового оператора(ов)" +"в ÑемейÑтве операторов \"%s\" метода доÑтупа %s нет опорной функции Ð´Ð»Ñ " +"типов %s и %s" #: access/spgist/spgutils.c:700 #, c-format msgid "SP-GiST inner tuple size %zu exceeds maximum %zu" msgstr "внутренний размер кортежа SP-GiST (%zu) превышает макÑимум (%zu)" -#: access/spgist/spgvalidate.c:92 -#, c-format -msgid "" -"spgist operator family \"%s\" contains support procedure %s with cross-type " -"registration" -msgstr "" -"ÑемейÑтво операторов spgist \"%s\" Ñодержит опорную процедуру %s Ñ " -"межтиповой региÑтрацией" - -#: access/spgist/spgvalidate.c:115 -#, c-format -msgid "" -"spgist operator family \"%s\" contains function %s with invalid support " -"number %d" -msgstr "" -"ÑемейÑтво операторов spgist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " -"опорным номером %d" - -#: access/spgist/spgvalidate.c:127 -#, c-format -msgid "" -"spgist operator family \"%s\" contains function %s with wrong signature for " -"support number %d" -msgstr "" -"ÑемейÑтво операторов spgist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" - -#: access/spgist/spgvalidate.c:146 -#, c-format -msgid "" -"spgist operator family \"%s\" contains operator %s with invalid strategy " -"number %d" -msgstr "" -"ÑемейÑтво операторов spgist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " -"номером Ñтратегии %d" - -#: access/spgist/spgvalidate.c:159 -#, c-format -msgid "" -"spgist operator family \"%s\" contains invalid ORDER BY specification for " -"operator %s" -msgstr "" -"ÑемейÑтво операторов spgist \"%s\" Ñодержит некорректное определение ORDER " -"BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" - -#: access/spgist/spgvalidate.c:172 -#, c-format -msgid "spgist operator family \"%s\" contains operator %s with wrong signature" -msgstr "" -"ÑемейÑтво операторов spgist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " -"объÑвлением" - -#: access/spgist/spgvalidate.c:200 -#, c-format -msgid "" -"spgist operator family \"%s\" is missing operator(s) for types %s and %s" -msgstr "" -"в ÑемейÑтве операторов spgist \"%s\" нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" - #: access/spgist/spgvalidate.c:220 #, c-format msgid "" -"spgist operator family \"%s\" is missing support function %d for type %s" +"operator family \"%s\" of access method %s is missing support function %d " +"for type %s" msgstr "" -"в ÑемейÑтве операторов spgist \"%s\" отÑутÑтвует Ð¾Ð¿Ð¾Ñ€Ð½Ð°Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ %d Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° " -"%s" - -#: access/spgist/spgvalidate.c:233 -#, c-format -msgid "spgist operator class \"%s\" is missing operator(s)" -msgstr "в клаÑÑе операторов spgist \"%s\" нет оператора(ов)" +"в ÑемейÑтве операторов \"%s\" метода доÑтупа %s нет опорной функции %d Ð´Ð»Ñ " +"типа %s" #: access/tablesample/bernoulli.c:152 access/tablesample/system.c:156 #, c-format @@ -1505,78 +1250,78 @@ msgstr "" msgid "invalid MultiXactId: %u" msgstr "неверный MultiXactId: %u" -#: access/transam/parallel.c:589 +#: access/transam/parallel.c:610 #, c-format msgid "postmaster exited during a parallel transaction" msgstr "postmaster завершилÑÑ Ð² процеÑÑе параллельной транзакции" -#: access/transam/parallel.c:774 +#: access/transam/parallel.c:799 #, c-format msgid "lost connection to parallel worker" msgstr "потерÑно подключение к параллельному иÑполнителю" -#: access/transam/parallel.c:833 access/transam/parallel.c:835 +#: access/transam/parallel.c:858 access/transam/parallel.c:860 msgid "parallel worker" msgstr "параллельный иÑполнитель" -#: access/transam/parallel.c:974 +#: access/transam/parallel.c:1001 #, c-format msgid "could not map dynamic shared memory segment" msgstr "не удалоÑÑŒ отобразить динамичеÑкий Ñегмент разделÑемой памÑти" -#: access/transam/parallel.c:979 +#: access/transam/parallel.c:1006 #, c-format msgid "invalid magic number in dynamic shared memory segment" msgstr "неверное магичеÑкое чиÑло в динамичеÑком Ñегменте разделÑемой памÑти" -#: access/transam/slru.c:665 +#: access/transam/slru.c:669 #, c-format msgid "file \"%s\" doesn't exist, reading as zeroes" msgstr "файл \"%s\" не ÑущеÑтвует, ÑчитаетÑÑ Ð½ÑƒÐ»ÐµÐ²Ñ‹Ð¼" -#: access/transam/slru.c:895 access/transam/slru.c:901 -#: access/transam/slru.c:908 access/transam/slru.c:915 -#: access/transam/slru.c:922 access/transam/slru.c:929 +#: access/transam/slru.c:899 access/transam/slru.c:905 +#: access/transam/slru.c:912 access/transam/slru.c:919 +#: access/transam/slru.c:926 access/transam/slru.c:933 #, c-format msgid "could not access status of transaction %u" msgstr "не удалоÑÑŒ получить ÑоÑтоÑние транзакции %u" -#: access/transam/slru.c:896 +#: access/transam/slru.c:900 #, c-format msgid "Could not open file \"%s\": %m." msgstr "Ðе удалоÑÑŒ открыть файл \"%s\": %m." -#: access/transam/slru.c:902 +#: access/transam/slru.c:906 #, c-format msgid "Could not seek in file \"%s\" to offset %u: %m." msgstr "Ðе удалоÑÑŒ перемеÑтитьÑÑ Ð² файле \"%s\" к Ñмещению %u: %m." -#: access/transam/slru.c:909 +#: access/transam/slru.c:913 #, c-format msgid "Could not read from file \"%s\" at offset %u: %m." msgstr "Ðе удалоÑÑŒ прочитать файл \"%s\" (по Ñмещению %u): %m." -#: access/transam/slru.c:916 +#: access/transam/slru.c:920 #, c-format msgid "Could not write to file \"%s\" at offset %u: %m." msgstr "Ðе удалоÑÑŒ запиÑать в файл \"%s\" (по Ñмещению %u): %m." -#: access/transam/slru.c:923 +#: access/transam/slru.c:927 #, c-format msgid "Could not fsync file \"%s\": %m." msgstr "Ðе удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ файл \"%s\": %m." -#: access/transam/slru.c:930 +#: access/transam/slru.c:934 #, c-format msgid "Could not close file \"%s\": %m." msgstr "Ðе удалоÑÑŒ закрыть файл \"%s\": %m." -#: access/transam/slru.c:1185 +#: access/transam/slru.c:1189 #, c-format msgid "could not truncate directory \"%s\": apparent wraparound" msgstr "не удалоÑÑŒ очиÑтить каталог \"%s\": видимо, произошло наложение" -#: access/transam/slru.c:1240 access/transam/slru.c:1296 +#: access/transam/slru.c:1244 access/transam/slru.c:1300 #, c-format msgid "removing file \"%s\"" msgstr "удалÑетÑÑ Ñ„Ð°Ð¹Ð» \"%s\"" @@ -1618,8 +1363,8 @@ msgstr "" "Идентификаторы линий времени должны быть меньше идентификатора линии-потомка." #: access/transam/timeline.c:412 access/transam/timeline.c:488 -#: access/transam/xlog.c:3093 access/transam/xlog.c:3254 -#: access/transam/xlogfuncs.c:690 commands/copy.c:1708 +#: access/transam/xlog.c:3099 access/transam/xlog.c:3260 +#: access/transam/xlogfuncs.c:685 commands/copy.c:1709 #: storage/file/copydir.c:201 #, c-format msgid "could not close file \"%s\": %m" @@ -1716,7 +1461,7 @@ msgstr "не удалоÑÑŒ получить информацию о файле msgid "could not read two-phase state file \"%s\": %m" msgstr "не удалоÑÑŒ прочитать файл ÑоÑтоÑÐ½Ð¸Ñ 2PC \"%s\": %m" -#: access/transam/twophase.c:1263 access/transam/xlog.c:6109 +#: access/transam/twophase.c:1263 access/transam/xlog.c:6115 #, c-format msgid "Failed while allocating an XLog reading processor." msgstr "Ðе удалоÑÑŒ размеÑтить обработчик журнала транзакций." @@ -1851,31 +1596,31 @@ msgstr "в одной транзакции не может быть больше msgid "maximum number of committed subtransactions (%d) exceeded" msgstr "превышен предел чиÑла зафикÑированных подтранзакций (%d)" -#: access/transam/xact.c:2263 +#: access/transam/xact.c:2260 #, c-format msgid "cannot PREPARE a transaction that has operated on temporary tables" msgstr "" -"выполнить PREPARE Ð´Ð»Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¸, оперирующей Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð½Ñ‹Ð¼Ð¸ таблицами, нельзÑ" +"Ð½ÐµÐ»ÑŒÐ·Ñ Ð²Ñ‹Ð¿Ð¾Ð»Ð½Ð¸Ñ‚ÑŒ PREPARE Ð´Ð»Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¸, оперирующей Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð½Ñ‹Ð¼Ð¸ таблицами" -#: access/transam/xact.c:2273 +#: access/transam/xact.c:2270 #, c-format msgid "cannot PREPARE a transaction that has exported snapshots" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ Ð²Ñ‹Ð¿Ð¾Ð»Ð½Ð¸Ñ‚ÑŒ PREPARE Ð´Ð»Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¸, Ñнимки которой ÑкÑпортированы" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3155 +#: access/transam/xact.c:3148 #, c-format msgid "%s cannot run inside a transaction block" msgstr "%s не может выполнÑÑ‚ÑŒÑÑ Ð²Ð½ÑƒÑ‚Ñ€Ð¸ блока транзакции" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3165 +#: access/transam/xact.c:3158 #, c-format msgid "%s cannot run inside a subtransaction" msgstr "%s не может выполнÑÑ‚ÑŒÑÑ Ð²Ð½ÑƒÑ‚Ñ€Ð¸ подтранзакции" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3175 +#: access/transam/xact.c:3168 #, c-format msgid "%s cannot be executed from a function or multi-command string" msgstr "" @@ -1883,162 +1628,162 @@ msgstr "" "команд" #. translator: %s represents an SQL statement name -#: access/transam/xact.c:3246 +#: access/transam/xact.c:3239 #, c-format msgid "%s can only be used in transaction blocks" msgstr "%s может выполнÑÑ‚ÑŒÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ внутри блоков транзакций" -#: access/transam/xact.c:3430 +#: access/transam/xact.c:3423 #, c-format msgid "there is already a transaction in progress" msgstr "Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñ ÑƒÐ¶Ðµ выполнÑетÑÑ" -#: access/transam/xact.c:3598 access/transam/xact.c:3701 +#: access/transam/xact.c:3591 access/transam/xact.c:3694 #, c-format msgid "there is no transaction in progress" msgstr "нет незавершённой транзакции" -#: access/transam/xact.c:3609 +#: access/transam/xact.c:3602 #, c-format msgid "cannot commit during a parallel operation" msgstr "фикÑировать транзакции во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" -#: access/transam/xact.c:3712 +#: access/transam/xact.c:3705 #, c-format msgid "cannot abort during a parallel operation" msgstr "прерывание во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций невозможно" -#: access/transam/xact.c:3754 +#: access/transam/xact.c:3747 #, c-format msgid "cannot define savepoints during a parallel operation" msgstr "определÑÑ‚ÑŒ точки ÑÐ¾Ñ…Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ Ð²Ð¾ Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" -#: access/transam/xact.c:3821 +#: access/transam/xact.c:3814 #, c-format msgid "cannot release savepoints during a parallel operation" msgstr "выÑвобождать точки ÑÐ¾Ñ…Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ Ð²Ð¾ Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" -#: access/transam/xact.c:3832 access/transam/xact.c:3884 -#: access/transam/xact.c:3890 access/transam/xact.c:3946 -#: access/transam/xact.c:3996 access/transam/xact.c:4002 +#: access/transam/xact.c:3825 access/transam/xact.c:3877 +#: access/transam/xact.c:3883 access/transam/xact.c:3939 +#: access/transam/xact.c:3989 access/transam/xact.c:3995 #, c-format msgid "no such savepoint" msgstr "нет такой точки ÑохранениÑ" -#: access/transam/xact.c:3934 +#: access/transam/xact.c:3927 #, c-format msgid "cannot rollback to savepoints during a parallel operation" msgstr "откатитьÑÑ Ðº точке ÑÐ¾Ñ…Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ Ð²Ð¾ Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" -#: access/transam/xact.c:4062 +#: access/transam/xact.c:4055 #, c-format msgid "cannot start subtransactions during a parallel operation" msgstr "запуÑкать подтранзакции во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" -#: access/transam/xact.c:4129 +#: access/transam/xact.c:4122 #, c-format msgid "cannot commit subtransactions during a parallel operation" msgstr "фикÑировать подтранзакции во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" -#: access/transam/xact.c:4737 +#: access/transam/xact.c:4751 #, c-format msgid "cannot have more than 2^32-1 subtransactions in a transaction" msgstr "в одной транзакции не может быть больше 2^32-1 подтранзакций" -#: access/transam/xlog.c:2299 +#: access/transam/xlog.c:2305 #, c-format msgid "could not seek in log file %s to offset %u: %m" msgstr "не удалоÑÑŒ перемеÑтитьÑÑ Ð² файле журнала %s к Ñмещению %u: %m" -#: access/transam/xlog.c:2319 +#: access/transam/xlog.c:2325 #, c-format msgid "could not write to log file %s at offset %u, length %zu: %m" msgstr "не удалоÑÑŒ запиÑать в файл журнала %s (Ñмещение: %u, длина: %zu): %m" -#: access/transam/xlog.c:2582 +#: access/transam/xlog.c:2588 #, c-format msgid "updated min recovery point to %X/%X on timeline %u" msgstr "Ð¼Ð¸Ð½Ð¸Ð¼Ð°Ð»ÑŒÐ½Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ° воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð¸Ð·Ð¼ÐµÐ½ÐµÐ½Ð° на %X/%X на линии времени %u" -#: access/transam/xlog.c:3224 +#: access/transam/xlog.c:3230 #, c-format msgid "not enough data in file \"%s\"" msgstr "недоÑтаточно данных в файле\"%s\"" -#: access/transam/xlog.c:3365 +#: access/transam/xlog.c:3371 #, c-format msgid "could not open transaction log file \"%s\": %m" msgstr "не удалоÑÑŒ открыть файл журнала транзакций \"%s\": %m" -#: access/transam/xlog.c:3554 access/transam/xlog.c:5339 +#: access/transam/xlog.c:3560 access/transam/xlog.c:5345 #, c-format msgid "could not close log file %s: %m" msgstr "не удалоÑÑŒ закрыть файл журнала \"%s\": %m" -#: access/transam/xlog.c:3611 access/transam/xlogutils.c:696 -#: replication/walsender.c:2097 +#: access/transam/xlog.c:3617 access/transam/xlogutils.c:696 +#: replication/walsender.c:2139 #, c-format msgid "requested WAL segment %s has already been removed" msgstr "запрошенный Ñегмент WAL %s уже удалён" -#: access/transam/xlog.c:3671 access/transam/xlog.c:3746 -#: access/transam/xlog.c:3944 +#: access/transam/xlog.c:3677 access/transam/xlog.c:3752 +#: access/transam/xlog.c:3950 #, c-format msgid "could not open transaction log directory \"%s\": %m" msgstr "не удалоÑÑŒ открыть каталог журнала транзакций \"%s\": %m" -#: access/transam/xlog.c:3827 +#: access/transam/xlog.c:3833 #, c-format msgid "recycled transaction log file \"%s\"" msgstr "файл журнала транзакций \"%s\" иÑпользуетÑÑ Ð¿Ð¾Ð²Ñ‚Ð¾Ñ€Ð½Ð¾" -#: access/transam/xlog.c:3839 +#: access/transam/xlog.c:3845 #, c-format msgid "removing transaction log file \"%s\"" msgstr "файл журнала транзакций \"%s\" удалÑетÑÑ" -#: access/transam/xlog.c:3859 +#: access/transam/xlog.c:3865 #, c-format msgid "could not rename old transaction log file \"%s\": %m" msgstr "не удалоÑÑŒ переименовать Ñтарый файл журнала транзакций \"%s\": %m" -#: access/transam/xlog.c:3871 +#: access/transam/xlog.c:3877 #, c-format msgid "could not remove old transaction log file \"%s\": %m" msgstr "не удалоÑÑŒ Ñтереть Ñтарый файл журнала транзакций \"%s\": %m" -#: access/transam/xlog.c:3904 access/transam/xlog.c:3914 +#: access/transam/xlog.c:3910 access/transam/xlog.c:3920 #, c-format msgid "required WAL directory \"%s\" does not exist" msgstr "требуемый каталог WAL \"%s\" не ÑущеÑтвует" -#: access/transam/xlog.c:3920 +#: access/transam/xlog.c:3926 #, c-format msgid "creating missing WAL directory \"%s\"" msgstr "ÑоздаётÑÑ Ð¾Ñ‚ÑутÑтвующий каталог WAL \"%s\"" -#: access/transam/xlog.c:3923 +#: access/transam/xlog.c:3929 #, c-format msgid "could not create missing directory \"%s\": %m" msgstr "не удалоÑÑŒ Ñоздать отÑутÑтвующий каталог \"%s\": %m" -#: access/transam/xlog.c:3954 +#: access/transam/xlog.c:3960 #, c-format msgid "removing transaction log backup history file \"%s\"" msgstr "удалÑетÑÑ Ñ„Ð°Ð¹Ð» иÑтории ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð°: \"%s\"" -#: access/transam/xlog.c:4035 +#: access/transam/xlog.c:4041 #, c-format msgid "unexpected timeline ID %u in log segment %s, offset %u" msgstr "неожиданный ID линии времени %u в Ñегменте журнала %s, Ñмещение %u" -#: access/transam/xlog.c:4157 +#: access/transam/xlog.c:4163 #, c-format msgid "new timeline %u is not a child of database system timeline %u" msgstr "" "Ð½Ð¾Ð²Ð°Ñ Ð»Ð¸Ð½Ð¸Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð¸ %u не ÑвлÑетÑÑ Ð¾Ñ‚Ð²ÐµÑ‚Ð²Ð»ÐµÐ½Ð¸ÐµÐ¼ линии времени ÑиÑтемы БД %u" -#: access/transam/xlog.c:4171 +#: access/transam/xlog.c:4177 #, c-format msgid "" "new timeline %u forked off current database system timeline %u before " @@ -2047,56 +1792,56 @@ msgstr "" "Ð½Ð¾Ð²Ð°Ñ Ð»Ð¸Ð½Ð¸Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð¸ %u ответвилаÑÑŒ от текущей линии времени базы данных %u " "до текущей точки воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ %X/%X" -#: access/transam/xlog.c:4190 +#: access/transam/xlog.c:4196 #, c-format msgid "new target timeline is %u" msgstr "Ð½Ð¾Ð²Ð°Ñ Ñ†ÐµÐ»ÐµÐ²Ð°Ñ Ð»Ð¸Ð½Ð¸Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð¸ %u" -#: access/transam/xlog.c:4270 +#: access/transam/xlog.c:4276 #, c-format msgid "could not create control file \"%s\": %m" msgstr "не удалоÑÑŒ Ñоздать файл \"%s\": %m" -#: access/transam/xlog.c:4281 access/transam/xlog.c:4517 +#: access/transam/xlog.c:4287 access/transam/xlog.c:4523 #, c-format msgid "could not write to control file: %m" msgstr "не удалоÑÑŒ запиÑать в файл pg_control: %m" -#: access/transam/xlog.c:4287 access/transam/xlog.c:4523 +#: access/transam/xlog.c:4293 access/transam/xlog.c:4529 #, c-format msgid "could not fsync control file: %m" msgstr "не удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ файл pg_control: %m" -#: access/transam/xlog.c:4292 access/transam/xlog.c:4528 +#: access/transam/xlog.c:4298 access/transam/xlog.c:4534 #, c-format msgid "could not close control file: %m" msgstr "не удалоÑÑŒ закрыть файл pg_control: %m" -#: access/transam/xlog.c:4310 access/transam/xlog.c:4506 +#: access/transam/xlog.c:4316 access/transam/xlog.c:4512 #, c-format msgid "could not open control file \"%s\": %m" msgstr "не удалоÑÑŒ открыть файл \"%s\": %m" -#: access/transam/xlog.c:4316 +#: access/transam/xlog.c:4322 #, c-format msgid "could not read from control file: %m" msgstr "не удалоÑÑŒ прочитать файл pg_control: %m" -#: access/transam/xlog.c:4329 access/transam/xlog.c:4338 -#: access/transam/xlog.c:4362 access/transam/xlog.c:4369 -#: access/transam/xlog.c:4376 access/transam/xlog.c:4381 -#: access/transam/xlog.c:4388 access/transam/xlog.c:4395 -#: access/transam/xlog.c:4402 access/transam/xlog.c:4409 -#: access/transam/xlog.c:4416 access/transam/xlog.c:4423 -#: access/transam/xlog.c:4430 access/transam/xlog.c:4439 -#: access/transam/xlog.c:4446 access/transam/xlog.c:4455 -#: access/transam/xlog.c:4462 access/transam/xlog.c:4471 -#: access/transam/xlog.c:4478 utils/init/miscinit.c:1380 +#: access/transam/xlog.c:4335 access/transam/xlog.c:4344 +#: access/transam/xlog.c:4368 access/transam/xlog.c:4375 +#: access/transam/xlog.c:4382 access/transam/xlog.c:4387 +#: access/transam/xlog.c:4394 access/transam/xlog.c:4401 +#: access/transam/xlog.c:4408 access/transam/xlog.c:4415 +#: access/transam/xlog.c:4422 access/transam/xlog.c:4429 +#: access/transam/xlog.c:4436 access/transam/xlog.c:4445 +#: access/transam/xlog.c:4452 access/transam/xlog.c:4461 +#: access/transam/xlog.c:4468 access/transam/xlog.c:4477 +#: access/transam/xlog.c:4484 utils/init/miscinit.c:1380 #, c-format msgid "database files are incompatible with server" msgstr "файлы базы данных не ÑовмеÑтимы Ñ Ñервером" -#: access/transam/xlog.c:4330 +#: access/transam/xlog.c:4336 #, c-format msgid "" "The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x), " @@ -2105,7 +1850,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ PG_CONTROL_VERSION %d (0x%08x), но " "Ñервер Ñкомпилирован Ñ PG_CONTROL_VERSION %d (0x%08x)." -#: access/transam/xlog.c:4334 +#: access/transam/xlog.c:4340 #, c-format msgid "" "This could be a problem of mismatched byte ordering. It looks like you need " @@ -2114,7 +1859,7 @@ msgstr "" "Возможно, проблема вызвана разным порÑдком байт. КажетÑÑ, вам надо выполнить " "initdb." -#: access/transam/xlog.c:4339 +#: access/transam/xlog.c:4345 #, c-format msgid "" "The database cluster was initialized with PG_CONTROL_VERSION %d, but the " @@ -2123,18 +1868,18 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ PG_CONTROL_VERSION %d, но Ñервер " "Ñкомпилирован Ñ PG_CONTROL_VERSION %d." -#: access/transam/xlog.c:4342 access/transam/xlog.c:4366 -#: access/transam/xlog.c:4373 access/transam/xlog.c:4378 +#: access/transam/xlog.c:4348 access/transam/xlog.c:4372 +#: access/transam/xlog.c:4379 access/transam/xlog.c:4384 #, c-format msgid "It looks like you need to initdb." msgstr "КажетÑÑ, вам надо выполнить initdb." -#: access/transam/xlog.c:4353 +#: access/transam/xlog.c:4359 #, c-format msgid "incorrect checksum in control file" msgstr "ошибка контрольной Ñуммы в файле pg_control" -#: access/transam/xlog.c:4363 +#: access/transam/xlog.c:4369 #, c-format msgid "" "The database cluster was initialized with CATALOG_VERSION_NO %d, but the " @@ -2143,7 +1888,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ CATALOG_VERSION_NO %d, но Ñервер " "Ñкомпилирован Ñ CATALOG_VERSION_NO %d." -#: access/transam/xlog.c:4370 +#: access/transam/xlog.c:4376 #, c-format msgid "" "The database cluster was initialized with MAXALIGN %d, but the server was " @@ -2152,7 +1897,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ MAXALIGN %d, но Ñервер " "Ñкомпилирован Ñ MAXALIGN %d." -#: access/transam/xlog.c:4377 +#: access/transam/xlog.c:4383 #, c-format msgid "" "The database cluster appears to use a different floating-point number format " @@ -2161,7 +1906,7 @@ msgstr "" "КажетÑÑ, в клаÑтере баз данных и в программе Ñервера иÑпользуютÑÑ Ñ€Ð°Ð·Ð½Ñ‹Ðµ " "форматы чиÑел Ñ Ð¿Ð»Ð°Ð²Ð°ÑŽÑ‰ÐµÐ¹ точкой." -#: access/transam/xlog.c:4382 +#: access/transam/xlog.c:4388 #, c-format msgid "" "The database cluster was initialized with BLCKSZ %d, but the server was " @@ -2170,18 +1915,18 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ BLCKSZ %d, но Ñервер Ñкомпилирован " "Ñ BLCKSZ %d." -#: access/transam/xlog.c:4385 access/transam/xlog.c:4392 -#: access/transam/xlog.c:4399 access/transam/xlog.c:4406 -#: access/transam/xlog.c:4413 access/transam/xlog.c:4420 -#: access/transam/xlog.c:4427 access/transam/xlog.c:4434 -#: access/transam/xlog.c:4442 access/transam/xlog.c:4449 -#: access/transam/xlog.c:4458 access/transam/xlog.c:4465 -#: access/transam/xlog.c:4474 access/transam/xlog.c:4481 +#: access/transam/xlog.c:4391 access/transam/xlog.c:4398 +#: access/transam/xlog.c:4405 access/transam/xlog.c:4412 +#: access/transam/xlog.c:4419 access/transam/xlog.c:4426 +#: access/transam/xlog.c:4433 access/transam/xlog.c:4440 +#: access/transam/xlog.c:4448 access/transam/xlog.c:4455 +#: access/transam/xlog.c:4464 access/transam/xlog.c:4471 +#: access/transam/xlog.c:4480 access/transam/xlog.c:4487 #, c-format msgid "It looks like you need to recompile or initdb." msgstr "КажетÑÑ, вам надо перекомпилировать Ñервер или выполнить initdb." -#: access/transam/xlog.c:4389 +#: access/transam/xlog.c:4395 #, c-format msgid "" "The database cluster was initialized with RELSEG_SIZE %d, but the server was " @@ -2190,7 +1935,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ RELSEG_SIZE %d, но Ñервер " "Ñкомпилирован Ñ RELSEG_SIZE %d." -#: access/transam/xlog.c:4396 +#: access/transam/xlog.c:4402 #, c-format msgid "" "The database cluster was initialized with XLOG_BLCKSZ %d, but the server was " @@ -2199,7 +1944,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ XLOG_BLCKSZ %d, но Ñервер " "Ñкомпилирован Ñ XLOG_BLCKSZ %d." -#: access/transam/xlog.c:4403 +#: access/transam/xlog.c:4409 #, c-format msgid "" "The database cluster was initialized with XLOG_SEG_SIZE %d, but the server " @@ -2208,7 +1953,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ XLOG_SEG_SIZE %d, но Ñервер " "Ñкомпилирован Ñ XLOG_SEG_SIZE %d." -#: access/transam/xlog.c:4410 +#: access/transam/xlog.c:4416 #, c-format msgid "" "The database cluster was initialized with NAMEDATALEN %d, but the server was " @@ -2217,7 +1962,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ NAMEDATALEN %d, но Ñервер " "Ñкомпилирован Ñ NAMEDATALEN %d." -#: access/transam/xlog.c:4417 +#: access/transam/xlog.c:4423 #, c-format msgid "" "The database cluster was initialized with INDEX_MAX_KEYS %d, but the server " @@ -2226,7 +1971,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ INDEX_MAX_KEYS %d, но Ñервер " "Ñкомпилирован Ñ INDEX_MAX_KEYS %d." -#: access/transam/xlog.c:4424 +#: access/transam/xlog.c:4430 #, c-format msgid "" "The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d, but the " @@ -2235,7 +1980,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ TOAST_MAX_CHUNK_SIZE %d, но Ñервер " "Ñкомпилирован Ñ TOAST_MAX_CHUNK_SIZE %d." -#: access/transam/xlog.c:4431 +#: access/transam/xlog.c:4437 #, c-format msgid "" "The database cluster was initialized with LOBLKSIZE %d, but the server was " @@ -2244,7 +1989,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ LOBLKSIZE %d, но Ñервер " "Ñкомпилирован Ñ LOBLKSIZE %d." -#: access/transam/xlog.c:4440 +#: access/transam/xlog.c:4446 #, c-format msgid "" "The database cluster was initialized without HAVE_INT64_TIMESTAMP but the " @@ -2253,7 +1998,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован без HAVE_INT64_TIMESTAMP, но Ñервер " "Ñкомпилирован Ñ HAVE_INT64_TIMESTAMP." -#: access/transam/xlog.c:4447 +#: access/transam/xlog.c:4453 #, c-format msgid "" "The database cluster was initialized with HAVE_INT64_TIMESTAMP but the " @@ -2262,7 +2007,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ HAVE_INT64_TIMESTAMP, но Ñервер " "Ñкомпилирован без HAVE_INT64_TIMESTAMP." -#: access/transam/xlog.c:4456 +#: access/transam/xlog.c:4462 #, c-format msgid "" "The database cluster was initialized without USE_FLOAT4_BYVAL but the server " @@ -2271,7 +2016,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован без USE_FLOAT4_BYVAL, но Ñервер " "Ñкомпилирован Ñ USE_FLOAT4_BYVAL." -#: access/transam/xlog.c:4463 +#: access/transam/xlog.c:4469 #, c-format msgid "" "The database cluster was initialized with USE_FLOAT4_BYVAL but the server " @@ -2280,7 +2025,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ USE_FLOAT4_BYVAL, но Ñервер " "Ñкомпилирован без USE_FLOAT4_BYVAL." -#: access/transam/xlog.c:4472 +#: access/transam/xlog.c:4478 #, c-format msgid "" "The database cluster was initialized without USE_FLOAT8_BYVAL but the server " @@ -2289,7 +2034,7 @@ msgstr "" "КлаÑтер баз данных был инициализирован без USE_FLOAT8_BYVAL, но Ñервер " "Ñкомпилирован Ñ USE_FLOAT8_BYVAL." -#: access/transam/xlog.c:4479 +#: access/transam/xlog.c:4485 #, c-format msgid "" "The database cluster was initialized with USE_FLOAT8_BYVAL but the server " @@ -2298,72 +2043,72 @@ msgstr "" "КлаÑтер баз данных был инициализирован Ñ USE_FLOAT8_BYVAL, но Ñервер был " "Ñкомпилирован без USE_FLOAT8_BYVAL." -#: access/transam/xlog.c:4900 +#: access/transam/xlog.c:4906 #, c-format msgid "could not write bootstrap transaction log file: %m" msgstr "не удалоÑÑŒ запиÑать начальный файл журнала транзакций: %m" -#: access/transam/xlog.c:4906 +#: access/transam/xlog.c:4912 #, c-format msgid "could not fsync bootstrap transaction log file: %m" -msgstr "не удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ начальный файл журнала транзакций: %m" +msgstr "не удалоÑÑŒ ÑброÑить на диÑк начальный файл журнала транзакций: %m" -#: access/transam/xlog.c:4911 +#: access/transam/xlog.c:4917 #, c-format msgid "could not close bootstrap transaction log file: %m" msgstr "не удалоÑÑŒ закрыть начальный файл журнала транзакций: %m" -#: access/transam/xlog.c:4986 +#: access/transam/xlog.c:4992 #, c-format msgid "could not open recovery command file \"%s\": %m" msgstr "не удалоÑÑŒ открыть файл команд воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\": %m" -#: access/transam/xlog.c:5032 access/transam/xlog.c:5117 +#: access/transam/xlog.c:5038 access/transam/xlog.c:5123 #, c-format msgid "invalid value for recovery parameter \"%s\": \"%s\"" msgstr "неверное значение Ð´Ð»Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð° воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\": \"%s\"" -#: access/transam/xlog.c:5035 +#: access/transam/xlog.c:5041 #, c-format msgid "Valid values are \"pause\", \"promote\", and \"shutdown\"." msgstr "ДопуÑтимые значениÑ: \"pause\", \"promote\" и \"shutdown\"." -#: access/transam/xlog.c:5055 +#: access/transam/xlog.c:5061 #, c-format msgid "recovery_target_timeline is not a valid number: \"%s\"" msgstr "recovery_target_timeline не ÑвлÑетÑÑ Ð´Ð¾Ð¿ÑƒÑтимым чиÑлом: \"%s\"" -#: access/transam/xlog.c:5072 +#: access/transam/xlog.c:5078 #, c-format msgid "recovery_target_xid is not a valid number: \"%s\"" msgstr "recovery_target_xid не ÑвлÑетÑÑ Ð´Ð¾Ð¿ÑƒÑтимым чиÑлом: \"%s\"" -#: access/transam/xlog.c:5103 +#: access/transam/xlog.c:5109 #, c-format msgid "recovery_target_name is too long (maximum %d characters)" msgstr "длина recovery_target_name превышает предел (%d)" -#: access/transam/xlog.c:5120 +#: access/transam/xlog.c:5126 #, c-format msgid "The only allowed value is \"immediate\"." msgstr "ЕдинÑтвенное допуÑтимое значение: \"immediate\"." -#: access/transam/xlog.c:5133 access/transam/xlog.c:5144 +#: access/transam/xlog.c:5139 access/transam/xlog.c:5150 #: commands/extension.c:534 commands/extension.c:542 utils/misc/guc.c:5640 #, c-format msgid "parameter \"%s\" requires a Boolean value" msgstr "параметр \"%s\" требует логичеÑкое значение" -#: access/transam/xlog.c:5179 +#: access/transam/xlog.c:5185 #, c-format msgid "parameter \"%s\" requires a temporal value" msgstr "параметр \"%s\" требует временное значение" -#: access/transam/xlog.c:5181 catalog/dependency.c:990 catalog/dependency.c:991 +#: access/transam/xlog.c:5187 catalog/dependency.c:990 catalog/dependency.c:991 #: catalog/dependency.c:997 catalog/dependency.c:998 catalog/dependency.c:1009 #: catalog/dependency.c:1010 catalog/objectaddress.c:1100 -#: commands/tablecmds.c:796 commands/tablecmds.c:9542 commands/user.c:1045 -#: commands/view.c:499 libpq/auth.c:307 replication/syncrep.c:919 +#: commands/tablecmds.c:796 commands/tablecmds.c:9556 commands/user.c:1045 +#: commands/view.c:499 libpq/auth.c:307 replication/syncrep.c:929 #: storage/lmgr/deadlock.c:1139 storage/lmgr/proc.c:1278 utils/adt/acl.c:5281 #: utils/misc/guc.c:5662 utils/misc/guc.c:5755 utils/misc/guc.c:9708 #: utils/misc/guc.c:9742 utils/misc/guc.c:9776 utils/misc/guc.c:9810 @@ -2372,12 +2117,12 @@ msgstr "параметр \"%s\" требует временное значени msgid "%s" msgstr "%s" -#: access/transam/xlog.c:5188 +#: access/transam/xlog.c:5194 #, c-format msgid "unrecognized recovery parameter \"%s\"" msgstr "нераÑпознанный параметр воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\"" -#: access/transam/xlog.c:5199 +#: access/transam/xlog.c:5205 #, c-format msgid "" "recovery command file \"%s\" specified neither primary_conninfo nor " @@ -2386,7 +2131,7 @@ msgstr "" "в файле команд воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" не указан параметр primary_conninfo или " "restore_command" -#: access/transam/xlog.c:5201 +#: access/transam/xlog.c:5207 #, c-format msgid "" "The database server will regularly poll the pg_xlog subdirectory to check " @@ -2395,7 +2140,7 @@ msgstr "" "Сервер БД будет регулÑрно опрашивать подкаталог pg_xlog и проверÑÑ‚ÑŒ " "ÑодержащиеÑÑ Ð² нём файлы." -#: access/transam/xlog.c:5208 +#: access/transam/xlog.c:5214 #, c-format msgid "" "recovery command file \"%s\" must specify restore_command when standby mode " @@ -2404,68 +2149,68 @@ msgstr "" "в файле команд воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" может отÑутÑтвовать restore_command, " "только еÑли Ñто резервный Ñервер" -#: access/transam/xlog.c:5229 +#: access/transam/xlog.c:5235 #, c-format msgid "standby mode is not supported by single-user servers" msgstr "" "режим резервного Ñервера не поддерживаетÑÑ Ð¾Ð´Ð½Ð¾Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»ÑŒÑким Ñервером" -#: access/transam/xlog.c:5248 +#: access/transam/xlog.c:5254 #, c-format msgid "recovery target timeline %u does not exist" msgstr "Ñ†ÐµÐ»ÐµÐ²Ð°Ñ Ð»Ð¸Ð½Ð¸Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð¸ Ð´Ð»Ñ Ð²Ð¾ÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ %u не ÑущеÑтвует" -#: access/transam/xlog.c:5369 +#: access/transam/xlog.c:5375 #, c-format msgid "archive recovery complete" msgstr "воÑÑтановление архива завершено" -#: access/transam/xlog.c:5428 access/transam/xlog.c:5656 +#: access/transam/xlog.c:5434 access/transam/xlog.c:5662 #, c-format msgid "recovery stopping after reaching consistency" msgstr "" "воÑÑтановление оÑтанавливаетÑÑ Ð¿Ð¾Ñле доÑÑ‚Ð¸Ð¶ÐµÐ½Ð¸Ñ ÑоглаÑованного ÑоÑтоÑниÑ" -#: access/transam/xlog.c:5516 +#: access/transam/xlog.c:5522 #, c-format msgid "recovery stopping before commit of transaction %u, time %s" msgstr "" "воÑÑтановление оÑтанавливаетÑÑ Ð¿ÐµÑ€ÐµÐ´ фикÑированием транзакции %u, Ð²Ñ€ÐµÐ¼Ñ %s" -#: access/transam/xlog.c:5523 +#: access/transam/xlog.c:5529 #, c-format msgid "recovery stopping before abort of transaction %u, time %s" msgstr "" "воÑÑтановление оÑтанавливаетÑÑ Ð¿ÐµÑ€ÐµÐ´ прерыванием транзакции %u, Ð²Ñ€ÐµÐ¼Ñ %s" -#: access/transam/xlog.c:5568 +#: access/transam/xlog.c:5574 #, c-format msgid "recovery stopping at restore point \"%s\", time %s" msgstr "воÑÑтановление оÑтанавливаетÑÑ Ð² точке воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\", Ð²Ñ€ÐµÐ¼Ñ %s" -#: access/transam/xlog.c:5636 +#: access/transam/xlog.c:5642 #, c-format msgid "recovery stopping after commit of transaction %u, time %s" msgstr "" "воÑÑтановление оÑтанавливаетÑÑ Ð¿Ð¾Ñле фикÑÐ¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¸ %u, Ð²Ñ€ÐµÐ¼Ñ %s" -#: access/transam/xlog.c:5644 +#: access/transam/xlog.c:5650 #, c-format msgid "recovery stopping after abort of transaction %u, time %s" msgstr "" "воÑÑтановление оÑтанавливаетÑÑ Ð¿Ð¾Ñле Ð¿Ñ€ÐµÑ€Ñ‹Ð²Ð°Ð½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¸ %u, Ð²Ñ€ÐµÐ¼Ñ %s" -#: access/transam/xlog.c:5683 +#: access/transam/xlog.c:5689 #, c-format msgid "recovery has paused" msgstr "воÑÑтановление приоÑтановлено" -#: access/transam/xlog.c:5684 +#: access/transam/xlog.c:5690 #, c-format msgid "Execute pg_xlog_replay_resume() to continue." msgstr "Выполните pg_xlog_replay_resume() Ð´Ð»Ñ Ð¿Ñ€Ð¾Ð´Ð¾Ð»Ð¶ÐµÐ½Ð¸Ñ." -#: access/transam/xlog.c:5891 +#: access/transam/xlog.c:5897 #, c-format msgid "" "hot standby is not possible because %s = %d is a lower setting than on the " @@ -2474,12 +2219,12 @@ msgstr "" "режим горÑчего резерва невозможен, так как параметр %s = %d, меньше чем на " "главном Ñервере (на нём было значение %d)" -#: access/transam/xlog.c:5917 +#: access/transam/xlog.c:5923 #, c-format msgid "WAL was generated with wal_level=minimal, data may be missing" msgstr "WAL был Ñоздан Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ wal_level=minimal, возможна Ð¿Ð¾Ñ‚ÐµÑ€Ñ Ð´Ð°Ð½Ð½Ñ‹Ñ…" -#: access/transam/xlog.c:5918 +#: access/transam/xlog.c:5924 #, c-format msgid "" "This happens if you temporarily set wal_level=minimal without taking a new " @@ -2488,7 +2233,7 @@ msgstr "" "Это проиÑходит, еÑли вы на Ð²Ñ€ÐµÐ¼Ñ ÑƒÑтановили wal_level=minimal и не Ñделали " "резервную копию базу данных." -#: access/transam/xlog.c:5929 +#: access/transam/xlog.c:5935 #, c-format msgid "" "hot standby is not possible because wal_level was not set to \"replica\" or " @@ -2497,7 +2242,7 @@ msgstr "" "режим горÑчего резерва невозможен, так как на главном Ñервере уÑтановлен " "неподходÑщий wal_level (должен быть \"replica\" или выше)" -#: access/transam/xlog.c:5930 +#: access/transam/xlog.c:5936 #, c-format msgid "" "Either set wal_level to \"replica\" on the master, or turn off hot_standby " @@ -2506,32 +2251,32 @@ msgstr "" "Либо уÑтановите Ð´Ð»Ñ wal_level значение \"replica\" на главном Ñервере, либо " "выключите hot_standby здеÑÑŒ." -#: access/transam/xlog.c:5987 +#: access/transam/xlog.c:5993 #, c-format msgid "control file contains invalid data" msgstr "файл pg_control Ñодержит неверные данные" -#: access/transam/xlog.c:5993 +#: access/transam/xlog.c:5999 #, c-format msgid "database system was shut down at %s" msgstr "ÑиÑтема БД была выключена: %s" -#: access/transam/xlog.c:5998 +#: access/transam/xlog.c:6004 #, c-format msgid "database system was shut down in recovery at %s" msgstr "ÑиÑтема БД была выключена в процеÑÑе воÑÑтановлениÑ: %s" -#: access/transam/xlog.c:6002 +#: access/transam/xlog.c:6008 #, c-format msgid "database system shutdown was interrupted; last known up at %s" msgstr "выключение ÑиÑтемы БД было прервано; поÑледний момент работы: %s" -#: access/transam/xlog.c:6006 +#: access/transam/xlog.c:6012 #, c-format msgid "database system was interrupted while in recovery at %s" msgstr "работа ÑиÑтемы БД была прервана во Ð²Ñ€ÐµÐ¼Ñ Ð²Ð¾ÑÑтановлениÑ: %s" -#: access/transam/xlog.c:6008 +#: access/transam/xlog.c:6014 #, c-format msgid "" "This probably means that some data is corrupted and you will have to use the " @@ -2540,14 +2285,14 @@ msgstr "" "Это Ñкорее вÑего означает, что некоторые данные повреждены и вам придётÑÑ " "воÑÑтановить БД из поÑледней резервной копии." -#: access/transam/xlog.c:6012 +#: access/transam/xlog.c:6018 #, c-format msgid "database system was interrupted while in recovery at log time %s" msgstr "" "работа ÑиÑтемы БД была прервана в процеÑÑе воÑÑтановлениÑ, Ð²Ñ€ÐµÐ¼Ñ Ð² журнале: " "%s" -#: access/transam/xlog.c:6014 +#: access/transam/xlog.c:6020 #, c-format msgid "" "If this has occurred more than once some data might be corrupted and you " @@ -2556,53 +2301,53 @@ msgstr "" "ЕÑли Ñто проиÑходит поÑтоÑнно, возможно, какие-то данные были иÑпорчены и " "Ð´Ð»Ñ Ð²Ð¾ÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ñтоит выбрать более раннюю точку." -#: access/transam/xlog.c:6018 +#: access/transam/xlog.c:6024 #, c-format msgid "database system was interrupted; last known up at %s" msgstr "работа ÑиÑтемы БД была прервана; поÑледний момент работы: %s" -#: access/transam/xlog.c:6074 +#: access/transam/xlog.c:6080 #, c-format msgid "entering standby mode" msgstr "переход в режим резервного Ñервера" -#: access/transam/xlog.c:6077 +#: access/transam/xlog.c:6083 #, c-format msgid "starting point-in-time recovery to XID %u" msgstr "начинаетÑÑ Ð²Ð¾ÑÑтановление точки во времени до XID %u" -#: access/transam/xlog.c:6081 +#: access/transam/xlog.c:6087 #, c-format msgid "starting point-in-time recovery to %s" msgstr "начинаетÑÑ Ð²Ð¾ÑÑтановление точки во времени до %s" -#: access/transam/xlog.c:6085 +#: access/transam/xlog.c:6091 #, c-format msgid "starting point-in-time recovery to \"%s\"" msgstr "начинаетÑÑ Ð²Ð¾ÑÑтановление точки во времени до \"%s\"" -#: access/transam/xlog.c:6089 +#: access/transam/xlog.c:6095 #, c-format msgid "starting point-in-time recovery to earliest consistent point" msgstr "" "начинаетÑÑ Ð²Ð¾ÑÑтановление точки во времени до первой точки ÑоглаÑованноÑти" -#: access/transam/xlog.c:6092 +#: access/transam/xlog.c:6098 #, c-format msgid "starting archive recovery" msgstr "начинаетÑÑ Ð²Ð¾ÑÑтановление архива" -#: access/transam/xlog.c:6136 access/transam/xlog.c:6264 +#: access/transam/xlog.c:6142 access/transam/xlog.c:6270 #, c-format msgid "checkpoint record is at %X/%X" msgstr "запиÑÑŒ о контрольной точке по Ñмещению %X/%X" -#: access/transam/xlog.c:6150 +#: access/transam/xlog.c:6156 #, c-format msgid "could not find redo location referenced by checkpoint record" msgstr "не удалоÑÑŒ найти положение REDO, указанное запиÑью контрольной точки" -#: access/transam/xlog.c:6151 access/transam/xlog.c:6158 +#: access/transam/xlog.c:6157 access/transam/xlog.c:6164 #, c-format msgid "" "If you are not restoring from a backup, try removing the file \"%s/" @@ -2611,47 +2356,47 @@ msgstr "" "ЕÑли вы не воÑÑтанавливаете БД из резервной копии, попробуйте удалить файл " "\"%s/backup_label\"." -#: access/transam/xlog.c:6157 +#: access/transam/xlog.c:6163 #, c-format msgid "could not locate required checkpoint record" msgstr "не удалоÑÑŒ Ñчитать нужную запиÑÑŒ контрольной точки" -#: access/transam/xlog.c:6183 commands/tablespace.c:641 +#: access/transam/xlog.c:6189 commands/tablespace.c:641 #, c-format msgid "could not create symbolic link \"%s\": %m" msgstr "не удалоÑÑŒ Ñоздать ÑимволичеÑкую ÑÑылку \"%s\": %m" -#: access/transam/xlog.c:6215 access/transam/xlog.c:6221 +#: access/transam/xlog.c:6221 access/transam/xlog.c:6227 #, c-format msgid "ignoring file \"%s\" because no file \"%s\" exists" msgstr "файл \"%s\" игнорируетÑÑ Ð²Ð²Ð¸Ð´Ñƒ отÑутÑÑ‚Ð²Ð¸Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\"" -#: access/transam/xlog.c:6217 access/transam/xlog.c:11032 +#: access/transam/xlog.c:6223 access/transam/xlog.c:11065 #, c-format msgid "File \"%s\" was renamed to \"%s\"." msgstr "Файл \"%s\" был переименован в \"%s\"." -#: access/transam/xlog.c:6223 +#: access/transam/xlog.c:6229 #, c-format msgid "Could not rename file \"%s\" to \"%s\": %m." msgstr "Ðе удалоÑÑŒ переименовать файл \"%s\" в \"%s\" (%m)." -#: access/transam/xlog.c:6274 access/transam/xlog.c:6289 +#: access/transam/xlog.c:6280 access/transam/xlog.c:6295 #, c-format msgid "could not locate a valid checkpoint record" msgstr "не удалоÑÑŒ Ñчитать правильную запиÑÑŒ контрольной точки" -#: access/transam/xlog.c:6283 +#: access/transam/xlog.c:6289 #, c-format msgid "using previous checkpoint record at %X/%X" msgstr "иÑпользуетÑÑ Ð¿Ñ€ÐµÐ´Ñ‹Ð´ÑƒÑ‰Ð°Ñ Ð·Ð°Ð¿Ð¸ÑÑŒ контрольной точки по Ñмещению %X/%X" -#: access/transam/xlog.c:6327 +#: access/transam/xlog.c:6333 #, c-format msgid "requested timeline %u is not a child of this server's history" msgstr "в иÑтории Ñервера нет Ð¾Ñ‚Ð²ÐµÑ‚Ð²Ð»ÐµÐ½Ð¸Ñ Ð·Ð°Ð¿Ñ€Ð¾ÑˆÐµÐ½Ð½Ð¾Ð¹ линии времени %u" -#: access/transam/xlog.c:6329 +#: access/transam/xlog.c:6335 #, c-format msgid "" "Latest checkpoint is at %X/%X on timeline %u, but in the history of the " @@ -2660,7 +2405,7 @@ msgstr "" "ПоÑледнÑÑ ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ°: %X/%X на линии времени %u, но в иÑтории " "запрошенной линии времени Ñервер ответвилÑÑ Ñ Ñтой линии в %X/%X." -#: access/transam/xlog.c:6345 +#: access/transam/xlog.c:6351 #, c-format msgid "" "requested timeline %u does not contain minimum recovery point %X/%X on " @@ -2669,22 +2414,22 @@ msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾ÑˆÐµÐ½Ð½Ð°Ñ Ð»Ð¸Ð½Ð¸Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð¸ %u не Ñодержит минимальную точку воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ %X/" "%X на линии времени %u" -#: access/transam/xlog.c:6376 +#: access/transam/xlog.c:6382 #, c-format msgid "invalid next transaction ID" msgstr "неверный ID Ñледующей транзакции" -#: access/transam/xlog.c:6459 +#: access/transam/xlog.c:6465 #, c-format msgid "invalid redo in checkpoint record" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð·Ð°Ð¿Ð¸ÑÑŒ REDO в контрольной точке" -#: access/transam/xlog.c:6470 +#: access/transam/xlog.c:6476 #, c-format msgid "invalid redo record in shutdown checkpoint" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð·Ð°Ð¿Ð¸ÑÑŒ REDO в контрольной точке выключениÑ" -#: access/transam/xlog.c:6498 +#: access/transam/xlog.c:6504 #, c-format msgid "" "database system was not properly shut down; automatic recovery in progress" @@ -2692,19 +2437,19 @@ msgstr "" "ÑиÑтема БД была оÑтановлена нештатно; производитÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑкое " "воÑÑтановление" -#: access/transam/xlog.c:6502 +#: access/transam/xlog.c:6508 #, c-format msgid "crash recovery starts in timeline %u and has target timeline %u" msgstr "" "воÑÑтановление поÑле ÑÐ±Ð¾Ñ Ð½Ð°Ñ‡Ð¸Ð½Ð°ÐµÑ‚ÑÑ Ð½Ð° линии времени %u, Ñ†ÐµÐ»ÐµÐ²Ð°Ñ Ð»Ð¸Ð½Ð¸Ñ " "времени: %u" -#: access/transam/xlog.c:6546 +#: access/transam/xlog.c:6552 #, c-format msgid "backup_label contains data inconsistent with control file" msgstr "backup_label Ñодержит данные, не ÑоглаÑованные Ñ Ñ„Ð°Ð¹Ð»Ð¾Ð¼ pg_control" -#: access/transam/xlog.c:6547 +#: access/transam/xlog.c:6553 #, c-format msgid "" "This means that the backup is corrupted and you will have to use another " @@ -2713,44 +2458,44 @@ msgstr "" "Это означает, что Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ð°Ñ ÐºÐ¾Ð¿Ð¸Ñ Ð¿Ð¾Ð²Ñ€ÐµÐ¶Ð´ÐµÐ½Ð° и Ð´Ð»Ñ Ð²Ð¾ÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð‘Ð” " "придётÑÑ Ð¸Ñпользовать другую копию." -#: access/transam/xlog.c:6621 +#: access/transam/xlog.c:6627 #, c-format msgid "initializing for hot standby" msgstr "Ð¸Ð½Ð¸Ñ†Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ†Ð¸Ñ Ð´Ð»Ñ Ð³Ð¾Ñ€Ñчего резерва" -#: access/transam/xlog.c:6753 +#: access/transam/xlog.c:6759 #, c-format msgid "redo starts at %X/%X" msgstr "запиÑÑŒ REDO начинаетÑÑ Ñо ÑÐ¼ÐµÑ‰ÐµÐ½Ð¸Ñ %X/%X" -#: access/transam/xlog.c:6978 +#: access/transam/xlog.c:6984 #, c-format msgid "requested recovery stop point is before consistent recovery point" msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾ÑˆÐµÐ½Ð½Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ° оÑтановки воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð¿Ñ€ÐµÐ´ÑˆÐµÑтвует ÑоглаÑованной точке " "воÑÑтановлениÑ" -#: access/transam/xlog.c:7016 +#: access/transam/xlog.c:7022 #, c-format msgid "redo done at %X/%X" msgstr "запиÑи REDO обработаны до ÑÐ¼ÐµÑ‰ÐµÐ½Ð¸Ñ %X/%X" -#: access/transam/xlog.c:7021 access/transam/xlog.c:8969 +#: access/transam/xlog.c:7027 access/transam/xlog.c:8986 #, c-format msgid "last completed transaction was at log time %s" msgstr "поÑледнÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÑ‘Ð½Ð½Ð°Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñ Ð±Ñ‹Ð»Ð° выполнена в %s" -#: access/transam/xlog.c:7030 +#: access/transam/xlog.c:7036 #, c-format msgid "redo is not required" msgstr "данные REDO не требуютÑÑ" -#: access/transam/xlog.c:7105 access/transam/xlog.c:7109 +#: access/transam/xlog.c:7111 access/transam/xlog.c:7115 #, c-format msgid "WAL ends before end of online backup" msgstr "WAL закончилÑÑ Ð±ÐµÐ· признака Ð¾ÐºÐ¾Ð½Ñ‡Ð°Ð½Ð¸Ñ ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ" -#: access/transam/xlog.c:7106 +#: access/transam/xlog.c:7112 #, c-format msgid "" "All WAL generated while online backup was taken must be available at " @@ -2759,7 +2504,7 @@ msgstr "" "Ð’Ñе журналы WAL, Ñозданные во Ð²Ñ€ÐµÐ¼Ñ Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ð¾Ð³Ð¾ ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ \"на ходу\", " "должны быть в наличии Ð´Ð»Ñ Ð²Ð¾ÑÑтановлениÑ." -#: access/transam/xlog.c:7110 +#: access/transam/xlog.c:7116 #, c-format msgid "" "Online backup started with pg_start_backup() must be ended with " @@ -2769,102 +2514,102 @@ msgstr "" "должно закончитьÑÑ pg_stop_backup(), и Ð´Ð»Ñ Ð²Ð¾ÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð´Ð¾Ð»Ð¶Ð½Ñ‹ быть " "доÑтупны вÑе журналы WAL." -#: access/transam/xlog.c:7113 +#: access/transam/xlog.c:7119 #, c-format msgid "WAL ends before consistent recovery point" msgstr "WAL закончилÑÑ Ð´Ð¾ ÑоглаÑованной точки воÑÑтановлениÑ" -#: access/transam/xlog.c:7140 +#: access/transam/xlog.c:7146 #, c-format msgid "selected new timeline ID: %u" msgstr "выбранный ID новой линии времени: %u" -#: access/transam/xlog.c:7551 +#: access/transam/xlog.c:7557 #, c-format msgid "consistent recovery state reached at %X/%X" msgstr "ÑоглаÑованное ÑоÑтоÑние воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð´Ð¾Ñтигнуто по Ñмещению %X/%X" -#: access/transam/xlog.c:7742 +#: access/transam/xlog.c:7748 #, c-format msgid "invalid primary checkpoint link in control file" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ ÑÑылка на первичную контрольную точку в файле pg_control" -#: access/transam/xlog.c:7746 +#: access/transam/xlog.c:7752 #, c-format msgid "invalid secondary checkpoint link in control file" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ ÑÑылка на вторичную контрольную точку в файле pg_control" -#: access/transam/xlog.c:7750 +#: access/transam/xlog.c:7756 #, c-format msgid "invalid checkpoint link in backup_label file" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ ÑÑылка на контрольную точку в файле backup_label" -#: access/transam/xlog.c:7767 +#: access/transam/xlog.c:7773 #, c-format msgid "invalid primary checkpoint record" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð·Ð°Ð¿Ð¸ÑÑŒ первичной контрольной точки" -#: access/transam/xlog.c:7771 +#: access/transam/xlog.c:7777 #, c-format msgid "invalid secondary checkpoint record" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð·Ð°Ð¿Ð¸ÑÑŒ вторичной контрольной точки" -#: access/transam/xlog.c:7775 +#: access/transam/xlog.c:7781 #, c-format msgid "invalid checkpoint record" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð·Ð°Ð¿Ð¸ÑÑŒ контрольной точки" -#: access/transam/xlog.c:7786 +#: access/transam/xlog.c:7792 #, c-format msgid "invalid resource manager ID in primary checkpoint record" msgstr "неверный ID менеджера реÑурÑов в запиÑи первичной контрольной точки" -#: access/transam/xlog.c:7790 +#: access/transam/xlog.c:7796 #, c-format msgid "invalid resource manager ID in secondary checkpoint record" msgstr "неверный ID менеджера реÑурÑов в запиÑи вторичной контрольной точки" -#: access/transam/xlog.c:7794 +#: access/transam/xlog.c:7800 #, c-format msgid "invalid resource manager ID in checkpoint record" msgstr "неверный ID менеджера реÑурÑов в запиÑи контрольной точки" -#: access/transam/xlog.c:7806 +#: access/transam/xlog.c:7812 #, c-format msgid "invalid xl_info in primary checkpoint record" msgstr "неверные флаги xl_info в запиÑи первичной контрольной точки" -#: access/transam/xlog.c:7810 +#: access/transam/xlog.c:7816 #, c-format msgid "invalid xl_info in secondary checkpoint record" msgstr "неверные флаги xl_info в запиÑи вторичной контрольной точки" -#: access/transam/xlog.c:7814 +#: access/transam/xlog.c:7820 #, c-format msgid "invalid xl_info in checkpoint record" msgstr "неверные флаги xl_info в запиÑи контрольной точки" -#: access/transam/xlog.c:7825 +#: access/transam/xlog.c:7831 #, c-format msgid "invalid length of primary checkpoint record" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° запиÑи первичной контрольной точки" -#: access/transam/xlog.c:7829 +#: access/transam/xlog.c:7835 #, c-format msgid "invalid length of secondary checkpoint record" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° запиÑи вторичной контрольной точки" -#: access/transam/xlog.c:7833 +#: access/transam/xlog.c:7839 #, c-format msgid "invalid length of checkpoint record" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° запиÑи контрольной точки" -#: access/transam/xlog.c:8001 +#: access/transam/xlog.c:8007 #, c-format msgid "shutting down" msgstr "выключение" -#: access/transam/xlog.c:8514 +#: access/transam/xlog.c:8531 #, c-format msgid "" "concurrent transaction log activity while database system is shutting down" @@ -2872,29 +2617,29 @@ msgstr "" "во Ð²Ñ€ÐµÐ¼Ñ Ð²Ñ‹ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ ÑиÑтемы баз данных отмечена активноÑÑ‚ÑŒ в журнале " "транзакций" -#: access/transam/xlog.c:8768 +#: access/transam/xlog.c:8785 #, c-format msgid "skipping restartpoint, recovery has already ended" msgstr "" "Ñоздание точки перезапуÑка пропуÑкаетÑÑ, воÑÑтановление уже закончилоÑÑŒ" -#: access/transam/xlog.c:8791 +#: access/transam/xlog.c:8808 #, c-format msgid "skipping restartpoint, already performed at %X/%X" msgstr "" "Ñоздание точки перезапуÑка пропуÑкаетÑÑ, она уже Ñоздана по Ñмещению %X/%X" -#: access/transam/xlog.c:8967 +#: access/transam/xlog.c:8984 #, c-format msgid "recovery restart point at %X/%X" msgstr "точка перезапуÑка воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð¿Ð¾ Ñмещению %X/%X" -#: access/transam/xlog.c:9100 +#: access/transam/xlog.c:9117 #, c-format msgid "restore point \"%s\" created at %X/%X" msgstr "точка воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" Ñоздана по Ñмещению %X/%X" -#: access/transam/xlog.c:9230 +#: access/transam/xlog.c:9247 #, c-format msgid "" "unexpected previous timeline ID %u (current timeline ID %u) in checkpoint " @@ -2903,13 +2648,13 @@ msgstr "" "неожиданный ID предыдущей линии времени %u (ID текущей линии времени %u) в " "запиÑи контрольной точки" -#: access/transam/xlog.c:9239 +#: access/transam/xlog.c:9256 #, c-format msgid "unexpected timeline ID %u (after %u) in checkpoint record" msgstr "неожиданный ID линии времени %u (поÑле %u) в запиÑи контрольной точки" # skip-rule: capital-letter-first -#: access/transam/xlog.c:9255 +#: access/transam/xlog.c:9272 #, c-format msgid "" "unexpected timeline ID %u in checkpoint record, before reaching minimum " @@ -2918,79 +2663,79 @@ msgstr "" "неожиданный ID линии времени %u в запиÑи контрольной точки, до доÑÑ‚Ð¸Ð¶ÐµÐ½Ð¸Ñ " "минимальной к. Ñ‚. %X/%X на линии времени %u" -#: access/transam/xlog.c:9326 +#: access/transam/xlog.c:9343 #, c-format msgid "online backup was canceled, recovery cannot continue" msgstr "" "резервное копирование \"на ходу\" было отменено, продолжить воÑÑтановление " "нельзÑ" -#: access/transam/xlog.c:9382 access/transam/xlog.c:9429 -#: access/transam/xlog.c:9452 +#: access/transam/xlog.c:9399 access/transam/xlog.c:9446 +#: access/transam/xlog.c:9469 #, c-format msgid "unexpected timeline ID %u (should be %u) in checkpoint record" msgstr "" "неожиданный ID линии времени %u (должен быть %u) в запиÑи точки " "воÑÑтановлениÑ" -#: access/transam/xlog.c:9727 +#: access/transam/xlog.c:9744 #, c-format msgid "could not fsync log segment %s: %m" msgstr "не удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ Ñегмент журнала %s: %m" -#: access/transam/xlog.c:9751 +#: access/transam/xlog.c:9768 #, c-format msgid "could not fsync log file %s: %m" msgstr "не удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ файл журнала %s: %m" -#: access/transam/xlog.c:9759 +#: access/transam/xlog.c:9776 #, c-format msgid "could not fsync write-through log file %s: %m" msgstr "не удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ файл журнала Ñквозной запиÑи %s: %m" -#: access/transam/xlog.c:9768 +#: access/transam/xlog.c:9785 #, c-format msgid "could not fdatasync log file %s: %m" msgstr "" "не удалоÑÑŒ Ñинхронизировать Ñ Ð¤Ð¡ данные (fdatasync) файла журнала %s: %m" -#: access/transam/xlog.c:9859 access/transam/xlog.c:10363 -#: access/transam/xlogfuncs.c:294 access/transam/xlogfuncs.c:321 -#: access/transam/xlogfuncs.c:360 access/transam/xlogfuncs.c:381 -#: access/transam/xlogfuncs.c:402 +#: access/transam/xlog.c:9876 access/transam/xlog.c:10393 +#: access/transam/xlogfuncs.c:289 access/transam/xlogfuncs.c:316 +#: access/transam/xlogfuncs.c:355 access/transam/xlogfuncs.c:376 +#: access/transam/xlogfuncs.c:397 #, c-format msgid "WAL control functions cannot be executed during recovery." msgstr "Функции ÑƒÐ¿Ñ€Ð°Ð²Ð»ÐµÐ½Ð¸Ñ WAL Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать в процеÑÑе воÑÑтановлениÑ." -#: access/transam/xlog.c:9868 access/transam/xlog.c:10372 +#: access/transam/xlog.c:9885 access/transam/xlog.c:10402 #, c-format msgid "WAL level not sufficient for making an online backup" msgstr "" "Выбранный уровень WAL недоÑтаточен Ð´Ð»Ñ Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ð¾Ð³Ð¾ ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ \"на ходу\"" -#: access/transam/xlog.c:9869 access/transam/xlog.c:10373 -#: access/transam/xlogfuncs.c:327 +#: access/transam/xlog.c:9886 access/transam/xlog.c:10403 +#: access/transam/xlogfuncs.c:322 #, c-format msgid "wal_level must be set to \"replica\" or \"logical\" at server start." msgstr "УÑтановите wal_level \"replica\" или \"logical\" при запуÑке Ñервера." -#: access/transam/xlog.c:9874 +#: access/transam/xlog.c:9891 #, c-format msgid "backup label too long (max %d bytes)" msgstr "длина метки резервной копии превышает предел (%d байт)" -#: access/transam/xlog.c:9911 access/transam/xlog.c:10183 -#: access/transam/xlog.c:10221 +#: access/transam/xlog.c:9928 access/transam/xlog.c:10200 +#: access/transam/xlog.c:10238 #, c-format msgid "a backup is already in progress" msgstr "резервное копирование уже выполнÑетÑÑ" -#: access/transam/xlog.c:9912 +#: access/transam/xlog.c:9929 #, c-format msgid "Run pg_stop_backup() and try again." msgstr "Выполните pg_stop_backup() и повторите операцию." -#: access/transam/xlog.c:10007 +#: access/transam/xlog.c:10024 #, c-format msgid "" "WAL generated with full_page_writes=off was replayed since last restartpoint" @@ -2998,7 +2743,7 @@ msgstr "" "ПоÑле поÑледней точки перезапуÑка был воÑпроизведён WAL, Ñозданный в режиме " "full_page_writes=off." -#: access/transam/xlog.c:10009 access/transam/xlog.c:10554 +#: access/transam/xlog.c:10026 access/transam/xlog.c:10587 #, c-format msgid "" "This means that the backup being taken on the standby is corrupt and should " @@ -3010,39 +2755,39 @@ msgstr "" "CHECKPOINT на главном Ñервере, а затем попробуйте резервное копирование \"на " "ходу\" ещё раз." -#: access/transam/xlog.c:10076 replication/basebackup.c:1026 +#: access/transam/xlog.c:10093 replication/basebackup.c:1026 #: utils/adt/misc.c:498 #, c-format msgid "could not read symbolic link \"%s\": %m" msgstr "не удалоÑÑŒ прочитать ÑимволичеÑкую ÑÑылку \"%s\": %m" -#: access/transam/xlog.c:10083 replication/basebackup.c:1031 +#: access/transam/xlog.c:10100 replication/basebackup.c:1031 #: utils/adt/misc.c:503 #, c-format msgid "symbolic link \"%s\" target is too long" msgstr "целевой путь ÑимволичеÑкой ÑÑылки \"%s\" Ñлишком длинный" -#: access/transam/xlog.c:10136 commands/tablespace.c:391 +#: access/transam/xlog.c:10153 commands/tablespace.c:391 #: commands/tablespace.c:553 replication/basebackup.c:1047 utils/adt/misc.c:511 #, c-format msgid "tablespaces are not supported on this platform" msgstr "табличные проÑтранÑтва не поддерживаютÑÑ Ð½Ð° Ñтой платформе" -#: access/transam/xlog.c:10177 access/transam/xlog.c:10215 -#: access/transam/xlog.c:10411 access/transam/xlogarchive.c:106 -#: access/transam/xlogarchive.c:265 commands/copy.c:1815 commands/copy.c:2839 -#: commands/extension.c:3130 commands/tablespace.c:782 +#: access/transam/xlog.c:10194 access/transam/xlog.c:10232 +#: access/transam/xlog.c:10441 access/transam/xlogarchive.c:106 +#: access/transam/xlogarchive.c:265 commands/copy.c:1816 commands/copy.c:2840 +#: commands/extension.c:3133 commands/tablespace.c:782 #: commands/tablespace.c:873 replication/basebackup.c:409 -#: replication/basebackup.c:477 replication/logical/snapbuild.c:1491 -#: storage/file/copydir.c:72 storage/file/copydir.c:115 storage/file/fd.c:2826 -#: storage/file/fd.c:2918 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 +#: replication/basebackup.c:477 replication/logical/snapbuild.c:1496 +#: storage/file/copydir.c:72 storage/file/copydir.c:115 storage/file/fd.c:2903 +#: storage/file/fd.c:2995 utils/adt/dbsize.c:70 utils/adt/dbsize.c:220 #: utils/adt/dbsize.c:300 utils/adt/genfile.c:114 utils/adt/genfile.c:333 #: guc-file.l:1001 #, c-format msgid "could not stat file \"%s\": %m" msgstr "не удалоÑÑŒ получить информацию о файле \"%s\": %m" -#: access/transam/xlog.c:10184 access/transam/xlog.c:10222 +#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 #, c-format msgid "" "If you're sure there is no backup in progress, remove file \"%s\" and try " @@ -3051,36 +2796,36 @@ msgstr "" "ЕÑли вы Ñчитаете, что Ð¸Ð½Ñ„Ð¾Ñ€Ð¼Ð°Ñ†Ð¸Ñ Ð¾ резервном копировании неверна, удалите " "файл \"%s\" и попробуйте Ñнова." -#: access/transam/xlog.c:10201 access/transam/xlog.c:10239 -#: access/transam/xlog.c:10615 +#: access/transam/xlog.c:10218 access/transam/xlog.c:10256 +#: access/transam/xlog.c:10648 #, c-format msgid "could not write file \"%s\": %m" msgstr "не удалоÑÑŒ запиÑать файл \"%s\": %m" -#: access/transam/xlog.c:10388 +#: access/transam/xlog.c:10418 #, c-format msgid "exclusive backup not in progress" msgstr "монопольное резервное копирование не выполнÑетÑÑ" -#: access/transam/xlog.c:10415 +#: access/transam/xlog.c:10445 #, c-format msgid "a backup is not in progress" msgstr "резервное копирование не выполнÑетÑÑ" -#: access/transam/xlog.c:10489 access/transam/xlog.c:10502 -#: access/transam/xlog.c:10842 access/transam/xlog.c:10848 -#: access/transam/xlog.c:10932 access/transam/xlogfuncs.c:695 +#: access/transam/xlog.c:10522 access/transam/xlog.c:10535 +#: access/transam/xlog.c:10875 access/transam/xlog.c:10881 +#: access/transam/xlog.c:10965 access/transam/xlogfuncs.c:690 #, c-format msgid "invalid data in file \"%s\"" msgstr "неверные данные в файле \"%s\"" -#: access/transam/xlog.c:10506 replication/basebackup.c:938 +#: access/transam/xlog.c:10539 replication/basebackup.c:938 #, c-format msgid "the standby was promoted during online backup" msgstr "" "дежурный Ñервер был повышен в процеÑÑе резервного ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ \"на ходу\"" -#: access/transam/xlog.c:10507 replication/basebackup.c:939 +#: access/transam/xlog.c:10540 replication/basebackup.c:939 #, c-format msgid "" "This means that the backup being taken is corrupt and should not be used. " @@ -3089,7 +2834,7 @@ msgstr "" "Это означает, что ÑÐ¾Ð·Ð´Ð°Ð²Ð°ÐµÐ¼Ð°Ñ Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ð°Ñ ÐºÐ¾Ð¿Ð¸Ñ Ð¸Ñпорчена и иÑпользовать её не " "Ñледует. Попробуйте резервное копирование \"на ходу\" ещё раз." -#: access/transam/xlog.c:10552 +#: access/transam/xlog.c:10585 #, c-format msgid "" "WAL generated with full_page_writes=off was replayed during online backup" @@ -3097,7 +2842,7 @@ msgstr "" "Ð’ процеÑÑе резервного ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ \"на ходу\" был воÑпроизведён WAL, " "Ñозданный в режиме full_page_writes=off" -#: access/transam/xlog.c:10664 +#: access/transam/xlog.c:10697 #, c-format msgid "" "pg_stop_backup cleanup done, waiting for required WAL segments to be archived" @@ -3105,7 +2850,7 @@ msgstr "" "очиÑтка в pg_stop_backup выполнена, ожидаютÑÑ Ñ‚Ñ€ÐµÐ±ÑƒÐµÐ¼Ñ‹Ðµ Ñегменты WAL Ð´Ð»Ñ " "архивации" -#: access/transam/xlog.c:10674 +#: access/transam/xlog.c:10707 #, c-format msgid "" "pg_stop_backup still waiting for all required WAL segments to be archived " @@ -3114,7 +2859,7 @@ msgstr "" "pg_stop_backup вÑÑ‘ ещё ждёт вÑе требуемые Ñегменты WAL Ð´Ð»Ñ Ð°Ñ€Ñ…Ð¸Ð²Ð°Ñ†Ð¸Ð¸ (прошло " "%d Ñек.)" -#: access/transam/xlog.c:10676 +#: access/transam/xlog.c:10709 #, c-format msgid "" "Check that your archive_command is executing properly. pg_stop_backup can " @@ -3125,13 +2870,13 @@ msgstr "" "можно отменить безопаÑно, но Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ð°Ñ ÐºÐ¾Ð¿Ð¸Ñ Ð±Ð°Ð·Ñ‹ данных будет непригодна " "без вÑех Ñегментов WAL." -#: access/transam/xlog.c:10683 +#: access/transam/xlog.c:10716 #, c-format msgid "pg_stop_backup complete, all required WAL segments have been archived" msgstr "" "команда pg_stop_backup завершена, вÑе требуемые Ñегменты WAL заархивированы" -#: access/transam/xlog.c:10687 +#: access/transam/xlog.c:10720 #, c-format msgid "" "WAL archiving is not enabled; you must ensure that all required WAL segments " @@ -3141,35 +2886,35 @@ msgstr "" "Ñегментов WAL другими ÑредÑтвами Ð´Ð»Ñ Ð¿Ð¾Ð»ÑƒÑ‡ÐµÐ½Ð¸Ñ Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ð¾Ð¹ копии" #. translator: %s is an XLog record description -#: access/transam/xlog.c:10972 +#: access/transam/xlog.c:11005 #, c-format msgid "xlog redo at %X/%X for %s" msgstr "запиÑÑŒ REDO в XLOG в позиции %X/%X Ð´Ð»Ñ %s" -#: access/transam/xlog.c:11021 +#: access/transam/xlog.c:11054 #, c-format msgid "online backup mode was not canceled" msgstr "режим ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ \"на ходу\" не был отменён" -#: access/transam/xlog.c:11022 +#: access/transam/xlog.c:11055 #, c-format msgid "File \"%s\" could not be renamed to \"%s\": %m." msgstr "Ðе удалоÑÑŒ переименовать файл \"%s\" в \"%s\": %m." -#: access/transam/xlog.c:11031 access/transam/xlog.c:11043 -#: access/transam/xlog.c:11053 +#: access/transam/xlog.c:11064 access/transam/xlog.c:11076 +#: access/transam/xlog.c:11086 #, c-format msgid "online backup mode canceled" msgstr "режим ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ \"на ходу\" отменён" -#: access/transam/xlog.c:11044 +#: access/transam/xlog.c:11077 #, c-format msgid "" "Files \"%s\" and \"%s\" were renamed to \"%s\" and \"%s\", respectively." msgstr "" "Файлы \"%s\" и \"%s\" были переименованы в \"%s\" и \"%s\", ÑоответÑтвенно." -#: access/transam/xlog.c:11054 +#: access/transam/xlog.c:11087 #, c-format msgid "" "File \"%s\" was renamed to \"%s\", but file \"%s\" could not be renamed to " @@ -3178,28 +2923,28 @@ msgstr "" "Файл \"%s\" был переименован в \"%s\", но переименовать \"%s\" в \"%s\" не " "удалоÑÑŒ: %m." -#: access/transam/xlog.c:11176 access/transam/xlogutils.c:718 -#: replication/walreceiver.c:994 replication/walsender.c:2114 +#: access/transam/xlog.c:11209 access/transam/xlogutils.c:718 +#: replication/walreceiver.c:994 replication/walsender.c:2156 #, c-format msgid "could not seek in log segment %s to offset %u: %m" msgstr "не удалоÑÑŒ перемеÑтитьÑÑ Ð² Ñегменте журнала %s к Ñмещению %u: %m" -#: access/transam/xlog.c:11188 +#: access/transam/xlog.c:11221 #, c-format msgid "could not read from log segment %s, offset %u: %m" msgstr "не удалоÑÑŒ прочитать Ñегмент журнала %s, Ñмещение %u: %m" -#: access/transam/xlog.c:11662 +#: access/transam/xlog.c:11695 #, c-format msgid "received promote request" msgstr "получен Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð¿Ð¾Ð²Ñ‹ÑˆÐµÐ½Ð¸Ñ ÑтатуÑа" -#: access/transam/xlog.c:11675 +#: access/transam/xlog.c:11708 #, c-format msgid "trigger file found: %s" msgstr "найден файл триггера: %s" -#: access/transam/xlog.c:11684 +#: access/transam/xlog.c:11717 #, c-format msgid "could not stat trigger file \"%s\": %m" msgstr "не удалоÑÑŒ получить информацию о файле триггера \"%s\": %m" @@ -3228,8 +2973,8 @@ msgid "%s \"%s\": %s" msgstr "%s \"%s\": %s" #: access/transam/xlogarchive.c:458 replication/logical/snapbuild.c:1619 -#: replication/slot.c:480 replication/slot.c:992 replication/slot.c:1100 -#: storage/file/fd.c:635 storage/file/fd.c:693 utils/time/snapmgr.c:1298 +#: replication/slot.c:496 replication/slot.c:1009 replication/slot.c:1117 +#: storage/file/fd.c:642 storage/file/fd.c:700 utils/time/snapmgr.c:1298 #, c-format msgid "could not rename file \"%s\" to \"%s\": %m" msgstr "не удалоÑÑŒ переименовать файл \"%s\" в \"%s\": %m" @@ -3244,107 +2989,107 @@ msgstr "не удалоÑÑŒ Ñоздать файл ÑоÑтоÑÐ½Ð¸Ñ Ð°Ñ€Ñ…Ð¸ msgid "could not write archive status file \"%s\": %m" msgstr "не удалоÑÑŒ запиÑать файл ÑоÑтоÑÐ½Ð¸Ñ Ð°Ñ€Ñ…Ð¸Ð²Ð° \"%s\": %m" -#: access/transam/xlogfuncs.c:58 +#: access/transam/xlogfuncs.c:56 #, c-format msgid "aborting backup due to backend exiting before pg_stop_backup was called" msgstr "" "прерывание резервного ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ð¸Ð·-за Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ð¾Ð±Ñлуживающего процеÑÑа " "до вызова pg_stop_backup" -#: access/transam/xlogfuncs.c:88 +#: access/transam/xlogfuncs.c:87 #, c-format msgid "a backup is already in progress in this session" msgstr "резервное копирование уже выполнÑетÑÑ Ð² Ñтом ÑеанÑе" -#: access/transam/xlogfuncs.c:94 commands/tablespace.c:705 -#: commands/tablespace.c:715 postmaster/postmaster.c:1406 +#: access/transam/xlogfuncs.c:93 commands/tablespace.c:705 +#: commands/tablespace.c:715 postmaster/postmaster.c:1424 #: replication/basebackup.c:297 replication/basebackup.c:637 -#: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2292 -#: storage/file/fd.c:2891 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 +#: storage/file/copydir.c:53 storage/file/copydir.c:96 storage/file/fd.c:2369 +#: storage/file/fd.c:2968 storage/ipc/dsm.c:300 utils/adt/genfile.c:439 #: utils/adt/misc.c:411 utils/misc/tzparser.c:339 #, c-format msgid "could not open directory \"%s\": %m" msgstr "не удалоÑÑŒ открыть каталог \"%s\": %m" -#: access/transam/xlogfuncs.c:155 access/transam/xlogfuncs.c:229 +#: access/transam/xlogfuncs.c:153 access/transam/xlogfuncs.c:226 #, c-format msgid "non-exclusive backup in progress" msgstr "выполнÑетÑÑ Ð½Ðµ монопольное резервное копирование" -#: access/transam/xlogfuncs.c:156 access/transam/xlogfuncs.c:230 +#: access/transam/xlogfuncs.c:154 access/transam/xlogfuncs.c:227 #, c-format msgid "Did you mean to use pg_stop_backup('f')?" msgstr "ВероÑтно, подразумевалоÑÑŒ pg_stop_backup('f')?" -#: access/transam/xlogfuncs.c:200 commands/event_trigger.c:1445 -#: commands/event_trigger.c:1996 commands/extension.c:1729 -#: commands/extension.c:1838 commands/extension.c:2031 commands/prepare.c:702 +#: access/transam/xlogfuncs.c:197 commands/event_trigger.c:1445 +#: commands/event_trigger.c:1996 commands/extension.c:1732 +#: commands/extension.c:1841 commands/extension.c:2034 commands/prepare.c:702 #: executor/execQual.c:1757 executor/execQual.c:1782 executor/execQual.c:2157 #: executor/execQual.c:5438 executor/functions.c:1031 foreign/foreign.c:492 -#: replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1391 -#: replication/slotfuncs.c:189 replication/walsender.c:2763 +#: replication/logical/logicalfuncs.c:175 replication/logical/origin.c:1394 +#: replication/slotfuncs.c:189 replication/walsender.c:2882 #: utils/adt/jsonfuncs.c:1483 utils/adt/jsonfuncs.c:1613 #: utils/adt/jsonfuncs.c:1801 utils/adt/jsonfuncs.c:1928 #: utils/adt/jsonfuncs.c:2694 utils/adt/pgstatfuncs.c:554 #: utils/adt/pgstatfuncs.c:655 utils/fmgr/funcapi.c:61 utils/misc/guc.c:8436 -#: utils/mmgr/portalmem.c:1074 +#: utils/mmgr/portalmem.c:1088 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "" "функциÑ, Ð²Ð¾Ð·Ð²Ñ€Ð°Ñ‰Ð°ÑŽÑ‰Ð°Ñ Ð¼Ð½Ð¾Ð¶ÐµÑтво, вызвана в контекÑте, где ему нет меÑта" -#: access/transam/xlogfuncs.c:204 commands/event_trigger.c:1449 -#: commands/event_trigger.c:2000 commands/extension.c:1733 -#: commands/extension.c:1842 commands/extension.c:2035 commands/prepare.c:706 +#: access/transam/xlogfuncs.c:201 commands/event_trigger.c:1449 +#: commands/event_trigger.c:2000 commands/extension.c:1736 +#: commands/extension.c:1845 commands/extension.c:2038 commands/prepare.c:706 #: foreign/foreign.c:497 replication/logical/logicalfuncs.c:179 -#: replication/logical/origin.c:1395 replication/slotfuncs.c:193 -#: replication/walsender.c:2767 utils/adt/pgstatfuncs.c:558 +#: replication/logical/origin.c:1398 replication/slotfuncs.c:193 +#: replication/walsender.c:2886 utils/adt/pgstatfuncs.c:558 #: utils/adt/pgstatfuncs.c:659 utils/misc/guc.c:8440 utils/misc/pg_config.c:44 -#: utils/mmgr/portalmem.c:1078 +#: utils/mmgr/portalmem.c:1092 #, c-format msgid "materialize mode required, but it is not allowed in this context" msgstr "требуетÑÑ Ñ€ÐµÐ¶Ð¸Ð¼ материализации, но он недопуÑтим в Ñтом контекÑте" -#: access/transam/xlogfuncs.c:247 +#: access/transam/xlogfuncs.c:243 #, c-format msgid "non-exclusive backup is not in progress" msgstr "немонопольное резервное копирование не выполнÑетÑÑ" -#: access/transam/xlogfuncs.c:248 +#: access/transam/xlogfuncs.c:244 #, c-format msgid "Did you mean to use pg_stop_backup('t')?" msgstr "ВероÑтно, подразумевалоÑÑŒ pg_stop_backup('t')?" -#: access/transam/xlogfuncs.c:326 +#: access/transam/xlogfuncs.c:321 #, c-format msgid "WAL level not sufficient for creating a restore point" msgstr "Выбранный уровень WAL не доÑтаточен Ð´Ð»Ñ ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ Ñ‚Ð¾Ñ‡ÐºÐ¸ воÑÑтановлениÑ" # well-spelled: Ñимв -#: access/transam/xlogfuncs.c:334 +#: access/transam/xlogfuncs.c:329 #, c-format msgid "value too long for restore point (maximum %d characters)" msgstr "значение Ð´Ð»Ñ Ñ‚Ð¾Ñ‡ÐºÐ¸ воÑÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð¿Ñ€ÐµÐ²Ñ‹ÑˆÐ°ÐµÑ‚ предел (%d Ñимв.)" -#: access/transam/xlogfuncs.c:472 +#: access/transam/xlogfuncs.c:467 #, c-format msgid "pg_xlogfile_name_offset() cannot be executed during recovery." msgstr "" "Функцию pg_xlogfile_name_offset() Ð½ÐµÐ»ÑŒÐ·Ñ Ð²Ñ‹Ð·Ñ‹Ð²Ð°Ñ‚ÑŒ во Ð²Ñ€ÐµÐ¼Ñ Ð²Ð¾ÑÑтановлениÑ." -#: access/transam/xlogfuncs.c:528 +#: access/transam/xlogfuncs.c:523 #, c-format msgid "pg_xlogfile_name() cannot be executed during recovery." msgstr "Функцию pg_xlogfile_name() Ð½ÐµÐ»ÑŒÐ·Ñ Ð²Ñ‹Ð·Ñ‹Ð²Ð°Ñ‚ÑŒ в процеÑÑе воÑÑтановлениÑ." -#: access/transam/xlogfuncs.c:548 access/transam/xlogfuncs.c:568 -#: access/transam/xlogfuncs.c:585 +#: access/transam/xlogfuncs.c:543 access/transam/xlogfuncs.c:563 +#: access/transam/xlogfuncs.c:580 #, c-format msgid "recovery is not in progress" msgstr "воÑÑтановление не выполнÑетÑÑ" -#: access/transam/xlogfuncs.c:549 access/transam/xlogfuncs.c:569 -#: access/transam/xlogfuncs.c:586 +#: access/transam/xlogfuncs.c:544 access/transam/xlogfuncs.c:564 +#: access/transam/xlogfuncs.c:581 #, c-format msgid "Recovery control functions can only be executed during recovery." msgstr "" @@ -3517,23 +3262,23 @@ msgstr "запиÑÑŒ Ñ Ð½ÐµÐ²ÐµÑ€Ð½Ð¾Ð¹ длиной в позиции %X/%X" msgid "invalid compressed image at %X/%X, block %d" msgstr "неверный Ñжатый образ в позиции %X/%X, блок %d" -#: access/transam/xlogutils.c:739 replication/walsender.c:2131 +#: access/transam/xlogutils.c:739 replication/walsender.c:2173 #, c-format msgid "could not read from log segment %s, offset %u, length %lu: %m" msgstr "не удалоÑÑŒ прочитать Ñегмент журнала %s (Ñмещение %u, длина %lu): %m" -#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:793 tcop/postgres.c:3501 +#: bootstrap/bootstrap.c:269 postmaster/postmaster.c:811 tcop/postgres.c:3499 #, c-format msgid "--%s requires a value" msgstr "Ð´Ð»Ñ --%s требуетÑÑ Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ðµ" -#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:798 tcop/postgres.c:3506 +#: bootstrap/bootstrap.c:274 postmaster/postmaster.c:816 tcop/postgres.c:3504 #, c-format msgid "-c %s requires a value" msgstr "Ð´Ð»Ñ -c %s требуетÑÑ Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ðµ" -#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:810 -#: postmaster/postmaster.c:823 +#: bootstrap/bootstrap.c:285 postmaster/postmaster.c:828 +#: postmaster/postmaster.c:841 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Ð”Ð»Ñ Ð´Ð¾Ð¿Ð¾Ð»Ð½Ð¸Ñ‚ÐµÐ»ÑŒÐ½Ð¾Ð¹ информации попробуйте \"%s --help\".\n" @@ -3663,24 +3408,24 @@ msgid "large object %u does not exist" msgstr "большой объект %u не ÑущеÑтвует" #: catalog/aclchk.c:882 catalog/aclchk.c:890 commands/collationcmds.c:92 -#: commands/copy.c:1047 commands/copy.c:1065 commands/copy.c:1073 -#: commands/copy.c:1081 commands/copy.c:1089 commands/copy.c:1097 -#: commands/copy.c:1105 commands/copy.c:1113 commands/copy.c:1121 -#: commands/copy.c:1137 commands/copy.c:1151 commands/copy.c:1170 -#: commands/copy.c:1185 commands/dbcommands.c:155 commands/dbcommands.c:163 +#: commands/copy.c:1048 commands/copy.c:1066 commands/copy.c:1074 +#: commands/copy.c:1082 commands/copy.c:1090 commands/copy.c:1098 +#: commands/copy.c:1106 commands/copy.c:1114 commands/copy.c:1122 +#: commands/copy.c:1138 commands/copy.c:1152 commands/copy.c:1171 +#: commands/copy.c:1186 commands/dbcommands.c:155 commands/dbcommands.c:163 #: commands/dbcommands.c:171 commands/dbcommands.c:179 #: commands/dbcommands.c:187 commands/dbcommands.c:195 #: commands/dbcommands.c:203 commands/dbcommands.c:211 #: commands/dbcommands.c:219 commands/dbcommands.c:1397 #: commands/dbcommands.c:1405 commands/dbcommands.c:1413 -#: commands/dbcommands.c:1421 commands/extension.c:1219 -#: commands/extension.c:1227 commands/extension.c:1235 -#: commands/extension.c:1243 commands/extension.c:2761 +#: commands/dbcommands.c:1421 commands/extension.c:1222 +#: commands/extension.c:1230 commands/extension.c:1238 +#: commands/extension.c:1246 commands/extension.c:2764 #: commands/foreigncmds.c:539 commands/foreigncmds.c:548 #: commands/functioncmds.c:533 commands/functioncmds.c:649 #: commands/functioncmds.c:657 commands/functioncmds.c:665 -#: commands/functioncmds.c:673 commands/functioncmds.c:2085 -#: commands/functioncmds.c:2093 commands/sequence.c:1189 +#: commands/functioncmds.c:673 commands/functioncmds.c:2105 +#: commands/functioncmds.c:2113 commands/sequence.c:1189 #: commands/sequence.c:1197 commands/sequence.c:1205 commands/sequence.c:1213 #: commands/sequence.c:1221 commands/sequence.c:1229 commands/sequence.c:1237 #: commands/sequence.c:1245 commands/typecmds.c:295 commands/typecmds.c:1382 @@ -3704,21 +3449,21 @@ msgid "default privileges cannot be set for columns" msgstr "права по умолчанию Ð½ÐµÐ»ÑŒÐ·Ñ Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»Ð¸Ñ‚ÑŒ Ð´Ð»Ñ Ñтолбцов" #: catalog/aclchk.c:1502 catalog/objectaddress.c:1390 commands/analyze.c:376 -#: commands/copy.c:4458 commands/sequence.c:1491 commands/tablecmds.c:5198 -#: commands/tablecmds.c:5304 commands/tablecmds.c:5364 -#: commands/tablecmds.c:5477 commands/tablecmds.c:5534 -#: commands/tablecmds.c:5628 commands/tablecmds.c:5724 -#: commands/tablecmds.c:7915 commands/tablecmds.c:8177 -#: commands/tablecmds.c:8597 commands/trigger.c:642 parser/analyze.c:2228 +#: commands/copy.c:4459 commands/sequence.c:1491 commands/tablecmds.c:5211 +#: commands/tablecmds.c:5317 commands/tablecmds.c:5377 +#: commands/tablecmds.c:5490 commands/tablecmds.c:5547 +#: commands/tablecmds.c:5641 commands/tablecmds.c:5737 +#: commands/tablecmds.c:7929 commands/tablecmds.c:8191 +#: commands/tablecmds.c:8611 commands/trigger.c:642 parser/analyze.c:2228 #: parser/parse_relation.c:2628 parser/parse_relation.c:2690 #: parser/parse_target.c:951 parser/parse_type.c:127 utils/adt/acl.c:2840 -#: utils/adt/ruleutils.c:1984 +#: utils/adt/ruleutils.c:1987 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist" msgstr "Ñтолбец \"%s\" в таблице \"%s\" не ÑущеÑтвует" #: catalog/aclchk.c:1771 catalog/objectaddress.c:1203 commands/sequence.c:1078 -#: commands/tablecmds.c:224 commands/tablecmds.c:12154 utils/adt/acl.c:2076 +#: commands/tablecmds.c:224 commands/tablecmds.c:12168 utils/adt/acl.c:2076 #: utils/adt/acl.c:2106 utils/adt/acl.c:2138 utils/adt/acl.c:2170 #: utils/adt/acl.c:2198 utils/adt/acl.c:2228 #, c-format @@ -3771,7 +3516,7 @@ msgstr "Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² маÑÑивов Ð½ÐµÐ»ÑŒÐ·Ñ Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»Ð¸Ñ‚ÑŒ п msgid "Set the privileges of the element type instead." msgstr "ВмеÑто Ñтого уÑтановите права Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° Ñлемента." -#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3146 +#: catalog/aclchk.c:3137 catalog/objectaddress.c:1523 commands/typecmds.c:3161 #, c-format msgid "\"%s\" is not a domain" msgstr "\"%s\" - Ñто не домен" @@ -4176,12 +3921,12 @@ msgid "System catalog modifications are currently disallowed." msgstr "Изменение ÑиÑтемного каталога в текущем ÑоÑтоÑнии запрещено." #: catalog/heap.c:415 commands/tablecmds.c:1439 commands/tablecmds.c:1896 -#: commands/tablecmds.c:4820 +#: commands/tablecmds.c:4833 #, c-format msgid "tables can have at most %d columns" msgstr "макÑимальное чиÑло Ñтолбцов в таблице: %d" -#: catalog/heap.c:432 commands/tablecmds.c:5081 +#: catalog/heap.c:432 commands/tablecmds.c:5094 #, c-format msgid "column name \"%s\" conflicts with a system column name" msgstr "Ð¸Ð¼Ñ Ñтолбца \"%s\" конфликтует Ñ ÑиÑтемным Ñтолбцом" @@ -4219,11 +3964,11 @@ msgstr "" "Ñортировки" #: catalog/heap.c:586 commands/createas.c:204 commands/createas.c:501 -#: commands/indexcmds.c:1132 commands/view.c:103 regex/regc_pg_locale.c:262 +#: commands/indexcmds.c:1133 commands/view.c:103 regex/regc_pg_locale.c:262 #: utils/adt/formatting.c:1513 utils/adt/formatting.c:1565 #: utils/adt/formatting.c:1633 utils/adt/formatting.c:1685 #: utils/adt/formatting.c:1754 utils/adt/formatting.c:1818 utils/adt/like.c:213 -#: utils/adt/selfuncs.c:5334 utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 +#: utils/adt/selfuncs.c:5434 utils/adt/varlena.c:1421 utils/adt/varlena.c:1826 #, c-format msgid "Use the COLLATE clause to set the collation explicitly." msgstr "Задайте правило Ñортировки Ñвно в предложении COLLATE." @@ -4233,7 +3978,7 @@ msgstr "Задайте правило Ñортировки Ñвно в пред msgid "relation \"%s\" already exists" msgstr "отношение \"%s\" уже ÑущеÑтвует" -#: catalog/heap.c:1083 catalog/pg_type.c:412 catalog/pg_type.c:722 +#: catalog/heap.c:1083 catalog/pg_type.c:412 catalog/pg_type.c:737 #: commands/typecmds.c:237 commands/typecmds.c:784 commands/typecmds.c:1135 #: commands/typecmds.c:1357 commands/typecmds.c:2113 #, c-format @@ -4259,7 +4004,7 @@ msgstr "значение OID кучи в pg_class не задано в режи msgid "check constraint \"%s\" already exists" msgstr "ограничение-проверка \"%s\" уже ÑущеÑтвует" -#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6069 +#: catalog/heap.c:2456 catalog/pg_constraint.c:654 commands/tablecmds.c:6082 #, c-format msgid "constraint \"%s\" for relation \"%s\" already exists" msgstr "ограничение \"%s\" Ð´Ð»Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\" уже ÑущеÑтвует" @@ -4301,14 +4046,14 @@ msgstr "в выражении по умолчанию Ð½ÐµÐ»ÑŒÐ·Ñ ÑÑылат msgid "default expression must not return a set" msgstr "выражение по умолчанию не может возвращать множеÑтво" -#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1084 +#: catalog/heap.c:2625 rewrite/rewriteHandler.c:1115 #, c-format msgid "column \"%s\" is of type %s but default expression is of type %s" msgstr "Ñтолбец \"%s\" имеет тип %s, но тип Ð²Ñ‹Ñ€Ð°Ð¶ÐµÐ½Ð¸Ñ Ð¿Ð¾ умолчанию %s" #: catalog/heap.c:2630 commands/prepare.c:374 parser/parse_node.c:428 #: parser/parse_target.c:539 parser/parse_target.c:789 -#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1089 +#: parser/parse_target.c:799 rewrite/rewriteHandler.c:1120 #, c-format msgid "You will need to rewrite or cast the expression." msgstr "Перепишите выражение или преобразуйте его тип." @@ -4347,7 +4092,7 @@ msgid "Truncate table \"%s\" at the same time, or use TRUNCATE ... CASCADE." msgstr "" "ОпуÑтошите таблицу \"%s\" параллельно или иÑпользуйте TRUNCATE ... CASCADE." -#: catalog/index.c:210 parser/parse_utilcmd.c:1473 parser/parse_utilcmd.c:1559 +#: catalog/index.c:210 parser/parse_utilcmd.c:1474 parser/parse_utilcmd.c:1560 #, c-format msgid "multiple primary keys for table \"%s\" are not allowed" msgstr "таблица \"%s\" не может иметь неÑколько первичных ключей" @@ -4376,7 +4121,7 @@ msgid "shared indexes cannot be created after initdb" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ Ñоздать разделÑемые индекÑÑ‹ поÑле initdb" #: catalog/index.c:784 commands/createas.c:249 commands/sequence.c:141 -#: parser/parse_utilcmd.c:191 +#: parser/parse_utilcmd.c:192 #, c-format msgid "relation \"%s\" already exists, skipping" msgstr "отношение \"%s\" уже ÑущеÑтвует, пропуÑкаетÑÑ" @@ -4407,12 +4152,6 @@ msgstr "переиндекÑировать временные таблицы д msgid "index \"%s\" was reindexed" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" был переÑтроен" -#: catalog/index.c:3456 commands/vacuumlazy.c:1338 commands/vacuumlazy.c:1414 -#: commands/vacuumlazy.c:1603 commands/vacuumlazy.c:1813 -#, c-format -msgid "%s." -msgstr "%s." - #: catalog/namespace.c:249 catalog/namespace.c:447 catalog/namespace.c:541 #: commands/trigger.c:4523 #, c-format @@ -4440,13 +4179,13 @@ msgid "relation \"%s.%s\" does not exist" msgstr "отношение \"%s.%s\" не ÑущеÑтвует" #: catalog/namespace.c:419 parser/parse_relation.c:1151 -#: parser/parse_relation.c:1159 utils/adt/regproc.c:1034 +#: parser/parse_relation.c:1159 utils/adt/regproc.c:1035 #, c-format msgid "relation \"%s\" does not exist" msgstr "отношение \"%s\" не ÑущеÑтвует" -#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1383 -#: commands/extension.c:1389 +#: catalog/namespace.c:487 catalog/namespace.c:2841 commands/extension.c:1386 +#: commands/extension.c:1392 #, c-format msgid "no schema has been selected to create in" msgstr "Ñхема Ð´Ð»Ñ ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ Ð¾Ð±ÑŠÐµÐºÑ‚Ð¾Ð² не выбрана" @@ -4493,7 +4232,7 @@ msgid "cross-database references are not implemented: %s" msgstr "ÑÑылки между базами не реализованы: %s" #: catalog/namespace.c:2652 parser/parse_expr.c:799 parser/parse_target.c:1148 -#: gram.y:13450 gram.y:14819 +#: gram.y:13463 gram.y:14832 #, c-format msgid "improper qualified name (too many dotted names): %s" msgstr "неверное полное Ð¸Ð¼Ñ (Ñлишком много компонентов): %s" @@ -4541,8 +4280,8 @@ msgstr "Ñоздавать временные таблицы в процеÑÑе #: catalog/namespace.c:3688 #, c-format -msgid "cannot create temporary tables in parallel mode" -msgstr "Ñоздавать временные таблицы в параллельном режиме нельзÑ" +msgid "cannot create temporary tables during a parallel operation" +msgstr "Ñоздавать временные таблицы во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" #: catalog/namespace.c:3932 commands/tablespace.c:1173 commands/variable.c:63 #: utils/misc/guc.c:9875 @@ -4558,7 +4297,7 @@ msgstr "Ð¸Ð¼Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð° доÑтупа не может быть ÑоÑтав msgid "database name cannot be qualified" msgstr "Ð¸Ð¼Ñ Ð±Ð°Ð·Ñ‹ данных не может быть ÑоÑтавным" -#: catalog/objectaddress.c:1071 commands/extension.c:2507 +#: catalog/objectaddress.c:1071 commands/extension.c:2510 #, c-format msgid "extension name cannot be qualified" msgstr "Ð¸Ð¼Ñ Ñ€Ð°ÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ Ð½Ðµ может быть ÑоÑтавным" @@ -4594,25 +4333,25 @@ msgstr "Ð¸Ð¼Ñ Ñобытийного триггера не может быть #: catalog/objectaddress.c:1210 commands/lockcmds.c:94 commands/policy.c:94 #: commands/policy.c:382 commands/policy.c:471 commands/tablecmds.c:218 #: commands/tablecmds.c:1300 commands/tablecmds.c:4347 -#: commands/tablecmds.c:8017 +#: commands/tablecmds.c:8031 #, c-format msgid "\"%s\" is not a table" msgstr "\"%s\" - Ñто не таблица" #: catalog/objectaddress.c:1217 commands/tablecmds.c:230 -#: commands/tablecmds.c:4377 commands/tablecmds.c:12159 commands/view.c:141 +#: commands/tablecmds.c:4377 commands/tablecmds.c:12173 commands/view.c:141 #, c-format msgid "\"%s\" is not a view" msgstr "\"%s\" - Ñто не предÑтавление" #: catalog/objectaddress.c:1224 commands/matview.c:174 commands/tablecmds.c:236 -#: commands/tablecmds.c:12164 +#: commands/tablecmds.c:12178 #, c-format msgid "\"%s\" is not a materialized view" msgstr "\"%s\" - Ñто не материализованное предÑтавление" #: catalog/objectaddress.c:1231 commands/tablecmds.c:254 -#: commands/tablecmds.c:4380 commands/tablecmds.c:12169 +#: commands/tablecmds.c:4380 commands/tablecmds.c:12183 #, c-format msgid "\"%s\" is not a foreign table" msgstr "\"%s\" - Ñто не ÑтороннÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð°" @@ -4629,9 +4368,9 @@ msgstr "" "значение по умолчанию Ð´Ð»Ñ Ñтолбца \"%s\" Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\" не ÑущеÑтвует" #: catalog/objectaddress.c:1512 commands/functioncmds.c:128 -#: commands/tablecmds.c:246 commands/typecmds.c:3214 parser/parse_type.c:226 +#: commands/tablecmds.c:246 commands/typecmds.c:3229 parser/parse_type.c:226 #: parser/parse_type.c:255 parser/parse_type.c:795 utils/adt/acl.c:4374 -#: utils/adt/regproc.c:1225 +#: utils/adt/regproc.c:1226 #, c-format msgid "type \"%s\" does not exist" msgstr "тип \"%s\" не ÑущеÑтвует" @@ -4641,163 +4380,163 @@ msgstr "тип \"%s\" не ÑущеÑтвует" msgid "operator %d (%s, %s) of %s does not exist" msgstr "оператор %d (%s, %s) из ÑемейÑтва %s не ÑущеÑтвует" -#: catalog/objectaddress.c:1658 +#: catalog/objectaddress.c:1660 #, c-format msgid "function %d (%s, %s) of %s does not exist" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ %d (%s, %s) из ÑемейÑтва %s не ÑущеÑтвует" -#: catalog/objectaddress.c:1707 catalog/objectaddress.c:1733 +#: catalog/objectaddress.c:1711 catalog/objectaddress.c:1737 #, c-format msgid "user mapping for user \"%s\" on server \"%s\" does not exist" msgstr "ÑопоÑтавление Ð´Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" на Ñервере \"%s\" не ÑущеÑтвует" -#: catalog/objectaddress.c:1722 commands/foreigncmds.c:430 +#: catalog/objectaddress.c:1726 commands/foreigncmds.c:430 #: commands/foreigncmds.c:997 commands/foreigncmds.c:1359 foreign/foreign.c:692 #, c-format msgid "server \"%s\" does not exist" msgstr "Ñервер \"%s\" не ÑущеÑтвует" -#: catalog/objectaddress.c:1794 +#: catalog/objectaddress.c:1798 #, c-format msgid "unrecognized default ACL object type %c" msgstr "нераÑпознанный тип объекта ACL по умолчанию: %c" -#: catalog/objectaddress.c:1795 +#: catalog/objectaddress.c:1799 #, c-format msgid "Valid object types are \"r\", \"S\", \"f\", and \"T\"." msgstr "ДопуÑтимые значениÑ: \"r\", \"S\", \"f\" и \"T\"." -#: catalog/objectaddress.c:1841 +#: catalog/objectaddress.c:1845 #, c-format msgid "default ACL for user \"%s\" in schema \"%s\" on %s does not exist" msgstr "" "ACL по умолчанию Ð´Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" в Ñхеме \"%s\" Ð´Ð»Ñ Ð¾Ð±ÑŠÐµÐºÑ‚Ð° %s не " "ÑущеÑтвует" -#: catalog/objectaddress.c:1846 +#: catalog/objectaddress.c:1850 #, c-format msgid "default ACL for user \"%s\" on %s does not exist" msgstr "" "ACL по умолчанию Ð´Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" и Ð´Ð»Ñ Ð¾Ð±ÑŠÐµÐºÑ‚Ð° %s не ÑущеÑтвует" -#: catalog/objectaddress.c:1873 catalog/objectaddress.c:1929 -#: catalog/objectaddress.c:1984 +#: catalog/objectaddress.c:1877 catalog/objectaddress.c:1933 +#: catalog/objectaddress.c:1988 #, c-format msgid "name or argument lists may not contain nulls" msgstr "ÑпиÑки имён и аргументов не должны Ñодержать NULL" -#: catalog/objectaddress.c:1905 +#: catalog/objectaddress.c:1909 #, c-format msgid "unsupported object type \"%s\"" msgstr "неподдерживаемый тип объекта: \"%s\"" -#: catalog/objectaddress.c:1925 catalog/objectaddress.c:1943 +#: catalog/objectaddress.c:1929 catalog/objectaddress.c:1947 #, c-format msgid "name list length must be exactly %d" msgstr "длина ÑпиÑка имён должна быть равна %d" -#: catalog/objectaddress.c:1947 +#: catalog/objectaddress.c:1951 #, c-format msgid "large object OID may not be null" msgstr "OID большого объекта не может быть NULL" -#: catalog/objectaddress.c:1956 catalog/objectaddress.c:2016 -#: catalog/objectaddress.c:2023 +#: catalog/objectaddress.c:1960 catalog/objectaddress.c:2020 +#: catalog/objectaddress.c:2027 #, c-format msgid "name list length must be at least %d" msgstr "длина ÑпиÑка аргументов должна быть не меньше %d" -#: catalog/objectaddress.c:2009 catalog/objectaddress.c:2029 +#: catalog/objectaddress.c:2013 catalog/objectaddress.c:2033 #, c-format msgid "argument list length must be exactly %d" msgstr "длина ÑпиÑка аргументов должна быть равна %d" -#: catalog/objectaddress.c:2165 libpq/be-fsstubs.c:350 +#: catalog/objectaddress.c:2169 libpq/be-fsstubs.c:350 #, c-format msgid "must be owner of large object %u" msgstr "нужно быть владельцем большого объекта %u" -#: catalog/objectaddress.c:2180 commands/functioncmds.c:1426 +#: catalog/objectaddress.c:2184 commands/functioncmds.c:1446 #, c-format msgid "must be owner of type %s or type %s" msgstr "Ñто разрешено только владельцу типа %s или %s" -#: catalog/objectaddress.c:2220 catalog/objectaddress.c:2237 +#: catalog/objectaddress.c:2224 catalog/objectaddress.c:2241 #, c-format msgid "must be superuser" msgstr "требуютÑÑ Ð¿Ñ€Ð°Ð²Ð° ÑуперпользователÑ" -#: catalog/objectaddress.c:2227 +#: catalog/objectaddress.c:2231 #, c-format msgid "must have CREATEROLE privilege" msgstr "требуетÑÑ Ð¿Ñ€Ð°Ð²Ð¾ CREATEROLE" -#: catalog/objectaddress.c:2302 +#: catalog/objectaddress.c:2306 #, c-format msgid "unrecognized object type \"%s\"" msgstr "нераÑпознанный тип объекта \"%s\"" -#: catalog/objectaddress.c:2497 +#: catalog/objectaddress.c:2501 #, c-format msgid " column %s" msgstr " Ñтолбец %s" -#: catalog/objectaddress.c:2503 +#: catalog/objectaddress.c:2507 #, c-format msgid "function %s" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ %s" -#: catalog/objectaddress.c:2508 +#: catalog/objectaddress.c:2512 #, c-format msgid "type %s" msgstr "тип %s" -#: catalog/objectaddress.c:2538 +#: catalog/objectaddress.c:2542 #, c-format msgid "cast from %s to %s" msgstr "приведение %s к %s" -#: catalog/objectaddress.c:2558 +#: catalog/objectaddress.c:2562 #, c-format msgid "collation %s" msgstr "правило Ñортировки %s" -#: catalog/objectaddress.c:2582 +#: catalog/objectaddress.c:2586 #, c-format msgid "constraint %s on %s" msgstr "ограничение %s в отношении %s" -#: catalog/objectaddress.c:2588 +#: catalog/objectaddress.c:2592 #, c-format msgid "constraint %s" msgstr "ограничение %s" -#: catalog/objectaddress.c:2605 +#: catalog/objectaddress.c:2609 #, c-format msgid "conversion %s" msgstr "преобразование %s" -#: catalog/objectaddress.c:2642 +#: catalog/objectaddress.c:2646 #, c-format msgid "default for %s" msgstr "значение по умолчанию, %s" -#: catalog/objectaddress.c:2651 +#: catalog/objectaddress.c:2655 #, c-format msgid "language %s" msgstr "Ñзык %s" -#: catalog/objectaddress.c:2656 +#: catalog/objectaddress.c:2660 #, c-format msgid "large object %u" msgstr "большой объект %u" -#: catalog/objectaddress.c:2661 +#: catalog/objectaddress.c:2665 #, c-format msgid "operator %s" msgstr "оператор %s" -#: catalog/objectaddress.c:2693 +#: catalog/objectaddress.c:2697 #, c-format msgid "operator class %s for access method %s" msgstr "клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð² %s Ð´Ð»Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð° доÑтупа %s" @@ -4806,7 +4545,7 @@ msgstr "клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð² %s Ð´Ð»Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð° доÑтупа %s #. first two %s's are data type names, the third %s is the #. description of the operator family, and the last %s is the #. textual form of the operator with arguments. -#: catalog/objectaddress.c:2743 +#: catalog/objectaddress.c:2747 #, c-format msgid "operator %d (%s, %s) of %s: %s" msgstr "оператор %d (%s, %s) из ÑемейÑтва \"%s\": %s" @@ -4815,178 +4554,178 @@ msgstr "оператор %d (%s, %s) из ÑемейÑтва \"%s\": %s" #. are data type names, the third %s is the description of the #. operator family, and the last %s is the textual form of the #. function with arguments. -#: catalog/objectaddress.c:2793 +#: catalog/objectaddress.c:2797 #, c-format msgid "function %d (%s, %s) of %s: %s" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ %d (%s, %s) из ÑемейÑтва \"%s\": %s" -#: catalog/objectaddress.c:2833 +#: catalog/objectaddress.c:2837 #, c-format msgid "rule %s on " msgstr "правило %s Ð´Ð»Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ: " -#: catalog/objectaddress.c:2855 +#: catalog/objectaddress.c:2859 #, c-format msgid "transform for %s language %s" msgstr "преобразование Ð´Ð»Ñ %s, Ñзыка %s" -#: catalog/objectaddress.c:2889 +#: catalog/objectaddress.c:2893 #, c-format msgid "trigger %s on " msgstr "триггер %s в отношении: " -#: catalog/objectaddress.c:2906 +#: catalog/objectaddress.c:2910 #, c-format msgid "schema %s" msgstr "Ñхема %s" -#: catalog/objectaddress.c:2919 +#: catalog/objectaddress.c:2923 #, c-format msgid "text search parser %s" msgstr "анализатор текÑтового поиÑка %s" -#: catalog/objectaddress.c:2934 +#: catalog/objectaddress.c:2938 #, c-format msgid "text search dictionary %s" msgstr "Ñловарь текÑтового поиÑка %s" -#: catalog/objectaddress.c:2949 +#: catalog/objectaddress.c:2953 #, c-format msgid "text search template %s" msgstr "шаблон текÑтового поиÑка %s" -#: catalog/objectaddress.c:2964 +#: catalog/objectaddress.c:2968 #, c-format msgid "text search configuration %s" msgstr "ÐºÐ¾Ð½Ñ„Ð¸Ð³ÑƒÑ€Ð°Ñ†Ð¸Ñ Ñ‚ÐµÐºÑтового поиÑка %s" -#: catalog/objectaddress.c:2972 +#: catalog/objectaddress.c:2976 #, c-format msgid "role %s" msgstr "роль %s" -#: catalog/objectaddress.c:2985 +#: catalog/objectaddress.c:2989 #, c-format msgid "database %s" msgstr "база данных %s" -#: catalog/objectaddress.c:2997 +#: catalog/objectaddress.c:3001 #, c-format msgid "tablespace %s" msgstr "табличное проÑтранÑтво %s" -#: catalog/objectaddress.c:3006 +#: catalog/objectaddress.c:3010 #, c-format msgid "foreign-data wrapper %s" msgstr "обёртка Ñторонних данных %s" -#: catalog/objectaddress.c:3015 +#: catalog/objectaddress.c:3019 #, c-format msgid "server %s" msgstr "Ñервер %s" -#: catalog/objectaddress.c:3043 +#: catalog/objectaddress.c:3047 #, c-format msgid "user mapping for %s on server %s" msgstr "ÑопоÑтавление Ð´Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ %s на Ñервере %s" -#: catalog/objectaddress.c:3078 +#: catalog/objectaddress.c:3082 #, c-format msgid "default privileges on new relations belonging to role %s" msgstr "права по умолчанию Ð´Ð»Ñ Ð½Ð¾Ð²Ñ‹Ñ… отношений, принадлежащих роли %s" -#: catalog/objectaddress.c:3083 +#: catalog/objectaddress.c:3087 #, c-format msgid "default privileges on new sequences belonging to role %s" msgstr "" "права по умолчанию Ð´Ð»Ñ Ð½Ð¾Ð²Ñ‹Ñ… поÑледовательноÑтей, принадлежащих роли %s" -#: catalog/objectaddress.c:3088 +#: catalog/objectaddress.c:3092 #, c-format msgid "default privileges on new functions belonging to role %s" msgstr "права по умолчанию Ð´Ð»Ñ Ð½Ð¾Ð²Ñ‹Ñ… функций, принадлежащих роли %s" -#: catalog/objectaddress.c:3093 +#: catalog/objectaddress.c:3097 #, c-format msgid "default privileges on new types belonging to role %s" msgstr "права по умолчанию Ð´Ð»Ñ Ð½Ð¾Ð²Ñ‹Ñ… типов, принадлежащих роли %s" -#: catalog/objectaddress.c:3099 +#: catalog/objectaddress.c:3103 #, c-format msgid "default privileges belonging to role %s" msgstr "права по умолчанию Ð´Ð»Ñ Ð½Ð¾Ð²Ñ‹Ñ… объектов, принадлежащих роли %s" -#: catalog/objectaddress.c:3107 +#: catalog/objectaddress.c:3111 #, c-format msgid " in schema %s" msgstr " в Ñхеме %s" -#: catalog/objectaddress.c:3124 +#: catalog/objectaddress.c:3128 #, c-format msgid "extension %s" msgstr "раÑширение %s" -#: catalog/objectaddress.c:3137 +#: catalog/objectaddress.c:3141 #, c-format msgid "event trigger %s" msgstr "Ñобытийный триггер %s" -#: catalog/objectaddress.c:3169 +#: catalog/objectaddress.c:3173 #, c-format msgid "policy %s on " msgstr "политика %s Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ " -#: catalog/objectaddress.c:3187 +#: catalog/objectaddress.c:3191 #, c-format msgid "access method %s" msgstr "метод доÑтупа %s" -#: catalog/objectaddress.c:3247 +#: catalog/objectaddress.c:3251 #, c-format msgid "table %s" msgstr "таблица %s" -#: catalog/objectaddress.c:3251 +#: catalog/objectaddress.c:3255 #, c-format msgid "index %s" msgstr "Ð¸Ð½Ð´ÐµÐºÑ %s" -#: catalog/objectaddress.c:3255 +#: catalog/objectaddress.c:3259 #, c-format msgid "sequence %s" msgstr "поÑледовательноÑÑ‚ÑŒ %s" -#: catalog/objectaddress.c:3259 +#: catalog/objectaddress.c:3263 #, c-format msgid "toast table %s" msgstr "TOAST-таблица %s" -#: catalog/objectaddress.c:3263 +#: catalog/objectaddress.c:3267 #, c-format msgid "view %s" msgstr "предÑтавление %s" -#: catalog/objectaddress.c:3267 +#: catalog/objectaddress.c:3271 #, c-format msgid "materialized view %s" msgstr "материализованное предÑтавление %s" -#: catalog/objectaddress.c:3271 +#: catalog/objectaddress.c:3275 #, c-format msgid "composite type %s" msgstr "ÑоÑтавной тип %s" -#: catalog/objectaddress.c:3275 +#: catalog/objectaddress.c:3279 #, c-format msgid "foreign table %s" msgstr "ÑтороннÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° %s" -#: catalog/objectaddress.c:3280 +#: catalog/objectaddress.c:3284 #, c-format msgid "relation %s" msgstr "отношение %s" -#: catalog/objectaddress.c:3317 +#: catalog/objectaddress.c:3321 #, c-format msgid "operator family %s for access method %s" msgstr "ÑемейÑтво операторов %s Ð´Ð»Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð° доÑтупа %s" @@ -5069,10 +4808,9 @@ msgstr "ÐºÐ¾Ð¼Ð±Ð¸Ð½Ð¸Ñ€ÑƒÑŽÑ‰Ð°Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ %s должна возвращ #: catalog/pg_aggregate.c:436 #, c-format -msgid "" -"combine function with \"%s\" transition type must not be declared STRICT" +msgid "combine function with transition type %s must not be declared STRICT" msgstr "" -"ÐºÐ¾Ð¼Ð±Ð¸Ð½Ð¸Ñ€ÑƒÑŽÑ‰Ð°Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ñ Ð¿ÐµÑ€ÐµÑ…Ð¾Ð´Ð½Ñ‹Ð¼ типом \"%s\" не должна объÑвлÑÑ‚ÑŒÑÑ ÐºÐ°Ðº " +"ÐºÐ¾Ð¼Ð±Ð¸Ð½Ð¸Ñ€ÑƒÑŽÑ‰Ð°Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ñ Ð¿ÐµÑ€ÐµÑ…Ð¾Ð´Ð½Ñ‹Ð¼ типом %s не должна объÑвлÑÑ‚ÑŒÑÑ ÐºÐ°Ðº " "ÑÑ‚Ñ€Ð¾Ð³Ð°Ñ (STRICT)" #: catalog/pg_aggregate.c:455 @@ -5201,7 +4939,7 @@ msgstr "преобразование \"%s\" уже ÑущеÑтвует" msgid "default conversion for %s to %s already exists" msgstr "преобразование по умолчанию из %s в %s уже ÑущеÑтвует" -#: catalog/pg_depend.c:165 commands/extension.c:3029 +#: catalog/pg_depend.c:165 commands/extension.c:3032 #, c-format msgid "%s is already a member of extension \"%s\"" msgstr "%s уже отноÑитÑÑ Ðº раÑширению \"%s\"" @@ -5538,13 +5276,13 @@ msgstr "выравнивание \"%c\" не подходит Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° п msgid "fixed-size types must have storage PLAIN" msgstr "Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² поÑтоÑнного размера применим только режим Ñ…Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ PLAIN" -#: catalog/pg_type.c:789 +#: catalog/pg_type.c:809 #, c-format msgid "could not form array type name for type \"%s\"" msgstr "не удалоÑÑŒ Ñформировать Ð¸Ð¼Ñ Ñ‚Ð¸Ð¿Ð° маÑÑива Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° \"%s\"" #: catalog/toasting.c:105 commands/indexcmds.c:389 commands/tablecmds.c:4359 -#: commands/tablecmds.c:12047 +#: commands/tablecmds.c:12061 #, c-format msgid "\"%s\" is not a table or materialized view" msgstr "\"%s\" - Ñто не таблица и не материализованное предÑтавление" @@ -5720,7 +5458,7 @@ msgstr "метод доÑтупа \"%s\" уже ÑущеÑтвует" msgid "must be superuser to drop access methods" msgstr "Ð´Ð»Ñ ÑƒÐ´Ð°Ð»ÐµÐ½Ð¸Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð¾Ð² доÑтупа нужно быть Ñуперпользователем" -#: commands/amcmds.c:175 commands/indexcmds.c:164 commands/indexcmds.c:495 +#: commands/amcmds.c:175 commands/indexcmds.c:164 commands/indexcmds.c:496 #: commands/opclasscmds.c:365 commands/opclasscmds.c:790 #, c-format msgid "access method \"%s\" does not exist" @@ -5819,7 +5557,7 @@ msgstr "" "пропуÑкаетÑÑ Ð°Ð½Ð°Ð»Ð¸Ð· дерева наÑÐ»ÐµÐ´Ð¾Ð²Ð°Ð½Ð¸Ñ \"%s.%s\" --- Ñто дерево " "наÑÐ»ÐµÐ´Ð¾Ð²Ð°Ð½Ð¸Ñ Ð½Ðµ Ñодержит анализируемых дочерних таблиц" -#: commands/analyze.c:1420 commands/tablecmds.c:8079 executor/execQual.c:2927 +#: commands/analyze.c:1420 commands/tablecmds.c:8093 executor/execQual.c:2927 msgid "could not convert row type" msgstr "не удалоÑÑŒ преобразовать тип Ñтроки" @@ -5883,7 +5621,7 @@ msgstr "клаÑтеризовать временные таблицы друг msgid "there is no previously clustered index for table \"%s\"" msgstr "таблица \"%s\" ранее не клаÑтеризовалаÑÑŒ по какому-либо индекÑу" -#: commands/cluster.c:173 commands/tablecmds.c:9383 commands/tablecmds.c:11143 +#: commands/cluster.c:173 commands/tablecmds.c:9397 commands/tablecmds.c:11157 #, c-format msgid "index \"%s\" for table \"%s\" does not exist" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\" не ÑущеÑтвует" @@ -5898,7 +5636,7 @@ msgstr "клаÑтеризовать разделÑемый каталог не msgid "cannot vacuum temporary tables of other sessions" msgstr "очищать временные таблицы других ÑеанÑов нельзÑ" -#: commands/cluster.c:431 commands/tablecmds.c:11153 +#: commands/cluster.c:431 commands/tablecmds.c:11167 #, c-format msgid "\"%s\" is not an index for table \"%s\"" msgstr "\"%s\" не ÑвлÑетÑÑ Ð¸Ð½Ð´ÐµÐºÑом таблицы \"%s\"" @@ -5921,23 +5659,23 @@ msgstr "клаÑтеризовать по чаÑтичному индекÑу \" msgid "cannot cluster on invalid index \"%s\"" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ ÐºÐ»Ð°Ñтеризовать таблицу по неверному индекÑу \"%s\"" -#: commands/cluster.c:918 +#: commands/cluster.c:920 #, c-format msgid "clustering \"%s.%s\" using index scan on \"%s\"" msgstr "клаÑÑ‚ÐµÑ€Ð¸Ð·Ð°Ñ†Ð¸Ñ \"%s.%s\" путём ÑÐºÐ°Ð½Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ð¸Ð½Ð´ÐµÐºÑа \"%s\"" -#: commands/cluster.c:924 +#: commands/cluster.c:926 #, c-format msgid "clustering \"%s.%s\" using sequential scan and sort" msgstr "" "клаÑÑ‚ÐµÑ€Ð¸Ð·Ð°Ñ†Ð¸Ñ \"%s.%s\" путём поÑледовательного ÑÐºÐ°Ð½Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ð¸ Ñортировки" -#: commands/cluster.c:929 commands/vacuumlazy.c:479 +#: commands/cluster.c:931 commands/vacuumlazy.c:484 #, c-format msgid "vacuuming \"%s.%s\"" msgstr "очиÑтка \"%s.%s\"" -#: commands/cluster.c:1088 +#: commands/cluster.c:1090 #, c-format msgid "" "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u pages" @@ -5945,7 +5683,7 @@ msgstr "" "\"%s\": найдено удалÑемых верÑий Ñтрок: %.0f, неудалÑемых - %.0f, " "проÑмотрено Ñтраниц: %u" -#: commands/cluster.c:1092 +#: commands/cluster.c:1094 #, c-format msgid "" "%.0f dead row versions cannot be removed yet.\n" @@ -5989,7 +5727,7 @@ msgstr "правило Ñортировки \"%s\" уже ÑущеÑтвует msgid "database \"%s\" does not exist" msgstr "база данных \"%s\" не ÑущеÑтвует" -#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:753 +#: commands/comment.c:101 commands/seclabel.c:116 parser/parse_utilcmd.c:754 #, c-format msgid "" "\"%s\" is not a table, view, materialized view, composite type, or foreign " @@ -6055,7 +5793,7 @@ msgid "could not read from COPY file: %m" msgstr "не удалоÑÑŒ прочитать файл COPY: %m" #: commands/copy.c:595 commands/copy.c:616 commands/copy.c:620 -#: tcop/postgres.c:341 tcop/postgres.c:377 tcop/postgres.c:404 +#: tcop/postgres.c:333 tcop/postgres.c:369 tcop/postgres.c:396 #, c-format msgid "unexpected EOF on client connection with an open transaction" msgstr "неожиданный обрыв ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ñ ÐºÐ»Ð¸ÐµÐ½Ñ‚Ð¾Ð¼ при открытой транзакции" @@ -6100,307 +5838,307 @@ msgstr "COPY FROM не поддерживаетÑÑ Ñ Ð·Ð°Ñ‰Ð¸Ñ‚Ð¾Ð¹ на ур msgid "Use INSERT statements instead." msgstr "ИÑпользуйте операторы INSERT." -#: commands/copy.c:1058 +#: commands/copy.c:1059 #, c-format msgid "COPY format \"%s\" not recognized" msgstr "формат \"%s\" Ð´Ð»Ñ COPY не раÑпознан" -#: commands/copy.c:1129 commands/copy.c:1143 commands/copy.c:1157 -#: commands/copy.c:1177 +#: commands/copy.c:1130 commands/copy.c:1144 commands/copy.c:1158 +#: commands/copy.c:1178 #, c-format msgid "argument to option \"%s\" must be a list of column names" msgstr "аргументом параметра \"%s\" должен быть ÑпиÑок имён Ñтолбцов" -#: commands/copy.c:1190 +#: commands/copy.c:1191 #, c-format msgid "argument to option \"%s\" must be a valid encoding name" msgstr "аргументом параметра \"%s\" должно быть название допуÑтимой кодировки" -#: commands/copy.c:1196 commands/dbcommands.c:232 commands/dbcommands.c:1427 +#: commands/copy.c:1197 commands/dbcommands.c:232 commands/dbcommands.c:1427 #, c-format msgid "option \"%s\" not recognized" msgstr "параметр \"%s\" не раÑпознан" -#: commands/copy.c:1207 +#: commands/copy.c:1208 #, c-format msgid "cannot specify DELIMITER in BINARY mode" msgstr "в режиме BINARY Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐºÐ°Ð·Ñ‹Ð²Ð°Ñ‚ÑŒ DELIMITER" -#: commands/copy.c:1212 +#: commands/copy.c:1213 #, c-format msgid "cannot specify NULL in BINARY mode" msgstr "в режиме BINARY Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐºÐ°Ð·Ñ‹Ð²Ð°Ñ‚ÑŒ NULL" -#: commands/copy.c:1234 +#: commands/copy.c:1235 #, c-format msgid "COPY delimiter must be a single one-byte character" msgstr "разделитель Ð´Ð»Ñ COPY должен быть однобайтным Ñимволом" -#: commands/copy.c:1241 +#: commands/copy.c:1242 #, c-format msgid "COPY delimiter cannot be newline or carriage return" msgstr "" "разделителем Ð´Ð»Ñ COPY не может быть Ñимвол новой Ñтроки или возврата каретки" -#: commands/copy.c:1247 +#: commands/copy.c:1248 #, c-format msgid "COPY null representation cannot use newline or carriage return" msgstr "" "предÑтавление NULL Ð´Ð»Ñ COPY не может включать Ñимвол новой Ñтроки или " "возврата каретки" -#: commands/copy.c:1264 +#: commands/copy.c:1265 #, c-format msgid "COPY delimiter cannot be \"%s\"" msgstr "\"%s\" не может быть разделителем Ð´Ð»Ñ COPY" -#: commands/copy.c:1270 +#: commands/copy.c:1271 #, c-format msgid "COPY HEADER available only in CSV mode" msgstr "COPY HEADER можно иÑпользовать только в режиме CSV" -#: commands/copy.c:1276 +#: commands/copy.c:1277 #, c-format msgid "COPY quote available only in CSV mode" msgstr "определить кавычки Ð´Ð»Ñ COPY можно только в режиме CSV" -#: commands/copy.c:1281 +#: commands/copy.c:1282 #, c-format msgid "COPY quote must be a single one-byte character" msgstr "Ñимвол кавычек Ð´Ð»Ñ COPY должен быть однобайтным" -#: commands/copy.c:1286 +#: commands/copy.c:1287 #, c-format msgid "COPY delimiter and quote must be different" msgstr "Ñимвол кавычек Ð´Ð»Ñ COPY должен отличатьÑÑ Ð¾Ñ‚ разделителÑ" -#: commands/copy.c:1292 +#: commands/copy.c:1293 #, c-format msgid "COPY escape available only in CSV mode" msgstr "определить ÑпецÑимвол Ð´Ð»Ñ COPY можно только в режиме CSV" -#: commands/copy.c:1297 +#: commands/copy.c:1298 #, c-format msgid "COPY escape must be a single one-byte character" msgstr "ÑпецÑимвол Ð´Ð»Ñ COPY должен быть однобайтным" -#: commands/copy.c:1303 +#: commands/copy.c:1304 #, c-format msgid "COPY force quote available only in CSV mode" msgstr "параметр force quote Ð´Ð»Ñ COPY можно иÑпользовать только в режиме CSV" -#: commands/copy.c:1307 +#: commands/copy.c:1308 #, c-format msgid "COPY force quote only available using COPY TO" msgstr "параметр force quote Ð´Ð»Ñ COPY можно иÑпользовать только Ñ COPY TO" -#: commands/copy.c:1313 +#: commands/copy.c:1314 #, c-format msgid "COPY force not null available only in CSV mode" msgstr "" "параметр force not null Ð´Ð»Ñ COPY можно иÑпользовать только в режиме CSV" -#: commands/copy.c:1317 +#: commands/copy.c:1318 #, c-format msgid "COPY force not null only available using COPY FROM" msgstr "параметр force not null Ð´Ð»Ñ COPY можно иÑпользовать только Ñ COPY FROM" -#: commands/copy.c:1323 +#: commands/copy.c:1324 #, c-format msgid "COPY force null available only in CSV mode" msgstr "параметр force null Ð´Ð»Ñ COPY можно иÑпользовать только в режиме CSV" -#: commands/copy.c:1328 +#: commands/copy.c:1329 #, c-format msgid "COPY force null only available using COPY FROM" msgstr "параметр force null Ð´Ð»Ñ COPY можно иÑпользовать только Ñ COPY FROM" -#: commands/copy.c:1334 +#: commands/copy.c:1335 #, c-format msgid "COPY delimiter must not appear in the NULL specification" msgstr "разделитель Ð´Ð»Ñ COPY не должен приÑутÑтвовать в предÑтавлении NULL" -#: commands/copy.c:1341 +#: commands/copy.c:1342 #, c-format msgid "CSV quote character must not appear in the NULL specification" msgstr "Ñимвол кавычек в CSV не должен приÑутÑтвовать в предÑтавлении NULL" -#: commands/copy.c:1402 +#: commands/copy.c:1403 #, c-format msgid "table \"%s\" does not have OIDs" msgstr "таблица \"%s\" не Ñодержит OID" -#: commands/copy.c:1419 +#: commands/copy.c:1420 #, c-format msgid "COPY (query) WITH OIDS is not supported" msgstr "COPY (запроÑ) WITH OIDS не поддерживаетÑÑ" -#: commands/copy.c:1439 +#: commands/copy.c:1440 #, c-format msgid "DO INSTEAD NOTHING rules are not supported for COPY" msgstr "правила DO INSTEAD NOTHING не поддерживаютÑÑ Ñ COPY" -#: commands/copy.c:1453 +#: commands/copy.c:1454 #, c-format msgid "conditional DO INSTEAD rules are not supported for COPY" msgstr "уÑловные правила DO INSTEAD не поддерживаютÑÑ Ñ COPY" -#: commands/copy.c:1457 +#: commands/copy.c:1458 #, c-format msgid "DO ALSO rules are not supported for the COPY" msgstr "правила DO ALSO не поддерживаютÑÑ Ñ COPY" -#: commands/copy.c:1462 +#: commands/copy.c:1463 #, c-format msgid "multi-statement DO INSTEAD rules are not supported for COPY" msgstr "ÑоÑтавные правила DO INSTEAD не поддерживаютÑÑ Ñ COPY" -#: commands/copy.c:1472 +#: commands/copy.c:1473 #, c-format msgid "COPY (SELECT INTO) is not supported" msgstr "COPY (SELECT INTO) не поддерживаетÑÑ" -#: commands/copy.c:1489 +#: commands/copy.c:1490 #, c-format msgid "COPY query must have a RETURNING clause" msgstr "в запроÑе COPY должно быть предложение RETURNING" -#: commands/copy.c:1517 +#: commands/copy.c:1518 #, c-format msgid "relation referenced by COPY statement has changed" msgstr "отношение, задейÑтвованное в операторе COPY, изменилоÑÑŒ" -#: commands/copy.c:1575 +#: commands/copy.c:1576 #, c-format msgid "FORCE_QUOTE column \"%s\" not referenced by COPY" msgstr "Ñтолбец FORCE_QUOTE \"%s\" не фигурирует в COPY" -#: commands/copy.c:1597 +#: commands/copy.c:1598 #, c-format msgid "FORCE_NOT_NULL column \"%s\" not referenced by COPY" msgstr "Ñтолбец FORCE_NOT_NULL \"%s\" не фигурирует в COPY" -#: commands/copy.c:1619 +#: commands/copy.c:1620 #, c-format msgid "FORCE_NULL column \"%s\" not referenced by COPY" msgstr "Ñтолбец FORCE_NULL \"%s\" не фигурирует в COPY" -#: commands/copy.c:1684 +#: commands/copy.c:1685 #, c-format msgid "could not close pipe to external command: %m" msgstr "не удалоÑÑŒ закрыть канал Ñообщений Ñ Ð²Ð½ÐµÑˆÐ½ÐµÐ¹ командой: %m" -#: commands/copy.c:1688 +#: commands/copy.c:1689 #, c-format msgid "program \"%s\" failed" msgstr "Ñбой программы \"%s\"" -#: commands/copy.c:1738 +#: commands/copy.c:1739 #, c-format msgid "cannot copy from view \"%s\"" msgstr "копировать из предÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: commands/copy.c:1740 commands/copy.c:1746 commands/copy.c:1752 +#: commands/copy.c:1741 commands/copy.c:1747 commands/copy.c:1753 #, c-format msgid "Try the COPY (SELECT ...) TO variant." msgstr "Попробуйте вариацию COPY (SELECT ...) TO." -#: commands/copy.c:1744 +#: commands/copy.c:1745 #, c-format msgid "cannot copy from materialized view \"%s\"" msgstr "копировать из материализованного предÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: commands/copy.c:1750 +#: commands/copy.c:1751 #, c-format msgid "cannot copy from foreign table \"%s\"" msgstr "копировать из Ñторонней таблицы \"%s\" нельзÑ" -#: commands/copy.c:1756 +#: commands/copy.c:1757 #, c-format msgid "cannot copy from sequence \"%s\"" msgstr "копировать из поÑледовательноÑти \"%s\" нельзÑ" -#: commands/copy.c:1761 +#: commands/copy.c:1762 #, c-format msgid "cannot copy from non-table relation \"%s\"" msgstr "копировать из Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\", не ÑвлÑющегоÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†ÐµÐ¹, нельзÑ" -#: commands/copy.c:1786 commands/copy.c:2822 +#: commands/copy.c:1787 commands/copy.c:2823 #, c-format msgid "could not execute command \"%s\": %m" msgstr "не удалоÑÑŒ выполнить команду \"%s\": %m" -#: commands/copy.c:1801 +#: commands/copy.c:1802 #, c-format msgid "relative path not allowed for COPY to file" msgstr "при выполнении COPY в файл Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐºÐ°Ð·Ñ‹Ð²Ð°Ñ‚ÑŒ отноÑительный путь" -#: commands/copy.c:1809 +#: commands/copy.c:1810 #, c-format msgid "could not open file \"%s\" for writing: %m" msgstr "не удалоÑÑŒ открыть файл \"%s\" Ð´Ð»Ñ Ð·Ð°Ð¿Ð¸Ñи: %m" -#: commands/copy.c:1821 commands/copy.c:2845 +#: commands/copy.c:1822 commands/copy.c:2846 #, c-format msgid "\"%s\" is a directory" msgstr "\"%s\" - Ñто каталог" -#: commands/copy.c:2144 +#: commands/copy.c:2145 #, c-format msgid "COPY %s, line %d, column %s" msgstr "COPY %s, Ñтрока %d, Ñтолбец %s" -#: commands/copy.c:2148 commands/copy.c:2195 +#: commands/copy.c:2149 commands/copy.c:2196 #, c-format msgid "COPY %s, line %d" msgstr "COPY %s, Ñтрока %d" -#: commands/copy.c:2159 +#: commands/copy.c:2160 #, c-format msgid "COPY %s, line %d, column %s: \"%s\"" msgstr "COPY %s, Ñтрока %d, Ñтолбец %s: \"%s\"" -#: commands/copy.c:2167 +#: commands/copy.c:2168 #, c-format msgid "COPY %s, line %d, column %s: null input" msgstr "COPY %s, Ñтрока %d, Ñтолбец %s: значение NULL" -#: commands/copy.c:2189 +#: commands/copy.c:2190 #, c-format msgid "COPY %s, line %d: \"%s\"" msgstr "COPY %s, Ñтрока %d: \"%s\"" -#: commands/copy.c:2273 +#: commands/copy.c:2274 #, c-format msgid "cannot copy to view \"%s\"" msgstr "копировать в предÑтавление \"%s\" нельзÑ" -#: commands/copy.c:2278 +#: commands/copy.c:2279 #, c-format msgid "cannot copy to materialized view \"%s\"" msgstr "копировать в материализованное предÑтавление \"%s\" нельзÑ" -#: commands/copy.c:2283 +#: commands/copy.c:2284 #, c-format msgid "cannot copy to foreign table \"%s\"" msgstr "копировать в Ñтороннюю таблицу \"%s\" нельзÑ" -#: commands/copy.c:2288 +#: commands/copy.c:2289 #, c-format msgid "cannot copy to sequence \"%s\"" msgstr "копировать в поÑледовательноÑÑ‚ÑŒ \"%s\" нельзÑ" -#: commands/copy.c:2293 +#: commands/copy.c:2294 #, c-format msgid "cannot copy to non-table relation \"%s\"" msgstr "копировать в отношение \"%s\", не ÑвлÑющееÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†ÐµÐ¹, нельзÑ" -#: commands/copy.c:2356 +#: commands/copy.c:2357 #, c-format msgid "cannot perform FREEZE because of prior transaction activity" msgstr "выполнить FREEZE Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ð·-за предыдущей активноÑти в транзакции" -#: commands/copy.c:2362 +#: commands/copy.c:2363 #, c-format msgid "" "cannot perform FREEZE because the table was not created or truncated in the " @@ -6409,144 +6147,144 @@ msgstr "" "выполнить FREEZE нельзÑ, так как таблица не была Ñоздана или уÑечена в " "текущей подтранзакции" -#: commands/copy.c:2865 +#: commands/copy.c:2866 #, c-format msgid "COPY file signature not recognized" msgstr "подпиÑÑŒ COPY-файла не раÑпознана" -#: commands/copy.c:2870 +#: commands/copy.c:2871 #, c-format msgid "invalid COPY file header (missing flags)" msgstr "неверный заголовок файла COPY (отÑутÑтвуют флаги)" -#: commands/copy.c:2876 +#: commands/copy.c:2877 #, c-format msgid "unrecognized critical flags in COPY file header" msgstr "не раÑпознаны важные флаги в заголовке файла COPY" -#: commands/copy.c:2882 +#: commands/copy.c:2883 #, c-format msgid "invalid COPY file header (missing length)" msgstr "неверный заголовок файла COPY (отÑутÑтвует длина)" -#: commands/copy.c:2889 +#: commands/copy.c:2890 #, c-format msgid "invalid COPY file header (wrong length)" msgstr "неверный заголовок файла COPY (Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ð°Ñ Ð´Ð»Ð¸Ð½Ð°)" -#: commands/copy.c:3022 commands/copy.c:3729 commands/copy.c:3959 +#: commands/copy.c:3023 commands/copy.c:3730 commands/copy.c:3960 #, c-format msgid "extra data after last expected column" msgstr "лишние данные поÑле Ñодержимого поÑледнего Ñтолбца" -#: commands/copy.c:3032 +#: commands/copy.c:3033 #, c-format msgid "missing data for OID column" msgstr "нет данных Ð´Ð»Ñ Ñтолбца OID" -#: commands/copy.c:3038 +#: commands/copy.c:3039 #, c-format msgid "null OID in COPY data" msgstr "неверное значение OID (NULL) в данных COPY" -#: commands/copy.c:3048 commands/copy.c:3171 +#: commands/copy.c:3049 commands/copy.c:3172 #, c-format msgid "invalid OID in COPY data" msgstr "неверный OID в данных COPY" -#: commands/copy.c:3063 +#: commands/copy.c:3064 #, c-format msgid "missing data for column \"%s\"" msgstr "нет данных Ð´Ð»Ñ Ñтолбца \"%s\"" -#: commands/copy.c:3146 +#: commands/copy.c:3147 #, c-format msgid "received copy data after EOF marker" msgstr "поÑле маркера конца файла продолжаютÑÑ Ð´Ð°Ð½Ð½Ñ‹Ðµ COPY" -#: commands/copy.c:3153 +#: commands/copy.c:3154 #, c-format msgid "row field count is %d, expected %d" msgstr "количеÑтво полей в Ñтроке: %d, ожидалоÑÑŒ: %d" -#: commands/copy.c:3493 commands/copy.c:3510 +#: commands/copy.c:3494 commands/copy.c:3511 #, c-format msgid "literal carriage return found in data" msgstr "в данных обнаружен Ñвный возврат каретки" -#: commands/copy.c:3494 commands/copy.c:3511 +#: commands/copy.c:3495 commands/copy.c:3512 #, c-format msgid "unquoted carriage return found in data" msgstr "в данных обнаружен возврат каретки не в кавычках" -#: commands/copy.c:3496 commands/copy.c:3513 +#: commands/copy.c:3497 commands/copy.c:3514 #, c-format msgid "Use \"\\r\" to represent carriage return." msgstr "ПредÑтавьте возврат каретки как \"\\r\"." -#: commands/copy.c:3497 commands/copy.c:3514 +#: commands/copy.c:3498 commands/copy.c:3515 #, c-format msgid "Use quoted CSV field to represent carriage return." msgstr "Заключите возврат каретки в кавычки CSV." -#: commands/copy.c:3526 +#: commands/copy.c:3527 #, c-format msgid "literal newline found in data" msgstr "в данных обнаружен Ñвный Ñимвол новой Ñтроки" -#: commands/copy.c:3527 +#: commands/copy.c:3528 #, c-format msgid "unquoted newline found in data" msgstr "в данных обнаружен Ñвный Ñимвол новой Ñтроки не в кавычках" -#: commands/copy.c:3529 +#: commands/copy.c:3530 #, c-format msgid "Use \"\\n\" to represent newline." msgstr "ПредÑтавьте Ñимвол новой Ñтроки как \"\\n\"." -#: commands/copy.c:3530 +#: commands/copy.c:3531 #, c-format msgid "Use quoted CSV field to represent newline." msgstr "Заключите Ñимвол новой Ñтроки в кавычки CSV." -#: commands/copy.c:3576 commands/copy.c:3612 +#: commands/copy.c:3577 commands/copy.c:3613 #, c-format msgid "end-of-copy marker does not match previous newline style" msgstr "маркер \"конец копии\" не ÑоответÑтвует предыдущему Ñтилю новой Ñтроки" -#: commands/copy.c:3585 commands/copy.c:3601 +#: commands/copy.c:3586 commands/copy.c:3602 #, c-format msgid "end-of-copy marker corrupt" msgstr "маркер \"конец копии\" иÑпорчен" -#: commands/copy.c:4043 +#: commands/copy.c:4044 #, c-format msgid "unterminated CSV quoted field" msgstr "незавершённое поле в кавычках CSV" -#: commands/copy.c:4120 commands/copy.c:4139 +#: commands/copy.c:4121 commands/copy.c:4140 #, c-format msgid "unexpected EOF in COPY data" msgstr "неожиданный конец данных COPY" -#: commands/copy.c:4129 +#: commands/copy.c:4130 #, c-format msgid "invalid field size" msgstr "неверный размер полÑ" -#: commands/copy.c:4152 +#: commands/copy.c:4153 #, c-format msgid "incorrect binary data format" msgstr "неверный двоичный формат данных" -#: commands/copy.c:4463 commands/indexcmds.c:1053 commands/tablecmds.c:1464 +#: commands/copy.c:4464 commands/indexcmds.c:1054 commands/tablecmds.c:1464 #: commands/tablecmds.c:2291 parser/parse_relation.c:3177 #: parser/parse_relation.c:3197 utils/adt/tsvector_op.c:2559 #, c-format msgid "column \"%s\" does not exist" msgstr "Ñтолбец \"%s\" не ÑущеÑтвует" -#: commands/copy.c:4470 commands/tablecmds.c:1490 commands/trigger.c:651 +#: commands/copy.c:4471 commands/tablecmds.c:1490 commands/trigger.c:651 #: parser/parse_target.c:967 parser/parse_target.c:978 #, c-format msgid "column \"%s\" specified more than once" @@ -6862,7 +6600,7 @@ msgid "invalid argument for %s: \"%s\"" msgstr "неверный аргумент Ð´Ð»Ñ %s: \"%s\"" #: commands/dropcmds.c:112 commands/functioncmds.c:1203 -#: utils/adt/ruleutils.c:2080 +#: utils/adt/ruleutils.c:2083 #, c-format msgid "\"%s\" is an aggregate function" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ \"%s\" ÑвлÑетÑÑ Ð°Ð³Ñ€ÐµÐ³Ð°Ñ‚Ð½Ð¾Ð¹" @@ -6874,7 +6612,7 @@ msgstr "ИÑпользуйте DROP AGGREGATE Ð´Ð»Ñ ÑƒÐ´Ð°Ð»ÐµÐ½Ð¸Ñ Ð°Ð³Ñ€ÐµÐ³ #: commands/dropcmds.c:165 commands/sequence.c:424 commands/tablecmds.c:2378 #: commands/tablecmds.c:2529 commands/tablecmds.c:2571 -#: commands/tablecmds.c:11524 tcop/utility.c:1119 +#: commands/tablecmds.c:11538 tcop/utility.c:1119 #, c-format msgid "relation \"%s\" does not exist, skipping" msgstr "отношение \"%s\" не ÑущеÑтвует, пропуÑкаетÑÑ" @@ -7090,7 +6828,7 @@ msgstr "параметр BUFFERS оператора EXPLAIN требует ук msgid "EXPLAIN option TIMING requires ANALYZE" msgstr "параметр TIMING оператора EXPLAIN требует ÑƒÐºÐ°Ð·Ð°Ð½Ð¸Ñ ANALYZE" -#: commands/extension.c:155 commands/extension.c:2719 +#: commands/extension.c:155 commands/extension.c:2722 #, c-format msgid "extension \"%s\" does not exist" msgstr "раÑширение \"%s\" не ÑущеÑтвует" @@ -7180,33 +6918,33 @@ msgid "parameter \"schema\" cannot be specified when \"relocatable\" is true" msgstr "" "параметр \"schema\" не может быть указан вмеÑте Ñ \"relocatable\" = true" -#: commands/extension.c:722 +#: commands/extension.c:725 #, c-format msgid "" "transaction control statements are not allowed within an extension script" msgstr "в Ñкрипте раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ Ð½Ðµ должно быть операторов ÑƒÐ¿Ñ€Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñми" -#: commands/extension.c:790 +#: commands/extension.c:793 #, c-format msgid "permission denied to create extension \"%s\"" msgstr "нет прав на Ñоздание раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ \"%s\"" -#: commands/extension.c:792 +#: commands/extension.c:795 #, c-format msgid "Must be superuser to create this extension." msgstr "Ð”Ð»Ñ ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ Ñтого раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ Ð½ÑƒÐ¶Ð½Ð¾ быть Ñуперпользователем." -#: commands/extension.c:796 +#: commands/extension.c:799 #, c-format msgid "permission denied to update extension \"%s\"" msgstr "нет прав на изменение раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ \"%s\"" -#: commands/extension.c:798 +#: commands/extension.c:801 #, c-format msgid "Must be superuser to update this extension." msgstr "Ð”Ð»Ñ Ð¸Ð·Ð¼ÐµÐ½ÐµÐ½Ð¸Ñ Ñтого раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ Ð½ÑƒÐ¶Ð½Ð¾ быть Ñуперпользователем." -#: commands/extension.c:1080 +#: commands/extension.c:1083 #, c-format msgid "" "extension \"%s\" has no update path from version \"%s\" to version \"%s\"" @@ -7214,64 +6952,64 @@ msgstr "" "Ð´Ð»Ñ Ñ€Ð°ÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ \"%s\" не определён путь Ð¾Ð±Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ñ Ð²ÐµÑ€Ñии \"%s\" до верÑии " "\"%s\"" -#: commands/extension.c:1262 commands/extension.c:2779 +#: commands/extension.c:1265 commands/extension.c:2782 #, c-format msgid "version to install must be specified" msgstr "нужно указать верÑию Ð´Ð»Ñ ÑƒÑтановки" -#: commands/extension.c:1279 +#: commands/extension.c:1282 #, c-format msgid "FROM version must be different from installation target version \"%s\"" msgstr "верÑÐ¸Ñ FROM должна отличатьÑÑ Ð¾Ñ‚ уÑтанавливаемой верÑии \"%s\"" -#: commands/extension.c:1344 +#: commands/extension.c:1347 #, c-format msgid "extension \"%s\" must be installed in schema \"%s\"" msgstr "раÑширение \"%s\" должно уÑтанавливатьÑÑ Ð² Ñхему \"%s\"" -#: commands/extension.c:1436 +#: commands/extension.c:1439 #, c-format msgid "cyclic dependency detected between extensions \"%s\" and \"%s\"" msgstr "выÑвлена цикличеÑÐºÐ°Ñ Ð·Ð°Ð²Ð¸ÑимоÑÑ‚ÑŒ между раÑширениÑми \"%s\" и \"%s\"" -#: commands/extension.c:1441 +#: commands/extension.c:1444 #, c-format msgid "installing required extension \"%s\"" msgstr "уÑтановка требуемого раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ \"%s\"" -#: commands/extension.c:1469 commands/extension.c:2924 +#: commands/extension.c:1472 commands/extension.c:2927 #, c-format msgid "required extension \"%s\" is not installed" msgstr "требуемое раÑширение \"%s\" не уÑтановлено" -#: commands/extension.c:1471 +#: commands/extension.c:1474 #, c-format msgid "Use CREATE EXTENSION ... CASCADE to install required extensions too." msgstr "" "Выполните CREATE EXTENSION ... CASCADE, чтобы уÑтановить также требуемые " "раÑширениÑ." -#: commands/extension.c:1535 +#: commands/extension.c:1538 #, c-format msgid "extension \"%s\" already exists, skipping" msgstr "раÑширение \"%s\" уже ÑущеÑтвует, пропуÑкаетÑÑ" -#: commands/extension.c:1542 +#: commands/extension.c:1545 #, c-format msgid "extension \"%s\" already exists" msgstr "раÑширение \"%s\" уже ÑущеÑтвует" -#: commands/extension.c:1553 +#: commands/extension.c:1556 #, c-format msgid "nested CREATE EXTENSION is not supported" msgstr "вложенные операторы CREATE EXTENSION не поддерживаютÑÑ" -#: commands/extension.c:1681 +#: commands/extension.c:1684 #, c-format msgid "cannot drop extension \"%s\" because it is being modified" msgstr "удалить раÑширение \"%s\" нельзÑ, так как Ñто модифицируемый объект" -#: commands/extension.c:2152 +#: commands/extension.c:2155 #, c-format msgid "" "pg_extension_config_dump() can only be called from an SQL script executed by " @@ -7280,17 +7018,17 @@ msgstr "" "функцию pg_extension_config_dump() можно вызывать только из SQL-Ñкрипта, " "запуÑкаемого в CREATE EXTENSION" -#: commands/extension.c:2164 +#: commands/extension.c:2167 #, c-format msgid "OID %u does not refer to a table" msgstr "OID %u не отноÑитÑÑ Ðº таблице" -#: commands/extension.c:2169 +#: commands/extension.c:2172 #, c-format msgid "table \"%s\" is not a member of the extension being created" msgstr "таблица \"%s\" не отноÑитÑÑ Ðº Ñозданному раÑширению" -#: commands/extension.c:2534 +#: commands/extension.c:2537 #, c-format msgid "" "cannot move extension \"%s\" into schema \"%s\" because the extension " @@ -7299,27 +7037,27 @@ msgstr "" "перемеÑтить раÑширение \"%s\" в Ñхему \"%s\" нельзÑ, так как оно Ñодержит " "Ñхему" -#: commands/extension.c:2574 commands/extension.c:2637 +#: commands/extension.c:2577 commands/extension.c:2640 #, c-format msgid "extension \"%s\" does not support SET SCHEMA" msgstr "раÑширение \"%s\" не поддерживает SET SCHEMA" -#: commands/extension.c:2639 +#: commands/extension.c:2642 #, c-format msgid "%s is not in the extension's schema \"%s\"" msgstr "объект %s не принадлежит Ñхеме раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ \"%s\"" -#: commands/extension.c:2699 +#: commands/extension.c:2702 #, c-format msgid "nested ALTER EXTENSION is not supported" msgstr "вложенные операторы ALTER EXTENSION не поддерживаютÑÑ" -#: commands/extension.c:2790 +#: commands/extension.c:2793 #, c-format msgid "version \"%s\" of extension \"%s\" is already installed" msgstr "верÑÐ¸Ñ \"%s\" раÑÑˆÐ¸Ñ€ÐµÐ½Ð¸Ñ \"%s\" уже уÑтановлена" -#: commands/extension.c:3041 +#: commands/extension.c:3044 #, c-format msgid "" "cannot add schema \"%s\" to extension \"%s\" because the schema contains the " @@ -7328,12 +7066,12 @@ msgstr "" "добавить Ñхему \"%s\" к раÑширению \"%s\" нельзÑ, так как Ñхема Ñодержит " "раÑширение" -#: commands/extension.c:3069 +#: commands/extension.c:3072 #, c-format msgid "%s is not a member of extension \"%s\"" msgstr "%s не отноÑитÑÑ Ðº раÑширению \"%s\"" -#: commands/extension.c:3135 +#: commands/extension.c:3138 #, c-format msgid "file \"%s\" is too large" msgstr "файл \"%s\" Ñлишком большой" @@ -7561,13 +7299,13 @@ msgstr "нераÑпознанный атрибут функции \"%s\" --- и msgid "only one AS item needed for language \"%s\"" msgstr "Ð´Ð»Ñ Ñзыка \"%s\" нужно только одно выражение AS" -#: commands/functioncmds.c:929 commands/functioncmds.c:2119 +#: commands/functioncmds.c:929 commands/functioncmds.c:2139 #: commands/proclang.c:563 #, c-format msgid "language \"%s\" does not exist" msgstr "Ñзык \"%s\" не ÑущеÑтвует" -#: commands/functioncmds.c:931 commands/functioncmds.c:2121 +#: commands/functioncmds.c:931 commands/functioncmds.c:2141 #, c-format msgid "Use CREATE LANGUAGE to load the language into the database." msgstr "Выполните CREATE LANGUAGE, чтобы загрузить Ñзык в базу данных." @@ -7594,34 +7332,34 @@ msgstr "необходимо указать тип результата функ msgid "ROWS is not applicable when function does not return a set" msgstr "указание ROWS неприменимо, когда Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð²Ð¾Ð·Ð²Ñ€Ð°Ñ‰Ð°ÐµÑ‚ не множеÑтво" -#: commands/functioncmds.c:1412 +#: commands/functioncmds.c:1432 #, c-format msgid "source data type %s is a pseudo-type" msgstr "иÑходный тип данных %s ÑвлÑетÑÑ Ð¿Ñевдотипом" -#: commands/functioncmds.c:1418 +#: commands/functioncmds.c:1438 #, c-format msgid "target data type %s is a pseudo-type" msgstr "целевой тип данных %s ÑвлÑетÑÑ Ð¿Ñевдотипом" -#: commands/functioncmds.c:1442 +#: commands/functioncmds.c:1462 #, c-format msgid "cast will be ignored because the source data type is a domain" msgstr "" "приведение будет проигнорировано, так как иÑходные данные имеют тип домен" -#: commands/functioncmds.c:1447 +#: commands/functioncmds.c:1467 #, c-format msgid "cast will be ignored because the target data type is a domain" msgstr "" "приведение будет проигнорировано, так как целевые данные имеют тип домен" -#: commands/functioncmds.c:1474 +#: commands/functioncmds.c:1494 #, c-format msgid "cast function must take one to three arguments" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð´Ð¾Ð»Ð¶Ð½Ð° принимать от одного до трёх аргументов" -#: commands/functioncmds.c:1478 +#: commands/functioncmds.c:1498 #, c-format msgid "" "argument of cast function must match or be binary-coercible from source data " @@ -7630,17 +7368,17 @@ msgstr "" "аргумент функции Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ñовпадать или быть двоично-ÑовмеÑтимым Ñ " "иÑходным типом данных" -#: commands/functioncmds.c:1482 +#: commands/functioncmds.c:1502 #, c-format msgid "second argument of cast function must be type integer" msgstr "второй аргумент функции Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð´Ð¾Ð»Ð¶ÐµÐ½ быть целого типа" -#: commands/functioncmds.c:1486 +#: commands/functioncmds.c:1506 #, c-format msgid "third argument of cast function must be type boolean" msgstr "третий аргумент функции Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð´Ð¾Ð»Ð¶ÐµÐ½ быть логичеÑкого типа" -#: commands/functioncmds.c:1490 +#: commands/functioncmds.c:1510 #, c-format msgid "" "return data type of cast function must match or be binary-coercible to " @@ -7649,142 +7387,142 @@ msgstr "" "тип возвращаемых данных функции Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ñовпадать или быть двоично-" "ÑовмеÑтимым Ñ Ñ†ÐµÐ»ÐµÐ²Ñ‹Ð¼ типом данных" -#: commands/functioncmds.c:1501 +#: commands/functioncmds.c:1521 #, c-format msgid "cast function must not be volatile" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð½Ðµ может быть изменчивой (volatile)" -#: commands/functioncmds.c:1506 +#: commands/functioncmds.c:1526 #, c-format msgid "cast function must not be an aggregate function" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð½Ðµ может быть агрегатной" -#: commands/functioncmds.c:1510 +#: commands/functioncmds.c:1530 #, c-format msgid "cast function must not be a window function" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð½Ðµ может быть оконной" -#: commands/functioncmds.c:1514 +#: commands/functioncmds.c:1534 #, c-format msgid "cast function must not return a set" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð½Ðµ может возвращать множеÑтво" -#: commands/functioncmds.c:1540 +#: commands/functioncmds.c:1560 #, c-format msgid "must be superuser to create a cast WITHOUT FUNCTION" msgstr "Ð´Ð»Ñ ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ Ð¿Ñ€Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ WITHOUT FUNCTION нужно быть Ñуперпользователем" -#: commands/functioncmds.c:1555 +#: commands/functioncmds.c:1575 #, c-format msgid "source and target data types are not physically compatible" msgstr "иÑходный и целевой типы данных не ÑовмеÑтимы физичеÑки" -#: commands/functioncmds.c:1570 +#: commands/functioncmds.c:1590 #, c-format msgid "composite data types are not binary-compatible" msgstr "ÑоÑтавные типы данных не ÑовмеÑтимы на двоичном уровне" -#: commands/functioncmds.c:1576 +#: commands/functioncmds.c:1596 #, c-format msgid "enum data types are not binary-compatible" msgstr "типы-перечиÑÐ»ÐµÐ½Ð¸Ñ Ð½Ðµ ÑовмеÑтимы на двоичном уровне" -#: commands/functioncmds.c:1582 +#: commands/functioncmds.c:1602 #, c-format msgid "array data types are not binary-compatible" msgstr "типы-маÑÑивы не ÑовмеÑтимы на двоичном уровне" -#: commands/functioncmds.c:1599 +#: commands/functioncmds.c:1619 #, c-format msgid "domain data types must not be marked binary-compatible" msgstr "типы-домены не могут ÑчитатьÑÑ Ð´Ð²Ð¾Ð¸Ñ‡Ð½Ð¾-ÑовмеÑтимыми" -#: commands/functioncmds.c:1609 +#: commands/functioncmds.c:1629 #, c-format msgid "source data type and target data type are the same" msgstr "иÑходный тип данных Ñовпадает Ñ Ñ†ÐµÐ»ÐµÐ²Ñ‹Ð¼" -#: commands/functioncmds.c:1642 +#: commands/functioncmds.c:1662 #, c-format msgid "cast from type %s to type %s already exists" msgstr "приведение типа %s к типу %s уже ÑущеÑтвует" -#: commands/functioncmds.c:1717 +#: commands/functioncmds.c:1737 #, c-format msgid "cast from type %s to type %s does not exist" msgstr "приведение типа %s к типу %s не ÑущеÑтвует" -#: commands/functioncmds.c:1756 +#: commands/functioncmds.c:1776 #, c-format msgid "transform function must not be volatile" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð½Ðµ может быть изменчивой" -#: commands/functioncmds.c:1760 +#: commands/functioncmds.c:1780 #, c-format msgid "transform function must not be an aggregate function" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð½Ðµ может быть агрегатной" -#: commands/functioncmds.c:1764 +#: commands/functioncmds.c:1784 #, c-format msgid "transform function must not be a window function" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð½Ðµ может быть оконной" -#: commands/functioncmds.c:1768 +#: commands/functioncmds.c:1788 #, c-format msgid "transform function must not return a set" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð½Ðµ может возвращать множеÑтво" -#: commands/functioncmds.c:1772 +#: commands/functioncmds.c:1792 #, c-format msgid "transform function must take one argument" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð´Ð¾Ð»Ð¶Ð½Ð° принимать один аргумент" -#: commands/functioncmds.c:1776 +#: commands/functioncmds.c:1796 #, c-format msgid "first argument of transform function must be type \"internal\"" msgstr "первый аргумент функции Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð´Ð¾Ð»Ð¶ÐµÐ½ иметь тип \"internal\"" -#: commands/functioncmds.c:1813 +#: commands/functioncmds.c:1833 #, c-format msgid "data type %s is a pseudo-type" msgstr "тип данных %s ÑвлÑетÑÑ Ð¿Ñевдотипом" -#: commands/functioncmds.c:1819 +#: commands/functioncmds.c:1839 #, c-format msgid "data type %s is a domain" msgstr "тип данных \"%s\" ÑвлÑетÑÑ Ð´Ð¾Ð¼ÐµÐ½Ð¾Ð¼" -#: commands/functioncmds.c:1859 +#: commands/functioncmds.c:1879 #, c-format msgid "return data type of FROM SQL function must be \"internal\"" msgstr "результат функции FROM SQL должен иметь тип \"internal\"" -#: commands/functioncmds.c:1884 +#: commands/functioncmds.c:1904 #, c-format msgid "return data type of TO SQL function must be the transform data type" msgstr "результат функции TO SQL должен иметь тип данных преобразованиÑ" -#: commands/functioncmds.c:1911 +#: commands/functioncmds.c:1931 #, c-format msgid "transform for type %s language \"%s\" already exists" msgstr "преобразование Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° %s, Ñзыка \"%s\" уже ÑущеÑтвует" -#: commands/functioncmds.c:2002 +#: commands/functioncmds.c:2022 #, c-format msgid "transform for type %s language \"%s\" does not exist" msgstr "преобразование Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° %s, Ñзыка \"%s\" не ÑущеÑтвует" -#: commands/functioncmds.c:2053 +#: commands/functioncmds.c:2073 #, c-format msgid "function %s already exists in schema \"%s\"" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ %s уже ÑущеÑтвует в Ñхеме \"%s\"" -#: commands/functioncmds.c:2106 +#: commands/functioncmds.c:2126 #, c-format msgid "no inline code specified" msgstr "нет внедрённого кода" -#: commands/functioncmds.c:2151 +#: commands/functioncmds.c:2171 #, c-format msgid "language \"%s\" does not support inline code execution" msgstr "Ñзык \"%s\" не поддерживает выполнение внедрённого кода" @@ -7809,91 +7547,91 @@ msgstr "Ñоздать Ð¸Ð½Ð´ÐµÐºÑ Ð² Ñторонней таблице \"%s\" msgid "cannot create indexes on temporary tables of other sessions" msgstr "Ñоздавать индекÑÑ‹ во временных таблицах других ÑеанÑов нельзÑ" -#: commands/indexcmds.c:454 commands/tablecmds.c:546 commands/tablecmds.c:9694 +#: commands/indexcmds.c:455 commands/tablecmds.c:546 commands/tablecmds.c:9708 #, c-format msgid "only shared relations can be placed in pg_global tablespace" msgstr "" "в табличное проÑтранÑтво pg_global можно помеÑтить только разделÑемые таблицы" -#: commands/indexcmds.c:487 +#: commands/indexcmds.c:488 #, c-format msgid "substituting access method \"gist\" for obsolete method \"rtree\"" msgstr "уÑтаревший метод доÑтупа \"rtree\" подменÑетÑÑ Ð¼ÐµÑ‚Ð¾Ð´Ð¾Ð¼ \"gist\"" -#: commands/indexcmds.c:505 +#: commands/indexcmds.c:506 #, c-format msgid "hash indexes are not WAL-logged and their use is discouraged" msgstr "хеш-индекÑÑ‹ не запиÑываютÑÑ Ð² журнал, иÑпользовать их не рекомендуетÑÑ" -#: commands/indexcmds.c:510 +#: commands/indexcmds.c:511 #, c-format msgid "access method \"%s\" does not support unique indexes" msgstr "метод доÑтупа \"%s\" не поддерживает уникальные индекÑÑ‹" -#: commands/indexcmds.c:515 +#: commands/indexcmds.c:516 #, c-format msgid "access method \"%s\" does not support multicolumn indexes" msgstr "метод доÑтупа \"%s\" не поддерживает индекÑÑ‹ по многим Ñтолбцам" -#: commands/indexcmds.c:520 +#: commands/indexcmds.c:521 #, c-format msgid "access method \"%s\" does not support exclusion constraints" msgstr "метод доÑтупа \"%s\" не поддерживает ограничениÑ-иÑключениÑ" -#: commands/indexcmds.c:590 commands/indexcmds.c:610 +#: commands/indexcmds.c:591 commands/indexcmds.c:611 #, c-format msgid "index creation on system columns is not supported" msgstr "Ñоздание индекÑа Ð´Ð»Ñ ÑиÑтемных Ñтолбцов не поддерживаетÑÑ" -#: commands/indexcmds.c:635 +#: commands/indexcmds.c:636 #, c-format msgid "%s %s will create implicit index \"%s\" for table \"%s\"" msgstr "%s %s ÑоздаÑÑ‚ неÑвный Ð¸Ð½Ð´ÐµÐºÑ \"%s\" Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\"" -#: commands/indexcmds.c:982 +#: commands/indexcmds.c:983 #, c-format msgid "functions in index predicate must be marked IMMUTABLE" msgstr "функции в предикате индекÑа должны быть помечены как IMMUTABLE" -#: commands/indexcmds.c:1048 parser/parse_utilcmd.c:1881 +#: commands/indexcmds.c:1049 parser/parse_utilcmd.c:1882 #, c-format msgid "column \"%s\" named in key does not exist" msgstr "указанный в ключе Ñтолбец \"%s\" не ÑущеÑтвует" -#: commands/indexcmds.c:1108 +#: commands/indexcmds.c:1109 #, c-format msgid "functions in index expression must be marked IMMUTABLE" msgstr "функции в индекÑном выражении должны быть помечены как IMMUTABLE" -#: commands/indexcmds.c:1131 +#: commands/indexcmds.c:1132 #, c-format msgid "could not determine which collation to use for index expression" msgstr "не удалоÑÑŒ определить правило Ñортировки Ð´Ð»Ñ Ð¸Ð½Ð´ÐµÐºÑного выражениÑ" -#: commands/indexcmds.c:1139 commands/typecmds.c:827 parser/parse_expr.c:2608 -#: parser/parse_type.c:550 parser/parse_utilcmd.c:2807 utils/adt/misc.c:666 +#: commands/indexcmds.c:1140 commands/typecmds.c:827 parser/parse_expr.c:2608 +#: parser/parse_type.c:550 parser/parse_utilcmd.c:2808 utils/adt/misc.c:666 #, c-format msgid "collations are not supported by type %s" msgstr "тип %s не поддерживает Ñортировку (COLLATION)" -#: commands/indexcmds.c:1177 +#: commands/indexcmds.c:1178 #, c-format msgid "operator %s is not commutative" msgstr "оператор %s не коммутативен" -#: commands/indexcmds.c:1179 +#: commands/indexcmds.c:1180 #, c-format msgid "Only commutative operators can be used in exclusion constraints." msgstr "" "Ð’ ограничениÑÑ…-иÑключениÑÑ… могут иÑпользоватьÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ коммутативные " "операторы." -#: commands/indexcmds.c:1205 +#: commands/indexcmds.c:1206 #, c-format msgid "operator %s is not a member of operator family \"%s\"" msgstr "оператор \"%s\" не входит в ÑемейÑтво операторов \"%s\"" -#: commands/indexcmds.c:1208 +#: commands/indexcmds.c:1209 #, c-format msgid "" "The exclusion operator must be related to the index operator class for the " @@ -7902,24 +7640,24 @@ msgstr "" "Оператор иÑÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð´Ð»Ñ Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð´Ð¾Ð»Ð¶ÐµÐ½ отноÑитьÑÑ Ðº клаÑÑу операторов " "индекÑа." -#: commands/indexcmds.c:1243 +#: commands/indexcmds.c:1244 #, c-format msgid "access method \"%s\" does not support ASC/DESC options" msgstr "метод доÑтупа \"%s\" не поддерживает Ñортировку ASC/DESC" -#: commands/indexcmds.c:1248 +#: commands/indexcmds.c:1249 #, c-format msgid "access method \"%s\" does not support NULLS FIRST/LAST options" msgstr "метод доÑтупа \"%s\" не поддерживает параметр NULLS FIRST/LAST" -#: commands/indexcmds.c:1304 commands/typecmds.c:1935 +#: commands/indexcmds.c:1305 commands/typecmds.c:1935 #, c-format msgid "data type %s has no default operator class for access method \"%s\"" msgstr "" "Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° данных %s не определён клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð² по умолчанию Ð´Ð»Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð° " "доÑтупа \"%s\"" -#: commands/indexcmds.c:1306 +#: commands/indexcmds.c:1307 #, c-format msgid "" "You must specify an operator class for the index or define a default " @@ -7928,34 +7666,34 @@ msgstr "" "Ð’Ñ‹ должны указать клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð² Ð´Ð»Ñ Ð¸Ð½Ð´ÐµÐºÑа или определить клаÑÑ " "операторов по умолчанию Ð´Ð»Ñ Ñтого типа данных." -#: commands/indexcmds.c:1335 commands/indexcmds.c:1343 +#: commands/indexcmds.c:1336 commands/indexcmds.c:1344 #: commands/opclasscmds.c:205 #, c-format msgid "operator class \"%s\" does not exist for access method \"%s\"" msgstr "клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð² \"%s\" Ð´Ð»Ñ Ð¼ÐµÑ‚Ð¾Ð´Ð° доÑтупа \"%s\" не ÑущеÑтвует" -#: commands/indexcmds.c:1356 commands/typecmds.c:1923 +#: commands/indexcmds.c:1357 commands/typecmds.c:1923 #, c-format msgid "operator class \"%s\" does not accept data type %s" msgstr "клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð² \"%s\" не принимает тип данных %s" -#: commands/indexcmds.c:1446 +#: commands/indexcmds.c:1447 #, c-format msgid "there are multiple default operator classes for data type %s" msgstr "" "Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° данных %s определено неÑколько клаÑÑов операторов по умолчанию" -#: commands/indexcmds.c:1837 +#: commands/indexcmds.c:1838 #, c-format msgid "table \"%s\" has no indexes" msgstr "таблица \"%s\" не имеет индекÑов" -#: commands/indexcmds.c:1892 +#: commands/indexcmds.c:1893 #, c-format msgid "can only reindex the currently open database" msgstr "переиндекÑировать можно только текущую базу данных" -#: commands/indexcmds.c:1992 +#: commands/indexcmds.c:1993 #, c-format msgid "table \"%s.%s\" was reindexed" msgstr "таблица \"%s.%s\" переиндекÑирована" @@ -8216,8 +7954,8 @@ msgstr "атрибут оператора \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ð·Ð¼ÐµÐ½Ð¸Ñ‚ÑŒ" #: commands/policy.c:87 commands/policy.c:388 commands/policy.c:477 #: commands/tablecmds.c:971 commands/tablecmds.c:1313 commands/tablecmds.c:2185 -#: commands/tablecmds.c:4329 commands/tablecmds.c:6280 -#: commands/tablecmds.c:12080 commands/tablecmds.c:12115 commands/trigger.c:241 +#: commands/tablecmds.c:4329 commands/tablecmds.c:6293 +#: commands/tablecmds.c:12094 commands/tablecmds.c:12129 commands/trigger.c:241 #: commands/trigger.c:1125 commands/trigger.c:1233 rewrite/rewriteDefine.c:273 #: rewrite/rewriteDefine.c:917 #, c-format @@ -8270,7 +8008,7 @@ msgid "invalid cursor name: must not be empty" msgstr "Ð¸Ð¼Ñ ÐºÑƒÑ€Ñора не может быть пуÑтым" #: commands/portalcmds.c:168 commands/portalcmds.c:222 -#: executor/execCurrent.c:67 utils/adt/xml.c:2389 utils/adt/xml.c:2556 +#: executor/execCurrent.c:67 utils/adt/xml.c:2399 utils/adt/xml.c:2569 #, c-format msgid "cursor \"%s\" does not exist" msgstr "курÑор \"%s\" не ÑущеÑтвует" @@ -8280,7 +8018,7 @@ msgstr "курÑор \"%s\" не ÑущеÑтвует" msgid "invalid statement name: must not be empty" msgstr "неверный оператор: Ð¸Ð¼Ñ Ð½Ðµ должно быть пуÑтым" -#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1343 +#: commands/prepare.c:129 parser/parse_param.c:304 tcop/postgres.c:1335 #, c-format msgid "could not determine data type of parameter $%d" msgstr "не удалоÑÑŒ определить тип данных параметра $%d" @@ -8546,7 +8284,7 @@ msgstr "" "Выполните DROP MATERIALIZED VIEW Ð´Ð»Ñ ÑƒÐ´Ð°Ð»ÐµÐ½Ð¸Ñ Ð¼Ð°Ñ‚ÐµÑ€Ð¸Ð°Ð»Ð¸Ð·Ð¾Ð²Ð°Ð½Ð½Ð¾Ð³Ð¾ " "предÑтавлениÑ." -#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1630 +#: commands/tablecmds.c:240 parser/parse_utilcmd.c:1631 #, c-format msgid "index \"%s\" does not exist" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" не ÑущеÑтвует" @@ -8569,8 +8307,8 @@ msgstr "\"%s\" - Ñто не тип" msgid "Use DROP TYPE to remove a type." msgstr "Выполните DROP TYPE Ð´Ð»Ñ ÑƒÐ´Ð°Ð»ÐµÐ½Ð¸Ñ Ñ‚Ð¸Ð¿Ð°." -#: commands/tablecmds.c:252 commands/tablecmds.c:8583 -#: commands/tablecmds.c:11335 +#: commands/tablecmds.c:252 commands/tablecmds.c:8597 +#: commands/tablecmds.c:11349 #, c-format msgid "foreign table \"%s\" does not exist" msgstr "ÑтороннÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° \"%s\" не ÑущеÑтвует" @@ -8616,23 +8354,23 @@ msgstr "опуÑтошение раÑпроÑтранÑетÑÑ Ð½Ð° табли msgid "cannot truncate temporary tables of other sessions" msgstr "временные таблицы других ÑеанÑов Ð½ÐµÐ»ÑŒÐ·Ñ Ð¾Ð¿ÑƒÑтошить" -#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1844 +#: commands/tablecmds.c:1529 parser/parse_utilcmd.c:1845 #, c-format msgid "inherited relation \"%s\" is not a table or foreign table" msgstr "" "наÑледуемое отношение \"%s\" не ÑвлÑетÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†ÐµÐ¹ или Ñторонней таблицей" -#: commands/tablecmds.c:1536 commands/tablecmds.c:10150 +#: commands/tablecmds.c:1536 commands/tablecmds.c:10164 #, c-format msgid "cannot inherit from temporary relation \"%s\"" msgstr "временное отношение \"%s\" не может наÑледоватьÑÑ" -#: commands/tablecmds.c:1544 commands/tablecmds.c:10158 +#: commands/tablecmds.c:1544 commands/tablecmds.c:10172 #, c-format msgid "cannot inherit from temporary relation of another session" msgstr "наÑледование от временного Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ Ð´Ñ€ÑƒÐ³Ð¾Ð³Ð¾ ÑеанÑа невозможно" -#: commands/tablecmds.c:1560 commands/tablecmds.c:10192 +#: commands/tablecmds.c:1560 commands/tablecmds.c:10206 #, c-format msgid "relation \"%s\" would be inherited from more than once" msgstr "отношение \"%s\" наÑледуетÑÑ Ð½ÐµÐ¾Ð´Ð½Ð¾ÐºÑ€Ð°Ñ‚Ð½Ð¾" @@ -8662,7 +8400,7 @@ msgid "inherited column \"%s\" has a collation conflict" msgstr "конфликт правил Ñортировки в наÑледованном Ñтолбце \"%s\"" #: commands/tablecmds.c:1629 commands/tablecmds.c:1851 -#: commands/tablecmds.c:4767 +#: commands/tablecmds.c:4780 #, c-format msgid "\"%s\" versus \"%s\"" msgstr "\"%s\" и \"%s\"" @@ -8672,14 +8410,14 @@ msgstr "\"%s\" и \"%s\"" msgid "inherited column \"%s\" has a storage parameter conflict" msgstr "конфликт параметров Ñ…Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ Ð² наÑледованном Ñтолбце \"%s\"" -#: commands/tablecmds.c:1752 commands/tablecmds.c:8088 -#: parser/parse_utilcmd.c:923 parser/parse_utilcmd.c:1274 -#: parser/parse_utilcmd.c:1350 +#: commands/tablecmds.c:1752 commands/tablecmds.c:8102 +#: parser/parse_utilcmd.c:924 parser/parse_utilcmd.c:1275 +#: parser/parse_utilcmd.c:1351 #, c-format msgid "cannot convert whole-row table reference" msgstr "преобразовать ÑÑылку на тип вÑей Ñтроки таблицы нельзÑ" -#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:924 +#: commands/tablecmds.c:1753 parser/parse_utilcmd.c:925 #, c-format msgid "Constraint \"%s\" contains a whole-row reference to table \"%s\"." msgstr "Ограничение \"%s\" ÑÑылаетÑÑ Ð½Ð° тип вÑей Ñтроки в таблице \"%s\"." @@ -8824,7 +8562,7 @@ msgstr "проверка таблицы \"%s\"" msgid "column \"%s\" contains null values" msgstr "Ñтолбец \"%s\" Ñодержит Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ NULL" -#: commands/tablecmds.c:4202 commands/tablecmds.c:7385 +#: commands/tablecmds.c:4202 commands/tablecmds.c:7399 #, c-format msgid "check constraint \"%s\" is violated by some row" msgstr "ограничение-проверку \"%s\" нарушает Ð½ÐµÐºÐ¾Ñ‚Ð¾Ñ€Ð°Ñ Ñтрока" @@ -8869,7 +8607,7 @@ msgstr "\"%s\" - Ñто не таблица и не ÑтороннÑÑ Ñ‚Ð°Ð±Ð» msgid "\"%s\" is not a table, composite type, or foreign table" msgstr "\"%s\" - Ñто не таблица, ÑоÑтавной тип или ÑтороннÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð°" -#: commands/tablecmds.c:4374 commands/tablecmds.c:5426 +#: commands/tablecmds.c:4374 commands/tablecmds.c:5439 #, c-format msgid "\"%s\" is not a table, materialized view, index, or foreign table" msgstr "" @@ -8881,13 +8619,13 @@ msgstr "" msgid "\"%s\" is of the wrong type" msgstr "неправильный тип \"%s\"" -#: commands/tablecmds.c:4536 commands/tablecmds.c:4543 +#: commands/tablecmds.c:4557 commands/tablecmds.c:4564 #, c-format msgid "cannot alter type \"%s\" because column \"%s.%s\" uses it" msgstr "" "изменить тип \"%s\" нельзÑ, так как он задейÑтвован в Ñтолбце \"%s.%s\"" -#: commands/tablecmds.c:4550 +#: commands/tablecmds.c:4571 #, c-format msgid "" "cannot alter foreign table \"%s\" because column \"%s.%s\" uses its row type" @@ -8895,148 +8633,148 @@ msgstr "" "изменить Ñтороннюю таблицу \"%s\" нельзÑ, так как Ñтолбец \"%s.%s\" " "задейÑтвует тип её Ñтроки" -#: commands/tablecmds.c:4557 +#: commands/tablecmds.c:4578 #, c-format msgid "cannot alter table \"%s\" because column \"%s.%s\" uses its row type" msgstr "" "изменить таблицу \"%s\" нельзÑ, так как Ñтолбец \"%s.%s\" задейÑтвует тип её " "Ñтроки" -#: commands/tablecmds.c:4619 +#: commands/tablecmds.c:4632 #, c-format msgid "cannot alter type \"%s\" because it is the type of a typed table" msgstr "изменить тип \"%s\", так как Ñто тип типизированной таблицы" -#: commands/tablecmds.c:4621 +#: commands/tablecmds.c:4634 #, c-format msgid "Use ALTER ... CASCADE to alter the typed tables too." msgstr "" "Чтобы изменить также типизированные таблицы, выполните ALTER ... CASCADE." -#: commands/tablecmds.c:4665 +#: commands/tablecmds.c:4678 #, c-format msgid "type %s is not a composite type" msgstr "тип %s не ÑвлÑетÑÑ ÑоÑтавным" -#: commands/tablecmds.c:4691 +#: commands/tablecmds.c:4704 #, c-format msgid "cannot add column to typed table" msgstr "добавить Ñтолбец в типизированную таблицу нельзÑ" -#: commands/tablecmds.c:4759 commands/tablecmds.c:10351 +#: commands/tablecmds.c:4772 commands/tablecmds.c:10365 #, c-format msgid "child table \"%s\" has different type for column \"%s\"" msgstr "дочернÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° \"%s\" имеет другой тип Ð´Ð»Ñ Ñтолбца \"%s\"" -#: commands/tablecmds.c:4765 commands/tablecmds.c:10358 +#: commands/tablecmds.c:4778 commands/tablecmds.c:10372 #, c-format msgid "child table \"%s\" has different collation for column \"%s\"" msgstr "" "дочернÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° \"%s\" имеет другое правило Ñортировки Ð´Ð»Ñ Ñтолбца \"%s\"" -#: commands/tablecmds.c:4775 +#: commands/tablecmds.c:4788 #, c-format msgid "child table \"%s\" has a conflicting \"%s\" column" msgstr "дочернÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° \"%s\" Ñодержит конфликтующий Ñтолбец \"%s\"" -#: commands/tablecmds.c:4787 +#: commands/tablecmds.c:4800 #, c-format msgid "merging definition of column \"%s\" for child \"%s\"" msgstr "объединение определений Ñтолбца \"%s\" Ð´Ð»Ñ Ð¿Ð¾Ñ‚Ð¾Ð¼ÐºÐ° \"%s\"" -#: commands/tablecmds.c:5014 +#: commands/tablecmds.c:5027 #, c-format msgid "column must be added to child tables too" msgstr "Ñтолбец также должен быть добавлен к дочерним таблицам" -#: commands/tablecmds.c:5089 +#: commands/tablecmds.c:5102 #, c-format msgid "column \"%s\" of relation \"%s\" already exists, skipping" msgstr "Ñтолбец \"%s\" Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\" уже ÑущеÑтвует, пропуÑкаетÑÑ" -#: commands/tablecmds.c:5096 +#: commands/tablecmds.c:5109 #, c-format msgid "column \"%s\" of relation \"%s\" already exists" msgstr "Ñтолбец \"%s\" Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\" уже ÑущеÑтвует" -#: commands/tablecmds.c:5207 commands/tablecmds.c:5313 -#: commands/tablecmds.c:5371 commands/tablecmds.c:5485 -#: commands/tablecmds.c:5542 commands/tablecmds.c:5636 -#: commands/tablecmds.c:7924 commands/tablecmds.c:8606 +#: commands/tablecmds.c:5220 commands/tablecmds.c:5326 +#: commands/tablecmds.c:5384 commands/tablecmds.c:5498 +#: commands/tablecmds.c:5555 commands/tablecmds.c:5649 +#: commands/tablecmds.c:7938 commands/tablecmds.c:8620 #, c-format msgid "cannot alter system column \"%s\"" msgstr "ÑиÑтемный Ñтолбец \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ð·Ð¼ÐµÐ½Ð¸Ñ‚ÑŒ" -#: commands/tablecmds.c:5243 +#: commands/tablecmds.c:5256 #, c-format msgid "column \"%s\" is in a primary key" msgstr "Ñтолбец \"%s\" входит в первичный ключ" -#: commands/tablecmds.c:5458 +#: commands/tablecmds.c:5471 #, c-format msgid "statistics target %d is too low" msgstr "целевое ограничение ÑтатиÑтики Ñлишком мало (%d)" -#: commands/tablecmds.c:5466 +#: commands/tablecmds.c:5479 #, c-format msgid "lowering statistics target to %d" msgstr "целевое ограничение ÑтатиÑтики ÑнижаетÑÑ Ð´Ð¾ %d" -#: commands/tablecmds.c:5616 +#: commands/tablecmds.c:5629 #, c-format msgid "invalid storage type \"%s\"" msgstr "неверный тип хранилища \"%s\"" -#: commands/tablecmds.c:5648 +#: commands/tablecmds.c:5661 #, c-format msgid "column data type %s can only have storage PLAIN" msgstr "тип данных Ñтолбца %s ÑовмеÑтим только Ñ Ñ…Ñ€Ð°Ð½Ð¸Ð»Ð¸Ñ‰ÐµÐ¼ PLAIN" -#: commands/tablecmds.c:5686 +#: commands/tablecmds.c:5699 #, c-format msgid "cannot drop column from typed table" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐ´Ð°Ð»Ð¸Ñ‚ÑŒ Ñтолбец в типизированной таблице" -#: commands/tablecmds.c:5730 +#: commands/tablecmds.c:5743 #, c-format msgid "column \"%s\" of relation \"%s\" does not exist, skipping" msgstr "Ñтолбец \"%s\" в таблице\"%s\" не ÑущеÑтвует, пропуÑкаетÑÑ" -#: commands/tablecmds.c:5743 +#: commands/tablecmds.c:5756 #, c-format msgid "cannot drop system column \"%s\"" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐ´Ð°Ð»Ð¸Ñ‚ÑŒ ÑиÑтемный Ñтолбец \"%s\"" -#: commands/tablecmds.c:5750 +#: commands/tablecmds.c:5763 #, c-format msgid "cannot drop inherited column \"%s\"" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐ´Ð°Ð»Ð¸Ñ‚ÑŒ наÑледованный Ñтолбец \"%s\"" -#: commands/tablecmds.c:5990 +#: commands/tablecmds.c:6003 #, c-format msgid "" "ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index \"%s\" to \"%s\"" msgstr "" "ALTER TABLE / ADD CONSTRAINT USING INDEX переименует Ð¸Ð½Ð´ÐµÐºÑ \"%s\" в \"%s\"" -#: commands/tablecmds.c:6203 +#: commands/tablecmds.c:6216 #, c-format msgid "constraint must be added to child tables too" msgstr "ограничение также должно быть добавлено к дочерним таблицам" -#: commands/tablecmds.c:6274 +#: commands/tablecmds.c:6287 #, c-format msgid "referenced relation \"%s\" is not a table" msgstr "указанный объект \"%s\" не ÑвлÑетÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†ÐµÐ¹" -#: commands/tablecmds.c:6297 +#: commands/tablecmds.c:6310 #, c-format msgid "constraints on permanent tables may reference only permanent tables" msgstr "" "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð² поÑтоÑнных таблицах могут ÑÑылатьÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ на поÑтоÑнные " "таблицы" -#: commands/tablecmds.c:6304 +#: commands/tablecmds.c:6317 #, c-format msgid "" "constraints on unlogged tables may reference only permanent or unlogged " @@ -9045,13 +8783,13 @@ msgstr "" "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð² нежурналируемых таблицах могут ÑÑылатьÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ на поÑтоÑнные " "или нежурналируемые таблицы" -#: commands/tablecmds.c:6310 +#: commands/tablecmds.c:6323 #, c-format msgid "constraints on temporary tables may reference only temporary tables" msgstr "" "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð²Ð¾ временных таблицах могут ÑÑылатьÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ на временные таблицы" -#: commands/tablecmds.c:6314 +#: commands/tablecmds.c:6327 #, c-format msgid "" "constraints on temporary tables must involve temporary tables of this session" @@ -9059,33 +8797,33 @@ msgstr "" "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð²Ð¾ временных таблицах должны ÑÑылатьÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ на временные " "таблицы текущего ÑеанÑа" -#: commands/tablecmds.c:6375 +#: commands/tablecmds.c:6388 #, c-format msgid "number of referencing and referenced columns for foreign key disagree" msgstr "чиÑло Ñтолбцов в иÑточнике и назначении внешнего ключа не Ñовпадает" -#: commands/tablecmds.c:6482 +#: commands/tablecmds.c:6495 #, c-format msgid "foreign key constraint \"%s\" cannot be implemented" msgstr "ограничение внешнего ключа \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ñ€ÐµÐ°Ð»Ð¸Ð·Ð¾Ð²Ð°Ñ‚ÑŒ" -#: commands/tablecmds.c:6485 +#: commands/tablecmds.c:6498 #, c-format msgid "Key columns \"%s\" and \"%s\" are of incompatible types: %s and %s." msgstr "Столбцы ключа \"%s\" и \"%s\" имеют неÑовмеÑтимые типы: %s и %s." -#: commands/tablecmds.c:6692 commands/tablecmds.c:6860 -#: commands/tablecmds.c:7763 commands/tablecmds.c:7819 +#: commands/tablecmds.c:6705 commands/tablecmds.c:6873 +#: commands/tablecmds.c:7777 commands/tablecmds.c:7833 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist" msgstr "ограничение \"%s\" в таблице \"%s\" не ÑущеÑтвует" -#: commands/tablecmds.c:6698 +#: commands/tablecmds.c:6711 #, c-format msgid "constraint \"%s\" of relation \"%s\" is not a foreign key constraint" msgstr "ограничение \"%s\" в таблице \"%s\" не ÑвлÑетÑÑ Ð²Ð½ÐµÑˆÐ½Ð¸Ð¼ ключом" -#: commands/tablecmds.c:6867 +#: commands/tablecmds.c:6880 #, c-format msgid "" "constraint \"%s\" of relation \"%s\" is not a foreign key or check constraint" @@ -9093,46 +8831,46 @@ msgstr "" "ограничение \"%s\" в таблице \"%s\" не ÑвлÑетÑÑ Ð²Ð½ÐµÑˆÐ½Ð¸Ð¼ ключом или " "ограничением-проверкой" -#: commands/tablecmds.c:6935 +#: commands/tablecmds.c:6949 #, c-format msgid "constraint must be validated on child tables too" msgstr "ограничение также должно ÑоблюдатьÑÑ Ð² дочерних таблицах" -#: commands/tablecmds.c:7004 +#: commands/tablecmds.c:7018 #, c-format msgid "column \"%s\" referenced in foreign key constraint does not exist" msgstr "Ñтолбец \"%s\", указанный в ограничении внешнего ключа, не ÑущеÑтвует" -#: commands/tablecmds.c:7009 +#: commands/tablecmds.c:7023 #, c-format msgid "cannot have more than %d keys in a foreign key" msgstr "во внешнем ключе не может быть больше %d Ñтолбцов" -#: commands/tablecmds.c:7074 +#: commands/tablecmds.c:7088 #, c-format msgid "cannot use a deferrable primary key for referenced table \"%s\"" msgstr "" "иÑпользовать откладываемый первичный ключ в целевой внешней таблице \"%s\" " "нельзÑ" -#: commands/tablecmds.c:7091 +#: commands/tablecmds.c:7105 #, c-format msgid "there is no primary key for referenced table \"%s\"" msgstr "в целевой внешней таблице \"%s\" нет первичного ключа" -#: commands/tablecmds.c:7156 +#: commands/tablecmds.c:7170 #, c-format msgid "foreign key referenced-columns list must not contain duplicates" msgstr "в ÑпиÑке Ñтолбцов внешнего ключа не должно быть повторений" -#: commands/tablecmds.c:7250 +#: commands/tablecmds.c:7264 #, c-format msgid "cannot use a deferrable unique constraint for referenced table \"%s\"" msgstr "" "иÑпользовать откладываемое ограничение уникальноÑти в целевой внешней " "таблице \"%s\" нельзÑ" -#: commands/tablecmds.c:7255 +#: commands/tablecmds.c:7269 #, c-format msgid "" "there is no unique constraint matching given keys for referenced table \"%s\"" @@ -9140,32 +8878,32 @@ msgstr "" "в целевой внешней таблице \"%s\" нет Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ ÑƒÐ½Ð¸ÐºÐ°Ð»ÑŒÐ½Ð¾Ñти, " "ÑоответÑтвующего данным ключам" -#: commands/tablecmds.c:7418 +#: commands/tablecmds.c:7432 #, c-format msgid "validating foreign key constraint \"%s\"" msgstr "проверка Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð²Ð½ÐµÑˆÐ½ÐµÐ³Ð¾ ключа \"%s\"" -#: commands/tablecmds.c:7717 +#: commands/tablecmds.c:7731 #, c-format msgid "cannot drop inherited constraint \"%s\" of relation \"%s\"" msgstr "удалить наÑледованное ограничение \"%s\" таблицы \"%s\" нельзÑ" -#: commands/tablecmds.c:7769 +#: commands/tablecmds.c:7783 #, c-format msgid "constraint \"%s\" of relation \"%s\" does not exist, skipping" msgstr "ограничение \"%s\" в таблице \"%s\" не ÑущеÑтвует, пропуÑкаетÑÑ" -#: commands/tablecmds.c:7908 +#: commands/tablecmds.c:7922 #, c-format msgid "cannot alter column type of typed table" msgstr "изменить тип Ñтолбца в типизированной таблице нельзÑ" -#: commands/tablecmds.c:7931 +#: commands/tablecmds.c:7945 #, c-format msgid "cannot alter inherited column \"%s\"" msgstr "изменить наÑледованный Ñтолбец \"%s\" нельзÑ" -#: commands/tablecmds.c:7980 +#: commands/tablecmds.c:7994 #, c-format msgid "" "result of USING clause for column \"%s\" cannot be cast automatically to " @@ -9173,199 +8911,199 @@ msgid "" msgstr "" "результат USING Ð´Ð»Ñ Ñтолбца \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки привеÑти к типу %s" -#: commands/tablecmds.c:7983 +#: commands/tablecmds.c:7997 #, c-format msgid "You might need to add an explicit cast." msgstr "Возможно, необходимо добавить Ñвное приведение." -#: commands/tablecmds.c:7987 +#: commands/tablecmds.c:8001 #, c-format msgid "column \"%s\" cannot be cast automatically to type %s" msgstr "Ñтолбец \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки привеÑти к типу %s" # skip-rule: double-colons #. translator: USING is SQL, don't translate it -#: commands/tablecmds.c:7990 +#: commands/tablecmds.c:8004 #, c-format msgid "You might need to specify \"USING %s::%s\"." msgstr "Возможно, необходимо указать \"USING %s::%s\"." -#: commands/tablecmds.c:8089 +#: commands/tablecmds.c:8103 #, c-format msgid "USING expression contains a whole-row table reference." msgstr "Выражение USING ÑÑылаетÑÑ Ð½Ð° тип вÑей Ñтроки таблицы." -#: commands/tablecmds.c:8100 +#: commands/tablecmds.c:8114 #, c-format msgid "type of inherited column \"%s\" must be changed in child tables too" msgstr "" "тип наÑледованного Ñтолбца \"%s\" должен быть изменён и в дочерних таблицах" -#: commands/tablecmds.c:8187 +#: commands/tablecmds.c:8201 #, c-format msgid "cannot alter type of column \"%s\" twice" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ð·Ð¼ÐµÐ½Ð¸Ñ‚ÑŒ тип Ñтолбца \"%s\" дважды" -#: commands/tablecmds.c:8223 +#: commands/tablecmds.c:8237 #, c-format msgid "default for column \"%s\" cannot be cast automatically to type %s" msgstr "" "значение по умолчанию Ð´Ð»Ñ Ñтолбца \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки привеÑти к " "типу %s" -#: commands/tablecmds.c:8349 +#: commands/tablecmds.c:8363 #, c-format msgid "cannot alter type of a column used by a view or rule" msgstr "" "изменить тип Ñтолбца, задейÑтвованного в предÑтавлении или правиле, нельзÑ" -#: commands/tablecmds.c:8350 commands/tablecmds.c:8369 -#: commands/tablecmds.c:8387 +#: commands/tablecmds.c:8364 commands/tablecmds.c:8383 +#: commands/tablecmds.c:8401 #, c-format msgid "%s depends on column \"%s\"" msgstr "%s завиÑит от Ñтолбца \"%s\"" -#: commands/tablecmds.c:8368 +#: commands/tablecmds.c:8382 #, c-format msgid "cannot alter type of a column used in a trigger definition" msgstr "изменить тип Ñтолбца, задейÑтвованного в определении триггера, нельзÑ" -#: commands/tablecmds.c:8386 +#: commands/tablecmds.c:8400 #, c-format msgid "cannot alter type of a column used in a policy definition" msgstr "изменить тип Ñтолбца, задейÑтвованного в определении политики, нельзÑ" -#: commands/tablecmds.c:9051 +#: commands/tablecmds.c:9065 #, c-format msgid "cannot change owner of index \"%s\"" msgstr "Ñменить владельца индекÑа \"%s\" нельзÑ" -#: commands/tablecmds.c:9053 +#: commands/tablecmds.c:9067 #, c-format msgid "Change the ownership of the index's table, instead." msgstr "Однако возможно Ñменить владельца таблицы, Ñодержащей Ñтот индекÑ." -#: commands/tablecmds.c:9069 +#: commands/tablecmds.c:9083 #, c-format msgid "cannot change owner of sequence \"%s\"" msgstr "Ñменить владельца поÑледовательноÑти \"%s\" нельзÑ" -#: commands/tablecmds.c:9071 commands/tablecmds.c:11543 +#: commands/tablecmds.c:9085 commands/tablecmds.c:11557 #, c-format msgid "Sequence \"%s\" is linked to table \"%s\"." msgstr "ПоÑледовательноÑÑ‚ÑŒ \"%s\" ÑвÑзана Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†ÐµÐ¹ \"%s\"." -#: commands/tablecmds.c:9083 commands/tablecmds.c:12190 +#: commands/tablecmds.c:9097 commands/tablecmds.c:12204 #, c-format msgid "Use ALTER TYPE instead." msgstr "ИÑпользуйте ALTER TYPE." -#: commands/tablecmds.c:9092 +#: commands/tablecmds.c:9106 #, c-format msgid "\"%s\" is not a table, view, sequence, or foreign table" msgstr "" "\"%s\" - Ñто не таблица, TOAST-таблица, индекÑ, предÑтавление или " "поÑледовательноÑÑ‚ÑŒ" -#: commands/tablecmds.c:9435 +#: commands/tablecmds.c:9449 #, c-format msgid "cannot have multiple SET TABLESPACE subcommands" msgstr "в одной инÑтрукции не может быть неÑколько подкоманд SET TABLESPACE" -#: commands/tablecmds.c:9508 +#: commands/tablecmds.c:9522 #, c-format msgid "\"%s\" is not a table, view, materialized view, index, or TOAST table" msgstr "" "\"%s\" - Ñто не таблица, предÑтавление, материализованное предÑтавление, " "Ð¸Ð½Ð´ÐµÐºÑ Ð¸Ð»Ð¸ TOAST-таблица" -#: commands/tablecmds.c:9541 commands/view.c:498 +#: commands/tablecmds.c:9555 commands/view.c:498 #, c-format msgid "WITH CHECK OPTION is supported only on automatically updatable views" msgstr "" "WITH CHECK OPTION поддерживаетÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ Ñ Ð°Ð²Ñ‚Ð¾Ð¾Ð±Ð½Ð¾Ð²Ð»Ñемыми предÑтавлениÑми" -#: commands/tablecmds.c:9687 +#: commands/tablecmds.c:9701 #, c-format msgid "cannot move system relation \"%s\"" msgstr "перемеÑтить ÑиÑтемную таблицу \"%s\" нельзÑ" -#: commands/tablecmds.c:9703 +#: commands/tablecmds.c:9717 #, c-format msgid "cannot move temporary tables of other sessions" msgstr "перемещать временные таблицы других ÑеанÑов нельзÑ" -#: commands/tablecmds.c:9840 +#: commands/tablecmds.c:9854 #, c-format msgid "only tables, indexes, and materialized views exist in tablespaces" msgstr "" "в табличных проÑтранÑтвах еÑÑ‚ÑŒ только таблицы, индекÑÑ‹ и материализованные " "предÑтавлениÑ" -#: commands/tablecmds.c:9852 +#: commands/tablecmds.c:9866 #, c-format msgid "cannot move relations in to or out of pg_global tablespace" msgstr "перемещать объекты в/из табличного проÑтранÑтва pg_global нельзÑ" -#: commands/tablecmds.c:9943 +#: commands/tablecmds.c:9957 #, c-format msgid "aborting because lock on relation \"%s.%s\" is not available" msgstr "" "обработка прерываетÑÑ Ð¸Ð·-за невозможноÑти заблокировать отношение \"%s.%s\"" -#: commands/tablecmds.c:9959 +#: commands/tablecmds.c:9973 #, c-format msgid "no matching relations in tablespace \"%s\" found" msgstr "в табличном проÑтранÑтве \"%s\" не найдены подходÑщие отношениÑ" -#: commands/tablecmds.c:10033 storage/buffer/bufmgr.c:915 +#: commands/tablecmds.c:10047 storage/buffer/bufmgr.c:915 #, c-format msgid "invalid page in block %u of relation %s" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ñтраница в блоке %u Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ %s" -#: commands/tablecmds.c:10115 +#: commands/tablecmds.c:10129 #, c-format msgid "cannot change inheritance of typed table" msgstr "изменить наÑледование типизированной таблицы нельзÑ" -#: commands/tablecmds.c:10165 +#: commands/tablecmds.c:10179 #, c-format msgid "cannot inherit to temporary relation of another session" msgstr "наÑледование Ð´Ð»Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð½Ð¾Ð³Ð¾ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ Ð´Ñ€ÑƒÐ³Ð¾Ð³Ð¾ ÑеанÑа невозможно" -#: commands/tablecmds.c:10219 +#: commands/tablecmds.c:10233 #, c-format msgid "circular inheritance not allowed" msgstr "цикличеÑкое наÑледование недопуÑтимо" -#: commands/tablecmds.c:10220 +#: commands/tablecmds.c:10234 #, c-format msgid "\"%s\" is already a child of \"%s\"." msgstr "\"%s\" уже ÑвлÑетÑÑ Ð¿Ð¾Ñ‚Ð¾Ð¼ÐºÐ¾Ð¼ \"%s\"." -#: commands/tablecmds.c:10228 +#: commands/tablecmds.c:10242 #, c-format msgid "table \"%s\" without OIDs cannot inherit from table \"%s\" with OIDs" msgstr "таблица \"%s\" без OID не может наÑледоватьÑÑ Ð¾Ñ‚ таблицы \"%s\" Ñ OID" -#: commands/tablecmds.c:10369 +#: commands/tablecmds.c:10383 #, c-format msgid "column \"%s\" in child table must be marked NOT NULL" msgstr "Ñтолбец \"%s\" в дочерней таблице должен быть помечен как NOT NULL" -#: commands/tablecmds.c:10385 commands/tablecmds.c:10418 +#: commands/tablecmds.c:10399 commands/tablecmds.c:10432 #, c-format msgid "child table is missing column \"%s\"" msgstr "в дочерней таблице не хватает Ñтолбца \"%s\"" -#: commands/tablecmds.c:10501 +#: commands/tablecmds.c:10515 #, c-format msgid "child table \"%s\" has different definition for check constraint \"%s\"" msgstr "" "дочернÑÑ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð° \"%s\" Ñодержит другое определение ограничениÑ-проверки \"%s" "\"" -#: commands/tablecmds.c:10509 +#: commands/tablecmds.c:10523 #, c-format msgid "" "constraint \"%s\" conflicts with non-inherited constraint on child table \"%s" @@ -9374,7 +9112,7 @@ msgstr "" "ограничение \"%s\" конфликтует Ñ Ð½ÐµÐ½Ð°Ñледуемым ограничением дочерней таблицы " "\"%s\"" -#: commands/tablecmds.c:10520 +#: commands/tablecmds.c:10534 #, c-format msgid "" "constraint \"%s\" conflicts with NOT VALID constraint on child table \"%s\"" @@ -9382,76 +9120,76 @@ msgstr "" "ограничение \"%s\" конфликтует Ñ Ð½ÐµÐ¿Ñ€Ð¾Ð²ÐµÑ€ÐµÐ½Ð½Ñ‹Ð¼ (NOT VALID) ограничением " "дочерней таблицы \"%s\"" -#: commands/tablecmds.c:10544 +#: commands/tablecmds.c:10558 #, c-format msgid "child table is missing constraint \"%s\"" msgstr "в дочерней таблице не хватает Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ \"%s\"" -#: commands/tablecmds.c:10628 +#: commands/tablecmds.c:10642 #, c-format msgid "relation \"%s\" is not a parent of relation \"%s\"" msgstr "отношение \"%s\" не ÑвлÑетÑÑ Ð¿Ñ€ÐµÐ´ÐºÐ¾Ð¼ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\"" -#: commands/tablecmds.c:10862 +#: commands/tablecmds.c:10876 #, c-format msgid "typed tables cannot inherit" msgstr "типизированные таблицы не могут наÑледоватьÑÑ" -#: commands/tablecmds.c:10893 +#: commands/tablecmds.c:10907 #, c-format msgid "table is missing column \"%s\"" msgstr "в таблице не хватает Ñтолбца \"%s\"" -#: commands/tablecmds.c:10903 +#: commands/tablecmds.c:10917 #, c-format msgid "table has column \"%s\" where type requires \"%s\"" msgstr "таблица Ñодержит Ñтолбец \"%s\", тогда как тип требует \"%s\"" -#: commands/tablecmds.c:10912 +#: commands/tablecmds.c:10926 #, c-format msgid "table \"%s\" has different type for column \"%s\"" msgstr "таблица \"%s\" Ñодержит Ñтолбец \"%s\" другого типа" -#: commands/tablecmds.c:10925 +#: commands/tablecmds.c:10939 #, c-format msgid "table has extra column \"%s\"" msgstr "таблица Ñодержит лишний Ñтолбец \"%s\"" -#: commands/tablecmds.c:10977 +#: commands/tablecmds.c:10991 #, c-format msgid "\"%s\" is not a typed table" msgstr "\"%s\" - Ñто не Ñ‚Ð¸Ð¿Ð¸Ð·Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð½Ð°Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ð°" -#: commands/tablecmds.c:11161 +#: commands/tablecmds.c:11175 #, c-format msgid "cannot use non-unique index \"%s\" as replica identity" msgstr "" "Ð´Ð»Ñ Ð¸Ð´ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ реплики Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать неуникальный Ð¸Ð½Ð´ÐµÐºÑ \"%s\"" -#: commands/tablecmds.c:11167 +#: commands/tablecmds.c:11181 #, c-format msgid "cannot use non-immediate index \"%s\" as replica identity" msgstr "" "Ð´Ð»Ñ Ð¸Ð´ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ реплики Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать не непоÑредÑтвенный Ð¸Ð½Ð´ÐµÐºÑ \"%s" "\"" -#: commands/tablecmds.c:11173 +#: commands/tablecmds.c:11187 #, c-format msgid "cannot use expression index \"%s\" as replica identity" msgstr "" "Ð´Ð»Ñ Ð¸Ð´ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ реплики Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ð¸Ð½Ð´ÐµÐºÑ Ñ Ð²Ñ‹Ñ€Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼ \"%s\"" -#: commands/tablecmds.c:11179 +#: commands/tablecmds.c:11193 #, c-format msgid "cannot use partial index \"%s\" as replica identity" msgstr "Ð´Ð»Ñ Ð¸Ð´ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ реплики Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать чаÑтичный Ð¸Ð½Ð´ÐµÐºÑ \"%s\"" -#: commands/tablecmds.c:11185 +#: commands/tablecmds.c:11199 #, c-format msgid "cannot use invalid index \"%s\" as replica identity" msgstr "Ð´Ð»Ñ Ð¸Ð´ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ реплики Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать нерабочий Ð¸Ð½Ð´ÐµÐºÑ \"%s\"" -#: commands/tablecmds.c:11206 +#: commands/tablecmds.c:11220 #, c-format msgid "" "index \"%s\" cannot be used as replica identity because column %d is a " @@ -9460,7 +9198,7 @@ msgstr "" "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ð´Ð»Ñ Ð¸Ð´ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ реплики, так как Ñтолбец " "%d - ÑиÑтемный" -#: commands/tablecmds.c:11213 +#: commands/tablecmds.c:11227 #, c-format msgid "" "index \"%s\" cannot be used as replica identity because column \"%s\" is " @@ -9469,13 +9207,13 @@ msgstr "" "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ð´Ð»Ñ Ð¸Ð´ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ реплики, так как Ñтолбец " "\"%s\" допуÑкает NULL" -#: commands/tablecmds.c:11416 +#: commands/tablecmds.c:11430 #, c-format msgid "cannot change logged status of table \"%s\" because it is temporary" msgstr "" "изменить ÑоÑтоÑние Ð¶ÑƒÑ€Ð½Ð°Ð»Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ %s нельзÑ, так как она временнаÑ" -#: commands/tablecmds.c:11475 +#: commands/tablecmds.c:11489 #, c-format msgid "" "could not change table \"%s\" to logged because it references unlogged table " @@ -9484,7 +9222,7 @@ msgstr "" "не удалоÑÑŒ Ñделать таблицу \"%s\" журналируемой, так как она ÑÑылаетÑÑ Ð½Ð° " "нежурналируемую таблицу \"%s\"" -#: commands/tablecmds.c:11485 +#: commands/tablecmds.c:11499 #, c-format msgid "" "could not change table \"%s\" to unlogged because it references logged table " @@ -9493,22 +9231,22 @@ msgstr "" "не удалоÑÑŒ Ñделать таблицу \"%s\" нежурналируемой, так как она ÑÑылаетÑÑ Ð½Ð° " "журналируемую таблицу \"%s\"" -#: commands/tablecmds.c:11542 +#: commands/tablecmds.c:11556 #, c-format msgid "cannot move an owned sequence into another schema" msgstr "перемеÑтить поÑледовательноÑÑ‚ÑŒ Ñ Ð²Ð»Ð°Ð´ÐµÐ»ÑŒÑ†ÐµÐ¼ в другую Ñхему нельзÑ" -#: commands/tablecmds.c:11647 +#: commands/tablecmds.c:11661 #, c-format msgid "relation \"%s\" already exists in schema \"%s\"" msgstr "отношение \"%s\" уже ÑущеÑтвует в Ñхеме \"%s\"" -#: commands/tablecmds.c:12174 +#: commands/tablecmds.c:12188 #, c-format msgid "\"%s\" is not a composite type" msgstr "\"%s\" - Ñто не ÑоÑтавной тип" -#: commands/tablecmds.c:12204 +#: commands/tablecmds.c:12218 #, c-format msgid "" "\"%s\" is not a table, view, materialized view, sequence, or foreign table" @@ -9518,7 +9256,7 @@ msgstr "" #: commands/tablespace.c:162 commands/tablespace.c:179 #: commands/tablespace.c:190 commands/tablespace.c:198 -#: commands/tablespace.c:625 replication/slot.c:980 storage/file/copydir.c:47 +#: commands/tablespace.c:625 replication/slot.c:997 storage/file/copydir.c:47 #, c-format msgid "could not create directory \"%s\": %m" msgstr "не удалоÑÑŒ Ñоздать каталог \"%s\": %m" @@ -10186,42 +9924,42 @@ msgid "" msgstr "" "Ñтолбец \"%s\" таблицы \"%s\" Ñодержит значениÑ, нарушающие новое ограничение" -#: commands/typecmds.c:2971 commands/typecmds.c:3228 commands/typecmds.c:3417 +#: commands/typecmds.c:2986 commands/typecmds.c:3243 commands/typecmds.c:3432 #, c-format msgid "%s is not a domain" msgstr "\"%s\" - Ñто не домен" -#: commands/typecmds.c:3005 +#: commands/typecmds.c:3020 #, c-format msgid "constraint \"%s\" for domain \"%s\" already exists" msgstr "ограничение \"%s\" Ð´Ð»Ñ Ð´Ð¾Ð¼ÐµÐ½Ð° \"%s\" уже ÑущеÑтвует" -#: commands/typecmds.c:3055 +#: commands/typecmds.c:3070 #, c-format msgid "cannot use table references in domain check constraint" msgstr "в ограничении-проверке Ð´Ð»Ñ Ð´Ð¾Ð¼ÐµÐ½Ð° Ð½ÐµÐ»ÑŒÐ·Ñ ÑÑылатьÑÑ Ð½Ð° таблицы" -#: commands/typecmds.c:3158 commands/typecmds.c:3240 commands/typecmds.c:3534 +#: commands/typecmds.c:3173 commands/typecmds.c:3255 commands/typecmds.c:3549 #, c-format msgid "%s is a table's row type" msgstr "%s - Ñто тип Ñтрок таблицы" -#: commands/typecmds.c:3160 commands/typecmds.c:3242 commands/typecmds.c:3536 +#: commands/typecmds.c:3175 commands/typecmds.c:3257 commands/typecmds.c:3551 #, c-format msgid "Use ALTER TABLE instead." msgstr "Изменить его можно Ñ Ð¿Ð¾Ð¼Ð¾Ñ‰ÑŒÑŽ ALTER TABLE." -#: commands/typecmds.c:3167 commands/typecmds.c:3249 commands/typecmds.c:3449 +#: commands/typecmds.c:3182 commands/typecmds.c:3264 commands/typecmds.c:3464 #, c-format msgid "cannot alter array type %s" msgstr "изменить тип маÑÑива \"%s\" нельзÑ" -#: commands/typecmds.c:3169 commands/typecmds.c:3251 commands/typecmds.c:3451 +#: commands/typecmds.c:3184 commands/typecmds.c:3266 commands/typecmds.c:3466 #, c-format msgid "You can alter type %s, which will alter the array type as well." msgstr "Однако можно изменить тип %s, что повлечёт изменение типа маÑÑива." -#: commands/typecmds.c:3519 +#: commands/typecmds.c:3534 #, c-format msgid "type \"%s\" already exists in schema \"%s\"" msgstr "тип \"%s\" уже ÑущеÑтвует в Ñхеме \"%s\"" @@ -10252,7 +9990,7 @@ msgid "permission denied to create role" msgstr "нет прав Ð´Ð»Ñ ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ Ñ€Ð¾Ð»Ð¸" #: commands/user.c:322 commands/user.c:1176 commands/user.c:1183 -#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 gram.y:13615 gram.y:13650 +#: utils/adt/acl.c:5279 utils/adt/acl.c:5285 gram.y:13628 gram.y:13663 #, c-format msgid "role name \"%s\" is reserved" msgstr "Ð¸Ð¼Ñ Ñ€Ð¾Ð»Ð¸ \"%s\" зарезервировано" @@ -10479,13 +10217,13 @@ msgstr "" "\"%s\" пропуÑкаетÑÑ --- очищать не таблицы или Ñпециальные ÑиÑтемные таблицы " "нельзÑ" -#: commands/vacuumlazy.c:366 +#: commands/vacuumlazy.c:371 #, c-format msgid "automatic vacuum of table \"%s.%s.%s\": index scans: %d\n" msgstr "" "автоматичеÑÐºÐ°Ñ Ð¾Ñ‡Ð¸Ñтка таблицы \"%s.%s.%s\": Ñканирований индекÑа: %d\n" -#: commands/vacuumlazy.c:371 +#: commands/vacuumlazy.c:376 #, c-format msgid "" "pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n" @@ -10493,7 +10231,7 @@ msgstr "" "Ñтраниц удалено: %u, оÑталоÑÑŒ: %u, пропущено закреплённых: %u, пропущено " "замороженных: %u\n" -#: commands/vacuumlazy.c:377 +#: commands/vacuumlazy.c:382 #, c-format msgid "" "tuples: %.0f removed, %.0f remain, %.0f are dead but not yet removable\n" @@ -10501,45 +10239,45 @@ msgstr "" "верÑий Ñтрок: удалено: %.0f, оÑталоÑÑŒ: %.0f, «мёртвых», но ещё не подлежащих " "удалению: %.0f\n" -#: commands/vacuumlazy.c:382 +#: commands/vacuumlazy.c:387 #, c-format msgid "buffer usage: %d hits, %d misses, %d dirtied\n" msgstr "" "иÑпользование буфера: попаданий: %d, промахов: %d, «грÑзных» запиÑей: %d\n" -#: commands/vacuumlazy.c:386 +#: commands/vacuumlazy.c:391 #, c-format msgid "avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n" msgstr "" "ÑреднÑÑ ÑкороÑÑ‚ÑŒ чтениÑ: %.3f МБ/Ñ, ÑреднÑÑ ÑкороÑÑ‚ÑŒ запиÑи: %.3f МБ/Ñ\n" -#: commands/vacuumlazy.c:388 +#: commands/vacuumlazy.c:393 #, c-format msgid "system usage: %s" msgstr "нагрузка ÑиÑтемы: %s" -#: commands/vacuumlazy.c:846 +#: commands/vacuumlazy.c:852 #, c-format msgid "relation \"%s\" page %u is uninitialized --- fixing" msgstr "" "в отношении \"%s\" не инициализирована Ñтраница %u --- ÑÐ¸Ñ‚ÑƒÐ°Ñ†Ð¸Ñ Ð¸ÑправлÑетÑÑ" -#: commands/vacuumlazy.c:1316 +#: commands/vacuumlazy.c:1322 #, c-format msgid "\"%s\": removed %.0f row versions in %u pages" msgstr "\"%s\": удалено верÑий Ñтрок: %.0f, обработано Ñтраниц: %u" -#: commands/vacuumlazy.c:1326 +#: commands/vacuumlazy.c:1332 #, c-format msgid "%.0f dead row versions cannot be removed yet.\n" msgstr "Ð’ данный момент Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐ´Ð°Ð»Ð¸Ñ‚ÑŒ \"мёртвых\" Ñтрок: %.0f.\n" -#: commands/vacuumlazy.c:1328 +#: commands/vacuumlazy.c:1334 #, c-format msgid "There were %.0f unused item pointers.\n" msgstr "Ðайдено неиÑпользованных указателей: %.0f.\n" -#: commands/vacuumlazy.c:1330 +#: commands/vacuumlazy.c:1336 #, c-format msgid "Skipped %u page due to buffer pins.\n" msgid_plural "Skipped %u pages due to buffer pins.\n" @@ -10547,7 +10285,7 @@ msgstr[0] "Пропущено Ñтраниц, закреплённых в буф msgstr[1] "Пропущено Ñтраниц, закреплённых в буфере: %u.\n" msgstr[2] "Пропущено Ñтраниц, закреплённых в буфере: %u.\n" -#: commands/vacuumlazy.c:1334 +#: commands/vacuumlazy.c:1340 #, c-format msgid "%u page is entirely empty.\n" msgid_plural "%u pages are entirely empty.\n" @@ -10555,7 +10293,7 @@ msgstr[0] "ПолноÑтью пуÑÑ‚Ñ‹Ñ… Ñтраниц: %u.\n" msgstr[1] "ПолноÑтью пуÑÑ‚Ñ‹Ñ… Ñтраниц: %u.\n" msgstr[2] "ПолноÑтью пуÑÑ‚Ñ‹Ñ… Ñтраниц: %u.\n" -#: commands/vacuumlazy.c:1342 +#: commands/vacuumlazy.c:1347 #, c-format msgid "" "\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u " @@ -10564,22 +10302,22 @@ msgstr "" "\"%s\": найдено удалÑемых верÑий Ñтрок: %.0f, неудалÑемых - %.0f, обработано " "Ñтраниц: %u, вÑего Ñтраниц: %u" -#: commands/vacuumlazy.c:1411 +#: commands/vacuumlazy.c:1416 #, c-format msgid "\"%s\": removed %d row versions in %d pages" msgstr "\"%s\": удалено верÑий Ñтрок: %d, обработано Ñтраниц: %d" -#: commands/vacuumlazy.c:1600 +#: commands/vacuumlazy.c:1604 #, c-format msgid "scanned index \"%s\" to remove %d row versions" msgstr "проÑканирован Ð¸Ð½Ð´ÐµÐºÑ \"%s\", удалено верÑий Ñтрок: %d" -#: commands/vacuumlazy.c:1646 +#: commands/vacuumlazy.c:1650 #, c-format msgid "index \"%s\" now contains %.0f row versions in %u pages" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" теперь Ñодержит верÑий Ñтрок: %.0f, в Ñтраницах: %u" -#: commands/vacuumlazy.c:1650 +#: commands/vacuumlazy.c:1654 #, c-format msgid "" "%.0f index row versions were removed.\n" @@ -10590,17 +10328,17 @@ msgstr "" "Удалено индекÑных Ñтраниц: %u, пригодно Ð´Ð»Ñ Ð¿Ð¾Ð²Ñ‚Ð¾Ñ€Ð½Ð¾Ð³Ð¾ иÑпользованиÑ: %u.\n" "%s." -#: commands/vacuumlazy.c:1745 +#: commands/vacuumlazy.c:1749 #, c-format msgid "\"%s\": stopping truncate due to conflicting lock request" msgstr "\"%s\": оÑтановка уÑÐµÑ‡ÐµÐ½Ð¸Ñ Ð¸Ð·-за конфликтующего запроÑа блокировки" -#: commands/vacuumlazy.c:1810 +#: commands/vacuumlazy.c:1814 #, c-format msgid "\"%s\": truncated %u to %u pages" msgstr "\"%s\": уÑечение (было Ñтраниц: %u, Ñтало: %u)" -#: commands/vacuumlazy.c:1866 +#: commands/vacuumlazy.c:1870 #, c-format msgid "\"%s\": suspending truncate due to conflicting lock request" msgstr "\"%s\": приоÑтановка уÑÐµÑ‡ÐµÐ½Ð¸Ñ Ð¸Ð·-за конфликтующего запроÑа блокировки" @@ -10672,7 +10410,7 @@ msgid "SET TRANSACTION ISOLATION LEVEL must not be called in a subtransaction" msgstr "" "команда SET TRANSACTION ISOLATION LEVEL не должна вызыватьÑÑ Ð² подтранзакции" -#: commands/variable.c:574 storage/lmgr/predicate.c:1587 +#: commands/variable.c:574 storage/lmgr/predicate.c:1600 #, c-format msgid "cannot use serializable mode in a hot standby" msgstr "иÑпользовать Ñериализуемый режим в горÑчем резерве нельзÑ" @@ -10707,8 +10445,8 @@ msgstr "Изменить клиентÑкую кодировку ÑÐµÐ¹Ñ‡Ð°Ñ Ð½ #: commands/variable.c:779 #, c-format -msgid "cannot change client_encoding in a parallel worker" -msgstr "изменить клиентÑкую кодировку в параллельном иÑполнителе нельзÑ" +msgid "cannot change client_encoding during a parallel operation" +msgstr "изменить клиентÑкую кодировку во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ð¾Ð¹ операции нельзÑ" #: commands/variable.c:915 #, c-format @@ -10871,12 +10609,12 @@ msgstr "поÑледовательноÑÑ‚ÑŒ \"%s\" изменить нельз msgid "cannot change TOAST relation \"%s\"" msgstr "TOAST-отношение \"%s\" изменить нельзÑ" -#: executor/execMain.c:1051 rewrite/rewriteHandler.c:2648 +#: executor/execMain.c:1051 rewrite/rewriteHandler.c:2679 #, c-format msgid "cannot insert into view \"%s\"" msgstr "вÑтавить данные в предÑтавление \"%s\" нельзÑ" -#: executor/execMain.c:1053 rewrite/rewriteHandler.c:2651 +#: executor/execMain.c:1053 rewrite/rewriteHandler.c:2682 #, c-format msgid "" "To enable inserting into the view, provide an INSTEAD OF INSERT trigger or " @@ -10885,12 +10623,12 @@ msgstr "" "Чтобы предÑтавление допуÑкало добавление данных, уÑтановите триггер INSTEAD " "OF INSERT или безуÑловное правило ON INSERT DO INSTEAD." -#: executor/execMain.c:1059 rewrite/rewriteHandler.c:2656 +#: executor/execMain.c:1059 rewrite/rewriteHandler.c:2687 #, c-format msgid "cannot update view \"%s\"" msgstr "изменить данные в предÑтавлении \"%s\" нельзÑ" -#: executor/execMain.c:1061 rewrite/rewriteHandler.c:2659 +#: executor/execMain.c:1061 rewrite/rewriteHandler.c:2690 #, c-format msgid "" "To enable updating the view, provide an INSTEAD OF UPDATE trigger or an " @@ -10899,12 +10637,12 @@ msgstr "" "Чтобы предÑтавление допуÑкало изменение данных, уÑтановите триггер INSTEAD " "OF UPDATE или безуÑловное правило ON UPDATE DO INSTEAD." -#: executor/execMain.c:1067 rewrite/rewriteHandler.c:2664 +#: executor/execMain.c:1067 rewrite/rewriteHandler.c:2695 #, c-format msgid "cannot delete from view \"%s\"" msgstr "удалить данные из предÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: executor/execMain.c:1069 rewrite/rewriteHandler.c:2667 +#: executor/execMain.c:1069 rewrite/rewriteHandler.c:2698 #, c-format msgid "" "To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an " @@ -11347,7 +11085,7 @@ msgstr "не удалоÑÑŒ перемеÑтитьÑÑ Ð²Ð¾ временном msgid "could not write to hash-join temporary file: %m" msgstr "не удалоÑÑŒ запиÑать во временный файл хеш-ÑоединениÑ: %m" -#: executor/nodeHashjoin.c:928 executor/nodeHashjoin.c:938 +#: executor/nodeHashjoin.c:935 executor/nodeHashjoin.c:945 #, c-format msgid "could not read from hash-join temporary file: %m" msgstr "не удалоÑÑŒ прочитать временный файл хеш-ÑоединениÑ: %m" @@ -11715,200 +11453,200 @@ msgstr "ожидалÑÑ Ð¾Ñ‚Ð²ÐµÑ‚ Ñ Ð¿Ð°Ñ€Ð¾Ð»ÐµÐ¼, но получено Ñ msgid "invalid password packet size" msgstr "неверный размер пакета Ñ Ð¿Ð°Ñ€Ð¾Ð»ÐµÐ¼" -#: libpq/auth.c:828 +#: libpq/auth.c:712 +#, c-format +msgid "empty password returned by client" +msgstr "клиент возвратил пуÑтой пароль" + +#: libpq/auth.c:842 #, c-format msgid "GSSAPI is not supported in protocol version 2" msgstr "GSSAPI не поддерживаетÑÑ Ð² протоколе верÑии 2" -#: libpq/auth.c:888 +#: libpq/auth.c:902 #, c-format msgid "expected GSS response, got message type %d" msgstr "ожидалÑÑ Ð¾Ñ‚Ð²ÐµÑ‚ GSS, но получено Ñообщение %d" -#: libpq/auth.c:949 +#: libpq/auth.c:963 msgid "accepting GSS security context failed" msgstr "принÑÑ‚ÑŒ контекÑÑ‚ безопаÑноÑти GSS не удалоÑÑŒ" -#: libpq/auth.c:975 +#: libpq/auth.c:989 msgid "retrieving GSS user name failed" msgstr "получить Ð¸Ð¼Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ GSS не удалоÑÑŒ" -#: libpq/auth.c:1094 +#: libpq/auth.c:1108 #, c-format msgid "SSPI is not supported in protocol version 2" msgstr "SSPI не поддерживаетÑÑ Ð² протоколе верÑии 2" -#: libpq/auth.c:1109 +#: libpq/auth.c:1123 msgid "could not acquire SSPI credentials" msgstr "не удалоÑÑŒ получить удоÑтоверение SSPI" -#: libpq/auth.c:1127 +#: libpq/auth.c:1141 #, c-format msgid "expected SSPI response, got message type %d" msgstr "ожидалÑÑ Ð¾Ñ‚Ð²ÐµÑ‚ SSPI, но получено Ñообщение %d" -#: libpq/auth.c:1199 +#: libpq/auth.c:1213 msgid "could not accept SSPI security context" msgstr "принÑÑ‚ÑŒ контекÑÑ‚ безопаÑноÑти SSPI не удалоÑÑŒ" -#: libpq/auth.c:1261 +#: libpq/auth.c:1275 msgid "could not get token from SSPI security context" msgstr "не удалоÑÑŒ получить маркер из контекÑта безопаÑноÑти SSPI" -#: libpq/auth.c:1380 libpq/auth.c:1399 +#: libpq/auth.c:1394 libpq/auth.c:1413 #, c-format msgid "could not translate name" msgstr "не удалоÑÑŒ преобразовать имÑ" -#: libpq/auth.c:1412 +#: libpq/auth.c:1426 #, c-format msgid "realm name too long" msgstr "Ð¸Ð¼Ñ Ð¾Ð±Ð»Ð°Ñти Ñлишком длинное" -#: libpq/auth.c:1427 +#: libpq/auth.c:1441 #, c-format msgid "translated account name too long" msgstr "преобразованное Ð¸Ð¼Ñ ÑƒÑ‡Ñ‘Ñ‚Ð½Ð¾Ð¹ запиÑи Ñлишком длинное" -#: libpq/auth.c:1613 +#: libpq/auth.c:1627 #, c-format msgid "could not create socket for Ident connection: %m" msgstr "не удалоÑÑŒ Ñоздать Ñокет Ð´Ð»Ñ Ð¿Ð¾Ð´ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ðº Ñерверу Ident: %m" -#: libpq/auth.c:1628 +#: libpq/auth.c:1642 #, c-format msgid "could not bind to local address \"%s\": %m" msgstr "не удалоÑÑŒ привÑзатьÑÑ Ðº локальному адреÑу \"%s\": %m" -#: libpq/auth.c:1640 +#: libpq/auth.c:1654 #, c-format msgid "could not connect to Ident server at address \"%s\", port %s: %m" msgstr "не удалоÑÑŒ подключитьÑÑ Ðº Ñерверу Ident по адреÑу \"%s\", порт %s: %m" -#: libpq/auth.c:1662 +#: libpq/auth.c:1676 #, c-format msgid "could not send query to Ident server at address \"%s\", port %s: %m" msgstr "" "не удалоÑÑŒ отправить Ð·Ð°Ð¿Ñ€Ð¾Ñ Ñерверу Ident по адреÑу \"%s\", порт %s: %m" -#: libpq/auth.c:1679 +#: libpq/auth.c:1693 #, c-format msgid "" "could not receive response from Ident server at address \"%s\", port %s: %m" msgstr "" "не удалоÑÑŒ получить ответ от Ñервера Ident по адреÑу \"%s\", порт %s: %m" -#: libpq/auth.c:1689 +#: libpq/auth.c:1703 #, c-format msgid "invalidly formatted response from Ident server: \"%s\"" msgstr "неверно форматированный ответ от Ñервера Ident: \"%s\"" -#: libpq/auth.c:1729 +#: libpq/auth.c:1743 #, c-format msgid "peer authentication is not supported on this platform" msgstr "проверка подлинноÑти peer в Ñтой ОС не поддерживаетÑÑ" -#: libpq/auth.c:1733 +#: libpq/auth.c:1747 #, c-format msgid "could not get peer credentials: %m" msgstr "не удалоÑÑŒ получить данные Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ñ‡ÐµÑ€ÐµÐ· механизм peer: %m" -#: libpq/auth.c:1742 +#: libpq/auth.c:1756 #, c-format msgid "could not look up local user ID %ld: %s" msgstr "найти локального Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð¿Ð¾ идентификатору (%ld) не удалоÑÑŒ: %s" -#: libpq/auth.c:1826 libpq/auth.c:2152 libpq/auth.c:2512 -#, c-format -msgid "empty password returned by client" -msgstr "клиент возвратил пуÑтой пароль" - -#: libpq/auth.c:1836 +#: libpq/auth.c:1844 #, c-format msgid "error from underlying PAM layer: %s" msgstr "ошибка в нижележащем Ñлое PAM: %s" -#: libpq/auth.c:1917 +#: libpq/auth.c:1925 #, c-format msgid "could not create PAM authenticator: %s" msgstr "не удалоÑÑŒ Ñоздать аутентификатор PAM: %s" -#: libpq/auth.c:1928 +#: libpq/auth.c:1936 #, c-format msgid "pam_set_item(PAM_USER) failed: %s" msgstr "ошибка в pam_set_item(PAM_USER): %s" -#: libpq/auth.c:1939 +#: libpq/auth.c:1947 #, c-format msgid "pam_set_item(PAM_RHOST) failed: %s" msgstr "ошибка в pam_set_item(PAM_RHOST): %s" -#: libpq/auth.c:1950 +#: libpq/auth.c:1958 #, c-format msgid "pam_set_item(PAM_CONV) failed: %s" msgstr "ошибка в pam_set_item(PAM_CONV): %s" -#: libpq/auth.c:1961 +#: libpq/auth.c:1969 #, c-format msgid "pam_authenticate failed: %s" msgstr "ошибка в pam_authenticate: %s" -#: libpq/auth.c:1972 +#: libpq/auth.c:1980 #, c-format msgid "pam_acct_mgmt failed: %s" msgstr "ошибка в pam_acct_mgmt: %s" -#: libpq/auth.c:1983 +#: libpq/auth.c:1991 #, c-format msgid "could not release PAM authenticator: %s" msgstr "не удалоÑÑŒ оÑвободить аутентификатор PAM: %s" -#: libpq/auth.c:2048 +#: libpq/auth.c:2056 #, c-format msgid "could not initialize LDAP: %m" msgstr "не удалоÑÑŒ инициализировать LDAP: %m" -#: libpq/auth.c:2051 +#: libpq/auth.c:2059 #, c-format msgid "could not initialize LDAP: error code %d" msgstr "не удалоÑÑŒ инициализировать LDAP (код ошибки: %d)" -#: libpq/auth.c:2061 +#: libpq/auth.c:2069 #, c-format msgid "could not set LDAP protocol version: %s" msgstr "не удалоÑÑŒ задать верÑию протокола LDAP: %s" -#: libpq/auth.c:2090 +#: libpq/auth.c:2098 #, c-format msgid "could not load wldap32.dll" msgstr "не удалоÑÑŒ загрузить wldap32.dll" -#: libpq/auth.c:2098 +#: libpq/auth.c:2106 #, c-format msgid "could not load function _ldap_start_tls_sA in wldap32.dll" msgstr "не удалоÑÑŒ найти функцию _ldap_start_tls_sA в wldap32.dll" -#: libpq/auth.c:2099 +#: libpq/auth.c:2107 #, c-format msgid "LDAP over SSL is not supported on this platform." msgstr "LDAP через SSL не поддерживаетÑÑ Ð² Ñтой ОС." -#: libpq/auth.c:2114 +#: libpq/auth.c:2122 #, c-format msgid "could not start LDAP TLS session: %s" msgstr "не удалоÑÑŒ начать ÑÐµÐ°Ð½Ñ LDAP TLS: %s" -#: libpq/auth.c:2136 +#: libpq/auth.c:2144 #, c-format msgid "LDAP server not specified" msgstr "LDAP-Ñервер не определён" -#: libpq/auth.c:2189 +#: libpq/auth.c:2192 #, c-format msgid "invalid character in user name for LDAP authentication" msgstr "недопуÑтимый Ñимвол в имени Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð´Ð»Ñ Ð¿Ñ€Ð¾Ð²ÐµÑ€ÐºÐ¸ подлинноÑти LDAP" -#: libpq/auth.c:2204 +#: libpq/auth.c:2207 #, c-format msgid "" "could not perform initial LDAP bind for ldapbinddn \"%s\" on server \"%s\": " @@ -11917,28 +11655,28 @@ msgstr "" "не удалоÑÑŒ выполнить начальную привÑзку LDAP Ð´Ð»Ñ ldapbinddn \"%s\" на " "Ñервере \"%s\": %s" -#: libpq/auth.c:2228 +#: libpq/auth.c:2231 #, c-format msgid "could not search LDAP for filter \"%s\" on server \"%s\": %s" msgstr "" "не удалоÑÑŒ выполнить LDAP-поиÑк по фильтру \"%s\" на Ñервере \"%s\": %s" -#: libpq/auth.c:2239 +#: libpq/auth.c:2242 #, c-format msgid "LDAP user \"%s\" does not exist" msgstr "в LDAP нет Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\"" -#: libpq/auth.c:2240 +#: libpq/auth.c:2243 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned no entries." msgstr "LDAP-поиÑк по фильтру \"%s\" на Ñервере \"%s\" не вернул результатов" -#: libpq/auth.c:2244 +#: libpq/auth.c:2247 #, c-format msgid "LDAP user \"%s\" is not unique" msgstr "пользователь LDAP \"%s\" не уникален" -#: libpq/auth.c:2245 +#: libpq/auth.c:2248 #, c-format msgid "LDAP search for filter \"%s\" on server \"%s\" returned %d entry." msgid_plural "" @@ -11947,7 +11685,7 @@ msgstr[0] "LDAP-поиÑк по фильтру \"%s\" на Ñервере \"%s\" msgstr[1] "LDAP-поиÑк по фильтру \"%s\" на Ñервере \"%s\" вернул %d запиÑи." msgstr[2] "LDAP-поиÑк по фильтру \"%s\" на Ñервере \"%s\" вернул %d запиÑей." -#: libpq/auth.c:2263 +#: libpq/auth.c:2266 #, c-format msgid "" "could not get dn for the first entry matching \"%s\" on server \"%s\": %s" @@ -11955,19 +11693,19 @@ msgstr "" "не удалоÑÑŒ получить dn Ð´Ð»Ñ Ð¿ÐµÑ€Ð²Ð¾Ð³Ð¾ результата, ÑоответÑтвующего \"%s\" на " "Ñервере \"%s\": %s" -#: libpq/auth.c:2283 +#: libpq/auth.c:2286 #, c-format msgid "could not unbind after searching for user \"%s\" on server \"%s\": %s" msgstr "" "не удалоÑÑŒ отвÑзатьÑÑ Ð¿Ð¾Ñле поиÑка Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" на Ñервере \"%s\": %s" -#: libpq/auth.c:2313 +#: libpq/auth.c:2316 #, c-format msgid "LDAP login failed for user \"%s\" on server \"%s\": %s" msgstr "" "ошибка при региÑтрации в LDAP Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" на Ñервере \"%s\": %s" -#: libpq/auth.c:2341 +#: libpq/auth.c:2344 #, c-format msgid "" "certificate authentication failed for user \"%s\": client certificate " @@ -11976,99 +11714,99 @@ msgstr "" "ошибка проверки подлинноÑти Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" по Ñертификату: Ñертификат " "клиента не Ñодержит Ð¸Ð¼Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ" -#: libpq/auth.c:2468 +#: libpq/auth.c:2474 #, c-format msgid "RADIUS server not specified" msgstr "RADIUS-Ñервер не определён" -#: libpq/auth.c:2475 +#: libpq/auth.c:2481 #, c-format msgid "RADIUS secret not specified" msgstr "Ñекрет RADIUS не определён" -#: libpq/auth.c:2491 libpq/hba.c:1632 +#: libpq/auth.c:2497 libpq/hba.c:1632 #, c-format msgid "could not translate RADIUS server name \"%s\" to address: %s" msgstr "не удалоÑÑŒ преобразовать Ð¸Ð¼Ñ Ñервера RADIUS \"%s\" в адреÑ: %s" # well-spelled: Ñимв -#: libpq/auth.c:2519 +#: libpq/auth.c:2518 #, c-format msgid "" "RADIUS authentication does not support passwords longer than %d characters" msgstr "проверка подлинноÑти RADIUS не поддерживает пароли длиннее %d Ñимв." -#: libpq/auth.c:2531 +#: libpq/auth.c:2530 #, c-format msgid "could not generate random encryption vector" msgstr "не удалоÑÑŒ Ñгенерировать Ñлучайный вектор шифрованиÑ" -#: libpq/auth.c:2569 +#: libpq/auth.c:2568 #, c-format msgid "could not perform MD5 encryption of password" msgstr "не удалоÑÑŒ вычиÑлить MD5-хеш паролÑ" -#: libpq/auth.c:2594 +#: libpq/auth.c:2593 #, c-format msgid "could not create RADIUS socket: %m" msgstr "не удалоÑÑŒ Ñоздать Ñокет RADIUS: %m" -#: libpq/auth.c:2615 +#: libpq/auth.c:2614 #, c-format msgid "could not bind local RADIUS socket: %m" msgstr "не удалоÑÑŒ привÑзатьÑÑ Ðº локальному Ñокету RADIUS: %m" -#: libpq/auth.c:2625 +#: libpq/auth.c:2624 #, c-format msgid "could not send RADIUS packet: %m" msgstr "не удалоÑÑŒ отправить пакет RADIUS: %m" -#: libpq/auth.c:2658 libpq/auth.c:2683 +#: libpq/auth.c:2657 libpq/auth.c:2682 #, c-format msgid "timeout waiting for RADIUS response" msgstr "превышено Ð²Ñ€ÐµÐ¼Ñ Ð¾Ð¶Ð¸Ð´Ð°Ð½Ð¸Ñ Ð¾Ñ‚Ð²ÐµÑ‚Ð° RADIUS" -#: libpq/auth.c:2676 +#: libpq/auth.c:2675 #, c-format msgid "could not check status on RADIUS socket: %m" msgstr "не удалоÑÑŒ проверить ÑоÑтоÑние Ñокета RADIUS: %m" -#: libpq/auth.c:2705 +#: libpq/auth.c:2704 #, c-format msgid "could not read RADIUS response: %m" msgstr "не удалоÑÑŒ прочитать ответ RADIUS: %m" -#: libpq/auth.c:2717 libpq/auth.c:2721 +#: libpq/auth.c:2716 libpq/auth.c:2720 #, c-format msgid "RADIUS response was sent from incorrect port: %d" msgstr "ответ RADIUS был отправлен Ñ Ð½ÐµÐ²ÐµÑ€Ð½Ð¾Ð³Ð¾ порта: %d" -#: libpq/auth.c:2730 +#: libpq/auth.c:2729 #, c-format msgid "RADIUS response too short: %d" msgstr "Ñлишком короткий ответ RADIUS: %d" -#: libpq/auth.c:2737 +#: libpq/auth.c:2736 #, c-format msgid "RADIUS response has corrupt length: %d (actual length %d)" msgstr "в ответе RADIUS иÑпорчена длина: %d (фактичеÑÐºÐ°Ñ Ð´Ð»Ð¸Ð½Ð° %d)" -#: libpq/auth.c:2745 +#: libpq/auth.c:2744 #, c-format msgid "RADIUS response is to a different request: %d (should be %d)" msgstr "пришёл ответ RADIUS на другой запроÑ: %d (ожидалÑÑ %d)" -#: libpq/auth.c:2770 +#: libpq/auth.c:2769 #, c-format msgid "could not perform MD5 encryption of received packet" msgstr "не удалоÑÑŒ вычиÑлить MD5 Ð´Ð»Ñ Ð¿Ñ€Ð¸Ð½Ñтого пакета" -#: libpq/auth.c:2779 +#: libpq/auth.c:2778 #, c-format msgid "RADIUS response has incorrect MD5 signature" msgstr "ответ RADIUS Ñодержит неверную подпиÑÑŒ MD5" -#: libpq/auth.c:2796 +#: libpq/auth.c:2795 #, c-format msgid "RADIUS response has invalid code (%d) for user \"%s\"" msgstr "ответ RADIUS Ñодержит неверный код (%d) Ð´Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\"" @@ -12081,7 +11819,7 @@ msgid "invalid large-object descriptor: %d" msgstr "неверный деÑкриптор большого объекта: %d" #: libpq/be-fsstubs.c:178 libpq/be-fsstubs.c:216 libpq/be-fsstubs.c:600 -#: libpq/be-fsstubs.c:788 +#: libpq/be-fsstubs.c:788 libpq/be-fsstubs.c:908 #, c-format msgid "permission denied for large object %u" msgstr "нет доÑтупа к большому объекту %u" @@ -12207,88 +11945,88 @@ msgstr "не удалоÑÑŒ загрузить файл закрытого кл msgid "check of private key failed: %s" msgstr "ошибка при проверке закрытого ключа: %s" -#: libpq/be-secure-openssl.c:292 +#: libpq/be-secure-openssl.c:300 #, c-format msgid "could not load root certificate file \"%s\": %s" msgstr "не удалоÑÑŒ загрузить файл корневых Ñертификатов \"%s\": %s" -#: libpq/be-secure-openssl.c:316 +#: libpq/be-secure-openssl.c:324 #, c-format msgid "SSL certificate revocation list file \"%s\" ignored" msgstr "файл Ñо ÑпиÑком отзыва Ñертификатов SSL \"%s\" игнорируетÑÑ" -#: libpq/be-secure-openssl.c:318 +#: libpq/be-secure-openssl.c:326 #, c-format msgid "SSL library does not support certificate revocation lists." msgstr "Библиотека SSL не поддерживает ÑпиÑки отзыва Ñертификатов." -#: libpq/be-secure-openssl.c:323 +#: libpq/be-secure-openssl.c:331 #, c-format msgid "could not load SSL certificate revocation list file \"%s\": %s" msgstr "" "не удалоÑÑŒ загрузить файл Ñо ÑпиÑком отзыва Ñертификатов SSL \"%s\": %s" -#: libpq/be-secure-openssl.c:370 +#: libpq/be-secure-openssl.c:378 #, c-format msgid "could not initialize SSL connection: %s" msgstr "инициализировать SSL-подключение не удалоÑÑŒ: %s" -#: libpq/be-secure-openssl.c:378 +#: libpq/be-secure-openssl.c:386 #, c-format msgid "could not set SSL socket: %s" msgstr "не удалоÑÑŒ Ñоздать SSL-Ñокет: %s" -#: libpq/be-secure-openssl.c:432 +#: libpq/be-secure-openssl.c:440 #, c-format msgid "could not accept SSL connection: %m" msgstr "не удалоÑÑŒ принÑÑ‚ÑŒ SSL-подключение: %m" -#: libpq/be-secure-openssl.c:436 libpq/be-secure-openssl.c:447 +#: libpq/be-secure-openssl.c:444 libpq/be-secure-openssl.c:455 #, c-format msgid "could not accept SSL connection: EOF detected" msgstr "не удалоÑÑŒ принÑÑ‚ÑŒ SSL-подключение: обрыв данных" -#: libpq/be-secure-openssl.c:441 +#: libpq/be-secure-openssl.c:449 #, c-format msgid "could not accept SSL connection: %s" msgstr "не удалоÑÑŒ принÑÑ‚ÑŒ SSL-подключение: %s" -#: libpq/be-secure-openssl.c:452 libpq/be-secure-openssl.c:593 -#: libpq/be-secure-openssl.c:653 +#: libpq/be-secure-openssl.c:460 libpq/be-secure-openssl.c:603 +#: libpq/be-secure-openssl.c:669 #, c-format msgid "unrecognized SSL error code: %d" msgstr "нераÑпознанный код ошибки SSL: %d" -#: libpq/be-secure-openssl.c:496 +#: libpq/be-secure-openssl.c:504 #, c-format msgid "SSL certificate's common name contains embedded null" msgstr "Ð˜Ð¼Ñ SSL-Ñертификата включает нулевой байт" -#: libpq/be-secure-openssl.c:507 +#: libpq/be-secure-openssl.c:515 #, c-format msgid "SSL connection from \"%s\"" msgstr "SSL-подключение от \"%s\"" -#: libpq/be-secure-openssl.c:584 libpq/be-secure-openssl.c:644 +#: libpq/be-secure-openssl.c:592 libpq/be-secure-openssl.c:654 #, c-format msgid "SSL error: %s" msgstr "ошибка SSL: %s" -#: libpq/be-secure-openssl.c:1055 +#: libpq/be-secure-openssl.c:1071 #, c-format msgid "ECDH: unrecognized curve name: %s" msgstr "ECDH: нераÑпознанное Ð¸Ð¼Ñ ÐºÑ€Ð¸Ð²Ð¾Ð¹: %s" -#: libpq/be-secure-openssl.c:1060 +#: libpq/be-secure-openssl.c:1076 #, c-format msgid "ECDH: could not create key" msgstr "ECDH: не удалоÑÑŒ Ñоздать ключ" -#: libpq/be-secure-openssl.c:1084 +#: libpq/be-secure-openssl.c:1100 msgid "no SSL error reported" msgstr "нет ÑÐ¾Ð¾Ð±Ñ‰ÐµÐ½Ð¸Ñ Ð¾Ð± ошибке SSL" -#: libpq/be-secure-openssl.c:1088 +#: libpq/be-secure-openssl.c:1104 #, c-format msgid "SSL error code %lu" msgstr "код ошибки SSL: %lu" @@ -12308,17 +12046,17 @@ msgstr "Роль \"%s\" не ÑущеÑтвует." msgid "User \"%s\" has no password assigned." msgstr "Пользователь \"%s\" не имеет паролÑ." -#: libpq/crypt.c:79 +#: libpq/crypt.c:88 libpq/crypt.c:103 #, c-format msgid "User \"%s\" has an empty password." msgstr "У Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" пуÑтой пароль." -#: libpq/crypt.c:159 +#: libpq/crypt.c:184 #, c-format msgid "User \"%s\" has an expired password." msgstr "Срок Ð¿Ð°Ñ€Ð¾Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\" иÑтёк." -#: libpq/crypt.c:167 +#: libpq/crypt.c:192 #, c-format msgid "Password does not match for user \"%s\"." msgstr "Пароль не подходит Ð´Ð»Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ \"%s\"." @@ -12667,73 +12405,73 @@ msgstr "" msgid "could not open usermap file \"%s\": %m" msgstr "не удалоÑÑŒ открыть файл ÑопоÑтавлений пользователей \"%s\": %m" -#: libpq/pqcomm.c:202 +#: libpq/pqcomm.c:221 #, c-format msgid "could not set socket to nonblocking mode: %m" msgstr "не удалоÑÑŒ перевеÑти Ñокет в неблокирующий режим: %m" -#: libpq/pqcomm.c:354 +#: libpq/pqcomm.c:373 #, c-format msgid "Unix-domain socket path \"%s\" is too long (maximum %d bytes)" msgstr "длина пути доменного Ñокета \"%s\" превышает предел (%d байт)" -#: libpq/pqcomm.c:375 +#: libpq/pqcomm.c:394 #, c-format msgid "could not translate host name \"%s\", service \"%s\" to address: %s" msgstr "перевеÑти Ð¸Ð¼Ñ ÑƒÐ·Ð»Ð° \"%s\", Ñлужбы \"%s\" в Ð°Ð´Ñ€ÐµÑ Ð½Ðµ удалоÑÑŒ: %s" -#: libpq/pqcomm.c:379 +#: libpq/pqcomm.c:398 #, c-format msgid "could not translate service \"%s\" to address: %s" msgstr "не удалоÑÑŒ перевеÑти Ð¸Ð¼Ñ Ñлужбы \"%s\" в адреÑ: %s" -#: libpq/pqcomm.c:406 +#: libpq/pqcomm.c:425 #, c-format msgid "could not bind to all requested addresses: MAXLISTEN (%d) exceeded" msgstr "" "не удалоÑÑŒ привÑзатьÑÑ ÐºÐ¾ вÑем запрошенным адреÑам: превышен предел " "MAXLISTEN (%d)" -#: libpq/pqcomm.c:415 +#: libpq/pqcomm.c:434 msgid "IPv4" msgstr "IPv4" -#: libpq/pqcomm.c:419 +#: libpq/pqcomm.c:438 msgid "IPv6" msgstr "IPv6" -#: libpq/pqcomm.c:424 +#: libpq/pqcomm.c:443 msgid "Unix" msgstr "Unix" -#: libpq/pqcomm.c:429 +#: libpq/pqcomm.c:448 #, c-format msgid "unrecognized address family %d" msgstr "нераÑпознанное ÑемейÑтво адреÑов: %d" #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:440 +#: libpq/pqcomm.c:459 #, c-format msgid "could not create %s socket: %m" msgstr "не удалоÑÑŒ Ñоздать Ñокет %s: %m" -#: libpq/pqcomm.c:465 +#: libpq/pqcomm.c:484 #, c-format msgid "setsockopt(SO_REUSEADDR) failed: %m" msgstr "ошибка в setsockopt(SO_REUSEADDR): %m" -#: libpq/pqcomm.c:480 +#: libpq/pqcomm.c:499 #, c-format msgid "setsockopt(IPV6_V6ONLY) failed: %m" msgstr "ошибка в setsockopt(IPV6_V6ONLY): %m" #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:499 +#: libpq/pqcomm.c:518 #, c-format msgid "could not bind %s socket: %m" msgstr "не удалоÑÑŒ привÑзатьÑÑ Ðº Ñокету %s: %m" -#: libpq/pqcomm.c:502 +#: libpq/pqcomm.c:521 #, c-format msgid "" "Is another postmaster already running on port %d? If not, remove socket file " @@ -12742,7 +12480,7 @@ msgstr "" "Возможно порт %d занÑÑ‚ другим процеÑÑом postmaster? ЕÑли нет, удалите файл " "\"%s\" и повторите попытку." -#: libpq/pqcomm.c:505 +#: libpq/pqcomm.c:524 #, c-format msgid "" "Is another postmaster already running on port %d? If not, wait a few seconds " @@ -12752,62 +12490,62 @@ msgstr "" "попытку через неÑколько Ñекунд." #. translator: %s is IPv4, IPv6, or Unix -#: libpq/pqcomm.c:538 +#: libpq/pqcomm.c:557 #, c-format msgid "could not listen on %s socket: %m" msgstr "не удалоÑÑŒ начать приём в Ñокете %s: %m" -#: libpq/pqcomm.c:623 +#: libpq/pqcomm.c:642 #, c-format msgid "group \"%s\" does not exist" msgstr "группа \"%s\" не ÑущеÑтвует" -#: libpq/pqcomm.c:633 +#: libpq/pqcomm.c:652 #, c-format msgid "could not set group of file \"%s\": %m" msgstr "не удалоÑÑŒ уÑтановить группу Ð´Ð»Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\": %m" -#: libpq/pqcomm.c:644 +#: libpq/pqcomm.c:663 #, c-format msgid "could not set permissions of file \"%s\": %m" msgstr "не удалоÑÑŒ уÑтановить права доÑтупа Ð´Ð»Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\": %m" -#: libpq/pqcomm.c:674 +#: libpq/pqcomm.c:693 #, c-format msgid "could not accept new connection: %m" msgstr "не удалоÑÑŒ принÑÑ‚ÑŒ новое подключение: %m" -#: libpq/pqcomm.c:885 +#: libpq/pqcomm.c:904 #, c-format msgid "there is no client connection" msgstr "нет клиентÑкого подключениÑ" -#: libpq/pqcomm.c:936 libpq/pqcomm.c:1032 +#: libpq/pqcomm.c:955 libpq/pqcomm.c:1051 #, c-format msgid "could not receive data from client: %m" msgstr "не удалоÑÑŒ получить данные от клиента: %m" -#: libpq/pqcomm.c:1177 tcop/postgres.c:3917 +#: libpq/pqcomm.c:1196 tcop/postgres.c:3915 #, c-format msgid "terminating connection because protocol synchronization was lost" msgstr "закрытие Ð¿Ð¾Ð´ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð¸Ð·-за потери Ñинхронизации протокола" -#: libpq/pqcomm.c:1243 +#: libpq/pqcomm.c:1262 #, c-format msgid "unexpected EOF within message length word" msgstr "неожиданный обрыв данных в Ñлове длины ÑообщениÑ" -#: libpq/pqcomm.c:1254 +#: libpq/pqcomm.c:1273 #, c-format msgid "invalid message length" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° ÑообщениÑ" -#: libpq/pqcomm.c:1276 libpq/pqcomm.c:1289 +#: libpq/pqcomm.c:1295 libpq/pqcomm.c:1308 #, c-format msgid "incomplete message from client" msgstr "неполное Ñообщение от клиента" -#: libpq/pqcomm.c:1422 +#: libpq/pqcomm.c:1441 #, c-format msgid "could not send data to client: %m" msgstr "не удалоÑÑŒ поÑлать данные клиенту: %m" @@ -13212,7 +12950,7 @@ msgid "could not implement GROUP BY" msgstr "не удалоÑÑŒ реализовать GROUP BY" #: optimizer/plan/planner.c:3810 optimizer/plan/planner.c:4203 -#: optimizer/prep/prepunion.c:929 +#: optimizer/prep/prepunion.c:939 #, c-format msgid "" "Some of the datatypes only support hashing, while others only support " @@ -13251,18 +12989,18 @@ msgstr "Столбцы, Ñортирующие окна, должны иметь msgid "too many range table entries" msgstr "Ñлишком много Ñлементов RTE" -#: optimizer/prep/prepunion.c:484 +#: optimizer/prep/prepunion.c:494 #, c-format msgid "could not implement recursive UNION" msgstr "не удалоÑÑŒ реализовать рекурÑивный UNION" -#: optimizer/prep/prepunion.c:485 +#: optimizer/prep/prepunion.c:495 #, c-format msgid "All column datatypes must be hashable." msgstr "Ð’Ñе Ñтолбцы должны иметь хешируемые типы данных." #. translator: %s is UNION, INTERSECT, or EXCEPT -#: optimizer/prep/prepunion.c:928 +#: optimizer/prep/prepunion.c:938 #, c-format msgid "could not implement %s" msgstr "не удалоÑÑŒ реализовать %s" @@ -14321,7 +14059,7 @@ msgstr "параметр $%d не ÑущеÑтвует" msgid "NULLIF requires = operator to yield boolean" msgstr "Ð´Ð»Ñ NULLIF требуетÑÑ, чтобы оператор = возвращал логичеÑкое значение" -#: parser/parse_expr.c:1501 gram.y:9887 +#: parser/parse_expr.c:1501 gram.y:9896 #, c-format msgid "number of columns does not match number of values" msgstr "чиÑло Ñтолбцов не равно чиÑлу значений" @@ -14661,8 +14399,8 @@ msgid "array assignment requires type %s but expression is of type %s" msgstr "" "Ð´Ð»Ñ Ð¿Ñ€Ð¸ÑÐ²Ð°Ð¸Ð²Ð°Ð½Ð¸Ñ Ð¼Ð°ÑÑива требуетÑÑ Ñ‚Ð¸Ð¿ %s, однако выражение имеет тип %s" -#: parser/parse_oper.c:125 parser/parse_oper.c:722 utils/adt/regproc.c:583 -#: utils/adt/regproc.c:603 utils/adt/regproc.c:787 +#: parser/parse_oper.c:125 parser/parse_oper.c:722 utils/adt/regproc.c:584 +#: utils/adt/regproc.c:604 utils/adt/regproc.c:788 #, c-format msgid "operator does not exist: %s" msgstr "оператор не ÑущеÑтвует: %s" @@ -14961,133 +14699,133 @@ msgstr "модификатором типа должна быть проÑÑ‚Ð°Ñ msgid "invalid type name \"%s\"" msgstr "неверное Ð¸Ð¼Ñ Ñ‚Ð¸Ð¿Ð° \"%s\"" -#: parser/parse_utilcmd.c:384 +#: parser/parse_utilcmd.c:385 #, c-format msgid "array of serial is not implemented" msgstr "маÑÑивы Ñ Ñ‚Ð¸Ð¿Ð¾Ð¼ serial не реализованы" -#: parser/parse_utilcmd.c:432 +#: parser/parse_utilcmd.c:433 #, c-format msgid "%s will create implicit sequence \"%s\" for serial column \"%s.%s\"" msgstr "%s ÑоздаÑÑ‚ поÑледовательноÑÑ‚ÑŒ \"%s\" Ð´Ð»Ñ Ñтолбца serial \"%s.%s\"" -#: parser/parse_utilcmd.c:526 parser/parse_utilcmd.c:538 +#: parser/parse_utilcmd.c:527 parser/parse_utilcmd.c:539 #, c-format msgid "" "conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"" msgstr "конфликт NULL/NOT NULL в объÑвлении Ñтолбца \"%s\" таблицы \"%s\"" -#: parser/parse_utilcmd.c:550 +#: parser/parse_utilcmd.c:551 #, c-format msgid "multiple default values specified for column \"%s\" of table \"%s\"" msgstr "" "Ð´Ð»Ñ Ñтолбца \"%s\" таблицы \"%s\" указано неÑколько значений по умолчанию" -#: parser/parse_utilcmd.c:567 parser/parse_utilcmd.c:658 +#: parser/parse_utilcmd.c:568 parser/parse_utilcmd.c:659 #, c-format msgid "primary key constraints are not supported on foreign tables" msgstr "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð¿ÐµÑ€Ð²Ð¸Ñ‡Ð½Ð¾Ð³Ð¾ ключа Ð´Ð»Ñ Ñторонних таблиц не поддерживаютÑÑ" -#: parser/parse_utilcmd.c:576 parser/parse_utilcmd.c:668 +#: parser/parse_utilcmd.c:577 parser/parse_utilcmd.c:669 #, c-format msgid "unique constraints are not supported on foreign tables" msgstr "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ ÑƒÐ½Ð¸ÐºÐ°Ð»ÑŒÐ½Ð¾Ñти Ð´Ð»Ñ Ñторонних таблиц не поддерживаютÑÑ" -#: parser/parse_utilcmd.c:593 parser/parse_utilcmd.c:692 +#: parser/parse_utilcmd.c:594 parser/parse_utilcmd.c:693 #, c-format msgid "foreign key constraints are not supported on foreign tables" msgstr "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ Ð²Ð½ÐµÑˆÐ½ÐµÐ³Ð¾ ключа Ð´Ð»Ñ Ñторонних таблиц не поддерживаютÑÑ" -#: parser/parse_utilcmd.c:678 +#: parser/parse_utilcmd.c:679 #, c-format msgid "exclusion constraints are not supported on foreign tables" msgstr "ограничениÑ-иÑÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð´Ð»Ñ Ñторонних таблиц не поддерживаютÑÑ" -#: parser/parse_utilcmd.c:742 +#: parser/parse_utilcmd.c:743 #, c-format msgid "LIKE is not supported for creating foreign tables" msgstr "LIKE при Ñоздании Ñторонних таблиц не поддерживаетÑÑ" -#: parser/parse_utilcmd.c:1275 parser/parse_utilcmd.c:1351 +#: parser/parse_utilcmd.c:1276 parser/parse_utilcmd.c:1352 #, c-format msgid "Index \"%s\" contains a whole-row table reference." msgstr "Ð˜Ð½Ð´ÐµÐºÑ \"%s\" ÑÑылаетÑÑ Ð½Ð° тип вÑей Ñтроки таблицы." -#: parser/parse_utilcmd.c:1621 +#: parser/parse_utilcmd.c:1622 #, c-format msgid "cannot use an existing index in CREATE TABLE" msgstr "в CREATE TABLE Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать ÑущеÑтвующий индекÑ" -#: parser/parse_utilcmd.c:1641 +#: parser/parse_utilcmd.c:1642 #, c-format msgid "index \"%s\" is already associated with a constraint" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" уже ÑвÑзан Ñ Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸ÐµÐ¼" -#: parser/parse_utilcmd.c:1649 +#: parser/parse_utilcmd.c:1650 #, c-format msgid "index \"%s\" does not belong to table \"%s\"" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" не принадлежит таблице \"%s\"" -#: parser/parse_utilcmd.c:1656 +#: parser/parse_utilcmd.c:1657 #, c-format msgid "index \"%s\" is not valid" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" - нерабочий" -#: parser/parse_utilcmd.c:1662 +#: parser/parse_utilcmd.c:1663 #, c-format msgid "\"%s\" is not a unique index" msgstr "\"%s\" не ÑвлÑетÑÑ ÑƒÐ½Ð¸ÐºÐ°Ð»ÑŒÐ½Ñ‹Ð¼ индекÑом" -#: parser/parse_utilcmd.c:1663 parser/parse_utilcmd.c:1670 -#: parser/parse_utilcmd.c:1677 parser/parse_utilcmd.c:1747 +#: parser/parse_utilcmd.c:1664 parser/parse_utilcmd.c:1671 +#: parser/parse_utilcmd.c:1678 parser/parse_utilcmd.c:1748 #, c-format msgid "Cannot create a primary key or unique constraint using such an index." msgstr "" "Создать первичный ключ или ограничение уникальноÑти Ð´Ð»Ñ Ñ‚Ð°ÐºÐ¾Ð³Ð¾ индекÑа " "нельзÑ." -#: parser/parse_utilcmd.c:1669 +#: parser/parse_utilcmd.c:1670 #, c-format msgid "index \"%s\" contains expressions" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" Ñодержит выражениÑ" -#: parser/parse_utilcmd.c:1676 +#: parser/parse_utilcmd.c:1677 #, c-format msgid "\"%s\" is a partial index" msgstr "\"%s\" - чаÑтичный индекÑ" -#: parser/parse_utilcmd.c:1688 +#: parser/parse_utilcmd.c:1689 #, c-format msgid "\"%s\" is a deferrable index" msgstr "\"%s\" - откладываемый индекÑ" -#: parser/parse_utilcmd.c:1689 +#: parser/parse_utilcmd.c:1690 #, c-format msgid "Cannot create a non-deferrable constraint using a deferrable index." msgstr "" "Создать не откладываемое ограничение на базе откладываемого индекÑа нельзÑ." -#: parser/parse_utilcmd.c:1746 +#: parser/parse_utilcmd.c:1747 #, c-format msgid "index \"%s\" does not have default sorting behavior" msgstr "Ð´Ð»Ñ Ð¸Ð½Ð´ÐµÐºÑа \"%s\" не определено поведение при Ñортировке по умолчанию" -#: parser/parse_utilcmd.c:1893 +#: parser/parse_utilcmd.c:1894 #, c-format msgid "column \"%s\" appears twice in primary key constraint" msgstr "Ñтолбец \"%s\" фигурирует в первичном ключе дважды" -#: parser/parse_utilcmd.c:1899 +#: parser/parse_utilcmd.c:1900 #, c-format msgid "column \"%s\" appears twice in unique constraint" msgstr "Ñтолбец \"%s\" фигурирует в ограничении уникальноÑти дважды" -#: parser/parse_utilcmd.c:2103 +#: parser/parse_utilcmd.c:2104 #, c-format msgid "index expression cannot return a set" msgstr "индекÑное выражение не может возвращать множеÑтво" -#: parser/parse_utilcmd.c:2114 +#: parser/parse_utilcmd.c:2115 #, c-format msgid "" "index expressions and predicates can refer only to the table being indexed" @@ -15095,17 +14833,17 @@ msgstr "" "индекÑные Ð²Ñ‹Ñ€Ð°Ð¶ÐµÐ½Ð¸Ñ Ð¸ предикаты могут ÑÑылатьÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ на индекÑируемую " "таблицу" -#: parser/parse_utilcmd.c:2160 +#: parser/parse_utilcmd.c:2161 #, c-format msgid "rules on materialized views are not supported" msgstr "правила Ð´Ð»Ñ Ð¼Ð°Ñ‚ÐµÑ€Ð¸Ð°Ð»Ð¸Ð·Ð¾Ð²Ð°Ð½Ð½Ñ‹Ñ… предÑтавлений не поддерживаютÑÑ" -#: parser/parse_utilcmd.c:2221 +#: parser/parse_utilcmd.c:2222 #, c-format msgid "rule WHERE condition cannot contain references to other relations" msgstr "в уÑловиÑÑ… WHERE Ð´Ð»Ñ Ð¿Ñ€Ð°Ð²Ð¸Ð» Ð½ÐµÐ»ÑŒÐ·Ñ ÑÑылатьÑÑ Ð½Ð° другие отношениÑ" -#: parser/parse_utilcmd.c:2293 +#: parser/parse_utilcmd.c:2294 #, c-format msgid "" "rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE " @@ -15114,85 +14852,85 @@ msgstr "" "правила Ñ ÑƒÑловиÑми WHERE могут Ñодержать только дейÑÑ‚Ð²Ð¸Ñ SELECT, INSERT, " "UPDATE или DELETE" -#: parser/parse_utilcmd.c:2311 parser/parse_utilcmd.c:2410 +#: parser/parse_utilcmd.c:2312 parser/parse_utilcmd.c:2411 #: rewrite/rewriteHandler.c:485 rewrite/rewriteManip.c:1015 #, c-format msgid "conditional UNION/INTERSECT/EXCEPT statements are not implemented" msgstr "уÑловные операторы UNION/INTERSECT/EXCEPT не реализованы" -#: parser/parse_utilcmd.c:2329 +#: parser/parse_utilcmd.c:2330 #, c-format msgid "ON SELECT rule cannot use OLD" msgstr "в правиле ON SELECT Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать OLD" -#: parser/parse_utilcmd.c:2333 +#: parser/parse_utilcmd.c:2334 #, c-format msgid "ON SELECT rule cannot use NEW" msgstr "в правиле ON SELECT Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать NEW" -#: parser/parse_utilcmd.c:2342 +#: parser/parse_utilcmd.c:2343 #, c-format msgid "ON INSERT rule cannot use OLD" msgstr "в правиле ON INSERT Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать OLD" -#: parser/parse_utilcmd.c:2348 +#: parser/parse_utilcmd.c:2349 #, c-format msgid "ON DELETE rule cannot use NEW" msgstr "в правиле ON DELETE Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать NEW" -#: parser/parse_utilcmd.c:2376 +#: parser/parse_utilcmd.c:2377 #, c-format msgid "cannot refer to OLD within WITH query" msgstr "в запроÑе WITH Ð½ÐµÐ»ÑŒÐ·Ñ ÑÑылатьÑÑ Ð½Ð° OLD" -#: parser/parse_utilcmd.c:2383 +#: parser/parse_utilcmd.c:2384 #, c-format msgid "cannot refer to NEW within WITH query" msgstr "в запроÑе WITH Ð½ÐµÐ»ÑŒÐ·Ñ ÑÑылатьÑÑ Ð½Ð° NEW" -#: parser/parse_utilcmd.c:2586 +#: parser/parse_utilcmd.c:2587 #, c-format msgid "transform expression must not return a set" msgstr "выражение Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð½Ðµ должно возвращать множеÑтво" -#: parser/parse_utilcmd.c:2700 +#: parser/parse_utilcmd.c:2701 #, c-format msgid "misplaced DEFERRABLE clause" msgstr "предложение DEFERRABLE раÑположено неправильно" -#: parser/parse_utilcmd.c:2705 parser/parse_utilcmd.c:2720 +#: parser/parse_utilcmd.c:2706 parser/parse_utilcmd.c:2721 #, c-format msgid "multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed" msgstr "DEFERRABLE/NOT DEFERRABLE можно указать только один раз" -#: parser/parse_utilcmd.c:2715 +#: parser/parse_utilcmd.c:2716 #, c-format msgid "misplaced NOT DEFERRABLE clause" msgstr "предложение NOT DEFERRABLE раÑположено неправильно" -#: parser/parse_utilcmd.c:2728 parser/parse_utilcmd.c:2754 gram.y:4902 +#: parser/parse_utilcmd.c:2729 parser/parse_utilcmd.c:2755 gram.y:4911 #, c-format msgid "constraint declared INITIALLY DEFERRED must be DEFERRABLE" msgstr "" "ограничение Ñ Ñ…Ð°Ñ€Ð°ÐºÑ‚ÐµÑ€Ð¸Ñтикой INITIALLY DEFERRED должно быть объÑвлено как " "DEFERRABLE" -#: parser/parse_utilcmd.c:2736 +#: parser/parse_utilcmd.c:2737 #, c-format msgid "misplaced INITIALLY DEFERRED clause" msgstr "предложение INITIALLY DEFERRED раÑположено неправильно" -#: parser/parse_utilcmd.c:2741 parser/parse_utilcmd.c:2767 +#: parser/parse_utilcmd.c:2742 parser/parse_utilcmd.c:2768 #, c-format msgid "multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed" msgstr "INITIALLY IMMEDIATE/DEFERRED можно указать только один раз" -#: parser/parse_utilcmd.c:2762 +#: parser/parse_utilcmd.c:2763 #, c-format msgid "misplaced INITIALLY IMMEDIATE clause" msgstr "предложение INITIALLY IMMEDIATE раÑположено неправильно" -#: parser/parse_utilcmd.c:2953 +#: parser/parse_utilcmd.c:2954 #, c-format msgid "" "CREATE specifies a schema (%s) different from the one being created (%s)" @@ -15241,17 +14979,17 @@ msgstr "" "Возможно, вам Ñледует увеличить параметр Ñдра SEMVMX минимум до %d. " "Подробнее об Ñтом напиÑано в документации PostgreSQL." -#: port/pg_shmem.c:175 port/sysv_shmem.c:175 +#: port/pg_shmem.c:195 port/sysv_shmem.c:195 #, c-format msgid "could not create shared memory segment: %m" msgstr "не удалоÑÑŒ Ñоздать Ñегмент разделÑемой памÑти: %m" -#: port/pg_shmem.c:176 port/sysv_shmem.c:176 +#: port/pg_shmem.c:196 port/sysv_shmem.c:196 #, c-format msgid "Failed system call was shmget(key=%lu, size=%zu, 0%o)." msgstr "Ошибка в ÑиÑтемном вызове shmget(ключ=%lu, размер=%zu, 0%o)." -#: port/pg_shmem.c:180 port/sysv_shmem.c:180 +#: port/pg_shmem.c:200 port/sysv_shmem.c:200 #, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory " @@ -15265,7 +15003,7 @@ msgstr "" "ÐŸÐ¾Ð´Ñ€Ð¾Ð±Ð½Ð°Ñ Ð¸Ð½Ñ„Ð¾Ñ€Ð¼Ð°Ñ†Ð¸Ñ Ð¾ наÑтройке разделÑемой памÑти ÑодержитÑÑ Ð² " "документации PostgreSQL." -#: port/pg_shmem.c:187 port/sysv_shmem.c:187 +#: port/pg_shmem.c:207 port/sysv_shmem.c:207 #, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory " @@ -15280,7 +15018,7 @@ msgstr "" "ÐŸÐ¾Ð´Ñ€Ð¾Ð±Ð½Ð°Ñ Ð¸Ð½Ñ„Ð¾Ñ€Ð¼Ð°Ñ†Ð¸Ñ Ð¾ наÑтройке разделÑемой памÑти ÑодержитÑÑ Ð² " "документации PostgreSQL." -#: port/pg_shmem.c:193 port/sysv_shmem.c:193 +#: port/pg_shmem.c:213 port/sysv_shmem.c:213 #, c-format msgid "" "This error does *not* mean that you have run out of disk space. It occurs " @@ -15297,12 +15035,12 @@ msgstr "" "ÐŸÐ¾Ð´Ñ€Ð¾Ð±Ð½Ð°Ñ Ð¸Ð½Ñ„Ð¾Ñ€Ð¼Ð°Ñ†Ð¸Ñ Ð¾ наÑтройке разделÑемой памÑти ÑодержитÑÑ Ð² " "документации PostgreSQL." -#: port/pg_shmem.c:483 port/sysv_shmem.c:483 +#: port/pg_shmem.c:504 port/sysv_shmem.c:504 #, c-format msgid "could not map anonymous shared memory: %m" msgstr "не удалоÑÑŒ получить анонимную разделÑемую памÑÑ‚ÑŒ: %m" -#: port/pg_shmem.c:485 port/sysv_shmem.c:485 +#: port/pg_shmem.c:506 port/sysv_shmem.c:506 #, c-format msgid "" "This error usually means that PostgreSQL's request for a shared memory " @@ -15316,12 +15054,12 @@ msgstr "" "Б) можно Ñнизить иÑпользование разделÑемой памÑти, возможно, уменьшив " "shared_buffers или max_connections." -#: port/pg_shmem.c:551 port/sysv_shmem.c:551 port/win32_shmem.c:134 +#: port/pg_shmem.c:572 port/sysv_shmem.c:572 port/win32_shmem.c:134 #, c-format msgid "huge pages not supported on this platform" msgstr "гигантÑкие Ñтраницы на Ñтой платформе не поддерживаютÑÑ" -#: port/pg_shmem.c:646 port/sysv_shmem.c:646 +#: port/pg_shmem.c:667 port/sysv_shmem.c:667 #, c-format msgid "could not stat data directory \"%s\": %m" msgstr "не удалоÑÑŒ получить информацию о каталоге данных \"%s\": %m" @@ -15485,17 +15223,17 @@ msgstr "автоочиÑтка не запущена из-за неправил msgid "Enable the \"track_counts\" option." msgstr "Включите параметр \"track_counts\"." -#: postmaster/bgworker.c:346 postmaster/bgworker.c:745 +#: postmaster/bgworker.c:367 postmaster/bgworker.c:762 #, c-format msgid "registering background worker \"%s\"" msgstr "региÑÑ‚Ñ€Ð°Ñ†Ð¸Ñ Ñ„Ð¾Ð½Ð¾Ð²Ð¾Ð³Ð¾ процеÑÑа \"%s\"" -#: postmaster/bgworker.c:375 +#: postmaster/bgworker.c:396 #, c-format msgid "unregistering background worker \"%s\"" msgstr "разрегиÑÑ‚Ñ€Ð°Ñ†Ð¸Ñ Ñ„Ð¾Ð½Ð¾Ð²Ð¾Ð³Ð¾ процеÑÑа \"%s\"" -#: postmaster/bgworker.c:484 +#: postmaster/bgworker.c:505 #, c-format msgid "" "background worker \"%s\": must attach to shared memory in order to request a " @@ -15504,7 +15242,7 @@ msgstr "" "фоновый процеÑÑ \"%s\" должен иметь доÑтуп к общей памÑти, чтобы запроÑить " "подключение к БД" -#: postmaster/bgworker.c:493 +#: postmaster/bgworker.c:514 #, c-format msgid "" "background worker \"%s\": cannot request database access if starting at " @@ -15513,24 +15251,24 @@ msgstr "" "фоновый процеÑÑ \"%s\" не может получить доÑтуп к БД, еÑли он запущен при " "Ñтарте главного процеÑÑа" -#: postmaster/bgworker.c:507 +#: postmaster/bgworker.c:528 #, c-format msgid "background worker \"%s\": invalid restart interval" msgstr "фоновый процеÑÑ \"%s\": неправильный интервал перезапуÑка" -#: postmaster/bgworker.c:552 +#: postmaster/bgworker.c:573 #, c-format msgid "terminating background worker \"%s\" due to administrator command" msgstr "завершение фонового процеÑÑа \"%s\" по команде админиÑтратора" -#: postmaster/bgworker.c:752 +#: postmaster/bgworker.c:769 #, c-format msgid "" "background worker \"%s\": must be registered in shared_preload_libraries" msgstr "" "фоновой процеÑÑ \"%s\" должен быть зарегиÑтрирован в shared_preload_libraries" -#: postmaster/bgworker.c:764 +#: postmaster/bgworker.c:781 #, c-format msgid "" "background worker \"%s\": only dynamic background workers can request " @@ -15539,12 +15277,12 @@ msgstr "" "фоновый процеÑÑ \"%s\": только динамичеÑкие фоновые процеÑÑÑ‹ могут " "запрашивать уведомление" -#: postmaster/bgworker.c:779 +#: postmaster/bgworker.c:796 #, c-format msgid "too many background workers" msgstr "Ñлишком много фоновых процеÑÑов" -#: postmaster/bgworker.c:780 +#: postmaster/bgworker.c:797 #, c-format msgid "Up to %d background worker can be registered with the current settings." msgid_plural "" @@ -15556,7 +15294,7 @@ msgstr[1] "" msgstr[2] "" "МакÑимально возможное чиÑло фоновых процеÑÑов при текущих параметрах: %d." -#: postmaster/bgworker.c:784 +#: postmaster/bgworker.c:801 #, c-format msgid "" "Consider increasing the configuration parameter \"max_worker_processes\"." @@ -15630,7 +15368,7 @@ msgstr "Команда архивации Ñ Ð¾ÑˆÐ¸Ð±ÐºÐ¾Ð¹: %s" msgid "archive command was terminated by exception 0x%X" msgstr "команда архивации была прервана иÑключением 0x%X" -#: postmaster/pgarch.c:598 postmaster/postmaster.c:3491 +#: postmaster/pgarch.c:598 postmaster/postmaster.c:3514 #, c-format msgid "" "See C include file \"ntstatus.h\" for a description of the hexadecimal value." @@ -15663,132 +15401,132 @@ msgstr "файл архива журнала транзакций \"%s\"" msgid "could not open archive status directory \"%s\": %m" msgstr "не удалоÑÑŒ открыть каталог ÑоÑтоÑÐ½Ð¸Ñ Ð°Ñ€Ñ…Ð¸Ð²Ð° \"%s\": %m" -#: postmaster/pgstat.c:355 +#: postmaster/pgstat.c:358 #, c-format msgid "could not resolve \"localhost\": %s" msgstr "не удалоÑÑŒ разрешить \"localhost\": %s" -#: postmaster/pgstat.c:378 +#: postmaster/pgstat.c:381 #, c-format msgid "trying another address for the statistics collector" msgstr "проба другого адреÑа Ð´Ð»Ñ Ñборщика ÑтатиÑтики" -#: postmaster/pgstat.c:387 +#: postmaster/pgstat.c:390 #, c-format msgid "could not create socket for statistics collector: %m" msgstr "не удалоÑÑŒ Ñоздать Ñокет Ð´Ð»Ñ Ñборщика ÑтатиÑтики: %m" -#: postmaster/pgstat.c:399 +#: postmaster/pgstat.c:402 #, c-format msgid "could not bind socket for statistics collector: %m" msgstr "не удалоÑÑŒ привÑзатьÑÑ Ðº Ñокету Ð´Ð»Ñ Ñборщика ÑтатиÑтики: %m" -#: postmaster/pgstat.c:410 +#: postmaster/pgstat.c:413 #, c-format msgid "could not get address of socket for statistics collector: %m" msgstr "не удалоÑÑŒ получить Ð°Ð´Ñ€ÐµÑ Ñокета Ð´Ð»Ñ Ñборщика ÑтатиÑтики: %m" -#: postmaster/pgstat.c:426 +#: postmaster/pgstat.c:429 #, c-format msgid "could not connect socket for statistics collector: %m" msgstr "не удалоÑÑŒ подключить Ñокет Ð´Ð»Ñ Ñборщика ÑтатиÑтики: %m" -#: postmaster/pgstat.c:447 +#: postmaster/pgstat.c:450 #, c-format msgid "could not send test message on socket for statistics collector: %m" msgstr "" "не удалоÑÑŒ поÑлать теÑтовое Ñообщение в Ñокет Ð´Ð»Ñ Ñборщика ÑтатиÑтики: %m" -#: postmaster/pgstat.c:473 +#: postmaster/pgstat.c:476 #, c-format msgid "select() failed in statistics collector: %m" msgstr "Ñбой select() в Ñборщике ÑтатиÑтики: %m" -#: postmaster/pgstat.c:488 +#: postmaster/pgstat.c:491 #, c-format msgid "test message did not get through on socket for statistics collector" msgstr "теÑтовое Ñообщение не прошло через Ñокет Ð´Ð»Ñ Ñборщика ÑтатиÑтики" -#: postmaster/pgstat.c:503 +#: postmaster/pgstat.c:506 #, c-format msgid "could not receive test message on socket for statistics collector: %m" msgstr "" "теÑтовое Ñообщение через Ñокет Ð´Ð»Ñ Ñборщика ÑтатиÑтики получить не удалоÑÑŒ: " "%m" -#: postmaster/pgstat.c:513 +#: postmaster/pgstat.c:516 #, c-format msgid "incorrect test message transmission on socket for statistics collector" msgstr "теÑтовое Ñообщение через Ñокет Ð´Ð»Ñ Ñборщика ÑтатиÑтики прошло неверно" -#: postmaster/pgstat.c:536 +#: postmaster/pgstat.c:539 #, c-format msgid "could not set statistics collector socket to nonblocking mode: %m" msgstr "" "не удалоÑÑŒ переключить Ñокет Ñборщика ÑтатиÑтики в неблокирующий режим: %m" -#: postmaster/pgstat.c:546 +#: postmaster/pgstat.c:578 #, c-format msgid "disabling statistics collector for lack of working socket" msgstr "Ñборщик ÑтатиÑтики отключаетÑÑ Ð¸Ð·-за нехватки рабочего Ñокета" -#: postmaster/pgstat.c:693 +#: postmaster/pgstat.c:725 #, c-format msgid "could not fork statistics collector: %m" msgstr "не удалоÑÑŒ породить процеÑÑ Ñборщика ÑтатиÑтики: %m" -#: postmaster/pgstat.c:1261 +#: postmaster/pgstat.c:1293 #, c-format msgid "unrecognized reset target: \"%s\"" msgstr "запрошен ÑÐ±Ñ€Ð¾Ñ Ð½ÐµÐ¸Ð·Ð²ÐµÑтного Ñчётчика: \"%s\"" -#: postmaster/pgstat.c:1262 +#: postmaster/pgstat.c:1294 #, c-format msgid "Target must be \"archiver\" or \"bgwriter\"." msgstr "ДопуÑтимый Ñчётчик: \"archiver\" или \"bgwriter\"." -#: postmaster/pgstat.c:3587 +#: postmaster/pgstat.c:3619 #, c-format msgid "could not read statistics message: %m" msgstr "не удалоÑÑŒ прочитать Ñообщение ÑтатиÑтики: %m" -#: postmaster/pgstat.c:3918 postmaster/pgstat.c:4075 +#: postmaster/pgstat.c:3950 postmaster/pgstat.c:4107 #, c-format msgid "could not open temporary statistics file \"%s\": %m" msgstr "не удалоÑÑŒ открыть временный файл ÑтатиÑтики \"%s\": %m" -#: postmaster/pgstat.c:3985 postmaster/pgstat.c:4120 +#: postmaster/pgstat.c:4017 postmaster/pgstat.c:4152 #, c-format msgid "could not write temporary statistics file \"%s\": %m" msgstr "не удалоÑÑŒ запиÑать во временный файл ÑтатиÑтики \"%s\": %m" -#: postmaster/pgstat.c:3994 postmaster/pgstat.c:4129 +#: postmaster/pgstat.c:4026 postmaster/pgstat.c:4161 #, c-format msgid "could not close temporary statistics file \"%s\": %m" msgstr "не удалоÑÑŒ закрыть временный файл ÑтатиÑтики \"%s\": %m" -#: postmaster/pgstat.c:4002 postmaster/pgstat.c:4137 +#: postmaster/pgstat.c:4034 postmaster/pgstat.c:4169 #, c-format msgid "could not rename temporary statistics file \"%s\" to \"%s\": %m" msgstr "" "не удалоÑÑŒ переименовать временный файл ÑтатиÑтики из \"%s\" в \"%s\": %m" -#: postmaster/pgstat.c:4226 postmaster/pgstat.c:4411 postmaster/pgstat.c:4564 +#: postmaster/pgstat.c:4258 postmaster/pgstat.c:4464 postmaster/pgstat.c:4617 #, c-format msgid "could not open statistics file \"%s\": %m" msgstr "не удалоÑÑŒ открыть файл ÑтатиÑтики \"%s\": %m" -#: postmaster/pgstat.c:4238 postmaster/pgstat.c:4248 postmaster/pgstat.c:4258 -#: postmaster/pgstat.c:4279 postmaster/pgstat.c:4294 postmaster/pgstat.c:4348 -#: postmaster/pgstat.c:4423 postmaster/pgstat.c:4443 postmaster/pgstat.c:4461 -#: postmaster/pgstat.c:4477 postmaster/pgstat.c:4495 postmaster/pgstat.c:4511 -#: postmaster/pgstat.c:4576 postmaster/pgstat.c:4588 postmaster/pgstat.c:4600 -#: postmaster/pgstat.c:4625 postmaster/pgstat.c:4647 +#: postmaster/pgstat.c:4270 postmaster/pgstat.c:4280 postmaster/pgstat.c:4301 +#: postmaster/pgstat.c:4323 postmaster/pgstat.c:4338 postmaster/pgstat.c:4401 +#: postmaster/pgstat.c:4476 postmaster/pgstat.c:4496 postmaster/pgstat.c:4514 +#: postmaster/pgstat.c:4530 postmaster/pgstat.c:4548 postmaster/pgstat.c:4564 +#: postmaster/pgstat.c:4629 postmaster/pgstat.c:4641 postmaster/pgstat.c:4653 +#: postmaster/pgstat.c:4678 postmaster/pgstat.c:4700 #, c-format msgid "corrupted statistics file \"%s\"" msgstr "файл ÑтатиÑтики \"%s\" иÑпорчен" -#: postmaster/pgstat.c:4776 +#: postmaster/pgstat.c:4829 #, c-format msgid "" "using stale statistics instead of current ones because stats collector is " @@ -15797,44 +15535,44 @@ msgstr "" "иÑпользуетÑÑ Ð¿Ñ€Ð¾ÑÑ€Ð¾Ñ‡ÐµÐ½Ð½Ð°Ñ ÑтатиÑтика вмеÑто текущей, так как Ñборщик " "ÑтатиÑтики не отвечает" -#: postmaster/pgstat.c:5103 +#: postmaster/pgstat.c:5156 #, c-format msgid "database hash table corrupted during cleanup --- abort" msgstr "таблица хеша базы данных иÑпорчена при очиÑтке --- прерывание" -#: postmaster/postmaster.c:684 +#: postmaster/postmaster.c:702 #, c-format msgid "%s: invalid argument for option -f: \"%s\"\n" msgstr "%s: неверный аргумент Ð´Ð»Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð° -f: \"%s\"\n" -#: postmaster/postmaster.c:770 +#: postmaster/postmaster.c:788 #, c-format msgid "%s: invalid argument for option -t: \"%s\"\n" msgstr "%s: неверный аргумент Ð´Ð»Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð° -t: \"%s\"\n" -#: postmaster/postmaster.c:821 +#: postmaster/postmaster.c:839 #, c-format msgid "%s: invalid argument: \"%s\"\n" msgstr "%s: неверный аргумент: \"%s\"\n" -#: postmaster/postmaster.c:860 +#: postmaster/postmaster.c:878 #, c-format msgid "%s: superuser_reserved_connections must be less than max_connections\n" msgstr "" "%s: параметр superuser_reserved_connections должен быть меньше " "max_connections\n" -#: postmaster/postmaster.c:865 +#: postmaster/postmaster.c:883 #, c-format msgid "%s: max_wal_senders must be less than max_connections\n" msgstr "%s: параметр max_wal_senders должен быть меньше max_connections\n" -#: postmaster/postmaster.c:870 +#: postmaster/postmaster.c:888 #, c-format msgid "WAL archival cannot be enabled when wal_level is \"minimal\"" msgstr "Ðрхивацию WAL Ð½ÐµÐ»ÑŒÐ·Ñ Ð²ÐºÐ»ÑŽÑ‡Ð¸Ñ‚ÑŒ, еÑли уÑтановлен wal_level \"minimal\"" -#: postmaster/postmaster.c:873 +#: postmaster/postmaster.c:891 #, c-format msgid "" "WAL streaming (max_wal_senders > 0) requires wal_level \"replica\" or " @@ -15843,88 +15581,88 @@ msgstr "" "Ð”Ð»Ñ Ð¿Ð¾Ñ‚Ð¾ÐºÐ¾Ð²Ð¾Ð¹ транÑлÑции WAL (max_wal_senders > 0) wal_level должен быть " "\"replica\" или \"logical\"" -#: postmaster/postmaster.c:881 +#: postmaster/postmaster.c:899 #, c-format msgid "%s: invalid datetoken tables, please fix\n" msgstr "%s: ошибка в таблицах маркеров времени, требуетÑÑ Ð¸Ñправление\n" -#: postmaster/postmaster.c:973 postmaster/postmaster.c:1071 +#: postmaster/postmaster.c:991 postmaster/postmaster.c:1089 #: utils/init/miscinit.c:1429 #, c-format msgid "invalid list syntax in parameter \"%s\"" msgstr "неверный формат ÑпиÑка в параметре \"%s\"" -#: postmaster/postmaster.c:1004 +#: postmaster/postmaster.c:1022 #, c-format msgid "could not create listen socket for \"%s\"" msgstr "не удалоÑÑŒ Ñоздать принимающий Ñокет Ð´Ð»Ñ \"%s\"" -#: postmaster/postmaster.c:1010 +#: postmaster/postmaster.c:1028 #, c-format msgid "could not create any TCP/IP sockets" msgstr "не удалоÑÑŒ Ñоздать Ñокеты TCP/IP" -#: postmaster/postmaster.c:1093 +#: postmaster/postmaster.c:1111 #, c-format msgid "could not create Unix-domain socket in directory \"%s\"" msgstr "не удалоÑÑŒ Ñоздать доменный Ñокет в каталоге \"%s\"" -#: postmaster/postmaster.c:1099 +#: postmaster/postmaster.c:1117 #, c-format msgid "could not create any Unix-domain sockets" msgstr "ни один доменный Ñокет Ñоздать не удалоÑÑŒ" -#: postmaster/postmaster.c:1111 +#: postmaster/postmaster.c:1129 #, c-format msgid "no socket created for listening" msgstr "отÑутÑтвуют принимающие Ñокеты" -#: postmaster/postmaster.c:1151 +#: postmaster/postmaster.c:1169 #, c-format msgid "could not create I/O completion port for child queue" msgstr "не удалоÑÑŒ Ñоздать порт Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ð²Ð²Ð¾Ð´Ð°/вывода Ð´Ð»Ñ Ð¾Ñ‡ÐµÑ€ÐµÐ´Ð¸ потомков" -#: postmaster/postmaster.c:1180 +#: postmaster/postmaster.c:1198 #, c-format msgid "%s: could not change permissions of external PID file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ поменÑÑ‚ÑŒ права Ð´Ð»Ñ Ð²Ð½ÐµÑˆÐ½ÐµÐ³Ð¾ файла PID \"%s\": %s\n" -#: postmaster/postmaster.c:1184 +#: postmaster/postmaster.c:1202 #, c-format msgid "%s: could not write external PID file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ запиÑать внешний файл PID \"%s\": %s\n" -#: postmaster/postmaster.c:1234 +#: postmaster/postmaster.c:1252 #, c-format msgid "ending log output to stderr" msgstr "завершение вывода в stderr" -#: postmaster/postmaster.c:1235 +#: postmaster/postmaster.c:1253 #, c-format msgid "Future log output will go to log destination \"%s\"." msgstr "Ð’ дальнейшем протокол будет выводитьÑÑ Ð² \"%s\"." -#: postmaster/postmaster.c:1261 utils/init/postinit.c:213 +#: postmaster/postmaster.c:1279 utils/init/postinit.c:213 #, c-format msgid "could not load pg_hba.conf" msgstr "не удалоÑÑŒ загрузить pg_hba.conf" -#: postmaster/postmaster.c:1287 +#: postmaster/postmaster.c:1305 #, c-format msgid "postmaster became multithreaded during startup" msgstr "процеÑÑ postmaster Ñтал многопоточным при запуÑке" -#: postmaster/postmaster.c:1288 +#: postmaster/postmaster.c:1306 #, c-format msgid "Set the LC_ALL environment variable to a valid locale." msgstr "УÑтановите в переменной Ð¾ÐºÑ€ÑƒÐ¶ÐµÐ½Ð¸Ñ LC_ALL правильную локаль." -#: postmaster/postmaster.c:1385 +#: postmaster/postmaster.c:1403 #, c-format msgid "%s: could not locate matching postgres executable" msgstr "%s: подходÑщий иÑполнÑемый файл postgres не найден" -#: postmaster/postmaster.c:1408 utils/misc/tzparser.c:341 +#: postmaster/postmaster.c:1426 utils/misc/tzparser.c:341 #, c-format msgid "" "This may indicate an incomplete PostgreSQL installation, or that the file " @@ -15933,43 +15671,43 @@ msgstr "" "Возможно, PostgreSQL уÑтановлен не полноÑтью или файла \"%s\" нет в " "положенном меÑте." -#: postmaster/postmaster.c:1436 +#: postmaster/postmaster.c:1454 #, c-format msgid "data directory \"%s\" does not exist" msgstr "каталог данных \"%s\" не ÑущеÑтвует" -#: postmaster/postmaster.c:1441 +#: postmaster/postmaster.c:1459 #, c-format msgid "could not read permissions of directory \"%s\": %m" msgstr "не удалоÑÑŒ Ñчитать права на каталог \"%s\": %m" -#: postmaster/postmaster.c:1449 +#: postmaster/postmaster.c:1467 #, c-format msgid "specified data directory \"%s\" is not a directory" msgstr "указанный каталог данных \"%s\" не ÑущеÑтвует" -#: postmaster/postmaster.c:1465 +#: postmaster/postmaster.c:1483 #, c-format msgid "data directory \"%s\" has wrong ownership" msgstr "владелец каталога данных \"%s\" определён неверно" -#: postmaster/postmaster.c:1467 +#: postmaster/postmaster.c:1485 #, c-format msgid "The server must be started by the user that owns the data directory." msgstr "" "Сервер должен запуÑкать пользователь, ÑвлÑющийÑÑ Ð²Ð»Ð°Ð´ÐµÐ»ÑŒÑ†ÐµÐ¼ каталога данных." -#: postmaster/postmaster.c:1487 +#: postmaster/postmaster.c:1505 #, c-format msgid "data directory \"%s\" has group or world access" msgstr "к каталогу данных \"%s\" имеют доÑтуп вÑе или группа" -#: postmaster/postmaster.c:1489 +#: postmaster/postmaster.c:1507 #, c-format msgid "Permissions should be u=rwx (0700)." msgstr "Права должны быть: u=rwx (0700)." -#: postmaster/postmaster.c:1500 +#: postmaster/postmaster.c:1518 #, c-format msgid "" "%s: could not find the database system\n" @@ -15980,376 +15718,387 @@ msgstr "" "ОжидалоÑÑŒ найти её в каталоге \"%s\",\n" "но открыть файл \"%s\" не удалоÑÑŒ: %s\n" -#: postmaster/postmaster.c:1677 +#: postmaster/postmaster.c:1695 #, c-format msgid "select() failed in postmaster: %m" msgstr "Ñбой select() в postmaster'е: %m" -#: postmaster/postmaster.c:1828 +#: postmaster/postmaster.c:1850 #, c-format msgid "" "performing immediate shutdown because data directory lock file is invalid" msgstr "" "немедленное отключение из-за ошибочного файла блокировки каталога данных" -#: postmaster/postmaster.c:1906 postmaster/postmaster.c:1937 +#: postmaster/postmaster.c:1928 postmaster/postmaster.c:1959 #, c-format msgid "incomplete startup packet" msgstr "неполный Ñтартовый пакет" -#: postmaster/postmaster.c:1918 +#: postmaster/postmaster.c:1940 #, c-format msgid "invalid length of startup packet" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° Ñтартового пакета" -#: postmaster/postmaster.c:1976 +#: postmaster/postmaster.c:1998 #, c-format msgid "failed to send SSL negotiation response: %m" msgstr "не удалоÑÑŒ отправить ответ в процеÑÑе SSL-ÑоглаÑованиÑ: %m" -#: postmaster/postmaster.c:2005 +#: postmaster/postmaster.c:2027 #, c-format msgid "unsupported frontend protocol %u.%u: server supports %u.0 to %u.%u" msgstr "" "неподдерживаемый протокол клиентÑкого Ð¿Ñ€Ð¸Ð»Ð¾Ð¶ÐµÐ½Ð¸Ñ %u.%u; Ñервер поддерживает " "%u.0 - %u.%u" -#: postmaster/postmaster.c:2068 utils/misc/guc.c:5660 utils/misc/guc.c:5753 +#: postmaster/postmaster.c:2090 utils/misc/guc.c:5660 utils/misc/guc.c:5753 #: utils/misc/guc.c:7051 utils/misc/guc.c:9805 utils/misc/guc.c:9839 #, c-format msgid "invalid value for parameter \"%s\": \"%s\"" msgstr "неверное значение Ð´Ð»Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð° \"%s\": \"%s\"" -#: postmaster/postmaster.c:2071 +#: postmaster/postmaster.c:2093 #, c-format msgid "Valid values are: \"false\", 0, \"true\", 1, \"database\"." msgstr "ДопуÑтимые значениÑ: \"false\", 0, \"true\", 1, \"database\"." -#: postmaster/postmaster.c:2091 +#: postmaster/postmaster.c:2113 #, c-format msgid "invalid startup packet layout: expected terminator as last byte" msgstr "" "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ñтруктура Ñтартового пакета: поÑледним байтом должен быть терминатор" -#: postmaster/postmaster.c:2119 +#: postmaster/postmaster.c:2141 #, c-format msgid "no PostgreSQL user name specified in startup packet" msgstr "в Ñтартовом пакете не указано Ð¸Ð¼Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ PostgreSQL" -#: postmaster/postmaster.c:2178 +#: postmaster/postmaster.c:2200 #, c-format msgid "the database system is starting up" msgstr "ÑиÑтема баз данных запуÑкаетÑÑ" -#: postmaster/postmaster.c:2183 +#: postmaster/postmaster.c:2205 #, c-format msgid "the database system is shutting down" msgstr "ÑиÑтема баз данных оÑтанавливаетÑÑ" -#: postmaster/postmaster.c:2188 +#: postmaster/postmaster.c:2210 #, c-format msgid "the database system is in recovery mode" msgstr "ÑиÑтема баз данных в режиме воÑÑтановлениÑ" -#: postmaster/postmaster.c:2193 storage/ipc/procarray.c:297 +#: postmaster/postmaster.c:2215 storage/ipc/procarray.c:298 #: storage/ipc/sinvaladt.c:298 storage/lmgr/proc.c:340 #, c-format msgid "sorry, too many clients already" msgstr "извините, уже Ñлишком много клиентов" -#: postmaster/postmaster.c:2255 +#: postmaster/postmaster.c:2277 #, c-format msgid "wrong key in cancel request for process %d" msgstr "неправильный ключ в запроÑе на отмену процеÑÑа %d" -#: postmaster/postmaster.c:2263 +#: postmaster/postmaster.c:2285 #, c-format msgid "PID %d in cancel request did not match any process" msgstr "процеÑÑ Ñ ÐºÐ¾Ð´Ð¾Ð¼ %d, полученным в запроÑе на отмену, не найден" -#: postmaster/postmaster.c:2483 +#: postmaster/postmaster.c:2505 #, c-format msgid "received SIGHUP, reloading configuration files" msgstr "получен SIGHUP, файлы конфигурации перезагружаютÑÑ" -#: postmaster/postmaster.c:2508 +#: postmaster/postmaster.c:2530 #, c-format msgid "pg_hba.conf not reloaded" msgstr "pg_hba.conf не перезагружен" -#: postmaster/postmaster.c:2512 +#: postmaster/postmaster.c:2534 #, c-format msgid "pg_ident.conf not reloaded" msgstr "pg_ident.conf не перезагружен" -#: postmaster/postmaster.c:2553 +#: postmaster/postmaster.c:2575 #, c-format msgid "received smart shutdown request" msgstr "получен Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° \"вежливое\" выключение" -#: postmaster/postmaster.c:2608 +#: postmaster/postmaster.c:2630 #, c-format msgid "received fast shutdown request" msgstr "получен Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° быÑтрое выключение" -#: postmaster/postmaster.c:2638 +#: postmaster/postmaster.c:2660 #, c-format msgid "aborting any active transactions" msgstr "прерывание вÑех активных транзакций" -#: postmaster/postmaster.c:2672 +#: postmaster/postmaster.c:2694 #, c-format msgid "received immediate shutdown request" msgstr "получен Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° немедленное выключение" -#: postmaster/postmaster.c:2736 +#: postmaster/postmaster.c:2758 #, c-format msgid "shutdown at recovery target" msgstr "выключение при доÑтижении цели воÑÑтановлениÑ" -#: postmaster/postmaster.c:2752 postmaster/postmaster.c:2775 +#: postmaster/postmaster.c:2774 postmaster/postmaster.c:2797 msgid "startup process" msgstr "Ñтартовый процеÑÑ" -#: postmaster/postmaster.c:2755 +#: postmaster/postmaster.c:2777 #, c-format msgid "aborting startup due to startup process failure" msgstr "прерывание запуÑка из-за ошибки в Ñтартовом процеÑÑе" -#: postmaster/postmaster.c:2816 +#: postmaster/postmaster.c:2838 #, c-format msgid "database system is ready to accept connections" msgstr "ÑиÑтема БД готова принимать подключениÑ" -#: postmaster/postmaster.c:2835 +#: postmaster/postmaster.c:2857 msgid "background writer process" msgstr "процеÑÑ Ñ„Ð¾Ð½Ð¾Ð²Ð¾Ð¹ запиÑи" -#: postmaster/postmaster.c:2889 +#: postmaster/postmaster.c:2911 msgid "checkpointer process" msgstr "процеÑÑ ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ñ‹Ñ… точек" -#: postmaster/postmaster.c:2905 +#: postmaster/postmaster.c:2927 msgid "WAL writer process" msgstr "процеÑÑ Ð·Ð°Ð¿Ð¸Ñи WAL" -#: postmaster/postmaster.c:2919 +#: postmaster/postmaster.c:2942 msgid "WAL receiver process" msgstr "процеÑÑ ÑÑ‡Ð¸Ñ‚Ñ‹Ð²Ð°Ð½Ð¸Ñ WAL" -#: postmaster/postmaster.c:2934 +#: postmaster/postmaster.c:2957 msgid "autovacuum launcher process" msgstr "процеÑÑ Ð·Ð°Ð¿ÑƒÑка автоочиÑтки" -#: postmaster/postmaster.c:2949 +#: postmaster/postmaster.c:2972 msgid "archiver process" msgstr "процеÑÑ Ð°Ñ€Ñ…Ð¸Ð²Ð°Ñ†Ð¸Ð¸" -#: postmaster/postmaster.c:2965 +#: postmaster/postmaster.c:2988 msgid "statistics collector process" msgstr "процеÑÑ Ñбора ÑтатиÑтики" -#: postmaster/postmaster.c:2979 +#: postmaster/postmaster.c:3002 msgid "system logger process" msgstr "процеÑÑ ÑиÑтемного протоколированиÑ" -#: postmaster/postmaster.c:3041 +#: postmaster/postmaster.c:3064 msgid "worker process" msgstr "рабочий процеÑÑ" -#: postmaster/postmaster.c:3124 postmaster/postmaster.c:3144 -#: postmaster/postmaster.c:3151 postmaster/postmaster.c:3169 +#: postmaster/postmaster.c:3147 postmaster/postmaster.c:3167 +#: postmaster/postmaster.c:3174 postmaster/postmaster.c:3192 msgid "server process" msgstr "процеÑÑ Ñервера" -#: postmaster/postmaster.c:3223 +#: postmaster/postmaster.c:3246 #, c-format msgid "terminating any other active server processes" msgstr "завершение вÑех оÑтальных активных Ñерверных процеÑÑов" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3479 +#: postmaster/postmaster.c:3502 #, c-format msgid "%s (PID %d) exited with exit code %d" msgstr "%s (PID %d) завершилÑÑ Ñ ÐºÐ¾Ð´Ð¾Ð¼ выхода %d" -#: postmaster/postmaster.c:3481 postmaster/postmaster.c:3492 -#: postmaster/postmaster.c:3503 postmaster/postmaster.c:3512 -#: postmaster/postmaster.c:3522 +#: postmaster/postmaster.c:3504 postmaster/postmaster.c:3515 +#: postmaster/postmaster.c:3526 postmaster/postmaster.c:3535 +#: postmaster/postmaster.c:3545 #, c-format msgid "Failed process was running: %s" msgstr "ЗавершившийÑÑ Ð¿Ñ€Ð¾Ñ†ÐµÑÑ Ð²Ñ‹Ð¿Ð¾Ð»Ð½Ñл дейÑтвие: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3489 +#: postmaster/postmaster.c:3512 #, c-format msgid "%s (PID %d) was terminated by exception 0x%X" msgstr "%s (PID %d) был прерван иÑключением 0x%X" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3499 +#: postmaster/postmaster.c:3522 #, c-format msgid "%s (PID %d) was terminated by signal %d: %s" msgstr "%s (PID %d) был завершён по Ñигналу %d: %s" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3510 +#: postmaster/postmaster.c:3533 #, c-format msgid "%s (PID %d) was terminated by signal %d" msgstr "%s (PID %d) был завершён по Ñигналу %d" #. translator: %s is a noun phrase describing a child process, such as #. "server process" -#: postmaster/postmaster.c:3520 +#: postmaster/postmaster.c:3543 #, c-format msgid "%s (PID %d) exited with unrecognized status %d" msgstr "%s (PID %d) завершилÑÑ Ñ Ð½ÐµÐ¸Ð·Ð²ÐµÑтным кодом ÑоÑтоÑÐ½Ð¸Ñ %d" -#: postmaster/postmaster.c:3707 +#: postmaster/postmaster.c:3730 #, c-format msgid "abnormal database system shutdown" msgstr "аварийное выключение ÑиÑтемы БД" -#: postmaster/postmaster.c:3747 +#: postmaster/postmaster.c:3770 #, c-format msgid "all server processes terminated; reinitializing" msgstr "вÑе Ñерверные процеÑÑÑ‹ завершены... переинициализациÑ" -#: postmaster/postmaster.c:3959 +#: postmaster/postmaster.c:3982 #, c-format msgid "could not fork new process for connection: %m" msgstr "породить новый процеÑÑ Ð´Ð»Ñ ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ð½Ðµ удалоÑÑŒ: %m" -#: postmaster/postmaster.c:4001 +#: postmaster/postmaster.c:4024 msgid "could not fork new process for connection: " msgstr "породить новый процеÑÑ Ð´Ð»Ñ ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ð½Ðµ удалоÑÑŒ: " -#: postmaster/postmaster.c:4115 +#: postmaster/postmaster.c:4138 #, c-format msgid "connection received: host=%s port=%s" msgstr "принÑто подключение: узел=%s порт=%s" -#: postmaster/postmaster.c:4120 +#: postmaster/postmaster.c:4143 #, c-format msgid "connection received: host=%s" msgstr "принÑто подключение: узел=%s" -#: postmaster/postmaster.c:4403 +#: postmaster/postmaster.c:4426 #, c-format msgid "could not execute server process \"%s\": %m" msgstr "запуÑтить Ñерверный процеÑÑ \"%s\" не удалоÑÑŒ: %m" -#: postmaster/postmaster.c:4947 +#: postmaster/postmaster.c:4579 +#, c-format +msgid "giving up after too many tries to reserve shared memory" +msgstr "" +"чиÑло повторных попыток Ñ€ÐµÐ·ÐµÑ€Ð²Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ñ€Ð°Ð·Ð´ÐµÐ»Ñемой памÑти доÑтигло предела" + +#: postmaster/postmaster.c:4580 +#, c-format +msgid "This might be caused by ASLR or antivirus software." +msgstr "Это может быть вызвано антивируÑным ПО или механизмом ASLR." + +#: postmaster/postmaster.c:4978 #, c-format msgid "database system is ready to accept read only connections" msgstr "ÑиÑтема БД готова к подключениÑм в режиме \"только чтение\"" -#: postmaster/postmaster.c:5238 +#: postmaster/postmaster.c:5267 #, c-format msgid "could not fork startup process: %m" msgstr "породить Ñтартовый процеÑÑ Ð½Ðµ удалоÑÑŒ: %m" -#: postmaster/postmaster.c:5242 +#: postmaster/postmaster.c:5271 #, c-format msgid "could not fork background writer process: %m" msgstr "породить процеÑÑ Ñ„Ð¾Ð½Ð¾Ð²Ð¾Ð¹ запиÑи не удалоÑÑŒ: %m" -#: postmaster/postmaster.c:5246 +#: postmaster/postmaster.c:5275 #, c-format msgid "could not fork checkpointer process: %m" msgstr "породить процеÑÑ ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ñ‹Ñ… точек не удалоÑÑŒ: %m" -#: postmaster/postmaster.c:5250 +#: postmaster/postmaster.c:5279 #, c-format msgid "could not fork WAL writer process: %m" msgstr "породить процеÑÑ Ð·Ð°Ð¿Ð¸Ñи WAL не удалоÑÑŒ: %m" -#: postmaster/postmaster.c:5254 +#: postmaster/postmaster.c:5283 #, c-format msgid "could not fork WAL receiver process: %m" msgstr "породить процеÑÑ ÑÑ‡Ð¸Ñ‚Ñ‹Ð²Ð°Ð½Ð¸Ñ WAL не удалоÑÑŒ: %m" -#: postmaster/postmaster.c:5258 +#: postmaster/postmaster.c:5287 #, c-format msgid "could not fork process: %m" msgstr "породить процеÑÑ Ð½Ðµ удалоÑÑŒ: %m" -#: postmaster/postmaster.c:5420 postmaster/postmaster.c:5443 +#: postmaster/postmaster.c:5467 postmaster/postmaster.c:5490 #, c-format msgid "database connection requirement not indicated during registration" msgstr "" "при региÑтрации фонового процеÑÑа не указывалоÑÑŒ, что ему требуетÑÑ " "подключение к БД" -#: postmaster/postmaster.c:5427 postmaster/postmaster.c:5450 +#: postmaster/postmaster.c:5474 postmaster/postmaster.c:5497 #, c-format msgid "invalid processing mode in background worker" msgstr "неправильный режим обработки в фоновом процеÑÑе" -#: postmaster/postmaster.c:5502 +#: postmaster/postmaster.c:5569 #, c-format msgid "starting background worker process \"%s\"" msgstr "запуÑк фонового рабочего процеÑÑа \"%s\"" -#: postmaster/postmaster.c:5513 +#: postmaster/postmaster.c:5581 #, c-format msgid "could not fork worker process: %m" msgstr "породить рабочий процеÑÑ Ð½Ðµ удалоÑÑŒ: %m" -#: postmaster/postmaster.c:5901 +#: postmaster/postmaster.c:5998 #, c-format msgid "could not duplicate socket %d for use in backend: error code %d" msgstr "" "продублировать Ñокет %d Ð´Ð»Ñ Ñерверного процеÑÑа не удалоÑÑŒ (код ошибки: %d)" -#: postmaster/postmaster.c:5933 +#: postmaster/postmaster.c:6030 #, c-format msgid "could not create inherited socket: error code %d\n" msgstr "Ñоздать наÑледуемый Ñокет не удалоÑÑŒ (код ошибки: %d)\n" -#: postmaster/postmaster.c:5962 +#: postmaster/postmaster.c:6059 #, c-format msgid "could not open backend variables file \"%s\": %s\n" msgstr "открыть файл Ñерверных переменных \"%s\" не удалоÑÑŒ: %s\n" -#: postmaster/postmaster.c:5969 +#: postmaster/postmaster.c:6066 #, c-format msgid "could not read from backend variables file \"%s\": %s\n" msgstr "прочитать файл Ñерверных переменных \"%s\" не удалоÑÑŒ: %s\n" -#: postmaster/postmaster.c:5978 +#: postmaster/postmaster.c:6075 #, c-format msgid "could not remove file \"%s\": %s\n" msgstr "не удалоÑÑŒ Ñтереть файл \"%s\": %s\n" -#: postmaster/postmaster.c:5995 +#: postmaster/postmaster.c:6092 #, c-format msgid "could not map view of backend variables: error code %lu\n" msgstr "отобразить файл Ñерверных переменных не удалоÑÑŒ (код ошибки: %lu)\n" -#: postmaster/postmaster.c:6004 +#: postmaster/postmaster.c:6101 #, c-format msgid "could not unmap view of backend variables: error code %lu\n" msgstr "" "отключить отображение файла Ñерверных переменных не удалоÑÑŒ (код ошибки: " "%lu)\n" -#: postmaster/postmaster.c:6011 +#: postmaster/postmaster.c:6108 #, c-format msgid "could not close handle to backend parameter variables: error code %lu\n" msgstr "" "закрыть указатель файла Ñерверных переменных не удалоÑÑŒ (код ошибки: %lu)\n" -#: postmaster/postmaster.c:6172 +#: postmaster/postmaster.c:6269 #, c-format msgid "could not read exit code for process\n" msgstr "прочитать код Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ð¿Ñ€Ð¾Ñ†ÐµÑÑа не удалоÑÑŒ\n" -#: postmaster/postmaster.c:6177 +#: postmaster/postmaster.c:6274 #, c-format msgid "could not post child completion status\n" msgstr "отправить ÑоÑтоÑние Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ð¿Ð¾Ñ‚Ð¾Ð¼ÐºÐ° не удалоÑÑŒ\n" @@ -16564,19 +16313,19 @@ msgstr "ОжидалÑÑ 1 кортеж Ñ 2 полÑми, однако полу msgid "invalid socket: %s" msgstr "неверный Ñокет: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:426 storage/ipc/latch.c:1280 +#: replication/libpqwalreceiver/libpqwalreceiver.c:426 storage/ipc/latch.c:1343 #, c-format msgid "select() failed: %m" msgstr "ошибка в select(): %m" -#: replication/libpqwalreceiver/libpqwalreceiver.c:549 -#: replication/libpqwalreceiver/libpqwalreceiver.c:576 +#: replication/libpqwalreceiver/libpqwalreceiver.c:555 #: replication/libpqwalreceiver/libpqwalreceiver.c:582 +#: replication/libpqwalreceiver/libpqwalreceiver.c:588 #, c-format msgid "could not receive data from WAL stream: %s" msgstr "не удалоÑÑŒ извлечь данные из потока WAL: %s" -#: replication/libpqwalreceiver/libpqwalreceiver.c:601 +#: replication/libpqwalreceiver/libpqwalreceiver.c:607 #, c-format msgid "could not send data to WAL stream: %s" msgstr "не удалоÑÑŒ отправить данные в поток WAL: %s" @@ -16596,18 +16345,18 @@ msgstr "Ð´Ð»Ñ Ð»Ð¾Ð³Ð¸Ñ‡ÐµÑкого Ð´ÐµÐºÐ¾Ð´Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ñ‚Ñ€ÐµÐ±ÑƒÐµÑ‚ msgid "logical decoding cannot be used while in recovery" msgstr "логичеÑкое декодирование Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать в процеÑÑе воÑÑтановлениÑ" -#: replication/logical/logical.c:236 replication/logical/logical.c:348 +#: replication/logical/logical.c:239 replication/logical/logical.c:360 #, c-format msgid "cannot use physical replication slot for logical decoding" msgstr "" "физичеÑкий Ñлот репликации Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ð´Ð»Ñ Ð»Ð¾Ð³Ð¸Ñ‡ÐµÑкого декодированиÑ" -#: replication/logical/logical.c:241 replication/logical/logical.c:353 +#: replication/logical/logical.c:244 replication/logical/logical.c:365 #, c-format msgid "replication slot \"%s\" was not created in this database" msgstr "Ñлот репликации \"%s\" Ñоздан не в Ñтой базе данных" -#: replication/logical/logical.c:248 +#: replication/logical/logical.c:251 #, c-format msgid "" "cannot create logical replication slot in transaction that has performed " @@ -16615,24 +16364,24 @@ msgid "" msgstr "" "Ð½ÐµÐ»ÑŒÐ·Ñ Ñоздать логичеÑкий Ñлот репликации в транзакции, оÑущеÑтвлÑющей запиÑÑŒ" -#: replication/logical/logical.c:390 +#: replication/logical/logical.c:402 #, c-format msgid "starting logical decoding for slot \"%s\"" msgstr "начинаетÑÑ Ð»Ð¾Ð³Ð¸Ñ‡ÐµÑкое декодирование Ð´Ð»Ñ Ñлота \"%s\"" -#: replication/logical/logical.c:392 +#: replication/logical/logical.c:404 #, c-format msgid "streaming transactions committing after %X/%X, reading WAL from %X/%X" msgstr "передача транзакций, фикÑируемых поÑле %X/%X, чтение WAL Ñ %X/%X" -#: replication/logical/logical.c:527 +#: replication/logical/logical.c:539 #, c-format msgid "" "slot \"%s\", output plugin \"%s\", in the %s callback, associated LSN %X/%X" msgstr "" "Ñлот \"%s\", модуль вывода \"%s\", в обработчике %s, ÑвÑзанный LSN: %X/%X" -#: replication/logical/logical.c:534 +#: replication/logical/logical.c:546 #, c-format msgid "slot \"%s\", output plugin \"%s\", in the %s callback" msgstr "Ñлот \"%s\", модуль вывода \"%s\", в обработчике %s" @@ -16711,37 +16460,37 @@ msgstr "" "удалить иÑточник репликации Ñ OID %d нельзÑ, он иÑпользуетÑÑ Ð¿Ñ€Ð¾Ñ†ÐµÑÑом Ñ PID " "%d" -#: replication/logical/origin.c:671 +#: replication/logical/origin.c:674 #, c-format msgid "replication checkpoint has wrong magic %u instead of %u" msgstr "" "ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ° репликации имеет неправильную Ñигнатуру (%u вмеÑто %u)" -#: replication/logical/origin.c:703 +#: replication/logical/origin.c:706 #, c-format msgid "could not read file \"%s\": read %d of %zu" msgstr "не удалоÑÑŒ прочитать файл \"%s\" (прочитано байт: %d из %zu)" -#: replication/logical/origin.c:712 +#: replication/logical/origin.c:715 #, c-format msgid "could not find free replication state, increase max_replication_slots" msgstr "" "не удалоÑÑŒ найти Ñвободную Ñчейку Ð´Ð»Ñ ÑоÑтоÑÐ½Ð¸Ñ Ñ€ÐµÐ¿Ð»Ð¸ÐºÐ°Ñ†Ð¸Ð¸, увеличьте " "max_replication_slots" -#: replication/logical/origin.c:730 +#: replication/logical/origin.c:733 #, c-format msgid "replication slot checkpoint has wrong checksum %u, expected %u" msgstr "" "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñумма файла контрольной точки Ð´Ð»Ñ Ñлота репликации (%u " "вмеÑто %u)" -#: replication/logical/origin.c:854 +#: replication/logical/origin.c:857 #, c-format msgid "replication origin with OID %d is already active for PID %d" msgstr "иÑточник репликации Ñ OID %d уже занÑÑ‚ процеÑÑом Ñ PID %d" -#: replication/logical/origin.c:865 replication/logical/origin.c:1045 +#: replication/logical/origin.c:868 replication/logical/origin.c:1048 #, c-format msgid "" "could not find free replication state slot for replication origin with OID %u" @@ -16749,41 +16498,41 @@ msgstr "" "не удалоÑÑŒ найти Ñвободный Ñлот ÑоÑтоÑÐ½Ð¸Ñ Ñ€ÐµÐ¿Ð»Ð¸ÐºÐ°Ñ†Ð¸Ð¸ Ð´Ð»Ñ Ð¸Ñточника " "репликации Ñ OID %u" -#: replication/logical/origin.c:867 replication/logical/origin.c:1047 -#: replication/slot.c:1299 +#: replication/logical/origin.c:870 replication/logical/origin.c:1050 +#: replication/slot.c:1316 #, c-format msgid "Increase max_replication_slots and try again." msgstr "Увеличьте параметр max_replication_slots и повторите попытку." -#: replication/logical/origin.c:1004 +#: replication/logical/origin.c:1007 #, c-format msgid "cannot setup replication origin when one is already setup" msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ Ð½Ð°Ñтроить иÑточник репликации, когда он уже наÑтроен" -#: replication/logical/origin.c:1033 +#: replication/logical/origin.c:1036 #, c-format msgid "replication identifier %d is already active for PID %d" msgstr "идентификатор репликации %d уже занÑÑ‚ процеÑÑом Ñ PID %d" -#: replication/logical/origin.c:1079 replication/logical/origin.c:1274 -#: replication/logical/origin.c:1294 +#: replication/logical/origin.c:1082 replication/logical/origin.c:1277 +#: replication/logical/origin.c:1297 #, c-format msgid "no replication origin is configured" msgstr "ни один иÑточник репликации не наÑтроен" -#: replication/logical/reorderbuffer.c:2330 +#: replication/logical/reorderbuffer.c:2331 #, c-format msgid "could not write to data file for XID %u: %m" msgstr "не удалоÑÑŒ запиÑать в файл данных Ð´Ð»Ñ XID %u: %m" -#: replication/logical/reorderbuffer.c:2426 -#: replication/logical/reorderbuffer.c:2446 +#: replication/logical/reorderbuffer.c:2427 +#: replication/logical/reorderbuffer.c:2447 #, c-format msgid "could not read from reorderbuffer spill file: %m" msgstr "не удалоÑÑŒ прочитать из файла подкачки буфера переÑортировки: %m" -#: replication/logical/reorderbuffer.c:2430 -#: replication/logical/reorderbuffer.c:2450 +#: replication/logical/reorderbuffer.c:2431 +#: replication/logical/reorderbuffer.c:2451 #, c-format msgid "" "could not read from reorderbuffer spill file: read %d instead of %u bytes" @@ -16791,14 +16540,14 @@ msgstr "" "не удалоÑÑŒ прочитать из файла подкачки буфера переÑортировки (прочитано " "байт: %d, требовалоÑÑŒ: %u)" -#: replication/logical/reorderbuffer.c:3106 +#: replication/logical/reorderbuffer.c:3107 #, c-format msgid "could not read from file \"%s\": read %d instead of %d bytes" msgstr "" "не удалоÑÑŒ прочитать из файла \"%s\" (прочитано байт: %d, требовалоÑÑŒ: %d)" # skip-rule: capital-letter-first -#: replication/logical/snapbuild.c:598 +#: replication/logical/snapbuild.c:646 #, c-format msgid "exported logical decoding snapshot: \"%s\" with %u transaction ID" msgid_plural "" @@ -16810,38 +16559,41 @@ msgstr[1] "" msgstr[2] "" "ÑкÑпортирован Ñнимок логичеÑкого декодированиÑ: \"%s\" (ид. транзакций: %u)" -#: replication/logical/snapbuild.c:917 replication/logical/snapbuild.c:1282 -#: replication/logical/snapbuild.c:1813 +#: replication/logical/snapbuild.c:1243 replication/logical/snapbuild.c:1333 +#: replication/logical/snapbuild.c:1808 #, c-format msgid "logical decoding found consistent point at %X/%X" msgstr "процеÑÑ Ð»Ð¾Ð³Ð¸Ñ‡ÐµÑкого Ð´ÐµÐºÐ¾Ð´Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ð´Ð¾Ñтиг точки ÑоглаÑованноÑти в %X/%X" -#: replication/logical/snapbuild.c:919 -#, c-format -msgid "Transaction ID %u finished; no more running transactions." -msgstr "Ð¢Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñ %u завершена, больше активных транзакций нет." - -#: replication/logical/snapbuild.c:1284 +#: replication/logical/snapbuild.c:1245 #, c-format msgid "There are no running transactions." msgstr "Больше активных транзакций нет." -#: replication/logical/snapbuild.c:1346 +#: replication/logical/snapbuild.c:1286 #, c-format msgid "logical decoding found initial starting point at %X/%X" msgstr "" "процеÑÑ Ð»Ð¾Ð³Ð¸Ñ‡ÐµÑкого Ð´ÐµÐºÐ¾Ð´Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ Ð½Ð°ÑˆÑ‘Ð» начальную Ñтартовую точку в %X/%X" -#: replication/logical/snapbuild.c:1348 +#: replication/logical/snapbuild.c:1288 replication/logical/snapbuild.c:1311 #, c-format -msgid "%u transaction needs to finish." -msgid_plural "%u transactions need to finish." -msgstr[0] "Ðеобходимо дождатьÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¹ (%u)." -msgstr[1] "Ðеобходимо дождатьÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¹ (%u)." -msgstr[2] "Ðеобходимо дождатьÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¹ (%u)." +msgid "Waiting for transactions (approximately %d) older than %u to end." +msgstr "Ожидание транзакций (примерно %d), Ñтарее %u до конца." + +#: replication/logical/snapbuild.c:1309 +#, c-format +msgid "logical decoding found initial consistent point at %X/%X" +msgstr "" +"при логичеÑком декодировании найдена Ð½Ð°Ñ‡Ð°Ð»ÑŒÐ½Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ° ÑоглаÑованноÑти в %X/%X" + +#: replication/logical/snapbuild.c:1335 +#, c-format +msgid "There are no old transactions anymore." +msgstr "Больше Ñтарых транзакций нет." #: replication/logical/snapbuild.c:1687 replication/logical/snapbuild.c:1713 -#: replication/logical/snapbuild.c:1727 replication/logical/snapbuild.c:1741 +#: replication/logical/snapbuild.c:1728 replication/logical/snapbuild.c:1742 #, c-format msgid "could not read file \"%s\", read %d of %d: %m" msgstr "не удалоÑÑŒ прочитать файл \"%s\" (прочитано байт: %d из %d): %m" @@ -16858,18 +16610,18 @@ msgid "snapbuild state file \"%s\" has unsupported version: %u instead of %u" msgstr "" "файл ÑоÑтоÑÐ½Ð¸Ñ snapbuild \"%s\" имеет неправильную верÑию (%u вмеÑто %u)" -#: replication/logical/snapbuild.c:1754 +#: replication/logical/snapbuild.c:1755 #, c-format msgid "checksum mismatch for snapbuild state file \"%s\": is %u, should be %u" msgstr "" "в файле ÑоÑтоÑÐ½Ð¸Ñ snapbuild \"%s\" Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñумма (%u вмеÑто %u)" -#: replication/logical/snapbuild.c:1815 +#: replication/logical/snapbuild.c:1810 #, c-format msgid "Logical decoding will begin using saved snapshot." msgstr "ЛогичеÑкое декодирование начнётÑÑ Ñ Ñохранённого Ñнимка." -#: replication/logical/snapbuild.c:1888 +#: replication/logical/snapbuild.c:1881 #, c-format msgid "could not parse file name \"%s\"" msgstr "не удалоÑÑŒ разобрать Ð¸Ð¼Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\"" @@ -16923,50 +16675,50 @@ msgstr "Ñлот репликации \"%s\" не ÑущеÑтвует" msgid "replication slot \"%s\" is active for PID %d" msgstr "Ñлот репликации \"%s\" занÑÑ‚ процеÑÑом Ñ PID %d" -#: replication/slot.c:511 replication/slot.c:923 replication/slot.c:1260 +#: replication/slot.c:527 replication/slot.c:940 replication/slot.c:1277 #, c-format msgid "could not remove directory \"%s\"" msgstr "ошибка при удалении каталога \"%s\"" -#: replication/slot.c:772 +#: replication/slot.c:789 #, c-format msgid "replication slots can only be used if max_replication_slots > 0" msgstr "" "Ñлоты репликации можно иÑпользовать, только еÑли max_replication_slots > 0" -#: replication/slot.c:777 +#: replication/slot.c:794 #, c-format msgid "replication slots can only be used if wal_level >= replica" msgstr "Ñлоты репликации можно иÑпользовать, только еÑли wal_level >= replica" -#: replication/slot.c:1192 replication/slot.c:1230 +#: replication/slot.c:1209 replication/slot.c:1247 #, c-format msgid "could not read file \"%s\", read %d of %u: %m" msgstr "не удалоÑÑŒ прочитать файл \"%s\" (прочитано байт: %d из %u): %m" -#: replication/slot.c:1201 +#: replication/slot.c:1218 #, c-format msgid "replication slot file \"%s\" has wrong magic number: %u instead of %u" msgstr "" "файл Ñлота репликации \"%s\" имеет неправильную Ñигнатуру (%u вмеÑто %u)" -#: replication/slot.c:1208 +#: replication/slot.c:1225 #, c-format msgid "replication slot file \"%s\" has unsupported version %u" msgstr "файл ÑоÑтоÑÐ½Ð¸Ñ snapbuild \"%s\" имеет неподдерживаемую верÑию %u" -#: replication/slot.c:1215 +#: replication/slot.c:1232 #, c-format msgid "replication slot file \"%s\" has corrupted length %u" msgstr "у файла Ñлота репликации \"%s\" Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð´Ð»Ð¸Ð½Ð°: %u" -#: replication/slot.c:1245 +#: replication/slot.c:1262 #, c-format msgid "checksum mismatch for replication slot file \"%s\": is %u, should be %u" msgstr "" "в файле Ñлота репликации \"%s\" Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñумма (%u вмеÑто %u)" -#: replication/slot.c:1298 +#: replication/slot.c:1315 #, c-format msgid "too many replication slots active before shutdown" msgstr "перед завершением активно Ñлишком много Ñлотов репликации" @@ -16994,23 +16746,23 @@ msgstr "" msgid "canceling wait for synchronous replication due to user request" msgstr "отмена Ð¾Ð¶Ð¸Ð´Ð°Ð½Ð¸Ñ Ñинхронной репликации по запроÑу пользователÑ" -#: replication/syncrep.c:368 +#: replication/syncrep.c:371 #, c-format msgid "standby \"%s\" now has synchronous standby priority %u" msgstr "" "резервный Ñервер \"%s\" теперь имеет приоритет Ñинхронной репликации %u" -#: replication/syncrep.c:428 +#: replication/syncrep.c:431 #, c-format msgid "standby \"%s\" is now a synchronous standby with priority %u" msgstr "резервный Ñервер \"%s\" Ñтал Ñинхронным Ñ Ð¿Ñ€Ð¸Ð¾Ñ€Ð¸Ñ‚ÐµÑ‚Ð¾Ð¼ %u" -#: replication/syncrep.c:921 +#: replication/syncrep.c:931 #, c-format msgid "synchronous_standby_names parser failed" msgstr "ошибка при разборе synchronous_standby_names" -#: replication/syncrep.c:927 +#: replication/syncrep.c:937 #, c-format msgid "number of synchronous standbys (%d) must be greater than zero" msgstr "чиÑло Ñинхронных резервных Ñерверов (%d) должно быть больше нулÑ" @@ -17080,30 +16832,30 @@ msgstr "загрузка файла иÑтории Ð´Ð»Ñ Ð»Ð¸Ð½Ð¸Ð¸ време msgid "could not write to log segment %s at offset %u, length %lu: %m" msgstr "не удалоÑÑŒ запиÑать в Ñегмент журнала %s (Ñмещение %u, длина %lu): %m" -#: replication/walsender.c:485 +#: replication/walsender.c:490 #, c-format msgid "could not seek to beginning of file \"%s\": %m" msgstr "не удалоÑÑŒ перейти к началу файла \"%s\": %m" -#: replication/walsender.c:536 +#: replication/walsender.c:541 #, c-format msgid "cannot use a logical replication slot for physical replication" msgstr "" "логичеÑкий Ñлот репликации Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ð´Ð»Ñ Ñ„Ð¸Ð·Ð¸Ñ‡ÐµÑкой репликации" -#: replication/walsender.c:599 +#: replication/walsender.c:604 #, c-format msgid "" "requested starting point %X/%X on timeline %u is not in this server's history" msgstr "" "в иÑтории Ñервера нет запрошенной начальной точки %X/%X на линии времени %u" -#: replication/walsender.c:603 +#: replication/walsender.c:608 #, c-format msgid "This server's history forked from timeline %u at %X/%X." msgstr "ИÑÑ‚Ð¾Ñ€Ð¸Ñ Ñтого Ñервера ответвилаÑÑŒ от линии времени %u в %X/%X." -#: replication/walsender.c:648 +#: replication/walsender.c:653 #, c-format msgid "" "requested starting point %X/%X is ahead of the WAL flush position of this " @@ -17112,48 +16864,55 @@ msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾ÑˆÐµÐ½Ð½Ð°Ñ Ð½Ð°Ñ‡Ð°Ð»ÑŒÐ½Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ° %X/%X впереди позиции Ñброшенных данных журнала " "на Ñтом Ñервере (%X/%X)" -#: replication/walsender.c:974 +#: replication/walsender.c:977 #, c-format msgid "terminating walsender process after promotion" msgstr "завершение процеÑÑа передачи журнала поÑле повышениÑ" -#: replication/walsender.c:1300 +#: replication/walsender.c:1333 +#, c-format +msgid "cannot execute new commands while WAL sender is in stopping mode" +msgstr "" +"Ð½ÐµÐ»ÑŒÐ·Ñ Ð²Ñ‹Ð¿Ð¾Ð»Ð½ÑÑ‚ÑŒ новые команды, пока процеÑÑ Ð¿ÐµÑ€ÐµÐ´Ð°Ñ‡Ð¸ WAL находитÑÑ Ð² режиме " +"оÑтановки" + +#: replication/walsender.c:1341 #, c-format msgid "received replication command: %s" msgstr "получена команда репликации: %s" -#: replication/walsender.c:1391 replication/walsender.c:1407 +#: replication/walsender.c:1440 replication/walsender.c:1456 #, c-format msgid "unexpected EOF on standby connection" msgstr "неожиданный обрыв ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ñ Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ñ‹Ð¼ Ñервером" -#: replication/walsender.c:1421 +#: replication/walsender.c:1470 #, c-format msgid "unexpected standby message type \"%c\", after receiving CopyDone" msgstr "" "поÑле CopyDone резервный Ñервер передал Ñообщение неожиданного типа \"%c\"" -#: replication/walsender.c:1459 +#: replication/walsender.c:1508 #, c-format msgid "invalid standby message type \"%c\"" msgstr "неверный тип ÑÐ¾Ð¾Ð±Ñ‰ÐµÐ½Ð¸Ñ Ñ€ÐµÐ·ÐµÑ€Ð²Ð½Ð¾Ð³Ð¾ Ñервера: \"%c\"" -#: replication/walsender.c:1500 +#: replication/walsender.c:1549 #, c-format msgid "unexpected message type \"%c\"" msgstr "неожиданный тип ÑÐ¾Ð¾Ð±Ñ‰ÐµÐ½Ð¸Ñ \"%c\"" -#: replication/walsender.c:1784 +#: replication/walsender.c:1833 #, c-format msgid "terminating walsender process due to replication timeout" msgstr "завершение процеÑÑа передачи журнала из-за таймаута репликации" -#: replication/walsender.c:1877 +#: replication/walsender.c:1919 #, c-format msgid "standby \"%s\" has now caught up with primary" msgstr "резервный Ñервер \"%s\" нагнал главный" -#: replication/walsender.c:1980 +#: replication/walsender.c:2022 #, c-format msgid "" "number of requested standby connections exceeds max_wal_senders (currently " @@ -17399,87 +17158,87 @@ msgstr "" msgid "cannot have RETURNING lists in multiple rules" msgstr "RETURNING можно определить только Ð´Ð»Ñ Ð¾Ð´Ð½Ð¾Ð³Ð¾ правила" -#: rewrite/rewriteHandler.c:928 rewrite/rewriteHandler.c:946 +#: rewrite/rewriteHandler.c:949 rewrite/rewriteHandler.c:967 #, c-format msgid "multiple assignments to same column \"%s\"" msgstr "многочиÑленные приÑÐ²Ð¾ÐµÐ½Ð¸Ñ Ð¾Ð´Ð½Ð¾Ð¼Ñƒ Ñтолбцу \"%s\"" -#: rewrite/rewriteHandler.c:1721 rewrite/rewriteHandler.c:3331 +#: rewrite/rewriteHandler.c:1752 rewrite/rewriteHandler.c:3362 #, c-format msgid "infinite recursion detected in rules for relation \"%s\"" msgstr "обнаружена беÑÐºÐ¾Ð½ÐµÑ‡Ð½Ð°Ñ Ñ€ÐµÐºÑƒÑ€ÑÐ¸Ñ Ð² правилах Ð´Ð»Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\"" -#: rewrite/rewriteHandler.c:1806 +#: rewrite/rewriteHandler.c:1837 #, c-format msgid "infinite recursion detected in policy for relation \"%s\"" msgstr "обнаружена беÑÐºÐ¾Ð½ÐµÑ‡Ð½Ð°Ñ Ñ€ÐµÐºÑƒÑ€ÑÐ¸Ñ Ð² политике Ð´Ð»Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\"" -#: rewrite/rewriteHandler.c:2123 +#: rewrite/rewriteHandler.c:2154 msgid "Junk view columns are not updatable." msgstr "Утилизируемые Ñтолбцы предÑтавлений не обновлÑÑŽÑ‚ÑÑ." -#: rewrite/rewriteHandler.c:2128 +#: rewrite/rewriteHandler.c:2159 msgid "" "View columns that are not columns of their base relation are not updatable." msgstr "" "Столбцы предÑтавлений, не ÑвлÑющиеÑÑ Ñтолбцами базовых отношений, не " "обновлÑÑŽÑ‚ÑÑ." -#: rewrite/rewriteHandler.c:2131 +#: rewrite/rewriteHandler.c:2162 msgid "View columns that refer to system columns are not updatable." msgstr "" "Столбцы предÑтавлений, ÑÑылающиеÑÑ Ð½Ð° ÑиÑтемные Ñтолбцы, не обновлÑÑŽÑ‚ÑÑ." -#: rewrite/rewriteHandler.c:2134 +#: rewrite/rewriteHandler.c:2165 msgid "View columns that return whole-row references are not updatable." msgstr "" "Столбцы предÑтавлений, возвращающие ÑÑылки на вÑÑŽ Ñтроку, не обновлÑÑŽÑ‚ÑÑ." -#: rewrite/rewriteHandler.c:2192 +#: rewrite/rewriteHandler.c:2223 msgid "Views containing DISTINCT are not automatically updatable." msgstr "ПредÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ DISTINCT не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2195 +#: rewrite/rewriteHandler.c:2226 msgid "Views containing GROUP BY are not automatically updatable." msgstr "ПредÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ GROUP BY не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2198 +#: rewrite/rewriteHandler.c:2229 msgid "Views containing HAVING are not automatically updatable." msgstr "ПредÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ HAVING не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2201 +#: rewrite/rewriteHandler.c:2232 msgid "" "Views containing UNION, INTERSECT, or EXCEPT are not automatically updatable." msgstr "" "ПредÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ UNION, INTERSECT или EXCEPT не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2204 +#: rewrite/rewriteHandler.c:2235 msgid "Views containing WITH are not automatically updatable." msgstr "ПредÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ WITH не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2207 +#: rewrite/rewriteHandler.c:2238 msgid "Views containing LIMIT or OFFSET are not automatically updatable." msgstr "ПредÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ LIMIT или OFFSET не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2219 +#: rewrite/rewriteHandler.c:2250 msgid "Views that return aggregate functions are not automatically updatable." msgstr "" "ПредÑтавлениÑ, возвращающие агрегатные функции, не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2222 +#: rewrite/rewriteHandler.c:2253 msgid "Views that return window functions are not automatically updatable." msgstr "" "ПредÑтавлениÑ, возвращающие оконные функции, не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2225 +#: rewrite/rewriteHandler.c:2256 msgid "" "Views that return set-returning functions are not automatically updatable." msgstr "" "ПредÑтавлениÑ, возвращающие функции Ñ Ñ€ÐµÐ·ÑƒÐ»ÑŒÑ‚Ð°Ñ‚Ð¾Ð¼-множеÑтвом, не обновлÑÑŽÑ‚ÑÑ " "автоматичеÑки." -#: rewrite/rewriteHandler.c:2232 rewrite/rewriteHandler.c:2236 -#: rewrite/rewriteHandler.c:2243 +#: rewrite/rewriteHandler.c:2263 rewrite/rewriteHandler.c:2267 +#: rewrite/rewriteHandler.c:2274 msgid "" "Views that do not select from a single table or view are not automatically " "updatable." @@ -17487,27 +17246,27 @@ msgstr "" "ПредÑтавлениÑ, выбирающие данные не из одной таблицы или предÑтавлениÑ, не " "обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2246 +#: rewrite/rewriteHandler.c:2277 msgid "Views containing TABLESAMPLE are not automatically updatable." msgstr "ПредÑтавлениÑ, Ñодержащие TABLESAMPLE, не обновлÑÑŽÑ‚ÑÑ Ð°Ð²Ñ‚Ð¾Ð¼Ð°Ñ‚Ð¸Ñ‡ÐµÑки." -#: rewrite/rewriteHandler.c:2270 +#: rewrite/rewriteHandler.c:2301 msgid "Views that have no updatable columns are not automatically updatable." msgstr "" "ПредÑтавлениÑ, не Ñодержащие обновлÑемых Ñтолбцов, не обновлÑÑŽÑ‚ÑÑ " "автоматичеÑки." -#: rewrite/rewriteHandler.c:2724 +#: rewrite/rewriteHandler.c:2755 #, c-format msgid "cannot insert into column \"%s\" of view \"%s\"" msgstr "вÑтавить данные в Ñтолбец \"%s\" предÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: rewrite/rewriteHandler.c:2732 +#: rewrite/rewriteHandler.c:2763 #, c-format msgid "cannot update column \"%s\" of view \"%s\"" msgstr "изменить данные в Ñтолбце \"%s\" предÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: rewrite/rewriteHandler.c:3130 +#: rewrite/rewriteHandler.c:3161 #, c-format msgid "" "DO INSTEAD NOTHING rules are not supported for data-modifying statements in " @@ -17516,7 +17275,7 @@ msgstr "" "правила DO INSTEAD NOTHING не поддерживаютÑÑ Ð² операторах, изменÑющих " "данные, в WITH" -#: rewrite/rewriteHandler.c:3144 +#: rewrite/rewriteHandler.c:3175 #, c-format msgid "" "conditional DO INSTEAD rules are not supported for data-modifying statements " @@ -17525,13 +17284,13 @@ msgstr "" "уÑловные правила DO INSTEAD не поддерживаютÑÑ Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð², изменÑющих " "данные, в WITH" -#: rewrite/rewriteHandler.c:3148 +#: rewrite/rewriteHandler.c:3179 #, c-format msgid "DO ALSO rules are not supported for data-modifying statements in WITH" msgstr "" "правила DO ALSO не поддерживаютÑÑ Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð², изменÑющих данные, в WITH" -#: rewrite/rewriteHandler.c:3153 +#: rewrite/rewriteHandler.c:3184 #, c-format msgid "" "multi-statement DO INSTEAD rules are not supported for data-modifying " @@ -17540,43 +17299,43 @@ msgstr "" "ÑоÑтавные правила DO INSTEAD не поддерживаютÑÑ Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð², изменÑющих " "данные, в WITH" -#: rewrite/rewriteHandler.c:3368 +#: rewrite/rewriteHandler.c:3399 #, c-format msgid "cannot perform INSERT RETURNING on relation \"%s\"" msgstr "выполнить INSERT RETURNING Ð´Ð»Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: rewrite/rewriteHandler.c:3370 +#: rewrite/rewriteHandler.c:3401 #, c-format msgid "" "You need an unconditional ON INSERT DO INSTEAD rule with a RETURNING clause." msgstr "" "Ðеобходимо безуÑловное правило ON INSERT DO INSTEAD Ñ Ð¿Ñ€ÐµÐ´Ð»Ð¾Ð¶ÐµÐ½Ð¸ÐµÐ¼ RETURNING." -#: rewrite/rewriteHandler.c:3375 +#: rewrite/rewriteHandler.c:3406 #, c-format msgid "cannot perform UPDATE RETURNING on relation \"%s\"" msgstr "выполнить UPDATE RETURNING Ð´Ð»Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: rewrite/rewriteHandler.c:3377 +#: rewrite/rewriteHandler.c:3408 #, c-format msgid "" "You need an unconditional ON UPDATE DO INSTEAD rule with a RETURNING clause." msgstr "" "Ðеобходимо безуÑловное правило ON UPDATE DO INSTEAD Ñ Ð¿Ñ€ÐµÐ´Ð»Ð¾Ð¶ÐµÐ½Ð¸ÐµÐ¼ RETURNING." -#: rewrite/rewriteHandler.c:3382 +#: rewrite/rewriteHandler.c:3413 #, c-format msgid "cannot perform DELETE RETURNING on relation \"%s\"" msgstr "выполнить DELETE RETURNING Ð´Ð»Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ \"%s\" нельзÑ" -#: rewrite/rewriteHandler.c:3384 +#: rewrite/rewriteHandler.c:3415 #, c-format msgid "" "You need an unconditional ON DELETE DO INSTEAD rule with a RETURNING clause." msgstr "" "Ðеобходимо безуÑловное правило ON DELETE DO INSTEAD Ñ Ð¿Ñ€ÐµÐ´Ð»Ð¾Ð¶ÐµÐ½Ð¸ÐµÐ¼ RETURNING." -#: rewrite/rewriteHandler.c:3402 +#: rewrite/rewriteHandler.c:3433 #, c-format msgid "" "INSERT with ON CONFLICT clause cannot be used with table that has INSERT or " @@ -17585,7 +17344,7 @@ msgstr "" "INSERT c предложением ON CONFLICT Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†ÐµÐ¹, Ð´Ð»Ñ " "которой заданы правила INSERT или UPDATE" -#: rewrite/rewriteHandler.c:3459 +#: rewrite/rewriteHandler.c:3490 #, c-format msgid "" "WITH cannot be used in a query that is rewritten by rules into multiple " @@ -17678,22 +17437,22 @@ msgstr "" msgid "invalid page in block %u of relation %s; zeroing out page" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ñтраница в блоке %u Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ %s; Ñтраница обнулÑетÑÑ" -#: storage/buffer/bufmgr.c:3952 +#: storage/buffer/bufmgr.c:3969 #, c-format msgid "could not write block %u of %s" msgstr "не удалоÑÑŒ запиÑÑŒ блок %u файла %s" -#: storage/buffer/bufmgr.c:3954 +#: storage/buffer/bufmgr.c:3971 #, c-format msgid "Multiple failures --- write error might be permanent." msgstr "МножеÑтвенные Ñбои - возможно, поÑтоÑÐ½Ð½Ð°Ñ Ð¾ÑˆÐ¸Ð±ÐºÐ° запиÑи." -#: storage/buffer/bufmgr.c:3975 storage/buffer/bufmgr.c:3994 +#: storage/buffer/bufmgr.c:3992 storage/buffer/bufmgr.c:4011 #, c-format msgid "writing block %u of relation %s" msgstr "запиÑÑŒ блока %u Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ %s" -#: storage/buffer/bufmgr.c:4295 +#: storage/buffer/bufmgr.c:4312 #, c-format msgid "snapshot too old" msgstr "Ñнимок Ñлишком Ñтар" @@ -17708,75 +17467,75 @@ msgstr "нет пуÑтого локального буфера" msgid "cannot access temporary tables during a parallel operation" msgstr "обращатьÑÑ Ðº временным таблицам во Ð²Ñ€ÐµÐ¼Ñ Ð¿Ð°Ñ€Ð°Ð»Ð»ÐµÐ»ÑŒÐ½Ñ‹Ñ… операций нельзÑ" -#: storage/file/fd.c:436 storage/file/fd.c:508 storage/file/fd.c:544 +#: storage/file/fd.c:443 storage/file/fd.c:515 storage/file/fd.c:551 #, c-format msgid "could not flush dirty data: %m" msgstr "не удалоÑÑŒ ÑброÑить грÑзные данные: %m" -#: storage/file/fd.c:466 +#: storage/file/fd.c:473 #, c-format msgid "could not determine dirty data size: %m" msgstr "не удалоÑÑŒ определить размер грÑзных данных: %m" -#: storage/file/fd.c:518 +#: storage/file/fd.c:525 #, c-format msgid "could not munmap() while flushing data: %m" msgstr "ошибка в munmap() при ÑброÑе данных на диÑк: %m" -#: storage/file/fd.c:682 +#: storage/file/fd.c:689 #, c-format msgid "could not link file \"%s\" to \"%s\": %m" msgstr "Ð´Ð»Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\" не удалоÑÑŒ Ñоздать ÑÑылку \"%s\": %m" -#: storage/file/fd.c:776 +#: storage/file/fd.c:783 #, c-format msgid "getrlimit failed: %m" msgstr "ошибка в getrlimit(): %m" -#: storage/file/fd.c:866 +#: storage/file/fd.c:873 #, c-format msgid "insufficient file descriptors available to start server process" msgstr "недоÑтаточно деÑкрипторов файлов Ð´Ð»Ñ Ð·Ð°Ð¿ÑƒÑка Ñерверного процеÑÑа" -#: storage/file/fd.c:867 +#: storage/file/fd.c:874 #, c-format msgid "System allows %d, we need at least %d." msgstr "СиÑтема выделÑет: %d, а требуетÑÑ Ð¼Ð¸Ð½Ð¸Ð¼ÑƒÐ¼: %d." -#: storage/file/fd.c:908 storage/file/fd.c:2001 storage/file/fd.c:2094 -#: storage/file/fd.c:2242 +#: storage/file/fd.c:915 storage/file/fd.c:2078 storage/file/fd.c:2171 +#: storage/file/fd.c:2319 #, c-format msgid "out of file descriptors: %m; release and retry" msgstr "нехватка деÑкрипторов файлов: %m; оÑвободите их и повторите попытку" -#: storage/file/fd.c:1482 +#: storage/file/fd.c:1520 #, c-format msgid "temporary file: path \"%s\", size %lu" msgstr "временный файл: путь \"%s\", размер %lu" -#: storage/file/fd.c:1656 +#: storage/file/fd.c:1717 #, c-format msgid "temporary file size exceeds temp_file_limit (%dkB)" msgstr "размер временного файла превышает предел temp_file_limit (%d КБ)" -#: storage/file/fd.c:1977 storage/file/fd.c:2027 +#: storage/file/fd.c:2054 storage/file/fd.c:2104 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to open file \"%s\"" msgstr "превышен предел maxAllocatedDescs (%d) при попытке открыть файл \"%s\"" -#: storage/file/fd.c:2067 +#: storage/file/fd.c:2144 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to execute command \"%s\"" msgstr "" "превышен предел maxAllocatedDescs (%d) при попытке выполнить команду \"%s\"" -#: storage/file/fd.c:2218 +#: storage/file/fd.c:2295 #, c-format msgid "exceeded maxAllocatedDescs (%d) while trying to open directory \"%s\"" msgstr "" "превышен предел maxAllocatedDescs (%d) при попытке открыть каталог \"%s\"" -#: storage/file/fd.c:2304 +#: storage/file/fd.c:2381 #, c-format msgid "could not read directory \"%s\": %m" msgstr "не удалоÑÑŒ прочитать каталог \"%s\": %m" @@ -17860,17 +17619,17 @@ msgstr "не удалоÑÑŒ Ñоздать Ñегмент разделÑемой msgid "could not duplicate handle for \"%s\": %m" msgstr "не удалоÑÑŒ продублировать указатель Ð´Ð»Ñ \"%s\": %m" -#: storage/ipc/latch.c:778 +#: storage/ipc/latch.c:841 #, c-format msgid "epoll_ctl() failed: %m" msgstr "ошибка в epoll_ctl(): %m" -#: storage/ipc/latch.c:1002 +#: storage/ipc/latch.c:1065 #, c-format msgid "epoll_wait() failed: %m" msgstr "ошибка в epoll_wait(): %m" -#: storage/ipc/latch.c:1122 +#: storage/ipc/latch.c:1185 #, c-format msgid "poll() failed: %m" msgstr "ошибка в poll(): %m" @@ -17878,9 +17637,9 @@ msgstr "ошибка в poll(): %m" #: storage/ipc/shm_toc.c:108 storage/ipc/shm_toc.c:189 storage/ipc/shmem.c:212 #: storage/lmgr/lock.c:883 storage/lmgr/lock.c:917 storage/lmgr/lock.c:2682 #: storage/lmgr/lock.c:4007 storage/lmgr/lock.c:4072 storage/lmgr/lock.c:4364 -#: storage/lmgr/predicate.c:2329 storage/lmgr/predicate.c:2344 -#: storage/lmgr/predicate.c:3736 storage/lmgr/predicate.c:4879 -#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1043 +#: storage/lmgr/predicate.c:2342 storage/lmgr/predicate.c:2357 +#: storage/lmgr/predicate.c:3749 storage/lmgr/predicate.c:4892 +#: storage/lmgr/proc.c:203 utils/hash/dynahash.c:1042 #, c-format msgid "out of shared memory" msgstr "нехватка разделÑемой памÑти" @@ -17912,13 +17671,13 @@ msgstr "" msgid "requested shared memory size overflows size_t" msgstr "запрошенный размер разделÑемой памÑти не умещаетÑÑ Ð² size_t" -#: storage/ipc/standby.c:530 tcop/postgres.c:2976 +#: storage/ipc/standby.c:530 tcop/postgres.c:2974 #, c-format msgid "canceling statement due to conflict with recovery" msgstr "" "выполнение оператора отменено из-за конфликта Ñ Ð¿Ñ€Ð¾Ñ†ÐµÑÑом воÑÑтановлениÑ" -#: storage/ipc/standby.c:531 tcop/postgres.c:2263 +#: storage/ipc/standby.c:531 tcop/postgres.c:2255 #, c-format msgid "User transaction caused buffer deadlock with recovery." msgstr "" @@ -18118,12 +17877,12 @@ msgstr "" "в пуле недоÑтаточно Ñлементов Ð´Ð»Ñ Ð·Ð°Ð¿Ð¸Ñи о потенциальном конфликте чтениÑ/" "запиÑи" -#: storage/lmgr/predicate.c:909 +#: storage/lmgr/predicate.c:910 #, c-format msgid "memory for serializable conflict tracking is nearly exhausted" msgstr "памÑÑ‚ÑŒ Ð´Ð»Ñ Ð¾Ñ‚ÑÐ»ÐµÐ¶Ð¸Ð²Ð°Ð½Ð¸Ñ ÐºÐ¾Ð½Ñ„Ð»Ð¸ÐºÑ‚Ð¾Ð² Ñериализации практичеÑки иÑчерпана" -#: storage/lmgr/predicate.c:910 +#: storage/lmgr/predicate.c:911 #, c-format msgid "" "There might be an idle transaction or a forgotten prepared transaction " @@ -18132,7 +17891,7 @@ msgstr "" "ВероÑтно, Ñта ÑÐ¸Ñ‚ÑƒÐ°Ñ†Ð¸Ñ Ð²Ñ‹Ð·Ð²Ð°Ð½Ð° забытой подготовленной транзакцией или " "транзакцией, проÑтаивающей долгое времÑ." -#: storage/lmgr/predicate.c:1190 storage/lmgr/predicate.c:1261 +#: storage/lmgr/predicate.c:1205 storage/lmgr/predicate.c:1277 #, c-format msgid "" "not enough shared memory for elements of data structure \"%s\" (%zu bytes " @@ -18141,18 +17900,18 @@ msgstr "" "недоÑтаточно разделÑемой памÑти Ð´Ð»Ñ Ñлементов Ñтруктуры данных \"%s" "\" (запрошено байт: %zu)" -#: storage/lmgr/predicate.c:1549 +#: storage/lmgr/predicate.c:1562 #, c-format msgid "deferrable snapshot was unsafe; trying a new one" msgstr "откладываемый Ñнимок был небезопаÑен; пробуем более новый" -#: storage/lmgr/predicate.c:1588 +#: storage/lmgr/predicate.c:1601 #, c-format msgid "\"default_transaction_isolation\" is set to \"serializable\"." msgstr "" "Параметр \"default_transaction_isolation\" имеет значение \"serializable\"." -#: storage/lmgr/predicate.c:1589 +#: storage/lmgr/predicate.c:1602 #, c-format msgid "" "You can use \"SET default_transaction_isolation = 'repeatable read'\" to " @@ -18161,34 +17920,34 @@ msgstr "" "Чтобы изменить режим по умолчанию, выполните \"SET " "default_transaction_isolation = 'repeatable read'\"." -#: storage/lmgr/predicate.c:1628 +#: storage/lmgr/predicate.c:1641 #, c-format msgid "a snapshot-importing transaction must not be READ ONLY DEFERRABLE" msgstr "транзакциÑ, Ð¸Ð¼Ð¿Ð¾Ñ€Ñ‚Ð¸Ñ€ÑƒÑŽÑ‰Ð°Ñ Ñнимок, не должна быть READ ONLY DEFERRABLE" -#: storage/lmgr/predicate.c:1706 utils/time/snapmgr.c:617 +#: storage/lmgr/predicate.c:1719 utils/time/snapmgr.c:617 #: utils/time/snapmgr.c:623 #, c-format msgid "could not import the requested snapshot" msgstr "не удалоÑÑŒ импортировать запрошенный Ñнимок" -#: storage/lmgr/predicate.c:1707 utils/time/snapmgr.c:624 +#: storage/lmgr/predicate.c:1720 utils/time/snapmgr.c:624 #, c-format msgid "The source transaction %u is not running anymore." msgstr "ИÑÑ…Ð¾Ð´Ð½Ð°Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñ %u уже не выполнÑетÑÑ." -#: storage/lmgr/predicate.c:2330 storage/lmgr/predicate.c:2345 -#: storage/lmgr/predicate.c:3737 +#: storage/lmgr/predicate.c:2343 storage/lmgr/predicate.c:2358 +#: storage/lmgr/predicate.c:3750 #, c-format msgid "You might need to increase max_pred_locks_per_transaction." msgstr "" "Возможно, Ñледует увеличить значение параметра max_locks_per_transaction." -#: storage/lmgr/predicate.c:3891 storage/lmgr/predicate.c:3980 -#: storage/lmgr/predicate.c:3988 storage/lmgr/predicate.c:4027 -#: storage/lmgr/predicate.c:4266 storage/lmgr/predicate.c:4603 -#: storage/lmgr/predicate.c:4615 storage/lmgr/predicate.c:4657 -#: storage/lmgr/predicate.c:4695 +#: storage/lmgr/predicate.c:3904 storage/lmgr/predicate.c:3993 +#: storage/lmgr/predicate.c:4001 storage/lmgr/predicate.c:4040 +#: storage/lmgr/predicate.c:4279 storage/lmgr/predicate.c:4616 +#: storage/lmgr/predicate.c:4628 storage/lmgr/predicate.c:4670 +#: storage/lmgr/predicate.c:4708 #, c-format msgid "" "could not serialize access due to read/write dependencies among transactions" @@ -18196,11 +17955,11 @@ msgstr "" "не удалоÑÑŒ Ñериализовать доÑтуп из-за завиÑимоÑтей чтениÑ/запиÑи между " "транзакциÑми" -#: storage/lmgr/predicate.c:3893 storage/lmgr/predicate.c:3982 -#: storage/lmgr/predicate.c:3990 storage/lmgr/predicate.c:4029 -#: storage/lmgr/predicate.c:4268 storage/lmgr/predicate.c:4605 -#: storage/lmgr/predicate.c:4617 storage/lmgr/predicate.c:4659 -#: storage/lmgr/predicate.c:4697 +#: storage/lmgr/predicate.c:3906 storage/lmgr/predicate.c:3995 +#: storage/lmgr/predicate.c:4003 storage/lmgr/predicate.c:4042 +#: storage/lmgr/predicate.c:4281 storage/lmgr/predicate.c:4618 +#: storage/lmgr/predicate.c:4630 storage/lmgr/predicate.c:4672 +#: storage/lmgr/predicate.c:4710 #, c-format msgid "The transaction might succeed if retried." msgstr "Ð¢Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñ Ð¼Ð¾Ð¶ÐµÑ‚ завершитьÑÑ ÑƒÑпешно при Ñледующей попытке." @@ -18280,12 +18039,12 @@ msgstr "иÑпорченный указатель Ñлемента: %u" msgid "corrupted item lengths: total %u, available space %u" msgstr "иÑпорченный размер Ñлемента (общий размер: %u, доÑтупно: %u)" -#: storage/page/bufpage.c:756 storage/page/bufpage.c:892 +#: storage/page/bufpage.c:756 #, c-format msgid "corrupted item pointer: offset = %u, size = %u" msgstr "иÑпорченный указатель Ñлемента: Ñмещение = %u, размер = %u" -#: storage/page/bufpage.c:997 +#: storage/page/bufpage.c:892 storage/page/bufpage.c:997 #, c-format msgid "corrupted item pointer: offset = %u, length = %u" msgstr "иÑпорченный указатель Ñлемента: Ñмещение = %u, длина = %u" @@ -18378,14 +18137,14 @@ msgstr "" msgid "could not open file \"%s\" (target block %u): %m" msgstr "не удалоÑÑŒ открыть файл file \"%s\" (целевой блок %u): %m" -#: tcop/fastpath.c:111 tcop/fastpath.c:475 tcop/fastpath.c:605 +#: tcop/fastpath.c:111 tcop/fastpath.c:463 tcop/fastpath.c:593 #, c-format msgid "invalid argument size %d in function call message" msgstr "неверный размер аргумента (%d) в Ñообщении вызова функции" -#: tcop/fastpath.c:291 tcop/postgres.c:992 tcop/postgres.c:1301 -#: tcop/postgres.c:1559 tcop/postgres.c:1964 tcop/postgres.c:2331 -#: tcop/postgres.c:2406 +#: tcop/fastpath.c:281 tcop/postgres.c:984 tcop/postgres.c:1293 +#: tcop/postgres.c:1551 tcop/postgres.c:1956 tcop/postgres.c:2323 +#: tcop/postgres.c:2398 #, c-format msgid "" "current transaction is aborted, commands ignored until end of transaction " @@ -18393,95 +18152,95 @@ msgid "" msgstr "" "Ñ‚ÐµÐºÑƒÑ‰Ð°Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñ Ð¿Ñ€ÐµÑ€Ð²Ð°Ð½Ð°, команды до конца блока транзакции игнорируютÑÑ" -#: tcop/fastpath.c:319 +#: tcop/fastpath.c:309 #, c-format msgid "fastpath function call: \"%s\" (OID %u)" msgstr "вызов функции fastpath: \"%s\" (OID %u)" -#: tcop/fastpath.c:401 tcop/postgres.c:1163 tcop/postgres.c:1426 -#: tcop/postgres.c:1805 tcop/postgres.c:2022 +#: tcop/fastpath.c:391 tcop/postgres.c:1155 tcop/postgres.c:1418 +#: tcop/postgres.c:1797 tcop/postgres.c:2014 #, c-format msgid "duration: %s ms" msgstr "продолжительноÑÑ‚ÑŒ: %s мÑ" -#: tcop/fastpath.c:405 +#: tcop/fastpath.c:395 #, c-format msgid "duration: %s ms fastpath function call: \"%s\" (OID %u)" msgstr "продолжительноÑÑ‚ÑŒ %s мÑ, вызов функции fastpath: \"%s\" (OID %u)" -#: tcop/fastpath.c:443 tcop/fastpath.c:570 +#: tcop/fastpath.c:431 tcop/fastpath.c:558 #, c-format msgid "function call message contains %d arguments but function requires %d" msgstr "" "Ñообщение вызова функции Ñодержит неверное чиÑло аргументов (%d, а требуетÑÑ " "%d)" -#: tcop/fastpath.c:451 +#: tcop/fastpath.c:439 #, c-format msgid "function call message contains %d argument formats but %d arguments" msgstr "" "Ñообщение вызова функции Ñодержит неверное чиÑло форматов (%d, а аргументов " "%d)" -#: tcop/fastpath.c:538 tcop/fastpath.c:621 +#: tcop/fastpath.c:526 tcop/fastpath.c:609 #, c-format msgid "incorrect binary data format in function argument %d" msgstr "неправильный формат двоичных данных в аргументе функции %d" -#: tcop/postgres.c:352 tcop/postgres.c:388 tcop/postgres.c:415 +#: tcop/postgres.c:344 tcop/postgres.c:380 tcop/postgres.c:407 #, c-format msgid "unexpected EOF on client connection" msgstr "неожиданный обрыв ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ñ ÐºÐ»Ð¸ÐµÐ½Ñ‚Ð¾Ð¼" -#: tcop/postgres.c:438 tcop/postgres.c:450 tcop/postgres.c:461 -#: tcop/postgres.c:473 tcop/postgres.c:4314 +#: tcop/postgres.c:430 tcop/postgres.c:442 tcop/postgres.c:453 +#: tcop/postgres.c:465 tcop/postgres.c:4300 #, c-format msgid "invalid frontend message type %d" msgstr "неправильный тип клиентÑкого ÑÐ¾Ð¾Ð±Ñ‰ÐµÐ½Ð¸Ñ %d" -#: tcop/postgres.c:933 +#: tcop/postgres.c:925 #, c-format msgid "statement: %s" msgstr "оператор: %s" -#: tcop/postgres.c:1168 +#: tcop/postgres.c:1160 #, c-format msgid "duration: %s ms statement: %s" msgstr "продолжительноÑÑ‚ÑŒ: %s мÑ, оператор: %s" -#: tcop/postgres.c:1218 +#: tcop/postgres.c:1210 #, c-format msgid "parse %s: %s" msgstr "разбор %s: %s" -#: tcop/postgres.c:1274 +#: tcop/postgres.c:1266 #, c-format msgid "cannot insert multiple commands into a prepared statement" msgstr "в подготовленный оператор Ð½ÐµÐ»ÑŒÐ·Ñ Ð²Ñтавить неÑколько команд" -#: tcop/postgres.c:1431 +#: tcop/postgres.c:1423 #, c-format msgid "duration: %s ms parse %s: %s" msgstr "продолжительноÑÑ‚ÑŒ: %s мÑ, разбор %s: %s" -#: tcop/postgres.c:1476 +#: tcop/postgres.c:1468 #, c-format msgid "bind %s to %s" msgstr "привÑзка %s к %s" # [SM]: TO REVIEW -#: tcop/postgres.c:1495 tcop/postgres.c:2312 +#: tcop/postgres.c:1487 tcop/postgres.c:2304 #, c-format msgid "unnamed prepared statement does not exist" msgstr "безымÑнный подготовленный оператор не ÑущеÑтвует" -#: tcop/postgres.c:1537 +#: tcop/postgres.c:1529 #, c-format msgid "bind message has %d parameter formats but %d parameters" msgstr "" "неверное чиÑло форматов параметров в Ñообщении Bind (%d, а параметров %d)" -#: tcop/postgres.c:1543 +#: tcop/postgres.c:1535 #, c-format msgid "" "bind message supplies %d parameters, but prepared statement \"%s\" requires " @@ -18490,88 +18249,88 @@ msgstr "" "в Ñообщении Bind передано неверное чиÑло параметров (%d, а подготовленный " "оператор \"%s\" требует %d)" -#: tcop/postgres.c:1712 +#: tcop/postgres.c:1704 #, c-format msgid "incorrect binary data format in bind parameter %d" msgstr "неверный формат двоичных данных в параметре Bind %d" -#: tcop/postgres.c:1810 +#: tcop/postgres.c:1802 #, c-format msgid "duration: %s ms bind %s%s%s: %s" msgstr "продолжительноÑÑ‚ÑŒ: %s мÑ, Ñообщение Bind %s%s%s: %s" -#: tcop/postgres.c:1858 tcop/postgres.c:2392 +#: tcop/postgres.c:1850 tcop/postgres.c:2384 #, c-format msgid "portal \"%s\" does not exist" msgstr "портал \"%s\" не ÑущеÑтвует" -#: tcop/postgres.c:1943 +#: tcop/postgres.c:1935 #, c-format msgid "%s %s%s%s: %s" msgstr "%s %s%s%s: %s" -#: tcop/postgres.c:1945 tcop/postgres.c:2030 +#: tcop/postgres.c:1937 tcop/postgres.c:2022 msgid "execute fetch from" msgstr "выборка из" -#: tcop/postgres.c:1946 tcop/postgres.c:2031 +#: tcop/postgres.c:1938 tcop/postgres.c:2023 msgid "execute" msgstr "выполнение" -#: tcop/postgres.c:2027 +#: tcop/postgres.c:2019 #, c-format msgid "duration: %s ms %s %s%s%s: %s" msgstr "продолжительноÑÑ‚ÑŒ: %s Ð¼Ñ %s %s%s%s: %s" -#: tcop/postgres.c:2153 +#: tcop/postgres.c:2145 #, c-format msgid "prepare: %s" msgstr "подготовка: %s" -#: tcop/postgres.c:2216 +#: tcop/postgres.c:2208 #, c-format msgid "parameters: %s" msgstr "параметры: %s" -#: tcop/postgres.c:2235 +#: tcop/postgres.c:2227 #, c-format msgid "abort reason: recovery conflict" msgstr "причина прерываниÑ: конфликт при воÑÑтановлении" -#: tcop/postgres.c:2251 +#: tcop/postgres.c:2243 #, c-format msgid "User was holding shared buffer pin for too long." msgstr "Пользователь удерживал фикÑатор разделÑемого буфера Ñлишком долго." -#: tcop/postgres.c:2254 +#: tcop/postgres.c:2246 #, c-format msgid "User was holding a relation lock for too long." msgstr "Пользователь удерживал блокировку таблицы Ñлишком долго." -#: tcop/postgres.c:2257 +#: tcop/postgres.c:2249 #, c-format msgid "User was or might have been using tablespace that must be dropped." msgstr "" "Пользователь иÑпользовал табличное проÑтранÑтво, которое должно быть удалено." -#: tcop/postgres.c:2260 +#: tcop/postgres.c:2252 #, c-format msgid "User query might have needed to see row versions that must be removed." msgstr "" "ЗапроÑу Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð½ÑƒÐ¶Ð½Ð¾ было видеть верÑии Ñтрок, которые должны быть " "удалены." -#: tcop/postgres.c:2266 +#: tcop/postgres.c:2258 #, c-format msgid "User was connected to a database that must be dropped." msgstr "Пользователь был подключён к базе данных, ÐºÐ¾Ñ‚Ð¾Ñ€Ð°Ñ Ð´Ð¾Ð»Ð¶Ð½Ð° быть удалена." -#: tcop/postgres.c:2595 +#: tcop/postgres.c:2587 #, c-format msgid "terminating connection because of crash of another server process" msgstr "закрытие Ð¿Ð¾Ð´ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð¸Ð·-за краха другого Ñерверного процеÑÑа" -#: tcop/postgres.c:2596 +#: tcop/postgres.c:2588 #, c-format msgid "" "The postmaster has commanded this server process to roll back the current " @@ -18582,7 +18341,7 @@ msgstr "" "транзакцию и завершитьÑÑ, так как другой Ñерверный процеÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐ¸Ð»ÑÑ " "аварийно и возможно разрушил разделÑемую памÑÑ‚ÑŒ." -#: tcop/postgres.c:2600 tcop/postgres.c:2904 +#: tcop/postgres.c:2592 tcop/postgres.c:2902 #, c-format msgid "" "In a moment you should be able to reconnect to the database and repeat your " @@ -18591,12 +18350,12 @@ msgstr "" "Ð’Ñ‹ Ñможете переподключитьÑÑ Ðº базе данных и повторить вашу команду Ñию " "минуту." -#: tcop/postgres.c:2686 +#: tcop/postgres.c:2678 #, c-format msgid "floating-point exception" msgstr "иÑключение в операции Ñ Ð¿Ð»Ð°Ð²Ð°ÑŽÑ‰ÐµÐ¹ точкой" -#: tcop/postgres.c:2687 +#: tcop/postgres.c:2679 #, c-format msgid "" "An invalid floating-point operation was signaled. This probably means an out-" @@ -18606,62 +18365,62 @@ msgstr "" "оказалÑÑ Ð²Ð½Ðµ допуÑтимых рамок или произошла ошибка вычиÑлениÑ, например, " "деление на ноль." -#: tcop/postgres.c:2849 +#: tcop/postgres.c:2847 #, c-format msgid "canceling authentication due to timeout" msgstr "отмена проверки подлинноÑти из-за таймаута" -#: tcop/postgres.c:2853 +#: tcop/postgres.c:2851 #, c-format msgid "terminating autovacuum process due to administrator command" msgstr "прекращение процеÑÑа автоочиÑтки по команде админиÑтратора" -#: tcop/postgres.c:2859 tcop/postgres.c:2869 tcop/postgres.c:2902 +#: tcop/postgres.c:2857 tcop/postgres.c:2867 tcop/postgres.c:2900 #, c-format msgid "terminating connection due to conflict with recovery" msgstr "закрытие Ð¿Ð¾Ð´ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð¸Ð·-за конфликта Ñ Ð¿Ñ€Ð¾Ñ†ÐµÑÑом воÑÑтановлениÑ" -#: tcop/postgres.c:2875 +#: tcop/postgres.c:2873 #, c-format msgid "terminating connection due to administrator command" msgstr "закрытие Ð¿Ð¾Ð´ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð¿Ð¾ команде админиÑтратора" -#: tcop/postgres.c:2885 +#: tcop/postgres.c:2883 #, c-format msgid "connection to client lost" msgstr "подключение к клиенту потерÑно" -#: tcop/postgres.c:2953 +#: tcop/postgres.c:2951 #, c-format msgid "canceling statement due to lock timeout" msgstr "выполнение оператора отменено из-за таймаута блокировки" -#: tcop/postgres.c:2960 +#: tcop/postgres.c:2958 #, c-format msgid "canceling statement due to statement timeout" msgstr "выполнение оператора отменено из-за таймаута" -#: tcop/postgres.c:2967 +#: tcop/postgres.c:2965 #, c-format msgid "canceling autovacuum task" msgstr "отмена задачи автоочиÑтки" -#: tcop/postgres.c:2990 +#: tcop/postgres.c:2988 #, c-format msgid "canceling statement due to user request" msgstr "выполнение оператора отменено по запроÑу пользователÑ" -#: tcop/postgres.c:3000 +#: tcop/postgres.c:2998 #, c-format msgid "terminating connection due to idle-in-transaction timeout" msgstr "закрытие Ð¿Ð¾Ð´ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð¸Ð·-за таймаута проÑÑ‚Ð¾Ñ Ð² транзакции" -#: tcop/postgres.c:3114 +#: tcop/postgres.c:3112 #, c-format msgid "stack depth limit exceeded" msgstr "превышен предел глубины Ñтека" -#: tcop/postgres.c:3115 +#: tcop/postgres.c:3113 #, c-format msgid "" "Increase the configuration parameter \"max_stack_depth\" (currently %dkB), " @@ -18671,12 +18430,12 @@ msgstr "" "КБ), предварительно убедившиÑÑŒ, что ОС предоÑтавлÑет доÑтаточный размер " "Ñтека." -#: tcop/postgres.c:3178 +#: tcop/postgres.c:3176 #, c-format msgid "\"max_stack_depth\" must not exceed %ldkB." msgstr "Значение \"max_stack_depth\" не должно превышать %ld КБ." -#: tcop/postgres.c:3180 +#: tcop/postgres.c:3178 #, c-format msgid "" "Increase the platform's stack depth limit via \"ulimit -s\" or local " @@ -18685,48 +18444,48 @@ msgstr "" "Увеличьте предел глубины Ñтека в ÑиÑтеме Ñ Ð¿Ð¾Ð¼Ð¾Ñ‰ÑŒÑŽ команды \"ulimit -s\" или " "Ñквивалента в вашей ОС." -#: tcop/postgres.c:3540 +#: tcop/postgres.c:3538 #, c-format msgid "invalid command-line argument for server process: %s" msgstr "неверный аргумент командной Ñтроки Ð´Ð»Ñ Ñерверного процеÑÑа: %s" -#: tcop/postgres.c:3541 tcop/postgres.c:3547 +#: tcop/postgres.c:3539 tcop/postgres.c:3545 #, c-format msgid "Try \"%s --help\" for more information." msgstr "Ð”Ð»Ñ Ð´Ð¾Ð¿Ð¾Ð»Ð½Ð¸Ñ‚ÐµÐ»ÑŒÐ½Ð¾Ð¹ информации попробуйте \"%s --help\"." -#: tcop/postgres.c:3545 +#: tcop/postgres.c:3543 #, c-format msgid "%s: invalid command-line argument: %s" msgstr "%s: неверный аргумент командной Ñтроки: %s" -#: tcop/postgres.c:3607 +#: tcop/postgres.c:3605 #, c-format msgid "%s: no database nor user name specified" msgstr "%s: не указаны ни база данных, ни пользователь" -#: tcop/postgres.c:4222 +#: tcop/postgres.c:4208 #, c-format msgid "invalid CLOSE message subtype %d" msgstr "неверный подтип ÑÐ¾Ð¾Ð±Ñ‰ÐµÐ½Ð¸Ñ CLOSE: %d" -#: tcop/postgres.c:4257 +#: tcop/postgres.c:4243 #, c-format msgid "invalid DESCRIBE message subtype %d" msgstr "неверный подтип ÑÐ¾Ð¾Ð±Ñ‰ÐµÐ½Ð¸Ñ DESCRIBE: %d" -#: tcop/postgres.c:4335 +#: tcop/postgres.c:4321 #, c-format msgid "fastpath function calls not supported in a replication connection" msgstr "вызовы функции fastpath не поддерживаютÑÑ Ð´Ð»Ñ Ñ€ÐµÐ¿Ð»Ð¸Ñ†Ð¸Ñ€ÑƒÑŽÑ‰Ð¸Ñ… Ñоединений" -#: tcop/postgres.c:4339 +#: tcop/postgres.c:4325 #, c-format msgid "extended query protocol not supported in a replication connection" msgstr "" "протокол раÑширенных запроÑов не поддерживаетÑÑ Ð´Ð»Ñ Ñ€ÐµÐ¿Ð»Ð¸Ñ†Ð¸Ñ€ÑƒÑŽÑ‰Ð¸Ñ… Ñоединений" -#: tcop/postgres.c:4509 +#: tcop/postgres.c:4495 #, c-format msgid "" "disconnection: session time: %d:%02d:%02d.%03d user=%s database=%s host=%s%s" @@ -18937,7 +18696,7 @@ msgid "invalid regular expression: %s" msgstr "неверное регулÑрное выражение: %s" #: tsearch/spell.c:954 tsearch/spell.c:971 tsearch/spell.c:988 -#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14401 gram.y:14418 +#: tsearch/spell.c:1005 tsearch/spell.c:1070 gram.y:14414 gram.y:14431 #, c-format msgid "syntax error" msgstr "ошибка ÑинтакÑиÑа" @@ -19138,8 +18897,8 @@ msgstr "aclremove больше не поддерживаетÑÑ" msgid "unrecognized privilege type: \"%s\"" msgstr "нераÑпознанный тип прав: \"%s\"" -#: utils/adt/acl.c:3427 utils/adt/regproc.c:123 utils/adt/regproc.c:144 -#: utils/adt/regproc.c:319 +#: utils/adt/acl.c:3427 utils/adt/regproc.c:124 utils/adt/regproc.c:145 +#: utils/adt/regproc.c:320 #, c-format msgid "function \"%s\" does not exist" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ \"%s\" не ÑущеÑтвует" @@ -19510,7 +19269,7 @@ msgstr "неверный ÑинтакÑÐ¸Ñ Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° money: \"%s\"" #: utils/adt/int.c:1097 utils/adt/int.c:1125 utils/adt/int8.c:597 #: utils/adt/int8.c:657 utils/adt/int8.c:897 utils/adt/int8.c:1005 #: utils/adt/int8.c:1094 utils/adt/int8.c:1202 utils/adt/numeric.c:6818 -#: utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 utils/adt/timestamp.c:3499 +#: utils/adt/numeric.c:7107 utils/adt/numeric.c:8120 utils/adt/timestamp.c:3542 #, c-format msgid "division by zero" msgstr "деление на ноль" @@ -19520,7 +19279,7 @@ msgstr "деление на ноль" msgid "\"char\" out of range" msgstr "значение \"char\" вне диапазона" -#: utils/adt/date.c:67 utils/adt/timestamp.c:94 utils/adt/varbit.c:52 +#: utils/adt/date.c:67 utils/adt/timestamp.c:95 utils/adt/varbit.c:52 #: utils/adt/varchar.c:45 #, c-format msgid "invalid type modifier" @@ -19548,17 +19307,17 @@ msgid "date out of range: \"%s\"" msgstr "дата вне диапазона: \"%s\"" #: utils/adt/date.c:222 utils/adt/date.c:456 utils/adt/date.c:480 -#: utils/adt/xml.c:2027 +#: utils/adt/xml.c:2031 #, c-format msgid "date out of range" msgstr "дата вне диапазона" -#: utils/adt/date.c:264 utils/adt/timestamp.c:593 +#: utils/adt/date.c:264 utils/adt/timestamp.c:594 #, c-format msgid "date field value out of range: %d-%02d-%02d" msgstr "значение Ð¿Ð¾Ð»Ñ Ñ‚Ð¸Ð¿Ð° date вне диапазона: %d-%02d-%02d" -#: utils/adt/date.c:271 utils/adt/date.c:280 utils/adt/timestamp.c:599 +#: utils/adt/date.c:271 utils/adt/date.c:280 utils/adt/timestamp.c:600 #, c-format msgid "date out of range: %d-%02d-%02d" msgstr "дата вне диапазона: %d-%02d-%02d" @@ -19580,28 +19339,28 @@ msgstr "дата вне диапазона Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° timestamp" #: utils/adt/formatting.c:3436 utils/adt/formatting.c:3504 #: utils/adt/json.c:1534 utils/adt/json.c:1556 utils/adt/jsonb.c:823 #: utils/adt/jsonb.c:847 utils/adt/nabstime.c:455 utils/adt/nabstime.c:498 -#: utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 utils/adt/timestamp.c:224 -#: utils/adt/timestamp.c:268 utils/adt/timestamp.c:726 -#: utils/adt/timestamp.c:735 utils/adt/timestamp.c:817 -#: utils/adt/timestamp.c:857 utils/adt/timestamp.c:3074 -#: utils/adt/timestamp.c:3095 utils/adt/timestamp.c:3108 -#: utils/adt/timestamp.c:3117 utils/adt/timestamp.c:3125 -#: utils/adt/timestamp.c:3180 utils/adt/timestamp.c:3203 -#: utils/adt/timestamp.c:3216 utils/adt/timestamp.c:3227 -#: utils/adt/timestamp.c:3235 utils/adt/timestamp.c:3809 -#: utils/adt/timestamp.c:3938 utils/adt/timestamp.c:3979 -#: utils/adt/timestamp.c:4067 utils/adt/timestamp.c:4113 -#: utils/adt/timestamp.c:4224 utils/adt/timestamp.c:4631 -#: utils/adt/timestamp.c:4747 utils/adt/timestamp.c:4757 -#: utils/adt/timestamp.c:4853 utils/adt/timestamp.c:4972 -#: utils/adt/timestamp.c:4982 utils/adt/timestamp.c:5234 -#: utils/adt/timestamp.c:5248 utils/adt/timestamp.c:5253 -#: utils/adt/timestamp.c:5267 utils/adt/timestamp.c:5316 -#: utils/adt/timestamp.c:5348 utils/adt/timestamp.c:5355 -#: utils/adt/timestamp.c:5381 utils/adt/timestamp.c:5385 -#: utils/adt/timestamp.c:5454 utils/adt/timestamp.c:5458 -#: utils/adt/timestamp.c:5472 utils/adt/timestamp.c:5510 utils/adt/xml.c:2049 -#: utils/adt/xml.c:2056 utils/adt/xml.c:2076 utils/adt/xml.c:2083 +#: utils/adt/nabstime.c:528 utils/adt/nabstime.c:571 utils/adt/timestamp.c:225 +#: utils/adt/timestamp.c:269 utils/adt/timestamp.c:727 +#: utils/adt/timestamp.c:736 utils/adt/timestamp.c:818 +#: utils/adt/timestamp.c:858 utils/adt/timestamp.c:3117 +#: utils/adt/timestamp.c:3138 utils/adt/timestamp.c:3151 +#: utils/adt/timestamp.c:3160 utils/adt/timestamp.c:3168 +#: utils/adt/timestamp.c:3223 utils/adt/timestamp.c:3246 +#: utils/adt/timestamp.c:3259 utils/adt/timestamp.c:3270 +#: utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3852 +#: utils/adt/timestamp.c:3981 utils/adt/timestamp.c:4022 +#: utils/adt/timestamp.c:4110 utils/adt/timestamp.c:4156 +#: utils/adt/timestamp.c:4267 utils/adt/timestamp.c:4674 +#: utils/adt/timestamp.c:4790 utils/adt/timestamp.c:4800 +#: utils/adt/timestamp.c:4896 utils/adt/timestamp.c:5015 +#: utils/adt/timestamp.c:5025 utils/adt/timestamp.c:5277 +#: utils/adt/timestamp.c:5291 utils/adt/timestamp.c:5296 +#: utils/adt/timestamp.c:5310 utils/adt/timestamp.c:5359 +#: utils/adt/timestamp.c:5391 utils/adt/timestamp.c:5398 +#: utils/adt/timestamp.c:5424 utils/adt/timestamp.c:5428 +#: utils/adt/timestamp.c:5497 utils/adt/timestamp.c:5501 +#: utils/adt/timestamp.c:5515 utils/adt/timestamp.c:5553 utils/adt/xml.c:2053 +#: utils/adt/xml.c:2060 utils/adt/xml.c:2080 utils/adt/xml.c:2087 #, c-format msgid "timestamp out of range" msgstr "timestamp вне диапазона" @@ -19622,7 +19381,7 @@ msgstr "abstime вне диапазона Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° даты" msgid "time out of range" msgstr "Ð²Ñ€ÐµÐ¼Ñ Ð²Ð½Ðµ диапазона" -#: utils/adt/date.c:1326 utils/adt/timestamp.c:618 +#: utils/adt/date.c:1326 utils/adt/timestamp.c:619 #, c-format msgid "time field value out of range: %d:%02d:%02g" msgstr "значение Ð¿Ð¾Ð»Ñ Ñ‚Ð¸Ð¿Ð° time вне диапазона: %d:%02d:%02g" @@ -19643,14 +19402,14 @@ msgid "\"time with time zone\" units \"%s\" not recognized" msgstr "\"Ð²Ñ€ÐµÐ¼Ñ Ñ Ñ‡Ð°Ñовым поÑÑом\" Ñодержит нераÑпознанные единицы \"%s\"" #: utils/adt/date.c:2830 utils/adt/datetime.c:995 utils/adt/datetime.c:1917 -#: utils/adt/datetime.c:4743 utils/adt/timestamp.c:532 -#: utils/adt/timestamp.c:559 utils/adt/timestamp.c:5259 -#: utils/adt/timestamp.c:5464 +#: utils/adt/datetime.c:4743 utils/adt/timestamp.c:533 +#: utils/adt/timestamp.c:560 utils/adt/timestamp.c:5302 +#: utils/adt/timestamp.c:5507 #, c-format msgid "time zone \"%s\" not recognized" msgstr "чаÑовой поÑÑ \"%s\" не раÑпознан" -#: utils/adt/date.c:2870 utils/adt/timestamp.c:5301 utils/adt/timestamp.c:5495 +#: utils/adt/date.c:2870 utils/adt/timestamp.c:5344 utils/adt/timestamp.c:5538 #, c-format msgid "interval time zone \"%s\" must not include months or days" msgstr "" @@ -20244,7 +20003,7 @@ msgid "oidvector has too many elements" msgstr "oidvector Ñодержит Ñлишком много Ñлементов" #: utils/adt/int.c:1362 utils/adt/int8.c:1460 utils/adt/numeric.c:1351 -#: utils/adt/timestamp.c:5561 utils/adt/timestamp.c:5642 +#: utils/adt/timestamp.c:5604 utils/adt/timestamp.c:5685 #, c-format msgid "step size cannot equal zero" msgstr "размер шага не может быть нулевым" @@ -20397,15 +20156,12 @@ msgid "key value must be scalar, not array, composite, or json" msgstr "" "значением ключа должен быть ÑкалÑÑ€ (не маÑÑив, композитный тип или json)" -#: utils/adt/json.c:2006 -#, c-format -msgid "could not determine data type for argument 1" -msgstr "не удалоÑÑŒ определить тип данных аргумента 1" - -#: utils/adt/json.c:2016 +#: utils/adt/json.c:2006 utils/adt/json.c:2016 utils/adt/json.c:2142 +#: utils/adt/json.c:2163 utils/adt/json.c:2222 utils/adt/jsonb.c:1214 +#: utils/adt/jsonb.c:1237 utils/adt/jsonb.c:1297 #, c-format -msgid "could not determine data type for argument 2" -msgstr "не удалоÑÑŒ определить тип данных аргумента 2" +msgid "could not determine data type for argument %d" +msgstr "не удалоÑÑŒ определить тип данных аргумента %d" #: utils/adt/json.c:2040 utils/adt/jsonb.c:1781 #, c-format @@ -20425,11 +20181,6 @@ msgid "" msgstr "" "Ðргументы json_build_object() должны ÑоÑтоÑÑ‚ÑŒ из пар ключей и значений." -#: utils/adt/json.c:2142 utils/adt/json.c:2163 utils/adt/json.c:2222 -#, c-format -msgid "could not determine data type for argument %d" -msgstr "не удалоÑÑŒ определить тип данных аргумента %d" - #: utils/adt/json.c:2148 #, c-format msgid "argument %d cannot be null" @@ -20479,11 +20230,6 @@ msgstr "" msgid "argument %d: key must not be null" msgstr "аргумент %d: ключ не может быть NULL" -#: utils/adt/jsonb.c:1214 utils/adt/jsonb.c:1237 utils/adt/jsonb.c:1297 -#, c-format -msgid "argument %d: could not determine data type" -msgstr "аргумент %d: не удалоÑÑŒ определить тип данных" - #: utils/adt/jsonb.c:1834 #, c-format msgid "object keys must be strings" @@ -20645,7 +20391,7 @@ msgstr "Ñлемент пути в позиции %d - не целочиÑлен msgid "levenshtein argument exceeds maximum length of %d characters" msgstr "длина аргумента levenshtein() превышает макÑимум (%d Ñимв.)" -#: utils/adt/like.c:212 utils/adt/selfuncs.c:5333 +#: utils/adt/like.c:212 utils/adt/selfuncs.c:5433 #, c-format msgid "could not determine which collation to use for ILIKE" msgstr "не удалоÑÑŒ определить, какой порÑдок Ñортировки иÑпользовать Ð´Ð»Ñ ILIKE" @@ -21312,61 +21058,61 @@ msgstr "неверный Ñлемент рег. выражениÑ: \"%c\"" msgid "regexp_split does not support the global option" msgstr "regexp_split не поддерживает глобальный поиÑк" -#: utils/adt/regproc.c:128 utils/adt/regproc.c:148 +#: utils/adt/regproc.c:129 utils/adt/regproc.c:149 #, c-format msgid "more than one function named \"%s\"" msgstr "Ð¸Ð¼Ñ \"%s\" имеют неÑколько функций" -#: utils/adt/regproc.c:587 utils/adt/regproc.c:607 +#: utils/adt/regproc.c:588 utils/adt/regproc.c:608 #, c-format msgid "more than one operator named %s" msgstr "Ð¸Ð¼Ñ %s имеют неÑколько операторов" -#: utils/adt/regproc.c:774 utils/adt/regproc.c:815 gram.y:7302 +#: utils/adt/regproc.c:775 utils/adt/regproc.c:816 gram.y:7311 #, c-format msgid "missing argument" msgstr "отÑутÑтвует аргумент" -#: utils/adt/regproc.c:775 utils/adt/regproc.c:816 gram.y:7303 +#: utils/adt/regproc.c:776 utils/adt/regproc.c:817 gram.y:7312 #, c-format msgid "Use NONE to denote the missing argument of a unary operator." msgstr "" "Чтобы обозначить отÑутÑтвующий аргумент унарного оператора, укажите NONE." -#: utils/adt/regproc.c:779 utils/adt/regproc.c:820 utils/adt/regproc.c:2006 -#: utils/adt/ruleutils.c:8367 utils/adt/ruleutils.c:8536 +#: utils/adt/regproc.c:780 utils/adt/regproc.c:821 utils/adt/regproc.c:2007 +#: utils/adt/ruleutils.c:8453 utils/adt/ruleutils.c:8622 #, c-format msgid "too many arguments" msgstr "Ñлишком много аргументов" -#: utils/adt/regproc.c:780 utils/adt/regproc.c:821 +#: utils/adt/regproc.c:781 utils/adt/regproc.c:822 #, c-format msgid "Provide two argument types for operator." msgstr "ПредоÑтавьте Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° два типа аргументов." -#: utils/adt/regproc.c:1594 utils/adt/regproc.c:1618 utils/adt/regproc.c:1715 -#: utils/adt/regproc.c:1739 utils/adt/regproc.c:1841 utils/adt/regproc.c:1846 +#: utils/adt/regproc.c:1595 utils/adt/regproc.c:1619 utils/adt/regproc.c:1716 +#: utils/adt/regproc.c:1740 utils/adt/regproc.c:1842 utils/adt/regproc.c:1847 #: utils/adt/varlena.c:3084 utils/adt/varlena.c:3089 #, c-format msgid "invalid name syntax" msgstr "ошибка ÑинтакÑиÑа в имени" -#: utils/adt/regproc.c:1904 +#: utils/adt/regproc.c:1905 #, c-format msgid "expected a left parenthesis" msgstr "ожидалаÑÑŒ Ð»ÐµÐ²Ð°Ñ Ñкобка" -#: utils/adt/regproc.c:1920 +#: utils/adt/regproc.c:1921 #, c-format msgid "expected a right parenthesis" msgstr "ожидалаÑÑŒ Ð¿Ñ€Ð°Ð²Ð°Ñ Ñкобка" -#: utils/adt/regproc.c:1939 +#: utils/adt/regproc.c:1940 #, c-format msgid "expected a type name" msgstr "ожидалоÑÑŒ Ð¸Ð¼Ñ Ñ‚Ð¸Ð¿Ð°" -#: utils/adt/regproc.c:1971 +#: utils/adt/regproc.c:1972 #, c-format msgid "improper type name" msgstr "ошибочное Ð¸Ð¼Ñ Ñ‚Ð¸Ð¿Ð°" @@ -21377,7 +21123,7 @@ msgstr "ошибочное Ð¸Ð¼Ñ Ñ‚Ð¸Ð¿Ð°" #: utils/adt/ri_triggers.c:1515 utils/adt/ri_triggers.c:1691 #: utils/adt/ri_triggers.c:1871 utils/adt/ri_triggers.c:2062 #: utils/adt/ri_triggers.c:2120 utils/adt/ri_triggers.c:2225 -#: utils/adt/ri_triggers.c:2402 gram.y:3343 +#: utils/adt/ri_triggers.c:2402 gram.y:3351 #, c-format msgid "MATCH PARTIAL not yet implemented" msgstr "выражение MATCH PARTIAL ещё не реализовано" @@ -21524,17 +21270,17 @@ msgstr "не удалоÑÑŒ Ñравнить различные типы Ñто msgid "cannot compare record types with different numbers of columns" msgstr "Ñравнивать типы запиÑей Ñ Ñ€Ð°Ð·Ð½Ñ‹Ð¼ чиÑлом Ñтолбцов нельзÑ" -#: utils/adt/ruleutils.c:4289 +#: utils/adt/ruleutils.c:4297 #, c-format msgid "rule \"%s\" has unsupported event type %d" msgstr "правило \"%s\" имеет неподдерживаемый тип Ñобытий %d" -#: utils/adt/selfuncs.c:5318 +#: utils/adt/selfuncs.c:5418 #, c-format msgid "case insensitive matching not supported on type bytea" msgstr "региÑтронезавиÑимое Ñравнение не поддерживаетÑÑ Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° bytea" -#: utils/adt/selfuncs.c:5421 +#: utils/adt/selfuncs.c:5521 #, c-format msgid "regular-expression matching not supported on type bytea" msgstr "Ñравнение Ñ Ñ€ÐµÐ³ÑƒÐ»Ñрными выражениÑми не поддерживаетÑÑ Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° bytea" @@ -21544,127 +21290,127 @@ msgstr "Ñравнение Ñ Ñ€ÐµÐ³ÑƒÐ»Ñрными выражениÑми не msgid "invalid input syntax for type tid: \"%s\"" msgstr "неверный ÑинтакÑÐ¸Ñ Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° tid: \"%s\"" -#: utils/adt/timestamp.c:99 +#: utils/adt/timestamp.c:100 #, c-format msgid "TIMESTAMP(%d)%s precision must not be negative" msgstr "TIMESTAMP(%d)%s: точноÑÑ‚ÑŒ должна быть неотрицательна" -#: utils/adt/timestamp.c:105 +#: utils/adt/timestamp.c:106 #, c-format msgid "TIMESTAMP(%d)%s precision reduced to maximum allowed, %d" msgstr "TIMESTAMP(%d)%s: точноÑÑ‚ÑŒ уменьшена до дозволенного макÑимума: %d" -#: utils/adt/timestamp.c:170 utils/adt/timestamp.c:445 +#: utils/adt/timestamp.c:171 utils/adt/timestamp.c:446 #, c-format msgid "timestamp out of range: \"%s\"" msgstr "timestamp вне диапазона: \"%s\"" -#: utils/adt/timestamp.c:188 utils/adt/timestamp.c:463 -#: utils/adt/timestamp.c:990 +#: utils/adt/timestamp.c:189 utils/adt/timestamp.c:464 +#: utils/adt/timestamp.c:991 #, c-format msgid "date/time value \"%s\" is no longer supported" msgstr "значение даты/времени \"%s\" более не поддерживаетÑÑ" -#: utils/adt/timestamp.c:258 utils/adt/timestamp.c:754 +#: utils/adt/timestamp.c:259 utils/adt/timestamp.c:755 #, c-format msgid "timestamp cannot be NaN" msgstr "timestamp не может быть NaN" -#: utils/adt/timestamp.c:380 +#: utils/adt/timestamp.c:381 #, c-format msgid "timestamp(%d) precision must be between %d and %d" msgstr "точноÑÑ‚ÑŒ timestamp(%d) должна быть между %d и %d" -#: utils/adt/timestamp.c:513 +#: utils/adt/timestamp.c:514 #, c-format msgid "invalid input syntax for numeric time zone: \"%s\"" msgstr "неверный ÑинтакÑÐ¸Ñ Ð´Ð»Ñ Ñ‡Ð¸Ñлового чаÑового поÑÑа: \"%s\"" -#: utils/adt/timestamp.c:515 +#: utils/adt/timestamp.c:516 #, c-format msgid "Numeric time zones must have \"-\" or \"+\" as first character." msgstr "" "ЗапиÑÑŒ чиÑлового чаÑового поÑÑа должна начинатьÑÑ Ñ Ñимвола \"-\" или \"+\"." -#: utils/adt/timestamp.c:528 +#: utils/adt/timestamp.c:529 #, c-format msgid "numeric time zone \"%s\" out of range" msgstr "чиÑловой чаÑовой поÑÑ \"%s\" вне диапазона" -#: utils/adt/timestamp.c:631 utils/adt/timestamp.c:641 -#: utils/adt/timestamp.c:653 +#: utils/adt/timestamp.c:632 utils/adt/timestamp.c:642 +#: utils/adt/timestamp.c:654 #, c-format msgid "timestamp out of range: %d-%02d-%02d %d:%02d:%02g" msgstr "timestamp вне диапазона: %d-%02d-%02d %d:%02d:%02g" -#: utils/adt/timestamp.c:772 utils/adt/timestamp.c:788 +#: utils/adt/timestamp.c:773 utils/adt/timestamp.c:789 #, c-format msgid "timestamp out of range: \"%g\"" msgstr "timestamp вне диапазона: \"%g\"" -#: utils/adt/timestamp.c:984 utils/adt/timestamp.c:1608 -#: utils/adt/timestamp.c:2121 utils/adt/timestamp.c:3273 -#: utils/adt/timestamp.c:3278 utils/adt/timestamp.c:3283 -#: utils/adt/timestamp.c:3333 utils/adt/timestamp.c:3340 -#: utils/adt/timestamp.c:3347 utils/adt/timestamp.c:3367 -#: utils/adt/timestamp.c:3374 utils/adt/timestamp.c:3381 -#: utils/adt/timestamp.c:3411 utils/adt/timestamp.c:3419 -#: utils/adt/timestamp.c:3464 utils/adt/timestamp.c:3804 -#: utils/adt/timestamp.c:3933 utils/adt/timestamp.c:4324 +#: utils/adt/timestamp.c:985 utils/adt/timestamp.c:1609 +#: utils/adt/timestamp.c:2122 utils/adt/timestamp.c:3316 +#: utils/adt/timestamp.c:3321 utils/adt/timestamp.c:3326 +#: utils/adt/timestamp.c:3376 utils/adt/timestamp.c:3383 +#: utils/adt/timestamp.c:3390 utils/adt/timestamp.c:3410 +#: utils/adt/timestamp.c:3417 utils/adt/timestamp.c:3424 +#: utils/adt/timestamp.c:3454 utils/adt/timestamp.c:3462 +#: utils/adt/timestamp.c:3507 utils/adt/timestamp.c:3847 +#: utils/adt/timestamp.c:3976 utils/adt/timestamp.c:4367 #, c-format msgid "interval out of range" msgstr "interval вне диапазона" -#: utils/adt/timestamp.c:1125 utils/adt/timestamp.c:1158 +#: utils/adt/timestamp.c:1126 utils/adt/timestamp.c:1159 #, c-format msgid "invalid INTERVAL type modifier" msgstr "неверный модификатор типа INTERVAL" -#: utils/adt/timestamp.c:1141 +#: utils/adt/timestamp.c:1142 #, c-format msgid "INTERVAL(%d) precision must not be negative" msgstr "INTERVAL(%d): точноÑÑ‚ÑŒ должна быть неотрицательна" -#: utils/adt/timestamp.c:1147 +#: utils/adt/timestamp.c:1148 #, c-format msgid "INTERVAL(%d) precision reduced to maximum allowed, %d" msgstr "INTERVAL(%d): точноÑÑ‚ÑŒ уменьшена до макÑимально возможной: %d" -#: utils/adt/timestamp.c:1552 +#: utils/adt/timestamp.c:1553 #, c-format msgid "interval(%d) precision must be between %d and %d" msgstr "точноÑÑ‚ÑŒ interval(%d) должна быть между %d и %d" -#: utils/adt/timestamp.c:2850 +#: utils/adt/timestamp.c:2893 #, c-format msgid "cannot subtract infinite timestamps" msgstr "вычитать беÑконечные Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ timestamp нельзÑ" -#: utils/adt/timestamp.c:4059 utils/adt/timestamp.c:4584 -#: utils/adt/timestamp.c:4768 utils/adt/timestamp.c:4793 +#: utils/adt/timestamp.c:4102 utils/adt/timestamp.c:4627 +#: utils/adt/timestamp.c:4811 utils/adt/timestamp.c:4836 #, c-format msgid "timestamp units \"%s\" not supported" msgstr "единицы timestamp \"%s\" не поддерживаютÑÑ" -#: utils/adt/timestamp.c:4073 utils/adt/timestamp.c:4538 -#: utils/adt/timestamp.c:4803 +#: utils/adt/timestamp.c:4116 utils/adt/timestamp.c:4581 +#: utils/adt/timestamp.c:4846 #, c-format msgid "timestamp units \"%s\" not recognized" msgstr "единицы timestamp \"%s\" не раÑпознаны" -#: utils/adt/timestamp.c:4213 utils/adt/timestamp.c:4579 -#: utils/adt/timestamp.c:4990 utils/adt/timestamp.c:5016 +#: utils/adt/timestamp.c:4256 utils/adt/timestamp.c:4622 +#: utils/adt/timestamp.c:5033 utils/adt/timestamp.c:5059 #, c-format msgid "timestamp with time zone units \"%s\" not supported" msgstr "единицы timestamp Ñ Ñ‡Ð°Ñовым поÑÑом \"%s\" не поддерживаютÑÑ" -#: utils/adt/timestamp.c:4230 utils/adt/timestamp.c:4533 -#: utils/adt/timestamp.c:5025 +#: utils/adt/timestamp.c:4273 utils/adt/timestamp.c:4576 +#: utils/adt/timestamp.c:5068 #, c-format msgid "timestamp with time zone units \"%s\" not recognized" msgstr "единицы timestamp Ñ Ñ‡Ð°Ñовым поÑÑом \"%s\" не раÑпознаны" -#: utils/adt/timestamp.c:4311 +#: utils/adt/timestamp.c:4354 #, c-format msgid "" "interval units \"%s\" not supported because months usually have fractional " @@ -21673,12 +21419,12 @@ msgstr "" "единицы интервала \"%s\" не поддерживаютÑÑ, так как в меÑÑцах дробное чиÑло " "недель" -#: utils/adt/timestamp.c:4317 utils/adt/timestamp.c:5131 +#: utils/adt/timestamp.c:4360 utils/adt/timestamp.c:5174 #, c-format msgid "interval units \"%s\" not supported" msgstr "единицы interval \"%s\" не поддерживаютÑÑ" -#: utils/adt/timestamp.c:4333 utils/adt/timestamp.c:5158 +#: utils/adt/timestamp.c:4376 utils/adt/timestamp.c:5201 #, c-format msgid "interval units \"%s\" not recognized" msgstr "единицы interval \"%s\" не раÑпознаны" @@ -22053,73 +21799,73 @@ msgstr "аргумент ntile должен быть больше нулÑ" msgid "argument of nth_value must be greater than zero" msgstr "аргумент nth_value должен быть больше нулÑ" -#: utils/adt/xml.c:171 +#: utils/adt/xml.c:175 #, c-format msgid "unsupported XML feature" msgstr "XML-функции не поддерживаютÑÑ" -#: utils/adt/xml.c:172 +#: utils/adt/xml.c:176 #, c-format msgid "This functionality requires the server to be built with libxml support." msgstr "Ð”Ð»Ñ Ñтой функциональноÑти в Ñервере не хватает поддержки libxml." -#: utils/adt/xml.c:173 +#: utils/adt/xml.c:177 #, c-format msgid "You need to rebuild PostgreSQL using --with-libxml." msgstr "Ðеобходимо перекомпилировать PostgreSQL Ñ ÐºÐ»ÑŽÑ‡Ð¾Ð¼ --with-libxml." -#: utils/adt/xml.c:192 utils/mb/mbutils.c:523 +#: utils/adt/xml.c:196 utils/mb/mbutils.c:523 #, c-format msgid "invalid encoding name \"%s\"" msgstr "неверное Ð¸Ð¼Ñ ÐºÐ¾Ð´Ð¸Ñ€Ð¾Ð²ÐºÐ¸: \"%s\"" -#: utils/adt/xml.c:435 utils/adt/xml.c:440 +#: utils/adt/xml.c:439 utils/adt/xml.c:444 #, c-format msgid "invalid XML comment" msgstr "ошибка в XML-комментарии" -#: utils/adt/xml.c:569 +#: utils/adt/xml.c:573 #, c-format msgid "not an XML document" msgstr "не XML-документ" -#: utils/adt/xml.c:728 utils/adt/xml.c:751 +#: utils/adt/xml.c:732 utils/adt/xml.c:755 #, c-format msgid "invalid XML processing instruction" msgstr "Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ð°Ñ XML-инÑÑ‚Ñ€ÑƒÐºÑ†Ð¸Ñ Ð¾Ð±Ñ€Ð°Ð±Ð¾Ñ‚ÐºÐ¸ (PI)" -#: utils/adt/xml.c:729 +#: utils/adt/xml.c:733 #, c-format msgid "XML processing instruction target name cannot be \"%s\"." msgstr "назначением XML-инÑтрукции обработки (PI) не может быть \"%s\"." -#: utils/adt/xml.c:752 +#: utils/adt/xml.c:756 #, c-format msgid "XML processing instruction cannot contain \"?>\"." msgstr "XML-инÑÑ‚Ñ€ÑƒÐºÑ†Ð¸Ñ Ð¾Ð±Ñ€Ð°Ð±Ð¾Ñ‚ÐºÐ¸ (PI) не может Ñодержать \"?>\"." -#: utils/adt/xml.c:831 +#: utils/adt/xml.c:835 #, c-format msgid "xmlvalidate is not implemented" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ xmlvalidate не реализована" -#: utils/adt/xml.c:910 +#: utils/adt/xml.c:914 #, c-format msgid "could not initialize XML library" msgstr "не удалоÑÑŒ инициализировать библиотеку XML" -#: utils/adt/xml.c:911 +#: utils/adt/xml.c:915 #, c-format msgid "" "libxml2 has incompatible char type: sizeof(char)=%u, sizeof(xmlChar)=%u." msgstr "другой тип char в libxml2: sizeof(char)=%u, sizeof(xmlChar)=%u." -#: utils/adt/xml.c:997 +#: utils/adt/xml.c:1001 #, c-format msgid "could not set up XML error handler" msgstr "не удалоÑÑŒ уÑтановить обработчик XML-ошибок" -#: utils/adt/xml.c:998 +#: utils/adt/xml.c:1002 #, c-format msgid "" "This probably indicates that the version of libxml2 being used is not " @@ -22128,72 +21874,72 @@ msgstr "" "Возможно Ñто означает, что иÑÐ¿Ð¾Ð»ÑŒÐ·ÑƒÐµÐ¼Ð°Ñ Ð²ÐµÑ€ÑÐ¸Ñ libxml2 не ÑовмеÑтима Ñ " "заголовочными файлами libxml2, Ñ ÐºÐ¾Ñ‚Ð¾Ñ€Ñ‹Ð¼Ð¸ был Ñобран PostgreSQL." -#: utils/adt/xml.c:1735 +#: utils/adt/xml.c:1739 msgid "Invalid character value." msgstr "Ðеверный Ñимвол." -#: utils/adt/xml.c:1738 +#: utils/adt/xml.c:1742 msgid "Space required." msgstr "ТребуетÑÑ Ð¿Ñ€Ð¾Ð±ÐµÐ»." -#: utils/adt/xml.c:1741 +#: utils/adt/xml.c:1745 msgid "standalone accepts only 'yes' or 'no'." msgstr "значениÑми атрибута standalone могут быть только 'yes' и 'no'." -#: utils/adt/xml.c:1744 +#: utils/adt/xml.c:1748 msgid "Malformed declaration: missing version." msgstr "Ошибочное объÑвление: не указана верÑиÑ." -#: utils/adt/xml.c:1747 +#: utils/adt/xml.c:1751 msgid "Missing encoding in text declaration." msgstr "Ð’ объÑвлении не указана кодировка." -#: utils/adt/xml.c:1750 +#: utils/adt/xml.c:1754 msgid "Parsing XML declaration: '?>' expected." msgstr "Ошибка при разборе XML-объÑвлениÑ: ожидаетÑÑ '?>'." -#: utils/adt/xml.c:1753 +#: utils/adt/xml.c:1757 #, c-format msgid "Unrecognized libxml error code: %d." msgstr "ÐераÑпознанный код ошибки libxml: %d." -#: utils/adt/xml.c:2028 +#: utils/adt/xml.c:2032 #, c-format msgid "XML does not support infinite date values." msgstr "XML не поддерживает беÑконечноÑÑ‚ÑŒ в датах." -#: utils/adt/xml.c:2050 utils/adt/xml.c:2077 +#: utils/adt/xml.c:2054 utils/adt/xml.c:2081 #, c-format msgid "XML does not support infinite timestamp values." msgstr "XML не поддерживает беÑконечноÑÑ‚ÑŒ в timestamp." -#: utils/adt/xml.c:2468 +#: utils/adt/xml.c:2481 #, c-format msgid "invalid query" msgstr "неверный запроÑ" -#: utils/adt/xml.c:3793 +#: utils/adt/xml.c:3806 #, c-format msgid "invalid array for XML namespace mapping" msgstr "неправильный маÑÑив Ñ ÑопоÑтавлениÑми проÑтранÑтв имён XML" -#: utils/adt/xml.c:3794 +#: utils/adt/xml.c:3807 #, c-format msgid "" "The array must be two-dimensional with length of the second axis equal to 2." msgstr "МаÑÑив должен быть двухмерным и Ñодержать 2 Ñлемента по второй оÑи." -#: utils/adt/xml.c:3818 +#: utils/adt/xml.c:3831 #, c-format msgid "empty XPath expression" msgstr "пуÑтое выражение XPath" -#: utils/adt/xml.c:3867 +#: utils/adt/xml.c:3880 #, c-format msgid "neither namespace name nor URI may be null" msgstr "ни префикÑ, ни URI проÑтранÑтва имён не может быть null" -#: utils/adt/xml.c:3874 +#: utils/adt/xml.c:3887 #, c-format msgid "could not register XML namespace with name \"%s\" and URI \"%s\"" msgstr "" @@ -25053,6 +24799,12 @@ msgid "" msgstr "" "заданный в запроÑе кортеж результата неÑовмеÑтим Ñ Ñ‚Ð¸Ð¿Ð¾Ð¼ результата функции" +#. translator: %d.%02ds is system CPU time, %d.%02du is user CPU time +#: utils/misc/pg_rusage.c:66 +#, c-format +msgid "CPU %d.%02ds/%d.%02du sec elapsed %d.%02d sec" +msgstr "CPU %d.%02ds/%d.%02du Ñ, прошло %d.%02d Ñ" + #: utils/misc/rls.c:127 #, c-format msgid "query would be affected by row-level security policy for table \"%s\"" @@ -25155,7 +24907,7 @@ msgid "@INCLUDE without file name in time zone file \"%s\", line %d" msgstr "" "в @INCLUDE не указано Ð¸Ð¼Ñ Ñ„Ð°Ð¹Ð»Ð° (файл чаÑовых поÑÑов \"%s\", Ñтрока %d)" -#: utils/mmgr/aset.c:510 +#: utils/mmgr/aset.c:511 #, c-format msgid "Failed while creating memory context \"%s\"." msgstr "Ошибка при Ñоздании контекÑта памÑти \"%s\"." @@ -25203,17 +24955,17 @@ msgstr "не удалоÑÑŒ Ñчитать блок %ld временного Ñ„ msgid "cannot have more than %d runs for an external sort" msgstr "чиÑло потоков данных Ð´Ð»Ñ Ð²Ð½ÐµÑˆÐ½ÐµÐ¹ Ñортировки не может превышать %d" -#: utils/sort/tuplesort.c:4474 +#: utils/sort/tuplesort.c:4479 #, c-format msgid "could not create unique index \"%s\"" msgstr "Ñоздать уникальный Ð¸Ð½Ð´ÐµÐºÑ \"%s\" не удалоÑÑŒ" -#: utils/sort/tuplesort.c:4476 +#: utils/sort/tuplesort.c:4481 #, c-format msgid "Key %s is duplicated." msgstr "Ключ %s дублируетÑÑ." -#: utils/sort/tuplesort.c:4477 +#: utils/sort/tuplesort.c:4482 #, c-format msgid "Duplicate keys exist." msgstr "Данные Ñодержат дублирующиеÑÑ ÐºÐ»ÑŽÑ‡Ð¸." @@ -25304,206 +25056,206 @@ msgstr "Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ð¼Ð¿Ð¾Ñ€Ñ‚Ð¸Ñ€Ð¾Ð²Ð°Ñ‚ÑŒ Ñнимок из другой msgid "unrecognized role option \"%s\"" msgstr "нераÑпознанный параметр роли \"%s\"" -#: gram.y:1278 gram.y:1293 +#: gram.y:1286 gram.y:1301 #, c-format msgid "CREATE SCHEMA IF NOT EXISTS cannot include schema elements" msgstr "CREATE SCHEMA IF NOT EXISTS не может включать Ñлементы Ñхемы" -#: gram.y:1438 +#: gram.y:1446 #, c-format msgid "current database cannot be changed" msgstr "Ñменить текущую базу данных нельзÑ" -#: gram.y:1562 +#: gram.y:1570 #, c-format msgid "time zone interval must be HOUR or HOUR TO MINUTE" msgstr "" "интервал, задающий чаÑовой поÑÑ, должен иметь точноÑÑ‚ÑŒ HOUR или HOUR TO " "MINUTE" -#: gram.y:2600 gram.y:2629 +#: gram.y:2608 gram.y:2637 #, c-format msgid "STDIN/STDOUT not allowed with PROGRAM" msgstr "ÑƒÐºÐ°Ð·Ð°Ð½Ð¸Ñ STDIN/STDOUT неÑовмеÑтимы Ñ PROGRAM" -#: gram.y:2895 gram.y:2902 gram.y:10295 gram.y:10303 +#: gram.y:2903 gram.y:2910 gram.y:10304 gram.y:10312 #, c-format msgid "GLOBAL is deprecated in temporary table creation" msgstr "указание GLOBAL при Ñоздании временных таблиц уÑтарело" -#: gram.y:4809 +#: gram.y:4818 msgid "duplicate trigger events specified" msgstr "ÑÐ¾Ð±Ñ‹Ñ‚Ð¸Ñ Ñ‚Ñ€Ð¸Ð³Ð³ÐµÑ€Ð° повторÑÑŽÑ‚ÑÑ" -#: gram.y:4909 +#: gram.y:4918 #, c-format msgid "conflicting constraint properties" msgstr "противоречащие характериÑтики ограничениÑ" -#: gram.y:5041 +#: gram.y:5050 #, c-format msgid "CREATE ASSERTION is not yet implemented" msgstr "оператор CREATE ASSERTION ещё не реализован" -#: gram.y:5057 +#: gram.y:5066 #, c-format msgid "DROP ASSERTION is not yet implemented" msgstr "оператор DROP ASSERTION ещё не реализован" -#: gram.y:5403 +#: gram.y:5412 #, c-format msgid "RECHECK is no longer required" msgstr "RECHECK более не требуетÑÑ" -#: gram.y:5404 +#: gram.y:5413 #, c-format msgid "Update your data type." msgstr "Обновите тип данных." -#: gram.y:6983 +#: gram.y:6992 #, c-format msgid "aggregates cannot have output arguments" msgstr "у агрегатных функций не может быть выходных аргументов" -#: gram.y:8853 gram.y:8871 +#: gram.y:8862 gram.y:8880 #, c-format msgid "WITH CHECK OPTION not supported on recursive views" msgstr "" "предложение WITH CHECK OPTION не поддерживаетÑÑ Ð´Ð»Ñ Ñ€ÐµÐºÑƒÑ€Ñивных предÑтавлений" -#: gram.y:9389 +#: gram.y:9398 #, c-format msgid "unrecognized VACUUM option \"%s\"" msgstr "нераÑпознанный параметр VACUUM: \"%s\"" -#: gram.y:10403 +#: gram.y:10412 #, c-format msgid "LIMIT #,# syntax is not supported" msgstr "ÑинтакÑÐ¸Ñ LIMIT #,# не поддерживаетÑÑ" -#: gram.y:10404 +#: gram.y:10413 #, c-format msgid "Use separate LIMIT and OFFSET clauses." msgstr "ИÑпользуйте отдельные Ð¿Ñ€ÐµÐ´Ð»Ð¾Ð¶ÐµÐ½Ð¸Ñ LIMIT и OFFSET." -#: gram.y:10667 gram.y:10692 +#: gram.y:10676 gram.y:10701 #, c-format msgid "VALUES in FROM must have an alias" msgstr "ÑпиÑок VALUES во FROM должен иметь пÑевдоним" -#: gram.y:10668 gram.y:10693 +#: gram.y:10677 gram.y:10702 #, c-format msgid "For example, FROM (VALUES ...) [AS] foo." msgstr "Ðапример, FROM (VALUES ...) [AS] foo." -#: gram.y:10673 gram.y:10698 +#: gram.y:10682 gram.y:10707 #, c-format msgid "subquery in FROM must have an alias" msgstr "Ð¿Ð¾Ð´Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð²Ð¾ FROM должен иметь пÑевдоним" -#: gram.y:10674 gram.y:10699 +#: gram.y:10683 gram.y:10708 #, c-format msgid "For example, FROM (SELECT ...) [AS] foo." msgstr "Ðапример, FROM (SELECT ...) [AS] foo." -#: gram.y:11273 +#: gram.y:11282 #, c-format msgid "precision for type float must be at least 1 bit" msgstr "тип float должен иметь точноÑÑ‚ÑŒ минимум 1 бит" -#: gram.y:11282 +#: gram.y:11291 #, c-format msgid "precision for type float must be less than 54 bits" msgstr "тип float должен иметь точноÑÑ‚ÑŒ меньше 54 бит" -#: gram.y:11786 +#: gram.y:11795 #, c-format msgid "wrong number of parameters on left side of OVERLAPS expression" msgstr "неверное чиÑло параметров в левой чаÑти Ð²Ñ‹Ñ€Ð°Ð¶ÐµÐ½Ð¸Ñ OVERLAPS" -#: gram.y:11791 +#: gram.y:11800 #, c-format msgid "wrong number of parameters on right side of OVERLAPS expression" msgstr "неверное чиÑло параметров в правой чаÑти Ð²Ñ‹Ñ€Ð°Ð¶ÐµÐ½Ð¸Ñ OVERLAPS" -#: gram.y:11966 +#: gram.y:11975 #, c-format msgid "UNIQUE predicate is not yet implemented" msgstr "предикат UNIQUE ещё не реализован" -#: gram.y:12296 +#: gram.y:12309 #, c-format msgid "cannot use multiple ORDER BY clauses with WITHIN GROUP" msgstr "ORDER BY Ñ WITHIN GROUP можно указать только один раз" -#: gram.y:12301 +#: gram.y:12314 #, c-format msgid "cannot use DISTINCT with WITHIN GROUP" msgstr "DISTINCT Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ñ WITHIN GROUP" -#: gram.y:12306 +#: gram.y:12319 #, c-format msgid "cannot use VARIADIC with WITHIN GROUP" msgstr "VARIADIC Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать Ñ WITHIN GROUP" -#: gram.y:12812 +#: gram.y:12825 #, c-format msgid "RANGE PRECEDING is only supported with UNBOUNDED" msgstr "RANGE PRECEDING поддерживаетÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ Ñ UNBOUNDED" -#: gram.y:12818 +#: gram.y:12831 #, c-format msgid "RANGE FOLLOWING is only supported with UNBOUNDED" msgstr "RANGE FOLLOWING поддерживаетÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ Ñ UNBOUNDED" -#: gram.y:12845 gram.y:12868 +#: gram.y:12858 gram.y:12881 #, c-format msgid "frame start cannot be UNBOUNDED FOLLOWING" msgstr "началом рамки не может быть UNBOUNDED FOLLOWING" -#: gram.y:12850 +#: gram.y:12863 #, c-format msgid "frame starting from following row cannot end with current row" msgstr "" "рамка, начинающаÑÑÑ Ñо Ñледующей Ñтроки, не может заканчиватьÑÑ Ñ‚ÐµÐºÑƒÑ‰ÐµÐ¹" -#: gram.y:12873 +#: gram.y:12886 #, c-format msgid "frame end cannot be UNBOUNDED PRECEDING" msgstr "концом рамки не может быть UNBOUNDED PRECEDING" -#: gram.y:12879 +#: gram.y:12892 #, c-format msgid "frame starting from current row cannot have preceding rows" msgstr "" "рамка, начинающаÑÑÑ Ñ Ñ‚ÐµÐºÑƒÑ‰ÐµÐ¹ Ñтроки, не может иметь предшеÑтвующих Ñтрок" -#: gram.y:12886 +#: gram.y:12899 #, c-format msgid "frame starting from following row cannot have preceding rows" msgstr "" "рамка, начинающаÑÑÑ Ñо Ñледующей Ñтроки, не может иметь предшеÑтвующих Ñтрок" -#: gram.y:13551 +#: gram.y:13564 #, c-format msgid "type modifier cannot have parameter name" msgstr "параметр функции-модификатора типа должен быть безымÑнным" -#: gram.y:13557 +#: gram.y:13570 #, c-format msgid "type modifier cannot have ORDER BY" msgstr "модификатор типа не может включать ORDER BY" -#: gram.y:13621 gram.y:13627 +#: gram.y:13634 gram.y:13640 #, c-format msgid "%s cannot be used as a role name here" msgstr "%s Ð½ÐµÐ»ÑŒÐ·Ñ Ð¸Ñпользовать здеÑÑŒ как Ð¸Ð¼Ñ Ñ€Ð¾Ð»Ð¸" -#: gram.y:14249 gram.y:14438 +#: gram.y:14262 gram.y:14451 msgid "improper use of \"*\"" msgstr "недопуÑтимое иÑпользование \"*\"" -#: gram.y:14502 +#: gram.y:14515 #, c-format msgid "" "an ordered-set aggregate with a VARIADIC direct argument must have one " @@ -25512,50 +25264,50 @@ msgstr "" "ÑÐ¾Ñ€Ñ‚Ð¸Ñ€ÑƒÑŽÑ‰Ð°Ñ Ð°Ð³Ñ€ÐµÐ³Ð°Ñ‚Ð½Ð°Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ñ Ð½ÐµÐ¿Ð¾ÑредÑтвенным аргументом VARIADIC должна " "иметь один агрегатный аргумент VARIADIC того же типа данных" -#: gram.y:14539 +#: gram.y:14552 #, c-format msgid "multiple ORDER BY clauses not allowed" msgstr "ORDER BY можно указать только один раз" -#: gram.y:14550 +#: gram.y:14563 #, c-format msgid "multiple OFFSET clauses not allowed" msgstr "OFFSET можно указать только один раз" -#: gram.y:14559 +#: gram.y:14572 #, c-format msgid "multiple LIMIT clauses not allowed" msgstr "LIMIT можно указать только один раз" -#: gram.y:14568 +#: gram.y:14581 #, c-format msgid "multiple WITH clauses not allowed" msgstr "WITH можно указать только один раз" -#: gram.y:14760 +#: gram.y:14773 #, c-format msgid "OUT and INOUT arguments aren't allowed in TABLE functions" msgstr "в табличных функциÑÑ… не может быть аргументов OUT и INOUT" -#: gram.y:14861 +#: gram.y:14874 #, c-format msgid "multiple COLLATE clauses not allowed" msgstr "COLLATE можно указать только один раз" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14899 gram.y:14912 +#: gram.y:14912 gram.y:14925 #, c-format msgid "%s constraints cannot be marked DEFERRABLE" msgstr "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ %s не могут иметь характериÑтики DEFERRABLE" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14925 +#: gram.y:14938 #, c-format msgid "%s constraints cannot be marked NOT VALID" msgstr "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ %s не могут иметь характериÑтики NOT VALID" #. translator: %s is CHECK, UNIQUE, or similar -#: gram.y:14938 +#: gram.y:14951 #, c-format msgid "%s constraints cannot be marked NO INHERIT" msgstr "Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ %s не могут иметь характериÑтики NO INHERIT" @@ -25779,6 +25531,252 @@ msgstr "неÑтандартное иÑпользование ÑпецÑимво msgid "Use the escape string syntax for escapes, e.g., E'\\r\\n'." msgstr "ИÑпользуйте Ð´Ð»Ñ Ð·Ð°Ð¿Ð¸Ñи ÑпецÑимволов ÑинтакÑÐ¸Ñ ÑпецÑтрок E'\\r\\n'." +#~ msgid "index row size %lu exceeds maximum %lu for index \"%s\"" +#~ msgstr "" +#~ "размер Ñтроки индекÑа (%lu) больше предельного размера (%lu) (Ð¸Ð½Ð´ÐµÐºÑ \"%s" +#~ "\")" + +#~ msgid "" +#~ "brin operator family \"%s\" contains function %s with invalid support " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов brin \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "опорным номером %d" + +#~ msgid "" +#~ "brin operator family \"%s\" contains function %s with wrong signature for " +#~ "support number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов brin \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" + +#~ msgid "" +#~ "brin operator family \"%s\" contains operator %s with invalid strategy " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов brin \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "номером Ñтратегии %d" + +#~ msgid "" +#~ "brin operator family \"%s\" contains invalid ORDER BY specification for " +#~ "operator %s" +#~ msgstr "" +#~ "ÑемейÑтво операторов brin \"%s\" Ñодержит некорректное определение ORDER " +#~ "BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" + +#~ msgid "" +#~ "brin operator family \"%s\" contains operator %s with wrong signature" +#~ msgstr "" +#~ "ÑемейÑтво операторов brin \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением" + +#~ msgid "brin operator class \"%s\" is missing support function %d" +#~ msgstr "в клаÑÑе операторов brin \"%s\" нет опорной функции %d" + +#~ msgid "" +#~ "gist operator family \"%s\" contains support procedure %s with cross-type " +#~ "registration" +#~ msgstr "" +#~ "ÑемейÑтво операторов gist \"%s\" Ñодержит опорную процедуру %s Ñ " +#~ "межтиповой региÑтрацией" + +#~ msgid "" +#~ "gist operator family \"%s\" contains function %s with invalid support " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов gist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "опорным номером %d" + +#~ msgid "" +#~ "gist operator family \"%s\" contains function %s with wrong signature for " +#~ "support number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов gist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" + +#~ msgid "" +#~ "gist operator family \"%s\" contains operator %s with invalid strategy " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов gist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "номером Ñтратегии %d" + +#~ msgid "" +#~ "gist operator family \"%s\" contains operator %s with wrong signature" +#~ msgstr "" +#~ "ÑемейÑтво операторов gist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением" + +#~ msgid "gist operator class \"%s\" is missing support function %d" +#~ msgstr "в клаÑÑе операторов gist \"%s\" нет опорной функции %d" + +#~ msgid "" +#~ "hash operator family \"%s\" contains support procedure %s with cross-type " +#~ "registration" +#~ msgstr "" +#~ "ÑемейÑтво операторов hash \"%s\" Ñодержит опорную процедуру %s Ñ " +#~ "межтиповой региÑтрацией" + +#~ msgid "" +#~ "hash operator family \"%s\" contains function %s with wrong signature for " +#~ "support number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов hash \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" + +#~ msgid "" +#~ "hash operator family \"%s\" contains function %s with invalid support " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов hash \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "опорным номером %d" + +#~ msgid "" +#~ "hash operator family \"%s\" contains operator %s with invalid strategy " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов hash \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "номером Ñтратегии %d" + +#~ msgid "" +#~ "hash operator family \"%s\" contains invalid ORDER BY specification for " +#~ "operator %s" +#~ msgstr "" +#~ "ÑемейÑтво операторов hash \"%s\" Ñодержит некорректное определение ORDER " +#~ "BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" + +#~ msgid "" +#~ "hash operator family \"%s\" contains operator %s with wrong signature" +#~ msgstr "" +#~ "ÑемейÑтво операторов hash \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением" + +#~ msgid "" +#~ "hash operator family \"%s\" is missing operator(s) for types %s and %s" +#~ msgstr "" +#~ "в ÑемейÑтве операторов hash \"%s\" нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" + +#~ msgid "hash operator class \"%s\" is missing operator(s)" +#~ msgstr "в клаÑÑе операторов hash \"%s\" нет оператора(ов)" + +#~ msgid "" +#~ "btree operator family \"%s\" contains function %s with invalid support " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов btree \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "опорным номером %d" + +#~ msgid "" +#~ "btree operator family \"%s\" contains function %s with wrong signature " +#~ "for support number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов btree \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" + +#~ msgid "" +#~ "btree operator family \"%s\" contains operator %s with invalid strategy " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов btree \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "номером Ñтратегии %d" + +#~ msgid "" +#~ "btree operator family \"%s\" contains invalid ORDER BY specification for " +#~ "operator %s" +#~ msgstr "" +#~ "ÑемейÑтво операторов btree \"%s\" Ñодержит некорректное определение ORDER " +#~ "BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" + +#~ msgid "" +#~ "btree operator family \"%s\" contains operator %s with wrong signature" +#~ msgstr "" +#~ "ÑемейÑтво операторов btree \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением" + +#~ msgid "" +#~ "btree operator family \"%s\" is missing operator(s) for types %s and %s" +#~ msgstr "" +#~ "в ÑемейÑтве операторов btree \"%s\" нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" + +#~ msgid "btree operator class \"%s\" is missing operator(s)" +#~ msgstr "в клаÑÑе операторов btree \"%s\" нет оператора(ов)" + +#~ msgid "btree operator family \"%s\" is missing cross-type operator(s)" +#~ msgstr "в ÑемейÑтве операторов btree \"%s\" нет межтипового оператора(ов)" + +#~ msgid "" +#~ "spgist operator family \"%s\" contains support procedure %s with cross-" +#~ "type registration" +#~ msgstr "" +#~ "ÑемейÑтво операторов spgist \"%s\" Ñодержит опорную процедуру %s Ñ " +#~ "межтиповой региÑтрацией" + +#~ msgid "" +#~ "spgist operator family \"%s\" contains function %s with invalid support " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов spgist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "опорным номером %d" + +#~ msgid "" +#~ "spgist operator family \"%s\" contains function %s with wrong signature " +#~ "for support number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов spgist \"%s\" Ñодержит функцию %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением Ð´Ð»Ñ Ð¾Ð¿Ð¾Ñ€Ð½Ð¾Ð³Ð¾ номера %d" + +#~ msgid "" +#~ "spgist operator family \"%s\" contains operator %s with invalid strategy " +#~ "number %d" +#~ msgstr "" +#~ "ÑемейÑтво операторов spgist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ñ€Ð°Ð²Ð¸Ð»ÑŒÐ½Ñ‹Ð¼ " +#~ "номером Ñтратегии %d" + +#~ msgid "" +#~ "spgist operator family \"%s\" contains invalid ORDER BY specification for " +#~ "operator %s" +#~ msgstr "" +#~ "ÑемейÑтво операторов spgist \"%s\" Ñодержит некорректное определение " +#~ "ORDER BY Ð´Ð»Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° %s" + +#~ msgid "" +#~ "spgist operator family \"%s\" contains operator %s with wrong signature" +#~ msgstr "" +#~ "ÑемейÑтво операторов spgist \"%s\" Ñодержит оператор %s Ñ Ð½ÐµÐ¿Ð¾Ð´Ñ…Ð¾Ð´Ñщим " +#~ "объÑвлением" + +#~ msgid "" +#~ "spgist operator family \"%s\" is missing operator(s) for types %s and %s" +#~ msgstr "" +#~ "в ÑемейÑтве операторов spgist \"%s\" нет оператора(ов) Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² %s и %s" + +#~ msgid "spgist operator class \"%s\" is missing operator(s)" +#~ msgstr "в клаÑÑе операторов spgist \"%s\" нет оператора(ов)" + +#~ msgid "%s." +#~ msgstr "%s." + +#~ msgid "cannot create temporary tables in parallel mode" +#~ msgstr "Ñоздавать временные таблицы в параллельном режиме нельзÑ" + +#~ msgid "could not determine data type for argument 1" +#~ msgstr "не удалоÑÑŒ определить тип данных аргумента 1" + +#~ msgid "could not determine data type for argument 2" +#~ msgstr "не удалоÑÑŒ определить тип данных аргумента 2" + +#~ msgid "argument %d: could not determine data type" +#~ msgstr "аргумент %d: не удалоÑÑŒ определить тип данных" + +#~ msgid "Transaction ID %u finished; no more running transactions." +#~ msgstr "Ð¢Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ñ %u завершена, больше активных транзакций нет." + +#~ msgid "%u transaction needs to finish." +#~ msgid_plural "%u transactions need to finish." +#~ msgstr[0] "Ðеобходимо дождатьÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¹ (%u)." +#~ msgstr[1] "Ðеобходимо дождатьÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¹ (%u)." +#~ msgstr[2] "Ðеобходимо дождатьÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ñ‚Ñ€Ð°Ð½Ð·Ð°ÐºÑ†Ð¸Ð¹ (%u)." + #~ msgid "wrong range of array subscripts" #~ msgstr "неправильный диапазон индекÑов маÑÑивов" diff --git a/src/bin/initdb/po/es.po b/src/bin/initdb/po/es.po index 739672c965..ca89853f58 100644 --- a/src/bin/initdb/po/es.po +++ b/src/bin/initdb/po/es.po @@ -10,8 +10,8 @@ msgid "" msgstr "" "Project-Id-Version: initdb (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" -"PO-Revision-Date: 2017-05-19 18:35-0400\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" +"PO-Revision-Date: 2017-08-28 11:37+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL-es-Ayuda \n" "Language: es\n" @@ -993,51 +993,3 @@ msgstr "" "\n" " %s%s%spg_ctl%s -D %s%s%s -l archivo_de_log start\n" "\n" - -#~ msgid "copying template1 to postgres ... " -#~ msgstr "copiando template1 a postgres ... " - -#~ msgid "copying template1 to template0 ... " -#~ msgstr "copiando template1 a template0 ... " - -#~ msgid "vacuuming database template1 ... " -#~ msgstr "haciendo vacuum a la base de datos template1 ... " - -#~ msgid "loading PL/pgSQL server-side language ... " -#~ msgstr "instalando el lenguaje PL/pgSQL ... " - -#~ msgid "creating information schema ... " -#~ msgstr "creando el esquema de información ... " - -#~ msgid "setting privileges on built-in objects ... " -#~ msgstr "estableciendo privilegios en objetos predefinidos ... " - -#~ msgid "creating dictionaries ... " -#~ msgstr "creando diccionarios ... " - -#~ msgid "creating conversions ... " -#~ msgstr "creando conversiones ... " - -#~ msgid "not supported on this platform\n" -#~ msgstr "no está soportado en esta plataforma\n" - -#~ msgid "creating collations ... " -#~ msgstr "creando algoritmos de ordenamiento ... " - -#~ msgid "loading system objects' descriptions ... " -#~ msgstr "cargando las descripciones de los objetos del sistema ... " - -#~ msgid "creating system views ... " -#~ msgstr "creando las vistas de sistema ... " - -#~ msgid "initializing dependencies ... " -#~ msgstr "inicializando dependencias ... " - -#~ msgid "setting password ... " -#~ msgstr "estableciendo contraseña ... " - -#~ msgid "initializing pg_authid ... " -#~ msgstr "inicializando pg_authid ... " - -#~ msgid "creating template1 database in %s/base/1 ... " -#~ msgstr "creando base de datos template1 en %s/base/1 ... " diff --git a/src/bin/initdb/po/ru.po b/src/bin/initdb/po/ru.po index e56222bb9d..5d1ca25526 100644 --- a/src/bin/initdb/po/ru.po +++ b/src/bin/initdb/po/ru.po @@ -6,14 +6,14 @@ # Sergey Burladyan , 2009. # Andrey Sudnik , 2010. # Dmitriy Olshevskiy , 2014. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: initdb (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:13+0000\n" -"PO-Revision-Date: 2016-11-24 11:56+0300\n" +"POT-Creation-Date: 2017-02-09 21:13+0000\n" +"PO-Revision-Date: 2017-03-28 20:31+0300\n" "Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" "Language: ru\n" diff --git a/src/bin/pg_basebackup/po/es.po b/src/bin/pg_basebackup/po/es.po index dc6e71bf1d..45247c4d3f 100644 --- a/src/bin/pg_basebackup/po/es.po +++ b/src/bin/pg_basebackup/po/es.po @@ -9,8 +9,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_basebackup (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" -"PO-Revision-Date: 2017-05-19 18:18-0400\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" +"PO-Revision-Date: 2017-08-28 11:37+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: Spanish \n" "Language: es\n" @@ -265,7 +265,7 @@ msgstr "" msgid "%s: could not read from ready pipe: %s\n" msgstr "%s: no se pudo leer desde la tubería: %s\n" -#: pg_basebackup.c:321 pg_basebackup.c:424 pg_basebackup.c:1906 +#: pg_basebackup.c:321 pg_basebackup.c:424 pg_basebackup.c:1910 #: streamutil.c:293 #, c-format msgid "%s: could not parse transaction log location \"%s\"\n" @@ -276,7 +276,7 @@ msgstr "%s: no se pudo interpretar la ubicación del registro transaccional «%s msgid "%s: could not create pipe for background process: %s\n" msgstr "%s: no se pudo crear la tubería para el proceso en segundo plano: %s\n" -#: pg_basebackup.c:462 pg_basebackup.c:517 pg_basebackup.c:1265 +#: pg_basebackup.c:462 pg_basebackup.c:517 pg_basebackup.c:1269 #, c-format msgid "%s: could not create directory \"%s\": %s\n" msgstr "%s: no se pudo crear el directorio «%s»: %s\n" @@ -357,233 +357,233 @@ msgstr "%s: la tasa de transferencia «%s» está fuera de rango\n" msgid "%s: could not write to compressed file \"%s\": %s\n" msgstr "%s: no se pudo escribir al archivo comprimido «%s»: %s\n" -#: pg_basebackup.c:762 pg_basebackup.c:1359 pg_basebackup.c:1584 +#: pg_basebackup.c:762 pg_basebackup.c:1363 pg_basebackup.c:1588 #, c-format msgid "%s: could not write to file \"%s\": %s\n" msgstr "%s: no se pudo escribir al archivo «%s»: %s\n" -#: pg_basebackup.c:817 pg_basebackup.c:838 pg_basebackup.c:866 +#: pg_basebackup.c:821 pg_basebackup.c:842 pg_basebackup.c:870 #, c-format msgid "%s: could not set compression level %d: %s\n" msgstr "%s: no se pudo definir el nivel de compresión %d: %s\n" -#: pg_basebackup.c:887 +#: pg_basebackup.c:891 #, c-format msgid "%s: could not create compressed file \"%s\": %s\n" msgstr "%s: no se pudo crear el archivo comprimido «%s»: %s\n" -#: pg_basebackup.c:898 pg_basebackup.c:1319 pg_basebackup.c:1577 +#: pg_basebackup.c:902 pg_basebackup.c:1323 pg_basebackup.c:1581 #, c-format msgid "%s: could not create file \"%s\": %s\n" msgstr "%s: no se pudo crear el archivo «%s»: %s\n" -#: pg_basebackup.c:910 pg_basebackup.c:1174 +#: pg_basebackup.c:914 pg_basebackup.c:1178 #, c-format msgid "%s: could not get COPY data stream: %s" msgstr "%s: no se pudo obtener un flujo de datos COPY: %s" -#: pg_basebackup.c:967 +#: pg_basebackup.c:971 #, c-format msgid "%s: could not close compressed file \"%s\": %s\n" msgstr "%s: no se pudo cerrar el archivo comprimido «%s»: %s\n" -#: pg_basebackup.c:980 pg_recvlogical.c:580 receivelog.c:206 receivelog.c:354 +#: pg_basebackup.c:984 pg_recvlogical.c:580 receivelog.c:206 receivelog.c:354 #: receivelog.c:743 #, c-format msgid "%s: could not close file \"%s\": %s\n" msgstr "%s: no se pudo cerrar el archivo «%s»: %s\n" -#: pg_basebackup.c:991 pg_basebackup.c:1203 pg_recvlogical.c:446 +#: pg_basebackup.c:995 pg_basebackup.c:1207 pg_recvlogical.c:446 #: receivelog.c:1024 #, c-format msgid "%s: could not read COPY data: %s" msgstr "%s: no fue posible leer datos COPY: %s" -#: pg_basebackup.c:1217 +#: pg_basebackup.c:1221 #, c-format msgid "%s: invalid tar block header size: %d\n" msgstr "%s: tamaño de bloque de cabecera de tar no válido: %d\n" -#: pg_basebackup.c:1273 +#: pg_basebackup.c:1277 #, c-format msgid "%s: could not set permissions on directory \"%s\": %s\n" msgstr "%s: no se pudo definir los permisos en el directorio «%s»: %s\n" -#: pg_basebackup.c:1297 +#: pg_basebackup.c:1301 #, c-format msgid "%s: could not create symbolic link from \"%s\" to \"%s\": %s\n" msgstr "%s: no se pudo crear un enlace simbólico desde «%s» a «%s»: %s\n" -#: pg_basebackup.c:1306 +#: pg_basebackup.c:1310 #, c-format msgid "%s: unrecognized link indicator \"%c\"\n" msgstr "%s: indicador de enlace «%c» no reconocido\n" -#: pg_basebackup.c:1326 +#: pg_basebackup.c:1330 #, c-format msgid "%s: could not set permissions on file \"%s\": %s\n" msgstr "%s: no se pudo definir los permisos al archivo «%s»: %s\n" -#: pg_basebackup.c:1385 +#: pg_basebackup.c:1389 #, c-format msgid "%s: COPY stream ended before last file was finished\n" msgstr "%s: el flujo COPY terminó antes que el último archivo estuviera completo\n" -#: pg_basebackup.c:1471 pg_basebackup.c:1491 pg_basebackup.c:1498 -#: pg_basebackup.c:1552 +#: pg_basebackup.c:1475 pg_basebackup.c:1495 pg_basebackup.c:1502 +#: pg_basebackup.c:1556 #, c-format msgid "%s: out of memory\n" msgstr "%s: memoria agotada\n" -#: pg_basebackup.c:1629 +#: pg_basebackup.c:1633 #, c-format msgid "%s: incompatible server version %s\n" msgstr "%s: versión del servidor %s incompatible\n" -#: pg_basebackup.c:1666 +#: pg_basebackup.c:1670 #, c-format msgid "%s: initiating base backup, waiting for checkpoint to complete\n" msgstr "%s: iniciando el respaldo base, esperando que el checkpoint se complete\n" -#: pg_basebackup.c:1684 pg_recvlogical.c:264 receivelog.c:541 receivelog.c:592 +#: pg_basebackup.c:1688 pg_recvlogical.c:264 receivelog.c:541 receivelog.c:592 #: receivelog.c:632 streamutil.c:263 streamutil.c:367 streamutil.c:413 #, c-format msgid "%s: could not send replication command \"%s\": %s" msgstr "%s: no se pudo ejecutar la orden de replicación «%s»: %s" -#: pg_basebackup.c:1695 +#: pg_basebackup.c:1699 #, c-format msgid "%s: could not initiate base backup: %s" msgstr "%s: no se pudo iniciar el respaldo base: %s" -#: pg_basebackup.c:1702 +#: pg_basebackup.c:1706 #, c-format msgid "%s: server returned unexpected response to BASE_BACKUP command; got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: el servidor envió una respuesta inesperada a la orden BASE_BACKUP; se obtuvieron %d filas y %d campos, se esperaban %d filas y %d campos\n" -#: pg_basebackup.c:1710 +#: pg_basebackup.c:1714 #, c-format msgid "%s: checkpoint completed\n" msgstr "%s: el checkpoint se ha completado\n" -#: pg_basebackup.c:1725 +#: pg_basebackup.c:1729 #, c-format msgid "transaction log start point: %s on timeline %u\n" msgstr "punto de inicio del registro transaccional: %s en el timeline %u\n" -#: pg_basebackup.c:1734 +#: pg_basebackup.c:1738 #, c-format msgid "%s: could not get backup header: %s" msgstr "%s: no se pudo obtener la cabecera de respaldo: %s" -#: pg_basebackup.c:1740 +#: pg_basebackup.c:1744 #, c-format msgid "%s: no data returned from server\n" msgstr "%s: el servidor no retornó datos\n" -#: pg_basebackup.c:1772 +#: pg_basebackup.c:1776 #, c-format msgid "%s: can only write single tablespace to stdout, database has %d\n" msgstr "%s: sólo se puede escribir un tablespace a stdout, la base de datos tiene %d\n" -#: pg_basebackup.c:1784 +#: pg_basebackup.c:1788 #, c-format msgid "%s: starting background WAL receiver\n" msgstr "%s: iniciando el receptor de WAL en segundo plano\n" -#: pg_basebackup.c:1815 +#: pg_basebackup.c:1819 #, c-format msgid "%s: could not get transaction log end position from server: %s" msgstr "%s: no se pudo obtener la posición final del registro transaccional del servidor: %s" -#: pg_basebackup.c:1822 +#: pg_basebackup.c:1826 #, c-format msgid "%s: no transaction log end position returned from server\n" msgstr "%s: el servidor no retornó la posición final del registro transaccional\n" -#: pg_basebackup.c:1834 +#: pg_basebackup.c:1838 #, c-format msgid "%s: final receive failed: %s" msgstr "%s: la recepción final falló: %s" -#: pg_basebackup.c:1858 +#: pg_basebackup.c:1862 #, c-format msgid "%s: waiting for background process to finish streaming ...\n" msgstr "%s: esperando que el proceso en segundo plano complete el flujo...\n" -#: pg_basebackup.c:1864 +#: pg_basebackup.c:1868 #, c-format msgid "%s: could not send command to background pipe: %s\n" msgstr "%s: no se pudo enviar una orden a la tubería de segundo plano: %s\n" -#: pg_basebackup.c:1873 +#: pg_basebackup.c:1877 #, c-format msgid "%s: could not wait for child process: %s\n" msgstr "%s: no se pudo esperar al proceso hijo: %s\n" -#: pg_basebackup.c:1879 +#: pg_basebackup.c:1883 #, c-format msgid "%s: child %d died, expected %d\n" msgstr "%s: el hijo %d murió, pero se esperaba al %d\n" -#: pg_basebackup.c:1885 +#: pg_basebackup.c:1889 #, c-format msgid "%s: child process did not exit normally\n" msgstr "%s: el proceso hijo no terminó normalmente\n" -#: pg_basebackup.c:1891 +#: pg_basebackup.c:1895 #, c-format msgid "%s: child process exited with error %d\n" msgstr "%s: el proceso hijo terminó con código de salida %d\n" -#: pg_basebackup.c:1918 +#: pg_basebackup.c:1922 #, c-format msgid "%s: could not wait for child thread: %s\n" msgstr "%s: no se pudo esperar el hilo hijo: %s\n" -#: pg_basebackup.c:1925 +#: pg_basebackup.c:1929 #, c-format msgid "%s: could not get child thread exit status: %s\n" msgstr "%s: no se pudo obtener la cabecera de respaldo: %s\n" -#: pg_basebackup.c:1931 +#: pg_basebackup.c:1935 #, c-format msgid "%s: child thread exited with error %u\n" msgstr "%s: el hilo hijo terminó con error %u\n" -#: pg_basebackup.c:2021 +#: pg_basebackup.c:2025 #, c-format msgid "%s: invalid output format \"%s\", must be \"plain\" or \"tar\"\n" msgstr "%s: formato de salida «%s» no válido, debe ser «plain» o «tar»\n" -#: pg_basebackup.c:2042 pg_basebackup.c:2054 +#: pg_basebackup.c:2046 pg_basebackup.c:2058 #, c-format msgid "%s: cannot specify both --xlog and --xlog-method\n" msgstr "%s: no se puede tanto --xlog como --xlog-method\n" -#: pg_basebackup.c:2069 +#: pg_basebackup.c:2073 #, c-format msgid "%s: invalid xlog-method option \"%s\", must be \"fetch\" or \"stream\"\n" msgstr "%s: opción de xlog-method «%s» no válida, debe ser «fetch» o «stream»\n" -#: pg_basebackup.c:2091 +#: pg_basebackup.c:2095 #, c-format msgid "%s: invalid compression level \"%s\"\n" msgstr "%s: valor de compresión «%s» no válido\n" -#: pg_basebackup.c:2103 +#: pg_basebackup.c:2107 #, c-format msgid "%s: invalid checkpoint argument \"%s\", must be \"fast\" or \"spread\"\n" msgstr "%s: argumento de checkpoint «%s» no válido, debe ser «fast» o «spread»\n" -#: pg_basebackup.c:2130 pg_receivexlog.c:445 pg_recvlogical.c:763 +#: pg_basebackup.c:2134 pg_receivexlog.c:445 pg_recvlogical.c:763 #, c-format msgid "%s: invalid status interval \"%s\"\n" msgstr "%s: intervalo de estado «%s» no válido\n" -#: pg_basebackup.c:2146 pg_basebackup.c:2160 pg_basebackup.c:2171 -#: pg_basebackup.c:2184 pg_basebackup.c:2194 pg_basebackup.c:2204 -#: pg_basebackup.c:2216 pg_basebackup.c:2227 pg_receivexlog.c:477 +#: pg_basebackup.c:2150 pg_basebackup.c:2164 pg_basebackup.c:2175 +#: pg_basebackup.c:2188 pg_basebackup.c:2198 pg_basebackup.c:2208 +#: pg_basebackup.c:2220 pg_basebackup.c:2231 pg_receivexlog.c:477 #: pg_receivexlog.c:491 pg_receivexlog.c:499 pg_receivexlog.c:509 #: pg_receivexlog.c:520 pg_recvlogical.c:790 pg_recvlogical.c:804 #: pg_recvlogical.c:815 pg_recvlogical.c:823 pg_recvlogical.c:831 @@ -592,52 +592,52 @@ msgstr "%s: intervalo de estado «%s» no válido\n" msgid "Try \"%s --help\" for more information.\n" msgstr "Use «%s --help» para obtener más información.\n" -#: pg_basebackup.c:2158 pg_receivexlog.c:489 pg_recvlogical.c:802 +#: pg_basebackup.c:2162 pg_receivexlog.c:489 pg_recvlogical.c:802 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: demasiados argumentos en la línea de órdenes (el primero es «%s»)\n" -#: pg_basebackup.c:2170 pg_receivexlog.c:519 +#: pg_basebackup.c:2174 pg_receivexlog.c:519 #, c-format msgid "%s: no target directory specified\n" msgstr "%s: no se especificó un directorio de salida\n" -#: pg_basebackup.c:2182 +#: pg_basebackup.c:2186 #, c-format msgid "%s: only tar mode backups can be compressed\n" msgstr "%s: sólo los respaldos de modo tar pueden ser comprimidos\n" -#: pg_basebackup.c:2192 +#: pg_basebackup.c:2196 #, c-format msgid "%s: WAL streaming can only be used in plain mode\n" msgstr "%s: el flujo de WAL sólo puede usar en modo «plain»\n" -#: pg_basebackup.c:2202 +#: pg_basebackup.c:2206 #, c-format msgid "%s: replication slots can only be used with WAL streaming\n" msgstr "%s: los slots de replicación sólo pueden usarse con flujo de WAL\n" -#: pg_basebackup.c:2214 +#: pg_basebackup.c:2218 #, c-format msgid "%s: transaction log directory location can only be specified in plain mode\n" msgstr "%s: la ubicación del registro transaccional sólo puede especificarse en modo «plain»\n" -#: pg_basebackup.c:2225 +#: pg_basebackup.c:2229 #, c-format msgid "%s: transaction log directory location must be an absolute path\n" msgstr "%s: la ubicación del registro transaccional debe ser una ruta absoluta\n" -#: pg_basebackup.c:2237 +#: pg_basebackup.c:2241 #, c-format msgid "%s: this build does not support compression\n" msgstr "%s: esta instalación no soporta compresión\n" -#: pg_basebackup.c:2264 +#: pg_basebackup.c:2268 #, c-format msgid "%s: could not create symbolic link \"%s\": %s\n" msgstr "%s: no se pudo crear el enlace simbólico «%s»: %s\n" -#: pg_basebackup.c:2269 +#: pg_basebackup.c:2273 #, c-format msgid "%s: symlinks are not supported on this platform\n" msgstr "%s: los enlaces simbólicos no están soportados en esta plataforma\n" @@ -1161,12 +1161,3 @@ msgstr "%s: no se pudo create el slot de replicación «%s»: se obtuvieron %d f #, c-format msgid "%s: could not drop replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields\n" msgstr "%s: no se pudo eliminar el slot de replicación «%s»: se obtuvieron %d filas y %d campos, se esperaban %d filas y %d campos\n" - -#~ msgid "%s: socket not open" -#~ msgstr "%s: socket no abierto" - -#~ msgid "%s: could not parse file mode\n" -#~ msgstr "%s: nose pudo interpretar el modo del archivo\n" - -#~ msgid "%s: could not parse file size\n" -#~ msgstr "%s: no se pudo interpretar el tamaño del archivo\n" diff --git a/src/bin/pg_basebackup/po/ru.po b/src/bin/pg_basebackup/po/ru.po index 09b27bd358..db7a1923a9 100644 --- a/src/bin/pg_basebackup/po/ru.po +++ b/src/bin/pg_basebackup/po/ru.po @@ -1,14 +1,14 @@ # Russian message translation file for pg_basebackup # Copyright (C) 2012-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: pg_basebackup (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-10-24 02:44+0000\n" -"PO-Revision-Date: 2016-09-20 12:00+0300\n" +"POT-Creation-Date: 2017-08-17 17:52+0000\n" +"PO-Revision-Date: 2017-05-27 16:06+0300\n" "Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" "Language: ru\n" @@ -114,10 +114,10 @@ msgstr "" #, c-format msgid "" " -R, --write-recovery-conf\n" -" write recovery.conf after backup\n" +" write recovery.conf for replication\n" msgstr "" " -R, --write-recovery-conf\n" -" запиÑать recovery.conf поÑле копированиÑ\n" +" запиÑать recovery.conf Ð´Ð»Ñ Ñ€ÐµÐ¿Ð»Ð¸ÐºÐ°Ñ†Ð¸Ð¸\n" #: pg_basebackup.c:244 pg_receivexlog.c:74 #, c-format @@ -282,7 +282,7 @@ msgstr "" msgid "%s: could not read from ready pipe: %s\n" msgstr "%s: не удалоÑÑŒ прочитать из готового канала: %s\n" -#: pg_basebackup.c:321 pg_basebackup.c:424 pg_basebackup.c:1895 +#: pg_basebackup.c:321 pg_basebackup.c:424 pg_basebackup.c:1910 #: streamutil.c:293 #, c-format msgid "%s: could not parse transaction log location \"%s\"\n" @@ -293,7 +293,7 @@ msgstr "%s: не удалоÑÑŒ разобрать положение в жур msgid "%s: could not create pipe for background process: %s\n" msgstr "%s: не удалоÑÑŒ Ñоздать канал Ð´Ð»Ñ Ñ„Ð¾Ð½Ð¾Ð²Ð¾Ð³Ð¾ процеÑÑа: %s\n" -#: pg_basebackup.c:462 pg_basebackup.c:517 pg_basebackup.c:1265 +#: pg_basebackup.c:462 pg_basebackup.c:517 pg_basebackup.c:1269 #, c-format msgid "%s: could not create directory \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ Ñоздать каталог \"%s\": %s\n" @@ -377,101 +377,108 @@ msgstr "%s: ÑкороÑÑ‚ÑŒ передачи \"%s\" вне диапазона\n msgid "%s: could not write to compressed file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ запиÑать файл Ñжатого архива \"%s\": %s\n" -#: pg_basebackup.c:762 pg_basebackup.c:1359 pg_basebackup.c:1584 +#: pg_basebackup.c:762 pg_basebackup.c:1363 pg_basebackup.c:1588 #, c-format msgid "%s: could not write to file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ запиÑать файл \"%s\": %s\n" -#: pg_basebackup.c:817 pg_basebackup.c:838 pg_basebackup.c:866 +#: pg_basebackup.c:821 pg_basebackup.c:842 pg_basebackup.c:870 #, c-format msgid "%s: could not set compression level %d: %s\n" msgstr "%s: не удалоÑÑŒ уÑтановить уровень ÑÐ¶Ð°Ñ‚Ð¸Ñ %d: %s\n" -#: pg_basebackup.c:887 +#: pg_basebackup.c:891 #, c-format msgid "%s: could not create compressed file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ Ñоздать файл Ñжатого архива \"%s\": %s\n" -#: pg_basebackup.c:898 pg_basebackup.c:1319 pg_basebackup.c:1577 +#: pg_basebackup.c:902 pg_basebackup.c:1323 pg_basebackup.c:1581 #, c-format msgid "%s: could not create file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ Ñоздать файл \"%s\": %s\n" -#: pg_basebackup.c:910 pg_basebackup.c:1174 +#: pg_basebackup.c:914 pg_basebackup.c:1178 #, c-format msgid "%s: could not get COPY data stream: %s" msgstr "%s: не удалоÑÑŒ получить поток данных COPY: %s" -#: pg_basebackup.c:967 +#: pg_basebackup.c:971 #, c-format msgid "%s: could not close compressed file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ закрыть Ñжатый файл \"%s\": %s\n" -#: pg_basebackup.c:980 pg_recvlogical.c:580 receivelog.c:206 receivelog.c:354 +#: pg_basebackup.c:984 pg_recvlogical.c:580 receivelog.c:206 receivelog.c:354 #: receivelog.c:743 #, c-format msgid "%s: could not close file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ закрыть файл \"%s\": %s\n" -#: pg_basebackup.c:991 pg_basebackup.c:1203 pg_recvlogical.c:446 +#: pg_basebackup.c:995 pg_basebackup.c:1207 pg_recvlogical.c:446 #: receivelog.c:1024 #, c-format msgid "%s: could not read COPY data: %s" msgstr "%s: не удалоÑÑŒ прочитать данные COPY: %s" -#: pg_basebackup.c:1217 +#: pg_basebackup.c:1221 #, c-format msgid "%s: invalid tar block header size: %d\n" msgstr "%s: неверный размер заголовка блока tar: %d\n" -#: pg_basebackup.c:1273 +#: pg_basebackup.c:1277 #, c-format msgid "%s: could not set permissions on directory \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ уÑтановить права Ð´Ð»Ñ ÐºÐ°Ñ‚Ð°Ð»Ð¾Ð³Ð° \"%s\": %s\n" -#: pg_basebackup.c:1297 +#: pg_basebackup.c:1301 #, c-format msgid "%s: could not create symbolic link from \"%s\" to \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ Ñоздать ÑимволичеÑкую ÑÑылку \"%s\" в \"%s\": %s\n" -#: pg_basebackup.c:1306 +#: pg_basebackup.c:1310 #, c-format msgid "%s: unrecognized link indicator \"%c\"\n" msgstr "%s: нераÑпознанный индикатор ÑвÑзи \"%c\"\n" -#: pg_basebackup.c:1326 +#: pg_basebackup.c:1330 #, c-format msgid "%s: could not set permissions on file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ уÑтановить права доÑтупа Ð´Ð»Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\": %s\n" -#: pg_basebackup.c:1385 +#: pg_basebackup.c:1389 #, c-format msgid "%s: COPY stream ended before last file was finished\n" msgstr "%s: поток COPY закончилÑÑ Ð´Ð¾ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ð¿Ð¾Ñледнего файла\n" -#: pg_basebackup.c:1471 pg_basebackup.c:1491 pg_basebackup.c:1498 -#: pg_basebackup.c:1552 +#: pg_basebackup.c:1475 pg_basebackup.c:1495 pg_basebackup.c:1502 +#: pg_basebackup.c:1556 #, c-format msgid "%s: out of memory\n" msgstr "%s: нехватка памÑти\n" -#: pg_basebackup.c:1629 +#: pg_basebackup.c:1633 #, c-format msgid "%s: incompatible server version %s\n" msgstr "%s: неÑовмеÑÑ‚Ð¸Ð¼Ð°Ñ Ð²ÐµÑ€ÑÐ¸Ñ Ñервера %s\n" -#: pg_basebackup.c:1676 pg_recvlogical.c:264 receivelog.c:541 receivelog.c:592 +#: pg_basebackup.c:1670 +#, c-format +msgid "%s: initiating base backup, waiting for checkpoint to complete\n" +msgstr "" +"%s: начинаетÑÑ Ð±Ð°Ð·Ð¾Ð²Ð¾Ðµ резервное копирование, ожидаетÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ðµ " +"контрольной точки\n" + +#: pg_basebackup.c:1688 pg_recvlogical.c:264 receivelog.c:541 receivelog.c:592 #: receivelog.c:632 streamutil.c:263 streamutil.c:367 streamutil.c:413 #, c-format msgid "%s: could not send replication command \"%s\": %s" msgstr "%s: не удалоÑÑŒ передать команду репликации \"%s\": %s" -#: pg_basebackup.c:1687 +#: pg_basebackup.c:1699 #, c-format msgid "%s: could not initiate base backup: %s" msgstr "%s: не удалоÑÑŒ инициализировать базовое резервное копирование: %s" -#: pg_basebackup.c:1694 +#: pg_basebackup.c:1706 #, c-format msgid "" "%s: server returned unexpected response to BASE_BACKUP command; got %d rows " @@ -482,103 +489,108 @@ msgstr "" #: pg_basebackup.c:1714 #, c-format +msgid "%s: checkpoint completed\n" +msgstr "%s: ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ° завершена\n" + +#: pg_basebackup.c:1729 +#, c-format msgid "transaction log start point: %s on timeline %u\n" msgstr "ÑÑ‚Ð°Ñ€Ñ‚Ð¾Ð²Ð°Ñ Ñ‚Ð¾Ñ‡ÐºÐ° журнала транзакций: %s на линии времени %u\n" -#: pg_basebackup.c:1723 +#: pg_basebackup.c:1738 #, c-format msgid "%s: could not get backup header: %s" msgstr "%s: не удалоÑÑŒ получить заголовок резервной копии: %s" -#: pg_basebackup.c:1729 +#: pg_basebackup.c:1744 #, c-format msgid "%s: no data returned from server\n" msgstr "%s: Ñервер не вернул данные\n" -#: pg_basebackup.c:1761 +#: pg_basebackup.c:1776 #, c-format msgid "%s: can only write single tablespace to stdout, database has %d\n" msgstr "" "%s: в stdout можно вывеÑти только одно табличное проÑтранÑтво, вÑего в СУБД " "их %d\n" -#: pg_basebackup.c:1773 +#: pg_basebackup.c:1788 #, c-format msgid "%s: starting background WAL receiver\n" msgstr "%s: запуÑк фонового процеÑÑа ÑÑ‡Ð¸Ñ‚Ñ‹Ð²Ð°Ð½Ð¸Ñ WAL\n" -#: pg_basebackup.c:1804 +#: pg_basebackup.c:1819 #, c-format msgid "%s: could not get transaction log end position from server: %s" msgstr "" "%s: не удалоÑÑŒ получить конечную позицию в журнале транзакций Ñ Ñервера: %s" -#: pg_basebackup.c:1811 +#: pg_basebackup.c:1826 #, c-format msgid "%s: no transaction log end position returned from server\n" msgstr "%s: Ñервер не вернул конечную позицию в журнале транзакций\n" -#: pg_basebackup.c:1823 +#: pg_basebackup.c:1838 #, c-format msgid "%s: final receive failed: %s" msgstr "%s: ошибка в конце передачи: %s" -#: pg_basebackup.c:1847 +#: pg_basebackup.c:1862 #, c-format msgid "%s: waiting for background process to finish streaming ...\n" msgstr "%s: ожидание Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ð¿Ð¾Ñ‚Ð¾ÐºÐ¾Ð²Ð¾Ð¹ передачи фоновым процеÑÑом...\n" -#: pg_basebackup.c:1853 +#: pg_basebackup.c:1868 #, c-format msgid "%s: could not send command to background pipe: %s\n" msgstr "%s: не удалоÑÑŒ отправить команду в канал фонового процеÑÑа: %s\n" -#: pg_basebackup.c:1862 +#: pg_basebackup.c:1877 #, c-format msgid "%s: could not wait for child process: %s\n" msgstr "%s: Ñбой при ожидании дочернего процеÑÑа: %s\n" -#: pg_basebackup.c:1868 +#: pg_basebackup.c:1883 #, c-format msgid "%s: child %d died, expected %d\n" msgstr "%s: завершилÑÑ Ð´Ð¾Ñ‡ÐµÑ€Ð½Ð¸Ð¹ процеÑÑ %d вмеÑто ожидаемого %d\n" -#: pg_basebackup.c:1874 +#: pg_basebackup.c:1889 #, c-format msgid "%s: child process did not exit normally\n" msgstr "%s: дочерний процеÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÑ‘Ð½ ненормально\n" -#: pg_basebackup.c:1880 +#: pg_basebackup.c:1895 #, c-format msgid "%s: child process exited with error %d\n" msgstr "%s: дочерний процеÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐ¸Ð»ÑÑ Ñ Ð¾ÑˆÐ¸Ð±ÐºÐ¾Ð¹ %d\n" -#: pg_basebackup.c:1907 +#: pg_basebackup.c:1922 #, c-format msgid "%s: could not wait for child thread: %s\n" msgstr "%s: Ñбой при ожидании дочернего потока: %s\n" -#: pg_basebackup.c:1914 +#: pg_basebackup.c:1929 #, c-format msgid "%s: could not get child thread exit status: %s\n" msgstr "%s: не удалоÑÑŒ получить ÑоÑтоÑние Ð·Ð°Ð²ÐµÑ€ÑˆÐµÐ½Ð¸Ñ Ð´Ð¾Ñ‡ÐµÑ€Ð½ÐµÐ³Ð¾ потока: %s\n" -#: pg_basebackup.c:1920 +#: pg_basebackup.c:1935 #, c-format msgid "%s: child thread exited with error %u\n" msgstr "%s: дочерний поток завершилÑÑ Ñ Ð¾ÑˆÐ¸Ð±ÐºÐ¾Ð¹ %u\n" -#: pg_basebackup.c:2010 +#: pg_basebackup.c:2025 #, c-format msgid "%s: invalid output format \"%s\", must be \"plain\" or \"tar\"\n" msgstr "%s: неверный формат вывода \"%s\", должен быть \"plain\" или \"tar\"\n" -#: pg_basebackup.c:2031 pg_basebackup.c:2043 +#: pg_basebackup.c:2046 pg_basebackup.c:2058 #, c-format msgid "%s: cannot specify both --xlog and --xlog-method\n" msgstr "%s: указать и --xlog, и --xlog-method одновременно нельзÑ\n" -#: pg_basebackup.c:2058 +#: pg_basebackup.c:2073 #, c-format msgid "" "%s: invalid xlog-method option \"%s\", must be \"fetch\" or \"stream\"\n" @@ -586,12 +598,12 @@ msgstr "" "%s: неверный аргумент Ð´Ð»Ñ xlog-method - \"%s\", допуÑкаетÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ \"fetch\" " "или \"stream\"\n" -#: pg_basebackup.c:2080 +#: pg_basebackup.c:2095 #, c-format msgid "%s: invalid compression level \"%s\"\n" msgstr "%s: неверный уровень ÑÐ¶Ð°Ñ‚Ð¸Ñ \"%s\"\n" -#: pg_basebackup.c:2092 +#: pg_basebackup.c:2107 #, c-format msgid "" "%s: invalid checkpoint argument \"%s\", must be \"fast\" or \"spread\"\n" @@ -599,14 +611,14 @@ msgstr "" "%s: неверный аргумент режима контрольных точек \"%s\", должен быть \"fast\" " "или \"spread\"\n" -#: pg_basebackup.c:2119 pg_receivexlog.c:445 pg_recvlogical.c:763 +#: pg_basebackup.c:2134 pg_receivexlog.c:445 pg_recvlogical.c:763 #, c-format msgid "%s: invalid status interval \"%s\"\n" msgstr "%s: неверный интервал Ñообщений о ÑоÑтоÑнии \"%s\"\n" -#: pg_basebackup.c:2135 pg_basebackup.c:2149 pg_basebackup.c:2160 -#: pg_basebackup.c:2173 pg_basebackup.c:2183 pg_basebackup.c:2193 -#: pg_basebackup.c:2205 pg_basebackup.c:2216 pg_receivexlog.c:477 +#: pg_basebackup.c:2150 pg_basebackup.c:2164 pg_basebackup.c:2175 +#: pg_basebackup.c:2188 pg_basebackup.c:2198 pg_basebackup.c:2208 +#: pg_basebackup.c:2220 pg_basebackup.c:2231 pg_receivexlog.c:477 #: pg_receivexlog.c:491 pg_receivexlog.c:499 pg_receivexlog.c:509 #: pg_receivexlog.c:520 pg_recvlogical.c:790 pg_recvlogical.c:804 #: pg_recvlogical.c:815 pg_recvlogical.c:823 pg_recvlogical.c:831 @@ -615,33 +627,33 @@ msgstr "%s: неверный интервал Ñообщений о ÑоÑÑ‚Ð¾Ñ msgid "Try \"%s --help\" for more information.\n" msgstr "Ð”Ð»Ñ Ð´Ð¾Ð¿Ð¾Ð»Ð½Ð¸Ñ‚ÐµÐ»ÑŒÐ½Ð¾Ð¹ информации попробуйте \"%s --help\".\n" -#: pg_basebackup.c:2147 pg_receivexlog.c:489 pg_recvlogical.c:802 +#: pg_basebackup.c:2162 pg_receivexlog.c:489 pg_recvlogical.c:802 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: Ñлишком много аргументов командной Ñтроки (первый: \"%s\")\n" -#: pg_basebackup.c:2159 pg_receivexlog.c:519 +#: pg_basebackup.c:2174 pg_receivexlog.c:519 #, c-format msgid "%s: no target directory specified\n" msgstr "%s: целевой каталог не указан\n" -#: pg_basebackup.c:2171 +#: pg_basebackup.c:2186 #, c-format msgid "%s: only tar mode backups can be compressed\n" msgstr "%s: Ñжимать можно только резервные копии в архиве tar\n" -#: pg_basebackup.c:2181 +#: pg_basebackup.c:2196 #, c-format msgid "%s: WAL streaming can only be used in plain mode\n" msgstr "%s: Ð¿Ð¾Ñ‚Ð¾ÐºÐ¾Ð²Ð°Ñ Ð¿ÐµÑ€ÐµÐ´Ð°Ñ‡Ð° WAL поддерживаетÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ в режиме plain\n" -#: pg_basebackup.c:2191 +#: pg_basebackup.c:2206 #, c-format msgid "%s: replication slots can only be used with WAL streaming\n" msgstr "" "%s: Ñлоты репликации можно иÑпользовать только при потоковой передаче WAL\n" -#: pg_basebackup.c:2203 +#: pg_basebackup.c:2218 #, c-format msgid "" "%s: transaction log directory location can only be specified in plain mode\n" @@ -649,24 +661,24 @@ msgstr "" "%s: раÑположение каталога журнала транзакций можно указать только в режиме " "plain\n" -#: pg_basebackup.c:2214 +#: pg_basebackup.c:2229 #, c-format msgid "%s: transaction log directory location must be an absolute path\n" msgstr "" "%s: раÑположение каталога журнала транзакций должно определÑÑ‚ÑŒÑÑ Ð°Ð±Ñолютным " "путём\n" -#: pg_basebackup.c:2226 +#: pg_basebackup.c:2241 #, c-format msgid "%s: this build does not support compression\n" msgstr "%s: Ñта Ñборка программы не поддерживает Ñжатие\n" -#: pg_basebackup.c:2253 +#: pg_basebackup.c:2268 #, c-format msgid "%s: could not create symbolic link \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ Ñоздать ÑимволичеÑкую ÑÑылку \"%s\": %s\n" -#: pg_basebackup.c:2258 +#: pg_basebackup.c:2273 #, c-format msgid "%s: symlinks are not supported on this platform\n" msgstr "%s: ÑимволичеÑкие ÑÑылки не поддерживаютÑÑ Ð² Ñтой ОС\n" @@ -694,7 +706,7 @@ msgstr "" msgid "" " -D, --directory=DIR receive transaction log files into this directory\n" msgstr "" -" -D, --directory=ПУТЬ ÑохранÑÑ‚ÑŒ файлы журналов транзакций в данный " +" -D, --directory=ПУТЬ ÑохранÑÑ‚ÑŒ файлы журнала транзакций в данный " "каталог\n" #: pg_receivexlog.c:70 pg_recvlogical.c:82 diff --git a/src/bin/pg_config/po/es.po b/src/bin/pg_config/po/es.po index 219587b928..60a5f9ae8b 100644 --- a/src/bin/pg_config/po/es.po +++ b/src/bin/pg_config/po/es.po @@ -9,7 +9,7 @@ msgid "" msgstr "" "Project-Id-Version: pg_config (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" "PO-Revision-Date: 2016-05-23 09:38-0500\n" "Last-Translator: Carlos Chapi \n" "Language-Team: es \n" diff --git a/src/bin/pg_controldata/po/es.po b/src/bin/pg_controldata/po/es.po index 8bc79e950b..e15c5ac8b3 100644 --- a/src/bin/pg_controldata/po/es.po +++ b/src/bin/pg_controldata/po/es.po @@ -11,7 +11,7 @@ msgid "" msgstr "" "Project-Id-Version: pg_controldata (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:55+0000\n" +"POT-Creation-Date: 2017-08-27 21:53+0000\n" "PO-Revision-Date: 2016-05-23 09:44-0500\n" "Last-Translator: Carlos Chapi \n" "Language-Team: Castellano \n" diff --git a/src/bin/pg_controldata/po/ru.po b/src/bin/pg_controldata/po/ru.po index d146c99bbb..20dc403667 100644 --- a/src/bin/pg_controldata/po/ru.po +++ b/src/bin/pg_controldata/po/ru.po @@ -4,7 +4,7 @@ # Serguei A. Mokhov , 2002-2004. # Oleg Bartunov , 2004. # Andrey Sudnik , 2011. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" diff --git a/src/bin/pg_controldata/po/sv.po b/src/bin/pg_controldata/po/sv.po index b5c8fd028a..3d5da6f2ad 100644 --- a/src/bin/pg_controldata/po/sv.po +++ b/src/bin/pg_controldata/po/sv.po @@ -1,24 +1,70 @@ # Swedish message translation file for pg_controldata # This file is put in the public domain. -# Dennis Björklund , 2002, 2003, 2004, 2005, 2006. +# Dennis Björklund , 2002, 2003, 2004, 2005, 2006, 2017. # Mats Erik Andersson , 2014. # # Use these quotes: "%s" # msgid "" msgstr "" -"Project-Id-Version: PostgreSQL 9.4\n" +"Project-Id-Version: PostgreSQL 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2014-11-17 21:12+0000\n" -"PO-Revision-Date: 2014-11-19 23:46+0100\n" -"Last-Translator: Mats Erik Andersson \n" +"POT-Creation-Date: 2017-08-07 21:23+0000\n" +"PO-Revision-Date: 2017-08-08 06:20+0200\n" +"Last-Translator: Dennis Björklund \n" "Language-Team: Swedish \n" "Language: sv\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -#: pg_controldata.c:34 +#: ../../common/controldata_utils.c:56 +#, c-format +msgid "%s: could not open file \"%s\" for reading: %s\n" +msgstr "%s: kunde inte öppna fil \"%s\" för läsning: %s\n" + +#: ../../common/controldata_utils.c:69 +#, c-format +msgid "%s: could not read file \"%s\": %s\n" +msgstr "%s: kunde inte läsa fil \"%s\": %s\n" + +#: ../../common/controldata_utils.c:86 +msgid "calculated CRC checksum does not match value stored in file" +msgstr "" + +#: ../../common/controldata_utils.c:88 +#, c-format +msgid "" +"WARNING: Calculated CRC checksum does not match value stored in file.\n" +"Either the file is corrupt, or it has a different layout than this program\n" +"is expecting. The results below are untrustworthy.\n" +"\n" +msgstr "" +"VARNING: Beräknad CRC-kontrollsumma matchar inte det värde som har sparats i " +"filen.\n" +"Antingen är filen trasig, eller sÃ¥ har den en annan uppbyggnad än vad detta\n" +"program förväntade sig. Resultatet nedan är inte helt tillförlitligt.\n" +"\n" + +#: ../../common/controldata_utils.c:97 +msgid "byte ordering mismatch" +msgstr "byte-ordning stämmer inte" + +#: ../../common/controldata_utils.c:99 +#, c-format +msgid "" +"WARNING: possible byte ordering mismatch\n" +"The byte ordering used to store the pg_control file might not match the one\n" +"used by this program. In that case the results below would be incorrect, " +"and\n" +"the PostgreSQL installation would be incompatible with this data directory.\n" +msgstr "" +"VARNING: möjligt fel i talordning\n" +"Den endian-ordning med vilken pg_control lagrar filer passar kanske\n" +"inte detta program. I sÃ¥ fall kan nedanstÃ¥ende utfall vara oriktigt\n" +"och det installerade PostgreSQL vara oförenligt med databaskatalogen.\n" + +#: pg_controldata.c:33 #, c-format msgid "" "%s displays control information of a PostgreSQL database cluster.\n" @@ -27,24 +73,29 @@ msgstr "" "%s visar kontrollinformation om ett databaskluster för PostgreSQL.\n" "\n" -#: pg_controldata.c:35 +#: pg_controldata.c:34 #, c-format msgid "Usage:\n" msgstr "Användning:\n" -#: pg_controldata.c:36 +#: pg_controldata.c:35 #, c-format msgid " %s [OPTION] [DATADIR]\n" msgstr " %s [FLAGGA] [DATAKATALOG]\n" -#: pg_controldata.c:37 +#: pg_controldata.c:36 #, c-format msgid "" "\n" "Options:\n" msgstr "" "\n" -"Programväxlar:\n" +"Flaggor:\n" + +#: pg_controldata.c:37 +#, c-format +msgid " [-D] DATADIR data directory\n" +msgstr " [-D] DATADIR datakatalog\n" #: pg_controldata.c:38 #, c-format @@ -60,12 +111,14 @@ msgstr " -?, --help visa denna hjälp, avsluta sedan\n" #, c-format msgid "" "\n" -"If no data directory (DATADIR) is specified, the environment variable PGDATA\n" +"If no data directory (DATADIR) is specified, the environment variable " +"PGDATA\n" "is used.\n" "\n" msgstr "" "\n" -"Om ingen datakatalog (DATAKATALOG) har angivits sÃ¥ nyttjas omgivningsvariabeln\n" +"Om ingen datakatalog (DATAKATALOG) har angivits sÃ¥ nyttjas " +"omgivningsvariabeln\n" "PGDATA för detta syfte.\n" "\n" @@ -106,43 +159,24 @@ msgstr "i full drift" msgid "unrecognized status code" msgstr "okänd statuskod" -#: pg_controldata.c:83 +#: pg_controldata.c:81 msgid "unrecognized wal_level" msgstr "okänd wal_level" -#: pg_controldata.c:128 -#, c-format -msgid "%s: no data directory specified\n" -msgstr "%s: Ingen datakatalog angiven.\n" - -#: pg_controldata.c:129 +#: pg_controldata.c:127 pg_controldata.c:145 pg_controldata.c:153 #, c-format msgid "Try \"%s --help\" for more information.\n" -msgstr "Försök med '%s --help' för mer information.\n" +msgstr "Försök med \"%s --help\" för mer information.\n" -#: pg_controldata.c:137 +#: pg_controldata.c:143 #, c-format -msgid "%s: could not open file \"%s\" for reading: %s\n" -msgstr "%s: kunde inte öppna filen \"%s\" för läsning: %s\n" +msgid "%s: too many command-line arguments (first is \"%s\")\n" +msgstr "%s: för mÃ¥nga kommandoradsargument (första är \"%s\")\n" -#: pg_controldata.c:144 +#: pg_controldata.c:152 #, c-format -msgid "%s: could not read file \"%s\": %s\n" -msgstr "%s: kunde inte läsa filen \"%s\": %s\n" - -#: pg_controldata.c:158 -#, c-format -msgid "" -"WARNING: Calculated CRC checksum does not match value stored in file.\n" -"Either the file is corrupt, or it has a different layout than this program\n" -"is expecting. The results below are untrustworthy.\n" -"\n" -msgstr "" -"VARNING: Beräknad CRC-kontrollsumma matchar inte det värde som har sparats " -"i filen.\n" -"Antingen är filen trasig, eller sÃ¥ har den en annan uppbyggnad än vad detta\n" -"program förväntade sig. Resultatet nedan är inte helt tillförlitligt.\n" -"\n" +msgid "%s: no data directory specified\n" +msgstr "%s: ingen datakatalog angiven.\n" # Sep. 6th, 2014: # Insert additional spaces in translated strings for the @@ -150,282 +184,284 @@ msgstr "" # used for English is insufficient for Swedish. New indenting # is consistent for all reporting statements: six additional # space characters. -#: pg_controldata.c:192 +#: pg_controldata.c:190 #, c-format msgid "pg_control version number: %u\n" msgstr "Versionsnummer för pg_control: %u\n" -#: pg_controldata.c:195 -#, c-format -msgid "" -"WARNING: possible byte ordering mismatch\n" -"The byte ordering used to store the pg_control file might not match the one\n" -"used by this program. In that case the results below would be incorrect, and\n" -"the PostgreSQL installation would be incompatible with this data directory.\n" -msgstr "" -"VARNING: möjligt fel i talordning\n" -"Den endian-ordning med vilken pg_control lagrar filer passar kanske\n" -"inte detta program. I sÃ¥ fall kan nedanstÃ¥ende utfall vara oriktigt\n" -"och det installerade PostgreSQL vara oförenligt med databaskatalogen.\n" - -#: pg_controldata.c:199 +#: pg_controldata.c:192 #, c-format msgid "Catalog version number: %u\n" msgstr "Katalogversion: %u\n" -#: pg_controldata.c:201 +#: pg_controldata.c:194 #, c-format msgid "Database system identifier: %s\n" msgstr "Databasens systemidentifierare: %s\n" -#: pg_controldata.c:203 +#: pg_controldata.c:196 #, c-format msgid "Database cluster state: %s\n" msgstr "Databasklustrets tillstÃ¥nd: %s\n" -#: pg_controldata.c:205 +#: pg_controldata.c:198 #, c-format msgid "pg_control last modified: %s\n" msgstr "pg_control ändrades senast: %s\n" -#: pg_controldata.c:207 +#: pg_controldata.c:200 #, c-format msgid "Latest checkpoint location: %X/%X\n" -msgstr "Läge för senaste kontrollpunkt: %X/%X\n" +msgstr "Läge för senaste checkpoint: %X/%X\n" -#: pg_controldata.c:210 +#: pg_controldata.c:203 #, c-format msgid "Prior checkpoint location: %X/%X\n" -msgstr "Närmast föregÃ¥ende kontrollpunkt: %X/%X\n" +msgstr "Närmast föregÃ¥ende checkpoint: %X/%X\n" -#: pg_controldata.c:213 +#: pg_controldata.c:206 #, c-format msgid "Latest checkpoint's REDO location: %X/%X\n" -msgstr "REDO-läge för senaste kontrollpunkt: %X/%X\n" +msgstr "REDO-läge för senaste checkpoint: %X/%X\n" -#: pg_controldata.c:216 +#: pg_controldata.c:209 #, c-format msgid "Latest checkpoint's REDO WAL file: %s\n" -msgstr "REDO-WAL-fil vid senaste kontrollpunkt: %s\n" +msgstr "REDO-WAL-fil vid senaste checkpoint: %s\n" -#: pg_controldata.c:218 +#: pg_controldata.c:211 #, c-format msgid "Latest checkpoint's TimeLineID: %u\n" -msgstr "TimeLineID vid senaste kontrollpunkt: %u\n" +msgstr "TimeLineID vid senaste checkpoint: %u\n" -#: pg_controldata.c:220 +#: pg_controldata.c:213 #, c-format msgid "Latest checkpoint's PrevTimeLineID: %u\n" -msgstr "PrevTimeLineID vid senaste kontrollpunkt: %u\n" +msgstr "PrevTimeLineID vid senaste checkpoint: %u\n" -#: pg_controldata.c:222 +#: pg_controldata.c:215 #, c-format msgid "Latest checkpoint's full_page_writes: %s\n" -msgstr "Senaste kontrollpunktens full_page_writes: %s\n" +msgstr "Senaste checkpoint:ens full_page_writes: %s\n" -#: pg_controldata.c:223 pg_controldata.c:264 +#: pg_controldata.c:216 pg_controldata.c:261 pg_controldata.c:271 msgid "off" msgstr "av" -#: pg_controldata.c:223 pg_controldata.c:264 +#: pg_controldata.c:216 pg_controldata.c:261 pg_controldata.c:271 msgid "on" msgstr "pÃ¥" -#: pg_controldata.c:224 +#: pg_controldata.c:217 #, c-format -msgid "Latest checkpoint's NextXID: %u/%u\n" -msgstr "NextXID vid senaste kontrollpunkt: %u/%u\n" +msgid "Latest checkpoint's NextXID: %u:%u\n" +msgstr "NextXID vid senaste checkpoint: %u:%u\n" -#: pg_controldata.c:227 +#: pg_controldata.c:220 #, c-format msgid "Latest checkpoint's NextOID: %u\n" -msgstr "NextOID vid senaste kontrollpunkt: %u\n" +msgstr "NextOID vid senaste checkpoint: %u\n" -#: pg_controldata.c:229 +#: pg_controldata.c:222 #, c-format msgid "Latest checkpoint's NextMultiXactId: %u\n" -msgstr "NextMultiXactId vid senaste kontrollpunkt: %u\n" +msgstr "NextMultiXactId vid senaste checkpoint: %u\n" -#: pg_controldata.c:231 +#: pg_controldata.c:224 #, c-format msgid "Latest checkpoint's NextMultiOffset: %u\n" -msgstr "NextMultiOffset vid senaste kontrollpunkt: %u\n" +msgstr "NextMultiOffset vid senaste checkpoint: %u\n" -#: pg_controldata.c:233 +#: pg_controldata.c:226 #, c-format msgid "Latest checkpoint's oldestXID: %u\n" -msgstr "oldestXID vid senaste kontrollpunkt: %u\n" +msgstr "oldestXID vid senaste checkpoint: %u\n" -#: pg_controldata.c:235 +#: pg_controldata.c:228 #, c-format msgid "Latest checkpoint's oldestXID's DB: %u\n" -msgstr "DB för oldestXID vid senaste kontrollpunkt: %u\n" +msgstr "DB för oldestXID vid senaste checkpoint: %u\n" -#: pg_controldata.c:237 +#: pg_controldata.c:230 #, c-format msgid "Latest checkpoint's oldestActiveXID: %u\n" -msgstr "oldestActiveXID vid senaste kontrollpunkt: %u\n" +msgstr "oldestActiveXID vid senaste checkpoint: %u\n" -#: pg_controldata.c:239 +#: pg_controldata.c:232 #, c-format msgid "Latest checkpoint's oldestMultiXid: %u\n" -msgstr "oldestMultiXid vid senaste kontrollpunkt: %u\n" +msgstr "oldestMultiXid vid senaste checkpoint: %u\n" -#: pg_controldata.c:241 +#: pg_controldata.c:234 #, c-format msgid "Latest checkpoint's oldestMulti's DB: %u\n" -msgstr "DB för oldestMulti vid senaste kontrollpkt: %u\n" +msgstr "DB för oldestMulti vid senaste checkpoint: %u\n" + +#: pg_controldata.c:236 +#, c-format +msgid "Latest checkpoint's oldestCommitTsXid:%u\n" +msgstr "oldestCommitTsXid vid senaste checkpoint: %u\n" + +#: pg_controldata.c:238 +#, c-format +msgid "Latest checkpoint's newestCommitTsXid:%u\n" +msgstr "newestCommitTsXid vid senaste checkpoint: %u\n" -#: pg_controldata.c:243 +#: pg_controldata.c:240 #, c-format msgid "Time of latest checkpoint: %s\n" -msgstr "Tidpunkt för senaste kontrollpunkt: %s\n" +msgstr "Tidpunkt för senaste checkpoint: %s\n" -#: pg_controldata.c:245 +#: pg_controldata.c:242 #, c-format msgid "Fake LSN counter for unlogged rels: %X/%X\n" msgstr "Beräknat LSN-tal av ologgade relationer: %X/%X\n" -#: pg_controldata.c:248 +#: pg_controldata.c:245 #, c-format msgid "Minimum recovery ending location: %X/%X\n" -msgstr "Slutläge för minsta Ã¥terställning: %X/%X\n" +msgstr "Minsta slutposition vid Ã¥terställning: %X/%X\n" -#: pg_controldata.c:251 +#: pg_controldata.c:248 #, c-format msgid "Min recovery ending loc's timeline: %u\n" -msgstr "Sluttid för minsta Ã¥terställning: %u\n" +msgstr "Tidslinje för min slutpos vid Ã¥terställning:%u\n" -#: pg_controldata.c:253 +#: pg_controldata.c:250 #, c-format msgid "Backup start location: %X/%X\n" msgstr "Startpunkt för backup: %X/%X\n" -#: pg_controldata.c:256 +#: pg_controldata.c:253 #, c-format msgid "Backup end location: %X/%X\n" msgstr "Slutpunkt för backup: %X/%X\n" -#: pg_controldata.c:259 +#: pg_controldata.c:256 #, c-format msgid "End-of-backup record required: %s\n" msgstr "Tvingande markering av backupslut: %s\n" -#: pg_controldata.c:260 +#: pg_controldata.c:257 msgid "no" msgstr "nej" -#: pg_controldata.c:260 +#: pg_controldata.c:257 msgid "yes" msgstr "ja" -#: pg_controldata.c:261 +#: pg_controldata.c:258 #, c-format -msgid "Current wal_level setting: %s\n" -msgstr "Nuvarande värde pÃ¥ wal_level: %s\n" +msgid "wal_level setting: %s\n" +msgstr "Värde pÃ¥ wal_level: %s\n" -#: pg_controldata.c:263 +#: pg_controldata.c:260 #, c-format -msgid "Current wal_log_hints setting: %s\n" -msgstr "Nuvarande värde pÃ¥ wal_log_hints: %s\n" +msgid "wal_log_hints setting: %s\n" +msgstr "Värde pÃ¥ wal_log_hints: %s\n" -#: pg_controldata.c:265 +#: pg_controldata.c:262 #, c-format -msgid "Current max_connections setting: %d\n" -msgstr "Nuvarande värde pÃ¥ max_connections: %d\n" +msgid "max_connections setting: %d\n" +msgstr "Värde pÃ¥ max_connections: %d\n" -#: pg_controldata.c:267 +#: pg_controldata.c:264 #, c-format -msgid "Current max_worker_processes setting: %d\n" -msgstr "Nuvarande max_worker_processes: %d\n" +msgid "max_worker_processes setting: %d\n" +msgstr "Värde pÃ¥ max_worker_processes: %d\n" -#: pg_controldata.c:269 +#: pg_controldata.c:266 #, c-format -msgid "Current max_prepared_xacts setting: %d\n" -msgstr "Nuvarande max_prepared_xacts: %d\n" +msgid "max_prepared_xacts setting: %d\n" +msgstr "Värde pÃ¥ max_prepared_xacts: %d\n" -#: pg_controldata.c:271 +#: pg_controldata.c:268 #, c-format -msgid "Current max_locks_per_xact setting: %d\n" +msgid "max_locks_per_xact setting: %d\n" msgstr "Nuvarande max_locks_per_xact: %d\n" -#: pg_controldata.c:273 +#: pg_controldata.c:270 +#, c-format +msgid "track_commit_timestamp setting: %s\n" +msgstr "Värde pÃ¥ track_commit_timestamp: %s\n" + +#: pg_controldata.c:272 #, c-format msgid "Maximum data alignment: %u\n" msgstr "Maximal jämkning av data (alignment): %u\n" -#: pg_controldata.c:276 +#: pg_controldata.c:275 #, c-format msgid "Database block size: %u\n" msgstr "Databasens blockstorlek: %u\n" -#: pg_controldata.c:278 +#: pg_controldata.c:277 #, c-format msgid "Blocks per segment of large relation: %u\n" msgstr "Block per segment i en stor relation: %u\n" -#: pg_controldata.c:280 +#: pg_controldata.c:279 #, c-format msgid "WAL block size: %u\n" msgstr "Blockstorlek i transaktionsloggen: %u\n" -#: pg_controldata.c:282 +#: pg_controldata.c:281 #, c-format msgid "Bytes per WAL segment: %u\n" msgstr "Segmentstorlek i transaktionsloggen: %u\n" -#: pg_controldata.c:284 +#: pg_controldata.c:283 #, c-format msgid "Maximum length of identifiers: %u\n" msgstr "Maximal längd för identifierare: %u\n" -#: pg_controldata.c:286 +#: pg_controldata.c:285 #, c-format msgid "Maximum columns in an index: %u\n" msgstr "Maximalt antal kolonner i ett index: %u\n" -#: pg_controldata.c:288 +#: pg_controldata.c:287 #, c-format msgid "Maximum size of a TOAST chunk: %u\n" msgstr "Maximal storlek för en TOAST-enhet: %u\n" -#: pg_controldata.c:290 +#: pg_controldata.c:289 #, c-format msgid "Size of a large-object chunk: %u\n" msgstr "Storlek för large-object-enheter: %u\n" -#: pg_controldata.c:292 +#: pg_controldata.c:291 #, c-format msgid "Date/time type storage: %s\n" msgstr "Representation av dag och tid: %s\n" -#: pg_controldata.c:293 +#: pg_controldata.c:292 msgid "64-bit integers" msgstr "64-bitars heltal" -#: pg_controldata.c:293 +#: pg_controldata.c:292 msgid "floating-point numbers" msgstr "flyttal" -#: pg_controldata.c:294 +#: pg_controldata.c:293 #, c-format msgid "Float4 argument passing: %s\n" -msgstr "Ã…tkomst till float4-argument: %s\n" +msgstr "Överföring av float4-argument: %s\n" -#: pg_controldata.c:295 pg_controldata.c:297 +#: pg_controldata.c:294 pg_controldata.c:296 msgid "by reference" -msgstr "referens" +msgstr "med referens" -#: pg_controldata.c:295 pg_controldata.c:297 +#: pg_controldata.c:294 pg_controldata.c:296 msgid "by value" -msgstr "värdeÃ¥tkomst" +msgstr "med värde" -#: pg_controldata.c:296 +#: pg_controldata.c:295 #, c-format msgid "Float8 argument passing: %s\n" -msgstr "Ã…tkomst till float8-argument: %s\n" +msgstr "Överföring av float8-argument: %s\n" -#: pg_controldata.c:298 +#: pg_controldata.c:297 #, c-format msgid "Data page checksum version: %u\n" msgstr "Checksummaversion för datasidor: %u\n" diff --git a/src/bin/pg_ctl/po/es.po b/src/bin/pg_ctl/po/es.po index c13dbbddf1..78def253b5 100644 --- a/src/bin/pg_ctl/po/es.po +++ b/src/bin/pg_ctl/po/es.po @@ -10,8 +10,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_ctl (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" -"PO-Revision-Date: 2016-05-23 09:50-0500\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" +"PO-Revision-Date: 2017-08-28 11:37+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL Español \n" "Language: es\n" @@ -843,20 +843,3 @@ msgstr "%s: no se especificó operación\n" #, c-format msgid "%s: no database directory specified and environment variable PGDATA unset\n" msgstr "%s: no se especificó directorio de datos y la variable PGDATA no está definida\n" - -#~ msgid "%s: could not start server: exit code was %d\n" -#~ msgstr "%s: no se pudo iniciar el servidor: el código de retorno fue %d\n" - -#~ msgid "" -#~ "\n" -#~ "%s: this data directory appears to be running a pre-existing postmaster\n" -#~ msgstr "" -#~ "\n" -#~ "%s: este directorio de datos parece estar ejecutando un postmaster pre-existente\n" - -#~ msgid "" -#~ "\n" -#~ "%s: could not stat file \"%s\": %s\n" -#~ msgstr "" -#~ "\n" -#~ "%s: no se pudo hacer «stat» al archivo «%s»: %s\n" diff --git a/src/bin/pg_ctl/po/ru.po b/src/bin/pg_ctl/po/ru.po index fc2fa9239e..5b0c8405ae 100644 --- a/src/bin/pg_ctl/po/ru.po +++ b/src/bin/pg_ctl/po/ru.po @@ -6,7 +6,7 @@ # Sergey Burladyan , 2009, 2012. # Andrey Sudnik , 2010. # Dmitriy Olshevskiy , 2014. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" diff --git a/src/bin/pg_dump/po/es.po b/src/bin/pg_dump/po/es.po index f6f9e13526..2396ea6a7f 100644 --- a/src/bin/pg_dump/po/es.po +++ b/src/bin/pg_dump/po/es.po @@ -11,8 +11,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_dump (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" -"PO-Revision-Date: 2017-05-19 18:23-0400\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" +"PO-Revision-Date: 2017-08-28 11:37+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL Español \n" "Language: es\n" @@ -334,14 +334,14 @@ msgstr "no se pudo descomprimir datos: %s\n" msgid "could not close compression library: %s\n" msgstr "no se pudo cerrar la biblioteca de compresión: %s\n" -#: compress_io.c:596 compress_io.c:632 pg_backup_custom.c:591 -#: pg_backup_tar.c:561 +#: compress_io.c:600 compress_io.c:638 pg_backup_custom.c:591 +#: pg_backup_tar.c:566 pg_backup_tar.c:570 #, c-format msgid "could not read from input file: %s\n" msgstr "no se pudo leer el archivo de entrada: %s\n" -#: compress_io.c:635 pg_backup_custom.c:588 pg_backup_directory.c:548 -#: pg_backup_tar.c:797 pg_backup_tar.c:821 +#: compress_io.c:641 pg_backup_custom.c:588 pg_backup_directory.c:552 +#: pg_backup_tar.c:809 pg_backup_tar.c:833 #, c-format msgid "could not read from input file: end of file\n" msgstr "no se pudo leer desde el archivo de entrada: fin de archivo\n" @@ -444,502 +444,492 @@ msgstr "pgpipe: no se pudo aceptar la conexión: código de error %d\n" msgid "archiver" msgstr "archiver" -#: pg_backup_archiver.c:234 pg_backup_archiver.c:1563 +#: pg_backup_archiver.c:240 pg_backup_archiver.c:1589 #, c-format msgid "could not close output file: %s\n" msgstr "no se pudo cerrar el archivo de salida: %s\n" -#: pg_backup_archiver.c:280 pg_backup_archiver.c:285 +#: pg_backup_archiver.c:286 pg_backup_archiver.c:291 #, c-format msgid "WARNING: archive items not in correct section order\n" msgstr "PRECAUCIÓN: elementos del archivo no están en el orden correcto de secciones\n" -#: pg_backup_archiver.c:291 +#: pg_backup_archiver.c:297 #, c-format msgid "unexpected section code %d\n" msgstr "código de sección %d inesperado\n" -#: pg_backup_archiver.c:327 +#: pg_backup_archiver.c:333 #, c-format msgid "-C and -1 are incompatible options\n" msgstr "-C y -1 son opciones incompatibles\n" -#: pg_backup_archiver.c:337 +#: pg_backup_archiver.c:343 #, c-format msgid "parallel restore is not supported with this archive file format\n" msgstr "la restauración en paralelo no está soportada con este formato de archivo\n" -#: pg_backup_archiver.c:341 +#: pg_backup_archiver.c:347 #, c-format msgid "parallel restore is not supported with archives made by pre-8.0 pg_dump\n" msgstr "la restauración en paralelo no está soportada con archivos construidos con pg_dump anterior a 8.0\n" -#: pg_backup_archiver.c:359 +#: pg_backup_archiver.c:365 #, c-format msgid "cannot restore from compressed archive (compression not supported in this installation)\n" msgstr "no se puede reestablecer desde un archivo comprimido (la compresión no está soportada en esta instalación)\n" -#: pg_backup_archiver.c:376 +#: pg_backup_archiver.c:382 #, c-format msgid "connecting to database for restore\n" msgstr "conectando a la base de datos para reestablecimiento\n" -#: pg_backup_archiver.c:378 +#: pg_backup_archiver.c:384 #, c-format msgid "direct database connections are not supported in pre-1.3 archives\n" msgstr "" "las conexiones directas a la base de datos no están soportadas en\n" "archivadores pre-1.3\n" -#: pg_backup_archiver.c:423 +#: pg_backup_archiver.c:429 #, c-format msgid "implied data-only restore\n" msgstr "asumiendo reestablecimiento de sólo datos\n" -#: pg_backup_archiver.c:493 +#: pg_backup_archiver.c:499 #, c-format msgid "dropping %s %s\n" msgstr "eliminando %s %s\n" -#: pg_backup_archiver.c:586 +#: pg_backup_archiver.c:592 #, c-format msgid "WARNING: could not find where to insert IF EXISTS in statement \"%s\"\n" msgstr "PRECAUCIÓN: no se pudo encontrar dónde insertar IF EXISTS en la sentencia «%s»\n" -#: pg_backup_archiver.c:662 -#, c-format -msgid "setting owner and privileges for %s \"%s.%s\"\n" -msgstr "estableciendo dueño y privilegios para %s «%s.%s»\n" - -#: pg_backup_archiver.c:665 -#, c-format -msgid "setting owner and privileges for %s \"%s\"\n" -msgstr "estableciendo dueño y privilegios para %s «%s»\n" - -#: pg_backup_archiver.c:731 pg_backup_archiver.c:733 +#: pg_backup_archiver.c:755 pg_backup_archiver.c:757 #, c-format msgid "warning from original dump file: %s\n" msgstr "precaución desde el archivo original: %s\n" -#: pg_backup_archiver.c:742 +#: pg_backup_archiver.c:769 #, c-format msgid "creating %s \"%s.%s\"\n" msgstr "creando %s «%s.%s»\n" -#: pg_backup_archiver.c:745 +#: pg_backup_archiver.c:772 #, c-format msgid "creating %s \"%s\"\n" msgstr "creando %s «%s»\n" -#: pg_backup_archiver.c:797 +#: pg_backup_archiver.c:823 #, c-format msgid "connecting to new database \"%s\"\n" msgstr "conectando a nueva base de datos «%s»\n" -#: pg_backup_archiver.c:825 +#: pg_backup_archiver.c:851 #, c-format msgid "processing %s\n" msgstr "procesando %s\n" -#: pg_backup_archiver.c:845 +#: pg_backup_archiver.c:871 #, c-format msgid "processing data for table \"%s.%s\"\n" msgstr "procesando datos de la tabla «%s.%s»\n" -#: pg_backup_archiver.c:907 +#: pg_backup_archiver.c:933 #, c-format msgid "executing %s %s\n" msgstr "ejecutando %s %s\n" -#: pg_backup_archiver.c:946 +#: pg_backup_archiver.c:972 #, c-format msgid "disabling triggers for %s\n" msgstr "deshabilitando disparadores (triggers) para %s\n" -#: pg_backup_archiver.c:974 +#: pg_backup_archiver.c:1000 #, c-format msgid "enabling triggers for %s\n" msgstr "habilitando disparadores (triggers) para %s\n" -#: pg_backup_archiver.c:1004 +#: pg_backup_archiver.c:1030 #, c-format msgid "internal error -- WriteData cannot be called outside the context of a DataDumper routine\n" msgstr "" "error interno -- WriteData no puede ser llamada fuera del contexto\n" "de una rutina DataDumper\n" -#: pg_backup_archiver.c:1201 +#: pg_backup_archiver.c:1227 #, c-format msgid "large-object output not supported in chosen format\n" msgstr "" "la extracción de objetos grandes no está soportada en el formato\n" "seleccionado\n" -#: pg_backup_archiver.c:1259 +#: pg_backup_archiver.c:1285 #, c-format msgid "restored %d large object\n" msgid_plural "restored %d large objects\n" msgstr[0] "se reestableció %d objeto grande\n" msgstr[1] "se reestablecieron %d objetos grandes\n" -#: pg_backup_archiver.c:1280 pg_backup_tar.c:739 +#: pg_backup_archiver.c:1306 pg_backup_tar.c:751 #, c-format msgid "restoring large object with OID %u\n" msgstr "reestableciendo objeto grande con OID %u\n" -#: pg_backup_archiver.c:1292 +#: pg_backup_archiver.c:1318 #, c-format msgid "could not create large object %u: %s" msgstr "no se pudo crear el objeto grande %u: %s" -#: pg_backup_archiver.c:1297 pg_dump.c:3093 +#: pg_backup_archiver.c:1323 pg_dump.c:3093 #, c-format msgid "could not open large object %u: %s" msgstr "no se pudo abrir el objeto grande %u: %s" -#: pg_backup_archiver.c:1355 +#: pg_backup_archiver.c:1381 #, c-format msgid "could not open TOC file \"%s\": %s\n" msgstr "no se pudo abrir el archivo TOC «%s»: %s\n" -#: pg_backup_archiver.c:1396 +#: pg_backup_archiver.c:1422 #, c-format msgid "WARNING: line ignored: %s\n" msgstr "PRECAUCIÓN: línea ignorada: %s\n" -#: pg_backup_archiver.c:1403 +#: pg_backup_archiver.c:1429 #, c-format msgid "could not find entry for ID %d\n" msgstr "no se pudo encontrar una entrada para el ID %d\n" -#: pg_backup_archiver.c:1424 pg_backup_directory.c:230 -#: pg_backup_directory.c:597 +#: pg_backup_archiver.c:1450 pg_backup_directory.c:230 +#: pg_backup_directory.c:601 #, c-format msgid "could not close TOC file: %s\n" msgstr "no se pudo cerrar el archivo TOC: %s\n" -#: pg_backup_archiver.c:1533 pg_backup_custom.c:162 pg_backup_directory.c:341 -#: pg_backup_directory.c:583 pg_backup_directory.c:641 -#: pg_backup_directory.c:661 +#: pg_backup_archiver.c:1559 pg_backup_custom.c:162 pg_backup_directory.c:341 +#: pg_backup_directory.c:587 pg_backup_directory.c:645 +#: pg_backup_directory.c:665 #, c-format msgid "could not open output file \"%s\": %s\n" msgstr "no se pudo abrir el archivo de salida «%s»: %s\n" -#: pg_backup_archiver.c:1536 pg_backup_custom.c:169 +#: pg_backup_archiver.c:1562 pg_backup_custom.c:169 #, c-format msgid "could not open output file: %s\n" msgstr "no se pudo abrir el archivo de salida: %s\n" -#: pg_backup_archiver.c:1642 +#: pg_backup_archiver.c:1668 #, c-format msgid "wrote %lu byte of large object data (result = %lu)\n" msgid_plural "wrote %lu bytes of large object data (result = %lu)\n" msgstr[0] "se escribió %lu byte de los datos del objeto grande (resultado = %lu)\n" msgstr[1] "se escribieron %lu bytes de los datos del objeto grande (resultado = %lu)\n" -#: pg_backup_archiver.c:1648 +#: pg_backup_archiver.c:1674 #, c-format msgid "could not write to large object (result: %lu, expected: %lu)\n" msgstr "no se pudo escribir al objecto grande (resultado: %lu, esperado: %lu)\n" -#: pg_backup_archiver.c:1741 +#: pg_backup_archiver.c:1767 #, c-format msgid "Error while INITIALIZING:\n" msgstr "Error durante INICIALIZACIÓN:\n" -#: pg_backup_archiver.c:1746 +#: pg_backup_archiver.c:1772 #, c-format msgid "Error while PROCESSING TOC:\n" msgstr "Error durante PROCESAMIENTO DE TABLA DE CONTENIDOS:\n" -#: pg_backup_archiver.c:1751 +#: pg_backup_archiver.c:1777 #, c-format msgid "Error while FINALIZING:\n" msgstr "Error durante FINALIZACIÓN:\n" -#: pg_backup_archiver.c:1756 +#: pg_backup_archiver.c:1782 #, c-format msgid "Error from TOC entry %d; %u %u %s %s %s\n" msgstr "Error en entrada de la tabla de contenidos %d; %u %u %s %s %s\n" -#: pg_backup_archiver.c:1829 +#: pg_backup_archiver.c:1855 #, c-format msgid "bad dumpId\n" msgstr "dumpId incorrecto\n" -#: pg_backup_archiver.c:1850 +#: pg_backup_archiver.c:1876 #, c-format msgid "bad table dumpId for TABLE DATA item\n" msgstr "dumpId de tabla incorrecto para elemento TABLE DATA\n" -#: pg_backup_archiver.c:1942 +#: pg_backup_archiver.c:1968 #, c-format msgid "unexpected data offset flag %d\n" msgstr "bandera de posición inesperada %d\n" -#: pg_backup_archiver.c:1955 +#: pg_backup_archiver.c:1981 #, c-format msgid "file offset in dump file is too large\n" msgstr "el posición en el archivo es demasiado grande\n" -#: pg_backup_archiver.c:2068 +#: pg_backup_archiver.c:2094 #, c-format msgid "attempting to ascertain archive format\n" msgstr "intentando comprobar el formato del archivador\n" -#: pg_backup_archiver.c:2094 pg_backup_archiver.c:2104 +#: pg_backup_archiver.c:2120 pg_backup_archiver.c:2130 #, c-format msgid "directory name too long: \"%s\"\n" msgstr "nombre de directorio demasiado largo: «%s»\n" -#: pg_backup_archiver.c:2112 +#: pg_backup_archiver.c:2138 #, c-format msgid "directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does not exist)\n" msgstr "el directorio «%s» no parece ser un archivador válido (no existe «toc.dat»)\n" -#: pg_backup_archiver.c:2120 pg_backup_custom.c:181 pg_backup_custom.c:770 -#: pg_backup_directory.c:214 pg_backup_directory.c:399 +#: pg_backup_archiver.c:2146 pg_backup_custom.c:181 pg_backup_custom.c:770 +#: pg_backup_directory.c:214 pg_backup_directory.c:401 #, c-format msgid "could not open input file \"%s\": %s\n" msgstr "no se pudo abrir el archivo de entrada «%s»: %s\n" -#: pg_backup_archiver.c:2128 pg_backup_custom.c:188 +#: pg_backup_archiver.c:2154 pg_backup_custom.c:188 #, c-format msgid "could not open input file: %s\n" msgstr "no se pudo abrir el archivo de entrada: %s\n" -#: pg_backup_archiver.c:2135 +#: pg_backup_archiver.c:2161 #, c-format msgid "could not read input file: %s\n" msgstr "no se pudo leer el archivo de entrada: %s\n" -#: pg_backup_archiver.c:2137 +#: pg_backup_archiver.c:2163 #, c-format msgid "input file is too short (read %lu, expected 5)\n" msgstr "el archivo de entrada es demasiado corto (leidos %lu, esperados 5)\n" -#: pg_backup_archiver.c:2220 +#: pg_backup_archiver.c:2246 #, c-format msgid "input file appears to be a text format dump. Please use psql.\n" msgstr "el archivo de entrada parece ser un volcado de texto. Por favor use psql.\n" -#: pg_backup_archiver.c:2226 +#: pg_backup_archiver.c:2252 #, c-format msgid "input file does not appear to be a valid archive (too short?)\n" msgstr "el archivo de entrada no parece ser un archivador válido (¿demasiado corto?)\n" -#: pg_backup_archiver.c:2232 +#: pg_backup_archiver.c:2258 #, c-format msgid "input file does not appear to be a valid archive\n" msgstr "el archivo de entrada no parece ser un archivador válido\n" -#: pg_backup_archiver.c:2252 +#: pg_backup_archiver.c:2278 #, c-format msgid "could not close input file: %s\n" msgstr "no se pudo cerrar el archivo de entrada: %s\n" -#: pg_backup_archiver.c:2269 +#: pg_backup_archiver.c:2295 #, c-format msgid "allocating AH for %s, format %d\n" msgstr "reservando AH para %s, formato %d\n" -#: pg_backup_archiver.c:2374 +#: pg_backup_archiver.c:2400 #, c-format msgid "unrecognized file format \"%d\"\n" msgstr "formato de archivo no reconocido «%d»\n" -#: pg_backup_archiver.c:2530 +#: pg_backup_archiver.c:2556 #, c-format msgid "entry ID %d out of range -- perhaps a corrupt TOC\n" msgstr "" "la entrada con ID %d está fuera de rango -- tal vez\n" "la tabla de contenido está corrupta\n" -#: pg_backup_archiver.c:2646 +#: pg_backup_archiver.c:2672 #, c-format msgid "read TOC entry %d (ID %d) for %s %s\n" msgstr "leyendo entrada de la tabla de contenidos %d (ID %d) para %s %s\n" -#: pg_backup_archiver.c:2680 +#: pg_backup_archiver.c:2706 #, c-format msgid "unrecognized encoding \"%s\"\n" msgstr "no se reconoce la codificación: «%s»\n" -#: pg_backup_archiver.c:2685 +#: pg_backup_archiver.c:2711 #, c-format msgid "invalid ENCODING item: %s\n" msgstr "elemento ENCODING no válido: %s\n" -#: pg_backup_archiver.c:2703 +#: pg_backup_archiver.c:2729 #, c-format msgid "invalid STDSTRINGS item: %s\n" msgstr "elemento STDSTRINGS no válido: %s\n" -#: pg_backup_archiver.c:2718 +#: pg_backup_archiver.c:2744 #, c-format msgid "schema \"%s\" not found\n" msgstr "esquema «%s» no encontrado\n" -#: pg_backup_archiver.c:2725 +#: pg_backup_archiver.c:2751 #, c-format msgid "table \"%s\" not found\n" msgstr "tabla «%s» no encontrada\n" -#: pg_backup_archiver.c:2732 +#: pg_backup_archiver.c:2758 #, c-format msgid "index \"%s\" not found\n" msgstr "índice «%s» no encontrado\n" -#: pg_backup_archiver.c:2739 +#: pg_backup_archiver.c:2765 #, c-format msgid "function \"%s\" not found\n" msgstr "función «%s» no encontrada\n" -#: pg_backup_archiver.c:2746 +#: pg_backup_archiver.c:2772 #, c-format msgid "trigger \"%s\" not found\n" msgstr "disparador «%s» no encontrado\n" -#: pg_backup_archiver.c:2988 +#: pg_backup_archiver.c:3036 #, c-format msgid "could not set session user to \"%s\": %s" msgstr "no se pudo establecer el usuario de sesión a «%s»: %s" -#: pg_backup_archiver.c:3020 +#: pg_backup_archiver.c:3068 #, c-format msgid "could not set default_with_oids: %s" msgstr "no se pudo definir default_with_oids: %s" -#: pg_backup_archiver.c:3165 +#: pg_backup_archiver.c:3213 #, c-format msgid "could not set search_path to \"%s\": %s" msgstr "no se pudo establecer search_path a «%s»: %s" -#: pg_backup_archiver.c:3227 +#: pg_backup_archiver.c:3275 #, c-format msgid "could not set default_tablespace to %s: %s" msgstr "no se pudo establecer default_tablespace a %s: %s" -#: pg_backup_archiver.c:3314 pg_backup_archiver.c:3508 +#: pg_backup_archiver.c:3363 pg_backup_archiver.c:3553 #, c-format -msgid "WARNING: don't know how to set owner for object type %s\n" -msgstr "PRECAUCIÓN: no se sabe cómo establecer el dueño para el objeto de tipo %s\n" +msgid "WARNING: don't know how to set owner for object type \"%s\"\n" +msgstr "PRECAUCIÓN: no se sabe cómo establecer el dueño para el objeto de tipo «%s»\n" -#: pg_backup_archiver.c:3591 +#: pg_backup_archiver.c:3639 #, c-format msgid "did not find magic string in file header\n" msgstr "no se encontró la cadena mágica en el encabezado del archivo\n" -#: pg_backup_archiver.c:3604 +#: pg_backup_archiver.c:3652 #, c-format msgid "unsupported version (%d.%d) in file header\n" msgstr "versión no soportada (%d.%d) en el encabezado del archivo\n" -#: pg_backup_archiver.c:3609 +#: pg_backup_archiver.c:3657 #, c-format msgid "sanity check on integer size (%lu) failed\n" msgstr "revisión de integridad en el tamaño del entero (%lu) falló\n" -#: pg_backup_archiver.c:3613 +#: pg_backup_archiver.c:3661 #, c-format msgid "WARNING: archive was made on a machine with larger integers, some operations might fail\n" msgstr "" "PRECAUCIÓN: el archivador fue hecho en una máquina con enteros más \n" "grandes, algunas operaciones podrían fallar\n" -#: pg_backup_archiver.c:3623 +#: pg_backup_archiver.c:3671 #, c-format msgid "expected format (%d) differs from format found in file (%d)\n" msgstr "el formato esperado (%d) difiere del formato encontrado en el archivo (%d)\n" -#: pg_backup_archiver.c:3639 +#: pg_backup_archiver.c:3687 #, c-format msgid "WARNING: archive is compressed, but this installation does not support compression -- no data will be available\n" msgstr "" "PRECAUCIÓN: el archivador está comprimido, pero esta instalación no soporta\n" "compresión -- no habrá datos disponibles\n" -#: pg_backup_archiver.c:3657 +#: pg_backup_archiver.c:3705 #, c-format msgid "WARNING: invalid creation date in header\n" msgstr "PRECAUCIÓN: la fecha de creación en el encabezado no es válida\n" -#: pg_backup_archiver.c:3732 +#: pg_backup_archiver.c:3778 #, c-format msgid "entering restore_toc_entries_prefork\n" msgstr "ingresando restore_toc_entries_prefork\n" -#: pg_backup_archiver.c:3776 +#: pg_backup_archiver.c:3842 #, c-format msgid "processing item %d %s %s\n" msgstr "procesando el elemento %d %s %s\n" -#: pg_backup_archiver.c:3828 +#: pg_backup_archiver.c:3896 #, c-format msgid "entering restore_toc_entries_parallel\n" msgstr "ingresando restore_toc_entries_parallel\n" -#: pg_backup_archiver.c:3876 +#: pg_backup_archiver.c:3917 #, c-format msgid "entering main parallel loop\n" msgstr "ingresando al bucle paralelo principal\n" -#: pg_backup_archiver.c:3887 +#: pg_backup_archiver.c:3928 #, c-format msgid "skipping item %d %s %s\n" msgstr "saltando el elemento %d %s %s\n" -#: pg_backup_archiver.c:3897 +#: pg_backup_archiver.c:3938 #, c-format msgid "launching item %d %s %s\n" msgstr "lanzando el elemento %d %s %s\n" -#: pg_backup_archiver.c:3953 +#: pg_backup_archiver.c:4019 #, c-format msgid "finished main parallel loop\n" msgstr "terminó el bucle paralelo principal\n" -#: pg_backup_archiver.c:3962 +#: pg_backup_archiver.c:4037 #, c-format msgid "entering restore_toc_entries_postfork\n" msgstr "ingresando restore_toc_entries_postfork\n" -#: pg_backup_archiver.c:3981 +#: pg_backup_archiver.c:4057 #, c-format msgid "processing missed item %d %s %s\n" msgstr "procesando el elemento saltado %d %s %s\n" -#: pg_backup_archiver.c:4130 +#: pg_backup_archiver.c:4234 #, c-format msgid "no item ready\n" msgstr "ningún elemento listo\n" -#: pg_backup_archiver.c:4178 +#: pg_backup_archiver.c:4282 #, c-format msgid "could not find slot of finished worker\n" msgstr "no se pudo localizar la entrada del proceso o hilo que terminó\n" -#: pg_backup_archiver.c:4180 +#: pg_backup_archiver.c:4284 #, c-format msgid "finished item %d %s %s\n" msgstr "terminó el elemento %d %s %s\n" -#: pg_backup_archiver.c:4193 +#: pg_backup_archiver.c:4297 #, c-format msgid "worker process failed: exit code %d\n" msgstr "el proceso hijo falló: código de salida %d\n" -#: pg_backup_archiver.c:4355 +#: pg_backup_archiver.c:4459 #, c-format msgid "transferring dependency %d -> %d to %d\n" msgstr "transferiendo la dependencia %d -> %d a %d\n" -#: pg_backup_archiver.c:4428 +#: pg_backup_archiver.c:4532 #, c-format msgid "reducing dependencies for %d\n" msgstr "reduciendo las dependencias para %d\n" -#: pg_backup_archiver.c:4467 +#: pg_backup_archiver.c:4584 #, c-format msgid "table \"%s\" could not be created, will not restore its data\n" msgstr "la tabla «%s» no pudo ser creada, no se recuperarán sus datos\n" @@ -992,7 +982,7 @@ msgid "unrecognized data block type %d while restoring archive\n" msgstr "se encontró un bloque tipo %d no reconocido al restablecer el archivador\n" #: pg_backup_custom.c:709 pg_backup_custom.c:759 pg_backup_custom.c:908 -#: pg_backup_tar.c:1088 +#: pg_backup_tar.c:1100 #, c-format msgid "could not determine seek position in archive file: %s\n" msgstr "no se pudo determinar la posición (seek) en el archivo del archivador: %s\n" @@ -1176,42 +1166,48 @@ msgstr "no se pudo cerrar el directorio «%s»: %s\n" msgid "could not create directory \"%s\": %s\n" msgstr "no se pudo crear el directorio «%s»: %s\n" -#: pg_backup_directory.c:412 +#: pg_backup_directory.c:360 pg_backup_directory.c:500 +#: pg_backup_directory.c:530 +#, c-format +msgid "could not write to output file: %s\n" +msgstr "no se pudo escribir al archivo de salida: %s\n" + +#: pg_backup_directory.c:414 #, c-format msgid "could not close data file: %s\n" msgstr "no se pudo cerrar el archivo de datos: %s\n" -#: pg_backup_directory.c:453 +#: pg_backup_directory.c:455 #, c-format msgid "could not open large object TOC file \"%s\" for input: %s\n" msgstr "no se pudo abrir el archivo de la tabla de contenidos de objetos grandes «%s» para su lectura: %s\n" -#: pg_backup_directory.c:464 +#: pg_backup_directory.c:466 #, c-format msgid "invalid line in large object TOC file \"%s\": \"%s\"\n" msgstr "línea no válida en el archivo de la tabla de contenido de objetos grandes «%s»: «%s»\n" -#: pg_backup_directory.c:473 +#: pg_backup_directory.c:475 #, c-format msgid "error reading large object TOC file \"%s\"\n" msgstr "error al leer el archivo de la tabla de contenidos de objetos grandes «%s»\n" -#: pg_backup_directory.c:477 +#: pg_backup_directory.c:479 #, c-format msgid "could not close large object TOC file \"%s\": %s\n" msgstr "no se pudo cerrar el archivo de la tabla de contenido de los objetos grandes «%s»: %s\n" -#: pg_backup_directory.c:684 +#: pg_backup_directory.c:688 #, c-format msgid "could not write to blobs TOC file\n" msgstr "no se pudo escribir al archivo de la tabla de contenidos de objetos grandes\n" -#: pg_backup_directory.c:716 +#: pg_backup_directory.c:720 #, c-format msgid "file name too long: \"%s\"\n" msgstr "nombre de archivo demasiado largo: «%s»\n" -#: pg_backup_directory.c:802 +#: pg_backup_directory.c:806 #, c-format msgid "error during backup\n" msgstr "error durante el volcado\n" @@ -1271,71 +1267,71 @@ msgstr "no se pudo abrir archivo temporal\n" msgid "could not close tar member\n" msgstr "no se pudo cerrar miembro del archivo tar\n" -#: pg_backup_tar.c:571 +#: pg_backup_tar.c:583 #, c-format msgid "internal error -- neither th nor fh specified in tarReadRaw()\n" msgstr "error interno --- no se especificó th ni fh en tarReadRaw()\n" -#: pg_backup_tar.c:694 +#: pg_backup_tar.c:706 #, c-format msgid "unexpected COPY statement syntax: \"%s\"\n" msgstr "sintaxis de sentencia COPY inesperada: «%s»\n" -#: pg_backup_tar.c:960 +#: pg_backup_tar.c:972 #, c-format msgid "invalid OID for large object (%u)\n" msgstr "el OID del objeto grande no es válido (%u)\n" -#: pg_backup_tar.c:1104 +#: pg_backup_tar.c:1116 #, c-format msgid "could not close temporary file: %s\n" msgstr "no se pudo abrir archivo temporal: %s\n" -#: pg_backup_tar.c:1114 +#: pg_backup_tar.c:1126 #, c-format msgid "actual file length (%s) does not match expected (%s)\n" msgstr "el tamaño real del archivo (%s) no coincide con el esperado (%s)\n" -#: pg_backup_tar.c:1151 +#: pg_backup_tar.c:1163 #, c-format msgid "moving from position %s to next member at file position %s\n" msgstr "moviendo desde la posición %s a la posición del siguiente miembro %s\n" -#: pg_backup_tar.c:1162 +#: pg_backup_tar.c:1174 #, c-format msgid "now at file position %s\n" msgstr "ahora en la posición del archivo %s\n" -#: pg_backup_tar.c:1171 pg_backup_tar.c:1201 +#: pg_backup_tar.c:1183 pg_backup_tar.c:1213 #, c-format msgid "could not find header for file \"%s\" in tar archive\n" msgstr "no se pudo encontrar el encabezado para el archivo «%s» en el archivo tar\n" -#: pg_backup_tar.c:1185 +#: pg_backup_tar.c:1197 #, c-format msgid "skipping tar member %s\n" msgstr "saltando miembro del archivo tar %s\n" -#: pg_backup_tar.c:1189 +#: pg_backup_tar.c:1201 #, c-format msgid "restoring data out of order is not supported in this archive format: \"%s\" is required, but comes before \"%s\" in the archive file.\n" msgstr "" "la extracción de datos fuera de orden no está soportada en este formato:\n" "se requiere «%s», pero viene antes de «%s» en el archivador.\n" -#: pg_backup_tar.c:1235 +#: pg_backup_tar.c:1247 #, c-format msgid "incomplete tar header found (%lu byte)\n" msgid_plural "incomplete tar header found (%lu bytes)\n" msgstr[0] "se encontró un encabezado incompleto (%lu byte)\n" msgstr[1] "se encontró un encabezado incompleto (%lu bytes)\n" -#: pg_backup_tar.c:1276 +#: pg_backup_tar.c:1288 #, c-format msgid "TOC Entry %s at %s (length %s, checksum %d)\n" msgstr "entrada TOC %s en %s (tamaño %s, suma de integridad %d)\n" -#: pg_backup_tar.c:1287 +#: pg_backup_tar.c:1299 #, c-format msgid "corrupt tar header found in %s (expected %d, computed %d) file position %s\n" msgstr "" @@ -1894,290 +1890,290 @@ msgstr "tipo de orden inesperada en política: «%s»\n" msgid "could not find parent extension for %s\n" msgstr "no se pudo encontrar la extensión padre para %s\n" -#: pg_dump.c:3726 +#: pg_dump.c:3731 #, c-format msgid "WARNING: owner of schema \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño del esquema «%s» parece no ser válido\n" -#: pg_dump.c:3769 +#: pg_dump.c:3774 #, c-format msgid "schema with OID %u does not exist\n" msgstr "el esquema con OID %u no existe\n" -#: pg_dump.c:4184 +#: pg_dump.c:4189 #, c-format msgid "WARNING: owner of data type \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño del tipo «%s» parece no ser válido\n" -#: pg_dump.c:4298 +#: pg_dump.c:4303 #, c-format msgid "WARNING: owner of operator \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño del operador «%s» parece no ser válido\n" -#: pg_dump.c:4643 +#: pg_dump.c:4648 #, c-format msgid "WARNING: owner of operator class \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño de la clase de operadores «%s» parece no ser válido\n" -#: pg_dump.c:4734 +#: pg_dump.c:4739 #, c-format msgid "WARNING: owner of operator family \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño de la familia de operadores «%s» parece no ser válido\n" -#: pg_dump.c:4935 +#: pg_dump.c:4940 #, c-format msgid "WARNING: owner of aggregate function \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño de la función de agregación «%s» parece no ser válido\n" -#: pg_dump.c:5232 +#: pg_dump.c:5237 #, c-format msgid "WARNING: owner of function \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño de la función «%s» parece no ser válido\n" -#: pg_dump.c:6094 +#: pg_dump.c:6099 #, c-format msgid "WARNING: owner of table \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el dueño de la tabla «%s» parece no ser válido\n" -#: pg_dump.c:6136 pg_dump.c:16638 +#: pg_dump.c:6141 pg_dump.c:16665 #, c-format msgid "failed sanity check, parent table OID %u of sequence OID %u not found\n" msgstr "falló la revisión de integridad: no se encontró la tabla padre OID %u de la secuencia con OID %u\n" -#: pg_dump.c:6263 +#: pg_dump.c:6268 #, c-format msgid "reading indexes for table \"%s.%s\"\n" msgstr "extrayendo los índices para la tabla «%s.%s»\n" -#: pg_dump.c:6631 +#: pg_dump.c:6636 #, c-format msgid "reading foreign key constraints for table \"%s.%s\"\n" msgstr "extrayendo restricciones de llave foránea para la tabla «%s.%s»\n" -#: pg_dump.c:6877 +#: pg_dump.c:6882 #, c-format msgid "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not found\n" msgstr "falló la revisión de integridad: no se encontró la tabla padre OID %u del elemento con OID %u de pg_rewrite\n" -#: pg_dump.c:6971 +#: pg_dump.c:6976 #, c-format msgid "reading triggers for table \"%s.%s\"\n" msgstr "extrayendo los disparadores (triggers) para la tabla «%s.%s»\n" -#: pg_dump.c:7136 +#: pg_dump.c:7141 #, c-format msgid "query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of table: %u)\n" msgstr "" "la consulta produjo un nombre de tabla nulo para la llave foránea del \n" "disparador \"%s\" en la tabla «%s» (OID de la tabla: %u)\n" -#: pg_dump.c:7791 +#: pg_dump.c:7796 #, c-format msgid "finding the columns and types of table \"%s.%s\"\n" msgstr "buscando las columnas y tipos de la tabla «%s.%s»\n" -#: pg_dump.c:7970 +#: pg_dump.c:7975 #, c-format msgid "invalid column numbering in table \"%s\"\n" msgstr "numeración de columnas no válida en la tabla «%s»\n" -#: pg_dump.c:8004 +#: pg_dump.c:8009 #, c-format msgid "finding default expressions of table \"%s.%s\"\n" msgstr "buscando expresiones por omisión de la tabla «%s.%s»\n" -#: pg_dump.c:8057 +#: pg_dump.c:8062 #, c-format msgid "invalid adnum value %d for table \"%s\"\n" msgstr "el valor de adnum %d para la tabla «%s» no es válido\n" -#: pg_dump.c:8129 +#: pg_dump.c:8134 #, c-format msgid "finding check constraints for table \"%s.%s\"\n" msgstr "buscando restricciones de revisión (check) para la tabla «%s.%s»\n" -#: pg_dump.c:8225 +#: pg_dump.c:8230 #, c-format msgid "expected %d check constraint on table \"%s\" but found %d\n" msgid_plural "expected %d check constraints on table \"%s\" but found %d\n" msgstr[0] "se esperaban %d restricciones CHECK en la tabla «%s» pero se encontraron %d\n" msgstr[1] "se esperaban %d restricciones CHECK en la tabla «%s» pero se encontraron %d\n" -#: pg_dump.c:8229 +#: pg_dump.c:8234 #, c-format msgid "(The system catalogs might be corrupted.)\n" msgstr "(Los catálogos del sistema podrían estar corruptos)\n" -#: pg_dump.c:9808 +#: pg_dump.c:9813 #, c-format msgid "WARNING: typtype of data type \"%s\" appears to be invalid\n" msgstr "PRECAUCIÓN: el typtype del tipo «%s» parece no ser válido\n" -#: pg_dump.c:11350 +#: pg_dump.c:11355 #, c-format msgid "WARNING: bogus value in proargmodes array\n" msgstr "PRECAUCIÓN: valor no válido en el arreglo proargmodes\n" -#: pg_dump.c:11728 +#: pg_dump.c:11733 #, c-format msgid "WARNING: could not parse proallargtypes array\n" msgstr "PRECAUCIÓN: no se pudo interpretar el arreglo proallargtypes\n" -#: pg_dump.c:11744 +#: pg_dump.c:11749 #, c-format msgid "WARNING: could not parse proargmodes array\n" msgstr "PRECAUCIÓN: no se pudo interpretar el arreglo proargmodes\n" -#: pg_dump.c:11758 +#: pg_dump.c:11763 #, c-format msgid "WARNING: could not parse proargnames array\n" msgstr "PRECAUCIÓN: no se pudo interpretar el arreglo proargnames\n" -#: pg_dump.c:11769 +#: pg_dump.c:11774 #, c-format msgid "WARNING: could not parse proconfig array\n" msgstr "PRECAUCIÓN: no se pudo interpretar el arreglo proconfig\n" -#: pg_dump.c:11840 +#: pg_dump.c:11845 #, c-format msgid "unrecognized provolatile value for function \"%s\"\n" msgstr "el valor del atributo «provolatile» para la función «%s» es desconocido\n" -#: pg_dump.c:11884 pg_dump.c:13933 +#: pg_dump.c:11889 pg_dump.c:13950 #, c-format msgid "unrecognized proparallel value for function \"%s\"\n" msgstr "el valor del atributo «proparallel» para la función «%s» es desconocido\n" -#: pg_dump.c:11992 pg_dump.c:12102 pg_dump.c:12109 +#: pg_dump.c:11997 pg_dump.c:12107 pg_dump.c:12114 #, c-format msgid "could not find function definition for function with OID %u\n" msgstr "no se encontró la definición de la función con OID %u\n" -#: pg_dump.c:12037 +#: pg_dump.c:12042 #, c-format msgid "WARNING: bogus value in pg_cast.castfunc or pg_cast.castmethod field\n" msgstr "PRECAUCIÓN: valor no válido en los campos pg_cast.castfunc o pg_cast.castmethod\n" -#: pg_dump.c:12040 +#: pg_dump.c:12045 #, c-format msgid "WARNING: bogus value in pg_cast.castmethod field\n" msgstr "PRECAUCIÓN: valor no válido en el campo pg_cast.castmethod\n" -#: pg_dump.c:12130 +#: pg_dump.c:12135 #, c-format msgid "WARNING: bogus transform definition, at least one of trffromsql and trftosql should be nonzero\n" msgstr "PRECAUCIÓN: definición errónea de transformación; al menos uno de trffromsql and trftosql debe ser distinto de cero\n" -#: pg_dump.c:12147 +#: pg_dump.c:12152 #, c-format msgid "WARNING: bogus value in pg_transform.trffromsql field\n" msgstr "PRECAUCIÓN: valor erróneo en el campo pg_transform.trffromsql\n" -#: pg_dump.c:12168 +#: pg_dump.c:12173 #, c-format msgid "WARNING: bogus value in pg_transform.trftosql field\n" msgstr "PRECAUCIÓN: valor erróneo en el campo pg_transform.trftosql\n" -#: pg_dump.c:12559 +#: pg_dump.c:12564 #, c-format msgid "WARNING: could not find operator with OID %s\n" msgstr "PRECAUCIÓN: no se pudo encontrar el operador con OID %s\n" -#: pg_dump.c:12623 +#: pg_dump.c:12628 #, c-format msgid "WARNING: invalid type \"%c\" of access method \"%s\"\n" msgstr "PRECAUCIÓN: el tipo «%c» para el método de acceso «%s» no es válido\n" -#: pg_dump.c:13824 +#: pg_dump.c:13841 #, c-format msgid "WARNING: aggregate function %s could not be dumped correctly for this database version; ignored\n" msgstr "" "PRECAUCIÓN: la función de agregación «%s» no se pudo extraer correctamente\n" "para esta versión de la base de datos; ignorada\n" -#: pg_dump.c:14696 +#: pg_dump.c:14713 #, c-format msgid "unrecognized object type in default privileges: %d\n" msgstr "tipo de objeto desconocido en privilegios por omisión: %d\n" -#: pg_dump.c:14714 +#: pg_dump.c:14731 #, c-format msgid "could not parse default ACL list (%s)\n" msgstr "no se pudo interpretar la lista de ACL (%s)\n" -#: pg_dump.c:14785 +#: pg_dump.c:14812 #, c-format msgid "could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) for object \"%s\" (%s)\n" msgstr "no se pudo interpretar la lista inicial de GRANT ACL (%s) o la lista inicial de REVOKE ACL (%s) para el objeto «%s» (%s)\n" -#: pg_dump.c:14793 +#: pg_dump.c:14820 #, c-format msgid "could not parse GRANT ACL list (%s) or REVOKE ACL list (%s) for object \"%s\" (%s)\n" msgstr "no se pudo interpretar la lista de GRANT ACL (%s) o la lista de REVOKE ACL (%s) para el objeto «%s» (%s)\n" -#: pg_dump.c:15278 +#: pg_dump.c:15305 #, c-format msgid "query to obtain definition of view \"%s\" returned no data\n" msgstr "la consulta para obtener la definición de la vista «%s» no regresó datos\n" -#: pg_dump.c:15281 +#: pg_dump.c:15308 #, c-format msgid "query to obtain definition of view \"%s\" returned more than one definition\n" msgstr "la consulta para obtener la definición de la vista «%s» regresó más de una definición\n" -#: pg_dump.c:15288 +#: pg_dump.c:15315 #, c-format msgid "definition of view \"%s\" appears to be empty (length zero)\n" msgstr "la definición de la vista «%s» parece estar vacía (tamaño cero)\n" -#: pg_dump.c:16047 +#: pg_dump.c:16074 #, c-format msgid "invalid column number %d for table \"%s\"\n" msgstr "el número de columna %d no es válido para la tabla «%s»\n" -#: pg_dump.c:16176 +#: pg_dump.c:16203 #, c-format msgid "missing index for constraint \"%s\"\n" msgstr "falta un índice para restricción «%s»\n" -#: pg_dump.c:16379 +#: pg_dump.c:16406 #, c-format msgid "unrecognized constraint type: %c\n" msgstr "tipo de restricción inesperado: %c\n" -#: pg_dump.c:16533 pg_dump.c:16706 +#: pg_dump.c:16560 pg_dump.c:16733 #, c-format msgid "query to get data of sequence \"%s\" returned %d row (expected 1)\n" msgid_plural "query to get data of sequence \"%s\" returned %d rows (expected 1)\n" msgstr[0] "la consulta para obtener los datos de la secuencia «%s» regresó %d entrada, pero se esperaba 1\n" msgstr[1] "la consulta para obtener los datos de la secuencia «%s» regresó %d entradas, pero se esperaba 1\n" -#: pg_dump.c:16544 +#: pg_dump.c:16571 #, c-format msgid "query to get data of sequence \"%s\" returned name \"%s\"\n" msgstr "la consulta para obtener los datos de la secuencia «%s» regresó el nombre «%s»\n" -#: pg_dump.c:16804 +#: pg_dump.c:16831 #, c-format msgid "unexpected tgtype value: %d\n" msgstr "tgtype no esperado: %d\n" -#: pg_dump.c:16886 +#: pg_dump.c:16913 #, c-format msgid "invalid argument string (%s) for trigger \"%s\" on table \"%s\"\n" msgstr "argumento de cadena (%s) no válido para el disparador (trigger) «%s» en la tabla «%s»\n" -#: pg_dump.c:17083 +#: pg_dump.c:17120 #, c-format msgid "query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned\n" msgstr "la consulta para obtener la regla «%s» asociada con la tabla «%s» falló: retornó un número incorrecto de renglones\n" -#: pg_dump.c:17472 +#: pg_dump.c:17509 #, c-format msgid "reading dependency data\n" msgstr "obteniendo datos de dependencias\n" -#: pg_dump.c:18029 +#: pg_dump.c:18066 #, c-format msgid "WARNING: could not parse reloptions array\n" msgstr "PRECAUCIÓN: no se pudo interpretar el arreglo reloptions\n" @@ -2672,24 +2668,3 @@ msgstr "" "\n" "Si no se especifica un archivo de entrada, se usa la entrada estándar.\n" "\n" - -#~ msgid "worker is terminating\n" -#~ msgstr "el proceso hijo está terminando\n" - -#~ msgid "could not get relation name for OID %u: %s\n" -#~ msgstr "no se pudo obtener un nombre de relación para el OID %u: %s\n" - -#~ msgid "unrecognized command on communication channel: %s\n" -#~ msgstr "orden no reconocida en canal de comunicación: %s\n" - -#~ msgid "terminated by user\n" -#~ msgstr "terminado por el usuario\n" - -#~ msgid "error in ListenToWorkers(): %s\n" -#~ msgstr "error en ListenToWorkers(): %s\n" - -#~ msgid "could not open output file \"%s\" for writing\n" -#~ msgstr "no se pudo abrir el archivo de salida «%s» para escritura\n" - -#~ msgid "archive member too large for tar format\n" -#~ msgstr "el miembro de archivador es demasiado grande para el formato tar\n" diff --git a/src/bin/pg_dump/po/ru.po b/src/bin/pg_dump/po/ru.po index 5d7527d066..a10bd257b4 100644 --- a/src/bin/pg_dump/po/ru.po +++ b/src/bin/pg_dump/po/ru.po @@ -11,9 +11,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_dump (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-09 21:14+0000\n" -"PO-Revision-Date: 2017-04-03 08:42+0300\n" -"Last-Translator: Alexander Lakhin \n" +"POT-Creation-Date: 2017-08-17 17:53+0000\n" +"PO-Revision-Date: 2017-08-21 06:16+0300\n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -21,6 +20,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" +"Last-Translator: Alexander Lakhin \n" #: ../../common/exec.c:127 ../../common/exec.c:241 ../../common/exec.c:284 #, c-format @@ -332,14 +332,14 @@ msgstr "не удалоÑÑŒ раÑпаковать данные: %s\n" msgid "could not close compression library: %s\n" msgstr "не удалоÑÑŒ закрыть библиотеку ÑжатиÑ: %s\n" -#: compress_io.c:596 compress_io.c:632 pg_backup_custom.c:591 -#: pg_backup_tar.c:561 +#: compress_io.c:600 compress_io.c:638 pg_backup_custom.c:591 +#: pg_backup_tar.c:566 pg_backup_tar.c:570 #, c-format msgid "could not read from input file: %s\n" msgstr "не удалоÑÑŒ прочитать входной файл: %s\n" -#: compress_io.c:635 pg_backup_custom.c:588 pg_backup_directory.c:548 -#: pg_backup_tar.c:797 pg_backup_tar.c:821 +#: compress_io.c:641 pg_backup_custom.c:588 pg_backup_directory.c:552 +#: pg_backup_tar.c:809 pg_backup_tar.c:833 #, c-format msgid "could not read from input file: end of file\n" msgstr "не удалоÑÑŒ прочитать входной файл: конец файла\n" @@ -446,36 +446,36 @@ msgstr "pgpipe: не удалоÑÑŒ принÑÑ‚ÑŒ Ñоединение (код msgid "archiver" msgstr "архиватор" -#: pg_backup_archiver.c:234 pg_backup_archiver.c:1535 +#: pg_backup_archiver.c:240 pg_backup_archiver.c:1589 #, c-format msgid "could not close output file: %s\n" msgstr "не удалоÑÑŒ закрыть выходной файл: %s\n" -#: pg_backup_archiver.c:280 pg_backup_archiver.c:285 +#: pg_backup_archiver.c:286 pg_backup_archiver.c:291 #, c-format msgid "WARNING: archive items not in correct section order\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: в поÑледовательноÑти Ñлементов архива нарушен порÑдок " "разделов\n" -#: pg_backup_archiver.c:291 +#: pg_backup_archiver.c:297 #, c-format msgid "unexpected section code %d\n" msgstr "неожиданный код раздела %d\n" -#: pg_backup_archiver.c:327 +#: pg_backup_archiver.c:333 #, c-format msgid "-C and -1 are incompatible options\n" msgstr "Параметры -C и -1 неÑовмеÑтимы\n" -#: pg_backup_archiver.c:337 +#: pg_backup_archiver.c:343 #, c-format msgid "parallel restore is not supported with this archive file format\n" msgstr "" "параллельное воÑÑтановление не поддерживаетÑÑ Ñ Ð²Ñ‹Ð±Ñ€Ð°Ð½Ð½Ñ‹Ð¼ форматом архивного " "файла\n" -#: pg_backup_archiver.c:341 +#: pg_backup_archiver.c:347 #, c-format msgid "" "parallel restore is not supported with archives made by pre-8.0 pg_dump\n" @@ -483,7 +483,7 @@ msgstr "" "параллельное воÑÑтановление возможно только Ð´Ð»Ñ Ð°Ñ€Ñ…Ð¸Ð²Ð¾Ð², Ñозданных pg_dump " "верÑии 8.0 и новее\n" -#: pg_backup_archiver.c:359 +#: pg_backup_archiver.c:365 #, c-format msgid "" "cannot restore from compressed archive (compression not supported in this " @@ -492,90 +492,80 @@ msgstr "" "воÑÑтановить данные из Ñжатого архива Ð½ÐµÐ»ÑŒÐ·Ñ (уÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð½Ð°Ñ Ð²ÐµÑ€ÑÐ¸Ñ Ð½Ðµ " "поддерживает Ñжатие)\n" -#: pg_backup_archiver.c:376 +#: pg_backup_archiver.c:382 #, c-format msgid "connecting to database for restore\n" msgstr "подключение к базе данных Ð´Ð»Ñ Ð²Ð¾ÑÑтановлениÑ\n" -#: pg_backup_archiver.c:378 +#: pg_backup_archiver.c:384 #, c-format msgid "direct database connections are not supported in pre-1.3 archives\n" msgstr "" "прÑмые Ð¿Ð¾Ð´ÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ðº базе данных не поддерживаютÑÑ Ð² архивах до верÑии 1.3\n" -#: pg_backup_archiver.c:423 +#: pg_backup_archiver.c:429 #, c-format msgid "implied data-only restore\n" msgstr "подразумеваетÑÑ Ð²Ð¾ÑÑтановление только данных\n" -#: pg_backup_archiver.c:493 +#: pg_backup_archiver.c:499 #, c-format msgid "dropping %s %s\n" msgstr "удалÑетÑÑ %s %s\n" -#: pg_backup_archiver.c:586 +#: pg_backup_archiver.c:592 #, c-format msgid "WARNING: could not find where to insert IF EXISTS in statement \"%s\"\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: не удалоÑÑŒ определить, куда добавить IF EXISTS в оператор " "\"%s\"\n" -#: pg_backup_archiver.c:662 -#, c-format -msgid "setting owner and privileges for %s \"%s.%s\"\n" -msgstr "уÑтановка владельца и прав: %s \"%s.%s\"\n" - -#: pg_backup_archiver.c:665 -#, c-format -msgid "setting owner and privileges for %s \"%s\"\n" -msgstr "уÑтановка владельца и прав: %s \"%s\"\n" - -#: pg_backup_archiver.c:731 pg_backup_archiver.c:733 +#: pg_backup_archiver.c:755 pg_backup_archiver.c:757 #, c-format msgid "warning from original dump file: %s\n" msgstr "предупреждение из иÑходного файла: %s\n" -#: pg_backup_archiver.c:742 +#: pg_backup_archiver.c:769 #, c-format msgid "creating %s \"%s.%s\"\n" msgstr "ÑоздаётÑÑ %s \"%s.%s\"\n" -#: pg_backup_archiver.c:745 +#: pg_backup_archiver.c:772 #, c-format msgid "creating %s \"%s\"\n" msgstr "ÑоздаётÑÑ %s \"%s\"\n" -#: pg_backup_archiver.c:797 +#: pg_backup_archiver.c:823 #, c-format msgid "connecting to new database \"%s\"\n" msgstr "подключение к новой базе данных \"%s\"\n" -#: pg_backup_archiver.c:825 +#: pg_backup_archiver.c:851 #, c-format msgid "processing %s\n" msgstr "обрабатываетÑÑ %s\n" -#: pg_backup_archiver.c:845 +#: pg_backup_archiver.c:871 #, c-format msgid "processing data for table \"%s.%s\"\n" msgstr "обрабатываютÑÑ Ð´Ð°Ð½Ð½Ñ‹Ðµ таблицы \"%s.%s\"\n" -#: pg_backup_archiver.c:907 +#: pg_backup_archiver.c:933 #, c-format msgid "executing %s %s\n" msgstr "выполнÑетÑÑ %s %s\n" -#: pg_backup_archiver.c:946 +#: pg_backup_archiver.c:972 #, c-format msgid "disabling triggers for %s\n" msgstr "отключаютÑÑ Ñ‚Ñ€Ð¸Ð³Ð³ÐµÑ€Ñ‹ таблицы %s\n" -#: pg_backup_archiver.c:974 +#: pg_backup_archiver.c:1000 #, c-format msgid "enabling triggers for %s\n" msgstr "включаютÑÑ Ñ‚Ñ€Ð¸Ð³Ð³ÐµÑ€Ñ‹ таблицы %s\n" -#: pg_backup_archiver.c:1004 +#: pg_backup_archiver.c:1030 #, c-format msgid "" "internal error -- WriteData cannot be called outside the context of a " @@ -584,12 +574,12 @@ msgstr "" "внутреннÑÑ Ð¾ÑˆÐ¸Ð±ÐºÐ° -- WriteData Ð½ÐµÐ»ÑŒÐ·Ñ Ð²Ñ‹Ð·Ñ‹Ð²Ð°Ñ‚ÑŒ вне контекÑта процедуры " "DataDumper\n" -#: pg_backup_archiver.c:1173 +#: pg_backup_archiver.c:1227 #, c-format msgid "large-object output not supported in chosen format\n" msgstr "выбранный формат не поддерживает выгрузку больших объектов\n" -#: pg_backup_archiver.c:1231 +#: pg_backup_archiver.c:1285 #, c-format msgid "restored %d large object\n" msgid_plural "restored %d large objects\n" @@ -597,55 +587,55 @@ msgstr[0] "воÑÑтановлен %d большой объект\n" msgstr[1] "воÑÑтановлено %d больших объекта\n" msgstr[2] "воÑÑтановлено %d больших объектов\n" -#: pg_backup_archiver.c:1252 pg_backup_tar.c:739 +#: pg_backup_archiver.c:1306 pg_backup_tar.c:751 #, c-format msgid "restoring large object with OID %u\n" msgstr "воÑÑтановление большого объекта Ñ OID %u\n" -#: pg_backup_archiver.c:1264 +#: pg_backup_archiver.c:1318 #, c-format msgid "could not create large object %u: %s" msgstr "не удалоÑÑŒ Ñоздать большой объект %u: %s" -#: pg_backup_archiver.c:1269 pg_dump.c:3070 +#: pg_backup_archiver.c:1323 pg_dump.c:3093 #, c-format msgid "could not open large object %u: %s" msgstr "не удалоÑÑŒ открыть большой объект %u: %s" -#: pg_backup_archiver.c:1327 +#: pg_backup_archiver.c:1381 #, c-format msgid "could not open TOC file \"%s\": %s\n" msgstr "не удалоÑÑŒ открыть файл Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\": %s\n" -#: pg_backup_archiver.c:1368 +#: pg_backup_archiver.c:1422 #, c-format msgid "WARNING: line ignored: %s\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: Ñтрока проигнорирована: %s\n" -#: pg_backup_archiver.c:1375 +#: pg_backup_archiver.c:1429 #, c-format msgid "could not find entry for ID %d\n" msgstr "не найдена запиÑÑŒ Ð´Ð»Ñ ID %d\n" -#: pg_backup_archiver.c:1396 pg_backup_directory.c:230 -#: pg_backup_directory.c:597 +#: pg_backup_archiver.c:1450 pg_backup_directory.c:230 +#: pg_backup_directory.c:601 #, c-format msgid "could not close TOC file: %s\n" msgstr "не удалоÑÑŒ закрыть файл оглавлениÑ: %s\n" -#: pg_backup_archiver.c:1505 pg_backup_custom.c:162 pg_backup_directory.c:341 -#: pg_backup_directory.c:583 pg_backup_directory.c:641 -#: pg_backup_directory.c:661 +#: pg_backup_archiver.c:1559 pg_backup_custom.c:162 pg_backup_directory.c:341 +#: pg_backup_directory.c:587 pg_backup_directory.c:645 +#: pg_backup_directory.c:665 #, c-format msgid "could not open output file \"%s\": %s\n" msgstr "не удалоÑÑŒ открыть выходной файл \"%s\": %s\n" -#: pg_backup_archiver.c:1508 pg_backup_custom.c:169 +#: pg_backup_archiver.c:1562 pg_backup_custom.c:169 #, c-format msgid "could not open output file: %s\n" msgstr "не удалоÑÑŒ открыть выходной файл: %s\n" -#: pg_backup_archiver.c:1614 +#: pg_backup_archiver.c:1668 #, c-format msgid "wrote %lu byte of large object data (result = %lu)\n" msgid_plural "wrote %lu bytes of large object data (result = %lu)\n" @@ -653,212 +643,212 @@ msgstr[0] "запиÑан %lu байт данных большого объек msgstr[1] "запиÑано %lu байта данных большого объекта (результат = %lu)\n" msgstr[2] "запиÑано %lu байт данных большого объекта (результат = %lu)\n" -#: pg_backup_archiver.c:1620 +#: pg_backup_archiver.c:1674 #, c-format msgid "could not write to large object (result: %lu, expected: %lu)\n" msgstr "не удалоÑÑŒ запиÑать большой объект (результат: %lu, ожидалоÑÑŒ: %lu)\n" -#: pg_backup_archiver.c:1713 +#: pg_backup_archiver.c:1767 #, c-format msgid "Error while INITIALIZING:\n" msgstr "Ошибка при инициализации:\n" -#: pg_backup_archiver.c:1718 +#: pg_backup_archiver.c:1772 #, c-format msgid "Error while PROCESSING TOC:\n" msgstr "Ошибка при обработке оглавлениÑ:\n" -#: pg_backup_archiver.c:1723 +#: pg_backup_archiver.c:1777 #, c-format msgid "Error while FINALIZING:\n" msgstr "Ошибка при завершении:\n" -#: pg_backup_archiver.c:1728 +#: pg_backup_archiver.c:1782 #, c-format msgid "Error from TOC entry %d; %u %u %s %s %s\n" msgstr "Ошибка из запиÑи Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ %d; %u %u %s %s %s\n" -#: pg_backup_archiver.c:1801 +#: pg_backup_archiver.c:1855 #, c-format msgid "bad dumpId\n" msgstr "неверный dumpId\n" -#: pg_backup_archiver.c:1822 +#: pg_backup_archiver.c:1876 #, c-format msgid "bad table dumpId for TABLE DATA item\n" msgstr "неверный dumpId таблицы в Ñлементе TABLE DATA\n" -#: pg_backup_archiver.c:1914 +#: pg_backup_archiver.c:1968 #, c-format msgid "unexpected data offset flag %d\n" msgstr "неожиданный флаг ÑÐ¼ÐµÑ‰ÐµÐ½Ð¸Ñ Ð´Ð°Ð½Ð½Ñ‹Ñ…: %d\n" -#: pg_backup_archiver.c:1927 +#: pg_backup_archiver.c:1981 #, c-format msgid "file offset in dump file is too large\n" msgstr "Ñлишком большое Ñмещение в файле вывода\n" -#: pg_backup_archiver.c:2040 +#: pg_backup_archiver.c:2094 #, c-format msgid "attempting to ascertain archive format\n" msgstr "попытка выÑÑнить формат архива\n" -#: pg_backup_archiver.c:2066 pg_backup_archiver.c:2076 +#: pg_backup_archiver.c:2120 pg_backup_archiver.c:2130 #, c-format msgid "directory name too long: \"%s\"\n" msgstr "Ñлишком длинное Ð¸Ð¼Ñ ÐºÐ°Ñ‚Ð°Ð»Ð¾Ð³Ð°: \"%s\"\n" -#: pg_backup_archiver.c:2084 +#: pg_backup_archiver.c:2138 #, c-format msgid "" "directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does not " "exist)\n" msgstr "каталог \"%s\" не похож на архивный (в нём отÑутÑтвует \"toc.dat\")\n" -#: pg_backup_archiver.c:2092 pg_backup_custom.c:181 pg_backup_custom.c:770 -#: pg_backup_directory.c:214 pg_backup_directory.c:399 +#: pg_backup_archiver.c:2146 pg_backup_custom.c:181 pg_backup_custom.c:770 +#: pg_backup_directory.c:214 pg_backup_directory.c:401 #, c-format msgid "could not open input file \"%s\": %s\n" msgstr "не удалоÑÑŒ открыть входной файл \"%s\": %s\n" -#: pg_backup_archiver.c:2100 pg_backup_custom.c:188 +#: pg_backup_archiver.c:2154 pg_backup_custom.c:188 #, c-format msgid "could not open input file: %s\n" msgstr "не удалоÑÑŒ открыть входной файл: %s\n" -#: pg_backup_archiver.c:2107 +#: pg_backup_archiver.c:2161 #, c-format msgid "could not read input file: %s\n" msgstr "не удалоÑÑŒ прочитать входной файл: %s\n" -#: pg_backup_archiver.c:2109 +#: pg_backup_archiver.c:2163 #, c-format msgid "input file is too short (read %lu, expected 5)\n" msgstr "входной файл Ñлишком короткий (прочитано байт: %lu, ожидалоÑÑŒ: 5)\n" -#: pg_backup_archiver.c:2192 +#: pg_backup_archiver.c:2246 #, c-format msgid "input file appears to be a text format dump. Please use psql.\n" msgstr "" "входной файл похоже имеет текÑтовый формат. Загрузите его Ñ Ð¿Ð¾Ð¼Ð¾Ñ‰ÑŒÑŽ psql.\n" -#: pg_backup_archiver.c:2198 +#: pg_backup_archiver.c:2252 #, c-format msgid "input file does not appear to be a valid archive (too short?)\n" msgstr "входной файл не похож на архив (возможно, Ñлишком мал?)\n" -#: pg_backup_archiver.c:2204 +#: pg_backup_archiver.c:2258 #, c-format msgid "input file does not appear to be a valid archive\n" msgstr "входной файл не похож на архив\n" -#: pg_backup_archiver.c:2224 +#: pg_backup_archiver.c:2278 #, c-format msgid "could not close input file: %s\n" msgstr "не удалоÑÑŒ закрыть входной файл: %s\n" -#: pg_backup_archiver.c:2241 +#: pg_backup_archiver.c:2295 #, c-format msgid "allocating AH for %s, format %d\n" msgstr "выделение Ñтруктуры AH Ð´Ð»Ñ %s, формат %d\n" -#: pg_backup_archiver.c:2346 +#: pg_backup_archiver.c:2400 #, c-format msgid "unrecognized file format \"%d\"\n" msgstr "неопознанный формат файла: \"%d\"\n" -#: pg_backup_archiver.c:2502 +#: pg_backup_archiver.c:2556 #, c-format msgid "entry ID %d out of range -- perhaps a corrupt TOC\n" msgstr "ID запиÑи %d вне диапазона - возможно повреждено оглавление\n" -#: pg_backup_archiver.c:2618 +#: pg_backup_archiver.c:2672 #, c-format msgid "read TOC entry %d (ID %d) for %s %s\n" msgstr "прочитана запиÑÑŒ Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ %d (ID %d): %s %s\n" -#: pg_backup_archiver.c:2652 +#: pg_backup_archiver.c:2706 #, c-format msgid "unrecognized encoding \"%s\"\n" msgstr "нераÑÐ¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð°Ñ ÐºÐ¾Ð´Ð¸Ñ€Ð¾Ð²ÐºÐ° \"%s\"\n" -#: pg_backup_archiver.c:2657 +#: pg_backup_archiver.c:2711 #, c-format msgid "invalid ENCODING item: %s\n" msgstr "неверный Ñлемент ENCODING: %s\n" -#: pg_backup_archiver.c:2675 +#: pg_backup_archiver.c:2729 #, c-format msgid "invalid STDSTRINGS item: %s\n" msgstr "неверный Ñлемент STDSTRINGS: %s\n" -#: pg_backup_archiver.c:2690 +#: pg_backup_archiver.c:2744 #, c-format msgid "schema \"%s\" not found\n" msgstr "Ñхема \"%s\" не найдена\n" -#: pg_backup_archiver.c:2697 +#: pg_backup_archiver.c:2751 #, c-format msgid "table \"%s\" not found\n" msgstr "таблица \"%s\" не найдена\n" -#: pg_backup_archiver.c:2704 +#: pg_backup_archiver.c:2758 #, c-format msgid "index \"%s\" not found\n" msgstr "Ð¸Ð½Ð´ÐµÐºÑ \"%s\" не найден\n" -#: pg_backup_archiver.c:2711 +#: pg_backup_archiver.c:2765 #, c-format msgid "function \"%s\" not found\n" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ \"%s\" не найдена\n" -#: pg_backup_archiver.c:2718 +#: pg_backup_archiver.c:2772 #, c-format msgid "trigger \"%s\" not found\n" msgstr "триггер \"%s\" не найден\n" -#: pg_backup_archiver.c:2950 +#: pg_backup_archiver.c:3036 #, c-format msgid "could not set session user to \"%s\": %s" msgstr "не удалоÑÑŒ переключить Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ ÑеÑÑии на \"%s\": %s" -#: pg_backup_archiver.c:2982 +#: pg_backup_archiver.c:3068 #, c-format msgid "could not set default_with_oids: %s" msgstr "не удалоÑÑŒ уÑтановить параметр default_with_oids: %s" -#: pg_backup_archiver.c:3127 +#: pg_backup_archiver.c:3213 #, c-format msgid "could not set search_path to \"%s\": %s" msgstr "не удалоÑÑŒ приÑвоить search_path значение \"%s\": %s" -#: pg_backup_archiver.c:3189 +#: pg_backup_archiver.c:3275 #, c-format msgid "could not set default_tablespace to %s: %s" msgstr "не удалоÑÑŒ задать Ð´Ð»Ñ default_tablespace значение %s: %s" -#: pg_backup_archiver.c:3276 pg_backup_archiver.c:3470 +#: pg_backup_archiver.c:3363 pg_backup_archiver.c:3553 #, c-format -msgid "WARNING: don't know how to set owner for object type %s\n" +msgid "WARNING: don't know how to set owner for object type \"%s\"\n" msgstr "" -"ПРЕДУПРЕЖДЕÐИЕ: неизвеÑтно, как назначить владельца Ð´Ð»Ñ Ð¾Ð±ÑŠÐµÐºÑ‚Ð° типа %s\n" +"ПРЕДУПРЕЖДЕÐИЕ: неизвеÑтно, как назначить владельца Ð´Ð»Ñ Ð¾Ð±ÑŠÐµÐºÑ‚Ð° типа \"%s\"\n" -#: pg_backup_archiver.c:3552 +#: pg_backup_archiver.c:3639 #, c-format msgid "did not find magic string in file header\n" msgstr "в файле заголовка не найдена магичеÑÐºÐ°Ñ Ñтрока\n" -#: pg_backup_archiver.c:3565 +#: pg_backup_archiver.c:3652 #, c-format msgid "unsupported version (%d.%d) in file header\n" msgstr "Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ€Ð¶Ð¸Ð²Ð°ÐµÐ¼Ð°Ñ Ð²ÐµÑ€ÑÐ¸Ñ (%d.%d) в заголовке файла\n" -#: pg_backup_archiver.c:3570 +#: pg_backup_archiver.c:3657 #, c-format msgid "sanity check on integer size (%lu) failed\n" msgstr "неÑоответÑтвие размера integer (%lu)\n" -#: pg_backup_archiver.c:3574 +#: pg_backup_archiver.c:3661 #, c-format msgid "" "WARNING: archive was made on a machine with larger integers, some operations " @@ -867,12 +857,12 @@ msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: архив был Ñделан на компьютере большей разрÑдноÑти -- " "возможен Ñбой некоторых операций\n" -#: pg_backup_archiver.c:3584 +#: pg_backup_archiver.c:3671 #, c-format msgid "expected format (%d) differs from format found in file (%d)\n" msgstr "ожидаемый формат (%d) отличаетÑÑ Ð¾Ñ‚ формата, указанного в файле (%d)\n" -#: pg_backup_archiver.c:3600 +#: pg_backup_archiver.c:3687 #, c-format msgid "" "WARNING: archive is compressed, but this installation does not support " @@ -881,87 +871,87 @@ msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: архив Ñжат, но уÑÑ‚Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð½Ð°Ñ Ð²ÐµÑ€ÑÐ¸Ñ Ð½Ðµ поддерживает Ñжатие " "-- данные недоÑтупны\n" -#: pg_backup_archiver.c:3618 +#: pg_backup_archiver.c:3705 #, c-format msgid "WARNING: invalid creation date in header\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð´Ð°Ñ‚Ð° ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ Ð² заголовке\n" -#: pg_backup_archiver.c:3693 +#: pg_backup_archiver.c:3778 #, c-format msgid "entering restore_toc_entries_prefork\n" msgstr "вход в restore_toc_entries_prefork\n" -#: pg_backup_archiver.c:3737 +#: pg_backup_archiver.c:3841 #, c-format msgid "processing item %d %s %s\n" msgstr "обработка объекта %d %s %s\n" -#: pg_backup_archiver.c:3789 +#: pg_backup_archiver.c:3895 #, c-format msgid "entering restore_toc_entries_parallel\n" msgstr "вход в restore_toc_entries_parallel\n" -#: pg_backup_archiver.c:3837 +#: pg_backup_archiver.c:3916 #, c-format msgid "entering main parallel loop\n" msgstr "вход в оÑновной параллельный цикл\n" -#: pg_backup_archiver.c:3848 +#: pg_backup_archiver.c:3927 #, c-format msgid "skipping item %d %s %s\n" msgstr "объект %d %s %s пропуÑкаетÑÑ\n" -#: pg_backup_archiver.c:3858 +#: pg_backup_archiver.c:3937 #, c-format msgid "launching item %d %s %s\n" msgstr "объект %d %s %s запуÑкаетÑÑ\n" -#: pg_backup_archiver.c:3914 +#: pg_backup_archiver.c:4018 #, c-format msgid "finished main parallel loop\n" msgstr "оÑновной параллельный цикл закончен\n" -#: pg_backup_archiver.c:3923 +#: pg_backup_archiver.c:4036 #, c-format msgid "entering restore_toc_entries_postfork\n" msgstr "вход в restore_toc_entries_postfork\n" -#: pg_backup_archiver.c:3942 +#: pg_backup_archiver.c:4056 #, c-format msgid "processing missed item %d %s %s\n" msgstr "обработка пропущенного объекта %d %s %s\n" -#: pg_backup_archiver.c:4091 +#: pg_backup_archiver.c:4233 #, c-format msgid "no item ready\n" msgstr "Ñлемент не готов\n" -#: pg_backup_archiver.c:4139 +#: pg_backup_archiver.c:4281 #, c-format msgid "could not find slot of finished worker\n" msgstr "не удалоÑÑŒ найти Ñлот законченного рабочего объекта\n" -#: pg_backup_archiver.c:4141 +#: pg_backup_archiver.c:4283 #, c-format msgid "finished item %d %s %s\n" msgstr "закончен объект %d %s %s\n" -#: pg_backup_archiver.c:4154 +#: pg_backup_archiver.c:4296 #, c-format msgid "worker process failed: exit code %d\n" msgstr "рабочий процеÑÑ Ð·Ð°Ð²ÐµÑ€ÑˆÐ¸Ð»ÑÑ Ñ ÐºÐ¾Ð´Ð¾Ð¼ возврата %d\n" -#: pg_backup_archiver.c:4316 +#: pg_backup_archiver.c:4458 #, c-format msgid "transferring dependency %d -> %d to %d\n" msgstr "переключение завиÑимоÑти %d -> %d на %d\n" -#: pg_backup_archiver.c:4389 +#: pg_backup_archiver.c:4531 #, c-format msgid "reducing dependencies for %d\n" msgstr "уменьшение завиÑимоÑтей Ð´Ð»Ñ %d\n" -#: pg_backup_archiver.c:4428 +#: pg_backup_archiver.c:4579 #, c-format msgid "table \"%s\" could not be created, will not restore its data\n" msgstr "Ñоздать таблицу \"%s\" не удалоÑÑŒ, её данные не будут воÑÑтановлены\n" @@ -1023,7 +1013,7 @@ msgid "unrecognized data block type %d while restoring archive\n" msgstr "нераÑпознанный тип блока данных %d при воÑÑтановлении архива\n" #: pg_backup_custom.c:709 pg_backup_custom.c:759 pg_backup_custom.c:908 -#: pg_backup_tar.c:1088 +#: pg_backup_tar.c:1100 #, c-format msgid "could not determine seek position in archive file: %s\n" msgstr "не удалоÑÑŒ определить позицию в файле архива: %s\n" @@ -1173,7 +1163,7 @@ msgstr "ошибка в PQputCopyEnd: %s" msgid "COPY failed for table \"%s\": %s" msgstr "Ñбой команды COPY Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\": %s" -#: pg_backup_db.c:657 pg_dump.c:1805 +#: pg_backup_db.c:657 pg_dump.c:1814 #, c-format msgid "WARNING: unexpected extra results during COPY of table \"%s\"\n" msgstr "" @@ -1213,43 +1203,49 @@ msgstr "не удалоÑÑŒ закрыть каталог \"%s\": %s\n" msgid "could not create directory \"%s\": %s\n" msgstr "Ñоздать каталог \"%s\" не удалоÑÑŒ: %s\n" -#: pg_backup_directory.c:412 +#: pg_backup_directory.c:360 pg_backup_directory.c:500 +#: pg_backup_directory.c:530 +#, c-format +msgid "could not write to output file: %s\n" +msgstr "не удалоÑÑŒ запиÑать в выходной файл: %s\n" + +#: pg_backup_directory.c:414 #, c-format msgid "could not close data file: %s\n" msgstr "не удалоÑÑŒ закрыть файл данных: %s\n" -#: pg_backup_directory.c:453 +#: pg_backup_directory.c:455 #, c-format msgid "could not open large object TOC file \"%s\" for input: %s\n" msgstr "" "не удалоÑÑŒ открыть Ð´Ð»Ñ Ñ‡Ñ‚ÐµÐ½Ð¸Ñ Ñ„Ð°Ð¹Ð» Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ð±Ð¾Ð»ÑŒÑˆÐ¸Ñ… объектов \"%s\": %s\n" -#: pg_backup_directory.c:464 +#: pg_backup_directory.c:466 #, c-format msgid "invalid line in large object TOC file \"%s\": \"%s\"\n" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ñтрока в файле Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ð±Ð¾Ð»ÑŒÑˆÐ¸Ñ… объектов \"%s\": \"%s\"\n" -#: pg_backup_directory.c:473 +#: pg_backup_directory.c:475 #, c-format msgid "error reading large object TOC file \"%s\"\n" msgstr "ошибка Ñ‡Ñ‚ÐµÐ½Ð¸Ñ Ñ„Ð°Ð¹Ð»Ð° Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ð±Ð¾Ð»ÑŒÑˆÐ¸Ñ… объектов \"%s\"\n" -#: pg_backup_directory.c:477 +#: pg_backup_directory.c:479 #, c-format msgid "could not close large object TOC file \"%s\": %s\n" msgstr "не удалоÑÑŒ закрыть файл Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ð±Ð¾Ð»ÑŒÑˆÐ¸Ñ… объектов \"%s\": %s\n" -#: pg_backup_directory.c:684 +#: pg_backup_directory.c:688 #, c-format msgid "could not write to blobs TOC file\n" msgstr "не удалоÑÑŒ запиÑать в файл Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ð±Ð¾Ð»ÑŒÑˆÐ¸Ñ… объектов\n" -#: pg_backup_directory.c:716 +#: pg_backup_directory.c:720 #, c-format msgid "file name too long: \"%s\"\n" msgstr "Ñлишком длинное Ð¸Ð¼Ñ Ñ„Ð°Ð¹Ð»Ð°: \"%s\"\n" -#: pg_backup_directory.c:802 +#: pg_backup_directory.c:806 #, c-format msgid "error during backup\n" msgstr "ошибка в процеÑÑе резервного копированиÑ\n" @@ -1309,52 +1305,52 @@ msgstr "не удалоÑÑŒ открыть временный файл\n" msgid "could not close tar member\n" msgstr "не удалоÑÑŒ закрыть компонент tar-архива\n" -#: pg_backup_tar.c:571 +#: pg_backup_tar.c:583 #, c-format msgid "internal error -- neither th nor fh specified in tarReadRaw()\n" msgstr "внутреннÑÑ Ð¾ÑˆÐ¸Ð±ÐºÐ° -- в tarReadRaw() не указан ни th, ни fh\n" -#: pg_backup_tar.c:694 +#: pg_backup_tar.c:706 #, c-format msgid "unexpected COPY statement syntax: \"%s\"\n" msgstr "недопуÑтимый ÑинтакÑÐ¸Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° COPY: \"%s\"\n" -#: pg_backup_tar.c:960 +#: pg_backup_tar.c:972 #, c-format msgid "invalid OID for large object (%u)\n" msgstr "неверный OID Ð´Ð»Ñ Ð±Ð¾Ð»ÑŒÑˆÐ¾Ð³Ð¾ объекта (%u)\n" -#: pg_backup_tar.c:1104 +#: pg_backup_tar.c:1116 #, c-format msgid "could not close temporary file: %s\n" msgstr "не удалоÑÑŒ закрыть временный файл: %s\n" -#: pg_backup_tar.c:1114 +#: pg_backup_tar.c:1126 #, c-format msgid "actual file length (%s) does not match expected (%s)\n" msgstr "дейÑÑ‚Ð²Ð¸Ñ‚ÐµÐ»ÑŒÐ½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° файла (%s) не равна ожидаемой (%s)\n" -#: pg_backup_tar.c:1151 +#: pg_backup_tar.c:1163 #, c-format msgid "moving from position %s to next member at file position %s\n" msgstr "переход от позиции %s к Ñледующему компоненту в позиции %s\n" -#: pg_backup_tar.c:1162 +#: pg_backup_tar.c:1174 #, c-format msgid "now at file position %s\n" msgstr "Ñ‚ÐµÐºÑƒÑ‰Ð°Ñ Ð¿Ð¾Ð·Ð¸Ñ†Ð¸Ñ Ð² файле %s\n" -#: pg_backup_tar.c:1171 pg_backup_tar.c:1201 +#: pg_backup_tar.c:1183 pg_backup_tar.c:1213 #, c-format msgid "could not find header for file \"%s\" in tar archive\n" msgstr "в архиве tar не найден заголовок Ð´Ð»Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\"\n" -#: pg_backup_tar.c:1185 +#: pg_backup_tar.c:1197 #, c-format msgid "skipping tar member %s\n" msgstr "пропуÑкаетÑÑ ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ‚ tar %s\n" -#: pg_backup_tar.c:1189 +#: pg_backup_tar.c:1201 #, c-format msgid "" "restoring data out of order is not supported in this archive format: \"%s\" " @@ -1364,7 +1360,7 @@ msgstr "" "поддерживаетÑÑ: требуетÑÑ ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ‚ \"%s\", но в файле архива прежде идёт " "\"%s\".\n" -#: pg_backup_tar.c:1235 +#: pg_backup_tar.c:1247 #, c-format msgid "incomplete tar header found (%lu byte)\n" msgid_plural "incomplete tar header found (%lu bytes)\n" @@ -1373,12 +1369,12 @@ msgstr[1] "найден неполный tar-заголовок (размер %l msgstr[2] "найден неполный tar-заголовок (размер %lu байтов)\n" # skip-rule: capital-letter-first -#: pg_backup_tar.c:1276 +#: pg_backup_tar.c:1288 #, c-format msgid "TOC Entry %s at %s (length %s, checksum %d)\n" msgstr "ЗапиÑÑŒ Ð¾Ð³Ð»Ð°Ð²Ð»ÐµÐ½Ð¸Ñ %s в %s (длина: %s, контр. Ñумма: %d)\n" -#: pg_backup_tar.c:1287 +#: pg_backup_tar.c:1299 #, c-format msgid "" "corrupt tar header found in %s (expected %d, computed %d) file position %s\n" @@ -1492,7 +1488,7 @@ msgstr "ÑоответÑтвующие Ñхемы не найдены\n" msgid "no matching tables were found\n" msgstr "ÑоответÑтвующие таблицы не найдены\n" -#: pg_dump.c:888 +#: pg_dump.c:897 #, c-format msgid "" "%s dumps a database as a text file or to other formats.\n" @@ -1501,17 +1497,17 @@ msgstr "" "%s ÑохранÑет резервную копию БД в текÑтовом файле или другом виде.\n" "\n" -#: pg_dump.c:889 pg_dumpall.c:547 pg_restore.c:443 +#: pg_dump.c:898 pg_dumpall.c:547 pg_restore.c:443 #, c-format msgid "Usage:\n" msgstr "ИÑпользование:\n" -#: pg_dump.c:890 +#: pg_dump.c:899 #, c-format msgid " %s [OPTION]... [DBNAME]\n" msgstr " %s [ПÐРÐМЕТР]... [ИМЯ_БД]\n" -#: pg_dump.c:892 pg_dumpall.c:550 pg_restore.c:446 +#: pg_dump.c:901 pg_dumpall.c:550 pg_restore.c:446 #, c-format msgid "" "\n" @@ -1520,12 +1516,12 @@ msgstr "" "\n" "Общие параметры:\n" -#: pg_dump.c:893 +#: pg_dump.c:902 #, c-format msgid " -f, --file=FILENAME output file or directory name\n" msgstr " -f, --file=ИМЯ Ð¸Ð¼Ñ Ð²Ñ‹Ñ…Ð¾Ð´Ð½Ð¾Ð³Ð¾ файла или каталога\n" -#: pg_dump.c:894 +#: pg_dump.c:903 #, c-format msgid "" " -F, --format=c|d|t|p output file format (custom, directory, tar,\n" @@ -1535,7 +1531,7 @@ msgstr "" " (пользовательÑкий | каталог | tar |\n" " текÑтовый (по умолчанию))\n" -#: pg_dump.c:896 +#: pg_dump.c:905 #, c-format msgid " -j, --jobs=NUM use this many parallel jobs to dump\n" msgstr "" @@ -1543,23 +1539,23 @@ msgstr "" "чиÑло\n" " заданий\n" -#: pg_dump.c:897 pg_dumpall.c:552 +#: pg_dump.c:906 pg_dumpall.c:552 #, c-format msgid " -v, --verbose verbose mode\n" msgstr " -v, --verbose режим подробных Ñообщений\n" -#: pg_dump.c:898 pg_dumpall.c:553 +#: pg_dump.c:907 pg_dumpall.c:553 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version показать верÑию и выйти\n" -#: pg_dump.c:899 +#: pg_dump.c:908 #, c-format msgid "" " -Z, --compress=0-9 compression level for compressed formats\n" msgstr " -Z, --compress=0-9 уровень ÑÐ¶Ð°Ñ‚Ð¸Ñ Ð¿Ñ€Ð¸ архивации\n" -#: pg_dump.c:900 pg_dumpall.c:554 +#: pg_dump.c:909 pg_dumpall.c:554 #, c-format msgid "" " --lock-wait-timeout=TIMEOUT fail after waiting TIMEOUT for a table lock\n" @@ -1567,12 +1563,12 @@ msgstr "" " --lock-wait-timeout=ТÐЙМÐУТ прервать операцию при таймауте блокировки " "таблицы\n" -#: pg_dump.c:901 pg_dumpall.c:555 +#: pg_dump.c:910 pg_dumpall.c:555 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help показать Ñту Ñправку и выйти\n" -#: pg_dump.c:903 pg_dumpall.c:556 +#: pg_dump.c:912 pg_dumpall.c:556 #, c-format msgid "" "\n" @@ -1581,17 +1577,17 @@ msgstr "" "\n" "Параметры, управлÑющие выводом:\n" -#: pg_dump.c:904 pg_dumpall.c:557 +#: pg_dump.c:913 pg_dumpall.c:557 #, c-format msgid " -a, --data-only dump only the data, not the schema\n" msgstr " -a, --data-only выгрузить только данные, без Ñхемы\n" -#: pg_dump.c:905 +#: pg_dump.c:914 #, c-format msgid " -b, --blobs include large objects in dump\n" msgstr " -b, --blobs выгрузить также большие объекты\n" -#: pg_dump.c:906 pg_restore.c:457 +#: pg_dump.c:915 pg_restore.c:457 #, c-format msgid "" " -c, --clean clean (drop) database objects before " @@ -1600,7 +1596,7 @@ msgstr "" " -c, --clean очиÑтить (удалить) объекты БД при " "воÑÑтановлении\n" -#: pg_dump.c:907 +#: pg_dump.c:916 #, c-format msgid "" " -C, --create include commands to create database in dump\n" @@ -1608,27 +1604,27 @@ msgstr "" " -C, --create добавить в копию команды ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ Ð±Ð°Ð·Ñ‹ " "данных\n" -#: pg_dump.c:908 +#: pg_dump.c:917 #, c-format msgid " -E, --encoding=ENCODING dump the data in encoding ENCODING\n" msgstr " -E, --encoding=КОДИРОВКРвыгружать данные в заданной кодировке\n" -#: pg_dump.c:909 +#: pg_dump.c:918 #, c-format msgid " -n, --schema=SCHEMA dump the named schema(s) only\n" msgstr " -n, --schema=СХЕМРвыгрузить только указанную Ñхему(Ñ‹)\n" -#: pg_dump.c:910 +#: pg_dump.c:919 #, c-format msgid " -N, --exclude-schema=SCHEMA do NOT dump the named schema(s)\n" msgstr " -N, --exclude-schema=СХЕМРÐЕ выгружать указанную Ñхему(Ñ‹)\n" -#: pg_dump.c:911 pg_dumpall.c:560 +#: pg_dump.c:920 pg_dumpall.c:560 #, c-format msgid " -o, --oids include OIDs in dump\n" msgstr " -o, --oids выгружать данные Ñ OID\n" -#: pg_dump.c:912 +#: pg_dump.c:921 #, c-format msgid "" " -O, --no-owner skip restoration of object ownership in\n" @@ -1637,12 +1633,12 @@ msgstr "" " -O, --no-owner не воÑÑтанавливать владение объектами\n" " при иÑпользовании текÑтового формата\n" -#: pg_dump.c:914 pg_dumpall.c:563 +#: pg_dump.c:923 pg_dumpall.c:563 #, c-format msgid " -s, --schema-only dump only the schema, no data\n" msgstr " -s, --schema-only выгрузить только Ñхему, без данных\n" -#: pg_dump.c:915 +#: pg_dump.c:924 #, c-format msgid "" " -S, --superuser=NAME superuser user name to use in plain-text " @@ -1651,27 +1647,27 @@ msgstr "" " -S, --superuser=ИМЯ Ð¸Ð¼Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ, который будет задейÑтвован\n" " при воÑÑтановлении из текÑтового формата\n" -#: pg_dump.c:916 +#: pg_dump.c:925 #, c-format msgid " -t, --table=TABLE dump the named table(s) only\n" msgstr " -t, --table=ТÐБЛИЦРвыгрузить только указанную таблицу(Ñ‹)\n" -#: pg_dump.c:917 +#: pg_dump.c:926 #, c-format msgid " -T, --exclude-table=TABLE do NOT dump the named table(s)\n" msgstr " -T, --exclude-table=ТÐБЛИЦРÐЕ выгружать указанную таблицу(Ñ‹)\n" -#: pg_dump.c:918 pg_dumpall.c:566 +#: pg_dump.c:927 pg_dumpall.c:566 #, c-format msgid " -x, --no-privileges do not dump privileges (grant/revoke)\n" msgstr " -x, --no-privileges не выгружать права (назначение/отзыв)\n" -#: pg_dump.c:919 pg_dumpall.c:567 +#: pg_dump.c:928 pg_dumpall.c:567 #, c-format msgid " --binary-upgrade for use by upgrade utilities only\n" msgstr " --binary-upgrade только Ð´Ð»Ñ ÑƒÑ‚Ð¸Ð»Ð¸Ñ‚ Ð¾Ð±Ð½Ð¾Ð²Ð»ÐµÐ½Ð¸Ñ Ð‘Ð”\n" -#: pg_dump.c:920 pg_dumpall.c:568 +#: pg_dump.c:929 pg_dumpall.c:568 #, c-format msgid "" " --column-inserts dump data as INSERT commands with column " @@ -1680,7 +1676,7 @@ msgstr "" " --column-inserts выгружать данные в виде INSERT Ñ Ð¸Ð¼ÐµÐ½Ð°Ð¼Ð¸ " "Ñтолбцов\n" -#: pg_dump.c:921 pg_dumpall.c:569 +#: pg_dump.c:930 pg_dumpall.c:569 #, c-format msgid "" " --disable-dollar-quoting disable dollar quoting, use SQL standard " @@ -1689,7 +1685,7 @@ msgstr "" " --disable-dollar-quoting отключить ÑпецÑтроки Ñ $, выводить Ñтроки\n" " по Ñтандарту SQL\n" -#: pg_dump.c:922 pg_dumpall.c:570 pg_restore.c:473 +#: pg_dump.c:931 pg_dumpall.c:570 pg_restore.c:473 #, c-format msgid "" " --disable-triggers disable triggers during data-only restore\n" @@ -1697,7 +1693,7 @@ msgstr "" " --disable-triggers отключить триггеры при воÑÑтановлении\n" " только данных, без Ñхемы\n" -#: pg_dump.c:923 +#: pg_dump.c:932 #, c-format msgid "" " --enable-row-security enable row security (dump only content user " @@ -1708,19 +1704,19 @@ msgstr "" "только\n" " те данные, которые доÑтупны пользователю)\n" -#: pg_dump.c:925 +#: pg_dump.c:934 #, c-format msgid "" " --exclude-table-data=TABLE do NOT dump data for the named table(s)\n" msgstr " --exclude-table-data=ТÐБЛИЦРÐЕ выгружать указанную таблицу(Ñ‹)\n" -#: pg_dump.c:926 pg_dumpall.c:571 pg_restore.c:475 +#: pg_dump.c:935 pg_dumpall.c:571 pg_restore.c:475 #, c-format msgid " --if-exists use IF EXISTS when dropping objects\n" msgstr "" " --if-exists применÑÑ‚ÑŒ IF EXISTS при удалении объектов\n" -#: pg_dump.c:927 pg_dumpall.c:572 +#: pg_dump.c:936 pg_dumpall.c:572 #, c-format msgid "" " --inserts dump data as INSERT commands, rather than " @@ -1729,13 +1725,13 @@ msgstr "" " --inserts выгрузить данные в виде команд INSERT, не " "COPY\n" -#: pg_dump.c:928 pg_dumpall.c:573 +#: pg_dump.c:937 pg_dumpall.c:573 #, c-format msgid " --no-security-labels do not dump security label assignments\n" msgstr "" " --no-security-labels не выгружать Ð½Ð°Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ Ð¼ÐµÑ‚Ð¾Ðº безопаÑноÑти\n" -#: pg_dump.c:929 +#: pg_dump.c:938 #, c-format msgid "" " --no-synchronized-snapshots do not use synchronized snapshots in parallel " @@ -1744,20 +1740,20 @@ msgstr "" " --no-synchronized-snapshots не иÑпользовать Ñинхронизированные Ñнимки\n" " в параллельных заданиÑÑ…\n" -#: pg_dump.c:930 pg_dumpall.c:574 +#: pg_dump.c:939 pg_dumpall.c:574 #, c-format msgid " --no-tablespaces do not dump tablespace assignments\n" msgstr "" " --no-tablespaces не выгружать Ð½Ð°Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ‡Ð½Ñ‹Ñ… " "проÑтранÑтв\n" -#: pg_dump.c:931 pg_dumpall.c:575 +#: pg_dump.c:940 pg_dumpall.c:575 #, c-format msgid " --no-unlogged-table-data do not dump unlogged table data\n" msgstr "" " --no-unlogged-table-data не выгружать данные нежурналируемых таблиц\n" -#: pg_dump.c:932 pg_dumpall.c:576 +#: pg_dump.c:941 pg_dumpall.c:576 #, c-format msgid "" " --quote-all-identifiers quote all identifiers, even if not key words\n" @@ -1765,7 +1761,7 @@ msgstr "" " --quote-all-identifiers заключать в кавычки вÑе идентификаторы,\n" " а не только ключевые Ñлова\n" -#: pg_dump.c:933 +#: pg_dump.c:942 #, c-format msgid "" " --section=SECTION dump named section (pre-data, data, or post-" @@ -1774,7 +1770,7 @@ msgstr "" " --section=РÐЗДЕЛ выгрузить заданный раздел\n" " (pre-data, data или post-data)\n" -#: pg_dump.c:934 +#: pg_dump.c:943 #, c-format msgid "" " --serializable-deferrable wait until the dump can run without " @@ -1783,13 +1779,13 @@ msgstr "" " --serializable-deferrable дождатьÑÑ Ð¼Ð¾Ð¼ÐµÐ½Ñ‚Ð° Ð´Ð»Ñ Ð²Ñ‹Ð³Ñ€ÑƒÐ·ÐºÐ¸ данных без " "аномалий\n" -#: pg_dump.c:935 +#: pg_dump.c:944 #, c-format msgid " --snapshot=SNAPSHOT use given snapshot for the dump\n" msgstr "" " --snapshot=СÐИМОК иÑпользовать при выгрузке заданный Ñнимок\n" -#: pg_dump.c:936 pg_restore.c:481 +#: pg_dump.c:945 pg_restore.c:481 #, c-format msgid "" " --strict-names require table and/or schema include patterns " @@ -1802,7 +1798,7 @@ msgstr "" "минимум\n" " один объект\n" -#: pg_dump.c:938 pg_dumpall.c:577 pg_restore.c:483 +#: pg_dump.c:947 pg_dumpall.c:577 pg_restore.c:483 #, c-format msgid "" " --use-set-session-authorization\n" @@ -1814,7 +1810,7 @@ msgstr "" " уÑтанавливать владельца, иÑÐ¿Ð¾Ð»ÑŒÐ·ÑƒÑ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ‹\n" " SET SESSION AUTHORIZATION вмеÑто ALTER OWNER\n" -#: pg_dump.c:942 pg_dumpall.c:581 pg_restore.c:487 +#: pg_dump.c:951 pg_dumpall.c:581 pg_restore.c:487 #, c-format msgid "" "\n" @@ -1823,33 +1819,33 @@ msgstr "" "\n" "Параметры подключениÑ:\n" -#: pg_dump.c:943 +#: pg_dump.c:952 #, c-format msgid " -d, --dbname=DBNAME database to dump\n" msgstr " -d, --dbname=БД Ð¸Ð¼Ñ Ð±Ð°Ð·Ñ‹ данных Ð´Ð»Ñ Ð²Ñ‹Ð³Ñ€ÑƒÐ·ÐºÐ¸\n" -#: pg_dump.c:944 pg_dumpall.c:583 pg_restore.c:488 +#: pg_dump.c:953 pg_dumpall.c:583 pg_restore.c:488 #, c-format msgid " -h, --host=HOSTNAME database server host or socket directory\n" msgstr "" " -h, --host=ИМЯ Ð¸Ð¼Ñ Ñервера баз данных или каталог Ñокетов\n" -#: pg_dump.c:945 pg_dumpall.c:585 pg_restore.c:489 +#: pg_dump.c:954 pg_dumpall.c:585 pg_restore.c:489 #, c-format msgid " -p, --port=PORT database server port number\n" msgstr " -p, --port=ПОРТ номер порта Ñервера БД\n" -#: pg_dump.c:946 pg_dumpall.c:586 pg_restore.c:490 +#: pg_dump.c:955 pg_dumpall.c:586 pg_restore.c:490 #, c-format msgid " -U, --username=NAME connect as specified database user\n" msgstr " -U, --username=ИМЯ Ð¸Ð¼Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð±Ð°Ð· данных\n" -#: pg_dump.c:947 pg_dumpall.c:587 pg_restore.c:491 +#: pg_dump.c:956 pg_dumpall.c:587 pg_restore.c:491 #, c-format msgid " -w, --no-password never prompt for password\n" msgstr " -w, --no-password не запрашивать пароль\n" -#: pg_dump.c:948 pg_dumpall.c:588 pg_restore.c:492 +#: pg_dump.c:957 pg_dumpall.c:588 pg_restore.c:492 #, c-format msgid "" " -W, --password force password prompt (should happen " @@ -1857,12 +1853,12 @@ msgid "" msgstr "" " -W, --password запрашивать пароль вÑегда (обычно не требуетÑÑ)\n" -#: pg_dump.c:949 pg_dumpall.c:589 +#: pg_dump.c:958 pg_dumpall.c:589 #, c-format msgid " --role=ROLENAME do SET ROLE before dump\n" msgstr " --role=ИМЯ_РОЛИ выполнить SET ROLE перед выгрузкой\n" -#: pg_dump.c:951 +#: pg_dump.c:960 #, c-format msgid "" "\n" @@ -1875,194 +1871,194 @@ msgstr "" "PGDATABASE.\n" "\n" -#: pg_dump.c:953 pg_dumpall.c:593 pg_restore.c:499 +#: pg_dump.c:962 pg_dumpall.c:593 pg_restore.c:499 #, c-format msgid "Report bugs to .\n" msgstr "Об ошибках Ñообщайте по адреÑу .\n" -#: pg_dump.c:970 +#: pg_dump.c:979 #, c-format msgid "invalid client encoding \"%s\" specified\n" msgstr "указана Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ ÐºÐ»Ð¸ÐµÐ½Ñ‚ÑÐºÐ°Ñ ÐºÐ¾Ð´Ð¸Ñ€Ð¾Ð²ÐºÐ° \"%s\"\n" -#: pg_dump.c:1112 +#: pg_dump.c:1121 #, c-format msgid "" "Synchronized snapshots are not supported on standby servers.\n" "Run with --no-synchronized-snapshots instead if you do not need\n" "synchronized snapshots.\n" msgstr "" -"Ðа резервных Ñерверах Ñинхронизированные Ñнимки не поддерживаютÑÑ.\n" +"Ðа ведомых Ñерверах Ñинхронизированные Ñнимки не поддерживаютÑÑ.\n" "ЕÑли они вам не нужны, укажите при запуÑке ключ\n" "--no-synchronized-snapshots.\n" -#: pg_dump.c:1181 +#: pg_dump.c:1190 #, c-format msgid "invalid output format \"%s\" specified\n" msgstr "указан неверный формат вывода: \"%s\"\n" -#: pg_dump.c:1204 +#: pg_dump.c:1213 #, c-format msgid "server version must be at least 7.3 to use schema selection switches\n" msgstr "" "Ð´Ð»Ñ Ð¸ÑÐ¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð² выбора Ñхемы нужен Ñервер верÑии 7.3 или новее\n" -#: pg_dump.c:1222 +#: pg_dump.c:1231 #, c-format msgid "no matching schemas were found for pattern \"%s\"\n" msgstr "Ñхемы, ÑоответÑтвующие шаблону \"%s\", не найдены\n" -#: pg_dump.c:1275 +#: pg_dump.c:1284 #, c-format msgid "no matching tables were found for pattern \"%s\"\n" msgstr "таблицы, ÑоответÑтвующие шаблону \"%s\", не найдены\n" -#: pg_dump.c:1662 +#: pg_dump.c:1671 #, c-format msgid "dumping contents of table \"%s.%s\"\n" msgstr "выгрузка Ñодержимого таблицы \"%s.%s\"\n" -#: pg_dump.c:1786 +#: pg_dump.c:1795 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.\n" msgstr "Ошибка выгрузки таблицы \"%s\": Ñбой в PQendcopy().\n" -#: pg_dump.c:1787 pg_dump.c:1797 +#: pg_dump.c:1796 pg_dump.c:1806 #, c-format msgid "Error message from server: %s" msgstr "Сообщение об ошибке Ñ Ñервера: %s" -#: pg_dump.c:1788 pg_dump.c:1798 +#: pg_dump.c:1797 pg_dump.c:1807 #, c-format msgid "The command was: %s\n" msgstr "ВыполнÑлаÑÑŒ команда: %s\n" -#: pg_dump.c:1796 +#: pg_dump.c:1805 #, c-format msgid "Dumping the contents of table \"%s\" failed: PQgetResult() failed.\n" msgstr "Ошибка выгрузки таблицы \"%s\": Ñбой в PQgetResult().\n" -#: pg_dump.c:2445 +#: pg_dump.c:2454 #, c-format msgid "saving database definition\n" msgstr "Ñохранение Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ Ð±Ð°Ð·Ñ‹ данных\n" -#: pg_dump.c:2779 +#: pg_dump.c:2788 #, c-format msgid "saving encoding = %s\n" msgstr "Ñохранение кодировки (%s)\n" -#: pg_dump.c:2806 +#: pg_dump.c:2815 #, c-format msgid "saving standard_conforming_strings = %s\n" msgstr "Ñохранение standard_conforming_strings (%s)\n" -#: pg_dump.c:2846 +#: pg_dump.c:2855 #, c-format msgid "reading large objects\n" msgstr "чтение больших объектов\n" -#: pg_dump.c:3033 +#: pg_dump.c:3056 #, c-format msgid "saving large objects\n" msgstr "Ñохранение больших объектов\n" -#: pg_dump.c:3080 +#: pg_dump.c:3103 #, c-format msgid "error reading large object %u: %s" msgstr "ошибка Ñ‡Ñ‚ÐµÐ½Ð¸Ñ Ð±Ð¾Ð»ÑŒÑˆÐ¾Ð³Ð¾ объекта %u: %s" -#: pg_dump.c:3132 +#: pg_dump.c:3155 #, c-format msgid "reading row security enabled for table \"%s.%s\"\n" msgstr "чтение информации о защите Ñтрок Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s.%s\"\n" -#: pg_dump.c:3163 +#: pg_dump.c:3186 #, c-format msgid "reading policies for table \"%s.%s\"\n" msgstr "чтение политик таблицы \"%s.%s\"\n" -#: pg_dump.c:3296 +#: pg_dump.c:3319 #, c-format msgid "unexpected policy command type: \"%s\"\n" msgstr "нераÑпознанный тип команды в политике: \"%s\"\n" -#: pg_dump.c:3515 +#: pg_dump.c:3538 #, c-format msgid "could not find parent extension for %s\n" msgstr "не удалоÑÑŒ найти родительÑкое раÑширение Ð´Ð»Ñ %s\n" # TO REVIEW -#: pg_dump.c:3683 +#: pg_dump.c:3731 #, c-format msgid "WARNING: owner of schema \"%s\" appears to be invalid\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: у Ñхемы \"%s\" по-видимому неправильный владелец\n" -#: pg_dump.c:3726 +#: pg_dump.c:3774 #, c-format msgid "schema with OID %u does not exist\n" msgstr "Ñхема Ñ OID %u не ÑущеÑтвует\n" -#: pg_dump.c:4141 +#: pg_dump.c:4189 #, c-format msgid "WARNING: owner of data type \"%s\" appears to be invalid\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: у типа данных \"%s\" по-видимому неправильный владелец\n" -#: pg_dump.c:4255 +#: pg_dump.c:4303 #, c-format msgid "WARNING: owner of operator \"%s\" appears to be invalid\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: у оператора \"%s\" по-видимому неправильный владелец\n" -#: pg_dump.c:4600 +#: pg_dump.c:4648 #, c-format msgid "WARNING: owner of operator class \"%s\" appears to be invalid\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: у клаÑÑа операторов \"%s\" по-видимому неправильный " "владелец\n" -#: pg_dump.c:4691 +#: pg_dump.c:4739 #, c-format msgid "WARNING: owner of operator family \"%s\" appears to be invalid\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: у ÑемейÑтва операторов \"%s\" по-видимому неправильный " "владелец\n" -#: pg_dump.c:4892 +#: pg_dump.c:4940 #, c-format msgid "WARNING: owner of aggregate function \"%s\" appears to be invalid\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: у агрегатной функции \"%s\" по-видимому неправильный " "владелец\n" -#: pg_dump.c:5189 +#: pg_dump.c:5237 #, c-format msgid "WARNING: owner of function \"%s\" appears to be invalid\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: у функции \"%s\" по-видимому неправильный владелец\n" -#: pg_dump.c:6051 +#: pg_dump.c:6099 #, c-format msgid "WARNING: owner of table \"%s\" appears to be invalid\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: у таблицы \"%s\" по-видимому неправильный владелец\n" -#: pg_dump.c:6093 pg_dump.c:16593 +#: pg_dump.c:6141 pg_dump.c:16665 #, c-format msgid "failed sanity check, parent table OID %u of sequence OID %u not found\n" msgstr "" "нарушение целоÑтноÑти: по OID %u не удалоÑÑŒ найти родительÑкую таблицу " "поÑледовательноÑти Ñ OID %u\n" -#: pg_dump.c:6220 +#: pg_dump.c:6268 #, c-format msgid "reading indexes for table \"%s.%s\"\n" msgstr "чтение индекÑов таблицы \"%s.%s\"\n" -#: pg_dump.c:6588 +#: pg_dump.c:6636 #, c-format msgid "reading foreign key constraints for table \"%s.%s\"\n" msgstr "чтение ограничений внешних ключей таблицы \"%s.%s\"\n" -#: pg_dump.c:6834 +#: pg_dump.c:6882 #, c-format msgid "" "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not " @@ -2071,12 +2067,12 @@ msgstr "" "нарушение целоÑтноÑти: по OID %u не удалоÑÑŒ найти родительÑкую таблицу Ð´Ð»Ñ " "запиÑи pg_rewrite Ñ OID %u\n" -#: pg_dump.c:6928 +#: pg_dump.c:6976 #, c-format msgid "reading triggers for table \"%s.%s\"\n" msgstr "чтение триггеров таблицы \"%s.%s\"\n" -#: pg_dump.c:7093 +#: pg_dump.c:7141 #, c-format msgid "" "query produced null referenced table name for foreign key trigger \"%s\" on " @@ -2085,32 +2081,32 @@ msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ðµ вернул Ð¸Ð¼Ñ Ñ†ÐµÐ»ÐµÐ²Ð¾Ð¹ таблицы Ð´Ð»Ñ Ñ‚Ñ€Ð¸Ð³Ð³ÐµÑ€Ð° внешнего ключа \"%s\" в " "таблице \"%s\" (OID целевой таблицы: %u)\n" -#: pg_dump.c:7748 +#: pg_dump.c:7796 #, c-format msgid "finding the columns and types of table \"%s.%s\"\n" msgstr "поиÑк Ñтолбцов и типов таблицы \"%s.%s\"\n" -#: pg_dump.c:7927 +#: pg_dump.c:7975 #, c-format msgid "invalid column numbering in table \"%s\"\n" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ð½ÑƒÐ¼ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтолбцов в таблице \"%s\"\n" -#: pg_dump.c:7961 +#: pg_dump.c:8009 #, c-format msgid "finding default expressions of table \"%s.%s\"\n" msgstr "поиÑк выражений по умолчанию Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s.%s\"\n" -#: pg_dump.c:8014 +#: pg_dump.c:8062 #, c-format msgid "invalid adnum value %d for table \"%s\"\n" msgstr "неверное значение adnum (%d) в таблице \"%s\"\n" -#: pg_dump.c:8086 +#: pg_dump.c:8134 #, c-format msgid "finding check constraints for table \"%s.%s\"\n" msgstr "поиÑк ограничений-проверок Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s.%s\"\n" -#: pg_dump.c:8182 +#: pg_dump.c:8230 #, c-format msgid "expected %d check constraint on table \"%s\" but found %d\n" msgid_plural "expected %d check constraints on table \"%s\" but found %d\n" @@ -2121,72 +2117,72 @@ msgstr[1] "" msgstr[2] "" "ожидалоÑÑŒ %d ограничений-проверок Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\", но найдено: %d\n" -#: pg_dump.c:8186 +#: pg_dump.c:8234 #, c-format msgid "(The system catalogs might be corrupted.)\n" msgstr "(Возможно повреждены ÑиÑтемные каталоги.)\n" -#: pg_dump.c:9764 +#: pg_dump.c:9813 #, c-format msgid "WARNING: typtype of data type \"%s\" appears to be invalid\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: у типа данных \"%s\" по-видимому неправильный тип типа\n" -#: pg_dump.c:11306 +#: pg_dump.c:11355 #, c-format msgid "WARNING: bogus value in proargmodes array\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: неприемлемое значение в маÑÑиве proargmodes\n" -#: pg_dump.c:11684 +#: pg_dump.c:11733 #, c-format msgid "WARNING: could not parse proallargtypes array\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: не удалоÑÑŒ разобрать маÑÑив proallargtypes\n" -#: pg_dump.c:11700 +#: pg_dump.c:11749 #, c-format msgid "WARNING: could not parse proargmodes array\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: не удалоÑÑŒ разобрать маÑÑив proargmodes\n" -#: pg_dump.c:11714 +#: pg_dump.c:11763 #, c-format msgid "WARNING: could not parse proargnames array\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: не удалоÑÑŒ разобрать маÑÑив proargnames\n" -#: pg_dump.c:11725 +#: pg_dump.c:11774 #, c-format msgid "WARNING: could not parse proconfig array\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: не удалоÑÑŒ разобрать маÑÑив proconfig\n" # TO REVEIW -#: pg_dump.c:11796 +#: pg_dump.c:11845 #, c-format msgid "unrecognized provolatile value for function \"%s\"\n" msgstr "недопуÑтимое значение provolatile Ð´Ð»Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ð¸ \"%s\"\n" # TO REVEIW -#: pg_dump.c:11840 pg_dump.c:13889 +#: pg_dump.c:11889 pg_dump.c:13950 #, c-format msgid "unrecognized proparallel value for function \"%s\"\n" msgstr "недопуÑтимое значение proparallel Ð´Ð»Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ð¸ \"%s\"\n" -#: pg_dump.c:11948 pg_dump.c:12058 pg_dump.c:12065 +#: pg_dump.c:11997 pg_dump.c:12107 pg_dump.c:12114 #, c-format msgid "could not find function definition for function with OID %u\n" msgstr "не удалоÑÑŒ найти определение функции Ð´Ð»Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ð¸ Ñ OID %u\n" -#: pg_dump.c:11993 +#: pg_dump.c:12042 #, c-format msgid "WARNING: bogus value in pg_cast.castfunc or pg_cast.castmethod field\n" msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: неприемлемое значение в поле pg_cast.castfunc или pg_cast." "castmethod\n" -#: pg_dump.c:11996 +#: pg_dump.c:12045 #, c-format msgid "WARNING: bogus value in pg_cast.castmethod field\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: неприемлемое значение в поле pg_cast.castmethod\n" -#: pg_dump.c:12086 +#: pg_dump.c:12135 #, c-format msgid "" "WARNING: bogus transform definition, at least one of trffromsql and trftosql " @@ -2195,27 +2191,27 @@ msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: неприемлемое определение Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ (trffromsql или " "trftosql должно быть ненулевым)\n" -#: pg_dump.c:12103 +#: pg_dump.c:12152 #, c-format msgid "WARNING: bogus value in pg_transform.trffromsql field\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: неприемлемое значение в поле pg_transform.trffromsql\n" -#: pg_dump.c:12124 +#: pg_dump.c:12173 #, c-format msgid "WARNING: bogus value in pg_transform.trftosql field\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: неприемлемое значение в поле pg_transform.trftosql\n" -#: pg_dump.c:12515 +#: pg_dump.c:12564 #, c-format msgid "WARNING: could not find operator with OID %s\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: оператор Ñ OID %s не найден\n" -#: pg_dump.c:12579 +#: pg_dump.c:12628 #, c-format msgid "WARNING: invalid type \"%c\" of access method \"%s\"\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: неверный тип \"%c\" метода доÑтупа \"%s\"\n" -#: pg_dump.c:13780 +#: pg_dump.c:13841 #, c-format msgid "" "WARNING: aggregate function %s could not be dumped correctly for this " @@ -2224,17 +2220,17 @@ msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: Ð°Ð³Ñ€ÐµÐ³Ð°Ñ‚Ð½Ð°Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ %s не может быть правильно выгружена Ð´Ð»Ñ " "Ñтой верÑии базы данных; Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð¿Ñ€Ð¾Ð¸Ð³Ð½Ð¾Ñ€Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð°\n" -#: pg_dump.c:14652 +#: pg_dump.c:14713 #, c-format msgid "unrecognized object type in default privileges: %d\n" msgstr "нераÑпознанный тип объекта в определении прав по умолчанию: %d)\n" -#: pg_dump.c:14670 +#: pg_dump.c:14731 #, c-format msgid "could not parse default ACL list (%s)\n" msgstr "не удалоÑÑŒ разобрать ÑпиÑок прав по умолчанию (%s)\n" -#: pg_dump.c:14741 +#: pg_dump.c:14812 #, c-format msgid "" "could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) " @@ -2243,7 +2239,7 @@ msgstr "" "не удалоÑÑŒ разобрать изначальный ÑпиÑок GRANT ACL (%s) или изначальный " "ÑпиÑок REVOKE ACL (%s) Ð´Ð»Ñ Ð¾Ð±ÑŠÐµÐºÑ‚Ð° \"%s\" (%s)\n" -#: pg_dump.c:14749 +#: pg_dump.c:14820 #, c-format msgid "" "could not parse GRANT ACL list (%s) or REVOKE ACL list (%s) for object \"%s" @@ -2252,13 +2248,13 @@ msgstr "" "не удалоÑÑŒ разобрать ÑпиÑок GRANT ACL (%s) или ÑпиÑок REVOKE ACL (%s) Ð´Ð»Ñ " "объекта \"%s\" (%s)\n" -#: pg_dump.c:15233 +#: pg_dump.c:15305 #, c-format msgid "query to obtain definition of view \"%s\" returned no data\n" msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° получение Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ Ð¿Ñ€ÐµÐ´ÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" не возвратил данные\n" -#: pg_dump.c:15236 +#: pg_dump.c:15308 #, c-format msgid "" "query to obtain definition of view \"%s\" returned more than one definition\n" @@ -2266,27 +2262,27 @@ msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° Ð¿Ð¾Ð»ÑƒÑ‡ÐµÐ½Ð¸Ñ Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ Ð¿Ñ€ÐµÐ´ÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" возвратил неÑколько " "определений\n" -#: pg_dump.c:15243 +#: pg_dump.c:15315 #, c-format msgid "definition of view \"%s\" appears to be empty (length zero)\n" msgstr "определение предÑÑ‚Ð°Ð²Ð»ÐµÐ½Ð¸Ñ \"%s\" пуÑтое (длина равна нулю)\n" -#: pg_dump.c:16002 +#: pg_dump.c:16074 #, c-format msgid "invalid column number %d for table \"%s\"\n" msgstr "неверный номер Ñтолбца %d Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\"\n" -#: pg_dump.c:16131 +#: pg_dump.c:16203 #, c-format msgid "missing index for constraint \"%s\"\n" msgstr "отÑутÑтвует Ð¸Ð½Ð´ÐµÐºÑ Ð´Ð»Ñ Ð¾Ð³Ñ€Ð°Ð½Ð¸Ñ‡ÐµÐ½Ð¸Ñ \"%s\"\n" -#: pg_dump.c:16334 +#: pg_dump.c:16406 #, c-format msgid "unrecognized constraint type: %c\n" msgstr "нераÑпознанный тип ограничениÑ: %c\n" -#: pg_dump.c:16488 pg_dump.c:16661 +#: pg_dump.c:16560 pg_dump.c:16733 #, c-format msgid "query to get data of sequence \"%s\" returned %d row (expected 1)\n" msgid_plural "" @@ -2301,23 +2297,23 @@ msgstr[2] "" "Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° получение данных поÑледовательноÑти \"%s\" вернул %d Ñтрок " "(ожидалаÑÑŒ 1)\n" -#: pg_dump.c:16499 +#: pg_dump.c:16571 #, c-format msgid "query to get data of sequence \"%s\" returned name \"%s\"\n" msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° получение данных поÑледовательноÑти \"%s\" вернул Ð¸Ð¼Ñ \"%s\"\n" -#: pg_dump.c:16759 +#: pg_dump.c:16831 #, c-format msgid "unexpected tgtype value: %d\n" msgstr "неожиданное значение tgtype: %d\n" -#: pg_dump.c:16841 +#: pg_dump.c:16913 #, c-format msgid "invalid argument string (%s) for trigger \"%s\" on table \"%s\"\n" msgstr "Ð½ÐµÐ²ÐµÑ€Ð½Ð°Ñ Ñтрока аргументов (%s) Ð´Ð»Ñ Ñ‚Ñ€Ð¸Ð³Ð³ÐµÑ€Ð° \"%s\" таблицы \"%s\"\n" -#: pg_dump.c:17038 +#: pg_dump.c:17120 #, c-format msgid "" "query to get rule \"%s\" for table \"%s\" failed: wrong number of rows " @@ -2326,12 +2322,12 @@ msgstr "" "Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð½Ð° получение правила \"%s\" Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹ \"%s\" возвратил неверное " "чиÑло Ñтрок\n" -#: pg_dump.c:17427 +#: pg_dump.c:17509 #, c-format msgid "reading dependency data\n" msgstr "чтение данных о завиÑимоÑÑ‚ÑÑ…\n" -#: pg_dump.c:17984 +#: pg_dump.c:18066 #, c-format msgid "WARNING: could not parse reloptions array\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: не удалоÑÑŒ разобрать маÑÑив reloptions\n" @@ -2881,6 +2877,12 @@ msgstr "" "ввода.\n" "\n" +#~ msgid "setting owner and privileges for %s \"%s.%s\"\n" +#~ msgstr "уÑтановка владельца и прав: %s \"%s.%s\"\n" + +#~ msgid "setting owner and privileges for %s \"%s\"\n" +#~ msgstr "уÑтановка владельца и прав: %s \"%s\"\n" + #~ msgid "could not get relation name for OID %u: %s\n" #~ msgstr "не удалоÑÑŒ получить Ð¸Ð¼Ñ Ð¾Ñ‚Ð½Ð¾ÑˆÐµÐ½Ð¸Ñ Ñ OID %u: %s\n" @@ -2902,9 +2904,6 @@ msgstr "" #~ msgid "archive member too large for tar format\n" #~ msgstr "компонент архива Ñлишком велик Ð´Ð»Ñ Ñ„Ð¾Ñ€Ð¼Ð°Ñ‚Ð° tar\n" -#~ msgid "could not write to output file: %s\n" -#~ msgstr "не удалоÑÑŒ запиÑать в выходной файл: %s\n" - #~ msgid "could not write to custom output routine\n" #~ msgstr "не удалоÑÑŒ вывеÑти данную в пользовательÑкую процедуру\n" diff --git a/src/bin/pg_resetxlog/po/es.po b/src/bin/pg_resetxlog/po/es.po index d6969c0c43..d305a2b601 100644 --- a/src/bin/pg_resetxlog/po/es.po +++ b/src/bin/pg_resetxlog/po/es.po @@ -12,8 +12,8 @@ msgid "" msgstr "" "Project-Id-Version: pg_resetxlog (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" -"PO-Revision-Date: 2016-05-24 10:56-0500\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" +"PO-Revision-Date: 2017-08-28 11:04+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: Español \n" "Language: es\n" @@ -58,86 +58,86 @@ msgid "%s: could not get exit code from subprocess: error code %lu\n" msgstr "%s: no se pudo obtener el código de salida del subproceso»: código de error %lu\n" #. translator: the second %s is a command line argument (-e, etc) -#: pg_resetxlog.c:140 pg_resetxlog.c:155 pg_resetxlog.c:170 pg_resetxlog.c:177 -#: pg_resetxlog.c:201 pg_resetxlog.c:216 pg_resetxlog.c:224 pg_resetxlog.c:250 -#: pg_resetxlog.c:264 +#: pg_resetxlog.c:141 pg_resetxlog.c:156 pg_resetxlog.c:171 pg_resetxlog.c:178 +#: pg_resetxlog.c:202 pg_resetxlog.c:217 pg_resetxlog.c:225 pg_resetxlog.c:251 +#: pg_resetxlog.c:265 #, c-format msgid "%s: invalid argument for option %s\n" msgstr "%s: argumento no válido para la opción %s\n" -#: pg_resetxlog.c:141 pg_resetxlog.c:156 pg_resetxlog.c:171 pg_resetxlog.c:178 -#: pg_resetxlog.c:202 pg_resetxlog.c:217 pg_resetxlog.c:225 pg_resetxlog.c:251 -#: pg_resetxlog.c:265 pg_resetxlog.c:272 pg_resetxlog.c:285 pg_resetxlog.c:293 +#: pg_resetxlog.c:142 pg_resetxlog.c:157 pg_resetxlog.c:172 pg_resetxlog.c:179 +#: pg_resetxlog.c:203 pg_resetxlog.c:218 pg_resetxlog.c:226 pg_resetxlog.c:252 +#: pg_resetxlog.c:266 pg_resetxlog.c:273 pg_resetxlog.c:286 pg_resetxlog.c:294 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Prueba con «%s --help» para más información\n" -#: pg_resetxlog.c:146 +#: pg_resetxlog.c:147 #, c-format msgid "%s: transaction ID epoch (-e) must not be -1\n" msgstr "%s: el «epoch» de ID de transacción (-e) no debe ser -1\n" -#: pg_resetxlog.c:161 +#: pg_resetxlog.c:162 #, c-format msgid "%s: transaction ID (-x) must not be 0\n" msgstr "%s: el ID de transacción (-x) no debe ser 0\n" -#: pg_resetxlog.c:185 pg_resetxlog.c:192 +#: pg_resetxlog.c:186 pg_resetxlog.c:193 #, c-format msgid "%s: transaction ID (-c) must be either 0 or greater than or equal to 2\n" msgstr "%s: el ID de transacción (-c) debe ser 0 o bien mayor o igual a 2\n" -#: pg_resetxlog.c:207 +#: pg_resetxlog.c:208 #, c-format msgid "%s: OID (-o) must not be 0\n" msgstr "%s: OID (-o) no debe ser cero\n" -#: pg_resetxlog.c:230 +#: pg_resetxlog.c:231 #, c-format msgid "%s: multitransaction ID (-m) must not be 0\n" msgstr "%s: el ID de multitransacción (-m) no debe ser 0\n" -#: pg_resetxlog.c:240 +#: pg_resetxlog.c:241 #, c-format msgid "%s: oldest multitransaction ID (-m) must not be 0\n" msgstr "%s: el ID de multitransacción más antiguo (-m) no debe ser 0\n" -#: pg_resetxlog.c:256 +#: pg_resetxlog.c:257 #, c-format msgid "%s: multitransaction offset (-O) must not be -1\n" msgstr "%s: la posición de multitransacción (-O) no debe ser -1\n" -#: pg_resetxlog.c:283 +#: pg_resetxlog.c:284 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: demasiados argumentos de línea de órdenes (el primero es «%s»)\n" -#: pg_resetxlog.c:292 +#: pg_resetxlog.c:293 #, c-format msgid "%s: no data directory specified\n" msgstr "%s: directorio de datos no especificado\n" -#: pg_resetxlog.c:306 +#: pg_resetxlog.c:307 #, c-format msgid "%s: cannot be executed by \"root\"\n" msgstr "%s: no puede ser ejecutado con el usuario «root»\n" -#: pg_resetxlog.c:308 +#: pg_resetxlog.c:309 #, c-format msgid "You must run %s as the PostgreSQL superuser.\n" msgstr "Debe ejecutar %s con el superusuario de PostgreSQL.\n" -#: pg_resetxlog.c:318 +#: pg_resetxlog.c:319 #, c-format msgid "%s: could not change directory to \"%s\": %s\n" msgstr "%s: no se pudo cambiar al directorio «%s»: %s\n" -#: pg_resetxlog.c:331 pg_resetxlog.c:477 +#: pg_resetxlog.c:335 pg_resetxlog.c:482 pg_resetxlog.c:545 #, c-format msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: no se pudo abrir el archivo «%s» para lectura: %s\n" -#: pg_resetxlog.c:338 +#: pg_resetxlog.c:342 #, c-format msgid "" "%s: lock file \"%s\" exists\n" @@ -146,7 +146,7 @@ msgstr "" "%s: el archivo candado «%s» existe\n" "¿Hay un servidor corriendo? Si no, borre el archivo candado e inténtelo de nuevo\n" -#: pg_resetxlog.c:425 +#: pg_resetxlog.c:429 #, c-format msgid "" "\n" @@ -155,7 +155,7 @@ msgstr "" "\n" "Si estos valores parecen aceptables, use -f para forzar reinicio.\n" -#: pg_resetxlog.c:437 +#: pg_resetxlog.c:441 #, c-format msgid "" "The database server was not shut down cleanly.\n" @@ -166,12 +166,31 @@ msgstr "" "Reiniciar la bitácora de transacciones puede causar pérdida de datos.\n" "Si de todas formas quiere proceder, use -f para forzar su reinicio.\n" -#: pg_resetxlog.c:451 +#: pg_resetxlog.c:455 #, c-format msgid "Transaction log reset\n" msgstr "Bitácora de transacciones reiniciada\n" -#: pg_resetxlog.c:480 +#: pg_resetxlog.c:492 +#, c-format +msgid "%s: unexpected empty file \"%s\"\n" +msgstr "%s: archivo vacío «%s» inesperado\n" + +#: pg_resetxlog.c:497 pg_resetxlog.c:561 +#, c-format +msgid "%s: could not read file \"%s\": %s\n" +msgstr "%s: no se pudo leer el archivo «%s»: %s\n" + +#: pg_resetxlog.c:514 +#, c-format +msgid "" +"%s: data directory is of wrong version\n" +"File \"%s\" contains \"%s\", which is not compatible with this program's version \"%s\".\n" +msgstr "" +"%s: el directorio de datos es de la versión incorrecta\n" +"El archivo «%s» contiene «%s», que no es compatible con esta versión «%s».\n" + +#: pg_resetxlog.c:548 #, c-format msgid "" "If you are sure the data directory path is correct, execute\n" @@ -182,22 +201,17 @@ msgstr "" " touch %s\n" "y pruebe de nuevo.\n" -#: pg_resetxlog.c:493 -#, c-format -msgid "%s: could not read file \"%s\": %s\n" -msgstr "%s: no se pudo leer el archivo «%s»: %s\n" - -#: pg_resetxlog.c:516 +#: pg_resetxlog.c:584 #, c-format msgid "%s: pg_control exists but has invalid CRC; proceed with caution\n" msgstr "%s: existe pg_control pero tiene un CRC no válido, proceda con precaución\n" -#: pg_resetxlog.c:525 +#: pg_resetxlog.c:593 #, c-format -msgid "%s: pg_control exists but is broken or unknown version; ignoring it\n" -msgstr "%s: existe pg_control pero está roto o se desconoce su versión; ignorándolo\n" +msgid "%s: pg_control exists but is broken or wrong version; ignoring it\n" +msgstr "%s: pg_control existe pero está roto o su versión es incorrecta; ignorándolo\n" -#: pg_resetxlog.c:628 +#: pg_resetxlog.c:696 #, c-format msgid "" "Guessed pg_control values:\n" @@ -206,7 +220,7 @@ msgstr "" "Valores de pg_control asumidos:\n" "\n" -#: pg_resetxlog.c:630 +#: pg_resetxlog.c:698 #, c-format msgid "" "Current pg_control values:\n" @@ -215,176 +229,176 @@ msgstr "" "Valores actuales de pg_control:\n" "\n" -#: pg_resetxlog.c:639 +#: pg_resetxlog.c:707 #, c-format msgid "pg_control version number: %u\n" msgstr "Número de versión de pg_control: %u\n" -#: pg_resetxlog.c:641 +#: pg_resetxlog.c:709 #, c-format msgid "Catalog version number: %u\n" msgstr "Número de versión de catálogo: %u\n" -#: pg_resetxlog.c:643 +#: pg_resetxlog.c:711 #, c-format msgid "Database system identifier: %s\n" msgstr "Identificador de sistema: %s\n" -#: pg_resetxlog.c:645 +#: pg_resetxlog.c:713 #, c-format msgid "Latest checkpoint's TimeLineID: %u\n" msgstr "TimeLineID del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:647 +#: pg_resetxlog.c:715 #, c-format msgid "Latest checkpoint's full_page_writes: %s\n" msgstr "full_page_writes del checkpoint más reciente: %s\n" -#: pg_resetxlog.c:648 +#: pg_resetxlog.c:716 msgid "off" msgstr "desactivado" -#: pg_resetxlog.c:648 +#: pg_resetxlog.c:716 msgid "on" msgstr "activado" -#: pg_resetxlog.c:649 +#: pg_resetxlog.c:717 #, c-format msgid "Latest checkpoint's NextXID: %u:%u\n" msgstr "NextXID del checkpoint más reciente: %u:%u\n" -#: pg_resetxlog.c:652 +#: pg_resetxlog.c:720 #, c-format msgid "Latest checkpoint's NextOID: %u\n" msgstr "NextOID del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:654 +#: pg_resetxlog.c:722 #, c-format msgid "Latest checkpoint's NextMultiXactId: %u\n" msgstr "NextMultiXactId del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:656 +#: pg_resetxlog.c:724 #, c-format msgid "Latest checkpoint's NextMultiOffset: %u\n" msgstr "NextMultiOffset del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:658 +#: pg_resetxlog.c:726 #, c-format msgid "Latest checkpoint's oldestXID: %u\n" msgstr "oldestXID del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:660 +#: pg_resetxlog.c:728 #, c-format msgid "Latest checkpoint's oldestXID's DB: %u\n" msgstr "BD del oldestXID del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:662 +#: pg_resetxlog.c:730 #, c-format msgid "Latest checkpoint's oldestActiveXID: %u\n" msgstr "oldestActiveXID del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:664 +#: pg_resetxlog.c:732 #, c-format msgid "Latest checkpoint's oldestMultiXid: %u\n" msgstr "oldestMultiXid del checkpoint más reciente: %u\n" -#: pg_resetxlog.c:666 +#: pg_resetxlog.c:734 #, c-format msgid "Latest checkpoint's oldestMulti's DB: %u\n" msgstr "BD del oldestMultiXid del checkpt. más reciente: %u\n" -#: pg_resetxlog.c:668 +#: pg_resetxlog.c:736 #, c-format msgid "Latest checkpoint's oldestCommitTsXid:%u\n" msgstr "oldestCommitTsXid del último checkpoint: %u\n" -#: pg_resetxlog.c:670 +#: pg_resetxlog.c:738 #, c-format msgid "Latest checkpoint's newestCommitTsXid:%u\n" msgstr "newestCommitTsXid del último checkpoint: %u\n" -#: pg_resetxlog.c:672 +#: pg_resetxlog.c:740 #, c-format msgid "Maximum data alignment: %u\n" msgstr "Máximo alineamiento de datos: %u\n" -#: pg_resetxlog.c:675 +#: pg_resetxlog.c:743 #, c-format msgid "Database block size: %u\n" msgstr "Tamaño del bloque de la base de datos: %u\n" -#: pg_resetxlog.c:677 +#: pg_resetxlog.c:745 #, c-format msgid "Blocks per segment of large relation: %u\n" msgstr "Bloques por segmento de relación grande: %u\n" -#: pg_resetxlog.c:679 +#: pg_resetxlog.c:747 #, c-format msgid "WAL block size: %u\n" msgstr "Tamaño del bloque de WAL: %u\n" -#: pg_resetxlog.c:681 +#: pg_resetxlog.c:749 #, c-format msgid "Bytes per WAL segment: %u\n" msgstr "Bytes por segmento WAL: %u\n" -#: pg_resetxlog.c:683 +#: pg_resetxlog.c:751 #, c-format msgid "Maximum length of identifiers: %u\n" msgstr "Longitud máxima de identificadores: %u\n" -#: pg_resetxlog.c:685 +#: pg_resetxlog.c:753 #, c-format msgid "Maximum columns in an index: %u\n" msgstr "Máximo número de columnas en un índice: %u\n" -#: pg_resetxlog.c:687 +#: pg_resetxlog.c:755 #, c-format msgid "Maximum size of a TOAST chunk: %u\n" msgstr "Longitud máxima de un trozo TOAST: %u\n" -#: pg_resetxlog.c:689 +#: pg_resetxlog.c:757 #, c-format msgid "Size of a large-object chunk: %u\n" msgstr "Longitud máxima de un trozo de objeto grande: %u\n" -#: pg_resetxlog.c:691 +#: pg_resetxlog.c:759 #, c-format msgid "Date/time type storage: %s\n" msgstr "Tipo de almacenamiento hora/fecha: %s\n" -#: pg_resetxlog.c:692 +#: pg_resetxlog.c:760 msgid "64-bit integers" msgstr "enteros de 64 bits" -#: pg_resetxlog.c:692 +#: pg_resetxlog.c:760 msgid "floating-point numbers" msgstr "números de coma flotante" -#: pg_resetxlog.c:693 +#: pg_resetxlog.c:761 #, c-format msgid "Float4 argument passing: %s\n" msgstr "Paso de parámetros float4: %s\n" -#: pg_resetxlog.c:694 pg_resetxlog.c:696 +#: pg_resetxlog.c:762 pg_resetxlog.c:764 msgid "by reference" msgstr "por referencia" -#: pg_resetxlog.c:694 pg_resetxlog.c:696 +#: pg_resetxlog.c:762 pg_resetxlog.c:764 msgid "by value" msgstr "por valor" -#: pg_resetxlog.c:695 +#: pg_resetxlog.c:763 #, c-format msgid "Float8 argument passing: %s\n" msgstr "Paso de parámetros float8: %s\n" -#: pg_resetxlog.c:697 +#: pg_resetxlog.c:765 #, c-format msgid "Data page checksum version: %u\n" msgstr "Versión de suma de verificación de datos: %u\n" -#: pg_resetxlog.c:711 +#: pg_resetxlog.c:779 #, c-format msgid "" "\n" @@ -397,117 +411,117 @@ msgstr "" "Valores a cambiar:\n" "\n" -#: pg_resetxlog.c:714 +#: pg_resetxlog.c:782 #, c-format msgid "First log segment after reset: %s\n" msgstr "Primer segmento de log después de reiniciar: %s\n" -#: pg_resetxlog.c:718 +#: pg_resetxlog.c:786 #, c-format msgid "NextMultiXactId: %u\n" msgstr "NextMultiXactId: %u\n" -#: pg_resetxlog.c:720 +#: pg_resetxlog.c:788 #, c-format msgid "OldestMultiXid: %u\n" msgstr "OldestMultiXid: %u\n" -#: pg_resetxlog.c:722 +#: pg_resetxlog.c:790 #, c-format msgid "OldestMulti's DB: %u\n" msgstr "Base de datos del OldestMulti: %u\n" -#: pg_resetxlog.c:728 +#: pg_resetxlog.c:796 #, c-format msgid "NextMultiOffset: %u\n" msgstr "NextMultiOffset: %u\n" -#: pg_resetxlog.c:734 +#: pg_resetxlog.c:802 #, c-format msgid "NextOID: %u\n" msgstr "NextOID: %u\n" -#: pg_resetxlog.c:740 +#: pg_resetxlog.c:808 #, c-format msgid "NextXID: %u\n" msgstr "NextXID: %u\n" -#: pg_resetxlog.c:742 +#: pg_resetxlog.c:810 #, c-format msgid "OldestXID: %u\n" msgstr "OldestXID: %u\n" -#: pg_resetxlog.c:744 +#: pg_resetxlog.c:812 #, c-format msgid "OldestXID's DB: %u\n" msgstr "Base de datos del OldestXID: %u\n" -#: pg_resetxlog.c:750 +#: pg_resetxlog.c:818 #, c-format msgid "NextXID epoch: %u\n" msgstr "Epoch del NextXID: %u\n" -#: pg_resetxlog.c:756 +#: pg_resetxlog.c:824 #, c-format msgid "oldestCommitTsXid: %u\n" msgstr "oldestCommitTsXid: %u\n" -#: pg_resetxlog.c:761 +#: pg_resetxlog.c:829 #, c-format msgid "newestCommitTsXid: %u\n" msgstr "newestCommitTsXid: %u\n" -#: pg_resetxlog.c:827 +#: pg_resetxlog.c:895 #, c-format msgid "%s: internal error -- sizeof(ControlFileData) is too large ... fix PG_CONTROL_SIZE\n" msgstr "%s: error interno -- sizeof(ControlFileData) es demasiado grande ... corrija PG_CONTROL_SIZE\n" -#: pg_resetxlog.c:842 +#: pg_resetxlog.c:910 #, c-format msgid "%s: could not create pg_control file: %s\n" msgstr "%s: no se pudo crear el archivo pg_control: %s\n" -#: pg_resetxlog.c:853 +#: pg_resetxlog.c:921 #, c-format msgid "%s: could not write pg_control file: %s\n" msgstr "%s: no se pudo escribir el archivo pg_control: %s\n" -#: pg_resetxlog.c:860 pg_resetxlog.c:1156 +#: pg_resetxlog.c:928 pg_resetxlog.c:1224 #, c-format msgid "%s: fsync error: %s\n" msgstr "%s: error de fsync: %s\n" -#: pg_resetxlog.c:900 pg_resetxlog.c:971 pg_resetxlog.c:1022 +#: pg_resetxlog.c:968 pg_resetxlog.c:1039 pg_resetxlog.c:1090 #, c-format msgid "%s: could not open directory \"%s\": %s\n" msgstr "%s: no se pudo abrir el directorio «%s»: %s\n" -#: pg_resetxlog.c:936 pg_resetxlog.c:993 pg_resetxlog.c:1047 +#: pg_resetxlog.c:1004 pg_resetxlog.c:1061 pg_resetxlog.c:1115 #, c-format msgid "%s: could not read directory \"%s\": %s\n" msgstr "%s: no se pudo leer el directorio «%s»: %s\n" -#: pg_resetxlog.c:943 pg_resetxlog.c:1000 pg_resetxlog.c:1054 +#: pg_resetxlog.c:1011 pg_resetxlog.c:1068 pg_resetxlog.c:1122 #, c-format msgid "%s: could not close directory \"%s\": %s\n" msgstr "%s: no se pudo cerrar el directorio «%s»: %s\n" -#: pg_resetxlog.c:984 pg_resetxlog.c:1038 +#: pg_resetxlog.c:1052 pg_resetxlog.c:1106 #, c-format msgid "%s: could not delete file \"%s\": %s\n" msgstr "%s: no se pudo borrar el archivo «%s»: %s\n" -#: pg_resetxlog.c:1123 +#: pg_resetxlog.c:1191 #, c-format msgid "%s: could not open file \"%s\": %s\n" msgstr "%s: no se pudo abrir el archivo «%s»: %s\n" -#: pg_resetxlog.c:1134 pg_resetxlog.c:1148 +#: pg_resetxlog.c:1202 pg_resetxlog.c:1216 #, c-format msgid "%s: could not write file \"%s\": %s\n" msgstr "%s: no se pudo escribir en el archivo «%s»: %s\n" -#: pg_resetxlog.c:1167 +#: pg_resetxlog.c:1235 #, c-format msgid "" "%s resets the PostgreSQL transaction log.\n" @@ -516,7 +530,7 @@ msgstr "" "%s reinicia la bitácora de transacciones de PostgreSQL.\n" "\n" -#: pg_resetxlog.c:1168 +#: pg_resetxlog.c:1236 #, c-format msgid "" "Usage:\n" @@ -527,81 +541,81 @@ msgstr "" " %s [OPCIÓN]... DATADIR\n" "\n" -#: pg_resetxlog.c:1169 +#: pg_resetxlog.c:1237 #, c-format msgid "Options:\n" msgstr "Opciones:\n" -#: pg_resetxlog.c:1170 +#: pg_resetxlog.c:1238 #, c-format msgid " -c XID,XID set oldest and newest transactions bearing commit timestamp\n" msgstr "" " -c XID,XID asigna los ID de transacciones más antiguo y más nuevo que llevan\n" " timestamp de commit\n" -#: pg_resetxlog.c:1171 +#: pg_resetxlog.c:1239 #, c-format msgid " (zero in either value means no change)\n" msgstr " (cero en cualquiera de ellos significa no cambiar)\n" -#: pg_resetxlog.c:1172 +#: pg_resetxlog.c:1240 #, c-format msgid " [-D] DATADIR data directory\n" msgstr " [-D] DATADIR directorio de datos\n" -#: pg_resetxlog.c:1173 +#: pg_resetxlog.c:1241 #, c-format msgid " -e XIDEPOCH set next transaction ID epoch\n" msgstr " -e XIDEPOCH asigna el siguiente «epoch» de ID de transacción\n" -#: pg_resetxlog.c:1174 +#: pg_resetxlog.c:1242 #, c-format msgid " -f force update to be done\n" msgstr " -f fuerza que la actualización sea hecha\n" -#: pg_resetxlog.c:1175 +#: pg_resetxlog.c:1243 #, c-format msgid " -l XLOGFILE force minimum WAL starting location for new transaction log\n" msgstr "" " -l XLOGFILE fuerza una posición mínima de inicio de WAL para una\n" " nueva transacción\n" -#: pg_resetxlog.c:1176 +#: pg_resetxlog.c:1244 #, c-format msgid " -m MXID,MXID set next and oldest multitransaction ID\n" msgstr " -m MXID,MXID asigna el siguiente ID de multitransacción y el más antiguo\n" -#: pg_resetxlog.c:1177 +#: pg_resetxlog.c:1245 #, c-format msgid " -n no update, just show what would be done (for testing)\n" msgstr " -n no actualiza, sólo muestra lo que va a hacer (para pruebas)\n" -#: pg_resetxlog.c:1178 +#: pg_resetxlog.c:1246 #, c-format msgid " -o OID set next OID\n" msgstr " -o OID asigna el siguiente OID\n" -#: pg_resetxlog.c:1179 +#: pg_resetxlog.c:1247 #, c-format msgid " -O OFFSET set next multitransaction offset\n" msgstr " -O OFFSET asigna la siguiente posición de multitransacción\n" -#: pg_resetxlog.c:1180 +#: pg_resetxlog.c:1248 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version muestra información de la versión, luego sale\n" -#: pg_resetxlog.c:1181 +#: pg_resetxlog.c:1249 #, c-format msgid " -x XID set next transaction ID\n" msgstr " -x XID asigna el siguiente ID de transacción\n" -#: pg_resetxlog.c:1182 +#: pg_resetxlog.c:1250 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help muestra esta ayuda, luego sale\n" -#: pg_resetxlog.c:1183 +#: pg_resetxlog.c:1251 #, c-format msgid "" "\n" diff --git a/src/bin/pg_resetxlog/po/ru.po b/src/bin/pg_resetxlog/po/ru.po index e3b5c77f5d..233c7ab95e 100644 --- a/src/bin/pg_resetxlog/po/ru.po +++ b/src/bin/pg_resetxlog/po/ru.po @@ -5,15 +5,14 @@ # Oleg Bartunov , 2004. # Sergey Burladyan , 2009. # Dmitriy Olshevskiy , 2014. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2016, 2017. # msgid "" msgstr "" "Project-Id-Version: pg_resetxlog (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-06 22:13+0000\n" -"PO-Revision-Date: 2016-12-20 18:26+0300\n" -"Last-Translator: Alexander Lakhin \n" +"POT-Creation-Date: 2017-08-17 17:52+0000\n" +"PO-Revision-Date: 2017-08-21 08:21+0300\n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -21,6 +20,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" +"Last-Translator: Alexander Lakhin \n" #: ../../common/restricted_token.c:68 #, c-format @@ -60,87 +60,87 @@ msgid "%s: could not get exit code from subprocess: error code %lu\n" msgstr "%s: не удалоÑÑŒ получить код выхода от подпроцеÑÑа (код ошибки: %lu)\n" #. translator: the second %s is a command line argument (-e, etc) -#: pg_resetxlog.c:140 pg_resetxlog.c:155 pg_resetxlog.c:170 pg_resetxlog.c:177 -#: pg_resetxlog.c:201 pg_resetxlog.c:216 pg_resetxlog.c:224 pg_resetxlog.c:250 -#: pg_resetxlog.c:264 +#: pg_resetxlog.c:141 pg_resetxlog.c:156 pg_resetxlog.c:171 pg_resetxlog.c:178 +#: pg_resetxlog.c:202 pg_resetxlog.c:217 pg_resetxlog.c:225 pg_resetxlog.c:251 +#: pg_resetxlog.c:265 #, c-format msgid "%s: invalid argument for option %s\n" msgstr "%s: недопуÑтимый аргумент параметра %s\n" -#: pg_resetxlog.c:141 pg_resetxlog.c:156 pg_resetxlog.c:171 pg_resetxlog.c:178 -#: pg_resetxlog.c:202 pg_resetxlog.c:217 pg_resetxlog.c:225 pg_resetxlog.c:251 -#: pg_resetxlog.c:265 pg_resetxlog.c:272 pg_resetxlog.c:285 pg_resetxlog.c:293 +#: pg_resetxlog.c:142 pg_resetxlog.c:157 pg_resetxlog.c:172 pg_resetxlog.c:179 +#: pg_resetxlog.c:203 pg_resetxlog.c:218 pg_resetxlog.c:226 pg_resetxlog.c:252 +#: pg_resetxlog.c:266 pg_resetxlog.c:273 pg_resetxlog.c:286 pg_resetxlog.c:294 #, c-format msgid "Try \"%s --help\" for more information.\n" msgstr "Ð”Ð»Ñ Ð´Ð¾Ð¿Ð¾Ð»Ð½Ð¸Ñ‚ÐµÐ»ÑŒÐ½Ð¾Ð¹ информации попробуйте \"%s --help\".\n" -#: pg_resetxlog.c:146 +#: pg_resetxlog.c:147 #, c-format msgid "%s: transaction ID epoch (-e) must not be -1\n" msgstr "%s: Ñпоха ID транзакции (-e) не должна быть равна -1\n" -#: pg_resetxlog.c:161 +#: pg_resetxlog.c:162 #, c-format msgid "%s: transaction ID (-x) must not be 0\n" msgstr "%s: ID транзакции (-x) не должен быть равен 0\n" -#: pg_resetxlog.c:185 pg_resetxlog.c:192 +#: pg_resetxlog.c:186 pg_resetxlog.c:193 #, c-format msgid "" "%s: transaction ID (-c) must be either 0 or greater than or equal to 2\n" msgstr "%s: ID транзакции (-c) должен быть равен 0, либо больше или равен 2\n" -#: pg_resetxlog.c:207 +#: pg_resetxlog.c:208 #, c-format msgid "%s: OID (-o) must not be 0\n" msgstr "%s: OID (-o) не должен быть равен 0\n" -#: pg_resetxlog.c:230 +#: pg_resetxlog.c:231 #, c-format msgid "%s: multitransaction ID (-m) must not be 0\n" msgstr "%s: ID мультитранзакции (-m) не должен быть равен 0\n" -#: pg_resetxlog.c:240 +#: pg_resetxlog.c:241 #, c-format msgid "%s: oldest multitransaction ID (-m) must not be 0\n" msgstr "%s: ID Ñтарейшей мультитранзакции (-m) не должен быть равен 0\n" -#: pg_resetxlog.c:256 +#: pg_resetxlog.c:257 #, c-format msgid "%s: multitransaction offset (-O) must not be -1\n" msgstr "%s: Ñмещение мультитранзакции (-O) не должно быть равно -1\n" -#: pg_resetxlog.c:283 +#: pg_resetxlog.c:284 #, c-format msgid "%s: too many command-line arguments (first is \"%s\")\n" msgstr "%s: Ñлишком много аргументов командной Ñтроки (первый: \"%s\")\n" -#: pg_resetxlog.c:292 +#: pg_resetxlog.c:293 #, c-format msgid "%s: no data directory specified\n" msgstr "%s: каталог данных не указан\n" -#: pg_resetxlog.c:306 +#: pg_resetxlog.c:307 #, c-format msgid "%s: cannot be executed by \"root\"\n" msgstr "%s: программу не должен запуÑкать root\n" -#: pg_resetxlog.c:308 +#: pg_resetxlog.c:309 #, c-format msgid "You must run %s as the PostgreSQL superuser.\n" msgstr "ЗапуÑкать %s нужно от имени ÑÑƒÐ¿ÐµÑ€Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ PostgreSQL.\n" -#: pg_resetxlog.c:318 +#: pg_resetxlog.c:319 #, c-format msgid "%s: could not change directory to \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ перейти в каталог \"%s\": %s\n" -#: pg_resetxlog.c:331 pg_resetxlog.c:477 +#: pg_resetxlog.c:335 pg_resetxlog.c:482 pg_resetxlog.c:545 #, c-format msgid "%s: could not open file \"%s\" for reading: %s\n" msgstr "%s: не удалоÑÑŒ открыть файл \"%s\" Ð´Ð»Ñ Ñ‡Ñ‚ÐµÐ½Ð¸Ñ: %s\n" -#: pg_resetxlog.c:338 +#: pg_resetxlog.c:342 #, c-format msgid "" "%s: lock file \"%s\" exists\n" @@ -149,7 +149,7 @@ msgstr "" "%s: обнаружен файл блокировки \"%s\"\n" "Возможно, Ñервер запущен? ЕÑли нет, удалите Ñтот файл и попробуйте Ñнова.\n" -#: pg_resetxlog.c:425 +#: pg_resetxlog.c:429 #, c-format msgid "" "\n" @@ -159,7 +159,7 @@ msgstr "" "ЕÑли Ñти Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ Ð¿Ñ€Ð¸ÐµÐ¼Ð»ÐµÐ¼Ñ‹, выполните ÑÐ±Ñ€Ð¾Ñ Ð¿Ñ€Ð¸Ð½ÑƒÐ´Ð¸Ñ‚ÐµÐ»ÑŒÐ½Ð¾, добавив ключ -" "f.\n" -#: pg_resetxlog.c:437 +#: pg_resetxlog.c:441 #, c-format msgid "" "The database server was not shut down cleanly.\n" @@ -170,12 +170,32 @@ msgstr "" "Ð¡Ð±Ñ€Ð¾Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° транзакций может привеÑти к потере данных.\n" "ЕÑли вы хотите ÑброÑить его, неÑÐ¼Ð¾Ñ‚Ñ€Ñ Ð½Ð° Ñто, добавьте ключ -f.\n" -#: pg_resetxlog.c:451 +#: pg_resetxlog.c:455 #, c-format msgid "Transaction log reset\n" msgstr "Журнал транзакций Ñброшен\n" -#: pg_resetxlog.c:480 +#: pg_resetxlog.c:492 +#, c-format +msgid "%s: unexpected empty file \"%s\"\n" +msgstr "%s: файл \"%s\" оказалÑÑ Ð¿ÑƒÑтым\n" + +#: pg_resetxlog.c:497 pg_resetxlog.c:561 +#, c-format +msgid "%s: could not read file \"%s\": %s\n" +msgstr "%s: не удалоÑÑŒ прочитать файл \"%s\": %s\n" + +#: pg_resetxlog.c:514 +#, c-format +msgid "" +"%s: data directory is of wrong version\n" +"File \"%s\" contains \"%s\", which is not compatible with this program's " +"version \"%s\".\n" +msgstr "" +"%s: каталог данных неверной верÑии\n" +"Файл \"%s\" Ñодержит Ñтроку \"%s\", а ожидаетÑÑ Ð²ÐµÑ€ÑÐ¸Ñ Ð¿Ñ€Ð¾Ð³Ñ€Ð°Ð¼Ð¼Ñ‹ \"%s\".\n" + +#: pg_resetxlog.c:548 #, c-format msgid "" "If you are sure the data directory path is correct, execute\n" @@ -186,25 +206,21 @@ msgstr "" " touch %s\n" "и повторите попытку.\n" -#: pg_resetxlog.c:493 -#, c-format -msgid "%s: could not read file \"%s\": %s\n" -msgstr "%s: не удалоÑÑŒ прочитать файл \"%s\": %s\n" - -#: pg_resetxlog.c:516 +#: pg_resetxlog.c:584 #, c-format msgid "%s: pg_control exists but has invalid CRC; proceed with caution\n" msgstr "" "%s: pg_control ÑущеÑтвует, но его ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ð°Ñ Ñумма неверна; продолжайте Ñ " "оÑторожноÑтью\n" -#: pg_resetxlog.c:525 +#: pg_resetxlog.c:593 #, c-format -msgid "%s: pg_control exists but is broken or unknown version; ignoring it\n" +msgid "%s: pg_control exists but is broken or wrong version; ignoring it\n" msgstr "" -"%s: pg_control иÑпорчен или имеет неизвеÑтную верÑию; игнорируетÑÑ...\n" +"%s: pg_control иÑпорчен или имеет неизвеÑтную либо недопуÑтимую верÑию; " +"игнорируетÑÑ...\n" -#: pg_resetxlog.c:628 +#: pg_resetxlog.c:696 #, c-format msgid "" "Guessed pg_control values:\n" @@ -213,7 +229,7 @@ msgstr "" "Предполагаемые Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ pg_control:\n" "\n" -#: pg_resetxlog.c:630 +#: pg_resetxlog.c:698 #, c-format msgid "" "Current pg_control values:\n" @@ -222,190 +238,190 @@ msgstr "" "Текущие Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ pg_control:\n" "\n" -#: pg_resetxlog.c:639 +#: pg_resetxlog.c:707 #, c-format msgid "pg_control version number: %u\n" msgstr "Ðомер верÑии pg_control: %u\n" -#: pg_resetxlog.c:641 +#: pg_resetxlog.c:709 #, c-format msgid "Catalog version number: %u\n" msgstr "Ðомер верÑии каталога: %u\n" -#: pg_resetxlog.c:643 +#: pg_resetxlog.c:711 #, c-format msgid "Database system identifier: %s\n" msgstr "Идентификатор ÑиÑтемы баз данных: %s\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:645 +#: pg_resetxlog.c:713 #, c-format msgid "Latest checkpoint's TimeLineID: %u\n" msgstr "Ð›Ð¸Ð½Ð¸Ñ Ð²Ñ€ÐµÐ¼ÐµÐ½Ð¸ поÑледней конт. точки: %u\n" # skip-rule: no-space-after-period -#: pg_resetxlog.c:647 +#: pg_resetxlog.c:715 #, c-format msgid "Latest checkpoint's full_page_writes: %s\n" msgstr "Режим full_page_writes поÑледней к.Ñ‚: %s\n" -#: pg_resetxlog.c:648 +#: pg_resetxlog.c:716 msgid "off" msgstr "выкл." -#: pg_resetxlog.c:648 +#: pg_resetxlog.c:716 msgid "on" msgstr "вкл." # skip-rule: capital-letter-first -#: pg_resetxlog.c:649 +#: pg_resetxlog.c:717 #, c-format msgid "Latest checkpoint's NextXID: %u:%u\n" msgstr "NextXID поÑледней конт. точки: %u:%u\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:652 +#: pg_resetxlog.c:720 #, c-format msgid "Latest checkpoint's NextOID: %u\n" msgstr "NextOID поÑледней конт. точки: %u\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:654 +#: pg_resetxlog.c:722 #, c-format msgid "Latest checkpoint's NextMultiXactId: %u\n" msgstr "NextMultiXactId поÑлед. конт. точки: %u\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:656 +#: pg_resetxlog.c:724 #, c-format msgid "Latest checkpoint's NextMultiOffset: %u\n" msgstr "NextMultiOffset поÑлед. конт. точки: %u\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:658 +#: pg_resetxlog.c:726 #, c-format msgid "Latest checkpoint's oldestXID: %u\n" msgstr "oldestXID поÑледней конт. точки: %u\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:660 +#: pg_resetxlog.c:728 #, c-format msgid "Latest checkpoint's oldestXID's DB: %u\n" msgstr "БД Ñ oldestXID поÑледней конт. точки: %u\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:662 +#: pg_resetxlog.c:730 #, c-format msgid "Latest checkpoint's oldestActiveXID: %u\n" msgstr "oldestActiveXID поÑледней к. Ñ‚.: %u\n" # skip-rule: capital-letter-first -#: pg_resetxlog.c:664 +#: pg_resetxlog.c:732 #, c-format msgid "Latest checkpoint's oldestMultiXid: %u\n" msgstr "oldestMultiXid поÑледней конт. точки: %u\n" # skip-rule: capital-letter-first, double-space -#: pg_resetxlog.c:666 +#: pg_resetxlog.c:734 #, c-format msgid "Latest checkpoint's oldestMulti's DB: %u\n" msgstr "БД Ñ oldestMulti поÑледней к. Ñ‚.: %u\n" # skip-rule: capital-letter-first, double-space -#: pg_resetxlog.c:668 +#: pg_resetxlog.c:736 #, c-format msgid "Latest checkpoint's oldestCommitTsXid:%u\n" msgstr "oldestCommitTsXid поÑледней к. Ñ‚.: %u\n" # skip-rule: capital-letter-first, double-space -#: pg_resetxlog.c:670 +#: pg_resetxlog.c:738 #, c-format msgid "Latest checkpoint's newestCommitTsXid:%u\n" msgstr "newestCommitTsXid поÑледней к. Ñ‚.: %u\n" -#: pg_resetxlog.c:672 +#: pg_resetxlog.c:740 #, c-format msgid "Maximum data alignment: %u\n" msgstr "МакÑ. предел Ð²Ñ‹Ñ€Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ñ Ð´Ð°Ð½Ð½Ñ‹Ñ…: %u\n" -#: pg_resetxlog.c:675 +#: pg_resetxlog.c:743 #, c-format msgid "Database block size: %u\n" msgstr "Размер блока БД: %u\n" # skip-rule: double-space -#: pg_resetxlog.c:677 +#: pg_resetxlog.c:745 #, c-format msgid "Blocks per segment of large relation: %u\n" msgstr "Блоков в макÑ. Ñегменте отношений: %u\n" -#: pg_resetxlog.c:679 +#: pg_resetxlog.c:747 #, c-format msgid "WAL block size: %u\n" msgstr "Размер блока WAL: %u\n" -#: pg_resetxlog.c:681 +#: pg_resetxlog.c:749 #, c-format msgid "Bytes per WAL segment: %u\n" msgstr "Байт в Ñегменте WAL: %u\n" -#: pg_resetxlog.c:683 +#: pg_resetxlog.c:751 #, c-format msgid "Maximum length of identifiers: %u\n" msgstr "МакÑÐ¸Ð¼Ð°Ð»ÑŒÐ½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° идентификаторов: %u\n" -#: pg_resetxlog.c:685 +#: pg_resetxlog.c:753 #, c-format msgid "Maximum columns in an index: %u\n" msgstr "МакÑимальное чиÑло Ñтолбцов в индекÑе: %u\n" -#: pg_resetxlog.c:687 +#: pg_resetxlog.c:755 #, c-format msgid "Maximum size of a TOAST chunk: %u\n" msgstr "МакÑимальный размер порции TOAST: %u\n" -#: pg_resetxlog.c:689 +#: pg_resetxlog.c:757 #, c-format msgid "Size of a large-object chunk: %u\n" msgstr "Размер порции большого объекта: %u\n" -#: pg_resetxlog.c:691 +#: pg_resetxlog.c:759 #, c-format msgid "Date/time type storage: %s\n" msgstr "Формат Ñ…Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ Ð´Ð°Ñ‚Ñ‹/времени: %s\n" -#: pg_resetxlog.c:692 +#: pg_resetxlog.c:760 msgid "64-bit integers" msgstr "64-битные целые" -#: pg_resetxlog.c:692 +#: pg_resetxlog.c:760 msgid "floating-point numbers" msgstr "чиÑла Ñ Ð¿Ð»Ð°Ð²Ð°ÑŽÑ‰ÐµÐ¹ точкой" -#: pg_resetxlog.c:693 +#: pg_resetxlog.c:761 #, c-format msgid "Float4 argument passing: %s\n" msgstr "Передача аргумента Float4: %s\n" -#: pg_resetxlog.c:694 pg_resetxlog.c:696 +#: pg_resetxlog.c:762 pg_resetxlog.c:764 msgid "by reference" msgstr "по ÑÑылке" -#: pg_resetxlog.c:694 pg_resetxlog.c:696 +#: pg_resetxlog.c:762 pg_resetxlog.c:764 msgid "by value" msgstr "по значению" -#: pg_resetxlog.c:695 +#: pg_resetxlog.c:763 #, c-format msgid "Float8 argument passing: %s\n" msgstr "Передача аргумента Float8: %s\n" -#: pg_resetxlog.c:697 +#: pg_resetxlog.c:765 #, c-format msgid "Data page checksum version: %u\n" msgstr "ВерÑÐ¸Ñ ÐºÐ¾Ð½Ñ‚Ñ€Ð¾Ð»ÑŒÐ½Ñ‹Ñ… Ñумм Ñтраниц: %u\n" -#: pg_resetxlog.c:711 +#: pg_resetxlog.c:779 #, c-format msgid "" "\n" @@ -418,67 +434,67 @@ msgstr "" "ЗначениÑ, которые будут изменены:\n" "\n" -#: pg_resetxlog.c:714 +#: pg_resetxlog.c:782 #, c-format msgid "First log segment after reset: %s\n" msgstr "Первый Ñегмент журнала поÑле ÑброÑа: %s\n" -#: pg_resetxlog.c:718 +#: pg_resetxlog.c:786 #, c-format msgid "NextMultiXactId: %u\n" msgstr "NextMultiXactId: %u\n" -#: pg_resetxlog.c:720 +#: pg_resetxlog.c:788 #, c-format msgid "OldestMultiXid: %u\n" msgstr "OldestMultiXid: %u\n" -#: pg_resetxlog.c:722 +#: pg_resetxlog.c:790 #, c-format msgid "OldestMulti's DB: %u\n" msgstr "БД Ñ oldestMultiXid: %u\n" -#: pg_resetxlog.c:728 +#: pg_resetxlog.c:796 #, c-format msgid "NextMultiOffset: %u\n" msgstr "NextMultiOffset: %u\n" -#: pg_resetxlog.c:734 +#: pg_resetxlog.c:802 #, c-format msgid "NextOID: %u\n" msgstr "NextOID: %u\n" -#: pg_resetxlog.c:740 +#: pg_resetxlog.c:808 #, c-format msgid "NextXID: %u\n" msgstr "NextXID: %u\n" -#: pg_resetxlog.c:742 +#: pg_resetxlog.c:810 #, c-format msgid "OldestXID: %u\n" msgstr "OldestXID: %u\n" -#: pg_resetxlog.c:744 +#: pg_resetxlog.c:812 #, c-format msgid "OldestXID's DB: %u\n" msgstr "БД Ñ oldestXID: %u\n" -#: pg_resetxlog.c:750 +#: pg_resetxlog.c:818 #, c-format msgid "NextXID epoch: %u\n" msgstr "Эпоха NextXID: %u\n" -#: pg_resetxlog.c:756 +#: pg_resetxlog.c:824 #, c-format msgid "oldestCommitTsXid: %u\n" msgstr "oldestCommitTsXid: %u\n" -#: pg_resetxlog.c:761 +#: pg_resetxlog.c:829 #, c-format msgid "newestCommitTsXid: %u\n" msgstr "newestCommitTsXid: %u\n" -#: pg_resetxlog.c:827 +#: pg_resetxlog.c:895 #, c-format msgid "" "%s: internal error -- sizeof(ControlFileData) is too large ... fix " @@ -487,52 +503,52 @@ msgstr "" "%s: внутреннÑÑ Ð¾ÑˆÐ¸Ð±ÐºÐ° -- размер ControlFileData Ñлишком велик -- иÑправьте " "PG_CONTROL_SIZE\n" -#: pg_resetxlog.c:842 +#: pg_resetxlog.c:910 #, c-format msgid "%s: could not create pg_control file: %s\n" msgstr "%s: не удалоÑÑŒ Ñоздать файл pg_control: %s\n" -#: pg_resetxlog.c:853 +#: pg_resetxlog.c:921 #, c-format msgid "%s: could not write pg_control file: %s\n" msgstr "%s: не удалоÑÑŒ запиÑать файл pg_control: %s\n" -#: pg_resetxlog.c:860 pg_resetxlog.c:1156 +#: pg_resetxlog.c:928 pg_resetxlog.c:1224 #, c-format msgid "%s: fsync error: %s\n" msgstr "%s: ошибка Ñинхронизации Ñ Ð¤Ð¡: %s\n" -#: pg_resetxlog.c:900 pg_resetxlog.c:971 pg_resetxlog.c:1022 +#: pg_resetxlog.c:968 pg_resetxlog.c:1039 pg_resetxlog.c:1090 #, c-format msgid "%s: could not open directory \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ открыть каталог \"%s\": %s\n" -#: pg_resetxlog.c:936 pg_resetxlog.c:993 pg_resetxlog.c:1047 +#: pg_resetxlog.c:1004 pg_resetxlog.c:1061 pg_resetxlog.c:1115 #, c-format msgid "%s: could not read directory \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ прочитать каталог \"%s\": %s\n" -#: pg_resetxlog.c:943 pg_resetxlog.c:1000 pg_resetxlog.c:1054 +#: pg_resetxlog.c:1011 pg_resetxlog.c:1068 pg_resetxlog.c:1122 #, c-format msgid "%s: could not close directory \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ закрыть каталог \"%s\": %s\n" -#: pg_resetxlog.c:984 pg_resetxlog.c:1038 +#: pg_resetxlog.c:1052 pg_resetxlog.c:1106 #, c-format msgid "%s: could not delete file \"%s\": %s\n" msgstr "%s: ошибка при удалении файла \"%s\": %s\n" -#: pg_resetxlog.c:1123 +#: pg_resetxlog.c:1191 #, c-format msgid "%s: could not open file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ открыть файл \"%s\": %s\n" -#: pg_resetxlog.c:1134 pg_resetxlog.c:1148 +#: pg_resetxlog.c:1202 pg_resetxlog.c:1216 #, c-format msgid "%s: could not write file \"%s\": %s\n" msgstr "%s: не удалоÑÑŒ запиÑать файл \"%s\": %s\n" -#: pg_resetxlog.c:1167 +#: pg_resetxlog.c:1235 #, c-format msgid "" "%s resets the PostgreSQL transaction log.\n" @@ -541,7 +557,7 @@ msgstr "" "%s ÑбраÑывает журнал транзакций PostgreSQL.\n" "\n" -#: pg_resetxlog.c:1168 +#: pg_resetxlog.c:1236 #, c-format msgid "" "Usage:\n" @@ -552,12 +568,12 @@ msgstr "" " %s [ПÐРÐМЕТР]... КÐТ_ДÐÐÐЫХ\n" "\n" -#: pg_resetxlog.c:1169 +#: pg_resetxlog.c:1237 #, c-format msgid "Options:\n" msgstr "Параметры:\n" -#: pg_resetxlog.c:1170 +#: pg_resetxlog.c:1238 #, c-format msgid "" " -c XID,XID set oldest and newest transactions bearing commit " @@ -566,27 +582,27 @@ msgstr "" " -c XID,XID задать Ñтарейшую и новейшую транзакции, неÑущие метку " "времени фикÑации\n" -#: pg_resetxlog.c:1171 +#: pg_resetxlog.c:1239 #, c-format msgid " (zero in either value means no change)\n" msgstr " (0 в любом из аргументов игнорируетÑÑ)\n" -#: pg_resetxlog.c:1172 +#: pg_resetxlog.c:1240 #, c-format msgid " [-D] DATADIR data directory\n" msgstr " [-D] КÐТ_ДÐÐÐЫХ каталог данных\n" -#: pg_resetxlog.c:1173 +#: pg_resetxlog.c:1241 #, c-format msgid " -e XIDEPOCH set next transaction ID epoch\n" msgstr " -e XIDEPOCH задать Ñпоху в ID Ñледующей транзакции\n" -#: pg_resetxlog.c:1174 +#: pg_resetxlog.c:1242 #, c-format msgid " -f force update to be done\n" msgstr " -f принудительное выполнение операции\n" -#: pg_resetxlog.c:1175 +#: pg_resetxlog.c:1243 #, c-format msgid "" " -l XLOGFILE force minimum WAL starting location for new transaction " @@ -595,12 +611,12 @@ msgstr "" " -l XLOGFILE задать минимальное начальное положение WAL Ð´Ð»Ñ Ð½Ð¾Ð²Ð¾Ð³Ð¾\n" " журнала транзакций\n" -#: pg_resetxlog.c:1176 +#: pg_resetxlog.c:1244 #, c-format msgid " -m MXID,MXID set next and oldest multitransaction ID\n" msgstr " -m MXID,MXID задать ID Ñледующей и Ñтарейшей мультитранзакции\n" -#: pg_resetxlog.c:1177 +#: pg_resetxlog.c:1245 #, c-format msgid "" " -n no update, just show what would be done (for testing)\n" @@ -609,32 +625,32 @@ msgstr "" "их\n" " (Ð´Ð»Ñ Ð¿Ñ€Ð¾Ð²ÐµÑ€ÐºÐ¸)\n" -#: pg_resetxlog.c:1178 +#: pg_resetxlog.c:1246 #, c-format msgid " -o OID set next OID\n" msgstr " -o OID задать Ñледующий OID\n" -#: pg_resetxlog.c:1179 +#: pg_resetxlog.c:1247 #, c-format msgid " -O OFFSET set next multitransaction offset\n" msgstr " -O СМЕЩЕÐИЕ задать Ñмещение Ñледующей мультитранзакции\n" -#: pg_resetxlog.c:1180 +#: pg_resetxlog.c:1248 #, c-format msgid " -V, --version output version information, then exit\n" msgstr " -V, --version показать верÑию и выйти\n" -#: pg_resetxlog.c:1181 +#: pg_resetxlog.c:1249 #, c-format msgid " -x XID set next transaction ID\n" msgstr " -x XID задать ID Ñледующей транзакции\n" -#: pg_resetxlog.c:1182 +#: pg_resetxlog.c:1250 #, c-format msgid " -?, --help show this help, then exit\n" msgstr " -?, --help показать Ñту Ñправку и выйти\n" -#: pg_resetxlog.c:1183 +#: pg_resetxlog.c:1251 #, c-format msgid "" "\n" diff --git a/src/bin/pg_rewind/po/es.po b/src/bin/pg_rewind/po/es.po index e063faf236..454ce5e0ab 100644 --- a/src/bin/pg_rewind/po/es.po +++ b/src/bin/pg_rewind/po/es.po @@ -7,7 +7,7 @@ msgid "" msgstr "" "Project-Id-Version: pg_rewind (PostgreSQL) 9.6\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:55+0000\n" +"POT-Creation-Date: 2017-08-27 21:53+0000\n" "PO-Revision-Date: 2017-05-20 21:25-0400\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL Español \n" @@ -18,8 +18,7 @@ msgstr "" "X-Generator: Poedit 1.8.7\n" #: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 -#: ../../common/fe_memutils.c:98 parsexlog.c:74 parsexlog.c:127 -#: parsexlog.c:179 +#: ../../common/fe_memutils.c:98 parsexlog.c:74 parsexlog.c:127 parsexlog.c:179 #, c-format msgid "out of memory\n" msgstr "memoria agotada\n" @@ -280,97 +279,97 @@ msgstr "no se pudo obtener el listado de archivos: %s" msgid "unexpected result set while fetching file list\n" msgstr "conjunto de resultados inesperado mientras se obtenía el listado de archivos\n" -#: libpq_fetch.c:240 +#: libpq_fetch.c:262 #, c-format msgid "could not send query: %s" msgstr "no se pudo enviar la consulta: %s" -#: libpq_fetch.c:242 +#: libpq_fetch.c:264 #, c-format msgid "getting file chunks\n" msgstr "obteniendo trozos de archivos\n" -#: libpq_fetch.c:245 +#: libpq_fetch.c:267 #, c-format msgid "could not set libpq connection to single row mode\n" msgstr "no se pudo establecer la coneción libpq a modo «single row»\n" -#: libpq_fetch.c:265 +#: libpq_fetch.c:287 #, c-format msgid "unexpected result while fetching remote files: %s" msgstr "resultados inesperados mientras se obtenían archivos remotos: %s" -#: libpq_fetch.c:271 +#: libpq_fetch.c:293 #, c-format msgid "unexpected result set size while fetching remote files\n" msgstr "tamaño del conjunto de resultados inesperado mientras se obtenían archivos remotos\n" -#: libpq_fetch.c:277 +#: libpq_fetch.c:299 #, c-format msgid "unexpected data types in result set while fetching remote files: %u %u %u\n" msgstr "tipos de dato inesperados en el conjunto de resultados mientras se obtenían archivos remotos: %u %u %u\n" -#: libpq_fetch.c:285 +#: libpq_fetch.c:307 #, c-format msgid "unexpected result format while fetching remote files\n" msgstr "formato de resultados inesperado mientras se obtenían archivos remotos\n" -#: libpq_fetch.c:291 +#: libpq_fetch.c:313 #, c-format msgid "unexpected null values in result while fetching remote files\n" msgstr "valores nulos inesperados en el resultado mientras se obtenían archivos remotos\n" -#: libpq_fetch.c:295 +#: libpq_fetch.c:317 #, c-format msgid "unexpected result length while fetching remote files\n" msgstr "largo del resultado inesperado mientras se obtenían los archivos remotos\n" -#: libpq_fetch.c:317 +#: libpq_fetch.c:339 #, c-format msgid "received null value for chunk for file \"%s\", file has been deleted\n" msgstr "recibido un valor NULL para un trozo del archivo «%s», el archivo ha sido borrado\n" -#: libpq_fetch.c:324 -#, c-format -msgid "received chunk for file \"%s\", offset %d, size %d\n" +#: libpq_fetch.c:346 +#, fuzzy, c-format +msgid "received chunk for file \"%s\", offset " msgstr "recibido un trozo para el archivo «%s», posición %d, tamaño %d\n" -#: libpq_fetch.c:353 +#: libpq_fetch.c:375 #, c-format msgid "could not fetch remote file \"%s\": %s" msgstr "no se pudo obtener el archivo remoto «%s»: %s" -#: libpq_fetch.c:358 +#: libpq_fetch.c:380 #, c-format msgid "unexpected result set while fetching remote file \"%s\"\n" msgstr "conjunto de resultados inesperado mientras se obtenía el archivo remoto «%s»\n" -#: libpq_fetch.c:369 +#: libpq_fetch.c:391 #, c-format msgid "fetched file \"%s\", length %d\n" msgstr "obtenido archivo «%s», largo %d\n" -#: libpq_fetch.c:401 +#: libpq_fetch.c:424 #, c-format msgid "could not send COPY data: %s" msgstr "no se pudo enviar datos COPY: %s" -#: libpq_fetch.c:427 +#: libpq_fetch.c:450 #, c-format msgid "could not create temporary table: %s" msgstr "no se pudo crear tabla temporal: %s" -#: libpq_fetch.c:435 +#: libpq_fetch.c:458 #, c-format msgid "could not send file list: %s" msgstr "no se pudo enviar el listado de archivos: %s" -#: libpq_fetch.c:477 +#: libpq_fetch.c:500 #, c-format msgid "could not send end-of-COPY: %s" msgstr "no se pudo enviar fin-de-COPY: %s" -#: libpq_fetch.c:483 +#: libpq_fetch.c:506 #, c-format msgid "unexpected result while sending file list: %s" msgstr "resultados inesperados mientras se enviaba el listado de archivos: %s" diff --git a/src/bin/pg_rewind/po/ru.po b/src/bin/pg_rewind/po/ru.po index c31850c064..fcdcda836d 100644 --- a/src/bin/pg_rewind/po/ru.po +++ b/src/bin/pg_rewind/po/ru.po @@ -1,15 +1,14 @@ # Russian message translation file for pg_rewind # Copyright (C) 2015-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2015-2016. +# Alexander Lakhin , 2015-2017. # msgid "" msgstr "" "Project-Id-Version: pg_rewind (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:14+0000\n" -"PO-Revision-Date: 2016-11-24 14:26+0300\n" -"Last-Translator: Alexander Lakhin \n" +"POT-Creation-Date: 2017-08-17 17:53+0000\n" +"PO-Revision-Date: 2017-08-23 10:02+0300\n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -17,6 +16,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" +"Last-Translator: Alexander Lakhin \n" #: ../../common/fe_memutils.c:35 ../../common/fe_memutils.c:75 #: ../../common/fe_memutils.c:98 parsexlog.c:74 parsexlog.c:127 parsexlog.c:179 @@ -289,32 +289,32 @@ msgstr "не удалоÑÑŒ получить ÑпиÑок файлов: %s" msgid "unexpected result set while fetching file list\n" msgstr "неожиданный результат при получении ÑпиÑка файлов\n" -#: libpq_fetch.c:240 +#: libpq_fetch.c:262 #, c-format msgid "could not send query: %s" msgstr "не удалоÑÑŒ отправить запроÑ: %s" -#: libpq_fetch.c:242 +#: libpq_fetch.c:264 #, c-format msgid "getting file chunks\n" msgstr "получение Ñегментов файлов\n" -#: libpq_fetch.c:245 +#: libpq_fetch.c:267 #, c-format msgid "could not set libpq connection to single row mode\n" msgstr "не удалоÑÑŒ перевеÑти подключение libpq в одноÑтрочный режим\n" -#: libpq_fetch.c:265 +#: libpq_fetch.c:287 #, c-format msgid "unexpected result while fetching remote files: %s" msgstr "неожиданный результат при получении удалённых файлов: %s" -#: libpq_fetch.c:271 +#: libpq_fetch.c:293 #, c-format msgid "unexpected result set size while fetching remote files\n" msgstr "неожиданный размер набора результатов при получении удалённых файлов\n" -#: libpq_fetch.c:277 +#: libpq_fetch.c:299 #, c-format msgid "" "unexpected data types in result set while fetching remote files: %u %u %u\n" @@ -322,68 +322,68 @@ msgstr "" "неожиданные типы данных в наборе результатов при получении удалённых файлов: " "%u %u %u\n" -#: libpq_fetch.c:285 +#: libpq_fetch.c:307 #, c-format msgid "unexpected result format while fetching remote files\n" msgstr "неожиданный формат результата при получении удалённых файлов\n" -#: libpq_fetch.c:291 +#: libpq_fetch.c:313 #, c-format msgid "unexpected null values in result while fetching remote files\n" msgstr "" "неожиданные Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ NULL в результате при получении удалённых файлов\n" -#: libpq_fetch.c:295 +#: libpq_fetch.c:317 #, c-format msgid "unexpected result length while fetching remote files\n" msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð°Ñ Ð´Ð»Ð¸Ð½Ð° результата при получении удалённых файлов\n" -#: libpq_fetch.c:317 +#: libpq_fetch.c:339 #, c-format msgid "received null value for chunk for file \"%s\", file has been deleted\n" msgstr "Ð´Ð»Ñ Ñ„Ð°Ð¹Ð»Ð° \"%s\" вмеÑто Ñегмента получено NULL-значение, файл удалён\n" -#: libpq_fetch.c:324 +#: libpq_fetch.c:346 #, c-format -msgid "received chunk for file \"%s\", offset %d, size %d\n" -msgstr "получен Ñегмент файла \"%s\": Ñмещение %d, размер %d\n" +msgid "received chunk for file \"%s\", offset " +msgstr "получен Ñегмент файла \"%s\": Ñмещение " -#: libpq_fetch.c:353 +#: libpq_fetch.c:375 #, c-format msgid "could not fetch remote file \"%s\": %s" msgstr "не удалоÑÑŒ получить удалённый файл \"%s\": %s" -#: libpq_fetch.c:358 +#: libpq_fetch.c:380 #, c-format msgid "unexpected result set while fetching remote file \"%s\"\n" msgstr "неожиданный набор результатов при получении удалённого файла \"%s\"\n" -#: libpq_fetch.c:369 +#: libpq_fetch.c:391 #, c-format msgid "fetched file \"%s\", length %d\n" msgstr "получен файл \"%s\", длина %d\n" -#: libpq_fetch.c:401 +#: libpq_fetch.c:424 #, c-format msgid "could not send COPY data: %s" msgstr "не удалоÑÑŒ отправить данные COPY: %s" -#: libpq_fetch.c:427 +#: libpq_fetch.c:450 #, c-format msgid "could not create temporary table: %s" msgstr "не удалоÑÑŒ Ñоздать временную таблицу: %s" -#: libpq_fetch.c:435 +#: libpq_fetch.c:458 #, c-format msgid "could not send file list: %s" msgstr "не удалоÑÑŒ отправить ÑпиÑок файлов: %s" -#: libpq_fetch.c:477 +#: libpq_fetch.c:500 #, c-format msgid "could not send end-of-COPY: %s" msgstr "не удалоÑÑŒ отправить Ñообщение о завершении копированиÑ: %s" -#: libpq_fetch.c:483 +#: libpq_fetch.c:506 #, c-format msgid "unexpected result while sending file list: %s" msgstr "неожиданный результат при передаче ÑпиÑка: %s" diff --git a/src/bin/psql/po/es.po b/src/bin/psql/po/es.po index 0704a8ddb1..b6f749a36b 100644 --- a/src/bin/psql/po/es.po +++ b/src/bin/psql/po/es.po @@ -11,7 +11,7 @@ msgid "" msgstr "" "Project-Id-Version: psql (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" "PO-Revision-Date: 2017-05-20 23:08-0400\n" "Last-Translator: Ãlvaro Herrera \n" "Language-Team: PgSQL Español \n" @@ -221,8 +221,8 @@ msgstr "" "no encontrado\n" #: command.c:871 command.c:1962 command.c:3649 common.c:153 common.c:200 -#: common.c:497 common.c:1190 common.c:1218 common.c:1319 copy.c:489 -#: copy.c:709 large_obj.c:156 large_obj.c:191 large_obj.c:253 +#: common.c:497 common.c:1190 common.c:1218 common.c:1319 copy.c:489 copy.c:709 +#: large_obj.c:156 large_obj.c:191 large_obj.c:253 #, c-format msgid "%s" msgstr "%s" @@ -951,8 +951,7 @@ msgstr "Ubicación" msgid "Options" msgstr "Opciones" -#: describe.c:252 describe.c:609 describe.c:806 describe.c:3061 -#: describe.c:3065 +#: describe.c:252 describe.c:609 describe.c:806 describe.c:3061 describe.c:3065 msgid "Size" msgstr "Tamaño" @@ -2221,14 +2220,12 @@ msgstr "General\n" #: help.c:174 #, c-format msgid " \\copyright show PostgreSQL usage and distribution terms\n" -msgstr "" -" \\copyright mostrar términos de uso y distribución de PostgreSQL\n" +msgstr " \\copyright mostrar términos de uso y distribución de PostgreSQL\n" #: help.c:175 #, c-format msgid " \\errverbose show most recent error message at maximum verbosity\n" -msgstr "" -" \\errverbose mostrar error más reciente en máxima verbosidad\n" +msgstr " \\errverbose mostrar error más reciente en máxima verbosidad\n" #: help.c:176 #, c-format @@ -2240,8 +2237,7 @@ msgstr "" #: help.c:177 #, c-format msgid " \\gexec execute query, then execute each value in its result\n" -msgstr "" -" \\gexec ejecutar la consulta, luego ejecuta cada valor del resultado\n" +msgstr " \\gexec ejecutar la consulta, luego ejecuta cada valor del resultado\n" #: help.c:178 #, c-format @@ -2288,8 +2284,7 @@ msgstr " \\? variables desplegar ayuda sobre variables especiales\n" #: help.c:189 #, c-format msgid " \\h [NAME] help on syntax of SQL commands, * for all commands\n" -msgstr "" -" \\h [NOMBRE] desplegar sintaxis de órdenes SQL, use * para mostrar todas\n" +msgstr " \\h [NOMBRE] desplegar sintaxis de órdenes SQL, use * para mostrar todas\n" #: help.c:192 #, c-format @@ -2761,7 +2756,8 @@ msgstr "" msgid "" "List of specially treated variables\n" "\n" -msgstr "Lista de variables con tratamiento especial\n" +msgstr "" +"Lista de variables con tratamiento especial\n" "\n" #: help.c:332 @@ -3306,34 +3302,34 @@ msgstr "%s: memoria agotada\n" #: sql_help.c:1138 sql_help.c:1140 sql_help.c:1150 sql_help.c:1152 #: sql_help.c:1162 sql_help.c:1165 sql_help.c:1186 sql_help.c:1188 #: sql_help.c:1190 sql_help.c:1193 sql_help.c:1195 sql_help.c:1197 -#: sql_help.c:1247 sql_help.c:1285 sql_help.c:1288 sql_help.c:1290 -#: sql_help.c:1292 sql_help.c:1294 sql_help.c:1296 sql_help.c:1299 -#: sql_help.c:1339 sql_help.c:1544 sql_help.c:1608 sql_help.c:1627 -#: sql_help.c:1640 sql_help.c:1694 sql_help.c:1698 sql_help.c:1708 -#: sql_help.c:1728 sql_help.c:1753 sql_help.c:1771 sql_help.c:1800 -#: sql_help.c:1875 sql_help.c:1917 sql_help.c:1939 sql_help.c:1959 -#: sql_help.c:1960 sql_help.c:1995 sql_help.c:2015 sql_help.c:2037 -#: sql_help.c:2050 sql_help.c:2081 sql_help.c:2106 sql_help.c:2150 -#: sql_help.c:2336 sql_help.c:2349 sql_help.c:2366 sql_help.c:2382 -#: sql_help.c:2421 sql_help.c:2472 sql_help.c:2476 sql_help.c:2478 -#: sql_help.c:2484 sql_help.c:2502 sql_help.c:2529 sql_help.c:2564 -#: sql_help.c:2576 sql_help.c:2585 sql_help.c:2629 sql_help.c:2643 -#: sql_help.c:2671 sql_help.c:2679 sql_help.c:2687 sql_help.c:2695 -#: sql_help.c:2703 sql_help.c:2711 sql_help.c:2719 sql_help.c:2727 -#: sql_help.c:2736 sql_help.c:2747 sql_help.c:2755 sql_help.c:2763 -#: sql_help.c:2771 sql_help.c:2779 sql_help.c:2789 sql_help.c:2798 -#: sql_help.c:2807 sql_help.c:2815 sql_help.c:2824 sql_help.c:2832 -#: sql_help.c:2841 sql_help.c:2849 sql_help.c:2857 sql_help.c:2865 -#: sql_help.c:2873 sql_help.c:2881 sql_help.c:2889 sql_help.c:2897 -#: sql_help.c:2905 sql_help.c:2922 sql_help.c:2931 sql_help.c:2939 -#: sql_help.c:2956 sql_help.c:2971 sql_help.c:3236 sql_help.c:3287 -#: sql_help.c:3316 sql_help.c:3324 sql_help.c:3743 sql_help.c:3791 -#: sql_help.c:3932 +#: sql_help.c:1247 sql_help.c:1289 sql_help.c:1292 sql_help.c:1294 +#: sql_help.c:1296 sql_help.c:1298 sql_help.c:1300 sql_help.c:1303 +#: sql_help.c:1343 sql_help.c:1548 sql_help.c:1612 sql_help.c:1631 +#: sql_help.c:1644 sql_help.c:1698 sql_help.c:1702 sql_help.c:1712 +#: sql_help.c:1732 sql_help.c:1757 sql_help.c:1775 sql_help.c:1804 +#: sql_help.c:1879 sql_help.c:1921 sql_help.c:1943 sql_help.c:1963 +#: sql_help.c:1964 sql_help.c:1999 sql_help.c:2019 sql_help.c:2041 +#: sql_help.c:2054 sql_help.c:2085 sql_help.c:2110 sql_help.c:2154 +#: sql_help.c:2340 sql_help.c:2353 sql_help.c:2370 sql_help.c:2386 +#: sql_help.c:2425 sql_help.c:2476 sql_help.c:2480 sql_help.c:2482 +#: sql_help.c:2488 sql_help.c:2506 sql_help.c:2533 sql_help.c:2568 +#: sql_help.c:2580 sql_help.c:2589 sql_help.c:2633 sql_help.c:2647 +#: sql_help.c:2675 sql_help.c:2683 sql_help.c:2691 sql_help.c:2699 +#: sql_help.c:2707 sql_help.c:2715 sql_help.c:2723 sql_help.c:2731 +#: sql_help.c:2740 sql_help.c:2751 sql_help.c:2759 sql_help.c:2767 +#: sql_help.c:2775 sql_help.c:2783 sql_help.c:2793 sql_help.c:2802 +#: sql_help.c:2811 sql_help.c:2819 sql_help.c:2828 sql_help.c:2836 +#: sql_help.c:2845 sql_help.c:2853 sql_help.c:2861 sql_help.c:2869 +#: sql_help.c:2877 sql_help.c:2885 sql_help.c:2893 sql_help.c:2901 +#: sql_help.c:2909 sql_help.c:2926 sql_help.c:2935 sql_help.c:2943 +#: sql_help.c:2960 sql_help.c:2975 sql_help.c:3240 sql_help.c:3291 +#: sql_help.c:3320 sql_help.c:3328 sql_help.c:3747 sql_help.c:3795 +#: sql_help.c:3936 msgid "name" msgstr "nombre" -#: sql_help.c:37 sql_help.c:40 sql_help.c:43 sql_help.c:311 sql_help.c:1405 -#: sql_help.c:2644 sql_help.c:3539 +#: sql_help.c:37 sql_help.c:40 sql_help.c:43 sql_help.c:311 sql_help.c:1409 +#: sql_help.c:2648 sql_help.c:3543 msgid "aggregate_signature" msgstr "signatura_func_agregación" @@ -3343,108 +3339,106 @@ msgstr "signatura_func_agregación" #: sql_help.c:774 sql_help.c:820 sql_help.c:844 sql_help.c:854 sql_help.c:884 #: sql_help.c:904 sql_help.c:996 sql_help.c:1061 sql_help.c:1104 #: sql_help.c:1125 sql_help.c:1139 sql_help.c:1151 sql_help.c:1164 -#: sql_help.c:1194 sql_help.c:1248 sql_help.c:1293 +#: sql_help.c:1194 sql_help.c:1248 sql_help.c:1297 msgid "new_name" msgstr "nuevo_nombre" #: sql_help.c:41 sql_help.c:67 sql_help.c:82 sql_help.c:118 sql_help.c:234 #: sql_help.c:252 sql_help.c:373 sql_help.c:459 sql_help.c:505 sql_help.c:585 #: sql_help.c:594 sql_help.c:652 sql_help.c:672 sql_help.c:701 sql_help.c:756 -#: sql_help.c:856 sql_help.c:882 sql_help.c:902 sql_help.c:1045 -#: sql_help.c:1063 sql_help.c:1106 sql_help.c:1127 sql_help.c:1189 -#: sql_help.c:1291 sql_help.c:2322 +#: sql_help.c:856 sql_help.c:882 sql_help.c:902 sql_help.c:1045 sql_help.c:1063 +#: sql_help.c:1106 sql_help.c:1127 sql_help.c:1189 sql_help.c:1295 +#: sql_help.c:2326 msgid "new_owner" msgstr "nuevo_dueño" #: sql_help.c:44 sql_help.c:69 sql_help.c:84 sql_help.c:238 sql_help.c:303 #: sql_help.c:425 sql_help.c:510 sql_help.c:635 sql_help.c:676 sql_help.c:704 -#: sql_help.c:759 sql_help.c:886 sql_help.c:998 sql_help.c:1108 -#: sql_help.c:1129 sql_help.c:1141 sql_help.c:1153 sql_help.c:1196 -#: sql_help.c:1295 +#: sql_help.c:759 sql_help.c:886 sql_help.c:998 sql_help.c:1108 sql_help.c:1129 +#: sql_help.c:1141 sql_help.c:1153 sql_help.c:1196 sql_help.c:1299 msgid "new_schema" msgstr "nuevo_esquema" -#: sql_help.c:45 sql_help.c:1458 sql_help.c:2645 sql_help.c:3558 +#: sql_help.c:45 sql_help.c:1462 sql_help.c:2649 sql_help.c:3562 msgid "where aggregate_signature is:" msgstr "donde signatura_func_agregación es:" #: sql_help.c:46 sql_help.c:49 sql_help.c:52 sql_help.c:321 sql_help.c:346 #: sql_help.c:349 sql_help.c:352 sql_help.c:492 sql_help.c:497 sql_help.c:502 -#: sql_help.c:507 sql_help.c:512 sql_help.c:1423 sql_help.c:1459 -#: sql_help.c:1462 sql_help.c:1465 sql_help.c:1609 sql_help.c:1628 -#: sql_help.c:1631 sql_help.c:1876 sql_help.c:2646 sql_help.c:2649 -#: sql_help.c:2652 sql_help.c:2737 sql_help.c:3122 sql_help.c:3454 -#: sql_help.c:3545 sql_help.c:3559 sql_help.c:3562 sql_help.c:3565 +#: sql_help.c:507 sql_help.c:512 sql_help.c:1427 sql_help.c:1463 +#: sql_help.c:1466 sql_help.c:1469 sql_help.c:1613 sql_help.c:1632 +#: sql_help.c:1635 sql_help.c:1880 sql_help.c:2650 sql_help.c:2653 +#: sql_help.c:2656 sql_help.c:2741 sql_help.c:3126 sql_help.c:3458 +#: sql_help.c:3549 sql_help.c:3563 sql_help.c:3566 sql_help.c:3569 msgid "argmode" msgstr "modo_arg" #: sql_help.c:47 sql_help.c:50 sql_help.c:53 sql_help.c:322 sql_help.c:347 #: sql_help.c:350 sql_help.c:353 sql_help.c:493 sql_help.c:498 sql_help.c:503 -#: sql_help.c:508 sql_help.c:513 sql_help.c:1424 sql_help.c:1460 -#: sql_help.c:1463 sql_help.c:1466 sql_help.c:1610 sql_help.c:1629 -#: sql_help.c:1632 sql_help.c:1877 sql_help.c:2647 sql_help.c:2650 -#: sql_help.c:2653 sql_help.c:2738 sql_help.c:3546 sql_help.c:3560 -#: sql_help.c:3563 sql_help.c:3566 +#: sql_help.c:508 sql_help.c:513 sql_help.c:1428 sql_help.c:1464 +#: sql_help.c:1467 sql_help.c:1470 sql_help.c:1614 sql_help.c:1633 +#: sql_help.c:1636 sql_help.c:1881 sql_help.c:2651 sql_help.c:2654 +#: sql_help.c:2657 sql_help.c:2742 sql_help.c:3550 sql_help.c:3564 +#: sql_help.c:3567 sql_help.c:3570 msgid "argname" msgstr "nombre_arg" #: sql_help.c:48 sql_help.c:51 sql_help.c:54 sql_help.c:323 sql_help.c:348 #: sql_help.c:351 sql_help.c:354 sql_help.c:494 sql_help.c:499 sql_help.c:504 -#: sql_help.c:509 sql_help.c:514 sql_help.c:1425 sql_help.c:1461 -#: sql_help.c:1464 sql_help.c:1467 sql_help.c:1878 sql_help.c:2648 -#: sql_help.c:2651 sql_help.c:2654 sql_help.c:2739 sql_help.c:3547 -#: sql_help.c:3561 sql_help.c:3564 sql_help.c:3567 +#: sql_help.c:509 sql_help.c:514 sql_help.c:1429 sql_help.c:1465 +#: sql_help.c:1468 sql_help.c:1471 sql_help.c:1882 sql_help.c:2652 +#: sql_help.c:2655 sql_help.c:2658 sql_help.c:2743 sql_help.c:3551 +#: sql_help.c:3565 sql_help.c:3568 sql_help.c:3571 msgid "argtype" msgstr "tipo_arg" #: sql_help.c:110 sql_help.c:370 sql_help.c:448 sql_help.c:460 sql_help.c:814 -#: sql_help.c:899 sql_help.c:1122 sql_help.c:1242 sql_help.c:1270 -#: sql_help.c:1515 sql_help.c:1521 sql_help.c:1803 sql_help.c:1835 -#: sql_help.c:1842 sql_help.c:1918 sql_help.c:2082 sql_help.c:2171 -#: sql_help.c:2351 sql_help.c:2530 sql_help.c:2552 sql_help.c:2990 -#: sql_help.c:3156 +#: sql_help.c:899 sql_help.c:1122 sql_help.c:1242 sql_help.c:1274 +#: sql_help.c:1519 sql_help.c:1525 sql_help.c:1807 sql_help.c:1839 +#: sql_help.c:1846 sql_help.c:1922 sql_help.c:2086 sql_help.c:2175 +#: sql_help.c:2355 sql_help.c:2534 sql_help.c:2556 sql_help.c:2994 +#: sql_help.c:3160 msgid "option" msgstr "opción" -#: sql_help.c:111 sql_help.c:815 sql_help.c:1243 sql_help.c:1919 -#: sql_help.c:2083 sql_help.c:2531 +#: sql_help.c:111 sql_help.c:815 sql_help.c:1243 sql_help.c:1923 +#: sql_help.c:2087 sql_help.c:2535 msgid "where option can be:" msgstr "donde opción puede ser:" -#: sql_help.c:112 sql_help.c:1735 +#: sql_help.c:112 sql_help.c:1739 msgid "allowconn" msgstr "allowconn" -#: sql_help.c:113 sql_help.c:816 sql_help.c:1244 sql_help.c:1736 -#: sql_help.c:2084 sql_help.c:2532 +#: sql_help.c:113 sql_help.c:816 sql_help.c:1244 sql_help.c:1740 +#: sql_help.c:2088 sql_help.c:2536 msgid "connlimit" msgstr "límite_conexiones" -#: sql_help.c:114 sql_help.c:1737 +#: sql_help.c:114 sql_help.c:1741 msgid "istemplate" msgstr "esplantilla" -#: sql_help.c:120 sql_help.c:573 sql_help.c:638 sql_help.c:1001 -#: sql_help.c:1038 +#: sql_help.c:120 sql_help.c:573 sql_help.c:638 sql_help.c:1001 sql_help.c:1038 msgid "new_tablespace" msgstr "nuevo_tablespace" #: sql_help.c:122 sql_help.c:125 sql_help.c:127 sql_help.c:519 sql_help.c:521 #: sql_help.c:522 sql_help.c:823 sql_help.c:827 sql_help.c:830 sql_help.c:915 -#: sql_help.c:918 sql_help.c:1250 sql_help.c:1253 sql_help.c:1255 -#: sql_help.c:1887 sql_help.c:3341 sql_help.c:3732 +#: sql_help.c:918 sql_help.c:1251 sql_help.c:1255 sql_help.c:1258 +#: sql_help.c:1891 sql_help.c:3345 sql_help.c:3736 msgid "configuration_parameter" msgstr "parámetro_de_configuración" #: sql_help.c:123 sql_help.c:371 sql_help.c:443 sql_help.c:449 sql_help.c:461 #: sql_help.c:520 sql_help.c:568 sql_help.c:644 sql_help.c:650 sql_help.c:824 -#: sql_help.c:900 sql_help.c:916 sql_help.c:917 sql_help.c:1020 -#: sql_help.c:1040 sql_help.c:1066 sql_help.c:1123 sql_help.c:1251 -#: sql_help.c:1271 sql_help.c:1804 sql_help.c:1836 sql_help.c:1843 -#: sql_help.c:1888 sql_help.c:1889 sql_help.c:1947 sql_help.c:1979 -#: sql_help.c:2172 sql_help.c:2246 sql_help.c:2254 sql_help.c:2286 -#: sql_help.c:2308 sql_help.c:2325 sql_help.c:2352 sql_help.c:2553 -#: sql_help.c:3157 sql_help.c:3733 sql_help.c:3734 +#: sql_help.c:900 sql_help.c:916 sql_help.c:917 sql_help.c:1020 sql_help.c:1040 +#: sql_help.c:1066 sql_help.c:1123 sql_help.c:1252 sql_help.c:1275 +#: sql_help.c:1808 sql_help.c:1840 sql_help.c:1847 sql_help.c:1892 +#: sql_help.c:1893 sql_help.c:1951 sql_help.c:1983 sql_help.c:2176 +#: sql_help.c:2250 sql_help.c:2258 sql_help.c:2290 sql_help.c:2312 +#: sql_help.c:2329 sql_help.c:2356 sql_help.c:2557 sql_help.c:3161 +#: sql_help.c:3737 sql_help.c:3738 msgid "value" msgstr "valor" @@ -3452,9 +3446,9 @@ msgstr "valor" msgid "target_role" msgstr "rol_destino" -#: sql_help.c:186 sql_help.c:1787 sql_help.c:2130 sql_help.c:2135 -#: sql_help.c:3104 sql_help.c:3111 sql_help.c:3125 sql_help.c:3131 -#: sql_help.c:3436 sql_help.c:3443 sql_help.c:3457 sql_help.c:3463 +#: sql_help.c:186 sql_help.c:1791 sql_help.c:2134 sql_help.c:2139 +#: sql_help.c:3108 sql_help.c:3115 sql_help.c:3129 sql_help.c:3135 +#: sql_help.c:3440 sql_help.c:3447 sql_help.c:3461 sql_help.c:3467 msgid "schema_name" msgstr "nombre_de_esquema" @@ -3468,32 +3462,32 @@ msgstr "donde grant_o_revoke_abreviado es uno de:" #: sql_help.c:189 sql_help.c:190 sql_help.c:191 sql_help.c:192 sql_help.c:193 #: sql_help.c:194 sql_help.c:195 sql_help.c:196 sql_help.c:544 sql_help.c:572 -#: sql_help.c:637 sql_help.c:777 sql_help.c:834 sql_help.c:1000 -#: sql_help.c:1258 sql_help.c:1922 sql_help.c:1923 sql_help.c:1924 -#: sql_help.c:1925 sql_help.c:1926 sql_help.c:2052 sql_help.c:2087 -#: sql_help.c:2088 sql_help.c:2089 sql_help.c:2090 sql_help.c:2091 -#: sql_help.c:2535 sql_help.c:2536 sql_help.c:2537 sql_help.c:2538 -#: sql_help.c:2539 sql_help.c:3138 sql_help.c:3139 sql_help.c:3140 -#: sql_help.c:3437 sql_help.c:3441 sql_help.c:3444 sql_help.c:3446 -#: sql_help.c:3448 sql_help.c:3450 sql_help.c:3452 sql_help.c:3458 -#: sql_help.c:3460 sql_help.c:3462 sql_help.c:3464 sql_help.c:3466 -#: sql_help.c:3468 sql_help.c:3469 sql_help.c:3470 sql_help.c:3753 +#: sql_help.c:637 sql_help.c:777 sql_help.c:834 sql_help.c:1000 sql_help.c:1262 +#: sql_help.c:1926 sql_help.c:1927 sql_help.c:1928 sql_help.c:1929 +#: sql_help.c:1930 sql_help.c:2056 sql_help.c:2091 sql_help.c:2092 +#: sql_help.c:2093 sql_help.c:2094 sql_help.c:2095 sql_help.c:2539 +#: sql_help.c:2540 sql_help.c:2541 sql_help.c:2542 sql_help.c:2543 +#: sql_help.c:3142 sql_help.c:3143 sql_help.c:3144 sql_help.c:3441 +#: sql_help.c:3445 sql_help.c:3448 sql_help.c:3450 sql_help.c:3452 +#: sql_help.c:3454 sql_help.c:3456 sql_help.c:3462 sql_help.c:3464 +#: sql_help.c:3466 sql_help.c:3468 sql_help.c:3470 sql_help.c:3472 +#: sql_help.c:3473 sql_help.c:3474 sql_help.c:3757 msgid "role_name" msgstr "nombre_de_rol" #: sql_help.c:222 sql_help.c:436 sql_help.c:1011 sql_help.c:1013 -#: sql_help.c:1287 sql_help.c:1756 sql_help.c:1760 sql_help.c:1846 -#: sql_help.c:1850 sql_help.c:1943 sql_help.c:2258 sql_help.c:2268 -#: sql_help.c:2290 sql_help.c:3187 sql_help.c:3202 sql_help.c:3204 -#: sql_help.c:3618 sql_help.c:3619 sql_help.c:3628 sql_help.c:3669 -#: sql_help.c:3670 sql_help.c:3671 sql_help.c:3672 sql_help.c:3673 -#: sql_help.c:3674 sql_help.c:3707 sql_help.c:3708 sql_help.c:3713 -#: sql_help.c:3718 sql_help.c:3857 sql_help.c:3858 sql_help.c:3867 -#: sql_help.c:3908 sql_help.c:3909 sql_help.c:3910 sql_help.c:3911 -#: sql_help.c:3912 sql_help.c:3913 sql_help.c:3960 sql_help.c:3962 -#: sql_help.c:3995 sql_help.c:4051 sql_help.c:4052 sql_help.c:4061 -#: sql_help.c:4102 sql_help.c:4103 sql_help.c:4104 sql_help.c:4105 -#: sql_help.c:4106 sql_help.c:4107 +#: sql_help.c:1291 sql_help.c:1760 sql_help.c:1764 sql_help.c:1850 +#: sql_help.c:1854 sql_help.c:1947 sql_help.c:2262 sql_help.c:2272 +#: sql_help.c:2294 sql_help.c:3191 sql_help.c:3206 sql_help.c:3208 +#: sql_help.c:3622 sql_help.c:3623 sql_help.c:3632 sql_help.c:3673 +#: sql_help.c:3674 sql_help.c:3675 sql_help.c:3676 sql_help.c:3677 +#: sql_help.c:3678 sql_help.c:3711 sql_help.c:3712 sql_help.c:3717 +#: sql_help.c:3722 sql_help.c:3861 sql_help.c:3862 sql_help.c:3871 +#: sql_help.c:3912 sql_help.c:3913 sql_help.c:3914 sql_help.c:3915 +#: sql_help.c:3916 sql_help.c:3917 sql_help.c:3964 sql_help.c:3966 +#: sql_help.c:3999 sql_help.c:4055 sql_help.c:4056 sql_help.c:4065 +#: sql_help.c:4106 sql_help.c:4107 sql_help.c:4108 sql_help.c:4109 +#: sql_help.c:4110 sql_help.c:4111 msgid "expression" msgstr "expresión" @@ -3503,9 +3497,9 @@ msgstr "restricción_de_dominio" #: sql_help.c:227 sql_help.c:229 sql_help.c:232 sql_help.c:451 sql_help.c:452 #: sql_help.c:993 sql_help.c:1026 sql_help.c:1027 sql_help.c:1028 -#: sql_help.c:1048 sql_help.c:1411 sql_help.c:1413 sql_help.c:1759 -#: sql_help.c:1845 sql_help.c:1849 sql_help.c:2257 sql_help.c:2267 -#: sql_help.c:3199 +#: sql_help.c:1048 sql_help.c:1415 sql_help.c:1417 sql_help.c:1763 +#: sql_help.c:1849 sql_help.c:1853 sql_help.c:2261 sql_help.c:2271 +#: sql_help.c:3203 msgid "constraint_name" msgstr "nombre_restricción" @@ -3529,71 +3523,71 @@ msgstr "dondo objeto_miembro es:" #: sql_help.c:318 sql_help.c:319 sql_help.c:324 sql_help.c:328 sql_help.c:330 #: sql_help.c:332 sql_help.c:333 sql_help.c:334 sql_help.c:335 sql_help.c:336 #: sql_help.c:337 sql_help.c:338 sql_help.c:339 sql_help.c:340 sql_help.c:343 -#: sql_help.c:344 sql_help.c:1403 sql_help.c:1408 sql_help.c:1415 -#: sql_help.c:1416 sql_help.c:1417 sql_help.c:1418 sql_help.c:1419 -#: sql_help.c:1420 sql_help.c:1421 sql_help.c:1426 sql_help.c:1428 -#: sql_help.c:1432 sql_help.c:1434 sql_help.c:1438 sql_help.c:1439 -#: sql_help.c:1442 sql_help.c:1443 sql_help.c:1444 sql_help.c:1445 +#: sql_help.c:344 sql_help.c:1407 sql_help.c:1412 sql_help.c:1419 +#: sql_help.c:1420 sql_help.c:1421 sql_help.c:1422 sql_help.c:1423 +#: sql_help.c:1424 sql_help.c:1425 sql_help.c:1430 sql_help.c:1432 +#: sql_help.c:1436 sql_help.c:1438 sql_help.c:1442 sql_help.c:1443 #: sql_help.c:1446 sql_help.c:1447 sql_help.c:1448 sql_help.c:1449 -#: sql_help.c:1450 sql_help.c:1455 sql_help.c:1456 sql_help.c:3535 -#: sql_help.c:3540 sql_help.c:3541 sql_help.c:3542 sql_help.c:3543 -#: sql_help.c:3549 sql_help.c:3550 sql_help.c:3551 sql_help.c:3552 +#: sql_help.c:1450 sql_help.c:1451 sql_help.c:1452 sql_help.c:1453 +#: sql_help.c:1454 sql_help.c:1459 sql_help.c:1460 sql_help.c:3539 +#: sql_help.c:3544 sql_help.c:3545 sql_help.c:3546 sql_help.c:3547 #: sql_help.c:3553 sql_help.c:3554 sql_help.c:3555 sql_help.c:3556 +#: sql_help.c:3557 sql_help.c:3558 sql_help.c:3559 sql_help.c:3560 msgid "object_name" msgstr "nombre_de_objeto" -#: sql_help.c:310 sql_help.c:1404 sql_help.c:3538 +#: sql_help.c:310 sql_help.c:1408 sql_help.c:3542 msgid "aggregate_name" msgstr "nombre_función_agregación" -#: sql_help.c:312 sql_help.c:1406 sql_help.c:1674 sql_help.c:1678 -#: sql_help.c:1680 sql_help.c:2662 +#: sql_help.c:312 sql_help.c:1410 sql_help.c:1678 sql_help.c:1682 +#: sql_help.c:1684 sql_help.c:2666 msgid "source_type" msgstr "tipo_fuente" -#: sql_help.c:313 sql_help.c:1407 sql_help.c:1675 sql_help.c:1679 -#: sql_help.c:1681 sql_help.c:2663 +#: sql_help.c:313 sql_help.c:1411 sql_help.c:1679 sql_help.c:1683 +#: sql_help.c:1685 sql_help.c:2667 msgid "target_type" msgstr "tipo_destino" -#: sql_help.c:320 sql_help.c:741 sql_help.c:1422 sql_help.c:1676 -#: sql_help.c:1711 sql_help.c:1774 sql_help.c:1996 sql_help.c:2027 -#: sql_help.c:2426 sql_help.c:3121 sql_help.c:3453 sql_help.c:3544 -#: sql_help.c:3647 sql_help.c:3651 sql_help.c:3655 sql_help.c:3658 -#: sql_help.c:3886 sql_help.c:3890 sql_help.c:3894 sql_help.c:3897 -#: sql_help.c:4080 sql_help.c:4084 sql_help.c:4088 sql_help.c:4091 +#: sql_help.c:320 sql_help.c:741 sql_help.c:1426 sql_help.c:1680 +#: sql_help.c:1715 sql_help.c:1778 sql_help.c:2000 sql_help.c:2031 +#: sql_help.c:2430 sql_help.c:3125 sql_help.c:3457 sql_help.c:3548 +#: sql_help.c:3651 sql_help.c:3655 sql_help.c:3659 sql_help.c:3662 +#: sql_help.c:3890 sql_help.c:3894 sql_help.c:3898 sql_help.c:3901 +#: sql_help.c:4084 sql_help.c:4088 sql_help.c:4092 sql_help.c:4095 msgid "function_name" msgstr "nombre_de_función" -#: sql_help.c:325 sql_help.c:734 sql_help.c:1429 sql_help.c:2020 +#: sql_help.c:325 sql_help.c:734 sql_help.c:1433 sql_help.c:2024 msgid "operator_name" msgstr "nombre_operador" -#: sql_help.c:326 sql_help.c:670 sql_help.c:674 sql_help.c:678 sql_help.c:1430 -#: sql_help.c:1997 sql_help.c:2780 +#: sql_help.c:326 sql_help.c:670 sql_help.c:674 sql_help.c:678 sql_help.c:1434 +#: sql_help.c:2001 sql_help.c:2784 msgid "left_type" msgstr "tipo_izq" -#: sql_help.c:327 sql_help.c:671 sql_help.c:675 sql_help.c:679 sql_help.c:1431 -#: sql_help.c:1998 sql_help.c:2781 +#: sql_help.c:327 sql_help.c:671 sql_help.c:675 sql_help.c:679 sql_help.c:1435 +#: sql_help.c:2002 sql_help.c:2785 msgid "right_type" msgstr "tipo_der" #: sql_help.c:329 sql_help.c:331 sql_help.c:697 sql_help.c:700 sql_help.c:703 #: sql_help.c:732 sql_help.c:744 sql_help.c:752 sql_help.c:755 sql_help.c:758 -#: sql_help.c:1433 sql_help.c:1435 sql_help.c:2017 sql_help.c:2038 -#: sql_help.c:2273 sql_help.c:2790 sql_help.c:2799 +#: sql_help.c:1437 sql_help.c:1439 sql_help.c:2021 sql_help.c:2042 +#: sql_help.c:2277 sql_help.c:2794 sql_help.c:2803 msgid "index_method" msgstr "método_de_índice" -#: sql_help.c:341 sql_help.c:1044 sql_help.c:1451 sql_help.c:1884 -#: sql_help.c:2249 sql_help.c:2395 sql_help.c:2913 sql_help.c:3135 -#: sql_help.c:3467 +#: sql_help.c:341 sql_help.c:1044 sql_help.c:1455 sql_help.c:1888 +#: sql_help.c:2253 sql_help.c:2399 sql_help.c:2917 sql_help.c:3139 +#: sql_help.c:3471 msgid "type_name" msgstr "nombre_de_tipo" -#: sql_help.c:342 sql_help.c:1452 sql_help.c:1883 sql_help.c:2396 -#: sql_help.c:2620 sql_help.c:2914 sql_help.c:3127 sql_help.c:3459 +#: sql_help.c:342 sql_help.c:1456 sql_help.c:1887 sql_help.c:2400 +#: sql_help.c:2624 sql_help.c:2918 sql_help.c:3131 sql_help.c:3463 msgid "lang_name" msgstr "nombre_lenguaje" @@ -3601,16 +3595,16 @@ msgstr "nombre_lenguaje" msgid "and aggregate_signature is:" msgstr "y signatura_func_agregación es:" -#: sql_help.c:368 sql_help.c:1546 sql_help.c:1801 +#: sql_help.c:368 sql_help.c:1550 sql_help.c:1805 msgid "handler_function" msgstr "función_manejadora" -#: sql_help.c:369 sql_help.c:1802 +#: sql_help.c:369 sql_help.c:1806 msgid "validator_function" msgstr "función_validadora" #: sql_help.c:418 sql_help.c:495 sql_help.c:626 sql_help.c:988 sql_help.c:1187 -#: sql_help.c:2264 sql_help.c:2265 sql_help.c:2281 sql_help.c:2282 +#: sql_help.c:2268 sql_help.c:2269 sql_help.c:2285 sql_help.c:2286 msgid "action" msgstr "acción" @@ -3620,17 +3614,17 @@ msgstr "acción" #: sql_help.c:645 sql_help.c:647 sql_help.c:880 sql_help.c:990 sql_help.c:1003 #: sql_help.c:1007 sql_help.c:1008 sql_help.c:1012 sql_help.c:1014 #: sql_help.c:1015 sql_help.c:1016 sql_help.c:1018 sql_help.c:1021 -#: sql_help.c:1023 sql_help.c:1286 sql_help.c:1289 sql_help.c:1309 -#: sql_help.c:1410 sql_help.c:1512 sql_help.c:1517 sql_help.c:1531 -#: sql_help.c:1532 sql_help.c:1533 sql_help.c:1833 sql_help.c:1881 -#: sql_help.c:1942 sql_help.c:1977 sql_help.c:2157 sql_help.c:2237 -#: sql_help.c:2250 sql_help.c:2269 sql_help.c:2271 sql_help.c:2278 -#: sql_help.c:2289 sql_help.c:2306 sql_help.c:2429 sql_help.c:2565 -#: sql_help.c:3106 sql_help.c:3107 sql_help.c:3186 sql_help.c:3201 -#: sql_help.c:3203 sql_help.c:3205 sql_help.c:3438 sql_help.c:3439 -#: sql_help.c:3537 sql_help.c:3678 sql_help.c:3917 sql_help.c:3959 -#: sql_help.c:3961 sql_help.c:3963 sql_help.c:3980 sql_help.c:3983 -#: sql_help.c:4111 +#: sql_help.c:1023 sql_help.c:1290 sql_help.c:1293 sql_help.c:1313 +#: sql_help.c:1414 sql_help.c:1516 sql_help.c:1521 sql_help.c:1535 +#: sql_help.c:1536 sql_help.c:1537 sql_help.c:1837 sql_help.c:1885 +#: sql_help.c:1946 sql_help.c:1981 sql_help.c:2161 sql_help.c:2241 +#: sql_help.c:2254 sql_help.c:2273 sql_help.c:2275 sql_help.c:2282 +#: sql_help.c:2293 sql_help.c:2310 sql_help.c:2433 sql_help.c:2569 +#: sql_help.c:3110 sql_help.c:3111 sql_help.c:3190 sql_help.c:3205 +#: sql_help.c:3207 sql_help.c:3209 sql_help.c:3442 sql_help.c:3443 +#: sql_help.c:3541 sql_help.c:3682 sql_help.c:3921 sql_help.c:3963 +#: sql_help.c:3965 sql_help.c:3967 sql_help.c:3984 sql_help.c:3987 +#: sql_help.c:4115 msgid "column_name" msgstr "nombre_de_columna" @@ -3638,26 +3632,25 @@ msgstr "nombre_de_columna" msgid "new_column_name" msgstr "nuevo_nombre_de_columna" -#: sql_help.c:426 sql_help.c:516 sql_help.c:639 sql_help.c:1002 -#: sql_help.c:1200 +#: sql_help.c:426 sql_help.c:516 sql_help.c:639 sql_help.c:1002 sql_help.c:1200 msgid "where action is one of:" msgstr "donde acción es una de:" #: sql_help.c:428 sql_help.c:433 sql_help.c:1004 sql_help.c:1009 -#: sql_help.c:1202 sql_help.c:1206 sql_help.c:1754 sql_help.c:1834 -#: sql_help.c:2016 sql_help.c:2238 sql_help.c:2474 sql_help.c:3288 +#: sql_help.c:1202 sql_help.c:1206 sql_help.c:1758 sql_help.c:1838 +#: sql_help.c:2020 sql_help.c:2242 sql_help.c:2478 sql_help.c:3292 msgid "data_type" msgstr "tipo_de_dato" #: sql_help.c:429 sql_help.c:434 sql_help.c:1005 sql_help.c:1010 -#: sql_help.c:1203 sql_help.c:1207 sql_help.c:1755 sql_help.c:1837 -#: sql_help.c:1944 sql_help.c:2239 sql_help.c:2475 sql_help.c:2481 -#: sql_help.c:3196 +#: sql_help.c:1203 sql_help.c:1207 sql_help.c:1759 sql_help.c:1841 +#: sql_help.c:1948 sql_help.c:2243 sql_help.c:2479 sql_help.c:2485 +#: sql_help.c:3200 msgid "collation" msgstr "ordenamiento" -#: sql_help.c:430 sql_help.c:1006 sql_help.c:1838 sql_help.c:2240 -#: sql_help.c:2251 +#: sql_help.c:430 sql_help.c:1006 sql_help.c:1842 sql_help.c:2244 +#: sql_help.c:2255 msgid "column_constraint" msgstr "restricción_de_columna" @@ -3670,51 +3663,50 @@ msgstr "entero" msgid "attribute_option" msgstr "opción_de_atributo" -#: sql_help.c:450 sql_help.c:1024 sql_help.c:1839 sql_help.c:2241 -#: sql_help.c:2252 +#: sql_help.c:450 sql_help.c:1024 sql_help.c:1843 sql_help.c:2245 +#: sql_help.c:2256 msgid "table_constraint" msgstr "restricción_de_tabla" #: sql_help.c:453 sql_help.c:454 sql_help.c:455 sql_help.c:456 sql_help.c:1029 -#: sql_help.c:1030 sql_help.c:1031 sql_help.c:1032 sql_help.c:1453 +#: sql_help.c:1030 sql_help.c:1031 sql_help.c:1032 sql_help.c:1457 msgid "trigger_name" msgstr "nombre_disparador" #: sql_help.c:457 sql_help.c:458 sql_help.c:1042 sql_help.c:1043 -#: sql_help.c:1840 sql_help.c:2244 +#: sql_help.c:1844 sql_help.c:2248 msgid "parent_table" msgstr "tabla_padre" -#: sql_help.c:515 sql_help.c:565 sql_help.c:628 sql_help.c:1167 -#: sql_help.c:1786 +#: sql_help.c:515 sql_help.c:565 sql_help.c:628 sql_help.c:1167 sql_help.c:1790 msgid "extension_name" msgstr "nombre_de_extensión" -#: sql_help.c:517 sql_help.c:1885 +#: sql_help.c:517 sql_help.c:1889 msgid "execution_cost" msgstr "costo_de_ejecución" -#: sql_help.c:518 sql_help.c:1886 +#: sql_help.c:518 sql_help.c:1890 msgid "result_rows" msgstr "núm_de_filas" #: sql_help.c:539 sql_help.c:541 sql_help.c:813 sql_help.c:821 sql_help.c:825 #: sql_help.c:828 sql_help.c:831 sql_help.c:1241 sql_help.c:1249 -#: sql_help.c:1252 sql_help.c:1254 sql_help.c:1256 sql_help.c:2131 -#: sql_help.c:2133 sql_help.c:2136 sql_help.c:2137 sql_help.c:3105 -#: sql_help.c:3109 sql_help.c:3112 sql_help.c:3114 sql_help.c:3116 -#: sql_help.c:3118 sql_help.c:3120 sql_help.c:3126 sql_help.c:3128 -#: sql_help.c:3130 sql_help.c:3132 sql_help.c:3134 sql_help.c:3136 +#: sql_help.c:1253 sql_help.c:1256 sql_help.c:1259 sql_help.c:2135 +#: sql_help.c:2137 sql_help.c:2140 sql_help.c:2141 sql_help.c:3109 +#: sql_help.c:3113 sql_help.c:3116 sql_help.c:3118 sql_help.c:3120 +#: sql_help.c:3122 sql_help.c:3124 sql_help.c:3130 sql_help.c:3132 +#: sql_help.c:3134 sql_help.c:3136 sql_help.c:3138 sql_help.c:3140 msgid "role_specification" msgstr "especificación_de_rol" -#: sql_help.c:540 sql_help.c:542 sql_help.c:1268 sql_help.c:1729 -#: sql_help.c:2139 sql_help.c:2550 sql_help.c:2947 sql_help.c:3763 +#: sql_help.c:540 sql_help.c:542 sql_help.c:1272 sql_help.c:1733 +#: sql_help.c:2143 sql_help.c:2554 sql_help.c:2951 sql_help.c:3767 msgid "user_name" msgstr "nombre_de_usuario" -#: sql_help.c:543 sql_help.c:833 sql_help.c:1257 sql_help.c:2138 -#: sql_help.c:3137 +#: sql_help.c:543 sql_help.c:833 sql_help.c:1261 sql_help.c:2142 +#: sql_help.c:3141 msgid "where role_specification can be:" msgstr "donde especificación_de_rol puede ser:" @@ -3722,110 +3714,111 @@ msgstr "donde especificación_de_rol puede ser:" msgid "group_name" msgstr "nombre_de_grupo" -#: sql_help.c:563 sql_help.c:1734 sql_help.c:1948 sql_help.c:1980 -#: sql_help.c:2247 sql_help.c:2255 sql_help.c:2287 sql_help.c:2309 -#: sql_help.c:2321 sql_help.c:3133 sql_help.c:3465 +#: sql_help.c:563 sql_help.c:1738 sql_help.c:1952 sql_help.c:1984 +#: sql_help.c:2251 sql_help.c:2259 sql_help.c:2291 sql_help.c:2313 +#: sql_help.c:2325 sql_help.c:3137 sql_help.c:3469 msgid "tablespace_name" msgstr "nombre_de_tablespace" #: sql_help.c:567 sql_help.c:570 sql_help.c:649 sql_help.c:651 sql_help.c:1039 -#: sql_help.c:1041 sql_help.c:1946 sql_help.c:1978 sql_help.c:2245 -#: sql_help.c:2253 sql_help.c:2285 sql_help.c:2307 +#: sql_help.c:1041 sql_help.c:1950 sql_help.c:1982 sql_help.c:2249 +#: sql_help.c:2257 sql_help.c:2289 sql_help.c:2311 msgid "storage_parameter" msgstr "parámetro_de_almacenamiento" -#: sql_help.c:593 sql_help.c:1427 sql_help.c:3548 +#: sql_help.c:593 sql_help.c:1431 sql_help.c:3552 msgid "large_object_oid" msgstr "oid_de_objeto_grande" #: sql_help.c:648 sql_help.c:1037 sql_help.c:1046 sql_help.c:1049 -#: sql_help.c:1349 +#: sql_help.c:1353 msgid "index_name" msgstr "nombre_índice" -#: sql_help.c:680 sql_help.c:2001 +#: sql_help.c:680 sql_help.c:2005 msgid "res_proc" msgstr "proc_res" -#: sql_help.c:681 sql_help.c:2002 +#: sql_help.c:681 sql_help.c:2006 msgid "join_proc" msgstr "proc_join" -#: sql_help.c:733 sql_help.c:745 sql_help.c:2019 +#: sql_help.c:733 sql_help.c:745 sql_help.c:2023 msgid "strategy_number" msgstr "número_de_estrategia" #: sql_help.c:735 sql_help.c:736 sql_help.c:739 sql_help.c:740 sql_help.c:746 -#: sql_help.c:747 sql_help.c:749 sql_help.c:750 sql_help.c:2021 -#: sql_help.c:2022 sql_help.c:2025 sql_help.c:2026 +#: sql_help.c:747 sql_help.c:749 sql_help.c:750 sql_help.c:2025 sql_help.c:2026 +#: sql_help.c:2029 sql_help.c:2030 msgid "op_type" msgstr "tipo_op" -#: sql_help.c:737 sql_help.c:2023 +#: sql_help.c:737 sql_help.c:2027 msgid "sort_family_name" msgstr "nombre_familia_ordenamiento" -#: sql_help.c:738 sql_help.c:748 sql_help.c:2024 +#: sql_help.c:738 sql_help.c:748 sql_help.c:2028 msgid "support_number" msgstr "número_de_soporte" -#: sql_help.c:742 sql_help.c:1677 sql_help.c:2028 sql_help.c:2398 -#: sql_help.c:2400 +#: sql_help.c:742 sql_help.c:1681 sql_help.c:2032 sql_help.c:2402 +#: sql_help.c:2404 msgid "argument_type" msgstr "tipo_argumento" #: sql_help.c:773 sql_help.c:776 sql_help.c:843 sql_help.c:879 sql_help.c:1163 -#: sql_help.c:1166 sql_help.c:1308 sql_help.c:1348 sql_help.c:1412 -#: sql_help.c:1437 sql_help.c:1441 sql_help.c:1454 sql_help.c:1511 -#: sql_help.c:1516 sql_help.c:1832 sql_help.c:1940 sql_help.c:1976 -#: sql_help.c:2051 sql_help.c:2108 sql_help.c:2156 sql_help.c:2236 -#: sql_help.c:2248 sql_help.c:2305 sql_help.c:2423 sql_help.c:2599 -#: sql_help.c:2816 sql_help.c:2833 sql_help.c:2923 sql_help.c:3103 -#: sql_help.c:3108 sql_help.c:3153 sql_help.c:3184 sql_help.c:3435 -#: sql_help.c:3440 sql_help.c:3536 sql_help.c:3633 sql_help.c:3635 -#: sql_help.c:3684 sql_help.c:3723 sql_help.c:3872 sql_help.c:3874 -#: sql_help.c:3923 sql_help.c:3957 sql_help.c:3979 sql_help.c:3981 -#: sql_help.c:3982 sql_help.c:4066 sql_help.c:4068 sql_help.c:4117 +#: sql_help.c:1166 sql_help.c:1312 sql_help.c:1352 sql_help.c:1416 +#: sql_help.c:1441 sql_help.c:1445 sql_help.c:1458 sql_help.c:1515 +#: sql_help.c:1520 sql_help.c:1836 sql_help.c:1944 sql_help.c:1980 +#: sql_help.c:2055 sql_help.c:2112 sql_help.c:2160 sql_help.c:2240 +#: sql_help.c:2252 sql_help.c:2309 sql_help.c:2427 sql_help.c:2603 +#: sql_help.c:2820 sql_help.c:2837 sql_help.c:2927 sql_help.c:3107 +#: sql_help.c:3112 sql_help.c:3157 sql_help.c:3188 sql_help.c:3439 +#: sql_help.c:3444 sql_help.c:3540 sql_help.c:3637 sql_help.c:3639 +#: sql_help.c:3688 sql_help.c:3727 sql_help.c:3876 sql_help.c:3878 +#: sql_help.c:3927 sql_help.c:3961 sql_help.c:3983 sql_help.c:3985 +#: sql_help.c:3986 sql_help.c:4070 sql_help.c:4072 sql_help.c:4121 msgid "table_name" msgstr "nombre_de_tabla" -#: sql_help.c:778 sql_help.c:2053 +#: sql_help.c:778 sql_help.c:2057 msgid "using_expression" msgstr "expresión_using" -#: sql_help.c:779 sql_help.c:2054 +#: sql_help.c:779 sql_help.c:2058 msgid "check_expression" msgstr "expresión_check" -#: sql_help.c:817 sql_help.c:1245 sql_help.c:1920 sql_help.c:2085 -#: sql_help.c:2533 +#: sql_help.c:817 sql_help.c:1245 sql_help.c:1924 sql_help.c:2089 +#: sql_help.c:2537 msgid "password" msgstr "contraseña" -#: sql_help.c:818 sql_help.c:1246 sql_help.c:1921 sql_help.c:2086 -#: sql_help.c:2534 +#: sql_help.c:818 sql_help.c:1246 sql_help.c:1925 sql_help.c:2090 +#: sql_help.c:2538 msgid "timestamp" msgstr "fecha_hora" -#: sql_help.c:822 sql_help.c:826 sql_help.c:829 sql_help.c:832 sql_help.c:3113 -#: sql_help.c:3445 +#: sql_help.c:822 sql_help.c:826 sql_help.c:829 sql_help.c:832 sql_help.c:1250 +#: sql_help.c:1254 sql_help.c:1257 sql_help.c:1260 sql_help.c:3117 +#: sql_help.c:3449 msgid "database_name" msgstr "nombre_de_base_de_datos" -#: sql_help.c:873 sql_help.c:2151 +#: sql_help.c:873 sql_help.c:2155 msgid "increment" msgstr "incremento" -#: sql_help.c:874 sql_help.c:2152 +#: sql_help.c:874 sql_help.c:2156 msgid "minvalue" msgstr "valormin" -#: sql_help.c:875 sql_help.c:2153 +#: sql_help.c:875 sql_help.c:2157 msgid "maxvalue" msgstr "valormax" -#: sql_help.c:876 sql_help.c:2154 sql_help.c:3631 sql_help.c:3721 -#: sql_help.c:3870 sql_help.c:3999 sql_help.c:4064 +#: sql_help.c:876 sql_help.c:2158 sql_help.c:3635 sql_help.c:3725 +#: sql_help.c:3874 sql_help.c:4003 sql_help.c:4068 msgid "start" msgstr "inicio" @@ -3833,7 +3826,7 @@ msgstr "inicio" msgid "restart" msgstr "reinicio" -#: sql_help.c:878 sql_help.c:2155 +#: sql_help.c:878 sql_help.c:2159 msgid "cache" msgstr "cache" @@ -3849,7 +3842,7 @@ msgstr "nombre_regla_de_reescritura" msgid "and table_constraint_using_index is:" msgstr "y restricción_de_tabla_con_índice es:" -#: sql_help.c:1065 sql_help.c:1068 sql_help.c:2324 +#: sql_help.c:1065 sql_help.c:1068 sql_help.c:2328 msgid "tablespace_option" msgstr "opción_de_tablespace" @@ -3870,7 +3863,7 @@ msgid "new_dictionary" msgstr "diccionario_nuevo" #: sql_help.c:1191 sql_help.c:1201 sql_help.c:1204 sql_help.c:1205 -#: sql_help.c:2473 +#: sql_help.c:2477 msgid "attribute_name" msgstr "nombre_atributo" @@ -3886,1419 +3879,1419 @@ msgstr "nuevo_valor_enum" msgid "existing_enum_value" msgstr "valor_enum_existente" -#: sql_help.c:1269 sql_help.c:1841 sql_help.c:2167 sql_help.c:2551 -#: sql_help.c:2948 sql_help.c:3119 sql_help.c:3154 sql_help.c:3451 +#: sql_help.c:1273 sql_help.c:1845 sql_help.c:2171 sql_help.c:2555 +#: sql_help.c:2952 sql_help.c:3123 sql_help.c:3158 sql_help.c:3455 msgid "server_name" msgstr "nombre_de_servidor" -#: sql_help.c:1297 sql_help.c:1300 sql_help.c:2566 +#: sql_help.c:1301 sql_help.c:1304 sql_help.c:2570 msgid "view_option_name" msgstr "nombre_opción_de_vista" -#: sql_help.c:1298 sql_help.c:2567 +#: sql_help.c:1302 sql_help.c:2571 msgid "view_option_value" msgstr "valor_opción_de_vista" -#: sql_help.c:1323 sql_help.c:3779 sql_help.c:3781 sql_help.c:3805 +#: sql_help.c:1327 sql_help.c:3783 sql_help.c:3785 sql_help.c:3809 msgid "transaction_mode" msgstr "modo_de_transacción" -#: sql_help.c:1324 sql_help.c:3782 sql_help.c:3806 +#: sql_help.c:1328 sql_help.c:3786 sql_help.c:3810 msgid "where transaction_mode is one of:" msgstr "donde modo_de_transacción es uno de:" -#: sql_help.c:1409 +#: sql_help.c:1413 msgid "relation_name" msgstr "nombre_relación" -#: sql_help.c:1414 sql_help.c:3115 sql_help.c:3447 +#: sql_help.c:1418 sql_help.c:3119 sql_help.c:3451 msgid "domain_name" msgstr "nombre_de_dominio" -#: sql_help.c:1436 +#: sql_help.c:1440 msgid "policy_name" msgstr "nombre_de_política" -#: sql_help.c:1440 +#: sql_help.c:1444 msgid "rule_name" msgstr "nombre_regla" -#: sql_help.c:1457 +#: sql_help.c:1461 msgid "text" msgstr "texto" -#: sql_help.c:1482 sql_help.c:3297 sql_help.c:3485 +#: sql_help.c:1486 sql_help.c:3301 sql_help.c:3489 msgid "transaction_id" msgstr "id_de_transacción" -#: sql_help.c:1513 sql_help.c:1519 sql_help.c:3223 +#: sql_help.c:1517 sql_help.c:1523 sql_help.c:3227 msgid "filename" msgstr "nombre_de_archivo" -#: sql_help.c:1514 sql_help.c:1520 sql_help.c:2110 sql_help.c:2111 -#: sql_help.c:2112 +#: sql_help.c:1518 sql_help.c:1524 sql_help.c:2114 sql_help.c:2115 +#: sql_help.c:2116 msgid "command" msgstr "orden" -#: sql_help.c:1518 sql_help.c:1981 sql_help.c:2310 sql_help.c:2568 -#: sql_help.c:2586 sql_help.c:3188 +#: sql_help.c:1522 sql_help.c:1985 sql_help.c:2314 sql_help.c:2572 +#: sql_help.c:2590 sql_help.c:3192 msgid "query" msgstr "consulta" -#: sql_help.c:1522 sql_help.c:2993 +#: sql_help.c:1526 sql_help.c:2997 msgid "where option can be one of:" msgstr "donde opción puede ser una de:" -#: sql_help.c:1523 +#: sql_help.c:1527 msgid "format_name" msgstr "nombre_de_formato" -#: sql_help.c:1524 sql_help.c:1525 sql_help.c:1528 sql_help.c:2994 -#: sql_help.c:2995 sql_help.c:2996 sql_help.c:2997 sql_help.c:2998 +#: sql_help.c:1528 sql_help.c:1529 sql_help.c:1532 sql_help.c:2998 +#: sql_help.c:2999 sql_help.c:3000 sql_help.c:3001 sql_help.c:3002 msgid "boolean" msgstr "booleano" -#: sql_help.c:1526 +#: sql_help.c:1530 msgid "delimiter_character" msgstr "carácter_delimitador" -#: sql_help.c:1527 +#: sql_help.c:1531 msgid "null_string" msgstr "cadena_null" -#: sql_help.c:1529 +#: sql_help.c:1533 msgid "quote_character" msgstr "carácter_de_comilla" -#: sql_help.c:1530 +#: sql_help.c:1534 msgid "escape_character" msgstr "carácter_de_escape" -#: sql_help.c:1534 +#: sql_help.c:1538 msgid "encoding_name" msgstr "nombre_codificación" -#: sql_help.c:1545 +#: sql_help.c:1549 msgid "access_method_type" msgstr "tipo_de_método_de_acceso" -#: sql_help.c:1611 sql_help.c:1630 sql_help.c:1633 +#: sql_help.c:1615 sql_help.c:1634 sql_help.c:1637 msgid "arg_data_type" msgstr "tipo_de_dato_arg" -#: sql_help.c:1612 sql_help.c:1634 sql_help.c:1642 +#: sql_help.c:1616 sql_help.c:1638 sql_help.c:1646 msgid "sfunc" msgstr "func_transición" -#: sql_help.c:1613 sql_help.c:1635 sql_help.c:1643 +#: sql_help.c:1617 sql_help.c:1639 sql_help.c:1647 msgid "state_data_type" msgstr "tipo_de_dato_de_estado" -#: sql_help.c:1614 sql_help.c:1636 sql_help.c:1644 +#: sql_help.c:1618 sql_help.c:1640 sql_help.c:1648 msgid "state_data_size" msgstr "tamaño_de_dato_de_estado" -#: sql_help.c:1615 sql_help.c:1637 sql_help.c:1645 +#: sql_help.c:1619 sql_help.c:1641 sql_help.c:1649 msgid "ffunc" msgstr "func_final" -#: sql_help.c:1616 sql_help.c:1646 +#: sql_help.c:1620 sql_help.c:1650 msgid "combinefunc" msgstr "func_combinación" -#: sql_help.c:1617 sql_help.c:1647 +#: sql_help.c:1621 sql_help.c:1651 msgid "serialfunc" msgstr "func_serial" -#: sql_help.c:1618 sql_help.c:1648 +#: sql_help.c:1622 sql_help.c:1652 msgid "deserialfunc" msgstr "func_deserial" -#: sql_help.c:1619 sql_help.c:1638 sql_help.c:1649 +#: sql_help.c:1623 sql_help.c:1642 sql_help.c:1653 msgid "initial_condition" msgstr "condición_inicial" -#: sql_help.c:1620 sql_help.c:1650 +#: sql_help.c:1624 sql_help.c:1654 msgid "msfunc" msgstr "func_transición_m" -#: sql_help.c:1621 sql_help.c:1651 +#: sql_help.c:1625 sql_help.c:1655 msgid "minvfunc" msgstr "func_inv_m" -#: sql_help.c:1622 sql_help.c:1652 +#: sql_help.c:1626 sql_help.c:1656 msgid "mstate_data_type" msgstr "tipo_de_dato_de_estado_m" -#: sql_help.c:1623 sql_help.c:1653 +#: sql_help.c:1627 sql_help.c:1657 msgid "mstate_data_size" msgstr "tamaño_de_dato_de_estado_m" -#: sql_help.c:1624 sql_help.c:1654 +#: sql_help.c:1628 sql_help.c:1658 msgid "mffunc" msgstr "func_final_m" -#: sql_help.c:1625 sql_help.c:1655 +#: sql_help.c:1629 sql_help.c:1659 msgid "minitial_condition" msgstr "condición_inicial_m" -#: sql_help.c:1626 sql_help.c:1656 +#: sql_help.c:1630 sql_help.c:1660 msgid "sort_operator" msgstr "operador_de_ordenamiento" -#: sql_help.c:1639 +#: sql_help.c:1643 msgid "or the old syntax" msgstr "o la sintaxis antigua" -#: sql_help.c:1641 +#: sql_help.c:1645 msgid "base_type" msgstr "tipo_base" -#: sql_help.c:1695 +#: sql_help.c:1699 msgid "locale" msgstr "configuración regional" -#: sql_help.c:1696 sql_help.c:1732 +#: sql_help.c:1700 sql_help.c:1736 msgid "lc_collate" msgstr "lc_collate" -#: sql_help.c:1697 sql_help.c:1733 +#: sql_help.c:1701 sql_help.c:1737 msgid "lc_ctype" msgstr "lc_ctype" -#: sql_help.c:1699 +#: sql_help.c:1703 msgid "existing_collation" msgstr "ordenamiento_existente" -#: sql_help.c:1709 +#: sql_help.c:1713 msgid "source_encoding" msgstr "codificación_origen" -#: sql_help.c:1710 +#: sql_help.c:1714 msgid "dest_encoding" msgstr "codificación_destino" -#: sql_help.c:1730 sql_help.c:2350 +#: sql_help.c:1734 sql_help.c:2354 msgid "template" msgstr "plantilla" -#: sql_help.c:1731 +#: sql_help.c:1735 msgid "encoding" msgstr "codificación" -#: sql_help.c:1757 +#: sql_help.c:1761 msgid "constraint" msgstr "restricción" -#: sql_help.c:1758 +#: sql_help.c:1762 msgid "where constraint is:" msgstr "donde restricción es:" -#: sql_help.c:1772 sql_help.c:2107 sql_help.c:2422 +#: sql_help.c:1776 sql_help.c:2111 sql_help.c:2426 msgid "event" msgstr "evento" -#: sql_help.c:1773 +#: sql_help.c:1777 msgid "filter_variable" msgstr "variable_de_filtrado" -#: sql_help.c:1788 +#: sql_help.c:1792 msgid "version" msgstr "versión" -#: sql_help.c:1789 +#: sql_help.c:1793 msgid "old_version" msgstr "versión_antigua" -#: sql_help.c:1844 sql_help.c:2256 +#: sql_help.c:1848 sql_help.c:2260 msgid "where column_constraint is:" msgstr "donde restricción_de_columna es:" -#: sql_help.c:1847 sql_help.c:1879 sql_help.c:2259 +#: sql_help.c:1851 sql_help.c:1883 sql_help.c:2263 msgid "default_expr" msgstr "expr_por_omisión" -#: sql_help.c:1848 sql_help.c:2266 +#: sql_help.c:1852 sql_help.c:2270 msgid "and table_constraint is:" msgstr "y restricción_de_tabla es:" -#: sql_help.c:1880 +#: sql_help.c:1884 msgid "rettype" msgstr "tipo_ret" -#: sql_help.c:1882 +#: sql_help.c:1886 msgid "column_type" msgstr "tipo_columna" -#: sql_help.c:1890 +#: sql_help.c:1894 msgid "definition" msgstr "definición" -#: sql_help.c:1891 +#: sql_help.c:1895 msgid "obj_file" msgstr "archivo_obj" -#: sql_help.c:1892 +#: sql_help.c:1896 msgid "link_symbol" msgstr "símbolo_enlace" -#: sql_help.c:1893 +#: sql_help.c:1897 msgid "attribute" msgstr "atributo" -#: sql_help.c:1927 sql_help.c:2092 sql_help.c:2540 +#: sql_help.c:1931 sql_help.c:2096 sql_help.c:2544 msgid "uid" msgstr "uid" -#: sql_help.c:1941 +#: sql_help.c:1945 msgid "method" msgstr "método" -#: sql_help.c:1945 sql_help.c:2291 sql_help.c:3197 +#: sql_help.c:1949 sql_help.c:2295 sql_help.c:3201 msgid "opclass" msgstr "clase_de_ops" -#: sql_help.c:1949 sql_help.c:2277 +#: sql_help.c:1953 sql_help.c:2281 msgid "predicate" msgstr "predicado" -#: sql_help.c:1961 +#: sql_help.c:1965 msgid "call_handler" msgstr "manejador_de_llamada" -#: sql_help.c:1962 +#: sql_help.c:1966 msgid "inline_handler" msgstr "manejador_en_línea" -#: sql_help.c:1963 +#: sql_help.c:1967 msgid "valfunction" msgstr "función_val" -#: sql_help.c:1999 +#: sql_help.c:2003 msgid "com_op" msgstr "op_conm" -#: sql_help.c:2000 +#: sql_help.c:2004 msgid "neg_op" msgstr "op_neg" -#: sql_help.c:2018 +#: sql_help.c:2022 msgid "family_name" msgstr "nombre_familia" -#: sql_help.c:2029 +#: sql_help.c:2033 msgid "storage_type" msgstr "tipo_almacenamiento" -#: sql_help.c:2109 sql_help.c:2425 sql_help.c:2602 sql_help.c:3207 -#: sql_help.c:3622 sql_help.c:3624 sql_help.c:3712 sql_help.c:3714 -#: sql_help.c:3861 sql_help.c:3863 sql_help.c:3966 sql_help.c:4055 -#: sql_help.c:4057 +#: sql_help.c:2113 sql_help.c:2429 sql_help.c:2606 sql_help.c:3211 +#: sql_help.c:3626 sql_help.c:3628 sql_help.c:3716 sql_help.c:3718 +#: sql_help.c:3865 sql_help.c:3867 sql_help.c:3970 sql_help.c:4059 +#: sql_help.c:4061 msgid "condition" msgstr "condición" -#: sql_help.c:2113 sql_help.c:2428 +#: sql_help.c:2117 sql_help.c:2432 msgid "where event can be one of:" msgstr "donde evento puede ser una de:" -#: sql_help.c:2132 sql_help.c:2134 +#: sql_help.c:2136 sql_help.c:2138 msgid "schema_element" msgstr "elemento_de_esquema" -#: sql_help.c:2168 +#: sql_help.c:2172 msgid "server_type" msgstr "tipo_de_servidor" -#: sql_help.c:2169 +#: sql_help.c:2173 msgid "server_version" msgstr "versión_de_servidor" -#: sql_help.c:2170 sql_help.c:3117 sql_help.c:3449 +#: sql_help.c:2174 sql_help.c:3121 sql_help.c:3453 msgid "fdw_name" msgstr "nombre_fdw" -#: sql_help.c:2242 +#: sql_help.c:2246 msgid "source_table" msgstr "tabla_origen" -#: sql_help.c:2243 +#: sql_help.c:2247 msgid "like_option" msgstr "opción_de_like" -#: sql_help.c:2260 sql_help.c:2261 sql_help.c:2270 sql_help.c:2272 -#: sql_help.c:2276 +#: sql_help.c:2264 sql_help.c:2265 sql_help.c:2274 sql_help.c:2276 +#: sql_help.c:2280 msgid "index_parameters" msgstr "parámetros_de_índice" -#: sql_help.c:2262 sql_help.c:2279 +#: sql_help.c:2266 sql_help.c:2283 msgid "reftable" msgstr "tabla_ref" -#: sql_help.c:2263 sql_help.c:2280 +#: sql_help.c:2267 sql_help.c:2284 msgid "refcolumn" msgstr "columna_ref" -#: sql_help.c:2274 +#: sql_help.c:2278 msgid "exclude_element" msgstr "elemento_de_exclusión" -#: sql_help.c:2275 sql_help.c:3629 sql_help.c:3719 sql_help.c:3868 -#: sql_help.c:3997 sql_help.c:4062 +#: sql_help.c:2279 sql_help.c:3633 sql_help.c:3723 sql_help.c:3872 +#: sql_help.c:4001 sql_help.c:4066 msgid "operator" msgstr "operador" -#: sql_help.c:2283 +#: sql_help.c:2287 msgid "and like_option is:" msgstr "y opción_de_like es:" -#: sql_help.c:2284 +#: sql_help.c:2288 msgid "index_parameters in UNIQUE, PRIMARY KEY, and EXCLUDE constraints are:" msgstr "parámetros_de_índice en UNIQUE, PRIMARY KEY y EXCLUDE son:" -#: sql_help.c:2288 +#: sql_help.c:2292 msgid "exclude_element in an EXCLUDE constraint is:" msgstr "elemento_de_exclusión en una restricción EXCLUDE es:" -#: sql_help.c:2323 +#: sql_help.c:2327 msgid "directory" msgstr "directorio" -#: sql_help.c:2337 +#: sql_help.c:2341 msgid "parser_name" msgstr "nombre_de_parser" -#: sql_help.c:2338 +#: sql_help.c:2342 msgid "source_config" msgstr "config_origen" -#: sql_help.c:2367 +#: sql_help.c:2371 msgid "start_function" msgstr "función_inicio" -#: sql_help.c:2368 +#: sql_help.c:2372 msgid "gettoken_function" msgstr "función_gettoken" -#: sql_help.c:2369 +#: sql_help.c:2373 msgid "end_function" msgstr "función_fin" -#: sql_help.c:2370 +#: sql_help.c:2374 msgid "lextypes_function" msgstr "función_lextypes" -#: sql_help.c:2371 +#: sql_help.c:2375 msgid "headline_function" msgstr "función_headline" -#: sql_help.c:2383 +#: sql_help.c:2387 msgid "init_function" msgstr "función_init" -#: sql_help.c:2384 +#: sql_help.c:2388 msgid "lexize_function" msgstr "función_lexize" -#: sql_help.c:2397 +#: sql_help.c:2401 msgid "from_sql_function_name" msgstr "nombre_de_función_from" -#: sql_help.c:2399 +#: sql_help.c:2403 msgid "to_sql_function_name" msgstr "nombre_de_función_to" -#: sql_help.c:2424 +#: sql_help.c:2428 msgid "referenced_table_name" msgstr "nombre_tabla_referenciada" -#: sql_help.c:2427 +#: sql_help.c:2431 msgid "arguments" msgstr "argumentos" -#: sql_help.c:2477 sql_help.c:3557 +#: sql_help.c:2481 sql_help.c:3561 msgid "label" msgstr "etiqueta" -#: sql_help.c:2479 +#: sql_help.c:2483 msgid "subtype" msgstr "subtipo" -#: sql_help.c:2480 +#: sql_help.c:2484 msgid "subtype_operator_class" msgstr "clase_de_operador_del_subtipo" -#: sql_help.c:2482 +#: sql_help.c:2486 msgid "canonical_function" msgstr "función_canónica" -#: sql_help.c:2483 +#: sql_help.c:2487 msgid "subtype_diff_function" msgstr "función_diff_del_subtipo" -#: sql_help.c:2485 +#: sql_help.c:2489 msgid "input_function" msgstr "función_entrada" -#: sql_help.c:2486 +#: sql_help.c:2490 msgid "output_function" msgstr "función_salida" -#: sql_help.c:2487 +#: sql_help.c:2491 msgid "receive_function" msgstr "función_receive" -#: sql_help.c:2488 +#: sql_help.c:2492 msgid "send_function" msgstr "función_send" -#: sql_help.c:2489 +#: sql_help.c:2493 msgid "type_modifier_input_function" msgstr "función_entrada_del_modificador_de_tipo" -#: sql_help.c:2490 +#: sql_help.c:2494 msgid "type_modifier_output_function" msgstr "función_salida_del_modificador_de_tipo" -#: sql_help.c:2491 +#: sql_help.c:2495 msgid "analyze_function" msgstr "función_analyze" -#: sql_help.c:2492 +#: sql_help.c:2496 msgid "internallength" msgstr "largo_interno" -#: sql_help.c:2493 +#: sql_help.c:2497 msgid "alignment" msgstr "alineamiento" -#: sql_help.c:2494 +#: sql_help.c:2498 msgid "storage" msgstr "almacenamiento" -#: sql_help.c:2495 +#: sql_help.c:2499 msgid "like_type" msgstr "como_tipo" -#: sql_help.c:2496 +#: sql_help.c:2500 msgid "category" msgstr "categoría" -#: sql_help.c:2497 +#: sql_help.c:2501 msgid "preferred" msgstr "preferido" -#: sql_help.c:2498 +#: sql_help.c:2502 msgid "default" msgstr "valor_por_omisión" -#: sql_help.c:2499 +#: sql_help.c:2503 msgid "element" msgstr "elemento" -#: sql_help.c:2500 +#: sql_help.c:2504 msgid "delimiter" msgstr "delimitador" -#: sql_help.c:2501 +#: sql_help.c:2505 msgid "collatable" msgstr "ordenable" -#: sql_help.c:2598 sql_help.c:3183 sql_help.c:3617 sql_help.c:3706 -#: sql_help.c:3856 sql_help.c:3956 sql_help.c:4050 +#: sql_help.c:2602 sql_help.c:3187 sql_help.c:3621 sql_help.c:3710 +#: sql_help.c:3860 sql_help.c:3960 sql_help.c:4054 msgid "with_query" msgstr "consulta_with" -#: sql_help.c:2600 sql_help.c:3185 sql_help.c:3636 sql_help.c:3642 -#: sql_help.c:3645 sql_help.c:3649 sql_help.c:3653 sql_help.c:3661 -#: sql_help.c:3875 sql_help.c:3881 sql_help.c:3884 sql_help.c:3888 -#: sql_help.c:3892 sql_help.c:3900 sql_help.c:3958 sql_help.c:4069 -#: sql_help.c:4075 sql_help.c:4078 sql_help.c:4082 sql_help.c:4086 -#: sql_help.c:4094 +#: sql_help.c:2604 sql_help.c:3189 sql_help.c:3640 sql_help.c:3646 +#: sql_help.c:3649 sql_help.c:3653 sql_help.c:3657 sql_help.c:3665 +#: sql_help.c:3879 sql_help.c:3885 sql_help.c:3888 sql_help.c:3892 +#: sql_help.c:3896 sql_help.c:3904 sql_help.c:3962 sql_help.c:4073 +#: sql_help.c:4079 sql_help.c:4082 sql_help.c:4086 sql_help.c:4090 +#: sql_help.c:4098 msgid "alias" msgstr "alias" -#: sql_help.c:2601 +#: sql_help.c:2605 msgid "using_list" msgstr "lista_using" -#: sql_help.c:2603 sql_help.c:3024 sql_help.c:3264 sql_help.c:3967 +#: sql_help.c:2607 sql_help.c:3028 sql_help.c:3268 sql_help.c:3971 msgid "cursor_name" msgstr "nombre_de_cursor" -#: sql_help.c:2604 sql_help.c:3191 sql_help.c:3968 +#: sql_help.c:2608 sql_help.c:3195 sql_help.c:3972 msgid "output_expression" msgstr "expresión_de_salida" -#: sql_help.c:2605 sql_help.c:3192 sql_help.c:3620 sql_help.c:3709 -#: sql_help.c:3859 sql_help.c:3969 sql_help.c:4053 +#: sql_help.c:2609 sql_help.c:3196 sql_help.c:3624 sql_help.c:3713 +#: sql_help.c:3863 sql_help.c:3973 sql_help.c:4057 msgid "output_name" msgstr "nombre_de_salida" -#: sql_help.c:2621 +#: sql_help.c:2625 msgid "code" msgstr "código" -#: sql_help.c:2972 +#: sql_help.c:2976 msgid "parameter" msgstr "parámetro" -#: sql_help.c:2991 sql_help.c:2992 sql_help.c:3289 +#: sql_help.c:2995 sql_help.c:2996 sql_help.c:3293 msgid "statement" msgstr "sentencia" -#: sql_help.c:3023 sql_help.c:3263 +#: sql_help.c:3027 sql_help.c:3267 msgid "direction" msgstr "dirección" -#: sql_help.c:3025 sql_help.c:3265 +#: sql_help.c:3029 sql_help.c:3269 msgid "where direction can be empty or one of:" msgstr "donde dirección puede ser vacío o uno de:" -#: sql_help.c:3026 sql_help.c:3027 sql_help.c:3028 sql_help.c:3029 -#: sql_help.c:3030 sql_help.c:3266 sql_help.c:3267 sql_help.c:3268 -#: sql_help.c:3269 sql_help.c:3270 sql_help.c:3630 sql_help.c:3632 -#: sql_help.c:3720 sql_help.c:3722 sql_help.c:3869 sql_help.c:3871 -#: sql_help.c:3998 sql_help.c:4000 sql_help.c:4063 sql_help.c:4065 +#: sql_help.c:3030 sql_help.c:3031 sql_help.c:3032 sql_help.c:3033 +#: sql_help.c:3034 sql_help.c:3270 sql_help.c:3271 sql_help.c:3272 +#: sql_help.c:3273 sql_help.c:3274 sql_help.c:3634 sql_help.c:3636 +#: sql_help.c:3724 sql_help.c:3726 sql_help.c:3873 sql_help.c:3875 +#: sql_help.c:4002 sql_help.c:4004 sql_help.c:4067 sql_help.c:4069 msgid "count" msgstr "cantidad" -#: sql_help.c:3110 sql_help.c:3442 +#: sql_help.c:3114 sql_help.c:3446 msgid "sequence_name" msgstr "nombre_secuencia" -#: sql_help.c:3123 sql_help.c:3455 +#: sql_help.c:3127 sql_help.c:3459 msgid "arg_name" msgstr "nombre_arg" -#: sql_help.c:3124 sql_help.c:3456 +#: sql_help.c:3128 sql_help.c:3460 msgid "arg_type" msgstr "tipo_arg" -#: sql_help.c:3129 sql_help.c:3461 +#: sql_help.c:3133 sql_help.c:3465 msgid "loid" msgstr "loid" -#: sql_help.c:3152 +#: sql_help.c:3156 msgid "remote_schema" msgstr "schema_remoto" -#: sql_help.c:3155 +#: sql_help.c:3159 msgid "local_schema" msgstr "schema_local" -#: sql_help.c:3189 +#: sql_help.c:3193 msgid "conflict_target" msgstr "destino_de_conflict" -#: sql_help.c:3190 +#: sql_help.c:3194 msgid "conflict_action" msgstr "acción_de_conflict" -#: sql_help.c:3193 +#: sql_help.c:3197 msgid "where conflict_target can be one of:" msgstr "donde destino_de_conflict puede ser uno de:" -#: sql_help.c:3194 +#: sql_help.c:3198 msgid "index_column_name" msgstr "nombre_de_columna_de_índice" -#: sql_help.c:3195 +#: sql_help.c:3199 msgid "index_expression" msgstr "expresión_de_índice" -#: sql_help.c:3198 +#: sql_help.c:3202 msgid "index_predicate" msgstr "predicado_de_índice" -#: sql_help.c:3200 +#: sql_help.c:3204 msgid "and conflict_action is one of:" msgstr "donde acción_de_conflict es una de:" -#: sql_help.c:3206 sql_help.c:3964 +#: sql_help.c:3210 sql_help.c:3968 msgid "sub-SELECT" msgstr "sub-SELECT" -#: sql_help.c:3215 sql_help.c:3278 sql_help.c:3940 +#: sql_help.c:3219 sql_help.c:3282 sql_help.c:3944 msgid "channel" msgstr "canal" -#: sql_help.c:3237 +#: sql_help.c:3241 msgid "lockmode" msgstr "modo_bloqueo" -#: sql_help.c:3238 +#: sql_help.c:3242 msgid "where lockmode is one of:" msgstr "donde modo_bloqueo es uno de:" -#: sql_help.c:3279 +#: sql_help.c:3283 msgid "payload" msgstr "carga" -#: sql_help.c:3306 +#: sql_help.c:3310 msgid "old_role" msgstr "rol_antiguo" -#: sql_help.c:3307 +#: sql_help.c:3311 msgid "new_role" msgstr "rol_nuevo" -#: sql_help.c:3332 sql_help.c:3493 sql_help.c:3501 +#: sql_help.c:3336 sql_help.c:3497 sql_help.c:3505 msgid "savepoint_name" msgstr "nombre_de_savepoint" -#: sql_help.c:3534 +#: sql_help.c:3538 msgid "provider" msgstr "proveedor" -#: sql_help.c:3621 sql_help.c:3663 sql_help.c:3665 sql_help.c:3711 -#: sql_help.c:3860 sql_help.c:3902 sql_help.c:3904 sql_help.c:4054 -#: sql_help.c:4096 sql_help.c:4098 +#: sql_help.c:3625 sql_help.c:3667 sql_help.c:3669 sql_help.c:3715 +#: sql_help.c:3864 sql_help.c:3906 sql_help.c:3908 sql_help.c:4058 +#: sql_help.c:4100 sql_help.c:4102 msgid "from_item" msgstr "item_de_from" -#: sql_help.c:3623 sql_help.c:3675 sql_help.c:3862 sql_help.c:3914 -#: sql_help.c:4056 sql_help.c:4108 +#: sql_help.c:3627 sql_help.c:3679 sql_help.c:3866 sql_help.c:3918 +#: sql_help.c:4060 sql_help.c:4112 msgid "grouping_element" msgstr "elemento_agrupante" -#: sql_help.c:3625 sql_help.c:3715 sql_help.c:3864 sql_help.c:4058 +#: sql_help.c:3629 sql_help.c:3719 sql_help.c:3868 sql_help.c:4062 msgid "window_name" msgstr "nombre_de_ventana" -#: sql_help.c:3626 sql_help.c:3716 sql_help.c:3865 sql_help.c:4059 +#: sql_help.c:3630 sql_help.c:3720 sql_help.c:3869 sql_help.c:4063 msgid "window_definition" msgstr "definición_de_ventana" -#: sql_help.c:3627 sql_help.c:3641 sql_help.c:3679 sql_help.c:3717 -#: sql_help.c:3866 sql_help.c:3880 sql_help.c:3918 sql_help.c:4060 -#: sql_help.c:4074 sql_help.c:4112 +#: sql_help.c:3631 sql_help.c:3645 sql_help.c:3683 sql_help.c:3721 +#: sql_help.c:3870 sql_help.c:3884 sql_help.c:3922 sql_help.c:4064 +#: sql_help.c:4078 sql_help.c:4116 msgid "select" msgstr "select" -#: sql_help.c:3634 sql_help.c:3873 sql_help.c:4067 +#: sql_help.c:3638 sql_help.c:3877 sql_help.c:4071 msgid "where from_item can be one of:" msgstr "donde item_de_from puede ser uno de:" -#: sql_help.c:3637 sql_help.c:3643 sql_help.c:3646 sql_help.c:3650 -#: sql_help.c:3662 sql_help.c:3876 sql_help.c:3882 sql_help.c:3885 -#: sql_help.c:3889 sql_help.c:3901 sql_help.c:4070 sql_help.c:4076 -#: sql_help.c:4079 sql_help.c:4083 sql_help.c:4095 +#: sql_help.c:3641 sql_help.c:3647 sql_help.c:3650 sql_help.c:3654 +#: sql_help.c:3666 sql_help.c:3880 sql_help.c:3886 sql_help.c:3889 +#: sql_help.c:3893 sql_help.c:3905 sql_help.c:4074 sql_help.c:4080 +#: sql_help.c:4083 sql_help.c:4087 sql_help.c:4099 msgid "column_alias" msgstr "alias_de_columna" -#: sql_help.c:3638 sql_help.c:3877 sql_help.c:4071 +#: sql_help.c:3642 sql_help.c:3881 sql_help.c:4075 msgid "sampling_method" msgstr "método_de_sampleo" -#: sql_help.c:3639 sql_help.c:3648 sql_help.c:3652 sql_help.c:3656 -#: sql_help.c:3659 sql_help.c:3878 sql_help.c:3887 sql_help.c:3891 -#: sql_help.c:3895 sql_help.c:3898 sql_help.c:4072 sql_help.c:4081 -#: sql_help.c:4085 sql_help.c:4089 sql_help.c:4092 +#: sql_help.c:3643 sql_help.c:3652 sql_help.c:3656 sql_help.c:3660 +#: sql_help.c:3663 sql_help.c:3882 sql_help.c:3891 sql_help.c:3895 +#: sql_help.c:3899 sql_help.c:3902 sql_help.c:4076 sql_help.c:4085 +#: sql_help.c:4089 sql_help.c:4093 sql_help.c:4096 msgid "argument" msgstr "argumento" -#: sql_help.c:3640 sql_help.c:3879 sql_help.c:4073 +#: sql_help.c:3644 sql_help.c:3883 sql_help.c:4077 msgid "seed" msgstr "semilla" -#: sql_help.c:3644 sql_help.c:3677 sql_help.c:3883 sql_help.c:3916 -#: sql_help.c:4077 sql_help.c:4110 +#: sql_help.c:3648 sql_help.c:3681 sql_help.c:3887 sql_help.c:3920 +#: sql_help.c:4081 sql_help.c:4114 msgid "with_query_name" msgstr "nombre_consulta_with" -#: sql_help.c:3654 sql_help.c:3657 sql_help.c:3660 sql_help.c:3893 -#: sql_help.c:3896 sql_help.c:3899 sql_help.c:4087 sql_help.c:4090 -#: sql_help.c:4093 +#: sql_help.c:3658 sql_help.c:3661 sql_help.c:3664 sql_help.c:3897 +#: sql_help.c:3900 sql_help.c:3903 sql_help.c:4091 sql_help.c:4094 +#: sql_help.c:4097 msgid "column_definition" msgstr "definición_de_columna" -#: sql_help.c:3664 sql_help.c:3903 sql_help.c:4097 +#: sql_help.c:3668 sql_help.c:3907 sql_help.c:4101 msgid "join_type" msgstr "tipo_de_join" -#: sql_help.c:3666 sql_help.c:3905 sql_help.c:4099 +#: sql_help.c:3670 sql_help.c:3909 sql_help.c:4103 msgid "join_condition" msgstr "condición_de_join" -#: sql_help.c:3667 sql_help.c:3906 sql_help.c:4100 +#: sql_help.c:3671 sql_help.c:3910 sql_help.c:4104 msgid "join_column" msgstr "columna_de_join" -#: sql_help.c:3668 sql_help.c:3907 sql_help.c:4101 +#: sql_help.c:3672 sql_help.c:3911 sql_help.c:4105 msgid "and grouping_element can be one of:" msgstr "donde elemento_agrupante puede ser una de:" -#: sql_help.c:3676 sql_help.c:3915 sql_help.c:4109 +#: sql_help.c:3680 sql_help.c:3919 sql_help.c:4113 msgid "and with_query is:" msgstr "y consulta_with es:" -#: sql_help.c:3680 sql_help.c:3919 sql_help.c:4113 +#: sql_help.c:3684 sql_help.c:3923 sql_help.c:4117 msgid "values" msgstr "valores" -#: sql_help.c:3681 sql_help.c:3920 sql_help.c:4114 +#: sql_help.c:3685 sql_help.c:3924 sql_help.c:4118 msgid "insert" msgstr "insert" -#: sql_help.c:3682 sql_help.c:3921 sql_help.c:4115 +#: sql_help.c:3686 sql_help.c:3925 sql_help.c:4119 msgid "update" msgstr "update" -#: sql_help.c:3683 sql_help.c:3922 sql_help.c:4116 +#: sql_help.c:3687 sql_help.c:3926 sql_help.c:4120 msgid "delete" msgstr "delete" -#: sql_help.c:3710 +#: sql_help.c:3714 msgid "new_table" msgstr "nueva_tabla" -#: sql_help.c:3735 +#: sql_help.c:3739 msgid "timezone" msgstr "huso_horario" -#: sql_help.c:3780 +#: sql_help.c:3784 msgid "snapshot_id" msgstr "id_de_snapshot" -#: sql_help.c:3965 +#: sql_help.c:3969 msgid "from_list" msgstr "lista_from" -#: sql_help.c:3996 +#: sql_help.c:4000 msgid "sort_expression" msgstr "expresión_orden" -#: sql_help.c:4123 sql_help.c:4863 +#: sql_help.c:4127 sql_help.c:4867 msgid "abort the current transaction" msgstr "aborta la transacción en curso" -#: sql_help.c:4128 +#: sql_help.c:4132 msgid "change the definition of an aggregate function" msgstr "cambia la definición de una función de agregación" -#: sql_help.c:4133 +#: sql_help.c:4137 msgid "change the definition of a collation" msgstr "cambia la definición de un ordenamiento" -#: sql_help.c:4138 +#: sql_help.c:4142 msgid "change the definition of a conversion" msgstr "cambia la definición de una conversión" -#: sql_help.c:4143 +#: sql_help.c:4147 msgid "change a database" msgstr "cambia una base de datos" -#: sql_help.c:4148 +#: sql_help.c:4152 msgid "define default access privileges" msgstr "define privilegios de acceso por omisión" -#: sql_help.c:4153 +#: sql_help.c:4157 msgid "change the definition of a domain" msgstr "cambia la definición de un dominio" -#: sql_help.c:4158 +#: sql_help.c:4162 msgid "change the definition of an event trigger" msgstr "cambia la definición de un disparador por evento" -#: sql_help.c:4163 +#: sql_help.c:4167 msgid "change the definition of an extension" msgstr "cambia la definición de una extensión" -#: sql_help.c:4168 +#: sql_help.c:4172 msgid "change the definition of a foreign-data wrapper" msgstr "cambia la definición de un conector de datos externos" -#: sql_help.c:4173 +#: sql_help.c:4177 msgid "change the definition of a foreign table" msgstr "cambia la definición de una tabla foránea" -#: sql_help.c:4178 +#: sql_help.c:4182 msgid "change the definition of a function" msgstr "cambia la definición de una función" -#: sql_help.c:4183 +#: sql_help.c:4187 msgid "change role name or membership" msgstr "cambiar nombre del rol o membresía" -#: sql_help.c:4188 +#: sql_help.c:4192 msgid "change the definition of an index" msgstr "cambia la definición de un índice" -#: sql_help.c:4193 +#: sql_help.c:4197 msgid "change the definition of a procedural language" msgstr "cambia la definición de un lenguaje procedural" -#: sql_help.c:4198 +#: sql_help.c:4202 msgid "change the definition of a large object" msgstr "cambia la definición de un objeto grande" -#: sql_help.c:4203 +#: sql_help.c:4207 msgid "change the definition of a materialized view" msgstr "cambia la definición de una vista materializada" -#: sql_help.c:4208 +#: sql_help.c:4212 msgid "change the definition of an operator" msgstr "cambia la definición de un operador" -#: sql_help.c:4213 +#: sql_help.c:4217 msgid "change the definition of an operator class" msgstr "cambia la definición de una clase de operadores" -#: sql_help.c:4218 +#: sql_help.c:4222 msgid "change the definition of an operator family" msgstr "cambia la definición de una familia de operadores" -#: sql_help.c:4223 +#: sql_help.c:4227 msgid "change the definition of a row level security policy" msgstr "cambia la definición de una política de seguridad de registros" -#: sql_help.c:4228 sql_help.c:4298 +#: sql_help.c:4232 sql_help.c:4302 msgid "change a database role" msgstr "cambia un rol de la base de datos" -#: sql_help.c:4233 +#: sql_help.c:4237 msgid "change the definition of a rule" msgstr "cambia la definición de una regla" -#: sql_help.c:4238 +#: sql_help.c:4242 msgid "change the definition of a schema" msgstr "cambia la definición de un esquema" -#: sql_help.c:4243 +#: sql_help.c:4247 msgid "change the definition of a sequence generator" msgstr "cambia la definición de un generador secuencial" -#: sql_help.c:4248 +#: sql_help.c:4252 msgid "change the definition of a foreign server" msgstr "cambia la definición de un servidor foráneo" -#: sql_help.c:4253 +#: sql_help.c:4257 msgid "change a server configuration parameter" msgstr "cambia un parámetro de configuración del servidor" -#: sql_help.c:4258 +#: sql_help.c:4262 msgid "change the definition of a table" msgstr "cambia la definición de una tabla" -#: sql_help.c:4263 +#: sql_help.c:4267 msgid "change the definition of a tablespace" msgstr "cambia la definición de un tablespace" -#: sql_help.c:4268 +#: sql_help.c:4272 msgid "change the definition of a text search configuration" msgstr "cambia la definición de una configuración de búsqueda en texto" -#: sql_help.c:4273 +#: sql_help.c:4277 msgid "change the definition of a text search dictionary" msgstr "cambia la definición de un diccionario de búsqueda en texto" -#: sql_help.c:4278 +#: sql_help.c:4282 msgid "change the definition of a text search parser" msgstr "cambia la definición de un analizador de búsqueda en texto" -#: sql_help.c:4283 +#: sql_help.c:4287 msgid "change the definition of a text search template" msgstr "cambia la definición de una plantilla de búsqueda en texto" -#: sql_help.c:4288 +#: sql_help.c:4292 msgid "change the definition of a trigger" msgstr "cambia la definición de un disparador" -#: sql_help.c:4293 +#: sql_help.c:4297 msgid "change the definition of a type" msgstr "cambia la definición de un tipo" -#: sql_help.c:4303 +#: sql_help.c:4307 msgid "change the definition of a user mapping" msgstr "cambia la definición de un mapeo de usuario" -#: sql_help.c:4308 +#: sql_help.c:4312 msgid "change the definition of a view" msgstr "cambia la definición de una vista" -#: sql_help.c:4313 +#: sql_help.c:4317 msgid "collect statistics about a database" msgstr "recolecta estadísticas sobre una base de datos" -#: sql_help.c:4318 sql_help.c:4928 +#: sql_help.c:4322 sql_help.c:4932 msgid "start a transaction block" msgstr "inicia un bloque de transacción" -#: sql_help.c:4323 +#: sql_help.c:4327 msgid "force a transaction log checkpoint" msgstr "fuerza un checkpoint del registro de transacciones" -#: sql_help.c:4328 +#: sql_help.c:4332 msgid "close a cursor" msgstr "cierra un cursor" -#: sql_help.c:4333 +#: sql_help.c:4337 msgid "cluster a table according to an index" msgstr "reordena una tabla siguiendo un índice" -#: sql_help.c:4338 +#: sql_help.c:4342 msgid "define or change the comment of an object" msgstr "define o cambia un comentario sobre un objeto" -#: sql_help.c:4343 sql_help.c:4763 +#: sql_help.c:4347 sql_help.c:4767 msgid "commit the current transaction" msgstr "compromete la transacción en curso" -#: sql_help.c:4348 +#: sql_help.c:4352 msgid "commit a transaction that was earlier prepared for two-phase commit" msgstr "confirma una transacción que fue preparada para two-phase commit" -#: sql_help.c:4353 +#: sql_help.c:4357 msgid "copy data between a file and a table" msgstr "copia datos entre un archivo y una tabla" -#: sql_help.c:4358 +#: sql_help.c:4362 msgid "define a new access method" msgstr "define un nuevo método de acceso" -#: sql_help.c:4363 +#: sql_help.c:4367 msgid "define a new aggregate function" msgstr "define una nueva función de agregación" -#: sql_help.c:4368 +#: sql_help.c:4372 msgid "define a new cast" msgstr "define una nueva conversión de tipo" -#: sql_help.c:4373 +#: sql_help.c:4377 msgid "define a new collation" msgstr "define un nuevo ordenamiento" -#: sql_help.c:4378 +#: sql_help.c:4382 msgid "define a new encoding conversion" msgstr "define una nueva conversión de codificación" -#: sql_help.c:4383 +#: sql_help.c:4387 msgid "create a new database" msgstr "crea una nueva base de datos" -#: sql_help.c:4388 +#: sql_help.c:4392 msgid "define a new domain" msgstr "define un nuevo dominio" -#: sql_help.c:4393 +#: sql_help.c:4397 msgid "define a new event trigger" msgstr "define un nuevo disparador por evento" -#: sql_help.c:4398 +#: sql_help.c:4402 msgid "install an extension" msgstr "instala una extensión" -#: sql_help.c:4403 +#: sql_help.c:4407 msgid "define a new foreign-data wrapper" msgstr "define un nuevo conector de datos externos" -#: sql_help.c:4408 +#: sql_help.c:4412 msgid "define a new foreign table" msgstr "define una nueva tabla foránea" -#: sql_help.c:4413 +#: sql_help.c:4417 msgid "define a new function" msgstr "define una nueva función" -#: sql_help.c:4418 sql_help.c:4458 sql_help.c:4533 +#: sql_help.c:4422 sql_help.c:4462 sql_help.c:4537 msgid "define a new database role" msgstr "define un nuevo rol de la base de datos" -#: sql_help.c:4423 +#: sql_help.c:4427 msgid "define a new index" msgstr "define un nuevo índice" -#: sql_help.c:4428 +#: sql_help.c:4432 msgid "define a new procedural language" msgstr "define un nuevo lenguaje procedural" -#: sql_help.c:4433 +#: sql_help.c:4437 msgid "define a new materialized view" msgstr "define una nueva vista materializada" -#: sql_help.c:4438 +#: sql_help.c:4442 msgid "define a new operator" msgstr "define un nuevo operador" -#: sql_help.c:4443 +#: sql_help.c:4447 msgid "define a new operator class" msgstr "define una nueva clase de operadores" -#: sql_help.c:4448 +#: sql_help.c:4452 msgid "define a new operator family" msgstr "define una nueva familia de operadores" -#: sql_help.c:4453 +#: sql_help.c:4457 msgid "define a new row level security policy for a table" msgstr "define una nueva política de seguridad de registros para una tabla" -#: sql_help.c:4463 +#: sql_help.c:4467 msgid "define a new rewrite rule" msgstr "define una nueva regla de reescritura" -#: sql_help.c:4468 +#: sql_help.c:4472 msgid "define a new schema" msgstr "define un nuevo schema" -#: sql_help.c:4473 +#: sql_help.c:4477 msgid "define a new sequence generator" msgstr "define un nuevo generador secuencial" -#: sql_help.c:4478 +#: sql_help.c:4482 msgid "define a new foreign server" msgstr "define un nuevo servidor foráneo" -#: sql_help.c:4483 +#: sql_help.c:4487 msgid "define a new table" msgstr "define una nueva tabla" -#: sql_help.c:4488 sql_help.c:4893 +#: sql_help.c:4492 sql_help.c:4897 msgid "define a new table from the results of a query" msgstr "crea una nueva tabla usando los resultados de una consulta" -#: sql_help.c:4493 +#: sql_help.c:4497 msgid "define a new tablespace" msgstr "define un nuevo tablespace" -#: sql_help.c:4498 +#: sql_help.c:4502 msgid "define a new text search configuration" msgstr "define una nueva configuración de búsqueda en texto" -#: sql_help.c:4503 +#: sql_help.c:4507 msgid "define a new text search dictionary" msgstr "define un nuevo diccionario de búsqueda en texto" -#: sql_help.c:4508 +#: sql_help.c:4512 msgid "define a new text search parser" msgstr "define un nuevo analizador de búsqueda en texto" -#: sql_help.c:4513 +#: sql_help.c:4517 msgid "define a new text search template" msgstr "define una nueva plantilla de búsqueda en texto" -#: sql_help.c:4518 +#: sql_help.c:4522 msgid "define a new transform" msgstr "define una nueva transformación" -#: sql_help.c:4523 +#: sql_help.c:4527 msgid "define a new trigger" msgstr "define un nuevo disparador" -#: sql_help.c:4528 +#: sql_help.c:4532 msgid "define a new data type" msgstr "define un nuevo tipo de datos" -#: sql_help.c:4538 +#: sql_help.c:4542 msgid "define a new mapping of a user to a foreign server" msgstr "define un nuevo mapa de usuario a servidor foráneo" -#: sql_help.c:4543 +#: sql_help.c:4547 msgid "define a new view" msgstr "define una nueva vista" -#: sql_help.c:4548 +#: sql_help.c:4552 msgid "deallocate a prepared statement" msgstr "elimina una sentencia preparada" -#: sql_help.c:4553 +#: sql_help.c:4557 msgid "define a cursor" msgstr "define un nuevo cursor" -#: sql_help.c:4558 +#: sql_help.c:4562 msgid "delete rows of a table" msgstr "elimina filas de una tabla" -#: sql_help.c:4563 +#: sql_help.c:4567 msgid "discard session state" msgstr "descartar datos de la sesión" -#: sql_help.c:4568 +#: sql_help.c:4572 msgid "execute an anonymous code block" msgstr "ejecutar un bloque anónimo de código" -#: sql_help.c:4573 +#: sql_help.c:4577 msgid "remove an access method" msgstr "elimina un método de acceso" -#: sql_help.c:4578 +#: sql_help.c:4582 msgid "remove an aggregate function" msgstr "elimina una función de agregación" -#: sql_help.c:4583 +#: sql_help.c:4587 msgid "remove a cast" msgstr "elimina una conversión de tipo" -#: sql_help.c:4588 +#: sql_help.c:4592 msgid "remove a collation" msgstr "elimina un ordenamiento" -#: sql_help.c:4593 +#: sql_help.c:4597 msgid "remove a conversion" msgstr "elimina una conversión de codificación" -#: sql_help.c:4598 +#: sql_help.c:4602 msgid "remove a database" msgstr "elimina una base de datos" -#: sql_help.c:4603 +#: sql_help.c:4607 msgid "remove a domain" msgstr "elimina un dominio" -#: sql_help.c:4608 +#: sql_help.c:4612 msgid "remove an event trigger" msgstr "elimina un disparador por evento" -#: sql_help.c:4613 +#: sql_help.c:4617 msgid "remove an extension" msgstr "elimina una extensión" -#: sql_help.c:4618 +#: sql_help.c:4622 msgid "remove a foreign-data wrapper" msgstr "elimina un conector de datos externos" -#: sql_help.c:4623 +#: sql_help.c:4627 msgid "remove a foreign table" msgstr "elimina una tabla foránea" -#: sql_help.c:4628 +#: sql_help.c:4632 msgid "remove a function" msgstr "elimina una función" -#: sql_help.c:4633 sql_help.c:4678 sql_help.c:4748 +#: sql_help.c:4637 sql_help.c:4682 sql_help.c:4752 msgid "remove a database role" msgstr "elimina un rol de base de datos" -#: sql_help.c:4638 +#: sql_help.c:4642 msgid "remove an index" msgstr "elimina un índice" -#: sql_help.c:4643 +#: sql_help.c:4647 msgid "remove a procedural language" msgstr "elimina un lenguaje procedural" -#: sql_help.c:4648 +#: sql_help.c:4652 msgid "remove a materialized view" msgstr "elimina una vista materializada" -#: sql_help.c:4653 +#: sql_help.c:4657 msgid "remove an operator" msgstr "elimina un operador" -#: sql_help.c:4658 +#: sql_help.c:4662 msgid "remove an operator class" msgstr "elimina una clase de operadores" -#: sql_help.c:4663 +#: sql_help.c:4667 msgid "remove an operator family" msgstr "elimina una familia de operadores" -#: sql_help.c:4668 +#: sql_help.c:4672 msgid "remove database objects owned by a database role" msgstr "elimina objetos de propiedad de un rol de la base de datos" -#: sql_help.c:4673 +#: sql_help.c:4677 msgid "remove a row level security policy from a table" msgstr "elimina una política de seguridad de registros de una tabla" -#: sql_help.c:4683 +#: sql_help.c:4687 msgid "remove a rewrite rule" msgstr "elimina una regla de reescritura" -#: sql_help.c:4688 +#: sql_help.c:4692 msgid "remove a schema" msgstr "elimina un schema" -#: sql_help.c:4693 +#: sql_help.c:4697 msgid "remove a sequence" msgstr "elimina un generador secuencial" -#: sql_help.c:4698 +#: sql_help.c:4702 msgid "remove a foreign server descriptor" msgstr "elimina un descriptor de servidor foráneo" -#: sql_help.c:4703 +#: sql_help.c:4707 msgid "remove a table" msgstr "elimina una tabla" -#: sql_help.c:4708 +#: sql_help.c:4712 msgid "remove a tablespace" msgstr "elimina un tablespace" -#: sql_help.c:4713 +#: sql_help.c:4717 msgid "remove a text search configuration" msgstr "elimina una configuración de búsqueda en texto" -#: sql_help.c:4718 +#: sql_help.c:4722 msgid "remove a text search dictionary" msgstr "elimina un diccionario de búsqueda en texto" -#: sql_help.c:4723 +#: sql_help.c:4727 msgid "remove a text search parser" msgstr "elimina un analizador de búsqueda en texto" -#: sql_help.c:4728 +#: sql_help.c:4732 msgid "remove a text search template" msgstr "elimina una plantilla de búsqueda en texto" -#: sql_help.c:4733 +#: sql_help.c:4737 msgid "remove a transform" msgstr "elimina una transformación" -#: sql_help.c:4738 +#: sql_help.c:4742 msgid "remove a trigger" msgstr "elimina un disparador" -#: sql_help.c:4743 +#: sql_help.c:4747 msgid "remove a data type" msgstr "elimina un tipo de datos" -#: sql_help.c:4753 +#: sql_help.c:4757 msgid "remove a user mapping for a foreign server" msgstr "elimina un mapeo de usuario para un servidor remoto" -#: sql_help.c:4758 +#: sql_help.c:4762 msgid "remove a view" msgstr "elimina una vista" -#: sql_help.c:4768 +#: sql_help.c:4772 msgid "execute a prepared statement" msgstr "ejecuta una sentencia preparada" -#: sql_help.c:4773 +#: sql_help.c:4777 msgid "show the execution plan of a statement" msgstr "muestra el plan de ejecución de una sentencia" -#: sql_help.c:4778 +#: sql_help.c:4782 msgid "retrieve rows from a query using a cursor" msgstr "recupera filas de una consulta usando un cursor" -#: sql_help.c:4783 +#: sql_help.c:4787 msgid "define access privileges" msgstr "define privilegios de acceso" -#: sql_help.c:4788 +#: sql_help.c:4792 msgid "import table definitions from a foreign server" msgstr "importa definiciones de tablas desde un servidor foráneo" -#: sql_help.c:4793 +#: sql_help.c:4797 msgid "create new rows in a table" msgstr "crea nuevas filas en una tabla" -#: sql_help.c:4798 +#: sql_help.c:4802 msgid "listen for a notification" msgstr "escucha notificaciones" -#: sql_help.c:4803 +#: sql_help.c:4807 msgid "load a shared library file" msgstr "carga un archivo de biblioteca compartida" -#: sql_help.c:4808 +#: sql_help.c:4812 msgid "lock a table" msgstr "bloquea una tabla" -#: sql_help.c:4813 +#: sql_help.c:4817 msgid "position a cursor" msgstr "reposiciona un cursor" -#: sql_help.c:4818 +#: sql_help.c:4822 msgid "generate a notification" msgstr "genera una notificación" -#: sql_help.c:4823 +#: sql_help.c:4827 msgid "prepare a statement for execution" msgstr "prepara una sentencia para ejecución" -#: sql_help.c:4828 +#: sql_help.c:4832 msgid "prepare the current transaction for two-phase commit" msgstr "prepara la transacción actual para two-phase commit" -#: sql_help.c:4833 +#: sql_help.c:4837 msgid "change the ownership of database objects owned by a database role" msgstr "cambia de dueño a los objetos de propiedad de un rol de la base de datos" -#: sql_help.c:4838 +#: sql_help.c:4842 msgid "replace the contents of a materialized view" msgstr "reemplaza los contenidos de una vista materializada" -#: sql_help.c:4843 +#: sql_help.c:4847 msgid "rebuild indexes" msgstr "reconstruye índices" -#: sql_help.c:4848 +#: sql_help.c:4852 msgid "destroy a previously defined savepoint" msgstr "destruye un savepoint previamente definido" -#: sql_help.c:4853 +#: sql_help.c:4857 msgid "restore the value of a run-time parameter to the default value" msgstr "restaura el valor de un parámetro de configuración al valor inicial" -#: sql_help.c:4858 +#: sql_help.c:4862 msgid "remove access privileges" msgstr "revoca privilegios de acceso" -#: sql_help.c:4868 +#: sql_help.c:4872 msgid "cancel a transaction that was earlier prepared for two-phase commit" msgstr "cancela una transacción que fue previamente preparada para two-phase commit." -#: sql_help.c:4873 +#: sql_help.c:4877 msgid "roll back to a savepoint" msgstr "descartar hacia un savepoint" -#: sql_help.c:4878 +#: sql_help.c:4882 msgid "define a new savepoint within the current transaction" msgstr "define un nuevo savepoint en la transacción en curso" -#: sql_help.c:4883 +#: sql_help.c:4887 msgid "define or change a security label applied to an object" msgstr "define o cambia una etiqueta de seguridad sobre un objeto" -#: sql_help.c:4888 sql_help.c:4933 sql_help.c:4963 +#: sql_help.c:4892 sql_help.c:4937 sql_help.c:4967 msgid "retrieve rows from a table or view" msgstr "recupera filas desde una tabla o vista" -#: sql_help.c:4898 +#: sql_help.c:4902 msgid "change a run-time parameter" msgstr "cambia un parámetro de configuración" -#: sql_help.c:4903 +#: sql_help.c:4907 msgid "set constraint check timing for the current transaction" msgstr "define el modo de verificación de las restricciones de la transacción en curso" -#: sql_help.c:4908 +#: sql_help.c:4912 msgid "set the current user identifier of the current session" msgstr "define el identificador de usuario actual de la sesión actual" -#: sql_help.c:4913 +#: sql_help.c:4917 msgid "set the session user identifier and the current user identifier of the current session" msgstr "" "define el identificador del usuario de sesión y el identificador\n" "del usuario actual de la sesión en curso" -#: sql_help.c:4918 +#: sql_help.c:4922 msgid "set the characteristics of the current transaction" msgstr "define las características de la transacción en curso" -#: sql_help.c:4923 +#: sql_help.c:4927 msgid "show the value of a run-time parameter" msgstr "muestra el valor de un parámetro de configuración" -#: sql_help.c:4938 +#: sql_help.c:4942 msgid "empty a table or set of tables" msgstr "vacía una tabla o conjunto de tablas" -#: sql_help.c:4943 +#: sql_help.c:4947 msgid "stop listening for a notification" msgstr "deja de escuchar una notificación" -#: sql_help.c:4948 +#: sql_help.c:4952 msgid "update rows of a table" msgstr "actualiza filas de una tabla" -#: sql_help.c:4953 +#: sql_help.c:4957 msgid "garbage-collect and optionally analyze a database" msgstr "recolecta basura y opcionalmente estadísticas sobre una base de datos" -#: sql_help.c:4958 +#: sql_help.c:4962 msgid "compute a set of rows" msgstr "calcula un conjunto de registros" @@ -5357,7 +5350,7 @@ msgstr "%s: no se pudo encontrar el ejecutable propio\n" msgid "unrecognized value \"%s\" for \"%s\"; assuming \"%s\"\n" msgstr "valor «%s» no reconocido para «%s»; asumiendo «%s»\n" -#: tab-complete.c:3744 +#: tab-complete.c:3742 #, c-format msgid "" "tab completion query failed: %s\n" diff --git a/src/bin/psql/po/ru.po b/src/bin/psql/po/ru.po index 261c932a04..5283a8e198 100644 --- a/src/bin/psql/po/ru.po +++ b/src/bin/psql/po/ru.po @@ -4,14 +4,14 @@ # Serguei A. Mokhov , 2001-2005. # Oleg Bartunov , 2004-2005. # Sergey Burladyan , 2012. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: psql (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:13+0000\n" -"PO-Revision-Date: 2016-11-24 15:40+0300\n" +"POT-Creation-Date: 2017-08-17 17:52+0000\n" +"PO-Revision-Date: 2017-05-27 15:09+0300\n" "Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" "Language: ru\n" @@ -235,7 +235,7 @@ msgstr "" "перекодировки\n" #: command.c:871 command.c:1962 command.c:3649 common.c:153 common.c:200 -#: common.c:497 common.c:1190 common.c:1218 common.c:1319 copy.c:489 copy.c:699 +#: common.c:497 common.c:1190 common.c:1218 common.c:1319 copy.c:489 copy.c:709 #: large_obj.c:156 large_obj.c:191 large_obj.c:253 #, c-format msgid "%s" @@ -856,16 +856,16 @@ msgstr "отменено пользователем" #: copy.c:542 msgid "" "Enter data to be copied followed by a newline.\n" -"End with a backslash and a period on a line by itself." +"End with a backslash and a period on a line by itself, or an EOF signal." msgstr "" "Вводите данные Ð´Ð»Ñ ÐºÐ¾Ð¿Ð¸Ñ€Ð¾Ð²Ð°Ð½Ð¸Ñ, разделÑÑ Ñтроки переводом Ñтроки.\n" -"Закончите ввод Ñтрокой '\\.'." +"Закончите ввод Ñтрокой '\\.' или Ñигналом EOF." #: copy.c:671 msgid "aborted because of read failure" msgstr "прерывание из-за ошибки чтениÑ" -#: copy.c:695 +#: copy.c:705 msgid "trying to exit copy mode" msgstr "попытка выйти из режима копированиÑ" @@ -1468,6 +1468,17 @@ msgstr "Триггеры, Ñрабатывающие вÑегда:" msgid "Triggers firing on replica only:" msgstr "Триггеры, Ñрабатывающие только в реплике:" +#: describe.c:2519 +#, c-format +msgid "Server: %s" +msgstr "Сервер: %s" + +# well-spelled: ОСД +#: describe.c:2527 +#, c-format +msgid "FDW Options: (%s)" +msgstr "Параметр ОСД: (%s)" + #: describe.c:2541 msgid "Inherits" msgstr "ÐаÑледует" @@ -3563,34 +3574,34 @@ msgstr "%s: нехватка памÑти\n" #: sql_help.c:1138 sql_help.c:1140 sql_help.c:1150 sql_help.c:1152 #: sql_help.c:1162 sql_help.c:1165 sql_help.c:1186 sql_help.c:1188 #: sql_help.c:1190 sql_help.c:1193 sql_help.c:1195 sql_help.c:1197 -#: sql_help.c:1247 sql_help.c:1285 sql_help.c:1288 sql_help.c:1290 -#: sql_help.c:1292 sql_help.c:1294 sql_help.c:1296 sql_help.c:1299 -#: sql_help.c:1339 sql_help.c:1544 sql_help.c:1608 sql_help.c:1627 -#: sql_help.c:1640 sql_help.c:1694 sql_help.c:1698 sql_help.c:1708 -#: sql_help.c:1728 sql_help.c:1753 sql_help.c:1771 sql_help.c:1800 -#: sql_help.c:1875 sql_help.c:1917 sql_help.c:1939 sql_help.c:1959 -#: sql_help.c:1960 sql_help.c:1995 sql_help.c:2015 sql_help.c:2037 -#: sql_help.c:2050 sql_help.c:2081 sql_help.c:2106 sql_help.c:2150 -#: sql_help.c:2336 sql_help.c:2349 sql_help.c:2366 sql_help.c:2382 -#: sql_help.c:2421 sql_help.c:2472 sql_help.c:2476 sql_help.c:2478 -#: sql_help.c:2484 sql_help.c:2502 sql_help.c:2529 sql_help.c:2564 -#: sql_help.c:2576 sql_help.c:2585 sql_help.c:2629 sql_help.c:2643 -#: sql_help.c:2671 sql_help.c:2679 sql_help.c:2687 sql_help.c:2695 -#: sql_help.c:2703 sql_help.c:2711 sql_help.c:2719 sql_help.c:2727 -#: sql_help.c:2736 sql_help.c:2747 sql_help.c:2755 sql_help.c:2763 -#: sql_help.c:2771 sql_help.c:2779 sql_help.c:2789 sql_help.c:2798 -#: sql_help.c:2807 sql_help.c:2815 sql_help.c:2824 sql_help.c:2832 -#: sql_help.c:2841 sql_help.c:2849 sql_help.c:2857 sql_help.c:2865 -#: sql_help.c:2873 sql_help.c:2881 sql_help.c:2889 sql_help.c:2897 -#: sql_help.c:2905 sql_help.c:2922 sql_help.c:2931 sql_help.c:2939 -#: sql_help.c:2956 sql_help.c:2971 sql_help.c:3236 sql_help.c:3287 -#: sql_help.c:3316 sql_help.c:3324 sql_help.c:3743 sql_help.c:3791 -#: sql_help.c:3932 +#: sql_help.c:1247 sql_help.c:1289 sql_help.c:1292 sql_help.c:1294 +#: sql_help.c:1296 sql_help.c:1298 sql_help.c:1300 sql_help.c:1303 +#: sql_help.c:1343 sql_help.c:1548 sql_help.c:1612 sql_help.c:1631 +#: sql_help.c:1644 sql_help.c:1698 sql_help.c:1702 sql_help.c:1712 +#: sql_help.c:1732 sql_help.c:1757 sql_help.c:1775 sql_help.c:1804 +#: sql_help.c:1879 sql_help.c:1921 sql_help.c:1943 sql_help.c:1963 +#: sql_help.c:1964 sql_help.c:1999 sql_help.c:2019 sql_help.c:2041 +#: sql_help.c:2054 sql_help.c:2085 sql_help.c:2110 sql_help.c:2154 +#: sql_help.c:2340 sql_help.c:2353 sql_help.c:2370 sql_help.c:2386 +#: sql_help.c:2425 sql_help.c:2476 sql_help.c:2480 sql_help.c:2482 +#: sql_help.c:2488 sql_help.c:2506 sql_help.c:2533 sql_help.c:2568 +#: sql_help.c:2580 sql_help.c:2589 sql_help.c:2633 sql_help.c:2647 +#: sql_help.c:2675 sql_help.c:2683 sql_help.c:2691 sql_help.c:2699 +#: sql_help.c:2707 sql_help.c:2715 sql_help.c:2723 sql_help.c:2731 +#: sql_help.c:2740 sql_help.c:2751 sql_help.c:2759 sql_help.c:2767 +#: sql_help.c:2775 sql_help.c:2783 sql_help.c:2793 sql_help.c:2802 +#: sql_help.c:2811 sql_help.c:2819 sql_help.c:2828 sql_help.c:2836 +#: sql_help.c:2845 sql_help.c:2853 sql_help.c:2861 sql_help.c:2869 +#: sql_help.c:2877 sql_help.c:2885 sql_help.c:2893 sql_help.c:2901 +#: sql_help.c:2909 sql_help.c:2926 sql_help.c:2935 sql_help.c:2943 +#: sql_help.c:2960 sql_help.c:2975 sql_help.c:3240 sql_help.c:3291 +#: sql_help.c:3320 sql_help.c:3328 sql_help.c:3747 sql_help.c:3795 +#: sql_help.c:3936 msgid "name" msgstr "имÑ" -#: sql_help.c:37 sql_help.c:40 sql_help.c:43 sql_help.c:311 sql_help.c:1405 -#: sql_help.c:2644 sql_help.c:3539 +#: sql_help.c:37 sql_help.c:40 sql_help.c:43 sql_help.c:311 sql_help.c:1409 +#: sql_help.c:2648 sql_help.c:3543 msgid "aggregate_signature" msgstr "Ñигнатура_агр_функции" @@ -3600,7 +3611,7 @@ msgstr "Ñигнатура_агр_функции" #: sql_help.c:774 sql_help.c:820 sql_help.c:844 sql_help.c:854 sql_help.c:884 #: sql_help.c:904 sql_help.c:996 sql_help.c:1061 sql_help.c:1104 #: sql_help.c:1125 sql_help.c:1139 sql_help.c:1151 sql_help.c:1164 -#: sql_help.c:1194 sql_help.c:1248 sql_help.c:1293 +#: sql_help.c:1194 sql_help.c:1248 sql_help.c:1297 msgid "new_name" msgstr "новое_имÑ" @@ -3608,75 +3619,75 @@ msgstr "новое_имÑ" #: sql_help.c:252 sql_help.c:373 sql_help.c:459 sql_help.c:505 sql_help.c:585 #: sql_help.c:594 sql_help.c:652 sql_help.c:672 sql_help.c:701 sql_help.c:756 #: sql_help.c:856 sql_help.c:882 sql_help.c:902 sql_help.c:1045 sql_help.c:1063 -#: sql_help.c:1106 sql_help.c:1127 sql_help.c:1189 sql_help.c:1291 -#: sql_help.c:2322 +#: sql_help.c:1106 sql_help.c:1127 sql_help.c:1189 sql_help.c:1295 +#: sql_help.c:2326 msgid "new_owner" msgstr "новый_владелец" #: sql_help.c:44 sql_help.c:69 sql_help.c:84 sql_help.c:238 sql_help.c:303 #: sql_help.c:425 sql_help.c:510 sql_help.c:635 sql_help.c:676 sql_help.c:704 #: sql_help.c:759 sql_help.c:886 sql_help.c:998 sql_help.c:1108 sql_help.c:1129 -#: sql_help.c:1141 sql_help.c:1153 sql_help.c:1196 sql_help.c:1295 +#: sql_help.c:1141 sql_help.c:1153 sql_help.c:1196 sql_help.c:1299 msgid "new_schema" msgstr "новаÑ_Ñхема" -#: sql_help.c:45 sql_help.c:1458 sql_help.c:2645 sql_help.c:3558 +#: sql_help.c:45 sql_help.c:1462 sql_help.c:2649 sql_help.c:3562 msgid "where aggregate_signature is:" msgstr "где Ñигнатура_агр_функции:" #: sql_help.c:46 sql_help.c:49 sql_help.c:52 sql_help.c:321 sql_help.c:346 #: sql_help.c:349 sql_help.c:352 sql_help.c:492 sql_help.c:497 sql_help.c:502 -#: sql_help.c:507 sql_help.c:512 sql_help.c:1423 sql_help.c:1459 -#: sql_help.c:1462 sql_help.c:1465 sql_help.c:1609 sql_help.c:1628 -#: sql_help.c:1631 sql_help.c:1876 sql_help.c:2646 sql_help.c:2649 -#: sql_help.c:2652 sql_help.c:2737 sql_help.c:3122 sql_help.c:3454 -#: sql_help.c:3545 sql_help.c:3559 sql_help.c:3562 sql_help.c:3565 +#: sql_help.c:507 sql_help.c:512 sql_help.c:1427 sql_help.c:1463 +#: sql_help.c:1466 sql_help.c:1469 sql_help.c:1613 sql_help.c:1632 +#: sql_help.c:1635 sql_help.c:1880 sql_help.c:2650 sql_help.c:2653 +#: sql_help.c:2656 sql_help.c:2741 sql_help.c:3126 sql_help.c:3458 +#: sql_help.c:3549 sql_help.c:3563 sql_help.c:3566 sql_help.c:3569 msgid "argmode" msgstr "режим_аргумента" #: sql_help.c:47 sql_help.c:50 sql_help.c:53 sql_help.c:322 sql_help.c:347 #: sql_help.c:350 sql_help.c:353 sql_help.c:493 sql_help.c:498 sql_help.c:503 -#: sql_help.c:508 sql_help.c:513 sql_help.c:1424 sql_help.c:1460 -#: sql_help.c:1463 sql_help.c:1466 sql_help.c:1610 sql_help.c:1629 -#: sql_help.c:1632 sql_help.c:1877 sql_help.c:2647 sql_help.c:2650 -#: sql_help.c:2653 sql_help.c:2738 sql_help.c:3546 sql_help.c:3560 -#: sql_help.c:3563 sql_help.c:3566 +#: sql_help.c:508 sql_help.c:513 sql_help.c:1428 sql_help.c:1464 +#: sql_help.c:1467 sql_help.c:1470 sql_help.c:1614 sql_help.c:1633 +#: sql_help.c:1636 sql_help.c:1881 sql_help.c:2651 sql_help.c:2654 +#: sql_help.c:2657 sql_help.c:2742 sql_help.c:3550 sql_help.c:3564 +#: sql_help.c:3567 sql_help.c:3570 msgid "argname" msgstr "имÑ_аргумента" #: sql_help.c:48 sql_help.c:51 sql_help.c:54 sql_help.c:323 sql_help.c:348 #: sql_help.c:351 sql_help.c:354 sql_help.c:494 sql_help.c:499 sql_help.c:504 -#: sql_help.c:509 sql_help.c:514 sql_help.c:1425 sql_help.c:1461 -#: sql_help.c:1464 sql_help.c:1467 sql_help.c:1878 sql_help.c:2648 -#: sql_help.c:2651 sql_help.c:2654 sql_help.c:2739 sql_help.c:3547 -#: sql_help.c:3561 sql_help.c:3564 sql_help.c:3567 +#: sql_help.c:509 sql_help.c:514 sql_help.c:1429 sql_help.c:1465 +#: sql_help.c:1468 sql_help.c:1471 sql_help.c:1882 sql_help.c:2652 +#: sql_help.c:2655 sql_help.c:2658 sql_help.c:2743 sql_help.c:3551 +#: sql_help.c:3565 sql_help.c:3568 sql_help.c:3571 msgid "argtype" msgstr "тип_аргумента" #: sql_help.c:110 sql_help.c:370 sql_help.c:448 sql_help.c:460 sql_help.c:814 -#: sql_help.c:899 sql_help.c:1122 sql_help.c:1242 sql_help.c:1270 -#: sql_help.c:1515 sql_help.c:1521 sql_help.c:1803 sql_help.c:1835 -#: sql_help.c:1842 sql_help.c:1918 sql_help.c:2082 sql_help.c:2171 -#: sql_help.c:2351 sql_help.c:2530 sql_help.c:2552 sql_help.c:2990 -#: sql_help.c:3156 +#: sql_help.c:899 sql_help.c:1122 sql_help.c:1242 sql_help.c:1274 +#: sql_help.c:1519 sql_help.c:1525 sql_help.c:1807 sql_help.c:1839 +#: sql_help.c:1846 sql_help.c:1922 sql_help.c:2086 sql_help.c:2175 +#: sql_help.c:2355 sql_help.c:2534 sql_help.c:2556 sql_help.c:2994 +#: sql_help.c:3160 msgid "option" msgstr "параметр" -#: sql_help.c:111 sql_help.c:815 sql_help.c:1243 sql_help.c:1919 -#: sql_help.c:2083 sql_help.c:2531 +#: sql_help.c:111 sql_help.c:815 sql_help.c:1243 sql_help.c:1923 +#: sql_help.c:2087 sql_help.c:2535 msgid "where option can be:" msgstr "где допуÑтимые параметры:" -#: sql_help.c:112 sql_help.c:1735 +#: sql_help.c:112 sql_help.c:1739 msgid "allowconn" msgstr "разр_подключениÑ" -#: sql_help.c:113 sql_help.c:816 sql_help.c:1244 sql_help.c:1736 -#: sql_help.c:2084 sql_help.c:2532 +#: sql_help.c:113 sql_help.c:816 sql_help.c:1244 sql_help.c:1740 +#: sql_help.c:2088 sql_help.c:2536 msgid "connlimit" msgstr "предел_подключений" -#: sql_help.c:114 sql_help.c:1737 +#: sql_help.c:114 sql_help.c:1741 msgid "istemplate" msgstr "Ñто_шаблон" @@ -3686,20 +3697,20 @@ msgstr "новое_табл_проÑтранÑтво" #: sql_help.c:122 sql_help.c:125 sql_help.c:127 sql_help.c:519 sql_help.c:521 #: sql_help.c:522 sql_help.c:823 sql_help.c:827 sql_help.c:830 sql_help.c:915 -#: sql_help.c:918 sql_help.c:1250 sql_help.c:1253 sql_help.c:1255 -#: sql_help.c:1887 sql_help.c:3341 sql_help.c:3732 +#: sql_help.c:918 sql_help.c:1251 sql_help.c:1255 sql_help.c:1258 +#: sql_help.c:1891 sql_help.c:3345 sql_help.c:3736 msgid "configuration_parameter" msgstr "параметр_конфигурации" #: sql_help.c:123 sql_help.c:371 sql_help.c:443 sql_help.c:449 sql_help.c:461 #: sql_help.c:520 sql_help.c:568 sql_help.c:644 sql_help.c:650 sql_help.c:824 #: sql_help.c:900 sql_help.c:916 sql_help.c:917 sql_help.c:1020 sql_help.c:1040 -#: sql_help.c:1066 sql_help.c:1123 sql_help.c:1251 sql_help.c:1271 -#: sql_help.c:1804 sql_help.c:1836 sql_help.c:1843 sql_help.c:1888 -#: sql_help.c:1889 sql_help.c:1947 sql_help.c:1979 sql_help.c:2172 -#: sql_help.c:2246 sql_help.c:2254 sql_help.c:2286 sql_help.c:2308 -#: sql_help.c:2325 sql_help.c:2352 sql_help.c:2553 sql_help.c:3157 -#: sql_help.c:3733 sql_help.c:3734 +#: sql_help.c:1066 sql_help.c:1123 sql_help.c:1252 sql_help.c:1275 +#: sql_help.c:1808 sql_help.c:1840 sql_help.c:1847 sql_help.c:1892 +#: sql_help.c:1893 sql_help.c:1951 sql_help.c:1983 sql_help.c:2176 +#: sql_help.c:2250 sql_help.c:2258 sql_help.c:2290 sql_help.c:2312 +#: sql_help.c:2329 sql_help.c:2356 sql_help.c:2557 sql_help.c:3161 +#: sql_help.c:3737 sql_help.c:3738 msgid "value" msgstr "значение" @@ -3707,9 +3718,9 @@ msgstr "значение" msgid "target_role" msgstr "целеваÑ_роль" -#: sql_help.c:186 sql_help.c:1787 sql_help.c:2130 sql_help.c:2135 -#: sql_help.c:3104 sql_help.c:3111 sql_help.c:3125 sql_help.c:3131 -#: sql_help.c:3436 sql_help.c:3443 sql_help.c:3457 sql_help.c:3463 +#: sql_help.c:186 sql_help.c:1791 sql_help.c:2134 sql_help.c:2139 +#: sql_help.c:3108 sql_help.c:3115 sql_help.c:3129 sql_help.c:3135 +#: sql_help.c:3440 sql_help.c:3447 sql_help.c:3461 sql_help.c:3467 msgid "schema_name" msgstr "имÑ_Ñхемы" @@ -3723,32 +3734,32 @@ msgstr "где допуÑтимое предложение_GRANT_или_REVOKE:" #: sql_help.c:189 sql_help.c:190 sql_help.c:191 sql_help.c:192 sql_help.c:193 #: sql_help.c:194 sql_help.c:195 sql_help.c:196 sql_help.c:544 sql_help.c:572 -#: sql_help.c:637 sql_help.c:777 sql_help.c:834 sql_help.c:1000 sql_help.c:1258 -#: sql_help.c:1922 sql_help.c:1923 sql_help.c:1924 sql_help.c:1925 -#: sql_help.c:1926 sql_help.c:2052 sql_help.c:2087 sql_help.c:2088 -#: sql_help.c:2089 sql_help.c:2090 sql_help.c:2091 sql_help.c:2535 -#: sql_help.c:2536 sql_help.c:2537 sql_help.c:2538 sql_help.c:2539 -#: sql_help.c:3138 sql_help.c:3139 sql_help.c:3140 sql_help.c:3437 -#: sql_help.c:3441 sql_help.c:3444 sql_help.c:3446 sql_help.c:3448 -#: sql_help.c:3450 sql_help.c:3452 sql_help.c:3458 sql_help.c:3460 -#: sql_help.c:3462 sql_help.c:3464 sql_help.c:3466 sql_help.c:3468 -#: sql_help.c:3469 sql_help.c:3470 sql_help.c:3753 +#: sql_help.c:637 sql_help.c:777 sql_help.c:834 sql_help.c:1000 sql_help.c:1262 +#: sql_help.c:1926 sql_help.c:1927 sql_help.c:1928 sql_help.c:1929 +#: sql_help.c:1930 sql_help.c:2056 sql_help.c:2091 sql_help.c:2092 +#: sql_help.c:2093 sql_help.c:2094 sql_help.c:2095 sql_help.c:2539 +#: sql_help.c:2540 sql_help.c:2541 sql_help.c:2542 sql_help.c:2543 +#: sql_help.c:3142 sql_help.c:3143 sql_help.c:3144 sql_help.c:3441 +#: sql_help.c:3445 sql_help.c:3448 sql_help.c:3450 sql_help.c:3452 +#: sql_help.c:3454 sql_help.c:3456 sql_help.c:3462 sql_help.c:3464 +#: sql_help.c:3466 sql_help.c:3468 sql_help.c:3470 sql_help.c:3472 +#: sql_help.c:3473 sql_help.c:3474 sql_help.c:3757 msgid "role_name" msgstr "имÑ_роли" #: sql_help.c:222 sql_help.c:436 sql_help.c:1011 sql_help.c:1013 -#: sql_help.c:1287 sql_help.c:1756 sql_help.c:1760 sql_help.c:1846 -#: sql_help.c:1850 sql_help.c:1943 sql_help.c:2258 sql_help.c:2268 -#: sql_help.c:2290 sql_help.c:3187 sql_help.c:3202 sql_help.c:3204 -#: sql_help.c:3618 sql_help.c:3619 sql_help.c:3628 sql_help.c:3669 -#: sql_help.c:3670 sql_help.c:3671 sql_help.c:3672 sql_help.c:3673 -#: sql_help.c:3674 sql_help.c:3707 sql_help.c:3708 sql_help.c:3713 -#: sql_help.c:3718 sql_help.c:3857 sql_help.c:3858 sql_help.c:3867 -#: sql_help.c:3908 sql_help.c:3909 sql_help.c:3910 sql_help.c:3911 -#: sql_help.c:3912 sql_help.c:3913 sql_help.c:3960 sql_help.c:3962 -#: sql_help.c:3995 sql_help.c:4051 sql_help.c:4052 sql_help.c:4061 -#: sql_help.c:4102 sql_help.c:4103 sql_help.c:4104 sql_help.c:4105 -#: sql_help.c:4106 sql_help.c:4107 +#: sql_help.c:1291 sql_help.c:1760 sql_help.c:1764 sql_help.c:1850 +#: sql_help.c:1854 sql_help.c:1947 sql_help.c:2262 sql_help.c:2272 +#: sql_help.c:2294 sql_help.c:3191 sql_help.c:3206 sql_help.c:3208 +#: sql_help.c:3622 sql_help.c:3623 sql_help.c:3632 sql_help.c:3673 +#: sql_help.c:3674 sql_help.c:3675 sql_help.c:3676 sql_help.c:3677 +#: sql_help.c:3678 sql_help.c:3711 sql_help.c:3712 sql_help.c:3717 +#: sql_help.c:3722 sql_help.c:3861 sql_help.c:3862 sql_help.c:3871 +#: sql_help.c:3912 sql_help.c:3913 sql_help.c:3914 sql_help.c:3915 +#: sql_help.c:3916 sql_help.c:3917 sql_help.c:3964 sql_help.c:3966 +#: sql_help.c:3999 sql_help.c:4055 sql_help.c:4056 sql_help.c:4065 +#: sql_help.c:4106 sql_help.c:4107 sql_help.c:4108 sql_help.c:4109 +#: sql_help.c:4110 sql_help.c:4111 msgid "expression" msgstr "выражение" @@ -3758,9 +3769,9 @@ msgstr "ограничение_домена" #: sql_help.c:227 sql_help.c:229 sql_help.c:232 sql_help.c:451 sql_help.c:452 #: sql_help.c:993 sql_help.c:1026 sql_help.c:1027 sql_help.c:1028 -#: sql_help.c:1048 sql_help.c:1411 sql_help.c:1413 sql_help.c:1759 -#: sql_help.c:1845 sql_help.c:1849 sql_help.c:2257 sql_help.c:2267 -#: sql_help.c:3199 +#: sql_help.c:1048 sql_help.c:1415 sql_help.c:1417 sql_help.c:1763 +#: sql_help.c:1849 sql_help.c:1853 sql_help.c:2261 sql_help.c:2271 +#: sql_help.c:3203 msgid "constraint_name" msgstr "имÑ_ограничениÑ" @@ -3784,72 +3795,72 @@ msgstr "где Ñлемент_объект:" #: sql_help.c:318 sql_help.c:319 sql_help.c:324 sql_help.c:328 sql_help.c:330 #: sql_help.c:332 sql_help.c:333 sql_help.c:334 sql_help.c:335 sql_help.c:336 #: sql_help.c:337 sql_help.c:338 sql_help.c:339 sql_help.c:340 sql_help.c:343 -#: sql_help.c:344 sql_help.c:1403 sql_help.c:1408 sql_help.c:1415 -#: sql_help.c:1416 sql_help.c:1417 sql_help.c:1418 sql_help.c:1419 -#: sql_help.c:1420 sql_help.c:1421 sql_help.c:1426 sql_help.c:1428 -#: sql_help.c:1432 sql_help.c:1434 sql_help.c:1438 sql_help.c:1439 -#: sql_help.c:1442 sql_help.c:1443 sql_help.c:1444 sql_help.c:1445 +#: sql_help.c:344 sql_help.c:1407 sql_help.c:1412 sql_help.c:1419 +#: sql_help.c:1420 sql_help.c:1421 sql_help.c:1422 sql_help.c:1423 +#: sql_help.c:1424 sql_help.c:1425 sql_help.c:1430 sql_help.c:1432 +#: sql_help.c:1436 sql_help.c:1438 sql_help.c:1442 sql_help.c:1443 #: sql_help.c:1446 sql_help.c:1447 sql_help.c:1448 sql_help.c:1449 -#: sql_help.c:1450 sql_help.c:1455 sql_help.c:1456 sql_help.c:3535 -#: sql_help.c:3540 sql_help.c:3541 sql_help.c:3542 sql_help.c:3543 -#: sql_help.c:3549 sql_help.c:3550 sql_help.c:3551 sql_help.c:3552 +#: sql_help.c:1450 sql_help.c:1451 sql_help.c:1452 sql_help.c:1453 +#: sql_help.c:1454 sql_help.c:1459 sql_help.c:1460 sql_help.c:3539 +#: sql_help.c:3544 sql_help.c:3545 sql_help.c:3546 sql_help.c:3547 #: sql_help.c:3553 sql_help.c:3554 sql_help.c:3555 sql_help.c:3556 +#: sql_help.c:3557 sql_help.c:3558 sql_help.c:3559 sql_help.c:3560 msgid "object_name" msgstr "имÑ_объекта" # well-spelled: агр -#: sql_help.c:310 sql_help.c:1404 sql_help.c:3538 +#: sql_help.c:310 sql_help.c:1408 sql_help.c:3542 msgid "aggregate_name" msgstr "имÑ_агр_функции" -#: sql_help.c:312 sql_help.c:1406 sql_help.c:1674 sql_help.c:1678 -#: sql_help.c:1680 sql_help.c:2662 +#: sql_help.c:312 sql_help.c:1410 sql_help.c:1678 sql_help.c:1682 +#: sql_help.c:1684 sql_help.c:2666 msgid "source_type" msgstr "иÑходный_тип" -#: sql_help.c:313 sql_help.c:1407 sql_help.c:1675 sql_help.c:1679 -#: sql_help.c:1681 sql_help.c:2663 +#: sql_help.c:313 sql_help.c:1411 sql_help.c:1679 sql_help.c:1683 +#: sql_help.c:1685 sql_help.c:2667 msgid "target_type" msgstr "целевой_тип" -#: sql_help.c:320 sql_help.c:741 sql_help.c:1422 sql_help.c:1676 -#: sql_help.c:1711 sql_help.c:1774 sql_help.c:1996 sql_help.c:2027 -#: sql_help.c:2426 sql_help.c:3121 sql_help.c:3453 sql_help.c:3544 -#: sql_help.c:3647 sql_help.c:3651 sql_help.c:3655 sql_help.c:3658 -#: sql_help.c:3886 sql_help.c:3890 sql_help.c:3894 sql_help.c:3897 -#: sql_help.c:4080 sql_help.c:4084 sql_help.c:4088 sql_help.c:4091 +#: sql_help.c:320 sql_help.c:741 sql_help.c:1426 sql_help.c:1680 +#: sql_help.c:1715 sql_help.c:1778 sql_help.c:2000 sql_help.c:2031 +#: sql_help.c:2430 sql_help.c:3125 sql_help.c:3457 sql_help.c:3548 +#: sql_help.c:3651 sql_help.c:3655 sql_help.c:3659 sql_help.c:3662 +#: sql_help.c:3890 sql_help.c:3894 sql_help.c:3898 sql_help.c:3901 +#: sql_help.c:4084 sql_help.c:4088 sql_help.c:4092 sql_help.c:4095 msgid "function_name" msgstr "имÑ_функции" -#: sql_help.c:325 sql_help.c:734 sql_help.c:1429 sql_help.c:2020 +#: sql_help.c:325 sql_help.c:734 sql_help.c:1433 sql_help.c:2024 msgid "operator_name" msgstr "имÑ_оператора" -#: sql_help.c:326 sql_help.c:670 sql_help.c:674 sql_help.c:678 sql_help.c:1430 -#: sql_help.c:1997 sql_help.c:2780 +#: sql_help.c:326 sql_help.c:670 sql_help.c:674 sql_help.c:678 sql_help.c:1434 +#: sql_help.c:2001 sql_help.c:2784 msgid "left_type" msgstr "тип_Ñлева" -#: sql_help.c:327 sql_help.c:671 sql_help.c:675 sql_help.c:679 sql_help.c:1431 -#: sql_help.c:1998 sql_help.c:2781 +#: sql_help.c:327 sql_help.c:671 sql_help.c:675 sql_help.c:679 sql_help.c:1435 +#: sql_help.c:2002 sql_help.c:2785 msgid "right_type" msgstr "тип_Ñправа" #: sql_help.c:329 sql_help.c:331 sql_help.c:697 sql_help.c:700 sql_help.c:703 #: sql_help.c:732 sql_help.c:744 sql_help.c:752 sql_help.c:755 sql_help.c:758 -#: sql_help.c:1433 sql_help.c:1435 sql_help.c:2017 sql_help.c:2038 -#: sql_help.c:2273 sql_help.c:2790 sql_help.c:2799 +#: sql_help.c:1437 sql_help.c:1439 sql_help.c:2021 sql_help.c:2042 +#: sql_help.c:2277 sql_help.c:2794 sql_help.c:2803 msgid "index_method" msgstr "метод_индекÑа" -#: sql_help.c:341 sql_help.c:1044 sql_help.c:1451 sql_help.c:1884 -#: sql_help.c:2249 sql_help.c:2395 sql_help.c:2913 sql_help.c:3135 -#: sql_help.c:3467 +#: sql_help.c:341 sql_help.c:1044 sql_help.c:1455 sql_help.c:1888 +#: sql_help.c:2253 sql_help.c:2399 sql_help.c:2917 sql_help.c:3139 +#: sql_help.c:3471 msgid "type_name" msgstr "имÑ_типа" -#: sql_help.c:342 sql_help.c:1452 sql_help.c:1883 sql_help.c:2396 -#: sql_help.c:2620 sql_help.c:2914 sql_help.c:3127 sql_help.c:3459 +#: sql_help.c:342 sql_help.c:1456 sql_help.c:1887 sql_help.c:2400 +#: sql_help.c:2624 sql_help.c:2918 sql_help.c:3131 sql_help.c:3463 msgid "lang_name" msgstr "имÑ_Ñзыка" @@ -3857,16 +3868,16 @@ msgstr "имÑ_Ñзыка" msgid "and aggregate_signature is:" msgstr "и Ñигнатура_агр_функции:" -#: sql_help.c:368 sql_help.c:1546 sql_help.c:1801 +#: sql_help.c:368 sql_help.c:1550 sql_help.c:1805 msgid "handler_function" msgstr "функциÑ_обработчик" -#: sql_help.c:369 sql_help.c:1802 +#: sql_help.c:369 sql_help.c:1806 msgid "validator_function" msgstr "функциÑ_проверки" #: sql_help.c:418 sql_help.c:495 sql_help.c:626 sql_help.c:988 sql_help.c:1187 -#: sql_help.c:2264 sql_help.c:2265 sql_help.c:2281 sql_help.c:2282 +#: sql_help.c:2268 sql_help.c:2269 sql_help.c:2285 sql_help.c:2286 msgid "action" msgstr "дейÑтвие" @@ -3876,17 +3887,17 @@ msgstr "дейÑтвие" #: sql_help.c:645 sql_help.c:647 sql_help.c:880 sql_help.c:990 sql_help.c:1003 #: sql_help.c:1007 sql_help.c:1008 sql_help.c:1012 sql_help.c:1014 #: sql_help.c:1015 sql_help.c:1016 sql_help.c:1018 sql_help.c:1021 -#: sql_help.c:1023 sql_help.c:1286 sql_help.c:1289 sql_help.c:1309 -#: sql_help.c:1410 sql_help.c:1512 sql_help.c:1517 sql_help.c:1531 -#: sql_help.c:1532 sql_help.c:1533 sql_help.c:1833 sql_help.c:1881 -#: sql_help.c:1942 sql_help.c:1977 sql_help.c:2157 sql_help.c:2237 -#: sql_help.c:2250 sql_help.c:2269 sql_help.c:2271 sql_help.c:2278 -#: sql_help.c:2289 sql_help.c:2306 sql_help.c:2429 sql_help.c:2565 -#: sql_help.c:3106 sql_help.c:3107 sql_help.c:3186 sql_help.c:3201 -#: sql_help.c:3203 sql_help.c:3205 sql_help.c:3438 sql_help.c:3439 -#: sql_help.c:3537 sql_help.c:3678 sql_help.c:3917 sql_help.c:3959 -#: sql_help.c:3961 sql_help.c:3963 sql_help.c:3980 sql_help.c:3983 -#: sql_help.c:4111 +#: sql_help.c:1023 sql_help.c:1290 sql_help.c:1293 sql_help.c:1313 +#: sql_help.c:1414 sql_help.c:1516 sql_help.c:1521 sql_help.c:1535 +#: sql_help.c:1536 sql_help.c:1537 sql_help.c:1837 sql_help.c:1885 +#: sql_help.c:1946 sql_help.c:1981 sql_help.c:2161 sql_help.c:2241 +#: sql_help.c:2254 sql_help.c:2273 sql_help.c:2275 sql_help.c:2282 +#: sql_help.c:2293 sql_help.c:2310 sql_help.c:2433 sql_help.c:2569 +#: sql_help.c:3110 sql_help.c:3111 sql_help.c:3190 sql_help.c:3205 +#: sql_help.c:3207 sql_help.c:3209 sql_help.c:3442 sql_help.c:3443 +#: sql_help.c:3541 sql_help.c:3682 sql_help.c:3921 sql_help.c:3963 +#: sql_help.c:3965 sql_help.c:3967 sql_help.c:3984 sql_help.c:3987 +#: sql_help.c:4115 msgid "column_name" msgstr "имÑ_Ñтолбца" @@ -3899,20 +3910,20 @@ msgid "where action is one of:" msgstr "где допуÑтимое дейÑтвие:" #: sql_help.c:428 sql_help.c:433 sql_help.c:1004 sql_help.c:1009 -#: sql_help.c:1202 sql_help.c:1206 sql_help.c:1754 sql_help.c:1834 -#: sql_help.c:2016 sql_help.c:2238 sql_help.c:2474 sql_help.c:3288 +#: sql_help.c:1202 sql_help.c:1206 sql_help.c:1758 sql_help.c:1838 +#: sql_help.c:2020 sql_help.c:2242 sql_help.c:2478 sql_help.c:3292 msgid "data_type" msgstr "тип_данных" #: sql_help.c:429 sql_help.c:434 sql_help.c:1005 sql_help.c:1010 -#: sql_help.c:1203 sql_help.c:1207 sql_help.c:1755 sql_help.c:1837 -#: sql_help.c:1944 sql_help.c:2239 sql_help.c:2475 sql_help.c:2481 -#: sql_help.c:3196 +#: sql_help.c:1203 sql_help.c:1207 sql_help.c:1759 sql_help.c:1841 +#: sql_help.c:1948 sql_help.c:2243 sql_help.c:2479 sql_help.c:2485 +#: sql_help.c:3200 msgid "collation" msgstr "правило_Ñортировки" -#: sql_help.c:430 sql_help.c:1006 sql_help.c:1838 sql_help.c:2240 -#: sql_help.c:2251 +#: sql_help.c:430 sql_help.c:1006 sql_help.c:1842 sql_help.c:2244 +#: sql_help.c:2255 msgid "column_constraint" msgstr "ограничение_Ñтолбца" @@ -3925,50 +3936,50 @@ msgstr "целое" msgid "attribute_option" msgstr "атрибут" -#: sql_help.c:450 sql_help.c:1024 sql_help.c:1839 sql_help.c:2241 -#: sql_help.c:2252 +#: sql_help.c:450 sql_help.c:1024 sql_help.c:1843 sql_help.c:2245 +#: sql_help.c:2256 msgid "table_constraint" msgstr "ограничение_таблицы" #: sql_help.c:453 sql_help.c:454 sql_help.c:455 sql_help.c:456 sql_help.c:1029 -#: sql_help.c:1030 sql_help.c:1031 sql_help.c:1032 sql_help.c:1453 +#: sql_help.c:1030 sql_help.c:1031 sql_help.c:1032 sql_help.c:1457 msgid "trigger_name" msgstr "имÑ_триггера" #: sql_help.c:457 sql_help.c:458 sql_help.c:1042 sql_help.c:1043 -#: sql_help.c:1840 sql_help.c:2244 +#: sql_help.c:1844 sql_help.c:2248 msgid "parent_table" msgstr "таблица_родитель" -#: sql_help.c:515 sql_help.c:565 sql_help.c:628 sql_help.c:1167 sql_help.c:1786 +#: sql_help.c:515 sql_help.c:565 sql_help.c:628 sql_help.c:1167 sql_help.c:1790 msgid "extension_name" msgstr "имÑ_раÑширениÑ" -#: sql_help.c:517 sql_help.c:1885 +#: sql_help.c:517 sql_help.c:1889 msgid "execution_cost" msgstr "ÑтоимоÑÑ‚ÑŒ_выполнениÑ" -#: sql_help.c:518 sql_help.c:1886 +#: sql_help.c:518 sql_help.c:1890 msgid "result_rows" msgstr "Ñтрок_в_результате" #: sql_help.c:539 sql_help.c:541 sql_help.c:813 sql_help.c:821 sql_help.c:825 #: sql_help.c:828 sql_help.c:831 sql_help.c:1241 sql_help.c:1249 -#: sql_help.c:1252 sql_help.c:1254 sql_help.c:1256 sql_help.c:2131 -#: sql_help.c:2133 sql_help.c:2136 sql_help.c:2137 sql_help.c:3105 -#: sql_help.c:3109 sql_help.c:3112 sql_help.c:3114 sql_help.c:3116 -#: sql_help.c:3118 sql_help.c:3120 sql_help.c:3126 sql_help.c:3128 -#: sql_help.c:3130 sql_help.c:3132 sql_help.c:3134 sql_help.c:3136 +#: sql_help.c:1253 sql_help.c:1256 sql_help.c:1259 sql_help.c:2135 +#: sql_help.c:2137 sql_help.c:2140 sql_help.c:2141 sql_help.c:3109 +#: sql_help.c:3113 sql_help.c:3116 sql_help.c:3118 sql_help.c:3120 +#: sql_help.c:3122 sql_help.c:3124 sql_help.c:3130 sql_help.c:3132 +#: sql_help.c:3134 sql_help.c:3136 sql_help.c:3138 sql_help.c:3140 msgid "role_specification" msgstr "указание_роли" -#: sql_help.c:540 sql_help.c:542 sql_help.c:1268 sql_help.c:1729 -#: sql_help.c:2139 sql_help.c:2550 sql_help.c:2947 sql_help.c:3763 +#: sql_help.c:540 sql_help.c:542 sql_help.c:1272 sql_help.c:1733 +#: sql_help.c:2143 sql_help.c:2554 sql_help.c:2951 sql_help.c:3767 msgid "user_name" msgstr "имÑ_пользователÑ" -#: sql_help.c:543 sql_help.c:833 sql_help.c:1257 sql_help.c:2138 -#: sql_help.c:3137 +#: sql_help.c:543 sql_help.c:833 sql_help.c:1261 sql_help.c:2142 +#: sql_help.c:3141 msgid "where role_specification can be:" msgstr "где допуÑтимое указание_роли:" @@ -3976,110 +3987,111 @@ msgstr "где допуÑтимое указание_роли:" msgid "group_name" msgstr "имÑ_группы" -#: sql_help.c:563 sql_help.c:1734 sql_help.c:1948 sql_help.c:1980 -#: sql_help.c:2247 sql_help.c:2255 sql_help.c:2287 sql_help.c:2309 -#: sql_help.c:2321 sql_help.c:3133 sql_help.c:3465 +#: sql_help.c:563 sql_help.c:1738 sql_help.c:1952 sql_help.c:1984 +#: sql_help.c:2251 sql_help.c:2259 sql_help.c:2291 sql_help.c:2313 +#: sql_help.c:2325 sql_help.c:3137 sql_help.c:3469 msgid "tablespace_name" msgstr "табл_проÑтранÑтво" #: sql_help.c:567 sql_help.c:570 sql_help.c:649 sql_help.c:651 sql_help.c:1039 -#: sql_help.c:1041 sql_help.c:1946 sql_help.c:1978 sql_help.c:2245 -#: sql_help.c:2253 sql_help.c:2285 sql_help.c:2307 +#: sql_help.c:1041 sql_help.c:1950 sql_help.c:1982 sql_help.c:2249 +#: sql_help.c:2257 sql_help.c:2289 sql_help.c:2311 msgid "storage_parameter" msgstr "параметр_хранениÑ" -#: sql_help.c:593 sql_help.c:1427 sql_help.c:3548 +#: sql_help.c:593 sql_help.c:1431 sql_help.c:3552 msgid "large_object_oid" msgstr "oid_большого_объекта" #: sql_help.c:648 sql_help.c:1037 sql_help.c:1046 sql_help.c:1049 -#: sql_help.c:1349 +#: sql_help.c:1353 msgid "index_name" msgstr "имÑ_индекÑа" -#: sql_help.c:680 sql_help.c:2001 +#: sql_help.c:680 sql_help.c:2005 msgid "res_proc" msgstr "процедура_ограничениÑ" -#: sql_help.c:681 sql_help.c:2002 +#: sql_help.c:681 sql_help.c:2006 msgid "join_proc" msgstr "процедура_ÑоединениÑ" -#: sql_help.c:733 sql_help.c:745 sql_help.c:2019 +#: sql_help.c:733 sql_help.c:745 sql_help.c:2023 msgid "strategy_number" msgstr "номер_Ñтратегии" #: sql_help.c:735 sql_help.c:736 sql_help.c:739 sql_help.c:740 sql_help.c:746 -#: sql_help.c:747 sql_help.c:749 sql_help.c:750 sql_help.c:2021 sql_help.c:2022 -#: sql_help.c:2025 sql_help.c:2026 +#: sql_help.c:747 sql_help.c:749 sql_help.c:750 sql_help.c:2025 sql_help.c:2026 +#: sql_help.c:2029 sql_help.c:2030 msgid "op_type" msgstr "тип_операции" -#: sql_help.c:737 sql_help.c:2023 +#: sql_help.c:737 sql_help.c:2027 msgid "sort_family_name" msgstr "ÑемейÑтво_Ñортировки" -#: sql_help.c:738 sql_help.c:748 sql_help.c:2024 +#: sql_help.c:738 sql_help.c:748 sql_help.c:2028 msgid "support_number" msgstr "номер_опорной_процедуры" -#: sql_help.c:742 sql_help.c:1677 sql_help.c:2028 sql_help.c:2398 -#: sql_help.c:2400 +#: sql_help.c:742 sql_help.c:1681 sql_help.c:2032 sql_help.c:2402 +#: sql_help.c:2404 msgid "argument_type" msgstr "тип_аргумента" #: sql_help.c:773 sql_help.c:776 sql_help.c:843 sql_help.c:879 sql_help.c:1163 -#: sql_help.c:1166 sql_help.c:1308 sql_help.c:1348 sql_help.c:1412 -#: sql_help.c:1437 sql_help.c:1441 sql_help.c:1454 sql_help.c:1511 -#: sql_help.c:1516 sql_help.c:1832 sql_help.c:1940 sql_help.c:1976 -#: sql_help.c:2051 sql_help.c:2108 sql_help.c:2156 sql_help.c:2236 -#: sql_help.c:2248 sql_help.c:2305 sql_help.c:2423 sql_help.c:2599 -#: sql_help.c:2816 sql_help.c:2833 sql_help.c:2923 sql_help.c:3103 -#: sql_help.c:3108 sql_help.c:3153 sql_help.c:3184 sql_help.c:3435 -#: sql_help.c:3440 sql_help.c:3536 sql_help.c:3633 sql_help.c:3635 -#: sql_help.c:3684 sql_help.c:3723 sql_help.c:3872 sql_help.c:3874 -#: sql_help.c:3923 sql_help.c:3957 sql_help.c:3979 sql_help.c:3981 -#: sql_help.c:3982 sql_help.c:4066 sql_help.c:4068 sql_help.c:4117 +#: sql_help.c:1166 sql_help.c:1312 sql_help.c:1352 sql_help.c:1416 +#: sql_help.c:1441 sql_help.c:1445 sql_help.c:1458 sql_help.c:1515 +#: sql_help.c:1520 sql_help.c:1836 sql_help.c:1944 sql_help.c:1980 +#: sql_help.c:2055 sql_help.c:2112 sql_help.c:2160 sql_help.c:2240 +#: sql_help.c:2252 sql_help.c:2309 sql_help.c:2427 sql_help.c:2603 +#: sql_help.c:2820 sql_help.c:2837 sql_help.c:2927 sql_help.c:3107 +#: sql_help.c:3112 sql_help.c:3157 sql_help.c:3188 sql_help.c:3439 +#: sql_help.c:3444 sql_help.c:3540 sql_help.c:3637 sql_help.c:3639 +#: sql_help.c:3688 sql_help.c:3727 sql_help.c:3876 sql_help.c:3878 +#: sql_help.c:3927 sql_help.c:3961 sql_help.c:3983 sql_help.c:3985 +#: sql_help.c:3986 sql_help.c:4070 sql_help.c:4072 sql_help.c:4121 msgid "table_name" msgstr "имÑ_таблицы" -#: sql_help.c:778 sql_help.c:2053 +#: sql_help.c:778 sql_help.c:2057 msgid "using_expression" msgstr "выражение_иÑпользованиÑ" -#: sql_help.c:779 sql_help.c:2054 +#: sql_help.c:779 sql_help.c:2058 msgid "check_expression" msgstr "выражение_проверки" -#: sql_help.c:817 sql_help.c:1245 sql_help.c:1920 sql_help.c:2085 -#: sql_help.c:2533 +#: sql_help.c:817 sql_help.c:1245 sql_help.c:1924 sql_help.c:2089 +#: sql_help.c:2537 msgid "password" msgstr "пароль" -#: sql_help.c:818 sql_help.c:1246 sql_help.c:1921 sql_help.c:2086 -#: sql_help.c:2534 +#: sql_help.c:818 sql_help.c:1246 sql_help.c:1925 sql_help.c:2090 +#: sql_help.c:2538 msgid "timestamp" msgstr "timestamp" -#: sql_help.c:822 sql_help.c:826 sql_help.c:829 sql_help.c:832 sql_help.c:3113 -#: sql_help.c:3445 +#: sql_help.c:822 sql_help.c:826 sql_help.c:829 sql_help.c:832 sql_help.c:1250 +#: sql_help.c:1254 sql_help.c:1257 sql_help.c:1260 sql_help.c:3117 +#: sql_help.c:3449 msgid "database_name" msgstr "имÑ_БД" -#: sql_help.c:873 sql_help.c:2151 +#: sql_help.c:873 sql_help.c:2155 msgid "increment" msgstr "шаг" -#: sql_help.c:874 sql_help.c:2152 +#: sql_help.c:874 sql_help.c:2156 msgid "minvalue" msgstr "мин_значение" -#: sql_help.c:875 sql_help.c:2153 +#: sql_help.c:875 sql_help.c:2157 msgid "maxvalue" msgstr "макÑ_значение" -#: sql_help.c:876 sql_help.c:2154 sql_help.c:3631 sql_help.c:3721 -#: sql_help.c:3870 sql_help.c:3999 sql_help.c:4064 +#: sql_help.c:876 sql_help.c:2158 sql_help.c:3635 sql_help.c:3725 +#: sql_help.c:3874 sql_help.c:4003 sql_help.c:4068 msgid "start" msgstr "начальное_значение" @@ -4087,7 +4099,7 @@ msgstr "начальное_значение" msgid "restart" msgstr "значение_перезапуÑка" -#: sql_help.c:878 sql_help.c:2155 +#: sql_help.c:878 sql_help.c:2159 msgid "cache" msgstr "кеш" @@ -4103,7 +4115,7 @@ msgstr "имÑ_правила_перезапиÑи" msgid "and table_constraint_using_index is:" msgstr "и ограничение_таблицы_Ñ_индекÑом:" -#: sql_help.c:1065 sql_help.c:1068 sql_help.c:2324 +#: sql_help.c:1065 sql_help.c:1068 sql_help.c:2328 msgid "tablespace_option" msgstr "параметр_табл_проÑтранÑтва" @@ -4124,7 +4136,7 @@ msgid "new_dictionary" msgstr "новый_Ñловарь" #: sql_help.c:1191 sql_help.c:1201 sql_help.c:1204 sql_help.c:1205 -#: sql_help.c:2473 +#: sql_help.c:2477 msgid "attribute_name" msgstr "имÑ_атрибута" @@ -4140,1389 +4152,1389 @@ msgstr "новое_значение_перечиÑлениÑ" msgid "existing_enum_value" msgstr "ÑущеÑтвующее_значение_перечиÑлениÑ" -#: sql_help.c:1269 sql_help.c:1841 sql_help.c:2167 sql_help.c:2551 -#: sql_help.c:2948 sql_help.c:3119 sql_help.c:3154 sql_help.c:3451 +#: sql_help.c:1273 sql_help.c:1845 sql_help.c:2171 sql_help.c:2555 +#: sql_help.c:2952 sql_help.c:3123 sql_help.c:3158 sql_help.c:3455 msgid "server_name" msgstr "имÑ_Ñервера" -#: sql_help.c:1297 sql_help.c:1300 sql_help.c:2566 +#: sql_help.c:1301 sql_help.c:1304 sql_help.c:2570 msgid "view_option_name" msgstr "имÑ_параметра_предÑтавлениÑ" -#: sql_help.c:1298 sql_help.c:2567 +#: sql_help.c:1302 sql_help.c:2571 msgid "view_option_value" msgstr "значение_параметра_предÑтавлениÑ" -#: sql_help.c:1323 sql_help.c:3779 sql_help.c:3781 sql_help.c:3805 +#: sql_help.c:1327 sql_help.c:3783 sql_help.c:3785 sql_help.c:3809 msgid "transaction_mode" msgstr "режим_транзакции" -#: sql_help.c:1324 sql_help.c:3782 sql_help.c:3806 +#: sql_help.c:1328 sql_help.c:3786 sql_help.c:3810 msgid "where transaction_mode is one of:" msgstr "где допуÑтимый режим_транзакции:" -#: sql_help.c:1409 +#: sql_help.c:1413 msgid "relation_name" msgstr "имÑ_отношениÑ" -#: sql_help.c:1414 sql_help.c:3115 sql_help.c:3447 +#: sql_help.c:1418 sql_help.c:3119 sql_help.c:3451 msgid "domain_name" msgstr "имÑ_домена" -#: sql_help.c:1436 +#: sql_help.c:1440 msgid "policy_name" msgstr "имÑ_политики" -#: sql_help.c:1440 +#: sql_help.c:1444 msgid "rule_name" msgstr "имÑ_правила" -#: sql_help.c:1457 +#: sql_help.c:1461 msgid "text" msgstr "текÑÑ‚" -#: sql_help.c:1482 sql_help.c:3297 sql_help.c:3485 +#: sql_help.c:1486 sql_help.c:3301 sql_help.c:3489 msgid "transaction_id" msgstr "код_транзакции" -#: sql_help.c:1513 sql_help.c:1519 sql_help.c:3223 +#: sql_help.c:1517 sql_help.c:1523 sql_help.c:3227 msgid "filename" msgstr "имÑ_файла" -#: sql_help.c:1514 sql_help.c:1520 sql_help.c:2110 sql_help.c:2111 -#: sql_help.c:2112 +#: sql_help.c:1518 sql_help.c:1524 sql_help.c:2114 sql_help.c:2115 +#: sql_help.c:2116 msgid "command" msgstr "команда" -#: sql_help.c:1518 sql_help.c:1981 sql_help.c:2310 sql_help.c:2568 -#: sql_help.c:2586 sql_help.c:3188 +#: sql_help.c:1522 sql_help.c:1985 sql_help.c:2314 sql_help.c:2572 +#: sql_help.c:2590 sql_help.c:3192 msgid "query" msgstr "запроÑ" -#: sql_help.c:1522 sql_help.c:2993 +#: sql_help.c:1526 sql_help.c:2997 msgid "where option can be one of:" msgstr "где допуÑтимый параметр:" -#: sql_help.c:1523 +#: sql_help.c:1527 msgid "format_name" msgstr "имÑ_формата" -#: sql_help.c:1524 sql_help.c:1525 sql_help.c:1528 sql_help.c:2994 -#: sql_help.c:2995 sql_help.c:2996 sql_help.c:2997 sql_help.c:2998 +#: sql_help.c:1528 sql_help.c:1529 sql_help.c:1532 sql_help.c:2998 +#: sql_help.c:2999 sql_help.c:3000 sql_help.c:3001 sql_help.c:3002 msgid "boolean" msgstr "логичеÑкое_значение" -#: sql_help.c:1526 +#: sql_help.c:1530 msgid "delimiter_character" msgstr "Ñимвол_разделитель" -#: sql_help.c:1527 +#: sql_help.c:1531 msgid "null_string" msgstr "предÑтавление_NULL" -#: sql_help.c:1529 +#: sql_help.c:1533 msgid "quote_character" msgstr "Ñимвол_кавычек" -#: sql_help.c:1530 +#: sql_help.c:1534 msgid "escape_character" msgstr "ÑпецÑимвол" -#: sql_help.c:1534 +#: sql_help.c:1538 msgid "encoding_name" msgstr "имÑ_кодировки" -#: sql_help.c:1545 +#: sql_help.c:1549 msgid "access_method_type" msgstr "тип_метода_доÑтупа" -#: sql_help.c:1611 sql_help.c:1630 sql_help.c:1633 +#: sql_help.c:1615 sql_help.c:1634 sql_help.c:1637 msgid "arg_data_type" msgstr "тип_данных_аргумента" -#: sql_help.c:1612 sql_help.c:1634 sql_help.c:1642 +#: sql_help.c:1616 sql_help.c:1638 sql_help.c:1646 msgid "sfunc" msgstr "функциÑ_ÑоÑтоÑниÑ" -#: sql_help.c:1613 sql_help.c:1635 sql_help.c:1643 +#: sql_help.c:1617 sql_help.c:1639 sql_help.c:1647 msgid "state_data_type" msgstr "тип_данных_ÑоÑтоÑниÑ" -#: sql_help.c:1614 sql_help.c:1636 sql_help.c:1644 +#: sql_help.c:1618 sql_help.c:1640 sql_help.c:1648 msgid "state_data_size" msgstr "размер_данных_ÑоÑтоÑниÑ" -#: sql_help.c:1615 sql_help.c:1637 sql_help.c:1645 +#: sql_help.c:1619 sql_help.c:1641 sql_help.c:1649 msgid "ffunc" msgstr "функциÑ_завершениÑ" -#: sql_help.c:1616 sql_help.c:1646 +#: sql_help.c:1620 sql_help.c:1650 msgid "combinefunc" msgstr "комбинирующаÑ_функциÑ" -#: sql_help.c:1617 sql_help.c:1647 +#: sql_help.c:1621 sql_help.c:1651 msgid "serialfunc" msgstr "функциÑ_Ñериализации" -#: sql_help.c:1618 sql_help.c:1648 +#: sql_help.c:1622 sql_help.c:1652 msgid "deserialfunc" msgstr "функциÑ_деÑериализации" -#: sql_help.c:1619 sql_help.c:1638 sql_help.c:1649 +#: sql_help.c:1623 sql_help.c:1642 sql_help.c:1653 msgid "initial_condition" msgstr "начальное_уÑловие" -#: sql_help.c:1620 sql_help.c:1650 +#: sql_help.c:1624 sql_help.c:1654 msgid "msfunc" msgstr "функциÑ_ÑоÑтоÑниÑ_движ" -#: sql_help.c:1621 sql_help.c:1651 +#: sql_help.c:1625 sql_help.c:1655 msgid "minvfunc" msgstr "обратнаÑ_функциÑ_движ" -#: sql_help.c:1622 sql_help.c:1652 +#: sql_help.c:1626 sql_help.c:1656 msgid "mstate_data_type" msgstr "тип_данных_ÑоÑтоÑниÑ_движ" -#: sql_help.c:1623 sql_help.c:1653 +#: sql_help.c:1627 sql_help.c:1657 msgid "mstate_data_size" msgstr "размер_данных_ÑоÑтоÑниÑ_движ" -#: sql_help.c:1624 sql_help.c:1654 +#: sql_help.c:1628 sql_help.c:1658 msgid "mffunc" msgstr "функциÑ_завершениÑ_движ" -#: sql_help.c:1625 sql_help.c:1655 +#: sql_help.c:1629 sql_help.c:1659 msgid "minitial_condition" msgstr "начальное_уÑловие_движ" -#: sql_help.c:1626 sql_help.c:1656 +#: sql_help.c:1630 sql_help.c:1660 msgid "sort_operator" msgstr "оператор_Ñортировки" -#: sql_help.c:1639 +#: sql_help.c:1643 msgid "or the old syntax" msgstr "или Ñтарый ÑинтакÑиÑ" -#: sql_help.c:1641 +#: sql_help.c:1645 msgid "base_type" msgstr "базовый_тип" -#: sql_help.c:1695 +#: sql_help.c:1699 msgid "locale" msgstr "код_локали" -#: sql_help.c:1696 sql_help.c:1732 +#: sql_help.c:1700 sql_help.c:1736 msgid "lc_collate" msgstr "код_правила_Ñортировки" -#: sql_help.c:1697 sql_help.c:1733 +#: sql_help.c:1701 sql_help.c:1737 msgid "lc_ctype" msgstr "код_клаÑÑификации_Ñимволов" -#: sql_help.c:1699 +#: sql_help.c:1703 msgid "existing_collation" msgstr "ÑущеÑтвующее_правило_Ñортировки" -#: sql_help.c:1709 +#: sql_help.c:1713 msgid "source_encoding" msgstr "иÑходнаÑ_кодировка" -#: sql_help.c:1710 +#: sql_help.c:1714 msgid "dest_encoding" msgstr "целеваÑ_кодировка" -#: sql_help.c:1730 sql_help.c:2350 +#: sql_help.c:1734 sql_help.c:2354 msgid "template" msgstr "шаблон" -#: sql_help.c:1731 +#: sql_help.c:1735 msgid "encoding" msgstr "кодировка" -#: sql_help.c:1757 +#: sql_help.c:1761 msgid "constraint" msgstr "ограничение" -#: sql_help.c:1758 +#: sql_help.c:1762 msgid "where constraint is:" msgstr "где ограничение:" -#: sql_help.c:1772 sql_help.c:2107 sql_help.c:2422 +#: sql_help.c:1776 sql_help.c:2111 sql_help.c:2426 msgid "event" msgstr "Ñобытие" -#: sql_help.c:1773 +#: sql_help.c:1777 msgid "filter_variable" msgstr "переменнаÑ_фильтра" -#: sql_help.c:1788 +#: sql_help.c:1792 msgid "version" msgstr "верÑиÑ" -#: sql_help.c:1789 +#: sql_help.c:1793 msgid "old_version" msgstr "ÑтараÑ_верÑиÑ" -#: sql_help.c:1844 sql_help.c:2256 +#: sql_help.c:1848 sql_help.c:2260 msgid "where column_constraint is:" msgstr "где ограничение_Ñтолбца:" -#: sql_help.c:1847 sql_help.c:1879 sql_help.c:2259 +#: sql_help.c:1851 sql_help.c:1883 sql_help.c:2263 msgid "default_expr" msgstr "выражение_по_умолчанию" -#: sql_help.c:1848 sql_help.c:2266 +#: sql_help.c:1852 sql_help.c:2270 msgid "and table_constraint is:" msgstr "и ограничение_таблицы:" -#: sql_help.c:1880 +#: sql_help.c:1884 msgid "rettype" msgstr "тип_возврата" -#: sql_help.c:1882 +#: sql_help.c:1886 msgid "column_type" msgstr "тип_Ñтолбца" -#: sql_help.c:1890 +#: sql_help.c:1894 msgid "definition" msgstr "определение" -#: sql_help.c:1891 +#: sql_help.c:1895 msgid "obj_file" msgstr "объектный_файл" -#: sql_help.c:1892 +#: sql_help.c:1896 msgid "link_symbol" msgstr "Ñимвол_в_ÑкÑпорте" -#: sql_help.c:1893 +#: sql_help.c:1897 msgid "attribute" msgstr "атрибут" -#: sql_help.c:1927 sql_help.c:2092 sql_help.c:2540 +#: sql_help.c:1931 sql_help.c:2096 sql_help.c:2544 msgid "uid" msgstr "uid" -#: sql_help.c:1941 +#: sql_help.c:1945 msgid "method" msgstr "метод" -#: sql_help.c:1945 sql_help.c:2291 sql_help.c:3197 +#: sql_help.c:1949 sql_help.c:2295 sql_help.c:3201 msgid "opclass" msgstr "клаÑÑ_оператора" -#: sql_help.c:1949 sql_help.c:2277 +#: sql_help.c:1953 sql_help.c:2281 msgid "predicate" msgstr "предикат" -#: sql_help.c:1961 +#: sql_help.c:1965 msgid "call_handler" msgstr "обработчик_вызова" -#: sql_help.c:1962 +#: sql_help.c:1966 msgid "inline_handler" msgstr "обработчик_внедрённого_кода" -#: sql_help.c:1963 +#: sql_help.c:1967 msgid "valfunction" msgstr "функциÑ_проверки" -#: sql_help.c:1999 +#: sql_help.c:2003 msgid "com_op" msgstr "коммут_оператор" -#: sql_help.c:2000 +#: sql_help.c:2004 msgid "neg_op" msgstr "обратный_оператор" -#: sql_help.c:2018 +#: sql_help.c:2022 msgid "family_name" msgstr "имÑ_ÑемейÑтва" -#: sql_help.c:2029 +#: sql_help.c:2033 msgid "storage_type" msgstr "тип_хранениÑ" -#: sql_help.c:2109 sql_help.c:2425 sql_help.c:2602 sql_help.c:3207 -#: sql_help.c:3622 sql_help.c:3624 sql_help.c:3712 sql_help.c:3714 -#: sql_help.c:3861 sql_help.c:3863 sql_help.c:3966 sql_help.c:4055 -#: sql_help.c:4057 +#: sql_help.c:2113 sql_help.c:2429 sql_help.c:2606 sql_help.c:3211 +#: sql_help.c:3626 sql_help.c:3628 sql_help.c:3716 sql_help.c:3718 +#: sql_help.c:3865 sql_help.c:3867 sql_help.c:3970 sql_help.c:4059 +#: sql_help.c:4061 msgid "condition" msgstr "уÑловие" -#: sql_help.c:2113 sql_help.c:2428 +#: sql_help.c:2117 sql_help.c:2432 msgid "where event can be one of:" msgstr "где допуÑтимое Ñобытие:" -#: sql_help.c:2132 sql_help.c:2134 +#: sql_help.c:2136 sql_help.c:2138 msgid "schema_element" msgstr "Ñлемент_Ñхемы" -#: sql_help.c:2168 +#: sql_help.c:2172 msgid "server_type" msgstr "тип_Ñервера" -#: sql_help.c:2169 +#: sql_help.c:2173 msgid "server_version" msgstr "верÑиÑ_Ñервера" -#: sql_help.c:2170 sql_help.c:3117 sql_help.c:3449 +#: sql_help.c:2174 sql_help.c:3121 sql_help.c:3453 msgid "fdw_name" msgstr "имÑ_обёртки_Ñторонних_данных" -#: sql_help.c:2242 +#: sql_help.c:2246 msgid "source_table" msgstr "иÑходнаÑ_таблица" -#: sql_help.c:2243 +#: sql_help.c:2247 msgid "like_option" msgstr "параметр_порождениÑ" -#: sql_help.c:2260 sql_help.c:2261 sql_help.c:2270 sql_help.c:2272 -#: sql_help.c:2276 +#: sql_help.c:2264 sql_help.c:2265 sql_help.c:2274 sql_help.c:2276 +#: sql_help.c:2280 msgid "index_parameters" msgstr "параметры_индекÑа" -#: sql_help.c:2262 sql_help.c:2279 +#: sql_help.c:2266 sql_help.c:2283 msgid "reftable" msgstr "целеваÑ_таблица" -#: sql_help.c:2263 sql_help.c:2280 +#: sql_help.c:2267 sql_help.c:2284 msgid "refcolumn" msgstr "целевой_Ñтолбец" -#: sql_help.c:2274 +#: sql_help.c:2278 msgid "exclude_element" msgstr "объект_иÑключениÑ" -#: sql_help.c:2275 sql_help.c:3629 sql_help.c:3719 sql_help.c:3868 -#: sql_help.c:3997 sql_help.c:4062 +#: sql_help.c:2279 sql_help.c:3633 sql_help.c:3723 sql_help.c:3872 +#: sql_help.c:4001 sql_help.c:4066 msgid "operator" msgstr "оператор" -#: sql_help.c:2283 +#: sql_help.c:2287 msgid "and like_option is:" msgstr "и параметр_порождениÑ:" -#: sql_help.c:2284 +#: sql_help.c:2288 msgid "index_parameters in UNIQUE, PRIMARY KEY, and EXCLUDE constraints are:" msgstr "параметры_индекÑа в ограничениÑÑ… UNIQUE, PRIMARY KEY и EXCLUDE:" -#: sql_help.c:2288 +#: sql_help.c:2292 msgid "exclude_element in an EXCLUDE constraint is:" msgstr "объект_иÑÐºÐ»ÑŽÑ‡ÐµÐ½Ð¸Ñ Ð² ограничении EXCLUDE:" -#: sql_help.c:2323 +#: sql_help.c:2327 msgid "directory" msgstr "каталог" -#: sql_help.c:2337 +#: sql_help.c:2341 msgid "parser_name" msgstr "имÑ_анализатора" -#: sql_help.c:2338 +#: sql_help.c:2342 msgid "source_config" msgstr "иÑходнаÑ_конфигурациÑ" -#: sql_help.c:2367 +#: sql_help.c:2371 msgid "start_function" msgstr "функциÑ_начала" -#: sql_help.c:2368 +#: sql_help.c:2372 msgid "gettoken_function" msgstr "функциÑ_выдачи_фрагмента" -#: sql_help.c:2369 +#: sql_help.c:2373 msgid "end_function" msgstr "функциÑ_окончаниÑ" -#: sql_help.c:2370 +#: sql_help.c:2374 msgid "lextypes_function" msgstr "функциÑ_лекÑ_типов" -#: sql_help.c:2371 +#: sql_help.c:2375 msgid "headline_function" msgstr "функциÑ_ÑозданиÑ_выдержек" -#: sql_help.c:2383 +#: sql_help.c:2387 msgid "init_function" msgstr "функциÑ_инициализации" -#: sql_help.c:2384 +#: sql_help.c:2388 msgid "lexize_function" msgstr "функциÑ_выделениÑ_лекÑем" -#: sql_help.c:2397 +#: sql_help.c:2401 msgid "from_sql_function_name" msgstr "имÑ_функции_из_sql" -#: sql_help.c:2399 +#: sql_help.c:2403 msgid "to_sql_function_name" msgstr "имÑ_функции_в_sql" -#: sql_help.c:2424 +#: sql_help.c:2428 msgid "referenced_table_name" msgstr "ÑÑылающаÑÑÑ_таблица" -#: sql_help.c:2427 +#: sql_help.c:2431 msgid "arguments" msgstr "аргументы" -#: sql_help.c:2477 sql_help.c:3557 +#: sql_help.c:2481 sql_help.c:3561 msgid "label" msgstr "метка" -#: sql_help.c:2479 +#: sql_help.c:2483 msgid "subtype" msgstr "подтип" -#: sql_help.c:2480 +#: sql_help.c:2484 msgid "subtype_operator_class" msgstr "клаÑÑ_оператора_подтипа" -#: sql_help.c:2482 +#: sql_help.c:2486 msgid "canonical_function" msgstr "каноничеÑкаÑ_функциÑ" -#: sql_help.c:2483 +#: sql_help.c:2487 msgid "subtype_diff_function" msgstr "функциÑ_различий_подтипа" -#: sql_help.c:2485 +#: sql_help.c:2489 msgid "input_function" msgstr "функциÑ_ввода" -#: sql_help.c:2486 +#: sql_help.c:2490 msgid "output_function" msgstr "функциÑ_вывода" -#: sql_help.c:2487 +#: sql_help.c:2491 msgid "receive_function" msgstr "функциÑ_получениÑ" -#: sql_help.c:2488 +#: sql_help.c:2492 msgid "send_function" msgstr "функциÑ_отправки" -#: sql_help.c:2489 +#: sql_help.c:2493 msgid "type_modifier_input_function" msgstr "функциÑ_ввода_модификатора_типа" -#: sql_help.c:2490 +#: sql_help.c:2494 msgid "type_modifier_output_function" msgstr "функциÑ_вывода_модификатора_типа" -#: sql_help.c:2491 +#: sql_help.c:2495 msgid "analyze_function" msgstr "функциÑ_анализа" -#: sql_help.c:2492 +#: sql_help.c:2496 msgid "internallength" msgstr "внутр_длина" -#: sql_help.c:2493 +#: sql_help.c:2497 msgid "alignment" msgstr "выравнивание" -#: sql_help.c:2494 +#: sql_help.c:2498 msgid "storage" msgstr "хранение" -#: sql_help.c:2495 +#: sql_help.c:2499 msgid "like_type" msgstr "тип_образец" -#: sql_help.c:2496 +#: sql_help.c:2500 msgid "category" msgstr "категориÑ" -#: sql_help.c:2497 +#: sql_help.c:2501 msgid "preferred" msgstr "предпочитаемый" -#: sql_help.c:2498 +#: sql_help.c:2502 msgid "default" msgstr "по_умолчанию" -#: sql_help.c:2499 +#: sql_help.c:2503 msgid "element" msgstr "Ñлемент" -#: sql_help.c:2500 +#: sql_help.c:2504 msgid "delimiter" msgstr "разделитель" -#: sql_help.c:2501 +#: sql_help.c:2505 msgid "collatable" msgstr "Ñортируемый" -#: sql_help.c:2598 sql_help.c:3183 sql_help.c:3617 sql_help.c:3706 -#: sql_help.c:3856 sql_help.c:3956 sql_help.c:4050 +#: sql_help.c:2602 sql_help.c:3187 sql_help.c:3621 sql_help.c:3710 +#: sql_help.c:3860 sql_help.c:3960 sql_help.c:4054 msgid "with_query" msgstr "запроÑ_WITH" -#: sql_help.c:2600 sql_help.c:3185 sql_help.c:3636 sql_help.c:3642 -#: sql_help.c:3645 sql_help.c:3649 sql_help.c:3653 sql_help.c:3661 -#: sql_help.c:3875 sql_help.c:3881 sql_help.c:3884 sql_help.c:3888 -#: sql_help.c:3892 sql_help.c:3900 sql_help.c:3958 sql_help.c:4069 -#: sql_help.c:4075 sql_help.c:4078 sql_help.c:4082 sql_help.c:4086 -#: sql_help.c:4094 +#: sql_help.c:2604 sql_help.c:3189 sql_help.c:3640 sql_help.c:3646 +#: sql_help.c:3649 sql_help.c:3653 sql_help.c:3657 sql_help.c:3665 +#: sql_help.c:3879 sql_help.c:3885 sql_help.c:3888 sql_help.c:3892 +#: sql_help.c:3896 sql_help.c:3904 sql_help.c:3962 sql_help.c:4073 +#: sql_help.c:4079 sql_help.c:4082 sql_help.c:4086 sql_help.c:4090 +#: sql_help.c:4098 msgid "alias" msgstr "пÑевдоним" -#: sql_help.c:2601 +#: sql_help.c:2605 msgid "using_list" msgstr "ÑпиÑок_USING" -#: sql_help.c:2603 sql_help.c:3024 sql_help.c:3264 sql_help.c:3967 +#: sql_help.c:2607 sql_help.c:3028 sql_help.c:3268 sql_help.c:3971 msgid "cursor_name" msgstr "имÑ_курÑора" -#: sql_help.c:2604 sql_help.c:3191 sql_help.c:3968 +#: sql_help.c:2608 sql_help.c:3195 sql_help.c:3972 msgid "output_expression" msgstr "выражение_результата" -#: sql_help.c:2605 sql_help.c:3192 sql_help.c:3620 sql_help.c:3709 -#: sql_help.c:3859 sql_help.c:3969 sql_help.c:4053 +#: sql_help.c:2609 sql_help.c:3196 sql_help.c:3624 sql_help.c:3713 +#: sql_help.c:3863 sql_help.c:3973 sql_help.c:4057 msgid "output_name" msgstr "имÑ_результата" -#: sql_help.c:2621 +#: sql_help.c:2625 msgid "code" msgstr "внедрённый_код" -#: sql_help.c:2972 +#: sql_help.c:2976 msgid "parameter" msgstr "параметр" -#: sql_help.c:2991 sql_help.c:2992 sql_help.c:3289 +#: sql_help.c:2995 sql_help.c:2996 sql_help.c:3293 msgid "statement" msgstr "оператор" -#: sql_help.c:3023 sql_help.c:3263 +#: sql_help.c:3027 sql_help.c:3267 msgid "direction" msgstr "направление" -#: sql_help.c:3025 sql_help.c:3265 +#: sql_help.c:3029 sql_help.c:3269 msgid "where direction can be empty or one of:" msgstr "где допуÑтимое направление пуÑтое или:" -#: sql_help.c:3026 sql_help.c:3027 sql_help.c:3028 sql_help.c:3029 -#: sql_help.c:3030 sql_help.c:3266 sql_help.c:3267 sql_help.c:3268 -#: sql_help.c:3269 sql_help.c:3270 sql_help.c:3630 sql_help.c:3632 -#: sql_help.c:3720 sql_help.c:3722 sql_help.c:3869 sql_help.c:3871 -#: sql_help.c:3998 sql_help.c:4000 sql_help.c:4063 sql_help.c:4065 +#: sql_help.c:3030 sql_help.c:3031 sql_help.c:3032 sql_help.c:3033 +#: sql_help.c:3034 sql_help.c:3270 sql_help.c:3271 sql_help.c:3272 +#: sql_help.c:3273 sql_help.c:3274 sql_help.c:3634 sql_help.c:3636 +#: sql_help.c:3724 sql_help.c:3726 sql_help.c:3873 sql_help.c:3875 +#: sql_help.c:4002 sql_help.c:4004 sql_help.c:4067 sql_help.c:4069 msgid "count" msgstr "чиÑло" -#: sql_help.c:3110 sql_help.c:3442 +#: sql_help.c:3114 sql_help.c:3446 msgid "sequence_name" msgstr "имÑ_поÑледовательноÑти" -#: sql_help.c:3123 sql_help.c:3455 +#: sql_help.c:3127 sql_help.c:3459 msgid "arg_name" msgstr "имÑ_аргумента" -#: sql_help.c:3124 sql_help.c:3456 +#: sql_help.c:3128 sql_help.c:3460 msgid "arg_type" msgstr "тип_аргумента" -#: sql_help.c:3129 sql_help.c:3461 +#: sql_help.c:3133 sql_help.c:3465 msgid "loid" msgstr "код_БО" -#: sql_help.c:3152 +#: sql_help.c:3156 msgid "remote_schema" msgstr "удалённаÑ_Ñхема" -#: sql_help.c:3155 +#: sql_help.c:3159 msgid "local_schema" msgstr "локальнаÑ_Ñхема" -#: sql_help.c:3189 +#: sql_help.c:3193 msgid "conflict_target" msgstr "объект_конфликта" -#: sql_help.c:3190 +#: sql_help.c:3194 msgid "conflict_action" msgstr "дейÑтвие_при_конфликте" -#: sql_help.c:3193 +#: sql_help.c:3197 msgid "where conflict_target can be one of:" msgstr "где допуÑтимый объект_конфликта:" -#: sql_help.c:3194 +#: sql_help.c:3198 msgid "index_column_name" msgstr "имÑ_Ñтолбца_индекÑа" -#: sql_help.c:3195 +#: sql_help.c:3199 msgid "index_expression" msgstr "выражение_индекÑа" -#: sql_help.c:3198 +#: sql_help.c:3202 msgid "index_predicate" msgstr "предикат_индекÑа" -#: sql_help.c:3200 +#: sql_help.c:3204 msgid "and conflict_action is one of:" msgstr "а допуÑтимое дейÑтвие_при_конфликте:" -#: sql_help.c:3206 sql_help.c:3964 +#: sql_help.c:3210 sql_help.c:3968 msgid "sub-SELECT" msgstr "вложенный_SELECT" -#: sql_help.c:3215 sql_help.c:3278 sql_help.c:3940 +#: sql_help.c:3219 sql_help.c:3282 sql_help.c:3944 msgid "channel" msgstr "канал" -#: sql_help.c:3237 +#: sql_help.c:3241 msgid "lockmode" msgstr "режим_блокировки" -#: sql_help.c:3238 +#: sql_help.c:3242 msgid "where lockmode is one of:" msgstr "где допуÑтимый режим_блокировки:" -#: sql_help.c:3279 +#: sql_help.c:3283 msgid "payload" msgstr "Ñообщение_нагрузка" -#: sql_help.c:3306 +#: sql_help.c:3310 msgid "old_role" msgstr "ÑтараÑ_роль" -#: sql_help.c:3307 +#: sql_help.c:3311 msgid "new_role" msgstr "новаÑ_роль" -#: sql_help.c:3332 sql_help.c:3493 sql_help.c:3501 +#: sql_help.c:3336 sql_help.c:3497 sql_help.c:3505 msgid "savepoint_name" msgstr "имÑ_точки_ÑохранениÑ" -#: sql_help.c:3534 +#: sql_help.c:3538 msgid "provider" msgstr "поÑтавщик" -#: sql_help.c:3621 sql_help.c:3663 sql_help.c:3665 sql_help.c:3711 -#: sql_help.c:3860 sql_help.c:3902 sql_help.c:3904 sql_help.c:4054 -#: sql_help.c:4096 sql_help.c:4098 +#: sql_help.c:3625 sql_help.c:3667 sql_help.c:3669 sql_help.c:3715 +#: sql_help.c:3864 sql_help.c:3906 sql_help.c:3908 sql_help.c:4058 +#: sql_help.c:4100 sql_help.c:4102 msgid "from_item" msgstr "иÑточник_данных" -#: sql_help.c:3623 sql_help.c:3675 sql_help.c:3862 sql_help.c:3914 -#: sql_help.c:4056 sql_help.c:4108 +#: sql_help.c:3627 sql_help.c:3679 sql_help.c:3866 sql_help.c:3918 +#: sql_help.c:4060 sql_help.c:4112 msgid "grouping_element" msgstr "Ñлемент_группированиÑ" -#: sql_help.c:3625 sql_help.c:3715 sql_help.c:3864 sql_help.c:4058 +#: sql_help.c:3629 sql_help.c:3719 sql_help.c:3868 sql_help.c:4062 msgid "window_name" msgstr "имÑ_окна" -#: sql_help.c:3626 sql_help.c:3716 sql_help.c:3865 sql_help.c:4059 +#: sql_help.c:3630 sql_help.c:3720 sql_help.c:3869 sql_help.c:4063 msgid "window_definition" msgstr "определение_окна" -#: sql_help.c:3627 sql_help.c:3641 sql_help.c:3679 sql_help.c:3717 -#: sql_help.c:3866 sql_help.c:3880 sql_help.c:3918 sql_help.c:4060 -#: sql_help.c:4074 sql_help.c:4112 +#: sql_help.c:3631 sql_help.c:3645 sql_help.c:3683 sql_help.c:3721 +#: sql_help.c:3870 sql_help.c:3884 sql_help.c:3922 sql_help.c:4064 +#: sql_help.c:4078 sql_help.c:4116 msgid "select" msgstr "select" -#: sql_help.c:3634 sql_help.c:3873 sql_help.c:4067 +#: sql_help.c:3638 sql_help.c:3877 sql_help.c:4071 msgid "where from_item can be one of:" msgstr "где допуÑтимый иÑточник_данных:" -#: sql_help.c:3637 sql_help.c:3643 sql_help.c:3646 sql_help.c:3650 -#: sql_help.c:3662 sql_help.c:3876 sql_help.c:3882 sql_help.c:3885 -#: sql_help.c:3889 sql_help.c:3901 sql_help.c:4070 sql_help.c:4076 -#: sql_help.c:4079 sql_help.c:4083 sql_help.c:4095 +#: sql_help.c:3641 sql_help.c:3647 sql_help.c:3650 sql_help.c:3654 +#: sql_help.c:3666 sql_help.c:3880 sql_help.c:3886 sql_help.c:3889 +#: sql_help.c:3893 sql_help.c:3905 sql_help.c:4074 sql_help.c:4080 +#: sql_help.c:4083 sql_help.c:4087 sql_help.c:4099 msgid "column_alias" msgstr "пÑевдоним_Ñтолбца" -#: sql_help.c:3638 sql_help.c:3877 sql_help.c:4071 +#: sql_help.c:3642 sql_help.c:3881 sql_help.c:4075 msgid "sampling_method" msgstr "метод_выборки" -#: sql_help.c:3639 sql_help.c:3648 sql_help.c:3652 sql_help.c:3656 -#: sql_help.c:3659 sql_help.c:3878 sql_help.c:3887 sql_help.c:3891 -#: sql_help.c:3895 sql_help.c:3898 sql_help.c:4072 sql_help.c:4081 -#: sql_help.c:4085 sql_help.c:4089 sql_help.c:4092 +#: sql_help.c:3643 sql_help.c:3652 sql_help.c:3656 sql_help.c:3660 +#: sql_help.c:3663 sql_help.c:3882 sql_help.c:3891 sql_help.c:3895 +#: sql_help.c:3899 sql_help.c:3902 sql_help.c:4076 sql_help.c:4085 +#: sql_help.c:4089 sql_help.c:4093 sql_help.c:4096 msgid "argument" msgstr "аргумент" -#: sql_help.c:3640 sql_help.c:3879 sql_help.c:4073 +#: sql_help.c:3644 sql_help.c:3883 sql_help.c:4077 msgid "seed" msgstr "начальное_чиÑло" -#: sql_help.c:3644 sql_help.c:3677 sql_help.c:3883 sql_help.c:3916 -#: sql_help.c:4077 sql_help.c:4110 +#: sql_help.c:3648 sql_help.c:3681 sql_help.c:3887 sql_help.c:3920 +#: sql_help.c:4081 sql_help.c:4114 msgid "with_query_name" msgstr "имÑ_запроÑа_WITH" -#: sql_help.c:3654 sql_help.c:3657 sql_help.c:3660 sql_help.c:3893 -#: sql_help.c:3896 sql_help.c:3899 sql_help.c:4087 sql_help.c:4090 -#: sql_help.c:4093 +#: sql_help.c:3658 sql_help.c:3661 sql_help.c:3664 sql_help.c:3897 +#: sql_help.c:3900 sql_help.c:3903 sql_help.c:4091 sql_help.c:4094 +#: sql_help.c:4097 msgid "column_definition" msgstr "определение_Ñтолбца" -#: sql_help.c:3664 sql_help.c:3903 sql_help.c:4097 +#: sql_help.c:3668 sql_help.c:3907 sql_help.c:4101 msgid "join_type" msgstr "тип_ÑоединениÑ" -#: sql_help.c:3666 sql_help.c:3905 sql_help.c:4099 +#: sql_help.c:3670 sql_help.c:3909 sql_help.c:4103 msgid "join_condition" msgstr "уÑловие_ÑоединениÑ" -#: sql_help.c:3667 sql_help.c:3906 sql_help.c:4100 +#: sql_help.c:3671 sql_help.c:3910 sql_help.c:4104 msgid "join_column" msgstr "Ñтолбец_ÑоединениÑ" -#: sql_help.c:3668 sql_help.c:3907 sql_help.c:4101 +#: sql_help.c:3672 sql_help.c:3911 sql_help.c:4105 msgid "and grouping_element can be one of:" msgstr "где допуÑтимый Ñлемент_группированиÑ:" -#: sql_help.c:3676 sql_help.c:3915 sql_help.c:4109 +#: sql_help.c:3680 sql_help.c:3919 sql_help.c:4113 msgid "and with_query is:" msgstr "и запроÑ_WITH:" -#: sql_help.c:3680 sql_help.c:3919 sql_help.c:4113 +#: sql_help.c:3684 sql_help.c:3923 sql_help.c:4117 msgid "values" msgstr "значениÑ" -#: sql_help.c:3681 sql_help.c:3920 sql_help.c:4114 +#: sql_help.c:3685 sql_help.c:3924 sql_help.c:4118 msgid "insert" msgstr "insert" -#: sql_help.c:3682 sql_help.c:3921 sql_help.c:4115 +#: sql_help.c:3686 sql_help.c:3925 sql_help.c:4119 msgid "update" msgstr "update" -#: sql_help.c:3683 sql_help.c:3922 sql_help.c:4116 +#: sql_help.c:3687 sql_help.c:3926 sql_help.c:4120 msgid "delete" msgstr "delete" -#: sql_help.c:3710 +#: sql_help.c:3714 msgid "new_table" msgstr "новаÑ_таблица" -#: sql_help.c:3735 +#: sql_help.c:3739 msgid "timezone" msgstr "чаÑовой_поÑÑ" -#: sql_help.c:3780 +#: sql_help.c:3784 msgid "snapshot_id" msgstr "код_Ñнимка" -#: sql_help.c:3965 +#: sql_help.c:3969 msgid "from_list" msgstr "ÑпиÑок_FROM" -#: sql_help.c:3996 +#: sql_help.c:4000 msgid "sort_expression" msgstr "выражение_Ñортировки" -#: sql_help.c:4123 sql_help.c:4863 +#: sql_help.c:4127 sql_help.c:4867 msgid "abort the current transaction" msgstr "прервать текущую транзакцию" -#: sql_help.c:4128 +#: sql_help.c:4132 msgid "change the definition of an aggregate function" msgstr "изменить определение агрегатной функции" -#: sql_help.c:4133 +#: sql_help.c:4137 msgid "change the definition of a collation" msgstr "изменить определение правила Ñортировки" -#: sql_help.c:4138 +#: sql_help.c:4142 msgid "change the definition of a conversion" msgstr "изменить определение преобразованиÑ" -#: sql_help.c:4143 +#: sql_help.c:4147 msgid "change a database" msgstr "изменить атрибуты базы данных" -#: sql_help.c:4148 +#: sql_help.c:4152 msgid "define default access privileges" msgstr "определить права доÑтупа по умолчанию" -#: sql_help.c:4153 +#: sql_help.c:4157 msgid "change the definition of a domain" msgstr "изменить определение домена" -#: sql_help.c:4158 +#: sql_help.c:4162 msgid "change the definition of an event trigger" msgstr "изменить определение Ñобытийного триггера" -#: sql_help.c:4163 +#: sql_help.c:4167 msgid "change the definition of an extension" msgstr "изменить определение раÑширениÑ" -#: sql_help.c:4168 +#: sql_help.c:4172 msgid "change the definition of a foreign-data wrapper" msgstr "изменить определение обёртки Ñторонних данных" -#: sql_help.c:4173 +#: sql_help.c:4177 msgid "change the definition of a foreign table" msgstr "изменить определение Ñторонней таблицы" -#: sql_help.c:4178 +#: sql_help.c:4182 msgid "change the definition of a function" msgstr "изменить определение функции" -#: sql_help.c:4183 +#: sql_help.c:4187 msgid "change role name or membership" msgstr "изменить Ð¸Ð¼Ñ Ñ€Ð¾Ð»Ð¸ или членÑтво" -#: sql_help.c:4188 +#: sql_help.c:4192 msgid "change the definition of an index" msgstr "изменить определение индекÑа" -#: sql_help.c:4193 +#: sql_help.c:4197 msgid "change the definition of a procedural language" msgstr "изменить определение процедурного Ñзыка" -#: sql_help.c:4198 +#: sql_help.c:4202 msgid "change the definition of a large object" msgstr "изменить определение большого объекта" -#: sql_help.c:4203 +#: sql_help.c:4207 msgid "change the definition of a materialized view" msgstr "изменить определение материализованного предÑтавлениÑ" -#: sql_help.c:4208 +#: sql_help.c:4212 msgid "change the definition of an operator" msgstr "изменить определение оператора" -#: sql_help.c:4213 +#: sql_help.c:4217 msgid "change the definition of an operator class" msgstr "изменить определение клаÑÑа операторов" -#: sql_help.c:4218 +#: sql_help.c:4222 msgid "change the definition of an operator family" msgstr "изменить определение ÑемейÑтва операторов" -#: sql_help.c:4223 +#: sql_help.c:4227 msgid "change the definition of a row level security policy" msgstr "изменить определение политики безопаÑноÑти на уровне Ñтрок" -#: sql_help.c:4228 sql_help.c:4298 +#: sql_help.c:4232 sql_help.c:4302 msgid "change a database role" msgstr "изменить роль Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð‘Ð”" -#: sql_help.c:4233 +#: sql_help.c:4237 msgid "change the definition of a rule" msgstr "изменить определение правила" -#: sql_help.c:4238 +#: sql_help.c:4242 msgid "change the definition of a schema" msgstr "изменить определение Ñхемы" -#: sql_help.c:4243 +#: sql_help.c:4247 msgid "change the definition of a sequence generator" msgstr "изменить определение генератора поÑледовательноÑти" -#: sql_help.c:4248 +#: sql_help.c:4252 msgid "change the definition of a foreign server" msgstr "изменить определение Ñтороннего Ñервера" -#: sql_help.c:4253 +#: sql_help.c:4257 msgid "change a server configuration parameter" msgstr "изменить параметр конфигурации Ñервера" -#: sql_help.c:4258 +#: sql_help.c:4262 msgid "change the definition of a table" msgstr "изменить определение таблицы" -#: sql_help.c:4263 +#: sql_help.c:4267 msgid "change the definition of a tablespace" msgstr "изменить определение табличного проÑтранÑтва" -#: sql_help.c:4268 +#: sql_help.c:4272 msgid "change the definition of a text search configuration" msgstr "изменить определение конфигурации текÑтового поиÑка" -#: sql_help.c:4273 +#: sql_help.c:4277 msgid "change the definition of a text search dictionary" msgstr "изменить определение ÑÐ»Ð¾Ð²Ð°Ñ€Ñ Ñ‚ÐµÐºÑтового поиÑка" -#: sql_help.c:4278 +#: sql_help.c:4282 msgid "change the definition of a text search parser" msgstr "изменить определение анализатора текÑтового поиÑка" -#: sql_help.c:4283 +#: sql_help.c:4287 msgid "change the definition of a text search template" msgstr "изменить определение шаблона текÑтового поиÑка" -#: sql_help.c:4288 +#: sql_help.c:4292 msgid "change the definition of a trigger" msgstr "изменить определение триггера" -#: sql_help.c:4293 +#: sql_help.c:4297 msgid "change the definition of a type" msgstr "изменить определение типа" -#: sql_help.c:4303 +#: sql_help.c:4307 msgid "change the definition of a user mapping" msgstr "изменить ÑопоÑтавление пользователей" -#: sql_help.c:4308 +#: sql_help.c:4312 msgid "change the definition of a view" msgstr "изменить определение предÑтавлениÑ" -#: sql_help.c:4313 +#: sql_help.c:4317 msgid "collect statistics about a database" msgstr "Ñобрать ÑтатиÑтику о базе данных" -#: sql_help.c:4318 sql_help.c:4928 +#: sql_help.c:4322 sql_help.c:4932 msgid "start a transaction block" msgstr "начать транзакцию" -#: sql_help.c:4323 +#: sql_help.c:4327 msgid "force a transaction log checkpoint" -msgstr "отметить контрольную точку в журнале транзакций" +msgstr "произвеÑти контрольную точку в журнале транзакций" -#: sql_help.c:4328 +#: sql_help.c:4332 msgid "close a cursor" msgstr "закрыть курÑор" -#: sql_help.c:4333 +#: sql_help.c:4337 msgid "cluster a table according to an index" msgstr "перегруппировать таблицу по индекÑу" -#: sql_help.c:4338 +#: sql_help.c:4342 msgid "define or change the comment of an object" msgstr "задать или изменить комментарий объекта" -#: sql_help.c:4343 sql_help.c:4763 +#: sql_help.c:4347 sql_help.c:4767 msgid "commit the current transaction" msgstr "зафикÑировать текущую транзакцию" -#: sql_help.c:4348 +#: sql_help.c:4352 msgid "commit a transaction that was earlier prepared for two-phase commit" msgstr "зафикÑировать транзакцию, ранее подготовленную Ð´Ð»Ñ Ð´Ð²ÑƒÑ…Ñ„Ð°Ð·Ð½Ð¾Ð¹ фикÑации" -#: sql_help.c:4353 +#: sql_help.c:4357 msgid "copy data between a file and a table" msgstr "импорт/ÑкÑпорт данных в файл" -#: sql_help.c:4358 +#: sql_help.c:4362 msgid "define a new access method" msgstr "Ñоздать новый метод доÑтупа" -#: sql_help.c:4363 +#: sql_help.c:4367 msgid "define a new aggregate function" msgstr "Ñоздать агрегатную функцию" -#: sql_help.c:4368 +#: sql_help.c:4372 msgid "define a new cast" msgstr "Ñоздать приведение типов" -#: sql_help.c:4373 +#: sql_help.c:4377 msgid "define a new collation" msgstr "Ñоздать правило Ñортировки" -#: sql_help.c:4378 +#: sql_help.c:4382 msgid "define a new encoding conversion" msgstr "Ñоздать преобразование кодировки" -#: sql_help.c:4383 +#: sql_help.c:4387 msgid "create a new database" msgstr "Ñоздать базу данных" -#: sql_help.c:4388 +#: sql_help.c:4392 msgid "define a new domain" msgstr "Ñоздать домен" -#: sql_help.c:4393 +#: sql_help.c:4397 msgid "define a new event trigger" msgstr "Ñоздать Ñобытийный триггер" -#: sql_help.c:4398 +#: sql_help.c:4402 msgid "install an extension" msgstr "уÑтановить раÑширение" -#: sql_help.c:4403 +#: sql_help.c:4407 msgid "define a new foreign-data wrapper" msgstr "Ñоздать обёртку Ñторонних данных" -#: sql_help.c:4408 +#: sql_help.c:4412 msgid "define a new foreign table" msgstr "Ñоздать Ñтороннюю таблицу" -#: sql_help.c:4413 +#: sql_help.c:4417 msgid "define a new function" msgstr "Ñоздать функцию" -#: sql_help.c:4418 sql_help.c:4458 sql_help.c:4533 +#: sql_help.c:4422 sql_help.c:4462 sql_help.c:4537 msgid "define a new database role" msgstr "Ñоздать роль Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð‘Ð”" -#: sql_help.c:4423 +#: sql_help.c:4427 msgid "define a new index" msgstr "Ñоздать индекÑ" -#: sql_help.c:4428 +#: sql_help.c:4432 msgid "define a new procedural language" msgstr "Ñоздать процедурный Ñзык" -#: sql_help.c:4433 +#: sql_help.c:4437 msgid "define a new materialized view" msgstr "Ñоздать материализованное предÑтавление" -#: sql_help.c:4438 +#: sql_help.c:4442 msgid "define a new operator" msgstr "Ñоздать оператор" -#: sql_help.c:4443 +#: sql_help.c:4447 msgid "define a new operator class" msgstr "Ñоздать клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð²" -#: sql_help.c:4448 +#: sql_help.c:4452 msgid "define a new operator family" msgstr "Ñоздать ÑемейÑтво операторов" -#: sql_help.c:4453 +#: sql_help.c:4457 msgid "define a new row level security policy for a table" msgstr "Ñоздать новую политику безопаÑноÑти на уровне Ñтрок Ð´Ð»Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ†Ñ‹" -#: sql_help.c:4463 +#: sql_help.c:4467 msgid "define a new rewrite rule" msgstr "Ñоздать правило перезапиÑи" -#: sql_help.c:4468 +#: sql_help.c:4472 msgid "define a new schema" msgstr "Ñоздать Ñхему" -#: sql_help.c:4473 +#: sql_help.c:4477 msgid "define a new sequence generator" msgstr "Ñоздать генератор поÑледовательноÑтей" -#: sql_help.c:4478 +#: sql_help.c:4482 msgid "define a new foreign server" msgstr "Ñоздать Ñторонний Ñервер" -#: sql_help.c:4483 +#: sql_help.c:4487 msgid "define a new table" msgstr "Ñоздать таблицу" -#: sql_help.c:4488 sql_help.c:4893 +#: sql_help.c:4492 sql_help.c:4897 msgid "define a new table from the results of a query" msgstr "Ñоздать таблицу из результатов запроÑа" -#: sql_help.c:4493 +#: sql_help.c:4497 msgid "define a new tablespace" msgstr "Ñоздать табличное проÑтранÑтво" -#: sql_help.c:4498 +#: sql_help.c:4502 msgid "define a new text search configuration" msgstr "Ñоздать конфигурацию текÑтового поиÑка" -#: sql_help.c:4503 +#: sql_help.c:4507 msgid "define a new text search dictionary" msgstr "Ñоздать Ñловарь текÑтового поиÑка" -#: sql_help.c:4508 +#: sql_help.c:4512 msgid "define a new text search parser" msgstr "Ñоздать анализатор текÑтового поиÑка" -#: sql_help.c:4513 +#: sql_help.c:4517 msgid "define a new text search template" msgstr "Ñоздать шаблон текÑтового поиÑка" -#: sql_help.c:4518 +#: sql_help.c:4522 msgid "define a new transform" msgstr "Ñоздать преобразование" -#: sql_help.c:4523 +#: sql_help.c:4527 msgid "define a new trigger" msgstr "Ñоздать триггер" -#: sql_help.c:4528 +#: sql_help.c:4532 msgid "define a new data type" msgstr "Ñоздать тип данных" -#: sql_help.c:4538 +#: sql_help.c:4542 msgid "define a new mapping of a user to a foreign server" msgstr "Ñоздать ÑопоÑтавление Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð´Ð»Ñ Ñтороннего Ñервера" -#: sql_help.c:4543 +#: sql_help.c:4547 msgid "define a new view" msgstr "Ñоздать предÑтавление" -#: sql_help.c:4548 +#: sql_help.c:4552 msgid "deallocate a prepared statement" msgstr "оÑвободить подготовленный оператор" -#: sql_help.c:4553 +#: sql_help.c:4557 msgid "define a cursor" msgstr "Ñоздать курÑор" -#: sql_help.c:4558 +#: sql_help.c:4562 msgid "delete rows of a table" msgstr "удалить запиÑи таблицы" -#: sql_help.c:4563 +#: sql_help.c:4567 msgid "discard session state" msgstr "очиÑтить ÑоÑтоÑние ÑеанÑа" -#: sql_help.c:4568 +#: sql_help.c:4572 msgid "execute an anonymous code block" msgstr "выполнить анонимный блок кода" -#: sql_help.c:4573 +#: sql_help.c:4577 msgid "remove an access method" msgstr "удалить метод доÑтупа" -#: sql_help.c:4578 +#: sql_help.c:4582 msgid "remove an aggregate function" msgstr "удалить агрегатную функцию" -#: sql_help.c:4583 +#: sql_help.c:4587 msgid "remove a cast" msgstr "удалить приведение типа" -#: sql_help.c:4588 +#: sql_help.c:4592 msgid "remove a collation" msgstr "удалить правило Ñортировки" -#: sql_help.c:4593 +#: sql_help.c:4597 msgid "remove a conversion" msgstr "удалить преобразование" -#: sql_help.c:4598 +#: sql_help.c:4602 msgid "remove a database" msgstr "удалить базу данных" -#: sql_help.c:4603 +#: sql_help.c:4607 msgid "remove a domain" msgstr "удалить домен" -#: sql_help.c:4608 +#: sql_help.c:4612 msgid "remove an event trigger" msgstr "удалить Ñобытийный триггер" -#: sql_help.c:4613 +#: sql_help.c:4617 msgid "remove an extension" msgstr "удалить раÑширение" -#: sql_help.c:4618 +#: sql_help.c:4622 msgid "remove a foreign-data wrapper" msgstr "удалить обёртку Ñторонних данных" -#: sql_help.c:4623 +#: sql_help.c:4627 msgid "remove a foreign table" msgstr "удалить Ñтороннюю таблицу" -#: sql_help.c:4628 +#: sql_help.c:4632 msgid "remove a function" msgstr "удалить функцию" -#: sql_help.c:4633 sql_help.c:4678 sql_help.c:4748 +#: sql_help.c:4637 sql_help.c:4682 sql_help.c:4752 msgid "remove a database role" msgstr "удалить роль Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð‘Ð”" -#: sql_help.c:4638 +#: sql_help.c:4642 msgid "remove an index" msgstr "удалить индекÑ" -#: sql_help.c:4643 +#: sql_help.c:4647 msgid "remove a procedural language" msgstr "удалить процедурный Ñзык" -#: sql_help.c:4648 +#: sql_help.c:4652 msgid "remove a materialized view" msgstr "удалить материализованное предÑтавление" -#: sql_help.c:4653 +#: sql_help.c:4657 msgid "remove an operator" msgstr "удалить оператор" -#: sql_help.c:4658 +#: sql_help.c:4662 msgid "remove an operator class" msgstr "удалить клаÑÑ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð²" -#: sql_help.c:4663 +#: sql_help.c:4667 msgid "remove an operator family" msgstr "удалить ÑемейÑтво операторов" -#: sql_help.c:4668 +#: sql_help.c:4672 msgid "remove database objects owned by a database role" msgstr "удалить объекты базы данных, принадлежащие роли" -#: sql_help.c:4673 +#: sql_help.c:4677 msgid "remove a row level security policy from a table" msgstr "удалить политику безопаÑноÑти на уровне Ñтрок из таблицы" -#: sql_help.c:4683 +#: sql_help.c:4687 msgid "remove a rewrite rule" msgstr "удалить правило перезапиÑи" -#: sql_help.c:4688 +#: sql_help.c:4692 msgid "remove a schema" msgstr "удалить Ñхему" -#: sql_help.c:4693 +#: sql_help.c:4697 msgid "remove a sequence" msgstr "удалить поÑледовательноÑÑ‚ÑŒ" -#: sql_help.c:4698 +#: sql_help.c:4702 msgid "remove a foreign server descriptor" msgstr "удалить опиÑание Ñтороннего Ñервера" -#: sql_help.c:4703 +#: sql_help.c:4707 msgid "remove a table" msgstr "удалить таблицу" -#: sql_help.c:4708 +#: sql_help.c:4712 msgid "remove a tablespace" msgstr "удалить табличное проÑтранÑтво" -#: sql_help.c:4713 +#: sql_help.c:4717 msgid "remove a text search configuration" msgstr "удалить конфигурацию текÑтового поиÑка" -#: sql_help.c:4718 +#: sql_help.c:4722 msgid "remove a text search dictionary" msgstr "удалить Ñловарь текÑтового поиÑка" -#: sql_help.c:4723 +#: sql_help.c:4727 msgid "remove a text search parser" msgstr "удалить анализатор текÑтового поиÑка" -#: sql_help.c:4728 +#: sql_help.c:4732 msgid "remove a text search template" msgstr "удалить шаблон текÑтового поиÑка" -#: sql_help.c:4733 +#: sql_help.c:4737 msgid "remove a transform" msgstr "удалить преобразование" -#: sql_help.c:4738 +#: sql_help.c:4742 msgid "remove a trigger" msgstr "удалить триггер" -#: sql_help.c:4743 +#: sql_help.c:4747 msgid "remove a data type" msgstr "удалить тип данных" -#: sql_help.c:4753 +#: sql_help.c:4757 msgid "remove a user mapping for a foreign server" msgstr "удалить ÑопоÑтавление Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð´Ð»Ñ Ñтороннего Ñервера" -#: sql_help.c:4758 +#: sql_help.c:4762 msgid "remove a view" msgstr "удалить предÑтавление" -#: sql_help.c:4768 +#: sql_help.c:4772 msgid "execute a prepared statement" msgstr "выполнить подготовленный оператор" -#: sql_help.c:4773 +#: sql_help.c:4777 msgid "show the execution plan of a statement" msgstr "показать план Ð²Ñ‹Ð¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ Ð¾Ð¿ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð°" -#: sql_help.c:4778 +#: sql_help.c:4782 msgid "retrieve rows from a query using a cursor" msgstr "получить результат запроÑа через курÑор" -#: sql_help.c:4783 +#: sql_help.c:4787 msgid "define access privileges" msgstr "определить права доÑтупа" -#: sql_help.c:4788 +#: sql_help.c:4792 msgid "import table definitions from a foreign server" msgstr "импортировать Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ Ñ‚Ð°Ð±Ð»Ð¸Ñ† Ñо Ñтороннего Ñервера" -#: sql_help.c:4793 +#: sql_help.c:4797 msgid "create new rows in a table" msgstr "добавить Ñтроки в таблицу" -#: sql_help.c:4798 +#: sql_help.c:4802 msgid "listen for a notification" msgstr "ожидать уведомлениÑ" -#: sql_help.c:4803 +#: sql_help.c:4807 msgid "load a shared library file" msgstr "загрузить файл разделÑемой библиотеки" -#: sql_help.c:4808 +#: sql_help.c:4812 msgid "lock a table" msgstr "заблокировать таблицу" -#: sql_help.c:4813 +#: sql_help.c:4817 msgid "position a cursor" msgstr "уÑтановить курÑор" -#: sql_help.c:4818 +#: sql_help.c:4822 msgid "generate a notification" msgstr "Ñгенерировать уведомление" -#: sql_help.c:4823 +#: sql_help.c:4827 msgid "prepare a statement for execution" msgstr "подготовить оператор Ð´Ð»Ñ Ð²Ñ‹Ð¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ" -#: sql_help.c:4828 +#: sql_help.c:4832 msgid "prepare the current transaction for two-phase commit" msgstr "подготовить текущую транзакцию Ð´Ð»Ñ Ð´Ð²ÑƒÑ…Ñ„Ð°Ð·Ð½Ð¾Ð¹ фикÑации" -#: sql_help.c:4833 +#: sql_help.c:4837 msgid "change the ownership of database objects owned by a database role" msgstr "изменить владельца объектов БД, принадлежащих заданной роли" -#: sql_help.c:4838 +#: sql_help.c:4842 msgid "replace the contents of a materialized view" msgstr "заменить Ñодержимое материализованного предÑтавлениÑ" -#: sql_help.c:4843 +#: sql_help.c:4847 msgid "rebuild indexes" msgstr "переÑтроить индекÑÑ‹" -#: sql_help.c:4848 +#: sql_help.c:4852 msgid "destroy a previously defined savepoint" msgstr "удалить ранее определённую точку ÑохранениÑ" -#: sql_help.c:4853 +#: sql_help.c:4857 msgid "restore the value of a run-time parameter to the default value" msgstr "воÑÑтановить иÑходное значение параметра выполнениÑ" -#: sql_help.c:4858 +#: sql_help.c:4862 msgid "remove access privileges" msgstr "удалить права доÑтупа" -#: sql_help.c:4868 +#: sql_help.c:4872 msgid "cancel a transaction that was earlier prepared for two-phase commit" msgstr "отменить транзакцию, подготовленную ранее Ð´Ð»Ñ Ð´Ð²ÑƒÑ…Ñ„Ð°Ð·Ð½Ð¾Ð¹ фикÑации" -#: sql_help.c:4873 +#: sql_help.c:4877 msgid "roll back to a savepoint" msgstr "откатитьÑÑ Ðº точке ÑохранениÑ" -#: sql_help.c:4878 +#: sql_help.c:4882 msgid "define a new savepoint within the current transaction" msgstr "определить новую точку ÑÐ¾Ñ…Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ Ð² текущей транзакции" -#: sql_help.c:4883 +#: sql_help.c:4887 msgid "define or change a security label applied to an object" msgstr "задать или изменить метку безопаÑноÑти, применённую к объекту" -#: sql_help.c:4888 sql_help.c:4933 sql_help.c:4963 +#: sql_help.c:4892 sql_help.c:4937 sql_help.c:4967 msgid "retrieve rows from a table or view" msgstr "выбрать Ñтроки из таблицы или предÑтавлениÑ" -#: sql_help.c:4898 +#: sql_help.c:4902 msgid "change a run-time parameter" msgstr "изменить параметр выполнениÑ" -#: sql_help.c:4903 +#: sql_help.c:4907 msgid "set constraint check timing for the current transaction" msgstr "уÑтановить Ð²Ñ€ÐµÐ¼Ñ Ð¿Ñ€Ð¾Ð²ÐµÑ€ÐºÐ¸ ограничений Ð´Ð»Ñ Ñ‚ÐµÐºÑƒÑ‰ÐµÐ¹ транзакции" -#: sql_help.c:4908 +#: sql_help.c:4912 msgid "set the current user identifier of the current session" msgstr "задать идентификатор текущего Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð² текущем ÑеанÑе" -#: sql_help.c:4913 +#: sql_help.c:4917 msgid "" "set the session user identifier and the current user identifier of the " "current session" @@ -5530,31 +5542,31 @@ msgstr "" "задать идентификатор Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ ÑеанÑа и идентификатор текущего " "Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð² текущем ÑеанÑе" -#: sql_help.c:4918 +#: sql_help.c:4922 msgid "set the characteristics of the current transaction" msgstr "задать ÑвойÑтва текущей транзакции" -#: sql_help.c:4923 +#: sql_help.c:4927 msgid "show the value of a run-time parameter" msgstr "показать значение параметра выполнениÑ" -#: sql_help.c:4938 +#: sql_help.c:4942 msgid "empty a table or set of tables" msgstr "опуÑтошить таблицу или набор таблиц" -#: sql_help.c:4943 +#: sql_help.c:4947 msgid "stop listening for a notification" msgstr "прекратить ожидание уведомлений" -#: sql_help.c:4948 +#: sql_help.c:4952 msgid "update rows of a table" msgstr "изменить Ñтроки таблицы" -#: sql_help.c:4953 +#: sql_help.c:4957 msgid "garbage-collect and optionally analyze a database" msgstr "произвеÑти Ñборку муÑора и проанализировать базу данных" -#: sql_help.c:4958 +#: sql_help.c:4962 msgid "compute a set of rows" msgstr "получить набор Ñтрок" @@ -5613,7 +5625,7 @@ msgstr "%s: не удалоÑÑŒ найти Ñвой иÑполнÑемый фа msgid "unrecognized value \"%s\" for \"%s\"; assuming \"%s\"\n" msgstr "нераÑпознанное значение \"%s\" Ð´Ð»Ñ \"%s\"; подразумеваетÑÑ \"%s\"\n" -#: tab-complete.c:3743 +#: tab-complete.c:3742 #, c-format msgid "" "tab completion query failed: %s\n" diff --git a/src/bin/scripts/po/es.po b/src/bin/scripts/po/es.po index e7ca4048d0..9909b1dc6e 100644 --- a/src/bin/scripts/po/es.po +++ b/src/bin/scripts/po/es.po @@ -12,7 +12,7 @@ msgid "" msgstr "" "Project-Id-Version: pgscripts (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:54+0000\n" +"POT-Creation-Date: 2017-08-27 21:52+0000\n" "PO-Revision-Date: 2016-05-25 11:14-0500\n" "Last-Translator: Carlos Chapi \n" "Language-Team: Castellano \n" @@ -223,8 +223,8 @@ msgstr " -h, --host=ANFITRIÓN nombre del servidor o directorio del socket msgid " -p, --port=PORT database server port\n" msgstr " -p, --port=PUERTO puerto del servidor\n" -#: clusterdb.c:284 createlang.c:247 dropdb.c:166 droplang.c:248 -#: reindexdb.c:418 vacuumdb.c:967 +#: clusterdb.c:284 createlang.c:247 dropdb.c:166 droplang.c:248 reindexdb.c:418 +#: vacuumdb.c:967 #, c-format msgid " -U, --username=USERNAME user name to connect as\n" msgstr " -U, --username=USUARIO nombre de usuario para la conexión\n" diff --git a/src/bin/scripts/po/ru.po b/src/bin/scripts/po/ru.po index b54aac7b42..d8a146482d 100644 --- a/src/bin/scripts/po/ru.po +++ b/src/bin/scripts/po/ru.po @@ -3,7 +3,7 @@ # This file is distributed under the same license as the PostgreSQL package. # Serguei A. Mokhov, , 2003-2004. # Oleg Bartunov , 2004. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" diff --git a/src/interfaces/ecpg/ecpglib/po/es.po b/src/interfaces/ecpg/ecpglib/po/es.po index 497bae3d97..9e40436a58 100644 --- a/src/interfaces/ecpg/ecpglib/po/es.po +++ b/src/interfaces/ecpg/ecpglib/po/es.po @@ -9,7 +9,7 @@ msgid "" msgstr "" "Project-Id-Version: ecpglib (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:49+0000\n" +"POT-Creation-Date: 2017-08-27 21:47+0000\n" "PO-Revision-Date: 2016-05-03 12:17-0300\n" "Last-Translator: Emanuel Calvo Franco \n" "Language-Team: PgSQL-es-Ayuda \n" diff --git a/src/interfaces/ecpg/ecpglib/po/ru.po b/src/interfaces/ecpg/ecpglib/po/ru.po index fcae3223b6..eb4434fd78 100644 --- a/src/interfaces/ecpg/ecpglib/po/ru.po +++ b/src/interfaces/ecpg/ecpglib/po/ru.po @@ -1,7 +1,7 @@ # Russian message translation file for ecpglib # Copyright (C) 2012-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" diff --git a/src/interfaces/ecpg/preproc/po/es.po b/src/interfaces/ecpg/preproc/po/es.po index 77ccc83169..0dd41da931 100644 --- a/src/interfaces/ecpg/preproc/po/es.po +++ b/src/interfaces/ecpg/preproc/po/es.po @@ -11,8 +11,8 @@ msgid "" msgstr "" "Project-Id-Version: ecpg (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:49+0000\n" -"PO-Revision-Date: 2016-05-03 12:17-0300\n" +"POT-Creation-Date: 2017-08-27 21:47+0000\n" +"PO-Revision-Date: 2017-08-28 11:37+0200\n" "Last-Translator: Ãlvaro Herrera \n" "Language: es\n" @@ -358,185 +358,185 @@ msgstr "inicializador no permitido en definición de tipo" msgid "type name \"string\" is reserved in Informix mode" msgstr "el nombre de tipo «string» está reservado en modo Informix" -#: preproc.y:546 preproc.y:14626 +#: preproc.y:546 preproc.y:14635 #, c-format msgid "type \"%s\" is already defined" msgstr "el tipo «%s» ya está definido" -#: preproc.y:570 preproc.y:15284 preproc.y:15604 variable.c:620 +#: preproc.y:570 preproc.y:15293 preproc.y:15613 variable.c:620 #, c-format msgid "multidimensional arrays for simple data types are not supported" msgstr "los arrays multidimensionales para tipos de datos simples no están soportados" -#: preproc.y:1634 +#: preproc.y:1635 #, c-format msgid "AT option not allowed in CLOSE DATABASE statement" msgstr "la opción AT no está permitida en la sentencia CLOSE DATABASE" -#: preproc.y:1849 +#: preproc.y:1850 #, c-format msgid "AT option not allowed in CONNECT statement" msgstr "la opción AT no está permitida en la sentencia CONNECT" -#: preproc.y:1883 +#: preproc.y:1884 #, c-format msgid "AT option not allowed in DISCONNECT statement" msgstr "la opción AT no está permitida en la sentencia DISCONNECT" -#: preproc.y:1938 +#: preproc.y:1939 #, c-format msgid "AT option not allowed in SET CONNECTION statement" msgstr "la opción AT no está permitida en la sentencia SET CONNECTION" -#: preproc.y:1960 +#: preproc.y:1961 #, c-format msgid "AT option not allowed in TYPE statement" msgstr "la opción AT no está permitida en la sentencia TYPE" -#: preproc.y:1969 +#: preproc.y:1970 #, c-format msgid "AT option not allowed in VAR statement" msgstr "la opción AT no está permitida en la sentencia VAR" -#: preproc.y:1976 +#: preproc.y:1977 #, c-format msgid "AT option not allowed in WHENEVER statement" msgstr "la opción AT no está permitida en la sentencia WHENEVER" -#: preproc.y:2228 preproc.y:2233 preproc.y:2349 preproc.y:3759 preproc.y:5173 -#: preproc.y:5182 preproc.y:5466 preproc.y:6902 preproc.y:8140 preproc.y:8145 -#: preproc.y:10776 preproc.y:11393 +#: preproc.y:2233 preproc.y:2238 preproc.y:2354 preproc.y:3764 preproc.y:5182 +#: preproc.y:5191 preproc.y:5475 preproc.y:6911 preproc.y:8149 preproc.y:8154 +#: preproc.y:10785 preproc.y:11402 #, c-format msgid "unsupported feature will be passed to server" msgstr "característica no soportada será pasada al servidor" -#: preproc.y:2607 +#: preproc.y:2612 #, c-format msgid "SHOW ALL is not implemented" msgstr "SHOW ALL no está implementado" -#: preproc.y:3147 +#: preproc.y:3152 #, c-format msgid "COPY FROM STDIN is not implemented" msgstr "COPY FROM STDIN no está implementado" -#: preproc.y:9035 preproc.y:14215 +#: preproc.y:9044 preproc.y:14224 #, c-format msgid "using variable \"%s\" in different declare statements is not supported" msgstr "el uso de la variable «%s» en diferentes sentencias declare no está soportado" -#: preproc.y:9037 preproc.y:14217 +#: preproc.y:9046 preproc.y:14226 #, c-format msgid "cursor \"%s\" is already defined" msgstr "el cursor «%s» ya está definido" -#: preproc.y:9467 +#: preproc.y:9476 #, c-format msgid "no longer supported LIMIT #,# syntax passed to server" msgstr "la sintaxis LIMIT #,# que ya no está soportada ha sido pasada al servidor" -#: preproc.y:9775 preproc.y:9782 +#: preproc.y:9784 preproc.y:9791 #, c-format msgid "subquery in FROM must have an alias" msgstr "las subconsultas en FROM deben tener un alias" -#: preproc.y:13945 +#: preproc.y:13954 #, c-format msgid "CREATE TABLE AS cannot specify INTO" msgstr "CREATE TABLE AS no puede especificar INTO" -#: preproc.y:13981 +#: preproc.y:13990 #, c-format msgid "expected \"@\", found \"%s\"" msgstr "se esperaba «@», se encontró «%s»" -#: preproc.y:13993 +#: preproc.y:14002 #, c-format msgid "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are supported" msgstr "sólo los protocolos «tcp» y «unix» y tipo de bases de datos «postgresql» están soportados" -#: preproc.y:13996 +#: preproc.y:14005 #, c-format msgid "expected \"://\", found \"%s\"" msgstr "se esperaba «://», se encontró «%s»" -#: preproc.y:14001 +#: preproc.y:14010 #, c-format msgid "Unix-domain sockets only work on \"localhost\" but not on \"%s\"" msgstr "los sockets de dominio unix sólo trabajan en «localhost» pero no en «%s»" -#: preproc.y:14027 +#: preproc.y:14036 #, c-format msgid "expected \"postgresql\", found \"%s\"" msgstr "se esperaba «postgresql», se encontró «%s»" -#: preproc.y:14030 +#: preproc.y:14039 #, c-format msgid "invalid connection type: %s" msgstr "tipo de conexión no válido: %s" -#: preproc.y:14039 +#: preproc.y:14048 #, c-format msgid "expected \"@\" or \"://\", found \"%s\"" msgstr "se esperaba «@» o «://», se encontró «%s»" -#: preproc.y:14114 preproc.y:14132 +#: preproc.y:14123 preproc.y:14141 #, c-format msgid "invalid data type" msgstr "tipo de dato no válido" -#: preproc.y:14143 preproc.y:14160 +#: preproc.y:14152 preproc.y:14169 #, c-format msgid "incomplete statement" msgstr "sentencia incompleta" -#: preproc.y:14146 preproc.y:14163 +#: preproc.y:14155 preproc.y:14172 #, c-format msgid "unrecognized token \"%s\"" msgstr "elemento «%s» no reconocido" -#: preproc.y:14437 +#: preproc.y:14446 #, c-format msgid "only data types numeric and decimal have precision/scale argument" msgstr "sólo los tipos de dato numeric y decimal tienen argumento de precisión/escala" -#: preproc.y:14449 +#: preproc.y:14458 #, c-format msgid "interval specification not allowed here" msgstr "la especificación de intervalo no está permitida aquí" -#: preproc.y:14601 preproc.y:14653 +#: preproc.y:14610 preproc.y:14662 #, c-format msgid "too many levels in nested structure/union definition" msgstr "demasiados niveles en la definición anidada de estructura/unión" -#: preproc.y:14792 +#: preproc.y:14801 #, c-format msgid "pointers to varchar are not implemented" msgstr "los punteros a varchar no están implementados" -#: preproc.y:14979 preproc.y:15004 +#: preproc.y:14988 preproc.y:15013 #, c-format msgid "using unsupported DESCRIBE statement" msgstr "utilizando sentencia DESCRIBE no soportada" -#: preproc.y:15251 +#: preproc.y:15260 #, c-format msgid "initializer not allowed in EXEC SQL VAR command" msgstr "inicializador no permitido en la orden EXEC SQL VAR" -#: preproc.y:15562 +#: preproc.y:15571 #, c-format msgid "arrays of indicators are not allowed on input" msgstr "no se permiten los arrays de indicadores en la entrada" -#: preproc.y:15783 +#: preproc.y:15792 #, c-format msgid "operator not allowed in variable definition" msgstr "operador no permitido en definición de variable" #. translator: %s is typically the translation of "syntax error" -#: preproc.y:15821 +#: preproc.y:15833 #, c-format msgid "%s at or near \"%s\"" msgstr "%s en o cerca de «%s»" @@ -657,6 +657,3 @@ msgstr "los punteros a puntero no están soportados para este tipo de dato" #, c-format msgid "multidimensional arrays for structures are not supported" msgstr "los arrays multidimensionales para estructuras no están soportados" - -#~ msgid " --version output version information, then exit\n" -#~ msgstr " --version muestra información de la versión, luego sale\n" diff --git a/src/interfaces/ecpg/preproc/po/ru.po b/src/interfaces/ecpg/preproc/po/ru.po index 854b6c9e19..138aaec01f 100644 --- a/src/interfaces/ecpg/preproc/po/ru.po +++ b/src/interfaces/ecpg/preproc/po/ru.po @@ -1,13 +1,13 @@ # Russian message translation file for ecpg # Copyright (C) 2012-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: ecpg (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-02-01 23:08+0000\n" +"POT-Creation-Date: 2017-08-17 17:47+0000\n" "PO-Revision-Date: 2016-11-24 16:01+0300\n" "Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" @@ -253,67 +253,67 @@ msgstr "Ð¾Ð±Ð¾Ñ€Ð²Ð°Ð½Ð½Ð°Ñ ÑˆÐµÑÑ‚Ð½Ð°Ð´Ñ†Ð°Ñ‚ÐµÑ€Ð¸Ñ‡Ð½Ð°Ñ Ñтрока" msgid "unterminated quoted string" msgstr "Ð½ÐµÐ·Ð°Ð²ÐµÑ€ÑˆÑ‘Ð½Ð½Ð°Ñ Ñтрока в кавычках" -#: pgc.l:605 pgc.l:618 +#: pgc.l:606 pgc.l:619 #, c-format msgid "zero-length delimited identifier" msgstr "пуÑтой идентификатор в кавычках" -#: pgc.l:626 +#: pgc.l:627 #, c-format msgid "unterminated quoted identifier" msgstr "незавершённый идентификатор в кавычках" -#: pgc.l:881 +#: pgc.l:882 #, c-format msgid "nested /* ... */ comments" msgstr "вложенные комментарии /* ... */" -#: pgc.l:974 +#: pgc.l:975 #, c-format msgid "missing identifier in EXEC SQL UNDEF command" msgstr "в команде EXEC SQL UNDEF отÑутÑтвует идентификатор" -#: pgc.l:1020 pgc.l:1034 +#: pgc.l:1021 pgc.l:1035 #, c-format msgid "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"" msgstr "нет ÑоответÑтвующего \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"" -#: pgc.l:1023 pgc.l:1036 pgc.l:1212 +#: pgc.l:1024 pgc.l:1037 pgc.l:1213 #, c-format msgid "missing \"EXEC SQL ENDIF;\"" msgstr "отÑутÑтвует \"EXEC SQL ENDIF;\"" -#: pgc.l:1052 pgc.l:1071 +#: pgc.l:1053 pgc.l:1072 #, c-format msgid "more than one EXEC SQL ELSE" msgstr "Ð½ÐµÐ¾Ð´Ð½Ð¾ÐºÑ€Ð°Ñ‚Ð½Ð°Ñ ÐºÐ¾Ð¼Ð°Ð½Ð´Ð° EXEC SQL ELSE" -#: pgc.l:1093 pgc.l:1107 +#: pgc.l:1094 pgc.l:1108 #, c-format msgid "unmatched EXEC SQL ENDIF" msgstr "Ð½ÐµÐ¿Ð°Ñ€Ð½Ð°Ñ ÐºÐ¾Ð¼Ð°Ð½Ð´Ð° EXEC SQL ENDIF" -#: pgc.l:1127 +#: pgc.l:1128 #, c-format msgid "too many nested EXEC SQL IFDEF conditions" msgstr "Ñлишком много вложенных уÑловий EXEC SQL IFDEF" -#: pgc.l:1160 +#: pgc.l:1161 #, c-format msgid "missing identifier in EXEC SQL IFDEF command" msgstr "в команде EXEC SQL IFDEF отÑутÑтвует идентификатор" -#: pgc.l:1169 +#: pgc.l:1170 #, c-format msgid "missing identifier in EXEC SQL DEFINE command" msgstr "в команде EXEC SQL DEFINE отÑутÑтвует идентификатор" -#: pgc.l:1202 +#: pgc.l:1203 #, c-format msgid "syntax error in EXEC SQL INCLUDE command" msgstr "ошибка ÑинтакÑиÑа в команде EXEC SQL INCLUDE" -#: pgc.l:1251 +#: pgc.l:1252 #, c-format msgid "" "internal error: unreachable state; please report this to " -#: pgc.l:1375 +#: pgc.l:1376 #, c-format msgid "Error: include path \"%s/%s\" is too long on line %d, skipping\n" msgstr "" "Ошибка: путь включаемых файлов \"%s/%s\" в Ñтроке %d Ñлишком длинный, " "пропуÑкаетÑÑ\n" -#: pgc.l:1398 +#: pgc.l:1399 #, c-format msgid "could not open include file \"%s\" on line %d" msgstr "не удалоÑÑŒ открыть включаемый файл \"%s\" (Ñтрока %d)" @@ -363,100 +363,100 @@ msgstr "определение типа не может включать ини msgid "type name \"string\" is reserved in Informix mode" msgstr "Ð¸Ð¼Ñ Ñ‚Ð¸Ð¿Ð° \"string\" в режиме Informix зарезервировано" -#: preproc.y:546 preproc.y:14626 +#: preproc.y:546 preproc.y:14635 #, c-format msgid "type \"%s\" is already defined" msgstr "тип \"%s\" уже определён" -#: preproc.y:570 preproc.y:15284 preproc.y:15604 variable.c:620 +#: preproc.y:570 preproc.y:15293 preproc.y:15613 variable.c:620 #, c-format msgid "multidimensional arrays for simple data types are not supported" msgstr "многомерные маÑÑивы Ñ Ð¿Ñ€Ð¾Ñтыми типами данных не поддерживаютÑÑ" -#: preproc.y:1634 +#: preproc.y:1635 #, c-format msgid "AT option not allowed in CLOSE DATABASE statement" msgstr "оператор CLOSE DATABASE Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ AT не поддерживаетÑÑ" -#: preproc.y:1849 +#: preproc.y:1850 #, c-format msgid "AT option not allowed in CONNECT statement" msgstr "оператор CONNECT Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ AT не поддерживаетÑÑ" -#: preproc.y:1883 +#: preproc.y:1884 #, c-format msgid "AT option not allowed in DISCONNECT statement" msgstr "оператор DISCONNECT Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ AT не поддерживаетÑÑ" -#: preproc.y:1938 +#: preproc.y:1939 #, c-format msgid "AT option not allowed in SET CONNECTION statement" msgstr "оператор SET CONNECTION Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ AT не поддерживаетÑÑ" -#: preproc.y:1960 +#: preproc.y:1961 #, c-format msgid "AT option not allowed in TYPE statement" msgstr "оператор TYPE Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ AT не поддерживаетÑÑ" -#: preproc.y:1969 +#: preproc.y:1970 #, c-format msgid "AT option not allowed in VAR statement" msgstr "оператор VAR Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ AT не поддерживаетÑÑ" -#: preproc.y:1976 +#: preproc.y:1977 #, c-format msgid "AT option not allowed in WHENEVER statement" msgstr "оператор WHENEVER Ñ Ð¿Ð°Ñ€Ð°Ð¼ÐµÑ‚Ñ€Ð¾Ð¼ AT не поддерживаетÑÑ" -#: preproc.y:2228 preproc.y:2233 preproc.y:2349 preproc.y:3759 preproc.y:5173 -#: preproc.y:5182 preproc.y:5466 preproc.y:6902 preproc.y:8140 preproc.y:8145 -#: preproc.y:10776 preproc.y:11393 +#: preproc.y:2233 preproc.y:2238 preproc.y:2354 preproc.y:3764 preproc.y:5182 +#: preproc.y:5191 preproc.y:5475 preproc.y:6911 preproc.y:8149 preproc.y:8154 +#: preproc.y:10785 preproc.y:11402 #, c-format msgid "unsupported feature will be passed to server" msgstr "Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ€Ð¶Ð¸Ð²Ð°ÐµÐ¼Ð°Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ Ð±ÑƒÐ´ÐµÑ‚ передана Ñерверу" -#: preproc.y:2607 +#: preproc.y:2612 #, c-format msgid "SHOW ALL is not implemented" msgstr "SHOW ALL не реализовано" -#: preproc.y:3147 +#: preproc.y:3152 #, c-format msgid "COPY FROM STDIN is not implemented" msgstr "Ð¾Ð¿ÐµÑ€Ð°Ñ†Ð¸Ñ COPY FROM STDIN не реализована" -#: preproc.y:9035 preproc.y:14215 +#: preproc.y:9044 preproc.y:14224 #, c-format msgid "using variable \"%s\" in different declare statements is not supported" msgstr "" "иÑпользование переменной \"%s\" в разных операторах DECLARE не поддерживаетÑÑ" -#: preproc.y:9037 preproc.y:14217 +#: preproc.y:9046 preproc.y:14226 #, c-format msgid "cursor \"%s\" is already defined" msgstr "курÑор \"%s\" уже определён" -#: preproc.y:9467 +#: preproc.y:9476 #, c-format msgid "no longer supported LIMIT #,# syntax passed to server" msgstr "не поддерживаемое более предложение LIMIT #,# передано на Ñервер" -#: preproc.y:9775 preproc.y:9782 +#: preproc.y:9784 preproc.y:9791 #, c-format msgid "subquery in FROM must have an alias" msgstr "Ð¿Ð¾Ð´Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð²Ð¾ FROM должен иметь пÑевдоним" -#: preproc.y:13945 +#: preproc.y:13954 #, c-format msgid "CREATE TABLE AS cannot specify INTO" msgstr "в CREATE TABLE AS Ð½ÐµÐ»ÑŒÐ·Ñ ÑƒÐºÐ°Ð·Ð°Ñ‚ÑŒ INTO" -#: preproc.y:13981 +#: preproc.y:13990 #, c-format msgid "expected \"@\", found \"%s\"" msgstr "ожидалÑÑ Ð·Ð½Ð°Ðº \"@\", но на Ñтом меÑте \"%s\"" -#: preproc.y:13993 +#: preproc.y:14002 #, c-format msgid "" "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are " @@ -465,90 +465,90 @@ msgstr "" "поддерживаютÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ протоколы \"tcp\" и \"unix\", а тип базы данных - " "\"postgresql\"" -#: preproc.y:13996 +#: preproc.y:14005 #, c-format msgid "expected \"://\", found \"%s\"" msgstr "ожидалоÑÑŒ \"://\", но на Ñтом меÑте \"%s\"" -#: preproc.y:14001 +#: preproc.y:14010 #, c-format msgid "Unix-domain sockets only work on \"localhost\" but not on \"%s\"" msgstr "" "Доменные Ñокеты Unix работают только Ñ \"localhost\", но не Ñ Ð°Ð´Ñ€ÐµÑом \"%s\"" -#: preproc.y:14027 +#: preproc.y:14036 #, c-format msgid "expected \"postgresql\", found \"%s\"" msgstr "ожидалÑÑ Ñ‚Ð¸Ð¿ \"postgresql\", но на Ñтом меÑте \"%s\"" -#: preproc.y:14030 +#: preproc.y:14039 #, c-format msgid "invalid connection type: %s" msgstr "неверный тип подключениÑ: %s" -#: preproc.y:14039 +#: preproc.y:14048 #, c-format msgid "expected \"@\" or \"://\", found \"%s\"" msgstr "ожидалоÑÑŒ \"@\" или \"://\", но на Ñтом меÑте \"%s\"" -#: preproc.y:14114 preproc.y:14132 +#: preproc.y:14123 preproc.y:14141 #, c-format msgid "invalid data type" msgstr "неверный тип данных" -#: preproc.y:14143 preproc.y:14160 +#: preproc.y:14152 preproc.y:14169 #, c-format msgid "incomplete statement" msgstr "неполный оператор" -#: preproc.y:14146 preproc.y:14163 +#: preproc.y:14155 preproc.y:14172 #, c-format msgid "unrecognized token \"%s\"" msgstr "нераÑпознанное ключевое Ñлово \"%s\"" -#: preproc.y:14437 +#: preproc.y:14446 #, c-format msgid "only data types numeric and decimal have precision/scale argument" msgstr "" "точноÑÑ‚ÑŒ/маÑштаб можно указать только Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð¾Ð² данных numeric и decimal" -#: preproc.y:14449 +#: preproc.y:14458 #, c-format msgid "interval specification not allowed here" msgstr "определение интервала здеÑÑŒ не допуÑкаетÑÑ" -#: preproc.y:14601 preproc.y:14653 +#: preproc.y:14610 preproc.y:14662 #, c-format msgid "too many levels in nested structure/union definition" msgstr "Ñлишком много уровней в определении вложенной Ñтруктуры/объединениÑ" -#: preproc.y:14792 +#: preproc.y:14801 #, c-format msgid "pointers to varchar are not implemented" msgstr "указатели на varchar не реализованы" -#: preproc.y:14979 preproc.y:15004 +#: preproc.y:14988 preproc.y:15013 #, c-format msgid "using unsupported DESCRIBE statement" msgstr "иÑпользуетÑÑ Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ€Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ‹Ð¹ оператор DESCRIBE" -#: preproc.y:15251 +#: preproc.y:15260 #, c-format msgid "initializer not allowed in EXEC SQL VAR command" msgstr "команда EXEC SQL VAR не может включать инициализатор" -#: preproc.y:15562 +#: preproc.y:15571 #, c-format msgid "arrays of indicators are not allowed on input" msgstr "маÑÑивы индикаторов на входе недопуÑтимы" -#: preproc.y:15783 +#: preproc.y:15792 #, c-format msgid "operator not allowed in variable definition" msgstr "недопуÑтимый оператор в определении переменной" #. translator: %s is typically the translation of "syntax error" -#: preproc.y:15821 +#: preproc.y:15833 #, c-format msgid "%s at or near \"%s\"" msgstr "%s (примерное положение: \"%s\")" diff --git a/src/interfaces/libpq/po/es.po b/src/interfaces/libpq/po/es.po index fe3ce91113..4543d6f387 100644 --- a/src/interfaces/libpq/po/es.po +++ b/src/interfaces/libpq/po/es.po @@ -11,8 +11,8 @@ msgid "" msgstr "" "Project-Id-Version: libpq (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:49+0000\n" -"PO-Revision-Date: 2017-05-19 18:24-0400\n" +"POT-Creation-Date: 2017-08-27 21:47+0000\n" +"PO-Revision-Date: 2017-08-28 11:37+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL-es-Ayuda \n" "Language: es\n" @@ -25,7 +25,7 @@ msgstr "" msgid "GSSAPI continuation error" msgstr "error en continuación de GSSAPI" -#: fe-auth.c:177 fe-auth.c:412 +#: fe-auth.c:177 fe-auth.c:417 msgid "host name must be specified\n" msgstr "el nombre de servidor debe ser especificado\n" @@ -33,12 +33,12 @@ msgstr "el nombre de servidor debe ser especificado\n" msgid "duplicate GSS authentication request\n" msgstr "petición de autentificación GSS duplicada\n" -#: fe-auth.c:197 fe-auth.c:309 fe-auth.c:383 fe-auth.c:418 fe-auth.c:514 -#: fe-auth.c:793 fe-connect.c:707 fe-connect.c:904 fe-connect.c:1080 -#: fe-connect.c:2091 fe-connect.c:3484 fe-connect.c:3736 fe-connect.c:3855 -#: fe-connect.c:4095 fe-connect.c:4175 fe-connect.c:4274 fe-connect.c:4530 -#: fe-connect.c:4559 fe-connect.c:4631 fe-connect.c:4655 fe-connect.c:4673 -#: fe-connect.c:4769 fe-connect.c:5103 fe-connect.c:5253 fe-exec.c:2651 +#: fe-auth.c:197 fe-auth.c:309 fe-auth.c:388 fe-auth.c:423 fe-auth.c:519 +#: fe-auth.c:798 fe-connect.c:767 fe-connect.c:964 fe-connect.c:1140 +#: fe-connect.c:2141 fe-connect.c:3499 fe-connect.c:3751 fe-connect.c:3870 +#: fe-connect.c:4110 fe-connect.c:4190 fe-connect.c:4289 fe-connect.c:4545 +#: fe-connect.c:4574 fe-connect.c:4646 fe-connect.c:4670 fe-connect.c:4688 +#: fe-connect.c:4784 fe-connect.c:5118 fe-connect.c:5268 fe-exec.c:2651 #: fe-exec.c:3398 fe-exec.c:3563 fe-lobj.c:896 fe-protocol2.c:1206 #: fe-protocol3.c:992 fe-protocol3.c:1678 fe-secure-openssl.c:515 #: fe-secure-openssl.c:1139 @@ -53,74 +53,78 @@ msgstr "error en conversión de nombre GSSAPI" msgid "SSPI continuation error" msgstr "error en continuación de SSPI" -#: fe-auth.c:398 +#: fe-auth.c:378 +msgid "duplicate SSPI authentication request\n" +msgstr "petición de autentificación SSPI duplicada\n" + +#: fe-auth.c:403 msgid "could not acquire SSPI credentials" msgstr "no se pudo obtener las credenciales SSPI" -#: fe-auth.c:489 +#: fe-auth.c:494 msgid "SCM_CRED authentication method not supported\n" msgstr "el método de autentificación SCM_CRED no está soportado\n" -#: fe-auth.c:565 +#: fe-auth.c:570 msgid "Kerberos 4 authentication not supported\n" msgstr "el método de autentificación Kerberos 4 no está soportado\n" -#: fe-auth.c:570 +#: fe-auth.c:575 msgid "Kerberos 5 authentication not supported\n" msgstr "el método de autentificación Kerberos 5 no está soportado\n" -#: fe-auth.c:641 +#: fe-auth.c:646 msgid "GSSAPI authentication not supported\n" msgstr "el método de autentificación GSSAPI no está soportado\n" -#: fe-auth.c:673 +#: fe-auth.c:678 msgid "SSPI authentication not supported\n" msgstr "el método de autentificación SSPI no está soportado\n" -#: fe-auth.c:681 +#: fe-auth.c:686 msgid "Crypt authentication not supported\n" msgstr "el método de autentificación Crypt no está soportado\n" -#: fe-auth.c:716 +#: fe-auth.c:721 msgid "SCRAM authentication requires libpq version 10 or above\n" msgstr "la autentificación SCRAM requiere la versión de libpq 10 o superior\n" -#: fe-auth.c:721 +#: fe-auth.c:726 #, c-format msgid "authentication method %u not supported\n" msgstr "el método de autentificación %u no está soportado\n" -#: fe-auth.c:768 +#: fe-auth.c:773 #, c-format msgid "user name lookup failure: error code %lu\n" msgstr "fallo en la búsqueda del nombre de usuario: código de error %lu\n" -#: fe-auth.c:778 fe-connect.c:2018 +#: fe-auth.c:783 fe-connect.c:2068 #, c-format msgid "could not look up local user ID %d: %s\n" msgstr "no se pudo buscar el usuario local de ID %d: %s\n" -#: fe-auth.c:783 fe-connect.c:2023 +#: fe-auth.c:788 fe-connect.c:2073 #, c-format msgid "local user with ID %d does not exist\n" msgstr "no existe un usuario local con ID %d\n" -#: fe-connect.c:846 +#: fe-connect.c:906 #, c-format msgid "invalid sslmode value: \"%s\"\n" msgstr "valor sslmode no válido: «%s»\n" -#: fe-connect.c:867 +#: fe-connect.c:927 #, c-format msgid "sslmode value \"%s\" invalid when SSL support is not compiled in\n" msgstr "el valor sslmode «%s» no es válido cuando no se ha compilado con soporte SSL\n" -#: fe-connect.c:1104 +#: fe-connect.c:1164 #, c-format msgid "could not set socket to TCP no delay mode: %s\n" msgstr "no se pudo establecer el socket en modo TCP sin retardo: %s\n" -#: fe-connect.c:1134 +#: fe-connect.c:1194 #, c-format msgid "" "could not connect to server: %s\n" @@ -131,7 +135,7 @@ msgstr "" "\t¿Está el servidor en ejecución localmente y aceptando\n" "\tconexiones en el socket de dominio Unix «%s»?\n" -#: fe-connect.c:1189 +#: fe-connect.c:1249 #, c-format msgid "" "could not connect to server: %s\n" @@ -142,7 +146,7 @@ msgstr "" "\t¿Está el servidor en ejecución en el servidor «%s» (%s) y aceptando\n" "\tconexiones TCP/IP en el puerto %s?\n" -#: fe-connect.c:1198 +#: fe-connect.c:1258 #, c-format msgid "" "could not connect to server: %s\n" @@ -153,300 +157,280 @@ msgstr "" "\t¿Está el servidor en ejecución en el servidor «%s» y aceptando\n" "\tconexiones TCP/IP en el puerto %s?\n" -#: fe-connect.c:1249 -#, c-format -msgid "setsockopt(TCP_KEEPIDLE) failed: %s\n" -msgstr "setsockopt(TCP_KEEPIDLE) falló: %s\n" - -#: fe-connect.c:1262 -#, c-format -msgid "setsockopt(TCP_KEEPALIVE) failed: %s\n" -msgstr "setsockopt(TCP_KEEPALIVE) falló: %s\n" - -#: fe-connect.c:1294 +#: fe-connect.c:1309 fe-connect.c:1341 fe-connect.c:1374 fe-connect.c:1841 #, c-format -msgid "setsockopt(TCP_KEEPINTVL) failed: %s\n" -msgstr "setsockopt(TCP_KEEPINTVL) falló: %s\n" +msgid "setsockopt(%s) failed: %s\n" +msgstr "setsockopt(%s) falló: %s\n" -#: fe-connect.c:1326 -#, c-format -msgid "setsockopt(TCP_KEEPCNT) failed: %s\n" -msgstr "setsockopt(TCP_KEEPCNT) falló: %s\n" - -#: fe-connect.c:1374 +#: fe-connect.c:1423 #, c-format msgid "WSAIoctl(SIO_KEEPALIVE_VALS) failed: %ui\n" msgstr "WSAIoctl(SIO_KEEPALIVE_VALS) failed: %ui\n" -#: fe-connect.c:1426 +#: fe-connect.c:1475 #, c-format msgid "invalid port number: \"%s\"\n" msgstr "número de puerto no válido: «%s»\n" -#: fe-connect.c:1459 +#: fe-connect.c:1508 #, c-format msgid "Unix-domain socket path \"%s\" is too long (maximum %d bytes)\n" msgstr "la ruta del socket de dominio Unix «%s» es demasiado larga (máximo %d bytes)\n" -#: fe-connect.c:1478 +#: fe-connect.c:1527 #, c-format msgid "could not translate host name \"%s\" to address: %s\n" msgstr "no se pudo traducir el nombre «%s» a una dirección: %s\n" -#: fe-connect.c:1482 +#: fe-connect.c:1531 #, c-format msgid "could not translate Unix-domain socket path \"%s\" to address: %s\n" msgstr "no se pudo traducir la ruta del socket Unix «%s» a una dirección: %s\n" -#: fe-connect.c:1687 +#: fe-connect.c:1736 msgid "invalid connection state, probably indicative of memory corruption\n" msgstr "el estado de conexión no es válido, probablemente por corrupción de memoria\n" -#: fe-connect.c:1727 +#: fe-connect.c:1776 #, c-format msgid "could not create socket: %s\n" msgstr "no se pudo crear el socket: %s\n" -#: fe-connect.c:1749 +#: fe-connect.c:1798 #, c-format msgid "could not set socket to nonblocking mode: %s\n" msgstr "no se pudo establecer el socket en modo no bloqueante: %s\n" -#: fe-connect.c:1760 +#: fe-connect.c:1809 #, c-format msgid "could not set socket to close-on-exec mode: %s\n" msgstr "no se pudo poner el socket en modo close-on-exec: %s\n" -#: fe-connect.c:1779 +#: fe-connect.c:1828 msgid "keepalives parameter must be an integer\n" msgstr "el parámetro de keepalives debe ser un entero\n" -#: fe-connect.c:1792 -#, c-format -msgid "setsockopt(SO_KEEPALIVE) failed: %s\n" -msgstr "setsockopt(SO_KEEPALIVE) falló: %s\n" - -#: fe-connect.c:1929 +#: fe-connect.c:1979 #, c-format msgid "could not get socket error status: %s\n" msgstr "no se pudo determinar el estado de error del socket: %s\n" -#: fe-connect.c:1963 +#: fe-connect.c:2013 #, c-format msgid "could not get client address from socket: %s\n" msgstr "no se pudo obtener la dirección del cliente desde el socket: %s\n" -#: fe-connect.c:2005 +#: fe-connect.c:2055 msgid "requirepeer parameter is not supported on this platform\n" msgstr "el parámetro requirepeer no está soportado en esta plataforma\n" -#: fe-connect.c:2008 +#: fe-connect.c:2058 #, c-format msgid "could not get peer credentials: %s\n" msgstr "no se pudo obtener credenciales de la contraparte: %s\n" -#: fe-connect.c:2031 +#: fe-connect.c:2081 #, c-format msgid "requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n" msgstr "requirepeer especifica «%s», pero el nombre de usuario de la contraparte es «%s»\n" -#: fe-connect.c:2065 +#: fe-connect.c:2115 #, c-format msgid "could not send SSL negotiation packet: %s\n" msgstr "no se pudo enviar el paquete de negociación SSL: %s\n" -#: fe-connect.c:2104 +#: fe-connect.c:2154 #, c-format msgid "could not send startup packet: %s\n" msgstr "no se pudo enviar el paquete de inicio: %s\n" -#: fe-connect.c:2174 +#: fe-connect.c:2224 msgid "server does not support SSL, but SSL was required\n" msgstr "el servidor no soporta SSL, pero SSL es requerida\n" -#: fe-connect.c:2200 +#: fe-connect.c:2250 #, c-format msgid "received invalid response to SSL negotiation: %c\n" msgstr "se ha recibido una respuesta no válida en la negociación SSL: %c\n" -#: fe-connect.c:2275 fe-connect.c:2308 +#: fe-connect.c:2325 fe-connect.c:2358 #, c-format msgid "expected authentication request from server, but received %c\n" msgstr "se esperaba una petición de autentificación desde el servidor, pero se ha recibido %c\n" -#: fe-connect.c:2475 +#: fe-connect.c:2525 #, c-format msgid "out of memory allocating GSSAPI buffer (%d)" msgstr "memoria agotada creando el búfer GSSAPI (%d)" -#: fe-connect.c:2560 +#: fe-connect.c:2610 msgid "unexpected message from server during startup\n" msgstr "se ha recibido un mensaje inesperado del servidor durante el inicio\n" -#: fe-connect.c:2654 +#: fe-connect.c:2704 #, c-format msgid "invalid connection state %d, probably indicative of memory corruption\n" msgstr "estado de conexión no válido %d, probablemente por corrupción de memoria\n" -#: fe-connect.c:3090 fe-connect.c:3150 +#: fe-connect.c:3105 fe-connect.c:3165 #, c-format msgid "PGEventProc \"%s\" failed during PGEVT_CONNRESET event\n" msgstr "PGEventProc «%s» falló durante el evento PGEVT_CONNRESET\n" -#: fe-connect.c:3497 +#: fe-connect.c:3512 #, c-format msgid "invalid LDAP URL \"%s\": scheme must be ldap://\n" msgstr "URL LDAP no válida «%s»: el esquema debe ser ldap://\n" -#: fe-connect.c:3512 +#: fe-connect.c:3527 #, c-format msgid "invalid LDAP URL \"%s\": missing distinguished name\n" msgstr "URL LDAP no válida «%s»: distinguished name faltante\n" -#: fe-connect.c:3523 fe-connect.c:3576 +#: fe-connect.c:3538 fe-connect.c:3591 #, c-format msgid "invalid LDAP URL \"%s\": must have exactly one attribute\n" msgstr "URL LDAP no válida «%s»: debe tener exactamente un atributo\n" -#: fe-connect.c:3533 fe-connect.c:3590 +#: fe-connect.c:3548 fe-connect.c:3605 #, c-format msgid "invalid LDAP URL \"%s\": must have search scope (base/one/sub)\n" msgstr "URL LDAP no válida «%s»: debe tener ámbito de búsqueda (base/one/sub)\n" -#: fe-connect.c:3544 +#: fe-connect.c:3559 #, c-format msgid "invalid LDAP URL \"%s\": no filter\n" msgstr "URL LDAP no válida «%s»: no tiene filtro\n" -#: fe-connect.c:3565 +#: fe-connect.c:3580 #, c-format msgid "invalid LDAP URL \"%s\": invalid port number\n" msgstr "URL LDAP no válida «%s»: número de puerto no válido\n" -#: fe-connect.c:3599 +#: fe-connect.c:3614 msgid "could not create LDAP structure\n" msgstr "no se pudo crear estructura LDAP\n" -#: fe-connect.c:3675 +#: fe-connect.c:3690 #, c-format msgid "lookup on LDAP server failed: %s\n" msgstr "búsqueda en servidor LDAP falló: %s\n" -#: fe-connect.c:3686 +#: fe-connect.c:3701 msgid "more than one entry found on LDAP lookup\n" msgstr "se encontro más de una entrada en búsqueda LDAP\n" -#: fe-connect.c:3687 fe-connect.c:3699 +#: fe-connect.c:3702 fe-connect.c:3714 msgid "no entry found on LDAP lookup\n" msgstr "no se encontró ninguna entrada en búsqueda LDAP\n" -#: fe-connect.c:3710 fe-connect.c:3723 +#: fe-connect.c:3725 fe-connect.c:3738 msgid "attribute has no values on LDAP lookup\n" msgstr "la búsqueda LDAP entregó atributo sin valores\n" -#: fe-connect.c:3775 fe-connect.c:3794 fe-connect.c:4313 +#: fe-connect.c:3790 fe-connect.c:3809 fe-connect.c:4328 #, c-format msgid "missing \"=\" after \"%s\" in connection info string\n" msgstr "falta «=» después de «%s» en la cadena de información de la conexión\n" -#: fe-connect.c:3867 fe-connect.c:4498 fe-connect.c:5236 +#: fe-connect.c:3882 fe-connect.c:4513 fe-connect.c:5251 #, c-format msgid "invalid connection option \"%s\"\n" msgstr "opción de conexión no válida «%s»\n" -#: fe-connect.c:3883 fe-connect.c:4362 +#: fe-connect.c:3898 fe-connect.c:4377 msgid "unterminated quoted string in connection info string\n" msgstr "cadena de caracteres entre comillas sin terminar en la cadena de información de conexión\n" -#: fe-connect.c:3923 +#: fe-connect.c:3938 msgid "could not get home directory to locate service definition file" msgstr "no se pudo obtener el directorio home para localizar el archivo de definición de servicio" -#: fe-connect.c:3956 +#: fe-connect.c:3971 #, c-format msgid "definition of service \"%s\" not found\n" msgstr "la definición de servicio «%s» no fue encontrada\n" -#: fe-connect.c:3979 +#: fe-connect.c:3994 #, c-format msgid "service file \"%s\" not found\n" msgstr "el archivo de servicio «%s» no fue encontrado\n" -#: fe-connect.c:3992 +#: fe-connect.c:4007 #, c-format msgid "line %d too long in service file \"%s\"\n" msgstr "la línea %d es demasiado larga en archivo de servicio «%s»\n" -#: fe-connect.c:4063 fe-connect.c:4107 +#: fe-connect.c:4078 fe-connect.c:4122 #, c-format msgid "syntax error in service file \"%s\", line %d\n" msgstr "error de sintaxis en archivo de servicio «%s», línea %d\n" -#: fe-connect.c:4074 +#: fe-connect.c:4089 #, c-format msgid "nested service specifications not supported in service file \"%s\", line %d\n" msgstr "especificaciones de servicio anidadas no soportadas en archivo de servicio «%s», línea %d\n" -#: fe-connect.c:4780 +#: fe-connect.c:4795 #, c-format msgid "invalid URI propagated to internal parser routine: \"%s\"\n" msgstr "URI no válida propagada a rutina interna de procesamiento: «%s»\n" -#: fe-connect.c:4850 +#: fe-connect.c:4865 #, c-format msgid "end of string reached when looking for matching \"]\" in IPv6 host address in URI: \"%s\"\n" msgstr "se encontró el fin de la cadena mientras se buscaba el «]» correspondiente en dirección IPv6 en URI: «%s»\n" -#: fe-connect.c:4857 +#: fe-connect.c:4872 #, c-format msgid "IPv6 host address may not be empty in URI: \"%s\"\n" msgstr "la dirección IPv6 no puede ser vacía en la URI: «%s»\n" -#: fe-connect.c:4872 +#: fe-connect.c:4887 #, c-format msgid "unexpected character \"%c\" at position %d in URI (expected \":\" or \"/\"): \"%s\"\n" msgstr "carácter «%c» inesperado en la posición %d en URI (se esperaba «:» o «/»): «%s»\n" -#: fe-connect.c:4986 +#: fe-connect.c:5001 #, c-format msgid "extra key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "separador llave/valor «=» extra en parámetro de la URI: «%s»\n" -#: fe-connect.c:5006 +#: fe-connect.c:5021 #, c-format msgid "missing key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "separador llave/valor «=» faltante en parámetro de la URI: «%s»\n" -#: fe-connect.c:5057 +#: fe-connect.c:5072 #, c-format msgid "invalid URI query parameter: \"%s\"\n" msgstr "parámetro de URI no válido: «%s»\n" -#: fe-connect.c:5131 +#: fe-connect.c:5146 #, c-format msgid "invalid percent-encoded token: \"%s\"\n" msgstr "elemento escapado con %% no válido: «%s»\n" -#: fe-connect.c:5141 +#: fe-connect.c:5156 #, c-format msgid "forbidden value %%00 in percent-encoded value: \"%s\"\n" msgstr "valor no permitido %%00 en valor escapado con %%: «%s»\n" -#: fe-connect.c:5475 +#: fe-connect.c:5490 msgid "connection pointer is NULL\n" msgstr "el puntero de conexión es NULL\n" -#: fe-connect.c:5773 +#: fe-connect.c:5788 #, c-format msgid "WARNING: password file \"%s\" is not a plain file\n" msgstr "ADVERTENCIA: El archivo de claves «%s» no es un archivo plano\n" -#: fe-connect.c:5782 +#: fe-connect.c:5797 #, c-format msgid "WARNING: password file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n" msgstr "ADVERTENCIA: El archivo de claves «%s» tiene permiso de lectura para el grupo u otros; los permisos deberían ser u=rw (0600) o menos\n" -#: fe-connect.c:5896 +#: fe-connect.c:5911 #, c-format msgid "password retrieved from file \"%s\"\n" msgstr "contraseña obtenida desde el archivo «%s»\n" @@ -686,9 +670,9 @@ msgstr "el estado %c no es válido, probablemente por corrupción de memoria\n" msgid "message type 0x%02x arrived from server while idle" msgstr "un mensaje de tipo 0x%02x llegó del servidor estando inactivo" -#: fe-protocol2.c:503 fe-protocol2.c:538 fe-protocol2.c:1049 -#: fe-protocol3.c:209 fe-protocol3.c:236 fe-protocol3.c:253 fe-protocol3.c:333 -#: fe-protocol3.c:728 fe-protocol3.c:951 +#: fe-protocol2.c:503 fe-protocol2.c:538 fe-protocol2.c:1049 fe-protocol3.c:209 +#: fe-protocol3.c:236 fe-protocol3.c:253 fe-protocol3.c:333 fe-protocol3.c:728 +#: fe-protocol3.c:951 msgid "out of memory" msgstr "memoria agotada" @@ -1007,9 +991,3 @@ msgstr "no se pudo enviar datos al servidor: %s\n" #, c-format msgid "unrecognized socket error: 0x%08X/%d" msgstr "código de error de socket no reconocido: 0x%08X/%d" - -#~ msgid "could not acquire mutex: %s\n" -#~ msgstr "no se pudo adquirir el mutex: %s\n" - -#~ msgid "socket not open\n" -#~ msgstr "el socket no está abierto\n" diff --git a/src/interfaces/libpq/po/ru.po b/src/interfaces/libpq/po/ru.po index bf7e248dec..2935cad7f0 100644 --- a/src/interfaces/libpq/po/ru.po +++ b/src/interfaces/libpq/po/ru.po @@ -4,15 +4,14 @@ # Serguei A. Mokhov , 2001-2004. # Oleg Bartunov , 2005. # Andrey Sudnik , 2010. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: libpq (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-11-23 19:08+0000\n" -"PO-Revision-Date: 2016-09-20 12:00+0300\n" -"Last-Translator: Alexander Lakhin \n" +"POT-Creation-Date: 2017-08-17 17:47+0000\n" +"PO-Revision-Date: 2017-08-20 13:57+0300\n" "Language-Team: Russian \n" "Language: ru\n" "MIME-Version: 1.0\n" @@ -20,12 +19,13 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" +"Last-Translator: Alexander Lakhin \n" #: fe-auth.c:148 msgid "GSSAPI continuation error" msgstr "ошибка Ð¿Ñ€Ð¾Ð´Ð¾Ð»Ð¶ÐµÐ½Ð¸Ñ Ð² GSSAPI" -#: fe-auth.c:177 fe-auth.c:412 +#: fe-auth.c:177 fe-auth.c:417 msgid "host name must be specified\n" msgstr "требуетÑÑ ÑƒÐºÐ°Ð·Ð°Ñ‚ÑŒ Ð¸Ð¼Ñ Ñервера\n" @@ -33,14 +33,15 @@ msgstr "требуетÑÑ ÑƒÐºÐ°Ð·Ð°Ñ‚ÑŒ Ð¸Ð¼Ñ Ñервера\n" msgid "duplicate GSS authentication request\n" msgstr "повторный Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ GSS\n" -#: fe-auth.c:197 fe-auth.c:309 fe-auth.c:383 fe-auth.c:418 fe-auth.c:514 -#: fe-auth.c:780 fe-connect.c:707 fe-connect.c:904 fe-connect.c:1080 -#: fe-connect.c:2091 fe-connect.c:3484 fe-connect.c:3736 fe-connect.c:3855 -#: fe-connect.c:4095 fe-connect.c:4175 fe-connect.c:4274 fe-connect.c:4530 -#: fe-connect.c:4559 fe-connect.c:4631 fe-connect.c:4649 fe-connect.c:4745 -#: fe-connect.c:5079 fe-connect.c:5229 fe-exec.c:2651 fe-exec.c:3398 -#: fe-exec.c:3563 fe-lobj.c:896 fe-protocol2.c:1206 fe-protocol3.c:992 -#: fe-protocol3.c:1678 fe-secure-openssl.c:515 fe-secure-openssl.c:1139 +#: fe-auth.c:197 fe-auth.c:309 fe-auth.c:388 fe-auth.c:423 fe-auth.c:519 +#: fe-auth.c:798 fe-connect.c:767 fe-connect.c:964 fe-connect.c:1140 +#: fe-connect.c:2141 fe-connect.c:3499 fe-connect.c:3751 fe-connect.c:3870 +#: fe-connect.c:4110 fe-connect.c:4190 fe-connect.c:4289 fe-connect.c:4545 +#: fe-connect.c:4574 fe-connect.c:4646 fe-connect.c:4670 fe-connect.c:4688 +#: fe-connect.c:4784 fe-connect.c:5118 fe-connect.c:5268 fe-exec.c:2651 +#: fe-exec.c:3398 fe-exec.c:3563 fe-lobj.c:896 fe-protocol2.c:1206 +#: fe-protocol3.c:992 fe-protocol3.c:1678 fe-secure-openssl.c:515 +#: fe-secure-openssl.c:1139 msgid "out of memory\n" msgstr "нехватка памÑти\n" @@ -52,70 +53,78 @@ msgstr "ошибка импорта имени в GSSAPI" msgid "SSPI continuation error" msgstr "ошибка Ð¿Ñ€Ð¾Ð´Ð¾Ð»Ð¶ÐµÐ½Ð¸Ñ Ð² SSPI" -#: fe-auth.c:398 +#: fe-auth.c:378 +msgid "duplicate SSPI authentication request\n" +msgstr "повторный Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ SSPI\n" + +#: fe-auth.c:403 msgid "could not acquire SSPI credentials" msgstr "не удалоÑÑŒ получить удоÑтоверение SSPI" -#: fe-auth.c:489 +#: fe-auth.c:494 msgid "SCM_CRED authentication method not supported\n" msgstr "Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ñ SCM_CRED не поддерживаетÑÑ\n" -#: fe-auth.c:565 +#: fe-auth.c:570 msgid "Kerberos 4 authentication not supported\n" msgstr "Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ñ Kerberos 4 не поддерживаетÑÑ\n" -#: fe-auth.c:570 +#: fe-auth.c:575 msgid "Kerberos 5 authentication not supported\n" msgstr "Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ñ Kerberos 5 не поддерживаетÑÑ\n" -#: fe-auth.c:641 +#: fe-auth.c:646 msgid "GSSAPI authentication not supported\n" msgstr "Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ñ Ñ‡ÐµÑ€ÐµÐ· GSSAPI не поддерживаетÑÑ\n" -#: fe-auth.c:673 +#: fe-auth.c:678 msgid "SSPI authentication not supported\n" msgstr "Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ñ Ñ‡ÐµÑ€ÐµÐ· SSPI не поддерживаетÑÑ\n" -#: fe-auth.c:681 +#: fe-auth.c:686 msgid "Crypt authentication not supported\n" msgstr "Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ñ Crypt не поддерживаетÑÑ\n" -#: fe-auth.c:708 +#: fe-auth.c:721 +msgid "SCRAM authentication requires libpq version 10 or above\n" +msgstr "Ð´Ð»Ñ Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ SCRAM требуетÑÑ libpq верÑии 10 или новее\n" + +#: fe-auth.c:726 #, c-format msgid "authentication method %u not supported\n" msgstr "метод аутентификации %u не поддерживаетÑÑ\n" -#: fe-auth.c:755 +#: fe-auth.c:773 #, c-format msgid "user name lookup failure: error code %lu\n" msgstr "раÑпознать Ð¸Ð¼Ñ Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð½Ðµ удалоÑÑŒ (код ошибки: %lu)\n" -#: fe-auth.c:765 fe-connect.c:2018 +#: fe-auth.c:783 fe-connect.c:2068 #, c-format msgid "could not look up local user ID %d: %s\n" msgstr "найти локального Ð¿Ð¾Ð»ÑŒÐ·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð¿Ð¾ идентификатору (%d) не удалоÑÑŒ: %s\n" -#: fe-auth.c:770 fe-connect.c:2023 +#: fe-auth.c:788 fe-connect.c:2073 #, c-format msgid "local user with ID %d does not exist\n" msgstr "локальный пользователь Ñ ID %d не ÑущеÑтвует\n" -#: fe-connect.c:846 +#: fe-connect.c:906 #, c-format msgid "invalid sslmode value: \"%s\"\n" msgstr "неверное значение sslmode: \"%s\"\n" -#: fe-connect.c:867 +#: fe-connect.c:927 #, c-format msgid "sslmode value \"%s\" invalid when SSL support is not compiled in\n" msgstr "значение sslmode \"%s\" недопуÑтимо Ð´Ð»Ñ Ñборки без поддержки SSL\n" -#: fe-connect.c:1104 +#: fe-connect.c:1164 #, c-format msgid "could not set socket to TCP no delay mode: %s\n" msgstr "не удалоÑÑŒ перевеÑти Ñокет в режим TCP-передачи без задержки: %s\n" -#: fe-connect.c:1134 +#: fe-connect.c:1194 #, c-format msgid "" "could not connect to server: %s\n" @@ -126,7 +135,7 @@ msgstr "" "\tОн дейÑтвительно работает локально и принимает\n" "\tÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ñ‡ÐµÑ€ÐµÐ· доменный Ñокет \"%s\"?\n" -#: fe-connect.c:1189 +#: fe-connect.c:1249 #, c-format msgid "" "could not connect to server: %s\n" @@ -137,7 +146,7 @@ msgstr "" "\tОн дейÑтвительно работает по адреÑу \"%s\" (%s)\n" "\t и принимает TCP-ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ (порт %s)?\n" -#: fe-connect.c:1198 +#: fe-connect.c:1258 #, c-format msgid "" "could not connect to server: %s\n" @@ -148,243 +157,223 @@ msgstr "" "\tОн дейÑтвительно работает по адреÑу \"%s\"\n" "\t и принимает TCP-ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ (порт %s)?\n" -#: fe-connect.c:1249 -#, c-format -msgid "setsockopt(TCP_KEEPIDLE) failed: %s\n" -msgstr "ошибка в setsockopt(TCP_KEEPIDLE): %s\n" - -#: fe-connect.c:1262 -#, c-format -msgid "setsockopt(TCP_KEEPALIVE) failed: %s\n" -msgstr "ошибка в setsockopt(TCP_KEEPALIVE): %s\n" - -#: fe-connect.c:1294 -#, c-format -msgid "setsockopt(TCP_KEEPINTVL) failed: %s\n" -msgstr "ошибка в setsockopt(TCP_KEEPINTVL): %s\n" - -#: fe-connect.c:1326 +#: fe-connect.c:1309 fe-connect.c:1341 fe-connect.c:1374 fe-connect.c:1841 #, c-format -msgid "setsockopt(TCP_KEEPCNT) failed: %s\n" -msgstr "ошибка в setsockopt(TCP_KEEPCNT): %s\n" +msgid "setsockopt(%s) failed: %s\n" +msgstr "ошибка в setsockopt(%s): %s\n" -#: fe-connect.c:1374 +#: fe-connect.c:1423 #, c-format msgid "WSAIoctl(SIO_KEEPALIVE_VALS) failed: %ui\n" msgstr "ошибка в WSAIoctl(SIO_KEEPALIVE_VALS): %ui\n" -#: fe-connect.c:1426 +#: fe-connect.c:1475 #, c-format msgid "invalid port number: \"%s\"\n" msgstr "неверный номер порта: \"%s\"\n" -#: fe-connect.c:1459 +#: fe-connect.c:1508 #, c-format msgid "Unix-domain socket path \"%s\" is too long (maximum %d bytes)\n" msgstr "длина пути доменного Ñокета \"%s\" превышает предел (%d байт)\n" -#: fe-connect.c:1478 +#: fe-connect.c:1527 #, c-format msgid "could not translate host name \"%s\" to address: %s\n" msgstr "преобразовать Ð¸Ð¼Ñ \"%s\" в Ð°Ð´Ñ€ÐµÑ Ð½Ðµ удалоÑÑŒ: %s\n" -#: fe-connect.c:1482 +#: fe-connect.c:1531 #, c-format msgid "could not translate Unix-domain socket path \"%s\" to address: %s\n" msgstr "" "преобразовать путь к доменному Ñокету UNIX \"%s\" в Ð°Ð´Ñ€ÐµÑ Ð½Ðµ удалоÑÑŒ: %s\n" -#: fe-connect.c:1687 +#: fe-connect.c:1736 msgid "invalid connection state, probably indicative of memory corruption\n" msgstr "неверное ÑоÑтоÑние ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ - возможно разрушение памÑти\n" -#: fe-connect.c:1727 +#: fe-connect.c:1776 #, c-format msgid "could not create socket: %s\n" msgstr "не удалоÑÑŒ Ñоздать Ñокет: %s\n" -#: fe-connect.c:1749 +#: fe-connect.c:1798 #, c-format msgid "could not set socket to nonblocking mode: %s\n" msgstr "не удалоÑÑŒ перевеÑти Ñокет в неблокирующий режим: %s\n" -#: fe-connect.c:1760 +#: fe-connect.c:1809 #, c-format msgid "could not set socket to close-on-exec mode: %s\n" msgstr "" "не удалоÑÑŒ перевеÑти Ñокет в режим Ð·Ð°ÐºÑ€Ñ‹Ñ‚Ð¸Ñ Ð¿Ñ€Ð¸ выполнении (close-on-exec): " "%s\n" -#: fe-connect.c:1779 +#: fe-connect.c:1828 msgid "keepalives parameter must be an integer\n" msgstr "параметр keepalives должен быть целым чиÑлом\n" -#: fe-connect.c:1792 -#, c-format -msgid "setsockopt(SO_KEEPALIVE) failed: %s\n" -msgstr "ошибка в setsockopt(SO_KEEPALIVE): %s\n" - -#: fe-connect.c:1929 +#: fe-connect.c:1979 #, c-format msgid "could not get socket error status: %s\n" msgstr "не удалоÑÑŒ получить ÑÑ‚Ð°Ñ‚ÑƒÑ Ð¾ÑˆÐ¸Ð±ÐºÐ¸ Ñокета: %s\n" -#: fe-connect.c:1963 +#: fe-connect.c:2013 #, c-format msgid "could not get client address from socket: %s\n" msgstr "не удалоÑÑŒ получить Ð°Ð´Ñ€ÐµÑ ÐºÐ»Ð¸ÐµÐ½Ñ‚Ð° из Ñокета: %s\n" -#: fe-connect.c:2005 +#: fe-connect.c:2055 msgid "requirepeer parameter is not supported on this platform\n" msgstr "параметр requirepeer не поддерживаетÑÑ Ð² Ñтой ОС\n" -#: fe-connect.c:2008 +#: fe-connect.c:2058 #, c-format msgid "could not get peer credentials: %s\n" msgstr "не удалоÑÑŒ получить учётные данные Ñервера: %s\n" -#: fe-connect.c:2031 +#: fe-connect.c:2081 #, c-format msgid "requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n" msgstr "" "requirepeer допуÑкает подключение только к \"%s\", но Ñервер работает под " "именем \"%s\"\n" -#: fe-connect.c:2065 +#: fe-connect.c:2115 #, c-format msgid "could not send SSL negotiation packet: %s\n" msgstr "не удалоÑÑŒ отправить пакет ÑоглаÑÐ¾Ð²Ð°Ð½Ð¸Ñ SSL: %s\n" -#: fe-connect.c:2104 +#: fe-connect.c:2154 #, c-format msgid "could not send startup packet: %s\n" msgstr "не удалоÑÑŒ отправить Ñтартовый пакет: %s\n" -#: fe-connect.c:2174 +#: fe-connect.c:2224 msgid "server does not support SSL, but SSL was required\n" msgstr "затребовано подключение через SSL, но Ñервер не поддерживает SSL\n" -#: fe-connect.c:2200 +#: fe-connect.c:2250 #, c-format msgid "received invalid response to SSL negotiation: %c\n" msgstr "получен неверный ответ на ÑоглаÑование SSL: %c\n" -#: fe-connect.c:2275 fe-connect.c:2308 +#: fe-connect.c:2325 fe-connect.c:2358 #, c-format msgid "expected authentication request from server, but received %c\n" msgstr "ожидалÑÑ Ð·Ð°Ð¿Ñ€Ð¾Ñ Ð°ÑƒÑ‚ÐµÐ½Ñ‚Ð¸Ñ„Ð¸ÐºÐ°Ñ†Ð¸Ð¸ от Ñервера, но получено: %c\n" -#: fe-connect.c:2475 +#: fe-connect.c:2525 #, c-format msgid "out of memory allocating GSSAPI buffer (%d)" msgstr "недоÑтаточно памÑти Ð´Ð»Ñ Ð±ÑƒÑ„ÐµÑ€Ð° GSSAPI (%d)" -#: fe-connect.c:2560 +#: fe-connect.c:2610 msgid "unexpected message from server during startup\n" msgstr "неожиданное Ñообщение от Ñервера в начале работы\n" -#: fe-connect.c:2654 +#: fe-connect.c:2704 #, c-format msgid "invalid connection state %d, probably indicative of memory corruption\n" msgstr "неверное ÑоÑтоÑние ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ %d - возможно разрушение памÑти\n" -#: fe-connect.c:3090 fe-connect.c:3150 +#: fe-connect.c:3105 fe-connect.c:3165 #, c-format msgid "PGEventProc \"%s\" failed during PGEVT_CONNRESET event\n" msgstr "ошибка в PGEventProc \"%s\" при обработке ÑÐ¾Ð±Ñ‹Ñ‚Ð¸Ñ PGEVT_CONNRESET\n" -#: fe-connect.c:3497 +#: fe-connect.c:3512 #, c-format msgid "invalid LDAP URL \"%s\": scheme must be ldap://\n" msgstr "некорректный Ð°Ð´Ñ€ÐµÑ LDAP \"%s\": Ñхема должна быть ldap://\n" -#: fe-connect.c:3512 +#: fe-connect.c:3527 #, c-format msgid "invalid LDAP URL \"%s\": missing distinguished name\n" msgstr "некорректный Ð°Ð´Ñ€ÐµÑ LDAP \"%s\": отÑутÑтвует уникальное имÑ\n" -#: fe-connect.c:3523 fe-connect.c:3576 +#: fe-connect.c:3538 fe-connect.c:3591 #, c-format msgid "invalid LDAP URL \"%s\": must have exactly one attribute\n" msgstr "некорректный Ð°Ð´Ñ€ÐµÑ LDAP \"%s\": должен быть только один атрибут\n" -#: fe-connect.c:3533 fe-connect.c:3590 +#: fe-connect.c:3548 fe-connect.c:3605 #, c-format msgid "invalid LDAP URL \"%s\": must have search scope (base/one/sub)\n" msgstr "" "некорректный Ð°Ð´Ñ€ÐµÑ LDAP \"%s\": не указана облаÑÑ‚ÑŒ поиÑка (base/one/sub)\n" -#: fe-connect.c:3544 +#: fe-connect.c:3559 #, c-format msgid "invalid LDAP URL \"%s\": no filter\n" msgstr "некорректный Ð°Ð´Ñ€ÐµÑ LDAP \"%s\": нет фильтра\n" -#: fe-connect.c:3565 +#: fe-connect.c:3580 #, c-format msgid "invalid LDAP URL \"%s\": invalid port number\n" msgstr "некорректный Ð°Ð´Ñ€ÐµÑ LDAP \"%s\": неверный номер порта\n" -#: fe-connect.c:3599 +#: fe-connect.c:3614 msgid "could not create LDAP structure\n" msgstr "не удалоÑÑŒ Ñоздать Ñтруктуру LDAP\n" -#: fe-connect.c:3675 +#: fe-connect.c:3690 #, c-format msgid "lookup on LDAP server failed: %s\n" msgstr "ошибка поиÑка на Ñервере LDAP: %s\n" -#: fe-connect.c:3686 +#: fe-connect.c:3701 msgid "more than one entry found on LDAP lookup\n" msgstr "при поиÑке LDAP найдено более одного вхождениÑ\n" -#: fe-connect.c:3687 fe-connect.c:3699 +#: fe-connect.c:3702 fe-connect.c:3714 msgid "no entry found on LDAP lookup\n" msgstr "при поиÑке LDAP ничего не найдено\n" -#: fe-connect.c:3710 fe-connect.c:3723 +#: fe-connect.c:3725 fe-connect.c:3738 msgid "attribute has no values on LDAP lookup\n" msgstr "атрибут не Ñодержит значений при поиÑке LDAP\n" -#: fe-connect.c:3775 fe-connect.c:3794 fe-connect.c:4313 +#: fe-connect.c:3790 fe-connect.c:3809 fe-connect.c:4328 #, c-format msgid "missing \"=\" after \"%s\" in connection info string\n" msgstr "в Ñтроке ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ð½ÐµÑ‚ \"=\" поÑле \"%s\"\n" -#: fe-connect.c:3867 fe-connect.c:4498 fe-connect.c:5212 +#: fe-connect.c:3882 fe-connect.c:4513 fe-connect.c:5251 #, c-format msgid "invalid connection option \"%s\"\n" msgstr "неверный параметр ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ \"%s\"\n" -#: fe-connect.c:3883 fe-connect.c:4362 +#: fe-connect.c:3898 fe-connect.c:4377 msgid "unterminated quoted string in connection info string\n" msgstr "в Ñтроке ÑÐ¾ÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ Ð½Ðµ хватает закрывающей кавычки\n" -#: fe-connect.c:3923 +#: fe-connect.c:3938 msgid "could not get home directory to locate service definition file" msgstr "" "не удалоÑÑŒ получить домашний каталог Ð´Ð»Ñ Ð·Ð°Ð³Ñ€ÑƒÐ·ÐºÐ¸ файла определений Ñлужб" -#: fe-connect.c:3956 +#: fe-connect.c:3971 #, c-format msgid "definition of service \"%s\" not found\n" msgstr "определение Ñлужбы \"%s\" не найдено\n" -#: fe-connect.c:3979 +#: fe-connect.c:3994 #, c-format msgid "service file \"%s\" not found\n" msgstr "файл определений Ñлужб \"%s\" не найден\n" -#: fe-connect.c:3992 +#: fe-connect.c:4007 #, c-format msgid "line %d too long in service file \"%s\"\n" msgstr "Ñлишком Ð´Ð»Ð¸Ð½Ð½Ð°Ñ Ñтрока (%d) в файле определений Ñлужб \"%s\"\n" -#: fe-connect.c:4063 fe-connect.c:4107 +#: fe-connect.c:4078 fe-connect.c:4122 #, c-format msgid "syntax error in service file \"%s\", line %d\n" msgstr "ÑинтакÑичеÑÐºÐ°Ñ Ð¾ÑˆÐ¸Ð±ÐºÐ° в файле Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ Ñлужб \"%s\" (Ñтрока %d)\n" -#: fe-connect.c:4074 +#: fe-connect.c:4089 #, c-format msgid "" "nested service specifications not supported in service file \"%s\", line %d\n" @@ -392,24 +381,24 @@ msgstr "" "рекурÑивные Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ Ñлужб не поддерживаютÑÑ (файл Ð¾Ð¿Ñ€ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ Ñлужб \"%s" "\", Ñтрока %d)\n" -#: fe-connect.c:4756 +#: fe-connect.c:4795 #, c-format msgid "invalid URI propagated to internal parser routine: \"%s\"\n" msgstr "во внутреннюю процедуру разбора Ñтроки передан ошибочный URI: \"%s\"\n" -#: fe-connect.c:4826 +#: fe-connect.c:4865 #, c-format msgid "" "end of string reached when looking for matching \"]\" in IPv6 host address " "in URI: \"%s\"\n" msgstr "URI не Ñодержит Ñимвол \"]\" поÑле адреÑа IPv6: \"%s\"\n" -#: fe-connect.c:4833 +#: fe-connect.c:4872 #, c-format msgid "IPv6 host address may not be empty in URI: \"%s\"\n" msgstr "IPv6, ÑодержащийÑÑ Ð² URI, не может быть пуÑтым: \"%s\"\n" -#: fe-connect.c:4848 +#: fe-connect.c:4887 #, c-format msgid "" "unexpected character \"%c\" at position %d in URI (expected \":\" or \"/\"): " @@ -418,41 +407,41 @@ msgstr "" "неожиданный Ñимвол \"%c\" в позиции %d в URI (ожидалоÑÑŒ \":\" или \"/\"): " "\"%s\"\n" -#: fe-connect.c:4962 +#: fe-connect.c:5001 #, c-format msgid "extra key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "лишний разделитель ключа/Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ \"=\" в параметрах URI: \"%s\"\n" -#: fe-connect.c:4982 +#: fe-connect.c:5021 #, c-format msgid "missing key/value separator \"=\" in URI query parameter: \"%s\"\n" msgstr "в параметрах URI не хватает Ñ€Ð°Ð·Ð´ÐµÐ»Ð¸Ñ‚ÐµÐ»Ñ ÐºÐ»ÑŽÑ‡Ð°/Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ \"=\": \"%s\"\n" -#: fe-connect.c:5033 +#: fe-connect.c:5072 #, c-format msgid "invalid URI query parameter: \"%s\"\n" msgstr "неверный параметр в URI: \"%s\"\n" -#: fe-connect.c:5107 +#: fe-connect.c:5146 #, c-format msgid "invalid percent-encoded token: \"%s\"\n" msgstr "неверный Ñимвол, закодированный Ñ %%: \"%s\"\n" -#: fe-connect.c:5117 +#: fe-connect.c:5156 #, c-format msgid "forbidden value %%00 in percent-encoded value: \"%s\"\n" msgstr "недопуÑтимое значение %%00 Ð´Ð»Ñ Ñимвола, закодированного Ñ %%: \"%s\"\n" -#: fe-connect.c:5451 +#: fe-connect.c:5490 msgid "connection pointer is NULL\n" msgstr "нулевой указатель ÑоединениÑ\n" -#: fe-connect.c:5749 +#: fe-connect.c:5788 #, c-format msgid "WARNING: password file \"%s\" is not a plain file\n" msgstr "ПРЕДУПРЕЖДЕÐИЕ: файл паролей \"%s\" - не обычный файл\n" -#: fe-connect.c:5758 +#: fe-connect.c:5797 #, c-format msgid "" "WARNING: password file \"%s\" has group or world access; permissions should " @@ -461,7 +450,7 @@ msgstr "" "ПРЕДУПРЕЖДЕÐИЕ: к файлу паролей \"%s\" имеют доÑтуп вÑе или группа; права " "должны быть u=rw (0600) или более ограниченные\n" -#: fe-connect.c:5872 +#: fe-connect.c:5911 #, c-format msgid "password retrieved from file \"%s\"\n" msgstr "пароль получен из файла \"%s\"\n" @@ -1045,6 +1034,18 @@ msgstr "не удалоÑÑŒ передать данные Ñерверу: %s\n" msgid "unrecognized socket error: 0x%08X/%d" msgstr "нераÑÐ¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð°Ñ Ð¾ÑˆÐ¸Ð±ÐºÐ° Ñокета: 0x%08X/%d" +#~ msgid "setsockopt(TCP_KEEPIDLE) failed: %s\n" +#~ msgstr "ошибка в setsockopt(TCP_KEEPIDLE): %s\n" + +#~ msgid "setsockopt(TCP_KEEPALIVE) failed: %s\n" +#~ msgstr "ошибка в setsockopt(TCP_KEEPALIVE): %s\n" + +#~ msgid "setsockopt(TCP_KEEPINTVL) failed: %s\n" +#~ msgstr "ошибка в setsockopt(TCP_KEEPINTVL): %s\n" + +#~ msgid "setsockopt(SO_KEEPALIVE) failed: %s\n" +#~ msgstr "ошибка в setsockopt(SO_KEEPALIVE): %s\n" + #~ msgid "could not acquire mutex: %s\n" #~ msgstr "не удалоÑÑŒ заблокировать Ñемафор: %s\n" diff --git a/src/pl/plperl/po/es.po b/src/pl/plperl/po/es.po index c1b5698d91..09cd64dfae 100644 --- a/src/pl/plperl/po/es.po +++ b/src/pl/plperl/po/es.po @@ -10,7 +10,7 @@ msgid "" msgstr "" "Project-Id-Version: plperl (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:48+0000\n" +"POT-Creation-Date: 2017-08-27 21:47+0000\n" "PO-Revision-Date: 2016-05-25 11:29-0500\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL-es-Ayuda \n" @@ -20,205 +20,205 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 1.8.7\n" -#: plperl.c:405 +#: plperl.c:422 msgid "If true, trusted and untrusted Perl code will be compiled in strict mode." msgstr "Si es verdadero, se compilará código Perl confiable y no confiable en modo «strict»." -#: plperl.c:419 +#: plperl.c:436 msgid "Perl initialization code to execute when a Perl interpreter is initialized." msgstr "Código Perl de inicialización a ejecutar cuando un intérprete Perl es inicializado." -#: plperl.c:441 +#: plperl.c:458 msgid "Perl initialization code to execute once when plperl is first used." msgstr "Código Perl de inicialización a ejecutar cuando plperl se usa por primera vez." -#: plperl.c:449 +#: plperl.c:466 msgid "Perl initialization code to execute once when plperlu is first used." msgstr "Código Perl de inicialización a ejecutar cuando plperlu se usa por primera vez." -#: plperl.c:646 +#: plperl.c:663 #, c-format msgid "cannot allocate multiple Perl interpreters on this platform" msgstr "no se pueden instanciar múltiples intérpretes Perl en esta plataforma" -#: plperl.c:666 plperl.c:841 plperl.c:847 plperl.c:961 plperl.c:973 -#: plperl.c:1016 plperl.c:1037 plperl.c:2080 plperl.c:2189 plperl.c:2256 -#: plperl.c:2318 +#: plperl.c:686 plperl.c:870 plperl.c:876 plperl.c:993 plperl.c:1005 +#: plperl.c:1048 plperl.c:1071 plperl.c:2126 plperl.c:2236 plperl.c:2304 +#: plperl.c:2367 #, c-format msgid "%s" msgstr "%s" -#: plperl.c:667 +#: plperl.c:687 #, c-format msgid "while executing PostgreSQL::InServer::SPI::bootstrap" msgstr "mientras se ejecutaba PostgreSQL::InServer::SPI::bootstrap" -#: plperl.c:842 +#: plperl.c:871 #, c-format msgid "while parsing Perl initialization" msgstr "mientras se interpretaba la inicialización de Perl" -#: plperl.c:848 +#: plperl.c:877 #, c-format msgid "while running Perl initialization" msgstr "mientras se ejecutaba la inicialización de Perl" -#: plperl.c:962 +#: plperl.c:994 #, c-format msgid "while executing PLC_TRUSTED" msgstr "mientras se ejecutaba PLC_TRUSTED" -#: plperl.c:974 +#: plperl.c:1006 #, c-format msgid "while executing utf8fix" msgstr "mientras se ejecutaba utf8fix" -#: plperl.c:1017 +#: plperl.c:1049 #, c-format msgid "while executing plperl.on_plperl_init" msgstr "mientras se ejecutaba plperl.on_plperl_init" -#: plperl.c:1038 +#: plperl.c:1072 #, c-format msgid "while executing plperl.on_plperlu_init" msgstr "mientras se ejecutaba plperl.on_plperlu_init" -#: plperl.c:1082 plperl.c:1722 +#: plperl.c:1117 plperl.c:1767 #, c-format msgid "Perl hash contains nonexistent column \"%s\"" msgstr "el hash de Perl contiene el columna inexistente «%s»" -#: plperl.c:1167 +#: plperl.c:1205 #, c-format msgid "number of array dimensions (%d) exceeds the maximum allowed (%d)" msgstr "el número de dimensiones del array (%d) excede el máximo permitido (%d)" -#: plperl.c:1179 plperl.c:1196 +#: plperl.c:1217 plperl.c:1234 #, c-format msgid "multidimensional arrays must have array expressions with matching dimensions" msgstr "los arrays multidimensionales deben tener expresiones de arrays con dimensiones coincidentes" -#: plperl.c:1231 +#: plperl.c:1270 #, c-format msgid "cannot convert Perl array to non-array type %s" msgstr "no se puede convertir un array de Perl al tipo no-array %s" -#: plperl.c:1333 +#: plperl.c:1372 #, c-format msgid "cannot convert Perl hash to non-composite type %s" msgstr "no se puede convertir un hash de Perl al tipo no compuesto %s" -#: plperl.c:1344 +#: plperl.c:1383 #, c-format msgid "function returning record called in context that cannot accept type record" msgstr "se llamó una función que retorna un registro en un contexto que no puede aceptarlo" -#: plperl.c:1359 +#: plperl.c:1398 #, c-format msgid "PL/Perl function must return reference to hash or array" msgstr "una función Perl debe retornar una referencia a un hash o array" -#: plperl.c:1396 +#: plperl.c:1435 #, c-format msgid "lookup failed for type %s" msgstr "búsqueda del tipo %s falló" -#: plperl.c:1699 +#: plperl.c:1744 #, c-format msgid "$_TD->{new} does not exist" msgstr "$_TD->{new} no existe" -#: plperl.c:1703 +#: plperl.c:1748 #, c-format msgid "$_TD->{new} is not a hash reference" msgstr "$_TD->{new} no es una referencia a un hash" -#: plperl.c:1956 plperl.c:2790 +#: plperl.c:2001 plperl.c:2838 #, c-format msgid "PL/Perl functions cannot return type %s" msgstr "las funciones en PL/Perl no pueden retornar el tipo %s" -#: plperl.c:1969 plperl.c:2835 +#: plperl.c:2014 plperl.c:2883 #, c-format msgid "PL/Perl functions cannot accept type %s" msgstr "funciones de PL/Perl no pueden aceptar el tipo %s" -#: plperl.c:2085 +#: plperl.c:2131 #, c-format msgid "didn't get a CODE reference from compiling function \"%s\"" msgstr "no se obtuvo una referencia CODE en la compilación de la función «%s»" -#: plperl.c:2177 +#: plperl.c:2224 #, c-format msgid "didn't get a return item from function" msgstr "no se obtuvo un elemento de retorno desde la función" -#: plperl.c:2220 plperl.c:2286 +#: plperl.c:2268 plperl.c:2335 #, c-format msgid "couldn't fetch $_TD" msgstr "no se pudo obtener $_TD" -#: plperl.c:2244 plperl.c:2306 +#: plperl.c:2292 plperl.c:2355 #, c-format msgid "didn't get a return item from trigger function" msgstr "no se obtuvo un elemento de retorno desde la función de disparador" -#: plperl.c:2363 +#: plperl.c:2412 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "se llamó a una función que retorna un conjunto en un contexto que no puede aceptarlo" -#: plperl.c:2407 +#: plperl.c:2457 #, c-format msgid "set-returning PL/Perl function must return reference to array or use return_next" msgstr "una función PL/Perl que retorna un conjunto debe retornar una referencia a un array o usar return_next" -#: plperl.c:2521 +#: plperl.c:2571 #, c-format msgid "ignoring modified row in DELETE trigger" msgstr "ignorando la tupla modificada en el disparador DELETE" -#: plperl.c:2529 +#: plperl.c:2579 #, c-format msgid "result of PL/Perl trigger function must be undef, \"SKIP\", or \"MODIFY\"" msgstr "el resultado de la función disparadora en PL/Perl debe ser undef, «SKIP» o «MODIFY»" -#: plperl.c:2708 plperl.c:2718 +#: plperl.c:2756 plperl.c:2766 #, c-format msgid "out of memory" msgstr "memoria agotada" -#: plperl.c:2782 +#: plperl.c:2830 #, c-format msgid "trigger functions can only be called as triggers" msgstr "las funciones disparadoras sólo pueden ser llamadas como disparadores" -#: plperl.c:3121 +#: plperl.c:3171 #, c-format msgid "query result has too many rows to fit in a Perl array" msgstr "el resultado de la consulta tiene demasiados registros y no entran en un array de Perl" -#: plperl.c:3166 +#: plperl.c:3241 #, c-format msgid "cannot use return_next in a non-SETOF function" msgstr "no se puede utilizar return_next en una función sin SETOF" -#: plperl.c:3220 +#: plperl.c:3301 #, c-format msgid "SETOF-composite-returning PL/Perl function must call return_next with reference to hash" msgstr "una función Perl que retorna SETOF de un tipo compuesto debe invocar return_next con una referencia a un hash" -#: plperl.c:3948 +#: plperl.c:4075 #, c-format msgid "PL/Perl function \"%s\"" msgstr "función PL/Perl «%s»" -#: plperl.c:3960 +#: plperl.c:4087 #, c-format msgid "compilation of PL/Perl function \"%s\"" msgstr "compilación de la función PL/Perl «%s»" -#: plperl.c:3969 +#: plperl.c:4096 #, c-format msgid "PL/Perl anonymous code block" msgstr "bloque de código anónimo de PL/Perl" diff --git a/src/pl/plperl/po/ru.po b/src/pl/plperl/po/ru.po index ca66ed12cd..65eeeedd23 100644 --- a/src/pl/plperl/po/ru.po +++ b/src/pl/plperl/po/ru.po @@ -1,13 +1,13 @@ # Russian message translation file for plperl # Copyright (C) 2012-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" "Project-Id-Version: plperl (PostgreSQL current)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2016-09-20 18:07+0000\n" +"POT-Creation-Date: 2017-08-17 17:47+0000\n" "PO-Revision-Date: 2016-09-20 12:00+0300\n" "Last-Translator: Alexander Lakhin \n" "Language-Team: Russian \n" @@ -18,90 +18,90 @@ msgstr "" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" -#: plperl.c:405 +#: plperl.c:422 msgid "" "If true, trusted and untrusted Perl code will be compiled in strict mode." msgstr "" "ЕÑли Ñтот параметр равен true, доверенный и недоверенный код Perl будет " "компилироватьÑÑ Ð² Ñтрогом режиме." -#: plperl.c:419 +#: plperl.c:436 msgid "" "Perl initialization code to execute when a Perl interpreter is initialized." msgstr "" "Код инициализации Perl, который выполнÑетÑÑ Ð¿Ñ€Ð¸ инициализации интерпретатора " "Perl." -#: plperl.c:441 +#: plperl.c:458 msgid "Perl initialization code to execute once when plperl is first used." msgstr "" "Код инициализации Perl, который выполнÑетÑÑ Ð¾Ð´Ð¸Ð½ раз, при первом " "иÑпользовании plperl." -#: plperl.c:449 +#: plperl.c:466 msgid "Perl initialization code to execute once when plperlu is first used." msgstr "" "Код инициализации Perl, который выполнÑетÑÑ Ð¾Ð´Ð¸Ð½ раз, при первом " "иÑпользовании plperlu." -#: plperl.c:646 +#: plperl.c:663 #, c-format msgid "cannot allocate multiple Perl interpreters on this platform" msgstr "на Ñтой платформе Ð½ÐµÐ»ÑŒÐ·Ñ Ð·Ð°Ð¿ÑƒÑтить множеÑтво интерпретаторов Perl" -#: plperl.c:666 plperl.c:841 plperl.c:847 plperl.c:961 plperl.c:973 -#: plperl.c:1016 plperl.c:1037 plperl.c:2080 plperl.c:2189 plperl.c:2256 -#: plperl.c:2318 +#: plperl.c:686 plperl.c:870 plperl.c:876 plperl.c:993 plperl.c:1005 +#: plperl.c:1048 plperl.c:1071 plperl.c:2126 plperl.c:2236 plperl.c:2304 +#: plperl.c:2367 #, c-format msgid "%s" msgstr "%s" -#: plperl.c:667 +#: plperl.c:687 #, c-format msgid "while executing PostgreSQL::InServer::SPI::bootstrap" msgstr "при выполнении PostgreSQL::InServer::SPI::bootstrap" -#: plperl.c:842 +#: plperl.c:871 #, c-format msgid "while parsing Perl initialization" msgstr "при разборе параметров инициализации Perl" -#: plperl.c:848 +#: plperl.c:877 #, c-format msgid "while running Perl initialization" msgstr "при выполнении инициализации Perl" -#: plperl.c:962 +#: plperl.c:994 #, c-format msgid "while executing PLC_TRUSTED" msgstr "при выполнении PLC_TRUSTED" -#: plperl.c:974 +#: plperl.c:1006 #, c-format msgid "while executing utf8fix" msgstr "при выполнении utf8fix" -#: plperl.c:1017 +#: plperl.c:1049 #, c-format msgid "while executing plperl.on_plperl_init" msgstr "при выполнении plperl.on_plperl_init" -#: plperl.c:1038 +#: plperl.c:1072 #, c-format msgid "while executing plperl.on_plperlu_init" msgstr "при выполнении plperl.on_plperlu_init" -#: plperl.c:1082 plperl.c:1722 +#: plperl.c:1117 plperl.c:1767 #, c-format msgid "Perl hash contains nonexistent column \"%s\"" msgstr "Perl-хеш Ñодержит неÑущеÑтвующий Ñтолбец \"%s\"" -#: plperl.c:1167 +#: plperl.c:1205 #, c-format msgid "number of array dimensions (%d) exceeds the maximum allowed (%d)" msgstr "чиÑло размерноÑтей маÑÑива (%d) превышает предел (%d)" -#: plperl.c:1179 plperl.c:1196 +#: plperl.c:1217 plperl.c:1234 #, c-format msgid "" "multidimensional arrays must have array expressions with matching dimensions" @@ -109,80 +109,80 @@ msgstr "" "Ð´Ð»Ñ Ð¼Ð½Ð¾Ð³Ð¾Ð¼ÐµÑ€Ð½Ñ‹Ñ… маÑÑивов должны задаватьÑÑ Ð²Ñ‹Ñ€Ð°Ð¶ÐµÐ½Ð¸Ñ Ñ ÑоответÑтвующими " "размерноÑÑ‚Ñми" -#: plperl.c:1231 +#: plperl.c:1270 #, c-format msgid "cannot convert Perl array to non-array type %s" msgstr "Perl-маÑÑив Ð½ÐµÐ»ÑŒÐ·Ñ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ñ‚ÑŒ в тип не маÑÑива %s" -#: plperl.c:1333 +#: plperl.c:1372 #, c-format msgid "cannot convert Perl hash to non-composite type %s" msgstr "Perl-хеш Ð½ÐµÐ»ÑŒÐ·Ñ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ñ‚ÑŒ в не ÑоÑтавной тип %s" -#: plperl.c:1344 +#: plperl.c:1383 #, c-format msgid "" "function returning record called in context that cannot accept type record" msgstr "" "функциÑ, Ð²Ð¾Ð·Ð²Ñ€Ð°Ñ‰Ð°ÑŽÑ‰Ð°Ñ Ð·Ð°Ð¿Ð¸ÑÑŒ, вызвана в контекÑте, не допуÑкающем Ñтот тип" -#: plperl.c:1359 +#: plperl.c:1398 #, c-format msgid "PL/Perl function must return reference to hash or array" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ PL/Perl должна возвращать ÑÑылку на хеш или маÑÑив" -#: plperl.c:1396 +#: plperl.c:1435 #, c-format msgid "lookup failed for type %s" msgstr "найти тип %s не удалоÑÑŒ" -#: plperl.c:1699 +#: plperl.c:1744 #, c-format msgid "$_TD->{new} does not exist" msgstr "$_TD->{new} не ÑущеÑтвует" -#: plperl.c:1703 +#: plperl.c:1748 #, c-format msgid "$_TD->{new} is not a hash reference" msgstr "$_TD->{new} - не ÑÑылка на хеш" -#: plperl.c:1956 plperl.c:2790 +#: plperl.c:2001 plperl.c:2838 #, c-format msgid "PL/Perl functions cannot return type %s" msgstr "функции PL/Perl не могут возвращать тип %s" -#: plperl.c:1969 plperl.c:2835 +#: plperl.c:2014 plperl.c:2883 #, c-format msgid "PL/Perl functions cannot accept type %s" msgstr "функции PL/Perl не могут принимать тип %s" -#: plperl.c:2085 +#: plperl.c:2131 #, c-format msgid "didn't get a CODE reference from compiling function \"%s\"" msgstr "не удалоÑÑŒ получить ÑÑылку на код поÑле компилÑции функции \"%s\"" -#: plperl.c:2177 +#: plperl.c:2224 #, c-format msgid "didn't get a return item from function" msgstr "не удалоÑÑŒ получить возвращаемый Ñлемент от функции" -#: plperl.c:2220 plperl.c:2286 +#: plperl.c:2268 plperl.c:2335 #, c-format msgid "couldn't fetch $_TD" msgstr "не удалоÑÑŒ получить $_TD" -#: plperl.c:2244 plperl.c:2306 +#: plperl.c:2292 plperl.c:2355 #, c-format msgid "didn't get a return item from trigger function" msgstr "не удалоÑÑŒ получить возвращаемый Ñлемент от триггерной функции" -#: plperl.c:2363 +#: plperl.c:2412 #, c-format msgid "set-valued function called in context that cannot accept a set" msgstr "" "функциÑ, Ð²Ð¾Ð·Ð²Ñ€Ð°Ñ‰Ð°ÑŽÑ‰Ð°Ñ Ð¼Ð½Ð¾Ð¶ÐµÑтво, вызвана в контекÑте, где ему нет меÑта" -#: plperl.c:2407 +#: plperl.c:2457 #, c-format msgid "" "set-returning PL/Perl function must return reference to array or use " @@ -191,12 +191,12 @@ msgstr "" "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ PL/Perl, Ð²Ð¾Ð·Ð²Ñ€Ð°Ñ‰Ð°ÑŽÑ‰Ð°Ñ Ð¼Ð½Ð¾Ð¶ÐµÑтво, должна возвращать ÑÑылку на маÑÑив " "или вызывать return_next" -#: plperl.c:2521 +#: plperl.c:2571 #, c-format msgid "ignoring modified row in DELETE trigger" msgstr "в триггере DELETE Ð¸Ð·Ð¼ÐµÐ½Ñ‘Ð½Ð½Ð°Ñ Ñтрока игнорируетÑÑ" -#: plperl.c:2529 +#: plperl.c:2579 #, c-format msgid "" "result of PL/Perl trigger function must be undef, \"SKIP\", or \"MODIFY\"" @@ -204,29 +204,29 @@ msgstr "" "результатом триггерной функции PL/Perl должен быть undef, \"SKIP\" или " "\"MODIFY\"" -#: plperl.c:2708 plperl.c:2718 +#: plperl.c:2756 plperl.c:2766 #, c-format msgid "out of memory" msgstr "нехватка памÑти" -#: plperl.c:2782 +#: plperl.c:2830 #, c-format msgid "trigger functions can only be called as triggers" msgstr "триггерные функции могут вызыватьÑÑ Ñ‚Ð¾Ð»ÑŒÐºÐ¾ в триггерах" -#: plperl.c:3121 +#: plperl.c:3171 #, c-format msgid "query result has too many rows to fit in a Perl array" msgstr "" "результат запроÑа Ñодержит Ñлишком много Ñтрок Ð´Ð»Ñ Ð¿ÐµÑ€ÐµÐ´Ð°Ñ‡Ð¸ в маÑÑиве Perl" -#: plperl.c:3166 +#: plperl.c:3241 #, c-format msgid "cannot use return_next in a non-SETOF function" msgstr "" "return_next можно иÑпользовать только в функциÑÑ…, возвращающих множеÑтва" -#: plperl.c:3220 +#: plperl.c:3301 #, c-format msgid "" "SETOF-composite-returning PL/Perl function must call return_next with " @@ -235,17 +235,17 @@ msgstr "" "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ PL/Perl, Ð²Ð¾Ð·Ð²Ñ€Ð°Ñ‰Ð°ÑŽÑ‰Ð°Ñ ÑоÑтавное множеÑтво, должна вызывать " "return_next Ñо ÑÑылкой на хеш" -#: plperl.c:3948 +#: plperl.c:4075 #, c-format msgid "PL/Perl function \"%s\"" msgstr "Ñ„ÑƒÐ½ÐºÑ†Ð¸Ñ PL/Perl \"%s\"" -#: plperl.c:3960 +#: plperl.c:4087 #, c-format msgid "compilation of PL/Perl function \"%s\"" msgstr "компилÑÑ†Ð¸Ñ Ñ„ÑƒÐ½ÐºÑ†Ð¸Ð¸ PL/Perl \"%s\"" -#: plperl.c:3969 +#: plperl.c:4096 #, c-format msgid "PL/Perl anonymous code block" msgstr "анонимный блок кода PL/Perl" diff --git a/src/pl/plpgsql/src/po/es.po b/src/pl/plpgsql/src/po/es.po index 4bb96608fd..896971169b 100644 --- a/src/pl/plpgsql/src/po/es.po +++ b/src/pl/plpgsql/src/po/es.po @@ -12,8 +12,8 @@ msgid "" msgstr "" "Project-Id-Version: plpgsql (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:48+0000\n" -"PO-Revision-Date: 2016-05-25 11:54-0500\n" +"POT-Creation-Date: 2017-08-27 21:47+0000\n" +"PO-Revision-Date: 2017-08-28 11:38+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL-es-Ayuda \n" "Language: es\n" @@ -824,6 +824,3 @@ msgstr "%s al final de la entrada" #, c-format msgid "%s at or near \"%s\"" msgstr "%s en o cerca de «%s»" - -#~ msgid "label does not exist" -#~ msgstr "la etiqueta no existe" diff --git a/src/pl/plpgsql/src/po/ru.po b/src/pl/plpgsql/src/po/ru.po index e38b7086c7..1004ca3aad 100644 --- a/src/pl/plpgsql/src/po/ru.po +++ b/src/pl/plpgsql/src/po/ru.po @@ -1,7 +1,7 @@ # Russian message translation file for plpgsql # Copyright (C) 2012-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" diff --git a/src/pl/plpython/po/es.po b/src/pl/plpython/po/es.po index d3a7fc2283..35f23bb50d 100644 --- a/src/pl/plpython/po/es.po +++ b/src/pl/plpython/po/es.po @@ -10,8 +10,8 @@ msgid "" msgstr "" "Project-Id-Version: plpython (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:48+0000\n" -"PO-Revision-Date: 2017-05-19 18:35-0400\n" +"POT-Creation-Date: 2017-08-27 21:46+0000\n" +"PO-Revision-Date: 2017-08-28 11:38+0200\n" "Last-Translator: Carlos Chapi \n" "Language-Team: PgSQL-es-Ayuda \n" "Language: es\n" @@ -442,21 +442,3 @@ msgstr "no se pudo convertir el objeto Unicode de Python a bytes" #, c-format msgid "could not extract bytes from encoded string" msgstr "no se pudo extraer bytes desde la cadena codificada" - -#~ msgid "could not create the base SPI exceptions" -#~ msgstr "no se pudo crear las excepciones SPI basales" - -#~ msgid "the message is already specified" -#~ msgstr "el mensaje ya está definido" - -#~ msgid "PL/Python does not support conversion to arrays of row types." -#~ msgstr "PL/Python no soporta la conversión de arrays a tipos de registro." - -#~ msgid "plpy.prepare does not support composite types" -#~ msgstr "plpy.prepare no soporta tipos compuestos" - -#~ msgid "Start a new session to use a different Python major version." -#~ msgstr "Inicie una nueva sesión para usar una versión mayor de Python diferente." - -#~ msgid "This session has previously used Python major version %d, and it is now attempting to use Python major version %d." -#~ msgstr "Esta sesión ha usado previamente la versión mayor de Python %d, y ahora está intentando usar la versión mayor %d." diff --git a/src/pl/plpython/po/ru.po b/src/pl/plpython/po/ru.po index a038e9d554..df85d196db 100644 --- a/src/pl/plpython/po/ru.po +++ b/src/pl/plpython/po/ru.po @@ -1,7 +1,7 @@ # Russian message translation file for plpython # Copyright (C) 2012-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2012-2016, 2017. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" diff --git a/src/pl/tcl/po/es.po b/src/pl/tcl/po/es.po index 69bd8f66d6..d4faaa480f 100644 --- a/src/pl/tcl/po/es.po +++ b/src/pl/tcl/po/es.po @@ -10,7 +10,7 @@ msgid "" msgstr "" "Project-Id-Version: pltcl (PostgreSQL 9.6)\n" "Report-Msgid-Bugs-To: pgsql-bugs@postgresql.org\n" -"POT-Creation-Date: 2017-05-18 07:48+0000\n" +"POT-Creation-Date: 2017-08-27 21:46+0000\n" "PO-Revision-Date: 2016-05-03 12:17-0300\n" "Last-Translator: Ãlvaro Herrera \n" "Language-Team: PgSQL-es-Ayuda \n" diff --git a/src/pl/tcl/po/ru.po b/src/pl/tcl/po/ru.po index 701a377388..7e07de69fe 100644 --- a/src/pl/tcl/po/ru.po +++ b/src/pl/tcl/po/ru.po @@ -1,7 +1,7 @@ # Russian message translation file for pltcl # Copyright (C) 2012-2016 PostgreSQL Global Development Group # This file is distributed under the same license as the PostgreSQL package. -# Alexander Lakhin , 2012-2016. +# Alexander Lakhin , 2012-2017. # msgid "" msgstr "" From c72a656725ef07fb8752333e0f3bdaf3c0aee999 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 28 Aug 2017 11:40:47 -0400 Subject: [PATCH 0212/1139] Doc: adjust release-note credit for parallel pg_restore fix. Discussion: https://postgr.es/m/CAFcNs+pJ6_Ud-zg3vY_Y0mzfESdM34Humt8avKrAKq_H+v18Cg@mail.gmail.com --- doc/src/sgml/release-9.3.sgml | 3 ++- doc/src/sgml/release-9.4.sgml | 3 ++- doc/src/sgml/release-9.5.sgml | 3 ++- doc/src/sgml/release-9.6.sgml | 3 ++- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/doc/src/sgml/release-9.3.sgml b/doc/src/sgml/release-9.3.sgml index ef86abb6ec..9eaf5d54db 100644 --- a/doc/src/sgml/release-9.3.sgml +++ b/doc/src/sgml/release-9.3.sgml @@ -103,7 +103,8 @@ COMMIT; Fix crash in pg_restore when using parallel mode and - using a list file to select a subset of items to restore (Tom Lane) + using a list file to select a subset of items to restore + (Fabrízio de Royes Mello) diff --git a/doc/src/sgml/release-9.4.sgml b/doc/src/sgml/release-9.4.sgml index 310e287c5b..1c5c25d2b3 100644 --- a/doc/src/sgml/release-9.4.sgml +++ b/doc/src/sgml/release-9.4.sgml @@ -119,7 +119,8 @@ COMMIT; Fix crash in pg_restore when using parallel mode and - using a list file to select a subset of items to restore (Tom Lane) + using a list file to select a subset of items to restore + (Fabrízio de Royes Mello) diff --git a/doc/src/sgml/release-9.5.sgml b/doc/src/sgml/release-9.5.sgml index 37beac8b27..b7f522deb9 100644 --- a/doc/src/sgml/release-9.5.sgml +++ b/doc/src/sgml/release-9.5.sgml @@ -102,7 +102,8 @@ COMMIT; Fix crash in pg_restore when using parallel mode and - using a list file to select a subset of items to restore (Tom Lane) + using a list file to select a subset of items to restore + (Fabrízio de Royes Mello) diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml index 03be048938..f5e4869fec 100644 --- a/doc/src/sgml/release-9.6.sgml +++ b/doc/src/sgml/release-9.6.sgml @@ -160,7 +160,8 @@ Branch: REL9_3_STABLE [ece4bd901] 2017-08-19 13:39:38 -0400 --> Fix crash in pg_restore when using parallel mode and - using a list file to select a subset of items to restore (Tom Lane) + using a list file to select a subset of items to restore + (Fabrízio de Royes Mello) From 254bb39b720426f7a4616cb6b40f810c44b24b20 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 28 Aug 2017 17:21:42 -0400 Subject: [PATCH 0213/1139] Stamp 9.6.5. --- configure | 18 +++++++++--------- configure.in | 2 +- doc/bug.template | 2 +- src/include/pg_config.h.win32 | 8 ++++---- src/interfaces/libpq/libpq.rc.in | 8 ++++---- src/port/win32ver.rc | 4 ++-- 6 files changed, 21 insertions(+), 21 deletions(-) diff --git a/configure b/configure index 3c9603751a..cc098aabdb 100755 --- a/configure +++ b/configure @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for PostgreSQL 9.6.4. +# Generated by GNU Autoconf 2.69 for PostgreSQL 9.6.5. # # Report bugs to . # @@ -582,8 +582,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='PostgreSQL' PACKAGE_TARNAME='postgresql' -PACKAGE_VERSION='9.6.4' -PACKAGE_STRING='PostgreSQL 9.6.4' +PACKAGE_VERSION='9.6.5' +PACKAGE_STRING='PostgreSQL 9.6.5' PACKAGE_BUGREPORT='pgsql-bugs@postgresql.org' PACKAGE_URL='' @@ -1399,7 +1399,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures PostgreSQL 9.6.4 to adapt to many kinds of systems. +\`configure' configures PostgreSQL 9.6.5 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1464,7 +1464,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of PostgreSQL 9.6.4:";; + short | recursive ) echo "Configuration of PostgreSQL 9.6.5:";; esac cat <<\_ACEOF @@ -1616,7 +1616,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -PostgreSQL configure 9.6.4 +PostgreSQL configure 9.6.5 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -2327,7 +2327,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by PostgreSQL $as_me 9.6.4, which was +It was created by PostgreSQL $as_me 9.6.5, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -16477,7 +16477,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by PostgreSQL $as_me 9.6.4, which was +This file was extended by PostgreSQL $as_me 9.6.5, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -16547,7 +16547,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -PostgreSQL config.status 9.6.4 +PostgreSQL config.status 9.6.5 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" diff --git a/configure.in b/configure.in index 9e7474e5fc..3cb0d19967 100644 --- a/configure.in +++ b/configure.in @@ -17,7 +17,7 @@ dnl Read the Autoconf manual for details. dnl m4_pattern_forbid(^PGAC_)dnl to catch undefined macros -AC_INIT([PostgreSQL], [9.6.4], [pgsql-bugs@postgresql.org]) +AC_INIT([PostgreSQL], [9.6.5], [pgsql-bugs@postgresql.org]) m4_if(m4_defn([m4_PACKAGE_VERSION]), [2.69], [], [m4_fatal([Autoconf version 2.69 is required. Untested combinations of 'autoconf' and PostgreSQL versions are not diff --git a/doc/bug.template b/doc/bug.template index 47aea48f38..8dca218e99 100644 --- a/doc/bug.template +++ b/doc/bug.template @@ -27,7 +27,7 @@ System Configuration: Operating System (example: Linux 2.4.18) : - PostgreSQL version (example: PostgreSQL 9.6.4): PostgreSQL 9.6.4 + PostgreSQL version (example: PostgreSQL 9.6.5): PostgreSQL 9.6.5 Compiler used (example: gcc 3.3.5) : diff --git a/src/include/pg_config.h.win32 b/src/include/pg_config.h.win32 index 35fe28cde8..0e17ccbb40 100644 --- a/src/include/pg_config.h.win32 +++ b/src/include/pg_config.h.win32 @@ -554,10 +554,10 @@ #define PACKAGE_NAME "PostgreSQL" /* Define to the full name and version of this package. */ -#define PACKAGE_STRING "PostgreSQL 9.6.4" +#define PACKAGE_STRING "PostgreSQL 9.6.5" /* Define to the version of this package. */ -#define PACKAGE_VERSION "9.6.4" +#define PACKAGE_VERSION "9.6.5" /* Define to the name of a signed 128-bit integer type. */ #undef PG_INT128_TYPE @@ -566,10 +566,10 @@ #define PG_INT64_TYPE long long int /* PostgreSQL version as a string */ -#define PG_VERSION "9.6.4" +#define PG_VERSION "9.6.5" /* PostgreSQL version as a number */ -#define PG_VERSION_NUM 90604 +#define PG_VERSION_NUM 90605 /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "postgresql" diff --git a/src/interfaces/libpq/libpq.rc.in b/src/interfaces/libpq/libpq.rc.in index 7c2edf9077..da975742b7 100644 --- a/src/interfaces/libpq/libpq.rc.in +++ b/src/interfaces/libpq/libpq.rc.in @@ -1,8 +1,8 @@ #include VS_VERSION_INFO VERSIONINFO - FILEVERSION 9,6,4,0 - PRODUCTVERSION 9,6,4,0 + FILEVERSION 9,6,5,0 + PRODUCTVERSION 9,6,5,0 FILEFLAGSMASK 0x3fL FILEFLAGS 0 FILEOS VOS__WINDOWS32 @@ -15,13 +15,13 @@ BEGIN BEGIN VALUE "CompanyName", "\0" VALUE "FileDescription", "PostgreSQL Access Library\0" - VALUE "FileVersion", "9.6.4\0" + VALUE "FileVersion", "9.6.5\0" VALUE "InternalName", "libpq\0" VALUE "LegalCopyright", "Copyright (C) 2016\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", "libpq.dll\0" VALUE "ProductName", "PostgreSQL\0" - VALUE "ProductVersion", "9.6.4\0" + VALUE "ProductVersion", "9.6.5\0" END END BLOCK "VarFileInfo" diff --git a/src/port/win32ver.rc b/src/port/win32ver.rc index bb73cc63a8..2b99e094c2 100644 --- a/src/port/win32ver.rc +++ b/src/port/win32ver.rc @@ -2,8 +2,8 @@ #include "pg_config.h" VS_VERSION_INFO VERSIONINFO - FILEVERSION 9,6,4,0 - PRODUCTVERSION 9,6,4,0 + FILEVERSION 9,6,5,0 + PRODUCTVERSION 9,6,5,0 FILEFLAGSMASK 0x17L FILEFLAGS 0x0L FILEOS VOS_NT_WINDOWS32 From dbc7a7d9201da6cd85dc0bba4499c2367a2cf9d7 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 29 Aug 2017 09:34:21 -0400 Subject: [PATCH 0214/1139] Improve docs about numeric formatting patterns (to_char/to_number). The explanation about "0" versus "9" format characters was confusing and arguably wrong; the discussion of sign handling wasn't very good either. Notably, while it's accurate to say that "FM" strips leading zeroes in date/time values, what it really does with numeric values is to strip *trailing* zeroes, and then only if you wrote "9" rather than "0". Per gripes from Erwin Brandstetter. Discussion: https://postgr.es/m/CAGHENJ7jgRbTn6nf48xNZ=FHgL2WQ4X8mYsUAU57f-vq8PubEw@mail.gmail.com Discussion: https://postgr.es/m/CAGHENJ45ymd=GOCu1vwV9u7GmCR80_5tW0fP9C_gJKbruGMHvQ@mail.gmail.com --- doc/src/sgml/func.sgml | 63 ++++++++++++++++++++++++++++++------------ 1 file changed, 46 insertions(+), 17 deletions(-) diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index 12bbc391e0..8482601294 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -6277,11 +6277,11 @@ SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}'); 9 - value with the specified number of digits + digit position (can be dropped if insignificant) 0 - value with leading zeros + digit position (will not be dropped, even if insignificant) . (period) @@ -6289,7 +6289,7 @@ SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}'); , (comma) - group (thousand) separator + group (thousands) separator PR @@ -6347,6 +6347,39 @@ SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}'); Usage notes for numeric formatting: + + + 0 specifies a digit position that will always be printed, + even if it contains a leading/trailing zero. 9 also + specifies a digit position, but if it is a leading zero then it will + be replaced by a space, while if it is a trailing zero and fill mode + is specified then it will be deleted. (For to_number(), + these two pattern characters are equivalent.) + + + + + + The pattern characters S, L, D, + and G represent the sign, currency symbol, decimal point, + and thousands separator characters defined by the current locale + (see + and ). The pattern characters period + and comma represent those exact characters, with the meanings of + decimal point and thousands separator, regardless of locale. + + + + + + If no explicit provision is made for a sign + in to_char()'s pattern, one column will be reserved for + the sign, and it will be anchored to (appear just left of) the + number. If S appears just left of some 9's, + it will likewise be anchored to the number. + + + A sign formatted using SG, PL, or @@ -6354,18 +6387,10 @@ SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}'); the number; for example, to_char(-12, 'MI9999') produces '-  12' but to_char(-12, 'S9999') produces '  -12'. - The Oracle implementation does not allow the use of + (The Oracle implementation does not allow the use of MI before 9, but rather requires that 9 precede - MI. - - - - - - 9 results in a value with the same number of - digits as there are 9s. If a digit is - not available it outputs a space. + MI.) @@ -6412,8 +6437,8 @@ SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}'); Certain modifiers can be applied to any template pattern to alter its - behavior. For example, FM9999 - is the 9999 pattern with the + behavior. For example, FM99.99 + is the 99.99 pattern with the FM modifier. shows the modifier patterns for numeric formatting. @@ -6432,8 +6457,8 @@ SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}'); FM prefix - fill mode (suppress leading zeroes and padding blanks) - FM9999 + fill mode (suppress trailing zeroes and padding blanks) + FM99.99 TH suffix @@ -6480,6 +6505,10 @@ SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}'); to_char(-0.1, 'FM9.99') '-.1' + + to_char(-0.1, 'FM90.99') + '-0.1' + to_char(0.1, '0.9') ' 0.1' From bc95e5874ac9bc027d1549677ec4f61b9d36a2a3 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 29 Aug 2017 15:18:01 -0400 Subject: [PATCH 0215/1139] Teach libpq to detect integer overflow in the row count of a PGresult. Adding more than 1 billion rows to a PGresult would overflow its ntups and tupArrSize fields, leading to client crashes. It'd be desirable to use wider fields on 64-bit machines, but because all of libpq's external APIs use plain "int" for row counters, that's going to be hard to accomplish without an ABI break. Given the lack of complaints so far, and the general pain that would be involved in using such huge PGresults, let's settle for just preventing the overflow and reporting a useful error message if it does happen. Also, for a couple more lines of code we can increase the threshold of trouble from INT_MAX/2 to INT_MAX rows. To do that, refactor pqAddTuple() to allow returning an error message that replaces the default assumption that it failed because of out-of-memory. Along the way, fix PQsetvalue() so that it reports all failures via pqInternalNotice(). It already did so in the case of bad field number, but neglected to report anything for other error causes. Because of the potential for crashes, this seems like a back-patchable bug fix, despite the lack of field reports. Michael Paquier, per a complaint from Igor Korot. Discussion: https://postgr.es/m/CA+FnnTxyLWyjY1goewmJNxC==HQCCF4fKkoCTa9qR36oRAHDPw@mail.gmail.com --- src/interfaces/libpq/fe-exec.c | 69 +++++++++++++++++++++++++++++----- 1 file changed, 60 insertions(+), 9 deletions(-) diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c index 87ff5659ff..ca20dd130c 100644 --- a/src/interfaces/libpq/fe-exec.c +++ b/src/interfaces/libpq/fe-exec.c @@ -16,6 +16,7 @@ #include #include +#include #include "libpq-fe.h" #include "libpq-int.h" @@ -51,7 +52,8 @@ static bool static_std_strings = false; static PGEvent *dupEvents(PGEvent *events, int count); -static bool pqAddTuple(PGresult *res, PGresAttValue *tup); +static bool pqAddTuple(PGresult *res, PGresAttValue *tup, + const char **errmsgp); static bool PQsendQueryStart(PGconn *conn); static int PQsendQueryGuts(PGconn *conn, const char *command, @@ -416,18 +418,26 @@ dupEvents(PGEvent *events, int count) * equal to PQntuples(res). If it is equal, a new tuple is created and * added to the result. * Returns a non-zero value for success and zero for failure. + * (On failure, we report the specific problem via pqInternalNotice.) */ int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len) { PGresAttValue *attval; + const char *errmsg = NULL; + /* Note that this check also protects us against null "res" */ if (!check_field_number(res, field_num)) return FALSE; /* Invalid tup_num, must be <= ntups */ if (tup_num < 0 || tup_num > res->ntups) + { + pqInternalNotice(&res->noticeHooks, + "row number %d is out of range 0..%d", + tup_num, res->ntups); return FALSE; + } /* need to allocate a new tuple? */ if (tup_num == res->ntups) @@ -440,7 +450,7 @@ PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len) TRUE); if (!tup) - return FALSE; + goto fail; /* initialize each column to NULL */ for (i = 0; i < res->numAttributes; i++) @@ -450,8 +460,8 @@ PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len) } /* add it to the array */ - if (!pqAddTuple(res, tup)) - return FALSE; + if (!pqAddTuple(res, tup, &errmsg)) + goto fail; } attval = &res->tuples[tup_num][field_num]; @@ -471,13 +481,24 @@ PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len) { attval->value = (char *) pqResultAlloc(res, len + 1, TRUE); if (!attval->value) - return FALSE; + goto fail; attval->len = len; memcpy(attval->value, value, len); attval->value[len] = '\0'; } return TRUE; + + /* + * Report failure via pqInternalNotice. If preceding code didn't provide + * an error message, assume "out of memory" was meant. + */ +fail: + if (!errmsg) + errmsg = libpq_gettext("out of memory"); + pqInternalNotice(&res->noticeHooks, "%s", errmsg); + + return FALSE; } /* @@ -847,10 +868,13 @@ pqInternalNotice(const PGNoticeHooks *hooks, const char *fmt,...) /* * pqAddTuple * add a row pointer to the PGresult structure, growing it if necessary - * Returns TRUE if OK, FALSE if not enough memory to add the row + * Returns TRUE if OK, FALSE if an error prevented adding the row + * + * On error, *errmsgp can be set to an error string to be returned. + * If it is left NULL, the error is presumed to be "out of memory". */ static bool -pqAddTuple(PGresult *res, PGresAttValue *tup) +pqAddTuple(PGresult *res, PGresAttValue *tup, const char **errmsgp) { if (res->ntups >= res->tupArrSize) { @@ -865,9 +889,36 @@ pqAddTuple(PGresult *res, PGresAttValue *tup) * existing allocation. Note that the positions beyond res->ntups are * garbage, not necessarily NULL. */ - int newSize = (res->tupArrSize > 0) ? res->tupArrSize * 2 : 128; + int newSize; PGresAttValue **newTuples; + /* + * Since we use integers for row numbers, we can't support more than + * INT_MAX rows. Make sure we allow that many, though. + */ + if (res->tupArrSize <= INT_MAX / 2) + newSize = (res->tupArrSize > 0) ? res->tupArrSize * 2 : 128; + else if (res->tupArrSize < INT_MAX) + newSize = INT_MAX; + else + { + *errmsgp = libpq_gettext("PGresult cannot support more than INT_MAX tuples"); + return FALSE; + } + + /* + * Also, on 32-bit platforms we could, in theory, overflow size_t even + * before newSize gets to INT_MAX. (In practice we'd doubtless hit + * OOM long before that, but let's check.) + */ +#if INT_MAX >= (SIZE_MAX / 2) + if (newSize > SIZE_MAX / sizeof(PGresAttValue *)) + { + *errmsgp = libpq_gettext("size_t overflow"); + return FALSE; + } +#endif + if (res->tuples == NULL) newTuples = (PGresAttValue **) malloc(newSize * sizeof(PGresAttValue *)); @@ -1093,7 +1144,7 @@ pqRowProcessor(PGconn *conn, const char **errmsgp) } /* And add the tuple to the PGresult's tuple array */ - if (!pqAddTuple(res, tup)) + if (!pqAddTuple(res, tup, errmsgp)) goto fail; /* From 941e47fc43cc3d80bfd4112e013a1d11235ead6a Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 29 Aug 2017 15:38:05 -0400 Subject: [PATCH 0216/1139] Doc: document libpq's restriction to INT_MAX rows in a PGresult. As long as PQntuples, PQgetvalue, etc, use "int" for row numbers, we're pretty much stuck with this limitation. The documentation formerly stated that the result of PQntuples "might overflow on 32-bit operating systems", which is just nonsense: that's not where the overflow would happen, and if you did reach an overflow it would not be on a 32-bit machine, because you'd have OOM'd long since. Discussion: https://postgr.es/m/CA+FnnTxyLWyjY1goewmJNxC==HQCCF4fKkoCTa9qR36oRAHDPw@mail.gmail.com --- doc/src/sgml/libpq.sgml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml index 84590a0a6f..7a90cb09a9 100644 --- a/doc/src/sgml/libpq.sgml +++ b/doc/src/sgml/libpq.sgml @@ -3061,9 +3061,10 @@ void PQclear(PGresult *res); - Returns the number of rows (tuples) in the query result. Because - it returns an integer result, large result sets might overflow the - return value on 32-bit operating systems. + Returns the number of rows (tuples) in the query result. + (Note that PGresult objects are limited to no more + than INT_MAX rows, so an int result is + sufficient.) int PQntuples(const PGresult *res); From 9b1d48506a87a0ac61a1501a4253b6e6e524b87a Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Thu, 31 Aug 2017 15:56:21 -0400 Subject: [PATCH 0217/1139] Improve low-level backup documentation. Our documentation hasn't really caught up with the fact that non-exclusive backups can now be taken using pg_start_backup and pg_stop_backup even on standbys. Update. David Steele, reviewed by Robert Haas and Michael Paquier Discussion: http://postgr.es/m/f349b834-1443-ebf0-3c2a-965f944004d7@pgmasters.net --- doc/src/sgml/backup.sgml | 27 +++++++++++++++++++++------ doc/src/sgml/func.sgml | 15 +++++++++++++-- 2 files changed, 34 insertions(+), 8 deletions(-) diff --git a/doc/src/sgml/backup.sgml b/doc/src/sgml/backup.sgml index 03c0dbf1cd..fd696c38db 100644 --- a/doc/src/sgml/backup.sgml +++ b/doc/src/sgml/backup.sgml @@ -889,8 +889,11 @@ SELECT pg_start_backup('label', false, false); SELECT * FROM pg_stop_backup(false); - This terminates the backup mode and performs an automatic switch to - the next WAL segment. The reason for the switch is to arrange for + This terminates backup mode. On a primary, it also performs an automatic + switch to the next WAL segment. On a standby, it is not possible to + automatically switch WAL segments, so you may wish to run + pg_switch_xlog on the primary to perform a manual + switch. The reason for the switch is to arrange for the last WAL segment file written during the backup interval to be ready to archive. @@ -908,7 +911,7 @@ SELECT * FROM pg_stop_backup(false); Once the WAL segment files active during the backup are archived, you are done. The file identified by pg_stop_backup's first return value is the last segment that is required to form a complete set of - backup files. If archive_mode is enabled, + backup files. On a primary, if archive_mode is enabled, pg_stop_backup does not return until the last segment has been archived. Archiving of these files happens automatically since you have @@ -924,6 +927,13 @@ SELECT * FROM pg_stop_backup(false); pg_stop_backup terminates because of this your backup may not be valid. + + + Note that on a standby pg_stop_backup does not wait for + WAL segments to be archived so the backup process must ensure that all WAL + segments required for the backup are successfully archived. + + @@ -932,9 +942,9 @@ SELECT * FROM pg_stop_backup(false); Making an exclusive low level backup The process for an exclusive backup is mostly the same as for a - non-exclusive one, but it differs in a few key steps. It does not allow - more than one concurrent backup to run, and there can be some issues on - the server if it crashes during the backup. Prior to PostgreSQL 9.6, this + non-exclusive one, but it differs in a few key steps. This type of backup + can only be taken on a primary and does not allow concurrent backups. + Prior to PostgreSQL 9.6, this was the only low-level method available, but it is now recommended that all users upgrade their scripts to use non-exclusive backups if possible. @@ -992,6 +1002,11 @@ SELECT pg_start_backup('label', true); for things to consider during this backup. + + Note that if the server crashes during the backup it may not be + possible to restart until the backup_label file has been + manually deleted from the PGDATA directory. + diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index 8482601294..63dfab2009 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -18070,11 +18070,22 @@ postgres=# select pg_start_backup('label_goes_here'); pg_start_backup. In a non-exclusive backup, the contents of the backup_label and tablespace_map are returned in the result of the function, and should be written to files in the - backup (and not in the data directory). + backup (and not in the data directory). When executed on a primary + pg_stop_backup will wait for WAL to be archived, provided that + archiving is enabled. - The function also creates a backup history file in the transaction log + On a standby pg_stop_backup will return immediately without + waiting, so it's important to verify that all required WAL segments have + been archived. If write activity on the primary is low, it may be useful + to run pg_switch_xlog on the primary in order to trigger a + segment switch. + + + + When executed on a primary, the function also creates a backup history file + in the write-ahead log archive area. The history file includes the label given to pg_start_backup, the starting and ending transaction log locations for the backup, and the starting and ending times of the backup. The return From e50d401a83968436c5d794a77b2cc8fa0a31906d Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 1 Sep 2017 13:52:53 -0400 Subject: [PATCH 0218/1139] Ensure SIZE_MAX can be used throughout our code. Pre-C99 platforms may lack and thereby SIZE_MAX. We have a couple of places using the hack "(size_t) -1" as a fallback, but it wasn't universally available; which means the code added in commit 2e70d6b5e fails to compile everywhere. Move that hack to c.h so that we can rely on having SIZE_MAX everywhere. Per discussion, it'd be a good idea to make the macro's value safe for use in #if-tests, but that will take a bit more work. This is just a quick expedient to get the buildfarm green again. Back-patch to all supported branches, like the previous commit. Discussion: https://postgr.es/m/15883.1504278595@sss.pgh.pa.us --- src/include/c.h | 5 +++++ src/include/utils/memutils.h | 2 +- src/timezone/private.h | 4 ---- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/include/c.h b/src/include/c.h index 726f0f3f88..f1f8b11877 100644 --- a/src/include/c.h +++ b/src/include/c.h @@ -340,6 +340,11 @@ typedef unsigned PG_INT128_TYPE uint128; #define PG_INT64_MAX INT64CONST(0x7FFFFFFFFFFFFFFF) #define PG_UINT64_MAX UINT64CONST(0xFFFFFFFFFFFFFFFF) +/* Max value of size_t might also be missing if we don't have stdint.h */ +#ifndef SIZE_MAX +#define SIZE_MAX ((size_t) -1) +#endif + /* Select timestamp representation (float8 or int64) */ #ifdef USE_INTEGER_DATETIMES #define HAVE_INT64_TIMESTAMP diff --git a/src/include/utils/memutils.h b/src/include/utils/memutils.h index e6334a2038..5125833b6a 100644 --- a/src/include/utils/memutils.h +++ b/src/include/utils/memutils.h @@ -41,7 +41,7 @@ #define AllocSizeIsValid(size) ((Size) (size) <= MaxAllocSize) -#define MaxAllocHugeSize ((Size) -1 >> 1) /* SIZE_MAX / 2 */ +#define MaxAllocHugeSize (SIZE_MAX / 2) #define AllocHugeSizeIsValid(size) ((Size) (size) <= MaxAllocHugeSize) diff --git a/src/timezone/private.h b/src/timezone/private.h index f031b17b7e..f78053660e 100644 --- a/src/timezone/private.h +++ b/src/timezone/private.h @@ -48,10 +48,6 @@ /* Unlike 's isdigit, this also works if c < 0 | c > UCHAR_MAX. */ #define is_digit(c) ((unsigned)(c) - '0' <= 9) -#ifndef SIZE_MAX -#define SIZE_MAX ((size_t) -1) -#endif - /* * SunOS 4.1.1 libraries lack remove. */ From 3a0f8e7d3f9a54ab34b69d1fc8c9f7806d67521a Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 1 Sep 2017 15:14:18 -0400 Subject: [PATCH 0219/1139] Make [U]INT64CONST safe for use in #if conditions. Instead of using a cast to force the constant to be the right width, assume we can plaster on an L, UL, LL, or ULL suffix as appropriate. The old approach to this is very hoary, dating from before we were willing to require compilers to have working int64 types. This fix makes the PG_INT64_MIN, PG_INT64_MAX, and PG_UINT64_MAX constants safe to use in preprocessor conditions, where a cast doesn't work. Other symbolic constants that might be defined using [U]INT64CONST are likewise safer than before. Also fix the SIZE_MAX macro to be similarly safe, if we are forced to provide a definition for that. The test added in commit 2e70d6b5e happens to do what we want even with the hack "(size_t) -1" definition, but we could easily get burnt on other tests in future. Back-patch to all supported branches, like the previous commits. Discussion: https://postgr.es/m/15883.1504278595@sss.pgh.pa.us --- configure | 18 ------------------ configure.in | 12 ------------ src/include/c.h | 21 ++++++++++----------- src/include/pg_config.h.in | 4 ---- src/include/pg_config.h.win32 | 8 +------- 5 files changed, 11 insertions(+), 52 deletions(-) diff --git a/configure b/configure index cc098aabdb..2821a8f7e4 100755 --- a/configure +++ b/configure @@ -13726,24 +13726,6 @@ cat >>confdefs.h <<_ACEOF _ACEOF - -if test x"$HAVE_LONG_LONG_INT_64" = xyes ; then - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -#define INT64CONST(x) x##LL -long long int foo = INT64CONST(0x1234567890123456); - -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - -$as_echo "#define HAVE_LL_CONSTANTS 1" >>confdefs.h - -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi - - # If we found "long int" is 64 bits, assume snprintf handles it. If # we found we need to use "long long int", better check. We cope with # snprintfs that use %lld, %qd, or %I64d as the format. If none of these diff --git a/configure.in b/configure.in index 3cb0d19967..a1696db921 100644 --- a/configure.in +++ b/configure.in @@ -1751,18 +1751,6 @@ fi AC_DEFINE_UNQUOTED(PG_INT64_TYPE, $pg_int64_type, [Define to the name of a signed 64-bit integer type.]) -dnl If we need to use "long long int", figure out whether nnnLL notation works. - -if test x"$HAVE_LONG_LONG_INT_64" = xyes ; then - AC_COMPILE_IFELSE([AC_LANG_SOURCE([ -#define INT64CONST(x) x##LL -long long int foo = INT64CONST(0x1234567890123456); -])], - [AC_DEFINE(HAVE_LL_CONSTANTS, 1, [Define to 1 if constants of type 'long long int' should have the suffix LL.])], - []) -fi - - # If we found "long int" is 64 bits, assume snprintf handles it. If # we found we need to use "long long int", better check. We cope with # snprintfs that use %lld, %qd, or %I64d as the format. If none of these diff --git a/src/include/c.h b/src/include/c.h index f1f8b11877..179e6248c7 100644 --- a/src/include/c.h +++ b/src/include/c.h @@ -285,6 +285,8 @@ typedef long int int64; #ifndef HAVE_UINT64 typedef unsigned long int uint64; #endif +#define INT64CONST(x) (x##L) +#define UINT64CONST(x) (x##UL) #elif defined(HAVE_LONG_LONG_INT_64) /* We have working support for "long long int", use that */ @@ -294,20 +296,13 @@ typedef long long int int64; #ifndef HAVE_UINT64 typedef unsigned long long int uint64; #endif +#define INT64CONST(x) (x##LL) +#define UINT64CONST(x) (x##ULL) #else /* neither HAVE_LONG_INT_64 nor HAVE_LONG_LONG_INT_64 */ #error must have a working 64-bit integer datatype #endif -/* Decide if we need to decorate 64-bit constants */ -#ifdef HAVE_LL_CONSTANTS -#define INT64CONST(x) ((int64) x##LL) -#define UINT64CONST(x) ((uint64) x##ULL) -#else -#define INT64CONST(x) ((int64) x) -#define UINT64CONST(x) ((uint64) x) -#endif - /* snprintf format strings to use for 64-bit integers */ #define INT64_FORMAT "%" INT64_MODIFIER "d" #define UINT64_FORMAT "%" INT64_MODIFIER "u" @@ -335,14 +330,18 @@ typedef unsigned PG_INT128_TYPE uint128; #define PG_UINT16_MAX (0xFFFF) #define PG_INT32_MIN (-0x7FFFFFFF-1) #define PG_INT32_MAX (0x7FFFFFFF) -#define PG_UINT32_MAX (0xFFFFFFFF) +#define PG_UINT32_MAX (0xFFFFFFFFU) #define PG_INT64_MIN (-INT64CONST(0x7FFFFFFFFFFFFFFF) - 1) #define PG_INT64_MAX INT64CONST(0x7FFFFFFFFFFFFFFF) #define PG_UINT64_MAX UINT64CONST(0xFFFFFFFFFFFFFFFF) /* Max value of size_t might also be missing if we don't have stdint.h */ #ifndef SIZE_MAX -#define SIZE_MAX ((size_t) -1) +#if SIZEOF_SIZE_T == 8 +#define SIZE_MAX PG_UINT64_MAX +#else +#define SIZE_MAX PG_UINT32_MAX +#endif #endif /* Select timestamp representation (float8 or int64) */ diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in index 7dbfa90bf4..a152371e61 100644 --- a/src/include/pg_config.h.in +++ b/src/include/pg_config.h.in @@ -333,10 +333,6 @@ /* Define to 1 if you have the `z' library (-lz). */ #undef HAVE_LIBZ -/* Define to 1 if constants of type 'long long int' should have the suffix LL. - */ -#undef HAVE_LL_CONSTANTS - /* Define to 1 if the system has the type `locale_t'. */ #undef HAVE_LOCALE_T diff --git a/src/include/pg_config.h.win32 b/src/include/pg_config.h.win32 index 0e17ccbb40..65085d7d31 100644 --- a/src/include/pg_config.h.win32 +++ b/src/include/pg_config.h.win32 @@ -217,12 +217,6 @@ /* Define to 1 if you have the `z' library (-lz). */ /* #undef HAVE_LIBZ */ -/* Define to 1 if constants of type 'long long int' should have the suffix LL. - */ -#if (_MSC_VER > 1200) -#define HAVE_LL_CONSTANTS 1 -#endif - /* Define to 1 if the system has the type `locale_t'. */ #define HAVE_LOCALE_T 1 @@ -231,7 +225,7 @@ /* Define to 1 if `long long int' works and is 64 bits. */ #if (_MSC_VER > 1200) -#define HAVE_LONG_LONG_INT_64 +#define HAVE_LONG_LONG_INT_64 1 #endif /* Define to 1 if you have the `mbstowcs_l' function. */ From 991a5ba73eb0d59713aec299e1245d506a72150e Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Fri, 1 Sep 2017 22:59:27 -0400 Subject: [PATCH 0220/1139] doc: Fix typos and other minor issues Author: Alexander Lakhin --- doc/src/sgml/event-trigger.sgml | 1 + doc/src/sgml/logicaldecoding.sgml | 2 +- doc/src/sgml/perform.sgml | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/event-trigger.sgml b/doc/src/sgml/event-trigger.sgml index 3ed14f08c0..c7b880d7c9 100644 --- a/doc/src/sgml/event-trigger.sgml +++ b/doc/src/sgml/event-trigger.sgml @@ -565,6 +565,7 @@ X - - + CREATE USER MAPPING diff --git a/doc/src/sgml/logicaldecoding.sgml b/doc/src/sgml/logicaldecoding.sgml index bc0c989f22..9bf9abf29b 100644 --- a/doc/src/sgml/logicaldecoding.sgml +++ b/doc/src/sgml/logicaldecoding.sgml @@ -338,7 +338,7 @@ $ pg_recvlogical -d postgres --slot test --drop-slot The pg_replication_slots view and the - pg_stat_replication + pg_stat_replication view provide information about the current state of replication slots and streaming replication connections respectively. These views apply to both physical and logical replication. diff --git a/doc/src/sgml/perform.sgml b/doc/src/sgml/perform.sgml index 7bcbfa7611..a99abdda0c 100644 --- a/doc/src/sgml/perform.sgml +++ b/doc/src/sgml/perform.sgml @@ -1610,7 +1610,7 @@ SELECT * FROM x, y, a, b, c WHERE something AND somethingelse; Increase and ; this reduces the frequency + linkend="guc-checkpoint-timeout">; this reduces the frequency of checkpoints, but increases the storage requirements of /pg_xlog. From a4b0a4d437dc71839999c0d5bed23445abf82d88 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 3 Sep 2017 11:01:08 -0400 Subject: [PATCH 0221/1139] Fix macro-redefinition warning on MSVC. In commit 9d6b160d7, I tweaked pg_config.h.win32 to use "#define HAVE_LONG_LONG_INT_64 1" rather than defining it as empty, for consistency with what happens in an autoconf'd build. But Solution.pm injects another definition of that macro into ecpg_config.h, leading to justifiable (though harmless) compiler whining. Make that one consistent too. Back-patch, like the previous patch. Discussion: https://postgr.es/m/CAEepm=1dWsXROuSbRg8PbKLh0S=8Ou-V8sr05DxmJOF5chBxqQ@mail.gmail.com --- src/tools/msvc/Solution.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/msvc/Solution.pm b/src/tools/msvc/Solution.pm index c155c5f3ca..abedb4f948 100644 --- a/src/tools/msvc/Solution.pm +++ b/src/tools/msvc/Solution.pm @@ -419,7 +419,7 @@ s{PG_VERSION_STR "[^"]+"}{__STRINGIFY(x) #x\n#define __STRINGIFY2(z) __STRINGIFY || confess "Could not open ecpg_config.h"; print O < 1200) -#define HAVE_LONG_LONG_INT_64 +#define HAVE_LONG_LONG_INT_64 1 #define ENABLE_THREAD_SAFETY 1 EOF print O "#define USE_INTEGER_DATETIMES 1\n" From bd75335a83bf0564d6d256d1b78499a5ea489d74 Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Mon, 4 Sep 2017 11:08:52 +0200 Subject: [PATCH 0222/1139] Fix translatable string Discussion: https://postgr.es/m/20170828130545.sdajqlpr37hmmd6a@alvherre.pgsql --- src/bin/pg_rewind/libpq_fetch.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/bin/pg_rewind/libpq_fetch.c b/src/bin/pg_rewind/libpq_fetch.c index e90907bd38..189853b3f1 100644 --- a/src/bin/pg_rewind/libpq_fetch.c +++ b/src/bin/pg_rewind/libpq_fetch.c @@ -271,6 +271,7 @@ receiveFileChunks(const char *sql) char *filename; int filenamelen; int64 chunkoff; + char chunkoff_str[32]; int chunksize; char *chunk; @@ -343,8 +344,13 @@ receiveFileChunks(const char *sql) continue; } - pg_log(PG_DEBUG, "received chunk for file \"%s\", offset " INT64_FORMAT ", size %d\n", - filename, chunkoff, chunksize); + /* + * Separate step to keep platform-dependent format code out of + * translatable strings. + */ + snprintf(chunkoff_str, sizeof(chunkoff_str), INT64_FORMAT, chunkoff); + pg_log(PG_DEBUG, "received chunk for file \"%s\", offset %s, size %d\n", + filename, chunkoff_str, chunksize); open_target_file(filename, false); From 64e2b29bdea0861d6b7509653a676ccc9261bfbb Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 11 Sep 2017 22:02:58 -0400 Subject: [PATCH 0223/1139] Fix RecursiveCopy.pm to cope with disappearing files. When copying from an active database tree, it's possible for files to be deleted after we see them in a readdir() scan but before we can open them. (Once we've got a file open, we don't expect any further errors from it getting unlinked, though.) Tweak RecursiveCopy so it can cope with this case, so as to avoid irreproducible test failures. Back-patch to 9.6 where this code was added. In v10 and HEAD, also remove unused "use RecursiveCopy" in one recovery test script. Michael Paquier and Tom Lane Discussion: https://postgr.es/m/24621.1504924323@sss.pgh.pa.us --- src/test/perl/RecursiveCopy.pm | 64 ++++++++++++++++++++++++---------- 1 file changed, 45 insertions(+), 19 deletions(-) diff --git a/src/test/perl/RecursiveCopy.pm b/src/test/perl/RecursiveCopy.pm index 3e98813286..8be9211c11 100644 --- a/src/test/perl/RecursiveCopy.pm +++ b/src/test/perl/RecursiveCopy.pm @@ -29,12 +29,17 @@ use File::Copy; =head2 copypath($from, $to, %params) Recursively copy all files and directories from $from to $to. +Does not preserve file metadata (e.g., permissions). Only regular files and subdirectories are copied. Trying to copy other types of directory entries raises an exception. Raises an exception if a file would be overwritten, the source directory can't -be read, or any I/O operation fails. Always returns true. +be read, or any I/O operation fails. However, we silently ignore ENOENT on +open, because when copying from a live database it's possible for a file/dir +to be deleted after we see its directory entry but before we can open it. + +Always returns true. If the B parameter is given, it must be a subroutine reference. This subroutine will be called for each entry in the source directory with its @@ -74,6 +79,9 @@ sub copypath $filterfn = sub { return 1; }; } + # Complain if original path is bogus, because _copypath_recurse won't. + die "\"$base_src_dir\" does not exist" if !-e $base_src_dir; + # Start recursive copy from current directory return _copypath_recurse($base_src_dir, $base_dest_dir, "", $filterfn); } @@ -89,12 +97,8 @@ sub _copypath_recurse return 1 unless &$filterfn($curr_path); # Check for symlink -- needed only on source dir - die "Cannot operate on symlinks" if -l $srcpath; - - # Can't handle symlinks or other weird things - die "Source path \"$srcpath\" is not a regular file or directory" - unless -f $srcpath - or -d $srcpath; + # (note: this will fall through quietly if file is already gone) + die "Cannot operate on symlink \"$srcpath\"" if -l $srcpath; # Abort if destination path already exists. Should we allow directories # to exist already? @@ -104,25 +108,47 @@ sub _copypath_recurse # same name and we're done. if (-f $srcpath) { - copy($srcpath, $destpath) + my $fh; + unless (open($fh, '<', $srcpath)) + { + return 1 if ($!{ENOENT}); + die "open($srcpath) failed: $!"; + } + copy($fh, $destpath) or die "copy $srcpath -> $destpath failed: $!"; + close $fh; return 1; } - # Otherwise this is directory: create it on dest and recurse onto it. - mkdir($destpath) or die "mkdir($destpath) failed: $!"; - - opendir(my $directory, $srcpath) or die "could not opendir($srcpath): $!"; - while (my $entry = readdir($directory)) + # If it's a directory, create it on dest and recurse into it. + if (-d $srcpath) { - next if ($entry eq '.' or $entry eq '..'); - _copypath_recurse($base_src_dir, $base_dest_dir, - $curr_path eq '' ? $entry : "$curr_path/$entry", $filterfn) - or die "copypath $srcpath/$entry -> $destpath/$entry failed"; + my $directory; + unless (opendir($directory, $srcpath)) + { + return 1 if ($!{ENOENT}); + die "opendir($srcpath) failed: $!"; + } + + mkdir($destpath) or die "mkdir($destpath) failed: $!"; + + while (my $entry = readdir($directory)) + { + next if ($entry eq '.' or $entry eq '..'); + _copypath_recurse($base_src_dir, $base_dest_dir, + $curr_path eq '' ? $entry : "$curr_path/$entry", $filterfn) + or die "copypath $srcpath/$entry -> $destpath/$entry failed"; + } + + closedir($directory); + return 1; } - closedir($directory); - return 1; + # If it disappeared from sight, that's OK. + return 1 if !-e $srcpath; + + # Else it's some weird file type; complain. + die "Source path \"$srcpath\" is not a regular file or directory"; } 1; From 8d787bd66c8f64db85e0102f1dc1a0978d060fa1 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Tue, 12 Sep 2017 13:17:52 -0400 Subject: [PATCH 0224/1139] docs: improve pg_upgrade rsync instructions This explains how rsync accomplishes updating standby servers and clarifies the instructions. Reported-by: Andreas Joseph Krogh Discussion: https://postgr.es/m/VisenaEmail.10.2b4049e43870bd16.15d898d696f@tc7-visena Backpatch-through: 9.5 --- doc/src/sgml/ref/pgupgrade.sgml | 42 ++++++++++++++++++++------------- 1 file changed, 25 insertions(+), 17 deletions(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index b4f775ff8e..f497eda4b8 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -332,7 +332,7 @@ NET STOP postgresql-9.0 Also, if upgrading standby servers, change wal_level to replica in the postgresql.conf file on - the new master cluster. + the new primary cluster. @@ -425,8 +425,8 @@ pg_upgrade.exe linkend="streaming-replication">) or Log-Shipping (see ) standby servers, follow these steps to upgrade them. You will not be running pg_upgrade - on the standby servers, but rather rsync. Do not - start any servers yet. + on the standby servers, but rather rsync on the + primary. Do not start any servers yet. @@ -455,7 +455,7 @@ pg_upgrade.exe Install the same custom shared object files on the new standbys - that you installed in the new master cluster. + that you installed in the new primary cluster. @@ -482,25 +482,33 @@ pg_upgrade.exe Run <application>rsync</> - From a directory that is above the old and new database cluster - directories, run this for each slave: + From a directory on the primary server that is above the old and + new database cluster directories, run this on the + primary for each standby server: rsync --archive --delete --hard-links --size-only old_pgdata new_pgdata remote_dir where + + + What rsync does is to copy files from the + primary to the standby, and, if pg_upgrade's + @@ -517,8 +525,8 @@ rsync --archive --delete --hard-links --size-only old_pgdata new_pgdata remote_d Configure the servers for log shipping. (You do not need to run pg_start_backup() and pg_stop_backup() - or take a file system backup as the slaves are still synchronized - with the master.) + or take a file system backup as the standbys are still synchronized + with the primary.) From 3b3327ef2762bf6753ccd5bee75a4935a09bd0a1 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Wed, 13 Sep 2017 09:11:28 -0400 Subject: [PATCH 0225/1139] docs: improve pg_upgrade standby instructions This makes it clear that pg_upgrade standby upgrade instructions should only be used in link mode, adds examples, and explains how rsync works with links. Reported-by: Andreas Joseph Krogh Discussion: https://postgr.es/m/VisenaEmail.6c.c0e592c5af4ef0a2.15e785dcb61@tc7-visena Backpatch-through: 9.5 --- doc/src/sgml/ref/pgupgrade.sgml | 64 +++++++++++++++++++++------------ 1 file changed, 41 insertions(+), 23 deletions(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index f497eda4b8..40563cfbda 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -423,10 +423,12 @@ pg_upgrade.exe If you have Streaming Replication (see ) or Log-Shipping (see ) standby servers, follow these steps to - upgrade them. You will not be running pg_upgrade - on the standby servers, but rather rsync on the - primary. Do not start any servers yet. + linkend="warm-standby">) standby servers, and used link mode, + follow these steps to upgrade them. You will not be running + pg_upgrade on the standby servers, but rather + rsync on the primary. Do not start any servers yet. + If you did not use link mode, skip the instructions in + this section and simply recreate the standby servers. @@ -482,9 +484,11 @@ pg_upgrade.exe Run <application>rsync</> - From a directory on the primary server that is above the old and - new database cluster directories, run this on the - primary for each standby server: + When using link mode, standby servers can be quickly upgraded using + rsync. To accomplish this, from a directory on + the primary server that is above the old and new database cluster + directories, run this on the primary for each standby + server: rsync --archive --delete --hard-links --size-only old_pgdata new_pgdata remote_dir @@ -492,30 +496,44 @@ rsync --archive --delete --hard-links --size-only old_pgdata new_pgdata remote_d where - What rsync does is to copy files from the - primary to the standby, and, if pg_upgrade's - If you have tablespaces, you will need to run a similar - rsync command for each tablespace directory. If you - have relocated pg_xlog outside the data directories, - rsync must be run on those directories too. + rsync command for each tablespace directory, e.g.: + + +rsync --archive --delete --hard-links --size-only /vol1/pg_tblsp/PG_9.5_201510051 \ + /vol1/pg_tblsp/PG_9.6_201608131 standby.example.com:/vol1/pg_tblsp + + + If you have relocated pg_xlog outside the data + directories, rsync must be run on those directories + too. From e5c8d43abde8cbb4b7fbbb5a215e497f11bf6fe6 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Wed, 13 Sep 2017 09:22:18 -0400 Subject: [PATCH 0226/1139] docs: adjust "link mode" mention in pg_upgrade streaming steps Backpatch-through: 9.5 --- doc/src/sgml/ref/pgupgrade.sgml | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index 40563cfbda..cf7191907e 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -421,14 +421,14 @@ pg_upgrade.exe Upgrade Streaming Replication and Log-Shipping standby servers - If you have Streaming Replication (see ) or Log-Shipping (see ) standby servers, and used link mode, - follow these steps to upgrade them. You will not be running - pg_upgrade on the standby servers, but rather - rsync on the primary. Do not start any servers yet. - If you did not use link mode, skip the instructions in - this section and simply recreate the standby servers. + linkend="warm-standby">) standby servers, follow these steps to + upgrade them. You will not be running pg_upgrade on + the standby servers, but rather rsync on the primary. + Do not start any servers yet. If you did not use link + mode, skip the instructions in this section and simply recreate the + standby servers. From 839ee1811d053da4cdd0a44aea8fe7b011284be2 Mon Sep 17 00:00:00 2001 From: Michael Meskes Date: Sat, 26 Aug 2017 12:57:21 +0200 Subject: [PATCH 0227/1139] Make setlocale in ECPG test cases thread aware on Windows. Fix threaded test cases on Windows not to crash in setlocale() which can be global or local to a thread on Windows. Author: Christian Ullrich --- .../ecpg/test/expected/thread-alloc.c | 39 ++++++----- .../ecpg/test/expected/thread-descriptor.c | 19 ++++-- .../ecpg/test/expected/thread-prep.c | 67 ++++++++++--------- .../ecpg/test/expected/thread-thread.c | 60 +++++++++-------- .../test/expected/thread-thread_implicit.c | 60 +++++++++-------- src/interfaces/ecpg/test/thread/alloc.pgc | 5 ++ .../ecpg/test/thread/descriptor.pgc | 5 ++ src/interfaces/ecpg/test/thread/prep.pgc | 5 ++ src/interfaces/ecpg/test/thread/thread.pgc | 6 ++ .../ecpg/test/thread/thread_implicit.pgc | 6 ++ 10 files changed, 163 insertions(+), 109 deletions(-) diff --git a/src/interfaces/ecpg/test/expected/thread-alloc.c b/src/interfaces/ecpg/test/expected/thread-alloc.c index 49f1cd19c4..1312580f57 100644 --- a/src/interfaces/ecpg/test/expected/thread-alloc.c +++ b/src/interfaces/ecpg/test/expected/thread-alloc.c @@ -22,6 +22,7 @@ main(void) #define WIN32_LEAN_AND_MEAN #include #include +#include #else #include #endif @@ -99,7 +100,7 @@ struct sqlca_t *ECPGget_sqlca(void); #endif -#line 24 "alloc.pgc" +#line 25 "alloc.pgc" #line 1 "regression.h" @@ -109,14 +110,14 @@ struct sqlca_t *ECPGget_sqlca(void); -#line 25 "alloc.pgc" +#line 26 "alloc.pgc" /* exec sql whenever sqlerror sqlprint ; */ -#line 27 "alloc.pgc" +#line 28 "alloc.pgc" /* exec sql whenever not found sqlprint ; */ -#line 28 "alloc.pgc" +#line 29 "alloc.pgc" #ifdef WIN32 @@ -127,59 +128,63 @@ static void* fn(void* arg) { int i; +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + /* exec sql begin declare section */ -#line 39 "alloc.pgc" +#line 44 "alloc.pgc" int value ; -#line 40 "alloc.pgc" +#line 45 "alloc.pgc" char name [ 100 ] ; -#line 41 "alloc.pgc" +#line 46 "alloc.pgc" char ** r = NULL ; /* exec sql end declare section */ -#line 42 "alloc.pgc" +#line 47 "alloc.pgc" value = (long)arg; sprintf(name, "Connection: %d", value); { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , name, 0); -#line 47 "alloc.pgc" +#line 52 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 47 "alloc.pgc" +#line 52 "alloc.pgc" { ECPGsetcommit(__LINE__, "on", NULL); -#line 48 "alloc.pgc" +#line 53 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 48 "alloc.pgc" +#line 53 "alloc.pgc" for (i = 1; i <= REPEATS; ++i) { { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "select relname from pg_class where relname = 'pg_class'", ECPGt_EOIT, ECPGt_char,&(r),(long)0,(long)0,(1)*sizeof(char), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT); -#line 51 "alloc.pgc" +#line 56 "alloc.pgc" if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint(); -#line 51 "alloc.pgc" +#line 56 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 51 "alloc.pgc" +#line 56 "alloc.pgc" free(r); r = NULL; } { ECPGdisconnect(__LINE__, name); -#line 55 "alloc.pgc" +#line 60 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 55 "alloc.pgc" +#line 60 "alloc.pgc" return 0; diff --git a/src/interfaces/ecpg/test/expected/thread-descriptor.c b/src/interfaces/ecpg/test/expected/thread-descriptor.c index e2be89dec0..8698db78e6 100644 --- a/src/interfaces/ecpg/test/expected/thread-descriptor.c +++ b/src/interfaces/ecpg/test/expected/thread-descriptor.c @@ -12,6 +12,7 @@ #define WIN32_LEAN_AND_MEAN #include #include +#include #else #include #endif @@ -90,13 +91,13 @@ struct sqlca_t *ECPGget_sqlca(void); #endif -#line 15 "descriptor.pgc" +#line 16 "descriptor.pgc" /* exec sql whenever sqlerror sqlprint ; */ -#line 16 "descriptor.pgc" +#line 17 "descriptor.pgc" /* exec sql whenever not found sqlprint ; */ -#line 17 "descriptor.pgc" +#line 18 "descriptor.pgc" #if defined(ENABLE_THREAD_SAFETY) && defined(WIN32) @@ -107,19 +108,23 @@ static void* fn(void* arg) { int i; +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + for (i = 1; i <= REPEATS; ++i) { ECPGallocate_desc(__LINE__, "mydesc"); -#line 29 "descriptor.pgc" +#line 34 "descriptor.pgc" if (sqlca.sqlcode < 0) sqlprint(); -#line 29 "descriptor.pgc" +#line 34 "descriptor.pgc" ECPGdeallocate_desc(__LINE__, "mydesc"); -#line 30 "descriptor.pgc" +#line 35 "descriptor.pgc" if (sqlca.sqlcode < 0) sqlprint(); -#line 30 "descriptor.pgc" +#line 35 "descriptor.pgc" } diff --git a/src/interfaces/ecpg/test/expected/thread-prep.c b/src/interfaces/ecpg/test/expected/thread-prep.c index 4d06b90b98..1b023e68a2 100644 --- a/src/interfaces/ecpg/test/expected/thread-prep.c +++ b/src/interfaces/ecpg/test/expected/thread-prep.c @@ -22,6 +22,7 @@ main(void) #define WIN32_LEAN_AND_MEAN #include #include +#include #else #include #endif @@ -99,7 +100,7 @@ struct sqlca_t *ECPGget_sqlca(void); #endif -#line 24 "prep.pgc" +#line 25 "prep.pgc" #line 1 "regression.h" @@ -109,14 +110,14 @@ struct sqlca_t *ECPGget_sqlca(void); -#line 25 "prep.pgc" +#line 26 "prep.pgc" /* exec sql whenever sqlerror sqlprint ; */ -#line 27 "prep.pgc" +#line 28 "prep.pgc" /* exec sql whenever not found sqlprint ; */ -#line 28 "prep.pgc" +#line 29 "prep.pgc" #ifdef WIN32 @@ -127,69 +128,73 @@ static void* fn(void* arg) { int i; +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + /* exec sql begin declare section */ -#line 39 "prep.pgc" +#line 44 "prep.pgc" int value ; -#line 40 "prep.pgc" +#line 45 "prep.pgc" char name [ 100 ] ; -#line 41 "prep.pgc" +#line 46 "prep.pgc" char query [ 256 ] = "INSERT INTO T VALUES ( ? )" ; /* exec sql end declare section */ -#line 42 "prep.pgc" +#line 47 "prep.pgc" value = (long)arg; sprintf(name, "Connection: %d", value); { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , name, 0); -#line 47 "prep.pgc" +#line 52 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 47 "prep.pgc" +#line 52 "prep.pgc" { ECPGsetcommit(__LINE__, "on", NULL); -#line 48 "prep.pgc" +#line 53 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 48 "prep.pgc" +#line 53 "prep.pgc" for (i = 1; i <= REPEATS; ++i) { { ECPGprepare(__LINE__, NULL, 0, "i", query); -#line 51 "prep.pgc" +#line 56 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 51 "prep.pgc" +#line 56 "prep.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_execute, "i", ECPGt_int,&(value),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT); -#line 52 "prep.pgc" +#line 57 "prep.pgc" if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint(); -#line 52 "prep.pgc" +#line 57 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 52 "prep.pgc" +#line 57 "prep.pgc" } { ECPGdeallocate(__LINE__, 0, NULL, "i"); -#line 54 "prep.pgc" +#line 59 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 54 "prep.pgc" +#line 59 "prep.pgc" { ECPGdisconnect(__LINE__, name); -#line 55 "prep.pgc" +#line 60 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 55 "prep.pgc" +#line 60 "prep.pgc" return 0; @@ -205,34 +210,34 @@ int main () #endif { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , NULL, 0); -#line 69 "prep.pgc" +#line 74 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 69 "prep.pgc" +#line 74 "prep.pgc" { ECPGsetcommit(__LINE__, "on", NULL); -#line 70 "prep.pgc" +#line 75 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 70 "prep.pgc" +#line 75 "prep.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "drop table if exists T", ECPGt_EOIT, ECPGt_EORT); -#line 71 "prep.pgc" +#line 76 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 71 "prep.pgc" +#line 76 "prep.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "create table T ( i int )", ECPGt_EOIT, ECPGt_EORT); -#line 72 "prep.pgc" +#line 77 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 72 "prep.pgc" +#line 77 "prep.pgc" { ECPGdisconnect(__LINE__, "CURRENT"); -#line 73 "prep.pgc" +#line 78 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 73 "prep.pgc" +#line 78 "prep.pgc" #ifdef WIN32 diff --git a/src/interfaces/ecpg/test/expected/thread-thread.c b/src/interfaces/ecpg/test/expected/thread-thread.c index 981a763a3f..93dc156fc6 100644 --- a/src/interfaces/ecpg/test/expected/thread-thread.c +++ b/src/interfaces/ecpg/test/expected/thread-thread.c @@ -26,6 +26,7 @@ main(void) #include #else #include +#include #endif @@ -36,7 +37,7 @@ main(void) -#line 22 "thread.pgc" +#line 23 "thread.pgc" void *test_thread(void *arg); @@ -55,10 +56,10 @@ int main() /* exec sql begin declare section */ -#line 38 "thread.pgc" +#line 39 "thread.pgc" int l_rows ; /* exec sql end declare section */ -#line 39 "thread.pgc" +#line 40 "thread.pgc" /* Do not switch on debug output for regression tests. The threads get executed in @@ -67,22 +68,22 @@ int main() /* setup test_thread table */ { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , NULL, 0); } -#line 46 "thread.pgc" +#line 47 "thread.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "drop table test_thread", ECPGt_EOIT, ECPGt_EORT);} -#line 47 "thread.pgc" +#line 48 "thread.pgc" /* DROP might fail */ { ECPGtrans(__LINE__, NULL, "commit");} -#line 48 "thread.pgc" +#line 49 "thread.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "create table test_thread ( tstamp timestamp not null default cast ( timeofday ( ) as timestamp ) , thread text not null , iteration integer not null , primary key ( thread , iteration ) )", ECPGt_EOIT, ECPGt_EORT);} -#line 53 "thread.pgc" +#line 54 "thread.pgc" { ECPGtrans(__LINE__, NULL, "commit");} -#line 54 "thread.pgc" +#line 55 "thread.pgc" { ECPGdisconnect(__LINE__, "CURRENT");} -#line 55 "thread.pgc" +#line 56 "thread.pgc" /* create, and start, threads */ @@ -114,18 +115,18 @@ int main() /* and check results */ { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , NULL, 0); } -#line 85 "thread.pgc" +#line 86 "thread.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "select count ( * ) from test_thread", ECPGt_EOIT, ECPGt_int,&(l_rows),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);} -#line 86 "thread.pgc" +#line 87 "thread.pgc" { ECPGtrans(__LINE__, NULL, "commit");} -#line 87 "thread.pgc" +#line 88 "thread.pgc" { ECPGdisconnect(__LINE__, "CURRENT");} -#line 88 "thread.pgc" +#line 89 "thread.pgc" if( l_rows == (nthreads * iterations) ) printf("Success.\n"); @@ -138,17 +139,22 @@ int main() void *test_thread(void *arg) { long threadnum = (long)arg; + +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + /* exec sql begin declare section */ -#line 101 "thread.pgc" +#line 107 "thread.pgc" int l_i ; -#line 102 "thread.pgc" +#line 108 "thread.pgc" char l_connection [ 128 ] ; /* exec sql end declare section */ -#line 103 "thread.pgc" +#line 109 "thread.pgc" /* build up connection name, and connect to database */ @@ -158,13 +164,13 @@ void *test_thread(void *arg) _snprintf(l_connection, sizeof(l_connection), "thread_%03ld", threadnum); #endif /* exec sql whenever sqlerror sqlprint ; */ -#line 111 "thread.pgc" +#line 117 "thread.pgc" { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , l_connection, 0); -#line 112 "thread.pgc" +#line 118 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 112 "thread.pgc" +#line 118 "thread.pgc" if( sqlca.sqlcode != 0 ) { @@ -172,10 +178,10 @@ if (sqlca.sqlcode < 0) sqlprint();} return( NULL ); } { ECPGtrans(__LINE__, l_connection, "begin"); -#line 118 "thread.pgc" +#line 124 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 118 "thread.pgc" +#line 124 "thread.pgc" /* insert into test_thread table */ @@ -186,10 +192,10 @@ if (sqlca.sqlcode < 0) sqlprint();} ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_int,&(l_i),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT); -#line 123 "thread.pgc" +#line 129 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 123 "thread.pgc" +#line 129 "thread.pgc" if( sqlca.sqlcode != 0 ) printf("%s: ERROR: insert failed!\n", l_connection); @@ -197,16 +203,16 @@ if (sqlca.sqlcode < 0) sqlprint();} /* all done */ { ECPGtrans(__LINE__, l_connection, "commit"); -#line 129 "thread.pgc" +#line 135 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 129 "thread.pgc" +#line 135 "thread.pgc" { ECPGdisconnect(__LINE__, l_connection); -#line 130 "thread.pgc" +#line 136 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 130 "thread.pgc" +#line 136 "thread.pgc" return( NULL ); } diff --git a/src/interfaces/ecpg/test/expected/thread-thread_implicit.c b/src/interfaces/ecpg/test/expected/thread-thread_implicit.c index 5f2d177c4a..c7dbf35cbf 100644 --- a/src/interfaces/ecpg/test/expected/thread-thread_implicit.c +++ b/src/interfaces/ecpg/test/expected/thread-thread_implicit.c @@ -27,6 +27,7 @@ main(void) #include #else #include +#include #endif @@ -37,7 +38,7 @@ main(void) -#line 23 "thread_implicit.pgc" +#line 24 "thread_implicit.pgc" void *test_thread(void *arg); @@ -56,10 +57,10 @@ int main() /* exec sql begin declare section */ -#line 39 "thread_implicit.pgc" +#line 40 "thread_implicit.pgc" int l_rows ; /* exec sql end declare section */ -#line 40 "thread_implicit.pgc" +#line 41 "thread_implicit.pgc" /* Do not switch on debug output for regression tests. The threads get executed in @@ -68,22 +69,22 @@ int main() /* setup test_thread table */ { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , NULL, 0); } -#line 47 "thread_implicit.pgc" +#line 48 "thread_implicit.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "drop table test_thread", ECPGt_EOIT, ECPGt_EORT);} -#line 48 "thread_implicit.pgc" +#line 49 "thread_implicit.pgc" /* DROP might fail */ { ECPGtrans(__LINE__, NULL, "commit");} -#line 49 "thread_implicit.pgc" +#line 50 "thread_implicit.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "create table test_thread ( tstamp timestamp not null default cast ( timeofday ( ) as timestamp ) , thread text not null , iteration integer not null , primary key ( thread , iteration ) )", ECPGt_EOIT, ECPGt_EORT);} -#line 54 "thread_implicit.pgc" +#line 55 "thread_implicit.pgc" { ECPGtrans(__LINE__, NULL, "commit");} -#line 55 "thread_implicit.pgc" +#line 56 "thread_implicit.pgc" { ECPGdisconnect(__LINE__, "CURRENT");} -#line 56 "thread_implicit.pgc" +#line 57 "thread_implicit.pgc" /* create, and start, threads */ @@ -115,18 +116,18 @@ int main() /* and check results */ { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , NULL, 0); } -#line 86 "thread_implicit.pgc" +#line 87 "thread_implicit.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "select count ( * ) from test_thread", ECPGt_EOIT, ECPGt_int,&(l_rows),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);} -#line 87 "thread_implicit.pgc" +#line 88 "thread_implicit.pgc" { ECPGtrans(__LINE__, NULL, "commit");} -#line 88 "thread_implicit.pgc" +#line 89 "thread_implicit.pgc" { ECPGdisconnect(__LINE__, "CURRENT");} -#line 89 "thread_implicit.pgc" +#line 90 "thread_implicit.pgc" if( l_rows == (nthreads * iterations) ) printf("Success.\n"); @@ -139,17 +140,22 @@ int main() void *test_thread(void *arg) { long threadnum = (long)arg; + +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + /* exec sql begin declare section */ -#line 102 "thread_implicit.pgc" +#line 108 "thread_implicit.pgc" int l_i ; -#line 103 "thread_implicit.pgc" +#line 109 "thread_implicit.pgc" char l_connection [ 128 ] ; /* exec sql end declare section */ -#line 104 "thread_implicit.pgc" +#line 110 "thread_implicit.pgc" /* build up connection name, and connect to database */ @@ -159,13 +165,13 @@ void *test_thread(void *arg) _snprintf(l_connection, sizeof(l_connection), "thread_%03ld", threadnum); #endif /* exec sql whenever sqlerror sqlprint ; */ -#line 112 "thread_implicit.pgc" +#line 118 "thread_implicit.pgc" { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , l_connection, 0); -#line 113 "thread_implicit.pgc" +#line 119 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 113 "thread_implicit.pgc" +#line 119 "thread_implicit.pgc" if( sqlca.sqlcode != 0 ) { @@ -173,10 +179,10 @@ if (sqlca.sqlcode < 0) sqlprint();} return( NULL ); } { ECPGtrans(__LINE__, NULL, "begin"); -#line 119 "thread_implicit.pgc" +#line 125 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 119 "thread_implicit.pgc" +#line 125 "thread_implicit.pgc" /* insert into test_thread table */ @@ -187,10 +193,10 @@ if (sqlca.sqlcode < 0) sqlprint();} ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_int,&(l_i),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT); -#line 124 "thread_implicit.pgc" +#line 130 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 124 "thread_implicit.pgc" +#line 130 "thread_implicit.pgc" if( sqlca.sqlcode != 0 ) printf("%s: ERROR: insert failed!\n", l_connection); @@ -198,16 +204,16 @@ if (sqlca.sqlcode < 0) sqlprint();} /* all done */ { ECPGtrans(__LINE__, NULL, "commit"); -#line 130 "thread_implicit.pgc" +#line 136 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 130 "thread_implicit.pgc" +#line 136 "thread_implicit.pgc" { ECPGdisconnect(__LINE__, l_connection); -#line 131 "thread_implicit.pgc" +#line 137 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 131 "thread_implicit.pgc" +#line 137 "thread_implicit.pgc" return( NULL ); } diff --git a/src/interfaces/ecpg/test/thread/alloc.pgc b/src/interfaces/ecpg/test/thread/alloc.pgc index ea98495be4..8e6d042d89 100644 --- a/src/interfaces/ecpg/test/thread/alloc.pgc +++ b/src/interfaces/ecpg/test/thread/alloc.pgc @@ -13,6 +13,7 @@ main(void) #define WIN32_LEAN_AND_MEAN #include #include +#include #else #include #endif @@ -35,6 +36,10 @@ static void* fn(void* arg) { int i; +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + EXEC SQL BEGIN DECLARE SECTION; int value; char name[100]; diff --git a/src/interfaces/ecpg/test/thread/descriptor.pgc b/src/interfaces/ecpg/test/thread/descriptor.pgc index e07a5e22b7..c88c05a8a5 100644 --- a/src/interfaces/ecpg/test/thread/descriptor.pgc +++ b/src/interfaces/ecpg/test/thread/descriptor.pgc @@ -3,6 +3,7 @@ #define WIN32_LEAN_AND_MEAN #include #include +#include #else #include #endif @@ -24,6 +25,10 @@ static void* fn(void* arg) { int i; +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + for (i = 1; i <= REPEATS; ++i) { EXEC SQL ALLOCATE DESCRIPTOR mydesc; diff --git a/src/interfaces/ecpg/test/thread/prep.pgc b/src/interfaces/ecpg/test/thread/prep.pgc index 45205ddc8b..1ec96767af 100644 --- a/src/interfaces/ecpg/test/thread/prep.pgc +++ b/src/interfaces/ecpg/test/thread/prep.pgc @@ -13,6 +13,7 @@ main(void) #define WIN32_LEAN_AND_MEAN #include #include +#include #else #include #endif @@ -35,6 +36,10 @@ static void* fn(void* arg) { int i; +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + EXEC SQL BEGIN DECLARE SECTION; int value; char name[100]; diff --git a/src/interfaces/ecpg/test/thread/thread.pgc b/src/interfaces/ecpg/test/thread/thread.pgc index d8ee96dd55..05a23115d6 100644 --- a/src/interfaces/ecpg/test/thread/thread.pgc +++ b/src/interfaces/ecpg/test/thread/thread.pgc @@ -17,6 +17,7 @@ main(void) #include #else #include +#include #endif exec sql include ../regression; @@ -97,6 +98,11 @@ int main() void *test_thread(void *arg) { long threadnum = (long)arg; + +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + EXEC SQL BEGIN DECLARE SECTION; int l_i; char l_connection[128]; diff --git a/src/interfaces/ecpg/test/thread/thread_implicit.pgc b/src/interfaces/ecpg/test/thread/thread_implicit.pgc index e39b8b8007..f4d7a88140 100644 --- a/src/interfaces/ecpg/test/thread/thread_implicit.pgc +++ b/src/interfaces/ecpg/test/thread/thread_implicit.pgc @@ -18,6 +18,7 @@ main(void) #include #else #include +#include #endif exec sql include ../regression; @@ -98,6 +99,11 @@ int main() void *test_thread(void *arg) { long threadnum = (long)arg; + +#ifdef WIN32 + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif + EXEC SQL BEGIN DECLARE SECTION; int l_i; char l_connection[128]; From 407e660781b8c3866fe97fd5e326a078f549db61 Mon Sep 17 00:00:00 2001 From: Michael Meskes Date: Sat, 26 Aug 2017 19:07:25 +0200 Subject: [PATCH 0228/1139] Changed order of statements and added an additiona MSVC safeguard to make ecpg thread test cases work on Windows. --- .../ecpg/test/expected/thread-alloc.c | 36 ++++++----- .../ecpg/test/expected/thread-descriptor.c | 10 +-- .../ecpg/test/expected/thread-prep.c | 64 ++++++++++--------- .../ecpg/test/expected/thread-thread.c | 38 +++++------ .../test/expected/thread-thread_implicit.c | 38 +++++------ src/interfaces/ecpg/test/thread/alloc.pgc | 10 +-- .../ecpg/test/thread/descriptor.pgc | 2 + src/interfaces/ecpg/test/thread/prep.pgc | 10 +-- src/interfaces/ecpg/test/thread/thread.pgc | 10 +-- .../ecpg/test/thread/thread_implicit.pgc | 10 +-- 10 files changed, 124 insertions(+), 104 deletions(-) diff --git a/src/interfaces/ecpg/test/expected/thread-alloc.c b/src/interfaces/ecpg/test/expected/thread-alloc.c index 1312580f57..5e946b2b85 100644 --- a/src/interfaces/ecpg/test/expected/thread-alloc.c +++ b/src/interfaces/ecpg/test/expected/thread-alloc.c @@ -128,63 +128,65 @@ static void* fn(void* arg) { int i; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - /* exec sql begin declare section */ -#line 44 "alloc.pgc" +#line 40 "alloc.pgc" int value ; -#line 45 "alloc.pgc" +#line 41 "alloc.pgc" char name [ 100 ] ; -#line 46 "alloc.pgc" +#line 42 "alloc.pgc" char ** r = NULL ; /* exec sql end declare section */ -#line 47 "alloc.pgc" +#line 43 "alloc.pgc" + +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif value = (long)arg; sprintf(name, "Connection: %d", value); { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , name, 0); -#line 52 "alloc.pgc" +#line 54 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 52 "alloc.pgc" +#line 54 "alloc.pgc" { ECPGsetcommit(__LINE__, "on", NULL); -#line 53 "alloc.pgc" +#line 55 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 53 "alloc.pgc" +#line 55 "alloc.pgc" for (i = 1; i <= REPEATS; ++i) { { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "select relname from pg_class where relname = 'pg_class'", ECPGt_EOIT, ECPGt_char,&(r),(long)0,(long)0,(1)*sizeof(char), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT); -#line 56 "alloc.pgc" +#line 58 "alloc.pgc" if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint(); -#line 56 "alloc.pgc" +#line 58 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 56 "alloc.pgc" +#line 58 "alloc.pgc" free(r); r = NULL; } { ECPGdisconnect(__LINE__, name); -#line 60 "alloc.pgc" +#line 62 "alloc.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 60 "alloc.pgc" +#line 62 "alloc.pgc" return 0; diff --git a/src/interfaces/ecpg/test/expected/thread-descriptor.c b/src/interfaces/ecpg/test/expected/thread-descriptor.c index 8698db78e6..2f15262209 100644 --- a/src/interfaces/ecpg/test/expected/thread-descriptor.c +++ b/src/interfaces/ecpg/test/expected/thread-descriptor.c @@ -109,22 +109,24 @@ static void* fn(void* arg) int i; #ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif #endif for (i = 1; i <= REPEATS; ++i) { ECPGallocate_desc(__LINE__, "mydesc"); -#line 34 "descriptor.pgc" +#line 36 "descriptor.pgc" if (sqlca.sqlcode < 0) sqlprint(); -#line 34 "descriptor.pgc" +#line 36 "descriptor.pgc" ECPGdeallocate_desc(__LINE__, "mydesc"); -#line 35 "descriptor.pgc" +#line 37 "descriptor.pgc" if (sqlca.sqlcode < 0) sqlprint(); -#line 35 "descriptor.pgc" +#line 37 "descriptor.pgc" } diff --git a/src/interfaces/ecpg/test/expected/thread-prep.c b/src/interfaces/ecpg/test/expected/thread-prep.c index 1b023e68a2..0c9090756f 100644 --- a/src/interfaces/ecpg/test/expected/thread-prep.c +++ b/src/interfaces/ecpg/test/expected/thread-prep.c @@ -128,73 +128,75 @@ static void* fn(void* arg) { int i; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - /* exec sql begin declare section */ -#line 44 "prep.pgc" +#line 40 "prep.pgc" int value ; -#line 45 "prep.pgc" +#line 41 "prep.pgc" char name [ 100 ] ; -#line 46 "prep.pgc" +#line 42 "prep.pgc" char query [ 256 ] = "INSERT INTO T VALUES ( ? )" ; /* exec sql end declare section */ -#line 47 "prep.pgc" +#line 43 "prep.pgc" +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif + value = (long)arg; sprintf(name, "Connection: %d", value); { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , name, 0); -#line 52 "prep.pgc" +#line 54 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 52 "prep.pgc" +#line 54 "prep.pgc" { ECPGsetcommit(__LINE__, "on", NULL); -#line 53 "prep.pgc" +#line 55 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 53 "prep.pgc" +#line 55 "prep.pgc" for (i = 1; i <= REPEATS; ++i) { { ECPGprepare(__LINE__, NULL, 0, "i", query); -#line 56 "prep.pgc" +#line 58 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 56 "prep.pgc" +#line 58 "prep.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_execute, "i", ECPGt_int,&(value),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT); -#line 57 "prep.pgc" +#line 59 "prep.pgc" if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint(); -#line 57 "prep.pgc" +#line 59 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 57 "prep.pgc" +#line 59 "prep.pgc" } { ECPGdeallocate(__LINE__, 0, NULL, "i"); -#line 59 "prep.pgc" +#line 61 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 59 "prep.pgc" +#line 61 "prep.pgc" { ECPGdisconnect(__LINE__, name); -#line 60 "prep.pgc" +#line 62 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 60 "prep.pgc" +#line 62 "prep.pgc" return 0; @@ -210,34 +212,34 @@ int main () #endif { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , NULL, 0); -#line 74 "prep.pgc" +#line 76 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 74 "prep.pgc" +#line 76 "prep.pgc" { ECPGsetcommit(__LINE__, "on", NULL); -#line 75 "prep.pgc" +#line 77 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 75 "prep.pgc" +#line 77 "prep.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "drop table if exists T", ECPGt_EOIT, ECPGt_EORT); -#line 76 "prep.pgc" +#line 78 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 76 "prep.pgc" +#line 78 "prep.pgc" { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "create table T ( i int )", ECPGt_EOIT, ECPGt_EORT); -#line 77 "prep.pgc" +#line 79 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 77 "prep.pgc" +#line 79 "prep.pgc" { ECPGdisconnect(__LINE__, "CURRENT"); -#line 78 "prep.pgc" +#line 80 "prep.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 78 "prep.pgc" +#line 80 "prep.pgc" #ifdef WIN32 diff --git a/src/interfaces/ecpg/test/expected/thread-thread.c b/src/interfaces/ecpg/test/expected/thread-thread.c index 93dc156fc6..87cc660ecf 100644 --- a/src/interfaces/ecpg/test/expected/thread-thread.c +++ b/src/interfaces/ecpg/test/expected/thread-thread.c @@ -140,22 +140,24 @@ void *test_thread(void *arg) { long threadnum = (long)arg; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - /* exec sql begin declare section */ -#line 107 "thread.pgc" +#line 103 "thread.pgc" int l_i ; -#line 108 "thread.pgc" +#line 104 "thread.pgc" char l_connection [ 128 ] ; /* exec sql end declare section */ -#line 109 "thread.pgc" +#line 105 "thread.pgc" + +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif /* build up connection name, and connect to database */ #ifndef WIN32_ONLY_COMPILER @@ -164,13 +166,13 @@ void *test_thread(void *arg) _snprintf(l_connection, sizeof(l_connection), "thread_%03ld", threadnum); #endif /* exec sql whenever sqlerror sqlprint ; */ -#line 117 "thread.pgc" +#line 119 "thread.pgc" { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , l_connection, 0); -#line 118 "thread.pgc" +#line 120 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 118 "thread.pgc" +#line 120 "thread.pgc" if( sqlca.sqlcode != 0 ) { @@ -178,10 +180,10 @@ if (sqlca.sqlcode < 0) sqlprint();} return( NULL ); } { ECPGtrans(__LINE__, l_connection, "begin"); -#line 124 "thread.pgc" +#line 126 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 124 "thread.pgc" +#line 126 "thread.pgc" /* insert into test_thread table */ @@ -192,10 +194,10 @@ if (sqlca.sqlcode < 0) sqlprint();} ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_int,&(l_i),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT); -#line 129 "thread.pgc" +#line 131 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 129 "thread.pgc" +#line 131 "thread.pgc" if( sqlca.sqlcode != 0 ) printf("%s: ERROR: insert failed!\n", l_connection); @@ -203,16 +205,16 @@ if (sqlca.sqlcode < 0) sqlprint();} /* all done */ { ECPGtrans(__LINE__, l_connection, "commit"); -#line 135 "thread.pgc" +#line 137 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 135 "thread.pgc" +#line 137 "thread.pgc" { ECPGdisconnect(__LINE__, l_connection); -#line 136 "thread.pgc" +#line 138 "thread.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 136 "thread.pgc" +#line 138 "thread.pgc" return( NULL ); } diff --git a/src/interfaces/ecpg/test/expected/thread-thread_implicit.c b/src/interfaces/ecpg/test/expected/thread-thread_implicit.c index c7dbf35cbf..e716260d46 100644 --- a/src/interfaces/ecpg/test/expected/thread-thread_implicit.c +++ b/src/interfaces/ecpg/test/expected/thread-thread_implicit.c @@ -141,22 +141,24 @@ void *test_thread(void *arg) { long threadnum = (long)arg; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - /* exec sql begin declare section */ -#line 108 "thread_implicit.pgc" +#line 104 "thread_implicit.pgc" int l_i ; -#line 109 "thread_implicit.pgc" +#line 105 "thread_implicit.pgc" char l_connection [ 128 ] ; /* exec sql end declare section */ -#line 110 "thread_implicit.pgc" +#line 106 "thread_implicit.pgc" + +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif /* build up connection name, and connect to database */ #ifndef WIN32_ONLY_COMPILER @@ -165,13 +167,13 @@ void *test_thread(void *arg) _snprintf(l_connection, sizeof(l_connection), "thread_%03ld", threadnum); #endif /* exec sql whenever sqlerror sqlprint ; */ -#line 118 "thread_implicit.pgc" +#line 120 "thread_implicit.pgc" { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , l_connection, 0); -#line 119 "thread_implicit.pgc" +#line 121 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 119 "thread_implicit.pgc" +#line 121 "thread_implicit.pgc" if( sqlca.sqlcode != 0 ) { @@ -179,10 +181,10 @@ if (sqlca.sqlcode < 0) sqlprint();} return( NULL ); } { ECPGtrans(__LINE__, NULL, "begin"); -#line 125 "thread_implicit.pgc" +#line 127 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 125 "thread_implicit.pgc" +#line 127 "thread_implicit.pgc" /* insert into test_thread table */ @@ -193,10 +195,10 @@ if (sqlca.sqlcode < 0) sqlprint();} ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_int,&(l_i),(long)1,(long)1,sizeof(int), ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT); -#line 130 "thread_implicit.pgc" +#line 132 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 130 "thread_implicit.pgc" +#line 132 "thread_implicit.pgc" if( sqlca.sqlcode != 0 ) printf("%s: ERROR: insert failed!\n", l_connection); @@ -204,16 +206,16 @@ if (sqlca.sqlcode < 0) sqlprint();} /* all done */ { ECPGtrans(__LINE__, NULL, "commit"); -#line 136 "thread_implicit.pgc" +#line 138 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 136 "thread_implicit.pgc" +#line 138 "thread_implicit.pgc" { ECPGdisconnect(__LINE__, l_connection); -#line 137 "thread_implicit.pgc" +#line 139 "thread_implicit.pgc" if (sqlca.sqlcode < 0) sqlprint();} -#line 137 "thread_implicit.pgc" +#line 139 "thread_implicit.pgc" return( NULL ); } diff --git a/src/interfaces/ecpg/test/thread/alloc.pgc b/src/interfaces/ecpg/test/thread/alloc.pgc index 8e6d042d89..b13bcb860b 100644 --- a/src/interfaces/ecpg/test/thread/alloc.pgc +++ b/src/interfaces/ecpg/test/thread/alloc.pgc @@ -36,16 +36,18 @@ static void* fn(void* arg) { int i; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - EXEC SQL BEGIN DECLARE SECTION; int value; char name[100]; char **r = NULL; EXEC SQL END DECLARE SECTION; +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif + value = (long)arg; sprintf(name, "Connection: %d", value); diff --git a/src/interfaces/ecpg/test/thread/descriptor.pgc b/src/interfaces/ecpg/test/thread/descriptor.pgc index c88c05a8a5..3f28c6d329 100644 --- a/src/interfaces/ecpg/test/thread/descriptor.pgc +++ b/src/interfaces/ecpg/test/thread/descriptor.pgc @@ -26,7 +26,9 @@ static void* fn(void* arg) int i; #ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif #endif for (i = 1; i <= REPEATS; ++i) diff --git a/src/interfaces/ecpg/test/thread/prep.pgc b/src/interfaces/ecpg/test/thread/prep.pgc index 1ec96767af..3a2467c9ab 100644 --- a/src/interfaces/ecpg/test/thread/prep.pgc +++ b/src/interfaces/ecpg/test/thread/prep.pgc @@ -36,16 +36,18 @@ static void* fn(void* arg) { int i; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - EXEC SQL BEGIN DECLARE SECTION; int value; char name[100]; char query[256] = "INSERT INTO T VALUES ( ? )"; EXEC SQL END DECLARE SECTION; +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif + value = (long)arg; sprintf(name, "Connection: %d", value); diff --git a/src/interfaces/ecpg/test/thread/thread.pgc b/src/interfaces/ecpg/test/thread/thread.pgc index 05a23115d6..e3680b3b31 100644 --- a/src/interfaces/ecpg/test/thread/thread.pgc +++ b/src/interfaces/ecpg/test/thread/thread.pgc @@ -99,15 +99,17 @@ void *test_thread(void *arg) { long threadnum = (long)arg; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - EXEC SQL BEGIN DECLARE SECTION; int l_i; char l_connection[128]; EXEC SQL END DECLARE SECTION; +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif + /* build up connection name, and connect to database */ #ifndef WIN32_ONLY_COMPILER snprintf(l_connection, sizeof(l_connection), "thread_%03ld", threadnum); diff --git a/src/interfaces/ecpg/test/thread/thread_implicit.pgc b/src/interfaces/ecpg/test/thread/thread_implicit.pgc index f4d7a88140..e5814acb27 100644 --- a/src/interfaces/ecpg/test/thread/thread_implicit.pgc +++ b/src/interfaces/ecpg/test/thread/thread_implicit.pgc @@ -100,15 +100,17 @@ void *test_thread(void *arg) { long threadnum = (long)arg; -#ifdef WIN32 - _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); -#endif - EXEC SQL BEGIN DECLARE SECTION; int l_i; char l_connection[128]; EXEC SQL END DECLARE SECTION; +#ifdef WIN32 +#ifdef _MSC_VER /* requires MSVC */ + _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); +#endif +#endif + /* build up connection name, and connect to database */ #ifndef WIN32_ONLY_COMPILER snprintf(l_connection, sizeof(l_connection), "thread_%03ld", threadnum); From caae416aac83db7c96695c1927a254e82f7da5dc Mon Sep 17 00:00:00 2001 From: Stephen Frost Date: Wed, 13 Sep 2017 20:02:27 -0400 Subject: [PATCH 0229/1139] Fix ordering in pg_dump of GRANTs The order in which GRANTs are output is important as GRANTs which have been GRANT'd by individuals via WITH GRANT OPTION GRANTs have to come after the GRANT which included the WITH GRANT OPTION. This happens naturally in the backend during normal operation as we only change existing ACLs in-place, only add new ACLs to the end, and when removing an ACL we remove any which depend on it also. Also, adjust the comments in acl.h to make this clear. Unfortunately, the updates to pg_dump to handle initial privileges involved pulling apart ACLs and then combining them back together and could end up putting them back together in an invalid order, leading to dumps which wouldn't restore. Fix this by adjusting the queries used by pg_dump to ensure that the ACLs are rebuilt in the same order in which they were originally. Back-patch to 9.6 where the changes for initial privileges were done. --- src/bin/pg_dump/dumputils.c | 51 ++++++++++++++++++++++++++----------- src/include/utils/acl.h | 14 +++++++--- 2 files changed, 47 insertions(+), 18 deletions(-) diff --git a/src/bin/pg_dump/dumputils.c b/src/bin/pg_dump/dumputils.c index 11870a33fa..c171978060 100644 --- a/src/bin/pg_dump/dumputils.c +++ b/src/bin/pg_dump/dumputils.c @@ -729,21 +729,36 @@ buildACLQueries(PQExpBuffer acl_subquery, PQExpBuffer racl_subquery, * We always perform this delta on all ACLs and expect that by the time * these are run the initial privileges will be in place, even in a binary * upgrade situation (see below). + * + * Finally, the order in which privileges are in the ACL string (the order + * they been GRANT'd in, which the backend maintains) must be preserved to + * ensure that GRANTs WITH GRANT OPTION and subsequent GRANTs based on + * those are dumped in the correct order. */ - printfPQExpBuffer(acl_subquery, "(SELECT pg_catalog.array_agg(acl) FROM " - "(SELECT pg_catalog.unnest(coalesce(%s,pg_catalog.acldefault(%s,%s))) AS acl " - "EXCEPT " - "SELECT pg_catalog.unnest(coalesce(pip.initprivs,pg_catalog.acldefault(%s,%s)))) as foo)", + printfPQExpBuffer(acl_subquery, + "(SELECT pg_catalog.array_agg(acl ORDER BY row_n) FROM " + "(SELECT acl, row_n FROM " + "pg_catalog.unnest(coalesce(%s,pg_catalog.acldefault(%s,%s))) " + "WITH ORDINALITY AS perm(acl,row_n) " + "WHERE NOT EXISTS ( " + "SELECT 1 FROM " + "pg_catalog.unnest(coalesce(pip.initprivs,pg_catalog.acldefault(%s,%s))) " + "AS init(init_acl) WHERE acl = init_acl)) as foo)", acl_column, obj_kind, acl_owner, obj_kind, acl_owner); - printfPQExpBuffer(racl_subquery, "(SELECT pg_catalog.array_agg(acl) FROM " - "(SELECT pg_catalog.unnest(coalesce(pip.initprivs,pg_catalog.acldefault(%s,%s))) AS acl " - "EXCEPT " - "SELECT pg_catalog.unnest(coalesce(%s,pg_catalog.acldefault(%s,%s)))) as foo)", + printfPQExpBuffer(racl_subquery, + "(SELECT pg_catalog.array_agg(acl ORDER BY row_n) FROM " + "(SELECT acl, row_n FROM " + "pg_catalog.unnest(coalesce(pip.initprivs,pg_catalog.acldefault(%s,%s))) " + "WITH ORDINALITY AS initp(acl,row_n) " + "WHERE NOT EXISTS ( " + "SELECT 1 FROM " + "pg_catalog.unnest(coalesce(%s,pg_catalog.acldefault(%s,%s))) " + "AS permp(orig_acl) WHERE acl = orig_acl)) as foo)", obj_kind, acl_owner, acl_column, @@ -768,19 +783,25 @@ buildACLQueries(PQExpBuffer acl_subquery, PQExpBuffer racl_subquery, { printfPQExpBuffer(init_acl_subquery, "CASE WHEN privtype = 'e' THEN " - "(SELECT pg_catalog.array_agg(acl) FROM " - "(SELECT pg_catalog.unnest(pip.initprivs) AS acl " - "EXCEPT " - "SELECT pg_catalog.unnest(pg_catalog.acldefault(%s,%s))) as foo) END", + "(SELECT pg_catalog.array_agg(acl ORDER BY row_n) FROM " + "(SELECT acl, row_n FROM pg_catalog.unnest(pip.initprivs) " + "WITH ORDINALITY AS initp(acl,row_n) " + "WHERE NOT EXISTS ( " + "SELECT 1 FROM " + "pg_catalog.unnest(pg_catalog.acldefault(%s,%s)) " + "AS privm(orig_acl) WHERE acl = orig_acl)) as foo) END", obj_kind, acl_owner); printfPQExpBuffer(init_racl_subquery, "CASE WHEN privtype = 'e' THEN " "(SELECT pg_catalog.array_agg(acl) FROM " - "(SELECT pg_catalog.unnest(pg_catalog.acldefault(%s,%s)) AS acl " - "EXCEPT " - "SELECT pg_catalog.unnest(pip.initprivs)) as foo) END", + "(SELECT acl, row_n FROM " + "pg_catalog.unnest(pg_catalog.acldefault(%s,%s)) " + "WITH ORDINALITY AS privp(acl,row_n) " + "WHERE NOT EXISTS ( " + "SELECT 1 FROM pg_catalog.unnest(pip.initprivs) " + "AS initp(init_acl) WHERE acl = init_acl)) as foo) END", obj_kind, acl_owner); } diff --git a/src/include/utils/acl.h b/src/include/utils/acl.h index 5a4f1714f3..14279f79da 100644 --- a/src/include/utils/acl.h +++ b/src/include/utils/acl.h @@ -12,9 +12,17 @@ * NOTES * An ACL array is simply an array of AclItems, representing the union * of the privileges represented by the individual items. A zero-length - * array represents "no privileges". There are no assumptions about the - * ordering of the items, but we do expect that there are no two entries - * in the array with the same grantor and grantee. + * array represents "no privileges". + * + * The order of items in the array is important as client utilities (in + * particular, pg_dump, though possibly other clients) expect to be able + * to issue GRANTs in the ordering of the items in the array. The reason + * this matters is that GRANTs WITH GRANT OPTION must be before any GRANTs + * which depend on it. This happens naturally in the backend during + * operations as we update ACLs in-place, new items are appended, and + * existing entries are only removed if there's no dependency on them (no + * GRANT can been based on it, or, if there was, those GRANTs are also + * removed). * * For backward-compatibility purposes we have to allow null ACL entries * in system catalogs. A null ACL will be treated as meaning "default From 353328ad1afd14211e8f19c03aba19f2804f48ae Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Thu, 14 Sep 2017 16:25:19 -0400 Subject: [PATCH 0230/1139] Add missing tags to GetCommandLogLevel. Otherwise, log_statement = 'ddl' causes errors if those statement types are used. Michael Paquier, reviewed by Ashutosh Sharma Discussion: http://postgr.es/m/CAB7nPqStC3HkE76Q1MnHsVd1vF1Td9zXApzYadzDMyLMRkkGrw@mail.gmail.com --- src/backend/tcop/utility.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index 9102116865..c6d2e26b0a 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -2864,6 +2864,10 @@ GetCommandLogLevel(Node *parsetree) lev = LOGSTMT_DDL; break; + case T_AlterOperatorStmt: + lev = LOGSTMT_DDL; + break; + case T_AlterTableMoveAllStmt: case T_AlterTableStmt: lev = LOGSTMT_DDL; From c4c45945e27c9fc90b0dcb1d9af7fd6ea5220f81 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Sat, 16 Sep 2017 11:58:00 -0400 Subject: [PATCH 0231/1139] docs: clarify pg_upgrade docs regarding standbys and rsync Document that rsync is an _optional_ way to upgrade standbys, suggest rsync option --dry-run, and mention a way of upgrading one standby from another using rsync. Also clarify some instructions by specifying if they operate on the old or new clusters. Reported-by: Stephen Frost, Magnus Hagander Discussion: https://postgr.es/m/20170914191250.GB6595@momjian.us Backpatch-through: 9.5 --- doc/src/sgml/ref/pgupgrade.sgml | 41 +++++++++++++++++++-------------- 1 file changed, 24 insertions(+), 17 deletions(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index cf7191907e..a61856765c 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -320,20 +320,14 @@ NET STOP postgresql-9.0 Prepare for standby server upgrades - If you are upgrading standby servers (as outlined in section ), verify that the old standby + If you are upgrading standby servers using methods outlined in section , verify that the old standby servers are caught up by running pg_controldata against the old primary and standby clusters. Verify that the Latest checkpoint location values match in all clusters. (There will be a mismatch if old standby servers were shut down before the old primary.) - - - Also, if upgrading standby servers, change wal_level - to replica in the postgresql.conf file on - the new primary cluster. - @@ -423,12 +417,18 @@ pg_upgrade.exe If you used link mode and have Streaming Replication (see ) or Log-Shipping (see ) standby servers, follow these steps to - upgrade them. You will not be running pg_upgrade on + linkend="warm-standby">) standby servers, you can follow these steps to + quickly upgrade them. You will not be running pg_upgrade on the standby servers, but rather rsync on the primary. - Do not start any servers yet. If you did not use link - mode, skip the instructions in this section and simply recreate the - standby servers. + Do not start any servers yet. + + + + If you did not use link mode, do not have or do not + want to use rsync, or want an easier solution, skip + the instructions in this section and simply recreate the standby + servers once pg_upgrade completes and the new primary + is running. @@ -448,7 +448,7 @@ pg_upgrade.exe Make sure the new standby data directories do not exist or are empty. If initdb was run, delete - the standby server data directories. + the standby servers' new data directories. @@ -474,9 +474,10 @@ pg_upgrade.exe Save configuration files - Save any configuration files from the standbys you need to keep, - e.g. postgresql.conf, recovery.conf, - as these will be overwritten or removed in the next step. + Save any configuration files from the old standbys' data + directories you need to keep, e.g. postgresql.conf, + recovery.conf, because these will be overwritten or + removed in the next step. @@ -507,6 +508,12 @@ rsync --archive --delete --hard-links --size-only /opt/PostgreSQL/9.5/data \ /opt/PostgreSQL/9.6/data standby.example.com:/opt/PostgreSQL + You can verify what the command will do using + rsync's From c0d21bdb86b1eadd25ae56f07729aa53e1ca64c0 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 17 Sep 2017 14:50:01 -0400 Subject: [PATCH 0232/1139] Fix possible dangling pointer dereference in trigger.c. AfterTriggerEndQuery correctly notes that the query_stack could get repalloc'd during a trigger firing, but it nonetheless passes the address of a query_stack entry to afterTriggerInvokeEvents, so that if such a repalloc occurs, afterTriggerInvokeEvents is already working with an obsolete dangling pointer while it scans the rest of the events. Oops. The only code at risk is its "delete_ok" cleanup code, so we can prevent unsafe behavior by passing delete_ok = false instead of true. However, that could have a significant performance penalty, because the point of passing delete_ok = true is to not have to re-scan possibly a large number of dead trigger events on the next time through the loop. There's more than one way to skin that cat, though. What we can do is delete all the "chunks" in the event list except the last one, since we know all events in them must be dead. Deleting the chunks is work we'd have had to do later in AfterTriggerEndQuery anyway, and it ends up saving rescanning of just about the same events we'd have gotten rid of with delete_ok = true. In v10 and HEAD, we also have to be careful to mop up any per-table after_trig_events pointers that would become dangling. This is slightly annoying, but I don't think that normal use-cases will traverse this code path often enough for it to be a performance problem. It's pretty hard to hit this in practice because of the unlikelihood of the query_stack getting resized at just the wrong time. Nonetheless, it's definitely a live bug of ancient standing, so back-patch to all supported branches. Discussion: https://postgr.es/m/2891.1505419542@sss.pgh.pa.us --- src/backend/commands/trigger.c | 59 +++++++++++++++++++++++++++------- 1 file changed, 48 insertions(+), 11 deletions(-) diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c index 9de22a13d7..e660c10d8a 100644 --- a/src/backend/commands/trigger.c +++ b/src/backend/commands/trigger.c @@ -3433,14 +3433,12 @@ static void afterTriggerFreeEventList(AfterTriggerEventList *events) { AfterTriggerEventChunk *chunk; - AfterTriggerEventChunk *next_chunk; - for (chunk = events->head; chunk != NULL; chunk = next_chunk) + while ((chunk = events->head) != NULL) { - next_chunk = chunk->next; + events->head = chunk->next; pfree(chunk); } - events->head = NULL; events->tail = NULL; events->tailfree = NULL; } @@ -3484,6 +3482,23 @@ afterTriggerRestoreEventList(AfterTriggerEventList *events, } } +/* ---------- + * afterTriggerDeleteHeadEventChunk() + * + * Remove the first chunk of events from the given event list. + * ---------- + */ +static void +afterTriggerDeleteHeadEventChunk(AfterTriggerEventList *events) +{ + AfterTriggerEventChunk *target = events->head; + + Assert(target && target->next); + + events->head = target->next; + pfree(target); +} + /* ---------- * AfterTriggerExecute() @@ -3853,7 +3868,7 @@ afterTriggerInvokeEvents(AfterTriggerEventList *events, /* * If it's last chunk, must sync event list's tailfree too. Note * that delete_ok must NOT be passed as true if there could be - * stacked AfterTriggerEventList values pointing at this event + * additional AfterTriggerEventList values pointing at this event * list, since we'd fail to fix their copies of tailfree. */ if (chunk == events->tail) @@ -3985,23 +4000,45 @@ AfterTriggerEndQuery(EState *estate) * will instead fire any triggers in a dedicated query level. Foreign key * enforcement triggers do add to the current query level, thanks to their * passing fire_triggers = false to SPI_execute_snapshot(). Other - * C-language triggers might do likewise. Be careful here: firing a - * trigger could result in query_stack being repalloc'd, so we can't save - * its address across afterTriggerInvokeEvents calls. + * C-language triggers might do likewise. * * If we find no firable events, we don't have to increment * firing_counter. */ + events = &afterTriggers.query_stack[afterTriggers.query_depth]; + for (;;) { - events = &afterTriggers.query_stack[afterTriggers.query_depth]; if (afterTriggerMarkEvents(events, &afterTriggers.events, true)) { CommandId firing_id = afterTriggers.firing_counter++; + AfterTriggerEventChunk *oldtail = events->tail; - /* OK to delete the immediate events after processing them */ - if (afterTriggerInvokeEvents(events, firing_id, estate, true)) + if (afterTriggerInvokeEvents(events, firing_id, estate, false)) break; /* all fired */ + + /* + * Firing a trigger could result in query_stack being repalloc'd, + * so we must recalculate ptr after each afterTriggerInvokeEvents + * call. Furthermore, it's unsafe to pass delete_ok = true here, + * because that could cause afterTriggerInvokeEvents to try to + * access *events after the stack has been repalloc'd. + */ + events = &afterTriggers.query_stack[afterTriggers.query_depth]; + + /* + * We'll need to scan the events list again. To reduce the cost + * of doing so, get rid of completely-fired chunks. We know that + * all events were marked IN_PROGRESS or DONE at the conclusion of + * afterTriggerMarkEvents, so any still-interesting events must + * have been added after that, and so must be in the chunk that + * was then the tail chunk, or in later chunks. So, zap all + * chunks before oldtail. This is approximately the same set of + * events we would have gotten rid of by passing delete_ok = true. + */ + Assert(oldtail != NULL); + while (events->head != oldtail) + afterTriggerDeleteHeadEventChunk(events); } else break; From 86e4ebb9af7ed07f11410d568e0fd72427f3b0e3 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 17 Sep 2017 15:28:51 -0400 Subject: [PATCH 0233/1139] Allow rel_is_distinct_for() to look through RelabelType below OpExpr. This lets it do the right thing for, eg, varchar columns. Back-patch to 9.5 where this logic appeared. David Rowley, per report from Kim Rose Carlsen Discussion: https://postgr.es/m/VI1PR05MB17091F9A9876528055D6A827C76D0@VI1PR05MB1709.eurprd05.prod.outlook.com --- src/backend/optimizer/plan/analyzejoins.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/backend/optimizer/plan/analyzejoins.c b/src/backend/optimizer/plan/analyzejoins.c index e28a8dc533..614fd293ed 100644 --- a/src/backend/optimizer/plan/analyzejoins.c +++ b/src/backend/optimizer/plan/analyzejoins.c @@ -617,6 +617,14 @@ rel_is_distinct_for(PlannerInfo *root, RelOptInfo *rel, List *clause_list) else var = (Var *) get_leftop(rinfo->clause); + /* + * We may ignore any RelabelType node above the operand. (There + * won't be more than one, since eval_const_expressions() has been + * applied already.) + */ + if (var && IsA(var, RelabelType)) + var = (Var *) ((RelabelType *) var)->arg; + /* * If inner side isn't a Var referencing a subquery output column, * this clause doesn't help us. From 59b5a3e5c72e4b91876df226eab09dc97c6e190e Mon Sep 17 00:00:00 2001 From: Michael Meskes Date: Mon, 11 Sep 2017 21:10:36 +0200 Subject: [PATCH 0234/1139] Fixed ECPG to correctly handle out-of-scope cursor declarations with pointers or array variables. --- src/interfaces/ecpg/preproc/ecpg.header | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/interfaces/ecpg/preproc/ecpg.header b/src/interfaces/ecpg/preproc/ecpg.header index 2562366bbe..a52da01b1f 100644 --- a/src/interfaces/ecpg/preproc/ecpg.header +++ b/src/interfaces/ecpg/preproc/ecpg.header @@ -352,7 +352,7 @@ adjust_outofscope_cursor_vars(struct cursor *cur) else { newvar = new_variable(cat_str(4, mm_strdup("("), - mm_strdup(ecpg_type_name(ptr->variable->type->type)), + mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(var_text)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, From ea96568396830e2c5e409dbafbcece30c72b8698 Mon Sep 17 00:00:00 2001 From: Magnus Hagander Date: Wed, 20 Sep 2017 14:09:05 +0200 Subject: [PATCH 0235/1139] Mention need for --no-inc-recursive in rsync command Since rsync 3.0.0 (released in 2008), the default way to enumerate changes was changed in a way that makes it less likely that the hardlink sync mode works. Since the whole point of the documented procedure is for the hardlinks to work, change our docs to suggest using the backwards compatibility switch. --- doc/src/sgml/ref/pgupgrade.sgml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index a61856765c..4e248eae38 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -492,7 +492,7 @@ pg_upgrade.exe server: -rsync --archive --delete --hard-links --size-only old_pgdata new_pgdata remote_dir +rsync --archive --delete --hard-links --size-only --no-inc-recursive old_pgdata new_pgdata remote_dir where From 33dd10ef2f1df34e834c64f78622302ea5d78a93 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 20 Sep 2017 11:10:42 -0400 Subject: [PATCH 0237/1139] Fix erroneous documentation about noise word GROUP. GRANT, REVOKE, and some allied commands allow the noise word GROUP before a role name (cf. grantee production in gram.y). This option does not exist elsewhere, but it had nonetheless snuck into the documentation for ALTER ROLE, ALTER USER, and CREATE SCHEMA. Seems to be a copy-and-pasteo in commit 31eae6028, which did expand the syntax choices here, but not in that way. Back-patch to 9.5 where that came in. Discussion: https://postgr.es/m/20170916123750.8885.66941@wrigleys.postgresql.org --- doc/src/sgml/ref/alter_role.sgml | 2 +- doc/src/sgml/ref/alter_user.sgml | 2 +- doc/src/sgml/ref/create_schema.sgml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/src/sgml/ref/alter_role.sgml b/doc/src/sgml/ref/alter_role.sgml index da36ad9696..ec83c4a18a 100644 --- a/doc/src/sgml/ref/alter_role.sgml +++ b/doc/src/sgml/ref/alter_role.sgml @@ -45,7 +45,7 @@ ALTER ROLE { role_specification | A where role_specification can be: - [ GROUP ] role_name + role_name | CURRENT_USER | SESSION_USER diff --git a/doc/src/sgml/ref/alter_user.sgml b/doc/src/sgml/ref/alter_user.sgml index 50bfae6cc3..70155131cb 100644 --- a/doc/src/sgml/ref/alter_user.sgml +++ b/doc/src/sgml/ref/alter_user.sgml @@ -45,7 +45,7 @@ ALTER USER { role_specification | A where role_specification can be: - [ GROUP ] role_name + role_name | CURRENT_USER | SESSION_USER diff --git a/doc/src/sgml/ref/create_schema.sgml b/doc/src/sgml/ref/create_schema.sgml index 554a4483c5..5d29cd768a 100644 --- a/doc/src/sgml/ref/create_schema.sgml +++ b/doc/src/sgml/ref/create_schema.sgml @@ -28,7 +28,7 @@ CREATE SCHEMA IF NOT EXISTS AUTHORIZATION role_sp where role_specification can be: - [ GROUP ] user_name + user_name | CURRENT_USER | SESSION_USER From ea31541f564851611fee58fe2019c866ce0e8aa0 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 21 Sep 2017 18:13:11 -0400 Subject: [PATCH 0238/1139] Give a better error for duplicate entries in VACUUM/ANALYZE column list. Previously, the code didn't think about this case and would just try to analyze such a column twice. That would fail at the point of inserting the second version of the pg_statistic row, with obscure error messsages like "duplicate key value violates unique constraint" or "tuple already updated by self", depending on context and PG version. We could allow the case by ignoring duplicate column specifications, but it seems better to reject it explicitly. The bogus error messages seem like arguably a bug, so back-patch to all supported versions. Nathan Bossart, per a report from Michael Paquier, and whacked around a bit by me. Discussion: https://postgr.es/m/E061A8E3-5E3D-494D-94F0-E8A9B312BBFC@amazon.com --- src/backend/commands/analyze.c | 13 ++++++++++++- src/test/regress/expected/vacuum.out | 5 +++++ src/test/regress/sql/vacuum.sql | 4 ++++ 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c index c617abb223..c58f3096e6 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -356,10 +356,14 @@ do_analyze_rel(Relation onerel, int options, VacuumParams *params, /* * Determine which columns to analyze * - * Note that system attributes are never analyzed. + * Note that system attributes are never analyzed, so we just reject them + * at the lookup stage. We also reject duplicate column mentions. (We + * could alternatively ignore duplicates, but analyzing a column twice + * won't work; we'd end up making a conflicting update in pg_statistic.) */ if (va_cols != NIL) { + Bitmapset *unique_cols = NULL; ListCell *le; vacattrstats = (VacAttrStats **) palloc(list_length(va_cols) * @@ -375,6 +379,13 @@ do_analyze_rel(Relation onerel, int options, VacuumParams *params, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" of relation \"%s\" does not exist", col, RelationGetRelationName(onerel)))); + if (bms_is_member(i, unique_cols)) + ereport(ERROR, + (errcode(ERRCODE_DUPLICATE_COLUMN), + errmsg("column \"%s\" of relation \"%s\" is specified twice", + col, RelationGetRelationName(onerel)))); + unique_cols = bms_add_member(unique_cols, i); + vacattrstats[tcnt] = examine_attribute(onerel, i, NULL); if (vacattrstats[tcnt] != NULL) tcnt++; diff --git a/src/test/regress/expected/vacuum.out b/src/test/regress/expected/vacuum.out index 9b604be4b6..23a877e9cc 100644 --- a/src/test/regress/expected/vacuum.out +++ b/src/test/regress/expected/vacuum.out @@ -80,5 +80,10 @@ CONTEXT: SQL function "do_analyze" statement 1 SQL function "wrap_do_analyze" statement 1 VACUUM FULL vactst; VACUUM (DISABLE_PAGE_SKIPPING) vaccluster; +-- check behavior with duplicate column mentions +VACUUM ANALYZE vaccluster(i,i); +ERROR: column "i" of relation "vaccluster" is specified twice +ANALYZE vaccluster(i,i); +ERROR: column "i" of relation "vaccluster" is specified twice DROP TABLE vaccluster; DROP TABLE vactst; diff --git a/src/test/regress/sql/vacuum.sql b/src/test/regress/sql/vacuum.sql index 7b819f654d..0d35da9987 100644 --- a/src/test/regress/sql/vacuum.sql +++ b/src/test/regress/sql/vacuum.sql @@ -62,5 +62,9 @@ VACUUM FULL vactst; VACUUM (DISABLE_PAGE_SKIPPING) vaccluster; +-- check behavior with duplicate column mentions +VACUUM ANALYZE vaccluster(i,i); +ANALYZE vaccluster(i,i); + DROP TABLE vaccluster; DROP TABLE vactst; From e25f4401dad7829463efff1f4655f2c6d6b076ff Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 22 Sep 2017 00:04:21 -0400 Subject: [PATCH 0239/1139] Sync our copy of the timezone library with IANA tzcode master. This patch absorbs a few unreleased fixes in the IANA code. It corresponds to commit 2d8b944c1cec0808ac4f7a9ee1a463c28f9cd00a in https://github.com/eggert/tz. Non-cosmetic changes include: TZDEFRULESTRING is updated to match current US DST practice, rather than what it was over ten years ago. This only matters for interpretation of POSIX-style zone names (e.g., "EST5EDT"), and only if the timezone database doesn't include either an exact match for the zone name or a "posixrules" entry. The latter should not be true in any current Postgres installation, but this could possibly matter when using --with-system-tzdata. Get rid of a nonportable use of "++var" on a bool var. This is part of a larger fix that eliminates some vestigial support for consecutive leap seconds, and adds checks to the "zic" compiler that the data files do not specify that. Remove a couple of ancient compatibility hacks. The IANA crew think these are obsolete, and I tend to agree. But perhaps our buildfarm will think different. Back-patch to all supported branches, in line with our policy that all branches should be using current IANA code. Before v10, this includes application of current pgindent rules, to avoid whitespace problems in future back-patches. Discussion: https://postgr.es/m/E1dsWhf-0000pT-F9@gemulon.postgresql.org --- src/timezone/localtime.c | 138 ++++++++++++------------- src/timezone/private.h | 27 ++--- src/timezone/strftime.c | 50 +++++---- src/timezone/tzfile.h | 8 +- src/timezone/zic.c | 217 ++++++++++++++++++++++++--------------- 5 files changed, 236 insertions(+), 204 deletions(-) diff --git a/src/timezone/localtime.c b/src/timezone/localtime.c index 04105b2c96..d946e882aa 100644 --- a/src/timezone/localtime.c +++ b/src/timezone/localtime.c @@ -26,15 +26,15 @@ #ifndef WILDABBR /* * Someone might make incorrect use of a time zone abbreviation: - * 1. They might reference tzname[0] before calling tzset (explicitly + * 1. They might reference tzname[0] before calling tzset (explicitly * or implicitly). - * 2. They might reference tzname[1] before calling tzset (explicitly + * 2. They might reference tzname[1] before calling tzset (explicitly * or implicitly). - * 3. They might reference tzname[1] after setting to a time zone + * 3. They might reference tzname[1] after setting to a time zone * in which Daylight Saving Time is never observed. - * 4. They might reference tzname[0] after setting to a time zone + * 4. They might reference tzname[0] after setting to a time zone * in which Standard Time is never observed. - * 5. They might reference tm.TM_ZONE after calling offtime. + * 5. They might reference tm.TM_ZONE after calling offtime. * What's best to do in the above cases is open to debate; * for now, we just set things up so that in any of the five cases * WILDABBR is used. Another possibility: initialize tzname[0] to the @@ -44,18 +44,14 @@ * that tzname[0] has the "normal" length of three characters). */ #define WILDABBR " " -#endif /* !defined WILDABBR */ +#endif /* !defined WILDABBR */ static const char wildabbr[] = WILDABBR; static const char gmt[] = "GMT"; -/* The minimum and maximum finite time values. This assumes no padding. */ -static const pg_time_t time_t_min = MINVAL(pg_time_t, TYPE_BIT(pg_time_t)); -static const pg_time_t time_t_max = MAXVAL(pg_time_t, TYPE_BIT(pg_time_t)); - /* - * We cache the result of trying to load the TZDEFRULES zone here. + * PG: We cache the result of trying to load the TZDEFRULES zone here. * tzdefrules_loaded is 0 if not tried yet, +1 if good, -1 if failed. */ static struct state tzdefrules_s; @@ -63,12 +59,12 @@ static int tzdefrules_loaded = 0; /* * The DST rules to use if TZ has no rules and we can't load TZDEFRULES. - * We default to US rules as of 1999-08-17. + * Default to US rules as of 2017-05-07. * POSIX 1003.1 section 8.1.1 says that the default DST rules are * implementation dependent; for historical reasons, US rules are a * common default. */ -#define TZDEFRULESTRING ",M4.1.0,M10.5.0" +#define TZDEFRULESTRING ",M3.2.0,M11.1.0" /* structs ttinfo, lsinfo, state have been moved to pgtz.h */ @@ -112,7 +108,7 @@ static struct pg_tm tm; /* Initialize *S to a value based on GMTOFF, ISDST, and ABBRIND. */ static void -init_ttinfo(struct ttinfo * s, int32 gmtoff, bool isdst, int abbrind) +init_ttinfo(struct ttinfo *s, int32 gmtoff, bool isdst, int abbrind) { s->tt_gmtoff = gmtoff; s->tt_isdst = isdst; @@ -189,16 +185,14 @@ union input_buffer /* The entire buffer. */ char buf[2 * sizeof(struct tzhead) + 2 * sizeof(struct state) - + 4 * TZ_MAX_TIMES]; + + 4 * TZ_MAX_TIMES]; }; /* Local storage needed for 'tzloadbody'. */ union local_storage { - /* We don't need the "fullname" member */ - /* The results of analyzing the file's contents after it is opened. */ - struct + struct file_analysis { /* The input buffer. */ union input_buffer u; @@ -206,6 +200,8 @@ union local_storage /* A temporary state used for parsing a TZ string in the file. */ struct state st; } u; + + /* We don't need the "fullname" member */ }; /* Load tz data from the file named NAME into *SP. Read extended @@ -215,8 +211,8 @@ union local_storage * given name is stored there (the buffer must be > TZ_STRLEN_MAX bytes!). */ static int -tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, - union local_storage * lsp) +tzloadbody(char const *name, char *canonname, struct state *sp, bool doextend, + union local_storage *lsp) { int i; int fid; @@ -255,6 +251,8 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, { int32 ttisstdcnt = detzcode(up->tzhead.tzh_ttisstdcnt); int32 ttisgmtcnt = detzcode(up->tzhead.tzh_ttisgmtcnt); + int64 prevtr = 0; + int32 prevcorr = 0; int32 leapcnt = detzcode(up->tzhead.tzh_leapcnt); int32 timecnt = detzcode(up->tzhead.tzh_timecnt); int32 typecnt = detzcode(up->tzhead.tzh_typecnt); @@ -270,7 +268,7 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, return EINVAL; if (nread < (tzheadsize /* struct tzhead */ - + timecnt * stored /* ats */ + + timecnt * stored /* ats */ + timecnt /* types */ + typecnt * 6 /* ttinfos */ + charcnt /* chars */ @@ -285,8 +283,8 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, /* * Read transitions, discarding those out of pg_time_t range. But - * pretend the last transition before time_t_min occurred at - * time_t_min. + * pretend the last transition before TIME_T_MIN occurred at + * TIME_T_MIN. */ timecnt = 0; for (i = 0; i < sp->timecnt; ++i) @@ -294,12 +292,12 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, int64 at = stored == 4 ? detzcode(p) : detzcode64(p); - sp->types[i] = at <= time_t_max; + sp->types[i] = at <= TIME_T_MAX; if (sp->types[i]) { pg_time_t attime - = ((TYPE_SIGNED(pg_time_t) ? at < time_t_min : at < 0) - ? time_t_min : at); + = ((TYPE_SIGNED(pg_time_t) ? at < TIME_T_MIN : at < 0) + ? TIME_T_MIN : at); if (timecnt && attime <= sp->ats[timecnt - 1]) { @@ -354,20 +352,22 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, int32 corr = detzcode(p + stored); p += stored + 4; - if (tr <= time_t_max) + /* Leap seconds cannot occur before the Epoch. */ + if (tr < 0) + return EINVAL; + if (tr <= TIME_T_MAX) { - pg_time_t trans - = ((TYPE_SIGNED(pg_time_t) ? tr < time_t_min : tr < 0) - ? time_t_min : tr); - - if (leapcnt && trans <= sp->lsis[leapcnt - 1].ls_trans) - { - if (trans < sp->lsis[leapcnt - 1].ls_trans) - return EINVAL; - leapcnt--; - } - sp->lsis[leapcnt].ls_trans = trans; - sp->lsis[leapcnt].ls_corr = corr; + /* + * Leap seconds cannot occur more than once per UTC month, and + * UTC months are at least 28 days long (minus 1 second for a + * negative leap second). Each leap second's correction must + * differ from the previous one's by 1 second. + */ + if (tr - prevtr < 28 * SECSPERDAY - 1 + || (corr != prevcorr - 1 && corr != prevcorr + 1)) + return EINVAL; + sp->lsis[leapcnt].ls_trans = prevtr = tr; + sp->lsis[leapcnt].ls_corr = prevcorr = corr; leapcnt++; } } @@ -508,7 +508,7 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, } /* - * If type 0 is is unused in transitions, it's the type to use for early + * If type 0 is unused in transitions, it's the type to use for early * times. */ for (i = 0; i < sp->timecnt; ++i) @@ -553,7 +553,7 @@ tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend, * given name is stored there (the buffer must be > TZ_STRLEN_MAX bytes!). */ int -tzload(const char *name, char *canonname, struct state * sp, bool doextend) +tzload(const char *name, char *canonname, struct state *sp, bool doextend) { union local_storage *lsp = malloc(sizeof *lsp); @@ -569,7 +569,7 @@ tzload(const char *name, char *canonname, struct state * sp, bool doextend) } static bool -typesequiv(const struct state * sp, int a, int b) +typesequiv(const struct state *sp, int a, int b) { bool result; @@ -737,7 +737,7 @@ getoffset(const char *strp, int32 *offsetp) * Otherwise, return a pointer to the first character not part of the rule. */ static const char * -getrule(const char *strp, struct rule * rulep) +getrule(const char *strp, struct rule *rulep) { if (*strp == 'J') { @@ -788,7 +788,7 @@ getrule(const char *strp, struct rule * rulep) strp = getoffset(strp, &rulep->r_time); } else - rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */ + rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */ return strp; } @@ -797,7 +797,7 @@ getrule(const char *strp, struct rule * rulep) * effect, calculate the year-relative time that rule takes effect. */ static int32 -transtime(int year, const struct rule * rulep, +transtime(int year, const struct rule *rulep, int32 offset) { bool leapyear; @@ -894,7 +894,7 @@ transtime(int year, const struct rule * rulep, * Returns true on success, false on failure. */ bool -tzparse(const char *name, struct state * sp, bool lastditch) +tzparse(const char *name, struct state *sp, bool lastditch) { const char *stdname; const char *dstname = NULL; @@ -921,7 +921,7 @@ tzparse(const char *name, struct state * sp, bool lastditch) stdlen = (sizeof sp->chars) - 1; charcnt = stdlen + 1; stdoffset = 0; - sp->goback = sp->goahead = false; /* simulate failed tzload() */ + sp->goback = sp->goahead = false; /* simulate failed tzload() */ load_ok = false; } else @@ -1217,7 +1217,7 @@ tzparse(const char *name, struct state * sp, bool lastditch) } static void -gmtload(struct state * sp) +gmtload(struct state *sp) { if (tzload(gmt, NULL, sp, true) != 0) tzparse(gmt, sp, true); @@ -1231,8 +1231,8 @@ gmtload(struct state * sp) * but it *is* desirable.) */ static struct pg_tm * -localsub(struct state const * sp, pg_time_t const * timep, - struct pg_tm * tmp) +localsub(struct state const *sp, pg_time_t const *timep, + struct pg_tm *tmp) { const struct ttinfo *ttisp; int i; @@ -1323,7 +1323,7 @@ pg_localtime(const pg_time_t *timep, const pg_tz *tz) * Except we have a private "struct state" for GMT, so no sp is passed in. */ static struct pg_tm * -gmtsub(pg_time_t const * timep, int32 offset, struct pg_tm * tmp) +gmtsub(pg_time_t const *timep, int32 offset, struct pg_tm *tmp) { struct pg_tm *result; @@ -1361,16 +1361,23 @@ pg_gmtime(const pg_time_t *timep) * Return the number of leap years through the end of the given year * where, to make the math easy, the answer for year zero is defined as zero. */ +static int +leaps_thru_end_of_nonneg(int y) +{ + return y / 4 - y / 100 + y / 400; +} + static int leaps_thru_end_of(const int y) { - return (y >= 0) ? (y / 4 - y / 100 + y / 400) : - -(leaps_thru_end_of(-(y + 1)) + 1); + return (y < 0 + ? -1 - leaps_thru_end_of_nonneg(-1 - y) + : leaps_thru_end_of_nonneg(y)); } static struct pg_tm * timesub(const pg_time_t *timep, int32 offset, - const struct state * sp, struct pg_tm * tmp) + const struct state *sp, struct pg_tm *tmp) { const struct lsinfo *lp; pg_time_t tdays; @@ -1390,22 +1397,9 @@ timesub(const pg_time_t *timep, int32 offset, lp = &sp->lsis[i]; if (*timep >= lp->ls_trans) { - if (*timep == lp->ls_trans) - { - hit = ((i == 0 && lp->ls_corr > 0) || - lp->ls_corr > sp->lsis[i - 1].ls_corr); - if (hit) - while (i > 0 && - sp->lsis[i].ls_trans == - sp->lsis[i - 1].ls_trans + 1 && - sp->lsis[i].ls_corr == - sp->lsis[i - 1].ls_corr + 1) - { - ++hit; - --i; - } - } corr = lp->ls_corr; + hit = (*timep == lp->ls_trans + && (i == 0 ? 0 : lp[-1].ls_corr) < corr); break; } } @@ -1529,13 +1523,13 @@ increment_overflow_time(pg_time_t *tp, int32 j) { /*---------- * This is like - * 'if (! (time_t_min <= *tp + j && *tp + j <= time_t_max)) ...', + * 'if (! (TIME_T_MIN <= *tp + j && *tp + j <= TIME_T_MAX)) ...', * except that it does the right thing even if *tp + j would overflow. *---------- */ if (!(j < 0 - ? (TYPE_SIGNED(pg_time_t) ? time_t_min - j <= *tp : -1 - j < *tp) - : *tp <= time_t_max - j)) + ? (TYPE_SIGNED(pg_time_t) ? TIME_T_MIN - j <= *tp : -1 - j < *tp) + : *tp <= TIME_T_MAX - j)) return true; *tp += j; return false; diff --git a/src/timezone/private.h b/src/timezone/private.h index f78053660e..701112ec5b 100644 --- a/src/timezone/private.h +++ b/src/timezone/private.h @@ -38,26 +38,9 @@ #define EOVERFLOW EINVAL #endif -#ifndef WIFEXITED -#define WIFEXITED(status) (((status) & 0xff) == 0) -#endif /* !defined WIFEXITED */ -#ifndef WEXITSTATUS -#define WEXITSTATUS(status) (((status) >> 8) & 0xff) -#endif /* !defined WEXITSTATUS */ - /* Unlike 's isdigit, this also works if c < 0 | c > UCHAR_MAX. */ #define is_digit(c) ((unsigned)(c) - '0' <= 9) -/* - * SunOS 4.1.1 libraries lack remove. - */ - -#ifndef remove -extern int unlink(const char *filename); - -#define remove unlink -#endif /* !defined remove */ - /* * Finally, some convenience items. @@ -78,6 +61,10 @@ extern int unlink(const char *filename); #define MINVAL(t, b) \ ((t) (TYPE_SIGNED(t) ? - TWOS_COMPLEMENT(t) - MAXVAL(t, b) : 0)) +/* The extreme time values, assuming no padding. */ +#define TIME_T_MIN MINVAL(pg_time_t, TYPE_BIT(pg_time_t)) +#define TIME_T_MAX MAXVAL(pg_time_t, TYPE_BIT(pg_time_t)) + /* * 302 / 1000 is log10(2.0) rounded up. * Subtract one for the sign bit if the type is signed; @@ -91,7 +78,7 @@ extern int unlink(const char *filename); /* * INITIALIZE(x) */ -#define INITIALIZE(x) ((x) = 0) +#define INITIALIZE(x) ((x) = 0) #undef _ #define _(msgid) (msgid) @@ -146,7 +133,7 @@ extern int unlink(const char *filename); * or * isleap(a + b) == isleap(a % 400 + b % 400) * This is true even if % means modulo rather than Fortran remainder - * (which is allowed by C89 but not C99). + * (which is allowed by C89 but not by C99 or later). * We use this to avoid addition overflow problems. */ @@ -162,4 +149,4 @@ extern int unlink(const char *filename); ((int64) YEARSPERREPEAT * (int64) AVGSECSPERYEAR) #define SECSPERREPEAT_BITS 34 /* ceil(log2(SECSPERREPEAT)) */ -#endif /* !defined PRIVATE_H */ +#endif /* !defined PRIVATE_H */ diff --git a/src/timezone/strftime.c b/src/timezone/strftime.c index 2f32cf8bdb..e1c6483443 100644 --- a/src/timezone/strftime.c +++ b/src/timezone/strftime.c @@ -41,7 +41,6 @@ #include "postgres.h" #include -#include #include "private.h" @@ -83,17 +82,17 @@ static const struct lc_time_T C_time_locale = { /* * x_fmt * - * C99 requires this format. Using just numbers (as here) makes Quakers - * happier; it's also compatible with SVR4. + * C99 and later require this format. Using just numbers (as here) makes + * Quakers happier; it's also compatible with SVR4. */ "%m/%d/%y", /* * c_fmt * - * C99 requires this format. Previously this code used "%D %X", but we now - * conform to C99. Note that "%a %b %d %H:%M:%S %Y" is used by Solaris - * 2.3. + * C99 and later require this format. Previously this code used "%D %X", + * but we now conform to C99. Note that "%a %b %d %H:%M:%S %Y" is used by + * Solaris 2.3. */ "%a %b %e %T %Y", @@ -107,26 +106,25 @@ static const struct lc_time_T C_time_locale = { "%a %b %e %H:%M:%S %Z %Y" }; +enum warn +{ + IN_NONE, IN_SOME, IN_THIS, IN_ALL +}; + static char *_add(const char *, char *, const char *); static char *_conv(int, const char *, char *, const char *); -static char *_fmt(const char *, const struct pg_tm *, char *, - const char *, int *); +static char *_fmt(const char *, const struct pg_tm *, char *, const char *, + enum warn *); static char *_yconv(int, int, bool, bool, char *, const char *); -#define IN_NONE 0 -#define IN_SOME 1 -#define IN_THIS 2 -#define IN_ALL 3 - size_t pg_strftime(char *s, size_t maxsize, const char *format, - const struct pg_tm * t) + const struct pg_tm *t) { char *p; - int warn; + enum warn warn = IN_NONE; - warn = IN_NONE; p = _fmt(format, t, s, s + maxsize, &warn); if (p == s + maxsize) return 0; @@ -135,8 +133,8 @@ pg_strftime(char *s, size_t maxsize, const char *format, } static char * -_fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, - int *warnp) +_fmt(const char *format, const struct pg_tm *t, char *pt, + const char *ptlim, enum warn *warnp) { for (; *format; ++format) { @@ -185,7 +183,7 @@ _fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, continue; case 'c': { - int warn2 = IN_SOME; + enum warn warn2 = IN_SOME; pt = _fmt(Locale->c_fmt, t, pt, ptlim, &warn2); if (warn2 == IN_ALL) @@ -204,9 +202,9 @@ _fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, case 'O': /* - * C99 locale modifiers. The sequences %Ec %EC %Ex %EX - * %Ey %EY %Od %oe %OH %OI %Om %OM %OS %Ou %OU %OV %Ow - * %OW %Oy are supposed to provide alternate + * Locale modifiers of C99 and later. The sequences %Ec + * %EC %Ex %EX %Ey %EY %Od %oe %OH %OI %Om %OM %OS %Ou %OU + * %OV %Ow %OW %Oy are supposed to provide alternate * representations. */ goto label; @@ -246,7 +244,7 @@ _fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, */ pt = _add("kitchen sink", pt, ptlim); continue; -#endif /* defined KITCHEN_SINK */ +#endif /* defined KITCHEN_SINK */ case 'l': /* @@ -418,7 +416,7 @@ _fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, continue; case 'x': { - int warn2 = IN_SOME; + enum warn warn2 = IN_SOME; pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2); if (warn2 == IN_ALL) @@ -443,8 +441,8 @@ _fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, pt = _add(t->tm_zone, pt, ptlim); /* - * C99 says that %Z must be replaced by the empty string - * if the time zone is not determinable. + * C99 and later say that %Z must be replaced by the empty + * string if the time zone is not determinable. */ continue; case 'z': diff --git a/src/timezone/tzfile.h b/src/timezone/tzfile.h index 56a5b43472..2843833e49 100644 --- a/src/timezone/tzfile.h +++ b/src/timezone/tzfile.h @@ -34,9 +34,9 @@ struct tzhead { char tzh_magic[4]; /* TZ_MAGIC */ char tzh_version[1]; /* '\0' or '2' or '3' as of 2013 */ - char tzh_reserved[15]; /* reserved; must be zero */ - char tzh_ttisgmtcnt[4]; /* coded number of trans. time flags */ - char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */ + char tzh_reserved[15]; /* reserved; must be zero */ + char tzh_ttisgmtcnt[4]; /* coded number of trans. time flags */ + char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */ char tzh_leapcnt[4]; /* coded number of leap seconds */ char tzh_timecnt[4]; /* coded number of transition times */ char tzh_typecnt[4]; /* coded number of local time types */ @@ -100,4 +100,4 @@ struct tzhead #define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */ -#endif /* !defined TZFILE_H */ +#endif /* !defined TZFILE_H */ diff --git a/src/timezone/zic.c b/src/timezone/zic.c index f6beedcab2..db119265c3 100644 --- a/src/timezone/zic.c +++ b/src/timezone/zic.c @@ -9,10 +9,8 @@ #include "postgres_fe.h" #include -#include #include #include -#include #include "pg_getopt.h" @@ -28,7 +26,7 @@ typedef int64 zic_t; #ifndef ZIC_MAX_ABBR_LEN_WO_WARN #define ZIC_MAX_ABBR_LEN_WO_WARN 6 -#endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */ +#endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */ #ifndef WIN32 #ifdef S_IRUSR @@ -47,9 +45,12 @@ typedef int64 zic_t; static ptrdiff_t const PTRDIFF_MAX = MAXVAL(ptrdiff_t, TYPE_BIT(ptrdiff_t)); #endif -/* The type and printf format for line numbers. */ +/* + * The type for line numbers. In Postgres, use %d to format them; upstream + * uses PRIdMAX but we prefer not to rely on that, not least because it + * results in platform-dependent strings to be translated. + */ typedef int lineno_t; -#define PRIdLINENO "d" struct rule { @@ -84,9 +85,9 @@ struct rule * r_dycode r_dayofmonth r_wday */ -#define DC_DOM 0 /* 1..31 */ /* unused */ -#define DC_DOWGEQ 1 /* 1..31 */ /* 0..6 (Sun..Sat) */ -#define DC_DOWLEQ 2 /* 1..31 */ /* 0..6 (Sun..Sat) */ +#define DC_DOM 0 /* 1..31 */ /* unused */ +#define DC_DOWGEQ 1 /* 1..31 */ /* 0..6 (Sun..Sat) */ +#define DC_DOWLEQ 2 /* 1..31 */ /* 0..6 (Sun..Sat) */ struct zone { @@ -138,9 +139,9 @@ static char lowerit(char); static void mkdirs(char const *, bool); static void newabbr(const char *abbr); static zic_t oadd(zic_t t1, zic_t t2); -static void outzone(const struct zone * zp, ptrdiff_t ntzones); -static zic_t rpytime(const struct rule * rp, zic_t wantedy); -static void rulesub(struct rule * rp, +static void outzone(const struct zone *zp, ptrdiff_t ntzones); +static zic_t rpytime(const struct rule *rp, zic_t wantedy); +static void rulesub(struct rule *rp, const char *loyearp, const char *hiyearp, const char *typep, const char *monthp, const char *dayp, const char *timep); @@ -292,12 +293,15 @@ struct lookup }; static struct lookup const *byword(const char *string, - const struct lookup * lp); + const struct lookup *lp); -static struct lookup const line_codes[] = { +static struct lookup const zi_line_codes[] = { {"Rule", LC_RULE}, {"Zone", LC_ZONE}, {"Link", LC_LINK}, + {NULL, 0} +}; +static struct lookup const leap_line_codes[] = { {"Leap", LC_LEAP}, {NULL, 0} }; @@ -373,7 +377,7 @@ static struct attype zic_t at; bool dontmerge; unsigned char type; -} *attypes; +} *attypes; static zic_t gmtoffs[TZ_MAX_TYPES]; static char isdsts[TZ_MAX_TYPES]; static unsigned char abbrinds[TZ_MAX_TYPES]; @@ -424,7 +428,7 @@ erealloc(void *ptr, size_t size) } static char * -ecpyalloc(char const * str) +ecpyalloc(char const *str) { return memcheck(strdup(str)); } @@ -436,7 +440,8 @@ growalloc(void *ptr, size_t itemsize, ptrdiff_t nitems, ptrdiff_t *nitems_alloc) return ptr; else { - ptrdiff_t amax = PTRDIFF_MAX - WORK_AROUND_QTBUG_53071; + ptrdiff_t nitems_max = PTRDIFF_MAX - WORK_AROUND_QTBUG_53071; + ptrdiff_t amax = nitems_max < SIZE_MAX ? nitems_max : SIZE_MAX; if ((amax - 1) / 3 * 2 < *nitems_alloc) memory_exhausted(_("integer overflow")); @@ -450,7 +455,7 @@ growalloc(void *ptr, size_t itemsize, ptrdiff_t nitems, ptrdiff_t *nitems_alloc) */ static void -eats(char const * name, lineno_t num, char const * rname, lineno_t rnum) +eats(char const *name, lineno_t num, char const *rname, lineno_t rnum) { filename = name; linenum = num; @@ -459,7 +464,7 @@ eats(char const * name, lineno_t num, char const * rname, lineno_t rnum) } static void -eat(char const * name, lineno_t num) +eat(char const *name, lineno_t num) { eats(name, num, NULL, -1); } @@ -472,10 +477,10 @@ verror(const char *string, va_list args) * "*" -v on BSD systems. */ if (filename) - fprintf(stderr, _("\"%s\", line %" PRIdLINENO ": "), filename, linenum); + fprintf(stderr, _("\"%s\", line %d: "), filename, linenum); vfprintf(stderr, string, args); if (rfilename != NULL) - fprintf(stderr, _(" (rule from \"%s\", line %" PRIdLINENO ")"), + fprintf(stderr, _(" (rule from \"%s\", line %d)"), rfilename, rlinenum); fprintf(stderr, "\n"); } @@ -504,7 +509,7 @@ warning(const char *string,...) } static void -close_file(FILE *stream, char const * dir, char const * name) +close_file(FILE *stream, char const *dir, char const *name) { char const *e = (ferror(stream) ? _("I/O error") : fclose(stream) != 0 ? strerror(errno) : NULL); @@ -537,7 +542,7 @@ usage(FILE *stream, int status) ancestors. After this is done, all files are accessed with names relative to DIR. */ static void -change_directory(char const * dir) +change_directory(char const *dir) { if (chdir(dir) != 0) { @@ -564,7 +569,7 @@ static const char *leapsec; static const char *yitcommand; int -main(int argc, char *argv[]) +main(int argc, char **argv) { int c, k; @@ -573,7 +578,7 @@ main(int argc, char *argv[]) #ifndef WIN32 umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH)); -#endif /* !WIN32 */ +#endif progname = argv[0]; if (TYPE_BIT(zic_t) <64) { @@ -632,7 +637,10 @@ main(int argc, char *argv[]) break; case 'y': if (yitcommand == NULL) + { + warning(_("-y is obsolescent")); yitcommand = strdup(optarg); + } else { fprintf(stderr, @@ -721,8 +729,8 @@ main(int argc, char *argv[]) } static bool -componentcheck(char const * name, char const * component, - char const * component_end) +componentcheck(char const *name, char const *component, + char const *component_end) { enum { @@ -813,7 +821,7 @@ namecheck(const char *name) */ #ifdef HAVE_SYMLINK static char * -relname(char const * from, char const * to) +relname(char const *from, char const *to) { size_t i, taillen, @@ -853,12 +861,12 @@ relname(char const * from, char const * to) } return result; } -#endif /* HAVE_SYMLINK */ +#endif /* HAVE_SYMLINK */ /* Hard link FROM to TO, following any symbolic links. Return 0 if successful, an error number otherwise. */ static int -hardlinkerr(char const * from, char const * to) +hardlinkerr(char const *from, char const *to) { int r = linkat(AT_FDCWD, from, AT_FDCWD, to, AT_SYMLINK_FOLLOW); @@ -866,7 +874,7 @@ hardlinkerr(char const * from, char const * to) } static void -dolink(char const * fromfield, char const * tofield, bool staysymlink) +dolink(char const *fromfield, char const *tofield, bool staysymlink) { bool todirs_made = false; int link_errno; @@ -921,7 +929,7 @@ dolink(char const * fromfield, char const * tofield, bool staysymlink) strerror(link_errno)); } else -#endif /* HAVE_SYMLINK */ +#endif /* HAVE_SYMLINK */ { FILE *fp, *tp; @@ -1010,7 +1018,7 @@ static const zic_t early_time = (WORK_AROUND_GNOME_BUG_730332 /* Return true if NAME is a directory. */ static bool -itsdir(char const * name) +itsdir(char const *name) { struct stat st; int res = stat(name, &st); @@ -1035,7 +1043,7 @@ itsdir(char const * name) /* Return true if NAME is a symbolic link. */ static bool -itssymlink(char const * name) +itssymlink(char const *name) { #ifdef HAVE_SYMLINK char c; @@ -1203,6 +1211,9 @@ infile(const char *name) wantcont = inzcont(fields, nfields); else { + struct lookup const *line_codes + = name == leapsec ? leap_line_codes : zi_line_codes; + lp = byword(fields[0], line_codes); if (lp == NULL) error(_("input line of unknown type")); @@ -1221,12 +1232,7 @@ infile(const char *name) wantcont = false; break; case LC_LEAP: - if (name != leapsec) - warning(_("%s: Leap line in non leap" - " seconds file %s"), - progname, name); - else - inleap(fields, nfields); + inleap(fields, nfields); wantcont = false; break; default: /* "cannot happen" */ @@ -1251,7 +1257,7 @@ infile(const char *name) * Call error with errstring and return zero on errors. */ static zic_t -gethms(char const * string, char const * errstring, bool signable) +gethms(char const *string, char const *errstring, bool signable) { /* PG: make hh be int not zic_t to avoid sscanf portability issues */ int hh; @@ -1360,7 +1366,7 @@ inzone(char **fields, int nfields) strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) { error(_("duplicate zone name %s" - " (file \"%s\", line %" PRIdLINENO ")"), + " (file \"%s\", line %d)"), fields[ZF_NAME], zones[i].z_filename, zones[i].z_linenum); @@ -1574,21 +1580,11 @@ inleap(char **fields, int nfields) positive = false; count = 1; } - else if (strcmp(cp, "--") == 0) - { - positive = false; - count = 2; - } else if (strcmp(cp, "+") == 0) { positive = true; count = 1; } - else if (strcmp(cp, "++") == 0) - { - positive = true; - count = 2; - } else { error(_("illegal CORRECTION field on Leap line")); @@ -1600,9 +1596,9 @@ inleap(char **fields, int nfields) return; } t = tadd(t, tod); - if (t < early_time) + if (t < 0) { - error(_("leap second precedes Big Bang")); + error(_("leap second precedes Epoch")); return; } leapadd(t, positive, lp->l_value, count); @@ -1635,7 +1631,7 @@ inlink(char **fields, int nfields) } static void -rulesub(struct rule * rp, const char *loyearp, const char *hiyearp, +rulesub(struct rule *rp, const char *loyearp, const char *hiyearp, const char *typep, const char *monthp, const char *dayp, const char *timep) { @@ -1754,11 +1750,14 @@ rulesub(struct rule * rp, const char *loyearp, const char *hiyearp, error(_("typed single year")); return; } + warning(_("year type \"%s\" is obsolete; use \"-\" instead"), + typep); rp->r_yrtype = ecpyalloc(typep); } /* - * Day work. Accept things such as: 1 last-Sunday Sun<=20 Sun>=7 + * Day work. Accept things such as: 1 lastSunday last-Sunday + * (undocumented; warn about this) Sun<=20 Sun>=7 */ dp = ecpyalloc(dayp); if ((lp = byword(dp, lasts)) != NULL) @@ -2141,7 +2140,7 @@ writezone(const char *const name, const char *const string, char version) writetype[type] = true; } } -#endif /* !defined +#endif /* !defined * LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH */ thistypecnt = 0; for (i = 0; i < typecnt; ++i) @@ -2324,7 +2323,7 @@ abbroffset(char *buf, zic_t offset) } static size_t -doabbr(char *abbr, struct zone const * zp, char const * letters, +doabbr(char *abbr, struct zone const *zp, char const *letters, zic_t stdoff, bool doquotes) { char *cp; @@ -2410,7 +2409,7 @@ stringoffset(char *result, zic_t offset) } static int -stringrule(char *result, const struct rule * const rp, const zic_t dstoff, +stringrule(char *result, const struct rule *const rp, const zic_t dstoff, const zic_t gmtoff) { zic_t tod = rp->r_tod; @@ -2492,7 +2491,7 @@ stringrule(char *result, const struct rule * const rp, const zic_t dstoff, } static int -rule_cmp(struct rule const * a, struct rule const * b) +rule_cmp(struct rule const *a, struct rule const *b) { if (!a) return -!!b; @@ -2510,7 +2509,7 @@ enum YEAR_BY_YEAR_ZONE = 1}; static int -stringzone(char *result, struct zone const * zpfirst, ptrdiff_t zonecount) +stringzone(char *result, struct zone const *zpfirst, ptrdiff_t zonecount) { const struct zone *zp; struct rule *rp; @@ -2645,7 +2644,7 @@ stringzone(char *result, struct zone const * zpfirst, ptrdiff_t zonecount) } static void -outzone(const struct zone * zpfirst, ptrdiff_t zonecount) +outzone(const struct zone *zpfirst, ptrdiff_t zonecount) { const struct zone *zp; struct rule *rp; @@ -2851,9 +2850,10 @@ outzone(const struct zone * zpfirst, ptrdiff_t zonecount) { ptrdiff_t k; zic_t jtime, - ktime = 0; + ktime; zic_t offset; + INITIALIZE(ktime); if (useuntil) { /* @@ -2930,7 +2930,8 @@ outzone(const struct zone * zpfirst, ptrdiff_t zonecount) continue; } if (*startbuf == '\0' && - startoff == oadd(zp->z_gmtoff, stdoff)) + startoff == oadd(zp->z_gmtoff, + stdoff)) { doabbr(startbuf, zp, @@ -3046,7 +3047,7 @@ addtt(zic_t starttime, int type) } static int -addtype(zic_t gmtoff, char const * abbr, bool isdst, bool ttisstd, bool ttisgmt) +addtype(zic_t gmtoff, char const *abbr, bool isdst, bool ttisstd, bool ttisgmt) { int i, j; @@ -3105,14 +3106,7 @@ leapadd(zic_t t, bool positive, int rolling, int count) } for (i = 0; i < leapcnt; ++i) if (t <= trans[i]) - { - if (t == trans[i]) - { - error(_("repeated leap second moment")); - exit(EXIT_FAILURE); - } break; - } do { for (j = leapcnt; j > i; --j) @@ -3133,19 +3127,26 @@ adjleap(void) { int i; zic_t last = 0; + zic_t prevtrans = 0; /* * propagate leap seconds forward */ for (i = 0; i < leapcnt; ++i) { + if (trans[i] - prevtrans < 28 * SECSPERDAY) + { + error(_("Leap seconds too close together")); + exit(EXIT_FAILURE); + } + prevtrans = trans[i]; trans[i] = tadd(trans[i], last); last = corr[i] += last; } } static char * -shellquote(char *b, char const * s) +shellquote(char *b, char const *s) { *b++ = '\''; while (*s) @@ -3192,7 +3193,7 @@ yearistype(zic_t year, const char *type) exit(EXIT_FAILURE); } -/* Is A a space character in the C locale? */ +/* Is A a space character in the C locale? */ static bool is_space(char a) { @@ -3363,8 +3364,21 @@ itsabbr(const char *abbr, const char *word) return true; } +/* Return true if ABBR is an initial prefix of WORD, ignoring ASCII case. */ + +static bool +ciprefix(char const *abbr, char const *word) +{ + do + if (!*abbr) + return true; + while (lowerit(*abbr++) == lowerit(*word++)); + + return false; +} + static const struct lookup * -byword(const char *word, const struct lookup * table) +byword(const char *word, const struct lookup *table) { const struct lookup *foundlp; const struct lookup *lp; @@ -3372,6 +3386,23 @@ byword(const char *word, const struct lookup * table) if (word == NULL || table == NULL) return NULL; + /* + * If TABLE is LASTS and the word starts with "last" followed by a + * non-'-', skip the "last" and look in WDAY_NAMES instead. Warn about any + * usage of the undocumented prefix "last-". + */ + if (table == lasts && ciprefix("last", word) && word[4]) + { + if (word[4] == '-') + warning(_("\"%s\" is undocumented; use \"last%s\" instead"), + word, word + 5); + else + { + word += 4; + table = wday_names; + } + } + /* * Look for exact match. */ @@ -3384,13 +3415,31 @@ byword(const char *word, const struct lookup * table) */ foundlp = NULL; for (lp = table; lp->l_word != NULL; ++lp) - if (itsabbr(word, lp->l_word)) + if (ciprefix(word, lp->l_word)) { if (foundlp == NULL) foundlp = lp; else return NULL; /* multiple inexact matches */ } + + /* Warn about any backward-compatibility issue with pre-2017c zic. */ + if (foundlp) + { + bool pre_2017c_match = false; + + for (lp = table; lp->l_word; lp++) + if (itsabbr(word, lp->l_word)) + { + if (pre_2017c_match) + { + warning(_("\"%s\" is ambiguous in pre-2017c zic"), word); + break; + } + pre_2017c_match = true; + } + } + return foundlp; } @@ -3479,7 +3528,7 @@ tadd(zic_t t1, zic_t t2) */ static zic_t -rpytime(const struct rule * rp, zic_t wantedy) +rpytime(const struct rule *rp, zic_t wantedy) { int m, i; @@ -3571,7 +3620,7 @@ will not work with pre-2004 versions of zic")); return min_time; if (dayoff > max_time / SECSPERDAY) return max_time; - t = (zic_t) dayoff *SECSPERDAY; + t = (zic_t) dayoff * SECSPERDAY; return tadd(t, rp->r_tod); } @@ -3615,18 +3664,22 @@ newabbr(const char *string) do it for ARGNAME too. Exit with failure if there is trouble. Do not consider an existing non-directory to be trouble. */ static void -mkdirs(char const * argname, bool ancestors) +mkdirs(char const *argname, bool ancestors) { char *name; char *cp; cp = name = ecpyalloc(argname); + /* + * On MS-Windows systems, do not worry about drive letters or backslashes, + * as this should suffice in practice. Time zone names do not use drive + * letters and backslashes. If the -d option of zic does not name an + * already-existing directory, it can use slashes to separate the + * already-existing ancestor prefix from the to-be-created subdirectories. + */ + /* Do not mkdir a root directory, as it must exist. */ -#ifdef WIN32 - if (is_alpha(name[0]) && name[1] == ':') - cp += 2; -#endif while (*cp == '/') cp++; From a1f30ecc5115b0186ad02ec76f75296906813d26 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Fri, 22 Sep 2017 16:50:59 -0400 Subject: [PATCH 0240/1139] Fix saving and restoring umask In two cases, we set a different umask for some piece of code and restore it afterwards. But if the contained code errors out, the umask is not restored. So add TRY/CATCH blocks to fix that. --- src/backend/commands/copy.c | 11 ++++++++++- src/backend/libpq/be-fsstubs.c | 13 +++++++++++-- 2 files changed, 21 insertions(+), 3 deletions(-) diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c index 41a828c2fe..feab7aa6e2 100644 --- a/src/backend/commands/copy.c +++ b/src/backend/commands/copy.c @@ -1802,7 +1802,16 @@ BeginCopyTo(Relation rel, errmsg("relative path not allowed for COPY to file"))); oumask = umask(S_IWGRP | S_IWOTH); - cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W); + PG_TRY(); + { + cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W); + } + PG_CATCH(); + { + umask(oumask); + PG_RE_THROW(); + } + PG_END_TRY(); umask(oumask); if (cstate->copy_file == NULL) ereport(ERROR, diff --git a/src/backend/libpq/be-fsstubs.c b/src/backend/libpq/be-fsstubs.c index 50e416da79..0112428e7d 100644 --- a/src/backend/libpq/be-fsstubs.c +++ b/src/backend/libpq/be-fsstubs.c @@ -538,8 +538,17 @@ lo_export(PG_FUNCTION_ARGS) */ text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf)); oumask = umask(S_IWGRP | S_IWOTH); - fd = OpenTransientFile(fnamebuf, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, - S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); + PG_TRY(); + { + fd = OpenTransientFile(fnamebuf, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, + S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); + } + PG_CATCH(); + { + umask(oumask); + PG_RE_THROW(); + } + PG_END_TRY(); umask(oumask); if (fd < 0) ereport(ERROR, From 10aafbdbe4224846095198644a1169807ab9b391 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Mon, 25 Sep 2017 08:03:05 -0400 Subject: [PATCH 0241/1139] Support building with Visual Studio 2017 Haribabu Kommi, reviewed by Takeshi Ideriha and Christian Ullrich Backpatch to 9.6 --- doc/src/sgml/install-windows.sgml | 16 +++++++++------- src/tools/msvc/MSBuildProject.pm | 23 +++++++++++++++++++++++ src/tools/msvc/README | 13 +++++++------ src/tools/msvc/Solution.pm | 26 ++++++++++++++++++++++++++ src/tools/msvc/VSObjectFactory.pm | 13 +++++++++++++ 5 files changed, 78 insertions(+), 13 deletions(-) diff --git a/doc/src/sgml/install-windows.sgml b/doc/src/sgml/install-windows.sgml index 3bdcc75079..1f7ad7a648 100644 --- a/doc/src/sgml/install-windows.sgml +++ b/doc/src/sgml/install-windows.sgml @@ -19,10 +19,10 @@ There are several different ways of building PostgreSQL on Windows. The simplest way to build with - Microsoft tools is to install Visual Studio Express 2015 + Microsoft tools is to install Visual Studio Express 2017 for Windows Desktop and use the included compiler. It is also possible to build with the full - Microsoft Visual C++ 2005 to 2015. + Microsoft Visual C++ 2005 to 2017. In some cases that requires the installation of the Windows SDK in addition to the compiler. @@ -77,19 +77,19 @@ Visual Studio Express or some versions of the Microsoft Windows SDK. If you do not already have a Visual Studio environment set up, the easiest - ways are to use the compilers from Visual Studio Express 2015 + ways are to use the compilers from Visual Studio Express 2017 for Windows Desktop or those in the Windows SDK - 7.1, which are both free downloads from Microsoft. + 8.1, which are both free downloads from Microsoft. Both 32-bit and 64-bit builds are possible with the Microsoft Compiler suite. 32-bit PostgreSQL builds are possible with Visual Studio 2005 to - Visual Studio 2015 (including Express editions), - as well as standalone Windows SDK releases 6.0 to 7.1. + Visual Studio 2017 (including Express editions), + as well as standalone Windows SDK releases 6.0 to 8.1. 64-bit PostgreSQL builds are supported with - Microsoft Windows SDK version 6.0a to 7.1 or + Microsoft Windows SDK version 6.0a to 8.1 or Visual Studio 2008 and above. Compilation is supported down to Windows XP and Windows Server 2003 when building with @@ -97,6 +97,8 @@ Visual Studio 2013. Building with Visual Studio 2015 is supported down to Windows Vista and Windows Server 2008. + Building with Visual Studio 2017 is supported + down to Windows 7 SP1 and Windows Server 2008 R2 SP1. diff --git a/src/tools/msvc/MSBuildProject.pm b/src/tools/msvc/MSBuildProject.pm index 27329f9e36..7a287bd0bd 100644 --- a/src/tools/msvc/MSBuildProject.pm +++ b/src/tools/msvc/MSBuildProject.pm @@ -483,4 +483,27 @@ sub new return $self; } +package VC2017Project; + +# +# Package that encapsulates a Visual C++ 2017 project file +# + +use strict; +use warnings; +use base qw(VC2012Project); + +sub new +{ + my $classname = shift; + my $self = $classname->SUPER::_new(@_); + bless($self, $classname); + + $self->{vcver} = '15.00'; + $self->{PlatformToolset} = 'v141'; + $self->{ToolsVersion} = '15.0'; + + return $self; +} + 1; diff --git a/src/tools/msvc/README b/src/tools/msvc/README index b61ddb8791..48082cab90 100644 --- a/src/tools/msvc/README +++ b/src/tools/msvc/README @@ -4,7 +4,7 @@ MSVC build ========== This directory contains the tools required to build PostgreSQL using -Microsoft Visual Studio 2005 - 2011. This builds the whole backend, not just +Microsoft Visual Studio 2005 - 2017. This builds the whole backend, not just the libpq frontend library. For more information, see the documentation chapter "Installation on Windows" and the description below. @@ -92,11 +92,12 @@ These configuration arguments are passed over to Mkvcbuild::mkvcbuild (Mkvcbuild.pm) which creates the Visual Studio project and solution files. It does this by using VSObjectFactory::CreateSolution to create an object implementing the Solution interface (this could be either a VS2005Solution, -a VS2008Solution, a VS2010Solution or a VS2012Solution, all in Solution.pm, -depending on the user's build environment) and adding objects implementing -the corresponding Project interface (VC2005Project or VC2008Project from -VCBuildProject.pm or VC2010Project or VC2012Project from MSBuildProject.pm) -to it. +a VS2008Solution, a VS2010Solution or a VS2012Solution or a VS2013Solution, +or a VS2015Solution or a VS2017Solution, all in Solution.pm, depending on +the user's build environment) and adding objects implementing the corresponding +Project interface (VC2005Project or VC2008Project from VCBuildProject.pm or +VC2010Project or VC2012Project or VC2013Project or VC2015Project or VC2017Project +from MSBuildProject.pm) to it. When Solution::Save is called, the implementations of Solution and Project save their content in the appropriate format. The final step of starting the appropriate build program (msbuild or vcbuild) diff --git a/src/tools/msvc/Solution.pm b/src/tools/msvc/Solution.pm index abedb4f948..a8fdc31530 100644 --- a/src/tools/msvc/Solution.pm +++ b/src/tools/msvc/Solution.pm @@ -827,6 +827,32 @@ sub new return $self; } +package VS2017Solution; + +# +# Package that encapsulates a Visual Studio 2017 solution file +# + +use Carp; +use strict; +use warnings; +use base qw(Solution); + +sub new +{ + my $classname = shift; + my $self = $classname->SUPER::_new(@_); + bless($self, $classname); + + $self->{solutionFileVersion} = '12.00'; + $self->{vcver} = '15.00'; + $self->{visualStudioName} = 'Visual Studio 2017'; + $self->{VisualStudioVersion} = '15.0.26730.3'; + $self->{MinimumVisualStudioVersion} = '10.0.40219.1'; + + return $self; +} + sub GetAdditionalHeaders { my ($self, $f) = @_; diff --git a/src/tools/msvc/VSObjectFactory.pm b/src/tools/msvc/VSObjectFactory.pm index 4190ada618..2f3480a1f6 100644 --- a/src/tools/msvc/VSObjectFactory.pm +++ b/src/tools/msvc/VSObjectFactory.pm @@ -53,8 +53,14 @@ sub CreateSolution { return new VS2015Solution(@_); } + # visual 2017 hasn't changed the nmake version to 15, so adjust the check to support it. + elsif (($visualStudioVersion ge '14.10') or ($visualStudioVersion eq '15.00')) + { + return new VS2017Solution(@_); + } else { + croak $visualStudioVersion; croak "The requested Visual Studio version is not supported."; } } @@ -92,8 +98,14 @@ sub CreateProject { return new VC2015Project(@_); } + # visual 2017 hasn't changed the nmake version to 15, so adjust the check to support it. + elsif (($visualStudioVersion ge '14.10') or ($visualStudioVersion eq '15.00')) + { + return new VC2017Project(@_); + } else { + croak $visualStudioVersion; croak "The requested Visual Studio version is not supported."; } } @@ -120,6 +132,7 @@ sub DetermineVisualStudioVersion sub _GetVisualStudioVersion { my ($major, $minor) = @_; + # visual 2017 hasn't changed the nmake version to 15, so still using the older version for comparison. if ($major > 14) { carp From 1750612224704043218fac81e29c05d866e866ce Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 25 Sep 2017 16:09:20 -0400 Subject: [PATCH 0242/1139] Avoid SIGBUS on Linux when a DSM memory request overruns tmpfs. On Linux, shared memory segments created with shm_open() are backed by swap files created in tmpfs. If the swap file needs to be extended, but there's no tmpfs space left, you get a very unfriendly SIGBUS trap. To avoid this, force allocation of the full request size when we create the segment. This adds a few cycles, but none that we wouldn't expend later anyway, assuming the request isn't hugely bigger than the actual need. Make this code #ifdef __linux__, because (a) there's not currently a reason to think the same problem exists on other platforms, and (b) applying posix_fallocate() to an FD created by shm_open() isn't very portable anyway. Back-patch to 9.4 where the DSM code came in. Thomas Munro, per a bug report from Amul Sul Discussion: https://postgr.es/m/1002664500.12301802.1471008223422.JavaMail.yahoo@mail.yahoo.com --- configure | 2 +- configure.in | 2 +- src/backend/storage/ipc/dsm_impl.c | 54 ++++++++++++++++++++++++++++-- src/include/pg_config.h.in | 3 ++ src/include/pg_config.h.win32 | 3 ++ 5 files changed, 60 insertions(+), 4 deletions(-) diff --git a/configure b/configure index 2821a8f7e4..2ed820f3ac 100755 --- a/configure +++ b/configure @@ -12517,7 +12517,7 @@ fi LIBS_including_readline="$LIBS" LIBS=`echo "$LIBS" | sed -e 's/-ledit//g' -e 's/-lreadline//g'` -for ac_func in cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l +for ac_func in cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll posix_fallocate pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" diff --git a/configure.in b/configure.in index a1696db921..60a767ef5a 100644 --- a/configure.in +++ b/configure.in @@ -1457,7 +1457,7 @@ PGAC_FUNC_WCSTOMBS_L LIBS_including_readline="$LIBS" LIBS=`echo "$LIBS" | sed -e 's/-ledit//g' -e 's/-lreadline//g'` -AC_CHECK_FUNCS([cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l]) +AC_CHECK_FUNCS([cbrt dlopen fdatasync getifaddrs getpeerucred getrlimit mbstowcs_l memmove poll posix_fallocate pstat pthread_is_threaded_np readlink setproctitle setsid shm_open symlink sync_file_range towlower utime utimes wcstombs wcstombs_l]) AC_REPLACE_FUNCS(fseeko) case $host_os in diff --git a/src/backend/storage/ipc/dsm_impl.c b/src/backend/storage/ipc/dsm_impl.c index 8c706aee00..fce6044a3d 100644 --- a/src/backend/storage/ipc/dsm_impl.c +++ b/src/backend/storage/ipc/dsm_impl.c @@ -73,6 +73,7 @@ static bool dsm_impl_posix(dsm_op op, dsm_handle handle, Size request_size, void **impl_private, void **mapped_address, Size *mapped_size, int elevel); +static int dsm_impl_posix_resize(int fd, off_t size); #endif #ifdef USE_DSM_SYSV static bool dsm_impl_sysv(dsm_op op, dsm_handle handle, Size request_size, @@ -319,7 +320,8 @@ dsm_impl_posix(dsm_op op, dsm_handle handle, Size request_size, } request_size = st.st_size; } - else if (*mapped_size != request_size && ftruncate(fd, request_size)) + else if (*mapped_size != request_size && + dsm_impl_posix_resize(fd, request_size) != 0) { int save_errno; @@ -392,7 +394,55 @@ dsm_impl_posix(dsm_op op, dsm_handle handle, Size request_size, return true; } -#endif + +/* + * Set the size of a virtual memory region associated with a file descriptor. + * If necessary, also ensure that virtual memory is actually allocated by the + * operating system, to avoid nasty surprises later. + * + * Returns non-zero if either truncation or allocation fails, and sets errno. + */ +static int +dsm_impl_posix_resize(int fd, off_t size) +{ + int rc; + + /* Truncate (or extend) the file to the requested size. */ + rc = ftruncate(fd, size); + + /* + * On Linux, a shm_open fd is backed by a tmpfs file. After resizing with + * ftruncate, the file may contain a hole. Accessing memory backed by a + * hole causes tmpfs to allocate pages, which fails with SIGBUS if there + * is no more tmpfs space available. So we ask tmpfs to allocate pages + * here, so we can fail gracefully with ENOSPC now rather than risking + * SIGBUS later. + */ +#if defined(HAVE_POSIX_FALLOCATE) && defined(__linux__) + if (rc == 0) + { + /* We may get interrupted, if so just retry. */ + do + { + rc = posix_fallocate(fd, 0, size); + } while (rc == -1 && errno == EINTR); + + if (rc != 0 && errno == ENOSYS) + { + /* + * Kernel too old (< 2.6.23). Rather than fail, just trust that + * we won't hit the problem (it typically doesn't show up without + * many-GB-sized requests, anyway). + */ + rc = 0; + } + } +#endif /* HAVE_POSIX_FALLOCATE && __linux__ */ + + return rc; +} + +#endif /* USE_DSM_POSIX */ #ifdef USE_DSM_SYSV /* diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in index a152371e61..1e0583f7b1 100644 --- a/src/include/pg_config.h.in +++ b/src/include/pg_config.h.in @@ -390,6 +390,9 @@ /* Define to 1 if you have the `posix_fadvise' function. */ #undef HAVE_POSIX_FADVISE +/* Define to 1 if you have the `posix_fallocate' function. */ +#undef HAVE_POSIX_FALLOCATE + /* Define to 1 if the assembler supports PPC's LWARX mutex hint bit. */ #undef HAVE_PPC_LWARX_MUTEX_HINT diff --git a/src/include/pg_config.h.win32 b/src/include/pg_config.h.win32 index 65085d7d31..86a3661bb1 100644 --- a/src/include/pg_config.h.win32 +++ b/src/include/pg_config.h.win32 @@ -258,6 +258,9 @@ /* Define to 1 if you have the header file. */ /* #undef HAVE_POLL_H */ +/* Define to 1 if you have the `posix_fallocate' function. */ +/* #undef HAVE_POSIX_FALLOCATE */ + /* Define to 1 if you have the `pstat' function. */ /* #undef HAVE_PSTAT */ From 12ac252f9014a96c0b7159912659fa4d0f9cbc07 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 26 Sep 2017 13:42:53 -0400 Subject: [PATCH 0243/1139] Fix failure-to-read-man-page in commit 899bd785c. posix_fallocate() is not quite a drop-in replacement for fallocate(), because it is defined to return the error code as its function result, not in "errno". I (tgl) missed this because RHEL6's version seems to set errno as well. That is not the case on more modern Linuxen, though, as per buildfarm results. Aside from fixing the return-convention confusion, remove the test for ENOSYS; we expect that glibc will mask that for posix_fallocate, though it does not for fallocate. Keep the test for EINTR, because POSIX specifies that as a possible result, and buildfarm results suggest that it can happen in practice. Back-patch to 9.4, like the previous commit. Thomas Munro Discussion: https://postgr.es/m/1002664500.12301802.1471008223422.JavaMail.yahoo@mail.yahoo.com --- src/backend/storage/ipc/dsm_impl.c | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/src/backend/storage/ipc/dsm_impl.c b/src/backend/storage/ipc/dsm_impl.c index fce6044a3d..1a11d21df0 100644 --- a/src/backend/storage/ipc/dsm_impl.c +++ b/src/backend/storage/ipc/dsm_impl.c @@ -425,17 +425,14 @@ dsm_impl_posix_resize(int fd, off_t size) do { rc = posix_fallocate(fd, 0, size); - } while (rc == -1 && errno == EINTR); + } while (rc == EINTR); - if (rc != 0 && errno == ENOSYS) - { - /* - * Kernel too old (< 2.6.23). Rather than fail, just trust that - * we won't hit the problem (it typically doesn't show up without - * many-GB-sized requests, anyway). - */ - rc = 0; - } + /* + * The caller expects errno to be set, but posix_fallocate() doesn't + * set it. Instead it returns error numbers directly. So set errno, + * even though we'll also return rc to indicate success or failure. + */ + errno = rc; } #endif /* HAVE_POSIX_FALLOCATE && __linux__ */ From cb87ae6c5b2e83665312155140d9a01b37f50cbb Mon Sep 17 00:00:00 2001 From: knizhnik Date: Tue, 9 Feb 2016 00:03:51 +0300 Subject: [PATCH 0244/1139] Continue wwork on mmts --- multimaster.c | 318 ++++++++++++++++++++------------------------------ 1 file changed, 128 insertions(+), 190 deletions(-) diff --git a/multimaster.c b/multimaster.c index d316624c5a..6396cf47b7 100644 --- a/multimaster.c +++ b/multimaster.c @@ -53,13 +53,19 @@ #include "multimaster.h" #include "bgwpool.h" +typedef struct DtmTransStatus +{ + TransactionId xid; + XidStatus status; + csn_t csn + bool is_local; + struct DtmTransStatus* next; +} DtmTransStatus; + typedef struct { LWLockId hashLock; - LWLockId xidLock; TransactionId minXid; /* XID of oldest transaction visible by any active transaction (local or global) */ - TransactionId nextXid; /* next XID for local transaction */ - size_t nReservedXids; /* number of XIDs reserved for local transactions */ int64 disabledNodeMask; int nNodes; pg_atomic_uint32 nReceivers; @@ -67,16 +73,10 @@ typedef struct BgwPool pool; } DtmState; -typedef struct -{ - TransactionId xid; - int count; -} LocalTransaction; - typedef struct { TransactionId xid; - GlobalTransactionId gtid; - bool is_global; + bool is_local; + bool is_distributed; csn_t csn; csn_t snapshot; } DtmCurrentTrans; @@ -86,7 +86,7 @@ typedef struct { #define DTM_HASH_SIZE 1003 #define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) -#define MAKE_GTID(xid) (((GlobalTransactionId)MyProcId << 32) | xid) +#define MAKE_GTID(xid) (((GlobalTransactionId)MMNodeId << 32) | xid) void _PG_init(void); void _PG_fini(void); @@ -160,7 +160,6 @@ static int MMWorkers; static char *Arbiters; static char *ArbitersCopy; static int DtmBufferSize; -static bool DtmVoted; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -171,7 +170,6 @@ static void MMExecutorFinish(QueryDesc *queryDesc); static void MMProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag); -static bool MMIsDistributedTrans; static char const* DtmGetName(void) @@ -386,176 +384,130 @@ DtmXactCallback(XactEvent event, void *arg) switch (event) { case XACT_EVENT_START: - //XTM_INFO("%d: normal=%d, initialized=%d, replication=%d, bgw=%d, vacuum=%d\n", - // getpid(), IsNormalProcessingMode(), dtm->initialized, MMDoReplication, IsBackgroundWorker, IsAutoVacuumWorkerProcess()); - if (IsNormalProcessingMode() && dtm->initialized && MMDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess()) { - MMBeginTransaction(); - } + DtmBeginTransaction(&dtm_tx); break; case XACT_EVENT_PRE_COMMIT: - DtmPrepareTransaction(xid); + DtmPrepareTransaction(&dtm_tx); break; - case XACT_EVENT_COMMIT: - case XACT_EVENT_ABORT: - if (TransactionIdIsValid(DtmNextXid)) - { - if (!DtmVoted) { - ArbiterSetTransStatus(DtmNextXid, TRANSACTION_STATUS_ABORTED, false); - } - if (event == XACT_EVENT_COMMIT) - { - /* - * Now transaction status is already written in CLOG, - * so we can remove information about it from hash table - */ - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - hash_search(xid_in_doubt, &DtmNextXid, HASH_REMOVE, NULL); - LWLockRelease(dtm->hashLock); - } -#if 0 /* should be handled now using DtmVoted flag */ - else - { - /* - * Transaction at the node can be aborted because of transaction failure at some other node - * before it starts doing anything and assigned Xid, in this case Postgres is not calling SetTransactionStatus, - * so we have to send report to DTMD here - */ - if (!TransactionIdIsValid(GetCurrentTransactionIdIfAny())) { - XTM_INFO("%d: abort transation on DTMD\n", getpid()); - ArbiterSetTransStatus(DtmNextXid, TRANSACTION_STATUS_ABORTED, false); - } - } -#endif - DtmNextXid = InvalidTransactionId; - DtmLastSnapshot = NULL; - } - MMIsDistributedTrans = false; - break; default: break; } } - -static void DtmPrepareTransaction(TransactionId xid) +void DtmBeginTransaction(DtmCurrentTrans* x) { - Assert(xid == dtm_tx.xid); - - if (!dtm_tx.gtid) { /* GTID is assigned for replicated transaction */ - DtmTransStatus* ts; + if (!TransactionIdIsValid(x->xid)) { LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2status, &xid, HASH_ENTER, NULL); - ts->gtid = MAKE_GTID(xid); - ts->snapshot = dtm_tx.snapshot; - ts->status = TRANSACTION_STATUS_UNKNOWN; + x->xid = GetCurrentTransactionIdIfAny(); + x->csn = INVALID_CSN; + x->is_local = false; + x->is_distributed = false; + x->snapshot = dtm_get_csn(); LWLockRelease(dtm->hashLock); - } + DTM_TRACE((stderr, "DtmLocalBegin: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot)); + } +} + +/* + * We need to pass snapshot to WAL-sender, so create record in transaction status hash table + * before commit + */ +static void DtmPrepareTransaction(DtmCurrentTrans* x) +{ + DtmTransStatus* ts; + Assert(TransactionIdIsValid(x->xid)); + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + ts = hash_search(xid2status, &x->xid, HASH_ENTER, NULL); + ts->snapshot = x->snapshot; + ts->status = TRANSACTION_STATUS_UNKNOWN; + ts->is_local = x->is_local; + LWLockRelease(dtm->hashLock); } -static void DtmCommitTransaction(TransactionId xid) +static XidStatus DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { DtmTransStatus* ts; - GlobalTransactionId gtid = dtm_tx.gtid; + GlobalTransactionId gtid = MAKE_GTID(xid); csn_t csn; - bool found; int i; + int nSubxids; + XidStatus status; + bool ack = ArbiterVoteTransaction(gtid, true); /* wait until transaction at all nodes are prepared */ LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - status = hash_search(xid2status, &xid, HASH_ENTER, &found); - if (found) { /* master transaction */ - Assert(!gtid); - gtid = ts->gtid; - } else { - Assert(gtid); - /* GTID is assigned for replicated transaction */ - ts->status = TRANSACTION_STATUS_IN_PROGRESS; - } - ts->csn = dtm_get_cid(); - ts->nSubxids = id->nSubxids; + ts = hash_search(xid2status, &xid, HASH_FIND, NULL); + Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ + ts->status = status = ack ? TRANSACTION_STATUS_IN_PROGRESS : TRANSACTION_STATUS_ABORTED; + ts->csn = dtm_get_cid(); DtmTransactionListAppend(ts); - DtmAddSubtransactions(ts, id->subxids, id->nSubxids); + DtmAddSubtransactions(ts, subxids, nsubxids); LWLockRelease(dtm->hashLock); - csn = ArbiterGetCSN(gtid, ts->csn); /* get max CSN */ - + csn = ack ? ArbiterGetCSN(gtid, ts->csn) : INVALID_CSN; /* get max CSN */ LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts->csn = csn; - for (i = 0; i < ts->nSubxids; i++) { + if (csn != INVALID_CSN) { + ts->csn = csn; + dtm_sync(csn); + status = TRANSACTION_STATUS_COMMITTED; + } else { + csn = ts->csn; + status = TRANSACTION_STATUS_ABORTED; + } + ts->status = status; + for (i = 0; i < nsubxids; i++) { ts = ts->next; - ts->cid = csn; + ts->status = status; + ts->csn = csn; } - dtm_sync(csn); LWLockRelease(dtm->hashLock); + return status; +} - - - +static void DtmAbortTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) +{ + int i; + DtmTransStatus* ts; + GlobalTransactionId gtid = MAKE_GTID(xid); + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + ts = hash_search(xid2status, &xid, HASH_FIND, NULL); + Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ + ts->status = TRANSACTION_STATUS_ABORTED; + for (i = 0; i < nSubxids; i++) { + ts->status = status; + ts = ts->next; + ts->status = TRANSACTION_STATUS_ABORTED; + } + LWLockRelease(dtm->hashLock); -static XidStatus DtmGetTransactionStatus(TransactionId xid, XLogRecPtr *lsn) -{ - /* Because of global snapshots we can ask for status of transaction which is not yet started locally: so we have - * to compare xid with ShmemVariableCache->nextXid before accessing CLOG - */ - XidStatus status = xid >= ShmemVariableCache->nextXid - ? TRANSACTION_STATUS_IN_PROGRESS - : PgTransactionIdGetStatus(xid, lsn); - XTM_TRACE("XTM: DtmGetTransactionStatus\n"); - return status; -} + ArbiterVoteTransaction(gtid, false); +} + + static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) { XTM_INFO("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); if (!RecoveryInProgress()) { - if (TransactionIdIsValid(DtmNextXid)) + if (status == TRANSACTION_STATUS_ABORTED || !dtm_tx.is_distributed) { - DtmVoted = true; - if (status == TRANSACTION_STATUS_ABORTED || !MMIsDistributedTrans) - { - PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); - ArbiterSetTransStatus(xid, TRANSACTION_STATUS_ABORTED, false); - XTM_INFO("Abort transaction %d\n", xid); - return; - } - else - { - XidStatus verdict; - XTM_INFO("Begin commit transaction %d\n", xid); - - /* Mark transaction as in-doubt in xid_in_doubt hash table */ - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - hash_search(xid_in_doubt, &DtmNextXid, HASH_ENTER, NULL); - LWLockRelease(dtm->hashLock); - verdict = ArbiterSetTransStatus(xid, status, true); - if (verdict != status) { - XTM_INFO("Commit of transaction %d is rejected by arbiter: staus=%d\n", xid, verdict); - DtmNextXid = InvalidTransactionId; - DtmLastSnapshot = NULL; - MMIsDistributedTrans = false; - MarkAsAborted(); - END_CRIT_SECTION(); - elog(ERROR, "Commit of transaction %d is rejected by DTM", xid); - } else { - XTM_INFO("Commit transaction %d\n", xid); - } - } + DtmAbortTransaction(xid, nsubxids, xibxods); + XTM_INFO("Abort transaction %d\n", xid); } else { - XTM_INFO("Set transaction %u status in local CLOG\n" , xid); + if (DtmCommitTransaction(xid, nsubxids, xids) == TRANSACTION_STATUS_COMMITTED) { + XTM_INFO("Commit transaction %d\n", xid); + } else { + PgTransactionIdSetTreeStatus(xid, nsubxids, TRANSACTION_STATUS_ABORTED, status, lsn); + dtm_tx.is_distributed = false; + MarkAsAborted(); + END_CRIT_SECTION(); + elog(ERROR, "Commit of transaction %d is rejected by DTM", xid); + } } } - else if (status != TRANSACTION_STATUS_ABORTED) - { - XidStatus gs; - gs = ArbiterGetTransStatus(xid, false); - if (gs != TRANSACTION_STATUS_UNKNOWN) { - Assert(gs != TRANSACTION_STATUS_IN_PROGRESS); - status = gs; - } - } PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); } @@ -734,42 +686,27 @@ static void DtmShmemStartup(void) DtmInitialize(); } -void DtmLocalBegin(DtmCurrentTrans* x) -{ - if (!TransactionIdIsValid(x->xid)) { - SpinLockAcquire(&local->lock); - x->xid = GetCurrentTransactionIdIfAny(); - x->csn = INVALID_CSN; - x->is_global = false; - x->snapshot = dtm_get_csn(); - SpinLockRelease(&local->lock); - DTM_TRACE((stderr, "DtmLocalBegin: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot)); - } -} - /* * *************************************************************************** */ GlobalTransactionId MMBeginTransaction(void) { - MMIsDistributedTrans = false; + dtm_tx.is_distributed = false; return dtm_tx.snapshot; } -csn_t MMExtend - void MMJoinTransaction(GlonalTransactionId gtid, csn_t snapshot) { - SpinLockAcquire(&local->lock); + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); dtm_sync(snapshot); - SpinLockRelease(&local->lock); + LWLockRelease(dtm->hashLock); dtm_tx.gtid = gtid; dtm_tx.xid = GetCurrentTransactionId(); dtm_tx.snapshot = snapshot; - MMIsDistributedTrans = true; - MMMarkTransAsLocal(dtm_tx.xid); + dtm_tx.is_local = true; + dtm_tx.is_distributed = false; } void MMReceiverStarted() @@ -779,32 +716,17 @@ void MMReceiverStarted() } } -void MMMarkTransAsLocal(TransactionId xid) -{ - LocalTransaction* lt; - - Assert(TransactionIdIsValid(xid)); - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - lt = hash_search(local_trans, &xid, HASH_ENTER, NULL); - lt->count = dtm->nNodes-1; - LWLockRelease(dtm->hashLock); -} - bool MMIsLocalTransaction(TransactionId xid) { - LocalTransaction* lt; - bool result = false; - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - lt = hash_search(local_trans, &xid, HASH_FIND, NULL); - if (lt != NULL) { - result = true; - Assert(lt->count > 0); - if (--lt->count == 0) { - hash_search(local_trans, &xid, HASH_REMOVE, NULL); - } - } - LWLockRelease(dtm->hashLock); - return result; + TransStatus* ts; + bool is_local = false; + LWLockAcquire(dtm->hashLock, LW_SHARED); + ts = hash_search(xid2status, &xid, HASH_FIND, NULL); + if (ts != NULL) { + is_local = ts->is_local; + } + LWLockRelease(dtm->hashLock); + return is_local; } bool MMDetectGlobalDeadLock(PGPROC* proc) @@ -825,7 +747,7 @@ Datum mm_stop_replication(PG_FUNCTION_ARGS) { MMDoReplication = false; - MMIsDistributedTrans = false; + dtm_tx.is_distributed = false; PG_RETURN_VOID(); } @@ -998,7 +920,7 @@ static void MMProcessUtility(Node *parsetree, const char *queryString, params, dest, completionTag); } if (!skipCommand) { - MMIsDistributedTrans = false; + dtm_tx.is_distributed = false; } } else { MMBroadcastUtilityStmt(queryString, false); @@ -1011,7 +933,7 @@ MMExecutorFinish(QueryDesc *queryDesc) CmdType operation = queryDesc->operation; EState *estate = queryDesc->estate; if (estate->es_processed != 0) { - MMIsDistributedTrans |= operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE; + dtm_tx.is_distributed |= operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE; } } if (PreviousExecutorFinishHook != NULL) @@ -1033,3 +955,19 @@ static BgwPool* MMPoolConstructor(void) { return &dtm->pool; } + +static void DtmAddSubtransactions(DtmTransStatus* ts, TransactionId* subxids, int nSubxids) +{ + int i; + for (i = 0; i < nSubxids; i++) { + bool found; + DtmTransStatus* sts; + Assert(TransactionIdIsValid(subxids[i])); + sts = (DtmTransStatus*)hash_search(xid2status, &subxids[i], HASH_ENTER, &found); + Assert(!found); + sts->status = ts->status; + sts->cid = ts->cid; + sts->nSubxids = 0; + DtmTransactionListInsertAfter(ts, sts); + } +} From 4abea17c118d343c988193e1969a0aed07d96353 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 9 Feb 2016 17:59:44 +0300 Subject: [PATCH 0245/1139] Continue work on MMTS --- multimaster.c | 471 ++++++++++++++++++++++++---------------------- multimaster.h | 48 ++++- pglogical_proto.c | 7 +- 3 files changed, 295 insertions(+), 231 deletions(-) diff --git a/multimaster.c b/multimaster.c index 6396cf47b7..93057cbc2b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -48,45 +48,27 @@ #include "port/atomics.h" #include "tcop/utility.h" -#include "arbiter.h" -#include "sockhub.h" #include "multimaster.h" -#include "bgwpool.h" -typedef struct DtmTransStatus -{ - TransactionId xid; - XidStatus status; - csn_t csn - bool is_local; - struct DtmTransStatus* next; -} DtmTransStatus; - -typedef struct -{ - LWLockId hashLock; - TransactionId minXid; /* XID of oldest transaction visible by any active transaction (local or global) */ - int64 disabledNodeMask; - int nNodes; - pg_atomic_uint32 nReceivers; - bool initialized; - BgwPool pool; -} DtmState; + typedef struct { TransactionId xid; - bool is_local; - bool is_distributed; - csn_t csn; - csn_t snapshot; + GlobalTransactionId gtid + bool is_local; /* transaction on replica */ + bool is_distributed; /* transaction performs INSERT/UPDATE/DELETE and has to be replicated to other nodes */ + csn_t snapshot; /* transaction snaphsot */ } DtmCurrentTrans; +typedef uint64 timestamp_t; #define DTM_SHMEM_SIZE (64*1024*1024) -#define DTM_HASH_SIZE 1003 +#define DTM_HASH_SIZE 1000003 +#define USEC 1000000 +#define MIN_WAIT_TIMEOUT 1000 +#define MAX_WAIT_TIMEOUT 100000 #define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) -#define MAKE_GTID(xid) (((GlobalTransactionId)MMNodeId << 32) | xid) void _PG_init(void); void _PG_fini(void); @@ -98,69 +80,55 @@ PG_FUNCTION_INFO_V1(mm_stop_replication); PG_FUNCTION_INFO_V1(mm_drop_node); static Snapshot DtmGetSnapshot(Snapshot snapshot); -static void DtmMergeWithGlobalSnapshot(Snapshot snapshot); -static XidStatus DtmGetTransactionStatus(TransactionId xid, XLogRecPtr *lsn); static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); static void DtmUpdateRecentXmin(Snapshot snapshot); static void DtmInitialize(void); -static void DtmSubXactCallback(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg); static void DtmXactCallback(XactEvent event, void *arg); -static TransactionId DtmGetNextXid(void); -static TransactionId DtmGetNewTransactionId(bool isSubXact); -static TransactionId DtmGetOldestXmin(Relation rel, bool ignoreVacuum); -static TransactionId DtmGetGlobalTransactionId(void); +static Snapshot DtmGetSnapshot(Snapshot snapshot); +static TransactionId DtmGetOldestXmin(Relation rel, bool ignoreVacuum); +static bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); +static TransactionId DtmAdjustOldestXid(TransactionId xid); static bool DtmDetectGlobalDeadLock(PGPROC* proc); -static void DtmSerializeLock(PROCLOCK* lock, void* arg); +static cid_t DtmGetCsn(TransactionId xid); +static void DtmAddSubtransactions(DtmTransState* ts, TransactionId* subxids, int nSubxids); static char const* DtmGetName(void); -static bool TransactionIdIsInSnapshot(TransactionId xid, Snapshot snapshot); -static bool TransactionIdIsInDoubt(TransactionId xid); - static void DtmShmemStartup(void); -static void DtmBackgroundWorker(Datum arg); -static void MMMarkTransAsLocal(TransactionId xid); static BgwPool* MMPoolConstructor(void); static bool MMRunUtilityStmt(PGconn* conn, char const* sql); static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError); - -static HTAB* xid_in_doubt; -static HTAB* local_trans; -static DtmState* dtm; - -static TransactionId DtmNextXid; -static SnapshotData DtmSnapshot = { HeapTupleSatisfiesMVCC }; -static bool DtmHasGlobalSnapshot; -static int DtmLocalXidReserve; -static CommandId DtmCurcid; -static Snapshot DtmLastSnapshot; -static TransactionManager DtmTM = { - DtmGetTransactionStatus, - DtmSetTransactionStatus, - DtmGetSnapshot, - DtmGetNewTransactionId, - DtmGetOldestXmin, - PgTransactionIdIsInProgress, - DtmGetGlobalTransactionId, - PgXidInMVCCSnapshot, - DtmDetectGlobalDeadLock, - DtmGetName +static void MMVoteForTransaction(DtmTransState* ts); + +static HTAB* xid2state; +static DtmCurrentTrans dtm_tx; + +static TransactionManager DtmTM = { + PgTransactionIdGetStatus, + PgTransactionIdSetTreeStatus, + DtmGetSnapshot, + PgGetNewTransactionId, + DtmGetOldestXmin, + PgTransactionIdIsInProgress, + PgGetGlobalTransactionId, + DtmXidInMVCCSnapshot, + DtmDetectGlobalDeadLock, + DtmGetName }; +DtmState* dtm; bool MMDoReplication; char* MMDatabaseName; -static char* MMConnStrs; -static int MMNodeId; +char* MMConnStrs; +int MMNodeId; +int MMArbiterPort; + static int MMNodes; static int MMQueueSize; static int MMWorkers; -static char *Arbiters; -static char *ArbitersCopy; -static int DtmBufferSize; - static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; static shmem_startup_hook_type PreviousShmemStartupHook; @@ -171,7 +139,82 @@ static void MMProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag); +/* + * System time manipulation functions + */ + + +static timestamp_t dtm_get_current_time() +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + local->time_shift; +} + +static void dtm_sleep(timestamp_t interval) +{ + struct timespec ts; + struct timespec rem; + ts.tv_sec = 0; + ts.tv_nsec = interval*1000; + + while (nanosleep(&ts, &rem) < 0) { + totalSleepInterrupts += 1; + Assert(errno == EINTR); + ts = rem; + } +} + +static csn_t dtm_get_csn() +{ + csn_t csn = dtm_get_current_time(); + if (csn <= dtm->csn) { + csn = ++dtm->csn; + } else { + dtm->csn = csn; + } + return csn; +} +static csn_t dtm_sync(csn_t global_csn) +{ + csn_t dtm_csn; +#if 1 + while ((dtm_csn = dtm_get_csn()) < global_csn) { + dtm->time_shift += global_csn - dtm_csn; + } +#else + while ((dtm_csn = dtm_get_csn()) < global_csn) { + LWLockRelease(&dtm->hashLock); +#if TRACE_SLEEP_TIME + { + timestamp_t now = dtm_get_current_time(); + static timestamp_t firstReportTime; + static timestamp_t prevReportTime; + static timestamp_t totalSleepTime; +#endif + dtm_sleep(global_csn - dtm_csn); +#if TRACE_SLEEP_TIME + totalSleepTime += dtm_get_current_time() - now; + if (now > prevReportTime + USEC) { + prevReportTime = now; + if (firstReportTime == 0) { + firstReportTime = now; + } else { + fprintf(stderr, "Sync sleep %lu of %lu usec (%f%%)\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime)); + } + } + } +#endif + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + } +#endif + return dtm_csn; +} + +/* + * Distribute transaction manager functions + */ static char const* DtmGetName(void) { return "mmts"; @@ -203,7 +246,7 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) timestamp_t delay = MIN_WAIT_TIMEOUT; Assert(xid != InvalidTransactionId); - SpinLockAcquire(&local->lock); + LWLockAcquire(&dtm->hashLock, LW_SHARED); #if TRACE_SLEEP_TIME if (firstReportTime == 0) { @@ -212,19 +255,19 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) #endif while (true) { - DtmTransStatus* ts = (DtmTransStatus*)hash_search(xid2status, &xid, HASH_FIND, NULL); + DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { - if (ts->cid > dtm_tx.snapshot) { + if (ts->csn > dtm_tx.snapshot) { DTM_TRACE((stderr, "%d: tuple with xid=%d(csn=%lld) is invisibile in snapshot %lld\n", - getpid(), xid, ts->cid, dtm_tx.snapshot)); - SpinLockRelease(&local->lock); + getpid(), xid, ts->csn, dtm_tx.snapshot)); + LWLockRelease(&dtm->hashLock); return true; } if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { DTM_TRACE((stderr, "%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtm_tx.snapshot)); - SpinLockRelease(&local->lock); + LWLockRelease(&dtm->hashLock); #if TRACE_SLEEP_TIME { timestamp_t delta, now = dtm_get_current_time(); @@ -249,14 +292,14 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (delay*2 <= MAX_WAIT_TIMEOUT) { delay *= 2; } - SpinLockAcquire(&local->lock); + LWLockAcquire(&dtm->hashLock, LW_SHARED); } else { - bool invisible = ts->status == TRANSACTION_STATUS_ABORTED; + bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; DTM_TRACE((stderr, "%d: tuple with xid=%d(csn= %lld) is %s in snapshot %lld\n", - getpid(), xid, ts->cid, invisible ? "rollbacked" : "committed", dtm_tx.snapshot)); - SpinLockRelease(&local->lock); + getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtm_tx.snapshot)); + LWLockRelease(&dtm->hashLock); return invisible; } } @@ -266,7 +309,7 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) break; } } - SpinLockRelease(&local->lock); + LWLockRelease(&dtm->hashLock); return PgXidInMVCCSnapshot(xid, snapshot); } @@ -280,44 +323,61 @@ static int dtm_xid_match_fn(const void *key1, const void *key2, Size keysize) return *(TransactionId*)key1 - *(TransactionId*)key2; } -static void DtmTransactionListAppend(DtmTransStatus* ts) +static void DtmTransactionListAppend(DtmTransState* ts) { ts->next = NULL; - *local->trans_list_tail = ts; - local->trans_list_tail = &ts->next; + *dtm->trans_list_tail = ts; + dtm->trans_list_tail = &ts->next; } -static void DtmTransactionListInsertAfter(DtmTransStatus* after, DtmTransStatus* ts) +static void DtmTransactionListInsertAfter(DtmTransState* after, DtmTransState* ts) { ts->next = after->next; after->next = ts; - if (local->trans_list_tail == &after->next) { - local->trans_list_tail = &ts->next; + if (dtm->trans_list_tail == &after->next) { + dtm->trans_list_tail = &ts->next; + } +} + +static void DtmAddSubtransactions(DtmTransState* ts, TransactionId* subxids, int nSubxids) +{ + int i; + for (i = 0; i < nSubxids; i++) { + bool found; + DtmTransState* sts; + Assert(TransactionIdIsValid(subxids[i])); + sts = (DtmTransState*)hash_search(xid2state, &subxids[i], HASH_ENTER, &found); + Assert(!found); + sts->status = ts->status; + sts->csn = ts->csn; + sts->nSubxids = 0; + DtmTransactionListInsertAfter(ts, sts); } } static TransactionId DtmAdjustOldestXid(TransactionId xid) { if (TransactionIdIsValid(xid)) { - DtmTransStatus *ts, *prev = NULL; - timestamp_t cutoff_time = dtm_get_current_time() - DtmVacuumDelay*USEC; - SpinLockAcquire(&local->lock); - ts = (DtmTransStatus*)hash_search(xid2status, &xid, HASH_FIND, NULL); + DtmTransState *ts, *prev = NULL; + + LWLockAcquire(&dtm->hashLock, LW_EXCLSUIVE); + ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { - cutoff_time = ts->cid - DtmVacuumDelay*USEC; - } - for (ts = local->trans_list_head; ts != NULL && ts->cid < cutoff_time; prev = ts, ts = ts->next) { - if (prev != NULL) { - hash_search(xid2status, &prev->xid, HASH_REMOVE, NULL); - } + timestamp_t cutoff_time = ts->csn - DtmVacuumDelay*USEC; + + for (ts = dtm->trans_list_head; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { + if (prev != NULL) { + hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); + } + } } if (prev != NULL) { - local->trans_list_head = prev; - xid = prev->xid; + dtm->trans_list_head = prev; + dtm->minXid = xid = prev->xid; } else { - xid = FirstNormalTransactionId; + xid = dtm->minXid; } - SpinLockRelease(&local->lock); + LWLockRelease(&dtm->hashLock); } return xid; } @@ -332,11 +392,11 @@ static void DtmInitialize() if (!found) { dtm->hashLock = LWLockAssign(); - dtm->xidLock = LWLockAssign(); - dtm->nReservedXids = 0; + dtm->csn = dtm_get_current_time(); dtm->minXid = InvalidTransactionId; dtm->nNodes = MMNodes; dtm->disabledNodeMask = 0; + dtm->pendingTransactions = NULL; pg_atomic_write_u32(&dtm->nReceivers, 0); dtm->initialized = false; BgwPoolInit(&dtm->pool, MMExecutor, MMDatabaseName, MMQueueSize); @@ -346,37 +406,19 @@ static void DtmInitialize() LWLockRelease(AddinShmemInitLock); info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(TransactionId); + info.entrysize = sizeof(DtmTransState); info.hash = dtm_xid_hash_fn; info.match = dtm_xid_match_fn; - xid_in_doubt = ShmemInitHash( - "xid_in_doubt", + xid2state = ShmemInitHash( + "xid2state", DTM_HASH_SIZE, DTM_HASH_SIZE, &info, HASH_ELEM | HASH_FUNCTION | HASH_COMPARE ); - - info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(LocalTransaction); - info.hash = dtm_xid_hash_fn; - info.match = dtm_xid_match_fn; - local_trans = ShmemInitHash( - "local_trans", - DTM_HASH_SIZE, DTM_HASH_SIZE, - &info, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE - ); - MMDoReplication = true; TM = &DtmTM; } -static void -DtmSubXactCallback(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg) -{ - elog(ERROR, "Subtransactions are not currently supported"); -} - static void DtmXactCallback(XactEvent event, void *arg) { @@ -384,7 +426,7 @@ DtmXactCallback(XactEvent event, void *arg) switch (event) { case XACT_EVENT_START: - DtmBeginTransaction(&dtm_tx); + DtmBeginTransaction(&dtm_tx); break; case XACT_EVENT_PRE_COMMIT: DtmPrepareTransaction(&dtm_tx); @@ -399,12 +441,12 @@ void DtmBeginTransaction(DtmCurrentTrans* x) if (!TransactionIdIsValid(x->xid)) { LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); x->xid = GetCurrentTransactionIdIfAny(); - x->csn = INVALID_CSN; x->is_local = false; x->is_distributed = false; x->snapshot = dtm_get_csn(); + x->gtid.xid = InvalidTransactionId; LWLockRelease(dtm->hashLock); - DTM_TRACE((stderr, "DtmLocalBegin: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot)); + DTM_TRACE((stderr, "DtmLocalTransaction: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot)); } } @@ -414,43 +456,50 @@ void DtmBeginTransaction(DtmCurrentTrans* x) */ static void DtmPrepareTransaction(DtmCurrentTrans* x) { - DtmTransStatus* ts; + DtmTransState* ts; Assert(TransactionIdIsValid(x->xid)); LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2status, &x->xid, HASH_ENTER, NULL); - ts->snapshot = x->snapshot; + ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); + ts->snapshot = x->is_local ? x->snapshot : INVALID_CSN; ts->status = TRANSACTION_STATUS_UNKNOWN; - ts->is_local = x->is_local; + ts->csn = dtm_get_csn(); + if (!TransactionIdIsValid(x->gtid.xid)) + { + ts->gtid.xid = xid; + ts->gtid.node = MMNodeId; + } else { + ts->gtid = x->gtid; + } LWLockRelease(dtm->hashLock); } static XidStatus DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { - DtmTransStatus* ts; - GlobalTransactionId gtid = MAKE_GTID(xid); + DtmTransState* ts; csn_t csn; int i; int nSubxids; XidStatus status; - bool ack = ArbiterVoteTransaction(gtid, true); /* wait until transaction at all nodes are prepared */ LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2status, &xid, HASH_FIND, NULL); + ts = hash_search(xid2state, &xid, HASH_FIND, NULL); Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ - ts->status = status = ack ? TRANSACTION_STATUS_IN_PROGRESS : TRANSACTION_STATUS_ABORTED; - ts->csn = dtm_get_cid(); + + /* now transaction is in doubt state */ + ts->status = TRANSACTION_STATUS_IN_PROGRESS; + csn = dtm_get_csn(); + if (csn > ts->csn) { + ts->csn = csn; + } DtmTransactionListAppend(ts); DtmAddSubtransactions(ts, subxids, nsubxids); - LWLockRelease(dtm->hashLock); - csn = ack ? ArbiterGetCSN(gtid, ts->csn) : INVALID_CSN; /* get max CSN */ - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + MMVoteForTransaction(ts); /* wait until transaction at all nodes are prepared */ + csn = ts->csn; if (csn != INVALID_CSN) { - ts->csn = csn; dtm_sync(csn); status = TRANSACTION_STATUS_COMMITTED; } else { - csn = ts->csn; status = TRANSACTION_STATUS_ABORTED; } ts->status = status; @@ -466,11 +515,16 @@ static XidStatus DtmCommitTransaction(TransactionId xid, int nsubxids, Transacti static void DtmAbortTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { int i; - DtmTransStatus* ts; - GlobalTransactionId gtid = MAKE_GTID(xid); + DtmTransState* ts; + + if (!TransactionIdIsValid(dtm_tx.gtid.xid)) + { + dtm_tx.gtid.xid = xid; + dtm_tx.gtid.node = MMNodeId; + } LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2status, &xid, HASH_FIND, NULL); + ts = hash_search(xid2state, &xid, HASH_FIND, NULL); Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ ts->status = TRANSACTION_STATUS_ABORTED; for (i = 0; i < nSubxids; i++) { @@ -480,7 +534,7 @@ static void DtmAbortTransaction(TransactionId xid, int nsubxids, TransactionId * } LWLockRelease(dtm->hashLock); - ArbiterVoteTransaction(gtid, false); + ArbiterVoteTransaction(dtm_tx.gtid, false); } @@ -511,6 +565,20 @@ static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, Transaction PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); } +bool DtmDetectGlobalDeadLock(PGPROC* proc) +{ + elog(WARNING, "Global deadlock?"); + return true; +} + +static void DtmShmemStartup(void) +{ + if (PreviousShmemStartupHook) { + PreviousShmemStartupHook(); + } + DtmInitialize(); +} + /* * *************************************************************************** */ @@ -560,12 +628,12 @@ _PG_init(void) ); DefineCustomIntVariable( - "multimaster.local_xid_reserve", - "Number of XIDs reserved by node for local transactions", + "multimaster.arpiter_port", + "Base value for assigning arbiter ports", NULL, - &DtmLocalXidReserve, - 100, - 1, + &MMAtbiterPort, + 54321, + 0, INT_MAX, PGC_BACKEND, 0, @@ -574,34 +642,6 @@ _PG_init(void) NULL ); - DefineCustomIntVariable( - "multimaster.buffer_size", - "Size of sockhub buffer for connection to DTM daemon, if 0, then direct connection will be used", - NULL, - &DtmBufferSize, - 0, - 0, - INT_MAX, - PGC_BACKEND, - 0, - NULL, - NULL, - NULL - ); - - DefineCustomStringVariable( - "multimaster.arbiters", - "The comma separated host:port pairs where arbiters reside", - NULL, - &Arbiters, - "127.0.0.1:5431", - PGC_BACKEND, // context - 0, // flags, - NULL, // GucStringCheckHook check_hook, - NULL, // GucStringAssignHook assign_hook, - NULL // GucShowHook show_hook - ); - DefineCustomStringVariable( "multimaster.conn_strings", "Multimaster node connection strings separated by commas, i.e. 'replication=database dbname=postgres host=localhost port=5001,replication=database dbname=postgres host=localhost port=5002'", @@ -636,7 +676,7 @@ _PG_init(void) * resources in dtm_shmem_startup(). */ RequestAddinShmemSpace(DTM_SHMEM_SIZE + MMQueueSize); - RequestAddinLWLocks(2); + RequestAddinLWLocks(1); MMNodes = MMStartReceivers(MMConnStrs, MMNodeId); if (MMNodes < 2) { @@ -644,14 +684,7 @@ _PG_init(void) } BgwPoolStart(MMWorkers, MMPoolConstructor); - ArbitersCopy = strdup(Arbiters); - if (DtmBufferSize != 0) - { - ArbiterConfig(Arbiters, Unix_socket_directories); - RegisterBackgroundWorker(&DtmWorker); - } - else - ArbiterConfig(Arbiters, NULL); + MMArbiterInitialize(); /* * Install hooks. @@ -678,24 +711,11 @@ _PG_fini(void) } -static void DtmShmemStartup(void) -{ - if (PreviousShmemStartupHook) { - PreviousShmemStartupHook(); - } - DtmInitialize(); -} /* * *************************************************************************** */ -GlobalTransactionId MMBeginTransaction(void) -{ - dtm_tx.is_distributed = false; - return dtm_tx.snapshot; -} - void MMJoinTransaction(GlonalTransactionId gtid, csn_t snapshot) { LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); @@ -716,26 +736,21 @@ void MMReceiverStarted() } } -bool MMIsLocalTransaction(TransactionId xid) +csn_t MMTransactionSnapshot(TransactionId xid) { TransStatus* ts; - bool is_local = false; + csn_t snapshot = INVALID_CSN; + LWLockAcquire(dtm->hashLock, LW_SHARED); - ts = hash_search(xid2status, &xid, HASH_FIND, NULL); + ts = hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { - is_local = ts->is_local; + snapshot = ts->snapshot; } LWLockRelease(dtm->hashLock); - return is_local; -} -bool MMDetectGlobalDeadLock(PGPROC* proc) -{ - elog(WARNING, "Global deadlock?"); - return true; + return snapshot; } - Datum mm_start_replication(PG_FUNCTION_ARGS) { @@ -926,6 +941,8 @@ static void MMProcessUtility(Node *parsetree, const char *queryString, MMBroadcastUtilityStmt(queryString, false); } } + + static void MMExecutorFinish(QueryDesc *queryDesc) { @@ -956,18 +973,24 @@ static BgwPool* MMPoolConstructor(void) return &dtm->pool; } -static void DtmAddSubtransactions(DtmTransStatus* ts, TransactionId* subxids, int nSubxids) + +void MMVoteForTransaction(DtmTransState* ts) { - int i; - for (i = 0; i < nSubxids; i++) { - bool found; - DtmTransStatus* sts; - Assert(TransactionIdIsValid(subxids[i])); - sts = (DtmTransStatus*)hash_search(xid2status, &subxids[i], HASH_ENTER, &found); - Assert(!found); - sts->status = ts->status; - sts->cid = ts->cid; - sts->nSubxids = 0; - DtmTransactionListInsertAfter(ts, sts); - } + LWLockRelease(&dtm->hashLock); + if (ts->gtid.node == MMNodeId) { + /* I am master: wait responces from replicas */ + while (ts->nVotes+1 != dtm->nNodes) { + WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); + ResetLatch(&MyProc->procLatch); + } + LWLockAcquire(&dtm->hashLock< LW_EXCLUSIVE); + } else { + /* I am replica: firrst notify master... */ + ts->nextPending = dtm->pendingTransactions; + dtm->pendingTransactions = ts; + PGSemaphoreUnlock(&dtm->semapahore); + /* ... and wait reposnse from it */ + WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); + ResetLatch(&MyProc->procLatch); + } } diff --git a/multimaster.h b/multimaster.h index 433347fcac..1db942d13d 100644 --- a/multimaster.h +++ b/multimaster.h @@ -2,19 +2,59 @@ #define __MULTIMASTER_H__ #include "bytebuf.h" +#include "bgwpool.h" #define XTM_TRACE(fmt, ...) /* #define XTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ #define XTM_INFO(fmt, ...) -typedef int64 GlobalTransactionId; -typedef int64 csn_t; +typedef uint64 csn_t; +#define INVALID_CSN ((csn_t)-1) +typedef struct +{ + int node; + TransactionId xid; +} GlobalTransactionId; + +typedef struct DtmTransState +{ + TransactionId xid; + GlobalTransactionId gtid; + XidStatus status; + csn_t csn; /* commit serial number */ + csn_t snapshot; /* transaction snapshot, or 0 for local transactions */ + int nVotes; + int pid; + struct DtmTransState* nextPending; + struct DtmTransState* next; +} DtmTransState; + +typedef struct +{ + LWLockId hashLock; + TransactionId minXid; /* XID of oldest transaction visible by any active transaction (local or global) */ + int64 disabledNodeMask; + int nNodes; + pg_atomic_uint32 nReceivers; + bool initialized; + csn_t csn; + DtmTransState* pendingTransactions; + BgwPool pool; + Latch latch; +} DtmState; + +extern char* MMConnStrs; +extern int MMNodeId +extern int MMArbiterPort; + +extern DtmState* dtm; + +extern void MMArbiterInitialize(); extern int MMStartReceivers(char* nodes, int node_id); extern GlobalTransactionId MMBeginTransaction(void); -extern GlobalTransactionId MMTransactionSnapshot(TransactionId xid); +extern csn_t MMTransactionSnapshot(TransactionId xid); extern void MMJoinTransaction(GlobalTransactionId gtid, csn_t snapshot); -extern bool MMIsLocalTransaction(TransactionId xid); extern void MMReceiverStarted(void); extern void MMExecute(void* work, int size); extern void MMExecutor(int id, void* work, size_t size); diff --git a/pglogical_proto.c b/pglogical_proto.c index 75fca5e6d7..472b52fe4b 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -103,12 +103,14 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, ReorderBufferTXN *txn) { PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; - if (MMIsLocalTransaction(txn->xid)) { + csn_t csn = MMTransactionSnapshot(txn->xid); + if (csn == INVALID_CSN) { mm->isLocal = true; } else { mm->isLocal = false; pq_sendbyte(out, 'B'); /* BEGIN */ - pq_sendint64(out, MMTransactionSnapshot(txn->xid)); + pq_sendint64(out, MMGenerateGTID(txn->xid)); + pq_sendint64(out, csn); } } @@ -122,7 +124,6 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; if (!mm->isLocal) { pq_sendbyte(out, 'C'); /* sending COMMIT */ - pq_sendint64(out, MyProcPid, txn->xid); } } From bf78f0b612e6bfe5ff0351cf4c7c0092ef7a365f Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 9 Feb 2016 18:04:20 +0300 Subject: [PATCH 0246/1139] Add arbiter.c --- arbiter.c | 237 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 arbiter.c diff --git a/arbiter.c b/arbiter.c new file mode 100644 index 0000000000..a130656fa3 --- /dev/null +++ b/arbiter.c @@ -0,0 +1,237 @@ +/* + * multimaster.c + * + * Multimaster based on logical replication + * + */ + +#include +#include +#include + +#include "postgres.h" +#include "fmgr.h" +#include "miscadmin.h" +#include "libpq-fe.h" +#include "postmaster/postmaster.h" +#include "postmaster/bgworker.h" +#include "storage/s_lock.h" +#include "storage/spin.h" +#include "storage/lmgr.h" +#include "storage/shmem.h" +#include "storage/ipc.h" +#include "access/xlogdefs.h" +#include "access/xact.h" +#include "access/xtm.h" +#include "access/transam.h" +#include "access/subtrans.h" +#include "access/commit_ts.h" +#include "access/xlog.h" +#include "storage/proc.h" +#include "storage/procarray.h" +#include "executor/executor.h" +#include "access/twophase.h" +#include "utils/guc.h" +#include "utils/hsearch.h" +#include "utils/tqual.h" +#include "utils/array.h" +#include "utils/builtins.h" +#include "utils/memutils.h" +#include "commands/dbcommands.h" +#include "miscadmin.h" +#include "postmaster/autovacuum.h" +#include "storage/pmsignal.h" +#include "storage/proc.h" +#include "utils/syscache.h" +#include "replication/walsender.h" +#include "replication/slot.h" +#include "port/atomics.h" +#include "tcop/utility.h" + +#include "multimaster.h" + +#define MAX_CONNECT_ATTEMPTS 10 +#define TX_BUFFER_SIZE 1024 + +typedef struct +{ + TransactionId xid; + csn_t csn; +} DtmCommitMessage; + +typedef struct +{ + DtmCOmmitMessage buf[TX_BUFFER_SIZE]; + int used; +} DtmTxBuffer; + +static int* sockets; +static DtmCommitMessage** txBuffers; + +static BackgroundWorker DtmSender = { + "mm-sender", + 0, /* do not need connection to the database */ + BgWorkerStart_PostmasterStart, + 1, /* restrart in one second (is it possible to restort immediately?) */ + DtmTransSender +}; + +static BackgroundWorker DtmRecevier = { + "mm-receiver", + 0, /* do not need connection to the database */ + BgWorkerStart_PostmasterStart, + 1, /* restrart in one second (is it possible to restort immediately?) */ + DtmTransReceiver +}; + +void MMArbiterInitialize() +{ + RegisterBackgroundWorker(&DtmSender); + RegisterBackgroundWorker(&DtmRecevier); +} + + +static int resolve_host_by_name(const char *hostname, unsigned* addrs, unsigned* n_addrs) +{ + struct sockaddr_in sin; + struct hostent* hp; + unsigned i; + + sin.sin_addr.s_addr = inet_addr(hostname); + if (sin.sin_addr.s_addr != INADDR_NONE) { + memcpy(&addrs[0], &sin.sin_addr.s_addr, sizeof(sin.sin_addr.s_addr)); + *n_addrs = 1; + return 1; + } + + hp = gethostbyname(hostname); + if (hp == NULL || hp->h_addrtype != AF_INET) { + return 0; + } + for (i = 0; hp->h_addr_list[i] != NULL && i < *n_addrs; i++) { + memcpy(&addrs[i], hp->h_addr_list[i], sizeof(addrs[i])); + } + *n_addrs = i; + return 1; +} + +static int connectSocket(char const* host, int port) +{ + struct sockaddr_in sock_inet; + unsigned addrs[128]; + unsigned i, n_addrs = sizeof(addrs) / sizeof(addrs[0]); + int max_attempts = MAX_CONNECT_ATTEMPTS; + int sd; + + sock_inet.sin_family = AF_INET; + sock_inet.sin_port = htons(port); + + if (!resolve_host_by_name(host, addrs, &n_addrs)) { + elog(ERROR, "Failed to resolve host '%s' by name", host); + } + sd = socket(AF_INET, SOCK_STREAM, 0); + if (sd < 0) { + elog(ERROR, "Failed to create socket: %d", errno); + } + while (1) { + int rc = -1; + for (i = 0; i < n_addrs; ++i) { + memcpy(&sock_inet.sin_addr, &addrs[i], sizeof sock_inet.sin_addr); + do { + rc = connect(sd, (struct sockaddr*)&sock_inet, sizeof(sock_inet)); + } while (rc < 0 && errno == EINTR); + + if (rc >= 0 || errno == EINPROGRESS) { + break; + } + } + if (rc < 0) { + if ((errno != ENOENT && errno != ECONNREFUSED && errno != EINPROGRESS) || max_attempts == 0) { + elog(ERROR, "Sockhub failed to connect to %s:%d: %d", host, port, errno); + } else { + max_attempts -= 1; + sleep(1); + } + continue; + } else { + int optval = 1; + setsockopt(shub->output, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)); + return sd; + } + } +} + +static void openConnections() +{ + int nNodes = dtm->nNodes; + int i; + char* connStr = pstrdup(MMConnStrs); + + sockets = (int*)palloc(sizeof(int)*nNodes); + + for (i = 0; i < nNodes; i++) { + char* host = strstr(connStr, "host="); + char* end; + if (host == NULL) { + elog(ERROR, "Invalid connection string: '%s'", MMConnStrs); + } + for (end = host+5; *end != ' ' && *end != ',' && end != '\0'; end++); + *end = '\0'; + connStr = end + 1; + sockets[i] = i+1 != MMNodeId ? connectSocket(host, MMArbiterPort + i) : -1; + } +} + +static void acceptConnections() +{ + int nNodes = dtm->nNodes-1; + sockaddr_in sock_inet; + int i; + int sd; + int on = 1; + + sockets = (int*)palloc(sizeof(int)*nNodes); + + sock_inet.sin_family = AF_INET; + sock_inet.sin_addr.s_addr = htonl(INADDR_ANY); + sock_inet.sin_port = htons(MMArbiterPort + MMNodeId); + + sd = socket(u.sock.sa_family, SOCK_STREAM, 0); + if (sd < 0) { + elog(ERROR, "Failed to create socket: %d", errno); + } + setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on); + + if (bind(fd, (sockaddr*)&sock_init, nNodes-1) < 0) { + elog(ERROR, "Failed to bind socket: %d", errno); + } + + for (i = 0; i < nNodes-1; i++) { + sockets[i] = accept(sd, NULL, NULL); + if (sockets[i] < 0) { + elog(ERROR, "Failed to accept socket: %d", errno); + } + } +} + +static void DtmTransSender(Datum arg) +{ + txBuffer = (DtmCommitMessage*) + openConnections(); + + while (true) { + DtmTransState* ts; + PGSemaphoreLock(&dtm->semphore); + + LWLockAcquire(&dtm->hashLock, LW_EXCLUSIVE); + for (ts = dtm->pendingTransactions; ts != NULL; ts = ts->nextPending) { + int node = ts->gtid.node; + Assert(node != MMNodeId); + sockets +} + +static void DtmTransReceiver(Datum arg) +{ + acceptConnections(); +} + From cd6b6d2d173ee8bea8439a31cfd2b0b8ec97f363 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 9 Feb 2016 20:27:55 +0300 Subject: [PATCH 0247/1139] Update MMTS --- arbiter.c | 34 ++++++++++++++++++++++++++++------ multimaster.c | 7 +++++-- multimaster.h | 2 ++ 3 files changed, 35 insertions(+), 8 deletions(-) diff --git a/arbiter.c b/arbiter.c index a130656fa3..3a9d9c5a57 100644 --- a/arbiter.c +++ b/arbiter.c @@ -61,12 +61,12 @@ typedef struct typedef struct { - DtmCOmmitMessage buf[TX_BUFFER_SIZE]; + DtmCommitMessage data[TX_BUFFER_SIZE]; int used; } DtmTxBuffer; static int* sockets; -static DtmCommitMessage** txBuffers; +static DtmTxBuffer* txBuffers; static BackgroundWorker DtmSender = { "mm-sender", @@ -216,18 +216,40 @@ static void acceptConnections() static void DtmTransSender(Datum arg) { - txBuffer = (DtmCommitMessage*) + int nNodes = dtm->nNodes; + int i; + DtmCommitMessage* txBuffer = (DtmCommitMessage*)palloc(sizeof(DtmTxBuffer)*(nNodes)); + openConnections(); + for (i = 0; i < nNodes; i++) { + txBuffer[i].used = 0; + } + while (true) { - DtmTransState* ts; + DtmTransState* ts; PGSemaphoreLock(&dtm->semphore); - LWLockAcquire(&dtm->hashLock, LW_EXCLUSIVE); + SpinLockAcquire(&dtm->spinlock); + ts = dtm->pendingTransactions; + dtm->pendingTransactions = NULL; + SpinLockRelease(&dtm->spinlock); + for (ts = dtm->pendingTransactions; ts != NULL; ts = ts->nextPending) { int node = ts->gtid.node; Assert(node != MMNodeId); - sockets + node -= 1; + if (txBuffer[node].used == TX_BUFFER_SIZE) { + WriteSocket(sockets[node], txBuffer[node].data, txBuffer[node].used*sizeof(DtmCommitRequest)); + txBuffer[node].used = 0; + } + txBuffer[node].data[txBuffer[node].used].xid = ts->xid; + txBuffer[node].data[txBuffer[node].used].csn = ts->csn; + txBuffer[node].used += 1; + } + dtm->pendingTransactions = NULL; + + } } static void DtmTransReceiver(Datum arg) diff --git a/multimaster.c b/multimaster.c index 93057cbc2b..d3bce6f015 100644 --- a/multimaster.c +++ b/multimaster.c @@ -983,14 +983,17 @@ void MMVoteForTransaction(DtmTransState* ts) WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); } - LWLockAcquire(&dtm->hashLock< LW_EXCLUSIVE); } else { - /* I am replica: firrst notify master... */ + /* I am replica: first notify master... */ + SpinLockAcquire(&dtm->spinlock); ts->nextPending = dtm->pendingTransactions; dtm->pendingTransactions = ts; + SpinLockRelease(&dtm->spinlock); + PGSemaphoreUnlock(&dtm->semapahore); /* ... and wait reposnse from it */ WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); } + LWLockAcquire(&dtm->hashLock< LW_EXCLUSIVE); } diff --git a/multimaster.h b/multimaster.h index 1db942d13d..1e64d80776 100644 --- a/multimaster.h +++ b/multimaster.h @@ -32,6 +32,8 @@ typedef struct DtmTransState typedef struct { + volatile slock_t spinlock; + PGSemaphoreData semaphore; LWLockId hashLock; TransactionId minXid; /* XID of oldest transaction visible by any active transaction (local or global) */ int64 disabledNodeMask; From 1b5946d5c721259378e3d7f21868ffcd06dbd16a Mon Sep 17 00:00:00 2001 From: knizhnik Date: Tue, 9 Feb 2016 23:58:03 +0300 Subject: [PATCH 0248/1139] Continue work on MMTS --- arbiter.c | 170 ++++++++++++++++++++++++++++++++++++++++++++------ multimaster.c | 34 ++++++---- multimaster.h | 1 + 3 files changed, 172 insertions(+), 33 deletions(-) diff --git a/arbiter.c b/arbiter.c index 3a9d9c5a57..78a7e8cc60 100644 --- a/arbiter.c +++ b/arbiter.c @@ -51,7 +51,8 @@ #include "multimaster.h" #define MAX_CONNECT_ATTEMPTS 10 -#define TX_BUFFER_SIZE 1024 +#define BUFFER_SIZE 1024 +#define BUFFER_SIZE 1024 typedef struct { @@ -61,12 +62,11 @@ typedef struct typedef struct { - DtmCommitMessage data[TX_BUFFER_SIZE]; + DtmCommitMessage data[BUFFER_SIZE]; int used; -} DtmTxBuffer; +} DtmBuffer; static int* sockets; -static DtmTxBuffer* txBuffers; static BackgroundWorker DtmSender = { "mm-sender", @@ -115,6 +115,34 @@ static int resolve_host_by_name(const char *hostname, unsigned* addrs, unsigned* return 1; } +#ifdef USE_EPOLL +static int epollfd; +#else +static int max_fd; +static fd_set inset; +#endif + +inline void registerSocket(int fd, int i) +{ +#ifdef USE_EPOLL + struct epoll_event ev; + ev.events = EPOLLIN; + ev.data.u32 = i; + if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) < 0) { + char buf[ERR_BUF_SIZE]; + sprintf(buf, "Failed to add socket %d to epoll set", fd); + shub->params->error_handler(buf, SHUB_FATAL_ERROR); + } +#else + FD_SET(fd, &inset); + if (fd > max_fd) { + max_fd = fd; + } +#endif +} + + + static int connectSocket(char const* host, int port) { struct sockaddr_in sock_inet; @@ -206,20 +234,47 @@ static void acceptConnections() elog(ERROR, "Failed to bind socket: %d", errno); } - for (i = 0; i < nNodes-1; i++) { - sockets[i] = accept(sd, NULL, NULL); - if (sockets[i] < 0) { + for (i = 0; i < nNodes; i++) { + int fd = accept(sd, NULL, NULL); + if (fd < 0) { elog(ERROR, "Failed to accept socket: %d", errno); } + registerSocket(fd, i); + sockets[i] = fd; } } +static void WriteSocket(int sd, void const* buf, int size) +{ + char* src = (char*)buf; + while (size != 0) { + int n = send(sd, src, size, 0); + if (n <= 0) { + return 0; + } + size -= n; + src += n; + } +} + +static int ReadSocket(int sd, void* buf, int buf_size) +{ + int rc = recv(sd, buf, buf_size, 0); + if (rc <= 0) { + elog(ERROR, "Arbiter failed to read socket: %d", rc); + } + return rc; +} + + static void DtmTransSender(Datum arg) { int nNodes = dtm->nNodes; int i; - DtmCommitMessage* txBuffer = (DtmCommitMessage*)palloc(sizeof(DtmTxBuffer)*(nNodes)); + DtmTxBuffer* txBuffer = (DtmTxBuffer*)palloc(sizeof(DtmTxBuffer)*nNodes); + sockets = (int*)palloc(sizeof(int)*nNodes); + openConnections(); for (i = 0; i < nNodes; i++) { @@ -229,31 +284,106 @@ static void DtmTransSender(Datum arg) while (true) { DtmTransState* ts; PGSemaphoreLock(&dtm->semphore); + CHECK_FOR_INTERRUPTS(); SpinLockAcquire(&dtm->spinlock); ts = dtm->pendingTransactions; dtm->pendingTransactions = NULL; SpinLockRelease(&dtm->spinlock); - for (ts = dtm->pendingTransactions; ts != NULL; ts = ts->nextPending) { - int node = ts->gtid.node; - Assert(node != MMNodeId); - node -= 1; - if (txBuffer[node].used == TX_BUFFER_SIZE) { - WriteSocket(sockets[node], txBuffer[node].data, txBuffer[node].used*sizeof(DtmCommitRequest)); - txBuffer[node].used = 0; + for (; ts != NULL; ts = ts->nextPending) { + i = ts->gtid.node-1; + Assert(i != MMNodeId); + if (txBuffer[i].used == BUFFER_SIZE) { + WriteSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitRequest)); + txBuffer[i].used = 0; } - txBuffer[node].data[txBuffer[node].used].xid = ts->xid; - txBuffer[node].data[txBuffer[node].used].csn = ts->csn; - txBuffer[node].used += 1; + txBuffer[i].data[txBuffer[i].used].xid = ts->xid; + txBuffer[i].data[txBuffer[i].used].csn = ts->csn; + txBuffer[i].used += 1; } - dtm->pendingTransactions = NULL; - + for (i = 0; i < nNodes; i++) { + if (txBuffer[i].used != 0) { + WriteSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitRequest)); + txBuffer[i].used = 0; + } + } } } static void DtmTransReceiver(Datum arg) { + int nNodes = dtm->nNodes-1; + int i, j, rc; + int rxBufPos = 0; + DtmBuffer* rxBuffer = (DtmBuffer*)palloc(sizeof(DtmBuffer)*nNodes); + HTAB* xid2state; + +#ifdef USE_EPOLL + struct epoll_event* events = (struct epoll_event*)palloc(SIZEOF(struct epoll_event)*nNodes); + epollfd = epoll_create(nNodes); +#else + FD_ZERO(&inset); + max_fd = 0; +#endif + acceptConnections(); + xid2state = MMCreateHash(); + + for (i = 0; i < nNodes; i++) { + txBuffer[i].used = 0; + } + + while (true) { +#ifdef USE_EPOLL + rc = epoll_wait(epollfd, events, MAX_EVENTS, shub->in_buffer_used == 0 ? -1 : shub->params->delay); + if (rc < 0) { + elog(ERROR, "epoll failed: %d", errno); + } + for (j = 0; j < rc; j++) { + i = events[j].data.u32; + if (events[j].events & EPOLLERR) { + struct sockaddr_in insock; + socklen_t len = sizeof(insock); + getpeername(fd, (struct sockaddr*)&insock, &len); + elog(WARNING, "Loose connection with %s", inet_ntoa(insock.sin_addr_)); + epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL); + } + else if (events[j].events & EPOLLIN) +#else + fd_set events; + events = inset; + rc = select(max_fd+1, &events, NULL, NULL, NULL); + if (rc < 0) { + elog(ERROR, "select failed: %d", errno); + } + for (i = 0; i < nNodes; i++) { + if (FD_ISSET(sockets[i], &events)) +#endif + { + int nResponses; + rxBuffer[i].used += ReadSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, RX_BUFFER_SIZE-rxBufPos); + nResponses = rxBuffer[i].used/sizeof(DtmCommitRequest); + + LWLockAcquire(&dtm->hashLock, LW_SHARED); + + for (j = 0; j < nResponses; j++) { + DtmCommitRequest* req = &rxBuffer[i].data[j]; + DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &req->xid, HASH_FIND, NULL); + Assert(ts != NULL); + if (req->csn > ts->csn) { + ts->csn = req->csn; + } + if (ts->nVotes == dtm->nNodes-1) { + SetLatch(&ProcGlobal->allProcs[ts->pid].procLatch); + } + } + if (rxBuffer[i].used != nResponses*sizeof(DtmCommitRequest)) { + rxBuffer[i].used -= nResponses*sizeof(DtmCommitRequest); + memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(DtmCommitRequest), rxBuffer[i].used); + } + } + } + } } diff --git a/multimaster.c b/multimaster.c index d3bce6f015..9048bf3ad7 100644 --- a/multimaster.c +++ b/multimaster.c @@ -385,7 +385,6 @@ static TransactionId DtmAdjustOldestXid(TransactionId xid) static void DtmInitialize() { bool found; - static HASHCTL info; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); dtm = ShmemInitStruct("dtm", sizeof(DtmState), &found); @@ -403,18 +402,8 @@ static void DtmInitialize() RegisterXactCallback(DtmXactCallback, NULL); RegisterSubXactCallback(DtmSubXactCallback, NULL); } + xid2state = MMCreateHash(); LWLockRelease(AddinShmemInitLock); - - info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(DtmTransState); - info.hash = dtm_xid_hash_fn; - info.match = dtm_xid_match_fn; - xid2state = ShmemInitHash( - "xid2state", - DTM_HASH_SIZE, DTM_HASH_SIZE, - &info, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE - ); MMDoReplication = true; TM = &DtmTM; } @@ -987,13 +976,32 @@ void MMVoteForTransaction(DtmTransState* ts) /* I am replica: first notify master... */ SpinLockAcquire(&dtm->spinlock); ts->nextPending = dtm->pendingTransactions; + ts->pid = MyProc->pgprocno; dtm->pendingTransactions = ts; SpinLockRelease(&dtm->spinlock); PGSemaphoreUnlock(&dtm->semapahore); - /* ... and wait reposnse from it */ + /* ... and wait response from it */ WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); } LWLockAcquire(&dtm->hashLock< LW_EXCLUSIVE); } + +HTAB* MMCreateHash(); +{ + static HASHCTL info; + TAB* htab; + info.keysize = sizeof(TransactionId); + info.entrysize = sizeof(DtmTransState); + info.hash = dtm_xid_hash_fn; + info.match = dtm_xid_match_fn; + htab = ShmemInitHash( + "xid2state", + DTM_HASH_SIZE, DTM_HASH_SIZE, + &info, + HASH_ELEM | HASH_FUNCTION | HASH_COMPARE + ); + return htab; +} + diff --git a/multimaster.h b/multimaster.h index 1e64d80776..e8e70c2f24 100644 --- a/multimaster.h +++ b/multimaster.h @@ -60,6 +60,7 @@ extern void MMJoinTransaction(GlobalTransactionId gtid, csn_t snapshot); extern void MMReceiverStarted(void); extern void MMExecute(void* work, int size); extern void MMExecutor(int id, void* work, size_t size); +extern HTAB* MMCreateHash(); extern char* MMDatabaseName; From ca55e19a1eb59989bc305ef76d854a05a6016802 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 10 Feb 2016 19:17:57 +0300 Subject: [PATCH 0249/1139] Add comments --- Makefile | 11 +- arbiter.c | 178 ++++++++++++++--------- multimaster.c | 337 ++++++++++++++++++++++++------------------- multimaster.h | 85 ++++++----- pglogical_apply.c | 11 +- pglogical_proto.c | 4 +- pglogical_receiver.c | 3 + tests/dtmbench | Bin 451917 -> 469438 bytes 8 files changed, 364 insertions(+), 265 deletions(-) diff --git a/Makefile b/Makefile index ea66e1225f..eaca18614a 100644 --- a/Makefile +++ b/Makefile @@ -1,8 +1,5 @@ MODULE_big = multimaster -OBJS = multimaster.o ../arbiter/lib/libarbiter.a ../arbiter/sockhub/libsockhub.a bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o -#OBJS = multimaster.o pglogical_receiver.o decoder_raw.o libdtm.o bytebuf.o bgwpool.o sockhub/sockhub.o - -override CPPFLAGS += -I../arbiter/api -I../arbiter/sockhub +OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o EXTENSION = multimaster DATA = multimaster--1.0.sql @@ -11,12 +8,6 @@ DATA = multimaster--1.0.sql all: multimaster.o multimaster.so -../arbiter/sockhub/libsockhub.a: - make -C ../arbiter/sockhub - -../arbiter/lib/libarbiter.a: - make -C ../arbiter - PG_CPPFLAGS = -I$(libpq_srcdir) -DUSE_PGLOGICAL_OUTPUT SHLIB_LINK = $(libpq) diff --git a/arbiter.c b/arbiter.c index 78a7e8cc60..16e1be6b4a 100644 --- a/arbiter.c +++ b/arbiter.c @@ -7,12 +7,19 @@ #include #include +#include +#include +#include +#include +#include +#include +#include +#include #include #include "postgres.h" #include "fmgr.h" #include "miscadmin.h" -#include "libpq-fe.h" #include "postmaster/postmaster.h" #include "postmaster/bgworker.h" #include "storage/s_lock.h" @@ -48,29 +55,50 @@ #include "port/atomics.h" #include "tcop/utility.h" +#ifndef USE_EPOLL +#ifdef __linux__ +#define USE_EPOLL 1 +#else +#define USE_EPOLL 0 +#endif +#endif + +#ifdef USE_EPOLL +#include +#else +#include +#endif + + #include "multimaster.h" #define MAX_CONNECT_ATTEMPTS 10 -#define BUFFER_SIZE 1024 -#define BUFFER_SIZE 1024 +#define MAX_ROUTES 16 +#define BUFFER_SIZE 1024 typedef struct { - TransactionId xid; - csn_t csn; + TransactionId dxid; /* Transaction ID at destination node */ + TransactionId sxid; /* Transaction IO at sender node */ + int node; /* Sender node ID */ + csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ } DtmCommitMessage; typedef struct { - DtmCommitMessage data[BUFFER_SIZE]; int used; + DtmCommitMessage data[BUFFER_SIZE]; } DtmBuffer; static int* sockets; +static DtmState* ds; + +static void DtmTransSender(Datum arg); +static void DtmTransReceiver(Datum arg); static BackgroundWorker DtmSender = { "mm-sender", - 0, /* do not need connection to the database */ + BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_PostmasterStart, 1, /* restrart in one second (is it possible to restort immediately?) */ DtmTransSender @@ -78,19 +106,18 @@ static BackgroundWorker DtmSender = { static BackgroundWorker DtmRecevier = { "mm-receiver", - 0, /* do not need connection to the database */ + BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_PostmasterStart, 1, /* restrart in one second (is it possible to restort immediately?) */ DtmTransReceiver }; -void MMArbiterInitialize() +void MMArbiterInitialize(void) { RegisterBackgroundWorker(&DtmSender); RegisterBackgroundWorker(&DtmRecevier); } - static int resolve_host_by_name(const char *hostname, unsigned* addrs, unsigned* n_addrs) { struct sockaddr_in sin; @@ -115,23 +142,21 @@ static int resolve_host_by_name(const char *hostname, unsigned* addrs, unsigned* return 1; } -#ifdef USE_EPOLL +#if USE_EPOLL static int epollfd; #else static int max_fd; static fd_set inset; #endif -inline void registerSocket(int fd, int i) +static void registerSocket(int fd, int i) { -#ifdef USE_EPOLL +#if USE_EPOLL struct epoll_event ev; ev.events = EPOLLIN; ev.data.u32 = i; if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) < 0) { - char buf[ERR_BUF_SIZE]; - sprintf(buf, "Failed to add socket %d to epoll set", fd); - shub->params->error_handler(buf, SHUB_FATAL_ERROR); + elog(ERROR, "Failed to add socket to epoll set: %d", errno); } #else FD_SET(fd, &inset); @@ -146,7 +171,7 @@ inline void registerSocket(int fd, int i) static int connectSocket(char const* host, int port) { struct sockaddr_in sock_inet; - unsigned addrs[128]; + unsigned addrs[MAX_ROUTES]; unsigned i, n_addrs = sizeof(addrs) / sizeof(addrs[0]); int max_attempts = MAX_CONNECT_ATTEMPTS; int sd; @@ -183,7 +208,7 @@ static int connectSocket(char const* host, int port) continue; } else { int optval = 1; - setsockopt(shub->output, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)); + setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)); return sd; } } @@ -191,7 +216,7 @@ static int connectSocket(char const* host, int port) static void openConnections() { - int nNodes = dtm->nNodes; + int nNodes = ds->nNodes; int i; char* connStr = pstrdup(MMConnStrs); @@ -212,11 +237,11 @@ static void openConnections() static void acceptConnections() { - int nNodes = dtm->nNodes-1; - sockaddr_in sock_inet; + struct sockaddr_in sock_inet; int i; int sd; int on = 1; + int nNodes = ds->nNodes-1; sockets = (int*)palloc(sizeof(int)*nNodes); @@ -224,13 +249,13 @@ static void acceptConnections() sock_inet.sin_addr.s_addr = htonl(INADDR_ANY); sock_inet.sin_port = htons(MMArbiterPort + MMNodeId); - sd = socket(u.sock.sa_family, SOCK_STREAM, 0); + sd = socket(sock_inet.sin_family, SOCK_STREAM, 0); if (sd < 0) { elog(ERROR, "Failed to create socket: %d", errno); } setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on); - if (bind(fd, (sockaddr*)&sock_init, nNodes-1) < 0) { + if (bind(sd, (struct sockaddr*)&sock_inet, nNodes-1) < 0) { elog(ERROR, "Failed to bind socket: %d", errno); } @@ -242,22 +267,23 @@ static void acceptConnections() registerSocket(fd, i); sockets[i] = fd; } + close(sd); } -static void WriteSocket(int sd, void const* buf, int size) +static void writeSocket(int sd, void const* buf, int size) { char* src = (char*)buf; while (size != 0) { int n = send(sd, src, size, 0); if (n <= 0) { - return 0; + elog(ERROR, "Write socket failed: %d", errno); } size -= n; src += n; } } -static int ReadSocket(int sd, void* buf, int buf_size) +static int readSocket(int sd, void* buf, int buf_size) { int rc = recv(sd, buf, buf_size, 0); if (rc <= 0) { @@ -269,11 +295,12 @@ static int ReadSocket(int sd, void* buf, int buf_size) static void DtmTransSender(Datum arg) { - int nNodes = dtm->nNodes; + int nNodes = MMNodes; int i; - DtmTxBuffer* txBuffer = (DtmTxBuffer*)palloc(sizeof(DtmTxBuffer)*nNodes); + DtmBuffer* txBuffer = (DtmBuffer*)palloc(sizeof(DtmBuffer)*nNodes); sockets = (int*)palloc(sizeof(int)*nNodes); + ds = MMGetState(); openConnections(); @@ -283,28 +310,45 @@ static void DtmTransSender(Datum arg) while (true) { DtmTransState* ts; - PGSemaphoreLock(&dtm->semphore); + PGSemaphoreLock(&ds->votingSemaphore); CHECK_FOR_INTERRUPTS(); - SpinLockAcquire(&dtm->spinlock); - ts = dtm->pendingTransactions; - dtm->pendingTransactions = NULL; - SpinLockRelease(&dtm->spinlock); - - for (; ts != NULL; ts = ts->nextPending) { - i = ts->gtid.node-1; - Assert(i != MMNodeId); - if (txBuffer[i].used == BUFFER_SIZE) { - WriteSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitRequest)); - txBuffer[i].used = 0; + SpinLockAcquire(&ds->votingSpinlock); + ts = ds->votingTransactions; + ds->votingTransactions = NULL; + SpinLockRelease(&ds->votingSpinlock); + + for (; ts != NULL; ts = ts->nextVoting) { + if (ts->gtid.node == MMNodeId) { + /* Coordinator is broadcasting confirmations to replicas */ + for (i = 0; i < nNodes; i++) { + if (TransactionIdIsValid(ts->xids[i])) { + if (txBuffer[i].used == BUFFER_SIZE) { + writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); + txBuffer[i].used = 0; + } + txBuffer[i].data[txBuffer[i].used].dxid = ts->xids[i]; + txBuffer[i].data[txBuffer[i].used].csn = ts->csn; + txBuffer[i].used += 1; + } + } + } else { + /* Replica is notifying master */ + i = ts->gtid.node-1; + if (txBuffer[i].used == BUFFER_SIZE) { + writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); + txBuffer[i].used = 0; + } + txBuffer[i].data[txBuffer[i].used].dxid = ts->gtid.xid; + txBuffer[i].data[txBuffer[i].used].sxid = ts->xid; + txBuffer[i].data[txBuffer[i].used].node = MMNodeId; + txBuffer[i].data[txBuffer[i].used].csn = ts->csn; + txBuffer[i].used += 1; } - txBuffer[i].data[txBuffer[i].used].xid = ts->xid; - txBuffer[i].data[txBuffer[i].used].csn = ts->csn; - txBuffer[i].used += 1; } for (i = 0; i < nNodes; i++) { if (txBuffer[i].used != 0) { - WriteSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitRequest)); + writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); txBuffer[i].used = 0; } } @@ -313,30 +357,32 @@ static void DtmTransSender(Datum arg) static void DtmTransReceiver(Datum arg) { - int nNodes = dtm->nNodes-1; + int nNodes = MMNodes-1; int i, j, rc; int rxBufPos = 0; DtmBuffer* rxBuffer = (DtmBuffer*)palloc(sizeof(DtmBuffer)*nNodes); HTAB* xid2state; -#ifdef USE_EPOLL - struct epoll_event* events = (struct epoll_event*)palloc(SIZEOF(struct epoll_event)*nNodes); +#if USE_EPOLL + struct epoll_event* events = (struct epoll_event*)palloc(sizeof(struct epoll_event)*nNodes); epollfd = epoll_create(nNodes); #else FD_ZERO(&inset); max_fd = 0; #endif + ds = MMGetState(); + acceptConnections(); xid2state = MMCreateHash(); for (i = 0; i < nNodes; i++) { - txBuffer[i].used = 0; + rxBuffer[i].used = 0; } while (true) { -#ifdef USE_EPOLL - rc = epoll_wait(epollfd, events, MAX_EVENTS, shub->in_buffer_used == 0 ? -1 : shub->params->delay); +#if USE_EPOLL + rc = epoll_wait(epollfd, events, nNodes, -1); if (rc < 0) { elog(ERROR, "epoll failed: %d", errno); } @@ -345,9 +391,9 @@ static void DtmTransReceiver(Datum arg) if (events[j].events & EPOLLERR) { struct sockaddr_in insock; socklen_t len = sizeof(insock); - getpeername(fd, (struct sockaddr*)&insock, &len); - elog(WARNING, "Loose connection with %s", inet_ntoa(insock.sin_addr_)); - epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL); + getpeername(sockets[i], (struct sockaddr*)&insock, &len); + elog(WARNING, "Loose connection with %s", inet_ntoa(insock.sin_addr)); + epoll_ctl(epollfd, EPOLL_CTL_DEL, sockets[i], NULL); } else if (events[j].events & EPOLLIN) #else @@ -362,25 +408,27 @@ static void DtmTransReceiver(Datum arg) #endif { int nResponses; - rxBuffer[i].used += ReadSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, RX_BUFFER_SIZE-rxBufPos); - nResponses = rxBuffer[i].used/sizeof(DtmCommitRequest); + rxBuffer[i].used += readSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBufPos); + nResponses = rxBuffer[i].used/sizeof(DtmCommitMessage); - LWLockAcquire(&dtm->hashLock, LW_SHARED); + LWLockAcquire(ds->hashLock, LW_SHARED); for (j = 0; j < nResponses; j++) { - DtmCommitRequest* req = &rxBuffer[i].data[j]; - DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &req->xid, HASH_FIND, NULL); + DtmCommitMessage* msg = &rxBuffer[i].data[j]; + DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); - if (req->csn > ts->csn) { - ts->csn = req->csn; + if (msg->csn > ts->csn) { + ts->csn = msg->csn; } - if (ts->nVotes == dtm->nNodes-1) { - SetLatch(&ProcGlobal->allProcs[ts->pid].procLatch); + Assert((unsigned)(msg->node-1) <= (unsigned)nNodes); + ts->xids[msg->node-1] = msg->sxid; + if (++ts->nVotes == ds->nNodes) { + SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } } - if (rxBuffer[i].used != nResponses*sizeof(DtmCommitRequest)) { - rxBuffer[i].used -= nResponses*sizeof(DtmCommitRequest); - memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(DtmCommitRequest), rxBuffer[i].used); + rxBuffer[i].used -= nResponses*sizeof(DtmCommitMessage); + if (rxBuffer[i].used != 0) { + memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(DtmCommitMessage), rxBuffer[i].used); } } } diff --git a/multimaster.c b/multimaster.c index 9048bf3ad7..19ffb068ee 100644 --- a/multimaster.c +++ b/multimaster.c @@ -15,11 +15,13 @@ #include "libpq-fe.h" #include "postmaster/postmaster.h" #include "postmaster/bgworker.h" +#include "storage/lwlock.h" #include "storage/s_lock.h" #include "storage/spin.h" #include "storage/lmgr.h" #include "storage/shmem.h" #include "storage/ipc.h" +#include "storage/procarray.h" #include "access/xlogdefs.h" #include "access/xact.h" #include "access/xtm.h" @@ -28,7 +30,6 @@ #include "access/commit_ts.h" #include "access/xlog.h" #include "storage/proc.h" -#include "storage/procarray.h" #include "executor/executor.h" #include "access/twophase.h" #include "utils/guc.h" @@ -50,26 +51,23 @@ #include "multimaster.h" - - typedef struct { - TransactionId xid; - GlobalTransactionId gtid - bool is_local; /* transaction on replica */ - bool is_distributed; /* transaction performs INSERT/UPDATE/DELETE and has to be replicated to other nodes */ + TransactionId xid; /* local transaction ID */ + GlobalTransactionId gtid; /* global transaction ID assigned by coordinator of transaction */ + bool isReplicated; /* transaction on replica */ + bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ + bool containsDML; /* transaction contains DML statements */ csn_t snapshot; /* transaction snaphsot */ } DtmCurrentTrans; typedef uint64 timestamp_t; #define DTM_SHMEM_SIZE (64*1024*1024) -#define DTM_HASH_SIZE 1000003 +#define DTM_HASH_SIZE 100003 #define USEC 1000000 #define MIN_WAIT_TIMEOUT 1000 #define MAX_WAIT_TIMEOUT 100000 -#define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) - void _PG_init(void); void _PG_fini(void); @@ -81,16 +79,16 @@ PG_FUNCTION_INFO_V1(mm_drop_node); static Snapshot DtmGetSnapshot(Snapshot snapshot); static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); -static void DtmUpdateRecentXmin(Snapshot snapshot); static void DtmInitialize(void); static void DtmXactCallback(XactEvent event, void *arg); - +static void DtmBeginTransaction(DtmCurrentTrans* x); +static void DtmPrepareTransaction(DtmCurrentTrans* x); +static void DtmEndTransaction(DtmCurrentTrans* x); static Snapshot DtmGetSnapshot(Snapshot snapshot); static TransactionId DtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); static TransactionId DtmAdjustOldestXid(TransactionId xid); static bool DtmDetectGlobalDeadLock(PGPROC* proc); -static cid_t DtmGetCsn(TransactionId xid); static void DtmAddSubtransactions(DtmTransState* ts, TransactionId* subxids, int nSubxids); static char const* DtmGetName(void); @@ -102,11 +100,12 @@ static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError); static void MMVoteForTransaction(DtmTransState* ts); static HTAB* xid2state; -static DtmCurrentTrans dtm_tx; +static DtmCurrentTrans dtmTx; +static DtmState* dtm; static TransactionManager DtmTM = { PgTransactionIdGetStatus, - PgTransactionIdSetTreeStatus, + DtmSetTransactionStatus, DtmGetSnapshot, PgGetNewTransactionId, DtmGetOldestXmin, @@ -117,17 +116,17 @@ static TransactionManager DtmTM = { DtmGetName }; -DtmState* dtm; bool MMDoReplication; char* MMDatabaseName; char* MMConnStrs; int MMNodeId; int MMArbiterPort; +int MMNodes; -static int MMNodes; -static int MMQueueSize; -static int MMWorkers; +static int MMQueueSize; +static int MMWorkers; +static int DtmVacuumDelay; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -148,7 +147,7 @@ static timestamp_t dtm_get_current_time() { struct timeval tv; gettimeofday(&tv, NULL); - return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + local->time_shift; + return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + dtm->timeShift; } static void dtm_sleep(timestamp_t interval) @@ -159,7 +158,6 @@ static void dtm_sleep(timestamp_t interval) ts.tv_nsec = interval*1000; while (nanosleep(&ts, &rem) < 0) { - totalSleepInterrupts += 1; Assert(errno == EINTR); ts = rem; } @@ -179,36 +177,9 @@ static csn_t dtm_get_csn() static csn_t dtm_sync(csn_t global_csn) { csn_t dtm_csn; -#if 1 - while ((dtm_csn = dtm_get_csn()) < global_csn) { - dtm->time_shift += global_csn - dtm_csn; - } -#else while ((dtm_csn = dtm_get_csn()) < global_csn) { - LWLockRelease(&dtm->hashLock); -#if TRACE_SLEEP_TIME - { - timestamp_t now = dtm_get_current_time(); - static timestamp_t firstReportTime; - static timestamp_t prevReportTime; - static timestamp_t totalSleepTime; -#endif - dtm_sleep(global_csn - dtm_csn); -#if TRACE_SLEEP_TIME - totalSleepTime += dtm_get_current_time() - now; - if (now > prevReportTime + USEC) { - prevReportTime = now; - if (firstReportTime == 0) { - firstReportTime = now; - } else { - fprintf(stderr, "Sync sleep %lu of %lu usec (%f%%)\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime)); - } - } - } -#endif - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + dtm->timeShift += global_csn - dtm_csn; } -#endif return dtm_csn; } @@ -217,7 +188,7 @@ static csn_t dtm_sync(csn_t global_csn) */ static char const* DtmGetName(void) { - return "mmts"; + return MULTIMASTER_NAME; } Snapshot DtmGetSnapshot(Snapshot snapshot) @@ -246,7 +217,7 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) timestamp_t delay = MIN_WAIT_TIMEOUT; Assert(xid != InvalidTransactionId); - LWLockAcquire(&dtm->hashLock, LW_SHARED); + LWLockAcquire(dtm->hashLock, LW_SHARED); #if TRACE_SLEEP_TIME if (firstReportTime == 0) { @@ -258,16 +229,16 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { - if (ts->csn > dtm_tx.snapshot) { + if (ts->csn > dtmTx.snapshot) { DTM_TRACE((stderr, "%d: tuple with xid=%d(csn=%lld) is invisibile in snapshot %lld\n", - getpid(), xid, ts->csn, dtm_tx.snapshot)); - LWLockRelease(&dtm->hashLock); + getpid(), xid, ts->csn, dtmTx.snapshot)); + LWLockRelease(dtm->hashLock); return true; } if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { - DTM_TRACE((stderr, "%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtm_tx.snapshot)); - LWLockRelease(&dtm->hashLock); + DTM_TRACE((stderr, "%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot)); + LWLockRelease(dtm->hashLock); #if TRACE_SLEEP_TIME { timestamp_t delta, now = dtm_get_current_time(); @@ -292,24 +263,24 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (delay*2 <= MAX_WAIT_TIMEOUT) { delay *= 2; } - LWLockAcquire(&dtm->hashLock, LW_SHARED); + LWLockAcquire(dtm->hashLock, LW_SHARED); } else { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; DTM_TRACE((stderr, "%d: tuple with xid=%d(csn= %lld) is %s in snapshot %lld\n", - getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtm_tx.snapshot)); - LWLockRelease(&dtm->hashLock); + getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot)); + LWLockRelease(dtm->hashLock); return invisible; } } else { - DTM_TRACE((stderr, "%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtm_tx.snapshot)); + DTM_TRACE((stderr, "%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot)); break; } } - LWLockRelease(&dtm->hashLock); + LWLockRelease(dtm->hashLock); return PgXidInMVCCSnapshot(xid, snapshot); } @@ -326,16 +297,16 @@ static int dtm_xid_match_fn(const void *key1, const void *key2, Size keysize) static void DtmTransactionListAppend(DtmTransState* ts) { ts->next = NULL; - *dtm->trans_list_tail = ts; - dtm->trans_list_tail = &ts->next; + *dtm->transListTail = ts; + dtm->transListTail = &ts->next; } static void DtmTransactionListInsertAfter(DtmTransState* after, DtmTransState* ts) { ts->next = after->next; after->next = ts; - if (dtm->trans_list_tail == &after->next) { - dtm->trans_list_tail = &ts->next; + if (dtm->transListTail == &after->next) { + dtm->transListTail = &ts->next; } } @@ -350,34 +321,43 @@ static void DtmAddSubtransactions(DtmTransState* ts, TransactionId* subxids, int Assert(!found); sts->status = ts->status; sts->csn = ts->csn; - sts->nSubxids = 0; DtmTransactionListInsertAfter(ts, sts); } } -static TransactionId DtmAdjustOldestXid(TransactionId xid) +/* + * There can be different oldest XIDs at different cluster node. + * Seince we do not have centralized aribiter, we have to rely in DtmVacuumDelay. + * This function takes XID which PostgreSQL consider to be the latest and try to find XID which + * is older than it more than DtmVacuumDelay. + * If no such XID can be located, then return previously observed oldest XID + */ +static TransactionId +DtmAdjustOldestXid(TransactionId xid) { if (TransactionIdIsValid(xid)) { DtmTransState *ts, *prev = NULL; - LWLockAcquire(&dtm->hashLock, LW_EXCLSUIVE); + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { timestamp_t cutoff_time = ts->csn - DtmVacuumDelay*USEC; - for (ts = dtm->trans_list_head; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { + for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { + Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED); if (prev != NULL) { + /* Remove information about too old transactions */ hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); } } } if (prev != NULL) { - dtm->trans_list_head = prev; - dtm->minXid = xid = prev->xid; + dtm->transListHead = prev; + dtm->oldestXid = xid = prev->xid; } else { - xid = dtm->minXid; + xid = dtm->oldestXid; } - LWLockRelease(&dtm->hashLock); + LWLockRelease(dtm->hashLock); } return xid; } @@ -387,25 +367,32 @@ static void DtmInitialize() bool found; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); - dtm = ShmemInitStruct("dtm", sizeof(DtmState), &found); + dtm = (DtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(DtmState), &found); if (!found) { - dtm->hashLock = LWLockAssign(); + dtm->hashLock = (LWLock*)GetNamedLWLockTranche(MULTIMASTER_NAME); dtm->csn = dtm_get_current_time(); - dtm->minXid = InvalidTransactionId; + dtm->oldestXid = FirstNormalTransactionId; dtm->nNodes = MMNodes; dtm->disabledNodeMask = 0; - dtm->pendingTransactions = NULL; + dtm->votingTransactions = NULL; + dtm->transListHead = NULL; + dtm->transListTail = &dtm->transListHead; pg_atomic_write_u32(&dtm->nReceivers, 0); + dtm->timeShift = 0; dtm->initialized = false; + PGSemaphoreCreate(&dtm->votingSemaphore); + PGSemaphoreReset(&dtm->votingSemaphore); + SpinLockInit(&dtm->votingSpinlock); BgwPoolInit(&dtm->pool, MMExecutor, MMDatabaseName, MMQueueSize); RegisterXactCallback(DtmXactCallback, NULL); - RegisterSubXactCallback(DtmSubXactCallback, NULL); + dtmTx.snapshot = INVALID_CSN; + dtmTx.xid = InvalidTransactionId; } xid2state = MMCreateHash(); - LWLockRelease(AddinShmemInitLock); MMDoReplication = true; TM = &DtmTM; + LWLockRelease(AddinShmemInitLock); } static void @@ -414,24 +401,29 @@ DtmXactCallback(XactEvent event, void *arg) //XTM_INFO("%d: DtmXactCallbackevent=%d nextxid=%d\n", getpid(), event, DtmNextXid); switch (event) { - case XACT_EVENT_START: - DtmBeginTransaction(&dtm_tx); + case XACT_EVENT_START: + DtmBeginTransaction(&dtmTx); break; - case XACT_EVENT_PRE_COMMIT: - DtmPrepareTransaction(&dtm_tx); + case XACT_EVENT_PRE_COMMIT: + DtmPrepareTransaction(&dtmTx); break; + case XACT_EVENT_COMMIT: + case XACT_EVENT_ABORT: + DtmEndTransaction(&dtmTx); default: break; } } -void DtmBeginTransaction(DtmCurrentTrans* x) +static void +DtmBeginTransaction(DtmCurrentTrans* x) { - if (!TransactionIdIsValid(x->xid)) { + if (x->snapshot == INVALID_CSN) { LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); x->xid = GetCurrentTransactionIdIfAny(); - x->is_local = false; - x->is_distributed = false; + x->isReplicated = false; + x->isDistributed = IsNormalProcessingMode() && dtm->initialized && MMDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); + x->containsDML = false; x->snapshot = dtm_get_csn(); x->gtid.xid = InvalidTransactionId; LWLockRelease(dtm->hashLock); @@ -446,15 +438,28 @@ void DtmBeginTransaction(DtmCurrentTrans* x) static void DtmPrepareTransaction(DtmCurrentTrans* x) { DtmTransState* ts; - Assert(TransactionIdIsValid(x->xid)); + int i; + + if (!x->isDistributed) { + return; + } + + if (!TransactionIdIsValid(x->xid)) { + x->xid = GetCurrentTransactionId(); + } LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); - ts->snapshot = x->is_local ? x->snapshot : INVALID_CSN; + ts->snapshot = x->isReplicated ? x->snapshot : INVALID_CSN; ts->status = TRANSACTION_STATUS_UNKNOWN; ts->csn = dtm_get_csn(); + ts->procno = MyProc->pgprocno; + ts->nVotes = 1; /* I voted myself */ + for (i = 0; i < MMNodes; i++) { + ts->xids[i] = InvalidTransactionId; + } if (!TransactionIdIsValid(x->gtid.xid)) { - ts->gtid.xid = xid; + ts->gtid.xid = x->xid; ts->gtid.node = MMNodeId; } else { ts->gtid = x->gtid; @@ -462,12 +467,20 @@ static void DtmPrepareTransaction(DtmCurrentTrans* x) LWLockRelease(dtm->hashLock); } -static XidStatus DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) +static void +DtmEndTransaction(DtmCurrentTrans* x) +{ + x->snapshot = INVALID_CSN; + x->xid = InvalidTransactionId; + x->gtid.xid = InvalidTransactionId; +} + +static XidStatus +DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { DtmTransState* ts; csn_t csn; int i; - int nSubxids; XidStatus status; LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); @@ -501,50 +514,43 @@ static XidStatus DtmCommitTransaction(TransactionId xid, int nsubxids, Transacti return status; } -static void DtmAbortTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) +static void +DtmAbortTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { int i; DtmTransState* ts; - if (!TransactionIdIsValid(dtm_tx.gtid.xid)) - { - dtm_tx.gtid.xid = xid; - dtm_tx.gtid.node = MMNodeId; - } - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); ts = hash_search(xid2state, &xid, HASH_FIND, NULL); Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ ts->status = TRANSACTION_STATUS_ABORTED; - for (i = 0; i < nSubxids; i++) { - ts->status = status; + for (i = 0; i < nsubxids; i++) { ts = ts->next; ts->status = TRANSACTION_STATUS_ABORTED; } LWLockRelease(dtm->hashLock); - - ArbiterVoteTransaction(dtm_tx.gtid, false); } -static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) +static void +DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) { - XTM_INFO("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); - if (!RecoveryInProgress()) + DTM_INFO("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); + if (dtmTx.isDistributed) { - if (status == TRANSACTION_STATUS_ABORTED || !dtm_tx.is_distributed) + if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML) { - DtmAbortTransaction(xid, nsubxids, xibxods); - XTM_INFO("Abort transaction %d\n", xid); + DtmAbortTransaction(xid, nsubxids, subxids); + DTM_INFO("Abort transaction %d\n", xid); } else { - if (DtmCommitTransaction(xid, nsubxids, xids) == TRANSACTION_STATUS_COMMITTED) { - XTM_INFO("Commit transaction %d\n", xid); + if (DtmCommitTransaction(xid, nsubxids, subxids) == TRANSACTION_STATUS_COMMITTED) { + DTM_INFO("Commit transaction %d\n", xid); } else { - PgTransactionIdSetTreeStatus(xid, nsubxids, TRANSACTION_STATUS_ABORTED, status, lsn); - dtm_tx.is_distributed = false; + PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, TRANSACTION_STATUS_ABORTED, lsn); + dtmTx.isDistributed = false; MarkAsAborted(); END_CRIT_SECTION(); elog(ERROR, "Commit of transaction %d is rejected by DTM", xid); @@ -554,13 +560,15 @@ static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, Transaction PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); } -bool DtmDetectGlobalDeadLock(PGPROC* proc) +static bool +DtmDetectGlobalDeadLock(PGPROC* proc) { elog(WARNING, "Global deadlock?"); return true; } -static void DtmShmemStartup(void) +static void +DtmShmemStartup(void) { if (PreviousShmemStartupHook) { PreviousShmemStartupHook(); @@ -586,6 +594,21 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.vacuum_delay", + "Minimal age of records which can be vacuumed (seconds)", + NULL, + &DtmVacuumDelay, + 10, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.workers", "Number of multimaster executor workers per node", @@ -620,7 +643,7 @@ _PG_init(void) "multimaster.arpiter_port", "Base value for assigning arbiter ports", NULL, - &MMAtbiterPort, + &MMArbiterPort, 54321, 0, INT_MAX, @@ -665,12 +688,12 @@ _PG_init(void) * resources in dtm_shmem_startup(). */ RequestAddinShmemSpace(DTM_SHMEM_SIZE + MMQueueSize); - RequestAddinLWLocks(1); + RequestNamedLWLockTranche(MULTIMASTER_NAME, 1); MMNodes = MMStartReceivers(MMConnStrs, MMNodeId); if (MMNodes < 2) { elog(ERROR, "Multimaster should have at least two nodes"); - } + } BgwPoolStart(MMWorkers, MMPoolConstructor); MMArbiterInitialize(); @@ -705,17 +728,18 @@ _PG_fini(void) * *************************************************************************** */ -void MMJoinTransaction(GlonalTransactionId gtid, csn_t snapshot) +void MMJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot) { LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); dtm_sync(snapshot); LWLockRelease(dtm->hashLock); - dtm_tx.gtid = gtid; - dtm_tx.xid = GetCurrentTransactionId(); - dtm_tx.snapshot = snapshot; - dtm_tx.is_local = true; - dtm_tx.is_distributed = false; + dtmTx.gtid = *gtid; + dtmTx.xid = GetCurrentTransactionId(); + dtmTx.snapshot = snapshot; + dtmTx.isReplicated = true; + dtmTx.isDistributed = true; + dtmTx.containsDML = true; } void MMReceiverStarted() @@ -727,7 +751,7 @@ void MMReceiverStarted() csn_t MMTransactionSnapshot(TransactionId xid) { - TransStatus* ts; + DtmTransState* ts; csn_t snapshot = INVALID_CSN; LWLockAcquire(dtm->hashLock, LW_SHARED); @@ -751,7 +775,7 @@ Datum mm_stop_replication(PG_FUNCTION_ARGS) { MMDoReplication = false; - dtm_tx.is_distributed = false; + dtmTx.isDistributed = false; PG_RETURN_VOID(); } @@ -924,7 +948,7 @@ static void MMProcessUtility(Node *parsetree, const char *queryString, params, dest, completionTag); } if (!skipCommand) { - dtm_tx.is_distributed = false; + dtmTx.isDistributed = false; } } else { MMBroadcastUtilityStmt(queryString, false); @@ -939,7 +963,7 @@ MMExecutorFinish(QueryDesc *queryDesc) CmdType operation = queryDesc->operation; EState *estate = queryDesc->estate; if (estate->es_processed != 0) { - dtm_tx.is_distributed |= operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE; + dtmTx.containsDML |= operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE; } } if (PreviousExecutorFinishHook != NULL) @@ -957,43 +981,53 @@ void MMExecute(void* work, int size) BgwPoolExecute(&dtm->pool, work, size); } -static BgwPool* MMPoolConstructor(void) +static BgwPool* +MMPoolConstructor(void) { return &dtm->pool; } +static void +SendCommitMessage(DtmTransState* ts) +{ + SpinLockAcquire(&dtm->votingSpinlock); + ts->nextVoting = dtm->votingTransactions; + dtm->votingTransactions = ts; + SpinLockRelease(&dtm->votingSpinlock); + + PGSemaphoreUnlock(&dtm->votingSemaphore); +} -void MMVoteForTransaction(DtmTransState* ts) +static void +MMVoteForTransaction(DtmTransState* ts) { - LWLockRelease(&dtm->hashLock); + LWLockRelease(dtm->hashLock); if (ts->gtid.node == MMNodeId) { - /* I am master: wait responces from replicas */ - while (ts->nVotes+1 != dtm->nNodes) { - WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); - ResetLatch(&MyProc->procLatch); - } + /* I am coordinator: wait responses from all replicas for transaction replicated using logical decoding */ + WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); + ResetLatch(&MyProc->procLatch); + Assert(ts->nVotes == dtm->nNodes); + + /* ... and then send notifications to replicas */ + SendCommitMessage(ts); } else { /* I am replica: first notify master... */ - SpinLockAcquire(&dtm->spinlock); - ts->nextPending = dtm->pendingTransactions; - ts->pid = MyProc->pgprocno; - dtm->pendingTransactions = ts; - SpinLockRelease(&dtm->spinlock); - - PGSemaphoreUnlock(&dtm->semapahore); + ts->nVotes = dtm->nNodes-1; /* I just need one confirmation from coordinator */ + SendCommitMessage(ts); /* ... and wait response from it */ WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); } - LWLockAcquire(&dtm->hashLock< LW_EXCLUSIVE); + LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); } -HTAB* MMCreateHash(); +HTAB* MMCreateHash(void) { - static HASHCTL info; - TAB* htab; + HASHCTL info; + HTAB* htab; + memset(&info, 0, sizeof(info)); info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(DtmTransState); + info.entrysize = sizeof(DtmTransState) + (MMNodes-1)*sizeof(TransactionId); info.hash = dtm_xid_hash_fn; info.match = dtm_xid_match_fn; htab = ShmemInitHash( @@ -1004,4 +1038,9 @@ HTAB* MMCreateHash(); ); return htab; } - + +DtmState* +MMGetState(void) +{ + return dtm; +} diff --git a/multimaster.h b/multimaster.h index e8e70c2f24..f9f204e999 100644 --- a/multimaster.h +++ b/multimaster.h @@ -4,64 +4,75 @@ #include "bytebuf.h" #include "bgwpool.h" -#define XTM_TRACE(fmt, ...) +#define DTM_TRACE(fmt, ...) /* #define XTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ -#define XTM_INFO(fmt, ...) +#define DTM_INFO(fmt, ...) -typedef uint64 csn_t; +#define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) + +#define MULTIMASTER_NAME "mmts" + +typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) +/* Identifier of global transaction */ typedef struct { - int node; - TransactionId xid; + int node; /* Zero based index of node initiating transaction */ + TransactionId xid; /* Transaction ID at this node */ } GlobalTransactionId; typedef struct DtmTransState { TransactionId xid; + XidStatus status; GlobalTransactionId gtid; - XidStatus status; - csn_t csn; /* commit serial number */ - csn_t snapshot; /* transaction snapshot, or 0 for local transactions */ - int nVotes; - int pid; - struct DtmTransState* nextPending; - struct DtmTransState* next; + csn_t csn; /* commit serial number */ + csn_t snapshot; /* transaction snapshot, or INVALID_CSN for local transactions */ + int nVotes; /* number of votes received from replcas for this transaction: + finally should be nNodes-1 */ + int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, + used to notify coordinator by arbiter */ + struct DtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ + struct DtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ + TransactionId xids[1]; /* transaction ID at replicas: varying size MMNodes */ } DtmTransState; typedef struct { - volatile slock_t spinlock; - PGSemaphoreData semaphore; - LWLockId hashLock; - TransactionId minXid; /* XID of oldest transaction visible by any active transaction (local or global) */ - int64 disabledNodeMask; - int nNodes; - pg_atomic_uint32 nReceivers; - bool initialized; - csn_t csn; - DtmTransState* pendingTransactions; - BgwPool pool; - Latch latch; + volatile slock_t votingSpinlock; /* spinlock used to protect votingTransactions list */ + PGSemaphoreData votingSemaphore; /* semaphore used to notify mm-sender about new responses to coordinator */ + LWLockId hashLock; /* lock to synchronize access to hash table */ + TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ + int64 disabledNodeMask; /* bitmask of disable nodes (so no more than 64 nodes in multimaster:) */ + int nNodes; /* number of active nodes */ + pg_atomic_uint32 nReceivers; /* number of initialized logical receivers (used to determine moment when MM intialization is completed */ + long timeShift; /* local time correction */ + bool initialized; + csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ + DtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. + This list is used to pass information to mm-sender BGW */ + DtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. + It is cleanup by DtmGetOldestXmin */ + DtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. + This list is expected to be in CSN ascending order, by strict order may be violated */ + BgwPool pool; /* Pool of background workers for applying logical replication patches */ } DtmState; extern char* MMConnStrs; -extern int MMNodeId +extern int MMNodeId; +extern int MMNodes; extern int MMArbiterPort; +extern char* MMDatabaseName; -extern DtmState* dtm; - -extern void MMArbiterInitialize(); -extern int MMStartReceivers(char* nodes, int node_id); -extern GlobalTransactionId MMBeginTransaction(void); +extern void MMArbiterInitialize(void); +extern int MMStartReceivers(char* nodes, int node_id); extern csn_t MMTransactionSnapshot(TransactionId xid); -extern void MMJoinTransaction(GlobalTransactionId gtid, csn_t snapshot); -extern void MMReceiverStarted(void); -extern void MMExecute(void* work, int size); -extern void MMExecutor(int id, void* work, size_t size); -extern HTAB* MMCreateHash(); - -extern char* MMDatabaseName; +extern void MMJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot); +extern void MMReceiverStarted(void); +extern void MMExecute(void* work, int size); +extern void MMExecutor(int id, void* work, size_t size); +extern HTAB* MMCreateHash(void); +extern DtmState* MMGetState(void); #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index aaafd155e7..18c3860e13 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -8,6 +8,7 @@ #include "access/htup_details.h" #include "access/relscan.h" #include "access/xact.h" +#include "access/clog.h" #include "catalog/catversion.h" #include "catalog/dependency.h" @@ -323,9 +324,13 @@ create_rel_estate(Relation rel) static void process_remote_begin(StringInfo s) { - GlobalTransactionId gtid = pg_getmsgint64(s); - csn_t snapshot = pq_getmsgint64(s); - MMJoinTransaction(gtid, snapshot); + GlobalTransactionId gtid; + csn_t snapshot; + + gtid.node = pq_getmsgint(s, 4); + gtid.xid = pq_getmsgint(s, 4); + snapshot = pq_getmsgint64(s); + MMJoinTransaction(>id, snapshot); SetCurrentStatementStartTimestamp(); StartTransactionCommand(); } diff --git a/pglogical_proto.c b/pglogical_proto.c index 472b52fe4b..800b090b7e 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -7,6 +7,7 @@ #include "access/sysattr.h" #include "access/tuptoaster.h" #include "access/xact.h" +#include "access/clog.h" #include "catalog/catversion.h" #include "catalog/index.h" @@ -109,7 +110,8 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, } else { mm->isLocal = false; pq_sendbyte(out, 'B'); /* BEGIN */ - pq_sendint64(out, MMGenerateGTID(txn->xid)); + pq_sendint(out, MMNodeId, 4); + pq_sendint(out, txn->xid, 4); pq_sendint64(out, csn); } } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index a2b777d7f0..fcfaac1a3c 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -20,6 +20,7 @@ #include "libpq-fe.h" #include "pqexpbuffer.h" #include "access/xact.h" +#include "access/clog.h" #include "access/transam.h" #include "lib/stringinfo.h" #include "pgstat.h" @@ -200,7 +201,9 @@ pglogical_receiver_main(Datum main_arg) PQExpBuffer query; PGconn *conn; PGresult *res; +#ifndef USE_PGLOGICAL_OUTPUT bool insideTrans = false; +#endif ByteBuffer buf; /* Register functions for SIGTERM/SIGHUP management */ diff --git a/tests/dtmbench b/tests/dtmbench index 3ad806cd7b75ce539658d9555058f72e348c61e5..d833e4a223d2fbc6db0d3c3240941c7d3f92e364 100755 GIT binary patch literal 469438 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 ~xMtdrtSz+z|$D#eJD&5X#F9ozJ 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

2FO@o-&`geQ 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 Date: Wed, 10 Feb 2016 23:48:44 +0300 Subject: [PATCH 0250/1139] MMTS bug fixes --- arbiter.c | 28 +++++++++++++++++----------- multimaster.c | 43 ++++++++++++++++++++++++++----------------- tests/dtmbench | Bin 469438 -> 478837 bytes 3 files changed, 43 insertions(+), 28 deletions(-) diff --git a/arbiter.c b/arbiter.c index 16e1be6b4a..dba7884731 100644 --- a/arbiter.c +++ b/arbiter.c @@ -1,7 +1,7 @@ /* - * multimaster.c + * arbiter.c * - * Multimaster based on logical replication + * Coordinate global transaction commit * */ @@ -99,7 +99,7 @@ static void DtmTransReceiver(Datum arg); static BackgroundWorker DtmSender = { "mm-sender", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ - BgWorkerStart_PostmasterStart, + BgWorkerStart_ConsistentState, 1, /* restrart in one second (is it possible to restort immediately?) */ DtmTransSender }; @@ -107,7 +107,7 @@ static BackgroundWorker DtmSender = { static BackgroundWorker DtmRecevier = { "mm-receiver", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ - BgWorkerStart_PostmasterStart, + BgWorkerStart_ConsistentState, 1, /* restrart in one second (is it possible to restort immediately?) */ DtmTransReceiver }; @@ -216,7 +216,7 @@ static int connectSocket(char const* host, int port) static void openConnections() { - int nNodes = ds->nNodes; + int nNodes = MMNodes; int i; char* connStr = pstrdup(MMConnStrs); @@ -228,9 +228,14 @@ static void openConnections() if (host == NULL) { elog(ERROR, "Invalid connection string: '%s'", MMConnStrs); } - for (end = host+5; *end != ' ' && *end != ',' && end != '\0'; end++); - *end = '\0'; - connStr = end + 1; + host += 5; + for (end = host; *end != ' ' && *end != ',' && *end != '\0'; end++); + if (*end != '\0') { + *end = '\0'; + connStr = end + 1; + } else { + connStr = end; + } sockets[i] = i+1 != MMNodeId ? connectSocket(host, MMArbiterPort + i) : -1; } } @@ -241,7 +246,7 @@ static void acceptConnections() int i; int sd; int on = 1; - int nNodes = ds->nNodes-1; + int nNodes = MMNodes-1; sockets = (int*)palloc(sizeof(int)*nNodes); @@ -359,7 +364,6 @@ static void DtmTransReceiver(Datum arg) { int nNodes = MMNodes-1; int i, j, rc; - int rxBufPos = 0; DtmBuffer* rxBuffer = (DtmBuffer*)palloc(sizeof(DtmBuffer)*nNodes); HTAB* xid2state; @@ -408,7 +412,7 @@ static void DtmTransReceiver(Datum arg) #endif { int nResponses; - rxBuffer[i].used += readSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBufPos); + rxBuffer[i].used += readSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBuffer[i].used); nResponses = rxBuffer[i].used/sizeof(DtmCommitMessage); LWLockAcquire(ds->hashLock, LW_SHARED); @@ -426,6 +430,8 @@ static void DtmTransReceiver(Datum arg) SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } } + LWLockRelease(ds->hashLock); + rxBuffer[i].used -= nResponses*sizeof(DtmCommitMessage); if (rxBuffer[i].used != 0) { memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(DtmCommitMessage), rxBuffer[i].used); diff --git a/multimaster.c b/multimaster.c index 19ffb068ee..fd9d691cc0 100644 --- a/multimaster.c +++ b/multimaster.c @@ -453,7 +453,7 @@ static void DtmPrepareTransaction(DtmCurrentTrans* x) ts->status = TRANSACTION_STATUS_UNKNOWN; ts->csn = dtm_get_csn(); ts->procno = MyProc->pgprocno; - ts->nVotes = 1; /* I voted myself */ + ts->nVotes = 1; /* My own voice */ for (i = 0; i < MMNodes; i++) { ts->xids[i] = InvalidTransactionId; } @@ -479,7 +479,8 @@ static XidStatus DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { DtmTransState* ts; - csn_t csn; + csn_t localCSN; + csn_t globalCSN; int i; XidStatus status; @@ -489,33 +490,34 @@ DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) /* now transaction is in doubt state */ ts->status = TRANSACTION_STATUS_IN_PROGRESS; - csn = dtm_get_csn(); - if (csn > ts->csn) { - ts->csn = csn; - } + localCSN = dtm_get_csn(); + ts->csn = localCSN; DtmTransactionListAppend(ts); DtmAddSubtransactions(ts, subxids, nsubxids); MMVoteForTransaction(ts); /* wait until transaction at all nodes are prepared */ - csn = ts->csn; - if (csn != INVALID_CSN) { - dtm_sync(csn); + globalCSN = ts->csn; + Assert(globalCSN >= localCSN); + + if (globalCSN != INVALID_CSN) { + dtm_sync(globalCSN); status = TRANSACTION_STATUS_COMMITTED; } else { + ts->csn = globalCSN = localCSN; status = TRANSACTION_STATUS_ABORTED; } ts->status = status; for (i = 0; i < nsubxids; i++) { ts = ts->next; ts->status = status; - ts->csn = csn; + ts->csn = globalCSN; } LWLockRelease(dtm->hashLock); return status; } static void -DtmAbortTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) +DtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status) { int i; DtmTransState* ts; @@ -523,10 +525,10 @@ DtmAbortTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); ts = hash_search(xid2state, &xid, HASH_FIND, NULL); Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ - ts->status = TRANSACTION_STATUS_ABORTED; + ts->status = status; for (i = 0; i < nsubxids; i++) { ts = ts->next; - ts->status = TRANSACTION_STATUS_ABORTED; + ts->status = status; } LWLockRelease(dtm->hashLock); } @@ -539,9 +541,10 @@ DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, DTM_INFO("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); if (dtmTx.isDistributed) { + Assert(xid == dtmTx.xid); if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML) { - DtmAbortTransaction(xid, nsubxids, subxids); + DtmFinishTransaction(xid, nsubxids, subxids, status); DTM_INFO("Abort transaction %d\n", xid); } else @@ -990,12 +993,18 @@ MMPoolConstructor(void) static void SendCommitMessage(DtmTransState* ts) { + DtmTransState* votingList; + SpinLockAcquire(&dtm->votingSpinlock); - ts->nextVoting = dtm->votingTransactions; + votingList = dtm->votingTransactions; + ts->nextVoting = votingList; dtm->votingTransactions = ts; SpinLockRelease(&dtm->votingSpinlock); - PGSemaphoreUnlock(&dtm->votingSemaphore); + if (votingList == NULL) { + /* singal semaphreo only once for the whole list */ + PGSemaphoreUnlock(&dtm->votingSemaphore); + } } static void @@ -1011,7 +1020,7 @@ MMVoteForTransaction(DtmTransState* ts) /* ... and then send notifications to replicas */ SendCommitMessage(ts); } else { - /* I am replica: first notify master... */ + /* I am replica: first notify coordinator... */ ts->nVotes = dtm->nNodes-1; /* I just need one confirmation from coordinator */ SendCommitMessage(ts); /* ... and wait response from it */ diff --git a/tests/dtmbench b/tests/dtmbench index d833e4a223d2fbc6db0d3c3240941c7d3f92e364..d4b3e9e000f2196f90bf41e6859fc346aff00fbb 100755 GIT binary patch literal 478837 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�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 J$gwp<{}21a+tC03 literal 469438 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 Date: Thu, 11 Feb 2016 20:11:40 +0300 Subject: [PATCH 0251/1139] Continue work on MMTS --- arbiter.c | 19 +++++++-- multimaster.c | 95 +++++++++++++++++++++++++-------------------- multimaster.h | 6 +-- pglogical_apply.c | 3 +- pglogical_proto.c | 1 + tests/dtmbench | Bin 478837 -> 451933 bytes tests/dtmbench.cpp | 4 +- 7 files changed, 77 insertions(+), 51 deletions(-) diff --git a/arbiter.c b/arbiter.c index dba7884731..6a04a1f7bb 100644 --- a/arbiter.c +++ b/arbiter.c @@ -200,7 +200,7 @@ static int connectSocket(char const* host, int port) } if (rc < 0) { if ((errno != ENOENT && errno != ECONNREFUSED && errno != EINPROGRESS) || max_attempts == 0) { - elog(ERROR, "Sockhub failed to connect to %s:%d: %d", host, port, errno); + elog(ERROR, "Arbiter failed to connect to %s:%d: %d", host, port, errno); } else { max_attempts -= 1; sleep(1); @@ -236,7 +236,7 @@ static void openConnections() } else { connStr = end; } - sockets[i] = i+1 != MMNodeId ? connectSocket(host, MMArbiterPort + i) : -1; + sockets[i] = i+1 != MMNodeId ? connectSocket(host, MMArbiterPort + i + 1) : -1; } } @@ -260,9 +260,12 @@ static void acceptConnections() } setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on); - if (bind(sd, (struct sockaddr*)&sock_inet, nNodes-1) < 0) { + if (bind(sd, (struct sockaddr*)&sock_inet, sizeof(sock_inet)) < 0) { elog(ERROR, "Failed to bind socket: %d", errno); } + if (listen(sd, MMNodes-1) < 0) { + elog(ERROR, "Failed to listen socket: %d", errno); + } for (i = 0; i < nNodes; i++) { int fd = accept(sd, NULL, NULL); @@ -332,8 +335,13 @@ static void DtmTransSender(Datum arg) writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); txBuffer[i].used = 0; } + DTM_TRACE("Send notification %ld to replica %d from coordinator %d for transaction %d (local transaction %d)\n", + ts->csn, i+1, MMNodeId, ts->xid, ts->xids[i]); + txBuffer[i].data[txBuffer[i].used].dxid = ts->xids[i]; + txBuffer[i].data[txBuffer[i].used].sxid = ts->xid; txBuffer[i].data[txBuffer[i].used].csn = ts->csn; + txBuffer[i].data[txBuffer[i].used].node = MMNodeId; txBuffer[i].used += 1; } } @@ -344,6 +352,8 @@ static void DtmTransSender(Datum arg) writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); txBuffer[i].used = 0; } + DTM_TRACE("Send notification %ld to coordinator %d from node %d for transaction %d (local transaction %d)\n", + ts->csn, ts->gtid.node, MMNodeId, ts->gtid.xid, ts->xid); txBuffer[i].data[txBuffer[i].used].dxid = ts->gtid.xid; txBuffer[i].data[txBuffer[i].used].sxid = ts->xid; txBuffer[i].data[txBuffer[i].used].node = MMNodeId; @@ -426,6 +436,9 @@ static void DtmTransReceiver(Datum arg) } Assert((unsigned)(msg->node-1) <= (unsigned)nNodes); ts->xids[msg->node-1] = msg->sxid; + DTM_TRACE("Receive response %ld for transaction %d votes %d from node %d (transaction %d)\n", + msg->csn, msg->dxid, ts->nVotes+1, msg->node, msg->sxid); + Assert(ts->nVotes > 0 && ts->nVotes < ds->nNodes); if (++ts->nVotes == ds->nNodes) { SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } diff --git a/multimaster.c b/multimaster.c index fd9d691cc0..d7b3dfb28c 100644 --- a/multimaster.c +++ b/multimaster.c @@ -230,14 +230,14 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (ts != NULL) { if (ts->csn > dtmTx.snapshot) { - DTM_TRACE((stderr, "%d: tuple with xid=%d(csn=%lld) is invisibile in snapshot %lld\n", - getpid(), xid, ts->csn, dtmTx.snapshot)); + DTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", + getpid(), xid, ts->csn, dtmTx.snapshot); LWLockRelease(dtm->hashLock); return true; } if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { - DTM_TRACE((stderr, "%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot)); + DTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); LWLockRelease(dtm->hashLock); #if TRACE_SLEEP_TIME { @@ -255,7 +255,7 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (firstReportTime == 0) { firstReportTime = now; } else { - fprintf(stderr, "Snapshot sleep %lu of %lu usec (%f%%), maximum=%lu\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime), maxSleepTime); + DTM_TRACE("Snapshot sleep %lu of %lu usec (%f%%), maximum=%lu\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime), maxSleepTime); } } } @@ -268,15 +268,15 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) else { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; - DTM_TRACE((stderr, "%d: tuple with xid=%d(csn= %lld) is %s in snapshot %lld\n", - getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot)); + DTM_TUPLE_TRACE("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld\n", + getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot); LWLockRelease(dtm->hashLock); return invisible; } } else { - DTM_TRACE((stderr, "%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot)); + DTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); break; } } @@ -342,7 +342,7 @@ DtmAdjustOldestXid(TransactionId xid) ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { timestamp_t cutoff_time = ts->csn - DtmVacuumDelay*USEC; - + #if 0 for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED); if (prev != NULL) { @@ -350,6 +350,7 @@ DtmAdjustOldestXid(TransactionId xid) hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); } } + #endif } if (prev != NULL) { dtm->transListHead = prev; @@ -398,7 +399,6 @@ static void DtmInitialize() static void DtmXactCallback(XactEvent event, void *arg) { - //XTM_INFO("%d: DtmXactCallbackevent=%d nextxid=%d\n", getpid(), event, DtmNextXid); switch (event) { case XACT_EVENT_START: @@ -427,7 +427,7 @@ DtmBeginTransaction(DtmCurrentTrans* x) x->snapshot = dtm_get_csn(); x->gtid.xid = InvalidTransactionId; LWLockRelease(dtm->hashLock); - DTM_TRACE((stderr, "DtmLocalTransaction: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot)); + DTM_TRACE("DtmLocalTransaction: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot); } } @@ -438,6 +438,7 @@ DtmBeginTransaction(DtmCurrentTrans* x) static void DtmPrepareTransaction(DtmCurrentTrans* x) { DtmTransState* ts; + bool found; int i; if (!x->isDistributed) { @@ -448,8 +449,9 @@ static void DtmPrepareTransaction(DtmCurrentTrans* x) x->xid = GetCurrentTransactionId(); } LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); - ts->snapshot = x->isReplicated ? x->snapshot : INVALID_CSN; + ts = hash_search(xid2state, &x->xid, HASH_ENTER, &found); + Assert(!found); + ts->snapshot = x->isReplicated ? INVALID_CSN : x->snapshot; ts->status = TRANSACTION_STATUS_UNKNOWN; ts->csn = dtm_get_csn(); ts->procno = MyProc->pgprocno; @@ -475,6 +477,24 @@ DtmEndTransaction(DtmCurrentTrans* x) x->gtid.xid = InvalidTransactionId; } +static void +SendNotificationMessage(DtmTransState* ts) +{ + DtmTransState* votingList; + + SpinLockAcquire(&dtm->votingSpinlock); + votingList = dtm->votingTransactions; + ts->nextVoting = votingList; + dtm->votingTransactions = ts; + SpinLockRelease(&dtm->votingSpinlock); + DTM_TRACE("Register commit message\n"); + if (votingList == NULL) { + /* singal semaphore only once for the whole list */ + DTM_TRACE("Signal semaphore\n"); + PGSemaphoreUnlock(&dtm->votingSemaphore); + } +} + static XidStatus DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { @@ -524,12 +544,16 @@ DtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); ts = hash_search(xid2state, &xid, HASH_FIND, NULL); - Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ - ts->status = status; - for (i = 0; i < nsubxids; i++) { - ts = ts->next; + if (ts != NULL) { /* should be created by DtmPrepareTransaction */ ts->status = status; - } + for (i = 0; i < nsubxids; i++) { + ts = ts->next; + ts->status = status; + } + if (dtmTx.isReplicated) { + SendNotificationMessage(ts); + } + } LWLockRelease(dtm->hashLock); } @@ -538,19 +562,18 @@ DtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) { - DTM_INFO("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); - if (dtmTx.isDistributed) + DTM_TRACE("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); + if (xid == dtmTx.xid && dtmTx.isDistributed) { - Assert(xid == dtmTx.xid); if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML) { DtmFinishTransaction(xid, nsubxids, subxids, status); - DTM_INFO("Abort transaction %d\n", xid); + DTM_TRACE("Abort transaction %d\n", xid); } else { if (DtmCommitTransaction(xid, nsubxids, subxids) == TRANSACTION_STATUS_COMMITTED) { - DTM_INFO("Commit transaction %d\n", xid); + DTM_TRACE("Commit transaction %d\n", xid); } else { PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, TRANSACTION_STATUS_ABORTED, lsn); dtmTx.isDistributed = false; @@ -643,7 +666,7 @@ _PG_init(void) ); DefineCustomIntVariable( - "multimaster.arpiter_port", + "multimaster.arbiter_port", "Base value for assigning arbiter ports", NULL, &MMArbiterPort, @@ -990,42 +1013,29 @@ MMPoolConstructor(void) return &dtm->pool; } -static void -SendCommitMessage(DtmTransState* ts) -{ - DtmTransState* votingList; - - SpinLockAcquire(&dtm->votingSpinlock); - votingList = dtm->votingTransactions; - ts->nextVoting = votingList; - dtm->votingTransactions = ts; - SpinLockRelease(&dtm->votingSpinlock); - - if (votingList == NULL) { - /* singal semaphreo only once for the whole list */ - PGSemaphoreUnlock(&dtm->votingSemaphore); - } -} - static void MMVoteForTransaction(DtmTransState* ts) { LWLockRelease(dtm->hashLock); if (ts->gtid.node == MMNodeId) { /* I am coordinator: wait responses from all replicas for transaction replicated using logical decoding */ + DTM_TRACE("Coordinator waiting latch...\n"); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); + DTM_TRACE("Coordinator receive %d votes\n", ts->nVotes); Assert(ts->nVotes == dtm->nNodes); /* ... and then send notifications to replicas */ - SendCommitMessage(ts); + SendNotificationMessage(ts); } else { /* I am replica: first notify coordinator... */ ts->nVotes = dtm->nNodes-1; /* I just need one confirmation from coordinator */ - SendCommitMessage(ts); + SendNotificationMessage(ts); /* ... and wait response from it */ + DTM_TRACE("Node %d waiting latch...\n", MMNodeId); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); + DTM_TRACE("Node %d receive response...\n", MMNodeId); } LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); } @@ -1034,6 +1044,7 @@ HTAB* MMCreateHash(void) { HASHCTL info; HTAB* htab; + Assert(MMNodes > 0); memset(&info, 0, sizeof(info)); info.keysize = sizeof(TransactionId); info.entrysize = sizeof(DtmTransState) + (MMNodes-1)*sizeof(TransactionId); diff --git a/multimaster.h b/multimaster.h index f9f204e999..35bb32d984 100644 --- a/multimaster.h +++ b/multimaster.h @@ -4,9 +4,9 @@ #include "bytebuf.h" #include "bgwpool.h" -#define DTM_TRACE(fmt, ...) -/* #define XTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ -#define DTM_INFO(fmt, ...) +#define DTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) +//#define DTM_TRACE(fmt, ...) +#define DTM_TUPLE_TRACE(fmt, ...) #define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) diff --git a/pglogical_apply.c b/pglogical_apply.c index 18c3860e13..aa554dd525 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -330,9 +330,10 @@ process_remote_begin(StringInfo s) gtid.node = pq_getmsgint(s, 4); gtid.xid = pq_getmsgint(s, 4); snapshot = pq_getmsgint64(s); - MMJoinTransaction(>id, snapshot); SetCurrentStatementStartTimestamp(); StartTransactionCommand(); + MMJoinTransaction(>id, snapshot); + fprintf(stderr, "REMOTE begin node=%d xid=%d snapshot=%ld\n", gtid.node, gtid.xid, snapshot); } static void diff --git a/pglogical_proto.c b/pglogical_proto.c index 800b090b7e..f5ae6ec630 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -105,6 +105,7 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, { PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; csn_t csn = MMTransactionSnapshot(txn->xid); + fprintf(stderr, "pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); if (csn == INVALID_CSN) { mm->isLocal = true; } else { diff --git a/tests/dtmbench b/tests/dtmbench index d4b3e9e000f2196f90bf41e6859fc346aff00fbb..875fabc51f30fc68b5894e0683e2c687cfbd8347 100755 GIT binary patch literal 451933 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 z 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

J`@JQyOk7cVus+wZ{OO5Y`sBqg&}Uqx}k? z1z~MI#Nj^eu05$7)`r>y=%X+^X*!HQ<9dS}4SxaXv=7Sz816PVnpOJ;!~sm`SsIxw ztDnMfkGn;xm?8>+RDwjk_k5JXJ?%CeU_#&wK=@3Uf!pvQjU2V7u0`XvgR}<`c0cJx zjvVG(H}KwG<@BNdqk&Jl6DL>T>1()HK+b&NOUa=F+D=CCneZZS;9Ljn?^a;DBXK@v z;g${LPcy}w1^go^VONAwE$}g#UP=kn$3u`+DmIw~bz@NEXv&MP;QUc2&jVf%L6MU6UB7PIsCRF|&IS;+`6SLKjywb8J{*PT3mtVF z*jE;JGCunljrl=Tt*dbRSBM={LAXC?SKFNL0$0DB`z<)}!0+`roMg?8*I0rI+N5SK zfW0&jTKFXT9-c3qi~{$9Swn3a4|5NJH7t_JFvv+8Z~?E$vO)rDygJx7Z_W_95WNS0fv_ZuPmxchrnY$B)-3oP&xPSDFF&r)-n zVB>5ZZoI6jHO9f3u#=s^Uh=C-ZivXvXfOFS*~pol;a>85#k$Et@5PdM zl_hr&=|WY(O1v8sJE7VT)J-}B{kf_sis{IRE%~@Q#vUlI5qK$I*QR}dZMRmnt5iMPzX^g;9ZtI}_o$51KUj%ap0Mc4Tl4D#J#{V?P|5W6ER))k{tSzK} zQG?A!bz(EdxUaWHuc5?oJ2L=E&gn`7)LCwwigSM|h7Q+5#&Wx;*^SN>byEAWTNzU)e-5Z^yxeB;+K&45Y7jhGy!XRo2K?VF&!ID^z zbtutLaw%6egs3^i#VM9}D!HtyxkVD? zHW+Js)_qbkW3A+YuG$XyK8u-_W2}`t#LavOm)Ag6=YjufIiBcCu$4U5t$@R+iblNS zVG-{=-wPd0C9iRRNpYML@J*Em>3&Nz@OrnwFGw>JZVspoVW}L6rjp-x2kcf_djOzE zeQgbY;MV=kXio?9g0C&nRPr|Wd!+Mj(D-sdYkX}Df8wr1xb!RG&j1|^YcrZk-tE4E z&LY}B0Jdq?TXQkZH_lOVbPwaG1y8z=bpmJHfuwb0+bYn8EhqAaI-JNvs#4f z18N$E`7~?tZ|)?_z5@3Klo^H@M2Sq0{wMdpK?Pk|q{CNxI^rQ~dZ0~mkq1z^8L;*5fla|OOdic5;ghJ;BxmMp~x z#S8qi5oebyB?)jUDQsR-3ZuT{{DIdOp&K;=);`jNL`ume0?$r2#S8)dnB_PcE)^Iz z$Lz>+faVaE9wdQOa@oL{*`_X50a_o{W+0VZKG5zt}yJtl$;)z{xo(g&=T<<7QN@3H*~a-TsN?72~58p48~E(qXK7+ppdB`%#S36$Dssm$rA#3-Uo9n zSnpe=el9Wj>A>a^rnJL=zP7N((hTR>K=E^CApQwF8uN$VWAR9ca+;7lH!vL+kW>K> z%K9X6M%RtpK>l{%WghNpf>7U*bP$&OP9Vo3K%F4&;X`S)FbgEF4_x{~`{|Ab^sI$F zP9OS5JMtsqr{t}Hnd8xU7lO6QXVMWTqj*C^YwO(QPXPZI*n!({Msvw-RQ)qJR(uQW z4bKBe^`(Y%AV@qKyS*j$p29n+)4QzCR{qApOfJ!LxW8 zV&Ng~U$fVG@Q#_{Djk7gw}q3rQAN3vX@Izs{RVtaNmF9290@5Isukb|u_TtJqgq;1 z^?_ulm3sFPN_qYD`E1m6Udh zRj1O9yn^zZtARN%(_@$1lTbK=B{7AiWt>ANPid`c{RG7;5Z|(pN4AreV=4@HP^&It z9SSNR5-3HmXmt&DQ9akQVd8vO;WwcTsLB7Xgx)R%bkEt+E z?Kc*npwoc(jxkdSxynFmylRf?-0C{Sw|uBb%6sZ%xW@miHU8gb{&PRM&Fb(wii}Ox zyc3E8uUV;7q=`YQ+y#A?60{E!f+;%``<0RyHD#xIkBucUYRac-hiouLP1z-yN@CQM z-6|bsl*FhhpQ)O%!5B4VkE$md41ZJhDjohZU`^St`$6YfII&MTqS%eyv_pBYaZbHj z60u<-Q*3#y*><5e*iL-~6KP6zSLJvR^Dq`6IL$?z+f}6?s%XVtd(qnh zJxxeM{0p#)Pgn&=tZS;a-oRA@!5HPUy3&l~1@pY$Jq~xuVp}~A_|-^?gsLeYx|9Dv zovZ=2&By(M90}A@es;HGqNiu-BuHmS?9XB(ZJ6?xn`<*J?-9NR=%%$};9G8yZOWNK zIB$C#4zOr#2~|^qft|gLb`?O?2(un_Rxu@4pwUpg&xhLW0Co1YB~(o*5I8yuZ?Ymh z9MI#wwuVav;?QEV3C{vFFRaZ_H6UKdKEx1X**TC_^RSp&W1yQdD6p~~G8BZ%1G?Xb+wk2ld6vG& zQ;0^8b|4}>OWK7UOGkJqZv>+IBO0KIp&*U4L<27g%tVwrknr<><`UM;#t1KEb)YoP z>P34spbcSdfwu&rasQEM9{_aB*UtEMANKA*VAOmVz6kLZtEszw#vl7({bJw~q`_3S zj>y7=V#?LPcOPNj?u9tnLPnKow3J*?8I6J01J=aij-=7@^vd(N=_|c}JZe#o zozIwH_?Plf)KL)C6cApEB!&C7}S zMeE2mWph;SLU8;B2*FOa(K!Be2$!-isx0qFDh#Zo#hr{P_oF(`MGdL~`&A)sWFfs* zT3<*`wD&SdT|s#CKS{d;sQk;ET$X8EW>6` zb+$5~au8PxL(D3sd>!3AKPK7+5I<-kFWhpHRm^i>BCj510)PAtoD8|YHd{>Pogh62 z!Xlp}oyGrgGCpLF$q{oJvy{6Dtj{8ux*{$hC6iJtW*HLk?r9J%Mv$D0oUt%cKBio8 z;5UI~!vRH)TB(h;{a-~j<%O_>1@v+C4u`((XA#46UxP`a`kK3uYW&j0@uViYU+mzw z5H8){<1kE^J6^{Z!)##gculN>8&Av~uMNW!0W8+r{ zApm@6LEpEE4oiTOl^mLPLM=c^cw{9SE~(3?t~e_HaS$H(5#@Ejw`gS^%e4_@4iF1q z5vlivKqfRU3vp!&>0-N1{t9)4(6~M1CNzEms}lG&?uO#ZUYm(fZ=@QKRjQ4DMdMEB z1l_z9q@6A&!74TFa8@@LK(rW3;_<9*z6Z&6EA_;Z4Se@ov3Ajky)+iK(;iiDr_i4$ zOs;1BV^{tztFPubu^l??5vDQ>f(>0tIBGO)2lkz1zRfz{a9s*Zwo5=-JY ztTHX#p)Nvl-AcXhxeq@R&)}(M+#&T!2Ac35*onuYReS7*!Q$9VvLaolg>vJ#M`wEO zSZZnyK|3O{xb8Y43q1gZx*kI6xK^qTc0r=}xRYusln@xo{pxKLZ{2n~%iZX06>mp( zJC{$#F0@y25n1BLxDJZdr9!h{QsTzAF6s|Bt~$R^9NeyIg=|dcMmP1YY%m~<>#5ka zbP6=Cs>{mN;bmN!TUs_4QO0GsNwUFwXk0b7A~z)5kL#_*?NH8jS}fHAm4GGj7Pj=s zLR>%9Y%Y2e;rf7@5{~A`lTa*ffI2uxIs4$X>J2C}4D(DSZm1fu3zzf(yAuITBP_<{ zOeJoF8jNYkeI4Ru7V^k;B&LmfT>X-wwE7O<`+W|p#>rT}7dtaeeenUzp9A)@k82y< zkv@o9p)Mjk78hcA;{Hc0;)3^)l+(8^Y@AZnMxf7Ox7@P8D_D+`Ch#|^R$tut#=U3^ zs3l=t2L&%f`@9;3!6(}N01XOj3w%-aTyC_d0Gb)r?tco}KdVcvjrL+dE5q6X|E6{z z9VBJ%1hhA-&6jw^{i)vEZ1(OuK$pVW0$*1>-bWNc&jY=15Wr$Q?>z(Bj=N`~X`T{* z$`ICVFL0Fm&%L;3o7%MjHT1PR4aZITaY6U1t#|~Ea4$f*LOX3g3Bz}}zdflOP8{wN zVW=D;u(+IVVt(WC%Y+6%-{~Y!y!&ej^+-s-Pqy;D|pBuZxXdMV^2~^09b&Z!7 z!&>5DF?W~3LK5tczCaSc#-k2Xc&?QMasD6Pbi0ex#@(ohXN(JyhTh}qg_}_ zo(ZYoI_vTH7qy0jwFJ7~eQk%)n(k|*#MD4-l!!i8PdQyG;tCLuRakWA%*7!Vnha|x zkA4VVo#^GoG;c3BCn9+%AH0Jqni$QOOw-h5z&Cx$1sL(fUdlC`AH*GtZt{=j<-v(g zDJ;6kEW9>-!MhTu+DbVmp)Tgi?>dB!JgP*wWQ4J>I4oKkVeU6O# zl=u1r9uid)6-M!$JQlgCFjLxr;j%7R#vWDaoY()vdZf+@of!t(P` zFCx=H%k4oN@Lw$pc|p|N1l*ef@+1)Fk$fl1se2p1$*Hbd4#pa?WE^VoGr0Z((P1mr z$F;oDMfSn6W)KV* z06phx%Ncjv`|c*h->gry6woSPTf-l?XW<`fQ0)S=-`AE?>bQ^H@?(_q2jL5Ve)6?7 zyvu!RE~)`X1{IB7ogItuoTt=rd))`0H`@0CDoa?;fC3+MU+ZPG>jG*V*5(;^+)=k( ze{;s&3sAo>%row|&)s4#Du+>vngD1@80Hyw+*j_JS_WPKXt58=jpT7ZN40qqZL$U8 zPYKa2kIm$yZMg^P9inTNz(J5l@-x6M`5YNbX-D?MgQ3w=cI&RH0{zhbShO9@sroPM zd>Fkm&TvWtPxU!6A!yU|JC_DSp_2Cp6{g&wEA0QRkqi@v<(G44W4!Nxex zVAcN%JQmHQcU;D?E~8~&_8gQ^2w0MjvkWgwL2UxF-iDFdAhh;LQZre+{XM48ELiFT z!ec&Z7LI-%fAraQT&KYJmLN?B;RQ?5uY`-c5px=osEmN+fHqjzyc~+Jjf)G#?s?7( zg9E@%k|Q&T>`~gB-_SyNVuyce_WF0=H*Vu>;=DL0&@-QD#XJ~S#j)s`kwZk9a2^e` znq&rSI`I1BNLiXQlC$7rfp5PscDe!Yf14fQJRT^6;FJ}mo&rAeHak@&!RNJ6?@fl! z?8b|Mzw6u4`z4&iQ3o;2)F)>T@Z-K6&ACz>b`oOuG&N)KGVm*w;}q&y-<%HFvywtR zFevhG!I@HpaWIKlP4c`9q@C{jaJ{DcpO4`@ch2khIsZD2!(%|{UI7t)_j_LEsqki; z%#FqYwu0Av$`G7ToJW-EO(rY2urpeH>Vt6ADa|n7>m^aX+&1db)rSCwF3dv!qAMM-aR@GUv&?quyMZ;L1GK6a~&# zmr?o^EQ!gSEvkxiv5FdivmPuW)rXME#6vHDs#V`ri6GqXlQLws;e7_4tMYeMPHhNO zbKo6r<1qK{RZzP+qI1KX8VY|S$L zd}uVx%8Pfs{O+XdruOd{gi9S*G?7)R*)lD9eceSku~aD_)QBMI^rJV@-G)P^_}d&+1JOR{A7%Gd*j1o80uV@Mb%( zT^4sFDDif<<2vEKD%etI0bL-h8*Sj9*rh%0&%fYmJK?yty^uX%6RH?{{};8Ph&}fDgTm!}-)xfoAAl(s!Q$K8Ktv zWeF!|pmDS*YZdTKx7p!*>JVSbWYF+OuX^(qIV zj+!~Q0PqBIviKvM27zBjz8b(AN7`vS0#l7@4`DB>Y_cYHwv~htb98r@WJ670 zHumy;xR`c-j~qiWZR+Rc#}`AtFxf*+n>Ks+5z62f!V){OW0>sWF$li1!Yr98$sYa& z;9m=B&)`s&>><7h7 zs+8JrEUTNR0e^=jaZ^?|uRwCkO0^}MJyz$rto6UO=hW^jlJXV(q^@K^A%{vUo z{cPTIvSG4$b7aG0^VrmWHjkC-XY>A)4U^6LTQ*EK?-n;~Ht+o?Tp6UrD=7SLEQzPE zpTny0vw3COA`7<$*cKnxHcU3J?F8e(G2mx> z&P*xCWb^KBgb$a&sCy0gP0R7Kd0n?5nZ>=xi>zN^ET#@jHt&xbxST@mDu9?6G&N|l zd1G%F?RJ1VhqX;MuNR^v(H;)y@vyeZ=Ed|-y6jni=7qIQHt!nJby7oX0lgpAHrc#A zIG^O6x`zRM9@aM5ydEE#y7?8*Utw*N&AV@o(a!N04gy&8e%ox`PcLKgqVWoZr9y2s zZ^C^hSJpHPnQUHT&v@L2P&%8zX7l>2Hswtq#2WXrdC@J5r>}*zCM`f0EaVm`Y_v9p zwM;gzVPWIpkuYSkd9&Wc6Qq~m{Lf*?Wb@v=fJ++OuOI>`b| zUSPCpgtbgI@9nRRR!3jUX7jFms8ef0fsDl>UB~-{9X!+)KGut&ZO>-&mf?CWvwq)!bLCDvlg&GR7*i~??;3@(J}lZbR*ck%_XwS| z*}RYL!Bc~P(m-q+N!C1*%{%*|Hrf-M0X|PtOg8TcT)bhIo&wQV+UNyuo=0raY` zZL@jrevFHrEPFkm&AztH=FOjj+dv8PhKiG6ZIjJgwNYv9-vM0NQg~qa50%{kAO*XG%B?AuvG~9=6Ht&nh(3}SG zY(mn<*i3#luQ5(XvN0d=4)FJVj*KOn&D&ebRPABlU*EUEo^)9< zacE;Eo5zPHg;)fn@^>KGY+m%I%Bcgqc?8GL<~@-Y-@gMiGy?Wmpr6efz7-vEG6*mD zBo^&w^M1LB9bXLWT^|>Ho6Y;EjnY-W2l#QHBjea+^Rn%PjZ47(_HmZsWhtmlAlM0x zQzrG4nVy_<4|eKIuQRdCzZyrH&wUwF0IYbZ3VpZZFWpHZ#cT}J?zHAfsga;=uDl-=CzE0 z8|1tUe4%egbFLJZY~Jr9OwQy3;5#hmwrn25Y{}*o*>Za}kAbw)z2{lv>t+RT8rKM! zk?PSOV3KW&fWG_n2LO~ViJwo}L}$^Wq=U z*}MfkkxT0x&g{iMECIh{_Tu}5GkfuUC7usw_Tpzr9ZO~}el|Oue#b)m9GO@ovlsu8 z%zu*Ei+@=ryIuo(4sqfasNL}70G7m9&KwVkbeTF0$z?0mhm*UBhaQ1YtFBjp@n{z; zqUz-)E=P>`plXDWDL(|NH1JBdad=`7Uq$_d$%N)qQ{b)1DJmv-#E7q@78X~|Si+fr zhFBB&h!Njdt!|9Be-NGq=s90o4hiuOsBE9&KtXsZpjE!MhC8c*XnoP%1!%voEr*2o z-s+=rc$k#h7Xba_YioF*TGbaXC?Om@0jH%{jORQg#6PA&IQonBy@1LRmby(7c$|D5 zP_*j;Y8=+)5hMN`HMFZaV)O#kFAVdD5x-Wgt%d2HWlsP!B@FY35x-G=UD&`204)x~ zd^jk6w~DKPp2>Fk2+$tFbj>TriVtPLEFay8|5L4)Zg}5=^Lr#uC^r?qa$S+8Lb&|u zVUbEOrW(SOBnjgma2wAvN1+suYLF;prb?M@eBxv`uBvIXE+7r?iEKts*fK50f9ekH zj$$W(Fe8Gbvx)I1+zJcv@)>BUw}G$mIkK19#@}w)cY*H&cHGCMApYn?VtgoYqy!4O z1j3&_iM?7U6650ot!HxoCnD*D#kBGiOyco{19Qq_N}vykfRYL8-pxc}d_tg9HJs8C zZUm@B7-k|dzH*>lKGXU80(z8ixSb@C7+){&$tk7#@O0pFtqI)#a`7gqk}~890xv~Q z7CXXuDo}Bi8Fw{-H@VFYr}FqYfw2v6h+@?|gzZ7(WU(WhrGeD$X1bpO{6%tDyL#W- zzMLJ(3m{x!l}*AXB9X|cHZqYY^Lr>CijMv19%P;F@6iF_*&PyzU*-wlh8Sc7hb6H( zJBCRl7KY$HE0hDU*8&LyeH&srfch5Ho<$}SY2FDPhw};5p2w~vb-4w4sir5;GyO#3 zc!(y`N?(?16Nz&ndDBY0fdZLC;=2%kU?E*>*Dr8wm5IdDkefte)MS%L?12@h?7rcW zNc;l?NiR|=MS2Tq+zE9BlJLW`;wHgT-+Z3c&C(FvN1gdu-K-8tBP-RGY$CC(6>Arr z*eMGYJ{vl5D&!G~MAnZ^By!COvG5SRZ#FWdZwpMDl{JyrehLf_|6e2$$@LS7m!R`2 zmc(V;1)E58K*@raejFO z1-At@B4QJXwLE;PfEKGy#r|MP+>R|jk@(MSJOD?y3!q+vcL{6~iI1Jam3err#sHcS zhD{=|!9+aF3D|uF&;r6@+$Iv=`wq|sh__kDBim0TuIz)`qN#oo_;)^sRpTcTuOolr zUI!M1^HDKxY?wsis(9lI#Gmg6T9@9l**8qtj&fcg;D zbzl;SOZOS=ae$r4+9r|s$Q7f#70}0FZIei>T}A1#zXo(JtZfpB zdkUMq`v;JE##V5eNhDs(g}cb;c>zGh2y4$xA~7M>Xr}?H8P+z5#9giMh$*!@0P5yz z+eG4*gD`m!9u3Ho3bl#EzcJf0%y(ypA(KcfzTdRzYC;pC?p+e3&o9!?~- zGoGFgYfV}piNvSS_M+t=+A>-ukyw2c9#p1>1;da@B(CXgQk_-8kVzy?{uZyWrdDf0 z+C!5_yxzmK<$$o3NhAh7Fj`Z>S|*V=_>$3j%h$4r#1s8>f^ajComg}SKFSUrnhzgr zBJnjGqnZ6X2hPutJex=?TUJw|XTWPL+SCmg@x-1@BwlTxdG~=+{Z2fSNbKJTQ!KRG zfs^U;SRGO)UQ0S@6N!DIHTfwJUyLMco=GGgOV+&Q;B4@Dnqm@(XE540==TFYHjy|I(Fom-pNXpA!kI@b=pQ)?wYLTCJ&)UHK&}nqgCuj9 zNSD?>nrvrJP5>z|JAZdB>wac-gp4ZuY$PdzghMZiQB>0Wle??iC;kUgB9!J z+DYjm-@>w=NW2L~HXQWzo}MAWPb3zAJi%i62xk+CLpI^oN|03z;EgTE6aBO)+c3r! zyP>;*cf$+Uu559|79w zYuiNP420dRL3J9?cfPhwBqrg0xe%rRbpue~IkWqYO(gz}d~#mGg#eWxtUWi0#NL@k zI|ESdu(nAgzEK+aLuz*d)FZ5I5{dB>O!8thpmAZ?Bobe2j;m+%{AEC|hhdXQbjv9X zZv?c}hixLUW+7-Ef%p_5>Ah?wKasfiVSK8ZNAkabE5xLlBV)-X5<7lms8$;|1(#SgyZ6dMcKIKdYJ~x8nClVXKht~iB+8hCU zEYMFR4ok;A9R%S^pF|)1L}CdB$-e;m+s8%UCK5k=&eU!07jP2{7F{_qj%_0GY+sa- z0<5l&vkWgwL2UvXs-d6`AoTM|QZre+{XOO(Fx1;yVBogxk;08J00RPFiqd8ZKOCs@K$E0YYLClUt5A?{}0vTpYBC+IuBoY}& zJKY=A#LubuI5Ix-7JlZH$MoZbUk;qPG6Nxghm_(w?e zF9P}{44XvapS=+Ppq5o|E;2D#WXHT5toYC*=$S-f%ij&J0yr6wJd;Q~e+3gEO|=2s zjTAP3G4(u5`H4haD3znoSdgapwhBs_uldBuZfy)(Y4Nu~+Tar@@`P;@iRY2XReL}< z9zpUGiSx6YO1KRCy3dilw28#Sdr?XE;Ob`)EV>q?ApZD?#Ob*~N&%sUPhzk36N&k7 zcBu7O(MRxRL7Z?j_(iFJ+|JH3GqzRiwFB<9$PFE(+%rUIXJn;nx#%(DU03OOr*Z@kTp zNhB5>f?FNPIRyNxNIN=_coD)YR@o$MA`*$5Y9kYgGQWp+r8qy4(V!GniKup*K6MHKxiN)EGQ=fSNaFc-Q2~pqM#1912D2OInvHp}; z+Wx9AwlR=60dKMAKza@M5}$J)&8Bt4sY|5~1AP!-3TGSey|;0)6$NK!p#BtN=R4rP z+{XE+E6O?+SdeZw!B;T;v55EjHGOG6y#UTPfu4s9Ckc4!ZJd>tQP!V8~7`h`AJM=*ZjoD!I`k-!||kfcAu8 ze%!fIF#5<%)B4{6x@=)j4)xrWmccst7hJZQ92>AvXu3YcOB0UGYZY44=Ki^|bgF`r14&jd6p z3@;u7I3s#mW7DWB0d2IfY53d|!KoR2>s!M)1pKSpILFI^(kUM>Q`V!RIt^q;EZrZ!>D{&^La}P_A*}aRPeFYqiyH>a8%RG9H>jm~G_EsZQdwPZ70$cl)r1tyFL!K>Beh+ekon^KlQ-f6UWQJ1ME7tW2YqX^A3%?g;+PA zdU)hb9J2}9Pd!jzKlQ+M`>6-6+fO~@!+H@ciK+C;eCpvo2&!74SDlFY)I%p!ep4V1 z`efsi)&8HrY(pmGV2Rd#(^>BWravH6`}?6sfScRb$nRnLi4GI){yp$K(w~`)WZ-!V=SyI#C+=EEsR>Wz>7fVTZW$H z%%>i9u2;?)AlrPDd`&T*dYD!K6?Y8y8J{E0;d2fw75``&|0Y8d|5%Oq#|o1{#I7Wd z{7HWa?Ly@z)ail#1L`u22nrngsRxpkj0pD(J<%h=J$o-&QkCY2aKA~Gb^WP_bXn(P zeD1eJz9vV1>Y=2p^Ok-00!vYHj_!W{k*xE@B9WhZpl|-C9=4;W@4}MUlWpXG>fsBB zzO`bnue9IW*!Dm5a2*@>EHZlDJZyOb!7|kQu^ed;jU@;~)Z3-YEGGm|XO z`Ex87k&LMjT=fv(L6+i)y8YAxD$`LDfz9%9-xGaik54_MT7Gbvir>{qn!=WL=G%kTh8q9sfUDXI5^RG z89?O;OEqh_q5EAvT*4&W5K!~5HqY$wsfU^O8tp!S286W*?&$XV#ArVaXnI(iXZHBi zL*eT<7|{44K+D50&+PH3hnr`VhCc@MnGf4fJv1!^&C?KHCPc4wBeP}wPdzl>Y>J3o zjN75Hn7wD}0iSvpU(Ez2r2r-Qu=&(ON)9w`El8UZ@k{VO^>DZ=?gyj)y@3zD6DL=o zAe`$;&Q##D$YJA&r+CRLZp*=^9@f5t{ap%dT_n!D13vYTfUC7q%wE7JNC~?llxl%d zN0ct*GT`fxR_v!9l13SC`tpL%G#(P*~<^k7(< zFQ{|72lDkc4h#k~BCKsb_3-pSyl9EF@GPL&VQurNhwBw^rwQSA0Il=2?WZ2DeF|td z#7C{BjAZ{)57p6_>IYz#Ew0~Dm*bHJZOqt+!Q7Jvi>^8j7h}SF>Y+tzm?#HAtw>UM zu$oUjd|Lxw`lYKKKzt~IY(Mqz(xax(F@UE>P&}&YWD7p^@Z|v5SpdQcpTzk@CtKWy zqu$3fqqYJ2)Z+f99u#I&_bZ5hv`~14bIhk6MvMXH7VsRHX7!HqP+@l5eClEEGIYUv zK}hpSQaj-tx1W0WeK*Xt0IORhlVOnmsfW|e^mubef;5Fhzq@C7H?Z3vdj1Jmdkuso zzBP7`I~}B|e^CTS{+u~+fGz+^!bGGb5Wr1bj>A!0kB&pQ`~g0o-7&I-N1Xe&euCV;z!)d1>PbaV)10=PIxOGF@A+XQeG0adfGt`HNz z#pAjuTc8clZk7=dz;Wsw3S@$hk{=PkT^SC)<^W&db8G;|QW2}sH2yV&CjPM+@sAZI z0UW!M1aQ({LQ~NY3A=F|K>#-fC%C03@B=uKl?mYJi5?N|+2d$g8^E2FbsfO{DC;_a zJBZeXZcQ}z`D3!K12~pq1Gw?B{+|IHee(mjr*L?iiY4)1wvive&4Xx>6?-m5juYyG zZ9jn9jE#dnp%d1;AXtWa8MWjGaOVO3>QnEbEkA%$Na@^#MT*z$X};B!_7<*vaKzpV zIN4G>QMUoyGYU9*E7UZ85zsG$McW2&um6Jc7{Wm$&+oxv zv`qlFcZSg}4d_0?TH6G0(~lYL27sD{wM_tbBB&hJhI$y#BVpJCa4#cUCh#Oc&-kzn z;8I#c^9_hs6JoiZR4rT958#%@;D#p_u^XfVzKt{!z?JW15>MX)`q_s~0M~Il6xABE zKbCL_egJn3`QJDiPXJ!wPMlnUw>#oInViPJ+mgfT7f<~F?gA1(E^pNt9*LU(uKh_< z%nZOUk>c;HTz+z^1-iYbbSbL=Z;rHL1Gu3@kiw%UM}eQTX7n3|-IjqF=ZuNp0bR2u z{BLzVjg*jR=Xw_h0W7AaO#nA#xY4cvs0v}-%S-@Q{FHM3M!Tq%fZBz%O#oLX-Em^* z+8{u~eQg`S6&Zvj2~wsON^jtIRpk?}lsU1f zrBIuJ9zhJYzQqv(273Pl3x)2VjgS)r&;N01^hf^)^cIMjJkS4unS-b&Rr+u>0_dgu9R*5gs3;@YtuEzKamm1iF-p zK*)9a&YX@y9sr5spt?vX_aI}_bBO1eQ&fu^M9EOr|AEOF4(`? zA!s#I5B~qv3RP%|X9NDT3wsr%o)f0Bp7}Pv;jklh!OuZ>{9=ofd3SEqfTuX3X0e#X zM|H>4y)g3`jNj}vT-Mt`z&!_5HodY?2%$E`g>sk`U9Wx(JDFdOg>Er1efbWiOWqB* zm6$I3{{PK%zj-UzD12RaBdE$g@$F^a7)YFc_k_5|d>v08i}DFb?_o%se%Ie5%4cjQ zS(LXmd5s})`u<%Wy{pUX7V)dq>3jSd``uO`eiLSywfatZiT&sizzaL6r=6ZyJy5RoLvqt8!Z_r~LMU9Df)DWM-#rVzT z$$-dwwKEEg6aA0xs9$IfIu$?kds}lGeLm8U?!=kp9QE0q{8_@uJp3BqGwv0ftQ1Dx zuTTSA8Xz1w9rK(>PZu&6<>=Sc$EGgW2* z6rKI<0E;{dLp8g%Z2Z40KXbMuaE7cO&c42~B?$|yBg{=4cu{4X4x#E_(L z^nE;pCv07WgFO}P!Xmm{;xAYlkbS)l4^ciS$Z64V4MK!!>@gmmC zBw=tzw^Sd%#~oM_VB@_bQ%OkyT*Id<5K5;sSb3=9Xgq>Q%7cLWkV4PAArN_&5m-8H zzQQdo(F2{E;5-ie8J|NnAv)D~dK5jhL`&sRQN0DuQu64L(`MIRpc7U`qb5IqbYG+e z){oO>T49v(bkEJ;oCW@41V_(U=v8Ro-Y6ip$s;JGdTO<;$Z*xqi;LSl&^qOBoy5^M zLsrjYimG07D#msB14yP;uSIF0!IPM*Nu zPbi12p&9~jZaLvFw9v+pN)9kivoFdbJBU6qX?wVjaFpY@KhsC<#k}qJk#yNGeI%J1 zejizfayGH7wyYn&kL-cyxD|Vyh}k}J4$+=HR&uxx-T>}MXbj4?eWYba102oKaFz=v9n?j!5~;XV@k>Ht(@_0&&6 zGBZ){AF--uB3b?KGZA7e%w_*v77M{0zJFBf49({J~W*6t>Z-1sJH?a8kKC0;v2Oi5Ku0LYSLCD zpTY`oijQTrJ^pNQ+{%vaG*V83>x8agv-m5l^(Sv^R}MGZ6P4O4{#73UPpz7)Yi@*9 z)4GEm9^A)CoSYktAy#tb1NoT}%k}1bOU}}g2~FyusiV`YB6_+*2*rrnhERN*#)eQl zt+gQ(gL^-Ox`i^LcVf>f;=tgCP#z@3tkg>t$b?W8AkMH*LTxey zJrCB8+u^x?Qs?w-h3oh=KkoW0FKO=`=e!Ftw{fUN*UEzft)26J$};EioAUmg_XkS6 z&Qh0gAlTE!Y94>nyvUA=O_h4Ei zB@^%npYpj-^qe>8UF7#jnF)A4DfG-+0#U@AmyGjr^)B%3K8I>Tv~%7mOh;5yC&4*G z9zC*i-hqFC`~hhIb*W1c3#=b|+BgF7n#v2jL3@!v_S>_Ele;YhR# z7VVK}zpQfxjINzhopMfr(RG;P^jl>bN_&nao}@3fRo;MPxs`fn1Tw9%8RDH5ifEMs zNTW3dqE6xG2U5;M(d&sd+bV^oDW@GN4&2X*U=x)HYt{(`(YDH;!&{uR;dh0 zEi3g-3S?TP6~vt_6wxXbMxsN)c{L31lcb!1qIVS{+bUO2E9Xa2<^q1xrv$L(RMV~U zGU9x(vI)Y^NTFxmQD{Z9O67$xa|-y+K8I>Tw5_t~F5EN5;-XPo*|CU6wpAXz2S`y! zlZi+vVuAHz$I8^_z^MzoMFdB;ivFH9KUALZa8A^Fbo%9kcWf1Yf!empRaw`qazobj zSP9h5GFCRAv@I+#8>D`#?1kinm3lb@GOcm};@>P3(JK5L?Fb+$8+?n$lITIvn+cI^ zl?;T~6G%w{oa$5N2}QTc_eckbm6m|JlS0qD{-8v(%IjTVW*G2^K8I>Tw5_t*!>Iy` zdlj5F$)iWMRW2e-QX3%M8EJv_V_Rhs&Pvru;NL}XbgS^g(0JVw3P|X?61?d2Nr&&) zDopU(Rv97dx>cCww=)>O0p!nMO%EaegC%haq<*XPgk*q~dNTzwtuhwkDHe)om6*Mc0y#J<5IN(X}_i8`~;dxo(rh-=MVbS>ng^ z*B)1{LgF4VQtvZ?Osm8}T-ZVptunMAIwTZTWx%yaIS55>6GXOE+V4`%JEU{~{E$!C zDHPo*OP?@S#sHp93O)1YfD+LvT^@#+H-NA9IV@a=wpG@i!^J}uw+o#8{ux|p0$m-&WS~P!cugrH15W+G7Z}aU9-VfbUI(McZZ`rFL&9o(p}c| zSm8x4+bVp+uHPynQQ8wMaVVsItIUMtWh?bY3S?S^w+^neP(-T~L;^S!h}w&v6Qn!= zMXx2+Y^&U#8`rR~tuEu|Iu=doj5T{)xq%FwSjmMwERIDy^U8q|(JBM#!%Su1^?eT2 zglJpk?uoc03Zd!>&O_wUBikzRMS+ZjbV{TJc>}Q-D;GH;Uj@E6f}>l7mlK^(Q5296 z%Mlr!-T9a`l%lxkZ=KBZvB%Bv#R$CWp^ZpX^qIO)rcC2;6X+d7HW5&w*RB(0yKN7*wt-_1zPKd9ZOyGNv&?=9fykn~jL#eh^ z&oCU(Dv#kV3Uw8D zENVh?Shx^vtBl6E9Tinka1zL)N48Z~e+Ua{kT#CA!1}RcrA0YtcLm-rf}>kS-pLu_ z8#WV)BI}D*3F74N4r3+!oMm*a@N<^YwZqR@M%UpzE`F;VL}|xaVs1$NRyhyJuU6{i z7s#}V^Cd!mETRz6Di?;KLqbWF1YDk!qEPgfKxA8G!3^9%KuQC^t$oTmq3BjAlVGg$ z2Rxb-dge_8C8AX-^u%7w1U}#Auy7&TR=I&w87is`;A|m}9@$p8mvO*BNY6xCkb8j4 zSc(1+oIilyjNs^2;msmWh|j#n&Sl=S=4d{oXY!e)F-}cBGli?1vuf_C$yE-HntPja zRp&DcV%6j`7vUljAM_lAMQ#c5>SN93Ghe}J(M%s9&%ipL`A$RRG9qA`&wOqRKEMTJ z8&P>~*5os9BEiA!lRjYbnT1>7(|5itxe+E-o~NyODV}?&^O-B*xuhiE^5eauq)=c0p5m3q^NW zKE5MX3IHxk3O)1g2PLAz*3ZD6)&SnZ=TJ?Ew!;o7gKs86sQQ32fINC+JM42fuT?1$;FSGcM>tg{@e zy2IYZRo!8~2ElaL&u1xz54IGACAkB~`wLsP!}fkhIW>HQJOk?v`!_PO9U@@cVSE3A z&klh;l&Cx>WIF7>r||hiRLV0xU^?uN6_m5cw(?UH81Ui*mT%|*a_*dQWxO| zKdN6Wiu*L~Du{b0nT-wcB5jCQ^J9Brl&f0F&KcPFtsdIC0{g7fqW!my6RgphcUnFT ztQ1!q)s|wF06_&TiT5@^S15}gM*}q=tY-n|fzL3wuEotMRyCQsIe9c=7|d zx4k9G?C;=j@S+pSiK$Jb3z6T#$V+I1m=;7Hi$n@`K@ZJ2KESIL{@tH``rpfot2FY1 z$tq{mp;7o3j5^MLQBh@n!#UVzWtCGqbvKL-sa^GnXn0X~b|vK$=&2fGJrMnb;}pvr z9YFUhJ4HFgCMiK9Rp^hXI)4a?zgzgSdlZjqWeoR4+Ll7c2^Lj0K($ppE6{~BUZ1g2Q zGSg8Jde4VwWvG+638$^a#)#UH+p&w>xl7{H4;FJCopuZwzlt=o?O?1wrz*g5JO-uQ z!S8X)<0dNN7%C>S^LDTX3achrQV|?hS*V#U(QS(L7bn}1#2*;wjDI1qQmibh^GmVv zv~NY$vKC0QnR!@a*Tlueq-Lqi1@{BGDbNQNLM`M#4HcHcPx-dRtf{77FeMdxTB_+f z34TMM3U{MF74rh@1M%Mho7laB0l51<+u&U>-sujk%=hVC zhFBR#T1i zLP&U;>XZiV*LMZ*zvxho^VTz#?DQ*g7PYdFeJ+uR?~c>Y8vax&wRP;#t{ z)l`ViN!e=IsPdIAWasZ}7%k0fMXMi!!2 z0olK;gvi&n#Xx3rsvhGPZJkpQs%8qg;s8IX5`o{i1Kw}bNx1z9_omSI5$2_SG6&*d zSnL_;e3giEh&Y-3aS5wfeUb7bD&c+A)z+^u?%t_WnywDLgVBE5+5xUd`1w1*6H21e zClFrk!!i+Qml|_uwvoa=wS{9aZ{}EhO2)#eu()`^J=lS>{AGjuV-cBIoD!E1JQj;l z{71OJ4_SA{DSkJnqf7iHTGdDCjZ>mmHK4f^{}FEQ!`yO8Tp0zpn&LkSc$2iQs4V+( z9p@#*_NoP_Ro*a(+PBgO!Sf`r$?(_z7JigMl(JS@mtv}4R~n{1RE#cyn&DDL;GSNQ=P$%7SkD5qW; z$AS~gKOMnPI@g220Cu%rEw1MbR=5gz1Fq)_mOxSU8gji@Fp0X2xLzjcQMWPID+F(i zguDsYs|K%ChrB7*YXzq!K;De&je_^!sz$x$bh%Y9j_WPB-a43ods^$Y;`#%@v42AM z0j{?RZfFj9Tduba4jvErgIsSH{Okd&cjfwn!Kta>bmMyaU~$^vQ+rN_;3(R8i0d7L z@6yi0T<;WoWIW`3x!yUr^8u_6;(C|hB-$Cw^{!68$8Q1{OQ#2*zNEqA2Op~|LgHD#GS}Y zUVy#)-KE|^%W^Weutws=_IY1AybOA0!z5N-<`nFEktgLbg_z4Ik~{D8|7Q}UEdu!{ z(cNWkHb~Y|<-V{mk=EB!*w6|!z5mcPK(4wSDVAF3zjP1`G*d&YM3u~py#}33ts+!!7Y#=9w;=^TgaX)>xY7r<%dpODC1!#|R zKh|^6Pd}mB!?m#gN zC4a>^*W{USZzL2?$ecVpBtp= zGms9F*qVN%y^d4A*yZkq)&~9o(B&|ES1-UT+^80g_^D#y&D~hE_G7Q0bd{IeEY_a? z_Je+Gxl)c(tZ|M_0E2wIy|LGY1qNSShV^`GfM9S926^Lx+^d|y=+TfDraWIQ>NYMu z4637PyB8I;u*6gd-m*e5sT))FnA*$q)$<~0e62Y%%+Y6DfV}zLcf85C9zZuXld~u zN)?AF$%?%sV$DV6ic-}fZ{%Y)xjX56OJwX{s$n7JP@sAO?@LZ4s>&BMVy~*~f8!7j zff^5Jx^F_vr|~At*c)n7ZDV2)@a16>eDEjsraC)aIR{w6$ACWb;S9cNGWM2gieaZt zL;M{f*(do-M6BaB?}PDh9pWfdhCm*DaoRqHs!(wd7Pf${87--b=nPfdehb_+V|^p1VrPl*jrD`uhSPGf6d1x6SH-Cvm$cE z5U35nw~(`$u&vV^Yn8K&@G(GVd=p~c*6EBsN}IR_{ASpMsng1sOUKhhUhGm~EV=|+ zr$x%3;wnL0m5}U{tkX8$}+dR<>(z25qAh_KP z>47lf6#Lp&N3u-6o?N z`rWUbsN5M>p%C1FewDkv4D~XU=dPjVL%xv4CbNXmJ$v_da@RUm05!c4(j69&nZjvv z3E^Ds+S75gQzrm@ZDHqej>+70-bQWFy!w^M44QO8Be34=ml-HOc8hxq;coUz#WB1N zx-Sw>ZLk@G=|fkQ267*k#Fr`79deudOjW$D2?EssP&2}>6VA9=7g{^qI+y@ePlyLt zO;4<5Jo>;XldRIr_ zZGd%)#BGZXf_StKZKG-1qMsbcg%Ai{0Q_1cMOu`5;DW)X`yMVx&{k(!$KncmsvjX zRgk@2>}74uI$e5$_-)lKm}uw@?dcTg8!o?Lj83e$GUiZqW93hz*|a#shBM zVV)UUg~kJ(Ov+a*Z?=}|hB;6yp)#>h7S3A>Xz!VD`afyHghhuxr-}C?ejjl>gL=_7 zajv84#F}?3K~*SQFAuTRcE+9JmEAzm3u(nDyZKfGdnD50Qvh2ULSI2I%$L2KveaSX zvR6swZ|M55WsCqjeGGSMB#Un!FPk^wxH(Sg56&?1CXzB0J1>hbA1~YKuYZ_9r%VU@ zP!ffsyRtp6-e#{PtpL2%QM|05+5+vfV>t*hxdm0{!>R;^m8EJ1nA%q zV{iA$4%}CaO2WG3A)>?Bw0vIHv&Uh1@O3jSS`A2zI69#c&^!2$0Y|)&1*CNx<>0yO zs`-cQk@p1BKaTR9SY=oD?13dV6h_7anH)!dN4+b%ZqjBnNpMkUA&@5mbnwtYfNYPWH;)|dm0e%vAza$U5ry6Xax6gax)e8Ml%2!am!F{ZK|!Ak=h#!i zVSD~I423kfkRatkd!Le#EJDH(#0MB3d5)9Qq>+aRez?ig3YNw5Y ze;hP+0W42zx51{p4alef?Q-H8pwkx|gVlSXeV7Q(RXWdt zm&GUJQ)gU`LHY(DvJyKA#^o%F7u|{dV7vo2_5P1ai=n*<$_I%w9TufNFy$GX+kXN2 ziLeGmR)dqsW9}~WmnRusDOj(oh|L~)Ees)3=Xb)=jG`Gpu5_rG>}M%u;gJ>AKpx;5 z1Bw|lJedtEi+WAAO~y#TTo*LQLBn3wN2s}}OD+IWTeC+1FF70K$;v12{V+Con*r|$ zC>+ySE6a{xEUc7cfKLV#Qx?r=<(6KS@(1AX->xid(Y&mM7zw7Xc^MN8wNj06KrzKt z%DNthETt9TyntfLqLd8>Cs@iLz#{{SDGM9g)GfcXv);WQ@FM}mWTcdBM;+x^z?%b# z$w(=?ir%p&;0?gX0*c9qbMe%DKbFNChEZGP6yVd2;${6>7R7kw{&#Ij%b`Q4gw2M) zkzqjJoH5TvaD5<+1GM1}7Xy8FHKsH4U3&mGIWV0Ony!b@a3dx#sYlkHZyJwLpiDg* z?cF7yy>|mn4*Q44Kv{VfTDCTCA8rA3n6TCuwx!9d1&wZnrPNR6;fKXoNfD)@R4LkON z@vqYps_kyD3g)d# zqOd>6?C>*Y{OLgCCF~A4il_ZSX2%0P5Q9X&!0sObs{KJ`x0m{gcL~vukKrCRErFNC z{vfmabr|L&a$P9;?x}vRqX7Bp9*vyvzUKLPGl~*f$#$IA6djP*4P)sAHl)gRCh-pSA0e>G* zv{hiYk=bv;C6-aT6v6NRqj=g!X5Nb7ohPfH-AF`3?GcTW8y-dC+j`%H z?<~ z0DMJ2F&QbPXo#a+54dwcF&Qc4=}(*46L1^gu>r+|Atxi5E51T?&@(s(@O(${vijbF zVr;62v&=?L)&SYzP^~bw)^He>xpm(swn=#xoDUq&yHne$eP2+)*g=!YHf-|9p@Y1f zI_>e>zZ=8tvNc)gnlnGb)G+g9R^M7LpjGsw7TIY2I3~}0w+w5pj>$8Rn5K{^GLK3Q z+Q=T*G76E0nGdR?>L`9pZUq(#a5E3&I&bDDFQEhd5LwAA!1G8c(&*-rWag)Le1YX> zC}lNv&&N?diJ$pZHpXt+I=>9$9ip1O@xM~OZgU#%k%mF}2jEkV;$^KsN0Rx?tKHE3 zK`D_4R@|_aG@z7kTcOud1N8tmauhF%uVl*nZp}oCwg=MHq3P9O)63%9mNNg9@`0rc z2YhD|g;R^n|5Tf9+xmwAFCv9LNPkux!Kp>&FAt$9(n;3_z`K$tZJz|?w{o9b%6ou6 zOQIA{0_Be%5cX>2SHM2ba>ng$#luN(2SX{JY2VmU1oN_K6gIp+M$2 zGJc@->_FhR2OM>bzAPZKtZcu=p1%8l&pR8ZoYcjPh>7G`;F|*uPnuUPvyvP@=PPX67`BY{JULr*1Yi2@3l3urOncpmy%iOeinSYZ3rO~AK1j%Q#*Gr9@wcHaf`iG$7Bu)d5ev!(pK z-ZRjr~cxFRw^ptReR8B$nip`WltCPM=BD1wTJHVE-Iq-G?$DCIU__neZ zRYQ-aFYuvB9KNP3Gf!q=;Ystl2lyOv=nzwJOnh{ZchI>iX9e)$Bs+WsRc0rdyhu!Z zyaxQez>c1sW?H*?$|FZ?)PE2BwVWYT&Js zI9kC5%DkO6ub#jMCvmif4U+pYGtw$H8TbQ$k6a`VG9nj2RmZ8#;8ZUprCuQ2H{LXG6RZT3{< z1Mfi&eUUy;9ij_EO=QMP_LPqXepeEQ;gx!oOsj6~EC9YViNo+pZ7Tmnhoxb$4fug1 z4#O+8nQR$o^ZFS0H%T0ZS85B{f!hVtjv#nav6U<{t7vK)IfWR}vs4p!!+>M_!|IoM zz5LwUo`&|oyPl1cBZCo{OeD7hA0KdN+N-A_m@hM-E+nLZpi?Pb<*An1MH(Ws`JXoU zpK-_kEv%k_#@`H8{%1IPc|EUV<>(?K&P5Zic{Qafb+E{Pkdapbncd3sG=k?TU$I+7 zDneg1z|1-1duvjM%jxs&v0eqd1vz8%6!U^i>O}eFNla>?kgkCG1t!$IHqxngi(tt~ z*DS{apX@lM4NsjS%h7`?{1~989b7V~r^*{`#ALGr_+H1c_2M4kgL-P>LqK0T*qY#& zC3U)NXlzUR7w|F_og+#F{tVgplFjB);0=;E8X$AzHqpI|_$e}~hO9aTn((X%p zNVfqWn`B3WXr5$ZEms5NA>fY(c8uq=k}ZWa&`cK)s|~ z8XnifW+0uT)X`LZB?Iba0mQf2>aAX8i8yb-q{(=jEpzMy&W+@qhIKEC@Ak{P`B%uJ8#Dw%bam4lAoJrW7di5Ve18Ztd|F-uq&Przkt6Sx@t7Sc`YMpO0#p|{ z@`m186H6yd`!$e%#ZfMD&K!sTJ5><9d2B84jtd6U0--sbZq&{F|J^U<}1ylMNpA}~rJ_R3>3 zXFb#sdFaPp^X~uf9(w_7TT~+?;yZ|&x?*qv{bVV!NEu!~<jP=(&=QyQ^PgFBl{L^2aK8kKy`--h z?LRWd^6muZ{(y&O)ZQVY_nG9s^3W#3D*|P8K%2+|YQ6M&6#1=dCYwU-3{X15-Dc7Q zM>th@*IoXRb2_5`t&o4THO@xloQ6pJf!=Qy;T7rpymkzKljUiIP42&>53U7beMnA%^L@ZmO0$jV0CKC#{z9C81c{t; z0X~0(EuN>>;y?Ak$&eBIf!7Asn0Wlu8N9yy(iwSN53F;5n>>bMq>|ta(l>cGjWf>@1S~^scD|xJ<<*rk#l>=>`#DIhQ4ZmO_vnZ(cHdr z1;U9>^|Gdfngh=cIQL5HM{&6Q<$(kCG=?hp${PsI?T%-ne!6_b+B8u9J4FqaQsOL- z<~gD_U6!$44U$FOlv7$c&ja5aaGKS>59Jz-iI542(3^lhaj@oP2EHvm>jdH$*?lEi zoS#7W&5^vud)ZT zge@L|UgQ5vLN4oNNM9@i0J_}4UOkPuU2-in9h^2Eau(k$eSyW!#M6(X0rala8`<{C z->q?(2vz-lM>Mckb72T~d8IwJHUk%m?3p|Io}__&_1U!oD*e5uJi`u%_^le7Oi)X$t;44^}v_B&~L{GQm`?JBCoASp>{1~E7MC?gnmzXxxXP0;&Wj9y87$II59R`y3hgY1nBhy83s}hievN^fJPGI-2b(52jZF|zZio7ygG{@kO>$aD zW`2#N9|HR_z_n_%D9?;b%ZK?$|2weK)op3bLlezTv`3NCB>lhkc8zMlYdDVA?B6dT z`T26$`xd?iP@6b>avoA&EIn?ugXZ3V2FBsvFw97+DMztPFae&ENr0xs;k_7(q&1Qr z&~U+37C~4_SpD4Ww&8$VOYPkj-UeuQ9KLrg@}4apKX1>{F+e9Boc<)Lme=euTzXAg zEXT0|q&fT-c<7QKhrd38iD%{ci|lQ}7XrE@fLnZgF;Z`mA3sLfu7A?h|*X(XYTG}_#3za~NxeWMf$MKqtPXqj; z{1~yt+z05DB=`@>`NF0?0q6$@o2QFL!M$D!&Qa3Zh3Y+wSis$*US(|Yo5lxH^I4wRnU^I)!>;{4cq{x+mcWZUo*p^x{vzhXEUxh&S7fbCFgUI)rm?#(%&U zC32c`6q)vE=v55em9r7}ivfqBgl~nC^LeNkk*S>bfq$LAF@rxt{4(_UaBB?rcX%n- z;z#Z^;{Y-3n@~Rt)zw%H;8zBm`0%e8hkt3`h323&S7JU$ea=SYATaIw(5vGuaU4j~ z0-_l%?Vf>Le+%tHJFmtT0e>do=*+jp>Y?EL8LExNOW6)=kHftdEw&(wivG~aIGyi7 z{h5Q(*}i$r_KZZ*G{4j`bQ4g>Z@~X1$5gMI(2AyA>feZ#;qoF_uTleRiP#LB&#ow~ zrXRWjs^(N{;J0rJ%PlI^0anYuM^KwO0_)~*ufYRrW~(v4&o@SvA-UKOQ5YCNBCyev?l)T7@M_# z_Bw}{+aMeNdJync{>R<%X;(n~9qcvXEHLeAe=nTNT0I`fWTJY=O}w{|uBqRAi)lI+ z0(l}p8}F@$w3+@g3}MzoyM>7MF^zA*%0XH)e*}iwuR(h_K$<*(RyeJ>KLbrU!|59! zKRMKney+waA+3e~{Tdv9EsX!M86Rn#YWyn325Hy$eLlz46+rbJ>@`_Oq@`c3BcA_l zi#uR|@J0G2vHG^jD{QV?`F;B1ONXG`0{D(3$|V?0r?vGjon!{D4+37DKuI5pemwnN z#F*L9Z(frjXp7R?`xDYrCQ=+@vuE)oD}w^;oN5_*@FOaX_JK%$U0IsW~t+)o=GP!T@-ufWt|Q*Eli{ zW~TX{Vt76n(5OUMN3d!4_=_8x!!Xu{QTqG*XJ%r^R|o4~*o^VCHYk0QMp#`- zd(bb9e;n=A2Hb!Y4cEq{GJwwUJ3WCX0HDna5@)pLp;x~X@I(G;v_<^^4NHOxdjX#3 zH^-HkDS#dfU=uo5S4PPm@yqWpo_QMZDo62}e8r%h@BjX&LH7W8iKwYZeA+PWQU6^8 z4x{B0AYa7O9>KXtTi}1P2-mc(5%0f1LK*hBy~bCaMA}9Ep;YvR&|cyYbGn-}UIX|^ z|LPMaESdrC5l~q2vxaLuZ8=x^w}KiA=mX$V^W;a`Dt{f0mlNb!fEOlG#w|d*D@&bH zXBc>Z>c$8jpt=x)ylY;Yj`-y=(|vN@D2&6?p7-~F-L)=P)6vv;_e(|SbrGpQ8K;2$ zL3_8ex>RkCa;QFn6y>m~-kT}gG3-y<;0vwQfc^@HnKC>eT+mC~=+{D*#wjs*IgVpS zqu%xFQM*cY$cjOq({Der%9&ag^qhy$Duldq#<8R6&~6pYZwIx*^(!&DW7+jF-3~d8 zuQJWyfal&edQ4@m*b56C+I<{P^afT*OC-7$%{gmnkO=G3#l@Hwb*y%p1-bAX7Uaph zVaBUD=2h{2J@4xEXkcs6jkpn}=X1CVtUKGx&mx@SoY#ZsH+8aBLvAjO@S`cVj2YL1 zo~hbwxgMI%PHSqIf!fGGsBaG-ZCdNJpsn_DH`Fs7WE`8-o7s2z{AzUBh$&eLcm*l* zm|fL35riy`*Zmii{0B%6%4tYKrM!XNF>Dzf3b51Wa+Z)-5*YwYc-7>o@R?TnM=#wu}Wi)|z=l=qdc>ct_X2Cw|6m3O{58uv z1FQvSGUEsAl{nxilSFyOI;<&!_1`KFZ^?j-%W*IiaGi_lDv!uf+Z`*fRd2IUcUp?eA>l$E>BT zLjrT5*)+F9%~iPq=4jVT8Hd?N+N*vC)cp!w$&u+u`Vf*e&`98;7R{KsEME+_`QF&^7= zM=|Z?L-I3h3eiU#VoMRFGRll+%WJoIUiE^tvaBJlRbs2f9iBa=zTkP0cR>A^=`UrW zv`cNOSh2|W(EpWy*|>NWiDeZKDGO_wG&qq%K4*q=HA7}vt0KlMXe6kYY$$S>GP%vMlH}tmzm??>33q;04KQjTdB^gYsJS2I{!L}qF)|W$*Q*aH-a77~wIiJOE zb9tmIAvpx#eJ1*zW%-$9F~FBl@_mvDcm?mRLV&l@2&MFMh&zvy zhq7^*M4x^Qtk&ulwAPhsnF|HS#2K&A)M4zrIs^(P%NnSQ9pq)Ic8ctU=8)6cqq>`x zSVlSSkid=KRHGa3)??{`)yP`h;aI3In2P&f@UtqmjO$ncbKVrg{I&t~*Cb#z!>^H8 zcr23V;2^^x2+ivFG8hl{bD%->VaQH_;z1_q%-nilhw1~MV3f#W=vM@otvkE2ohRrd8ti>J9F!crfM1DewznE%JJVV9$i1#f^5z3BcS#OZ~AH+GHfdkBKPXjl`I(vcp?pqW8QaR=j9V9z|%yt zpkEwdJl|&K(NqaJB5MKeO(euw-A2$p4^<93PEf+U8(6}wTEhIR<1V4T;6{-!bQQ5> z+!l9I*uG+zH)1Of@Q=p<=ke zF(3M637E~WA`%OWFB=?eGmP@MXUm-JtZJE>>y=G|6Om7SK?{+8A=$4?dQUu8#j-@o zfPX%=IA(L5jl{B_xz=%TaF~x_0$jb|3eE7D5*bpD22uJ#HPA?u=w)0gM$oTn!zKitr=Fv#NSmW>I>?MyoD4WGSx%z3>B*<@*VVlBw#kfgGeka zzC>YClLi^i#wtklf~uO~{mhU%oCWF&s*7afXD(Ac8qZKMypNza^urS{o8c@Z78YM7 zIoM{{VcZGk_Z1tq@n(1$iqIY+zn5VCQ8LDEL-hhWecV(zddWLf^^fQ2&?! z*;0(9O&*R2a#EwgVLyU-R`r64df1a$4tv|cg|0PIEs7tuV&{o;f&S(M%w{+b ziG@cccQ`o6aN<|YFsvE=8>q{W`huv)D(E&c)zWx|ilvGifc{7VW;2|C#KPjsNe4SW zXJYZIdchy`bD!oxc9~Qc{4JHCx&&Lsig<1ciAZDUTPI*Px28xdEW31au*>bA>zUgr z=JpyedvKXl7yK;uLiI3{tPOIjqtI!266)s@Ae-5DNGdG3yy#$?S(K-$!*BPnqI|*} zvoO4{^(2$(f)jF@38Bt-F`lDBpG!rkFG+xGj=v%)o~ppEp@ZGwRf{sS_m~;SGA=W! z3y#UnP>o=c1M$oh`amW_{ZImAGrI^$g$0)-4tAMc){cX*etKkC$czFWQ<}dS(-i4S zRNh0H&zSBgbNmQ9Z>|~C4*YsZd{C?7E|>^o%lL+@OeRNPT^X87s8s`6ow{XjL}{2r z8al*zoI|ZBp(qQ};m2Dsx9il6^S%9`*3yZe)SM!x4QeON4KD>(}!`D)vJRNBAPLaD=ad2uJwvSS<2_k&$gI z!iRUm5k904R(;IMeB1#qElnkdGTvqiIUL~=5V6Sfs^^n8VJjOw-`9ngnO@2L<#Fd2BJ2@rFVzCGS3usT_+?4o7&`Z!8j1nfsX4pcp{8e^jo`G;jI}M<~HoGg>z? z-!K-A@K)higl`@T>po^RygfJ;;Wxa)c5gKNV0A3AU2`>i-l!Rl@V?`i-5X80mWX2( zBNm|;j_~H;Sft9eG|7ETHQ~rgHOVhgha+as@A}3f@9Um&IP#6kvszMbK9^FH5U0%HAS7M=iR7qc`oZ1d*>1D22g(JM*EF9teurZZmDkB1+2}gK02i~Qsd&B1~C3q7% z?qrMEz0vSu4c?%NMh1rkIZ6dyO z9FFkYhHc0t%Yqq>T&(>2R6bYbSt>Wj%`T`gy625AvB+<_Z`7S~``+AB zA66N!k%b18LG_eT4OGK#0LCKxCS%y{k19I84>fK3ss-JT#vYb+PdOanm+E2>emM~D z@Yns_NEM5WQ*@>>X(1NL@5lX8-FL=59GRq?tA|lPT=na4=M73Vn0uo)oMLr3Z{dkW zDh=oU{!!dh6SnfH+o>5if|}Vt!;$i%si7QG8JbWl&IP7&{S;|?XLU_W8{p`eRb^Nb45!{p}x85@4_{zSma4uFN#Hs z-f(ya63)Kv58q3fnsCI(*Q@@uY1F6R!~M0`ha>#X7Gi7$HIxx`ki!vvc`Fv-m(Wn> zb>Bxhe=ExGK!qbSv5!S4$5h69c)^TC_@%C}-Ir2yj`E*WdC>jjY}Nfx?8A{q6wRMc z{dCnIoJIK?jJ9#cRc|=Fu__j6`Y8A3Kh8ZhXfRctt7zIn>ig>ce(b{$-ZT}n`-~!L zxbIhE3#;0j=og~A9{@E_sJ|%;YH2g)cD`nFOX-^Zt^2C`YK;s55E8xKco)74YN?jcv82h6bO+CYcTq#*N|f5 z^A{o4r(7X&&IZ_PK)Fh!_2ZEBZDG|H3Z62TD~3W}r_oPp@P1@ioq;Wb=5>;v z{yhrewOaixD9uNIi9XQ5JWQ7BoW8wSqLvq5hegmQdLoNfH0wovtARAFDVK_jL;ovn zC`TgKR)@YV<8Vf1@vg z^+uiq8GVnU>C33U>}hH)Q2C_p%Ppt=z-sQP533xGusku{haWo|DfW7PpB~Jw_c&#o*-`lh(-9cML5FGF2(eP=NQ5$-Dr00 zp#gr63BzY5LOxKOREkkQj@ku(s1NwG6<*q2pC&nM#}F7-uNDY{n->5^L(g~0KPHhu z@X3BJ^}!t6~O!mDB72rpuVBfJC@(>;cIxEg|ij_#LXACB<) z2nK46xaXQV8ca-gVv)*?DPO32E&}5%^O#kjJHS2`;YurH-E#pE9RU`r!VxZHg(FdUR`XaOh$@xxl~^yym*C+Vty;|x(8e%#kssHRw%r& z!oLlqDFM+)aUw5T7Rsh8ame#QS``qD6ek|R^sGpD=@8c>{oUXl3Ajdzb9q^^NO-{y z*9-mc!1MClQ5h-D<<-I>;Z-SI)bh^*uYSNaQk=_6T1CPOO1K{7w*jw5z%^2w%d1gE z!mB2@=;DtA@7{oGq&SzCT#AI38E}=tUku**fNP{Um)9tYgck>}Ug5tC-bVq~NO3N& zEEEaX^>JCi{|UTEzVm~T;#^)7C=xDsW4+wJ7`!V3u94zgu9g=G*Q&A9?dO8mKj0cE z&gDXPk#L0>3)KFd;LQ%WMv8N}JY6JQ9LCzRzYM$=0SP#kpM1EfTI{Vj0x04PI8jHBy|*MbIMQ5+qhI{Vw3$ z8gPvi=W_jWiEsh2;17Q?X!8TAk>XS?J}wb1{}r6_SA+IqKs8dF%9X<8WXZ_p}rbUrXroXQ0|SVd!1(9f?6TFZcHq&SreWkte^ptw%z zcL#4+z%^2w%d4bIgbQ1py7|*UTNqG{6sK~H>`6I(1@12Tg}t4>6V%1BRKh+~zwsAZ zIyQ?Kap1>O!mrFNk~$~A{Q-)n<#kRR8}d7KPfPwbwEYcf2zs{Lg8e>e;wMR*i6YO zc~MR<3gz`8*!%|+e+RIU;zfv||0xpQ--A1V{K}n?4>n`UNO3N204kKPXtX6rHv~jV zUUZgrWlP%t?hD1x0H)+cmta6&D6^gcd^Z#`1DKK*or2+Qq2#Ur`~(!60+`YYxMPGD z3i*%2S6+00a{IRh_Z6U@1zbu2cU>!Tr)ajR>%sjQC|-|6#6#Sy=X@`Ig|3+3 zVKZmmNO5j0a0_Mk2PkYaklF@BN?tTg{l+g%`#qqzJpoQ|%*>_W+y#7Iz%f!hubOIX z6y`bpGa#)Gh?Kl2zsg%E{7A5W0E!P1;Do%|qo(-Z0RJ=K7%86D9yRv*01zv7!~GxF zi~}fn(Z5?UugAv%ZU{w-0H)+cKgNuwP(FVEa7QS51~4Try0;DC?+yYU0mZxkrerF3 z>1n$U;QJ@qK9`=hP?I%6z(&`g$z3FEG4=9~K&zj+<@d0dY=GDDeJYKKmhZR69QkQ| zzgEllKTs1Loryvj^eRmJ3))|?nPa2mMH^{lew{g_V(450n}I2@UJUgr91UgQhZn65 zZnTyr*vII<2HN}}0V_v3e|pif8q`ZsP=5dv;{y((-;}+6j9M>xu~H)!f;tEN%DcIA;%p}fWk&NRTY12dGo=#yIJ^KpFsQYa1vFb{6E{CYkP{9NIjnI~ufe~@FG z`K-PcpiI4?fPJrr@psHCQ;+@7QR+;pT*x~$c$OiQgX#WnVluXqKt(n@=R2lRgYuK%N(c6*35*Y@4sH0!{ zCLA?3bJRwP7p9vQW&$qc`Im!qLqKGsXL2Zgd;DYdI6y4-_&0%eS3srY3N!4fwEAa31fSTP4IR5CHBb@LU|IV1Poo{5=3W0lXcUHd5U5N^O<@M!5T5g7kYp zG*XxuM+^sCD14iR0t_hC_Rq>$Oh02n{kacqx{A}q3~_={)J#R#AfVKT8=^%n`a?GF5+lu7L8(-E+@V|+MfY@5jK;Pk>bALTU!gI zJbE{O9Y_ZQVu{9J1{(u7Y8P4Gg2BK=2l=6sM?q!>=|$No77D)r=l==f`F&iz99OvN zoQ-is`jyy$+7}I{Uk9|@fJ(_#=lWPdr5tZt{-M?RJm^uK2Y@;*NNA+^vAqN8BAHhm zIV=LH>Xo=AqZb8&9pI<2Zs)&T5`J0=&x39vSx?Iscff}#gS?mIP~Q@^bkM-HW1H&H z5~);9C*6x4(x#;^itSg1;u37;gz#wLhfC>)hS0W4Koa`Uf8#XxU4i!tI6O;8J)Eun z2xun+2wQz1)zAq0GohUyAZ&txl*tD2G_=nJ2wQa^FSP=)6WW&pgkydn|KU{VD6}U6 zgcABjEblLp@9Ca%`XN~Rbsgooq0}8-iz}$~qQ$5XizIamSPe?Do|e~EK-Zf~-ypn! zC2_we2zth-w9Xx5WIZJ+gItT&9ykkmVhOU!Ygoi~q#r0r56bG!V2N~(Qcfq`h4u#e z^B5E-v6(Yyy*7^i{1Mu7`jTiexSXQY>^DFi48_ENYI>NU4irj1T=MoG0RBwCVQ=Q@;#hP|>3r@MXZO=Cpl$-~ zP(Y=`_HvZhq?7!R&8(ZCS6Lz}dgC1%{r%5@{}Ql`6l5M9sXbM%w_!GAfOwZ;GcKcK zOE4qlFfxzcuhjdGfO<8+{D4ZyQJcO?>S%N+ON4KY%0KGg40wD%Hd4F*Q&HkV+4w%J z&IV~&K&0fX-h7l+yJ;tJ@g`9B0DM}GV2)k;2m=5n-r#8IE$BZCOi=Qo*R*6*z0a2M z7bs{GE#t?Oamf~7p}fVANg0R-AF-L^r{qOr3h(AzzAhA31+dQL7s(xr)q&7zh-RQ5 z#(c^#Dk%^2QjXmM8KVc-(p{lUV_7Fb`xrKppKHuVc%^UVpe~&keNeQy*`TffZC5~b zBRjOXD|IwiDEDz5cnFM-0v4O|bpFKK1~n8fe-@lmP@HqK%arp#Q{ehBYQ5-7N?pRi z-i1)q3aFIOh$!5NaC0cS2e2CpviQ?cgE&@<_k@wUx1y-AlgXJ`I4uQ%jM8E!)8L3ClV3bnx{Ai+F=QZ@k{7Fw~RNy z3*ASC7wx46Us{D^Q=nKLBrCDRwX+nLxK``=3GFOJ4kj&{usoa87ogZ5BxI9{l2q#o zEQ2%J?99^q|I=2)moFOQuU{Sqxw^b$>R4Gmrf?d8}E zQ4KDV?sR%bXf-By)0GQDD!u5-+N}NE39Or;7$2l(MhP9xYsf?HhjwqkVUxaC{P{S? zmD{q6CXy<*dlr;%WIpzct}nL%&!G-~MKT(FLzAn;e;0~xu$l52Dc;`J)&pC|1N$#X z6>o7w)1w4Lj9Ad>`_+M86>v=VP=Yh-9dOzL?;mhD7czCM^zBcfUrAqp9lZZQe^5t) zc7H(S>XPZY&K)ZoIOQpnLUbVhLQvKOG}F_R$aO1cKih#H4LF?rxLn^jf?W4v2Xi-$ z0rgAJ{tT#GvU9-*LJAhAu4qU)Ukn zr87b81zIeiaxE;#^;J%53gylUpxpz?qJYLFht;y@03IB_G(@#q1DjVG+@GPS8vPJO zM4wl+ycJBHPDu|@yIP0C!4F=!us;^dTCMLX=Yo^8+sLzAQ^^`gf#?-s0YbD>xqP+8wls`~wb zJPYmS0HNeXOSfjBZ|np39VkA>rtKPUiZoG7Rr=RTejGJFdR(i2E)D(xZFrdTf*M>T zbzcBd8(MAGcw;7u%I=j)FFHxnU%(t&Kv58+XGRI_+8fNHAMiT^PKo;dfT{0AQVG@m z+^yn209H}JG*VFcq9-)l9|yza29RD3h-RreAQs9kY(I_yKM`=)e!xw?qpJI-p#392 zD0$J7>cs`40aqE0=eDq^7kLY&@gh~}4Y2c~(?O2z))eQnZD|E<9yUW%gNr1GUc4Pz z^&)TjbY7&=iw@TGJ(%M(C>93knNfll7c-A%pxqU4O0-`Oh_+uv@;Qo1FTMrV7Xi~q zfpekvC}w*s`QwWZvi>FOj8V`!TX_o1e+nM!9_BJUfc++dXcx4IxkX*vAd>! ziaEXv#YaJUW|ZK?FPO)7(E1}>9wpl22SnTBBB_UFnO;l>t8TzFQsA8EYR$IHLoj(Q zNL>P=x$qGXm&ox#&#Tnm9|XpPfMukB75xt8mdGPGI#3@5ZFxX7Qk;5@Qrjb(();<_ zL3=Bp8Yxb_0;jr2%Ao!>*&_Z|;QbMBjTGnRYUSdKGyL)+G3Li+&I7MhKP~^g0Jlos zNUay;qcDr)UY?jdDD=eCyN)cgJfK6}Me3SAa@v_v|U(@Dpr9&Kg^aJc#l6se=!ahi4Nz#(W+mx6O4@LBug*!j>R?jGNFBIOS>GuT`JCj&ViG{*DLH&Dx&q?5T&&oR( z29y~x)I%}W0<)JbhD<;iM#BgHpbtI=fJ1Mjt2huE2g^B}-mw36(;G6~IO5!GNLp_+ zPR;ktar_)daM8`s>As4?jLan*C$kT&IGlPt1#M_!@>y-@x!|&rooL`8PNXt}l8Ww! zniECRX~wMFERyN8`^j1DR$YLT$7f2c-E&LYO|w7LZYBHU!yY)6bfG!7GW0dC^8EqWpqS=AayDvtO(YzEQwG~9Ik2?t8!P5|!)EEp(N-Fhcp!_bNaO8*|WKu=Y8 zwM@vwT}9LUp5S^>TGJhF7hnz}@OuKb5;>rm2$jnBb;8wAAzL9!C}TkI^w`z?Y=E;(K_f~vnxmfqxf=U3J{eEoIMua>nhVX?llunE8| zQOnQAtg$;{(~~y=^XkHwad;&FA_9MfQsr4>{4tPku$l65u?NUNoF)GkXfGJ+5Z)`Z zT*mNT{YGqao|aM%;ZkuUy(zy?PN9%~2H4jIDa`F7L5umkgwV^&AmFRzIIKyQ7Jaqw zK2Q6DttTo$C>LXC9qT|jZ=}^W5Cx199|V>FyTt?zo<1AdY1@q+LxB015kYs zkj=VxU~s)`1QhP(c~h^;rf<9lb&ujc@h6aH$K%qv&;<{CT2@)VTEK`0iUyK6$8w@r9k z-BC;2L*nV5kl%J`1^tv_xeEX8196AE(GkN|OGMwHf8oy0Y2m&A_7zygatu-m3%^r- zf%s=~g09=8oUt6jzstegCCQ{0r7AG#3@f|k4{MKAsgbT1?uOAputLGX1g)>vApWQNlrNV_DNw@<^Vl*wne476tA0X0$& zlzz>y*dF6oCLrwwgZ9zrJY>3tv=pZ*ES z_;ipZW|Me&zD5ImdR>HE`gAHJ;`deGF*g*HLlrwR45 z4)nVunPlr{Cs^4n_gf2z?nG2)phLI@>DOBVZpP9-dEzk2^v}tRMc$v(ADnGk2VS$x zsW{R|gXPL#-0ud%#Jywe0RwU0^==pU8L0i{963sfxF2?xi+j?{IXZ*p&Jii@9KB-; zgnN|Y=V(3%<{Vv=;?B`emY7ZA=`1Z4&(RPt%sE;L$($p}$yPta&(RNBKAs~Fjhtyi zYeKT;sFO_qFX&&`#(j>G8TYqC+9k<66Zg;15KmNPYbJi8*pR-U?a6WHd6XZ1HF5t6 zQW~E+xP(u4>oGF!Ni#k@gXVlniu377o7J9@K5bmq`E)fT6ZchYc|GJ>>hvs)2Kw|z zXG zZXqmb9gy~xeiZTio<;oFH#{-!y#0pWLlcZcF$;ySWeoiR>IG9=_hBU0eV7~gE(YpF z`8G(sfp5LAX8nj;6-U_|u^g&@@HU^j$uc8jp9FK0bU^Ji zb#xfG2W7G4*`s1_T*f~Ah{AsQdUsAyZ zoTHQoxQ6IcOy@8%P=#^%`i580i*B1;^ zi3=f_N_@m}VH(;7?Xy`VFS!zDgHkN4#DgL2l4PE##7k(1 zvGT3W_iUATt;MoY{-6@?K}u7J9bCev_v$gS5|d_pdIrt;loaRFO*X5kbd~dI-8ARZ zry!Y1{GBE4QJ;3xXrNF3pC=0`GL?8Wqty7c`Ty|gAtlqN zKS0_g$vorJjC39kd|J+$N%Se|tg9E^g_sPXC^qhaTx^rDHZQY?*5(7j31n^Fj?dKZTP%~F<6mU#6fjHH?=|2alu4GCP`^jroUMs?MmbP*BoAY)$k+~=9qacm zFk$MqV`PJYIQ;EiSHA~TcCqLvC1SCH(in@RnOHo7=3i1M7 zGZvqLv`dnCCKf-YA;#jXHs8cpG@bNpi+LziP`^E_F_`-8;1WI^G{d!-q#2){L32JO z#rgD6n^iWl3VeDS2*#%;AQ_*&Zi!P#Jbjf$1AST->(R!igCH57eqgzApZ-J3N1q;0 zKHJQ1Az7bZ@IQQ-ir&q%nT;Url4PFo=}=(!+b!SQd=q_&TI}it>-ViFdc1!BZIiHm zPq&Dz-|hsmelKx}#<70ax5d@^ZN|R~zwo?q`}V*Br;g}ZmK8ufzsI)h*OXtPI>};vN!D_tj!CP#yup1j->uCQu%*+<2g* zDW8E-zZ&@rlunRrpnPBxBzLZ3l+4QaIHX;Y%rk-VHVrXQimaK$KrxlCm&I7YgUa_a zQku%=;1WJPp=D-+Mw;>I88qipQk+k3wpnE(tH7syFLpkC50a^TOD%CKiKm~_XrNE4 zRd+t^0m=Auo#n=TdW-Vu(-)LapMDI<`t&QCAnwzI5wdp)9hyu^7$NVs782cw5weS{ zk5B?v=XT56md-jyt=2cx(lJ)g#g%fXHSrYgbS4a(*9$wy1-NwT2J1F&>B{T3xSusRT z?m`{ulx84;nVIloloC@WNPtrOB_Yw>G2v3^l9Z< z&Zh;Cj8ErTZrrC0luw_oS3Z6E9wh72cWi<(_K2KMe^oMldQolqG?{07+6@@~cFPKD zCef#;oUUH53tfYvxXO7zw%R1D&M#R+tMp#^!a~|n9*}PKCoA~BOW4>Qoav+r&Kd5{ zID@BLLVIxXL|s(wujjEAaE3b`#owm$;Xf>MJ$xJ)yCs2PD)>2h*=i+T!I!~S$qN2H ztR0jKEzcgPso=?TU`P5)v%5pHV+Fsgj;r8~Q5`EI=uR%0>nivhP)sm7N{L{+@?lrO zNi)HC2F(Q{DJ~cuTZ z*SFYb#;>M=*GEd@QwNvu=}bLFR&dgcPtTw^pOWHydZo>(I@Y5CpDqN!__S<&=hK)a z_9yZ5O&SgKX?HM;Pv=516?~fI#(i2&`Sj^2<+FmPH$W-O9C)8iknGb;P|O&)52Rg^ z%rib+KtrtH3$2+%pQ3`hdcg`l8%2p%@Rc?REBH!_*b08cLbigpvp-qE50|j9J2=w` z6&&|mUWE&1r@@p*+|-z_nDJf`eqLDm4#L@5T02|I9t-I|Po60MIBq(VG2=&oLHPw7 z+{+RhJsiJrWx;E3Id05&MV6NJynhsm_o^&Agwc5aaR>%~-pp~Y$-uEgJQ-LCN&R_C z$8D3>FgmYS$7FK~spRGlQJ!M?3Hk{zRxDpb+Mv>LNZ&!)EkkXJi!jZnw`hyagfzmw zlOOd;;eTiUC+Uj+J(x33J|BV|Z&SK+DTA+?&-}^*%fEubIS;ucvr281O|lh0u{?|Y z6Cf4~AIW7B#vq@SU1Ci)EQiAwJaPfq^`PGi&Ib9bOClq+Q?XRQm1v?b$U8|W9>Fgb zKCf@!6-h9j<}VgL`fuR7li`c7yv(-dr* zf0Sis{i)l?)t?EFO#RtrO{JKiK%3M-`K&*FWAa&l>Oivfr&UI_Qej*FTnCw}WVT78 zAnlT5o~b{pXvmfGd~50y%elCf`k3W>T}^SVt8^1r&RUimFX!o?oP)tK<$Ms5E$3RB z0Bei-=gRqw1Tp4df=@5RpIDJrBTH{V*ve>4V23~cMQ=XBt zZy~+UD~%0c(ln}$fh9iuLu2@{9y}XW(oCaz2F*39q_{@)9Ty77EofAyfM6Qc%g`{G zpqOflyq?65k_HZyvqq+i;35tg-H{Ph;tb7JV_-g0udXTKM!*#P+B+pgEaN3wWt2PQ)6M!xb#zdkf+q87Zf^|-UqwJrH)a;r41h=jV>k4xbzH~ zb15m#rQf&{h$Zj9rN=-pF749PxwNY-^C%Keix!J6eF6;Q(xZ@!ONX4{(k)s(y7cNy z=h9w~tV>VZ1aX&|i?@@N%=ldfX_qAPO#B|FAvUg)&hFP88mhZ2SXs#o*Bb-h{sjxW z!67QG$tbcca&I;tuJ3N-QZM)ye zpZDfiq;@Uvr1Kr^l+sWHu))$)o&9;AAyD>;I~ncKi|m$v+N=}$$>_jrd=qg4N?QwE z*6T6{(%(K-mZz;nk9HMwdDzal4{9SH_Q73ah1Q>K| z+-$Vbq0O6w&m9y?d+f>HAf+KS%+J;XnM=;9O~S_*4oO|?L9K>=(_rp^bhfmPIQt=F z%D4*M&A8ZNkvcon&Q9Tz4L{j~!}7KMh3+qwk7Rv}oEw81-`{5=)+A1%^usUj!z{UC(da=|dDF+I^*A*oG8AOx#Ye)w*@sP75 zuGj&2E(c)pEDVy(w#jx$a(+9d^4Sc1S}a`yJ2`=!ENf?{umU98s(1+F59m$qQy`f_ z-vP-Kn)h=ir%E{&qne)pm}Fl;GRZ!GbZ$#FUCBxINeBfQ4J`Ouuj8F(8sUsuk506h zJny1Gp; zxfx2+f8sYLH>2SHhJfwlW?0hX=5{x^c}?!{WE4M$;Llq>)=YI?w|VnIuZ%eOBx8qD zo%U^cPQHe8k4l{C?0~de&h413rTqUt)u~}qy5WF~s=k!@ajJ7sJ2%xyW+hE^z6Q}u zb(qBSUcrmu@XXj#G{hll>UC~B)!t@TVmvif^W%7mG&7z$gXYFlq`2`^XKO1Pc?ILC z=Rh#yshZcjI&oV;HdA?1Nj%+2i^V!I0t_>rS_R3Br|z=c_z*R$eAeAa4*9IR4ItS% z@n4(3Ind1q3Y5&cI~LL|N#>cl`y37N3@)%{;^Wj+@o{QDd!&1C05WRd)6TDlk=l$? z9ixO_k7>E-SJI4M&!9QKlH&Y&tIf@;RKl-I+B?7Ac7yZlB3tHc5>KzzV$rV~!7zUP z7bN4?RcH9Mukz{F{9NbPJ0MxVrgq9^kxC5x%{X;|lIhp&kakHj&-nF68lqqKp5fQS z^y>~u?Ts^Ij}#5M{>kV{%jnyhz|!+rD8AMvAJRd&&z%FdQNhS^J%^5+cw6!|xeDCJ zENd!UBBR?a=gMU_=!=E#z1aXun}yhmax;GW^Hz=BAbeF%$#i8GZ;}(x70Y|rXXmpV zd}~iU^;`09{ucI92`L{gmV2NxY1nwi)9jPE`27s5?T}@VR@;)EYmdF`gt91YvFrsV z9hm24NCl8~%NEOR@Nd2Kmy=Z-HU`#=(F5|7g=_qdH`l|6HshRUp<%M_Zw)9=n;gx0 z$PSx!y*g~l3KoIuAu(iZ)p%=M6xaIhX?V6KNGz-~R{pc?0T z$U$4UQz%@p9&%ns7yk}!m=5^C)z7f(jQ{>%nD~Dll8OKKt*I32?r`V6%4hu7K;LNE zmGWEFALV>g$t>qjkakHj&y=%XXD#P`ab>&(xiL^UAv`F3 zt#PMOGCazaw9hSefl;EmwOQ$+rvuFH)YY_PmWv=Vw(5#nG9!p0LtzvpQ-Vk`6h_h+ z6cjrGJN|s%_xhBzdBip55glB-t&EEuJt%J{+js^td=kwnvk-Ia{** z(%8n|G0;s#Or9LC9E+;#I$lnWqZqyzsb!!INHtrSI z1#=dCAm|G@i|%1_;R)X@xwiCY&aW5AyW25H+6Mane5QU_$w%7V4}GNF{J^j>hMwMk z1xEhFW~StPJB@kPE0kG!T`Ti)kC=xa9MADtuVp7NLA$2(PNe08{i98=(P1?T^1q%6 zY|H2P%#)iHt*npRwWB_G*U9z#<#}&Q2N>>ekDRyT@=u-^fgE0a0qcqSvU@)I^A*nU zyD~k3$!<%TjFQ&r>Ul@>!7(Vv{j(cKU+YoP=RSw)k8aN7%?F~swt1>6etOzO z@bxbHJHs5FS3XxBTf>ak0DM=oD}r=drFoFr^k5C;>kg8Wrre2@>tg^+vezM*WG_N8 z$@rRvGm>>hvKxbBHw4M9vB`Exa*};A1lVjX$&)-NgNb6Fn1IX!8JFT7|8X}5f4iO0|x+4d0sP%FpVlyEc+ zer0*C1ux%GzEVfi=)k~ep&I=m+34N0-8FO(DQ@ujyDd-wvI_?FrFzj7d{k;EBr_ZTvTHU|c~eO|T@A%b zcvNZwh^FWL$r6JBdgo(WIQD4g_NHNu=$k^aJz83~Y#J^x@=UnlrYD%YB$<@3=v>ZP zh!5tUp8|th%;Kmm&xM+aI(1y&)JI@^w;Z+<*Yx}InEs#?Tj%KMzssDdaWM0W?5T`7 zGwQ!-tIBs5wpH&-N)6cWp+7dm^7~i;gW@LXfVSg1Rb1Q(4Ma~>T;GT1oDFQ{&e>YH zQ?Oe8Mv1NCF!oabSj@vdr7yk4Mzjs2%|hBf`5wP7>c^w(h^ES!h}xqJH7|X=n&Df% zH{tCm>t*(c(Q-+ryy80Jdg>^XS&l|vloCm47N;4q!g|t_0 zu%@{t$n4mpcCxxX%x-`@qS>)Yovw-5r1lv|gKSdeX4j;aOy-(YlY&jENx>$SDGti5 zE)$H8O3j-)C9GAI0f16WAB}fPS;8rn;x<`POjjQUP%QhgZwD*IvIWx1Dy@ce*&xXNM%8diaof^o(493MPIH;4TVuz-h8ftiO-OS1ihhfn8& zX&ycuW-azdD);c|4~p_CM*?aeJ|((aCfjtb@@renvh9^27P=LYw^wG`Uw7%RpY5-E zG%CqAF|o=X_FNRB{AfA4F)=1GhPas6tP*3Q#w{);N+wQ<36qd9VG=SXOhU#)LP8f4 zCJAH0BwDMGIujFH@Y}@1dV9d=CiSmk?uiX9CNghz zF)I?6cc(t2oUHXH7wdz{CN&>c z?u67PUY@qO9WD_s2NY$zB%n54h~m}_o9-;};<7jKvfC0(ywvTQt%p@IUiiTF5$h7( zgJX zVnykL1l0O~s2PPgw3Izt7(E={#M8x52x(>%at6(fLP&9=kZ)``rlK6dD5U%_9y&)M z4?;4dklEIYdq_OJ7S1wD0PiZ7Q|q$B-9TiK<(B#XnEMX+s*3FYJ9z;fptOj9HP|bV z5UQvVjnWhh#bA4crce|DV(-C*g+=VT>Pl59F`%+yTT$0u7Q3sivaGVM>+1je zJ!j^=`|b;v-DUruU-*#BoB5uZGiT16IWu$aeU`!2`Gta~BT^2OIwIF2WgU^X!UXmR zV5NY$wSEVwMia*A*1Ai%v;zgP)g-);C37qb5M3j-(#C2=JDc5co*DTVyTWI)`=K6v zKD$6td_MbPq}CcfpWWJ$wz8yYzr#bx$iH8(k0bTGq#i`z~%EecTg*qq>AEZFR{CIgM^YNKLM=8=5jI z3|F|T6UJ;a?r|rKV}%z!tga8L$MIPO(bd-J`w{j*b%X>7ngX~S=q9tbMN$Cb$;oIu zCa+5vY|DDN#%Gy9Pq-PlLSC7$LT2AunR#J&^6bL{SE1_EDur{CSFne`q*|ommfG7R zF&o=fvXtUYDz&qbrA_8cOBWI^x`eI29ch}RvFMoypoV&}pQWOCdd6hiPsCl2ge$it zG+gV=>;MjAb@n6A50(YUn*2%PpDdtJea+7+=J#+FGRNnN%rBMS+<$)q`e|$2{+sVk zI}Y8`?RJ+*>3jv_Vr0NCfPDD2z?oi`63Jd}_^P*)Y>ibY?lL9)Y*e+>@Eva*t2m=d zkt#rHx%p{Q0=$IatIUV1Ip}=J@KVzizwZQanRz7yY;_4HCi1kDgW}p`H93=XqsCG- zk*+jgB7a`RCTJoFQxlm2b0(4yXClYi-fclkzKPrdfSSlD=Q$HuZGoBC@T6~h79C64 zs4W3dH)?Y&Fkv4r1X!<4J5@XT*bgadA8!p4Bwt4s0NH55AiGh+NeVP|fvv%rM)yvO z#|>Z6d8RFOQ@YF5aBlfh&IaLTCQ`pg3fq|Gz|#Qc%RUu+I#NFg*(sK+$rRiAeM3N% zBwKC({@^rt7W02&K7n|1CZ$~lO3bzi$L^nc)Nr0;$sMA4@ez%avyC#m+z3NP3=< zehh@FwL=8d`t`MhQLPD6wN8OKwI;-=^~bh{RcOsu>+CwG)~_I?D}Tm>TvB;U2;6p` zu*F05J*E-Mm46&ks@Xj)Hlf*P2%and3c>RT;%%g?W*3GD?8^U>fVuMboKEEq<8%nSr*NWc60_{k84r77?q8lwWhLB6Xz!ksk7-6DeUT(iE5zDIrdz-`SS>>>Uv4 zW&qSultEKfq=PNHRRnJPPTHeLR|26T{T3+|>9DYb@_#3Iigff$;wjQvq^w9Q!UW02 zVgZniCJah47O`ffNm204y8p7hOfnXHm+s5L&9_LkI-g*^sy78pW5IXyDtHr8M*)mi zEm^WA)5^AlEir?GhdYMi6l`V+?D z8&G}wv@;fbUttM!x}hnpMAtwoDT2`!*|>-H8n?GuJ!4CrtG|1?Kdg5U2OcZU5JyCEt{s2Y~8* zr`b;LKej+`U+Vo|r9JBXL?Be}Z$L`*{;w9BFeUd1o_hZ`!Bg+M*ZX>(by_Z23Y=!@ zJ^E3A=yM5^kZLqxoSKqbSP@N0)K-&hN~|lm)-sig4mhu44JcKnt~4OiS{WFcXTnsb zDKIBfLYz#Wu`SJ|sNDMw_MPKo`VdlTOWIj}*AciaS9Fgu{Z6nn&%Ne4nRXA0DE~*{ zk21X$D77Wak+Qbrm@q-IEqMdTMiT}l*^=JPixZ;Y`?6oMy-cztd_#7J3&~9!sS}WT z-0%h5DPY7kK(QHH2TsWx>H%?uZa0TsY+wU?ckFzSFEf9J)8bHl zzyd4h3x8SKWTx55opp^&+l;!w`Gcsy6;1+K#)8wOV!mm%!$o4P;NUw%0}x$fc;_AR zSc=y*Ij)_LH?2GBU1t6W`g&WoPU>A@_(s|%%wI~9OYpAR6^5^+f5PyM`9Y$-=c9

TtUJEt#IzZS=t#NkxbAFf6EQ(Hx?Uts9o;#AgYkMI%ftS_;frG(wz3 z+ibbW>>03Va{$m);zgv?q8(e1E6t4|a9c;Pm9&rQijAu-5hq(wX14_-= zZQST;s7XnfAlaNX0@-N7pri}0V#nJqayMz;4Y)>(!JlmhM+^59X@LwEjllP)T8)51 zHK2DH3+@x4(+Ko}JF!fRfJ3YU!Wn>al)_Zm)_ns|BL-lV%%#8E=C?@2cRj~p;(YoF zq&la92+XOaGN-hd^D3$Md=ztDu^3kps8i?GA(vA|hge3E=hnq2)4A2lmbbE^NS<5w z1E+H?&tO z9HNb~Nq6QdshmcHFf}46FlR&vaYp1x%f)82=DS4~1E5CaGo;jr96B*qn(MSbjmS8# zm1IPEVI@O50h|i5CYQ@mr zc2yVXL#}m3q=PMQ-iV9@PK`(y7cwFh0ICro$$FDvt4%Q?PB6P#elixEAfl%cxeui3 zK{?cBD_D9^FQT-`d}U?l8xi%O)QGskMCEEk_PmZ2(}*}krvnm3Bp0Pk<_9-oz6WKE zh?}*(5#hl~lgSM9P@G$4-(q^-gW#@r(4}wjUu_G&S}E|A2ulpD$7vY#Nw$hCqrxx? zGhW8qdH+a#U=`PZvE_!Z=bvGbxnLXbJ^t)9?q}ae!BX=Ie*XgCQnLZ6ehuvD%n%6= z@^3}n3Udv9uQaS?nc=qx1S{sjeHrqWno0P5uGDlmQkUDtt3btTv}2KXrw2MJ&_Iw_Et7r8!5NZ^EV-X3Xn7xT88pZwQ(EV|tLPAmfpAvw zHk3A*k8KOSRSddT@7TgkQt`i}V!Bp;2B})bAi}qbT1=~$RP3xGi&q-fsaCPWjTBNR zD~DvOcn-?cwc6d5x3Z#0cCD@fPOV}X7qW^=0930;lJ#a!TWyL}bb?73uG2;Iw2EJV zRIQ>zc?Tt2s}46&uv@I`e5+WqnVhRtbcKn^)heC^QniW>(FYYf*J_?r{4Y0R&MG?B z%1v9}D%POACUZ!jhhi0(EkBQ&FJLzY+VXZbSKjK)Zv=T6&8;>3g6mYs3NsP;xGcf% z=*<*q5mGrwtu^~1b#!R7_*QRzT{dn^@cT5O7>LwGNUb+R11yq@Tg-sN;SXL5vwJW8 zC-#l^n98bJuUjs2_3Kw|F(Z!zbQLl_@}bSWy_Kc+nB%?ZIiCwLzk|KqloR;nB-ecl z6aG)+X1?wkCZ{It(NK(#s z_EuhcSUI=3H|+@_rJ%nBtjVmlkc6PG6G68+TuI*qUPZD|1Ra^bZWac%yDiqDO}1zg zNcCvMl`j^4N4`yd*=X0rZUJ`)XNR$X7rsRp7jVLK0Z)Os1)LDKfcLcAY({JTu4crY z6bPem-bG4xH4|)aGY{bco-J(gu=jwwh~;7L*+|(n++q`J_~*hO*YGC=&ja+2k%Fz_ zHz&*w6WF`B)_1dV-o+h`RHF&w^Z>mGW%y|_b8Izy^S5<$4Pc zD%V$$Qn~gIiz)wD!Bei;_YqIIo`#f_>&0OLE7$V{Ou62H6x^c_PUZS0E23OawZ#d! zLX(|bPq01BJd|?%=etg>KZ082>JS0Bb`}`rN|?$u1?J>Rh?DEdZWPg)FW1TUJGoXo z;N-fwS1zf%#RP8qNZO-Z9|uC^`d6e>uHRT}TcO~~y%q?bay|7yC)a66S-I{Rl9ziR z^;Q8>u1_M>Xu>#^>o!(IxwhSrTu(ndS74hDrCi6p@8sI!w@$7O5s+)?d(I9JrgBYz zIk^(z zOQWRJZfV}#r>^y>J1-^mrrx^?ucE{Za(ocpLl=}e-a{&%)i=i+Ld+oslWB9 z&l2kIL)3gK&+_exj`fL;-0XUNkr1~{@$Rlc(@&e_hvf>*>A+jh!b*05^{SAI=L)Z# z1@N;Le3=hkV!=lxfg1?^z=D_i;Kdd^A^>J5o-xkX>UgyAKJfAD1dmq)@h^B-!fG$J z6QezxH)Xh?SsvgRJ#E}nJJAPkw&0D0+Hb8{JX*X~NUAC@Szzg9+s>zZz;_RjLk9}1 z2JxkS%ECt6?(0i5zqe$QFdfZHzkI?`;A=J?#3-n~M~~2!yNleR?{$Ah^+A2VdKvXS z)8e!R$9MQGnhv!X?M3TWOM85a=84OB+C`7lA+`X4w`dlB>=fe}K-6$KNYt`~1@iol z2&3U5Obu5G%o#31oZ&jcvfby1z=AMzg)>}TRyxDA^vGOku8P2IBZVy*t}}p8!*vr< zYPgy#wyjWbLGT1m!}Y!3X}I=y48>}=_P0ai6IjD_G$3lYCL`5o!Z|ZOV9!TZP$$;RiV1#fKXo+rYTgyRH!L1Csab5Q1fh4TY^G8@Np;9 z$BMw$&w>{_yC)BDGp^g_kg?cMc>J>hTloe{mc7*z&fa$%o zUPYmXaVpefP==o-b5-*~#hi0fgYVIN9lSWzN73Duh;wd>Uxayw({am|eUau@b_Sa3 zaYKonpsNIbv0nU;us!*BHN-Q(8nYN7DBN6oh*(oQ;sx&HE< zAa;AyGi_;Nk2=A&%YowkmP1rwpv=qn;fO(xatk3P-RhUxI(pa^x{dw`E$C71dq8b4 z^DKfrOq)N9RZ}lr_7YUxZS=U$-F)ZwOR8!*L_jsq`OM9C!c;X=U`{m&ajJQ(Wnv38 z&TUxk0zfx{d#`b-d4!c_pI%hWql7K0W(g2F-xnjL^Zgi$^`~$C7U7So>8*9Dc_30& zHGd8h*!ez8z*Nn0q#8{ar>c1`E23&nwACc$JI_GC6i;+-w>>QvFlBqK3>%cl+lU(U zMAxCJ(9MhmuSqv~qWcXHdZOzPi-B+_x-4xnPuLdx6W#e+7+3 z`9$}7;PgZ{j0>IUc7KvX$v_m6tTz!W{*)74Cz!65pNs{4MD#q-9fL~NN~BO2Md9+U zi-;!klI7Vy)t$eN!qrnPceKmn zGfv)r*uGlxguG{rn<9J;;*aQ{Ozav;#x0gC!LjGYJX{`a1)|-T?%0#>AmE!4W_W3r zM40WhyXsgx!ftlKorHO{6wFj*=8`9Gy&X2QaN73>Z8mi{a8krK=*-(DABPv_)!MH- zZ;y3yrqBDe8Y>UKYsKDDqrv6f#$#U!ROZI162CD8Fn$q+M0JC25<8>)o(O? zKzG?+_-&e{o_UuXTnj3-pIa<1zWw~^L-6eE=a05DVL$tvnG1UUtTH^B?bS0^KFviN z=9^VtaW?#f{GZVRzS$C~yPl%C;{(7$E!J7mv@0Sv2mv1g?)Nkao<*uqQhW$_2~un2 zy$WGc_aLxR@j+mvl6NbBYJ(ZqQyJrO11*5?p#*CW)J(pZf`i&NGUMV&D3OR9c(#P; z4y44A?=Ge6+uwy%p5(oT2Aa$)i*P#-yfqc7w#r;vi)X)V*%C_S(|%u5DvOc-523up zmM+$l({ZK`csbP!cGUOT^3A0FsK%#0aV`_sV^1kpMQmVm;G`@UR9+2;z;P6_IssJXWG)#eyhxXv7@t()PWklIag|+%s-JD zx*nwUC(C?;aazbR6b(yT`@Nt(>@7Sv=9v~5Kg z9`Li#Y{s95zT*o+_8$q}+Sv)VrT$Ixd0%9-7hJmye1*Wr7a(I7$rvvg=e~?NxvOL> zmW;WWAEtw3{45ziUV@B+WeT79d(Xp5Z1&f_o`%->^UXKLdyg}?6Mo@+dH_9UK83Z( zwLs@Zn9k;AV3(TjP&oKmPOG1hnuHVt9gUK3gn{-Gs&OLH(Fn zdn&$e{eWEQgpA!Ax`ksjI3yeVbwnXsLXelS zMye-RWkuwsfO+#PRO~##^KEIu6O5ms&2utxCw_%RbQ7j9ebY?;@2L#59Nk~0^;I%71i9rqcb&FYd7d+@q$o<@}YSu)CK*VAdUYfp|{1$Wi z5eS~x2E@MGT!YPhH6}|nc;W!0@Qy(jJn;w9<9av;SD%WLzTZN2Zkd{H2f{4;Yu7Y< zH%MXi6rhMW0m8&rgTOj(M9I6R)-%@`T9V^M~|?T0@6K^xcVcP8-I%$LA3ED}Z#aqv_e<1PMC|GLp@mooT zAw`lkW>!&x#CeQqmtFmLQr(2IrRFO9CKmhs^=N6G<*kbKUyfizpAU{Pfy>MUkT~2X z;_zzpxKvh&-(+E#IUK1O{Zycxa)5bYg&8cEG5B4CdJv+6)YC{kV-{H?--MKjE{Ouq zqD^XT-6#8YbT~Uz=-lg;%UssX7oOjY%w67PrB@)8{sB{SkU9jZ$IYr@Y?Evg`=P7+ zkr$qK1Oz9nKJoVeD)ARctrFrX%@E^-=PS&;C_r$f{JsXi8%?;4wISlbRTC^tjO9YY~>7ggk|G+1-Vl zF;DA+kejOaLD*y(En#9)#RD0CxH-+nNhFqA>@nqhUwRvqb5ZRWtu=k?vHKMLwal&PM7Wq|kyJ2F|M) zu7&6iXkn9Wfh#53jm+i~nj1|n2JEZ$G?>^#-B5~JPC->G&1U4=Fr}Nf9nRh0y83s_ z!k#e7w-D9mQx8Wjd%!%KTlsk=KCd!d6B;bTi~BD#! zK6wLqcKvs0k7w6E0ikEt{kKw^UK)*9MvHCBcJR|W|6#%N?D}S)^jc*NQZPXbVyd@- z^a&V^Jd_RN^z8a5l;Nkz{L8kRIJ@R}paUGw_I-1S@^aCEXxY?XoLtWa zwaV2Y0&=Yv@l&pZsa#WFPOgMFx$b6Ln@e%IJAo13Ik`r*Ik`@cYy8x4lY!#j}OizODRuR_X0%k0LLQLXu>#^>s73Xa=j)+ zu25tr*Pgbg-XO|#jmMctef=G%Rjv*Zkn0=5H|0v0$~6V%>tSvb(V8#U-~Zs` zI`2m(*IO*la|zsbm#{^-z5s;EwbehJTz{J)*E0oAxyFG~eZ3MXE7vzub%=mS4>g2Qq=czRQ(#V{ggBArx&a&<5NXxF zoJjxjvlHo-{<);`atYk_qqIkn_W#9+vSJB7Vx1FqLZx z%*mAyC)dl}Cr#PaMNMY-k+Ta;^u2(i4e9)^_4b#RJY+X$X= zeL(P(>q|&kxjwrcxo#0K<=Qo!at-5Dt|y~RC0bjONsG-SZ z4a}7iw^CZygLc^!?Ir*cf94b4EW~*s;>i3LVb-;2SJv65-ap+9>sq0n5Td3NWrlk>u#5Kg=KShdFa1Sj@DQ$ za)4LahW=_zUAbo#-vGaO3PwSXYw9f0sg1e&9`QeU+H$3g)uk2@K5cp0N|_?dwwTuz z;T4qu4pl!M2#g2%2ewBA@X4}B!cx2S+sePp(hlXqte8hHZpUfy?mSpJ=?GOgVn=Ns z+vRB8dFXUdg%`G_3iq_QPkSYuV5>2$M{&|(*#BXOqlf*!Z2rm32_GaNDInEbH1;zchni+nMkPte!?zn za|zt`nzTm){FGp6fPX?t4e;|8>$|G?mkXW-_{_Gfn+Etoq^tqHe>(>F9s$z;KZjJK z3FFiN<6M-3gGb$LyUw>23koNmCUmgv=sK0F`dMq!-+)}7*`sLP;S5__~Bb+(8W zWWC9?B@%?C#~~F~T5}-;bMsOW0*^xq!GRu!FvUAD0NP`NywJ?>%!Au-qPX4+v-M5I zHXGl5Za)p~jzF3qOY2RMEz(y`ej4}$y0z8{nCo#Dixym0@RzZ}XK8N$d@TShP67U4 zfgn4TE9f)kQ;TQR*qi_!oR`{ekI7{}mRnP-pPo(n^lsqOGp4^~J^dn_7zL|rGF5>h z*9DBiDtY#~!J5X+6!VhlovGV=-nnR3S{^>{e49mN9)mNwJIn{2Xyy{nJFf&#pLhNl zDSh5KND_YDnbqj?&Pk}G=bd|YU`>49d5LX&5~$qs&gV!epLb3wwa+`VRD}vVRSdcHGXO!ISAl2ud9jXs{<09nNqqNC%w-x&l za?>`mCXJADg^9{FLax(pte6pU4lxN8yXd%nC~Yza+KOFtT-vlgtQd!~R#{wd9Io$~ zJuJ{e&RfYQ1q8;s_NK~{i(NkVJP*z3bI+-e;B(Ip0H@DAzabQS?m1>Fb)%L1 z-19$#g3mo4+?9h+9AJ@*Z8QzJc(WtcE`4dk2%yx6ZMMiwC^vgvDhR&GW+;{pHDX^_ zL=RSkpKhZ+7b{L9b`?+?jInFA7_nJjU>@qRp3Coa9I1}Ua7L_k4`;+2BH;dv??M=j z7-4F}Qee)A5#o&4uFhjXYraca0Du~?Mx@mJ8E!q41_HMoBy7=$wZ?u#jaV*HYQ#

?3wgD+?#BK`{SR?j@fN8{bh2zp_!Zik%H(G2VxbIyKVwKzwdAlWbebHta%_ zsSPW!g>2Zf0ICfm$$E3Htv1DmIl;JVv5W<~i|A>?egUc4Fo&9C z13Hf+{rj-c8wSD2_=ZCEWx)rL7l11fel>{h8b-&X9~uvylIx!LR6 zuvuuY$;=4!P;3~ppEl>&wQ~h}C9@fK<(S~RTW!=VE~n3!nHI`GgO4nnTDsn3T7OWY zf!p165+Vn_8;-AYGS@;5rgoPZdZX{+Hz8&Z}?9>h$-IiKZumx@H^VM zpv4XUZrw?oxZzh4-tdz|Z}=U_p3*yzT~^VJREZmYVxcv>;Xm5)*1-Dh4Zl{(8-4=y zhTq|~5SMhrPqg0f56jJ!Ci|QKOwtYi55VXRf5E|gO=pEg%J-k6OHRwyn+17VNAeB- zXv^g!*6eQh??hF4!~fW!O!0>Q9i;Szf39s}KPLr#rFr6pUx|6cuf)9JAAcB$dBYzj z-p&nw7^XM;;oQziH~e>_5qHBMM(Pd!A&1j~@rK`(cd~tOH~iH==nelfNVy-Z;}B2v zp7y$S1}AyvBdG1X;XmDqa2+sa#>G%V-N>E+L?Q(h;tl_73wGAV%v>o1yx~tfk_5cr zAAuBV=MDdSOOTm|+GlnI4|>CYlYn`{|1wf*#qMqy?{?hbdl26PUeLH+teiLe zzd>q)+2FXQE0uD?-_I&bqNZZ0iQdO&LO;?XM8UBA1q(cQaoOE{7VZ*4?xJ?-O=DbS z2@|Kbv}|}R(=yZqyi}^Ew%l4jZCuYjaE0!M|A$$;;eX50@`nEh2Z2>=GUwXXnz`Zs zvn5KmteTm*B3<6_XM*SBG#;8{{!!AHpbC!c?v)Feg_+oLrx_t#uj} zkn5GlI=SvT)X8=8&|DDV<Ep>o}1d)j~wM9Z$ubaH(H z)GAkp2*~v==_ln%n94N;=HyC?K_Nk%C!I~tFNuLBi9QAOnqI9RHF&wRIYEaBFeSFw%e>+ zKeIg@gAPQ?KI!S?`cF`+Tpc3H+VBH?{ZaU)TnSUTrofzB32}1W>PC^`azLl~H}&;_NGd+x8c>DAzlIP`SQ~l*%=2sCFTt zuWt!|lv@H7orxSHT{Xq)#HA2nn(0|&po_^bNK^?pfy&ZLIFnd|e)X1 ze1Z>NVz2*$H~J#bXUuF1=9PY>PvEZfg%DTzc#`*N)7egp+kMz#TW^pFz0!9x?R6jP z1Q>iD3DgNa$CbWRq*wZrY%9Fd-x8pPHXdpvnRKPU%Je(ac$wC@+=RJk=Jr3B13Di0 zOU+39{t*L#XTMSQq$$GZ2!d#rnU!ZG)9rfu3iBcI@Xf9G-3}Icsd)jZ1og}2TYO$- zCNBz6UWf0>Z7o#}zwrDi?KrUJFptVHT@q?*i; zwpT}fYrkzW8AlVDAdm|zLIqMH)j}AwEYy4kkeug;;B6c}- zDZc(tOP?^WhDzIfgP{CRkV)bv%zdHac5g?PnkW3?+2P{7`PJpfd{3x9pAWsZ%#8ta z?Z%_>ZOB|U(b;iVyqLvTesu_WrycKkI!A+d*ta32cKjk+l|5)e%j~5Dbl+ba>c?FM0s<9|GE z;8ag%BcLS!jbVc4_`ffBj(=LAKmHr6ZS@K4zT-eZbl))osYVmV>G;oMMf5km zay;U!lkyM7uY7Jh+5rCj*9hGUO7-DfaX_ZKAK_$5n94K-=448Ulj+}VQ=5V^{RRM) z>43>jrVW0BUGrmK-snckHm(}jYkO!p`vo-#caDLbdW-;PWt3z&22 zGNc+!7^gCAVnvkcnr3AR`|lNRfn>i*wQTKE2(HI|b#c9k<)&0v>)&FQ*-Zsdl8moOTf6wBsII z*E$Zm+d17jg{<%dWqhgAj_$|jO5eQE)Q(od7PVs$5UL$-A*I@Jn8o@ND1Wu^N9`DR z4)N5EvyigdF~JUmPhe-)@fega&q`T?9|LUIdiN^#P=;TwmYLtb0Mgl3Z)N9503Zt9@ zM#SUdfQ1ph6Q&S4VPS~xh$)1QSPH~BV;7^L^=6x8mQI=cY%;&KqviPj$?yAbLDFQ_ z+4AJRKVzIb$+)y`IFa^k-+I%r>V@da+SsL*M+W@tjkCcYB1xdnTZLCJa+LBO7 zVQtS!O$=+BVH;lzDi_wae+}DVSX)x54QpemMuc2qX*aWLd)^4XHLUGIAT%Q68jEln zk#3{^(U&OR$vh9#26K-^$N&ez+FX9-sSH~f)z3|tyjo}49HNct8coua9KvYY2vgIR z0&}K~5NFyRwOmX>Yrbh)0DzjdE?73yNps8VVgk4I6}D*F&HzG9+f7L6l5u!=1<3!4 z@JG}3z2LcI>@f{&=%IT_m>~I^JdOqu-;ovqB|VTd+!iKQ3o0V`;d|fK+D?wM0_!$< zwhS2*-K#_08V%x5o6*CJ1usYs84Yp^5E>2Q5S{W9(I8Kvw8^|?TkxYnf)Q=c+rnIs zWh{8MKZlADZM#l)(I7#D9}S|#j0Q<6cF`a###h&%PK^f1#^**vxaCSG-Tp`;+O9>J zMuW7r<<8wmjs{r@oJNC$aiM6CKLV)HAS79D+S_VVqCuQscD16PNKw4b5ppTPh?N(bi)oMapmTI0-5JCXe2s z(MpbJJ4YxO(RK?`>rGC8MRKvxY(lpyhfv@6HAHKGQv0>UB0G(x{VEUyBic4y;Oy5E z7U7oeZlhO;0jK@yF^l%=6^ju26^Lka`D0Lbx6z#jJNtDbsMIxch=6N$@E~Wu2vhr& z0(16@5NE&Mw_G%!HQ#=H27ubHk+Yrsnqb%4O$2WHLE5AJx)BJqUw=SK?N@Qw)5?ED z@U&mOu!UFGY%Ee3Cte!f7ACMR?=%6^HM<=tM6`u)>YBaAis+hMVvC&-(@mz@urF;# z6A^94$*|FeZ9@fW!yKv;OkKu;>qPjpVLj$J8|DzXK)9&fV^P{<((QK4w_(AEwjXWt zRZ{U)M>!jIEl4#gH;C|Um=@E9B^5gx#^RNRb*c?pj?ak7wTvX&u#R(`4eM{qo3~-v zz}cwW5H4iH#sjD}j3kK4weS=h<^JzBr zee(v&+C?T^JV|ozSZf{$fO{&|GsE6DYX#`u*a+Ya%>dK>@xHk$44l~} z+HCH(e4YsholJ8_&gZ6KJ)U_!2FF3}XU?C^?Z`XgK|uiY%bYLG-;lGlC&uYZvo9(g z`;+H^b^?-Deb0*PzcPjR&}kBg0KY5S^Y+U%IAe`&gnsPy8h&;C`Dn>_n;D#0T`xtm z-o7_w;hSAzpM2waRG6;6r2xM+2Y>5%_n{X&!_mCIn9q*&yuJO;-fUWH7)3Qrs4yHZ|YSyc-}!L zk>+g{%db6Xt6E1_;rG-VzJ@5jV|fI6(p7%7W$GU%AYwu!(K@;adeA!B5!vnDL-L$f zSjoq>l9&DUCYI%0nF5L=Q}-VRwK$En@ z2TRhLHp$mH9@rtHeWb&l9maR-Y&v1*l6C-|>N*BlV0Cvd(qVA>quLM8!1`(Pv4FSg z2nd+q9~QOAFp&=J+Y@Q>4=>&^W_Sj3JM~08y+PX9ap`$ox+O7^aS-~vTUSGP*H+T(?t{RLW3*ca7}aJy zulrsAkd+>TEc>{J@;lawb?n*89NR-A0m z20tF+)3(oUKcq*o2=-7)DhItgEL@5yq`j!7W+@mQ!}lq#4T z%vb3hm&j5#g@Bl-xNdx2_Xx}DqEVl77b$|`g0WS_PbJMRR1ijQiKC$+%HXtK!(n*%L_ z{qxD%j{+hgw^I`Z6&*&kKe>CbFh5v0JR@8@Hdvgf5`nrj18mr7-+0Yp(=OZdCXi=U zuhSA@Bew;9#WIaNZ(?HBsL)SOAUGe`5_^3{Vx(BlnL(7poE2<~L}&XM5GgZaw0l&Z zNlLGCmnDT5CN#%knk;2vsS^DxO3rknQ%pPPdGSQ4V_FrlMBAZ>ObqFiU?v-%n#gcQ zu+-0jpolpqk>N1s=Ady_%{JA*l=-t+3@=`t>o6o@?<#ylYV8g7%)P9hyNas@`$qjd zM(0%fwOaFE)5$J?wSEcKLkhO8C-Bph*Mve$_n8;P@jS$->-sTMO6;q z5;f$Sf153#Y;MO($~`>Z4{m&=`HhrwwmIrWE~k~txdS<>LBr7oYg+7jB<|v!rl0s? zcS*afi=5vLD(hY0v(nu|gx~hP0fd&{=gMW}y5IEjPRbx>p7(&HnR?K*BADL>>R>B5 zVpSe80D2F*o(l32$FqF;U4jmuwe?4l$7Mi2Ey1U(jEWAOO_w&g-HS6843(-8;O}K+ zq`|RXX7&ak-;D28(0(G?TORx@(`$ub`I5o*K=Hj`Ipi8vugP37&mcDoL$uCZIS+9b-RBQQ!Fm>W zTJV&@!Sd4<&QX8HC*`LN_LJxRJ|RoY4V9Ob*0UTeJK&VrMv(-`pL4?jfM z^dNh$$tPMpFon;5bnM&DuREss8BD%Gh9EP(^gl7jN%>ZQyAW@0yGGb^K;Lns_Vc^^ z>?DEm_uOa8#QUJvvHSpyP+^lq{wFEk3xeC65En=LLp$0$r?AYTMO|P&c5O%wyY@*E zhB==~4k_qg@Q@-0)05`xb4gW*ulR*axAwe0yEHWLOP2=zE0+e7Ut2*{pdacI{Ke+D z&)@h64wGWOg*i~4jht+;h(!5clX74SO83J~*t-Hu8S_tUKn;G7jsK>1T}^fG(u$(8 zy5e~6qQejGozrVz@5!aLHD0qN@fo$r1y$$Gn30?_V_^SS|C}SsN-OGS966<;ZU?p1 zR%a#A>W8w@$-So(74=T3h^$#wlgLt$H8Y#%|5wO1SY4c4k)tb)Pp+Gi zTtxYR>DqX8MPZre71x$ej#m^-?NwC8!wj#cwk$R+UQ}CI-D@hxgP)5kD{5-1>xybM zYjR;tX;BP0r4>^&ry@Q*R#;Y6SyZTWI6^_HytJsab|w(`SXWzG)@v$8CgORu)rA!` zg+;Zcl@%_lrnb1WG8<4F!PHDGtd1AQs%psrRFWJNmQATdvvF;%I$l#(24=LnlG1ot zvHJk7!0j~m(e|XasL1uD6dku*+TPVwlvb41mKK(ko*zd&4p>_qx6Pr#3P=R(#*_zb zmwc5MRwXFP!BnZAQ&w72+sihr5=+$M*h|fUAfRoi6H^1};&=(tn6I@ntKv0CLOy7N zj3rVEEv-~4kh|pcB8XCRV<&MGOG-IlipLwwkw(=+CfAjg)gD<|aSX@bHH34hs@kd5 z@xo%4lV}iS?7S1DNG0ZAkZO@M%qSc(5W{$5`l2xw9e%jaM?35j;?oHW>JCBFq_Q|m zl5{OFjFXdfl&V-V-HslbCo@8hhU2wNkzpAUe}JnBORbI4w7P>SlRt1%Nv z$@#7t17H6ERSP$VWc4@zytFFkG!w5mFe3NY>c3Z1Y^YbwhMgSMi0a-d>|a{blX;?>oa)l&;Aip$~{V$GWZ zZ9Wq7sZdM@yKePc`;LRuGI6V^i{p@+^=@C2(8rf!sL|&gg0(sl& z8&LkN_eOfF$Z-YO!<|}y+=Cm^TSv|<0Qz22faJUNBO;Ud@fp)_3O+wyzxwD%r;@aE ztaj;b&|IgJayjF?$Q`W=V3*9Ehc-sAjYz)+zqvM%B@x!V^n#M+s;*_#Z`H5fZkcU1 zQaK{gdK9fMajhR=-bhdP($b@mAIxg`3ohiZ&xtSvKqETdI&whmb{pG1BhknTFxfh? zdvpl-NMWaHm=(r1o>^8CSv3cevrI*Y?3k-d=8&s18~!7%eyU#`IX~J96^vUHU<{qz zb3|Gz4i$wpX88YQ?)r?d+{sXK7?Tw#G<=`@M}pe%@OdLs1q4Q-Lz?Hr4q3Fzf5b}5 z#%#;~DVCr_ix0Lk`T$?Y(x*$>*xl0GMoyUr`_X3+Qe%c7mCe*CY5Vcaraz6x@60Di zzFOaaIgr-6AiZ7d$hRh10)740>_zGAB7K(uNtaVeKLZN8bSX38a1A8-nCxb5KQazBU;oL`K)xAaQxD8a8)S5z)$$MO-t0xYJd)lma`l|r^zM<}(|Q|xI0v_N z_%M&j)ey_$z8)mH*pT`vh#~>P+I3jW^B;Gm_ z4>jj%irkeJ%|!VFv!V?oJ!v})Hp8*20@PH6gz?`Qb%2d$Bh;H!v(j#WvF69CKeyloN8 zJ4xMg!4Ql4BHiVo#T%gC*QdXMioUsEUZm~T=+V(Bk+ucTK`%!YT(l~omcA~k;;ZJF z$lY@`M!SOPEs;g2qXFHCMke$^#%<~BQ^TxUX4L8|Iz?wubnA|1PGD+**q=n%p-FV% z8Z>Zt0XRM;?XZlaqIXA+zVK-F^;7o{j|tG%_4EH$m_~EkYTq- z-;L?rFUJsKMwNiAT5-2@M(q|^e?cuKPf4vzs}bqUXh6CN66_jTC+T%abGj9boSrn< z#?w7}frA654Qgz?wx_)UBv;Id4vA)==w&b3YuM>PE`&ePIr6!;6`7Ytfj5zNrwM-z zK7ZjEPj)!hOXdlG1;XDV;jcjWV|pF5N%)(1LzutTk^X3?`I*i+1rKEhg*&nzJ2Wmk zzfcW@iQF_hZL-0XzhO?agmeD9Wd41lK)*1W3G1^J;M067)pLZHHWOKgQGw>=$}kKr zxahfwCt>D2G$$>~PIeB=eY2vq7$wZVNOzdAR*}Xzs4qRTG9pG`;cWbA9l31|UHO2W z^_ie$(xxMovMl+3#A)_F1#jIgs{cSaarOptCO5&?<=~ks2j+t#3)1vo2`uCd~T>(jlh~k;St(4cE?r zOxs4Lu+hDvB@-uN)qlxsgrKZv!IkBtf`n%gjhxfa0yA{YoQ=<+W0$9MX8(XLM&Sh&o(HN{ z!?{c3<~bX|+4&g9T_e+@nHL>(G(^#rP8fV6I$6#)f-tOabR&8=FAWsjA*u;`W2aiM z&%+j?ISaNI4cHm~7wi|ggF3-U49&45UuK6^jQ&|*awZY(sO&$rVVLqGCPsGMVb%YM z)ujcbhy9mX(Rt6IPuEBAv0Y?UecE^v&4BX1HG7fRyL9-9C`yaKK5=XOEA}a9icl@x z9`VQQwl!#*nl)H9Grc>v@9>fWh7*>hRiqqW!H5#EnOgBgFq?&!;{BSJDdtn$LfeL( zain3-vw4)=^W29k-wWq#jVzxtB=VAn^}S;+_+N`6U(TQoufbS+4oS!wJaS@s`^dxT z4TDFe9nlGye~Oe?*xLGsbx+<7Rj)hQR(%QlzSfbEnGo`zf)kmX$AcHy4n?{ZM9O$P z5Z>eTLOJ(1cNU@W-Z{PCucSq>-ABc_r`U?Wu=}*GFq6mAcn#i2Cx*_{(cGsUpLPiM zY3t!fq(|;HvP8Y_@6=H5N_AucCP$L#&g7g6PiWU@_d8&4IzTGq={i>9o8a)~&P1jb zfZ_)LyTX*CTW=ug%oDb558G~mt#Qz;){z)_OPN-+&F(F9J(Mzf>JQNjHl#iL9IE+d z_Qv3jLDVm85RXSXLSmCnwGwMgGtqM}p6lx0NbktaA<}E>MO7_>_?6f)z>3Z)ku;APUzkPoxdr11 zp_y8Vt!48NwD6a<1(7eO!NPWq+&2gIq+{fPG#z{Tz1Po12bFCMDSNyL2b+Sq7@+g+4xzi%A)TbR~@L?lTtMRvBB72nPe8+8^T;W3^Q?IzM~=*kv}>rI7P+l{W8@3-@Wk<>CSDVHg8h9B z3*962wUIwz16J_{Mbn=+;mV*{WcA;a3buul|x4{2ku==w$Gzf|<-lE8%^rSw=Vr_764LM+g+=^unTo7%D zoGnL1SI&v{@@q(sJc466oXpI|LEbK0_0fij{J}t9ZmP${-Iw@O9o>2de(n-)F?RYX zV{7~Ch4JvLzU4Dxxbi=*F3tjSzr5{ERIe zKDJ*hFRy=LO-<>PioEjtk@)PPk&#kWb{1%AYGd}Y)LoL7m*$P_6Z6U{E2d=1FN9!_ zD8boe)I2#aF9(;v#d*^_e64w9b$Mapnth1Wn~6)>!GnX>;zM}JeuU-+?%O5%7@O~3 zuxoDSF^Aa#mCBHvQ)xJu9qFT)sS)zr!Wg1RhTQ-gZ^AsrYS8=F>GRu|73 zGZGYjTNsJrxLjc?6MYdTl+`~rwhA#7b%>-Xma^faP8k%7A-*V91cl0ujjAjNt8=6Za!AbR1)&5PFixqkaz_9J~@g%!(78^!u1BPZj3?dn-TC zg$re6`}g#?Nlz7P{}?2lBv$0)Wo5}N_mFCX*DbEBxCMG0O-VK}HeRoSgx z{@0VnSHqgDzEG8-%Bq<$&bXSqF-2oW7D>l~GrGS9(9mM^fgJiF@(5!e)RF-yvwZj% zV8>=f#-ZwF{#b{?x^`-=hm|D;a+(4*3dns{|> ztgLc6ruUfUCo2rI@}-8kUoB&JvI}eTP*CHhm0cEKO)yF|7^ITw%8J^sc&u$Mosm~= z3AZzGT0AbzO$sa_iRB=qJOhggs|p!UN7fK*Q=FxLvh`12{gb1A`YDq&IkEhB6-*K2 zRTC?V7oHoJmE~k;Z5+l)r=_nGB9pN-{R^wAxCBv3<=WkVUF(|^>o+`LgIj1b@&*(Z z7h`d(VFLpK3uk{_F$W!AUOX02MRheg2(qa97AU)qA0QNnI4T^=%4k=p(*t9%;&^Rg zX<1f3HHE(U78`7hrpQroo(;X48LOFDKDn|?q^FDdK)0Byp%oSK%~hGG5>|CC{s9>^ zH>-=F8C7LqQ)-vWoq5gbQ(7^Nv6EN}ifGo^i<*G0Ip4)s(j10h0a#mJRZ@yTImDAq ziF;gMDr1ayLj}@8R=?0HlQpn#I)d@Ape2?`HfR@Bn6$FWYOfrMV*QsyRRh#~24b&H z$O37SI_UcIf82h@to~J&w2)orM5U}B>X(eKsE$v;iW{#!v9hQRlV}262+;`{1gqE1 zs9;uQ^(`r_D2|nsR%4y6EYX=J1lzTsEw(Ftt@r3OAS*Cn@KDCavikWEbubCj;$?Y# z@+2R878XyhhQsQ-maM$I6Z)t=syg)#R3<)8PJBkZi2TD_3W^88eeuHb;YG;L3izbM zi|A_=|M}Gi17mJI^m+H_DbWzh7|6lRqw?FW7bn^O5#x$&uUc)^o zs`k`JfOlS5TAY}UsW!21e&O`v{TOdlko1|9qWy_A2-^-D>&lREH0G?gP6sjIf#slO z<2FcE8b;Z}pMeUE#4nn3>*?s0HPDUhU>I!${OXb1U;YnlukIhL<3D(?+Y1aH9NY^W zgAL0mi2v0=g;L8N1d0(K-n^dD-QuuiIscS%MQzRYMfV?g8(Dpd_Au0@2_{7?3vu%bwEWqjz+GYPYRi*5$|C`EmN3DBm*lufnWk(&{69-Hy zJY)Z4qCAGflj@lPT@1S!1K@5}!imIqa_b@9hI*H^Sy*P0H?8m?v7H(Uuf&~|guKDU{;5fOlD0@f1T=i<=9K= zJo@i98L~l&O~x?=9D4DPV|dslUaf0F^XD_isP*2#(i516a7>asdKj(pm^wnKuBP^C zXRh`+HPZ{L(6i&z35P0W$0o?*OVUH0YUsW$YY>Kv$~dknybGrHk{ufgTNO(jvcNKN zp9zOre6v-zWOMGeOP07Szb;>ogB}|LsHsj=fa0}b&maP zQHrGJLSXo7<5S`|3Bd`2ET@Utkeve+Y8E}bG_PNb{sdf(7#@niLl9H2?T5Dsua~TF zhneUlj*>8UafYRqSNyo7sVGvMBKsVX@OIs)7CWc|;O~^hOSsBy_lRwWs^=CLaju$Q zTtZ&ZuN=+lx??A_mC?>~OLCkq#!X#T4s;5Sx|9_bVN~jHoKRj~kQ75+AN0E2%--pj9M%3RcY+Sx5Ixg`XQK)0=(lA3!}jN7RprD3mvVgq z>j%qxygdI_I}VRGs!D`RdB}7oN=wVD%JAvr7}o-MIt{}`=b33Q-)_#wU}KD@1oQZ4 z7?vnG=NF%ZMi2gniq5VYaubu)m+OUpJVq1gyW^@EGAN$9=GF&HxW|FLatRLx+?FVL zf!b;JQCS1PT@kk3*uU4{G2B9&wR63~gVS|b18V6~pr<&S((UEsLaYgV$WXQ`V{2MC z-*}E?x3g|d^QUYMw~lrt`47#+ui3AlvoUs{E=e^q_&nZ>VX2f8PPa7wx2GRG;o8yc z-l*H zzips<%Gh37^Dw2fh}WA{^xx_$>*zeh%H!pg*qtRk*k6XN=``PYJ^N^~xT6{BU#xPr zH-9ogZD@WoH%L54InGGk(m|2s`ZPNhOFZa5eCm$xPK&0U41+#qDhGT#URHq13!J;u zVny<{!;-fCv)CV*b8y{J;+-A$}?tI6Rd)zU+-HTOErkN-$(Q}IbMC)h))x`X-y}SMi z$3mS6N>PJKnz8$Gi>yvd;LwE5Nf8!7v0eXTh7)@@I#2$L!1l$DlNcMDKDD%H>g1WV zac??IlD(F~?MDu`JM5sI*tG2IL^e*=yOEPZ(5r^2nGT;oWo6SaOe?G|Eu35?hod!u zk0A!6yas1Cc(nl*R^Ok)Ud(gHPdXi81BxrlV}(UUxU2N-Sgf{i$`P59D=W*6@WXiQ zyiA@Y?&vQ$*ZP2NrtLK6&kq`6huq6dyb5t6s>O1tm~v_mv;fm-R}S1Z%30I#@SDbk zW@cz}_iwP8-OT!k{iM$;>1d%LadoRJxb%Q9R!l~<{K-M%91TnF2Q*6A$4BB2+MGB^C|odIJ` zJ&yaL;Zq9=i$~G>?-R@JTY{J~MB^bJ#tg0p_MF&h6%U`9mp5(9IGjM_^}{H-1!D)E zo%IKk{JWBxc>G)^_nmhkrYC#(jDn%N>%!p>HV`|%Quh^srM0=J1x`w5to&_WUX>lT zmYMGUHC2d#i}UCyCpk1tZh-Q~=ET6E4b@3BXT1=2D4w$3<&T_9iP?o6et~r-rPIF> zi$`b09vt($dU8#5ZRPZ$9Z#>Fs)^a|G}=zXsW>+9qf&9)G`2Q7VWyHjX}M1pYn5`1 zAnstMz}@l_JS39hf7gkGb68h}bCmd)cy$rH>>aNXGD_P!0&JlKvBggu6ArSc&Mn;G z_4m)Ks;Vnx;ntN-=T?ndCNb6(h_{hknf%#(RLIHkJ$mk~@jb~lqQAOnvKLGViojCm z4xMn&Y5m~;Y@%tv5RX-GdR3*@*t(LZI6Qp{iz}?n{*qIkTb~BgQI}WLtV5IFpOlG5?Dj@aC_{{)3qWdD+{~WXXu{ zvxA%0@NyYYrjVOf9=MFd-pL)>{&$zfWEL|!`QXxD4w^rB6cV>|{2R{Wj)U&?3RR;9 zx9g&`(9WPoNj_xrkv$SW8+4Xz%qd(Z8(bQ=KY>5ZeT|*-+aIOL0TU;ySkPZ+ZXHH& zaZMhMS0!{DqO}KPNiiUa>j*4vwT0Dc-VzJyP8$RledzO{*C7a4Waq82ByH@A^7=C9 z$DXA^k%p#Rwr1fNMt6**xM)S}4lb$rf=W!8@;bg`PG*eQJ{wS%m2HpgYGsRej#q;H z`t&0ATDMqXZ7tqCm>~PF9Xxj)a57HW;ITRRZf6VAVlx^%m6R?d_G{UC^yZ8P{_@3_ z{$|vLN%#>QEz|sf!t(eevFpMa8~oVB8d@G3SB;BGZzuz+cp9CLBQhCZ1PSZYFK)y! z@LB!C_n6#VY6NlfYnB|EPA=7FYjB<$c-V#eYy|4ygtl0>nI+yrIZYpT zDV&Btw?e!@QqO_hblZ7X*;!e^&9v+*eCERb$e_9k8z1Id1vOg!G|cKlU!}MR7vD8G z;f38UELL8V&bF*8u<4UEwgw@ zTMFkrv~)|Mi$Axo1N^{VcT_kWn^)>LgSy-p=xT_QY%WWf@Vr*alW5oAVR)!q&cy@P zC8f(X0msg+vduXGfh*W#<<1IP54n%d8i2U<7$5b(or#(tovQW8W-4LUV2~?{xn1TN zBUfg3qNhr~orSQ4L)0>N%-&Lu!7=~X6Jnm+;>$r2ULH#>cBC}!_H&1ULrIri{TPO8 zAMQ*zQlT3?=MLrLItqu%6YxCP|95$8M>!dJULMQCpiw({$M5cplO&bot4(#jT0OST zxDG|+(X>+g3SJL4DwFa2BCFFiDQxz$`_}o7L#R&K*YM_z5t|uYwexl;rk!)pi2FWw z9KkS=;bRBIMosR62q#ARB#z4MTJ1YhzqTRE>XXns(8`&uzQGuNfGlf?Q(Kk2e~h-% z+;D#|;V@Lx;GvxvLsFa#*IcBl|pr zNKW*u`STe(Qw_VSM|q-4zFSJi(?i@Au0rrc1J4JD!~P&SoE{Il?0By3q<-_DBpATO z(8q*gYN#BqA@cMZ0<#N`;n{VE(ZJ>2I6e|G_S8{%622s}Idrr$2sfu1h^orG-LY)( z#zaE%8LC-cStD+fKa;RG<2&^K58PYxDco|tIUF8+(TqZzJi%VoAzHTzLBMpCbkyq* z+bajd5-;Gc1rz$^wv>2wU!p+xuJycgcu;Pm9ehuv^eh7NvhG0@xW36DkicaTdf@xrv`Ov6D z6hR@}ahiYhraJ@SdOOZn%O`sv20?=xcYFzfXLq3bJlw9U!0alB$E!S$(O9D-18V{72WN>mueq&{|>d~3o~sC~5`_$d!$D%RQ5pqtp7 zMo5rjk;h9}o*?nr6!}JpW*&Ck85b-&WdLnhg+AjU+@jjh9w4yema~@{Jax!x%vcGY zmad}_)!2MLQcNNpM0Vk4bZ`e)3Nr@J2P^2vIHGJ~c#4|P77af1GW-BfUp$&6lEBg! zd>ZKAyKNj)Raq4aJj1{JtK}9?jsHj9yMSqymF1!TI2;@a5R@YlHL($cgUmoz^<}yz z1J11&%9&y6+ISiGt!q~?^;gx@U)4PgV}o}*`kVt13`R{6JSaZL2u3+i;+5l(1amRO zV2qk`;89|{5QEXg%Y(=BewTNxwbx$z|95rmZXucHnXa|>zxKL*>s#ObYYw46QH|Im z(qlSE=gh31PQEg=>TZ<94d;asR{cM&aUsFQ!Vf;75()+Y?pLt1X6#?_=E4~nP1m$M zd+m6#NwMorXe(7_M$`FLx=h(MQFCPgR515C0{z@zh!TbG;v_tya{T@-QpoJD!}d&v zP~E99+CEcCh{3sB9}S4O(-j9N8!VTa{Ah%jR2>DaMj<_3cj1kLmD{s4jJO-x*BN$G zSj#<_k*!-pxl9F-Q#mW3-J1A`)|C128nbB=C!^oKYiS3tUhC~|Z0gY&g~e*LdlaFM zTeQrY7EAx2o3Z1_M#=jFi1ag5TVe=fQo{yWDx)*cMmK)gt0Fj1gLnS~EK|(SpEg%j z|F4xDAR2Z17rDj4F5-$T?BX`Rk4e9b%CFsXqoN|%hQ{g0mfEN*vfJv8le%${y&Cmf zoDz`4!6~vCpO0Jm9GNw_J|(83!b!n9f9VPF&X-9gP*Ffla;ZftHv##98r~>6m(KG*P$ip8+;r9Go++^Nl(m(N_1 z2vT~iN=Em>CkzHAWR4(~ZBPU>JBqpJ&ZCmhtKVe7;p94<5rj_iLp%-QkP2dmDa=%g zU)5@9U;;IyAPp0(g~>t|e$gw+aYrh_Rv(v%laC+lfO<`AUSNBoA#5-_oOcY`NV6cX z_mu)^W#@4Gp+3TiYN9v9&H$bTG&zIyw3#*OK1_}bF+}1Q;Mhi|RB&0-qgGf6EKk`{ z!}-ldI1)%OYgLbY)JXHRrm)MWAj600fjzHULsuF$p-D4_e^}uxSOvUx$J|(3E@pHqrM8PbUU~yDG^Pp{0q46n@A6oKie%GSA=| zWhcFUa86gv1kW1=FeH^(`*+$?vErvK8T-`t$)bG?P{p2>Rb`Ei%E8_i?DHrccY(k}8&H_av z1*o$AU?8B(6Mr#x7B$1UDuyQ7{7V<~x@0h15T7ywWAS3U<1|D z8dnCQ862RfV{y|poboejFJR=|?mUw4032{TaH4$hl zMRW|4NDZ`Zv*Bjaawd^>$f}J~{a-Zdss(&BPFtG^Tt;M*Pxk9J0#{{Y*yFcSnXQXQq3$a6Mrjmzq0uK4M4XcvqA%$#4rZ`n_ zirO4?Bewg~n4QktI&x#+1T1g?B>F2IpxW?3J@UT54mIU5E#LSzp~ao( zI1f3+Lu=betvfY%ZSOwu%eBy*vdM8b!+mCwGU0I^?(f2)2}Y_2QnLmc<6)7rOURpv z$#e3gr`%SS1WsjcN|=lgx3x#7eur8tfo86+E9pYjg3j2z5kMz4${I>-q|r(R*-2~_ zV7hzuE<%)pe<90hydow}Rb0)C4lJ;0H|V|%5uMq2g_wvMU#S=Fo zl-5u~X)Qf51+%9WF?To)k>9y)+fG4^W$p# zT8ZzW=*fW^Qq2rTlL|^z2VwVLLqdtvIjs?kbUt!37?T~&?U!)CW}tJzJSaizk>qKh z`29#&xCd2Xw2Nm^z9qah@uKReKe=|4A9k~k>u&H=o|r|MR)VUH2#~CS5Jz1)-idpU z#8ke@?S&@=BGsk1G?!!*pyVi;vW%)ZNBe*qaY~WiBWPI7R7+?h^Z2SVP{CasP61${ zCLkRZA03U*9v#Rh&Z`4CT*uSjCD1QCZW#E95kGFo1PjiaHa+0qN`Od^HPPQdJlqFr zbm=~Ey`eaFM}rYPF#CHG2r^B@CBjoxoiuMdF)A3fd#JwQFHtcc;DN^=# zcA%Bpz5+ygSuy2}L4Zzb0jx`&0778^{~0Y+V#S3zZT03=$c3F0kz&xt(% zEHEzbAp9BZpz4Y@qZZoWk4k_l1@)@Kjo3GuObLT&fYff7rKoGNIILTn2p4}JF7=BN z-%1f;L;sy#d!P_2<}Gfy2}!$0g%m`%BxhbdB`o95$l-OfJjP7lONeV&if;PirP2^} z_AW5)ZcIWUR3^bmCE04Try)?s=E6}!JXjfm-B%wQ1q1}<=`F3VtAVd$0N`pSIO*XK zJSN^!o7;%qd$6n=kizj;O`A%gB5NSA5;IF#WalXg1P9Y9>>9#(Np@blGl>v!J7o0c zGN5EGn8GWoOJX!v4&!T<{I;sRhv0o*=N8YUyjm8nK%-8h-N zUM)50@KLGA#4fnNX{64$Slt8|a&h1hD48Ulh5L*fUajfn?tm2n(qvr*54GXK>g+N; zEkW;q;@2g-`bZ?xDGtoSHWp}qO6XT1(1Rx-Zek86VFW#=DPv?RvssRws|eLzW48ybSw#Rww|`mTeBP+I9|0eqA^ z7n9TA*dZjzg&6p~BNnjC0Cs|d?C^Guyq!i(F<0>#bA9@}(GMUiPxhw)C@RmCTTZ>? zB+efui`Y%Lz8cVfYN~A-f=05iQQcFi$SC3t zt&%cR&_tvnWMC!HWh4hg`#fbs0iak!snt!;s~SDkIN91+8kvGdBxK>H>5dBO_1CwS zE)H?9HSbdh4=3Bue3BY2rsQ~->|eM;3ILCt+bJc>JV;|tVr--jmoElM<^)oykEk7@4@(1L znScUv{nvtd+u7d%Kg7uTI`haEjH4zgrh%E2*s5ah6MS1DKji~A5DJ#O*=IF=yQXo9 zSME4UBz4O$Tm<_QoK;=r*5E>}M$aZL437YoQXs(qM@^G0sEZMEnc=1wP+#gDo00Gd zlo3zHEUP2&V2S3>!-+f8V$mEF!K=a+RP2=?cesx(^$4v1JSt4BIFOItAVeMvVLL~w zp0W4JZ-n^w8V5F`rz|(1c@d_G!-X~NRIinpQ(Y4~YLo`(9x&T|*!iykO(U5w5;pUy zg+e@KloX3wz&@i-6iDnqR!q(#4h=?BI0qC7Y6_`wXAK`ph9tcqaj9q|G>4l8nQ^Cl zT9D!cKMCw15(Yv_^b{4E_i&hv?Y4}~&P*;Qnm7r=nS zjrTAX^~j|_t~;!0;yu%_CgV^{4$)=rvJufFq5R9KhpN`hIRK?x#-P{6IU2@GzOG@} z5Lrvun3U|+3;nt-j<^vcun5Er4e?O~G8%;o-E5GkePLA%=t@wJ_uCmA5Kp)S4pObZ zWTCmTg?NDGHBPEa2|xI^K&lF*hZgY3((>jOBHOGDd%Fk24J8c4cyg%jAvh6aB1{N2 zDv^OQ9iApcg_F0PsK!35Re+Ut?cEE4+=mt|wG1`USuvhIcl10TCSkGsn$?P}FAf@F zuWcbbfkc5(OP|e^81cy?Cc*~&V1xIk)Fu^IO@fxi9R~F7y?{?o z6M5If0c5_OQDJFsZ|REb!C>D6XPu=zT!Wz7hfA7N8C3hWhZ}Oco?^`DDgk|6&s%P@ zCzM;B9KA-Nc&I;YQjxJ)_2|;AP)y5vrp8Db0k(N@LuivtTqeK^sl=j0ajH$ajn25k zS4ysuVA)fdxe3lw8JlNBHE_^_lEv>+#0t=^SWfKBk$oG1w^}Yje!qydK~(~UH&ddg z*^`B7w!#yXBgn+F9JJ9D&K5*k=Lx$)*%IJ%21eK2mnF7jpU6Ub6H z=pYf`&cP7cbX**3yHHqdZf|S?fI(HosIs=)Ly^*oyOEGxz-byUK*6X{gFW1U_3;T) zVXF_lhey5N^GG(ct7hMOa}ZU z@~J7=(7Ot&sDpKwuxmmx#1y%-xrHRY;0u_P=l&(A|3rjCPYrTbb}6_R#Z1T1s6hn8 zoXAiy$i$PGfSk~7;yGWizuB zMww=2@lw-3(C~qS&SD91$PrLZj#7eWYNYoF0f!Ld`85bTECdh3ziUf_OroTd35FR* znD0@IDY!gNuiklQ)HaiZ73-*A!rDCjCbdG4DQHGlMda6&C`!U;Ri$*gregu-`YoWz zfDhIa0WjIv3=tHCq!1!UN4^E{1Vh2`@X}PCN;Lt;ircKl0=OKMHZ%7V&?2US0HV=r zL{BW`_opf*Tyn3Z663}xc~s2wAeG2H2+e`{r!>7VrhYY8jN-I!gTj~K*E*)0W&>u7 z)~;@BV@qVw7~7F+8EFX91$FWJ!8XW9xZ#+oHjzCtLPNm5Jr6@f&KfI(WNuk*X4ONK2Iz8XoKE~HWd z=SXJ-+PU$(x8GCT+-j_BQiL33;a=5yesc(UmMb`hbzLgy&u&fet^);DCjE~}$pvq* ze$Z>RWHOH0lh?0_=8oEqSVH?ZpPpWGU2U8!gd&6_Rd{k`1uYRdY}{FP8fyxwNfT17 ztRd|Do*L#&P83AJN$TSz~=sMj;es);ZPoblS4Q*g}Yg-zbrk$K_;-snoENXACNCDkZGM&-D!w)d- zM2}boI>2pc0;{Tz>wqk5RmStXy*xbUUAMXzb?C`7Kp9_J+j`;20}{~~&)lt)C zjl~DJ4_hB_tbJr_a(RWMv{GF*(h#abd1izO{ij@B4LhgJd~6v&t1-94w|NjmLWek}wF;qNP>SHkf1O6yh1*KOx5(3JJGmfkI-iwD*{pdYZ+ONzMCE zZ6wA^uUH!1D}wjRzL6c}fs$kykM-A)^+@Wu{#UQF(;~t}zlKTOmxkAkHL6my?!@Ma zAD)cm_y?vyqgQzIBOvC{W}1zmbf}ouJ!rtL-Eh%C|286#w%F((i5P%J%!Lfmwb)KI|a8uQwk#Xr%Ko(a0YRz>yzM5x(w1&t-W-W$2ftAG1=-` z@G28DHGnD*e_9cDs+=EJ8UFRXGYSs>$9-&Wfijo=YMa?(gSC3kF(0DXN(uvd1m00TT9mS3QJ6t_Ier2Ny4mDkxfM{Z!}xnMLouM_&2LsrwdY9(ic` zzOS;mHe4hv30z=~7J0x&8z;i{rlf)$OK%=kWJB__k;A%i3o<=>CNClxoW!bxLaILxOME#!&{RQJe;^tzSwm1;F3S~L+EJc}2wzaWDuQA}cf9;Rlo8`K0uDq5Zf$GJQ;HR-`+ z)POyRhm65Cilv;L(eOg>#_UowP9?pi@@xpk9%tDZ#u!38a z>l*ELr*w)EFfHLe5ZFZ(Hqs)8yf!6C0D!F|?m}!SNC$GBPghdsU~!gDfyhnauNt6; zR&-zy6SBe*HuiAy1XHXK4t~F7@^>AA6Wr$noK`>}`#|&-(MYW=L^vZ z0viCc?7IZ0*=!WyP&950PPVweC9JS4Spy(-IvWt~L40`d#OOqvG3?xRpqQLLLb$4- zMCnc?o}E!;Ny>UV${sjNlFefa2K`s;fPK9Ihd2rOXw=c@g@^RWSuiCR8{ncF1S8ys z3Og&;UQJLG;zvdCPs6ZU6F23abH(TR%g8_{cH?Rwexr_wq09SJQiJ=q;7G4APC(i# zbrh`76qedpkHwfQjCzov+0G6@N=_)(_^GJA^NaW|N9Eec@_Gsur2-~uM?%$yI5nRd z`q45Wb5tpSC{o>Gq3Js62JNUo#x1ZlkoRcM%-o;FWT`7{%p%)lIf(w{%!m?2l{o12 zSdHrQrPA5l$0yT@9^n`_MTd%Z>JlBQ%xXLGXoGozq69jL&5LHGJ#>}}VuL}y8X1Ps zFQ5|}LhUs=I%;d&KQ{8|jY9OPOjNICxp`%sufM64se>Dlk8kO5Z`o=PtVqZO)1$=r zCndtd@4=oH5rFy#4GCBKixyDcC@0zy<$CI)#u9L|dMv*QcH&U8mXoyX+Y6~2m?~3a zUYj|bs-Llj(Yoz~8lXc1MmcCv8OtB_n}kKIS|dZ&?pZN09e<$f?wn!g8#dB*kB`U7@fc zok#Hdw}63?VKtiR+lS|g?M!!^nV{I&1Xjj+@2ST3`mpOsxCY3=nz`wZM1kG_{?2&^kBV@d zgijP(yT$c!nsWXy=-!T{UX9En(5(bDaia$8ZfZWm_{{M(JOUmZeXT{Q3W<)BQCiOo z@nV$(Ro2cGJ>C^njuA~=impfBX>iA!cOg^AWa%LqD!PY>YDmgWxAmdPmWs$!Z=yC5 z8jf$UhJay+-?_AhIIN>YoZX6-CxD2=FLSViVDf5T-gq=S?O5VTOTSGfEtPwaQ#3t^ zF#{@3?d?50yjZeN;bo|2?9;$o$wht5`dCQOo%z@1x?bB&pd=EVfpxC1;n{U*D-T1#oz0*(0#3US(>T=h*b?|4 zH`aE1sEb%v0Gto|1`dBiiJgc)Mp(FRrWURsl_pL_WjjNqX06ro-wkuaS6uPQB4r{o zvinL0w6wy>t??T?$kC~ zBI1%zEl9`ap!B>C=kuXWVd0T?6qO@@M?kcrNo*CEXZ}YitM0faNR7h; zbH(mCN)rGskfV6;)ohNL!L(WD$zjvzTcG3icT@obu&h*FnM&erh?)p1jfB;4x%1J` z5khyQ5yV>F{JE5&98oWq%r|+pX(pn|&X+DR)kvuaD_7iig2va7-w2HdhlOm7N3}MZ zg6~S&Qaa`$z39*vWa6adNRx12061{xPpnH6P4)9bpkE1ixWL|%pkksU_;d-`R=RFAX+@BiWsFK-cwpDw$f6*r zo-h$pI4jbvXD&)O0$*7A&&CzcScQ;DMD7^{_0iV-LA!+d$t)|>*v8apG0dKt*&v_P zaE8v+-NW<ya^KZ?!iFbUHg!DqT-bR)GzjeYRHZY1uon8w`!iRZ12)F@VhQA ztlN^Owqj+k6?Ok~F9ety0Yb$FguNwjf;Ex*1-U=5iO8Sj04Nh)$ zmsP!md5~N+WuUlX_(fFpOV}Gy?a?LqS~!)(81MAqvGa9@fob9_dH=~V%z3xhr)UFq z4_uF0O1&W7jR5F2Fr@xFsO$LZw19<7CV&Jw8o~?51L#PzE%z0mPq}vknbhs72q2~& zjw*u4L!k-J_(0#CA1|*UK6sL&uy=KRXKxMGdlIE2amey?b2|6n#U=Er2V}NIX_#c| zo6l%L%1^M!p+S}Q8{RG2wMqXFc#)0Q1h5b596U_3RUqd#?s^v;-V7G+~mm;x|M3;VLXkB+J63Z%kolK@g-6^@hD>+~Ej%p8)YM4~HP*dx6h&iWv zyXJBl9MV+Ep-yT;{kK9rju;$n#9$|N-SAC!P7AV>x)&ib?5UGwXfq;nZLdO7iNzjr z%a4hV7P;e!6}}>-;PoyX#|G%iXa^C-Rx=ZZU5C)UTm8om;L{(dkfQe8gI-5f5$Q}) zx)~#vsK-Er0oG#haY!oSIcTsNOnmHDw`Kqh5BD`!ihD3(mT;9`gG0DWO`+@rSB4Dn zHT|;)^+>iKY>WRo@W2os_tw|9kY!4T68TZa%}T@r$#E*^VSL_cPBBxfDzOpthRw@E z6-b zu>|BC^->m5mr~F(`a&M2s^l4bvZ~QkkeQezVzoFSlhoK_ubSWNhMmATd0vS zgi5>1dtkK7lckgn2TxgQXe^9sn@WWhP1lX9HLk&A1H6rE?AqY(5Z5B$hlZe*oSkW*q6)u16iQ@JOH9)S085DK)nLOIS%~C9i9ep`aum6g{%~!&ew1|Q(w8X`jFhDuoyUBNO=f@ z!BcQUnG(|hbA*}iBQg(6mX=hVTV-@S2imkYmzoi2It-A-OmKr{&AhR}=FG38?$$Cj z#}^Pq=pk&{^h1M*Q&Ust5fsfVAf{G407#G{R$XYuas7%A0<+rW)H5kqMefy9oD{gW zmeM2&4;q*zO@vO2UgP%8t}av89c)8go+Z+Wb;(~Odl1p^e6uTdru9mggQ+Rcunfa1$H>*)`a}PvH>GyeRv^>Gtz^+;-Hc&vT_z#>to@`WsR4IK4Y0U* z;R(T~8NwD4Z=7PBBZRzM+ERc?wTamvAdHN6v62$;E(+bzL`=d%87)ycsj0T__$%JV zRzV0O_ipM&L{#&0>ZVx+%aCI=sgjwkr6B-SBD%_n+J9Ytb*OpCbiaqE`*Ul%YC(zp z3jxIC&P57S?6mDB-~wz~rjC>V_jLCxA9o0}kTl1r*Xj*1c`~{L1r0k8foNjYvqZwU z!c}OX!(LwQY0Pr)AHAzJ4WeMG{hb57hj3CFP)0k+l zyc(y)bjlW^V@tv;Iw>iW6DYw=S~Dxfvr-0vB!U>_8^aM?hV*xKQc-ngyft)B_DR7JeWtgQ=QSt2-96 z21V(J)PQWn>#LAVm0=B$`;Ol3$S@q<+zk+gj~qsr|EFg*r7?4J)0r-*_?!(hFOpGr zb?Qg7GAE&-N$a`D%p6*CynGjcfBOJNt54i{XWiGgn_DLH_wA-phwOOJx@p#YfU%>B z4|cYwsbIHs`tk-W6>!VLe{ys9+Jo&C6NW=dIy_hwj@8~B#?R!pJ=bD5f2H8#0B z0}s=?ns@IJ1Vp1fW|Ek2a=GW}5ai}{6G(|KBR9Dj4@WedEB~>vJNpupOmc-)^e$84 zgR``}xurRbh{p5pCvwX}KV#*K0~!sBy6rj25tEnRw8iKOqXQBdoF=ewon&(-lk`q= zkjaSyzWVC8e<)U3Nv#GD>y-FwBUW;2W6%S^J9HpvU{r;Sx4}})!=fok%**!rMzSy# zsTI;r2WR3L6Qf^KJQKeJn&dd$NG~*2vZDwWc#oI2o8rU$Hasour&w$ZES^P~?Apx=^E0=ZJ~W(D%oV$}2DLLTg0b`B}27OqU;nLJSR8Q3;3?)$cH;4{{C&6cnn}!5FVG}LyWdw>IQzs1^|--ol@@Sp&FeYzEa%n#Rg8vFHrlAX zXugEb0S&yPvgR>!Q5`sFeX$1dRDFRnyAgbf^cyg}vv~*RB(4B<;pic%BeB%Y1>7bLWE&&xNwumLv7MRPn0={G zi0Tf<{^uNAxSSL$CDwKZ-9wOAP$KU8{_Xw z<@UsO-#t=vhR&g`~fmdv=QlVG04%US9{bes}6jswZ6O66qW5;!}F) zF0k%WvrZ2M07^5v(G5na=yM$(RwS{(LVbJfA`DxQ`cZs-oY1}zmw9exASN{r!XrO; zvl~*n7cze}iWz`L-c}8yoU_O_0zJS)r;1#fOzRsgBBg7Df}$(|A&QY%PXml4@ys@d zJ6mc2grF#w)+{vCP?VPLzcaIf0Aot>iiM)c%-1D91$5If5EV?uV81wyD6io%NvUa0 z1cqa7%=ValucoKO0Vg#`a zcgGC%U03aRcW4i|<2a;~p2B!l0%~*qaC%1WW3F%DdV?UXMh+i=ydAAA8e?9Ie9K5n zIapnC+m$v{iyPsakw-8;D2oai06(!E$*rw1_tdl7@#(~5Y8e6t0kPl&?f_xLd>P4# zXO_TplT8hsa3b)f91FE#T3uT{fOWyk#YK00bI(Jq>3N~LGq5gmAv$66HPESor((uT zjHPlLV5nU<68C~bf!_cGt<3W`Z3we~;Pr^?PPZgmxT7wt2Ri2`Dh1yTnkHkie7MfbnZ~mdgyPJ=#-ufjC~CS!sC(&S$?h}L@{P~Ud<@eaFgH24veng#_CF@t_stA*$mkyc~} zfolg#dssBju$G{{(q$t-H#}qGfh>N1UF`5+H>Y}2yRuJw&8u%aA<@VrWCvdKeUKIVM2NvSB5vn`Ise$3e)XF>}wN^6uWPu9?1-xJK znAq@rHW6n#v1ka(A>L3>^w_GmI$fUDnTYX(oegV1&lnDRHI%@(Qzlj!F=e;GXanKe z8rx)UyWM%)xmpGRHug=tRNm2v$y9*_2pp}QX+5taEBS$0gGo>VTBWnwKq!iBrvpgC zT~CaQBQ2~K{cD;-SZH9My|tA!aFcs|i3wv`P!ZZ0BsJ`RH!QE>^+W~hgdG$$KvkEF zb<4sf!jN^ii@1jvp2kjA3at-E55$avei@L! z?CQWZDS`=c;6h|kToTBNyBdAD2E9v(ZCS!V1_mch$UPFJv>dJS3W@t`IoiBB5!S;x zWH)YiEEa>eE$miqY+1#?^JRoNU9Z!NricwHsbU4)ApwH~Lxjd%LcMB84&lN2%hx2P z&@na~^VWx@mP1ep1EF${d<%&{Tw^bZzaB&~!esXM5M%0U@ZJ#UGznQy+eWwWennZQ z1|3sVt{&uN`JxvEhT;Vap6RQ3!Ap$y!vj!LUkDI3M%WnHIKMqm)3(Pi^J5K#oFCi z+ky$yT@`6ow0oEqgQaP8zO>Y|$;Q;sa6q~^GI?qe8_``*8EC>6O#cBzJy_LVyOG+YM00*`MB=nwp0&lL+_r+pEZQg!*zTjgl1S-x+z}pfL`! zBjE+i%BK*&b+9%NGn_D$m&T%nr8Ck@tvbZ;R0!v#=@p5Q$Z$4g(YVH4yBBFjsxlEj zaiGWLw~&IwLLn%;VrL5mSuy}v1MR3p#v(*GuDC-3B<{gLN_$$`-k)C9w^ zO|-^q`%9Z!u%in`{(5CAL7^Jfb;x^W5Ie@{X&AFioQ=T;!~_um2*juz7N!{Fxf4X^ zKB?<^%u?wpME+}+AxYlev?z}^2JJ-2oMKT;(vq6|ySYzx)H<-ZGKu7T|MJG>%EslL zJx>n|9)%xxRv7=ype7XgDP2$mUXzA0j$t_yx-8=Yb81$J zZ+SAI%hF?T)iAoO!rGj|&$4F9U5UY%L`l*ZD5yQZe+OzrL(zail<$T!LR@bc-yLt`dewWu&_P&D095 zo1IE|;GswEz2_ku*MsH$bbn=CGcmSP2%M9Q+hX)+C$oCSn`7J{+k4S>Q^xIanAGRe z42MZB_WGc$A4AyT-UEwM^9wzT*rte9JFePlMoL3lg%j%T*3!yayO_5i(3KKFmaDbx zo!-@hZB-+Ij;CVEVcf3ZX&Ru2L5?j&q{}lwT4MlBBS^8c4H&&s_K&_PW_8mHPEdoX z5I;c;B`J^U??lLRl_wVjF2Hq1GC|2w*#_kXvy&$`w>LI{Cj=1%A-ZLx1GYMAGF&cb z!@9ISzJbXEv#|r`E}`bZzwb2LOXc#95mN_hQ|4m0B+5qEi&bNA@H}HFMq8HTVQ8a# zTtqbq)gbu>v(`$(15OGe-GHB{YZZS;*8W!t(LXTc73K zoVY_&z^N6Cin&ZYs`vNk=-?(SUKs*#pyR>b#G~z(eROUrkKhbgFdXrjbCO|FbBoB? zZ#qz|0Vi>DC@)fv+Im`?nMS|PxdNanA$d&%9wf!bvJYXryX2^5w>Tzzhl4zLR9oKW z+AHH-d1dcS2&)E07ytTF`*)CY1(9pr1z@`?c08xva_atcvgiSaxX(h_sVxJjUOVD)BrunVP@U&W^ZRFD>uv39Be#Wg6@1bzhFcAI!n6 zPJ^qJ%A6_k&C}5{^~9XT7VL|4Q!>oPer0)2ODv!{r*CWX5deE#6?bOr0Q(lqCgTHU zgX<&WhlT-ts|ofO_sYTecDaHgtkB<au|4I$wc6~1*ALa4vA zqIpUKNxZ*w@nxx0NW=%oy_d6QcHluu3fUR;5OYJt|79ZDgafst{JxVzE1Do;8m#oAkZPy9dP9a!zvmhq(q1DvZ|L$u`FxXhWTow zk~N8@YnVJIW@G+lay`kB$n--bK4&%tn&~mAnTd{$!0|U^3(1VcJQ(5j+7po`9c}#w z&%DjDpbZ<1RF@FtLY8?=f%a+%kuoAZAggBT`7GRu2TW>UC$`KtAPvo!h^%91D@5lL zw5MrTCXf~tLL$7X&|7#jMa|b$BG~l4vTSO8VJV;4ow|1A(!&~V5{KCN&)iVw^twmV z6bWH=u8#m{qeV-~=qGq#01IST;?u9Ib5T}>b!Y2A;?CVrv|SYjsb+Mb8G9NLRZChg zhm5kddBvqJV8$r&H@p&lxJHzDtPJ5Gr4@TYC9rleHOq3c+Jk-Fv$}f0BV+)LI5s2n)Bq*Prx3!n+z=d9Q>eG39x~?6ziPL)8LEu@l%;hG zj2>L3=&3^TXBq~ZY6@7s`p<3b4ELEtO#B@r!r-O(1JES%eV9B9HnGqu!0CnLUvk#0 zwNrL~xdv%^Yw8XNSR@>UDPS8>LpQg@=xJ+c$I+ZBR7=623DnNj<-Hw5LK1UI$Az2rr8$KH!*_it!v(-xJq@YRXI*h^{^e;62Y-?6;Z2&9t4zB@$!0W zz?AL4v38r6advWl2)_*rWjFp4BG-e;PKwQhs9;5V6WCymvgOeV9bq3fLD1-BFif%z z)sO}9q-$>0zB0i^?2h72+7sPke1_BvVx9@>uhk}z`ux3a5D5U&eJ>MUTZs&~e1IoT zsf)~g2%&;dRa)I7GzArUN)qN!je8-gca+u{AdGM^84Zpaz(U=qxH)TxhYE^KNO%&{!jbfH0O)dU0E zxwyKUMr)FbZki3D9t9@c3#;*ek~Z2Uu`cOJ&T){5lHFamLJ_U2!((#OoD{!q zdOs7j36elk7xU?7!~x3OoX8mMzi@G1D4}4}NfeOXG>Omv=+Oi*%S)?fG6%bPCMOHj zoXtCMCPxTY20i4_LcYY^?Cjpo%!L6AMQMBPf2To?Jz%FHc-jrA&6a>agapey(c8aH z0!b*=cMM+&Z)CKcslrlw7{4OjYmOP4{AY(#qG4wnW`z~q&wKAX&-tEQugIZTxw(fe10!bzGr9+VrTWgd52 z26D9HxgI0oRnh2uI|!r&@|%ve1@YvV=u?WA2e2WyxVLk#3!yLupj7nQ-VDO9TRPO; zy`7cB$U__uMDc_@aUZlsj=LSP(2}teBFTIV)yX;Vl2vhBnarO!sd1M%4J7a4u7*T`tMrvMi-YI+ zAJV{=C+*l)1751)L+R{R^t0Z#0)3}V%M_(oVxYijWLcJE`x^ni8}1?s?GOtvh%f0h zeAiu3G{2#%i9NoW%&NO z$|IcPDv)%ulB(K}bQl8&9MPi%tP8Fw4gC3083eC?Y~|W*C;SEzE3p+IJB!>TQVmno z8tieiNjgf(8Pt(r93X6sg&ao}C(Py;ie9Y16G6Fo#tjZ6s0s4Dj=r|f(Q{34u8Im9 z@Uy6PA`d&I0RbRsMTE%YZNR)W->?bD2-HG_6sYnrlM_YiR0Y%5`v~K*LZB4fkV?ms z*04xU6cQtWo8ac)31w@O3Y3)bDhk_(4PFWq0NxFj9tIp`I>g;JDOM-8bkt?R5#*m5xbJIe= zh;{`Wp$eBGIUkgg70xZ1)ts7|T6(2(FSwB}ORQaO$HTcb;I{U1-8R{za97C{pE8fK zhyXmUVwi>+XK1<*3Hmi9Ndv=~3T%0W^H+(c*)0VJI5r#bkH{JV-$lI6S{WZ#VQl6B zV7rJjjyOdW9~ZVwoHY{+lv)9nL=YNB2?Ue})iWNn>hb7Nqpr%)ivdry9#a@R#S*;f3P>iwHd;W0Tq_8o`!rCWE->0rf%(}lSPLxxt%3I5AfJj zbiC?Tw=B|V0OX(#CU?7c)d_UX2~u&t&+N2>7YQUYP{2Sv`qhSv)P2d0%q_%-vjV~l zesfoq(daGj?_37TEGQ5C-m2UUYmfNdkOp|jqmtbkd;;#gGmVe@!b!_wRzTyff*!YB zn8gIZJ?>Bex9Zg`T2QWzyT!u|;$VNx65k#jK$OFN$;QrL?In+GZ@zA0d-JiEKwh+e z5fW)c_Bt5C@8TuERj@-_e#v04KYYnPPJ~e~j(+6k6Pj>qP2waNYHC1alc{lwtT=TQ zSb(avSENb=bd?TlAb!r=3)@7;i0OrsQ9gr2m;a#B!i{*Z{iQEbgG!oNnUm+7KKfpS zK+K)-`!shI2AP;FrM(hDv4lk|&fzpB-fr7+$ zV`OflU;>R7R4>=Al~vLM@+c=coaF3Is+2+*sM%!mvom=7jgR&?4~o>MrWh22pXg2< z)!U8FfEF|mhMe6^Vp{G}xMFbCNt{CwQCbgeXc@q!`ne4Ru3FL{Nd0Pd*NMQu# z(*Whn`sUi!>M0P1z`Ru<`*E_Vfc6>mVTTAzPmWm9e3=+V+@LxV$cQVM8$O!8EEoVL zV3bh~450yT185CYq}W=?&If)8L6T)-%C``;7V(f*STH}wi54pvNe0k*Cv$yFVvt>2 zmE!u%)! zZg&NwEULmtz_xXcdg3H~A4uE4I7dU?k_m&MNXi{g&8&{nP`lJ1%;;z8rOIZ_lOZb3c@C|KQolT{8O)e ztwvR&vyO3?63=hg1F0t7-Mt{)FT0B|$^BDUl&ON% z7PS*KiL%%fFCPqr2i+g+;!^JIX*4)lRSc`)Fti4-7(oPKUN4@|e;D8N1XMnDHXC~B z6z+g(OZMC1Ds#U=;|S6V>n({Rr-iNsLlx;L#?edQufz(71VQP@k&D{RbfZ#D(O!4g z1L?Kq!ass=FUph!LtB;({oPz_|aJ_nUv9HoN`jvSp%Y3H=uDur)Wa!?Mp5zUpfr>SYO z{yf^`MU!5+B*3bd1DIG^LX*%5@hr#Cde6;|CQe2pNvw;9qs`@W1`6U{C80v@ytBda zsQOtVs09b1?g3Di_O6O_`UaqO)es=bfoTXNZdM)~K~#_$BGrr`)ghsOc@t@1kYh*z zc_iAewO73e3h~e?+}6qz$x}_$N?qpj0(JUjq4c7-e|5#^X_eB67lLK%5VA)O0~@^E zaWM8k<1;va((gZ^iYFvq+wF+sY?9df`

-v_OkI^zOr{C&r~u-X>KzVz`rV9hQ~ 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�^FymIo5sS9Z|c1!?-sA}PVp-560hExUDHebcji!ko1W+-m@@}1!@fu85X4~H$CXYqZZ9z-jAh=ZNy zj{Qxi<_na_h}M51Z9O0Ahkd~#$OPdcZ&KVNbzrF75Nzn*haIdzEUU!69<2l3qxHUO z4Y7|ujeUh;m@F{;wYC1+Y}K0*1;!gfTNJt4TR#1G*qH?uxqMbJpOwAMcY|I3R}P`K z$T_fCNCWb=3Ic++`FJ=8W#IGgid;Rv{QfYbSr$126&bLxUyt=zB#&GaE&N@t&qj-b z$SV~@3+z93R#0=X5=Vx1Sd8Bl>?86@h5m1H=!n2vV;xzAiiM~3hR=HHuvbjll-Din z=~KN&Dkln9fK}S`nAa`zNGg?*1)-i7YrH>y{aoMKcC|nU<(n_W3=|;CK74 zY^rc9U+-1EEi^R8A{$cF%cj0J)?<;a7g6*Zv-XQ9IX=fd4OHVm7^XZtHV@_c%Ite8)x-uwca|L38{ z3oQOmp`m#epB7$SsCQReg?ihMe#E~bIh#vUmmxadXSmY2C_pq_mSdT@H ztB9kX=k?iWaS(Z>0*+$;v9kgh$x0j<+F>z%S0E$vN`?OGkc6v^`^K}UAk97CVDu%s zkKlmMb7WHQ1JL?MC1_UQ~zqd{?%ACEmvj!S?T(Gqp#81!rCsf_#5HXqb&ZWzq0F-PY=H8ZkY8j^@ir_4b9gZ8apCI7I{
  • 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

    rDqx$o{tfkvZb-zp&_$yMTBV+9^?ItEjqNHt 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 S0WI9^SH-hV4al)IME?(YJKdH5 literal 451933 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 z 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

    J`@JQyOk7cVus+wZ{OO5Y`sBqg&}Uqx}k? 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

    -v_OkI^zOr{C&r~u-X>KzVz`rV9hQ~ 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�^FymIo5sS9Z|c1!?-sA}PVp-560hExUDHebcji!ko1W+-m@@}1!@fu85X4~H$CXYqZZ9z-jAh=ZNy zj{Qxi<_na_h}M51Z9O0Ahkd~#$OPdcZ&KVNbzrF75Nzn*haIdzEUU!69<2l3qxHUO z4Y7|ujeUh;m@F{;wYC1+Y}K0*1;!gfTNJt4TR#1G*qH?uxqMbJpOwAMcY|I3R}P`K z$T_fCNCWb=3Ic++`FJ=8W#IGgid;Rv{QfYbSr$126&bLxUyt=zB#&GaE&N@t&qj-b z$SV~@3+z93R#0=X5=Vx1Sd8Bl>?86@h5m1H=!n2vV;xzAiiM~3hR=HHuvbjll-Din z=~KN&Dkln9fK}S`nAa`zNGg?*1)-i7YrH>y{aoMKcC|nU<(n_W3=|;CK74 zY^rc9U+-1EEi^R8A{$cF%cj0J)?<;a7g6*Zv-XQ9IX=fd4OHVm7^XZtHV@_c%Ite8)x-uwca|L38{ z3oQOmp`m#epB7$SsCQReg?ihMe#E~bIh#vUmmxadXSmY2C_pq_mSdT@H ztB9kX=k?iWaS(Z>0*+$;v9kgh$x0j<+F>z%S0E$vN`?OGkc6v^`^K}UAk97CVDu%s zkKlmMb7WHQ1JL?MC1_UQ~zqd{?%ACEmvj!S?T(Gqp#81!rCsf_#5HXqb&ZWzq0F-PY=H8ZkY8j^@ir_4b9gZ8apCI7I{

    6;s^9=5F@A)|Y(v%m4rjEPh#9j}I@7 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 diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 27c1f38b40..41e57741a0 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -179,7 +179,6 @@ void* writer(void* arg) void initializeDatabase() { connection conn(cfg.connections[0]); -#if 0 printf("creating extension\n"); { nontransaction txn(conn); @@ -197,7 +196,6 @@ void initializeDatabase() txn.commit(); } printf("table t created\n"); -#endif printf("inserting stuff into t\n"); { work txn(conn); From b86825bbddc57393adb3e7ead9a01a508689ab00 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 12 Feb 2016 12:30:01 +0300 Subject: [PATCH 0253/1139] Refactoring of mmts --- arbiter.c | 314 ++++++++++++++++++++++----------- multimaster.c | 441 ++++++++++++++++++++++------------------------ multimaster.h | 76 ++++---- pglogical_apply.c | 4 +- pglogical_proto.c | 4 +- 5 files changed, 464 insertions(+), 375 deletions(-) diff --git a/arbiter.c b/arbiter.c index 0567247254..63e9c61033 100644 --- a/arbiter.c +++ b/arbiter.c @@ -63,7 +63,7 @@ #endif #endif -#ifdef USE_EPOLL +#if USE_EPOLL #include #else #include @@ -78,56 +78,73 @@ typedef enum { + MSG_READY, MSG_PREPARE, MSG_COMMIT, - MSG_ABORT + MSG_ABORT, + MSG_PREPARED, + MSG_COMMITTED, + MSG_ABORTED } MessageCode; typedef struct { - MessageCode code; /* Message code: MSG_PREPARE, MSG_COMMIT, MSG_ABORT + MessageCode code; /* Message code: MSG_READY, MSG_PREPARE, MSG_COMMIT, MSG_ABORT */ int node; /* Sender node ID */ TransactionId dxid; /* Transaction ID at destination node */ TransactionId sxid; /* Transaction IO at sender node */ csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ -} DtmCommitMessage; +} MtmCommitMessage; typedef struct { int used; - DtmCommitMessage data[BUFFER_SIZE]; -} DtmBuffer; + MtmCommitMessage data[BUFFER_SIZE]; +} MtmBuffer; static int* sockets; -static DtmState* ds; +static MtmState* ds; + +static void MtmTransSender(Datum arg); +static void MtmTransReceiver(Datum arg); + +static char const* const messageText[] = +{ + "READY", + "PREPARE", + "COMMIT", + "ABORT", + "PREPARED", + "COMMITTED", + "ABORTED" +}; -static void DtmTransSender(Datum arg); -static void DtmTransReceiver(Datum arg); -static BackgroundWorker DtmSender = { +static BackgroundWorker MtmSender = { "mm-sender", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, 1, /* restart in one second (is it possible to restart immediately?) */ - DtmTransSender + MtmTransSender }; -static BackgroundWorker DtmRecevier = { +static BackgroundWorker MtmRecevier = { "mm-receiver", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, 1, /* restart in one second (is it possible to restart immediately?) */ - DtmTransReceiver + MtmTransReceiver }; -void MMArbiterInitialize(void) +void MtmArbiterInitialize(void) { - RegisterBackgroundWorker(&DtmSender); - RegisterBackgroundWorker(&DtmRecevier); + RegisterBackgroundWorker(&MtmSender); + RegisterBackgroundWorker(&MtmRecevier); } -static int resolve_host_by_name(const char *hostname, unsigned* addrs, unsigned* n_addrs) +static int +MtmResolveHostByName(const char *hostname, unsigned* addrs, unsigned* n_addrs) { struct sockaddr_in sin; struct hostent* hp; @@ -158,7 +175,7 @@ static int max_fd; static fd_set inset; #endif -static void registerSocket(int fd, int i) +static void MtmRegisterSocket(int fd, int i) { #if USE_EPOLL struct epoll_event ev; @@ -177,7 +194,7 @@ static void registerSocket(int fd, int i) -static int connectSocket(char const* host, int port) +static int MtmConnectSocket(char const* host, int port) { struct sockaddr_in sock_inet; unsigned addrs[MAX_ROUTES]; @@ -188,7 +205,7 @@ static int connectSocket(char const* host, int port) sock_inet.sin_family = AF_INET; sock_inet.sin_port = htons(port); - if (!resolve_host_by_name(host, addrs, &n_addrs)) { + if (!MtmResolveHostByName(host, addrs, &n_addrs)) { elog(ERROR, "Failed to resolve host '%s' by name", host); } sd = socket(AF_INET, SOCK_STREAM, 0); @@ -223,11 +240,11 @@ static int connectSocket(char const* host, int port) } } -static void openConnections() +static void MtmOpenConnections() { - int nNodes = MMNodes; + int nNodes = MtmNodes; int i; - char* connStr = pstrdup(MMConnStrs); + char* connStr = pstrdup(MtmConnStrs); sockets = (int*)palloc(sizeof(int)*nNodes); @@ -235,7 +252,7 @@ static void openConnections() char* host = strstr(connStr, "host="); char* end; if (host == NULL) { - elog(ERROR, "Invalid connection string: '%s'", MMConnStrs); + elog(ERROR, "Invalid connection string: '%s'", MtmConnStrs); } host += 5; for (end = host; *end != ' ' && *end != ',' && *end != '\0'; end++); @@ -245,23 +262,23 @@ static void openConnections() } else { connStr = end; } - sockets[i] = i+1 != MMNodeId ? connectSocket(host, MMArbiterPort + i + 1) : -1; + sockets[i] = i+1 != MtmNodeId ? MtmConnectSocket(host, MtmArbiterPort + i + 1) : -1; } } -static void acceptConnections() +static void MtmAcceptConnections() { struct sockaddr_in sock_inet; int i; int sd; int on = 1; - int nNodes = MMNodes-1; + int nNodes = MtmNodes-1; sockets = (int*)palloc(sizeof(int)*nNodes); sock_inet.sin_family = AF_INET; sock_inet.sin_addr.s_addr = htonl(INADDR_ANY); - sock_inet.sin_port = htons(MMArbiterPort + MMNodeId); + sock_inet.sin_port = htons(MtmArbiterPort + MtmNodeId); sd = socket(sock_inet.sin_family, SOCK_STREAM, 0); if (sd < 0) { @@ -272,7 +289,7 @@ static void acceptConnections() if (bind(sd, (struct sockaddr*)&sock_inet, sizeof(sock_inet)) < 0) { elog(ERROR, "Failed to bind socket: %d", errno); } - if (listen(sd, MMNodes-1) < 0) { + if (listen(sd, MtmNodes-1) < 0) { elog(ERROR, "Failed to listen socket: %d", errno); } @@ -281,13 +298,13 @@ static void acceptConnections() if (fd < 0) { elog(ERROR, "Failed to accept socket: %d", errno); } - registerSocket(fd, i); + MtmRegisterSocket(fd, i); sockets[i] = fd; } close(sd); } -static void writeSocket(int sd, void const* buf, int size) +static void MtmWriteSocket(int sd, void const* buf, int size) { char* src = (char*)buf; while (size != 0) { @@ -300,7 +317,7 @@ static void writeSocket(int sd, void const* buf, int size) } } -static int readSocket(int sd, void* buf, int buf_size) +static int MtmReadSocket(int sd, void* buf, int buf_size) { int rc = recv(sd, buf, buf_size, 0); if (rc <= 0) { @@ -309,43 +326,55 @@ static int readSocket(int sd, void* buf, int buf_size) return rc; } -static bool IsCoordinator(DtmTransState* ts) -{ - return ts->dsid.node == MMNodeId; -} -static void DtmAppendBuffer(MessageCode code, DtmBuffer* txBuffer, TransactionId xid, int node, DtmTransState* ts) +static void MtmAppendBuffer(MessageCode code, MtmBuffer* txBuffer, TransactionId xid, int node, MtmTransState* ts) { - DtmBuffer* buf = &txBuffer[node]; + MtmBuffer* buf = &txBuffer[node]; if (buf->used == BUFFER_SIZE) { - writeSocket(sockets[node], buf->data, buf->used*sizeof(DtmCommitMessage)); + MtmWriteSocket(sockets[node], buf->data, buf->used*sizeof(MtmCommitMessage)); buf->used = 0; } + DTM_TRACE("Send message %s CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", + messageText[code], ts->csn, node, MtmNodeId, ts->gtid.xid, ts->xid); buf->data[buf->used].code = code; buf->data[buf->used].dxid = xid; buf->data[buf->used].sxid = ts->xid; - buf->data[buf->used].csn = ts->status == TRANSACTION_STATUS_ABORTED ? INVALID_CSN : ts->csn; - buf->data[buf->used].node = MMNodeId; + buf->data[buf->used].csn = ts->csn; + buf->data[buf->used].node = MtmNodeId; buf->used += 1; } -static void DtmTransSender(Datum arg) +static void MtmBroadcastMessage(MessageCode code, MtmBuffer* txBuffer, MtmTransState* ts) +{ + int i; + int n = 1; + for (i = 0; i < MtmNodes; i++) + { + if (TransactionIdIsValid(ts->xids[i])) { + MtmAppendBuffer(code, txBuffer, ts->xids[i], i, ts); + n += 1; + } + } + Assert(n == ds->nNodes); +} + +static void MtmTransSender(Datum arg) { - int nNodes = MMNodes; + int nNodes = MtmNodes; int i; - DtmBuffer* txBuffer = (DtmBuffer*)palloc(sizeof(DtmBuffer)*nNodes); + MtmBuffer* txBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); sockets = (int*)palloc(sizeof(int)*nNodes); - ds = MMGetState(); + ds = MtmGetState(); - openConnections(); + MtmOpenConnections(); for (i = 0; i < nNodes; i++) { txBuffer[i].used = 0; } while (true) { - DtmTransState* ts; + MtmTransState* ts; PGSemaphoreLock(&ds->votingSemaphore); CHECK_FOR_INTERRUPTS(); @@ -355,34 +384,64 @@ static void DtmTransSender(Datum arg) SpinLockRelease(&ds->votingSpinlock); for (; ts != NULL; ts = ts->nextVoting) { - if (IsCoordinator(ts)) { - /* Coordinator is broadcasting PREPARE message to replicas */ - for (i = 0; i < nNodes; i++) { - if (TransactionIdIsValid(ts->xids[i])) { - DtmAppendBuffer(CMD_PREPARE, txBuffer, ts->xids[i], i, ts); - } + if (MtmIsCoordinator(ts)) { + /* Coordinator is broadcasting message to replicas */ + MessageCode code = MSG_ABORT; + switch (ts->status) { + case TRANSACTION_STATUS_IN_PROGRESS: + code = MSG_PREPARE; + break; + case TRANSACTION_STATUS_COMMITTED: + code = MSG_COMMIT; + break; + case TRANSACTION_STATUS_ABORTED: + code = MSG_ABORT; + break; + default: + Assert(false); } + MtmBroadcastMessage(code, txBuffer, ts); } else { - /* Replica is notifying master that it is ready to PREPARE */ - DTM_TRACE("Send notification %ld to coordinator %d from node %d for transaction %d (local transaction %d)\n", - ts->csn, ts->gtid.node, MMNodeId, ts->gtid.xid, ts->xid); - DtmAppendBuffer(CMD_PREPARE, txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); + /* Replica is notifying master about it's state */ + MessageCode code = MSG_ABORT; + switch (ts->status) { + case TRANSACTION_STATUS_UNKNOWN: + code = MSG_READY; + break; + case TRANSACTION_STATUS_IN_PROGRESS: + code = MSG_PREPARED; + break; + case TRANSACTION_STATUS_COMMITTED: + code = MSG_COMMITTED; + break; + case TRANSACTION_STATUS_ABORTED: + code = MSG_ABORTED; + break; + default: + Assert(false); + } + MtmAppendBuffer(code, txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); } } for (i = 0; i < nNodes; i++) { if (txBuffer[i].used != 0) { - writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); + MtmWriteSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(MtmCommitMessage)); txBuffer[i].used = 0; } } } } -static void DtmTransReceiver(Datum arg) +static void MtmWakeUpBackend(MtmTransState* ts) +{ + SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); +} + +static void MtmTransReceiver(Datum arg) { - int nNodes = MMNodes-1; + int nNodes = MtmNodes-1; int i, j, rc; - DtmBuffer* rxBuffer = (DtmBuffer*)palloc(sizeof(DtmBuffer)*nNodes); + MtmBuffer* rxBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); HTAB* xid2state; #if USE_EPOLL @@ -393,10 +452,10 @@ static void DtmTransReceiver(Datum arg) max_fd = 0; #endif - ds = MMGetState(); + ds = MtmGetState(); - acceptConnections(); - xid2state = MMCreateHash(); + MtmAcceptConnections(); + xid2state = MtmCreateHash(); for (i = 0; i < nNodes; i++) { rxBuffer[i].used = 0; @@ -430,56 +489,105 @@ static void DtmTransReceiver(Datum arg) #endif { int nResponses; - rxBuffer[i].used += readSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBuffer[i].used); - nResponses = rxBuffer[i].used/sizeof(DtmCommitMessage); + rxBuffer[i].used += MtmReadSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBuffer[i].used); + nResponses = rxBuffer[i].used/sizeof(MtmCommitMessage); - LWLockAcquire(ds->hashLock, LW_SHARED); + LWLockAcquire(ds->hashLock, LW_EXCLUSIVE); for (j = 0; j < nResponses; j++) { - DtmCommitMessage* msg = &rxBuffer[i].data[j]; - DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); + MtmCommitMessage* msg = &rxBuffer[i].data[j]; + MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); - switch (msg->code) { - case CMD_PREPARE: - if (IsCoordinator(ts)) { - switch (msg->command) { - case CMD_PREPARE: - - if (ts->state == TRANSACTION_STATUS_IN_PROGRESS: - /* transaction is in-prepared stage (in-doubt): calculate max CSN */ - if (msg->csn > ts->csn) { - ts->csn = msg->csn; - } - Assert(ts->nVotes < dtm->nNodes); - if (++ts->nVotes == dtm->nNodes) { /* receive responses from all nodes */ - ts->status = TRANSACTION_STATUS_COMMIT; - - if (ts->state == TRANSACTION_STATUS_UNKNOWN) { - /* All nodes are ready to prepare: switch transaction to in-doubt state */ - ts->csn = dtm_get_csn(); - ts->status = TRANSACTION_STATUS_IN_PROGRESS; - /* and broadcast PREPARE message */ - MMSendNotificationMessage(ts); - } else if (ts->state == CMD_ABORT) { - ts->status = TRANSACTION_STATUS_ABORTED; - - } else { - Assert(ts->state == TRANSACTION_STATUS_IN_PROGRESS); - Assert((unsigned)(msg->node-1) <= (unsigned)nNodes); ts->xids[msg->node-1] = msg->sxid; - DTM_TRACE("Receive response %ld for transaction %d votes %d from node %d (transaction %d)\n", - msg->csn, msg->dxid, ts->nVotes+1, msg->node, msg->sxid); - Assert(ts->nVotes > 0 && ts->nVotes < ds->nNodes); - if (++ts->nVotes == ds->nNodes) { - SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); + + if (MtmIsCoordinator(ts)) { + switch (msg->code) { + case MSG_READY: + if (ts->status == TRANSACTION_STATUS_UNKNOWN) { + Assert(ts->nVotes < ds->nNodes); + if (++ts->nVotes == ds->nNodes) { + /* All nodes are ready to commit: assign CSN and switch to in-doubt state */ + ts->nVotes = 1; /* I voted myself */ + ts->csn = MtmAssignCSN(); + ts->status = TRANSACTION_STATUS_IN_PROGRESS; + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + } + } else { + Assert(ts->status == TRANSACTION_STATUS_ABORTED); + } + break; + case MSG_PREPARED: + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + if (msg->csn > ts->csn) { + ts->csn = msg->csn; + } + Assert(ts->nVotes < ds->nNodes); + if (++ts->nVotes == ds->nNodes) { + /* All nodes are in in-doubt state, ts->csn is maximum of CSNs at all nodes */ + /* Now do commit */ + ts->nVotes = 1; /* I voted myself */ + MtmSyncClock(ts->csn); + ts->status = TRANSACTION_STATUS_COMMITTED; + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + } + break; + case MSG_COMMITTED: + Assert(ts->status == TRANSACTION_STATUS_COMMITTED); + Assert(ts->nVotes < ds->nNodes); + if (++ts->nVotes == ds->nNodes) { + MtmWakeUpBackend(ts); + } + break; + case MSG_ABORTED: + if (ts->status != TRANSACTION_STATUS_ABORTED) { + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + ts->status = TRANSACTION_STATUS_ABORTED; + MtmAdjustSubtransactions(ts); + MtmWakeUpBackend(ts); + } + break; + default: + Assert(false); + } + } else { /* replica */ + switch (msg->code) { + case MSG_PREPARE: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + ts->csn = MtmAssignCSN(); + ts->status = TRANSACTION_STATUS_IN_PROGRESS; + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + break; + case MSG_COMMIT: + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + ts->csn = msg->csn; + MtmSyncClock(ts->csn); + ts->status = TRANSACTION_STATUS_COMMITTED; + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + MtmWakeUpBackend(ts); + break; + case MSG_ABORT: + if (ts->status != TRANSACTION_STATUS_ABORTED) { + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + ts->status = TRANSACTION_STATUS_ABORTED; + MtmAdjustSubtransactions(ts); + MtmWakeUpBackend(ts); + } + break; + default: + Assert(false); + } } } LWLockRelease(ds->hashLock); - rxBuffer[i].used -= nResponses*sizeof(DtmCommitMessage); + rxBuffer[i].used -= nResponses*sizeof(MtmCommitMessage); if (rxBuffer[i].used != 0) { - memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(DtmCommitMessage), rxBuffer[i].used); + memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(MtmCommitMessage), rxBuffer[i].used); } } } diff --git a/multimaster.c b/multimaster.c index 0f1a95529b..f12e019a34 100644 --- a/multimaster.c +++ b/multimaster.c @@ -58,12 +58,12 @@ typedef struct { bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ bool containsDML; /* transaction contains DML statements */ csn_t snapshot; /* transaction snaphsot */ -} DtmCurrentTrans; +} MtmCurrentTrans; typedef uint64 timestamp_t; -#define DTM_SHMEM_SIZE (64*1024*1024) -#define DTM_HASH_SIZE 100003 +#define MTM_SHMEM_SIZE (64*1024*1024) +#define MTM_HASH_SIZE 100003 #define USEC 1000000 #define MIN_WAIT_TIMEOUT 1000 #define MAX_WAIT_TIMEOUT 100000 @@ -77,64 +77,64 @@ PG_FUNCTION_INFO_V1(mm_start_replication); PG_FUNCTION_INFO_V1(mm_stop_replication); PG_FUNCTION_INFO_V1(mm_drop_node); -static Snapshot DtmGetSnapshot(Snapshot snapshot); -static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); -static void DtmInitialize(void); -static void DtmXactCallback(XactEvent event, void *arg); -static void DtmBeginTransaction(DtmCurrentTrans* x); -static void DtmPrepareTransaction(DtmCurrentTrans* x); -static void DtmEndTransaction(DtmCurrentTrans* x); -static Snapshot DtmGetSnapshot(Snapshot snapshot); -static TransactionId DtmGetOldestXmin(Relation rel, bool ignoreVacuum); -static bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); -static TransactionId DtmAdjustOldestXid(TransactionId xid); -static bool DtmDetectGlobalDeadLock(PGPROC* proc); -static void DtmAddSubtransactions(DtmTransState* ts, TransactionId* subxids, int nSubxids); -static char const* DtmGetName(void); - -static void DtmShmemStartup(void); - -static BgwPool* MMPoolConstructor(void); -static bool MMRunUtilityStmt(PGconn* conn, char const* sql); -static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError); -static void MMVoteForTransaction(DtmTransState* ts); +static Snapshot MtmGetSnapshot(Snapshot snapshot); +static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); +static void MtmInitialize(void); +static void MtmXactCallback(XactEvent event, void *arg); +static void MtmBeginTransaction(MtmCurrentTrans* x); +static void MtmPrepareTransaction(MtmCurrentTrans* x); +static void MtmEndTransaction(MtmCurrentTrans* x); +static Snapshot MtmGetSnapshot(Snapshot snapshot); +static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); +static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); +static TransactionId MtmAdjustOldestXid(TransactionId xid); +static bool MtmDetectGlobalDeadLock(PGPROC* proc); +static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int nSubxids); +static char const* MtmGetName(void); + +static void MtmShmemStartup(void); + +static BgwPool* MtmPoolConstructor(void); +static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); +static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); +static void MtmVoteForTransaction(MtmTransState* ts); static HTAB* xid2state; -static DtmCurrentTrans dtmTx; -static DtmState* dtm; +static MtmCurrentTrans dtmTx; +static MtmState* dtm; -static TransactionManager DtmTM = { +static TransactionManager MtmTM = { PgTransactionIdGetStatus, - DtmSetTransactionStatus, - DtmGetSnapshot, + MtmSetTransactionStatus, + MtmGetSnapshot, PgGetNewTransactionId, - DtmGetOldestXmin, + MtmGetOldestXmin, PgTransactionIdIsInProgress, PgGetGlobalTransactionId, - DtmXidInMVCCSnapshot, - DtmDetectGlobalDeadLock, - DtmGetName + MtmXidInMVCCSnapshot, + MtmDetectGlobalDeadLock, + MtmGetName }; -bool MMDoReplication; -char* MMDatabaseName; +bool MtmDoReplication; +char* MtmDatabaseName; -char* MMConnStrs; -int MMNodeId; -int MMArbiterPort; -int MMNodes; +char* MtmConnStrs; +int MtmNodeId; +int MtmArbiterPort; +int MtmNodes; -static int MMQueueSize; -static int MMWorkers; -static int DtmVacuumDelay; +static int MtmQueueSize; +static int MtmWorkers; +static int MtmVacuumDelay; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; static shmem_startup_hook_type PreviousShmemStartupHook; -static void MMExecutorFinish(QueryDesc *queryDesc); -static void MMProcessUtility(Node *parsetree, const char *queryString, +static void MtmExecutorFinish(QueryDesc *queryDesc); +static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag); @@ -143,14 +143,14 @@ static void MMProcessUtility(Node *parsetree, const char *queryString, */ -static timestamp_t dtm_get_current_time() +static timestamp_t MtmGetCurrentTime() { struct timeval tv; gettimeofday(&tv, NULL); return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + dtm->timeShift; } -static void dtm_sleep(timestamp_t interval) +static void MtmSleep(timestamp_t interval) { struct timespec ts; struct timespec rem; @@ -163,9 +163,9 @@ static void dtm_sleep(timestamp_t interval) } } -static csn_t dtm_get_csn() +csn_t MtmAssignCSN() { - csn_t csn = dtm_get_current_time(); + csn_t csn = MtmGetCurrentTime(); if (csn <= dtm->csn) { csn = ++dtm->csn; } else { @@ -174,39 +174,39 @@ static csn_t dtm_get_csn() return csn; } -static csn_t dtm_sync(csn_t global_csn) +csn_t MtmSyncClock(csn_t global_csn) { - csn_t dtm_csn; - while ((dtm_csn = dtm_get_csn()) < global_csn) { - dtm->timeShift += global_csn - dtm_csn; + csn_t local_csn; + while ((local_csn = MtmAssignCSN()) < global_csn) { + dtm->timeShift += global_csn - local_csn; } - return dtm_csn; + return local_csn; } /* * Distribute transaction manager functions */ -static char const* DtmGetName(void) +static char const* MtmGetName(void) { return MULTIMASTER_NAME; } -Snapshot DtmGetSnapshot(Snapshot snapshot) +Snapshot MtmGetSnapshot(Snapshot snapshot) { snapshot = PgGetSnapshotData(snapshot); - RecentGlobalDataXmin = RecentGlobalXmin = DtmAdjustOldestXid(RecentGlobalDataXmin); + RecentGlobalDataXmin = RecentGlobalXmin = MtmAdjustOldestXid(RecentGlobalDataXmin); return snapshot; } -TransactionId DtmGetOldestXmin(Relation rel, bool ignoreVacuum) +TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum) { TransactionId xmin = PgGetOldestXmin(rel, ignoreVacuum); - xmin = DtmAdjustOldestXid(xmin); + xmin = MtmAdjustOldestXid(xmin); return xmin; } -bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) +bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) { #if TRACE_SLEEP_TIME static timestamp_t firstReportTime; @@ -221,31 +221,31 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) #if TRACE_SLEEP_TIME if (firstReportTime == 0) { - firstReportTime = dtm_get_current_time(); + firstReportTime = MtmGetCurrentTime(); } #endif while (true) { - DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { if (ts->csn > dtmTx.snapshot) { - DTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", + MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", getpid(), xid, ts->csn, dtmTx.snapshot); LWLockRelease(dtm->hashLock); return true; } if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { - DTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); + MTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); LWLockRelease(dtm->hashLock); #if TRACE_SLEEP_TIME { - timestamp_t delta, now = dtm_get_current_time(); + timestamp_t delta, now = MtmGetCurrentTime(); #endif - dtm_sleep(delay); + MtmSleep(delay); #if TRACE_SLEEP_TIME - delta = dtm_get_current_time() - now; + delta = MtmGetCurrentTime() - now; totalSleepTime += delta; if (delta > maxSleepTime) { maxSleepTime = delta; @@ -255,7 +255,7 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (firstReportTime == 0) { firstReportTime = now; } else { - DTM_TRACE("Snapshot sleep %lu of %lu usec (%f%%), maximum=%lu\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime), maxSleepTime); + MTM_TRACE("Snapshot sleep %lu of %lu usec (%f%%), maximum=%lu\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime), maxSleepTime); } } } @@ -268,7 +268,7 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) else { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; - DTM_TUPLE_TRACE("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld\n", + MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld\n", getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot); LWLockRelease(dtm->hashLock); return invisible; @@ -276,7 +276,7 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) } else { - DTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); + MTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); break; } } @@ -284,24 +284,24 @@ bool DtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) return PgXidInMVCCSnapshot(xid, snapshot); } -static uint32 dtm_xid_hash_fn(const void *key, Size keysize) +static uint32 MtmXidHashFunc(const void *key, Size keysize) { return (uint32)*(TransactionId*)key; } -static int dtm_xid_match_fn(const void *key1, const void *key2, Size keysize) +static int MtmXidMatchFunc(const void *key1, const void *key2, Size keysize) { return *(TransactionId*)key1 - *(TransactionId*)key2; } -static void DtmTransactionListAppend(DtmTransState* ts) +static void MtmTransactionListAppend(MtmTransState* ts) { ts->next = NULL; *dtm->transListTail = ts; dtm->transListTail = &ts->next; } -static void DtmTransactionListInsertAfter(DtmTransState* after, DtmTransState* ts) +static void MtmTransactionListInsertAfter(MtmTransState* after, MtmTransState* ts) { ts->next = after->next; after->next = ts; @@ -310,38 +310,53 @@ static void DtmTransactionListInsertAfter(DtmTransState* after, DtmTransState* t } } -static void DtmAddSubtransactions(DtmTransState* ts, TransactionId* subxids, int nSubxids) +static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int nSubxids) { int i; + ts->nSubxids = nSubxids; for (i = 0; i < nSubxids; i++) { bool found; - DtmTransState* sts; + MtmTransState* sts; Assert(TransactionIdIsValid(subxids[i])); - sts = (DtmTransState*)hash_search(xid2state, &subxids[i], HASH_ENTER, &found); + sts = (MtmTransState*)hash_search(xid2state, &subxids[i], HASH_ENTER, &found); Assert(!found); sts->status = ts->status; sts->csn = ts->csn; - DtmTransactionListInsertAfter(ts, sts); + MtmTransactionListInsertAfter(ts, sts); } } +void MtmAdjustSubtransactions(MtmTransState* ts) +{ + int i; + int nSubxids = ts->nSubxids; + MtmTransState* sts = ts; + + for (i = 0; i < nSubxids; i++) { + sts = sts->next; + sts->status = ts->status; + sts->csn = ts->csn; + } +} + + /* * There can be different oldest XIDs at different cluster node. - * Seince we do not have centralized aribiter, we have to rely in DtmVacuumDelay. + * Seince we do not have centralized aribiter, we have to rely in MtmVacuumDelay. * This function takes XID which PostgreSQL consider to be the latest and try to find XID which - * is older than it more than DtmVacuumDelay. + * is older than it more than MtmVacuumDelay. * If no such XID can be located, then return previously observed oldest XID */ static TransactionId -DtmAdjustOldestXid(TransactionId xid) +MtmAdjustOldestXid(TransactionId xid) { if (TransactionIdIsValid(xid)) { - DtmTransState *ts, *prev = NULL; + MtmTransState *ts, *prev = NULL; LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { - timestamp_t cutoff_time = ts->csn - DtmVacuumDelay*USEC; + timestamp_t cutoff_time = ts->csn - MtmVacuumDelay*USEC; for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED); if (prev != NULL) { @@ -361,18 +376,18 @@ DtmAdjustOldestXid(TransactionId xid) return xid; } -static void DtmInitialize() +static void MtmInitialize() { bool found; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); - dtm = (DtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(DtmState), &found); + dtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState), &found); if (!found) { dtm->hashLock = (LWLock*)GetNamedLWLockTranche(MULTIMASTER_NAME); - dtm->csn = dtm_get_current_time(); + dtm->csn = MtmGetCurrentTime(); dtm->oldestXid = FirstNormalTransactionId; - dtm->nNodes = MMNodes; + dtm->nNodes = MtmNodes; dtm->disabledNodeMask = 0; dtm->votingTransactions = NULL; dtm->transListHead = NULL; @@ -383,49 +398,49 @@ static void DtmInitialize() PGSemaphoreCreate(&dtm->votingSemaphore); PGSemaphoreReset(&dtm->votingSemaphore); SpinLockInit(&dtm->votingSpinlock); - BgwPoolInit(&dtm->pool, MMExecutor, MMDatabaseName, MMQueueSize); - RegisterXactCallback(DtmXactCallback, NULL); + BgwPoolInit(&dtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); + RegisterXactCallback(MtmXactCallback, NULL); dtmTx.snapshot = INVALID_CSN; dtmTx.xid = InvalidTransactionId; } - xid2state = MMCreateHash(); - MMDoReplication = true; - TM = &DtmTM; + xid2state = MtmCreateHash(); + MtmDoReplication = true; + TM = &MtmTM; LWLockRelease(AddinShmemInitLock); } static void -DtmXactCallback(XactEvent event, void *arg) +MtmXactCallback(XactEvent event, void *arg) { switch (event) { case XACT_EVENT_START: - DtmBeginTransaction(&dtmTx); + MtmBeginTransaction(&dtmTx); break; case XACT_EVENT_PRE_COMMIT: - DtmPrepareTransaction(&dtmTx); + MtmPrepareTransaction(&dtmTx); break; case XACT_EVENT_COMMIT: case XACT_EVENT_ABORT: - DtmEndTransaction(&dtmTx); + MtmEndTransaction(&dtmTx); default: break; } } static void -DtmBeginTransaction(DtmCurrentTrans* x) +MtmBeginTransaction(MtmCurrentTrans* x) { if (x->snapshot == INVALID_CSN) { LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; - x->isDistributed = IsNormalProcessingMode() && dtm->initialized && MMDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); + x->isDistributed = IsNormalProcessingMode() && dtm->initialized && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); x->containsDML = false; - x->snapshot = dtm_get_csn(); + x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; LWLockRelease(dtm->hashLock); - DTM_TRACE("DtmLocalTransaction: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot); + MTM_TRACE("MtmLocalTransaction: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot); } } @@ -433,9 +448,9 @@ DtmBeginTransaction(DtmCurrentTrans* x) * We need to pass snapshot to WAL-sender, so create record in transaction status hash table * before commit */ -static void DtmPrepareTransaction(DtmCurrentTrans* x) +static void MtmPrepareTransaction(MtmCurrentTrans* x) { - DtmTransState* ts; + MtmTransState* ts; bool found; int i; @@ -451,16 +466,16 @@ static void DtmPrepareTransaction(DtmCurrentTrans* x) Assert(!found); ts->snapshot = x->isReplicated ? INVALID_CSN : x->snapshot; ts->status = TRANSACTION_STATUS_UNKNOWN; - ts->csn = dtm_get_csn(); + ts->csn = MtmAssignCSN(); ts->procno = MyProc->pgprocno; ts->nVotes = 1; /* My own voice */ - for (i = 0; i < MMNodes; i++) { + for (i = 0; i < MtmNodes; i++) { ts->xids[i] = InvalidTransactionId; } if (!TransactionIdIsValid(x->gtid.xid)) { ts->gtid.xid = x->xid; - ts->gtid.node = MMNodeId; + ts->gtid.node = MtmNodeId; } else { ts->gtid = x->gtid; } @@ -468,87 +483,61 @@ static void DtmPrepareTransaction(DtmCurrentTrans* x) } static void -DtmEndTransaction(DtmCurrentTrans* x) +MtmEndTransaction(MtmCurrentTrans* x) { x->snapshot = INVALID_CSN; x->xid = InvalidTransactionId; x->gtid.xid = InvalidTransactionId; } -void MMSendNotificationMessage(DtmTransState* ts) +void MtmSendNotificationMessage(MtmTransState* ts) { - DtmTransState* votingList; + MtmTransState* votingList; SpinLockAcquire(&dtm->votingSpinlock); votingList = dtm->votingTransactions; ts->nextVoting = votingList; dtm->votingTransactions = ts; SpinLockRelease(&dtm->votingSpinlock); - DTM_TRACE("Register commit message\n"); + MTM_TRACE("Register commit message\n"); if (votingList == NULL) { /* singal semaphore only once for the whole list */ - DTM_TRACE("Signal semaphore\n"); + MTM_TRACE("Signal semaphore\n"); PGSemaphoreUnlock(&dtm->votingSemaphore); } } static XidStatus -DtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) +MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { - DtmTransState* ts; - csn_t localCSN; - csn_t globalCSN; - int i; - XidStatus status; + MtmTransState* ts; LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); ts = hash_search(xid2state, &xid, HASH_FIND, NULL); - Assert(ts != NULL); /* should be created by DtmPrepareTransaction */ - - /* now transaction is in doubt state */ - ts->status = TRANSACTION_STATUS_IN_PROGRESS; - localCSN = dtm_get_csn(); - ts->csn = localCSN; - DtmTransactionListAppend(ts); - DtmAddSubtransactions(ts, subxids, nsubxids); - - MMVoteForTransaction(ts); /* wait until transaction at all nodes are prepared */ - globalCSN = ts->csn; - Assert(globalCSN >= localCSN); - - if (globalCSN != INVALID_CSN) { - dtm_sync(globalCSN); - status = TRANSACTION_STATUS_COMMITTED; - } else { - ts->csn = globalCSN = localCSN; - status = TRANSACTION_STATUS_ABORTED; - } - ts->status = status; - for (i = 0; i < nsubxids; i++) { - ts = ts->next; - ts->status = status; - ts->csn = globalCSN; - } + Assert(ts != NULL); /* should be created by MtmPrepareTransaction */ + + MtmTransactionListAppend(ts); + MtmAddSubtransactions(ts, subxids, nsubxids); + LWLockRelease(dtm->hashLock); - return status; + + MtmVoteForTransaction(ts); + + return ts->status; } static void -DtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status) +MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status) { - int i; - DtmTransState* ts; + MtmTransState* ts; LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); ts = hash_search(xid2state, &xid, HASH_FIND, NULL); - if (ts != NULL) { /* should be created by DtmPrepareTransaction */ + if (ts != NULL) { ts->status = status; - for (i = 0; i < nsubxids; i++) { - ts = ts->next; - ts->status = status; - } + MtmAdjustSubtransactions(ts); if (dtmTx.isReplicated) { - MMSendNotificationMessage(ts); + MtmSendNotificationMessage(ts); } } LWLockRelease(dtm->hashLock); @@ -557,20 +546,20 @@ DtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi static void -DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) +MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) { - DTM_TRACE("%d: DtmSetTransactionStatus %u = %u\n", getpid(), xid, status); + MTM_TRACE("%d: MtmSetTransactionStatus %u = %u\n", getpid(), xid, status); if (xid == dtmTx.xid && dtmTx.isDistributed) { if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML) { - DtmFinishTransaction(xid, nsubxids, subxids, status); - DTM_TRACE("Abort transaction %d\n", xid); + MtmFinishTransaction(xid, nsubxids, subxids, status); + MTM_TRACE("Abort transaction %d\n", xid); } else { - if (DtmCommitTransaction(xid, nsubxids, subxids) == TRANSACTION_STATUS_COMMITTED) { - DTM_TRACE("Commit transaction %d\n", xid); + if (MtmCommitTransaction(xid, nsubxids, subxids) == TRANSACTION_STATUS_COMMITTED) { + MTM_TRACE("Commit transaction %d\n", xid); } else { PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, TRANSACTION_STATUS_ABORTED, lsn); dtmTx.isDistributed = false; @@ -584,19 +573,19 @@ DtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, } static bool -DtmDetectGlobalDeadLock(PGPROC* proc) +MtmDetectGlobalDeadLock(PGPROC* proc) { elog(WARNING, "Global deadlock?"); return true; } static void -DtmShmemStartup(void) +MtmShmemStartup(void) { if (PreviousShmemStartupHook) { PreviousShmemStartupHook(); } - DtmInitialize(); + MtmInitialize(); } /* @@ -621,7 +610,7 @@ _PG_init(void) "multimaster.vacuum_delay", "Minimal age of records which can be vacuumed (seconds)", NULL, - &DtmVacuumDelay, + &MtmVacuumDelay, 10, 1, INT_MAX, @@ -636,7 +625,7 @@ _PG_init(void) "multimaster.workers", "Number of multimaster executor workers per node", NULL, - &MMWorkers, + &MtmWorkers, 8, 1, INT_MAX, @@ -651,7 +640,7 @@ _PG_init(void) "multimaster.queue_size", "Multimaster queue size", NULL, - &MMQueueSize, + &MtmQueueSize, 1024*1024, 1024, INT_MAX, @@ -666,7 +655,7 @@ _PG_init(void) "multimaster.arbiter_port", "Base value for assigning arbiter ports", NULL, - &MMArbiterPort, + &MtmArbiterPort, 54321, 0, INT_MAX, @@ -681,7 +670,7 @@ _PG_init(void) "multimaster.conn_strings", "Multimaster node connection strings separated by commas, i.e. 'replication=database dbname=postgres host=localhost port=5001,replication=database dbname=postgres host=localhost port=5002'", NULL, - &MMConnStrs, + &MtmConnStrs, "", PGC_BACKEND, // context 0, // flags, @@ -694,7 +683,7 @@ _PG_init(void) "multimaster.node_id", "Multimaster node ID", NULL, - &MMNodeId, + &MtmNodeId, 1, 1, INT_MAX, @@ -708,30 +697,30 @@ _PG_init(void) /* * Request additional shared resources. (These are no-ops if we're not in * the postmaster process.) We'll allocate or attach to the shared - * resources in dtm_shmem_startup(). + * resources in mtm_shmem_startup(). */ - RequestAddinShmemSpace(DTM_SHMEM_SIZE + MMQueueSize); + RequestAddinShmemSpace(MTM_SHMEM_SIZE + MtmQueueSize); RequestNamedLWLockTranche(MULTIMASTER_NAME, 1); - MMNodes = MMStartReceivers(MMConnStrs, MMNodeId); - if (MMNodes < 2) { + MtmNodes = MtmStartReceivers(MtmConnStrs, MtmNodeId); + if (MtmNodes < 2) { elog(ERROR, "Multimaster should have at least two nodes"); } - BgwPoolStart(MMWorkers, MMPoolConstructor); + BgwPoolStart(MtmWorkers, MtmPoolConstructor); - MMArbiterInitialize(); + MtmArbiterInitialize(); /* * Install hooks. */ PreviousShmemStartupHook = shmem_startup_hook; - shmem_startup_hook = DtmShmemStartup; + shmem_startup_hook = MtmShmemStartup; PreviousExecutorFinishHook = ExecutorFinish_hook; - ExecutorFinish_hook = MMExecutorFinish; + ExecutorFinish_hook = MtmExecutorFinish; PreviousProcessUtilityHook = ProcessUtility_hook; - ProcessUtility_hook = MMProcessUtility; + ProcessUtility_hook = MtmProcessUtility; } /* @@ -751,10 +740,10 @@ _PG_fini(void) * *************************************************************************** */ -void MMJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot) +void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot) { LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - dtm_sync(snapshot); + MtmSyncClock(snapshot); LWLockRelease(dtm->hashLock); dtmTx.gtid = *gtid; @@ -765,16 +754,16 @@ void MMJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot) dtmTx.containsDML = true; } -void MMReceiverStarted() +void MtmReceiverStarted() { if (pg_atomic_fetch_add_u32(&dtm->nReceivers, 1) == dtm->nNodes-2) { dtm->initialized = true; } } -csn_t MMTransactionSnapshot(TransactionId xid) +csn_t MtmTransactionSnapshot(TransactionId xid) { - DtmTransState* ts; + MtmTransState* ts; csn_t snapshot = INVALID_CSN; LWLockAcquire(dtm->hashLock, LW_SHARED); @@ -790,14 +779,14 @@ csn_t MMTransactionSnapshot(TransactionId xid) Datum mm_start_replication(PG_FUNCTION_ARGS) { - MMDoReplication = true; + MtmDoReplication = true; PG_RETURN_VOID(); } Datum mm_stop_replication(PG_FUNCTION_ARGS) { - MMDoReplication = false; + MtmDoReplication = false; dtmTx.isDistributed = false; PG_RETURN_VOID(); } @@ -817,7 +806,7 @@ mm_drop_node(PG_FUNCTION_ARGS) dtm->nNodes -= 1; if (!IsTransactionBlock()) { - MMBroadcastUtilityStmt(psprintf("select mm_drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); + MtmBroadcastUtilityStmt(psprintf("select mm_drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); } if (dropSlot) { @@ -830,7 +819,7 @@ mm_drop_node(PG_FUNCTION_ARGS) /* * Execute statement with specified parameters and check its result */ -static bool MMRunUtilityStmt(PGconn* conn, char const* sql) +static bool MtmRunUtilityStmt(PGconn* conn, char const* sql) { PGresult *result = PQexec(conn, sql); int status = PQresultStatus(result); @@ -842,15 +831,15 @@ static bool MMRunUtilityStmt(PGconn* conn, char const* sql) return ret; } -static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError) +static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) { - char* conn_str = pstrdup(MMConnStrs); + char* conn_str = pstrdup(MtmConnStrs); char* conn_str_end = conn_str + strlen(conn_str); int i = 0; int64 disabledNodeMask = dtm->disabledNodeMask; int failedNode = -1; char const* errorMsg = NULL; - PGconn **conns = palloc0(sizeof(PGconn*)*MMNodes); + PGconn **conns = palloc0(sizeof(PGconn*)*MtmNodes); while (conn_str < conn_str_end) { @@ -880,19 +869,19 @@ static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError) conn_str = p + 1; i += 1; } - Assert(i == MMNodes); + Assert(i == MtmNodes); - for (i = 0; i < MMNodes; i++) + for (i = 0; i < MtmNodes; i++) { if (conns[i]) { - if (!MMRunUtilityStmt(conns[i], "BEGIN TRANSACTION") && !ignoreError) + if (!MtmRunUtilityStmt(conns[i], "BEGIN TRANSACTION") && !ignoreError) { errorMsg = "Failed to start transaction at node %d"; failedNode = i; break; } - if (!MMRunUtilityStmt(conns[i], sql) && !ignoreError) + if (!MtmRunUtilityStmt(conns[i], sql) && !ignoreError) { errorMsg = "Failed to run command at node %d"; failedNode = i; @@ -902,24 +891,24 @@ static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError) } if (failedNode >= 0 && !ignoreError) { - for (i = 0; i < MMNodes; i++) + for (i = 0; i < MtmNodes; i++) { if (conns[i]) { - MMRunUtilityStmt(conns[i], "ROLLBACK TRANSACTION"); + MtmRunUtilityStmt(conns[i], "ROLLBACK TRANSACTION"); } } } else { - for (i = 0; i < MMNodes; i++) + for (i = 0; i < MtmNodes; i++) { - if (conns[i] && !MMRunUtilityStmt(conns[i], "COMMIT TRANSACTION") && !ignoreError) + if (conns[i] && !MtmRunUtilityStmt(conns[i], "COMMIT TRANSACTION") && !ignoreError) { errorMsg = "Commit failed at node %d"; failedNode = i; } } } - for (i = 0; i < MMNodes; i++) + for (i = 0; i < MtmNodes; i++) { if (conns[i]) { @@ -932,7 +921,7 @@ static void MMBroadcastUtilityStmt(char const* sql, bool ignoreError) } } -static void MMProcessUtility(Node *parsetree, const char *queryString, +static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag) { @@ -974,15 +963,15 @@ static void MMProcessUtility(Node *parsetree, const char *queryString, dtmTx.isDistributed = false; } } else { - MMBroadcastUtilityStmt(queryString, false); + MtmBroadcastUtilityStmt(queryString, false); } } static void -MMExecutorFinish(QueryDesc *queryDesc) +MtmExecutorFinish(QueryDesc *queryDesc) { - if (MMDoReplication) { + if (MtmDoReplication) { CmdType operation = queryDesc->operation; EState *estate = queryDesc->estate; if (estate->es_processed != 0) { @@ -999,65 +988,51 @@ MMExecutorFinish(QueryDesc *queryDesc) } } -void MMExecute(void* work, int size) +void MtmExecute(void* work, int size) { BgwPoolExecute(&dtm->pool, work, size); } static BgwPool* -MMPoolConstructor(void) +MtmPoolConstructor(void) { return &dtm->pool; } static void -MMVoteForTransaction(DtmTransState* ts) +MtmVoteForTransaction(MtmTransState* ts) { - LWLockRelease(dtm->hashLock); - if (ts->gtid.node == MMNodeId) { - /* I am coordinator: wait responses from all replicas for transaction replicated using logical decoding */ - DTM_TRACE("Coordinator waiting latch...\n"); - WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); - ResetLatch(&MyProc->procLatch); - DTM_TRACE("Coordinator receive %d votes\n", ts->nVotes); - Assert(ts->nVotes == dtm->nNodes); - - /* ... and then send notifications to replicas */ - MMSendNotificationMessage(ts); - } else { - /* I am replica: first notify coordinator... */ - ts->nVotes = dtm->nNodes-1; /* I just need one confirmation from coordinator */ - MMSendNotificationMessage(ts); - /* ... and wait response from it */ - DTM_TRACE("Node %d waiting latch...\n", MMNodeId); - WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); - ResetLatch(&MyProc->procLatch); - DTM_TRACE("Node %d receive response...\n", MMNodeId); + if (!MtmIsCoordinator(ts)) { + MtmSendNotificationMessage(ts); /* send READY message to coordinator */ } - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + + MTM_TRACE("Node %d waiting latch...\n", MtmNodeId); + WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); + ResetLatch(&MyProc->procLatch); + MTM_TRACE("Node %d receives response...\n", MtmNodeId); } -HTAB* MMCreateHash(void) +HTAB* MtmCreateHash(void) { HASHCTL info; HTAB* htab; - Assert(MMNodes > 0); + Assert(MtmNodes > 0); memset(&info, 0, sizeof(info)); info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(DtmTransState) + (MMNodes-1)*sizeof(TransactionId); - info.hash = dtm_xid_hash_fn; - info.match = dtm_xid_match_fn; + info.entrysize = sizeof(MtmTransState) + (MtmNodes-1)*sizeof(TransactionId); + info.hash = MtmXidHashFunc; + info.match = MtmXidMatchFunc; htab = ShmemInitHash( "xid2state", - DTM_HASH_SIZE, DTM_HASH_SIZE, + MTM_HASH_SIZE, MTM_HASH_SIZE, &info, HASH_ELEM | HASH_FUNCTION | HASH_COMPARE ); return htab; } -DtmState* -MMGetState(void) +MtmState* +MtmGetState(void) { return dtm; } diff --git a/multimaster.h b/multimaster.h index 6ce80c4e49..9674234933 100644 --- a/multimaster.h +++ b/multimaster.h @@ -4,9 +4,9 @@ #include "bytebuf.h" #include "bgwpool.h" -#define DTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -//#define DTM_TRACE(fmt, ...) -#define DTM_TUPLE_TRACE(fmt, ...) +#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) +//#define MTM_TRACE(fmt, ...) +#define MTM_TUPLE_TRACE(fmt, ...) #define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) @@ -22,21 +22,22 @@ typedef struct TransactionId xid; /* Transaction ID at this node */ } GlobalTransactionId; -typedef struct DtmTransState +typedef struct MtmTransState { TransactionId xid; XidStatus status; GlobalTransactionId gtid; - csn_t csn; /* commit serial number */ - csn_t snapshot; /* transaction snapshot, or INVALID_CSN for local transactions */ - int nVotes; /* number of votes received from replcas for this transaction: - finally should be nNodes-1 */ - int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, - used to notify coordinator by arbiter */ - struct DtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ - struct DtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ - TransactionId xids[1]; /* transaction ID at replicas: varying size MMNodes */ -} DtmTransState; + csn_t csn; /* commit serial number */ + csn_t snapshot; /* transaction snapshot, or INVALID_CSN for local transactions */ + int nVotes; /* number of votes received from replcas for this transaction: + finally should be nNodes-1 */ + int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, + used to notify coordinator by arbiter */ + struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ + struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ + int nSubxids; /* Number of subtransanctions */ + TransactionId xids[1]; /* transaction ID at replicas: varying size MtmNodes */ +} MtmTransState; typedef struct { @@ -46,34 +47,39 @@ typedef struct TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ int64 disabledNodeMask; /* bitmask of disable nodes (so no more than 64 nodes in multimaster:) */ int nNodes; /* number of active nodes */ - pg_atomic_uint32 nReceivers; /* number of initialized logical receivers (used to determine moment when MM intialization is completed */ + pg_atomic_uint32 nReceivers; /* number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ long timeShift; /* local time correction */ bool initialized; csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ - DtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. + MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. This list is used to pass information to mm-sender BGW */ - DtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. - It is cleanup by DtmGetOldestXmin */ - DtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. + MtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. + It is cleanup by MtmGetOldestXmin */ + MtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. This list is expected to be in CSN ascending order, by strict order may be violated */ BgwPool pool; /* Pool of background workers for applying logical replication patches */ -} DtmState; +} MtmState; -extern char* MMConnStrs; -extern int MMNodeId; -extern int MMNodes; -extern int MMArbiterPort; -extern char* MMDatabaseName; +#define MtmIsCoordinator(ts) (ts->gtid.node == MtmNodeId) -extern void MMArbiterInitialize(void); -extern int MMStartReceivers(char* nodes, int node_id); -extern csn_t MMTransactionSnapshot(TransactionId xid); -extern void MMJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot); -extern void MMReceiverStarted(void); -extern void MMExecute(void* work, int size); -extern void MMExecutor(int id, void* work, size_t size); -extern HTAB* MMCreateHash(void); -extern void MMSendNotificationMessage(DtmTransState* ts); -extern DtmState* MMGetState(void); +extern char* MtmConnStrs; +extern int MtmNodeId; +extern int MtmNodes; +extern int MtmArbiterPort; +extern char* MtmDatabaseName; + +extern void MtmArbiterInitialize(void); +extern int MtmStartReceivers(char* nodes, int node_id); +extern csn_t MtmTransactionSnapshot(TransactionId xid); +extern csn_t MtmAssignCSN(void); +extern csn_t MtmSyncClock(csn_t csn); +extern void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot); +extern void MtmReceiverStarted(void); +extern void MtmExecute(void* work, int size); +extern void MtmExecutor(int id, void* work, size_t size); +extern HTAB* MtmCreateHash(void); +extern void MtmSendNotificationMessage(MtmTransState* ts); +extern void MtmAdjustSubtransactions(MtmTransState* ts); +extern MtmState* MtmGetState(void); #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index aa554dd525..1d2202048f 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -332,7 +332,7 @@ process_remote_begin(StringInfo s) snapshot = pq_getmsgint64(s); SetCurrentStatementStartTimestamp(); StartTransactionCommand(); - MMJoinTransaction(>id, snapshot); + MtmJoinTransaction(>id, snapshot); fprintf(stderr, "REMOTE begin node=%d xid=%d snapshot=%ld\n", gtid.node, gtid.xid, snapshot); } @@ -759,7 +759,7 @@ process_remote_delete(StringInfo s, Relation rel) static MemoryContext ApplyContext; -void MMExecutor(int id, void* work, size_t size) +void MtmExecutor(int id, void* work, size_t size) { StringInfoData s; Relation rel = NULL; diff --git a/pglogical_proto.c b/pglogical_proto.c index f5ae6ec630..ec37508c2a 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -104,14 +104,14 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, ReorderBufferTXN *txn) { PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; - csn_t csn = MMTransactionSnapshot(txn->xid); + csn_t csn = MtmTransactionSnapshot(txn->xid); fprintf(stderr, "pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); if (csn == INVALID_CSN) { mm->isLocal = true; } else { mm->isLocal = false; pq_sendbyte(out, 'B'); /* BEGIN */ - pq_sendint(out, MMNodeId, 4); + pq_sendint(out, MtmNodeId, 4); pq_sendint(out, txn->xid, 4); pq_sendint64(out, csn); } From ba483768a8d42a57eca60399a79724f57128f656 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 12 Feb 2016 14:17:49 +0300 Subject: [PATCH 0254/1139] MMTS update --- multimaster.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index f12e019a34..7ec5dd0d9e 100644 --- a/multimaster.c +++ b/multimaster.c @@ -507,7 +507,7 @@ void MtmSendNotificationMessage(MtmTransState* ts) } } -static XidStatus +static bool MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { MtmTransState* ts; @@ -523,7 +523,7 @@ MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) MtmVoteForTransaction(ts); - return ts->status; + return ts->status == TRANSACTION_STATUS_COMMITTED; } static void @@ -558,7 +558,7 @@ MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, } else { - if (MtmCommitTransaction(xid, nsubxids, subxids) == TRANSACTION_STATUS_COMMITTED) { + if (MtmCommitTransaction(xid, nsubxids, subxids)) { MTM_TRACE("Commit transaction %d\n", xid); } else { PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, TRANSACTION_STATUS_ABORTED, lsn); From d0e04582f44a5d723e9ba288c2db755d1446b1e3 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 12 Feb 2016 20:23:48 +0300 Subject: [PATCH 0255/1139] Continue work on MMTS --- arbiter.c | 2 +- decoder_raw.c | 12 +++++----- multimaster.c | 51 ++++++++++++++++++++++++++++++------------- multimaster.h | 3 ++- pglogical_apply.c | 5 ++++- pglogical_proto.c | 2 +- pglogical_receiver.c | 16 +++++++------- tests/dtmbench | Bin 478845 -> 469262 bytes tests/dtmbench.cpp | 2 -- 9 files changed, 58 insertions(+), 35 deletions(-) diff --git a/arbiter.c b/arbiter.c index 63e9c61033..82de5d5e2f 100644 --- a/arbiter.c +++ b/arbiter.c @@ -334,7 +334,7 @@ static void MtmAppendBuffer(MessageCode code, MtmBuffer* txBuffer, TransactionId MtmWriteSocket(sockets[node], buf->data, buf->used*sizeof(MtmCommitMessage)); buf->used = 0; } - DTM_TRACE("Send message %s CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", + MTM_TRACE("Send message %s CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", messageText[code], ts->csn, node, MtmNodeId, ts->gtid.xid, ts->xid); buf->data[buf->used].code = code; buf->data[buf->used].dxid = xid; diff --git a/decoder_raw.c b/decoder_raw.c index 4d1d5b81b7..b77848ba37 100644 --- a/decoder_raw.c +++ b/decoder_raw.c @@ -108,11 +108,11 @@ decoder_raw_begin_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn) Assert(lastXid != txn->xid); lastXid = txn->xid; if (MMIsLocalTransaction(txn->xid)) { - XTM_INFO("Skip local transaction %u\n", txn->xid); + MTM_INFO("Skip local transaction %u\n", txn->xid); data->isLocal = true; } else { OutputPluginPrepareWrite(ctx, true); - XTM_INFO("Send transaction %u to replica\n", txn->xid); + MTM_INFO("Send transaction %u to replica\n", txn->xid); appendStringInfo(ctx->out, "BEGIN %u;", txn->xid); OutputPluginWrite(ctx, true); data->isLocal = false; @@ -126,12 +126,12 @@ decoder_raw_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, { DecoderRawData *data = ctx->output_plugin_private; if (!data->isLocal) { - XTM_INFO("Send commit of transaction %u to replica\n", txn->xid); + MTM_INFO("Send commit of transaction %u to replica\n", txn->xid); OutputPluginPrepareWrite(ctx, true); appendStringInfoString(ctx->out, "COMMIT;"); OutputPluginWrite(ctx, true); } else { - XTM_INFO("Skip commit of transaction %u\n", txn->xid); + MTM_INFO("Skip commit of transaction %u\n", txn->xid); } } @@ -483,10 +483,10 @@ decoder_raw_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, data = ctx->output_plugin_private; if (data->isLocal) { - XTM_INFO("Skip action %d in transaction %u\n", change->action, txn->xid); + MTM_INFO("Skip action %d in transaction %u\n", change->action, txn->xid); return; } - XTM_INFO("Send action %d in transaction %u to replica\n", change->action, txn->xid); + MTM_INFO("Send action %d in transaction %u to replica\n", change->action, txn->xid); /* Avoid leaking memory by using and resetting our own context */ old = MemoryContextSwitchTo(data->context); diff --git a/multimaster.c b/multimaster.c index 7ec5dd0d9e..20ac3755c9 100644 --- a/multimaster.c +++ b/multimaster.c @@ -194,7 +194,7 @@ static char const* MtmGetName(void) Snapshot MtmGetSnapshot(Snapshot snapshot) { snapshot = PgGetSnapshotData(snapshot); - RecentGlobalDataXmin = RecentGlobalXmin = MtmAdjustOldestXid(RecentGlobalDataXmin); + RecentGlobalDataXmin = RecentGlobalXmin = dtm->oldestXid;//MtmAdjustOldestXid(RecentGlobalDataXmin); return snapshot; } @@ -499,10 +499,8 @@ void MtmSendNotificationMessage(MtmTransState* ts) ts->nextVoting = votingList; dtm->votingTransactions = ts; SpinLockRelease(&dtm->votingSpinlock); - MTM_TRACE("Register commit message\n"); if (votingList == NULL) { /* singal semaphore only once for the whole list */ - MTM_TRACE("Signal semaphore\n"); PGSemaphoreUnlock(&dtm->votingSemaphore); } } @@ -519,9 +517,11 @@ MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) MtmTransactionListAppend(ts); MtmAddSubtransactions(ts, subxids, nsubxids); + MtmVoteForTransaction(ts); + LWLockRelease(dtm->hashLock); - MtmVoteForTransaction(ts); + MTM_TRACE("%d: MtmCommitTransaction status=%d\n", getpid(), ts->status); return ts->status == TRANSACTION_STATUS_COMMITTED; } @@ -530,15 +530,32 @@ static void MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status) { MtmTransState* ts; + MtmCurrentTrans* x = &dtmTx; + bool found; LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2state, &xid, HASH_FIND, NULL); - if (ts != NULL) { + ts = hash_search(xid2state, &xid, HASH_ENTER, &found); + if (!found) { ts->status = status; - MtmAdjustSubtransactions(ts); - if (dtmTx.isReplicated) { - MtmSendNotificationMessage(ts); + ts->csn = MtmAssignCSN(); + ts->procno = MyProc->pgprocno; + ts->snapshot = INVALID_CSN; + if (!TransactionIdIsValid(x->gtid.xid)) + { + ts->gtid.xid = x->xid; + ts->gtid.node = MtmNodeId; + } else { + ts->gtid = x->gtid; } + MtmTransactionListAppend(ts); + MtmAddSubtransactions(ts, subxids, nsubxids); + } + ts->status = status; + MtmAdjustSubtransactions(ts); + + if (dtmTx.isReplicated) { + ts->gtid = x->gtid; + MtmSendNotificationMessage(ts); } LWLockRelease(dtm->hashLock); } @@ -548,13 +565,13 @@ MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) { - MTM_TRACE("%d: MtmSetTransactionStatus %u = %u\n", getpid(), xid, status); + MTM_TRACE("%d: MtmSetTransactionStatus %u(%u) = %u, isDistributed=%d\n", getpid(), xid, dtmTx.xid, status, dtmTx.isDistributed); if (xid == dtmTx.xid && dtmTx.isDistributed) { if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML) { MtmFinishTransaction(xid, nsubxids, subxids, status); - MTM_TRACE("Abort transaction %d\n", xid); + MTM_TRACE("Abort transaction %d, status=%d, DML=%d\n", xid, status, dtmTx.containsDML); } else { @@ -1006,10 +1023,14 @@ MtmVoteForTransaction(MtmTransState* ts) MtmSendNotificationMessage(ts); /* send READY message to coordinator */ } - MTM_TRACE("Node %d waiting latch...\n", MtmNodeId); - WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); - ResetLatch(&MyProc->procLatch); - MTM_TRACE("Node %d receives response...\n", MtmNodeId); + MTM_TRACE("%d: Node %d waiting latch...\n", getpid(), MtmNodeId); + while (ts->status != TRANSACTION_STATUS_COMMITTED && ts->status != TRANSACTION_STATUS_ABORTED) { + LWLockRelease(dtm->hashLock); + WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); + ResetLatch(&MyProc->procLatch); + LWLockAcquire(dtm->hashLock, LW_SHARED); + } + MTM_TRACE("%d: Node %d receives response...\n", getpid(), MtmNodeId); } HTAB* MtmCreateHash(void) diff --git a/multimaster.h b/multimaster.h index 9674234933..53f8a58470 100644 --- a/multimaster.h +++ b/multimaster.h @@ -4,8 +4,9 @@ #include "bytebuf.h" #include "bgwpool.h" -#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) +#define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) //#define MTM_TRACE(fmt, ...) +#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TUPLE_TRACE(fmt, ...) #define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) diff --git a/pglogical_apply.c b/pglogical_apply.c index 1d2202048f..63c315dccd 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -1,3 +1,4 @@ +#include #include "postgres.h" #include "funcapi.h" @@ -333,7 +334,8 @@ process_remote_begin(StringInfo s) SetCurrentStatementStartTimestamp(); StartTransactionCommand(); MtmJoinTransaction(>id, snapshot); - fprintf(stderr, "REMOTE begin node=%d xid=%d snapshot=%ld\n", gtid.node, gtid.xid, snapshot); + + MTM_TRACE("REMOTE begin node=%d xid=%d snapshot=%ld\n", gtid.node, gtid.xid, snapshot); } static void @@ -815,6 +817,7 @@ void MtmExecutor(int id, void* work, size_t size) PG_CATCH(); { FlushErrorState(); + MTM_TRACE("%d: REMOTE abort transaction %d\n", getpid(), GetCurrentTransactionId()); AbortCurrentTransaction(); } PG_END_TRY(); diff --git a/pglogical_proto.c b/pglogical_proto.c index ec37508c2a..126e9f964f 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -105,7 +105,7 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, { PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; csn_t csn = MtmTransactionSnapshot(txn->xid); - fprintf(stderr, "pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); + MTM_TRACE("pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); if (csn == INVALID_CSN) { mm->isLocal = true; } else { diff --git a/pglogical_receiver.c b/pglogical_receiver.c index fcfaac1a3c..38c570b889 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -216,7 +216,7 @@ pglogical_receiver_main(Datum main_arg) BackgroundWorkerUnblockSignals(); /* Connect to a database */ - BackgroundWorkerInitializeConnection(MMDatabaseName, NULL); + BackgroundWorkerInitializeConnection(MtmDatabaseName, NULL); /* Establish connection to remote server */ conn = PQconnectdb(args->receiver_conn_string); @@ -260,7 +260,7 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); resetPQExpBuffer(query); - MMReceiverStarted(); + MtmReceiverStarted(); ByteBufferAlloc(&buf); while (!got_sigterm) @@ -392,7 +392,7 @@ pglogical_receiver_main(Datum main_arg) ByteBufferAppend(&buf, stmt, rc - hdr_len); if (stmt[0] == 'C') /* commit */ { - MMExecute(buf.data, buf.used); + MtmExecute(buf.data, buf.used); ByteBufferReset(&buf); } #else @@ -511,7 +511,7 @@ pglogical_receiver_main(Datum main_arg) } -int MMStartReceivers(char* conns, int node_id) +int MtmStartReceivers(char* conns, int node_id) { int i = 0; BackgroundWorker worker; @@ -530,7 +530,7 @@ int MMStartReceivers(char* conns, int node_id) } if (++i != node_id) { ReceiverArgs* ctx = (ReceiverArgs*)malloc(sizeof(ReceiverArgs)); - if (MMDatabaseName == NULL) { + if (MtmDatabaseName == NULL) { char* dbname = strstr(conn_str, "dbname="); char* eon; int len; @@ -538,9 +538,9 @@ int MMStartReceivers(char* conns, int node_id) dbname += 7; eon = strchr(dbname, ' '); len = eon - dbname; - MMDatabaseName = (char*)malloc(len + 1); - memcpy(MMDatabaseName, dbname, len); - MMDatabaseName[len] = '\0'; + MtmDatabaseName = (char*)malloc(len + 1); + memcpy(MtmDatabaseName, dbname, len); + MtmDatabaseName[len] = '\0'; } ctx->receiver_conn_string = psprintf("replication=database %.*s", (int)(p - conn_str), conn_str); sprintf(ctx->receiver_slot, "mm_slot_%d", node_id); diff --git a/tests/dtmbench b/tests/dtmbench index 4bb7c73ec79f5e615829d73329d80897cb0c426f..d07108be73dbe446d3d2259cd0cdf6e255c3a3b3 100755 GIT binary patch literal 469262 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 z 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 literal 478845 zcmeEvd0dp$_y4`mFfbwlZb;@b+NhX5eI2AC6~WLD;< z#mdUc%62msT(RA(%(RkBZAPqYGu!0%KKI^dcxHgUeLt_?@4w&U>zQ-!Ip>~x&bjBV z&*Q`L#N<&L=S;seHjGhjOSgD|lD~{y>=+>O^b^nGm<7MxSXbtcyjkFgLbP}HmfaxNk!)T?y4t4uT9Nirhy@M8y9OdH)D6Q(Ds-C5sb!1Wc zaE@RDj28(V{vy##hkCgiP|l;e;`t|_>)9taXXb!@eR8uRb93^F7DX%qsLDc;ynIP!bbq6sPuRRTLHFEX#&G=+i_oq`+D4TU5h(eq!{ZD*bVnp zxJN6TZWm>*!95ChAnx9{=^BVTR;0Xt;*pKPorrrJZv7gHM1r0H9D|#5AB1}X?vc1D z){=1RS9>G|s7$beL4ZAR565l8-350a-2dkCj@zb7kiW_AbTyN}^God(;>pQGO90=t zzZ$rXim#o5tpPi$v<|E)QQx~IA`GCdq7jI|-2-3mp&jEDrv#&#(0?oRc?|N?m3*rzbqo9!%6_cV>(zxNH&JglG-PA?PEjrX^|TT#z@;YS9B6|7)+YR5f*+{f8ddM}s*+_*@NWUV6=sBj4)Kap zf>ijSF*#P~L-^v!iXVJ*ZGe38PnGhI-oH9F5m)O_t}#DcZlZtLnvioB^r3pKD$eyW z^+FSVo2$oRr+A^a{?lKzd%TaFDX^<6m^S(F4{Ji71l|9sQvSoLg4s=st8<&M_xC3F zOPjzigI!itml1?Cq36%glg9s)ta!n$`)#}GkD;9=GBptod(pm)#bKK!?27eo zoc}}UMD}h|cF~$gTv!(t+_q>@WZ$S5tOi+H+U$Axd1-}?jQNhVG?q4ILE6OZ**S%d z?D->dGYSi{3t8Iq@%^YsOy8`Tj``X`g z{G>^RlQQs=m>APHZCqMTUST#wXA~_;96u1Xg36URB`qTt5n;gm?2N31^WnlYsjfj>15-$v zaIG@7adoA=jrvXb0!0h+;$>r)4k7%r2lN{s(#eDE?&2rRpu0m!H>YyEhEI{=?CS^7M|;*D*gP zWTcU4bUY55G!kk9q(%U;U=FY4SE$M~6h>@JU*)%5QI0}<;6Jug#&Cj2Q zF`dwfDPuDy=2E+Q`C=d%J*jX!2142Dsh;ua-$%LL=Y0EO;!LVeD%a0joEi)-*=$S{kExs1*<`ctydk(Jr27i9-vTFYFNAzhW0nc>KsL-HmS_QT{> z;MKD*B4#9IQj6v-oQL16+!Q&T6^@7zuG8s4U}i>cZdy@Z_M!p|WZ79PEh&{c>3lU~ zrj8qto1d4RnlUpsTd7b`G(S6SLC$TyUq75p? zV(?7Mo>u_;{Okg>Z2tU=*_hx89CK&}NXx{p1658(|HRA+Z2m$FGFfTRH$M{w3GK7< zz^R;p_J$v5D$bahvmhomCM|8jyqq*Kt)@8^7i41so|R92@!=%-4Y|^EO>WIzT(1p0 zJ^<5n&g?uj^9VKOXAAwLdGNBDlzi%e$!Ud+D5O_3H$NwjT78~uaHM8uW~LQVE{3H| z&RduRYbRoWo0l!(M0$$I(Ui}W#R`fXg=|4#0eXsK7DJD5xI~+Ol zvh!zUWh@4TimKJpybNf7^-xwm0w+5w!;t~{%)&xR1}ZO$jZRJ)J|ZnPDi$F+dc=sd zzNlT`rcFb-9~&`kTEg(8w3sN`Pjj4_m~c9WrJ=|X#IjgiexS-r6DeAD>U6G7P9?9u zpi`R45I6lJ$#ltIqWU8(Wy<`o6uWeGXQp{wyEAI{mnT zp3;3Wj+4ynb_3mvw0C)vp}fY9V@<2C&mBG2L7E>cQDr`U@m8$ZHMUmCvoA;&^`Z!) zvn|i1&IiCO&a-s9ejY-2<9VBYUO{*|3)3(CoPqHAobnwZ8G5LY*oLu81OB0B;Ym!UO$s1@^%BB&O`O9%78cSmkt~7 zbS|o2M+|uV+>~g?4fv~cX22Q)-m`ZC-etgFZQ#FXz|(oNeqA=;={(hQEld|lYDYQ~ z(l3hv-$h3Ph8plT13uhsN{aAFCq)ry1}x2I^P30pDLo0?sku2N>`L27H_WzsP_eXuua6@PiHbRR%nrW$Ra^ z0Y6kn0&Xzi>3N8LZ8G5FbtK>x1Ae#xzs-OjX~1tc;71$qRR(;L0e{$lr)MGhb;N+z z&*h1B+<@1g+Yr9SfFDN)b-4`q@j4RFUUI?Wnt_qQUUI;)pRv0BM{l&Ux^AD~Hw0%l zb=@dGhf26>>Tq>?hw?PZxQ~eZKFZU?U%UcDw~3UeY0X_D@?$7ZLz?@D$PcGH z4Q1{sksm~P8p7P$L_U`CZ79D<=?jSRkTn(P8}{;1mc*FvlAM>`qMlM57g;oFR!C1KR%OY4o-pu>kTt_dO6LBga=$|;?Km9LxfFE9_H4_D zXRc#tsqIw2UXgu#M#4=AHz(YZkaqKal(tta+hnh}kNS!z-|vv?GPv#KLldT3nSJok z;Q%3}{h+J8tj^KQUQx8kH2{{`OU#`>ve?TLAz+cqzM_s6T_L48B&wpQ*kwg8bcmYjjsb2{aJzt}#4W&8Dclx<)rp5i)>#%00j>`aN09v%#Mmn;(twiUmlYd?ih>P< zE5S;js}z!As$x!-49$TscE^m6&c(8(YP(5jo8&wcb7@D)_3_M^7GbX*O+ys3JAX$q zTqLVUTM1H3RFAe$(sjq5b#=+k-|QvT(E~fSBrTnnmv4=Eo9Z!BJt1pGVJJsD+MOTT zP0NatoFAZ)BmHD0Lb$BwA1b*Dm6V&`m}+IJDkwGZ`10q=szTPdD6GpT7ss4TjH$C% zm)YSW(kwCNOk&I>bQyd3koIV-Y-%j>=0gv-hf?2todBdwJW}A=BQg?b84W&b><5IHzk*<;-{{IyM!0JK6c8 zeeWNpiREqQffHb^1hWBt3b|!3Fews~NFdpH+I7=qavb8VnWYr&PG;u!$pGvn zmxD3AEVx<@H(+gf^ByA9)p+9f=KbFG?k4(V`-<;{fW22t5MXy+wC{CYZ|8^XA6;>@ z^+;>3OGE#L95Eji5B++Qm9e6hG_kqz&}=s!GJgOR|9L;H|MrABNU`f#k-7F>l=BGt zkqXoux!Ju0WrQix9(uq@R)%c{zV2ek-qE3DRd=-gS=CoQIdmA#A&Y2ptijt)fQ~8aG(H6h1$VkU4*u9-7Sd8HY;(25;5BD{L0n$63Ud{ zWQ((xopfBaOSQd?Xd}M1M%xvs5jxkmtb`&9SdIKrWi0w`2JT z3;YTZ&PkS{9rkj>!Ku2GPTA*CB2!Bb5Tc#0mB4EFMraQlis=-q;lvPZ#Hmtqm^ zY3NT<(W8!8J5+n7Ty`G8P`;Mho$QZxMZh%ot;ixicIf=0eEH)%{Fi?Pe^1F@J|YNu zJ0}IXvw)aYS)OvaVoaUWj!J4Dggj&Z&AOxRFZA)l+f9x@QYFN-3~K;iXX&&IqG6ax z`i0>B+RrGy5pOFlTo$uZ$M74hA|7Zsuvfflt0CyDc12JD1cbmlzp__sKMr5H_|FD3 z*pG{1+iQqc1QYEQ2rg{v>PEu?4`+aV;ingRr><(QB_*FExNBROU@+!*;tUN^MF(LX(077mRq#3!uDqOJo$HrW+fUrJ&B&4iTEdH8wK^IYhRL{!=Ta+|!7c3Fd zB>V1jP#@-w7c-*5U6yVcWWc$`33Vlds|Nnq^EXPm!pIpdXzmRXL6m9>p(rTW{Q=?Z z3I~gq+ERAg2-i>H5C}_c@w+#Y6sy9ekbB~ZknY-g(c3@iB1ES6V9BxqS3F_iHR7pn z>UT8q_e~hJK!Q{Q>02TJiwX_cX5<)PNoc*8Ucz0eu!;1ies`M)2k+)ckh>V?=ey_3 zhDGC*=cBzug&RDtH`E4Vuls>knv=&_p|JFE%-g#oGU6GA6tvDZTKOn~Yd?7PjF*t< zh9=rw0I@nXoT}JL#mY-<7ey2r?0ZZ2qSWT{C7b|ZPhZ&VidK?o5OB2?O|VlAD#j6E zkg&N_4IhRY-WD~yYTG2nm7TUq5_3}oIr~*xfkLJeax}Kfgp60nXhN>Tp4wi%(-uxh zte5=l%mvhlxYX|N3|xQo0Y-`HtCdiCD%Q=Nbw1-CL1W`;hu_OByNnk*8b` zmD|@?x!6X^jTgfQ)%OYf?!F$`2KAkX_P%;%dCEORiMas+%Mmw+@Z$GjcKIZE1q&Ysodtq%H7#W zIjVpLhjdpdm3yPHa)TNvcMZ7&bzN=6Egira2SfLo} z3-rnF^C`asd40%{BMWveYOWQ7%Y<6VKx2sO^i}Am7_G!;(Vsdm#>|I_gSJcF%bk$2 zmS{EKLDx|w+j4yGqgG8=?J8a~yOt&X9V!uNBQ}o-A#q^p1Az1>OAzVoq-&sOZ`Xceu|Q zke+tiN0bpLE&7Er$H!$D)kRTq%S;mgijpK|E$63H!`yc8a>+rCa0@9b2i;|Nd+Tr+ z9Bx`YyT760@aEUbo4+d9OnTLwt@3S=m-|cotd#b3f78AW;gMY4?X^Ul4)yBx6ae*z zO0+axVgalt7Rf}Zt(X$HlASg7y_ZecU51n$##v;tbF-~j;InLtl6z&@3c!JrB%P`B zUJ%u|HNK+XS>)Irn#hx}K{lCtQsvmsSzNQf#j#k$mKu<--iLw7&hK5ZE<(OVOMQE} z!)8f#*13X-(Rn4=`Gf0Ta#D2(m7#E_&KeJ@=#xn$2lyCg2eE=$WbZ{wBj}wp@Ic6& z4tS>A{K!Zv9eL3Nl%9;fcNtP>PxTIP{}*H)3L0EtsOA`rTyz?Z@Qu ze#dBw+*vMqCkc&GZJp!-cX&GVxL)Bp5-xhTSoHQ%IP^a3J&BOwdgClvx?JBTJKf37pLWk7-`*;G>oaN=cower zT_1??h8ozl6aH`?#W2&L+{{MGiSbC3E2VN%8Y|bnk#g;5924b|shp*;a!1kZzIwhb zyhnPrp>jJKv+wQ(7xwe9&ffqtb|AQtJ>wbIr&Da&3blgq@*FtKMinnS&Gz@93 zO^|3WFA*c4acd`b6y>jMBKC^6#AtKyYNX2xF}2;E?%Iy0k;tI$+#c;}E;6@=t1U>o zx``I5vh*}$mmIW^R%Q7Z6iLy7ab;&57-+wBWfK`kT(CK&YR1j_6R!Q0`nufF-PiY7 zwCBJ<+eR4Uo+@@6u-~v=tNq;jJjuNS&1#^#=lkTZ^~s+`n;7{w`s61f|E4_udOM`F zIdp#$hS3=)j&p~aKe#HthO~-Z z)XYiMWdy`R?M>*BR9@!O%tf~(mA|%$SSxl3b!mN?R9;k&RIx1G^=Y`s#3O_AKap9c zH!GFMwYRPREkA ze$quPcIQFYW$-nOQ@PL-s?Vmm8bP;~Vi9wYv)1JYv9ZLp#l=R=*=S<%q5>(}$*pbYr7jVD3RzjCQtaQJih|?vq_C6Rjp!5SWh1(8Q!@J2 zk<9(>(F%44zW)5$cl~Kcuf+PZ|6nVvKf43a%BKpgL>HxtDS?a9t7KB7sRigVu0l`a zJr(MgL?cN2$-QJh^;wH<014wyBkRz|20;n24n6e+dW`Qnlxejek0aD*3 zD3Z5>N~^SDR9U|imDbpMNxWx4O6T^)L(dGfLcP*QF!YFZ=|i?nD4ble)fNGVxxYh3 zjXP*e3`M`Wt|1j@Z8vVI(UiIb?kBoPZw%<*FNS%uQB5rTiSZ3{9q z%-a(7&`>$9tS+SVE=hke6J>+Z3ySq;{v$dK-yTzh_iH5W#a`M;WoF z{*$VQ@pJ}e48^j?VH*+1ATL4=Dk>g&I?hTScnFzs&R<;XsgiQJQMH%jX%poC^8$9A zP%BlfN#&{S9SUcai(0XOovUyu)Gy+RknXy40<|HVPUGe?A|r!RU%=i+IP}2 z<+$%El`AYN@buDa&c+gUi*T{; zlKFH~?RBHDCzbZZbjrUpJs$0e2~9lcxJlJjKwAMT&5c#0Afi}PwE$@_V04mf%da zSwhMdfsWU3Y?zYqKuyGJ09S9+utQbunhDL${~YR{lK=(!rbjWo-%ehDc(4@-84 zpby!rKT|6L56yhXpkwjS2?MMM$+CG=P~Q(Gm&;Mcj#<7Ko)W9NO-QKqu-Cfo(a)(N z8?5UNQ-d_JuB#Eg^;*|`hZo&E>$;jyk%<@Uy1pXQU|qNMIAnXT>*R3gS=!xA94ijc zK$_6<9rh;KX4 z%1)L`rgC&D(xBY@M#}v~`k}r8R~st#9kLC|UE4^xrJizMz&q}Fjg>o%M)uXSm#5rj zD%YX0avK{d_vN3up1D-+17v;lbPV&Y>t0WpI4V;r%CH3V7kYwAoh8WqGZc{RXk4=G z^;vhf67DR8US8{S_e}H#LpgVQpFC~*jC5K}81ut@@^qGFq|+^dMXli{P^(p#1tNOJbKq3t2iFT9fuZC;D4kfy z=c|UERQodY6R$T3g)ID>uVp*Dd~lt_u$dm*BjyYweJbZ{}Ay%P|yF5_MxjMIX}U2W{xWh(M@|Lv?AV_ z><)8W3HYISGTKikxIL+nVL#Gprw{u-{C{OXl=xrSPyGLl{eOGe4|7}z_-WLBRMEix z5B`~+{Q|}`6>tWyb%a-fy4<-Ir_7neqV?XA3L;FKXR|0-~?WgTePgKz${@?%C z_7ms-!hR_6zp|hB{~P2Lub}+be<=*qtBS_kQh{bc|);QwC9yR5Ny?hb|+mz#gp@21j;eakcE8s=I2*AtslJ9s?wXZ6! z>8OBa3VCg(LkQ8saiH4jVoAP*JFcBUFRQBc>1h4E%Bhy3Z^bJ#p`LdZYl9`CllyzWY`x6#m!SqSsyJYp(0nYpxHe*IYNN*Ic)%*IZu}uepZw+-VC%9rg;Gj0l)&n@0Qb z0y=q0Cv*YCVp~29Ychg2MN=DtILGCB4=MZY)@uP#Mn^&Hc;9rA1@D{U zK-W3eQuMAJQAQ_msHkpYX!)cdQkEE;V}sl)Al0znd>L8a)$jndcCotJz!G;4WPSHl zdA?;XsAX1XR}D0Ce@R&{HA>#0=u)~s(~vSNRa4JnFCT-~cz>tYc#Hbb^A%Fs{U-!@ zzfXIQ&pvDn#MFHxx!boE`)r1R!+; z7IL?S8rBky4?XL(p+4(1oZr*J;a*Zz3JsS+i=Lx;^r2U^i*bFnuTlMC-P_U9`gkC8 zsb4o1rKvhztrm)hl$KNMDdk_3%18JrzeA7MkkX|MqGyT3FM?S{9EsUYEu9IX1gzb^zKI*{#V^PcN z35TfCQ4xkfD9Q!G7>-5#aXLNDdCt`p%s6xkDNCYOP;Q|AC@213gQ4Bsw}U}%5yuqo z{<-`m>F1G9tM*9`*EQZ;cz8>dh`?(PPWNnNjZ4ojjG1TT&@X-`*~{P9L?MI!^-!^= z5-HbWF#@P(skvB}d7h>2p>9|%&)jJ0nIU&U^uFQ@wGR^W3HBGRCk~QA4bJ}FgIDYg z&i;z*cJJr8zshPc*yDLFz24~2VX#35{gqO3uKNES9uN7h&mWQA`3q{*u4`g_PW?}; zH~z+YqvS$(a`|iwW_`pN=X$t?`mcI!y%0g~+H;^$8(n02LmM4FHnud{=x4N%o*wId zhK>3&>m&Pt*3UL+n>wyMTRh7UkE~x7)C1va$>Tfj`}iYdZJsA$Trk6(hOBpgtoc-bso6^4ty*he=1i}t-= zwr>aMQG0jO?JF0O2zE5Dec*3Jp|#`W`v_`Ze!cfT*zv6=p!$1vIpe;^E8W zfoF?q$yHVg;3)Dg=1i{v3}+1o;tcOR=pG0u&A`Epj~6~BS)E-^LQrir{^uOC_pG+> zt;0)lbs=TvU`vwo*MvPN$C7#;98)obUNpkTFsd++IuDKGza~3-+Zm3VyEEnf8R@ZZAh}yl$6+^C1 z9$2?vUXl|p2vp+;vn~m>imNj$cQ->)SVnURO<*P%Gq%DH@A4I4eVvU4N(^=1iJ{jp zQoH}-ov&R*3!^@@x7JQ@)2n**2g6ANKU-J|SEDL=LR7X61?l0^MlqIqH?Y27`bbXQ zt~d9Ih=U+kjV3iTmmw4^j0q<{^oifY~#ur!Ziv6oEhNENgMGpZ&@Q>gaGgpmEU zA+Fg-xo@Z=HTTy(?wTeD$KA68Cf9bHUNxz)S456(YsE9;ZqWpsxi%N+elgj()OOkK zyvc^%aUm|b=h+13-&kST_x^24a(?EzeHX-{Q98t&q&P@+{()!7Bb`4a)V28nLBZ{a zk@K|H$4roG3#AuIFfZVxJ$m>Ykqm!DQ-8svUQD4)=Ygn4Y(DoB;(vM37nj6Wx$p@# zYxW|12C)zy9Aw^KLz5iY^>phze2*_@UIu-BlX*&6<>$S!>IFLJ3u9IX%bK5GV3nDi zSrCKoEfxZ;$ewcY8=Ry`p`&QlEGs^Cl@GRwi3uaEBPNU+mz0{CI1*pKk~I2WC%$bq zF)<|(-zFHIoMim3?T{LfKx7@5iofG+p z1w9ozOU-v=>%LS#KBsR8PG*WfjUJ)(B?J^+@6 z`g5`iBcgkE%j((NiXXjPQ2{>qg(k2TW;-BqDDFsWjL|8Qvk|^tjqy#8<_`*N7CGNK zzFA(;yqVeat@*R8^nEvc7S0+G(-X9XUNrILPeF?&Vulyd^i91tlrkHhL30xDmM!_>3C08s^H0rPgi>9=wo@LUe`fr76?#&f;`G8 z�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

  • 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

    rDqx$o{tfkvZb-zp&_$yMTBV+9^?ItEjqNHt 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 S0WI9^SH-hV4al)IME?(YJKdH5 diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 41e57741a0..05d3d974b0 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -184,7 +184,6 @@ void initializeDatabase() nontransaction txn(conn); exec(txn, "drop extension if exists multimaster"); exec(txn, "create extension multimaster"); - txn.commit(); } printf("extension created\n"); @@ -193,7 +192,6 @@ void initializeDatabase() nontransaction txn(conn); exec(txn, "drop table if exists t"); exec(txn, "create table t(u int primary key, v int)"); - txn.commit(); } printf("table t created\n"); printf("inserting stuff into t\n"); From 3fa50e137dfdd0c739ff84c4f4547010880c929d Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 14 Feb 2016 23:18:11 +0300 Subject: [PATCH 0256/1139] MMTS stil doesn't work --- arbiter.c | 287 ++++++++++++++++++++++++++++++++----------------- multimaster.c | 194 ++++++++++++++++++++------------- multimaster.h | 39 +++++-- tests/dtmbench | Bin 469262 -> 478605 bytes 4 files changed, 335 insertions(+), 185 deletions(-) diff --git a/arbiter.c b/arbiter.c index 82de5d5e2f..11a97cc657 100644 --- a/arbiter.c +++ b/arbiter.c @@ -76,25 +76,13 @@ #define MAX_ROUTES 16 #define BUFFER_SIZE 1024 -typedef enum -{ - MSG_READY, - MSG_PREPARE, - MSG_COMMIT, - MSG_ABORT, - MSG_PREPARED, - MSG_COMMITTED, - MSG_ABORTED -} MessageCode; - - typedef struct { - MessageCode code; /* Message code: MSG_READY, MSG_PREPARE, MSG_COMMIT, MSG_ABORT */ - int node; /* Sender node ID */ - TransactionId dxid; /* Transaction ID at destination node */ - TransactionId sxid; /* Transaction IO at sender node */ - csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ + MtmMessageCode code; /* Message code: MSG_READY, MSG_PREPARE, MSG_COMMIT, MSG_ABORT */ + int node; /* Sender node ID */ + TransactionId dxid; /* Transaction ID at destination node */ + TransactionId sxid; /* Transaction IO at sender node */ + csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ } MtmCommitMessage; typedef struct @@ -111,11 +99,16 @@ static void MtmTransReceiver(Datum arg); static char const* const messageText[] = { + "INVALID", "READY", + "BEGIN_PREPARE", "PREPARE", + "END_PREPARE", "COMMIT", "ABORT", + "BEGIN_PREPARED", "PREPARED", + "END_PREPARED", "COMMITTED", "ABORTED" }; @@ -327,7 +320,7 @@ static int MtmReadSocket(int sd, void* buf, int buf_size) } -static void MtmAppendBuffer(MessageCode code, MtmBuffer* txBuffer, TransactionId xid, int node, MtmTransState* ts) +static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, MtmTransState* ts) { MtmBuffer* buf = &txBuffer[node]; if (buf->used == BUFFER_SIZE) { @@ -335,8 +328,9 @@ static void MtmAppendBuffer(MessageCode code, MtmBuffer* txBuffer, TransactionId buf->used = 0; } MTM_TRACE("Send message %s CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", - messageText[code], ts->csn, node, MtmNodeId, ts->gtid.xid, ts->xid); - buf->data[buf->used].code = code; + messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); + Assert(ts->cmd != MSG_INVALID); + buf->data[buf->used].code = ts->cmd; buf->data[buf->used].dxid = xid; buf->data[buf->used].sxid = ts->xid; buf->data[buf->used].csn = ts->csn; @@ -344,14 +338,15 @@ static void MtmAppendBuffer(MessageCode code, MtmBuffer* txBuffer, TransactionId buf->used += 1; } -static void MtmBroadcastMessage(MessageCode code, MtmBuffer* txBuffer, MtmTransState* ts) +static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) { int i; int n = 1; for (i = 0; i < MtmNodes; i++) { if (TransactionIdIsValid(ts->xids[i])) { - MtmAppendBuffer(code, txBuffer, ts->xids[i], i, ts); + Assert(i+1 != MtmNodeId); + MtmAppendBuffer(txBuffer, ts->xids[i], i, ts); n += 1; } } @@ -378,51 +373,23 @@ static void MtmTransSender(Datum arg) PGSemaphoreLock(&ds->votingSemaphore); CHECK_FOR_INTERRUPTS(); - SpinLockAcquire(&ds->votingSpinlock); - ts = ds->votingTransactions; - ds->votingTransactions = NULL; - SpinLockRelease(&ds->votingSpinlock); - - for (; ts != NULL; ts = ts->nextVoting) { - if (MtmIsCoordinator(ts)) { - /* Coordinator is broadcasting message to replicas */ - MessageCode code = MSG_ABORT; - switch (ts->status) { - case TRANSACTION_STATUS_IN_PROGRESS: - code = MSG_PREPARE; - break; - case TRANSACTION_STATUS_COMMITTED: - code = MSG_COMMIT; - break; - case TRANSACTION_STATUS_ABORTED: - code = MSG_ABORT; - break; - default: - Assert(false); - } - MtmBroadcastMessage(code, txBuffer, ts); + /* + * Use shared lock to improve locality, + * because all other process mnodifying this list use exclusive lock + */ + MtmLock(LW_SHARED); + + for (ts = ds->votingTransactions; ts != NULL; ts = ts->nextVoting) { + if (MtmIsCoordinator(ts)) { + MtmBroadcastMessage(txBuffer, ts); } else { - /* Replica is notifying master about it's state */ - MessageCode code = MSG_ABORT; - switch (ts->status) { - case TRANSACTION_STATUS_UNKNOWN: - code = MSG_READY; - break; - case TRANSACTION_STATUS_IN_PROGRESS: - code = MSG_PREPARED; - break; - case TRANSACTION_STATUS_COMMITTED: - code = MSG_COMMITTED; - break; - case TRANSACTION_STATUS_ABORTED: - code = MSG_ABORTED; - break; - default: - Assert(false); - } - MtmAppendBuffer(code, txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); + MtmAppendBuffer(txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); } + ts->cmd = MSG_INVALID; } + ds->votingTransactions = NULL; + MtmUnlock(); + for (i = 0; i < nNodes; i++) { if (txBuffer[i].used != 0) { MtmWriteSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(MtmCommitMessage)); @@ -492,98 +459,218 @@ static void MtmTransReceiver(Datum arg) rxBuffer[i].used += MtmReadSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBuffer[i].used); nResponses = rxBuffer[i].used/sizeof(MtmCommitMessage); - LWLockAcquire(ds->hashLock, LW_EXCLUSIVE); + MtmLock(LW_EXCLUSIVE); for (j = 0; j < nResponses; j++) { MtmCommitMessage* msg = &rxBuffer[i].data[j]; MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); + Assert(ts->cmd == MSG_INVALID); Assert((unsigned)(msg->node-1) <= (unsigned)nNodes); ts->xids[msg->node-1] = msg->sxid; +#ifdef FAST_COMMIT_PROTOCOL if (MtmIsCoordinator(ts)) { switch (msg->code) { - case MSG_READY: - if (ts->status == TRANSACTION_STATUS_UNKNOWN) { - Assert(ts->nVotes < ds->nNodes); - if (++ts->nVotes == ds->nNodes) { - /* All nodes are ready to commit: assign CSN and switch to in-doubt state */ + case MSG_READY: + Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->nVotes < ds->nNodes); + if (msg->csn > ts->csn) { + ts->csn = msg->csn; + MtmSyncClock(ts->csn); + } + if (++ts->nVotes == ds->nNodes) { + /* All nodes are finished their transactions */ + if (ts->status == TRANSACTION_STATUS_UNKNOWN) { ts->nVotes = 1; /* I voted myself */ - ts->csn = MtmAssignCSN(); - ts->status = TRANSACTION_STATUS_IN_PROGRESS; - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); + ts->cmd = MSG_COMMIT; + } else { + ts->status = TRANSACTION_STATUS_ABORTED; + ts->cmd = MSG_ABORT; + MtmWakeUpBackend(ts); } - } else { - Assert(ts->status == TRANSACTION_STATUS_ABORTED); + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); } break; - case MSG_PREPARED: - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - if (msg->csn > ts->csn) { - ts->csn = msg->csn; + case MSG_COMMITTED: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->nVotes < ds->nNodes); + if (++ts->nVotes == ds->nNodes) { + ts->status = TRANSACTION_STATUS_COMMITTED; + MtmAdjustSubtransactions(ts); + MtmWakeUpBackend(ts); } + break; + case MSG_ABORTED: + Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_UNKNOWN); Assert(ts->nVotes < ds->nNodes); + ts->status = TRANSACTION_STATUS_ABORTED; if (++ts->nVotes == ds->nNodes) { - /* All nodes are in in-doubt state, ts->csn is maximum of CSNs at all nodes */ - /* Now do commit */ + ts->cmd = MSG_ABORT; + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + MtmWakeUpBackend(ts); + } + break; + default: + Assert(false); + } + } else { /* replica */ + switch (msg->code) { + case MSG_COMMIT: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->csn <= msg->csn); + ts->csn = msg->csn; + MtmSyncClock(ts->csn); + ts->status = TRANSACTION_STATUS_COMMITTED; + ts->cmd = MSG_COMMITTED; + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + MtmWakeUpBackend(ts); + break; + case MSG_ABORT: + if (ts->status != TRANSACTION_STATUS_ABORTED) { + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN || ts->status == TRANSACTION_STATUS_IN_PROGRESS); + ts->status = TRANSACTION_STATUS_ABORTED; + MtmAdjustSubtransactions(ts); + MtmWakeUpBackend(ts); + } + break; + default: + Assert(false); + } + } +#else + if (MtmIsCoordinator(ts)) { + switch (msg->code) { + case MSG_READY: + Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); + Assert(ts->nVotes < ds->nNodes); + if (++ts->nVotes == ds->nNodes) { + /* All nodes are finished their transactions */ + if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { + ts->nVotes = 1; /* I voted myself */ + ts->cmd = MSG_BEGIN_PREPARE; + } else { + ts->status = TRANSACTION_STATUS_ABORTED; + ts->cmd = MSG_ABORT; + MtmWakeUpBackend(ts); + } + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + } + break; + case MSG_BEGIN_PREPARED: + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + Assert(ts->nVotes < ds->nNodes); + if (++ts->nVotes == ds->nNodes) { + /* All nodes are in in-doubt state */ ts->nVotes = 1; /* I voted myself */ + ts->status = TRANSACTION_STATUS_UNKNOWN; + ts->cmd = MSG_PREPARE; + ts->csn = MtmAssignCSN(); + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts); + } + break; + case MSG_PREPARED: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->nVotes < ds->nNodes); + if (msg->csn > ts->csn) { + ts->csn = msg->csn; MtmSyncClock(ts->csn); - ts->status = TRANSACTION_STATUS_COMMITTED; + } + if (++ts->nVotes == ds->nNodes) { + /* ts->csn is maximum of CSNs at all nodes */ + ts->nVotes = 1; /* I voted myself */ + ts->cmd = MSG_END_PREPARE; MtmAdjustSubtransactions(ts); MtmSendNotificationMessage(ts); } break; - case MSG_COMMITTED: - Assert(ts->status == TRANSACTION_STATUS_COMMITTED); + case MSG_END_PREPARED: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->nVotes < ds->nNodes); + if (++ts->nVotes == ds->nNodes) { + /* All nodes have now same CSN: do commits */ + ts->nVotes = 1; /* I voted myself */ + ts->cmd = MSG_COMMIT; + MtmSendNotificationMessage(ts); + } + break; + case MSG_COMMITTED: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); Assert(ts->nVotes < ds->nNodes); if (++ts->nVotes == ds->nNodes) { + ts->status = TRANSACTION_STATUS_COMMITTED; + MtmAdjustSubtransactions(ts); MtmWakeUpBackend(ts); } break; - case MSG_ABORTED: - if (ts->status != TRANSACTION_STATUS_ABORTED) { - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - ts->status = TRANSACTION_STATUS_ABORTED; + case MSG_ABORTED: + Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); + Assert(ts->nVotes < ds->nNodes); + ts->status = TRANSACTION_STATUS_ABORTED; + if (++ts->nVotes == ds->nNodes) { + ts->cmd = MSG_ABORT; MtmAdjustSubtransactions(ts); - MtmWakeUpBackend(ts); + MtmSendNotificationMessage(ts); + MtmWakeUpBackend(ts); } break; - default: + default: Assert(false); } } else { /* replica */ switch (msg->code) { - case MSG_PREPARE: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + case MSG_BEGIN_PREPARE: + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + ts->status = TRANSACTION_STATUS_UNKNOWN; + ts->cmd = MSG_BEGIN_PREPARED; ts->csn = MtmAssignCSN(); - ts->status = TRANSACTION_STATUS_IN_PROGRESS; MtmAdjustSubtransactions(ts); MtmSendNotificationMessage(ts); break; - case MSG_COMMIT: - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + case MSG_PREPARE: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + ts->csn = MtmAssignCSN(); + ts->cmd = MSG_PREPARED; + MtmSendNotificationMessage(ts); + break; + case MSG_END_PREPARE: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->csn <= msg->csn); ts->csn = msg->csn; + ts->cmd = MSG_END_PREPARED; + MtmAdjustSubtransactions(ts); MtmSyncClock(ts->csn); + MtmSendNotificationMessage(ts); + break; + case MSG_COMMIT: + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->csn == msg->csn); ts->status = TRANSACTION_STATUS_COMMITTED; + ts->cmd = MSG_COMMITTED; MtmAdjustSubtransactions(ts); MtmSendNotificationMessage(ts); MtmWakeUpBackend(ts); break; - case MSG_ABORT: + case MSG_ABORT: if (ts->status != TRANSACTION_STATUS_ABORTED) { - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN || ts->status == TRANSACTION_STATUS_IN_PROGRESS); ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); MtmWakeUpBackend(ts); } break; - default: + default: Assert(false); } } +#endif } - LWLockRelease(ds->hashLock); + MtmUnlock(); rxBuffer[i].used -= nResponses*sizeof(MtmCommitMessage); if (rxBuffer[i].used != 0) { diff --git a/multimaster.c b/multimaster.c index 20ac3755c9..5d7128191b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -84,7 +84,6 @@ static void MtmXactCallback(XactEvent event, void *arg); static void MtmBeginTransaction(MtmCurrentTrans* x); static void MtmPrepareTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x); -static Snapshot MtmGetSnapshot(Snapshot snapshot); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); static TransactionId MtmAdjustOldestXid(TransactionId xid); @@ -138,11 +137,29 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag); +void MtmLock(LWLockMode mode) +{ +#ifdef USE_SPINLOCK + SpinLockAcquire(&ds->hashSpinlock); +#else + LWLockAcquire(dtm->hashLock, mode); +#endif +} + +void MtmUnlock(void) +{ +#ifdef USE_SPINLOCK + SpinLockRelease(&ds->hashSpinlock); +#else + LWLockRelease(dtm->hashLock); +#endif +} + + /* * System time manipulation functions */ - static timestamp_t MtmGetCurrentTime() { struct timeval tv; @@ -194,7 +211,7 @@ static char const* MtmGetName(void) Snapshot MtmGetSnapshot(Snapshot snapshot) { snapshot = PgGetSnapshotData(snapshot); - RecentGlobalDataXmin = RecentGlobalXmin = dtm->oldestXid;//MtmAdjustOldestXid(RecentGlobalDataXmin); + RecentGlobalDataXmin = RecentGlobalXmin = dtm->oldestXid;//MtmAdjustOldestXid(RecentGlobalDataXmin); return snapshot; } @@ -217,7 +234,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) timestamp_t delay = MIN_WAIT_TIMEOUT; Assert(xid != InvalidTransactionId); - LWLockAcquire(dtm->hashLock, LW_SHARED); + MtmLock(LW_SHARED); #if TRACE_SLEEP_TIME if (firstReportTime == 0) { @@ -232,13 +249,13 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (ts->csn > dtmTx.snapshot) { MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", getpid(), xid, ts->csn, dtmTx.snapshot); - LWLockRelease(dtm->hashLock); + MtmUnlock(); return true; } - if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) + if (ts->status == TRANSACTION_STATUS_UNKNOWN) { MTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); - LWLockRelease(dtm->hashLock); + MtmUnlock(); #if TRACE_SLEEP_TIME { timestamp_t delta, now = MtmGetCurrentTime(); @@ -263,14 +280,14 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (delay*2 <= MAX_WAIT_TIMEOUT) { delay *= 2; } - LWLockAcquire(dtm->hashLock, LW_SHARED); + MtmLock(LW_SHARED); } else { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld\n", getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot); - LWLockRelease(dtm->hashLock); + MtmUnlock(); return invisible; } } @@ -280,7 +297,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) break; } } - LWLockRelease(dtm->hashLock); + MtmUnlock(); return PgXidInMVCCSnapshot(xid, snapshot); } @@ -297,6 +314,7 @@ static int MtmXidMatchFunc(const void *key1, const void *key2, Size keysize) static void MtmTransactionListAppend(MtmTransState* ts) { ts->next = NULL; + ts->nSubxids = 0; *dtm->transListTail = ts; dtm->transListTail = &ts->next; } @@ -353,12 +371,12 @@ MtmAdjustOldestXid(TransactionId xid) if (TransactionIdIsValid(xid)) { MtmTransState *ts, *prev = NULL; - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + MtmLock(LW_EXCLUSIVE); ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { timestamp_t cutoff_time = ts->csn - MtmVacuumDelay*USEC; for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { - Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED); + Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); if (prev != NULL) { /* Remove information about too old transactions */ hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); @@ -371,7 +389,7 @@ MtmAdjustOldestXid(TransactionId xid) } else { xid = dtm->oldestXid; } - LWLockRelease(dtm->hashLock); + MtmUnlock(); } return xid; } @@ -397,7 +415,7 @@ static void MtmInitialize() dtm->initialized = false; PGSemaphoreCreate(&dtm->votingSemaphore); PGSemaphoreReset(&dtm->votingSemaphore); - SpinLockInit(&dtm->votingSpinlock); + SpinLockInit(&dtm->hashSpinlock); BgwPoolInit(&dtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); RegisterXactCallback(MtmXactCallback, NULL); dtmTx.snapshot = INVALID_CSN; @@ -432,15 +450,16 @@ static void MtmBeginTransaction(MtmCurrentTrans* x) { if (x->snapshot == INVALID_CSN) { - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - x->xid = GetCurrentTransactionIdIfAny(); + MtmLock(LW_EXCLUSIVE); + x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; x->isDistributed = IsNormalProcessingMode() && dtm->initialized && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); x->containsDML = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; - LWLockRelease(dtm->hashLock); - MTM_TRACE("MtmLocalTransaction: transaction %u uses local snapshot %lu\n", x->xid, x->snapshot); + MtmUnlock(); + + MTM_TRACE("MtmLocalTransaction: %s transaction %u uses local snapshot %lu\n", x->isDistributed ? "distributed" : "local", x->xid, x->snapshot); } } @@ -451,35 +470,40 @@ MtmBeginTransaction(MtmCurrentTrans* x) static void MtmPrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; - bool found; int i; if (!x->isDistributed) { return; } - - if (!TransactionIdIsValid(x->xid)) { - x->xid = GetCurrentTransactionId(); - } - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2state, &x->xid, HASH_ENTER, &found); - Assert(!found); - ts->snapshot = x->isReplicated ? INVALID_CSN : x->snapshot; + x->xid = GetCurrentTransactionId(); + + MtmLock(LW_EXCLUSIVE); + ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); +#ifdef FAST_COMMIT_PROTOCOL ts->status = TRANSACTION_STATUS_UNKNOWN; +#else + ts->status = TRANSACTION_STATUS_IN_PROGRESS; +#endif + ts->snapshot = x->isReplicated ? INVALID_CSN : x->snapshot; ts->csn = MtmAssignCSN(); + ts->gtid = x->gtid; + ts->cmd = MSG_INVALID; ts->procno = MyProc->pgprocno; - ts->nVotes = 1; /* My own voice */ - for (i = 0; i < MtmNodes; i++) { - ts->xids[i] = InvalidTransactionId; - } - if (!TransactionIdIsValid(x->gtid.xid)) - { + ts->nVotes = 0; + if (TransactionIdIsValid(x->gtid.xid)) { + ts->gtid = x->gtid; + } else { ts->gtid.xid = x->xid; ts->gtid.node = MtmNodeId; - } else { - ts->gtid = x->gtid; } - LWLockRelease(dtm->hashLock); + for (i = 0; i < MtmNodes; i++) { + ts->xids[i] = InvalidTransactionId; + } + MtmTransactionListAppend(ts); + + MtmUnlock(); + + MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", getpid(), x->xid, ts->csn); } static void @@ -494,11 +518,10 @@ void MtmSendNotificationMessage(MtmTransState* ts) { MtmTransState* votingList; - SpinLockAcquire(&dtm->votingSpinlock); votingList = dtm->votingTransactions; ts->nextVoting = votingList; dtm->votingTransactions = ts; - SpinLockRelease(&dtm->votingSpinlock); + if (votingList == NULL) { /* singal semaphore only once for the whole list */ PGSemaphoreUnlock(&dtm->votingSemaphore); @@ -510,18 +533,18 @@ MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { MtmTransState* ts; - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); + MtmLock(LW_EXCLUSIVE); ts = hash_search(xid2state, &xid, HASH_FIND, NULL); Assert(ts != NULL); /* should be created by MtmPrepareTransaction */ - MtmTransactionListAppend(ts); + MTM_TRACE("%d: MtmCommitTransaction begin commit of %d CSN=%ld\n", getpid(), xid, ts->csn); MtmAddSubtransactions(ts, subxids, nsubxids); MtmVoteForTransaction(ts); - LWLockRelease(dtm->hashLock); + MtmUnlock(); - MTM_TRACE("%d: MtmCommitTransaction status=%d\n", getpid(), ts->status); + MTM_TRACE("%d: MtmCommitTransaction %d status=%d\n", getpid(), xid, ts->status); return ts->status == TRANSACTION_STATUS_COMMITTED; } @@ -529,35 +552,35 @@ MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) static void MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status) { - MtmTransState* ts; MtmCurrentTrans* x = &dtmTx; - bool found; - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - ts = hash_search(xid2state, &xid, HASH_ENTER, &found); - if (!found) { - ts->status = status; - ts->csn = MtmAssignCSN(); - ts->procno = MyProc->pgprocno; - ts->snapshot = INVALID_CSN; - if (!TransactionIdIsValid(x->gtid.xid)) - { - ts->gtid.xid = x->xid; - ts->gtid.node = MtmNodeId; - } else { + if (x->isReplicated) { + MtmTransState* ts; + XidStatus prevStatus = TRANSACTION_STATUS_UNKNOWN; + bool found; + + Assert(status == TRANSACTION_STATUS_ABORTED); + + MtmLock(LW_EXCLUSIVE); + ts = hash_search(xid2state, &xid, HASH_ENTER, &found); + if (!found) { + ts->snapshot = INVALID_CSN; + ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; + ts->cmd = MSG_INVALID; + } else { + prevStatus = ts->status; } - MtmTransactionListAppend(ts); - MtmAddSubtransactions(ts, subxids, nsubxids); - } - ts->status = status; - MtmAdjustSubtransactions(ts); - - if (dtmTx.isReplicated) { - ts->gtid = x->gtid; - MtmSendNotificationMessage(ts); + ts->status = status; + MtmAdjustSubtransactions(ts); + + if (prevStatus != TRANSACTION_STATUS_ABORTED) { + ts->cmd = MSG_ABORTED; + MtmSendNotificationMessage(ts); + } + MtmUnlock(); + MTM_TRACE("%d: MtmFinishTransaction %d CSN=%ld, status=%d\n", getpid(), xid, ts->csn, status); } - LWLockRelease(dtm->hashLock); } @@ -571,7 +594,7 @@ MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML) { MtmFinishTransaction(xid, nsubxids, subxids, status); - MTM_TRACE("Abort transaction %d, status=%d, DML=%d\n", xid, status, dtmTx.containsDML); + MTM_TRACE("Finish transaction %d, status=%d, DML=%d\n", xid, status, dtmTx.containsDML); } else { @@ -757,15 +780,22 @@ _PG_fini(void) * *************************************************************************** */ -void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot) +void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { - LWLockAcquire(dtm->hashLock, LW_EXCLUSIVE); - MtmSyncClock(snapshot); - LWLockRelease(dtm->hashLock); + csn_t localSnapshot; + + MtmLock(LW_EXCLUSIVE); + localSnapshot = MtmSyncClock(globalSnapshot); + MtmUnlock(); + if (globalSnapshot < localSnapshot - MtmVacuumDelay * USEC) + { + elog(ERROR, "Too old snapshot: requested %ld, current %ld", globalSnapshot, localSnapshot); + } + dtmTx.gtid = *gtid; dtmTx.xid = GetCurrentTransactionId(); - dtmTx.snapshot = snapshot; + dtmTx.snapshot = globalSnapshot; dtmTx.isReplicated = true; dtmTx.isDistributed = true; dtmTx.containsDML = true; @@ -783,12 +813,12 @@ csn_t MtmTransactionSnapshot(TransactionId xid) MtmTransState* ts; csn_t snapshot = INVALID_CSN; - LWLockAcquire(dtm->hashLock, LW_SHARED); + MtmLock(LW_SHARED); ts = hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { snapshot = ts->snapshot; } - LWLockRelease(dtm->hashLock); + MtmUnlock(); return snapshot; } @@ -1020,15 +1050,25 @@ static void MtmVoteForTransaction(MtmTransState* ts) { if (!MtmIsCoordinator(ts)) { + ts->cmd = ts->status == TRANSACTION_STATUS_ABORTED ? MSG_ABORTED : MSG_READY; MtmSendNotificationMessage(ts); /* send READY message to coordinator */ + } else if (++ts->nVotes == dtm->nNodes) { /* everybody already voted except me */ + if (ts->status != TRANSACTION_STATUS_ABORTED) { +#ifdef FAST_COMMIT_PROTOCOL + ts->cmd = MSG_COMMIT; +#else + ts->cmd = MSG_BEGIN_PREPARE; +#endif + ts->nVotes = 1; /* I voted myself */ + MtmSendNotificationMessage(ts); + } } - MTM_TRACE("%d: Node %d waiting latch...\n", getpid(), MtmNodeId); while (ts->status != TRANSACTION_STATUS_COMMITTED && ts->status != TRANSACTION_STATUS_ABORTED) { - LWLockRelease(dtm->hashLock); + MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); - LWLockAcquire(dtm->hashLock, LW_SHARED); + MtmLock(LW_SHARED); } MTM_TRACE("%d: Node %d receives response...\n", getpid(), MtmNodeId); } diff --git a/multimaster.h b/multimaster.h index 53f8a58470..51fef659aa 100644 --- a/multimaster.h +++ b/multimaster.h @@ -13,6 +13,9 @@ #define MULTIMASTER_NAME "mmts" +//#define FAST_COMMIT_PROTOCOL 1 + + typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) @@ -23,26 +26,44 @@ typedef struct TransactionId xid; /* Transaction ID at this node */ } GlobalTransactionId; +typedef enum +{ + MSG_INVALID, + MSG_READY, + MSG_BEGIN_PREPARE, + MSG_PREPARE, + MSG_END_PREPARE, + MSG_COMMIT, + MSG_ABORT, + MSG_BEGIN_PREPARED, + MSG_PREPARED, + MSG_END_PREPARED, + MSG_COMMITTED, + MSG_ABORTED +} MtmMessageCode; + + typedef struct MtmTransState { - TransactionId xid; - XidStatus status; + TransactionId xid; + XidStatus status; GlobalTransactionId gtid; - csn_t csn; /* commit serial number */ - csn_t snapshot; /* transaction snapshot, or INVALID_CSN for local transactions */ - int nVotes; /* number of votes received from replcas for this transaction: + csn_t csn; /* commit serial number */ + csn_t snapshot; /* transaction snapshot, or INVALID_CSN for local transactions */ + int nVotes; /* number of votes received from replcas for this transaction: finally should be nNodes-1 */ - int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, + int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, used to notify coordinator by arbiter */ + MtmMessageCode cmd; /* Notification message code to be sent */ + int nSubxids; /* Number of subtransanctions */ struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ - int nSubxids; /* Number of subtransanctions */ TransactionId xids[1]; /* transaction ID at replicas: varying size MtmNodes */ } MtmTransState; typedef struct { - volatile slock_t votingSpinlock; /* spinlock used to protect votingTransactions list */ + volatile slock_t hashSpinlock; /* spinlock used to protect access to hash table */ PGSemaphoreData votingSemaphore; /* semaphore used to notify mm-sender about new responses to coordinator */ LWLockId hashLock; /* lock to synchronize access to hash table */ TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ @@ -81,6 +102,8 @@ extern void MtmExecutor(int id, void* work, size_t size); extern HTAB* MtmCreateHash(void); extern void MtmSendNotificationMessage(MtmTransState* ts); extern void MtmAdjustSubtransactions(MtmTransState* ts); +extern void MtmLock(LWLockMode mode); +extern void MtmUnlock(void); extern MtmState* MtmGetState(void); #endif diff --git a/tests/dtmbench b/tests/dtmbench index d07108be73dbe446d3d2259cd0cdf6e255c3a3b3..911dc4e2b41c69040d190030d69f9aa25354b1a5 100755 GIT binary patch literal 478605 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 GME?&U=B&*C literal 469262 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 z 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 From ed196a38ee7811a8e04084990a287ec8305c2edd Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 15 Feb 2016 17:53:50 +0300 Subject: [PATCH 0257/1139] Fix bug in MMTS --- arbiter.c | 137 +++---------------------------- multimaster--1.0.sql | 16 ++-- multimaster.c | 67 +++++++++------ multimaster.h | 15 ++-- pglogical_receiver.c | 6 +- tests/deploy_layouts/cluster.yml | 2 +- tests/dtmbench | Bin 478605 -> 471038 bytes tests/dtmbench.cpp | 5 +- tests/perf.results | 17 ++++ 9 files changed, 92 insertions(+), 173 deletions(-) diff --git a/arbiter.c b/arbiter.c index 11a97cc657..10590b8a28 100644 --- a/arbiter.c +++ b/arbiter.c @@ -101,14 +101,10 @@ static char const* const messageText[] = { "INVALID", "READY", - "BEGIN_PREPARE", "PREPARE", - "END_PREPARE", "COMMIT", "ABORT", - "BEGIN_PREPARED", "PREPARED", - "END_PREPARED", "COMMITTED", "ABORTED" }; @@ -401,6 +397,7 @@ static void MtmTransSender(Datum arg) static void MtmWakeUpBackend(MtmTransState* ts) { + ts->done = true; SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } @@ -469,79 +466,6 @@ static void MtmTransReceiver(Datum arg) Assert((unsigned)(msg->node-1) <= (unsigned)nNodes); ts->xids[msg->node-1] = msg->sxid; -#ifdef FAST_COMMIT_PROTOCOL - if (MtmIsCoordinator(ts)) { - switch (msg->code) { - case MSG_READY: - Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->nVotes < ds->nNodes); - if (msg->csn > ts->csn) { - ts->csn = msg->csn; - MtmSyncClock(ts->csn); - } - if (++ts->nVotes == ds->nNodes) { - /* All nodes are finished their transactions */ - if (ts->status == TRANSACTION_STATUS_UNKNOWN) { - ts->nVotes = 1; /* I voted myself */ - ts->cmd = MSG_COMMIT; - } else { - ts->status = TRANSACTION_STATUS_ABORTED; - ts->cmd = MSG_ABORT; - MtmWakeUpBackend(ts); - } - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - } - break; - case MSG_COMMITTED: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->nVotes < ds->nNodes); - if (++ts->nVotes == ds->nNodes) { - ts->status = TRANSACTION_STATUS_COMMITTED; - MtmAdjustSubtransactions(ts); - MtmWakeUpBackend(ts); - } - break; - case MSG_ABORTED: - Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->nVotes < ds->nNodes); - ts->status = TRANSACTION_STATUS_ABORTED; - if (++ts->nVotes == ds->nNodes) { - ts->cmd = MSG_ABORT; - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - MtmWakeUpBackend(ts); - } - break; - default: - Assert(false); - } - } else { /* replica */ - switch (msg->code) { - case MSG_COMMIT: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->csn <= msg->csn); - ts->csn = msg->csn; - MtmSyncClock(ts->csn); - ts->status = TRANSACTION_STATUS_COMMITTED; - ts->cmd = MSG_COMMITTED; - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - MtmWakeUpBackend(ts); - break; - case MSG_ABORT: - if (ts->status != TRANSACTION_STATUS_ABORTED) { - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN || ts->status == TRANSACTION_STATUS_IN_PROGRESS); - ts->status = TRANSACTION_STATUS_ABORTED; - MtmAdjustSubtransactions(ts); - MtmWakeUpBackend(ts); - } - break; - default: - Assert(false); - } - } -#else if (MtmIsCoordinator(ts)) { switch (msg->code) { case MSG_READY: @@ -551,31 +475,18 @@ static void MtmTransReceiver(Datum arg) /* All nodes are finished their transactions */ if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { ts->nVotes = 1; /* I voted myself */ - ts->cmd = MSG_BEGIN_PREPARE; + ts->cmd = MSG_PREPARE; } else { ts->status = TRANSACTION_STATUS_ABORTED; ts->cmd = MSG_ABORT; + MtmAdjustSubtransactions(ts); MtmWakeUpBackend(ts); } - MtmAdjustSubtransactions(ts); MtmSendNotificationMessage(ts); } break; - case MSG_BEGIN_PREPARED: - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < ds->nNodes); - if (++ts->nVotes == ds->nNodes) { - /* All nodes are in in-doubt state */ - ts->nVotes = 1; /* I voted myself */ - ts->status = TRANSACTION_STATUS_UNKNOWN; - ts->cmd = MSG_PREPARE; - ts->csn = MtmAssignCSN(); - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - } - break; case MSG_PREPARED: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); Assert(ts->nVotes < ds->nNodes); if (msg->csn > ts->csn) { ts->csn = msg->csn; @@ -584,18 +495,10 @@ static void MtmTransReceiver(Datum arg) if (++ts->nVotes == ds->nNodes) { /* ts->csn is maximum of CSNs at all nodes */ ts->nVotes = 1; /* I voted myself */ - ts->cmd = MSG_END_PREPARE; - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - } - break; - case MSG_END_PREPARED: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->nVotes < ds->nNodes); - if (++ts->nVotes == ds->nNodes) { - /* All nodes have now same CSN: do commits */ - ts->nVotes = 1; /* I voted myself */ ts->cmd = MSG_COMMIT; + ts->csn = MtmAssignCSN(); + ts->status = TRANSACTION_STATUS_UNKNOWN; + MtmAdjustSubtransactions(ts); MtmSendNotificationMessage(ts); } break; @@ -603,8 +506,7 @@ static void MtmTransReceiver(Datum arg) Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); Assert(ts->nVotes < ds->nNodes); if (++ts->nVotes == ds->nNodes) { - ts->status = TRANSACTION_STATUS_COMMITTED; - MtmAdjustSubtransactions(ts); + /* All nodes have the same CSN */ MtmWakeUpBackend(ts); } break; @@ -624,33 +526,19 @@ static void MtmTransReceiver(Datum arg) } } else { /* replica */ switch (msg->code) { - case MSG_BEGIN_PREPARE: + case MSG_PREPARE: Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); ts->status = TRANSACTION_STATUS_UNKNOWN; - ts->cmd = MSG_BEGIN_PREPARED; - ts->csn = MtmAssignCSN(); - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - break; - case MSG_PREPARE: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); ts->csn = MtmAssignCSN(); ts->cmd = MSG_PREPARED; MtmSendNotificationMessage(ts); break; - case MSG_END_PREPARE: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->csn <= msg->csn); - ts->csn = msg->csn; - ts->cmd = MSG_END_PREPARED; - MtmAdjustSubtransactions(ts); - MtmSyncClock(ts->csn); - MtmSendNotificationMessage(ts); break; case MSG_COMMIT: Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->csn == msg->csn); - ts->status = TRANSACTION_STATUS_COMMITTED; + Assert(ts->csn < msg->csn); + ts->csn = msg->csn; + MtmSyncClock(ts->csn); ts->cmd = MSG_COMMITTED; MtmAdjustSubtransactions(ts); MtmSendNotificationMessage(ts); @@ -668,7 +556,6 @@ static void MtmTransReceiver(Datum arg) Assert(false); } } -#endif } MtmUnlock(); diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index d15688916e..694af8db5f 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -1,15 +1,19 @@ -- complain if script is sourced in psql, rather than via CREATE EXTENSION \echo Use "CREATE EXTENSION multimaster" to load this file. \quit -CREATE FUNCTION mm_start_replication() RETURNS void -AS 'MODULE_PATHNAME','mm_start_replication' +CREATE FUNCTION mtm_start_replication() RETURNS void +AS 'MODULE_PATHNAME','mtm_start_replication' LANGUAGE C; -CREATE FUNCTION mm_stop_replication() RETURNS void -AS 'MODULE_PATHNAME','mm_stop_replication' +CREATE FUNCTION mtm_stop_replication() RETURNS void +AS 'MODULE_PATHNAME','mtm_stop_replication' LANGUAGE C; -CREATE FUNCTION mm_drop_node(node integer, drop_slot bool default false) RETURNS void -AS 'MODULE_PATHNAME','mm_drop_node' +CREATE FUNCTION mtm_drop_node(node integer, drop_slot bool default false) RETURNS void +AS 'MODULE_PATHNAME','mtm_drop_node' +LANGUAGE C; + +CREATE FUNCTION mtm_get_snapshot() RETURNS bigint +AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; diff --git a/multimaster.c b/multimaster.c index 5d7128191b..7eb2fbed2d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -73,9 +73,10 @@ void _PG_fini(void); PG_MODULE_MAGIC; -PG_FUNCTION_INFO_V1(mm_start_replication); -PG_FUNCTION_INFO_V1(mm_stop_replication); -PG_FUNCTION_INFO_V1(mm_drop_node); +PG_FUNCTION_INFO_V1(mtm_start_replication); +PG_FUNCTION_INFO_V1(mtm_stop_replication); +PG_FUNCTION_INFO_V1(mtm_drop_node); +PG_FUNCTION_INFO_V1(mtm_get_snapshot); static Snapshot MtmGetSnapshot(Snapshot snapshot); static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); @@ -83,7 +84,7 @@ static void MtmInitialize(void); static void MtmXactCallback(XactEvent event, void *arg); static void MtmBeginTransaction(MtmCurrentTrans* x); static void MtmPrepareTransaction(MtmCurrentTrans* x); -static void MtmEndTransaction(MtmCurrentTrans* x); +static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); static TransactionId MtmAdjustOldestXid(TransactionId xid); @@ -211,7 +212,7 @@ static char const* MtmGetName(void) Snapshot MtmGetSnapshot(Snapshot snapshot) { snapshot = PgGetSnapshotData(snapshot); - RecentGlobalDataXmin = RecentGlobalXmin = dtm->oldestXid;//MtmAdjustOldestXid(RecentGlobalDataXmin); + RecentGlobalDataXmin = RecentGlobalXmin = MtmAdjustOldestXid(RecentGlobalDataXmin); return snapshot; } @@ -244,7 +245,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) while (true) { MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); - if (ts != NULL) + if (ts != NULL && ts->status != TRANSACTION_STATUS_IN_PROGRESS) { if (ts->csn > dtmTx.snapshot) { MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", @@ -439,9 +440,12 @@ MtmXactCallback(XactEvent event, void *arg) MtmPrepareTransaction(&dtmTx); break; case XACT_EVENT_COMMIT: - case XACT_EVENT_ABORT: - MtmEndTransaction(&dtmTx); - default: + MtmEndTransaction(&dtmTx, true); + break; + case XACT_EVENT_ABORT: + MtmEndTransaction(&dtmTx, false); + break; + default: break; } } @@ -479,17 +483,14 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) MtmLock(LW_EXCLUSIVE); ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); -#ifdef FAST_COMMIT_PROTOCOL - ts->status = TRANSACTION_STATUS_UNKNOWN; -#else ts->status = TRANSACTION_STATUS_IN_PROGRESS; -#endif ts->snapshot = x->isReplicated ? INVALID_CSN : x->snapshot; ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; ts->cmd = MSG_INVALID; ts->procno = MyProc->pgprocno; ts->nVotes = 0; + ts->done = false; if (TransactionIdIsValid(x->gtid.xid)) { ts->gtid = x->gtid; } else { @@ -507,8 +508,17 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) } static void -MtmEndTransaction(MtmCurrentTrans* x) +MtmEndTransaction(MtmCurrentTrans* x, bool commit) { + if (x->isDistributed && commit) { + MtmTransState* ts; + MtmLock(LW_EXCLUSIVE); + ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); + Assert(ts != NULL); + ts->status = TRANSACTION_STATUS_COMMITTED; + MtmAdjustSubtransactions(ts); + MtmUnlock(); + } x->snapshot = INVALID_CSN; x->xid = InvalidTransactionId; x->gtid.xid = InvalidTransactionId; @@ -546,7 +556,7 @@ MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) MTM_TRACE("%d: MtmCommitTransaction %d status=%d\n", getpid(), xid, ts->status); - return ts->status == TRANSACTION_STATUS_COMMITTED; + return ts->status != TRANSACTION_STATUS_ABORTED; } static void @@ -824,14 +834,14 @@ csn_t MtmTransactionSnapshot(TransactionId xid) } Datum -mm_start_replication(PG_FUNCTION_ARGS) +mtm_start_replication(PG_FUNCTION_ARGS) { MtmDoReplication = true; PG_RETURN_VOID(); } Datum -mm_stop_replication(PG_FUNCTION_ARGS) +mtm_stop_replication(PG_FUNCTION_ARGS) { MtmDoReplication = false; dtmTx.isDistributed = false; @@ -839,7 +849,7 @@ mm_stop_replication(PG_FUNCTION_ARGS) } Datum -mm_drop_node(PG_FUNCTION_ARGS) +mtm_drop_node(PG_FUNCTION_ARGS) { int nodeId = PG_GETARG_INT32(0); bool dropSlot = PG_GETARG_BOOL(1); @@ -853,16 +863,22 @@ mm_drop_node(PG_FUNCTION_ARGS) dtm->nNodes -= 1; if (!IsTransactionBlock()) { - MtmBroadcastUtilityStmt(psprintf("select mm_drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); + MtmBroadcastUtilityStmt(psprintf("select mtm_drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); } if (dropSlot) { - ReplicationSlotDrop(psprintf("mm_slot_%d", nodeId)); + ReplicationSlotDrop(psprintf("mtm_slot_%d", nodeId)); } } PG_RETURN_VOID(); } - + +Datum +mtm_get_snapshot(PG_FUNCTION_ARGS) +{ + PG_RETURN_INT64(dtmTx.snapshot); +} + /* * Execute statement with specified parameters and check its result */ @@ -1054,17 +1070,14 @@ MtmVoteForTransaction(MtmTransState* ts) MtmSendNotificationMessage(ts); /* send READY message to coordinator */ } else if (++ts->nVotes == dtm->nNodes) { /* everybody already voted except me */ if (ts->status != TRANSACTION_STATUS_ABORTED) { -#ifdef FAST_COMMIT_PROTOCOL - ts->cmd = MSG_COMMIT; -#else - ts->cmd = MSG_BEGIN_PREPARE; -#endif + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + ts->cmd = MSG_PREPARE; ts->nVotes = 1; /* I voted myself */ MtmSendNotificationMessage(ts); } } MTM_TRACE("%d: Node %d waiting latch...\n", getpid(), MtmNodeId); - while (ts->status != TRANSACTION_STATUS_COMMITTED && ts->status != TRANSACTION_STATUS_ABORTED) { + while (!ts->done) { MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); diff --git a/multimaster.h b/multimaster.h index 51fef659aa..55d881c025 100644 --- a/multimaster.h +++ b/multimaster.h @@ -5,17 +5,17 @@ #include "bgwpool.h" #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -//#define MTM_TRACE(fmt, ...) -#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) +#define MTM_TRACE(fmt, ...) #define MTM_TUPLE_TRACE(fmt, ...) +/* +#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) +#define MTM_TUPLE_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) +*/ #define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) #define MULTIMASTER_NAME "mmts" -//#define FAST_COMMIT_PROTOCOL 1 - - typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) @@ -30,14 +30,10 @@ typedef enum { MSG_INVALID, MSG_READY, - MSG_BEGIN_PREPARE, MSG_PREPARE, - MSG_END_PREPARE, MSG_COMMIT, MSG_ABORT, - MSG_BEGIN_PREPARED, MSG_PREPARED, - MSG_END_PREPARED, MSG_COMMITTED, MSG_ABORTED } MtmMessageCode; @@ -58,6 +54,7 @@ typedef struct MtmTransState int nSubxids; /* Number of subtransanctions */ struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ + bool done; TransactionId xids[1]; /* transaction ID at replicas: varying size MtmNodes */ } MtmTransState; diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 38c570b889..7dc9959d38 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -210,7 +210,7 @@ pglogical_receiver_main(Datum main_arg) pqsignal(SIGHUP, receiver_raw_sighup); pqsignal(SIGTERM, receiver_raw_sigterm); - sprintf(worker_proc, "mm_recv_%d", getpid()); + sprintf(worker_proc, "mtm_recv_%d", getpid()); /* We're now ready to receive signals */ BackgroundWorkerUnblockSignals(); @@ -543,10 +543,10 @@ int MtmStartReceivers(char* conns, int node_id) MtmDatabaseName[len] = '\0'; } ctx->receiver_conn_string = psprintf("replication=database %.*s", (int)(p - conn_str), conn_str); - sprintf(ctx->receiver_slot, "mm_slot_%d", node_id); + sprintf(ctx->receiver_slot, "mtm_slot_%d", node_id); /* Worker parameter and registration */ - snprintf(worker.bgw_name, BGW_MAXLEN, "mm_worker_%d_%d", node_id, i); + snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_worker_%d_%d", node_id, i); worker.bgw_main_arg = (Datum)ctx; RegisterBackgroundWorker(&worker); diff --git a/tests/deploy_layouts/cluster.yml b/tests/deploy_layouts/cluster.yml index 1088615b51..6e7a163625 100644 --- a/tests/deploy_layouts/cluster.yml +++ b/tests/deploy_layouts/cluster.yml @@ -69,7 +69,7 @@ - name: build multimaster shell: "make clean && make -j {{makejobs}} install" args: - chdir: "{{pg_src}}/contrib/multimaster" + chdir: "{{pg_src}}/contrib/mmts" - name: enable dtm extension on datanodes lineinfile: diff --git a/tests/dtmbench b/tests/dtmbench index 911dc4e2b41c69040d190030d69f9aa25354b1a5..a8319af5136f09404a60160fba43f50da5d2b753 100755 GIT binary patch literal 471038 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

    aDv+M5Ww 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�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%0AC*1F`m;#wnE-;lbdb83yX2Ik*$`hZ`;Q4 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 O=(@wARd5gxWLDgL!F!@OB;25b8N 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 K6&1B1bDK4c22&fbS!QhrA2AI=``Y|i* z(_&?1Wo4y(%v>-RY*#C@Y#~#d5i8rwHu=4ubIzT)GeFQv{B~#ESRimSrxAyEi9WDe zs@9=}a~U%M2GF%C32LIakg%h`m=1Ld2~vIDBT-%oxU)o{I%Les2~>`3-6i?EN-{ZJ zhZb%O_$0&+EB__)h;&MpJ0;8MFjm^HL)|}8M`uUL@2DmMBRr9Sw8{%*^(^h2J%_GW z<#92eqKT8qUc2lgQ5owh$$(I ziRbo*LkY!h?8K>DogR-!seBY*n!KJUVJpBE@|wU1oEpySa9)p-j@~#^`4wXW0lVXD zk8`Y~>3$J2!Kt@>b6m&Z?2I!OC-v!WIO*si z02?YHfoPolaVFp#hI0T;%BS%->F6WC-~Kug#I6jjk(0>f^f-Nk08rlf9}x&(V{|71 z*% zA=r({KP~MH@02Jd1sKzW{o7#AW6*D1l*t9HLY&=#xP`MH>h*dhnWZ*SZ+A3gWA;#c z6Ftq(o>=KuqO4c<>sDEB(UMHPN)D-=tv(ci#5K{rv9Ockwpr@e^Q3bV@qb3EjrX^=r&h!?KpSO^mCz zHsSAYO~_X?L0<;HtgT?Ad%^#U$PzBXIX^*J%E z3H{yS7s(%!^7^6j@-1zqs5cGv(eYIi^4**0N2Vt7;Q-pV zv3lDy;a7YU@qZsSk-tUKFIw~P1M9+~+ZQd0?jI9})ga5rm^;6)Afv>dRcz15U>V~U zWK7PTn^$7bEgqGhRZ@~$!ZL1}IDm@8_0O4YFU~3`$;!6p6&57q6lP@2E-bbuFCdXA z_CX7Bv+ae&DN{^WiK8b&)rK;k(#c9=Dh3-LtWl# z8ntnBoKP@LDi|PZ$jHenMn&GzaSc_Eicg+AaY{zqK(AH8GYSzg1{LRK>K7Qx8LEwL9DE*6SJCv2D{ zgV7PQ3+K<5_DX9Tbccb4&N`m!LiUuD=Gzm-=Gv!a<(K9r&%c!d++_1oOZl~9e1mob z<$q{LNKl*TJ<4}f`I{ygn4MpU)Zn9yh(!Y*2jniw%{KOGA4jjtF3c~TUr-{NRjPT+pIngRYXf(u(Y*AH4vo39y{RRl&>uOHS1^~xq&#~`N`7)& z+??XV`54oQoSZg3dvZRtt4}NjqtR1JCSo8It)A`~pZwV6@FDB2X>V$CveAUU( zu&EpsBg`E1J+B7e2waB<@J5DPjL&7Xr!kN&OYAw>efkhO2-8~jqAU@rjO;9X_B_%z zrDOmmw<4dOg%L3;C7W8bVBviH=H#b|>8xZ_91oq&=L)m4^7AuF3vw3~VIa%RVHqju z)JcowjF~=RRDNMWZhF@2{9I{5QE72*#)7@CcO zL)`k@0!YeWpuG_Xnu@b#=PihfkITqdFh4JYPpcXB#YMT8faeraT>Kjbdm);Mn~8uf!V+X| zuHBwDKeupBPS#>@sHj{m&Ch}bSP$hCB5`tavg}#l&n_tuY>*0a*x1yRk)tx=W8#sb zV@Hk3=#SbtZN>~-4`8Ea%t#uUk`Wg}_tOe?O-$IG!_tsr1hFjUM*z6uQ27-tJ9WMy zcTRRN1Evnzr+p1wa_W*6PUuOM5mKDBquNcuIm@9QT6-w(hhl8nFg{# z{ObHu27X$P#n?_VvpWoYGp>Ehn+)Yub_#1+eSL24wI136Sh+0o!Hc(H#jdioQlDi( zCa)Jo80~H8hrYi7VMhB|`l0WK5Z$=nrten}o%X`?L*Hj0x_(bWylQzrPV{a>kcWOh zPV{SaBA|XBN_6ACqJE!9blNxb9P+-8=(NA8A5qd@+*WvUgLtt9x@cojBEdix?JVet z20GQDADV$qG1ZSW16_umvt}6Rw2!MFnFc!Tt?I`-1HFY#1S~Sp^*vc)FEY?+KU6=; z40PlD(kcU;_C@t$oq?|Jn-XuMf!e^9=mT{kV3dJA$Uu)Z&=U;w1Ot7rfu3lf4>iy= z1D*D=^&`zdAFdMtXBg=8JVZY-4fI5v2sqC`A8DW$8R(-8^hE~xSOdMxKu>44l-6haQ%%|R^NRC ze#5YLQ{SENc~rt(TaTmrJ%rOF<37gmy9lR=$z9FyC4|#Z=HAZnV!~+%b8qJOt%TFi z>cafH)Q=1$}INWy6db0>0q2;nq!xMMjU zPdE)_ZY#%o6HY^zJDlU)2&bXT%{bnHaGGM=m#%`)y%pg!t+{JC9!xk5Y3^ejR|%(~ z%w5g#-)8`)AIsPo+wC&~&=lJ7<(-7xo9Dk5-8rs~K z{v!X^6K*BEmgDyjPD7mg7{~7-oTgHDHOH3_PE)9RJI9L&r=icind7$--ktDu9G^`% z4T0`5j^9K$4Snt+j!!0>hCFvB$Hx)gi|{m#k0iV|;fWj{LO2b1?pTh;6W*6_E5~~i z9!+>S$GZ_8LpbAj2f}HpcVGIGw?E-DRJv<{Pt_dflBOq3OPZRLp5*v*inik7M)1n( zm9UBzkmX@(s?awy=NLAo@%1UIelW3`3R6wiB zJvB3FR?^K$wr|ERJLf&WGGnV(pJ=47iB^;k5pBambt9xrS6%)P|a@YadDS<6~m6W zDiJz|*@^P*A&m;;Z~^M;?)HrejN$^rNr3EaSVcE3(3b>0Zd5?w0wxl86#~f>--cE8 z!$3q4iM#Al$;Z6p&50w!5ZQqrpjox531wQGI*d zpp4x)GptLQsHsLXacff?N8&E;PP{&mIWnTOnz1xQG0pKCE+hG6%~&fz%88n>7P@rZ z`A2iL^W+M^Puc_Gxvs$kUMQ_G*PtPWe_qO^8SEsHyy99OT^RB8wjS(Y4kHaYGxx{T%= z)&Y%`ON|A&r1BbMbU+8K{9tUVsVF?vlo^?7nrGFVi55-a#YYbw-W+u;KU_Zi>NL1; z#QZUVJ11z)N@`VJ6*`~jKhPfu{bsJ8^Yv;{O*xT~nlrtFg(}mO`^YvZe-_%7AC*b8 z_qY1`l-myHXwIF)jys{{O%NIN>t)R}VXKyRlIK_DiLh1Qz^^%B-&g;rh4p?z>r+J; z0{l(Q*>(YRYJJ+y1xRunkjf@FT>H~zCoNw+?b%g?ld@DZ`Oa0sI>Hw29Cr=qcXa+)Dwfg{?Y5%NDj3%pom!paM zdC**L3=PhK`=?sj{>5O&Rl9fFKf(4a79CDjky|EG_2K_cjL;1 zp`*sU16P|@D!6(9S2^Ii-$b?RXmCG%i{?0^m7l$omYz~m9h*Vb9oT#eftt-&JGs7u zLG2~X;)%s(6v9*qlT{W2v&2??)-_XP7qq5I;j>W|&*UV<{*72yv(;3O|2 zc7a}hDeS=5@XG2t+x{f$bB+zKN~^D|c1#anUg!SqSLBXQ`%RsqIsU+;8i^HRMYZPG zU@M}T%CXwE2r$)AVJqWswQUukJu$3Tg>4blt<5sWvM~gcCDXb9~|Ie;H+*vup`kQn`C4js z@;}xU1=rlS0Y!f7*5$|e%O`l`ulxe}UP9hEDg<^rri8e2K$x@6nRcaWT)jg>C3Tyi z&xpTPf5QElK7ROy$sSCmgt?Ys4d5RvotH&C3^OS|6FgY=G37V%ZNe604jLs<5l^CI&P1|98F@x2k?C6dqo`4*7J)j?wV0?4(xy4G zSF73}o!P@Ry#{O8zO7`3O&Z8m!9aouc=y5eoYY3TJ!`p1I=}bd@TpV)dLaSe;-|SG@G0TpOg;$;75jFHNQ^bmT)!iL`}dNs zvE=`|bk&2WO1dqK+PY}p8k%)yOB$S9YD?R9mgFW%8k&2lEpgvXL>nS$X%vw}Vr06G zT=ES`CQpPSKPov>S#L!{v_vzf{3OPs^BKS71VTWxqA3gTi){&YyQLw|g!&W4T znMAw+H^oFul*CvfK7>1G&AG=GNkpuQ0ySq4MsZ9JG^k;EkoOJxxExmT7Ao`~n?K+Q zjJeD;3l6vs0c}w3u13naJ>_gv?$gG~4QZs@jeMA(`Ys~!?r}gH)OP{)``cOQDYt{l zWj0o>cZ2$Po`L4-ng7;q`qG~^^K-N=Nqf=yys>ikG*XT#py46Y^$?ZY*;u)ejg;$3Awjt!R}Ph<2sLPj-;w(M z?Vx(f^`&w@HCErtjg)K6%k8k0f#>?+TNI_6c4`O1JnwFWIbL7S8|iOA)`&0h!{hz% zXQ9U^Kid!Q;D?{^D?bh^5@UJQ58v%qz8JVZ5{WSecPet0;loTuoe-eW#C4`UdaPU` zxCT-;#_0JxNzm<)@A4+BvL#y2fB3ami#A_{S*>mdEona2s|Vt`{UXQ@>l8li6ZsyH ziC9ZU+zcb?o~EJ~@k15(49XP~;j*aYT2$h`o}+Sj6VBDbFut-WCcPL##WKh0D;dW=O9EHaF~V%?VMdWMR@GOK|XR`ER#Hl@4+e7-je58Tw| z1n-mZRAnDfdc-=kG#z}wt6wY<7h+XL*Qt(L?Z6ci?k2-3k7DmJ)v?7^#_2h> zMX7yqY(b=}w(B4P4$QQ_2r1;~X9N zT56HjhZae&J7w^pu)FMtjMH3zs>x6+xH41G_pU$--9xiRElRg_7E4_<6Lw6Jv`$2e-N%=|LnRHp5BHkHNORSk zBX8`sG-{(I91%H%8*P|bn658CFS8sZy)*F_8F=bCqquBC4^EhgH_dK{wOK z_r*kYe7cWJrp(wxX&{3xR=TMUcdFyZeNhzoJ9upUMz6}hct9IzsJ^h=)s8e~w-`3k z%Ct?|ufL@@PP$Bj7UiXVeX_9;5pX{9$`g2L(WV@!!9$Wo#c!F$Jur> z3OifekKdH40fCNVVJ{xgHfn>9EN}7ar(rK1*RoG&gHJ9C*&i*`z4~_gNIp<3)|@(Z<$m4qE3qzM!7xdKtyg z{aPoY`>kEUS74)&-%gB;nls;4lrs2YSjE55gnXY*bKZ>mgVXjqXyCe=TBPdrS}+Ym znrk~WYR+;#0vbmFesAG?WiyFaz0OCQ!`I;2SyH4`-I3|qg{O}|(0A^Lbv5V69g*^8 zq+R`F3st${40M+twvbhog%}jc(4q;IXYCkhzj2ik8(Uh4aa{GxoAoDJ2iNKAb9)c} z*yqr_2R7E8g){Ey{LTaZ8`f)epZM+{xf@%r8RXr)(ddFEGF3Ub0Z#2o)$R3;B1FRd1Dy6WWH;Z2T)v9Wiqw*|u-Cl+aWMoPOIq)w zi&`|tVV8xHr9qyGg(f$BAG7Zul^vKVI-q8j&o2qx8y*~w~{hwP7w0n3T` zvF?5@&|sbxD^aU!F3q8S)1l5AFL{_+y=!*9n`(9SlRWh72E5jimucXIRczu3kDWW$ zPnfUV_Ymqh>@MW+pu0{$R|LFtzaW`631Z!SaH4LTYxn0UqpxAmCoYIabl)y@^sndf zaF3O+2k74YYX9}8hF*#Fr+KKA)}NP$SozAQ8m&Z!es`u{ui{ierxu{YxC%WJMEDlj z-?rFDKDCeNr+#bEjbLH?X=ELGI~l>(q2GUo9^=0bCI9``q4$%ZSchIi3F7S%l*vcI zrBzxPs`M^JE4X!9A3^slNNJzGZ1|4BR+v}u2!bSiBhD^R%xNsV^mnUQ4i8-FHKC4mMHHFJ>v26uH!@MnN zKMj==D(k~4?#2|n3wG3BN(wuG1$p@uygjiBL~3^`P3=OE@Bh6f6M_hytvf>aJ#};G zJne=VQ?c@K_(oA7hkO`$sHklC%L!JBz(YVLIDU3*p-P?NdU8!}wB{|Y< zmaxi2;N!I$8>VDDK;!uugpe8Xl^&smRnpr>QqJc&+B0YldX7eKAIBA1_&(KOCLo?rbgsg0MmqAvfWaWG+sNWB!I>jiXVU{mLr1+|CGcM$M*k@h$;wRLQ z4c2w1crrCy*VXda`mF1|#fxp8bzN;ZM-utEu0KZ_tn2oiLY2PjIx!r2mUa)4#EL^S z5c@3c#Q35w3&JW!HWHsO7dwyf(&Y+R~?d;aajgr;J8rDtH-|g#JQLY^k$^@Qq*5j>aY10l#&3 zD;~}Y*yXc6ch5#|FqCt5@Wbi0&&a3Mgb^Ry_cX?-pxRedP{e?9B-YBvOO%b8ki&Bl|z1t8D_i?m1d4eri|<$$Nu~@K9^w z-k_Rnm`TcELkVK%o=)E29^hSRjdAV~)?~VRb8CEOAe|RVJUMB)4j@nXJH=$$yE@tU zAbv! z-m1ZL9mKr?`E{E?wY;NQgbL&xP3f1eTS-6!A0xXb_+b_E$pk)_UH2Ip^%g>fT&$1W zD4qf|=!KEo03O4G?!E#xvgFd+we~bLV*JSTQCH$oR}DUY4FuKJofPjBQ6O;N8$>Vs z;WemrKOOYGYeZK`=~GkaHQe%x;hMA1syQe_f!8?E!*CYxRv>o)W7gDgbf*ap&?by}$-nH*I1j-ME(~bq6w2sF3 z=Iu#!FT+0mIukc;ti@1&X**wgO0VN;4Er5^@7pYYpPS{{gJ!QY*yHJ`e)}WKUlj7I zN&X41{l;$Uw?9(1NyO7*a!n9le-EZit1(gH%4Gi1b>A^+%2CEuS*Z<#c}5>cc|zl@ z-(#=8f7qv_7kEBHMC)E{MBd-OCxrYql7GM}|F{03tEV_V#ByeyD+k$4_ey9*ydyaX z?znEi59O25f7-zvOpOfxu~RPZ^x^;e|F8Uq5&tXyN&dg_|1Tf^;g0JD{50x6s%YT< zd;iFPj7R?_Nxh4B*TeqrlP%ZVA4dGI{3rSU#(&K7hW3Y%t{d>_18VFZ_oQ|11AV{=e}b%Q=JpFw%7ce%8_7HDExcPVftVZ?*EWR)c8>Gl+bNTz}QP z)E4)qex2e-wP8E*kVS0W8pbDW*Hm$s@ql1qu~rqbKy!Sc9r!9B#erG(eOKMv_4VVb zLZVU}0X9+-F2`+WYix1i9yRTl=A44THtiH(IAAScB%lk>3U~=H3h;_n{;g74<8O-V zR#ZSUg*bN6CIs){*idbCsl3pl*n7{Ums92Xbgcd!<#bEwH~eLqaL+r6b)kY#ev~$O zNAXuFu`y>d-2asZ)4~Un)y(=@T+OUMqt`4TuX@Ert66`&wJd<t20oVGz(2>Ce6xVxz~enN zS_h^h$~3oI4HH0EF!} z74${9%U_H+pTiv>!cRA*0=YK#}kJ zv;XqD4;u$H^~Z(uyHqWfSxDD|bsg!azvf&@0j9qhI7xRw2!3Z7d}FJM)m#@>D_R!# zwXOXvYPT+~%QP$Rqm0+rXO5rv60P!bY1_Kn=zdAu9xOWwC0I?(z@|eaJqSVyK}x8&w6dR-+B%E_q1?$f=m@kqlD7Z=cpci=#}kaT%WzssD1J7U1)fHJm9u? z*NvqavW`PF-0-jpC*__r{zYMYl)v%2^^6UxSPF69j9C7VaNrEAu3P7EbBv#xcMGXK zv$QDb59Gm+xJ;W5XS3 zK|+f2me>i-IpMS{4yl`pzil{3*G;dl!z!pB`8o3@cZSNk>c|Ty+b_m_)PcWSk<06h zBUI^_C_^HY=7V5N$I^k=ou1%0?}~>oHl4yMQ>YbW80Zh<_}?)Y+TDEz1oRfMPxEVy zmqeV?VOHIf9;s`6rSR~UD&dLO8V?k}QR4EA`Q>*CeQ=ea`-Hs~*xQgG$pb9f@;zdnCNL?;CG*R5}2eNO$4uQ&d} zdZYYeWU6y62D5&Ak8=Y;L;Y7iw_b>(cfEh8Q6I06>kWOh`}x??=wpD+_!MTSb<&wvL-1mz|*xCY5#$16L?hK&5{ju&7#6xsJ zXBV32xX-7lnuhHf(74ZOem-{+Zi;pd=Wfb&&HmlTXa3SKLVWQJ^7$XM@BN~E`@)yH zdzx-vv5-Wvqj|N#zm|sAO%U%R$oul^eeZ+q-*^&gpl_Em-k1M}V#4psG5$~s7}jrw zzaM#v@=N}$F7Ertl)p4S5hZBO!q)rK>YfnmW}HSdbn>r<^4{*LSSpwz0&D|dGCjK5W-m#`4!y8~&6W$NH_rF9f4 zD<$vy)c2&>4##*JSTJ|JCPTsxttt_FW8$FyEG+JSn!Bv&6+ zc^-#G6Y0eY%)K0N_T z9b9McGG`ra+c(EsDKr;bsTAcu7WQD5ehpDeN)=x(;U~p$hzj-K?a9kwAxPz1`zePG z@^UF?CSHy@GARkG%ct>+^D%E=Nb}v7(Y?1X^z)qW%UE5nqao@Jq*e{PK6P;Yg83;9 zydY46EzJ59)XI-8@Z8-Dm)tX&OK1XX4QIwz1>jx2Qmn6Y(Ll-J?z=Gb8b)gOzkTt# zRkSebS9e?8BsaaP=iL}i8T|3W3WOR}(G#M|^(aUWmmcI}xo-pO3#PBc)a`n6Kf;5z z03O>%$*`2(G(7M65FORkkD9}QcMpku7qQF1X7;}Fg~VT7&qHiN*ZVL<9m8}^RwvlnaoqlDn8GZ<5g&Hr&XkB2XkHcB*)`j!%-7;(G@a{QmdT}A?E}cKTdwx!^E(ttpK`$xJ(hKcb`GP;S zB-a`}&k7q#<`piqmX_dKWY$9dMa2@WuX4N+>)r+zTIii@R#Bno^a#FtZ%mZV)u6hT7TjIYUM z=OTK!?=mH${{44f6W;l=aUs(uaJFADZM!8~Hi5Fq2dD?*|h?s{#G{$tD*D zaU5I-KTUnnF({@7?qA-&e*HV)|5N?+M2Zf28b!wp2~WxV z@UMTJ%-gb5AzwC0!2h;>s`Kv-|N8%b`)4*9uKzav^w%tO(9<|NW=MES=7oR!!)0ES zO%U>B69xRA>Q}BY4gDGVJK?+2Wc?~r!Aj_;)aCSWO>2KpkvqbhE* z_CwALI`)D!z+HG3VKd+=yw{unxvhZn0JSrq16~1i5&XKo-iq>9&eqq@Ab1W>EC`;* zIE`1&PJM%V0B2zAUIeJs)z@zYbOF{9yjWi!iH8I;zN@dNk5+62q{j;LzK0y(qD!a; zQ2U|2p8j8iqkvJcKk}FQ`eT4w0j~hk(MABKESb!dMd8XdAwiaPu+av3N1U}U!B*7C zLc_;|Mve<>zR*&}uJ16kcYj+qDoW)?st{)9z>sovlg+7*NK1waN2PuK>lH( zj|>f8ttN#=t~8AfwU!5r4vkgs2oAM^k`x*~GSo7rIZ1JQwgGNNx#x)hZn-)()S4R{ z8lDtt87aiL&BRugq@{9?f=uf$#F=!zsDARzg0`VaG2o%1M1u`UWW!k4Fve)Z_~zVh z^5>XdZpS|_w*logqV0Ko?=)U+qOrbFqP}-fE)%)J%boq_!KQ1KU>;qBZLAC%|G%I@Ab$zq!GC&hRc^pzpUi%H)YYOl25P|LXH>NtRr%}0k?#Q!I?1NNSR z+(ojt)$QEga+RAp6{b@2dhDe3+X1 z9ObqR`F|AUa$zUMWevrp%9I>xT}^RWX-3kP2aXO+RNo8^jRge(f`kZAvZ$Z>Qa%f@Pkmu;0LDlfW0%Qzc=}4LI>X~31p!AYPWlhx zHbS1p=zzqM#{EN1c>F6;{{<`HF>=G`9eN6HPtu2HN$X)pKn3*i{yM5fptjbuCZNi^ zI&ge>kh(G$LvvDdlM)aUtIm(%)`;=<5XxQIQC~k-(g;vHe+GIY<^~55Zdh$z8JH28 zSRS-iU1O>WP-js0LhSzXra@hFYS&Ug=b=nC~~Uj}`O3%c`1KW~Nr>OZ6?dzEW(J;Z#r zHJfJstTih%zubx~How!F-LIJ6YRR@K=6hSRHx%=(w(M8MT-l1PQ_WwsWV_Y&@3&;9 z)%K8FZ8E>omOXAV?~Y)*Oy|2xh;Rv=ez`Us~+aA!qqAfcf5Dm#Hv-yn(_L$lH zas=CHHa{D|-Zq;bk6>S!&F^kCMTHYmzn$`-}^T^shAVt%m=dsi{9Z-bDSUuend6!VF2_P!eP zVN25vSlcpaYXC{^2{7+z!;S@*|I>z@4KSZ?!+r=bf6<0jn$5qqVn3SA54K_J0?j8| zvHgMOi!Ir~pmb>18)`n%hCS1=4`UCtf)OvZGC$si9cV*TOqt7cqjC~?8q}K}Qj`q} zB6+GULqn}>%|24hwQX6gVt%;|`w2F;W~bDFd)l%~h+c%r9YB(Q1yD@>Wi~(4nmuVY zKNZ1VHk%K(!-x9JS0mUff#%B*?1Mn_dlBreAhV+_do;+5IKLJ|zWf%{3EJMZ4Evxh z`#jwIZCmzYD;3vUC~&T}L@0~s;SC>hAxXI|2A?y%quu@hR;fblVby#nKzUs?9}Q4` zQq4yKl=YN0+sx({15LGN^ZG#cY@m5xpa}`Z6B-#8U8(eE+`C}*FlFI40p>%&?0n!p zwLX}A&_;IRTB8NKN6(Mll?n|8O{eK+w`mfg47ZPiRl*cNITS zmn97BBI}p1hlGP993$a03Fk<-K*E(0-Y+5ZJMf=H46#Pxe`oDw9S}1Z|D}Z>Or4GY zK&Z4|YF#v2?-L?eYJw z{feduK3_Id`RM}Z%U|HJGX%aD*K}NxIA7Kh;ig3TWqg?mcueBUI2Bv1GZXoh{$IP% zCphV#WfUFy&}>{536A((GftJmnnii%cPzbfI^+Mry-#7AZ!wCYk!EZ7&v8E-0IJCn zRJ#TL_l9EG_Zu)Z=;RrIfS_}n7+B4T=9EczEHy1hVI6wqp-@188IM9x*8B}H^)Wcu zp{j^3f2qRd8oGqy4J9a5hG=!Tk27CJLv?t7F3pxe%gZFB1lFL2pi9FQ7Jf~aFF>-4 zTcxmTx^BQFv&6i|*frfArAwyX1x+1OiP6kHpCxpxr0-Z*o<4y4`n$<0X1O{F*Ze;^ z4zT>3gKG!TEf%#uO5Q`)A(q-%pgZY0+%g|kbzDu?Z7jE~!F3f~M_MM`4w*G{-O~-05o<`R zJ>Xo!k*JV4_X6q2k=T$Wn}BrUNJ7XfXv)r=Ig%Li_*x)Vj%XqAcLC|jk+hI~*FkkR zj?4(DodLwAjK{Q*8S>pbKzb-Q0GSsu{6-*A-0Gqb$1W)7%Mp9Xju>!al!b6%QOMdA zK;o5=K*~be!pF}2l{6rCh5Y&xkO9hcXe$qS;$?^>D06|V3W**FPLcwn*t(F7nE5)7 zQ=SE~G2~G~#&cwI$Ww%*a%5}B^Mp*`$o7yOgiKU=q0Fw3PbL9L98g~FK&_bc&Zc;-@g90sN3a2j9sjZn>3lBP_y-v=&4Zk`SlJ6KIkc3RV!;b%z z<_Ps1^}bgXW{V$y%hn0DK>?c?`v6+PenIWF>-gmzM{v8BK*FMyuk~84V`?DeZG-7e zVhk{+F-Qek{s7V@XmX{(EZqlp#aL+xds|`Mhl&R4*bLXh=sEzhe?qoxJY*s$Rv`4m zbvyhAUWnc_D3yf`Eorm(l?bI4juNgR6VZqm^+33(6+v78R{GzkGh#<`SgUIzveE3TO&VO-G zwUvW4`#4zpDF^Fd#VkOVP>gf-vJqJAHD7)QE#$OJ0St!In~F}e)vy7x(#6|CG;s4$YBtaBnrPE_A@ z8fMO@P^J4kya5ZD1tdck#v0C`-$b=i{&ka(d9X1V9)bwvrL79rv(F>L>!L8Qu3u8{ zIw`ZT|3f=3C`xz3 zf1$>rqLd{Va;V_7kzF9(R~Z{Ba3LkuM7{RVxD52JRaN7uo)&Uu@zd!AW`>)VybA+!}|)Ys&X zpq41RKsl&WBizL5wJjM+7c1}UTsA+O9vGPdQjJL^q+wUrVFb`s90=}-_sOAk?dpH|?H(;2dA z?x(uA0NRwk+p&sJJ1K>bQG%(Kko`z*wW~t=X{^T+kAl63Di$G8?^wdGDJ1IBmHc|c zc3dyd-Ayt#rlRl)`tt{+$4a8#MQ$iPR?~HPIb8?c-Wk)Mx*-rZ+?H#Q%fz1bpt`Nz#6pXt(%-EjO z!K|5qHTQiW{+k$iR4Vp3T1kDoXETMp0OAfWBM9MF-><^QvT8s)p)(@5ll{K#2Yp|Z zPDN$V;s*D7U4r%dvI5LAFLi~PUFQU8a=o@PO0F>=fI6uzCawGgy(VKT<7KP#4Uk3NSTT(A?_q_rh2$> zpJ3^t4pHvK=#mF&A#tc;79WxaPLi?-(IGeP2Im32oCq%69_ov*|^qp9-}hmOydeXn&;jL32>jNBkg=wBm1f~sr{EN>dRp5k^q~?1ff2q!d<+maomM7- zm+j$unp`Lu^f^VLo2u9$v0RrDGeyEc#8U084*gbPcfdL(7bJQ8Q^`wMT0`T3JV4R|B3ij=4GfefA zZ_2e`^&&POPzKZgkg6_L$8QlmUKt6N<|!@M6>1HVlb6l{Yp$nsLIrL+)GGCS8e?yg z@-nbidP)oS{b~f*dx`xhSWkLOe>4o1KdL5AlBM^7b;w(qv$v{$#>mp2gY~ty^sl&0 zQa@DRzM1hMLirOcwUzEz0=hW|)GyWZxsp8utV9ocNCBc5 zy0{#|~;h`V0 zrxyL?7v=0&MCLV+5BU}!@)OovYP9KI3@pkg;C-p{S;9@&5%Jr3^-Z-S5K zZqgdj8MsW1Dd&Bu=Uecvcw}D2IKdJ=K_$_nal0z@v_vF2;uKzqy12|#vd()LR0+Li+H!I)WePBV%-v zD^!)0NmAoDNZ#a;Hn_>vE(y5&trRSQ(49VlEP>116QI2&WgY}3mAN@6l{&*F&d{gule|E z^qq=C&sCn%eIEnynZ88~0pJyMGe3#$#x1c!vZA3h6DAKfpB^SH!P94kXUs-R{2d%` zj?v^m{5B*{d!%_dM2e53?v!ILKO*b@8A1W=8mMInT+nVFjR~Dk44p{GBS<766TMRT z<`y}5B!Pc}kBnHwBm{kjmU`NJe_QDceR_PkN09qrXap|3*L?U@Y2!vn{-+6PV@puE z=!cb~3uU=uD088aa)##MRb4P2$C8^jhY8biBu+znbHk_z6K<%1Z#*fb;~+V{5otri z@Cw=lUf3Xubx3-O?+=is&lLN&w%7ak z@Z%`4RXu#aC~+;Mhc{Bf+aO(E-i=)UEYLh!+)ideS|llTK(YE8))&Kk^u}4BP}C|K z5lNukpy(6ogNx(>VDyO&R103jh+hM#6C}y!V)BzE;H?a% zUK2DVQlUwKDRtogplf3ZJ?OTvdrSA<1vPRLsx>;xQ`zT{CC22J!=t?&!y#SIcJ<`+CBYd%YcLygwU0vR zMUS92;#@HLSM@4x;ke*Y2%Yi>^04zLCF~)M3xbwzm4ZJ&Na?7@)KE1EMmIA(dxu``!y z4?^f!kD$R&5{&L=`tr0CJP4sv9zlOYx!U7F;Q_M#A0Vl8(*5^Hvji@9HfZ%R!0KRtp5LrE}tifQwEQm`$a{r1Kw z`klX_T{ifW%A~iOFwSvm?5QKgXF0uq`46WOQLs}22Ygben6Q&J>@85(vpLwFK7ddENN>+ z`{NY;do3|Ye_*mI0md#oz41Xk3*TXQ#s;ZGaHONVm?C3`_WEEO!_tG z6kC9of#K9kM(`auA#uyU?-UY`gZsQk;#scaPwY*_%$}Dj_V5mY`#wof1rb7`57jbf zk6TEb2loeGiIJmmuN!mgFGULObfsg+**p!VkD?$2Q&fXG-G>PGSTGAB>VXZ|reB5y z4(k|P$QV7$w^tYC8&>h_+Ki zyU##WxjKc&NhBGw=03S5#M5H0jSU(=e9m7_Mh6;gw?QllDLDe25)BEu_?)o4>#4!fk z!G03Kc$6NqKdVwmq=7rrPvUxNi-T!xMJ>hPF7uPP&jE>=@81_XHh}x6uf(W#*Fxg$ z)K`R#mwmY`nA#_31)eK}$DCZ-9bqN{Q|ZxC%qeO}b><7W{Djh1rKcz{pB{vcBq|c~ znHfE^InJo}$Y(+Pq5}xMb)umW`gO)aF6PXH1=v_46%ZLqVjuE&eUAO-nDcW!R@g^i z-U3FBmw65Pd(4H8&^tbb@Eu^RASSQ1A7}n>JD8+)BN$KU%!oXg#rm}!kK(_@!g?yc z8{BGLg2i(tQ&e!N{3&q0*14j5JZ*=>Sd=?X2nBzD9f(-*`XjETfW=>>D#Da<+<{UZ zox$$qC-Mz>7@_Q|Q-uFur;-TyFSXdPGal1P*@E$mY{>z;&{w2CZ8*i)l&4OKK$ZKl zSunLu^K^9Z@R+{J`ks1=j^-^IqfnO{O;5&R`iX1ays=6xj2KN%#$w`>4ba(}RK)aG zzQOgkRL6M;Na{f4FHlZw|C1Vp1x?28YYuJ8#+DLp6w z+ZDaQuPI5}-ToR~_oT=sUB{`*l{-Ok=+uZPTrp9gLfHgli-#59 z25YE_7r)xw8;$)r5>@u#=M54G=3L6Xc8|S;U58ZSeu|%3FSi*wLc8bBjZ;`6aj)R# zs+UW-*Y4Gp*rE%EE+wKDVuDjxJCt+ZSc9E33aBywoa=S2NUWihneEQi)BH$OgnWw_01_KY<5#;MTegx$z7F;g z5}}Yv5gK{gU45laYWV_eH;H()B+wAo&Z0bPmughBbPJpYHGHePT^nWlMj6W<;Kz}S zSC2Q@g2~{Z5Ac>E5_KV@8Yb#~q_RxZr*X;4QhKu>JEjpN>Pslra8co#s5G|mMCGd_ z+oPEXX4AW!hHI#MZ_sHt;W2wxyhseq^P>HE%0 z1)ag^rE`4}b>K8S-=aE_z)mF*@-5!67|??Qp??7ulLoW zC+Y_)q?+fzf7Mrwo~VKOGM4Xy|EaGYZ?XlG!RlFT|MeU3OEbI$6FWH__H~M#lEOhc ze`hXs)~y`Nt>9qZBOK(t0?>Td8g#5UyV52WqkhYM=oAZ-0q{6vRyM8|D)G@kdjB*X z$YNzCkSv^0@1m%rmMOP`vQ(!=P+`_J6*p&bD;3*ng}-NYKiK?5D%N!_2K%^sl*lr{ z+3w}cd>x!M%KgwluMxfF<@A^XZR?dmw<(P5IqTuXZ}=9R`;`-~E9?W<^d~q$n8&$+ zqCz3^pmMSR`3`m$uzQopCya5v*QcdPPpsHi;?oH@Dz z7FSz@vfGre9#Gg4P%HIv5nn}{}jD3-hMsxDXu{n!(& zaBr9LDh&G=tTP@q1&GBxfJI5%9_5~cj9msx>F48lTzvu9)ygv5Nwfv)8lBDJezt&f zNV)Ke!uo+a(93CF3C>Yv+O-Nx0d60a0WEHdhs4;&?m-~O_Wc4wJqvm+ zlQCL5OBS`x@}pLtth#CjNK1YJl*!Tl}p90B;N#Gnf{tndbuC|x>Blz5*QyoAOX zOIKkbLV`k?1(Op&Z=}P7_{^zsu<9HhmBiOUK|Z2;M;0tn=)7YNMhz`@*p9L!7RAa5oI zw-#}5+e!}dpXOkG4F|WM;h;FEj%CgS%T?BxS2?95_=rs7mKxZ5}{7dvP2a(DS3~5V?6JX!rqRC&gpq>Q1~`Hy~v) z=48(vKuSi&0`XE2>!gf-Za)+&sc&&GL0}UFm_)$#HkwmWrfh~M!gw1!>fJk5~Rlu9)spnx+*{R$51@;GUTh2 zY>2QyacMwoit-H#e~U9JkI1Ql$D$cucXA6RI6ZpBlGDGf6g6=|vFAA1`SLxwX5teZ4DDW35=EeBq z0yw5T0{#|~S;5)gVCYirP|lQzT>xb-SO>lA7gm6Mx59=f>{%-P8Cc)w?1;Nb#RP9) zC$9Pp{Xm&RLEAMDz7``GOqp~Ew@?4V{Si|vx!d5!5qdS!VmWdF*EMt<((^Jzlv|Zy zn0rRzjN-9Q+u94%0^SJ9bdYE3ED^jL7C#1^_P130s^KbCtK12Z3SErdK<^4Fi;iR4 z91ofJ+^L#Bp6pcseE81U1W#Z$dTaz^c>PY|19wMkwco z4+WoYarOaOI?hclG7 z=If7Q(&deL8#uQU_h*W35)b0RG7y}4k%-@k!}tG`L$AY1Hb7yIgZsR%grR!`?*(hb zQy2h)se_C^_X#y>Cv_V7Ysk61FzrjVidsH|-g8xIc{j3*{^)s_`>c8|ID_7Q8w|Xb z)qD{COao`s!z4fCk0BsesA(qwdVt*5!%Cn9tnz^R9Uj*`g-VrVu*MVn2`ZUDD_G?b zbp$3sAkY@Z4NGQ=U|RdsDK@!E$)m33f8=dG%gwOnwL7l*hr^>SbS`KJb$I z_5HFB9004v%brImyHow*1{w5Pu+Dqf{F$NhnyPJsl0QHWM3}h05zmn6@jSl{s1slt zb)n8+_aYH;OypJidlatgKpd%;75VKMkBqHT0}sZp!(uyJ`NZ@V3Unt5QwAL;EuWi| zGSF6%q8F+DskAwKTNYzGDQ*ve{PQrv(cfjS0A;OCjd+K%>^l+E(pnQy=k!I~TAv-J9?w?EuWIH zD!mtPE+E7E&3qo0x4(HFuXsT1>nL=9lwP7b1hdrLnlZBI6c}F+^D<}B(`@tNho@s* z4dO32|L`!AdaZ!krNM|*I8LEX5SMoWp|?(q_>*)6lLo=QYXn#+9yVWQ3(m?Jpw9E* zh|)<>RN12o!MaOli-7dIaX2_nub!_kYJpAQZqX&gf;2X647_+@=Pe5R4>&a*F3Ag# zDfML#`Ojsn&rGMmKkt#@#_>K%dD4*{J@I4+eh-ng&9G38oNPT3YZmiKvJ8N#2dIK} z017n#1+_bsVQP=jx5MHyq)%)sn7<}VM2|3^U3Eb35$1FE@@v|#HJ^WkU(+VM`J1QE z+6w0DKVFH9}GPKx~jl zv<>MRw1aAYT2aP=K3V69_8dxMS;W&DX5$arAgkO8cBw8B!HW-}*WS!7W$7RA#S#H;i8RE(k zVlcumh%v?*jV-c7_I(>$mXH#%FO^VHlB9(eEw(6GQdvSs3PmL(BuTsf`~7^DJJ;9u z|NH&s^*VRXectcq`E1Yme4g{1bI*x=)IWC|KfSdN(j9QcoyxR?j+$vxjqH*3(8(SmL2M4qivmfv=QX*9mN|V5zJ8(6ErCbK= z)r%@6qv}T}rETCojI@|347>z6dZY#J95@zdOk@D6YfX3=ug*bRdk1)5k7#!Q)HR|l z@Swo&O-wUK19~u`&0CRT#|7R*Oi-Wodjili5p97V4!jV=aZ7kLpbbttlXt$xJ|0NT zgK^jk@mE$;j$|)$WDDSH0^L^wzX0sA#l70RGc!DB+A?!&B-Y0ihfQ}K4>n_hyx1x+ zRR*H;svu-Xljwh%DYsC@j*qE$6V6~**B)RFiel?qC}S7L3|wG}odSG86emnweTP@< z%9sUMRn-a*Ryz`B6i@E=j@=lO3PWlKu)P-dG7Eo-;mjXf)WZ!M-$VSXg(7pD*LF+} zob1H3vv90n0|X4%bkjM_nx@~#F505rKwRlp0->QJN&iHep4qfCn0KgdGhnU*SpB1! z`lgQ)=g^an#{Q1!h^qcXkmi!;9A5tjC-XEIv5RA4N}}8sL3q%rf{kBn=r z``P~l@Bv4W?$eY->K#Kl3;3@nitgqRE8G7YF&iKx zT#DtW%ucLTSbWS+6dOa-99wE#4vP)zIz!UWO2dr=GGX0lh$mUdgmsG-!(t??dl7Ik zhIKeY!(XTrzNh5;Bvnv2O)k^pquf>a1n?eO9GbfdUqf=nO2eZF*H!p2n6Q_?$T95&CD+0d7&@jcmoLc)j2+WnRP#=IUddaj znf9{k3dP>oQpd66dqn!G8fGQoi4=RGi4ZjEb{P6g)GQR!k>Ow3F?A#4NT+eNPg}3p z0ae?<)zdbrt?O{s0Od_!d`NS1Xi1|Vs7J>tTwYS%Q6S$EohK+`z_e{@KoLx_kp78{ zPpj1EtwSC}DIck1NWzqgMJ?T-%0iNErQwA%7ov?@2UF`ybqBE47S|n`!Ei3^xXOD6 z7BzH=p9B0p%hAzVCIh;(?^SA1IQcAKb1m+5YWyD5e^ReMsPmsb?=;j}61%ZCyigqK z(7fyb4pUzLR?Kt7@t+mpe-_67G|K<%s4~<*=*?&y7NjP9%(w9phoq07g?G|4y+;x`WD&@0+Dnt4_#czc) zVAIAB48zBL*ix6U4<)opOT&){Aeuw*a*8E5ORMUuXCZpUio+|V+i6A<8vAM!z8r9b z^X#IsU}>th-pW_sgK@#J-jtFVxTW3aD-Xky2b+{^Mo#Wf8tb2V5%=$atWtniww$o& zOXQZe#D4>8vuXsaox@!%bZC~g-oG7zYC)8*hJZBE5)J&GKl6&`l_ER`&^*G@ITD(s zZT27f3<-I{uL63@X>0gHfAAkhdncfMPFq5=v`_p4wGiS``wXB9PFusf{l|x(X@rB> z_$eedU3LaTv$TEwvltE0E(fR*VHqF|AM_jiW3=x8)FPtI$Sv(he?1b)>e-&OM@DxC^A~1ghmG+1K?Rca80-zNUm_b?EzyAHjOaf#ppid&O+*slV{)xk6 z&$3Sd`iU@W9%gwuGE2K5(CrjXHQD&sCOGxOCXLq|iMrDA1uCKzei>j@qH%^)X~hD& znkijO6Todri4-H0l7UlOan+lp3<5kl+KT+5D=j539=9K;*}$HRHX%`2TBSh4XG}4x zfUmI}Ps8bfWlKy$_5eCaSUgCgvb5U*K49sKbAT>Iv>BD9)e1Cw&Qvg=DV{HdO>1W| z>`H4GXxtHXD+h5ULNfjma-}s6gdah(8bW-hh4dYKl4eS48F(DCjOqn!h{Jh6d0i$o zfa$J*`)`5%OkiPFPd@aIVA2KzmfmU(nq|P>cKSRL8}U$sfELwKJK7KX`T^vaUDOZyvG7JWKCW1K}tVz*K zF_*!}Fl|cA9f;_t>OT$AN)qYIa!}@q4AUNs=`ab_J^*27lr=9yBE!;wdv@#L^1lOq z{(79Wz*bCDtgIi8wX+bm$gt}nm9UWYldw=Px*Jftl(lbTj4E_F1D!IzeGD(TUVgAF z;uxDBtSI|jYAf`vD*Ie%EA+|Wz6~TFg}DW+#$AwlHjrEn$to)iw-?9+k{>|4(?WXr z>aYt*gz~%?JZ}WrPxB0<( z*l&z2wHIq;@`LRl=x&AK0YprG@IL$sVFZxz4joEV@`KZ?OgF>k2N&)@otFVK`N4;F zq9!^&_$MoC@`J3n$q!B_t-Mh%djv`+XmlLQF!@2|T3Mst0sKpFqJTO-*byuKyAT#^ ziAeyP22FnORtTz4DCSIlupR`>tS~%{wnDUE@`K#~4RkP%9fM383+ap~L~EP;;8TE> zSy*?7$q#mY7(oI`co*o0mJyX7ym+_rz5sH{q2x#92m2s?4*Uf?4h|p<(y+KY{X}9+ zafZ-&^lVD0iu9L5Y3(Hk$eJM)$l~$uby&wgb~XO7Q_E1tkZpd7Iuq43S9APt{@ItT*wH>~@{9tp?+B@nJ+H(29{*aHbm>y4)A56zA zupC@93-A+`5*BrvAMA)LnrbDm4GwoTarwblXX5+;^-%{v`qC0zesJ6>Jm;72FMxh0 zyplDv`N3b%S)!c}^KT(+x}$7<@Y#_{YgYkOgRp4Z{NPtVDsMH7w*qvx)3*7+&lVt# zCp;9;sED@74^Bl`D%y_#njg_N`N3D8S6cfuKyOF1O@46I0bC5C@m+vEi@+v7xS_1l z@Q;9gcCgJ4wn87MSY$s7Vv{z9rE58|EobD@1r)Bh;OM+B(?e z2dCv=@cKhKf(YGDN^tqXaFX)Ivi`GyKY2Y)kwBps#0liA0=|J9RzTaa`N6e)upaIO z_Ej`)@`Gba;0c2?@eAO8NQqR%x<46?9dC<$e zaTR)DiyFEY-ghSmy&OsUC(?AAAN;;4%#8tSdNh-PkS9?f@`Gj0>Lboy3euY-I)~2{ z1tLG#{wrA94#GZXjV@yIgE{kbANr>OUvd;y%}^HQt!^lJu#ObPrn^CEFFdy>N(?BA zV%-NfAvM_iQ!F0EVJf~w7J9hGzCEmc9pNgXB`l>@P34R zozAkMWw&AG$=7XNDJa&Qg=_u!`l~rme~J~j2uAn{Y2^gESG^4J+Yb7NkgOm1W^`D9 z!x`VzPQaf>Q_9Vx;g#wn#6MfetUkPlA>W#FgAfQ*fOZh|%Zn}b27L2s^A?7DTT2(m zxe{%c1ya$W-FOE>z5^HL7_mLVV5h1_^InMcPT4mO zeN~}LyN(E~UPcUr;rP#65m>UarxBk+?Fg;cq7{1@aTb!_tTbFtAafcK2iy6uiGr?9 z&)dIbu>({!$jz+=9kDANR1e8sulzHZk1LE(O>#@cLUVFDWnMycf zu3P=qxvReb)TgnfK9IZmD}y@ZYDQQQv2ig^jmaQ!iH zr(&go2@l~4T;eW8ZtAUb-o=+sRRCXZpkO*n)YAQ`FeK%zH2esl@OVeJ!eo0Hy@~^$ zsixvGwW$9B{2#|**LazE51{@}sd^J(BY#(%$6*um#>OMa7bR{~$CGeDg;l5lyn*9f zka9+3!^S!F^asdN!>Hd0cn{0*G6cS;Y7|!93Yxed&;-J|54K%~_GOh4Fxm?NEs1Cg z{D;bT8mVAvuLJacM0?ct(EdktM1oJsJ_P7!L|b6x=WI9HmjV41(M}6PJJw$pGOa7n z4YzDyGovT)4gTes2%uPYH9)lp>zd#D1hkX=yy-@}4WN4>+5#8wSKt&*w1)#4G%m4F6JK|hD#==0lgl9nCeU{>G#F>%6NQ2XfgD?P6DO) zS8zvxl=mGW_LYLlfX>zUY#vvIFa6k-AP z`W&Y5#J^)-yHA@c4mizG!Z>QeVz25Hy6c^BImNW8JHTmwJ>JA2;0=zckF&!Ypgk0v z$&SbFkUk0D!b(=1G#G_Xjkz>K3HcciUyUYf-jhXObV*Ewk=p1saP~N!rtlG#iSNW* zUaAlJ9{~U6DD(?`V5c)zn)pRbp3%6--4mxi*m52BRr`$rd^%=KBVD6PfEz|p#EgDI zgC_qTbGRgy3beHoh{H(cVInTAKVAmYQG6Ggyx;%rXT&2|4Ald`Cy}G)5k8eM z@sNM?QQafzX+TS@37y7CJm%lgOZS0#7tjYzTkTpD@GpO zt*!w2hp;Z2Pi0KJ;7>+`UYc+ip;9qyW(E}al7Fx!Vj;q}0jf<{Yk!`FnqTqnO~tQ8 z2)6^&DWWa#U;cZgjrK@D_Y>CIOrj)S^YEEl2@`^I+v5o2-|;@=2y-3)V>yo|GXq5fIy!Irq~m@9cw zA58t&G)Io5jQodCgCAqh#_EGWRRdo48cruH&WSbS)}u@5&Z-0O{*J>g*T;Cq05mgk zN?f7)3~?ezbFV{8pH>JK8^!;11nEKGtD-pgwH)C#@zrYJ7teqWM8RPe=w&k3kT@{# zC006h8iY%Z#5x*$NZ?{SbWRX!$&J`_!$n{2WlHQGe`2cX`ij77I*uI2x{L{d>b&OA z0$3M^vy5=Af+hz(JdTPC2Vs&UNzde}?V$LZJ_hMY5MFX5-dY`&=TyoaPl>Yv$LfHz z5ri$4q#qrXI6D5{SIsbe1?Z%O%|m4Pc&Wt6@!1LHF!&ev4gJt+x}xE%{{tiRSp4QC zrq!i@SGtBXa187$3EXw3DeDg4t;rGBk|iQTILiWgo0tPO2l#!?j^@ny0(M>sY%6ZO z;Zfj=uCXJWm4U|!n>xP@{QYa}48f^*;;pfjx8NwC8y^CG!r76L$`DS|*nc+Q;WOm? z2|N}%x!azv6znXCZ&leOG>ZdIu^g}1gxR0)H-Jt$ZCM7A?^WyG!qegi{|hJv zONMTrhVNImq!{g+0hK1K%jPnW{IHrb8S^N$`DT!YPFs@w$+OiDBN6<=uIdb^XGHt+ zEYy5~8dyYW?Qwu6MzjTfR#k*UiS{Bu&qcJkN+j=4bCHLURQq~Bn<6k*iR3+MHKM~G zS+y?!9gDzRC6W)Q3^<;^zXAF?0yBM^T-ZO}Zs~Nyc^s%*q2glk4~w zzBj#J7o?Vs$S&1vnHH00`=_R0lzW3PG>W8Cyvfh_{WqElO$R>DasH4JpM^PXXq%tb z8irm2;XOx^()gkCz{v;vp@-4(&p@;d*bXD<5VpH<$cgewEOEdp~sO;&;BJ59&61k{l*kC(7CL!Q)^oE&KL zlyRyNz{gt?hQm2Gxp1KA4W>Ju1pfRr9L}f7sew1%Gkw1S_;zw~l_i{-fiX{*vc3j> z<{CSkPm>!2ewu6Q>|@?Z#FpERaGD2-^j7*XDhoWF93BX!&YVw^y9C-a#5%#QX$Jgm za&py2I70$&*Xt=J~mVN1SCtX zG+bFAlc{_Y;*A#4)#>>;?lWVi@)+bMQyCbFHHml6j=_#se)nq0RQ>{jlS+}{K{W1# z8UabE^95>Lp$k>Y+_e9{RKGS9T=n@Azed20DhFAyuDTb$1WPvZ zhF?M+l{aL6+PtCq)$`bEuYvS74X_S2Z}@#HEaUjT1HfK_4G2o!kT$#!n-gMxG++EY zB5>plXFZTRZ}b{G#^nuvdIfkhV0SxQ+c0^>= z!)>3KzL^DRZbaMU4QC_f673a$Ryl2(H_Z1u7B3p#2`DTbYV(GdGqC8K26Qq4nY`gA z1x<}Tq>#b~(XB3TnDVYEuP7n*xXT+3?rLgUBcf&UhJG2N)jFbO@`mkum>Ld_KqhZE zX@$ufPLDwCF_6d`CY{ICY!3IbNLd19`8Rbip74G|%j69gzihM)N3=}d@Xhax)+MK9 z^M>zygs7v6=jFk5%P=;55IjQ%51mIHY~FDAO`2B?oVw9Gn>YM=gw6-H2i(t5T4I30 zV$bFcH{&#iMLq=1qu1k^yy3_%F~vgrC2%%69y>-xEu4>)w0XlV1(c8vfcRZBS@TTZ za4tHKM*jjQ4tWUOUQIE1!`VM;2PqCX%~9xHdUCLN!~G|51_1m{$C2aS<_&{5G z0gsEKh?(fTVfTxOr9qwt;>#rSAQP9?A5nS3{P%0iAAor9zgjkV!&qFbr{$kOR5%sA zu4R`u%n!y*WXUw?@`mLhs%6D`U3*?!gj27}8@2+YlViP1g3B8Yf_${a^a^M5hL7VE z`gM@iW5A!boUrKIyy4r==`(Eg4)Ax$(X)`r8|LY(dqnLAbl943dBa*Ib?>T+fUY=g zn>VaHPy2*Q9)mH)rdx0GhOgu?+LZy_Mp&0^@`iUK{_l)#P%QzqbJ}u7n0U!AkD3o4 zJOt3lh&E68kT-mKE1rT&cn+X>5p9A0^84eYU9?{X^j1XM+Mb`ya6BhS|K~WaJ=JX^7JZ(ILVdCYLvC@|E&l;7Xni zyp7|?v1Idx_mwqWI|%sbYd9uvIJ>?XyvKk)=QuKPXk#XCc=irsY&}SyT!(1$h8OnW z_fNo2MR8o-a0)Iv{RJq`{kC0F7C&6xunSfuRT6{>j>Lo6ZkV6N#z;ya72fM`@198?MCyDh}5P zc;9O{JU>O=a9w^=)&b@)33^nHHq z0f09t^x@O~Qd+FQsZ&yqoJj~1m^VzCPL|{ilV)u~={j$i)LZ8bQwHMhi#~dvImD#C z67Wk7F{xi9hnUn~;`vApG3g08oliBr~j3FDLI355+>LRoAL#vHyxAeIPT>ZHQHq%BUja zk^O)`Z2`Xf8V*kkk~*r!NYv4sI*E_7qRj3SrYVl;;g34OTr{ z;Sw0((tyen7HwG)lI~M2_TVrj+z?O`r>)_K)E85Xc27Y4owh6qNz>K3G|VH^o(O1~ z)7J1@Rqa0fFpuzafL@Gfb4f^Aq_&O4L!Jn40`y@-Ti|7CUosxsM)(+@?;_e@x-BY_Lpj#p^SB#{uRLh$UoC&CY1m^F~lFq7^aVOws z9G8xO`Vi)@hreLQhdzf>@?P7doBZzhMVIg(uWLBY1K|1VgeJ5p}bHo+?nc8N|egi3Pf~_2fF)VCJHzu9&s|`W1ML{SV zMbdf8q(A)9Z{YVq?4x?Xn>miOQroyW(DPm3-GL2rxD><>ow7`-6sU@$Sxo`qF-M|T z>y%|uW?=7PwjbC^i|dqS((Qp!>6pgRIJFJX4#L{InX*i39%x-3r?jl%w}4JZU{2*p zodaD;80S|Lk@&!tYn&uynUoXof53~uX`&49D&#~4AcNC=(&)f&M8MJ$O@X(&hQsMT zX=>oLqo&)303S#z&BrGM>wwp!fVZO z_a*S}$;nk`PUT4(18=v(62+eT2Y7H&bbW-gCor|2neJ}^UXh%LopucqpqvR|W2k=zw@F?tM>Q>2CkE`yz{q6%5oVfudtjmbPSWSTnE9&R;W{! zMXCXol;uGH-&j!BEIMUL^Im8eC@B{fqA3-+y!9}0e&Y{9e7%$q)^{G-O@Wp?reiR*JxE7($7<*t4_4CKcqQeA>gSr)fqU3D*h z91i}w5~s|8JSt_${>AoZmI*1@JM-`j{#9N>ch9wu0UprkBm!wa!F zA@)b}E=f#}c2afb=1y65#^O?#`2QkhNv=y-o`>OISz>3FXj7IkpcEjDQoR=UByLld zZ|=pdj^#n9Y)Lw0nT4;}R%DKV|1o7b1PV4~`Te0t%JKzN>;IgxWOu318!%~8miA<+Hu%5E@c@%7B>C?7DVhT=8X-Lvb-DZ6C1Yxujn{mNjWBE z`Q$gag%L*m#=x6fj!RiyMZmd$t>^zbRC<=zCNT?f$Z5p9#QystZ69zpFcfOm{dUQGC*i*^@w=2|dYmRt1M$gd zvgVnT<&3JD_XarcI-aJOl;tLOs6P>cGe-2X^da5yqok-?kA}*~zBr#xbb^H<$9y?|Ph|~Y8Ws|b( zx(;(EEI$Y0>i=fhr7X9DvCEo_-0FA~qMxi-uWPf#MNXj_E@kP@Mivg69{9&ea4E~; zke9cZUg2!Y@}_P0odU?JA@DmbCoK9lW!WOXzVBc413s7>J&%}_S`KKX)3zzg#=G@MscnFEIBlDY4| zqu8YRo=sV<=;?Vy36}&^mawk5Nm<^E6Hw8v2dHsG+oUYNDr>a60qPUcHYv;FI1=S1 zmhpflM_`k(OlXVcoZYe*(6R_@QkIWYN4k{oMnGE}Y*Ut3iUK+W@d-j)H^Uqzm$EE5 z7`G~OCI1t6>?4*V$C6E1PX5?*ZE@h`ui==KtiYbdC@Q zf%L$2h&E-p<$&@Y1O9Xr$E7Ua*o-H@1KJb?hgqOYSx%~ph8+OmYe!~p4X3q6X{C~Ud|d>hozT5c+HYr%JQRarf0VU+Gk-sMaelVZgpJL(HsV6 zfd5L4%u!J(%ajj{!zDh3OCQ*Bb9fGml;v_vn=*>&z_Z8^*ODc|rYu*(&)7h9H}D?L zj^^z@<%%0jGUx^nld$OnJ^EHhhS`#`Y`h*jQ7KCX(q5mn4e^okBC?fZ zSK^~+ZQSbkBm(+AlYYlXTxWb#zJO5bfv+WHdGnJ96LiXwER(Vvj?%A}vgFySl4q?Z z^_77CIw?zu=X0klWvt}3$D}8vFHOo)W)73Glo`yVEM>B@Da(S7WB$UH`YdM-o3g9` zNo_0D%gGDGL+ep-o3gwMgwBq%g1D?0NLki6rMy*ikx{@WT*EOb%X?nHtLmb;M;`h##AK=(wnP0I4wH;wjiKw~1>CT02M zOr^Ew0(vr{ZBmxQ<{K|v1!zqKHYv;B*Wm^Qmc0ki!3b(H6VNr(4`1$QkIi4 zadDaBk}w~Se!wOT3vXe^hh{*}q%24LX?WGasTa*NDa*q+EBTnFIsooP3Wv{_S^!fv zWqB0GimXBtL7MGseJW)xb;K3^56_q}TLIF$jz}j63)`kFbC5DtdqDUyisVw3s}f8n z`~v(R$B|arlx3|0=%oA$F!f{8y&whg!=)@Axe=tAAT)F&dbLYges>l)f0fO5o2cn@R8Tp5zZ@tD<2y>bAUf}jUAJ++`I|X3d?#E_{MAOn3U!C@pwE0IR}A% z6KzMQEYCssyHz#`o2Zl}r`qV0rOfZ4zA)Ro=co9^clu9$Yq(@#z8c1>%f~sTCk({L zRsWtgxX^})y&JaF100z;H^518qXOVhJL7dT!GPL~_#gOKa=xV3)cB(V;BEmm6Qaki z5%&wIr4YSp#rkzg8D;N)vF(AEFQb{Tp*{q@*KtnLY(`%+Gktg9t20V-P6NMm4QEVo za1I2Tz?|4gcnZfqHmO-y+qrcR%KA1?3PF!>ssOL;IBcPpF$Q_*^b3Iv8;zZIz`I|= z>G>PV3dE$t<;2cd;FGV%3B^>1F?JRMe=Uj=MpvW2pD|;l7l>I2KNMrzLE0BZ^fGEa zh)NZWDRRJY&H(@Q8czQbuv02#S_?C~CL)`96Sm0kd9_C3SqJGAV|M>!DxMC!COI;E z8qSP){aO;FIIh zyTm-x-!$nx;9D)n)9}EUANm>i2%sML8vSzF%5y=X-yc;H*3I|ACrGL-jRa=Q~iJswj3|R ztASd474u*-oF2l1)KoyTuYpg*>eo$zu%t1TRU8wTaWlWQ>P!Ptsz^)ph{ryw1$ zL@$G@V|rq26Sz4YRs96$mk7+4-=^Of`(?U08_V-F3}e%yuic+7w@oh;Td;y@Y-Qk? z*Kqh=>-18w|L!-Ow!phNjvOMjdJZ1!rB{x7GF%hfZ^R0F47Y(hQLU&VlzvK%iXgic8B9=jl9;M#!hu&^$sY4?`BWW*Ejz+zM- z)ERi)^*gZ69D5HnD?9p42>jIdlvnnCzCYRLmH4s`ObM%NUVkW(sP}X}N)F%Cc`1kq zE`C393$T}G@%8M@1XsT!bi&!RYfTfBH!C)UC&}xY$&uGJU&M}=@(q6NfNMhAVYJ>=cb)$)p%(l|-KLVNS zM$bU}l7;kY)uHX%teSiG2U{=KjQ&Aw(B1qVAD_W@IW)Pv1pDUMenX$dl10!y+m8bK zY(MVXXZvyAKHIM-_HV(KdP7whZy+xO=~M-R+Ey4&B4VEH*9!YBfpm0eL89_(zg||R zo1w=h_Ri1|)cGM`e!0zzBQpGI$C8Rpr3 zU2jLsf$s+ad_}OFfIPK`y}xZM+~W)3MQm3b*r5C*6#QTu`YHjNHm8LXib7D<3d5CX zD?|$#emE0QV+YG&u90c&Ang-{Xzd26EbO_FfF822?hx~Azn;UD#}Rk}=u*qjN0xc_ z$K?-{_YRP44kcex%)38cD}p2Y3*g^6j#N&5MnXT4TW!P{LOap3DRcW{)r&n8dP$z& z$C}|Wek>mUX2LrDv8(Zqomz%Eo_+TR?b&Dhu_pS6i2c4GMp7RUu_sH)zJ9h}1=;5> z^I}gW9VLfPm5x1AK=yf|DfUNJ#6H_EN%sHq*?z3PvhV)*@HspL6I*IEj*)w|-w}v@ zu;Oqn8NXNX-96jyZ+ywO)aZp5<6F2MScX~!-`%tQ%7IqZQ5(~id$!;0khip$9#8XZ zzw%WPHiE1A0UmBCVNtiw_Ve(krU84>;jSk7#1`-VSg;@KC+eeCfwaaF4P4P*ja6za z;XQy35^l{J%84!B{n2cT(LM+0lGE03UH|W)MmynoTm;6ZwdKSX@BUbaFn=zMR{)ew zSh`umcliYhBacJ48KAo&+B~tvyFX5UW3&eX8WzzOxR?LKE~7mI(4!G;F5P(d2OrSQ z-cT>~#gjj1m$Q)VsY`=@!u+*}M&@xPY z*i7qr=8boMyjtHZ$>jl6cCdN2-)#jkxVJ;vl87ro2U2+V$EDu5DTK!R10QicPLaUX z*AOw1GaLAm?sApe8SjI??8N3pA>qSXOq5*9DB@BVmWi_vZisAELiJlpRJ z%xzME5rD=?m8Z9#)Nsc-{0L~A`OJwqe=7~&9v|S zXww|eA!J>E_vf?cPB&RUU-8jwJmP zX}W#3-|hQgt}R%-qnQkZ+_U{2z=<+d{RcssL!xu|=x6(-eGSs{AiUK_nCKpJcqXMyMGGsl_-ktX16HHPby_mtQ#zcXZ!IL*r7kM2&NpzsXL;< z16Ya56vi@zwdp?}zcwUSG&m6BW23=Qvah4Taoo4j;8>V@2wUnrj;5B5RF6Wk$V$Tt z1v1g#3W!%*$V7vmc3{<9G*}q0M1v zWM4;vM`d3}gPSqhHX7V6`#KtAMQk*9v+Vz8G|1|^XmCF~{V=xFJscw!4W5DMS1S%5 zl<`}O?=Bh);mS=3Y@!!l2`Ky(ScX~`-(56#8))?%^*C+0Xs|WpT`U$A4W4^lc|U-w zMgg8+DPd8!(cr4Sz!v~p?r>KV7Y#miFMdvi`l$Co+GdF^8vFtC>omeg0ewsOC)UtL zgN@o5?Y{u2S8YexXmBZ#38GyDP)Wj~ZKJ{4e#3Pc8m|SYp3}C`;E5~v2@m0W0CkIK zn`rQ15g zaV5BDa5D0wy=eSC;1jRMDH5pO1GmkPvk3Tda@hS+Qx^@+-GoE#U0@$Z<0cxMcia?n z6!0lhB2_WbV8RxhXtERrpP|>IO0m)4{+n?Lhn&*D%abDqlzq~3tsjkvhJcz_6YfdR zA*8HCyCW_f}JmWETz2dJOm5N6hL*mT!XWK5W7Fz#iT$O55t zG%44?+7M}VJn6Y+tU26rz`QSt?V`bNE$30-OQJYomhGa!^##!AcR<+WNSskzG&uGY z@B_fUw781~d*Vg_|2)M1S|~Ed*=TV3A~;rlTqWg|Qr&ck200J9Cq2hJ15!;8S~!yQ zPo(KK8hq&!FnfYEJetWsC=v}~fugEE3#6w>bPgXK4K~Jf<*x!^gR@2#vC-hqh=o`W ze?Q=3jw0P>qQNa_xlk?xj>TG%YjlMt(I6Kwi3Vj+to!=ohz93=iVONdSdag67zV!V zs&3Hsw=6({=$*T6z%CzcQFe9j)7WJiuv}fcPUH*a+$)5Pk9D53U0a^Hu|qawz%NdX4rK# zEp`C4uZ||U$XVB&qOgSdy_ez4*%*812kEUjtk8e-7Rt1}wfzUvTa3h2&)c^6O_9O+fEVWUU~S%I zi>J(s?_N^6u@%*HH!{38-Pp0E@(KZ|jV(;M?ndtA>c+au&cJQf6@c5c1F`?!r!c7F z#$#71PPQm(3;pjyv>dl!Wp3E{VuTl7!UJc(FOT60RAsjP6DSCemr25OIj?^@@@a8h zzKuf2_4?03(j;yiUx#>|&hz>god?AQX}RHu?MP4WPh}le^iZe+y|x7uBEG=vx7WY^ zhcMM@lt$7$CJ8~QDm&U;#8diD?ufBHz0wv*bN{n{4XjcRT0PW-|G!$X7w*D!e)h8* zTh2ej0qMk*<=KgR8gt@m(*QnFEL;>4Z$ODWMET5>3Kr#$1;cqN5fIExntN%yS1M)S1?w9S$B<;5;VKf`ce{0Nnrih|QS~YQX}E8XK>xA=QZ#BW1~lIAc!Tfhe%7 z=>K(H{bILaao{^Wuj$dS)_)&^hY{mZU1Y5pF?WP|IrA{(gnsl-;-utm!lN;>5{`CN zE*tt#m41^ouK)H8bnw~K;#B{?(;8T&mpJ&o|G%0z_;pG(vqbe(JVLoToQEChLB5D5 z%y&;L8)&JyK-NR{34A`6Yzzwcd~CEDeNBeo;tE@JDAuVAao zP+N*S8omCj6wHi!#F}x-pB$`S|G1Y}%7)yql;SMtgIW&doCE0O&`kk$?qw;eRnz}v zPvE)3ZW*Lc>8pyiI2s<;^SONKZ#RG(VM*W)6oPp#wYbH&o9*6|IvimI|awT^GdB~6w4eKPi2sgtPc zS!}7FLF#E~YxNf-aqk*w_zQuqP@%mFLwt*cQU^lGt9||)ppHjIDepxns#<^>k#Y=* z;rAgjl&%?Yk+(?c0=U1U><~(qI<^BH-pk=M5J0icsw=7EKikY0|q!2a>t4k?3D zrZ(RW&JF160@!p-Sc*PqFezZ1AHnzd9`~Y@%$j|{s#K>CBI3+h=>1B0F5c~2A0zY&)Mu^G512BOe8e>mK`C-^EIP))*8 zaE8FY`ZQSc zw(~Emn=ddFx7$f|O9M|Mhb=Z`rK|v_VBnkS#!fcyHrLqk-v*~}pyeF=T#`LE2>5Wz z(QyICzF6LA`ZgG^`3seh@q~N4fD?S{9ukr|_c)&0J$}pW9%rN6;|r9-J1$bIqU4Bs zoQLQSD-LH6v+l8CE=~aesr>I_{IR9h71+4PiN?77l5jepni1HzNAnYy4cN%L0JSG9 z1zYzB9mi!pY7YZ6&ce~|@iB%^Ow0$q$a0)}%m*wc-Ujr(g`?f0!g9n?EanjK6XdWB z;pZT7?$K<3Ddtb$vFK>2so@y+*g4;nRUCMEa&p-*?y(;+u2i=n@H?-uW85R{kg?Mb z`0#7&824yb4RvGB%>vHMj_!8}8#(q7_lW0{(=h*>1j)=lX=mL0BfI~7{=w9R8EiTt z09YvZfwRykVnKHQyM^jv;Ts%?urM%U0f(EN17-KWTac+VK2J%p@M^@uCy_eH?tiz? zfpxg!{c*I-F-18Qrti>3`@~%hk*JamXb2E2}+F59K7Ya zt0@CXyPERn7j`w}>6Bef8Q8kjwAyAYk6o?T6IvXG}DWhI1b9Ho#@^lDmlxUupngvUr>&BCXk6}6hy z$J(JT0$1n>&0*m}w5w_Vcs!e!#T5pp1bM8HT}?Oj08$Oo+lfdiVnG6bvzm6ndaODC z?-j+-tLfz%JWRMpP(b|9H^Iy5{?b;iepuqNUQ5fsZiR!`eLa)A%%o(kx`Vq6YO>yJ z!(FETv)(F&-7GdgYt7cy$R(q!{n#X;53j(USAro#*7~_!an;u$}4^o$lAL3D&91K?6fRBe9^SlnumYiF} z|8NsqxpyqY@;m>meea;=?u5qc|I|3BzPA{-6GrNyf6F76Xn6YKHSdfWg)7AN4W?>*2^ z)q!V{6TrOXWtbHrAGk*dw*}NO0-F`$kMelNIp?_%fW{J*g6#^?ZIJTl3hHq{i!B_z zLOd|rm{{bYNn$)xy@N(p^ zriNoyh=oH@Sh!rYC^Qr-J0FF zXN0zb=&iiiq(*kSTM!Eir68?JL`o40>>qpbP#){Ix&wIYD2_gwB@Y?ei2_pk{UoDu z@#E``N;6ori_l%NuSaDr<{7&PF%{!RWj#vU#1gx(E_M;x1Id?G8tx^K8I>~-|7xMA zQF%Qb2P6=cfVvgJmO226;kgjmQ91hr0vS>&1I~1m#X`}e;(cwbv;o|U6xJ*}7?h|{ zVR~MT20qPkShx`Fs9d=jr_n5K2{_BiV~y;nEcp@0dPqNsw!r?eqtbL5I7fk>isI-| zsg8zup&lq8K1Zo46g?_0 zVh$23ry=~E6xJ;4V=rn{yme?r0(zksHqD`$5bdb^5XLeCp{fo}CV8xp9TnaiqFO@Q zE!u*-*3*OrfA;}r1n}`u96c)Xdh*b37_azMx1csz-TCro6B@K^fn6OMbmA_@A!}7X z?&{EB1b204&=9*OG}zZlc?(h2Ic#C(q{1I!&xQs&Ucz0!C_^LU8CZt~qu@hjqhK2v zy!bROJAz)1sJxHega#EtIQu~{_c*|W27{i$i_e`c$&SU#d)l-1&WG591_w}cmrcv{ z4(__6w{S#Vy9+~E4pQf^ z1tBSErQu2f8HcR`acv7lIc&n`%KHH3R9nE^NT~+J@D~tShdqMK&@NI&1D@n4-w8!K z?1BmSZ5t_z0Iwj0H4DE3QIx}uCgQ5-!;`n8OFBWHZ0rm&UOov*hv4*Tvs&L8{uX+DC15C0G+LUS9Z_wYM}IQEn-s(tX7{8h@1ceM%TAZyiWEHy7=V&)l@< zx?b2C=ByWXkbOOEc9ne{V)W*|%}-86k+ZR-4usTs;WLoDWToL@0vRt{3-J~UMS0WyT%I>Q_OCmxIe}!+>3*Q}rYd{Vm z&%oLX>y(F`DA;=8_c$-2p}UDrV*QO5mVOmSJH8Kffbqf*R^l1X7Hgs>J$Z|1O8y;a zc6?^(&#voayf|l_jPF0NQynkS*{P0?&UH@qBMSN%TWTRlos)U{aQ=r)q~V(dGEP<$ z;<6Tsa_Boo$TS_Kz@Yu&u9zsXkjzeO+SFX z%8R}(j7`^srD!MP#ZNCp$BJ)J4z{wo^Zgjc$$AfQPSydt#>q1AsDtV-H2_=qHa4st z_NtkPSpDvyH~d_9K>O*|&C8awQ!%eVf zy|CzhOyi`S!pAR;(oQJa3x9eF_w14qLJNyvlbVH7Ad2$BaWJLQfY)^#stM70Vc%Eq zIxpI44^9{ISR?C&w;{o=?uB$>v<3E$o$7AKxvp9O{JAJjuAvFh^Ws-ef~~CXd}5>V z!crJFGu4H$YrJqwZ{=-(sq@&vWjWPt$DZ}VoV9rL5lm==JOgVl{P%6V)gTJCUU=el z&!eIGLHz|~1fgkt!0h^&*HjmN=CN(;ap9OYf1XeY~I@$W!2>l&Go`JQK z)o-J`IZ?26vKb}uh)N(Y5-rR&8Yg@21?BPkCI=WNt8puCeU8|oO1wO2G;8l45Syv) z0n}WkIzDDod*Kx}Iwf0s;ex~0^};eRXQw)OmZbdPHNHW*$n{iLllyk6>x_Qui7mAb zD`LHHI3y2RY4~=5j2F&<_$doTdEqb|Z$*KqRruIIN>eC?t6|T2;e-J=SV`HBk7JHf zPbk_8r#x${T!t_ft(2ODlkhFd3)dpqtO^4!?>H=6h}H{t{e(M8AXE*&$tI6AvR=52 zp-X2-2Sr<8|JbRna2m8H0G}1b$u%?~dR~0fiQ6Y2G(9U7uIG9!IE$_B3*U z@xle^%IoHAu_oHd{kzZBEH;DYII=&(A9dk~$83lcW zE%hX%&dClza>7c(X9Y4&b`j#gEfnQsIS*iI0-_3_ZY8j#UW8(JAw<^6o_hudD=9Sr zH*}QcLeWk(7pGier4!&BQdqO_C{UuD?4e<3#Y4a!bsVY*(K^`|n4_quUIOPe@>nD5 zWLq&RYBQw!qAke1b!MtNjMS(49{7bQj&?HMP2+{=Sn>aKMQyUW^C!8+$!_JvG@Ws& z!CjqkX~sfEM)h=8Ed)5o{6jI(p4k6FL+6y0S zfmc68!PW~$euNutfV@RiekE_baMvl^<%dq$=>X$}@7;~_KW9ts6pEK$&u8t8J&Ky^ zux}M=E_0#uMdX*!b+icv*55RadGE5YcuaUvJM;h;a7Zv$Pd5b8}eQ- z=di<3_!w-d6CrgDI~|gFRvMlrka5^$5WjArD2Mg#!4GnQsO|XJN6H*1hMQu~I&7D> zaGi>j)A+dLD0d4*J8b;h#!4QvuqZaES-1=+Q4V_urz@&5@OqBJ!i8uZHX{{334%~{ z0H-T?tdVutahM9!a7ZUbTabI@jKkK(T^H&J;7g-8dXRXx8-CV?0^*zfiBht<^H)R0 zVKb1;GY;E`yV_yz;;wesF5J})TM@g)VfQUl-bR#_3`=tBT=*2eS%>|24bCbYLY{%O z!v>Dx9?&S*I_%3=kb4Hb7g6~kpK;jCACQtnr##>Q&}Y42 zRSF^lP$l~`&VRo_9s5;>>kLH8ytO6 z54O~@yyL7$><74BoHOPm%>OEeNL1FzAYh0Wpe!xHq{)NQK zdpHP7JRw$EIxDi5yFi-F8Ot8KEL9vvYOc;)hu;U4_)DOv7V>g_DhO#u>4le^Z82-Q zX;C5w4+~){2^7l*x^UtI)I5KHK5&c}cg)ZgVbAvzwSNf7polKNqIrktDAPFxZwRaO zxBtn?Im_A&6}$;?=|5Myu$anO$Qo`C(g2cN4Gq4wA@G5MPj6sq-hfbLNS|SWFFGUAgS6xgXjvMCyf6^EA6gx4Uc*P|n)9js-F38cYMrEUDKhvy zDkhyMdsMfF3X2=C;2}`|p*WRHse<%cPSutu;{$as3c1}u+(YYFa!&T6Abh08V82f^ zA!j~y3n|j35aN!uEe3K%QuQ-+FN`gZQZ=*O^EUuLq^bk|@H+T_!*J#jTUhJwqRmV9 zFxpV0g+Yk4RVENGXZ4G~?~qEf19MecTbb`S4wkXY8piqP6hHah$C061%i4IioSp;ayo&z_-{N3VzUAt4DA!W_M*;8Rj%b^{ zDh#(P@rmO7-n_dz_t?Hd=(w66gVTd3$c*iUCajw}4}9r$@R7ku@pyt_@GX1>ls_0b z;W+scXMn>&!ieSYi5qo*@}A|9LEb|iXFfaMK*uItojYOpB&8NVLzMuHw6cvsQOK~Uov=-x=p#C8mvg&X56n5Tt?mI z+|LLuYyf!+?$-~#gfqtacXGc;@b81zZ^nWp3I|q4h-D~N>`!B zmm>XF+0T#tk+MHB$o;q=&5xANxL_BNY${C&KjVViF zZL+)Y40bnm2P-bvm)ve349M63>6-(wI|VYmOgF_IepuB7XVqVGT3X_ec7mKCa)kTu z5Mi0#fJ_>CjjFtDR0~5LfW!s)c+Qc*s`!ix7O28~e#Ql>%I8V>o@$e z;}WU&I$=%=98fnGmicX3L|U>0q(#NR^Hv(>9x5{fQ$x<`vLK9-9}Rp=0{dM%q*OU) z&q$P&Pw~sQ#Mx82XL9a;4$xM=JT&6ZLb{Tw{H8y&{u>QJDkS>lNOJnROLB7H6*vDV z)y^hPt?<3J5?;>N&j2qe4d~@??x6t#@Gm5-81WifalxnFWXtk$?qrt~5!;KLbkzQ` zSZOP<_j1;-@efMlH;}-_djns39Ma~2-IQp@n41@pcc^kAB8;K+H5C43g_=I_6eh}> zfAtf8GVSpO=0`kz^PMWiN_0s%H8z9TT9(SDQIH-1_N6y!YY?Ol*)IdeFNc}^tmQz` zx#Q)e6a~IfS~-PM)<}2mkP2_&yr;-496<4>PT>4Dp=rKzxc4BZ5kj=4w|$RyXJa(e zwvAKxTH#xygfInUZIrKZa8iEVPm}CdFYRLi=Af(jy~LDHsa77g{vt;PmPL6@_&Cml zrl)uEl}%RL8}b1T;YP(O|BCw?Z*8iu1kCrpKy4CYp2aPw&-B}+Imt?wGq%32ahg~($y}0XR$g_;)RMqkn%P9xPIf5r_aNF_aZoAv*dQkV9PY+ zHLkM(wYsSsIgQKt$>4;srM_1lRcd>sHKgUcG{?MlE2LE%QrpjhZq>0V%Hsg~O@Q1( zbSw12pYUT3EmY?F8XIR!P2DShxAWRwIs&D-%`U^)LNJ(&O)HM=kLTXztyiKAd>7VL3X%6{(hIGCk>)Sq zj3gL*!w>!pH`suN1h@L160h;&HXv{Lsxwr2Qtbf6wP-N-j=!!kUdaQ28V6`1;V%hi zmTUs8HGWoQ6!rwfO9@dkELJn;A|4EG^q*=4d=0S8(fF-W>UMu0#77+T4NX_&5ClK= zGw;MzAqXx3{x_OZ?94ql1Ogz3ssJf;?{KeCiCSoxAH*8dsN`8hE&e^1a6pt+@EJcD zW*Xg69lKt9KQKz>N#6-}uq+PBJT=oO4>D-UlgZ8t27BP>%u|PlOmgtxM9Aw=ep3VL z=DB?eRA*sJ?Lb8>Y_tf1cdRf>lX|8Q&yW$nzc00$Y_cTl@~n6B{m9NI2T!X37jYhs z|2Z}E|7kV#|K{d2~NOXYd*6bx&a>kBT(z%6Nx(yuLIQ1BBdid(&$|Fy80o04|9KzPa_rcB77>FOXnqjeOJ^VWaN$M$J%c61X;cr9yzJun` zwDs_3k+@q3!RLUFM^nVZ*%GfM@1#n-qdLE&V0M3iQ)FEJxF*HoN-5QfH#$AeYc{I! z&Al)fjo!hRpdUPf(B_V8PD#l%Y2l8VDhmfhYiy~kzl?Y45Rk(`9(8R4{Xwc%a49^h zFGzzd(QB)S)c+Jyr#}JGsS#wsCn&MOqAchvf^@k>%!nUj9UAsns+T(dJ-}N@SBJ#7pwqHT zkGq2Up85zAa`q$L!Oq?cRWEz@ehhJTa&0s)JM}l5uz4w0PoU$nUr5AED-NH%;W#J% zAj87!jdb{6IdZaJQuATx1r~jlzJ86vXRo{+OUXqbY9lzi$m7$z^)j1@uU@ylqk4PU zt22(^hcD!P2jO|g6N)r6dwsbbxOhSeYNbn~0@}#7q&$WrYi{=D`e;C|BQ^VK0K;29 zK`M?*?L1TyxTt0;#Z~pL1g@&tzT&bvpd5{4Z&UqI!Wfp47s}!wW=MIMW`7iim0u3i z$G~}lyaM#0+5<j77<19>NcastTSJr?m+5wO)RAfFLs8G3ri{{0MQWI@jW z`NN_*`jPcj7U=AMetKW?lF{0t*mOlp(o(e%vr&r}_4phmrYbu)_bQzqwjX57lzoHB zbK_uG$j+li!awr-)tW<}SFMF!LO*s+veMDhIe1QXKE)vk-bz~bjp}i*o@WX2V|pn; zhOEMJJltia1?*hUo2C;MBNWLlWNe*iN#L(T zvP;UBQVH)T04Xi?NV%1D&n}}1qv|EFrM}5N7%$SYsxl;*R;q_Ez0pA^q^e$%Ft-5e z76pfO<@3X6e+$^k^KA?8vjPZW4(ENF%kM)ou@1-NouSlsAZLeOK+)L^AI4;q{ro$a z6tZ{UjSCRj^S{Hr8`&Qp#RHbIU&ck2xarLc&VOlVjGw6SuAnA+$!R5kCoz_|V}*0w(O9}J}bju0^+6$6!bLV&Ni?a`<( zZiCA^DbRN=SYr{2=baMh0M^`uqHn_1bU9JloUjQKOWs)l238*?bijd=_YpxpN%(@u z+yF;#cS7Cy_%dI;a@4iACGwBG8Wu_pFFKsUwV z4nqMCP)in>*!KdO9EZm@13W@yj5dSr7@+3~%cW;uj_|a*RjW7koI`B}v?C5TFGkL{ ztDYN7ReucVxP>#OqCt7t`Eayp`_x^9M#aCtQ~z=)f2;7h!21FlQ3}_j?5v3(g#vBR$sH`y1v?Ubv0yZcK zpA4fn6@h?iE|pWa4K)zwzuyB$Xw zfacWoqgX`~J)Z;rxfDk)R%_yUextjMvdG_<`r?RRy_fyfF=VQN|LPROX$Jgq$2pf( z--t!ovM**hX&3u@(F>|P5U#f*uPgm~+GT#=76gs8!5M$i3%AT`11#G=H;kduBfw@@ z+-o_O8e96^$^%-2;N@|sWGA3j{!cs5C2U9V8-%ob5U91Ey9%)mBltTDCDeP%7Vja| zHvXLbASo;im&2jsXK|mEv>gAXp?D1%^M-SPG$SfjF0(LkBbhfm4Bi#~<(QSW2j0nY zyvz@e0BP@!17QF{hs2Tg2Z3Da^Cj~;5qiHxGFs3VXU@*YRpt7>-=w^!0L`ue2_HmsDNr=K*PEQPb&Pj?Oo&tN#p!ckKanbFdg;=AST_ zw5$D9=t>6zy3N6t%cVZ~D3b2(54ac20MIlGds*X%T;mUer@0E$A|OjGYLaew2XyE8 zU8my-06_1Sf`y|89hq0{g04P($vYTag7jNyq6|#3=FzA2_qUA18Vu5_XbF^Md|T)d4_GA{ZWEoU<7P_L?F<-<>;4e=Lj)}HuAutzZl>q}om){T#Y zGRNQav>y0Q1N^j8Drkq#VPe1{Bzcifn z-`dFfJbz%09zcH&_;*K{$Nn($mYUEI^QR%r3Yb|`!x6tSFY_FZU*`KCpglDKgudGt zN#@zVAYzg4zk`xP=yev+HK1F`v?yXP@b8!fPYnDH$9c6W(#~3%1{E*(_u?N1Wsd@$ zNs8EYX7N=(7yHBDyA~mIwTrwL(@!t+3KU)1693YpxD5zsUlPpCO4FA4-=3+wV}O2i zu;eUjUM;}O{cMcDIcg~vz(#O5Oapk8*1f{-^MXd}18G83H@NpEBIT9-1tSP(a4wxl7b@m}aL}xE=j@?o!3+b@d93ky!3BRTF8|snEVEkmWK>IZp=GxhoV0 z)(tDnMB~m~DU+T)J$BuQ9}g;KSRKIWa~uuXLgb2MRl@5T+X%%^Pk95JQ^5agIbP2z z-vtue(jR4!o`N#QA+a%)Mu(gG!X+zBUwR>s7DN{#-}>%>rYyb__9WfyHGl_|qUat{ z^On{{LlWLNa3(vR7-cK=wz(S@Mont-055lxcxS75o9{&TC#rUWv)A#oDp~$|@91n@ zgX$~5zmdX1Nob*Zne2nR>lj`oxcqZ)Xx?))IIV9bDl+%8ZD{OV8&j8obA{sxCHr2u z?%XQs!~)ObWLWhBKD0DPM(4S;)PrxK62=3YN<3be8n2_q^g;Z&z!o`Nrx8YHm0Mrs z?Zi?p7cO1}{<`IOG62nOu1a|;6 zfpZYv!eVh_(yKChx)Un`wW}(Dj|+4IHP6z$iR!A6H+s3<)tkqG-Hh-8hfPvvqC3jH zR$YqTMFr9WwB5ktz@K!S`>?ak+VFCoV&lM*``-@YaK~-SV^@PEya%zI&-F9}|Ts zLi`k@FD=oVq}tKa`>6aIg_9~AzZ~|dz#-S~W#8~P@^zD%yhppBKs`WN7S;Wbm$EQBtwh+ZAd99IC9v(-O4mA4Mit4VO@8i+kd9ZiE91a!o~VmFzcF9keL?ZAld zXFvgXwRm-#E}5NWZcM%ViSD&)fK%V`bZ6NIE+Th<`e_NQ0#GLhGZn2yI@H|f)pR(s z0l{Q>mu=mKtsusrO>4CoMFjS0OBEPBx&gUj}kwTh>-pW5RqZL%^_mv_~ zq@Dq}0TYePQR5K*Ash|gMuHhkHG|pk8gw8&Pt5`Lg2i>m)QVs1i#)gdD_ucqGvGH! zd6%(2#K~*L5B5c#-~XZRxYehCze%F-Tf&jW{hq?&H4qgDqo{C*7I=I#*~p8Xu}~ps z9U$jBv{lwFs9&`MBa;D)+ZG5vm8#>m;^yX&)xTqWFKB-tgX1W_BOF=V{Az4rcP8TA z4P;^*6(zNQ>2! zSC(Q$Nb>hzz~v&g{4fBtS~j0psx;*sz>OV6+R_b!?(ia8e{X1%v;*4JF(fO(c=fPl z3;{aQF(fC#*#1&KlgbpJg^nQ^5yp=G2TUr9fv#~3$ww=G6(F)}#GRP4vo78Qyw6g+ zo|D?4#7d4Y0&)zYKN1mB`&8_tF+6MJ%{-VitxlDzfbky=Q<2kZA@ctGcDQ{{)%Afi zx2Wk5h4TJEbcRCd2)L)C=(3zWA88z_FcFUQTxhuk@K{HYl4>QC!^hzih4MJyIgX+$ zO(;hrH=zrlmeqhaJBls|p&XlZv(fS%;7=Vz=Y`+Ijr`bliP7>K;6O!N^*S#?`J@j0s_y~) zZDDCPy6t51^A3><)x4LC+sJ@T)Wo69p^vz%7OEjbXhY^rkjVIp>FFk`vAF9~C-P80 z(Zkh-a9}R(rmn&Xw!<(ChQu|_3S32dlI^)7PX)vwUdq^!*#Y$k)X!xS4VoEurgNtW z&ji$RfG<0Oe5+D6--;{Il4N66bR2c{T7xQ={ir;CCi*-kuK5_P~i^!zlzlH;MBVnq*{m;GZW< zEv*Cos^jSL;eKL~cLM#k7|tQ!UzFxdQ9{}qD2GflmiogHSan#6R=>XBd37Q=O0g5_ zyK6F(?pJI(7!ri0;@1J`>Z=F(@kN?Qdxa|X)TN9T>8w;Y*!m4P8h&|UDHG0?su`>{ zOg5K!CrI~`$WO0kXj7J|8Ky45B}moG1->YW!zYL$qtu#>W&!*Y zi;O2c0_a#A{+Lei9@X+S57!0e4KS6vS%KMwOTt;p-@>&E8l#sRu74(rZL9@A)!T&dZB<~um6{O5@M zmO6@7z@gH5Ae$XJRgJjuE-&)78dd~DMNPgB=wk=B7&7Ws>~Wz6!Je7%z<&V!>ELPV zjc!oBR3_P~8tT0Pj+{JsYE0J;9}~-1&h|4+Rk|IQSuD?}t1Ch5o=g^A-pk+OA_f2( zjzi2rkKrEFsm;`>O-ha|52V2kcdn%!VnKu70j>>UGn^a$({A~n&W``zF#qY@_?!Nb z|LFtI607d_0>sF{fOw~V{GLPP1O4MtrV=>@w_OE(07t{i=_sz^g?1I}tAMJD@TLyy zLM;3dvYpM{`6Ay0n!XKV!f(|Xq#h(*Lryja;*mcBZKo-(Hv-fMKzBGjl7{Sk82Kyk z9Bx<1pzkr@Pgstp;lBfWaGP7;<$(A}37t*tow>Ji`CHZ-6=%Z!Yva(#B)DJSe+sTllDQ1{6-gX%QxQKMQ!UAEKj1^j zVSyMoE*_|&e?uE{N%sMNI7yFi(*0u0)5J?X4}7K5qf1Ww$yxqAm_v)Ncmw!>B#!u# zn*PRihQrr)P9<@~)t}?n$7DeCRD!wHz@hW3(-K!-*Y__lE%zeeZId|S>d*Bzyk$7O zfe$XtnWDtk*Y{t0yL!kQkuyPC~#1X50+|M&| zTyfT8h7wnM>TLGB zWq?&};OCL^H>1i%ppk#nB$UJk!fgPxkHa!jNDVCamB){DtNwt75oW^1*n|@d zGG;~-6#`@G8x_Io$~yyx&Z*{ziB$>wh~-?Vt;WDFA%|s=QC=Fkm{>;OuA`<#y8-W; z#1Rv#9vJeT;oJ^q#83u-bt^3k>H7 z@UN3N(oD|}tQ}>FH~<5yh(lkOzIJJXjRJ=!7|!{?Gf&599GH%!Bt}x5fnVo1tUa%f zm|(NOAO?#O#OL{*UM#qWcVbnT^vP-}o{6X)xg?;5*Q6J}Byg*E_e%myfWK*!{C}qj zrxo%y?U?^*t7l2l+R?WNh!tH*#gW{A`T-gFgPEyBmsFK?*j2EO0Tr%+uZZB#n66*( z@m&JNxYe`|(bR>&FDB<~sebYCeFKmDfVYJZpsohg$EgtY+KKlIq{pz}LKUNd-)T9< z#}5dML{B7eA)vVyPBi!%0#&d+CCRJ<&aH?gr>4#12fEZUDZC5lh=mh<{Gh-in9+)g z-+%|swil}_U54000y9P$&e_1vPvVI2+!7d%-d(bLIq=Tpus}@X663ioaAc<83;{ke zNsn+w1-`%{nHbMB;4_^bU2@U@?+o~tm`1S-`1&M{G{A9zUoa7qhO-y=M@bxMfcFF< z4;s!d!2e0&NCUh#@Cv#I(NhfuSPzH3E}b7~fD;1~HXBYW;JKwa#>d|uxDpH4qNsmq zf){47g*g@pvy(h)?@8Eyg*=RTBfI?z;aSojQm;>hweIoxXr1h_5}6>g*Gsu}7ir?F zbfoln+Jm5jHdxI~qFFb7Oy&v#Fmg8m10#_S9g5?1*ox1@|jKi`j zm*f9>k?B0<04j2@e4R3Kh5vbf18)Gd)xq*n!pN2W+#}dQ2A8Kk0Q5;5mW8>i{EdTg zmzD4-K>v-yGWf>*b&Qf^8KEj#+Sxdy1U$Vu(9xfjXD>F_7$caL+N)$A1jB{$=9wA3%TF=w7z0WcBlpVTvK} znYbfS8;7p{amb_L+~5zv$U``n0l&g=^uo^&&dmn<)uxyUP(R>99f#4pY+0$g$v@KG zOwjHF{_yEI!~BCM%q;DB;42+R4|_$=E&lU(F+*0x-T;2Uaddu!Gs+)?m2BaB3;dMh z=mg8lQPD52K^s9YrvKy?6yZ<z@`h2X9AZyt=NCo%Ya0-Wbh!)q-5Z@s@3 z*xSUV5z%K#CnxK&y1UDK5UL`t_?&-!2If~*o0s+O5;T)7{+$usmj4BkihCjY!n1~S zM!c>5XBd7m$F+c*>(I;}+X3C?_mANVC2jS5(;Yr?_o7&0&ZWV zUCSFfozF#w(xw;M>mzCug5}10J_*Nx{=}$!qB7$ke5}`w;c3@-h!eyi2%f+wM2kx6 zrKs*~1fOpqo!(=L&s?YVZh%=WZ(5Sp)>8C+NW2fXnfrgG(u}zvtxiGkdNIoio2I?ZA?@*&g+~{4|uoDU?cMMWZ=~TPIdC1hs zQOwkJFnr8-{HVCfpjm#7Z-aW#&H zy|bX_G6`*^1|Vd(4b}GzG}Kn{#jyt*B+jV8i_~?cdIG`oEoAO|y~^aTR;|pNaq9tZ zCS?eds~K5`O|bCO>vhWk+|t3UX1cl=l479x0;eBHKKBxw#D^3r63^_d{<7gZcV3u< z(d}=vio449;@#nWP*$HOJk~c0E?i|o#vORC;V@W{Xwxr!L}^r)ky3t;>IFiW@78j&yX2kcCtdP+2xx($;keS5d|%=vcLHI^X-H)+ISST; z|AXl+`CsNY2G)wQOmBv=*9}TxbHMC=R+6@&ztc*ht?+M-32mW#Zb&t0G4&q!0w1s8p_Wq>WkI0H>M~i49^TG@a zGv#h;u;vu%+~x)_zQNI*OIiB4pgclq8UklB`sd8l31&(I3lO--0$z{yYvAVEDe6(1 zaN1=do#ZUV8C&P;Z?EimhoOY|7Va11{Xn&N2_5pVZRj>CtgX<{t#s-q8)W^l*RNPs zY6GZHQL55G)x(d5|HaTMZa4`q=6HcsNcGJAY&(HebeiSIvL>EV7q-JyU#$iqHvAy$ z@@e(>Vr+4yPOZWtqqm;?PKN`x!IT&i(m1n+F6b&u8if4vIB_tT)i-f@t-|vlv zisbx)oEaXK@G#q9G(>M64DlK6Xo&A(1?3!-kT4&Zh=$mHf+0S^6b$j*C+xQXIVy56 z#20RYA->8J6*($$FvRZ`L_^bd6V>NtlE1IzOc~q5h#b3`Of5eLIT-pu(6hQTymL2( z@a>&wD2(nb8oETz+341>nFqpyAtH1|8k&i7FvKmc zk>}eOLK%66j7>83QsyS)L38H5&}bBLrW_1$&*)(2L!6@`M@0^XxK(j9#I2)IQF7*X zztPYU;hz+_coaj}=3&f`gP|`3oj;x-?+Kc52jv!HdDh{Y!zUr5p$G5b`Q}MHGbCu_ z&jh^@!^UXnB{?6$IT#uRW-#=#@F_<{4u-hrZ8XF^h=b<*o1m-jXEm2&73s#e1(V<}pa?%iNP;xY1s(FkC;6+jpUAsa5?d54@C5;Srz$us$L)Eht_Lz=-5rC_MnWsIX` zzN-xvEax|I4u-gt6qMWqLtHQlhPa*(HD?{dn+w6vLlVw&FvJDYVCden$fO(!4M|_Q8|kvhRUCqeSPM; z;K2~ztA*QsetK%pA^caa_SICxj~y1IoROW%f0en7Mqtxa%rNTj!PF=i z+K=-yinYjH5~Vu5a{Dn2ZJyGQn;*_qcX%m{7p8y^TD}&OfF_M7hMq+?mC}@Qdg%S? zkT0NIJv4U_bYDoh&RpDU^-`LRfZVY8LeytUW}`gJ9H6x~4pFbCquY?Qcg0jxN=nP) z$l*{6^D>#Qa%u!~booyJLSu&`iFQ=$g(jYdI9E_k3H^E;;q57hLe1(Rlw9`G)!R{LO2>mxd6?-@x7P#@-+N!$pJs3t3`G$V3~}Sr^JX1G7E-Em z$KAQA;Evn9lxi}OY4GB=P*+2p4+l$rw<;o+?; z48m>%e6yu^t@ypTlv?+_gIkG2?+5arLwj;fJ*9TX?}5xi=wgdxNU9n>=WrPCCP2F! zEMK0-U26`)a9QsG2=m&o!;hR90JHm$hV{osr08>G9z$N2GiB@rDDpTIYShU0LJo%B z6!h2m3_l-dbm$@3vZsF*=i0)ioK zYZ?u4o7tc_pC!uPl{01Rz$Egt#bj#vQOLp2Awm5Y8Gi8+hJ-}^kDSjzOMnAh#WTa< z5+Mgei*_*NA7+Q&5X2Q8VSo;2fD^_rAGy}&HB6cVe~fQ&hPRRPUU8rLOy?X^uT+4W zsd};U>fo5KKJAV+56KJjt*s)}0_#S84gwaaXVt)g1zzA4x*2TNpbA=juP~1VaNO4P6pS!CrRNvFPHRm3z3suXVxGUM5ion-Q?$GM* zjWgTnSi%&iu|Peqj(0@7_KZN~+`85OB_5?)LX>WzJf>RmVgpzeI17iqSW1g}7a!cqXshzY_r& ze7la?3rwi@q8is0Pngd3rxPYod+V6uqLe=$p=)vIylE+(1{bpyE6zvp2G?%TjyS58 z;#AIcV~Wok`#*zJ?oz8$OK~C}?~AE6XMlJ%NUa@_(o&Vj$DG=U*q)-S+J^bGQ<%>m z#}uF0^{)frW*3vvB3O20y=L>iJ&2V-ycf_zj!4N1^NFaK;?q5T3;|0@!!gANd;FIX zx+57G!OPo^(31|~6P!9UV-`3tt0w5>wrt1Kb}0cQ}~RQq=uOFE!%NgU|HB7YX;; zw%|Spbb;eia@++RafJhtY=1Zue;v@b9G8;gE`5<)zWWtZ?{5J2D9~>mmy#Fex8`wy zutoo01cbBQ^+WQ)UkDuB2)H%^E^@He<7_3SUZaXDfcJJBtt^3)ijkW?6!>Vzp#+yJ z^;{la$De|LXB@00ry@K8#AT`xT$QR7@K=Mk%W<_7=f;G)nA{J2{}b?jc3dsRxi1Nq zJNaOLAiq3T(Q4z+mY}6Lce`YE6?#uU3#2xVNC~bPooh^S$9?}A1Pm<&&sR=QOg(~5 z)E@)V&u03|QH5dB|FU35F(MhLjr!IZr4Lrn=Ep9;7m0(v@_k{6C*auHMK zYzI6H0S`Nvl6HgTCh_~p+UJ*>G+mL875Iz{pK&_(n z<_Sn)p~~rj&EPg45ETckikRX@W&Ps_{RxM@HcDQYAMcH+f0;sRE8LR8pGQI<$NV(w~mV z0Z)RRELXG9)pYfPA+8ZGRv+SAzL9?xy7O!tx=gfWmCsl0relQ=DEt!6VQzc0T)hoF z-TauUi~RY05q__W&&;h*SJptrD=YXgDPZ)ml@&R@!2io zY6g(77NJ`m!mB~9d7~&Y%HNCdV-C}j%{9g_7<9%|-Zm)t9i)nF?B!|Gbi|mNo()b- z;F*r2CC3Txf{n%0qPIc33Z&~DQA=?mca(~$;=Uk`1nB`s)KZ){9>gNW{jdCIL81-b z#K)%@C4Orh^V{|{0*3_5hhYAH^<3B)3G zb`-?=Ah|qnAqK#gbOmkWK%Ia9F~v{X_*VlM>{M$hu9~00iK)t1^YF)l^oS#BDNgJT zVv%}h8i+4~pILc(vQ^ zU7%L!9KS3NC?i+Q&@#n`l<`!%{{uLFj?I%E+_`d(srK7ZvXy~1a-0NLJ%z3s<^K~| zSA(JbS?gD=T!8P%PXOqJ>3@sVoH`(m2C-(B7~a3Yuqwly0CUG;e|{poP<>Gi42GAWtCq!$h+C3WSOEWI`;FGf4Ns^Wh+3>fCLJ|2+bJ$Dyl)mj>hpHuZA2 zQ&Aa*M%dJWq_+T47oklZLdgpslBWL`;T!~XaWEw>d{W>I7`FKX5pc7EIjn=;H#qVf zhtSCmq2z_RS`ky9Fsri>u+G5=wQw72A>%7u6$iG1dJHsE6&tLKs@TA)VE9PLFGAMU z5>qd(5Ep2!hxR1Fd0bSsMmrVl%ZIx5h}l!`iNbwUx z{%4?RJ*_ubnU&9P3+Y;Hy+OV}6!xVZESQf-zamnNEA7Qn()v?ZjzmM%(Ol(+>muS} z)fWgXpgG7_xu{xl77#8k)SLTY^M!oBA7}-Rs--x!lJtuF_OL%0q`8hrNoS|r6n>D{ z3-b%eG4? zi|3d+gFn6SR4Jf)IcUy6zy*%OK{JyXM+PZxu{x-SHKH$4J$$QQ*-g$B@S);OaoVUJ5$Gp54?*@AqmD`q%LIByAHUt zI4(3YLu~L2#F_wXx=3{;t5CBtJ+eU05vE=k?UtL`AG%cJTJ5-8v0Reg=oxjwXGx93%Toh+yR4(6;|hyNe- zClb`3NKk)*(W!pUA(*Lc#=JS}huuN7+=T|jfF(Hn5MtbL5i`8S8M;#bcW^TBcuu(06g@DrA#J71r4UZ6oNy51$=i=n5HnxF1|sG(R}LV#S1O1ulY*VQ1Be+3ZWD2R_zHSBTRI zXDIPHMQS)18^9Pc1-%ZRtNY&>=#-cN`$ICIe{k5zS7^iC0@~7w)C*Mq(P=VJ*Jj`~ zG8%RM|H?qW#0=OUk^%h#MXt6(T{hIU$DwV3k{90AkWDti8FfAaSo@f&@1X33-vWs7 zF8kU$5O5z39hZ_9J|*z#Hh`ZX7XO{Tvl!gLsY8 zX~$1k+gohLOjsghSDp{fEsjSC!#wHfuONIM0_Hl{_VmnJ{DX-_svUd!S3$E`vof=m z*t_4$-u+z=zjHcm?_Mfvb?Gwx0;h6UTP*C#wffZS8R~^ANe6KiRi2N4PL7(Oa;ja? z9^|D?CBq9}Akp@`fM^2{aKDR|umD;)l?$LN#Nnq_P9?_+UoH`UM3?VBg@9*WMEWe$ zW&i#_Rv~ngLnwLSWldPs7xe{v2mvQ>)SM5m$_FsCjWH)w73S)|&y!X#W=w%M!te)jl;FY^A{*C)0#gEAQ!$322v%$*j+4=Q&hO=k?2r^cW zW!0$-Qyz~KP7>0lN?g1e5XznRj%z^iq$SI<0{l%CcpEmKz_!HRDvzY$n%9aBqjmpx6Atv47d zuLWtCBkC1JM~tbDSYBg+PjVa%<8Vz+762(k=v;?T^1{=bvbH|KqbB|a1eD;A`sHIM zy4o0&@wSi~fgHX?VyvaY&k*_@4owt=F;(MTAb%mWT6c?Z#l+Tc{KMWwieJw5JAh{E z*UGG4elpwEuY6cLe7@B07^d70k%l_`vSJ!jKM@&&(8o$4u6}C($HmUVrTOzfS?p+( z@braT*#efuCIswrFpHp6{a!K}oKJ!O<~YoQt6xcJnYsrHJFMUGJ+S_bLzk15T(yNq zOS0FGg~}|DIyja^er5kC<6v-9?|UxWT_2-t%|SAwkU$J8^efqaC} zFC8LFFL(|K^RObtk9Yd#_QVz2F`N5T=L+@gulNAQbb(i>MVJd!EA$(Ji@Q9~Ca0J> z#1vX1v;z*EwprZa*J1r$2p!}QN?w>>f{iJDgVrB|fEf<9b4K?1@vqJnsh_E-7&PN~ ziml9EKXIP;=n@cjgZR1AY3GThdi`dc>-_{yD9>h^lR~XN^?HWlHa)Ugr0Q`Aral7f z44R8;2>*+9+5zEGatw5%UBjrc9*l)#jNOJ-07mH<8z1~IqwQ}3gxNGOqW&hpL7g5F z;0HBuuzUR^=hsPa45H z2>l6%w#Wn{C^b$a!wZ*)J$|?n(NcTi83Y_UTEY$G%Bj4e?8a&2VD|@!II08@+ajQ+ zi>M{n7lhk3rp3S16~tj6-Q$Q_iW7SX@po!01ZlY=QX^}RgRV5d83CMN0pDXP?;kcG z<`^5SOs72?psw=P8+JnW!u>`6&Tfcw5|OIH`RGffr1ht+oO!j47GF-e8xa?)2|%!% z(gfrj7gbB~YZwgbGQ}?!;8O>FZ}4t)TrI`9{Io%l+DE&XNu>kx3Oqho&8%?ogn?c- zOISaUwIPvZS4*h{YCUhd53?87VBkvJC1I9wf zqU43^OTXWfBZZ9!c*nsUAe2hz1pDDnfdA?^?4jN0NBZGqsu{Xtj(*DZMSK3b}lY}}6w5J?ZOL6L2 zjJp=Aaac=9ALuU!ZM&mtDNcP~hT!k_LMGn_=^IDXQk?h`sx+qfMwI^#NL8=5m(6FG z7OHd3_V8vDL%lHH=_^usG?`Wi5KG}&l{G2yT_mn9_|Tm^(QlL)%Dd zd-^owyA#MFi@iQZ`hi4xLN4TX(US@BM9v@`H~7U*-N^ataRmH@Lsu{7uceIT`g!1l z`=KmwXb#usQA!z^D5did+QK1}7UA|^?YvT4G@-YwK3U$Ul?0-^IjYBT*Y+dXtJmK04V;4_t2F!==?ilN(^x23I zW^*_ft@i*q=rnWD8py@So&P05L;dZg@hPW8>JC1~o5>Uxs)I2+bDAj+?8a2iQs}A% zc2gHaKWyYIXsx>VapdG$;49Qa`G}h>Szn>HqKwTCq&*oOu0IH@Tb(9(^kt8R*cBM^{TdEy{y!A{x9k}&)cB*WZ$;)bA*v4XU2X9aaIgq zY(CY8jt5c&NN@(;M#TpRZ5&1koSF~rE9yAH?<-ax;onvSZ&Gg>#dwZE{)UK3(*DA4 z&8&mmZC1A(+zF7##Yd~uJjh3l?i_^pdBtii!nojGtQJGM8PZm{cl)Z^ zj^EQIrngP~Y@+q4fOs)=DaN0H&B)e%9NJ*VN+M#{`P^>=3`7RKP)j>!rA#G8-dzcs{ z_;j&a>Ui@FZ>yrZEsAASihXaf`UzoL>z9!Bi`Ef{*VkmkL&k%{iq!;!HS?+EV5=l_ zK(XS3HAG)ie0;~oEr(S37dSWY@IYPypW-2HrwXD@Ee!$k7q~zbD?V~d3ibmL+s-%n z$U#1!N1O3;AZXJ*D}{D45uio}9r6{nugXHICte+rk@esLG1757s zP``JBhr)xjNb-}+-mG{heyK?&WRqF5L%k|GKERpZDJWKZApI(-K6IKGtvBvaysuxZ zR=OC^nHVK%jnV%XJ`+e!7Z__2@-VLCcRuj}(!fiD@M$(2x>;(;HOuf4bl2+?TVLHy z*s;ebTw(O6dEWzRb`vu|J=I~S+r_L88RkjU2vT`;2r0DfJ3-O5Z7KHZVUt4#lSbPn zP20Am!Nlax*)}QGwvU?RnxoY@+dcwzX6_7f{8i zsAQP7eQ|kmY1<XJ(%1LJ1%F$d_4!O2+^2=0??rPVFX8N8F zAnj7gJl*Y9(Y~Za<(W^ISvA!0zS`V=8n8m!?_Uvy=p9 z5FJVyZI3i`DozC_!57zAxq|3cb|uTofh>sZMmOCf1{J8D$qfE743 zMKVk)Ix1Y+Ta9$u+c$a6Od+Tv^4u5!YXQ1tE zpJ=AN{R(N9O6F;MyXXvwT%uBpnz%=h-cEaj%_jc^xK8I0dLgRz2o_GLmGZ-Ft&pZ` z#nQ^u3MsZ$cABIXut@FjV<`x_Rw`h?zDuQ>%;reuZ4F%qOtYSYq-)4B_el*k5UXPi z9TF~U=x<1yR1Kri*3esG+r@nKg6>(k_+E z(>0W#TVIK~`1Cd8?NPR!@&g$CaEYcJ0=d=1*^P!a)*ycL1U}lP?lw?*r+`;zBcbPi zOWkLX^MJtLaFdY0N-*BWq5X}PO8c7wK)o>cCNcho9%bP&_#2}x?r;7AQfVX&glb#h z0*${h%(%a~7SobMe={2p{Egw2_BSJ}H5h+mNFD}-_5#@`qfN2%h}ueUHKw9(InOKYxKP5h1FS!-VEm=6Ni{$>Rv<8PAK)|xe!)=aLo z<{sU0_@j)!IUt&8&A&l{ze(b0YrdqqM25dH@ag@H$x%8+w9eo3K~&>!44hCa@=htB;{&lIS9J!)6NoqV=|i~nYT668<=Lj0Ll0p!z`e>Q%{T4 zv4%bpE^FvtNbom?SHWoP>X^6Gur*W&$@rTjwyhz}Wet&QYbeLClY4|>(aak92on5F z5>MAqbqo>k2Y+MWq#B~XF=a-7vj-VZ@HZw7{mpTMSbt+6`Wp|8Um}eae`65wH|rGr z#$hZ!O*FxAzi|faVR#rL!+wVskV4PWvZl3Rn^J-ew;4qmZJ0FUS&XJK zHcX1O;kAa8gXEkIKMsPnPQR8+*=3r;X-!xB*2qdo#(r(GMcH5(S4u6#KEbobC+U*~Z;8~J*+HNm9 zMcoxH}0B!tRbBpsOG8~S9 zlg!yT9FwC}xK1~e>5r(!;TSlfR<0alYlSr9a11R)l0=Ewm0MD5t?V?UqlvY$3ItvD zl^ck|F`3OVnsg2I1EyI^AQ^{anCV!K37i@%R>vATB3#yx-%uQm;n^Ch=9r^^>l%6z zl5sdmY+FN`%Nior)=-XN0_;rHmhDhHL41$dvjVHbMg{0XoOf5z;w`_=7C{{xNw{FbZ z>}#UXO8749Cq{JvGL&-DfV-)d@4^lOdyD!lJI>e!Mr2g6Dv$evL|<2X63}!wV7v`q ztoZ7@hKmy5e870IzF6@sd<~CHfL9T&g{4Zq(Ep(*=gt6Mnap{xO?4fV4@Ka0O{|4m zxCh~fFGlg|E_F2++HR{hrG@`w)ZhZ-?~l7Ia~yEZoDWG`crx2sxaQKr$z|#AK1FuJ z9MM@=f$O+>>E<=jO6xuWX{*`>Oj~rt3xup2Xm=C!Bw#hym!f9_Z4Q#o)P0aPsXm5h zv%kSz=sS-23nZQWWVX$|<}&-_+6H>k=#~X3gxX7}ej)R~OK1aWmrCa8%NYy|e|uG( ziumfZTmWlm3WB%Dt=gN7`X0d5{2g*@_Dwa(gxbc+j?@-LJdBz*%7V6M_!FTe<)+`p zv-UU|--L9u8@3GFK+vh}k?e5XN1ArSmX=E0_;YTU6zhh|o7A=;HP<;-Y{v57z2Vi6 zwqoNH{^n@>PlpU_ZVhvrQPCW%z^P9p!>rj^VCb6N3kkQ24G#t&e={AkRi(YjuL#zai|Y|UgC zG#?k5a?^|nwq_z(wq`8DW&4bEjmOHM3c`>=aKy+N7Q_JX*;fc)DgPT_S-cYJ}4Lp6G z_NW(4zi=_;6NixmeGfZb{J(~sv3Ef2G87;Ev4)S1(br{ZN5&ut+l%sJ(wa7rTJi#N zHwDTh*0uhOlPHZ6HO%D5jVq$K2HBM>eGR01B=)X)4AQ?o7I613fnOelu&Fro0&cdgl=V`9a!4LhsXZXD=-n{w{T5kUY%RfDGkecTmlruVoc^yH` zdVr?Mlm?^5iq+4M-V^CxNV%6WtO9tOAZ=H#UWfHEqbCRLI5kr(oN#@cWYMwBc;5^kW0Q?oFj zs@V%(xE1qI2~uy7_)zZ*NIO+uLYRG8PX@+xbn#~~TUN)I&ds)q8FH0`|_NwN%gr6isEXF(p zZW+f&mISdEhk@PrhAkD1A7+RTuCMkBH`MM#c zS56q}^lZM4M_(jr44>BdyjGl%-TiBxgwsAQOpX`XP|m<~ePqz)LK z9ca#S%qy;x*8HzUy^vbf&M6( zFj_fjvKSv|{)kZwFO*Lk9WZ6J3KyDE@Z>|bW-8~}nz0O<4b;r=2T5bikfv+K(o(4# ze{OO{imjQCO=>3-Yvy?nbj@7cfi=_oOj|P(@LMCFLo!nUb2<571y0>98D`B??`X^W zT1cDJ{G^&`=9pU@^9xA2W|G;qW;B;IL$0lv9!Vu`YbMl*d0@?400}FXNjzOMw*bRm ziP~JIW;nj2kM43g79UJmg&Bmul+o!Av)FG0_P8X(ou+<(v{P|Q%w&F~8+yAh0ci5a zkVxL4xKn0{`q`-G_p-!eqU9r%jfy)`S+Ed=oHF{+N4R#r5#bm*;Jj5a{0&tCnG;G3 zPS6`B#))je+SR#$i&X~B`#UpT?zW|)9#mP7UsvoZOGR6b@kL7n>IihbI>M`}6Xd~N zIDX^~U^db=-59`(<9ENcPj2X*3nQff7SYCp$NG3Sc&Ro zAbu>$7Ioe7&%({C0=7$fvqd?FJ?ELsO(blW^t`KWgVN%hKh1#Oz9Cs2h-dRNqduIru8QCgiCKi zF8=na1-OKrk|7Rtjw4tvz11~|?c*iR*KbAC?7@M`#Rj1z!4C0vz-9a+XtLpNx(wS8 za#<`~I391b*ojBV==G0VOS=~7Y?j62WR_h(CS#{8ASW}N#c2vHE}7!2PE%-gWhmD2 z?m|LusfSHwX@T;$NzF7tc7fzdyfLB26x;zqk0~stypF_0r+?%k*>jPGYvA(8T%!vO zPX63d#7=N@|8wRwbOS35F}^$^UFjwV)HWL4LvB8h5l#wRM3K&pjh&F4$A!o22+!o_ zWs?jVQR)0#id^XYOp*M&dHVe9Q4e05BQd!&@*C2i1^6?znWd2>TpC$uD77&@)bL5O zG-7E#aA{<-p~aU*3QI4INGvRk&=Z!pYAL%ka!8%Z$3x8~$1%wsOncr#NdLYkaN9uk z9Ot$XOK@!;VJQN8U>-{0z8B@Lr7!Scs@#QVoLBLP1aDW|<>G|Vm;<=trzyjrs#tM* zi+PBJ+a2BbHaPnYZn7R8N366t*6pWBEOt4znPZ`g0CUrd&H$LcNB@j6{s{Dr^Q)tD<`4kmCFGdc%p zPex#|dK~B4dGryTlSt*J6svv?<;X5kMOMCU8;q-s(V`VhMZo6U&SVlaM$+`C&eB4b zX77BGVn=o9CbLJ8S=V-+20_~@KDLMIORvt~Tymd=-x~QElJ@9l85KET1x|I5N~Cu^ zrx&^Ou6-eGQs)|;&339|zUG)GAZb6G%(i}5bLof4C7a{ze52d8&!p%2EB0n5kW4D| z&Pp4j!49?K@2uc9wZTT1_7=E@DKA!4ZsVqTfkIr!LL7R5P)qg+PcQs$6FjA=E*yi; zei${L@q}vLn~2qSwrxP%m!mUs>KYKY`*;xnc(Vd!>lzS)w<~TVQfM@;0*nUK4yuaL z7P0F~AC~>skfuS}t`@+&EcqnKbJX0YWlRX5SZ&0a`_F7qY|e>9+9t1$sGfCLwE0=Q z`0`INKIem@`da(63}<-f297*w?UOWZpO%)w!o;7Ob&z81bGEs{0;J~b^8^Um3I|@# z(pd#i+vg$t)<{b@A8nsruN><0j#9;`le3r;+Ghb6+CG;;!h0u%XYF&LV^-;JnJpk` z`%GqA`_x?8C%M)>dl=nu`_%Ur`EO>oiY892#E^^0!XO;M%S zV8!T4`2sPu)3B($IuvG9>W)r>G+il{=IYKm4N`2Sylqm-K}xPt`VX*0&#lQ}vH*3Z zWZqzrCm`ucIcQWYpo&uyVT-y_b_Ic9h^+btdQHsHGYWm5qj3Z`*4xyvWgWq5&Dnh`#wmG^GW1( zMx}`CuIeEW(f+7H1sWs`ywUM*!8NT(ihu~YyrQPIw z>-mV?`C02*`PTnd6s7a6+)SX>AR4N7c7ktZ@OH&b3g#J&%>l!=WkNWVil{e zAnky(UEP#G&L??}dVB$W>m2}!)x9`J2Gh6F(_5`1(zmjNiEdPr6VO7SS^58+&-g6Y z>%rKrRwXd@fq_!*8zY4!`l3+2>Wwj&$+%Y&w+xo3+vhPaHT#g5j`Qyz7ONCU7Y<>r zxKBl56uy^x2w|G{79{deOi;H)eTbw=vGHE+9|+Uz?;%|yTAxO|jkW|4lkep&L)c4# zUX_gEyIj|@h*lG>&>>A zY!)D!&YRV{k)^~X$2pMD#Q@aa>~n`)d6V^KyN!yIRB@^&N?d!hyTQ;tY8|9a>I1{G z-Yn#pmkzbeevq^`OJ-Ydrn&TH)AI5zHxWr4#>{-y>ok-FI~2EZDON#La~^ob>QDTh1ZkH_ zR=8PlJDKt(8QT@5;^p0!MaN#8Ultv&K{_U>PC88t`o=6O5XBhqThT{9i z$~EGoP0-?XYDrVmCRlE`H9-s8?7?()N^7JElBP}2(o&3aH_9Q!n&4R`D?N~uGr?XU zXcIgNX_tE3kXjl|+8i5=u&l9=bmwZB6RGah=i){<;#n?ScCPy&ZBnz1Mr)2wJ7%k! ztvTjH(&m`Vw&tk0G)Ho+Ic_q#%bVQVb=E1OndZ0@(k_+E)8_b58Y0EkP-BzQ$;28O34*SnFCk&|8*2!< zRxZ5NB88B2tqeCR^1;IU&*&nwlh`F(){2Mu#3psS;n`Zbz%g$IuHDIWNV-;%*|t_R zm$gE!t(6j^J6MoT`DmCPJ)M!Yq5ELdi*1O2S5vGYh8TN2*y`LoS10huz z$&%+Te`UxV`UF5JRyA<$3?kn4H&He#ZW)*yg-x8B24Z&zoOO&ZAu*A+R9lmq_<+au zzZ_dgqo2TBE>@=kc(80updWhq0vvk4qow%Rgdf`cSaDEM`!dWYjPlOZfIl^F4v_bs zV`ivlB(ktkapR%S46_h5pSI?|z={>O8~Or_Evjw;V;dNi@{1L>EFxN>elu}xhW%(E z3^p<=hRDC?>XjawMi5{`t|P{JmSvg#ru4 zl^2V0ZfR5rQ_wA{J;t4uRp%V;cT}vnl_*j8SEJm`nxoC3dyCqI_!jGdSZQmD6?Z>+ z7P0u&BtJ19IEJMDz@aNbOYw@}<~)ZLi+UE?V{?shZ2pNI@s?&2?GEY5mQAeJ7IScbKH zc$@b`Ir{_Bw70ReawZF|KOn_=n}H@5tB{)O58B*reagd-cBxf{)W&Gip66Z1suQ)I z$1;yn-KlS0NP2{!7l@nGD@L7lJ1>By9n=os+UANhXzYJMS3{akm2lX0@_44mV(H2H~%AmmyO5Y=xbnd$+Vg%Q{n&V0Tlc8rc#b z086(-%Sx{kZ;3mAmZrW}+dl0KUU<^p;$Xb6ByJKK(v6JvLdaNauz>HSai( zn#*Z}OlBprvt4luvXs6#!dOs8rZ@cd>JIf5fMT@`=ZbgISl2;n4{3|y7H5f3f=};I z4PzCh>iU#VO5&2%9G;%b^sCDGjfk z=tgl>XPLNOUEG*G`z+*JyQivF@q8$wfX=bM9#?2zoG7XB?aJHbW}y zo<;!Eto4xez{oNSsqWN6$b6|MtiA&g4{RHC);+bCYvic5&)wENO@O4`Q!?ASC(WgM zBGqnz%E-)=8aw;JWA zbx#(ID?cL2>7Kq9<#bP$Ri|FuJypJk%EuYyr*lshOLk8K5tDIklPTq%N>rgy>E?FQ z88OOE^#R)Kvj(?WmMJWE9Gncjo7M65r=eg9%a8CBtH_ng+X5c$RpIy7kanqLg_{*W z2DHc|V`m_o!fqBF@8Miw0(F!?%7%oeB~KHB<6C}O2&*S9Mv;kuo0`d&DW$^8Jgn%D zO0HF&cYO{6ytm~{&zb|Ty8k8Wq=V{*w6%k(XqY`vLn&v!A`Fh7o&-ZXsH%n$cTkJO zL(@UM3D%pcsbM5LC>uTzx+`~SzmlobK{dPAIw;FXa8OlNkVXeZns!i@R>nb*Vja|F zCKs!ansZRMfS_H^+mLptLPKg}3Pz8gGVZgiA&|6#vdp7Ycd9WmU&=wv0TJ&l71<^L(&c^nQa}E=F<OSWvuW_14#2h|-^INT&sDF?OAfN=+vFn-E0 zU~8s`zsg;nm&&JudTgR~P?i;UP`jiW>7Z7DrN>W}m40sAK^+8IqI#NCPV1m7Xd7hO znsX%!bWrstQ8^uyW#t&_qFxo}z!|IX)Hx0vK}&XwrMI-|0(6mT?^Ws01JXiu7qVNW<8_d|@PDCHHlC5M zmCOFI_^jafF!d3@AIG8fa_71gDu^|%&{F{huMjo(@r3B%#N__Z~3B;O!B6V+0zSi)aCz~=oUOyDKM_0EIow|;Onxgqog z&rczj`|Z}4O5e7}@MPU!Mi2bM&W0VWZ+tFG=d-5dmYTMUCi=#W5`U{I%X?Z-_HS%}m=GPweQ%N*1D|5G z%JbqV^m8|&L(*^VZlGDC8t>Vt0kKV;Sb8iG=o(CAzl_+K!=A} zq1Qu-G|rK$=X>x~I-RwSu_hw?=IP`{A=R2eiT3T!WC^n#np~`7HI%q`0B?5S$XZ5a zMQjrqcMP?(go>CgG*$#@rXnsg>a0DuiZ~9A?uRaUf)&xt5aSiGPgg`;a~Xd_y)LqS zQW1Dy=N_2jWd_#JAp;#nT)kvr@g7nNYm4or^g*iHrYysDE6CzBDJ)(JX}Zg`v{X|t zZpnfa+vVn%+!P`;cd1pMw3j;TDK3!i1E{;%BlxWgq5adgo9%O9j!xlxcC&LN!|XrD zfuZ})wU9Qcp@wH`pqpc!Gutw+grs}gWVY>THJ3dtxwfZmo~iR-i^MKlj}XmVwtgHE zc2-Q{>1FG;L=)4aRliFyNPR+%#X=pz}g{~dTvROf?DxtA$goH-6!rxxdGQe5Za_x$+X>06q_-3P zdWP4=SLzwXn!L?Tb68NyhD95!$zL+p7OG{~#8FsxOX@6C(zMB2S{aik#hU!%=GqHr zulA)_6|;r@Op)9;1gK5^3;fn5-*JI8`9fnSN5$kHl?>D5?*&7f{02yPB0kCF+d1ZW z&st_DNZRC++1BJWmnKiHHTgP8rff}qq-dteKLKf%O6F;k-!GbA@|*vM$?s7wnR4QO zFnf`4YY_Mk%PY*!VP4pMyp}-xy$o@vF;ST2K0~a8j>Bq$#dR-ZaeGyI1J7%}&Gj$a zO7}0vjG{uYQnt09CnTXU}WBYuCz0@;Tv9WCfs0*P#e(OTm4oOer zN-oTivN}l>r~cT)470KQCS14I5iBPdB#C!0=b1{$sLu`u@e%_*KHDjV^Yza~o9X+Oe#J+8HD? z)(&aL(CS>2BYIjJZLaj607sYcMo1;5G}t3CitUkXM(Z@9gUNo?HjX`Y_P-bFOrAICfa@RM=;-EOv(bBfWE4#VE9H%f@6aw^NBGUSBD^gJY363z zD>iPbFXJS*<%dt-PA+F%O5QSAXL)5_-iviOOEF_iMH`EX|r5 zN;yqvtPRpkZ45W+%Jhm8z|pnw79`xwE90ydV1x?)lVdI;3iY~xZP$k({F|zmfi-lr z%&g1eb(*jg8op*5{EzNZETcS<;~y^NZ+9uA=>~6UWg0vww!sfHxyeUr&hUD?ZZCD~ zE@|)pb%QVWhDCZo(!FA~X(jup;#4KcFq`qC!ey_x3(_W)o7CWU?%<`7nN>oqWcG%n z8+1{PF(4{h1*=t2ajgq##l8NY zXU?4WzW2>y{EGem;>XL}cb++OX3m*2XJ*bj7b)D#AHm6hf5lRQOlL#}d`3O1aLeJd zT~~PrQ!pzZQNd)aRvlABNHEvf?x2nlCW28|8^I8wf;q?4R)E?9!7K(qba3y-DVTZ4 z6v0&DyW~8LlnAEQwPp!PY`NJo%0XOI%XMA0f3!BQ~9 zs$ix>I$YNVpIOQj%x+ImFj1Tc<`m@Nuhm@dSd3a?*{JxL>#L0iQ!=NmQpq%;xY%Mv zgd~&mC}ETgVImoYwUG=VDw!5nTlOI#$^7I=?f-_SD48k96v;e*?@ngxR5CXoT0nYU z3rTDlYZ<0wP6k2-!j(uZH+MVSHWux9pIM%X{5C-D^R!APidM-8mXaY>B~#RaWX1y{ z?=e>+g*OT!IFZa^O9_&B*0I>WWPa!RY6TjaHFL{jDw(HHTqL82kYv`_{-9(C6Uiv7 zjbsQ>$^6OH<_!!<=0DG9|L^=PB~yS*k<3(l7s)(^l#H2;t~s?NvE^TuVfObo7E2Q~ z>^Vy2gNS4n1js)iUu4*dl#H1uS|uY`N`_dKOhKf_b#Id*Xx7Y@)hd~K6c@=TA|#n$$aE$+sJO!osN+k zwErJR>H(8|s7hvs=QU?8QX-k1Tyu(m%GiR7D$vW6%6kevKoNe7boouy34tV9ZtRS}#>=37e%k~zEs$;kb+D_r3LtQUV- zGhap%!WU-m^#V^5UUj&1Coc8dA96U*m{(w_>}x+st!|CV`c%*nSt}|e>w_(fqmVEN zn}-7zJ8HW*YJn`z2S&!yI;2|7?;J4Vs|ru*Iw_T`ncW^&o<0e9QdEei6#-9#Ii4;Y zRA9O38|7)|7nP@(NVS?@J79_@>#+$>nwjG1Hvvz-Kym3OMTK}e-on^VggKrTb;Q#h z0Z-n)$kX3C<4H49JPll{{j@iV3r~s)@$`1U6Jd_0`#R!jJTM}=YmsU-Pj$wVW~TIM zWx&(&fG0(TcskF**iVExo}PDA?G}~YtH20PIWLi?58LPI8S}wG1-9&mAn#miw>5CN zTh8Dqww%A^)$E+OspW?M;+Zo4wj)m+mp`2Mq<^tz7UYKdl^{O?LR}>Erex5T_}~Sf^zWl%$4sLLuI9?8azL8dzzfv^L6`Kbu8(Y06)^&0LcQK?O=IJzt*u!=^ z49eM!Sk;Bi)6kb`p3ZSNsX^IJnJ2klTT$y!U)I^rJk9!ezxHO(ko&b2(K`n_o>yj! zT&E*o>?=9~6rv^{R;d>jrsCZZCNq`7;*Rs+7>W>`sV;VG7oobqx?Kf;XyfpWoT*xn zDL%yc_%1nbA|*3bku&crNMcL2WtcP7Zm$x{nd(HOmYXvoGu3mJXChYy$hVM^nJS9b znM$ynsfg8?YLSz%4nXxGwt0;_aHh&dYL$uNWTvV?9{yU*d2MDYs3rd71(z#bUu_oA z$U)~7C@Y3ZvqNIJ$#w>f0AV5)g|!h2Au5&|Tva)_A+c-%KsrD1I>l0pOcBe?_%1oy zZc?#a;@Yx^B)0tBsv0|c91tRwMx>UTYa(K)43O^x$X;)#SfXeZi(n}hVpS|H9f)NR zFd~)`q!3yZ!HHO|v6LW|yE+gH43Q2`-m3jRIM?Batm%Ub$ce{sAIHcJ#(t}rve7{9TSw$vHbRw0+M5a$+%nRaihlLH6Op-6oP}}OI!srU}FN7FkTpf zf48e;9Rw45{Hy0Uav3&uFPbZ1V-GvT&bB_r7yZjxCWb}~ev{VbUk+iJUrHb_GdnIn6RmB|RAkw=zU(xp~szloN<^#aF|fdv4#LJ3%xlI2c>zW06PB3jL!u7V(RY{9xFTLE8!(acl@584VCI@V$62z>m`JiL%640w80K#IRM&fm8ODY@kLccyk<>;aww#2*4w zd%xwzTnTBr8L3cQ-E-!T7#gu(9`Y`DK@(Oui#n?ZzTnSXzxhl4enDy744{a}{5RvH zHp7xUhMbp7(u-YA%p33FE*{f!46N<1z9jEZr+dwI!|+zUqnSO3c}G0Yi;VWb^B#W5 zIa64PcSD;87)bq2#qXfGqT5&)iziY1Su+rMup0b1^+!KI-o1v=cON)(k*%oji`Ice zdzYGQeE#tx7U_%B1^;1+V%mb#LuSWGsj`bu7WW6g_D>ehM+V+{!>1J44=EN|ZQh%h zDzb-TF7s!-ZK+IK>MJ0KMT}@6YU(?rz`~Z0{v}Jz837-ZF@g7+M^Hp@n~6h|^*`_o zFZkn=EIeTN{C@LWeBbm_q38_;5|<4B$s+H>XW^&B)J8D8WVqR4uEyt0z~CJghko2- z3XN0#giq~7_Q6`YRL zwqJ0*D?So8D!NMca+K`V!M7k|skt7XQutR$N#XfOEwqLIb41(1xH@>H$pd7i+0TCN zg3nbZTE}`*famv_tJ@>-2|5_hmzu}$xdBzJG|Q1{OXWfHDxRPACGF!WNNFv-T}%3{ zUTQAD^DBW^YGxz#6jJ*4l$nA~y7ncGmkKY|asV>Ae?_$&I1Jb6x{hoCCe~5{wOwjP z;rY*jNTr~3bMf#52j0%njxD&<7Ptg?xnHxu6-YgS6sR-gw89lwN9qekfCmXVJ?#Y<1=IiKLIe+DugGMI2eEs1XNm{056AJp)rXOz3s9ry?P))4c+yKR6Gnw7$s&y5 zuL{$N0)qavg;600a|&^UBiGlF3l!p9U_>F-Ak}J4cEFTEAXbAiA3ChSmi-FkLo!G7 zYZJ73g3DzNc4(UMFYo-PaH-vzy~Osx?Hjcr?*|Q0M3$|@di)pKu3|$7la+(QG8Lv5 zA`zl1hhoRfX4Dom^q8L7&m43&^n^P)-VOAj4jt#hPiUM z%woCg@EB4EPI5Ty|A_%|P%ly?vIHsFb%>&MBr-!4RT?sdlxkW3TGL#lrxI1{Q5k!So)kg1HXgCFj3LiC|h>YYKqM*m9_4n1UJH zhgf!ZHBt!Cj0k3v<(bGA0_3+yiD05=6^vjh7-Cg0wUG{2!R*tQJWw#>k;3_S1Sf*| z8S?Ol5Y32S>`+3ENakGESG8zp*38#mCuxrTTTxubz9K@B`Md28N`^3zjKbPTh7gs^ zg|4{gY`nLB9zKiQ9x*&Ik_$Nrjg9#SHi64#vU5tPho%P{-lnk*dnR$^OSIOLHDN{0!A%(?u1SgWo+{sDi!cHZ#!1YxT z8k#k;@eP&C{wOYzQA9{G$892vk|9haqp&uTAw(tf8&_KkyHzD~+0NSkt-DY%>yRnN zZ2Mg`XBJW-nQYe_ZzLsCW*Mer7F#U)`%R>ln}HF@>=Yo2b|Y0H8;}yoMA0f4!BR5B zs$^OsJ+6}ZjipSLNIi%-5C@#>}KnCG(u?s~j{mYvzt`k!g;ZJ$F~hC?X`8 zf7@14GK7g_6xK#Egs5a*cD2>ATU9a#?VG>hWEy+4D$=WZoWL0CKpz zge10n^Cl6LOs{OF*xyGXwcKoRIGtwh43KvQ$PGw|WTI%5j9@7lVpTGWB0a8>`Px#Z zWCjeNWTH5c%o)hTU#r=n1Ifra$71K24ImhQSu@Kao$xuw`5?5$JmGNSN33X~ACcwf zR20}!>MZZDT0+sV}t$nqs%L}CZ;Mc-&h z8{Y`NkMg9B({7GR*38S^W^wA@u_!J)DJsO%krqat2y;A5byc>+{AT~)31MGIWVho!%9El(Joy$zo(OY1 z-R-J6)KLrcX%sLbyI&&JYMyAHr)SLjLkn!#29W1SfF~^jA^jBgsYdwa##x~o9oD@M zgi(``I#IxB>5~NabKs`}u!Kxz`RS*yPc&kob$|o&6!y!Yz&tx9@k3sXV9CCH1iF8B z(0#EIvJA_@IGqQs2c9u%TF-D$F1n;~`@2z2x*1KRGa0@r{*g1-n6rUAgPj{HjE;Q4 zSq(jdwF~m)Ch1BfogfCk$2DMmLzNd>^qZLH-3}?>hHr>|vAA-cj;pHL@)Dd2Am z;roLkaJ&)RH6jfUPrKD@aQKU`UL`imKg7|btH&RSAM3>3`=?k<-hSj}YRO;m{2A~k z=JQmC*u%9X>+C-6n|pW6H8s19tLiIU zw@pDigP&y1K~a&AW^3~xp$)c$ln`MeA%(S(5Fsj|g|4b4VF}FzK>B_qQV-xlFZFeL z9;i8EkP@kQBMZp7R{&JTmUliRf>N1nv6RXkNa0lmhf}r}2FP6xQmGUmB~po^RVsp| zRESln6h(SleVuYknNs;VQV7$G;6y5qSxS(~K*wT4DliT@PVV2gK*ysXE#9IR3TJvt`8_MnASm1H>XQ6Uv5+;}IQYi}HK_TEz zu+64z7T{41h;PTioC80~;d!t}>e)4t_~zCCVkb#2^Gfjj8J zBysPZYZbGUGc@^Ld)HNg6XZH}^O7&NP``M;)vX8967qhl2@cVFGGTyMdfkxK~}_5Ia%@@YiSJ8y^$Jz3LL6)|hz?Vf!s~{hmHw z2ikomHvfmE=;!_erNs6qBD7Im{0U*SJ%owvQCN53Aax@!A!>Vm;kf91SZH?G_fS&f zjlheL!jF(4Q)YyBf}CS=)b=cK<9QxQY$>-4)An2lgxL89kXmjYa5%L+y9CGsa}{|k zQeu0eXth0prR^bBZO`ib0^3S;AJz6GEoIuC>yTPyqByZV8!RQ*o>v@;YJ2E*=fFg0^q$3m|=6P7rG0Isma83drHjgB}20PeBG?{UO~0D$_9q$IasYG#V~a!Z^6 z0Nn?Xa|Qq?s&_%^?wEs-+iD(l#P#q$!`^}^XaAa~M@)JX=3JEIT&&|o&;ITHcB}c9 zBdMnj_Axnzj`MP>4_v;o99(X-5On2ot2U5D;mfTa0ZuNr`WUHICW@BJtv+$p=ro>w zxm7=?mt1Z&4k@|ZDq14_aw{pp%dJ?V)qE9g=6SY__`m^6f#+S1sYkA`nhw0!prf41 z*CIc*>qQnp8*~O{GO$_z z_UQEhl{Z4|ks`e@v`3$QPCB$lGl39$bQx01&FhY$+M`M?bT~f9r?`=BRNadri!dW~PWwuiW4;($Cl33J`!ZJ4Cz%yV;bMw-0+VhN@xa75R*k!P;o{vtJ9PF~GFAIuyX@XT^<;3(m9UQz zTys+)Qw*-z=?FTH46f0#wJ3|=n!~*~Q(s#i%LX^QZ1WIs?;#Lrs7F))YYvvq)j2wtZ7La$kj;sYH zHfJf+RzhkP0g*~U>E;f@rkDe(sfo>f(-yG7HRx;!uDJs#P-k$>N3OsUQlEPbc#z%VrJ%sFtg$G4@=yDgC!LjD1kW%>*2QBeE^MTPu@*DZbe3xq-8cwTU9gpI%- z_!=1T2PPiNd8yn1Q?V4*Re#2GbIm*gTv%4a!8O`n<(jF%HJ8}nn&GZ2gKL@<0_)sr zs$6yL1lMSx%~oCy+r~4vrW$-MH4Ls--!rC3?mQV;=r&jCA8za1qjS z?x#cldybV{=Cl(=quKLpAAIJMLpJ2?pdpILLS_5|gOA(xvLS?t&#SOZL8aE+gs9KE z!`K3wy#lob4IK*4MjE>Rshm2zBh=458{Z{oJyNpgS9^qz$N?&2%S)DF`nlVjMlARI zjzDU;Imh9&|E~y;cLvA}NXfc8idH{Yu=I0@RX_J0M_ao@*WF)R%3OC3IGuiO6eoUe z0(tmrHP<>a>gP)2x2{G8j4dF{n}UXB&0LVFl9`X$4$(}>)E zh9Zwf%I%X!&?*_hQZmG1z`;xhKtQ7XfQ!TqL6iWdl7rD2p&khA@$g!rF`(LR2!pceNFuwm>pZS8M+ducc(>AyXuCKE8`& z-b6~QS&M7V5|Y?bXc?wtb~{`9`$VJ=6&R7smzHNDR|d$pkP^v6(JC3iQZmG zT*u5db>xAP$wdn1m=T;vrUrTVLsVb~k`Yh#J?Dk(Mlk-eW_}V#=L(Pz=_o2BoxfNZ zr9&9RLr?ZoN3D%Ja}O}m$KC7c&cxezveumuo-}hmVF^6_tfy+sfhaCKDM|+gBt6E$ z$P;0XryX2XyEtlrMic=fJl$Y<`bkGT#q+WBaG3)Fo}NQx;RExPAhO21>u}<5=^=jV zy=rM;#e@P&Xa9g&#Wvc)uRupysHjk{?`>ghAz`kCb&i_)q(KV@B(;ULNVS?v9WdfV z3Qr4MCO3@umo@X7fTt@_TzFDch^M~?JQ3!2`i-OZ6CsuwhxZ0N#T&@e9i8!{Uhjd9 z3Ou20wVw_`ap6f(A)Y2$82gDZ$J0BmDwSc-Psafxny|?79FrQEba(yL>U})rr#v6gy8iKyd#z@PIVkOJ&tA(<7nP>V8+pm z4GQR8Wh+<^aWv~lcg|R0xH^C>X@?1J#^GXchrKz#s``d+GjM@4SWJ+RMAAIwN-~n> z;ZSLa_cJ#hf=C*!TJAO19ftQS-C}Lycr4cD9p9V7>0UfvX>P|S{7pQ6%(Nm+*Z5Jh zWpsL(p7-FrrM;286uXY77@}Kgwh4-^H+e`uYIeCOQfx6^u^NeoQXmH@sp~;A9_f|X z8+_QD9xBua9P_W|HD=9r)V_0(*>g7QtwHJ(q;R8(Ys{g-+YGi1x2)w*BWd?j*#3(&EuimjmV9^ zjqZF24_Ww8b3-UQXCmHv{HMRv+!18Y3T4k@_U;)=%|&=PZ4OJHgwzX;xpmAw0mP@{ z;px~9mYG?zvnL_@=TB`<-Z|f9o)^+w2@SwBuJWG|c@=ZwL5(?zWOuWXHRL8;_C;R#5 zk^So&PT4OGkZX`H4gC-)VLysi_61A!iB-p9k@KQ=5}gQ|utOs$vk4=RLV#`rC(Stn zdHBPtt7yVT%N8YcJ|5q1CZC4*e8+nB(P-krm8KNW)|l1qDXkl~Z29V1OPgnWE?1rW z*U7I4RAQHO-;r`2U5=|qP>;m0?dZ(l9xQ~vtg~nKO`nq2H?ig+4#%2PadoLFSz_1} zwF32JoxQw2>thVtmCf9I=hlxRvX8ORQTy~Ggu5jf^Jp^o_LM?YYM5cZ08iq@5++`( z!s5bsYJEY7da+|1+fz_oFjLI~KxV2Bk;3`{nc~F`KVNgIk&>~p`S1c;!#a}K($g|b zW&5MWQrTWcYPtEZ!ztS~PBVi2*Vb(~ckyL`tL*MXOWvsEg`TFR745-I#vYy>A#xx-R|RK9d9 z>Z;F41wM)nPR6aR2je>UkX7Q`FuDYrT^0kmTFrEqlXlOE96wy>`h6ohE!H&Hngd3y zJ!=`(6fDCZ^HJg00<;w4*nV=3`;{%g3!j@Vro1P#gNj`EeBaO5$-MBHMQHGP7kS>U zJL{-_75Osi|2ww8R;1NIFFv&OQNIWi{Zd$_1w;0_t3ZhAS9jN=MW`##ufJcS`t{1C zc5XqY=-2)~*PP3cl2KpchRO<(*kUZh)USsvmZSa~r10L9!>NAVy_1gmieIRHU5=FK zR}`)KC0Obgv8rF$k|gt4tIp`qlrJqy&YyFf!`xt~PQcVq*u_SDVq$ zSo6|dR5Bw_TqL82kYp~k{XxkPCX!KD8_5u&lG)wWmUCQ4GQ%&^{vUQZB~yz`k<2`N z7n|?~QX-jb*PKNpvE{dxVM=D#Uul1zfE3=Fib$p?Kt2>8-$Y6z6Gf|J1WU;ftCGp- zKr%gB$O9#lgA{%NC4v*lR3i_6cyFo$$*eXL;dLMA`bte{Y+lZ;l+HBdEwB}xg478M zD1eni+v0m31F!K7WC-|0qzGPVo<^$G&$?h&}lU<$kbZn2@884uV>IYpOWp(>%6 zkV?$4FscM$V2N897dTpNwlaPJj0pAxq*~224wzaj;^f8NR2AW7(r&7t-vr!f;Se|7 zER5U`=D4|`BX0J-Qn{%^s@2@tJ~yka-~YACJeV@XU#z(|4%)=`zZ%8wv%Y^6rT#w= zk68adiU`&K0^u4U3JKN$0^vHK4Mf)h%Tdu*QaHy|UW8H_ zDg3t0Wu$Ogu8S0Au0-jLaAjLiHnwXv_?AfFBd(_F&Pd@g4v~t|+ip*yc<}x!pw^fY zhp>J_C{kFTuLJEq6K~08DGu-+*XRIOL{F;})>b!K;v7G{t7sW6h7d$RFEiIB88uH)#z-W9w|Ht zB_&e$9Hb;tI9eh-QdmkbQkW%L&H89F&vV_xNMZEzDunz=r10;67aR0%r>nKdkL`N9 zMKDtM&flpG`otkpHt0%gglU7`25ODz;f9U1L7_-teZB~^`%E0ZuiBua7pe_XM92o2 zeF&osB1~+M!rIs%LevKJb6l)LZNZA*QUJsTeSp*|bFl-Bb3G&WXxI&kx)>?3M~d`L zpgr2tGEaMSpT*M3yo%Iv)8Z(qJ$lyiPvp^yNR`Msq{JRY(Q1zbOM67D+M|0N?WjHa zwWUmZbRSZyOcW>f=u1lpdU2N{qxQ(DznG&vTxQA~U2Bzq=4f~PFXl*5DRZ>k_6W^U z0Z?L&6qSQMQ*$&OxveJG)e@MaaHOzi>hSAz=T4RdnxmzbIL(owra0m>M=x69qaE?U z95rsFcqLL;GgHKqmN?DPflzcYM~Z3zag7u{7P+lvq9Y!dqfn%<=0(lX^(aYmq(dh# zM|5~w%~VG+Fh_j+jCs{PehK{9p(Ho_jB@^+JfdUtxOvAx87bWJCjzHb*P23yW{yM( zzha&~9btNx;I_O|3Q&>fu{!>l>-_`lm_+_VV0o$e2&ue3uv03=BG}O3SD;hq+ce_Y z0-MWizO-EUHuNr-D=SLP4TkLA883oS8QFx%$X1vy9HrL!gy_ir-0|U^7#i8JKkAr0 z7b*N80y1SZKN95Zcax50b83ODVIE0rd3%3y!ZCUp5Hd!uL29|_>2NxlZw!z-!JQN2 zD5PXGN6|W(1{o|mzlo-(=5x$seod8F9J&Y_38s$W-yQ!By6j^8_cJF z#}@lh5a(_?zh=C$w>@vSJzU~1=5^Ta9U8`MAmQp=q+wuaM6dnLn77t39vZk^F`TM>7_Li(JEtoSvBLzd;SB zkIeA?X&&+9+Q+5g$gIV!NWLDVf4ngXdHkFOkKaqOG zyfEIhDcWN`PKtJ&fVT`SxEE4V%pfJjPHwMQ0>yrV3@LUQQc`RlQY^O0M45ch+=9Fz zi^<7r5MVUF$B7`hGa$DBf}x4jPJdzQTYx(v$yo8rfO^E-4OFY^m$-C`*JDqRdc8}vWP%(5L#qTBtI+>z+dk!m%s zMTzPnc1g2d>#mR-YRgGxd+3!|!he8*SVD#9u!nE*hOLr54q;*m6_)834t6~WQA_x5 z$5Ab+3w)e?ZztRKjZCC)^9?e^6224U9J53%p?_L|tzjccZ29aEwS*S}A@=P7q?ViQ z9ZoIb;sANz9f~{_DY1l6v|2*J(h?G@may)0;X%7Z*I7wRnSRZ6NUbtaocJ{xEG5Y2 zAjhJbLw~{T5Dc$uiJcL0$+~->B$n7fB zQr(|@r*?l0Qg~0)0aN>2ma8@9dM7-Y$lXN?SF=$HGSQT+#769 zv0ttL?bl8HW;`gx-36ZamVNNXukc{1eQ@I6xFNzR;1Jg@MWEV0VQxN@GOk9(Rd{m>7;`qE3C4f9&B6czzax;;o=Ik6c zV>mJ<{GC+CB898bka?f+LU6SenYS)AJ@I_4Mem5zedalEqGT19e>Zkr@SM1%=1ZhL zw5bn}>U$4&*iLbbFg9Nr!inN^_cZ%tuvcL|wd`@C7>YtNQQTxxoG9w<)rlfpOeYE{ z!HGgjaH3#|HKxv0LY=|c5B@n`4uu~w$DuQ4x$GkHP-h;?qj(k~W2sqy&xy;Jx)7;P zY-%=A$1Z08!57D+7w&fmA|#Hm1xEx04-N|M85F!ZTChLE8t_o+dKxLI>rtdw7jz5E zJ!t-o?{)ZozoByxX1rhHQu7d=35BId358pb+6%H(3Qytt0(@U>sz7U=YkF@h5;zPK zN22vh%{9pT7f?&h&ykvPKYOty+>7T)FVYEKZGH}yw&siiOGEX%U(v5^Ki-PGrDh>M zuLYG=CW>n{=eUw|u&sn7m_;PC){J!7a?67j=j9Ms1&3`r646L1u4?^je~DN&*ipu9-6`$|eRifuJtyV5Gv*n(@DyQN0n+MtL?(u5?r)?6EsxisS; zb1$lW$uYc+a=pa7I+Sw#02xcoYxq17yeu{Ak-7n?`>kGvi*)<-QbXH z{dR$uhHjFjoS@%;cCNHk?V`>x;+>LO)b)Irb=pN;IM*%enCljGE;qEOTQYdJiXKsn$eaAleR5LafqN7%e6$P`zm5Z@)|R-|N$#yCN>ki?di=u%nK zZM0Z!yzKI*UDP?8x-zo^(r;N%#)TfU71gi zT4ka*abLi$X=Th?^oEa4vPM6umnxI&`cbjJ}`!%av2z>SvF{}qs4S^2$q9`*i|Nq zYc+ej3Uz2pkmm7rgtN1yrxg{jb&=^aLVLOyq*vOWhB~6ER$EoHi1hOQuDWP1Z{JE9 z?B%6~Jvw1=exdw8i~@3KUz$#L|9-fa?%dDt9KfRI<0yRSU-`k!wMe9Wb0 zFfva9fu*JZsdH@Qeme#7S1dJs0_<)9mWCoqy!%D6?jbcX7K+em6@&a<+lw?7ggM9h zXvgL*j?KUrEVL|gUGqLtt!9b?rW|WGM%J2ME=w%(5ciF9>*GfGVBRpa-%iwauk2EX zH z_nN8Tt|VJ{DL54r-u?WiRD^T!JbNt_fld1@QV-ibkV=Q`Wx2=p&ei@iwgBDRflsgi z_d!mvDZ00}Aa$SJ2Z$ION%7^eWmW*T;IpuJrTMrk~|g^M3RaMNwT+vQIdo?N%nNq z)SC<>*#L}4@)66{?hY7{Bz_Fh^%Z}$XEv%3J*+KtJ%qD&2Ve$OQdDyzjPOHP>|;`P z4W7d8$S^O0#sh|59y7Ni+h5Sq+-lBnpo|GpgChj3KsVr;IlzAbQ}C*pzW}4Xn;Y$$ zae4Pohl6Z)a{zE}p(U@I{0s0PZXe{WC4`$0N*`NC&}2h=0;$#FN(~& z0K*OdQZFEd^(Nm;K4h-~7VvtXjyku+vhgcC9Q6+(KSZj+rrtnmDN;Bk*{gtPZ!hT> zH%zj8z2pR0xM_5+0{rWFGwi45-BRG#-OjT6JSYjfm+VzwAw3*0*4rEhtgt)rS!MTZ zq#V0fxDo|qx3^>WS&JmQxO@er$?hbiTFqk)9%Wa5;0X0TWokj|z%h=+zLv!rlz!N3 z9tw(k7XXBlGy923cQ9Xp#g*n;WVV`~F8idQKd9;yMPHYrLn77>+)@lrS{^Be{~%@6 z2@K3t26nd$j9gE@oeWHIbowX*dtg&QDnF~8%AJ;9>$29dpY}EnfjZVD_!8FgKR8gk zTK`^@RcJI>M2 zO_4)QHsbS`m zaoPjjo~JKz3`TM9!wa+%om4iFFcE)(hE^o&h81t_xoRC%tgMKiLaW zwDiI!j)rbXrR%~mD2ZRJLYo?qy3eo|q9xLMK}xU}SYoaDyn|lY)6HLfRTsJ$g9&4U z9St$KB{xVnL~-bb4TeL)Vx%ATbF_4&oZb&N+BR@ZJdM;U6Gclu9OP(p*S<^}6aTR^ z*bjTZp#2ank=_qdg8je}YfX-$pBfW*htN%;`=jA98*k*b(AH7Jzmt7>XU_za+pz&` zo}0AoO|Z0TTT&NC7fmg&tpTm$W3yVDxE*vHw)sd~){rHP%*SeDj*}9dhQ+R$ zEdR7AQXcI8%mH3lLZg12`N741QGa5tG{vFw;QK3eu7HnLh0y8#kB%=|EQYj`_1=bhh)6@WTWX3oIWL2wVck z>bsB%9{<}EU+Q_g-*Q}x>60-T`^jD)hc-JOXpbWG=F@{A@?+ z0~5bnE>-)`6z^|5??bcZL2NT^His_ry#KOL$J6 z=WUn-9=gRhL&*K8`TZ}0E9dPwcQm3{F09=GuL=s+|5kR&r{-_?K4d(8F)w(w#T-A* z^9Bds&wT47^vZeG0pPJl|HUYX{bqc8^D2`0*WLzCW!|}1l#nL1x&Npvq&_pBzlUyk z-}5T)jcRL4d1t;uf@fKRTxr{9M-t^uPZ1?y4 zUL$+{wC8x(X@4KDXV1~dhu*m)e7DT)@D$Yf4^iFw8oyW1o-AbWHNI^?VK`t}$c?9R zd+dkbKEgYwL77aJ*~XR09N(8^w(V=AM0GFb_S(^X<(KVJfv4kJyb@d zdkD8Xiu1gEGSa$!U*S3reDA0IFupIp{v;^dGp}d<&eLqC?ay8qjD{Q#&Bd4s9%U;0 zAbB)+XFkA2PfBKo?M$MccSuS$hXLhz18pm;K1tI&@6doSdWBseyyS!*>%-jOAv!@H z=7k@o2n=fb7=|SLP>}52=j&^bFy8l&IPs=u@oDeRPKB9hL&}YXKl}YU7yjbLri&sYlY0o;NQ1NV*X} zVCb|43hsG@DQONzAHXKX(zNZ!{lUm?SXUnvCFObJb1XBvq11$!8@+kfJWLE!){gv1 zLD@`pfp+uJQhtw}N#U5FNYCA^;vP%RI6enM@ep+t(C9e{h*Vb|m&&N_HL2&(JB2eR zhcn0bjb;~zvr{CGm&dGF74igmL~RZ~K9O9D^iB$_o$W{5ovwz2G(7L*)KHS1J|%@9 zS=L4KacW9DZ1-tllwwY&reIFCd4Z)#ahnJVg}Qr+Jd~l$no7eQ^TE{M0p!F7Wsne9 zqkPZ=(a7>trKt+1r$1B)&j|BDf-_SO)G}5Ck6?s|IWzS@F=q`%<+Q%+D6u+~!4S8G z7j6OUyv2}4wH6=+vR^aMX|v=$0B8F!`z^eR>eH;9O-J$JJ;IxohDf=I?puD5 zRIJy}LU`>aw&0R>o_pSZ`GG7|7$A~D(tn9lH}9#t}}ajyZ2?=eq;JM7wfm|GuLK%M%NoUfZ_oC4pffp zo8437wa{eR7Sgr2!R3(iMW!bl_urG7pzm%(zB-)Q*0B6RxwX#aAI%W!s@-I1a#)h9 zKk-{YjJ&Q!g4DmDKN&-`A4cb0E=;ahIs>R#KMKHUp;n%4K%W391U ziYjyaX22=G+gv)|z*)a~EPC|s=I8TqN5xJH#=d;;29yWX zB;`okoJZ20aPvA;8En`p#~AlxZFOiJZn(1TCdJj^^0rZHTrRgW6vt+*bxg9<6RFO} zTp;~)jdbsml&I4ocJfoUwIr}kWeVNN02@!MRNePyTy@0$!`PJv8t|<2G5Ybjv`WX@ zZYbEvRlDA{4hv-qC;8_AKhl8$;s2A|!AcC?nY_KAyh4Nc{Y5KwZIFz*e?^|T`d$h% zkD@P!8;9?&q!n|jx6#%v+Rpl3)k3TvEWhTun8BYZ+d||fkV}m`>2OE%4JFEM1oTbi z%r)vQ6y=~uEA%!B<@VhT{risVbqoSZ_FXp&xOI}6(Z%4ur<76CVLOxI_tP+Z@_~KA ze0n|HHyMnY87Tc8JTe#XZsQp9KgC zS1_NuXQ?M&z`(E@g|{!wPz-o3<)w242itPyo>;Ma=Yct6zUs9tJ`F6ahyTr?4fS=0 zR@Ri2RvubWT~^sJt^ClkgAO`$@W2rRa}Q0{<$9e0rdA~DJ4ckyNeV!z*PcCRPUl6Y zmX@70yR>dvTDfqM%8IFn&L}H8bk6XhiJ^lJX{bJ{x@LCuA(a)?4Ra2eQQhFUcQvMw z(K0D)stL-WBb$QM&+WXCVcwKTsuMfpGF5X&{XeaIYQv0l{@HzyRISvbL zl}}65ChG>yq&%mV)>o7z>XUU9)idw}yE~=HnyQMjisW2;_2GmktEQG$m(3hlR?F=t zuRd9skgY0#^LtrMH7GQcCFN0d`Rqh#C3(b#mQZO(R#Xn02|;2LDOp!qU0+(3tf;Bh zM$9selj#){ zso+cNm)sq=p92J)*nIglr zr4{TB)_}gPsNr)W9f#EZikf=R(E`&Os-0G{P*u$=r(kweff7!IYB6}qr&m;C2-VcO zMpidemDgbq1r5ijL95Fe>gq6XNCOXSo6{g6Rs@0pX1g_o0vDF2@;PPYwQg`pXQ2e- zDnm6fyQYqPfex0gkWAZVBq2yBN$uH(Os}b>VSkN;{m;psC?EvUfnR)R|W4^4bJiha|#kR*-& zPmhFuYf7g0<0kk+TKNykY-wr%>hzCC0kXY5q9Y*WWecP<|q@#J47W4Jtt`QuyTqflE$w|IWHHH%R67ylHM|AR^LC#YmEmH~g~H-q{)7|=2QWp6!3%26hk z>CcbF^YP>t=dQ<>hrDI}U9otp|J(DD{`M{Yi}CsX7w429|NQgjBmY~U*z?bu5O2V@ zuP|O>{zd0*0>igK&tm>_un$b{v0FUKRYkU2T2)d6J?;qKbG*!QRLKg36!Ppe?w;K#lE zm>9p{J~Vpq|6tt2{NJF%GyFGU7@00XgRjYeigokvZ)8U-ZC(#a97;v&F&{vT_37u) z49HmD&cFKHB+~zmC1Xst*z|;0Z~rQreh>1YJ)nR;YT5*{k9$;x$34{1-M`;T{$V`w z{Y6l^G>dKxc*=ZtVRW4xvMSyE_b>s(b5Yqpyu~9=LDkoyE&cpYy^rzi$v7B*0?sPw zxOpwMN#Cb=zP~>v9qO$WdoG5Gjfqcp z1MLwH<}=IxvS|}-!&~5Xbjby)Pd*ap3r)Pm4(jwF9v;kY+@sXJ&78{E*%(zZe>>Xd zO#e4+$1bM7^uaqH@ORE#4D_$gOV zJo}e5w|)XP7sOgY=)-g81Ak^}D1Qiz#e?>TvUN+`REdA=v=*8%^P(fUKTYjb*86$S zdOsQPeloiGe}aTUlW(l2e`|BA|EZb3!apZ}te-R8FIt9H{k1XP!ZxORJ|z{%IvjqJ zcs|Rn@=u)*@_djH%%(B_!e$Pr#ThV`9JH83FlaySSgTvVw^oM+?Sx>^?#3~DB-Aj) z3!Sj_k?&CTbimen;D#5cZ4R%K%y%5ZA&9Y@VI#GW>m$es9kCf3#CPTm%mMW#S98;CaNtSYKd**bDjs(2#4J zt!?>zGpr3A597aQ;@O`-x(nz|WcfYg%d8p7@K+i-AgE)#{U_rmAvYpp02dN5EF?6V z${$VR@@~drtBjm69)!6&oHK^+zuE+K3G8Aw|NSP8o-54+fSI=QLVloP$3ewjV6!t~ ztR{|X*6CvAicC(yS2WI_Y+ch9TSMIcgU{8(1Lr0~_1Lum)G(;nYK(K^Y-bDoEYP1f z$*qUp^~|01DGxZ`Rl|SKJLfmEnkne^FjXu;I;|#_1yi5p@4nFfb53iwg&CP_n63Ee z|Gz3e=0~jM|+MB3IpCarXID)5rcD&H4UQ9<+Y@f$&fl`q$4X zfxi8%DL&yXsNX-lc*#+dVmJsGbT6{&X841~ zA5xMHrI^UY>xdG6$0WYo*u1!db?x2F)0wl{x;}qw=Hm1nZ$6f|AN%_!{gP~d-+_ni zo{^!$Yopfpwr4VG`UUImKiHY)rSQyyOAw~FH}fp~7iS(!us32MZ~Wh3yn{n5&&e-c zy_t(KOZ_8blV7wR8GmhD*dgodFYvcr){b2dY_jpMYTg7Qe}u=yhP7e_n{Q_@PUREA z#u@o*yrh4(i7&hXBf7*H8``Oier*1>9QMb%?p~i|UVyx=oV^f^=KJx*+G@ zQTx)}{}gLf3%eAxzB=pUlr16A+7rS=v7Db1&$i>cyZ>LT>21L)+R}GZFa5gbo6rk^ zSqaq_-#JyG^IJ2zYh!9pOw}9T=Xt2u+PTZDxmxZuR z|GidXAutE!{v=x62V`?f9NC9Ga|u@%oDR}f7~f|i?c@KRO1B~;l9Z*Fw$LPO)=K~6 zn>DuElTiMp&0IQfwdp+MGWBs1%Ji3K&}X{2vAvC|V3y-#>Yd{HWfx3_fq;&CeTO|bZpe0T&O+SHMo{2fbtOp1T;Z!`1b zC(iPpYr;bLHZy^V=}06`W=k?A?BuqQ=GnzCp85W5=d|+Q8h&tJ#=n>!BlvLvKl}|w zma?}t<)F+k@Sudydco29bC}lihPzxQUeIk>H~;3Q zIIGL>pT|tkJ+BPxP|2QGhJWdKHjlcMk^1g*0O-O@+S_Z-g|B=D#$={{ zIrkQW5*%+IQ*$!mtHD|Y88Pg)V~6OvCM+=C1%w&QI5&|y*d0(Nrd8D8473n`#iiqmha?IMhnCjY zSInp`teQL#-#uH&@WkY)I9@6*A75NwoE*#(vhfp(>x*0^L#k_%71QS?Dl6)f<<;eN zAePL{Nfeh?f_83w(h^3w%JTYpPzb6TmMBhCmQPO>76BjBk*KbjR&I}vyvmyD8QJy& zC(&eOL?VH6_e2?5HaH=N#qQW^Jo)bmYlVfmIn&DBSz>wN6Dru>9r?hOC zJGdII2jRJS!BG|tpoZ8JFx#BL>^U4h;|#a3s(7&LH>EZe%uOvU9E^j#X@#@A1e#b^ zRhl~0&4)PZli4_W8#yw3mYL6!(SzlA=#bPt9_^k7r=s#Sd-Q=WLlh%_>kw^I+14SO zJ(~YX*AGGzNbb-?aV^fE8xVLf&FaATNnxSqB_`FBot3DqsjMiQTbM^#;=Pw?74@|> z_2uZYNMV&5)@HPhF9NnW5AaUa zi-s;@22my=LsH439?d9ECXS)u3&t}IMcBgsFjisWI_0)YdeUXB9Flq)t+Hk|W`qtb zJmwhiHMx8SXO6n#QxQIH2&ooh+JS`XA)x7X2&9R2jkB+!x1Ei>F3aRQ$5lic!^=u* zOBww{)({ynEm!`@lYa)uKZE6;A=0|~!HLP`wYhoht9lrc(zD9#>;R$H4=t^&fgjI|fS2e8|fgTO@Xpf6X znVYDeTQ#+&lFVDI&W^b`71gsCwFRqNR_SC@9}-3zDGr`ink)q{Syel|qOx3t%|NyC zErje8A`Gf_2JKL_hrXJI=ZMx(E^>!NY<}+W(%A?l!W;{yq(ayt zQz?5^SySg#p|=y#SXcdU4fKMdb?DhdhHuK@u=b!3ykP2r9oEsNP2Xzn*>Lng7md`A z1VoD=JJ!lKq(1GqPU#Zu+~2{hL(i?=x_1eL&(X?Kk)+X_e9|O|Ir@l->S>8;#AtG2 zp;7B#ZtSq%+n7?gsu5Yxd1dcRg*BQ`(o&bI%`D`+loLxU8$?;dV@1so zMr!UL#CT0hOs}Y`PbO-n%ji}0QUy%+2D)sK207o+4ZhsmP@EK;q~b*GkRX@}#$;A` zWnoUCeU33*I&F3xLI~Ay$}KEBJO^FWgs{fW+54da8O#m|{F372Ak>Hs=#sic1sob| zgCJ|2tm(mbs#IO8tc`}X?{L9EO`KIex3CCm4i`g>3fC;-F#w!P(B5i>E22adVm+%G zs#rYX!9vZftC^jEF*~{;Sw6=)y!rbFYaG1P9ddUM$ZLS7EG`X$41t#T-`80DA&s)N4oXh z$dS6_3m#2NV97TcUj8wNdSoL)7WIcu$Z3nxBB=C_Ybc?*M<)Sd9uSgxzQeZy2Nq(+>>R(p3rUc+|~h;U8^Q zk&#69H{X5fq{j>iP%r8krvX6kR?&>2n=Ov!SS`x#Utmayu?_@ zCXw>U;J$Hr1~=L|E8>+^c~DUMhQX<)OIy@)?b7TS*+9VN+|i(3iMKOSn~B&Ivu})~ zlaH*UwAFcNbs{}N9@9dyd`3C;9k8Ca(^g7*^Wf69j~-u9I3&So7p9E*I+GhEiBfoJ z@D3qRU3-?xjD`*yo;FmhI?aGf&k4J$M!yr&7qRof#^Vni5Z}3%3W-?H*mi%tl@Oxx zD@)7J8x7d-sj4dTtU^?l!g=NNUo)N9P6x~X(fo&p6%9W(u2b*8h~`x1V}2;Na_)qM z@1vcC!>dZ?B%Il_I`Lfs?WB2j5*jwG9J5#ryg|2Bjsdq-mXYOEwQeiHt|g*!Xm?Kv zJM%hb1KUs-80PR!Qjp!%?XG(4n{Bn-E_xm`SMIhV*}ug8t*jDcRax&fg?&}qemmv3 z{Rw-30X5YLO$KP2&Cjj2>K|_CAvW73A&UCrxgfa>*bsv056yQJX=GA} zSkqK)MOAGjz8#(5tdg+XFO!Qgqa~OQHsFe|#^i=eT^)Bw60^A8wQhwhcE-w)f;EXe zZ^4m9?jVXXZO<}r)kU&)o~8iXFuT>HgY5`7vsmR~g51F)Ll^D2 zu8NNKPr76dySj_3bMd%@cM^9G#$lUh65e66qcLS{+~(_$z-GPm+igUp52p6I zkqc7wIC<2IHMxhQ5WD=xaE2DtO{GOcEJnJP1}55`Zi315?Er$sP&)T&NV1`}vRqZN zI5B%>McK@$bCWRry5Xsw*N-d>yR(ssEIH6c3t+F^?JVAyAE(@>DOm7)R*|eIfL}^(WPRjzzkVux!I5>N1O-<#& zL41l+xODMrFh=^*AK6(9;!L*MW|OJ{J4){=@T#p>PzQT54t~z@5e1IS2H(Tk%WG$v zq(yLECVac1iPm!q%{}c6mz34%*rVw1EXy5=hN@_9(M6ZAwo>-e($*(3+hHYJUO7z_ zs%m^8_R_-(u`XG|$n1gr3AeYB5`_)ciUu8hj~@Syh_E28={w@Vx;%B*4XE(?k0TQ% zkiI%p$=ah1mr`Bov@ZL&K}eR>E*DHDMlD#?{Af0={awoMJ9DLisJ>eTt3(AmaUh-B z8Jd7+dDH95%g++k?Z9j3c!WiriS`d})np~B66fGh!fHUcH8La7bFxFIo!N?cXR=(l zSZ=%Huu9zh(AaL*d~~w=({XcQs6un}2+YxTgX{lr6fN#Z2NPh3_x9`(*Dvaz1iL+j zwY6Pq`1kkL>hodaUB+ zshLWf6Vj{FZIusy*S2PP;_;{`TK%sKqv3c~N;? z87}7GI11T^h$Ci4o_g^Twvcj^x;VFnY+Ob(Rt>dr{{N2(MRFx}BvaJxI}X6T_79g|?aq zG>$gi;BQrDHsaZhNVtu4=wKvdY!Ji62+8)xcZj+S>0t zx4E9Q+c(y|PwVbH064X%ccDw|YHJoT0Z+%0ayHI?j>c&=Rxv7xA8LeCyOXxTX*|hN zB{$FVjN#AI0jx|cCwA{OupeEUZ6jf>smU4}=vZx}rbuW(8Y7*$Uf8v$z!Bf^bqE0P z#xi7<$2*g;y=*Nh0?;LLgJYd z0jG_+P}E)G(7t|}GsTw%G1hd9>1vXmU;1>^CB2SrYpJ^(jbcL7B`>Gd7?B`2#NIjz zAKJbi*ig-P7R#scq$71AueQN$#fyuet^L0+DN~-zHKJT?T*bWMIHJLIptJ1j5Q)-R zh?OnHb)E>eEHABVv;O{3obyPG(FlnpZGSY3XsC7}uXegj4fVh?&ds3*JFN_HLG^>J zGfSISJ=+DSZq1lCyfYF+bJxo;85FLRy2|*h)Il6}B%LjHVu&u;tsmd!E!Sa)3BZW2 z*J;Y`HGJ<^4jDa%{Txg>)8T;Vv43YPuJ65}5^Nzc5?J)Mi$15?QVhyrZ4PV3!)~Um zXZs3~n};bg{m8^BMJMg64|%U{y0ElUDij_j(-}gUJFKpJMuM+6A>ITpv>@O_^p7h# zTi=gn1v`G-u4-yM_tfbv=vjmGeFyfqOD3eNJJBu(r3l*w#fLkYcTn#Sod<@fEwTYV zc7=l5d0nroeT;-3sH-^{N8mU!I}xu`{?GfS1D$qnU0@zck72<3xkm)A<8a8g8)ld& z&Ho{LZSBuMKZN4J**~PT98Y5urs8qbEo{3(k;|d3!64$v2F~esg}~(Iq_hW}%ishz zk)WIHjFGzSIigxyZT%Cp5i@;tJ>Kb?li$W2kh4~6k2H9&y+eUY8{*3?yWk}q%XPS* zxV?km(o>sc&)E)wz+0y4=^>U8XQX&RhdznRmsP6`fDeVyJBB)S)PtqW@qAaP__#?D zooCnd9oUDi?BlW;pK$r>$7l~rq`A89f<#V1i^Q`(8B@47sacv{S6z4yCq7o zlZMds21Lf!BH*5$heWJ4AdcRiN7$$fjVf@;y*1)~hetMy!peu`wgj5ly@fOJ?kuC) zMZIt)%qF;3Y8cO*$SbTW!#atgJfyFT-#&#sup?vCz{{}9`!JL>;$ zp2zUo{R)qcqu!HZ`!XzJ**fSb(yzTGvE7W)9c|2y2<&MmNSDK0JsRx1q#v$*#|wuP zHzHb7t8DD@z{u6X$U~K^{sl*kU2=#b3qRe%7rj#NBRI5_RRA(O^as0c?YNDbwtd+7 zAr8XcFoGDF)liM0KMn8lADyVHsj-_#ow&oP9hxrn2ljB%Vk6!$JDeYuh^1IsKs?PsfWtYvAN#Xj?v+F+F%c~Q*YmN={&o(rWOaH zWi}QlB;|Ha9KMH--$A@z>Rd+e==$NKLE{*s(*2IpU)lHL>oT3pLtQlXn55I*VQBxF z0bqi;s-w$uiVHbYz_r%!e(p%QSQV#=8fdyTH|c^qPPjAG#(%S3XxBoiUBpSmYx_R& zCO<5aRdhr{9U>89g5lq)yqglcSt*&C1~x*$=7bA2y4 zv%*>j?ysjJO`;JSG^5-)$6_3>-MHxq_Xh=A{YTOgf-*y>PT5WGZI=&WnARS)|uW6jFOgiuwI=gqp4!KZsIvasq z_5|Htn}q0CA*UbP>**>?g!x3v19&RJ->11#?xivNmBDXcQf9H$);lae2HEt`eBNNo+rgswK#GQz- zsk=O^!iJP6vJiDr3LVWcAeBL^wRU3~cY)Q*ZeDn}b`(&<%S9*Jh*p?mF$du@JsTyN zJ2*W^Qx5bJ3H;8d1XiU~=>IZe!>?Eeliv3jCY?_`UELYMMGy8?J@f|NhH3ZSiXXUz z+2#ae>l_FLT^9H&;mNa8AG2fQ*T(e(ok&<14&iY-puK(7ZeLmD30#u)m({tvAVmBP zymc$FTAZjO(q^NRw@Eo2KwY!Hdrqe}pB9@#hd#Ji3*qeH zfVv;a5phc&jMMhQL)zZ>*3Q;W=ymQ+EJJ(SH?nu^G)ld1IzXeLRVzc26RlQ4P-@rw%lhW!=|DdlRUl-4hG zCm>Why|RgixTiMW&^aa1F)UiNtZL-)!p^pt5aWt7T@5(fh+)kHrQJPCLjk#f+tt{E zm3*Lh#>xRSXu2RAhc)YQ0aOWkW!P2ey~>0J$b(yN7RK3uqv%F=dUJW@65zly@ty8n zy>pPE;a>>Rx*IFXKgH=C8}G|~pIj!2WPgAdvLzNn*O`j5?t(b$ik|IaG7JAvoUt$p zP>Byt1JN^uKpIOI7L6x3zqPBE^#t0Cdb9$@)6!d`6qf_fbkpkeLU0F3-mTg$qa?aa}1(LvWplvP9L2|R8YpPKZ?jj8uDo+yR za&=M0ys}HVaKx|y@g@5jUvlBn6uoUnx&GA@8lyB8-omKg$s~Ssawlsf$E|i!+rvra zQAq&ovPdOAYs@AFB&x~rA3wn{$i>s0?gjI^ad#ht8{d||O=7%IKAT!!{7q&r&myT> zrg6?jJ;Gec7=J7PhDWdU+XNauBst6PN9o9e6jENUQ!3h@JOdG zMooxlzPo6gtR6~redXa8wgJSl57(`Z`7kJZ0CD4^%L{72RynOEj#RqGmyHvnS81Ic z8g$Sn!n|q&&X4Wt#=9eIaTfaK{NVjp)qB@k5H+r_4&-4$5=d8rRAHbKw))}UssZO^ z#RlBdN8M5bGkB9VVludCc|YTOHESga$G;5}6d_AtRQC0J$%d?cAW zJ6EDC73a>=ORySU@?BL{zvl#P4V{54;A{8%$~q#o`|Ft2EVj!^4}k`5zdaEU-*iYH zZL*Uz9+DekY*sh)FNQKwrhgD^8!O4MXG1Lfy$bTxFttQE0FvlJT=To{`-QEb4Dvdt zhB1r!a$%6ID;oET#_;uJ?u6OjQr#IoxWpp7Aux6Ehx| zV`Db_UXfZZ6`A|$!-JqIhr82!nFo)j_D?S!hQ9-DR3h%3lAuNnyFaBx)Lk`D_EtF5 zT2fW_i%f4cnYej~`E4-OitnMsKt^LV*-k=w=-n#8=IM-gR}D(-F@-A?zcRhYLMK)NpWM+{mjE$4}0h)%AsQDqyT$LbBj1 z8*3JH7}RPUitNHO9!;E`L~cL~dI>hSxV8>Q=aoKY{E8iH!i4p=%`3GQ3f*Q}C20e8 z6XJ0N3hyC7$@vel(FPlP1>?`!nw!2}=uTDdbEj!JD-WdT+ad@qrMEu0eA-L4iDW4w z6p2)+ndeIsWQ=oN!Gw~KwMjHyRam}3--=7!mam$ap&hFr@`ip_4TRkVxkJ-nOux7X zt0wROhr4)0xFiy|nI7KSX3ES>RAY>pc;B9q3l|XHW}>ElGL^I*2f{`pwfk|PO>V zi6S1Q*?`USlw4|r+gQd83TL6n5QLZ3Bapgy7pjymN=4&byDsVNsvt0vS->-Imn^o5 zP}}JT(BaY}yW+)#Yn%jaa8hqtlZ$IR=jC-z*Kj}zm!1@@&e+V(8bLU!zQ>so}%u{c81KbQ# zC)|k7MAGy*?(lvpVg&?jEAyFR&4$J5A_$Je;=|=0*1S7gxKi_x9O-H{UR3sD11ZhJ z?NTn7!9qJi?970L)vy4UVk2Uk-X01TL2(G_SP;z9M?n!CXHXgy%9{^FP|d^NfY`15 zHI)m&1K~jNb{)d%q_^7#fj;5tbLz`G{WQsnpt{ zCbu)lv8ol2`K%=>Aq~8k1?zBK%5axZV~Jn}0SQ4D;nP<@m>=!-wNKrR_u4carl8GFO!d4dYI3TJxwh$C2VM=t-E8X}t6$ibnv>L@$( z0)L6KZ+&G|<)ra&J5YEZRyoI+n$Lf1FTG?UJ1plzjin5Z148ZE7RHG#vjUb7hH+lDRxg_INM5laFm;=U++m~?5;B#YUVB4A6AY>W z5%{0*c#y{_#e>L7gYhK07-Amo+_Tn$&UNb2ioV!g*;?7As^30~!s-ynEOlbLV`3MI z04Q$6N^7ClTX;0lE;p>vsHh&b(=Zl;JKRD~`I<6Go1Ab&H#a0q5*XQ@dc(<6V&YHY z6-swL+_(A*hyX~9I~T8_vJww)yy5sAp#-ZvIoBGrz7F~S4yat{~kIrE^#Z)&4E$`wlpueSmV zaU8h80|5%Q#J1X}kVL4;O|>R_@xFCY-nRuh21`K9Qb|Su^Gw&t=AMDa5L!W82;4+4 z+``+1weI(p@c!n&MHrQ?Rcw0#?X0@o;ApHUw;&&h zQI)~om~q^oV^*##8We3m4|XgNU;PwDCSD`Y!nkKf82sfm*!AcunZZC8C;TXkca)-x zrl^L`pQxx`d}ny=_A*|(Ro_#?knu>}CsKQKxdJobqDtemr}V5a7YK6S6mR630e#|4 z?j5qZYHbX(y{%ji)1F-h#k;}9rQXigMkbxlv_N$DG%>96d_F&vny zc;Yc?!Tn-AJ|jiQ&ma+#dn=0w_1h4Q8$B1aRcep}b(J8GT^zuS zKxMYGwt<(0+%h-rG{4#(U4;QSNIBHC{#s){1U`MGyfhF`z?!(~7(!{E>7NrO@0DA< ziwnJFF;l^yP1ukgfD=b5;kT8F*SVl!=yEH(2iufiuSALHkqwMs5c@eHqTrJusf4!y zeOq>pg=!%^ZH}pFFk}Em;piX;N2Nm{N@0-wH%vwAt54)Dao3V(l00|>J*$Q6-r**F z8{NC*Nu^G>z=l)2S$NwTkW}%2m^!@iwZeQ@dk(djoFj7H$we#eyjf zjtp_}kwWIubp5kCRgfTveldwEgUY?j@lM@{2#t2R&KW`XJ7x zq?zp(%xBzvxIs+gwtvRoX)t!xL^2R!KpQKS@C|yi{2YFN(IJewmaE34mG9WY&Zw}J z{>?h9NyoHKq0P90pX&=3>_z*O?I>9$(GHqF-sgu8h5}M{#3BnAEqUFUzxFM4_`cb4_ryg^*@tz<{+1OR9VYRi2PPN0@DqJ5xrkf&bYdN^>g=JGYY;VD_{Lv|d+`ebRIQ2D^ z!KwsmW1;tmSdyC6n8|y)&~GFLWUpH2-z|ooN{)D>`$aLl0;fN!*lBz+*2FJWNkx+x zPy4-FGQCW+1w$NFgKfht7?NFy(zi%u4hPb=0f^L=;w7f<9;y%@N zh+yh2wNuxbGsc0Mz|YWroY&GKi`;5;a|mf{(ZkKWBm?APJtCtPa_hBwX zl(|dyHLaOw@~z8@YEU56HoXdp<>J$|pf#srksH$;V@hBd_5s_A56ulv? z6Noh~F6m~M6zNB}s189n%s5rJcSEL0RJ7=Nr{-oJI6Zyp z)wcH<#GS2()i5^#imSnCsB%y(Dr3Cc zSzxzo?x6qO71uJwgB10O)^%lBtkCU>>3?Kyl|9Id*nSkM#EVcR>Mj_&DG23L5+S-T&-LPvlkKOfSsPDFH{!uD zxA5$GMeODWr`f0^_7bWqHuAe^Cx12SjvL)H zvA>0v6~&fVAB%d);aw2Ygq^TgYRfMu>>rz0iE@P~W@b>zo91lJalzW9wH;Z;gt0+uCKKfd) zF_pc}b~i z^TTVK7q-A;VuKmQ6o%)Uu#j_|=E*XO#w$}R6wB_dl%m#VJn-BO2H_1BncSD8(`x1eg_F zSlmT)P|#u!^BorsHv82e-h&4HGTuY6u)d*>*RN-~r)TcNU1jFJHT4l`oRhIG1h};z zwZ?-m7m2wuVpZ=p7(n&#HY~Pq`ECqm5&X$H zi}TZWz81IkjczqS4r6S9r|Cm8rLk2T=dm?O*w0l}kHxFBSU%Pn32MQO-_X@qNsUSY zQxS!nu5>PF!pzn)TH`599w8>rh=mP3QnYXzKO>@5>J)oL2KiAiv4vKiMT9*8njksOT~*3^Bv0i#>vQ-&_%P<`2hee4ShG zd&)K-a?{m1^r=o8L@dWj!4mGVnfX~v^wncB`WY;kgRze|;MRDWfwBLFQCv|%Via?z z&<8Gc3Buo@K32aeVQpqymA`XABAuEuhiUeLN08m@!d-knr9oWDA()Y}eIVZpD0B6b zCkApSN)PvOz|Vwy=EryhaqTf?Ob3GU+N~)bQA3PrupvnjbOL1Gbc~I3Yph!>(Z!f_ z>8?iUl1dQ#G#}f@U5eHISg*XPE6UUJpnLFg>1`~m2Wg*s#gFnLQnndKX{xq4M`=uK zuZP?RJQBElpRb^fSM=_9l>~tQ<7>i6&I7Z77s_ZbdxyBqKva#KDtU^$x zrV^neD?3YO<6@_8C5E%G%b7J$CU}BVTHSWsI*mkqfSu@CY9|U-YvM@Murgw-TTVCN zVKemv>}_m5hR~mpRg8R1HXRi)LrYVd+?0>6#FnfxRd~L*y8#30t&5vB&yD;*`yD!w zihwBSiR)K1frFS-9kyWc;uH=tV!$rJy&&f6Z}qyXz^(I$ttb1izO?r0i}AMwQQ%o< zw@$%CCyszgkjzmeA?vNA0B46H3V^{k;SHjZp3Y9MR!~9U%hV@ z^9%zu7@ue;J)w&!`+?VM7uI^6{&`rL9@^a$Ys{79L-0eA4ix%uUMI#+cKf$bWPOMr zB93OY{>m{2i8Ek>)C1Ile*SLGDOBTbCR9?<#Yg|>gLnThsO_5HB z&TMHN;Ty$g74L{(_ZVvnCA2=Why~I3buPyuhPYp(D(xyyMl50pceWTgxFr`8?7@tE zsj#FbhK8r1VC#wQz1>v=6S3eejq}+WL!$pnNp~gQ%^3gEhQ}^!qi><%^9p@f* zo!3JkW2*yWKY*bI4`pgWAf}8dygbAeZH0rmkgXCwi7h#9m~&{#NoD+QaH@sY_tb6= z!7X>@5Wh;ditf9LJT-muB00bd{LK*5t3mA3l^!1`R$5>6e?t1_Lc)!#Efy5q`)aH2lr z24Jg{pmgnalFDXqcy2&My}rA#+3#3L;TVy(yKn*5_Jz%*74S#9#tmFOvL(`G#GO$w zV3Y2@(@o?mvQgsgH&QJTK2{D9>P^5qmR&rm+LYkjFQYPI#n4Cz#`C@b6*CXQ4CZ^*_6fY*q8 zwY_uNcC5=Tk9<=P&Q?))3F-k`VX&NdY~+GJK*CcVKgfG%@=BsPeYPPicm&G`i(CWX zGkSL6B7}$!Er=P3%2s5u8i)nVne37Xa-{yCGY=Zsm@y(^Hh2jyQxXr!OI#GM$)Pd^ zJy|e%V1!S)>!^f8U3dfmYR5?QAp}gBe_&rfqoKr524#4N2XokN8gNF3H@BVv>~=to zAf-5RxQv{}g0A!;8&xroKQGU?1rKuI-uijU7%EcGh5H3v#e~`32ctBl0YfL3g#BIb zzHt|B`N9C{afu6a-QVOGT7=F!>Wp9jEw%^@$|v7Ob~U@aCT6?fg5k1Nc^U$rF0ap^ z_cL96`@`MBn;ZmRUDy=uF@Ewf?|cqq*R zIc|J33>+y)=p=s^srED&)Tz$u`W7O%oZss2&_py@3YP}a5Ox*{KDnAg!z^O&I|l3E ztuC%DF5#9Sz=Ee}f1FB%WHYB*KHN}6W+Ucg8=^_91oW`Ai)P2>jqe7E;|0=qd5ECy zy?_4Dsh7R%(9xHlc=^Pkn>TiLH&&G3bG5mrSq@2bo|)O$BrJl`P`wKADA>+ zah2G>=7{FtFSZwZk5nmDoKpso;AJ0XdS-mEuWO6GmMfYTEY|SmDRK+*85slTL6|WL zbD?fJmqb>xzJ>rtSf?g!p{PWv&cVUVP|wDOw!^b)n_Cy{{w6b%6Ilz6BykJWA8ln> zc5^9K22{ApDy0UiGGX;i9aLx1T?2l#JSos)#onT<$5j)C%>Qr9v>3MD>c#=P8?$LL9fZEPzOkGmL4Zl`9}EvH3d_)xVeK?!V1Xygn$ zXqNp2GCa2BV*owU-0*;Fb@L>rEWF%- zy9igfv9`IOy8o11nl~_m@ATZJEC;zYue5ekR;u!lBB?dfFexX7BARnVn+-!g;FRF){Iq)Q>oT# z@$7wxIYzp?dW*OXXPLy}Gv}58%*e=dAtrpj+$y_}p@fi_4GS>bxm|q^Oh`*fb|EJ` zOf&)v=HlHvol99jTsKcyS>*=TejZ9g>(QTmAMC?s!ZtvN&V_YTPBa67iHJwEie}>B z7S0+*P4c&hQc5t8aR_2fP^(6o-+C$9*ux1E<*uq_rM>GYhJCpv-X_P>Y~n9BF{ztz z9d2H6AMQNXUGD4CVM?+3N4sZNw)M6k)FO!alF9x}>l? zsG|~OjJ)|c#SUeLPl1Sx5=3rkFyB%rvoSnABAgeVn)Soaom|77tcnWtD%!lumnxKd z>8xpAsy6_2+Z@i3d^~%B#xl>8eXD!dBg{na3R|XYu}MTm?r%E_SuM&7ENZp@Qq~pczwuw7S{!~ReI~ySm)oV@ z+P1=H=HogbvBVXIsDr4nc%tH-snb()Q)lI;hQq(|lH>y7Z&<`vBVIM$X!0;Q-!$G( z;Lsw}t%z&JncBtBjhRgrS~E~P;3=pk2x`n_@41bk-FEVDS{7V=tz0{Jf~~_d^X;{^ zgETX^S&;#_!e01*F-U0hNSEfJ@TuMvxqnpnVe393oq#MJ(@Q`H_d z$1yDjebwmsH&t8*22{kUX*au(& zyXp*(pe!ct#B$HovrDELpf0W0fdNn(+2Yo>nlv(+n%Fg&tzmXdND_~Sv5Bv$;l>gL zjs>(A4#3UyB+gk4xti?dEan$(jbJIZ;RUnR^Rbl~9Ml3=qoD-CN?ST@`hD>WkYXs$+iYr8E__zbq8zL5G`%4xU&JU1!Yx!BACWs3!2hw^)P5sM%^-# z;;$y6co#ueZRl{n9_+oV&iQn9Tlu1(%PL!3>hU>0_^df?597yYS92s&zW zCzUnCnO$v!QUPPqCTjQ6=mjp{!>|p5f{#LHbz39>s##I+#*XNzv02KsHZc|^T4>@H zL~us)M1QkJP6IrqEH(nLa1zy4FsmH{3pYf>39*!h75LdC7=o>NKg@wBWLCCTRi_Q% z2}2ymN5hOqs;%B}S`TD$QQ?9HJ)*?Wr0(e1I3HsrAGAG7MO1-BD}`WD31{VYaRQ31 z>HhuV`z=qNDAy*M8i>c&Rw1dH#?~=|w(uT{z6PR~qlP&=%8LlJ$LVPeMgsw{rkAh_ zvp@@oFuXKnq8sbRw{Qc+8(~CP3yEh&3$9P0*k-jMVk_n3jq^lU@^7~mmAAul2WCb{| zN|6}@mgvx28f}Fxe~QDkVhejn>V0#Aur2tB4is=(TUZXm%-kpFc=m2{FwEnNV^G#? z2CwMi#YXg#SWid_5W~Vbg{Vjrx;Wixi)Zr2Mh9n6hMJA2Y>D!)Zao{J8GHjOa2L_^ zxp`M*=FTVF+_{Q4Wy==`3wqGBfxMhm3x-M9B5%V+cA?i>cyt;U5p4VWaVMW%o0hkM;){#DVXwO}wg=f_D zxLyfgqps3Z_Fm()Vl1WKzv2;`;J3WL(X z0L}LqG`Dv_z=G&Z@inY_L{zNY=P7X4J6#0A!V{{1Pc~%&T_$8YFyX7bSUE#ak6-}5 zA6pn$gex_b-A4D`UC@&%+yl&P5zGsZnXa8f03fB5HNnEt77nDDdrgR4Sbs6sAljyE z*?}UI3Wh-k3abejKqI@`e5PPUTF9ECMJIZxFs>%^ybZ^r2QKQqQhbRvS1!4JH50p7 zKq|f%(K3DuZFWSpqQdKh{@x=qpH;$h-z?*%g+!vP@})C^MY!29x56a9@3bQk6+ zE5eIAB%MMUcqCLFR1VT~!KcxVpCDMO;AL*rxhy=&=E^yExZ+VoVdZ4QpzFY6RK1s5 zlF5AgG`JNM9z?z`^|?19dN&BF8ZvF*(Abpyq?n zTM_{9NpgUS@Z2Mf-o@9bQjKhTjUHv7wfn)?B=PayQ8f34fqv9u3v#AJz4+d_TFm2V z#f{|!Gv+@in^#r9pV0?!ZF>~u#eC%;S>=r1q&shF>kYJb`qyq~V)u1!a~HSH#a%=l zRrY3et>-cK(#Z*2CMIpPGcCrAOPT2+5*_VA^$As_gyVn!!XrjDQ_q%o-R@vZuYPiz zrnAu`?~Wc=SCL^2I$0clIXg8Ci+YPRNI zcnY(Aa9Iet*Ixi%n3_7aVPlo@QD%DMOFG?$qKCss%H**NBXUAM(ANROQkg0c8IEV^ zbg2x^UK(*@?gsw3wapM*!X*AwW1u0U|J2g8qF$L$moC(8NvTMob5nKajN(0bdiH_S zcg;;daR2G4ho(;Z1~{^V2Rp!Mh))BAtEz37KArYEnZ~P|LJ($DHXcP;*N4u+HqK` zwHga$KT0IVf|d8>n+Zj0>VB&}Y^d8~ZL=hvyQbS;Vu`Ij8p33}v>M+q3n$fo%@1HSTvj*!%~!AUHO2quz}DWn5s8Fp+RU zf+bcgF48ImptBJZ~R zbSqX5dfMX66d;PngDt-dEkhEqu#;;CN+9Y(G-^kwM6jk>9`wzHjsy)hjqhFSaL*Uehof8*3FYFq zxv9_z_31|3s=m*g)e?gjgI}b?7gC0WRwLYBx z1;N$6x^qQhBrPu?LI6(cc?&!#VoM2UQqf--Jq%m*s;L}I+*RNVO=8qY(#Cq^1##s7 z18Y$&PC@9R&;O`VQFmzpZ{gafQA*3%$n5wXU0*!x7M6rn`rAR&fR5lrDE3XfYNR)pJT z_Hgw4mfF6BfxaS;_?y)-*V!;NKNI%?q2yv?3r7fwTgy6l+)V6gr|Nyg*BU}25z2*U zpG>5#0y)`@6-sI&@4>$v5B{K9J0<1D&qwi^c6<#9=m1s3ST}kc zp^{LGs+~B6sW0Gc_u~1rrSliJdj4(}Bmuzye0s(Y9-Vzr?u#APl-?cgwq0xXK-vMK zV;(fU3I=DI2r70CEEY1x(0GFsl>Gsj61!#+@vsj=SKnNHc~}(ZJMfnCc>0ys)#lE_Ntk zDh7akn%7CCt(_jK?t9R`5c2{mX*RW|Awpi2 z`8#jtnH=(>%(9xW&R-LdGrNb7hqvFJ8%!E^(pD9ahqy5Bsz%nhnGk?cY+-F0cJ%;m z7+Py3BPQoUtHC%uG3{ zuBTBFfPe`{&5<1nG`UvSZ}Qn0v6w~PTLio1mo2>%IG8!i{-^wq!@h&gTRp_^?>$_Lp3iIhX}Q7^&$ z1yP#A%zAU>VpI&=L8^e>(lci0)w>O1X)ud@sC_KJYh1Pg@{uK#k1Slm;Rma3yryf> zGJz~%#!VC`mqIyfg!&5)*O;Mg};unk2xtf^`8snK>>-TKdWvsy6QE)(DmyR^`bH0kA4g!YX&E%4Fom zq(^n7q95K{y^+koXpfRiagJ#H=%+Pf+Rp)Kxl|93+k7m7ji@jt7E&3pY7oT%5{EW) zX390fAP`C18&ImgMO#e9HTcehb?as8{0A^Qq;LEY3LUyA&TdN~tX33i4s+)0@rKQ8(3eDL{tke7+G!pC8ZaaX| zMMG_|5$>z5lfg*SpoC>!edJpeuP#wSi@+Q?S*PYkiR{6YNE&p^PHVr5fn1Zyqn#qr6`qnd1P(D5=>qO$)H zq;m5klctz8wyYQ_WnpovCu(WYR&2NhNae83z2RUaSNHyDHMsoxDjGxeC!&9S4Wpd- zo$yC9MZ7AqUN=FdvewWGf|r^*=LVcNp^O9BLqTF zae=V7TT{KBy*&xQGb8>oyF76$C%v*4gdOWY0w!7@XjssR+cdgmC7Lcih3o+#DAceR z42L+REM3y*g$?~5@t2q_)Q-;h%zYUA%zbME>?0>8HgGj}HSg5SiS2Wqjw@DGFCEp` zf*UYeO~OIQK;0qAraCaERq;b3C6G|gEd)iz;NrmB=Y`~4CuTtFHDGj3vW>LLBPE%7 z<_HA!(%xoSJQ@`P!x!|H-XfsCe>K&LfV+&n;e9)J3ymdeON8o_KXl z1q`@umsP~2xY|?dm&-7GYj`>AF&NGZ4ePG0;wEDOO1le<*FK-ef`4UghReKz$Erz9 zv8XE02un8|@;~}{a~xddB(9ODA>58Z6_SVTt7PpU{3dLRlzG}_{H37VC!=bQW z?fnNF1(Q>o%cr2e(l?uNfTU4-62|}$egt)@2Gnx0I|i;RNEXT4^O`F<81qXo*-M4t zC`!Ea4B5cre+xVCvr|5+HCE}B6LVW~=Q}E|%~2?YD^5W)AEmt#If|0?8fq0Up#wO` z<^xRqf|Kj>S-7=(+!Dw!EdH0sXdGu64#?Kx3~ZvB&8#v8`&dCUMp6S40eavup2$rY z>(4l3;3#0ivS)$nOx6l+W`jo434O>;zaao>2sd02Sy`lE$UqT0 zVRQY_vY4oL91VLz^(_^NTE?UXG8+vYU%9n}U3G29 z>w!cag|*Hyr?-JHv^w0|YAz}+n4!ZcM>dKYeyH;Btx41*?d;RwvhG^~6W;yZOXS8X z8tsY|nlsZL4D+t#<%bqPnn0HD-U)a~8uJJ$x=CZJsmrdpkroMuH-=L++JQM?wO1-3 zaD{1X&(E-i8E-yxKqy<>ni9DKMpIH8bXMLd7JF^%e^L`Ad$cq?c8cL5D#C}B3_zT( zlx=9Wlt8Q|vC&h%yG=y-EI-co z(}l8#{|TrZxJ!x1dtr806)vVkX63ttuNYsj8Xc$QJQAKwrrHwhQpS=HCzVy`t}&%~to_279cr3i`CsVc*O zZ%H(fg-#AG9y%Whltsp{;yTb2Xo;TW4V$?g3fJTziB$wZ*3{Fr_a1c+rzZFM#Y&wbn&c-CIC<#4&iMt4;g{*VRqS!? z?$GqQ;AuTJ9*i)IoTIO))&LQNZk0m1t+0 z54Ea^$}urfF{Mqi?fj_GonBKUxc>xhx3gXKB!@IwW0PnUNS7(eWT8PPUF`_!K0HBg z@K}3-j|ZffTP?wE2H25%#k2{1TNX(UeOdGmT)aG9j0UG=ViRPT_FzO0Jix#<(g&2Q5Tq7Ru4sWF13|V&fklcH)Lc2mC8ZF@Ue&pG5n@KJ%0|q<&QL_z=`QW| zAkkmn-LNp9DI~TwVj4KmZ08zI^>{XH*jYvn8_ubU=;2!Mq`B4}m-xVS8uA_lpAjp! zl~;>vcdF{K5``&mcFO1D&1h`=$nothdBA1q5kvEV>br2!7;w~PT50SF(5C(UG`IB; z35#cq8{v*cr%wX@7)y#P177JKA6qi`(hbKQjj;2W#0b%I-_Q6`G&1An&8aB0U|#Fv zlB+aEJT5!kx!&3Z2(2GlSl?ZllSt)#m^d!7?jo6^=XzVa+b|l%Z0ZeVr8je- zV+O4-^xRsiMF1#Xdk5%4a7>Hhqa1SBSU)AjV(KsIz@>HCJ*5G}yKwlnBq|aRx}x|s-%FRU4!#S-n|I0&l=v075rLP(0cUzR^-kN^mB=sf z?$FMR(mK070r!my;!cK;g2y47fKT|shBDxKs#k9_7A_f-Wo3PtJau}d0lzNpRqmR@ z9rp@sGhDq8s>&w6%z%_6A!eunzEwf4U)N6P(_I@7G}>sBi(5@BG2nD+rb@|UC!(Zp zMxJO~tyea@BzWwooSMNs#ZFUG-!}1JO;Z2^&L!NRRA>~Lh9H-8G6m{?Q37piT@|M{ z9)qoQbC|T$XAp-nV9(VHkh98>lU}`Kq7qq709DNq^uZ;GJQf~Z(&Zf>uuRYPq}i~0 zMP?8#4?qQT#HgTYb?Gu8U4`eKHIpwfW9j1wH;q@SBsrWLcgAoYcez*<<|>TQBmMTi^>coPwZv4;}{wQZW5bDcN_j&5fQ>}XeR0r-TJ!mirxF)PmT z@&m+vE3mv<#DidKZc&I$PH#Sas~8e4vo@?cL|wy+a@m*L?s#fag^|WqsxLop-AS^uBOQD7E4OT zM<`lyzLd^hGr$$;{f6B1>LRA1f*9g{HN1|i7szF>vAcr%H!P|a2s98q9gaG;3uxDm4k(l?pffe4dBRKbKb z8Ux7HHDG$32f6ibn8G;?O%WtxKsM4?CmTHyGhni zlUrmK(V&)gCi<>8zjgqGSK$7?7n&yb@=(u(%{$^d*70O?j{jCXOST!__ibsLB3}F& zxE}H{=a-d@O7>Vrvq#@w(PT+A+%^1`vpi953p@!p1sYbkenr2E2vAHC|p7C@^ zL?#Qy-*UbK^8#i_!g}gOr6tFx4~@9mdOv0w%oa3`3y2SOzY33MAh3qFDBbeL zVwO2^SOvYf8E%M~fyl%&q5o))!eR`tPX${;3nqDi%V_18_q*>Zs#`_haYbc5INK1d zMXc)5SLMrhlVQm8x%_-x<8(Nb793@k6=7dklMNz0RGkZ@rN@^gg5eS2kcP98zG%yK))Dtur!5W+reC@F% zmCV)P7D5exG~i`x(Vbl9>DgbIf^a!(9ZAA&hk8{*OM?$6pWrlP_E~J-4UL`_OhiCv zb~LJHzXKk5iUy9~qoP%ecq0BfhxDJ_ zO?kUuW%&@4ZQ4zOA{k4SOqo!S$RGKOLi^2tNP3oCw;=?e8U?o1Dr91>`ns#q77x3s zDX5Ze<11DZ`2gUC@OPs*B+V78gkl@jjb3Jp3kHRa(K&?UBAA*{5Xr}Aqv5)OkV zDT<1C%w%s8RX>cnwgo2+MkE;tx+-H1YWKY3pSVu zh_RdoXB{xw!Z8`?mTba8?5E7FlIOd=drY<7*M?K}r6KjQI4L!Oz{F9Nl!>Xm+S~`u zjt$-{9~*BZj{e|6Y%RN&lsCakYU7LkIv&2(`QS0L=n7jW+q4t9>ym44ds*Nqn8GHOnOGaf^$LJ%t#Zc&)R z3)u{foRO~`m=({j25$evMcCDd>C*C)#G~Hd_^PH&9#)n^C5;ZQ&iYJdkx6ukn`mI` z%WOjIWZuGd8^HGPA{wt4_xZBKJxVE3|Kh@S_RL-`kD54AG3b?ZEk%UcE=^aVEZpdt zBodaG_6kQJy{;%P>w!;;9(Wp|Rk!4c;0?iP34wh@_JCM@u562e2doreA-FthkVbH$ zVmpebV&FQv^hoE5A%+Xar5|C&4)(;F(K;hh2^T)BI9qws7{ycq`^~tDIxgYZ4(;Jj zxh%k@OjpT@&lQ2Cr) zZ%3FIpWTPzJL=QpTY5&I$X=W%eTaLUDP=w|^gEZFg!ZRxt2!j!g(|u^AiDcq3VNfgf&&4&> zi4{6vx9CPeX{*ND@|H>*D*omoe9EQIVzzg0a5zVeampu;D#MU%`BsC>1YUG_&Tg0o zLCWB5RlqVgQd2g8%AC~L_}I!N=$rZ^VhuNh)*OPkmaMO=N}zVEOlU3f#kdkisN%0+ zI*h%E{jhZrRtw9MVEwyTWX6}`fHSDN5(VaL8yQZz)il_lG zCu{wSON>#IvXQw%sTzu0N$xJvMI-2~(53C3*nh?cPUEQe-`o{D7c;gRYqmAggHz|R zsx<7)8pB>b=i$Gi)HK@aH&edF#PDWA!dOwWAx}51oZIR>3d`f*tbE6fb`8p&cz(&@ zUEEadCpj)vkHw4X#I7kxQsil}&pZbtjm+^l!WiYgLU8eddHT5x7_m25u@AbKsU^4h z^I@5x@5kF8x=GW~6`5+7p1N^m!)_iK4JFXA`#8%@TV_(^#CPp%ZLBSI`BvW;$Vt01 zNP?c6vNPx)=FG#~x1o?wX3p(2hWXULj7QKgACp(Cd2aUcaJfD6dv@xsd%o%H^xRZO zE;(v(07;GV!b%`j03)JD9zS^?L7^_ecMNN~<|YW(`k8DTPo-_C+FUQCQq@RsrkWZb zvnuwki64=%LKP2)PWOS`9Xw$_ja!4iqLgxB!`{PMQBtT8QbhuG!Ci>T<^aU|dc3%0 z@-eZ_QjV_i@EUoiVo7)LPN~{k`ECE2FyiGK&q3ubpd=J&wOW|$hzsJaL3~1M7ALWI zNZ@j@O0uMc*ng>ZX2g{S}0COE7*i)dx*Y!j@Lz&Ri5VW)H^U!SfdMaGclw+)m6QPc=?*YYIL% z;D)+(4p__9-9)pYs#-@t z{fnU1okvz+aSBbxKzh*{$ASVlhrj9mEO%tY)ib9$6)*>eBFc@7!i2X(x*d(HvAWjl zBTUTJP8V+35<&$5dht9lp2yyDBe(-t)tY_Zl-O1&0nM)(lj>`~6s{sUR|Ps`{(g#; zsllYQ*Q92gI9iqWGxAD>`x+Q}CCU$=C0*O>h~Nq)`Gx%d2|N-OnGv z6r>Oe?DnAL*0Zp@jZYvz?(E7ABz|&=nwykhA(yok`KYn?t=`~EJ$TXe#BDXC7A#1@ zMbwYZi6a%&k`7@!`&g}XJet7nB^ZGZcDV5`i55m`s;0?!3!@BmZDKv zR6A_!?j|0H@4&vTw~Cm>-G$yc{J*jQ%skiaFW`L}&B=bnx=iZ2NB}_4nXn`$#9;ct z-Id;>h@d>z-TzH1G)1ZZAkM5crA;&+B1@l!X7=hz7w0brBjEN(` zpz*92U~m)XnsmQ>xN05Yn(%b$j!9<^$XH;ZQrl^jILb>)5(C29m)RVp^-8Q7lQAiK zPeR(g+r)nA>uKgiQJR;$StVkDis#Kyap0z?r}`5(>1xzlR1+6kdBsjJ=R9UP51kgQ z)ZC+I0;+T3-#ri$iz}*13kFR_FyohrjTcF`NpEDbTM_8CSN~zC9u$qfTbc|G-~_O+ zsR29&aPOl^)IgUj`eT!?$(s$T^ODe8t9V=#7d{*Jh_eeDz?s=I3)`L4SXzyR z*Ae)+gFB(#WfNLnK%0bN61Fw5C^?I(=*C#xrCO=y{fr;0RIXZl#S=%|Kh^yCDNk+$xIOTL3EvnKMyM`aLSVVYz!;bg{vQ>?Lca``6`qAEvvATha zTE%qaVJhF)gs;`2W@l@>Wmd;}khWBK9s-MnxZ)KgZL)sX=k~5t&cx0YH8%7`$mC-7 zJl{2wA66LK2EMjxQ&Wq{145QYtii*ND@xlMj=bXwssPhV?3%p{pw7kE4#|x)6G#?V z#7Kl&Eh)%!EfR^GC)iSoZ9|Y>+}@8?)nU>&+M3bJdvMe61wNSBmyjMYyAGijcyMu3 z_>K=Yt&5%K+;_4g|9!Rpy{D#*^N{ zrw6rEuT*I16In~wb!PI;4*LT9?YIz3{#+<}4U-@6BAa;TJ{l|T*F2{5d3$*W*LN;I zZ!hn{=J|Phc_&&q@8*<4@FM||hw|^P>pax-72&zAGuu?3428{(?Q`2^`8VNjZD^NZJT9+@EYDpVPj7#7>K(t6m9U<}Hl`2C<5i zU?5q@d*;Xg+{g08oy#}gaQS&Ryx{m()u3eEpYgf{((o?-sZDdN`;*PhJ>fq+8LG@P z`CmfOER&!0BBQd*z4`P>9dv<8<;{c2K6@|k0CeivdwCZ|WuLv5ccPW^IcAGrT`y{1n8U6`kN0?U3tCN{iPHdUY;{E7hY2mOmv==1iA zpt6U9!4>-hk*N1qpd9S)xdBpaNoEKHHvO}OLa@a*rInfCw6Su&2w&_UvGF2>s8=db zh>^e`4iJm66`15)*q-5BvbVyXdCKvLAL@$oJ0hzVGDCF5LC7TAFQNl`_{)g7Y@go) zO&{{9Wm5&r zr2;+@4E9)TiIoW6^&Pat48LrGb*Z+%59Y&p+^f99{{jb?{EbjF%jCzr$WWcRx12et z%@$Dod;J48fGSM#>(*_(J8SD%o&F~~dwFwqteoFt^RIQ_tad*9LYq%DwYgnt6Sea; z-{)|C*8gJ9boW9g%+=iWp1j5XYCUF-#Cl9}BwDYj(+_&5SVztP`$5qeZ7W&1I7hhjF1cGn}_j zJ70!Rc^{$q(p9`(sX!eF2fHj%2Ua3{N*$QtmyN*A*07;Q9*9odWrOz|*M?w~_uMb} z9C2L~N%$%8f4|MZE{Yh&9zGg31Ka0j0_Gp{;j^j2X5d$2fr^bC3ur`!K(F;#|ErrcWWrp{UGK?T{I6|#&m4*MnB+)`oBn;?*$4eE z){)S%9~7POR@qcx)AOqUu%3V%N`#87-rz+FRo;FPRQA9YhJ!2iCnsPwp5h*2e}B$F z2oo7H-a%dH9s~5t=WafVD~m@<2GaRK=mO65+EGur08&S;gx* zHS$1o;*J=+=eRZmtGwra$%oH%Q6%A~Z8rnEC}J3U_^9^;3}gG;Oei|$!)H^4&A_k5 z0u>uO7zl*2hzD%?#Xcm(17_G?I3_so`_kIXu%A#nNAc(TS8TorP`y$C#R&(yEVjf- zgwIaEZ0Q<-J(X1~p!nlnX^E{s9}n3CJYBZr#?q zv$kx1<<0Q~Wb?0e;L5wP&?e5ba+}+Gg*Hnkpu_oD|ErrcWWrp{UGK?T{IAwy=18o^ zBu7%*^zZY|KInh3j)a!|py-UZ%BBjNo?iuk^#tTlB2;Ykh7|g|{UWIBfh`ONSL{zt zz-&ClJ;eV0oP*F4kQr|woM~+G;V>>a0keKW?VLP(%A1XS6)vUqN(J&jIJi{Bp|KL- zvlFl_u(Mgk0(l@haYqc^b6gvORo-*I4r_XG@M``k<@ zI_AS?Q-#gIuf_ru8#@>XgtCYSZ2HAMBs&2;!~ViC!GYhG)@FwNgxWcZKi|KKeHBo= zUa5fMgo9lchsH{T&rU#xfnPQPdn&6~K=H@D$~*io(16L`4n?y}{;n7KspYx1%ru{X zUWEYdMZI(_zuk~5~tD7`r!d%T= z@5x*IuWfqI9EtUq@+;6(~m z-hL5O_P`c~gDdtYCtx<7;vQmuf6hVZ3CN7M5Y99<`EVGQoPb$Bp>|FlKIP5Ez6#`_ zUa3GH2nUy{I5buwe0Bo11$H*8SRfBXC+>*BdyZ>Eu*!Sxmwb-6E{Y`lwC!eK7ex$X z4@cYu*%&?zO zJ4f;7`&Y5A0*cow6;PaTu*>4mSc&l23Ft8J%SK>NWfco3-uZevz5YA@3p8Nz--e=D zCeOXZYTF6O+#9?U#~YLDm5TW!veSPWdYEG}{jhE>`D6aUNBr-zI&Xh!caOP$9hy7K zWNc0<=5YLifAGux7u)Hn-MrHOW@T+Z6y$@I?)%!qUy$=-TpbnCaQ?A? zOmfBHJ;G!<{(~+)2T!cN`Uw6mpKcE9>W`5u_BWn2}Scv{;SHj%smk*&NBJGhoX5Vf1~nkzD)TT)Uzxfg$i`? zahUS!*|m{q<$NsKY(5&ckdH@O$Va3tsPN-knw!0xA68bu`^75 zcWC^L*VWMYd;G@=1V7@1T#_PK^)DeM;g|0TeHKI~^)Cw|qhzgz6 zD-}BXN$-p}1FFd+F$PqPNg|7FBj$)L_?AiH3ch8M^KRefNb`#$z>&B0q_?$j_N4v< zAeg*imPNBn{sS*ExS0F1Sdqy)=j>an$lU9_6oY5-jg^Yb?Zk>qUZ_-L?$KD0$$wR; zsDn!W;ds9zjCYR7^uzl3^;ZAjUH%u>5M0lh`#@;!ER$ar=1M9u_g{y(nqxBdTax#` z(_8*w{|jZr;}?J3k^RfMg_rd0i0M#oM8?4lswAVzT~Vnqkd5jQ?DHI2 zcEUD>1C2c@F6JE;5tRMCE8Tm{5D4t1$1jKoo=rZS?mcEWb)j}Xwtwt>u=yfD^-6`k zM>yDJu_aa_e7g6T;g^lT&iW8pv9R}uQJh1$u;utGWo&}mNy^^j>@QvV6YS{-+&t zfiZ8pu*cjVMSN!RKU69*_t{vH$uqtZ)*^HBUJ9IJl0&nK`QWTHAD)%w1GLh7h=1&` zwI*K)Kp;K^fKXZhs5SW_Px$OG7c)$LO(>eZ+moCoFz8IaF4oEi%Z6GH_W9lx=B_|# z*&J(u|IB;jPlVSNfgmPx3A`%IB}zG$>yEGGWi0gbeHZo${h+ka4@wLDpfn%Pi+n;( z#7WLO!7SuGB#b$SQJAZ|ZKWxB>spw%uZ8&liX^Gt2kyM}K2TWi1BLZI3RmWObA_8> zy;7m2C7oca z|N3LG7OpVNy~j%-Bxf>du5h(tbF5up+}`hP{&J;9=6)^q$YgSNE%eCdSi8{U6W-?k z6WX3<@|)*RDpiA6n8{ark%<+U+lUo&GFWeZj?I52^f=4pABUp(Kk?+L(Dp2o_lBbR zS9x+i6wTIws+~22;4eaVulZ7M;7n-fHT8yS3PCnR_<{aRCPQJ{gdeq-OomeLt_|F; zsKcEvK|3JX5FslA+0-^?Qsne(iBnmU-RCfYCLY?$rw)SLLwot;X-xvj>C>9|1ZvIw z09H%w=lCQZ_rF@m%pCzE=9uKjv|hbigqLaR_74Ka%`?eSBWTc}8(#H-+AQ3FS&(u9 zNg%M7^R5fq`zx>d(AdMl;EGd;BPbtFkuhO^w}i#Qt&14~p_7SQAX|JSt<21Z7qW7` zXfO2N*?1A0dZof8a3nCc9gMg7U#v2duX^aD0u2hy<#8zTH5 zYfL6XVcUcswU|tXQtz%2ZuX%xh#7XM)GF^%Yv!G5&Ai(pUCYPW+;PX}kA3am@oW8y zV#nX-%fgjXn#exBCVUB+$jl4F0?skXHPw$f-q>w{pt9Q^4hS;OB&VAMm3dA-2`Ygk z5ZG6F*9C&guQ(b7nVHzs2t#8Jv9V#`ic<-KnvbVQ!Pwt(!(xGgF+(6oBiZ7^X=P@( zVyv8#nlJW`*mx0~dZhwEB^d0n*b*xdJd>(94E(YQ*4eBcERXWx6!zSWdpWjY3*Wd` z*z7m%aRZXVXidUQf{i_QV~v|&$CW+zQQrxF>3>|!KzbkC4j|~Yw(N^Kl+t}mcORyy`^5Kvyp(qEQUvcM@k7zc;T~j`y zo7yHsau;Ds1gUgC;e`Jk2Os##N90G*q4wsrcTxzba31M^33UmDs!8jj_n#T0w0pDt@ zB^!P!R$=nbyaCf?D${A)|vd-v~_0KHMSv>f0fo_mvPLEU9w5g z><9KfYm*xKxrjiM-Ts&HWa+K`~e`N5F# z_KTphhl9Zt`@`8(@2_xRvA<7*$;S!743`;akVdU!p1`4eTMjbzwB*>XTo*G$2R4!~ z&i~;(v(w^1R94OltSfrs)=3a=e}kvH9{3s(Me|ESO&e@bScfmr9jDOt~F;48f+ z4obHTzx)pWQ45**I{~&iCjWU_kC~r}^_YxnfeqUP$=?d!&HsH*@_W#X4|vh9##(tp z{EC1m^vuMj=9pwtMT)`3Sa~=QV$%iUz@~rLhoXCh8TNMr&SD_~9QUuJm6>5Ttenrt z_xVR`ytsAil?p_FV6ewxORPljbYRTz%O+TV-eG0Eg0_tql5Bwn_UF7e#;L{@IJC!> ze=AHS3iBy@ssA|AzKGod-|O8LHUYam;@tz?I0kMu6y;5!D2Jb4ao6s*g@*@~Jsb?K z*dKOAKAs|0vA-)}*?^zS5C~w^A=xf$@i)`T%y8jZIiI_pf5gU%;M6M>w#!Ih5C@2Y zxF6+^vI=)X`9{(76&o(y*Piq__+$SI6l3yle)CCf5u7TMFY+S0uQB(MSdqz>Rx0Lz z<()pOv-`H|_So;AM^Kn#|A;_@ip;V9FBEr=7vcvN5DKf#9AOI8bFlt{cl=rZi_f3z z>@jzJ809>Z1jH&bM<~p5;`Jq{&}%JWc@1NKUX3^(_MYyD!({TuLeVUf@A4u;PUb!x zE9O)C3jgVz@L~VS>-LzN4Ij=k$)04ruiImeJsDo%2NtkvtDg5h=k2o@)cSZ+qxhlF zC`$82yWZ%p`(GRfTYJp>W*E^NlLS%gH8plVd^b-h_&vzQ$NX0|RXC*h6#*FuDmHd7 z5Pl_049GY$YzlFwK7O4XD;(1wq_vshKtt_(-hR%%V)MmwrCzCUu8al;*NqqkLe3;7 z(e_F{fc!(CCa7!vZ6h7!=NEh)>~rQG^HSgmlWcj&e%|CQC7*+^GRGk{5mtWvtr1Fm z&D?iHD4Ar#fO3d#-kJfaq?S!pVXTu{e*89XL_cQcdm@NTvfZIN`G<7~pVu&pbrSuQ zfBa>yKB-uQRb}#LLeXoP{8=wDv}5i+$BH>7KFfdl!BFKj^{;AzaehTe3fF5^`4^$# zhw2SKl!LAKPn|NDjYPSAWP4xG*Ui(J>E4X;w9&@*aw&s~+ z^HwqM!AkQ{9`|OFZ*kNVzAYR;r?PMLKEh8w;Xi62Gru2zo@0^-q4jd;*u&}Y-8|dp z_dvo=`>$-Oa4PXD0x}X*Z0ukld@M{14gqG^R5)iirvI4MW`+X|wexxVuz$toi>Fe( zQsGn@4Gyjwu?weC4r*QnXo~Zvsn)mnz^oQ?uk%tYJd^CP++5c`NNR!1=bf_Fx!5Uc zG51L9l*z%(t!JGo;m-SHr5&%Vm6*8{yJV7G78`rC-eaArlbDfi<4VdT5xvYg@Wc0b zFJIhw^K))^bEo)(EbIPs7(tDY|ET}era9JqZ*y~XOg!^!a7JVE34ScISUU)fZFSo13aG7?m5>|h}LXqXt# zMrPPlAio^bN7CBNaG;@fK5yUeU$OZjv94Dt5bM$4;JOjJ3Rs?3DN|S0y59$8wU|5W zrC4|-*<-o6S^prZRUp=^^>FMIwV3P1PMI9s-0QPWi}aP1&UvNVmB{KvV3p0e$!VICbFheLU%n(YOX6P#-`eMT{cPOCm43jUZRAi3G4exg* zUt6ij9FGC)Bqnz%6`A|C(Dgi%|D;lpx%bA3OuoNTk-1-t6`A}n<@ z&%}yM{z9c9bH5xbGC3Iu3#Ny;Zw!QGhRIh|Dl$jx6rJ1Z5LyE|57^1ez%<{pj}nOv?^WbV;ek;zX*a*BCm?lX~` zGWn~KoT4IgPexXT$&{)@x_fWscx3MWa6Ha4`RYnV=2l`wCKE~yfJ$`ga*qdlom#b(!wZF+BC`prY9ojkidje!n7IJ z1EtLM;)Z52St3*{0FTlF@F*<+kJ21?UaM#0CN0#u&3~OvYF*xA?o8Oqb4;eq)n|;& zv37xA5GykIhn0%V z{Yk9I}`Dl+#2u_BYdUa833Z^nvDeqlV1F>2<%B%a4ieq*H~ zbEjfOCeytdDaH3CyYliLbN^G=m2*rcXa#_XR{vE*E0i+#Trb7qFqz;VDi-h$r3L&$ zX#xLG+Jt{+91pR-C}Sjkpy;r(DN)8apEty>h-mww-TzR*ro0FHys49efyN$H=AL(0 z6vT5-J%?2dp_w5N5{2%v7#Fe0Z}8dD+RSk3LhXEPtKJ8jF9KArRL~3%4t7~=iIoW7 zaKIj^A;g3EcqnO3PPGF4`|G}Al3E2U&1)4-fzP~-eI z;9zevN$$ofGDijnGs0vt^JtMXPgcf0XO7$qK4+4wj8$Zg+zcu*Nmj-xGDmI(6`3R} zV-=YrH-m~yl9jQF%#oWxMJCD0SViW@&7dNaWM!-(bL3`Fk;w#&FlhxeLTLewP)al+ z+hbiZN6rUbF`3{SJ}17B?Xl09BjX&qzTn^iWY8dN>Icj1+vzScx zQ)GdtoUzZDd(sINR*}hsW&z1d8?Q*SP`9-4BF&;I#QP81m8oE{&zYl+1)npS$T0D_B6IT3b$)^S{2>?b*$HOhfH`@U54jgc$#d&Nj;r?9 zqVDT$m-m>Xc3ik{uka_8ip*UXMAQ#5nQTh5SU9^-T9^@(7Pb&d3uhNf3tI@KJiC$^ zK`9YF!DEyrD6C1&NCN*8#j_Ws1^7`~fFGp=_)%JbAEgEOQCff>r8)e6;kWz$CJ`>z zYdy<<<$VjA|A~Pj=(M@|q_H{P)j&0JxNd&B5vVZL`=SaBKrub2OWV)E2z1N`N|A<5 zEpwD=V1}5aNW&^JN2vz(9+N3b#w|rjg?-K(g%$XmNlGfLB6Ad0pdyo$R9HpkD6Bw5 zCMl_~ip)`1fr?C0QehRDqp$)MnWUt`Dl$i51u8O`kX9gWX(L8LLYag$${fWKXq3t1 zqJc&W2!qnn-i)**K^W96APh?Lok4^-<%k2+Ai3nyq3GFudT`){Eyk~i12$gfVp{1Om77x2fQPO@5Wnmfq!=;naoN z`Pe?@eX#i=K=n!m!2{u7m&KM?iSP{v>{rwfq9%AC(N3<)Z>!_qAwLU}S_Lf4YZdVC z_nxt0dLkJm8$f-qP|Q)d0ZPFnB^y?exo5PTW1t4+O-`GB&;Q!EnWIHBaDqviGh0RG z<^!KNym51K`eAKINVrDhTQTlRYq4;$p!Wichtk4=h=-Kv+fQ$U~qalVl*QB6H*+P?1S85LS^n z@(`%VBpC>+$Q*eHRAe$)bPT4j=qTl)lYy{CnIjK@MwuLjok*|)T@|ncr3LIjX#qP> z+Jqf%k4y#^lIw)sOE)r3M}f%mD=xUr0&}sgu>2DhtDU?D`#gu1oy6vb0gXNCp__MD zJc-%g^Bq<_iJ2h~K?T4juTPl_W;k`Bc0RVh=6$gFB0%*@1tx=Vu*+ggtVH;9Xw2}- zMqvM=n?kW7#NGLLUf>tb+x;(Av_PG{&VM};YXM7{yUk0nd6-O^E1)x*W9{ zvKWB8uox)iVvwn`MwugDhenx92su74tQtxStA^6Ts-d*7YA9`5wPZ0qUOb3U%7Om7 zNI_7_+@~W2VKSj0sK^;f28zEH9HubEuei%H~)bW5}yKl4iI7}&8`Ddrw(_Xhl&WioNDMn&$lg|Me)nYu}F z{bm~&&ly||ZW#0V#1!@gzv4_+=Y2i2)iB99Tx{-OK(IT#Kjpv|FIDXCY>CF)+D`n%!enMUDr)2Y>l$$5nDJbPmNw6KI`OH67B;JISTn=D* z;_@DIWOQ(dFi9@QDl$h#2Njtlmtz%~Bcp?gOp?p7ip-JGK}9B$*#wM**+gk!Hc`si zB=2KgF-P_XT``$VJ3cQ=J4y@Fj?$)S{|=vikPpr|rxZo6&rqX4WcU@=#>T*0Y%8qP z5BgTKig^!KnnTM@VspcQ#vXMm<{cLIC;R)(l=Lt|AV5rhLP-ysd?Y13%y3tQ+WFY7 zcpq%O2vEIJf%Fg#c3EtRl?b1b9%lGuBd|*~gm^F?4>2ksJs-Nf$2CYc3rbIVa|8;j zkJ87zG$B1GQoV59wY{d%{glkm&WC|n*r$Mr`!peDC@l~(lop5? zO7lhk(IPS9*vaSEW?+u24(I`sRDl0jgu}M{M%G zltwW_JP5V(v3XiyKig2*YVoR(<_>@L5!!H|wJ(Xd1;llMv$0$lb8igTT z7VaNZeB7IV!vCU($^YAnfFSRTlz;*URAiFU2CK*%1rDglWO5rri}|wrQIU!eW|9L# zSLR3&8i@nPmkb8Pp+MG9+62&li943i#D3?0!l&s&VFqhLLViW4_Z`D@Wyj_{*ylO4 z?Brmeu}8(=yu%_|v%g7)RneLm0>Sq#+2RL$lC&~2oH)T!2NXFZ+g}Hs%@TTVChc)!3 z5Ixaa6?W6Nxpecp{4d}F5n%2eUW$#(WYS!LTCh3RE*z9>;C->jpQz93JN?)9##-o( zxu1-1F_|=1fQ!wsb^$In@awV157puNp#S>eSPR`T_rFEBm`s{0z{TcRy8ss(NEF0R z*5UfN_xz~}T+DqY!o_6LTmddN$JzzBPI*8+x{?8NusfKe{vIDP$w+=ykvRtQLq#SN zW*se(22y!%pEF1OJus9>o}*Urao^9RA6CkvhR33n=DX}QK19N5wU{HgpNo(`=8z{- z3B??zGMOQi7G|iR#4EJ;WU)n*7FtAUKD*yuhY^TP7_au-tOR3yTM@?Zc38321duk# zD0*jxV<^f8%dc7w>%Wc624*Gi0hm}I0_@~qps`0ie)A5CXEOVHL&|J0Lm-5QezSyV zVw3Oo+0ql78E(%|JD78`L%9a! z9ZI0E`h^|3SKLo*k;d|dIm{JI=aa61VvqYslCBGg$FBcb+$QWd_AvjptgXT};a7xj zUub`}vQ6?H%G-pU91Jw}sA!XSSi~jv_e1G6VTM2e@jtHHgiZcHx=onjGKAVWTD`;j zVDm+Q>Xi!HgmAFSVoR(<_;i~v!!H|w{q7n<)V9e_J4W%L0<0*EDVgJ21;8XGll_E> zT&x7CQTn*|OX#i9d@BD}@A@PDcfXeb*t6ElJJ!OyUoFhL{ny@I(%h?Rc(Ut1a}cmfoR-+bd_E}!s=%)Z-&KK@og54_ zBAD)yd`QKu!~T9dr3%ati2t{}bAj`#s_y+s0wF-u2=bIih!_DO=1oAwe;xxQ5STDC z7;%z+CX-1ROlHP;gapW=f{NARfYwr#POw!eP|byksMy9{ilD^iR^%#L4d|^ryc)y@ zio#uI@AWU+H3D~{;#nz&+*=g#P?^50t03NuuXw) zs0M@w&B=oTH32iw7?cDE^IT0}0B4b{SDU37c(6t~u|UGB7u5dghb^~m8Dex`@(!gI zx*2f-v@twL8IDfH?brJIRUcL=q@@F(#3RN@kUSbKi+cXmR$I5K}bUz%S@%Rk-ueMskb+-#pHQuuak9%6K;Qe{=s zJ*EQ4=#&&lcTNS6(VJ2r-9;5ZMwg^Oy6qJ}MjKKf-Lp>5I>Tt8Qsp-;=>BsBkkLa4 zu!Zh36+lK~=6F349=ca4$;Xk=ds86Y!3rRwn^Pd&N0L$)&kUpQC#A5N?t-MI#6U*p zCdH?j?k6jNjQ&0Ww$S~@3Lv8gQy|@^D}aoCnF8sKPpVXGBclmPIcuT&axFJ=TT+Y$-=QhG-bIW1XBmxT7=VMI>9l-_^n>CKT#N*iaTQOUumk?tW0 zsVRRLXyh<(oUXC`qpPABlZT2{R9hO8ZJUP}b)-w4Zf1cB(29Gp%|$+k!_m>yA&!KH zsIf7PfZ%;hv$mf2QZbQ`_!{v?zE_eK-We7Kd#0x{V%wA_7j!?Und5<+^Vvx~l@Xh% zR8hL@q#nqK%~XJN*-1T+5u2$1>9Ui0AR{(Y0VdsweU)s_tWnvPi}Ic-v$wU839PJk z0!w)i^Y&gWGJzE!fn{-e_JGlXt;J}}xljwCJlxv0xgN%o(h5p8!)y}5_CZNw#i+E2>3~i)~M)%ak@{tvDwK~SxLI0uT zsX!~rTh;kdQ7d=c+)xYY-}NNOjjoV>rljPSHfk+0p)&ah0`B|l!H)lil(bPfC>pc$ ziWSb8Atpy=Nsu_i>y&Bd25ovO?2O$kXq<6k^4oPq&iuHMVvKP zNY>auVYtD>XjD|ju7!ya<-EGG^*JwSSzgexyr5-P5Kq%iQuXpX@ViG1Srk_>Qc&N{ zqh_cKwq9SU7_s|iHsVxVd_QTGA}(cYv5@V#c;;#`kS{BAT)bJ`D;u1;!JkdC7UOCCM2pVc_yT!swQ{V zt?aK;Qj&ED<9R3~Pt@s7O&-TAKT;oNd?@n@8VaX-=_tidJ8Wke`F8&$ZYQn$xR-4s?Bdt zCB?bj@Ki?Jar|N2e30?pMv|Uo=czXDJ=LbZr&g~fO(*MvTLLUws*SFY2<@LGb)tzb z6;(72rgtPar9ir@bPr^7PYR^_sFFO8(NRe~YNC6(l01;nnJJL&Kn0Mv{znR=OMUSY z8U3FWNH;Sl;x*AfA=wd{=uTFWmso8=1hsYZ5OXpmeW)%}MzfSEyFA@jX#Mx>j1E<* z0O_7n0c3Pu3Z%QG0?6p<6iD~;6+lK`N`Z7qFtt&)rOXNz7fG{BP6?G2JT;v~p)#78 zOinZ1%ybKo>CQ}6UTRK5wrkT6qooOBGhJlK>y?TmKMT^C$kqxJQr!Ml9DeasEZq=%7?>d zfv46GV40~V4RD9He*PG7RFq>KT~1{l$mlD{dR<2MiF9F$9!BY5E_dkk5?Kp9y1+e^ z5zAc+vMa;`StM)^p2{daB<7B(9>~#=0E-@?OEDJ`-AqLYB)tu-Bt5bDRT8cijBO(3@}38Zn$-G{H7^HzC-8V zp&1aQ1Z{nLSal#iXiy#$c-ItmpfV^45cbt)Y`eOMion~Z0##Aol+W@cvNF#?WoFn| zJeBo?sh*0;?dd8L34tXgRF)KL!b@OTWY&OS?R*66m#W_NM^x1_F&4`MF&1hd#zGCm zSg3&*3zZmiD3KTol@aF>If&8COojjhlOa?)8HD{x4ZoC{_vw1!kR>F{-m0k)C`fQ| zTJzR2N@X?Etqh{o;MuLUC_zSjrlHX-TdOd*meF@>woEa=2q`@Na}kKVGFzq?5V{0y zeft~Lf%u?7c~GECVFxOMk^o_!D^m>MEHt)HT?ANLncA~yh&&^*GS5N{EFqx=mXJ_U zxjijYLJce-p|XTBD?_M(l_69+AK@}}&3}KH%7ji9bRcv>4TMgpfzSyx5IUg}I_k}f zQhkW#^=b84qRW7LL0RIMJy=|Q;NqszTgxbw)l9cCh*m?m`k(|E^_hl7w;HX&;1We& zZ?^g{zzA8Qd)&uO5c&RW^kRyT9G7M6Kb}nB-RWMtb~zn<~hTE@3Sk)9M7S|M!MXrNS=$0 zjCc+uK)RWeoB(aogiGW{U$hd*%=zVMC(l#EmCsJ0$1;nVDf_Rgd<5y!Y2`agmmrVJ zq`YAEwj}df>>R+wb2sl9qf}Ni-O3JuD@w}$$ zqZ{Hcz`!aKiGfunR1Djmr0cMr$n1P`$xV}J=iv;`V7xyRtW0$h?RILz)#>~7RwrWN zS4JQlQZfSJ5ULG_m$3JugYO<2a9`vG+!v~KA4i``D-2KOcycex*xD#0D+sQdpSM;< z%xdtS6)72>X=rq7&MFKpM4TF(tuPEQVr;Z2avylte7-GPVHl9?fURf0(wEc`9yBKp z3RIYy90P=TuEH>=X6xUogWv)ch8NTxOcrVK#>q_X?#Sn(eSu9@w++=KeGOrl_Z&sy zcs>%yZC;|_^^FqK?sE zY8Ty%xPV=V10Apn0soL{+>@`oAJwb3q$p9x==Rhux*2f+yATIDU>5>1FLnpct9Pm9 z`z!2X^k8Zi-Hf<^U5Eo6u z3`>A?Z&S%07}&W)PhjT~YG98ND!UP{o_o30pSP=44EqB$bEBF`kmNN{8zCXt@C05t zwSvUo?OQ^RWrS+Qd901#yK|=1c%xb*=mr%ixq$_~ku$|f4h04RS z%q^u*f6b8~eZ!Sdc{>g7)%Du!bYLO2c@!4b@~H_ckuP-kX|haOtvGpevHb*wkctE~ zC4zEaL4dBYNkzzgO@w?zKd&n%2pzjqU3BqdOtgN(P~MYTq_?Tm?bT4M+^UqyPOmiSdyViF}$} z5>lv)_&~e7o=i8BqXNvU4!!#y)iwU^G;!&oF)Z%3++yq79p#?Jfx0tQ zDkw&uPnFWmC=H0a+bA6q_2oZ04QPjg9f-lbsY<%23<~?#yv8GQUQ*F3_dGjIpnj_& z$IH=u^Vsb)n30$xf8p&z@01wFw0MToQqtKt5jiC-sRAKCR&^DWgBq&u$EJ zTX>7s89v?SW5Fo>$lCv>A38r*!$UEbXS7sgKBpLXY}=?@Z`D>leJLMCWVBkTvd7a! zya!qho@$H68e^KEi4!jci%g}C7vfzQD`AJIQk|J0DT9<6BQq4aD9Tla^TPm(37BTcz>um z5Fa!s4+L_P-jXJ)g}}P95J~yKaR$`;G(aB3=r7XLql?C{ zxa*W5g9@BKKz$@tDkw%DO_kE!ySR@TrDLK^`Qr?rzg4gUG5B<Z!bBq7UL|>nj0RF5-ODS0j9#-Skx2I>C3%UAPECL0hmsk^-zr`<2rX=g1$Ygeu{5=1;w(*Di>EER^dGJN|^0}nNa=NSMLu#da zK(eNnvwDwj0JWU%O=m-DrF%z0T2A+06H+VPZzrVXbW6#aZ>39-kWZs`>k?+|3yF0+ zC0U-WEW|rf(!JXKT}nDsm&=jKN?Ok1V(o}{y6G~?-5NFPGP+-*>`%~)9!z52LU*jj z-UAsOp3F!K-Qz2OjAo`lx-V1!867l_d1<8kZY6oujQ%PCw$Qz+0?6pT6iD}16+lM6 zPk_yIuSjZq{FIE*=48H`>8{W@@-{MBmCRf--7i)E8U0fNY@z$VDu9fhNP%=`X)bux zjNX)FNDE!k!2=`n_t!6Fgha&0=B12?lY@-luq59L!71nFWCb+R{aiw7%AXY)?OCDV z8xm3Zz2w*ve^`pq?&N&bLN}As0yHTdz1Zd=pAsMMUmWJ{Q)6Qq0pWNQ)2ywxzO?=% zB>QgtF*jZ!*-2&gR7MnMdDVn2mDvLsQJm!#f-aTW0~t}A1xS}9@IbchOajXeQ)9ALPB>}B1^s~kil_D zHE3eZ-JX)Zpk0<>;B^L8TsFAY`oI?j0%6hn`NRbDd8+jr-UkyO8|kL;3Oww<#GP6s z;yj?wAzBW~D1Ru4Ln}v2&XOUE=S)a?IKyv9%`DHUrP=OsCSXzjl+AE^F)BO;)}mTHhSe zI)#q?6Q>&KqE?m-O8+fMswTSMOh_$snFM((wN1X5Mvtp$_BC0{0t@qKwI?;AjG&I> z{9EQ3M=HB)9n1?_mKU@vFKC$+#8Z|9$)P;-MSWbwNO`3(@EH3-mBHrYD+MF=pUhU2 ziVM9|kGPaE_agk9Ts(8HxdJ&?q4Gt2@}&*&7xF=A)GI|_)b|O!&YgLDAF4O!d%q(O z+KV&hC)ji7rSUCIlW61fB^59smSx?U$3F>8<_pdo>5rTl>IG`*Le1 zk4Csn_nE_pJ9Rm7(B(GW0~v9rEx4|hB;a1z^*KZ%hV%#T#nCv{SA zJSOR*F}xO%by-Mwc12Qao9L3aVwzNUMqf>VbRSTX2QvCj3Z%;l@IXcfBu_7z=(4mu zkkR2OkZvY?Vk6;eN`Z8FOy(tCr-18IAl3DivYA1Z*1{znR=o5>52NM2-;K&T`^ChS73 z7It~jkC+q6n3P*=%dE?S!e6Wtk~K|8)-EAgqe!jYNw(!6JN43c(=?Tj{V@7L!q`j~ zSu!;Ov>FiyT1uFO*s|p3_~3aZ2P9aYO1#K4Ph~{1N!rpS(>#z7$tFO$e>{0d$?z@} zMe{H9s3jM++In_IzgMcfXOC`XeuSO*`Fy(Eh05ql>2jz0 zvkD-iXHp>D*Xc_t-XKP=PhMzgrdzH6GHOqObU#!9Wb{`lkZvY5#2LFjy+L+~da7Ne zp2|YKy<&+m+MX^kx|tal1MG}5WhW$))6%I<;DM~V{Hs;Dg$Ng+@YXU)Wi`{~RPKRR zgQr?+QG$&6Ohco4BZpNOe0K->-lHLL@9toL5%RGc|GiF#{GVAg1MWBywDs)@jZ8Y0g!D_^LreBv#$FI46WQ#}>0G7C$vfrTa1 zz`_!0U||WBg_T(^LbbDmSJXtGr;I3zg%$D?U1roo&(4Ul_$N^zGjl0*Coq>n4b0^q zVv%IlPS@F!vNKH=0Q-TEc(HzuUJ{bc9=O<8{PZ(QWi`{S45HQG*^87QqdwEn=!%9_ z7_1~Xb&>k*iX;P!kg~VKef<<7pUR>c5V{0yeLGvZ5Fa!s4+<1X>_BBu5+Lkzt}%eK z(AXcUu>fl;lDjqyk!KHTzR5fbmC+BCD&pv7s;K~}rc8`y53E4JvI6ncW3f0>V+9+i zu|f^hSfK`LtWX0rR;YH8M_6M^8Xu~vUnPwG7;0>0;`UT4otcRfY+&Mq8kjht1}09Z zfr%3;6URBz$CMFAP1*M7W_D3ww=>KXElyIoAhWy zQd!9XzcRE|gJ-waq9hepk7;Oh1;#22Rvq*moh^|JFhZ)%E>})Xqf z3-LjN@}NLL#ST;kB>}=dS5O(iS!nDtYAnDS3aUJ9B*`d}na7kwT1d7$3dz<+A)%SV zC?vbMgv83?p{9`N@|vgZ9WTYbbT!*S<`cMNc5iLJfpj zsDUsGH4tW@2Er`VK$wLZ2(wUan2FP8G%~XG-=~X)r_Msc#)+DvafL8{aPj!s2b@tV ztC?QSY(d5)Fx*2f+yATIDU>C37Kat2z-oKEk zsyp(pS$FEOl6zKJI)Mkdy^6X;Ed39LsfAjCuOWrHQR0zt>gOKbYK}dE6gk-}nq<#Me zo@#E&_o0j%vW_~U%{oW4&N`xX*AcD5j%ZzWMC-I82Hv-HOa6UJ4jOppl0dEFkLdh9 zudTe{7`N|B^01Ze{Ryds?l%%r;Iomfc-E7?`Ij#5n-h(=%3)ea)$DW|KbB&HBj)Gg zz!!37PKUH=gNF$lAbIC@ni<5!5g8DfG10)dAqJ_5!k#x#h&EJ?-3H4k%G)jMHegSf zi48iJ2L&V%<@e}J2PNe}0Z9WY0ZD-mObjX{jhD<`K3+vrYNLR-`x4u)8b8EJ^ezDkQ5>NJZ){P_>c* z$UaI>x}8XoSj&voQ@TmW%u*G0mMRnDg$5RuU;_(Fs94;n9(W0Xg(cX)!V+p= zVF}evXP~Ug@;i3l6rhazA~fK>Py_A@HQ>Hb1MUko;J#1;?hDnrkE5rgb%i@2s;CqZ ztSJ@O6}TwJzA!LKWhKSAGB#F&XSdd(Bo$YWX=rro%qk2nKJ=ZLtt$*LLMny-p5Fa!s4+_*3>_BBu5+Lkzb%g<(g~rZM7Xj|2uCTMmU$8=!Q7mE_ zrGi+;G`mt_nq4O`4fTy`PE50FB&OLF64UJZh-r3CY;lnLE9-)gtOr7}4uo&atoeen z)(Z*a`PjCQ=<FHCm>O%0f~X{*J;m5j9+U&BH!UD zNhVZAe2u3pC%Ty&6<}U<=(~7O-IGQPy@-`{XJrMJB3#(_qF9TP;h9E!+qEl!^px(`vcuKzz`kJScEJ!46agB>}=dcRpbNXQ8nh z)kT1TpUokoSSGStT9++E)?46v=0R=N6!j=Z?@AMwE*it)uFfsCzQFg)gL;3eR8WjQ zm@1{4Q5q08Xq3u(Bl4#qKsPGbff#%|RY@0>L18!LHRiu(o{C<%=h9MC^Z49>lc;v0IYHi4iYE*8j_|MA6AzW6ZWyQQRR(dBhq4`jqkxdNoi zOQ9afDDcAQ3;NX90~sAOujHaBuV>SJw~{=N(O)INKZNgwrc!zvAJfXj7ruEaqg8t9 zlZ}Y(7t`abY($LsRw;=t-TzeqWE6OVCSUyMRdc@1JTn(PF3_3(o>H?p^2%sEqh(QK`Xn34sS%15uKGV`&Q-?o2~qWd)7}aAC;^?Lyq}jKJsMhKT5otAB1o zWPrZpS7LDe-Yl8{dJ?n^@1SxaK4?%L6xi#r1C>EZfUwWG#sJPjWA9O80S2B$kS64F z;N24zA`2t1*MmA$b$S$|sY;bRql?C{xM|9eK?OEvP-mn{1;yyisZzRo7k8FX8vGd; zKxZr1ffy`GRnkReP}q5SjrqNP*Ci#FhCkF+f=KtoxBE*{9_XH|Bsp7b7-BFh#htF* z#VN@qd0t^N3TG!=7t=*x{M#+fLyS`Kxf@kv{Uq_HiSE-%a>g^jvy78d)C`BqtIVBO zQHe--9kD$0tSXzB2ooZMlM+Xp>845rXO%jMHjq}W%p6J)DkLjPNLJ7&wFc{)HU_Dv z5txdGR9HQBrJ<2`BwBxhl?{DIB*B*&$$%N>!;6eDPUsur-v>j}d08P0$UubHm>#T5 zC=HsK2L(#`h|FkIGv1-C%s$;)64J$VPirkXKl~3RG3s6Bsq$+*bl;^U4`lSg6iD~O z6+lM+GX>K9aRrdkw&jUxXISPxJlmYO(fnTRUYC;a>=y~CiS8J6Rt~6i@mOjB-M6JE zy2}z$6Ww(QshRGMgw%Aub|)roH@{B1ttn}lc8RgrMVA1JU33Yspy=L^$Z8_cA4y3! zYWJp;M3*@bS)(-Ivy#9!&C_m2N?N1cEh*_b?OvafGLz-H%-Fk&PsQ>dsDGYXWDtu| z-n_nHhyjx=X;#FSLUNlFj@_N4N^a{1a$5pfLiaODk|S=<5CcTH2iMjlgb_$tdp3$f zvLO@_@yjg7YO>?kz^w3?W~Ik8#4|lH%}!2CtEN+O#i|Sxcp+JZLbCdVRHTjxkh=rA zguh}g?oB3W{e~e1|CUT-Gu>}xaaJiBnArWJcSbWN=R$G6%0Q+hB;CD=hYwJ|Z7w~c zD&)Ra-VDy@(bONhq?ZTU8Szw`2A*o2M>P^_PFO4GF|`swBRB1-yu{CLNiu%27I4uc zR7R&HWxbg$n}7!fq9W|p8LL_jKm-}FLb9>~hh(_0??tf|CBrj~__(vCbt!lNMc=U+ zZ1)6!0Y=EX5&Zkx5xGhC0EcG4!6ZT3nRun@Kzz`kJScD?#tu{lB>}>|`ivb=7f}&- zxM7Q+UnbV;2UXA`+WNF%^nImD1)`g7u<>dr5(hevsGN&9o9-WNisWbP&rwyJbCi6C zlJQ2#RxiRhOUZ|X5k#PcM6}p4gv2(*`AA4VR+XG>gjA%iHz@+k>E5KIc#peH`*$X= zM!MfolHAMQxCJ9Px`{@*9E%-}0mjBUu$Dub12W*4CIaccMh|fg$1!@P5@Uh(@Ep@P zNMDm>=1Bda3^RRV=d{@9Q3sfrvC+@}W#Q;3veN^d@Q?%0aUEsQtLYmZO&hYhVw%+x z)2xn|R!zR_yH>oAtaKq+;eic%uI34=Ce}~CB}uFD>osQ=Xgew@(`6kT9IYQWwkJAf z#^h-y4v|5GRPffTIVwFfOHf}Ox^)t|)rY6AQx^nx@F}8?d!dXSj&4H? z9y@Rm`t2$gm!SvjbMmcyL>>ENvd&SFm?k7^m5{7KLb}7)A|z{ukgNsFH^r_7NW6Hf ziz!CL<`?)1U)(B6vG51u$P9+tgbV&^l#6XIsr!t~$ z3OilujRzLRZiTL&vC(GP;U*0+UZ1SmWpr_JbaZ)SU5shg!I+kJZ<%#3hFRxgTHdu~ z*0mUB|E#sLsaRu$WNpptWrSTw)+`~h7x6qtNNh!HJ3?a9VGe{;WG7p#+-TU1Q%J~W zYZDT(_wtO07;H`_u}FP7snc?K8&`1~sF;?Y!E^^=)?%EERZPPnf)&&7h-k&MB71L6 zUCM`RnbjySm7y?=;4<`a3<$iSmXF}_53A-IwRPXqz<~2q;QfV60{o(lE?n}u(}tlJ z(;XCIZmqWGBvW*AzQmd>=Az6(=LgBkKwS-h8I}J^8k3uM9>DfpK$p%75d81nMMzvxTStE=# z2tu-UV&8*FnQEd-61mqy^EM1KFeu!WC~T#hD!gh#Zt}(UedhGfmX%x_sQn^)c+sc(3PG=1Ft*f1fk<6sV=%tE6Km| zo^viyh;t5?cdt+-^8GWIXH@~Ow|Od~6O#Zo)5UcU#CweKRBMf=+Es*VB+K&|%NTfM zGfGXu#5xVO8p5WbWO$|#BKNG#Dhxh=L*EhVoO=Mr03&$$9EpFC1vB7r5?~wjgOv&4 zL38q;z>`JHKx0r6Ak1@)F@Uqk)_1F|-~ta8$-8v*x;SdDnQw!ShjDkmm3(?wsngdh%d zppfR?SJQnojVh$l9Pw zbmCYw4>7ttaif{;yE6VZ4>2NaB9Sg0dWnp1Qh;=`{x%O)dK*R7-}vDf4j-8$$1>6Y zf8>4xC$KT*q>qvDZHa~(a{_lNJ4}AYw*z?_n({U@<@Gh8Z%i`txf9A#^=lx>^!3}e z3^Cf6c->6*lNG>iIz>3SUlg;W7eAG1;*Dw~9u$pPdc_I{8ba>vDnEM-+V&)4TIga% z7H*BHxMoaRtIoYk+gh;1$~(!3aLFrYbP*bk2C6{^Y8L_sSXj`XtL-04Cu-}KAx1+= z6}#wW#0k(uBtjhMfL*t!%r9#DvZyZ_H}S-A6DQ9&QGVFoN_;?J->nV)q{4nz8~k7` zILB&R#h6nSc2;e0R?^-x`(RyfM<(TUy+oGLG0AFdrkfELm;%Is4ot!LNhKfV*Z9^w z_t*X#wUuha=EB|)dU>EWQOoz8sMdvQ;Ejo)ts|BGIu#{vow|QBgV!tZz?e9;XWZCH zLy)HHrE&g}Jg$dA^qeFt-I5j0;2I^q+{t*SEP_d|iFH8#V1I^}`fP0;uPWd1`|+oY1C1{OU0?^Z~> zlIedjVQZp$UjiFAiT+oW=1gGlM9LePKg6>lWLg5n3KW_%(*g+tDy9V@2JB^8KBzWg zh)m0lnI&g!Zd$;iTc(9B8b?cZ&_{c4T95@eFfHFz(;{7%**biv(&V*vx>Tky(UvVk z3~(#(n*1wN1d#9)fI`cG(H7m0hae$9E)^v|weGDMSLk1nxE>^ThG0N};3Jtt1%KNft{ot0dlKW$i88`LSLkL-& zUf#2LtW+$2Ib*8pT4{kKTB4E)6k3TE9*~HQdv|o1>aEce3zyw%_hxI{%KBtlcu*#{ zxzDO>nasen{Zz01T3ea6z0He-2Q@!apG*r6%AEY#k_*}!v^D8v18U)c*?xU}5-mI+ zamQqD<3rl+*7iTOeO%k8w6#XR*!VY|=k2>g+a22O)YjTFU+JH$5&t&DU90T}w7tGY z{uLwS@7zcHTWYlT+lqTa+vt2B->KU6XuC;U8{gd{T~_{WdVQz1yR~g!?Bia9zsKMwD85nKBK|v-Z@B!}SF1kozf!%`?87eN zVfEN}+^ceH#UpRB#;IiDX64_e*LP~WTif;v3g$aAuUei09=$Hwnom0K$wd6P9xB@;I*|NVM>r?$Jb-Ev{U{1o8ZtKjc3@+T<1QQIQ^ zJC$#^{Pq$NP9bkoTO*B_Gbxd7Z26 z0_NEy$cv4?Q1!0V*5;crCt9O8^0Qh#UZ(hU+HN-dRzB(vMTVbxpBKJ21C5J%*&&XHsNJ6`n+m%mBvG12Uu4W&8eM#~7b#{S2E0o@$ZKt+f+HTeMJ=(rc+Ye}Kx5uN4LUeOLL0%U`cP z@VBa+)$IGZ+IO_#&((H?wwbARUGVZ7YHmD6+pz_Bl~*hNsA1yYpnTQr z8C2Zu+I~*kH(c!F-KcGkw$^{k|CM3#->iJ_pIE1U_#@@B{3{CVzftuLm%m8T-~(4QA3N2bTJaAL6Te6Ks@X$a$uH)G{L1B%#^tQH`utm}?YFeG_>T`0Kci0h zlMMb+9bc#I{n{4U_sRl(i@!zv*{??Y7Zm>!ZTD#VOKpiC_F8>AM#%rbKH~pjjrI~p z=A&BtkJ32SibvkxDc_g0Et+5Cl261LIq((b?%`;V!^*cu+aiClqe*d>Xj|6S#s_-4USFf_+5$ZE z9=+bL?ZyK9%P#Trb(OY*+V0fW+H~{PbuFHZHw%|j&l@ufwoQBTKl2D zRjd;E&j8L`?|K@ z)bXe#greZN<|V^#0Fjs8K^ zKedYfC3WgQSoNH)Z8dwrEw0f%8{d-h4VRz!D2j*G2fnu;eil#MKc;q~$Id_VVEM08 zzTxuMs}KCGCO?bp`;ppr-|I`xbo`q020wmws&C2jqP*UudB(bHo#FX@p)Gmjlw|%x z|1)aG@3g(r*b}Ke6Exqkhjmq?|3F=5Mfyjnp3}6&{v*`xjH#{*ZhnpSS^n9|H(Y+^ zrzjp)ANa>KA8h^^;TK}$4zTxuMs}KC2*JvMh-K2Kn z*KXx+RR8eP`ZuV2!{x76ANYT%(LU_DQ|-jBBhC83PwU^OlyA8F_38uvTlKG`@h`IP zakcMxZSjlxuwD6gXlwm@dW8J->H|Mr<6q6b`C9j=zxYM{9aO)NLp|M4a9+NmPI)$7 z@PA0e-G)pdG5@TbA7@aeLGt}{b}O? z{xRhnKg;6})z;#FT7WxQ@jp_1Z+VlKGfMT2Ezn;i??fZ-$QtEg_c4ZlbdCJz#UJ$I zkBtYohg9DoZ}xt-YFmV#rudoK&e8VE+J0SI%ipQ=K5f@)yIouKFDcLu?sJO&g0|?j z`tYk{@@c!ybD!#Ao-O}lD*s7squC_~xlP-9w0*70KUv!;`$*qTmA^~d?`yl?9B;?t z+D58xh5Chmx2u2O)Ap#dJm3G();W{;&-#1v=^npG+cTB#Z3X<`Iuw8Z8J^$T*Q0i3 zRJ(4I@(q{2UVY#nQ#*-Yk$u>8rP?{De8_=sYk_}V$~Rp8di8<7Rqd>1A9h`@b}m&u zSGJYX8@@ zW#9eZI=23jH~X1=wdg!iQad=`ZrAzY-1&f>^S-04)wf9bf2wW0{7aSZd&A^!Q@)3W z$-hNP3NiF{NUG++W9GMZ`0P!C-l$i^*gn_y8sXU9=*Op+kY*< zbMCixbI!K*oU3{Fd6S1l_%({VvPOJwop{#4&y;U}tadf)i)f|66cM_Yc0-r56xrSjdN?Ozw%e|8n%?oj$Q=Xkx3 zX?xNlKR!)ctG`Iztw!G6HOj;8PZ<7B)X0xs{6R1NSo^_sl)Rr0oa@_%w4JihkFU_S zi2uuK?+$J6)%IMK+p4YQe_ChMgO4Mah>YFUfUsUzdFy`GuYtUZD;%TZf)<^cDJ?@ z)n04g13GWN)3&ot`<_&L4pw`WaQW-i2mU>3r;V>M zFT$?V)y_G}haBc(kJ2swDatoo{(AL+zew$=W*>GfRy!l*Lr&tC=9~4eqm*wex;mU&x8nuL%YIy-oRs%U`cP@Q-0<75i>f`#z&B^#eKhMZJj3-_0ZB zuU8-VTh+g6_E9%Kq4jgR*6ki`jXM$7&(iC2wOvqv->Gt+*A}_E6u(XL>~3xC{$TaL zB(LN`GTit*vXAEjdA~ICyFusoN^Q3m?qtnv+)zg~Ud&s6`a z**8J&|9Kuj9pOHm`?B}weVO%dqVhkWZN2B_P1$ds5u#b{gJQuO{Jf(hK zqWM=1e~{vis}X-#op|(rT=~ABZIS)h@mj^5s_iswt-sJ`>Gd;UgmMuf8<@E@-}PxUTrP@F{Rh4-|{~-LjG$0T7BS;Er^fB*BVED1GI>LuIgK$ z?ILaYHMglcAN+Fg?FI8wB!^$jMoy#hBj=6+dGIY$d%%$=)*o=ais$zl`B`O)=SOgF zQanEocINVugYw&8{GONP=SN@pAxiQVz4rGsE&qR*II|9jv&HlKh0IGe{Ihk+=ePK3 zl@Fd@)T?IC=Z`Nrm+Ws<@q19#Uw(zj;uoFZLJU^wiTCaah+aYc5()P>RTKnL;O0Qq7Z8bT3AAZq17UjojlSmJU)1)i+D7K@yGrM08u*zOzWLt3BXILxQ*xL1?FN2-!Q!F+t>U+9 zd$+b<(v}}-u>3#N>rZPtLD#{nw6*vJNcuZ@p0Qje1>MzQ2#}x8wWWb}#WbzK?BJvmf() zK|L*g%=f3z^8E+9-|DZQvedUzwdM2wdvu(9{#(y$e13VCjyc~o>iL5Gd7IWp^1Y<> z?9hxwNhC(rC)6 zja|a%+y35Y%9^f$DeF6W`#QV3Dh6e_*4weREoRVO&)WWIN@rK6{NLZPLH=JY1G(0{ zs;$2*n$mG;d3A5wx{mUttAv-42yJgKcWh|y=;<$uoohS1jB;CVZ`(#MgZ^dh!YKOM z)^)ZEU$>}`|E4&-UdPJ5zGzB&_quf*U2<_%$I5{gzxee^)z^1t=}9J%nq3omrTf5%}Z z2fgDk&#}!niM`-xo8|iR8UCe*mmJ5^!#(4mZ=C(HOW3dEs9icS9eIx{|KrNPM}fo( ze*9l&_`iKb$#H!92+v3yWBxeKmj800#W5Kx|Kh)%V@le(CVIJVlK-&-La%hP{9BcO zt0vyWcycm-6SPmeNyb@z>eII4J@CWv1ZV!>gLJiYvivj4C3k6N*(1#KC-dm9M$!AE z6Y~@QlJb|7|J;K>`nFU#jINh)mjBvLkGQte1Ak%gHhx2ff9qwQf9qwQ@fapXF9|H3V_O7%1TrF3Fh_`gH> zcPRgM5?dKc+S2@1I|W3Jl{h&wf0qB$0{(A&)AM&7pJA4+<)5ScHhyn<#`C}Yrl6|_8esIM8 zTS*_E{Ni;b{bdpRWhMRP5&K{z{S^`WTP1x$#J*KYe`UmeR7pQ1VxOs`9~!ZLRMKA+ zu`g884~wYxmGr}(@Of$*ER-?PaRqc!j1)B{npl88AxDqb&**4;^w4Wd71!crx?lA43l&5e#FmeW z^6@`e=&_tVM$TDEpE|iDz4UL1bYpyvp|278sOYHZ$SYPjaBN@v7jK`VqI^EwB=lI$ zppoOxLHWG8U+^KnzNK<_o-kd;@!xauFP6`Jacp1wR}`O@i@~F0m%dTYT^=oQbM$=N zPI3+&lFRcmly29>`A$wgZ&x~cKL6h#^hshr&o!9PyM=y;&^ce(`G>+wIG zobk~uCJ+Cw&?hQywmDEXn?s^}-FtEDY@}P_kR@q zlaurG3%0I)P37>b%U@GD4?DUtXPVy>&<~SiPpo%>#+h?Qo6zI@Y&3DZ#^H~ON*W*H zf0xkXIPiR~L-IcUn|nYUho@iY(R$^nQFOM@Co;&iEkcjw@LX?^Uh5P3E8}@Fb?-`{ zht|ieElY-i@!ToRni;AdA&S8{Icr3Lg*)m-fikH>-{4_59z&C>03?Q zzM=BBnmqZ9;s*`>XgTPGD=P5M3q7Rw zXjunw{_va|OuNwIxRo>x$p5V3qf1Io{!aIQ6g?|+SO1rL`umhVPM(t?Q%SBlrGS2R z0llk${ue@z?dLiCKd6$=7T_On^!)ku-yD5>#Ls`Pmw3g0-z|{;d*~X6O&%Vd_A+k| z&*5eBc7GpMx?QJt2tA(1tvX-ShaU?)6u0LJ=!;~F4dE{>pubD#vEJRPmvwPd0sd~G z$8qNMiWk)1{pJ2Qrt`YN%hcZ$LXYhkJg%fj-)s@O+kefzusf!UJ(1==_PpTaN6|JT z=L9J%v0h$}iO+5E-&CQ8;&7qjdA$Vu&I0_CjxLk@x{{N-RyXGOelsM0S^<4o0sShW zPYmpL?{##ivf{s+g&vMOd{2f9M&C9FBc(;F{B~c z&ejV`j)nX@`c-jVP4745SmORp7J4jam)bAW?fw=CJ@$9&`6V|-&R;3Mq;WgR!=uj$ zJ!I!YDu>s{8s!`o|4lwDj6b)4eyPx1o-Zvq{x7@#qv)mr{1*%84;9d#ETA7R&qd<+ z^r*i_tKO)+ZSC6fnswb><-Y#5-u|e)x4*A{VD;)L?NPbBX#Pdz^A|QXm&?(rj^2(n zoqh5OUb%l=xqWSSm%O$WAeGCjy31?UcCTz(TVB=Q-P>1g8`u!ZYhyiYJNi3TO_@FG zj2R+104m3?+xger%JMo|@5ac#ZntV+-MWp!k{Olbm-{N9tNPci?C5I0bV_?qPgK6- zf~LNi<%>FcrcEs`F0bnB>*?<6Xt?OSrnZIc4O4o=&neTQ@;T>UIB)Lx<#OM^%JRZ; z`|35K4%guA=o!=l*7QF3(xr-Oh zkFA>7^Ue($rcLXY7xent+WY0j&4uS*&{Uo_tFy0rZCgApukBdhv9@7agQL&x?Pyzd zd2eTbN4ckaZD;#NxzMm+TEqHiU0Y|DNNirHGM!|7JyXOqh<)uF+R7_s&brF&ZT;<+ zmP+%NE|phZ%hRUJhz5462Pps;?e4TNt zytZ>?d%3-D0LTSR{WJP|r%jt(Zt5wwcMr(R+N&fgeH}8HXOzqG(zV2X!?fw;^Sj&M z!Ng5(XmH6WFJ5;DRHiV=hf2%mtR7gqR$gm%`P$bsT{7sB=B9lVs#w;=7l5T4 z*H4>1tz2Heu2WWYTVG$fe`8OFB=+j=hKh7aOr6!<-PP6MGS_)LGhPIH@kN%oOTjE; zc4nHKklFDo=ZMjTJAG=osob%yr+;I)x1&c=r@OapO@~wa+z9||E9$SBYr!87Si%1 z)8@p{>1!-jhWQS#d_AfxFTeyqcZyz zOn29kx-!CA<-+HyUZtKnk{N9)yL)}|n4FAjO|^V%>Yr1-Xr)Y5N5{gZzNY?}J#C%6 z3#D}V*q+`aY17u*AyXh*R#)5FY15UmN-DtWh6brJwH~?)KgTdq#^#!_Uk7t5)0$XJX6QA5%)^C zWe3wFV;#)w>X!Y!V$H2u+gP~0R22HtC6PKdbhO9Y%HG%NG_zLMY}iolk+&FiOLlZh zomoFMT=R0lo0Umi_TL)TNtGCOxVIA3R~_~`^-;N{>+;U7RdNpM8(1e_IC0MW`Ldl) zEly79@m3+HKYzq<2grf0jtxCBw;ii0V(89Pb#3%} z4U*sJbMxVn`C_f9Hre7tPp;WK>+$8h+%84EKaP+&4vk=+U)3SUo$igknqoi=SyE+6 zFS%gajCC8!16`f(9FRj{e=i9bT6$9hYfsOQ<@8h&Z&JlMF-wm6{i$H}DN z<>qFlTbuEb(w}7HU_M*2r*lnL@SN!HIBhl-;0VeRH{KhO6s^+fKY`m@Q>` zZc7nLl`TaO#dAU3G$%MY&Gl6|z)3FlcdyMQxZj!crydG{-M`$NxeAfHF^R1{&&iWx zNZ-KP{xi<$=wH}(fgENV)?KExLKfME&VFk~a@eRmBDg?Qh&;W$d+orwuD8rd_@+fiQM+1o$RCXv@<#%*!EGmQXcCfm0jV?fUH{|Z8%JEI8olH3_7aYtQwL;I5_y2aT z-Y5k~o+fm4^ybfE5#g<}pBekLw)wdf+XB3G&61H=`nh}`uV4PC1= zSF+C*w9HF|i=QoMG?M$1B4sX?*_(y<&XlJqmG`CPRejy%OWV3u$y=0r2Ku=*PmYS2 zyOVvFx_Ut4w$rWail+;l`0`10h8)N;H*{yj8^Dr*j^2&(AfUNiHT;}PgH=18;(8X$ zUN=*Jn#eog@~Dnb7VNS_MpsG7$W=+V!L+Y{Y;d1x3SPlt& z9li48a9~42_EC-8Z+3O}u9HWW@~Ex1Exyy2eP3?r8{CeUsS5UF9PgBJxQP)>ee&=u zez>*wQc&Y9lAcd0_P;r@rC!{&cAz8PQ7PP)b=xAmzOUf%p5N|s0WI9^SH`nW4al)I GME?&U=B&*C diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 05d3d974b0..9c99318371 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -127,7 +127,8 @@ void* reader(void* arg) result r = txn.exec("select sum(v) from t"); int64_t sum = r[0][0].as(int64_t()); if (sum != prevSum) { - printf("Total=%ld\n", sum); + // r = txn.exec("select mtm_get_snapshot()"); + printf("Total=%ld, snapshot=%ld\n", sum, r[0][0].as(int64_t())); prevSum = sum; } t.transactions += 1; @@ -148,7 +149,7 @@ void* writer(void* arg) { //work transaction txn(*conns[random() % conns.size()]); - // transaction txn(*conns[random() % conns.size()]); + //transaction txn(*conns[random() % conns.size()]); int srcAcc = random() % cfg.nAccounts; int dstAcc = random() % cfg.nAccounts; try { diff --git a/tests/perf.results b/tests/perf.results index 95939ddae3..9d1805af6b 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -100,3 +100,20 @@ Bench finished at Ср. дек. 30 15:35:45 MSK 2015 Bench started at Ср. дек. 30 19:57:27 MSK 2015 astro5:{tps:111696.732113, transactions:20000000, selects:40000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:100000, hosts:3} Bench finished at Ср. дек. 30 20:00:27 MSK 2015 +Bench started at Пн. февр. 15 16:57:31 MSK 2016 +astro5:{tps:79803.776347, transactions:3000000, selects:6000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:600, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 16:58:09 MSK 2016 +Bench started at Пн. февр. 15 17:02:12 MSK 2016 +astro5:{tps:94747.726126, transactions:1000000, selects:2000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 17:02:22 MSK 2016 +Bench started at Пн. февр. 15 17:05:39 MSK 2016 +Bench started at Пн. февр. 15 17:23:09 MSK 2016 +astro5:{tps:117535.154295, transactions:1250000, selects:2500000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 17:23:20 MSK 2016 +Bench started at Пн. февр. 15 17:25:21 MSK 2016 +astro5:{tps:90684.278694, transactions:1750000, selects:3500000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:350, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 17:25:41 MSK 2016 +Bench started at Пн. февр. 15 17:26:11 MSK 2016 +astro5:{tps:96460.088384, transactions:1000000, selects:2000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 17:26:22 MSK 2016 +Bench started at Пн. февр. 15 17:26:41 MSK 2016 From 3911ec5fa3365502c1d6d7e5e096c4e35dfaa78a Mon Sep 17 00:00:00 2001 From: knizhnik Date: Tue, 16 Feb 2016 23:30:03 +0300 Subject: [PATCH 0258/1139] Make experiment with spinlocks --- multimaster.c | 6 ++++-- tests/dtmbench | Bin 471038 -> 479349 bytes 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/multimaster.c b/multimaster.c index 7eb2fbed2d..2a64058a92 100644 --- a/multimaster.c +++ b/multimaster.c @@ -60,6 +60,8 @@ typedef struct { csn_t snapshot; /* transaction snaphsot */ } MtmCurrentTrans; +/* #define USE_SPINLOCK 1 */ + typedef uint64 timestamp_t; #define MTM_SHMEM_SIZE (64*1024*1024) @@ -141,7 +143,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, void MtmLock(LWLockMode mode) { #ifdef USE_SPINLOCK - SpinLockAcquire(&ds->hashSpinlock); + SpinLockAcquire(&dtm->hashSpinlock); #else LWLockAcquire(dtm->hashLock, mode); #endif @@ -150,7 +152,7 @@ void MtmLock(LWLockMode mode) void MtmUnlock(void) { #ifdef USE_SPINLOCK - SpinLockRelease(&ds->hashSpinlock); + SpinLockRelease(&dtm->hashSpinlock); #else LWLockRelease(dtm->hashLock); #endif diff --git a/tests/dtmbench b/tests/dtmbench index a8319af5136f09404a60160fba43f50da5d2b753..930c3c2afd43c49cd82f6f2fa4510278b127d969 100755 GIT binary patch literal 479349 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

    H@8>@69=+eQ^EXNP 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 literal 471038 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

    aDv+M5Ww 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�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%0AC*1F`m;#wnE-;lbdb83yX2Ik*$`hZ`;Q4 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 O=(@wARd5gxWLDgL!F!@OB;25b8N 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 K6&1B Date: Fri, 19 Feb 2016 19:55:09 +0300 Subject: [PATCH 0259/1139] New DDL replication mechanism --- multimaster--1.0.sql | 9 ++--- multimaster.c | 83 +++++++++++++++++++++++++++++++++----------- multimaster.control | 3 +- multimaster.h | 11 ++++-- pglogical_apply.c | 21 ++++++++--- tests/dtmbench.cpp | 16 +++------ tests/perf.results | 21 +++++++++++ tests/perf.yml | 2 +- tests/reinit-mm.sh | 19 ++++++---- 9 files changed, 134 insertions(+), 51 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 694af8db5f..74e48313ba 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -1,19 +1,20 @@ -- complain if script is sourced in psql, rather than via CREATE EXTENSION \echo Use "CREATE EXTENSION multimaster" to load this file. \quit -CREATE FUNCTION mtm_start_replication() RETURNS void +CREATE FUNCTION mtm.start_replication() RETURNS void AS 'MODULE_PATHNAME','mtm_start_replication' LANGUAGE C; -CREATE FUNCTION mtm_stop_replication() RETURNS void +CREATE FUNCTION mtm.stop_replication() RETURNS void AS 'MODULE_PATHNAME','mtm_stop_replication' LANGUAGE C; -CREATE FUNCTION mtm_drop_node(node integer, drop_slot bool default false) RETURNS void +CREATE FUNCTION mtm.drop_node(node integer, drop_slot bool default false) RETURNS void AS 'MODULE_PATHNAME','mtm_drop_node' LANGUAGE C; -CREATE FUNCTION mtm_get_snapshot() RETURNS bigint +CREATE FUNCTION mtm.get_snapshot() RETURNS bigint AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; +CREATE TABLE IF NOT EXISTS mtm.ddl_log (issued timestamp with time zone not null, query text); diff --git a/multimaster.c b/multimaster.c index 2a64058a92..efb0f31e87 100644 --- a/multimaster.c +++ b/multimaster.c @@ -48,6 +48,9 @@ #include "replication/slot.h" #include "port/atomics.h" #include "tcop/utility.h" +#include "nodes/makefuncs.h" +#include "access/htup_details.h" +#include "catalog/indexing.h" #include "multimaster.h" @@ -865,7 +868,7 @@ mtm_drop_node(PG_FUNCTION_ARGS) dtm->nNodes -= 1; if (!IsTransactionBlock()) { - MtmBroadcastUtilityStmt(psprintf("select mtm_drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); + MtmBroadcastUtilityStmt(psprintf("select multimaster.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); } if (dropSlot) { @@ -880,7 +883,7 @@ mtm_get_snapshot(PG_FUNCTION_ARGS) { PG_RETURN_INT64(dtmTx.snapshot); } - + /* * Execute statement with specified parameters and check its result */ @@ -926,7 +929,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) failedNode = i; do { PQfinish(conns[i]); - } while (--i >= 0); + } while (--i >= 0); elog(ERROR, "Failed to establish connection '%s' to node %d", conn_str, failedNode); } } @@ -935,7 +938,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) i += 1; } Assert(i == MtmNodes); - + for (i = 0; i < MtmNodes; i++) { if (conns[i]) @@ -972,7 +975,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) failedNode = i; } } - } + } for (i = 0; i < MtmNodes; i++) { if (conns[i]) @@ -986,6 +989,48 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) } } +static void MtmProcessDDLCommand(char const* queryString) +{ + RangeVar *rv; + Relation rel; + TupleDesc tupDesc; + HeapTuple tup; + Datum values[Natts_mtm_ddl_log]; + bool nulls[Natts_mtm_ddl_log]; + TimestampTz ts = GetCurrentTimestamp(); + + rv = makeRangeVar(MULTIMASTER_SCHEMA_NAME, MULTIMASTER_DDL_TABLE, -1); + rel = heap_openrv_extended(rv, RowExclusiveLock, true); + + if (rel == NULL) { + return; + } + + tupDesc = RelationGetDescr(rel); + + /* Form a tuple. */ + memset(nulls, false, sizeof(nulls)); + + values[Anum_mtm_ddl_log_issued - 1] = TimestampTzGetDatum(ts); + values[Anum_mtm_ddl_log_query - 1] = CStringGetTextDatum(queryString); + + tup = heap_form_tuple(tupDesc, values, nulls); + + /* Insert the tuple to the catalog. */ + simple_heap_insert(rel, tup); + + /* Update the indexes. */ + CatalogUpdateIndexes(rel, tup); + + /* Cleanup. */ + heap_freetuple(tup); + heap_close(rel, RowExclusiveLock); + + elog(WARNING, "Replicate command: '%s'", queryString); + + dtmTx.containsDML = true; +} + static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag) @@ -1013,22 +1058,18 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, skipCommand = false; break; } - if (skipCommand || IsTransactionBlock()) { - if (PreviousProcessUtilityHook != NULL) - { - PreviousProcessUtilityHook(parsetree, queryString, context, - params, dest, completionTag); - } - else - { - standard_ProcessUtility(parsetree, queryString, context, - params, dest, completionTag); - } - if (!skipCommand) { - dtmTx.isDistributed = false; - } - } else { - MtmBroadcastUtilityStmt(queryString, false); + if (!skipCommand && !dtmTx.isReplicated) { + MtmProcessDDLCommand(queryString); + } + if (PreviousProcessUtilityHook != NULL) + { + PreviousProcessUtilityHook(parsetree, queryString, context, + params, dest, completionTag); + } + else + { + standard_ProcessUtility(parsetree, queryString, context, + params, dest, completionTag); } } diff --git a/multimaster.control b/multimaster.control index 6938570163..e6fd73248e 100644 --- a/multimaster.control +++ b/multimaster.control @@ -1,4 +1,5 @@ comment = 'Multimaster' default_version = '1.0' module_pathname = '$libdir/multimaster' -relocatable = true \ No newline at end of file +schema = mtm +relocatable = false \ No newline at end of file diff --git a/multimaster.h b/multimaster.h index 55d881c025..c2748df135 100644 --- a/multimaster.h +++ b/multimaster.h @@ -5,7 +5,7 @@ #include "bgwpool.h" #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -#define MTM_TRACE(fmt, ...) +#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TUPLE_TRACE(fmt, ...) /* #define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) @@ -14,7 +14,14 @@ #define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) -#define MULTIMASTER_NAME "mmts" +#define MULTIMASTER_NAME "mtm" +#define MULTIMASTER_SCHEMA_NAME "mtm" +#define MULTIMASTER_DDL_TABLE "ddl_log" + +#define Natts_mtm_ddl_log 2 +#define Anum_mtm_ddl_log_issued 1 +#define Anum_mtm_ddl_log_query 2 + typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) diff --git a/pglogical_apply.c b/pglogical_apply.c index 63c315dccd..fa1cbb097e 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -472,13 +472,14 @@ process_remote_commit(StringInfo s) static void process_remote_insert(StringInfo s, Relation rel) { - EState *estate; - TupleData new_tuple; + EState *estate; + TupleData new_tuple; TupleTableSlot *newslot; TupleTableSlot *oldslot; ResultRelInfo *relinfo; - ScanKey *index_keys; - int i; + ScanKey *index_keys; + char* relname = RelationGetRelationName(rel); + int i; estate = create_rel_estate(rel); newslot = ExecInitExtraTupleSlot(estate); @@ -560,6 +561,18 @@ process_remote_insert(StringInfo s, Relation rel) FreeExecutorState(estate); CommandCounterIncrement(); + + if (strcmp(relname, MULTIMASTER_DDL_TABLE) == 0) { + char* ddl = TextDatumGetCString(new_tuple.values[Anum_mtm_ddl_log_query-1]); + int rc; + SPI_connect(); + rc = SPI_execute(ddl, false, 0); + SPI_finish(); + if (rc != SPI_OK_UTILITY) { + elog(ERROR, "Failed to execute utility statement %s", ddl); + } + } + } static void diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 9c99318371..5719e92d4c 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -180,28 +180,20 @@ void* writer(void* arg) void initializeDatabase() { connection conn(cfg.connections[0]); - printf("creating extension\n"); - { - nontransaction txn(conn); - exec(txn, "drop extension if exists multimaster"); - exec(txn, "create extension multimaster"); - } - printf("extension created\n"); - - printf("creating table t\n"); + time_t start = getCurrentTime(); + printf("Creating database schema...\n"); { nontransaction txn(conn); exec(txn, "drop table if exists t"); exec(txn, "create table t(u int primary key, v int)"); } - printf("table t created\n"); - printf("inserting stuff into t\n"); + printf("Populating data...\n"); { work txn(conn); exec(txn, "insert into t (select generate_series(0,%d), %d)", cfg.nAccounts-1, 0); txn.commit(); } - printf("stuff inserted\n"); + printf("Initialization completed in %f seconds\n", (start - getCurrentTime())/100000.0); } int main (int argc, char* argv[]) diff --git a/tests/perf.results b/tests/perf.results index 9d1805af6b..69aeb936b3 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -117,3 +117,24 @@ Bench started at Пн. февр. 15 17:26:11 MSK 2016 astro5:{tps:96460.088384, transactions:1000000, selects:2000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:5000, hosts:3} Bench finished at Пн. февр. 15 17:26:22 MSK 2016 Bench started at Пн. февр. 15 17:26:41 MSK 2016 +Bench started at Пн. февр. 15 17:58:14 MSK 2016 +astro5:{tps:93430.358394, transactions:1250000, selects:2500000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 17:58:28 MSK 2016 +Bench started at Пн. февр. 15 17:59:11 MSK 2016 +astro5:{tps:81893.902409, transactions:1500000, selects:3000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:300, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 17:59:29 MSK 2016 +Bench started at Пн. февр. 15 17:59:59 MSK 2016 +astro5:{tps:105707.597142, transactions:1000000, selects:2000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 18:00:09 MSK 2016 +Bench started at Пн. февр. 15 18:00:54 MSK 2016 +astro5:{tps:92668.464039, transactions:1250000, selects:2500000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:5000, hosts:3} +Bench finished at Пн. февр. 15 18:01:08 MSK 2016 +Bench started at Пн. февр. 15 18:06:22 MSK 2016 +astro5:{tps:121069.442298, transactions:125000000, selects:250000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:250, update_percent:0, accounts:500000, iterations:500000, hosts:3} +Bench finished at Пн. февр. 15 18:23:35 MSK 2016 +Bench started at Пн. февр. 15 18:24:11 MSK 2016 +astro5:{tps:122202.228254, transactions:100000000, selects:200000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:500000, hosts:3} +Bench finished at Пн. февр. 15 18:37:50 MSK 2016 +Bench started at Пн. февр. 15 18:44:02 MSK 2016 +astro5:{tps:121774.204222, transactions:100000000, selects:200000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:500000, hosts:3} +Bench finished at Пн. февр. 15 18:57:44 MSK 2016 diff --git a/tests/perf.yml b/tests/perf.yml index c911285165..5d9d013565 100644 --- a/tests/perf.yml +++ b/tests/perf.yml @@ -46,7 +46,7 @@ - name: run transfers shell: > ~/pg_cluster/install/bin/dtmbench {{connections}} - -w {{ nconns }} -r 0 -n 5000 -a 500000 -p {{ up }} | + -w {{ nconns }} -r 0 -n 500000 -a 500000 -p {{ up }} | tee -a perf.results | sed "s/^/`hostname`:/" register: transfers_result diff --git a/tests/reinit-mm.sh b/tests/reinit-mm.sh index 7be2ea645a..c5ff1fcd27 100755 --- a/tests/reinit-mm.sh +++ b/tests/reinit-mm.sh @@ -10,14 +10,15 @@ sep="" for ((i=1;i<=n_nodes;i++)) do port=$((5431+i)) - conn_str="$conn_str${sep}dbname=postgres host=127.0.0.1 port=$port sslmode=disable" + conn_str="$conn_str${sep}dbname=postgres host=localhost port=$port sslmode=disable" sep="," initdb node$i done -echo Start DTM -~/postgres_cluster/contrib/arbiter/bin/arbiter -r 0.0.0.0:5431 -i 0 -d dtm 2> dtm.log & -sleep 2 +#echo Start DTM +#~/postgres_cluster/contrib/arbiter/bin/arbiter -r 0.0.0.0:5431 -i 0 -d dtm 2> dtm.log & +#sleep 2 +echo "Starting nodes..." echo Start nodes for ((i=1;i<=n_nodes;i++)) @@ -31,7 +32,13 @@ do done sleep 5 -echo Initialize database schema -psql postgres -f init.sql +echo "Create multimaster extension..." + +for ((i=1;i<=n_nodes;i++)) +do + port=$((5431+i)) + psql postgres -p $port -c "create extension multimaster" +done + echo Done From b2f99701555f14a47324d8737575ac087dcd6758 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 19 Feb 2016 19:56:47 +0300 Subject: [PATCH 0260/1139] Remove contrib/mmts/tests/dtmbench --- tests/dtmbench | Bin 479349 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100755 tests/dtmbench diff --git a/tests/dtmbench b/tests/dtmbench deleted file mode 100755 index 930c3c2afd43c49cd82f6f2fa4510278b127d969..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 479349 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

    H@8>@69=+eQ^EXNP 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 From ae972c150c5fdde14dbfdddfe2ee2aff455db94a Mon Sep 17 00:00:00 2001 From: knizhnik Date: Fri, 19 Feb 2016 23:24:41 +0300 Subject: [PATCH 0261/1139] Fix handling of DDL --- multimaster.c | 27 ++++++++++++++++----------- tests/dtmbench.cpp | 2 ++ tests/reinit-mm.sh | 8 -------- 3 files changed, 18 insertions(+), 19 deletions(-) diff --git a/multimaster.c b/multimaster.c index efb0f31e87..d8c5a45ca4 100644 --- a/multimaster.c +++ b/multimaster.c @@ -489,7 +489,7 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) MtmLock(LW_EXCLUSIVE); ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); ts->status = TRANSACTION_STATUS_IN_PROGRESS; - ts->snapshot = x->isReplicated ? INVALID_CSN : x->snapshot; + ts->snapshot = x->isReplicated || !x->containsDML ? INVALID_CSN : x->snapshot; ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; ts->cmd = MSG_INVALID; @@ -868,7 +868,7 @@ mtm_drop_node(PG_FUNCTION_ARGS) dtm->nNodes -= 1; if (!IsTransactionBlock()) { - MtmBroadcastUtilityStmt(psprintf("select multimaster.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); + MtmBroadcastUtilityStmt(psprintf("select mtm.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); } if (dropSlot) { @@ -989,7 +989,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) } } -static void MtmProcessDDLCommand(char const* queryString) +static bool MtmProcessDDLCommand(char const* queryString) { RangeVar *rv; Relation rel; @@ -1002,8 +1002,12 @@ static void MtmProcessDDLCommand(char const* queryString) rv = makeRangeVar(MULTIMASTER_SCHEMA_NAME, MULTIMASTER_DDL_TABLE, -1); rel = heap_openrv_extended(rv, RowExclusiveLock, true); - if (rel == NULL) { - return; + if (rel == NULL) { + if (!IsTransactionBlock()) { + MtmBroadcastUtilityStmt(queryString, false); + return true; + } + return false; } tupDesc = RelationGetDescr(rel); @@ -1026,9 +1030,8 @@ static void MtmProcessDDLCommand(char const* queryString) heap_freetuple(tup); heap_close(rel, RowExclusiveLock); - elog(WARNING, "Replicate command: '%s'", queryString); - dtmTx.containsDML = true; + return false; } static void MtmProcessUtility(Node *parsetree, const char *queryString, @@ -1038,7 +1041,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, bool skipCommand; switch (nodeTag(parsetree)) { - case T_TransactionStmt: case T_PlannedStmt: case T_ClosePortalStmt: case T_FetchStmt: @@ -1052,14 +1054,17 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_LoadStmt: case T_VariableSetStmt: case T_VariableShowStmt: + case T_TransactionStmt: skipCommand = true; break; default: - skipCommand = false; + skipCommand = false; break; } - if (!skipCommand && !dtmTx.isReplicated) { - MtmProcessDDLCommand(queryString); + if (!skipCommand && !dtmTx.isReplicated && context == PROCESS_UTILITY_TOPLEVEL) { + if (MtmProcessDDLCommand(queryString)) { + return; + } } if (PreviousProcessUtilityHook != NULL) { diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 5719e92d4c..2279edd442 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -184,6 +184,8 @@ void initializeDatabase() printf("Creating database schema...\n"); { nontransaction txn(conn); + exec(txn, "drop extension if exists multimsater"); + exec(txn, "create extension multimaster"); exec(txn, "drop table if exists t"); exec(txn, "create table t(u int primary key, v int)"); } diff --git a/tests/reinit-mm.sh b/tests/reinit-mm.sh index c5ff1fcd27..be892d2baa 100755 --- a/tests/reinit-mm.sh +++ b/tests/reinit-mm.sh @@ -32,13 +32,5 @@ do done sleep 5 -echo "Create multimaster extension..." - -for ((i=1;i<=n_nodes;i++)) -do - port=$((5431+i)) - psql postgres -p $port -c "create extension multimaster" -done - echo Done From 991a5e2d9978896ff310e5a19df803f3cbd58e9d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Sat, 20 Feb 2016 13:09:00 +0300 Subject: [PATCH 0262/1139] Handle socket errors --- arbiter.c | 297 +++++++++++++++++++++++++++++++++++--------------- multimaster.c | 99 +++++++++++++---- multimaster.h | 15 ++- 3 files changed, 299 insertions(+), 112 deletions(-) diff --git a/arbiter.c b/arbiter.c index 10590b8a28..3d36a8fe55 100644 --- a/arbiter.c +++ b/arbiter.c @@ -72,9 +72,9 @@ #include "multimaster.h" -#define MAX_CONNECT_ATTEMPTS 10 -#define MAX_ROUTES 16 -#define BUFFER_SIZE 1024 +#define MAX_ROUTES 16 +#define BUFFER_SIZE 1024 +#define HANDSHAKE_MAGIC 0xCAFEDEED typedef struct { @@ -83,15 +83,17 @@ typedef struct TransactionId dxid; /* Transaction ID at destination node */ TransactionId sxid; /* Transaction IO at sender node */ csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ -} MtmCommitMessage; +} MtmArbiterMessage; typedef struct { int used; - MtmCommitMessage data[BUFFER_SIZE]; + MtmArbiterMessage data[BUFFER_SIZE]; } MtmBuffer; -static int* sockets; +static int* sockets; +static char** hosts; +static int gateway; static MtmState* ds; static void MtmTransSender(Datum arg); @@ -100,6 +102,7 @@ static void MtmTransReceiver(Datum arg); static char const* const messageText[] = { "INVALID", + "HANDSHAKE", "READY", "PREPARE", "COMMIT", @@ -111,7 +114,7 @@ static char const* const messageText[] = static BackgroundWorker MtmSender = { - "mm-sender", + "mtm-sender", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, 1, /* restart in one second (is it possible to restart immediately?) */ @@ -119,7 +122,7 @@ static BackgroundWorker MtmSender = { }; static BackgroundWorker MtmRecevier = { - "mm-receiver", + "mtm-receiver", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, 1, /* restart in one second (is it possible to restart immediately?) */ @@ -164,14 +167,14 @@ static int max_fd; static fd_set inset; #endif -static void MtmRegisterSocket(int fd, int i) +static void MtmRegisterSocket(int fd, int node) { #if USE_EPOLL struct epoll_event ev; ev.events = EPOLLIN; - ev.data.u32 = i; + ev.data.u32 = node; if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) < 0) { - elog(ERROR, "Failed to add socket to epoll set: %d", errno); + elog(ERROR, "Arbuter failed to add socket to epoll set: %d", errno); } #else FD_SET(fd, &inset); @@ -181,25 +184,65 @@ static void MtmRegisterSocket(int fd, int i) #endif } +static void MtmUnregisterSocket(int fd) +{ +#if USE_EPOLL + epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL); +#else + FD_CLR(fd, &inset); +#endif +} + + +static void MtmDisconnect(int node) +{ + close(sockets[node]); + MtmUnregisterSocket(sockets[node]); + sockets[node] = -1; +} + +static bool MtmWriteSocket(int sd, void const* buf, int size) +{ + char* src = (char*)buf; + while (size != 0) { + int n = send(sd, src, size, 0); + if (n <= 0) { + return false; + } + size -= n; + src += n; + } + return true; +} + +static int MtmReadSocket(int sd, void* buf, int buf_size) +{ + int rc = recv(sd, buf, buf_size, 0); + if (rc <= 0) { + return -1; + } + return rc; +} + -static int MtmConnectSocket(char const* host, int port) +static int MtmConnectSocket(char const* host, int port, int max_attempts) { struct sockaddr_in sock_inet; unsigned addrs[MAX_ROUTES]; unsigned i, n_addrs = sizeof(addrs) / sizeof(addrs[0]); - int max_attempts = MAX_CONNECT_ATTEMPTS; int sd; sock_inet.sin_family = AF_INET; sock_inet.sin_port = htons(port); if (!MtmResolveHostByName(host, addrs, &n_addrs)) { - elog(ERROR, "Failed to resolve host '%s' by name", host); + elog(ERROR, "Arbiter failed to resolve host '%s' by name", host); } + Retry: sd = socket(AF_INET, SOCK_STREAM, 0); if (sd < 0) { - elog(ERROR, "Failed to create socket: %d", errno); + elog(ERROR, "Arbiter failed to create socket: %d", errno); } while (1) { int rc = -1; @@ -215,20 +258,34 @@ static int MtmConnectSocket(char const* host, int port) } if (rc < 0) { if ((errno != ENOENT && errno != ECONNREFUSED && errno != EINPROGRESS) || max_attempts == 0) { - elog(ERROR, "Arbiter failed to connect to %s:%d: %d", host, port, errno); + elog(WARNING, "Arbiter failed to connect to %s:%d: %d", host, port, errno); + return -1; } else { max_attempts -= 1; - sleep(1); + MtmSleep(MtmConnectTimeout); } continue; } else { int optval = 1; + MtmArbiterMessage msg; setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)); + + msg.code = MSG_HANDSHAKE; + msg.node = MtmNodeId; + msg.dxid = HANDSHAKE_MAGIC; + msg.sxid = ShmemVariableCache->nextXid; + msg.csn = MtmGetCurrentTime(); + if (!MtmWriteSocket(sd, &msg, sizeof msg)) { + elog(WARNING, "Arbiter failed to send handshake message to %s:%d: %d", host, port, errno); + close(sd); + goto Retry; + } return sd; } } } + static void MtmOpenConnections() { int nNodes = MtmNodes; @@ -236,6 +293,7 @@ static void MtmOpenConnections() char* connStr = pstrdup(MtmConnStrs); sockets = (int*)palloc(sizeof(int)*nNodes); + hosts = (char**)palloc(sizeof(char*)*nNodes); for (i = 0; i < nNodes; i++) { char* host = strstr(connStr, "host="); @@ -251,68 +309,97 @@ static void MtmOpenConnections() } else { connStr = end; } - sockets[i] = i+1 != MtmNodeId ? MtmConnectSocket(host, MtmArbiterPort + i + 1) : -1; + hosts[i] = host; + if (i+1 != MtmNodeId) { + sockets[i] = MtmConnectSocket(host, MtmArbiterPort + i + 1, MtmConnectAttempts); + if (sockets[i] < 0) { + MtmDropNode(i+1, false); + } + } else { + sockets[i] = -1; + } } } -static void MtmAcceptConnections() + +static bool MtmSendToNode(int node, void const* buf, int size) +{ + while (!MtmWriteSocket(sockets[node], buf, size)) { + elog(WARNING, "Arbiter failed to write socket: %d", errno); + close(sockets[node]); + sockets[node] = MtmConnectSocket(hosts[node], MtmArbiterPort + node + 1, MtmReconnectAttempts); + if (sockets[node] < 0) { + MtmDropNode(node+1, false); + return false; + } + } + return true; +} + +static int MtmReadFromNode(int node, void* buf, int buf_size) +{ + int rc = MtmReadSocket(sockets[node], buf, buf_size); + if (rc <= 0) { + elog(WARNING, "Arbiter failed to read from node=%d, rc=%d, errno=%d", node+1, rc, errno); + MtmDisconnect(node); + } + return rc; +} + +static void MtmAcceptOneConnection() +{ + int fd = accept(gateway, NULL, NULL); + if (fd < 0) { + elog(WARNING, "Arbiter failed to accept socket: %d", errno); + } else { + MtmArbiterMessage msg; + int rc = MtmReadSocket(fd, &msg, sizeof msg); + if (rc < sizeof(msg)) { + elog(WARNING, "Arbiter failed to handshake socket: %d, errno=%d", rc, errno); + } else if (msg.code != MSG_HANDSHAKE && msg.dxid != HANDSHAKE_MAGIC) { + elog(WARNING, "Arbiter get unexpected handshake message %d", msg.code); + close(fd); + } else{ + Assert(msg.node > 0 && msg.node <= MtmNodes && msg.node != MtmNodeId); + elog(NOTICE, "Arbiter established connection with node %d", msg.node); + MtmRegisterSocket(fd, msg.node-1); + sockets[msg.node-1] = fd; + } + } +} + + +static void MtmAcceptIncomingConnections() { struct sockaddr_in sock_inet; - int i; - int sd; int on = 1; - int nNodes = MtmNodes-1; + int i; - sockets = (int*)palloc(sizeof(int)*nNodes); + sockets = (int*)palloc(sizeof(int)*MtmNodes); sock_inet.sin_family = AF_INET; sock_inet.sin_addr.s_addr = htonl(INADDR_ANY); sock_inet.sin_port = htons(MtmArbiterPort + MtmNodeId); - sd = socket(sock_inet.sin_family, SOCK_STREAM, 0); - if (sd < 0) { - elog(ERROR, "Failed to create socket: %d", errno); + gateway = socket(sock_inet.sin_family, SOCK_STREAM, 0); + if (gateway < 0) { + elog(ERROR, "Arbiter failed to create socket: %d", errno); } - setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on); + setsockopt(gateway, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on); - if (bind(sd, (struct sockaddr*)&sock_inet, sizeof(sock_inet)) < 0) { - elog(ERROR, "Failed to bind socket: %d", errno); + if (bind(gateway, (struct sockaddr*)&sock_inet, sizeof(sock_inet)) < 0) { + elog(ERROR, "Arbiter failed to bind socket: %d", errno); } - if (listen(sd, MtmNodes-1) < 0) { - elog(ERROR, "Failed to listen socket: %d", errno); + if (listen(gateway, MtmNodes) < 0) { + elog(ERROR, "Arbiter failed to listen socket: %d", errno); } - for (i = 0; i < nNodes; i++) { - int fd = accept(sd, NULL, NULL); - if (fd < 0) { - elog(ERROR, "Failed to accept socket: %d", errno); - } - MtmRegisterSocket(fd, i); - sockets[i] = fd; - } - close(sd); -} + sockets[MtmNodeId-1] = gateway; + MtmRegisterSocket(gateway, MtmNodeId-1); -static void MtmWriteSocket(int sd, void const* buf, int size) -{ - char* src = (char*)buf; - while (size != 0) { - int n = send(sd, src, size, 0); - if (n <= 0) { - elog(ERROR, "Write socket failed: %d", errno); - } - size -= n; - src += n; - } -} - -static int MtmReadSocket(int sd, void* buf, int buf_size) -{ - int rc = recv(sd, buf, buf_size, 0); - if (rc <= 0) { - elog(ERROR, "Arbiter failed to read socket: %d", rc); + for (i = 0; i < MtmNodes-1; i++) { + MtmAcceptOneConnection(); } - return rc; } @@ -320,7 +407,10 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt { MtmBuffer* buf = &txBuffer[node]; if (buf->used == BUFFER_SIZE) { - MtmWriteSocket(sockets[node], buf->data, buf->used*sizeof(MtmCommitMessage)); + if (!MtmSendToNode(node, buf->data, buf->used*sizeof(MtmArbiterMessage))) { + buf->used = 0; + return; + } buf->used = 0; } MTM_TRACE("Send message %s CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", @@ -355,7 +445,6 @@ static void MtmTransSender(Datum arg) int i; MtmBuffer* txBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); - sockets = (int*)palloc(sizeof(int)*nNodes); ds = MtmGetState(); MtmOpenConnections(); @@ -371,7 +460,7 @@ static void MtmTransSender(Datum arg) /* * Use shared lock to improve locality, - * because all other process mnodifying this list use exclusive lock + * because all other process modifying this list are using exclusive lock */ MtmLock(LW_SHARED); @@ -388,7 +477,7 @@ static void MtmTransSender(Datum arg) for (i = 0; i < nNodes; i++) { if (txBuffer[i].used != 0) { - MtmWriteSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(MtmCommitMessage)); + MtmSendToNode(i, txBuffer[i].data, txBuffer[i].used*sizeof(MtmArbiterMessage)); txBuffer[i].used = 0; } } @@ -401,10 +490,36 @@ static void MtmWakeUpBackend(MtmTransState* ts) SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } +#if !USE_EPOLL +static bool MtmRecovery() +{ + int nNodes = MtmNodes; + bool recovered = false; + int i; + + for (i = 0; i < nNodes; i++) { + int sd = sockets[i]; + if (sd >= 0 && FD_ISSET(sd, &inset)) { + struct timeval tm = {0,0}; + fd_set tryset; + FD_ZERO(&tryset); + FD_SET(sd, &tryset); + if (select(sd+1, &tryset, NULL, NULL, &tm) < 0) { + elog(WARNING, "Arbiter lost connection with node %d", i+1); + MtmDisconnect(i); + recovered = true; + } + } + } + return recorvered; +} +#endif + static void MtmTransReceiver(Datum arg) { - int nNodes = MtmNodes-1; - int i, j, rc; + int nNodes = MtmNodes; + int nResponses; + int i, j, n, rc; MtmBuffer* rxBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); HTAB* xid2state; @@ -418,7 +533,7 @@ static void MtmTransReceiver(Datum arg) ds = MtmGetState(); - MtmAcceptConnections(); + MtmAcceptIncomingConnections(); xid2state = MtmCreateHash(); for (i = 0; i < nNodes; i++) { @@ -427,43 +542,53 @@ static void MtmTransReceiver(Datum arg) while (true) { #if USE_EPOLL - rc = epoll_wait(epollfd, events, nNodes, -1); - if (rc < 0) { - elog(ERROR, "epoll failed: %d", errno); + n = epoll_wait(epollfd, events, nNodes, -1); + if (n < 0) { + elog(ERROR, "Arbiter failed to poll sockets: %d", errno); } - for (j = 0; j < rc; j++) { + for (j = 0; j < n; j++) { i = events[j].data.u32; if (events[j].events & EPOLLERR) { - struct sockaddr_in insock; - socklen_t len = sizeof(insock); - getpeername(sockets[i], (struct sockaddr*)&insock, &len); - elog(WARNING, "Loose connection with %s", inet_ntoa(insock.sin_addr)); - epoll_ctl(epollfd, EPOLL_CTL_DEL, sockets[i], NULL); + elog(WARNING, "Arbiter lost connection with node %d", i+1); + MtmDisconnect(j); } else if (events[j].events & EPOLLIN) #else fd_set events; - events = inset; - rc = select(max_fd+1, &events, NULL, NULL, NULL); + do { + events = inset; + rc = select(max_fd+1, &events, NULL, NULL, NULL); + } while (rc < 0 && MtmRecovery()); + if (rc < 0) { - elog(ERROR, "select failed: %d", errno); + elog(ERROR, "Arbiter failed to select sockets: %d", errno); } for (i = 0; i < nNodes; i++) { if (FD_ISSET(sockets[i], &events)) #endif { - int nResponses; - rxBuffer[i].used += MtmReadSocket(sockets[i], (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBuffer[i].used); - nResponses = rxBuffer[i].used/sizeof(MtmCommitMessage); + if (i+1 == MtmNodeId) { + Assert(sockets[i] == gateway); + MtmAcceptOneConnection(); + continue; + } + + rc = MtmReadFromNode(i, (char*)rxBuffer[i].data + rxBuffer[i].used, BUFFER_SIZE-rxBuffer[i].used); + if (rc <= 0) { + continue; + } + + rxBuffer[i].used += rc; + nResponses = rxBuffer[i].used/sizeof(MtmArbiterMessage); MtmLock(LW_EXCLUSIVE); for (j = 0; j < nResponses; j++) { - MtmCommitMessage* msg = &rxBuffer[i].data[j]; + MtmArbiterMessage* msg = &rxBuffer[i].data[j]; MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); Assert(ts->cmd == MSG_INVALID); - Assert((unsigned)(msg->node-1) <= (unsigned)nNodes); + Assert(msg->node > 0 && msg->node <= nNodes && msg->node != MtmNodeId); ts->xids[msg->node-1] = msg->sxid; if (MtmIsCoordinator(ts)) { @@ -559,9 +684,9 @@ static void MtmTransReceiver(Datum arg) } MtmUnlock(); - rxBuffer[i].used -= nResponses*sizeof(MtmCommitMessage); + rxBuffer[i].used -= nResponses*sizeof(MtmArbiterMessage); if (rxBuffer[i].used != 0) { - memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(MtmCommitMessage), rxBuffer[i].used); + memmove(rxBuffer[i].data, (char*)rxBuffer[i].data + nResponses*sizeof(MtmArbiterMessage), rxBuffer[i].used); } } } diff --git a/multimaster.c b/multimaster.c index d8c5a45ca4..6c89b715be 100644 --- a/multimaster.c +++ b/multimaster.c @@ -65,8 +65,6 @@ typedef struct { /* #define USE_SPINLOCK 1 */ -typedef uint64 timestamp_t; - #define MTM_SHMEM_SIZE (64*1024*1024) #define MTM_HASH_SIZE 100003 #define USEC 1000000 @@ -128,6 +126,9 @@ char* MtmConnStrs; int MtmNodeId; int MtmArbiterPort; int MtmNodes; +int MtmConnectAttempts; +int MtmConnectTimeout; +int MtmReconnectAttempts; static int MtmQueueSize; static int MtmWorkers; @@ -166,19 +167,19 @@ void MtmUnlock(void) * System time manipulation functions */ -static timestamp_t MtmGetCurrentTime() +timestamp_t MtmGetCurrentTime(void) { struct timeval tv; gettimeofday(&tv, NULL); return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + dtm->timeShift; } -static void MtmSleep(timestamp_t interval) +void MtmSleep(timestamp_t interval) { struct timespec ts; struct timespec rem; - ts.tv_sec = 0; - ts.tv_nsec = interval*1000; + ts.tv_sec = interval/1000000; + ts.tv_nsec = interval%1000000*1000; while (nanosleep(&ts, &rem) < 0) { Assert(errno == EINTR); @@ -749,6 +750,52 @@ _PG_init(void) NULL ); + DefineCustomIntVariable( + "multimaster.connect_timeout", + "Multimaster nodes connect timeout", + "Interval in microseconds between connection attempts", + &MtmConnectTimeout, + 1000000, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomIntVariable( + "multimaster.connect_attempts", + "Multimaster number of connect attemts", + "Maximal number of attempt to establish connection with other node after which multimaster is give up", + &MtmConnectAttempts, + 10, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomIntVariable( + "multimaster.reconnect_attempts", + "Multimaster number of reconnect attemts", + "Maximal number of attempt to reestablish connection with other node after which node is considered to be offline", + &MtmReconnectAttempts, + 10, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + /* * Request additional shared resources. (These are no-ops if we're not in * the postmaster process.) We'll allocate or attach to the shared @@ -838,6 +885,28 @@ csn_t MtmTransactionSnapshot(TransactionId xid) return snapshot; } + +void MtmDropNode(int nodeId, bool dropSlot) +{ + if (!BIT_SET(dtm->disabledNodeMask, nodeId-1)) + { + if (nodeId <= 0 || nodeId > dtm->nNodes) + { + elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, dtm->nNodes); + } + dtm->disabledNodeMask |= ((int64)1 << (nodeId-1)); + dtm->nNodes -= 1; + if (!IsTransactionBlock()) + { + MtmBroadcastUtilityStmt(psprintf("select mtm.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); + } + if (dropSlot) + { + ReplicationSlotDrop(psprintf("mtm_slot_%d", nodeId)); + } + } +} + Datum mtm_start_replication(PG_FUNCTION_ARGS) { @@ -858,23 +927,7 @@ mtm_drop_node(PG_FUNCTION_ARGS) { int nodeId = PG_GETARG_INT32(0); bool dropSlot = PG_GETARG_BOOL(1); - if (!BIT_SET(dtm->disabledNodeMask, nodeId-1)) - { - if (nodeId <= 0 || nodeId > dtm->nNodes) - { - elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, dtm->nNodes); - } - dtm->disabledNodeMask |= ((int64)1 << (nodeId-1)); - dtm->nNodes -= 1; - if (!IsTransactionBlock()) - { - MtmBroadcastUtilityStmt(psprintf("select mtm.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); - } - if (dropSlot) - { - ReplicationSlotDrop(psprintf("mtm_slot_%d", nodeId)); - } - } + MtmDropNode(nodeId, dropSlot); PG_RETURN_VOID(); } diff --git a/multimaster.h b/multimaster.h index c2748df135..f32099c49a 100644 --- a/multimaster.h +++ b/multimaster.h @@ -26,6 +26,8 @@ typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) +typedef uint64 timestamp_t; + /* Identifier of global transaction */ typedef struct { @@ -36,6 +38,7 @@ typedef struct typedef enum { MSG_INVALID, + MSG_HANDSHAKE, MSG_READY, MSG_PREPARE, MSG_COMMIT, @@ -68,7 +71,7 @@ typedef struct MtmTransState typedef struct { volatile slock_t hashSpinlock; /* spinlock used to protect access to hash table */ - PGSemaphoreData votingSemaphore; /* semaphore used to notify mm-sender about new responses to coordinator */ + PGSemaphoreData votingSemaphore; /* semaphore used to notify mtm-sender about new responses to coordinator */ LWLockId hashLock; /* lock to synchronize access to hash table */ TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ int64 disabledNodeMask; /* bitmask of disable nodes (so no more than 64 nodes in multimaster:) */ @@ -78,7 +81,7 @@ typedef struct bool initialized; csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. - This list is used to pass information to mm-sender BGW */ + This list is used to pass information to mtm-sender BGW */ MtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. It is cleanup by MtmGetOldestXmin */ MtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. @@ -93,9 +96,12 @@ extern int MtmNodeId; extern int MtmNodes; extern int MtmArbiterPort; extern char* MtmDatabaseName; +extern int MtmConnectAttempts; +extern int MtmConnectTimeout; +extern int MtmReconnectAttempts; extern void MtmArbiterInitialize(void); -extern int MtmStartReceivers(char* nodes, int node_id); +extern int MtmStartReceivers(char* nodes, int nodeId); extern csn_t MtmTransactionSnapshot(TransactionId xid); extern csn_t MtmAssignCSN(void); extern csn_t MtmSyncClock(csn_t csn); @@ -108,6 +114,9 @@ extern void MtmSendNotificationMessage(MtmTransState* ts); extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); extern void MtmUnlock(void); +extern void MtmDropNode(int nodeId, bool dropSlot); extern MtmState* MtmGetState(void); +extern timestamp_t MtmGetCurrentTime(void); +extern void MtmSleep(timestamp_t interval); #endif From 4574fbd19161e043fdfffa99e21062e54ec675fe Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Sat, 20 Feb 2016 15:15:37 +0300 Subject: [PATCH 0263/1139] Keep data for disabled nodes --- arbiter.c | 11 ++++++++--- multimaster.c | 2 +- multimaster.h | 1 + pglogical_proto.c | 6 +++++- 4 files changed, 15 insertions(+), 5 deletions(-) diff --git a/arbiter.c b/arbiter.c index 3d36a8fe55..565c916c10 100644 --- a/arbiter.c +++ b/arbiter.c @@ -361,9 +361,14 @@ static void MtmAcceptOneConnection() close(fd); } else{ Assert(msg.node > 0 && msg.node <= MtmNodes && msg.node != MtmNodeId); - elog(NOTICE, "Arbiter established connection with node %d", msg.node); - MtmRegisterSocket(fd, msg.node-1); - sockets[msg.node-1] = fd; + if (BIT_SET(ds->disabledNodeMask, msg.node-1)) { + elog(WARNING, "Reject attempt to reconnect from disabled node %d", msg.node); + close(fd); + } else { + elog(NOTICE, "Arbiter established connection with node %d", msg.node); + MtmRegisterSocket(fd, msg.node-1); + sockets[msg.node-1] = fd; + } } } } diff --git a/multimaster.c b/multimaster.c index 6c89b715be..3d84ad47bd 100644 --- a/multimaster.c +++ b/multimaster.c @@ -902,7 +902,7 @@ void MtmDropNode(int nodeId, bool dropSlot) } if (dropSlot) { - ReplicationSlotDrop(psprintf("mtm_slot_%d", nodeId)); + ReplicationSlotDrop(psprintf(MULTIMASTER_SLOT_PATTERN, nodeId)); } } } diff --git a/multimaster.h b/multimaster.h index f32099c49a..8af67fec14 100644 --- a/multimaster.h +++ b/multimaster.h @@ -17,6 +17,7 @@ #define MULTIMASTER_NAME "mtm" #define MULTIMASTER_SCHEMA_NAME "mtm" #define MULTIMASTER_DDL_TABLE "ddl_log" +#define MULTIMASTER_SLOT_PATTERN "mtm_slot_%d" #define Natts_mtm_ddl_log 2 #define Anum_mtm_ddl_log_issued 1 diff --git a/pglogical_proto.c b/pglogical_proto.c index 126e9f964f..8eb9743727 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -39,6 +39,8 @@ typedef struct PGLogicalProtoMM { PGLogicalProtoAPI api; + MtmState* state; + int nodeId; bool isLocal; } PGLogicalProtoMM; @@ -106,7 +108,7 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; csn_t csn = MtmTransactionSnapshot(txn->xid); MTM_TRACE("pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); - if (csn == INVALID_CSN) { + if (csn == INVALID_CSN || BIT_SET(mm->state->disabledNodeMask, mm->nodeId-1)) { mm->isLocal = true; } else { mm->isLocal = false; @@ -377,6 +379,8 @@ pglogical_init_api(PGLogicalProtoType typ) PGLogicalProtoMM* pmm = palloc0(sizeof(PGLogicalProtoMM)); PGLogicalProtoAPI* res = &pmm->api; pmm->isLocal = false; + pmm->state = MtmGetState(); + sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &pmm->nodeId); res->write_rel = pglogical_write_rel; res->write_begin = pglogical_write_begin; res->write_commit = pglogical_write_commit; From b5da515e205cc2f6000e68b2f20ff9ebe3f1ef43 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Sat, 20 Feb 2016 19:54:46 +0300 Subject: [PATCH 0264/1139] Add KEEPALIVE --- arbiter.c | 1 + 1 file changed, 1 insertion(+) diff --git a/arbiter.c b/arbiter.c index 565c916c10..072ff0a4f5 100644 --- a/arbiter.c +++ b/arbiter.c @@ -269,6 +269,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) int optval = 1; MtmArbiterMessage msg; setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)); + setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (char const*)&optval, sizeof(optval)); msg.code = MSG_HANDSHAKE; msg.node = MtmNodeId; From 31594e521a480de114003bd190d9002409dddd37 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Tue, 23 Feb 2016 23:22:32 +0300 Subject: [PATCH 0265/1139] Update XTM documentation --- arbiter.c | 54 +++++++++++++++++++++++++++++++++++++------- multimaster.c | 54 ++++++++++++++++++++++++++++++-------------- multimaster.h | 37 ++++++++++++++++++++++-------- pglogical_proto.c | 2 +- pglogical_receiver.c | 46 +++++++++++++++++++++++-------------- 5 files changed, 141 insertions(+), 52 deletions(-) diff --git a/arbiter.c b/arbiter.c index 072ff0a4f5..015d527b06 100644 --- a/arbiter.c +++ b/arbiter.c @@ -83,6 +83,7 @@ typedef struct TransactionId dxid; /* Transaction ID at destination node */ TransactionId sxid; /* Transaction IO at sender node */ csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ + int64 disabledNodeMask; /* bitmask of disabled nodes at the sender of message */ } MtmArbiterMessage; typedef struct @@ -109,7 +110,8 @@ static char const* const messageText[] = "ABORT", "PREPARED", "COMMITTED", - "ABORTED" + "ABORTED", + "STATUS" }; @@ -276,11 +278,28 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) msg.dxid = HANDSHAKE_MAGIC; msg.sxid = ShmemVariableCache->nextXid; msg.csn = MtmGetCurrentTime(); + msg.disabledNodeMask = ds->disabledNodeMask; if (!MtmWriteSocket(sd, &msg, sizeof msg)) { elog(WARNING, "Arbiter failed to send handshake message to %s:%d: %d", host, port, errno); close(sd); goto Retry; } + if (MtmReadSocket(sd, &msg, sizeof msg) != sizeof(msg)) { + elog(WARNING, "Arbiter failed to receive response for handshake message from %s:%d: %d", host, port, errno); + close(sd); + goto Retry; + } + if (msg.code != MSG_STATUS || msg.dxid != HANDSHAKE_MAGIC) { + elog(WARNING, "Arbiter get unexpected response %d for handshake message from %s:%d: %d", msg.code, host, port, errno); + close(sd); + goto Retry; + } + + if (BIT_CHECK(msg.disabledNodeMask, MtmNodeId-1)) { + elog(WARNING, "Node is switched to recovery mode"); + ds->status = MTM_RECOVERY; + } + ds->disabledNodeMask = msg.disabledNodeMask; return sd; } } @@ -315,11 +334,16 @@ static void MtmOpenConnections() sockets[i] = MtmConnectSocket(host, MtmArbiterPort + i + 1, MtmConnectAttempts); if (sockets[i] < 0) { MtmDropNode(i+1, false); - } + } } else { sockets[i] = -1; } } + if (ds->nNodes < MtmNodes/2+1) { /* no quorum */ + ds->status = MTM_OFFLINE; + } else if (ds->status == MTM_INITIALIZATION) { + ds->status = MTM_CONNECTED; + } } @@ -362,8 +386,13 @@ static void MtmAcceptOneConnection() close(fd); } else{ Assert(msg.node > 0 && msg.node <= MtmNodes && msg.node != MtmNodeId); - if (BIT_SET(ds->disabledNodeMask, msg.node-1)) { - elog(WARNING, "Reject attempt to reconnect from disabled node %d", msg.node); + msg.code = MSG_STATUS; + msg.disabledNodeMask = ds->disabledNodeMask; + msg.dxid = HANDSHAKE_MAGIC; + msg.sxid = ShmemVariableCache->nextXid; + msg.csn = MtmGetCurrentTime(); + if (!MtmWriteSocket(fd, &msg, sizeof msg)) { + elog(WARNING, "Arbiter failed to write response for handshake message from node %d", msg.node); close(fd); } else { elog(NOTICE, "Arbiter established connection with node %d", msg.node); @@ -427,6 +456,7 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt buf->data[buf->used].sxid = ts->xid; buf->data[buf->used].csn = ts->csn; buf->data[buf->used].node = MtmNodeId; + buf->data[buf->used].disabledNodeMask = ds->disabledNodeMask; buf->used += 1; } @@ -659,12 +689,20 @@ static void MtmTransReceiver(Datum arg) switch (msg->code) { case MSG_PREPARE: Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - ts->status = TRANSACTION_STATUS_UNKNOWN; - ts->csn = MtmAssignCSN(); - ts->cmd = MSG_PREPARED; + if ((msg->disabledNodeMask & ~ds->disabledNodeMask) != 0) { + /* Coordinator's disabled mask is wider than my:so reject such transaction to avoid + commit on smaller subset of nodes */ + ts->status = TRANSACTION_STATUS_ABORTED; + ts->cmd = MSG_ABORT; + MtmAdjustSubtransactions(ts); + MtmWakeUpBackend(ts); + } else { + ts->status = TRANSACTION_STATUS_UNKNOWN; + ts->csn = MtmAssignCSN(); + ts->cmd = MSG_PREPARED; + } MtmSendNotificationMessage(ts); break; - break; case MSG_COMMIT: Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); Assert(ts->csn < msg->csn); diff --git a/multimaster.c b/multimaster.c index 3d84ad47bd..13b9e9e3a3 100644 --- a/multimaster.c +++ b/multimaster.c @@ -70,6 +70,7 @@ typedef struct { #define USEC 1000000 #define MIN_WAIT_TIMEOUT 1000 #define MAX_WAIT_TIMEOUT 100000 +#define STATUS_POLL_DELAY USEC void _PG_init(void); void _PG_fini(void); @@ -147,7 +148,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, void MtmLock(LWLockMode mode) { #ifdef USE_SPINLOCK - SpinLockAcquire(&dtm->hashSpinlock); + SpinLockAcquire(&dtm->spinlock); #else LWLockAcquire(dtm->hashLock, mode); #endif @@ -156,7 +157,7 @@ void MtmLock(LWLockMode mode) void MtmUnlock(void) { #ifdef USE_SPINLOCK - SpinLockRelease(&dtm->hashSpinlock); + SpinLockRelease(&dtm->spinlock); #else LWLockRelease(dtm->hashLock); #endif @@ -409,20 +410,22 @@ static void MtmInitialize() dtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState), &found); if (!found) { + dtm->status = MTM_INITIALIZATION; + dtm->recoverySlot = 0; dtm->hashLock = (LWLock*)GetNamedLWLockTranche(MULTIMASTER_NAME); dtm->csn = MtmGetCurrentTime(); dtm->oldestXid = FirstNormalTransactionId; dtm->nNodes = MtmNodes; dtm->disabledNodeMask = 0; + dtm->pglogicalNodeMask = 0; dtm->votingTransactions = NULL; dtm->transListHead = NULL; - dtm->transListTail = &dtm->transListHead; - pg_atomic_write_u32(&dtm->nReceivers, 0); + dtm->transListTail = &dtm->transListHead; + dtm->nReceivers = 0; dtm->timeShift = 0; - dtm->initialized = false; PGSemaphoreCreate(&dtm->votingSemaphore); PGSemaphoreReset(&dtm->votingSemaphore); - SpinLockInit(&dtm->hashSpinlock); + SpinLockInit(&dtm->spinlock); BgwPoolInit(&dtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); RegisterXactCallback(MtmXactCallback, NULL); dtmTx.snapshot = INVALID_CSN; @@ -463,7 +466,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) MtmLock(LW_EXCLUSIVE); x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; - x->isDistributed = IsNormalProcessingMode() && dtm->initialized && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); + x->isDistributed = IsNormalProcessingMode() && dtm->status == MTM_ONLINE && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); x->containsDML = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; @@ -575,8 +578,6 @@ MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi XidStatus prevStatus = TRANSACTION_STATUS_UNKNOWN; bool found; - Assert(status == TRANSACTION_STATUS_ABORTED); - MtmLock(LW_EXCLUSIVE); ts = hash_search(xid2state, &xid, HASH_ENTER, &found); if (!found) { @@ -590,7 +591,7 @@ MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi ts->status = status; MtmAdjustSubtransactions(ts); - if (prevStatus != TRANSACTION_STATUS_ABORTED) { + if (dtm->status != MTM_RECOVERY && prevStatus != TRANSACTION_STATUS_ABORTED) { ts->cmd = MSG_ABORTED; MtmSendNotificationMessage(ts); } @@ -607,7 +608,7 @@ MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, MTM_TRACE("%d: MtmSetTransactionStatus %u(%u) = %u, isDistributed=%d\n", getpid(), xid, dtmTx.xid, status, dtmTx.isDistributed); if (xid == dtmTx.xid && dtmTx.isDistributed) { - if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML) + if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML || dtm->status == MTM_RECOVERY) { MtmFinishTransaction(xid, nsubxids, subxids, status); MTM_TRACE("Finish transaction %d, status=%d, DML=%d\n", xid, status, dtmTx.containsDML); @@ -863,11 +864,17 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) dtmTx.containsDML = true; } -void MtmReceiverStarted() +void MtmReceiverStarted(int nodeId) { - if (pg_atomic_fetch_add_u32(&dtm->nReceivers, 1) == dtm->nNodes-2) { - dtm->initialized = true; + SpinLockAcquire(&dtm->spinlock); + if (!BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { + dtm->pglogicalNodeMask |= (int64)1 << (nodeId-1); + if (++dtm->nReceivers == dtm->nNodes-1) { + Assert(dtm->status == MTM_CONNECTED); + dtm->status = MTM_ONLINE; + } } + SpinLockRelease(&dtm->spinlock); } csn_t MtmTransactionSnapshot(TransactionId xid) @@ -885,10 +892,23 @@ csn_t MtmTransactionSnapshot(TransactionId xid) return snapshot; } - +MtmSlotMode MtmReceiverSlotMode(int nodeId) +{ + while (dtm->status != MTM_CONNECTED && dtm->status != MTM_ONLINE) { + if (dtm->status == MTM_RECOVERY) { + if (dtm->recoverySlot == 0 || dtm->recoverySlot == nodeId) { + dtm->recoverySlot = nodeId; + return SLOT_OPEN_EXISTED; + } + } + MtmSleep(STATUS_POLL_DELAY); + } + return dtm->recoverySlot ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; +} + void MtmDropNode(int nodeId, bool dropSlot) { - if (!BIT_SET(dtm->disabledNodeMask, nodeId-1)) + if (!BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) { if (nodeId <= 0 || nodeId > dtm->nNodes) { @@ -969,7 +989,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) p = conn_str_end; } *p = '\0'; - if (!BIT_SET(disabledNodeMask, i)) + if (!BIT_CHECK(disabledNodeMask, i)) { conns[i] = PQconnectdb(conn_str); if (PQstatus(conns[i]) != CONNECTION_OK) diff --git a/multimaster.h b/multimaster.h index 8af67fec14..2568139a04 100644 --- a/multimaster.h +++ b/multimaster.h @@ -12,7 +12,7 @@ #define MTM_TUPLE_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ -#define BIT_SET(mask, bit) ((mask) & ((int64)1 << (bit))) +#define BIT_CHECK(mask, bit) ((mask) & ((int64)1 << (bit))) #define MULTIMASTER_NAME "mtm" #define MULTIMASTER_SCHEMA_NAME "mtm" @@ -46,9 +46,25 @@ typedef enum MSG_ABORT, MSG_PREPARED, MSG_COMMITTED, - MSG_ABORTED + MSG_ABORTED, + MSG_STATUS } MtmMessageCode; +typedef enum +{ + MTM_INITIALIZATION, /* Initial status */ + MTM_OFFLINE, /* Node is out of quorum */ + MTM_CONNECTED, /* Arbiter is established connections with other nodes */ + MTM_ONLINE, /* Ready to receive client's queries */ + MTM_RECOVERY /* Node is in recovery process */ +} MtmNodeStatus; + +typedef enum +{ + SLOT_CREATE_NEW, /* create new slot (drop existed) */ + SLOT_OPEN_EXISTED, /* open existed slot */ + SLOT_OPEN_ALWAYS, /* open existed slot or create new if noty exists */ +} MtmSlotMode; typedef struct MtmTransState { @@ -71,16 +87,18 @@ typedef struct MtmTransState typedef struct { - volatile slock_t hashSpinlock; /* spinlock used to protect access to hash table */ + MtmNodeStatus status; /* Status of this node */ + int recoverySlot; /* NodeId of recovery slot or 0 if none */ + volatile slock_t spinlock; /* spinlock used to protect access to hash table */ PGSemaphoreData votingSemaphore; /* semaphore used to notify mtm-sender about new responses to coordinator */ LWLockId hashLock; /* lock to synchronize access to hash table */ TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ - int64 disabledNodeMask; /* bitmask of disable nodes (so no more than 64 nodes in multimaster:) */ + int64 disabledNodeMask; /* bitmask of disabled nodes (so no more than 64 nodes in multimaster:) */ + int64 pglogicalNodeMask; /* bitmask of started pglogic receviers */ int nNodes; /* number of active nodes */ - pg_atomic_uint32 nReceivers; /* number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ - long timeShift; /* local time correction */ - bool initialized; - csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ + int nReceivers; /* number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ + long timeShift; /* local time correction */ + csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. This list is used to pass information to mtm-sender BGW */ MtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. @@ -107,7 +125,8 @@ extern csn_t MtmTransactionSnapshot(TransactionId xid); extern csn_t MtmAssignCSN(void); extern csn_t MtmSyncClock(csn_t csn); extern void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t snapshot); -extern void MtmReceiverStarted(void); +extern void MtmReceiverStarted(int nodeId); +extern MtmSlotMode MtmReceiverSlotMode(int nodeId); extern void MtmExecute(void* work, int size); extern void MtmExecutor(int id, void* work, size_t size); extern HTAB* MtmCreateHash(void); diff --git a/pglogical_proto.c b/pglogical_proto.c index 8eb9743727..a6eb05e520 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -108,7 +108,7 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; csn_t csn = MtmTransactionSnapshot(txn->xid); MTM_TRACE("pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); - if (csn == INVALID_CSN || BIT_SET(mm->state->disabledNodeMask, mm->nodeId-1)) { + if (csn == INVALID_CSN || BIT_CHECK(mm->state->disabledNodeMask, mm->nodeId-1)) { mm->isLocal = true; } else { mm->isLocal = false; diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 7dc9959d38..8d93205e29 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -37,6 +37,7 @@ /* Allow load of this module in shared libs */ typedef struct ReceiverArgs { + int receiver_node; char* receiver_conn_string; char receiver_slot[16]; } ReceiverArgs; @@ -201,6 +202,7 @@ pglogical_receiver_main(Datum main_arg) PQExpBuffer query; PGconn *conn; PGresult *res; + MtmSlotMode mode; #ifndef USE_PGLOGICAL_OUTPUT bool insideTrans = false; #endif @@ -218,6 +220,8 @@ pglogical_receiver_main(Datum main_arg) /* Connect to a database */ BackgroundWorkerInitializeConnection(MtmDatabaseName, NULL); + mode = MtmReceiverSlotMode(args->receiver_node); + /* Establish connection to remote server */ conn = PQconnectdb(args->receiver_conn_string); if (PQstatus(conn) != CONNECTION_OK) @@ -230,22 +234,29 @@ pglogical_receiver_main(Datum main_arg) query = createPQExpBuffer(); - appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"", args->receiver_slot, worker_name); - res = PQexec(conn, query->data); - if (PQresultStatus(res) != PGRES_TUPLES_OK) - { - const char *sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE); - if (!sqlstate || strcmp(sqlstate, ERRCODE_DUPLICATE_OBJECT_STR) != 0) + if (mode == SLOT_CREATE_NEW) { + appendPQExpBuffer(query, "DROP_REPLICATION_SLOT \"%s\"", args->receiver_slot); + res = PQexec(conn, query->data); + PQclear(res); + resetPQExpBuffer(query); + } + if (mode != SLOT_OPEN_EXISTED) { + appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"", args->receiver_slot, worker_name); + res = PQexec(conn, query->data); + if (PQresultStatus(res) != PGRES_TUPLES_OK) { - PQclear(res); - ereport(ERROR, (errmsg("%s: Could not create logical slot", - worker_proc))); - proc_exit(1); - } - } - PQclear(res); - resetPQExpBuffer(query); - + const char *sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE); + if (!sqlstate || strcmp(sqlstate, ERRCODE_DUPLICATE_OBJECT_STR) != 0) + { + PQclear(res); + ereport(ERROR, (errmsg("%s: Could not create logical slot", + worker_proc))); + proc_exit(1); + } + } + PQclear(res); + resetPQExpBuffer(query); + } /* Start logical replication at specified position */ appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL 0/0 (\"startup_params_format\" '1', \"max_proto_version\" '1', \"min_proto_version\" '1')", args->receiver_slot); @@ -260,7 +271,7 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); resetPQExpBuffer(query); - MtmReceiverStarted(); + MtmReceiverStarted(args->receiver_node); ByteBufferAlloc(&buf); while (!got_sigterm) @@ -544,7 +555,8 @@ int MtmStartReceivers(char* conns, int node_id) } ctx->receiver_conn_string = psprintf("replication=database %.*s", (int)(p - conn_str), conn_str); sprintf(ctx->receiver_slot, "mtm_slot_%d", node_id); - + ctx->receiver_node = node_id; + /* Worker parameter and registration */ snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_worker_%d_%d", node_id, i); From c83f738fed48da2fd7a632c2d68a18f56b6e58d1 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 24 Feb 2016 20:31:13 +0300 Subject: [PATCH 0266/1139] Switch from recovery to normal mode --- multimaster.c | 64 ++++++++++++++++++++++++++++++++++++++++---- multimaster.h | 18 ++++++++----- pglogical_apply.c | 2 ++ pglogical_proto.c | 1 + pglogical_receiver.c | 16 ++++++++--- 5 files changed, 86 insertions(+), 15 deletions(-) diff --git a/multimaster.c b/multimaster.c index 13b9e9e3a3..85d40f19b9 100644 --- a/multimaster.c +++ b/multimaster.c @@ -60,11 +60,19 @@ typedef struct { bool isReplicated; /* transaction on replica */ bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ bool containsDML; /* transaction contains DML statements */ + bool isPrepared; /* transaction was prepared for commit */ csn_t snapshot; /* transaction snaphsot */ } MtmCurrentTrans; /* #define USE_SPINLOCK 1 */ +typedef enum +{ + HASH_LOCK_ID, + COMMIT_LOCK_ID, + N_LOCKS +} MtmLockIds; + #define MTM_SHMEM_SIZE (64*1024*1024) #define MTM_HASH_SIZE 100003 #define USEC 1000000 @@ -150,7 +158,7 @@ void MtmLock(LWLockMode mode) #ifdef USE_SPINLOCK SpinLockAcquire(&dtm->spinlock); #else - LWLockAcquire(dtm->hashLock, mode); + LWLockAcquire(dtm->locks[HASH_LOCK_ID], mode); #endif } @@ -159,7 +167,7 @@ void MtmUnlock(void) #ifdef USE_SPINLOCK SpinLockRelease(&dtm->spinlock); #else - LWLockRelease(dtm->hashLock); + LWLockRelease(dtm->locks[HASH_LOCK_ID]); #endif } @@ -412,7 +420,7 @@ static void MtmInitialize() { dtm->status = MTM_INITIALIZATION; dtm->recoverySlot = 0; - dtm->hashLock = (LWLock*)GetNamedLWLockTranche(MULTIMASTER_NAME); + dtm->locks = GetNamedLWLockTranche(MULTIMASTER_NAME); dtm->csn = MtmGetCurrentTime(); dtm->oldestXid = FirstNormalTransactionId; dtm->nNodes = MtmNodes; @@ -423,6 +431,7 @@ static void MtmInitialize() dtm->transListTail = &dtm->transListHead; dtm->nReceivers = 0; dtm->timeShift = 0; + pg_atomic_write_u32(&dtm->nCommittingTrans, 0); PGSemaphoreCreate(&dtm->votingSemaphore); PGSemaphoreReset(&dtm->votingSemaphore); SpinLockInit(&dtm->spinlock); @@ -467,6 +476,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; x->isDistributed = IsNormalProcessingMode() && dtm->status == MTM_ONLINE && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); + x->isPrepared = false; x->containsDML = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; @@ -476,6 +486,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) } } + /* * We need to pass snapshot to WAL-sender, so create record in transaction status hash table * before commit @@ -488,8 +499,14 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) if (!x->isDistributed) { return; } - x->xid = GetCurrentTransactionId(); + /* Check that commits are not disabled */ + LWLockAcquire(dtm->locks[COMMIT_LOCK_ID], LW_SHARED); + LWLockRelease(dtm->locks[COMMIT_LOCK_ID]); + pg_atomic_fetch_add_u32(dtm->nCommittingTransactions, 1); + x->isPrepared = true; + x->xid = GetCurrentTransactionId(); + MtmLock(LW_EXCLUSIVE); ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); ts->status = TRANSACTION_STATUS_IN_PROGRESS; @@ -500,6 +517,7 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) ts->procno = MyProc->pgprocno; ts->nVotes = 0; ts->done = false; + if (TransactionIdIsValid(x->gtid.xid)) { ts->gtid = x->gtid; } else { @@ -528,6 +546,9 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) MtmAdjustSubtransactions(ts); MtmUnlock(); } + if (x->isPrepared) { + pg_atomic_fetch_add_u32(dtm->nCommittingTransactions, -1); + } x->snapshot = INVALID_CSN; x->xid = InvalidTransactionId; x->gtid.xid = InvalidTransactionId; @@ -547,6 +568,39 @@ void MtmSendNotificationMessage(MtmTransState* ts) } } +void MtmUpdateStatus(bool recovered) +{ + if (dtm->status == MTM_RECOVERY) { + MtmLock(LW_EXCLUSIVE); + dtm->status = MTM_ONLINE; /* Is it all we shoudl do t switch to nortmal state */ + MtmUnlock(); + } +} + +void MtmRecoveryCompleted(int nodeId) +{ + if (BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { + if (MyWalSnd->sentPtr == GetXLogInsertRecPtr()) { + /* Ok, now we done with recovery of node */ + MtmLock(LW_EXCLUSIVE); + dtm->pglogicalNodeMask &= (int64)1 << (nodeId-1); /* now node is assumed as recovered */ + dtm->nNodes += 1; + MtmUnlock(); + + LWLockRelease(dtm->locks[COMMIT_LOCK_ID]); /* enable commits */ + + return true; + } else if (MyWalSnd->sentPtr + MtmSlotDelayThreashold > GetXLogInsertRecPtr()) { + /* we almost done with recovery of node.. */ + LWLockAcquire(dtm->locks[COMMIT_LOCK_ID], LW_EXCLUSIVE); /* disable new commits */ + } + return false; + } else { + return true; + } +} + + static bool MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { @@ -803,7 +857,7 @@ _PG_init(void) * resources in mtm_shmem_startup(). */ RequestAddinShmemSpace(MTM_SHMEM_SIZE + MtmQueueSize); - RequestNamedLWLockTranche(MULTIMASTER_NAME, 1); + RequestNamedLWLockTranche(MULTIMASTER_NAME, N_LOCKS); MtmNodes = MtmStartReceivers(MtmConnStrs, MtmNodeId); if (MtmNodes < 2) { diff --git a/multimaster.h b/multimaster.h index 2568139a04..b8c3aa87f8 100644 --- a/multimaster.h +++ b/multimaster.h @@ -14,10 +14,12 @@ #define BIT_CHECK(mask, bit) ((mask) & ((int64)1 << (bit))) -#define MULTIMASTER_NAME "mtm" -#define MULTIMASTER_SCHEMA_NAME "mtm" -#define MULTIMASTER_DDL_TABLE "ddl_log" -#define MULTIMASTER_SLOT_PATTERN "mtm_slot_%d" +#define MULTIMASTER_NAME "mtm" +#define MULTIMASTER_SCHEMA_NAME "mtm" +#define MULTIMASTER_DDL_TABLE "ddl_log" +#define MULTIMASTER_SLOT_PATTERN "mtm_slot_%d" +#define MULTIMASTER_MIN_PROTO_VERSION 1 +#define MULTIMASTER_MAX_PROTO_VERSION 1 #define Natts_mtm_ddl_log 2 #define Anum_mtm_ddl_log_issued 1 @@ -91,7 +93,7 @@ typedef struct int recoverySlot; /* NodeId of recovery slot or 0 if none */ volatile slock_t spinlock; /* spinlock used to protect access to hash table */ PGSemaphoreData votingSemaphore; /* semaphore used to notify mtm-sender about new responses to coordinator */ - LWLockId hashLock; /* lock to synchronize access to hash table */ + LWLockPadded *locks; /* multimaster lock tranche */ TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ int64 disabledNodeMask; /* bitmask of disabled nodes (so no more than 64 nodes in multimaster:) */ int64 pglogicalNodeMask; /* bitmask of started pglogic receviers */ @@ -99,6 +101,7 @@ typedef struct int nReceivers; /* number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ long timeShift; /* local time correction */ csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ + pg_atomic_uint32 nCommittingTrans; /* nubmer of transactions i process of commit */ MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. This list is used to pass information to mtm-sender BGW */ MtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. @@ -137,6 +140,7 @@ extern void MtmUnlock(void); extern void MtmDropNode(int nodeId, bool dropSlot); extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); -extern void MtmSleep(timestamp_t interval); - +extern void MtmSleep(timestamp_t interval); +extern void MtmRecoveryCompleted(int nodeId); +extern void MtmUpdateStatus(bool recovered); #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index fa1cbb097e..6d42103c39 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -466,7 +466,9 @@ read_rel(StringInfo s, LOCKMODE mode) static void process_remote_commit(StringInfo s) { + bool recovered = pq_getmsgbyte(s); CommitTransactionCommand(); + MtmUpdateStatus(recovered); } static void diff --git a/pglogical_proto.c b/pglogical_proto.c index a6eb05e520..b7cac278ce 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -129,6 +129,7 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; if (!mm->isLocal) { pq_sendbyte(out, 'C'); /* sending COMMIT */ + pq_sendbyte(out, MtmRecoveryCompleted(mm->nodeId)); } } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 8d93205e29..61a9b3e118 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -31,6 +31,7 @@ #include "utils/guc.h" #include "utils/snapmgr.h" #include "executor/spi.h" +#include "replication/origin.h" #include "multimaster.h" @@ -203,10 +204,12 @@ pglogical_receiver_main(Datum main_arg) PGconn *conn; PGresult *res; MtmSlotMode mode; + MtmState* ds; #ifndef USE_PGLOGICAL_OUTPUT bool insideTrans = false; #endif ByteBuffer buf; + XLogRecPtr originStartPos; /* Register functions for SIGTERM/SIGHUP management */ pqsignal(SIGHUP, receiver_raw_sighup); @@ -258,8 +261,14 @@ pglogical_receiver_main(Datum main_arg) resetPQExpBuffer(query); } /* Start logical replication at specified position */ - appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL 0/0 (\"startup_params_format\" '1', \"max_proto_version\" '1', \"min_proto_version\" '1')", - args->receiver_slot); + originStartPos = replorigin_session_get_progress(false); + appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d')", + args->receiver_slot, + (uint32) (originStartPos >> 32), + (uint32) originStartPos, + MULTIMASTER_MAX_PROTO_VERSION, + MULTIMASTER_MIN_PROTO_VERSION + ); res = PQexec(conn, query->data); if (PQresultStatus(res) != PGRES_COPY_BOTH) { @@ -273,6 +282,7 @@ pglogical_receiver_main(Datum main_arg) MtmReceiverStarted(args->receiver_node); ByteBufferAlloc(&buf); + ds = MtmGetState(); while (!got_sigterm) { @@ -366,7 +376,7 @@ pglogical_receiver_main(Datum main_arg) * If sync mode is sent reply in all cases to ensure that * server knows how far replay has been done. */ - if (replyRequested || receiver_sync_mode) + if (replyRequested || receiver_sync_mode || ds->status == MTM_RECOVERY) { int64 now = feGetCurrentTimestamp(); From 37df65ebcdd42c8d52eb30bf07957a8ec3ff72ba Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 25 Feb 2016 18:44:53 +0300 Subject: [PATCH 0267/1139] Add switch from recovery to normal mode --- arbiter.c | 2 +- multimaster.c | 138 ++++++++++++++++++++++++++++++++-------------- multimaster.h | 14 +++-- pglogical_apply.c | 2 - pglogical_proto.c | 8 +-- 5 files changed, 110 insertions(+), 54 deletions(-) diff --git a/arbiter.c b/arbiter.c index 015d527b06..d528f01909 100644 --- a/arbiter.c +++ b/arbiter.c @@ -83,7 +83,7 @@ typedef struct TransactionId dxid; /* Transaction ID at destination node */ TransactionId sxid; /* Transaction IO at sender node */ csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ - int64 disabledNodeMask; /* bitmask of disabled nodes at the sender of message */ + nodemask_t disabledNodeMask; /* bitmask of disabled nodes at the sender of message */ } MtmArbiterMessage; typedef struct diff --git a/multimaster.c b/multimaster.c index 85d40f19b9..9b433b13a7 100644 --- a/multimaster.c +++ b/multimaster.c @@ -45,6 +45,7 @@ #include "storage/proc.h" #include "utils/syscache.h" #include "replication/walsender.h" +#include "replication/walsender_private.h" #include "replication/slot.h" #include "port/atomics.h" #include "tcop/utility.h" @@ -60,7 +61,6 @@ typedef struct { bool isReplicated; /* transaction on replica */ bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ bool containsDML; /* transaction contains DML statements */ - bool isPrepared; /* transaction was prepared for commit */ csn_t snapshot; /* transaction snaphsot */ } MtmCurrentTrans; @@ -68,8 +68,7 @@ typedef struct { typedef enum { - HASH_LOCK_ID, - COMMIT_LOCK_ID, + MTM_STATE_LOCK_ID, N_LOCKS } MtmLockIds; @@ -142,6 +141,7 @@ int MtmReconnectAttempts; static int MtmQueueSize; static int MtmWorkers; static int MtmVacuumDelay; +static int MtmMinRecoveryLag; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -158,7 +158,7 @@ void MtmLock(LWLockMode mode) #ifdef USE_SPINLOCK SpinLockAcquire(&dtm->spinlock); #else - LWLockAcquire(dtm->locks[HASH_LOCK_ID], mode); + LWLockAcquire((LWLockId)&dtm->locks[MTM_STATE_LOCK_ID], mode); #endif } @@ -167,7 +167,7 @@ void MtmUnlock(void) #ifdef USE_SPINLOCK SpinLockRelease(&dtm->spinlock); #else - LWLockRelease(dtm->locks[HASH_LOCK_ID]); + LWLockRelease((LWLockId)&dtm->locks[MTM_STATE_LOCK_ID]); #endif } @@ -426,12 +426,14 @@ static void MtmInitialize() dtm->nNodes = MtmNodes; dtm->disabledNodeMask = 0; dtm->pglogicalNodeMask = 0; + dtm->walSenderLockerMask = 0; + dtm->nodeLockerMask = 0; + dtm->nLockers = 0; dtm->votingTransactions = NULL; dtm->transListHead = NULL; dtm->transListTail = &dtm->transListHead; dtm->nReceivers = 0; dtm->timeShift = 0; - pg_atomic_write_u32(&dtm->nCommittingTrans, 0); PGSemaphoreCreate(&dtm->votingSemaphore); PGSemaphoreReset(&dtm->votingSemaphore); SpinLockInit(&dtm->spinlock); @@ -476,7 +478,6 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; x->isDistributed = IsNormalProcessingMode() && dtm->status == MTM_ONLINE && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); - x->isPrepared = false; x->containsDML = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; @@ -487,6 +488,53 @@ MtmBeginTransaction(MtmCurrentTrans* x) } +/* This function is called at transaction start with multimaster ock set */ +static void +MtmCheckClusterLock() +{ + while (true) + { + nodemask_t mask = dtm->walSenderLockerMask; + if (mask != 0) { + XLogRecPtr currLogPos = GetXLogInsertRecPtr(); + int i; + timestamp_t delay = MIN_WAIT_TIMEOUT; + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + if (WalSndCtl->walsnds[i].sentPtr != currLogPos) { + /* recovery is in progress */ + break; + } else { + /* recovered replica catched up with master */ + dtm->walSenderLockerMask &= ~((nodemask_t)1 << i); + } + } + } + if (mask != 0) { + /* some "almost catch-up" wal-senders are still working */ + /* Do not start new transactions until them complete */ + MtmUnlock(); + MtmSleep(delay); + if (delay*2 <= MAX_WAIT_TIMEOUT) { + delay *= 2; + } + MtmLock(LW_EXCLUSIVE); + continue; + } else { + /* All lockers are synchronized their logs */ + /* Remove lock and mark them as receovered */ + Assert(dtm->walSenderLockerMask == 0); + Assert((dtm->nodeLockerMask & dtm->disabledNodeMask) == dtm->nodeLockerMask); + dtm->disabledNodeMask &= ~dtm->nodeLockerMask; + dtm->nNodes += dtm->nLockers; + dtm->nLockers = 0; + dtm->nodeLockerMask = 0; + } + } + break; + } +} + /* * We need to pass snapshot to WAL-sender, so create record in transaction status hash table * before commit @@ -499,15 +547,12 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) if (!x->isDistributed) { return; } - /* Check that commits are not disabled */ - LWLockAcquire(dtm->locks[COMMIT_LOCK_ID], LW_SHARED); - LWLockRelease(dtm->locks[COMMIT_LOCK_ID]); - pg_atomic_fetch_add_u32(dtm->nCommittingTransactions, 1); - x->isPrepared = true; x->xid = GetCurrentTransactionId(); MtmLock(LW_EXCLUSIVE); + MtmCheckClusterLock(); + ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); ts->status = TRANSACTION_STATUS_IN_PROGRESS; ts->snapshot = x->isReplicated || !x->containsDML ? INVALID_CSN : x->snapshot; @@ -546,9 +591,6 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) MtmAdjustSubtransactions(ts); MtmUnlock(); } - if (x->isPrepared) { - pg_atomic_fetch_add_u32(dtm->nCommittingTransactions, -1); - } x->snapshot = INVALID_CSN; x->xid = InvalidTransactionId; x->gtid.xid = InvalidTransactionId; @@ -568,39 +610,29 @@ void MtmSendNotificationMessage(MtmTransState* ts) } } -void MtmUpdateStatus(bool recovered) -{ - if (dtm->status == MTM_RECOVERY) { - MtmLock(LW_EXCLUSIVE); - dtm->status = MTM_ONLINE; /* Is it all we shoudl do t switch to nortmal state */ - MtmUnlock(); - } -} - -void MtmRecoveryCompleted(int nodeId) +/* + * This function is called by WAL sender when start sending new transaction + */ +bool MtmIsRecoveredNode(int nodeId) { - if (BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { - if (MyWalSnd->sentPtr == GetXLogInsertRecPtr()) { - /* Ok, now we done with recovery of node */ + if (BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) { + Assert(MyWalSnd != NULL); + if (!BIT_CHECK(dtm->nodeLockerMask, nodeId-1) + && MyWalSnd->sentPtr + MtmMinRecoveryLag > GetXLogInsertRecPtr()) + { + /* Wal sender almost catched up */ + /* Lock cluster preventing new transaction to start until wal is completely replayed */ MtmLock(LW_EXCLUSIVE); - dtm->pglogicalNodeMask &= (int64)1 << (nodeId-1); /* now node is assumed as recovered */ - dtm->nNodes += 1; + dtm->nodeLockerMask |= (nodemask_t)1 << (nodeId-1); + dtm->walSenderLockerMask |= (nodemask_t)1 << (MyWalSnd - WalSndCtl->walsnds); + dtm->nLockers += 1; MtmUnlock(); - - LWLockRelease(dtm->locks[COMMIT_LOCK_ID]); /* enable commits */ - - return true; - } else if (MyWalSnd->sentPtr + MtmSlotDelayThreashold > GetXLogInsertRecPtr()) { - /* we almost done with recovery of node.. */ - LWLockAcquire(dtm->locks[COMMIT_LOCK_ID], LW_EXCLUSIVE); /* disable new commits */ } - return false; - } else { return true; } + return false; } - static bool MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) { @@ -717,6 +749,21 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.min_recovery_lag", + "Minamal lag of WAL-sender performing recovery after which cluster is locked until recovery is completed", + NULL, + &MtmMinRecoveryLag, + 100000, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.vacuum_delay", "Minimal age of records which can be vacuumed (seconds)", @@ -897,6 +944,12 @@ _PG_fini(void) * *************************************************************************** */ +static void MtmSwitchFromRecoveryToNormalMode() +{ + dtm->status = MTM_ONLINE; + /* ??? Something else to do here? */ +} + void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { csn_t localSnapshot; @@ -910,6 +963,11 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) elog(ERROR, "Too old snapshot: requested %ld, current %ld", globalSnapshot, localSnapshot); } + if (!TransactionIdIsValid(gtid->xid)) { + Assert(dtm->status == MTM_RECOVERY); + } else if (dtm->status == MTM_RECOVERY) { + MtmSwitchFromRecoveryToNormalMode(); + } dtmTx.gtid = *gtid; dtmTx.xid = GetCurrentTransactionId(); dtmTx.snapshot = globalSnapshot; diff --git a/multimaster.h b/multimaster.h index b8c3aa87f8..8026513f82 100644 --- a/multimaster.h +++ b/multimaster.h @@ -12,7 +12,7 @@ #define MTM_TUPLE_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ -#define BIT_CHECK(mask, bit) ((mask) & ((int64)1 << (bit))) +#define BIT_CHECK(mask, bit) (((mask) & ((nodemask_t)1 << (bit))) != 0) #define MULTIMASTER_NAME "mtm" #define MULTIMASTER_SCHEMA_NAME "mtm" @@ -30,6 +30,7 @@ typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) typedef uint64 timestamp_t; +typedef uint64_t nodemask_t; /* Identifier of global transaction */ typedef struct @@ -95,13 +96,15 @@ typedef struct PGSemaphoreData votingSemaphore; /* semaphore used to notify mtm-sender about new responses to coordinator */ LWLockPadded *locks; /* multimaster lock tranche */ TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ - int64 disabledNodeMask; /* bitmask of disabled nodes (so no more than 64 nodes in multimaster:) */ - int64 pglogicalNodeMask; /* bitmask of started pglogic receviers */ + nodemask_t disabledNodeMask; /* bitmask of disabled nodes (so no more than 64 nodes in multimaster:) */ + nodemask_t pglogicalNodeMask; /* bitmask of started pglogic receivers */ + nodemask_t walSenderLockerMask; /* Mask of WAL-senders IDs locking the cluster */ + nodemask_t nodeLockerMask; /* Mask of node IDs which WAL-senders are locking the cluster */ int nNodes; /* number of active nodes */ int nReceivers; /* number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ + int nLockers; /* number of lockers */ long timeShift; /* local time correction */ csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ - pg_atomic_uint32 nCommittingTrans; /* nubmer of transactions i process of commit */ MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. This list is used to pass information to mtm-sender BGW */ MtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. @@ -141,6 +144,5 @@ extern void MtmDropNode(int nodeId, bool dropSlot); extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); -extern void MtmRecoveryCompleted(int nodeId); -extern void MtmUpdateStatus(bool recovered); +extern bool MtmIsRecoveredNode(int nodeId); #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index 6d42103c39..fa1cbb097e 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -466,9 +466,7 @@ read_rel(StringInfo s, LOCKMODE mode) static void process_remote_commit(StringInfo s) { - bool recovered = pq_getmsgbyte(s); CommitTransactionCommand(); - MtmUpdateStatus(recovered); } static void diff --git a/pglogical_proto.c b/pglogical_proto.c index b7cac278ce..824ffbd4c0 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -39,7 +39,6 @@ typedef struct PGLogicalProtoMM { PGLogicalProtoAPI api; - MtmState* state; int nodeId; bool isLocal; } PGLogicalProtoMM; @@ -107,14 +106,15 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, { PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; csn_t csn = MtmTransactionSnapshot(txn->xid); + bool isRecovery = MtmIsRecoveredNode(mm->nodeId); MTM_TRACE("pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); - if (csn == INVALID_CSN || BIT_CHECK(mm->state->disabledNodeMask, mm->nodeId-1)) { + if (csn == INVALID_CSN && !isRecovery) { mm->isLocal = true; } else { mm->isLocal = false; pq_sendbyte(out, 'B'); /* BEGIN */ pq_sendint(out, MtmNodeId, 4); - pq_sendint(out, txn->xid, 4); + pq_sendint(out, isRecovery ? InvalidTransactionId : txn->xid, 4); pq_sendint64(out, csn); } } @@ -129,7 +129,6 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; if (!mm->isLocal) { pq_sendbyte(out, 'C'); /* sending COMMIT */ - pq_sendbyte(out, MtmRecoveryCompleted(mm->nodeId)); } } @@ -380,7 +379,6 @@ pglogical_init_api(PGLogicalProtoType typ) PGLogicalProtoMM* pmm = palloc0(sizeof(PGLogicalProtoMM)); PGLogicalProtoAPI* res = &pmm->api; pmm->isLocal = false; - pmm->state = MtmGetState(); sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &pmm->nodeId); res->write_rel = pglogical_write_rel; res->write_begin = pglogical_write_begin; From f5abea5cad6b646c06de6de6f03a43b0f0da5080 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 27 Feb 2016 00:05:46 +0300 Subject: [PATCH 0268/1139] Add MtmMaxRecoveryLag --- multimaster.c | 46 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 9b433b13a7..b4ae102755 100644 --- a/multimaster.c +++ b/multimaster.c @@ -142,6 +142,7 @@ static int MtmQueueSize; static int MtmWorkers; static int MtmVacuumDelay; static int MtmMinRecoveryLag; +static int MtmMaxRecoveryLag; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -579,6 +580,29 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", getpid(), x->xid, ts->csn); } +static void MtmCheckSlots() +{ + if (MtmMaxRecoveryLag != 0 && dtm->disabledNodeMask != 0) + { + int i; + for (i = 0; i < max_replication_slots; i++) { + ReplicationSlot* slot = &ReplicationSlotCtl->replication_slots[i]; + int nodeId; + if (slot->in_use + && sscanf(slot->data.name.data, MULTIMASTER_SLOT_PATTERN, &nodeId) == 1 + && BIT_CHECK(dtm->disabledNodeMask, nodeId-1) + && slot->data.restart_lsn + MtmMaxRecoveryLag < GetXLogInsertRecPtr()) + { + elog(WARNING, "Drop slot for node %d which lag %ld is larger than threshold %d", + nodeId, + GetXLogInsertRecPtr() - slot->data.restart_lsn, + MtmMaxRecoveryLag); + ReplicationSlotDrop(slot->data.name.data); + } + } + } +} + static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { @@ -594,6 +618,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) x->snapshot = INVALID_CSN; x->xid = InvalidTransactionId; x->gtid.xid = InvalidTransactionId; + MtmCheckSlots(); } void MtmSendNotificationMessage(MtmTransState* ts) @@ -752,7 +777,8 @@ _PG_init(void) DefineCustomIntVariable( "multimaster.min_recovery_lag", "Minamal lag of WAL-sender performing recovery after which cluster is locked until recovery is completed", - NULL, + "When wal-sender almost catch-up WAL current position we need to stop 'Achilles tortile compeition' and " + "temporary stop commit of new transactions until node will be completely repared", &MtmMinRecoveryLag, 100000, 1, @@ -764,6 +790,22 @@ _PG_init(void) NULL ); + DefineCustomIntVariable( + "multimaster.max_recovery_lag", + "Maximal lag of replication slot of failed node after which this slot is dropped to avoid transaction log overflow", + "Dropping slog makes it not possible to recover node using logical replication mechanism, it will eb ncessary to completely copy content of some other nodes " + "usimg basebackup or similar tool", + &MtmMaxRecoveryLag, + 100000000, + 0, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.vacuum_delay", "Minimal age of records which can be vacuumed (seconds)", @@ -944,12 +986,14 @@ _PG_fini(void) * *************************************************************************** */ + static void MtmSwitchFromRecoveryToNormalMode() { dtm->status = MTM_ONLINE; /* ??? Something else to do here? */ } + void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { csn_t localSnapshot; From d3a8cdc0ac4b0b74873450c27190604b67cc479a Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 27 Feb 2016 23:15:38 +0300 Subject: [PATCH 0269/1139] Add more comments --- arbiter.c | 18 +++++++----- multimaster.c | 66 ++++++++++++++++++++++++++++++++++++++------ pglogical_receiver.c | 7 +++++ 3 files changed, 76 insertions(+), 15 deletions(-) diff --git a/arbiter.c b/arbiter.c index d528f01909..9e05e87d18 100644 --- a/arbiter.c +++ b/arbiter.c @@ -176,7 +176,7 @@ static void MtmRegisterSocket(int fd, int node) ev.events = EPOLLIN; ev.data.u32 = node; if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) < 0) { - elog(ERROR, "Arbuter failed to add socket to epoll set: %d", errno); + elog(ERROR, "Arbiter failed to add socket to epoll set: %d", errno); } #else FD_SET(fd, &inset); @@ -285,21 +285,23 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) goto Retry; } if (MtmReadSocket(sd, &msg, sizeof msg) != sizeof(msg)) { - elog(WARNING, "Arbiter failed to receive response for handshake message from %s:%d: %d", host, port, errno); + elog(WARNING, "Arbiter failed to receive response for handshake message from %s:%d: errno=%d", host, port, errno); close(sd); goto Retry; } if (msg.code != MSG_STATUS || msg.dxid != HANDSHAKE_MAGIC) { - elog(WARNING, "Arbiter get unexpected response %d for handshake message from %s:%d: %d", msg.code, host, port, errno); + elog(WARNING, "Arbiter get unexpected response %d for handshake message from %s:%d", msg.code, host, port); close(sd); goto Retry; } + /* Some node cnosidered that I am dead, so switch to recovery mode */ if (BIT_CHECK(msg.disabledNodeMask, MtmNodeId-1)) { elog(WARNING, "Node is switched to recovery mode"); ds->status = MTM_RECOVERY; } - ds->disabledNodeMask = msg.disabledNodeMask; + /* Combine disable masks from all node. Is it actually correct or we should better check availability of nodes ourselves? */ + ds->disabledNodeMask |= msg.disabledNodeMask; return sd; } } @@ -340,8 +342,10 @@ static void MtmOpenConnections() } } if (ds->nNodes < MtmNodes/2+1) { /* no quorum */ + elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", ds->nNodes, MtmNodes); ds->status = MTM_OFFLINE; } else if (ds->status == MTM_INITIALIZATION) { + elog(WARNING, "Switch to CONNECTED mode"); ds->status = MTM_CONNECTED; } } @@ -392,7 +396,7 @@ static void MtmAcceptOneConnection() msg.sxid = ShmemVariableCache->nextXid; msg.csn = MtmGetCurrentTime(); if (!MtmWriteSocket(fd, &msg, sizeof msg)) { - elog(WARNING, "Arbiter failed to write response for handshake message from node %d", msg.node); + elog(WARNING, "Arbiter failed to write response for handshake message to node %d", msg.node); close(fd); } else { elog(NOTICE, "Arbiter established connection with node %d", msg.node); @@ -690,8 +694,8 @@ static void MtmTransReceiver(Datum arg) case MSG_PREPARE: Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); if ((msg->disabledNodeMask & ~ds->disabledNodeMask) != 0) { - /* Coordinator's disabled mask is wider than my:so reject such transaction to avoid - commit on smaller subset of nodes */ + /* Coordinator's disabled mask is wider than my: so reject such transaction to avoid + commit on smaller subset of nodes */ ts->status = TRANSACTION_STATUS_ABORTED; ts->cmd = MSG_ABORT; MtmAdjustSubtransactions(ts); diff --git a/multimaster.c b/multimaster.c index b4ae102755..b75723fc9a 100644 --- a/multimaster.c +++ b/multimaster.c @@ -154,6 +154,9 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag); +/* + * Using LWLock seems to be more efficient (at our benchmarks) + */ void MtmLock(LWLockMode mode) { #ifdef USE_SPINLOCK @@ -197,6 +200,9 @@ void MtmSleep(timestamp_t interval) } } +/** + * Return ascending unique timestamp which is used as CSN + */ csn_t MtmAssignCSN() { csn_t csn = MtmGetCurrentTime(); @@ -208,6 +214,9 @@ csn_t MtmAssignCSN() return csn; } +/** + * "Adjust" system clock if we receive message from future + */ csn_t MtmSyncClock(csn_t global_csn) { csn_t local_csn; @@ -471,6 +480,15 @@ MtmXactCallback(XactEvent event, void *arg) } } +/* + * Check if this is "normal" user trnsaction which shoudl be distributed to other nodes + */ +static bool +MtmIsUserTransaction() +{ + return IsNormalProcessingMode() && dtm->status == MTM_ONLINE && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); +} + static void MtmBeginTransaction(MtmCurrentTrans* x) { @@ -478,7 +496,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) MtmLock(LW_EXCLUSIVE); x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; - x->isDistributed = IsNormalProcessingMode() && dtm->status == MTM_ONLINE && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); + x->isDistributed = MtmIsUserTransaction(); x->containsDML = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; @@ -489,7 +507,11 @@ MtmBeginTransaction(MtmCurrentTrans* x) } -/* This function is called at transaction start with multimaster ock set */ +/* + * If there are recovering nodes which are catching-up WAL, check the status and prevent new transaction from commit to give + * WAL-sender a chance to catch-up WAL, completely synchronize replica and switch it to normal mode. + * This function is called at transaction start with multimaster lock set + */ static void MtmCheckClusterLock() { @@ -507,6 +529,7 @@ MtmCheckClusterLock() break; } else { /* recovered replica catched up with master */ + elog(WARNING, "WAL-sender %d complete receovery", i); dtm->walSenderLockerMask &= ~((nodemask_t)1 << i); } } @@ -524,6 +547,7 @@ MtmCheckClusterLock() } else { /* All lockers are synchronized their logs */ /* Remove lock and mark them as receovered */ + elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", dtm->nLockers, dtm->nodeLockerMask); Assert(dtm->walSenderLockerMask == 0); Assert((dtm->nodeLockerMask & dtm->disabledNodeMask) == dtm->nodeLockerMask); dtm->disabledNodeMask &= ~dtm->nodeLockerMask; @@ -552,6 +576,10 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) x->xid = GetCurrentTransactionId(); MtmLock(LW_EXCLUSIVE); + + /* + * Check if there is global multimaster lock preventing new transaction from commit to make a chance to wal-senders to cache-up + */ MtmCheckClusterLock(); ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); @@ -580,6 +608,10 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", getpid(), x->xid, ts->csn); } +/** + * Check state of replication slots. If some of them are too much lag behind wal, then drop this slots to avoid + * WAL overflow + */ static void MtmCheckSlots() { if (MtmMaxRecoveryLag != 0 && dtm->disabledNodeMask != 0) @@ -636,17 +668,23 @@ void MtmSendNotificationMessage(MtmTransState* ts) } /* - * This function is called by WAL sender when start sending new transaction + * This function is called by WAL sender when start sending new transaction. + * It returns true if specified node is in recovery mode. In this case we should send all transactions from WAL, + * not only coordinated by self node as in normal mode. */ bool MtmIsRecoveredNode(int nodeId) { if (BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) { - Assert(MyWalSnd != NULL); + Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ if (!BIT_CHECK(dtm->nodeLockerMask, nodeId-1) && MyWalSnd->sentPtr + MtmMinRecoveryLag > GetXLogInsertRecPtr()) { - /* Wal sender almost catched up */ - /* Lock cluster preventing new transaction to start until wal is completely replayed */ + /* + * Wal sender almost catched up. + * Lock cluster preventing new transaction to start until wal is completely replayed. + * We have to maintain two bitmasks: one is marking wal sender, another - correspondent nodes. + * Is there some better way to establish mapping between nodes ad WAL-seconder? + */ MtmLock(LW_EXCLUSIVE); dtm->nodeLockerMask |= (nodemask_t)1 << (nodeId-1); dtm->walSenderLockerMask |= (nodemask_t)1 << (MyWalSnd - WalSndCtl->walsnds); @@ -793,8 +831,8 @@ _PG_init(void) DefineCustomIntVariable( "multimaster.max_recovery_lag", "Maximal lag of replication slot of failed node after which this slot is dropped to avoid transaction log overflow", - "Dropping slog makes it not possible to recover node using logical replication mechanism, it will eb ncessary to completely copy content of some other nodes " - "usimg basebackup or similar tool", + "Dropping slog makes it not possible to recover node using logical replication mechanism, it will be ncessary to completely copy content of some other nodes " + "usimg basebackup or similar tool. Zero value of parameter disable droipping slot.", &MtmMaxRecoveryLag, 100000000, 0, @@ -990,6 +1028,7 @@ _PG_fini(void) static void MtmSwitchFromRecoveryToNormalMode() { dtm->status = MTM_ONLINE; + elog(WARNING, "Switch to normal mode"); /* ??? Something else to do here? */ } @@ -1008,8 +1047,10 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) } if (!TransactionIdIsValid(gtid->xid)) { + /* In case of recovery InvalidTransactionId is passed */ Assert(dtm->status == MTM_RECOVERY); } else if (dtm->status == MTM_RECOVERY) { + /* When recovery is completed we get normal transaction ID and switch to normal mode */ MtmSwitchFromRecoveryToNormalMode(); } dtmTx.gtid = *gtid; @@ -1026,6 +1067,7 @@ void MtmReceiverStarted(int nodeId) if (!BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { dtm->pglogicalNodeMask |= (int64)1 << (nodeId-1); if (++dtm->nReceivers == dtm->nNodes-1) { + elog(WARNING, "All receivers are started, switch to normal mode"); Assert(dtm->status == MTM_CONNECTED); dtm->status = MTM_ONLINE; } @@ -1048,17 +1090,25 @@ csn_t MtmTransactionSnapshot(TransactionId xid) return snapshot; } +/* + * Determine when and how we should open replication slot. + * Druing recovery we need to open only one replication slot from which node should receive all transactions. + * Slots at other nodes should be removed + */ MtmSlotMode MtmReceiverSlotMode(int nodeId) { while (dtm->status != MTM_CONNECTED && dtm->status != MTM_ONLINE) { if (dtm->status == MTM_RECOVERY) { if (dtm->recoverySlot == 0 || dtm->recoverySlot == nodeId) { + /* Choose for recovery first available slot */ dtm->recoverySlot = nodeId; return SLOT_OPEN_EXISTED; } } + /* delay opening of other slots until recovery is completed */ MtmSleep(STATUS_POLL_DELAY); } + /* After recovery completion we need to drop all other slots to avoid receive of redundant data */ return dtm->recoverySlot ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 61a9b3e118..dc599f0ba5 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -223,6 +223,11 @@ pglogical_receiver_main(Datum main_arg) /* Connect to a database */ BackgroundWorkerInitializeConnection(MtmDatabaseName, NULL); + /* + * Determine when and how we should open replication slot. + * Druing recovery we need to open only one replication slot from which node should receive all transactions. + * Slots at other nodes should be removed + */ mode = MtmReceiverSlotMode(args->receiver_node); /* Establish connection to remote server */ @@ -375,6 +380,8 @@ pglogical_receiver_main(Datum main_arg) * If the server requested an immediate reply, send one. * If sync mode is sent reply in all cases to ensure that * server knows how far replay has been done. + * In recovery mode also always send reply to provide master with more precise information + * about recovery progress */ if (replyRequested || receiver_sync_mode || ds->status == MTM_RECOVERY) { From 8fefcf64b4079654746d385ead09307df6b5aba5 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 28 Feb 2016 22:56:42 +0300 Subject: [PATCH 0270/1139] Support 2PC in multimaster --- multimaster.c | 83 +++++++++++++++++++++++++++++++++++++++++--- pglogical_receiver.c | 8 +++-- 2 files changed, 85 insertions(+), 6 deletions(-) diff --git a/multimaster.c b/multimaster.c index b75723fc9a..d6176072c9 100644 --- a/multimaster.c +++ b/multimaster.c @@ -61,7 +61,8 @@ typedef struct { bool isReplicated; /* transaction on replica */ bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ bool containsDML; /* transaction contains DML statements */ - csn_t snapshot; /* transaction snaphsot */ + bool isPrepared; /* transaction is prepared as part of 2PC */ + csn_t snapshot; /* transaction snaphsot */ } MtmCurrentTrans; /* #define USE_SPINLOCK 1 */ @@ -94,6 +95,8 @@ static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, Transaction static void MtmInitialize(void); static void MtmXactCallback(XactEvent event, void *arg); static void MtmBeginTransaction(MtmCurrentTrans* x); +static void MtmPrecommitTransaction(MtmCurrentTrans* x); +static bool MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids); static void MtmPrepareTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); @@ -143,6 +146,7 @@ static int MtmWorkers; static int MtmVacuumDelay; static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; +static bool MtmUse2PC; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -467,6 +471,9 @@ MtmXactCallback(XactEvent event, void *arg) MtmBeginTransaction(&dtmTx); break; case XACT_EVENT_PRE_COMMIT: + MtmPrecommitTransaction(&dtmTx); + break; + case XACT_EVENT_PREPARE: MtmPrepareTransaction(&dtmTx); break; case XACT_EVENT_COMMIT: @@ -498,6 +505,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->isReplicated = false; x->isDistributed = MtmIsUserTransaction(); x->containsDML = false; + x->isPrepared = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; MtmUnlock(); @@ -561,10 +569,11 @@ MtmCheckClusterLock() } /* + * This functions is called as pre-commit callback. * We need to pass snapshot to WAL-sender, so create record in transaction status hash table * before commit */ -static void MtmPrepareTransaction(MtmCurrentTrans* x) +static void MtmPrecommitTransaction(MtmCurrentTrans* x) { MtmTransState* ts; int i; @@ -608,6 +617,20 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", getpid(), x->xid, ts->csn); } +static void +MtmPrepareTransaction(MtmCurrentTrans* x) +{ + TransactionId *subxids; + int nSubxids; + MtmPrecommitTransaction(x); + x->isPrepared = true; + nSubxids = xactGetCommittedChildren(&subxids); + if (!MtmCommitTransaction(x->xid, nSubxids, subxids)) + { + elog(ERROR, "Commit of transaction %d is rejected by DTM", x->xid); + } +} + /** * Check state of replication slots. If some of them are too much lag behind wal, then drop this slots to avoid * WAL overflow @@ -755,7 +778,7 @@ static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) { MTM_TRACE("%d: MtmSetTransactionStatus %u(%u) = %u, isDistributed=%d\n", getpid(), xid, dtmTx.xid, status, dtmTx.isDistributed); - if (xid == dtmTx.xid && dtmTx.isDistributed) + if (xid == dtmTx.xid && dtmTx.isDistributed && !dtmTx.isPrepared) { if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML || dtm->status == MTM_RECOVERY) { @@ -812,6 +835,18 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomBoolVariable( + "multimaster.use_2pc", + "Use two phase commit", + "Replace normal commit with two phase commit", + &MtmUse2PC, + false, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); DefineCustomIntVariable( "multimaster.min_recovery_lag", "Minamal lag of WAL-sender performing recovery after which cluster is locked until recovery is completed", @@ -1313,6 +1348,17 @@ static bool MtmProcessDDLCommand(char const* queryString) return false; } +/* + * Genenerate global transaction identifier for two-pahse commit. + * It should be unique for all nodes + */ +static char* +MtmGenerateGid() +{ + static int localCount; + return psprintf("GID-%d-%d-%d", MtmNodeId, MyProcPid, ++localCount); +} + static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag) @@ -1320,6 +1366,36 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, bool skipCommand; switch (nodeTag(parsetree)) { + case T_TransactionStmt: + { + TransactionStmt *stmt = (TransactionStmt *) parsetree; + switch (stmt->kind) + { + case TRANS_STMT_COMMIT: + if (MtmUse2PC) { + char* gid = MtmGenerateGid(); + if (!PrepareTransactionBlock(gid)) + { + /* report unsuccessful commit in completionTag */ + if (completionTag) { + strcpy(completionTag, "ROLLBACK"); + } + /* ??? Should we do explicit rollback */ + } else { + FinishPreparedTransaction(gid, true); + } + return; + } + break; + case TRANS_STMT_PREPARE: + case TRANS_STMT_COMMIT_PREPARED: + case TRANS_STMT_ROLLBACK_PREPARED: + elog(ERROR, "Two phase commit is not supported by multimaster"); + default: + break; + } + } + /* no break */ case T_PlannedStmt: case T_ClosePortalStmt: case T_FetchStmt: @@ -1333,7 +1409,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_LoadStmt: case T_VariableSetStmt: case T_VariableShowStmt: - case T_TransactionStmt: skipCommand = true; break; default: diff --git a/pglogical_receiver.c b/pglogical_receiver.c index dc599f0ba5..1969a2abd8 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -209,7 +209,8 @@ pglogical_receiver_main(Datum main_arg) bool insideTrans = false; #endif ByteBuffer buf; - XLogRecPtr originStartPos; + XLogRecPtr originStartPos = 0; + RepOriginId originId; /* Register functions for SIGTERM/SIGHUP management */ pqsignal(SIGHUP, receiver_raw_sighup); @@ -266,7 +267,10 @@ pglogical_receiver_main(Datum main_arg) resetPQExpBuffer(query); } /* Start logical replication at specified position */ - originStartPos = replorigin_session_get_progress(false); + originId = replorigin_by_name(args->receiver_slot, true); + if (originId != InvalidRepOriginId) { + originStartPos = replorigin_get_progress(originId, false); + } appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d')", args->receiver_slot, (uint32) (originStartPos >> 32), From 98075f5c5d900dda82bb686ecec46b1dfa4016e1 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 29 Feb 2016 11:38:54 +0300 Subject: [PATCH 0271/1139] Fix start of pglogical_receiver --- multimaster.c | 30 +++++++++++++++++------------- pglogical_receiver.c | 28 +++++++++++++++++++--------- tests/dtmbench.cpp | 2 +- 3 files changed, 37 insertions(+), 23 deletions(-) diff --git a/multimaster.c b/multimaster.c index d6176072c9..641fc2807c 100644 --- a/multimaster.c +++ b/multimaster.c @@ -278,13 +278,13 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) { if (ts->csn > dtmTx.snapshot) { MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", - getpid(), xid, ts->csn, dtmTx.snapshot); + MyProcPid, xid, ts->csn, dtmTx.snapshot); MtmUnlock(); return true; } if (ts->status == TRANSACTION_STATUS_UNKNOWN) { - MTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); + MTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", MyProcPid, xid, dtmTx.snapshot); MtmUnlock(); #if TRACE_SLEEP_TIME { @@ -316,14 +316,14 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld\n", - getpid(), xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot); + MyProcPid, xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot); MtmUnlock(); return invisible; } } else { - MTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", getpid(), xid, dtmTx.snapshot); + MTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", MyProcPid, xid, dtmTx.snapshot); break; } } @@ -493,7 +493,7 @@ MtmXactCallback(XactEvent event, void *arg) static bool MtmIsUserTransaction() { - return IsNormalProcessingMode() && dtm->status == MTM_ONLINE && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); + return IsNormalProcessingMode() && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); } static void @@ -504,6 +504,10 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; x->isDistributed = MtmIsUserTransaction(); + if (x->isDistributed && dtm->status != MTM_ONLINE) { + MtmUnlock(); + elog(ERROR, "Multimaster node is offline"); + } x->containsDML = false; x->isPrepared = false; x->snapshot = MtmAssignCSN(); @@ -614,7 +618,7 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) MtmUnlock(); - MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", getpid(), x->xid, ts->csn); + MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", MyProcPid, x->xid, ts->csn); } static void @@ -728,14 +732,14 @@ MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) ts = hash_search(xid2state, &xid, HASH_FIND, NULL); Assert(ts != NULL); /* should be created by MtmPrepareTransaction */ - MTM_TRACE("%d: MtmCommitTransaction begin commit of %d CSN=%ld\n", getpid(), xid, ts->csn); + MTM_TRACE("%d: MtmCommitTransaction begin commit of %d CSN=%ld\n", MyProcPid, xid, ts->csn); MtmAddSubtransactions(ts, subxids, nsubxids); MtmVoteForTransaction(ts); MtmUnlock(); - MTM_TRACE("%d: MtmCommitTransaction %d status=%d\n", getpid(), xid, ts->status); + MTM_TRACE("%d: MtmCommitTransaction %d status=%d\n", MyProcPid, xid, ts->status); return ts->status != TRANSACTION_STATUS_ABORTED; } @@ -768,7 +772,7 @@ MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi MtmSendNotificationMessage(ts); } MtmUnlock(); - MTM_TRACE("%d: MtmFinishTransaction %d CSN=%ld, status=%d\n", getpid(), xid, ts->csn, status); + MTM_TRACE("%d: MtmFinishTransaction %d CSN=%ld, status=%d\n", MyProcPid, xid, ts->csn, status); } } @@ -777,7 +781,7 @@ MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) { - MTM_TRACE("%d: MtmSetTransactionStatus %u(%u) = %u, isDistributed=%d\n", getpid(), xid, dtmTx.xid, status, dtmTx.isDistributed); + MTM_TRACE("%d: MtmSetTransactionStatus %u(%u) = %u, isDistributed=%d\n", MyProcPid, xid, dtmTx.xid, status, dtmTx.isDistributed); if (xid == dtmTx.xid && dtmTx.isDistributed && !dtmTx.isPrepared) { if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML || dtm->status == MTM_RECOVERY) @@ -1100,7 +1104,7 @@ void MtmReceiverStarted(int nodeId) { SpinLockAcquire(&dtm->spinlock); if (!BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { - dtm->pglogicalNodeMask |= (int64)1 << (nodeId-1); + dtm->pglogicalNodeMask |= (nodemask_t)1 << (nodeId-1); if (++dtm->nReceivers == dtm->nNodes-1) { elog(WARNING, "All receivers are started, switch to normal mode"); Assert(dtm->status == MTM_CONNECTED); @@ -1478,14 +1482,14 @@ MtmVoteForTransaction(MtmTransState* ts) MtmSendNotificationMessage(ts); } } - MTM_TRACE("%d: Node %d waiting latch...\n", getpid(), MtmNodeId); + MTM_TRACE("%d: Node %d waiting latch...\n", MyProcPid, MtmNodeId); while (!ts->done) { MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); MtmLock(LW_SHARED); } - MTM_TRACE("%d: Node %d receives response...\n", getpid(), MtmNodeId); + MTM_TRACE("%d: Node %d receives response...\n", MyProcPid, MtmNodeId); } HTAB* MtmCreateHash(void) diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 1969a2abd8..570d21b8ef 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -17,6 +17,7 @@ #include #include "postgres.h" #include "fmgr.h" +#include "miscadmin.h" #include "libpq-fe.h" #include "pqexpbuffer.h" #include "access/xact.h" @@ -38,7 +39,8 @@ /* Allow load of this module in shared libs */ typedef struct ReceiverArgs { - int receiver_node; + int local_node; + int remote_node; char* receiver_conn_string; char receiver_slot[16]; } ReceiverArgs; @@ -55,7 +57,7 @@ static bool receiver_sync_mode = false; /* Worker name */ static char *worker_name = "multimaster"; -char worker_proc[16]; +char worker_proc[BGW_MAXLEN]; /* Lastly written positions */ static XLogRecPtr output_written_lsn = InvalidXLogRecPtr; @@ -216,7 +218,7 @@ pglogical_receiver_main(Datum main_arg) pqsignal(SIGHUP, receiver_raw_sighup); pqsignal(SIGTERM, receiver_raw_sigterm); - sprintf(worker_proc, "mtm_recv_%d", getpid()); + sprintf(worker_proc, "mtm_pglogical_receiver_%d_%d", args->local_node, args->remote_node); /* We're now ready to receive signals */ BackgroundWorkerUnblockSignals(); @@ -229,7 +231,7 @@ pglogical_receiver_main(Datum main_arg) * Druing recovery we need to open only one replication slot from which node should receive all transactions. * Slots at other nodes should be removed */ - mode = MtmReceiverSlotMode(args->receiver_node); + mode = MtmReceiverSlotMode(args->remote_node); /* Establish connection to remote server */ conn = PQconnectdb(args->receiver_conn_string); @@ -266,11 +268,18 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); resetPQExpBuffer(query); } + /* Start logical replication at specified position */ + StartTransactionCommand(); originId = replorigin_by_name(args->receiver_slot, true); if (originId != InvalidRepOriginId) { originStartPos = replorigin_get_progress(originId, false); + elog(WARNING, "Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); + } else { + elog(WARNING, "Start logical receiver from node %d", args->remote_node); } + CommitTransactionCommand(); + appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d')", args->receiver_slot, (uint32) (originStartPos >> 32), @@ -282,14 +291,14 @@ pglogical_receiver_main(Datum main_arg) if (PQresultStatus(res) != PGRES_COPY_BOTH) { PQclear(res); - ereport(LOG, (errmsg("%s: Could not start logical replication", - worker_proc))); + ereport(WARNING, (errmsg("%s: Could not start logical replication", + worker_proc))); proc_exit(1); } PQclear(res); resetPQExpBuffer(query); - MtmReceiverStarted(args->receiver_node); + MtmReceiverStarted(args->remote_node); ByteBufferAlloc(&buf); ds = MtmGetState(); @@ -576,10 +585,11 @@ int MtmStartReceivers(char* conns, int node_id) } ctx->receiver_conn_string = psprintf("replication=database %.*s", (int)(p - conn_str), conn_str); sprintf(ctx->receiver_slot, "mtm_slot_%d", node_id); - ctx->receiver_node = node_id; + ctx->local_node = node_id; + ctx->remote_node = i; /* Worker parameter and registration */ - snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_worker_%d_%d", node_id, i); + snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_pglogical_receiver_%d_%d", node_id, i); worker.bgw_main_arg = (Datum)ctx; RegisterBackgroundWorker(&worker); diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 2279edd442..506b466521 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -184,7 +184,7 @@ void initializeDatabase() printf("Creating database schema...\n"); { nontransaction txn(conn); - exec(txn, "drop extension if exists multimsater"); + exec(txn, "drop extension if exists multimaster"); exec(txn, "create extension multimaster"); exec(txn, "drop table if exists t"); exec(txn, "create table t(u int primary key, v int)"); From e8cf78fc58b9a67bbb6519e06b2724c93342bdd8 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 29 Feb 2016 20:37:44 +0300 Subject: [PATCH 0272/1139] Aff lock graph serializatgion --- multimaster.c | 70 +++++++++++++++++++++++++++++++++++++++++++++++++++ multimaster.h | 2 ++ 2 files changed, 72 insertions(+) diff --git a/multimaster.c b/multimaster.c index 641fc2807c..9542839f1b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1516,3 +1516,73 @@ MtmGetState(void) { return dtm; } + +static void +MtmGetGtid(TransactionId xid, GlobalTransactionId* gtid) +{ + MtmTransState* ts; + + MtmLock(LW_SHARED); + ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + Assert(ts != NULL); + *gtid = ts->gtid; + MtmUnlock(); +} + + +static void +MtmSerializeLock(PROCLOCK* proclock, void* arg) +{ + ByteBuffer* buf = (ByteBuffer*)arg; + LOCK* lock = proclock->tag.myLock; + PGPROC* proc = proclock->tag.myProc; + GlobalTransactionId gtid; + if (lock != NULL) { + PGXACT* srcPgXact = &ProcGlobal->allPgXact[proc->pgprocno]; + + if (TransactionIdIsValid(srcPgXact->xid) && proc->waitLock == lock) { + LockMethod lockMethodTable = GetLocksMethodTable(lock); + int numLockModes = lockMethodTable->numLockModes; + int conflictMask = lockMethodTable->conflictTab[proc->waitLockMode]; + SHM_QUEUE *procLocks = &(lock->procLocks); + int lm; + + MtmGetGtid(srcPgXact->xid, >id); /* waiting transaction */ + + ByteBufferAppendInt32(buf, gtid.node); + ByteBufferAppendInt32(buf, gtid.xid); + + proclock = (PROCLOCK *) SHMQueueNext(procLocks, procLocks, + offsetof(PROCLOCK, lockLink)); + while (proclock) + { + if (proc != proclock->tag.myProc) { + PGXACT* dstPgXact = &ProcGlobal->allPgXact[proclock->tag.myProc->pgprocno]; + if (TransactionIdIsValid(dstPgXact->xid)) { + Assert(srcPgXact->xid != dstPgXact->xid); + for (lm = 1; lm <= numLockModes; lm++) + { + if ((proclock->holdMask & LOCKBIT_ON(lm)) && (conflictMask & LOCKBIT_ON(lm))) + { + MTM_TRACE("%d: %u(%u) waits for %u(%u)\n", getpid(), srcPgXact->xid, proc->pid, dstPgXact->xid, proclock->tag.myProc->pid); + MtmGetGtid(srcPgXact->xid, >id); /* transaction holding lock */ + ByteBufferAppendInt32(buf, gtid.node); + ByteBufferAppendInt32(buf, gtid.xid); + break; + } + } + } + } + proclock = (PROCLOCK *) SHMQueueNext(procLocks, &proclock->lockLink, + offsetof(PROCLOCK, lockLink)); + } + ByteBufferAppendInt32(buf, 0); /* end of lock owners list */ + ByteBufferAppendInt32(buf, 0); /* end of lock owners list */ + } + } +} + +void MtmSerializeLockGraph(ByteBuffer* buf) +{ + EnumerateLocks(MtmSerializeLock, buf); +} diff --git a/multimaster.h b/multimaster.h index 8026513f82..c00c4e6081 100644 --- a/multimaster.h +++ b/multimaster.h @@ -145,4 +145,6 @@ extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern bool MtmIsRecoveredNode(int nodeId); +extern void MtmSerializeLockGraph(ByteBuffer* buf); + #endif From 3a629706ca9a1457e8cf945f72274d8f8bd55f53 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 3 Mar 2016 20:06:01 +0300 Subject: [PATCH 0273/1139] Distributed deadlock detections --- arbiter.c | 4 +-- ddd.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++++++ ddd.h | 30 +++++++++++++++++++++ multimaster.c | 68 +++++++++++++++++++++++++++++++++++++++------- multimaster.h | 2 +- 5 files changed, 166 insertions(+), 12 deletions(-) create mode 100644 ddd.c create mode 100644 ddd.h diff --git a/arbiter.c b/arbiter.c index 9e05e87d18..9bc8eb2801 100644 --- a/arbiter.c +++ b/arbiter.c @@ -335,7 +335,7 @@ static void MtmOpenConnections() if (i+1 != MtmNodeId) { sockets[i] = MtmConnectSocket(host, MtmArbiterPort + i + 1, MtmConnectAttempts); if (sockets[i] < 0) { - MtmDropNode(i+1, false); + MtmOnLostConnection(i+1); } } else { sockets[i] = -1; @@ -358,7 +358,7 @@ static bool MtmSendToNode(int node, void const* buf, int size) close(sockets[node]); sockets[node] = MtmConnectSocket(hosts[node], MtmArbiterPort + node + 1, MtmReconnectAttempts); if (sockets[node] < 0) { - MtmDropNode(node+1, false); + MtmOnLostConnection(node+1); return false; } } diff --git a/ddd.c b/ddd.c new file mode 100644 index 0000000000..1b7125ee44 --- /dev/null +++ b/ddd.c @@ -0,0 +1,74 @@ +#include +#include +#include +#include "ddd.h" + + +void MtmGraphInit(MtmGraph* graph) +{ + memset(graph->hashtable, 0, sizeof(graph->hashtable)); +} + +static inline MtmVertex* findVertex(MtmGraph* graph, GlobalTransactionId* gtid) +{ + xid_t h = gtid->xid % MAX_TRANSACTIONS; + MtmVertex* v; + for (v = graph->hashtable[h]; v != NULL; v = v->next) { + if (v->gtid == *gtid) { + return v; + } + } + v = (MtmVertex*)palloc(sizeof(MtmVertex)); + v->gtid = *gtid; + v->outgoingEdges = NULL; + v->collision = graph->hashtable[h]; + graph->hashtable[h] = v; + return v; +} + +void MtmGraphAdd(MtmGraph* graph, GlobalTransactionId* gtid, int size) +{ + GlobalTransactionId* last = gtid + size; + MtmEdge *e, *next, *edges = NULL; + while (gtid != last) { + Vertex* src = findVertex(graph, gtid++); + while (gtid->node != 0) { + Vertex* dst = findVertex(graph, gtid++); + e = (MtmEdge*)palloc(sizeof(MtmEdge)); + dst->nIncomingEdges += 1; + e->dst = dst; + e->src = src; + e->next = v->outgoingEdges; + v->outgoingEdges = e; + } + gtid += 1; + } +} + +static bool recursiveTraverseGraph(MtmVertex* root, MtmVertex* v) +{ + Edge* e; + v->node = VISITED_NODE_MARK; + for (e = v->outgoingEdges; e != NULL; e = e->next) { + if (e->dst == root) { + return true; + } else if (e->dst->node != VISITED_NODE_MAR && recursiveTraverseGraph(root, e->dst)) { /* loop */ + return true; + } + } + return false; +} + +bool MtmGraphFindLoop(MtmGraph* graph, GlobalTransactionId* root) +{ + Vertex* v; + for (v = graph->hashtable[root->xid % MAX_TRANSACTIONS]; v != NULL; v = v->next) { + if (v->gtid == *root) { + if (recursiveTraverseGraph(v, v)) { + return true; + } + break; + } + } + return false; +} diff --git a/ddd.h b/ddd.h new file mode 100644 index 0000000000..2ed36554c0 --- /dev/null +++ b/ddd.h @@ -0,0 +1,30 @@ +#ifndef __DDD_H__ + +#include "multimaster.h" + +#define MAX_TRANSACTIONS 1024 +#define VISITED_NODE_MARK 0 + +typedef struct MtmEdge { + struct MtmEdge* next; /* list of outgoing edges */ + struct MtmVertex* dst; + struct MtmVertex* src; +} MtmEdge; + +typedef struct MtmVertex +{ + struct MtmEdge* outgoingEdges; + struct MtmVertex* collision; + GlobalTransactionId gtid; +} MtmVertex; + +typedef struct MtmGraph +{ + MtmVertex* hashtable[MTM_MAX_TRANSACTIONS]; +} Graph; + +extern void MtmGraphInit(MtmGraph* graph); +extern void MtmGraphAdd(MtmGraph* graph, GlobalTransactionId* subgraph, int size); +extern bool MtmGraphFindLoop(MtmGraph* graph, GlobalTransactionId* root); + +#endif diff --git a/multimaster.c b/multimaster.c index 9542839f1b..87e00f4138 100644 --- a/multimaster.c +++ b/multimaster.c @@ -112,6 +112,7 @@ static BgwPool* MtmPoolConstructor(void); static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); static void MtmVoteForTransaction(MtmTransState* ts); +static void MtmSerializeLockGraph(ByteBuffer* buf) static HTAB* xid2state; static MtmCurrentTrans dtmTx; @@ -805,13 +806,6 @@ MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); } -static bool -MtmDetectGlobalDeadLock(PGPROC* proc) -{ - elog(WARNING, "Global deadlock?"); - return true; -} - static void MtmShmemStartup(void) { @@ -1582,7 +1576,63 @@ MtmSerializeLock(PROCLOCK* proclock, void* arg) } } -void MtmSerializeLockGraph(ByteBuffer* buf) +/* Stubs */ +typedef PaxosTimestamp { + time_t time; /* local time at master */ + uint32 naster; /* master node for this operation */ + uint32 psn; /* PAXOS serial number */ +} PaxosTimestamp; + +void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts); +void PaxosSet(char const* key, void* value, int size); + + +static bool +MtmDetectGlobalDeadLock(PGPROC* proc) +{ + bool hasDeadlock = false; + ByteBuffer buf; + PGXACT* pgxact = &ProcGlobal->allPgXact[proc->pgprocno]; + bool hasDeadlock = false; + if (TransactionIdIsValid(pgxact->xid)) { + MtmGraph graph; + GlobalTransactionId gtid; + int i; + + ByteBufferAlloc(&buf); + EnumerateLocks(DtmSerializeLock, &buf); + ByteBufferFree(&buf); + PaxosPut(dsprintf("lock-graph-%d", MMNodeId), buf.data, buf.size); + MtmGraphInit(&graph); + MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.size/sizeof(GlobalTransactionId)); + for (i = 0; i < MtmNodes; i++) { + if (i+1 MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { + int size; + void* data = PaxosGet(dsprintf("lock-graph-%d", i+1), &size, NULL); + MtmGraphAdd(&graph, (GlobalTransactionId*)data, size/sizeof(GlobalTransactoinId)); + } + } + MtmGetGtid(pgxact->xid, >id); + hasDeadlock = MtmGraphFindLoop(&graph, >id); + elog(WARNING, "Distributed deadlock check for %u:%u = %d", gtid.node, gtid.xid, hasDeadlock); + } + return hasDeadlock; +} + +void MtmOnLostConnection(int nodeId) { - EnumerateLocks(MtmSerializeLock, buf); + int i; + nodemask_t mask = dtm->disabledNodeMask; + nodemask_t matrix = (nodemask_t*)palloc0(sizeof(nodemask_t)*MtmNodes); + + mask |= (nodemask_t)1 << (nodeId-1); + PaxosPut(dsprintf("node-mask-%d", MMNodeId), &mask, sizeof mask); + matrix[MtmNodeId-1] = mask; + MtmSleep(MtmConnectTimeout); + for (i = 0; i < MtnNodes; i++) { + if (i+1 != MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { + void* data = PaxosGet(dsprintf("node-mask-%d", i+1), NULL, NULL); + matrix[i] = *(nodemask_t*)data; + } + } } diff --git a/multimaster.h b/multimaster.h index c00c4e6081..c5dd317ff3 100644 --- a/multimaster.h +++ b/multimaster.h @@ -141,10 +141,10 @@ extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); extern void MtmUnlock(void); extern void MtmDropNode(int nodeId, bool dropSlot); +extern void MtmOnLostConnection(int nodeId); extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern bool MtmIsRecoveredNode(int nodeId); -extern void MtmSerializeLockGraph(ByteBuffer* buf); #endif From 8b256c167fe02af06c775d09f89852fbe324794a Mon Sep 17 00:00:00 2001 From: knizhnik Date: Fri, 4 Mar 2016 00:03:58 +0300 Subject: [PATCH 0274/1139] Implement Bron-Kerbosch algiruithm for clique detection --- bkb.c | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++ multimaster.c | 4 ++ multimaster.h | 2 + 3 files changed, 117 insertions(+) create mode 100644 bkb.c diff --git a/bkb.c b/bkb.c new file mode 100644 index 0000000000..3e72dee373 --- /dev/null +++ b/bkb.c @@ -0,0 +1,111 @@ +/* + * Bron–Kerbosch algorithm to find maximum clque in graph + */ + +typedef struct { + int size; + int nodes[MAX_NODES]; +} List; + +static void list_append(List* list, int n) +{ + nodes[list->size++] = n; +} + +static void list_copy(List* dst, List* src) +{ + int i; + int n = src->size; + dst->size = n; + for (i = 0; i < n; i++) { + dst->nodes[i] = src->nodes[i]; + } +} + + +static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph, int* oldSet, int ne, int ce) +{ + int nod = 0; + int minnod = ce; + int fixp = -1; + int s = -1; + int i, j; + int newSet[MAX_NODES]; + + for (i = 0; i < ce && minnod != 0; i++) { + int p = oldSet[i]; + int cnt = 0; + int pos = -1; + + for (j = ne; j < ce; j++) { + if (!BIT_CHECK(graph[p], oldSet[j])) { + if (++cnt == minnod) + break; + pos = j; + } + } + if (minnod > cnt) { + minnod = cnt; + fixp = p; + if (i < ne) { + s = pos; + } else { + s = i; + nod = 1; + } + } + } + + + for (int k = minnod + nod; k >= 1; k--) { + int sel = oldSet[s]; + oldSet[s] = oldSet[ne]; + oldSet[ne] = sel; + + int newne = 0; + for (int i = 0; i < ne; i++) { + if (BIT_CHECK(graph[sel], oldSet[i])) { + newSet[newne++] = oldSet[i]; + } + } + int newce = newne; + for (int i = ne + 1; i < ce; i++) { + if (BIT_CHECK(graph[sel], oldSet[i])) { + newSet[newce++] = oldSet[i]; + } + } + list_append(cur, sel); + if (newce == 0) { + if (result->size < cur->size) { + list_copy(result, cur); + } + } else if (newne < newce) { + if (cur->size + newce - newne > result->size) { + findMaximumIndependentSet(cur, result, graph, newSet, newne, newce); + } + } + cur.size -= 1; + if (k > 1) { + for (s = ++ne; BIT_CHECK(graph[fixp], oldSet[s]); s++); + } + } +} + +nodemask_t MtmFindMaxClique(nodemask_t* graphs, in n_nodes); +{ + List tmp; + List result; + nodemask_t mask = 0; + int all[MAX_NODES]; + int i; + tmp.size = 0; + result.size = 0; + for (i = 0; i < n_nodes; i++) { + all[i]= i; + } + findMaximumIndependentSet(&tmp, &result, graph, all, 0, n_nodes); + for (i = 0; i < result.size; i++) { + mask |= (nodemask_t)1 << result.nodes[i]; + } + return ~mask; +} diff --git a/multimaster.c b/multimaster.c index 87e00f4138..fd2bbde68b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1023,6 +1023,10 @@ _PG_init(void) if (MtmNodes < 2) { elog(ERROR, "Multimaster should have at least two nodes"); } + if (MtmNodes > MAX_NODES) { + elog(ERROR, "Multimaster with mor than %d nodes is not currently supported", MAX_NODES); + } + BgwPoolStart(MtmWorkers, MtmPoolConstructor); MtmArbiterInitialize(); diff --git a/multimaster.h b/multimaster.h index c5dd317ff3..354e6815af 100644 --- a/multimaster.h +++ b/multimaster.h @@ -25,6 +25,7 @@ #define Anum_mtm_ddl_log_issued 1 #define Anum_mtm_ddl_log_query 2 +#define MAX_NODES 64 typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) @@ -146,5 +147,6 @@ extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern bool MtmIsRecoveredNode(int nodeId); +extern nodemask_t MtmFindMaxClique(nodemask_t* matrix, in n_modes); #endif From 38f712d8c859b853a4a81ec6b53e2da41afb416e Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 4 Mar 2016 12:57:18 +0300 Subject: [PATCH 0275/1139] =?UTF-8?q?Add=20Bron=E2=80=93Kerbosch=20algorit?= =?UTF-8?q?hm=20to=20find=20maximum=20clique=20in=20graph?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Makefile | 2 +- arbiter.c | 10 +++-- bkb.c | 51 ++++++++++++++---------- bkb.h | 16 ++++++++ ddd.c | 38 +++++++++--------- ddd.h | 5 ++- multimaster.c | 105 +++++++++++++++++++++++++++++++++----------------- multimaster.h | 15 ++++---- paxos.h | 13 +++++++ 9 files changed, 166 insertions(+), 89 deletions(-) create mode 100644 bkb.h create mode 100644 paxos.h diff --git a/Makefile b/Makefile index eaca18614a..8574fd30b9 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ MODULE_big = multimaster -OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o +OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o EXTENSION = multimaster DATA = multimaster--1.0.sql diff --git a/arbiter.c b/arbiter.c index 9bc8eb2801..e5f9490a38 100644 --- a/arbiter.c +++ b/arbiter.c @@ -81,7 +81,7 @@ typedef struct MtmMessageCode code; /* Message code: MSG_READY, MSG_PREPARE, MSG_COMMIT, MSG_ABORT */ int node; /* Sender node ID */ TransactionId dxid; /* Transaction ID at destination node */ - TransactionId sxid; /* Transaction IO at sender node */ + TransactionId sxid; /* Transaction ID at sender node */ csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ nodemask_t disabledNodeMask; /* bitmask of disabled nodes at the sender of message */ } MtmArbiterMessage; @@ -353,9 +353,11 @@ static void MtmOpenConnections() static bool MtmSendToNode(int node, void const* buf, int size) { - while (!MtmWriteSocket(sockets[node], buf, size)) { + while (sockets[node] < 0 || !MtmWriteSocket(sockets[node], buf, size)) { elog(WARNING, "Arbiter failed to write socket: %d", errno); - close(sockets[node]); + if (sockets[node] >= 0) { + close(sockets[node]); + } sockets[node] = MtmConnectSocket(hosts[node], MtmArbiterPort + node + 1, MtmReconnectAttempts); if (sockets[node] < 0) { MtmOnLostConnection(node+1); @@ -400,6 +402,8 @@ static void MtmAcceptOneConnection() close(fd); } else { elog(NOTICE, "Arbiter established connection with node %d", msg.node); + BIT_CLEAR(ds->connectivityMask, msg.node-1); + MtmOnConnectNode(msg.node); MtmRegisterSocket(fd, msg.node-1); sockets[msg.node-1] = fd; } diff --git a/bkb.c b/bkb.c index 3e72dee373..4d78a221bf 100644 --- a/bkb.c +++ b/bkb.c @@ -1,18 +1,22 @@ +#include "postgres.h" +#include "bkb.h" + /* - * Bron–Kerbosch algorithm to find maximum clque in graph + * Bron–Kerbosch algorithm to find maximum clique in graph */ typedef struct { int size; int nodes[MAX_NODES]; -} List; +} NodeList; -static void list_append(List* list, int n) +static void list_append(NodeList* list, int n) { - nodes[list->size++] = n; + Assert(list->size < MAX_NODES); + list->nodes[list->size++] = n; } -static void list_copy(List* dst, List* src) +static void list_copy(NodeList* dst, NodeList const* src) { int i; int n = src->size; @@ -23,13 +27,15 @@ static void list_copy(List* dst, List* src) } -static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph, int* oldSet, int ne, int ce) +static void findMaximumIndependentSet(NodeList* cur, NodeList* result, nodemask_t* graph, int* oldSet, int ne, int ce) { int nod = 0; int minnod = ce; int fixp = -1; int s = -1; - int i, j; + int i, j, k; + int newce, newne; + int sel; int newSet[MAX_NODES]; for (i = 0; i < ce && minnod != 0; i++) { @@ -39,8 +45,9 @@ static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph for (j = ne; j < ce; j++) { if (!BIT_CHECK(graph[p], oldSet[j])) { - if (++cnt == minnod) + if (++cnt == minnod) { break; + } pos = j; } } @@ -57,19 +64,19 @@ static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph } - for (int k = minnod + nod; k >= 1; k--) { - int sel = oldSet[s]; + for (k = minnod + nod; k >= 1; k--) { + sel = oldSet[s]; oldSet[s] = oldSet[ne]; oldSet[ne] = sel; - int newne = 0; - for (int i = 0; i < ne; i++) { + newne = 0; + for (i = 0; i < ne; i++) { if (BIT_CHECK(graph[sel], oldSet[i])) { newSet[newne++] = oldSet[i]; } } - int newce = newne; - for (int i = ne + 1; i < ce; i++) { + newce = newne; + for (i = ne + 1; i < ce; i++) { if (BIT_CHECK(graph[sel], oldSet[i])) { newSet[newce++] = oldSet[i]; } @@ -84,28 +91,30 @@ static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph findMaximumIndependentSet(cur, result, graph, newSet, newne, newce); } } - cur.size -= 1; + cur->size -= 1; if (k > 1) { for (s = ++ne; BIT_CHECK(graph[fixp], oldSet[s]); s++); } } } -nodemask_t MtmFindMaxClique(nodemask_t* graphs, in n_nodes); +nodemask_t MtmFindMaxClique(nodemask_t* graph, int n_nodes) { - List tmp; - List result; - nodemask_t mask = 0; + NodeList tmp; + NodeList result; + nodemask_t mask; int all[MAX_NODES]; int i; + tmp.size = 0; result.size = 0; for (i = 0; i < n_nodes; i++) { - all[i]= i; + all[i] = i; } findMaximumIndependentSet(&tmp, &result, graph, all, 0, n_nodes); + mask = 0; for (i = 0; i < result.size; i++) { mask |= (nodemask_t)1 << result.nodes[i]; } - return ~mask; + return mask; } diff --git a/bkb.h b/bkb.h new file mode 100644 index 0000000000..2ad2ba1464 --- /dev/null +++ b/bkb.h @@ -0,0 +1,16 @@ +/* + * Bron–Kerbosch algorithm to find maximum clique in graph + */ +#ifndef __BKB_H__ +#define __BKB_H__ + +#define MAX_NODES 64 + +typedef uint64_t nodemask_t; +#define BIT_CHECK(mask, bit) (((mask) & ((nodemask_t)1 << (bit))) != 0) +#define BIT_CLEAR(mask, bit) (mask &= ~((nodemask_t)1 << (bit))) +#define BIT_SET(mask, bit) (mask |= ((nodemask_t)1 << (bit))) + +extern nodemask_t MtmFindMaxClique(nodemask_t* matrix, int n_modes); + +#endif diff --git a/ddd.c b/ddd.c index 1b7125ee44..324969f33f 100644 --- a/ddd.c +++ b/ddd.c @@ -1,6 +1,8 @@ -#include -#include -#include +#include "postgres.h" +#include "access/clog.h" +#include "storage/lwlock.h" +#include "utils/hsearch.h" + #include "ddd.h" @@ -11,10 +13,10 @@ void MtmGraphInit(MtmGraph* graph) static inline MtmVertex* findVertex(MtmGraph* graph, GlobalTransactionId* gtid) { - xid_t h = gtid->xid % MAX_TRANSACTIONS; + uint32 h = gtid->xid % MAX_TRANSACTIONS; MtmVertex* v; - for (v = graph->hashtable[h]; v != NULL; v = v->next) { - if (v->gtid == *gtid) { + for (v = graph->hashtable[h]; v != NULL; v = v->collision) { + if (EQUAL_GTID(v->gtid, *gtid)) { return v; } } @@ -29,17 +31,15 @@ static inline MtmVertex* findVertex(MtmGraph* graph, GlobalTransactionId* gtid) void MtmGraphAdd(MtmGraph* graph, GlobalTransactionId* gtid, int size) { GlobalTransactionId* last = gtid + size; - MtmEdge *e, *next, *edges = NULL; while (gtid != last) { - Vertex* src = findVertex(graph, gtid++); + MtmVertex* src = findVertex(graph, gtid++); while (gtid->node != 0) { - Vertex* dst = findVertex(graph, gtid++); - e = (MtmEdge*)palloc(sizeof(MtmEdge)); - dst->nIncomingEdges += 1; + MtmVertex* dst = findVertex(graph, gtid++); + MtmEdge* e = (MtmEdge*)palloc(sizeof(MtmEdge)); e->dst = dst; e->src = src; - e->next = v->outgoingEdges; - v->outgoingEdges = e; + e->next = src->outgoingEdges; + src->outgoingEdges = e; } gtid += 1; } @@ -47,12 +47,12 @@ void MtmGraphAdd(MtmGraph* graph, GlobalTransactionId* gtid, int size) static bool recursiveTraverseGraph(MtmVertex* root, MtmVertex* v) { - Edge* e; - v->node = VISITED_NODE_MARK; + MtmEdge* e; + v->gtid.node = VISITED_NODE_MARK; for (e = v->outgoingEdges; e != NULL; e = e->next) { if (e->dst == root) { return true; - } else if (e->dst->node != VISITED_NODE_MAR && recursiveTraverseGraph(root, e->dst)) { /* loop */ + } else if (e->dst->gtid.node != VISITED_NODE_MARK && recursiveTraverseGraph(root, e->dst)) { /* loop */ return true; } } @@ -61,9 +61,9 @@ static bool recursiveTraverseGraph(MtmVertex* root, MtmVertex* v) bool MtmGraphFindLoop(MtmGraph* graph, GlobalTransactionId* root) { - Vertex* v; - for (v = graph->hashtable[root->xid % MAX_TRANSACTIONS]; v != NULL; v = v->next) { - if (v->gtid == *root) { + MtmVertex* v; + for (v = graph->hashtable[root->xid % MAX_TRANSACTIONS]; v != NULL; v = v->collision) { + if (EQUAL_GTID(v->gtid, *root)) { if (recursiveTraverseGraph(v, v)) { return true; } diff --git a/ddd.h b/ddd.h index 2ed36554c0..3399aed639 100644 --- a/ddd.h +++ b/ddd.h @@ -1,4 +1,5 @@ #ifndef __DDD_H__ +#define __DDD_H__ #include "multimaster.h" @@ -20,8 +21,8 @@ typedef struct MtmVertex typedef struct MtmGraph { - MtmVertex* hashtable[MTM_MAX_TRANSACTIONS]; -} Graph; + MtmVertex* hashtable[MAX_TRANSACTIONS]; +} MtmGraph; extern void MtmGraphInit(MtmGraph* graph); extern void MtmGraphAdd(MtmGraph* graph, GlobalTransactionId* subgraph, int size); diff --git a/multimaster.c b/multimaster.c index fd2bbde68b..4d8da84725 100644 --- a/multimaster.c +++ b/multimaster.c @@ -54,6 +54,8 @@ #include "catalog/indexing.h" #include "multimaster.h" +#include "ddd.h" +#include "paxos.h" typedef struct { TransactionId xid; /* local transaction ID */ @@ -112,7 +114,6 @@ static BgwPool* MtmPoolConstructor(void); static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); static void MtmVoteForTransaction(MtmTransState* ts); -static void MtmSerializeLockGraph(ByteBuffer* buf) static HTAB* xid2state; static MtmCurrentTrans dtmTx; @@ -440,6 +441,7 @@ static void MtmInitialize() dtm->oldestXid = FirstNormalTransactionId; dtm->nNodes = MtmNodes; dtm->disabledNodeMask = 0; + dtm->connectivityMask = 0; dtm->pglogicalNodeMask = 0; dtm->walSenderLockerMask = 0; dtm->nodeLockerMask = 0; @@ -543,7 +545,7 @@ MtmCheckClusterLock() } else { /* recovered replica catched up with master */ elog(WARNING, "WAL-sender %d complete receovery", i); - dtm->walSenderLockerMask &= ~((nodemask_t)1 << i); + BIT_CLEAR(dtm->walSenderLockerMask, i); } } } @@ -588,11 +590,15 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) } x->xid = GetCurrentTransactionId(); - + + if (dtm->disabledNodeMask != 0) { + MtmUpdateClusterStatus(); + } + MtmLock(LW_EXCLUSIVE); /* - * Check if there is global multimaster lock preventing new transaction from commit to make a chance to wal-senders to cache-up + * Check if there is global multimaster lock preventing new transaction from commit to make a chance to wal-senders to catch-up */ MtmCheckClusterLock(); @@ -714,8 +720,8 @@ bool MtmIsRecoveredNode(int nodeId) * Is there some better way to establish mapping between nodes ad WAL-seconder? */ MtmLock(LW_EXCLUSIVE); - dtm->nodeLockerMask |= (nodemask_t)1 << (nodeId-1); - dtm->walSenderLockerMask |= (nodemask_t)1 << (MyWalSnd - WalSndCtl->walsnds); + BIT_SET(dtm->nodeLockerMask, nodeId-1); + BIT_SET(dtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); dtm->nLockers += 1; MtmUnlock(); } @@ -1102,7 +1108,7 @@ void MtmReceiverStarted(int nodeId) { SpinLockAcquire(&dtm->spinlock); if (!BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { - dtm->pglogicalNodeMask |= (nodemask_t)1 << (nodeId-1); + BIT_SET(dtm->pglogicalNodeMask, nodeId-1); if (++dtm->nReceivers == dtm->nNodes-1) { elog(WARNING, "All receivers are started, switch to normal mode"); Assert(dtm->status == MTM_CONNECTED); @@ -1157,7 +1163,7 @@ void MtmDropNode(int nodeId, bool dropSlot) { elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, dtm->nNodes); } - dtm->disabledNodeMask |= ((int64)1 << (nodeId-1)); + BIT_SET(dtm->disabledNodeMask, nodeId-1); dtm->nNodes -= 1; if (!IsTransactionBlock()) { @@ -1220,7 +1226,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) char* conn_str = pstrdup(MtmConnStrs); char* conn_str_end = conn_str + strlen(conn_str); int i = 0; - int64 disabledNodeMask = dtm->disabledNodeMask; + nodemask_t disabledNodeMask = dtm->disabledNodeMask; int failedNode = -1; char const* errorMsg = NULL; PGconn **conns = palloc0(sizeof(PGconn*)*MtmNodes); @@ -1581,20 +1587,10 @@ MtmSerializeLock(PROCLOCK* proclock, void* arg) } /* Stubs */ -typedef PaxosTimestamp { - time_t time; /* local time at master */ - uint32 naster; /* master node for this operation */ - uint32 psn; /* PAXOS serial number */ -} PaxosTimestamp; - -void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts); -void PaxosSet(char const* key, void* value, int size); - static bool MtmDetectGlobalDeadLock(PGPROC* proc) { - bool hasDeadlock = false; ByteBuffer buf; PGXACT* pgxact = &ProcGlobal->allPgXact[proc->pgprocno]; bool hasDeadlock = false; @@ -1604,16 +1600,16 @@ MtmDetectGlobalDeadLock(PGPROC* proc) int i; ByteBufferAlloc(&buf); - EnumerateLocks(DtmSerializeLock, &buf); + EnumerateLocks(MtmSerializeLock, &buf); ByteBufferFree(&buf); - PaxosPut(dsprintf("lock-graph-%d", MMNodeId), buf.data, buf.size); + PaxosSet(psprintf("lock-graph-%d", MtmNodeId), buf.data, buf.size); MtmGraphInit(&graph); MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.size/sizeof(GlobalTransactionId)); for (i = 0; i < MtmNodes; i++) { - if (i+1 MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { + if (i+1 != MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { int size; - void* data = PaxosGet(dsprintf("lock-graph-%d", i+1), &size, NULL); - MtmGraphAdd(&graph, (GlobalTransactionId*)data, size/sizeof(GlobalTransactoinId)); + void* data = PaxosGet(psprintf("lock-graph-%d", i+1), &size, NULL); + MtmGraphAdd(&graph, (GlobalTransactionId*)data, size/sizeof(GlobalTransactionId)); } } MtmGetGtid(pgxact->xid, >id); @@ -1623,20 +1619,59 @@ MtmDetectGlobalDeadLock(PGPROC* proc) return hasDeadlock; } -void MtmOnLostConnection(int nodeId) +static void +MtmBuildConnectivityMatrix(nodemask_t* matrix) { int i; - nodemask_t mask = dtm->disabledNodeMask; - nodemask_t matrix = (nodemask_t*)palloc0(sizeof(nodemask_t)*MtmNodes); - - mask |= (nodemask_t)1 << (nodeId-1); - PaxosPut(dsprintf("node-mask-%d", MMNodeId), &mask, sizeof mask); - matrix[MtmNodeId-1] = mask; - MtmSleep(MtmConnectTimeout); - for (i = 0; i < MtnNodes; i++) { - if (i+1 != MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { - void* data = PaxosGet(dsprintf("node-mask-%d", i+1), NULL, NULL); + for (i = 0; i < MtmNodes; i++) { + if (i+1 != MtmNodeId) { + void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL); matrix[i] = *(nodemask_t*)data; + } else { + matrix[i] = dtm->connectivityMask; + } + } +} + + +void MtmUpdateClusterStatus(void) +{ + nodemask_t mask, clique; + nodemask_t matrix[MAX_NODES]; + int i; + + MtmBuildConnectivityMatrix(matrix); + + clique = MtmFindMaxClique(matrix, MtmNodes); + + MtmLock(LW_EXCLUSIVE); + mask = clique & ~dtm->disabledNodeMask; + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + dtm->nNodes -= 1; + BIT_SET(dtm->disabledNodeMask, i); } } + if (dtm->disabledNodeMask != clique) { + dtm->disabledNodeMask |= clique; + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->disabledNodeMask, sizeof dtm->disabledNodeMask); + } + MtmUnlock(); +} + +void MtmOnLostConnection(int nodeId) +{ + BIT_SET(dtm->connectivityMask, nodeId-1); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask); + + /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ + MtmSleep(MtmConnectTimeout); + + MtmUpdateClusterStatus(); +} + +void MtmOnConnectNode(int nodeId) +{ + BIT_CLEAR(dtm->connectivityMask, nodeId-1); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask); } diff --git a/multimaster.h b/multimaster.h index 354e6815af..a27fc09bff 100644 --- a/multimaster.h +++ b/multimaster.h @@ -3,6 +3,7 @@ #include "bytebuf.h" #include "bgwpool.h" +#include "bkb.h" #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) @@ -12,8 +13,6 @@ #define MTM_TUPLE_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ -#define BIT_CHECK(mask, bit) (((mask) & ((nodemask_t)1 << (bit))) != 0) - #define MULTIMASTER_NAME "mtm" #define MULTIMASTER_SCHEMA_NAME "mtm" #define MULTIMASTER_DDL_TABLE "ddl_log" @@ -25,13 +24,10 @@ #define Anum_mtm_ddl_log_issued 1 #define Anum_mtm_ddl_log_query 2 -#define MAX_NODES 64 - typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) typedef uint64 timestamp_t; -typedef uint64_t nodemask_t; /* Identifier of global transaction */ typedef struct @@ -40,6 +36,8 @@ typedef struct TransactionId xid; /* Transaction ID at this node */ } GlobalTransactionId; +#define EQUAL_GTID(x,y) ((x).node == (y).node && (x).xid == (y).xid) + typedef enum { MSG_INVALID, @@ -97,7 +95,8 @@ typedef struct PGSemaphoreData votingSemaphore; /* semaphore used to notify mtm-sender about new responses to coordinator */ LWLockPadded *locks; /* multimaster lock tranche */ TransactionId oldestXid; /* XID of oldest transaction visible by any active transaction (local or global) */ - nodemask_t disabledNodeMask; /* bitmask of disabled nodes (so no more than 64 nodes in multimaster:) */ + nodemask_t disabledNodeMask; /* bitmask of disabled nodes */ + nodemask_t connectivityMask; /* bitmask of dicconnected nodes */ nodemask_t pglogicalNodeMask; /* bitmask of started pglogic receivers */ nodemask_t walSenderLockerMask; /* Mask of WAL-senders IDs locking the cluster */ nodemask_t nodeLockerMask; /* Mask of node IDs which WAL-senders are locking the cluster */ @@ -143,10 +142,10 @@ extern void MtmLock(LWLockMode mode); extern void MtmUnlock(void); extern void MtmDropNode(int nodeId, bool dropSlot); extern void MtmOnLostConnection(int nodeId); +extern void MtmOnConnectNode(int nodeId); extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern bool MtmIsRecoveredNode(int nodeId); -extern nodemask_t MtmFindMaxClique(nodemask_t* matrix, in n_modes); - +extern void MtmUpdateClusterStatus(void); #endif diff --git a/paxos.h b/paxos.h new file mode 100644 index 0000000000..ff152bae70 --- /dev/null +++ b/paxos.h @@ -0,0 +1,13 @@ +#ifndef __PAXOS_H__ +#define __PAXOS_H__ + +typedef struct PaxosTimestamp { + time_t time; /* local time at master */ + uint32 master; /* master node for this operation */ + uint32 psn; /* PAXOS serial number */ +} PaxosTimestamp; + +extern void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts); +extern void PaxosSet(char const* key, void const* value, int size); + +#endif From 7889c2fa40afdd19e2d9510702a75fd1340ed8df Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 4 Mar 2016 19:11:22 +0300 Subject: [PATCH 0276/1139] Fix issues with deadlock detection --- arbiter.c | 6 ++--- bkb.c | 14 +++++----- bkbtest.c | 16 +++++++++++ multimaster.c | 66 ++++++++++++++++++++++++++++++++++++---------- multimaster.h | 4 +-- tests/dtmbench.cpp | 2 +- 6 files changed, 81 insertions(+), 27 deletions(-) create mode 100644 bkbtest.c diff --git a/arbiter.c b/arbiter.c index e5f9490a38..60857422e8 100644 --- a/arbiter.c +++ b/arbiter.c @@ -335,7 +335,7 @@ static void MtmOpenConnections() if (i+1 != MtmNodeId) { sockets[i] = MtmConnectSocket(host, MtmArbiterPort + i + 1, MtmConnectAttempts); if (sockets[i] < 0) { - MtmOnLostConnection(i+1); + MtmOnNodeDisconnect(i+1); } } else { sockets[i] = -1; @@ -360,7 +360,7 @@ static bool MtmSendToNode(int node, void const* buf, int size) } sockets[node] = MtmConnectSocket(hosts[node], MtmArbiterPort + node + 1, MtmReconnectAttempts); if (sockets[node] < 0) { - MtmOnLostConnection(node+1); + MtmOnNodeDisconnect(node+1); return false; } } @@ -403,7 +403,7 @@ static void MtmAcceptOneConnection() } else { elog(NOTICE, "Arbiter established connection with node %d", msg.node); BIT_CLEAR(ds->connectivityMask, msg.node-1); - MtmOnConnectNode(msg.node); + MtmOnNodeConnect(msg.node); MtmRegisterSocket(fd, msg.node-1); sockets[msg.node-1] = fd; } diff --git a/bkb.c b/bkb.c index 4d78a221bf..04d3063deb 100644 --- a/bkb.c +++ b/bkb.c @@ -1,4 +1,4 @@ -#include "postgres.h" +#include #include "bkb.h" /* @@ -12,7 +12,6 @@ typedef struct { static void list_append(NodeList* list, int n) { - Assert(list->size < MAX_NODES); list->nodes[list->size++] = n; } @@ -44,7 +43,7 @@ static void findMaximumIndependentSet(NodeList* cur, NodeList* result, nodemask_ int pos = -1; for (j = ne; j < ce; j++) { - if (!BIT_CHECK(graph[p], oldSet[j])) { + if (BIT_CHECK(graph[p], oldSet[j])) { if (++cnt == minnod) { break; } @@ -71,13 +70,13 @@ static void findMaximumIndependentSet(NodeList* cur, NodeList* result, nodemask_ newne = 0; for (i = 0; i < ne; i++) { - if (BIT_CHECK(graph[sel], oldSet[i])) { + if (!BIT_CHECK(graph[sel], oldSet[i])) { newSet[newne++] = oldSet[i]; } } newce = newne; for (i = ne + 1; i < ce; i++) { - if (BIT_CHECK(graph[sel], oldSet[i])) { + if (!BIT_CHECK(graph[sel], oldSet[i])) { newSet[newce++] = oldSet[i]; } } @@ -92,8 +91,9 @@ static void findMaximumIndependentSet(NodeList* cur, NodeList* result, nodemask_ } } cur->size -= 1; + ne += 1; if (k > 1) { - for (s = ++ne; BIT_CHECK(graph[fixp], oldSet[s]); s++); + for (s = ++ne; !BIT_CHECK(graph[fixp], oldSet[s]); s++); } } } @@ -114,7 +114,7 @@ nodemask_t MtmFindMaxClique(nodemask_t* graph, int n_nodes) findMaximumIndependentSet(&tmp, &result, graph, all, 0, n_nodes); mask = 0; for (i = 0; i < result.size; i++) { - mask |= (nodemask_t)1 << result.nodes[i]; + BIT_SET(mask, result.nodes[i]); } return mask; } diff --git a/bkbtest.c b/bkbtest.c new file mode 100644 index 0000000000..31cda3a073 --- /dev/null +++ b/bkbtest.c @@ -0,0 +1,16 @@ +#include +#include +#include "bkb.h" + +int main() { + nodemask_t matrix[64] = {0}; + nodemask_t clique; + matrix[0] = 6; + matrix[1] = 4; + matrix[2] = 1; + matrix[4] = 3; + clique = MtmFindMaxClique(matrix, 64); + printf("Clique=%lx\n", clique); + return 0; +} + diff --git a/multimaster.c b/multimaster.c index 4d8da84725..2f9690d0af 100644 --- a/multimaster.c +++ b/multimaster.c @@ -141,6 +141,7 @@ int MtmArbiterPort; int MtmNodes; int MtmConnectAttempts; int MtmConnectTimeout; +int MtmKeepaliveTimeout; int MtmReconnectAttempts; static int MtmQueueSize; @@ -986,6 +987,21 @@ _PG_init(void) NULL ); + DefineCustomIntVariable( + "multimaster.keepalive_timeout", + "Multimaster keepalive interval for sockets", + "Timeout in microseconds before polling state of nodes", + &MtmKeepaliveTimeout, + 1000000, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.connect_attempts", "Multimaster number of connect attemts", @@ -1528,8 +1544,12 @@ MtmGetGtid(TransactionId xid, GlobalTransactionId* gtid) MtmLock(LW_SHARED); ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); - Assert(ts != NULL); - *gtid = ts->gtid; + if (ts != NULL) { + *gtid = ts->gtid; + } else { + gtid->node = MtmNodeId; + gtid->xid = xid; + } MtmUnlock(); } @@ -1601,15 +1621,19 @@ MtmDetectGlobalDeadLock(PGPROC* proc) ByteBufferAlloc(&buf); EnumerateLocks(MtmSerializeLock, &buf); - ByteBufferFree(&buf); - PaxosSet(psprintf("lock-graph-%d", MtmNodeId), buf.data, buf.size); + PaxosSet(psprintf("lock-graph-%d", MtmNodeId), buf.data, buf.used); MtmGraphInit(&graph); - MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.size/sizeof(GlobalTransactionId)); + MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.used/sizeof(GlobalTransactionId)); + ByteBufferFree(&buf); for (i = 0; i < MtmNodes; i++) { if (i+1 != MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { int size; void* data = PaxosGet(psprintf("lock-graph-%d", i+1), &size, NULL); - MtmGraphAdd(&graph, (GlobalTransactionId*)data, size/sizeof(GlobalTransactionId)); + if (data == NULL) { + hasDeadlock = true; /* Just temporary hack until no Paxos */ + } else { + MtmGraphAdd(&graph, (GlobalTransactionId*)data, size/sizeof(GlobalTransactionId)); + } } } MtmGetGtid(pgxact->xid, >id); @@ -1636,42 +1660,56 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix) void MtmUpdateClusterStatus(void) { - nodemask_t mask, clique; + nodemask_t mask, clique, disconnectedMask; nodemask_t matrix[MAX_NODES]; int i; MtmBuildConnectivityMatrix(matrix); clique = MtmFindMaxClique(matrix, MtmNodes); - + disconnectedMask = ~clique & (((nodemask_t)1 << MtmNodes)-1); MtmLock(LW_EXCLUSIVE); - mask = clique & ~dtm->disabledNodeMask; + mask = disconnectedMask & ~dtm->disabledNodeMask; for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { dtm->nNodes -= 1; BIT_SET(dtm->disabledNodeMask, i); } } - if (dtm->disabledNodeMask != clique) { - dtm->disabledNodeMask |= clique; + if (dtm->disabledNodeMask != disconnectedMask) { + dtm->disabledNodeMask |= disconnectedMask; PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->disabledNodeMask, sizeof dtm->disabledNodeMask); } MtmUnlock(); } -void MtmOnLostConnection(int nodeId) +void MtmOnNodeDisconnect(int nodeId) { BIT_SET(dtm->connectivityMask, nodeId-1); PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask); /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ - MtmSleep(MtmConnectTimeout); + MtmSleep(MtmKeepaliveTimeout); MtmUpdateClusterStatus(); } -void MtmOnConnectNode(int nodeId) +void MtmOnNodeConnect(int nodeId) { BIT_CLEAR(dtm->connectivityMask, nodeId-1); PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask); } + +/* + * Paxos function stubs (until them are miplemented) + */ +void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts) +{ + if (size != NULL) { + *size = 0; + } + return NULL; +} + +void PaxosSet(char const* key, void const* value, int size) +{} diff --git a/multimaster.h b/multimaster.h index a27fc09bff..faa81bf902 100644 --- a/multimaster.h +++ b/multimaster.h @@ -141,8 +141,8 @@ extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); extern void MtmUnlock(void); extern void MtmDropNode(int nodeId, bool dropSlot); -extern void MtmOnLostConnection(int nodeId); -extern void MtmOnConnectNode(int nodeId); +extern void MtmOnNodeDisconnect(int nodeId); +extern void MtmOnNodeConnect(int nodeId); extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 506b466521..5a84f250ff 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -195,7 +195,7 @@ void initializeDatabase() exec(txn, "insert into t (select generate_series(0,%d), %d)", cfg.nAccounts-1, 0); txn.commit(); } - printf("Initialization completed in %f seconds\n", (start - getCurrentTime())/100000.0); + printf("Initialization completed in %f seconds\n", (getCurrentTime() - start)/100000.0); } int main (int argc, char* argv[]) From 4702e5cebecd7f5a42aab0e8b871d41dbbe95b37 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 4 Mar 2016 19:58:55 +0300 Subject: [PATCH 0277/1139] Handle changing of node status --- arbiter.c | 2 +- bkb.c | 3 ++- bkb.h | 2 +- multimaster.c | 53 ++++++++++++++++++++++++++++++++++----------------- multimaster.h | 2 ++ 5 files changed, 41 insertions(+), 21 deletions(-) diff --git a/arbiter.c b/arbiter.c index 60857422e8..ba623e0635 100644 --- a/arbiter.c +++ b/arbiter.c @@ -295,7 +295,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) goto Retry; } - /* Some node cnosidered that I am dead, so switch to recovery mode */ + /* Some node considered that I am dead, so switch to recovery mode */ if (BIT_CHECK(msg.disabledNodeMask, MtmNodeId-1)) { elog(WARNING, "Node is switched to recovery mode"); ds->status = MTM_RECOVERY; diff --git a/bkb.c b/bkb.c index 04d3063deb..572fc21a9b 100644 --- a/bkb.c +++ b/bkb.c @@ -98,7 +98,7 @@ static void findMaximumIndependentSet(NodeList* cur, NodeList* result, nodemask_ } } -nodemask_t MtmFindMaxClique(nodemask_t* graph, int n_nodes) +nodemask_t MtmFindMaxClique(nodemask_t* graph, int n_nodes, int* clique_size) { NodeList tmp; NodeList result; @@ -116,5 +116,6 @@ nodemask_t MtmFindMaxClique(nodemask_t* graph, int n_nodes) for (i = 0; i < result.size; i++) { BIT_SET(mask, result.nodes[i]); } + *clique_size = result.size; return mask; } diff --git a/bkb.h b/bkb.h index 2ad2ba1464..e0440209c7 100644 --- a/bkb.h +++ b/bkb.h @@ -11,6 +11,6 @@ typedef uint64_t nodemask_t; #define BIT_CLEAR(mask, bit) (mask &= ~((nodemask_t)1 << (bit))) #define BIT_SET(mask, bit) (mask |= ((nodemask_t)1 << (bit))) -extern nodemask_t MtmFindMaxClique(nodemask_t* matrix, int n_modes); +extern nodemask_t MtmFindMaxClique(nodemask_t* matrix, int n_modes, int* clique_size); #endif diff --git a/multimaster.c b/multimaster.c index 2f9690d0af..2fc4caca92 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1084,13 +1084,20 @@ _PG_fini(void) */ -static void MtmSwitchFromRecoveryToNormalMode() +void MtmSwitchToNormalMode() { dtm->status = MTM_ONLINE; elog(WARNING, "Switch to normal mode"); /* ??? Something else to do here? */ } +void MtmSwitchToRecoveryMode() +{ + dtm->status = MTM_RECOVERY; + /* ??? Something else to do here? */ + elog(ERROR, "Switch to normal mode"); +} + void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { @@ -1110,7 +1117,7 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) Assert(dtm->status == MTM_RECOVERY); } else if (dtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ - MtmSwitchFromRecoveryToNormalMode(); + MtmSwitchToNormalMode(); } dtmTx.gtid = *gtid; dtmTx.xid = GetCurrentTransactionId(); @@ -1646,8 +1653,8 @@ MtmDetectGlobalDeadLock(PGPROC* proc) static void MtmBuildConnectivityMatrix(nodemask_t* matrix) { - int i; - for (i = 0; i < MtmNodes; i++) { + int i, j, n = MtmNodes; + for (i = 0; i < n; i++) { if (i+1 != MtmNodeId) { void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL); matrix[i] = *(nodemask_t*)data; @@ -1655,32 +1662,42 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix) matrix[i] = dtm->connectivityMask; } } + /* make matrix symetric: required for Bron–Kerbosch algorithm */ + for (i = 0; i < n; i++) { + for (j = 0; j < i; j++) { + matrix[i] |= ((matrix[j] >> i) & 1) << j; + } + } } void MtmUpdateClusterStatus(void) { - nodemask_t mask, clique, disconnectedMask; + nodemask_t mask, clique; nodemask_t matrix[MAX_NODES]; + int clique_size; int i; MtmBuildConnectivityMatrix(matrix); - clique = MtmFindMaxClique(matrix, MtmNodes); - disconnectedMask = ~clique & (((nodemask_t)1 << MtmNodes)-1); - MtmLock(LW_EXCLUSIVE); - mask = disconnectedMask & ~dtm->disabledNodeMask; - for (i = 0; mask != 0; i++, mask >>= 1) { - if (mask & 1) { - dtm->nNodes -= 1; - BIT_SET(dtm->disabledNodeMask, i); + clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); + if (clique_size >= MtmNodes/2+1) { /* have quorum */ + MtmLock(LW_EXCLUSIVE); + mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + dtm->nNodes -= 1; + BIT_SET(dtm->disabledNodeMask, i); + } } + MtmUnlock(); + if (BIT_CHECK(dtm->disabledNodeMask, MtmNodeId-1)) { + /* I was excluded from cluster:( */ + MtmSwitchToRecoveryMode(); + } + } else { + elog(WARNING, "Clique %lx has no quorum", clique); } - if (dtm->disabledNodeMask != disconnectedMask) { - dtm->disabledNodeMask |= disconnectedMask; - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->disabledNodeMask, sizeof dtm->disabledNodeMask); - } - MtmUnlock(); } void MtmOnNodeDisconnect(int nodeId) diff --git a/multimaster.h b/multimaster.h index faa81bf902..b575f55774 100644 --- a/multimaster.h +++ b/multimaster.h @@ -148,4 +148,6 @@ extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmUpdateClusterStatus(void); +extern void MtmSwitchToNormalMode(void); +extern void MtmSwitchToRecoveryMode(void); #endif From 9eb2b3dcdcc87a08c1b584cbdfed4bab7701ea68 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Fri, 4 Mar 2016 23:27:45 +0300 Subject: [PATCH 0278/1139] Perform select with timeout in arbiter --- arbiter.c | 21 +++++++++++-------- multimaster.c | 57 ++++++++++++++++++++++++++++++++++----------------- multimaster.h | 6 ++++-- 3 files changed, 55 insertions(+), 29 deletions(-) diff --git a/arbiter.c b/arbiter.c index ba623e0635..e996ad294d 100644 --- a/arbiter.c +++ b/arbiter.c @@ -297,8 +297,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) /* Some node considered that I am dead, so switch to recovery mode */ if (BIT_CHECK(msg.disabledNodeMask, MtmNodeId-1)) { - elog(WARNING, "Node is switched to recovery mode"); - ds->status = MTM_RECOVERY; + MtmClusterSwitchMode(MTM_RECOVERY); } /* Combine disable masks from all node. Is it actually correct or we should better check availability of nodes ourselves? */ ds->disabledNodeMask |= msg.disabledNodeMask; @@ -345,8 +344,7 @@ static void MtmOpenConnections() elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", ds->nNodes, MtmNodes); ds->status = MTM_OFFLINE; } else if (ds->status == MTM_INITIALIZATION) { - elog(WARNING, "Switch to CONNECTED mode"); - ds->status = MTM_CONNECTED; + MtmClusterSwitchMode(MTM_CONNECTED); } } @@ -403,9 +401,9 @@ static void MtmAcceptOneConnection() } else { elog(NOTICE, "Arbiter established connection with node %d", msg.node); BIT_CLEAR(ds->connectivityMask, msg.node-1); - MtmOnNodeConnect(msg.node); MtmRegisterSocket(fd, msg.node-1); sockets[msg.node-1] = fd; + MtmOnNodeConnect(msg.node); } } } @@ -586,7 +584,7 @@ static void MtmTransReceiver(Datum arg) while (true) { #if USE_EPOLL - n = epoll_wait(epollfd, events, nNodes, -1); + n = epoll_wait(epollfd, events, nNodes, MtmKeepaliveTimeout/1000); if (n < 0) { elog(ERROR, "Arbiter failed to poll sockets: %d", errno); } @@ -600,9 +598,12 @@ static void MtmTransReceiver(Datum arg) #else fd_set events; do { + struct timeval tv; events = inset; - rc = select(max_fd+1, &events, NULL, NULL, NULL); - } while (rc < 0 && MtmRecovery()); + tv.tv_sec = MtmKeepAliveTimeout/USEC; + tv.tv_usec = MtmKeepAliveTimeout%USEC; + n = select(max_fd+1, &events, NULL, NULL, &tv); + } while (n < 0 && MtmRecovery()); if (rc < 0) { elog(ERROR, "Arbiter failed to select sockets: %d", errno); @@ -742,6 +743,10 @@ static void MtmTransReceiver(Datum arg) } } } + if (n == 0 && ds->disabledNodeMask != 0) { + /* If timeout is expired and there are didabled nodes, then recheck cluster's state */ + MtmUpdateClusterStatus(); + } } } diff --git a/multimaster.c b/multimaster.c index 2fc4caca92..4a7dd8f12d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -77,7 +77,6 @@ typedef enum #define MTM_SHMEM_SIZE (64*1024*1024) #define MTM_HASH_SIZE 100003 -#define USEC 1000000 #define MIN_WAIT_TIMEOUT 1000 #define MAX_WAIT_TIMEOUT 100000 #define STATUS_POLL_DELAY USEC @@ -132,6 +131,15 @@ static TransactionManager MtmTM = { MtmGetName }; +static char const* const MtmNodeStatusMnem[] = +{ + "Intialization", + "Offline", + "Connected", + "Online", + "Recovery" +}; + bool MtmDoReplication; char* MtmDatabaseName; @@ -509,8 +517,9 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->isReplicated = false; x->isDistributed = MtmIsUserTransaction(); if (x->isDistributed && dtm->status != MTM_ONLINE) { - MtmUnlock(); - elog(ERROR, "Multimaster node is offline"); + /* reject all user's transactions at offline cluster */ + MtmUnlock(); + elog(ERROR, "Multimaster node is not online"); } x->containsDML = false; x->isPrepared = false; @@ -594,6 +603,9 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) if (dtm->disabledNodeMask != 0) { MtmUpdateClusterStatus(); + if (dtm->status != MTM_ONLINE) { + elog(ERROR, "Abort current transaction because this cluster node is not online"); + } } MtmLock(LW_EXCLUSIVE); @@ -1084,21 +1096,13 @@ _PG_fini(void) */ -void MtmSwitchToNormalMode() -{ - dtm->status = MTM_ONLINE; - elog(WARNING, "Switch to normal mode"); - /* ??? Something else to do here? */ -} - -void MtmSwitchToRecoveryMode() +void MtmClusterSwitchMode(MtmNodeStatus mode) { - dtm->status = MTM_RECOVERY; + dtm->status = mode; + elog(WARNING, "Switch to %s mode", MtmNodeStatusMnem[mode]); /* ??? Something else to do here? */ - elog(ERROR, "Switch to normal mode"); } - void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { csn_t localSnapshot; @@ -1117,7 +1121,7 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) Assert(dtm->status == MTM_RECOVERY); } else if (dtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ - MtmSwitchToNormalMode(); + MtmClusterSwitchMode(MTM_ONLINE); } dtmTx.gtid = *gtid; dtmTx.xid = GetCurrentTransactionId(); @@ -1670,7 +1674,10 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix) } } - +/** + * Build connectivity graph, find clique in it and extend disabledNodeMask by nodes not included in clique. + * This function returns false if current node is excluded from cluster, true otherwise + */ void MtmUpdateClusterStatus(void) { nodemask_t mask, clique; @@ -1683,17 +1690,29 @@ void MtmUpdateClusterStatus(void) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ MtmLock(LW_EXCLUSIVE); - mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; + mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { dtm->nNodes -= 1; BIT_SET(dtm->disabledNodeMask, i); } } + mask = clique & dtm->disabledNodeMask; /* new enabled nodes mask */ + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + dtm->nNodes += 1; + BIT_CLEAR(dtm->disabledNodeMask, i); + } + } MtmUnlock(); if (BIT_CHECK(dtm->disabledNodeMask, MtmNodeId-1)) { - /* I was excluded from cluster:( */ - MtmSwitchToRecoveryMode(); + if (dtm->status == MTM_ONLINE) { + /* I was excluded from cluster:( */ + MtmClusterSwitchMode(MTM_OFFLINE); + } + } else if (dtm->status == MTM_OFFLINE) { + /* Should we somehow restart logical receivers? */ + MtmClusterSwitchMode(MTM_RECOVERY); } } else { elog(WARNING, "Clique %lx has no quorum", clique); diff --git a/multimaster.h b/multimaster.h index b575f55774..f280b501bc 100644 --- a/multimaster.h +++ b/multimaster.h @@ -20,6 +20,8 @@ #define MULTIMASTER_MIN_PROTO_VERSION 1 #define MULTIMASTER_MAX_PROTO_VERSION 1 +#define USEC 1000000 + #define Natts_mtm_ddl_log 2 #define Anum_mtm_ddl_log_issued 1 #define Anum_mtm_ddl_log_query 2 @@ -124,6 +126,7 @@ extern char* MtmDatabaseName; extern int MtmConnectAttempts; extern int MtmConnectTimeout; extern int MtmReconnectAttempts; +extern int MtmKeepaliveTimeout; extern void MtmArbiterInitialize(void); extern int MtmStartReceivers(char* nodes, int nodeId); @@ -148,6 +151,5 @@ extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmUpdateClusterStatus(void); -extern void MtmSwitchToNormalMode(void); -extern void MtmSwitchToRecoveryMode(void); +extern void MtmClusterSwitchMode(MtmNodeStatus mode); #endif From e0105f6de50f4d4f6a3099dcee2c41a44466e71b Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 5 Mar 2016 10:52:54 +0300 Subject: [PATCH 0279/1139] Update Paxos interface --- arbiter.c | 6 +++--- multimaster.c | 38 +++++++++++++++++++------------------- multimaster.h | 6 ++++-- paxos.h | 23 +++++++++++++++++++++-- pglogical_receiver.c | 6 ++++++ 5 files changed, 53 insertions(+), 26 deletions(-) diff --git a/arbiter.c b/arbiter.c index e996ad294d..7294b941d3 100644 --- a/arbiter.c +++ b/arbiter.c @@ -297,7 +297,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) /* Some node considered that I am dead, so switch to recovery mode */ if (BIT_CHECK(msg.disabledNodeMask, MtmNodeId-1)) { - MtmClusterSwitchMode(MTM_RECOVERY); + MtmSwitchClusterMode(MTM_RECOVERY); } /* Combine disable masks from all node. Is it actually correct or we should better check availability of nodes ourselves? */ ds->disabledNodeMask |= msg.disabledNodeMask; @@ -344,7 +344,7 @@ static void MtmOpenConnections() elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", ds->nNodes, MtmNodes); ds->status = MTM_OFFLINE; } else if (ds->status == MTM_INITIALIZATION) { - MtmClusterSwitchMode(MTM_CONNECTED); + MtmSwitchClusterMode(MTM_CONNECTED); } } @@ -745,7 +745,7 @@ static void MtmTransReceiver(Datum arg) } if (n == 0 && ds->disabledNodeMask != 0) { /* If timeout is expired and there are didabled nodes, then recheck cluster's state */ - MtmUpdateClusterStatus(); + MtmRefreshClusterStatus(false); } } } diff --git a/multimaster.c b/multimaster.c index 4a7dd8f12d..e68e745807 100644 --- a/multimaster.c +++ b/multimaster.c @@ -131,7 +131,7 @@ static TransactionManager MtmTM = { MtmGetName }; -static char const* const MtmNodeStatusMnem[] = +char const* const MtmNodeStatusMnem[] = { "Intialization", "Offline", @@ -602,7 +602,7 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) x->xid = GetCurrentTransactionId(); if (dtm->disabledNodeMask != 0) { - MtmUpdateClusterStatus(); + MtmRefreshClusterStatus(true); if (dtm->status != MTM_ONLINE) { elog(ERROR, "Abort current transaction because this cluster node is not online"); } @@ -1096,7 +1096,7 @@ _PG_fini(void) */ -void MtmClusterSwitchMode(MtmNodeStatus mode) +void MtmSwitchClusterMode(MtmNodeStatus mode) { dtm->status = mode; elog(WARNING, "Switch to %s mode", MtmNodeStatusMnem[mode]); @@ -1121,7 +1121,8 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) Assert(dtm->status == MTM_RECOVERY); } else if (dtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ - MtmClusterSwitchMode(MTM_ONLINE); + dtm->recoverySlot = 0; + MtmSwitchClusterMode(MTM_ONLINE); } dtmTx.gtid = *gtid; dtmTx.xid = GetCurrentTransactionId(); @@ -1137,9 +1138,8 @@ void MtmReceiverStarted(int nodeId) if (!BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { BIT_SET(dtm->pglogicalNodeMask, nodeId-1); if (++dtm->nReceivers == dtm->nNodes-1) { - elog(WARNING, "All receivers are started, switch to normal mode"); Assert(dtm->status == MTM_CONNECTED); - dtm->status = MTM_ONLINE; + MtmSwitchClusterMode(MTM_OFFLINE); } } SpinLockRelease(&dtm->spinlock); @@ -1632,14 +1632,14 @@ MtmDetectGlobalDeadLock(PGPROC* proc) ByteBufferAlloc(&buf); EnumerateLocks(MtmSerializeLock, &buf); - PaxosSet(psprintf("lock-graph-%d", MtmNodeId), buf.data, buf.used); + PaxosSet(psprintf("lock-graph-%d", MtmNodeId), buf.data, buf.used, true); MtmGraphInit(&graph); MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.used/sizeof(GlobalTransactionId)); ByteBufferFree(&buf); for (i = 0; i < MtmNodes; i++) { if (i+1 != MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { int size; - void* data = PaxosGet(psprintf("lock-graph-%d", i+1), &size, NULL); + void* data = PaxosGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); if (data == NULL) { hasDeadlock = true; /* Just temporary hack until no Paxos */ } else { @@ -1655,12 +1655,12 @@ MtmDetectGlobalDeadLock(PGPROC* proc) } static void -MtmBuildConnectivityMatrix(nodemask_t* matrix) +MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) { int i, j, n = MtmNodes; for (i = 0; i < n; i++) { if (i+1 != MtmNodeId) { - void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL); + void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); matrix[i] = *(nodemask_t*)data; } else { matrix[i] = dtm->connectivityMask; @@ -1678,14 +1678,14 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix) * Build connectivity graph, find clique in it and extend disabledNodeMask by nodes not included in clique. * This function returns false if current node is excluded from cluster, true otherwise */ -void MtmUpdateClusterStatus(void) +void MtmRefreshClusterStatus(bool nowait) { nodemask_t mask, clique; nodemask_t matrix[MAX_NODES]; int clique_size; int i; - MtmBuildConnectivityMatrix(matrix); + MtmBuildConnectivityMatrix(matrix, nowait); clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ @@ -1708,11 +1708,11 @@ void MtmUpdateClusterStatus(void) if (BIT_CHECK(dtm->disabledNodeMask, MtmNodeId-1)) { if (dtm->status == MTM_ONLINE) { /* I was excluded from cluster:( */ - MtmClusterSwitchMode(MTM_OFFLINE); + MtmSwitchClusterMode(MTM_OFFLINE); } } else if (dtm->status == MTM_OFFLINE) { /* Should we somehow restart logical receivers? */ - MtmClusterSwitchMode(MTM_RECOVERY); + MtmSwitchClusterMode(MTM_RECOVERY); } } else { elog(WARNING, "Clique %lx has no quorum", clique); @@ -1722,24 +1722,24 @@ void MtmUpdateClusterStatus(void) void MtmOnNodeDisconnect(int nodeId) { BIT_SET(dtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ MtmSleep(MtmKeepaliveTimeout); - MtmUpdateClusterStatus(); + MtmRefreshClusterStatus(false); } void MtmOnNodeConnect(int nodeId) { BIT_CLEAR(dtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); } /* * Paxos function stubs (until them are miplemented) */ -void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts) +void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts, bool nowait) { if (size != NULL) { *size = 0; @@ -1747,5 +1747,5 @@ void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts) return NULL; } -void PaxosSet(char const* key, void const* value, int size) +void PaxosSet(char const* key, void const* value, int size, bool nowait) {} diff --git a/multimaster.h b/multimaster.h index f280b501bc..98e9167fbb 100644 --- a/multimaster.h +++ b/multimaster.h @@ -118,6 +118,8 @@ typedef struct #define MtmIsCoordinator(ts) (ts->gtid.node == MtmNodeId) +extern char const* const MtmNodeStatusMnem[]; + extern char* MtmConnStrs; extern int MtmNodeId; extern int MtmNodes; @@ -150,6 +152,6 @@ extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern bool MtmIsRecoveredNode(int nodeId); -extern void MtmUpdateClusterStatus(void); -extern void MtmClusterSwitchMode(MtmNodeStatus mode); +extern void MtmRefreshClusterStatus(bool nowait); +extern void MtmSwitchClusterMode(MtmNodeStatus mode); #endif diff --git a/paxos.h b/paxos.h index ff152bae70..3bcf091007 100644 --- a/paxos.h +++ b/paxos.h @@ -7,7 +7,26 @@ typedef struct PaxosTimestamp { uint32 psn; /* PAXOS serial number */ } PaxosTimestamp; -extern void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts); -extern void PaxosSet(char const* key, void const* value, int size); +/* + * Get key value. + * Returns NULL if key doesn't exist. + * Value should be copied into caller's private memory using palloc. + * If "size" is not NULL, then it is assigned size of value. + * If "ts" is not NULL, then it is assigned timestamp of last update of this value + * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. + */ +extern void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts, bool nowait); +/* + * Set new value for the specified key. IF value is NULL, then key should be deleted. + * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. + */ +extern void PaxosSet(char const* key, void const* value, int size, bool nowait); + +/* + * If key doesn't exists or its value is not equal to the specified value then store this value and return true. + * Otherwise do nothing and return false. + * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. + */ +extern bool PaxosCAS(char const* key, char const* value, bool nowait); #endif diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 570d21b8ef..1cbc54e30a 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -332,6 +332,12 @@ pglogical_receiver_main(Datum main_arg) if (rc & WL_POSTMASTER_DEATH) proc_exit(1); + if (ds->status != MTM_ONLINE && (ds->status != MTM_RECOVERY || ds->recoverySlot != args->remote_node)) { + ereport(LOG, (errmsg("%s: terminating WAL receiver because node is switched to %s mode", worker_proc, MtmNodeStatusMnem[ds->status]))); + proc_exit(0); + } + + /* Some cleanup */ if (copybuf != NULL) { From f051d35323da0621f4facd59e18796d59f4626c6 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 5 Mar 2016 23:26:30 +0300 Subject: [PATCH 0280/1139] Add recover_node function --- arbiter.c | 5 +++-- bgwpool.c | 2 +- bgwpool.h | 1 + multimaster--1.0.sql | 6 ++++++ multimaster.c | 28 +++++++++++++++++++++++++++- multimaster.h | 3 ++- pglogical_apply.c | 2 +- pglogical_receiver.c | 5 ++--- 8 files changed, 43 insertions(+), 9 deletions(-) diff --git a/arbiter.c b/arbiter.c index 7294b941d3..8c973f692e 100644 --- a/arbiter.c +++ b/arbiter.c @@ -119,7 +119,7 @@ static BackgroundWorker MtmSender = { "mtm-sender", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, - 1, /* restart in one second (is it possible to restart immediately?) */ + MULTIMASTER_BGW_RESTART_TIMEOUT, MtmTransSender }; @@ -127,7 +127,7 @@ static BackgroundWorker MtmRecevier = { "mtm-receiver", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, - 1, /* restart in one second (is it possible to restart immediately?) */ + MULTIMASTER_BGW_RESTART_TIMEOUT, MtmTransReceiver }; @@ -297,6 +297,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) /* Some node considered that I am dead, so switch to recovery mode */ if (BIT_CHECK(msg.disabledNodeMask, MtmNodeId-1)) { + elog(WARNING, "Node %d think that I am dead", msg.node); MtmSwitchClusterMode(MTM_RECOVERY); } /* Combine disable masks from all node. Is it actually correct or we should better check availability of nodes ourselves? */ diff --git a/bgwpool.c b/bgwpool.c index 933f7fcfb2..cb9a0c305f 100644 --- a/bgwpool.c +++ b/bgwpool.c @@ -85,7 +85,7 @@ void BgwPoolStart(int nWorkers, BgwPoolConstructor constructor) worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; worker.bgw_start_time = BgWorkerStart_ConsistentState; worker.bgw_main = BgwPoolMainLoop; - worker.bgw_restart_time = 10; /* Wait 10 seconds for restart before crash */ + worker.bgw_restart_time = MULTIMASTER_BGW_RESTART_TIMEOUT; for (i = 0; i < nWorkers; i++) { BgwPoolExecutorCtx* ctx = (BgwPoolExecutorCtx*)malloc(sizeof(BgwPoolExecutorCtx)); diff --git a/bgwpool.h b/bgwpool.h index 36303fd155..4668f4d76a 100644 --- a/bgwpool.h +++ b/bgwpool.h @@ -8,6 +8,7 @@ typedef void(*BgwPoolExecutor)(int id, void* work, size_t size); #define MAX_DBNAME_LEN 30 +#define MULTIMASTER_BGW_RESTART_TIMEOUT 10 /* seconds */ typedef struct { diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 74e48313ba..b325a2e57a 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -13,6 +13,12 @@ CREATE FUNCTION mtm.drop_node(node integer, drop_slot bool default false) RETURN AS 'MODULE_PATHNAME','mtm_drop_node' LANGUAGE C; +-- Create replication slot for the node which was previously dropped together with it's slot +CREATE FUNCTION mtm.recover_node(node integer) RETURNS void +AS 'MODULE_PATHNAME','mtm_recover_node' +LANGUAGE C; + + CREATE FUNCTION mtm.get_snapshot() RETURNS bigint AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; diff --git a/multimaster.c b/multimaster.c index e68e745807..6e071520b5 100644 --- a/multimaster.c +++ b/multimaster.c @@ -89,6 +89,7 @@ PG_MODULE_MAGIC; PG_FUNCTION_INFO_V1(mtm_start_replication); PG_FUNCTION_INFO_V1(mtm_stop_replication); PG_FUNCTION_INFO_V1(mtm_drop_node); +PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); static Snapshot MtmGetSnapshot(Snapshot snapshot); @@ -1182,6 +1183,22 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) return dtm->recoverySlot ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; } +void MtmRecoverNode(int nodeId) +{ + if (nodeId <= 0 || nodeId > dtm->nNodes) + { + elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, dtm->nNodes); + } + if (!BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) { + elog(ERROR, "Node %d was not disabled", nodeId); + } + if (!IsTransactionBlock()) + { + MtmBroadcastUtilityStmt(psprintf("select pg_create_logical_replication_slot('" MULTIMASTER_SLOT_PATTERN "', '" MULTIMASTER_NAME "')", nodeId), true); + } +} + + void MtmDropNode(int nodeId, bool dropSlot) { if (!BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) @@ -1227,6 +1244,14 @@ mtm_drop_node(PG_FUNCTION_ARGS) PG_RETURN_VOID(); } +Datum +mtm_recover_node(PG_FUNCTION_ARGS) +{ + int nodeId = PG_GETARG_INT32(0); + MtmRecoverNode(nodeId); + PG_RETURN_VOID(); +} + Datum mtm_get_snapshot(PG_FUNCTION_ARGS) { @@ -1599,7 +1624,7 @@ MtmSerializeLock(PROCLOCK* proclock, void* arg) { if ((proclock->holdMask & LOCKBIT_ON(lm)) && (conflictMask & LOCKBIT_ON(lm))) { - MTM_TRACE("%d: %u(%u) waits for %u(%u)\n", getpid(), srcPgXact->xid, proc->pid, dstPgXact->xid, proclock->tag.myProc->pid); + MTM_TRACE("%d: %u(%u) waits for %u(%u)\n", MyProcPid, srcPgXact->xid, proc->pid, dstPgXact->xid, proclock->tag.myProc->pid); MtmGetGtid(srcPgXact->xid, >id); /* transaction holding lock */ ByteBufferAppendInt32(buf, gtid.node); ByteBufferAppendInt32(buf, gtid.xid); @@ -1689,6 +1714,7 @@ void MtmRefreshClusterStatus(bool nowait) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ + elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, dtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { diff --git a/multimaster.h b/multimaster.h index 98e9167fbb..ee1adf3fd4 100644 --- a/multimaster.h +++ b/multimaster.h @@ -13,7 +13,7 @@ #define MTM_TUPLE_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ -#define MULTIMASTER_NAME "mtm" +#define MULTIMASTER_NAME "multimaster" #define MULTIMASTER_SCHEMA_NAME "mtm" #define MULTIMASTER_DDL_TABLE "ddl_log" #define MULTIMASTER_SLOT_PATTERN "mtm_slot_%d" @@ -146,6 +146,7 @@ extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); extern void MtmUnlock(void); extern void MtmDropNode(int nodeId, bool dropSlot); +extern void MtmRecoverNode(int nodeId); extern void MtmOnNodeDisconnect(int nodeId); extern void MtmOnNodeConnect(int nodeId); extern MtmState* MtmGetState(void); diff --git a/pglogical_apply.c b/pglogical_apply.c index fa1cbb097e..15f22604f7 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -830,7 +830,7 @@ void MtmExecutor(int id, void* work, size_t size) PG_CATCH(); { FlushErrorState(); - MTM_TRACE("%d: REMOTE abort transaction %d\n", getpid(), GetCurrentTransactionId()); + MTM_TRACE("%d: REMOTE abort transaction %d\n", MyProcPid, GetCurrentTransactionId()); AbortCurrentTransaction(); } PG_END_TRY(); diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 1cbc54e30a..0a2ba28765 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -56,7 +56,6 @@ static int receiver_idle_time = 0; static bool receiver_sync_mode = false; /* Worker name */ -static char *worker_name = "multimaster"; char worker_proc[BGW_MAXLEN]; /* Lastly written positions */ @@ -252,7 +251,7 @@ pglogical_receiver_main(Datum main_arg) resetPQExpBuffer(query); } if (mode != SLOT_OPEN_EXISTED) { - appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"", args->receiver_slot, worker_name); + appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"", args->receiver_slot, MULTIMASTER_NAME); res = PQexec(conn, query->data); if (PQresultStatus(res) != PGRES_TUPLES_OK) { @@ -568,7 +567,7 @@ int MtmStartReceivers(char* conns, int node_id) worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; worker.bgw_start_time = BgWorkerStart_ConsistentState; worker.bgw_main = pglogical_receiver_main; - worker.bgw_restart_time = 10; /* Wait 10 seconds for restart before crash */ + worker.bgw_restart_time = MULTIMASTER_BGW_RESTART_TIMEOUT; while (conn_str < conn_str_end) { char* p = strchr(conn_str, ','); From 5f7a3ec6901a17591c8079747dcd1715e1ffed78 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 6 Mar 2016 11:52:45 +0300 Subject: [PATCH 0281/1139] Add mtm.get_cluster_state and mtm.get_nodes_state --- bgwpool.c | 10 +++++ bgwpool.h | 2 + multimaster--1.0.sql | 13 +++++++ multimaster.c | 93 +++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 116 insertions(+), 2 deletions(-) diff --git a/bgwpool.c b/bgwpool.c index cb9a0c305f..74f6662751 100644 --- a/bgwpool.c +++ b/bgwpool.c @@ -97,6 +97,16 @@ void BgwPoolStart(int nWorkers, BgwPoolConstructor constructor) } } +size_t BgwPoolGetQueueSize(BgwPool* pool) +{ + size_t used; + SpinLockAcquire(&pool->lock); + used = pool->head <= pool->tail ? pool->tail - pool->head : pool->size - pool->head + pool->tail; + SpinLockRelease(&pool->lock); + return used; +} + + void BgwPoolExecute(BgwPool* pool, void* work, size_t size) { Assert(size+4 <= pool->size); diff --git a/bgwpool.h b/bgwpool.h index 4668f4d76a..822ec4b93c 100644 --- a/bgwpool.h +++ b/bgwpool.h @@ -33,4 +33,6 @@ extern void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbn extern void BgwPoolExecute(BgwPool* pool, void* work, size_t size); +extern size_t BgwPoolGetQueueSize(BgwPool* pool); + #endif diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index b325a2e57a..39c2398a26 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -23,4 +23,17 @@ CREATE FUNCTION mtm.get_snapshot() RETURNS bigint AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; + +CREATE TYPE mtm.node_state(id integer, disabled bool, disconnected bool, catchUp boolean, slotLag bigint, connStr text); + +CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state +AS 'MODULE_PATHNAME','mtm_get_nodes_state' +LANGUAGE C; + +CREATE TYPE mtm.cluster_state(status text, disabledNodeMask bigint, disconnectedNodeMask bigint, catchUpNodeMask bigint, nNodes integer, nActiveQueries integer, queueSize bigint); + +CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state +AS 'MODULE_PATHNAME','mtm_get_cluster_state' +LANGUAGE C; + CREATE TABLE IF NOT EXISTS mtm.ddl_log (issued timestamp with time zone not null, query text); diff --git a/multimaster.c b/multimaster.c index 6e071520b5..eeccd04d2b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -10,6 +10,7 @@ #include #include "postgres.h" +#include "funcapi.h" #include "fmgr.h" #include "miscadmin.h" #include "libpq-fe.h" @@ -91,6 +92,8 @@ PG_FUNCTION_INFO_V1(mtm_stop_replication); PG_FUNCTION_INFO_V1(mtm_drop_node); PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); +PG_FUNCTION_INFO_V1(mtm_get_nodes_state); +PG_FUNCTION_INFO_V1(mtm_get_cluster_state); static Snapshot MtmGetSnapshot(Snapshot snapshot); static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); @@ -683,6 +686,22 @@ static void MtmCheckSlots() } } +static int64 MtmGetSlotLag(int nodeId) +{ + int i; + for (i = 0; i < max_replication_slots; i++) { + ReplicationSlot* slot = &ReplicationSlotCtl->replication_slots[i]; + int node; + if (slot->in_use + && sscanf(slot->data.name.data, MULTIMASTER_SLOT_PATTERN, &node) == 1 + && node == nodeId) + { + return GetXLogInsertRecPtr() - slot->data.restart_lsn; + } + } + return -1; +} + static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { @@ -932,8 +951,8 @@ _PG_init(void) "Multimaster queue size", NULL, &MtmQueueSize, - 1024*1024, - 1024, + 256*1024*1024, + 1024*1024, INT_MAX, PGC_BACKEND, 0, @@ -1258,6 +1277,76 @@ mtm_get_snapshot(PG_FUNCTION_ARGS) PG_RETURN_INT64(dtmTx.snapshot); } +typedef struct +{ + int nodeId; + char* connStrPtr; + TupleDesc desc; + Datum values[6]; + bool nulls[6]; +} MtmGetNodeStateCtx; + +Datum +mtm_get_nodes_state(PG_FUNCTION_ARGS) +{ + FuncCallContext* funcctx; + MtmGetNodeStateCtx* usrfctx; + MemoryContext oldcontext; + char* p; + bool is_first_call = SRF_IS_FIRSTCALL(); + + if (is_first_call) { + funcctx = SRF_FIRSTCALL_INIT(); + oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); + usrfctx = (MtmGetNodeStateCtx*)palloc(sizeof(MtmGetNodeStateCtx)); + get_call_result_type(fcinfo, NULL, &usrfctx->desc); + usrfctx->nodeId = 1; + usrfctx->connStrPtr = pstrdup(MtmConnStrs); + memset(usrfctx->nulls, false, sizeof(usrfctx->nulls)); + funcctx->user_fctx = usrfctx; + MemoryContextSwitchTo(oldcontext); + } + funcctx = SRF_PERCALL_SETUP(); + usrfctx = (MtmGetNodeStateCtx*)funcctx->user_fctx; + if (usrfctx->nodeId > MtmNodes) { + SRF_RETURN_DONE(funcctx); + } + usrfctx->values[0] = Int32GetDatum(usrfctx->nodeId); + usrfctx->values[1] = BoolGetDatum(BIT_CHECK(dtm->disabledNodeMask, usrfctx->nodeId-1)); + usrfctx->values[2] = BoolGetDatum(BIT_CHECK(dtm->connectivityMask, usrfctx->nodeId-1)); + usrfctx->values[3] = BoolGetDatum(BIT_CHECK(dtm->nodeLockerMask, usrfctx->nodeId-1)); + usrfctx->values[4] = Int64GetDatum(MtmGetSlotLag(usrfctx->nodeId)); + p = strchr(usrfctx->connStrPtr, ','); + if (p != NULL) { + *p++ = '\0'; + } + usrfctx->values[5] = CStringGetTextDatum(usrfctx->connStrPtr); + usrfctx->connStrPtr = p; + usrfctx->nodeId += 1; + + SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(heap_form_tuple(usrfctx->desc, usrfctx->values, usrfctx->nulls))); +} + +Datum +mtm_get_cluster_state(PG_FUNCTION_ARGS) +{ + TupleDesc desc; + Datum values[7]; + bool nulls[7] = {false}; + + get_call_result_type(fcinfo, NULL, &desc); + + values[0] = CStringGetTextDatum(MtmNodeStatusMnem[dtm->status]); + values[1] = Int64GetDatum(dtm->disabledNodeMask); + values[2] = Int64GetDatum(dtm->connectivityMask); + values[3] = Int64GetDatum(dtm->nodeLockerMask); + values[4] = Int32GetDatum(dtm->nNodes); + values[5] = Int32GetDatum((int)dtm->pool.active); + values[6] = Int64GetDatum(BgwPoolGetQueueSize(&dtm->pool)); + + PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); +} + /* * Execute statement with specified parameters and check its result */ From ad9bb1b933bebdfa280568b73c3f79ccb6777920 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 6 Mar 2016 16:19:32 +0300 Subject: [PATCH 0282/1139] Fix definitions of SQL functions --- bgwpool.c | 9 ++++++++- multimaster--1.0.sql | 4 ++-- multimaster.c | 10 ++++++---- pglogical_receiver.c | 4 ++-- 4 files changed, 18 insertions(+), 9 deletions(-) diff --git a/bgwpool.c b/bgwpool.c index 74f6662751..2b6d659339 100644 --- a/bgwpool.c +++ b/bgwpool.c @@ -109,7 +109,14 @@ size_t BgwPoolGetQueueSize(BgwPool* pool) void BgwPoolExecute(BgwPool* pool, void* work, size_t size) { - Assert(size+4 <= pool->size); + if (size+4 > pool->size) { + /* + * Size of work is larger than size of shared buffer: + * run it immediately + */ + pool->executor(0, work, size); + return; + } SpinLockAcquire(&pool->lock); while (true) { diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 39c2398a26..62ab40700f 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -24,13 +24,13 @@ AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; -CREATE TYPE mtm.node_state(id integer, disabled bool, disconnected bool, catchUp boolean, slotLag bigint, connStr text); +CREATE TYPE mtm.node_state AS (id integer, disabled bool, disconnected bool, catchUp bool, slotLag bigint, connStr text); CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state AS 'MODULE_PATHNAME','mtm_get_nodes_state' LANGUAGE C; -CREATE TYPE mtm.cluster_state(status text, disabledNodeMask bigint, disconnectedNodeMask bigint, catchUpNodeMask bigint, nNodes integer, nActiveQueries integer, queueSize bigint); +CREATE TYPE mtm.cluster_state AS (status text, disabledNodeMask bigint, disconnectedNodeMask bigint, catchUpNodeMask bigint, nNodes integer, nActiveQueries integer, queueSize bigint); CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state AS 'MODULE_PATHNAME','mtm_get_cluster_state' diff --git a/multimaster.c b/multimaster.c index eeccd04d2b..59baad8fc4 100644 --- a/multimaster.c +++ b/multimaster.c @@ -523,7 +523,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) if (x->isDistributed && dtm->status != MTM_ONLINE) { /* reject all user's transactions at offline cluster */ MtmUnlock(); - elog(ERROR, "Multimaster node is not online"); + elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[dtm->status]); } x->containsDML = false; x->isPrepared = false; @@ -1159,7 +1159,7 @@ void MtmReceiverStarted(int nodeId) BIT_SET(dtm->pglogicalNodeMask, nodeId-1); if (++dtm->nReceivers == dtm->nNodes-1) { Assert(dtm->status == MTM_CONNECTED); - MtmSwitchClusterMode(MTM_OFFLINE); + MtmSwitchClusterMode(MTM_ONLINE); } } SpinLockRelease(&dtm->spinlock); @@ -1293,6 +1293,7 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) MtmGetNodeStateCtx* usrfctx; MemoryContext oldcontext; char* p; + int64 lag; bool is_first_call = SRF_IS_FIRSTCALL(); if (is_first_call) { @@ -1315,7 +1316,9 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->values[1] = BoolGetDatum(BIT_CHECK(dtm->disabledNodeMask, usrfctx->nodeId-1)); usrfctx->values[2] = BoolGetDatum(BIT_CHECK(dtm->connectivityMask, usrfctx->nodeId-1)); usrfctx->values[3] = BoolGetDatum(BIT_CHECK(dtm->nodeLockerMask, usrfctx->nodeId-1)); - usrfctx->values[4] = Int64GetDatum(MtmGetSlotLag(usrfctx->nodeId)); + lag = MtmGetSlotLag(usrfctx->nodeId); + usrfctx->values[4] = Int64GetDatum(lag); + usrfctx->nulls[4] = lag < 0; p = strchr(usrfctx->connStrPtr, ','); if (p != NULL) { *p++ = '\0'; @@ -1333,7 +1336,6 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) TupleDesc desc; Datum values[7]; bool nulls[7] = {false}; - get_call_result_type(fcinfo, NULL, &desc); values[0] = CStringGetTextDatum(MtmNodeStatusMnem[dtm->status]); diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 0a2ba28765..d264cacaab 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -331,8 +331,8 @@ pglogical_receiver_main(Datum main_arg) if (rc & WL_POSTMASTER_DEATH) proc_exit(1); - if (ds->status != MTM_ONLINE && (ds->status != MTM_RECOVERY || ds->recoverySlot != args->remote_node)) { - ereport(LOG, (errmsg("%s: terminating WAL receiver because node is switched to %s mode", worker_proc, MtmNodeStatusMnem[ds->status]))); + if (ds->status == MTM_OFFLINE || (ds->status == MTM_RECOVERY && ds->recoverySlot != args->remote_node)) { + ereport(LOG, (errmsg("%s: terminating WAL receiver because node was switched to %s mode", worker_proc, MtmNodeStatusMnem[ds->status]))); proc_exit(0); } From a8f07d2da12208f076706f5b673288d0bbfb8555 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 6 Mar 2016 23:29:21 +0300 Subject: [PATCH 0283/1139] Add more columns to node/cluster state function --- arbiter.c | 3 ++- multimaster--1.0.sql | 4 ++-- multimaster.c | 22 +++++++++++++++------- multimaster.h | 2 ++ 4 files changed, 21 insertions(+), 10 deletions(-) diff --git a/arbiter.c b/arbiter.c index 8c973f692e..14ee53bf5f 100644 --- a/arbiter.c +++ b/arbiter.c @@ -641,7 +641,8 @@ static void MtmTransReceiver(Datum arg) switch (msg->code) { case MSG_READY: Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < ds->nNodes); + Assert(ts->nVotes < ds->nNodes); + ds->nodeTransDelay[msg->node-1] += MtmGetCurrentTime() - ts->csn; if (++ts->nVotes == ds->nNodes) { /* All nodes are finished their transactions */ if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 62ab40700f..e3f4b9c349 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -24,13 +24,13 @@ AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; -CREATE TYPE mtm.node_state AS (id integer, disabled bool, disconnected bool, catchUp bool, slotLag bigint, connStr text); +CREATE TYPE mtm.node_state AS (id integer, disabled bool, disconnected bool, catchUp bool, slotLag bigint, avgTransDelay bigint, connStr text); CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state AS 'MODULE_PATHNAME','mtm_get_nodes_state' LANGUAGE C; -CREATE TYPE mtm.cluster_state AS (status text, disabledNodeMask bigint, disconnectedNodeMask bigint, catchUpNodeMask bigint, nNodes integer, nActiveQueries integer, queueSize bigint); +CREATE TYPE mtm.cluster_state AS (status text, disabledNodeMask bigint, disconnectedNodeMask bigint, catchUpNodeMask bigint, nNodes integer, nActiveQueries integer, queueSize bigint, transCount bigint, timeShift bigint, recoverySlot integer); CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state AS 'MODULE_PATHNAME','mtm_get_cluster_state' diff --git a/multimaster.c b/multimaster.c index 59baad8fc4..ce4123664e 100644 --- a/multimaster.c +++ b/multimaster.c @@ -464,13 +464,15 @@ static void MtmInitialize() dtm->transListTail = &dtm->transListHead; dtm->nReceivers = 0; dtm->timeShift = 0; + dtm->transCount = 0; + memset(dtm->nodeTransDelay, 0, sizeof(dtm->nodeTransDelay)); PGSemaphoreCreate(&dtm->votingSemaphore); PGSemaphoreReset(&dtm->votingSemaphore); SpinLockInit(&dtm->spinlock); BgwPoolInit(&dtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); RegisterXactCallback(MtmXactCallback, NULL); dtmTx.snapshot = INVALID_CSN; - dtmTx.xid = InvalidTransactionId; + dtmTx.xid = InvalidTransactionId; } xid2state = MtmCreateHash(); MtmDoReplication = true; @@ -628,7 +630,8 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) ts->procno = MyProc->pgprocno; ts->nVotes = 0; ts->done = false; - + dtm->transCount += 1; + if (TransactionIdIsValid(x->gtid.xid)) { ts->gtid = x->gtid; } else { @@ -1282,8 +1285,8 @@ typedef struct int nodeId; char* connStrPtr; TupleDesc desc; - Datum values[6]; - bool nulls[6]; + Datum values[7]; + bool nulls[7]; } MtmGetNodeStateCtx; Datum @@ -1319,11 +1322,12 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) lag = MtmGetSlotLag(usrfctx->nodeId); usrfctx->values[4] = Int64GetDatum(lag); usrfctx->nulls[4] = lag < 0; + usrfctx->values[5] = Int64GetDatum(dtm->transCount ? dtm->nodeTransDelay[usrfctx->nodeId-1]/dtm->transCount : 0); p = strchr(usrfctx->connStrPtr, ','); if (p != NULL) { *p++ = '\0'; } - usrfctx->values[5] = CStringGetTextDatum(usrfctx->connStrPtr); + usrfctx->values[6] = CStringGetTextDatum(usrfctx->connStrPtr); usrfctx->connStrPtr = p; usrfctx->nodeId += 1; @@ -1334,8 +1338,8 @@ Datum mtm_get_cluster_state(PG_FUNCTION_ARGS) { TupleDesc desc; - Datum values[7]; - bool nulls[7] = {false}; + Datum values[10]; + bool nulls[10] = {false}; get_call_result_type(fcinfo, NULL, &desc); values[0] = CStringGetTextDatum(MtmNodeStatusMnem[dtm->status]); @@ -1345,6 +1349,10 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) values[4] = Int32GetDatum(dtm->nNodes); values[5] = Int32GetDatum((int)dtm->pool.active); values[6] = Int64GetDatum(BgwPoolGetQueueSize(&dtm->pool)); + values[7] = Int64GetDatum(dtm->transCount); + values[8] = Int64GetDatum(dtm->timeShift); + values[9] = Int32GetDatum(dtm->recoverySlot); + nulls[9] = dtm->recoverySlot == 0; PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); } diff --git a/multimaster.h b/multimaster.h index ee1adf3fd4..48fbc9d577 100644 --- a/multimaster.h +++ b/multimaster.h @@ -113,6 +113,8 @@ typedef struct It is cleanup by MtmGetOldestXmin */ MtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. This list is expected to be in CSN ascending order, by strict order may be violated */ + uint64 transCount; /* Counter of transactions perfromed by this node */ + time_t nodeTransDelay[MAX_NODES]; /* Time of waiting transaction acknowledgment from node */ BgwPool pool; /* Pool of background workers for applying logical replication patches */ } MtmState; From 5c26b9d13e48bf1b68018b65a8cf61073949d890 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Tue, 8 Mar 2016 22:30:34 +0300 Subject: [PATCH 0284/1139] Minor refactoring --- arbiter.c | 2 +- multimaster.c | 4 ++-- multimaster.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/arbiter.c b/arbiter.c index 14ee53bf5f..9be689d5d9 100644 --- a/arbiter.c +++ b/arbiter.c @@ -529,7 +529,7 @@ static void MtmTransSender(Datum arg) static void MtmWakeUpBackend(MtmTransState* ts) { - ts->done = true; + ts->voteCompleted = true; SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } diff --git a/multimaster.c b/multimaster.c index ce4123664e..6ff80fb082 100644 --- a/multimaster.c +++ b/multimaster.c @@ -629,7 +629,7 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) ts->cmd = MSG_INVALID; ts->procno = MyProc->pgprocno; ts->nVotes = 0; - ts->done = false; + ts->voteCompleted = false; dtm->transCount += 1; if (TransactionIdIsValid(x->gtid.xid)) { @@ -1638,7 +1638,7 @@ MtmVoteForTransaction(MtmTransState* ts) } } MTM_TRACE("%d: Node %d waiting latch...\n", MyProcPid, MtmNodeId); - while (!ts->done) { + while (!ts->voteCompleted) { MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); diff --git a/multimaster.h b/multimaster.h index 48fbc9d577..385617ab2b 100644 --- a/multimaster.h +++ b/multimaster.h @@ -85,7 +85,7 @@ typedef struct MtmTransState int nSubxids; /* Number of subtransanctions */ struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ - bool done; + bool voteCompleted; /* Responses necessary to make a decision are received by coordinator of transaction */ TransactionId xids[1]; /* transaction ID at replicas: varying size MtmNodes */ } MtmTransState; From 11d8a7ddd5ba0a2e82d7df47932ea9c430b09d33 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 9 Mar 2016 20:13:13 +0300 Subject: [PATCH 0285/1139] Fix bug in deadlock detection --- multimaster.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 6ff80fb082..0bac49f3aa 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1724,7 +1724,7 @@ MtmSerializeLock(PROCLOCK* proclock, void* arg) if ((proclock->holdMask & LOCKBIT_ON(lm)) && (conflictMask & LOCKBIT_ON(lm))) { MTM_TRACE("%d: %u(%u) waits for %u(%u)\n", MyProcPid, srcPgXact->xid, proc->pid, dstPgXact->xid, proclock->tag.myProc->pid); - MtmGetGtid(srcPgXact->xid, >id); /* transaction holding lock */ + MtmGetGtid(dstPgXact->xid, >id); /* transaction holding lock */ ByteBufferAppendInt32(buf, gtid.node); ByteBufferAppendInt32(buf, gtid.xid); break; From e12b5b4d0af5450088de22ed05c9912efa81c0b6 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Fri, 11 Mar 2016 17:37:40 +0300 Subject: [PATCH 0286/1139] mmts:twophase_decoding --- arbiter.c | 6 ++--- multimaster.h | 7 ++++++ pglogical_apply.c | 56 ++++++++++++++++++++++++++++++++++++++++++++-- pglogical_proto.c | 34 +++++++++++++++++++++++++--- tests/reinit-mm.sh | 2 +- 5 files changed, 96 insertions(+), 9 deletions(-) diff --git a/arbiter.c b/arbiter.c index 9be689d5d9..594c0e6117 100644 --- a/arbiter.c +++ b/arbiter.c @@ -554,7 +554,7 @@ static bool MtmRecovery() } } } - return recorvered; + return recovered; } #endif @@ -601,8 +601,8 @@ static void MtmTransReceiver(Datum arg) do { struct timeval tv; events = inset; - tv.tv_sec = MtmKeepAliveTimeout/USEC; - tv.tv_usec = MtmKeepAliveTimeout%USEC; + tv.tv_sec = MtmKeepaliveTimeout/USEC; + tv.tv_usec = MtmKeepaliveTimeout%USEC; n = select(max_fd+1, &events, NULL, NULL, &tv); } while (n < 0 && MtmRecovery()); diff --git a/multimaster.h b/multimaster.h index 385617ab2b..933362f56b 100644 --- a/multimaster.h +++ b/multimaster.h @@ -29,6 +29,13 @@ typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) +#define PGLOGICAL_COMMIT 0x00 +#define PGLOGICAL_PREPARE 0x01 +#define PGLOGICAL_COMMIT_PREPARED 0x02 +#define PGLOGICAL_ABORT_PREPARED 0x03 + +#define PGLOGICAL_XACT_EVENT(flags) (flags & 0x03) + typedef uint64 timestamp_t; /* Identifier of global transaction */ diff --git a/pglogical_apply.c b/pglogical_apply.c index 15f22604f7..fbffd65928 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -464,9 +464,61 @@ read_rel(StringInfo s, LOCKMODE mode) } static void -process_remote_commit(StringInfo s) +process_remote_commit(StringInfo in) { - CommitTransactionCommand(); + XLogRecPtr commit_lsn; + XLogRecPtr end_lsn; + TimestampTz commit_time; + uint8 flags; + const char *gid; + + /* read flags */ + flags = pq_getmsgbyte(in); + + /* read fields */ + commit_lsn = pq_getmsgint64(in); + end_lsn = pq_getmsgint64(in); + commit_time = pq_getmsgint64(in); + + if (PGLOGICAL_XACT_EVENT(flags) != PGLOGICAL_COMMIT) + gid = pq_getmsgstring(in); + + switch(PGLOGICAL_XACT_EVENT(flags)) + { + case PGLOGICAL_COMMIT: + { + if (IsTransactionState()) + CommitTransactionCommand(); + break; + } + case PGLOGICAL_PREPARE: + { + /* prepare TBLOCK_INPROGRESS state for PrepareTransactionBlock() */ + BeginTransactionBlock(); + CommitTransactionCommand(); + StartTransactionCommand(); + /* PREPARE itself */ + PrepareTransactionBlock(gid); + CommitTransactionCommand(); + break; + } + case PGLOGICAL_COMMIT_PREPARED: + { + StartTransactionCommand(); + FinishPreparedTransaction(gid, true); + CommitTransactionCommand(); + break; + } + case PGLOGICAL_ABORT_PREPARED: + { + StartTransactionCommand(); + FinishPreparedTransaction(gid, false); + CommitTransactionCommand(); + break; + } + default: + Assert(false); + } } static void diff --git a/pglogical_proto.c b/pglogical_proto.c index 824ffbd4c0..905d876ef0 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -127,9 +127,37 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, ReorderBufferTXN *txn, XLogRecPtr commit_lsn) { PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; - if (!mm->isLocal) { - pq_sendbyte(out, 'C'); /* sending COMMIT */ - } + uint8 flags = 0; + + if (mm->isLocal) + return; + + pq_sendbyte(out, 'C'); /* sending COMMIT */ + + if (txn->xact_action == XLOG_XACT_COMMIT) + flags = PGLOGICAL_COMMIT; + else if (txn->xact_action == XLOG_XACT_PREPARE) + flags = PGLOGICAL_PREPARE; + else if (txn->xact_action == XLOG_XACT_COMMIT_PREPARED) + flags = PGLOGICAL_COMMIT_PREPARED; + else if (txn->xact_action == XLOG_XACT_ABORT_PREPARED) + flags = PGLOGICAL_ABORT_PREPARED; + else + Assert(false); + + /* send the flags field */ + pq_sendbyte(out, flags); + + /* send fixed fields */ + pq_sendint64(out, commit_lsn); + pq_sendint64(out, txn->end_lsn); + pq_sendint64(out, txn->commit_time); + + if (txn->xact_action == XLOG_XACT_PREPARE || + txn->xact_action == XLOG_XACT_COMMIT_PREPARED || + txn->xact_action == XLOG_XACT_ABORT_PREPARED) + pq_sendstring(out, txn->gid); + } /* diff --git a/tests/reinit-mm.sh b/tests/reinit-mm.sh index be892d2baa..bf22645339 100755 --- a/tests/reinit-mm.sh +++ b/tests/reinit-mm.sh @@ -1,5 +1,5 @@ n_nodes=3 -export PATH=~/postgres_cluster/dist/bin/:$PATH +export PATH=~/code/postgres_cluster/install/bin/:$PATH ulimit -c unlimited pkill -9 postgres pkill -9 arbiter From c8ac9e48a1009bc68acf04c57a1beea91d48677b Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 11 Mar 2016 18:40:28 +0300 Subject: [PATCH 0287/1139] Disable DDD --- arbiter.c | 3 ++- multimaster.c | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/arbiter.c b/arbiter.c index 594c0e6117..8ab23194c5 100644 --- a/arbiter.c +++ b/arbiter.c @@ -529,7 +529,8 @@ static void MtmTransSender(Datum arg) static void MtmWakeUpBackend(MtmTransState* ts) { - ts->voteCompleted = true; + ts->voteCompleted = true; + MTM_TRACE("Wakeup backed procno=%d, pid=%d\n", ts->procno, ProcGlobal->allProcs[ts->procno].pid); SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } diff --git a/multimaster.c b/multimaster.c index 0bac49f3aa..3cc0699d73 100644 --- a/multimaster.c +++ b/multimaster.c @@ -511,7 +511,7 @@ MtmXactCallback(XactEvent event, void *arg) static bool MtmIsUserTransaction() { - return IsNormalProcessingMode() && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); + return !IsAutoVacuumLauncherProcess() && IsNormalProcessingMode() && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); } static void @@ -525,6 +525,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) if (x->isDistributed && dtm->status != MTM_ONLINE) { /* reject all user's transactions at offline cluster */ MtmUnlock(); + Assert(dtm->status == MTM_ONLINE); elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[dtm->status]); } x->containsDML = false; @@ -1765,7 +1766,7 @@ MtmDetectGlobalDeadLock(PGPROC* proc) int size; void* data = PaxosGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); if (data == NULL) { - hasDeadlock = true; /* Just temporary hack until no Paxos */ + return true; /* Just temporary hack until no Paxos */ } else { MtmGraphAdd(&graph, (GlobalTransactionId*)data, size/sizeof(GlobalTransactionId)); } From 5da15b19e5c65607ec55e61a61c9db35f25a7d49 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Fri, 11 Mar 2016 18:51:44 +0300 Subject: [PATCH 0288/1139] fix warnings --- multimaster.c | 6 +++--- pglogical_apply.c | 9 +++------ 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/multimaster.c b/multimaster.c index 3cc0699d73..52d9c21c7c 100644 --- a/multimaster.c +++ b/multimaster.c @@ -579,7 +579,7 @@ MtmCheckClusterLock() } else { /* All lockers are synchronized their logs */ /* Remove lock and mark them as receovered */ - elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", dtm->nLockers, dtm->nodeLockerMask); + elog(WARNING, "Complete recovery of %d nodes (node mask %llx)", dtm->nLockers, dtm->nodeLockerMask); Assert(dtm->walSenderLockerMask == 0); Assert((dtm->nodeLockerMask & dtm->disabledNodeMask) == dtm->nodeLockerMask); dtm->disabledNodeMask &= ~dtm->nodeLockerMask; @@ -1814,7 +1814,7 @@ void MtmRefreshClusterStatus(bool nowait) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ - elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, dtm->disabledNodeMask); + elog(WARNING, "Find clique %llx, disabledNodeMask %llx", clique, dtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { @@ -1841,7 +1841,7 @@ void MtmRefreshClusterStatus(bool nowait) MtmSwitchClusterMode(MTM_RECOVERY); } } else { - elog(WARNING, "Clique %lx has no quorum", clique); + elog(WARNING, "Clique %llx has no quorum", clique); } } diff --git a/pglogical_apply.c b/pglogical_apply.c index fbffd65928..d3d2092552 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -466,9 +466,6 @@ read_rel(StringInfo s, LOCKMODE mode) static void process_remote_commit(StringInfo in) { - XLogRecPtr commit_lsn; - XLogRecPtr end_lsn; - TimestampTz commit_time; uint8 flags; const char *gid; @@ -476,9 +473,9 @@ process_remote_commit(StringInfo in) flags = pq_getmsgbyte(in); /* read fields */ - commit_lsn = pq_getmsgint64(in); - end_lsn = pq_getmsgint64(in); - commit_time = pq_getmsgint64(in); + pq_getmsgint64(in); /* commit_lsn */ + pq_getmsgint64(in); /* end_lsn */ + pq_getmsgint64(in); /* commit_time */ if (PGLOGICAL_XACT_EVENT(flags) != PGLOGICAL_COMMIT) gid = pq_getmsgstring(in); From 522f1835a00b0c1cfb03fd518bbbd31a56837a16 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 11 Mar 2016 20:17:13 +0300 Subject: [PATCH 0289/1139] switch on 2PC --- multimaster.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 52d9c21c7c..9ddd24577d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -881,7 +881,7 @@ _PG_init(void) "Use two phase commit", "Replace normal commit with two phase commit", &MtmUse2PC, - false, + true, PGC_BACKEND, 0, NULL, From f7ac918162b15bccc6f461e70ed4deef36750668 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 13 Mar 2016 22:44:38 +0300 Subject: [PATCH 0290/1139] Some 2pc fixes --- multimaster.c | 16 ++++++++++++++-- pglogical_apply.c | 4 +++- pglogical_proto.c | 2 ++ 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index 9ddd24577d..895563810f 100644 --- a/multimaster.c +++ b/multimaster.c @@ -103,6 +103,7 @@ static void MtmBeginTransaction(MtmCurrentTrans* x); static void MtmPrecommitTransaction(MtmCurrentTrans* x); static bool MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids); static void MtmPrepareTransaction(MtmCurrentTrans* x); +static void MtmCommitPreparedTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); @@ -494,6 +495,9 @@ MtmXactCallback(XactEvent event, void *arg) case XACT_EVENT_PREPARE: MtmPrepareTransaction(&dtmTx); break; + case XACT_EVENT_COMMIT_PREPARED: + MtmCommitPreparedTransaction(&dtmTx); + break; case XACT_EVENT_COMMIT: MtmEndTransaction(&dtmTx, true); break; @@ -652,10 +656,15 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) static void MtmPrepareTransaction(MtmCurrentTrans* x) { - TransactionId *subxids; - int nSubxids; MtmPrecommitTransaction(x); x->isPrepared = true; +} + +static void +MtmCommitPreparedTransaction(MtmCurrentTrans* x) +{ + TransactionId *subxids; + int nSubxids; nSubxids = xactGetCommittedChildren(&subxids); if (!MtmCommitTransaction(x->xid, nSubxids, subxids)) { @@ -1536,12 +1545,15 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, char* gid = MtmGenerateGid(); if (!PrepareTransactionBlock(gid)) { + elog(WARNING, "Failed to prepare transaction %s", gid); /* report unsuccessful commit in completionTag */ if (completionTag) { strcpy(completionTag, "ROLLBACK"); } /* ??? Should we do explicit rollback */ } else { + CommitTransactionCommand(); + StartTransactionCommand(); FinishPreparedTransaction(gid, true); } return; diff --git a/pglogical_apply.c b/pglogical_apply.c index d3d2092552..b81a2fb820 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -467,7 +467,7 @@ static void process_remote_commit(StringInfo in) { uint8 flags; - const char *gid; + const char *gid = NULL; /* read flags */ flags = pq_getmsgbyte(in); @@ -480,6 +480,8 @@ process_remote_commit(StringInfo in) if (PGLOGICAL_XACT_EVENT(flags) != PGLOGICAL_COMMIT) gid = pq_getmsgstring(in); + MTM_TRACE("PGLOGICAL_RECV commit: flags=%d, gid=%s\n", flags, gid); + switch(PGLOGICAL_XACT_EVENT(flags)) { case PGLOGICAL_COMMIT: diff --git a/pglogical_proto.c b/pglogical_proto.c index 905d876ef0..6a4a36afdc 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -145,6 +145,8 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, else Assert(false); + MTM_TRACE("PGLOGICAL_SEND commit: event=%d, gid=%s\n", flags, txn->gid); + /* send the flags field */ pq_sendbyte(out, flags); From e7c5d11ddb3d2c5e98ee67089e669a4ae4886627 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 14 Mar 2016 20:29:45 +0300 Subject: [PATCH 0291/1139] Debug 2PC --- multimaster.c | 26 +++++++++++++++++++------- pglogical_apply.c | 2 ++ 2 files changed, 21 insertions(+), 7 deletions(-) diff --git a/multimaster.c b/multimaster.c index 895563810f..747f312af2 100644 --- a/multimaster.c +++ b/multimaster.c @@ -538,7 +538,8 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->gtid.xid = InvalidTransactionId; MtmUnlock(); - MTM_TRACE("MtmLocalTransaction: %s transaction %u uses local snapshot %lu\n", x->isDistributed ? "distributed" : "local", x->xid, x->snapshot); + MTM_TRACE("%d: MtmLocalTransaction: %s transaction %u uses local snapshot %lu\n", + MyProcPid, x->isDistributed ? "distributed" : "local", x->xid, x->snapshot); } } @@ -583,7 +584,7 @@ MtmCheckClusterLock() } else { /* All lockers are synchronized their logs */ /* Remove lock and mark them as receovered */ - elog(WARNING, "Complete recovery of %d nodes (node mask %llx)", dtm->nLockers, dtm->nodeLockerMask); + elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", dtm->nLockers, dtm->nodeLockerMask); Assert(dtm->walSenderLockerMask == 0); Assert((dtm->nodeLockerMask & dtm->disabledNodeMask) == dtm->nodeLockerMask); dtm->disabledNodeMask &= ~dtm->nodeLockerMask; @@ -606,7 +607,7 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) MtmTransState* ts; int i; - if (!x->isDistributed) { + if (!x->isDistributed || x->isPrepared) { return; } @@ -657,6 +658,7 @@ static void MtmPrepareTransaction(MtmCurrentTrans* x) { MtmPrecommitTransaction(x); + MTM_TRACE("Prepare transaction %d", x->xid); x->isPrepared = true; } @@ -666,6 +668,7 @@ MtmCommitPreparedTransaction(MtmCurrentTrans* x) TransactionId *subxids; int nSubxids; nSubxids = xactGetCommittedChildren(&subxids); + MTM_TRACE("%d: Commit prepared transaction %d\n", MyProcPid, x->xid); if (!MtmCommitTransaction(x->xid, nSubxids, subxids)) { elog(ERROR, "Commit of transaction %d is rejected by DTM", x->xid); @@ -718,8 +721,12 @@ static int64 MtmGetSlotLag(int nodeId) static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { - if (x->isDistributed && commit) { + MTM_TRACE("%d: End transaction %d, prepared=%d, distributed=%d -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isDistributed, commit ? "commit" : "abort"); + if (x->isDistributed && commit) { MtmTransState* ts; + if (x->isPrepared) { + return; + } MtmLock(LW_EXCLUSIVE); ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); @@ -1541,8 +1548,13 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, switch (stmt->kind) { case TRANS_STMT_COMMIT: - if (MtmUse2PC) { + if (MtmUse2PC && dtmTx.isDistributed && dtmTx.containsDML) { char* gid = MtmGenerateGid(); + if (!IsTransactionBlock()) { + elog(WARNING, "Start transaction block for %d", dtmTx.xid); + CommitTransactionCommand(); + StartTransactionCommand(); + } if (!PrepareTransactionBlock(gid)) { elog(WARNING, "Failed to prepare transaction %s", gid); @@ -1826,7 +1838,7 @@ void MtmRefreshClusterStatus(bool nowait) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ - elog(WARNING, "Find clique %llx, disabledNodeMask %llx", clique, dtm->disabledNodeMask); + elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, dtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { @@ -1853,7 +1865,7 @@ void MtmRefreshClusterStatus(bool nowait) MtmSwitchClusterMode(MTM_RECOVERY); } } else { - elog(WARNING, "Clique %llx has no quorum", clique); + elog(WARNING, "Clique %lx has no quorum", clique); } } diff --git a/pglogical_apply.c b/pglogical_apply.c index b81a2fb820..9523b2d728 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -880,6 +880,8 @@ void MtmExecutor(int id, void* work, size_t size) } PG_CATCH(); { + MTM_TRACE("%d: REMOTE abort transaction %d\n", MyProcPid, GetCurrentTransactionId()); + PG_RE_THROW(); FlushErrorState(); MTM_TRACE("%d: REMOTE abort transaction %d\n", MyProcPid, GetCurrentTransactionId()); AbortCurrentTransaction(); From 4bf43fa36f864462f77d0836586f3f94d4cdf15c Mon Sep 17 00:00:00 2001 From: knizhnik Date: Mon, 14 Mar 2016 23:51:29 +0300 Subject: [PATCH 0292/1139] Start rewriting multimaster to 2PC --- arbiter.c | 126 ++++++-------------------------------------------- multimaster.c | 64 ++++++++++++------------- multimaster.h | 9 +--- 3 files changed, 49 insertions(+), 150 deletions(-) diff --git a/arbiter.c b/arbiter.c index 8ab23194c5..33c436cd68 100644 --- a/arbiter.c +++ b/arbiter.c @@ -458,7 +458,7 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt MTM_TRACE("Send message %s CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); Assert(ts->cmd != MSG_INVALID); - buf->data[buf->used].code = ts->cmd; + buf->data[buf->used].code = ts->status == TRANSACTION_STATUS_ABORTED ? MSG_ABORTED : MSG_PREPARED; buf->data[buf->used].dxid = xid; buf->data[buf->used].sxid = ts->xid; buf->data[buf->used].csn = ts->csn; @@ -467,21 +467,6 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt buf->used += 1; } -static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) -{ - int i; - int n = 1; - for (i = 0; i < MtmNodes; i++) - { - if (TransactionIdIsValid(ts->xids[i])) { - Assert(i+1 != MtmNodeId); - MtmAppendBuffer(txBuffer, ts->xids[i], i, ts); - n += 1; - } - } - Assert(n == ds->nNodes); -} - static void MtmTransSender(Datum arg) { int nNodes = MtmNodes; @@ -508,12 +493,7 @@ static void MtmTransSender(Datum arg) MtmLock(LW_SHARED); for (ts = ds->votingTransactions; ts != NULL; ts = ts->nextVoting) { - if (MtmIsCoordinator(ts)) { - MtmBroadcastMessage(txBuffer, ts); - } else { - MtmAppendBuffer(txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); - } - ts->cmd = MSG_INVALID; + MtmAppendBuffer(txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); } ds->votingTransactions = NULL; MtmUnlock(); @@ -634,101 +614,23 @@ static void MtmTransReceiver(Datum arg) MtmArbiterMessage* msg = &rxBuffer[i].data[j]; MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); - Assert(ts->cmd == MSG_INVALID); Assert(msg->node > 0 && msg->node <= nNodes && msg->node != MtmNodeId); - ts->xids[msg->node-1] = msg->sxid; - - if (MtmIsCoordinator(ts)) { - switch (msg->code) { - case MSG_READY: - Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < ds->nNodes); - ds->nodeTransDelay[msg->node-1] += MtmGetCurrentTime() - ts->csn; - if (++ts->nVotes == ds->nNodes) { - /* All nodes are finished their transactions */ - if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { - ts->nVotes = 1; /* I voted myself */ - ts->cmd = MSG_PREPARE; - } else { - ts->status = TRANSACTION_STATUS_ABORTED; - ts->cmd = MSG_ABORT; - MtmAdjustSubtransactions(ts); - MtmWakeUpBackend(ts); - } - MtmSendNotificationMessage(ts); - } - break; + Assert (MtmIsCoordinator(ts)); + switch (msg->code) { case MSG_PREPARED: - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < ds->nNodes); - if (msg->csn > ts->csn) { - ts->csn = msg->csn; - MtmSyncClock(ts->csn); - } - if (++ts->nVotes == ds->nNodes) { - /* ts->csn is maximum of CSNs at all nodes */ - ts->nVotes = 1; /* I voted myself */ - ts->cmd = MSG_COMMIT; - ts->csn = MtmAssignCSN(); - ts->status = TRANSACTION_STATUS_UNKNOWN; - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - } - break; - case MSG_COMMITTED: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->nVotes < ds->nNodes); - if (++ts->nVotes == ds->nNodes) { - /* All nodes have the same CSN */ - MtmWakeUpBackend(ts); + if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { + if (msg->csn > ts->csn) { + ts->csn = msg->csn; + MtmSyncClock(ts->csn); + } + if (++ts->nVotes == ds->nNodes) { + MtmWakeUpBackend(ts); + } } break; case MSG_ABORTED: - Assert(ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < ds->nNodes); - ts->status = TRANSACTION_STATUS_ABORTED; - if (++ts->nVotes == ds->nNodes) { - ts->cmd = MSG_ABORT; - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - MtmWakeUpBackend(ts); - } - break; - default: - Assert(false); - } - } else { /* replica */ - switch (msg->code) { - case MSG_PREPARE: - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - if ((msg->disabledNodeMask & ~ds->disabledNodeMask) != 0) { - /* Coordinator's disabled mask is wider than my: so reject such transaction to avoid - commit on smaller subset of nodes */ + if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { ts->status = TRANSACTION_STATUS_ABORTED; - ts->cmd = MSG_ABORT; - MtmAdjustSubtransactions(ts); - MtmWakeUpBackend(ts); - } else { - ts->status = TRANSACTION_STATUS_UNKNOWN; - ts->csn = MtmAssignCSN(); - ts->cmd = MSG_PREPARED; - } - MtmSendNotificationMessage(ts); - break; - case MSG_COMMIT: - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - Assert(ts->csn < msg->csn); - ts->csn = msg->csn; - MtmSyncClock(ts->csn); - ts->cmd = MSG_COMMITTED; - MtmAdjustSubtransactions(ts); - MtmSendNotificationMessage(ts); - MtmWakeUpBackend(ts); - break; - case MSG_ABORT: - if (ts->status != TRANSACTION_STATUS_ABORTED) { - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN || ts->status == TRANSACTION_STATUS_IN_PROGRESS); - ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); MtmWakeUpBackend(ts); } @@ -736,7 +638,7 @@ static void MtmTransReceiver(Datum arg) default: Assert(false); } - } + } } MtmUnlock(); diff --git a/multimaster.c b/multimaster.c index 747f312af2..383fe50455 100644 --- a/multimaster.c +++ b/multimaster.c @@ -64,7 +64,6 @@ typedef struct { bool isReplicated; /* transaction on replica */ bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ bool containsDML; /* transaction contains DML statements */ - bool isPrepared; /* transaction is prepared as part of 2PC */ csn_t snapshot; /* transaction snaphsot */ } MtmCurrentTrans; @@ -100,8 +99,8 @@ static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, Transaction static void MtmInitialize(void); static void MtmXactCallback(XactEvent event, void *arg); static void MtmBeginTransaction(MtmCurrentTrans* x); -static void MtmPrecommitTransaction(MtmCurrentTrans* x); static bool MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids); +static void MtmPrePrepareTransaction(MtmCurrentTrans* x); static void MtmPrepareTransaction(MtmCurrentTrans* x); static void MtmCommitPreparedTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); @@ -347,15 +346,6 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) return PgXidInMVCCSnapshot(xid, snapshot); } -static uint32 MtmXidHashFunc(const void *key, Size keysize) -{ - return (uint32)*(TransactionId*)key; -} - -static int MtmXidMatchFunc(const void *key1, const void *key2, Size keysize) -{ - return *(TransactionId*)key1 - *(TransactionId*)key2; -} static void MtmTransactionListAppend(MtmTransState* ts) { @@ -489,8 +479,8 @@ MtmXactCallback(XactEvent event, void *arg) case XACT_EVENT_START: MtmBeginTransaction(&dtmTx); break; - case XACT_EVENT_PRE_COMMIT: - MtmPrecommitTransaction(&dtmTx); + case XACT_EVENT_PRE_PREPARE: + MtmPrePrepareTransaction(&dtmTx); break; case XACT_EVENT_PREPARE: MtmPrepareTransaction(&dtmTx); @@ -598,16 +588,14 @@ MtmCheckClusterLock() } /* - * This functions is called as pre-commit callback. - * We need to pass snapshot to WAL-sender, so create record in transaction status hash table - * before commit + * Prepare transaction for two-phase commit */ -static void MtmPrecommitTransaction(MtmCurrentTrans* x) +MtmPrePrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; int i; - if (!x->isDistributed || x->isPrepared) { + if (!x->isDistributed) { return; } @@ -632,7 +620,6 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) ts->snapshot = x->isReplicated || !x->containsDML ? INVALID_CSN : x->snapshot; ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; - ts->cmd = MSG_INVALID; ts->procno = MyProc->pgprocno; ts->nVotes = 0; ts->voteCompleted = false; @@ -644,9 +631,6 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) ts->gtid.xid = x->xid; ts->gtid.node = MtmNodeId; } - for (i = 0; i < MtmNodes; i++) { - ts->xids[i] = InvalidTransactionId; - } MtmTransactionListAppend(ts); MtmUnlock(); @@ -654,14 +638,34 @@ static void MtmPrecommitTransaction(MtmCurrentTrans* x) MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", MyProcPid, x->xid, ts->csn); } -static void MtmPrepareTransaction(MtmCurrentTrans* x) -{ - MtmPrecommitTransaction(x); - MTM_TRACE("Prepare transaction %d", x->xid); - x->isPrepared = true; +{ + MtmLock(LW_EXCLUSIVE); + if (ts->status = TRANSACTION_STATUS_IN_PROGRESS) { + ts->status = TRANSACTION_STATUS_UNKNOWN; + MtmAdjustSubtransactions(ts); + } + + if (!MtmIsCoordinator(ts)) { + MtmSendNotificationMessage(ts); /* send notification to coordinator */ + MtmUnlock(); + } else { + /* wait N commits or just one ABORT */ + ts->nVotes += 1; + while (ts->nVotes != dtm->nNodes && ts->status == TRANSACTION_STATUS_PROGRESS) { + MtmUnlock(); + WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); + ResetLatch(&MyProc->procLatch); + MtmLock(LW_SHARED); + } + MtmUnlock(); + if (ts->status == TRANSACTION_STATUS_ABORTED) { + elog(ERROR, "Distributed transaction %d is rejected by DTM", x->xid); + } + } } + static void MtmCommitPreparedTransaction(MtmCurrentTrans* x) { @@ -1679,14 +1683,12 @@ HTAB* MtmCreateHash(void) Assert(MtmNodes > 0); memset(&info, 0, sizeof(info)); info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(MtmTransState) + (MtmNodes-1)*sizeof(TransactionId); - info.hash = MtmXidHashFunc; - info.match = MtmXidMatchFunc; + info.entrysize = sizeof(MtmTransState); htab = ShmemInitHash( "xid2state", MTM_HASH_SIZE, MTM_HASH_SIZE, &info, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE + HASH_ELEM ); return htab; } diff --git a/multimaster.h b/multimaster.h index 933362f56b..c11f903d78 100644 --- a/multimaster.h +++ b/multimaster.h @@ -19,6 +19,7 @@ #define MULTIMASTER_SLOT_PATTERN "mtm_slot_%d" #define MULTIMASTER_MIN_PROTO_VERSION 1 #define MULTIMASTER_MAX_PROTO_VERSION 1 +#define MULTIMASTER_MAX_GID 32 #define USEC 1000000 @@ -51,12 +52,7 @@ typedef enum { MSG_INVALID, MSG_HANDSHAKE, - MSG_READY, - MSG_PREPARE, - MSG_COMMIT, - MSG_ABORT, MSG_PREPARED, - MSG_COMMITTED, MSG_ABORTED, MSG_STATUS } MtmMessageCode; @@ -88,11 +84,10 @@ typedef struct MtmTransState finally should be nNodes-1 */ int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, used to notify coordinator by arbiter */ - MtmMessageCode cmd; /* Notification message code to be sent */ + bool voteCompleted; /* Responses necessary to make a decision are received by coordinator of transaction */ int nSubxids; /* Number of subtransanctions */ struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ - bool voteCompleted; /* Responses necessary to make a decision are received by coordinator of transaction */ TransactionId xids[1]; /* transaction ID at replicas: varying size MtmNodes */ } MtmTransState; From 75b1bbc4aae54921ed39479aacc750c2937a990c Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 15 Mar 2016 13:14:48 +0300 Subject: [PATCH 0293/1139] Rewrite 2pc support --- multimaster.c | 935 +++++++++++++++++++++++----------------------- multimaster.h | 5 +- pglogical_apply.c | 9 + pglogical_proto.c | 29 +- 4 files changed, 504 insertions(+), 474 deletions(-) diff --git a/multimaster.c b/multimaster.c index 383fe50455..fcfd22103d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -63,10 +63,18 @@ typedef struct { GlobalTransactionId gtid; /* global transaction ID assigned by coordinator of transaction */ bool isReplicated; /* transaction on replica */ bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ + bool isPrepared; /* transaction is perpared at first stage of 2PC */ bool containsDML; /* transaction contains DML statements */ csn_t snapshot; /* transaction snaphsot */ + csn_t csn; /* CSN */ + char gid[MULTIMASTER_MAX_GID_SIZE]; /* global transaction identifier (used by 2pc) */ } MtmCurrentTrans; +typedef struct { + char gid[MULTIMASTER_MAX_GID_SIZE]; + MtmTransState* state; +} MtmTransMap; + /* #define USE_SPINLOCK 1 */ typedef enum @@ -77,6 +85,7 @@ typedef enum #define MTM_SHMEM_SIZE (64*1024*1024) #define MTM_HASH_SIZE 100003 +#define MTM_MAP_SIZE 1003 #define MIN_WAIT_TIMEOUT 1000 #define MAX_WAIT_TIMEOUT 100000 #define STATUS_POLL_DELAY USEC @@ -95,14 +104,11 @@ PG_FUNCTION_INFO_V1(mtm_get_nodes_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_state); static Snapshot MtmGetSnapshot(Snapshot snapshot); -static void MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn); static void MtmInitialize(void); static void MtmXactCallback(XactEvent event, void *arg); static void MtmBeginTransaction(MtmCurrentTrans* x); -static bool MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids); static void MtmPrePrepareTransaction(MtmCurrentTrans* x); static void MtmPrepareTransaction(MtmCurrentTrans* x); -static void MtmCommitPreparedTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); @@ -110,6 +116,7 @@ static TransactionId MtmAdjustOldestXid(TransactionId xid); static bool MtmDetectGlobalDeadLock(PGPROC* proc); static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int nSubxids); static char const* MtmGetName(void); +static void MtmCheckClusterLock() static void MtmShmemStartup(void); @@ -119,12 +126,13 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); static void MtmVoteForTransaction(MtmTransState* ts); static HTAB* xid2state; +static HTAB* git2xid; static MtmCurrentTrans dtmTx; static MtmState* dtm; static TransactionManager MtmTM = { PgTransactionIdGetStatus, - MtmSetTransactionStatus, + PgTransactionIdSetTreeStatus, MtmGetSnapshot, PgGetNewTransactionId, MtmGetOldestXmin, @@ -161,7 +169,6 @@ static int MtmWorkers; static int MtmVacuumDelay; static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; -static bool MtmUse2PC; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -174,7 +181,10 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, DestReceiver *dest, char *completionTag); /* + * ------------------------------------------- + * Synchronize access to DTM structures. * Using LWLock seems to be more efficient (at our benchmarks) + * ------------------------------------------- */ void MtmLock(LWLockMode mode) { @@ -196,9 +206,12 @@ void MtmUnlock(void) /* - * System time manipulation functions + * ------------------------------------------- + * System time manipulation functions + * ------------------------------------------- */ + timestamp_t MtmGetCurrentTime(void) { struct timeval tv; @@ -253,6 +266,28 @@ static char const* MtmGetName(void) return MULTIMASTER_NAME; } +/* + * ------------------------------------------- + * Visibility&snapshots + * ------------------------------------------- + */ + +csn_t MtmTransactionSnapshot(TransactionId xid) +{ + MtmTransState* ts; + csn_t snapshot = INVALID_CSN; + + MtmLock(LW_SHARED); + ts = hash_search(xid2state, &xid, HASH_FIND, NULL); + if (ts != NULL) { + snapshot = ts->snapshot; + } + MtmUnlock(); + + return snapshot; +} + + Snapshot MtmGetSnapshot(Snapshot snapshot) { snapshot = PgGetSnapshotData(snapshot); @@ -347,6 +382,50 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) } + +/* + * There can be different oldest XIDs at different cluster node. + * Seince we do not have centralized aribiter, we have to rely in MtmVacuumDelay. + * This function takes XID which PostgreSQL consider to be the latest and try to find XID which + * is older than it more than MtmVacuumDelay. + * If no such XID can be located, then return previously observed oldest XID + */ +static TransactionId +MtmAdjustOldestXid(TransactionId xid) +{ + if (TransactionIdIsValid(xid)) { + MtmTransState *ts, *prev = NULL; + + MtmLock(LW_EXCLUSIVE); + ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + if (ts != NULL) { + timestamp_t cutoff_time = ts->csn - MtmVacuumDelay*USEC; + for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { + Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); + if (prev != NULL) { + /* Remove information about too old transactions */ + hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); + } + } + } + if (prev != NULL) { + dtm->transListHead = prev; + dtm->oldestXid = xid = prev->xid; + } else { + xid = dtm->oldestXid; + } + MtmUnlock(); + } + return xid; +} + +/* + * ------------------------------------------- + * Transaction list manipulation + * ------------------------------------------- + */ + + static void MtmTransactionListAppend(MtmTransState* ts) { ts->next = NULL; @@ -393,83 +472,12 @@ void MtmAdjustSubtransactions(MtmTransState* ts) } } - /* - * There can be different oldest XIDs at different cluster node. - * Seince we do not have centralized aribiter, we have to rely in MtmVacuumDelay. - * This function takes XID which PostgreSQL consider to be the latest and try to find XID which - * is older than it more than MtmVacuumDelay. - * If no such XID can be located, then return previously observed oldest XID + * ------------------------------------------- + * Transaction control + * ------------------------------------------- */ -static TransactionId -MtmAdjustOldestXid(TransactionId xid) -{ - if (TransactionIdIsValid(xid)) { - MtmTransState *ts, *prev = NULL; - - MtmLock(LW_EXCLUSIVE); - ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); - if (ts != NULL) { - timestamp_t cutoff_time = ts->csn - MtmVacuumDelay*USEC; - for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { - Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); - if (prev != NULL) { - /* Remove information about too old transactions */ - hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); - } - } - } - if (prev != NULL) { - dtm->transListHead = prev; - dtm->oldestXid = xid = prev->xid; - } else { - xid = dtm->oldestXid; - } - MtmUnlock(); - } - return xid; -} - -static void MtmInitialize() -{ - bool found; - LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); - dtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState), &found); - if (!found) - { - dtm->status = MTM_INITIALIZATION; - dtm->recoverySlot = 0; - dtm->locks = GetNamedLWLockTranche(MULTIMASTER_NAME); - dtm->csn = MtmGetCurrentTime(); - dtm->oldestXid = FirstNormalTransactionId; - dtm->nNodes = MtmNodes; - dtm->disabledNodeMask = 0; - dtm->connectivityMask = 0; - dtm->pglogicalNodeMask = 0; - dtm->walSenderLockerMask = 0; - dtm->nodeLockerMask = 0; - dtm->nLockers = 0; - dtm->votingTransactions = NULL; - dtm->transListHead = NULL; - dtm->transListTail = &dtm->transListHead; - dtm->nReceivers = 0; - dtm->timeShift = 0; - dtm->transCount = 0; - memset(dtm->nodeTransDelay, 0, sizeof(dtm->nodeTransDelay)); - PGSemaphoreCreate(&dtm->votingSemaphore); - PGSemaphoreReset(&dtm->votingSemaphore); - SpinLockInit(&dtm->spinlock); - BgwPoolInit(&dtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); - RegisterXactCallback(MtmXactCallback, NULL); - dtmTx.snapshot = INVALID_CSN; - dtmTx.xid = InvalidTransactionId; - } - xid2state = MtmCreateHash(); - MtmDoReplication = true; - TM = &MtmTM; - LWLockRelease(AddinShmemInitLock); -} static void MtmXactCallback(XactEvent event, void *arg) @@ -485,9 +493,6 @@ MtmXactCallback(XactEvent event, void *arg) case XACT_EVENT_PREPARE: MtmPrepareTransaction(&dtmTx); break; - case XACT_EVENT_COMMIT_PREPARED: - MtmCommitPreparedTransaction(&dtmTx); - break; case XACT_EVENT_COMMIT: MtmEndTransaction(&dtmTx, true); break; @@ -516,6 +521,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; x->isDistributed = MtmIsUserTransaction(); + x->isPrepared = false; if (x->isDistributed && dtm->status != MTM_ONLINE) { /* reject all user's transactions at offline cluster */ MtmUnlock(); @@ -526,6 +532,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->isPrepared = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; + x->gid[0] = '\0'; MtmUnlock(); MTM_TRACE("%d: MtmLocalTransaction: %s transaction %u uses local snapshot %lu\n", @@ -533,60 +540,6 @@ MtmBeginTransaction(MtmCurrentTrans* x) } } - -/* - * If there are recovering nodes which are catching-up WAL, check the status and prevent new transaction from commit to give - * WAL-sender a chance to catch-up WAL, completely synchronize replica and switch it to normal mode. - * This function is called at transaction start with multimaster lock set - */ -static void -MtmCheckClusterLock() -{ - while (true) - { - nodemask_t mask = dtm->walSenderLockerMask; - if (mask != 0) { - XLogRecPtr currLogPos = GetXLogInsertRecPtr(); - int i; - timestamp_t delay = MIN_WAIT_TIMEOUT; - for (i = 0; mask != 0; i++, mask >>= 1) { - if (mask & 1) { - if (WalSndCtl->walsnds[i].sentPtr != currLogPos) { - /* recovery is in progress */ - break; - } else { - /* recovered replica catched up with master */ - elog(WARNING, "WAL-sender %d complete receovery", i); - BIT_CLEAR(dtm->walSenderLockerMask, i); - } - } - } - if (mask != 0) { - /* some "almost catch-up" wal-senders are still working */ - /* Do not start new transactions until them complete */ - MtmUnlock(); - MtmSleep(delay); - if (delay*2 <= MAX_WAIT_TIMEOUT) { - delay *= 2; - } - MtmLock(LW_EXCLUSIVE); - continue; - } else { - /* All lockers are synchronized their logs */ - /* Remove lock and mark them as receovered */ - elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", dtm->nLockers, dtm->nodeLockerMask); - Assert(dtm->walSenderLockerMask == 0); - Assert((dtm->nodeLockerMask & dtm->disabledNodeMask) == dtm->nodeLockerMask); - dtm->disabledNodeMask &= ~dtm->nodeLockerMask; - dtm->nNodes += dtm->nLockers; - dtm->nLockers = 0; - dtm->nodeLockerMask = 0; - } - } - break; - } -} - /* * Prepare transaction for two-phase commit */ @@ -623,6 +576,10 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) ts->procno = MyProc->pgprocno; ts->nVotes = 0; ts->voteCompleted = false; + + x->isPrepared = true; + x->csn = csn; + dtm->transCount += 1; if (TransactionIdIsValid(x->gtid.xid)) { @@ -640,13 +597,20 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) MtmPrepareTransaction(MtmCurrentTrans* x) { + MtmTransState* ts; + MtmLock(LW_EXCLUSIVE); + ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); + Assert(ts != NULL); if (ts->status = TRANSACTION_STATUS_IN_PROGRESS) { ts->status = TRANSACTION_STATUS_UNKNOWN; MtmAdjustSubtransactions(ts); } - + if (!MtmIsCoordinator(ts)) { + MtmHashMap* hm = (MtmHashMap*)hash_search(gid2xid, x->gid, HASH_ENTER, NULL); + Assert(x->gid[0]); + hm->state = ts; MtmSendNotificationMessage(ts); /* send notification to coordinator */ MtmUnlock(); } else { @@ -667,18 +631,103 @@ MtmPrepareTransaction(MtmCurrentTrans* x) static void -MtmCommitPreparedTransaction(MtmCurrentTrans* x) +MtmEndTransaction(MtmCurrentTrans* x, bool commit) +{ + MTM_TRACE("%d: End transaction %d, prepared=%d, distributed=%d -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isDistributed, commit ? "commit" : "abort"); + if (x->isDistributed) { + MtmTransState* ts; + MtmLock(LW_EXCLUSIVE); + if (x->isPrepared) { + ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); + Assert(ts != NULL); + } else { + MtmHashMap* hm = (MtmHashMap*)hash_search(gid2xid, x->gid, HASH_REMOVE, NULL); + Assert(hm != NULL); + ts = hm->state; + } + if (commit) { + ts->status = TRANSACTION_STATUS_COMMITTED; + if (x->csn > ts->csn) { + ts->csn = x->csn; + MtmSyncClock(ts->csn); + } + } else { + ts->status = TRANSACTION_STATUS_ABORTED; + if (x->isReplicated) { + MtmSendNotificationMessage(ts); /* send notification to coordinator */ + } + } + MtmAdjustSubtransactions(ts); + MtmUnlock(); + } + x->snapshot = INVALID_CSN; + x->xid = InvalidTransactionId; + x->gtid.xid = InvalidTransactionId; + MtmCheckSlots(); +} + +void MtmSendNotificationMessage(MtmTransState* ts) { - TransactionId *subxids; - int nSubxids; - nSubxids = xactGetCommittedChildren(&subxids); - MTM_TRACE("%d: Commit prepared transaction %d\n", MyProcPid, x->xid); - if (!MtmCommitTransaction(x->xid, nSubxids, subxids)) + MtmTransState* votingList; + + votingList = dtm->votingTransactions; + ts->nextVoting = votingList; + dtm->votingTransactions = ts; + + if (votingList == NULL) { + /* singal semaphore only once for the whole list */ + PGSemaphoreUnlock(&dtm->votingSemaphore); + } +} + + + +void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) +{ + csn_t localSnapshot; + + MtmLock(LW_EXCLUSIVE); + localSnapshot = MtmSyncClock(globalSnapshot); + MtmUnlock(); + + if (globalSnapshot < localSnapshot - MtmVacuumDelay * USEC) { - elog(ERROR, "Commit of transaction %d is rejected by DTM", x->xid); + elog(ERROR, "Too old snapshot: requested %ld, current %ld", globalSnapshot, localSnapshot); + } + + if (!TransactionIdIsValid(gtid->xid)) { + /* In case of recovery InvalidTransactionId is passed */ + Assert(dtm->status == MTM_RECOVERY); + } else if (dtm->status == MTM_RECOVERY) { + /* When recovery is completed we get normal transaction ID and switch to normal mode */ + dtm->recoverySlot = 0; + MtmSwitchClusterMode(MTM_ONLINE); } + dtmTx.gtid = *gtid; + dtmTx.xid = GetCurrentTransactionId(); + dtmTx.snapshot = globalSnapshot; + dtmTx.isReplicated = true; + dtmTx.isDistributed = true; + dtmTx.containsDML = true; +} + +void MtmSetCurrentTransactionGID(char const* gid) +{ + strcpy(dtmTx.gid, gid); +} + +void MtmSetCurrentTransactionCSN(csn_t csn) +{ + dtmTx.csn = csn; } +/* + * ------------------------------------------- + * HA functions + * ------------------------------------------- + */ + + /** * Check state of replication slots. If some of them are too much lag behind wal, then drop this slots to avoid * WAL overflow @@ -722,41 +771,6 @@ static int64 MtmGetSlotLag(int nodeId) return -1; } -static void -MtmEndTransaction(MtmCurrentTrans* x, bool commit) -{ - MTM_TRACE("%d: End transaction %d, prepared=%d, distributed=%d -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isDistributed, commit ? "commit" : "abort"); - if (x->isDistributed && commit) { - MtmTransState* ts; - if (x->isPrepared) { - return; - } - MtmLock(LW_EXCLUSIVE); - ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); - Assert(ts != NULL); - ts->status = TRANSACTION_STATUS_COMMITTED; - MtmAdjustSubtransactions(ts); - MtmUnlock(); - } - x->snapshot = INVALID_CSN; - x->xid = InvalidTransactionId; - x->gtid.xid = InvalidTransactionId; - MtmCheckSlots(); -} - -void MtmSendNotificationMessage(MtmTransState* ts) -{ - MtmTransState* votingList; - - votingList = dtm->votingTransactions; - ts->nextVoting = votingList; - dtm->votingTransactions = ts; - - if (votingList == NULL) { - /* singal semaphore only once for the whole list */ - PGSemaphoreUnlock(&dtm->votingSemaphore); - } -} /* * This function is called by WAL sender when start sending new transaction. @@ -787,86 +801,255 @@ bool MtmIsRecoveredNode(int nodeId) return false; } -static bool -MtmCommitTransaction(TransactionId xid, int nsubxids, TransactionId *subxids) +void MtmSwitchClusterMode(MtmNodeStatus mode) { - MtmTransState* ts; + dtm->status = mode; + elog(WARNING, "Switch to %s mode", MtmNodeStatusMnem[mode]); + /* ??? Something else to do here? */ +} - MtmLock(LW_EXCLUSIVE); - ts = hash_search(xid2state, &xid, HASH_FIND, NULL); - Assert(ts != NULL); /* should be created by MtmPrepareTransaction */ - - MTM_TRACE("%d: MtmCommitTransaction begin commit of %d CSN=%ld\n", MyProcPid, xid, ts->csn); - MtmAddSubtransactions(ts, subxids, nsubxids); - MtmVoteForTransaction(ts); +/* + * If there are recovering nodes which are catching-up WAL, check the status and prevent new transaction from commit to give + * WAL-sender a chance to catch-up WAL, completely synchronize replica and switch it to normal mode. + * This function is called at transaction start with multimaster lock set + */ +static void +MtmCheckClusterLock() +{ + while (true) + { + nodemask_t mask = dtm->walSenderLockerMask; + if (mask != 0) { + XLogRecPtr currLogPos = GetXLogInsertRecPtr(); + int i; + timestamp_t delay = MIN_WAIT_TIMEOUT; + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + if (WalSndCtl->walsnds[i].sentPtr != currLogPos) { + /* recovery is in progress */ + break; + } else { + /* recovered replica catched up with master */ + elog(WARNING, "WAL-sender %d complete receovery", i); + BIT_CLEAR(dtm->walSenderLockerMask, i); + } + } + } + if (mask != 0) { + /* some "almost catch-up" wal-senders are still working */ + /* Do not start new transactions until them complete */ + MtmUnlock(); + MtmSleep(delay); + if (delay*2 <= MAX_WAIT_TIMEOUT) { + delay *= 2; + } + MtmLock(LW_EXCLUSIVE); + continue; + } else { + /* All lockers are synchronized their logs */ + /* Remove lock and mark them as receovered */ + elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", dtm->nLockers, dtm->nodeLockerMask); + Assert(dtm->walSenderLockerMask == 0); + Assert((dtm->nodeLockerMask & dtm->disabledNodeMask) == dtm->nodeLockerMask); + dtm->disabledNodeMask &= ~dtm->nodeLockerMask; + dtm->nNodes += dtm->nLockers; + dtm->nLockers = 0; + dtm->nodeLockerMask = 0; + } + } + break; + } +} - MtmUnlock(); +/** + * Build internode connectivity mask. 1 - means that node is disconnected. + */ +static void +MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) +{ + int i, j, n = MtmNodes; + for (i = 0; i < n; i++) { + if (i+1 != MtmNodeId) { + void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); + matrix[i] = *(nodemask_t*)data; + } else { + matrix[i] = dtm->connectivityMask; + } + } + /* make matrix symetric: required for Bron–Kerbosch algorithm */ + for (i = 0; i < n; i++) { + for (j = 0; j < i; j++) { + matrix[i] |= ((matrix[j] >> i) & 1) << j; + } + } +} + + +/** + * Build connectivity graph, find clique in it and extend disabledNodeMask by nodes not included in clique. + * This function returns false if current node is excluded from cluster, true otherwise + */ +void MtmRefreshClusterStatus(bool nowait) +{ + nodemask_t mask, clique; + nodemask_t matrix[MAX_NODES]; + int clique_size; + int i; + + MtmBuildConnectivityMatrix(matrix, nowait); + + clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); + if (clique_size >= MtmNodes/2+1) { /* have quorum */ + elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, dtm->disabledNodeMask); + MtmLock(LW_EXCLUSIVE); + mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; /* new disabled nodes mask */ + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + dtm->nNodes -= 1; + BIT_SET(dtm->disabledNodeMask, i); + } + } + mask = clique & dtm->disabledNodeMask; /* new enabled nodes mask */ + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + dtm->nNodes += 1; + BIT_CLEAR(dtm->disabledNodeMask, i); + } + } + MtmUnlock(); + if (BIT_CHECK(dtm->disabledNodeMask, MtmNodeId-1)) { + if (dtm->status == MTM_ONLINE) { + /* I was excluded from cluster:( */ + MtmSwitchClusterMode(MTM_OFFLINE); + } + } else if (dtm->status == MTM_OFFLINE) { + /* Should we somehow restart logical receivers? */ + MtmSwitchClusterMode(MTM_RECOVERY); + } + } else { + elog(WARNING, "Clique %lx has no quorum", clique); + } +} + +void MtmOnNodeDisconnect(int nodeId) +{ + BIT_SET(dtm->connectivityMask, nodeId-1); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); + + /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ + MtmSleep(MtmKeepaliveTimeout); + + MtmRefreshClusterStatus(false); +} + +void MtmOnNodeConnect(int nodeId) +{ + BIT_CLEAR(dtm->connectivityMask, nodeId-1); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); +} + +/* + * Paxos function stubs (until them are miplemented) + */ +void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts, bool nowait) +{ + if (size != NULL) { + *size = 0; + } + return NULL; +} + +void PaxosSet(char const* key, void const* value, int size, bool nowait) +{} + + +/* + * ------------------------------------------- + * Node initialization + * ------------------------------------------- + */ + +static void MtmInitialize() +{ + bool found; + + LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); + dtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState), &found); + if (!found) + { + dtm->status = MTM_INITIALIZATION; + dtm->recoverySlot = 0; + dtm->locks = GetNamedLWLockTranche(MULTIMASTER_NAME); + dtm->csn = MtmGetCurrentTime(); + dtm->oldestXid = FirstNormalTransactionId; + dtm->nNodes = MtmNodes; + dtm->disabledNodeMask = 0; + dtm->connectivityMask = 0; + dtm->pglogicalNodeMask = 0; + dtm->walSenderLockerMask = 0; + dtm->nodeLockerMask = 0; + dtm->nLockers = 0; + dtm->votingTransactions = NULL; + dtm->transListHead = NULL; + dtm->transListTail = &dtm->transListHead; + dtm->nReceivers = 0; + dtm->timeShift = 0; + dtm->transCount = 0; + memset(dtm->nodeTransDelay, 0, sizeof(dtm->nodeTransDelay)); + PGSemaphoreCreate(&dtm->votingSemaphore); + PGSemaphoreReset(&dtm->votingSemaphore); + SpinLockInit(&dtm->spinlock); + BgwPoolInit(&dtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); + RegisterXactCallback(MtmXactCallback, NULL); + dtmTx.snapshot = INVALID_CSN; + dtmTx.xid = InvalidTransactionId; + } + xid2state = MtmCreateHash(); + gid2xid = MtmCreateMap(); + MtmDoReplication = true; + TM = &MtmTM; + LWLockRelease(AddinShmemInitLock); +} - MTM_TRACE("%d: MtmCommitTransaction %d status=%d\n", MyProcPid, xid, ts->status); - return ts->status != TRANSACTION_STATUS_ABORTED; -} - -static void -MtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status) +HTAB* MtmCreateHash(void) { - MtmCurrentTrans* x = &dtmTx; - - if (x->isReplicated) { - MtmTransState* ts; - XidStatus prevStatus = TRANSACTION_STATUS_UNKNOWN; - bool found; + HASHCTL info; + HTAB* htab; + Assert(MtmNodes > 0); + memset(&info, 0, sizeof(info)); + info.keysize = sizeof(TransactionId); + info.entrysize = sizeof(MtmTransState); + htab = ShmemInitHash( + "xid2state", + MTM_HASH_SIZE, MTM_HASH_SIZE, + &info, + HASH_ELEM | HASH_BLOBS + ); + return htab; +} - MtmLock(LW_EXCLUSIVE); - ts = hash_search(xid2state, &xid, HASH_ENTER, &found); - if (!found) { - ts->snapshot = INVALID_CSN; - ts->csn = MtmAssignCSN(); - ts->gtid = x->gtid; - ts->cmd = MSG_INVALID; - } else { - prevStatus = ts->status; - } - ts->status = status; - MtmAdjustSubtransactions(ts); - - if (dtm->status != MTM_RECOVERY && prevStatus != TRANSACTION_STATUS_ABORTED) { - ts->cmd = MSG_ABORTED; - MtmSendNotificationMessage(ts); - } - MtmUnlock(); - MTM_TRACE("%d: MtmFinishTransaction %d CSN=%ld, status=%d\n", MyProcPid, xid, ts->csn, status); - } -} - - +HTAB* MtmCreateMap(void) +{ + HASHCTL info; + HTAB* htab; + memset(&info, 0, sizeof(info)); + info.keysize = MULTIMASTER_MAX_GID_SIZE; + info.entrysize = sizeof(MtmTransMap); + htab = ShmemInitHash( + "gid2xid", + MTM_MAP_SIZE, MTM_MAP_SIZE, + &info, + HASH_ELEM + ); + return htab; +} -static void -MtmSetTransactionStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn) +MtmState* +MtmGetState(void) { - MTM_TRACE("%d: MtmSetTransactionStatus %u(%u) = %u, isDistributed=%d\n", MyProcPid, xid, dtmTx.xid, status, dtmTx.isDistributed); - if (xid == dtmTx.xid && dtmTx.isDistributed && !dtmTx.isPrepared) - { - if (status == TRANSACTION_STATUS_ABORTED || !dtmTx.containsDML || dtm->status == MTM_RECOVERY) - { - MtmFinishTransaction(xid, nsubxids, subxids, status); - MTM_TRACE("Finish transaction %d, status=%d, DML=%d\n", xid, status, dtmTx.containsDML); - } - else - { - if (MtmCommitTransaction(xid, nsubxids, subxids)) { - MTM_TRACE("Commit transaction %d\n", xid); - } else { - PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, TRANSACTION_STATUS_ABORTED, lsn); - dtmTx.isDistributed = false; - MarkAsAborted(); - END_CRIT_SECTION(); - elog(ERROR, "Commit of transaction %d is rejected by DTM", xid); - } - } - } - PgTransactionIdSetTreeStatus(xid, nsubxids, subxids, status, lsn); + return dtm; } static void @@ -896,18 +1079,6 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; - DefineCustomBoolVariable( - "multimaster.use_2pc", - "Use two phase commit", - "Replace normal commit with two phase commit", - &MtmUse2PC, - true, - PGC_BACKEND, - 0, - NULL, - NULL, - NULL - ); DefineCustomIntVariable( "multimaster.min_recovery_lag", "Minamal lag of WAL-sender performing recovery after which cluster is locked until recovery is completed", @@ -1134,47 +1305,6 @@ _PG_fini(void) } - -/* - * *************************************************************************** - */ - - -void MtmSwitchClusterMode(MtmNodeStatus mode) -{ - dtm->status = mode; - elog(WARNING, "Switch to %s mode", MtmNodeStatusMnem[mode]); - /* ??? Something else to do here? */ -} - -void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) -{ - csn_t localSnapshot; - - MtmLock(LW_EXCLUSIVE); - localSnapshot = MtmSyncClock(globalSnapshot); - MtmUnlock(); - - if (globalSnapshot < localSnapshot - MtmVacuumDelay * USEC) - { - elog(ERROR, "Too old snapshot: requested %ld, current %ld", globalSnapshot, localSnapshot); - } - - if (!TransactionIdIsValid(gtid->xid)) { - /* In case of recovery InvalidTransactionId is passed */ - Assert(dtm->status == MTM_RECOVERY); - } else if (dtm->status == MTM_RECOVERY) { - /* When recovery is completed we get normal transaction ID and switch to normal mode */ - dtm->recoverySlot = 0; - MtmSwitchClusterMode(MTM_ONLINE); - } - dtmTx.gtid = *gtid; - dtmTx.xid = GetCurrentTransactionId(); - dtmTx.snapshot = globalSnapshot; - dtmTx.isReplicated = true; - dtmTx.isDistributed = true; - dtmTx.containsDML = true; -} void MtmReceiverStarted(int nodeId) { @@ -1189,21 +1319,6 @@ void MtmReceiverStarted(int nodeId) SpinLockRelease(&dtm->spinlock); } -csn_t MtmTransactionSnapshot(TransactionId xid) -{ - MtmTransState* ts; - csn_t snapshot = INVALID_CSN; - - MtmLock(LW_SHARED); - ts = hash_search(xid2state, &xid, HASH_FIND, NULL); - if (ts != NULL) { - snapshot = ts->snapshot; - } - MtmUnlock(); - - return snapshot; -} - /* * Determine when and how we should open replication slot. * Druing recovery we need to open only one replication slot from which node should receive all transactions. @@ -1263,6 +1378,13 @@ void MtmDropNode(int nodeId, bool dropSlot) } } +/* + * ------------------------------------------- + * SQL API functions + * ------------------------------------------- + */ + + Datum mtm_start_replication(PG_FUNCTION_ARGS) { @@ -1378,6 +1500,12 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); } +/* + * ------------------------------------------- + * Broadcast utulity statements + * ------------------------------------------- + */ + /* * Execute statement with specified parameters and check its result */ @@ -1528,15 +1656,17 @@ static bool MtmProcessDDLCommand(char const* queryString) return false; } + + /* * Genenerate global transaction identifier for two-pahse commit. * It should be unique for all nodes */ -static char* -MtmGenerateGid() +static void +MtmGenerateGid(char* gid) { static int localCount; - return psprintf("GID-%d-%d-%d", MtmNodeId, MyProcPid, ++localCount); + sprintf(gid, "MTM-%d-%d-%d", MtmNodeId, MyProcPid, ++localCount); } static void MtmProcessUtility(Node *parsetree, const char *queryString, @@ -1552,14 +1682,15 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, switch (stmt->kind) { case TRANS_STMT_COMMIT: - if (MtmUse2PC && dtmTx.isDistributed && dtmTx.containsDML) { - char* gid = MtmGenerateGid(); + if (dtmTx.isDistributed && dtmTx.containsDML) { + char gid{MUTLIMASTER_MAX_GID_SIZE]; + MtmGenerateGid(&gid); if (!IsTransactionBlock()) { elog(WARNING, "Start transaction block for %d", dtmTx.xid); CommitTransactionCommand(); StartTransactionCommand(); } - if (!PrepareTransactionBlock(gid)) + if (!PrepareTransactionBlock(&gid)) { elog(WARNING, "Failed to prepare transaction %s", gid); /* report unsuccessful commit in completionTag */ @@ -1641,6 +1772,12 @@ MtmExecutorFinish(QueryDesc *queryDesc) } } +/* + * ------------------------------------------- + * Executor pool interface + * ------------------------------------------- + */ + void MtmExecute(void* work, int size) { BgwPoolExecute(&dtm->pool, work, size); @@ -1652,52 +1789,11 @@ MtmPoolConstructor(void) return &dtm->pool; } -static void -MtmVoteForTransaction(MtmTransState* ts) -{ - if (!MtmIsCoordinator(ts)) { - ts->cmd = ts->status == TRANSACTION_STATUS_ABORTED ? MSG_ABORTED : MSG_READY; - MtmSendNotificationMessage(ts); /* send READY message to coordinator */ - } else if (++ts->nVotes == dtm->nNodes) { /* everybody already voted except me */ - if (ts->status != TRANSACTION_STATUS_ABORTED) { - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - ts->cmd = MSG_PREPARE; - ts->nVotes = 1; /* I voted myself */ - MtmSendNotificationMessage(ts); - } - } - MTM_TRACE("%d: Node %d waiting latch...\n", MyProcPid, MtmNodeId); - while (!ts->voteCompleted) { - MtmUnlock(); - WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); - ResetLatch(&MyProc->procLatch); - MtmLock(LW_SHARED); - } - MTM_TRACE("%d: Node %d receives response...\n", MyProcPid, MtmNodeId); -} - -HTAB* MtmCreateHash(void) -{ - HASHCTL info; - HTAB* htab; - Assert(MtmNodes > 0); - memset(&info, 0, sizeof(info)); - info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(MtmTransState); - htab = ShmemInitHash( - "xid2state", - MTM_HASH_SIZE, MTM_HASH_SIZE, - &info, - HASH_ELEM - ); - return htab; -} - -MtmState* -MtmGetState(void) -{ - return dtm; -} +/* + * ------------------------------------------- + * Deadlock detection + * ------------------------------------------- + */ static void MtmGetGtid(TransactionId xid, GlobalTransactionId* gtid) @@ -1768,8 +1864,6 @@ MtmSerializeLock(PROCLOCK* proclock, void* arg) } } -/* Stubs */ - static bool MtmDetectGlobalDeadLock(PGPROC* proc) { @@ -1804,100 +1898,3 @@ MtmDetectGlobalDeadLock(PGPROC* proc) } return hasDeadlock; } - -static void -MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) -{ - int i, j, n = MtmNodes; - for (i = 0; i < n; i++) { - if (i+1 != MtmNodeId) { - void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); - matrix[i] = *(nodemask_t*)data; - } else { - matrix[i] = dtm->connectivityMask; - } - } - /* make matrix symetric: required for Bron–Kerbosch algorithm */ - for (i = 0; i < n; i++) { - for (j = 0; j < i; j++) { - matrix[i] |= ((matrix[j] >> i) & 1) << j; - } - } -} - -/** - * Build connectivity graph, find clique in it and extend disabledNodeMask by nodes not included in clique. - * This function returns false if current node is excluded from cluster, true otherwise - */ -void MtmRefreshClusterStatus(bool nowait) -{ - nodemask_t mask, clique; - nodemask_t matrix[MAX_NODES]; - int clique_size; - int i; - - MtmBuildConnectivityMatrix(matrix, nowait); - - clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); - if (clique_size >= MtmNodes/2+1) { /* have quorum */ - elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, dtm->disabledNodeMask); - MtmLock(LW_EXCLUSIVE); - mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; /* new disabled nodes mask */ - for (i = 0; mask != 0; i++, mask >>= 1) { - if (mask & 1) { - dtm->nNodes -= 1; - BIT_SET(dtm->disabledNodeMask, i); - } - } - mask = clique & dtm->disabledNodeMask; /* new enabled nodes mask */ - for (i = 0; mask != 0; i++, mask >>= 1) { - if (mask & 1) { - dtm->nNodes += 1; - BIT_CLEAR(dtm->disabledNodeMask, i); - } - } - MtmUnlock(); - if (BIT_CHECK(dtm->disabledNodeMask, MtmNodeId-1)) { - if (dtm->status == MTM_ONLINE) { - /* I was excluded from cluster:( */ - MtmSwitchClusterMode(MTM_OFFLINE); - } - } else if (dtm->status == MTM_OFFLINE) { - /* Should we somehow restart logical receivers? */ - MtmSwitchClusterMode(MTM_RECOVERY); - } - } else { - elog(WARNING, "Clique %lx has no quorum", clique); - } -} - -void MtmOnNodeDisconnect(int nodeId) -{ - BIT_SET(dtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); - - /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ - MtmSleep(MtmKeepaliveTimeout); - - MtmRefreshClusterStatus(false); -} - -void MtmOnNodeConnect(int nodeId) -{ - BIT_CLEAR(dtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); -} - -/* - * Paxos function stubs (until them are miplemented) - */ -void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts, bool nowait) -{ - if (size != NULL) { - *size = 0; - } - return NULL; -} - -void PaxosSet(char const* key, void const* value, int size, bool nowait) -{} diff --git a/multimaster.h b/multimaster.h index c11f903d78..c9a53431d9 100644 --- a/multimaster.h +++ b/multimaster.h @@ -19,7 +19,7 @@ #define MULTIMASTER_SLOT_PATTERN "mtm_slot_%d" #define MULTIMASTER_MIN_PROTO_VERSION 1 #define MULTIMASTER_MAX_PROTO_VERSION 1 -#define MULTIMASTER_MAX_GID 32 +#define MULTIMASTER_MAX_GID_SIZE 32 #define USEC 1000000 @@ -145,6 +145,7 @@ extern MtmSlotMode MtmReceiverSlotMode(int nodeId); extern void MtmExecute(void* work, int size); extern void MtmExecutor(int id, void* work, size_t size); extern HTAB* MtmCreateHash(void); +extern HTAB* MtmCreateMap(void); extern void MtmSendNotificationMessage(MtmTransState* ts); extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); @@ -156,6 +157,8 @@ extern void MtmOnNodeConnect(int nodeId); extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); +extern void MtmSetCurrentTransactionGID(char const* gid); +extern void MtmSetCurrentTransactionCSN(csn_t csn); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); diff --git a/pglogical_apply.c b/pglogical_apply.c index 9523b2d728..e8b8ea8020 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -468,6 +468,7 @@ process_remote_commit(StringInfo in) { uint8 flags; const char *gid = NULL; + csn_t csn; /* read flags */ flags = pq_getmsgbyte(in); @@ -492,25 +493,33 @@ process_remote_commit(StringInfo in) } case PGLOGICAL_PREPARE: { + gid = pq_getmsgstring(in); /* prepare TBLOCK_INPROGRESS state for PrepareTransactionBlock() */ BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); /* PREPARE itself */ + MtmSetCurrentTransactionGid(gid); PrepareTransactionBlock(gid); CommitTransactionCommand(); break; } case PGLOGICAL_COMMIT_PREPARED: { + csn = pq_getmsgint64(in); + gid = pq_getmsgstring(in); StartTransactionCommand(); + MtmSetCurrentTransactionCSN(csn); + MtmSetCurrentTransactionGID(gid); FinishPreparedTransaction(gid, true); CommitTransactionCommand(); break; } case PGLOGICAL_ABORT_PREPARED: { + gid = pq_getmsgstring(in); StartTransactionCommand(); + MtmSetCurrentTransactionGid(gid); FinishPreparedTransaction(gid, false); CommitTransactionCommand(); break; diff --git a/pglogical_proto.c b/pglogical_proto.c index 6a4a36afdc..3610600109 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -39,8 +39,9 @@ typedef struct PGLogicalProtoMM { PGLogicalProtoAPI api; - int nodeId; - bool isLocal; + int nodeId; + bool isLocal; + HTAB* xid2state; } PGLogicalProtoMM; static void pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel); @@ -119,6 +120,20 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, } } + +static csn_t +MtmGetCSN(TransactionId xid) +{ + MtmTransState* ts; + csn_t csn; + MtmLock(LW_SHARED); + ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + Assert(ts != NULL); + csn = ts->csn; + MtmUnlock(); + return csn; +} + /* * Write COMMIT to the output stream. */ @@ -155,10 +170,15 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, pq_sendint64(out, txn->end_lsn); pq_sendint64(out, txn->commit_time); + if (txn->xact_action == XLOG_XACT_COMMIT_PREPARED) { + pq_sendint64(out, MtmGetCSN(txn->xid)); + } if (txn->xact_action == XLOG_XACT_PREPARE || - txn->xact_action == XLOG_XACT_COMMIT_PREPARED || - txn->xact_action == XLOG_XACT_ABORT_PREPARED) + txn->xact_action == XLOG_XACT_COMMIT_PREPARED || + txn->xact_action == XLOG_XACT_ABORT_PREPARED) + { pq_sendstring(out, txn->gid); + } } @@ -409,6 +429,7 @@ pglogical_init_api(PGLogicalProtoType typ) PGLogicalProtoMM* pmm = palloc0(sizeof(PGLogicalProtoMM)); PGLogicalProtoAPI* res = &pmm->api; pmm->isLocal = false; + pmm->xid2state = MtmCreateHash(); sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &pmm->nodeId); res->write_rel = pglogical_write_rel; res->write_begin = pglogical_write_begin; From 670cb784e1e867dbbe703eebbe4ec935c933e5bb Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 15 Mar 2016 14:00:14 +0300 Subject: [PATCH 0294/1139] Rewrite 2pc support --- multimaster.c | 7 +++---- multimaster.h | 2 -- pglogical_apply.c | 4 ++-- pglogical_proto.c | 6 +++--- 4 files changed, 8 insertions(+), 11 deletions(-) diff --git a/multimaster.c b/multimaster.c index fcfd22103d..6a27d40141 100644 --- a/multimaster.c +++ b/multimaster.c @@ -126,7 +126,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); static void MtmVoteForTransaction(MtmTransState* ts); static HTAB* xid2state; -static HTAB* git2xid; +static HTAB* gid2xid; static MtmCurrentTrans dtmTx; static MtmState* dtm; @@ -529,7 +529,6 @@ MtmBeginTransaction(MtmCurrentTrans* x) elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[dtm->status]); } x->containsDML = false; - x->isPrepared = false; x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; x->gid[0] = '\0'; @@ -541,7 +540,8 @@ MtmBeginTransaction(MtmCurrentTrans* x) } /* - * Prepare transaction for two-phase commit + * Prepare transaction for two-phase commit. + * This code is executed by PRE_PREPARE hook before PREPARE message is sent to replicas by logical replication */ MtmPrePrepareTransaction(MtmCurrentTrans* x) { @@ -575,7 +575,6 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) ts->gtid = x->gtid; ts->procno = MyProc->pgprocno; ts->nVotes = 0; - ts->voteCompleted = false; x->isPrepared = true; x->csn = csn; diff --git a/multimaster.h b/multimaster.h index c9a53431d9..bce90b50b8 100644 --- a/multimaster.h +++ b/multimaster.h @@ -84,11 +84,9 @@ typedef struct MtmTransState finally should be nNodes-1 */ int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, used to notify coordinator by arbiter */ - bool voteCompleted; /* Responses necessary to make a decision are received by coordinator of transaction */ int nSubxids; /* Number of subtransanctions */ struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ - TransactionId xids[1]; /* transaction ID at replicas: varying size MtmNodes */ } MtmTransState; typedef struct diff --git a/pglogical_apply.c b/pglogical_apply.c index e8b8ea8020..8494843e99 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -499,7 +499,7 @@ process_remote_commit(StringInfo in) CommitTransactionCommand(); StartTransactionCommand(); /* PREPARE itself */ - MtmSetCurrentTransactionGid(gid); + MtmSetCurrentTransactionGID(gid); PrepareTransactionBlock(gid); CommitTransactionCommand(); break; @@ -519,7 +519,7 @@ process_remote_commit(StringInfo in) { gid = pq_getmsgstring(in); StartTransactionCommand(); - MtmSetCurrentTransactionGid(gid); + MtmSetCurrentTransactionGID(gid); FinishPreparedTransaction(gid, false); CommitTransactionCommand(); break; diff --git a/pglogical_proto.c b/pglogical_proto.c index 3610600109..3553414190 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -122,12 +122,12 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, static csn_t -MtmGetCSN(TransactionId xid) +MtmGetCSN(PGLogicalProtoMM* mm, TransactionId xid) { MtmTransState* ts; csn_t csn; MtmLock(LW_SHARED); - ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + ts = (MtmTransState*)hash_search(mm->xid2state, &xid, HASH_FIND, NULL); Assert(ts != NULL); csn = ts->csn; MtmUnlock(); @@ -171,7 +171,7 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, pq_sendint64(out, txn->commit_time); if (txn->xact_action == XLOG_XACT_COMMIT_PREPARED) { - pq_sendint64(out, MtmGetCSN(txn->xid)); + pq_sendint64(out, MtmGetCSN(mm, txn->xid)); } if (txn->xact_action == XLOG_XACT_PREPARE || txn->xact_action == XLOG_XACT_COMMIT_PREPARED || From 0d9ed509c97f7a685f9b0d397d70d8568f3b66da Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 15 Mar 2016 15:08:05 +0300 Subject: [PATCH 0295/1139] 2PC stuff --- arbiter.c | 7 ++----- multimaster.c | 41 ++++++++++++++++++++++++++--------------- pglogical_apply.c | 3 --- 3 files changed, 28 insertions(+), 23 deletions(-) diff --git a/arbiter.c b/arbiter.c index 33c436cd68..5904d7a42b 100644 --- a/arbiter.c +++ b/arbiter.c @@ -455,9 +455,8 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt } buf->used = 0; } - MTM_TRACE("Send message %s CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", - messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); - Assert(ts->cmd != MSG_INVALID); + MTM_TRACE("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", + ts->status == TRANSACTION_STATUS_ABORTED ? "abort" : "commit", ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); buf->data[buf->used].code = ts->status == TRANSACTION_STATUS_ABORTED ? MSG_ABORTED : MSG_PREPARED; buf->data[buf->used].dxid = xid; buf->data[buf->used].sxid = ts->xid; @@ -509,7 +508,6 @@ static void MtmTransSender(Datum arg) static void MtmWakeUpBackend(MtmTransState* ts) { - ts->voteCompleted = true; MTM_TRACE("Wakeup backed procno=%d, pid=%d\n", ts->procno, ProcGlobal->allProcs[ts->procno].pid); SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } @@ -637,7 +635,6 @@ static void MtmTransReceiver(Datum arg) break; default: Assert(false); - } } } MtmUnlock(); diff --git a/multimaster.c b/multimaster.c index 6a27d40141..c8e9f0ded3 100644 --- a/multimaster.c +++ b/multimaster.c @@ -116,14 +116,15 @@ static TransactionId MtmAdjustOldestXid(TransactionId xid); static bool MtmDetectGlobalDeadLock(PGPROC* proc); static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int nSubxids); static char const* MtmGetName(void); -static void MtmCheckClusterLock() +static void MtmCheckClusterLock(void); +static void MtmCheckSlots(void); +static void MtmAddSubtransactions(MtmTransState* ts, TransactionId *subxids, int nSubxids); static void MtmShmemStartup(void); static BgwPool* MtmPoolConstructor(void); static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); -static void MtmVoteForTransaction(MtmTransState* ts); static HTAB* xid2state; static HTAB* gid2xid; @@ -543,10 +544,11 @@ MtmBeginTransaction(MtmCurrentTrans* x) * Prepare transaction for two-phase commit. * This code is executed by PRE_PREPARE hook before PREPARE message is sent to replicas by logical replication */ +static void MtmPrePrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; - int i; + TransactionId *subxids; if (!x->isDistributed) { return; @@ -575,9 +577,9 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) ts->gtid = x->gtid; ts->procno = MyProc->pgprocno; ts->nVotes = 0; - + ts->nSubxids = xactGetCommittedChildren(&subxids); x->isPrepared = true; - x->csn = csn; + x->csn = ts->csn; dtm->transCount += 1; @@ -588,12 +590,14 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) ts->gtid.node = MtmNodeId; } MtmTransactionListAppend(ts); + MtmAddSubtransactions(ts, subxids, ts->nSubxids); MtmUnlock(); MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", MyProcPid, x->xid, ts->csn); } +static void MtmPrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; @@ -601,21 +605,21 @@ MtmPrepareTransaction(MtmCurrentTrans* x) MtmLock(LW_EXCLUSIVE); ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); Assert(ts != NULL); - if (ts->status = TRANSACTION_STATUS_IN_PROGRESS) { + if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { ts->status = TRANSACTION_STATUS_UNKNOWN; MtmAdjustSubtransactions(ts); } if (!MtmIsCoordinator(ts)) { - MtmHashMap* hm = (MtmHashMap*)hash_search(gid2xid, x->gid, HASH_ENTER, NULL); + MtmTransMap* hm = (MtmTransMap*)hash_search(gid2xid, x->gid, HASH_ENTER, NULL); Assert(x->gid[0]); hm->state = ts; MtmSendNotificationMessage(ts); /* send notification to coordinator */ MtmUnlock(); } else { /* wait N commits or just one ABORT */ - ts->nVotes += 1; - while (ts->nVotes != dtm->nNodes && ts->status == TRANSACTION_STATUS_PROGRESS) { + ts->nVotes += 1; /* I vote myself */ + while (ts->nVotes != dtm->nNodes && ts->status == TRANSACTION_STATUS_IN_PROGRESS) { MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); @@ -633,14 +637,14 @@ static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { MTM_TRACE("%d: End transaction %d, prepared=%d, distributed=%d -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isDistributed, commit ? "commit" : "abort"); - if (x->isDistributed) { + if (x->isDistributed && (TransactionIdIsValid(x->xid) || x->isReplicated)) { MtmTransState* ts; MtmLock(LW_EXCLUSIVE); if (x->isPrepared) { ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); } else { - MtmHashMap* hm = (MtmHashMap*)hash_search(gid2xid, x->gid, HASH_REMOVE, NULL); + MtmTransMap* hm = (MtmTransMap*)hash_search(gid2xid, x->gid, HASH_REMOVE, NULL); Assert(hm != NULL); ts = hm->state; } @@ -712,12 +716,18 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) void MtmSetCurrentTransactionGID(char const* gid) { + MTM_TRACE("Set current transaction GID %s\n", gid); strcpy(dtmTx.gid, gid); + dtmTx.isDistributed = true; + dtmTx.isReplicated = true; } void MtmSetCurrentTransactionCSN(csn_t csn) { + MTM_TRACE("Set current transaction CSN %ld\n", csn); dtmTx.csn = csn; + dtmTx.isDistributed = true; + dtmTx.isReplicated = true; } /* @@ -731,7 +741,8 @@ void MtmSetCurrentTransactionCSN(csn_t csn) * Check state of replication slots. If some of them are too much lag behind wal, then drop this slots to avoid * WAL overflow */ -static void MtmCheckSlots() +static void +MtmCheckSlots() { if (MtmMaxRecoveryLag != 0 && dtm->disabledNodeMask != 0) { @@ -1682,14 +1693,14 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, { case TRANS_STMT_COMMIT: if (dtmTx.isDistributed && dtmTx.containsDML) { - char gid{MUTLIMASTER_MAX_GID_SIZE]; - MtmGenerateGid(&gid); + char gid[MULTIMASTER_MAX_GID_SIZE]; + MtmGenerateGid(gid); if (!IsTransactionBlock()) { elog(WARNING, "Start transaction block for %d", dtmTx.xid); CommitTransactionCommand(); StartTransactionCommand(); } - if (!PrepareTransactionBlock(&gid)) + if (!PrepareTransactionBlock(gid)) { elog(WARNING, "Failed to prepare transaction %s", gid); /* report unsuccessful commit in completionTag */ diff --git a/pglogical_apply.c b/pglogical_apply.c index 8494843e99..09925b2c19 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -478,9 +478,6 @@ process_remote_commit(StringInfo in) pq_getmsgint64(in); /* end_lsn */ pq_getmsgint64(in); /* commit_time */ - if (PGLOGICAL_XACT_EVENT(flags) != PGLOGICAL_COMMIT) - gid = pq_getmsgstring(in); - MTM_TRACE("PGLOGICAL_RECV commit: flags=%d, gid=%s\n", flags, gid); switch(PGLOGICAL_XACT_EVENT(flags)) From 75e4922a7d6e698b82764f5c4c59c0d2cdeed8b6 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 15 Mar 2016 17:07:00 +0300 Subject: [PATCH 0296/1139] 2PC bug fixes --- arbiter.c | 9 ++++++--- multimaster.c | 21 ++++++++++++++------- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/arbiter.c b/arbiter.c index 5904d7a42b..69da0e9d43 100644 --- a/arbiter.c +++ b/arbiter.c @@ -460,7 +460,7 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt buf->data[buf->used].code = ts->status == TRANSACTION_STATUS_ABORTED ? MSG_ABORTED : MSG_PREPARED; buf->data[buf->used].dxid = xid; buf->data[buf->used].sxid = ts->xid; - buf->data[buf->used].csn = ts->csn; + buf->data[buf->used].csn = ts->csn; buf->data[buf->used].node = MtmNodeId; buf->data[buf->used].disabledNodeMask = ds->disabledNodeMask; buf->used += 1; @@ -495,6 +495,7 @@ static void MtmTransSender(Datum arg) MtmAppendBuffer(txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); } ds->votingTransactions = NULL; + MtmUnlock(); for (i = 0; i < nNodes; i++) { @@ -616,7 +617,8 @@ static void MtmTransReceiver(Datum arg) Assert (MtmIsCoordinator(ts)); switch (msg->code) { case MSG_PREPARED: - if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { + if (ts->status != TRANSACTION_STATUS_ABORTED) { + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS || ts->status == TRANSACTION_STATUS_UNKNOWN); if (msg->csn > ts->csn) { ts->csn = msg->csn; MtmSyncClock(ts->csn); @@ -627,7 +629,8 @@ static void MtmTransReceiver(Datum arg) } break; case MSG_ABORTED: - if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { + if (ts->status != TRANSACTION_STATUS_ABORTED) { + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS || ts->status == TRANSACTION_STATUS_UNKNOWN); ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); MtmWakeUpBackend(ts); diff --git a/multimaster.c b/multimaster.c index c8e9f0ded3..b021959bed 100644 --- a/multimaster.c +++ b/multimaster.c @@ -571,7 +571,10 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) MtmCheckClusterLock(); ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); - ts->status = TRANSACTION_STATUS_IN_PROGRESS; + ts->status = TRANSACTION_STATUS_IN_PROGRESS; + /* + * Invalid CSN prevent replication of transaction by logical replication + */ ts->snapshot = x->isReplicated || !x->containsDML ? INVALID_CSN : x->snapshot; ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; @@ -603,7 +606,7 @@ MtmPrepareTransaction(MtmCurrentTrans* x) MtmTransState* ts; MtmLock(LW_EXCLUSIVE); - ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); + ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { ts->status = TRANSACTION_STATUS_UNKNOWN; @@ -619,7 +622,7 @@ MtmPrepareTransaction(MtmCurrentTrans* x) } else { /* wait N commits or just one ABORT */ ts->nVotes += 1; /* I vote myself */ - while (ts->nVotes != dtm->nNodes && ts->status == TRANSACTION_STATUS_IN_PROGRESS) { + while (ts->nVotes != dtm->nNodes && ts->status != TRANSACTION_STATUS_ABORTED) { MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); @@ -628,6 +631,8 @@ MtmPrepareTransaction(MtmCurrentTrans* x) MtmUnlock(); if (ts->status == TRANSACTION_STATUS_ABORTED) { elog(ERROR, "Distributed transaction %d is rejected by DTM", x->xid); + } else { + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); } } } @@ -637,7 +642,7 @@ static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { MTM_TRACE("%d: End transaction %d, prepared=%d, distributed=%d -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isDistributed, commit ? "commit" : "abort"); - if (x->isDistributed && (TransactionIdIsValid(x->xid) || x->isReplicated)) { + if (x->isDistributed && (x->isPrepared || x->isReplicated)) { MtmTransState* ts; MtmLock(LW_EXCLUSIVE); if (x->isPrepared) { @@ -656,7 +661,11 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) } } else { ts->status = TRANSACTION_STATUS_ABORTED; - if (x->isReplicated) { + if (x->isReplicated && TransactionIdIsValid(x->gtid.xid)) { + /* + * Send notification only of ABORT happens during transaction processing at replicas, + * do not send notification if ABORT is receiver from master + */ MtmSendNotificationMessage(ts); /* send notification to coordinator */ } } @@ -683,8 +692,6 @@ void MtmSendNotificationMessage(MtmTransState* ts) } } - - void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { csn_t localSnapshot; From 17a908af2f77673fdf5d7ecd5084f858df614b98 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 15 Mar 2016 20:08:35 +0300 Subject: [PATCH 0297/1139] 2PC fixes --- multimaster.c | 42 ++++++++++++++++++++++++------------------ pglogical_apply.c | 1 + pglogical_receiver.c | 2 +- 3 files changed, 26 insertions(+), 19 deletions(-) diff --git a/multimaster.c b/multimaster.c index b021959bed..ec3707bb06 100644 --- a/multimaster.c +++ b/multimaster.c @@ -643,33 +643,36 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) { MTM_TRACE("%d: End transaction %d, prepared=%d, distributed=%d -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isDistributed, commit ? "commit" : "abort"); if (x->isDistributed && (x->isPrepared || x->isReplicated)) { - MtmTransState* ts; + MtmTransState* ts = NULL; MtmLock(LW_EXCLUSIVE); if (x->isPrepared) { ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); } else { MtmTransMap* hm = (MtmTransMap*)hash_search(gid2xid, x->gid, HASH_REMOVE, NULL); - Assert(hm != NULL); - ts = hm->state; + if (hm != NULL) { + ts = hm->state; + } } - if (commit) { - ts->status = TRANSACTION_STATUS_COMMITTED; - if (x->csn > ts->csn) { - ts->csn = x->csn; - MtmSyncClock(ts->csn); + if (ts != NULL) { + if (commit) { + ts->status = TRANSACTION_STATUS_COMMITTED; + if (x->csn > ts->csn) { + ts->csn = x->csn; + MtmSyncClock(ts->csn); + } + } else { + ts->status = TRANSACTION_STATUS_ABORTED; + if (x->isReplicated && TransactionIdIsValid(x->gtid.xid)) { + /* + * Send notification only of ABORT happens during transaction processing at replicas, + * do not send notification if ABORT is receiver from master + */ + MtmSendNotificationMessage(ts); /* send notification to coordinator */ + } } - } else { - ts->status = TRANSACTION_STATUS_ABORTED; - if (x->isReplicated && TransactionIdIsValid(x->gtid.xid)) { - /* - * Send notification only of ABORT happens during transaction processing at replicas, - * do not send notification if ABORT is receiver from master - */ - MtmSendNotificationMessage(ts); /* send notification to coordinator */ - } + MtmAdjustSubtransactions(ts); } - MtmAdjustSubtransactions(ts); MtmUnlock(); } x->snapshot = INVALID_CSN; @@ -1691,6 +1694,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, DestReceiver *dest, char *completionTag) { bool skipCommand; + MTM_TRACE("%d: Process utility statement %s\n", MyProcPid, queryString); switch (nodeTag(parsetree)) { case T_TransactionStmt: @@ -1702,8 +1706,10 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, if (dtmTx.isDistributed && dtmTx.containsDML) { char gid[MULTIMASTER_MAX_GID_SIZE]; MtmGenerateGid(gid); + MTM_TRACE("%d: Start 2PC with GID=%s for %s\n", MyProcPid, gid, queryString); if (!IsTransactionBlock()) { elog(WARNING, "Start transaction block for %d", dtmTx.xid); + BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); } diff --git a/pglogical_apply.c b/pglogical_apply.c index 09925b2c19..e4e2666700 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -623,6 +623,7 @@ process_remote_insert(StringInfo s, Relation rel) char* ddl = TextDatumGetCString(new_tuple.values[Anum_mtm_ddl_log_query-1]); int rc; SPI_connect(); + MTM_TRACE("%d: Execute utility statement %s\n", MyProcPid, ddl); rc = SPI_execute(ddl, false, 0); SPI_finish(); if (rc != SPI_OK_UTILITY) { diff --git a/pglogical_receiver.c b/pglogical_receiver.c index d264cacaab..0c083e08e0 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -274,7 +274,7 @@ pglogical_receiver_main(Datum main_arg) if (originId != InvalidRepOriginId) { originStartPos = replorigin_get_progress(originId, false); elog(WARNING, "Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); - } else { + } else { elog(WARNING, "Start logical receiver from node %d", args->remote_node); } CommitTransactionCommand(); From 1200b6af4ebcc8b8b2cf1f7c83877187b023bb81 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 16 Mar 2016 19:50:40 +0300 Subject: [PATCH 0298/1139] More 2PC --- arbiter.c | 4 +- multimaster.c | 230 +++++++++++++++++++++++++++++----------------- multimaster.h | 4 +- pglogical_apply.c | 3 +- pglogical_proto.c | 55 +++++------ 5 files changed, 172 insertions(+), 124 deletions(-) diff --git a/arbiter.c b/arbiter.c index 69da0e9d43..e59f555418 100644 --- a/arbiter.c +++ b/arbiter.c @@ -544,7 +544,6 @@ static void MtmTransReceiver(Datum arg) int nResponses; int i, j, n, rc; MtmBuffer* rxBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); - HTAB* xid2state; #if USE_EPOLL struct epoll_event* events = (struct epoll_event*)palloc(sizeof(struct epoll_event)*nNodes); @@ -557,7 +556,6 @@ static void MtmTransReceiver(Datum arg) ds = MtmGetState(); MtmAcceptIncomingConnections(); - xid2state = MtmCreateHash(); for (i = 0; i < nNodes; i++) { rxBuffer[i].used = 0; @@ -611,7 +609,7 @@ static void MtmTransReceiver(Datum arg) for (j = 0; j < nResponses; j++) { MtmArbiterMessage* msg = &rxBuffer[i].data[j]; - MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); + MtmTransState* ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); Assert(msg->node > 0 && msg->node <= nNodes && msg->node != MtmNodeId); Assert (MtmIsCoordinator(ts)); diff --git a/multimaster.c b/multimaster.c index ec3707bb06..973bc11e52 100644 --- a/multimaster.c +++ b/multimaster.c @@ -126,8 +126,9 @@ static BgwPool* MtmPoolConstructor(void); static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); -static HTAB* xid2state; -static HTAB* gid2xid; +HTAB* MtmXid2State; +static HTAB* MtmGid2Xid; + static MtmCurrentTrans dtmTx; static MtmState* dtm; @@ -279,7 +280,7 @@ csn_t MtmTransactionSnapshot(TransactionId xid) csn_t snapshot = INVALID_CSN; MtmLock(LW_SHARED); - ts = hash_search(xid2state, &xid, HASH_FIND, NULL); + ts = hash_search(MtmXid2State, &xid, HASH_FIND, NULL); if (ts != NULL) { snapshot = ts->snapshot; } @@ -324,7 +325,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) #endif while (true) { - MtmTransState* ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + MtmTransState* ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); if (ts != NULL && ts->status != TRANSACTION_STATUS_IN_PROGRESS) { if (ts->csn > dtmTx.snapshot) { @@ -398,14 +399,14 @@ MtmAdjustOldestXid(TransactionId xid) MtmTransState *ts, *prev = NULL; MtmLock(LW_EXCLUSIVE); - ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); if (ts != NULL) { timestamp_t cutoff_time = ts->csn - MtmVacuumDelay*USEC; for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); if (prev != NULL) { /* Remove information about too old transactions */ - hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); + hash_search(MtmXid2State, &prev->xid, HASH_REMOVE, NULL); } } } @@ -452,7 +453,7 @@ static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int bool found; MtmTransState* sts; Assert(TransactionIdIsValid(subxids[i])); - sts = (MtmTransState*)hash_search(xid2state, &subxids[i], HASH_ENTER, &found); + sts = (MtmTransState*)hash_search(MtmXid2State, &subxids[i], HASH_ENTER, &found); Assert(!found); sts->status = ts->status; sts->csn = ts->csn; @@ -514,6 +515,14 @@ MtmIsUserTransaction() return !IsAutoVacuumLauncherProcess() && IsNormalProcessingMode() && MtmDoReplication && !am_walsender && !IsBackgroundWorker && !IsAutoVacuumWorkerProcess(); } +static void +MtmResetTransaction(MtmCurrentTrans* x) +{ + x->snapshot = INVALID_CSN; + x->xid = InvalidTransactionId; + x->gtid.xid = InvalidTransactionId; +} + static void MtmBeginTransaction(MtmCurrentTrans* x) { @@ -555,7 +564,8 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) } x->xid = GetCurrentTransactionId(); - + Assert(TransactionIdIsValid(x->xid)); + if (dtm->disabledNodeMask != 0) { MtmRefreshClusterStatus(true); if (dtm->status != MTM_ONLINE) { @@ -570,7 +580,7 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) */ MtmCheckClusterLock(); - ts = hash_search(xid2state, &x->xid, HASH_ENTER, NULL); + ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, NULL); ts->status = TRANSACTION_STATUS_IN_PROGRESS; /* * Invalid CSN prevent replication of transaction by logical replication @@ -581,23 +591,25 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) ts->procno = MyProc->pgprocno; ts->nVotes = 0; ts->nSubxids = xactGetCommittedChildren(&subxids); + x->isPrepared = true; x->csn = ts->csn; dtm->transCount += 1; - if (TransactionIdIsValid(x->gtid.xid)) { + if (TransactionIdIsValid(x->gtid.xid)) { + Assert(x->gtid.node != MtmNodeId); ts->gtid = x->gtid; } else { + /* I am coordinator of transaction */ ts->gtid.xid = x->xid; ts->gtid.node = MtmNodeId; } MtmTransactionListAppend(ts); MtmAddSubtransactions(ts, subxids, ts->nSubxids); - + MTM_TRACE("%d: MtmPrePrepareTransaction prepare commit of %d CSN=%ld\n", MyProcPid, x->xid, ts->csn); MtmUnlock(); - MTM_TRACE("%d: MtmPrepareTransaction prepare commit of %d CSN=%ld\n", MyProcPid, x->xid, ts->csn); } static void @@ -606,7 +618,7 @@ MtmPrepareTransaction(MtmCurrentTrans* x) MtmTransState* ts; MtmLock(LW_EXCLUSIVE); - ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); + ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { ts->status = TRANSACTION_STATUS_UNKNOWN; @@ -614,11 +626,12 @@ MtmPrepareTransaction(MtmCurrentTrans* x) } if (!MtmIsCoordinator(ts)) { - MtmTransMap* hm = (MtmTransMap*)hash_search(gid2xid, x->gid, HASH_ENTER, NULL); + MtmTransMap* hm = (MtmTransMap*)hash_search(MtmGid2Xid, x->gid, HASH_ENTER, NULL); Assert(x->gid[0]); hm->state = ts; MtmSendNotificationMessage(ts); /* send notification to coordinator */ MtmUnlock(); + MtmResetTransaction(x); } else { /* wait N commits or just one ABORT */ ts->nVotes += 1; /* I vote myself */ @@ -641,17 +654,20 @@ MtmPrepareTransaction(MtmCurrentTrans* x) static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { - MTM_TRACE("%d: End transaction %d, prepared=%d, distributed=%d -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isDistributed, commit ? "commit" : "abort"); + MTM_TRACE("%d: End transaction %d, prepared=%d, replicated=%d, distributed=%d, gid=%s -> %s\n", + MyProcPid, x->xid, x->isPrepared, x->isReplicated, x->isDistributed, x->gid, commit ? "commit" : "abort"); if (x->isDistributed && (x->isPrepared || x->isReplicated)) { MtmTransState* ts = NULL; MtmLock(LW_EXCLUSIVE); if (x->isPrepared) { - ts = hash_search(xid2state, &x->xid, HASH_FIND, NULL); + ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); } else { - MtmTransMap* hm = (MtmTransMap*)hash_search(gid2xid, x->gid, HASH_REMOVE, NULL); + MtmTransMap* hm = (MtmTransMap*)hash_search(MtmGid2Xid, x->gid, HASH_REMOVE, NULL); if (hm != NULL) { ts = hm->state; + } else { + MTM_TRACE("%d: GID %s not found\n", MyProcPid, x->gid); } } if (ts != NULL) { @@ -663,16 +679,27 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) } } else { ts->status = TRANSACTION_STATUS_ABORTED; - if (x->isReplicated && TransactionIdIsValid(x->gtid.xid)) { - /* - * Send notification only of ABORT happens during transaction processing at replicas, - * do not send notification if ABORT is receiver from master - */ - MtmSendNotificationMessage(ts); /* send notification to coordinator */ - } } MtmAdjustSubtransactions(ts); } + if (!commit && x->isReplicated && TransactionIdIsValid(x->gtid.xid)) { + /* + * Send notification only if ABORT happens during transaction processing at replicas, + * do not send notification if ABORT is receiver from master + */ + MTM_TRACE("%d: send ABORT notification to coordinator %d\n", MyProcPid, x->gtid.node); + if (ts == NULL) { + Assert(TransactionIdIsValid(x->xid)); + ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, NULL); + ts->status = TRANSACTION_STATUS_ABORTED; + ts->snapshot = INVALID_CSN; + ts->csn = MtmAssignCSN(); + ts->gtid = x->gtid; + ts->nSubxids = 0; + MtmTransactionListAppend(ts); + } + MtmSendNotificationMessage(ts); /* send notification to coordinator */ + } MtmUnlock(); } x->snapshot = INVALID_CSN; @@ -740,6 +767,20 @@ void MtmSetCurrentTransactionCSN(csn_t csn) dtmTx.isReplicated = true; } + +csn_t MtmGetTransactionCSN(TransactionId xid) +{ + MtmTransState* ts; + csn_t csn; + MtmLock(LW_SHARED); + ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); + Assert(ts != NULL); + csn = ts->csn; + MtmUnlock(); + return csn; +} + + /* * ------------------------------------------- * HA functions @@ -990,6 +1031,42 @@ void PaxosSet(char const* key, void const* value, int size, bool nowait) * ------------------------------------------- */ + +static HTAB* +MtmCreateHash(void) +{ + HASHCTL info; + HTAB* htab; + Assert(MtmNodes > 0); + memset(&info, 0, sizeof(info)); + info.keysize = sizeof(TransactionId); + info.entrysize = sizeof(MtmTransState); + htab = ShmemInitHash( + "MtmXid2State", + MTM_HASH_SIZE, MTM_HASH_SIZE, + &info, + HASH_ELEM | HASH_BLOBS + ); + return htab; +} + +static HTAB* +MtmCreateMap(void) +{ + HASHCTL info; + HTAB* htab; + memset(&info, 0, sizeof(info)); + info.keysize = MULTIMASTER_MAX_GID_SIZE; + info.entrysize = sizeof(MtmTransMap); + htab = ShmemInitHash( + "MtmGid2Xid", + MTM_MAP_SIZE, MTM_MAP_SIZE, + &info, + HASH_ELEM + ); + return htab; +} + static void MtmInitialize() { bool found; @@ -1025,47 +1102,14 @@ static void MtmInitialize() dtmTx.snapshot = INVALID_CSN; dtmTx.xid = InvalidTransactionId; } - xid2state = MtmCreateHash(); - gid2xid = MtmCreateMap(); + MtmXid2State = MtmCreateHash(); + MtmGid2Xid = MtmCreateMap(); MtmDoReplication = true; TM = &MtmTM; LWLockRelease(AddinShmemInitLock); } -HTAB* MtmCreateHash(void) -{ - HASHCTL info; - HTAB* htab; - Assert(MtmNodes > 0); - memset(&info, 0, sizeof(info)); - info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(MtmTransState); - htab = ShmemInitHash( - "xid2state", - MTM_HASH_SIZE, MTM_HASH_SIZE, - &info, - HASH_ELEM | HASH_BLOBS - ); - return htab; -} - -HTAB* MtmCreateMap(void) -{ - HASHCTL info; - HTAB* htab; - memset(&info, 0, sizeof(info)); - info.keysize = MULTIMASTER_MAX_GID_SIZE; - info.entrysize = sizeof(MtmTransMap); - htab = ShmemInitHash( - "gid2xid", - MTM_MAP_SIZE, MTM_MAP_SIZE, - &info, - HASH_ELEM - ); - return htab; -} - MtmState* MtmGetState(void) { @@ -1689,6 +1733,31 @@ MtmGenerateGid(char* gid) sprintf(gid, "MTM-%d-%d-%d", MtmNodeId, MyProcPid, ++localCount); } +static void MtmTwoPhaseCommit(char *completionTag) +{ + char gid[MULTIMASTER_MAX_GID_SIZE]; + MtmGenerateGid(gid); + if (!IsTransactionBlock()) { + elog(WARNING, "Start transaction block for %d", dtmTx.xid); + BeginTransactionBlock(); + CommitTransactionCommand(); + StartTransactionCommand(); + } + if (!PrepareTransactionBlock(gid)) + { + elog(WARNING, "Failed to prepare transaction %s", gid); + /* report unsuccessful commit in completionTag */ + if (completionTag) { + strcpy(completionTag, "ROLLBACK"); + } + /* ??? Should we do explicit rollback */ + } else { + CommitTransactionCommand(); + StartTransactionCommand(); + FinishPreparedTransaction(gid, true); + } +} + static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag) @@ -1703,29 +1772,8 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, switch (stmt->kind) { case TRANS_STMT_COMMIT: - if (dtmTx.isDistributed && dtmTx.containsDML) { - char gid[MULTIMASTER_MAX_GID_SIZE]; - MtmGenerateGid(gid); - MTM_TRACE("%d: Start 2PC with GID=%s for %s\n", MyProcPid, gid, queryString); - if (!IsTransactionBlock()) { - elog(WARNING, "Start transaction block for %d", dtmTx.xid); - BeginTransactionBlock(); - CommitTransactionCommand(); - StartTransactionCommand(); - } - if (!PrepareTransactionBlock(gid)) - { - elog(WARNING, "Failed to prepare transaction %s", gid); - /* report unsuccessful commit in completionTag */ - if (completionTag) { - strcpy(completionTag, "ROLLBACK"); - } - /* ??? Should we do explicit rollback */ - } else { - CommitTransactionCommand(); - StartTransactionCommand(); - FinishPreparedTransaction(gid, true); - } + if (dtmTx.isDistributed && dtmTx.containsDML) { + MtmTwoPhaseCommit(completionTag); return; } break; @@ -1761,6 +1809,9 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, if (MtmProcessDDLCommand(queryString)) { return; } + if (dtmTx.isDistributed && dtmTx.containsDML && !IsTransactionBlock()) { + MtmTwoPhaseCommit(completionTag); + } } if (PreviousProcessUtilityHook != NULL) { @@ -1781,9 +1832,18 @@ MtmExecutorFinish(QueryDesc *queryDesc) if (MtmDoReplication) { CmdType operation = queryDesc->operation; EState *estate = queryDesc->estate; - if (estate->es_processed != 0) { - dtmTx.containsDML |= operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE; + if (estate->es_processed != 0 && (operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE)) { + int i; + for (i = 0; i < estate->es_num_result_relations; i++) { + if (RelationNeedsWAL(estate->es_result_relations[i].ri_RelationDesc)) { + dtmTx.containsDML = true; + break; + } + } } + if (dtmTx.isDistributed && dtmTx.containsDML && !IsTransactionBlock()) { + MtmTwoPhaseCommit(NULL); + } } if (PreviousExecutorFinishHook != NULL) { @@ -1824,7 +1884,7 @@ MtmGetGtid(TransactionId xid, GlobalTransactionId* gtid) MtmTransState* ts; MtmLock(LW_SHARED); - ts = (MtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); + ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); if (ts != NULL) { *gtid = ts->gtid; } else { diff --git a/multimaster.h b/multimaster.h index bce90b50b8..57e5f6aaa5 100644 --- a/multimaster.h +++ b/multimaster.h @@ -131,6 +131,7 @@ extern int MtmConnectAttempts; extern int MtmConnectTimeout; extern int MtmReconnectAttempts; extern int MtmKeepaliveTimeout; +extern HTAB* MtmXid2State; extern void MtmArbiterInitialize(void); extern int MtmStartReceivers(char* nodes, int nodeId); @@ -142,8 +143,6 @@ extern void MtmReceiverStarted(int nodeId); extern MtmSlotMode MtmReceiverSlotMode(int nodeId); extern void MtmExecute(void* work, int size); extern void MtmExecutor(int id, void* work, size_t size); -extern HTAB* MtmCreateHash(void); -extern HTAB* MtmCreateMap(void); extern void MtmSendNotificationMessage(MtmTransState* ts); extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); @@ -157,6 +156,7 @@ extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern void MtmSetCurrentTransactionGID(char const* gid); extern void MtmSetCurrentTransactionCSN(csn_t csn); +extern csn_t MtmGetTransactionCSN(TransactionId xid); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); diff --git a/pglogical_apply.c b/pglogical_apply.c index e4e2666700..755cc8804a 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -887,8 +887,7 @@ void MtmExecutor(int id, void* work, size_t size) } PG_CATCH(); { - MTM_TRACE("%d: REMOTE abort transaction %d\n", MyProcPid, GetCurrentTransactionId()); - PG_RE_THROW(); + EmitErrorReport(); FlushErrorState(); MTM_TRACE("%d: REMOTE abort transaction %d\n", MyProcPid, GetCurrentTransactionId()); AbortCurrentTransaction(); diff --git a/pglogical_proto.c b/pglogical_proto.c index 3553414190..810e2f8c3d 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -41,7 +41,6 @@ typedef struct PGLogicalProtoMM PGLogicalProtoAPI api; int nodeId; bool isLocal; - HTAB* xid2state; } PGLogicalProtoMM; static void pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel); @@ -120,20 +119,6 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, } } - -static csn_t -MtmGetCSN(PGLogicalProtoMM* mm, TransactionId xid) -{ - MtmTransState* ts; - csn_t csn; - MtmLock(LW_SHARED); - ts = (MtmTransState*)hash_search(mm->xid2state, &xid, HASH_FIND, NULL); - Assert(ts != NULL); - csn = ts->csn; - MtmUnlock(); - return csn; -} - /* * Write COMMIT to the output stream. */ @@ -144,22 +129,32 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; uint8 flags = 0; - if (mm->isLocal) - return; - - pq_sendbyte(out, 'C'); /* sending COMMIT */ - - if (txn->xact_action == XLOG_XACT_COMMIT) + if (txn->xact_action == XLOG_XACT_COMMIT) flags = PGLOGICAL_COMMIT; - else if (txn->xact_action == XLOG_XACT_PREPARE) + else if (txn->xact_action == XLOG_XACT_PREPARE) flags = PGLOGICAL_PREPARE; - else if (txn->xact_action == XLOG_XACT_COMMIT_PREPARED) + else if (txn->xact_action == XLOG_XACT_COMMIT_PREPARED) flags = PGLOGICAL_COMMIT_PREPARED; - else if (txn->xact_action == XLOG_XACT_ABORT_PREPARED) + else if (txn->xact_action == XLOG_XACT_ABORT_PREPARED) flags = PGLOGICAL_ABORT_PREPARED; - else + else Assert(false); + + if (flags == PGLOGICAL_COMMIT || flags == PGLOGICAL_PREPARE) { + if (mm->isLocal) { + return; + } + } else { + csn_t csn = MtmTransactionSnapshot(txn->xid); + bool isRecovery = MtmIsRecoveredNode(mm->nodeId); + if (csn == INVALID_CSN && !isRecovery) { + return; + } + } + + pq_sendbyte(out, 'C'); /* sending COMMIT */ + MTM_TRACE("PGLOGICAL_SEND commit: event=%d, gid=%s\n", flags, txn->gid); /* send the flags field */ @@ -170,13 +165,10 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, pq_sendint64(out, txn->end_lsn); pq_sendint64(out, txn->commit_time); - if (txn->xact_action == XLOG_XACT_COMMIT_PREPARED) { - pq_sendint64(out, MtmGetCSN(mm, txn->xid)); + if (flags == PGLOGICAL_COMMIT_PREPARED) { + pq_sendint64(out, MtmGetTransactionCSN(txn->xid)); } - if (txn->xact_action == XLOG_XACT_PREPARE || - txn->xact_action == XLOG_XACT_COMMIT_PREPARED || - txn->xact_action == XLOG_XACT_ABORT_PREPARED) - { + if (flags != PGLOGICAL_COMMIT) { pq_sendstring(out, txn->gid); } @@ -429,7 +421,6 @@ pglogical_init_api(PGLogicalProtoType typ) PGLogicalProtoMM* pmm = palloc0(sizeof(PGLogicalProtoMM)); PGLogicalProtoAPI* res = &pmm->api; pmm->isLocal = false; - pmm->xid2state = MtmCreateHash(); sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &pmm->nodeId); res->write_rel = pglogical_write_rel; res->write_begin = pglogical_write_begin; From c9f6ec119ec9791b7b89030e3ff04b52aec07519 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 17 Mar 2016 14:28:00 +0300 Subject: [PATCH 0299/1139] Update 2PC support --- multimaster.c | 5 +++++ multimaster.h | 1 + pglogical_apply.c | 10 ++++++++-- 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/multimaster.c b/multimaster.c index 973bc11e52..98168ab09d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1116,6 +1116,11 @@ MtmGetState(void) return dtm; } +TransactionId MtmGetCurrentTransaction(void) +{ + return dtmTx.xid; +} + static void MtmShmemStartup(void) { diff --git a/multimaster.h b/multimaster.h index 57e5f6aaa5..242a28bb5c 100644 --- a/multimaster.h +++ b/multimaster.h @@ -157,6 +157,7 @@ extern void MtmSleep(timestamp_t interval); extern void MtmSetCurrentTransactionGID(char const* gid); extern void MtmSetCurrentTransactionCSN(csn_t csn); extern csn_t MtmGetTransactionCSN(TransactionId xid); +extern TransactionId MtmGetCurrentTransactionId(void); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); diff --git a/pglogical_apply.c b/pglogical_apply.c index 755cc8804a..ff2e93a5bc 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -484,12 +484,15 @@ process_remote_commit(StringInfo in) { case PGLOGICAL_COMMIT: { - if (IsTransactionState()) + if (IsTransactionState()) { + Assert(TransactionIdIsValid(MtmGetCurrentTransactionId())); CommitTransactionCommand(); + } break; } case PGLOGICAL_PREPARE: { + Assert(IsTransactionState() && TransactionIdIsValid(MtmGetCurrentTransactionId())); gid = pq_getmsgstring(in); /* prepare TBLOCK_INPROGRESS state for PrepareTransactionBlock() */ BeginTransactionBlock(); @@ -503,6 +506,7 @@ process_remote_commit(StringInfo in) } case PGLOGICAL_COMMIT_PREPARED: { + Assert(!TransactionIdIsValid(MtmGetCurrentTransactionId())); csn = pq_getmsgint64(in); gid = pq_getmsgstring(in); StartTransactionCommand(); @@ -514,6 +518,7 @@ process_remote_commit(StringInfo in) } case PGLOGICAL_ABORT_PREPARED: { + Assert(!TransactionIdIsValid(MtmGetCurrentTransactionId())); gid = pq_getmsgstring(in); StartTransactionCommand(); MtmSetCurrentTransactionGID(gid); @@ -889,8 +894,9 @@ void MtmExecutor(int id, void* work, size_t size) { EmitErrorReport(); FlushErrorState(); - MTM_TRACE("%d: REMOTE abort transaction %d\n", MyProcPid, GetCurrentTransactionId()); + MTM_TRACE("%d: REMOTE begin abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); AbortCurrentTransaction(); + MTM_TRACE("%d: REMOTE end abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); } PG_END_TRY(); From 5e358771667b0349c674d10cb5669ea081a95ca8 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 18 Mar 2016 20:34:45 +0300 Subject: [PATCH 0300/1139] Correctly store LSN --- arbiter.c | 102 ++++++++++++++++++++++++++++--------- bgwpool.c | 4 +- multimaster.c | 118 +++++++++++++++++++++---------------------- multimaster.h | 21 +++++--- pglogical_apply.c | 40 ++++++++++----- pglogical_proto.c | 9 ++-- pglogical_receiver.c | 28 ++++++---- tests/dtmbench.cpp | 9 ++++ 8 files changed, 214 insertions(+), 117 deletions(-) diff --git a/arbiter.c b/arbiter.c index e59f555418..6bcb72cf14 100644 --- a/arbiter.c +++ b/arbiter.c @@ -106,10 +106,7 @@ static char const* const messageText[] = "HANDSHAKE", "READY", "PREPARE", - "COMMIT", - "ABORT", "PREPARED", - "COMMITTED", "ABORTED", "STATUS" }; @@ -456,8 +453,10 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt buf->used = 0; } MTM_TRACE("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", - ts->status == TRANSACTION_STATUS_ABORTED ? "abort" : "commit", ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); - buf->data[buf->used].code = ts->status == TRANSACTION_STATUS_ABORTED ? MSG_ABORTED : MSG_PREPARED; + messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); + + Assert(ts->cmd != MSG_INVALID); + buf->data[buf->used].code = ts->cmd; buf->data[buf->used].dxid = xid; buf->data[buf->used].sxid = ts->xid; buf->data[buf->used].csn = ts->csn; @@ -466,6 +465,22 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt buf->used += 1; } +static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) +{ + int i; + int n = 1; + for (i = 0; i < MtmNodes; i++) + { + if (TransactionIdIsValid(ts->xids[i])) { + Assert(i+1 != MtmNodeId); + MtmAppendBuffer(txBuffer, ts->xids[i], i, ts); + n += 1; + } + } + Assert(n == ds->nNodes); +} + + static void MtmTransSender(Datum arg) { int nNodes = MtmNodes; @@ -492,7 +507,11 @@ static void MtmTransSender(Datum arg) MtmLock(LW_SHARED); for (ts = ds->votingTransactions; ts != NULL; ts = ts->nextVoting) { - MtmAppendBuffer(txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); + if (MtmIsCoordinator(ts)) { + MtmBroadcastMessage(txBuffer, ts); + } else { + MtmAppendBuffer(txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); + } } ds->votingTransactions = NULL; @@ -510,6 +529,7 @@ static void MtmTransSender(Datum arg) static void MtmWakeUpBackend(MtmTransState* ts) { MTM_TRACE("Wakeup backed procno=%d, pid=%d\n", ts->procno, ProcGlobal->allProcs[ts->procno].pid); + ts->votingCompleted = true; SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } @@ -565,6 +585,9 @@ static void MtmTransReceiver(Datum arg) #if USE_EPOLL n = epoll_wait(epollfd, events, nNodes, MtmKeepaliveTimeout/1000); if (n < 0) { + if (errno == EINTR) { + continue; + } elog(ERROR, "Arbiter failed to poll sockets: %d", errno); } for (j = 0; j < n; j++) { @@ -581,7 +604,9 @@ static void MtmTransReceiver(Datum arg) events = inset; tv.tv_sec = MtmKeepaliveTimeout/USEC; tv.tv_usec = MtmKeepaliveTimeout%USEC; - n = select(max_fd+1, &events, NULL, NULL, &tv); + do { + n = select(max_fd+1, &events, NULL, NULL, &tv); + } while (n < 0 && errno == ENINTR); } while (n < 0 && MtmRecovery()); if (rc < 0) { @@ -612,31 +637,62 @@ static void MtmTransReceiver(Datum arg) MtmTransState* ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); Assert(msg->node > 0 && msg->node <= nNodes && msg->node != MtmNodeId); - Assert (MtmIsCoordinator(ts)); - switch (msg->code) { - case MSG_PREPARED: - if (ts->status != TRANSACTION_STATUS_ABORTED) { - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS || ts->status == TRANSACTION_STATUS_UNKNOWN); - if (msg->csn > ts->csn) { - ts->csn = msg->csn; - MtmSyncClock(ts->csn); - } - if (++ts->nVotes == ds->nNodes) { - MtmWakeUpBackend(ts); + if (MtmIsCoordinator(ts)) { + switch (msg->code) { + case MSG_READY: + Assert(ts->nVotes < ds->nNodes); + ds->nodeTransDelay[msg->node-1] += MtmGetCurrentTime() - ts->csn; + ts->xids[msg->node-1] = msg->sxid; + if (++ts->nVotes == ds->nNodes) { + /* All nodes are finished their transactions */ + if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { + ts->nVotes = 1; /* I voted myself */ + MtmSendNotificationMessage(ts, MSG_PREPARE); + } else { + Assert(ts->status == TRANSACTION_STATUS_ABORTED); + MtmWakeUpBackend(ts); } } - break; - case MSG_ABORTED: + break; + case MSG_ABORTED: + Assert(ts->nVotes < ds->nNodes); if (ts->status != TRANSACTION_STATUS_ABORTED) { - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS || ts->status == TRANSACTION_STATUS_UNKNOWN); + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); + } + if (++ts->nVotes == ds->nNodes) { MtmWakeUpBackend(ts); } break; - default: + case MSG_PREPARED: + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + Assert(ts->nVotes < ds->nNodes); + if (msg->csn > ts->csn) { + ts->csn = msg->csn; + MtmSyncClock(ts->csn); + } + if (++ts->nVotes == ds->nNodes) { + ts->csn = MtmAssignCSN(); + ts->status = TRANSACTION_STATUS_UNKNOWN; + MtmWakeUpBackend(ts); + } + default: + Assert(false); + } + } else { + switch (msg->code) { + case MSG_PREPARE: + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + ts->status = TRANSACTION_STATUS_UNKNOWN; + ts->csn = MtmAssignCSN(); + MtmAdjustSubtransactions(ts); + MtmSendNotificationMessage(ts, MSG_PREPARED); + break; + default: Assert(false); - } + } + } } MtmUnlock(); diff --git a/bgwpool.c b/bgwpool.c index 2b6d659339..8ab1a7c378 100644 --- a/bgwpool.c +++ b/bgwpool.c @@ -37,7 +37,7 @@ static void BgwPoolMainLoop(Datum arg) SpinLockAcquire(&pool->lock); size = *(int*)&pool->queue[pool->head]; Assert(size < pool->size); - work = palloc(size); + work = malloc(size); pool->active -= 1; if (pool->head + size + 4 > pool->size) { memcpy(work, pool->queue, size); @@ -55,7 +55,7 @@ static void BgwPoolMainLoop(Datum arg) } SpinLockRelease(&pool->lock); pool->executor(id, work, size); - pfree(work); + free(work); } } diff --git a/multimaster.c b/multimaster.c index 98168ab09d..e4bb1aa317 100644 --- a/multimaster.c +++ b/multimaster.c @@ -65,6 +65,7 @@ typedef struct { bool isDistributed; /* transaction performed INSERT/UPDATE/DELETE and has to be replicated to other nodes */ bool isPrepared; /* transaction is perpared at first stage of 2PC */ bool containsDML; /* transaction contains DML statements */ + XidStatus status; /* transaction status */ csn_t snapshot; /* transaction snaphsot */ csn_t csn; /* CSN */ char gid[MULTIMASTER_MAX_GID_SIZE]; /* global transaction identifier (used by 2pc) */ @@ -108,7 +109,7 @@ static void MtmInitialize(void); static void MtmXactCallback(XactEvent event, void *arg); static void MtmBeginTransaction(MtmCurrentTrans* x); static void MtmPrePrepareTransaction(MtmCurrentTrans* x); -static void MtmPrepareTransaction(MtmCurrentTrans* x); +static void MtmPostPrepareTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); @@ -127,7 +128,7 @@ static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); HTAB* MtmXid2State; -static HTAB* MtmGid2Xid; +static HTAB* MtmGid2State; static MtmCurrentTrans dtmTx; static MtmState* dtm; @@ -492,8 +493,8 @@ MtmXactCallback(XactEvent event, void *arg) case XACT_EVENT_PRE_PREPARE: MtmPrePrepareTransaction(&dtmTx); break; - case XACT_EVENT_PREPARE: - MtmPrepareTransaction(&dtmTx); + case XACT_EVENT_POST_PREPARE: + MtmPostPrepareTransaction(&dtmTx); break; case XACT_EVENT_COMMIT: MtmEndTransaction(&dtmTx, true); @@ -542,6 +543,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->snapshot = MtmAssignCSN(); x->gtid.xid = InvalidTransactionId; x->gid[0] = '\0'; + x->status = TRANSACTION_STATUS_IN_PROGRESS; MtmUnlock(); MTM_TRACE("%d: MtmLocalTransaction: %s transaction %u uses local snapshot %lu\n", @@ -589,7 +591,9 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; ts->procno = MyProc->pgprocno; - ts->nVotes = 0; + ts->nVotes = 1; /* I am voted myself */ + ts->votingCompleted = false; + ts->cmd = MSG_INVALID; ts->nSubxids = xactGetCommittedChildren(&subxids); x->isPrepared = true; @@ -613,40 +617,31 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) } static void -MtmPrepareTransaction(MtmCurrentTrans* x) +MtmPostPrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; MtmLock(LW_EXCLUSIVE); ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); - if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { - ts->status = TRANSACTION_STATUS_UNKNOWN; - MtmAdjustSubtransactions(ts); - } - if (!MtmIsCoordinator(ts)) { - MtmTransMap* hm = (MtmTransMap*)hash_search(MtmGid2Xid, x->gid, HASH_ENTER, NULL); + MtmTransMap* tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_ENTER, NULL); Assert(x->gid[0]); - hm->state = ts; - MtmSendNotificationMessage(ts); /* send notification to coordinator */ + tm->state = ts; + MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ MtmUnlock(); MtmResetTransaction(x); } else { - /* wait N commits or just one ABORT */ - ts->nVotes += 1; /* I vote myself */ - while (ts->nVotes != dtm->nNodes && ts->status != TRANSACTION_STATUS_ABORTED) { + /* wait votes from all nodes */ + while (!ts->votingCompleted) { MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); MtmLock(LW_SHARED); } + x->status = ts->status; + MTM_TRACE("%d: Result of vote: %d\n", MyProcPid, ts->status); MtmUnlock(); - if (ts->status == TRANSACTION_STATUS_ABORTED) { - elog(ERROR, "Distributed transaction %d is rejected by DTM", x->xid); - } else { - Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - } } } @@ -662,21 +657,18 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) if (x->isPrepared) { ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); - } else { - MtmTransMap* hm = (MtmTransMap*)hash_search(MtmGid2Xid, x->gid, HASH_REMOVE, NULL); - if (hm != NULL) { - ts = hm->state; + } else if (x->gid[0]) { + MtmTransMap* tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_REMOVE, NULL); + if (tm != NULL) { + ts = tm->state; } else { MTM_TRACE("%d: GID %s not found\n", MyProcPid, x->gid); } } if (ts != NULL) { if (commit) { + Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); ts->status = TRANSACTION_STATUS_COMMITTED; - if (x->csn > ts->csn) { - ts->csn = x->csn; - MtmSyncClock(ts->csn); - } } else { ts->status = TRANSACTION_STATUS_ABORTED; } @@ -696,9 +688,10 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; ts->nSubxids = 0; + ts->cmd = MSG_INVALID; MtmTransactionListAppend(ts); } - MtmSendNotificationMessage(ts); /* send notification to coordinator */ + MtmSendNotificationMessage(ts, MSG_ABORTED); /* send notification to coordinator */ } MtmUnlock(); } @@ -708,12 +701,13 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) MtmCheckSlots(); } -void MtmSendNotificationMessage(MtmTransState* ts) +void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd) { MtmTransState* votingList; votingList = dtm->votingTransactions; ts->nextVoting = votingList; + ts->cmd = cmd; dtm->votingTransactions = ts; if (votingList == NULL) { @@ -759,28 +753,34 @@ void MtmSetCurrentTransactionGID(char const* gid) dtmTx.isReplicated = true; } -void MtmSetCurrentTransactionCSN(csn_t csn) +TransactionId MtmGetCurrentTransactionId(void) { - MTM_TRACE("Set current transaction CSN %ld\n", csn); - dtmTx.csn = csn; - dtmTx.isDistributed = true; - dtmTx.isReplicated = true; + return dtmTx.xid; } +XidStatus MtmGetCurrentTransactionStatus(void) +{ + return dtmTx.status; +} -csn_t MtmGetTransactionCSN(TransactionId xid) +XidStatus MtmGetGlobalTransactionStatus(char const* gid) { - MtmTransState* ts; - csn_t csn; + XidStatus status; + MtmTransMap* tm; + + Assert(gid[0]); MtmLock(LW_SHARED); - ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - Assert(ts != NULL); - csn = ts->csn; + tm = (MtmTransMap*)hash_search(MtmGid2State, gid, HASH_FIND, NULL); + if (tm != NULL) { + status = tm->state->status; + } else { + status = TRANSACTION_STATUS_ABORTED; + } MtmUnlock(); - return csn; + return status; } - + /* * ------------------------------------------- * HA functions @@ -804,7 +804,7 @@ MtmCheckSlots() if (slot->in_use && sscanf(slot->data.name.data, MULTIMASTER_SLOT_PATTERN, &nodeId) == 1 && BIT_CHECK(dtm->disabledNodeMask, nodeId-1) - && slot->data.restart_lsn + MtmMaxRecoveryLag < GetXLogInsertRecPtr()) + && slot->data.confirmed_flush + MtmMaxRecoveryLag < GetXLogInsertRecPtr()) { elog(WARNING, "Drop slot for node %d which lag %ld is larger than threshold %d", nodeId, @@ -826,7 +826,7 @@ static int64 MtmGetSlotLag(int nodeId) && sscanf(slot->data.name.data, MULTIMASTER_SLOT_PATTERN, &node) == 1 && node == nodeId) { - return GetXLogInsertRecPtr() - slot->data.restart_lsn; + return GetXLogInsertRecPtr() - slot->data.confirmed_flush; } } return -1; @@ -1033,14 +1033,14 @@ void PaxosSet(char const* key, void const* value, int size, bool nowait) static HTAB* -MtmCreateHash(void) +MtmCreateXidMap(void) { HASHCTL info; HTAB* htab; Assert(MtmNodes > 0); memset(&info, 0, sizeof(info)); info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(MtmTransState); + info.entrysize = sizeof(MtmTransState) + (MtmNodes-1)*sizeof(TransactionId); htab = ShmemInitHash( "MtmXid2State", MTM_HASH_SIZE, MTM_HASH_SIZE, @@ -1051,7 +1051,7 @@ MtmCreateHash(void) } static HTAB* -MtmCreateMap(void) +MtmCreateGidMap(void) { HASHCTL info; HTAB* htab; @@ -1059,7 +1059,7 @@ MtmCreateMap(void) info.keysize = MULTIMASTER_MAX_GID_SIZE; info.entrysize = sizeof(MtmTransMap); htab = ShmemInitHash( - "MtmGid2Xid", + "MtmGid2State", MTM_MAP_SIZE, MTM_MAP_SIZE, &info, HASH_ELEM @@ -1102,8 +1102,8 @@ static void MtmInitialize() dtmTx.snapshot = INVALID_CSN; dtmTx.xid = InvalidTransactionId; } - MtmXid2State = MtmCreateHash(); - MtmGid2Xid = MtmCreateMap(); + MtmXid2State = MtmCreateXidMap(); + MtmGid2State = MtmCreateGidMap(); MtmDoReplication = true; TM = &MtmTM; LWLockRelease(AddinShmemInitLock); @@ -1116,11 +1116,6 @@ MtmGetState(void) return dtm; } -TransactionId MtmGetCurrentTransaction(void) -{ - return dtmTx.xid; -} - static void MtmShmemStartup(void) { @@ -1759,7 +1754,12 @@ static void MtmTwoPhaseCommit(char *completionTag) } else { CommitTransactionCommand(); StartTransactionCommand(); - FinishPreparedTransaction(gid, true); + if (MtmGetCurrentTransactionStatus() == TRANSACTION_STATUS_ABORTED) { + FinishPreparedTransaction(gid, false); + elog(ERROR, "Transaction %s is aborted by DTM", gid); + } else { + FinishPreparedTransaction(gid, true); + } } } diff --git a/multimaster.h b/multimaster.h index 242a28bb5c..6d17fff38f 100644 --- a/multimaster.h +++ b/multimaster.h @@ -5,13 +5,14 @@ #include "bgwpool.h" #include "bkb.h" -#define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TUPLE_TRACE(fmt, ...) /* +#define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -#define MTM_TUPLE_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ +#define MTM_TRACE(fmt, ...) +#define MTM_TUPLE_TRACE(fmt, ...) +/* */ #define MULTIMASTER_NAME "multimaster" #define MULTIMASTER_SCHEMA_NAME "mtm" @@ -20,6 +21,7 @@ #define MULTIMASTER_MIN_PROTO_VERSION 1 #define MULTIMASTER_MAX_PROTO_VERSION 1 #define MULTIMASTER_MAX_GID_SIZE 32 +#define MULTIMASTER_MAX_SLOT_NAME_SIZE 16 #define USEC 1000000 @@ -52,6 +54,8 @@ typedef enum { MSG_INVALID, MSG_HANDSHAKE, + MSG_READY, + MSG_PREPARE, MSG_PREPARED, MSG_ABORTED, MSG_STATUS @@ -85,8 +89,11 @@ typedef struct MtmTransState int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, used to notify coordinator by arbiter */ int nSubxids; /* Number of subtransanctions */ - struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ + MtmMessageCode cmd; /* Notification message to be sent */ + struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ + bool votingCompleted; /* 2PC voting is completed */ + TransactionId xids[1]; /* Transaction ID at replicas: varying size MtmNodes */ } MtmTransState; typedef struct @@ -143,7 +150,7 @@ extern void MtmReceiverStarted(int nodeId); extern MtmSlotMode MtmReceiverSlotMode(int nodeId); extern void MtmExecute(void* work, int size); extern void MtmExecutor(int id, void* work, size_t size); -extern void MtmSendNotificationMessage(MtmTransState* ts); +extern void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd); extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); extern void MtmUnlock(void); @@ -155,9 +162,9 @@ extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern void MtmSetCurrentTransactionGID(char const* gid); -extern void MtmSetCurrentTransactionCSN(csn_t csn); -extern csn_t MtmGetTransactionCSN(TransactionId xid); extern TransactionId MtmGetCurrentTransactionId(void); +extern XidStatus MtmGetCurrentTransactionStatus(void); +extern XidStatus MtmGetGlobalTransactionStatus(char const* gid); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); diff --git a/pglogical_apply.c b/pglogical_apply.c index ff2e93a5bc..da2226abdb 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -26,6 +26,7 @@ #include "parser/parse_type.h" #include "replication/logical.h" +#include "replication/origin.h" #include "storage/ipc.h" #include "storage/lmgr.h" @@ -467,23 +468,28 @@ static void process_remote_commit(StringInfo in) { uint8 flags; + uint8 nodeId; const char *gid = NULL; - csn_t csn; + char slot_name[MULTIMASTER_MAX_SLOT_NAME_SIZE]; /* read flags */ flags = pq_getmsgbyte(in); + nodeId = pq_getmsgbyte(in); /* read fields */ - pq_getmsgint64(in); /* commit_lsn */ + replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ pq_getmsgint64(in); /* end_lsn */ - pq_getmsgint64(in); /* commit_time */ - - MTM_TRACE("PGLOGICAL_RECV commit: flags=%d, gid=%s\n", flags, gid); + replorigin_session_origin_timestamp = pq_getmsgint64(in); /* commit_time */ + + sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, nodeId); + replorigin_session_origin = replorigin_by_name(slot_name, false); + replorigin_session_setup(replorigin_session_origin); switch(PGLOGICAL_XACT_EVENT(flags)) { case PGLOGICAL_COMMIT: { + MTM_TRACE("%d: PGLOGICAL_COMMIT commit\n", MyProcPid); if (IsTransactionState()) { Assert(TransactionIdIsValid(MtmGetCurrentTransactionId())); CommitTransactionCommand(); @@ -495,6 +501,7 @@ process_remote_commit(StringInfo in) Assert(IsTransactionState() && TransactionIdIsValid(MtmGetCurrentTransactionId())); gid = pq_getmsgstring(in); /* prepare TBLOCK_INPROGRESS state for PrepareTransactionBlock() */ + MTM_TRACE("%d: PGLOGICAL_PREPARE commit: gid=%s\n", MyProcPid, gid); BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); @@ -507,10 +514,9 @@ process_remote_commit(StringInfo in) case PGLOGICAL_COMMIT_PREPARED: { Assert(!TransactionIdIsValid(MtmGetCurrentTransactionId())); - csn = pq_getmsgint64(in); gid = pq_getmsgstring(in); + MTM_TRACE("%d: PGLOGICAL_COMMIT_PREPARED commit: csn=%ld, gid=%s\n", MyProcPid, csn, gid); StartTransactionCommand(); - MtmSetCurrentTransactionCSN(csn); MtmSetCurrentTransactionGID(gid); FinishPreparedTransaction(gid, true); CommitTransactionCommand(); @@ -520,15 +526,20 @@ process_remote_commit(StringInfo in) { Assert(!TransactionIdIsValid(MtmGetCurrentTransactionId())); gid = pq_getmsgstring(in); - StartTransactionCommand(); - MtmSetCurrentTransactionGID(gid); - FinishPreparedTransaction(gid, false); - CommitTransactionCommand(); + MTM_TRACE("%d: PGLOGICAL_ABORT_PREPARED commit: gid=%s\n", MyProcPid, gid); + if (MtmGetGlobalTransactionStatus(gid) != TRANSACTION_STATUS_ABORTED) { + StartTransactionCommand(); + MtmSetCurrentTransactionGID(gid); + FinishPreparedTransaction(gid, false); + CommitTransactionCommand(); + } break; } default: Assert(false); } + replorigin_session_reset(); + replorigin_session_origin = InvalidRepOriginId; } static void @@ -854,12 +865,12 @@ void MtmExecutor(int id, void* work, size_t size) ALLOCSET_DEFAULT_MAXSIZE); } MemoryContextSwitchTo(ApplyContext); - + replorigin_session_origin = InvalidRepOriginId; PG_TRY(); { while (true) { char action = pq_getmsgbyte(&s); - + MTM_TRACE("%d: REMOTE process actiob %c\n", MyProcPid, action); switch (action) { /* BEGIN */ case 'B': @@ -892,6 +903,9 @@ void MtmExecutor(int id, void* work, size_t size) } PG_CATCH(); { + if (replorigin_session_origin != InvalidRepOriginId) { + replorigin_session_reset(); + } EmitErrorReport(); FlushErrorState(); MTM_TRACE("%d: REMOTE begin abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); diff --git a/pglogical_proto.c b/pglogical_proto.c index 810e2f8c3d..3719b5343f 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -3,6 +3,7 @@ #include "miscadmin.h" #include "pglogical_output.h" +#include "replication/origin.h" #include "access/sysattr.h" #include "access/tuptoaster.h" @@ -109,9 +110,11 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, bool isRecovery = MtmIsRecoveredNode(mm->nodeId); MTM_TRACE("pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); if (csn == INVALID_CSN && !isRecovery) { - mm->isLocal = true; + //Assert(txn->origin_id != InvalidRepOriginId); + mm->isLocal = true; } else { mm->isLocal = false; + //Assert(txn->origin_id == InvalidRepOriginId || isRecovery); pq_sendbyte(out, 'B'); /* BEGIN */ pq_sendint(out, MtmNodeId, 4); pq_sendint(out, isRecovery ? InvalidTransactionId : txn->xid, 4); @@ -159,15 +162,13 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, /* send the flags field */ pq_sendbyte(out, flags); + pq_sendbyte(out, MtmNodeId); /* send fixed fields */ pq_sendint64(out, commit_lsn); pq_sendint64(out, txn->end_lsn); pq_sendint64(out, txn->commit_time); - if (flags == PGLOGICAL_COMMIT_PREPARED) { - pq_sendint64(out, MtmGetTransactionCSN(txn->xid)); - } if (flags != PGLOGICAL_COMMIT) { pq_sendstring(out, txn->gid); } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 0c083e08e0..f217673438 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -42,7 +42,7 @@ typedef struct ReceiverArgs { int local_node; int remote_node; char* receiver_conn_string; - char receiver_slot[16]; + char receiver_slot[MULTIMASTER_MAX_SLOT_NAME_SIZE]; } ReceiverArgs; #define ERRCODE_DUPLICATE_OBJECT_STR "42710" @@ -205,13 +205,15 @@ pglogical_receiver_main(Datum main_arg) PGconn *conn; PGresult *res; MtmSlotMode mode; - MtmState* ds; + MtmState* ds = MtmGetState(); + #ifndef USE_PGLOGICAL_OUTPUT bool insideTrans = false; #endif ByteBuffer buf; XLogRecPtr originStartPos = 0; RepOriginId originId; + char* originName; /* Register functions for SIGTERM/SIGHUP management */ pqsignal(SIGHUP, receiver_raw_sighup); @@ -270,12 +272,21 @@ pglogical_receiver_main(Datum main_arg) /* Start logical replication at specified position */ StartTransactionCommand(); - originId = replorigin_by_name(args->receiver_slot, true); - if (originId != InvalidRepOriginId) { + originName = psprintf(MULTIMASTER_SLOT_PATTERN, args->remote_node); + originId = replorigin_by_name(originName, true); + if (originId == InvalidRepOriginId) { + originId = replorigin_create(originName); + /* + * We are just creating new replication slot. + * It is assumed that state of local and remote nodes is the same at this moment. + * Them are either empty, either new node is synchronized using base_backup. + * So we assume that LSNs are the same for local and remote node + */ + originStartPos = ds->status == MTM_RECOVERY ? GetXLogInsertRecPtr() : 0; + elog(WARNING, "Start logical receiver at position %lx from node %d", originStartPos, args->remote_node); + } else { originStartPos = replorigin_get_progress(originId, false); elog(WARNING, "Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); - } else { - elog(WARNING, "Start logical receiver from node %d", args->remote_node); } CommitTransactionCommand(); @@ -299,7 +310,6 @@ pglogical_receiver_main(Datum main_arg) MtmReceiverStarted(args->remote_node); ByteBufferAlloc(&buf); - ds = MtmGetState(); while (!got_sigterm) { @@ -438,7 +448,7 @@ pglogical_receiver_main(Datum main_arg) ByteBufferAppend(&buf, stmt, rc - hdr_len); if (stmt[0] == 'C') /* commit */ { - MtmExecute(buf.data, buf.used); + MtmExecute(buf.data, buf.used); ByteBufferReset(&buf); } #else @@ -589,7 +599,7 @@ int MtmStartReceivers(char* conns, int node_id) MtmDatabaseName[len] = '\0'; } ctx->receiver_conn_string = psprintf("replication=database %.*s", (int)(p - conn_str), conn_str); - sprintf(ctx->receiver_slot, "mtm_slot_%d", node_id); + sprintf(ctx->receiver_slot, MULTIMASTER_SLOT_PATTERN, node_id); ctx->local_node = node_id; ctx->remote_node = i; diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 5a84f250ff..3e551f8038 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -68,6 +68,7 @@ struct config int nAccounts; int updatePercent; vector connections; + bool scatter; config() { nReaders = 1; @@ -75,6 +76,7 @@ struct config nIterations = 1000; nAccounts = 100000; updatePercent = 100; + scatter = false; } }; @@ -152,6 +154,10 @@ void* writer(void* arg) //transaction txn(*conns[random() % conns.size()]); int srcAcc = random() % cfg.nAccounts; int dstAcc = random() % cfg.nAccounts; + if (cfg.scatter) { + srcAcc = srcAcc/cfg.nWriters*cfg.nWriters + t.id; + dstAcc = dstAcc/cfg.nWriters*cfg.nWriters + t.id; + } try { if (random() % 100 < cfg.updatePercent) { exec(txn, "update t set v = v - 1 where u=%d", srcAcc); @@ -225,6 +231,9 @@ int main (int argc, char* argv[]) case 'p': cfg.updatePercent = atoi(argv[++i]); continue; + case 's': + cfg.scatter = true; + continue; case 'c': cfg.connections.push_back(string(argv[++i])); continue; From dc5ae4a727413154e33005b86fc9da6adb2baeef Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 19 Mar 2016 00:01:51 +0300 Subject: [PATCH 0301/1139] Fixes in 2pc --- arbiter.c | 1 + multimaster.c | 44 +++++++++++++++++++++++++++++++------------- pglogical_apply.c | 17 ++++++++++++----- 3 files changed, 44 insertions(+), 18 deletions(-) diff --git a/arbiter.c b/arbiter.c index 6bcb72cf14..e9b20df771 100644 --- a/arbiter.c +++ b/arbiter.c @@ -677,6 +677,7 @@ static void MtmTransReceiver(Datum arg) ts->status = TRANSACTION_STATUS_UNKNOWN; MtmWakeUpBackend(ts); } + break; default: Assert(false); } diff --git a/multimaster.c b/multimaster.c index e4bb1aa317..3c5873fe87 100644 --- a/multimaster.c +++ b/multimaster.c @@ -110,6 +110,7 @@ static void MtmXactCallback(XactEvent event, void *arg); static void MtmBeginTransaction(MtmCurrentTrans* x); static void MtmPrePrepareTransaction(MtmCurrentTrans* x); static void MtmPostPrepareTransaction(MtmCurrentTrans* x); +static void MtmAbortPreparedTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); @@ -496,6 +497,9 @@ MtmXactCallback(XactEvent event, void *arg) case XACT_EVENT_POST_PREPARE: MtmPostPrepareTransaction(&dtmTx); break; + case XACT_EVENT_ABORT_PREPARED: + MtmAbortPreparedTransaction(&dtmTx); + break; case XACT_EVENT_COMMIT: MtmEndTransaction(&dtmTx, true); break; @@ -522,6 +526,7 @@ MtmResetTransaction(MtmCurrentTrans* x) x->snapshot = INVALID_CSN; x->xid = InvalidTransactionId; x->gtid.xid = InvalidTransactionId; + x->isDistributed = false; } static void @@ -620,14 +625,16 @@ static void MtmPostPrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; + MtmTransMap* tm; MtmLock(LW_EXCLUSIVE); ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); + tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_ENTER, NULL); + Assert(x->gid[0]); + tm->state = ts; + if (!MtmIsCoordinator(ts)) { - MtmTransMap* tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_ENTER, NULL); - Assert(x->gid[0]); - tm->state = ts; MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ MtmUnlock(); MtmResetTransaction(x); @@ -646,6 +653,20 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) } +static void +MtmAbortPreparedTransaction(MtmCurrentTrans* x) +{ + MtmTransMap* tm; + + MtmLock(LW_EXCLUSIVE); + tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_REMOVE, NULL); + Assert(tm != NULL); + tm->state->status = TRANSACTION_STATUS_ABORTED; + MtmAdjustSubtransactions(tm->state); + MtmUnlock(); + MtmResetTransaction(x); +} + static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { @@ -695,9 +716,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) } MtmUnlock(); } - x->snapshot = INVALID_CSN; - x->xid = InvalidTransactionId; - x->gtid.xid = InvalidTransactionId; + MtmResetTransaction(x); MtmCheckSlots(); } @@ -1735,17 +1754,16 @@ MtmGenerateGid(char* gid) static void MtmTwoPhaseCommit(char *completionTag) { - char gid[MULTIMASTER_MAX_GID_SIZE]; - MtmGenerateGid(gid); + MtmGenerateGid(dtmTx.gid); if (!IsTransactionBlock()) { elog(WARNING, "Start transaction block for %d", dtmTx.xid); BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); } - if (!PrepareTransactionBlock(gid)) + if (!PrepareTransactionBlock(dtmTx.gid)) { - elog(WARNING, "Failed to prepare transaction %s", gid); + elog(WARNING, "Failed to prepare transaction %s", dtmTx.gid); /* report unsuccessful commit in completionTag */ if (completionTag) { strcpy(completionTag, "ROLLBACK"); @@ -1755,10 +1773,10 @@ static void MtmTwoPhaseCommit(char *completionTag) CommitTransactionCommand(); StartTransactionCommand(); if (MtmGetCurrentTransactionStatus() == TRANSACTION_STATUS_ABORTED) { - FinishPreparedTransaction(gid, false); - elog(ERROR, "Transaction %s is aborted by DTM", gid); + FinishPreparedTransaction(dtmTx.gid, false); + elog(ERROR, "Transaction %s is aborted by DTM", dtmTx.gid); } else { - FinishPreparedTransaction(gid, true); + FinishPreparedTransaction(dtmTx.gid, true); } } } diff --git a/pglogical_apply.c b/pglogical_apply.c index da2226abdb..03a9e50787 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -464,13 +464,21 @@ read_rel(StringInfo s, LOCKMODE mode) return heap_open(relid, NoLock); } +static void +MtmSetCurrentSession(int nodeId) +{ + char slot_name[MULTIMASTER_MAX_SLOT_NAME_SIZE]; + sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, nodeId); + replorigin_session_origin = replorigin_by_name(slot_name, false); + replorigin_session_setup(replorigin_session_origin); +} + static void process_remote_commit(StringInfo in) { uint8 flags; uint8 nodeId; const char *gid = NULL; - char slot_name[MULTIMASTER_MAX_SLOT_NAME_SIZE]; /* read flags */ flags = pq_getmsgbyte(in); @@ -481,10 +489,6 @@ process_remote_commit(StringInfo in) pq_getmsgint64(in); /* end_lsn */ replorigin_session_origin_timestamp = pq_getmsgint64(in); /* commit_time */ - sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, nodeId); - replorigin_session_origin = replorigin_by_name(slot_name, false); - replorigin_session_setup(replorigin_session_origin); - switch(PGLOGICAL_XACT_EVENT(flags)) { case PGLOGICAL_COMMIT: @@ -492,6 +496,7 @@ process_remote_commit(StringInfo in) MTM_TRACE("%d: PGLOGICAL_COMMIT commit\n", MyProcPid); if (IsTransactionState()) { Assert(TransactionIdIsValid(MtmGetCurrentTransactionId())); + MtmSetCurrentSession(nodeId); CommitTransactionCommand(); } break; @@ -505,6 +510,7 @@ process_remote_commit(StringInfo in) BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); + MtmSetCurrentSession(nodeId); /* PREPARE itself */ MtmSetCurrentTransactionGID(gid); PrepareTransactionBlock(gid); @@ -517,6 +523,7 @@ process_remote_commit(StringInfo in) gid = pq_getmsgstring(in); MTM_TRACE("%d: PGLOGICAL_COMMIT_PREPARED commit: csn=%ld, gid=%s\n", MyProcPid, csn, gid); StartTransactionCommand(); + MtmSetCurrentSession(nodeId); MtmSetCurrentTransactionGID(gid); FinishPreparedTransaction(gid, true); CommitTransactionCommand(); From b3f24e75e4deffd23627977a635bfdc24f9939b4 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 19 Mar 2016 22:41:40 +0300 Subject: [PATCH 0302/1139] Fix memory leak in MMTS --- decoder_raw.c | 12 +++++----- multimaster.c | 52 ++++++++++++++++++++++++++++++++++---------- multimaster.h | 4 +++- pglogical_apply.c | 44 ++++++++++++++++++++++++++----------- pglogical_proto.c | 3 +++ pglogical_receiver.c | 18 +++++++-------- 6 files changed, 92 insertions(+), 41 deletions(-) diff --git a/decoder_raw.c b/decoder_raw.c index b77848ba37..2cd1db5705 100644 --- a/decoder_raw.c +++ b/decoder_raw.c @@ -108,11 +108,11 @@ decoder_raw_begin_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn) Assert(lastXid != txn->xid); lastXid = txn->xid; if (MMIsLocalTransaction(txn->xid)) { - MTM_INFO("Skip local transaction %u\n", txn->xid); + MTM_TRACE("Skip local transaction %u\n", txn->xid); data->isLocal = true; } else { OutputPluginPrepareWrite(ctx, true); - MTM_INFO("Send transaction %u to replica\n", txn->xid); + MTM_TRACE("Send transaction %u to replica\n", txn->xid); appendStringInfo(ctx->out, "BEGIN %u;", txn->xid); OutputPluginWrite(ctx, true); data->isLocal = false; @@ -126,12 +126,12 @@ decoder_raw_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, { DecoderRawData *data = ctx->output_plugin_private; if (!data->isLocal) { - MTM_INFO("Send commit of transaction %u to replica\n", txn->xid); + MTM_TRACE("Send commit of transaction %u to replica\n", txn->xid); OutputPluginPrepareWrite(ctx, true); appendStringInfoString(ctx->out, "COMMIT;"); OutputPluginWrite(ctx, true); } else { - MTM_INFO("Skip commit of transaction %u\n", txn->xid); + MTM_TRACE("Skip commit of transaction %u\n", txn->xid); } } @@ -483,10 +483,10 @@ decoder_raw_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, data = ctx->output_plugin_private; if (data->isLocal) { - MTM_INFO("Skip action %d in transaction %u\n", change->action, txn->xid); + MTM_TRACE("Skip action %d in transaction %u\n", change->action, txn->xid); return; } - MTM_INFO("Send action %d in transaction %u to replica\n", change->action, txn->xid); + MTM_TRACE("Send action %d in transaction %u to replica\n", change->action, txn->xid); /* Avoid leaking memory by using and resetting our own context */ old = MemoryContextSwitchTo(data->context); diff --git a/multimaster.c b/multimaster.c index 3c5873fe87..902d615212 100644 --- a/multimaster.c +++ b/multimaster.c @@ -527,6 +527,9 @@ MtmResetTransaction(MtmCurrentTrans* x) x->xid = InvalidTransactionId; x->gtid.xid = InvalidTransactionId; x->isDistributed = false; + x->isPrepared = false; + x->isPrepared = false; + x->status = TRANSACTION_STATUS_UNKNOWN; } static void @@ -625,16 +628,15 @@ static void MtmPostPrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; - MtmTransMap* tm; MtmLock(LW_EXCLUSIVE); ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); - tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_ENTER, NULL); - Assert(x->gid[0]); - tm->state = ts; if (!MtmIsCoordinator(ts)) { + MtmTransMap* tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_ENTER, NULL); + Assert(x->gid[0]); + tm->state = ts; MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ MtmUnlock(); MtmResetTransaction(x); @@ -658,13 +660,15 @@ MtmAbortPreparedTransaction(MtmCurrentTrans* x) { MtmTransMap* tm; - MtmLock(LW_EXCLUSIVE); - tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_REMOVE, NULL); - Assert(tm != NULL); - tm->state->status = TRANSACTION_STATUS_ABORTED; - MtmAdjustSubtransactions(tm->state); - MtmUnlock(); - MtmResetTransaction(x); + if (x->status != TRANSACTION_STATUS_ABORTED) { + MtmLock(LW_EXCLUSIVE); + tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_REMOVE, NULL); + Assert(tm != NULL); + tm->state->status = TRANSACTION_STATUS_ABORTED; + MtmAdjustSubtransactions(tm->state); + MtmUnlock(); + x->status = TRANSACTION_STATUS_ABORTED; + } } static void @@ -672,7 +676,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) { MTM_TRACE("%d: End transaction %d, prepared=%d, replicated=%d, distributed=%d, gid=%s -> %s\n", MyProcPid, x->xid, x->isPrepared, x->isReplicated, x->isDistributed, x->gid, commit ? "commit" : "abort"); - if (x->isDistributed && (x->isPrepared || x->isReplicated)) { + if (x->status != TRANSACTION_STATUS_ABORTED && x->isDistributed && (x->isPrepared || x->isReplicated)) { MtmTransState* ts = NULL; MtmLock(LW_EXCLUSIVE); if (x->isPrepared) { @@ -690,6 +694,10 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) if (commit) { Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); ts->status = TRANSACTION_STATUS_COMMITTED; + if (x->csn > ts->csn) { + ts->csn = x->csn; + MtmSyncClock(ts->csn); + } } else { ts->status = TRANSACTION_STATUS_ABORTED; } @@ -799,6 +807,26 @@ XidStatus MtmGetGlobalTransactionStatus(char const* gid) return status; } +void MtmSetCurrentTransactionCSN(csn_t csn) +{ + MTM_TRACE("Set current transaction CSN %ld\n", csn); + dtmTx.csn = csn; + dtmTx.isDistributed = true; + dtmTx.isReplicated = true; +} + + +csn_t MtmGetTransactionCSN(TransactionId xid) +{ + MtmTransState* ts; + csn_t csn; + MtmLock(LW_SHARED); + ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); + Assert(ts != NULL); + csn = ts->csn; + MtmUnlock(); + return csn; +} /* * ------------------------------------------- diff --git a/multimaster.h b/multimaster.h index 6d17fff38f..b45dcb468c 100644 --- a/multimaster.h +++ b/multimaster.h @@ -10,8 +10,8 @@ #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) */ +#define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) -#define MTM_TUPLE_TRACE(fmt, ...) /* */ #define MULTIMASTER_NAME "multimaster" @@ -162,6 +162,8 @@ extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern void MtmSetCurrentTransactionGID(char const* gid); +extern csn_t MtmGetTransactionCSN(TransactionId xid); +extern void MtmSetCurrentTransactionCSN(csn_t csn); extern TransactionId MtmGetCurrentTransactionId(void); extern XidStatus MtmGetCurrentTransactionStatus(void); extern XidStatus MtmGetGlobalTransactionStatus(char const* gid); diff --git a/pglogical_apply.c b/pglogical_apply.c index 03a9e50787..24206bf2e1 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -465,20 +465,37 @@ read_rel(StringInfo s, LOCKMODE mode) } static void -MtmSetCurrentSession(int nodeId) +MtmBeginSession(int nodeId) { +#if 0 char slot_name[MULTIMASTER_MAX_SLOT_NAME_SIZE]; sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, nodeId); + Assert(replorigin_session_origin == InvalidRepOriginId); replorigin_session_origin = replorigin_by_name(slot_name, false); + MTM_INFO("%d: Begin setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); replorigin_session_setup(replorigin_session_origin); + MTM_INFO("%d: End setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); +#endif +} + +static void +MtmEndSession(void) +{ + if (replorigin_session_origin != InvalidRepOriginId) { + MTM_INFO("%d: Begin reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); + replorigin_session_origin = InvalidRepOriginId; + replorigin_session_reset(); + MTM_INFO("%d: End reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); + } } static void process_remote_commit(StringInfo in) { - uint8 flags; - uint8 nodeId; - const char *gid = NULL; + uint8 flags; + uint8 nodeId; + csn_t csn; + const char *gid = NULL; /* read flags */ flags = pq_getmsgbyte(in); @@ -489,6 +506,8 @@ process_remote_commit(StringInfo in) pq_getmsgint64(in); /* end_lsn */ replorigin_session_origin_timestamp = pq_getmsgint64(in); /* commit_time */ + Assert(replorigin_session_origin == InvalidRepOriginId); + switch(PGLOGICAL_XACT_EVENT(flags)) { case PGLOGICAL_COMMIT: @@ -496,7 +515,7 @@ process_remote_commit(StringInfo in) MTM_TRACE("%d: PGLOGICAL_COMMIT commit\n", MyProcPid); if (IsTransactionState()) { Assert(TransactionIdIsValid(MtmGetCurrentTransactionId())); - MtmSetCurrentSession(nodeId); + MtmBeginSession(nodeId); CommitTransactionCommand(); } break; @@ -510,7 +529,7 @@ process_remote_commit(StringInfo in) BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); - MtmSetCurrentSession(nodeId); + MtmBeginSession(nodeId); /* PREPARE itself */ MtmSetCurrentTransactionGID(gid); PrepareTransactionBlock(gid); @@ -520,10 +539,12 @@ process_remote_commit(StringInfo in) case PGLOGICAL_COMMIT_PREPARED: { Assert(!TransactionIdIsValid(MtmGetCurrentTransactionId())); + csn = pq_getmsgint64(in); gid = pq_getmsgstring(in); MTM_TRACE("%d: PGLOGICAL_COMMIT_PREPARED commit: csn=%ld, gid=%s\n", MyProcPid, csn, gid); StartTransactionCommand(); - MtmSetCurrentSession(nodeId); + MtmBeginSession(nodeId); + MtmSetCurrentTransactionCSN(csn); MtmSetCurrentTransactionGID(gid); FinishPreparedTransaction(gid, true); CommitTransactionCommand(); @@ -545,8 +566,7 @@ process_remote_commit(StringInfo in) default: Assert(false); } - replorigin_session_reset(); - replorigin_session_origin = InvalidRepOriginId; + MtmEndSession(); } static void @@ -859,10 +879,10 @@ void MtmExecutor(int id, void* work, size_t size) { StringInfoData s; Relation rel = NULL; - initStringInfo(&s); s.data = work; s.len = size; s.maxlen = -1; + s.cursor = 0; if (ApplyContext == NULL) { ApplyContext = AllocSetContextCreate(TopMemoryContext, @@ -910,12 +930,10 @@ void MtmExecutor(int id, void* work, size_t size) } PG_CATCH(); { - if (replorigin_session_origin != InvalidRepOriginId) { - replorigin_session_reset(); - } EmitErrorReport(); FlushErrorState(); MTM_TRACE("%d: REMOTE begin abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); + MtmEndSession(); AbortCurrentTransaction(); MTM_TRACE("%d: REMOTE end abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); } diff --git a/pglogical_proto.c b/pglogical_proto.c index 3719b5343f..51a1605deb 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -169,6 +169,9 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, pq_sendint64(out, txn->end_lsn); pq_sendint64(out, txn->commit_time); + if (flags == PGLOGICAL_COMMIT_PREPARED) { + pq_sendint64(out, MtmGetTransactionCSN(txn->xid)); + } if (flags != PGLOGICAL_COMMIT) { pq_sendstring(out, txn->gid); } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index f217673438..4cb46f1d03 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -214,6 +214,8 @@ pglogical_receiver_main(Datum main_arg) XLogRecPtr originStartPos = 0; RepOriginId originId; char* originName; + /* Buffer for COPY data */ + char *copybuf = NULL; /* Register functions for SIGTERM/SIGHUP management */ pqsignal(SIGHUP, receiver_raw_sighup); @@ -314,8 +316,6 @@ pglogical_receiver_main(Datum main_arg) while (!got_sigterm) { int rc, hdr_len; - /* Buffer for COPY data */ - char *copybuf = NULL; /* Wait necessary amount of time */ rc = WaitLatch(&MyProc->procLatch, WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, @@ -347,13 +347,6 @@ pglogical_receiver_main(Datum main_arg) } - /* Some cleanup */ - if (copybuf != NULL) - { - PQfreemem(copybuf); - copybuf = NULL; - } - /* * Receive data. */ @@ -362,6 +355,13 @@ pglogical_receiver_main(Datum main_arg) XLogRecPtr walEnd; char* stmt; + /* Some cleanup */ + if (copybuf != NULL) + { + PQfreemem(copybuf); + copybuf = NULL; + } + rc = PQgetCopyData(conn, ©buf, 1); if (rc <= 0) { break; From 5aafae30beef5e538dcfd6f1537d62f9dcb5207a Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 20 Mar 2016 00:17:28 +0300 Subject: [PATCH 0303/1139] origin patch --- multimaster.c | 31 ++++++++++++++++++++----------- multimaster.h | 2 ++ pglogical_apply.c | 28 +++++++++++++++------------- 3 files changed, 37 insertions(+), 24 deletions(-) diff --git a/multimaster.c b/multimaster.c index 902d615212..8c27cd9a36 100644 --- a/multimaster.c +++ b/multimaster.c @@ -80,8 +80,7 @@ typedef struct { typedef enum { - MTM_STATE_LOCK_ID, - N_LOCKS + MTM_STATE_LOCK_ID } MtmLockIds; #define MTM_SHMEM_SIZE (64*1024*1024) @@ -208,6 +207,17 @@ void MtmUnlock(void) #endif } +void MtmLockNode(int nodeId) +{ + Assert(nodeId > 0 && nodeId <= MtmNodes); + LWLockAcquire((LWLockId)&dtm->locks[nodeId], LW_EXCLUSIVE); +} + +void MtmUnlockNode(int nodeId) +{ + Assert(nodeId > 0 && nodeId <= MtmNodes); + LWLockRelease((LWLockId)&dtm->locks[nodeId]); +} /* * ------------------------------------------- @@ -1370,15 +1380,6 @@ _PG_init(void) NULL ); - - /* - * Request additional shared resources. (These are no-ops if we're not in - * the postmaster process.) We'll allocate or attach to the shared - * resources in mtm_shmem_startup(). - */ - RequestAddinShmemSpace(MTM_SHMEM_SIZE + MtmQueueSize); - RequestNamedLWLockTranche(MULTIMASTER_NAME, N_LOCKS); - MtmNodes = MtmStartReceivers(MtmConnStrs, MtmNodeId); if (MtmNodes < 2) { elog(ERROR, "Multimaster should have at least two nodes"); @@ -1387,6 +1388,14 @@ _PG_init(void) elog(ERROR, "Multimaster with mor than %d nodes is not currently supported", MAX_NODES); } + /* + * Request additional shared resources. (These are no-ops if we're not in + * the postmaster process.) We'll allocate or attach to the shared + * resources in mtm_shmem_startup(). + */ + RequestAddinShmemSpace(MTM_SHMEM_SIZE + MtmQueueSize); + RequestNamedLWLockTranche(MULTIMASTER_NAME, 1 + MtmNodes); + BgwPoolStart(MtmWorkers, MtmPoolConstructor); MtmArbiterInitialize(); diff --git a/multimaster.h b/multimaster.h index b45dcb468c..71415b9ee3 100644 --- a/multimaster.h +++ b/multimaster.h @@ -154,6 +154,8 @@ extern void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd); extern void MtmAdjustSubtransactions(MtmTransState* ts); extern void MtmLock(LWLockMode mode); extern void MtmUnlock(void); +extern void MtmLockNode(int nodeId); +extern void MtmUnlockNode(int nodeId); extern void MtmDropNode(int nodeId, bool dropSlot); extern void MtmRecoverNode(int nodeId); extern void MtmOnNodeDisconnect(int nodeId); diff --git a/pglogical_apply.c b/pglogical_apply.c index 24206bf2e1..241d5ef5fd 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -73,6 +73,8 @@ static void process_remote_insert(StringInfo s, Relation rel); static void process_remote_update(StringInfo s, Relation rel); static void process_remote_delete(StringInfo s, Relation rel); +static int MtmReplicationNode; + /* * Search the index 'idxrel' for a tuple identified by 'skey' in 'rel'. * @@ -465,27 +467,27 @@ read_rel(StringInfo s, LOCKMODE mode) } static void -MtmBeginSession(int nodeId) +MtmBeginSession(void) { -#if 0 char slot_name[MULTIMASTER_MAX_SLOT_NAME_SIZE]; - sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, nodeId); + MtmLockNode(MtmReplicationNode); + sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, MtmReplicationNode); Assert(replorigin_session_origin == InvalidRepOriginId); replorigin_session_origin = replorigin_by_name(slot_name, false); - MTM_INFO("%d: Begin setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); + MTM_TRACE("%d: Begin setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); replorigin_session_setup(replorigin_session_origin); - MTM_INFO("%d: End setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); -#endif + MTM_TRACE("%d: End setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); } static void MtmEndSession(void) { if (replorigin_session_origin != InvalidRepOriginId) { - MTM_INFO("%d: Begin reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); + MTM_TRACE("%d: Begin reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); replorigin_session_origin = InvalidRepOriginId; replorigin_session_reset(); - MTM_INFO("%d: End reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); + MtmUnlockNode(MtmReplicationNode); + MTM_TRACE("%d: End reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); } } @@ -493,13 +495,12 @@ static void process_remote_commit(StringInfo in) { uint8 flags; - uint8 nodeId; csn_t csn; const char *gid = NULL; /* read flags */ flags = pq_getmsgbyte(in); - nodeId = pq_getmsgbyte(in); + MtmReplicationNode = pq_getmsgbyte(in); /* read fields */ replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ @@ -515,7 +516,7 @@ process_remote_commit(StringInfo in) MTM_TRACE("%d: PGLOGICAL_COMMIT commit\n", MyProcPid); if (IsTransactionState()) { Assert(TransactionIdIsValid(MtmGetCurrentTransactionId())); - MtmBeginSession(nodeId); + MtmBeginSession(); CommitTransactionCommand(); } break; @@ -529,7 +530,8 @@ process_remote_commit(StringInfo in) BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); - MtmBeginSession(nodeId); + + MtmBeginSession(); /* PREPARE itself */ MtmSetCurrentTransactionGID(gid); PrepareTransactionBlock(gid); @@ -543,7 +545,7 @@ process_remote_commit(StringInfo in) gid = pq_getmsgstring(in); MTM_TRACE("%d: PGLOGICAL_COMMIT_PREPARED commit: csn=%ld, gid=%s\n", MyProcPid, csn, gid); StartTransactionCommand(); - MtmBeginSession(nodeId); + MtmBeginSession(); MtmSetCurrentTransactionCSN(csn); MtmSetCurrentTransactionGID(gid); FinishPreparedTransaction(gid, true); From 055c6a6c24b92699fc2833aa9ee14c3cdade2179 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 21 Mar 2016 20:35:43 +0300 Subject: [PATCH 0304/1139] Remove vacuum delay --- arbiter.c | 157 +++++++------- multimaster.c | 472 +++++++++++++++++++++++-------------------- multimaster.h | 21 +- pglogical_receiver.c | 48 ++--- 4 files changed, 365 insertions(+), 333 deletions(-) diff --git a/arbiter.c b/arbiter.c index e9b20df771..eda5114bab 100644 --- a/arbiter.c +++ b/arbiter.c @@ -82,10 +82,17 @@ typedef struct int node; /* Sender node ID */ TransactionId dxid; /* Transaction ID at destination node */ TransactionId sxid; /* Transaction ID at sender node */ - csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ - nodemask_t disabledNodeMask; /* bitmask of disabled nodes at the sender of message */ + csn_t csn; /* Local CSN in case of sending data from replica to master, global CSN master->replica */ + nodemask_t disabledNodeMask; /* Bitmask of disabled nodes at the sender of message */ + csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ } MtmArbiterMessage; +typedef struct +{ + MtmArbiterMessage hdr; + char connStr[MULTIMASTER_MAX_CONN_STR_SIZE]; +} MtmHandshakeMessage; + typedef struct { int used; @@ -93,9 +100,7 @@ typedef struct } MtmBuffer; static int* sockets; -static char** hosts; static int gateway; -static MtmState* ds; static void MtmTransSender(Datum arg); static void MtmTransReceiver(Datum arg); @@ -266,39 +271,41 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) continue; } else { int optval = 1; - MtmArbiterMessage msg; + MtmHandshakeMessage req; + MtmArbiterMessage resp; setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)); setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (char const*)&optval, sizeof(optval)); - msg.code = MSG_HANDSHAKE; - msg.node = MtmNodeId; - msg.dxid = HANDSHAKE_MAGIC; - msg.sxid = ShmemVariableCache->nextXid; - msg.csn = MtmGetCurrentTime(); - msg.disabledNodeMask = ds->disabledNodeMask; - if (!MtmWriteSocket(sd, &msg, sizeof msg)) { + req.hdr.code = MSG_HANDSHAKE; + req.hdr.node = MtmNodeId; + req.hdr.dxid = HANDSHAKE_MAGIC; + req.hdr.sxid = ShmemVariableCache->nextXid; + req.hdr.csn = MtmGetCurrentTime(); + req.hdr.disabledNodeMask = Mtm->disabledNodeMask; + strcpy(req.connStr, Mtm->nodes[MtmNodeId-1].connStr); + if (!MtmWriteSocket(sd, &req, sizeof req)) { elog(WARNING, "Arbiter failed to send handshake message to %s:%d: %d", host, port, errno); close(sd); goto Retry; } - if (MtmReadSocket(sd, &msg, sizeof msg) != sizeof(msg)) { + if (MtmReadSocket(sd, &resp, sizeof resp) != sizeof(resp)) { elog(WARNING, "Arbiter failed to receive response for handshake message from %s:%d: errno=%d", host, port, errno); close(sd); goto Retry; } - if (msg.code != MSG_STATUS || msg.dxid != HANDSHAKE_MAGIC) { - elog(WARNING, "Arbiter get unexpected response %d for handshake message from %s:%d", msg.code, host, port); + if (resp.code != MSG_STATUS || resp.dxid != HANDSHAKE_MAGIC) { + elog(WARNING, "Arbiter get unexpected response %d for handshake message from %s:%d", resp.code, host, port); close(sd); goto Retry; } /* Some node considered that I am dead, so switch to recovery mode */ - if (BIT_CHECK(msg.disabledNodeMask, MtmNodeId-1)) { - elog(WARNING, "Node %d think that I am dead", msg.node); + if (BIT_CHECK(resp.disabledNodeMask, MtmNodeId-1)) { + elog(WARNING, "Node %d think that I am dead", resp.node); MtmSwitchClusterMode(MTM_RECOVERY); } /* Combine disable masks from all node. Is it actually correct or we should better check availability of nodes ourselves? */ - ds->disabledNodeMask |= msg.disabledNodeMask; + Mtm->disabledNodeMask |= resp.disabledNodeMask; return sd; } } @@ -309,28 +316,12 @@ static void MtmOpenConnections() { int nNodes = MtmNodes; int i; - char* connStr = pstrdup(MtmConnStrs); sockets = (int*)palloc(sizeof(int)*nNodes); - hosts = (char**)palloc(sizeof(char*)*nNodes); for (i = 0; i < nNodes; i++) { - char* host = strstr(connStr, "host="); - char* end; - if (host == NULL) { - elog(ERROR, "Invalid connection string: '%s'", MtmConnStrs); - } - host += 5; - for (end = host; *end != ' ' && *end != ',' && *end != '\0'; end++); - if (*end != '\0') { - *end = '\0'; - connStr = end + 1; - } else { - connStr = end; - } - hosts[i] = host; if (i+1 != MtmNodeId) { - sockets[i] = MtmConnectSocket(host, MtmArbiterPort + i + 1, MtmConnectAttempts); + sockets[i] = MtmConnectSocket(Mtm->nodes[i].hostName, MtmArbiterPort + i + 1, MtmConnectAttempts); if (sockets[i] < 0) { MtmOnNodeDisconnect(i+1); } @@ -338,10 +329,10 @@ static void MtmOpenConnections() sockets[i] = -1; } } - if (ds->nNodes < MtmNodes/2+1) { /* no quorum */ - elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", ds->nNodes, MtmNodes); - ds->status = MTM_OFFLINE; - } else if (ds->status == MTM_INITIALIZATION) { + if (Mtm->nNodes < MtmNodes/2+1) { /* no quorum */ + elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", Mtm->nNodes, MtmNodes); + Mtm->status = MTM_OFFLINE; + } else if (Mtm->status == MTM_INITIALIZATION) { MtmSwitchClusterMode(MTM_CONNECTED); } } @@ -354,7 +345,7 @@ static bool MtmSendToNode(int node, void const* buf, int size) if (sockets[node] >= 0) { close(sockets[node]); } - sockets[node] = MtmConnectSocket(hosts[node], MtmArbiterPort + node + 1, MtmReconnectAttempts); + sockets[node] = MtmConnectSocket(Mtm->nodes[node].hostName, MtmArbiterPort + node + 1, MtmReconnectAttempts); if (sockets[node] < 0) { MtmOnNodeDisconnect(node+1); return false; @@ -379,29 +370,31 @@ static void MtmAcceptOneConnection() if (fd < 0) { elog(WARNING, "Arbiter failed to accept socket: %d", errno); } else { - MtmArbiterMessage msg; - int rc = MtmReadSocket(fd, &msg, sizeof msg); - if (rc < sizeof(msg)) { + MtmHandshakeMessage req; + MtmArbiterMessage resp; + int rc = MtmReadSocket(fd, &req, sizeof req); + if (rc < sizeof(req)) { elog(WARNING, "Arbiter failed to handshake socket: %d, errno=%d", rc, errno); - } else if (msg.code != MSG_HANDSHAKE && msg.dxid != HANDSHAKE_MAGIC) { - elog(WARNING, "Arbiter get unexpected handshake message %d", msg.code); + } else if (req.hdr.code != MSG_HANDSHAKE && req.hdr.dxid != HANDSHAKE_MAGIC) { + elog(WARNING, "Arbiter get unexpected handshake message %d", req.hdr.code); close(fd); } else{ - Assert(msg.node > 0 && msg.node <= MtmNodes && msg.node != MtmNodeId); - msg.code = MSG_STATUS; - msg.disabledNodeMask = ds->disabledNodeMask; - msg.dxid = HANDSHAKE_MAGIC; - msg.sxid = ShmemVariableCache->nextXid; - msg.csn = MtmGetCurrentTime(); - if (!MtmWriteSocket(fd, &msg, sizeof msg)) { - elog(WARNING, "Arbiter failed to write response for handshake message to node %d", msg.node); + Assert(req.hdr.node > 0 && req.hdr.node <= MtmNodes && req.hdr.node != MtmNodeId); + resp.code = MSG_STATUS; + resp.disabledNodeMask = Mtm->disabledNodeMask; + resp.dxid = HANDSHAKE_MAGIC; + resp.sxid = ShmemVariableCache->nextXid; + resp.csn = MtmGetCurrentTime(); + MtmUpdateNodeConnStr(req.hdr.node, req.connStr); + if (!MtmWriteSocket(fd, &resp, sizeof resp)) { + elog(WARNING, "Arbiter failed to write response for handshake message to node %d", resp.node); close(fd); } else { - elog(NOTICE, "Arbiter established connection with node %d", msg.node); - BIT_CLEAR(ds->connectivityMask, msg.node-1); - MtmRegisterSocket(fd, msg.node-1); - sockets[msg.node-1] = fd; - MtmOnNodeConnect(msg.node); + elog(NOTICE, "Arbiter established connection with node %d", req.hdr.node); + BIT_CLEAR(Mtm->connectivityMask, req.hdr.node-1); + MtmRegisterSocket(fd, req.hdr.node-1); + sockets[req.hdr.node-1] = fd; + MtmOnNodeConnect(req.hdr.node); } } } @@ -415,7 +408,9 @@ static void MtmAcceptIncomingConnections() int i; sockets = (int*)palloc(sizeof(int)*MtmNodes); - + for (i = 0; i < MtmNodes; i++) { + sockets[i] = -1; + } sock_inet.sin_family = AF_INET; sock_inet.sin_addr.s_addr = htonl(INADDR_ANY); sock_inet.sin_port = htons(MtmArbiterPort + MtmNodeId); @@ -461,7 +456,8 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt buf->data[buf->used].sxid = ts->xid; buf->data[buf->used].csn = ts->csn; buf->data[buf->used].node = MtmNodeId; - buf->data[buf->used].disabledNodeMask = ds->disabledNodeMask; + buf->data[buf->used].disabledNodeMask = Mtm->disabledNodeMask; + buf->data[buf->used].oldestSnapshot = Mtm->nodes[MtmNodeId-1].oldestSnapshot; buf->used += 1; } @@ -477,7 +473,7 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) n += 1; } } - Assert(n == ds->nNodes); + Assert(n == Mtm->nNodes); } @@ -487,8 +483,6 @@ static void MtmTransSender(Datum arg) int i; MtmBuffer* txBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); - ds = MtmGetState(); - MtmOpenConnections(); for (i = 0; i < nNodes; i++) { @@ -497,7 +491,7 @@ static void MtmTransSender(Datum arg) while (true) { MtmTransState* ts; - PGSemaphoreLock(&ds->votingSemaphore); + PGSemaphoreLock(&Mtm->votingSemaphore); CHECK_FOR_INTERRUPTS(); /* @@ -506,14 +500,14 @@ static void MtmTransSender(Datum arg) */ MtmLock(LW_SHARED); - for (ts = ds->votingTransactions; ts != NULL; ts = ts->nextVoting) { + for (ts = Mtm->votingTransactions; ts != NULL; ts = ts->nextVoting) { if (MtmIsCoordinator(ts)) { MtmBroadcastMessage(txBuffer, ts); } else { MtmAppendBuffer(txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); } } - ds->votingTransactions = NULL; + Mtm->votingTransactions = NULL; MtmUnlock(); @@ -573,8 +567,6 @@ static void MtmTransReceiver(Datum arg) max_fd = 0; #endif - ds = MtmGetState(); - MtmAcceptIncomingConnections(); for (i = 0; i < nNodes; i++) { @@ -613,7 +605,7 @@ static void MtmTransReceiver(Datum arg) elog(ERROR, "Arbiter failed to select sockets: %d", errno); } for (i = 0; i < nNodes; i++) { - if (FD_ISSET(sockets[i], &events)) + if (sockets[i] >= 0 && FD_ISSET(sockets[i], &events)) #endif { if (i+1 == MtmNodeId) { @@ -637,13 +629,24 @@ static void MtmTransReceiver(Datum arg) MtmTransState* ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); Assert(msg->node > 0 && msg->node <= nNodes && msg->node != MtmNodeId); + + Mtm->nodes[msg->node-1].oldestSnapshot = msg->oldestSnapshot; + if (MtmIsCoordinator(ts)) { switch (msg->code) { case MSG_READY: - Assert(ts->nVotes < ds->nNodes); - ds->nodeTransDelay[msg->node-1] += MtmGetCurrentTime() - ts->csn; + Assert(ts->nVotes < Mtm->nNodes); + Mtm->nodes[msg->node-1].transDelay += MtmGetCurrentTime() - ts->csn; ts->xids[msg->node-1] = msg->sxid; - if (++ts->nVotes == ds->nNodes) { + + if ((~msg->disabledNodeMask & Mtm->disabledNodeMask) != 0) { + /* Coordinator's disabled mask is wider than of this node: so reject such transaction to avoid + commit on smaller subset of nodes */ + ts->status = TRANSACTION_STATUS_ABORTED; + MtmAdjustSubtransactions(ts); + } + + if (++ts->nVotes == Mtm->nNodes) { /* All nodes are finished their transactions */ if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { ts->nVotes = 1; /* I voted myself */ @@ -655,24 +658,24 @@ static void MtmTransReceiver(Datum arg) } break; case MSG_ABORTED: - Assert(ts->nVotes < ds->nNodes); + Assert(ts->nVotes < Mtm->nNodes); if (ts->status != TRANSACTION_STATUS_ABORTED) { Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); } - if (++ts->nVotes == ds->nNodes) { + if (++ts->nVotes == Mtm->nNodes) { MtmWakeUpBackend(ts); } break; case MSG_PREPARED: Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < ds->nNodes); + Assert(ts->nVotes < Mtm->nNodes); if (msg->csn > ts->csn) { ts->csn = msg->csn; MtmSyncClock(ts->csn); } - if (++ts->nVotes == ds->nNodes) { + if (++ts->nVotes == Mtm->nNodes) { ts->csn = MtmAssignCSN(); ts->status = TRANSACTION_STATUS_UNKNOWN; MtmWakeUpBackend(ts); @@ -703,7 +706,7 @@ static void MtmTransReceiver(Datum arg) } } } - if (n == 0 && ds->disabledNodeMask != 0) { + if (n == 0 && Mtm->disabledNodeMask != 0) { /* If timeout is expired and there are didabled nodes, then recheck cluster's state */ MtmRefreshClusterStatus(false); } diff --git a/multimaster.c b/multimaster.c index 8c27cd9a36..a4f30d6490 100644 --- a/multimaster.c +++ b/multimaster.c @@ -127,11 +127,12 @@ static BgwPool* MtmPoolConstructor(void); static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); +MtmState* Mtm; + HTAB* MtmXid2State; static HTAB* MtmGid2State; -static MtmCurrentTrans dtmTx; -static MtmState* dtm; +static MtmCurrentTrans MtmTx; static TransactionManager MtmTM = { PgTransactionIdGetStatus, @@ -158,7 +159,6 @@ char const* const MtmNodeStatusMnem[] = bool MtmDoReplication; char* MtmDatabaseName; -char* MtmConnStrs; int MtmNodeId; int MtmArbiterPort; int MtmNodes; @@ -167,9 +167,9 @@ int MtmConnectTimeout; int MtmKeepaliveTimeout; int MtmReconnectAttempts; +static char* MtmConnStrs; static int MtmQueueSize; static int MtmWorkers; -static int MtmVacuumDelay; static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; @@ -185,38 +185,38 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, /* * ------------------------------------------- - * Synchronize access to DTM structures. + * Synchronize access to MTM structures. * Using LWLock seems to be more efficient (at our benchmarks) * ------------------------------------------- */ void MtmLock(LWLockMode mode) { #ifdef USE_SPINLOCK - SpinLockAcquire(&dtm->spinlock); + SpinLockAcquire(&Mtm->spinlock); #else - LWLockAcquire((LWLockId)&dtm->locks[MTM_STATE_LOCK_ID], mode); + LWLockAcquire((LWLockId)&Mtm->locks[MTM_STATE_LOCK_ID], mode); #endif } void MtmUnlock(void) { #ifdef USE_SPINLOCK - SpinLockRelease(&dtm->spinlock); + SpinLockRelease(&Mtm->spinlock); #else - LWLockRelease((LWLockId)&dtm->locks[MTM_STATE_LOCK_ID]); + LWLockRelease((LWLockId)&Mtm->locks[MTM_STATE_LOCK_ID]); #endif } void MtmLockNode(int nodeId) { Assert(nodeId > 0 && nodeId <= MtmNodes); - LWLockAcquire((LWLockId)&dtm->locks[nodeId], LW_EXCLUSIVE); + LWLockAcquire((LWLockId)&Mtm->locks[nodeId], LW_EXCLUSIVE); } void MtmUnlockNode(int nodeId) { Assert(nodeId > 0 && nodeId <= MtmNodes); - LWLockRelease((LWLockId)&dtm->locks[nodeId]); + LWLockRelease((LWLockId)&Mtm->locks[nodeId]); } /* @@ -230,7 +230,7 @@ timestamp_t MtmGetCurrentTime(void) { struct timeval tv; gettimeofday(&tv, NULL); - return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + dtm->timeShift; + return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + Mtm->timeShift; } void MtmSleep(timestamp_t interval) @@ -252,10 +252,10 @@ void MtmSleep(timestamp_t interval) csn_t MtmAssignCSN() { csn_t csn = MtmGetCurrentTime(); - if (csn <= dtm->csn) { - csn = ++dtm->csn; + if (csn <= Mtm->csn) { + csn = ++Mtm->csn; } else { - dtm->csn = csn; + Mtm->csn = csn; } return csn; } @@ -267,7 +267,7 @@ csn_t MtmSyncClock(csn_t global_csn) { csn_t local_csn; while ((local_csn = MtmAssignCSN()) < global_csn) { - dtm->timeShift += global_csn - local_csn; + Mtm->timeShift += global_csn - local_csn; } return local_csn; } @@ -340,15 +340,15 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) MtmTransState* ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); if (ts != NULL && ts->status != TRANSACTION_STATUS_IN_PROGRESS) { - if (ts->csn > dtmTx.snapshot) { + if (ts->csn > MtmTx.snapshot) { MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", - MyProcPid, xid, ts->csn, dtmTx.snapshot); + MyProcPid, xid, ts->csn, MtmTx.snapshot); MtmUnlock(); return true; } if (ts->status == TRANSACTION_STATUS_UNKNOWN) { - MTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", MyProcPid, xid, dtmTx.snapshot); + MTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", MyProcPid, xid, MtmTx.snapshot); MtmUnlock(); #if TRACE_SLEEP_TIME { @@ -380,14 +380,14 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld\n", - MyProcPid, xid, ts->csn, invisible ? "rollbacked" : "committed", dtmTx.snapshot); + MyProcPid, xid, ts->csn, invisible ? "rollbacked" : "committed", MtmTx.snapshot); MtmUnlock(); return invisible; } } else { - MTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", MyProcPid, xid, dtmTx.snapshot); + MTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", MyProcPid, xid, MtmTx.snapshot); break; } } @@ -399,9 +399,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) /* * There can be different oldest XIDs at different cluster node. - * Seince we do not have centralized aribiter, we have to rely in MtmVacuumDelay. - * This function takes XID which PostgreSQL consider to be the latest and try to find XID which - * is older than it more than MtmVacuumDelay. + * We collest oldest CSNs from all nodes and choose minimum from them. * If no such XID can be located, then return previously observed oldest XID */ static TransactionId @@ -412,9 +410,17 @@ MtmAdjustOldestXid(TransactionId xid) MtmLock(LW_EXCLUSIVE); ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - if (ts != NULL) { - timestamp_t cutoff_time = ts->csn - MtmVacuumDelay*USEC; - for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { + if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { + csn_t oldestSnapshot; + int i; + + Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot = ts->csn; + for (i = 0; i < MtmNodes; i++) { + if (Mtm->nodes[i].oldestSnapshot < oldestSnapshot) { + oldestSnapshot = Mtm->nodes[i].oldestSnapshot; + } + } + for (ts = Mtm->transListHead; ts != NULL && ts->csn < oldestSnapshot; prev = ts, ts = ts->next) { Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); if (prev != NULL) { /* Remove information about too old transactions */ @@ -423,10 +429,10 @@ MtmAdjustOldestXid(TransactionId xid) } } if (prev != NULL) { - dtm->transListHead = prev; - dtm->oldestXid = xid = prev->xid; + Mtm->transListHead = prev; + Mtm->oldestXid = xid = prev->xid; } else { - xid = dtm->oldestXid; + xid = Mtm->oldestXid; } MtmUnlock(); } @@ -444,16 +450,16 @@ static void MtmTransactionListAppend(MtmTransState* ts) { ts->next = NULL; ts->nSubxids = 0; - *dtm->transListTail = ts; - dtm->transListTail = &ts->next; + *Mtm->transListTail = ts; + Mtm->transListTail = &ts->next; } static void MtmTransactionListInsertAfter(MtmTransState* after, MtmTransState* ts) { ts->next = after->next; after->next = ts; - if (dtm->transListTail == &after->next) { - dtm->transListTail = &ts->next; + if (Mtm->transListTail == &after->next) { + Mtm->transListTail = &ts->next; } } @@ -499,22 +505,22 @@ MtmXactCallback(XactEvent event, void *arg) switch (event) { case XACT_EVENT_START: - MtmBeginTransaction(&dtmTx); + MtmBeginTransaction(&MtmTx); break; case XACT_EVENT_PRE_PREPARE: - MtmPrePrepareTransaction(&dtmTx); + MtmPrePrepareTransaction(&MtmTx); break; case XACT_EVENT_POST_PREPARE: - MtmPostPrepareTransaction(&dtmTx); + MtmPostPrepareTransaction(&MtmTx); break; case XACT_EVENT_ABORT_PREPARED: - MtmAbortPreparedTransaction(&dtmTx); + MtmAbortPreparedTransaction(&MtmTx); break; case XACT_EVENT_COMMIT: - MtmEndTransaction(&dtmTx, true); + MtmEndTransaction(&MtmTx, true); break; case XACT_EVENT_ABORT: - MtmEndTransaction(&dtmTx, false); + MtmEndTransaction(&MtmTx, false); break; default: break; @@ -551,11 +557,11 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->isReplicated = false; x->isDistributed = MtmIsUserTransaction(); x->isPrepared = false; - if (x->isDistributed && dtm->status != MTM_ONLINE) { + if (x->isDistributed && Mtm->status != MTM_ONLINE) { /* reject all user's transactions at offline cluster */ MtmUnlock(); - Assert(dtm->status == MTM_ONLINE); - elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[dtm->status]); + Assert(Mtm->status == MTM_ONLINE); + elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[Mtm->status]); } x->containsDML = false; x->snapshot = MtmAssignCSN(); @@ -586,9 +592,9 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) x->xid = GetCurrentTransactionId(); Assert(TransactionIdIsValid(x->xid)); - if (dtm->disabledNodeMask != 0) { + if (Mtm->disabledNodeMask != 0) { MtmRefreshClusterStatus(true); - if (dtm->status != MTM_ONLINE) { + if (Mtm->status != MTM_ONLINE) { elog(ERROR, "Abort current transaction because this cluster node is not online"); } } @@ -617,7 +623,7 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) x->isPrepared = true; x->csn = ts->csn; - dtm->transCount += 1; + Mtm->transCount += 1; if (TransactionIdIsValid(x->gtid.xid)) { Assert(x->gtid.node != MtmNodeId); @@ -742,62 +748,55 @@ void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd) { MtmTransState* votingList; - votingList = dtm->votingTransactions; + votingList = Mtm->votingTransactions; ts->nextVoting = votingList; ts->cmd = cmd; - dtm->votingTransactions = ts; + Mtm->votingTransactions = ts; if (votingList == NULL) { /* singal semaphore only once for the whole list */ - PGSemaphoreUnlock(&dtm->votingSemaphore); + PGSemaphoreUnlock(&Mtm->votingSemaphore); } } void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { - csn_t localSnapshot; - MtmLock(LW_EXCLUSIVE); - localSnapshot = MtmSyncClock(globalSnapshot); + MtmSyncClock(globalSnapshot); MtmUnlock(); - if (globalSnapshot < localSnapshot - MtmVacuumDelay * USEC) - { - elog(ERROR, "Too old snapshot: requested %ld, current %ld", globalSnapshot, localSnapshot); - } - if (!TransactionIdIsValid(gtid->xid)) { /* In case of recovery InvalidTransactionId is passed */ - Assert(dtm->status == MTM_RECOVERY); - } else if (dtm->status == MTM_RECOVERY) { + Assert(Mtm->status == MTM_RECOVERY); + } else if (Mtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ - dtm->recoverySlot = 0; + Mtm->recoverySlot = 0; MtmSwitchClusterMode(MTM_ONLINE); } - dtmTx.gtid = *gtid; - dtmTx.xid = GetCurrentTransactionId(); - dtmTx.snapshot = globalSnapshot; - dtmTx.isReplicated = true; - dtmTx.isDistributed = true; - dtmTx.containsDML = true; + MtmTx.gtid = *gtid; + MtmTx.xid = GetCurrentTransactionId(); + MtmTx.snapshot = globalSnapshot; + MtmTx.isReplicated = true; + MtmTx.isDistributed = true; + MtmTx.containsDML = true; } void MtmSetCurrentTransactionGID(char const* gid) { MTM_TRACE("Set current transaction GID %s\n", gid); - strcpy(dtmTx.gid, gid); - dtmTx.isDistributed = true; - dtmTx.isReplicated = true; + strcpy(MtmTx.gid, gid); + MtmTx.isDistributed = true; + MtmTx.isReplicated = true; } TransactionId MtmGetCurrentTransactionId(void) { - return dtmTx.xid; + return MtmTx.xid; } XidStatus MtmGetCurrentTransactionStatus(void) { - return dtmTx.status; + return MtmTx.status; } XidStatus MtmGetGlobalTransactionStatus(char const* gid) @@ -820,9 +819,9 @@ XidStatus MtmGetGlobalTransactionStatus(char const* gid) void MtmSetCurrentTransactionCSN(csn_t csn) { MTM_TRACE("Set current transaction CSN %ld\n", csn); - dtmTx.csn = csn; - dtmTx.isDistributed = true; - dtmTx.isReplicated = true; + MtmTx.csn = csn; + MtmTx.isDistributed = true; + MtmTx.isReplicated = true; } @@ -852,7 +851,7 @@ csn_t MtmGetTransactionCSN(TransactionId xid) static void MtmCheckSlots() { - if (MtmMaxRecoveryLag != 0 && dtm->disabledNodeMask != 0) + if (MtmMaxRecoveryLag != 0 && Mtm->disabledNodeMask != 0) { int i; for (i = 0; i < max_replication_slots; i++) { @@ -860,7 +859,7 @@ MtmCheckSlots() int nodeId; if (slot->in_use && sscanf(slot->data.name.data, MULTIMASTER_SLOT_PATTERN, &nodeId) == 1 - && BIT_CHECK(dtm->disabledNodeMask, nodeId-1) + && BIT_CHECK(Mtm->disabledNodeMask, nodeId-1) && slot->data.confirmed_flush + MtmMaxRecoveryLag < GetXLogInsertRecPtr()) { elog(WARNING, "Drop slot for node %d which lag %ld is larger than threshold %d", @@ -897,9 +896,9 @@ static int64 MtmGetSlotLag(int nodeId) */ bool MtmIsRecoveredNode(int nodeId) { - if (BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) { + if (BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ - if (!BIT_CHECK(dtm->nodeLockerMask, nodeId-1) + if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) && MyWalSnd->sentPtr + MtmMinRecoveryLag > GetXLogInsertRecPtr()) { /* @@ -909,9 +908,9 @@ bool MtmIsRecoveredNode(int nodeId) * Is there some better way to establish mapping between nodes ad WAL-seconder? */ MtmLock(LW_EXCLUSIVE); - BIT_SET(dtm->nodeLockerMask, nodeId-1); - BIT_SET(dtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); - dtm->nLockers += 1; + BIT_SET(Mtm->nodeLockerMask, nodeId-1); + BIT_SET(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); + Mtm->nLockers += 1; MtmUnlock(); } return true; @@ -921,7 +920,7 @@ bool MtmIsRecoveredNode(int nodeId) void MtmSwitchClusterMode(MtmNodeStatus mode) { - dtm->status = mode; + Mtm->status = mode; elog(WARNING, "Switch to %s mode", MtmNodeStatusMnem[mode]); /* ??? Something else to do here? */ } @@ -937,7 +936,7 @@ MtmCheckClusterLock() { while (true) { - nodemask_t mask = dtm->walSenderLockerMask; + nodemask_t mask = Mtm->walSenderLockerMask; if (mask != 0) { XLogRecPtr currLogPos = GetXLogInsertRecPtr(); int i; @@ -950,7 +949,7 @@ MtmCheckClusterLock() } else { /* recovered replica catched up with master */ elog(WARNING, "WAL-sender %d complete receovery", i); - BIT_CLEAR(dtm->walSenderLockerMask, i); + BIT_CLEAR(Mtm->walSenderLockerMask, i); } } } @@ -967,13 +966,13 @@ MtmCheckClusterLock() } else { /* All lockers are synchronized their logs */ /* Remove lock and mark them as receovered */ - elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", dtm->nLockers, dtm->nodeLockerMask); - Assert(dtm->walSenderLockerMask == 0); - Assert((dtm->nodeLockerMask & dtm->disabledNodeMask) == dtm->nodeLockerMask); - dtm->disabledNodeMask &= ~dtm->nodeLockerMask; - dtm->nNodes += dtm->nLockers; - dtm->nLockers = 0; - dtm->nodeLockerMask = 0; + elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", Mtm->nLockers, Mtm->nodeLockerMask); + Assert(Mtm->walSenderLockerMask == 0); + Assert((Mtm->nodeLockerMask & Mtm->disabledNodeMask) == Mtm->nodeLockerMask); + Mtm->disabledNodeMask &= ~Mtm->nodeLockerMask; + Mtm->nNodes += Mtm->nLockers; + Mtm->nLockers = 0; + Mtm->nodeLockerMask = 0; } } break; @@ -992,7 +991,7 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); matrix[i] = *(nodemask_t*)data; } else { - matrix[i] = dtm->connectivityMask; + matrix[i] = Mtm->connectivityMask; } } /* make matrix symetric: required for Bron–Kerbosch algorithm */ @@ -1019,29 +1018,29 @@ void MtmRefreshClusterStatus(bool nowait) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ - elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, dtm->disabledNodeMask); + elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, Mtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); - mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~dtm->disabledNodeMask; /* new disabled nodes mask */ + mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~Mtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { - dtm->nNodes -= 1; - BIT_SET(dtm->disabledNodeMask, i); + Mtm->nNodes -= 1; + BIT_SET(Mtm->disabledNodeMask, i); } } - mask = clique & dtm->disabledNodeMask; /* new enabled nodes mask */ + mask = clique & Mtm->disabledNodeMask; /* new enabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { - dtm->nNodes += 1; - BIT_CLEAR(dtm->disabledNodeMask, i); + Mtm->nNodes += 1; + BIT_CLEAR(Mtm->disabledNodeMask, i); } } MtmUnlock(); - if (BIT_CHECK(dtm->disabledNodeMask, MtmNodeId-1)) { - if (dtm->status == MTM_ONLINE) { + if (BIT_CHECK(Mtm->disabledNodeMask, MtmNodeId-1)) { + if (Mtm->status == MTM_ONLINE) { /* I was excluded from cluster:( */ MtmSwitchClusterMode(MTM_OFFLINE); } - } else if (dtm->status == MTM_OFFLINE) { + } else if (Mtm->status == MTM_OFFLINE) { /* Should we somehow restart logical receivers? */ MtmSwitchClusterMode(MTM_RECOVERY); } @@ -1052,8 +1051,8 @@ void MtmRefreshClusterStatus(bool nowait) void MtmOnNodeDisconnect(int nodeId) { - BIT_SET(dtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); + BIT_SET(Mtm->connectivityMask, nodeId-1); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ MtmSleep(MtmKeepaliveTimeout); @@ -1063,8 +1062,8 @@ void MtmOnNodeDisconnect(int nodeId) void MtmOnNodeConnect(int nodeId) { - BIT_CLEAR(dtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &dtm->connectivityMask, sizeof dtm->connectivityMask, false); + BIT_CLEAR(Mtm->connectivityMask, nodeId-1); + PaxosSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); } /* @@ -1127,37 +1126,41 @@ MtmCreateGidMap(void) static void MtmInitialize() { bool found; + int i; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); - dtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState), &found); + Mtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState) + sizeof(MtmNodeInfo)*(MtmNodes-1), &found); if (!found) { - dtm->status = MTM_INITIALIZATION; - dtm->recoverySlot = 0; - dtm->locks = GetNamedLWLockTranche(MULTIMASTER_NAME); - dtm->csn = MtmGetCurrentTime(); - dtm->oldestXid = FirstNormalTransactionId; - dtm->nNodes = MtmNodes; - dtm->disabledNodeMask = 0; - dtm->connectivityMask = 0; - dtm->pglogicalNodeMask = 0; - dtm->walSenderLockerMask = 0; - dtm->nodeLockerMask = 0; - dtm->nLockers = 0; - dtm->votingTransactions = NULL; - dtm->transListHead = NULL; - dtm->transListTail = &dtm->transListHead; - dtm->nReceivers = 0; - dtm->timeShift = 0; - dtm->transCount = 0; - memset(dtm->nodeTransDelay, 0, sizeof(dtm->nodeTransDelay)); - PGSemaphoreCreate(&dtm->votingSemaphore); - PGSemaphoreReset(&dtm->votingSemaphore); - SpinLockInit(&dtm->spinlock); - BgwPoolInit(&dtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); + Mtm->status = MTM_INITIALIZATION; + Mtm->recoverySlot = 0; + Mtm->locks = GetNamedLWLockTranche(MULTIMASTER_NAME); + Mtm->csn = MtmGetCurrentTime(); + Mtm->oldestXid = FirstNormalTransactionId; + Mtm->nNodes = MtmNodes; + Mtm->disabledNodeMask = 0; + Mtm->connectivityMask = 0; + Mtm->pglogicalNodeMask = 0; + Mtm->walSenderLockerMask = 0; + Mtm->nodeLockerMask = 0; + Mtm->nLockers = 0; + Mtm->votingTransactions = NULL; + Mtm->transListHead = NULL; + Mtm->transListTail = &Mtm->transListHead; + Mtm->nReceivers = 0; + Mtm->timeShift = 0; + Mtm->transCount = 0; + for (i = 0; i < MtmNodes; i++) { + Mtm->nodes[i].oldestSnapshot = 0; + Mtm->nodes[i].transDelay = 0; + } + PGSemaphoreCreate(&Mtm->votingSemaphore); + PGSemaphoreReset(&Mtm->votingSemaphore); + SpinLockInit(&Mtm->spinlock); + BgwPoolInit(&Mtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); RegisterXactCallback(MtmXactCallback, NULL); - dtmTx.snapshot = INVALID_CSN; - dtmTx.xid = InvalidTransactionId; + MtmTx.snapshot = INVALID_CSN; + MtmTx.xid = InvalidTransactionId; } MtmXid2State = MtmCreateXidMap(); MtmGid2State = MtmCreateGidMap(); @@ -1166,13 +1169,6 @@ static void MtmInitialize() LWLockRelease(AddinShmemInitLock); } - -MtmState* -MtmGetState(void) -{ - return dtm; -} - static void MtmShmemStartup(void) { @@ -1182,9 +1178,71 @@ MtmShmemStartup(void) MtmInitialize(); } -/* - * *************************************************************************** - */ +void MtmUpdateNodeConnStr(int nodeId, char const* connStr) +{ + char const* host; + char const* end; + int hostLen; + + if (strlen(connStr) >= MULTIMASTER_MAX_CONN_STR_SIZE) { + elog(ERROR, "Too long (%d) connection string '%s' for node %d, limit is %d", + (int)strlen(connStr), connStr, nodeId, MULTIMASTER_MAX_CONN_STR_SIZE-1); + } + strcpy(Mtm->nodes[nodeId-1].connStr, connStr); + + host = strstr(connStr, "host="); + if (host == NULL) { + elog(ERROR, "Host not specified in connection string: '%s'", connStr); + } + host += 5; + for (end = host; *end != ' ' && *end != ',' && *end != '\0'; end++); + hostLen = end - host; + if (hostLen >= MULTIMASTER_MAX_HOST_NAME_SIZE) { + elog(ERROR, "Too long (%d) host name '%.*s' for node %d, limit is %d", + hostLen, hostLen, host, nodeId, MULTIMASTER_MAX_HOST_NAME_SIZE-1); + } + memcpy(Mtm->nodes[nodeId-1].hostName, host, hostLen); + Mtm->nodes[nodeId-1].hostName[hostLen] = '\0'; +} + +static void MtmSplitConnStrs(void) +{ + int i; + char* connStr = strdup(MtmConnStrs); + char* connStrEnd = connStr + strlen(connStr); + + for (i = 0; connStr < connStrEnd; i++) { + char* p = strchr(connStr, ','); + if (p == NULL) { + p = connStrEnd; + } + if (i == MAX_NODES) { + elog(ERROR, "Multimaster with more than %d nodes is not currently supported", MAX_NODES); + } + *p = '\0'; + MtmUpdateNodeConnStr(i+1, connStr); + if (i+1 == MtmNodeId) { + char* dbName = strstr(connStr, "dbname="); + char* end; + size_t len; + if (dbName == NULL) { + elog(ERROR, "Database not specified in connection string: '%s'", connStr); + } + dbName += 7; + for (end = dbName; *end != ' ' && *end != ',' && *end != '\0'; end++); + len = end - dbName; + MtmDatabaseName = (char*)malloc(len + 1); + memcpy(MtmDatabaseName, dbName, len); + MtmDatabaseName[len] = '\0'; + } + connStr = p + 1; + } + free(connStr); + if (i < 2) { + elog(ERROR, "Multimaster should have at least two nodes"); + } + MtmNodes = i; +} void _PG_init(void) @@ -1232,21 +1290,6 @@ _PG_init(void) NULL ); - DefineCustomIntVariable( - "multimaster.vacuum_delay", - "Minimal age of records which can be vacuumed (seconds)", - NULL, - &MtmVacuumDelay, - 10, - 1, - INT_MAX, - PGC_BACKEND, - 0, - NULL, - NULL, - NULL - ); - DefineCustomIntVariable( "multimaster.workers", "Number of multimaster executor workers per node", @@ -1380,13 +1423,8 @@ _PG_init(void) NULL ); - MtmNodes = MtmStartReceivers(MtmConnStrs, MtmNodeId); - if (MtmNodes < 2) { - elog(ERROR, "Multimaster should have at least two nodes"); - } - if (MtmNodes > MAX_NODES) { - elog(ERROR, "Multimaster with mor than %d nodes is not currently supported", MAX_NODES); - } + MtmSplitConnStrs(); + MtmStartReceivers(); /* * Request additional shared resources. (These are no-ops if we're not in @@ -1428,15 +1466,15 @@ _PG_fini(void) void MtmReceiverStarted(int nodeId) { - SpinLockAcquire(&dtm->spinlock); - if (!BIT_CHECK(dtm->pglogicalNodeMask, nodeId-1)) { - BIT_SET(dtm->pglogicalNodeMask, nodeId-1); - if (++dtm->nReceivers == dtm->nNodes-1) { - Assert(dtm->status == MTM_CONNECTED); + SpinLockAcquire(&Mtm->spinlock); + if (!BIT_CHECK(Mtm->pglogicalNodeMask, nodeId-1)) { + BIT_SET(Mtm->pglogicalNodeMask, nodeId-1); + if (++Mtm->nReceivers == Mtm->nNodes-1) { + Assert(Mtm->status == MTM_CONNECTED); MtmSwitchClusterMode(MTM_ONLINE); } } - SpinLockRelease(&dtm->spinlock); + SpinLockRelease(&Mtm->spinlock); } /* @@ -1446,11 +1484,11 @@ void MtmReceiverStarted(int nodeId) */ MtmSlotMode MtmReceiverSlotMode(int nodeId) { - while (dtm->status != MTM_CONNECTED && dtm->status != MTM_ONLINE) { - if (dtm->status == MTM_RECOVERY) { - if (dtm->recoverySlot == 0 || dtm->recoverySlot == nodeId) { + while (Mtm->status != MTM_CONNECTED && Mtm->status != MTM_ONLINE) { + if (Mtm->status == MTM_RECOVERY) { + if (Mtm->recoverySlot == 0 || Mtm->recoverySlot == nodeId) { /* Choose for recovery first available slot */ - dtm->recoverySlot = nodeId; + Mtm->recoverySlot = nodeId; return SLOT_OPEN_EXISTED; } } @@ -1458,16 +1496,16 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) MtmSleep(STATUS_POLL_DELAY); } /* After recovery completion we need to drop all other slots to avoid receive of redundant data */ - return dtm->recoverySlot ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; + return Mtm->recoverySlot ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; } void MtmRecoverNode(int nodeId) { - if (nodeId <= 0 || nodeId > dtm->nNodes) + if (nodeId <= 0 || nodeId > Mtm->nNodes) { - elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, dtm->nNodes); + elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nNodes); } - if (!BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) { + if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { elog(ERROR, "Node %d was not disabled", nodeId); } if (!IsTransactionBlock()) @@ -1479,14 +1517,14 @@ void MtmRecoverNode(int nodeId) void MtmDropNode(int nodeId, bool dropSlot) { - if (!BIT_CHECK(dtm->disabledNodeMask, nodeId-1)) + if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { - if (nodeId <= 0 || nodeId > dtm->nNodes) + if (nodeId <= 0 || nodeId > Mtm->nNodes) { - elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, dtm->nNodes); + elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nNodes); } - BIT_SET(dtm->disabledNodeMask, nodeId-1); - dtm->nNodes -= 1; + BIT_SET(Mtm->disabledNodeMask, nodeId-1); + Mtm->nNodes -= 1; if (!IsTransactionBlock()) { MtmBroadcastUtilityStmt(psprintf("select mtm.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); @@ -1516,7 +1554,7 @@ Datum mtm_stop_replication(PG_FUNCTION_ARGS) { MtmDoReplication = false; - dtmTx.isDistributed = false; + MtmTx.isDistributed = false; PG_RETURN_VOID(); } @@ -1540,7 +1578,7 @@ mtm_recover_node(PG_FUNCTION_ARGS) Datum mtm_get_snapshot(PG_FUNCTION_ARGS) { - PG_RETURN_INT64(dtmTx.snapshot); + PG_RETURN_INT64(MtmTx.snapshot); } typedef struct @@ -1579,13 +1617,13 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) SRF_RETURN_DONE(funcctx); } usrfctx->values[0] = Int32GetDatum(usrfctx->nodeId); - usrfctx->values[1] = BoolGetDatum(BIT_CHECK(dtm->disabledNodeMask, usrfctx->nodeId-1)); - usrfctx->values[2] = BoolGetDatum(BIT_CHECK(dtm->connectivityMask, usrfctx->nodeId-1)); - usrfctx->values[3] = BoolGetDatum(BIT_CHECK(dtm->nodeLockerMask, usrfctx->nodeId-1)); + usrfctx->values[1] = BoolGetDatum(BIT_CHECK(Mtm->disabledNodeMask, usrfctx->nodeId-1)); + usrfctx->values[2] = BoolGetDatum(BIT_CHECK(Mtm->connectivityMask, usrfctx->nodeId-1)); + usrfctx->values[3] = BoolGetDatum(BIT_CHECK(Mtm->nodeLockerMask, usrfctx->nodeId-1)); lag = MtmGetSlotLag(usrfctx->nodeId); usrfctx->values[4] = Int64GetDatum(lag); usrfctx->nulls[4] = lag < 0; - usrfctx->values[5] = Int64GetDatum(dtm->transCount ? dtm->nodeTransDelay[usrfctx->nodeId-1]/dtm->transCount : 0); + usrfctx->values[5] = Int64GetDatum(Mtm->transCount ? Mtm->nodes[usrfctx->nodeId-1].transDelay/Mtm->transCount : 0); p = strchr(usrfctx->connStrPtr, ','); if (p != NULL) { *p++ = '\0'; @@ -1605,17 +1643,17 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) bool nulls[10] = {false}; get_call_result_type(fcinfo, NULL, &desc); - values[0] = CStringGetTextDatum(MtmNodeStatusMnem[dtm->status]); - values[1] = Int64GetDatum(dtm->disabledNodeMask); - values[2] = Int64GetDatum(dtm->connectivityMask); - values[3] = Int64GetDatum(dtm->nodeLockerMask); - values[4] = Int32GetDatum(dtm->nNodes); - values[5] = Int32GetDatum((int)dtm->pool.active); - values[6] = Int64GetDatum(BgwPoolGetQueueSize(&dtm->pool)); - values[7] = Int64GetDatum(dtm->transCount); - values[8] = Int64GetDatum(dtm->timeShift); - values[9] = Int32GetDatum(dtm->recoverySlot); - nulls[9] = dtm->recoverySlot == 0; + values[0] = CStringGetTextDatum(MtmNodeStatusMnem[Mtm->status]); + values[1] = Int64GetDatum(Mtm->disabledNodeMask); + values[2] = Int64GetDatum(Mtm->connectivityMask); + values[3] = Int64GetDatum(Mtm->nodeLockerMask); + values[4] = Int32GetDatum(Mtm->nNodes); + values[5] = Int32GetDatum((int)Mtm->pool.active); + values[6] = Int64GetDatum(BgwPoolGetQueueSize(&Mtm->pool)); + values[7] = Int64GetDatum(Mtm->transCount); + values[8] = Int64GetDatum(Mtm->timeShift); + values[9] = Int32GetDatum(Mtm->recoverySlot); + nulls[9] = Mtm->recoverySlot == 0; PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); } @@ -1646,7 +1684,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) char* conn_str = pstrdup(MtmConnStrs); char* conn_str_end = conn_str + strlen(conn_str); int i = 0; - nodemask_t disabledNodeMask = dtm->disabledNodeMask; + nodemask_t disabledNodeMask = Mtm->disabledNodeMask; int failedNode = -1; char const* errorMsg = NULL; PGconn **conns = palloc0(sizeof(PGconn*)*MtmNodes); @@ -1772,7 +1810,7 @@ static bool MtmProcessDDLCommand(char const* queryString) heap_freetuple(tup); heap_close(rel, RowExclusiveLock); - dtmTx.containsDML = true; + MtmTx.containsDML = true; return false; } @@ -1791,16 +1829,16 @@ MtmGenerateGid(char* gid) static void MtmTwoPhaseCommit(char *completionTag) { - MtmGenerateGid(dtmTx.gid); + MtmGenerateGid(MtmTx.gid); if (!IsTransactionBlock()) { - elog(WARNING, "Start transaction block for %d", dtmTx.xid); + elog(WARNING, "Start transaction block for %d", MtmTx.xid); BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); } - if (!PrepareTransactionBlock(dtmTx.gid)) + if (!PrepareTransactionBlock(MtmTx.gid)) { - elog(WARNING, "Failed to prepare transaction %s", dtmTx.gid); + elog(WARNING, "Failed to prepare transaction %s", MtmTx.gid); /* report unsuccessful commit in completionTag */ if (completionTag) { strcpy(completionTag, "ROLLBACK"); @@ -1810,10 +1848,10 @@ static void MtmTwoPhaseCommit(char *completionTag) CommitTransactionCommand(); StartTransactionCommand(); if (MtmGetCurrentTransactionStatus() == TRANSACTION_STATUS_ABORTED) { - FinishPreparedTransaction(dtmTx.gid, false); - elog(ERROR, "Transaction %s is aborted by DTM", dtmTx.gid); + FinishPreparedTransaction(MtmTx.gid, false); + elog(ERROR, "Transaction %s is aborted by DTM", MtmTx.gid); } else { - FinishPreparedTransaction(dtmTx.gid, true); + FinishPreparedTransaction(MtmTx.gid, true); } } } @@ -1832,7 +1870,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, switch (stmt->kind) { case TRANS_STMT_COMMIT: - if (dtmTx.isDistributed && dtmTx.containsDML) { + if (MtmTx.isDistributed && MtmTx.containsDML) { MtmTwoPhaseCommit(completionTag); return; } @@ -1865,11 +1903,11 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, skipCommand = false; break; } - if (!skipCommand && !dtmTx.isReplicated && context == PROCESS_UTILITY_TOPLEVEL) { + if (!skipCommand && !MtmTx.isReplicated && context == PROCESS_UTILITY_TOPLEVEL) { if (MtmProcessDDLCommand(queryString)) { return; } - if (dtmTx.isDistributed && dtmTx.containsDML && !IsTransactionBlock()) { + if (MtmTx.isDistributed && MtmTx.containsDML && !IsTransactionBlock()) { MtmTwoPhaseCommit(completionTag); } } @@ -1896,12 +1934,12 @@ MtmExecutorFinish(QueryDesc *queryDesc) int i; for (i = 0; i < estate->es_num_result_relations; i++) { if (RelationNeedsWAL(estate->es_result_relations[i].ri_RelationDesc)) { - dtmTx.containsDML = true; + MtmTx.containsDML = true; break; } } } - if (dtmTx.isDistributed && dtmTx.containsDML && !IsTransactionBlock()) { + if (MtmTx.isDistributed && MtmTx.containsDML && !IsTransactionBlock()) { MtmTwoPhaseCommit(NULL); } } @@ -1923,13 +1961,13 @@ MtmExecutorFinish(QueryDesc *queryDesc) void MtmExecute(void* work, int size) { - BgwPoolExecute(&dtm->pool, work, size); + BgwPoolExecute(&Mtm->pool, work, size); } static BgwPool* MtmPoolConstructor(void) { - return &dtm->pool; + return &Mtm->pool; } /* @@ -2025,7 +2063,7 @@ MtmDetectGlobalDeadLock(PGPROC* proc) MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.used/sizeof(GlobalTransactionId)); ByteBufferFree(&buf); for (i = 0; i < MtmNodes; i++) { - if (i+1 != MtmNodeId && !BIT_CHECK(dtm->disabledNodeMask, i)) { + if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i)) { int size; void* data = PaxosGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); if (data == NULL) { diff --git a/multimaster.h b/multimaster.h index 71415b9ee3..db78698fba 100644 --- a/multimaster.h +++ b/multimaster.h @@ -22,6 +22,8 @@ #define MULTIMASTER_MAX_PROTO_VERSION 1 #define MULTIMASTER_MAX_GID_SIZE 32 #define MULTIMASTER_MAX_SLOT_NAME_SIZE 16 +#define MULTIMASTER_MAX_CONN_STR_SIZE 128 +#define MULTIMASTER_MAX_HOST_NAME_SIZE 64 #define USEC 1000000 @@ -77,6 +79,14 @@ typedef enum SLOT_OPEN_ALWAYS, /* open existed slot or create new if noty exists */ } MtmSlotMode; +typedef struct +{ + time_t transDelay; + csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ + char hostName[MULTIMASTER_MAX_HOST_NAME_SIZE]; + char connStr[MULTIMASTER_MAX_CONN_STR_SIZE]; +} MtmNodeInfo; + typedef struct MtmTransState { TransactionId xid; @@ -93,7 +103,7 @@ typedef struct MtmTransState struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ bool votingCompleted; /* 2PC voting is completed */ - TransactionId xids[1]; /* Transaction ID at replicas: varying size MtmNodes */ + TransactionId xids[1]; /* [MtmNodes]: transaction ID at replicas */ } MtmTransState; typedef struct @@ -123,13 +133,15 @@ typedef struct uint64 transCount; /* Counter of transactions perfromed by this node */ time_t nodeTransDelay[MAX_NODES]; /* Time of waiting transaction acknowledgment from node */ BgwPool pool; /* Pool of background workers for applying logical replication patches */ + MtmNodeInfo nodes[1]; /* [MtmNodes]: per-node data */ } MtmState; #define MtmIsCoordinator(ts) (ts->gtid.node == MtmNodeId) extern char const* const MtmNodeStatusMnem[]; -extern char* MtmConnStrs; +extern MtmState* Mtm; + extern int MtmNodeId; extern int MtmNodes; extern int MtmArbiterPort; @@ -141,7 +153,7 @@ extern int MtmKeepaliveTimeout; extern HTAB* MtmXid2State; extern void MtmArbiterInitialize(void); -extern int MtmStartReceivers(char* nodes, int nodeId); +extern void MtmStartReceivers(void); extern csn_t MtmTransactionSnapshot(TransactionId xid); extern csn_t MtmAssignCSN(void); extern csn_t MtmSyncClock(csn_t csn); @@ -160,7 +172,6 @@ extern void MtmDropNode(int nodeId, bool dropSlot); extern void MtmRecoverNode(int nodeId); extern void MtmOnNodeDisconnect(int nodeId); extern void MtmOnNodeConnect(int nodeId); -extern MtmState* MtmGetState(void); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); extern void MtmSetCurrentTransactionGID(char const* gid); @@ -172,4 +183,6 @@ extern XidStatus MtmGetGlobalTransactionStatus(char const* gid); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); +extern void MtmUpdateNodeConnStr(int nodeId, char const* connStr); + #endif diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 4cb46f1d03..3486920c36 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -205,7 +205,6 @@ pglogical_receiver_main(Datum main_arg) PGconn *conn; PGresult *res; MtmSlotMode mode; - MtmState* ds = MtmGetState(); #ifndef USE_PGLOGICAL_OUTPUT bool insideTrans = false; @@ -284,7 +283,7 @@ pglogical_receiver_main(Datum main_arg) * Them are either empty, either new node is synchronized using base_backup. * So we assume that LSNs are the same for local and remote node */ - originStartPos = ds->status == MTM_RECOVERY ? GetXLogInsertRecPtr() : 0; + originStartPos = Mtm->status == MTM_RECOVERY ? GetXLogInsertRecPtr() : 0; elog(WARNING, "Start logical receiver at position %lx from node %d", originStartPos, args->remote_node); } else { originStartPos = replorigin_get_progress(originId, false); @@ -341,8 +340,8 @@ pglogical_receiver_main(Datum main_arg) if (rc & WL_POSTMASTER_DEATH) proc_exit(1); - if (ds->status == MTM_OFFLINE || (ds->status == MTM_RECOVERY && ds->recoverySlot != args->remote_node)) { - ereport(LOG, (errmsg("%s: terminating WAL receiver because node was switched to %s mode", worker_proc, MtmNodeStatusMnem[ds->status]))); + if (Mtm->status == MTM_OFFLINE || (Mtm->status == MTM_RECOVERY && Mtm->recoverySlot != args->remote_node)) { + ereport(LOG, (errmsg("%s: terminating WAL receiver because node was switched to %s mode", worker_proc, MtmNodeStatusMnem[Mtm->status]))); proc_exit(0); } @@ -411,7 +410,7 @@ pglogical_receiver_main(Datum main_arg) * In recovery mode also always send reply to provide master with more precise information * about recovery progress */ - if (replyRequested || receiver_sync_mode || ds->status == MTM_RECOVERY) + if (replyRequested || receiver_sync_mode || Mtm->status == MTM_RECOVERY) { int64 now = feGetCurrentTimestamp(); @@ -567,52 +566,31 @@ pglogical_receiver_main(Datum main_arg) } -int MtmStartReceivers(char* conns, int node_id) +void MtmStartReceivers(void) { - int i = 0; + int i; BackgroundWorker worker; - char* conn_str = conns; - char* conn_str_end = conn_str + strlen(conn_str); MemSet(&worker, 0, sizeof(BackgroundWorker)); worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; worker.bgw_start_time = BgWorkerStart_ConsistentState; worker.bgw_main = pglogical_receiver_main; worker.bgw_restart_time = MULTIMASTER_BGW_RESTART_TIMEOUT; - while (conn_str < conn_str_end) { - char* p = strchr(conn_str, ','); - if (p == NULL) { - p = conn_str_end; - } - if (++i != node_id) { + for (i = 0; i < MtmNodes; i++) { + if (i+1 != MtmNodeId) { ReceiverArgs* ctx = (ReceiverArgs*)malloc(sizeof(ReceiverArgs)); - if (MtmDatabaseName == NULL) { - char* dbname = strstr(conn_str, "dbname="); - char* eon; - int len; - Assert(dbname != NULL); - dbname += 7; - eon = strchr(dbname, ' '); - len = eon - dbname; - MtmDatabaseName = (char*)malloc(len + 1); - memcpy(MtmDatabaseName, dbname, len); - MtmDatabaseName[len] = '\0'; - } - ctx->receiver_conn_string = psprintf("replication=database %.*s", (int)(p - conn_str), conn_str); - sprintf(ctx->receiver_slot, MULTIMASTER_SLOT_PATTERN, node_id); - ctx->local_node = node_id; - ctx->remote_node = i; + ctx->receiver_conn_string = psprintf("replication=database %s", Mtm->nodes[i].connStr); + sprintf(ctx->receiver_slot, MULTIMASTER_SLOT_PATTERN, MtmNodeId); + ctx->local_node = MtmNodeId; + ctx->remote_node = i+1; /* Worker parameter and registration */ - snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_pglogical_receiver_%d_%d", node_id, i); + snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_pglogical_receiver_%d_%d", MtmNodeId, i+1); worker.bgw_main_arg = (Datum)ctx; RegisterBackgroundWorker(&worker); } - conn_str = p + 1; } - - return i; } #ifndef USE_PGLOGICAL_OUTPUT From 6f1906b2ac28c7538fcaef03f58a24a8a14610df Mon Sep 17 00:00:00 2001 From: knizhnik Date: Tue, 22 Mar 2016 00:28:09 +0300 Subject: [PATCH 0305/1139] Ignore rel in MtmGetOldestXmin --- multimaster.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/multimaster.c b/multimaster.c index a4f30d6490..e2585fc7df 100644 --- a/multimaster.c +++ b/multimaster.c @@ -312,7 +312,7 @@ Snapshot MtmGetSnapshot(Snapshot snapshot) TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum) { - TransactionId xmin = PgGetOldestXmin(rel, ignoreVacuum); + TransactionId xmin = PgGetOldestXmin(NULL, ignoreVacuum); /* consider all backends */ xmin = MtmAdjustOldestXid(xmin); return xmin; } @@ -410,7 +410,7 @@ MtmAdjustOldestXid(TransactionId xid) MtmLock(LW_EXCLUSIVE); ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { + if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { /* committed transactions have same CSNs at all nodes */ csn_t oldestSnapshot; int i; From a772bdc38da3b109217e37ff78e2fe5d63aae403 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 22 Mar 2016 12:28:47 +0300 Subject: [PATCH 0306/1139] Check validness of node-id in config --- multimaster.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index e2585fc7df..5b1b39f659 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1195,7 +1195,7 @@ void MtmUpdateNodeConnStr(int nodeId, char const* connStr) elog(ERROR, "Host not specified in connection string: '%s'", connStr); } host += 5; - for (end = host; *end != ' ' && *end != ',' && *end != '\0'; end++); + for (end = host; *end != ' ' && *end != '\0'; end++); hostLen = end - host; if (hostLen >= MULTIMASTER_MAX_HOST_NAME_SIZE) { elog(ERROR, "Too long (%d) host name '%.*s' for node %d, limit is %d", @@ -1229,7 +1229,7 @@ static void MtmSplitConnStrs(void) elog(ERROR, "Database not specified in connection string: '%s'", connStr); } dbName += 7; - for (end = dbName; *end != ' ' && *end != ',' && *end != '\0'; end++); + for (end = dbName; *end != ' ' && *end != '\0'; end++); len = end - dbName; MtmDatabaseName = (char*)malloc(len + 1); memcpy(MtmDatabaseName, dbName, len); @@ -1242,6 +1242,9 @@ static void MtmSplitConnStrs(void) elog(ERROR, "Multimaster should have at least two nodes"); } MtmNodes = i; + if (MtmNodeId > MtmNodes) { + elog(ERROR, "Invalid node id %d for specified nubmer of nodes %d", MtmNodeId, MtmNodes); + } } void @@ -1353,7 +1356,7 @@ _PG_init(void) "Multimaster node ID", NULL, &MtmNodeId, - 1, + INT_MAX, 1, INT_MAX, PGC_BACKEND, From 4998537c64e993b6fabcea1b6064343cb1a4caf3 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 22 Mar 2016 13:22:52 +0300 Subject: [PATCH 0307/1139] Fix bug in MtmSplitConnStrs --- multimaster.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/multimaster.c b/multimaster.c index 5b1b39f659..235d29dc28 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1208,7 +1208,8 @@ void MtmUpdateNodeConnStr(int nodeId, char const* connStr) static void MtmSplitConnStrs(void) { int i; - char* connStr = strdup(MtmConnStrs); + char* copy = strdup(MtmConnStrs); + char* connStr = copy; char* connStrEnd = connStr + strlen(connStr); for (i = 0; connStr < connStrEnd; i++) { @@ -1237,7 +1238,7 @@ static void MtmSplitConnStrs(void) } connStr = p + 1; } - free(connStr); + free(copy); if (i < 2) { elog(ERROR, "Multimaster should have at least two nodes"); } From 5fd60663411b6a4ba1b6fde47ad5ce26ffb24133 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 22 Mar 2016 13:30:19 +0300 Subject: [PATCH 0308/1139] Fix mistyping --- arbiter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arbiter.c b/arbiter.c index eda5114bab..175e6e66c4 100644 --- a/arbiter.c +++ b/arbiter.c @@ -598,7 +598,7 @@ static void MtmTransReceiver(Datum arg) tv.tv_usec = MtmKeepaliveTimeout%USEC; do { n = select(max_fd+1, &events, NULL, NULL, &tv); - } while (n < 0 && errno == ENINTR); + } while (n < 0 && errno == EINTR); } while (n < 0 && MtmRecovery()); if (rc < 0) { From 6fd85843dedca31c4b16a7681dda7d0d3a188830 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 22 Mar 2016 15:30:58 +0300 Subject: [PATCH 0309/1139] Fix configuration problem --- arbiter.c | 8 +++--- multimaster.c | 66 +++++++++++++++++++++++++++----------------- multimaster.h | 14 ++++++++-- pglogical_receiver.c | 4 +-- 4 files changed, 58 insertions(+), 34 deletions(-) diff --git a/arbiter.c b/arbiter.c index 175e6e66c4..e1dd9082fc 100644 --- a/arbiter.c +++ b/arbiter.c @@ -282,7 +282,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) req.hdr.sxid = ShmemVariableCache->nextXid; req.hdr.csn = MtmGetCurrentTime(); req.hdr.disabledNodeMask = Mtm->disabledNodeMask; - strcpy(req.connStr, Mtm->nodes[MtmNodeId-1].connStr); + strcpy(req.connStr, Mtm->nodes[MtmNodeId-1].con.connStr); if (!MtmWriteSocket(sd, &req, sizeof req)) { elog(WARNING, "Arbiter failed to send handshake message to %s:%d: %d", host, port, errno); close(sd); @@ -321,7 +321,7 @@ static void MtmOpenConnections() for (i = 0; i < nNodes; i++) { if (i+1 != MtmNodeId) { - sockets[i] = MtmConnectSocket(Mtm->nodes[i].hostName, MtmArbiterPort + i + 1, MtmConnectAttempts); + sockets[i] = MtmConnectSocket(Mtm->nodes[i].con.hostName, MtmArbiterPort + i + 1, MtmConnectAttempts); if (sockets[i] < 0) { MtmOnNodeDisconnect(i+1); } @@ -345,7 +345,7 @@ static bool MtmSendToNode(int node, void const* buf, int size) if (sockets[node] >= 0) { close(sockets[node]); } - sockets[node] = MtmConnectSocket(Mtm->nodes[node].hostName, MtmArbiterPort + node + 1, MtmReconnectAttempts); + sockets[node] = MtmConnectSocket(Mtm->nodes[node].con.hostName, MtmArbiterPort + node + 1, MtmReconnectAttempts); if (sockets[node] < 0) { MtmOnNodeDisconnect(node+1); return false; @@ -385,7 +385,7 @@ static void MtmAcceptOneConnection() resp.dxid = HANDSHAKE_MAGIC; resp.sxid = ShmemVariableCache->nextXid; resp.csn = MtmGetCurrentTime(); - MtmUpdateNodeConnStr(req.hdr.node, req.connStr); + MtmUpdateNodeConnectionInfo(&Mtm->nodes[req.hdr.node-1].con, req.connStr); if (!MtmWriteSocket(fd, &resp, sizeof resp)) { elog(WARNING, "Arbiter failed to write response for handshake message to node %d", resp.node); close(fd); diff --git a/multimaster.c b/multimaster.c index 235d29dc28..51e6d50557 100644 --- a/multimaster.c +++ b/multimaster.c @@ -166,6 +166,7 @@ int MtmConnectAttempts; int MtmConnectTimeout; int MtmKeepaliveTimeout; int MtmReconnectAttempts; +MtmConnectionInfo* MtmConnections; static char* MtmConnStrs; static int MtmQueueSize; @@ -420,8 +421,13 @@ MtmAdjustOldestXid(TransactionId xid) oldestSnapshot = Mtm->nodes[i].oldestSnapshot; } } - for (ts = Mtm->transListHead; ts != NULL && ts->csn < oldestSnapshot; prev = ts, ts = ts->next) { - Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED || ts->status == TRANSACTION_STATUS_IN_PROGRESS); + for (ts = Mtm->transListHead; + ts != NULL + && ts->csn < oldestSnapshot + && (ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED) + && TransactionIdPrecedes(ts->xid, xid); + prev = ts, ts = ts->next) + { if (prev != NULL) { /* Remove information about too old transactions */ hash_search(MtmXid2State, &prev->xid, HASH_REMOVE, NULL); @@ -989,7 +995,7 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) for (i = 0; i < n; i++) { if (i+1 != MtmNodeId) { void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); - matrix[i] = *(nodemask_t*)data; + matrix[i] = data ? *(nodemask_t*)data : 0; } else { matrix[i] = Mtm->connectivityMask; } @@ -1153,6 +1159,7 @@ static void MtmInitialize() for (i = 0; i < MtmNodes; i++) { Mtm->nodes[i].oldestSnapshot = 0; Mtm->nodes[i].transDelay = 0; + Mtm->nodes[i].con = MtmConnections[i]; } PGSemaphoreCreate(&Mtm->votingSemaphore); PGSemaphoreReset(&Mtm->votingSemaphore); @@ -1178,17 +1185,17 @@ MtmShmemStartup(void) MtmInitialize(); } -void MtmUpdateNodeConnStr(int nodeId, char const* connStr) +void MtmUpdateNodeConnectionInfo(MtmConnectionInfo* conn, char const* connStr) { char const* host; char const* end; int hostLen; if (strlen(connStr) >= MULTIMASTER_MAX_CONN_STR_SIZE) { - elog(ERROR, "Too long (%d) connection string '%s' for node %d, limit is %d", - (int)strlen(connStr), connStr, nodeId, MULTIMASTER_MAX_CONN_STR_SIZE-1); + elog(ERROR, "Too long (%d) connection string '%s': limit is %d", + (int)strlen(connStr), connStr, MULTIMASTER_MAX_CONN_STR_SIZE-1); } - strcpy(Mtm->nodes[nodeId-1].connStr, connStr); + strcpy(conn->connStr, connStr); host = strstr(connStr, "host="); if (host == NULL) { @@ -1198,30 +1205,46 @@ void MtmUpdateNodeConnStr(int nodeId, char const* connStr) for (end = host; *end != ' ' && *end != '\0'; end++); hostLen = end - host; if (hostLen >= MULTIMASTER_MAX_HOST_NAME_SIZE) { - elog(ERROR, "Too long (%d) host name '%.*s' for node %d, limit is %d", - hostLen, hostLen, host, nodeId, MULTIMASTER_MAX_HOST_NAME_SIZE-1); + elog(ERROR, "Too long (%d) host name '%.*s': limit is %d", + hostLen, hostLen, host, MULTIMASTER_MAX_HOST_NAME_SIZE-1); } - memcpy(Mtm->nodes[nodeId-1].hostName, host, hostLen); - Mtm->nodes[nodeId-1].hostName[hostLen] = '\0'; + memcpy(conn->hostName, host, hostLen); + conn->hostName[hostLen] = '\0'; } static void MtmSplitConnStrs(void) { int i; - char* copy = strdup(MtmConnStrs); + char* copy = pstrdup(MtmConnStrs); char* connStr = copy; char* connStrEnd = connStr + strlen(connStr); + for (i = 0; connStr < connStrEnd; i++) { + char* p = strchr(connStr, ','); + if (p == NULL) { + p = connStrEnd; + } + connStr = p + 1; + } + if (i > MAX_NODES) { + elog(ERROR, "Multimaster with more than %d nodes is not currently supported", MAX_NODES); + } + if (i < 2) { + elog(ERROR, "Multimaster should have at least two nodes"); + } + MtmNodes = i; + MtmConnections = (MtmConnectionInfo*)palloc(i*sizeof(MtmConnectionInfo)); + connStr = copy; + for (i = 0; connStr < connStrEnd; i++) { char* p = strchr(connStr, ','); if (p == NULL) { p = connStrEnd; } - if (i == MAX_NODES) { - elog(ERROR, "Multimaster with more than %d nodes is not currently supported", MAX_NODES); - } *p = '\0'; - MtmUpdateNodeConnStr(i+1, connStr); + + MtmUpdateNodeConnectionInfo(&MtmConnections[i], connStr); + if (i+1 == MtmNodeId) { char* dbName = strstr(connStr, "dbname="); char* end; @@ -1232,20 +1255,13 @@ static void MtmSplitConnStrs(void) dbName += 7; for (end = dbName; *end != ' ' && *end != '\0'; end++); len = end - dbName; - MtmDatabaseName = (char*)malloc(len + 1); + MtmDatabaseName = (char*)palloc(len + 1); memcpy(MtmDatabaseName, dbName, len); MtmDatabaseName[len] = '\0'; } connStr = p + 1; } - free(copy); - if (i < 2) { - elog(ERROR, "Multimaster should have at least two nodes"); - } - MtmNodes = i; - if (MtmNodeId > MtmNodes) { - elog(ERROR, "Invalid node id %d for specified nubmer of nodes %d", MtmNodeId, MtmNodes); - } + pfree(copy); } void diff --git a/multimaster.h b/multimaster.h index db78698fba..27a1efc425 100644 --- a/multimaster.h +++ b/multimaster.h @@ -81,10 +81,16 @@ typedef enum typedef struct { + char hostName[MULTIMASTER_MAX_HOST_NAME_SIZE]; + char connStr[MULTIMASTER_MAX_CONN_STR_SIZE]; +} MtmConnectionInfo; + + +typedef struct +{ + MtmConnectionInfo con; time_t transDelay; csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ - char hostName[MULTIMASTER_MAX_HOST_NAME_SIZE]; - char connStr[MULTIMASTER_MAX_CONN_STR_SIZE]; } MtmNodeInfo; typedef struct MtmTransState @@ -152,6 +158,8 @@ extern int MtmReconnectAttempts; extern int MtmKeepaliveTimeout; extern HTAB* MtmXid2State; +extern MtmConnectionInfo* MtmConnections; + extern void MtmArbiterInitialize(void); extern void MtmStartReceivers(void); extern csn_t MtmTransactionSnapshot(TransactionId xid); @@ -183,6 +191,6 @@ extern XidStatus MtmGetGlobalTransactionStatus(char const* gid); extern bool MtmIsRecoveredNode(int nodeId); extern void MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); -extern void MtmUpdateNodeConnStr(int nodeId, char const* connStr); +extern void MtmUpdateNodeConnectionInfo(MtmConnectionInfo* conn, char const* connStr); #endif diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 3486920c36..397ef9fd73 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -578,8 +578,8 @@ void MtmStartReceivers(void) for (i = 0; i < MtmNodes; i++) { if (i+1 != MtmNodeId) { - ReceiverArgs* ctx = (ReceiverArgs*)malloc(sizeof(ReceiverArgs)); - ctx->receiver_conn_string = psprintf("replication=database %s", Mtm->nodes[i].connStr); + ReceiverArgs* ctx = (ReceiverArgs*)palloc(sizeof(ReceiverArgs)); + ctx->receiver_conn_string = psprintf("replication=database %s", MtmConnections[i].connStr); sprintf(ctx->receiver_slot, MULTIMASTER_SLOT_PATTERN, MtmNodeId); ctx->local_node = MtmNodeId; ctx->remote_node = i+1; From a0f28cdfb1b01df693571fc01d005c557026cd5d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 22 Mar 2016 19:04:13 +0300 Subject: [PATCH 0310/1139] Revive vacuum delay --- multimaster.c | 80 ++++++++++++++++++++++++++++++++++----------------- 1 file changed, 54 insertions(+), 26 deletions(-) diff --git a/multimaster.c b/multimaster.c index 51e6d50557..dd27bfe559 100644 --- a/multimaster.c +++ b/multimaster.c @@ -171,6 +171,7 @@ MtmConnectionInfo* MtmConnections; static char* MtmConnStrs; static int MtmQueueSize; static int MtmWorkers; +static int MtmVacuumDelay; static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; @@ -408,36 +409,48 @@ MtmAdjustOldestXid(TransactionId xid) { if (TransactionIdIsValid(xid)) { MtmTransState *ts, *prev = NULL; - + csn_t oldestSnapshot = 0; + int i; + MtmLock(LW_EXCLUSIVE); - ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { /* committed transactions have same CSNs at all nodes */ - csn_t oldestSnapshot; - int i; - - Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot = ts->csn; - for (i = 0; i < MtmNodes; i++) { - if (Mtm->nodes[i].oldestSnapshot < oldestSnapshot) { - oldestSnapshot = Mtm->nodes[i].oldestSnapshot; - } + for (ts = Mtm->transListHead; ts != NULL; ts = ts->next) { + if (TransactionIdPrecedes(ts->xid, xid) + && ts->status == TRANSACTION_STATUS_COMMITTED + && ts->csn > oldestSnapshot) + { + oldestSnapshot = ts->csn; } - for (ts = Mtm->transListHead; - ts != NULL - && ts->csn < oldestSnapshot - && (ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED) - && TransactionIdPrecedes(ts->xid, xid); - prev = ts, ts = ts->next) + } + Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; + for (i = 0; i < MtmNodes; i++) { + if (!BIT_CHECK(Mtm->disabledNodeMask, i) + && Mtm->nodes[i].oldestSnapshot < oldestSnapshot) { - if (prev != NULL) { - /* Remove information about too old transactions */ - hash_search(MtmXid2State, &prev->xid, HASH_REMOVE, NULL); - } + oldestSnapshot = Mtm->nodes[i].oldestSnapshot; } - } - if (prev != NULL) { - Mtm->transListHead = prev; - Mtm->oldestXid = xid = prev->xid; - } else { + } + oldestSnapshot -= MtmVacuumDelay*USEC; + for (ts = Mtm->transListHead; + ts != NULL + && ts->csn < oldestSnapshot + && TransactionIdPrecedes(ts->xid, xid) + && (ts->status == TRANSACTION_STATUS_COMMITTED || + ts->status == TRANSACTION_STATUS_ABORTED); + ts = ts->next) + { + if (ts->status == TRANSACTION_STATUS_COMMITTED) { + prev = ts; + } + } + if (prev != NULL) { + for (ts = Mtm->transListHead; ts != prev; ts = ts->next) { + /* Remove information about too old transactions */ + Assert(ts->status != TRANSACTION_STATUS_UNKNOWN); + hash_search(MtmXid2State, &ts->xid, HASH_REMOVE, NULL); + } + Mtm->transListHead = prev; + Mtm->oldestXid = xid = prev->xid; + } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { xid = Mtm->oldestXid; } MtmUnlock(); @@ -1325,6 +1338,21 @@ _PG_init(void) NULL ); + DefineCustomIntVariable( + "multimaster.vacuum_delay", + "Minimal age of records which can be vacuumed (seconds)", + NULL, + &MtmVacuumDelay, + 1, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.queue_size", "Multimaster queue size", From 5a61a27b0b11da0d500361a9be3050a39a9e05e3 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 22 Mar 2016 20:06:42 +0300 Subject: [PATCH 0311/1139] Reverted MtmAdjustOldestXid --- multimaster.c | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/multimaster.c b/multimaster.c index dd27bfe559..3ca2a37808 100644 --- a/multimaster.c +++ b/multimaster.c @@ -404,6 +404,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) * We collest oldest CSNs from all nodes and choose minimum from them. * If no such XID can be located, then return previously observed oldest XID */ +#if 0 static TransactionId MtmAdjustOldestXid(TransactionId xid) { @@ -457,7 +458,53 @@ MtmAdjustOldestXid(TransactionId xid) } return xid; } +#else +static TransactionId +MtmAdjustOldestXid(TransactionId xid) +{ + if (TransactionIdIsValid(xid)) { + MtmTransState *ts, *prev = NULL; + int i; + MtmLock(LW_EXCLUSIVE); + ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); + if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { + csn_t oldestSnapshot = ts->csn; + Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; + for (i = 0; i < MtmNodes; i++) { + if (!BIT_CHECK(Mtm->disabledNodeMask, i) + && Mtm->nodes[i].oldestSnapshot < oldestSnapshot) + { + oldestSnapshot = Mtm->nodes[i].oldestSnapshot; + } + } + oldestSnapshot -= MtmVacuumDelay*USEC; + + for (ts = Mtm->transListHead; + ts != NULL + && ts->csn < oldestSnapshot + && TransactionIdPrecedes(ts->xid, xid) + && (ts->status == TRANSACTION_STATUS_COMMITTED || + ts->status == TRANSACTION_STATUS_ABORTED); + prev = ts, ts = ts->next) + { + if (prev != NULL) { + /* Remove information about too old transactions */ + hash_search(MtmXid2State, &prev->xid, HASH_REMOVE, NULL); + } + } + } + if (prev != NULL) { + Mtm->transListHead = prev; + Mtm->oldestXid = xid = prev->xid; + } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { + xid = Mtm->oldestXid; + } + MtmUnlock(); + } + return xid; +} +#endif /* * ------------------------------------------- * Transaction list manipulation From 84f81cb9c6f23249c2961d8254ce1357d168704f Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 23 Mar 2016 15:00:14 +0300 Subject: [PATCH 0312/1139] fix arbiter socket after failed connect() --- arbiter.c | 20 ++++++++++++-------- tests/pg_hba.conf | 3 +++ tests/postgresql.conf.mm | 2 +- tests/reinit-mm.sh | 11 +++++++++-- 4 files changed, 25 insertions(+), 11 deletions(-) diff --git a/arbiter.c b/arbiter.c index e1dd9082fc..1bc73c15cb 100644 --- a/arbiter.c +++ b/arbiter.c @@ -243,30 +243,34 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) if (!MtmResolveHostByName(host, addrs, &n_addrs)) { elog(ERROR, "Arbiter failed to resolve host '%s' by name", host); } - Retry: - sd = socket(AF_INET, SOCK_STREAM, 0); - if (sd < 0) { - elog(ERROR, "Arbiter failed to create socket: %d", errno); - } + +Retry: + while (1) { int rc = -1; + + sd = socket(AF_INET, SOCK_STREAM, 0); + if (sd < 0) { + elog(ERROR, "Arbiter failed to create socket: %d", errno); + } for (i = 0; i < n_addrs; ++i) { memcpy(&sock_inet.sin_addr, &addrs[i], sizeof sock_inet.sin_addr); do { rc = connect(sd, (struct sockaddr*)&sock_inet, sizeof(sock_inet)); } while (rc < 0 && errno == EINTR); - + if (rc >= 0 || errno == EINPROGRESS) { break; } } if (rc < 0) { if ((errno != ENOENT && errno != ECONNREFUSED && errno != EINPROGRESS) || max_attempts == 0) { - elog(WARNING, "Arbiter failed to connect to %s:%d: %d", host, port, errno); + elog(WARNING, "Arbiter failed to connect to %s:%d: error=%d", host, port, errno); return -1; } else { max_attempts -= 1; - MtmSleep(MtmConnectTimeout); + elog(WARNING, "Arbiter trying to connect to %s:%d: error=%d", host, port, errno); + MtmSleep(5*MtmConnectTimeout); } continue; } else { diff --git a/tests/pg_hba.conf b/tests/pg_hba.conf index bb032013b6..685a0b9003 100644 --- a/tests/pg_hba.conf +++ b/tests/pg_hba.conf @@ -90,4 +90,7 @@ host all all ::1/128 trust # replication privilege. local replication knizhnik trust host replication knizhnik 127.0.0.1/32 trust +local replication stas trust +host replication stas ::1/128 trust +host replication stas 127.0.0.1/32 trust #host replication knizhnik ::1/128 trust diff --git a/tests/postgresql.conf.mm b/tests/postgresql.conf.mm index 8151f4c34d..6c9f04d0ce 100644 --- a/tests/postgresql.conf.mm +++ b/tests/postgresql.conf.mm @@ -625,4 +625,4 @@ # Add settings for extensions here multimaster.workers=8 -multimaster.queue_size=1073741824 +multimaster.queue_size=104857600 # 100mb diff --git a/tests/reinit-mm.sh b/tests/reinit-mm.sh index bf22645339..b43cb12dc6 100755 --- a/tests/reinit-mm.sh +++ b/tests/reinit-mm.sh @@ -3,6 +3,12 @@ export PATH=~/code/postgres_cluster/install/bin/:$PATH ulimit -c unlimited pkill -9 postgres pkill -9 arbiter + +cd ~/code/postgres_cluster/contrib/mmts/ +make install +cd ~/code/postgres_cluster/contrib/mmts/tests + + rm -fr node? *.log dtm mkdir dtm conn_str="" @@ -28,9 +34,10 @@ do echo "multimaster.conn_strings = '$conn_str'" >> node$i/postgresql.conf echo "multimaster.node_id = $i" >> node$i/postgresql.conf cp pg_hba.conf node$i - pg_ctl -D node$i -l node$i.log start + pg_ctl -w -D node$i -l node$i.log start done -sleep 5 +# sleep 5 +# psql -c "create extension multimaster;" postgres echo Done From 592364cf136dc48cf817e1a79fcc9c5dc0eb7cb0 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 23 Mar 2016 19:58:27 +0300 Subject: [PATCH 0313/1139] Add commit_command hook --- multimaster.c | 60 ++++++++++++++++++++++++++------------------------- 1 file changed, 31 insertions(+), 29 deletions(-) diff --git a/multimaster.c b/multimaster.c index 3ca2a37808..f50b94c34f 100644 --- a/multimaster.c +++ b/multimaster.c @@ -111,6 +111,7 @@ static void MtmPrePrepareTransaction(MtmCurrentTrans* x); static void MtmPostPrepareTransaction(MtmCurrentTrans* x); static void MtmAbortPreparedTransaction(MtmCurrentTrans* x); static void MtmEndTransaction(MtmCurrentTrans* x, bool commit); +static bool MtmTwoPhaseCommit(MtmCurrentTrans* x); static TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum); static bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); static TransactionId MtmAdjustOldestXid(TransactionId xid); @@ -588,6 +589,11 @@ MtmXactCallback(XactEvent event, void *arg) case XACT_EVENT_ABORT: MtmEndTransaction(&MtmTx, false); break; + case XACT_EVENT_COMMIT_COMMAND: + if (!IsTransactionBlock()) { + MtmTwoPhaseCommit(&MtmTx); + } + break; default: break; } @@ -1922,33 +1928,33 @@ MtmGenerateGid(char* gid) sprintf(gid, "MTM-%d-%d-%d", MtmNodeId, MyProcPid, ++localCount); } -static void MtmTwoPhaseCommit(char *completionTag) +static bool MtmTwoPhaseCommit(MtmCurrentTrans* x) { - MtmGenerateGid(MtmTx.gid); - if (!IsTransactionBlock()) { - elog(WARNING, "Start transaction block for %d", MtmTx.xid); - BeginTransactionBlock(); - CommitTransactionCommand(); - StartTransactionCommand(); - } - if (!PrepareTransactionBlock(MtmTx.gid)) - { - elog(WARNING, "Failed to prepare transaction %s", MtmTx.gid); - /* report unsuccessful commit in completionTag */ - if (completionTag) { - strcpy(completionTag, "ROLLBACK"); + if (x->isDistributed && x->containsDML) { + MtmGenerateGid(x->gid); + if (!IsTransactionBlock()) { + elog(WARNING, "Start transaction block for %d", x->xid); + BeginTransactionBlock(); + CommitTransactionCommand(); + StartTransactionCommand(); } - /* ??? Should we do explicit rollback */ - } else { - CommitTransactionCommand(); - StartTransactionCommand(); - if (MtmGetCurrentTransactionStatus() == TRANSACTION_STATUS_ABORTED) { - FinishPreparedTransaction(MtmTx.gid, false); - elog(ERROR, "Transaction %s is aborted by DTM", MtmTx.gid); - } else { - FinishPreparedTransaction(MtmTx.gid, true); + if (!PrepareTransactionBlock(x->gid)) + { + elog(WARNING, "Failed to prepare transaction %s", x->gid); + /* ??? Should we do explicit rollback */ + } else { + CommitTransactionCommand(); + StartTransactionCommand(); + if (MtmGetCurrentTransactionStatus() == TRANSACTION_STATUS_ABORTED) { + FinishPreparedTransaction(x->gid, false); + elog(ERROR, "Transaction %s is aborted by DTM", x->gid); + } else { + FinishPreparedTransaction(x->gid, true); + } } + return true; } + return false; } static void MtmProcessUtility(Node *parsetree, const char *queryString, @@ -1965,8 +1971,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, switch (stmt->kind) { case TRANS_STMT_COMMIT: - if (MtmTx.isDistributed && MtmTx.containsDML) { - MtmTwoPhaseCommit(completionTag); + if (MtmTwoPhaseCommit(&MtmTx)) { return; } break; @@ -2002,9 +2007,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, if (MtmProcessDDLCommand(queryString)) { return; } - if (MtmTx.isDistributed && MtmTx.containsDML && !IsTransactionBlock()) { - MtmTwoPhaseCommit(completionTag); - } } if (PreviousProcessUtilityHook != NULL) { @@ -2035,7 +2037,7 @@ MtmExecutorFinish(QueryDesc *queryDesc) } } if (MtmTx.isDistributed && MtmTx.containsDML && !IsTransactionBlock()) { - MtmTwoPhaseCommit(NULL); + MtmTwoPhaseCommit(&MtmTx); } } if (PreviousExecutorFinishHook != NULL) From b2a0c8071694ef5567befbd1a20c95c00269d1b1 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Thu, 24 Mar 2016 13:37:49 +0300 Subject: [PATCH 0314/1139] fix arbiter connection for select-based version --- arbiter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arbiter.c b/arbiter.c index 1bc73c15cb..0e044a39b9 100644 --- a/arbiter.c +++ b/arbiter.c @@ -605,7 +605,7 @@ static void MtmTransReceiver(Datum arg) } while (n < 0 && errno == EINTR); } while (n < 0 && MtmRecovery()); - if (rc < 0) { + if (n < 0) { elog(ERROR, "Arbiter failed to select sockets: %d", errno); } for (i = 0; i < nNodes; i++) { From 044e54475fa51ceda0d329bac10115ed348d3d8a Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Thu, 24 Mar 2016 17:07:15 +0300 Subject: [PATCH 0315/1139] mmts TODO --- TODO | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 TODO diff --git a/TODO b/TODO new file mode 100644 index 0000000000..0a562d9331 --- /dev/null +++ b/TODO @@ -0,0 +1,22 @@ +TODO + +* Disallow tables without pkeys. +* Automate extension creation (?) +* Database itn't usable right after pg_ctl -w. There are still several second before db will switch to operational mode. +* Statements without tx. +* Disallow user-created MTM-* gid's. + + + + + + + + + + + + + + + From 0fcf7409a129719c764f0b36f9159a1d62c63909 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 24 Mar 2016 20:51:23 +0300 Subject: [PATCH 0316/1139] Handle keepalive parameters --- arbiter.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 46 insertions(+), 4 deletions(-) diff --git a/arbiter.c b/arbiter.c index 0e044a39b9..b75c9c0781 100644 --- a/arbiter.c +++ b/arbiter.c @@ -230,6 +230,51 @@ static int MtmReadSocket(int sd, void* buf, int buf_size) +static void MtmSetSocketOptions(int sd) +{ +#ifdef TCP_NODELAY + int optval = 1; + if (setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)) < 0) { + elog(WARNING, "Failed to set TCP_NODELAY: %m"); + } +#endif + if (tcp_keepalives_idle) { +#ifdef TCP_KEEPIDLE + if (setsockopt(sd, IPPROTO_TCP, TCP_KEEPIDLE, + (char *) &tcp_keepalives_idle, sizeof(tcp_keepalives_idle)) < 0) + { + elog(WARNING, "Failed to set TCP_KEEPIDLE: %m"); + } +#else +#ifdef TCP_KEEPALIVE + if (setsockopt(sd, IPPROTO_TCP, TCP_KEEPALIVE, + (char *) &tcp_keepalives_idle, sizeof(tcp_keepalives_idle)) < 0) + { + elog(WARNING, "Failed to set TCP_KEEPALIVE: %m"); + } +#endif +#endif + } +#ifdef TCP_KEEPINTVL + if (tcp_keepalives_interval) { + if (setsockopt(sd, IPPROTO_TCP, TCP_KEEPINTVL, + (char *) &tcp_keepalives_interval, sizeof(tcp_keepalives_interval)) < 0) + { + elog(WARNING, "Failed to set TCP_KEEPINTVL: %m"); + } + } +#endif +#ifdef TCP_KEEPCNT + if (tcp_keepalives_count) { + if (setsockopt(sd, IPPROTO_TCP, TCP_KEEPCNT, + (char *) &tcp_keepalives_count, sizeof(tcp_keepalives_count)) < 0) + { + elog(WARNING, "Failed to set TCP_KEEPCNT: %m"); + } + } +#endif +} + static int MtmConnectSocket(char const* host, int port, int max_attempts) { struct sockaddr_in sock_inet; @@ -274,12 +319,9 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) } continue; } else { - int optval = 1; MtmHandshakeMessage req; MtmArbiterMessage resp; - setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)); - setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (char const*)&optval, sizeof(optval)); - + MtmSetSocketOptions(sd); req.hdr.code = MSG_HANDSHAKE; req.hdr.node = MtmNodeId; req.hdr.dxid = HANDSHAKE_MAGIC; From 32297b0dffdd4a3cf288f4d397bde34bf893913d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 25 Mar 2016 19:31:56 +0300 Subject: [PATCH 0317/1139] Set logical decoding hooks --- multimaster.c | 51 ++++++++++++++++- multimaster.h | 5 +- pglogical_hooks.c | 6 ++ pglogical_output.c | 2 +- pglogical_proto.c | 137 ++++++++++++++++++++++----------------------- pglogical_proto.h | 5 +- 6 files changed, 131 insertions(+), 75 deletions(-) diff --git a/multimaster.c b/multimaster.c index f50b94c34f..d8983cedb8 100644 --- a/multimaster.c +++ b/multimaster.c @@ -53,6 +53,7 @@ #include "nodes/makefuncs.h" #include "access/htup_details.h" #include "catalog/indexing.h" +#include "pglogical_output/hooks.h" #include "multimaster.h" #include "ddd.h" @@ -161,6 +162,7 @@ bool MtmDoReplication; char* MtmDatabaseName; int MtmNodeId; +int MtmReplicationNodeId; int MtmArbiterPort; int MtmNodes; int MtmConnectAttempts; @@ -1637,6 +1639,27 @@ void MtmDropNode(int nodeId, bool dropSlot) } } +static void +MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) +{ + MtmOnNodeDisconnect(MtmReplicationNodeId); +} + +static bool +MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) +{ + elog(WARNING, "MtmReplicationTxnFilterHook: args->origin_id=%d, MtmReplicationNodeId=%d", args->origin_id, MtmReplicationNodeId); + return args->origin_id == InvalidRepOriginId || MtmIsRecoveredNode(MtmReplicationNodeId); +} + +void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks) +{ + hooks->shutdown_hook = MtmReplicationShutdownHook; + hooks->txn_filter_hook = MtmReplicationTxnFilterHook; +} + + + /* * ------------------------------------------- * SQL API functions @@ -1988,16 +2011,42 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_ClosePortalStmt: case T_FetchStmt: case T_DoStmt: + case T_CreateTableSpaceStmt: + case T_DropTableSpaceStmt: + case T_AlterTableSpaceOptionsStmt: + case T_TruncateStmt: + case T_CommentStmt: /* XXX: we could replicate these */; case T_CopyStmt: case T_PrepareStmt: case T_ExecuteStmt: + case T_DeallocateStmt: + case T_GrantStmt: /* XXX: we could replicate some of these these */; + case T_GrantRoleStmt: + case T_AlterDatabaseStmt: + case T_AlterDatabaseSetStmt: case T_NotifyStmt: case T_ListenStmt: case T_UnlistenStmt: case T_LoadStmt: + case T_ClusterStmt: /* XXX: we could replicate these */; + case T_VacuumStmt: + case T_ExplainStmt: + case T_AlterSystemStmt: case T_VariableSetStmt: case T_VariableShowStmt: - skipCommand = true; + case T_DiscardStmt: + case T_CreateEventTrigStmt: + case T_AlterEventTrigStmt: + case T_CreateRoleStmt: + case T_AlterRoleStmt: + case T_AlterRoleSetStmt: + case T_DropRoleStmt: + case T_ReassignOwnedStmt: + case T_LockStmt: + case T_ConstraintsSetStmt: + case T_CheckPointStmt: + case T_ReindexStmt: + skipCommand = true; break; default: skipCommand = false; diff --git a/multimaster.h b/multimaster.h index 27a1efc425..9c6032c35a 100644 --- a/multimaster.h +++ b/multimaster.h @@ -5,6 +5,8 @@ #include "bgwpool.h" #include "bkb.h" +#include "pglogical_output/hooks.h" + #define MTM_TUPLE_TRACE(fmt, ...) /* #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) @@ -149,6 +151,7 @@ extern char const* const MtmNodeStatusMnem[]; extern MtmState* Mtm; extern int MtmNodeId; +extern int MtmReplicationNodeId; extern int MtmNodes; extern int MtmArbiterPort; extern char* MtmDatabaseName; @@ -192,5 +195,5 @@ extern bool MtmIsRecoveredNode(int nodeId); extern void MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); extern void MtmUpdateNodeConnectionInfo(MtmConnectionInfo* conn, char const* connStr); - +extern void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks); #endif diff --git a/pglogical_hooks.c b/pglogical_hooks.c index 73e812063f..2163d788e3 100644 --- a/pglogical_hooks.c +++ b/pglogical_hooks.c @@ -106,6 +106,12 @@ load_hooks(PGLogicalOutputData *data) data->hooks.row_filter_hook, data->hooks.txn_filter_hook, data->hooks.hooks_private_data); + } + else if (data->api->setup_hooks) + { + old_ctxt = MemoryContextSwitchTo(data->hooks_mctxt); + (*data->api->setup_hooks)(&data->hooks); + MemoryContextSwitchTo(old_ctxt); } if (txn_started) diff --git a/pglogical_output.c b/pglogical_output.c index 29de03c628..bc2cfa5e8d 100644 --- a/pglogical_output.c +++ b/pglogical_output.c @@ -343,7 +343,7 @@ pg_decode_startup(LogicalDecodingContext * ctx, OutputPluginOptions *opt, data->forward_changeset_origins = false; } - if (data->hooks_setup_funcname != NIL) + if (data->hooks_setup_funcname != NIL || data->api->setup_hooks) { data->hooks_mctxt = AllocSetContextCreate(ctx->context, diff --git a/pglogical_proto.c b/pglogical_proto.c index 51a1605deb..62f5f87d8e 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -37,12 +37,7 @@ #include "multimaster.h" -typedef struct PGLogicalProtoMM -{ - PGLogicalProtoAPI api; - int nodeId; - bool isLocal; -} PGLogicalProtoMM; +static bool MtmIsFilteredTxn; static void pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel); @@ -72,30 +67,31 @@ static char decide_datum_transfer(Form_pg_attribute att, static void pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel) { - PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; - if (!mm->isLocal) { - const char *nspname; - uint8 nspnamelen; - const char *relname; - uint8 relnamelen; - - pq_sendbyte(out, 'R'); /* sending RELATION */ - - nspname = get_namespace_name(rel->rd_rel->relnamespace); - if (nspname == NULL) - elog(ERROR, "cache lookup failed for namespace %u", - rel->rd_rel->relnamespace); - nspnamelen = strlen(nspname) + 1; - - relname = NameStr(rel->rd_rel->relname); - relnamelen = strlen(relname) + 1; - - pq_sendbyte(out, nspnamelen); /* schema name length */ - pq_sendbytes(out, nspname, nspnamelen); - - pq_sendbyte(out, relnamelen); /* table name length */ - pq_sendbytes(out, relname, relnamelen); - } + const char *nspname; + uint8 nspnamelen; + const char *relname; + uint8 relnamelen; + + if (MtmIsFilteredTxn) { + return; + } + + pq_sendbyte(out, 'R'); /* sending RELATION */ + + nspname = get_namespace_name(rel->rd_rel->relnamespace); + if (nspname == NULL) + elog(ERROR, "cache lookup failed for namespace %u", + rel->rd_rel->relnamespace); + nspnamelen = strlen(nspname) + 1; + + relname = NameStr(rel->rd_rel->relname); + relnamelen = strlen(relname) + 1; + + pq_sendbyte(out, nspnamelen); /* schema name length */ + pq_sendbytes(out, nspname, nspnamelen); + + pq_sendbyte(out, relnamelen); /* table name length */ + pq_sendbytes(out, relname, relnamelen); } /* @@ -105,21 +101,19 @@ static void pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, ReorderBufferTXN *txn) { - PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; + bool isRecovery = MtmIsRecoveredNode(MtmReplicationNodeId); csn_t csn = MtmTransactionSnapshot(txn->xid); - bool isRecovery = MtmIsRecoveredNode(mm->nodeId); MTM_TRACE("pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); - if (csn == INVALID_CSN && !isRecovery) { - //Assert(txn->origin_id != InvalidRepOriginId); - mm->isLocal = true; - } else { - mm->isLocal = false; - //Assert(txn->origin_id == InvalidRepOriginId || isRecovery); - pq_sendbyte(out, 'B'); /* BEGIN */ + + if (csn == INVALID_CSN && !isRecovery) { + MtmIsFilteredTxn = true; + } else { + pq_sendbyte(out, 'B'); /* BEGIN */ pq_sendint(out, MtmNodeId, 4); pq_sendint(out, isRecovery ? InvalidTransactionId : txn->xid, 4); - pq_sendint64(out, csn); - } + pq_sendint64(out, csn); + MtmIsFilteredTxn = false; + } } /* @@ -129,9 +123,11 @@ static void pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, ReorderBufferTXN *txn, XLogRecPtr commit_lsn) { - PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; uint8 flags = 0; + if (MtmIsFilteredTxn) { + return; + } if (txn->xact_action == XLOG_XACT_COMMIT) flags = PGLOGICAL_COMMIT; else if (txn->xact_action == XLOG_XACT_PREPARE) @@ -143,18 +139,19 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, else Assert(false); - +#if 0 if (flags == PGLOGICAL_COMMIT || flags == PGLOGICAL_PREPARE) { if (mm->isLocal) { return; } } else { csn_t csn = MtmTransactionSnapshot(txn->xid); - bool isRecovery = MtmIsRecoveredNode(mm->nodeId); + bool isRecovery = MtmIsRecoveredNode(MtmReplicationNodeId); if (csn == INVALID_CSN && !isRecovery) { return; } } +#endif pq_sendbyte(out, 'C'); /* sending COMMIT */ @@ -185,11 +182,10 @@ static void pglogical_write_insert(StringInfo out, PGLogicalOutputData *data, Relation rel, HeapTuple newtuple) { - PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; - if (!mm->isLocal) { - pq_sendbyte(out, 'I'); /* action INSERT */ - pglogical_write_tuple(out, data, rel, newtuple); - } + if (!MtmIsFilteredTxn) { + pq_sendbyte(out, 'I'); /* action INSERT */ + pglogical_write_tuple(out, data, rel, newtuple); + } } /* @@ -199,20 +195,20 @@ static void pglogical_write_update(StringInfo out, PGLogicalOutputData *data, Relation rel, HeapTuple oldtuple, HeapTuple newtuple) { - PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; - if (!mm->isLocal) { - pq_sendbyte(out, 'U'); /* action UPDATE */ - /* FIXME support whole tuple (O tuple type) */ - if (oldtuple != NULL) - { - pq_sendbyte(out, 'K'); /* old key follows */ - pglogical_write_tuple(out, data, rel, oldtuple); - } - - pq_sendbyte(out, 'N'); /* new tuple follows */ - pglogical_write_tuple(out, data, rel, newtuple); - } + if (!MtmIsFilteredTxn) { + pq_sendbyte(out, 'U'); /* action UPDATE */ + /* FIXME support whole tuple (O tuple type) */ + if (oldtuple != NULL) + { + pq_sendbyte(out, 'K'); /* old key follows */ + pglogical_write_tuple(out, data, rel, oldtuple); + } + + pq_sendbyte(out, 'N'); /* new tuple follows */ + pglogical_write_tuple(out, data, rel, newtuple); + } } + /* * Write DELETE to the output stream. */ @@ -220,11 +216,10 @@ static void pglogical_write_delete(StringInfo out, PGLogicalOutputData *data, Relation rel, HeapTuple oldtuple) { - PGLogicalProtoMM* mm = (PGLogicalProtoMM*)data->api; - if (!mm->isLocal) { - pq_sendbyte(out, 'D'); /* action DELETE */ - pglogical_write_tuple(out, data, rel, oldtuple); - } + if (!MtmIsFilteredTxn) { + pq_sendbyte(out, 'D'); /* action DELETE */ + pglogical_write_tuple(out, data, rel, oldtuple); + } } /* @@ -422,16 +417,16 @@ decide_datum_transfer(Form_pg_attribute att, Form_pg_type typclass, PGLogicalProtoAPI * pglogical_init_api(PGLogicalProtoType typ) { - PGLogicalProtoMM* pmm = palloc0(sizeof(PGLogicalProtoMM)); - PGLogicalProtoAPI* res = &pmm->api; - pmm->isLocal = false; - sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &pmm->nodeId); + PGLogicalProtoAPI* res = palloc0(sizeof(PGLogicalProtoAPI)); + sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &MtmReplicationNodeId); + elog(WARNING, "%d: PRGLOGICAL init API for slot %s node %d", MyProcPid, MyReplicationSlot->data.name.data, MtmReplicationNodeId); res->write_rel = pglogical_write_rel; res->write_begin = pglogical_write_begin; res->write_commit = pglogical_write_commit; res->write_insert = pglogical_write_insert; res->write_update = pglogical_write_update; res->write_delete = pglogical_write_delete; + res->setup_hooks = MtmSetupReplicationHooks; res->write_startup_message = write_startup_message; return res; } diff --git a/pglogical_proto.h b/pglogical_proto.h index b8c419d27e..2fdbec0e19 100644 --- a/pglogical_proto.h +++ b/pglogical_proto.h @@ -33,6 +33,8 @@ typedef void (*pglogical_write_delete_fn)(StringInfo out, PGLogicalOutputData *d typedef void (*write_startup_message_fn)(StringInfo out, List *msg); +typedef void (*pglogical_setup_hooks_fn)(struct PGLogicalHooks* hooks); + typedef struct PGLogicalProtoAPI { pglogical_write_rel_fn write_rel; @@ -42,7 +44,8 @@ typedef struct PGLogicalProtoAPI pglogical_write_insert_fn write_insert; pglogical_write_update_fn write_update; pglogical_write_delete_fn write_delete; - write_startup_message_fn write_startup_message; + pglogical_setup_hooks_fn setup_hooks; + write_startup_message_fn write_startup_message; } PGLogicalProtoAPI; From 16df7ec7ce114004fe58c6599eebd6556a28eae7 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Fri, 25 Mar 2016 20:18:40 +0300 Subject: [PATCH 0318/1139] do not replicate temp tables; return fixed error message --- multimaster.c | 43 ++++++++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 11 deletions(-) diff --git a/multimaster.c b/multimaster.c index d8983cedb8..0abb35c0d0 100644 --- a/multimaster.c +++ b/multimaster.c @@ -126,7 +126,7 @@ static void MtmAddSubtransactions(MtmTransState* ts, TransactionId *subxids, int static void MtmShmemStartup(void); static BgwPool* MtmPoolConstructor(void); -static bool MtmRunUtilityStmt(PGconn* conn, char const* sql); +static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg); static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError); MtmState* Mtm; @@ -1791,14 +1791,24 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) /* * Execute statement with specified parameters and check its result */ -static bool MtmRunUtilityStmt(PGconn* conn, char const* sql) +static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg) { PGresult *result = PQexec(conn, sql); int status = PQresultStatus(result); + char *errstr; + bool ret = status == PGRES_COMMAND_OK || status == PGRES_TUPLES_OK; - if (!ret) { - elog(WARNING, "Command '%s' failed with status %d", sql, status); + + if (!ret) { + char *errstr = PQresultErrorMessage(result); + int errlen = strlen(errstr); + + *errmsg = palloc0(errlen); + + /* Strip "ERROR:\t" from beginning and "\n" from end of error string */ + strncpy(*errmsg, errstr + 7, errlen - 1 - 7); } + PQclear(result); return ret; } @@ -1812,6 +1822,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) int failedNode = -1; char const* errorMsg = NULL; PGconn **conns = palloc0(sizeof(PGconn*)*MtmNodes); + char* utility_errmsg; while (conn_str < conn_str_end) { @@ -1847,15 +1858,18 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) { if (conns[i]) { - if (!MtmRunUtilityStmt(conns[i], "BEGIN TRANSACTION") && !ignoreError) + if (!MtmRunUtilityStmt(conns[i], "BEGIN TRANSACTION", &utility_errmsg) && !ignoreError) { errorMsg = "Failed to start transaction at node %d"; failedNode = i; break; } - if (!MtmRunUtilityStmt(conns[i], sql) && !ignoreError) + if (!MtmRunUtilityStmt(conns[i], sql, &utility_errmsg) && !ignoreError) { - errorMsg = "Failed to run command at node %d"; + // errorMsg = "Failed to run command at node %d"; + // XXX: add check for our node + errorMsg = utility_errmsg; + failedNode = i; break; } @@ -1867,13 +1881,13 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) { if (conns[i]) { - MtmRunUtilityStmt(conns[i], "ROLLBACK TRANSACTION"); + MtmRunUtilityStmt(conns[i], "ROLLBACK TRANSACTION", &utility_errmsg); } } } else { for (i = 0; i < MtmNodes; i++) { - if (conns[i] && !MtmRunUtilityStmt(conns[i], "COMMIT TRANSACTION") && !ignoreError) + if (conns[i] && !MtmRunUtilityStmt(conns[i], "COMMIT TRANSACTION", &utility_errmsg) && !ignoreError) { errorMsg = "Commit failed at node %d"; failedNode = i; @@ -1955,8 +1969,8 @@ static bool MtmTwoPhaseCommit(MtmCurrentTrans* x) { if (x->isDistributed && x->containsDML) { MtmGenerateGid(x->gid); - if (!IsTransactionBlock()) { - elog(WARNING, "Start transaction block for %d", x->xid); + if (!x->isTransactionBlock) { + /* elog(WARNING, "Start transaction block for %s", x->gid); */ BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); @@ -2048,6 +2062,13 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_ReindexStmt: skipCommand = true; break; + case T_CreateStmt: + { + /* Do not replicate temp tables */ + CreateStmt *stmt = (CreateStmt *) parsetree; + skipCommand = stmt->relation->relpersistence == RELPERSISTENCE_TEMP; + } + break; default: skipCommand = false; break; From b8c0a63a29c3c1283552a64000f32211c8dd2c18 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 26 Mar 2016 23:29:13 +0300 Subject: [PATCH 0319/1139] Prevent recusive broadcast by setting special applicastion name --- multimaster.c | 28 +++++++++++----------------- multimaster.h | 1 + pglogical_apply.c | 6 +++--- 3 files changed, 15 insertions(+), 20 deletions(-) diff --git a/multimaster.c b/multimaster.c index 0abb35c0d0..722f237e24 100644 --- a/multimaster.c +++ b/multimaster.c @@ -798,7 +798,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) * Send notification only if ABORT happens during transaction processing at replicas, * do not send notification if ABORT is receiver from master */ - MTM_TRACE("%d: send ABORT notification to coordinator %d\n", MyProcPid, x->gtid.node); + MTM_INFO("%d: send ABORT notification abort transaction %d to coordinator %d\n", MyProcPid, x->gtid.xid, x->gtid.node); if (ts == NULL) { Assert(TransactionIdIsValid(x->xid)); ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, NULL); @@ -1602,6 +1602,11 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) return Mtm->recoverySlot ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; } +static bool MtmIsBroadcast() +{ + return application_name != NULL && strcmp(application_name, MULTIMASTER_BROADCAST_SERVICE) == 0; +} + void MtmRecoverNode(int nodeId) { if (nodeId <= 0 || nodeId > Mtm->nNodes) @@ -1611,7 +1616,7 @@ void MtmRecoverNode(int nodeId) if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { elog(ERROR, "Node %d was not disabled", nodeId); } - if (!IsTransactionBlock()) + if (!MtmIsBroadcast()) { MtmBroadcastUtilityStmt(psprintf("select pg_create_logical_replication_slot('" MULTIMASTER_SLOT_PATTERN "', '" MULTIMASTER_NAME "')", nodeId), true); } @@ -1628,7 +1633,7 @@ void MtmDropNode(int nodeId, bool dropSlot) } BIT_SET(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes -= 1; - if (!IsTransactionBlock()) + if (!MtmIsBroadcast()) { MtmBroadcastUtilityStmt(psprintf("select mtm.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); } @@ -1648,7 +1653,6 @@ MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) static bool MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) { - elog(WARNING, "MtmReplicationTxnFilterHook: args->origin_id=%d, MtmReplicationNodeId=%d", args->origin_id, MtmReplicationNodeId); return args->origin_id == InvalidRepOriginId || MtmIsRecoveredNode(MtmReplicationNodeId); } @@ -1795,7 +1799,6 @@ static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg) { PGresult *result = PQexec(conn, sql); int status = PQresultStatus(result); - char *errstr; bool ret = status == PGRES_COMMAND_OK || status == PGRES_TUPLES_OK; @@ -1815,8 +1818,6 @@ static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg) static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) { - char* conn_str = pstrdup(MtmConnStrs); - char* conn_str_end = conn_str + strlen(conn_str); int i = 0; nodemask_t disabledNodeMask = Mtm->disabledNodeMask; int failedNode = -1; @@ -1824,16 +1825,11 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) PGconn **conns = palloc0(sizeof(PGconn*)*MtmNodes); char* utility_errmsg; - while (conn_str < conn_str_end) + for (i = 0; i < MtmNodes; i++) { - char* p = strchr(conn_str, ','); - if (p == NULL) { - p = conn_str_end; - } - *p = '\0'; if (!BIT_CHECK(disabledNodeMask, i)) { - conns[i] = PQconnectdb(conn_str); + conns[i] = PQconnectdb(psprintf("%s application_name=%s", Mtm->nodes[i].con.connStr, MULTIMASTER_BROADCAST_SERVICE)); if (PQstatus(conns[i]) != CONNECTION_OK) { if (ignoreError) @@ -1845,12 +1841,10 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) do { PQfinish(conns[i]); } while (--i >= 0); - elog(ERROR, "Failed to establish connection '%s' to node %d", conn_str, failedNode); + elog(ERROR, "Failed to establish connection '%s' to node %d", Mtm->nodes[i].con.connStr, failedNode); } } } - conn_str = p + 1; - i += 1; } Assert(i == MtmNodes); diff --git a/multimaster.h b/multimaster.h index 9c6032c35a..025fa1e972 100644 --- a/multimaster.h +++ b/multimaster.h @@ -26,6 +26,7 @@ #define MULTIMASTER_MAX_SLOT_NAME_SIZE 16 #define MULTIMASTER_MAX_CONN_STR_SIZE 128 #define MULTIMASTER_MAX_HOST_NAME_SIZE 64 +#define MULTIMASTER_BROADCAST_SERVICE "mtm_broadcast" #define USEC 1000000 diff --git a/pglogical_apply.c b/pglogical_apply.c index 241d5ef5fd..380b491c3e 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -934,10 +934,10 @@ void MtmExecutor(int id, void* work, size_t size) { EmitErrorReport(); FlushErrorState(); - MTM_TRACE("%d: REMOTE begin abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); - MtmEndSession(); + MTM_INFO("%d: REMOTE begin abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); + MtmEndSession(false); AbortCurrentTransaction(); - MTM_TRACE("%d: REMOTE end abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); + MTM_INFO("%d: REMOTE end abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); } PG_END_TRY(); From 69d8dd9a9f285383fe19f1b8883b8e3dae5620fd Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 27 Mar 2016 18:43:58 +0300 Subject: [PATCH 0320/1139] Fix sending commit of prepared transaction --- pglogical_proto.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/pglogical_proto.c b/pglogical_proto.c index 62f5f87d8e..e1e69af250 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -125,9 +125,6 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, { uint8 flags = 0; - if (MtmIsFilteredTxn) { - return; - } if (txn->xact_action == XLOG_XACT_COMMIT) flags = PGLOGICAL_COMMIT; else if (txn->xact_action == XLOG_XACT_PREPARE) @@ -139,9 +136,8 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, else Assert(false); -#if 0 if (flags == PGLOGICAL_COMMIT || flags == PGLOGICAL_PREPARE) { - if (mm->isLocal) { + if (MtmIsFilteredTxn) { return; } } else { @@ -151,7 +147,6 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, return; } } -#endif pq_sendbyte(out, 'C'); /* sending COMMIT */ From 6b70fbe99b9c2ab1c12738634b40916005f68c2f Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 28 Mar 2016 11:45:01 +0300 Subject: [PATCH 0321/1139] Handle node disconnect --- multimaster.c | 47 +++++++++++++++++++++++++++++++++++++++----- multimaster.h | 13 +++++++----- pglogical_receiver.c | 3 ++- 3 files changed, 52 insertions(+), 11 deletions(-) diff --git a/multimaster.c b/multimaster.c index 722f237e24..0bb93fa140 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1047,6 +1047,7 @@ MtmCheckClusterLock() Mtm->nNodes += Mtm->nLockers; Mtm->nLockers = 0; Mtm->nodeLockerMask = 0; + MtmCheckQuorum(); } } break; @@ -1056,14 +1057,17 @@ MtmCheckClusterLock() /** * Build internode connectivity mask. 1 - means that node is disconnected. */ -static void +static bool MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) { int i, j, n = MtmNodes; for (i = 0; i < n; i++) { if (i+1 != MtmNodeId) { void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); - matrix[i] = data ? *(nodemask_t*)data : 0; + if (data == NULL) { + return false; + } + matrix[i] = *(nodemask_t*)data; } else { matrix[i] = Mtm->connectivityMask; } @@ -1074,6 +1078,7 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) matrix[i] |= ((matrix[j] >> i) & 1) << j; } } + return true; } @@ -1081,14 +1086,17 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) * Build connectivity graph, find clique in it and extend disabledNodeMask by nodes not included in clique. * This function returns false if current node is excluded from cluster, true otherwise */ -void MtmRefreshClusterStatus(bool nowait) +bool MtmRefreshClusterStatus(bool nowait) { nodemask_t mask, clique; nodemask_t matrix[MAX_NODES]; int clique_size; int i; - MtmBuildConnectivityMatrix(matrix, nowait); + if (!MtmBuildConnectivityMatrix(matrix, nowait)) { + /* RAFT is not available */ + return false; + } clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ @@ -1108,6 +1116,7 @@ void MtmRefreshClusterStatus(bool nowait) BIT_CLEAR(Mtm->disabledNodeMask, i); } } + MtmCheckQuorum(); MtmUnlock(); if (BIT_CHECK(Mtm->disabledNodeMask, MtmNodeId-1)) { if (Mtm->status == MTM_ONLINE) { @@ -1120,9 +1129,27 @@ void MtmRefreshClusterStatus(bool nowait) } } else { elog(WARNING, "Clique %lx has no quorum", clique); + Mtm->status = MTM_IN_MINORITY; } + return true; } +void MtmCheckQuorum(void) +{ + if (Mtm->nNodes < MtmNodes/2+1) { + if (Mtm->status == MTM_ONLINE) { /* out of quorum */ + elog(WARNING, "Node is in minority: disabled mask %lx", Mtm->disabledNodeMask); + Mtm->status = MTM_IN_MINORITY; + } + } else { + if (Mtm->status == MTM_IN_MINORITY) { + elog(WARNING, "Node is in majority: dissbled mask %lx", Mtm->disabledNodeMask); + Mtm->status = MTM_ONLINE; + } + } +} + + void MtmOnNodeDisconnect(int nodeId) { BIT_SET(Mtm->connectivityMask, nodeId-1); @@ -1131,7 +1158,15 @@ void MtmOnNodeDisconnect(int nodeId) /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ MtmSleep(MtmKeepaliveTimeout); - MtmRefreshClusterStatus(false); + if (!MtmRefreshClusterStatus(false)) { + MtmLock(LW_EXCLUSIVE); + if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { + BIT_SET(Mtm->disabledNodeMask, nodeId-1); + Mtm->nNodes -= 1; + MtmCheckQuorum(); + } + MtmUnlock(); + } } void MtmOnNodeConnect(int nodeId) @@ -1633,6 +1668,7 @@ void MtmDropNode(int nodeId, bool dropSlot) } BIT_SET(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes -= 1; + MtmCheckQuorum(); if (!MtmIsBroadcast()) { MtmBroadcastUtilityStmt(psprintf("select mtm.drop_node(%d,%s)", nodeId, dropSlot ? "true" : "false"), true); @@ -1647,6 +1683,7 @@ void MtmDropNode(int nodeId, bool dropSlot) static void MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) { + elog(WARNING, "Logical replication to node %d is stopped", MtmReplicationNodeId); MtmOnNodeDisconnect(MtmReplicationNodeId); } diff --git a/multimaster.h b/multimaster.h index 025fa1e972..97b8f54350 100644 --- a/multimaster.h +++ b/multimaster.h @@ -8,13 +8,13 @@ #include "pglogical_output/hooks.h" #define MTM_TUPLE_TRACE(fmt, ...) -/* +#if 0 #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -*/ +#else #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) -/* */ +#endif #define MULTIMASTER_NAME "multimaster" #define MULTIMASTER_SCHEMA_NAME "mtm" @@ -72,7 +72,8 @@ typedef enum MTM_OFFLINE, /* Node is out of quorum */ MTM_CONNECTED, /* Arbiter is established connections with other nodes */ MTM_ONLINE, /* Ready to receive client's queries */ - MTM_RECOVERY /* Node is in recovery process */ + MTM_RECOVERY, /* Node is in recovery process */ + MTM_IN_MINORITY /* Node is out of quorum */ } MtmNodeStatus; typedef enum @@ -193,8 +194,10 @@ extern TransactionId MtmGetCurrentTransactionId(void); extern XidStatus MtmGetCurrentTransactionStatus(void); extern XidStatus MtmGetGlobalTransactionStatus(char const* gid); extern bool MtmIsRecoveredNode(int nodeId); -extern void MtmRefreshClusterStatus(bool nowait); +extern bool MtmRefreshClusterStatus(bool nowait); extern void MtmSwitchClusterMode(MtmNodeStatus mode); extern void MtmUpdateNodeConnectionInfo(MtmConnectionInfo* conn, char const* connStr); extern void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks); +extern void MtmCheckQuorum(void); + #endif diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 397ef9fd73..59aab99d38 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -240,8 +240,9 @@ pglogical_receiver_main(Datum main_arg) if (PQstatus(conn) != CONNECTION_OK) { PQfinish(conn); - ereport(ERROR, (errmsg("%s: Could not establish connection to remote server", + ereport(WARNING, (errmsg("%s: Could not establish connection to remote server", worker_proc))); + MtmOnNodeDisconnect(args->remote_node); proc_exit(1); } From 78af32872b66e0c783022ccc2cb020be8bcf07c5 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Mon, 28 Mar 2016 18:48:29 +0300 Subject: [PATCH 0322/1139] tap-test for mm recovery --- Makefile | 4 ++ TODO | 9 +-- t/001_basic_recovery.pl | 126 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 135 insertions(+), 4 deletions(-) create mode 100644 t/001_basic_recovery.pl diff --git a/Makefile b/Makefile index 8574fd30b9..ca41bb95a3 100644 --- a/Makefile +++ b/Makefile @@ -22,3 +22,7 @@ include $(top_builddir)/src/Makefile.global include $(top_srcdir)/contrib/contrib-global.mk endif +check: + env DESTDIR='$(abs_top_builddir)'/tmp_install make install + $(prove_check) + diff --git a/TODO b/TODO index 0a562d9331..3bd972a0fa 100644 --- a/TODO +++ b/TODO @@ -1,12 +1,13 @@ TODO -* Disallow tables without pkeys. +* Disallow or do not replicate tables without pkeys. * Automate extension creation (?) * Database itn't usable right after pg_ctl -w. There are still several second before db will switch to operational mode. -* Statements without tx. ++ Statements without tx. * Disallow user-created MTM-* gid's. - - +* Check configuration sanity for mm before actual startup: max_wal_senders, max_worker_processes, max_wal_senders, wal_level, max_replication_slots +* Handle SIGQUIT +* Move arbiter host/port to connstring diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl new file mode 100644 index 0000000000..69ebc7ad36 --- /dev/null +++ b/t/001_basic_recovery.pl @@ -0,0 +1,126 @@ +use strict; +use warnings; +use PostgresNode; +use TestLib; +use Test::More tests => 2; +use DBI; +use DBD::Pg ':async'; + +############################################################################### +# Aux routines +############################################################################### + +sub PostgresNode::inet_connstr { + my ($self, $dbname) = @_; + my $pgport = $self->port; + my $pghost = '127.0.0.1'; + my $pgdata = $self->data_dir; + + if (!defined($dbname)) + { + return "port=$pgport host=$pghost"; + } + return "port=$pgport host=$pghost dbname=$dbname"; +} + +############################################################################### +# Setup nodes +############################################################################### + +my $nnodes = 3; +my @nodes = (); +my $pgconf_common = qq( + listen_addresses = '127.0.0.1' + max_prepared_transactions = 10 + max_worker_processes = 10 + max_wal_senders = 10 + max_replication_slots = 10 + wal_level = logical + shared_preload_libraries = 'multimaster' + multimaster.workers=4 + multimaster.queue_size=10485760 # 10mb +); + +# Init nodes +for (my $i=0; $i < $nnodes; $i++) { + push(@nodes, get_new_node("node$i")); + $nodes[$i]->init; +} + +# Collect conn info +my $mm_connstr = join(', ', map { "${ \$_->inet_connstr('postgres') }" } @nodes); + +# Configure and start nodes +for (my $i=0; $i < $nnodes; $i++) { + $nodes[$i]->append_conf('postgresql.conf', $pgconf_common); + $nodes[$i]->append_conf('postgresql.conf', qq( + multimaster.node_id = @{[ $i + 1 ]} + multimaster.conn_strings = '$mm_connstr' + #multimaster.arbiter_port = ${ \$nodes[0]->port } + )); + $nodes[$i]->append_conf('pg_hba.conf', qq( + host replication all 127.0.0.1/32 trust + )); + $nodes[$i]->start; +} + +############################################################################### +# Wait until nodes are up +############################################################################### + +my $psql_out; +# XXX: change to poll_untill +sleep(7); + +############################################################################### +# Replication check +############################################################################### + +$nodes[0]->psql('postgres', " + create extension multimaster; + create table if not exists t(k int primary key, v int); + insert into t values(1, 10); +"); + +$nodes[1]->psql('postgres', "select v from t where k=1;", stdout => \$psql_out); +is($psql_out, '10', "Check sanity while all nodes are up."); + +############################################################################### +# Isolation regress checks +############################################################################### + +# we can call pg_regress here + +############################################################################### +# Work after node stop +############################################################################### + +$nodes[2]->teardown_node; + +# $nodes[0]->poll_query_until('postgres', +# "select disconnected = true from mtm.get_nodes_state() where id=3;") +# or die "Timed out while waiting for node to disconnect"; + +$nodes[0]->psql('postgres', " + insert into t values(2, 20); +"); + +$nodes[1]->psql('postgres', "select v from t where k=2;", stdout => \$psql_out); +is($psql_out, '20', "Check that we can commit after one node disconnect."); + + + + + + + + + + + + + + + + + From 1d135e616254b64d36cb676abefcef9a06897a09 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 28 Mar 2016 20:18:02 +0300 Subject: [PATCH 0323/1139] Node recovery --- arbiter.c | 6 +++--- multimaster.c | 35 +++++++++++++++++++++++++++-------- multimaster.h | 1 + pglogical_proto.c | 2 +- 4 files changed, 32 insertions(+), 12 deletions(-) diff --git a/arbiter.c b/arbiter.c index b75c9c0781..81c59e4e4e 100644 --- a/arbiter.c +++ b/arbiter.c @@ -348,10 +348,9 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) /* Some node considered that I am dead, so switch to recovery mode */ if (BIT_CHECK(resp.disabledNodeMask, MtmNodeId-1)) { elog(WARNING, "Node %d think that I am dead", resp.node); + BIT_SET(Mtm->disabledNodeMask, MtmNodeId-1); MtmSwitchClusterMode(MTM_RECOVERY); } - /* Combine disable masks from all node. Is it actually correct or we should better check availability of nodes ourselves? */ - Mtm->disabledNodeMask |= resp.disabledNodeMask; return sd; } } @@ -377,7 +376,7 @@ static void MtmOpenConnections() } if (Mtm->nNodes < MtmNodes/2+1) { /* no quorum */ elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", Mtm->nNodes, MtmNodes); - Mtm->status = MTM_OFFLINE; + Mtm->status = MTM_IN_MINORITY; } else if (Mtm->status == MTM_INITIALIZATION) { MtmSwitchClusterMode(MTM_CONNECTED); } @@ -431,6 +430,7 @@ static void MtmAcceptOneConnection() resp.dxid = HANDSHAKE_MAGIC; resp.sxid = ShmemVariableCache->nextXid; resp.csn = MtmGetCurrentTime(); + resp.node = MtmNodeId; MtmUpdateNodeConnectionInfo(&Mtm->nodes[req.hdr.node-1].con, req.connStr); if (!MtmWriteSocket(fd, &resp, sizeof resp)) { elog(WARNING, "Arbiter failed to write response for handshake message to node %d", resp.node); diff --git a/multimaster.c b/multimaster.c index 0bb93fa140..b0a28dd3d3 100644 --- a/multimaster.c +++ b/multimaster.c @@ -155,7 +155,8 @@ char const* const MtmNodeStatusMnem[] = "Offline", "Connected", "Online", - "Recovery" + "Recovery", + "InMinor" }; bool MtmDoReplication; @@ -631,10 +632,11 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->isReplicated = false; x->isDistributed = MtmIsUserTransaction(); x->isPrepared = false; - if (x->isDistributed && Mtm->status != MTM_ONLINE) { + x->isTransactionBlock = IsTransactionBlock(); + /* Application name can be cahnged usnig PGAPPNAME environment variable */ + if (x->isDistributed && Mtm->status != MTM_ONLINE && strcmp(application_name, MULTIMASTER_ADMIN) != 0) { /* reject all user's transactions at offline cluster */ MtmUnlock(); - Assert(Mtm->status == MTM_ONLINE); elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[Mtm->status]); } x->containsDML = false; @@ -981,11 +983,14 @@ bool MtmIsRecoveredNode(int nodeId) * We have to maintain two bitmasks: one is marking wal sender, another - correspondent nodes. * Is there some better way to establish mapping between nodes ad WAL-seconder? */ + elog(WARNING,"Node %d is catching up", nodeId); MtmLock(LW_EXCLUSIVE); BIT_SET(Mtm->nodeLockerMask, nodeId-1); BIT_SET(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); Mtm->nLockers += 1; MtmUnlock(); + } else { + MTM_INFO("Continue recovery of node %d, slot position %lx, WAL position %lx, lockers %d\n", nodeId, MyWalSnd->sentPtr, GetXLogInsertRecPtr(), Mtm->nLockers); } return true; } @@ -1022,7 +1027,7 @@ MtmCheckClusterLock() break; } else { /* recovered replica catched up with master */ - elog(WARNING, "WAL-sender %d complete receovery", i); + elog(WARNING, "WAL-sender %d complete recovery", i); BIT_CLEAR(Mtm->walSenderLockerMask, i); } } @@ -1608,8 +1613,9 @@ void MtmReceiverStarted(int nodeId) if (!BIT_CHECK(Mtm->pglogicalNodeMask, nodeId-1)) { BIT_SET(Mtm->pglogicalNodeMask, nodeId-1); if (++Mtm->nReceivers == Mtm->nNodes-1) { - Assert(Mtm->status == MTM_CONNECTED); - MtmSwitchClusterMode(MTM_ONLINE); + if (Mtm->status == MTM_CONNECTED) { + MtmSwitchClusterMode(MTM_ONLINE); + } } } SpinLockRelease(&Mtm->spinlock); @@ -1622,10 +1628,14 @@ void MtmReceiverStarted(int nodeId) */ MtmSlotMode MtmReceiverSlotMode(int nodeId) { + bool recovery = false; while (Mtm->status != MTM_CONNECTED && Mtm->status != MTM_ONLINE) { + MTM_INFO("%d: receiver slot mode %s\n", MyProcPid, MtmNodeStatusMnem[Mtm->status]); if (Mtm->status == MTM_RECOVERY) { + recovery = true; if (Mtm->recoverySlot == 0 || Mtm->recoverySlot == nodeId) { /* Choose for recovery first available slot */ + elog(WARNING, "Start recovery from node %d", nodeId); Mtm->recoverySlot = nodeId; return SLOT_OPEN_EXISTED; } @@ -1633,8 +1643,13 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) /* delay opening of other slots until recovery is completed */ MtmSleep(STATUS_POLL_DELAY); } + if (recovery) { + elog(WARNING, "Recreate replication slot for node %d after end of recovery", nodeId); + } else { + MTM_INFO("%d: Reuse replication slot for node %d\n", MyProcPid, nodeId); + } /* After recovery completion we need to drop all other slots to avoid receive of redundant data */ - return Mtm->recoverySlot ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; + return recovery ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; } static bool MtmIsBroadcast() @@ -1690,7 +1705,11 @@ MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) static bool MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) { - return args->origin_id == InvalidRepOriginId || MtmIsRecoveredNode(MtmReplicationNodeId); + bool res = Mtm->status != MTM_RECOVERY + && (args->origin_id == InvalidRepOriginId + || MtmIsRecoveredNode(MtmReplicationNodeId)); + MTM_TRACE("%d: MtmReplicationTxnFilterHook->%d\n", MyProcPid, res); + return res; } void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks) diff --git a/multimaster.h b/multimaster.h index 97b8f54350..d9efd84035 100644 --- a/multimaster.h +++ b/multimaster.h @@ -27,6 +27,7 @@ #define MULTIMASTER_MAX_CONN_STR_SIZE 128 #define MULTIMASTER_MAX_HOST_NAME_SIZE 64 #define MULTIMASTER_BROADCAST_SERVICE "mtm_broadcast" +#define MULTIMASTER_ADMIN "mtm_admin" #define USEC 1000000 diff --git a/pglogical_proto.c b/pglogical_proto.c index e1e69af250..77c7924c4d 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -103,7 +103,7 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, { bool isRecovery = MtmIsRecoveredNode(MtmReplicationNodeId); csn_t csn = MtmTransactionSnapshot(txn->xid); - MTM_TRACE("pglogical_write_begin %d CSN=%ld\n", txn->xid, csn); + MTM_INFO("%d: pglogical_write_begin %d CSN=%ld\n", MyProcPid, txn->xid, csn); if (csn == INVALID_CSN && !isRecovery) { MtmIsFilteredTxn = true; From f78894b20294f0958c06f6852b63ac62dbfd62f7 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 29 Mar 2016 14:00:13 +0300 Subject: [PATCH 0324/1139] Recovery in progress --- arbiter.c | 2 +- multimaster.c | 28 ++++++++++++++++++++++++---- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/arbiter.c b/arbiter.c index 81c59e4e4e..0777790811 100644 --- a/arbiter.c +++ b/arbiter.c @@ -376,7 +376,7 @@ static void MtmOpenConnections() } if (Mtm->nNodes < MtmNodes/2+1) { /* no quorum */ elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", Mtm->nNodes, MtmNodes); - Mtm->status = MTM_IN_MINORITY; + MtmSwitchClusterMode(MTM_IN_MINORITY); } else if (Mtm->status == MTM_INITIALIZATION) { MtmSwitchClusterMode(MTM_CONNECTED); } diff --git a/multimaster.c b/multimaster.c index b0a28dd3d3..f5caec3e9d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -972,7 +972,13 @@ static int64 MtmGetSlotLag(int nodeId) */ bool MtmIsRecoveredNode(int nodeId) { - if (BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { + return BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)); +} + + +void MtmRecoveryPorgress(XLogRecPtr lsn) +{ + Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) && MyWalSnd->sentPtr + MtmMinRecoveryLag > GetXLogInsertRecPtr()) @@ -1134,7 +1140,7 @@ bool MtmRefreshClusterStatus(bool nowait) } } else { elog(WARNING, "Clique %lx has no quorum", clique); - Mtm->status = MTM_IN_MINORITY; + MtmSwitchClusterMode(MTM_IN_MINORITY); } return true; } @@ -1144,12 +1150,12 @@ void MtmCheckQuorum(void) if (Mtm->nNodes < MtmNodes/2+1) { if (Mtm->status == MTM_ONLINE) { /* out of quorum */ elog(WARNING, "Node is in minority: disabled mask %lx", Mtm->disabledNodeMask); - Mtm->status = MTM_IN_MINORITY; + MtmSwitchClusterMode(MTM_IN_MINORITY); } } else { if (Mtm->status == MTM_IN_MINORITY) { elog(WARNING, "Node is in majority: dissbled mask %lx", Mtm->disabledNodeMask); - Mtm->status = MTM_ONLINE; + MtmSwitchClusterMode(MTM_ONLINE); } } } @@ -1695,6 +1701,19 @@ void MtmDropNode(int nodeId, bool dropSlot) } } +static void +MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) +{ + MtmLock(LW_EXCLUSIVE); + if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { + elog(WARNING, "Recovery of node %d is completed: start normal replication", MtmReplicationNodeId); + BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); + Mtm->nNodes += 1; + MtmCheckQuorum(); + } + MtmUnlock(); +} + static void MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) { @@ -1714,6 +1733,7 @@ MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks) { + hooks->startup_hook = MtmReplicationStartupHook; hooks->shutdown_hook = MtmReplicationShutdownHook; hooks->txn_filter_hook = MtmReplicationTxnFilterHook; } From 9994464fc79e04eca58e783c5fe4b50208c05f5c Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Tue, 29 Mar 2016 18:09:51 +0300 Subject: [PATCH 0325/1139] Implement PaxosGet and PaxosSet. --- multimaster.c | 35 ++++++++++++++++++++++++++++++++--- multimaster.control | 3 ++- 2 files changed, 34 insertions(+), 4 deletions(-) diff --git a/multimaster.c b/multimaster.c index f5caec3e9d..f824cb952f 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1191,14 +1191,43 @@ void MtmOnNodeConnect(int nodeId) */ void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts, bool nowait) { - if (size != NULL) { + unsigned enclen, declen, len; + char *enc, *dec; + Assert(ts == NULL); // not implemented + + enc = raftable_get(key); + if (enc == NULL) + { *size = 0; + return NULL; + } + + enclen = strlen(enc); + declen = hex_dec_len(enc, enclen); + dec = palloc(declen); + len = hex_decode(enc, enclen, dec); + pfree(enc); + Assert(len == declen); + + if (size != NULL) { + *size = declen; } - return NULL; + return dec; } void PaxosSet(char const* key, void const* value, int size, bool nowait) -{} +{ + unsigned enclen, declen, len; + char *enc, *dec; + + enclen = hex_enc_len(value, size); + enc = palloc(enclen); + len = hex_encode(value, size, enc); + Assert(len == enclen); + + raftable_set(key, enc, nowait ? 1 : INT_MAX); + pfree(enc); +} /* diff --git a/multimaster.control b/multimaster.control index e6fd73248e..8db351f479 100644 --- a/multimaster.control +++ b/multimaster.control @@ -2,4 +2,5 @@ comment = 'Multimaster' default_version = '1.0' module_pathname = '$libdir/multimaster' schema = mtm -relocatable = false \ No newline at end of file +relocatable = false +requires = raftable From cb8d490a6f5630e0137d301de85d883b33c63990 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Tue, 29 Mar 2016 18:16:18 +0300 Subject: [PATCH 0326/1139] Fix PaxosSet not appending zero to the encoded value. --- multimaster.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index f824cb952f..fc3ae64636 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1221,9 +1221,10 @@ void PaxosSet(char const* key, void const* value, int size, bool nowait) char *enc, *dec; enclen = hex_enc_len(value, size); - enc = palloc(enclen); + enc = palloc(enclen) + 1; len = hex_encode(value, size, enc); Assert(len == enclen); + enc[len] = '\0'; raftable_set(key, enc, nowait ? 1 : INT_MAX); pfree(enc); From 0f23a548c30c8a7f62cab03eda11aad3c06f40d4 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 29 Mar 2016 18:31:17 +0300 Subject: [PATCH 0327/1139] recovery in progress --- multimaster.c | 106 +++++++++++++++++++++++++++++++------------ multimaster.h | 16 ++++--- pglogical_apply.c | 7 ++- pglogical_proto.c | 4 +- pglogical_receiver.c | 5 +- 5 files changed, 97 insertions(+), 41 deletions(-) diff --git a/multimaster.c b/multimaster.c index fc3ae64636..0982fce76e 100644 --- a/multimaster.c +++ b/multimaster.c @@ -695,6 +695,7 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) ts->votingCompleted = false; ts->cmd = MSG_INVALID; ts->nSubxids = xactGetCommittedChildren(&subxids); + Mtm->nActiveTransactions += 1; x->isPrepared = true; x->csn = ts->csn; @@ -794,6 +795,8 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) ts->status = TRANSACTION_STATUS_ABORTED; } MtmAdjustSubtransactions(ts); + Assert(Mtm->nActiveTransactions != 0); + Mtm->nActiveTransactions -= 1; } if (!commit && x->isReplicated && TransactionIdIsValid(x->gtid.xid)) { /* @@ -835,6 +838,13 @@ void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd) } } +void MtmRecoveryCompleted(void) +{ + elog(WARNING, "Recevoery of node %d is completed", MtmNodeId); + Mtm->recoverySlot = 0; + MtmSwitchClusterMode(MTM_ONLINE); +} + void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { MtmLock(LW_EXCLUSIVE); @@ -846,8 +856,7 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) Assert(Mtm->status == MTM_RECOVERY); } else if (Mtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ - Mtm->recoverySlot = 0; - MtmSwitchClusterMode(MTM_ONLINE); + MtmRecoveryCompleted(); } MtmTx.gtid = *gtid; MtmTx.xid = GetCurrentTransactionId(); @@ -972,16 +981,32 @@ static int64 MtmGetSlotLag(int nodeId) */ bool MtmIsRecoveredNode(int nodeId) { - return BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)); + return BIT_CHECK(Mtm->disabledNodeMask, nodeId-1); } -void MtmRecoveryPorgress(XLogRecPtr lsn) +bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) { - - Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ - if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) - && MyWalSnd->sentPtr + MtmMinRecoveryLag > GetXLogInsertRecPtr()) + bool caughtUp = false; + if (MtmIsRecoveredNode(nodeId)) { + XLogRecPtr walLSN = GetXLogInsertRecPtr(); + MtmLock(LW_EXCLUSIVE); + if (slotLSN == walLSN) { + if (BIT_CHECK(Mtm->nodeLockerMask, nodeId-1)) { + elog(WARNING,"Node %d is caught-up", nodeId); + BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); + BIT_CLEAR(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); + BIT_CLEAR(Mtm->nodeLockerMask, nodeId-1); + Mtm->nLockers -= 1; + } else { + elog(WARNING,"Node %d is caugth-up without locking cluster", nodeId); + /* We are lucky: caugth-up without locking cluster! */ + Mtm->nNodes += 1; + BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); + } + caughtUp = true; + } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) + && slotLSN + MtmMinRecoveryLag > walLSN) { /* * Wal sender almost catched up. @@ -989,18 +1014,19 @@ void MtmRecoveryPorgress(XLogRecPtr lsn) * We have to maintain two bitmasks: one is marking wal sender, another - correspondent nodes. * Is there some better way to establish mapping between nodes ad WAL-seconder? */ - elog(WARNING,"Node %d is catching up", nodeId); - MtmLock(LW_EXCLUSIVE); + elog(WARNING,"Node %d is almost caught-up: lock cluster", nodeId); + Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ BIT_SET(Mtm->nodeLockerMask, nodeId-1); BIT_SET(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); Mtm->nLockers += 1; - MtmUnlock(); } else { - MTM_INFO("Continue recovery of node %d, slot position %lx, WAL position %lx, lockers %d\n", nodeId, MyWalSnd->sentPtr, GetXLogInsertRecPtr(), Mtm->nLockers); + MTM_INFO("Continue recovery of node %d, slot position %lx, WAL position %lx, WAL sender position %lx, lockers %d, active transactions %d\n", nodeId, slotLSN, walLSN, MyWalSnd->sentPtr, Mtm->nLockers, Mtm->nActiveTransactions); } - return true; + MtmUnlock(); + } else { + MTM_INFO("Node %d is not in recovery mode\n", nodeId); } - return false; + return caughtUp; } void MtmSwitchClusterMode(MtmNodeStatus mode) @@ -1019,22 +1045,24 @@ void MtmSwitchClusterMode(MtmNodeStatus mode) static void MtmCheckClusterLock() { + timestamp_t delay = MIN_WAIT_TIMEOUT; while (true) { nodemask_t mask = Mtm->walSenderLockerMask; if (mask != 0) { - XLogRecPtr currLogPos = GetXLogInsertRecPtr(); - int i; - timestamp_t delay = MIN_WAIT_TIMEOUT; - for (i = 0; mask != 0; i++, mask >>= 1) { - if (mask & 1) { - if (WalSndCtl->walsnds[i].sentPtr != currLogPos) { - /* recovery is in progress */ - break; - } else { - /* recovered replica catched up with master */ - elog(WARNING, "WAL-sender %d complete recovery", i); - BIT_CLEAR(Mtm->walSenderLockerMask, i); + if (Mtm->nActiveTransactions == 0) { + XLogRecPtr currLogPos = GetXLogInsertRecPtr(); + int i; + for (i = 0; mask != 0; i++, mask >>= 1) { + if (mask & 1) { + if (WalSndCtl->walsnds[i].sentPtr != currLogPos) { + /* recovery is in progress */ + break; + } else { + /* recovered replica catched up with master */ + elog(WARNING, "WAL-sender %d complete recovery", i); + BIT_CLEAR(Mtm->walSenderLockerMask, i); + } } } } @@ -1294,6 +1322,7 @@ static void MtmInitialize() Mtm->walSenderLockerMask = 0; Mtm->nodeLockerMask = 0; Mtm->nLockers = 0; + Mtm->nActiveTransactions = 0; Mtm->votingTransactions = NULL; Mtm->transListHead = NULL; Mtm->transListTail = &Mtm->transListHead; @@ -1734,12 +1763,31 @@ void MtmDropNode(int nodeId, bool dropSlot) static void MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) { + ListCell *param; + bool isRecoverySession = false; + foreach(param, args->in_params) + { + DefElem *elem = lfirst(param); + if (strcmp("mtm_replication_mode", elem->defname) == 0) { + isRecoverySession = elem->arg != NULL && strVal(elem->arg) != NULL && strcmp(strVal(elem->arg), "recovery") == 0; + break; + } + } MtmLock(LW_EXCLUSIVE); - if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { - elog(WARNING, "Recovery of node %d is completed: start normal replication", MtmReplicationNodeId); + if (isRecoverySession) { + elog(WARNING, "Node %d start recovery of node %d", MtmNodeId, MtmReplicationNodeId); + if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { + BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); + Mtm->nNodes -= 1; + MtmCheckQuorum(); + } + } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { + elog(WARNING, "Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes += 1; MtmCheckQuorum(); + } else { + elog(NOTICE, "Node %d start logical replication to node %d in normal mode", MtmNodeId, MtmReplicationNodeId); } MtmUnlock(); } @@ -1757,7 +1805,7 @@ MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) bool res = Mtm->status != MTM_RECOVERY && (args->origin_id == InvalidRepOriginId || MtmIsRecoveredNode(MtmReplicationNodeId)); - MTM_TRACE("%d: MtmReplicationTxnFilterHook->%d\n", MyProcPid, res); + MTM_INFO("%d: MtmReplicationTxnFilterHook->%d\n", MyProcPid, res); return res; } diff --git a/multimaster.h b/multimaster.h index d9efd84035..3bf615c7c1 100644 --- a/multimaster.h +++ b/multimaster.h @@ -130,18 +130,19 @@ typedef struct nodemask_t pglogicalNodeMask; /* bitmask of started pglogic receivers */ nodemask_t walSenderLockerMask; /* Mask of WAL-senders IDs locking the cluster */ nodemask_t nodeLockerMask; /* Mask of node IDs which WAL-senders are locking the cluster */ - int nNodes; /* number of active nodes */ - int nReceivers; /* number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ - int nLockers; /* number of lockers */ - long timeShift; /* local time correction */ - csn_t csn; /* last obtained CSN: used to provide unique acending CSNs based on system time */ + int nNodes; /* Number of active nodes */ + int nReceivers; /* Number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ + int nLockers; /* Number of lockers */ + int nActiveTransactions; /* Nunmber of active 2PC transactions */ + long timeShift; /* Local time correction */ + csn_t csn; /* Last obtained CSN: used to provide unique acending CSNs based on system time */ MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. This list is used to pass information to mtm-sender BGW */ MtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. It is cleanup by MtmGetOldestXmin */ MtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. This list is expected to be in CSN ascending order, by strict order may be violated */ - uint64 transCount; /* Counter of transactions perfromed by this node */ + uint64 transCount; /* Counter of transactions perfromed by this node */ time_t nodeTransDelay[MAX_NODES]; /* Time of waiting transaction acknowledgment from node */ BgwPool pool; /* Pool of background workers for applying logical replication patches */ MtmNodeInfo nodes[1]; /* [MtmNodes]: per-node data */ @@ -200,5 +201,6 @@ extern void MtmSwitchClusterMode(MtmNodeStatus mode); extern void MtmUpdateNodeConnectionInfo(MtmConnectionInfo* conn, char const* connStr); extern void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks); extern void MtmCheckQuorum(void); - +extern bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN); +extern void MtmRecoveryCompleted(void); #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index 380b491c3e..0a425ea42c 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -497,10 +497,12 @@ process_remote_commit(StringInfo in) uint8 flags; csn_t csn; const char *gid = NULL; + bool caughtUp; /* read flags */ flags = pq_getmsgbyte(in); MtmReplicationNode = pq_getmsgbyte(in); + caughtUp = pq_getmsgbyte(in) != 0; /* read fields */ replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ @@ -568,7 +570,10 @@ process_remote_commit(StringInfo in) default: Assert(false); } - MtmEndSession(); + MtmEndSession(true); + if (caughtUp) { + MtmRecoveryCompleted(); + } } static void diff --git a/pglogical_proto.c b/pglogical_proto.c index 77c7924c4d..fd23fbc620 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -150,11 +150,12 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, pq_sendbyte(out, 'C'); /* sending COMMIT */ - MTM_TRACE("PGLOGICAL_SEND commit: event=%d, gid=%s\n", flags, txn->gid); + MTM_INFO("PGLOGICAL_SEND commit: event=%d, gid=%s, commit_lsn=%lx, txn->end_lsn=%lx, xlog=%lx\n", flags, txn->gid, commit_lsn, txn->end_lsn, GetXLogInsertRecPtr()); /* send the flags field */ pq_sendbyte(out, flags); pq_sendbyte(out, MtmNodeId); + pq_sendbyte(out, MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn)); /* send fixed fields */ pq_sendint64(out, commit_lsn); @@ -167,7 +168,6 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, if (flags != PGLOGICAL_COMMIT) { pq_sendstring(out, txn->gid); } - } /* diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 59aab99d38..d50c6c4d99 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -292,12 +292,13 @@ pglogical_receiver_main(Datum main_arg) } CommitTransactionCommand(); - appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d')", + appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d', \"mtm_replication_mode\" '%s')", args->receiver_slot, (uint32) (originStartPos >> 32), (uint32) originStartPos, MULTIMASTER_MAX_PROTO_VERSION, - MULTIMASTER_MIN_PROTO_VERSION + MULTIMASTER_MIN_PROTO_VERSION, + mode == SLOT_OPEN_EXISTED ? "recovery" : "normal" ); res = PQexec(conn, query->data); if (PQresultStatus(res) != PGRES_COPY_BOTH) From 98eb87d0d06d286911246ce5420db70ce7c2ef51 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 10:47:04 +0300 Subject: [PATCH 0328/1139] Rename paxos to taftable and make last one optionally included --- multimaster.c | 79 +++++++++++++++---------------------------- paxos.h => raftable.h | 21 +++++++----- 2 files changed, 40 insertions(+), 60 deletions(-) rename paxos.h => raftable.h (66%) diff --git a/multimaster.c b/multimaster.c index 0982fce76e..0082305a1d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -57,7 +57,7 @@ #include "multimaster.h" #include "ddd.h" -#include "paxos.h" +#include "raftable.h" typedef struct { TransactionId xid; /* local transaction ID */ @@ -178,6 +178,7 @@ static int MtmWorkers; static int MtmVacuumDelay; static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; +static bool MtmUseRaftable; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -1102,7 +1103,7 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) int i, j, n = MtmNodes; for (i = 0; i < n; i++) { if (i+1 != MtmNodeId) { - void* data = PaxosGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); + void* data = RaftableGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); if (data == NULL) { return false; } @@ -1132,7 +1133,7 @@ bool MtmRefreshClusterStatus(bool nowait) int clique_size; int i; - if (!MtmBuildConnectivityMatrix(matrix, nowait)) { + if (!MtmUseRaftable || !MtmBuildConnectivityMatrix(matrix, nowait)) { /* RAFT is not available */ return false; } @@ -1192,7 +1193,7 @@ void MtmCheckQuorum(void) void MtmOnNodeDisconnect(int nodeId) { BIT_SET(Mtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); + RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ MtmSleep(MtmKeepaliveTimeout); @@ -1211,52 +1212,9 @@ void MtmOnNodeDisconnect(int nodeId) void MtmOnNodeConnect(int nodeId) { BIT_CLEAR(Mtm->connectivityMask, nodeId-1); - PaxosSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); + RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); } -/* - * Paxos function stubs (until them are miplemented) - */ -void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts, bool nowait) -{ - unsigned enclen, declen, len; - char *enc, *dec; - Assert(ts == NULL); // not implemented - - enc = raftable_get(key); - if (enc == NULL) - { - *size = 0; - return NULL; - } - - enclen = strlen(enc); - declen = hex_dec_len(enc, enclen); - dec = palloc(declen); - len = hex_decode(enc, enclen, dec); - pfree(enc); - Assert(len == declen); - - if (size != NULL) { - *size = declen; - } - return dec; -} - -void PaxosSet(char const* key, void const* value, int size, bool nowait) -{ - unsigned enclen, declen, len; - char *enc, *dec; - - enclen = hex_enc_len(value, size); - enc = palloc(enclen) + 1; - len = hex_encode(value, size, enc); - Assert(len == enclen); - enc[len] = '\0'; - - raftable_set(key, enc, nowait ? 1 : INT_MAX); - pfree(enc); -} /* @@ -1483,6 +1441,19 @@ _PG_init(void) NULL ); + DefineCustomBoolVariable( + "multimaster.use_raftable", + "Use raftable plugin for internode communication", + NULL, + &MtmUseRaftable, + false, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.workers", "Number of multimaster executor workers per node", @@ -1773,6 +1744,10 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) break; } } + if (isRecoverySession) { + MTM_INFO("%d: PGLOGICAL startup hook\n", MyProcPid); + sleep(30); + } MtmLock(LW_EXCLUSIVE); if (isRecoverySession) { elog(WARNING, "Node %d start recovery of node %d", MtmNodeId, MtmReplicationNodeId); @@ -1805,7 +1780,7 @@ MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) bool res = Mtm->status != MTM_RECOVERY && (args->origin_id == InvalidRepOriginId || MtmIsRecoveredNode(MtmReplicationNodeId)); - MTM_INFO("%d: MtmReplicationTxnFilterHook->%d\n", MyProcPid, res); + MTM_TRACE("%d: MtmReplicationTxnFilterHook->%d\n", MyProcPid, res); return res; } @@ -2373,16 +2348,16 @@ MtmDetectGlobalDeadLock(PGPROC* proc) ByteBufferAlloc(&buf); EnumerateLocks(MtmSerializeLock, &buf); - PaxosSet(psprintf("lock-graph-%d", MtmNodeId), buf.data, buf.used, true); + RaftableSet(psprintf("lock-graph-%d", MtmNodeId), buf.data, buf.used, true); MtmGraphInit(&graph); MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.used/sizeof(GlobalTransactionId)); ByteBufferFree(&buf); for (i = 0; i < MtmNodes; i++) { if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i)) { int size; - void* data = PaxosGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); + void* data = RaftableGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); if (data == NULL) { - return true; /* Just temporary hack until no Paxos */ + return true; /* If using Raftable is disabled */ } else { MtmGraphAdd(&graph, (GlobalTransactionId*)data, size/sizeof(GlobalTransactionId)); } diff --git a/paxos.h b/raftable.h similarity index 66% rename from paxos.h rename to raftable.h index 3bcf091007..4d52e8746f 100644 --- a/paxos.h +++ b/raftable.h @@ -1,11 +1,11 @@ -#ifndef __PAXOS_H__ -#define __PAXOS_H__ +#ifndef __RAFTABLE_H__ +#define __RAFTABLE_H__ -typedef struct PaxosTimestamp { +typedef struct RaftableTimestamp { time_t time; /* local time at master */ uint32 master; /* master node for this operation */ - uint32 psn; /* PAXOS serial number */ -} PaxosTimestamp; + uint32 psn; /* RAFTABLE serial number */ +} RaftableTimestamp; /* * Get key value. @@ -15,18 +15,23 @@ typedef struct PaxosTimestamp { * If "ts" is not NULL, then it is assigned timestamp of last update of this value * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. */ -extern void* PaxosGet(char const* key, int* size, PaxosTimestamp* ts, bool nowait); +extern void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait); /* * Set new value for the specified key. IF value is NULL, then key should be deleted. * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. */ -extern void PaxosSet(char const* key, void const* value, int size, bool nowait); +extern void RaftableSet(char const* key, void const* value, int size, bool nowait); /* * If key doesn't exists or its value is not equal to the specified value then store this value and return true. * Otherwise do nothing and return false. * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. */ -extern bool PaxosCAS(char const* key, char const* value, bool nowait); +extern bool RaftableCAS(char const* key, char const* value, bool nowait); + +typedef void* (*raftable_get_t)(char const* key, int* size, int timeout); +typedef void (*raftable_set_t)(char const* key, void const* value, int size, int timeout); + + #endif From 753a875c0c39e0c3301f105906fd71b930795495 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 10:52:31 +0300 Subject: [PATCH 0329/1139] Add MtmUseRaftable config parameter --- Makefile | 4 ++-- multimaster.c | 2 +- raftable.h | 1 + 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index ca41bb95a3..e734a12292 100644 --- a/Makefile +++ b/Makefile @@ -1,12 +1,12 @@ MODULE_big = multimaster -OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o +OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o EXTENSION = multimaster DATA = multimaster--1.0.sql .PHONY: all -all: multimaster.o multimaster.so +all: multimaster.so PG_CPPFLAGS = -I$(libpq_srcdir) -DUSE_PGLOGICAL_OUTPUT SHLIB_LINK = $(libpq) diff --git a/multimaster.c b/multimaster.c index 0082305a1d..49a660d729 100644 --- a/multimaster.c +++ b/multimaster.c @@ -170,6 +170,7 @@ int MtmConnectAttempts; int MtmConnectTimeout; int MtmKeepaliveTimeout; int MtmReconnectAttempts; +bool MtmUseRaftable; MtmConnectionInfo* MtmConnections; static char* MtmConnStrs; @@ -178,7 +179,6 @@ static int MtmWorkers; static int MtmVacuumDelay; static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; -static bool MtmUseRaftable; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; diff --git a/raftable.h b/raftable.h index 4d52e8746f..b2fab8c546 100644 --- a/raftable.h +++ b/raftable.h @@ -33,5 +33,6 @@ extern bool RaftableCAS(char const* key, char const* value, bool nowait); typedef void* (*raftable_get_t)(char const* key, int* size, int timeout); typedef void (*raftable_set_t)(char const* key, void const* value, int size, int timeout); +extern bool MtmUseRaftable; #endif From fade5ab58c1376c4e761251e1de67fc6302eddf3 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 10:55:05 +0300 Subject: [PATCH 0330/1139] Remove dependency from raftable --- multimaster.control | 1 - 1 file changed, 1 deletion(-) diff --git a/multimaster.control b/multimaster.control index 8db351f479..785b96798b 100644 --- a/multimaster.control +++ b/multimaster.control @@ -3,4 +3,3 @@ default_version = '1.0' module_pathname = '$libdir/multimaster' schema = mtm relocatable = false -requires = raftable From 90ef453d6338b10435bbc05c76b347be17473bc8 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 30 Mar 2016 11:34:27 +0300 Subject: [PATCH 0331/1139] Add raftable header include in multimaster. --- Makefile | 2 ++ multimaster.c | 1 + 2 files changed, 3 insertions(+) diff --git a/Makefile b/Makefile index e734a12292..d9c4f7b00b 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,8 @@ MODULE_big = multimaster OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o +override CPPFLAGS += -I../raftable + EXTENSION = multimaster DATA = multimaster--1.0.sql diff --git a/multimaster.c b/multimaster.c index 49a660d729..510c87f7ab 100644 --- a/multimaster.c +++ b/multimaster.c @@ -55,6 +55,7 @@ #include "catalog/indexing.h" #include "pglogical_output/hooks.h" +#include "raftable.h" #include "multimaster.h" #include "ddd.h" #include "raftable.h" From 8f3970031825ed7f29e770f5ad8c8fae1bc1f23e Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 30 Mar 2016 12:03:49 +0300 Subject: [PATCH 0332/1139] Fix conflicting raftable header names. Remove raftable.o from Makefile. --- Makefile | 2 +- multimaster.c | 23 ++++++++++++++++++++++- raftable.h => raftable_wrapper.h | 4 ++-- 3 files changed, 25 insertions(+), 4 deletions(-) rename raftable.h => raftable_wrapper.h (96%) diff --git a/Makefile b/Makefile index d9c4f7b00b..5760aa658f 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ MODULE_big = multimaster -OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o +OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o override CPPFLAGS += -I../raftable diff --git a/multimaster.c b/multimaster.c index 510c87f7ab..2de4a52814 100644 --- a/multimaster.c +++ b/multimaster.c @@ -55,9 +55,9 @@ #include "catalog/indexing.h" #include "pglogical_output/hooks.h" -#include "raftable.h" #include "multimaster.h" #include "ddd.h" +#include "raftable_wrapper.h" #include "raftable.h" typedef struct { @@ -2370,3 +2370,24 @@ MtmDetectGlobalDeadLock(PGPROC* proc) } return hasDeadlock; } + +void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait) +{ + size_t s; + char *value; + Assert(ts == NULL); /* not implemented */ + value = raftable_get(key, &s); + *size = s; + return value; +} + +void RaftableSet(char const* key, void const* value, int size, bool nowait) +{ + raftable_set(key, value, size, nowait ? 0 : -1); +} + +bool RaftableCAS(char const* key, char const* value, bool nowait) +{ + Assert(false); /* not implemented */ + return false; +} diff --git a/raftable.h b/raftable_wrapper.h similarity index 96% rename from raftable.h rename to raftable_wrapper.h index b2fab8c546..2c2533f771 100644 --- a/raftable.h +++ b/raftable_wrapper.h @@ -1,5 +1,5 @@ -#ifndef __RAFTABLE_H__ -#define __RAFTABLE_H__ +#ifndef __RAFTABLE_WRAPPER_H__ +#define __RAFTABLE_WRAPPER_H__ typedef struct RaftableTimestamp { time_t time; /* local time at master */ From ba886d5fe2f8f807e1c87175f73ae9948f44ee37 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 30 Mar 2016 12:18:02 +0300 Subject: [PATCH 0333/1139] Add extra-install and shared-preload into Makefile and TAP tests. --- Makefile | 2 ++ t/001_basic_recovery.pl | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 5760aa658f..6d47c87b5b 100644 --- a/Makefile +++ b/Makefile @@ -3,6 +3,8 @@ OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_ override CPPFLAGS += -I../raftable +EXTRA_INSTALL = contrib/raftable contrib/mmts + EXTENSION = multimaster DATA = multimaster--1.0.sql diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index 69ebc7ad36..ad40713cd4 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -36,7 +36,7 @@ sub PostgresNode::inet_connstr { max_wal_senders = 10 max_replication_slots = 10 wal_level = logical - shared_preload_libraries = 'multimaster' + shared_preload_libraries = 'raftable,multimaster' multimaster.workers=4 multimaster.queue_size=10485760 # 10mb ); From 0bec1d37ca2a415b7331c270aa73b00a63d47ef2 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 30 Mar 2016 13:04:26 +0300 Subject: [PATCH 0334/1139] Add a check that Raft is configured into the set-get-cas functions. --- multimaster.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/multimaster.c b/multimaster.c index 2de4a52814..8f75d3eda3 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2375,6 +2375,9 @@ void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait { size_t s; char *value; + + if (!MtmUseRaftable) return NULL; + Assert(ts == NULL); /* not implemented */ value = raftable_get(key, &s); *size = s; @@ -2383,11 +2386,15 @@ void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait void RaftableSet(char const* key, void const* value, int size, bool nowait) { + if (!MtmUseRaftable) return; + raftable_set(key, value, size, nowait ? 0 : -1); } bool RaftableCAS(char const* key, char const* value, bool nowait) { + if (!MtmUseRaftable) return false; + Assert(false); /* not implemented */ return false; } From b2225c9103cdff87977d07af8f1eac53fea376f2 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 13:13:34 +0300 Subject: [PATCH 0335/1139] Cleanup disconnected bit for recovered node --- multimaster.c | 7 ++----- pglogical_receiver.c | 4 ++-- raftable.c | 38 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 42 insertions(+), 7 deletions(-) create mode 100644 raftable.c diff --git a/multimaster.c b/multimaster.c index 8f75d3eda3..3531500295 100644 --- a/multimaster.c +++ b/multimaster.c @@ -842,8 +842,9 @@ void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd) void MtmRecoveryCompleted(void) { - elog(WARNING, "Recevoery of node %d is completed", MtmNodeId); + elog(WARNING, "Recovery of node %d is completed", MtmNodeId); Mtm->recoverySlot = 0; + BIT_CLEAR(Mtm->disabledNodeMask, MtmNodeId-1); MtmSwitchClusterMode(MTM_ONLINE); } @@ -1745,10 +1746,6 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) break; } } - if (isRecoverySession) { - MTM_INFO("%d: PGLOGICAL startup hook\n", MyProcPid); - sleep(30); - } MtmLock(LW_EXCLUSIVE); if (isRecoverySession) { elog(WARNING, "Node %d start recovery of node %d", MtmNodeId, MtmReplicationNodeId); diff --git a/pglogical_receiver.c b/pglogical_receiver.c index d50c6c4d99..d5c73ac007 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -53,7 +53,7 @@ static volatile sig_atomic_t got_sighup = false; /* GUC variables */ static int receiver_idle_time = 0; -static bool receiver_sync_mode = false; +static bool receiver_sync_mode = true; /* Worker name */ char worker_proc[BGW_MAXLEN]; @@ -292,7 +292,7 @@ pglogical_receiver_main(Datum main_arg) } CommitTransactionCommand(); - appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d', \"mtm_replication_mode\" '%s')", + appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d', \"forward_changesets\" '1', \"mtm_replication_mode\" '%s')", args->receiver_slot, (uint32) (originStartPos >> 32), (uint32) originStartPos, diff --git a/raftable.c b/raftable.c new file mode 100644 index 0000000000..c1dcb771b2 --- /dev/null +++ b/raftable.c @@ -0,0 +1,38 @@ +#include +#include "postgres.h" +#include "raftable.h" + + +static raftable_get_t raftable_get_impl; +static raftable_set_t raftable_set_impl; + +static void RaftableResolve() +{ + if (raftable_get_impl == NULL) { + void* dll = dlopen(NULL, RTLD_NOW); + raftable_get_impl = dlsym(dll, "raftable_get"); + raftable_set_impl = dlsym(dll, "raftable_set"); + Assert(raftable_get_impl != NULL && raftable_set_impl != NULL); + } +} + +/* + * Raftable function proxies + */ +void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait) +{ + if (!MtmUseRaftable) { + return NULL; + } + RaftableResolve(); + return (*raftable_get_impl)(key, size, nowait ? 0 : -1); +} + + +void RaftableSet(char const* key, void const* value, int size, bool nowait) +{ + if (MtmUseRaftable) { + RaftableResolve(); + (*raftable_set_impl)(key, value, size, nowait ? 0 : -1); + } +} From 44a13dea75de8e15c0e59a6e60719256763a5486 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 13:24:48 +0300 Subject: [PATCH 0336/1139] Fix raftable_wrapper --- multimaster.c | 30 +----------------------------- pglogical_output.c | 10 ++++++++-- raftable.c | 14 +++++++++++--- raftable_wrapper.h | 8 ++++---- 4 files changed, 24 insertions(+), 38 deletions(-) diff --git a/multimaster.c b/multimaster.c index 3531500295..9397bae477 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2352,7 +2352,7 @@ MtmDetectGlobalDeadLock(PGPROC* proc) ByteBufferFree(&buf); for (i = 0; i < MtmNodes; i++) { if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i)) { - int size; + size_t size; void* data = RaftableGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); if (data == NULL) { return true; /* If using Raftable is disabled */ @@ -2367,31 +2367,3 @@ MtmDetectGlobalDeadLock(PGPROC* proc) } return hasDeadlock; } - -void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait) -{ - size_t s; - char *value; - - if (!MtmUseRaftable) return NULL; - - Assert(ts == NULL); /* not implemented */ - value = raftable_get(key, &s); - *size = s; - return value; -} - -void RaftableSet(char const* key, void const* value, int size, bool nowait) -{ - if (!MtmUseRaftable) return; - - raftable_set(key, value, size, nowait ? 0 : -1); -} - -bool RaftableCAS(char const* key, char const* value, bool nowait) -{ - if (!MtmUseRaftable) return false; - - Assert(false); /* not implemented */ - return false; -} diff --git a/pglogical_output.c b/pglogical_output.c index bc2cfa5e8d..958fef2d03 100644 --- a/pglogical_output.c +++ b/pglogical_output.c @@ -480,17 +480,23 @@ pg_decode_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, /* * Decide if the whole transaction with specific origin should be filtered out. */ +extern int MtmReplicationNodeId; + static bool pg_decode_origin_filter(LogicalDecodingContext *ctx, RepOriginId origin_id) { PGLogicalOutputData *data = ctx->output_plugin_private; - if (!call_txn_filter_hook(data, origin_id)) + if (!call_txn_filter_hook(data, origin_id)) { + elog(WARNING, "Record with origin %d is not sent to node %d", origin_id, MtmReplicationNodeId); return true; + } - if (!data->forward_changesets && origin_id != InvalidRepOriginId) + if (!data->forward_changesets && origin_id != InvalidRepOriginId) { + *(int*)0 = 0; return true; + } return false; } diff --git a/raftable.c b/raftable.c index c1dcb771b2..174c93977b 100644 --- a/raftable.c +++ b/raftable.c @@ -19,20 +19,28 @@ static void RaftableResolve() /* * Raftable function proxies */ -void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait) +void* RaftableGet(char const* key, size_t* size, RaftableTimestamp* ts, bool nowait) { if (!MtmUseRaftable) { return NULL; } RaftableResolve(); - return (*raftable_get_impl)(key, size, nowait ? 0 : -1); + return (*raftable_get_impl)(key, size); } -void RaftableSet(char const* key, void const* value, int size, bool nowait) +void RaftableSet(char const* key, void const* value, size_t size, bool nowait) { if (MtmUseRaftable) { RaftableResolve(); (*raftable_set_impl)(key, value, size, nowait ? 0 : -1); } } + +bool RaftableCAS(char const* key, char const* value, bool nowait) +{ + if (!MtmUseRaftable) return false; + + Assert(false); /* not implemented */ + return false; +} diff --git a/raftable_wrapper.h b/raftable_wrapper.h index 2c2533f771..139146cbf3 100644 --- a/raftable_wrapper.h +++ b/raftable_wrapper.h @@ -15,13 +15,13 @@ typedef struct RaftableTimestamp { * If "ts" is not NULL, then it is assigned timestamp of last update of this value * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. */ -extern void* RaftableGet(char const* key, int* size, RaftableTimestamp* ts, bool nowait); +extern void* RaftableGet(char const* key, size_t* size, RaftableTimestamp* ts, bool nowait); /* * Set new value for the specified key. IF value is NULL, then key should be deleted. * If RAFT master is not accessible, then depending non value of "nowait" parameter, this funciton should either block until RAFT quorum is reached, either report error. */ -extern void RaftableSet(char const* key, void const* value, int size, bool nowait); +extern void RaftableSet(char const* key, void const* value, size_t size, bool nowait); /* * If key doesn't exists or its value is not equal to the specified value then store this value and return true. @@ -30,8 +30,8 @@ extern void RaftableSet(char const* key, void const* value, int size, bool nowa */ extern bool RaftableCAS(char const* key, char const* value, bool nowait); -typedef void* (*raftable_get_t)(char const* key, int* size, int timeout); -typedef void (*raftable_set_t)(char const* key, void const* value, int size, int timeout); +typedef void* (*raftable_get_t)(char const* key, size_t* size); +typedef void (*raftable_set_t)(char const* key, void const* value, size_t size, int timeout_ms); extern bool MtmUseRaftable; From 4a9d25ab7ae457d6315ca31d00fb30a77b91968d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 13:50:43 +0300 Subject: [PATCH 0337/1139] Fix raftable_wrapper --- Makefile | 2 +- raftable.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 6d47c87b5b..6ab3120a55 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ MODULE_big = multimaster -OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o +OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o override CPPFLAGS += -I../raftable diff --git a/raftable.c b/raftable.c index 174c93977b..35f4766c56 100644 --- a/raftable.c +++ b/raftable.c @@ -1,6 +1,6 @@ #include #include "postgres.h" -#include "raftable.h" +#include "raftable_wrapper.h" static raftable_get_t raftable_get_impl; From cc46d9f1160e4bf8abd02da8d8dc9663edf2f2df Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 14:57:21 +0300 Subject: [PATCH 0338/1139] Fix bug in specifying recovery position --- arbiter.c | 2 +- multimaster.c | 3 +-- pglogical_output.c | 1 - pglogical_receiver.c | 2 +- 4 files changed, 3 insertions(+), 5 deletions(-) diff --git a/arbiter.c b/arbiter.c index 0777790811..f61c204ad1 100644 --- a/arbiter.c +++ b/arbiter.c @@ -513,7 +513,7 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) int n = 1; for (i = 0; i < MtmNodes; i++) { - if (TransactionIdIsValid(ts->xids[i])) { + if (!BIT_CHECK(Mtm->disabledNodeMask, i) && TransactionIdIsValid(ts->xids[i])) { Assert(i+1 != MtmNodeId); MtmAppendBuffer(txBuffer, ts->xids[i], i, ts); n += 1; diff --git a/multimaster.c b/multimaster.c index 9397bae477..c192119f3d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1748,7 +1748,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) } MtmLock(LW_EXCLUSIVE); if (isRecoverySession) { - elog(WARNING, "Node %d start recovery of node %d", MtmNodeId, MtmReplicationNodeId); + elog(WARNING, "%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes -= 1; @@ -1778,7 +1778,6 @@ MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) bool res = Mtm->status != MTM_RECOVERY && (args->origin_id == InvalidRepOriginId || MtmIsRecoveredNode(MtmReplicationNodeId)); - MTM_TRACE("%d: MtmReplicationTxnFilterHook->%d\n", MyProcPid, res); return res; } diff --git a/pglogical_output.c b/pglogical_output.c index 958fef2d03..6d3754bab9 100644 --- a/pglogical_output.c +++ b/pglogical_output.c @@ -489,7 +489,6 @@ pg_decode_origin_filter(LogicalDecodingContext *ctx, PGLogicalOutputData *data = ctx->output_plugin_private; if (!call_txn_filter_hook(data, origin_id)) { - elog(WARNING, "Record with origin %d is not sent to node %d", origin_id, MtmReplicationNodeId); return true; } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index d5c73ac007..20975a1e69 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -292,7 +292,7 @@ pglogical_receiver_main(Datum main_arg) } CommitTransactionCommand(); - appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %u/%u (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d', \"forward_changesets\" '1', \"mtm_replication_mode\" '%s')", + appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %x/%x (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d', \"forward_changesets\" '1', \"mtm_replication_mode\" '%s')", args->receiver_slot, (uint32) (originStartPos >> 32), (uint32) originStartPos, From 5759a8a23d39fa8f6a411f1306a9e8ed3bac96d5 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 30 Mar 2016 18:17:05 +0300 Subject: [PATCH 0339/1139] Implement the setup part of the TAP test for deadlock detection. --- t/000_deadlock.pl | 148 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 t/000_deadlock.pl diff --git a/t/000_deadlock.pl b/t/000_deadlock.pl new file mode 100644 index 0000000000..efb6a1888c --- /dev/null +++ b/t/000_deadlock.pl @@ -0,0 +1,148 @@ +use strict; +use warnings; + +use PostgresNode; +use TestLib; +use Test::More tests => 2; + +use DBI; +use DBD::Pg ':async'; + +sub query_row +{ + my ($dbi, $sql, @keys) = @_; + my $sth = $dbi->prepare($sql) || die; + $sth->execute(@keys) || die; + my $ret = $sth->fetchrow_array || undef; + print "query_row('$sql') -> $ret \n"; + return $ret; +} + +sub query_exec +{ + my ($dbi, $sql) = @_; + my $rv = $dbi->do($sql) || die; + print "query_exec('$sql')\n"; + return $rv; +} + +sub query_exec_async +{ + my ($dbi, $sql) = @_; + my $rv = $dbi->do($sql, {pg_async => PG_ASYNC}) || die; + print "query_exec('$sql')\n"; + return $rv; +} + +my %allocated_ports = (); +sub allocate_ports +{ + my @allocated_now = (); + my ($host, $ports_to_alloc) = @_; + + while ($ports_to_alloc > 0) + { + my $port = int(rand() * 16384) + 49152; + next if $allocated_ports{$port}; + print "# Checking for port $port\n"; + if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) + { + $allocated_ports{$port} = 1; + push(@allocated_now, $port); + $ports_to_alloc--; + } + } + + return @allocated_now; +} + +my $nnodes = 2; +my @nodes = (); + +# Create nodes and allocate ports +foreach my $i (1..$nnodes) +{ + my $host = "127.0.0.1"; + my ($pgport, $raftport) = allocate_ports($host, 2); + my $node = new PostgresNode("node$i", $host, $pgport); + $node->{id} = $i; + $node->{raftport} = $raftport; + push(@nodes, $node); +} + +my $mm_connstr = join(',', map { "${ \$_->connstr('postgres') }" } @nodes); +my $raft_peers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @nodes); + +print("# mm_connstr = $mm_connstr\n"); +print("# raft_peers = $raft_peers\n"); + +# Init and Configure +foreach my $node (@nodes) +{ + my $id = $node->{id}; + my $host = $node->host; + my $pgport = $node->port; + my $raftport = $node->{raftport}; + + $node->init(hba_permit_replication => 0); + $node->append_conf("postgresql.conf", qq( + listen_addresses = '$host' + unix_socket_directories = '' + port = $pgport + max_connections = 200 + shared_buffers = 1GB + max_prepared_transactions = 200 + max_worker_processes = 100 + wal_level = logical + fsync = off + max_wal_size = 100GB + min_wal_size = 1GB + max_wal_senders = 10 + wal_sender_timeout = 0 + max_replication_slots = 10 + shared_preload_libraries = 'raftable,multimaster' + multimaster.workers = 8 + multimaster.queue_size = 104857600 # 100mb + multimaster.node_id = $id + multimaster.conn_strings = '$mm_connstr' + raftable.id = $id + raftable.peers = '$raft_peers' + )); + + $node->append_conf("pg_hba.conf", qq( + local replication all trust + host replication all 127.0.0.1/32 trust + host replication all ::1/128 trust + )); +} + +# Start +foreach my $node (@nodes) +{ + $node->start(); +} + +$nodes[0]->psql("create table t(k int primary key, v text)"); +$nodes[0]->psql("insert into t values (1, 'hello'), (2, 'world')"); + +#my @conns = map { DBI->connect('DBI:Pg:' . $_->connstr()) } @nodes; +# +#query_exec($conns[0], "begin"); +#query_exec($conns[1], "begin"); +# +#query_exec($conns[0], "update t set v = 'foo' where k = 1"); +#query_exec($conns[1], "update t set v = 'bar' where k = 2"); +# +#query_exec($conns[0], "update t set v = 'bar' where k = 2"); +#query_exec($conns[1], "update t set v = 'foo' where k = 1"); +# +#query_exec_async($conns[0], "commit"); +#query_exec_async($conns[1], "commit"); +# +#my $ready = 0; +#$ready++ if $conns[0]->pg_ready; +#$ready++ if $conns[1]->pg_ready; +# +#is($ready, 1, "one of the connections is deadlocked"); +# +#sleep(2); From 7795f8882be41fcf5c621bfb4059e6f980fe1b5d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 30 Mar 2016 19:56:05 +0300 Subject: [PATCH 0340/1139] More trace --- arbiter.c | 2 ++ multimaster.c | 2 +- multimaster.h | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/arbiter.c b/arbiter.c index f61c204ad1..dfe9333008 100644 --- a/arbiter.c +++ b/arbiter.c @@ -688,6 +688,8 @@ static void MtmTransReceiver(Datum arg) if ((~msg->disabledNodeMask & Mtm->disabledNodeMask) != 0) { /* Coordinator's disabled mask is wider than of this node: so reject such transaction to avoid commit on smaller subset of nodes */ + elog(WARNING, "Coordinator of distributed transaction see less nodes than node %d: %lx instead of %lx", + msg->node, Mtm->disabledNodeMask, msg->disabledNodeMask); ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); } diff --git a/multimaster.c b/multimaster.c index c192119f3d..42ee863600 100644 --- a/multimaster.c +++ b/multimaster.c @@ -636,7 +636,7 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->isPrepared = false; x->isTransactionBlock = IsTransactionBlock(); /* Application name can be cahnged usnig PGAPPNAME environment variable */ - if (x->isDistributed && Mtm->status != MTM_ONLINE && strcmp(application_name, MULTIMASTER_ADMIN) != 0) { + if (!IsBackgroundWorker && x->isDistributed && Mtm->status != MTM_ONLINE && strcmp(application_name, MULTIMASTER_ADMIN) != 0) { /* reject all user's transactions at offline cluster */ MtmUnlock(); elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[Mtm->status]); diff --git a/multimaster.h b/multimaster.h index 3bf615c7c1..e50cee26d0 100644 --- a/multimaster.h +++ b/multimaster.h @@ -8,7 +8,7 @@ #include "pglogical_output/hooks.h" #define MTM_TUPLE_TRACE(fmt, ...) -#if 0 +#if 1 #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #else From 50a052c319d24f5e020ea0dd23e93baedd2a6761 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Thu, 31 Mar 2016 00:01:34 +0300 Subject: [PATCH 0341/1139] Recvoery bug fixing --- arbiter.c | 3 ++- multimaster.c | 23 ++++++++++++++++------- pglogical_apply.c | 4 ++-- pglogical_proto.c | 3 ++- 4 files changed, 22 insertions(+), 11 deletions(-) diff --git a/arbiter.c b/arbiter.c index dfe9333008..9d261df63e 100644 --- a/arbiter.c +++ b/arbiter.c @@ -386,7 +386,7 @@ static void MtmOpenConnections() static bool MtmSendToNode(int node, void const* buf, int size) { while (sockets[node] < 0 || !MtmWriteSocket(sockets[node], buf, size)) { - elog(WARNING, "Arbiter failed to write socket: %d", errno); + elog(WARNING, "Arbiter failed to write to node %d: %d", node+1, errno); if (sockets[node] >= 0) { close(sockets[node]); } @@ -395,6 +395,7 @@ static bool MtmSendToNode(int node, void const* buf, int size) MtmOnNodeDisconnect(node+1); return false; } + elog(NOTICE, "Arbiter restablish connection with node %d", node+1); } return true; } diff --git a/multimaster.c b/multimaster.c index 42ee863600..ac16241d69 100644 --- a/multimaster.c +++ b/multimaster.c @@ -672,7 +672,7 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) if (Mtm->disabledNodeMask != 0) { MtmRefreshClusterStatus(true); - if (Mtm->status != MTM_ONLINE) { + if (!IsBackgroundWorker && Mtm->status != MTM_ONLINE) { elog(ERROR, "Abort current transaction because this cluster node is not online"); } } @@ -682,7 +682,9 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) /* * Check if there is global multimaster lock preventing new transaction from commit to make a chance to wal-senders to catch-up */ - MtmCheckClusterLock(); + if (!x->isReplicated) { + MtmCheckClusterLock(); + } ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, NULL); ts->status = TRANSACTION_STATUS_IN_PROGRESS; @@ -994,21 +996,23 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) if (MtmIsRecoveredNode(nodeId)) { XLogRecPtr walLSN = GetXLogInsertRecPtr(); MtmLock(LW_EXCLUSIVE); +#if 0 if (slotLSN == walLSN) { if (BIT_CHECK(Mtm->nodeLockerMask, nodeId-1)) { elog(WARNING,"Node %d is caught-up", nodeId); - BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); BIT_CLEAR(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); BIT_CLEAR(Mtm->nodeLockerMask, nodeId-1); Mtm->nLockers -= 1; } else { elog(WARNING,"Node %d is caugth-up without locking cluster", nodeId); /* We are lucky: caugth-up without locking cluster! */ - Mtm->nNodes += 1; - BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); } + BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); + Mtm->nNodes += 1; caughtUp = true; - } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) + } else +#endif + if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) && slotLSN + MtmMinRecoveryLag > walLSN) { /* @@ -2248,7 +2252,12 @@ MtmExecutorFinish(QueryDesc *queryDesc) void MtmExecute(void* work, int size) { - BgwPoolExecute(&Mtm->pool, work, size); + if (Mtm->status == MTM_RECOVERY) { + /* During recovery apply changes sequentially to preserve commit order */ + MtmExecutor(0, work, size); + } else { + BgwPoolExecute(&Mtm->pool, work, size); + } } static BgwPool* diff --git a/pglogical_apply.c b/pglogical_apply.c index 0a425ea42c..a73e5b4d68 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -497,12 +497,12 @@ process_remote_commit(StringInfo in) uint8 flags; csn_t csn; const char *gid = NULL; - bool caughtUp; + bool caughtUp = false; /* read flags */ flags = pq_getmsgbyte(in); MtmReplicationNode = pq_getmsgbyte(in); - caughtUp = pq_getmsgbyte(in) != 0; + /*caughtUp = pq_getmsgbyte(in) != 0;*/ /* read fields */ replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ diff --git a/pglogical_proto.c b/pglogical_proto.c index fd23fbc620..4cc3590d6e 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -147,6 +147,7 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, return; } } + MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn); pq_sendbyte(out, 'C'); /* sending COMMIT */ @@ -155,7 +156,7 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, /* send the flags field */ pq_sendbyte(out, flags); pq_sendbyte(out, MtmNodeId); - pq_sendbyte(out, MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn)); + /*pq_sendbyte(out, MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn));*/ /* send fixed fields */ pq_sendint64(out, commit_lsn); From aface56d1884e0ba57dff98ea8e3fe2778094b0a Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 31 Mar 2016 09:04:54 +0300 Subject: [PATCH 0342/1139] Undo changes around MtmRecoveryCaughtUp --- multimaster.c | 5 +---- pglogical_apply.c | 4 ++-- pglogical_proto.c | 4 +--- 3 files changed, 4 insertions(+), 9 deletions(-) diff --git a/multimaster.c b/multimaster.c index ac16241d69..7c654f9646 100644 --- a/multimaster.c +++ b/multimaster.c @@ -996,7 +996,6 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) if (MtmIsRecoveredNode(nodeId)) { XLogRecPtr walLSN = GetXLogInsertRecPtr(); MtmLock(LW_EXCLUSIVE); -#if 0 if (slotLSN == walLSN) { if (BIT_CHECK(Mtm->nodeLockerMask, nodeId-1)) { elog(WARNING,"Node %d is caught-up", nodeId); @@ -1010,9 +1009,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes += 1; caughtUp = true; - } else -#endif - if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) + } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) && slotLSN + MtmMinRecoveryLag > walLSN) { /* diff --git a/pglogical_apply.c b/pglogical_apply.c index a73e5b4d68..0a425ea42c 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -497,12 +497,12 @@ process_remote_commit(StringInfo in) uint8 flags; csn_t csn; const char *gid = NULL; - bool caughtUp = false; + bool caughtUp; /* read flags */ flags = pq_getmsgbyte(in); MtmReplicationNode = pq_getmsgbyte(in); - /*caughtUp = pq_getmsgbyte(in) != 0;*/ + caughtUp = pq_getmsgbyte(in) != 0; /* read fields */ replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ diff --git a/pglogical_proto.c b/pglogical_proto.c index 4cc3590d6e..53d88b8e16 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -147,8 +147,6 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, return; } } - MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn); - pq_sendbyte(out, 'C'); /* sending COMMIT */ MTM_INFO("PGLOGICAL_SEND commit: event=%d, gid=%s, commit_lsn=%lx, txn->end_lsn=%lx, xlog=%lx\n", flags, txn->gid, commit_lsn, txn->end_lsn, GetXLogInsertRecPtr()); @@ -156,7 +154,7 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, /* send the flags field */ pq_sendbyte(out, flags); pq_sendbyte(out, MtmNodeId); - /*pq_sendbyte(out, MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn));*/ + pq_sendbyte(out, MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn)); /* send fixed fields */ pq_sendint64(out, commit_lsn); From d29666d66edd6faac4a46d054bb3facd7e963b77 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 31 Mar 2016 13:19:19 +0300 Subject: [PATCH 0343/1139] some fixes in recovery --- multimaster.c | 66 ++++++++++++++++++++++++++++------------------- multimaster.h | 3 +++ pglogical_apply.c | 4 +-- pglogical_proto.c | 8 +++--- 4 files changed, 49 insertions(+), 32 deletions(-) diff --git a/multimaster.c b/multimaster.c index 7c654f9646..68d02061c1 100644 --- a/multimaster.c +++ b/multimaster.c @@ -635,9 +635,11 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->isDistributed = MtmIsUserTransaction(); x->isPrepared = false; x->isTransactionBlock = IsTransactionBlock(); - /* Application name can be cahnged usnig PGAPPNAME environment variable */ + /* Application name can be changed usnig PGAPPNAME environment variable */ if (!IsBackgroundWorker && x->isDistributed && Mtm->status != MTM_ONLINE && strcmp(application_name, MULTIMASTER_ADMIN) != 0) { - /* reject all user's transactions at offline cluster */ + /* Reject all user's transactions at offline cluster. + * Allow execution of transaction by bg-workers to make it possible to perform recovery. + */ MtmUnlock(); elog(ERROR, "Multimaster node is not online: current status %s", MtmNodeStatusMnem[Mtm->status]); } @@ -673,14 +675,17 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) if (Mtm->disabledNodeMask != 0) { MtmRefreshClusterStatus(true); if (!IsBackgroundWorker && Mtm->status != MTM_ONLINE) { - elog(ERROR, "Abort current transaction because this cluster node is not online"); + /* Do not take in accoutn bg-workers which are performing recovery */ + elog(ERROR, "Abort current transaction because this cluster node is in %s status", MtmNodeStatusMnem[Mtm->status]); } } MtmLock(LW_EXCLUSIVE); /* - * Check if there is global multimaster lock preventing new transaction from commit to make a chance to wal-senders to catch-up + * Check if there is global multimaster lock preventing new transaction from commit to make a chance to wal-senders to catch-up. + * Only "own" transactions are blacked. Transactions replicated from other nodes (including recovered transaction) should be proceeded + * and should not cause cluster status change. */ if (!x->isReplicated) { MtmCheckClusterLock(); @@ -716,7 +721,8 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) } MtmTransactionListAppend(ts); MtmAddSubtransactions(ts, subxids, ts->nSubxids); - MTM_TRACE("%d: MtmPrePrepareTransaction prepare commit of %d CSN=%ld\n", MyProcPid, x->xid, ts->csn); + MTM_TRACE("%d: MtmPrePrepareTransaction prepare commit of %d (gtid.xid=%d, gtid.node=%d, CSN=%ld)\n", + MyProcPid, x->xid, ts->gtid.xid, ts->gtid.node, ts->csn); MtmUnlock(); } @@ -842,14 +848,6 @@ void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd) } } -void MtmRecoveryCompleted(void) -{ - elog(WARNING, "Recovery of node %d is completed", MtmNodeId); - Mtm->recoverySlot = 0; - BIT_CLEAR(Mtm->disabledNodeMask, MtmNodeId-1); - MtmSwitchClusterMode(MTM_ONLINE); -} - void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { MtmLock(LW_EXCLUSIVE); @@ -933,6 +931,18 @@ csn_t MtmGetTransactionCSN(TransactionId xid) * ------------------------------------------- */ +void MtmRecoveryCompleted(void) +{ + elog(WARNING, "Recovery of node %d is completed", MtmNodeId); + MtmLock(LW_EXCLUSIVE); + Mtm->recoverySlot = 0; + BIT_CLEAR(Mtm->disabledNodeMask, MtmNodeId-1); + /* Mode will be changed to online once all locagical reciever are connected */ + MtmSwitchClusterMode(MTM_CONNECTED); + MtmUnlock(); +} + + /** * Check state of replication slots. If some of them are too much lag behind wal, then drop this slots to avoid @@ -993,10 +1003,10 @@ bool MtmIsRecoveredNode(int nodeId) bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) { bool caughtUp = false; + MtmLock(LW_EXCLUSIVE); if (MtmIsRecoveredNode(nodeId)) { XLogRecPtr walLSN = GetXLogInsertRecPtr(); - MtmLock(LW_EXCLUSIVE); - if (slotLSN == walLSN) { + if (slotLSN == walLSN && Mtm->nActiveTransactions == 0) { if (BIT_CHECK(Mtm->nodeLockerMask, nodeId-1)) { elog(WARNING,"Node %d is caught-up", nodeId); BIT_CLEAR(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); @@ -1018,7 +1028,8 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) * We have to maintain two bitmasks: one is marking wal sender, another - correspondent nodes. * Is there some better way to establish mapping between nodes ad WAL-seconder? */ - elog(WARNING,"Node %d is almost caught-up: lock cluster", nodeId); + elog(WARNING,"Node %d is almost caught-up: slot position %lx, WAL position %lx, active transactions %d", + nodeId, slotLSN, walLSN, Mtm->nActiveTransactions); Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ BIT_SET(Mtm->nodeLockerMask, nodeId-1); BIT_SET(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); @@ -1026,10 +1037,8 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) } else { MTM_INFO("Continue recovery of node %d, slot position %lx, WAL position %lx, WAL sender position %lx, lockers %d, active transactions %d\n", nodeId, slotLSN, walLSN, MyWalSnd->sentPtr, Mtm->nLockers, Mtm->nActiveTransactions); } - MtmUnlock(); - } else { - MTM_INFO("Node %d is not in recovery mode\n", nodeId); } + MtmUnlock(); return caughtUp; } @@ -1044,7 +1053,7 @@ void MtmSwitchClusterMode(MtmNodeStatus mode) /* * If there are recovering nodes which are catching-up WAL, check the status and prevent new transaction from commit to give * WAL-sender a chance to catch-up WAL, completely synchronize replica and switch it to normal mode. - * This function is called at transaction start with multimaster lock set + * This function is called before transaction prepare with multimaster lock set. */ static void MtmCheckClusterLock() @@ -1071,8 +1080,8 @@ MtmCheckClusterLock() } } if (mask != 0) { - /* some "almost catch-up" wal-senders are still working */ - /* Do not start new transactions until them complete */ + /* some "almost catch-up" wal-senders are still working. */ + /* Do not start new transactions until them are completed. */ MtmUnlock(); MtmSleep(delay); if (delay*2 <= MAX_WAIT_TIMEOUT) { @@ -1215,6 +1224,7 @@ void MtmOnNodeDisconnect(int nodeId) void MtmOnNodeConnect(int nodeId) { BIT_CLEAR(Mtm->connectivityMask, nodeId-1); + elog(NOTICE, "Reconnect node %d", nodeId); RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); } @@ -1645,10 +1655,14 @@ _PG_fini(void) } - +/* + * This functions is called by pglogical receiver main function when receiver background worker is started. + * We switch to ONLINE mode when all receviers are connected. + * As far as background worker can be restarted multiple times, use node bitmask. + */ void MtmReceiverStarted(int nodeId) { - SpinLockAcquire(&Mtm->spinlock); + MtmLock(LW_EXCLUSIVE); if (!BIT_CHECK(Mtm->pglogicalNodeMask, nodeId-1)) { BIT_SET(Mtm->pglogicalNodeMask, nodeId-1); if (++Mtm->nReceivers == Mtm->nNodes-1) { @@ -1656,8 +1670,8 @@ void MtmReceiverStarted(int nodeId) MtmSwitchClusterMode(MTM_ONLINE); } } - } - SpinLockRelease(&Mtm->spinlock); + } + MtmUnlock(); } /* diff --git a/multimaster.h b/multimaster.h index e50cee26d0..f2c24e257f 100644 --- a/multimaster.h +++ b/multimaster.h @@ -45,6 +45,9 @@ typedef uint64 csn_t; /* commit serial number */ #define PGLOGICAL_XACT_EVENT(flags) (flags & 0x03) +#define PGLOGICAL_CAUGHT_UP 0x04 + + typedef uint64 timestamp_t; /* Identifier of global transaction */ diff --git a/pglogical_apply.c b/pglogical_apply.c index 0a425ea42c..1749c15702 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -497,12 +497,10 @@ process_remote_commit(StringInfo in) uint8 flags; csn_t csn; const char *gid = NULL; - bool caughtUp; /* read flags */ flags = pq_getmsgbyte(in); MtmReplicationNode = pq_getmsgbyte(in); - caughtUp = pq_getmsgbyte(in) != 0; /* read fields */ replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ @@ -571,7 +569,7 @@ process_remote_commit(StringInfo in) Assert(false); } MtmEndSession(true); - if (caughtUp) { + if (flags & PGLOGICAL_CAUGHT_UP) { MtmRecoveryCompleted(); } } diff --git a/pglogical_proto.c b/pglogical_proto.c index 53d88b8e16..1f3431630a 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -103,7 +103,7 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, { bool isRecovery = MtmIsRecoveredNode(MtmReplicationNodeId); csn_t csn = MtmTransactionSnapshot(txn->xid); - MTM_INFO("%d: pglogical_write_begin %d CSN=%ld\n", MyProcPid, txn->xid, csn); + MTM_INFO("%d: pglogical_write_begin XID=%d node=%d CSN=%ld recovery=%d\n", MyProcPid, txn->xid, MtmReplicationNodeId, csn, isRecovery); if (csn == INVALID_CSN && !isRecovery) { MtmIsFilteredTxn = true; @@ -124,7 +124,7 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, ReorderBufferTXN *txn, XLogRecPtr commit_lsn) { uint8 flags = 0; - + if (txn->xact_action == XLOG_XACT_COMMIT) flags = PGLOGICAL_COMMIT; else if (txn->xact_action == XLOG_XACT_PREPARE) @@ -146,6 +146,9 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, if (csn == INVALID_CSN && !isRecovery) { return; } + if (MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn)) { + flags |= PGLOGICAL_CAUGHT_UP; + } } pq_sendbyte(out, 'C'); /* sending COMMIT */ @@ -154,7 +157,6 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, /* send the flags field */ pq_sendbyte(out, flags); pq_sendbyte(out, MtmNodeId); - pq_sendbyte(out, MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn)); /* send fixed fields */ pq_sendint64(out, commit_lsn); From e62a7968d8900ee0123f00873bb1ae20ebc9f802 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 31 Mar 2016 17:05:45 +0300 Subject: [PATCH 0344/1139] Fix recovery --- arbiter.c | 38 ++++++++++++++++++++++---------------- bgwpool.h | 2 +- multimaster.c | 12 ++++++++++-- multimaster.h | 2 ++ pglogical_apply.c | 2 +- pglogical_proto.c | 4 ++-- raftable.c | 20 +++----------------- raftable_wrapper.h | 3 --- tests/postgresql.conf.mm | 2 +- 9 files changed, 42 insertions(+), 43 deletions(-) diff --git a/arbiter.c b/arbiter.c index 9d261df63e..a3e00b3ed4 100644 --- a/arbiter.c +++ b/arbiter.c @@ -289,8 +289,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) elog(ERROR, "Arbiter failed to resolve host '%s' by name", host); } -Retry: - + Retry: while (1) { int rc = -1; @@ -384,20 +383,29 @@ static void MtmOpenConnections() static bool MtmSendToNode(int node, void const* buf, int size) -{ - while (sockets[node] < 0 || !MtmWriteSocket(sockets[node], buf, size)) { - elog(WARNING, "Arbiter failed to write to node %d: %d", node+1, errno); - if (sockets[node] >= 0) { +{ + while (true) { + if (sockets[node] >= 0 && BIT_CHECK(Mtm->reconnectMask, node)) { + elog(WARNING, "Arbiter is forced to reconnect to node %d", node+1); + BIT_CLEAR(Mtm->reconnectMask, node); close(sockets[node]); + sockets[node] = -1; } - sockets[node] = MtmConnectSocket(Mtm->nodes[node].con.hostName, MtmArbiterPort + node + 1, MtmReconnectAttempts); - if (sockets[node] < 0) { - MtmOnNodeDisconnect(node+1); - return false; + if (sockets[node] < 0 || !MtmWriteSocket(sockets[node], buf, size)) { + if (sockets[node] >= 0) { + elog(WARNING, "Arbiter failed to write to node %d: %d", node+1, errno); + close(sockets[node]); + } + sockets[node] = MtmConnectSocket(Mtm->nodes[node].con.hostName, MtmArbiterPort + node + 1, MtmReconnectAttempts); + if (sockets[node] < 0) { + MtmOnNodeDisconnect(node+1); + return false; + } + MTM_TRACE("Arbiter restablished connection with node %d\n", node+1); + } else { + return true; } - elog(NOTICE, "Arbiter restablish connection with node %d", node+1); } - return true; } static int MtmReadFromNode(int node, void* buf, int buf_size) @@ -477,10 +485,6 @@ static void MtmAcceptIncomingConnections() sockets[MtmNodeId-1] = gateway; MtmRegisterSocket(gateway, MtmNodeId-1); - - for (i = 0; i < MtmNodes-1; i++) { - MtmAcceptOneConnection(); - } } @@ -693,6 +697,7 @@ static void MtmTransReceiver(Datum arg) msg->node, Mtm->disabledNodeMask, msg->disabledNodeMask); ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); + Mtm->nActiveTransactions -= 1; } if (++ts->nVotes == Mtm->nNodes) { @@ -712,6 +717,7 @@ static void MtmTransReceiver(Datum arg) Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); ts->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(ts); + Mtm->nActiveTransactions -= 1; } if (++ts->nVotes == Mtm->nNodes) { MtmWakeUpBackend(ts); diff --git a/bgwpool.h b/bgwpool.h index 822ec4b93c..d05eb32120 100644 --- a/bgwpool.h +++ b/bgwpool.h @@ -8,7 +8,7 @@ typedef void(*BgwPoolExecutor)(int id, void* work, size_t size); #define MAX_DBNAME_LEN 30 -#define MULTIMASTER_BGW_RESTART_TIMEOUT 10 /* seconds */ +#define MULTIMASTER_BGW_RESTART_TIMEOUT 1 /* seconds */ typedef struct { diff --git a/multimaster.c b/multimaster.c index 68d02061c1..8925ae0cb5 100644 --- a/multimaster.c +++ b/multimaster.c @@ -736,11 +736,15 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); - if (!MtmIsCoordinator(ts)) { + if (!MtmIsCoordinator(ts) || Mtm->status == MTM_RECOVERY) { MtmTransMap* tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_ENTER, NULL); Assert(x->gid[0]); tm->state = ts; - MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ + if (Mtm->status != MTM_RECOVERY) { + MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ + } else { + ts->status = TRANSACTION_STATUS_UNKNOWN; + } MtmUnlock(); MtmResetTransaction(x); } else { @@ -769,6 +773,7 @@ MtmAbortPreparedTransaction(MtmCurrentTrans* x) Assert(tm != NULL); tm->state->status = TRANSACTION_STATUS_ABORTED; MtmAdjustSubtransactions(tm->state); + Mtm->nActiveTransactions -= 1; MtmUnlock(); x->status = TRANSACTION_STATUS_ABORTED; } @@ -809,6 +814,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) Mtm->nActiveTransactions -= 1; } if (!commit && x->isReplicated && TransactionIdIsValid(x->gtid.xid)) { + Assert(Mtm->status != MTM_RECOVERY); /* * Send notification only if ABORT happens during transaction processing at replicas, * do not send notification if ABORT is receiver from master @@ -1205,6 +1211,7 @@ void MtmCheckQuorum(void) void MtmOnNodeDisconnect(int nodeId) { BIT_SET(Mtm->connectivityMask, nodeId-1); + BIT_SET(Mtm->reconnectMask, nodeId-1); RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ @@ -1292,6 +1299,7 @@ static void MtmInitialize() Mtm->pglogicalNodeMask = 0; Mtm->walSenderLockerMask = 0; Mtm->nodeLockerMask = 0; + Mtm->reconnectMask = 0; Mtm->nLockers = 0; Mtm->nActiveTransactions = 0; Mtm->votingTransactions = NULL; diff --git a/multimaster.h b/multimaster.h index f2c24e257f..4d3179dc4f 100644 --- a/multimaster.h +++ b/multimaster.h @@ -133,6 +133,8 @@ typedef struct nodemask_t pglogicalNodeMask; /* bitmask of started pglogic receivers */ nodemask_t walSenderLockerMask; /* Mask of WAL-senders IDs locking the cluster */ nodemask_t nodeLockerMask; /* Mask of node IDs which WAL-senders are locking the cluster */ + nodemask_t reconnectMask; /* Mask of nodes connection to which has to be reestablished by sender */ + int nNodes; /* Number of active nodes */ int nReceivers; /* Number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ int nLockers; /* Number of lockers */ diff --git a/pglogical_apply.c b/pglogical_apply.c index 1749c15702..60e06a5d81 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -902,7 +902,7 @@ void MtmExecutor(int id, void* work, size_t size) { while (true) { char action = pq_getmsgbyte(&s); - MTM_TRACE("%d: REMOTE process actiob %c\n", MyProcPid, action); + MTM_TRACE("%d: REMOTE process action %c\n", MyProcPid, action); switch (action) { /* BEGIN */ case 'B': diff --git a/pglogical_proto.c b/pglogical_proto.c index 1f3431630a..9c0e7f3de1 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -163,10 +163,10 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, pq_sendint64(out, txn->end_lsn); pq_sendint64(out, txn->commit_time); - if (flags == PGLOGICAL_COMMIT_PREPARED) { + if (txn->xact_action == XLOG_XACT_COMMIT_PREPARED) { pq_sendint64(out, MtmGetTransactionCSN(txn->xid)); } - if (flags != PGLOGICAL_COMMIT) { + if (txn->xact_action != XLOG_XACT_COMMIT) { pq_sendstring(out, txn->gid); } } diff --git a/raftable.c b/raftable.c index 35f4766c56..90503c2288 100644 --- a/raftable.c +++ b/raftable.c @@ -1,21 +1,9 @@ #include #include "postgres.h" +#include "raftable.h" #include "raftable_wrapper.h" -static raftable_get_t raftable_get_impl; -static raftable_set_t raftable_set_impl; - -static void RaftableResolve() -{ - if (raftable_get_impl == NULL) { - void* dll = dlopen(NULL, RTLD_NOW); - raftable_get_impl = dlsym(dll, "raftable_get"); - raftable_set_impl = dlsym(dll, "raftable_set"); - Assert(raftable_get_impl != NULL && raftable_set_impl != NULL); - } -} - /* * Raftable function proxies */ @@ -24,16 +12,14 @@ void* RaftableGet(char const* key, size_t* size, RaftableTimestamp* ts, bool now if (!MtmUseRaftable) { return NULL; } - RaftableResolve(); - return (*raftable_get_impl)(key, size); + return raftable_get(key, size); } void RaftableSet(char const* key, void const* value, size_t size, bool nowait) { if (MtmUseRaftable) { - RaftableResolve(); - (*raftable_set_impl)(key, value, size, nowait ? 0 : -1); + raftable_set(key, value, size, nowait ? 0 : -1); } } diff --git a/raftable_wrapper.h b/raftable_wrapper.h index 139146cbf3..245c013d47 100644 --- a/raftable_wrapper.h +++ b/raftable_wrapper.h @@ -30,9 +30,6 @@ extern void RaftableSet(char const* key, void const* value, size_t size, bool n */ extern bool RaftableCAS(char const* key, char const* value, bool nowait); -typedef void* (*raftable_get_t)(char const* key, size_t* size); -typedef void (*raftable_set_t)(char const* key, void const* value, size_t size, int timeout_ms); - extern bool MtmUseRaftable; #endif diff --git a/tests/postgresql.conf.mm b/tests/postgresql.conf.mm index 6c9f04d0ce..bc5dcddde9 100644 --- a/tests/postgresql.conf.mm +++ b/tests/postgresql.conf.mm @@ -144,7 +144,7 @@ #max_files_per_process = 1000 # min 25 # (change requires restart) -shared_preload_libraries = 'multimaster' # (change requires restart) +shared_preload_libraries = 'raftable,multimaster' # (change requires restart) # - Cost-Based Vacuum Delay - From 31208e76c48df5437e352d47eb65297693404177 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Thu, 31 Mar 2016 17:19:44 +0300 Subject: [PATCH 0345/1139] Implement two async transactions in the deadlock tap test. --- t/000_deadlock.pl | 73 ++++++++++++++++++++++++++--------------------- 1 file changed, 41 insertions(+), 32 deletions(-) diff --git a/t/000_deadlock.pl b/t/000_deadlock.pl index efb6a1888c..76f1e50436 100644 --- a/t/000_deadlock.pl +++ b/t/000_deadlock.pl @@ -22,7 +22,7 @@ sub query_exec { my ($dbi, $sql) = @_; my $rv = $dbi->do($sql) || die; - print "query_exec('$sql')\n"; + print "query_exec('$sql') = $rv\n"; return $rv; } @@ -30,7 +30,7 @@ sub query_exec_async { my ($dbi, $sql) = @_; my $rv = $dbi->do($sql, {pg_async => PG_ASYNC}) || die; - print "query_exec('$sql')\n"; + print "query_exec_async('$sql') = $rv\n"; return $rv; } @@ -56,7 +56,7 @@ sub allocate_ports return @allocated_now; } -my $nnodes = 2; +my $nnodes = 3; my @nodes = (); # Create nodes and allocate ports @@ -89,22 +89,19 @@ sub allocate_ports listen_addresses = '$host' unix_socket_directories = '' port = $pgport - max_connections = 200 - shared_buffers = 1GB - max_prepared_transactions = 200 - max_worker_processes = 100 + max_prepared_transactions = 10 + max_worker_processes = 10 wal_level = logical fsync = off - max_wal_size = 100GB - min_wal_size = 1GB max_wal_senders = 10 wal_sender_timeout = 0 max_replication_slots = 10 shared_preload_libraries = 'raftable,multimaster' - multimaster.workers = 8 - multimaster.queue_size = 104857600 # 100mb + multimaster.workers = 4 + multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$mm_connstr' + multimaster.use_raftable = true raftable.id = $id raftable.peers = '$raft_peers' )); @@ -122,27 +119,39 @@ sub allocate_ports $node->start(); } -$nodes[0]->psql("create table t(k int primary key, v text)"); -$nodes[0]->psql("insert into t values (1, 'hello'), (2, 'world')"); +my ($rc, $out, $err); +sleep(10); -#my @conns = map { DBI->connect('DBI:Pg:' . $_->connstr()) } @nodes; -# -#query_exec($conns[0], "begin"); -#query_exec($conns[1], "begin"); -# -#query_exec($conns[0], "update t set v = 'foo' where k = 1"); -#query_exec($conns[1], "update t set v = 'bar' where k = 2"); -# -#query_exec($conns[0], "update t set v = 'bar' where k = 2"); -#query_exec($conns[1], "update t set v = 'foo' where k = 1"); -# -#query_exec_async($conns[0], "commit"); -#query_exec_async($conns[1], "commit"); -# -#my $ready = 0; -#$ready++ if $conns[0]->pg_ready; -#$ready++ if $conns[1]->pg_ready; -# -#is($ready, 1, "one of the connections is deadlocked"); +$nodes[0]->psql('postgres', "create table t(k int primary key, v text)"); +$nodes[0]->psql('postgres', "insert into t values (1, 'hello'), (2, 'world')"); + +#sub space2semicol +#{ +# my $str = shift; +# $str =~ tr/ /;/; +# return $str; +#} # +my @conns = map { DBI->connect('DBI:Pg:' . $_->connstr()) } @nodes; + +query_exec($conns[0], "begin"); +query_exec($conns[1], "begin"); + +query_exec($conns[0], "update t set v = 'asd' where k = 1"); +query_exec($conns[1], "update t set v = 'bsd' where k = 2"); + +query_exec($conns[0], "update t set v = 'bar' where k = 2"); +query_exec($conns[1], "update t set v = 'foo' where k = 1"); + +query_exec_async($conns[0], "commit"); +query_exec_async($conns[1], "commit"); + +for my $i (1..2) +{ + ($rc, $out, $err) = $nodes[$i]->psql('postgres', "select * from t"); + print(" rc[$i] = $rc\n"); + print("out[$i] = $out\n"); + print("err[$i] = $err\n"); +} + #sleep(2); From 6c714673cd2a4f1923b8431288ca74038c1b1c0a Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Thu, 31 Mar 2016 17:59:53 +0300 Subject: [PATCH 0346/1139] mm relication test --- t/001_basic_recovery.pl | 45 +++++++++++++++-------------------------- 1 file changed, 16 insertions(+), 29 deletions(-) diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index ad40713cd4..3546f793b6 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -2,7 +2,7 @@ use warnings; use PostgresNode; use TestLib; -use Test::More tests => 2; +use Test::More tests => 3; use DBI; use DBD::Pg ':async'; @@ -54,6 +54,7 @@ sub PostgresNode::inet_connstr { for (my $i=0; $i < $nnodes; $i++) { $nodes[$i]->append_conf('postgresql.conf', $pgconf_common); $nodes[$i]->append_conf('postgresql.conf', qq( + #port = ${ \$nodes[$i]->port } multimaster.node_id = @{[ $i + 1 ]} multimaster.conn_strings = '$mm_connstr' #multimaster.arbiter_port = ${ \$nodes[0]->port } @@ -69,8 +70,8 @@ sub PostgresNode::inet_connstr { ############################################################################### my $psql_out; -# XXX: change to poll_untill -sleep(7); +# XXX: create extension on start and poll_untill status is Online +sleep(5); ############################################################################### # Replication check @@ -79,11 +80,9 @@ sub PostgresNode::inet_connstr { $nodes[0]->psql('postgres', " create extension multimaster; create table if not exists t(k int primary key, v int); - insert into t values(1, 10); -"); - + insert into t values(1, 10);"); $nodes[1]->psql('postgres', "select v from t where k=1;", stdout => \$psql_out); -is($psql_out, '10', "Check sanity while all nodes are up."); +is($psql_out, '10', "Check replication while all nodes are up."); ############################################################################### # Isolation regress checks @@ -97,30 +96,18 @@ sub PostgresNode::inet_connstr { $nodes[2]->teardown_node; -# $nodes[0]->poll_query_until('postgres', -# "select disconnected = true from mtm.get_nodes_state() where id=3;") -# or die "Timed out while waiting for node to disconnect"; - -$nodes[0]->psql('postgres', " - insert into t values(2, 20); -"); - +$nodes[0]->psql('postgres', "insert into t values(2, 20);"); $nodes[1]->psql('postgres', "select v from t where k=2;", stdout => \$psql_out); -is($psql_out, '20', "Check that we can commit after one node disconnect."); - - - - - - - - - - - - - +is($psql_out, '20', "Check replication after node failure."); +############################################################################### +# Work after node start +############################################################################### +$nodes[2]->start; +sleep(5); # XXX: here we can poll +$nodes[0]->psql('postgres', "insert into t values(3, 30);"); +$nodes[2]->psql('postgres', "select v from t where k=3;", stdout => \$psql_out); +is($psql_out, '30', "Check replication after failed node recovery."); From 69d8f41cd8c5f7e7b1fdd83dd398fa89639efb8c Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Thu, 31 Mar 2016 18:35:41 +0300 Subject: [PATCH 0347/1139] Add a timeout to the deadlock tap test. --- t/000_deadlock.pl | 60 ++++++++++++++++++++++++++++++----------------- 1 file changed, 38 insertions(+), 22 deletions(-) diff --git a/t/000_deadlock.pl b/t/000_deadlock.pl index 76f1e50436..2cf1b3335e 100644 --- a/t/000_deadlock.pl +++ b/t/000_deadlock.pl @@ -3,7 +3,7 @@ use PostgresNode; use TestLib; -use Test::More tests => 2; +use Test::More tests => 1; use DBI; use DBD::Pg ':async'; @@ -14,7 +14,7 @@ sub query_row my $sth = $dbi->prepare($sql) || die; $sth->execute(@keys) || die; my $ret = $sth->fetchrow_array || undef; - print "query_row('$sql') -> $ret \n"; + diag("query_row('$sql') -> $ret\n"); return $ret; } @@ -22,7 +22,7 @@ sub query_exec { my ($dbi, $sql) = @_; my $rv = $dbi->do($sql) || die; - print "query_exec('$sql') = $rv\n"; + diag("query_exec('$sql') = $rv\n"); return $rv; } @@ -30,7 +30,7 @@ sub query_exec_async { my ($dbi, $sql) = @_; my $rv = $dbi->do($sql, {pg_async => PG_ASYNC}) || die; - print "query_exec_async('$sql') = $rv\n"; + diag("query_exec_async('$sql')\n"); return $rv; } @@ -44,7 +44,7 @@ sub allocate_ports { my $port = int(rand() * 16384) + 49152; next if $allocated_ports{$port}; - print "# Checking for port $port\n"; + diag("Checking for port $port\n"); if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) { $allocated_ports{$port} = 1; @@ -73,8 +73,8 @@ sub allocate_ports my $mm_connstr = join(',', map { "${ \$_->connstr('postgres') }" } @nodes); my $raft_peers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @nodes); -print("# mm_connstr = $mm_connstr\n"); -print("# raft_peers = $raft_peers\n"); +diag("mm_connstr = $mm_connstr\n"); +diag("raft_peers = $raft_peers\n"); # Init and Configure foreach my $node (@nodes) @@ -125,33 +125,49 @@ sub allocate_ports $nodes[0]->psql('postgres', "create table t(k int primary key, v text)"); $nodes[0]->psql('postgres', "insert into t values (1, 'hello'), (2, 'world')"); -#sub space2semicol -#{ -# my $str = shift; -# $str =~ tr/ /;/; -# return $str; -#} -# my @conns = map { DBI->connect('DBI:Pg:' . $_->connstr()) } @nodes; query_exec($conns[0], "begin"); query_exec($conns[1], "begin"); query_exec($conns[0], "update t set v = 'asd' where k = 1"); -query_exec($conns[1], "update t set v = 'bsd' where k = 2"); +query_exec($conns[1], "update t set v = 'bsd'"); query_exec($conns[0], "update t set v = 'bar' where k = 2"); -query_exec($conns[1], "update t set v = 'foo' where k = 1"); +query_exec($conns[1], "update t set v = 'foo'"); query_exec_async($conns[0], "commit"); query_exec_async($conns[1], "commit"); -for my $i (1..2) +my $timeout = 5; +while ($timeout > 0) { - ($rc, $out, $err) = $nodes[$i]->psql('postgres', "select * from t"); - print(" rc[$i] = $rc\n"); - print("out[$i] = $out\n"); - print("err[$i] = $err\n"); + my $r0 = $conns[0]->pg_ready(); + my $r1 = $conns[1]->pg_ready(); + if ($r0 && $r1) { + last; + } + diag("queries still running: [0]=$r0 [1]=$r1\n"); + sleep(1); +} + +if ($timeout > 0) +{ + diag("queries finished\n"); + + my $succeeded = 0; + $succeeded++ if $conns[0]->pg_result(); + $succeeded++ if $conns[1]->pg_result(); + + pass("queries finished"); +} +else +{ + diag("queries timed out\n"); + $conns[0]->pg_cancel() unless $conns[0]->pg_ready(); + $conns[1]->pg_cancel() unless $conns[1]->pg_ready(); + + fail("queries timed out"); } -#sleep(2); +query_row($conns[0], "select * from t where k = 1"); From 4cb7f3739963c830ceb4294afb203cf270242c10 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Fri, 1 Apr 2016 16:31:38 +0300 Subject: [PATCH 0348/1139] Add stop-signal handling to arbiter. --- arbiter.c | 26 +++++++++++++++++++++++--- t/000_deadlock.pl | 2 +- t/001_basic_recovery.pl | 11 ++++++++++- 3 files changed, 34 insertions(+), 5 deletions(-) diff --git a/arbiter.c b/arbiter.c index a3e00b3ed4..47d7a4cf33 100644 --- a/arbiter.c +++ b/arbiter.c @@ -164,6 +164,12 @@ MtmResolveHostByName(const char *hostname, unsigned* addrs, unsigned* n_addrs) return 1; } +static int stop = 0; +static void SetStop(int sig) +{ + stop = 1; +} + #if USE_EPOLL static int epollfd; #else @@ -530,17 +536,24 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) static void MtmTransSender(Datum arg) { + sigset_t sset; int nNodes = MtmNodes; int i; MtmBuffer* txBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); - + + signal(SIGINT, SetStop); + signal(SIGQUIT, SetStop); + signal(SIGTERM, SetStop); + sigfillset(&sset); + sigprocmask(SIG_UNBLOCK, &sset, NULL); + MtmOpenConnections(); for (i = 0; i < nNodes; i++) { txBuffer[i].used = 0; } - while (true) { + while (!stop) { MtmTransState* ts; PGSemaphoreLock(&Mtm->votingSemaphore); CHECK_FOR_INTERRUPTS(); @@ -605,6 +618,7 @@ static bool MtmRecovery() static void MtmTransReceiver(Datum arg) { + sigset_t sset; int nNodes = MtmNodes; int nResponses; int i, j, n, rc; @@ -617,6 +631,12 @@ static void MtmTransReceiver(Datum arg) FD_ZERO(&inset); max_fd = 0; #endif + + signal(SIGINT, SetStop); + signal(SIGQUIT, SetStop); + signal(SIGTERM, SetStop); + sigfillset(&sset); + sigprocmask(SIG_UNBLOCK, &sset, NULL); MtmAcceptIncomingConnections(); @@ -624,7 +644,7 @@ static void MtmTransReceiver(Datum arg) rxBuffer[i].used = 0; } - while (true) { + while (!stop) { #if USE_EPOLL n = epoll_wait(epollfd, events, nNodes, MtmKeepaliveTimeout/1000); if (n < 0) { diff --git a/t/000_deadlock.pl b/t/000_deadlock.pl index 2cf1b3335e..70df911f07 100644 --- a/t/000_deadlock.pl +++ b/t/000_deadlock.pl @@ -56,7 +56,7 @@ sub allocate_ports return @allocated_now; } -my $nnodes = 3; +my $nnodes = 2; my @nodes = (); # Create nodes and allocate ports diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index 3546f793b6..0901674383 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -96,8 +96,14 @@ sub PostgresNode::inet_connstr { $nodes[2]->teardown_node; +diag("sleeping"); +sleep(15); + +diag("inserting 2"); $nodes[0]->psql('postgres', "insert into t values(2, 20);"); +diag("selecting"); $nodes[1]->psql('postgres', "select v from t where k=2;", stdout => \$psql_out); +diag("selected"); is($psql_out, '20', "Check replication after node failure."); ############################################################################### @@ -105,9 +111,12 @@ sub PostgresNode::inet_connstr { ############################################################################### $nodes[2]->start; -sleep(5); # XXX: here we can poll +sleep(15); # XXX: here we can poll +diag("inserting 3"); $nodes[0]->psql('postgres', "insert into t values(3, 30);"); +diag("selecting"); $nodes[2]->psql('postgres', "select v from t where k=3;", stdout => \$psql_out); +diag("selected"); is($psql_out, '30', "Check replication after failed node recovery."); From d4bcc33f4ad04e5d65ed5433305e28bd1903e7ff Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 1 Apr 2016 19:53:19 +0300 Subject: [PATCH 0349/1139] Add local tables hash --- multimaster--1.0.sql | 7 ++ multimaster.c | 169 +++++++++++++++++++++++++++++++++++++++++-- multimaster.h | 9 +++ pglogical_apply.c | 4 + 4 files changed, 183 insertions(+), 6 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index e3f4b9c349..fd858cde8e 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -36,4 +36,11 @@ CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state AS 'MODULE_PATHNAME','mtm_get_cluster_state' LANGUAGE C; +CREATE FUNCTION mtm.make_table_local(relation regclass) RETURNS void +AS 'MODULE_PATHNAME','mtm_make_table_local' +LANGUAGE C; + CREATE TABLE IF NOT EXISTS mtm.ddl_log (issued timestamp with time zone not null, query text); + +CREATE TABLE IF NOT EXISTS mtm.local_tables(rel_schema text, rel_name text, primary key pk(rel_schema, rel_name)); + diff --git a/multimaster.c b/multimaster.c index 8925ae0cb5..ba612c1528 100644 --- a/multimaster.c +++ b/multimaster.c @@ -45,6 +45,7 @@ #include "storage/pmsignal.h" #include "storage/proc.h" #include "utils/syscache.h" +#include "utils/lsyscache.h" #include "replication/walsender.h" #include "replication/walsender_private.h" #include "replication/slot.h" @@ -53,6 +54,7 @@ #include "nodes/makefuncs.h" #include "access/htup_details.h" #include "catalog/indexing.h" +#include "catalog/namespace.h" #include "pglogical_output/hooks.h" #include "multimaster.h" @@ -104,6 +106,7 @@ PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); PG_FUNCTION_INFO_V1(mtm_get_nodes_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_state); +PG_FUNCTION_INFO_V1(mtm_make_table_local); static Snapshot MtmGetSnapshot(Snapshot snapshot); static void MtmInitialize(void); @@ -134,6 +137,7 @@ MtmState* Mtm; HTAB* MtmXid2State; static HTAB* MtmGid2State; +static HTAB* MtmLocalTables; static MtmCurrentTrans MtmTx; @@ -175,11 +179,12 @@ bool MtmUseRaftable; MtmConnectionInfo* MtmConnections; static char* MtmConnStrs; -static int MtmQueueSize; -static int MtmWorkers; -static int MtmVacuumDelay; -static int MtmMinRecoveryLag; -static int MtmMaxRecoveryLag; +static int MtmQueueSize; +static int MtmWorkers; +static int MtmVacuumDelay; +static int MtmMinRecoveryLag; +static int MtmMaxRecoveryLag; +static bool MtmIgnoreTablesWithoutPk; static ExecutorFinish_hook_type PreviousExecutorFinishHook; static ProcessUtility_hook_type PreviousProcessUtilityHook; @@ -1279,6 +1284,71 @@ MtmCreateGidMap(void) return htab; } +static HTAB* +MtmCreateLocalTableMap(void) +{ + HASHCTL info; + HTAB* htab; + memset(&info, 0, sizeof(info)); + info.keysize = sizeof(Oid); + htab = ShmemInitHash( + "MtmLocalTables", + MULTIMASTER_MAX_LOCAL_TABLES, MULTIMASTER_MAX_LOCAL_TABLES, + &info, + 0 + ); + return htab; +} + +static void MtmMakeRelationLocal(Oid relid) +{ + if (OidIsValid(relid)) { + MtmLock(LW_EXCLUSIVE); + hash_search(MtmLocalTables, &relid, HASH_ENTER, NULL); + MtmUnlock(); + } +} + + +void MtmMakeTableLocal(char* schema, char* name) +{ + RangeVar* rv = makeRangeVar(schema, name, -1); + Oid relid = RangeVarGetRelid(rv, NoLock, true); + MtmMakeRelationLocal(relid); +} + + +typedef struct { + NameData schema; + NameData name; +} MtmLocalTablesTuple; + +static void MtmLoadLocalTables(void) +{ + RangeVar *rv; + Relation rel; + SysScanDesc scan; + HeapTuple tuple; + + Assert(IsTransactionState()); + + rv = makeRangeVar(MULTIMASTER_SCHEMA_NAME, MULTIMASTER_LOCAL_TABLES_TABLE, -1); + rel = heap_openrv_extended(rv, RowExclusiveLock, true); + if (rel != NULL) { + scan = systable_beginscan(rel, 0, true, NULL, 0, NULL); + + while (HeapTupleIsValid(tuple = systable_getnext(scan))) + { + MtmLocalTablesTuple *t = (MtmLocalTablesTuple*) GETSTRUCT(tuple); + MtmMakeTableLocal(NameStr(t->schema), NameStr(t->name)); + } + + systable_endscan(scan); + heap_close(rel, RowExclusiveLock); + } +} + + static void MtmInitialize() { bool found; @@ -1308,6 +1378,7 @@ static void MtmInitialize() Mtm->nReceivers = 0; Mtm->timeShift = 0; Mtm->transCount = 0; + Mtm->localTablesHashLoaded = false; for (i = 0; i < MtmNodes; i++) { Mtm->nodes[i].oldestSnapshot = 0; Mtm->nodes[i].transDelay = 0; @@ -1323,6 +1394,7 @@ static void MtmInitialize() } MtmXid2State = MtmCreateXidMap(); MtmGid2State = MtmCreateGidMap(); + MtmLocalTables = MtmCreateLocalTableMap(); MtmDoReplication = true; TM = &MtmTM; LWLockRelease(AddinShmemInitLock); @@ -1475,6 +1547,19 @@ _PG_init(void) NULL ); + DefineCustomBoolVariable( + "multimaster.ignore_tables_without_pk", + "Do not replicate tables withpout primary key", + NULL, + &MtmIgnoreTablesWithoutPk, + false, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.workers", "Number of multimaster executor workers per node", @@ -1804,11 +1889,30 @@ MtmReplicationTxnFilterHook(struct PGLogicalTxnFilterArgs* args) return res; } +static bool +MtmReplicationRowFilterHook(struct PGLogicalRowFilterArgs* args) +{ + bool isDistributed; + MtmLock(LW_SHARED); + if (!Mtm->localTablesHashLoaded) { + MtmUnlock(); + MtmLock(LW_EXCLUSIVE); + if (!Mtm->localTablesHashLoaded) { + MtmLoadLocalTables(); + Mtm->localTablesHashLoaded = true; + } + } + isDistributed = hash_search(MtmLocalTables, &RelationGetRelid(args->changed_rel), HASH_FIND, NULL) == NULL; + MtmUnlock(); + return isDistributed; +} + void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks) { hooks->startup_hook = MtmReplicationStartupHook; hooks->shutdown_hook = MtmReplicationShutdownHook; hooks->txn_filter_hook = MtmReplicationTxnFilterHook; + hooks->row_filter_hook = MtmReplicationRowFilterHook; } @@ -1935,6 +2039,52 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); } + +Datum mtm_make_table_local(PG_FUNCTION_ARGS) +{ + Oid reloid = PG_GETARG_OID(1); + RangeVar *rv; + Relation rel; + TupleDesc tupDesc; + HeapTuple tup; + Datum values[Natts_mtm_local_tables]; + bool nulls[Natts_mtm_local_tables]; + + MtmMakeRelationLocal(reloid); + + rv = makeRangeVar(MULTIMASTER_SCHEMA_NAME, MULTIMASTER_LOCAL_TABLES_TABLE, -1); + rel = heap_openrv(rv, RowExclusiveLock); + if (rel != NULL) { + char* tableName = get_rel_name(reloid); + Oid schemaid = get_rel_namespace(reloid); + char* schemaName = get_namespace_name(schemaid); + + tupDesc = RelationGetDescr(rel); + + /* Form a tuple. */ + memset(nulls, false, sizeof(nulls)); + + values[Anum_mtm_local_tables_rel_schema - 1] = CStringGetTextDatum(schemaName); + values[Anum_mtm_local_tables_rel_name - 1] = CStringGetTextDatum(tableName); + + tup = heap_form_tuple(tupDesc, values, nulls); + + /* Insert the tuple to the catalog. */ + simple_heap_insert(rel, tup); + + /* Update the indexes. */ + CatalogUpdateIndexes(rel, tup); + + /* Cleanup. */ + heap_freetuple(tup); + heap_close(rel, RowExclusiveLock); + + MtmTx.containsDML = true; + } + return false; +} + + /* * ------------------------------------------- * Broadcast utulity statements @@ -2243,10 +2393,17 @@ MtmExecutorFinish(QueryDesc *queryDesc) if (estate->es_processed != 0 && (operation == CMD_INSERT || operation == CMD_UPDATE || operation == CMD_DELETE)) { int i; for (i = 0; i < estate->es_num_result_relations; i++) { - if (RelationNeedsWAL(estate->es_result_relations[i].ri_RelationDesc)) { + Relation rel = estate->es_result_relations[i].ri_RelationDesc; + if (RelationNeedsWAL(rel)) { MtmTx.containsDML = true; break; } + if (MtmIgnoreTablesWithoutPk) { + if (!rel->rd_indexvalid) { + RelationGetIndexList(rel); + } + MtmMakeRelationLocal(rel->rd_replidindex); + } } } if (MtmTx.isDistributed && MtmTx.containsDML && !IsTransactionBlock()) { diff --git a/multimaster.h b/multimaster.h index 4d3179dc4f..e50f609b36 100644 --- a/multimaster.h +++ b/multimaster.h @@ -19,6 +19,7 @@ #define MULTIMASTER_NAME "multimaster" #define MULTIMASTER_SCHEMA_NAME "mtm" #define MULTIMASTER_DDL_TABLE "ddl_log" +#define MULTIMASTER_LOCAL_TABLES_TABLE "local_tables" #define MULTIMASTER_SLOT_PATTERN "mtm_slot_%d" #define MULTIMASTER_MIN_PROTO_VERSION 1 #define MULTIMASTER_MAX_PROTO_VERSION 1 @@ -26,6 +27,7 @@ #define MULTIMASTER_MAX_SLOT_NAME_SIZE 16 #define MULTIMASTER_MAX_CONN_STR_SIZE 128 #define MULTIMASTER_MAX_HOST_NAME_SIZE 64 +#define MULTIMASTER_MAX_LOCAL_TABLES 256 #define MULTIMASTER_BROADCAST_SERVICE "mtm_broadcast" #define MULTIMASTER_ADMIN "mtm_admin" @@ -35,6 +37,10 @@ #define Anum_mtm_ddl_log_issued 1 #define Anum_mtm_ddl_log_query 2 +#define Natts_mtm_local_tables 2 +#define Anum_mtm_local_tables_rel_schema 1 +#define Anum_mtm_local_tables_rel_name 2 + typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) @@ -135,6 +141,7 @@ typedef struct nodemask_t nodeLockerMask; /* Mask of node IDs which WAL-senders are locking the cluster */ nodemask_t reconnectMask; /* Mask of nodes connection to which has to be reestablished by sender */ + bool localTablesHashLoaded; /* Whether data from local_tables table is loaded in shared memory hash table */ int nNodes; /* Number of active nodes */ int nReceivers; /* Number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ int nLockers; /* Number of lockers */ @@ -208,4 +215,6 @@ extern void MtmSetupReplicationHooks(struct PGLogicalHooks* hooks); extern void MtmCheckQuorum(void); extern bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN); extern void MtmRecoveryCompleted(void); +extern void MtmMakeTableLocal(char* schema, char* name); + #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index 60e06a5d81..d69ba0bdd0 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -677,6 +677,10 @@ process_remote_insert(StringInfo s, Relation rel) if (rc != SPI_OK_UTILITY) { elog(ERROR, "Failed to execute utility statement %s", ddl); } + } else if (strcmp(relname, MULTIMASTER_LOCAL_TABLES_TABLE) == 0) { + char* schema = TextDatumGetCString(new_tuple.values[Anum_mtm_local_tables_rel_schema-1]); + char* name = TextDatumGetCString(new_tuple.values[Anum_mtm_local_tables_rel_name-1]); + MtmMakeTableLocal(schema, name); } } From 11d0677a5ea6ce45840988ad825fae02dbe0f67a Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 1 Apr 2016 20:31:42 +0300 Subject: [PATCH 0350/1139] Fix bug in handling tables without primary key --- multimaster.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/multimaster.c b/multimaster.c index ba612c1528..c1039b980c 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2395,15 +2395,18 @@ MtmExecutorFinish(QueryDesc *queryDesc) for (i = 0; i < estate->es_num_result_relations; i++) { Relation rel = estate->es_result_relations[i].ri_RelationDesc; if (RelationNeedsWAL(rel)) { + if (MtmIgnoreTablesWithoutPk) { + if (!rel->rd_indexvalid) { + RelationGetIndexList(rel); + } + if (rel->rd_replidindex == InvalidOid) { + MtmMakeRelationLocal(RelationGetRelid(rel)); + continue; + } + } MtmTx.containsDML = true; break; } - if (MtmIgnoreTablesWithoutPk) { - if (!rel->rd_indexvalid) { - RelationGetIndexList(rel); - } - MtmMakeRelationLocal(rel->rd_replidindex); - } } } if (MtmTx.isDistributed && MtmTx.containsDML && !IsTransactionBlock()) { From 671f689671f9f6dd6cf4329ef7332f91210eee1c Mon Sep 17 00:00:00 2001 From: knizhnik Date: Fri, 1 Apr 2016 23:05:56 +0300 Subject: [PATCH 0351/1139] Fix local_table table defintion --- multimaster--1.0.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index fd858cde8e..0badae5022 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -42,5 +42,5 @@ LANGUAGE C; CREATE TABLE IF NOT EXISTS mtm.ddl_log (issued timestamp with time zone not null, query text); -CREATE TABLE IF NOT EXISTS mtm.local_tables(rel_schema text, rel_name text, primary key pk(rel_schema, rel_name)); +CREATE TABLE IF NOT EXISTS mtm.local_tables(rel_schema text, rel_name text, primary key(rel_schema, rel_name)); From b82ebd02d531d67f87489c4786e44b5277948c39 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Fri, 1 Apr 2016 23:45:53 +0300 Subject: [PATCH 0352/1139] Abort voting backends on node disconnect --- arbiter.c | 14 ++------------ multimaster.c | 38 ++++++++++++++++++++++++++++++++------ multimaster.h | 2 ++ 3 files changed, 36 insertions(+), 18 deletions(-) diff --git a/arbiter.c b/arbiter.c index 47d7a4cf33..7f3cc9bd21 100644 --- a/arbiter.c +++ b/arbiter.c @@ -584,12 +584,6 @@ static void MtmTransSender(Datum arg) } } -static void MtmWakeUpBackend(MtmTransState* ts) -{ - MTM_TRACE("Wakeup backed procno=%d, pid=%d\n", ts->procno, ProcGlobal->allProcs[ts->procno].pid); - ts->votingCompleted = true; - SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); -} #if !USE_EPOLL static bool MtmRecovery() @@ -715,9 +709,7 @@ static void MtmTransReceiver(Datum arg) commit on smaller subset of nodes */ elog(WARNING, "Coordinator of distributed transaction see less nodes than node %d: %lx instead of %lx", msg->node, Mtm->disabledNodeMask, msg->disabledNodeMask); - ts->status = TRANSACTION_STATUS_ABORTED; - MtmAdjustSubtransactions(ts); - Mtm->nActiveTransactions -= 1; + MtmAbortTransaction(ts); } if (++ts->nVotes == Mtm->nNodes) { @@ -735,9 +727,7 @@ static void MtmTransReceiver(Datum arg) Assert(ts->nVotes < Mtm->nNodes); if (ts->status != TRANSACTION_STATUS_ABORTED) { Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - ts->status = TRANSACTION_STATUS_ABORTED; - MtmAdjustSubtransactions(ts); - Mtm->nActiveTransactions -= 1; + MtmAbortTransaction(ts); } if (++ts->nVotes == Mtm->nNodes) { MtmWakeUpBackend(ts); diff --git a/multimaster.c b/multimaster.c index c1039b980c..b97b12bf68 100644 --- a/multimaster.c +++ b/multimaster.c @@ -552,6 +552,7 @@ static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int Assert(!found); sts->status = ts->status; sts->csn = ts->csn; + sts->votingCompleted = true; MtmTransactionListInsertAfter(ts, sts); } } @@ -744,7 +745,8 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) if (!MtmIsCoordinator(ts) || Mtm->status == MTM_RECOVERY) { MtmTransMap* tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_ENTER, NULL); Assert(x->gid[0]); - tm->state = ts; + tm->state = ts; + ts->votingCompleted = true; if (Mtm->status != MTM_RECOVERY) { MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ } else { @@ -776,9 +778,7 @@ MtmAbortPreparedTransaction(MtmCurrentTrans* x) MtmLock(LW_EXCLUSIVE); tm = (MtmTransMap*)hash_search(MtmGid2State, x->gid, HASH_REMOVE, NULL); Assert(tm != NULL); - tm->state->status = TRANSACTION_STATUS_ABORTED; - MtmAdjustSubtransactions(tm->state); - Mtm->nActiveTransactions -= 1; + MtmAbortTransaction(tm->state); MtmUnlock(); x->status = TRANSACTION_STATUS_ABORTED; } @@ -834,6 +834,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) ts->gtid = x->gtid; ts->nSubxids = 0; ts->cmd = MSG_INVALID; + ts->votingCompleted = true; MtmTransactionListAppend(ts); } MtmSendNotificationMessage(ts, MSG_ABORTED); /* send notification to coordinator */ @@ -936,6 +937,20 @@ csn_t MtmGetTransactionCSN(TransactionId xid) return csn; } +void MtmWakeUpBackend(MtmTransState* ts) +{ + MTM_TRACE("Wakeup backed procno=%d, pid=%d\n", ts->procno, ProcGlobal->allProcs[ts->procno].pid); + ts->votingCompleted = true; + SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); +} + +void MtmAbortTransaction(MtmTransState* ts) +{ + ts->status = TRANSACTION_STATUS_ABORTED; + MtmAdjustSubtransactions(ts); + Mtm->nActiveTransactions -= 1; +} + /* * ------------------------------------------- * HA functions @@ -1212,9 +1227,10 @@ void MtmCheckQuorum(void) } } - void MtmOnNodeDisconnect(int nodeId) -{ +{ + MtmTransState *ts; + BIT_SET(Mtm->connectivityMask, nodeId-1); BIT_SET(Mtm->reconnectMask, nodeId-1); RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); @@ -1228,6 +1244,16 @@ void MtmOnNodeDisconnect(int nodeId) BIT_SET(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes -= 1; MtmCheckQuorum(); + /* Interrupt voting for active transaction and abort them */ + for (ts = Mtm->transListHead; ts != NULL; ts = ts->next) { + if (!ts->votingCompleted) { + if (ts->status != TRANSACTION_STATUS_ABORTED) { + elog(WARNING, "Rollback active transaction %d:%d", ts->gtid.node, ts->gtid.xid); + MtmAbortTransaction(ts); + } + MtmWakeUpBackend(ts); + } + } } MtmUnlock(); } diff --git a/multimaster.h b/multimaster.h index e50f609b36..a5bc95658b 100644 --- a/multimaster.h +++ b/multimaster.h @@ -199,8 +199,10 @@ extern void MtmDropNode(int nodeId, bool dropSlot); extern void MtmRecoverNode(int nodeId); extern void MtmOnNodeDisconnect(int nodeId); extern void MtmOnNodeConnect(int nodeId); +extern void MtmWakeUpBackend(MtmTransState* ts); extern timestamp_t MtmGetCurrentTime(void); extern void MtmSleep(timestamp_t interval); +extern void MtmAbortTransaction(MtmTransState* ts); extern void MtmSetCurrentTransactionGID(char const* gid); extern csn_t MtmGetTransactionCSN(TransactionId xid); extern void MtmSetCurrentTransactionCSN(csn_t csn); From 92927df208030b731a3e7a1fd4bb5431d6040c01 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Sat, 2 Apr 2016 00:26:08 +0300 Subject: [PATCH 0353/1139] fix client ERROR message --- multimaster.c | 2 +- tests/postgresql.conf.mm | 1 + tests/reinit-mm.sh | 2 ++ 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index b97b12bf68..087100dcee 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2134,7 +2134,7 @@ static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg) *errmsg = palloc0(errlen); /* Strip "ERROR:\t" from beginning and "\n" from end of error string */ - strncpy(*errmsg, errstr + 7, errlen - 1 - 7); + strncpy(*errmsg, errstr + 8, errlen - 1 - 8); } PQclear(result); diff --git a/tests/postgresql.conf.mm b/tests/postgresql.conf.mm index bc5dcddde9..2dc4aed535 100644 --- a/tests/postgresql.conf.mm +++ b/tests/postgresql.conf.mm @@ -626,3 +626,4 @@ multimaster.workers=8 multimaster.queue_size=104857600 # 100mb +multimaster.ignore_tables_without_pk=1 diff --git a/tests/reinit-mm.sh b/tests/reinit-mm.sh index b43cb12dc6..0fae0fe6a8 100755 --- a/tests/reinit-mm.sh +++ b/tests/reinit-mm.sh @@ -6,6 +6,8 @@ pkill -9 arbiter cd ~/code/postgres_cluster/contrib/mmts/ make install +cd ~/code/postgres_cluster/contrib/raftable/ +make install cd ~/code/postgres_cluster/contrib/mmts/tests From 734b73704074bd6a9bdca0515715422252debd33 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 3 Apr 2016 10:44:02 +0300 Subject: [PATCH 0354/1139] Detect zombies --- arbiter.c | 5 ++++- multimaster.c | 18 ++++++++++++++---- 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/arbiter.c b/arbiter.c index 7f3cc9bd21..69a789722b 100644 --- a/arbiter.c +++ b/arbiter.c @@ -694,7 +694,10 @@ static void MtmTransReceiver(Datum arg) MtmTransState* ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); Assert(msg->node > 0 && msg->node <= nNodes && msg->node != MtmNodeId); - + + if (BIT_CHECK(msg->disabledNodeMask, MtmNodeId-1) && Mtm->status != MTM_RECOVERY) { + elog(PANIC, "Node %d thinks that I was dead: perform hara-kiri not to be a zombie", msg->node); + } Mtm->nodes[msg->node-1].oldestSnapshot = msg->oldestSnapshot; if (MtmIsCoordinator(ts)) { diff --git a/multimaster.c b/multimaster.c index 087100dcee..1f6a0ed61f 100644 --- a/multimaster.c +++ b/multimaster.c @@ -139,6 +139,8 @@ HTAB* MtmXid2State; static HTAB* MtmGid2State; static HTAB* MtmLocalTables; +static bool MtmIsRecoverySession; + static MtmCurrentTrans MtmTx; static TransactionManager MtmTM = { @@ -1022,7 +1024,15 @@ static int64 MtmGetSlotLag(int nodeId) */ bool MtmIsRecoveredNode(int nodeId) { - return BIT_CHECK(Mtm->disabledNodeMask, nodeId-1); + if (BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { + if (!MtmIsRecoverySession) { + elog(ERROR, "Node %d is marked as disabled but is not in recovery mode", nodeId); + } + return true; + } else { + MtmIsRecoverySession = false; /* recovery is completed */ + return false; + } } @@ -1871,17 +1881,17 @@ static void MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) { ListCell *param; - bool isRecoverySession = false; + MtmIsRecoverySession = false; foreach(param, args->in_params) { DefElem *elem = lfirst(param); if (strcmp("mtm_replication_mode", elem->defname) == 0) { - isRecoverySession = elem->arg != NULL && strVal(elem->arg) != NULL && strcmp(strVal(elem->arg), "recovery") == 0; + MtmIsRecoverySession = elem->arg != NULL && strVal(elem->arg) != NULL && strcmp(strVal(elem->arg), "recovery") == 0; break; } } MtmLock(LW_EXCLUSIVE); - if (isRecoverySession) { + if (MtmIsRecoverySession) { elog(WARNING, "%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); From fb58fcdad75b9b051cab4629ab27c8687585260a Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 3 Apr 2016 22:16:40 +0300 Subject: [PATCH 0355/1139] more price handling of recovery mode --- multimaster.c | 25 ++++++++++++++++++++----- pglogical_receiver.c | 9 ++++++++- 2 files changed, 28 insertions(+), 6 deletions(-) diff --git a/multimaster.c b/multimaster.c index 1f6a0ed61f..aa2ad1cc0b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1881,12 +1881,23 @@ static void MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) { ListCell *param; + bool recoveryCompleted = false; MtmIsRecoverySession = false; foreach(param, args->in_params) { DefElem *elem = lfirst(param); if (strcmp("mtm_replication_mode", elem->defname) == 0) { - MtmIsRecoverySession = elem->arg != NULL && strVal(elem->arg) != NULL && strcmp(strVal(elem->arg), "recovery") == 0; + if (elem->arg != NULL && strVal(elem->arg) != NULL) { + if (strcmp(strVal(elem->arg), "recovery") == 0) { + MtmIsRecoverySession = true; + } else if (strcmp(strVal(elem->arg), "recovered") == 0) { + recoveryCompleted = true; + } else if (strcmp(strVal(elem->arg), "normal") != 0) { + elog(ERROR, "Illegal recovery mode %s", strVal(elem->arg)); + } + } else { + elog(ERROR, "Replication mode is not specified"); + } break; } } @@ -1899,10 +1910,14 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) MtmCheckQuorum(); } } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { - elog(WARNING, "Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); - BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); - Mtm->nNodes += 1; - MtmCheckQuorum(); + if (recoveryCompleted) { + elog(WARNING, "Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); + BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); + Mtm->nNodes += 1; + MtmCheckQuorum(); + } else { + elog(ERROR, "Disabled node %d tries to reconnect without recovery", MtmReplicationNodeId); + } } else { elog(NOTICE, "Node %d start logical replication to node %d in normal mode", MtmNodeId, MtmReplicationNodeId); } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 20975a1e69..31084dfc85 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -196,6 +196,13 @@ feTimestampDifference(int64 start_time, int64 stop_time, } } +static char const* const MtmReplicationModeName[] = +{ + "recovered", /* SLOT_CREATE_NEW: recovery of node is completed so drop old slot and restart replication from the current position in WAL */ + "recovery", /* SLOT_OPEN_EXISTED: perform recorvery of the node by applying all data from theslot from specified point */ + "normal" /* SLOT_OPEN_ALWAYS: normal mode: use existeed slot or create new one and start receiving data from it from the specified position */ +}; + static void pglogical_receiver_main(Datum main_arg) { @@ -298,7 +305,7 @@ pglogical_receiver_main(Datum main_arg) (uint32) originStartPos, MULTIMASTER_MAX_PROTO_VERSION, MULTIMASTER_MIN_PROTO_VERSION, - mode == SLOT_OPEN_EXISTED ? "recovery" : "normal" + MtmReplicationModeName[mode] ); res = PQexec(conn, query->data); if (PQresultStatus(res) != PGRES_COPY_BOTH) From a095c6909fa049bd53f89918a27384c9f6a64ef9 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 4 Apr 2016 10:13:29 +0300 Subject: [PATCH 0356/1139] Partly merge with new version of pglogical_output plugin --- pglogical_config.h | 6 +++--- pglogical_hooks.h | 1 + pglogical_output/compat.h | 28 ++++++++++++++++++++++++++++ pglogical_output/hooks.h | 5 +++-- pglogical_proto.h | 18 +++++++++++------- 5 files changed, 46 insertions(+), 12 deletions(-) create mode 100644 pglogical_output/compat.h diff --git a/pglogical_config.h b/pglogical_config.h index 3af3ce8a35..8f620bd9da 100644 --- a/pglogical_config.h +++ b/pglogical_config.h @@ -5,6 +5,9 @@ #error must be included first #endif +#include "nodes/pg_list.h" +#include "pglogical_output.h" + inline static bool server_float4_byval(void) { @@ -45,9 +48,6 @@ server_bigendian(void) #endif } -typedef struct List List; -typedef struct PGLogicalOutputData PGLogicalOutputData; - extern int process_parameters(List *options, PGLogicalOutputData *data); extern List * prepare_startup_message(PGLogicalOutputData *data); diff --git a/pglogical_hooks.h b/pglogical_hooks.h index df661f335c..5dd970581d 100644 --- a/pglogical_hooks.h +++ b/pglogical_hooks.h @@ -5,6 +5,7 @@ /* public interface for hooks */ #include "pglogical_output/hooks.h" +#include "pglogical_output.h" extern void load_hooks(PGLogicalOutputData *data); diff --git a/pglogical_output/compat.h b/pglogical_output/compat.h new file mode 100644 index 0000000000..b0b14fc5e6 --- /dev/null +++ b/pglogical_output/compat.h @@ -0,0 +1,28 @@ +#ifndef PG_LOGICAL_COMPAT_H +#define PG_LOGICAL_COMPAT_H + +#include "pg_config.h" + +/* 9.4 lacks replication origins */ +#if PG_VERSION_NUM >= 90500 +#define HAVE_REPLICATION_ORIGINS +#else +/* To allow the same signature on hooks in 9.4 */ +typedef uint16 RepOriginId; +#define InvalidRepOriginId 0 +#endif + +/* 9.4 lacks PG_UINT32_MAX */ +#ifndef PG_UINT32_MAX +#define PG_UINT32_MAX UINT32_MAX +#endif + +#ifndef PG_INT32_MAX +#define PG_INT32_MAX INT32_MAX +#endif + +#ifndef PG_INT32_MIN +#define PG_INT32_MIN INT32_MIN +#endif + +#endif diff --git a/pglogical_output/hooks.h b/pglogical_output/hooks.h index b20fa72410..8766dd776b 100644 --- a/pglogical_output/hooks.h +++ b/pglogical_output/hooks.h @@ -7,8 +7,7 @@ #include "utils/palloc.h" #include "replication/reorderbuffer.h" -struct PGLogicalOutputData; -typedef struct PGLogicalOutputData PGLogicalOutputData; +#include "pglogical_output/compat.h" /* * This header is to be included by extensions that implement pglogical output @@ -43,6 +42,8 @@ struct PGLogicalRowFilterArgs void *private_data; Relation changed_rel; enum ReorderBufferChangeType change_type; + /* detailed row change event from logical decoding */ + ReorderBufferChange* change; }; typedef bool (*pglogical_row_filter_hook_fn)(struct PGLogicalRowFilterArgs *args); diff --git a/pglogical_proto.h b/pglogical_proto.h index 2fdbec0e19..96bad8bf08 100644 --- a/pglogical_proto.h +++ b/pglogical_proto.h @@ -13,22 +13,26 @@ #ifndef PG_LOGICAL_PROTO_H #define PG_LOGICAL_PROTO_H -typedef void (*pglogical_write_rel_fn)(StringInfo out, PGLogicalOutputData *data, Relation rel); +struct PGLogicalOutputData; +struct PGLRelMetaCacheEntry; -typedef void (*pglogical_write_begin_fn)(StringInfo out, PGLogicalOutputData *data, +typedef void (*pglogical_write_rel_fn)(StringInfo out, struct PGLogicalOutputData *data, + Relation rel/*, struct PGLRelMetaCacheEntry *cache_entry*/); + +typedef void (*pglogical_write_begin_fn)(StringInfo out, struct PGLogicalOutputData *data, ReorderBufferTXN *txn); -typedef void (*pglogical_write_commit_fn)(StringInfo out, PGLogicalOutputData *data, +typedef void (*pglogical_write_commit_fn)(StringInfo out, struct PGLogicalOutputData *data, ReorderBufferTXN *txn, XLogRecPtr commit_lsn); typedef void (*pglogical_write_origin_fn)(StringInfo out, const char *origin, XLogRecPtr origin_lsn); -typedef void (*pglogical_write_insert_fn)(StringInfo out, PGLogicalOutputData *data, +typedef void (*pglogical_write_insert_fn)(StringInfo out, struct PGLogicalOutputData *data, Relation rel, HeapTuple newtuple); -typedef void (*pglogical_write_update_fn)(StringInfo out, PGLogicalOutputData *data, +typedef void (*pglogical_write_update_fn)(StringInfo out, struct PGLogicalOutputData *data, Relation rel, HeapTuple oldtuple, HeapTuple newtuple); -typedef void (*pglogical_write_delete_fn)(StringInfo out, PGLogicalOutputData *data, +typedef void (*pglogical_write_delete_fn)(StringInfo out, struct PGLogicalOutputData *data, Relation rel, HeapTuple oldtuple); typedef void (*write_startup_message_fn)(StringInfo out, List *msg); @@ -45,7 +49,7 @@ typedef struct PGLogicalProtoAPI pglogical_write_update_fn write_update; pglogical_write_delete_fn write_delete; pglogical_setup_hooks_fn setup_hooks; - write_startup_message_fn write_startup_message; + write_startup_message_fn write_startup_message; } PGLogicalProtoAPI; From 5cce0cbb37acc76327d743071994731a679282c2 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Mon, 4 Apr 2016 17:16:55 +0300 Subject: [PATCH 0357/1139] print notices --- multimaster.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index aa2ad1cc0b..b6cf5addaa 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2158,7 +2158,7 @@ static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg) *errmsg = palloc0(errlen); - /* Strip "ERROR:\t" from beginning and "\n" from end of error string */ + /* Strip "ERROR: " from beginning and "\n" from end of error string */ strncpy(*errmsg, errstr + 8, errlen - 1 - 8); } @@ -2166,6 +2166,25 @@ static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg) return ret; } +void MtmNoticeReceiver(void *i, const PGresult *res) +{ + char *notice = PQresultErrorMessage(res); + char *stripped_notice; + int len = strlen(notice); + + /* Skip notices from other nodes */ + if ( (*(int *)i) != MtmNodeId - 1) + return; + + stripped_notice = palloc0(len); + + /* Strip "NOTICE: " from beginning and "\n" from end of error string */ + strncpy(stripped_notice, notice + 9, len - 1 - 9); + + elog(NOTICE, stripped_notice); + pfree(stripped_notice); +} + static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) { int i = 0; @@ -2194,6 +2213,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) elog(ERROR, "Failed to establish connection '%s' to node %d", Mtm->nodes[i].con.connStr, failedNode); } } + PQsetNoticeReceiver(conns[i], MtmNoticeReceiver, &i); } } Assert(i == MtmNodes); From 6c1733d912ebcfc72459656a1ef3e462da97bb12 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 4 Apr 2016 20:27:40 +0300 Subject: [PATCH 0358/1139] Add relation Id map --- Makefile | 2 +- multimaster.h | 4 +-- pglogical_apply.c | 36 ++++++++++++++--------- pglogical_proto.c | 13 +++++---- pglogical_relid_map.c | 66 +++++++++++++++++++++++++++++++++++++++++++ pglogical_relid_map.h | 14 +++++++++ 6 files changed, 114 insertions(+), 21 deletions(-) create mode 100644 pglogical_relid_map.c create mode 100644 pglogical_relid_map.h diff --git a/Makefile b/Makefile index 6ab3120a55..921016283a 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ MODULE_big = multimaster -OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o +OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o pglogical_relid_map.o ddd.o bkb.o override CPPFLAGS += -I../raftable diff --git a/multimaster.h b/multimaster.h index a5bc95658b..78fc508e6a 100644 --- a/multimaster.h +++ b/multimaster.h @@ -8,11 +8,11 @@ #include "pglogical_output/hooks.h" #define MTM_TUPLE_TRACE(fmt, ...) -#if 1 +#if 0 #define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) #else -#define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) +#define MTM_INFO(fmt, ...) #define MTM_TRACE(fmt, ...) #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index d69ba0bdd0..34ed5ecba5 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -49,6 +49,7 @@ #include "parser/parse_relation.h" #include "multimaster.h" +#include "pglogical_relid_map.h" typedef struct TupleData { @@ -451,19 +452,28 @@ read_rel(StringInfo s, LOCKMODE mode) int relnamelen; int nspnamelen; RangeVar* rv; - Oid relid; - - rv = makeNode(RangeVar); - - nspnamelen = pq_getmsgbyte(s); - rv->schemaname = (char *) pq_getmsgbytes(s, nspnamelen); - - relnamelen = pq_getmsgbyte(s); - rv->relname = (char *) pq_getmsgbytes(s, relnamelen); - - relid = RangeVarGetRelidExtended(rv, mode, false, false, NULL, NULL); - - return heap_open(relid, NoLock); + Oid remote_relid = pq_getmsgint(s, 4); + Oid local_relid; + + local_relid = pglogical_relid_map_get(remote_relid); + if (local_relid == InvalidOid) { + rv = makeNode(RangeVar); + + nspnamelen = pq_getmsgbyte(s); + rv->schemaname = (char *) pq_getmsgbytes(s, nspnamelen); + + relnamelen = pq_getmsgbyte(s); + rv->relname = (char *) pq_getmsgbytes(s, relnamelen); + + local_relid = RangeVarGetRelidExtended(rv, mode, false, false, NULL, NULL); + pglogical_relid_map_put(remote_relid, local_relid); + } else { + nspnamelen = pq_getmsgbyte(s); + s->cursor += nspnamelen; + relnamelen = pq_getmsgbyte(s); + s->cursor += relnamelen; + } + return heap_open(local_relid, NoLock); } static void diff --git a/pglogical_proto.c b/pglogical_proto.c index 9c0e7f3de1..d3e7da2399 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -36,6 +36,7 @@ #include "utils/typcache.h" #include "multimaster.h" +#include "pglogical_relid_map.h" static bool MtmIsFilteredTxn; @@ -71,13 +72,15 @@ pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel) uint8 nspnamelen; const char *relname; uint8 relnamelen; - + Oid relid; if (MtmIsFilteredTxn) { return; } - pq_sendbyte(out, 'R'); /* sending RELATION */ - + relid = RelationGetRelid(rel); + pq_sendbyte(out, 'R'); /* sending RELATION */ + pq_sendint(out, relid, sizeof relid); /* use Oid as relation identifier */ + nspname = get_namespace_name(rel->rd_rel->relnamespace); if (nspname == NULL) elog(ERROR, "cache lookup failed for namespace %u", @@ -86,10 +89,10 @@ pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel) relname = NameStr(rel->rd_rel->relname); relnamelen = strlen(relname) + 1; - + pq_sendbyte(out, nspnamelen); /* schema name length */ pq_sendbytes(out, nspname, nspnamelen); - + pq_sendbyte(out, relnamelen); /* table name length */ pq_sendbytes(out, relname, relnamelen); } diff --git a/pglogical_relid_map.c b/pglogical_relid_map.c new file mode 100644 index 0000000000..a492649b29 --- /dev/null +++ b/pglogical_relid_map.c @@ -0,0 +1,66 @@ +/*------------------------------------------------------------------------- + * + * pglogical_relid_map.c + * Logical Replication map of local Oids to to remote + * + * Copyright (c) 2012-2015, PostgreSQL Global Development Group + * + * IDENTIFICATION + * pglogical_relid_map.c + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" +#include "utils/hsearch.h" +#include "pglogical_relid_map.h" + +static HTAB *relid_map; + +static void +pglogical_relid_map_init(void) +{ + HASHCTL ctl; + int hash_flags = HASH_ELEM; + + Assert(relid_map == NULL); + + MemSet(&ctl, 0, sizeof(ctl)); + ctl.keysize = sizeof(Oid); + ctl.entrysize = sizeof(PGLRelidMapEntry); + +#if PG_VERSION_NUM >= 90500 + hash_flags |= HASH_BLOBS; +#else + ctl.hash = tag_hash; + hash_flags |= HASH_FUNCTION; +#endif + + relid_map = hash_create("pglogical_relid_map", PGL_INIT_RELID_MAP_SIZE, &ctl, hash_flags); + + Assert(relid_map != NULL); +} + +Oid pglogical_relid_map_get(Oid relid) +{ + if (relid_map != NULL) { + PGLRelidMapEntry* entry = (PGLRelidMapEntry*)hash_search(relid_map, &relid, HASH_FIND, NULL); + return entry ? entry->local_relid : InvalidOid; + } + return InvalidOid; +} + +bool pglogical_relid_map_put(Oid remote_relid, Oid local_relid) +{ + bool found; + PGLRelidMapEntry* entry; + if (relid_map == NULL) { + pglogical_relid_map_init(); + } + entry = hash_search(relid_map, &remote_relid, HASH_ENTER, &found); + if (found) { + Assert(entry->local_relid == local_relid); + return false; + } + entry->local_relid = local_relid; + return true; +} diff --git a/pglogical_relid_map.h b/pglogical_relid_map.h new file mode 100644 index 0000000000..d8f267c96e --- /dev/null +++ b/pglogical_relid_map.h @@ -0,0 +1,14 @@ +#ifndef PGLOGICAL_RELID_MAP +#define PGLOGICAL_RELID_MAP + +#define PGL_INIT_RELID_MAP_SIZE 256 + +typedef struct PGLRelidMapEntry { + Oid remote_relid; + Oid local_relid; +} PGLRelidMapEntry; + +extern Oid pglogical_relid_map_get(Oid relid); +extern bool pglogical_relid_map_put(Oid remote_relid, Oid local_relid); + +#endif From 9bacc10cac7de1f53acc368a899be07e2708b6bf Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Mon, 4 Apr 2016 20:31:01 +0300 Subject: [PATCH 0359/1139] temp index fix --- multimaster.c | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index b6cf5addaa..bd1735603e 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2230,9 +2230,10 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) } if (!MtmRunUtilityStmt(conns[i], sql, &utility_errmsg) && !ignoreError) { - // errorMsg = "Failed to run command at node %d"; - // XXX: add check for our node - errorMsg = utility_errmsg; + if (i + 1 == MtmNodeId) + errorMsg = utility_errmsg; + else + errorMsg = "Failed to run command at node %d"; failedNode = i; break; @@ -2433,6 +2434,27 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, skipCommand = stmt->relation->relpersistence == RELPERSISTENCE_TEMP; } break; + case T_IndexStmt: + { + Oid relid; + LOCKMODE lockmode; + Relation rel; + + IndexStmt *stmt = (IndexStmt *) parsetree; + lockmode = stmt->concurrent ? ShareUpdateExclusiveLock + : ShareLock; + relid = RangeVarGetRelidExtended(stmt->relation, lockmode, + false, false, + NULL, // ??? + NULL); + + rel = heap_open(relid, lockmode); + + skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; + + heap_close(rel, NoLock); + } + break; default: skipCommand = false; break; From 3cdb37312c2a2a7373e4c9a33e8cd92c6afb4bcf Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 5 Apr 2016 13:03:26 +0300 Subject: [PATCH 0360/1139] disallow concurrent index creation insise tx --- multimaster.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/multimaster.c b/multimaster.c index bd1735603e..26ac5c21f0 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2437,21 +2437,17 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_IndexStmt: { Oid relid; - LOCKMODE lockmode; Relation rel; - IndexStmt *stmt = (IndexStmt *) parsetree; - lockmode = stmt->concurrent ? ShareUpdateExclusiveLock - : ShareLock; - relid = RangeVarGetRelidExtended(stmt->relation, lockmode, - false, false, - NULL, // ??? - NULL); + bool isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL); - rel = heap_open(relid, lockmode); + if (stmt->concurrent) + PreventTransactionChain(isTopLevel, + "CREATE INDEX CONCURRENTLY"); + relid = RelnameGetRelid(stmt->relation->relname); + rel = heap_open(relid, ShareLock); skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; - heap_close(rel, NoLock); } break; From dc4fb754c0aaeb0a36965e44a202846838d40c2c Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 5 Apr 2016 18:02:40 +0300 Subject: [PATCH 0361/1139] handle exit of wal-sender --- multimaster.c | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/multimaster.c b/multimaster.c index 26ac5c21f0..fd8e3e4185 100644 --- a/multimaster.c +++ b/multimaster.c @@ -864,10 +864,13 @@ void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd) void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { - MtmLock(LW_EXCLUSIVE); - MtmSyncClock(globalSnapshot); - MtmUnlock(); - + if (globalSnapshot != INVALID_CSN) { + MtmLock(LW_EXCLUSIVE); + MtmSyncClock(globalSnapshot); + MtmUnlock(); + } else { + globalSnapshot = MtmTx.snapshot; + } if (!TransactionIdIsValid(gtid->xid)) { /* In case of recovery InvalidTransactionId is passed */ Assert(Mtm->status == MTM_RECOVERY); @@ -1876,6 +1879,14 @@ void MtmDropNode(int nodeId, bool dropSlot) } } } +static void +MtmOnProcExit(int code, Datum arg) +{ + if (MtmReplicationNodeId >= 0) { + elog(WARNING, "WAL-sender to %d is terminated", MtmReplicationNodeId); + MtmOnNodeDisconnect(MtmReplicationNodeId); + } +} static void MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) @@ -1922,13 +1933,17 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) elog(NOTICE, "Node %d start logical replication to node %d in normal mode", MtmNodeId, MtmReplicationNodeId); } MtmUnlock(); + on_proc_exit(MtmOnProcExit, 0); } static void MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) { - elog(WARNING, "Logical replication to node %d is stopped", MtmReplicationNodeId); - MtmOnNodeDisconnect(MtmReplicationNodeId); + if (MtmReplicationNodeId >= 0) { + elog(WARNING, "Logical replication to node %d is stopped", MtmReplicationNodeId); + MtmOnNodeDisconnect(MtmReplicationNodeId); + MtmReplicationNodeId = -1; /* defuse on_proc_exit hook */ + } } static bool @@ -2166,7 +2181,8 @@ static bool MtmRunUtilityStmt(PGconn* conn, char const* sql, char **errmsg) return ret; } -void MtmNoticeReceiver(void *i, const PGresult *res) +static void +MtmNoticeReceiver(void *i, const PGresult *res) { char *notice = PQresultErrorMessage(res); char *stripped_notice; From a07363ccef10365fc36fcccd6d708fccd92e5d6e Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 5 Apr 2016 20:10:18 +0300 Subject: [PATCH 0362/1139] Set SO_KEEPALIVE --- arbiter.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/arbiter.c b/arbiter.c index 69a789722b..7ef404be72 100644 --- a/arbiter.c +++ b/arbiter.c @@ -239,11 +239,15 @@ static int MtmReadSocket(int sd, void* buf, int buf_size) static void MtmSetSocketOptions(int sd) { #ifdef TCP_NODELAY - int optval = 1; - if (setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&optval, sizeof(optval)) < 0) { + int on = 1; + if (setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char const*)&on, sizeof(on)) < 0) { elog(WARNING, "Failed to set TCP_NODELAY: %m"); } #endif + if (setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (char const*)&on, sizeof(on)) < 0) { + elog(WARNING, "Failed to set SO_KEEPALIVE: %m"); + } + if (tcp_keepalives_idle) { #ifdef TCP_KEEPIDLE if (setsockopt(sd, IPPROTO_TCP, TCP_KEEPIDLE, From 33162a6450764b559358aa02ace94e40002cbbd2 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 6 Apr 2016 11:03:34 +0300 Subject: [PATCH 0363/1139] wip --- multimaster.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/multimaster.c b/multimaster.c index fd8e3e4185..c911a50222 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2467,6 +2467,18 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, heap_close(rel, NoLock); } break; + case T_DropStmt: + { + Oid relid; + Relation rel; + DropStmt *stmt = (DropStmt *) parsetree; + + //relid = RelnameGetRelid(stmt->relation->relname); + //rel = heap_open(relid, ShareLock); + //skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; + //heap_close(rel, NoLock); + } + break; default: skipCommand = false; break; From d0cbe22d645ec658c1c71aefe6914fa9b49eaf48 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 6 Apr 2016 15:16:38 +0300 Subject: [PATCH 0364/1139] Add a tap test with dtmbench. --- Makefile | 6 ++- t/001_basic_recovery.pl | 7 ++- t/002_dtmbench.pl | 117 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 127 insertions(+), 3 deletions(-) create mode 100644 t/002_dtmbench.pl diff --git a/Makefile b/Makefile index 921016283a..11e4319936 100644 --- a/Makefile +++ b/Makefile @@ -3,6 +3,7 @@ OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o override CPPFLAGS += -I../raftable +SCRIPTS_built = tests/dtmbench EXTRA_INSTALL = contrib/raftable contrib/mmts EXTENSION = multimaster @@ -10,7 +11,10 @@ DATA = multimaster--1.0.sql .PHONY: all -all: multimaster.so +all: multimaster.so tests/dtmbench + +tests/dtmbench: + make -C tests PG_CPPFLAGS = -I$(libpq_srcdir) -DUSE_PGLOGICAL_OUTPUT SHLIB_LINK = $(libpq) diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index 0901674383..871ce3acea 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -94,9 +94,10 @@ sub PostgresNode::inet_connstr { # Work after node stop ############################################################################### +diag("stopping node 2"); $nodes[2]->teardown_node; -diag("sleeping"); +diag("sleeping 15"); sleep(15); diag("inserting 2"); @@ -110,8 +111,10 @@ sub PostgresNode::inet_connstr { # Work after node start ############################################################################### +diag("starting node 2"); $nodes[2]->start; -sleep(15); # XXX: here we can poll +diag("sleeping 30"); +sleep(30); # XXX: here we can poll diag("inserting 3"); $nodes[0]->psql('postgres', "insert into t values(3, 30);"); diag("selecting"); diff --git a/t/002_dtmbench.pl b/t/002_dtmbench.pl new file mode 100644 index 0000000000..b34d470c4c --- /dev/null +++ b/t/002_dtmbench.pl @@ -0,0 +1,117 @@ +use strict; +use warnings; + +use PostgresNode; +use TestLib; +use Test::More tests => 1; + +my %allocated_ports = (); +sub allocate_ports +{ + my @allocated_now = (); + my ($host, $ports_to_alloc) = @_; + + while ($ports_to_alloc > 0) + { + my $port = int(rand() * 16384) + 49152; + next if $allocated_ports{$port}; + diag("checking for port $port\n"); + if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) + { + $allocated_ports{$port} = 1; + push(@allocated_now, $port); + $ports_to_alloc--; + } + } + + return @allocated_now; +} + +my $nnodes = 2; +my @nodes = (); + +diag("creating nodes"); +foreach my $i (1..$nnodes) +{ + my $host = "127.0.0.1"; + my ($pgport, $raftport) = allocate_ports($host, 2); + my $node = new PostgresNode("node$i", $host, $pgport); + $node->{id} = $i; + $node->{raftport} = $raftport; + push(@nodes, $node); +} + +my $mm_connstr = join(',', map { "${ \$_->connstr('postgres') }" } @nodes); +my $raft_peers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @nodes); + +diag("mm_connstr = $mm_connstr\n"); +diag("raft_peers = $raft_peers\n"); + +diag("initting and configuring nodes"); +foreach my $node (@nodes) +{ + my $id = $node->{id}; + my $host = $node->host; + my $pgport = $node->port; + my $raftport = $node->{raftport}; + + $node->init(hba_permit_replication => 0); + $node->append_conf("postgresql.conf", qq( + listen_addresses = '$host' + unix_socket_directories = '' + port = $pgport + max_prepared_transactions = 10 + max_worker_processes = 10 + wal_level = logical + fsync = off + max_wal_senders = 10 + wal_sender_timeout = 0 + max_replication_slots = 10 + shared_preload_libraries = 'raftable,multimaster' + multimaster.workers = 4 + multimaster.queue_size = 10485760 # 10mb + multimaster.node_id = $id + multimaster.conn_strings = '$mm_connstr' + multimaster.use_raftable = true + raftable.id = $id + raftable.peers = '$raft_peers' + )); + + $node->append_conf("pg_hba.conf", qq( + local replication all trust + host replication all 127.0.0.1/32 trust + host replication all ::1/128 trust + )); +} + +diag("starting nodes"); +foreach my $node (@nodes) +{ + $node->start(); +} + +my ($rc, $out, $err); + +diag("sleeping"); +sleep(10); + +my @argv = ('dtmbench'); +foreach my $node (@nodes) +{ + push(@argv, '-c', $node->connstr('postgres')); +} +push(@argv, '-n', 10, '-a', 1000, '-w', 10, '-r', 1); + +diag("running dtmbench -i"); +TestLib::run_log([@argv, '-i']); + +diag("running dtmbench"); +TestLib::run_log(\@argv, '>', \$out); +if ($out =~ /Wrong sum/) +{ + fail("inconsistency detected"); +} +else +{ + pass("all consistent during dtmbench"); +} From 875743b2823c8ff17703029c7d2199b84aaaa80d Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 6 Apr 2016 15:34:08 +0300 Subject: [PATCH 0365/1139] Bail out of dtmbench tap test if database init failed. --- t/002_dtmbench.pl | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/t/002_dtmbench.pl b/t/002_dtmbench.pl index b34d470c4c..93dcacb565 100644 --- a/t/002_dtmbench.pl +++ b/t/002_dtmbench.pl @@ -103,11 +103,17 @@ sub allocate_ports push(@argv, '-n', 10, '-a', 1000, '-w', 10, '-r', 1); diag("running dtmbench -i"); -TestLib::run_log([@argv, '-i']); +if (TestLib::run_log([@argv, '-i'])) +{ + BAIL_OUT("dtmbench -i failed"); +} diag("running dtmbench"); -TestLib::run_log(\@argv, '>', \$out); -if ($out =~ /Wrong sum/) +if (TestLib::run_log(\@argv, '>', \$out)) +{ + fail("dtmbench failed"); +} +elsif ($out =~ /Wrong sum/) { fail("inconsistency detected"); } From 8b0be3817c3f14a47c4476cd8a644ac84b433f0f Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 6 Apr 2016 15:35:59 +0300 Subject: [PATCH 0366/1139] fix drop temp table --- multimaster.c | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/multimaster.c b/multimaster.c index c911a50222..0c8f731a81 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2379,7 +2379,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag) { - bool skipCommand; + bool skipCommand = false; MTM_TRACE("%d: Process utility statement %s\n", MyProcPid, queryString); switch (nodeTag(parsetree)) { @@ -2469,14 +2469,21 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, break; case T_DropStmt: { - Oid relid; - Relation rel; DropStmt *stmt = (DropStmt *) parsetree; - //relid = RelnameGetRelid(stmt->relation->relname); - //rel = heap_open(relid, ShareLock); - //skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; - //heap_close(rel, NoLock); + if (stmt->removeType == OBJECT_TABLE) + { + RangeVar *rv = makeRangeVarFromNameList( + (List *) lfirst(list_head(stmt->objects))); + Oid relid = RelnameGetRelid(rv->relname); + + if (OidIsValid(relid)) + { + Relation rel = heap_open(relid, ShareLock); + skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; + heap_close(rel, ShareLock); + } + } } break; default: From abc2e7af27c5ccd252d1a6c951bbc80350bc5207 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 6 Apr 2016 16:44:44 +0300 Subject: [PATCH 0367/1139] fix index command for unexisintg relation; replicate create schema --- multimaster.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index 0c8f731a81..a8dc2909ec 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2462,9 +2462,13 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, "CREATE INDEX CONCURRENTLY"); relid = RelnameGetRelid(stmt->relation->relname); - rel = heap_open(relid, ShareLock); - skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; - heap_close(rel, NoLock); + + if (OidIsValid(relid)) + { + rel = heap_open(relid, ShareLock); + skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; + heap_close(rel, NoLock); + } } break; case T_DropStmt: @@ -2486,6 +2490,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, } } break; + case T_CreateSchemaStmt: default: skipCommand = false; break; From 62800c15eba132cf0ac2bf6338facfa4a35125c9 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 6 Apr 2016 16:49:36 +0300 Subject: [PATCH 0368/1139] Switch back to 1000 iterations during dtmbench tap test. --- t/002_dtmbench.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/t/002_dtmbench.pl b/t/002_dtmbench.pl index 93dcacb565..48918ee4a8 100644 --- a/t/002_dtmbench.pl +++ b/t/002_dtmbench.pl @@ -100,7 +100,7 @@ sub allocate_ports { push(@argv, '-c', $node->connstr('postgres')); } -push(@argv, '-n', 10, '-a', 1000, '-w', 10, '-r', 1); +push(@argv, '-n', 1000, '-a', 1000, '-w', 10, '-r', 1); diag("running dtmbench -i"); if (TestLib::run_log([@argv, '-i'])) From 98aa93a6f1332aef8c2d2c02df036c35125164dd Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 6 Apr 2016 19:15:45 +0300 Subject: [PATCH 0369/1139] Replace on_proc_exit with on_shmem_exit --- multimaster.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index a8dc2909ec..d4ffbb3283 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1933,7 +1933,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) elog(NOTICE, "Node %d start logical replication to node %d in normal mode", MtmNodeId, MtmReplicationNodeId); } MtmUnlock(); - on_proc_exit(MtmOnProcExit, 0); + on_shmem_exit(MtmOnProcExit, 0); } static void From 26b59ca331f6d1eec2b905b24761b24c9244bb01 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Thu, 7 Apr 2016 15:44:56 +0300 Subject: [PATCH 0370/1139] send GUC variables to nodes --- multimaster.c | 62 +++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 48 insertions(+), 14 deletions(-) diff --git a/multimaster.c b/multimaster.c index d4ffbb3283..62b584df60 100644 --- a/multimaster.c +++ b/multimaster.c @@ -139,7 +139,7 @@ HTAB* MtmXid2State; static HTAB* MtmGid2State; static HTAB* MtmLocalTables; -static bool MtmIsRecoverySession; +static bool MtmIsRecoverySession; static MtmCurrentTrans MtmTx; @@ -198,6 +198,9 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, ProcessUtilityContext context, ParamListInfo params, DestReceiver *dest, char *completionTag); +static StringInfo MtmGUCBuffer; +static bool MtmGUCBufferAllocated = false; + /* * ------------------------------------------- * Synchronize access to MTM structures. @@ -2238,6 +2241,12 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) { if (conns[i]) { + if (MtmGUCBufferAllocated && !MtmRunUtilityStmt(conns[i], MtmGUCBuffer->data, &utility_errmsg) && !ignoreError) + { + errorMsg = "Failed to set GUC variables at node %d"; + failedNode = i; + break; + } if (!MtmRunUtilityStmt(conns[i], "BEGIN TRANSACTION", &utility_errmsg) && !ignoreError) { errorMsg = "Failed to start transaction at node %d"; @@ -2249,7 +2258,10 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) if (i + 1 == MtmNodeId) errorMsg = utility_errmsg; else + { + elog(ERROR, utility_errmsg); errorMsg = "Failed to run command at node %d"; + } failedNode = i; break; @@ -2407,7 +2419,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_FetchStmt: case T_DoStmt: case T_CreateTableSpaceStmt: - case T_DropTableSpaceStmt: case T_AlterTableSpaceOptionsStmt: case T_TruncateStmt: case T_CommentStmt: /* XXX: we could replicate these */; @@ -2416,9 +2427,9 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_ExecuteStmt: case T_DeallocateStmt: case T_GrantStmt: /* XXX: we could replicate some of these these */; - case T_GrantRoleStmt: - case T_AlterDatabaseStmt: - case T_AlterDatabaseSetStmt: + //case T_GrantRoleStmt: + //case T_AlterDatabaseStmt: + //case T_AlterDatabaseSetStmt: case T_NotifyStmt: case T_ListenStmt: case T_UnlistenStmt: @@ -2427,22 +2438,46 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_VacuumStmt: case T_ExplainStmt: case T_AlterSystemStmt: - case T_VariableSetStmt: case T_VariableShowStmt: case T_DiscardStmt: - case T_CreateEventTrigStmt: - case T_AlterEventTrigStmt: - case T_CreateRoleStmt: - case T_AlterRoleStmt: - case T_AlterRoleSetStmt: - case T_DropRoleStmt: + //case T_CreateEventTrigStmt: + //case T_AlterEventTrigStmt: + //case T_CreateRoleStmt: + //case T_AlterRoleStmt: + //case T_AlterRoleSetStmt: + //case T_DropRoleStmt: case T_ReassignOwnedStmt: case T_LockStmt: - case T_ConstraintsSetStmt: + //case T_ConstraintsSetStmt: case T_CheckPointStmt: case T_ReindexStmt: skipCommand = true; break; + case T_VariableSetStmt: + { + //VariableSetStmt *stmt = (VariableSetStmt *) parsetree; + + if (!MtmGUCBufferAllocated) + { + MemoryContext oldcontext; + + oldcontext = MemoryContextSwitchTo(TopMemoryContext); + MtmGUCBuffer = makeStringInfo(); + MemoryContextSwitchTo(oldcontext); + MtmGUCBufferAllocated = true; + } + + //appendStringInfoString(MtmGUCBuffer, "SET "); + //appendStringInfoString(MtmGUCBuffer, stmt->name); + //appendStringInfoString(MtmGUCBuffer, " TO "); + //appendStringInfoString(MtmGUCBuffer, ExtractSetVariableArgs(stmt)); + //appendStringInfoString(MtmGUCBuffer, "; "); + + appendStringInfoString(MtmGUCBuffer, queryString); + + skipCommand = true; + } + break; case T_CreateStmt: { /* Do not replicate temp tables */ @@ -2490,7 +2525,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, } } break; - case T_CreateSchemaStmt: default: skipCommand = false; break; From 42e0dc091a3014626978c107cd065682c0051d2a Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Thu, 7 Apr 2016 16:35:52 +0300 Subject: [PATCH 0371/1139] Add TAP test with pgbench. --- t/003_pgbench.pl | 190 +++++++++++++++++++++++++++++++++++++++++++++++ tests/reader.pgb | 3 + tests/writer.pgb | 7 ++ 3 files changed, 200 insertions(+) create mode 100644 t/003_pgbench.pl create mode 100644 tests/reader.pgb create mode 100644 tests/writer.pgb diff --git a/t/003_pgbench.pl b/t/003_pgbench.pl new file mode 100644 index 0000000000..119d5c088e --- /dev/null +++ b/t/003_pgbench.pl @@ -0,0 +1,190 @@ +use strict; +use warnings; + +use PostgresNode; +use TestLib; +use Test::More tests => 2; +use IPC::Run qw(start finish); +use Cwd; + +my %allocated_ports = (); +sub allocate_ports +{ + my @allocated_now = (); + my ($host, $ports_to_alloc) = @_; + + while ($ports_to_alloc > 0) + { + my $port = int(rand() * 16384) + 49152; + next if $allocated_ports{$port}; + diag("checking for port $port\n"); + if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) + { + $allocated_ports{$port} = 1; + push(@allocated_now, $port); + $ports_to_alloc--; + } + } + + return @allocated_now; +} + +my $nnodes = 2; +my @nodes = (); + +diag("creating nodes"); +foreach my $i (1..$nnodes) +{ + my $host = "127.0.0.1"; + my ($pgport, $raftport) = allocate_ports($host, 2); + my $node = new PostgresNode("node$i", $host, $pgport); + $node->{id} = $i; + $node->{raftport} = $raftport; + push(@nodes, $node); +} + +my $mm_connstr = join(',', map { "${ \$_->connstr('postgres') }" } @nodes); +my $raft_peers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @nodes); + +diag("mm_connstr = $mm_connstr\n"); +diag("raft_peers = $raft_peers\n"); + +diag("initting and configuring nodes"); +foreach my $node (@nodes) +{ + my $id = $node->{id}; + my $host = $node->host; + my $pgport = $node->port; + my $raftport = $node->{raftport}; + + $node->init(hba_permit_replication => 0); + $node->append_conf("postgresql.conf", qq( + listen_addresses = '$host' + unix_socket_directories = '' + port = $pgport + max_prepared_transactions = 10 + max_worker_processes = 10 + wal_level = logical + fsync = off + max_wal_senders = 10 + wal_sender_timeout = 0 + max_replication_slots = 10 + shared_preload_libraries = 'raftable,multimaster' + multimaster.workers = 4 + multimaster.queue_size = 10485760 # 10mb + multimaster.node_id = $id + multimaster.conn_strings = '$mm_connstr' + multimaster.use_raftable = true + multimaster.ignore_tables_without_pk = true + raftable.id = $id + raftable.peers = '$raft_peers' + )); + + $node->append_conf("pg_hba.conf", qq( + local replication all trust + host replication all 127.0.0.1/32 trust + host replication all ::1/128 trust + )); +} + +diag("starting nodes"); +foreach my $node (@nodes) +{ + $node->start(); +} + +my ($rc, $out, $err); + +diag("sleeping 10"); +sleep(10); + +diag("preparing the tables"); +if ($nodes[0]->psql('postgres', "create table t (k int primary key, v int)")) +{ + BAIL_OUT('failed to create t'); +} + +if ($nodes[0]->psql('postgres', "insert into t (select generate_series(0, 999), 0)")) +{ + BAIL_OUT('failed to fill t'); +} + +if ($nodes[0]->psql('postgres', "create table reader_log (v int)")) +{ + BAIL_OUT('failed to create reader_log'); +} + +sub reader +{ + my ($node, $inref, $outref) = @_; + + my $clients = 1; + my $jobs = 1; + my $seconds = 30; + my $tps = 10; + my @argv = ( + 'pgbench', + '-n', + -c => $clients, + -j => $jobs, + -T => $seconds, + -h => $node->host(), + -p => $node->port(), + -f => 'tests/writer.pgb', + -R => $tps, + 'postgres', + ); + + diag("running[" . getcwd() . "]: " . join(' ', @argv)); + + return start(\@argv, $inref, $outref); +} + +sub writer +{ + my ($node, $inref, $outref) = @_; + + my $clients = 10; + my $jobs = 10; + my $seconds = 30; + my @argv = ( + 'pgbench', + '-n', + -c => $clients, + -j => $jobs, + -T => $seconds, + -h => $node->host(), + -p => $node->port(), + -f => 'tests/reader.pgb', + 'postgres', + ); + + diag("running[" . getcwd() . "]: " . join(' ', @argv)); + + return start(\@argv, $inref, $outref); +} + +diag("starting benches"); +my $in = ''; +my $out = ''; +my @benches = (); +foreach my $node (@nodes) +{ + push(@benches, writer($node, \$in, \$out)); + push(@benches, reader($node, \$in, \$out)); +} + +diag("finishing benches"); +foreach my $bench (@benches) +{ + finish($bench) || BAIL_OUT("pgbench exited with $?"); +} +diag($out); + +diag("checking readers' logs"); + +($rc, $out, $err) = $nodes[0]->psql('postgres', "select count(*) from reader_log where v != 0;"); +is($out, 0, "there is nothing except zeros in reader_log"); + +($rc, $out, $err) = $nodes[0]->psql('postgres', "select count(*) from reader_log where v = 0;"); +isnt($out, 0, "there are some zeros in reader_log"); diff --git a/tests/reader.pgb b/tests/reader.pgb new file mode 100644 index 0000000000..ccf8d7c485 --- /dev/null +++ b/tests/reader.pgb @@ -0,0 +1,3 @@ +begin; +insert into reader_log select sum(v) from t; +commit; diff --git a/tests/writer.pgb b/tests/writer.pgb new file mode 100644 index 0000000000..7252acb05e --- /dev/null +++ b/tests/writer.pgb @@ -0,0 +1,7 @@ +\setrandom src 0 999 +\setrandom dst 0 999 +\setrandom amount 1 10 +begin; +update t set v = v - :amount where k=:src; +update t set v = v + :amount where k=:dst; +commit; From 535eae1be4b6c9f299a7e494f03acb18950967b5 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Thu, 7 Apr 2016 18:58:38 +0300 Subject: [PATCH 0372/1139] Add a lock graph dumping function to multimaster sql api. --- multimaster--1.0.sql | 4 ++++ multimaster.c | 26 ++++++++++++++++++++++++++ t/002_dtmbench.pl | 6 +++--- t/003_pgbench.pl | 2 +- 4 files changed, 34 insertions(+), 4 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 0badae5022..f7e94e7706 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -40,6 +40,10 @@ CREATE FUNCTION mtm.make_table_local(relation regclass) RETURNS void AS 'MODULE_PATHNAME','mtm_make_table_local' LANGUAGE C; +CREATE FUNCTION mtm.dump_lock_graph() RETURNS text +AS 'MODULE_PATHNAME','mtm_dump_lock_graph' +LANGUAGE C; + CREATE TABLE IF NOT EXISTS mtm.ddl_log (issued timestamp with time zone not null, query text); CREATE TABLE IF NOT EXISTS mtm.local_tables(rel_schema text, rel_name text, primary key(rel_schema, rel_name)); diff --git a/multimaster.c b/multimaster.c index 62b584df60..9785cd9a82 100644 --- a/multimaster.c +++ b/multimaster.c @@ -107,6 +107,7 @@ PG_FUNCTION_INFO_V1(mtm_get_snapshot); PG_FUNCTION_INFO_V1(mtm_get_nodes_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_state); PG_FUNCTION_INFO_V1(mtm_make_table_local); +PG_FUNCTION_INFO_V1(mtm_dump_lock_graph); static Snapshot MtmGetSnapshot(Snapshot snapshot); static void MtmInitialize(void); @@ -2153,6 +2154,31 @@ Datum mtm_make_table_local(PG_FUNCTION_ARGS) return false; } +Datum mtm_dump_lock_graph(PG_FUNCTION_ARGS) +{ + StringInfo s = makeStringInfo(); + int i; + for (i = 0; i < MtmNodes; i++) + { + size_t size; + char *data = RaftableGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); + if (!data) continue; + GlobalTransactionId *gtid = (GlobalTransactionId *)data; + GlobalTransactionId *last = (GlobalTransactionId *)(data + size); + appendStringInfo(s, "node-%d lock graph: ", i+1); + while (gtid != last) { + GlobalTransactionId *src = gtid++; + appendStringInfo(s, "%d:%d -> ", src->node, src->xid); + while (gtid->node != 0) { + GlobalTransactionId *dst = gtid++; + appendStringInfo(s, "%d:%d, ", dst->node, dst->xid); + } + gtid += 1; + } + appendStringInfo(s, "\n"); + } + return CStringGetTextDatum(s->data); +} /* * ------------------------------------------- diff --git a/t/002_dtmbench.pl b/t/002_dtmbench.pl index 48918ee4a8..09d367625f 100644 --- a/t/002_dtmbench.pl +++ b/t/002_dtmbench.pl @@ -60,7 +60,7 @@ sub allocate_ports listen_addresses = '$host' unix_socket_directories = '' port = $pgport - max_prepared_transactions = 10 + max_prepared_transactions = 1000 max_worker_processes = 10 wal_level = logical fsync = off @@ -103,13 +103,13 @@ sub allocate_ports push(@argv, '-n', 1000, '-a', 1000, '-w', 10, '-r', 1); diag("running dtmbench -i"); -if (TestLib::run_log([@argv, '-i'])) +if (!TestLib::run_log([@argv, '-i'])) { BAIL_OUT("dtmbench -i failed"); } diag("running dtmbench"); -if (TestLib::run_log(\@argv, '>', \$out)) +if (!TestLib::run_log(\@argv, '>', \$out)) { fail("dtmbench failed"); } diff --git a/t/003_pgbench.pl b/t/003_pgbench.pl index 119d5c088e..e6d7b40f3e 100644 --- a/t/003_pgbench.pl +++ b/t/003_pgbench.pl @@ -62,7 +62,7 @@ sub allocate_ports listen_addresses = '$host' unix_socket_directories = '' port = $pgport - max_prepared_transactions = 10 + max_prepared_transactions = 1000 max_worker_processes = 10 wal_level = logical fsync = off From a0acd7b93e0dcc325f1ca57888dcacee8f9dbfe5 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 7 Apr 2016 20:05:42 +0300 Subject: [PATCH 0373/1139] Use MtmIsBroadcast to prevent recursion in MtmProcessDDLCommand --- multimaster.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/multimaster.c b/multimaster.c index 9785cd9a82..002f105ecf 100644 --- a/multimaster.c +++ b/multimaster.c @@ -877,7 +877,9 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) } if (!TransactionIdIsValid(gtid->xid)) { /* In case of recovery InvalidTransactionId is passed */ - Assert(Mtm->status == MTM_RECOVERY); + if (Mtm->status != MTM_RECOVERY) { + elog(PANIC, "Node %d tries to recover node %d which is in %s mode", MtmReplicationNode, MtmNodeId, MtmNodeStatusMnem[Mtm->status]); + } } else if (Mtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ MtmRecoveryCompleted(); @@ -2340,7 +2342,7 @@ static bool MtmProcessDDLCommand(char const* queryString) rel = heap_openrv_extended(rv, RowExclusiveLock, true); if (rel == NULL) { - if (!IsTransactionBlock()) { + if (!MtmIsBroadcast()) { MtmBroadcastUtilityStmt(queryString, false); return true; } From 4378dd728a63a817ade0cacc4c1d4a2259b87a66 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Fri, 8 Apr 2016 11:30:34 +0300 Subject: [PATCH 0374/1139] replicate grant stmt --- multimaster.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/multimaster.c b/multimaster.c index 002f105ecf..616ef35f32 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2272,6 +2272,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) if (MtmGUCBufferAllocated && !MtmRunUtilityStmt(conns[i], MtmGUCBuffer->data, &utility_errmsg) && !ignoreError) { errorMsg = "Failed to set GUC variables at node %d"; + elog(ERROR, utility_errmsg); failedNode = i; break; } @@ -2454,7 +2455,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_PrepareStmt: case T_ExecuteStmt: case T_DeallocateStmt: - case T_GrantStmt: /* XXX: we could replicate some of these these */; + //case T_GrantStmt: /* XXX: we could replicate some of these these */; //case T_GrantRoleStmt: //case T_AlterDatabaseStmt: //case T_AlterDatabaseSetStmt: @@ -2465,7 +2466,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_ClusterStmt: /* XXX: we could replicate these */; case T_VacuumStmt: case T_ExplainStmt: - case T_AlterSystemStmt: + //case T_AlterSystemStmt: case T_VariableShowStmt: case T_DiscardStmt: //case T_CreateEventTrigStmt: @@ -2483,7 +2484,13 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, break; case T_VariableSetStmt: { - //VariableSetStmt *stmt = (VariableSetStmt *) parsetree; + VariableSetStmt *stmt = (VariableSetStmt *) parsetree; + + skipCommand = true; + + /* Prevent SET TRANSACTION from replication */ + if (MtmTx.isTransactionBlock || stmt->kind == VAR_SET_MULTI) + break; if (!MtmGUCBufferAllocated) { @@ -2502,8 +2509,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, //appendStringInfoString(MtmGUCBuffer, "; "); appendStringInfoString(MtmGUCBuffer, queryString); - - skipCommand = true; } break; case T_CreateStmt: @@ -2530,7 +2535,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, { rel = heap_open(relid, ShareLock); skipCommand = rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP; - heap_close(rel, NoLock); + heap_close(rel, ShareLock); } } break; From e62c70015a05221f8b7eb39b6004d73ea3d93df9 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 8 Apr 2016 16:43:00 +0300 Subject: [PATCH 0375/1139] Fix compile bug in MtmJoinTransaction --- multimaster.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/multimaster.c b/multimaster.c index 616ef35f32..2a4aede640 100644 --- a/multimaster.c +++ b/multimaster.c @@ -878,7 +878,7 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) if (!TransactionIdIsValid(gtid->xid)) { /* In case of recovery InvalidTransactionId is passed */ if (Mtm->status != MTM_RECOVERY) { - elog(PANIC, "Node %d tries to recover node %d which is in %s mode", MtmReplicationNode, MtmNodeId, MtmNodeStatusMnem[Mtm->status]); + elog(PANIC, "Node %d tries to recover node %d which is in %s mode", MtmReplicationNodeId, MtmNodeId, MtmNodeStatusMnem[Mtm->status]); } } else if (Mtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ @@ -2164,20 +2164,21 @@ Datum mtm_dump_lock_graph(PG_FUNCTION_ARGS) { size_t size; char *data = RaftableGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); - if (!data) continue; - GlobalTransactionId *gtid = (GlobalTransactionId *)data; - GlobalTransactionId *last = (GlobalTransactionId *)(data + size); - appendStringInfo(s, "node-%d lock graph: ", i+1); - while (gtid != last) { - GlobalTransactionId *src = gtid++; - appendStringInfo(s, "%d:%d -> ", src->node, src->xid); - while (gtid->node != 0) { - GlobalTransactionId *dst = gtid++; - appendStringInfo(s, "%d:%d, ", dst->node, dst->xid); + if (data) { + GlobalTransactionId *gtid = (GlobalTransactionId *)data; + GlobalTransactionId *last = (GlobalTransactionId *)(data + size); + appendStringInfo(s, "node-%d lock graph: ", i+1); + while (gtid != last) { + GlobalTransactionId *src = gtid++; + appendStringInfo(s, "%d:%d -> ", src->node, src->xid); + while (gtid->node != 0) { + GlobalTransactionId *dst = gtid++; + appendStringInfo(s, "%d:%d, ", dst->node, dst->xid); + } + gtid += 1; } - gtid += 1; + appendStringInfo(s, "\n"); } - appendStringInfo(s, "\n"); } return CStringGetTextDatum(s->data); } From cc0a0544c6efc962403bb20b1716b71203395dee Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Fri, 8 Apr 2016 17:05:05 +0300 Subject: [PATCH 0376/1139] fix warnings in clang about long long formats --- Makefile | 4 ++-- arbiter.c | 25 +++++++++++++------------ multimaster.c | 16 ++++++++-------- pglogical_output.c | 1 - 4 files changed, 23 insertions(+), 23 deletions(-) diff --git a/Makefile b/Makefile index 11e4319936..e1deb094fa 100644 --- a/Makefile +++ b/Makefile @@ -3,7 +3,7 @@ OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o override CPPFLAGS += -I../raftable -SCRIPTS_built = tests/dtmbench +#SCRIPTS_built = tests/dtmbench EXTRA_INSTALL = contrib/raftable contrib/mmts EXTENSION = multimaster @@ -11,7 +11,7 @@ DATA = multimaster--1.0.sql .PHONY: all -all: multimaster.so tests/dtmbench +all: multimaster.so #tests/dtmbench tests/dtmbench: make -C tests diff --git a/arbiter.c b/arbiter.c index 7ef404be72..7c6197cb9a 100644 --- a/arbiter.c +++ b/arbiter.c @@ -105,17 +105,18 @@ static int gateway; static void MtmTransSender(Datum arg); static void MtmTransReceiver(Datum arg); -static char const* const messageText[] = -{ - "INVALID", - "HANDSHAKE", - "READY", - "PREPARE", - "PREPARED", - "ABORTED", - "STATUS" -}; - +/* + * static char const* const messageText[] = + * { + * "INVALID", + * "HANDSHAKE", + * "READY", + * "PREPARE", + * "PREPARED", + * "ABORTED", + * "STATUS" + *}; + */ static BackgroundWorker MtmSender = { "mtm-sender", @@ -715,7 +716,7 @@ static void MtmTransReceiver(Datum arg) /* Coordinator's disabled mask is wider than of this node: so reject such transaction to avoid commit on smaller subset of nodes */ elog(WARNING, "Coordinator of distributed transaction see less nodes than node %d: %lx instead of %lx", - msg->node, Mtm->disabledNodeMask, msg->disabledNodeMask); + msg->node, (long) Mtm->disabledNodeMask, (long) msg->disabledNodeMask); MtmAbortTransaction(ts); } diff --git a/multimaster.c b/multimaster.c index 2a4aede640..9d83f68da1 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1137,7 +1137,7 @@ MtmCheckClusterLock() } else { /* All lockers are synchronized their logs */ /* Remove lock and mark them as receovered */ - elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", Mtm->nLockers, Mtm->nodeLockerMask); + elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", Mtm->nLockers, (long) Mtm->nodeLockerMask); Assert(Mtm->walSenderLockerMask == 0); Assert((Mtm->nodeLockerMask & Mtm->disabledNodeMask) == Mtm->nodeLockerMask); Mtm->disabledNodeMask &= ~Mtm->nodeLockerMask; @@ -1197,7 +1197,7 @@ bool MtmRefreshClusterStatus(bool nowait) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ - elog(WARNING, "Find clique %lx, disabledNodeMask %lx", clique, Mtm->disabledNodeMask); + elog(WARNING, "Find clique %lx, disabledNodeMask %lx", (long) clique, (long) Mtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~Mtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { @@ -1225,7 +1225,7 @@ bool MtmRefreshClusterStatus(bool nowait) MtmSwitchClusterMode(MTM_RECOVERY); } } else { - elog(WARNING, "Clique %lx has no quorum", clique); + elog(WARNING, "Clique %lx has no quorum", (long) clique); MtmSwitchClusterMode(MTM_IN_MINORITY); } return true; @@ -1235,12 +1235,12 @@ void MtmCheckQuorum(void) { if (Mtm->nNodes < MtmNodes/2+1) { if (Mtm->status == MTM_ONLINE) { /* out of quorum */ - elog(WARNING, "Node is in minority: disabled mask %lx", Mtm->disabledNodeMask); + elog(WARNING, "Node is in minority: disabled mask %lx", (long) Mtm->disabledNodeMask); MtmSwitchClusterMode(MTM_IN_MINORITY); } } else { if (Mtm->status == MTM_IN_MINORITY) { - elog(WARNING, "Node is in majority: dissbled mask %lx", Mtm->disabledNodeMask); + elog(WARNING, "Node is in majority: dissbled mask %lx", (long) Mtm->disabledNodeMask); MtmSwitchClusterMode(MTM_ONLINE); } } @@ -2229,7 +2229,7 @@ MtmNoticeReceiver(void *i, const PGresult *res) /* Strip "NOTICE: " from beginning and "\n" from end of error string */ strncpy(stripped_notice, notice + 9, len - 1 - 9); - elog(NOTICE, stripped_notice); + elog(NOTICE, "%s", stripped_notice); pfree(stripped_notice); } @@ -2273,7 +2273,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) if (MtmGUCBufferAllocated && !MtmRunUtilityStmt(conns[i], MtmGUCBuffer->data, &utility_errmsg) && !ignoreError) { errorMsg = "Failed to set GUC variables at node %d"; - elog(ERROR, utility_errmsg); + elog(NOTICE, "%s", utility_errmsg); failedNode = i; break; } @@ -2289,7 +2289,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) errorMsg = utility_errmsg; else { - elog(ERROR, utility_errmsg); + elog(ERROR, "%s", utility_errmsg); errorMsg = "Failed to run command at node %d"; } diff --git a/pglogical_output.c b/pglogical_output.c index 6d3754bab9..6ae1e2277c 100644 --- a/pglogical_output.c +++ b/pglogical_output.c @@ -493,7 +493,6 @@ pg_decode_origin_filter(LogicalDecodingContext *ctx, } if (!data->forward_changesets && origin_id != InvalidRepOriginId) { - *(int*)0 = 0; return true; } From e641c6303e7bf7b6fdf32461caafe7b0c256e52f Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 8 Apr 2016 19:11:07 +0300 Subject: [PATCH 0377/1139] Fix deadlock detection --- multimaster.c | 60 ++++++++++++++++++++++++++--------------- t/001_basic_recovery.pl | 8 +++--- t/002_dtmbench.pl | 7 ++--- t/003_pgbench.pl | 7 ++--- 4 files changed, 52 insertions(+), 30 deletions(-) diff --git a/multimaster.c b/multimaster.c index 9d83f68da1..967936387a 100644 --- a/multimaster.c +++ b/multimaster.c @@ -667,6 +667,29 @@ MtmBeginTransaction(MtmCurrentTrans* x) } } + +static MtmTransState* +MtmCreateTransState(MtmCurrentTrans* x) +{ + bool found; + MtmTransState* ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, &found); + if (!found) { + ts->status = TRANSACTION_STATUS_IN_PROGRESS; + ts->snapshot = x->snapshot; + if (TransactionIdIsValid(x->gtid.xid)) { + Assert(x->gtid.node != MtmNodeId); + ts->gtid = x->gtid; + } else { + /* I am coordinator of transaction */ + ts->gtid.xid = x->xid; + ts->gtid.node = MtmNodeId; + } + } + return ts; +} + + + /* * Prepare transaction for two-phase commit. * This code is executed by PRE_PREPARE hook before PREPARE message is sent to replicas by logical replication @@ -675,7 +698,7 @@ static void MtmPrePrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; - TransactionId *subxids; + TransactionId* subxids; if (!x->isDistributed) { return; @@ -703,14 +726,12 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) MtmCheckClusterLock(); } - ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, NULL); - ts->status = TRANSACTION_STATUS_IN_PROGRESS; + ts = MtmCreateTransState(x); /* * Invalid CSN prevent replication of transaction by logical replication */ ts->snapshot = x->isReplicated || !x->containsDML ? INVALID_CSN : x->snapshot; ts->csn = MtmAssignCSN(); - ts->gtid = x->gtid; ts->procno = MyProc->pgprocno; ts->nVotes = 1; /* I am voted myself */ ts->votingCompleted = false; @@ -722,15 +743,6 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) x->csn = ts->csn; Mtm->transCount += 1; - - if (TransactionIdIsValid(x->gtid.xid)) { - Assert(x->gtid.node != MtmNodeId); - ts->gtid = x->gtid; - } else { - /* I am coordinator of transaction */ - ts->gtid.xid = x->xid; - ts->gtid.node = MtmNodeId; - } MtmTransactionListAppend(ts); MtmAddSubtransactions(ts, subxids, ts->nSubxids); MTM_TRACE("%d: MtmPrePrepareTransaction prepare commit of %d (gtid.xid=%d, gtid.node=%d, CSN=%ld)\n", @@ -844,7 +856,9 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) MtmTransactionListAppend(ts); } MtmSendNotificationMessage(ts, MSG_ABORTED); /* send notification to coordinator */ - } + } else if (x->status == TRANSACTION_STATUS_ABORTED && x->isReplicated && !x->isPrepared) { + hash_search(MtmXid2State, &x->xid, HASH_REMOVE, NULL); + } MtmUnlock(); } MtmResetTransaction(x); @@ -868,9 +882,19 @@ void MtmSendNotificationMessage(MtmTransState* ts, MtmMessageCode cmd) void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) { + MtmTx.gtid = *gtid; + MtmTx.xid = GetCurrentTransactionId(); + MtmTx.isReplicated = true; + MtmTx.isDistributed = true; + MtmTx.containsDML = true; + if (globalSnapshot != INVALID_CSN) { MtmLock(LW_EXCLUSIVE); MtmSyncClock(globalSnapshot); + MtmTx.snapshot = globalSnapshot; + if (Mtm->status != MTM_RECOVERY) { + MtmCreateTransState(&MtmTx); /* we need local->remote xid mapping for deadlock detection */ + } MtmUnlock(); } else { globalSnapshot = MtmTx.snapshot; @@ -878,18 +902,12 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) if (!TransactionIdIsValid(gtid->xid)) { /* In case of recovery InvalidTransactionId is passed */ if (Mtm->status != MTM_RECOVERY) { - elog(PANIC, "Node %d tries to recover node %d which is in %s mode", MtmReplicationNodeId, MtmNodeId, MtmNodeStatusMnem[Mtm->status]); + elog(PANIC, "Node %d tries to recover node %d which is in %s mode", gtid->node, MtmNodeId, MtmNodeStatusMnem[Mtm->status]); } } else if (Mtm->status == MTM_RECOVERY) { /* When recovery is completed we get normal transaction ID and switch to normal mode */ MtmRecoveryCompleted(); } - MtmTx.gtid = *gtid; - MtmTx.xid = GetCurrentTransactionId(); - MtmTx.snapshot = globalSnapshot; - MtmTx.isReplicated = true; - MtmTx.isDistributed = true; - MtmTx.containsDML = true; } void MtmSetCurrentTransactionGID(char const* gid) diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index 871ce3acea..cdfa3ddbec 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -31,13 +31,15 @@ sub PostgresNode::inet_connstr { my @nodes = (); my $pgconf_common = qq( listen_addresses = '127.0.0.1' - max_prepared_transactions = 10 - max_worker_processes = 10 + max_prepared_transactions = 200 + max_connections = 200 + max_worker_processes = 100 max_wal_senders = 10 max_replication_slots = 10 wal_level = logical + wal_sender_timeout = 0 shared_preload_libraries = 'raftable,multimaster' - multimaster.workers=4 + multimaster.workers=10 multimaster.queue_size=10485760 # 10mb ); diff --git a/t/002_dtmbench.pl b/t/002_dtmbench.pl index 09d367625f..1067d4d7b5 100644 --- a/t/002_dtmbench.pl +++ b/t/002_dtmbench.pl @@ -60,15 +60,16 @@ sub allocate_ports listen_addresses = '$host' unix_socket_directories = '' port = $pgport - max_prepared_transactions = 1000 - max_worker_processes = 10 + max_prepared_transactions = 200 + max_connections = 200 + max_worker_processes = 100 wal_level = logical fsync = off max_wal_senders = 10 wal_sender_timeout = 0 max_replication_slots = 10 shared_preload_libraries = 'raftable,multimaster' - multimaster.workers = 4 + multimaster.workers = 10 multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$mm_connstr' diff --git a/t/003_pgbench.pl b/t/003_pgbench.pl index e6d7b40f3e..44d2805ce8 100644 --- a/t/003_pgbench.pl +++ b/t/003_pgbench.pl @@ -62,15 +62,16 @@ sub allocate_ports listen_addresses = '$host' unix_socket_directories = '' port = $pgport - max_prepared_transactions = 1000 - max_worker_processes = 10 + max_prepared_transactions = 200 + max_connections = 200 + max_worker_processes = 100 wal_level = logical fsync = off max_wal_senders = 10 wal_sender_timeout = 0 max_replication_slots = 10 shared_preload_libraries = 'raftable,multimaster' - multimaster.workers = 4 + multimaster.workers = 10 multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$mm_connstr' From 63e88b3fc1db598e8580f6b928766c936e2e92f6 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 8 Apr 2016 20:55:41 +0300 Subject: [PATCH 0378/1139] Add recovery test --- bgwpool.c | 2 -- check-recovery.sh | 2 ++ multimaster.c | 35 +++++++++++++++++------------------ pglogical_proto.c | 3 ++- pglogical_receiver.c | 4 ++-- 5 files changed, 23 insertions(+), 23 deletions(-) create mode 100755 check-recovery.sh diff --git a/bgwpool.c b/bgwpool.c index 8ab1a7c378..564f9e659a 100644 --- a/bgwpool.c +++ b/bgwpool.c @@ -30,8 +30,6 @@ static void BgwPoolMainLoop(Datum arg) BackgroundWorkerUnblockSignals(); BackgroundWorkerInitializeConnection(pool->dbname, NULL); - elog(WARNING, "Start background worker %d", id); - while(true) { PGSemaphoreLock(&pool->available); SpinLockAcquire(&pool->lock); diff --git a/check-recovery.sh b/check-recovery.sh new file mode 100755 index 0000000000..5165fbc614 --- /dev/null +++ b/check-recovery.sh @@ -0,0 +1,2 @@ +rm -rf /home/knizhnik/postgres_cluster/contrib/mmts/tmp_check/log +TESTDIR='/home/knizhnik/postgres_cluster/contrib/mmts' PATH="/home/knizhnik/postgres_cluster/tmp_install/home/knizhnik/postgres_cluster/dist/bin:$PATH" LD_LIBRARY_PATH="/home/knizhnik/postgres_cluster/tmp_install/home/knizhnik/postgres_cluster/dist/lib:$LD_LIBRARY_PATH" PGPORT='65432' PG_REGRESS='/home/knizhnik/postgres_cluster/contrib/mmts/../../src/test/regress/pg_regress' prove -I ../../src/test/perl/ --verbose t/001_basic_recovery.pl diff --git a/multimaster.c b/multimaster.c index 967936387a..97515233d0 100644 --- a/multimaster.c +++ b/multimaster.c @@ -988,7 +988,7 @@ void MtmAbortTransaction(MtmTransState* ts) void MtmRecoveryCompleted(void) { - elog(WARNING, "Recovery of node %d is completed", MtmNodeId); + elog(NOTICE, "Recovery of node %d is completed", MtmNodeId); MtmLock(LW_EXCLUSIVE); Mtm->recoverySlot = 0; BIT_CLEAR(Mtm->disabledNodeMask, MtmNodeId-1); @@ -1071,12 +1071,12 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) XLogRecPtr walLSN = GetXLogInsertRecPtr(); if (slotLSN == walLSN && Mtm->nActiveTransactions == 0) { if (BIT_CHECK(Mtm->nodeLockerMask, nodeId-1)) { - elog(WARNING,"Node %d is caught-up", nodeId); + elog(NOTICE,"Node %d is caught-up", nodeId); BIT_CLEAR(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); BIT_CLEAR(Mtm->nodeLockerMask, nodeId-1); Mtm->nLockers -= 1; } else { - elog(WARNING,"Node %d is caugth-up without locking cluster", nodeId); + elog(NOTICE,"%d: dode %d is caugth-up without locking cluster", MyProcPid, nodeId); /* We are lucky: caugth-up without locking cluster! */ } BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); @@ -1091,7 +1091,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) * We have to maintain two bitmasks: one is marking wal sender, another - correspondent nodes. * Is there some better way to establish mapping between nodes ad WAL-seconder? */ - elog(WARNING,"Node %d is almost caught-up: slot position %lx, WAL position %lx, active transactions %d", + elog(NOTICE,"Node %d is almost caught-up: slot position %lx, WAL position %lx, active transactions %d", nodeId, slotLSN, walLSN, Mtm->nActiveTransactions); Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ BIT_SET(Mtm->nodeLockerMask, nodeId-1); @@ -1108,7 +1108,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) void MtmSwitchClusterMode(MtmNodeStatus mode) { Mtm->status = mode; - elog(WARNING, "Switch to %s mode", MtmNodeStatusMnem[mode]); + elog(NOTICE, "Switch to %s mode", MtmNodeStatusMnem[mode]); /* ??? Something else to do here? */ } @@ -1136,7 +1136,7 @@ MtmCheckClusterLock() break; } else { /* recovered replica catched up with master */ - elog(WARNING, "WAL-sender %d complete recovery", i); + elog(NOTICE, "WAL-sender %d complete recovery", i); BIT_CLEAR(Mtm->walSenderLockerMask, i); } } @@ -1155,7 +1155,7 @@ MtmCheckClusterLock() } else { /* All lockers are synchronized their logs */ /* Remove lock and mark them as receovered */ - elog(WARNING, "Complete recovery of %d nodes (node mask %lx)", Mtm->nLockers, (long) Mtm->nodeLockerMask); + elog(NOTICE, "Complete recovery of %d nodes (node mask %lx)", Mtm->nLockers, (long) Mtm->nodeLockerMask); Assert(Mtm->walSenderLockerMask == 0); Assert((Mtm->nodeLockerMask & Mtm->disabledNodeMask) == Mtm->nodeLockerMask); Mtm->disabledNodeMask &= ~Mtm->nodeLockerMask; @@ -1215,7 +1215,7 @@ bool MtmRefreshClusterStatus(bool nowait) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ - elog(WARNING, "Find clique %lx, disabledNodeMask %lx", (long) clique, (long) Mtm->disabledNodeMask); + elog(NOTICE, "Find clique %lx, disabledNodeMask %lx", (long) clique, (long) Mtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~Mtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { @@ -1243,7 +1243,7 @@ bool MtmRefreshClusterStatus(bool nowait) MtmSwitchClusterMode(MTM_RECOVERY); } } else { - elog(WARNING, "Clique %lx has no quorum", (long) clique); + elog(NOTICE, "Clique %lx has no quorum", (long) clique); MtmSwitchClusterMode(MTM_IN_MINORITY); } return true; @@ -1258,7 +1258,7 @@ void MtmCheckQuorum(void) } } else { if (Mtm->status == MTM_IN_MINORITY) { - elog(WARNING, "Node is in majority: dissbled mask %lx", (long) Mtm->disabledNodeMask); + elog(NOTICE, "Node is in majority: dissbled mask %lx", (long) Mtm->disabledNodeMask); MtmSwitchClusterMode(MTM_ONLINE); } } @@ -1285,7 +1285,7 @@ void MtmOnNodeDisconnect(int nodeId) for (ts = Mtm->transListHead; ts != NULL; ts = ts->next) { if (!ts->votingCompleted) { if (ts->status != TRANSACTION_STATUS_ABORTED) { - elog(WARNING, "Rollback active transaction %d:%d", ts->gtid.node, ts->gtid.xid); + elog(NOTICE, "Rollback active transaction %d:%d", ts->gtid.node, ts->gtid.xid); MtmAbortTransaction(ts); } MtmWakeUpBackend(ts); @@ -1844,7 +1844,7 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) recovery = true; if (Mtm->recoverySlot == 0 || Mtm->recoverySlot == nodeId) { /* Choose for recovery first available slot */ - elog(WARNING, "Start recovery from node %d", nodeId); + elog(NOTICE, "Start recovery from node %d", nodeId); Mtm->recoverySlot = nodeId; return SLOT_OPEN_EXISTED; } @@ -1853,7 +1853,7 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) MtmSleep(STATUS_POLL_DELAY); } if (recovery) { - elog(WARNING, "Recreate replication slot for node %d after end of recovery", nodeId); + elog(NOTICE, "Recreate replication slot for node %d after end of recovery", nodeId); } else { MTM_INFO("%d: Reuse replication slot for node %d\n", MyProcPid, nodeId); } @@ -1907,7 +1907,7 @@ static void MtmOnProcExit(int code, Datum arg) { if (MtmReplicationNodeId >= 0) { - elog(WARNING, "WAL-sender to %d is terminated", MtmReplicationNodeId); + elog(NOTICE, "WAL-sender to %d is terminated", MtmReplicationNodeId); MtmOnNodeDisconnect(MtmReplicationNodeId); } } @@ -1938,7 +1938,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) } MtmLock(LW_EXCLUSIVE); if (MtmIsRecoverySession) { - elog(WARNING, "%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); + elog(NOTICE, "%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes -= 1; @@ -1946,7 +1946,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) } } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { if (recoveryCompleted) { - elog(WARNING, "Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); + elog(NOTICE, "Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes += 1; MtmCheckQuorum(); @@ -1964,7 +1964,7 @@ static void MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) { if (MtmReplicationNodeId >= 0) { - elog(WARNING, "Logical replication to node %d is stopped", MtmReplicationNodeId); + elog(NOTICE, "Logical replication to node %d is stopped", MtmReplicationNodeId); MtmOnNodeDisconnect(MtmReplicationNodeId); MtmReplicationNodeId = -1; /* defuse on_proc_exit hook */ } @@ -2411,7 +2411,6 @@ static bool MtmTwoPhaseCommit(MtmCurrentTrans* x) if (x->isDistributed && x->containsDML) { MtmGenerateGid(x->gid); if (!x->isTransactionBlock) { - /* elog(WARNING, "Start transaction block for %s", x->gid); */ BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); diff --git a/pglogical_proto.c b/pglogical_proto.c index d3e7da2399..9ddd7b703a 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -150,6 +150,7 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, return; } if (MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn)) { + elog(NOTICE, "wal-sender complete recovery of node %d at LSN(commit %lx, end %lx, log %lx) in transaction %s event %d", MtmReplicationNodeId, commit_lsn, txn->end_lsn, GetXLogInsertRecPtr(), txn->gid, flags); flags |= PGLOGICAL_CAUGHT_UP; } } @@ -418,7 +419,7 @@ pglogical_init_api(PGLogicalProtoType typ) { PGLogicalProtoAPI* res = palloc0(sizeof(PGLogicalProtoAPI)); sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &MtmReplicationNodeId); - elog(WARNING, "%d: PRGLOGICAL init API for slot %s node %d", MyProcPid, MyReplicationSlot->data.name.data, MtmReplicationNodeId); + elog(LOG, "%d: PRGLOGICAL init API for slot %s node %d", MyProcPid, MyReplicationSlot->data.name.data, MtmReplicationNodeId); res->write_rel = pglogical_write_rel; res->write_begin = pglogical_write_begin; res->write_commit = pglogical_write_commit; diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 31084dfc85..18642622f1 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -292,10 +292,10 @@ pglogical_receiver_main(Datum main_arg) * So we assume that LSNs are the same for local and remote node */ originStartPos = Mtm->status == MTM_RECOVERY ? GetXLogInsertRecPtr() : 0; - elog(WARNING, "Start logical receiver at position %lx from node %d", originStartPos, args->remote_node); + elog(NOTICE, "Start logical receiver at position %lx from node %d", originStartPos, args->remote_node); } else { originStartPos = replorigin_get_progress(originId, false); - elog(WARNING, "Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); + elog(NOTICE, "Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); } CommitTransactionCommand(); From 2ccf1fcbcd6da057c7bccf7a1d96a531c21167a1 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 10 Apr 2016 22:22:08 +0300 Subject: [PATCH 0379/1139] Improve logging --- arbiter.c | 8 ++-- decoder_raw.c | 12 +++--- multimaster.c | 98 ++++++++++++++++++++++---------------------- multimaster.h | 29 +++++++++---- pglogical_apply.c | 32 ++++++++------- pglogical_proto.c | 10 ++--- pglogical_receiver.c | 4 +- 7 files changed, 105 insertions(+), 88 deletions(-) diff --git a/arbiter.c b/arbiter.c index 7c6197cb9a..ea8bcdf2af 100644 --- a/arbiter.c +++ b/arbiter.c @@ -412,7 +412,7 @@ static bool MtmSendToNode(int node, void const* buf, int size) MtmOnNodeDisconnect(node+1); return false; } - MTM_TRACE("Arbiter restablished connection with node %d\n", node+1); + MTM_LOG3("Arbiter restablished connection with node %d", node+1); } else { return true; } @@ -456,7 +456,7 @@ static void MtmAcceptOneConnection() elog(WARNING, "Arbiter failed to write response for handshake message to node %d", resp.node); close(fd); } else { - elog(NOTICE, "Arbiter established connection with node %d", req.hdr.node); + MTM_LOG1("Arbiter established connection with node %d", req.hdr.node); BIT_CLEAR(Mtm->connectivityMask, req.hdr.node-1); MtmRegisterSocket(fd, req.hdr.node-1); sockets[req.hdr.node-1] = fd; @@ -509,8 +509,8 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt } buf->used = 0; } - MTM_TRACE("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d\n", - messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); + MTM_LOG3("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d", + messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); Assert(ts->cmd != MSG_INVALID); buf->data[buf->used].code = ts->cmd; diff --git a/decoder_raw.c b/decoder_raw.c index 2cd1db5705..9c668cd311 100644 --- a/decoder_raw.c +++ b/decoder_raw.c @@ -108,11 +108,11 @@ decoder_raw_begin_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn) Assert(lastXid != txn->xid); lastXid = txn->xid; if (MMIsLocalTransaction(txn->xid)) { - MTM_TRACE("Skip local transaction %u\n", txn->xid); + MTM_LOG3("Skip local transaction %u", txn->xid); data->isLocal = true; } else { OutputPluginPrepareWrite(ctx, true); - MTM_TRACE("Send transaction %u to replica\n", txn->xid); + MTM_LOG3("Send transaction %u to replica", txn->xid); appendStringInfo(ctx->out, "BEGIN %u;", txn->xid); OutputPluginWrite(ctx, true); data->isLocal = false; @@ -126,12 +126,12 @@ decoder_raw_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, { DecoderRawData *data = ctx->output_plugin_private; if (!data->isLocal) { - MTM_TRACE("Send commit of transaction %u to replica\n", txn->xid); + MTM_LOG3("Send commit of transaction %u to replica", txn->xid); OutputPluginPrepareWrite(ctx, true); appendStringInfoString(ctx->out, "COMMIT;"); OutputPluginWrite(ctx, true); } else { - MTM_TRACE("Skip commit of transaction %u\n", txn->xid); + MTM_LOG3("Skip commit of transaction %u", txn->xid); } } @@ -483,10 +483,10 @@ decoder_raw_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, data = ctx->output_plugin_private; if (data->isLocal) { - MTM_TRACE("Skip action %d in transaction %u\n", change->action, txn->xid); + MTM_LOG3("Skip action %d in transaction %u", change->action, txn->xid); return; } - MTM_TRACE("Send action %d in transaction %u to replica\n", change->action, txn->xid); + MTM_LOG3("Send action %d in transaction %u to replica", change->action, txn->xid); /* Avoid leaking memory by using and resetting our own context */ old = MemoryContextSwitchTo(data->context); diff --git a/multimaster.c b/multimaster.c index 97515233d0..b86ce8d55d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -360,14 +360,14 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (ts != NULL && ts->status != TRANSACTION_STATUS_IN_PROGRESS) { if (ts->csn > MtmTx.snapshot) { - MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld\n", - MyProcPid, xid, ts->csn, MtmTx.snapshot); + MTM_LOG4("%d: tuple with xid=%d(csn=%ld) is invisibile in snapshot %ld", + MyProcPid, xid, ts->csn, MtmTx.snapshot); MtmUnlock(); return true; } if (ts->status == TRANSACTION_STATUS_UNKNOWN) { - MTM_TRACE("%d: wait for in-doubt transaction %u in snapshot %lu\n", MyProcPid, xid, MtmTx.snapshot); + MTM_LOG3("%d: wait for in-doubt transaction %u in snapshot %lu", MyProcPid, xid, MtmTx.snapshot); MtmUnlock(); #if TRACE_SLEEP_TIME { @@ -385,7 +385,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (firstReportTime == 0) { firstReportTime = now; } else { - MTM_TRACE("Snapshot sleep %lu of %lu usec (%f%%), maximum=%lu\n", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime), maxSleepTime); + MTM_LOG3("Snapshot sleep %lu of %lu usec (%f%%), maximum=%lu", totalSleepTime, now - firstReportTime, totalSleepTime*100.0/(now - firstReportTime), maxSleepTime); } } } @@ -398,15 +398,15 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) else { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; - MTM_TUPLE_TRACE("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld\n", - MyProcPid, xid, ts->csn, invisible ? "rollbacked" : "committed", MtmTx.snapshot); + MTM_LOG4("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld", + MyProcPid, xid, ts->csn, invisible ? "rollbacked" : "committed", MtmTx.snapshot); MtmUnlock(); return invisible; } } else { - MTM_TUPLE_TRACE("%d: visibility check is skept for transaction %u in snapshot %lu\n", MyProcPid, xid, MtmTx.snapshot); + MTM_LOG4("%d: visibility check is skept for transaction %u in snapshot %lu", MyProcPid, xid, MtmTx.snapshot); break; } } @@ -662,8 +662,8 @@ MtmBeginTransaction(MtmCurrentTrans* x) x->status = TRANSACTION_STATUS_IN_PROGRESS; MtmUnlock(); - MTM_TRACE("%d: MtmLocalTransaction: %s transaction %u uses local snapshot %lu\n", - MyProcPid, x->isDistributed ? "distributed" : "local", x->xid, x->snapshot); + MTM_LOG3("%d: MtmLocalTransaction: %s transaction %u uses local snapshot %lu", + MyProcPid, x->isDistributed ? "distributed" : "local", x->xid, x->snapshot); } } @@ -745,8 +745,8 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) Mtm->transCount += 1; MtmTransactionListAppend(ts); MtmAddSubtransactions(ts, subxids, ts->nSubxids); - MTM_TRACE("%d: MtmPrePrepareTransaction prepare commit of %d (gtid.xid=%d, gtid.node=%d, CSN=%ld)\n", - MyProcPid, x->xid, ts->gtid.xid, ts->gtid.node, ts->csn); + MTM_LOG3("%d: MtmPrePrepareTransaction prepare commit of %d (gtid.xid=%d, gtid.node=%d, CSN=%ld)", + MyProcPid, x->xid, ts->gtid.xid, ts->gtid.node, ts->csn); MtmUnlock(); } @@ -781,7 +781,7 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MtmLock(LW_SHARED); } x->status = ts->status; - MTM_TRACE("%d: Result of vote: %d\n", MyProcPid, ts->status); + MTM_LOG3("%d: Result of vote: %d", MyProcPid, ts->status); MtmUnlock(); } } @@ -805,8 +805,8 @@ MtmAbortPreparedTransaction(MtmCurrentTrans* x) static void MtmEndTransaction(MtmCurrentTrans* x, bool commit) { - MTM_TRACE("%d: End transaction %d, prepared=%d, replicated=%d, distributed=%d, gid=%s -> %s\n", - MyProcPid, x->xid, x->isPrepared, x->isReplicated, x->isDistributed, x->gid, commit ? "commit" : "abort"); + MTM_LOG3("%d: End transaction %d, prepared=%d, replicated=%d, distributed=%d, gid=%s -> %s", + MyProcPid, x->xid, x->isPrepared, x->isReplicated, x->isDistributed, x->gid, commit ? "commit" : "abort"); if (x->status != TRANSACTION_STATUS_ABORTED && x->isDistributed && (x->isPrepared || x->isReplicated)) { MtmTransState* ts = NULL; MtmLock(LW_EXCLUSIVE); @@ -818,7 +818,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) if (tm != NULL) { ts = tm->state; } else { - MTM_TRACE("%d: GID %s not found\n", MyProcPid, x->gid); + MTM_LOG3("%d: GID %s not found", MyProcPid, x->gid); } } if (ts != NULL) { @@ -842,7 +842,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) * Send notification only if ABORT happens during transaction processing at replicas, * do not send notification if ABORT is receiver from master */ - MTM_INFO("%d: send ABORT notification abort transaction %d to coordinator %d\n", MyProcPid, x->gtid.xid, x->gtid.node); + MTM_LOG2("%d: send ABORT notification abort transaction %d to coordinator %d", MyProcPid, x->gtid.xid, x->gtid.node); if (ts == NULL) { Assert(TransactionIdIsValid(x->xid)); ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, NULL); @@ -912,7 +912,7 @@ void MtmJoinTransaction(GlobalTransactionId* gtid, csn_t globalSnapshot) void MtmSetCurrentTransactionGID(char const* gid) { - MTM_TRACE("Set current transaction GID %s\n", gid); + MTM_LOG3("Set current transaction GID %s", gid); strcpy(MtmTx.gid, gid); MtmTx.isDistributed = true; MtmTx.isReplicated = true; @@ -947,7 +947,7 @@ XidStatus MtmGetGlobalTransactionStatus(char const* gid) void MtmSetCurrentTransactionCSN(csn_t csn) { - MTM_TRACE("Set current transaction CSN %ld\n", csn); + MTM_LOG3("Set current transaction CSN %ld", csn); MtmTx.csn = csn; MtmTx.isDistributed = true; MtmTx.isReplicated = true; @@ -968,7 +968,7 @@ csn_t MtmGetTransactionCSN(TransactionId xid) void MtmWakeUpBackend(MtmTransState* ts) { - MTM_TRACE("Wakeup backed procno=%d, pid=%d\n", ts->procno, ProcGlobal->allProcs[ts->procno].pid); + MTM_LOG3("Wakeup backed procno=%d, pid=%d", ts->procno, ProcGlobal->allProcs[ts->procno].pid); ts->votingCompleted = true; SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } @@ -988,7 +988,7 @@ void MtmAbortTransaction(MtmTransState* ts) void MtmRecoveryCompleted(void) { - elog(NOTICE, "Recovery of node %d is completed", MtmNodeId); + MTM_LOG1("Recovery of node %d is completed", MtmNodeId); MtmLock(LW_EXCLUSIVE); Mtm->recoverySlot = 0; BIT_CLEAR(Mtm->disabledNodeMask, MtmNodeId-1); @@ -1018,9 +1018,9 @@ MtmCheckSlots() && slot->data.confirmed_flush + MtmMaxRecoveryLag < GetXLogInsertRecPtr()) { elog(WARNING, "Drop slot for node %d which lag %ld is larger than threshold %d", - nodeId, - GetXLogInsertRecPtr() - slot->data.restart_lsn, - MtmMaxRecoveryLag); + nodeId, + GetXLogInsertRecPtr() - slot->data.restart_lsn, + MtmMaxRecoveryLag); ReplicationSlotDrop(slot->data.name.data); } } @@ -1071,12 +1071,12 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) XLogRecPtr walLSN = GetXLogInsertRecPtr(); if (slotLSN == walLSN && Mtm->nActiveTransactions == 0) { if (BIT_CHECK(Mtm->nodeLockerMask, nodeId-1)) { - elog(NOTICE,"Node %d is caught-up", nodeId); + MTM_LOG1("Node %d is caught-up", nodeId); BIT_CLEAR(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); BIT_CLEAR(Mtm->nodeLockerMask, nodeId-1); Mtm->nLockers -= 1; } else { - elog(NOTICE,"%d: dode %d is caugth-up without locking cluster", MyProcPid, nodeId); + MTM_LOG1("%d: dode %d is caugth-up without locking cluster", MyProcPid, nodeId); /* We are lucky: caugth-up without locking cluster! */ } BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); @@ -1091,14 +1091,14 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) * We have to maintain two bitmasks: one is marking wal sender, another - correspondent nodes. * Is there some better way to establish mapping between nodes ad WAL-seconder? */ - elog(NOTICE,"Node %d is almost caught-up: slot position %lx, WAL position %lx, active transactions %d", + MTM_LOG1("Node %d is almost caught-up: slot position %lx, WAL position %lx, active transactions %d", nodeId, slotLSN, walLSN, Mtm->nActiveTransactions); Assert(MyWalSnd != NULL); /* This function is called by WAL-sender, so it should not be NULL */ BIT_SET(Mtm->nodeLockerMask, nodeId-1); BIT_SET(Mtm->walSenderLockerMask, MyWalSnd - WalSndCtl->walsnds); Mtm->nLockers += 1; } else { - MTM_INFO("Continue recovery of node %d, slot position %lx, WAL position %lx, WAL sender position %lx, lockers %d, active transactions %d\n", nodeId, slotLSN, walLSN, MyWalSnd->sentPtr, Mtm->nLockers, Mtm->nActiveTransactions); + MTM_LOG2("Continue recovery of node %d, slot position %lx, WAL position %lx, WAL sender position %lx, lockers %d, active transactions %d", nodeId, slotLSN, walLSN, MyWalSnd->sentPtr, Mtm->nLockers, Mtm->nActiveTransactions); } } MtmUnlock(); @@ -1108,7 +1108,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) void MtmSwitchClusterMode(MtmNodeStatus mode) { Mtm->status = mode; - elog(NOTICE, "Switch to %s mode", MtmNodeStatusMnem[mode]); + MTM_LOG1("Switch to %s mode", MtmNodeStatusMnem[mode]); /* ??? Something else to do here? */ } @@ -1136,7 +1136,7 @@ MtmCheckClusterLock() break; } else { /* recovered replica catched up with master */ - elog(NOTICE, "WAL-sender %d complete recovery", i); + MTM_LOG1("WAL-sender %d complete recovery", i); BIT_CLEAR(Mtm->walSenderLockerMask, i); } } @@ -1155,7 +1155,7 @@ MtmCheckClusterLock() } else { /* All lockers are synchronized their logs */ /* Remove lock and mark them as receovered */ - elog(NOTICE, "Complete recovery of %d nodes (node mask %lx)", Mtm->nLockers, (long) Mtm->nodeLockerMask); + MTM_LOG1("Complete recovery of %d nodes (node mask %lx)", Mtm->nLockers, (long) Mtm->nodeLockerMask); Assert(Mtm->walSenderLockerMask == 0); Assert((Mtm->nodeLockerMask & Mtm->disabledNodeMask) == Mtm->nodeLockerMask); Mtm->disabledNodeMask &= ~Mtm->nodeLockerMask; @@ -1215,7 +1215,7 @@ bool MtmRefreshClusterStatus(bool nowait) clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); if (clique_size >= MtmNodes/2+1) { /* have quorum */ - elog(NOTICE, "Find clique %lx, disabledNodeMask %lx", (long) clique, (long) Mtm->disabledNodeMask); + MTM_LOG1("Find clique %lx, disabledNodeMask %lx", (long) clique, (long) Mtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~Mtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { @@ -1243,7 +1243,7 @@ bool MtmRefreshClusterStatus(bool nowait) MtmSwitchClusterMode(MTM_RECOVERY); } } else { - elog(NOTICE, "Clique %lx has no quorum", (long) clique); + MTM_LOG1("Clique %lx has no quorum", (long) clique); MtmSwitchClusterMode(MTM_IN_MINORITY); } return true; @@ -1258,7 +1258,7 @@ void MtmCheckQuorum(void) } } else { if (Mtm->status == MTM_IN_MINORITY) { - elog(NOTICE, "Node is in majority: dissbled mask %lx", (long) Mtm->disabledNodeMask); + MTM_LOG1("Node is in majority: dissbled mask %lx", (long) Mtm->disabledNodeMask); MtmSwitchClusterMode(MTM_ONLINE); } } @@ -1285,7 +1285,7 @@ void MtmOnNodeDisconnect(int nodeId) for (ts = Mtm->transListHead; ts != NULL; ts = ts->next) { if (!ts->votingCompleted) { if (ts->status != TRANSACTION_STATUS_ABORTED) { - elog(NOTICE, "Rollback active transaction %d:%d", ts->gtid.node, ts->gtid.xid); + MTM_LOG1("Rollback active transaction %d:%d", ts->gtid.node, ts->gtid.xid); MtmAbortTransaction(ts); } MtmWakeUpBackend(ts); @@ -1299,7 +1299,7 @@ void MtmOnNodeDisconnect(int nodeId) void MtmOnNodeConnect(int nodeId) { BIT_CLEAR(Mtm->connectivityMask, nodeId-1); - elog(NOTICE, "Reconnect node %d", nodeId); + MTM_LOG1("Reconnect node %d", nodeId); RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); } @@ -1480,7 +1480,7 @@ void MtmUpdateNodeConnectionInfo(MtmConnectionInfo* conn, char const* connStr) if (strlen(connStr) >= MULTIMASTER_MAX_CONN_STR_SIZE) { elog(ERROR, "Too long (%d) connection string '%s': limit is %d", - (int)strlen(connStr), connStr, MULTIMASTER_MAX_CONN_STR_SIZE-1); + (int)strlen(connStr), connStr, MULTIMASTER_MAX_CONN_STR_SIZE-1); } strcpy(conn->connStr, connStr); @@ -1839,12 +1839,12 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) { bool recovery = false; while (Mtm->status != MTM_CONNECTED && Mtm->status != MTM_ONLINE) { - MTM_INFO("%d: receiver slot mode %s\n", MyProcPid, MtmNodeStatusMnem[Mtm->status]); + MTM_LOG2("%d: receiver slot mode %s", MyProcPid, MtmNodeStatusMnem[Mtm->status]); if (Mtm->status == MTM_RECOVERY) { recovery = true; if (Mtm->recoverySlot == 0 || Mtm->recoverySlot == nodeId) { /* Choose for recovery first available slot */ - elog(NOTICE, "Start recovery from node %d", nodeId); + MTM_LOG1("Start recovery from node %d", nodeId); Mtm->recoverySlot = nodeId; return SLOT_OPEN_EXISTED; } @@ -1853,9 +1853,9 @@ MtmSlotMode MtmReceiverSlotMode(int nodeId) MtmSleep(STATUS_POLL_DELAY); } if (recovery) { - elog(NOTICE, "Recreate replication slot for node %d after end of recovery", nodeId); + MTM_LOG1("Recreate replication slot for node %d after end of recovery", nodeId); } else { - MTM_INFO("%d: Reuse replication slot for node %d\n", MyProcPid, nodeId); + MTM_LOG2("%d: Reuse replication slot for node %d", MyProcPid, nodeId); } /* After recovery completion we need to drop all other slots to avoid receive of redundant data */ return recovery ? SLOT_CREATE_NEW : SLOT_OPEN_ALWAYS; @@ -1907,7 +1907,7 @@ static void MtmOnProcExit(int code, Datum arg) { if (MtmReplicationNodeId >= 0) { - elog(NOTICE, "WAL-sender to %d is terminated", MtmReplicationNodeId); + MTM_LOG1("WAL-sender to %d is terminated", MtmReplicationNodeId); MtmOnNodeDisconnect(MtmReplicationNodeId); } } @@ -1938,7 +1938,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) } MtmLock(LW_EXCLUSIVE); if (MtmIsRecoverySession) { - elog(NOTICE, "%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); + MTM_LOG1("%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes -= 1; @@ -1946,7 +1946,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) } } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { if (recoveryCompleted) { - elog(NOTICE, "Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); + MTM_LOG1("Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes += 1; MtmCheckQuorum(); @@ -1954,7 +1954,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) elog(ERROR, "Disabled node %d tries to reconnect without recovery", MtmReplicationNodeId); } } else { - elog(NOTICE, "Node %d start logical replication to node %d in normal mode", MtmNodeId, MtmReplicationNodeId); + MTM_LOG1("Node %d start logical replication to node %d in normal mode", MtmNodeId, MtmReplicationNodeId); } MtmUnlock(); on_shmem_exit(MtmOnProcExit, 0); @@ -1964,7 +1964,7 @@ static void MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) { if (MtmReplicationNodeId >= 0) { - elog(NOTICE, "Logical replication to node %d is stopped", MtmReplicationNodeId); + MTM_LOG1("Logical replication to node %d is stopped", MtmReplicationNodeId); MtmOnNodeDisconnect(MtmReplicationNodeId); MtmReplicationNodeId = -1; /* defuse on_proc_exit hook */ } @@ -2247,7 +2247,7 @@ MtmNoticeReceiver(void *i, const PGresult *res) /* Strip "NOTICE: " from beginning and "\n" from end of error string */ strncpy(stripped_notice, notice + 9, len - 1 - 9); - elog(NOTICE, "%s", stripped_notice); + MTM_LOG1("%s", stripped_notice); pfree(stripped_notice); } @@ -2291,7 +2291,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) if (MtmGUCBufferAllocated && !MtmRunUtilityStmt(conns[i], MtmGUCBuffer->data, &utility_errmsg) && !ignoreError) { errorMsg = "Failed to set GUC variables at node %d"; - elog(NOTICE, "%s", utility_errmsg); + elog(WARNING, "%s", utility_errmsg); failedNode = i; break; } @@ -2439,7 +2439,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, DestReceiver *dest, char *completionTag) { bool skipCommand = false; - MTM_TRACE("%d: Process utility statement %s\n", MyProcPid, queryString); + MTM_LOG3("%d: Process utility statement %s", MyProcPid, queryString); switch (nodeTag(parsetree)) { case T_TransactionStmt: @@ -2716,7 +2716,7 @@ MtmSerializeLock(PROCLOCK* proclock, void* arg) { if ((proclock->holdMask & LOCKBIT_ON(lm)) && (conflictMask & LOCKBIT_ON(lm))) { - MTM_TRACE("%d: %u(%u) waits for %u(%u)\n", MyProcPid, srcPgXact->xid, proc->pid, dstPgXact->xid, proclock->tag.myProc->pid); + MTM_LOG3("%d: %u(%u) waits for %u(%u)", MyProcPid, srcPgXact->xid, proc->pid, dstPgXact->xid, proclock->tag.myProc->pid); MtmGetGtid(dstPgXact->xid, >id); /* transaction holding lock */ ByteBufferAppendInt32(buf, gtid.node); ByteBufferAppendInt32(buf, gtid.xid); diff --git a/multimaster.h b/multimaster.h index 78fc508e6a..4ff464df04 100644 --- a/multimaster.h +++ b/multimaster.h @@ -7,13 +7,28 @@ #include "pglogical_output/hooks.h" -#define MTM_TUPLE_TRACE(fmt, ...) -#if 0 -#define MTM_INFO(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -#define MTM_TRACE(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__) -#else -#define MTM_INFO(fmt, ...) -#define MTM_TRACE(fmt, ...) +#define DEBUG_LEVEL 1 + +#if DEBUG_LEVEL == 0 +#define MTM_LOG1(fmt, ...) elog(LOG, fmt, ## __VA_ARGS__) +#define MTM_LOG2(fmt, ...) +#define MTM_LOG3(fmt, ...) +#define MTM_LOG4(fmt, ...) +#elif DEBUG_LEVEL == 1 +#define MTM_LOG1(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG2(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG3(fmt, ...) +#define MTM_LOG4(fmt, ...) +#elif DEBUG_LEVEL == 2 +#define MTM_LOG1(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG2(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG3(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG4(fmt, ...) +#elif DEBUG_LEVEL >= 3 +#define MTM_LOG1(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG2(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG3(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) +#define MTM_LOG4(fmt, ...) fprintf(stderr, fmt "\n", ## __VA_ARGS__) #endif #define MULTIMASTER_NAME "multimaster" diff --git a/pglogical_apply.c b/pglogical_apply.c index 34ed5ecba5..feee7eddc9 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -339,7 +339,7 @@ process_remote_begin(StringInfo s) StartTransactionCommand(); MtmJoinTransaction(>id, snapshot); - MTM_TRACE("REMOTE begin node=%d xid=%d snapshot=%ld\n", gtid.node, gtid.xid, snapshot); + MTM_LOG3("REMOTE begin node=%d xid=%d snapshot=%ld", gtid.node, gtid.xid, snapshot); } static void @@ -484,20 +484,22 @@ MtmBeginSession(void) sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, MtmReplicationNode); Assert(replorigin_session_origin == InvalidRepOriginId); replorigin_session_origin = replorigin_by_name(slot_name, false); - MTM_TRACE("%d: Begin setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); + MTM_LOG3("%d: Begin setup replorigin session: %d", MyProcPid, replorigin_session_origin); replorigin_session_setup(replorigin_session_origin); - MTM_TRACE("%d: End setup replorigin session: %d\n", MyProcPid, replorigin_session_origin); + MTM_LOG3("%d: End setup replorigin session: %d", MyProcPid, replorigin_session_origin); } static void MtmEndSession(void) { if (replorigin_session_origin != InvalidRepOriginId) { - MTM_TRACE("%d: Begin reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); + MTM_LOG3("%d: Begin reset replorigin session: %d", MyProcPid, replorigin_session_origin); replorigin_session_origin = InvalidRepOriginId; replorigin_session_reset(); - MtmUnlockNode(MtmReplicationNode); - MTM_TRACE("%d: End reset replorigin session: %d\n", MyProcPid, replorigin_session_origin); + if (unlock) { + MtmUnlockNode(MtmReplicationNode); + } + MTM_LOG3("%d: End reset replorigin session: %d", MyProcPid, replorigin_session_origin); } } @@ -523,7 +525,7 @@ process_remote_commit(StringInfo in) { case PGLOGICAL_COMMIT: { - MTM_TRACE("%d: PGLOGICAL_COMMIT commit\n", MyProcPid); + MTM_LOG3("%d: PGLOGICAL_COMMIT commit", MyProcPid); if (IsTransactionState()) { Assert(TransactionIdIsValid(MtmGetCurrentTransactionId())); MtmBeginSession(); @@ -536,7 +538,7 @@ process_remote_commit(StringInfo in) Assert(IsTransactionState() && TransactionIdIsValid(MtmGetCurrentTransactionId())); gid = pq_getmsgstring(in); /* prepare TBLOCK_INPROGRESS state for PrepareTransactionBlock() */ - MTM_TRACE("%d: PGLOGICAL_PREPARE commit: gid=%s\n", MyProcPid, gid); + MTM_LOG3("%d: PGLOGICAL_PREPARE commit: gid=%s", MyProcPid, gid); BeginTransactionBlock(); CommitTransactionCommand(); StartTransactionCommand(); @@ -553,7 +555,7 @@ process_remote_commit(StringInfo in) Assert(!TransactionIdIsValid(MtmGetCurrentTransactionId())); csn = pq_getmsgint64(in); gid = pq_getmsgstring(in); - MTM_TRACE("%d: PGLOGICAL_COMMIT_PREPARED commit: csn=%ld, gid=%s\n", MyProcPid, csn, gid); + MTM_LOG3("%d: PGLOGICAL_COMMIT_PREPARED commit: csn=%ld, gid=%s", MyProcPid, csn, gid); StartTransactionCommand(); MtmBeginSession(); MtmSetCurrentTransactionCSN(csn); @@ -566,7 +568,7 @@ process_remote_commit(StringInfo in) { Assert(!TransactionIdIsValid(MtmGetCurrentTransactionId())); gid = pq_getmsgstring(in); - MTM_TRACE("%d: PGLOGICAL_ABORT_PREPARED commit: gid=%s\n", MyProcPid, gid); + MTM_LOG3("%d: PGLOGICAL_ABORT_PREPARED commit: gid=%s", MyProcPid, gid); if (MtmGetGlobalTransactionStatus(gid) != TRANSACTION_STATUS_ABORTED) { StartTransactionCommand(); MtmSetCurrentTransactionGID(gid); @@ -681,7 +683,7 @@ process_remote_insert(StringInfo s, Relation rel) char* ddl = TextDatumGetCString(new_tuple.values[Anum_mtm_ddl_log_query-1]); int rc; SPI_connect(); - MTM_TRACE("%d: Execute utility statement %s\n", MyProcPid, ddl); + MTM_LOG3("%d: Execute utility statement %s", MyProcPid, ddl); rc = SPI_execute(ddl, false, 0); SPI_finish(); if (rc != SPI_OK_UTILITY) { @@ -788,7 +790,7 @@ process_remote_update(StringInfo s, Relation rel) tuple_to_stringinfo(&o, RelationGetDescr(rel), oldslot->tts_tuple); appendStringInfo(&o, " to"); tuple_to_stringinfo(&o, RelationGetDescr(rel), remote_tuple); - elog(DEBUG1, "UPDATE:%s", o.data); + MTM_LOG1(DEBUG1, "UPDATE:%s", o.data); resetStringInfo(&o); } #endif @@ -916,7 +918,7 @@ void MtmExecutor(int id, void* work, size_t size) { while (true) { char action = pq_getmsgbyte(&s); - MTM_TRACE("%d: REMOTE process action %c\n", MyProcPid, action); + MTM_LOG3("%d: REMOTE process action %c", MyProcPid, action); switch (action) { /* BEGIN */ case 'B': @@ -951,10 +953,10 @@ void MtmExecutor(int id, void* work, size_t size) { EmitErrorReport(); FlushErrorState(); - MTM_INFO("%d: REMOTE begin abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); + MTM_LOG2("%d: REMOTE begin abort transaction %d", MyProcPid, MtmGetCurrentTransactionId()); MtmEndSession(false); AbortCurrentTransaction(); - MTM_INFO("%d: REMOTE end abort transaction %d\n", MyProcPid, MtmGetCurrentTransactionId()); + MTM_LOG2("%d: REMOTE end abort transaction %d", MyProcPid, MtmGetCurrentTransactionId()); } PG_END_TRY(); diff --git a/pglogical_proto.c b/pglogical_proto.c index 9ddd7b703a..ee7be70c79 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -84,7 +84,7 @@ pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel) nspname = get_namespace_name(rel->rd_rel->relnamespace); if (nspname == NULL) elog(ERROR, "cache lookup failed for namespace %u", - rel->rd_rel->relnamespace); + rel->rd_rel->relnamespace); nspnamelen = strlen(nspname) + 1; relname = NameStr(rel->rd_rel->relname); @@ -106,7 +106,7 @@ pglogical_write_begin(StringInfo out, PGLogicalOutputData *data, { bool isRecovery = MtmIsRecoveredNode(MtmReplicationNodeId); csn_t csn = MtmTransactionSnapshot(txn->xid); - MTM_INFO("%d: pglogical_write_begin XID=%d node=%d CSN=%ld recovery=%d\n", MyProcPid, txn->xid, MtmReplicationNodeId, csn, isRecovery); + MTM_LOG2("%d: pglogical_write_begin XID=%d node=%d CSN=%ld recovery=%d", MyProcPid, txn->xid, MtmReplicationNodeId, csn, isRecovery); if (csn == INVALID_CSN && !isRecovery) { MtmIsFilteredTxn = true; @@ -150,13 +150,13 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, return; } if (MtmRecoveryCaughtUp(MtmReplicationNodeId, txn->end_lsn)) { - elog(NOTICE, "wal-sender complete recovery of node %d at LSN(commit %lx, end %lx, log %lx) in transaction %s event %d", MtmReplicationNodeId, commit_lsn, txn->end_lsn, GetXLogInsertRecPtr(), txn->gid, flags); + MTM_LOG1("wal-sender complete recovery of node %d at LSN(commit %lx, end %lx, log %lx) in transaction %s event %d", MtmReplicationNodeId, commit_lsn, txn->end_lsn, GetXLogInsertRecPtr(), txn->gid, flags); flags |= PGLOGICAL_CAUGHT_UP; } } pq_sendbyte(out, 'C'); /* sending COMMIT */ - MTM_INFO("PGLOGICAL_SEND commit: event=%d, gid=%s, commit_lsn=%lx, txn->end_lsn=%lx, xlog=%lx\n", flags, txn->gid, commit_lsn, txn->end_lsn, GetXLogInsertRecPtr()); + MTM_LOG2("PGLOGICAL_SEND commit: event=%d, gid=%s, commit_lsn=%lx, txn->end_lsn=%lx, xlog=%lx", flags, txn->gid, commit_lsn, txn->end_lsn, GetXLogInsertRecPtr()); /* send the flags field */ pq_sendbyte(out, flags); @@ -419,7 +419,7 @@ pglogical_init_api(PGLogicalProtoType typ) { PGLogicalProtoAPI* res = palloc0(sizeof(PGLogicalProtoAPI)); sscanf(MyReplicationSlot->data.name.data, MULTIMASTER_SLOT_PATTERN, &MtmReplicationNodeId); - elog(LOG, "%d: PRGLOGICAL init API for slot %s node %d", MyProcPid, MyReplicationSlot->data.name.data, MtmReplicationNodeId); + MTM_LOG1("%d: PRGLOGICAL init API for slot %s node %d", MyProcPid, MyReplicationSlot->data.name.data, MtmReplicationNodeId); res->write_rel = pglogical_write_rel; res->write_begin = pglogical_write_begin; res->write_commit = pglogical_write_commit; diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 18642622f1..256b413e00 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -292,10 +292,10 @@ pglogical_receiver_main(Datum main_arg) * So we assume that LSNs are the same for local and remote node */ originStartPos = Mtm->status == MTM_RECOVERY ? GetXLogInsertRecPtr() : 0; - elog(NOTICE, "Start logical receiver at position %lx from node %d", originStartPos, args->remote_node); + MTM_LOG1("Start logical receiver at position %lx from node %d", originStartPos, args->remote_node); } else { originStartPos = replorigin_get_progress(originId, false); - elog(NOTICE, "Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); + MTM_LOG1("Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); } CommitTransactionCommand(); From 0055b4697cb63bea036e5e7e7d3efdf7eb7eb38a Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Mon, 11 Apr 2016 11:40:19 +0300 Subject: [PATCH 0380/1139] distinguish notices and warnigs on remote connections; handle DISCARD stmt --- multimaster.c | 61 ++++++++++++++++++++++++++++++++------------------- 1 file changed, 38 insertions(+), 23 deletions(-) diff --git a/multimaster.c b/multimaster.c index b86ce8d55d..76a4964aae 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2244,10 +2244,24 @@ MtmNoticeReceiver(void *i, const PGresult *res) stripped_notice = palloc0(len); - /* Strip "NOTICE: " from beginning and "\n" from end of error string */ - strncpy(stripped_notice, notice + 9, len - 1 - 9); + if (*notice == 'N') + { + /* Strip "NOTICE: " from beginning and "\n" from end of error string */ + strncpy(stripped_notice, notice + 9, len - 1 - 9); + elog(NOTICE, "%s", stripped_notice); + } + else if (*notice == 'W') + { + /* Strip "WARNING: " from beginning and "\n" from end of error string */ + strncpy(stripped_notice, notice + 10, len - 1 - 10); + elog(WARNING, "%s", stripped_notice); + } + else + { + stripped_notice = notice; + elog(WARNING, "%s", stripped_notice); + } - MTM_LOG1("%s", stripped_notice); pfree(stripped_notice); } @@ -2473,10 +2487,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_PrepareStmt: case T_ExecuteStmt: case T_DeallocateStmt: - //case T_GrantStmt: /* XXX: we could replicate some of these these */; - //case T_GrantRoleStmt: - //case T_AlterDatabaseStmt: - //case T_AlterDatabaseSetStmt: case T_NotifyStmt: case T_ListenStmt: case T_UnlistenStmt: @@ -2484,22 +2494,30 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_ClusterStmt: /* XXX: we could replicate these */; case T_VacuumStmt: case T_ExplainStmt: - //case T_AlterSystemStmt: case T_VariableShowStmt: - case T_DiscardStmt: - //case T_CreateEventTrigStmt: - //case T_AlterEventTrigStmt: - //case T_CreateRoleStmt: - //case T_AlterRoleStmt: - //case T_AlterRoleSetStmt: - //case T_DropRoleStmt: case T_ReassignOwnedStmt: case T_LockStmt: - //case T_ConstraintsSetStmt: case T_CheckPointStmt: case T_ReindexStmt: skipCommand = true; break; + case T_DiscardStmt: + { + //DiscardStmt *stmt = (DiscardStmt *) parsetree; + //skipCommand = stmt->target == DISCARD_TEMP; + + skipCommand = true; + + if (MtmGUCBufferAllocated) + { + // XXX: move allocation somewhere to backend startup and check + // where buffer is empty in send routines. + MtmGUCBufferAllocated = false; + pfree(MtmGUCBuffer); + } + + } + break; case T_VariableSetStmt: { VariableSetStmt *stmt = (VariableSetStmt *) parsetree; @@ -2507,7 +2525,7 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, skipCommand = true; /* Prevent SET TRANSACTION from replication */ - if (MtmTx.isTransactionBlock || stmt->kind == VAR_SET_MULTI) + if (stmt->kind == VAR_SET_MULTI) break; if (!MtmGUCBufferAllocated) @@ -2520,13 +2538,10 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, MtmGUCBufferAllocated = true; } - //appendStringInfoString(MtmGUCBuffer, "SET "); - //appendStringInfoString(MtmGUCBuffer, stmt->name); - //appendStringInfoString(MtmGUCBuffer, " TO "); - //appendStringInfoString(MtmGUCBuffer, ExtractSetVariableArgs(stmt)); - //appendStringInfoString(MtmGUCBuffer, "; "); - appendStringInfoString(MtmGUCBuffer, queryString); + + // sometimes there is no ';' char at the end. + appendStringInfoString(MtmGUCBuffer, ";"); } break; case T_CreateStmt: From 626dd6fa045273355e44c869d3748b257eb25759 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 11 Apr 2016 12:23:33 +0300 Subject: [PATCH 0381/1139] Do not mark node as disabled on logical replication connection failure --- multimaster.c | 2 +- pglogical_receiver.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/multimaster.c b/multimaster.c index 76a4964aae..59a0b076b8 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1076,7 +1076,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) BIT_CLEAR(Mtm->nodeLockerMask, nodeId-1); Mtm->nLockers -= 1; } else { - MTM_LOG1("%d: dode %d is caugth-up without locking cluster", MyProcPid, nodeId); + MTM_LOG1("%d: node %d is caugth-up without locking cluster", MyProcPid, nodeId); /* We are lucky: caugth-up without locking cluster! */ } BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 256b413e00..ba5bc0f08e 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -249,7 +249,7 @@ pglogical_receiver_main(Datum main_arg) PQfinish(conn); ereport(WARNING, (errmsg("%s: Could not establish connection to remote server", worker_proc))); - MtmOnNodeDisconnect(args->remote_node); + /* MtmOnNodeDisconnect(args->remote_node); */ proc_exit(1); } From 3a908ad05d543eb89bffeff16b6294915926c668 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Mon, 11 Apr 2016 12:57:23 +0300 Subject: [PATCH 0382/1139] Remove dtmbench from the tap-tests. --- Makefile | 3 +- t/002_dtmbench.pl | 124 ---------------------------------------------- 2 files changed, 1 insertion(+), 126 deletions(-) delete mode 100644 t/002_dtmbench.pl diff --git a/Makefile b/Makefile index e1deb094fa..2b2ae72de5 100644 --- a/Makefile +++ b/Makefile @@ -3,7 +3,6 @@ OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o override CPPFLAGS += -I../raftable -#SCRIPTS_built = tests/dtmbench EXTRA_INSTALL = contrib/raftable contrib/mmts EXTENSION = multimaster @@ -11,7 +10,7 @@ DATA = multimaster--1.0.sql .PHONY: all -all: multimaster.so #tests/dtmbench +all: multimaster.so tests/dtmbench: make -C tests diff --git a/t/002_dtmbench.pl b/t/002_dtmbench.pl deleted file mode 100644 index 1067d4d7b5..0000000000 --- a/t/002_dtmbench.pl +++ /dev/null @@ -1,124 +0,0 @@ -use strict; -use warnings; - -use PostgresNode; -use TestLib; -use Test::More tests => 1; - -my %allocated_ports = (); -sub allocate_ports -{ - my @allocated_now = (); - my ($host, $ports_to_alloc) = @_; - - while ($ports_to_alloc > 0) - { - my $port = int(rand() * 16384) + 49152; - next if $allocated_ports{$port}; - diag("checking for port $port\n"); - if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) - { - $allocated_ports{$port} = 1; - push(@allocated_now, $port); - $ports_to_alloc--; - } - } - - return @allocated_now; -} - -my $nnodes = 2; -my @nodes = (); - -diag("creating nodes"); -foreach my $i (1..$nnodes) -{ - my $host = "127.0.0.1"; - my ($pgport, $raftport) = allocate_ports($host, 2); - my $node = new PostgresNode("node$i", $host, $pgport); - $node->{id} = $i; - $node->{raftport} = $raftport; - push(@nodes, $node); -} - -my $mm_connstr = join(',', map { "${ \$_->connstr('postgres') }" } @nodes); -my $raft_peers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @nodes); - -diag("mm_connstr = $mm_connstr\n"); -diag("raft_peers = $raft_peers\n"); - -diag("initting and configuring nodes"); -foreach my $node (@nodes) -{ - my $id = $node->{id}; - my $host = $node->host; - my $pgport = $node->port; - my $raftport = $node->{raftport}; - - $node->init(hba_permit_replication => 0); - $node->append_conf("postgresql.conf", qq( - listen_addresses = '$host' - unix_socket_directories = '' - port = $pgport - max_prepared_transactions = 200 - max_connections = 200 - max_worker_processes = 100 - wal_level = logical - fsync = off - max_wal_senders = 10 - wal_sender_timeout = 0 - max_replication_slots = 10 - shared_preload_libraries = 'raftable,multimaster' - multimaster.workers = 10 - multimaster.queue_size = 10485760 # 10mb - multimaster.node_id = $id - multimaster.conn_strings = '$mm_connstr' - multimaster.use_raftable = true - raftable.id = $id - raftable.peers = '$raft_peers' - )); - - $node->append_conf("pg_hba.conf", qq( - local replication all trust - host replication all 127.0.0.1/32 trust - host replication all ::1/128 trust - )); -} - -diag("starting nodes"); -foreach my $node (@nodes) -{ - $node->start(); -} - -my ($rc, $out, $err); - -diag("sleeping"); -sleep(10); - -my @argv = ('dtmbench'); -foreach my $node (@nodes) -{ - push(@argv, '-c', $node->connstr('postgres')); -} -push(@argv, '-n', 1000, '-a', 1000, '-w', 10, '-r', 1); - -diag("running dtmbench -i"); -if (!TestLib::run_log([@argv, '-i'])) -{ - BAIL_OUT("dtmbench -i failed"); -} - -diag("running dtmbench"); -if (!TestLib::run_log(\@argv, '>', \$out)) -{ - fail("dtmbench failed"); -} -elsif ($out =~ /Wrong sum/) -{ - fail("inconsistency detected"); -} -else -{ - pass("all consistent during dtmbench"); -} From cc38c6ab1b8a1326daee76b240263d500154fd45 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Mon, 11 Apr 2016 15:02:42 +0300 Subject: [PATCH 0383/1139] Add the Cluster perl module for tap tests. --- Cluster.pm | 144 +++++++++++++++++++++++++++++++++++++++++++++++ t/003_pgbench.pl | 102 ++++----------------------------- 2 files changed, 155 insertions(+), 91 deletions(-) create mode 100644 Cluster.pm diff --git a/Cluster.pm b/Cluster.pm new file mode 100644 index 0000000000..e89ae11df4 --- /dev/null +++ b/Cluster.pm @@ -0,0 +1,144 @@ +package Cluster; + +use strict; +use warnings; + +use PostgresNode; +use TestLib; +use Test::More; +use Cwd; + +my %allocated_ports = (); +sub allocate_ports +{ + my @allocated_now = (); + my ($host, $ports_to_alloc) = @_; + + while ($ports_to_alloc > 0) + { + my $port = int(rand() * 16384) + 49152; + next if $allocated_ports{$port}; + diag("checking for port $port\n"); + if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) + { + $allocated_ports{$port} = 1; + push(@allocated_now, $port); + $ports_to_alloc--; + } + } + + return @allocated_now; +} + +sub new +{ + my ($class, $nodenum) = @_; + + my $nodes = []; + + foreach my $i (1..$nodenum) + { + my $host = "127.0.0.1"; + my ($pgport, $raftport) = allocate_ports($host, 2); + my $node = new PostgresNode("node$i", $host, $pgport); + $node->{id} = $i; + $node->{raftport} = $raftport; + push(@$nodes, $node); + } + + my $self = { + nodenum => $nodenum, + nodes => $nodes, + }; + + bless $self, $class; + return $self; +} + +sub init +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->init(hba_permit_replication => 0); + } +} + +sub configure +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + my $connstr = join(',', map { "${ \$_->connstr('postgres') }" } @$nodes); + my $raftpeers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @$nodes); + + foreach my $node (@$nodes) + { + my $id = $node->{id}; + my $host = $node->host; + my $pgport = $node->port; + my $raftport = $node->{raftport}; + + $node->append_conf("postgresql.conf", qq( + listen_addresses = '$host' + unix_socket_directories = '' + port = $pgport + max_prepared_transactions = 200 + max_connections = 200 + max_worker_processes = 100 + wal_level = logical + fsync = off + max_wal_senders = 10 + wal_sender_timeout = 0 + max_replication_slots = 10 + shared_preload_libraries = 'raftable,multimaster' + multimaster.workers = 10 + multimaster.queue_size = 10485760 # 10mb + multimaster.node_id = $id + multimaster.conn_strings = '$connstr' + multimaster.use_raftable = true + multimaster.ignore_tables_without_pk = true + raftable.id = $id + raftable.peers = '$raftpeers' + )); + + $node->append_conf("pg_hba.conf", qq( + local replication all trust + host replication all 127.0.0.1/32 trust + host replication all ::1/128 trust + )); + } +} + +sub start +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->start(); + } +} + +sub stop +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->stop(); + } +} + +sub psql +{ + my ($self, $index, @args) = @_; + my $node = $self->{nodes}->[$index]; + return $node->psql(@args); +} + +1; diff --git a/t/003_pgbench.pl b/t/003_pgbench.pl index 44d2805ce8..33bc8f5b08 100644 --- a/t/003_pgbench.pl +++ b/t/003_pgbench.pl @@ -1,98 +1,18 @@ use strict; use warnings; -use PostgresNode; +use Cluster; use TestLib; use Test::More tests => 2; use IPC::Run qw(start finish); use Cwd; -my %allocated_ports = (); -sub allocate_ports -{ - my @allocated_now = (); - my ($host, $ports_to_alloc) = @_; - - while ($ports_to_alloc > 0) - { - my $port = int(rand() * 16384) + 49152; - next if $allocated_ports{$port}; - diag("checking for port $port\n"); - if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) - { - $allocated_ports{$port} = 1; - push(@allocated_now, $port); - $ports_to_alloc--; - } - } - - return @allocated_now; -} - my $nnodes = 2; -my @nodes = (); - -diag("creating nodes"); -foreach my $i (1..$nnodes) -{ - my $host = "127.0.0.1"; - my ($pgport, $raftport) = allocate_ports($host, 2); - my $node = new PostgresNode("node$i", $host, $pgport); - $node->{id} = $i; - $node->{raftport} = $raftport; - push(@nodes, $node); -} - -my $mm_connstr = join(',', map { "${ \$_->connstr('postgres') }" } @nodes); -my $raft_peers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @nodes); +my $cluster = new Cluster($nnodes); -diag("mm_connstr = $mm_connstr\n"); -diag("raft_peers = $raft_peers\n"); - -diag("initting and configuring nodes"); -foreach my $node (@nodes) -{ - my $id = $node->{id}; - my $host = $node->host; - my $pgport = $node->port; - my $raftport = $node->{raftport}; - - $node->init(hba_permit_replication => 0); - $node->append_conf("postgresql.conf", qq( - listen_addresses = '$host' - unix_socket_directories = '' - port = $pgport - max_prepared_transactions = 200 - max_connections = 200 - max_worker_processes = 100 - wal_level = logical - fsync = off - max_wal_senders = 10 - wal_sender_timeout = 0 - max_replication_slots = 10 - shared_preload_libraries = 'raftable,multimaster' - multimaster.workers = 10 - multimaster.queue_size = 10485760 # 10mb - multimaster.node_id = $id - multimaster.conn_strings = '$mm_connstr' - multimaster.use_raftable = true - multimaster.ignore_tables_without_pk = true - raftable.id = $id - raftable.peers = '$raft_peers' - )); - - $node->append_conf("pg_hba.conf", qq( - local replication all trust - host replication all 127.0.0.1/32 trust - host replication all ::1/128 trust - )); -} - -diag("starting nodes"); -foreach my $node (@nodes) -{ - $node->start(); -} +$cluster->init(); +$cluster->configure(); +$cluster->start(); my ($rc, $out, $err); @@ -100,17 +20,17 @@ sub allocate_ports sleep(10); diag("preparing the tables"); -if ($nodes[0]->psql('postgres', "create table t (k int primary key, v int)")) +if ($cluster->psql(0, 'postgres', "create table t (k int primary key, v int)")) { BAIL_OUT('failed to create t'); } -if ($nodes[0]->psql('postgres', "insert into t (select generate_series(0, 999), 0)")) +if ($cluster->psql(0, 'postgres', "insert into t (select generate_series(0, 999), 0)")) { BAIL_OUT('failed to fill t'); } -if ($nodes[0]->psql('postgres', "create table reader_log (v int)")) +if ($cluster->psql(0, 'postgres', "create table reader_log (v int)")) { BAIL_OUT('failed to create reader_log'); } @@ -169,7 +89,7 @@ sub writer my $in = ''; my $out = ''; my @benches = (); -foreach my $node (@nodes) +foreach my $node (@{$cluster->{nodes}}) { push(@benches, writer($node, \$in, \$out)); push(@benches, reader($node, \$in, \$out)); @@ -184,8 +104,8 @@ sub writer diag("checking readers' logs"); -($rc, $out, $err) = $nodes[0]->psql('postgres', "select count(*) from reader_log where v != 0;"); +($rc, $out, $err) = $cluster->psql(0, 'postgres', "select count(*) from reader_log where v != 0;"); is($out, 0, "there is nothing except zeros in reader_log"); -($rc, $out, $err) = $nodes[0]->psql('postgres', "select count(*) from reader_log where v = 0;"); +($rc, $out, $err) = $cluster->psql(0, 'postgres', "select count(*) from reader_log where v = 0;"); isnt($out, 0, "there are some zeros in reader_log"); From d8baadea15d01ac3a47cfc4ccc3ab46d6343afa5 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Mon, 11 Apr 2016 15:09:59 +0300 Subject: [PATCH 0384/1139] Use the Cluster perl module in 000_deadlock test. --- t/000_deadlock.pl | 95 ++++------------------------------------------- 1 file changed, 8 insertions(+), 87 deletions(-) diff --git a/t/000_deadlock.pl b/t/000_deadlock.pl index 70df911f07..2bb38596e5 100644 --- a/t/000_deadlock.pl +++ b/t/000_deadlock.pl @@ -1,7 +1,7 @@ use strict; use warnings; -use PostgresNode; +use Cluster; use TestLib; use Test::More tests => 1; @@ -34,98 +34,19 @@ sub query_exec_async return $rv; } -my %allocated_ports = (); -sub allocate_ports -{ - my @allocated_now = (); - my ($host, $ports_to_alloc) = @_; - - while ($ports_to_alloc > 0) - { - my $port = int(rand() * 16384) + 49152; - next if $allocated_ports{$port}; - diag("Checking for port $port\n"); - if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) - { - $allocated_ports{$port} = 1; - push(@allocated_now, $port); - $ports_to_alloc--; - } - } - - return @allocated_now; -} - -my $nnodes = 2; -my @nodes = (); - -# Create nodes and allocate ports -foreach my $i (1..$nnodes) -{ - my $host = "127.0.0.1"; - my ($pgport, $raftport) = allocate_ports($host, 2); - my $node = new PostgresNode("node$i", $host, $pgport); - $node->{id} = $i; - $node->{raftport} = $raftport; - push(@nodes, $node); -} +my $cluster = new Cluster(2); -my $mm_connstr = join(',', map { "${ \$_->connstr('postgres') }" } @nodes); -my $raft_peers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @nodes); - -diag("mm_connstr = $mm_connstr\n"); -diag("raft_peers = $raft_peers\n"); - -# Init and Configure -foreach my $node (@nodes) -{ - my $id = $node->{id}; - my $host = $node->host; - my $pgport = $node->port; - my $raftport = $node->{raftport}; - - $node->init(hba_permit_replication => 0); - $node->append_conf("postgresql.conf", qq( - listen_addresses = '$host' - unix_socket_directories = '' - port = $pgport - max_prepared_transactions = 10 - max_worker_processes = 10 - wal_level = logical - fsync = off - max_wal_senders = 10 - wal_sender_timeout = 0 - max_replication_slots = 10 - shared_preload_libraries = 'raftable,multimaster' - multimaster.workers = 4 - multimaster.queue_size = 10485760 # 10mb - multimaster.node_id = $id - multimaster.conn_strings = '$mm_connstr' - multimaster.use_raftable = true - raftable.id = $id - raftable.peers = '$raft_peers' - )); - - $node->append_conf("pg_hba.conf", qq( - local replication all trust - host replication all 127.0.0.1/32 trust - host replication all ::1/128 trust - )); -} - -# Start -foreach my $node (@nodes) -{ - $node->start(); -} +$cluster->init(); +$cluster->configure(); +$cluster->start(); my ($rc, $out, $err); sleep(10); -$nodes[0]->psql('postgres', "create table t(k int primary key, v text)"); -$nodes[0]->psql('postgres', "insert into t values (1, 'hello'), (2, 'world')"); +$cluster->psql(0, 'postgres', "create table t(k int primary key, v text)"); +$cluster->psql(0, 'postgres', "insert into t values (1, 'hello'), (2, 'world')"); -my @conns = map { DBI->connect('DBI:Pg:' . $_->connstr()) } @nodes; +my @conns = map { DBI->connect('DBI:Pg:' . $_->connstr()) } @{$cluster->{nodes}}; query_exec($conns[0], "begin"); query_exec($conns[1], "begin"); From 089b2d5b4553e480cd309e87d91db5fed1a026b4 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Mon, 11 Apr 2016 15:22:10 +0300 Subject: [PATCH 0385/1139] Fix a warning about variable redeclaration in tap-test 003. --- t/003_pgbench.pl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/t/003_pgbench.pl b/t/003_pgbench.pl index 33bc8f5b08..dc6d3ef1f1 100644 --- a/t/003_pgbench.pl +++ b/t/003_pgbench.pl @@ -14,7 +14,7 @@ $cluster->configure(); $cluster->start(); -my ($rc, $out, $err); +my ($rc, $in, $out, $err); diag("sleeping 10"); sleep(10); @@ -86,8 +86,8 @@ sub writer } diag("starting benches"); -my $in = ''; -my $out = ''; +$in = ''; +$out = ''; my @benches = (); foreach my $node (@{$cluster->{nodes}}) { From b69ec26f8cd7a9e9eb344c49d5fe5da3d2e653db Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Mon, 11 Apr 2016 15:33:18 +0300 Subject: [PATCH 0386/1139] Use Cluster.pm in test 001. --- t/001_basic_recovery.pl | 82 +++++++---------------------------------- 1 file changed, 13 insertions(+), 69 deletions(-) diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index cdfa3ddbec..f11976e8b0 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -1,71 +1,15 @@ use strict; use warnings; -use PostgresNode; +use Cluster; use TestLib; use Test::More tests => 3; use DBI; use DBD::Pg ':async'; -############################################################################### -# Aux routines -############################################################################### - -sub PostgresNode::inet_connstr { - my ($self, $dbname) = @_; - my $pgport = $self->port; - my $pghost = '127.0.0.1'; - my $pgdata = $self->data_dir; - - if (!defined($dbname)) - { - return "port=$pgport host=$pghost"; - } - return "port=$pgport host=$pghost dbname=$dbname"; -} - -############################################################################### -# Setup nodes -############################################################################### - -my $nnodes = 3; -my @nodes = (); -my $pgconf_common = qq( - listen_addresses = '127.0.0.1' - max_prepared_transactions = 200 - max_connections = 200 - max_worker_processes = 100 - max_wal_senders = 10 - max_replication_slots = 10 - wal_level = logical - wal_sender_timeout = 0 - shared_preload_libraries = 'raftable,multimaster' - multimaster.workers=10 - multimaster.queue_size=10485760 # 10mb -); - -# Init nodes -for (my $i=0; $i < $nnodes; $i++) { - push(@nodes, get_new_node("node$i")); - $nodes[$i]->init; -} - -# Collect conn info -my $mm_connstr = join(', ', map { "${ \$_->inet_connstr('postgres') }" } @nodes); - -# Configure and start nodes -for (my $i=0; $i < $nnodes; $i++) { - $nodes[$i]->append_conf('postgresql.conf', $pgconf_common); - $nodes[$i]->append_conf('postgresql.conf', qq( - #port = ${ \$nodes[$i]->port } - multimaster.node_id = @{[ $i + 1 ]} - multimaster.conn_strings = '$mm_connstr' - #multimaster.arbiter_port = ${ \$nodes[0]->port } - )); - $nodes[$i]->append_conf('pg_hba.conf', qq( - host replication all 127.0.0.1/32 trust - )); - $nodes[$i]->start; -} +my $cluster = new Cluster(3); +$cluster->init(); +$cluster->configure(); +$cluster->start(); ############################################################################### # Wait until nodes are up @@ -79,11 +23,11 @@ sub PostgresNode::inet_connstr { # Replication check ############################################################################### -$nodes[0]->psql('postgres', " +$cluster->psql(0, 'postgres', " create extension multimaster; create table if not exists t(k int primary key, v int); insert into t values(1, 10);"); -$nodes[1]->psql('postgres', "select v from t where k=1;", stdout => \$psql_out); +$cluster->psql(1, 'postgres', "select v from t where k=1;", stdout => \$psql_out); is($psql_out, '10', "Check replication while all nodes are up."); ############################################################################### @@ -97,15 +41,15 @@ sub PostgresNode::inet_connstr { ############################################################################### diag("stopping node 2"); -$nodes[2]->teardown_node; +$cluster->{nodes}->[2]->teardown_node; diag("sleeping 15"); sleep(15); diag("inserting 2"); -$nodes[0]->psql('postgres', "insert into t values(2, 20);"); +$cluster->psql(0, 'postgres', "insert into t values(2, 20);"); diag("selecting"); -$nodes[1]->psql('postgres', "select v from t where k=2;", stdout => \$psql_out); +$cluster->psql(1, 'postgres', "select v from t where k=2;", stdout => \$psql_out); diag("selected"); is($psql_out, '20', "Check replication after node failure."); @@ -114,13 +58,13 @@ sub PostgresNode::inet_connstr { ############################################################################### diag("starting node 2"); -$nodes[2]->start; +$cluster->{nodes}->[2]->start; diag("sleeping 30"); sleep(30); # XXX: here we can poll diag("inserting 3"); -$nodes[0]->psql('postgres', "insert into t values(3, 30);"); +$cluster->psql(0, 'postgres', "insert into t values(3, 30);"); diag("selecting"); -$nodes[2]->psql('postgres', "select v from t where k=3;", stdout => \$psql_out); +$cluster->psql(2, 'postgres', "select v from t where k=3;", stdout => \$psql_out); diag("selected"); is($psql_out, '30', "Check replication after failed node recovery."); From b7551e4f809df5600b895bdcd49843766e656ce1 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 11 Apr 2016 20:32:43 +0300 Subject: [PATCH 0387/1139] Add status change time --- multimaster--1.0.sql | 2 +- multimaster.c | 39 +++++++++++++++++++++++++++++++++++---- multimaster.h | 3 ++- t/001_basic_recovery.pl | 6 +++--- 4 files changed, 41 insertions(+), 9 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index f7e94e7706..196b6c485f 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -24,7 +24,7 @@ AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; -CREATE TYPE mtm.node_state AS (id integer, disabled bool, disconnected bool, catchUp bool, slotLag bigint, avgTransDelay bigint, connStr text); +CREATE TYPE mtm.node_state AS (id integer, disabled bool, disconnected bool, catchUp bool, slotLag bigint, avgTransDelay bigint, lastStatusChange timestamp, connStr text); CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state AS 'MODULE_PATHNAME','mtm_get_nodes_state' diff --git a/multimaster.c b/multimaster.c index 59a0b076b8..c9a472d768 100644 --- a/multimaster.c +++ b/multimaster.c @@ -178,6 +178,7 @@ int MtmConnectAttempts; int MtmConnectTimeout; int MtmKeepaliveTimeout; int MtmReconnectAttempts; +int MtmNodeDisableDelay; bool MtmUseRaftable; MtmConnectionInfo* MtmConnections; @@ -992,6 +993,7 @@ void MtmRecoveryCompleted(void) MtmLock(LW_EXCLUSIVE); Mtm->recoverySlot = 0; BIT_CLEAR(Mtm->disabledNodeMask, MtmNodeId-1); + Mtm->nodes[MtmNodeId-1].lastStatusChangeTime = time(NULL); /* Mode will be changed to online once all locagical reciever are connected */ MtmSwitchClusterMode(MTM_CONNECTED); MtmUnlock(); @@ -1080,6 +1082,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) /* We are lucky: caugth-up without locking cluster! */ } BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); + Mtm->nodes[nodeId-1].lastStatusChangeTime = time(NULL); Mtm->nNodes += 1; caughtUp = true; } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) @@ -1222,6 +1225,7 @@ bool MtmRefreshClusterStatus(bool nowait) if (mask & 1) { Mtm->nNodes -= 1; BIT_SET(Mtm->disabledNodeMask, i); + Mtm->nodes[i].lastStatusChangeTime = time(NULL); } } mask = clique & Mtm->disabledNodeMask; /* new enabled nodes mask */ @@ -1229,6 +1233,7 @@ bool MtmRefreshClusterStatus(bool nowait) if (mask & 1) { Mtm->nNodes += 1; BIT_CLEAR(Mtm->disabledNodeMask, i); + Mtm->nodes[i].lastStatusChangeTime = time(NULL); } } MtmCheckQuorum(); @@ -1268,6 +1273,11 @@ void MtmOnNodeDisconnect(int nodeId) { MtmTransState *ts; + if (Mtm->nodes[nodeId-1].lastStatusChangeTime + MtmNodeDisableDelay > time(NULL)) { + /* Avoid false detection of node failure and prevent node status blinking */ + return; + } + BIT_SET(Mtm->connectivityMask, nodeId-1); BIT_SET(Mtm->reconnectMask, nodeId-1); RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); @@ -1278,6 +1288,7 @@ void MtmOnNodeDisconnect(int nodeId) if (!MtmRefreshClusterStatus(false)) { MtmLock(LW_EXCLUSIVE); if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { + Mtm->nodes[nodeId-1].lastStatusChangeTime = time(NULL); BIT_SET(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes -= 1; MtmCheckQuorum(); @@ -1445,6 +1456,7 @@ static void MtmInitialize() for (i = 0; i < MtmNodes; i++) { Mtm->nodes[i].oldestSnapshot = 0; Mtm->nodes[i].transDelay = 0; + Mtm->nodes[i].lastStatusChangeTime = time(NULL); Mtm->nodes[i].con = MtmConnections[i]; } PGSemaphoreCreate(&Mtm->votingSemaphore); @@ -1565,10 +1577,25 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.node_disable_delay", + "Minamal amount of time (sec) between node status change", + "This delay is used to avoid false detection of node failure and to prevent blinking of node status node", + &MtmNodeDisableDelay, + 1, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.min_recovery_lag", "Minamal lag of WAL-sender performing recovery after which cluster is locked until recovery is completed", - "When wal-sender almost catch-up WAL current position we need to stop 'Achilles tortile compeition' and " + "When wal-sender almost catch-up WAL current position we need to stop 'Achilles tortile competition' and " "temporary stop commit of new transactions until node will be completely repared", &MtmMinRecoveryLag, 100000, @@ -1890,6 +1917,7 @@ void MtmDropNode(int nodeId, bool dropSlot) { elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nNodes); } + Mtm->nodes[nodeId-1].lastStatusChangeTime = time(NULL); BIT_SET(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes -= 1; MtmCheckQuorum(); @@ -1940,6 +1968,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) if (MtmIsRecoverySession) { MTM_LOG1("%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { + Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = time(NULL); BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes -= 1; MtmCheckQuorum(); @@ -1947,6 +1976,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { if (recoveryCompleted) { MTM_LOG1("Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); + Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = time(NULL); BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes += 1; MtmCheckQuorum(); @@ -2057,8 +2087,8 @@ typedef struct int nodeId; char* connStrPtr; TupleDesc desc; - Datum values[7]; - bool nulls[7]; + Datum values[8]; + bool nulls[8]; } MtmGetNodeStateCtx; Datum @@ -2095,11 +2125,12 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->values[4] = Int64GetDatum(lag); usrfctx->nulls[4] = lag < 0; usrfctx->values[5] = Int64GetDatum(Mtm->transCount ? Mtm->nodes[usrfctx->nodeId-1].transDelay/Mtm->transCount : 0); + usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime)); p = strchr(usrfctx->connStrPtr, ','); if (p != NULL) { *p++ = '\0'; } - usrfctx->values[6] = CStringGetTextDatum(usrfctx->connStrPtr); + usrfctx->values[7] = CStringGetTextDatum(usrfctx->connStrPtr); usrfctx->connStrPtr = p; usrfctx->nodeId += 1; diff --git a/multimaster.h b/multimaster.h index 4ff464df04..e237c12d9c 100644 --- a/multimaster.h +++ b/multimaster.h @@ -119,6 +119,7 @@ typedef struct { MtmConnectionInfo con; time_t transDelay; + time_t lastStatusChangeTime; csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ } MtmNodeInfo; @@ -170,7 +171,6 @@ typedef struct MtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. This list is expected to be in CSN ascending order, by strict order may be violated */ uint64 transCount; /* Counter of transactions perfromed by this node */ - time_t nodeTransDelay[MAX_NODES]; /* Time of waiting transaction acknowledgment from node */ BgwPool pool; /* Pool of background workers for applying logical replication patches */ MtmNodeInfo nodes[1]; /* [MtmNodes]: per-node data */ } MtmState; @@ -190,6 +190,7 @@ extern int MtmConnectAttempts; extern int MtmConnectTimeout; extern int MtmReconnectAttempts; extern int MtmKeepaliveTimeout; +extern int MtmNodeDisableDelay; extern HTAB* MtmXid2State; extern MtmConnectionInfo* MtmConnections; diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index f11976e8b0..fff9d46511 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -58,9 +58,9 @@ ############################################################################### diag("starting node 2"); -$cluster->{nodes}->[2]->start; -diag("sleeping 30"); -sleep(30); # XXX: here we can poll +$nodes[2]->start; +diag("sleeping 10"); +sleep(10); # XXX: here we can poll diag("inserting 3"); $cluster->psql(0, 'postgres', "insert into t values(3, 30);"); diag("selecting"); From 0e79f78afd0df0b2cb152be6c2be42e6cdb9f12d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 12 Apr 2016 19:53:23 +0300 Subject: [PATCH 0388/1139] add mtm.poll_node function --- check-recovery.sh | 2 +- multimaster--1.0.sql | 4 ++++ multimaster.c | 22 ++++++++++++++++++++++ t/001_basic_recovery.pl | 3 ++- 4 files changed, 29 insertions(+), 2 deletions(-) diff --git a/check-recovery.sh b/check-recovery.sh index 5165fbc614..038fdc3085 100755 --- a/check-recovery.sh +++ b/check-recovery.sh @@ -1,2 +1,2 @@ -rm -rf /home/knizhnik/postgres_cluster/contrib/mmts/tmp_check/log +rm -rf /home/knizhnik/postgres_cluster/contrib/mmts/tmp_check TESTDIR='/home/knizhnik/postgres_cluster/contrib/mmts' PATH="/home/knizhnik/postgres_cluster/tmp_install/home/knizhnik/postgres_cluster/dist/bin:$PATH" LD_LIBRARY_PATH="/home/knizhnik/postgres_cluster/tmp_install/home/knizhnik/postgres_cluster/dist/lib:$LD_LIBRARY_PATH" PGPORT='65432' PG_REGRESS='/home/knizhnik/postgres_cluster/contrib/mmts/../../src/test/regress/pg_regress' prove -I ../../src/test/perl/ --verbose t/001_basic_recovery.pl diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 196b6c485f..b5e97d5d6e 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -44,6 +44,10 @@ CREATE FUNCTION mtm.dump_lock_graph() RETURNS text AS 'MODULE_PATHNAME','mtm_dump_lock_graph' LANGUAGE C; +CREATE FUNCTION mtm.poll_node(nodeId integer, noWait boolean default FALSE) RETURNS boolean +AS 'MODULE_PATHNAME','mtm_poll_node' +LANGUAGE C; + CREATE TABLE IF NOT EXISTS mtm.ddl_log (issued timestamp with time zone not null, query text); CREATE TABLE IF NOT EXISTS mtm.local_tables(rel_schema text, rel_name text, primary key(rel_schema, rel_name)); diff --git a/multimaster.c b/multimaster.c index c9a472d768..ac098176ad 100644 --- a/multimaster.c +++ b/multimaster.c @@ -102,6 +102,7 @@ PG_MODULE_MAGIC; PG_FUNCTION_INFO_V1(mtm_start_replication); PG_FUNCTION_INFO_V1(mtm_stop_replication); PG_FUNCTION_INFO_V1(mtm_drop_node); +PG_FUNCTION_INFO_V1(mtm_poll_node); PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); PG_FUNCTION_INFO_V1(mtm_get_nodes_state); @@ -2068,6 +2069,27 @@ mtm_drop_node(PG_FUNCTION_ARGS) PG_RETURN_VOID(); } +Datum +mtm_poll_node(PG_FUNCTION_ARGS) +{ + int nodeId = PG_GETARG_INT32(0); + bool nowait = PG_GETARG_BOOL(1); + bool online = true; + while (BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { + if (nowait) { + online = false; + break; + } else { + MtmSleep(STATUS_POLL_DELAY); + } + } + if (!nowait) { + /* Just wait some time until logical repication channels will be reestablished */ + MtmSleep(MtmNodeDisableDelay); + } + PG_RETURN_BOOL(online); +} + Datum mtm_recover_node(PG_FUNCTION_ARGS) { diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index fff9d46511..2d82ce671e 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -60,7 +60,8 @@ diag("starting node 2"); $nodes[2]->start; diag("sleeping 10"); -sleep(10); # XXX: here we can poll +#sleep(10); # XXX: here we can poll +$cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); diag("inserting 3"); $cluster->psql(0, 'postgres', "insert into t values(3, 30);"); diag("selecting"); From 4d6a93ee65236bcfcd47ed10ac57e121be293da0 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 13 Apr 2016 14:53:18 +0300 Subject: [PATCH 0389/1139] Make it possible to switch off DTM --- multimaster.c | 22 ++++++++++++-- multimaster.h | 3 +- tests/deploy_layouts/cluster.yml | 50 ++++++-------------------------- tests/perf.results | 13 +++++++++ tests/perf.yml | 2 +- 5 files changed, 45 insertions(+), 45 deletions(-) diff --git a/multimaster.c b/multimaster.c index ac098176ad..0a40a5aba6 100644 --- a/multimaster.c +++ b/multimaster.c @@ -181,6 +181,7 @@ int MtmKeepaliveTimeout; int MtmReconnectAttempts; int MtmNodeDisableDelay; bool MtmUseRaftable; +bool MtmUseDtm; MtmConnectionInfo* MtmConnections; static char* MtmConnStrs; @@ -339,7 +340,7 @@ TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum) } bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) -{ +{ #if TRACE_SLEEP_TIME static timestamp_t firstReportTime; static timestamp_t prevReportTime; @@ -349,6 +350,10 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) timestamp_t delay = MIN_WAIT_TIMEOUT; Assert(xid != InvalidTransactionId); + if (!MtmUseDtm) { + return PgXidInMVCCSnapshot(xid, snapshot); + } + MtmLock(LW_SHARED); #if TRACE_SLEEP_TIME @@ -768,7 +773,7 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) tm->state = ts; ts->votingCompleted = true; if (Mtm->status != MTM_RECOVERY) { - MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ + MtmSendNotificationMessage(ts, MtmUseDtm ? MSG_READY : MSG_PREPARED); /* send notification to coordinator */ } else { ts->status = TRANSACTION_STATUS_UNKNOWN; } @@ -1651,6 +1656,19 @@ _PG_init(void) NULL ); + DefineCustomBoolVariable( + "multimaster.use_dtm", + "Use distributed transaction manager", + NULL, + &MtmUseDtm, + true, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.workers", "Number of multimaster executor workers per node", diff --git a/multimaster.h b/multimaster.h index e237c12d9c..b6fb8ae6e3 100644 --- a/multimaster.h +++ b/multimaster.h @@ -7,7 +7,7 @@ #include "pglogical_output/hooks.h" -#define DEBUG_LEVEL 1 +#define DEBUG_LEVEL 0 #if DEBUG_LEVEL == 0 #define MTM_LOG1(fmt, ...) elog(LOG, fmt, ## __VA_ARGS__) @@ -191,6 +191,7 @@ extern int MtmConnectTimeout; extern int MtmReconnectAttempts; extern int MtmKeepaliveTimeout; extern int MtmNodeDisableDelay; +extern bool MtmUseDtm; extern HTAB* MtmXid2State; extern MtmConnectionInfo* MtmConnections; diff --git a/tests/deploy_layouts/cluster.yml b/tests/deploy_layouts/cluster.yml index 6e7a163625..9202b1c9ea 100644 --- a/tests/deploy_layouts/cluster.yml +++ b/tests/deploy_layouts/cluster.yml @@ -1,41 +1,5 @@ --- -- hosts: nodes[0] - - roles: - - role: postgres - pg_port: 15432 - pg_repo: https://github.com/postgrespro/postgres_cluster.git - pg_version_tag: master - pg_destroy_and_init: true - - tasks: - - name: build sockhub - shell: "make clean && make -j 4" - args: - chdir: "~/pg_cluster/src/contrib/arbiter/sockhub" - - - name: build dtm - shell: "make clean && make -j 4" - args: - chdir: "~/pg_cluster/src/contrib/arbiter" - # when: dtm_sources.changed - - - name: kill arbiter - shell: kill -9 `cat ~/pg_cluster/dtm_data/arbiter.pid` || true - - - name: ensure datadir for dtm exists - shell: "rm -rf ~/pg_cluster/dtm_data && mkdir ~/pg_cluster/dtm_data" - - - name: start dtm - shell: > - nohup ~/pg_cluster/src/contrib/arbiter/bin/arbiter - -d ~/pg_cluster/dtm_data -r 0.0.0.0:5431 -i 0 -l ~/pg_cluster/dtm_data/log & - - - name: wait until dtm is available - wait_for: port=5431 delay=1 - - - hosts: nodes[1]:nodes[2]:nodes[3] # accelerate: true @@ -61,10 +25,10 @@ set_fact: connections: "{{ connstrs.results | map(attribute='ansible_facts.connstr') | join(', ') }}" - - name: build sockhub - shell: "make clean && make -j 4" + - name: build raftable + shell: "make clean && make -j {{makejobs}} install" args: - chdir: "{{pg_src}}/contrib/arbiter/sockhub" + chdir: "{{pg_src}}/contrib/raftable" - name: build multimaster shell: "make clean && make -j {{makejobs}} install" @@ -81,13 +45,17 @@ - "max_wal_senders = 10" - "wal_sender_timeout = 0" - "max_replication_slots = 10" + - "max_connections = 200" - "max_worker_processes = 100" - - "shared_preload_libraries = 'multimaster'" - - "multimaster.arbiters = '{{groups['nodes'][0]}}:5431'" + - "shared_preload_libraries = 'raftable,multimaster'" - "multimaster.conn_strings = '{{connections}}'" - "multimaster.node_id = {{ node_id }}" + - "multimaster.buffer_size = 65536" - "multimaster.queue_size = 1073741824" + - "multimaster.arbiter_port = 5600" + - "multimaster.vacuum_delay = 1" - "multimaster.workers = 32" + - "multimaster.use_dtm = 0" - name: restart postgrespro command: "{{pg_dst}}/bin/pg_ctl restart -w -D {{pg_datadir}} -l {{pg_datadir}}/pg.log" diff --git a/tests/perf.results b/tests/perf.results index 69aeb936b3..c530311323 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -138,3 +138,16 @@ Bench finished at Пн. февр. 15 18:37:50 MSK 2016 Bench started at Пн. февр. 15 18:44:02 MSK 2016 astro5:{tps:121774.204222, transactions:100000000, selects:200000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:200, update_percent:0, accounts:500000, iterations:500000, hosts:3} Bench finished at Пн. февр. 15 18:57:44 MSK 2016 +Bench started at Ср. апр. 13 13:52:07 MSK 2016 + +Bench finished at Ср. апр. 13 13:52:07 MSK 2016 +Bench started at Ср. апр. 13 13:52:45 MSK 2016 +Bench started at Ср. апр. 13 14:03:54 MSK 2016 +astro5:{tps:115156.025890, transactions:50000000, selects:100000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:100, update_percent:0, accounts:500000, iterations:500000, hosts:3} +Bench finished at Ср. апр. 13 14:11:09 MSK 2016 +Bench started at Ср. апр. 13 14:13:55 MSK 2016 +astro5:{tps:16576.973635, transactions:1000000, selects:0, updates:2000758, aborts:820, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 14:14:56 MSK 2016 +Bench started at Ср. апр. 13 14:23:33 MSK 2016 +astro5:{tps:16078.719352, transactions:1000000, selects:0, updates:2000802, aborts:788, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 14:24:36 MSK 2016 diff --git a/tests/perf.yml b/tests/perf.yml index 5d9d013565..cd95f788d2 100644 --- a/tests/perf.yml +++ b/tests/perf.yml @@ -46,7 +46,7 @@ - name: run transfers shell: > ~/pg_cluster/install/bin/dtmbench {{connections}} - -w {{ nconns }} -r 0 -n 500000 -a 500000 -p {{ up }} | + -w {{ nconns }} -r 0 -n 10000 -a 500000 -p {{ up }} | tee -a perf.results | sed "s/^/`hostname`:/" register: transfers_result From 991ab80624ee9d714a0ab1910fe8172ac3c93415 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 14 Apr 2016 12:32:13 +0300 Subject: [PATCH 0390/1139] Adjust oldest xid only in case of using DTM --- multimaster.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 0a40a5aba6..9360373e21 100644 --- a/multimaster.c +++ b/multimaster.c @@ -486,7 +486,7 @@ MtmAdjustOldestXid(TransactionId xid) static TransactionId MtmAdjustOldestXid(TransactionId xid) { - if (TransactionIdIsValid(xid)) { + if (TransactionIdIsValid(xid) && MtmUseDtm) { MtmTransState *ts, *prev = NULL; int i; From 04baf6bb47f29de3a5538e6fcbba24e2af00528c Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 14 Apr 2016 17:11:22 +0300 Subject: [PATCH 0391/1139] Fix MtmAdjustOldestXid --- multimaster.c | 18 +++++++------- tests/deploy_layouts/cluster.yml | 4 ++-- tests/perf.results | 41 ++++++++++++++++++++++++++++++++ 3 files changed, 53 insertions(+), 10 deletions(-) diff --git a/multimaster.c b/multimaster.c index 9360373e21..ee3aa3cefa 100644 --- a/multimaster.c +++ b/multimaster.c @@ -486,7 +486,7 @@ MtmAdjustOldestXid(TransactionId xid) static TransactionId MtmAdjustOldestXid(TransactionId xid) { - if (TransactionIdIsValid(xid) && MtmUseDtm) { + if (TransactionIdIsValid(xid)) { MtmTransState *ts, *prev = NULL; int i; @@ -517,13 +517,15 @@ MtmAdjustOldestXid(TransactionId xid) hash_search(MtmXid2State, &prev->xid, HASH_REMOVE, NULL); } } - } - if (prev != NULL) { - Mtm->transListHead = prev; - Mtm->oldestXid = xid = prev->xid; - } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { - xid = Mtm->oldestXid; - } + } + if (MtmUseDtm) { + if (prev != NULL) { + Mtm->transListHead = prev; + Mtm->oldestXid = xid = prev->xid; + } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { + xid = Mtm->oldestXid; + } + } MtmUnlock(); } return xid; diff --git a/tests/deploy_layouts/cluster.yml b/tests/deploy_layouts/cluster.yml index 9202b1c9ea..71af2f3ca7 100644 --- a/tests/deploy_layouts/cluster.yml +++ b/tests/deploy_layouts/cluster.yml @@ -46,7 +46,7 @@ - "wal_sender_timeout = 0" - "max_replication_slots = 10" - "max_connections = 200" - - "max_worker_processes = 100" + - "max_worker_processes = 200" - "shared_preload_libraries = 'raftable,multimaster'" - "multimaster.conn_strings = '{{connections}}'" - "multimaster.node_id = {{ node_id }}" @@ -54,7 +54,7 @@ - "multimaster.queue_size = 1073741824" - "multimaster.arbiter_port = 5600" - "multimaster.vacuum_delay = 1" - - "multimaster.workers = 32" + - "multimaster.workers = 100" - "multimaster.use_dtm = 0" - name: restart postgrespro diff --git a/tests/perf.results b/tests/perf.results index c530311323..9d48ec788c 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -151,3 +151,44 @@ Bench finished at Ср. апр. 13 14:14:56 MSK 2016 Bench started at Ср. апр. 13 14:23:33 MSK 2016 astro5:{tps:16078.719352, transactions:1000000, selects:0, updates:2000802, aborts:788, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} Bench finished at Ср. апр. 13 14:24:36 MSK 2016 +Bench started at Ср. апр. 13 14:56:01 MSK 2016 +astro5:{tps:19270.176742, transactions:1000000, selects:0, updates:2000712, aborts:1057, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 14:56:53 MSK 2016 +Bench started at Ср. апр. 13 14:57:38 MSK 2016 +astro5:{tps:118537.540721, transactions:1000000, selects:2000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:100, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 14:57:47 MSK 2016 +Bench started at Ср. апр. 13 14:58:18 MSK 2016 +astro5:{tps:19246.519176, transactions:1000000, selects:0, updates:2000774, aborts:1053, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 14:59:10 MSK 2016 +Bench started at Ср. апр. 13 15:06:25 MSK 2016 +astro5:{tps:18571.114322, transactions:1000000, selects:0, updates:2000840, aborts:865, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 15:07:19 MSK 2016 +Bench started at Ср. апр. 13 15:07:51 MSK 2016 +astro5:{tps:116649.799106, transactions:1000000, selects:2000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:100, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 15:08:00 MSK 2016 +Bench started at Ср. апр. 13 15:09:33 MSK 2016 +astro5:{tps:17636.360192, transactions:1000000, selects:0, updates:2000852, aborts:893, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Ср. апр. 13 15:10:30 MSK 2016 +Bench started at Ср. апр. 13 18:17:09 MSK 2016 +astro5:{tps:118106.246182, transactions:10000000, selects:20000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:100, update_percent:0, accounts:500000, iterations:100000, hosts:3} +Bench finished at Ср. апр. 13 18:18:34 MSK 2016 +Bench started at Ср. апр. 13 18:19:25 MSK 2016 +astro5:{tps:120241.087565, transactions:100000000, selects:200000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:100, update_percent:0, accounts:500000, iterations:1000000, hosts:3} +Bench finished at Ср. апр. 13 18:33:17 MSK 2016 +Bench started at Ср. апр. 13 18:33:52 MSK 2016 +Bench started at Ср. апр. 13 19:35:23 MSK 2016 + +Bench finished at Ср. апр. 13 19:35:24 MSK 2016 +Bench started at Ср. апр. 13 19:35:44 MSK 2016 +Bench started at Чт. апр. 14 14:30:56 MSK 2016 + +Bench finished at Чт. апр. 14 14:30:57 MSK 2016 +Bench started at Чт. апр. 14 15:05:58 MSK 2016 + +Bench finished at Чт. апр. 14 15:05:59 MSK 2016 +Bench started at Чт. апр. 14 15:06:49 MSK 2016 + +Bench finished at Чт. апр. 14 15:57:08 MSK 2016 +Bench started at Чт. апр. 14 16:07:25 MSK 2016 + +Bench finished at Чт. апр. 14 16:58:03 MSK 2016 From 829978c113f3425879e7997a05bf9d2eb26dd873 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 14 Apr 2016 19:12:08 +0300 Subject: [PATCH 0392/1139] Measure max wakeup time --- multimaster.c | 19 ++++++---- multimaster.h | 1 + tests/deploy_layouts/cluster.yml | 4 +-- tests/perf.results | 60 ++++++++++++++++++++++++++++++++ tests/perf.yml | 2 +- 5 files changed, 76 insertions(+), 10 deletions(-) diff --git a/multimaster.c b/multimaster.c index ee3aa3cefa..9e27b2a4c3 100644 --- a/multimaster.c +++ b/multimaster.c @@ -518,13 +518,11 @@ MtmAdjustOldestXid(TransactionId xid) } } } - if (MtmUseDtm) { - if (prev != NULL) { - Mtm->transListHead = prev; - Mtm->oldestXid = xid = prev->xid; - } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { - xid = Mtm->oldestXid; - } + if (prev != NULL) { + Mtm->transListHead = prev; + Mtm->oldestXid = xid = prev->xid; + } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { + xid = Mtm->oldestXid; } MtmUnlock(); } @@ -782,6 +780,8 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MtmUnlock(); MtmResetTransaction(x); } else { + time_t wakeupTime; + static time_t maxWakeupTime; /* wait votes from all nodes */ while (!ts->votingCompleted) { MtmUnlock(); @@ -789,6 +789,10 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) ResetLatch(&MyProc->procLatch); MtmLock(LW_SHARED); } + wakeupTime = MtmGetCurrentTime() - ts->wakeupTime; + if (wakeupTime > maxWakeupTime) { + maxWakeupTime = wakeupTime; + } x->status = ts->status; MTM_LOG3("%d: Result of vote: %d", MyProcPid, ts->status); MtmUnlock(); @@ -979,6 +983,7 @@ void MtmWakeUpBackend(MtmTransState* ts) { MTM_LOG3("Wakeup backed procno=%d, pid=%d", ts->procno, ProcGlobal->allProcs[ts->procno].pid); ts->votingCompleted = true; + ts->wakeupTime = MtmGetCurrentTime(); SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); } diff --git a/multimaster.h b/multimaster.h index b6fb8ae6e3..de965d0f5e 100644 --- a/multimaster.h +++ b/multimaster.h @@ -135,6 +135,7 @@ typedef struct MtmTransState int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, used to notify coordinator by arbiter */ int nSubxids; /* Number of subtransanctions */ + time_t wakeupTime; MtmMessageCode cmd; /* Notification message to be sent */ struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ diff --git a/tests/deploy_layouts/cluster.yml b/tests/deploy_layouts/cluster.yml index 71af2f3ca7..9202b1c9ea 100644 --- a/tests/deploy_layouts/cluster.yml +++ b/tests/deploy_layouts/cluster.yml @@ -46,7 +46,7 @@ - "wal_sender_timeout = 0" - "max_replication_slots = 10" - "max_connections = 200" - - "max_worker_processes = 200" + - "max_worker_processes = 100" - "shared_preload_libraries = 'raftable,multimaster'" - "multimaster.conn_strings = '{{connections}}'" - "multimaster.node_id = {{ node_id }}" @@ -54,7 +54,7 @@ - "multimaster.queue_size = 1073741824" - "multimaster.arbiter_port = 5600" - "multimaster.vacuum_delay = 1" - - "multimaster.workers = 100" + - "multimaster.workers = 32" - "multimaster.use_dtm = 0" - name: restart postgrespro diff --git a/tests/perf.results b/tests/perf.results index 9d48ec788c..a3d94ae601 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -192,3 +192,63 @@ Bench finished at Чт. апр. 14 15:57:08 MSK 2016 Bench started at Чт. апр. 14 16:07:25 MSK 2016 Bench finished at Чт. апр. 14 16:58:03 MSK 2016 +Bench started at Чт. апр. 14 17:14:41 MSK 2016 +astro5:{tps:841.620253, transactions:1000000, selects:0, updates:2000610, aborts:1045, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. апр. 14 17:34:30 MSK 2016 +Bench started at Чт. апр. 14 17:38:52 MSK 2016 +astro5:{tps:103207.588648, transactions:100000, selects:200000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:100, update_percent:0, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 17:38:53 MSK 2016 +Bench started at Чт. апр. 14 17:39:15 MSK 2016 +astro5:{tps:600.228131, transactions:100000, selects:0, updates:200058, aborts:94, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 17:42:02 MSK 2016 +Bench started at Чт. апр. 14 17:47:53 MSK 2016 +astro5:{tps:2826.840100, transactions:100000, selects:0, updates:200060, aborts:105, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 17:48:28 MSK 2016 +Bench started at Чт. апр. 14 17:50:15 MSK 2016 +astro5:{tps:1203.074674, transactions:100000, selects:0, updates:200038, aborts:102, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 17:51:39 MSK 2016 +Bench started at Чт. апр. 14 17:56:22 MSK 2016 +astro5:{tps:16673.903141, transactions:100000, selects:0, updates:200044, aborts:68, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 17:56:29 MSK 2016 +Bench started at Чт. апр. 14 18:01:48 MSK 2016 +astro5:{tps:15729.463298, transactions:100000, selects:0, updates:200052, aborts:68, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:01:55 MSK 2016 +Bench started at Чт. апр. 14 18:33:55 MSK 2016 +astro5:{tps:16955.322556, transactions:100000, selects:0, updates:200074, aborts:83, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:34:01 MSK 2016 +Bench started at Чт. апр. 14 18:34:29 MSK 2016 +astro5:{tps:16920.929961, transactions:150000, selects:0, updates:300194, aborts:187, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:34:39 MSK 2016 +Bench started at Чт. апр. 14 18:35:08 MSK 2016 + +Bench finished at Чт. апр. 14 18:35:09 MSK 2016 +Bench started at Чт. апр. 14 18:35:40 MSK 2016 + +Bench finished at Чт. апр. 14 18:35:40 MSK 2016 +Bench started at Чт. апр. 14 18:36:33 MSK 2016 + +Bench finished at Чт. апр. 14 18:36:34 MSK 2016 +Bench started at Чт. апр. 14 18:38:59 MSK 2016 +astro5:{tps:15017.551012, transactions:150000, selects:0, updates:300180, aborts:200, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:39:09 MSK 2016 +Bench started at Чт. апр. 14 18:42:34 MSK 2016 +astro5:{tps:6604.488490, transactions:150000, selects:0, updates:300154, aborts:215, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:42:57 MSK 2016 +Bench started at Чт. апр. 14 18:45:11 MSK 2016 +astro5:{tps:734.388293, transactions:100000, selects:0, updates:200058, aborts:102, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:47:28 MSK 2016 +Bench started at Чт. апр. 14 18:48:27 MSK 2016 +astro5:{tps:2989.544487, transactions:100000, selects:0, updates:200060, aborts:99, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:49:01 MSK 2016 +Bench started at Чт. апр. 14 18:49:34 MSK 2016 +astro5:{tps:2579.759122, transactions:100000, selects:0, updates:200066, aborts:99, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:50:14 MSK 2016 +Bench started at Чт. апр. 14 18:50:33 MSK 2016 +astro5:{tps:1825.359630, transactions:100000, selects:0, updates:200080, aborts:117, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:51:28 MSK 2016 +Bench started at Чт. апр. 14 18:51:58 MSK 2016 +astro5:{tps:1769.625629, transactions:150000, selects:0, updates:300148, aborts:230, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 18:53:23 MSK 2016 +Bench started at Чт. апр. 14 18:53:42 MSK 2016 +astro5:{tps:180.239135, transactions:150000, selects:0, updates:300156, aborts:232, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 19:07:34 MSK 2016 diff --git a/tests/perf.yml b/tests/perf.yml index cd95f788d2..7f8d4c13ed 100644 --- a/tests/perf.yml +++ b/tests/perf.yml @@ -46,7 +46,7 @@ - name: run transfers shell: > ~/pg_cluster/install/bin/dtmbench {{connections}} - -w {{ nconns }} -r 0 -n 10000 -a 500000 -p {{ up }} | + -w {{ nconns }} -r 0 -n 1000 -a 500000 -p {{ up }} | tee -a perf.results | sed "s/^/`hostname`:/" register: transfers_result From 4a431f93580174cb14696412214dca547d39de55 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 14 Apr 2016 20:18:50 +0300 Subject: [PATCH 0393/1139] Measure max wakeup time --- multimaster.c | 23 +++++++++++++---------- tests/perf.results | 39 +++++++++++++++++++++++++++++++++++++++ tests/perf.yml | 2 +- 3 files changed, 53 insertions(+), 11 deletions(-) diff --git a/multimaster.c b/multimaster.c index 9e27b2a4c3..0c1666981d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -518,11 +518,13 @@ MtmAdjustOldestXid(TransactionId xid) } } } - if (prev != NULL) { - Mtm->transListHead = prev; - Mtm->oldestXid = xid = prev->xid; - } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { - xid = Mtm->oldestXid; + if (MtmUseDtm) { + if (prev != NULL) { + Mtm->transListHead = prev; + Mtm->oldestXid = xid = prev->xid; + } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { + xid = Mtm->oldestXid; + } } MtmUnlock(); } @@ -758,6 +760,8 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) } +static time_t maxWakeupTime; + static void MtmPostPrepareTransaction(MtmCurrentTrans* x) { @@ -781,18 +785,17 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MtmResetTransaction(x); } else { time_t wakeupTime; - static time_t maxWakeupTime; /* wait votes from all nodes */ while (!ts->votingCompleted) { MtmUnlock(); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); ResetLatch(&MyProc->procLatch); + wakeupTime = MtmGetCurrentTime() - ts->wakeupTime; + if (wakeupTime > maxWakeupTime) { + maxWakeupTime = wakeupTime; + } MtmLock(LW_SHARED); } - wakeupTime = MtmGetCurrentTime() - ts->wakeupTime; - if (wakeupTime > maxWakeupTime) { - maxWakeupTime = wakeupTime; - } x->status = ts->status; MTM_LOG3("%d: Result of vote: %d", MyProcPid, ts->status); MtmUnlock(); diff --git a/tests/perf.results b/tests/perf.results index a3d94ae601..f780c70b92 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -252,3 +252,42 @@ Bench finished at Чт. апр. 14 18:53:23 MSK 2016 Bench started at Чт. апр. 14 18:53:42 MSK 2016 astro5:{tps:180.239135, transactions:150000, selects:0, updates:300156, aborts:232, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} Bench finished at Чт. апр. 14 19:07:34 MSK 2016 +Bench started at Чт. апр. 14 19:59:58 MSK 2016 +astro5:{tps:17844.456298, transactions:150000, selects:0, updates:300152, aborts:240, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:00:07 MSK 2016 +Bench started at Чт. апр. 14 20:01:03 MSK 2016 +astro5:{tps:19247.941850, transactions:150000, selects:0, updates:300138, aborts:203, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:01:11 MSK 2016 +Bench started at Чт. апр. 14 20:01:49 MSK 2016 +astro5:{tps:18371.053393, transactions:150000, selects:0, updates:300170, aborts:235, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:01:57 MSK 2016 +Bench started at Чт. апр. 14 20:02:23 MSK 2016 +astro5:{tps:13404.266927, transactions:100000, selects:0, updates:200058, aborts:97, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:02:30 MSK 2016 +Bench started at Чт. апр. 14 20:03:24 MSK 2016 +astro5:{tps:16527.393080, transactions:100000, selects:0, updates:200078, aborts:95, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:03:31 MSK 2016 +Bench started at Чт. апр. 14 20:04:00 MSK 2016 +astro5:{tps:18563.630432, transactions:150000, selects:0, updates:300190, aborts:226, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:04:08 MSK 2016 +Bench started at Чт. апр. 14 20:04:49 MSK 2016 +astro5:{tps:18701.395074, transactions:150000, selects:0, updates:300168, aborts:236, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:04:57 MSK 2016 +Bench started at Чт. апр. 14 20:05:19 MSK 2016 +astro5:{tps:19369.111871, transactions:150000, selects:0, updates:300190, aborts:231, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:1000, hosts:3} +Bench finished at Чт. апр. 14 20:05:27 MSK 2016 +Bench started at Чт. апр. 14 20:06:04 MSK 2016 +astro5:{tps:19453.975668, transactions:1500000, selects:0, updates:3001868, aborts:2439, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. апр. 14 20:07:21 MSK 2016 +Bench started at Чт. апр. 14 20:08:36 MSK 2016 +astro5:{tps:19686.758474, transactions:1500000, selects:0, updates:3001850, aborts:2463, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. апр. 14 20:09:53 MSK 2016 +Bench started at Чт. апр. 14 20:10:09 MSK 2016 +astro5:{tps:20577.036061, transactions:1500000, selects:0, updates:3001964, aborts:2467, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. апр. 14 20:11:23 MSK 2016 +Bench started at Чт. апр. 14 20:12:49 MSK 2016 +astro5:{tps:16349.624735, transactions:1500000, selects:0, updates:3001828, aborts:2412, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. апр. 14 20:14:21 MSK 2016 +Bench started at Чт. апр. 14 20:14:46 MSK 2016 +astro5:{tps:11453.993709, transactions:1500000, selects:0, updates:3001960, aborts:2563, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. апр. 14 20:16:57 MSK 2016 diff --git a/tests/perf.yml b/tests/perf.yml index 7f8d4c13ed..cd95f788d2 100644 --- a/tests/perf.yml +++ b/tests/perf.yml @@ -46,7 +46,7 @@ - name: run transfers shell: > ~/pg_cluster/install/bin/dtmbench {{connections}} - -w {{ nconns }} -r 0 -n 1000 -a 500000 -p {{ up }} | + -w {{ nconns }} -r 0 -n 10000 -a 500000 -p {{ up }} | tee -a perf.results | sed "s/^/`hostname`:/" register: transfers_result From d84543d409fd586cd4a5af5c698089c05e0f5bf4 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Thu, 14 Apr 2016 23:54:23 +0300 Subject: [PATCH 0394/1139] Fix bug in non-DTM mode --- multimaster.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/multimaster.c b/multimaster.c index 0c1666981d..baf81f111b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -525,6 +525,10 @@ MtmAdjustOldestXid(TransactionId xid) } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { xid = Mtm->oldestXid; } + } else { + if (prev != NULL) { + Mtm->transListHead = prev; + } } MtmUnlock(); } From 5dd394cbac971714e2a4756ca828affbee6c9392 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Fri, 15 Apr 2016 16:26:53 +0300 Subject: [PATCH 0395/1139] Add docker-compose config for tap-tests. --- docker/Dockerfile | 47 +++++++++++++++++++++++++++++++++++++ docker/docker-compose.yml | 47 +++++++++++++++++++++++++++++++++++++ docker/docker-entrypoint.sh | 42 +++++++++++++++++++++++++++++++++ 3 files changed, 136 insertions(+) create mode 100644 docker/Dockerfile create mode 100644 docker/docker-compose.yml create mode 100755 docker/docker-entrypoint.sh diff --git a/docker/Dockerfile b/docker/Dockerfile new file mode 100644 index 0000000000..46c5c19439 --- /dev/null +++ b/docker/Dockerfile @@ -0,0 +1,47 @@ +# vim:set ft=dockerfile: +FROM debian:jessie + +# explicitly set user/group IDs +RUN groupadd -r postgres --gid=999 && useradd -r -g postgres --uid=999 postgres + +RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/* + +RUN apt-get update && apt-get install -y \ + make \ + gcc \ + libreadline-dev \ + bison \ + flex \ + zlib1g-dev \ + && rm -rf /var/lib/apt/lists/* + +RUN mkdir /pg +RUN chown postgres:postgres /pg + +USER postgres + +WORKDIR /pg +ENV CFLAGS -O0 +RUN git clone -b master https://github.com/postgrespro/postgres_cluster.git --depth 1 + +WORKDIR /pg/postgres_cluster +RUN ./configure --enable-cassert --enable-debug --prefix /usr/local +RUN make -j 4 +USER root +RUN make install +RUN make -C contrib/raftable install +RUN make -C contrib/mmts install + +RUN mkdir -p /var/run/postgresql && chown -R postgres /var/run/postgresql + +ENV PATH /usr/local/bin:$PATH +ENV PGDATA /var/run/postgresql/data + +COPY docker-entrypoint.sh / + +USER postgres +ENTRYPOINT ["/docker-entrypoint.sh"] + +EXPOSE 5432 +EXPOSE 5431 +CMD ["postgres"] diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml new file mode 100644 index 0000000000..d6efc434ee --- /dev/null +++ b/docker/docker-compose.yml @@ -0,0 +1,47 @@ +version: '2' + +networks: + clusternet: + driver: bridge + ipam: + driver: default + config: + - subnet: 10.0.0.0/24 + +services: + node1: + build: . + networks: + clusternet: + ipv4_address: 10.0.0.10 + environment: + NODEID: '1' + CONNS: 'dbname=postgres host=10.0.0.10 port=5432,dbname=postgres host=10.0.0.20 port=5432,dbname=postgres host=10.0.0.30 port=5432' + PEERS: '1:10.0.0.10:5431,2:10.0.0.20:5431,3:10.0.0.30:5431' + ports: + - "5432:5432" + - "5431:5431" + node2: + build: . + networks: + clusternet: + ipv4_address: 10.0.0.20 + environment: + NODEID: '2' + CONNS: 'dbname=postgres host=10.0.0.10 port=5432,dbname=postgres host=10.0.0.20 port=5432,dbname=postgres host=10.0.0.30 port=5432' + PEERS: '1:10.0.0.10:5431,2:10.0.0.20:5431,3:10.0.0.30:5431' + ports: + - "5434:5432" + - "5433:5431" + node3: + build: . + networks: + clusternet: + ipv4_address: 10.0.0.30 + environment: + NODEID: '3' + CONNS: 'dbname=postgres host=10.0.0.10 port=5432,dbname=postgres host=10.0.0.20 port=5432,dbname=postgres host=10.0.0.30 port=5432' + PEERS: '1:10.0.0.10:5431,2:10.0.0.20:5431,3:10.0.0.30:5431' + ports: + - "5436:5432" + - "5435:5431" diff --git a/docker/docker-entrypoint.sh b/docker/docker-entrypoint.sh new file mode 100755 index 0000000000..d58d04b654 --- /dev/null +++ b/docker/docker-entrypoint.sh @@ -0,0 +1,42 @@ +#!/bin/bash +set -e + +mkdir -p "$PGDATA" +chmod 700 "$PGDATA" +chown -R postgres "$PGDATA" + +chmod g+s /run/postgresql +chown -R postgres /run/postgresql + +initdb + +cat >> "$PGDATA/pg_hba.conf" <<-EOF + host all all 0.0.0.0/0 trust + local replication all trust + host replication all 0.0.0.0/0 trust +EOF + +cat >> "$PGDATA/postgresql.conf" <<-EOF + listen_addresses = '*' + unix_socket_directories = '' + port = 5432 + max_prepared_transactions = 200 + max_connections = 200 + max_worker_processes = 100 + wal_level = logical + fsync = off + max_wal_senders = 10 + wal_sender_timeout = 0 + max_replication_slots = 10 + shared_preload_libraries = 'raftable,multimaster' + multimaster.workers = 10 + multimaster.queue_size = 10485760 # 10mb + multimaster.node_id = $NODEID + multimaster.conn_strings = '$CONNS' + multimaster.use_raftable = true + multimaster.ignore_tables_without_pk = true + raftable.id = $NODEID + raftable.peers = '$PEERS' +EOF + +"$@" From 7c4ccc19d27e73d7c93eeb5e6282563e65f1bbe9 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 15 Apr 2016 19:11:25 +0300 Subject: [PATCH 0396/1139] Fix Copy statement --- multimaster.c | 27 +++++++++++++++++++++-- tests/deploy_layouts/cluster.yml | 2 +- tests/perf.results | 37 ++++++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index baf81f111b..b78c61b0e4 100644 --- a/multimaster.c +++ b/multimaster.c @@ -518,7 +518,8 @@ MtmAdjustOldestXid(TransactionId xid) } } } - if (MtmUseDtm) { + //if (MtmUseDtm) + { if (prev != NULL) { Mtm->transListHead = prev; Mtm->oldestXid = xid = prev->xid; @@ -2568,7 +2569,6 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, case T_AlterTableSpaceOptionsStmt: case T_TruncateStmt: case T_CommentStmt: /* XXX: we could replicate these */; - case T_CopyStmt: case T_PrepareStmt: case T_ExecuteStmt: case T_DeallocateStmt: @@ -2676,6 +2676,29 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, } } break; + case T_CopyStmt: + { + CopyStmt *copyStatement = (CopyStmt *) parsetree; + skipCommand = true; + if (copyStatement->is_from) { + RangeVar *relation = copyStatement->relation; + + if (relation != NULL) + { + Oid relid = RangeVarGetRelid(relation, NoLock, true); + if (OidIsValid(relid)) + { + Relation rel = heap_open(relid, ShareLock); + if (RelationNeedsWAL(rel)) { + MtmTx.containsDML = true; + } + heap_close(rel, ShareLock); + } + } + } + break; + } + default: skipCommand = false; break; diff --git a/tests/deploy_layouts/cluster.yml b/tests/deploy_layouts/cluster.yml index 9202b1c9ea..2f998d271a 100644 --- a/tests/deploy_layouts/cluster.yml +++ b/tests/deploy_layouts/cluster.yml @@ -55,7 +55,7 @@ - "multimaster.arbiter_port = 5600" - "multimaster.vacuum_delay = 1" - "multimaster.workers = 32" - - "multimaster.use_dtm = 0" + - "multimaster.use_dtm = 1" - name: restart postgrespro command: "{{pg_dst}}/bin/pg_ctl restart -w -D {{pg_datadir}} -l {{pg_datadir}}/pg.log" diff --git a/tests/perf.results b/tests/perf.results index f780c70b92..216739cbfa 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -291,3 +291,40 @@ Bench finished at Чт. апр. 14 20:14:21 MSK 2016 Bench started at Чт. апр. 14 20:14:46 MSK 2016 astro5:{tps:11453.993709, transactions:1500000, selects:0, updates:3001960, aborts:2563, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} Bench finished at Чт. апр. 14 20:16:57 MSK 2016 +Bench started at Чт. апр. 14 20:22:40 MSK 2016 +Bench started at Пт. апр. 15 09:59:02 MSK 2016 +astro5:{tps:19157.887469, transactions:1500000, selects:0, updates:3001900, aborts:2466, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 10:00:20 MSK 2016 +Bench started at Пт. апр. 15 10:00:47 MSK 2016 +astro5:{tps:19393.531934, transactions:1500000, selects:0, updates:3001854, aborts:2486, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 10:02:04 MSK 2016 +Bench started at Пт. апр. 15 10:17:23 MSK 2016 +astro5:{tps:20665.868900, transactions:1500000, selects:0, updates:3001838, aborts:2422, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 10:18:36 MSK 2016 +Bench started at Пт. апр. 15 10:21:50 MSK 2016 +astro5:{tps:18643.610238, transactions:1500000, selects:0, updates:3001856, aborts:2431, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 10:23:11 MSK 2016 +Bench started at Пт. апр. 15 10:52:34 MSK 2016 +astro5:{tps:20520.642631, transactions:1500000, selects:0, updates:3001844, aborts:2421, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 10:53:48 MSK 2016 +Bench started at Пт. апр. 15 11:06:54 MSK 2016 +astro5:{tps:20158.824931, transactions:1500000, selects:0, updates:3001700, aborts:2392, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 11:08:10 MSK 2016 +Bench started at Пт. апр. 15 11:31:49 MSK 2016 +astro5:{tps:18980.574597, transactions:1000000, selects:0, updates:2000698, aborts:1019, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 11:32:42 MSK 2016 +Bench started at Пт. апр. 15 11:33:11 MSK 2016 +astro5:{tps:19746.702465, transactions:1500000, selects:0, updates:3001724, aborts:2315, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 11:34:27 MSK 2016 +Bench started at Пт. апр. 15 11:52:43 MSK 2016 +astro5:{tps:20725.160946, transactions:1500000, selects:0, updates:3001710, aborts:2348, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 11:53:55 MSK 2016 +Bench started at Пт. апр. 15 11:55:32 MSK 2016 +astro5:{tps:64193.925226, transactions:1500000, selects:3000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:150, update_percent:0, accounts:500000, iterations:10000, hosts:1} +Bench finished at Пт. апр. 15 11:55:56 MSK 2016 +Bench started at Пт. апр. 15 11:56:33 MSK 2016 +astro5:{tps:124840.952626, transactions:1500000, selects:3000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:150, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 11:56:45 MSK 2016 +Bench started at Пт. апр. 15 18:41:39 MSK 2016 +astro5:{tps:17367.895646, transactions:1500000, selects:0, updates:3002062, aborts:1968, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 18:43:05 MSK 2016 From b6abbca28eccc49e43e667ad7d2128a725d92858 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 15 Apr 2016 19:15:09 +0300 Subject: [PATCH 0397/1139] Remove garbage from file --- multimaster.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index b78c61b0e4..189e68eb91 100644 --- a/multimaster.c +++ b/multimaster.c @@ -518,7 +518,7 @@ MtmAdjustOldestXid(TransactionId xid) } } } - //if (MtmUseDtm) + if (MtmUseDtm) { if (prev != NULL) { Mtm->transListHead = prev; From c50624540017d4fad47da9c69639e68154983c85 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 17 Apr 2016 22:45:59 +0300 Subject: [PATCH 0398/1139] Add wait 2pc timeout --- arbiter.c | 16 ++++++++-- multimaster.c | 70 ++++++++++++++++++++++++++++++++++---------- multimaster.h | 1 - pglogical_receiver.c | 17 ++++------- tests/dtmbench.cpp | 2 +- 5 files changed, 75 insertions(+), 31 deletions(-) diff --git a/arbiter.c b/arbiter.c index ea8bcdf2af..2a3b4682a0 100644 --- a/arbiter.c +++ b/arbiter.c @@ -720,14 +720,24 @@ static void MtmTransReceiver(Datum arg) MtmAbortTransaction(ts); } + if (!MtmUseDtm && msg->csn > ts->csn) { + ts->csn = msg->csn; + MtmSyncClock(ts->csn); + } + if (++ts->nVotes == Mtm->nNodes) { /* All nodes are finished their transactions */ - if (ts->status == TRANSACTION_STATUS_IN_PROGRESS) { + if (ts->status == TRANSACTION_STATUS_ABORTED) { + MtmWakeUpBackend(ts); + } else if (MtmUseDtm) { + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); ts->nVotes = 1; /* I voted myself */ MtmSendNotificationMessage(ts, MSG_PREPARE); } else { - Assert(ts->status == TRANSACTION_STATUS_ABORTED); - MtmWakeUpBackend(ts); + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + ts->csn = MtmAssignCSN(); + ts->status = TRANSACTION_STATUS_UNKNOWN; + MtmWakeUpBackend(ts); } } break; diff --git a/multimaster.c b/multimaster.c index 189e68eb91..dda34780d2 100644 --- a/multimaster.c +++ b/multimaster.c @@ -190,6 +190,8 @@ static int MtmWorkers; static int MtmVacuumDelay; static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; +static int Mtm2PCPrepareRatio; +static int Mtm2PCMinTimeout; static bool MtmIgnoreTablesWithoutPk; static ExecutorFinish_hook_type PreviousExecutorFinishHook; @@ -765,8 +767,6 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) } -static time_t maxWakeupTime; - static void MtmPostPrepareTransaction(MtmCurrentTrans* x) { @@ -782,25 +782,32 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) tm->state = ts; ts->votingCompleted = true; if (Mtm->status != MTM_RECOVERY) { - MtmSendNotificationMessage(ts, MtmUseDtm ? MSG_READY : MSG_PREPARED); /* send notification to coordinator */ + if (MtmUseDtm) { + MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ + } else { + ts->csn = MtmAssignCSN(); + MtmSendNotificationMessage(ts, MSG_PREPARED); /* send notification to coordinator */ + ts->status = TRANSACTION_STATUS_UNKNOWN; + } } else { ts->status = TRANSACTION_STATUS_UNKNOWN; } MtmUnlock(); MtmResetTransaction(x); } else { - time_t wakeupTime; + time_t timeout = Max(Mtm2PCMinTimeout, (ts->csn - ts->snapshot)*Mtm2PCPrepareRatio/100000); /* usec->msec and percents */ + int result = 0; /* wait votes from all nodes */ - while (!ts->votingCompleted) { + while (!ts->votingCompleted && !(result & WL_TIMEOUT)) { MtmUnlock(); - WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); + result = WaitLatch(&MyProc->procLatch, WL_LATCH_SET|WL_TIMEOUT, timeout); ResetLatch(&MyProc->procLatch); - wakeupTime = MtmGetCurrentTime() - ts->wakeupTime; - if (wakeupTime > maxWakeupTime) { - maxWakeupTime = wakeupTime; - } MtmLock(LW_SHARED); } + if (!ts->votingCompleted) { + ts->status = TRANSACTION_STATUS_ABORTED; + elog(WARNING, "Transaction is aborted because of %d msec timeout expiration", (int)timeout); + } x->status = ts->status; MTM_LOG3("%d: Result of vote: %d", MyProcPid, ts->status); MtmUnlock(); @@ -988,11 +995,12 @@ csn_t MtmGetTransactionCSN(TransactionId xid) } void MtmWakeUpBackend(MtmTransState* ts) -{ - MTM_LOG3("Wakeup backed procno=%d, pid=%d", ts->procno, ProcGlobal->allProcs[ts->procno].pid); - ts->votingCompleted = true; - ts->wakeupTime = MtmGetCurrentTime(); - SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); +{ + if (!ts->votingCompleted) { + MTM_LOG3("Wakeup backed procno=%d, pid=%d", ts->procno, ProcGlobal->allProcs[ts->procno].pid); + ts->votingCompleted = true; + SetLatch(&ProcGlobal->allProcs[ts->procno].procLatch); + } } void MtmAbortTransaction(MtmTransState* ts) @@ -1598,6 +1606,38 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.2pc_min_timeout", + "Minamal amount of time (milliseconds) to wait 2PC confirmation from all nodes", + "Timeout for 2PC is calculated as MAX(prepare_time*2pc_prepare_ratio/100,2pc_min_timeout)", + &Mtm2PCMinTimeout, + 10000, + 0, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomIntVariable( + "multimaster.2pc_prepare_ratio", + "Percent of prepare time for maximal time of second phase of two-pahse commit", + "Timeout for 2PC is calculated as MAX(prepare_time*2pc_prepare_ratio/100,2pc_min_timeout)", + &Mtm2PCPrepareRatio, + 100, + 0, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + + DefineCustomIntVariable( "multimaster.node_disable_delay", "Minamal amount of time (sec) between node status change", diff --git a/multimaster.h b/multimaster.h index de965d0f5e..b6fb8ae6e3 100644 --- a/multimaster.h +++ b/multimaster.h @@ -135,7 +135,6 @@ typedef struct MtmTransState int procno; /* pgprocno of transaction coordinator waiting for responses from replicas, used to notify coordinator by arbiter */ int nSubxids; /* Number of subtransanctions */ - time_t wakeupTime; MtmMessageCode cmd; /* Notification message to be sent */ struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ diff --git a/pglogical_receiver.c b/pglogical_receiver.c index ba5bc0f08e..d635cf6bdb 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -53,15 +53,13 @@ static volatile sig_atomic_t got_sighup = false; /* GUC variables */ static int receiver_idle_time = 0; -static bool receiver_sync_mode = true; +static bool receiver_sync_mode = false; /* Worker name */ -char worker_proc[BGW_MAXLEN]; +static char worker_proc[BGW_MAXLEN]; /* Lastly written positions */ static XLogRecPtr output_written_lsn = InvalidXLogRecPtr; -static XLogRecPtr output_fsync_lsn = InvalidXLogRecPtr; -static XLogRecPtr output_applied_lsn = InvalidXLogRecPtr; /* Stream functions */ static void fe_sendint64(int64 i, char *buf); @@ -91,16 +89,17 @@ receiver_raw_sighup(SIGNAL_ARGS) * Send a Standby Status Update message to server. */ static bool -sendFeedback(PGconn *conn, int64 now) +sendFeedback(PGconn *conn, int64 now, RepOriginId originId) { char replybuf[1 + 8 + 8 + 8 + 8 + 1]; int len = 0; + XLogRecPtr output_applied_lsn = replorigin_get_progress(originId, true); replybuf[len] = 'r'; len += 1; fe_sendint64(output_written_lsn, &replybuf[len]); /* write */ len += 8; - fe_sendint64(output_fsync_lsn, &replybuf[len]); /* flush */ + fe_sendint64(output_applied_lsn, &replybuf[len]); /* flush */ len += 8; fe_sendint64(output_applied_lsn, &replybuf[len]); /* apply */ len += 8; @@ -409,8 +408,6 @@ pglogical_receiver_main(Datum main_arg) /* Update written position */ output_written_lsn = Max(walEnd, output_written_lsn); - output_fsync_lsn = output_written_lsn; - output_applied_lsn = output_written_lsn; /* * If the server requested an immediate reply, send one. @@ -424,7 +421,7 @@ pglogical_receiver_main(Datum main_arg) int64 now = feGetCurrentTimestamp(); /* Leave is feedback is not sent properly */ - if (!sendFeedback(conn, now)) + if (!sendFeedback(conn, now, originId)) proc_exit(1); } continue; @@ -482,8 +479,6 @@ pglogical_receiver_main(Datum main_arg) } /* Update written position */ output_written_lsn = Max(walEnd, output_written_lsn); - output_fsync_lsn = output_written_lsn; - output_applied_lsn = output_written_lsn; } /* No data, move to next loop */ diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 3e551f8038..553eca2ab3 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -129,7 +129,7 @@ void* reader(void* arg) result r = txn.exec("select sum(v) from t"); int64_t sum = r[0][0].as(int64_t()); if (sum != prevSum) { - // r = txn.exec("select mtm_get_snapshot()"); + r = txn.exec("select mtm.get_snapshot()"); printf("Total=%ld, snapshot=%ld\n", sum, r[0][0].as(int64_t())); prevSum = sum; } From 90c65eeb94374c4db49572edae0dce10486357c9 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sun, 17 Apr 2016 23:57:10 +0300 Subject: [PATCH 0399/1139] Fix problems with non-DTM mode --- multimaster.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/multimaster.c b/multimaster.c index dda34780d2..211dff80ea 100644 --- a/multimaster.c +++ b/multimaster.c @@ -782,11 +782,8 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) tm->state = ts; ts->votingCompleted = true; if (Mtm->status != MTM_RECOVERY) { - if (MtmUseDtm) { - MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ - } else { - ts->csn = MtmAssignCSN(); - MtmSendNotificationMessage(ts, MSG_PREPARED); /* send notification to coordinator */ + MtmSendNotificationMessage(ts, MSG_READY); /* send notification to coordinator */ + if (!MtmUseDtm) { ts->status = TRANSACTION_STATUS_UNKNOWN; } } else { From abd79ad172a6ee44975d1c112655d3a474f2a714 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 18 Apr 2016 12:56:14 +0300 Subject: [PATCH 0400/1139] Fix GUC for 2PC timeouts --- Cluster.pm | 1 + arbiter.c | 6 ------ multimaster.c | 6 +++--- tests/perf.results | 3 +++ 4 files changed, 7 insertions(+), 9 deletions(-) diff --git a/Cluster.pm b/Cluster.pm index e89ae11df4..c5ac76d588 100644 --- a/Cluster.pm +++ b/Cluster.pm @@ -100,6 +100,7 @@ sub configure multimaster.conn_strings = '$connstr' multimaster.use_raftable = true multimaster.ignore_tables_without_pk = true + multimaster.twopc_min_timeout = 60000 raftable.id = $id raftable.peers = '$raftpeers' )); diff --git a/arbiter.c b/arbiter.c index 2a3b4682a0..0a69474225 100644 --- a/arbiter.c +++ b/arbiter.c @@ -720,11 +720,6 @@ static void MtmTransReceiver(Datum arg) MtmAbortTransaction(ts); } - if (!MtmUseDtm && msg->csn > ts->csn) { - ts->csn = msg->csn; - MtmSyncClock(ts->csn); - } - if (++ts->nVotes == Mtm->nNodes) { /* All nodes are finished their transactions */ if (ts->status == TRANSACTION_STATUS_ABORTED) { @@ -735,7 +730,6 @@ static void MtmTransReceiver(Datum arg) MtmSendNotificationMessage(ts, MSG_PREPARE); } else { Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - ts->csn = MtmAssignCSN(); ts->status = TRANSACTION_STATUS_UNKNOWN; MtmWakeUpBackend(ts); } diff --git a/multimaster.c b/multimaster.c index 211dff80ea..32f6b64cc7 100644 --- a/multimaster.c +++ b/multimaster.c @@ -803,7 +803,7 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) } if (!ts->votingCompleted) { ts->status = TRANSACTION_STATUS_ABORTED; - elog(WARNING, "Transaction is aborted because of %d msec timeout expiration", (int)timeout); + elog(WARNING, "Transaction is aborted because of %d msec timeout expiration, prepare time %d msec", (int)timeout, (int)((ts->csn - x->snapshot)/1000)); } x->status = ts->status; MTM_LOG3("%d: Result of vote: %d", MyProcPid, ts->status); @@ -1604,7 +1604,7 @@ _PG_init(void) return; DefineCustomIntVariable( - "multimaster.2pc_min_timeout", + "multimaster.twopc_min_timeout", "Minamal amount of time (milliseconds) to wait 2PC confirmation from all nodes", "Timeout for 2PC is calculated as MAX(prepare_time*2pc_prepare_ratio/100,2pc_min_timeout)", &Mtm2PCMinTimeout, @@ -1619,7 +1619,7 @@ _PG_init(void) ); DefineCustomIntVariable( - "multimaster.2pc_prepare_ratio", + "multimaster.twopc_prepare_ratio", "Percent of prepare time for maximal time of second phase of two-pahse commit", "Timeout for 2PC is calculated as MAX(prepare_time*2pc_prepare_ratio/100,2pc_min_timeout)", &Mtm2PCPrepareRatio, diff --git a/tests/perf.results b/tests/perf.results index 216739cbfa..f98ef0abff 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -328,3 +328,6 @@ Bench finished at Пт. апр. 15 11:56:45 MSK 2016 Bench started at Пт. апр. 15 18:41:39 MSK 2016 astro5:{tps:17367.895646, transactions:1500000, selects:0, updates:3002062, aborts:1968, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} Bench finished at Пт. апр. 15 18:43:05 MSK 2016 +Bench started at Пт. апр. 15 20:01:20 MSK 2016 +astro5:{tps:18310.750502, transactions:1500000, selects:0, updates:3001948, aborts:1897, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Пт. апр. 15 20:02:42 MSK 2016 From 97a3e4293accd3cce25c60e9201e0d629b3cb545 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 18 Apr 2016 18:00:59 +0300 Subject: [PATCH 0401/1139] Add mtm.get_cluster_info function --- bgwpool.c | 14 +++---- bgwpool.h | 1 + multimaster--1.0.sql | 8 +++- multimaster.c | 91 ++++++++++++++++++++++++++++++++++---------- multimaster.h | 3 ++ 5 files changed, 88 insertions(+), 29 deletions(-) diff --git a/bgwpool.c b/bgwpool.c index 564f9e659a..c0044e2ffe 100644 --- a/bgwpool.c +++ b/bgwpool.c @@ -16,9 +16,6 @@ typedef struct int id; } BgwPoolExecutorCtx; -size_t n_snapshots; -size_t n_active; - static void BgwPoolMainLoop(Datum arg) { BgwPoolExecutorCtx* ctx = (BgwPoolExecutorCtx*)arg; @@ -36,7 +33,8 @@ static void BgwPoolMainLoop(Datum arg) size = *(int*)&pool->queue[pool->head]; Assert(size < pool->size); work = malloc(size); - pool->active -= 1; + pool->pending -= 1; + pool->active += 1; if (pool->head + size + 4 > pool->size) { memcpy(work, pool->queue, size); pool->head = INTALIGN(size); @@ -54,6 +52,9 @@ static void BgwPoolMainLoop(Datum arg) SpinLockRelease(&pool->lock); pool->executor(id, work, size); free(work); + SpinLockAcquire(&pool->lock); + pool->active -= 1; + SpinLockRelease(&pool->lock); } } @@ -71,6 +72,7 @@ void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, si pool->tail = 0; pool->size = queueSize; pool->active = 0; + pool->pending = 0; strcpy(pool->dbname, dbname); } @@ -126,9 +128,7 @@ void BgwPoolExecute(BgwPool* pool, void* work, size_t size) PGSemaphoreLock(&pool->overflow); SpinLockAcquire(&pool->lock); } else { - pool->active += 1; - n_snapshots += 1; - n_active += pool->active; + pool->pending += 1; *(int*)&pool->queue[pool->tail] = size; if (pool->size - pool->tail >= size + 4) { memcpy(&pool->queue[pool->tail+4], work, size); diff --git a/bgwpool.h b/bgwpool.h index d05eb32120..0a6c5a70a5 100644 --- a/bgwpool.h +++ b/bgwpool.h @@ -20,6 +20,7 @@ typedef struct size_t tail; size_t size; size_t active; + size_t pending; bool producerBlocked; char dbname[MAX_DBNAME_LEN]; char* queue; diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index b5e97d5d6e..bc5b95d213 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -24,18 +24,22 @@ AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; -CREATE TYPE mtm.node_state AS (id integer, disabled bool, disconnected bool, catchUp bool, slotLag bigint, avgTransDelay bigint, lastStatusChange timestamp, connStr text); +CREATE TYPE mtm.node_state AS ("id" integer, "disabled" bool, "disconnected" bool, "catchUp" bool, "slotLag" bigint, "avgTransDelay" bigint, "lastStatusChange" timestamp, "connStr" text); CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state AS 'MODULE_PATHNAME','mtm_get_nodes_state' LANGUAGE C; -CREATE TYPE mtm.cluster_state AS (status text, disabledNodeMask bigint, disconnectedNodeMask bigint, catchUpNodeMask bigint, nNodes integer, nActiveQueries integer, queueSize bigint, transCount bigint, timeShift bigint, recoverySlot integer); +CREATE TYPE mtm.cluster_state AS ("status" text, "disabledNodeMask" bigint, "disconnectedNodeMask" bigint, "catchUpNodeMask" bigint, "nNodes" integer, "nActiveQueries" integer, "nPendingQueries" integer, "queueSize" bigint, "transCount" bigint, "timeShift" bigint, "recoverySlot" integer); CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state AS 'MODULE_PATHNAME','mtm_get_cluster_state' LANGUAGE C; +CREATE FUNCTION mtm.get_cluster_info() RETURNS SETOF mtm.cluster_state +AS 'MODULE_PATHNAME','mtm_get_cluster_info' +LANGUAGE C; + CREATE FUNCTION mtm.make_table_local(relation regclass) RETURNS void AS 'MODULE_PATHNAME','mtm_make_table_local' LANGUAGE C; diff --git a/multimaster.c b/multimaster.c index 32f6b64cc7..3148cf522a 100644 --- a/multimaster.c +++ b/multimaster.c @@ -107,6 +107,7 @@ PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); PG_FUNCTION_INFO_V1(mtm_get_nodes_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_state); +PG_FUNCTION_INFO_V1(mtm_get_cluster_info); PG_FUNCTION_INFO_V1(mtm_make_table_local); PG_FUNCTION_INFO_V1(mtm_dump_lock_graph); @@ -1608,7 +1609,7 @@ _PG_init(void) "Minamal amount of time (milliseconds) to wait 2PC confirmation from all nodes", "Timeout for 2PC is calculated as MAX(prepare_time*2pc_prepare_ratio/100,2pc_min_timeout)", &Mtm2PCMinTimeout, - 10000, + 100000, /* 100 seconds */ 0, INT_MAX, PGC_BACKEND, @@ -1623,7 +1624,7 @@ _PG_init(void) "Percent of prepare time for maximal time of second phase of two-pahse commit", "Timeout for 2PC is calculated as MAX(prepare_time*2pc_prepare_ratio/100,2pc_min_timeout)", &Mtm2PCPrepareRatio, - 100, + 1000, /* 10 times */ 0, INT_MAX, PGC_BACKEND, @@ -2177,10 +2178,9 @@ mtm_get_snapshot(PG_FUNCTION_ARGS) typedef struct { int nodeId; - char* connStrPtr; TupleDesc desc; - Datum values[8]; - bool nulls[8]; + Datum values[Natts_mtm_nodes_state]; + bool nulls[Natts_mtm_nodes_state]; } MtmGetNodeStateCtx; Datum @@ -2189,7 +2189,6 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) FuncCallContext* funcctx; MtmGetNodeStateCtx* usrfctx; MemoryContext oldcontext; - char* p; int64 lag; bool is_first_call = SRF_IS_FIRSTCALL(); @@ -2199,7 +2198,6 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx = (MtmGetNodeStateCtx*)palloc(sizeof(MtmGetNodeStateCtx)); get_call_result_type(fcinfo, NULL, &usrfctx->desc); usrfctx->nodeId = 1; - usrfctx->connStrPtr = pstrdup(MtmConnStrs); memset(usrfctx->nulls, false, sizeof(usrfctx->nulls)); funcctx->user_fctx = usrfctx; MemoryContextSwitchTo(oldcontext); @@ -2218,23 +2216,19 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->nulls[4] = lag < 0; usrfctx->values[5] = Int64GetDatum(Mtm->transCount ? Mtm->nodes[usrfctx->nodeId-1].transDelay/Mtm->transCount : 0); usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime)); - p = strchr(usrfctx->connStrPtr, ','); - if (p != NULL) { - *p++ = '\0'; - } - usrfctx->values[7] = CStringGetTextDatum(usrfctx->connStrPtr); - usrfctx->connStrPtr = p; + usrfctx->values[7] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); usrfctx->nodeId += 1; SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(heap_form_tuple(usrfctx->desc, usrfctx->values, usrfctx->nulls))); } + Datum mtm_get_cluster_state(PG_FUNCTION_ARGS) { TupleDesc desc; - Datum values[10]; - bool nulls[10] = {false}; + Datum values[Natts_mtm_cluster_state]; + bool nulls[Natts_mtm_cluster_state] = {false}; get_call_result_type(fcinfo, NULL, &desc); values[0] = CStringGetTextDatum(MtmNodeStatusMnem[Mtm->status]); @@ -2243,16 +2237,73 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) values[3] = Int64GetDatum(Mtm->nodeLockerMask); values[4] = Int32GetDatum(Mtm->nNodes); values[5] = Int32GetDatum((int)Mtm->pool.active); - values[6] = Int64GetDatum(BgwPoolGetQueueSize(&Mtm->pool)); - values[7] = Int64GetDatum(Mtm->transCount); - values[8] = Int64GetDatum(Mtm->timeShift); - values[9] = Int32GetDatum(Mtm->recoverySlot); - nulls[9] = Mtm->recoverySlot == 0; + values[6] = Int32GetDatum((int)Mtm->pool.pending); + values[7] = Int64GetDatum(BgwPoolGetQueueSize(&Mtm->pool)); + values[8] = Int64GetDatum(Mtm->transCount); + values[9] = Int64GetDatum(Mtm->timeShift); + values[10] = Int32GetDatum(Mtm->recoverySlot); PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); } +typedef struct +{ + int nodeId; +} MtmGetClusterInfoCtx; + + +Datum +mtm_get_cluster_info(PG_FUNCTION_ARGS) +{ + + FuncCallContext* funcctx; + MtmGetClusterInfoCtx* usrfctx; + MemoryContext oldcontext; + TupleDesc desc; + bool is_first_call = SRF_IS_FIRSTCALL(); + int i; + PGconn* conn; + PGresult *result; + char* values[Natts_mtm_cluster_state]; + HeapTuple tuple; + + if (is_first_call) { + funcctx = SRF_FIRSTCALL_INIT(); + oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); + usrfctx = (MtmGetClusterInfoCtx*)palloc(sizeof(MtmGetNodeStateCtx)); + get_call_result_type(fcinfo, NULL, &desc); + funcctx->attinmeta = TupleDescGetAttInMetadata(desc); + usrfctx->nodeId = 1; + funcctx->user_fctx = usrfctx; + MemoryContextSwitchTo(oldcontext); + } + funcctx = SRF_PERCALL_SETUP(); + usrfctx = (MtmGetClusterInfoCtx*)funcctx->user_fctx; + if (usrfctx->nodeId > MtmNodes) { + SRF_RETURN_DONE(funcctx); + } + conn = PQconnectdb(Mtm->nodes[usrfctx->nodeId-1].con.connStr); + if (PQstatus(conn) != CONNECTION_OK) { + elog(ERROR, "Failed to establish connection '%s' to node %d", Mtm->nodes[usrfctx->nodeId-1].con.connStr, usrfctx->nodeId); + } + result = PQexec(conn, "select * from mtm.get_cluster_state()"); + + if (PQresultStatus(result) != PGRES_TUPLES_OK || PQntuples(result) != 1) { + elog(ERROR, "Failed to receive data from %d", usrfctx->nodeId); + } + + for (i = 0; i < Natts_mtm_cluster_state; i++) { + values[i] = PQgetvalue(result, 0, i); + } + tuple = BuildTupleFromCStrings(funcctx->attinmeta, values); + PQclear(result); + PQfinish(conn); + usrfctx->nodeId += 1; + SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple)); +} + + Datum mtm_make_table_local(PG_FUNCTION_ARGS) { Oid reloid = PG_GETARG_OID(1); diff --git a/multimaster.h b/multimaster.h index b6fb8ae6e3..ddec2fa482 100644 --- a/multimaster.h +++ b/multimaster.h @@ -56,6 +56,9 @@ #define Anum_mtm_local_tables_rel_schema 1 #define Anum_mtm_local_tables_rel_name 2 +#define Natts_mtm_cluster_state 11 +#define Natts_mtm_nodes_state 8 + typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) From bfd72af959e3897ff6ac851290e46a5af6e2c5d4 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 18 Apr 2016 20:28:40 +0300 Subject: [PATCH 0402/1139] Handle critical errors (not completed) --- multimaster.c | 17 +++++++++++++++++ multimaster.h | 1 + pglogical_apply.c | 1 + 3 files changed, 19 insertions(+) diff --git a/multimaster.c b/multimaster.c index 3148cf522a..02453cf26e 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1014,6 +1014,23 @@ void MtmAbortTransaction(MtmTransState* ts) * ------------------------------------------- */ +void MtmHandleApplyError(void) +{ + ErrorData *edata = CopyErrorData(); + switch (edata->sqlerrcode) { + case ERRCODE_DISK_FULL: + case ERRCODE_INSUFFICIENT_RESOURCES: + case ERRCODE_IO_ERROR: + case ERRCODE_DATA_CORRUPTED: + case ERRCODE_INDEX_CORRUPTED: + case ERRCODE_SYSTEM_ERROR: + case ERRCODE_INTERNAL_ERROR: + case ERRCODE_OUT_OF_MEMORY: + break; + } +} + + void MtmRecoveryCompleted(void) { MTM_LOG1("Recovery of node %d is completed", MtmNodeId); diff --git a/multimaster.h b/multimaster.h index ddec2fa482..cfe96e962b 100644 --- a/multimaster.h +++ b/multimaster.h @@ -238,5 +238,6 @@ extern void MtmCheckQuorum(void); extern bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN); extern void MtmRecoveryCompleted(void); extern void MtmMakeTableLocal(char* schema, char* name); +extern void MtmHandleApplyError(void); #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index feee7eddc9..612840f9c0 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -951,6 +951,7 @@ void MtmExecutor(int id, void* work, size_t size) } PG_CATCH(); { + MtmHandleApplyError(); EmitErrorReport(); FlushErrorState(); MTM_LOG2("%d: REMOTE begin abort transaction %d", MyProcPid, MtmGetCurrentTransactionId()); From a6417d0352c96acc5cbdcc4032b8843d676d88ba Mon Sep 17 00:00:00 2001 From: knizhnik Date: Mon, 18 Apr 2016 23:01:58 +0300 Subject: [PATCH 0403/1139] Exclude node from cluster on non-recoverable error --- multimaster.c | 10 +++++++--- multimaster.h | 5 +++-- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/multimaster.c b/multimaster.c index 02453cf26e..ca74c56aa0 100644 --- a/multimaster.c +++ b/multimaster.c @@ -166,7 +166,8 @@ char const* const MtmNodeStatusMnem[] = "Connected", "Online", "Recovery", - "InMinor" + "InMinor", + "OutOfService" }; bool MtmDoReplication; @@ -1025,8 +1026,11 @@ void MtmHandleApplyError(void) case ERRCODE_INDEX_CORRUPTED: case ERRCODE_SYSTEM_ERROR: case ERRCODE_INTERNAL_ERROR: - case ERRCODE_OUT_OF_MEMORY: - break; + case ERRCODE_OUT_OF_MEMORY: + elog(WARNING, "Node is excluded from cluster because of non-recoverable error %d", edata->sqlerrcode); + MtmSwitchClusterMode(MTM_OUT_OF_SERVICE); + kill(PostmasterPid, SIGQUIT); + break; } } diff --git a/multimaster.h b/multimaster.h index cfe96e962b..7b0abdd08d 100644 --- a/multimaster.h +++ b/multimaster.h @@ -97,11 +97,12 @@ typedef enum typedef enum { MTM_INITIALIZATION, /* Initial status */ - MTM_OFFLINE, /* Node is out of quorum */ + MTM_OFFLINE, /* Node is excluded from cluster */ MTM_CONNECTED, /* Arbiter is established connections with other nodes */ MTM_ONLINE, /* Ready to receive client's queries */ MTM_RECOVERY, /* Node is in recovery process */ - MTM_IN_MINORITY /* Node is out of quorum */ + MTM_IN_MINORITY, /* Node is out of quorum */ + MTM_OUT_OF_SERVICE /* Node is not avaiable to to critical, non-recoverable error */ } MtmNodeStatus; typedef enum From 77aa42a1ec7dbc5bad7458fbd33b3a3b8d93802a Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 19 Apr 2016 13:56:21 +0300 Subject: [PATCH 0404/1139] Vagrantfile --- tests/Vagrantfile | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 tests/Vagrantfile diff --git a/tests/Vagrantfile b/tests/Vagrantfile new file mode 100644 index 0000000000..eda28ad00a --- /dev/null +++ b/tests/Vagrantfile @@ -0,0 +1,12 @@ +# -*- mode: ruby -*- +# vi: set ft=ruby : + +Vagrant.configure(2) do |config| + config.vm.box = "ubuntu/ubuntu-15.04-snappy-core-stable" + + 5.times do |i| + config.vm.define "n#{i+1}l" + end + +end + From 386eb6dde93e916439cd6ee2a16bfadca354ae9f Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Tue, 19 Apr 2016 14:57:49 +0300 Subject: [PATCH 0405/1139] Update the readme. --- README.md | 165 ++++++++++++++++-------------------------------------- 1 file changed, 48 insertions(+), 117 deletions(-) diff --git a/README.md b/README.md index 01225bfd72..db38b2d3a8 100644 --- a/README.md +++ b/README.md @@ -1,117 +1,48 @@ -# pg_dtm - -### Design - -This repo implements distributed transaction manager using Snapshot Sharing mechanism. General concepts and alternative approaches described in postgres wiki https://wiki.postgresql.org/wiki/DTM. - -Backend-DTM protocol description can be found in [dtmd/README](dtmd/README). - -### Installation - -* Patch postgres using xtm.patch. After that build and install postgres in usual way. -```bash -cd ~/code/postgres -patch -p1 < ~/code/pg_dtm/xtm.patch -``` -* Install pg_dtm extension. -```bash -export PATH=/path/to/pgsql/bin/:$PATH -cd ~/code/pg_dtm -make && make install -``` -* Run dtmd. -```bash -cd ~/code/pg_dtm/dtmd -make -mkdir /tmp/clog -./bin/dtmd & -``` -* To run something meaningful you need at leat two postgres instances. Also pg_dtm requires presense in ```shared_preload_libraries```. -```bash -initdb -D ./install/data1 -initdb -D ./install/data2 -echo "port = 5433" >> ./install/data2/postgresql.conf -echo "shared_preload_libraries = 'pg_dtm'" >> ./install/data1/postgresql.conf -echo "shared_preload_libraries = 'pg_dtm'" >> ./install/data2/postgresql.conf -pg_ctl -D ./install/data1 -l ./install/data1/log start -pg_ctl -D ./install/data2 -l ./install/data2/log start -``` - -#### Automatic provisioning - -For a cluster-wide deploy we use ansible, more details in tests/deploy_layouts. (Ansible instructions will be later) - -### Usage - -Now cluster is running and you can use global tx between two nodes. Let's connect to postgres instances at different ports: - -```sql -create extension pg_dtm; -- node1 -create table accounts(user_id int, amount int); -- node1 -insert into accounts (select 2*generate_series(1,100)-1, 0); -- node1, odd user_id's - create extension pg_dtm; -- node2 - create table accounts(user_id int, amount int); -- node2 - insert into accounts (select 2*generate_series(1,100), 0); -- node2, even user_id's -select dtm_begin_transaction(); -- node1, returns global xid, e.g. 42 - select dtm_join_transaction(42); -- node2, join global tx -begin; -- node1 - begin; -- node2 -update accounts set amount=amount-100 where user_id=1; -- node1, transfer money from user#1 - update accounts set amount=amount+100 where user_id=2; -- node2, to user#2 -commit; -- node1, blocks until second commit happend - commit; -- node2 -``` - -### Consistency testing - -To ensure consistency we use simple bank test: perform a lot of simultaneous transfers between accounts on different servers, while constantly checking total amount of money on all accounts. This test can be found in tests/perf. - -```bash -> go run ./tests/perf/* - -C value - Connection string (repeat for multiple connections) - -a int - The number of bank accounts (default 100000) - -b string - Backend to use. Possible optinos: transfers, fdw, pgshard, readers. (default "transfers") - -g Use DTM to keep global consistency - -i Init database - -l Use 'repeatable read' isolation level instead of 'read committed' - -n int - The number updates each writer (reader in case of Reades backend) performs (default 10000) - -p Use parallel execs - -r int - The number of readers (default 1) - -s int - StartID. Script will update rows starting from this value - -v Show progress and other stuff for mortals - -w int - The number of writers (default 8) -``` - -So previous installation can be initialized with: -``` -go run ./tests/perf/*.go \ --C "dbname=postgres port=5432" \ --C "dbname=postgres port=5433" \ --g -i -``` -and tested with: -``` -go run ./tests/perf/*.go \ --C "dbname=postgres port=5432" \ --C "dbname=postgres port=5433" \ --g -``` - -### Using with postres_fdw. - -We also provide a patch, that enables support of global transactions with postres_fdw. After patching and installing postres_fdw it is possible to run same test via fdw usig key ```-b fdw```. - -### Using with pg_shard - -Citus Data have branch in their pg_shard repo, that interacts with transaction manager. https://github.com/citusdata/pg_shard/tree/transaction_manager_integration -To use this feature one should have following line in postgresql.conf (or set it via GUC) -``` -pg_shard.use_dtm_transactions = 1 -``` +# Postgres Multimaster + +## Testing + +The testing process involves multiple modules that perform different tasks. The +modules and their APIs are listed below. + +### Modules + +#### `combineaux` + +Governs the whole testing process. Runs different workloads during different +troubles. + +#### `stresseaux` + +Puts workloads against the database. Writes logs that are later used by +`valideaux`. + +* `start(id, workload, cluster)` - starts a `workload` against the `cluster` +and call it `id`. +* `stop(id)` - stops a previously started workload called `id`. + +#### `starteaux` + +Manages the database nodes. + +* `deploy(driver, ...)` - deploys a cluster using the specified `driver` and +other parameters specific to that driver. Returns a `cluster` instance that is +used in other methods. +* ` + +#### `troubleaux` + +This is the troublemaker that messes with the network, nodes and time. + +* `cause(cluster, trouble)` - causes the specified `trouble` in the specified +`cluster`. +* `fix(cluster)` - fixes all troubles caused in the `cluster`. + +#### `valideaux` + +Validates the logs of stresseaux. + +#### `reporteaux` + +Generates reports on the test results. This is usually a table that with +`trouble` vs `workload` axes. From 04a1fe48693ef5beade2ff7c729e8a7ea319660f Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Tue, 19 Apr 2016 15:19:07 +0300 Subject: [PATCH 0406/1139] Describe more methods in mmts readme. --- README.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index db38b2d3a8..7a4d3fd525 100644 --- a/README.md +++ b/README.md @@ -28,14 +28,19 @@ Manages the database nodes. * `deploy(driver, ...)` - deploys a cluster using the specified `driver` and other parameters specific to that driver. Returns a `cluster` instance that is used in other methods. -* ` +* `cluster->up(id)` - adds a node named `id` to the `cluster`. +* `cluster->down(id)` - removes a node named `id` from the `cluster`. +* `cluster->drop(src, dst, ratio)` - drop `ratio` packets flowing from node +`src` to node `dst`. +* `cluster->delay(src, dst, msec)` - delay packets flowing from node `src` to +node `dst` by `msec` milliseconds. #### `troubleaux` This is the troublemaker that messes with the network, nodes and time. -* `cause(cluster, trouble)` - causes the specified `trouble` in the specified -`cluster`. +* `cause(cluster, trouble, ...)` - causes the specified `trouble` in the +specified `cluster` with some trouble-specific parameters. * `fix(cluster)` - fixes all troubles caused in the `cluster`. #### `valideaux` From 501c8e72454cbc95cfb479d7b52646f773bd1729 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Tue, 19 Apr 2016 18:07:35 +0300 Subject: [PATCH 0407/1139] Add Testeaux perl module with some stubs. --- Testeaux.pm | 85 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 Testeaux.pm diff --git a/Testeaux.pm b/Testeaux.pm new file mode 100644 index 0000000000..2785fa6cd8 --- /dev/null +++ b/Testeaux.pm @@ -0,0 +1,85 @@ +package Testeaux; + +package combineaux +{ + sub combine + { + my ($workloads, $troubles) = @_; + + my $cluster = starteaux->deploy('lxc'); + + foreach my $workload (@$workloads) + { + foreach my $trouble (@$troubles) + { + print("run workload $workload during trouble $trouble\n"); + # FIXME: generate proper id instead of 'hello' + stresseaux::start('hello', $workload, $cluster); + # FIXME: add a time gap here + troubleaux::cause($cluster, $trouble); + # FIXME: add a time gap here + stresseaux::stop('hello'); + troubleaux::fix($cluster); + } + } + } +} + +package stresseaux +{ + sub start + { + my ($id, $workload, $cluster) = @_; + print("start stress $id: workload $workload, cluster $cluster\n"); + # fixme: implement + } + + sub stop + { + my $id = shift; + print("stop stress $id\n"); + # FIXME: implement + } +} + +package starteaux +{ + sub deploy + { + my ($class, $driver, @args) = @_; + my $self = {}; + print("deploy cluster using driver $driver\n"); + # fixme: implement + return bless $self, 'starteaux'; + } + + sub up + { + my ($self, $id) = @_; + print("up node $id\n"); + # FIXME: implement + } + + sub down + { + my ($self, $id = @_; + print("down node $id\n"); + # FIXME: implement + } + + sub drop + { + my ($self, $src, $dst, $ratio) = @_; + print("drop $ratio packets from $src to $dst\n"); + # FIXME: implement + } + + sub delay + { + my ($self, $src, $dst, $msec) = @_; + print("delay packets from $src to $dst by $msec msec\n"); + # FIXME: implement + } +} + +1; From d7bc3beed1167c232796a0b59864d111b4f16c3a Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 19 Apr 2016 18:12:57 +0300 Subject: [PATCH 0408/1139] Change flush position reporting method --- multimaster.c | 43 +++++++++++++++++++++++++++++++++++++++++++ multimaster.h | 12 ++++++++++++ pglogical_apply.c | 7 +++++-- pglogical_receiver.c | 9 +++++---- tests/dtmbench.cpp | 4 ++-- 5 files changed, 67 insertions(+), 8 deletions(-) diff --git a/multimaster.c b/multimaster.c index ca74c56aa0..2eb1aed38c 100644 --- a/multimaster.c +++ b/multimaster.c @@ -146,6 +146,8 @@ static bool MtmIsRecoverySession; static MtmCurrentTrans MtmTx; +static dlist_head MtmLsnMapping = DLIST_STATIC_INIT(MtmLsnMapping); + static TransactionManager MtmTM = { PgTransactionIdGetStatus, PgTransactionIdSetTreeStatus, @@ -1032,6 +1034,7 @@ void MtmHandleApplyError(void) kill(PostmasterPid, SIGQUIT); break; } + FreeErrorData(edata); } @@ -1506,6 +1509,7 @@ static void MtmInitialize() Mtm->nodes[i].transDelay = 0; Mtm->nodes[i].lastStatusChangeTime = time(NULL); Mtm->nodes[i].con = MtmConnections[i]; + Mtm->nodes[i].flushPos = 0; } PGSemaphoreCreate(&Mtm->votingSemaphore); PGSemaphoreReset(&Mtm->votingSemaphore); @@ -2083,6 +2087,45 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) on_shmem_exit(MtmOnProcExit, 0); } +XLogRecPtr MtmGetFlushPosition(int nodeId) +{ + return Mtm->nodes[nodeId-1].flushPos; +} + +void MtmUpdateLsnMapping(int node_id, XLogRecPtr end_lsn) +{ + dlist_mutable_iter iter; + MtmFlushPosition* flushpos; + XLogRecPtr local_flush = GetFlushRecPtr(); + MemoryContext old_context = MemoryContextSwitchTo(TopMemoryContext); + + /* Track commit lsn */ + flushpos = (MtmFlushPosition *) palloc(sizeof(MtmFlushPosition)); + flushpos->node_id = node_id; + flushpos->local_end = XactLastCommitEnd; + flushpos->remote_end = end_lsn; + dlist_push_tail(&MtmLsnMapping, &flushpos->node); + + MtmLock(LW_EXCLUSIVE); + dlist_foreach_modify(iter, &MtmLsnMapping) + { + flushpos = dlist_container(MtmFlushPosition, node, iter.cur); + if (flushpos->local_end <= local_flush) + { + if (Mtm->nodes[node_id-1].flushPos < local_flush) { + Mtm->nodes[node_id-1].flushPos = local_flush; + } + dlist_delete(iter.cur); + pfree(flushpos); + } else { + break; + } + } + MtmUnlock(); + MemoryContextSwitchTo(old_context); +} + + static void MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) { diff --git a/multimaster.h b/multimaster.h index 7b0abdd08d..3adf02b206 100644 --- a/multimaster.h +++ b/multimaster.h @@ -124,6 +124,7 @@ typedef struct MtmConnectionInfo con; time_t transDelay; time_t lastStatusChangeTime; + XLogRecPtr flushPos; csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ } MtmNodeInfo; @@ -179,6 +180,15 @@ typedef struct MtmNodeInfo nodes[1]; /* [MtmNodes]: per-node data */ } MtmState; +typedef struct MtmFlushPosition +{ + dlist_node node; + int node_id; + XLogRecPtr local_end; + XLogRecPtr remote_end; +} MtmFlushPosition; + + #define MtmIsCoordinator(ts) (ts->gtid.node == MtmNodeId) extern char const* const MtmNodeStatusMnem[]; @@ -240,5 +250,7 @@ extern bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN); extern void MtmRecoveryCompleted(void); extern void MtmMakeTableLocal(char* schema, char* name); extern void MtmHandleApplyError(void); +extern void MtmUpdateLsnMapping(int nodeId, XLogRecPtr endLsn); +extern XLogRecPtr MtmGetFlushPosition(int nodeId); #endif diff --git a/pglogical_apply.c b/pglogical_apply.c index 612840f9c0..33a2d385a7 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -509,14 +509,14 @@ process_remote_commit(StringInfo in) uint8 flags; csn_t csn; const char *gid = NULL; - + XLogRecPtr end_lsn; /* read flags */ flags = pq_getmsgbyte(in); MtmReplicationNode = pq_getmsgbyte(in); /* read fields */ replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ - pq_getmsgint64(in); /* end_lsn */ + end_lsn = pq_getmsgint64(in); /* end_lsn */ replorigin_session_origin_timestamp = pq_getmsgint64(in); /* commit_time */ Assert(replorigin_session_origin == InvalidRepOriginId); @@ -581,6 +581,7 @@ process_remote_commit(StringInfo in) Assert(false); } MtmEndSession(true); + MtmUpdateLsnMapping(MtmReplicationNodeId, end_lsn); if (flags & PGLOGICAL_CAUGHT_UP) { MtmRecoveryCompleted(); } @@ -951,7 +952,9 @@ void MtmExecutor(int id, void* work, size_t size) } PG_CATCH(); { + MemoryContext oldcontext = MemoryContextSwitchTo(ApplyContext); MtmHandleApplyError(); + MemoryContextSwitchTo(oldcontext); EmitErrorReport(); FlushErrorState(); MTM_LOG2("%d: REMOTE begin abort transaction %d", MyProcPid, MtmGetCurrentTransactionId()); diff --git a/pglogical_receiver.c b/pglogical_receiver.c index d635cf6bdb..95a1c2345e 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -89,17 +89,18 @@ receiver_raw_sighup(SIGNAL_ARGS) * Send a Standby Status Update message to server. */ static bool -sendFeedback(PGconn *conn, int64 now, RepOriginId originId) +sendFeedback(PGconn *conn, int64 now, int node_id) { char replybuf[1 + 8 + 8 + 8 + 8 + 1]; int len = 0; - XLogRecPtr output_applied_lsn = replorigin_get_progress(originId, true); + XLogRecPtr output_applied_lsn = output_written_lsn; + XLogRecPtr output_flushed_lsn = MtmGetFlushPosition(node_id); replybuf[len] = 'r'; len += 1; fe_sendint64(output_written_lsn, &replybuf[len]); /* write */ len += 8; - fe_sendint64(output_applied_lsn, &replybuf[len]); /* flush */ + fe_sendint64(output_flushed_lsn, &replybuf[len]); /* flush */ len += 8; fe_sendint64(output_applied_lsn, &replybuf[len]); /* apply */ len += 8; @@ -421,7 +422,7 @@ pglogical_receiver_main(Datum main_arg) int64 now = feGetCurrentTimestamp(); /* Leave is feedback is not sent properly */ - if (!sendFeedback(conn, now, originId)) + if (!sendFeedback(conn, now, args->remote_node)) proc_exit(1); } continue; diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 553eca2ab3..e92f1a5798 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -150,8 +150,8 @@ void* writer(void* arg) for (int i = 0; i < cfg.nIterations; i++) { //work - transaction txn(*conns[random() % conns.size()]); - //transaction txn(*conns[random() % conns.size()]); + //transaction txn(*conns[random() % conns.size()]); + transaction txn(*conns[random() % conns.size()]); int srcAcc = random() % cfg.nAccounts; int dstAcc = random() % cfg.nAccounts; if (cfg.scatter) { From b48c19147980c6ef7531a492a0aa79775f86bbaa Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 19 Apr 2016 19:32:17 +0300 Subject: [PATCH 0409/1139] =?UTF-8?q?Fix=20a=20big=20in=20building=20symet?= =?UTF-8?q?ric=20matrix=20for=20Bron=E2=80=93Kerbosch=20algorithm?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- multimaster.c | 1 + 1 file changed, 1 insertion(+) diff --git a/multimaster.c b/multimaster.c index 2eb1aed38c..34c17fbb27 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1245,6 +1245,7 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) for (i = 0; i < n; i++) { for (j = 0; j < i; j++) { matrix[i] |= ((matrix[j] >> i) & 1) << j; + matrix[j] |= ((matrix[i] >> j) & 1) << i; } } return true; From 0621b7bafb578ace03c4e3e90df4cb6ff1d17cb2 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 20 Apr 2016 13:56:21 +0300 Subject: [PATCH 0410/1139] Spill applied transactions to the disk --- Makefile | 4 +- multimaster.c | 17 +++++++ multimaster.h | 1 + pglogical_apply.c | 35 ++++++++++++- pglogical_receiver.c | 107 +++++++++++++++------------------------- spill.c | 114 +++++++++++++++++++++++++++++++++++++++++++ spill.h | 11 +++++ 7 files changed, 217 insertions(+), 72 deletions(-) create mode 100644 spill.c create mode 100644 spill.h diff --git a/Makefile b/Makefile index 2b2ae72de5..a77dc3aa1a 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ MODULE_big = multimaster -OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o pglogical_relid_map.o ddd.o bkb.o +OBJS = multimaster.o raftable.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o pglogical_relid_map.o ddd.o bkb.o spill.o override CPPFLAGS += -I../raftable @@ -15,7 +15,7 @@ all: multimaster.so tests/dtmbench: make -C tests -PG_CPPFLAGS = -I$(libpq_srcdir) -DUSE_PGLOGICAL_OUTPUT +PG_CPPFLAGS = -I$(libpq_srcdir) SHLIB_LINK = $(libpq) ifdef USE_PGXS diff --git a/multimaster.c b/multimaster.c index 34c17fbb27..f0ae4296b2 100644 --- a/multimaster.c +++ b/multimaster.c @@ -184,6 +184,7 @@ int MtmConnectTimeout; int MtmKeepaliveTimeout; int MtmReconnectAttempts; int MtmNodeDisableDelay; +int MtmTransSpillThreshold; bool MtmUseRaftable; bool MtmUseDtm; MtmConnectionInfo* MtmConnections; @@ -1247,6 +1248,7 @@ MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) matrix[i] |= ((matrix[j] >> i) & 1) << j; matrix[j] |= ((matrix[i] >> j) & 1) << i; } + matrix[i] &= ~((nodemask_t)1 << i); } return true; } @@ -1630,6 +1632,21 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.trans_spill_threshold", + "Maximal size (Mb) of transaction after which transaction is written to the disk", + NULL, + &MtmTransSpillThreshold, + 1000, /* 1Gb */ + 0, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.twopc_min_timeout", "Minamal amount of time (milliseconds) to wait 2PC confirmation from all nodes", diff --git a/multimaster.h b/multimaster.h index 3adf02b206..a2ddaefe9d 100644 --- a/multimaster.h +++ b/multimaster.h @@ -205,6 +205,7 @@ extern int MtmConnectTimeout; extern int MtmReconnectAttempts; extern int MtmKeepaliveTimeout; extern int MtmNodeDisableDelay; +extern int MtmTransSpillThreshold; extern bool MtmUseDtm; extern HTAB* MtmXid2State; diff --git a/pglogical_apply.c b/pglogical_apply.c index 33a2d385a7..5c6ee9ff7c 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -50,6 +50,7 @@ #include "multimaster.h" #include "pglogical_relid_map.h" +#include "spill.h" typedef struct TupleData { @@ -901,6 +902,9 @@ void MtmExecutor(int id, void* work, size_t size) { StringInfoData s; Relation rel = NULL; + int spill_file = -1; + int save_cursor; + int save_len; s.data = work; s.len = size; s.maxlen = -1; @@ -944,6 +948,33 @@ void MtmExecutor(int id, void* work, size_t size) case 'R': rel = read_rel(&s, RowExclusiveLock); continue; + case 'F': + { + int node_id = pq_getmsgint(&s, 4); + int file_id = pq_getmsgint(&s, 4); + Assert(spill_file < 0); + spill_file = MtmOpenSpillFile(node_id, file_id); + continue; + } + case '(': + { + int64 size = pq_getmsgint(&s, 4); + s.data = palloc(size); + save_cursor = s.cursor; + save_len = s.len; + s.cursor = 0; + s.len = size; + MtmReadSpillFile(spill_file, s.data, size); + continue; + } + case ')': + { + pfree(s.data); + s.data = work; + s.cursor = save_cursor; + s.len = save_len; + continue; + } default: elog(ERROR, "unknown action of type %c", action); } @@ -963,7 +994,9 @@ void MtmExecutor(int id, void* work, size_t size) MTM_LOG2("%d: REMOTE end abort transaction %d", MyProcPid, MtmGetCurrentTransactionId()); } PG_END_TRY(); - + if (spill_file >= 0) { + MtmCloseSpillFile(spill_file); + } MemoryContextResetAndDeleteChildren(ApplyContext); } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 95a1c2345e..7284489ece 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -24,6 +24,7 @@ #include "access/clog.h" #include "access/transam.h" #include "lib/stringinfo.h" +#include "libpq/pqformat.h" #include "pgstat.h" #include "postmaster/bgworker.h" #include "storage/ipc.h" @@ -35,6 +36,7 @@ #include "replication/origin.h" #include "multimaster.h" +#include "spill.h" /* Allow load of this module in shared libs */ @@ -213,20 +215,23 @@ pglogical_receiver_main(Datum main_arg) PGresult *res; MtmSlotMode mode; -#ifndef USE_PGLOGICAL_OUTPUT - bool insideTrans = false; -#endif ByteBuffer buf; XLogRecPtr originStartPos = 0; RepOriginId originId; char* originName; /* Buffer for COPY data */ char *copybuf = NULL; + int spill_file = -1; + StringInfoData spill_info; + + initStringInfo(&spill_info); /* Register functions for SIGTERM/SIGHUP management */ pqsignal(SIGHUP, receiver_raw_sighup); pqsignal(SIGTERM, receiver_raw_sigterm); + MtmCreateSpillDirectory(args->remote_node); + sprintf(worker_proc, "mtm_pglogical_receiver_%d_%d", args->local_node, args->remote_node); /* We're now ready to receive signals */ @@ -449,34 +454,38 @@ pglogical_receiver_main(Datum main_arg) if (rc > hdr_len) { stmt = copybuf + hdr_len; - -#ifdef USE_PGLOGICAL_OUTPUT + + if (buf.used >= MtmTransSpillThreshold) { + if (spill_file < 0) { + int file_id; + spill_file = MtmCreateSpillFile(args->remote_node, &file_id); + pq_sendbyte(&spill_info, 'F'); + pq_sendint(&spill_info, args->remote_node, 4); + pq_sendint(&spill_info, file_id, 4); + } + ByteBufferAppend(&buf, ")", 1); + pq_sendbyte(&spill_info, '('); + pq_sendint(&spill_info, buf.used, 4); + MtmSpillToFile(spill_file, buf.data, buf.used); + ByteBufferReset(&buf); + } ByteBufferAppend(&buf, stmt, rc - hdr_len); if (stmt[0] == 'C') /* commit */ - { - MtmExecute(buf.data, buf.used); + { + if (spill_file >= 0) { + ByteBufferAppend(&buf, ")", 1); + pq_sendbyte(&spill_info, '('); + pq_sendint(&spill_info, buf.used, 4); + MtmSpillToFile(spill_file, buf.data, buf.used); + MtmCloseSpillFile(spill_file); + MtmExecute(spill_info.data, spill_info.len); + spill_file = -1; + resetStringInfo(&spill_info); + } else { + MtmExecute(buf.data, buf.used); + } ByteBufferReset(&buf); } -#else - if (strncmp(stmt, "BEGIN ", 6) == 0) { - TransactionId xid; - int rc = sscanf(stmt + 6, "%u", &xid); - Assert(rc == 1); - ByteBufferAppendInt32(&buf, xid); - Assert(!insideTrans); - insideTrans = true; - } else if (strncmp(stmt, "COMMIT;", 7) == 0) { - Assert(insideTrans); - Assert(buf.used > 4); - buf.data[buf.used-1] = '\0'; /* replace last ';' with '\0' to make string zero terminated */ - MMExecute(buf.data, buf.used); - ByteBufferReset(&buf); - insideTrans = false; - } else { - Assert(insideTrans); - ByteBufferAppend(&buf, stmt, rc - hdr_len/*strlen(stmt)*/); - } -#endif } /* Update written position */ output_written_lsn = Max(walEnd, output_written_lsn); @@ -575,6 +584,7 @@ void MtmStartReceivers(void) { int i; BackgroundWorker worker; + MemSet(&worker, 0, sizeof(BackgroundWorker)); worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; worker.bgw_start_time = BgWorkerStart_ConsistentState; @@ -586,6 +596,7 @@ void MtmStartReceivers(void) ReceiverArgs* ctx = (ReceiverArgs*)palloc(sizeof(ReceiverArgs)); ctx->receiver_conn_string = psprintf("replication=database %s", MtmConnections[i].connStr); sprintf(ctx->receiver_slot, MULTIMASTER_SLOT_PATTERN, MtmNodeId); + ctx->local_node = MtmNodeId; ctx->remote_node = i+1; @@ -598,45 +609,3 @@ void MtmStartReceivers(void) } } -#ifndef USE_PGLOGICAL_OUTPUT -void MMExecutor(int id, void* work, size_t size) -{ - TransactionId xid = *(TransactionId*)work; - char* stmts = (char*)work + 4; - bool finished = false; - - MMJoinTransaction(xid); - - SetCurrentStatementStartTimestamp(); - StartTransactionCommand(); - SPI_connect(); - PushActiveSnapshot(GetTransactionSnapshot()); - - PG_TRY(); - { - int rc = SPI_execute(stmts, false, 0); - SPI_finish(); - PopActiveSnapshot(); - finished = true; - if (rc != SPI_OK_INSERT && rc != SPI_OK_UPDATE && rc != SPI_OK_DELETE) { - ereport(LOG, (errmsg("Executor %d: failed to apply transaction %u", - id, xid))); - AbortCurrentTransaction(); - } else { - CommitTransactionCommand(); - } - } - PG_CATCH(); - { - FlushErrorState(); - if (!finished) { - SPI_finish(); - if (ActiveSnapshotSet()) { - PopActiveSnapshot(); - } - } - AbortCurrentTransaction(); - } - PG_END_TRY(); -} -#endif diff --git a/spill.c b/spill.c new file mode 100644 index 0000000000..09d022bf03 --- /dev/null +++ b/spill.c @@ -0,0 +1,114 @@ +#include "postgres.h" + +#include +#include +#include "storage/fd.h" +#include "spill.h" +#include "pgstat.h" + +void MtmSpillToFile(int fd, char const* data, size_t size) +{ + Assert(fd >= 0); + while (size != 0) { + int written = write(fd, data, size); + if (written <= 0) { + CloseTransientFile(fd); + ereport(ERROR, + (errcode_for_file_access(), + errmsg("pglogical_recevier failed to spill transaction to file: %m"))); + } + data += written; + size -= written; + } +} + +void MtmCreateSpillDirectory(int node_id) +{ + char path[MAXPGPATH]; + struct dirent *spill_de; + DIR* spill_dir; + + mkdir("pg_mtm", S_IRWXU); + sprintf(path, "pg_mtm/%d", node_id); + mkdir(path, S_IRWXU); + + spill_dir = AllocateDir(path); + + while ((spill_de = ReadDir(spill_dir, path)) != NULL) + { + if (strncmp(spill_de->d_name, "txn", 3) == 0) + { + sprintf(path, "pg_mtm/%d/%s", node_id, spill_de->d_name); + + if (unlink(path) != 0) + ereport(PANIC, + (errcode_for_file_access(), + errmsg("pglogical_receiver could not remove spill file \"%s\": %m", + path))); + } + } + FreeDir(spill_dir); +} + + +int MtmCreateSpillFile(int node_id, int* file_id) +{ + static int spill_file_id; + char path[MAXPGPATH]; + int fd; + + sprintf(path, "pg_mtm/%d/txn-%d.snap", + node_id, ++spill_file_id); + fd = OpenTransientFile(path, + O_CREAT | O_TRUNC | O_WRONLY | O_APPEND | PG_BINARY, + S_IRUSR | S_IWUSR); + if (fd < 0) { + ereport(PANIC, + (errcode_for_file_access(), + errmsg("pglogical_receiver could not create spill file \"%s\": %m", + path))); + } + *file_id = spill_file_id; + return fd; +} + +int MtmOpenSpillFile(int node_id, int file_id) +{ + static char path[MAXPGPATH]; + int fd; + + sprintf(path, "pg_mtm/%d/txn-%d.snap", + node_id, file_id); + fd = OpenTransientFile(path, + O_RDONLY | PG_BINARY, + S_IRUSR | S_IWUSR); + if (fd < 0) { + ereport(PANIC, + (errcode_for_file_access(), + errmsg("pglogical_apply could not open spill file \"%s\": %m", + path))); + } + unlink(path); /* Should remove file on close */ + return fd; +} + +void MtmReadSpillFile(int fd, char* data, size_t size) +{ + Assert(fd >= 0); + while (size != 0) { + int rc = read(fd, data, size); + if (rc <= 0) { + CloseTransientFile(fd); + ereport(ERROR, + (errcode_for_file_access(), + errmsg("pglogical_apply failed to read spill file: %m"))); + } + data += rc; + size -= rc; + } +} + +void MtmCloseSpillFile(int fd) +{ + CloseTransientFile(fd); +} diff --git a/spill.h b/spill.h new file mode 100644 index 0000000000..01a6035ff0 --- /dev/null +++ b/spill.h @@ -0,0 +1,11 @@ +#ifndef __SPILL_H__ +#define __SPILL_H__ + +void MtmSpillToFile(int fd, char const* data, size_t size); +void MtmCreateSpillDirectory(int node_id); +int MtmCreateSpillFile(int node_id, int* file_id); +int MtmOpenSpillFile(int node_id, int file_id); +void MtmReadSpillFile(int fd, char* data, size_t size); +void MtmCloseSpillFile(int fd); + +#endif From e5fdc931002f6858adec596f455fdb6c75897039 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 20 Apr 2016 14:51:08 +0300 Subject: [PATCH 0411/1139] start/stop cluster --- testeaux/Cluster.pm | 164 ++++++++++++++++++++++++++++++++ testeaux/Makefile | 26 +++++ {tests => testeaux}/Vagrantfile | 0 testeaux/run.pl | 22 +++++ 4 files changed, 212 insertions(+) create mode 100644 testeaux/Cluster.pm create mode 100644 testeaux/Makefile rename {tests => testeaux}/Vagrantfile (100%) create mode 100644 testeaux/run.pl diff --git a/testeaux/Cluster.pm b/testeaux/Cluster.pm new file mode 100644 index 0000000000..72ea0a3438 --- /dev/null +++ b/testeaux/Cluster.pm @@ -0,0 +1,164 @@ +package Cluster; + +use strict; +use warnings; + +use PostgresNode; +use TestLib; +use Test::More; +use Cwd; +use List::Util; + +my %allocated_ports = (); +sub allocate_ports +{ + my @allocated_now = (); + my ($host, $ports_to_alloc) = @_; + + while ($ports_to_alloc > 0) + { + my $port = int(rand() * 16384) + 49152; + + # # try to use ordinary ports if available + # if (!@allocated_now) + # my $port = 5432; + # else + # my $port = max(@allocated_now) + 1; + + next if $allocated_ports{$port}; + diag("checking for port $port\n"); + if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) + { + $allocated_ports{$port} = 1; + push(@allocated_now, $port); + $ports_to_alloc--; + } + } + + return @allocated_now; +} + +sub new +{ + my ($class, $nodenum) = @_; + + my $nodes = []; + + foreach my $i (1..$nodenum) + { + my $host = "127.0.0.1"; + my ($pgport, $raftport) = allocate_ports($host, 2); + my $node = new PostgresNode("node$i", $host, $pgport); + $node->{id} = $i; + $node->{raftport} = $raftport; + push(@$nodes, $node); + } + + my $self = { + nodenum => $nodenum, + nodes => $nodes, + }; + + bless $self, $class; + return $self; +} + +sub init +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->init(hba_permit_replication => 0); + } +} + +sub detach +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + delete $node->{_pid}; + } +} + +sub configure +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + my $connstr = join(',', map { "${ \$_->connstr('postgres') }" } @$nodes); + my $raftpeers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @$nodes); + + foreach my $node (@$nodes) + { + my $id = $node->{id}; + my $host = $node->host; + my $pgport = $node->port; + my $raftport = $node->{raftport}; + + $node->append_conf("postgresql.conf", qq( + listen_addresses = '$host' + unix_socket_directories = '' + port = $pgport + max_prepared_transactions = 200 + max_connections = 200 + max_worker_processes = 100 + wal_level = logical + fsync = off + max_wal_senders = 10 + wal_sender_timeout = 0 + max_replication_slots = 10 + shared_preload_libraries = 'raftable,multimaster' + multimaster.workers = 10 + multimaster.queue_size = 10485760 # 10mb + multimaster.node_id = $id + multimaster.conn_strings = '$connstr' + multimaster.use_raftable = true + multimaster.ignore_tables_without_pk = true + multimaster.twopc_min_timeout = 60000 + raftable.id = $id + raftable.peers = '$raftpeers' + )); + + $node->append_conf("pg_hba.conf", qq( + local replication all trust + host replication all 127.0.0.1/32 trust + host replication all ::1/128 trust + )); + } +} + +sub start +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->start(); + } +} + +sub stop +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->stop(); + } +} + +sub psql +{ + my ($self, $index, @args) = @_; + my $node = $self->{nodes}->[$index]; + return $node->psql(@args); +} + +1; diff --git a/testeaux/Makefile b/testeaux/Makefile new file mode 100644 index 0000000000..f931ced1a3 --- /dev/null +++ b/testeaux/Makefile @@ -0,0 +1,26 @@ + +.PHONY: all + + +subdir = contrib/multimaster/testeaux +top_builddir = ../../.. +include $(top_builddir)/src/Makefile.global +include $(top_srcdir)/contrib/contrib-global.mk + +start: + echo "Installing postgres to SRCDIR/tmp_install" + cd $(abs_top_builddir) && env DESTDIR='$(abs_top_builddir)'/tmp_install make install > /dev/null + echo "Installing raftable to SRCDIR/tmp_install" + cd $(abs_top_builddir)/contrib/raftable && env DESTDIR='$(abs_top_builddir)'/tmp_install make install + echo "Installing mmts to SRCDIR/tmp_install" + cd $(abs_top_builddir)/contrib/mmts && env DESTDIR='$(abs_top_builddir)'/tmp_install make install + rm -rf $(CURDIR)/tmp_check/log + echo "Ininializing new postgres cluster in contrib/mmts/tmp_install" + cd $(srcdir) && TESTDIR='$(CURDIR)' PERL5LIB=$(abs_top_builddir)/src/test/perl:$(PERL5LIB) $(with_temp_install) PGPORT='6$(DEF_PGPORT)' PG_REGRESS='$(CURDIR)/$(top_builddir)/src/test/regress/pg_regress' perl run.pl + +stop: + echo "Stopping all instances in tmp_install" + for DIR in ./tmp_check/data_node*; do \ + pg_ctl stop -m immediate -D $$DIR/pgdata; \ + rm -rf $$DIR; \ + done diff --git a/tests/Vagrantfile b/testeaux/Vagrantfile similarity index 100% rename from tests/Vagrantfile rename to testeaux/Vagrantfile diff --git a/testeaux/run.pl b/testeaux/run.pl new file mode 100644 index 0000000000..16286a064f --- /dev/null +++ b/testeaux/run.pl @@ -0,0 +1,22 @@ +use strict; +use warnings; +use Cluster; +use TestLib; +use DBI; +use File::Temp (); + +#use DBD::Pg ':async'; + +#@{; eval { TestLib::end_av->object_2svref } || [] } = (); + +$File::Temp::KEEP_ALL = 1; + +my $cluster = new Cluster(3); +$cluster->init; +$cluster->configure; +$cluster->start; +$cluster->detach; + + +#sleep(3600); + From 7b1e095b1ef7f27aabdd5b6a232291be7aae8548 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 20 Apr 2016 14:53:34 +0300 Subject: [PATCH 0412/1139] clean up run.pl --- testeaux/run.pl | 7 ------- 1 file changed, 7 deletions(-) diff --git a/testeaux/run.pl b/testeaux/run.pl index 16286a064f..be48c4b189 100644 --- a/testeaux/run.pl +++ b/testeaux/run.pl @@ -5,10 +5,6 @@ use DBI; use File::Temp (); -#use DBD::Pg ':async'; - -#@{; eval { TestLib::end_av->object_2svref } || [] } = (); - $File::Temp::KEEP_ALL = 1; my $cluster = new Cluster(3); @@ -17,6 +13,3 @@ $cluster->start; $cluster->detach; - -#sleep(3600); - From 4e3682c21a59f70cba9732953fc48715b6d9db58 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 20 Apr 2016 15:40:55 +0300 Subject: [PATCH 0413/1139] use standard port, if available --- testeaux/Cluster.pm | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/testeaux/Cluster.pm b/testeaux/Cluster.pm index 72ea0a3438..7dd377a74e 100644 --- a/testeaux/Cluster.pm +++ b/testeaux/Cluster.pm @@ -7,32 +7,24 @@ use PostgresNode; use TestLib; use Test::More; use Cwd; -use List::Util; -my %allocated_ports = (); +my $max_port = 5431; sub allocate_ports { my @allocated_now = (); my ($host, $ports_to_alloc) = @_; + my $port = $max_port + 1; while ($ports_to_alloc > 0) { - my $port = int(rand() * 16384) + 49152; - - # # try to use ordinary ports if available - # if (!@allocated_now) - # my $port = 5432; - # else - # my $port = max(@allocated_now) + 1; - - next if $allocated_ports{$port}; diag("checking for port $port\n"); if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port])) { - $allocated_ports{$port} = 1; + $max_port = $port; push(@allocated_now, $port); $ports_to_alloc--; } + $port++; } return @allocated_now; From dd33aa2ba1fa3cfd602778d4d814b04027c9a646 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 20 Apr 2016 16:26:59 +0300 Subject: [PATCH 0414/1139] Move Testeaux module to the subfolder. --- Testeaux.pm => testeaux/Testeaux.pm | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Testeaux.pm => testeaux/Testeaux.pm (100%) diff --git a/Testeaux.pm b/testeaux/Testeaux.pm similarity index 100% rename from Testeaux.pm rename to testeaux/Testeaux.pm From 46a5c8263952c1626b58c2e8f6c2c36846d438e0 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 20 Apr 2016 17:03:39 +0300 Subject: [PATCH 0415/1139] Fix syntax in Testeaux module. Add an example that uses it. --- testeaux/Testeaux.pm | 50 +++++++++++++++++++++++++++++++++----------- testeaux/eaux.pl | 8 +++++++ 2 files changed, 46 insertions(+), 12 deletions(-) create mode 100755 testeaux/eaux.pl diff --git a/testeaux/Testeaux.pm b/testeaux/Testeaux.pm index 2785fa6cd8..792d9cdc92 100644 --- a/testeaux/Testeaux.pm +++ b/testeaux/Testeaux.pm @@ -1,12 +1,12 @@ package Testeaux; -package combineaux +package Combineaux { sub combine { my ($workloads, $troubles) = @_; - my $cluster = starteaux->deploy('lxc'); + my $cluster = Starteaux->deploy('lxc'); foreach my $workload (@$workloads) { @@ -14,18 +14,20 @@ package combineaux { print("run workload $workload during trouble $trouble\n"); # FIXME: generate proper id instead of 'hello' - stresseaux::start('hello', $workload, $cluster); - # FIXME: add a time gap here - troubleaux::cause($cluster, $trouble); - # FIXME: add a time gap here - stresseaux::stop('hello'); - troubleaux::fix($cluster); + Stresseaux::start('hello', $workload, $cluster); + sleep(1); # FIXME: will this work? + Troubleaux::cause($cluster, $trouble); + sleep(1); # FIXME: will this work? + Stresseaux::stop('hello'); + Troubleaux::fix($cluster); } } + + $cluster->destroy(); } } -package stresseaux +package Stresseaux { sub start { @@ -42,7 +44,7 @@ package stresseaux } } -package starteaux +package Starteaux { sub deploy { @@ -50,7 +52,7 @@ package starteaux my $self = {}; print("deploy cluster using driver $driver\n"); # fixme: implement - return bless $self, 'starteaux'; + return bless $self, 'Starteaux'; } sub up @@ -62,7 +64,7 @@ package starteaux sub down { - my ($self, $id = @_; + my ($self, $id) = @_; print("down node $id\n"); # FIXME: implement } @@ -80,6 +82,30 @@ package starteaux print("delay packets from $src to $dst by $msec msec\n"); # FIXME: implement } + + sub destroy + { + my ($self) = @_; + print("destroy cluster $cluster\n"); + # FIXME: implement + } +} + +package Troubleaux +{ + sub cause + { + my ($cluster, $trouble) = @_; + print("cause $trouble in cluster $cluster\n"); + # fixme: implement + } + + sub fix + { + my ($cluster) = @_; + print("fix cluster $cluster\n"); + # fixme: implement + } } 1; diff --git a/testeaux/eaux.pl b/testeaux/eaux.pl new file mode 100755 index 0000000000..cef723d4eb --- /dev/null +++ b/testeaux/eaux.pl @@ -0,0 +1,8 @@ +#!/usr/bin/perl + +use Testeaux; + +Combineaux::combine( + ['bank-transfers', 'pgbench-default'], + ['split-brain', 'time-shift'], +) From 97c667ceccb15cd449316f6ab51e6f8ebb4d94ef Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 20 Apr 2016 17:16:04 +0300 Subject: [PATCH 0416/1139] Improve deadlock detection algorithm by taking in account hidden dependencies between transactions caused by lack of vacant workers in apply pool --- bgwpool.c | 22 ++++++++++++++++++++-- bgwpool.h | 8 +++++++- multimaster.c | 49 +++++++++++++++++++++++++++++++++---------------- multimaster.h | 16 +++++++++------- 4 files changed, 69 insertions(+), 26 deletions(-) diff --git a/bgwpool.c b/bgwpool.c index c0044e2ffe..7f4bb2dbda 100644 --- a/bgwpool.c +++ b/bgwpool.c @@ -35,6 +35,9 @@ static void BgwPoolMainLoop(Datum arg) work = malloc(size); pool->pending -= 1; pool->active += 1; + if (pool->lastPeakTime == 0 && pool->active == pool->nWorkers && pool->pending != 0) { + pool->lastPeakTime = MtmGetSystemTime(); + } if (pool->head + size + 4 > pool->size) { memcpy(work, pool->queue, size); pool->head = INTALIGN(size); @@ -48,17 +51,19 @@ static void BgwPoolMainLoop(Datum arg) if (pool->producerBlocked) { pool->producerBlocked = false; PGSemaphoreUnlock(&pool->overflow); + pool->lastPeakTime = 0; } SpinLockRelease(&pool->lock); pool->executor(id, work, size); free(work); SpinLockAcquire(&pool->lock); pool->active -= 1; + pool->lastPeakTime = 0; SpinLockRelease(&pool->lock); } } -void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, size_t queueSize) +void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, size_t queueSize, size_t nWorkers) { pool->queue = (char*)ShmemAlloc(queueSize); pool->executor = executor; @@ -73,8 +78,15 @@ void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, si pool->size = queueSize; pool->active = 0; pool->pending = 0; + pool->nWorkers = nWorkers; + pool->lastPeakTime = 0; strcpy(pool->dbname, dbname); } + +timestamp_t BgwGetLastPeekTime(BgwPool* pool) +{ + return pool->lastPeakTime; +} void BgwPoolStart(int nWorkers, BgwPoolConstructor constructor) { @@ -123,12 +135,18 @@ void BgwPoolExecute(BgwPool* pool, void* work, size_t size) if ((pool->head <= pool->tail && pool->size - pool->tail < size + 4 && pool->head < size) || (pool->head > pool->tail && pool->head - pool->tail < size + 4)) { - pool->producerBlocked = true; + if (pool->lastPeakTime == 0) { + pool->lastPeakTime = MtmGetSystemTime(); + } + pool->producerBlocked = true; SpinLockRelease(&pool->lock); PGSemaphoreLock(&pool->overflow); SpinLockAcquire(&pool->lock); } else { pool->pending += 1; + if (pool->lastPeakTime == 0 && pool->active == pool->nWorkers && pool->pending != 0) { + pool->lastPeakTime = MtmGetSystemTime(); + } *(int*)&pool->queue[pool->tail] = size; if (pool->size - pool->tail >= size + 4) { memcpy(&pool->queue[pool->tail+4], work, size); diff --git a/bgwpool.h b/bgwpool.h index 0a6c5a70a5..f2a700ab4e 100644 --- a/bgwpool.h +++ b/bgwpool.h @@ -7,6 +7,8 @@ typedef void(*BgwPoolExecutor)(int id, void* work, size_t size); +typedef uint64 timestamp_t; + #define MAX_DBNAME_LEN 30 #define MULTIMASTER_BGW_RESTART_TIMEOUT 1 /* seconds */ @@ -21,6 +23,8 @@ typedef struct size_t size; size_t active; size_t pending; + size_t nWorkers; + time_t lastPeakTime; bool producerBlocked; char dbname[MAX_DBNAME_LEN]; char* queue; @@ -30,10 +34,12 @@ typedef BgwPool*(*BgwPoolConstructor)(void); extern void BgwPoolStart(int nWorkers, BgwPoolConstructor constructor); -extern void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, size_t queueSize); +extern void BgwPoolInit(BgwPool* pool, BgwPoolExecutor executor, char const* dbname, size_t queueSize, size_t nWorkers); extern void BgwPoolExecute(BgwPool* pool, void* work, size_t size); extern size_t BgwPoolGetQueueSize(BgwPool* pool); +extern timestamp_t BgwGetLastPeekTime(BgwPool* pool); + #endif diff --git a/multimaster.c b/multimaster.c index f0ae4296b2..2c7f9873cb 100644 --- a/multimaster.c +++ b/multimaster.c @@ -255,13 +255,18 @@ void MtmUnlockNode(int nodeId) */ -timestamp_t MtmGetCurrentTime(void) +timestamp_t MtmGetSystemTime(void) { struct timeval tv; gettimeofday(&tv, NULL); return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + Mtm->timeShift; } +timestamp_t MtmGetCurrentTime(void) +{ + return MtmGetSystemTime() + Mtm->timeShift; +} + void MtmSleep(timestamp_t interval) { struct timespec ts; @@ -1045,7 +1050,7 @@ void MtmRecoveryCompleted(void) MtmLock(LW_EXCLUSIVE); Mtm->recoverySlot = 0; BIT_CLEAR(Mtm->disabledNodeMask, MtmNodeId-1); - Mtm->nodes[MtmNodeId-1].lastStatusChangeTime = time(NULL); + Mtm->nodes[MtmNodeId-1].lastStatusChangeTime = MtmGetSystemTime(); /* Mode will be changed to online once all locagical reciever are connected */ MtmSwitchClusterMode(MTM_CONNECTED); MtmUnlock(); @@ -1134,7 +1139,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) /* We are lucky: caugth-up without locking cluster! */ } BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); - Mtm->nodes[nodeId-1].lastStatusChangeTime = time(NULL); + Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); Mtm->nNodes += 1; caughtUp = true; } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) @@ -1279,7 +1284,7 @@ bool MtmRefreshClusterStatus(bool nowait) if (mask & 1) { Mtm->nNodes -= 1; BIT_SET(Mtm->disabledNodeMask, i); - Mtm->nodes[i].lastStatusChangeTime = time(NULL); + Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); } } mask = clique & Mtm->disabledNodeMask; /* new enabled nodes mask */ @@ -1287,7 +1292,7 @@ bool MtmRefreshClusterStatus(bool nowait) if (mask & 1) { Mtm->nNodes += 1; BIT_CLEAR(Mtm->disabledNodeMask, i); - Mtm->nodes[i].lastStatusChangeTime = time(NULL); + Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); } } MtmCheckQuorum(); @@ -1327,7 +1332,7 @@ void MtmOnNodeDisconnect(int nodeId) { MtmTransState *ts; - if (Mtm->nodes[nodeId-1].lastStatusChangeTime + MtmNodeDisableDelay > time(NULL)) { + if (Mtm->nodes[nodeId-1].lastStatusChangeTime + MSEC_TO_USEC(MtmNodeDisableDelay) > MtmGetSystemTime()) { /* Avoid false detection of node failure and prevent node status blinking */ return; } @@ -1342,7 +1347,7 @@ void MtmOnNodeDisconnect(int nodeId) if (!MtmRefreshClusterStatus(false)) { MtmLock(LW_EXCLUSIVE); if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { - Mtm->nodes[nodeId-1].lastStatusChangeTime = time(NULL); + Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_SET(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes -= 1; MtmCheckQuorum(); @@ -1510,14 +1515,14 @@ static void MtmInitialize() for (i = 0; i < MtmNodes; i++) { Mtm->nodes[i].oldestSnapshot = 0; Mtm->nodes[i].transDelay = 0; - Mtm->nodes[i].lastStatusChangeTime = time(NULL); + Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); Mtm->nodes[i].con = MtmConnections[i]; Mtm->nodes[i].flushPos = 0; } PGSemaphoreCreate(&Mtm->votingSemaphore); PGSemaphoreReset(&Mtm->votingSemaphore); SpinLockInit(&Mtm->spinlock); - BgwPoolInit(&Mtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize); + BgwPoolInit(&Mtm->pool, MtmExecutor, MtmDatabaseName, MtmQueueSize, MtmWorkers); RegisterXactCallback(MtmXactCallback, NULL); MtmTx.snapshot = INVALID_CSN; MtmTx.xid = InvalidTransactionId; @@ -1681,10 +1686,10 @@ _PG_init(void) DefineCustomIntVariable( "multimaster.node_disable_delay", - "Minamal amount of time (sec) between node status change", + "Minamal amount of time (msec) between node status change", "This delay is used to avoid false detection of node failure and to prevent blinking of node status node", &MtmNodeDisableDelay, - 1, + 1000, 1, INT_MAX, PGC_BACKEND, @@ -2032,7 +2037,7 @@ void MtmDropNode(int nodeId, bool dropSlot) { elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nNodes); } - Mtm->nodes[nodeId-1].lastStatusChangeTime = time(NULL); + Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_SET(Mtm->disabledNodeMask, nodeId-1); Mtm->nNodes -= 1; MtmCheckQuorum(); @@ -2083,7 +2088,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) if (MtmIsRecoverySession) { MTM_LOG1("%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { - Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = time(NULL); + Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes -= 1; MtmCheckQuorum(); @@ -2091,7 +2096,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { if (recoveryCompleted) { MTM_LOG1("Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); - Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = time(NULL); + Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); Mtm->nNodes += 1; MtmCheckQuorum(); @@ -2238,7 +2243,7 @@ mtm_poll_node(PG_FUNCTION_ARGS) } if (!nowait) { /* Just wait some time until logical repication channels will be reestablished */ - MtmSleep(MtmNodeDisableDelay); + MtmSleep(MSEC_TO_USEC(MtmNodeDisableDelay)); } PG_RETURN_BOOL(online); } @@ -2297,7 +2302,7 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->values[4] = Int64GetDatum(lag); usrfctx->nulls[4] = lag < 0; usrfctx->values[5] = Int64GetDatum(Mtm->transCount ? Mtm->nodes[usrfctx->nodeId-1].transDelay/Mtm->transCount : 0); - usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime)); + usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime/USEC)); usrfctx->values[7] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); usrfctx->nodeId += 1; @@ -3058,6 +3063,18 @@ MtmDetectGlobalDeadLock(PGPROC* proc) MtmGetGtid(pgxact->xid, >id); hasDeadlock = MtmGraphFindLoop(&graph, >id); elog(WARNING, "Distributed deadlock check for %u:%u = %d", gtid.node, gtid.xid, hasDeadlock); + if (!hasDeadlock) { + /* There is no deadlock loop in graph, but deadlock can be caused by lack of apply workers: if all of them are busy, then some transactions + * can not be appied just because there are no vacant workers and it cause additional dependency between transactions which is not + * refelected in lock graph + */ + timestamp_t lastPeekTime = BgwGetLastPeekTime(&Mtm->pool); + if (lastPeekTime != 0 && MtmGetSystemTime() - lastPeekTime >= MSEC_TO_USEC(DeadlockTimeout)) { + hasDeadlock = true; + elog(WARNING, "Apply workers were blocked more than %d msec", + (int)USEC_TO_MSEC(MtmGetSystemTime() - lastPeekTime)); + } + } } return hasDeadlock; } diff --git a/multimaster.h b/multimaster.h index a2ddaefe9d..efe4bb3e32 100644 --- a/multimaster.h +++ b/multimaster.h @@ -48,6 +48,9 @@ #define USEC 1000000 +#define USEC_TO_MSEC(t) ((t)/1000) +#define MSEC_TO_USEC(t) ((t)*1000) + #define Natts_mtm_ddl_log 2 #define Anum_mtm_ddl_log_issued 1 #define Anum_mtm_ddl_log_query 2 @@ -72,8 +75,6 @@ typedef uint64 csn_t; /* commit serial number */ #define PGLOGICAL_CAUGHT_UP 0x04 -typedef uint64 timestamp_t; - /* Identifier of global transaction */ typedef struct { @@ -122,9 +123,9 @@ typedef struct typedef struct { MtmConnectionInfo con; - time_t transDelay; - time_t lastStatusChangeTime; - XLogRecPtr flushPos; + timestamp_t transDelay; + timestamp_t lastStatusChangeTime; + XLogRecPtr flushPos; csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ } MtmNodeInfo; @@ -232,8 +233,9 @@ extern void MtmRecoverNode(int nodeId); extern void MtmOnNodeDisconnect(int nodeId); extern void MtmOnNodeConnect(int nodeId); extern void MtmWakeUpBackend(MtmTransState* ts); -extern timestamp_t MtmGetCurrentTime(void); -extern void MtmSleep(timestamp_t interval); +extern timestamp_t MtmGetSystemTime(void); /* non-adjusted current system time */ +extern timestamp_t MtmGetCurrentTime(void); /* adjusted current system time */ +extern void MtmSleep(timestamp_t interval); extern void MtmAbortTransaction(MtmTransState* ts); extern void MtmSetCurrentTransactionGID(char const* gid); extern csn_t MtmGetTransactionCSN(TransactionId xid); From 904e5be5d72707d97f2804a6da93883d583ab253 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 20 Apr 2016 18:15:00 +0300 Subject: [PATCH 0417/1139] Move Stresseaux to a separate file. --- testeaux/Stresseaux.pm | 42 ++++++++++++++++++++++++++++++++++++++++++ testeaux/Testeaux.pm | 27 ++++++--------------------- 2 files changed, 48 insertions(+), 21 deletions(-) create mode 100644 testeaux/Stresseaux.pm diff --git a/testeaux/Stresseaux.pm b/testeaux/Stresseaux.pm new file mode 100644 index 0000000000..7b40a519b2 --- /dev/null +++ b/testeaux/Stresseaux.pm @@ -0,0 +1,42 @@ +package Stresseaux; + +my %running = (); + +sub start +{ + my ($id, $workload, $cluster) = @_; + print("start stress $id: workload $workload, cluster $cluster\n"); + + if (exists $running{$id}) + { + print("cannot start stress $id: that id has already been taken\n"); + return 0; + } + + # FIXME: implement 'stress'/'workload' objects + $running{$id} = {hello => 'world'}; + + # FIXME: implement + + return 1; +} + +sub stop +{ + my $id = shift; + print("stop stress $id\n"); + + my $stress = delete $running{$id}; + + if (!defined $stress) + { + print("cannot stop stress $id: that id is not running\n"); + return 0; + } + + # FIXME: implement + + return 1; +} + +1; diff --git a/testeaux/Testeaux.pm b/testeaux/Testeaux.pm index 792d9cdc92..01be62125d 100644 --- a/testeaux/Testeaux.pm +++ b/testeaux/Testeaux.pm @@ -1,5 +1,7 @@ package Testeaux; +use Stresseaux; + package Combineaux { sub combine @@ -12,13 +14,13 @@ package Combineaux { foreach my $trouble (@$troubles) { - print("run workload $workload during trouble $trouble\n"); - # FIXME: generate proper id instead of 'hello' - Stresseaux::start('hello', $workload, $cluster); + print("--- $workload vs. $trouble ---\n"); + my $id = "$workload+$trouble"; + Stresseaux::start($id, $workload, $cluster) || die "stress wouldn't start"; sleep(1); # FIXME: will this work? Troubleaux::cause($cluster, $trouble); sleep(1); # FIXME: will this work? - Stresseaux::stop('hello'); + Stresseaux::stop($id) || die "stress wouldn't stop"; Troubleaux::fix($cluster); } } @@ -27,23 +29,6 @@ package Combineaux } } -package Stresseaux -{ - sub start - { - my ($id, $workload, $cluster) = @_; - print("start stress $id: workload $workload, cluster $cluster\n"); - # fixme: implement - } - - sub stop - { - my $id = shift; - print("stop stress $id\n"); - # FIXME: implement - } -} - package Starteaux { sub deploy From dfe876dfbf72beddc0715fae70b8d8b2c762ea99 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Wed, 20 Apr 2016 18:18:56 +0300 Subject: [PATCH 0418/1139] Move the builtin lists of workloads and troubles from anonymous array refs into arrays. --- testeaux/eaux.pl | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/testeaux/eaux.pl b/testeaux/eaux.pl index cef723d4eb..babfbb3ddf 100755 --- a/testeaux/eaux.pl +++ b/testeaux/eaux.pl @@ -2,7 +2,13 @@ use Testeaux; -Combineaux::combine( - ['bank-transfers', 'pgbench-default'], - ['split-brain', 'time-shift'], -) +my @workloads = qw( + bank-transfers + pgbench-default +); +my @troubles = qw( + split-brain + time-shift +); + +Combineaux::combine(\@workloads, \@troubles); From 438f77dd2ed3e4716d54df81f38bd859931d2c0a Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Thu, 21 Apr 2016 16:48:21 +0300 Subject: [PATCH 0419/1139] Split Testeaux into multiple files. Implement stub stresses and troubles as plugins. --- testeaux/Combineaux.pm | 31 +++++++++++ testeaux/Starteaux.pm | 47 ++++++++++++++++ testeaux/Stresseaux.pm | 14 ++--- testeaux/Testeaux.pm | 96 --------------------------------- testeaux/Troubleaux.pm | 27 ++++++++++ testeaux/eaux.pl | 45 +++++++++++----- testeaux/stress/banktransfer.pm | 17 ++++++ testeaux/stress/pgbench.pm | 17 ++++++ testeaux/trouble/splitbrain.pm | 17 ++++++ testeaux/trouble/timeshift.pm | 17 ++++++ 10 files changed, 211 insertions(+), 117 deletions(-) create mode 100644 testeaux/Combineaux.pm create mode 100644 testeaux/Starteaux.pm delete mode 100644 testeaux/Testeaux.pm create mode 100644 testeaux/Troubleaux.pm create mode 100644 testeaux/stress/banktransfer.pm create mode 100644 testeaux/stress/pgbench.pm create mode 100644 testeaux/trouble/splitbrain.pm create mode 100644 testeaux/trouble/timeshift.pm diff --git a/testeaux/Combineaux.pm b/testeaux/Combineaux.pm new file mode 100644 index 0000000000..8a0f1141e4 --- /dev/null +++ b/testeaux/Combineaux.pm @@ -0,0 +1,31 @@ +package Combineaux; + +use Troubleaux; +use Stresseaux; +use Starteaux; + +sub combine +{ + my ($stresses, $troubles) = @_; + + my $cluster = Starteaux->deploy('lxc'); + + foreach my $stress (@$stresses) + { + foreach my $trouble (@$troubles) + { + print("--- $stress vs. $trouble ---\n"); + my $id = "$stress+$trouble"; + Stresseaux::start($id, $stress, $cluster) || die "stress wouldn't start"; + sleep(1); # FIXME: will this work? + Troubleaux::cause($cluster, $trouble); + sleep(1); # FIXME: will this work? + Stresseaux::stop($id) || die "stress wouldn't stop"; + Troubleaux::fix($cluster); + } + } + + $cluster->destroy(); +} + +1; diff --git a/testeaux/Starteaux.pm b/testeaux/Starteaux.pm new file mode 100644 index 0000000000..072f1c27bc --- /dev/null +++ b/testeaux/Starteaux.pm @@ -0,0 +1,47 @@ +package Starteaux; + +sub deploy +{ + my ($class, $driver, @args) = @_; + my $self = {}; + print("deploy cluster using driver $driver\n"); + # fixme: implement + return bless $self, 'Starteaux'; +} + +sub up +{ + my ($self, $id) = @_; + print("up node $id\n"); + # FIXME: implement +} + +sub down +{ + my ($self, $id) = @_; + print("down node $id\n"); + # FIXME: implement +} + +sub drop +{ + my ($self, $src, $dst, $ratio) = @_; + print("drop $ratio packets from $src to $dst\n"); + # FIXME: implement +} + +sub delay +{ + my ($self, $src, $dst, $msec) = @_; + print("delay packets from $src to $dst by $msec msec\n"); + # FIXME: implement +} + +sub destroy +{ + my ($self) = @_; + print("destroy cluster $cluster\n"); + # FIXME: implement +} + +1; diff --git a/testeaux/Stresseaux.pm b/testeaux/Stresseaux.pm index 7b40a519b2..763eb9f460 100644 --- a/testeaux/Stresseaux.pm +++ b/testeaux/Stresseaux.pm @@ -4,19 +4,16 @@ my %running = (); sub start { - my ($id, $workload, $cluster) = @_; - print("start stress $id: workload $workload, cluster $cluster\n"); + my ($id, $stressname, $cluster, @args) = @_; if (exists $running{$id}) { - print("cannot start stress $id: that id has already been taken\n"); + print("cannot start stress $stressname as $id: that id has already been taken\n"); return 0; } - # FIXME: implement 'stress'/'workload' objects - $running{$id} = {hello => 'world'}; - - # FIXME: implement + require "stress/$stressname.pm"; + $running{$id} = "stress::$stressname"->start($id, $cluster, @args); return 1; } @@ -24,7 +21,6 @@ sub start sub stop { my $id = shift; - print("stop stress $id\n"); my $stress = delete $running{$id}; @@ -34,7 +30,7 @@ sub stop return 0; } - # FIXME: implement + $stress->stop(); return 1; } diff --git a/testeaux/Testeaux.pm b/testeaux/Testeaux.pm deleted file mode 100644 index 01be62125d..0000000000 --- a/testeaux/Testeaux.pm +++ /dev/null @@ -1,96 +0,0 @@ -package Testeaux; - -use Stresseaux; - -package Combineaux -{ - sub combine - { - my ($workloads, $troubles) = @_; - - my $cluster = Starteaux->deploy('lxc'); - - foreach my $workload (@$workloads) - { - foreach my $trouble (@$troubles) - { - print("--- $workload vs. $trouble ---\n"); - my $id = "$workload+$trouble"; - Stresseaux::start($id, $workload, $cluster) || die "stress wouldn't start"; - sleep(1); # FIXME: will this work? - Troubleaux::cause($cluster, $trouble); - sleep(1); # FIXME: will this work? - Stresseaux::stop($id) || die "stress wouldn't stop"; - Troubleaux::fix($cluster); - } - } - - $cluster->destroy(); - } -} - -package Starteaux -{ - sub deploy - { - my ($class, $driver, @args) = @_; - my $self = {}; - print("deploy cluster using driver $driver\n"); - # fixme: implement - return bless $self, 'Starteaux'; - } - - sub up - { - my ($self, $id) = @_; - print("up node $id\n"); - # FIXME: implement - } - - sub down - { - my ($self, $id) = @_; - print("down node $id\n"); - # FIXME: implement - } - - sub drop - { - my ($self, $src, $dst, $ratio) = @_; - print("drop $ratio packets from $src to $dst\n"); - # FIXME: implement - } - - sub delay - { - my ($self, $src, $dst, $msec) = @_; - print("delay packets from $src to $dst by $msec msec\n"); - # FIXME: implement - } - - sub destroy - { - my ($self) = @_; - print("destroy cluster $cluster\n"); - # FIXME: implement - } -} - -package Troubleaux -{ - sub cause - { - my ($cluster, $trouble) = @_; - print("cause $trouble in cluster $cluster\n"); - # fixme: implement - } - - sub fix - { - my ($cluster) = @_; - print("fix cluster $cluster\n"); - # fixme: implement - } -} - -1; diff --git a/testeaux/Troubleaux.pm b/testeaux/Troubleaux.pm new file mode 100644 index 0000000000..3583030545 --- /dev/null +++ b/testeaux/Troubleaux.pm @@ -0,0 +1,27 @@ +my @caused = (); + +package Troubleaux +{ + sub cause + { + my $cluster = shift; + my $troublename = shift; + my @args = @_; + + require "trouble/$troublename.pm"; + push @caused, "trouble::$troublename"->cause(@args); + } + + sub fix + { + my ($cluster) = @_; + + while (@caused) + { + my $trouble = pop @caused; + $trouble->fix(); + } + } +} + +1; diff --git a/testeaux/eaux.pl b/testeaux/eaux.pl index babfbb3ddf..24c4b3e5ff 100755 --- a/testeaux/eaux.pl +++ b/testeaux/eaux.pl @@ -1,14 +1,35 @@ #!/usr/bin/perl -use Testeaux; - -my @workloads = qw( - bank-transfers - pgbench-default -); -my @troubles = qw( - split-brain - time-shift -); - -Combineaux::combine(\@workloads, \@troubles); +use Combineaux; + +sub list_modules +{ + my $dir = shift; + my @modules = (); + + opendir DIR, $dir or die "Cannot open directory: $!"; + + while (my $file = readdir(DIR)) { + # Use a regular expression to ignore files beginning with a period + next unless ($file =~ m/\.pm$/); + push @modules, substr($file, 0, -3); + } + + closedir DIR; + + return @modules; +} + +#my @workloads = qw( +# banktransfer +# pgbench +#); +#my @troubles = qw( +# splitbrain +# timeshift +#); + +my @stresses = list_modules('stress'); +my @troubles = list_modules('trouble'); + +Combineaux::combine(\@stresses, \@troubles); diff --git a/testeaux/stress/banktransfer.pm b/testeaux/stress/banktransfer.pm new file mode 100644 index 0000000000..f6c2f1a78e --- /dev/null +++ b/testeaux/stress/banktransfer.pm @@ -0,0 +1,17 @@ +package stress::banktransfer; + +sub start +{ + my ($class, @args) = @_; + my $self = {}; + print("start $class with args " . join(',', @args) . "\n"); + return bless $self, $class; +} + +sub stop +{ + my $self = shift; + print("stop $self\n"); +} + +1; diff --git a/testeaux/stress/pgbench.pm b/testeaux/stress/pgbench.pm new file mode 100644 index 0000000000..0cdf723def --- /dev/null +++ b/testeaux/stress/pgbench.pm @@ -0,0 +1,17 @@ +package stress::pgbench; + +sub start +{ + my ($class, @args) = @_; + my $self = {}; + print("start $class with args " . join(',', @args) . "\n"); + return bless $self, $class; +} + +sub stop +{ + my $self = shift; + print("stop $self\n"); +} + +1; diff --git a/testeaux/trouble/splitbrain.pm b/testeaux/trouble/splitbrain.pm new file mode 100644 index 0000000000..88cb16b346 --- /dev/null +++ b/testeaux/trouble/splitbrain.pm @@ -0,0 +1,17 @@ +package trouble::splitbrain; + +sub cause +{ + my ($class, @args) = @_; + my $self = {}; + print("cause $class with args " . join(',', @args) . "\n"); + return bless $self, $class; +} + +sub fix +{ + my $self = shift; + print("fix $self\n"); +} + +1; diff --git a/testeaux/trouble/timeshift.pm b/testeaux/trouble/timeshift.pm new file mode 100644 index 0000000000..f7239c0e45 --- /dev/null +++ b/testeaux/trouble/timeshift.pm @@ -0,0 +1,17 @@ +package trouble::timeshift; + +sub cause +{ + my $class = shift; + my $self = {}; + print("cause $class with args " . join(',', @args) . "\n"); + return bless $self, $class; +} + +sub fix +{ + my $self = shift; + print("fix $self\n"); +} + +1; From b8f9bb79bfe4db2c69e76731fb9c54fb8b2b6ffe Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Fri, 22 Apr 2016 14:44:17 +0300 Subject: [PATCH 0420/1139] Remove unused commented code from eaux.pl. --- testeaux/eaux.pl | 9 --------- 1 file changed, 9 deletions(-) diff --git a/testeaux/eaux.pl b/testeaux/eaux.pl index 24c4b3e5ff..338594fcc0 100755 --- a/testeaux/eaux.pl +++ b/testeaux/eaux.pl @@ -20,15 +20,6 @@ sub list_modules return @modules; } -#my @workloads = qw( -# banktransfer -# pgbench -#); -#my @troubles = qw( -# splitbrain -# timeshift -#); - my @stresses = list_modules('stress'); my @troubles = list_modules('trouble'); From 629f58bf50753297d540cdbd92398f8cf4268fff Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 22 Apr 2016 16:55:02 +0300 Subject: [PATCH 0421/1139] Make it possible to add nodes to the cluster --- arbiter.c | 41 ++++++------ bgwpool.h | 3 + multimaster--1.0.sql | 6 +- multimaster.c | 151 +++++++++++++++++++++++++++++-------------- multimaster.h | 15 ++--- pglogical_receiver.c | 83 ++++++++++++------------ 6 files changed, 179 insertions(+), 120 deletions(-) diff --git a/arbiter.c b/arbiter.c index 0a69474225..77a9ebb208 100644 --- a/arbiter.c +++ b/arbiter.c @@ -369,13 +369,13 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) static void MtmOpenConnections() { - int nNodes = MtmNodes; + int nNodes = MtmMaxNodes; int i; sockets = (int*)palloc(sizeof(int)*nNodes); for (i = 0; i < nNodes; i++) { - if (i+1 != MtmNodeId) { + if (i+1 != MtmNodeId && i < Mtm->nAllNodes) { sockets[i] = MtmConnectSocket(Mtm->nodes[i].con.hostName, MtmArbiterPort + i + 1, MtmConnectAttempts); if (sockets[i] < 0) { MtmOnNodeDisconnect(i+1); @@ -384,8 +384,8 @@ static void MtmOpenConnections() sockets[i] = -1; } } - if (Mtm->nNodes < MtmNodes/2+1) { /* no quorum */ - elog(WARNING, "Node is out of quorum: only %d nodes from %d are accssible", Mtm->nNodes, MtmNodes); + if (Mtm->nLiveNodes < Mtm->nAllNodes/2+1) { /* no quorum */ + elog(WARNING, "Node is out of quorum: only %d nodes of %d are accessible", Mtm->nLiveNodes, Mtm->nAllNodes); MtmSwitchClusterMode(MTM_IN_MINORITY); } else if (Mtm->status == MTM_INITIALIZATION) { MtmSwitchClusterMode(MTM_CONNECTED); @@ -444,7 +444,7 @@ static void MtmAcceptOneConnection() elog(WARNING, "Arbiter get unexpected handshake message %d", req.hdr.code); close(fd); } else{ - Assert(req.hdr.node > 0 && req.hdr.node <= MtmNodes && req.hdr.node != MtmNodeId); + Assert(req.hdr.node > 0 && req.hdr.node <= Mtm->nAllNodes && req.hdr.node != MtmNodeId); resp.code = MSG_STATUS; resp.disabledNodeMask = Mtm->disabledNodeMask; resp.dxid = HANDSHAKE_MAGIC; @@ -472,9 +472,10 @@ static void MtmAcceptIncomingConnections() struct sockaddr_in sock_inet; int on = 1; int i; + int nNodes = MtmMaxNodes; - sockets = (int*)palloc(sizeof(int)*MtmNodes); - for (i = 0; i < MtmNodes; i++) { + sockets = (int*)palloc(sizeof(int)*nNodes); + for (i = 0; i < nNodes; i++) { sockets[i] = -1; } sock_inet.sin_family = AF_INET; @@ -490,7 +491,7 @@ static void MtmAcceptIncomingConnections() if (bind(gateway, (struct sockaddr*)&sock_inet, sizeof(sock_inet)) < 0) { elog(ERROR, "Arbiter failed to bind socket: %d", errno); } - if (listen(gateway, MtmNodes) < 0) { + if (listen(gateway, nNodes) < 0) { elog(ERROR, "Arbiter failed to listen socket: %d", errno); } @@ -527,7 +528,7 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) { int i; int n = 1; - for (i = 0; i < MtmNodes; i++) + for (i = 0; i < Mtm->nAllNodes; i++) { if (!BIT_CHECK(Mtm->disabledNodeMask, i) && TransactionIdIsValid(ts->xids[i])) { Assert(i+1 != MtmNodeId); @@ -535,14 +536,14 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) n += 1; } } - Assert(n == Mtm->nNodes); + Assert(n == Mtm->nLiveNodes); } static void MtmTransSender(Datum arg) { sigset_t sset; - int nNodes = MtmNodes; + int nNodes = MtmMaxNodes; int i; MtmBuffer* txBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); @@ -580,7 +581,7 @@ static void MtmTransSender(Datum arg) MtmUnlock(); - for (i = 0; i < nNodes; i++) { + for (i = 0; i < Mtm->nAllNodes; i++) { if (txBuffer[i].used != 0) { MtmSendToNode(i, txBuffer[i].data, txBuffer[i].used*sizeof(MtmArbiterMessage)); txBuffer[i].used = 0; @@ -593,7 +594,7 @@ static void MtmTransSender(Datum arg) #if !USE_EPOLL static bool MtmRecovery() { - int nNodes = MtmNodes; + int nNodes = Mtm->nAllNodes; bool recovered = false; int i; @@ -618,7 +619,7 @@ static bool MtmRecovery() static void MtmTransReceiver(Datum arg) { sigset_t sset; - int nNodes = MtmNodes; + int nNodes = MtmMaxNodes; int nResponses; int i, j, n, rc; MtmBuffer* rxBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); @@ -708,7 +709,7 @@ static void MtmTransReceiver(Datum arg) if (MtmIsCoordinator(ts)) { switch (msg->code) { case MSG_READY: - Assert(ts->nVotes < Mtm->nNodes); + Assert(ts->nVotes < Mtm->nLiveNodes); Mtm->nodes[msg->node-1].transDelay += MtmGetCurrentTime() - ts->csn; ts->xids[msg->node-1] = msg->sxid; @@ -720,7 +721,7 @@ static void MtmTransReceiver(Datum arg) MtmAbortTransaction(ts); } - if (++ts->nVotes == Mtm->nNodes) { + if (++ts->nVotes == Mtm->nLiveNodes) { /* All nodes are finished their transactions */ if (ts->status == TRANSACTION_STATUS_ABORTED) { MtmWakeUpBackend(ts); @@ -736,23 +737,23 @@ static void MtmTransReceiver(Datum arg) } break; case MSG_ABORTED: - Assert(ts->nVotes < Mtm->nNodes); + Assert(ts->nVotes < Mtm->nLiveNodes); if (ts->status != TRANSACTION_STATUS_ABORTED) { Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); MtmAbortTransaction(ts); } - if (++ts->nVotes == Mtm->nNodes) { + if (++ts->nVotes == Mtm->nLiveNodes) { MtmWakeUpBackend(ts); } break; case MSG_PREPARED: Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < Mtm->nNodes); + Assert(ts->nVotes < Mtm->nLiveNodes); if (msg->csn > ts->csn) { ts->csn = msg->csn; MtmSyncClock(ts->csn); } - if (++ts->nVotes == Mtm->nNodes) { + if (++ts->nVotes == Mtm->nLiveNodes) { ts->csn = MtmAssignCSN(); ts->status = TRANSACTION_STATUS_UNKNOWN; MtmWakeUpBackend(ts); diff --git a/bgwpool.h b/bgwpool.h index f2a700ab4e..9bb99f5070 100644 --- a/bgwpool.h +++ b/bgwpool.h @@ -12,6 +12,9 @@ typedef uint64 timestamp_t; #define MAX_DBNAME_LEN 30 #define MULTIMASTER_BGW_RESTART_TIMEOUT 1 /* seconds */ +extern timestamp_t MtmGetSystemTime(void); /* non-adjusted current system time */ +extern timestamp_t MtmGetCurrentTime(void); /* adjusted current system time */ + typedef struct { BgwPoolExecutor executor; diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index bc5b95d213..d70857450e 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -13,6 +13,10 @@ CREATE FUNCTION mtm.drop_node(node integer, drop_slot bool default false) RETURN AS 'MODULE_PATHNAME','mtm_drop_node' LANGUAGE C; +CREATE FUNCTION mtm.add_node(conn_str cstring) RETURNS void +AS 'MODULE_PATHNAME','mtm_add_node' +LANGUAGE C; + -- Create replication slot for the node which was previously dropped together with it's slot CREATE FUNCTION mtm.recover_node(node integer) RETURNS void AS 'MODULE_PATHNAME','mtm_recover_node' @@ -30,7 +34,7 @@ CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state AS 'MODULE_PATHNAME','mtm_get_nodes_state' LANGUAGE C; -CREATE TYPE mtm.cluster_state AS ("status" text, "disabledNodeMask" bigint, "disconnectedNodeMask" bigint, "catchUpNodeMask" bigint, "nNodes" integer, "nActiveQueries" integer, "nPendingQueries" integer, "queueSize" bigint, "transCount" bigint, "timeShift" bigint, "recoverySlot" integer); +CREATE TYPE mtm.cluster_state AS ("status" text, "disabledNodeMask" bigint, "disconnectedNodeMask" bigint, "catchUpNodeMask" bigint, "liveNodes" integer, "allNodes" integer, "nActiveQueries" integer, "nPendingQueries" integer, "queueSize" bigint, "transCount" bigint, "timeShift" bigint, "recoverySlot" integer); CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state AS 'MODULE_PATHNAME','mtm_get_cluster_state' diff --git a/multimaster.c b/multimaster.c index 2c7f9873cb..9570c3c7a5 100644 --- a/multimaster.c +++ b/multimaster.c @@ -102,6 +102,7 @@ PG_MODULE_MAGIC; PG_FUNCTION_INFO_V1(mtm_start_replication); PG_FUNCTION_INFO_V1(mtm_stop_replication); PG_FUNCTION_INFO_V1(mtm_drop_node); +PG_FUNCTION_INFO_V1(mtm_add_node); PG_FUNCTION_INFO_V1(mtm_poll_node); PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); @@ -143,6 +144,7 @@ static HTAB* MtmGid2State; static HTAB* MtmLocalTables; static bool MtmIsRecoverySession; +static MtmConnectionInfo* MtmConnections; static MtmCurrentTrans MtmTx; @@ -175,19 +177,19 @@ char const* const MtmNodeStatusMnem[] = bool MtmDoReplication; char* MtmDatabaseName; +int MtmNodes; int MtmNodeId; int MtmReplicationNodeId; int MtmArbiterPort; -int MtmNodes; int MtmConnectAttempts; int MtmConnectTimeout; int MtmKeepaliveTimeout; int MtmReconnectAttempts; int MtmNodeDisableDelay; int MtmTransSpillThreshold; +int MtmMaxNodes; bool MtmUseRaftable; bool MtmUseDtm; -MtmConnectionInfo* MtmConnections; static char* MtmConnStrs; static int MtmQueueSize; @@ -238,13 +240,13 @@ void MtmUnlock(void) void MtmLockNode(int nodeId) { - Assert(nodeId > 0 && nodeId <= MtmNodes); + Assert(nodeId > 0 && nodeId <= Mtm->nAllNodes); LWLockAcquire((LWLockId)&Mtm->locks[nodeId], LW_EXCLUSIVE); } void MtmUnlockNode(int nodeId) { - Assert(nodeId > 0 && nodeId <= MtmNodes); + Assert(nodeId > 0 && nodeId <= Mtm->nAllNodes); LWLockRelease((LWLockId)&Mtm->locks[nodeId]); } @@ -459,7 +461,7 @@ MtmAdjustOldestXid(TransactionId xid) } } Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; - for (i = 0; i < MtmNodes; i++) { + for (i = 0; i < Mtm->nAllNodes; i++) { if (!BIT_CHECK(Mtm->disabledNodeMask, i) && Mtm->nodes[i].oldestSnapshot < oldestSnapshot) { @@ -507,7 +509,7 @@ MtmAdjustOldestXid(TransactionId xid) if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { csn_t oldestSnapshot = ts->csn; Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; - for (i = 0; i < MtmNodes; i++) { + for (i = 0; i < Mtm->nAllNodes; i++) { if (!BIT_CHECK(Mtm->disabledNodeMask, i) && Mtm->nodes[i].oldestSnapshot < oldestSnapshot) { @@ -1140,7 +1142,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) } BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); - Mtm->nNodes += 1; + Mtm->nLiveNodes += 1; caughtUp = true; } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) && slotLSN + MtmMinRecoveryLag > walLSN) @@ -1219,7 +1221,7 @@ MtmCheckClusterLock() Assert(Mtm->walSenderLockerMask == 0); Assert((Mtm->nodeLockerMask & Mtm->disabledNodeMask) == Mtm->nodeLockerMask); Mtm->disabledNodeMask &= ~Mtm->nodeLockerMask; - Mtm->nNodes += Mtm->nLockers; + Mtm->nLiveNodes += Mtm->nLockers; Mtm->nLockers = 0; Mtm->nodeLockerMask = 0; MtmCheckQuorum(); @@ -1235,7 +1237,7 @@ MtmCheckClusterLock() static bool MtmBuildConnectivityMatrix(nodemask_t* matrix, bool nowait) { - int i, j, n = MtmNodes; + int i, j, n = Mtm->nAllNodes; for (i = 0; i < n; i++) { if (i+1 != MtmNodeId) { void* data = RaftableGet(psprintf("node-mask-%d", i+1), NULL, NULL, nowait); @@ -1275,14 +1277,14 @@ bool MtmRefreshClusterStatus(bool nowait) return false; } - clique = MtmFindMaxClique(matrix, MtmNodes, &clique_size); - if (clique_size >= MtmNodes/2+1) { /* have quorum */ + clique = MtmFindMaxClique(matrix, Mtm->nAllNodes, &clique_size); + if (clique_size >= Mtm->nAllNodes/2+1) { /* have quorum */ MTM_LOG1("Find clique %lx, disabledNodeMask %lx", (long) clique, (long) Mtm->disabledNodeMask); MtmLock(LW_EXCLUSIVE); - mask = ~clique & (((nodemask_t)1 << MtmNodes)-1) & ~Mtm->disabledNodeMask; /* new disabled nodes mask */ + mask = ~clique & (((nodemask_t)1 << Mtm->nAllNodes)-1) & ~Mtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { - Mtm->nNodes -= 1; + Mtm->nLiveNodes -= 1; BIT_SET(Mtm->disabledNodeMask, i); Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); } @@ -1290,7 +1292,7 @@ bool MtmRefreshClusterStatus(bool nowait) mask = clique & Mtm->disabledNodeMask; /* new enabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { - Mtm->nNodes += 1; + Mtm->nLiveNodes += 1; BIT_CLEAR(Mtm->disabledNodeMask, i); Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); } @@ -1315,7 +1317,7 @@ bool MtmRefreshClusterStatus(bool nowait) void MtmCheckQuorum(void) { - if (Mtm->nNodes < MtmNodes/2+1) { + if (Mtm->nLiveNodes < Mtm->nAllNodes/2+1) { if (Mtm->status == MTM_ONLINE) { /* out of quorum */ elog(WARNING, "Node is in minority: disabled mask %lx", (long) Mtm->disabledNodeMask); MtmSwitchClusterMode(MTM_IN_MINORITY); @@ -1349,7 +1351,7 @@ void MtmOnNodeDisconnect(int nodeId) if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_SET(Mtm->disabledNodeMask, nodeId-1); - Mtm->nNodes -= 1; + Mtm->nLiveNodes -= 1; MtmCheckQuorum(); /* Interrupt voting for active transaction and abort them */ for (ts = Mtm->transListHead; ts != NULL; ts = ts->next) { @@ -1387,10 +1389,10 @@ MtmCreateXidMap(void) { HASHCTL info; HTAB* htab; - Assert(MtmNodes > 0); + Assert(MtmMaxNodes > 0); memset(&info, 0, sizeof(info)); info.keysize = sizeof(TransactionId); - info.entrysize = sizeof(MtmTransState) + (MtmNodes-1)*sizeof(TransactionId); + info.entrysize = sizeof(MtmTransState) + (MtmMaxNodes-1)*sizeof(TransactionId); htab = ShmemInitHash( "MtmXid2State", MTM_HASH_SIZE, MTM_HASH_SIZE, @@ -1488,7 +1490,7 @@ static void MtmInitialize() int i; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); - Mtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState) + sizeof(MtmNodeInfo)*(MtmNodes-1), &found); + Mtm = (MtmState*)ShmemInitStruct(MULTIMASTER_NAME, sizeof(MtmState) + sizeof(MtmNodeInfo)*(MtmMaxNodes-1), &found); if (!found) { Mtm->status = MTM_INITIALIZATION; @@ -1496,7 +1498,8 @@ static void MtmInitialize() Mtm->locks = GetNamedLWLockTranche(MULTIMASTER_NAME); Mtm->csn = MtmGetCurrentTime(); Mtm->oldestXid = FirstNormalTransactionId; - Mtm->nNodes = MtmNodes; + Mtm->nLiveNodes = MtmNodes; + Mtm->nAllNodes = MtmNodes; Mtm->disabledNodeMask = 0; Mtm->connectivityMask = 0; Mtm->pglogicalNodeMask = 0; @@ -1591,8 +1594,13 @@ static void MtmSplitConnStrs(void) if (i < 2) { elog(ERROR, "Multimaster should have at least two nodes"); } + if (MtmMaxNodes == 0) { + MtmMaxNodes = i; + } else if (MtmMaxNodes < i) { + elog(ERROR, "More than %d nodes are specified", MtmMaxNodes); + } MtmNodes = i; - MtmConnections = (MtmConnectionInfo*)palloc(i*sizeof(MtmConnectionInfo)); + MtmConnections = (MtmConnectionInfo*)palloc(MtmMaxNodes*sizeof(MtmConnectionInfo)); connStr = copy; for (i = 0; connStr < connStrEnd; i++) { @@ -1637,6 +1645,20 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.max_nodes", + "Maximal number of cluster nodes", + "This parameters allows to add new nodes to the cluster, default value 0 restricts number of nodes to one specified in multimaster.conn_strings", + &MtmMaxNodes, + 0, + 0, + MAX_NODES, + PGC_POSTMASTER, + 0, + NULL, + NULL, + NULL + ); DefineCustomIntVariable( "multimaster.trans_spill_threshold", "Maximal size (Mb) of transaction after which transaction is written to the disk", @@ -1927,7 +1949,7 @@ _PG_init(void) * resources in mtm_shmem_startup(). */ RequestAddinShmemSpace(MTM_SHMEM_SIZE + MtmQueueSize); - RequestNamedLWLockTranche(MULTIMASTER_NAME, 1 + MtmNodes); + RequestNamedLWLockTranche(MULTIMASTER_NAME, 1 + MtmMaxNodes); BgwPoolStart(MtmWorkers, MtmPoolConstructor); @@ -1968,7 +1990,7 @@ void MtmReceiverStarted(int nodeId) MtmLock(LW_EXCLUSIVE); if (!BIT_CHECK(Mtm->pglogicalNodeMask, nodeId-1)) { BIT_SET(Mtm->pglogicalNodeMask, nodeId-1); - if (++Mtm->nReceivers == Mtm->nNodes-1) { + if (++Mtm->nReceivers == Mtm->nLiveNodes-1) { if (Mtm->status == MTM_CONNECTED) { MtmSwitchClusterMode(MTM_ONLINE); } @@ -2015,9 +2037,9 @@ static bool MtmIsBroadcast() void MtmRecoverNode(int nodeId) { - if (nodeId <= 0 || nodeId > Mtm->nNodes) + if (nodeId <= 0 || nodeId > Mtm->nLiveNodes) { - elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nNodes); + elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nLiveNodes); } if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { elog(ERROR, "Node %d was not disabled", nodeId); @@ -2033,13 +2055,13 @@ void MtmDropNode(int nodeId, bool dropSlot) { if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { - if (nodeId <= 0 || nodeId > Mtm->nNodes) + if (nodeId <= 0 || nodeId > Mtm->nLiveNodes) { - elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nNodes); + elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nLiveNodes); } Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_SET(Mtm->disabledNodeMask, nodeId-1); - Mtm->nNodes -= 1; + Mtm->nLiveNodes -= 1; MtmCheckQuorum(); if (!MtmIsBroadcast()) { @@ -2090,7 +2112,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); - Mtm->nNodes -= 1; + Mtm->nLiveNodes -= 1; MtmCheckQuorum(); } } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { @@ -2098,7 +2120,7 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) MTM_LOG1("Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = MtmGetSystemTime(); BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); - Mtm->nNodes += 1; + Mtm->nLiveNodes += 1; MtmCheckQuorum(); } else { elog(ERROR, "Disabled node %d tries to reconnect without recovery", MtmReplicationNodeId); @@ -2226,6 +2248,35 @@ mtm_drop_node(PG_FUNCTION_ARGS) MtmDropNode(nodeId, dropSlot); PG_RETURN_VOID(); } + +Datum +mtm_add_node(PG_FUNCTION_ARGS) +{ + char* connStr = PG_GETARG_CSTRING(0); + + if (Mtm->nAllNodes == MtmMaxNodes) { + elog(ERROR, "Maximal number of nodes %d is reached", MtmMaxNodes); + } + if (!MtmIsBroadcast()) + { + MtmBroadcastUtilityStmt(psprintf("select mtm.add_node('%s')", connStr), true); + } + else + { + int nodeId = Mtm->nAllNodes; + elog(NOTICE, "Add node %d: '%s'", nodeId+1, connStr); + MtmUpdateNodeConnectionInfo(&Mtm->nodes[nodeId].con, connStr); + Mtm->nodes[nodeId].transDelay = 0; + Mtm->nodes[nodeId].lastStatusChangeTime = MtmGetSystemTime(); + Mtm->nodes[nodeId].flushPos = 0; + Mtm->nodes[nodeId].oldestSnapshot = 0; + + BIT_SET(Mtm->disabledNodeMask, nodeId); + Mtm->nAllNodes += 1; + MtmStartReceiver(nodeId+1, true); + } + PG_RETURN_VOID(); +} Datum mtm_poll_node(PG_FUNCTION_ARGS) @@ -2291,7 +2342,7 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) } funcctx = SRF_PERCALL_SETUP(); usrfctx = (MtmGetNodeStateCtx*)funcctx->user_fctx; - if (usrfctx->nodeId > MtmNodes) { + if (usrfctx->nodeId > Mtm->nAllNodes) { SRF_RETURN_DONE(funcctx); } usrfctx->values[0] = Int32GetDatum(usrfctx->nodeId); @@ -2322,13 +2373,14 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) values[1] = Int64GetDatum(Mtm->disabledNodeMask); values[2] = Int64GetDatum(Mtm->connectivityMask); values[3] = Int64GetDatum(Mtm->nodeLockerMask); - values[4] = Int32GetDatum(Mtm->nNodes); - values[5] = Int32GetDatum((int)Mtm->pool.active); - values[6] = Int32GetDatum((int)Mtm->pool.pending); - values[7] = Int64GetDatum(BgwPoolGetQueueSize(&Mtm->pool)); - values[8] = Int64GetDatum(Mtm->transCount); - values[9] = Int64GetDatum(Mtm->timeShift); - values[10] = Int32GetDatum(Mtm->recoverySlot); + values[4] = Int32GetDatum(Mtm->nLiveNodes); + values[5] = Int32GetDatum(Mtm->nAllNodes); + values[6] = Int32GetDatum((int)Mtm->pool.active); + values[7] = Int32GetDatum((int)Mtm->pool.pending); + values[8] = Int64GetDatum(BgwPoolGetQueueSize(&Mtm->pool)); + values[9] = Int64GetDatum(Mtm->transCount); + values[10] = Int64GetDatum(Mtm->timeShift); + values[11] = Int32GetDatum(Mtm->recoverySlot); PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); } @@ -2367,7 +2419,7 @@ mtm_get_cluster_info(PG_FUNCTION_ARGS) } funcctx = SRF_PERCALL_SETUP(); usrfctx = (MtmGetClusterInfoCtx*)funcctx->user_fctx; - if (usrfctx->nodeId > MtmNodes) { + if (usrfctx->nodeId > Mtm->nAllNodes) { SRF_RETURN_DONE(funcctx); } conn = PQconnectdb(Mtm->nodes[usrfctx->nodeId-1].con.connStr); @@ -2439,7 +2491,7 @@ Datum mtm_dump_lock_graph(PG_FUNCTION_ARGS) { StringInfo s = makeStringInfo(); int i; - for (i = 0; i < MtmNodes; i++) + for (i = 0; i < Mtm->nAllNodes; i++) { size_t size; char *data = RaftableGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); @@ -2532,10 +2584,11 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) nodemask_t disabledNodeMask = Mtm->disabledNodeMask; int failedNode = -1; char const* errorMsg = NULL; - PGconn **conns = palloc0(sizeof(PGconn*)*MtmNodes); + PGconn **conns = palloc0(sizeof(PGconn*)*Mtm->nAllNodes); char* utility_errmsg; - - for (i = 0; i < MtmNodes; i++) + int nNodes = Mtm->nAllNodes; + + for (i = 0; i < nNodes; i++) { if (!BIT_CHECK(disabledNodeMask, i)) { @@ -2557,9 +2610,9 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) PQsetNoticeReceiver(conns[i], MtmNoticeReceiver, &i); } } - Assert(i == MtmNodes); + Assert(i == nNodes); - for (i = 0; i < MtmNodes; i++) + for (i = 0; i < nNodes; i++) { if (conns[i]) { @@ -2593,7 +2646,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) } if (failedNode >= 0 && !ignoreError) { - for (i = 0; i < MtmNodes; i++) + for (i = 0; i < nNodes; i++) { if (conns[i]) { @@ -2601,7 +2654,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) } } } else { - for (i = 0; i < MtmNodes; i++) + for (i = 0; i < nNodes; i++) { if (conns[i] && !MtmRunUtilityStmt(conns[i], "COMMIT TRANSACTION", &utility_errmsg) && !ignoreError) { @@ -2610,7 +2663,7 @@ static void MtmBroadcastUtilityStmt(char const* sql, bool ignoreError) } } } - for (i = 0; i < MtmNodes; i++) + for (i = 0; i < nNodes; i++) { if (conns[i]) { @@ -3049,7 +3102,7 @@ MtmDetectGlobalDeadLock(PGPROC* proc) MtmGraphInit(&graph); MtmGraphAdd(&graph, (GlobalTransactionId*)buf.data, buf.used/sizeof(GlobalTransactionId)); ByteBufferFree(&buf); - for (i = 0; i < MtmNodes; i++) { + for (i = 0; i < Mtm->nAllNodes; i++) { if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i)) { size_t size; void* data = RaftableGet(psprintf("lock-graph-%d", i+1), &size, NULL, true); diff --git a/multimaster.h b/multimaster.h index efe4bb3e32..8d7844bb00 100644 --- a/multimaster.h +++ b/multimaster.h @@ -59,7 +59,7 @@ #define Anum_mtm_local_tables_rel_schema 1 #define Anum_mtm_local_tables_rel_name 2 -#define Natts_mtm_cluster_state 11 +#define Natts_mtm_cluster_state 12 #define Natts_mtm_nodes_state 8 typedef uint64 csn_t; /* commit serial number */ @@ -145,7 +145,7 @@ typedef struct MtmTransState struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ bool votingCompleted; /* 2PC voting is completed */ - TransactionId xids[1]; /* [MtmNodes]: transaction ID at replicas */ + TransactionId xids[1]; /* [Mtm->nAllNodes]: transaction ID at replicas */ } MtmTransState; typedef struct @@ -164,7 +164,8 @@ typedef struct nodemask_t reconnectMask; /* Mask of nodes connection to which has to be reestablished by sender */ bool localTablesHashLoaded; /* Whether data from local_tables table is loaded in shared memory hash table */ - int nNodes; /* Number of active nodes */ + int nLiveNodes; /* Number of active nodes */ + int nAllNodes; /* Total numbber of nodes */ int nReceivers; /* Number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ int nLockers; /* Number of lockers */ int nActiveTransactions; /* Nunmber of active 2PC transactions */ @@ -178,7 +179,7 @@ typedef struct This list is expected to be in CSN ascending order, by strict order may be violated */ uint64 transCount; /* Counter of transactions perfromed by this node */ BgwPool pool; /* Pool of background workers for applying logical replication patches */ - MtmNodeInfo nodes[1]; /* [MtmNodes]: per-node data */ + MtmNodeInfo nodes[1]; /* [Mtm->nAllNodes]: per-node data */ } MtmState; typedef struct MtmFlushPosition @@ -197,6 +198,7 @@ extern char const* const MtmNodeStatusMnem[]; extern MtmState* Mtm; extern int MtmNodeId; +extern int MtmMaxNodes; extern int MtmReplicationNodeId; extern int MtmNodes; extern int MtmArbiterPort; @@ -210,10 +212,9 @@ extern int MtmTransSpillThreshold; extern bool MtmUseDtm; extern HTAB* MtmXid2State; -extern MtmConnectionInfo* MtmConnections; - extern void MtmArbiterInitialize(void); extern void MtmStartReceivers(void); +extern void MtmStartReceiver(int nodeId, bool dynamic); extern csn_t MtmTransactionSnapshot(TransactionId xid); extern csn_t MtmAssignCSN(void); extern csn_t MtmSyncClock(csn_t csn); @@ -233,8 +234,6 @@ extern void MtmRecoverNode(int nodeId); extern void MtmOnNodeDisconnect(int nodeId); extern void MtmOnNodeConnect(int nodeId); extern void MtmWakeUpBackend(MtmTransState* ts); -extern timestamp_t MtmGetSystemTime(void); /* non-adjusted current system time */ -extern timestamp_t MtmGetCurrentTime(void); /* adjusted current system time */ extern void MtmSleep(timestamp_t interval); extern void MtmAbortTransaction(MtmTransState* ts); extern void MtmSetCurrentTransactionGID(char const* gid); diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 7284489ece..47f22d4749 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -32,21 +32,13 @@ #include "storage/proc.h" #include "utils/guc.h" #include "utils/snapmgr.h" +#include "utils/memutils.h" #include "executor/spi.h" #include "replication/origin.h" #include "multimaster.h" #include "spill.h" -/* Allow load of this module in shared libs */ - -typedef struct ReceiverArgs { - int local_node; - int remote_node; - char* receiver_conn_string; - char receiver_slot[MULTIMASTER_MAX_SLOT_NAME_SIZE]; -} ReceiverArgs; - #define ERRCODE_DUPLICATE_OBJECT_STR "42710" /* Signal handling */ @@ -208,7 +200,7 @@ static char const* const MtmReplicationModeName[] = static void pglogical_receiver_main(Datum main_arg) { - ReceiverArgs* args = (ReceiverArgs*)main_arg; + int nodeId = DatumGetInt32(main_arg); /* Variables for replication connection */ PQExpBuffer query; PGconn *conn; @@ -223,6 +215,8 @@ pglogical_receiver_main(Datum main_arg) char *copybuf = NULL; int spill_file = -1; StringInfoData spill_info; + char* connString = psprintf("replication=database %s", Mtm->nodes[nodeId-1].con.connStr); + char* slotName = psprintf(MULTIMASTER_SLOT_PATTERN, MtmNodeId); initStringInfo(&spill_info); @@ -230,9 +224,9 @@ pglogical_receiver_main(Datum main_arg) pqsignal(SIGHUP, receiver_raw_sighup); pqsignal(SIGTERM, receiver_raw_sigterm); - MtmCreateSpillDirectory(args->remote_node); + MtmCreateSpillDirectory(nodeId); - sprintf(worker_proc, "mtm_pglogical_receiver_%d_%d", args->local_node, args->remote_node); + sprintf(worker_proc, "mtm_pglogical_receiver_%d_%d", MtmNodeId, nodeId); /* We're now ready to receive signals */ BackgroundWorkerUnblockSignals(); @@ -245,29 +239,29 @@ pglogical_receiver_main(Datum main_arg) * Druing recovery we need to open only one replication slot from which node should receive all transactions. * Slots at other nodes should be removed */ - mode = MtmReceiverSlotMode(args->remote_node); + mode = MtmReceiverSlotMode(nodeId); /* Establish connection to remote server */ - conn = PQconnectdb(args->receiver_conn_string); + conn = PQconnectdb(connString); if (PQstatus(conn) != CONNECTION_OK) { PQfinish(conn); ereport(WARNING, (errmsg("%s: Could not establish connection to remote server", - worker_proc))); - /* MtmOnNodeDisconnect(args->remote_node); */ + worker_proc))); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } query = createPQExpBuffer(); if (mode == SLOT_CREATE_NEW) { - appendPQExpBuffer(query, "DROP_REPLICATION_SLOT \"%s\"", args->receiver_slot); + appendPQExpBuffer(query, "DROP_REPLICATION_SLOT \"%s\"", slotName); res = PQexec(conn, query->data); PQclear(res); resetPQExpBuffer(query); } if (mode != SLOT_OPEN_EXISTED) { - appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"", args->receiver_slot, MULTIMASTER_NAME); + appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"", slotName, MULTIMASTER_NAME); res = PQexec(conn, query->data); if (PQresultStatus(res) != PGRES_TUPLES_OK) { @@ -286,7 +280,7 @@ pglogical_receiver_main(Datum main_arg) /* Start logical replication at specified position */ StartTransactionCommand(); - originName = psprintf(MULTIMASTER_SLOT_PATTERN, args->remote_node); + originName = psprintf(MULTIMASTER_SLOT_PATTERN, nodeId); originId = replorigin_by_name(originName, true); if (originId == InvalidRepOriginId) { originId = replorigin_create(originName); @@ -297,15 +291,15 @@ pglogical_receiver_main(Datum main_arg) * So we assume that LSNs are the same for local and remote node */ originStartPos = Mtm->status == MTM_RECOVERY ? GetXLogInsertRecPtr() : 0; - MTM_LOG1("Start logical receiver at position %lx from node %d", originStartPos, args->remote_node); + MTM_LOG1("Start logical receiver at position %lx from node %d", originStartPos, nodeId); } else { originStartPos = replorigin_get_progress(originId, false); - MTM_LOG1("Restart logical receiver at position %lx from node %d", originStartPos, args->remote_node); + MTM_LOG1("Restart logical receiver at position %lx from node %d", originStartPos, nodeId); } CommitTransactionCommand(); appendPQExpBuffer(query, "START_REPLICATION SLOT \"%s\" LOGICAL %x/%x (\"startup_params_format\" '1', \"max_proto_version\" '%d', \"min_proto_version\" '%d', \"forward_changesets\" '1', \"mtm_replication_mode\" '%s')", - args->receiver_slot, + slotName, (uint32) (originStartPos >> 32), (uint32) originStartPos, MULTIMASTER_MAX_PROTO_VERSION, @@ -323,7 +317,7 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); resetPQExpBuffer(query); - MtmReceiverStarted(args->remote_node); + MtmReceiverStarted(nodeId); ByteBufferAlloc(&buf); while (!got_sigterm) @@ -354,7 +348,7 @@ pglogical_receiver_main(Datum main_arg) if (rc & WL_POSTMASTER_DEATH) proc_exit(1); - if (Mtm->status == MTM_OFFLINE || (Mtm->status == MTM_RECOVERY && Mtm->recoverySlot != args->remote_node)) { + if (Mtm->status == MTM_OFFLINE || (Mtm->status == MTM_RECOVERY && Mtm->recoverySlot != nodeId)) { ereport(LOG, (errmsg("%s: terminating WAL receiver because node was switched to %s mode", worker_proc, MtmNodeStatusMnem[Mtm->status]))); proc_exit(0); } @@ -427,7 +421,7 @@ pglogical_receiver_main(Datum main_arg) int64 now = feGetCurrentTimestamp(); /* Leave is feedback is not sent properly */ - if (!sendFeedback(conn, now, args->remote_node)) + if (!sendFeedback(conn, now, nodeId)) proc_exit(1); } continue; @@ -458,9 +452,9 @@ pglogical_receiver_main(Datum main_arg) if (buf.used >= MtmTransSpillThreshold) { if (spill_file < 0) { int file_id; - spill_file = MtmCreateSpillFile(args->remote_node, &file_id); + spill_file = MtmCreateSpillFile(nodeId, &file_id); pq_sendbyte(&spill_info, 'F'); - pq_sendint(&spill_info, args->remote_node, 4); + pq_sendint(&spill_info, nodeId, 4); pq_sendint(&spill_info, file_id, 4); } ByteBufferAppend(&buf, ")", 1); @@ -579,32 +573,37 @@ pglogical_receiver_main(Datum main_arg) proc_exit(0); } - -void MtmStartReceivers(void) +void MtmStartReceiver(int nodeId, bool dynamic) { - int i; BackgroundWorker worker; + MemoryContext oldContext = MemoryContextSwitchTo(TopMemoryContext); MemSet(&worker, 0, sizeof(BackgroundWorker)); worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; worker.bgw_start_time = BgWorkerStart_ConsistentState; worker.bgw_main = pglogical_receiver_main; worker.bgw_restart_time = MULTIMASTER_BGW_RESTART_TIMEOUT; + + /* Worker parameter and registration */ + snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_pglogical_receiver_%d_%d", MtmNodeId, nodeId); + + worker.bgw_main_arg = Int32GetDatum(nodeId); + if (dynamic) { + BackgroundWorkerHandle *handle; + RegisterDynamicBackgroundWorker(&worker, &handle); + } else { + RegisterBackgroundWorker(&worker); + } + + MemoryContextSwitchTo(oldContext); +} +void MtmStartReceivers(void) +{ + int i; for (i = 0; i < MtmNodes; i++) { if (i+1 != MtmNodeId) { - ReceiverArgs* ctx = (ReceiverArgs*)palloc(sizeof(ReceiverArgs)); - ctx->receiver_conn_string = psprintf("replication=database %s", MtmConnections[i].connStr); - sprintf(ctx->receiver_slot, MULTIMASTER_SLOT_PATTERN, MtmNodeId); - - ctx->local_node = MtmNodeId; - ctx->remote_node = i+1; - - /* Worker parameter and registration */ - snprintf(worker.bgw_name, BGW_MAXLEN, "mtm_pglogical_receiver_%d_%d", MtmNodeId, i+1); - - worker.bgw_main_arg = (Datum)ctx; - RegisterBackgroundWorker(&worker); + MtmStartReceiver(i+1, false); } } } From ccac390183d47576ecfd302d19d8548ab329d789 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 25 Apr 2016 22:06:08 +0300 Subject: [PATCH 0422/1139] Add dtmacid test --- tests/dtmacid.cpp | 313 ++++++++++++++++++++++++++++++++++++++++++++++ tests/makefile | 9 +- tests/run_perf.sh | 0 tests/runacid.sh | 5 + 4 files changed, 324 insertions(+), 3 deletions(-) create mode 100644 tests/dtmacid.cpp mode change 100644 => 100755 tests/run_perf.sh create mode 100755 tests/runacid.sh diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp new file mode 100644 index 0000000000..8b27942f34 --- /dev/null +++ b/tests/dtmacid.cpp @@ -0,0 +1,313 @@ +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +using namespace std; +using namespace pqxx; + +template +class my_unique_ptr +{ + T* ptr; + + public: + my_unique_ptr(T* p = NULL) : ptr(p) {} + ~my_unique_ptr() { delete ptr; } + T& operator*() { return *ptr; } + T* operator->() { return ptr; } + void operator=(T* p) { ptr = p; } + void operator=(my_unique_ptr& other) { + ptr = other.ptr; + other.ptr = NULL; + } +}; + +typedef void* (*thread_proc_t)(void*); +typedef uint32_t xid_t; + +struct thread +{ + pthread_t t; + size_t transactions; + size_t updates; + size_t selects; + size_t aborts; + int id; + + void start(int tid, thread_proc_t proc) { + id = tid; + updates = 0; + selects = 0; + aborts = 0; + transactions = 0; + pthread_create(&t, NULL, proc, this); + } + + void wait() { + pthread_join(t, NULL); + } +}; + +struct config +{ + int nReaders; + int nWriters; + int nIterations; + int nAccounts; + int updatePercent; + vector connections; + bool scatter; + + config() { + nReaders = 1; + nWriters = 10; + nIterations = 1000; + nAccounts = 100000; + updatePercent = 100; + scatter = false; + } +}; + +config cfg; +bool running; + +#define USEC 1000000 + +static time_t getCurrentTime() +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return (time_t)tv.tv_sec*USEC + tv.tv_usec; +} + + +void exec(transaction_base& txn, char const* sql, ...) +{ + va_list args; + va_start(args, sql); + char buf[1024]; + vsprintf(buf, sql, args); + va_end(args); + txn.exec(buf); +} + +template +T execQuery( transaction_base& txn, char const* sql, ...) +{ + va_list args; + va_start(args, sql); + char buf[1024]; + vsprintf(buf, sql, args); + va_end(args); + result r = txn.exec(buf); + return r[0][0].as(T()); +} + +void* reader(void* arg) +{ + thread& t = *(thread*)arg; + vector< my_unique_ptr > conns(cfg.connections.size()); + for (size_t i = 0; i < conns.size(); i++) { + conns[i] = new connection(cfg.connections[i]); + } + int lt = 0; + int gt = 0; + while (running) { + int c1 = random() % conns.size(); + int c2; + while ((c2 = random() % conns.size()) == c1); + work txn1(*conns[c1]); + work txn2(*conns[c2]); + result r1 = txn1.exec("select v from t order by u"); + result r2 = txn2.exec("select v from t order by u"); + int delta = 0; + for (int i=0; i < cfg.nAccounts; i++) { + int diff = r1[i][0].as(int()) - r2[i][0].as(int()); + if (diff != 0) { + if (delta == 0) { + delta = diff; + if (delta < 0) lt++; else gt++; + } else if (delta != diff) { + printf("Inconsistency found for record %d\n", i); + } + } + } + t.transactions += 2; + t.selects += 2; + txn1.commit(); + txn2.commit(); + } + printf("lt=%d, gt=%d\n", lt, gt); + return NULL; +} + +void* writer(void* arg) +{ + thread& t = *(thread*)arg; + vector< my_unique_ptr > conns(cfg.connections.size()); + for (size_t i = 0; i < conns.size(); i++) { + conns[i] = new connection(cfg.connections[i]); + } + for (int i = 0; i < cfg.nIterations; i++) + { + //work + //transaction txn(*conns[random() % conns.size()]); + transaction txn(*conns[random() % conns.size()]); + int acc = random() % cfg.nAccounts; + try { + exec(txn, "update t set v = v + 1 where u=%d", acc); + txn.commit(); + t.updates += 1; + t.transactions += 1; + } catch (pqxx_exception const& x) { + txn.abort(); + t.aborts += 1; + i -= 1; + } + } + return NULL; +} + +void initializeDatabase() +{ + connection conn(cfg.connections[0]); + time_t start = getCurrentTime(); + printf("Creating database schema...\n"); + { + nontransaction txn(conn); + exec(txn, "drop extension if exists multimaster"); + exec(txn, "create extension multimaster"); + exec(txn, "drop table if exists t"); + exec(txn, "create table t(u int primary key, v int)"); + } + printf("Populating data...\n"); + { + work txn(conn); + exec(txn, "insert into t (select generate_series(0,%d), %d)", cfg.nAccounts-1, 0); + txn.commit(); + } + printf("Initialization completed in %f seconds\n", (getCurrentTime() - start)/100000.0); +} + +int main (int argc, char* argv[]) +{ + bool initialize = false; + + if (argc == 1){ + printf("Use -h to show usage options\n"); + return 1; + } + + for (int i = 1; i < argc; i++) { + if (argv[i][0] == '-') { + switch (argv[i][1]) { + case 'r': + cfg.nReaders = atoi(argv[++i]); + continue; + case 'w': + cfg.nWriters = atoi(argv[++i]); + continue; + case 'a': + cfg.nAccounts = atoi(argv[++i]); + continue; + case 'n': + cfg.nIterations = atoi(argv[++i]); + continue; + case 'p': + cfg.updatePercent = atoi(argv[++i]); + continue; + case 's': + cfg.scatter = true; + continue; + case 'c': + cfg.connections.push_back(string(argv[++i])); + continue; + case 'i': + initialize = true; + continue; + } + } + printf("Options:\n" + "\t-r N\tnumber of readers (1)\n" + "\t-w N\tnumber of writers (10)\n" + "\t-a N\tnumber of accounts (100000)\n" + "\t-n N\tnumber of iterations (1000)\n" + "\t-p N\tupdate percent (100)\n" + "\t-c STR\tdatabase connection string\n" + "\t-i\tinitialize database\n"); + return 1; + } + + if (initialize) { + initializeDatabase(); + printf("%d accounts inserted\n", cfg.nAccounts); + return 0; + } + + time_t start = getCurrentTime(); + running = true; + + vector readers(cfg.nReaders); + vector writers(cfg.nWriters); + size_t nAborts = 0; + size_t nUpdates = 0; + size_t nSelects = 0; + size_t nTransactions = 0; + + for (int i = 0; i < cfg.nReaders; i++) { + readers[i].start(i, reader); + } + for (int i = 0; i < cfg.nWriters; i++) { + writers[i].start(i, writer); + } + + for (int i = 0; i < cfg.nWriters; i++) { + writers[i].wait(); + nUpdates += writers[i].updates; + nSelects += writers[i].selects; + nAborts += writers[i].aborts; + nTransactions += writers[i].transactions; + } + + running = false; + + for (int i = 0; i < cfg.nReaders; i++) { + readers[i].wait(); + nSelects += readers[i].selects; + nTransactions += writers[i].transactions; + } + + time_t elapsed = getCurrentTime() - start; + + printf( + "{\"tps\":%f, \"transactions\":%ld," + " \"selects\":%ld, \"updates\":%ld, \"aborts\":%ld, \"abort_percent\": %d," + " \"readers\":%d, \"writers\":%d, \"update_percent\":%d, \"accounts\":%d, \"iterations\":%d, \"hosts\":%ld}\n", + (double)(nTransactions*USEC)/elapsed, + nTransactions, + nSelects, + nUpdates, + nAborts, + (int)(nAborts*100/nTransactions), + cfg.nReaders, + cfg.nWriters, + cfg.updatePercent, + cfg.nAccounts, + cfg.nIterations, + cfg.connections.size() + ); + + return 0; +} diff --git a/tests/makefile b/tests/makefile index 8a45d37e85..71e2ca01ca 100644 --- a/tests/makefile +++ b/tests/makefile @@ -1,10 +1,13 @@ CXX=g++ -CXXFLAGS=-g -Wall -O2 -pthread +CXXFLAGS=-g -Wall -O0 -pthread -all: dtmbench +all: dtmbench dtmacid dtmbench: dtmbench.cpp $(CXX) $(CXXFLAGS) -o dtmbench dtmbench.cpp -lpqxx -lpq +dtmacid: dtmacid.cpp + $(CXX) $(CXXFLAGS) -o dtmacid dtmacid.cpp -lpqxx -lpq + clean: - rm -f dtmbench + rm -f dtmbench dtmacid diff --git a/tests/run_perf.sh b/tests/run_perf.sh old mode 100644 new mode 100755 diff --git a/tests/runacid.sh b/tests/runacid.sh new file mode 100755 index 0000000000..3f3d77f7c6 --- /dev/null +++ b/tests/runacid.sh @@ -0,0 +1,5 @@ +./dtmacid \ +-c "dbname=postgres host=localhost port=5432 sslmode=disable" \ +-c "dbname=postgres host=localhost port=5433 sslmode=disable" \ +-c "dbname=postgres host=localhost port=5434 sslmode=disable" \ +-n 1000 -a 1000 -w 10 -r 1 $* From 2105d9ef3e1229271c95e7da9925efcda2815d2b Mon Sep 17 00:00:00 2001 From: knizhnik Date: Mon, 25 Apr 2016 23:44:51 +0300 Subject: [PATCH 0423/1139] Fix spill to file threshold check --- multimaster.c | 2 ++ multimaster.h | 1 + pglogical_receiver.c | 2 +- 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 9570c3c7a5..231f46856b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -504,6 +504,8 @@ MtmAdjustOldestXid(TransactionId xid) MtmTransState *ts, *prev = NULL; int i; + return FirstNormalTransactionId; + MtmLock(LW_EXCLUSIVE); ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { diff --git a/multimaster.h b/multimaster.h index 8d7844bb00..4803e1d2f3 100644 --- a/multimaster.h +++ b/multimaster.h @@ -47,6 +47,7 @@ #define MULTIMASTER_ADMIN "mtm_admin" #define USEC 1000000 +#define MB (1024*1024) #define USEC_TO_MSEC(t) ((t)/1000) #define MSEC_TO_USEC(t) ((t)*1000) diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 47f22d4749..787c2da09a 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -449,7 +449,7 @@ pglogical_receiver_main(Datum main_arg) { stmt = copybuf + hdr_len; - if (buf.used >= MtmTransSpillThreshold) { + if (buf.used >= MtmTransSpillThreshold*MB) { if (spill_file < 0) { int file_id; spill_file = MtmCreateSpillFile(nodeId, &file_id); From 43ccb59c2c77d5c52014bede460265ac77773e12 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Tue, 26 Apr 2016 12:55:45 +0300 Subject: [PATCH 0424/1139] Add a test to check the cross-anomaly. --- t/002_cross.pl | 151 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 t/002_cross.pl diff --git a/t/002_cross.pl b/t/002_cross.pl new file mode 100644 index 0000000000..68f0bef6b1 --- /dev/null +++ b/t/002_cross.pl @@ -0,0 +1,151 @@ +use strict; +use warnings; + +use Cluster; +use TestLib; +use Test::More tests => 1; +use IPC::Run qw(start finish); +use Cwd; + +my $nnodes = 2; +my $nclients = 10; +my $nkeys = $nnodes * $nclients; +my $cluster = new Cluster($nnodes); + +$cluster->init(); +$cluster->configure(); +$cluster->start(); + +my ($rc, $in, $out, $err); + +diag("sleeping 10"); +sleep(10); + +diag("preparing the tables"); +if ($cluster->psql(0, 'postgres', "create table t (k int primary key, v int)")) +{ + BAIL_OUT('failed to create t'); +} + +if ($cluster->psql(0, 'postgres', "insert into t (select generate_series(0, $nkeys - 1), 0)")) +{ + BAIL_OUT('failed to fill t'); +} + +sub appender +{ + my ($appender_id, $clients, $seconds, $node, $inref, $outref) = @_; + + my @argv = ( + 'pgbench', + '-n', + -c => $clients, + -j => $clients, + -T => $seconds, + -h => $node->host(), + -p => $node->port(), + -D => "appender_id=$appender_id", + -D => "clients=$clients", + -f => 'tests/appender.pgb', + 'postgres', + ); + + diag("running[" . getcwd() . "]: " . join(' ', @argv)); + + return start(\@argv, $inref, $outref); +} + +sub state_dump +{ + my $state = shift; + + diag("<<<<<"); + while (my ($key, $value) = each(%{$state})) + { + diag("$key -> $value"); + } + diag(">>>>>"); +} + +sub state_leq +{ + my ($a, $b) = @_; + + while (my ($key, $value) = each(%{$a})) + { + if (!exists($b->{$key})) + { + diag("b has no key $key\n"); + return 0; + } + + if ($b->{$key} < $value) + { + diag($b->{$key} . " < $value\n"); + return 0; + } + } + + return 1; +} + +sub parse_state +{ + my $str = shift; + my $state = {}; + + while ($str =~ /(\d+)\|(\d+)/g) + { + $state->{$1} = $2; + } + + return $state; +} + +diag("starting appenders"); +diag("starting benches"); +$in = ''; +$out = ''; +my @appenders = (); +my $appender_id = 0; +my $seconds = 30; +foreach my $node (@{$cluster->{nodes}}) +{ + push(@appenders, appender($appender_id, $nclients, $seconds, $node, \$in, \$out)); + $appender_id++; +} + +my $selects = 0; +my $anomalies = 0; +my $started = time(); +my $node_id = 0; +my $state_a = undef; +my $state_b = undef; +my $out_a = ''; +my $out_b = ''; +while (time() - $started < $seconds) +{ + $node_id = ($node_id + 1) % $nnodes; + $state_a = $state_b; + $out_a = $out_b; + ($rc, $out, $err) = $cluster->psql($node_id, 'postgres', "select * from t;"); + $selects++; + $state_b = parse_state($out); + $out_b = $out; + if (defined $state_a) + { + if (!state_leq($state_a, $state_b) && !state_leq($state_a, $state_b)) + { + diag("cross anomaly detected:\n===a\n$out_a\n+++b\n$out_b\n---\n"); + $anomalies++; + } + } +} + +diag("finishing benches"); +foreach my $appender (@appenders) +{ + finish($appender) || BAIL_OUT("pgbench exited with $?"); +} + +is($anomalies, 0, "no cross anomalies after $selects selects"); From 7a88fe9fc22eb109e67cebd0ec9391f073e44bc6 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 26 Apr 2016 13:10:39 +0300 Subject: [PATCH 0425/1139] Fix oldest xid adjustment algorithm --- multimaster.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index 231f46856b..7fd4b9cf38 100644 --- a/multimaster.c +++ b/multimaster.c @@ -341,14 +341,14 @@ csn_t MtmTransactionSnapshot(TransactionId xid) Snapshot MtmGetSnapshot(Snapshot snapshot) { snapshot = PgGetSnapshotData(snapshot); - RecentGlobalDataXmin = RecentGlobalXmin = MtmAdjustOldestXid(RecentGlobalDataXmin); + RecentGlobalDataXmin = RecentGlobalXmin = Mtm->oldestXid;//MtmAdjustOldestXid(RecentGlobalDataXmin); return snapshot; } TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum) { - TransactionId xmin = PgGetOldestXmin(NULL, ignoreVacuum); /* consider all backends */ + TransactionId xmin = PgGetOldestXmin(NULL, false); /* consider all backends */ xmin = MtmAdjustOldestXid(xmin); return xmin; } @@ -539,7 +539,8 @@ MtmAdjustOldestXid(TransactionId xid) if (prev != NULL) { Mtm->transListHead = prev; Mtm->oldestXid = xid = prev->xid; - } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { + } else { + Assert(TransactionIdPrecedesOrEqual(Mtm->oldestXid, xid)); xid = Mtm->oldestXid; } } else { From dc2d4ecd8d0e777697af8fc6ae44da892cea2c14 Mon Sep 17 00:00:00 2001 From: "Constantin S. Pan" Date: Tue, 26 Apr 2016 13:33:37 +0300 Subject: [PATCH 0426/1139] Add the 'appender' pgbench script for the cross-anomaly test. --- tests/appender.pgb | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 tests/appender.pgb diff --git a/tests/appender.pgb b/tests/appender.pgb new file mode 100644 index 0000000000..92a24fa5ac --- /dev/null +++ b/tests/appender.pgb @@ -0,0 +1,4 @@ +\set key :appender_id * :clients + :client_id +begin; +update t set v = v + 1 where k = :key; +commit; From 24820a351d7dc87f95aa9af4f32f1958cbb1e0ec Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 26 Apr 2016 15:46:24 +0300 Subject: [PATCH 0427/1139] provision vagrant cluster --- testeaux/Vagrantfile | 16 ++++++++-- testeaux/provision.yml | 68 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 81 insertions(+), 3 deletions(-) create mode 100644 testeaux/provision.yml diff --git a/testeaux/Vagrantfile b/testeaux/Vagrantfile index eda28ad00a..739168fc90 100644 --- a/testeaux/Vagrantfile +++ b/testeaux/Vagrantfile @@ -2,10 +2,20 @@ # vi: set ft=ruby : Vagrant.configure(2) do |config| - config.vm.box = "ubuntu/ubuntu-15.04-snappy-core-stable" + config.vm.box = "ubuntu/trusty64" - 5.times do |i| - config.vm.define "n#{i+1}l" + nhosts = 3 + + nhosts.times do |i| + config.vm.define "node#{i}" do |node| + node.vm.hostname = "node#{i}" + if i == nhosts - 1 + node.vm.provision :ansible do |ansible| + ansible.limit = "all" + ansible.playbook = "provision.yml" + end + end + end end end diff --git a/testeaux/provision.yml b/testeaux/provision.yml new file mode 100644 index 0000000000..3e8b04c3e4 --- /dev/null +++ b/testeaux/provision.yml @@ -0,0 +1,68 @@ +--- + +- hosts: all + + roles: + - role: kelvich.postgres + pg_port: 5432 + pg_repo: https://github.com/postgrespro/postgres_cluster.git + pg_version_tag: master + pg_destroy_and_init: true + pg_config_role: + - line: "multimaster.buffer_size = 65536" + + tasks: + - name: generate connstrings + set_fact: + connstr: "host={{item}} user={{ansible_ssh_user}} dbname=postgres" + with_items: + groups['all'] | reverse | batch(nnodes | d(3) | int) | first + register: connstrs + + - name: make a list + set_fact: + connections: "{{ connstrs.results | map(attribute='ansible_facts.connstr') | join(', ') }}" + + - debug: var=hostvars + + - debug: var=inventory_hostname + + #- debug: var=hostvars[inventory_hostname] + + - name: build raftable + shell: "make clean && make -j {{makejobs}} install" + args: + chdir: "{{pg_src}}/contrib/raftable" + + - name: build multimaster + shell: "make clean && make -j {{makejobs}} install" + args: + chdir: "{{pg_src}}/contrib/mmts" + + - name: enable dtm extension on datanodes + lineinfile: + dest: "{{pg_datadir}}/postgresql.conf" + line: "{{item}}" + state: present + with_items: + - "wal_level = logical" + - "max_wal_senders = 10" + - "wal_sender_timeout = 0" + - "max_replication_slots = 10" + - "max_connections = 200" + - "max_worker_processes = 100" + - "shared_preload_libraries = 'raftable,multimaster'" + - "multimaster.conn_strings = '{{connections}}'" + - "multimaster.node_id = {{ inventory_hostname | regex_replace('([0-9]+)', '\\1') }}" + - "multimaster.buffer_size = 65536" + - "multimaster.queue_size = 1073741824" + - "multimaster.arbiter_port = 5600" + - "multimaster.vacuum_delay = 1" + - "multimaster.workers = 32" + - "multimaster.use_dtm = 1" + + - name: restart postgrespro + command: "{{pg_dst}}/bin/pg_ctl restart -w -D {{pg_datadir}} -l {{pg_datadir}}/pg.log" + environment: + LD_LIBRARY_PATH: "{{pg_dst}}/lib/" + From 24885ab08fa88f9952a5a00c08da3d01ed9b8419 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 26 Apr 2016 15:53:00 +0300 Subject: [PATCH 0428/1139] Setup test cluster via ssh connection. WIP --- testeaux/RemoteCluster.pm | 179 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 179 insertions(+) create mode 100644 testeaux/RemoteCluster.pm diff --git a/testeaux/RemoteCluster.pm b/testeaux/RemoteCluster.pm new file mode 100644 index 0000000000..2336dd33e7 --- /dev/null +++ b/testeaux/RemoteCluster.pm @@ -0,0 +1,179 @@ +package RemoteCluster; + +use strict; +use warnings; +use Data::Dumper; +use Net::OpenSSH; +use Cwd; + +sub new +{ + my ($class, $config_fname) = @_; + open(my $config, '<', $config_fname); + my @config_lines = <$config>; + my @nodes = (); + + # Parse connection options from ssh_config + my $node; + foreach (@config_lines) + { + if (/^Host (.+)/) + { + if ($node->{'host'}){ + push(@nodes, $node); + $node = {}; + } + $node->{'host'} = $1; + } + elsif (/\s*([^\s]+)\s*([^\s]+)\s*/) + { + $node->{'cfg'}->{$1} = $2; + } + } + push(@nodes, $node); + + # print Dumper(@nodes); + + my $self = { + nnodes => scalar @nodes, + nodes => \@nodes, + }; + + bless $self, $class; + return $self; +} + +sub run +{ + my ($self, $node_id, $cmd) = @_; + my $node = $self->{nodes}[$node_id]; + my $opts = $node->{cfg}; + + print "===\n"; + print Dumper($opts); + print "===\n"; + + my $ssh = Net::OpenSSH->new( + $opts->{HostName}, + port => $opts->{Port}, + user => $opts->{User}, + key_path => $opts->{IdentityFile} =~ /"([^"]*)"/, + master_opts => [-o => "StrictHostKeyChecking=no"] + ); + + my @ls = $ssh->capture($cmd); + + print Dumper(@ls); + +} + +sub init +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->init(hba_permit_replication => 0); + } +} + +sub detach +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + delete $node->{_pid}; + } +} + +sub configure +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + my $connstr = join(',', map { "${ \$_->connstr('postgres') }" } @$nodes); + my $raftpeers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @$nodes); + + foreach my $node (@$nodes) + { + my $id = $node->{id}; + my $host = $node->host; + my $pgport = $node->port; + my $raftport = $node->{raftport}; + + $node->append_conf("postgresql.conf", qq( + listen_addresses = '$host' + unix_socket_directories = '' + port = $pgport + max_prepared_transactions = 200 + max_connections = 200 + max_worker_processes = 100 + wal_level = logical + fsync = off + max_wal_senders = 10 + wal_sender_timeout = 0 + max_replication_slots = 10 + shared_preload_libraries = 'raftable,multimaster' + multimaster.workers = 10 + multimaster.queue_size = 10485760 # 10mb + multimaster.node_id = $id + multimaster.conn_strings = '$connstr' + multimaster.use_raftable = true + multimaster.ignore_tables_without_pk = true + multimaster.twopc_min_timeout = 60000 + raftable.id = $id + raftable.peers = '$raftpeers' + )); + + $node->append_conf("pg_hba.conf", qq( + local replication all trust + host replication all 127.0.0.1/32 trust + host replication all ::1/128 trust + )); + } +} + +sub start +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->start(); + } +} + +sub stop +{ + my ($self) = @_; + my $nodes = $self->{nodes}; + + foreach my $node (@$nodes) + { + $node->stop(); + } +} + +sub psql +{ + my ($self, $index, @args) = @_; + my $node = $self->{nodes}->[$index]; + return $node->psql(@args); +} + + +my $cluster = new RemoteCluster('ssh-config'); + +print $cluster->{'nnodes'} . "\n"; + +$cluster->run(1, 'ls -la'); + +1; + + + + From 73916d4d571e3730a4b3f0445e16d0e59adbe95d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 26 Apr 2016 18:14:48 +0300 Subject: [PATCH 0429/1139] Fixes in MtmAdjustOldestXid --- arbiter.c | 4 +-- multimaster.c | 70 +++++---------------------------------------------- multimaster.h | 3 +-- 3 files changed, 9 insertions(+), 68 deletions(-) diff --git a/arbiter.c b/arbiter.c index 77a9ebb208..f86a35a809 100644 --- a/arbiter.c +++ b/arbiter.c @@ -665,8 +665,8 @@ static void MtmTransReceiver(Datum arg) do { struct timeval tv; events = inset; - tv.tv_sec = MtmKeepaliveTimeout/USEC; - tv.tv_usec = MtmKeepaliveTimeout%USEC; + tv.tv_sec = MtmKeepaliveTimeout/USECS_PER_SEC; + tv.tv_usec = MtmKeepaliveTimeout%USECS_PER_SEC; do { n = select(max_fd+1, &events, NULL, NULL, &tv); } while (n < 0 && errno == EINTR); diff --git a/multimaster.c b/multimaster.c index 7fd4b9cf38..4b2fad48a8 100644 --- a/multimaster.c +++ b/multimaster.c @@ -92,7 +92,7 @@ typedef enum #define MTM_MAP_SIZE 1003 #define MIN_WAIT_TIMEOUT 1000 #define MAX_WAIT_TIMEOUT 100000 -#define STATUS_POLL_DELAY USEC +#define STATUS_POLL_DELAY USECS_PER_SEC void _PG_init(void); void _PG_fini(void); @@ -261,7 +261,7 @@ timestamp_t MtmGetSystemTime(void) { struct timeval tv; gettimeofday(&tv, NULL); - return (timestamp_t)tv.tv_sec*USEC + tv.tv_usec + Mtm->timeShift; + return (timestamp_t)tv.tv_sec*USECS_PER_SEC + tv.tv_usec + Mtm->timeShift; } timestamp_t MtmGetCurrentTime(void) @@ -401,7 +401,7 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (delta > maxSleepTime) { maxSleepTime = delta; } - if (now > prevReportTime + USEC*10) { + if (now > prevReportTime + USECS_PER_SEC*10) { prevReportTime = now; if (firstReportTime == 0) { firstReportTime = now; @@ -442,61 +442,6 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) * We collest oldest CSNs from all nodes and choose minimum from them. * If no such XID can be located, then return previously observed oldest XID */ -#if 0 -static TransactionId -MtmAdjustOldestXid(TransactionId xid) -{ - if (TransactionIdIsValid(xid)) { - MtmTransState *ts, *prev = NULL; - csn_t oldestSnapshot = 0; - int i; - - MtmLock(LW_EXCLUSIVE); - for (ts = Mtm->transListHead; ts != NULL; ts = ts->next) { - if (TransactionIdPrecedes(ts->xid, xid) - && ts->status == TRANSACTION_STATUS_COMMITTED - && ts->csn > oldestSnapshot) - { - oldestSnapshot = ts->csn; - } - } - Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; - for (i = 0; i < Mtm->nAllNodes; i++) { - if (!BIT_CHECK(Mtm->disabledNodeMask, i) - && Mtm->nodes[i].oldestSnapshot < oldestSnapshot) - { - oldestSnapshot = Mtm->nodes[i].oldestSnapshot; - } - } - oldestSnapshot -= MtmVacuumDelay*USEC; - for (ts = Mtm->transListHead; - ts != NULL - && ts->csn < oldestSnapshot - && TransactionIdPrecedes(ts->xid, xid) - && (ts->status == TRANSACTION_STATUS_COMMITTED || - ts->status == TRANSACTION_STATUS_ABORTED); - ts = ts->next) - { - if (ts->status == TRANSACTION_STATUS_COMMITTED) { - prev = ts; - } - } - if (prev != NULL) { - for (ts = Mtm->transListHead; ts != prev; ts = ts->next) { - /* Remove information about too old transactions */ - Assert(ts->status != TRANSACTION_STATUS_UNKNOWN); - hash_search(MtmXid2State, &ts->xid, HASH_REMOVE, NULL); - } - Mtm->transListHead = prev; - Mtm->oldestXid = xid = prev->xid; - } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { - xid = Mtm->oldestXid; - } - MtmUnlock(); - } - return xid; -} -#else static TransactionId MtmAdjustOldestXid(TransactionId xid) { @@ -504,8 +449,6 @@ MtmAdjustOldestXid(TransactionId xid) MtmTransState *ts, *prev = NULL; int i; - return FirstNormalTransactionId; - MtmLock(LW_EXCLUSIVE); ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { @@ -518,7 +461,7 @@ MtmAdjustOldestXid(TransactionId xid) oldestSnapshot = Mtm->nodes[i].oldestSnapshot; } } - oldestSnapshot -= MtmVacuumDelay*USEC; + oldestSnapshot -= MtmVacuumDelay*USECS_PER_SEC; for (ts = Mtm->transListHead; ts != NULL @@ -540,7 +483,7 @@ MtmAdjustOldestXid(TransactionId xid) Mtm->transListHead = prev; Mtm->oldestXid = xid = prev->xid; } else { - Assert(TransactionIdPrecedesOrEqual(Mtm->oldestXid, xid)); + Assert(TransactionIdPrecedesOrEquals(Mtm->oldestXid, xid)); xid = Mtm->oldestXid; } } else { @@ -552,7 +495,6 @@ MtmAdjustOldestXid(TransactionId xid) } return xid; } -#endif /* * ------------------------------------------- * Transaction list manipulation @@ -2356,7 +2298,7 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->values[4] = Int64GetDatum(lag); usrfctx->nulls[4] = lag < 0; usrfctx->values[5] = Int64GetDatum(Mtm->transCount ? Mtm->nodes[usrfctx->nodeId-1].transDelay/Mtm->transCount : 0); - usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime/USEC)); + usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime/USECS_PER_SEC)); usrfctx->values[7] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); usrfctx->nodeId += 1; diff --git a/multimaster.h b/multimaster.h index 4803e1d2f3..00b138ed25 100644 --- a/multimaster.h +++ b/multimaster.h @@ -46,8 +46,7 @@ #define MULTIMASTER_BROADCAST_SERVICE "mtm_broadcast" #define MULTIMASTER_ADMIN "mtm_admin" -#define USEC 1000000 -#define MB (1024*1024) +#define MB (1024*1024L) #define USEC_TO_MSEC(t) ((t)/1000) #define MSEC_TO_USEC(t) ((t)*1000) From 2af32350d47eb00373a469cc5700187fc0f1c1c1 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 26 Apr 2016 19:02:50 +0300 Subject: [PATCH 0430/1139] RemoteNode --- testeaux/RemoteNode.pm | 123 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 testeaux/RemoteNode.pm diff --git a/testeaux/RemoteNode.pm b/testeaux/RemoteNode.pm new file mode 100644 index 0000000000..8549130a60 --- /dev/null +++ b/testeaux/RemoteNode.pm @@ -0,0 +1,123 @@ +package RemoteNode; + +use strict; +use warnings; +use Net::OpenSSH; + +sub new +{ + my ($class, $name, $sshopts) = @_; + + my $self = { + _port => $sshopts->{Port}, + _host => $sshopts->{HostName}, + _user => $sshopts->{User}, + _keypath => $sshopts->{IdentityFile} =~ /"([^"]*)"/, + _pgdata => "/home/$sshopts->{User}/pg_cluster/data_5432", + _pgbin => "/home/$sshopts->{User}/pg_cluster/install/bin", + }; + + bless $self, $class; + + # kill postgres here to ensure + # predictable initial state. + $self->execute("pkill -9 postgres || true"); + + return $self; +} + +sub execute +{ + my ($self, $cmd) = @_; + + # XXX: reuse connection + my $ssh = Net::OpenSSH->new( + host => $self->{_host}, + port => $self->{_port}, + user => $self->{_user}, + key_path => $self->{_keypath}, + master_opts => [-o => "StrictHostKeyChecking=no"] + ); + + print "# running \"$cmd\":\n"; + + my $output = $ssh->capture($cmd); + + $ssh->error and + warn "operation didn't complete successfully: ". $ssh->error; + + # XXX: tab and colorize output + print $output; + print "---\n"; + + return $?; +} + +sub init +{ + my ($self, %params) = @_; + my $pgbin = $self->{_pgbin}; + my $pgdata = $self->{_pgdata}; + + $self->execute("rm -rf $pgdata"); + $self->execute("env LANG=C LC_ALL=C $pgbin/initdb -D $pgdata -A trust -N"); + + $self->execute("echo 'fsync = off' >> $pgdata/postgresql.conf"); + $self->execute("echo 'host all all 0.0.0.0/0 trust' >> $pgdata/pg_hba.conf"); +} + +sub start +{ + my ($self) = @_; + my $pgbin = $self->{_pgbin}; + my $pgdata = $self->{_pgdata}; + + $self->execute("$pgbin/pg_ctl -w -D $pgdata -l $pgdata/log start"); +} + +sub stop +{ + my ($self, $mode) = @_; + my $pgbin = $self->{_pgbin}; + my $pgdata = $self->{_pgdata}; + + $self->execute("$pgbin/pg_ctl -w -D $pgdata -m $mode stop"); +} + +sub restart +{ + my ($self) = @_; + my $pgbin = $self->{_pgbin}; + my $pgdata = $self->{_pgdata}; + + $self->execute("$pgbin/pg_ctl -w -D $pgdata restart"); +} + +sub append_conf +{ + +} + +sub psql +{ + +} + +# XXX: test +my $node = new RemoteNode('node0', { + 'Port' => '2200', + 'IdentityFile' => '"/Users/stas/code/postgres_cluster/contrib/mmts/testeaux/.vagrant/machines/node1/virtualbox/private_key"', + 'IdentitiesOnly' => 'yes', + 'LogLevel' => 'FATAL', + 'PasswordAuthentication' => 'no', + 'StrictHostKeyChecking' => 'no', + 'HostName' => '127.0.0.1', + 'User' => 'vagrant', + 'UserKnownHostsFile' => '/dev/null' + }); + +$node->execute("ls -ls"); +$node->init; +$node->start; + + From bf168d6475072d820da73c308c7b2d3942d1e682 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 26 Apr 2016 19:48:03 +0300 Subject: [PATCH 0431/1139] Abort transaction ni case of cluster configuration change --- multimaster.c | 15 +++++++++++---- multimaster.h | 3 ++- tests/dtmacid.cpp | 1 - 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/multimaster.c b/multimaster.c index 4b2fad48a8..7bdb74c9ee 100644 --- a/multimaster.c +++ b/multimaster.c @@ -273,8 +273,8 @@ void MtmSleep(timestamp_t interval) { struct timespec ts; struct timespec rem; - ts.tv_sec = interval/1000000; - ts.tv_nsec = interval%1000000*1000; + ts.tv_sec = interval/USECS_PER_SEC; + ts.tv_nsec = interval%USECS_PER_SEC*1000; while (nanosleep(&ts, &rem) < 0) { Assert(errno == EINTR); @@ -751,6 +751,7 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) } else { time_t timeout = Max(Mtm2PCMinTimeout, (ts->csn - ts->snapshot)*Mtm2PCPrepareRatio/100000); /* usec->msec and percents */ int result = 0; + int nConfigChanges = Mtm->nConfigChanges; /* wait votes from all nodes */ while (!ts->votingCompleted && !(result & WL_TIMEOUT)) { MtmUnlock(); @@ -758,9 +759,12 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) ResetLatch(&MyProc->procLatch); MtmLock(LW_SHARED); } - if (!ts->votingCompleted) { + if (!ts->votingCompleted) { ts->status = TRANSACTION_STATUS_ABORTED; - elog(WARNING, "Transaction is aborted because of %d msec timeout expiration, prepare time %d msec", (int)timeout, (int)((ts->csn - x->snapshot)/1000)); + elog(WARNING, "Transaction is aborted because of %d msec timeout expiration, prepare time %d msec", (int)timeout, (int)USEC_TO_MSEC(ts->csn - x->snapshot)); + } else if (nConfigChanges != Mtm->nConfigChanges) { + ts->status = TRANSACTION_STATUS_ABORTED; + elog(WARNING, "Transaction is aborted because cluster configuration is changed during commit"); } x->status = ts->status; MTM_LOG3("%d: Result of vote: %d", MyProcPid, ts->status); @@ -1088,6 +1092,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); Mtm->nLiveNodes += 1; + Mtm->nConfigChanges += 1; caughtUp = true; } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) && slotLSN + MtmMinRecoveryLag > walLSN) @@ -1262,6 +1267,7 @@ bool MtmRefreshClusterStatus(bool nowait) void MtmCheckQuorum(void) { + Mtm->nConfigChanges += 1; if (Mtm->nLiveNodes < Mtm->nAllNodes/2+1) { if (Mtm->status == MTM_ONLINE) { /* out of quorum */ elog(WARNING, "Node is in minority: disabled mask %lx", (long) Mtm->disabledNodeMask); @@ -1459,6 +1465,7 @@ static void MtmInitialize() Mtm->nReceivers = 0; Mtm->timeShift = 0; Mtm->transCount = 0; + Mtm->nConfigChanges = 0; Mtm->localTablesHashLoaded = false; for (i = 0; i < MtmNodes; i++) { Mtm->nodes[i].oldestSnapshot = 0; diff --git a/multimaster.h b/multimaster.h index 00b138ed25..e5c06a3047 100644 --- a/multimaster.h +++ b/multimaster.h @@ -169,7 +169,8 @@ typedef struct int nReceivers; /* Number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ int nLockers; /* Number of lockers */ int nActiveTransactions; /* Nunmber of active 2PC transactions */ - long timeShift; /* Local time correction */ + int nConfigChanges; /* Number of cluster configuration changes */ + int64 timeShift; /* Local time correction */ csn_t csn; /* Last obtained CSN: used to provide unique acending CSNs based on system time */ MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. This list is used to pass information to mtm-sender BGW */ diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp index 8b27942f34..638088c124 100644 --- a/tests/dtmacid.cpp +++ b/tests/dtmacid.cpp @@ -144,7 +144,6 @@ void* reader(void* arg) } } } - t.transactions += 2; t.selects += 2; txn1.commit(); txn2.commit(); From 66ee06f5e62ebc8ab04f67809ecae9a257d5e375 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Wed, 27 Apr 2016 00:09:54 +0300 Subject: [PATCH 0432/1139] Yet another version of MtmAdjustOldestXid --- multimaster.c | 16 +++++++++------- multimaster.h | 1 + 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/multimaster.c b/multimaster.c index 7bdb74c9ee..4b26d55f63 100644 --- a/multimaster.c +++ b/multimaster.c @@ -329,7 +329,7 @@ csn_t MtmTransactionSnapshot(TransactionId xid) MtmLock(LW_SHARED); ts = hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - if (ts != NULL) { + if (ts != NULL && !ts->isLocal) { snapshot = ts->snapshot; } MtmUnlock(); @@ -451,8 +451,8 @@ MtmAdjustOldestXid(TransactionId xid) MtmLock(LW_EXCLUSIVE); ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - if (ts != NULL && ts->status == TRANSACTION_STATUS_COMMITTED) { - csn_t oldestSnapshot = ts->csn; + if (ts != NULL) { + csn_t oldestSnapshot = ts->snapshot; Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; for (i = 0; i < Mtm->nAllNodes; i++) { if (!BIT_CHECK(Mtm->disabledNodeMask, i) @@ -482,8 +482,7 @@ MtmAdjustOldestXid(TransactionId xid) if (prev != NULL) { Mtm->transListHead = prev; Mtm->oldestXid = xid = prev->xid; - } else { - Assert(TransactionIdPrecedesOrEquals(Mtm->oldestXid, xid)); + } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { xid = Mtm->oldestXid; } } else { @@ -649,6 +648,7 @@ MtmCreateTransState(MtmCurrentTrans* x) if (!found) { ts->status = TRANSACTION_STATUS_IN_PROGRESS; ts->snapshot = x->snapshot; + ts->isLocal = true; if (TransactionIdIsValid(x->gtid.xid)) { Assert(x->gtid.node != MtmNodeId); ts->gtid = x->gtid; @@ -703,7 +703,8 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) /* * Invalid CSN prevent replication of transaction by logical replication */ - ts->snapshot = x->isReplicated || !x->containsDML ? INVALID_CSN : x->snapshot; + ts->isLocal = x->isReplicated || !x->containsDML; + ts->snapshot = x->snapshot; ts->csn = MtmAssignCSN(); ts->procno = MyProc->pgprocno; ts->nVotes = 1; /* I am voted myself */ @@ -833,7 +834,8 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) Assert(TransactionIdIsValid(x->xid)); ts = hash_search(MtmXid2State, &x->xid, HASH_ENTER, NULL); ts->status = TRANSACTION_STATUS_ABORTED; - ts->snapshot = INVALID_CSN; + ts->isLocal = true; + ts->snapshot = x->snapshot; ts->csn = MtmAssignCSN(); ts->gtid = x->gtid; ts->nSubxids = 0; diff --git a/multimaster.h b/multimaster.h index e5c06a3047..ec5e431ac3 100644 --- a/multimaster.h +++ b/multimaster.h @@ -145,6 +145,7 @@ typedef struct MtmTransState struct MtmTransState* nextVoting; /* Next element in L1-list of voting transactions. */ struct MtmTransState* next; /* Next element in L1 list of all finished transaction present in xid2state hash */ bool votingCompleted; /* 2PC voting is completed */ + bool isLocal; /* Transaction is either replicated, either doesn't contain DML statements, so it shoudl be ignored by pglogical replication */ TransactionId xids[1]; /* [Mtm->nAllNodes]: transaction ID at replicas */ } MtmTransState; From 125d7b8d882edb6ca64cecf51d69da67c878436d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 27 Apr 2016 14:30:47 +0300 Subject: [PATCH 0433/1139] Dump hash info --- multimaster--1.0.sql | 5 +++-- multimaster.c | 7 ++++++- multimaster.h | 4 ++-- 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index d70857450e..acca18fbdd 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -28,13 +28,14 @@ AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; -CREATE TYPE mtm.node_state AS ("id" integer, "disabled" bool, "disconnected" bool, "catchUp" bool, "slotLag" bigint, "avgTransDelay" bigint, "lastStatusChange" timestamp, "connStr" text); +CREATE TYPE mtm.node_state AS ("id" integer, "disabled" bool, "disconnected" bool, "catchUp" bool, "slotLag" bigint, "avgTransDelay" bigint, "lastStatusChange" timestamp, "oldestSnapshot" bigint, "connStr" text); CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state AS 'MODULE_PATHNAME','mtm_get_nodes_state' LANGUAGE C; -CREATE TYPE mtm.cluster_state AS ("status" text, "disabledNodeMask" bigint, "disconnectedNodeMask" bigint, "catchUpNodeMask" bigint, "liveNodes" integer, "allNodes" integer, "nActiveQueries" integer, "nPendingQueries" integer, "queueSize" bigint, "transCount" bigint, "timeShift" bigint, "recoverySlot" integer); +CREATE TYPE mtm.cluster_state AS ("status" text, "disabledNodeMask" bigint, "disconnectedNodeMask" bigint, "catchUpNodeMask" bigint, "liveNodes" integer, "allNodes" integer, "nActiveQueries" integer, "nPendingQueries" integer, "queueSize" bigint, "transCount" bigint, "timeShift" bigint, "recoverySlot" integer, +"xidHashSize" bigint, "gidHashSize" bigint, "oldestSnapshot" bigint, "configChanges" integer); CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state AS 'MODULE_PATHNAME','mtm_get_cluster_state' diff --git a/multimaster.c b/multimaster.c index 4b26d55f63..086e3ba11d 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2308,7 +2308,8 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->nulls[4] = lag < 0; usrfctx->values[5] = Int64GetDatum(Mtm->transCount ? Mtm->nodes[usrfctx->nodeId-1].transDelay/Mtm->transCount : 0); usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime/USECS_PER_SEC)); - usrfctx->values[7] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); + usrfctx->values[7] = Int64GetDatum(Mtm->nodes[usrfctx->nodeId-1].oldestSnapshot); + usrfctx->values[8] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); usrfctx->nodeId += 1; SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(heap_form_tuple(usrfctx->desc, usrfctx->values, usrfctx->nulls))); @@ -2335,6 +2336,10 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) values[9] = Int64GetDatum(Mtm->transCount); values[10] = Int64GetDatum(Mtm->timeShift); values[11] = Int32GetDatum(Mtm->recoverySlot); + values[12] = Int64GetDatum(hash_get_num_entries(MtmXid2State)); + values[13] = Int64GetDatum(hash_get_num_entries(MtmGid2State)); + values[14] = Int64GetDatum(Mtm->oldestSnapshot); + values[15] = Int32GetDatum(Mtm->nConfigChanges); PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); } diff --git a/multimaster.h b/multimaster.h index ec5e431ac3..36cad16447 100644 --- a/multimaster.h +++ b/multimaster.h @@ -59,8 +59,8 @@ #define Anum_mtm_local_tables_rel_schema 1 #define Anum_mtm_local_tables_rel_name 2 -#define Natts_mtm_cluster_state 12 -#define Natts_mtm_nodes_state 8 +#define Natts_mtm_cluster_state 16 +#define Natts_mtm_nodes_state 9 typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) From 906fcbbc9250ec7c37f306bf85da1192cf34848d Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 27 Apr 2016 17:59:54 +0300 Subject: [PATCH 0434/1139] RemoteCluster.pm --- testeaux/RemoteCluster.pm | 87 +++++++++++---------------------------- testeaux/RemoteNode.pm | 48 ++++++++++----------- testeaux/Vagrantfile | 2 + 3 files changed, 46 insertions(+), 91 deletions(-) diff --git a/testeaux/RemoteCluster.pm b/testeaux/RemoteCluster.pm index 2336dd33e7..3f7e283bc6 100644 --- a/testeaux/RemoteCluster.pm +++ b/testeaux/RemoteCluster.pm @@ -5,32 +5,32 @@ use warnings; use Data::Dumper; use Net::OpenSSH; use Cwd; +use RemoteNode; sub new { my ($class, $config_fname) = @_; open(my $config, '<', $config_fname); - my @config_lines = <$config>; my @nodes = (); # Parse connection options from ssh_config - my $node; - foreach (@config_lines) + my $node_cfg; + foreach (<$config>) { if (/^Host (.+)/) { - if ($node->{'host'}){ - push(@nodes, $node); - $node = {}; + if ($node_cfg->{'host'}){ + push(@nodes, new RemoteNode($node_cfg->{'host'}, $node_cfg->{'cfg'})); + $node_cfg = {}; } - $node->{'host'} = $1; + $node_cfg->{'host'} = $1; } elsif (/\s*([^\s]+)\s*([^\s]+)\s*/) { - $node->{'cfg'}->{$1} = $2; + $node_cfg->{'cfg'}->{$1} = $2; } } - push(@nodes, $node); + push(@nodes, new RemoteNode($node_cfg->{'host'}, $node_cfg->{'cfg'})); # print Dumper(@nodes); @@ -43,30 +43,6 @@ sub new return $self; } -sub run -{ - my ($self, $node_id, $cmd) = @_; - my $node = $self->{nodes}[$node_id]; - my $opts = $node->{cfg}; - - print "===\n"; - print Dumper($opts); - print "===\n"; - - my $ssh = Net::OpenSSH->new( - $opts->{HostName}, - port => $opts->{Port}, - user => $opts->{User}, - key_path => $opts->{IdentityFile} =~ /"([^"]*)"/, - master_opts => [-o => "StrictHostKeyChecking=no"] - ); - - my @ls = $ssh->capture($cmd); - - print Dumper(@ls); - -} - sub init { my ($self) = @_; @@ -74,18 +50,7 @@ sub init foreach my $node (@$nodes) { - $node->init(hba_permit_replication => 0); - } -} - -sub detach -{ - my ($self) = @_; - my $nodes = $self->{nodes}; - - foreach my $node (@$nodes) - { - delete $node->{_pid}; + $node->init; } } @@ -94,20 +59,19 @@ sub configure my ($self) = @_; my $nodes = $self->{nodes}; - my $connstr = join(',', map { "${ \$_->connstr('postgres') }" } @$nodes); - my $raftpeers = join(',', map { join(':', $_->{id}, $_->host, $_->{raftport}) } @$nodes); + my $connstr = join(', ', map { $_->connstr('postgres') } @$nodes); + my $raftpeers = join(',', map { join(':', $_->{_id}, $_->{_host}, 6666) } @$nodes); foreach my $node (@$nodes) { - my $id = $node->{id}; - my $host = $node->host; - my $pgport = $node->port; - my $raftport = $node->{raftport}; + my $id = $node->{_id}; + my $host = $node->{_host}; + my $pgport = $node->{_port}; + #my $raftport = $node->{raftport}; $node->append_conf("postgresql.conf", qq( listen_addresses = '$host' - unix_socket_directories = '' - port = $pgport + port = 5432 max_prepared_transactions = 200 max_connections = 200 max_worker_processes = 100 @@ -130,8 +94,8 @@ sub configure $node->append_conf("pg_hba.conf", qq( local replication all trust - host replication all 127.0.0.1/32 trust - host replication all ::1/128 trust + host replication all 0.0.0.0/0 trust + host replication all ::1/0 trust )); } } @@ -165,15 +129,10 @@ sub psql return $node->psql(@args); } - +# XXX: test my $cluster = new RemoteCluster('ssh-config'); - -print $cluster->{'nnodes'} . "\n"; - -$cluster->run(1, 'ls -la'); +$cluster->init; +$cluster->configure; +$cluster->start; 1; - - - - diff --git a/testeaux/RemoteNode.pm b/testeaux/RemoteNode.pm index 8549130a60..d3c04f0165 100644 --- a/testeaux/RemoteNode.pm +++ b/testeaux/RemoteNode.pm @@ -7,8 +7,13 @@ use Net::OpenSSH; sub new { my ($class, $name, $sshopts) = @_; + my ($node_id) = $name =~ /(\d+)/; + + print "### Creating node $name.\n"; my $self = { + _name => $name, + _id => $node_id + 1, _port => $sshopts->{Port}, _host => $sshopts->{HostName}, _user => $sshopts->{User}, @@ -26,6 +31,13 @@ sub new return $self; } +sub connstr +{ + my ($self, $dbname) = @_; + + "host=$self->{_host} dbname=$dbname"; +} + sub execute { my ($self, $cmd) = @_; @@ -62,8 +74,8 @@ sub init $self->execute("rm -rf $pgdata"); $self->execute("env LANG=C LC_ALL=C $pgbin/initdb -D $pgdata -A trust -N"); - $self->execute("echo 'fsync = off' >> $pgdata/postgresql.conf"); - $self->execute("echo 'host all all 0.0.0.0/0 trust' >> $pgdata/pg_hba.conf"); + $self->append_conf("postgresql.conf", "fsync = off"); + $self->append_conf("pg_hba.conf", "host all all 0.0.0.0/0 trust"); } sub start @@ -72,7 +84,7 @@ sub start my $pgbin = $self->{_pgbin}; my $pgdata = $self->{_pgdata}; - $self->execute("$pgbin/pg_ctl -w -D $pgdata -l $pgdata/log start"); + $self->execute("ulimit -c unlimited && $pgbin/pg_ctl -w -D $pgdata -l $pgdata/log start"); } sub stop @@ -90,34 +102,16 @@ sub restart my $pgbin = $self->{_pgbin}; my $pgdata = $self->{_pgdata}; - $self->execute("$pgbin/pg_ctl -w -D $pgdata restart"); + $self->execute("$pgbin/pg_ctl -w -D $pgdata -l $pgdata/log restart"); } sub append_conf { + my ($self, $fname, $conf_str) = @_; + my $pgdata = $self->{_pgdata}; + my $cmd = "cat <<- EOF >> $pgdata/$fname \n $conf_str \nEOF\n"; + $self->execute($cmd); } -sub psql -{ - -} - -# XXX: test -my $node = new RemoteNode('node0', { - 'Port' => '2200', - 'IdentityFile' => '"/Users/stas/code/postgres_cluster/contrib/mmts/testeaux/.vagrant/machines/node1/virtualbox/private_key"', - 'IdentitiesOnly' => 'yes', - 'LogLevel' => 'FATAL', - 'PasswordAuthentication' => 'no', - 'StrictHostKeyChecking' => 'no', - 'HostName' => '127.0.0.1', - 'User' => 'vagrant', - 'UserKnownHostsFile' => '/dev/null' - }); - -$node->execute("ls -ls"); -$node->init; -$node->start; - - +1; diff --git a/testeaux/Vagrantfile b/testeaux/Vagrantfile index 739168fc90..69e14822a7 100644 --- a/testeaux/Vagrantfile +++ b/testeaux/Vagrantfile @@ -3,11 +3,13 @@ Vagrant.configure(2) do |config| config.vm.box = "ubuntu/trusty64" + config.vm.network "private_network", type: "dhcp" nhosts = 3 nhosts.times do |i| config.vm.define "node#{i}" do |node| + #node.vm.network "private_network", ip: "10.20.30.#{i+40}" node.vm.hostname = "node#{i}" if i == nhosts - 1 node.vm.provision :ansible do |ansible| From 8e9e4fd0c0a30b95fe3acacc7908b8778e49444d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 27 Apr 2016 18:26:34 +0300 Subject: [PATCH 0435/1139] Fix bug in flushed_lsn reporting --- multimaster--1.0.sql | 2 +- multimaster.c | 122 ++++++++++++++++++++++++++----------------- multimaster.h | 1 + pglogical_apply.c | 10 ++-- pglogical_receiver.c | 2 +- tests/dtmacid.cpp | 1 - 6 files changed, 80 insertions(+), 58 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index acca18fbdd..8535e13f73 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -35,7 +35,7 @@ AS 'MODULE_PATHNAME','mtm_get_nodes_state' LANGUAGE C; CREATE TYPE mtm.cluster_state AS ("status" text, "disabledNodeMask" bigint, "disconnectedNodeMask" bigint, "catchUpNodeMask" bigint, "liveNodes" integer, "allNodes" integer, "nActiveQueries" integer, "nPendingQueries" integer, "queueSize" bigint, "transCount" bigint, "timeShift" bigint, "recoverySlot" integer, -"xidHashSize" bigint, "gidHashSize" bigint, "oldestSnapshot" bigint, "configChanges" integer); +"xidHashSize" bigint, "gidHashSize" bigint, "oldestXid" integer, "configChanges" integer); CREATE FUNCTION mtm.get_cluster_state() RETURNS mtm.cluster_state AS 'MODULE_PATHNAME','mtm_get_cluster_state' diff --git a/multimaster.c b/multimaster.c index 086e3ba11d..ea682d8c7a 100644 --- a/multimaster.c +++ b/multimaster.c @@ -199,6 +199,7 @@ static int MtmMinRecoveryLag; static int MtmMaxRecoveryLag; static int Mtm2PCPrepareRatio; static int Mtm2PCMinTimeout; +static int MtmGcPeriod; static bool MtmIgnoreTablesWithoutPk; static ExecutorFinish_hook_type PreviousExecutorFinishHook; @@ -341,7 +342,7 @@ csn_t MtmTransactionSnapshot(TransactionId xid) Snapshot MtmGetSnapshot(Snapshot snapshot) { snapshot = PgGetSnapshotData(snapshot); - RecentGlobalDataXmin = RecentGlobalXmin = Mtm->oldestXid;//MtmAdjustOldestXid(RecentGlobalDataXmin); + RecentGlobalDataXmin = RecentGlobalXmin = Mtm->oldestXid; return snapshot; } @@ -349,8 +350,12 @@ Snapshot MtmGetSnapshot(Snapshot snapshot) TransactionId MtmGetOldestXmin(Relation rel, bool ignoreVacuum) { TransactionId xmin = PgGetOldestXmin(NULL, false); /* consider all backends */ - xmin = MtmAdjustOldestXid(xmin); - return xmin; + if (TransactionIdIsValid(xmin)) { + MtmLock(LW_EXCLUSIVE); + xmin = MtmAdjustOldestXid(xmin); + MtmUnlock(); + } + return xmin; } bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) @@ -445,53 +450,50 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) static TransactionId MtmAdjustOldestXid(TransactionId xid) { - if (TransactionIdIsValid(xid)) { - MtmTransState *ts, *prev = NULL; - int i; - - MtmLock(LW_EXCLUSIVE); - ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - if (ts != NULL) { - csn_t oldestSnapshot = ts->snapshot; - Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; - for (i = 0; i < Mtm->nAllNodes; i++) { - if (!BIT_CHECK(Mtm->disabledNodeMask, i) - && Mtm->nodes[i].oldestSnapshot < oldestSnapshot) - { - oldestSnapshot = Mtm->nodes[i].oldestSnapshot; - } - } - oldestSnapshot -= MtmVacuumDelay*USECS_PER_SEC; - - for (ts = Mtm->transListHead; - ts != NULL - && ts->csn < oldestSnapshot - && TransactionIdPrecedes(ts->xid, xid) - && (ts->status == TRANSACTION_STATUS_COMMITTED || - ts->status == TRANSACTION_STATUS_ABORTED); - prev = ts, ts = ts->next) + int i; + MtmTransState *prev = NULL; + MtmTransState *ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); + MTM_LOG1("%d: MtmAdjustOldestXid(%d): snapshot=%ld, csn=%ld, status=%d", MyProcPid, xid, ts != NULL ? ts->snapshot : 0, ts != NULL ? ts->csn : 0, ts != NULL ? ts->status : -1); + Mtm->gcCount = 0; + if (ts != NULL) { + csn_t oldestSnapshot = ts->snapshot; + Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; + for (i = 0; i < Mtm->nAllNodes; i++) { + if (!BIT_CHECK(Mtm->disabledNodeMask, i) + && Mtm->nodes[i].oldestSnapshot < oldestSnapshot) { - if (prev != NULL) { - /* Remove information about too old transactions */ - hash_search(MtmXid2State, &prev->xid, HASH_REMOVE, NULL); - } + oldestSnapshot = Mtm->nodes[i].oldestSnapshot; } - } - if (MtmUseDtm) + } + oldestSnapshot -= MtmVacuumDelay*USECS_PER_SEC; + + for (ts = Mtm->transListHead; + ts != NULL + && ts->csn < oldestSnapshot + && TransactionIdPrecedes(ts->xid, xid) + && (ts->status == TRANSACTION_STATUS_COMMITTED || + ts->status == TRANSACTION_STATUS_ABORTED); + prev = ts, ts = ts->next) { if (prev != NULL) { - Mtm->transListHead = prev; - Mtm->oldestXid = xid = prev->xid; - } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { - xid = Mtm->oldestXid; - } - } else { - if (prev != NULL) { - Mtm->transListHead = prev; + /* Remove information about too old transactions */ + hash_search(MtmXid2State, &prev->xid, HASH_REMOVE, NULL); } } - MtmUnlock(); - } + } + if (MtmUseDtm) + { + if (prev != NULL) { + Mtm->transListHead = prev; + Mtm->oldestXid = xid = prev->xid; + } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { + xid = Mtm->oldestXid; + } + } else { + if (prev != NULL) { + Mtm->transListHead = prev; + } + } return xid; } /* @@ -613,7 +615,12 @@ static void MtmBeginTransaction(MtmCurrentTrans* x) { if (x->snapshot == INVALID_CSN) { - MtmLock(LW_EXCLUSIVE); + TransactionId xmin = (Mtm->gcCount >= MtmGcPeriod) ? PgGetOldestXmin(NULL, false) : InvalidTransactionId; /* Get oldest xmin outside critical section */ + + MtmLock(LW_EXCLUSIVE); + if (TransactionIdIsValid(xmin) && Mtm->gcCount >= MtmGcPeriod) { + MtmAdjustOldestXid(xmin); + } x->xid = GetCurrentTransactionIdIfAny(); x->isReplicated = false; x->isDistributed = MtmIsUserTransaction(); @@ -689,7 +696,6 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) } MtmLock(LW_EXCLUSIVE); - /* * Check if there is global multimaster lock preventing new transaction from commit to make a chance to wal-senders to catch-up. * Only "own" transactions are blacked. Transactions replicated from other nodes (including recovered transaction) should be proceeded @@ -715,8 +721,10 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) x->isPrepared = true; x->csn = ts->csn; - + Mtm->transCount += 1; + Mtm->gcCount += 1; + MtmTransactionListAppend(ts); MtmAddSubtransactions(ts, subxids, ts->nSubxids); MTM_LOG3("%d: MtmPrePrepareTransaction prepare commit of %d (gtid.xid=%d, gtid.node=%d, CSN=%ld)", @@ -1465,8 +1473,9 @@ static void MtmInitialize() Mtm->transListHead = NULL; Mtm->transListTail = &Mtm->transListHead; Mtm->nReceivers = 0; - Mtm->timeShift = 0; + Mtm->timeShift = 0; Mtm->transCount = 0; + Mtm->gcCount = 0; Mtm->nConfigChanges = 0; Mtm->localTablesHashLoaded = false; for (i = 0; i < MtmNodes; i++) { @@ -1599,6 +1608,21 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.gc_period", + "Number of distributed transactions after which garbage collection is started", + "Multimaster is building xid->csn hash map which has to be cleaned to avoid hash overflow. This parameter specifies interval of invoking garbage collector for this map", + &MtmGcPeriod, + MTM_HASH_SIZE/10, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.max_nodes", "Maximal number of cluster nodes", @@ -2338,7 +2362,7 @@ mtm_get_cluster_state(PG_FUNCTION_ARGS) values[11] = Int32GetDatum(Mtm->recoverySlot); values[12] = Int64GetDatum(hash_get_num_entries(MtmXid2State)); values[13] = Int64GetDatum(hash_get_num_entries(MtmGid2State)); - values[14] = Int64GetDatum(Mtm->oldestSnapshot); + values[14] = Int32GetDatum(Mtm->oldestXid); values[15] = Int32GetDatum(Mtm->nConfigChanges); PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(desc, values, nulls))); diff --git a/multimaster.h b/multimaster.h index 36cad16447..85051df7f6 100644 --- a/multimaster.h +++ b/multimaster.h @@ -180,6 +180,7 @@ typedef struct MtmTransState** transListTail; /* Tail of L1 list of all finished transactionds, used to append new elements. This list is expected to be in CSN ascending order, by strict order may be violated */ uint64 transCount; /* Counter of transactions perfromed by this node */ + uint64 gcCount; /* Number of global transactions performed since last GC */ BgwPool pool; /* Pool of background workers for applying logical replication patches */ MtmNodeInfo nodes[1]; /* [Mtm->nAllNodes]: per-node data */ } MtmState; diff --git a/pglogical_apply.c b/pglogical_apply.c index 5c6ee9ff7c..40767ab184 100644 --- a/pglogical_apply.c +++ b/pglogical_apply.c @@ -75,8 +75,6 @@ static void process_remote_insert(StringInfo s, Relation rel); static void process_remote_update(StringInfo s, Relation rel); static void process_remote_delete(StringInfo s, Relation rel); -static int MtmReplicationNode; - /* * Search the index 'idxrel' for a tuple identified by 'skey' in 'rel'. * @@ -481,8 +479,8 @@ static void MtmBeginSession(void) { char slot_name[MULTIMASTER_MAX_SLOT_NAME_SIZE]; - MtmLockNode(MtmReplicationNode); - sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, MtmReplicationNode); + MtmLockNode(MtmReplicationNodeId); + sprintf(slot_name, MULTIMASTER_SLOT_PATTERN, MtmReplicationNodeId); Assert(replorigin_session_origin == InvalidRepOriginId); replorigin_session_origin = replorigin_by_name(slot_name, false); MTM_LOG3("%d: Begin setup replorigin session: %d", MyProcPid, replorigin_session_origin); @@ -498,7 +496,7 @@ MtmEndSession(void) replorigin_session_origin = InvalidRepOriginId; replorigin_session_reset(); if (unlock) { - MtmUnlockNode(MtmReplicationNode); + MtmUnlockNode(MtmReplicationNodeId); } MTM_LOG3("%d: End reset replorigin session: %d", MyProcPid, replorigin_session_origin); } @@ -513,7 +511,7 @@ process_remote_commit(StringInfo in) XLogRecPtr end_lsn; /* read flags */ flags = pq_getmsgbyte(in); - MtmReplicationNode = pq_getmsgbyte(in); + MtmReplicationNodeId = pq_getmsgbyte(in); /* read fields */ replorigin_session_origin_lsn = pq_getmsgint64(in); /* commit_lsn */ diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 787c2da09a..00a660bb53 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -47,7 +47,7 @@ static volatile sig_atomic_t got_sighup = false; /* GUC variables */ static int receiver_idle_time = 0; -static bool receiver_sync_mode = false; +static bool receiver_sync_mode = true; /* We need sync mode to have up-to-date values of catalog_xmin in replication slots */ /* Worker name */ static char worker_proc[BGW_MAXLEN]; diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp index 638088c124..3e615cb483 100644 --- a/tests/dtmacid.cpp +++ b/tests/dtmacid.cpp @@ -285,7 +285,6 @@ int main (int argc, char* argv[]) for (int i = 0; i < cfg.nReaders; i++) { readers[i].wait(); nSelects += readers[i].selects; - nTransactions += writers[i].transactions; } time_t elapsed = getCurrentTime() - start; From 34d042e34942bc41755e6c33a38d9f0b37e2fdfc Mon Sep 17 00:00:00 2001 From: knizhnik Date: Wed, 27 Apr 2016 23:22:45 +0300 Subject: [PATCH 0436/1139] Add mtm.get_csn function --- multimaster--1.0.sql | 4 ++++ multimaster.c | 22 +++++++++++++++++++++- tests/dtmacid.cpp | 6 +++--- 3 files changed, 28 insertions(+), 4 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 8535e13f73..00c0a900a9 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -27,6 +27,10 @@ CREATE FUNCTION mtm.get_snapshot() RETURNS bigint AS 'MODULE_PATHNAME','mtm_get_snapshot' LANGUAGE C; +CREATE FUNCTION mtm.get_csn(tid xid) RETURNS bigint +AS 'MODULE_PATHNAME','mtm_get_csn' +LANGUAGE C; + CREATE TYPE mtm.node_state AS ("id" integer, "disabled" bool, "disconnected" bool, "catchUp" bool, "slotLag" bigint, "avgTransDelay" bigint, "lastStatusChange" timestamp, "oldestSnapshot" bigint, "connStr" text); diff --git a/multimaster.c b/multimaster.c index ea682d8c7a..ad41b5b021 100644 --- a/multimaster.c +++ b/multimaster.c @@ -106,6 +106,7 @@ PG_FUNCTION_INFO_V1(mtm_add_node); PG_FUNCTION_INFO_V1(mtm_poll_node); PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); +PG_FUNCTION_INFO_V1(mtm_get_csn); PG_FUNCTION_INFO_V1(mtm_get_nodes_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_info); @@ -451,12 +452,13 @@ static TransactionId MtmAdjustOldestXid(TransactionId xid) { int i; + csn_t oldestSnapshot = INVALID_CSN; MtmTransState *prev = NULL; MtmTransState *ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); MTM_LOG1("%d: MtmAdjustOldestXid(%d): snapshot=%ld, csn=%ld, status=%d", MyProcPid, xid, ts != NULL ? ts->snapshot : 0, ts != NULL ? ts->csn : 0, ts != NULL ? ts->status : -1); Mtm->gcCount = 0; if (ts != NULL) { - csn_t oldestSnapshot = ts->snapshot; + oldestSnapshot = ts->snapshot; Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; for (i = 0; i < Mtm->nAllNodes; i++) { if (!BIT_CHECK(Mtm->disabledNodeMask, i) @@ -486,6 +488,7 @@ MtmAdjustOldestXid(TransactionId xid) if (prev != NULL) { Mtm->transListHead = prev; Mtm->oldestXid = xid = prev->xid; + MTM_LOG1("%d: MtmAdjustOldestXid: oldestXid=%d, olderstSnapshot=%ld", MyProcPid, xid, oldestSnapshot); } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { xid = Mtm->oldestXid; } @@ -2291,6 +2294,23 @@ mtm_get_snapshot(PG_FUNCTION_ARGS) PG_RETURN_INT64(MtmTx.snapshot); } +Datum +mtm_get_csn(PG_FUNCTION_ARGS) +{ + TransactionId xid = PG_GETARG_INT32(0); + MtmTransState* ts; + csn_t csn = INVALID_CSN; + + MtmLock(LW_SHARED); + ts = hash_search(MtmXid2State, &xid, HASH_FIND, NULL); + if (ts != NULL) { + csn = ts->csn; + } + MtmUnlock(); + + return csn; +} + typedef struct { int nodeId; diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp index 3e615cb483..78f3ee9e7a 100644 --- a/tests/dtmacid.cpp +++ b/tests/dtmacid.cpp @@ -130,8 +130,8 @@ void* reader(void* arg) while ((c2 = random() % conns.size()) == c1); work txn1(*conns[c1]); work txn2(*conns[c2]); - result r1 = txn1.exec("select v from t order by u"); - result r2 = txn2.exec("select v from t order by u"); + result r1 = txn1.exec("select v,xmin,xmax,mtm.get_csn(xmin) from t order by u"); + result r2 = txn2.exec("select v,xmin,xmax,mtm.get_csn(xmin) from t order by u"); int delta = 0; for (int i=0; i < cfg.nAccounts; i++) { int diff = r1[i][0].as(int()) - r2[i][0].as(int()); @@ -140,7 +140,7 @@ void* reader(void* arg) delta = diff; if (delta < 0) lt++; else gt++; } else if (delta != diff) { - printf("Inconsistency found for record %d\n", i); + printf("Inconsistency found for record %d: [%d,%d]->%ld vs [%d,%d]->%ld\n", i, r1[i][1].as(int()), r1[i][2].as(int()), r1[i][3].as(int64_t()), r2[i][1].as(int()), r2[i][2].as(int()), r2[i][3].as(int64_t())); } } } From afa7ff622a79282fc241570ceecdb8b157cafdbb Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 28 Apr 2016 12:23:53 +0300 Subject: [PATCH 0437/1139] Add mtm.get_last_csn function --- multimaster--1.0.sql | 4 ++++ multimaster.c | 10 +++++++++- multimaster.h | 3 ++- tests/dtmacid.cpp | 8 +++++--- 4 files changed, 20 insertions(+), 5 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index 00c0a900a9..ca3d659b66 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -31,6 +31,10 @@ CREATE FUNCTION mtm.get_csn(tid xid) RETURNS bigint AS 'MODULE_PATHNAME','mtm_get_csn' LANGUAGE C; +CREATE FUNCTION mtm.get_last_csn() RETURNS bigint +AS 'MODULE_PATHNAME','mtm_get_last_csn' +LANGUAGE C; + CREATE TYPE mtm.node_state AS ("id" integer, "disabled" bool, "disconnected" bool, "catchUp" bool, "slotLag" bigint, "avgTransDelay" bigint, "lastStatusChange" timestamp, "oldestSnapshot" bigint, "connStr" text); diff --git a/multimaster.c b/multimaster.c index ad41b5b021..0aa27fa6ec 100644 --- a/multimaster.c +++ b/multimaster.c @@ -107,6 +107,7 @@ PG_FUNCTION_INFO_V1(mtm_poll_node); PG_FUNCTION_INFO_V1(mtm_recover_node); PG_FUNCTION_INFO_V1(mtm_get_snapshot); PG_FUNCTION_INFO_V1(mtm_get_csn); +PG_FUNCTION_INFO_V1(mtm_get_last_csn); PG_FUNCTION_INFO_V1(mtm_get_nodes_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_info); @@ -822,11 +823,11 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) if (ts != NULL) { if (commit) { Assert(ts->status == TRANSACTION_STATUS_UNKNOWN); - ts->status = TRANSACTION_STATUS_COMMITTED; if (x->csn > ts->csn) { ts->csn = x->csn; MtmSyncClock(ts->csn); } + ts->status = TRANSACTION_STATUS_COMMITTED; } else { ts->status = TRANSACTION_STATUS_ABORTED; } @@ -1461,6 +1462,7 @@ static void MtmInitialize() Mtm->recoverySlot = 0; Mtm->locks = GetNamedLWLockTranche(MULTIMASTER_NAME); Mtm->csn = MtmGetCurrentTime(); + Mtm->lastCsn = INVALID_CSN; Mtm->oldestXid = FirstNormalTransactionId; Mtm->nLiveNodes = MtmNodes; Mtm->nAllNodes = MtmNodes; @@ -2294,6 +2296,12 @@ mtm_get_snapshot(PG_FUNCTION_ARGS) PG_RETURN_INT64(MtmTx.snapshot); } +Datum +mtm_get_last_csn(PG_FUNCTION_ARGS) +{ + PG_RETURN_INT64(Mtm->lastCsn); +} + Datum mtm_get_csn(PG_FUNCTION_ARGS) { diff --git a/multimaster.h b/multimaster.h index 85051df7f6..8ad4db1d6d 100644 --- a/multimaster.h +++ b/multimaster.h @@ -172,7 +172,8 @@ typedef struct int nActiveTransactions; /* Nunmber of active 2PC transactions */ int nConfigChanges; /* Number of cluster configuration changes */ int64 timeShift; /* Local time correction */ - csn_t csn; /* Last obtained CSN: used to provide unique acending CSNs based on system time */ + csn_t csn; /* Last obtained timestamp: used to provide unique acending CSNs based on system time */ + csn_t lastCsn; /* CSN of last committed transaction */ MtmTransState* votingTransactions; /* L1-list of replicated transactions sendings notifications to coordinator. This list is used to pass information to mtm-sender BGW */ MtmTransState* transListHead; /* L1 list of all finished transactions present in xid2state hash. diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp index 78f3ee9e7a..3a353b422d 100644 --- a/tests/dtmacid.cpp +++ b/tests/dtmacid.cpp @@ -130,8 +130,8 @@ void* reader(void* arg) while ((c2 = random() % conns.size()) == c1); work txn1(*conns[c1]); work txn2(*conns[c2]); - result r1 = txn1.exec("select v,xmin,xmax,mtm.get_csn(xmin) from t order by u"); - result r2 = txn2.exec("select v,xmin,xmax,mtm.get_csn(xmin) from t order by u"); + result r1 = txn1.exec("select v,xmin,xmax,mtm.get_csn(xmin),mtm.get_csn(xmax),mtm.get_snapshot(),mtm.get_last_csn() from t order by u"); + result r2 = txn2.exec("select v,xmin,xmax,mtm.get_csn(xmin),mtm.get_csn(xmax),mtm.get_snapshot(),mtm.get_last_csn() from t order by u"); int delta = 0; for (int i=0; i < cfg.nAccounts; i++) { int diff = r1[i][0].as(int()) - r2[i][0].as(int()); @@ -140,7 +140,9 @@ void* reader(void* arg) delta = diff; if (delta < 0) lt++; else gt++; } else if (delta != diff) { - printf("Inconsistency found for record %d: [%d,%d]->%ld vs [%d,%d]->%ld\n", i, r1[i][1].as(int()), r1[i][2].as(int()), r1[i][3].as(int64_t()), r2[i][1].as(int()), r2[i][2].as(int()), r2[i][3].as(int64_t())); + printf("Inconsistency found for record %d: [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld) vs. [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld)\n", i, + r1[i][1].as(int()), r1[i][2].as(int()), r1[i][3].as(int64_t()), r1[i][4].as(int64_t()), r1[i][5].as(int64_t()), r1[i][6].as(int64_t()), + r2[i][1].as(int()), r2[i][2].as(int()), r2[i][3].as(int64_t()), r2[i][4].as(int64_t()), r2[i][5].as(int64_t()), r2[i][6].as(int64_t())); } } } From c2cd5cb88dcafbf4f67b2145d20535a09acf29f9 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 28 Apr 2016 13:41:08 +0300 Subject: [PATCH 0438/1139] Add mtm.get_last_csn function --- multimaster.c | 1 + 1 file changed, 1 insertion(+) diff --git a/multimaster.c b/multimaster.c index 0aa27fa6ec..d043f018f8 100644 --- a/multimaster.c +++ b/multimaster.c @@ -827,6 +827,7 @@ MtmEndTransaction(MtmCurrentTrans* x, bool commit) ts->csn = x->csn; MtmSyncClock(ts->csn); } + Mtm->lastCsn = ts->csn; ts->status = TRANSACTION_STATUS_COMMITTED; } else { ts->status = TRANSACTION_STATUS_ABORTED; From d1c7f1bfdcf4151921ae33b1b9bd5c58ce7e56c2 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 28 Apr 2016 17:29:55 +0300 Subject: [PATCH 0439/1139] More visibility traces --- multimaster.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index d043f018f8..be695af368 100644 --- a/multimaster.c +++ b/multimaster.c @@ -374,7 +374,6 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) if (!MtmUseDtm) { return PgXidInMVCCSnapshot(xid, snapshot); } - MtmLock(LW_SHARED); #if TRACE_SLEEP_TIME @@ -426,6 +425,9 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) else { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; + if (invisible != PgXidInMVCCSnapshot(xid, snapshot)) { + fprintf(stderr, "Change visibility for XID %d(csn=%ld, status=%d) in snapshot %ld [%d,%d]\n", xid, ts->csn, ts->status, MtmTx.snapshot, snapshot->xmin, snapshot->xmax); + } MTM_LOG4("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld", MyProcPid, xid, ts->csn, invisible ? "rollbacked" : "committed", MtmTx.snapshot); MtmUnlock(); From 1f368bee6ddd38e5b2209b4e23e4a13583c78cde Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 28 Apr 2016 20:21:28 +0300 Subject: [PATCH 0440/1139] Add -s option to dtmacid --- tests/dtmacid.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp index 3a353b422d..ab8a6fb16b 100644 --- a/tests/dtmacid.cpp +++ b/tests/dtmacid.cpp @@ -166,7 +166,10 @@ void* writer(void* arg) //work //transaction txn(*conns[random() % conns.size()]); transaction txn(*conns[random() % conns.size()]); - int acc = random() % cfg.nAccounts; + int acc = cfg.scatter + ? random() % (cfg.nAccounts/cfg.nWriters) * cfg.nWriters + t.id + : random() % cfg.nAccounts; + try { exec(txn, "update t set v = v + 1 where u=%d", acc); txn.commit(); @@ -247,6 +250,7 @@ int main (int argc, char* argv[]) "\t-n N\tnumber of iterations (1000)\n" "\t-p N\tupdate percent (100)\n" "\t-c STR\tdatabase connection string\n" + "\t-s\tavoid conflicts\n" "\t-i\tinitialize database\n"); return 1; } From 9f7e1313b50c9792ecaf5e41447883815374fb3b Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 29 Apr 2016 10:51:52 +0300 Subject: [PATCH 0441/1139] Add table dump --- tests/dtmacid.cpp | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp index ab8a6fb16b..1ac98a82f9 100644 --- a/tests/dtmacid.cpp +++ b/tests/dtmacid.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -122,6 +123,9 @@ void* reader(void* arg) for (size_t i = 0; i < conns.size(); i++) { conns[i] = new connection(cfg.connections[i]); } + char buf[256]; + sprintf(buf, "dump-%d.txt", t.id); + FILE* out = fopen(buf, "w"); int lt = 0; int gt = 0; while (running) { @@ -133,13 +137,19 @@ void* reader(void* arg) result r1 = txn1.exec("select v,xmin,xmax,mtm.get_csn(xmin),mtm.get_csn(xmax),mtm.get_snapshot(),mtm.get_last_csn() from t order by u"); result r2 = txn2.exec("select v,xmin,xmax,mtm.get_csn(xmin),mtm.get_csn(xmax),mtm.get_snapshot(),mtm.get_last_csn() from t order by u"); int delta = 0; + assert((int)r1.size() == cfg.nAccounts && (int)r2.size() == cfg.nAccounts); for (int i=0; i < cfg.nAccounts; i++) { int diff = r1[i][0].as(int()) - r2[i][0].as(int()); + fprintf(out, "%d: %d %c %d - [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld) vs. [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld)\n", + i, r1[i][0].as(int()), diff < 0 ? '<' : diff == 0 ? '=' : '>', r2[i][0].as(int()), + r1[i][1].as(int()), r1[i][2].as(int()), r1[i][3].as(int64_t()), r1[i][4].as(int64_t()), r1[i][5].as(int64_t()), r1[i][6].as(int64_t()), + r2[i][1].as(int()), r2[i][2].as(int()), r2[i][3].as(int64_t()), r2[i][4].as(int64_t()), r2[i][5].as(int64_t()), r2[i][6].as(int64_t())); if (diff != 0) { if (delta == 0) { delta = diff; if (delta < 0) lt++; else gt++; } else if (delta != diff) { + fflush(out); printf("Inconsistency found for record %d: [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld) vs. [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld)\n", i, r1[i][1].as(int()), r1[i][2].as(int()), r1[i][3].as(int64_t()), r1[i][4].as(int64_t()), r1[i][5].as(int64_t()), r1[i][6].as(int64_t()), r2[i][1].as(int()), r2[i][2].as(int()), r2[i][3].as(int64_t()), r2[i][4].as(int64_t()), r2[i][5].as(int64_t()), r2[i][6].as(int64_t())); @@ -150,6 +160,7 @@ void* reader(void* arg) txn1.commit(); txn2.commit(); } + fclose(out); printf("lt=%d, gt=%d\n", lt, gt); return NULL; } From ef499dbf6caba6ffc1911071d9e693f08a2b9ff6 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 29 Apr 2016 11:44:40 +0300 Subject: [PATCH 0442/1139] Update ansible scripts to support dtmacid test --- multimaster.c | 7 ++-- tests/acid.yml | 60 ++++++++++++++++++++++++++++++++ tests/deploy_layouts/cluster.yml | 8 +++++ tests/dtmacid.cpp | 4 ++- 4 files changed, 73 insertions(+), 6 deletions(-) create mode 100644 tests/acid.yml diff --git a/multimaster.c b/multimaster.c index be695af368..0ac66a6446 100644 --- a/multimaster.c +++ b/multimaster.c @@ -425,9 +425,6 @@ bool MtmXidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) else { bool invisible = ts->status != TRANSACTION_STATUS_COMMITTED; - if (invisible != PgXidInMVCCSnapshot(xid, snapshot)) { - fprintf(stderr, "Change visibility for XID %d(csn=%ld, status=%d) in snapshot %ld [%d,%d]\n", xid, ts->csn, ts->status, MtmTx.snapshot, snapshot->xmin, snapshot->xmax); - } MTM_LOG4("%d: tuple with xid=%d(csn= %ld) is %s in snapshot %ld", MyProcPid, xid, ts->csn, invisible ? "rollbacked" : "committed", MtmTx.snapshot); MtmUnlock(); @@ -458,7 +455,7 @@ MtmAdjustOldestXid(TransactionId xid) csn_t oldestSnapshot = INVALID_CSN; MtmTransState *prev = NULL; MtmTransState *ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); - MTM_LOG1("%d: MtmAdjustOldestXid(%d): snapshot=%ld, csn=%ld, status=%d", MyProcPid, xid, ts != NULL ? ts->snapshot : 0, ts != NULL ? ts->csn : 0, ts != NULL ? ts->status : -1); + MTM_LOG2("%d: MtmAdjustOldestXid(%d): snapshot=%ld, csn=%ld, status=%d", MyProcPid, xid, ts != NULL ? ts->snapshot : 0, ts != NULL ? ts->csn : 0, ts != NULL ? ts->status : -1); Mtm->gcCount = 0; if (ts != NULL) { oldestSnapshot = ts->snapshot; @@ -491,7 +488,7 @@ MtmAdjustOldestXid(TransactionId xid) if (prev != NULL) { Mtm->transListHead = prev; Mtm->oldestXid = xid = prev->xid; - MTM_LOG1("%d: MtmAdjustOldestXid: oldestXid=%d, olderstSnapshot=%ld", MyProcPid, xid, oldestSnapshot); + MTM_LOG2("%d: MtmAdjustOldestXid: oldestXid=%d, olderstSnapshot=%ld", MyProcPid, xid, oldestSnapshot); } else if (TransactionIdPrecedes(Mtm->oldestXid, xid)) { xid = Mtm->oldestXid; } diff --git a/tests/acid.yml b/tests/acid.yml new file mode 100644 index 0000000000..b0496023f6 --- /dev/null +++ b/tests/acid.yml @@ -0,0 +1,60 @@ +--- + +- hosts: nodes[-1] + gather_facts: no + tasks: + + - name: create mm ext + shell: > + ~/pg_cluster/install/bin/psql -p 15432 postgres -c "drop extension if exists multimaster"; + ~/pg_cluster/install/bin/psql -p 15432 postgres -c "drop table if exists t"; + ~/pg_cluster/install/bin/psql -p 15432 postgres -c 'create extension multimaster;'; + ~/pg_cluster/install/bin/psql -p 15432 postgres -c 'create table t(u int primary key, v int);'; + +- hosts: clients + gather_facts: no + tasks: + + - name: generate connstrings + set_fact: + connstr: "-c 'host={{item}} user={{ansible_ssh_user}} port=15432 dbname=postgres' " + with_items: + groups['nodes'] | reverse | batch(nnodes | d(1) | int) | first + register: connstrs + + - name: make a list + set_fact: + connections: "{{ connstrs.results | map(attribute='ansible_facts.connstr') | join }}" + +- hosts: clients[0] + gather_facts: no + tasks: + - name: init database + shell: "~/pg_cluster/install/bin/dtmacid {{connections}} -a 100 -i" + register: init_result + environment: + LD_LIBRARY_PATH: "/home/{{ansible_ssh_user}}/pg_cluster/install/lib" + + - debug: var=init_result + +- hosts: clients + gather_facts: no + tasks: + + - local_action: shell echo "Bench started at `date`" >> perf.results + + - name: run transfers + shell: > + ~/pg_cluster/install/bin/dtmacid {{connections}} + -w {{ nconns }} -w 4 -r 2 -n 100000 -a 100 | + tee -a perf.results | + sed "s/^/`hostname`:/" + register: transfers_result + environment: + LD_LIBRARY_PATH: "/home/{{ansible_ssh_user}}/pg_cluster/install/lib" + + - debug: var=transfers_result + + - local_action: 'shell echo "{{transfers_result.stdout }}" >> perf.results' + + - local_action: shell echo "Bench finished at `date`" >> perf.results diff --git a/tests/deploy_layouts/cluster.yml b/tests/deploy_layouts/cluster.yml index 2f998d271a..58f1e2318b 100644 --- a/tests/deploy_layouts/cluster.yml +++ b/tests/deploy_layouts/cluster.yml @@ -70,6 +70,7 @@ copy: src=../{{item}} dest=~/{{item}} mode=0755 with_items: - "dtmbench.cpp" + - "dtmacid.cpp" - name: clone pqxx git: repo=https://github.com/Ambrosys/pqxx.git @@ -96,4 +97,11 @@ - name: install dtmbench shell: "mv dtmbench ~/pg_cluster/install/bin/dtmbench" + - name: compile dtmacid + shell: "g++ -g -Wall -O2 -o dtmacid dtmacid.cpp -lpqxx -lpq -pthread -L/home/{{ansible_ssh_user}}/pg_cluster/install/lib/ -I/home/{{ansible_ssh_user}}/pg_cluster/install/include/" + + - name: install dtmacid + shell: "mv dtmacid ~/pg_cluster/install/bin/dtmacid" + + diff --git a/tests/dtmacid.cpp b/tests/dtmacid.cpp index 1ac98a82f9..a696bae3db 100644 --- a/tests/dtmacid.cpp +++ b/tests/dtmacid.cpp @@ -140,15 +140,17 @@ void* reader(void* arg) assert((int)r1.size() == cfg.nAccounts && (int)r2.size() == cfg.nAccounts); for (int i=0; i < cfg.nAccounts; i++) { int diff = r1[i][0].as(int()) - r2[i][0].as(int()); +#if 0 fprintf(out, "%d: %d %c %d - [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld) vs. [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld)\n", i, r1[i][0].as(int()), diff < 0 ? '<' : diff == 0 ? '=' : '>', r2[i][0].as(int()), r1[i][1].as(int()), r1[i][2].as(int()), r1[i][3].as(int64_t()), r1[i][4].as(int64_t()), r1[i][5].as(int64_t()), r1[i][6].as(int64_t()), r2[i][1].as(int()), r2[i][2].as(int()), r2[i][3].as(int64_t()), r2[i][4].as(int64_t()), r2[i][5].as(int64_t()), r2[i][6].as(int64_t())); +#endif if (diff != 0) { if (delta == 0) { delta = diff; if (delta < 0) lt++; else gt++; - } else if (delta != diff) { + } else if ((delta ^ diff) < 0) { fflush(out); printf("Inconsistency found for record %d: [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld) vs. [%d,%d]->[%ld,%ld] (snapshot %ld, last CSN %ld)\n", i, r1[i][1].as(int()), r1[i][2].as(int()), r1[i][3].as(int64_t()), r1[i][4].as(int64_t()), r1[i][5].as(int64_t()), r1[i][6].as(int64_t()), From 20cbd9c9327abddc8439361c0ae7a88e25c5d7d2 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 4 May 2016 12:14:58 +0300 Subject: [PATCH 0443/1139] tests --- t/001_basic_recovery.pl | 18 +++++++++++------- testeaux/Cluster.pm | 4 ++-- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index 2d82ce671e..16b8a32336 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -3,8 +3,6 @@ use Cluster; use TestLib; use Test::More tests => 3; -use DBI; -use DBD::Pg ':async'; my $cluster = new Cluster(3); $cluster->init(); @@ -43,11 +41,13 @@ diag("stopping node 2"); $cluster->{nodes}->[2]->teardown_node; -diag("sleeping 15"); -sleep(15); +my $ret = $cluster->psql(0, 'postgres', "insert into t values(4, 40);"); +diag "tx1 status = $ret"; diag("inserting 2"); -$cluster->psql(0, 'postgres', "insert into t values(2, 20);"); +my $ret = $cluster->psql(0, 'postgres', "insert into t values(2, 20);"); +diag "tx2 status = $ret"; + diag("selecting"); $cluster->psql(1, 'postgres', "select v from t where k=2;", stdout => \$psql_out); diag("selected"); @@ -58,15 +58,19 @@ ############################################################################### diag("starting node 2"); -$nodes[2]->start; -diag("sleeping 10"); +$cluster->{nodes}->[2]->start; +#diag("sleeping 10"); #sleep(10); # XXX: here we can poll + $cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); diag("inserting 3"); + $cluster->psql(0, 'postgres', "insert into t values(3, 30);"); diag("selecting"); + $cluster->psql(2, 'postgres', "select v from t where k=3;", stdout => \$psql_out); diag("selected"); + is($psql_out, '30', "Check replication after failed node recovery."); diff --git a/testeaux/Cluster.pm b/testeaux/Cluster.pm index 7dd377a74e..139202b8de 100644 --- a/testeaux/Cluster.pm +++ b/testeaux/Cluster.pm @@ -109,9 +109,9 @@ sub configure multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$connstr' - multimaster.use_raftable = true + multimaster.use_raftable = false multimaster.ignore_tables_without_pk = true - multimaster.twopc_min_timeout = 60000 + multimaster.twopc_min_timeout = 10000 raftable.id = $id raftable.peers = '$raftpeers' )); From 71924e3dc3f8a98b67e836a2275a79427e3dc531 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 17:38:09 +0300 Subject: [PATCH 0444/1139] Detect node disconnection in case of pglogical_receiver failures --- multimaster.c | 2 +- pglogical_receiver.c | 14 ++++++++++++-- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/multimaster.c b/multimaster.c index 0ac66a6446..e7a19d3362 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1289,7 +1289,7 @@ void MtmCheckQuorum(void) } } else { if (Mtm->status == MTM_IN_MINORITY) { - MTM_LOG1("Node is in majority: dissbled mask %lx", (long) Mtm->disabledNodeMask); + MTM_LOG1("Node is in majority: disabled mask %lx", (long) Mtm->disabledNodeMask); MtmSwitchClusterMode(MTM_ONLINE); } } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 00a660bb53..10a8f98b0d 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -194,7 +194,7 @@ static char const* const MtmReplicationModeName[] = { "recovered", /* SLOT_CREATE_NEW: recovery of node is completed so drop old slot and restart replication from the current position in WAL */ "recovery", /* SLOT_OPEN_EXISTED: perform recorvery of the node by applying all data from theslot from specified point */ - "normal" /* SLOT_OPEN_ALWAYS: normal mode: use existeed slot or create new one and start receiving data from it from the specified position */ + "normal" /* SLOT_OPEN_ALWAYS: normal mode: use existed slot or create new one and start receiving data from it from the specified position */ }; static void @@ -248,6 +248,7 @@ pglogical_receiver_main(Datum main_arg) PQfinish(conn); ereport(WARNING, (errmsg("%s: Could not establish connection to remote server", worker_proc))); + /* Do not make decision about node status here because at startup peer node may just no yet started */ /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } @@ -271,6 +272,7 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); ereport(ERROR, (errmsg("%s: Could not create logical slot", worker_proc))); + MtmOnNodeDisconnect(nodeId); proc_exit(1); } } @@ -312,6 +314,7 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); ereport(WARNING, (errmsg("%s: Could not start logical replication", worker_proc))); + MtmOnNodeDisconnect(nodeId); proc_exit(1); } PQclear(res); @@ -402,6 +405,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: streaming header too small: %d", worker_proc, rc))); + MtmOnNodeDisconnect(nodeId); proc_exit(1); } replyRequested = copybuf[pos]; @@ -421,8 +425,10 @@ pglogical_receiver_main(Datum main_arg) int64 now = feGetCurrentTimestamp(); /* Leave is feedback is not sent properly */ - if (!sendFeedback(conn, now, nodeId)) + if (!sendFeedback(conn, now, nodeId)) { + MtmOnNodeDisconnect(nodeId); proc_exit(1); + } } continue; } @@ -430,6 +436,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Incorrect streaming header", worker_proc))); + MtmOnNodeDisconnect(nodeId); proc_exit(1); } @@ -538,6 +545,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Incorrect status received... Leaving.", worker_proc))); + MtmOnNodeDisconnect(nodeId); proc_exit(1); } @@ -546,6 +554,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Data remaining on the socket... Leaving.", worker_proc))); + MtmOnNodeDisconnect(nodeId); proc_exit(1); } continue; @@ -564,6 +573,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Failure while receiving changes...", worker_proc))); + MtmOnNodeDisconnect(nodeId); proc_exit(1); } } From b59ca54e29927876c6c6aed8b5af1a13c5dfaf43 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 18:11:55 +0300 Subject: [PATCH 0445/1139] Increase node_disable_delay to 10 seconds --- multimaster.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index e7a19d3362..9ab9bbb2a4 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1694,7 +1694,7 @@ _PG_init(void) "Minamal amount of time (msec) between node status change", "This delay is used to avoid false detection of node failure and to prevent blinking of node status node", &MtmNodeDisableDelay, - 1000, + 10000, 1, INT_MAX, PGC_BACKEND, From 2e82abe9194a1e205683571546e1f1d370c0645c Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 18:24:21 +0300 Subject: [PATCH 0446/1139] Undo change of node_disable_delay --- multimaster.c | 2 +- t/001_basic_recovery.pl | 1 + tests/perf.results | 9 +++++++++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 9ab9bbb2a4..e7a19d3362 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1694,7 +1694,7 @@ _PG_init(void) "Minamal amount of time (msec) between node status change", "This delay is used to avoid false detection of node failure and to prevent blinking of node status node", &MtmNodeDisableDelay, - 10000, + 1000, 1, INT_MAX, PGC_BACKEND, diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index 16b8a32336..e7a5ec2d83 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -63,6 +63,7 @@ #sleep(10); # XXX: here we can poll $cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); +$cluster->psql(1, 'postgres', "select mtm.poll_node(3);"); diag("inserting 3"); $cluster->psql(0, 'postgres', "insert into t values(3, 30);"); diff --git a/tests/perf.results b/tests/perf.results index f98ef0abff..0252e2b869 100644 --- a/tests/perf.results +++ b/tests/perf.results @@ -331,3 +331,12 @@ Bench finished at Пт. апр. 15 18:43:05 MSK 2016 Bench started at Пт. апр. 15 20:01:20 MSK 2016 astro5:{tps:18310.750502, transactions:1500000, selects:0, updates:3001948, aborts:1897, abort_percent: 0, readers:0, writers:150, update_percent:100, accounts:500000, iterations:10000, hosts:3} Bench finished at Пт. апр. 15 20:02:42 MSK 2016 +Bench started at Чт. Ð¼Ð°Ñ 5 18:13:53 MSK 2016 + +Bench finished at Чт. Ð¼Ð°Ñ 5 18:13:54 MSK 2016 +Bench started at Чт. Ð¼Ð°Ñ 5 18:17:38 MSK 2016 +astro5:{tps:17241.207493, transactions:1000000, selects:0, updates:2000766, aborts:383, abort_percent: 0, readers:0, writers:100, update_percent:100, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. Ð¼Ð°Ñ 5 18:18:36 MSK 2016 +Bench started at Чт. Ð¼Ð°Ñ 5 18:22:37 MSK 2016 +astro5:{tps:117307.983547, transactions:1000000, selects:2000000, updates:0, aborts:0, abort_percent: 0, readers:0, writers:100, update_percent:0, accounts:500000, iterations:10000, hosts:3} +Bench finished at Чт. Ð¼Ð°Ñ 5 18:22:46 MSK 2016 From c144b0536afa82c54dbce8047c658f2ec89ca460 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 18:42:58 +0300 Subject: [PATCH 0447/1139] Add pooling of all nodes --- multimaster.c | 4 +++- t/001_basic_recovery.pl | 1 + 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index e7a19d3362..1bc557e2e4 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2267,7 +2267,9 @@ mtm_poll_node(PG_FUNCTION_ARGS) int nodeId = PG_GETARG_INT32(0); bool nowait = PG_GETARG_BOOL(1); bool online = true; - while (BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { + while ((nodeId == MtmNodeId && Mtm->status != MTM_ONLINE) + || (nodeId =! MtmNodeId && BIT_CHECK(Mtm->disabledNodeMask, nodeId-1))) + { if (nowait) { online = false; break; diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index e7a5ec2d83..a94c62c7e7 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -64,6 +64,7 @@ $cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); $cluster->psql(1, 'postgres', "select mtm.poll_node(3);"); +$cluster->psql(2, 'postgres', "select mtm.poll_node(3);"); diag("inserting 3"); $cluster->psql(0, 'postgres', "insert into t values(3, 30);"); From 200a22e8abb725ee299594a8afd25111973b828d Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 18:54:58 +0300 Subject: [PATCH 0448/1139] Add pooling of all node --- t/001_basic_recovery.pl | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index a94c62c7e7..be0e474ee6 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -60,11 +60,11 @@ diag("starting node 2"); $cluster->{nodes}->[2]->start; #diag("sleeping 10"); -#sleep(10); # XXX: here we can poll +sleep(10); # XXX: here we can poll -$cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); -$cluster->psql(1, 'postgres', "select mtm.poll_node(3);"); -$cluster->psql(2, 'postgres', "select mtm.poll_node(3);"); +#$cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); +#$cluster->psql(1, 'postgres', "select mtm.poll_node(3);"); +#$cluster->psql(2, 'postgres', "select mtm.poll_node(3);"); diag("inserting 3"); $cluster->psql(0, 'postgres', "insert into t values(3, 30);"); From b755151cf2215b27bac086eee5acc169103087d7 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 19:12:54 +0300 Subject: [PATCH 0449/1139] Change basic_recovery test --- t/001_basic_recovery.pl | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/t/001_basic_recovery.pl b/t/001_basic_recovery.pl index be0e474ee6..4aec66018b 100644 --- a/t/001_basic_recovery.pl +++ b/t/001_basic_recovery.pl @@ -2,7 +2,7 @@ use warnings; use Cluster; use TestLib; -use Test::More tests => 3; +use Test::More tests => 4; my $cluster = new Cluster(3); $cluster->init(); @@ -60,19 +60,24 @@ diag("starting node 2"); $cluster->{nodes}->[2]->start; #diag("sleeping 10"); -sleep(10); # XXX: here we can poll +#sleep(10); # XXX: here we can poll -#$cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); -#$cluster->psql(1, 'postgres', "select mtm.poll_node(3);"); -#$cluster->psql(2, 'postgres', "select mtm.poll_node(3);"); -diag("inserting 3"); +$cluster->psql(0, 'postgres', "select mtm.poll_node(3);"); +diag("inserting 3"); $cluster->psql(0, 'postgres', "insert into t values(3, 30);"); -diag("selecting"); +diag("inserting 4"); +$cluster->psql(1, 'postgres', "insert into t values(4, 40);"); +diag("selecting"); $cluster->psql(2, 'postgres', "select v from t where k=3;", stdout => \$psql_out); diag("selected"); is($psql_out, '30', "Check replication after failed node recovery."); +$cluster->psql(2, 'postgres', "select v from t where k=4;", stdout => \$psql_out); +diag("selected"); + +is($psql_out, '40', "Check replication after failed node recovery."); + From acb0ab60c89a502e0ee217261cd5400b3693e7eb Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Thu, 5 May 2016 19:49:18 +0300 Subject: [PATCH 0450/1139] try to test mmts without raftable --- Cluster.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cluster.pm b/Cluster.pm index c5ac76d588..0bd24499e0 100644 --- a/Cluster.pm +++ b/Cluster.pm @@ -98,7 +98,7 @@ sub configure multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$connstr' - multimaster.use_raftable = true + multimaster.use_raftable = false multimaster.ignore_tables_without_pk = true multimaster.twopc_min_timeout = 60000 raftable.id = $id From bd41d9ef07d3d6aac50ee58565ddb9c88c116806 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 20:04:06 +0300 Subject: [PATCH 0451/1139] Fix bug in BK algorithm implementation --- bkb.c | 2 +- bkbtest.c | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/bkb.c b/bkb.c index 572fc21a9b..ebabfcf2c8 100644 --- a/bkb.c +++ b/bkb.c @@ -93,7 +93,7 @@ static void findMaximumIndependentSet(NodeList* cur, NodeList* result, nodemask_ cur->size -= 1; ne += 1; if (k > 1) { - for (s = ++ne; !BIT_CHECK(graph[fixp], oldSet[s]); s++); + for (s = ne; !BIT_CHECK(graph[fixp], oldSet[s]); s++); } } } diff --git a/bkbtest.c b/bkbtest.c index 31cda3a073..b30c7cfaca 100644 --- a/bkbtest.c +++ b/bkbtest.c @@ -5,11 +5,12 @@ int main() { nodemask_t matrix[64] = {0}; nodemask_t clique; + int clique_size; matrix[0] = 6; matrix[1] = 4; matrix[2] = 1; matrix[4] = 3; - clique = MtmFindMaxClique(matrix, 64); + clique = MtmFindMaxClique(matrix, 64, &clique_size); printf("Clique=%lx\n", clique); return 0; } From be81ae138b44bfec82a71e8a73b5e5bb289d6b59 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 5 May 2016 20:05:13 +0300 Subject: [PATCH 0452/1139] Run tests with Raftable enabled --- Cluster.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cluster.pm b/Cluster.pm index 0bd24499e0..c5ac76d588 100644 --- a/Cluster.pm +++ b/Cluster.pm @@ -98,7 +98,7 @@ sub configure multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$connstr' - multimaster.use_raftable = false + multimaster.use_raftable = true multimaster.ignore_tables_without_pk = true multimaster.twopc_min_timeout = 60000 raftable.id = $id From 5b20bea963c0d68526141eba98a3191305de5c45 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 6 May 2016 11:01:49 +0300 Subject: [PATCH 0453/1139] Add mtm.inject_2pc_error function --- multimaster--1.0.sql | 4 ++++ multimaster.c | 28 ++++++++++++++++++++++++++-- multimaster.h | 1 + 3 files changed, 31 insertions(+), 2 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index ca3d659b66..a6c8d5623b 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -65,6 +65,10 @@ CREATE FUNCTION mtm.poll_node(nodeId integer, noWait boolean default FALSE) RETU AS 'MODULE_PATHNAME','mtm_poll_node' LANGUAGE C; +CREATE FUNCTION mtm.inject_2pc_error(stage integer) RETURNS void +AS 'MODULE_PATHNAME','mtm_inject_2pc_error' +LANGUAGE C; + CREATE TABLE IF NOT EXISTS mtm.ddl_log (issued timestamp with time zone not null, query text); CREATE TABLE IF NOT EXISTS mtm.local_tables(rel_schema text, rel_name text, primary key(rel_schema, rel_name)); diff --git a/multimaster.c b/multimaster.c index 1bc557e2e4..e07089216b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -113,6 +113,7 @@ PG_FUNCTION_INFO_V1(mtm_get_cluster_state); PG_FUNCTION_INFO_V1(mtm_get_cluster_info); PG_FUNCTION_INFO_V1(mtm_make_table_local); PG_FUNCTION_INFO_V1(mtm_dump_lock_graph); +PG_FUNCTION_INFO_V1(mtm_inject_2pc_error); static Snapshot MtmGetSnapshot(Snapshot snapshot); static void MtmInitialize(void); @@ -687,6 +688,10 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) return; } + if (Mtm->inject2PCError == 1) { + Mtm->inject2PCError = 0; + elog(ERROR, "ERROR INJECTION for transaction %d (%s)", x->xid, x->gid); + } x->xid = GetCurrentTransactionId(); Assert(TransactionIdIsValid(x->xid)); @@ -741,6 +746,10 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) { MtmTransState* ts; + if (Mtm->inject2PCError == 2) { + Mtm->inject2PCError = 0; + elog(ERROR, "ERROR INJECTION for transaction %d (%s)", x->xid, x->gid); + } MtmLock(LW_EXCLUSIVE); ts = hash_search(MtmXid2State, &x->xid, HASH_FIND, NULL); Assert(ts != NULL); @@ -782,6 +791,10 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MTM_LOG3("%d: Result of vote: %d", MyProcPid, ts->status); MtmUnlock(); } + if (Mtm->inject2PCError == 3) { + Mtm->inject2PCError = 0; + elog(ERROR, "ERROR INJECTION for transaction %d (%s)", x->xid, x->gid); + } } @@ -1483,6 +1496,7 @@ static void MtmInitialize() Mtm->gcCount = 0; Mtm->nConfigChanges = 0; Mtm->localTablesHashLoaded = false; + Mtm->inject2PCError = 0; for (i = 0; i < MtmNodes; i++) { Mtm->nodes[i].oldestSnapshot = 0; Mtm->nodes[i].transDelay = 0; @@ -2426,12 +2440,13 @@ mtm_get_cluster_info(PG_FUNCTION_ARGS) usrfctx = (MtmGetClusterInfoCtx*)palloc(sizeof(MtmGetNodeStateCtx)); get_call_result_type(fcinfo, NULL, &desc); funcctx->attinmeta = TupleDescGetAttInMetadata(desc); - usrfctx->nodeId = 1; + usrfctx->nodeId = 0; funcctx->user_fctx = usrfctx; MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); usrfctx = (MtmGetClusterInfoCtx*)funcctx->user_fctx; + while (++usrfctx->nodeId <= Mtm->nAllNodes && BIT_CHECK(Mtm->disabledNodeMask, usrfctx->nodeId-1)); if (usrfctx->nodeId > Mtm->nAllNodes) { SRF_RETURN_DONE(funcctx); } @@ -2527,6 +2542,12 @@ Datum mtm_dump_lock_graph(PG_FUNCTION_ARGS) return CStringGetTextDatum(s->data); } +Datum mtm_inject_2pc_error(PG_FUNCTION_ARGS) +{ + Mtm->inject2PCError = PG_GETARG_INT32(0); + PG_RETURN_VOID(); +} + /* * ------------------------------------------- * Broadcast utulity statements @@ -2794,9 +2815,12 @@ static void MtmProcessUtility(Node *parsetree, const char *queryString, } break; case TRANS_STMT_PREPARE: + elog(ERROR, "Two phase commit is not supported by multimaster"); + break; case TRANS_STMT_COMMIT_PREPARED: case TRANS_STMT_ROLLBACK_PREPARED: - elog(ERROR, "Two phase commit is not supported by multimaster"); + skipCommand = true; + break; default: break; } diff --git a/multimaster.h b/multimaster.h index 8ad4db1d6d..38bd7caafc 100644 --- a/multimaster.h +++ b/multimaster.h @@ -165,6 +165,7 @@ typedef struct nodemask_t reconnectMask; /* Mask of nodes connection to which has to be reestablished by sender */ bool localTablesHashLoaded; /* Whether data from local_tables table is loaded in shared memory hash table */ + int inject2PCError; /* Simulate error during 2PC commit at this node */ int nLiveNodes; /* Number of active nodes */ int nAllNodes; /* Total numbber of nodes */ int nReceivers; /* Number of initialized logical receivers (used to determine moment when Mtm intialization is completed */ From 3edfdffce16d6495b8c7866261a5c20d16ed6bc8 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 11 May 2016 18:58:54 +0300 Subject: [PATCH 0454/1139] Add information about BGW to node status --- multimaster--1.0.sql | 2 +- multimaster.c | 11 +++++++++-- multimaster.h | 8 ++++++-- pglogical_proto.c | 4 ++++ pglogical_receiver.c | 3 +++ 5 files changed, 23 insertions(+), 5 deletions(-) diff --git a/multimaster--1.0.sql b/multimaster--1.0.sql index a6c8d5623b..e1114e6898 100644 --- a/multimaster--1.0.sql +++ b/multimaster--1.0.sql @@ -36,7 +36,7 @@ AS 'MODULE_PATHNAME','mtm_get_last_csn' LANGUAGE C; -CREATE TYPE mtm.node_state AS ("id" integer, "disabled" bool, "disconnected" bool, "catchUp" bool, "slotLag" bigint, "avgTransDelay" bigint, "lastStatusChange" timestamp, "oldestSnapshot" bigint, "connStr" text); +CREATE TYPE mtm.node_state AS ("id" integer, "disabled" bool, "disconnected" bool, "catchUp" bool, "slotLag" bigint, "avgTransDelay" bigint, "lastStatusChange" timestamp, "oldestSnapshot" bigint, "SenderPid" integer, "SenderStartTime" timestamp, "ReceiverPid" integer, "ReceiverStartTime" timestamp, "connStr" text); CREATE FUNCTION mtm.get_nodes_state() RETURNS SETOF mtm.node_state AS 'MODULE_PATHNAME','mtm_get_nodes_state' diff --git a/multimaster.c b/multimaster.c index e07089216b..9df25c3e33 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2073,7 +2073,8 @@ void MtmDropNode(int nodeId, bool dropSlot) static void MtmOnProcExit(int code, Datum arg) { - if (MtmReplicationNodeId >= 0) { + if (MtmReplicationNodeId > 0) { + Mtm->nodes[MtmReplicationNodeId-1].senderPid = -1; MTM_LOG1("WAL-sender to %d is terminated", MtmReplicationNodeId); MtmOnNodeDisconnect(MtmReplicationNodeId); } @@ -2085,6 +2086,8 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) ListCell *param; bool recoveryCompleted = false; MtmIsRecoverySession = false; + Mtm->nodes[MtmReplicationNodeId-1].senderPid = MyProcPid; + Mtm->nodes[MtmReplicationNodeId-1].senderStartTime = MtmGetSystemTime(); foreach(param, args->in_params) { DefElem *elem = lfirst(param); @@ -2377,7 +2380,11 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->values[5] = Int64GetDatum(Mtm->transCount ? Mtm->nodes[usrfctx->nodeId-1].transDelay/Mtm->transCount : 0); usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime/USECS_PER_SEC)); usrfctx->values[7] = Int64GetDatum(Mtm->nodes[usrfctx->nodeId-1].oldestSnapshot); - usrfctx->values[8] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); + usrfctx->values[8] = Int32GetDatum(Mtm->nodes[usrfctx->nodeId-1].senderPid); + usrfctx->values[9] = Int64GetDatum(Mtm->nodes[usrfctx->nodeId-1].senderStartTime); + usrfctx->values[10] = Int32GetDatum(Mtm->nodes[usrfctx->nodeId-1].receiverPid); + usrfctx->values[11] = Int64GetDatum(Mtm->nodes[usrfctx->nodeId-1].receiverStartTime); + usrfctx->values[12] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); usrfctx->nodeId += 1; SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(heap_form_tuple(usrfctx->desc, usrfctx->values, usrfctx->nulls))); diff --git a/multimaster.h b/multimaster.h index 38bd7caafc..87a78ce811 100644 --- a/multimaster.h +++ b/multimaster.h @@ -60,7 +60,7 @@ #define Anum_mtm_local_tables_rel_name 2 #define Natts_mtm_cluster_state 16 -#define Natts_mtm_nodes_state 9 +#define Natts_mtm_nodes_state 13 typedef uint64 csn_t; /* commit serial number */ #define INVALID_CSN ((csn_t)-1) @@ -125,8 +125,12 @@ typedef struct MtmConnectionInfo con; timestamp_t transDelay; timestamp_t lastStatusChangeTime; + timestamp_t receiverStartTime; + timestamp_t senderStartTime; + int senderPid; + int receiverPid; XLogRecPtr flushPos; - csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ + csn_t oldestSnapshot; /* Oldest snapshot used by active transactions at this node */ } MtmNodeInfo; typedef struct MtmTransState diff --git a/pglogical_proto.c b/pglogical_proto.c index ee7be70c79..590504a74c 100644 --- a/pglogical_proto.c +++ b/pglogical_proto.c @@ -146,6 +146,10 @@ pglogical_write_commit(StringInfo out, PGLogicalOutputData *data, } else { csn_t csn = MtmTransactionSnapshot(txn->xid); bool isRecovery = MtmIsRecoveredNode(MtmReplicationNodeId); + /* + * INVALID_CSN means replicated transaction (transaction initiated by some other nodes). + * We do not need to send such transactions unless we perform recovery + */ if (csn == INVALID_CSN && !isRecovery) { return; } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index 10a8f98b0d..ab46cf4f6c 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -226,6 +226,9 @@ pglogical_receiver_main(Datum main_arg) MtmCreateSpillDirectory(nodeId); + Mtm->nodes[nodeId-1].senderPid = MyProcPid; + Mtm->nodes[nodeId-1].senderStartTime = MtmGetSystemTime(); + sprintf(worker_proc, "mtm_pglogical_receiver_%d_%d", MtmNodeId, nodeId); /* We're now ready to receive signals */ From 1e89f6a61e81ef07e367689b180426a3899fb8fa Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Wed, 11 May 2016 19:07:30 +0300 Subject: [PATCH 0455/1139] test with splits --- testeaux/{ => lib}/Cluster.pm | 0 testeaux/{ => lib}/Combineaux.pm | 0 testeaux/{ => lib}/RemoteCluster.pm | 19 +++++++--- testeaux/{ => lib}/RemoteNode.pm | 50 ++++++++++++++++++++++-- testeaux/{ => lib}/Starteaux.pm | 0 testeaux/{ => lib}/Stresseaux.pm | 0 testeaux/{ => lib}/Troubleaux.pm | 0 testeaux/provision.yml | 59 +---------------------------- testeaux/roles/postgres | 1 + testeaux/run_splits.pl | 49 ++++++++++++++++++++++++ 10 files changed, 110 insertions(+), 68 deletions(-) rename testeaux/{ => lib}/Cluster.pm (100%) rename testeaux/{ => lib}/Combineaux.pm (100%) rename testeaux/{ => lib}/RemoteCluster.pm (89%) rename testeaux/{ => lib}/RemoteNode.pm (72%) rename testeaux/{ => lib}/Starteaux.pm (100%) rename testeaux/{ => lib}/Stresseaux.pm (100%) rename testeaux/{ => lib}/Troubleaux.pm (100%) create mode 160000 testeaux/roles/postgres create mode 100644 testeaux/run_splits.pl diff --git a/testeaux/Cluster.pm b/testeaux/lib/Cluster.pm similarity index 100% rename from testeaux/Cluster.pm rename to testeaux/lib/Cluster.pm diff --git a/testeaux/Combineaux.pm b/testeaux/lib/Combineaux.pm similarity index 100% rename from testeaux/Combineaux.pm rename to testeaux/lib/Combineaux.pm diff --git a/testeaux/RemoteCluster.pm b/testeaux/lib/RemoteCluster.pm similarity index 89% rename from testeaux/RemoteCluster.pm rename to testeaux/lib/RemoteCluster.pm index 3f7e283bc6..db05690068 100644 --- a/testeaux/RemoteCluster.pm +++ b/testeaux/lib/RemoteCluster.pm @@ -80,14 +80,21 @@ sub configure max_wal_senders = 10 wal_sender_timeout = 0 max_replication_slots = 10 + + tcp_keepalives_idle = 2 + tcp_keepalives_interval = 1 + tcp_keepalives_count = 2 + shared_preload_libraries = 'raftable,multimaster' multimaster.workers = 10 multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$connstr' - multimaster.use_raftable = true + multimaster.use_raftable = false multimaster.ignore_tables_without_pk = true multimaster.twopc_min_timeout = 60000 + multimaster.twopc_prepare_ratio = 1000 #% + raftable.id = $id raftable.peers = '$raftpeers' )); @@ -130,9 +137,9 @@ sub psql } # XXX: test -my $cluster = new RemoteCluster('ssh-config'); -$cluster->init; -$cluster->configure; -$cluster->start; - +#my $cluster = new RemoteCluster('ssh-config'); +# $cluster->init; +# $cluster->configure; +# $cluster->start; +# 1; diff --git a/testeaux/RemoteNode.pm b/testeaux/lib/RemoteNode.pm similarity index 72% rename from testeaux/RemoteNode.pm rename to testeaux/lib/RemoteNode.pm index d3c04f0165..45f08d540b 100644 --- a/testeaux/RemoteNode.pm +++ b/testeaux/lib/RemoteNode.pm @@ -3,6 +3,7 @@ package RemoteNode; use strict; use warnings; use Net::OpenSSH; +use IPC::Run; sub new { @@ -24,9 +25,8 @@ sub new bless $self, $class; - # kill postgres here to ensure - # predictable initial state. - $self->execute("pkill -9 postgres || true"); + $self->execute("sudo iptables -F"); + $self->execute("sudo iptables -A INPUT -p tcp --dport ssh -j ACCEPT"); return $self; } @@ -35,7 +35,7 @@ sub connstr { my ($self, $dbname) = @_; - "host=$self->{_host} dbname=$dbname"; + "host=$self->{_host} dbname=$dbname user=$self->{_user}"; } sub execute @@ -71,6 +71,10 @@ sub init my $pgbin = $self->{_pgbin}; my $pgdata = $self->{_pgdata}; + # kill postgres here to ensure + # predictable initial state. + $self->execute("pkill -9 postgres || true"); + $self->execute("rm -rf $pgdata"); $self->execute("env LANG=C LC_ALL=C $pgbin/initdb -D $pgdata -A trust -N"); @@ -114,4 +118,42 @@ sub append_conf $self->execute($cmd); } +sub psql +{ + my ($self, $dbname, $sql) = @_; + my $stderr; + my $stdout; + + my @psql_command = + ('psql', '-XAtq', '-d', $self->connstr($dbname), '-f', '-'); + + my @ipcrun_command = (\@psql_command, '<', \$sql); + #push @ipcrun_command, '>', $stdout; + #push @ipcrun_command, '2>', $stderr; + + IPC::Run::run @ipcrun_command; + my $ret = $?; + + return $ret; +} + +sub net_deny_in +{ + my ($self) = @_; + $self->execute("sudo iptables -A INPUT -j DROP"); +} + +sub net_deny_out +{ + my ($self) = @_; + $self->execute("sudo iptables -A OUTPUT -j DROP"); +} + +sub net_allow +{ + my ($self) = @_; + $self->execute("sudo iptables -D INPUT -j DROP"); + $self->execute("sudo iptables -D OUTPUT -j DROP"); +} + 1; diff --git a/testeaux/Starteaux.pm b/testeaux/lib/Starteaux.pm similarity index 100% rename from testeaux/Starteaux.pm rename to testeaux/lib/Starteaux.pm diff --git a/testeaux/Stresseaux.pm b/testeaux/lib/Stresseaux.pm similarity index 100% rename from testeaux/Stresseaux.pm rename to testeaux/lib/Stresseaux.pm diff --git a/testeaux/Troubleaux.pm b/testeaux/lib/Troubleaux.pm similarity index 100% rename from testeaux/Troubleaux.pm rename to testeaux/lib/Troubleaux.pm diff --git a/testeaux/provision.yml b/testeaux/provision.yml index 3e8b04c3e4..439dea7ead 100644 --- a/testeaux/provision.yml +++ b/testeaux/provision.yml @@ -3,66 +3,9 @@ - hosts: all roles: - - role: kelvich.postgres + - role: postgres pg_port: 5432 pg_repo: https://github.com/postgrespro/postgres_cluster.git pg_version_tag: master pg_destroy_and_init: true - pg_config_role: - - line: "multimaster.buffer_size = 65536" - - tasks: - - name: generate connstrings - set_fact: - connstr: "host={{item}} user={{ansible_ssh_user}} dbname=postgres" - with_items: - groups['all'] | reverse | batch(nnodes | d(3) | int) | first - register: connstrs - - - name: make a list - set_fact: - connections: "{{ connstrs.results | map(attribute='ansible_facts.connstr') | join(', ') }}" - - - debug: var=hostvars - - - debug: var=inventory_hostname - - #- debug: var=hostvars[inventory_hostname] - - - name: build raftable - shell: "make clean && make -j {{makejobs}} install" - args: - chdir: "{{pg_src}}/contrib/raftable" - - - name: build multimaster - shell: "make clean && make -j {{makejobs}} install" - args: - chdir: "{{pg_src}}/contrib/mmts" - - - name: enable dtm extension on datanodes - lineinfile: - dest: "{{pg_datadir}}/postgresql.conf" - line: "{{item}}" - state: present - with_items: - - "wal_level = logical" - - "max_wal_senders = 10" - - "wal_sender_timeout = 0" - - "max_replication_slots = 10" - - "max_connections = 200" - - "max_worker_processes = 100" - - "shared_preload_libraries = 'raftable,multimaster'" - - "multimaster.conn_strings = '{{connections}}'" - - "multimaster.node_id = {{ inventory_hostname | regex_replace('([0-9]+)', '\\1') }}" - - "multimaster.buffer_size = 65536" - - "multimaster.queue_size = 1073741824" - - "multimaster.arbiter_port = 5600" - - "multimaster.vacuum_delay = 1" - - "multimaster.workers = 32" - - "multimaster.use_dtm = 1" - - - name: restart postgrespro - command: "{{pg_dst}}/bin/pg_ctl restart -w -D {{pg_datadir}} -l {{pg_datadir}}/pg.log" - environment: - LD_LIBRARY_PATH: "{{pg_dst}}/lib/" diff --git a/testeaux/roles/postgres b/testeaux/roles/postgres new file mode 160000 index 0000000000..51e6d51571 --- /dev/null +++ b/testeaux/roles/postgres @@ -0,0 +1 @@ +Subproject commit 51e6d51571c89e5dc51b332a84cf11eb945d130c diff --git a/testeaux/run_splits.pl b/testeaux/run_splits.pl new file mode 100644 index 0000000000..cc36b1afb3 --- /dev/null +++ b/testeaux/run_splits.pl @@ -0,0 +1,49 @@ +use strict; +use warnings; + +use lib 'lib'; +use RemoteCluster; +use IPC::Run; + +my $cluster = new RemoteCluster('ssh-config'); +$cluster->init; +$cluster->configure; +$cluster->start; +sleep 10; + +$cluster->{nodes}->[0]->psql('postgres','create extension if not exists multimaster'); +$cluster->{nodes}->[0]->psql('postgres','select * from mtm.get_nodes_state();'); + +print("Initializing database\n"); +IPC::Run::run ( + 'pgbench', + '-i', + -h => $cluster->{nodes}->[0]->{_host}, + -U => $cluster->{nodes}->[0]->{_user}, + 'postgres' +); + +my $pgbench1 = IPC::Run::start ( + 'pgbench', + -c => 4, + -T => 30, + -P => 1, + -h => $cluster->{nodes}->[0]->{_host}, + -U => $cluster->{nodes}->[0]->{_user}, + 'postgres' +); + +sleep 5; +$cluster->{nodes}->[0]->net_deny_in; +sleep 10; +$cluster->{nodes}->[0]->net_allow; + + +IPC::Run::finish($pgbench1); +# IPC::Run::run @pgbench_init + + + + + + From 28f6f7d93e553caeddcc6d0eb2d493432c3821f3 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 12 May 2016 15:07:33 +0300 Subject: [PATCH 0456/1139] Fix output of timestamps for get>_nodes_state --- multimaster.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/multimaster.c b/multimaster.c index 9df25c3e33..c5135adf9b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2381,9 +2381,9 @@ mtm_get_nodes_state(PG_FUNCTION_ARGS) usrfctx->values[6] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].lastStatusChangeTime/USECS_PER_SEC)); usrfctx->values[7] = Int64GetDatum(Mtm->nodes[usrfctx->nodeId-1].oldestSnapshot); usrfctx->values[8] = Int32GetDatum(Mtm->nodes[usrfctx->nodeId-1].senderPid); - usrfctx->values[9] = Int64GetDatum(Mtm->nodes[usrfctx->nodeId-1].senderStartTime); + usrfctx->values[9] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].senderStartTime/USECS_PER_SEC)); usrfctx->values[10] = Int32GetDatum(Mtm->nodes[usrfctx->nodeId-1].receiverPid); - usrfctx->values[11] = Int64GetDatum(Mtm->nodes[usrfctx->nodeId-1].receiverStartTime); + usrfctx->values[11] = TimestampTzGetDatum(time_t_to_timestamptz(Mtm->nodes[usrfctx->nodeId-1].receiverStartTime/USECS_PER_SEC)); usrfctx->values[12] = CStringGetTextDatum(Mtm->nodes[usrfctx->nodeId-1].con.connStr); usrfctx->nodeId += 1; From cce49da1875782ba28d4d0d05e6a9e98bb360d2a Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 12 May 2016 16:11:35 +0300 Subject: [PATCH 0457/1139] Call MtmOnNodeDisconnect in case of read error --- arbiter.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/arbiter.c b/arbiter.c index f86a35a809..2a7a9d58a5 100644 --- a/arbiter.c +++ b/arbiter.c @@ -207,9 +207,10 @@ static void MtmUnregisterSocket(int fd) static void MtmDisconnect(int node) { - close(sockets[node]); MtmUnregisterSocket(sockets[node]); + close(sockets[node]); sockets[node] = -1; + MtmOnNodeDisconnect(node+1); } static bool MtmWriteSocket(int sd, void const* buf, int size) From e0a24c29f85acf372420ef43b31dc7f2c13d566b Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 12 May 2016 16:39:41 +0300 Subject: [PATCH 0458/1139] Fix bug in handling connection errors --- arbiter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arbiter.c b/arbiter.c index 2a7a9d58a5..370255bc62 100644 --- a/arbiter.c +++ b/arbiter.c @@ -658,7 +658,7 @@ static void MtmTransReceiver(Datum arg) i = events[j].data.u32; if (events[j].events & EPOLLERR) { elog(WARNING, "Arbiter lost connection with node %d", i+1); - MtmDisconnect(j); + MtmDisconnect(i); } else if (events[j].events & EPOLLIN) #else From 1df84a30a11fbe7d507a86c53bc85ee8a3630edc Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Thu, 12 May 2016 19:28:33 +0300 Subject: [PATCH 0459/1139] Disable ratftable in regression tests --- Cluster.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Cluster.pm b/Cluster.pm index c5ac76d588..c151957af5 100644 --- a/Cluster.pm +++ b/Cluster.pm @@ -98,11 +98,11 @@ sub configure multimaster.queue_size = 10485760 # 10mb multimaster.node_id = $id multimaster.conn_strings = '$connstr' - multimaster.use_raftable = true + multimaster.use_raftable = false multimaster.ignore_tables_without_pk = true multimaster.twopc_min_timeout = 60000 - raftable.id = $id - raftable.peers = '$raftpeers' +# raftable.id = $id +# raftable.peers = '$raftpeers' )); $node->append_conf("pg_hba.conf", qq( From 02cd914840fabd9e84a5c37c22a80163ffe8284e Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Fri, 13 May 2016 15:13:27 +0300 Subject: [PATCH 0460/1139] rebuild extensions on provision --- testeaux/lib/RemoteNode.pm | 5 +++-- testeaux/provision.yml | 11 +++++++++++ testeaux/run_splits.pl | 20 ++++++++++++++------ testeaux/stress/banktransfer.pm | 5 +++++ 4 files changed, 33 insertions(+), 8 deletions(-) diff --git a/testeaux/lib/RemoteNode.pm b/testeaux/lib/RemoteNode.pm index 45f08d540b..74d3814904 100644 --- a/testeaux/lib/RemoteNode.pm +++ b/testeaux/lib/RemoteNode.pm @@ -27,6 +27,7 @@ sub new $self->execute("sudo iptables -F"); $self->execute("sudo iptables -A INPUT -p tcp --dport ssh -j ACCEPT"); + $self->execute("sudo iptables -A OUTPUT -p tcp --sport ssh -m state --state ESTABLISHED,RELATED -j ACCEPT"); return $self; } @@ -152,8 +153,8 @@ sub net_deny_out sub net_allow { my ($self) = @_; - $self->execute("sudo iptables -D INPUT -j DROP"); - $self->execute("sudo iptables -D OUTPUT -j DROP"); + $self->execute("sudo iptables -D INPUT -j DROP || true"); + $self->execute("sudo iptables -D OUTPUT -j DROP || true"); } 1; diff --git a/testeaux/provision.yml b/testeaux/provision.yml index 439dea7ead..f37e25b842 100644 --- a/testeaux/provision.yml +++ b/testeaux/provision.yml @@ -9,3 +9,14 @@ pg_version_tag: master pg_destroy_and_init: true + tasks: + - name: build raftable + shell: "make clean && make -j {{makejobs}} install" + args: + chdir: "{{pg_src}}/contrib/raftable" + + - name: build multimaster + shell: "make clean && make -j {{makejobs}} install" + args: + chdir: "{{pg_src}}/contrib/mmts" + diff --git a/testeaux/run_splits.pl b/testeaux/run_splits.pl index cc36b1afb3..874bc5e601 100644 --- a/testeaux/run_splits.pl +++ b/testeaux/run_splits.pl @@ -23,7 +23,11 @@ 'postgres' ); -my $pgbench1 = IPC::Run::start ( +my $out = ''; +my $err = ''; +my $in = ''; + +my @pgb_params = ( 'pgbench', -c => 4, -T => 30, @@ -33,16 +37,20 @@ 'postgres' ); + + +my $pgbench1 = IPC::Run::start @pgb_params; #, \$in, \$out, \$err; + sleep 5; -$cluster->{nodes}->[0]->net_deny_in; +$cluster->{nodes}->[2]->net_deny_out; +$cluster->{nodes}->[2]->net_deny_in; sleep 10; -$cluster->{nodes}->[0]->net_allow; - +$cluster->{nodes}->[2]->net_allow; IPC::Run::finish($pgbench1); -# IPC::Run::run @pgbench_init - +print("---stdout--\n$out\n"); +print("---stderr--\n$err\n"); diff --git a/testeaux/stress/banktransfer.pm b/testeaux/stress/banktransfer.pm index f6c2f1a78e..76632a44cb 100644 --- a/testeaux/stress/banktransfer.pm +++ b/testeaux/stress/banktransfer.pm @@ -1,5 +1,10 @@ package stress::banktransfer; +sub init +{ + +} + sub start { my ($class, @args) = @_; From 9c18d409d09589063064158c8e6d32319eaa8efd Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 13 May 2016 15:14:09 +0300 Subject: [PATCH 0461/1139] Check status of epoll_ctl --- arbiter.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/arbiter.c b/arbiter.c index 370255bc62..c039486f9b 100644 --- a/arbiter.c +++ b/arbiter.c @@ -198,7 +198,9 @@ static void MtmRegisterSocket(int fd, int node) static void MtmUnregisterSocket(int fd) { #if USE_EPOLL - epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL); + if (epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL) < 0) { + elog(ERROR, "Arbiter failed to unregister socket from epoll set: %d", errno); + } #else FD_CLR(fd, &inset); #endif From 8a26667668f91316423fce8de7ee8aae5d98fb9f Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 13 May 2016 20:22:56 +0300 Subject: [PATCH 0462/1139] Change order of denying ports in test --- testeaux/run_splits.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testeaux/run_splits.pl b/testeaux/run_splits.pl index 874bc5e601..3d171ece7e 100644 --- a/testeaux/run_splits.pl +++ b/testeaux/run_splits.pl @@ -42,8 +42,8 @@ my $pgbench1 = IPC::Run::start @pgb_params; #, \$in, \$out, \$err; sleep 5; -$cluster->{nodes}->[2]->net_deny_out; $cluster->{nodes}->[2]->net_deny_in; +$cluster->{nodes}->[2]->net_deny_out; sleep 10; $cluster->{nodes}->[2]->net_allow; From de99b01e5c92ef0592d733e03cd7cc4edb8cddd5 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 14 May 2016 00:03:01 +0300 Subject: [PATCH 0463/1139] Implement internal heartbeat for multimaster --- arbiter.c | 78 ++++++++++++++++++++++------------ multimaster.c | 115 +++++++++++++++++++++++++++++++++++++++----------- multimaster.h | 6 ++- 3 files changed, 147 insertions(+), 52 deletions(-) diff --git a/arbiter.c b/arbiter.c index c039486f9b..058485cf3d 100644 --- a/arbiter.c +++ b/arbiter.c @@ -44,6 +44,7 @@ #include "utils/array.h" #include "utils/builtins.h" #include "utils/memutils.h" +#include "utils/timeout.h" #include "commands/dbcommands.h" #include "miscadmin.h" #include "postmaster/autovacuum.h" @@ -101,22 +102,23 @@ typedef struct static int* sockets; static int gateway; +static bool send_heartbeat; static void MtmTransSender(Datum arg); static void MtmTransReceiver(Datum arg); -/* - * static char const* const messageText[] = - * { - * "INVALID", - * "HANDSHAKE", - * "READY", - * "PREPARE", - * "PREPARED", - * "ABORTED", - * "STATUS" - *}; - */ + +static char const* const messageText[] = +{ + "INVALID", + "HANDSHAKE", + "READY", + "PREPARE", + "PREPARED", + "ABORTED", + "STATUS", + "HEARTBEAT" +}; static BackgroundWorker MtmSender = { "mtm-sender", @@ -513,14 +515,19 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt } buf->used = 0; } - MTM_LOG3("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d", - messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); - - Assert(ts->cmd != MSG_INVALID); - buf->data[buf->used].code = ts->cmd; buf->data[buf->used].dxid = xid; - buf->data[buf->used].sxid = ts->xid; - buf->data[buf->used].csn = ts->csn; + + if (ts != NULL) { + MTM_LOG3("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d", + messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); + Assert(ts->cmd != MSG_INVALID); + buf->data[buf->used].code = ts->cmd; + buf->data[buf->used].sxid = ts->xid; + buf->data[buf->used].csn = ts->csn; + } else { + buf->data[buf->used].code = MSG_HEARTBEAT; + MTM_LOG3("Send HEARTBEAT message to node %d from node %d\n", node+1, MtmNodeId); + } buf->data[buf->used].node = MtmNodeId; buf->data[buf->used].disabledNodeMask = Mtm->disabledNodeMask; buf->data[buf->used].oldestSnapshot = Mtm->nodes[MtmNodeId-1].oldestSnapshot; @@ -533,15 +540,21 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) int n = 1; for (i = 0; i < Mtm->nAllNodes; i++) { - if (!BIT_CHECK(Mtm->disabledNodeMask, i) && TransactionIdIsValid(ts->xids[i])) { + if (!BIT_CHECK(Mtm->disabledNodeMask, i) && (ts == NULL || TransactionIdIsValid(ts->xids[i]))) { Assert(i+1 != MtmNodeId); - MtmAppendBuffer(txBuffer, ts->xids[i], i, ts); + MtmAppendBuffer(txBuffer, ts ? ts->xids[i] : InvalidTransactionId, i, ts); n += 1; } } Assert(n == Mtm->nLiveNodes); } +static void MtmSendHeartbeat() +{ + send_heartbeat = true; + PGSemaphoreUnlock(&Mtm->votingSemaphore); +} + static void MtmTransSender(Datum arg) { @@ -556,6 +569,8 @@ static void MtmTransSender(Datum arg) sigfillset(&sset); sigprocmask(SIG_UNBLOCK, &sset, NULL); + RegisterTimeout(USER_TIMEOUT, MtmSendHeartbeat); + MtmOpenConnections(); for (i = 0; i < nNodes; i++) { @@ -567,6 +582,10 @@ static void MtmTransSender(Datum arg) PGSemaphoreLock(&Mtm->votingSemaphore); CHECK_FOR_INTERRUPTS(); + if (send_heartbeat) { + send_heartbeat = false; + MtmBroadcastMessage(txBuffer, NULL); + } /* * Use shared lock to improve locality, * because all other process modifying this list are using exclusive lock @@ -700,15 +719,22 @@ static void MtmTransReceiver(Datum arg) for (j = 0; j < nResponses; j++) { MtmArbiterMessage* msg = &rxBuffer[i].data[j]; - MtmTransState* ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); - Assert(ts != NULL); + MtmTransState* ts; + Assert(msg->node > 0 && msg->node <= nNodes && msg->node != MtmNodeId); + Mtm->nodes[msg->node-1].oldestSnapshot = msg->oldestSnapshot; + Mtm->nodes[msg->node-1].lastHeartbeat = MtmGetSystemTime(); + + if (msg->code == MSG_HEARTBEAT) { + continue; + } + ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); + Assert(ts != NULL); if (BIT_CHECK(msg->disabledNodeMask, MtmNodeId-1) && Mtm->status != MTM_RECOVERY) { elog(PANIC, "Node %d thinks that I was dead: perform hara-kiri not to be a zombie", msg->node); } - Mtm->nodes[msg->node-1].oldestSnapshot = msg->oldestSnapshot; - + if (MtmIsCoordinator(ts)) { switch (msg->code) { case MSG_READY: @@ -768,7 +794,7 @@ static void MtmTransReceiver(Datum arg) } else { switch (msg->code) { case MSG_PREPARE: - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); ts->status = TRANSACTION_STATUS_UNKNOWN; ts->csn = MtmAssignCSN(); MtmAdjustSubtransactions(ts); diff --git a/multimaster.c b/multimaster.c index c5135adf9b..2b4b06d737 100644 --- a/multimaster.c +++ b/multimaster.c @@ -191,6 +191,8 @@ int MtmReconnectAttempts; int MtmNodeDisableDelay; int MtmTransSpillThreshold; int MtmMaxNodes; +int MtmHeartbeatSendTimeout; +int MtmHeartbeatRecvTimeout; bool MtmUseRaftable; bool MtmUseDtm; @@ -741,6 +743,27 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) } +/* + * Check heartbeats + */ +static void MtmWatchdog() +{ + int i, n = Mtm->nAllNodes; + timestamp_t now = MtmGetSystemTime(); + for (i = 0; i < n; i++) { + if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i)) { + if (Mtm->nodes[i].lastHeartbeat != 0 + && now > Mtm->nodes[i].lastHeartbeat + MSEC_TO_USEC(MtmHeartbeatRecvTimeout)) + { + elog(WARNING, "Disable node %d because last heartbeat was received %d msec ago", + i+1, (int)USEC_TO_MSEC(now - Mtm->nodes[i].lastHeartbeat)); + MtmOnNodeDisconnect(i+1); + } + } + } +} + + static void MtmPostPrepareTransaction(MtmCurrentTrans* x) { @@ -770,14 +793,24 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MtmUnlock(); MtmResetTransaction(x); } else { - time_t timeout = Max(Mtm2PCMinTimeout, (ts->csn - ts->snapshot)*Mtm2PCPrepareRatio/100000); /* usec->msec and percents */ + time_t transTimeout = Max(Mtm2PCMinTimeout, (ts->csn - ts->snapshot)*Mtm2PCPrepareRatio/100000); /* usec->msec and percents */ + time_t timeout = transTimeout < MtmHeartbeatRecvTimeout ? transTimeout : MtmHeartbeatRecvTimeout; + timestamp_t deadline = MtmGetSystemTime() + MSEC_TO_USEC(transTimeout); int result = 0; int nConfigChanges = Mtm->nConfigChanges; /* wait votes from all nodes */ - while (!ts->votingCompleted && !(result & WL_TIMEOUT)) { + while (!ts->votingCompleted) { MtmUnlock(); + MtmWatchdog(); result = WaitLatch(&MyProc->procLatch, WL_LATCH_SET|WL_TIMEOUT, timeout); - ResetLatch(&MyProc->procLatch); + if (result & WL_TIMEOUT) { + if (MtmGetSystemTime() > deadline) { + MtmLock(LW_SHARED); + break; + } + } else { + ResetLatch(&MyProc->procLatch); + } MtmLock(LW_SHARED); } if (!ts->votingCompleted) { @@ -1022,6 +1055,22 @@ void MtmHandleApplyError(void) } +static void MtmDisableNode(int nodeId) +{ + BIT_SET(Mtm->disabledNodeMask, nodeId-1); + Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); + Mtm->nodes[nodeId-1].lastHeartbeat = 0; /* defuse watchdog until first heartbeat is received */ + Mtm->nLiveNodes -= 1; +} + +static void MtmEnableNode(int nodeId) +{ + BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); + Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); + Mtm->nodes[nodeId-1].lastHeartbeat = 0; /* defuse watchdog until first heartbeat is received */ + Mtm->nLiveNodes += 1; +} + void MtmRecoveryCompleted(void) { MTM_LOG1("Recovery of node %d is completed", MtmNodeId); @@ -1116,9 +1165,7 @@ bool MtmRecoveryCaughtUp(int nodeId, XLogRecPtr slotLSN) MTM_LOG1("%d: node %d is caugth-up without locking cluster", MyProcPid, nodeId); /* We are lucky: caugth-up without locking cluster! */ } - BIT_CLEAR(Mtm->disabledNodeMask, nodeId-1); - Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); - Mtm->nLiveNodes += 1; + MtmEnableNode(nodeId); Mtm->nConfigChanges += 1; caughtUp = true; } else if (!BIT_CHECK(Mtm->nodeLockerMask, nodeId-1) @@ -1261,17 +1308,13 @@ bool MtmRefreshClusterStatus(bool nowait) mask = ~clique & (((nodemask_t)1 << Mtm->nAllNodes)-1) & ~Mtm->disabledNodeMask; /* new disabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { - Mtm->nLiveNodes -= 1; - BIT_SET(Mtm->disabledNodeMask, i); - Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); + MtmDisableNode(i+1); } } mask = clique & Mtm->disabledNodeMask; /* new enabled nodes mask */ for (i = 0; mask != 0; i++, mask >>= 1) { if (mask & 1) { - Mtm->nLiveNodes += 1; - BIT_CLEAR(Mtm->disabledNodeMask, i); - Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); + MtmEnableNode(i+1); } } MtmCheckQuorum(); @@ -1316,7 +1359,6 @@ void MtmOnNodeDisconnect(int nodeId) /* Avoid false detection of node failure and prevent node status blinking */ return; } - BIT_SET(Mtm->connectivityMask, nodeId-1); BIT_SET(Mtm->reconnectMask, nodeId-1); RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); @@ -1327,9 +1369,7 @@ void MtmOnNodeDisconnect(int nodeId) if (!MtmRefreshClusterStatus(false)) { MtmLock(LW_EXCLUSIVE); if (!BIT_CHECK(Mtm->disabledNodeMask, nodeId-1)) { - Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); - BIT_SET(Mtm->disabledNodeMask, nodeId-1); - Mtm->nLiveNodes -= 1; + MtmDisableNode(nodeId); MtmCheckQuorum(); /* Interrupt voting for active transaction and abort them */ for (ts = Mtm->transListHead; ts != NULL; ts = ts->next) { @@ -1503,6 +1543,7 @@ static void MtmInitialize() Mtm->nodes[i].lastStatusChangeTime = MtmGetSystemTime(); Mtm->nodes[i].con = MtmConnections[i]; Mtm->nodes[i].flushPos = 0; + Mtm->nodes[i].lastHeartbeat = 0; } PGSemaphoreCreate(&Mtm->votingSemaphore); PGSemaphoreReset(&Mtm->votingSemaphore); @@ -1627,6 +1668,36 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; + DefineCustomIntVariable( + "multimaster.heartbeat_send_timeout", + "Timeout in milliseconds of sending heartbeat messages", + "Period of broadcasting heartbeat messages by abiter to all nodes", + &MtmHeartbeatSendTimeout, + 1000, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + + DefineCustomIntVariable( + "multimaster.heartbeat_recv_timeout", + "Timeout in milliseconds of receiving heartbeat messages", + "If no heartbeat message is received from node within this period, it assumed to be dead", + &MtmHeartbeatRecvTimeout, + 2000, + 1, + INT_MAX, + PGC_BACKEND, + 0, + NULL, + NULL, + NULL + ); + DefineCustomIntVariable( "multimaster.gc_period", "Number of distributed transactions after which garbage collection is started", @@ -2056,9 +2127,7 @@ void MtmDropNode(int nodeId, bool dropSlot) { elog(ERROR, "NodeID %d is out of range [1,%d]", nodeId, Mtm->nLiveNodes); } - Mtm->nodes[nodeId-1].lastStatusChangeTime = MtmGetSystemTime(); - BIT_SET(Mtm->disabledNodeMask, nodeId-1); - Mtm->nLiveNodes -= 1; + MtmDisableNode(nodeId); MtmCheckQuorum(); if (!MtmIsBroadcast()) { @@ -2110,17 +2179,13 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args) if (MtmIsRecoverySession) { MTM_LOG1("%d: Node %d start recovery of node %d", MyProcPid, MtmNodeId, MtmReplicationNodeId); if (!BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { - Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = MtmGetSystemTime(); - BIT_SET(Mtm->disabledNodeMask, MtmReplicationNodeId-1); - Mtm->nLiveNodes -= 1; + MtmDisableNode(MtmReplicationNodeId); MtmCheckQuorum(); } } else if (BIT_CHECK(Mtm->disabledNodeMask, MtmReplicationNodeId-1)) { if (recoveryCompleted) { MTM_LOG1("Node %d consider that recovery of node %d is completed: start normal replication", MtmNodeId, MtmReplicationNodeId); - Mtm->nodes[MtmReplicationNodeId-1].lastStatusChangeTime = MtmGetSystemTime(); - BIT_CLEAR(Mtm->disabledNodeMask, MtmReplicationNodeId-1); - Mtm->nLiveNodes += 1; + MtmEnableNode(MtmReplicationNodeId); MtmCheckQuorum(); } else { elog(ERROR, "Disabled node %d tries to reconnect without recovery", MtmReplicationNodeId); diff --git a/multimaster.h b/multimaster.h index 87a78ce811..e6e3837028 100644 --- a/multimaster.h +++ b/multimaster.h @@ -92,7 +92,8 @@ typedef enum MSG_PREPARE, MSG_PREPARED, MSG_ABORTED, - MSG_STATUS + MSG_STATUS, + MSG_HEARTBEAT } MtmMessageCode; typedef enum @@ -127,6 +128,7 @@ typedef struct timestamp_t lastStatusChangeTime; timestamp_t receiverStartTime; timestamp_t senderStartTime; + timestamp_t lastHeartbeat; int senderPid; int receiverPid; XLogRecPtr flushPos; @@ -218,6 +220,8 @@ extern int MtmReconnectAttempts; extern int MtmKeepaliveTimeout; extern int MtmNodeDisableDelay; extern int MtmTransSpillThreshold; +extern int MtmHeartbeatSendTimeout; +extern int MtmHeartbeatRecvTimeout; extern bool MtmUseDtm; extern HTAB* MtmXid2State; From 02789a0af61a3bb35f6a84988a8f8837a288189b Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 14 May 2016 18:56:05 +0300 Subject: [PATCH 0464/1139] Accept abort transaction at prepare stage --- arbiter.c | 28 +++++++++++++++++----------- multimaster.c | 2 +- 2 files changed, 18 insertions(+), 12 deletions(-) diff --git a/arbiter.c b/arbiter.c index 058485cf3d..42c0d51042 100644 --- a/arbiter.c +++ b/arbiter.c @@ -776,17 +776,23 @@ static void MtmTransReceiver(Datum arg) } break; case MSG_PREPARED: - Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < Mtm->nLiveNodes); - if (msg->csn > ts->csn) { - ts->csn = msg->csn; - MtmSyncClock(ts->csn); - } - if (++ts->nVotes == Mtm->nLiveNodes) { - ts->csn = MtmAssignCSN(); - ts->status = TRANSACTION_STATUS_UNKNOWN; - MtmWakeUpBackend(ts); - } + if (ts->status != TRANSACTION_STATUS_ABORTED) { + Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); + Assert(ts->nVotes < Mtm->nLiveNodes); + if (msg->csn > ts->csn) { + ts->csn = msg->csn; + MtmSyncClock(ts->csn); + } + if (++ts->nVotes == Mtm->nLiveNodes) { + ts->csn = MtmAssignCSN(); + ts->status = TRANSACTION_STATUS_UNKNOWN; + MtmWakeUpBackend(ts); + } + } else { + if (++ts->nVotes == Mtm->nLiveNodes) { + MtmWakeUpBackend(ts); + } + } break; default: Assert(false); diff --git a/multimaster.c b/multimaster.c index 2b4b06d737..0bfcf92f75 100644 --- a/multimaster.c +++ b/multimaster.c @@ -794,7 +794,7 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MtmResetTransaction(x); } else { time_t transTimeout = Max(Mtm2PCMinTimeout, (ts->csn - ts->snapshot)*Mtm2PCPrepareRatio/100000); /* usec->msec and percents */ - time_t timeout = transTimeout < MtmHeartbeatRecvTimeout ? transTimeout : MtmHeartbeatRecvTimeout; + time_t timeout = Min(transTimeout, MtmHeartbeatRecvTimeout); timestamp_t deadline = MtmGetSystemTime() + MSEC_TO_USEC(transTimeout); int result = 0; int nConfigChanges = Mtm->nConfigChanges; From 9b1ae2b18f45d3194837a791c133c03322bb462e Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 14 May 2016 19:40:20 +0300 Subject: [PATCH 0465/1139] Reset latch --- arbiter.c | 2 +- multimaster.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/arbiter.c b/arbiter.c index 42c0d51042..9447812930 100644 --- a/arbiter.c +++ b/arbiter.c @@ -776,9 +776,9 @@ static void MtmTransReceiver(Datum arg) } break; case MSG_PREPARED: + Assert(ts->nVotes < Mtm->nLiveNodes); if (ts->status != TRANSACTION_STATUS_ABORTED) { Assert(ts->status == TRANSACTION_STATUS_IN_PROGRESS); - Assert(ts->nVotes < Mtm->nLiveNodes); if (msg->csn > ts->csn) { ts->csn = msg->csn; MtmSyncClock(ts->csn); diff --git a/multimaster.c b/multimaster.c index 0bfcf92f75..f66dc007f5 100644 --- a/multimaster.c +++ b/multimaster.c @@ -803,13 +803,13 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MtmUnlock(); MtmWatchdog(); result = WaitLatch(&MyProc->procLatch, WL_LATCH_SET|WL_TIMEOUT, timeout); - if (result & WL_TIMEOUT) { + if (result & WL_LATCH_SET) { + ResetLatch(&MyProc->procLatch); + } else if (result & WL_TIMEOUT) { if (MtmGetSystemTime() > deadline) { MtmLock(LW_SHARED); break; } - } else { - ResetLatch(&MyProc->procLatch); } MtmLock(LW_SHARED); } From 4a96cd36b0cdda07b4ec26f15bb0a9663269911b Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 14 May 2016 21:35:48 +0300 Subject: [PATCH 0466/1139] Move watchdog check under lock --- multimaster.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index f66dc007f5..719bc2a669 100644 --- a/multimaster.c +++ b/multimaster.c @@ -800,8 +800,8 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) int nConfigChanges = Mtm->nConfigChanges; /* wait votes from all nodes */ while (!ts->votingCompleted) { - MtmUnlock(); MtmWatchdog(); + MtmUnlock(); result = WaitLatch(&MyProc->procLatch, WL_LATCH_SET|WL_TIMEOUT, timeout); if (result & WL_LATCH_SET) { ResetLatch(&MyProc->procLatch); From 7f5318f5fadb567924368cdb797d121adf55c0a0 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Sat, 14 May 2016 21:45:51 +0300 Subject: [PATCH 0467/1139] Check for transaction status before waiting latch --- multimaster.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 719bc2a669..d7e2bdbd0c 100644 --- a/multimaster.c +++ b/multimaster.c @@ -800,8 +800,13 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) int nConfigChanges = Mtm->nConfigChanges; /* wait votes from all nodes */ while (!ts->votingCompleted) { - MtmWatchdog(); MtmUnlock(); + MtmWatchdog(); + if (ts->status == TRANSACTION_STATUS_ABORTED) { + elog(WARNING, "Transaction %d(%s) is aborted by watchdog", x->xid, x->gid); + x->status = TRANSACTION_STATUS_ABORTED; + return; + } result = WaitLatch(&MyProc->procLatch, WL_LATCH_SET|WL_TIMEOUT, timeout); if (result & WL_LATCH_SET) { ResetLatch(&MyProc->procLatch); From 79cc60b1d433049e94108321179593bd42c600a5 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Sat, 14 May 2016 23:16:41 +0300 Subject: [PATCH 0468/1139] Fix timer initialziation --- arbiter.c | 19 ++++++++++++++----- multimaster.c | 14 +++++++------- 2 files changed, 21 insertions(+), 12 deletions(-) diff --git a/arbiter.c b/arbiter.c index 9447812930..54afd9c41c 100644 --- a/arbiter.c +++ b/arbiter.c @@ -103,6 +103,7 @@ typedef struct static int* sockets; static int gateway; static bool send_heartbeat; +static TimeoutId heartbeat_timer; static void MtmTransSender(Datum arg); static void MtmTransReceiver(Datum arg); @@ -526,7 +527,7 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt buf->data[buf->used].csn = ts->csn; } else { buf->data[buf->used].code = MSG_HEARTBEAT; - MTM_LOG3("Send HEARTBEAT message to node %d from node %d\n", node+1, MtmNodeId); + MTM_LOG3("Send HEARTBEAT to node %d from node %d at %ld\n", node+1, MtmNodeId, USEC_TO_MSEC(MtmGetSystemTime())); } buf->data[buf->used].node = MtmNodeId; buf->data[buf->used].disabledNodeMask = Mtm->disabledNodeMask; @@ -540,8 +541,9 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) int n = 1; for (i = 0; i < Mtm->nAllNodes; i++) { - if (!BIT_CHECK(Mtm->disabledNodeMask, i) && (ts == NULL || TransactionIdIsValid(ts->xids[i]))) { - Assert(i+1 != MtmNodeId); + if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i) + && (ts == NULL || TransactionIdIsValid(ts->xids[i]))) + { MtmAppendBuffer(txBuffer, ts ? ts->xids[i] : InvalidTransactionId, i, ts); n += 1; } @@ -553,6 +555,7 @@ static void MtmSendHeartbeat() { send_heartbeat = true; PGSemaphoreUnlock(&Mtm->votingSemaphore); + //enable_timeout_after(heartbeat_timer, MtmHeartbeatSendTimeout); } @@ -561,15 +564,19 @@ static void MtmTransSender(Datum arg) sigset_t sset; int nNodes = MtmMaxNodes; int i; + MtmBuffer* txBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); + InitializeTimeouts(); + signal(SIGINT, SetStop); signal(SIGQUIT, SetStop); signal(SIGTERM, SetStop); sigfillset(&sset); sigprocmask(SIG_UNBLOCK, &sset, NULL); - RegisterTimeout(USER_TIMEOUT, MtmSendHeartbeat); + heartbeat_timer = RegisterTimeout(USER_TIMEOUT, MtmSendHeartbeat); + enable_timeout_after(heartbeat_timer, MtmHeartbeatSendTimeout); MtmOpenConnections(); @@ -584,6 +591,7 @@ static void MtmTransSender(Datum arg) if (send_heartbeat) { send_heartbeat = false; + enable_timeout_after(heartbeat_timer, MtmHeartbeatSendTimeout); MtmBroadcastMessage(txBuffer, NULL); } /* @@ -725,7 +733,8 @@ static void MtmTransReceiver(Datum arg) Mtm->nodes[msg->node-1].oldestSnapshot = msg->oldestSnapshot; Mtm->nodes[msg->node-1].lastHeartbeat = MtmGetSystemTime(); - if (msg->code == MSG_HEARTBEAT) { + if (msg->code == MSG_HEARTBEAT) { + MTM_LOG3("Receive HEARTBEAT from node %d at %ld", msg->node, USEC_TO_MSEC(MtmGetSystemTime())); continue; } ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); diff --git a/multimaster.c b/multimaster.c index d7e2bdbd0c..baeafa5d5c 100644 --- a/multimaster.c +++ b/multimaster.c @@ -755,8 +755,8 @@ static void MtmWatchdog() if (Mtm->nodes[i].lastHeartbeat != 0 && now > Mtm->nodes[i].lastHeartbeat + MSEC_TO_USEC(MtmHeartbeatRecvTimeout)) { - elog(WARNING, "Disable node %d because last heartbeat was received %d msec ago", - i+1, (int)USEC_TO_MSEC(now - Mtm->nodes[i].lastHeartbeat)); + elog(WARNING, "Disable node %d because last heartbeat was received %d msec ago (%ld)", + i+1, (int)USEC_TO_MSEC(now - Mtm->nodes[i].lastHeartbeat), USEC_TO_MSEC(now)); MtmOnNodeDisconnect(i+1); } } @@ -801,7 +801,7 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) /* wait votes from all nodes */ while (!ts->votingCompleted) { MtmUnlock(); - MtmWatchdog(); + //MtmWatchdog(); if (ts->status == TRANSACTION_STATUS_ABORTED) { elog(WARNING, "Transaction %d(%s) is aborted by watchdog", x->xid, x->gid); x->status = TRANSACTION_STATUS_ABORTED; @@ -1693,7 +1693,7 @@ _PG_init(void) "Timeout in milliseconds of receiving heartbeat messages", "If no heartbeat message is received from node within this period, it assumed to be dead", &MtmHeartbeatRecvTimeout, - 2000, + 100000, 1, INT_MAX, PGC_BACKEND, @@ -1752,7 +1752,7 @@ _PG_init(void) "Minamal amount of time (milliseconds) to wait 2PC confirmation from all nodes", "Timeout for 2PC is calculated as MAX(prepare_time*2pc_prepare_ratio/100,2pc_min_timeout)", &Mtm2PCMinTimeout, - 100000, /* 100 seconds */ + 10000, /* 100 seconds */ 0, INT_MAX, PGC_BACKEND, @@ -1813,8 +1813,8 @@ _PG_init(void) DefineCustomIntVariable( "multimaster.max_recovery_lag", "Maximal lag of replication slot of failed node after which this slot is dropped to avoid transaction log overflow", - "Dropping slog makes it not possible to recover node using logical replication mechanism, it will be ncessary to completely copy content of some other nodes " - "usimg basebackup or similar tool. Zero value of parameter disable droipping slot.", + "Dropping slot makes it not possible to recover node using logical replication mechanism, it will be ncessary to completely copy content of some other nodes " + "using basebackup or similar tool. Zero value of parameter disable dropping slot.", &MtmMaxRecoveryLag, 100000000, 0, From 37a9a6e02b1948a3e5b03c1d8e29722b795c6a5c Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Mon, 16 May 2016 18:42:56 +0300 Subject: [PATCH 0469/1139] Send hearbeat during reconnect --- arbiter.c | 86 ++++++++++++++++++++++++++++++++------------------- multimaster.c | 2 +- 2 files changed, 55 insertions(+), 33 deletions(-) diff --git a/arbiter.c b/arbiter.c index 54afd9c41c..b4cca6f962 100644 --- a/arbiter.c +++ b/arbiter.c @@ -292,6 +292,43 @@ static void MtmSetSocketOptions(int sd) #endif } + + +static void MtmScheduleHeartbeat() +{ + send_heartbeat = true; + PGSemaphoreUnlock(&Mtm->votingSemaphore); +} + +static void MtmSendHeartbeat() +{ + int i; + MtmArbiterMessage msg; + msg.code = MSG_HEARTBEAT; + msg.disabledNodeMask = Mtm->disabledNodeMask; + msg.oldestSnapshot = Mtm->nodes[MtmNodeId-1].oldestSnapshot; + msg.node = MtmNodeId; + + for (i = 0; i < Mtm->nAllNodes; i++) + { + if (sockets[i] >= 0 && !BIT_CHECK(Mtm->disabledNodeMask|Mtm->reconnectMask, i)) + { + MtmWriteSocket(sockets[i], &msg, sizeof(msg)); + } + } + +} + +static void MtmCheckHeartbeat() +{ + if (send_heartbeat) { + send_heartbeat = false; + enable_timeout_after(heartbeat_timer, MtmHeartbeatSendTimeout); + MtmSendHeartbeat(); + } +} + + static int MtmConnectSocket(char const* host, int port, int max_attempts) { struct sockaddr_in sock_inet; @@ -318,6 +355,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) memcpy(&sock_inet.sin_addr, &addrs[i], sizeof sock_inet.sin_addr); do { rc = connect(sd, (struct sockaddr*)&sock_inet, sizeof(sock_inet)); + MtmCheckHeartbeat(); } while (rc < 0 && errno == EINTR); if (rc >= 0 || errno == EINPROGRESS) { @@ -331,7 +369,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) } else { max_attempts -= 1; elog(WARNING, "Arbiter trying to connect to %s:%d: error=%d", host, port, errno); - MtmSleep(5*MtmConnectTimeout); + MtmSleep(MtmConnectTimeout); } continue; } else { @@ -380,14 +418,15 @@ static void MtmOpenConnections() sockets = (int*)palloc(sizeof(int)*nNodes); + for (i = 0; i < nNodes; i++) { + sockets[i] = -1; + } for (i = 0; i < nNodes; i++) { if (i+1 != MtmNodeId && i < Mtm->nAllNodes) { sockets[i] = MtmConnectSocket(Mtm->nodes[i].con.hostName, MtmArbiterPort + i + 1, MtmConnectAttempts); if (sockets[i] < 0) { MtmOnNodeDisconnect(i+1); } - } else { - sockets[i] = -1; } } if (Mtm->nLiveNodes < Mtm->nAllNodes/2+1) { /* no quorum */ @@ -412,6 +451,7 @@ static bool MtmSendToNode(int node, void const* buf, int size) if (sockets[node] >= 0) { elog(WARNING, "Arbiter failed to write to node %d: %d", node+1, errno); close(sockets[node]); + sockets[node] = -1; } sockets[node] = MtmConnectSocket(Mtm->nodes[node].con.hostName, MtmArbiterPort + node + 1, MtmReconnectAttempts); if (sockets[node] < 0) { @@ -518,17 +558,12 @@ static void MtmAppendBuffer(MtmBuffer* txBuffer, TransactionId xid, int node, Mt } buf->data[buf->used].dxid = xid; - if (ts != NULL) { - MTM_LOG3("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d", - messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); - Assert(ts->cmd != MSG_INVALID); - buf->data[buf->used].code = ts->cmd; - buf->data[buf->used].sxid = ts->xid; - buf->data[buf->used].csn = ts->csn; - } else { - buf->data[buf->used].code = MSG_HEARTBEAT; - MTM_LOG3("Send HEARTBEAT to node %d from node %d at %ld\n", node+1, MtmNodeId, USEC_TO_MSEC(MtmGetSystemTime())); - } + MTM_LOG3("Send %s message CSN=%ld to node %d from node %d for global transaction %d/local transaction %d", + messageText[ts->cmd], ts->csn, node+1, MtmNodeId, ts->gtid.xid, ts->xid); + Assert(ts->cmd != MSG_INVALID); + buf->data[buf->used].code = ts->cmd; + buf->data[buf->used].sxid = ts->xid; + buf->data[buf->used].csn = ts->csn; buf->data[buf->used].node = MtmNodeId; buf->data[buf->used].disabledNodeMask = Mtm->disabledNodeMask; buf->data[buf->used].oldestSnapshot = Mtm->nodes[MtmNodeId-1].oldestSnapshot; @@ -541,24 +576,15 @@ static void MtmBroadcastMessage(MtmBuffer* txBuffer, MtmTransState* ts) int n = 1; for (i = 0; i < Mtm->nAllNodes; i++) { - if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i) - && (ts == NULL || TransactionIdIsValid(ts->xids[i]))) + if (i+1 != MtmNodeId && !BIT_CHECK(Mtm->disabledNodeMask, i) && TransactionIdIsValid(ts->xids[i])) { - MtmAppendBuffer(txBuffer, ts ? ts->xids[i] : InvalidTransactionId, i, ts); + MtmAppendBuffer(txBuffer, ts->xids[i], i, ts); n += 1; } } Assert(n == Mtm->nLiveNodes); } -static void MtmSendHeartbeat() -{ - send_heartbeat = true; - PGSemaphoreUnlock(&Mtm->votingSemaphore); - //enable_timeout_after(heartbeat_timer, MtmHeartbeatSendTimeout); -} - - static void MtmTransSender(Datum arg) { sigset_t sset; @@ -575,7 +601,7 @@ static void MtmTransSender(Datum arg) sigfillset(&sset); sigprocmask(SIG_UNBLOCK, &sset, NULL); - heartbeat_timer = RegisterTimeout(USER_TIMEOUT, MtmSendHeartbeat); + heartbeat_timer = RegisterTimeout(USER_TIMEOUT, MtmScheduleHeartbeat); enable_timeout_after(heartbeat_timer, MtmHeartbeatSendTimeout); MtmOpenConnections(); @@ -589,11 +615,7 @@ static void MtmTransSender(Datum arg) PGSemaphoreLock(&Mtm->votingSemaphore); CHECK_FOR_INTERRUPTS(); - if (send_heartbeat) { - send_heartbeat = false; - enable_timeout_after(heartbeat_timer, MtmHeartbeatSendTimeout); - MtmBroadcastMessage(txBuffer, NULL); - } + MtmCheckHeartbeat(); /* * Use shared lock to improve locality, * because all other process modifying this list are using exclusive lock @@ -676,7 +698,7 @@ static void MtmTransReceiver(Datum arg) while (!stop) { #if USE_EPOLL - n = epoll_wait(epollfd, events, nNodes, MtmKeepaliveTimeout/1000); + n = epoll_wait(epollfd, events, nNodes, USEC_TO_MSEC(MtmKeepaliveTimeout)); if (n < 0) { if (errno == EINTR) { continue; diff --git a/multimaster.c b/multimaster.c index baeafa5d5c..579e016f74 100644 --- a/multimaster.c +++ b/multimaster.c @@ -1693,7 +1693,7 @@ _PG_init(void) "Timeout in milliseconds of receiving heartbeat messages", "If no heartbeat message is received from node within this period, it assumed to be dead", &MtmHeartbeatRecvTimeout, - 100000, + 10000, 1, INT_MAX, PGC_BACKEND, From 54cbf4c8766585c320fd4351d9972b2b23a2deb3 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Fri, 20 May 2016 20:14:07 +0300 Subject: [PATCH 0470/1139] Ignore messages from dead nodes --- arbiter.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/arbiter.c b/arbiter.c index b4cca6f962..0f1052d21a 100644 --- a/arbiter.c +++ b/arbiter.c @@ -759,6 +759,11 @@ static void MtmTransReceiver(Datum arg) MTM_LOG3("Receive HEARTBEAT from node %d at %ld", msg->node, USEC_TO_MSEC(MtmGetSystemTime())); continue; } + if (BIT_CHECK(msg->disabledNodeMask, msg->node-1)) { + elog(WARNING, "Ignore message from dead node %d\n", msg->node); + continue; + } + ts = (MtmTransState*)hash_search(MtmXid2State, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); From f947553e92a8234dc60a432d20e15a46c393468b Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 24 May 2016 18:29:59 +0300 Subject: [PATCH 0471/1139] Handle heartbeat timesouts in arbiter receiver --- arbiter.c | 15 +++++++++++---- multimaster.c | 29 +++++++++++------------------ multimaster.h | 6 ++++-- 3 files changed, 26 insertions(+), 24 deletions(-) diff --git a/arbiter.c b/arbiter.c index 0f1052d21a..5571ff18f7 100644 --- a/arbiter.c +++ b/arbiter.c @@ -675,6 +675,8 @@ static void MtmTransReceiver(Datum arg) int nResponses; int i, j, n, rc; MtmBuffer* rxBuffer = (MtmBuffer*)palloc(sizeof(MtmBuffer)*nNodes); + timestamp_t lastHeartbeatCheck = MtmGetSystemTime(); + timestamp_t now; #if USE_EPOLL struct epoll_event* events = (struct epoll_event*)palloc(sizeof(struct epoll_event)*nNodes); @@ -698,7 +700,7 @@ static void MtmTransReceiver(Datum arg) while (!stop) { #if USE_EPOLL - n = epoll_wait(epollfd, events, nNodes, USEC_TO_MSEC(MtmKeepaliveTimeout)); + n = epoll_wait(epollfd, events, nNodes, MtmHeartbeatRecvTimeout); if (n < 0) { if (errno == EINTR) { continue; @@ -717,8 +719,8 @@ static void MtmTransReceiver(Datum arg) do { struct timeval tv; events = inset; - tv.tv_sec = MtmKeepaliveTimeout/USECS_PER_SEC; - tv.tv_usec = MtmKeepaliveTimeout%USECS_PER_SEC; + tv.tv_sec = MtmHeartbeatRecvTimeout/1000; + tv.tv_usec = MtmHeartbeatRecvTimeout%1000*1000; do { n = select(max_fd+1, &events, NULL, NULL, &tv); } while (n < 0 && errno == EINTR); @@ -855,8 +857,13 @@ static void MtmTransReceiver(Datum arg) } } } + now = MtmGetSystemTime(); + if (now > lastHeartbeatCheck + MSEC_TO_USEC(MtmHeartbeatRecvTimeout)) { + MtmWatchdog(); + lastHeartbeatCheck = now; + } if (n == 0 && Mtm->disabledNodeMask != 0) { - /* If timeout is expired and there are didabled nodes, then recheck cluster's state */ + /* If timeout is expired and there are disabled nodes, then recheck cluster's state */ MtmRefreshClusterStatus(false); } } diff --git a/multimaster.c b/multimaster.c index 579e016f74..fbe417265b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -186,7 +186,7 @@ int MtmReplicationNodeId; int MtmArbiterPort; int MtmConnectAttempts; int MtmConnectTimeout; -int MtmKeepaliveTimeout; +int MtmRaftPollDelay; int MtmReconnectAttempts; int MtmNodeDisableDelay; int MtmTransSpillThreshold; @@ -746,7 +746,7 @@ MtmPrePrepareTransaction(MtmCurrentTrans* x) /* * Check heartbeats */ -static void MtmWatchdog() +void MtmWatchdog(void) { int i, n = Mtm->nAllNodes; timestamp_t now = MtmGetSystemTime(); @@ -794,33 +794,27 @@ MtmPostPrepareTransaction(MtmCurrentTrans* x) MtmResetTransaction(x); } else { time_t transTimeout = Max(Mtm2PCMinTimeout, (ts->csn - ts->snapshot)*Mtm2PCPrepareRatio/100000); /* usec->msec and percents */ - time_t timeout = Min(transTimeout, MtmHeartbeatRecvTimeout); - timestamp_t deadline = MtmGetSystemTime() + MSEC_TO_USEC(transTimeout); int result = 0; int nConfigChanges = Mtm->nConfigChanges; /* wait votes from all nodes */ - while (!ts->votingCompleted) { + while (!ts->votingCompleted && !(result & WL_TIMEOUT)) + { MtmUnlock(); - //MtmWatchdog(); + MtmWatchdog(); if (ts->status == TRANSACTION_STATUS_ABORTED) { elog(WARNING, "Transaction %d(%s) is aborted by watchdog", x->xid, x->gid); x->status = TRANSACTION_STATUS_ABORTED; return; } - result = WaitLatch(&MyProc->procLatch, WL_LATCH_SET|WL_TIMEOUT, timeout); + result = WaitLatch(&MyProc->procLatch, WL_LATCH_SET|WL_TIMEOUT, transTimeout); if (result & WL_LATCH_SET) { ResetLatch(&MyProc->procLatch); - } else if (result & WL_TIMEOUT) { - if (MtmGetSystemTime() > deadline) { - MtmLock(LW_SHARED); - break; - } } MtmLock(LW_SHARED); } if (!ts->votingCompleted) { ts->status = TRANSACTION_STATUS_ABORTED; - elog(WARNING, "Transaction is aborted because of %d msec timeout expiration, prepare time %d msec", (int)timeout, (int)USEC_TO_MSEC(ts->csn - x->snapshot)); + elog(WARNING, "Transaction is aborted because of %d msec timeout expiration, prepare time %d msec", (int)transTimeout, (int)USEC_TO_MSEC(ts->csn - x->snapshot)); } else if (nConfigChanges != Mtm->nConfigChanges) { ts->status = TRANSACTION_STATUS_ABORTED; elog(WARNING, "Transaction is aborted because cluster configuration is changed during commit"); @@ -1368,8 +1362,7 @@ void MtmOnNodeDisconnect(int nodeId) BIT_SET(Mtm->reconnectMask, nodeId-1); RaftableSet(psprintf("node-mask-%d", MtmNodeId), &Mtm->connectivityMask, sizeof Mtm->connectivityMask, false); - /* Wait more than socket KEEPALIVE timeout to let other nodes update their statuses */ - MtmSleep(MtmKeepaliveTimeout); + MtmSleep(MtmRaftPollDelay); if (!MtmRefreshClusterStatus(false)) { MtmLock(LW_EXCLUSIVE); @@ -1969,10 +1962,10 @@ _PG_init(void) ); DefineCustomIntVariable( - "multimaster.keepalive_timeout", - "Multimaster keepalive interval for sockets", + "multimaster.raft_poll_delay", + "Multimaster delay of polling cluster state from Raftable after updating local node status", "Timeout in microseconds before polling state of nodes", - &MtmKeepaliveTimeout, + &MtmRaftPollDelay, 1000000, 1, INT_MAX, diff --git a/multimaster.h b/multimaster.h index e6e3837028..2d2d5cab7e 100644 --- a/multimaster.h +++ b/multimaster.h @@ -217,7 +217,7 @@ extern char* MtmDatabaseName; extern int MtmConnectAttempts; extern int MtmConnectTimeout; extern int MtmReconnectAttempts; -extern int MtmKeepaliveTimeout; +extern int MtmRaftPollDelay; extern int MtmNodeDisableDelay; extern int MtmTransSpillThreshold; extern int MtmHeartbeatSendTimeout; @@ -266,6 +266,8 @@ extern void MtmRecoveryCompleted(void); extern void MtmMakeTableLocal(char* schema, char* name); extern void MtmHandleApplyError(void); extern void MtmUpdateLsnMapping(int nodeId, XLogRecPtr endLsn); -extern XLogRecPtr MtmGetFlushPosition(int nodeId); +extern XLogRecPtr MtmGetFlushPosition(int nodeId); +extern void MtmWatchdog(void); + #endif From 45c3a43aef0f76715c4f438316b76f22aa31e745 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 31 May 2016 15:55:56 +0300 Subject: [PATCH 0472/1139] Fix bug in get_cluster_info --- multimaster.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index fbe417265b..2bc5d84400 100644 --- a/multimaster.c +++ b/multimaster.c @@ -460,6 +460,7 @@ MtmAdjustOldestXid(TransactionId xid) MtmTransState *ts = (MtmTransState*)hash_search(MtmXid2State, &xid, HASH_FIND, NULL); MTM_LOG2("%d: MtmAdjustOldestXid(%d): snapshot=%ld, csn=%ld, status=%d", MyProcPid, xid, ts != NULL ? ts->snapshot : 0, ts != NULL ? ts->csn : 0, ts != NULL ? ts->status : -1); Mtm->gcCount = 0; + if (ts != NULL) { oldestSnapshot = ts->snapshot; Mtm->nodes[MtmNodeId-1].oldestSnapshot = oldestSnapshot; @@ -486,6 +487,7 @@ MtmAdjustOldestXid(TransactionId xid) } } } + if (MtmUseDtm) { if (prev != NULL) { @@ -2536,7 +2538,6 @@ mtm_get_cluster_info(PG_FUNCTION_ARGS) tuple = BuildTupleFromCStrings(funcctx->attinmeta, values); PQclear(result); PQfinish(conn); - usrfctx->nodeId += 1; SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple)); } From 1cdcd42bf336f602a2627f5a9ddc50f386b58a46 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 31 May 2016 20:06:28 +0300 Subject: [PATCH 0473/1139] max_parallel_degree = 0 in tests --- Cluster.pm | 1 + 1 file changed, 1 insertion(+) diff --git a/Cluster.pm b/Cluster.pm index c151957af5..e6d6952591 100644 --- a/Cluster.pm +++ b/Cluster.pm @@ -88,6 +88,7 @@ sub configure max_prepared_transactions = 200 max_connections = 200 max_worker_processes = 100 + max_parallel_degree = 0 wal_level = logical fsync = off max_wal_senders = 10 From e3ef99cab223918a37c9be91813861c012208a3e Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 1 Jun 2016 17:53:47 +0300 Subject: [PATCH 0474/1139] Do not change cluster status because of pglogical errors --- arbiter.c | 2 +- multimaster.c | 4 ++-- pglogical_receiver.c | 16 ++++++++-------- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/arbiter.c b/arbiter.c index 5571ff18f7..3f3fa8d2a4 100644 --- a/arbiter.c +++ b/arbiter.c @@ -401,7 +401,7 @@ static int MtmConnectSocket(char const* host, int port, int max_attempts) /* Some node considered that I am dead, so switch to recovery mode */ if (BIT_CHECK(resp.disabledNodeMask, MtmNodeId-1)) { - elog(WARNING, "Node %d think that I am dead", resp.node); + elog(WARNING, "Node %d thinks that I was dead", resp.node); BIT_SET(Mtm->disabledNodeMask, MtmNodeId-1); MtmSwitchClusterMode(MTM_RECOVERY); } diff --git a/multimaster.c b/multimaster.c index 2bc5d84400..620a5da2d6 100644 --- a/multimaster.c +++ b/multimaster.c @@ -2145,7 +2145,7 @@ MtmOnProcExit(int code, Datum arg) if (MtmReplicationNodeId > 0) { Mtm->nodes[MtmReplicationNodeId-1].senderPid = -1; MTM_LOG1("WAL-sender to %d is terminated", MtmReplicationNodeId); - MtmOnNodeDisconnect(MtmReplicationNodeId); + /* MtmOnNodeDisconnect(MtmReplicationNodeId); */ } } @@ -2241,7 +2241,7 @@ MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args) { if (MtmReplicationNodeId >= 0) { MTM_LOG1("Logical replication to node %d is stopped", MtmReplicationNodeId); - MtmOnNodeDisconnect(MtmReplicationNodeId); + /* MtmOnNodeDisconnect(MtmReplicationNodeId); */ MtmReplicationNodeId = -1; /* defuse on_proc_exit hook */ } } diff --git a/pglogical_receiver.c b/pglogical_receiver.c index ab46cf4f6c..8a2a1f93c1 100644 --- a/pglogical_receiver.c +++ b/pglogical_receiver.c @@ -275,7 +275,7 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); ereport(ERROR, (errmsg("%s: Could not create logical slot", worker_proc))); - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } } @@ -317,7 +317,7 @@ pglogical_receiver_main(Datum main_arg) PQclear(res); ereport(WARNING, (errmsg("%s: Could not start logical replication", worker_proc))); - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } PQclear(res); @@ -408,7 +408,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: streaming header too small: %d", worker_proc, rc))); - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } replyRequested = copybuf[pos]; @@ -429,7 +429,7 @@ pglogical_receiver_main(Datum main_arg) /* Leave is feedback is not sent properly */ if (!sendFeedback(conn, now, nodeId)) { - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } } @@ -439,7 +439,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Incorrect streaming header", worker_proc))); - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } @@ -548,7 +548,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Incorrect status received... Leaving.", worker_proc))); - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } @@ -557,7 +557,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Data remaining on the socket... Leaving.", worker_proc))); - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } continue; @@ -576,7 +576,7 @@ pglogical_receiver_main(Datum main_arg) { ereport(LOG, (errmsg("%s: Failure while receiving changes...", worker_proc))); - MtmOnNodeDisconnect(nodeId); + /* MtmOnNodeDisconnect(nodeId); */ proc_exit(1); } } From 3aa2630b929ba24942600d1af8412b18a2e44700 Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Wed, 1 Jun 2016 18:40:40 +0300 Subject: [PATCH 0475/1139] Fixes #2: add GetTransactionStateSize, SerializeTransactionState and DeserializeTransactionState to XTM API --- multimaster.c | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 620a5da2d6..94f214d841 100644 --- a/multimaster.c +++ b/multimaster.c @@ -130,6 +130,10 @@ static TransactionId MtmAdjustOldestXid(TransactionId xid); static bool MtmDetectGlobalDeadLock(PGPROC* proc); static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int nSubxids); static char const* MtmGetName(void); +static size_t MtmGetTransactionStateSize(void); +static void MtmSerializeTransactionState(void* ctx); +static void MtmDeserializeTransactionState(void* ctx); + static void MtmCheckClusterLock(void); static void MtmCheckSlots(void); static void MtmAddSubtransactions(MtmTransState* ts, TransactionId *subxids, int nSubxids); @@ -163,7 +167,10 @@ static TransactionManager MtmTM = { PgGetGlobalTransactionId, MtmXidInMVCCSnapshot, MtmDetectGlobalDeadLock, - MtmGetName + MtmGetName, + MtmGetTransactionStateSize, + MtmSerializeTransactionState, + MtmDeserializeTransactionState }; char const* const MtmNodeStatusMnem[] = @@ -322,6 +329,26 @@ static char const* MtmGetName(void) return MULTIMASTER_NAME; } +static size_t +MtmGetTransactionStateSize(void) +{ + return sizeof(MtmTx); +} + +static void +MtmSerializeTransactionState(void* ctx) +{ + memcpy(ctx, &MtmTx, sizeof(MtmTx)); +} + +static void +MtmDeserializeTransactionState(void* ctx) +{ + memcpy(&MtmTx, ctx, sizeof(MtmTx)); +} + + + /* * ------------------------------------------- * Visibility&snapshots From 14a9ad8e7b678c82875a961385812e9e5125f81c Mon Sep 17 00:00:00 2001 From: Konstantin Knizhnik Date: Tue, 7 Jun 2016 10:44:58 +0300 Subject: [PATCH 0476/1139] Support unique sequences through XTM --- multimaster.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/multimaster.c b/multimaster.c index 94f214d841..a7fb052bb1 100644 --- a/multimaster.c +++ b/multimaster.c @@ -133,6 +133,7 @@ static char const* MtmGetName(void); static size_t MtmGetTransactionStateSize(void); static void MtmSerializeTransactionState(void* ctx); static void MtmDeserializeTransactionState(void* ctx); +static void MtmInitializeSequence(int64* start, int64* step); static void MtmCheckClusterLock(void); static void MtmCheckSlots(void); @@ -170,7 +171,8 @@ static TransactionManager MtmTM = { MtmGetName, MtmGetTransactionStateSize, MtmSerializeTransactionState, - MtmDeserializeTransactionState + MtmDeserializeTransactionState, + MtmInitializeSequence }; char const* const MtmNodeStatusMnem[] = @@ -348,6 +350,13 @@ MtmDeserializeTransactionState(void* ctx) } +static void +MtmInitializeSequence(int64* start, int64* step) +{ + *start = MtmNodeId; + *step = MtmMaxNodes; +} + /* * ------------------------------------------- From 6ba3da374360dcef950213bb3cd09e42fc8d6dd8 Mon Sep 17 00:00:00 2001 From: Stas Kelvich Date: Tue, 7 Jun 2016 14:31:51 +0300 Subject: [PATCH 0477/1139] network recovery tests infrastructure. #6 --- tests2/.gitignore | 4 + tests2/Dockerfile | 60 +++++++++++++++ tests2/Vagrantfile | 42 +++++++++++ tests2/blockade.yml | 32 ++++++++ tests2/docker-entrypoint.sh | 95 +++++++++++++++++++++++ tests2/lib/__init__.py | 0 tests2/lib/bank_client.py | 147 ++++++++++++++++++++++++++++++++++++ tests2/lib/event_history.py | 87 +++++++++++++++++++++ tests2/requirements.txt | 2 + tests2/test_recovery.py | 69 +++++++++++++++++ 10 files changed, 538 insertions(+) create mode 100644 tests2/.gitignore create mode 100644 tests2/Dockerfile create mode 100644 tests2/Vagrantfile create mode 100644 tests2/blockade.yml create mode 100755 tests2/docker-entrypoint.sh create mode 100644 tests2/lib/__init__.py create mode 100644 tests2/lib/bank_client.py create mode 100644 tests2/lib/event_history.py create mode 100644 tests2/requirements.txt create mode 100644 tests2/test_recovery.py diff --git a/tests2/.gitignore b/tests2/.gitignore new file mode 100644 index 0000000000..a913ac969f --- /dev/null +++ b/tests2/.gitignore @@ -0,0 +1,4 @@ +.blockade +.vagrant +*.swp +*.pyc diff --git a/tests2/Dockerfile b/tests2/Dockerfile new file mode 100644 index 0000000000..5f827746fc --- /dev/null +++ b/tests2/Dockerfile @@ -0,0 +1,60 @@ +# vim:set ft=dockerfile: +FROM debian:jessie + +# explicitly set user/group IDs +RUN groupadd -r postgres --gid=999 && useradd -r -g postgres --uid=999 postgres + +# make the "en_US.UTF-8" locale so postgres will be utf-8 enabled by default +RUN apt-get update && apt-get install -y locales && rm -rf /var/lib/apt/lists/* \ + && localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8 +ENV LANG en_US.utf8 + +# use git to fetch sources +RUN apt-get update \ + && apt-get install -y git \ + && rm -rf /var/lib/apt/lists/* + +# postgres build deps +RUN apt-get update && apt-get install -y \ + make \ + gcc \ + libreadline-dev \ + bison \ + flex \ + zlib1g-dev \ + && rm -rf /var/lib/apt/lists/* + +RUN mkdir /pg +RUN chown postgres:postgres /pg + +USER postgres +WORKDIR /pg +ENV CFLAGS -O0 +RUN git clone https://github.com/postgrespro/postgres_cluster.git --depth 1 +WORKDIR /pg/postgres_cluster +RUN ./configure --enable-cassert --enable-debug --prefix=/usr/local/ +RUN make -j 4 + +USER root +RUN make install +RUN cd /pg/postgres_cluster/contrib/pg_tsdtm && make install +RUN cd /pg/postgres_cluster/contrib/raftable && make install +RUN cd /pg/postgres_cluster/contrib/mmts && make install +RUN cd /pg/postgres_cluster/contrib/postgres_fdw && make install +RUN mkdir -p /var/lib/postgresql/data && chown -R postgres /var/lib/postgresql/data +RUN mkdir -p /run/postgresql && chown -R postgres /run/postgresql + +USER postgres +ENV PATH /usr/local/bin:$PATH +ENV PGDATA /var/lib/postgresql/data +VOLUME /var/lib/postgresql/data + +COPY docker-entrypoint.sh / + +ENTRYPOINT ["/docker-entrypoint.sh"] + +EXPOSE 5432 +CMD ["postgres"] + + + diff --git a/tests2/Vagrantfile b/tests2/Vagrantfile new file mode 100644 index 0000000000..9ae2cc22da --- /dev/null +++ b/tests2/Vagrantfile @@ -0,0 +1,42 @@ +script = <

    • 6;s^9=5F@A)|Y(v%m4rjEPh#9j}I@7 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 literal 478837 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�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 J$gwp<{}21a+tC03 diff --git a/tests/dtmbench.cpp b/tests/dtmbench.cpp index 988ee68ed1..27c1f38b40 100644 --- a/tests/dtmbench.cpp +++ b/tests/dtmbench.cpp @@ -179,7 +179,7 @@ void* writer(void* arg) void initializeDatabase() { connection conn(cfg.connections[0]); - +#if 0 printf("creating extension\n"); { nontransaction txn(conn); @@ -197,7 +197,7 @@ void initializeDatabase() txn.commit(); } printf("table t created\n"); - +#endif printf("inserting stuff into t\n"); { work txn(conn); From f0b478b8fb0e0a1620eb90738eab30bf31c0dd45 Mon Sep 17 00:00:00 2001 From: knizhnik Date: Fri, 12 Feb 2016 00:07:25 +0300 Subject: [PATCH 0252/1139] reduce in-doubt stage in MMTS --- arbiter.c | 94 ++++++++++++++++++++++++++++++--------------- multimaster.c | 11 ++---- multimaster.h | 1 + tests/dtmbench | Bin 451933 -> 478845 bytes tests/dtmbench.cpp | 2 - 5 files changed, 68 insertions(+), 40 deletions(-) diff --git a/arbiter.c b/arbiter.c index 6a04a1f7bb..0567247254 100644 --- a/arbiter.c +++ b/arbiter.c @@ -76,11 +76,20 @@ #define MAX_ROUTES 16 #define BUFFER_SIZE 1024 +typedef enum +{ + MSG_PREPARE, + MSG_COMMIT, + MSG_ABORT +} MessageCode; + + typedef struct { + MessageCode code; /* Message code: MSG_PREPARE, MSG_COMMIT, MSG_ABORT + int node; /* Sender node ID */ TransactionId dxid; /* Transaction ID at destination node */ TransactionId sxid; /* Transaction IO at sender node */ - int node; /* Sender node ID */ csn_t csn; /* local CSN in case of sending data from replica to master, global CSN master->replica */ } DtmCommitMessage; @@ -100,7 +109,7 @@ static BackgroundWorker DtmSender = { "mm-sender", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, - 1, /* restrart in one second (is it possible to restort immediately?) */ + 1, /* restart in one second (is it possible to restart immediately?) */ DtmTransSender }; @@ -108,7 +117,7 @@ static BackgroundWorker DtmRecevier = { "mm-receiver", BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, /* do not need connection to the database */ BgWorkerStart_ConsistentState, - 1, /* restrart in one second (is it possible to restort immediately?) */ + 1, /* restart in one second (is it possible to restart immediately?) */ DtmTransReceiver }; @@ -300,6 +309,25 @@ static int readSocket(int sd, void* buf, int buf_size) return rc; } +static bool IsCoordinator(DtmTransState* ts) +{ + return ts->dsid.node == MMNodeId; +} + +static void DtmAppendBuffer(MessageCode code, DtmBuffer* txBuffer, TransactionId xid, int node, DtmTransState* ts) +{ + DtmBuffer* buf = &txBuffer[node]; + if (buf->used == BUFFER_SIZE) { + writeSocket(sockets[node], buf->data, buf->used*sizeof(DtmCommitMessage)); + buf->used = 0; + } + buf->data[buf->used].code = code; + buf->data[buf->used].dxid = xid; + buf->data[buf->used].sxid = ts->xid; + buf->data[buf->used].csn = ts->status == TRANSACTION_STATUS_ABORTED ? INVALID_CSN : ts->csn; + buf->data[buf->used].node = MMNodeId; + buf->used += 1; +} static void DtmTransSender(Datum arg) { @@ -327,38 +355,18 @@ static void DtmTransSender(Datum arg) SpinLockRelease(&ds->votingSpinlock); for (; ts != NULL; ts = ts->nextVoting) { - if (ts->gtid.node == MMNodeId) { - /* Coordinator is broadcasting confirmations to replicas */ + if (IsCoordinator(ts)) { + /* Coordinator is broadcasting PREPARE message to replicas */ for (i = 0; i < nNodes; i++) { if (TransactionIdIsValid(ts->xids[i])) { - if (txBuffer[i].used == BUFFER_SIZE) { - writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); - txBuffer[i].used = 0; - } - DTM_TRACE("Send notification %ld to replica %d from coordinator %d for transaction %d (local transaction %d)\n", - ts->csn, i+1, MMNodeId, ts->xid, ts->xids[i]); - - txBuffer[i].data[txBuffer[i].used].dxid = ts->xids[i]; - txBuffer[i].data[txBuffer[i].used].sxid = ts->xid; - txBuffer[i].data[txBuffer[i].used].csn = ts->csn; - txBuffer[i].data[txBuffer[i].used].node = MMNodeId; - txBuffer[i].used += 1; + DtmAppendBuffer(CMD_PREPARE, txBuffer, ts->xids[i], i, ts); } } } else { - /* Replica is notifying master */ - i = ts->gtid.node-1; - if (txBuffer[i].used == BUFFER_SIZE) { - writeSocket(sockets[i], txBuffer[i].data, txBuffer[i].used*sizeof(DtmCommitMessage)); - txBuffer[i].used = 0; - } + /* Replica is notifying master that it is ready to PREPARE */ DTM_TRACE("Send notification %ld to coordinator %d from node %d for transaction %d (local transaction %d)\n", ts->csn, ts->gtid.node, MMNodeId, ts->gtid.xid, ts->xid); - txBuffer[i].data[txBuffer[i].used].dxid = ts->gtid.xid; - txBuffer[i].data[txBuffer[i].used].sxid = ts->xid; - txBuffer[i].data[txBuffer[i].used].node = MMNodeId; - txBuffer[i].data[txBuffer[i].used].csn = ts->csn; - txBuffer[i].used += 1; + DtmAppendBuffer(CMD_PREPARE, txBuffer, ts->gtid.xid, ts->gtid.node-1, ts); } } for (i = 0; i < nNodes; i++) { @@ -431,9 +439,33 @@ static void DtmTransReceiver(Datum arg) DtmCommitMessage* msg = &rxBuffer[i].data[j]; DtmTransState* ts = (DtmTransState*)hash_search(xid2state, &msg->dxid, HASH_FIND, NULL); Assert(ts != NULL); - if (msg->csn > ts->csn) { - ts->csn = msg->csn; - } + switch (msg->code) { + case CMD_PREPARE: + if (IsCoordinator(ts)) { + switch (msg->command) { + case CMD_PREPARE: + + if (ts->state == TRANSACTION_STATUS_IN_PROGRESS: + /* transaction is in-prepared stage (in-doubt): calculate max CSN */ + if (msg->csn > ts->csn) { + ts->csn = msg->csn; + } + Assert(ts->nVotes < dtm->nNodes); + if (++ts->nVotes == dtm->nNodes) { /* receive responses from all nodes */ + ts->status = TRANSACTION_STATUS_COMMIT; + + if (ts->state == TRANSACTION_STATUS_UNKNOWN) { + /* All nodes are ready to prepare: switch transaction to in-doubt state */ + ts->csn = dtm_get_csn(); + ts->status = TRANSACTION_STATUS_IN_PROGRESS; + /* and broadcast PREPARE message */ + MMSendNotificationMessage(ts); + } else if (ts->state == CMD_ABORT) { + ts->status = TRANSACTION_STATUS_ABORTED; + + } else { + Assert(ts->state == TRANSACTION_STATUS_IN_PROGRESS); + Assert((unsigned)(msg->node-1) <= (unsigned)nNodes); ts->xids[msg->node-1] = msg->sxid; DTM_TRACE("Receive response %ld for transaction %d votes %d from node %d (transaction %d)\n", diff --git a/multimaster.c b/multimaster.c index d7b3dfb28c..0f1a95529b 100644 --- a/multimaster.c +++ b/multimaster.c @@ -342,7 +342,6 @@ DtmAdjustOldestXid(TransactionId xid) ts = (DtmTransState*)hash_search(xid2state, &xid, HASH_FIND, NULL); if (ts != NULL) { timestamp_t cutoff_time = ts->csn - DtmVacuumDelay*USEC; - #if 0 for (ts = dtm->transListHead; ts != NULL && ts->csn < cutoff_time; prev = ts, ts = ts->next) { Assert(ts->status == TRANSACTION_STATUS_COMMITTED || ts->status == TRANSACTION_STATUS_ABORTED); if (prev != NULL) { @@ -350,7 +349,6 @@ DtmAdjustOldestXid(TransactionId xid) hash_search(xid2state, &prev->xid, HASH_REMOVE, NULL); } } - #endif } if (prev != NULL) { dtm->transListHead = prev; @@ -477,8 +475,7 @@ DtmEndTransaction(DtmCurrentTrans* x) x->gtid.xid = InvalidTransactionId; } -static void -SendNotificationMessage(DtmTransState* ts) +void MMSendNotificationMessage(DtmTransState* ts) { DtmTransState* votingList; @@ -551,7 +548,7 @@ DtmFinishTransaction(TransactionId xid, int nsubxids, TransactionId *subxids, Xi ts->status = status; } if (dtmTx.isReplicated) { - SendNotificationMessage(ts); + MMSendNotificationMessage(ts); } } LWLockRelease(dtm->hashLock); @@ -1026,11 +1023,11 @@ MMVoteForTransaction(DtmTransState* ts) Assert(ts->nVotes == dtm->nNodes); /* ... and then send notifications to replicas */ - SendNotificationMessage(ts); + MMSendNotificationMessage(ts); } else { /* I am replica: first notify coordinator... */ ts->nVotes = dtm->nNodes-1; /* I just need one confirmation from coordinator */ - SendNotificationMessage(ts); + MMSendNotificationMessage(ts); /* ... and wait response from it */ DTM_TRACE("Node %d waiting latch...\n", MMNodeId); WaitLatch(&MyProc->procLatch, WL_LATCH_SET, -1); diff --git a/multimaster.h b/multimaster.h index 35bb32d984..6ce80c4e49 100644 --- a/multimaster.h +++ b/multimaster.h @@ -73,6 +73,7 @@ extern void MMReceiverStarted(void); extern void MMExecute(void* work, int size); extern void MMExecutor(int id, void* work, size_t size); extern HTAB* MMCreateHash(void); +extern void MMSendNotificationMessage(DtmTransState* ts); extern DtmState* MMGetState(void); #endif diff --git a/tests/dtmbench b/tests/dtmbench index 875fabc51f30fc68b5894e0683e2c687cfbd8347..4bb7c73ec79f5e615829d73329d80897cb0c426f 100755 GIT binary patch literal 478845 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 z�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