git.postgresql.org Git - postgresql.git/commitdiff

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml

index 8c56b134a842273503c77406f2b896243e29f128..ecd9aa73ef7665e3907a05ef36b741885c1fd22b 100644 (file)

--- a/doc/src/sgml/config.sgml

+++ b/doc/src/sgml/config.sgml

</listitem>

</varlistentry>

- <varlistentry id="guc-force-parallel-mode" xreflabel="force_parallel_mode">

- <term><varname>force_parallel_mode</varname> (<type>enum</type>)

+ <varlistentry id="guc-debug-parallel-query" xreflabel="debug_parallel_query">

+ <term><varname>debug_parallel_query</varname> (<type>enum</type>)

<indexterm>

- <primary><varname>force_parallel_mode</varname> configuration parameter</primary>

+ <primary><varname>debug_parallel_query</varname> configuration parameter</primary>

</indexterm>

</term>

<listitem>

<para>

Allows the use of parallel queries for testing purposes even in cases

where no performance benefit is expected.

- The allowed values of <varname>force_parallel_mode</varname> are

+ The allowed values of <varname>debug_parallel_query</varname> are

<literal>off</literal> (use parallel mode only when it is expected to improve

performance), <literal>on</literal> (force parallel query for all queries

for which it is thought to be safe), and <literal>regress</literal> (like

diff --git a/doc/src/sgml/regress.sgml b/doc/src/sgml/regress.sgml

index 117d097390ca07aa2658f2de15b7f0a8d55d2432..a08c7a78af83a7cf77fd25fe4d358ffb138b178c 100644 (file)

--- a/doc/src/sgml/regress.sgml

+++ b/doc/src/sgml/regress.sgml

set in the <varname>PGOPTIONS</varname> environment variable (for settings

that allow this):

<screen>

-make check PGOPTIONS="-c force_parallel_mode=regress -c work_mem=50MB"

+make check PGOPTIONS="-c debug_parallel_query=regress -c work_mem=50MB"

</screen>

When running against a temporary installation, custom settings can also be

set by supplying a pre-written <filename>postgresql.conf</filename>:

diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c

index 9e3ec0d5d8a2d06e43237be352dfd118dd60cb31..b26f2a64fbcb4de5b7384ca99aa21b181daf41b8 100644 (file)

--- a/src/backend/access/transam/parallel.c

+++ b/src/backend/access/transam/parallel.c

* If desired, add a context line to show that this is a

* message propagated from a parallel worker. Otherwise, it

* can sometimes be confusing to understand what actually

- * happened. (We don't do this in FORCE_PARALLEL_REGRESS mode

+ * happened. (We don't do this in DEBUG_PARALLEL_REGRESS mode

* because it causes test-result instability depending on

* whether a parallel worker is actually used or not.)

*/

- if (force_parallel_mode != FORCE_PARALLEL_REGRESS)

+ if (debug_parallel_query != DEBUG_PARALLEL_REGRESS)

{

if (edata.context)

edata.context = psprintf("%s\n%s", edata.context,

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c

index fbbf28cf0637b46d8de9a47b778b977f62b992b4..e57bda7b62dc66debf25dacf315044312e08c696 100644 (file)

--- a/src/backend/commands/explain.c

+++ b/src/backend/commands/explain.c

/*

* Sometimes we mark a Gather node as "invisible", which means that it's

* not to be displayed in EXPLAIN output. The purpose of this is to allow

- * running regression tests with force_parallel_mode=regress to get the

- * same results as running the same tests with force_parallel_mode=off.

+ * running regression tests with debug_parallel_query=regress to get the

+ * same results as running the same tests with debug_parallel_query=off.

* Such marking is currently only supported on a Gather at the top of the

* plan. We skip that node, and we must also hide per-worker detail data

* further down in the plan tree.

diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c

index 4c17407e5dfa728976b6a332942b8ef159e0dbb8..7afd434c601587c80a3670de008f782d7e35e2d3 100644 (file)

--- a/src/backend/optimizer/plan/planmain.c

+++ b/src/backend/optimizer/plan/planmain.c

* Anything parallel-restricted in the query tlist will be

* dealt with later.) This is normally pretty silly, because

* a Result-only plan would never be interesting to

- * parallelize. However, if force_parallel_mode is on, then

+ * parallelize. However, if debug_parallel_query is on, then

* we want to execute the Result in a parallel worker if

* possible, so we must do this.

*/

if (root->glob->parallelModeOK &&

- force_parallel_mode != FORCE_PARALLEL_OFF)

+ debug_parallel_query != DEBUG_PARALLEL_OFF)

final_rel->consider_parallel =

is_parallel_safe(root, parse->jointree->quals);

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c

index db5ff6fdca443c0e2f2f5020b4cb47752f594429..a1873ce26d4335d3438bc92635d6908a6c7e62f9 100644 (file)

--- a/src/backend/optimizer/plan/planner.c

+++ b/src/backend/optimizer/plan/planner.c

/* GUC parameters */

double cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION;

-int force_parallel_mode = FORCE_PARALLEL_OFF;

+int debug_parallel_query = DEBUG_PARALLEL_OFF;

bool parallel_leader_participation = true;

/* Hook for plugins to get control in planner() */

* true during plan creation if a Gather or Gather Merge plan is actually

* created (cf. create_gather_plan, create_gather_merge_plan).

*

- * However, if force_parallel_mode = on or force_parallel_mode = regress,

- * then we impose parallel mode whenever it's safe to do so, even if the

- * final plan doesn't use parallelism. It's not safe to do so if the

- * query contains anything parallel-unsafe; parallelModeOK will be false

- * in that case. Note that parallelModeOK can't change after this point.

- * Otherwise, everything in the query is either parallel-safe or

+ * However, if debug_parallel_query = on or debug_parallel_query =

+ * regress, then we impose parallel mode whenever it's safe to do so, even

+ * if the final plan doesn't use parallelism. It's not safe to do so if

+ * the query contains anything parallel-unsafe; parallelModeOK will be

+ * false in that case. Note that parallelModeOK can't change after this

+ * point. Otherwise, everything in the query is either parallel-safe or

* parallel-restricted, and in either case it should be OK to impose

* parallel-mode restrictions. If that ends up breaking something, then

* either some function the user included in the query is incorrectly

* parallel-unsafe, or else the query planner itself has a bug.

*/

glob->parallelModeNeeded = glob->parallelModeOK &&

- (force_parallel_mode != FORCE_PARALLEL_OFF);

+ (debug_parallel_query != DEBUG_PARALLEL_OFF);

/* Determine what fraction of the plan is likely to be scanned */

if (cursorOptions & CURSOR_OPT_FAST_PLAN)

* Optionally add a Gather node for testing purposes, provided this is

* actually a safe thing to do.

*/

- if (force_parallel_mode != FORCE_PARALLEL_OFF && top_plan->parallel_safe)

+ if (debug_parallel_query != DEBUG_PARALLEL_OFF && top_plan->parallel_safe)

{

Gather *gather = makeNode(Gather);

gather->plan.righttree = NULL;

gather->num_workers = 1;

gather->single_copy = true;

- gather->invisible = (force_parallel_mode == FORCE_PARALLEL_REGRESS);

+ gather->invisible = (debug_parallel_query == DEBUG_PARALLEL_REGRESS);

/*

* Since this Gather has no parallel-aware descendants to signal to,

diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c

index bc83f3577d7bbc9f824c5ca6c54a204d5d89365c..51e07d55825c773396e7cce7d3cfa9a63b288840 100644 (file)

--- a/src/backend/utils/misc/guc.c

+++ b/src/backend/utils/misc/guc.c

static const char *const map_old_guc_names[] = {

"sort_mem", "work_mem",

"vacuum_mem", "maintenance_work_mem",

+ "force_parallel_mode", "debug_parallel_query",

NULL

};

diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c

index b46e3b8c558289fcf5d9c1bdff62dc8c0ab9f073..43b9d926600e8ce65d7e2d2d449df5d6c4008866 100644 (file)

--- a/src/backend/utils/misc/guc_tables.c

+++ b/src/backend/utils/misc/guc_tables.c

{NULL, 0, false}

};

-static const struct config_enum_entry force_parallel_mode_options[] = {

- {"off", FORCE_PARALLEL_OFF, false},

- {"on", FORCE_PARALLEL_ON, false},

- {"regress", FORCE_PARALLEL_REGRESS, false},

- {"true", FORCE_PARALLEL_ON, true},

- {"false", FORCE_PARALLEL_OFF, true},

- {"yes", FORCE_PARALLEL_ON, true},

- {"no", FORCE_PARALLEL_OFF, true},

- {"1", FORCE_PARALLEL_ON, true},

- {"0", FORCE_PARALLEL_OFF, true},

+static const struct config_enum_entry debug_parallel_query_options[] = {

+ {"off", DEBUG_PARALLEL_OFF, false},

+ {"on", DEBUG_PARALLEL_ON, false},

+ {"regress", DEBUG_PARALLEL_REGRESS, false},

+ {"true", DEBUG_PARALLEL_ON, true},

+ {"false", DEBUG_PARALLEL_OFF, true},

+ {"yes", DEBUG_PARALLEL_ON, true},

+ {"no", DEBUG_PARALLEL_OFF, true},

+ {"1", DEBUG_PARALLEL_ON, true},

+ {"0", DEBUG_PARALLEL_OFF, true},

{NULL, 0, false}

};

},

{

- {"force_parallel_mode", PGC_USERSET, DEVELOPER_OPTIONS,

- gettext_noop("Forces use of parallel query facilities."),

- gettext_noop("If possible, run query using a parallel worker and with parallel restrictions."),

+ {"debug_parallel_query", PGC_USERSET, DEVELOPER_OPTIONS,

+ gettext_noop("Forces the planner's use parallel query nodes."),

+ gettext_noop("This can be useful for testing the parallel query infrastructure "

+ "by forcing the planner to generate plans which contains nodes "

+ "which perform tuple communication between workers and the main process."),

GUC_NOT_IN_SAMPLE | GUC_EXPLAIN

},

- &force_parallel_mode,

- FORCE_PARALLEL_OFF, force_parallel_mode_options,

+ &debug_parallel_query,

+ DEBUG_PARALLEL_OFF, debug_parallel_query_options,

NULL, NULL, NULL

},

diff --git a/src/include/optimizer/optimizer.h b/src/include/optimizer/optimizer.h

index b6df013c213276c26da63181bbfe6609db2fa9a2..514746c58523bf142673a7c3d57d020d8357ebc9 100644 (file)

--- a/src/include/optimizer/optimizer.h

+++ b/src/include/optimizer/optimizer.h

/* in plan/planner.c: */

-/* possible values for force_parallel_mode */

+/* possible values for debug_parallel_query */

typedef enum

{

- FORCE_PARALLEL_OFF,

- FORCE_PARALLEL_ON,

- FORCE_PARALLEL_REGRESS

-} ForceParallelMode;

+ DEBUG_PARALLEL_OFF,

+ DEBUG_PARALLEL_ON,

+ DEBUG_PARALLEL_REGRESS

+} DebugParallelMode;

/* GUC parameters */

-extern PGDLLIMPORT int force_parallel_mode;

+extern PGDLLIMPORT int debug_parallel_query;

extern PGDLLIMPORT bool parallel_leader_participation;

extern struct PlannedStmt *planner(Query *parse, const char *query_string,

diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c

index 70a002a0f6af68b65723c1686ad4579852a6de02..ffd6d2e3bc3b46de0cfa7929d58b503e27789ce3 100644 (file)

--- a/src/pl/plpgsql/src/pl_exec.c

+++ b/src/pl/plpgsql/src/pl_exec.c

/*

* Ordinarily, the plan node should be a simple Result. However, if

- * force_parallel_mode is on, the planner might've stuck a Gather node

+ * debug_parallel_query is on, the planner might've stuck a Gather node

* atop that. The simplest way to deal with this is to look through the

* Gather node. The Gather node's tlist would normally contain a Var

* referencing the child node's output, but it could also be a Param, or

diff --git a/src/test/isolation/expected/deadlock-parallel.out b/src/test/isolation/expected/deadlock-parallel.out

index 6fe5e24a02b0a70a1195f985d5f166ca7e7a3321..9083673c88017ee5aea9433ca3d6603e2e12dd1a 100644 (file)

--- a/src/test/isolation/expected/deadlock-parallel.out

+++ b/src/test/isolation/expected/deadlock-parallel.out

step e1l: SELECT lock_excl(1,x) FROM bigt LIMIT 1; <waiting ...>

step e2l: SELECT lock_excl(2,x) FROM bigt LIMIT 1; <waiting ...>

-step d1a2: SET force_parallel_mode = on;

+step d1a2: SET debug_parallel_query = on;

SET parallel_setup_cost = 0;

SET parallel_tuple_cost = 0;

SET min_parallel_table_scan_size = 0;

SET parallel_leader_participation = off;

SET max_parallel_workers_per_gather = 3;

SELECT sum(lock_share(2,x)) FROM bigt; <waiting ...>

-step d2a1: SET force_parallel_mode = on;

+step d2a1: SET debug_parallel_query = on;

SET parallel_setup_cost = 0;

SET parallel_tuple_cost = 0;

SET min_parallel_table_scan_size = 0;

SET parallel_leader_participation = off;

SET max_parallel_workers_per_gather = 3;

SELECT sum(lock_share(1,x)) FROM bigt;

- SET force_parallel_mode = off;

+ SET debug_parallel_query = off;

RESET parallel_setup_cost;

RESET parallel_tuple_cost;

SELECT lock_share(3,x) FROM bigt LIMIT 1; <waiting ...>

diff --git a/src/test/isolation/specs/deadlock-parallel.spec b/src/test/isolation/specs/deadlock-parallel.spec

index a050a4963ab9491d65b2a85ddfdb6cc5ae6d2c5e..2016bcddae9276fb5c8fdfae7760a42518e7dfbf 100644 (file)

--- a/src/test/isolation/specs/deadlock-parallel.spec

+++ b/src/test/isolation/specs/deadlock-parallel.spec

# and is incorrectly marked parallel-safe so that it can execute in a worker.

# Note that we explicitly override any global settings of isolation level

-# or force_parallel_mode, to ensure we're testing what we intend to.

+# or debug_parallel_query, to ensure we're testing what we intend to.

# Otherwise, this is morally equivalent to deadlock-soft.spec:

# Four-process deadlock with two hard edges and two soft edges.

session d1

setup { BEGIN isolation level repeatable read;

- SET force_parallel_mode = off;

+ SET debug_parallel_query = off;

SET deadlock_timeout = '10s';

}

# these locks will be taken in the leader, so they will persist:

step d1a1 { SELECT lock_share(1,x), lock_excl(3,x) FROM bigt LIMIT 1; }

# this causes all the parallel workers to take locks:

-step d1a2 { SET force_parallel_mode = on;

+step d1a2 { SET debug_parallel_query = on;

SET parallel_setup_cost = 0;

SET parallel_tuple_cost = 0;

SET min_parallel_table_scan_size = 0;

session d2

setup { BEGIN isolation level repeatable read;

- SET force_parallel_mode = off;

+ SET debug_parallel_query = off;

SET deadlock_timeout = '10ms';

}

# this lock will be taken in the leader, so it will persist:

step d2a2 { select lock_share(2,x) FROM bigt LIMIT 1; }

# this causes all the parallel workers to take locks;

# after which, make the leader take lock 3 to prevent client-driven deadlock

-step d2a1 { SET force_parallel_mode = on;

+step d2a1 { SET debug_parallel_query = on;

SET parallel_setup_cost = 0;

SET parallel_tuple_cost = 0;

SET min_parallel_table_scan_size = 0;

SET parallel_leader_participation = off;

SET max_parallel_workers_per_gather = 3;

SELECT sum(lock_share(1,x)) FROM bigt;

- SET force_parallel_mode = off;

+ SET debug_parallel_query = off;

RESET parallel_setup_cost;

RESET parallel_tuple_cost;

SELECT lock_share(3,x) FROM bigt LIMIT 1; }

session e1

setup { BEGIN isolation level repeatable read;

- SET force_parallel_mode = on;

+ SET debug_parallel_query = on;

SET deadlock_timeout = '10s';

}

# this lock will be taken in a parallel worker, but we don't need it to persist

session e2

setup { BEGIN isolation level repeatable read;

- SET force_parallel_mode = on;

+ SET debug_parallel_query = on;

SET deadlock_timeout = '10s';

}

# this lock will be taken in a parallel worker, but we don't need it to persist

diff --git a/src/test/isolation/specs/serializable-parallel.spec b/src/test/isolation/specs/serializable-parallel.spec

index 508648e80c5cba9a2a653a089661ceda3fbb985a..f786b1db1feea514f5727b2299ff075bcce6a69a 100644 (file)

--- a/src/test/isolation/specs/serializable-parallel.spec

+++ b/src/test/isolation/specs/serializable-parallel.spec

session s3

setup {

BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;

- SET force_parallel_mode = on;

+ SET debug_parallel_query = on;

}

step s3r { SELECT id, balance FROM bank_account WHERE id IN ('X', 'Y') ORDER BY id; }

step s3c { COMMIT; }

diff --git a/src/test/modules/libpq_pipeline/libpq_pipeline.c b/src/test/modules/libpq_pipeline/libpq_pipeline.c

index 6111bf9b672d64441532b4ebdf352ac7068264f7..f48da7d963e37ead67fdd1add125447e7411b972 100644 (file)

--- a/src/test/modules/libpq_pipeline/libpq_pipeline.c

+++ b/src/test/modules/libpq_pipeline/libpq_pipeline.c

res = PQexec(conn, "SET lc_messages TO \"C\"");

if (PQresultStatus(res) != PGRES_COMMAND_OK)

pg_fatal("failed to set lc_messages: %s", PQerrorMessage(conn));

- res = PQexec(conn, "SET force_parallel_mode = off");

+ res = PQexec(conn, "SET debug_parallel_query = off");

if (PQresultStatus(res) != PGRES_COMMAND_OK)

- pg_fatal("failed to set force_parallel_mode: %s", PQerrorMessage(conn));

+ pg_fatal("failed to set debug_parallel_query: %s", PQerrorMessage(conn));

/* Set the trace file, if requested */

if (tracefile != NULL)

diff --git a/src/test/modules/test_oat_hooks/test_oat_hooks.c b/src/test/modules/test_oat_hooks/test_oat_hooks.c

index 1409a1d7e58a540e2362ea5c94515bdaaa93d061..b03f90bd55f7483a68b4c6c7b06dd0593bee4c8d 100644 (file)

--- a/src/test/modules/test_oat_hooks/test_oat_hooks.c

+++ b/src/test/modules/test_oat_hooks/test_oat_hooks.c

/*

* Ensure that audit messages are not duplicated by only emitting them

* from a leader process, not a worker process. This makes the test

- * results deterministic even if run with force_parallel_mode = regress.

+ * results deterministic even if run with debug_parallel_query = regress.

*/

if (REGRESS_audit && !IsParallelWorker())

{

diff --git a/src/test/regress/expected/multirangetypes.out b/src/test/regress/expected/multirangetypes.out

index 14aa4c46cde8b9851e4a07042ec54a7bd61e6fe5..e70896b754507f8e41925e57f328821ff300bfa4 100644 (file)

--- a/src/test/regress/expected/multirangetypes.out

+++ b/src/test/regress/expected/multirangetypes.out

--

create type two_ints as (a int, b int);

create type two_ints_range as range (subtype = two_ints);

--- with force_parallel_mode on, this exercises tqueue.c's range remapping

+-- with debug_parallel_query on, this exercises tqueue.c's range remapping

select *, row_to_json(upper(t)) as u from

(values (two_ints_multirange(two_ints_range(row(1,2), row(3,4)))),

(two_ints_multirange(two_ints_range(row(5,6), row(7,8))))) v(t);

diff --git a/src/test/regress/expected/rangetypes.out b/src/test/regress/expected/rangetypes.out

index 9eb31aecfe125da11cc6c6d6a9584bb78452008a..a3e9e447afc438bc112f009f4ef5d07455a9448b 100644 (file)

--- a/src/test/regress/expected/rangetypes.out

+++ b/src/test/regress/expected/rangetypes.out

--

create type two_ints as (a int, b int);

create type two_ints_range as range (subtype = two_ints);

--- with force_parallel_mode on, this exercises tqueue.c's range remapping

+-- with debug_parallel_query on, this exercises tqueue.c's range remapping

select *, row_to_json(upper(t)) as u from

(values (two_ints_range(row(1,2), row(3,4))),

(two_ints_range(row(5,6), row(7,8)))) v(t);

diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out

index 91f74fe47a3d1fef87fd1808a1ad89ef04c61315..d88353d496c824af5ac02af8cf7f0dc0787f7707 100644 (file)

--- a/src/test/regress/expected/select_parallel.out

+++ b/src/test/regress/expected/select_parallel.out

reset parallel_leader_participation;

reset max_parallel_workers;

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

explain (costs off)

select stringu1::int2 from tenk1 where unique1 = 1;

QUERY PLAN

END;

$$;

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

SELECT make_record(x) FROM (SELECT generate_series(1, 5) x) ss ORDER BY x;

make_record

-------------

set role regress_parallel_worker;

reset session authorization;

drop role regress_parallel_worker;

-set force_parallel_mode = 1;

+set debug_parallel_query = 1;

select count(*) from tenk1;

count

-------

10000

(1 row)

-reset force_parallel_mode;

+reset debug_parallel_query;

reset role;

-- Window function calculation can't be pushed to workers.

explain (costs off, verbose)

-- to increase the parallel query test coverage

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

EXPLAIN (analyze, timing off, summary off, costs off) SELECT * FROM tenk1;

QUERY PLAN

-------------------------------------------------------------

-- provoke error in worker

-- (make the error message long enough to require multiple bufferloads)

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

select (stringu1 || repeat('abcd', 5000))::int2 from tenk1 where unique1 = 1;

ERROR: invalid input syntax for type smallint: "BAAAAAabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"

CONTEXT: parallel worker

diff --git a/src/test/regress/expected/with.out b/src/test/regress/expected/with.out

index d0ad7900e85d5f16e37e588d4f44d88cd72d3778..88e57a2c8774fea8e699681dc84317fd4c34c727 100644 (file)

--- a/src/test/regress/expected/with.out

+++ b/src/test/regress/expected/with.out

SELECT a FROM generate_series(11,13) AS a;

CREATE RULE bug6051_3_ins AS ON INSERT TO bug6051_3 DO INSTEAD

SELECT i FROM bug6051_2;

-BEGIN; SET LOCAL force_parallel_mode = on;

+BEGIN; SET LOCAL debug_parallel_query = on;

WITH t1 AS ( DELETE FROM bug6051_3 RETURNING * )

INSERT INTO bug6051_3 SELECT * FROM t1;

i

diff --git a/src/test/regress/sql/multirangetypes.sql b/src/test/regress/sql/multirangetypes.sql

index 78a650eb0fbf97937465ae62bc5837b359e2490e..fc369a550cfc082ee5ff353055ed406b06d6b5fe 100644 (file)

--- a/src/test/regress/sql/multirangetypes.sql

+++ b/src/test/regress/sql/multirangetypes.sql

create type two_ints as (a int, b int);

create type two_ints_range as range (subtype = two_ints);

--- with force_parallel_mode on, this exercises tqueue.c's range remapping

+-- with debug_parallel_query on, this exercises tqueue.c's range remapping

select *, row_to_json(upper(t)) as u from

(values (two_ints_multirange(two_ints_range(row(1,2), row(3,4)))),

(two_ints_multirange(two_ints_range(row(5,6), row(7,8))))) v(t);

diff --git a/src/test/regress/sql/rangetypes.sql b/src/test/regress/sql/rangetypes.sql

index 798cd23910369066bc9cfd06a6750c248395bea2..4e6a0912def10425776c9d446707ccef7a89829e 100644 (file)

--- a/src/test/regress/sql/rangetypes.sql

+++ b/src/test/regress/sql/rangetypes.sql

create type two_ints as (a int, b int);

create type two_ints_range as range (subtype = two_ints);

--- with force_parallel_mode on, this exercises tqueue.c's range remapping

+-- with debug_parallel_query on, this exercises tqueue.c's range remapping

select *, row_to_json(upper(t)) as u from

(values (two_ints_range(row(1,2), row(3,4))),

(two_ints_range(row(5,6), row(7,8)))) v(t);

diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql

index 62fb68c7a0483ccfb2733e110a90c3e106203d39..80c914dc02b0bc74e330beb89c1fad72364139c4 100644 (file)

--- a/src/test/regress/sql/select_parallel.sql

+++ b/src/test/regress/sql/select_parallel.sql

reset max_parallel_workers;

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

explain (costs off)

select stringu1::int2 from tenk1 where unique1 = 1;

ROLLBACK TO SAVEPOINT settings;

END;

$$;

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

SELECT make_record(x) FROM (SELECT generate_series(1, 5) x) ss ORDER BY x;

ROLLBACK TO SAVEPOINT settings;

DROP function make_record(n int);

set role regress_parallel_worker;

reset session authorization;

drop role regress_parallel_worker;

-set force_parallel_mode = 1;

+set debug_parallel_query = 1;

select count(*) from tenk1;

-reset force_parallel_mode;

+reset debug_parallel_query;

reset role;

-- Window function calculation can't be pushed to workers.

-- to increase the parallel query test coverage

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

EXPLAIN (analyze, timing off, summary off, costs off) SELECT * FROM tenk1;

ROLLBACK TO SAVEPOINT settings;

-- provoke error in worker

-- (make the error message long enough to require multiple bufferloads)

SAVEPOINT settings;

-SET LOCAL force_parallel_mode = 1;

+SET LOCAL debug_parallel_query = 1;

select (stringu1 || repeat('abcd', 5000))::int2 from tenk1 where unique1 = 1;

ROLLBACK TO SAVEPOINT settings;

diff --git a/src/test/regress/sql/with.sql b/src/test/regress/sql/with.sql

index 2148972ea2338bed283dad78f8c890dc6ff755e6..582139df7bd834e394b679d32058b7c4ab3e2443 100644 (file)

--- a/src/test/regress/sql/with.sql

+++ b/src/test/regress/sql/with.sql

CREATE RULE bug6051_3_ins AS ON INSERT TO bug6051_3 DO INSTEAD

SELECT i FROM bug6051_2;

-BEGIN; SET LOCAL force_parallel_mode = on;

+BEGIN; SET LOCAL debug_parallel_query = on;

WITH t1 AS ( DELETE FROM bug6051_3 RETURNING * )

INSERT INTO bug6051_3 SELECT * FROM t1;