[*]

indent_style =tab

indent_size =4

os:

-linux

-linux

sudo:required

dist:trusty

language:c

compiler:

-clang

-gcc

services:

-docker

before_install:

-if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get -y install -qq wget ca-certificates; fi

-if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then source ./travis/dep-ubuntu-postgres.sh; fi

-if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then source ./travis/dep-ubuntu-llvm.sh; fi

-if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get update -qq; fi

install:

-sed -e 's/${CHECK_CODE}/'${CHECK_CODE}/g -e 's/${PG_VERSION}/'${PG_VERSION}/g Dockerfile.tmpl > Dockerfile

-docker-compose build

env:

global:

-LLVM_VER=4.0

matrix:

-PG_VER=10 CHECK_CODE=true

-PG_VER=10 CHECK_CODE=false

-PG_VER=9.6 CHECK_CODE=true

-PG_VER=9.6 CHECK_CODE=false

-PG_VER=9.5 CHECK_CODE=true

-PG_VER=9.5 CHECK_CODE=false

script:bash ./travis/pg-travis-test.sh

script:

-docker-compose run $(bash <(curl -s https://codecov.io/env)) tests

after_success:

-bash <(curl -s https://codecov.io/bash)

env:

-PG_VERSION=10 CHECK_CODE=clang

-PG_VERSION=9.6 CHECK_CODE=clang

-PG_VERSION=9.5 CHECK_CODE=clang

-PG_VERSION=10 CHECK_CODE=cppcheck

-PG_VERSION=9.6 CHECK_CODE=cppcheck

-PG_VERSION=9.5 CHECK_CODE=cppcheck

-PG_VERSION=10 CHECK_CODE=false

-PG_VERSION=9.6 CHECK_CODE=false

-PG_VERSION=9.5 CHECK_CODE=false

FROM postgres:${PG_VERSION}-alpine

ENV LANG=C.UTF-8 PGDATA=/pg/data

RUN if [ "${CHECK_CODE}" = "clang" ] ; then \

echo 'http://dl-3.alpinelinux.org/alpine/edge/main' > /etc/apk/repositories; \

apk --no-cache add clang-analyzer make musl-dev gcc; \

fi

RUN if [ "${CHECK_CODE}" = "cppcheck" ] ; then \

apk --no-cache add cppcheck --repository http://dl-cdn.alpinelinux.org/alpine/v3.6/community; \

fi

RUN if [ "${CHECK_CODE}" = "false" ] ; then \

echo 'http://dl-3.alpinelinux.org/alpine/edge/main' > /etc/apk/repositories; \

apk --no-cache add curl python3 gcc make musl-dev cmocka-dev;\

pip3 install testgres; \

fi

RUN mkdir -p /pg/data && \

mkdir /pg/pg_pathman && \

chown postgres:postgres ${PGDATA} && \

chmod a+rwx /usr/local/lib/postgresql && \

chmod a+rwx /usr/local/share/postgresql/extension

ADD . /pg/pg_pathman

WORKDIR /pg/pg_pathman

RUN chmod -R go+rwX /pg/pg_pathman

USER postgres

ENTRYPOINT PGDATA=${PGDATA} CHECK_CODE=${CHECK_CODE} bash run_tests.sh

src/pl_funcs.o src/pl_range_funcs.o src/pl_hash_funcs.o src/pathman_workers.o\

src/hooks.o src/nodes_common.o src/xact_handling.o src/utility_stmt_hooking.o\

src/planner_tree_modification.o src/debug_print.o src/partition_creation.o\

src/compat/pg_compat.o src/compat/relation_tags.o src/compat/expand_rte_hook.o\

src/compat/pg_compat.o src/compat/relation_tags.o src/compat/rowmarks_fix.o\

overridePG_CPPFLAGS += -I$(CURDIR)/src/include

cmocka_tests:

$(MAKE) -C tests/cmocka check

clean_gcov:

find.\

-name"*.gcda" -delete -o\

-name"*.gcno" -delete -o\

-name"*.gcov" -delete

tests:

build:.

SQL statement "SELECT pathman.prepare_for_partitioning(parent_relid,

expression,

partition_data)"

PL/pgSQL function pathman.create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line4 at PERFORM

PL/pgSQL function pathman.create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line3 at PERFORM

\set VERBOSITY terse

ALTER TABLE test.hash_rel ALTER COLUMN value SET NOT NULL;

SELECT pathman.create_hash_partitions('test.hash_rel', 'value', 3, partition_data:=false);

CREATE TABLE test.tmp (id INTEGER NOT NULL, value INTEGER NOT NULL);

INSERT INTO test.tmp VALUES (1, 1), (2, 2);

/* Test UPDATE and DELETE */

EXPLAIN (COSTS OFF) UPDATE test.range_rel SET value = 111 WHERE dt = '2010-06-15';

EXPLAIN (COSTS OFF) UPDATE test.range_rel SET value = 111 WHERE dt = '2010-06-15';/* have partitions for this 'dt' */

QUERY PLAN

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

Update on range_rel_6

166 | Tue Jun 15 00:00:00 2010 | 111

(1 row)

EXPLAIN (COSTS OFF) DELETE FROM test.range_rel WHERE dt = '2010-06-15';

EXPLAIN (COSTS OFF) DELETE FROM test.range_rel WHERE dt = '2010-06-15';/* have partitions for this 'dt' */

QUERY PLAN

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

Delete on range_rel_6

----+----+-------

(0 rows)

EXPLAIN (COSTS OFF) UPDATE test.range_rel SET value = 222 WHERE dt = '1990-01-01';/* no partitions for this 'dt' */

QUERY PLAN

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

Update on range_rel

-> Seq Scan on range_rel

Filter: (dt = 'Mon Jan 01 00:00:00 1990'::timestamp without time zone)

(3 rows)

UPDATE test.range_rel SET value = 111 WHERE dt = '1990-01-01';

SELECT * FROM test.range_rel WHERE dt = '1990-01-01';

id | dt | value

----+----+-------

(0 rows)

EXPLAIN (COSTS OFF) DELETE FROM test.range_rel WHERE dt < '1990-01-01';/* no partitions for this 'dt' */

QUERY PLAN

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

Delete on range_rel

-> Seq Scan on range_rel

Filter: (dt < 'Mon Jan 01 00:00:00 1990'::timestamp without time zone)

(3 rows)

DELETE FROM test.range_rel WHERE dt < '1990-01-01';

SELECT * FROM test.range_rel WHERE dt < '1990-01-01';

id | dt | value

----+----+-------

(0 rows)

EXPLAIN (COSTS OFF) UPDATE test.range_rel r SET value = t.value FROM test.tmp t WHERE r.dt = '2010-01-01' AND r.id = t.id;

QUERY PLAN

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

SQL statement "SELECT public.prepare_for_partitioning(parent_relid,

expression,

partition_data)"

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line4 at PERFORM

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line3 at PERFORM

/* Try using system attributes */

SELECT create_hash_partitions('test_exprs.hash_rel', 'xmin', 4);

ERROR: failed to analyze partitioning expression "xmin"

SQL statement "SELECT public.prepare_for_partitioning(parent_relid,

expression,

partition_data)"

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line4 at PERFORM

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line3 at PERFORM

/* Try using subqueries */

SELECT create_hash_partitions('test_exprs.hash_rel',

'value, (select oid from pg_class limit 1)',

SQL statement "SELECT public.prepare_for_partitioning(parent_relid,

expression,

partition_data)"

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line4 at PERFORM

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line3 at PERFORM

/* Try using mutable expression */

SELECT create_hash_partitions('test_exprs.hash_rel', 'random()', 4);

ERROR: failed to analyze partitioning expression "random()"

SQL statement "SELECT public.prepare_for_partitioning(parent_relid,

expression,

partition_data)"

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line4 at PERFORM

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line3 at PERFORM

/* Try using broken parentheses */

SELECT create_hash_partitions('test_exprs.hash_rel', 'value * value2))', 4);

ERROR: failed to parse partitioning expression "value * value2))"

SQL statement "SELECT public.prepare_for_partitioning(parent_relid,

expression,

partition_data)"

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line4 at PERFORM

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line3 at PERFORM

/* Try using missing columns */

SELECT create_hash_partitions('test_exprs.hash_rel', 'value * value3', 4);

ERROR: failed to analyze partitioning expression "value * value3"

SQL statement "SELECT public.prepare_for_partitioning(parent_relid,

expression,

partition_data)"

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line4 at PERFORM

PL/pgSQL function create_hash_partitions(regclass,text,integer,boolean,text[],text[]) line3 at PERFORM

/* Check that 'pathman_hooks_enabled' is true (1 partition in plan) */

EXPLAIN (COSTS OFF) INSERT INTO test_exprs.canary_copy

SELECT * FROM test_exprs.canary WHERE val = 1;

/*

* -------------------------------------------

* NOTE: This test behaves differenly on 9.5

* -------------------------------------------

*/

CREATE EXTENSION pg_pathman;

CREATE SCHEMA rowmarks;

CREATE TABLE rowmarks.first(id int NOT NULL);

6

(1 row)

/* Check updates (plan) */

SET enable_hashjoin = f;/* Hash Semi Join on 10 vs Hash Join on 9.6 */

SET enable_mergejoin = f;/* Merge Semi Join on 10 vs Merge Join on 9.6 */

EXPLAIN (COSTS OFF)

UPDATE rowmarks.second SET id = 2

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id = 1);

QUERY PLAN

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

Update on second

-> Nested Loop Semi Join

-> Seq Scan on second

Filter: (id = 1)

-> Materialize

-> Append

-> Seq Scan on first_0

Filter: (id = 1)

(8 rows)

EXPLAIN (COSTS OFF)

UPDATE rowmarks.second SET id = 2

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id < 1);

QUERY PLAN

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

Update on second

-> Nested Loop

Join Filter: (second.id = first_0.id)

-> HashAggregate

Group Key: first_0.id

-> Append

-> Seq Scan on first_0

Filter: (id < 1)

-> Seq Scan on first_1

Filter: (id < 1)

-> Seq Scan on first_2

Filter: (id < 1)

-> Seq Scan on first_3

Filter: (id < 1)

-> Seq Scan on first_4

Filter: (id < 1)

-> Materialize

-> Seq Scan on second

(18 rows)

EXPLAIN (COSTS OFF)

UPDATE rowmarks.second SET id = 2

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id = 1 OR id = 2);

QUERY PLAN

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

Update on second

-> Nested Loop Semi Join

Join Filter: (second.id = first_0.id)

-> Seq Scan on second

-> Materialize

-> Append

-> Seq Scan on first_0

Filter: (id = 1)

-> Seq Scan on first_1

Filter: (id = 2)

(10 rows)

EXPLAIN (COSTS OFF)

UPDATE rowmarks.second SET id = 2

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id = 1)

RETURNING *, tableoid::regclass;

QUERY PLAN

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

Update on second

-> Nested Loop Semi Join

-> Seq Scan on second

Filter: (id = 1)

-> Materialize

-> Append

-> Seq Scan on first_0

Filter: (id = 1)

(8 rows)

SET enable_hashjoin = t;

SET enable_mergejoin = t;

/* Check updates (execution) */

UPDATE rowmarks.second SET id = 1

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id = 1 OR id = 2)

RETURNING *, tableoid::regclass;

id | tableoid

----+-----------------

1 | rowmarks.second

1 | rowmarks.second

(2 rows)

/* Check deletes (plan) */

SET enable_hashjoin = f;/* Hash Semi Join on 10 vs Hash Join on 9.6 */

SET enable_mergejoin = f;/* Merge Semi Join on 10 vs Merge Join on 9.6 */

EXPLAIN (COSTS OFF)

DELETE FROM rowmarks.second

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id = 1);

QUERY PLAN

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

Delete on second

-> Nested Loop Semi Join

-> Seq Scan on second

Filter: (id = 1)

-> Materialize

-> Append

-> Seq Scan on first_0

Filter: (id = 1)

(8 rows)

EXPLAIN (COSTS OFF)

DELETE FROM rowmarks.second

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id < 1);

QUERY PLAN

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

Delete on second

-> Nested Loop

Join Filter: (second.id = first_0.id)

-> HashAggregate

Group Key: first_0.id

-> Append

-> Seq Scan on first_0

Filter: (id < 1)

-> Seq Scan on first_1

Filter: (id < 1)

-> Seq Scan on first_2

Filter: (id < 1)

-> Seq Scan on first_3

Filter: (id < 1)

-> Seq Scan on first_4

Filter: (id < 1)

-> Materialize

-> Seq Scan on second

(18 rows)

EXPLAIN (COSTS OFF)

DELETE FROM rowmarks.second

WHERE rowmarks.second.id IN (SELECT id FROM rowmarks.first WHERE id = 1 OR id = 2);

QUERY PLAN

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

Delete on second

-> Nested Loop Semi Join

Join Filter: (second.id = first_0.id)

-> Seq Scan on second

-> Materialize

-> Append

-> Seq Scan on first_0

Filter: (id = 1)

-> Seq Scan on first_1

Filter: (id = 2)

(10 rows)

SET enable_hashjoin = t;

SET enable_mergejoin = t;

DROP SCHEMA rowmarks CASCADE;

NOTICE: drop cascades to 7 other objects

DETAIL: drop cascades to table rowmarks.first