]> git.evergreen-ils.org Git - working/Evergreen.git/blob - Open-ILS/src/sql/Pg/090.schema.action.sql
Merge remote-tracking branch 'eg-working/user/berick/hold-current-shelf-lib'
[working/Evergreen.git] / Open-ILS / src / sql / Pg / 090.schema.action.sql
1 /*
2  * Copyright (C) 2004-2008  Georgia Public Library Service
3  * Copyright (C) 2007-2008  Equinox Software, Inc.
4  * Mike Rylander <miker@esilibrary.com> 
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17
18 DROP SCHEMA IF EXISTS action CASCADE;
19
20 BEGIN;
21
22 CREATE SCHEMA action;
23
24 CREATE TABLE action.in_house_use (
25         id              SERIAL                          PRIMARY KEY,
26         item            BIGINT                          NOT NULL, -- REFERENCES asset.copy (id) DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
27         staff           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
28         org_unit        INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
29         use_time        TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
30 );
31 CREATE INDEX action_in_house_use_staff_idx      ON action.in_house_use ( staff );
32
33 CREATE TABLE action.non_cataloged_circulation (
34         id              SERIAL                          PRIMARY KEY,
35         patron          INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
36         staff           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
37         circ_lib        INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
38         item_type       INT                             NOT NULL REFERENCES config.non_cataloged_type (id) DEFERRABLE INITIALLY DEFERRED,
39         circ_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
40 );
41 CREATE INDEX action_non_cat_circ_patron_idx ON action.non_cataloged_circulation ( patron );
42 CREATE INDEX action_non_cat_circ_staff_idx  ON action.non_cataloged_circulation ( staff );
43
44 CREATE TABLE action.non_cat_in_house_use (
45         id              SERIAL                          PRIMARY KEY,
46         item_type       BIGINT                          NOT NULL REFERENCES config.non_cataloged_type(id) DEFERRABLE INITIALLY DEFERRED,
47         staff           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
48         org_unit        INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
49         use_time        TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
50 );
51 CREATE INDEX non_cat_in_house_use_staff_idx ON action.non_cat_in_house_use ( staff );
52
53 CREATE TABLE action.survey (
54         id              SERIAL                          PRIMARY KEY,
55         owner           INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
56         start_date      TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
57         end_date        TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW() + '10 years'::INTERVAL,
58         usr_summary     BOOL                            NOT NULL DEFAULT FALSE,
59         opac            BOOL                            NOT NULL DEFAULT FALSE,
60         poll            BOOL                            NOT NULL DEFAULT FALSE,
61         required        BOOL                            NOT NULL DEFAULT FALSE,
62         name            TEXT                            NOT NULL,
63         description     TEXT                            NOT NULL
64 );
65 CREATE UNIQUE INDEX asv_once_per_owner_idx ON action.survey (owner,name);
66
67 CREATE TABLE action.survey_question (
68         id              SERIAL  PRIMARY KEY,
69         survey          INT     NOT NULL REFERENCES action.survey DEFERRABLE INITIALLY DEFERRED,
70         question        TEXT    NOT NULL
71 );
72
73 CREATE TABLE action.survey_answer (
74         id              SERIAL  PRIMARY KEY,
75         question        INT     NOT NULL REFERENCES action.survey_question DEFERRABLE INITIALLY DEFERRED,
76         answer          TEXT    NOT NULL
77 );
78
79 CREATE SEQUENCE action.survey_response_group_id_seq;
80
81 CREATE TABLE action.survey_response (
82         id                      BIGSERIAL                       PRIMARY KEY,
83         response_group_id       INT,
84         usr                     INT, -- REFERENCES actor.usr
85         survey                  INT                             NOT NULL REFERENCES action.survey DEFERRABLE INITIALLY DEFERRED,
86         question                INT                             NOT NULL REFERENCES action.survey_question DEFERRABLE INITIALLY DEFERRED,
87         answer                  INT                             NOT NULL REFERENCES action.survey_answer DEFERRABLE INITIALLY DEFERRED,
88         answer_date             TIMESTAMP WITH TIME ZONE,
89         effective_date          TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
90 );
91 CREATE INDEX action_survey_response_usr_idx ON action.survey_response ( usr );
92
93 CREATE OR REPLACE FUNCTION action.survey_response_answer_date_fixup () RETURNS TRIGGER AS '
94 BEGIN
95         NEW.answer_date := NOW();
96         RETURN NEW;
97 END;
98 ' LANGUAGE 'plpgsql';
99 CREATE TRIGGER action_survey_response_answer_date_fixup_tgr
100         BEFORE INSERT ON action.survey_response
101         FOR EACH ROW
102         EXECUTE PROCEDURE action.survey_response_answer_date_fixup ();
103
104 CREATE TABLE action.archive_actor_stat_cat (
105     id          BIGSERIAL   PRIMARY KEY,
106     xact        BIGINT      NOT NULL, -- action.circulation (+aged/all)
107     stat_cat    INT         NOT NULL,
108     value       TEXT        NOT NULL
109 );
110
111 CREATE TABLE action.archive_asset_stat_cat (
112     id          BIGSERIAL   PRIMARY KEY,
113     xact        BIGINT      NOT NULL, -- action.circulation (+aged/all)
114     stat_cat    INT         NOT NULL,
115     value       TEXT        NOT NULL
116 );
117
118
119 CREATE TABLE action.circulation (
120         target_copy             BIGINT                          NOT NULL, -- asset.copy.id
121         circ_lib                INT                             NOT NULL, -- actor.org_unit.id
122         circ_staff              INT                             NOT NULL, -- actor.usr.id
123         checkin_staff           INT,                                      -- actor.usr.id
124         checkin_lib             INT,                                      -- actor.org_unit.id
125         renewal_remaining       INT                             NOT NULL, -- derived from "circ duration" rule
126     grace_period           INTERVAL             NOT NULL, -- derived from "circ fine" rule
127         due_date                TIMESTAMP WITH TIME ZONE,
128         stop_fines_time         TIMESTAMP WITH TIME ZONE,
129         checkin_time            TIMESTAMP WITH TIME ZONE,
130         create_time             TIMESTAMP WITH TIME ZONE    NOT NULL DEFAULT NOW(),
131         duration                INTERVAL,                                 -- derived from "circ duration" rule
132         fine_interval           INTERVAL                        NOT NULL DEFAULT '1 day'::INTERVAL, -- derived from "circ fine" rule
133         recurring_fine          NUMERIC(6,2),                             -- derived from "circ fine" rule
134         max_fine                NUMERIC(6,2),                             -- derived from "max fine" rule
135         phone_renewal           BOOL                            NOT NULL DEFAULT FALSE,
136         desk_renewal            BOOL                            NOT NULL DEFAULT FALSE,
137         opac_renewal            BOOL                            NOT NULL DEFAULT FALSE,
138         duration_rule           TEXT                            NOT NULL, -- name of "circ duration" rule
139         recurring_fine_rule     TEXT                            NOT NULL, -- name of "circ fine" rule
140         max_fine_rule           TEXT                            NOT NULL, -- name of "max fine" rule
141         stop_fines              TEXT                            CHECK (stop_fines IN (
142                                                'CHECKIN','CLAIMSRETURNED','LOST','MAXFINES','RENEW','LONGOVERDUE','CLAIMSNEVERCHECKEDOUT')),
143         workstation         INT        REFERENCES actor.workstation(id)
144                                        ON DELETE SET NULL
145                                                                    DEFERRABLE INITIALLY DEFERRED,
146         checkin_workstation INT        REFERENCES actor.workstation(id)
147                                        ON DELETE SET NULL
148                                                                    DEFERRABLE INITIALLY DEFERRED,
149         copy_location   INT                             NOT NULL DEFAULT 1 REFERENCES asset.copy_location (id) DEFERRABLE INITIALLY DEFERRED,
150         checkin_scan_time   TIMESTAMP WITH TIME ZONE
151 ) INHERITS (money.billable_xact);
152 ALTER TABLE action.circulation ADD PRIMARY KEY (id);
153 ALTER TABLE action.circulation
154         ADD COLUMN parent_circ BIGINT
155         REFERENCES action.circulation( id )
156         DEFERRABLE INITIALLY DEFERRED;
157 CREATE INDEX circ_open_xacts_idx ON action.circulation (usr) WHERE xact_finish IS NULL;
158 CREATE INDEX circ_outstanding_idx ON action.circulation (usr) WHERE checkin_time IS NULL;
159 CREATE INDEX circ_checkin_time ON "action".circulation (checkin_time) WHERE checkin_time IS NOT NULL;
160 CREATE INDEX circ_circ_lib_idx ON "action".circulation (circ_lib);
161 CREATE INDEX circ_open_date_idx ON "action".circulation (xact_start) WHERE xact_finish IS NULL;
162 CREATE INDEX circ_all_usr_idx       ON action.circulation ( usr );
163 CREATE INDEX circ_circ_staff_idx    ON action.circulation ( circ_staff );
164 CREATE INDEX circ_checkin_staff_idx ON action.circulation ( checkin_staff );
165 CREATE INDEX action_circulation_target_copy_idx ON action.circulation (target_copy);
166 CREATE UNIQUE INDEX circ_parent_idx ON action.circulation ( parent_circ ) WHERE parent_circ IS NOT NULL;
167 CREATE UNIQUE INDEX only_one_concurrent_checkout_per_copy ON action.circulation(target_copy) WHERE checkin_time IS NULL;
168
169 CREATE TRIGGER action_circulation_target_copy_trig AFTER INSERT OR UPDATE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE evergreen.fake_fkey_tgr('target_copy');
170
171 CREATE TRIGGER mat_summary_create_tgr AFTER INSERT ON action.circulation FOR EACH ROW EXECUTE PROCEDURE money.mat_summary_create ('circulation');
172 CREATE TRIGGER mat_summary_change_tgr AFTER UPDATE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE money.mat_summary_update ();
173 CREATE TRIGGER mat_summary_remove_tgr AFTER DELETE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE money.mat_summary_delete ();
174
175 CREATE OR REPLACE FUNCTION action.push_circ_due_time () RETURNS TRIGGER AS $$
176 BEGIN
177     IF (EXTRACT(EPOCH FROM NEW.duration)::INT % EXTRACT(EPOCH FROM '1 day'::INTERVAL)::INT) = 0 THEN
178         NEW.due_date = (NEW.due_date::DATE + '1 day'::INTERVAL - '1 second'::INTERVAL)::TIMESTAMPTZ;
179     END IF;
180
181     RETURN NEW;
182 END;
183 $$ LANGUAGE PLPGSQL;
184
185 CREATE TRIGGER push_due_date_tgr BEFORE INSERT OR UPDATE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE action.push_circ_due_time();
186
187 CREATE OR REPLACE FUNCTION action.fill_circ_copy_location () RETURNS TRIGGER AS $$
188 BEGIN
189     SELECT INTO NEW.copy_location location FROM asset.copy WHERE id = NEW.target_copy;
190     RETURN NEW;
191 END;
192 $$ LANGUAGE PLPGSQL;
193
194 CREATE TRIGGER fill_circ_copy_location_tgr BEFORE INSERT ON action.circulation FOR EACH ROW EXECUTE PROCEDURE action.fill_circ_copy_location();
195
196 CREATE OR REPLACE FUNCTION action.archive_stat_cats () RETURNS TRIGGER AS $$
197 BEGIN
198     INSERT INTO action.archive_actor_stat_cat(xact, stat_cat, value)
199         SELECT NEW.id, asceum.stat_cat, asceum.stat_cat_entry
200         FROM actor.stat_cat_entry_usr_map asceum
201              JOIN actor.stat_cat sc ON asceum.stat_cat = sc.id
202         WHERE NEW.usr = asceum.target_usr AND sc.checkout_archive;
203     INSERT INTO action.archive_asset_stat_cat(xact, stat_cat, value)
204         SELECT NEW.id, ascecm.stat_cat, asce.value
205         FROM asset.stat_cat_entry_copy_map ascecm
206              JOIN asset.stat_cat sc ON ascecm.stat_cat = sc.id
207              JOIN asset.stat_cat_entry asce ON ascecm.stat_cat_entry = asce.id
208         WHERE NEW.target_copy = ascecm.owning_copy AND sc.checkout_archive;
209     RETURN NULL;
210 END;
211 $$ LANGUAGE PLPGSQL;
212
213 CREATE TRIGGER archive_stat_cats_tgr AFTER INSERT ON action.circulation FOR EACH ROW EXECUTE PROCEDURE action.archive_stat_cats();
214
215 CREATE TABLE action.aged_circulation (
216         usr_post_code           TEXT,
217         usr_home_ou             INT     NOT NULL,
218         usr_profile             INT     NOT NULL,
219         usr_birth_year          INT,
220         copy_call_number        INT     NOT NULL,
221         copy_owning_lib         INT     NOT NULL,
222         copy_circ_lib           INT     NOT NULL,
223         copy_bib_record         BIGINT  NOT NULL,
224         LIKE action.circulation
225
226 );
227 ALTER TABLE action.aged_circulation ADD PRIMARY KEY (id);
228 ALTER TABLE action.aged_circulation DROP COLUMN usr;
229 CREATE INDEX aged_circ_circ_lib_idx ON "action".aged_circulation (circ_lib);
230 CREATE INDEX aged_circ_start_idx ON "action".aged_circulation (xact_start);
231 CREATE INDEX aged_circ_copy_circ_lib_idx ON "action".aged_circulation (copy_circ_lib);
232 CREATE INDEX aged_circ_copy_owning_lib_idx ON "action".aged_circulation (copy_owning_lib);
233 CREATE INDEX aged_circ_copy_location_idx ON "action".aged_circulation (copy_location);
234 CREATE INDEX action_aged_circulation_target_copy_idx ON action.aged_circulation (target_copy);
235
236 CREATE OR REPLACE VIEW action.all_circulation AS
237     SELECT  id,usr_post_code, usr_home_ou, usr_profile, usr_birth_year, copy_call_number, copy_location,
238         copy_owning_lib, copy_circ_lib, copy_bib_record, xact_start, xact_finish, target_copy,
239         circ_lib, circ_staff, checkin_staff, checkin_lib, renewal_remaining, grace_period, due_date,
240         stop_fines_time, checkin_time, create_time, duration, fine_interval, recurring_fine,
241         max_fine, phone_renewal, desk_renewal, opac_renewal, duration_rule, recurring_fine_rule,
242         max_fine_rule, stop_fines, workstation, checkin_workstation, checkin_scan_time, parent_circ
243       FROM  action.aged_circulation
244             UNION ALL
245     SELECT  DISTINCT circ.id,COALESCE(a.post_code,b.post_code) AS usr_post_code, p.home_ou AS usr_home_ou, p.profile AS usr_profile, EXTRACT(YEAR FROM p.dob)::INT AS usr_birth_year,
246         cp.call_number AS copy_call_number, circ.copy_location, cn.owning_lib AS copy_owning_lib, cp.circ_lib AS copy_circ_lib,
247         cn.record AS copy_bib_record, circ.xact_start, circ.xact_finish, circ.target_copy, circ.circ_lib, circ.circ_staff, circ.checkin_staff,
248         circ.checkin_lib, circ.renewal_remaining, circ.grace_period, circ.due_date, circ.stop_fines_time, circ.checkin_time, circ.create_time, circ.duration,
249         circ.fine_interval, circ.recurring_fine, circ.max_fine, circ.phone_renewal, circ.desk_renewal, circ.opac_renewal, circ.duration_rule,
250         circ.recurring_fine_rule, circ.max_fine_rule, circ.stop_fines, circ.workstation, circ.checkin_workstation, circ.checkin_scan_time,
251         circ.parent_circ
252       FROM  action.circulation circ
253         JOIN asset.copy cp ON (circ.target_copy = cp.id)
254         JOIN asset.call_number cn ON (cp.call_number = cn.id)
255         JOIN actor.usr p ON (circ.usr = p.id)
256         LEFT JOIN actor.usr_address a ON (p.mailing_address = a.id)
257         LEFT JOIN actor.usr_address b ON (p.billing_address = b.id);
258
259 CREATE OR REPLACE FUNCTION action.age_circ_on_delete () RETURNS TRIGGER AS $$
260 DECLARE
261 found char := 'N';
262 BEGIN
263
264     -- If there are any renewals for this circulation, don't archive or delete
265     -- it yet.   We'll do so later, when we archive and delete the renewals.
266
267     SELECT 'Y' INTO found
268     FROM action.circulation
269     WHERE parent_circ = OLD.id
270     LIMIT 1;
271
272     IF found = 'Y' THEN
273         RETURN NULL;  -- don't delete
274         END IF;
275
276     -- Archive a copy of the old row to action.aged_circulation
277
278     INSERT INTO action.aged_circulation
279         (id,usr_post_code, usr_home_ou, usr_profile, usr_birth_year, copy_call_number, copy_location,
280         copy_owning_lib, copy_circ_lib, copy_bib_record, xact_start, xact_finish, target_copy,
281         circ_lib, circ_staff, checkin_staff, checkin_lib, renewal_remaining, grace_period, due_date,
282         stop_fines_time, checkin_time, create_time, duration, fine_interval, recurring_fine,
283         max_fine, phone_renewal, desk_renewal, opac_renewal, duration_rule, recurring_fine_rule,
284         max_fine_rule, stop_fines, workstation, checkin_workstation, checkin_scan_time, parent_circ)
285       SELECT
286         id,usr_post_code, usr_home_ou, usr_profile, usr_birth_year, copy_call_number, copy_location,
287         copy_owning_lib, copy_circ_lib, copy_bib_record, xact_start, xact_finish, target_copy,
288         circ_lib, circ_staff, checkin_staff, checkin_lib, renewal_remaining, grace_period, due_date,
289         stop_fines_time, checkin_time, create_time, duration, fine_interval, recurring_fine,
290         max_fine, phone_renewal, desk_renewal, opac_renewal, duration_rule, recurring_fine_rule,
291         max_fine_rule, stop_fines, workstation, checkin_workstation, checkin_scan_time, parent_circ
292         FROM action.all_circulation WHERE id = OLD.id;
293
294     RETURN OLD;
295 END;
296 $$ LANGUAGE 'plpgsql';
297
298 CREATE TRIGGER action_circulation_aging_tgr
299         BEFORE DELETE ON action.circulation
300         FOR EACH ROW
301         EXECUTE PROCEDURE action.age_circ_on_delete ();
302
303
304 CREATE OR REPLACE FUNCTION action.age_parent_circ_on_delete () RETURNS TRIGGER AS $$
305 BEGIN
306
307     -- Having deleted a renewal, we can delete the original circulation (or a previous
308     -- renewal, if that's what parent_circ is pointing to).  That deletion will trigger
309     -- deletion of any prior parents, etc. recursively.
310
311     IF OLD.parent_circ IS NOT NULL THEN
312         DELETE FROM action.circulation
313         WHERE id = OLD.parent_circ;
314     END IF;
315
316     RETURN OLD;
317 END;
318 $$ LANGUAGE 'plpgsql';
319
320 CREATE TRIGGER age_parent_circ
321         AFTER DELETE ON action.circulation
322         FOR EACH ROW
323         EXECUTE PROCEDURE action.age_parent_circ_on_delete ();
324
325
326 CREATE OR REPLACE VIEW action.open_circulation AS
327         SELECT  *
328           FROM  action.circulation
329           WHERE checkin_time IS NULL
330           ORDER BY due_date;
331                 
332
333 CREATE OR REPLACE VIEW action.billable_circulations AS
334         SELECT  *
335           FROM  action.circulation
336           WHERE xact_finish IS NULL;
337
338 CREATE OR REPLACE FUNCTION action.circulation_claims_returned () RETURNS TRIGGER AS $$
339 BEGIN
340         IF OLD.stop_fines IS NULL OR OLD.stop_fines <> NEW.stop_fines THEN
341                 IF NEW.stop_fines = 'CLAIMSRETURNED' THEN
342                         UPDATE actor.usr SET claims_returned_count = claims_returned_count + 1 WHERE id = NEW.usr;
343                 END IF;
344                 IF NEW.stop_fines = 'CLAIMSNEVERCHECKEDOUT' THEN
345                         UPDATE actor.usr SET claims_never_checked_out_count = claims_never_checked_out_count + 1 WHERE id = NEW.usr;
346                 END IF;
347                 IF NEW.stop_fines = 'LOST' THEN
348                         UPDATE asset.copy SET status = 3 WHERE id = NEW.target_copy;
349                 END IF;
350         END IF;
351         RETURN NEW;
352 END;
353 $$ LANGUAGE 'plpgsql';
354 CREATE TRIGGER action_circulation_stop_fines_tgr
355         BEFORE UPDATE ON action.circulation
356         FOR EACH ROW
357         EXECUTE PROCEDURE action.circulation_claims_returned ();
358
359 CREATE TABLE action.hold_request_cancel_cause (
360     id      SERIAL  PRIMARY KEY,
361     label   TEXT    UNIQUE
362 );
363 INSERT INTO action.hold_request_cancel_cause (id,label) VALUES (1,'Untargeted expiration');
364 INSERT INTO action.hold_request_cancel_cause (id,label) VALUES (2,'Hold Shelf expiration');
365 INSERT INTO action.hold_request_cancel_cause (id,label) VALUES (3,'Patron via phone');
366 INSERT INTO action.hold_request_cancel_cause (id,label) VALUES (4,'Patron in person');
367 INSERT INTO action.hold_request_cancel_cause (id,label) VALUES (5,'Staff forced');
368 INSERT INTO action.hold_request_cancel_cause (id,label) VALUES (6,'Patron via OPAC');
369 SELECT SETVAL('action.hold_request_cancel_cause_id_seq', 100);
370
371 CREATE TABLE action.hold_request (
372         id                      SERIAL                          PRIMARY KEY,
373         request_time            TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
374         capture_time            TIMESTAMP WITH TIME ZONE,
375         fulfillment_time        TIMESTAMP WITH TIME ZONE,
376         checkin_time            TIMESTAMP WITH TIME ZONE,
377         return_time             TIMESTAMP WITH TIME ZONE,
378         prev_check_time         TIMESTAMP WITH TIME ZONE,
379         expire_time             TIMESTAMP WITH TIME ZONE,
380         cancel_time             TIMESTAMP WITH TIME ZONE,
381         cancel_cause    INT REFERENCES action.hold_request_cancel_cause (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,
382         cancel_note             TEXT,
383         target                  BIGINT                          NOT NULL, -- see hold_type
384         current_copy            BIGINT,                         -- REFERENCES asset.copy (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,  -- XXX could be an serial.unit now...
385         fulfillment_staff       INT                             REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
386         fulfillment_lib         INT                             REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
387         request_lib             INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
388         requestor               INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
389         usr                     INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
390         selection_ou            INT                             NOT NULL,
391         selection_depth         INT                             NOT NULL DEFAULT 0,
392         pickup_lib              INT                             NOT NULL REFERENCES actor.org_unit DEFERRABLE INITIALLY DEFERRED,
393         hold_type               TEXT                            NOT NULL, -- CHECK (hold_type IN ('M','T','V','C')),  -- XXX constraint too constraining...
394         holdable_formats        TEXT,
395         phone_notify            TEXT,
396         email_notify            BOOL                            NOT NULL DEFAULT TRUE,
397         frozen                  BOOL                            NOT NULL DEFAULT FALSE,
398         thaw_date               TIMESTAMP WITH TIME ZONE,
399         shelf_time              TIMESTAMP WITH TIME ZONE,
400     cut_in_line     BOOL,
401         mint_condition  BOOL NOT NULL DEFAULT TRUE,
402         shelf_expire_time TIMESTAMPTZ,
403         current_shelf_lib INT REFERENCES actor.org_unit DEFERRABLE INITIALLY DEFERRED
404 );
405
406 CREATE INDEX hold_request_target_idx ON action.hold_request (target);
407 CREATE INDEX hold_request_usr_idx ON action.hold_request (usr);
408 CREATE INDEX hold_request_pickup_lib_idx ON action.hold_request (pickup_lib);
409 CREATE INDEX hold_request_current_copy_idx ON action.hold_request (current_copy);
410 CREATE INDEX hold_request_prev_check_time_idx ON action.hold_request (prev_check_time);
411 CREATE INDEX hold_request_fulfillment_staff_idx ON action.hold_request ( fulfillment_staff );
412 CREATE INDEX hold_request_requestor_idx         ON action.hold_request ( requestor );
413
414
415 CREATE TABLE action.hold_request_note (
416
417     id     BIGSERIAL PRIMARY KEY,
418     hold   BIGINT    NOT NULL REFERENCES action.hold_request (id)
419                               ON DELETE CASCADE
420                               DEFERRABLE INITIALLY DEFERRED,
421     title  TEXT      NOT NULL,
422     body   TEXT      NOT NULL,
423     slip   BOOL      NOT NULL DEFAULT FALSE,
424     pub    BOOL      NOT NULL DEFAULT FALSE,
425     staff  BOOL      NOT NULL DEFAULT FALSE  -- created by staff
426
427 );
428 CREATE INDEX ahrn_hold_idx ON action.hold_request_note (hold);
429
430
431 CREATE TABLE action.hold_notification (
432         id              SERIAL                          PRIMARY KEY,
433         hold            INT                             NOT NULL REFERENCES action.hold_request (id)
434                                                                         ON DELETE CASCADE
435                                                                         DEFERRABLE INITIALLY DEFERRED,
436         notify_staff    INT                     REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
437         notify_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
438         method          TEXT                            NOT NULL, -- email address or phone number
439         note            TEXT
440 );
441 CREATE INDEX ahn_hold_idx ON action.hold_notification (hold);
442 CREATE INDEX ahn_notify_staff_idx ON action.hold_notification ( notify_staff );
443
444 CREATE TABLE action.hold_copy_map (
445         id              BIGSERIAL       PRIMARY KEY,
446         hold            INT     NOT NULL REFERENCES action.hold_request (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
447         target_copy     BIGINT  NOT NULL, -- REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
448         CONSTRAINT copy_once_per_hold UNIQUE (hold,target_copy)
449 );
450 -- CREATE INDEX acm_hold_idx ON action.hold_copy_map (hold);
451 CREATE INDEX acm_copy_idx ON action.hold_copy_map (target_copy);
452
453 CREATE TABLE action.transit_copy (
454         id                      SERIAL                          PRIMARY KEY,
455         source_send_time        TIMESTAMP WITH TIME ZONE,
456         dest_recv_time          TIMESTAMP WITH TIME ZONE,
457         target_copy             BIGINT                          NOT NULL, -- REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
458         source                  INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
459         dest                    INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
460         prev_hop                INT                             REFERENCES action.transit_copy (id) DEFERRABLE INITIALLY DEFERRED,
461         copy_status             INT                             NOT NULL REFERENCES config.copy_status (id) DEFERRABLE INITIALLY DEFERRED,
462         persistant_transfer     BOOL                            NOT NULL DEFAULT FALSE,
463         prev_dest       INT                             REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED
464 );
465 CREATE INDEX active_transit_dest_idx ON "action".transit_copy (dest); 
466 CREATE INDEX active_transit_source_idx ON "action".transit_copy (source);
467 CREATE INDEX active_transit_cp_idx ON "action".transit_copy (target_copy);
468
469
470 CREATE TABLE action.hold_transit_copy (
471         hold    INT     REFERENCES action.hold_request (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED
472 ) INHERITS (action.transit_copy);
473 ALTER TABLE action.hold_transit_copy ADD PRIMARY KEY (id);
474 -- ALTER TABLE action.hold_transit_copy ADD CONSTRAINT ahtc_tc_fkey FOREIGN KEY (target_copy) REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED; -- XXX could be an serial.issuance
475 CREATE INDEX active_hold_transit_dest_idx ON "action".hold_transit_copy (dest);
476 CREATE INDEX active_hold_transit_source_idx ON "action".hold_transit_copy (source);
477 CREATE INDEX active_hold_transit_cp_idx ON "action".hold_transit_copy (target_copy);
478
479
480 CREATE TABLE action.unfulfilled_hold_list (
481         id              BIGSERIAL                       PRIMARY KEY,
482         current_copy    BIGINT                          NOT NULL,
483         hold            INT                             NOT NULL,
484         circ_lib        INT                             NOT NULL,
485         fail_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
486 );
487 CREATE INDEX uhr_hold_idx ON action.unfulfilled_hold_list (hold);
488
489 CREATE OR REPLACE VIEW action.unfulfilled_hold_loops AS
490     SELECT  u.hold,
491             c.circ_lib,
492             count(*)
493       FROM  action.unfulfilled_hold_list u
494             JOIN asset.copy c ON (c.id = u.current_copy)
495       GROUP BY 1,2;
496
497 CREATE OR REPLACE VIEW action.unfulfilled_hold_min_loop AS
498     SELECT  hold,
499             min(count)
500       FROM  action.unfulfilled_hold_loops
501       GROUP BY 1;
502
503 CREATE OR REPLACE VIEW action.unfulfilled_hold_innermost_loop AS
504     SELECT  DISTINCT l.*
505       FROM  action.unfulfilled_hold_loops l
506             JOIN action.unfulfilled_hold_min_loop m USING (hold)
507       WHERE l.count = m.min;
508
509 CREATE VIEW action.unfulfilled_hold_max_loop AS
510     SELECT  hold,
511             max(count) AS max
512       FROM  action.unfulfilled_hold_loops
513       GROUP BY 1;
514
515
516 CREATE TABLE action.fieldset (
517     id              SERIAL          PRIMARY KEY,
518     owner           INT             NOT NULL REFERENCES actor.usr (id)
519                                     DEFERRABLE INITIALLY DEFERRED,
520         owning_lib      INT             NOT NULL REFERENCES actor.org_unit (id)
521                                     DEFERRABLE INITIALLY DEFERRED,
522         status          TEXT            NOT NULL
523                                         CONSTRAINT valid_status CHECK ( status in
524                                                                         ( 'PENDING', 'APPLIED', 'ERROR' )),
525     creation_time   TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
526     scheduled_time  TIMESTAMPTZ,
527     applied_time    TIMESTAMPTZ,
528     classname       TEXT            NOT NULL, -- an IDL class name
529     name            TEXT            NOT NULL,
530     stored_query    INT             REFERENCES query.stored_query (id)
531                                     DEFERRABLE INITIALLY DEFERRED,
532     pkey_value      TEXT,
533         CONSTRAINT lib_name_unique UNIQUE (owning_lib, name),
534     CONSTRAINT fieldset_one_or_the_other CHECK (
535         (stored_query IS NOT NULL AND pkey_value IS NULL) OR
536         (pkey_value IS NOT NULL AND stored_query IS NULL)
537     )
538         -- the CHECK constraint means we can update the fields for a single
539         -- row without all the extra overhead involved in a query
540 );
541
542 CREATE INDEX action_fieldset_sched_time_idx ON action.fieldset( scheduled_time );
543 CREATE INDEX action_owner_idx               ON action.fieldset( owner );
544
545
546 CREATE TABLE action.fieldset_col_val (
547     id              SERIAL  PRIMARY KEY,
548     fieldset        INT     NOT NULL REFERENCES action.fieldset
549                                          ON DELETE CASCADE
550                                          DEFERRABLE INITIALLY DEFERRED,
551     col             TEXT    NOT NULL,  -- "field" from the idl ... the column on the table
552     val             TEXT,              -- value for the column ... NULL means, well, NULL
553     CONSTRAINT fieldset_col_once_per_set UNIQUE (fieldset, col)
554 );
555
556
557 -- represents a circ chain summary
558 CREATE TYPE action.circ_chain_summary AS (
559     num_circs INTEGER,
560     start_time TIMESTAMP WITH TIME ZONE,
561     checkout_workstation TEXT,
562     last_renewal_time TIMESTAMP WITH TIME ZONE, -- NULL if no renewals
563     last_stop_fines TEXT,
564     last_stop_fines_time TIMESTAMP WITH TIME ZONE,
565     last_renewal_workstation TEXT, -- NULL if no renewals
566     last_checkin_workstation TEXT,
567     last_checkin_time TIMESTAMP WITH TIME ZONE,
568     last_checkin_scan_time TIMESTAMP WITH TIME ZONE
569 );
570
571
572 CREATE OR REPLACE FUNCTION action.circ_chain ( ctx_circ_id INTEGER ) RETURNS SETOF action.circulation AS $$
573 DECLARE
574     tmp_circ action.circulation%ROWTYPE;
575     circ_0 action.circulation%ROWTYPE;
576 BEGIN
577
578     SELECT INTO tmp_circ * FROM action.circulation WHERE id = ctx_circ_id;
579
580     IF tmp_circ IS NULL THEN
581         RETURN NEXT tmp_circ;
582     END IF;
583     circ_0 := tmp_circ;
584
585     -- find the front of the chain
586     WHILE TRUE LOOP
587         SELECT INTO tmp_circ * FROM action.circulation WHERE id = tmp_circ.parent_circ;
588         IF tmp_circ IS NULL THEN
589             EXIT;
590         END IF;
591         circ_0 := tmp_circ;
592     END LOOP;
593
594     -- now send the circs to the caller, oldest to newest
595     tmp_circ := circ_0;
596     WHILE TRUE LOOP
597         IF tmp_circ IS NULL THEN
598             EXIT;
599         END IF;
600         RETURN NEXT tmp_circ;
601         SELECT INTO tmp_circ * FROM action.circulation WHERE parent_circ = tmp_circ.id;
602     END LOOP;
603
604 END;
605 $$ LANGUAGE 'plpgsql';
606
607 CREATE OR REPLACE FUNCTION action.summarize_circ_chain ( ctx_circ_id INTEGER ) RETURNS action.circ_chain_summary AS $$
608
609 DECLARE
610
611     -- first circ in the chain
612     circ_0 action.circulation%ROWTYPE;
613
614     -- last circ in the chain
615     circ_n action.circulation%ROWTYPE;
616
617     -- circ chain under construction
618     chain action.circ_chain_summary;
619     tmp_circ action.circulation%ROWTYPE;
620
621 BEGIN
622     
623     chain.num_circs := 0;
624     FOR tmp_circ IN SELECT * FROM action.circ_chain(ctx_circ_id) LOOP
625
626         IF chain.num_circs = 0 THEN
627             circ_0 := tmp_circ;
628         END IF;
629
630         chain.num_circs := chain.num_circs + 1;
631         circ_n := tmp_circ;
632     END LOOP;
633
634     chain.start_time := circ_0.xact_start;
635     chain.last_stop_fines := circ_n.stop_fines;
636     chain.last_stop_fines_time := circ_n.stop_fines_time;
637     chain.last_checkin_time := circ_n.checkin_time;
638     chain.last_checkin_scan_time := circ_n.checkin_scan_time;
639     SELECT INTO chain.checkout_workstation name FROM actor.workstation WHERE id = circ_0.workstation;
640     SELECT INTO chain.last_checkin_workstation name FROM actor.workstation WHERE id = circ_n.checkin_workstation;
641
642     IF chain.num_circs > 1 THEN
643         chain.last_renewal_time := circ_n.xact_start;
644         SELECT INTO chain.last_renewal_workstation name FROM actor.workstation WHERE id = circ_n.workstation;
645     END IF;
646
647     RETURN chain;
648
649 END;
650 $$ LANGUAGE 'plpgsql';
651
652 -- Return the list of circ chain heads in xact_start order that the user has chosen to "retain"
653 CREATE OR REPLACE FUNCTION action.usr_visible_circs (usr_id INT) RETURNS SETOF action.circulation AS $func$
654 DECLARE
655     c               action.circulation%ROWTYPE;
656     view_age        INTERVAL;
657     usr_view_age    actor.usr_setting%ROWTYPE;
658     usr_view_start  actor.usr_setting%ROWTYPE;
659 BEGIN
660     SELECT * INTO usr_view_age FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.circ.retention_age';
661     SELECT * INTO usr_view_start FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.circ.retention_start';
662
663     IF usr_view_age.value IS NOT NULL AND usr_view_start.value IS NOT NULL THEN
664         -- User opted in and supplied a retention age
665         IF oils_json_to_text(usr_view_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ) THEN
666             view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
667         ELSE
668             view_age := oils_json_to_text(usr_view_age.value)::INTERVAL;
669         END IF;
670     ELSIF usr_view_start.value IS NOT NULL THEN
671         -- User opted in
672         view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
673     ELSE
674         -- User did not opt in
675         RETURN;
676     END IF;
677
678     FOR c IN
679         SELECT  *
680           FROM  action.circulation
681           WHERE usr = usr_id
682                 AND parent_circ IS NULL
683                 AND xact_start > NOW() - view_age
684           ORDER BY xact_start DESC
685     LOOP
686         RETURN NEXT c;
687     END LOOP;
688
689     RETURN;
690 END;
691 $func$ LANGUAGE PLPGSQL;
692
693 CREATE OR REPLACE FUNCTION action.usr_visible_circ_copies( INTEGER ) RETURNS SETOF BIGINT AS $$
694     SELECT DISTINCT(target_copy) FROM action.usr_visible_circs($1)
695 $$ LANGUAGE SQL;
696
697 CREATE OR REPLACE FUNCTION action.usr_visible_holds (usr_id INT) RETURNS SETOF action.hold_request AS $func$
698 DECLARE
699     h               action.hold_request%ROWTYPE;
700     view_age        INTERVAL;
701     view_count      INT;
702     usr_view_count  actor.usr_setting%ROWTYPE;
703     usr_view_age    actor.usr_setting%ROWTYPE;
704     usr_view_start  actor.usr_setting%ROWTYPE;
705 BEGIN
706     SELECT * INTO usr_view_count FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_count';
707     SELECT * INTO usr_view_age FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_age';
708     SELECT * INTO usr_view_start FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_start';
709
710     FOR h IN
711         SELECT  *
712           FROM  action.hold_request
713           WHERE usr = usr_id
714                 AND fulfillment_time IS NULL
715                 AND cancel_time IS NULL
716           ORDER BY request_time DESC
717     LOOP
718         RETURN NEXT h;
719     END LOOP;
720
721     IF usr_view_start.value IS NULL THEN
722         RETURN;
723     END IF;
724
725     IF usr_view_age.value IS NOT NULL THEN
726         -- User opted in and supplied a retention age
727         IF oils_json_to_text(usr_view_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ) THEN
728             view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
729         ELSE
730             view_age := oils_json_to_text(usr_view_age.value)::INTERVAL;
731         END IF;
732     ELSE
733         -- User opted in
734         view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
735     END IF;
736
737     IF usr_view_count.value IS NOT NULL THEN
738         view_count := oils_json_to_text(usr_view_count.value)::INT;
739     ELSE
740         view_count := 1000;
741     END IF;
742
743     -- show some fulfilled/canceled holds
744     FOR h IN
745         SELECT  *
746           FROM  action.hold_request
747           WHERE usr = usr_id
748                 AND ( fulfillment_time IS NOT NULL OR cancel_time IS NOT NULL )
749                 AND request_time > NOW() - view_age
750           ORDER BY request_time DESC
751           LIMIT view_count
752     LOOP
753         RETURN NEXT h;
754     END LOOP;
755
756     RETURN;
757 END;
758 $func$ LANGUAGE PLPGSQL;
759
760 CREATE OR REPLACE FUNCTION action.purge_circulations () RETURNS INT AS $func$
761 DECLARE
762     usr_keep_age    actor.usr_setting%ROWTYPE;
763     usr_keep_start  actor.usr_setting%ROWTYPE;
764     org_keep_age    INTERVAL;
765     org_keep_count  INT;
766
767     keep_age        INTERVAL;
768
769     target_acp      RECORD;
770     circ_chain_head action.circulation%ROWTYPE;
771     circ_chain_tail action.circulation%ROWTYPE;
772
773     purge_position  INT;
774     count_purged    INT;
775 BEGIN
776
777     count_purged := 0;
778
779     SELECT value::INTERVAL INTO org_keep_age FROM config.global_flag WHERE name = 'history.circ.retention_age' AND enabled;
780
781     SELECT value::INT INTO org_keep_count FROM config.global_flag WHERE name = 'history.circ.retention_count' AND enabled;
782     IF org_keep_count IS NULL THEN
783         RETURN count_purged; -- Gimme a count to keep, or I keep them all, forever
784     END IF;
785
786     -- First, find copies with more than keep_count non-renewal circs
787     FOR target_acp IN
788         SELECT  target_copy,
789                 COUNT(*) AS total_real_circs
790           FROM  action.circulation
791           WHERE parent_circ IS NULL
792                 AND xact_finish IS NOT NULL
793           GROUP BY target_copy
794           HAVING COUNT(*) > org_keep_count
795     LOOP
796         purge_position := 0;
797         -- And, for those, select circs that are finished and older than keep_age
798         FOR circ_chain_head IN
799             SELECT  *
800               FROM  action.circulation
801               WHERE target_copy = target_acp.target_copy
802                     AND parent_circ IS NULL
803               ORDER BY xact_start
804         LOOP
805
806             -- Stop once we've purged enough circs to hit org_keep_count
807             EXIT WHEN target_acp.total_real_circs - purge_position <= org_keep_count;
808
809             SELECT * INTO circ_chain_tail FROM action.circ_chain(circ_chain_head.id) ORDER BY xact_start DESC LIMIT 1;
810             EXIT WHEN circ_chain_tail.xact_finish IS NULL;
811
812             -- Now get the user settings, if any, to block purging if the user wants to keep more circs
813             usr_keep_age.value := NULL;
814             SELECT * INTO usr_keep_age FROM actor.usr_setting WHERE usr = circ_chain_head.usr AND name = 'history.circ.retention_age';
815
816             usr_keep_start.value := NULL;
817             SELECT * INTO usr_keep_start FROM actor.usr_setting WHERE usr = circ_chain_head.usr AND name = 'history.circ.retention_start';
818
819             IF usr_keep_age.value IS NOT NULL AND usr_keep_start.value IS NOT NULL THEN
820                 IF oils_json_to_text(usr_keep_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ) THEN
821                     keep_age := AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ);
822                 ELSE
823                     keep_age := oils_json_to_text(usr_keep_age.value)::INTERVAL;
824                 END IF;
825             ELSIF usr_keep_start.value IS NOT NULL THEN
826                 keep_age := AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ);
827             ELSE
828                 keep_age := COALESCE( org_keep_age::INTERVAL, '2000 years'::INTERVAL );
829             END IF;
830
831             EXIT WHEN AGE(NOW(), circ_chain_tail.xact_finish) < keep_age;
832
833             -- We've passed the purging tests, purge the circ chain starting at the end
834             DELETE FROM action.circulation WHERE id = circ_chain_tail.id;
835             WHILE circ_chain_tail.parent_circ IS NOT NULL LOOP
836                 SELECT * INTO circ_chain_tail FROM action.circulation WHERE id = circ_chain_tail.parent_circ;
837                 DELETE FROM action.circulation WHERE id = circ_chain_tail.id;
838             END LOOP;
839
840             count_purged := count_purged + 1;
841             purge_position := purge_position + 1;
842
843         END LOOP;
844     END LOOP;
845 END;
846 $func$ LANGUAGE PLPGSQL;
847
848
849 CREATE OR REPLACE FUNCTION action.apply_fieldset(
850         fieldset_id IN INT,        -- id from action.fieldset
851         table_name  IN TEXT,       -- table to be updated
852         pkey_name   IN TEXT,       -- name of primary key column in that table
853         query       IN TEXT        -- query constructed by qstore (for query-based
854                                    --    fieldsets only; otherwise null
855 )
856 RETURNS TEXT AS $$
857 DECLARE
858         statement TEXT;
859         fs_status TEXT;
860         fs_pkey_value TEXT;
861         fs_query TEXT;
862         sep CHAR;
863         status_code TEXT;
864         msg TEXT;
865         update_count INT;
866         cv RECORD;
867 BEGIN
868         -- Sanity checks
869         IF fieldset_id IS NULL THEN
870                 RETURN 'Fieldset ID parameter is NULL';
871         END IF;
872         IF table_name IS NULL THEN
873                 RETURN 'Table name parameter is NULL';
874         END IF;
875         IF pkey_name IS NULL THEN
876                 RETURN 'Primary key name parameter is NULL';
877         END IF;
878         --
879         statement := 'UPDATE ' || table_name || ' SET';
880         --
881         SELECT
882                 status,
883                 quote_literal( pkey_value )
884         INTO
885                 fs_status,
886                 fs_pkey_value
887         FROM
888                 action.fieldset
889         WHERE
890                 id = fieldset_id;
891         --
892         IF fs_status IS NULL THEN
893                 RETURN 'No fieldset found for id = ' || fieldset_id;
894         ELSIF fs_status = 'APPLIED' THEN
895                 RETURN 'Fieldset ' || fieldset_id || ' has already been applied';
896         END IF;
897         --
898         sep := '';
899         FOR cv IN
900                 SELECT  col,
901                                 val
902                 FROM    action.fieldset_col_val
903                 WHERE   fieldset = fieldset_id
904         LOOP
905                 statement := statement || sep || ' ' || cv.col
906                                          || ' = ' || coalesce( quote_literal( cv.val ), 'NULL' );
907                 sep := ',';
908         END LOOP;
909         --
910         IF sep = '' THEN
911                 RETURN 'Fieldset ' || fieldset_id || ' has no column values defined';
912         END IF;
913         --
914         -- Add the WHERE clause.  This differs according to whether it's a
915         -- single-row fieldset or a query-based fieldset.
916         --
917         IF query IS NULL        AND fs_pkey_value IS NULL THEN
918                 RETURN 'Incomplete fieldset: neither a primary key nor a query available';
919         ELSIF query IS NOT NULL AND fs_pkey_value IS NULL THEN
920             fs_query := rtrim( query, ';' );
921             statement := statement || ' WHERE ' || pkey_name || ' IN ( '
922                          || fs_query || ' );';
923         ELSIF query IS NULL     AND fs_pkey_value IS NOT NULL THEN
924                 statement := statement || ' WHERE ' || pkey_name || ' = '
925                                      || fs_pkey_value || ';';
926         ELSE  -- both are not null
927                 RETURN 'Ambiguous fieldset: both a primary key and a query provided';
928         END IF;
929         --
930         -- Execute the update
931         --
932         BEGIN
933                 EXECUTE statement;
934                 GET DIAGNOSTICS update_count = ROW_COUNT;
935                 --
936                 IF UPDATE_COUNT > 0 THEN
937                         status_code := 'APPLIED';
938                         msg := NULL;
939                 ELSE
940                         status_code := 'ERROR';
941                         msg := 'No eligible rows found for fieldset ' || fieldset_id;
942         END IF;
943         EXCEPTION WHEN OTHERS THEN
944                 status_code := 'ERROR';
945                 msg := 'Unable to apply fieldset ' || fieldset_id
946                            || ': ' || sqlerrm;
947         END;
948         --
949         -- Update fieldset status
950         --
951         UPDATE action.fieldset
952         SET status       = status_code,
953             applied_time = now()
954         WHERE id = fieldset_id;
955         --
956         RETURN msg;
957 END;
958 $$ LANGUAGE plpgsql;
959
960 COMMENT ON FUNCTION action.apply_fieldset( INT, TEXT, TEXT, TEXT ) IS $$
961 Applies a specified fieldset, using a supplied table name and primary
962 key name.  The query parameter should be non-null only for
963 query-based fieldsets.
964
965 Returns NULL if successful, or an error message if not.
966 $$;
967
968
969 COMMIT;