src/pl/plpython/expected/plpython_function.out

   1 CREATE FUNCTION global_test_one() returns text
   2     AS
   3 'if not SD.has_key("global_test"):
   4         SD["global_test"] = "set by global_test_one"
   5 if not GD.has_key("global_test"):
   6         GD["global_test"] = "set by global_test_one"
   7 return "SD: " + SD["global_test"] + ", GD: " + GD["global_test"]'
   8     LANGUAGE plpythonu;
   9 CREATE FUNCTION global_test_two() returns text
  10     AS
  11 'if not SD.has_key("global_test"):
  12         SD["global_test"] = "set by global_test_two"
  13 if not GD.has_key("global_test"):
  14         GD["global_test"] = "set by global_test_two"
  15 return "SD: " + SD["global_test"] + ", GD: " + GD["global_test"]'
  16     LANGUAGE plpythonu;
  17 CREATE FUNCTION static_test() returns int4
  18     AS
  19 'if SD.has_key("call"):
  20         SD["call"] = SD["call"] + 1
  21 else:
  22         SD["call"] = 1
  23 return SD["call"]
  24 '
  25     LANGUAGE plpythonu;
  26 -- import python modules
  27 CREATE FUNCTION import_fail() returns text
  28     AS
  29 'try:
  30         import foosocket
  31 except Exception, ex:
  32         plpy.notice("import socket failed -- %s" % str(ex))
  33         return "failed as expected"
  34 return "succeeded, that wasn''t supposed to happen"'
  35     LANGUAGE plpythonu;
  36 CREATE FUNCTION import_succeed() returns text
  37         AS
  38 'try:
  39   import array
  40   import bisect
  41   import calendar
  42   import cmath
  43   import errno
  44   import math
  45   import md5
  46   import operator
  47   import random
  48   import re
  49   import sha
  50   import string
  51   import time
  52 except Exception, ex:
  53         plpy.notice("import failed -- %s" % str(ex))
  54         return "failed, that wasn''t supposed to happen"
  55 return "succeeded, as expected"'
  56     LANGUAGE plpythonu;
  57 CREATE FUNCTION import_test_one(p text) RETURNS text
  58         AS
  59 'import sha
  60 digest = sha.new(p)
  61 return digest.hexdigest()'
  62         LANGUAGE plpythonu;
  63 CREATE FUNCTION import_test_two(u users) RETURNS text
  64         AS
  65 'import sha
  66 plain = u["fname"] + u["lname"]
  67 digest = sha.new(plain);
  68 return "sha hash of " + plain + " is " + digest.hexdigest()'
  69         LANGUAGE plpythonu;
  70 CREATE FUNCTION argument_test_one(u users, a1 text, a2 text) RETURNS text
  71         AS
  72 'keys = u.keys()
  73 keys.sort()
  74 out = []
  75 for key in keys:
  76     out.append("%s: %s" % (key, u[key]))
  77 words = a1 + " " + a2 + " => {" + ", ".join(out) + "}"
  78 return words'
  79         LANGUAGE plpythonu;
  80 -- these triggers are dedicated to HPHC of RI who
  81 -- decided that my kid's name was william not willem, and
  82 -- vigorously resisted all efforts at correction.  they have
  83 -- since gone bankrupt...
  84 CREATE FUNCTION users_insert() returns trigger
  85         AS
  86 'if TD["new"]["fname"] == None or TD["new"]["lname"] == None:
  87         return "SKIP"
  88 if TD["new"]["username"] == None:
  89         TD["new"]["username"] = TD["new"]["fname"][:1] + "_" + TD["new"]["lname"]
  90         rv = "MODIFY"
  91 else:
  92         rv = None
  93 if TD["new"]["fname"] == "william":
  94         TD["new"]["fname"] = TD["args"][0]
  95         rv = "MODIFY"
  96 return rv'
  97         LANGUAGE plpythonu;
  98 CREATE FUNCTION users_update() returns trigger
  99         AS
 100 'if TD["event"] == "UPDATE":
 101         if TD["old"]["fname"] != TD["new"]["fname"] and TD["old"]["fname"] == TD["args"][0]:
 102                 return "SKIP"
 103 return None'
 104         LANGUAGE plpythonu;
 105 CREATE FUNCTION users_delete() RETURNS trigger
 106         AS
 107 'if TD["old"]["fname"] == TD["args"][0]:
 108         return "SKIP"
 109 return None'
 110         LANGUAGE plpythonu;
 111 CREATE TRIGGER users_insert_trig BEFORE INSERT ON users FOR EACH ROW
 112         EXECUTE PROCEDURE users_insert ('willem');
 113 CREATE TRIGGER users_update_trig BEFORE UPDATE ON users FOR EACH ROW
 114         EXECUTE PROCEDURE users_update ('willem');
 115 CREATE TRIGGER users_delete_trig BEFORE DELETE ON users FOR EACH ROW
 116         EXECUTE PROCEDURE users_delete ('willem');
 117 -- dump trigger data
 118 CREATE TABLE trigger_test
 119         (i int, v text );
 120 CREATE FUNCTION trigger_data() returns trigger language plpythonu as $$
 121
 122 if TD.has_key('relid'):
 123         TD['relid'] = "bogus:12345"
 124
 125 skeys = TD.keys()
 126 skeys.sort()
 127 for key in skeys:
 128         val = TD[key]
 129         plpy.notice("TD[" + key + "] => " + str(val))
 130
 131 return None
 132
 133 $$;
 134 CREATE TRIGGER show_trigger_data_trig
 135 BEFORE INSERT OR UPDATE OR DELETE ON trigger_test
 136 FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
 137 insert into trigger_test values(1,'insert');
 138 NOTICE:  ("TD[args] => ['23', 'skidoo']",)
 139 NOTICE:  ('TD[event] => INSERT',)
 140 NOTICE:  ('TD[level] => ROW',)
 141 NOTICE:  ('TD[name] => show_trigger_data_trig',)
 142 NOTICE:  ("TD[new] => {'i': 1, 'v': 'insert'}",)
 143 NOTICE:  ('TD[old] => None',)
 144 NOTICE:  ('TD[relid] => bogus:12345',)
 145 NOTICE:  ('TD[table_name] => trigger_test',)
 146 NOTICE:  ('TD[table_schema] => public',)
 147 NOTICE:  ('TD[when] => BEFORE',)
 148 update trigger_test set v = 'update' where i = 1;
 149 NOTICE:  ("TD[args] => ['23', 'skidoo']",)
 150 NOTICE:  ('TD[event] => UPDATE',)
 151 NOTICE:  ('TD[level] => ROW',)
 152 NOTICE:  ('TD[name] => show_trigger_data_trig',)
 153 NOTICE:  ("TD[new] => {'i': 1, 'v': 'update'}",)
 154 NOTICE:  ("TD[old] => {'i': 1, 'v': 'insert'}",)
 155 NOTICE:  ('TD[relid] => bogus:12345',)
 156 NOTICE:  ('TD[table_name] => trigger_test',)
 157 NOTICE:  ('TD[table_schema] => public',)
 158 NOTICE:  ('TD[when] => BEFORE',)
 159 delete from trigger_test;
 160 NOTICE:  ("TD[args] => ['23', 'skidoo']",)
 161 NOTICE:  ('TD[event] => DELETE',)
 162 NOTICE:  ('TD[level] => ROW',)
 163 NOTICE:  ('TD[name] => show_trigger_data_trig',)
 164 NOTICE:  ('TD[new] => None',)
 165 NOTICE:  ("TD[old] => {'i': 1, 'v': 'update'}",)
 166 NOTICE:  ('TD[relid] => bogus:12345',)
 167 NOTICE:  ('TD[table_name] => trigger_test',)
 168 NOTICE:  ('TD[table_schema] => public',)
 169 NOTICE:  ('TD[when] => BEFORE',)
 170
 171 DROP TRIGGER show_trigger_data_trig on trigger_test;
 172
 173 DROP FUNCTION trigger_data();
 174 -- nested calls
 175 --
 176 CREATE FUNCTION nested_call_one(a text) RETURNS text
 177         AS
 178 'q = "SELECT nested_call_two(''%s'')" % a
 179 r = plpy.execute(q)
 180 return r[0]'
 181         LANGUAGE plpythonu ;
 182 CREATE FUNCTION nested_call_two(a text) RETURNS text
 183         AS
 184 'q = "SELECT nested_call_three(''%s'')" % a
 185 r = plpy.execute(q)
 186 return r[0]'
 187         LANGUAGE plpythonu ;
 188 CREATE FUNCTION nested_call_three(a text) RETURNS text
 189         AS
 190 'return a'
 191         LANGUAGE plpythonu ;
 192 -- some spi stuff
 193 CREATE FUNCTION spi_prepared_plan_test_one(a text) RETURNS text
 194         AS
 195 'if not SD.has_key("myplan"):
 196         q = "SELECT count(*) FROM users WHERE lname = $1"
 197         SD["myplan"] = plpy.prepare(q, [ "text" ])
 198 try:
 199         rv = plpy.execute(SD["myplan"], [a])
 200         return "there are " + str(rv[0]["count"]) + " " + str(a) + "s"
 201 except Exception, ex:
 202         plpy.error(str(ex))
 203 return None
 204 '
 205         LANGUAGE plpythonu;
 206 CREATE FUNCTION spi_prepared_plan_test_nested(a text) RETURNS text
 207         AS
 208 'if not SD.has_key("myplan"):
 209         q = "SELECT spi_prepared_plan_test_one(''%s'') as count" % a
 210         SD["myplan"] = plpy.prepare(q)
 211 try:
 212         rv = plpy.execute(SD["myplan"])
 213         if len(rv):
 214                 return rv[0]["count"]
 215 except Exception, ex:
 216         plpy.error(str(ex))
 217 return None
 218 '
 219         LANGUAGE plpythonu;
 220 /* really stupid function just to get the module loaded
 221 */
 222 CREATE FUNCTION stupid() RETURNS text AS 'return "zarkon"' LANGUAGE plpythonu;
 223 /* a typo
 224 */
 225 CREATE FUNCTION invalid_type_uncaught(a text) RETURNS text
 226         AS
 227 'if not SD.has_key("plan"):
 228         q = "SELECT fname FROM users WHERE lname = $1"
 229         SD["plan"] = plpy.prepare(q, [ "test" ])
 230 rv = plpy.execute(SD["plan"], [ a ])
 231 if len(rv):
 232         return rv[0]["fname"]
 233 return None
 234 '
 235         LANGUAGE plpythonu;
 236 /* for what it's worth catch the exception generated by
 237  * the typo, and return None
 238  */
 239 CREATE FUNCTION invalid_type_caught(a text) RETURNS text
 240         AS
 241 'if not SD.has_key("plan"):
 242         q = "SELECT fname FROM users WHERE lname = $1"
 243         try:
 244                 SD["plan"] = plpy.prepare(q, [ "test" ])
 245         except plpy.SPIError, ex:
 246                 plpy.notice(str(ex))
 247                 return None
 248 rv = plpy.execute(SD["plan"], [ a ])
 249 if len(rv):
 250         return rv[0]["fname"]
 251 return None
 252 '
 253         LANGUAGE plpythonu;
 254 /* for what it's worth catch the exception generated by
 255  * the typo, and reraise it as a plain error
 256  */
 257 CREATE FUNCTION invalid_type_reraised(a text) RETURNS text
 258         AS
 259 'if not SD.has_key("plan"):
 260         q = "SELECT fname FROM users WHERE lname = $1"
 261         try:
 262                 SD["plan"] = plpy.prepare(q, [ "test" ])
 263         except plpy.SPIError, ex:
 264                 plpy.error(str(ex))
 265 rv = plpy.execute(SD["plan"], [ a ])
 266 if len(rv):
 267         return rv[0]["fname"]
 268 return None
 269 '
 270         LANGUAGE plpythonu;
 271 /* no typo no messing about
 272 */
 273 CREATE FUNCTION valid_type(a text) RETURNS text
 274         AS
 275 'if not SD.has_key("plan"):
 276         SD["plan"] = plpy.prepare("SELECT fname FROM users WHERE lname = $1", [ "text" ])
 277 rv = plpy.execute(SD["plan"], [ a ])
 278 if len(rv):
 279         return rv[0]["fname"]
 280 return None
 281 '
 282         LANGUAGE plpythonu;
 283 /* Flat out syntax error
 284 */
 285 CREATE FUNCTION sql_syntax_error() RETURNS text
 286         AS
 287 'plpy.execute("syntax error")'
 288         LANGUAGE plpythonu;
 289 /* check the handling of uncaught python exceptions
 290  */
 291 CREATE FUNCTION exception_index_invalid(text) RETURNS text
 292         AS
 293 'return args[1]'
 294         LANGUAGE plpythonu;
 295 /* check handling of nested exceptions
 296  */
 297 CREATE FUNCTION exception_index_invalid_nested() RETURNS text
 298         AS
 299 'rv = plpy.execute("SELECT test5(''foo'')")
 300 return rv[0]'
 301         LANGUAGE plpythonu;
 302 CREATE FUNCTION join_sequences(s sequences) RETURNS text
 303         AS
 304 'if not s["multipart"]:
 305         return s["sequence"]
 306 q = "SELECT sequence FROM xsequences WHERE pid = ''%s''" % s["pid"]
 307 rv = plpy.execute(q)
 308 seq = s["sequence"]
 309 for r in rv:
 310         seq = seq + r["sequence"]
 311 return seq
 312 '
 313         LANGUAGE plpythonu;
 314 --
 315 -- Universal Newline Support
 316 --
 317 CREATE OR REPLACE FUNCTION newline_lf() RETURNS integer AS
 318 E'x = 100\ny = 23\nreturn x + y\n'
 319 LANGUAGE plpythonu;
 320 CREATE OR REPLACE FUNCTION newline_cr() RETURNS integer AS
 321 E'x = 100\ry = 23\rreturn x + y\r'
 322 LANGUAGE plpythonu;
 323 CREATE OR REPLACE FUNCTION newline_crlf() RETURNS integer AS
 324 E'x = 100\r\ny = 23\r\nreturn x + y\r\n'
 325 LANGUAGE plpythonu;
 326 --
 327 -- Unicode error handling
 328 --
 329 CREATE FUNCTION unicode_return_error() RETURNS text AS E'
 330 return u"\\x80"
 331 ' LANGUAGE plpythonu;
 332 CREATE FUNCTION unicode_trigger_error() RETURNS trigger AS E'
 333 TD["new"]["testvalue"] = u"\\x80"
 334 return "MODIFY"
 335 ' LANGUAGE plpythonu;
 336 CREATE TRIGGER unicode_test_bi BEFORE INSERT ON unicode_test
 337   FOR EACH ROW EXECUTE PROCEDURE unicode_trigger_error();
 338 CREATE FUNCTION unicode_plan_error1() RETURNS text AS E'
 339 plan = plpy.prepare("SELECT $1 AS testvalue", ["text"])
 340 rv = plpy.execute(plan, [u"\\x80"], 1)
 341 return rv[0]["testvalue"]
 342 ' LANGUAGE plpythonu;
 343 CREATE FUNCTION unicode_plan_error2() RETURNS text AS E'
 344 plan = plpy.prepare("SELECT $1 AS testvalue1, $2 AS testvalue2", ["text", "text"])
 345 rv = plpy.execute(plan, u"\\x80", 1)
 346 return rv[0]["testvalue1"]
 347 ' LANGUAGE plpythonu;
 348 -- Tests for functions that return void
 349 CREATE FUNCTION test_void_func1() RETURNS void AS $$
 350 x = 10
 351 $$ LANGUAGE plpythonu;
 352 -- illegal: can't return non-None value in void-returning func
 353 CREATE FUNCTION test_void_func2() RETURNS void AS $$
 354 return 10
 355 $$ LANGUAGE plpythonu;
 356 CREATE FUNCTION test_return_none() RETURNS int AS $$
 357 None
 358 $$ LANGUAGE plpythonu;
 359 --
 360 -- Test named parameters
 361 --
 362 CREATE FUNCTION test_param_names1(a0 integer, a1 text) RETURNS boolean AS $$
 363 assert a0 == args[0]
 364 assert a1 == args[1]
 365 return True
 366 $$ LANGUAGE plpythonu;
 367 CREATE FUNCTION test_param_names2(u users) RETURNS text AS $$
 368 assert u == args[0]
 369 return str(u)
 370 $$ LANGUAGE plpythonu;
 371 -- use deliberately wrong parameter names
 372 CREATE FUNCTION test_param_names3(a0 integer) RETURNS boolean AS $$
 373 try:
 374         assert a1 == args[0]
 375         return False
 376 except NameError, e:
 377         assert e.args[0].find("a1") > -1
 378         return True
 379 $$ LANGUAGE plpythonu;
 380 --
 381 -- Test returning SETOF
 382 --
 383 CREATE FUNCTION test_setof_as_list(count integer, content text) RETURNS SETOF text AS $$
 384 return [ content ]*count
 385 $$ LANGUAGE plpythonu;
 386 CREATE FUNCTION test_setof_as_tuple(count integer, content text) RETURNS SETOF text AS $$
 387 t = ()
 388 for i in xrange(count):
 389         t += ( content, )
 390 return t
 391 $$ LANGUAGE plpythonu;
 392 CREATE FUNCTION test_setof_as_iterator(count integer, content text) RETURNS SETOF text AS $$
 393 class producer:
 394         def __init__ (self, icount, icontent):
 395                 self.icontent = icontent
 396                 self.icount = icount
 397         def __iter__ (self):
 398                 return self
 399         def next (self):
 400                 if self.icount == 0:
 401                         raise StopIteration
 402                 self.icount -= 1
 403                 return self.icontent
 404 return producer(count, content)
 405 $$ LANGUAGE plpythonu;
 406 --
 407 -- Test returning tuples
 408 --
 409 CREATE FUNCTION test_table_record_as(typ text, first text, second integer, retnull boolean) RETURNS table_record AS $$
 410 if retnull:
 411         return None
 412 if typ == 'dict':
 413         return { 'first': first, 'second': second, 'additionalfield': 'must not cause trouble' }
 414 elif typ == 'tuple':
 415         return ( first, second )
 416 elif typ == 'list':
 417         return [ first, second ]
 418 elif typ == 'obj':
 419         class type_record: pass
 420         type_record.first = first
 421         type_record.second = second
 422         return type_record
 423 $$ LANGUAGE plpythonu;
 424 CREATE FUNCTION test_type_record_as(typ text, first text, second integer, retnull boolean) RETURNS type_record AS $$
 425 if retnull:
 426         return None
 427 if typ == 'dict':
 428         return { 'first': first, 'second': second, 'additionalfield': 'must not cause trouble' }
 429 elif typ == 'tuple':
 430         return ( first, second )
 431 elif typ == 'list':
 432         return [ first, second ]
 433 elif typ == 'obj':
 434         class type_record: pass
 435         type_record.first = first
 436         type_record.second = second
 437         return type_record
 438 $$ LANGUAGE plpythonu;
 439 CREATE FUNCTION test_in_out_params(first in text, second out text) AS $$
 440 return first + '_in_to_out';
 441 $$ LANGUAGE plpythonu;
 442 -- this doesn't work yet :-(
 443 CREATE FUNCTION test_in_out_params_multi(first in text,
 444                                          second out text, third out text) AS $$
 445 return first + '_record_in_to_out';
 446 $$ LANGUAGE plpythonu;
 447 CREATE FUNCTION test_inout_params(first inout text) AS $$
 448 return first + '_inout';
 449 $$ LANGUAGE plpythonu;