src/pl/plpython/expected/plpython_spi.out

   1 --
   2 -- nested calls
   3 --
   4 CREATE FUNCTION nested_call_one(a text) RETURNS text
   5         AS
   6 'q = "SELECT nested_call_two(''%s'')" % a
   7 r = plpy.execute(q)
   8 return r[0]'
   9         LANGUAGE plpythonu ;
  10 CREATE FUNCTION nested_call_two(a text) RETURNS text
  11         AS
  12 'q = "SELECT nested_call_three(''%s'')" % a
  13 r = plpy.execute(q)
  14 return r[0]'
  15         LANGUAGE plpythonu ;
  16 CREATE FUNCTION nested_call_three(a text) RETURNS text
  17         AS
  18 'return a'
  19         LANGUAGE plpythonu ;
  20 -- some spi stuff
  21 CREATE FUNCTION spi_prepared_plan_test_one(a text) RETURNS text
  22         AS
  23 'if "myplan" not in SD:
  24         q = "SELECT count(*) FROM users WHERE lname = $1"
  25         SD["myplan"] = plpy.prepare(q, [ "text" ])
  26 try:
  27         rv = plpy.execute(SD["myplan"], [a])
  28         return "there are " + str(rv[0]["count"]) + " " + str(a) + "s"
  29 except Exception as ex:
  30         plpy.error(str(ex))
  31 return None
  32 '
  33         LANGUAGE plpythonu;
  34 CREATE FUNCTION spi_prepared_plan_test_two(a text) RETURNS text
  35         AS
  36 'if "myplan" not in SD:
  37         q = "SELECT count(*) FROM users WHERE lname = $1"
  38         SD["myplan"] = plpy.prepare(q, [ "text" ])
  39 try:
  40         rv = SD["myplan"].execute([a])
  41         return "there are " + str(rv[0]["count"]) + " " + str(a) + "s"
  42 except Exception as ex:
  43         plpy.error(str(ex))
  44 return None
  45 '
  46         LANGUAGE plpythonu;
  47 CREATE FUNCTION spi_prepared_plan_test_nested(a text) RETURNS text
  48         AS
  49 'if "myplan" not in SD:
  50         q = "SELECT spi_prepared_plan_test_one(''%s'') as count" % a
  51         SD["myplan"] = plpy.prepare(q)
  52 try:
  53         rv = plpy.execute(SD["myplan"])
  54         if len(rv):
  55                 return rv[0]["count"]
  56 except Exception as ex:
  57         plpy.error(str(ex))
  58 return None
  59 '
  60         LANGUAGE plpythonu;
  61 CREATE FUNCTION join_sequences(s sequences) RETURNS text
  62         AS
  63 'if not s["multipart"]:
  64         return s["sequence"]
  65 q = "SELECT sequence FROM xsequences WHERE pid = ''%s''" % s["pid"]
  66 rv = plpy.execute(q)
  67 seq = s["sequence"]
  68 for r in rv:
  69         seq = seq + r["sequence"]
  70 return seq
  71 '
  72         LANGUAGE plpythonu;
  73 CREATE FUNCTION spi_recursive_sum(a int) RETURNS int
  74         AS
  75 'r = 0
  76 if a > 1:
  77     r = plpy.execute("SELECT spi_recursive_sum(%d) as a" % (a-1))[0]["a"]
  78 return a + r
  79 '
  80         LANGUAGE plpythonu;
  81 --
  82 -- spi and nested calls
  83 --
  84 select nested_call_one('pass this along');
  85                          nested_call_one
  86 -----------------------------------------------------------------
  87  {'nested_call_two': "{'nested_call_three': 'pass this along'}"}
  88 (1 row)
  89
  90 select spi_prepared_plan_test_one('doe');
  91  spi_prepared_plan_test_one
  92 ----------------------------
  93  there are 3 does
  94 (1 row)
  95
  96 select spi_prepared_plan_test_two('smith');
  97  spi_prepared_plan_test_two
  98 ----------------------------
  99  there are 1 smiths
 100 (1 row)
 101
 102 select spi_prepared_plan_test_nested('smith');
 103  spi_prepared_plan_test_nested
 104 -------------------------------
 105  there are 1 smiths
 106 (1 row)
 107
 108 SELECT join_sequences(sequences) FROM sequences;
 109  join_sequences
 110 ----------------
 111  ABCDEFGHIJKL
 112  ABCDEF
 113  ABCDEF
 114  ABCDEF
 115  ABCDEF
 116  ABCDEF
 117 (6 rows)
 118
 119 SELECT join_sequences(sequences) FROM sequences
 120         WHERE join_sequences(sequences) ~* '^A';
 121  join_sequences
 122 ----------------
 123  ABCDEFGHIJKL
 124  ABCDEF
 125  ABCDEF
 126  ABCDEF
 127  ABCDEF
 128  ABCDEF
 129 (6 rows)
 130
 131 SELECT join_sequences(sequences) FROM sequences
 132         WHERE join_sequences(sequences) ~* '^B';
 133  join_sequences
 134 ----------------
 135 (0 rows)
 136
 137 SELECT spi_recursive_sum(10);
 138  spi_recursive_sum
 139 -------------------
 140                 55
 141 (1 row)
 142
 143 --
 144 -- plan and result objects
 145 --
 146 CREATE FUNCTION result_metadata_test(cmd text) RETURNS int
 147 AS $$
 148 plan = plpy.prepare(cmd)
 149 plpy.info(plan.status()) # not really documented or useful
 150 result = plpy.execute(plan)
 151 if result.status() > 0:
 152    plpy.info(result.colnames())
 153    plpy.info(result.coltypes())
 154    plpy.info(result.coltypmods())
 155    return result.nrows()
 156 else:
 157    return None
 158 $$ LANGUAGE plpythonu;
 159 SELECT result_metadata_test($$SELECT 1 AS foo, '11'::text AS bar UNION SELECT 2, '22'$$);
 160 INFO:  True
 161 INFO:  ['foo', 'bar']
 162 INFO:  [23, 25]
 163 INFO:  [-1, -1]
 164  result_metadata_test
 165 ----------------------
 166                     2
 167 (1 row)
 168
 169 SELECT result_metadata_test($$CREATE TEMPORARY TABLE foo1 (a int, b text)$$);
 170 INFO:  True
 171 ERROR:  plpy.Error: command did not produce a result set
 172 CONTEXT:  Traceback (most recent call last):
 173   PL/Python function "result_metadata_test", line 6, in <module>
 174     plpy.info(result.colnames())
 175 PL/Python function "result_metadata_test"
 176 CREATE FUNCTION result_nrows_test(cmd text) RETURNS int
 177 AS $$
 178 result = plpy.execute(cmd)
 179 return result.nrows()
 180 $$ LANGUAGE plpythonu;
 181 SELECT result_nrows_test($$SELECT 1$$);
 182  result_nrows_test
 183 -------------------
 184                  1
 185 (1 row)
 186
 187 SELECT result_nrows_test($$CREATE TEMPORARY TABLE foo2 (a int, b text)$$);
 188  result_nrows_test
 189 -------------------
 190                  0
 191 (1 row)
 192
 193 SELECT result_nrows_test($$INSERT INTO foo2 VALUES (1, 'one'), (2, 'two')$$);
 194  result_nrows_test
 195 -------------------
 196                  2
 197 (1 row)
 198
 199 SELECT result_nrows_test($$UPDATE foo2 SET b = '' WHERE a = 2$$);
 200  result_nrows_test
 201 -------------------
 202                  1
 203 (1 row)
 204
 205 CREATE FUNCTION result_len_test(cmd text) RETURNS int
 206 AS $$
 207 result = plpy.execute(cmd)
 208 return len(result)
 209 $$ LANGUAGE plpythonu;
 210 SELECT result_len_test($$SELECT 1$$);
 211  result_len_test
 212 -----------------
 213                1
 214 (1 row)
 215
 216 SELECT result_len_test($$CREATE TEMPORARY TABLE foo3 (a int, b text)$$);
 217  result_len_test
 218 -----------------
 219                0
 220 (1 row)
 221
 222 SELECT result_len_test($$INSERT INTO foo3 VALUES (1, 'one'), (2, 'two')$$);
 223  result_len_test
 224 -----------------
 225                0
 226 (1 row)
 227
 228 SELECT result_len_test($$UPDATE foo3 SET b= '' WHERE a = 2$$);
 229  result_len_test
 230 -----------------
 231                0
 232 (1 row)
 233
 234 CREATE FUNCTION result_subscript_test() RETURNS void
 235 AS $$
 236 result = plpy.execute("SELECT 1 AS c UNION ALL SELECT 2 "
 237                       "UNION ALL SELECT 3 UNION ALL SELECT 4")
 238
 239 plpy.info(result[1]['c'])
 240 plpy.info(result[-1]['c'])
 241
 242 plpy.info([item['c'] for item in result[1:3]])
 243 plpy.info([item['c'] for item in result[::2]])
 244
 245 result[-1] = {'c': 1000}
 246 result[:2] = [{'c': 10}, {'c': 100}]
 247 plpy.info([item['c'] for item in result[:]])
 248
 249 # raises TypeError, but the message differs on Python 2.6, so silence it
 250 try:
 251     plpy.info(result['foo'])
 252 except TypeError:
 253     pass
 254 else:
 255     assert False, "TypeError not raised"
 256
 257 $$ LANGUAGE plpythonu;
 258 SELECT result_subscript_test();
 259 INFO:  2
 260 INFO:  4
 261 INFO:  [2, 3]
 262 INFO:  [1, 3]
 263 INFO:  [10, 100, 3, 1000]
 264  result_subscript_test
 265 -----------------------
 266
 267 (1 row)
 268
 269 CREATE FUNCTION result_empty_test() RETURNS void
 270 AS $$
 271 result = plpy.execute("select 1 where false")
 272
 273 plpy.info(result[:])
 274
 275 $$ LANGUAGE plpythonu;
 276 SELECT result_empty_test();
 277 INFO:  []
 278  result_empty_test
 279 -------------------
 280
 281 (1 row)
 282
 283 CREATE FUNCTION result_str_test(cmd text) RETURNS text
 284 AS $$
 285 plan = plpy.prepare(cmd)
 286 result = plpy.execute(plan)
 287 return str(result)
 288 $$ LANGUAGE plpythonu;
 289 SELECT result_str_test($$SELECT 1 AS foo UNION SELECT 2$$);
 290                       result_str_test
 291 ------------------------------------------------------------
 292  <PLyResult status=5 nrows=2 rows=[{'foo': 1}, {'foo': 2}]>
 293 (1 row)
 294
 295 SELECT result_str_test($$CREATE TEMPORARY TABLE foo1 (a int, b text)$$);
 296            result_str_test
 297 --------------------------------------
 298  <PLyResult status=4 nrows=0 rows=[]>
 299 (1 row)
 300
 301 -- cursor objects
 302 CREATE FUNCTION simple_cursor_test() RETURNS int AS $$
 303 res = plpy.cursor("select fname, lname from users")
 304 does = 0
 305 for row in res:
 306     if row['lname'] == 'doe':
 307         does += 1
 308 return does
 309 $$ LANGUAGE plpythonu;
 310 CREATE FUNCTION double_cursor_close() RETURNS int AS $$
 311 res = plpy.cursor("select fname, lname from users")
 312 res.close()
 313 res.close()
 314 $$ LANGUAGE plpythonu;
 315 CREATE FUNCTION cursor_fetch() RETURNS int AS $$
 316 res = plpy.cursor("select fname, lname from users")
 317 assert len(res.fetch(3)) == 3
 318 assert len(res.fetch(3)) == 1
 319 assert len(res.fetch(3)) == 0
 320 assert len(res.fetch(3)) == 0
 321 try:
 322     # use next() or __next__(), the method name changed in
 323     # http://www.python.org/dev/peps/pep-3114/
 324     try:
 325         res.next()
 326     except AttributeError:
 327         res.__next__()
 328 except StopIteration:
 329     pass
 330 else:
 331     assert False, "StopIteration not raised"
 332 $$ LANGUAGE plpythonu;
 333 CREATE FUNCTION cursor_mix_next_and_fetch() RETURNS int AS $$
 334 res = plpy.cursor("select fname, lname from users order by fname")
 335 assert len(res.fetch(2)) == 2
 336
 337 item = None
 338 try:
 339     item = res.next()
 340 except AttributeError:
 341     item = res.__next__()
 342 assert item['fname'] == 'rick'
 343
 344 assert len(res.fetch(2)) == 1
 345 $$ LANGUAGE plpythonu;
 346 CREATE FUNCTION fetch_after_close() RETURNS int AS $$
 347 res = plpy.cursor("select fname, lname from users")
 348 res.close()
 349 try:
 350     res.fetch(1)
 351 except ValueError:
 352     pass
 353 else:
 354     assert False, "ValueError not raised"
 355 $$ LANGUAGE plpythonu;
 356 CREATE FUNCTION next_after_close() RETURNS int AS $$
 357 res = plpy.cursor("select fname, lname from users")
 358 res.close()
 359 try:
 360     try:
 361         res.next()
 362     except AttributeError:
 363         res.__next__()
 364 except ValueError:
 365     pass
 366 else:
 367     assert False, "ValueError not raised"
 368 $$ LANGUAGE plpythonu;
 369 CREATE FUNCTION cursor_fetch_next_empty() RETURNS int AS $$
 370 res = plpy.cursor("select fname, lname from users where false")
 371 assert len(res.fetch(1)) == 0
 372 try:
 373     try:
 374         res.next()
 375     except AttributeError:
 376         res.__next__()
 377 except StopIteration:
 378     pass
 379 else:
 380     assert False, "StopIteration not raised"
 381 $$ LANGUAGE plpythonu;
 382 CREATE FUNCTION cursor_plan() RETURNS SETOF text AS $$
 383 plan = plpy.prepare(
 384     "select fname, lname from users where fname like $1 || '%' order by fname",
 385     ["text"])
 386 for row in plpy.cursor(plan, ["w"]):
 387     yield row['fname']
 388 for row in plan.cursor(["j"]):
 389     yield row['fname']
 390 $$ LANGUAGE plpythonu;
 391 CREATE FUNCTION cursor_plan_wrong_args() RETURNS SETOF text AS $$
 392 plan = plpy.prepare("select fname, lname from users where fname like $1 || '%'",
 393                     ["text"])
 394 c = plpy.cursor(plan, ["a", "b"])
 395 $$ LANGUAGE plpythonu;
 396 CREATE TYPE test_composite_type AS (
 397   a1 int,
 398   a2 varchar
 399 );
 400 CREATE OR REPLACE FUNCTION plan_composite_args() RETURNS test_composite_type AS $$
 401 plan = plpy.prepare("select $1 as c1", ["test_composite_type"])
 402 res = plpy.execute(plan, [{"a1": 3, "a2": "label"}])
 403 return res[0]["c1"]
 404 $$ LANGUAGE plpythonu;
 405 SELECT simple_cursor_test();
 406  simple_cursor_test
 407 --------------------
 408                   3
 409 (1 row)
 410
 411 SELECT double_cursor_close();
 412  double_cursor_close
 413 ---------------------
 414
 415 (1 row)
 416
 417 SELECT cursor_fetch();
 418  cursor_fetch
 419 --------------
 420
 421 (1 row)
 422
 423 SELECT cursor_mix_next_and_fetch();
 424  cursor_mix_next_and_fetch
 425 ---------------------------
 426
 427 (1 row)
 428
 429 SELECT fetch_after_close();
 430  fetch_after_close
 431 -------------------
 432
 433 (1 row)
 434
 435 SELECT next_after_close();
 436  next_after_close
 437 ------------------
 438
 439 (1 row)
 440
 441 SELECT cursor_fetch_next_empty();
 442  cursor_fetch_next_empty
 443 -------------------------
 444
 445 (1 row)
 446
 447 SELECT cursor_plan();
 448  cursor_plan
 449 -------------
 450  willem
 451  jane
 452  john
 453 (3 rows)
 454
 455 SELECT cursor_plan_wrong_args();
 456 ERROR:  TypeError: Expected sequence of 1 argument, got 2: ['a', 'b']
 457 CONTEXT:  Traceback (most recent call last):
 458   PL/Python function "cursor_plan_wrong_args", line 4, in <module>
 459     c = plpy.cursor(plan, ["a", "b"])
 460 PL/Python function "cursor_plan_wrong_args"
 461 SELECT plan_composite_args();
 462  plan_composite_args
 463 ---------------------
 464  (3,label)
 465 (1 row)
 466