1-- 2-- multi shard update delete 3-- this file is intended to test multi shard update/delete queries 4-- 5SET citus.next_shard_id TO 1440000; 6 7SET citus.shard_replication_factor to 1; 8SET citus.multi_shard_modify_mode to 'parallel'; 9 10CREATE TABLE users_test_table(user_id int, value_1 int, value_2 int, value_3 int); 11SELECT create_distributed_table('users_test_table', 'user_id'); 12\COPY users_test_table FROM STDIN DELIMITER AS ','; 131, 5, 6, 7 142, 12, 7, 18 153, 23, 8, 25 164, 42, 9, 23 175, 35, 10, 21 186, 21, 11, 25 197, 27, 12, 18 208, 18, 13, 4 217, 38, 14, 22 226, 43, 15, 22 235, 61, 16, 17 244, 6, 17, 8 253, 16, 18, 44 262, 25, 19, 38 271, 55, 20, 17 28\. 29 30CREATE TABLE events_test_table (user_id int, value_1 int, value_2 int, value_3 int); 31SELECT create_distributed_table('events_test_table', 'user_id'); 32\COPY events_test_table FROM STDIN DELIMITER AS ','; 331, 5, 7, 7 343, 11, 78, 18 355, 22, 9, 25 367, 41, 10, 23 379, 34, 11, 21 381, 20, 12, 25 393, 26, 13, 18 405, 17, 14, 4 417, 37, 15, 22 429, 42, 16, 22 431, 60, 17, 17 443, 5, 18, 8 455, 15, 19, 44 467, 24, 20, 38 479, 54, 21, 17 48\. 49 50CREATE TABLE events_reference_copy_table (like events_test_table); 51SELECT create_reference_table('events_reference_copy_table'); 52INSERT INTO events_reference_copy_table SELECT * FROM events_test_table; 53 54CREATE TABLE users_reference_copy_table (like users_test_table); 55SELECT create_reference_table('users_reference_copy_table'); 56INSERT INTO users_reference_copy_table SELECT * FROM users_test_table; 57 58-- Run multi shard updates and deletes without transaction on hash distributed tables 59UPDATE users_test_table SET value_1 = 1; 60SELECT COUNT(*), SUM(value_1) FROM users_test_table; 61 62SELECT COUNT(*), SUM(value_2) FROM users_test_table WHERE user_id = 1 or user_id = 3; 63UPDATE users_test_table SET value_2 = value_2 + 1 WHERE user_id = 1 or user_id = 3; 64SELECT COUNT(*), SUM(value_2) FROM users_test_table WHERE user_id = 1 or user_id = 3; 65 66UPDATE users_test_table SET value_3 = 0 WHERE user_id <> 5; 67SELECT SUM(value_3) FROM users_test_table WHERE user_id <> 5; 68 69SELECT COUNT(*) FROM users_test_table WHERE user_id = 3 or user_id = 5; 70DELETE FROM users_test_table WHERE user_id = 3 or user_id = 5; 71SELECT COUNT(*) FROM users_test_table WHERE user_id = 3 or user_id = 5; 72 73-- Run multi shard update delete queries within transactions 74BEGIN; 75UPDATE users_test_table SET value_3 = 0; 76END; 77SELECT SUM(value_3) FROM users_test_table; 78 79-- Update can also be rollbacked 80BEGIN; 81UPDATE users_test_table SET value_3 = 1; 82ROLLBACK; 83SELECT SUM(value_3) FROM users_test_table; 84 85-- Run with inserts (we need to set citus.multi_shard_modify_mode to sequential) 86BEGIN; 87INSERT INTO users_test_table (user_id, value_3) VALUES(20, 15); 88INSERT INTO users_test_table (user_id, value_3) VALUES(16,1), (20,16), (7,1), (20,17); 89SET citus.multi_shard_modify_mode to sequential; 90UPDATE users_test_table SET value_3 = 1; 91END; 92SELECT SUM(value_3) FROM users_test_table; 93 94SET citus.multi_shard_modify_mode to 'sequential'; 95-- Run multiple multi shard updates (with sequential executor) 96BEGIN; 97UPDATE users_test_table SET value_3 = 5; 98UPDATE users_test_table SET value_3 = 0; 99END; 100SELECT SUM(value_3) FROM users_copy_table; 101 102-- Run multiple multi shard updates (with parallel executor) 103SET citus.multi_shard_modify_mode to 'parallel'; 104UPDATE users_test_table SET value_3 = 5; 105BEGIN; 106UPDATE users_test_table SET value_3 = 2; 107UPDATE users_test_table SET value_3 = 0; 108END; 109SELECT SUM(value_3) FROM users_test_table; 110 111-- Check with kind of constraints 112UPDATE users_test_table SET value_3 = 1 WHERE user_id = 3 or true; 113SELECT COUNT(*), SUM(value_3) FROM users_test_table; 114UPDATE users_test_table SET value_3 = 0 WHERE user_id = 20 and false; 115SELECT COUNT(*), SUM(value_3) FROM users_test_table; 116 117-- Run multi shard updates with prepared statements 118PREPARE foo_plan(int,int) AS UPDATE users_test_table SET value_1 = $1, value_3 = $2; 119 120EXECUTE foo_plan(1,5); 121EXECUTE foo_plan(3,15); 122EXECUTE foo_plan(5,25); 123EXECUTE foo_plan(7,35); 124EXECUTE foo_plan(9,45); 125EXECUTE foo_plan(0,0); 126 127SELECT SUM(value_1), SUM(value_3) FROM users_test_table; 128 129-- Test on append table (set executor mode to sequential, since with the append 130-- distributed tables parallel executor may create tons of connections) 131SET citus.multi_shard_modify_mode to sequential; 132CREATE TABLE append_stage_table(id int, col_2 int); 133INSERT INTO append_stage_table VALUES(1,3); 134INSERT INTO append_stage_table VALUES(3,2); 135INSERT INTO append_stage_table VALUES(5,4); 136 137CREATE TABLE append_stage_table_2(id int, col_2 int); 138INSERT INTO append_stage_table_2 VALUES(8,3); 139INSERT INTO append_stage_table_2 VALUES(9,2); 140INSERT INTO append_stage_table_2 VALUES(10,4); 141 142CREATE TABLE test_append_table(id int, col_2 int); 143SELECT create_distributed_table('test_append_table','id','append'); 144SELECT master_create_empty_shard('test_append_table'); 145SELECT * FROM master_append_table_to_shard(1440010, 'append_stage_table', 'localhost', :master_port); 146SELECT master_create_empty_shard('test_append_table') AS new_shard_id; 147SELECT * FROM master_append_table_to_shard(1440011, 'append_stage_table_2', 'localhost', :master_port); 148UPDATE test_append_table SET col_2 = 5; 149SELECT * FROM test_append_table ORDER BY 1 DESC, 2 DESC; 150 151DROP TABLE append_stage_table; 152DROP TABLE append_stage_table_2; 153DROP TABLE test_append_table; 154 155-- Update multi shard of partitioned distributed table 156SET citus.multi_shard_modify_mode to 'parallel'; 157SET citus.shard_replication_factor to 1; 158CREATE TABLE tt1(id int, col_2 int) partition by range (col_2); 159CREATE TABLE tt1_510 partition of tt1 for VALUES FROM (5) to (10); 160CREATE TABLE tt1_1120 partition of tt1 for VALUES FROM (11) to (20); 161INSERT INTO tt1 VALUES (1,11), (3,15), (5,17), (6,19), (8,17), (2,12); 162SELECT create_distributed_table('tt1','id'); 163UPDATE tt1 SET col_2 = 13; 164DELETE FROM tt1 WHERE id = 1 or id = 3 or id = 5; 165SELECT * FROM tt1 ORDER BY 1 DESC, 2 DESC; 166 167-- Partitioned distributed table within transaction 168INSERT INTO tt1 VALUES(4,6); 169INSERT INTO tt1 VALUES(7,7); 170INSERT INTO tt1 VALUES(9,8); 171BEGIN; 172-- Update rows from partititon tt1_1120 173UPDATE tt1 SET col_2 = 12 WHERE col_2 > 10 and col_2 < 20; 174-- Update rows from partititon tt1_510 175UPDATE tt1 SET col_2 = 7 WHERE col_2 < 10 and col_2 > 5; 176COMMIT; 177SELECT * FROM tt1 ORDER BY id; 178 179-- Modify main table and partition table within same transaction 180BEGIN; 181UPDATE tt1 SET col_2 = 12 WHERE col_2 > 10 and col_2 < 20; 182UPDATE tt1 SET col_2 = 7 WHERE col_2 < 10 and col_2 > 5; 183DELETE FROM tt1_510; 184DELETE FROM tt1_1120; 185COMMIT; 186SELECT * FROM tt1 ORDER BY id; 187DROP TABLE tt1; 188 189-- Update and copy in the same transaction 190CREATE TABLE tt2(id int, col_2 int); 191SELECT create_distributed_table('tt2','id'); 192 193BEGIN; 194\COPY tt2 FROM STDIN DELIMITER AS ','; 1951, 10 1963, 15 1977, 14 1989, 75 1992, 42 200\. 201UPDATE tt2 SET col_2 = 1; 202COMMIT; 203SELECT * FROM tt2 ORDER BY id; 204 205-- Test returning with both type of executors 206UPDATE tt2 SET col_2 = 5 RETURNING id, col_2; 207SET citus.multi_shard_modify_mode to sequential; 208UPDATE tt2 SET col_2 = 3 RETURNING id, col_2; 209DROP TABLE tt2; 210 211-- Multiple RTEs are only supported if subquery is pushdownable 212SET citus.multi_shard_modify_mode to DEFAULT; 213 214-- To test colocation between tables in modify query 215SET citus.shard_count to 6; 216 217CREATE TABLE events_test_table_2 (user_id int, value_1 int, value_2 int, value_3 int); 218SELECT create_distributed_table('events_test_table_2', 'user_id'); 219\COPY events_test_table_2 FROM STDIN DELIMITER AS ','; 2201, 5, 7, 7 2213, 11, 78, 18 2225, 22, 9, 25 2237, 41, 10, 23 2249, 34, 11, 21 2251, 20, 12, 25 2263, 26, 13, 18 2275, 17, 14, 4 2287, 37, 15, 22 2299, 42, 16, 22 2301, 60, 17, 17 2313, 5, 18, 8 2325, 15, 19, 44 2337, 24, 20, 38 2349, 54, 21, 17 235\. 236 237CREATE TABLE events_test_table_local (user_id int, value_1 int, value_2 int, value_3 int); 238\COPY events_test_table_local FROM STDIN DELIMITER AS ','; 2391, 5, 7, 7 2403, 11, 78, 18 2415, 22, 9, 25 2427, 41, 10, 23 2439, 34, 11, 21 2441, 20, 12, 25 2453, 26, 13, 18 2465, 17, 14, 4 2477, 37, 15, 22 2489, 42, 16, 22 2491, 60, 17, 17 2503, 5, 18, 8 2515, 15, 19, 44 2527, 24, 20, 38 2539, 54, 21, 17 254\. 255 256CREATE TABLE test_table_1(id int, date_col timestamptz, col_3 int); 257INSERT INTO test_table_1 VALUES(1, '2014-04-05 08:32:12', 5); 258INSERT INTO test_table_1 VALUES(2, '2015-02-01 08:31:16', 7); 259INSERT INTO test_table_1 VALUES(3, '2111-01-12 08:35:19', 9); 260SELECT create_distributed_table('test_table_1', 'id'); 261 262-- We can pushdown query if there is partition key equality 263UPDATE users_test_table 264SET value_2 = 5 265FROM events_test_table 266WHERE users_test_table.user_id = events_test_table.user_id; 267 268DELETE FROM users_test_table 269USING events_test_table 270WHERE users_test_table.user_id = events_test_table.user_id; 271 272UPDATE users_test_table 273SET value_1 = 3 274WHERE user_id IN (SELECT user_id 275 FROM events_test_table); 276 277DELETE FROM users_test_table 278WHERE user_id IN (SELECT user_id 279 FROM events_test_table); 280 281DELETE FROM events_test_table_2 282WHERE now() > (SELECT max(date_col) 283 FROM test_table_1 284 WHERE test_table_1.id = events_test_table_2.user_id 285 GROUP BY id) 286RETURNING *; 287 288UPDATE users_test_table 289SET value_1 = 5 290FROM events_test_table 291WHERE users_test_table.user_id = events_test_table.user_id 292 AND events_test_table.user_id > 5; 293 294UPDATE users_test_table 295SET value_1 = 4 296WHERE user_id IN (SELECT user_id 297 FROM users_test_table 298 UNION 299 SELECT user_id 300 FROM events_test_table); 301 302UPDATE users_test_table 303SET value_1 = 4 304WHERE user_id IN (SELECT user_id 305 FROM users_test_table 306 UNION 307 SELECT user_id 308 FROM events_test_table) returning value_3; 309 310UPDATE users_test_table 311SET value_1 = 4 312WHERE user_id IN (SELECT user_id 313 FROM users_test_table 314 UNION ALL 315 SELECT user_id 316 FROM events_test_table) returning value_3; 317 318UPDATE users_test_table 319SET value_1 = 5 320WHERE 321 value_2 > 322 (SELECT 323 max(value_2) 324 FROM 325 events_test_table 326 WHERE 327 users_test_table.user_id = events_test_table.user_id 328 GROUP BY 329 user_id 330 ); 331 332UPDATE users_test_table 333SET value_3 = 1 334WHERE 335 value_2 > 336 (SELECT 337 max(value_2) 338 FROM 339 events_test_table 340 WHERE 341 users_test_table.user_id = events_test_table.user_id AND 342 users_test_table.value_2 > events_test_table.value_2 343 GROUP BY 344 user_id 345 ); 346 347UPDATE users_test_table 348SET value_2 = 4 349WHERE 350 value_1 > 1 AND value_1 < 3 351 AND value_2 >= 1 352 AND user_id IN 353 ( 354 SELECT 355 e1.user_id 356 FROM ( 357 SELECT 358 user_id, 359 1 AS view_homepage 360 FROM events_test_table 361 WHERE 362 value_1 IN (0, 1) 363 ) e1 LEFT JOIN LATERAL ( 364 SELECT 365 user_id, 366 1 AS use_demo 367 FROM events_test_table 368 WHERE 369 user_id = e1.user_id 370 ) e2 ON true 371); 372 373UPDATE users_test_table 374SET value_3 = 5 375WHERE value_2 IN (SELECT AVG(value_1) OVER (PARTITION BY user_id) FROM events_test_table WHERE events_test_table.user_id = users_test_table.user_id); 376 377-- Test it within transaction 378BEGIN; 379 380INSERT INTO users_test_table 381SELECT * FROM events_test_table 382WHERE events_test_table.user_id = 1 OR events_test_table.user_id = 5; 383 384SELECT SUM(value_2) FROM users_test_table; 385 386UPDATE users_test_table 387SET value_2 = 1 388FROM events_test_table 389WHERE users_test_table.user_id = events_test_table.user_id; 390 391SELECT SUM(value_2) FROM users_test_table; 392 393COMMIT; 394 395-- Test with schema 396CREATE SCHEMA sec_schema; 397CREATE TABLE sec_schema.tt1(id int, value_1 int); 398SELECT create_distributed_table('sec_schema.tt1','id'); 399INSERT INTO sec_schema.tt1 values(1,1),(2,2),(7,7),(9,9); 400 401UPDATE sec_schema.tt1 402SET value_1 = 11 403WHERE id < (SELECT max(value_2) FROM events_test_table_2 404 WHERE sec_schema.tt1.id = events_test_table_2.user_id 405 GROUP BY user_id) 406RETURNING *; 407 408DROP SCHEMA sec_schema CASCADE; 409 410-- We don't need partition key equality with reference tables 411UPDATE events_test_table 412SET value_2 = 5 413FROM users_reference_copy_table 414WHERE users_reference_copy_table.user_id = events_test_table.value_1; 415 416-- Both reference tables and hash distributed tables can be used in subquery 417UPDATE events_test_table as ett 418SET value_2 = 6 419WHERE ett.value_3 IN (SELECT utt.value_3 420 FROM users_test_table as utt, users_reference_copy_table as uct 421 WHERE utt.user_id = uct.user_id AND utt.user_id = ett.user_id); 422 423-- We don't need equality check with constant values in sub-select 424UPDATE users_reference_copy_table 425SET value_2 = 6 426WHERE user_id IN (SELECT 2); 427 428UPDATE users_reference_copy_table 429SET value_2 = 6 430WHERE value_1 IN (SELECT 2); 431 432UPDATE users_test_table 433SET value_2 = 6 434WHERE user_id IN (SELECT 2); 435 436UPDATE users_test_table 437SET value_2 = 6 438WHERE value_1 IN (SELECT 2); 439 440-- Function calls in subqueries will be recursively planned 441UPDATE test_table_1 442SET col_3 = 6 443WHERE date_col IN (SELECT now()); 444 445-- Test with prepared statements 446SELECT COUNT(*) FROM users_test_table WHERE value_1 = 0; 447PREPARE foo_plan_2(int,int) AS UPDATE users_test_table 448 SET value_1 = $1, value_3 = $2 449 FROM events_test_table 450 WHERE users_test_table.user_id = events_test_table.user_id; 451 452EXECUTE foo_plan_2(1,5); 453EXECUTE foo_plan_2(3,15); 454EXECUTE foo_plan_2(5,25); 455EXECUTE foo_plan_2(7,35); 456EXECUTE foo_plan_2(9,45); 457EXECUTE foo_plan_2(0,0); 458SELECT COUNT(*) FROM users_test_table WHERE value_1 = 0; 459 460-- Test with varying WHERE expressions 461UPDATE users_test_table 462SET value_1 = 7 463FROM events_test_table 464WHERE users_test_table.user_id = events_test_table.user_id OR FALSE; 465 466UPDATE users_test_table 467SET value_1 = 7 468FROM events_test_table 469WHERE users_test_table.user_id = events_test_table.user_id AND TRUE; 470 471-- Test with inactive shard-placement 472-- manually set shardstate of one placement of users_test_table as inactive 473UPDATE pg_dist_shard_placement SET shardstate = 3 WHERE shardid = 1440000; 474UPDATE users_test_table 475SET value_2 = 5 476FROM events_test_table 477WHERE users_test_table.user_id = events_test_table.user_id; 478 479-- manually set shardstate of one placement of events_test_table as inactive 480UPDATE pg_dist_shard_placement SET shardstate = 3 WHERE shardid = 1440004; 481UPDATE users_test_table 482SET value_2 = 5 483FROM events_test_table 484WHERE users_test_table.user_id = events_test_table.user_id; 485 486UPDATE pg_dist_shard_placement SET shardstate = 1 WHERE shardid = 1440000; 487UPDATE pg_dist_shard_placement SET shardstate = 1 WHERE shardid = 1440004; 488 489-- Subquery must return single value to use it with comparison operators 490UPDATE users_test_table as utt 491SET value_1 = 3 492WHERE value_2 > (SELECT value_3 FROM events_test_table as ett WHERE utt.user_id = ett.user_id); 493 494-- We can not pushdown a query if the target relation is reference table 495UPDATE users_reference_copy_table 496SET value_2 = 5 497FROM events_test_table 498WHERE users_reference_copy_table.user_id = events_test_table.user_id; 499 500-- We cannot push down it if the query has outer join and using 501UPDATE events_test_table 502SET value_2 = users_test_table.user_id 503FROM users_test_table 504FULL OUTER JOIN events_test_table e2 USING (user_id) 505WHERE e2.user_id = events_test_table.user_id RETURNING events_test_table.value_2; 506 507-- Non-pushdownable subqueries, but will be handled through recursive planning 508UPDATE users_test_table 509SET value_1 = 1 510WHERE user_id IN (SELECT Count(value_1) 511 FROM events_test_table 512 GROUP BY user_id); 513 514UPDATE users_test_table 515SET value_1 = (SELECT Count(*) 516 FROM events_test_table); 517 518UPDATE users_test_table 519SET value_1 = 4 520WHERE user_id IN (SELECT user_id 521 FROM users_test_table 522 UNION 523 SELECT value_1 524 FROM events_test_table); 525 526UPDATE users_test_table 527SET value_1 = 4 528WHERE user_id IN (SELECT user_id 529 FROM users_test_table 530 INTERSECT 531 SELECT Sum(value_1) 532 FROM events_test_table 533 GROUP BY user_id); 534 535UPDATE users_test_table 536SET value_2 = (SELECT value_3 537 FROM users_test_table); 538 539UPDATE users_test_table 540SET value_2 = 2 541WHERE 542 value_2 > 543 (SELECT 544 max(value_2) 545 FROM 546 events_test_table 547 WHERE 548 users_test_table.user_id > events_test_table.user_id AND 549 users_test_table.value_1 = events_test_table.value_1 550 GROUP BY 551 user_id 552 ); 553 554UPDATE users_test_table 555SET (value_1, value_2) = (2,1) 556WHERE user_id IN 557 (SELECT user_id 558 FROM users_test_table 559 INTERSECT 560 SELECT user_id 561 FROM events_test_table); 562 563-- Reference tables can not locate on the outer part of the outer join 564UPDATE users_test_table 565SET value_1 = 4 566WHERE user_id IN 567 (SELECT DISTINCT e2.user_id 568 FROM users_reference_copy_table 569 LEFT JOIN users_test_table e2 ON (e2.user_id = users_reference_copy_table.value_1)) RETURNING *; 570 571-- Volatile functions are also not supported 572UPDATE users_test_table 573SET value_2 = 5 574FROM events_test_table 575WHERE users_test_table.user_id = events_test_table.user_id * random(); 576 577UPDATE users_test_table 578SET value_2 = 5 * random() 579FROM events_test_table 580WHERE users_test_table.user_id = events_test_table.user_id; 581 582UPDATE users_test_table 583SET value_1 = 3 584WHERE user_id = 1 AND value_1 IN (SELECT value_1 585 FROM users_test_table 586 WHERE user_id = 1 AND value_2 > random()); 587 588-- Recursive modify planner does not take care of following test because the query 589-- is fully pushdownable, yet not allowed because it would lead to inconsistent replicas. 590UPDATE users_test_table 591SET value_2 = subquery.random FROM (SELECT user_id, random() 592 FROM events_test_table) subquery 593WHERE users_test_table.user_id = subquery.user_id; 594 595-- Volatile functions in a subquery are recursively planned 596UPDATE users_test_table 597SET value_2 = 5 598WHERE users_test_table.user_id IN (SELECT user_id * random() FROM events_test_table); 599 600UPDATE users_test_table 601SET value_2 = subquery.random FROM (SELECT user_id, random() 602 FROM events_test_table) subquery; 603 604UPDATE users_test_table 605SET value_2 = subquery.random FROM (SELECT user_id, random() 606 FROM events_test_table OFFSET 0) subquery 607WHERE users_test_table.user_id = subquery.user_id; 608 609-- Make following tests consistent 610UPDATE users_test_table SET value_2 = 0; 611 612-- Joins with tables not supported 613UPDATE users_test_table 614SET value_2 = 5 615FROM events_test_table_local 616WHERE users_test_table.user_id = events_test_table_local.user_id; 617 618UPDATE events_test_table_local 619SET value_2 = 5 620FROM users_test_table 621WHERE events_test_table_local.user_id = users_test_table.user_id; 622 623-- Local tables in a subquery are supported through recursive planning 624UPDATE users_test_table 625SET value_2 = 5 626WHERE users_test_table.user_id IN(SELECT user_id FROM events_test_table_local); 627 628-- Shard counts of tables must be equal to pushdown the query 629UPDATE users_test_table 630SET value_2 = 5 631FROM events_test_table_2 632WHERE users_test_table.user_id = events_test_table_2.user_id; 633 634-- Should error out due to multiple row return from subquery, but we can not get this information within 635-- subquery pushdown planner. This query will be sent to worker with recursive planner. 636\set VERBOSITY terse 637DELETE FROM users_test_table 638WHERE users_test_table.user_id = (SELECT user_id 639 FROM events_test_table); 640\set VERBOSITY default 641 642-- Cursors are not supported 643BEGIN; 644DECLARE test_cursor CURSOR FOR SELECT * FROM users_test_table ORDER BY user_id; 645FETCH test_cursor; 646UPDATE users_test_table SET value_2 = 5 WHERE CURRENT OF test_cursor; 647ROLLBACK; 648 649-- Stable functions are supported 650SELECT * FROM test_table_1 ORDER BY 1 DESC, 2 DESC, 3 DESC; 651UPDATE test_table_1 SET col_3 = 3 WHERE date_col < now(); 652SELECT * FROM test_table_1 ORDER BY 1 DESC, 2 DESC, 3 DESC; 653DELETE FROM test_table_1 WHERE date_col < current_timestamp; 654SELECT * FROM test_table_1 ORDER BY 1 DESC, 2 DESC, 3 DESC; 655 656DROP TABLE test_table_1; 657 658-- Volatile functions are not supported 659CREATE TABLE test_table_2(id int, double_col double precision); 660INSERT INTO test_table_2 VALUES(1, random()); 661INSERT INTO test_table_2 VALUES(2, random()); 662INSERT INTO test_table_2 VALUES(3, random()); 663SELECT create_distributed_table('test_table_2', 'id'); 664 665UPDATE test_table_2 SET double_col = random(); 666 667DROP TABLE test_table_2; 668 669-- Run multi shard updates and deletes without transaction on reference tables 670SELECT COUNT(*) FROM users_reference_copy_table; 671UPDATE users_reference_copy_table SET value_1 = 1; 672SELECT SUM(value_1) FROM users_reference_copy_table; 673 674SELECT COUNT(*), SUM(value_2) FROM users_reference_copy_table WHERE user_id = 3 or user_id = 5; 675UPDATE users_reference_copy_table SET value_2 = value_2 + 1 WHERE user_id = 3 or user_id = 5; 676SELECT COUNT(*), SUM(value_2) FROM users_reference_copy_table WHERE user_id = 3 or user_id = 5; 677 678UPDATE users_reference_copy_table SET value_3 = 0 WHERE user_id <> 3; 679SELECT SUM(value_3) FROM users_reference_copy_table WHERE user_id <> 3; 680 681DELETE FROM users_reference_copy_table WHERE user_id = 3 or user_id = 5; 682SELECT COUNT(*) FROM users_reference_copy_table WHERE user_id = 3 or user_id = 5; 683 684-- Do some tests by changing shard replication factor 685DROP TABLE users_test_table; 686 687SET citus.shard_replication_factor to 2; 688 689CREATE TABLE users_test_table(user_id int, value_1 int, value_2 int, value_3 int); 690SELECT create_distributed_table('users_test_table', 'user_id'); 691\COPY users_test_table FROM STDIN DELIMITER AS ','; 6921, 5, 6, 7 6932, 12, 7, 18 6943, 23, 8, 25 6954, 42, 9, 23 6965, 35, 10, 21 6976, 21, 11, 25 6987, 27, 12, 18 6998, 18, 13, 4 7007, 38, 14, 22 7016, 43, 15, 22 7025, 61, 16, 17 7034, 6, 17, 8 7043, 16, 18, 44 7052, 25, 19, 38 7061, 55, 20, 17 707\. 708 709-- Run multi shard updates and deletes without transaction on hash distributed tables 710UPDATE users_test_table SET value_1 = 1; 711SELECT COUNT(*), SUM(value_1) FROM users_test_table; 712 713SELECT COUNT(*), SUM(value_2) FROM users_test_table WHERE user_id = 1 or user_id = 3; 714UPDATE users_test_table SET value_2 = value_2 + 1 WHERE user_id = 1 or user_id = 3; 715SELECT COUNT(*), SUM(value_2) FROM users_test_table WHERE user_id = 1 or user_id = 3; 716 717UPDATE users_test_table SET value_3 = 0 WHERE user_id <> 5; 718SELECT SUM(value_3) FROM users_test_table WHERE user_id <> 5; 719 720SELECT COUNT(*) FROM users_test_table WHERE user_id = 3 or user_id = 5; 721DELETE FROM users_test_table WHERE user_id = 3 or user_id = 5; 722SELECT COUNT(*) FROM users_test_table WHERE user_id = 3 or user_id = 5; 723 724DROP TABLE users_test_table; 725DROP TABLE events_test_table; 726DROP TABLE events_reference_copy_table; 727DROP TABLE users_reference_copy_table; 728