granicus.if.org Git - postgresql/blob - src/pl/plpython/sql/plpython_function.sql

   1
   2
   3 CREATE FUNCTION global_test_one() returns text
   4     AS
   5 'if not SD.has_key("global_test"):
   6         SD["global_test"] = "set by global_test_one"
   7 if not GD.has_key("global_test"):
   8         GD["global_test"] = "set by global_test_one"
   9 return "SD: " + SD["global_test"] + ", GD: " + GD["global_test"]'
  10     LANGUAGE plpythonu;
  11
  12 CREATE FUNCTION global_test_two() returns text
  13     AS
  14 'if not SD.has_key("global_test"):
  15         SD["global_test"] = "set by global_test_two"
  16 if not GD.has_key("global_test"):
  17         GD["global_test"] = "set by global_test_two"
  18 return "SD: " + SD["global_test"] + ", GD: " + GD["global_test"]'
  19     LANGUAGE plpythonu;
  20
  21
  22 CREATE FUNCTION static_test() returns int4
  23     AS
  24 'if SD.has_key("call"):
  25         SD["call"] = SD["call"] + 1
  26 else:
  27         SD["call"] = 1
  28 return SD["call"]
  29 '
  30     LANGUAGE plpythonu;
  31
  32 -- import python modules
  33
  34 CREATE FUNCTION import_fail() returns text
  35     AS
  36 'try:
  37         import foosocket
  38 except Exception, ex:
  39         plpy.notice("import socket failed -- %s" % str(ex))
  40         return "failed as expected"
  41 return "succeeded, that wasn''t supposed to happen"'
  42     LANGUAGE plpythonu;
  43
  44
  45 CREATE FUNCTION import_succeed() returns text
  46         AS
  47 'try:
  48   import array
  49   import bisect
  50   import calendar
  51   import cmath
  52   import errno
  53   import math
  54   import md5
  55   import operator
  56   import random
  57   import re
  58   import sha
  59   import string
  60   import time
  61   import whrandom
  62 except Exception, ex:
  63         plpy.notice("import failed -- %s" % str(ex))
  64         return "failed, that wasn''t supposed to happen"
  65 return "succeeded, as expected"'
  66     LANGUAGE plpythonu;
  67
  68 CREATE FUNCTION import_test_one(text) RETURNS text
  69         AS
  70 'import sha
  71 digest = sha.new(args[0])
  72 return digest.hexdigest()'
  73         LANGUAGE plpythonu;
  74
  75 CREATE FUNCTION import_test_two(users) RETURNS text
  76         AS
  77 'import sha
  78 plain = args[0]["fname"] + args[0]["lname"]
  79 digest = sha.new(plain);
  80 return "sha hash of " + plain + " is " + digest.hexdigest()'
  81         LANGUAGE plpythonu;
  82
  83 CREATE FUNCTION argument_test_one(users, text, text) RETURNS text
  84         AS
  85 'keys = args[0].keys()
  86 keys.sort()
  87 out = []
  88 for key in keys:
  89     out.append("%s: %s" % (key, args[0][key]))
  90 words = args[1] + " " + args[2] + " => {" + ", ".join(out) + "}"
  91 return words'
  92         LANGUAGE plpythonu;
  93
  94
  95 -- these triggers are dedicated to HPHC of RI who
  96 -- decided that my kid's name was william not willem, and
  97 -- vigorously resisted all efforts at correction.  they have
  98 -- since gone bankrupt...
  99
 100 CREATE FUNCTION users_insert() returns trigger
 101         AS
 102 'if TD["new"]["fname"] == None or TD["new"]["lname"] == None:
 103         return "SKIP"
 104 if TD["new"]["username"] == None:
 105         TD["new"]["username"] = TD["new"]["fname"][:1] + "_" + TD["new"]["lname"]
 106         rv = "MODIFY"
 107 else:
 108         rv = None
 109 if TD["new"]["fname"] == "william":
 110         TD["new"]["fname"] = TD["args"][0]
 111         rv = "MODIFY"
 112 return rv'
 113         LANGUAGE plpythonu;
 114
 115
 116 CREATE FUNCTION users_update() returns trigger
 117         AS
 118 'if TD["event"] == "UPDATE":
 119         if TD["old"]["fname"] != TD["new"]["fname"] and TD["old"]["fname"] == TD["args"][0]:
 120                 return "SKIP"
 121 return None'
 122         LANGUAGE plpythonu;
 123
 124
 125 CREATE FUNCTION users_delete() RETURNS trigger
 126         AS
 127 'if TD["old"]["fname"] == TD["args"][0]:
 128         return "SKIP"
 129 return None'
 130         LANGUAGE plpythonu;
 131
 132
 133 CREATE TRIGGER users_insert_trig BEFORE INSERT ON users FOR EACH ROW
 134         EXECUTE PROCEDURE users_insert ('willem');
 135
 136 CREATE TRIGGER users_update_trig BEFORE UPDATE ON users FOR EACH ROW
 137         EXECUTE PROCEDURE users_update ('willem');
 138
 139 CREATE TRIGGER users_delete_trig BEFORE DELETE ON users FOR EACH ROW
 140         EXECUTE PROCEDURE users_delete ('willem');
 141
 142
 143 -- nested calls
 144 --
 145
 146 CREATE FUNCTION nested_call_one(text) RETURNS text
 147         AS
 148 'q = "SELECT nested_call_two(''%s'')" % args[0]
 149 r = plpy.execute(q)
 150 return r[0]'
 151         LANGUAGE plpythonu ;
 152
 153 CREATE FUNCTION nested_call_two(text) RETURNS text
 154         AS
 155 'q = "SELECT nested_call_three(''%s'')" % args[0]
 156 r = plpy.execute(q)
 157 return r[0]'
 158         LANGUAGE plpythonu ;
 159
 160 CREATE FUNCTION nested_call_three(text) RETURNS text
 161         AS
 162 'return args[0]'
 163         LANGUAGE plpythonu ;
 164
 165 -- some spi stuff
 166
 167 CREATE FUNCTION spi_prepared_plan_test_one(text) RETURNS text
 168         AS
 169 'if not SD.has_key("myplan"):
 170         q = "SELECT count(*) FROM users WHERE lname = $1"
 171         SD["myplan"] = plpy.prepare(q, [ "text" ])
 172 try:
 173         rv = plpy.execute(SD["myplan"], [args[0]])
 174         return "there are " + str(rv[0]["count"]) + " " + str(args[0]) + "s"
 175 except Exception, ex:
 176         plpy.error(str(ex))
 177 return None
 178 '
 179         LANGUAGE plpythonu;
 180
 181 CREATE FUNCTION spi_prepared_plan_test_nested(text) RETURNS text
 182         AS
 183 'if not SD.has_key("myplan"):
 184         q = "SELECT spi_prepared_plan_test_one(''%s'') as count" % args[0]
 185         SD["myplan"] = plpy.prepare(q)
 186 try:
 187         rv = plpy.execute(SD["myplan"])
 188         if len(rv):
 189                 return rv[0]["count"]
 190 except Exception, ex:
 191         plpy.error(str(ex))
 192 return None
 193 '
 194         LANGUAGE plpythonu;
 195
 196
 197 /* really stupid function just to get the module loaded
 198 */
 199 CREATE FUNCTION stupid() RETURNS text AS 'return "zarkon"' LANGUAGE plpythonu;
 200
 201 /* a typo
 202 */
 203 CREATE FUNCTION invalid_type_uncaught(text) RETURNS text
 204         AS
 205 'if not SD.has_key("plan"):
 206         q = "SELECT fname FROM users WHERE lname = $1"
 207         SD["plan"] = plpy.prepare(q, [ "test" ])
 208 rv = plpy.execute(SD["plan"], [ args[0] ])
 209 if len(rv):
 210         return rv[0]["fname"]
 211 return None
 212 '
 213         LANGUAGE plpythonu;
 214
 215 /* for what it's worth catch the exception generated by
 216  * the typo, and return None
 217  */
 218 CREATE FUNCTION invalid_type_caught(text) RETURNS text
 219         AS
 220 'if not SD.has_key("plan"):
 221         q = "SELECT fname FROM users WHERE lname = $1"
 222         try:
 223                 SD["plan"] = plpy.prepare(q, [ "test" ])
 224         except plpy.SPIError, ex:
 225                 plpy.notice(str(ex))
 226                 return None
 227 rv = plpy.execute(SD["plan"], [ args[0] ])
 228 if len(rv):
 229         return rv[0]["fname"]
 230 return None
 231 '
 232         LANGUAGE plpythonu;
 233
 234 /* for what it's worth catch the exception generated by
 235  * the typo, and reraise it as a plain error
 236  */
 237 CREATE FUNCTION invalid_type_reraised(text) RETURNS text
 238         AS
 239 'if not SD.has_key("plan"):
 240         q = "SELECT fname FROM users WHERE lname = $1"
 241         try:
 242                 SD["plan"] = plpy.prepare(q, [ "test" ])
 243         except plpy.SPIError, ex:
 244                 plpy.error(str(ex))
 245 rv = plpy.execute(SD["plan"], [ args[0] ])
 246 if len(rv):
 247         return rv[0]["fname"]
 248 return None
 249 '
 250         LANGUAGE plpythonu;
 251
 252
 253 /* no typo no messing about
 254 */
 255 CREATE FUNCTION valid_type(text) RETURNS text
 256         AS
 257 'if not SD.has_key("plan"):
 258         SD["plan"] = plpy.prepare("SELECT fname FROM users WHERE lname = $1", [ "text" ])
 259 rv = plpy.execute(SD["plan"], [ args[0] ])
 260 if len(rv):
 261         return rv[0]["fname"]
 262 return None
 263 '
 264         LANGUAGE plpythonu;
 265 /* Flat out syntax error
 266 */
 267 CREATE FUNCTION sql_syntax_error() RETURNS text
 268         AS
 269 'plpy.execute("syntax error")'
 270         LANGUAGE plpythonu;
 271
 272 /* check the handling of uncaught python exceptions
 273  */
 274 CREATE FUNCTION exception_index_invalid(text) RETURNS text
 275         AS
 276 'return args[1]'
 277         LANGUAGE plpythonu;
 278
 279 /* check handling of nested exceptions
 280  */
 281 CREATE FUNCTION exception_index_invalid_nested() RETURNS text
 282         AS
 283 'rv = plpy.execute("SELECT test5(''foo'')")
 284 return rv[0]'
 285         LANGUAGE plpythonu;
 286
 287
 288 CREATE FUNCTION join_sequences(sequences) RETURNS text
 289         AS
 290 'if not args[0]["multipart"]:
 291         return args[0]["sequence"]
 292 q = "SELECT sequence FROM xsequences WHERE pid = ''%s''" % args[0]["pid"]
 293 rv = plpy.execute(q)
 294 seq = args[0]["sequence"]
 295 for r in rv:
 296         seq = seq + r["sequence"]
 297 return seq
 298 '
 299         LANGUAGE plpythonu;
 300
 301 --
 302 -- Universal Newline Support
 303 --
 304
 305 CREATE OR REPLACE FUNCTION newline_lf() RETURNS integer AS
 306 'x = 100\ny = 23\nreturn x + y\n'
 307 LANGUAGE plpythonu;
 308
 309 CREATE OR REPLACE FUNCTION newline_cr() RETURNS integer AS
 310 'x = 100\ry = 23\rreturn x + y\r'
 311 LANGUAGE plpythonu;
 312
 313 CREATE OR REPLACE FUNCTION newline_crlf() RETURNS integer AS
 314 'x = 100\r\ny = 23\r\nreturn x + y\r\n'
 315 LANGUAGE plpythonu;