src/pl/plpython/expected/plpython_subtransaction.out

   1 --
   2 -- Test explicit subtransactions
   3 --
   4 -- Test table to see if transactions get properly rolled back
   5 CREATE TABLE subtransaction_tbl (
   6     i integer
   7 );
   8 CREATE FUNCTION subtransaction_ctx_test(what_error text = NULL) RETURNS text
   9 AS $$
  10 with plpy.subtransaction():
  11     plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
  12     plpy.execute("INSERT INTO subtransaction_tbl VALUES (2)")
  13     if what_error == "SPI":
  14         plpy.execute("INSERT INTO subtransaction_tbl VALUES ('oops')")
  15     elif what_error == "Python":
  16         raise Exception("Python exception")
  17 $$ LANGUAGE plpythonu;
  18 SELECT subtransaction_ctx_test();
  19  subtransaction_ctx_test
  20 -------------------------
  21
  22 (1 row)
  23
  24 SELECT * FROM subtransaction_tbl;
  25  i
  26 ---
  27  1
  28  2
  29 (2 rows)
  30
  31 TRUNCATE subtransaction_tbl;
  32 SELECT subtransaction_ctx_test('SPI');
  33 ERROR:  spiexceptions.InvalidTextRepresentation: invalid input syntax for type integer: "oops"
  34 LINE 1: INSERT INTO subtransaction_tbl VALUES ('oops')
  35                                                ^
  36 QUERY:  INSERT INTO subtransaction_tbl VALUES ('oops')
  37 CONTEXT:  Traceback (most recent call last):
  38   PL/Python function "subtransaction_ctx_test", line 6, in <module>
  39     plpy.execute("INSERT INTO subtransaction_tbl VALUES ('oops')")
  40 PL/Python function "subtransaction_ctx_test"
  41 SELECT * FROM subtransaction_tbl;
  42  i
  43 ---
  44 (0 rows)
  45
  46 TRUNCATE subtransaction_tbl;
  47 SELECT subtransaction_ctx_test('Python');
  48 ERROR:  Exception: Python exception
  49 CONTEXT:  Traceback (most recent call last):
  50   PL/Python function "subtransaction_ctx_test", line 8, in <module>
  51     raise Exception("Python exception")
  52 PL/Python function "subtransaction_ctx_test"
  53 SELECT * FROM subtransaction_tbl;
  54  i
  55 ---
  56 (0 rows)
  57
  58 TRUNCATE subtransaction_tbl;
  59 -- Nested subtransactions
  60 CREATE FUNCTION subtransaction_nested_test(swallow boolean = 'f') RETURNS text
  61 AS $$
  62 plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
  63 with plpy.subtransaction():
  64     plpy.execute("INSERT INTO subtransaction_tbl VALUES (2)")
  65     try:
  66         with plpy.subtransaction():
  67             plpy.execute("INSERT INTO subtransaction_tbl VALUES (3)")
  68             plpy.execute("error")
  69     except plpy.SPIError as e:
  70         if not swallow:
  71             raise
  72         plpy.notice("Swallowed %s(%r)" % (e.__class__.__name__, e.args[0]))
  73 return "ok"
  74 $$ LANGUAGE plpythonu;
  75 SELECT subtransaction_nested_test();
  76 ERROR:  spiexceptions.SyntaxError: syntax error at or near "error"
  77 LINE 1: error
  78         ^
  79 QUERY:  error
  80 CONTEXT:  Traceback (most recent call last):
  81   PL/Python function "subtransaction_nested_test", line 8, in <module>
  82     plpy.execute("error")
  83 PL/Python function "subtransaction_nested_test"
  84 SELECT * FROM subtransaction_tbl;
  85  i
  86 ---
  87 (0 rows)
  88
  89 TRUNCATE subtransaction_tbl;
  90 SELECT subtransaction_nested_test('t');
  91 NOTICE:  Swallowed SyntaxError('syntax error at or near "error"')
  92  subtransaction_nested_test
  93 ----------------------------
  94  ok
  95 (1 row)
  96
  97 SELECT * FROM subtransaction_tbl;
  98  i
  99 ---
 100  1
 101  2
 102 (2 rows)
 103
 104 TRUNCATE subtransaction_tbl;
 105 -- Nested subtransactions that recursively call code dealing with
 106 -- subtransactions
 107 CREATE FUNCTION subtransaction_deeply_nested_test() RETURNS text
 108 AS $$
 109 plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
 110 with plpy.subtransaction():
 111     plpy.execute("INSERT INTO subtransaction_tbl VALUES (2)")
 112     plpy.execute("SELECT subtransaction_nested_test('t')")
 113 return "ok"
 114 $$ LANGUAGE plpythonu;
 115 SELECT subtransaction_deeply_nested_test();
 116 NOTICE:  Swallowed SyntaxError('syntax error at or near "error"')
 117  subtransaction_deeply_nested_test
 118 -----------------------------------
 119  ok
 120 (1 row)
 121
 122 SELECT * FROM subtransaction_tbl;
 123  i
 124 ---
 125  1
 126  2
 127  1
 128  2
 129 (4 rows)
 130
 131 TRUNCATE subtransaction_tbl;
 132 -- Error conditions from not opening/closing subtransactions
 133 CREATE FUNCTION subtransaction_exit_without_enter() RETURNS void
 134 AS $$
 135 plpy.subtransaction().__exit__(None, None, None)
 136 $$ LANGUAGE plpythonu;
 137 CREATE FUNCTION subtransaction_enter_without_exit() RETURNS void
 138 AS $$
 139 plpy.subtransaction().__enter__()
 140 $$ LANGUAGE plpythonu;
 141 CREATE FUNCTION subtransaction_exit_twice() RETURNS void
 142 AS $$
 143 plpy.subtransaction().__enter__()
 144 plpy.subtransaction().__exit__(None, None, None)
 145 plpy.subtransaction().__exit__(None, None, None)
 146 $$ LANGUAGE plpythonu;
 147 CREATE FUNCTION subtransaction_enter_twice() RETURNS void
 148 AS $$
 149 plpy.subtransaction().__enter__()
 150 plpy.subtransaction().__enter__()
 151 $$ LANGUAGE plpythonu;
 152 CREATE FUNCTION subtransaction_exit_same_subtransaction_twice() RETURNS void
 153 AS $$
 154 s = plpy.subtransaction()
 155 s.__enter__()
 156 s.__exit__(None, None, None)
 157 s.__exit__(None, None, None)
 158 $$ LANGUAGE plpythonu;
 159 CREATE FUNCTION subtransaction_enter_same_subtransaction_twice() RETURNS void
 160 AS $$
 161 s = plpy.subtransaction()
 162 s.__enter__()
 163 s.__enter__()
 164 s.__exit__(None, None, None)
 165 $$ LANGUAGE plpythonu;
 166 -- No warnings here, as the subtransaction gets indeed closed
 167 CREATE FUNCTION subtransaction_enter_subtransaction_in_with() RETURNS void
 168 AS $$
 169 with plpy.subtransaction() as s:
 170     s.__enter__()
 171 $$ LANGUAGE plpythonu;
 172 CREATE FUNCTION subtransaction_exit_subtransaction_in_with() RETURNS void
 173 AS $$
 174 try:
 175     with plpy.subtransaction() as s:
 176         s.__exit__(None, None, None)
 177 except ValueError as e:
 178     raise ValueError(e)
 179 $$ LANGUAGE plpythonu;
 180 SELECT subtransaction_exit_without_enter();
 181 ERROR:  ValueError: this subtransaction has not been entered
 182 CONTEXT:  Traceback (most recent call last):
 183   PL/Python function "subtransaction_exit_without_enter", line 2, in <module>
 184     plpy.subtransaction().__exit__(None, None, None)
 185 PL/Python function "subtransaction_exit_without_enter"
 186 SELECT subtransaction_enter_without_exit();
 187 WARNING:  forcibly aborting a subtransaction that has not been exited
 188  subtransaction_enter_without_exit
 189 -----------------------------------
 190
 191 (1 row)
 192
 193 SELECT subtransaction_exit_twice();
 194 WARNING:  forcibly aborting a subtransaction that has not been exited
 195 ERROR:  ValueError: this subtransaction has not been entered
 196 CONTEXT:  Traceback (most recent call last):
 197   PL/Python function "subtransaction_exit_twice", line 3, in <module>
 198     plpy.subtransaction().__exit__(None, None, None)
 199 PL/Python function "subtransaction_exit_twice"
 200 SELECT subtransaction_enter_twice();
 201 WARNING:  forcibly aborting a subtransaction that has not been exited
 202 WARNING:  forcibly aborting a subtransaction that has not been exited
 203  subtransaction_enter_twice
 204 ----------------------------
 205
 206 (1 row)
 207
 208 SELECT subtransaction_exit_same_subtransaction_twice();
 209 ERROR:  ValueError: this subtransaction has already been exited
 210 CONTEXT:  Traceback (most recent call last):
 211   PL/Python function "subtransaction_exit_same_subtransaction_twice", line 5, in <module>
 212     s.__exit__(None, None, None)
 213 PL/Python function "subtransaction_exit_same_subtransaction_twice"
 214 SELECT subtransaction_enter_same_subtransaction_twice();
 215 WARNING:  forcibly aborting a subtransaction that has not been exited
 216 ERROR:  ValueError: this subtransaction has already been entered
 217 CONTEXT:  Traceback (most recent call last):
 218   PL/Python function "subtransaction_enter_same_subtransaction_twice", line 4, in <module>
 219     s.__enter__()
 220 PL/Python function "subtransaction_enter_same_subtransaction_twice"
 221 SELECT subtransaction_enter_subtransaction_in_with();
 222 ERROR:  ValueError: this subtransaction has already been entered
 223 CONTEXT:  Traceback (most recent call last):
 224   PL/Python function "subtransaction_enter_subtransaction_in_with", line 3, in <module>
 225     s.__enter__()
 226 PL/Python function "subtransaction_enter_subtransaction_in_with"
 227 SELECT subtransaction_exit_subtransaction_in_with();
 228 ERROR:  ValueError: this subtransaction has already been exited
 229 CONTEXT:  Traceback (most recent call last):
 230   PL/Python function "subtransaction_exit_subtransaction_in_with", line 6, in <module>
 231     raise ValueError(e)
 232 PL/Python function "subtransaction_exit_subtransaction_in_with"
 233 -- Make sure we don't get a "current transaction is aborted" error
 234 SELECT 1 as test;
 235  test
 236 ------
 237     1
 238 (1 row)
 239
 240 -- Mix explicit subtransactions and normal SPI calls
 241 CREATE FUNCTION subtransaction_mix_explicit_and_implicit() RETURNS void
 242 AS $$
 243 p = plpy.prepare("INSERT INTO subtransaction_tbl VALUES ($1)", ["integer"])
 244 try:
 245     with plpy.subtransaction():
 246         plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
 247         plpy.execute(p, [2])
 248         plpy.execute(p, ["wrong"])
 249 except plpy.SPIError:
 250     plpy.warning("Caught a SPI error from an explicit subtransaction")
 251
 252 try:
 253     plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
 254     plpy.execute(p, [2])
 255     plpy.execute(p, ["wrong"])
 256 except plpy.SPIError:
 257     plpy.warning("Caught a SPI error")
 258 $$ LANGUAGE plpythonu;
 259 SELECT subtransaction_mix_explicit_and_implicit();
 260 WARNING:  Caught a SPI error from an explicit subtransaction
 261 WARNING:  Caught a SPI error
 262  subtransaction_mix_explicit_and_implicit
 263 ------------------------------------------
 264
 265 (1 row)
 266
 267 SELECT * FROM subtransaction_tbl;
 268  i
 269 ---
 270  1
 271  2
 272 (2 rows)
 273
 274 TRUNCATE subtransaction_tbl;
 275 -- Alternative method names for Python <2.6
 276 CREATE FUNCTION subtransaction_alternative_names() RETURNS void
 277 AS $$
 278 s = plpy.subtransaction()
 279 s.enter()
 280 s.exit(None, None, None)
 281 $$ LANGUAGE plpythonu;
 282 SELECT subtransaction_alternative_names();
 283  subtransaction_alternative_names
 284 ----------------------------------
 285
 286 (1 row)
 287
 288 -- try/catch inside a subtransaction block
 289 CREATE FUNCTION try_catch_inside_subtransaction() RETURNS void
 290 AS $$
 291 with plpy.subtransaction():
 292      plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
 293      try:
 294          plpy.execute("INSERT INTO subtransaction_tbl VALUES ('a')")
 295      except plpy.SPIError:
 296          plpy.notice("caught")
 297 $$ LANGUAGE plpythonu;
 298 SELECT try_catch_inside_subtransaction();
 299 NOTICE:  caught
 300  try_catch_inside_subtransaction
 301 ---------------------------------
 302
 303 (1 row)
 304
 305 SELECT * FROM subtransaction_tbl;
 306  i
 307 ---
 308  1
 309 (1 row)
 310
 311 TRUNCATE subtransaction_tbl;
 312 ALTER TABLE subtransaction_tbl ADD PRIMARY KEY (i);
 313 CREATE FUNCTION pk_violation_inside_subtransaction() RETURNS void
 314 AS $$
 315 with plpy.subtransaction():
 316      plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
 317      try:
 318          plpy.execute("INSERT INTO subtransaction_tbl VALUES (1)")
 319      except plpy.SPIError:
 320          plpy.notice("caught")
 321 $$ LANGUAGE plpythonu;
 322 SELECT pk_violation_inside_subtransaction();
 323 NOTICE:  caught
 324  pk_violation_inside_subtransaction
 325 ------------------------------------
 326
 327 (1 row)
 328
 329 SELECT * FROM subtransaction_tbl;
 330  i
 331 ---
 332  1
 333 (1 row)
 334
 335 DROP TABLE subtransaction_tbl;
 336 -- cursor/subtransactions interactions
 337 CREATE FUNCTION cursor_in_subxact() RETURNS int AS $$
 338 with plpy.subtransaction():
 339     cur = plpy.cursor("select * from generate_series(1, 20) as gen(i)")
 340     cur.fetch(10)
 341 fetched = cur.fetch(10);
 342 return int(fetched[5]["i"])
 343 $$ LANGUAGE plpythonu;
 344 CREATE FUNCTION cursor_aborted_subxact() RETURNS int AS $$
 345 try:
 346     with plpy.subtransaction():
 347         cur = plpy.cursor("select * from generate_series(1, 20) as gen(i)")
 348         cur.fetch(10);
 349         plpy.execute("select no_such_function()")
 350 except plpy.SPIError:
 351     fetched = cur.fetch(10)
 352     return int(fetched[5]["i"])
 353 return 0 # not reached
 354 $$ LANGUAGE plpythonu;
 355 CREATE FUNCTION cursor_plan_aborted_subxact() RETURNS int AS $$
 356 try:
 357     with plpy.subtransaction():
 358         plpy.execute('create temporary table tmp(i) '
 359                      'as select generate_series(1, 10)')
 360         plan = plpy.prepare("select i from tmp")
 361         cur = plpy.cursor(plan)
 362         plpy.execute("select no_such_function()")
 363 except plpy.SPIError:
 364     fetched = cur.fetch(5)
 365     return fetched[2]["i"]
 366 return 0 # not reached
 367 $$ LANGUAGE plpythonu;
 368 CREATE FUNCTION cursor_close_aborted_subxact() RETURNS boolean AS $$
 369 try:
 370     with plpy.subtransaction():
 371         cur = plpy.cursor('select 1')
 372         plpy.execute("select no_such_function()")
 373 except plpy.SPIError:
 374     cur.close()
 375     return True
 376 return False # not reached
 377 $$ LANGUAGE plpythonu;
 378 SELECT cursor_in_subxact();
 379  cursor_in_subxact
 380 -------------------
 381                 16
 382 (1 row)
 383
 384 SELECT cursor_aborted_subxact();
 385 ERROR:  ValueError: iterating a cursor in an aborted subtransaction
 386 CONTEXT:  Traceback (most recent call last):
 387   PL/Python function "cursor_aborted_subxact", line 8, in <module>
 388     fetched = cur.fetch(10)
 389 PL/Python function "cursor_aborted_subxact"
 390 SELECT cursor_plan_aborted_subxact();
 391 ERROR:  ValueError: iterating a cursor in an aborted subtransaction
 392 CONTEXT:  Traceback (most recent call last):
 393   PL/Python function "cursor_plan_aborted_subxact", line 10, in <module>
 394     fetched = cur.fetch(5)
 395 PL/Python function "cursor_plan_aborted_subxact"
 396 SELECT cursor_close_aborted_subxact();
 397 ERROR:  ValueError: closing a cursor in an aborted subtransaction
 398 CONTEXT:  Traceback (most recent call last):
 399   PL/Python function "cursor_close_aborted_subxact", line 7, in <module>
 400     cur.close()
 401 PL/Python function "cursor_close_aborted_subxact"