← Back to branch summary

~vcs-imports/mammoth-replicator/trunk

« back to all changes in this revision

Viewing changes to src/pl/plpython/plpython_function.sql

  • Committer: alvherre
  • Date: 2005-12-16 21:24:52 UTC
  • Revision ID: svn-v4:db760fc0-0f08-0410-9d63-cc6633f64896:trunk:1
Initial import of the REL8_0_3 sources from the Pgsql CVS repository.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pl/plpython/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
CREATE OR REPLACE FUNCTION read_file(text) RETURNS text AS '
 
302
  return open(args[0]).read()
 
303
' LANGUAGE plpythonu;
 
304
 
 
305
CREATE OR REPLACE FUNCTION write_file(text,text) RETURNS text AS '
 
306
  open(args[0],"w").write(args[1])
 
307
  return "Wrote to file: %s" % args[0]
 
308
' LANGUAGE plpythonu;
 
309
 
 
310
--
 
311
-- Universal Newline Support
 
312
-- 
 
313
 
 
314
CREATE OR REPLACE FUNCTION newline_lf() RETURNS integer AS
 
315
'x = 100\ny = 23\nreturn x + y\n'
 
316
LANGUAGE plpythonu;
 
317
 
 
318
CREATE OR REPLACE FUNCTION newline_cr() RETURNS integer AS
 
319
'x = 100\ry = 23\rreturn x + y\r'
 
320
LANGUAGE plpythonu;
 
321
 
 
322
CREATE OR REPLACE FUNCTION newline_crlf() RETURNS integer AS
 
323
'x = 100\r\ny = 23\r\nreturn x + y\r\n'
 
324
LANGUAGE plpythonu;