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 );
 404
 405 CREATE INDEX hold_request_target_idx ON action.hold_request (target);
 406 CREATE INDEX hold_request_usr_idx ON action.hold_request (usr);
 407 CREATE INDEX hold_request_pickup_lib_idx ON action.hold_request (pickup_lib);
 408 CREATE INDEX hold_request_current_copy_idx ON action.hold_request (current_copy);
 409 CREATE INDEX hold_request_prev_check_time_idx ON action.hold_request (prev_check_time);
 410 CREATE INDEX hold_request_fulfillment_staff_idx ON action.hold_request ( fulfillment_staff );
 411 CREATE INDEX hold_request_requestor_idx         ON action.hold_request ( requestor );
 412
 413
 414 CREATE TABLE action.hold_request_note (
 415
 416     id     BIGSERIAL PRIMARY KEY,
 417     hold   BIGINT    NOT NULL REFERENCES action.hold_request (id)
 418                               ON DELETE CASCADE
 419                               DEFERRABLE INITIALLY DEFERRED,
 420     title  TEXT      NOT NULL,
 421     body   TEXT      NOT NULL,
 422     slip   BOOL      NOT NULL DEFAULT FALSE,
 423     pub    BOOL      NOT NULL DEFAULT FALSE,
 424     staff  BOOL      NOT NULL DEFAULT FALSE  -- created by staff
 425
 426 );
 427 CREATE INDEX ahrn_hold_idx ON action.hold_request_note (hold);
 428
 429
 430 CREATE TABLE action.hold_notification (
 431         id              SERIAL                          PRIMARY KEY,
 432         hold            INT                             NOT NULL REFERENCES action.hold_request (id)
 433                                                                         ON DELETE CASCADE
 434                                                                         DEFERRABLE INITIALLY DEFERRED,
 435         notify_staff    INT                     REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
 436         notify_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
 437         method          TEXT                            NOT NULL, -- email address or phone number
 438         note            TEXT
 439 );
 440 CREATE INDEX ahn_hold_idx ON action.hold_notification (hold);
 441 CREATE INDEX ahn_notify_staff_idx ON action.hold_notification ( notify_staff );
 442
 443 CREATE TABLE action.hold_copy_map (
 444         id              BIGSERIAL       PRIMARY KEY,
 445         hold            INT     NOT NULL REFERENCES action.hold_request (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
 446         target_copy     BIGINT  NOT NULL, -- REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
 447         CONSTRAINT copy_once_per_hold UNIQUE (hold,target_copy)
 448 );
 449 -- CREATE INDEX acm_hold_idx ON action.hold_copy_map (hold);
 450 CREATE INDEX acm_copy_idx ON action.hold_copy_map (target_copy);
 451
 452 CREATE TABLE action.transit_copy (
 453         id                      SERIAL                          PRIMARY KEY,
 454         source_send_time        TIMESTAMP WITH TIME ZONE,
 455         dest_recv_time          TIMESTAMP WITH TIME ZONE,
 456         target_copy             BIGINT                          NOT NULL, -- REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
 457         source                  INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
 458         dest                    INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
 459         prev_hop                INT                             REFERENCES action.transit_copy (id) DEFERRABLE INITIALLY DEFERRED,
 460         copy_status             INT                             NOT NULL REFERENCES config.copy_status (id) DEFERRABLE INITIALLY DEFERRED,
 461         persistant_transfer     BOOL                            NOT NULL DEFAULT FALSE,
 462         prev_dest       INT                             REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED
 463 );
 464 CREATE INDEX active_transit_dest_idx ON "action".transit_copy (dest);
 465 CREATE INDEX active_transit_source_idx ON "action".transit_copy (source);
 466 CREATE INDEX active_transit_cp_idx ON "action".transit_copy (target_copy);
 467
 468
 469 CREATE TABLE action.hold_transit_copy (
 470         hold    INT     REFERENCES action.hold_request (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED
 471 ) INHERITS (action.transit_copy);
 472 ALTER TABLE action.hold_transit_copy ADD PRIMARY KEY (id);
 473 -- 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
 474 CREATE INDEX active_hold_transit_dest_idx ON "action".hold_transit_copy (dest);
 475 CREATE INDEX active_hold_transit_source_idx ON "action".hold_transit_copy (source);
 476 CREATE INDEX active_hold_transit_cp_idx ON "action".hold_transit_copy (target_copy);
 477
 478
 479 CREATE TABLE action.unfulfilled_hold_list (
 480         id              BIGSERIAL                       PRIMARY KEY,
 481         current_copy    BIGINT                          NOT NULL,
 482         hold            INT                             NOT NULL,
 483         circ_lib        INT                             NOT NULL,
 484         fail_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
 485 );
 486 CREATE INDEX uhr_hold_idx ON action.unfulfilled_hold_list (hold);
 487
 488 CREATE OR REPLACE VIEW action.unfulfilled_hold_loops AS
 489     SELECT  u.hold,
 490             c.circ_lib,
 491             count(*)
 492       FROM  action.unfulfilled_hold_list u
 493             JOIN asset.copy c ON (c.id = u.current_copy)
 494       GROUP BY 1,2;
 495
 496 CREATE OR REPLACE VIEW action.unfulfilled_hold_min_loop AS
 497     SELECT  hold,
 498             min(count)
 499       FROM  action.unfulfilled_hold_loops
 500       GROUP BY 1;
 501
 502 CREATE OR REPLACE VIEW action.unfulfilled_hold_innermost_loop AS
 503     SELECT  DISTINCT l.*
 504       FROM  action.unfulfilled_hold_loops l
 505             JOIN action.unfulfilled_hold_min_loop m USING (hold)
 506       WHERE l.count = m.min;
 507
 508 CREATE VIEW action.unfulfilled_hold_max_loop AS
 509     SELECT  hold,
 510             max(count) AS max
 511       FROM  action.unfulfilled_hold_loops
 512       GROUP BY 1;
 513
 514
 515 CREATE TABLE action.fieldset (
 516     id              SERIAL          PRIMARY KEY,
 517     owner           INT             NOT NULL REFERENCES actor.usr (id)
 518                                     DEFERRABLE INITIALLY DEFERRED,
 519         owning_lib      INT             NOT NULL REFERENCES actor.org_unit (id)
 520                                     DEFERRABLE INITIALLY DEFERRED,
 521         status          TEXT            NOT NULL
 522                                         CONSTRAINT valid_status CHECK ( status in
 523                                                                         ( 'PENDING', 'APPLIED', 'ERROR' )),
 524     creation_time   TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
 525     scheduled_time  TIMESTAMPTZ,
 526     applied_time    TIMESTAMPTZ,
 527     classname       TEXT            NOT NULL, -- an IDL class name
 528     name            TEXT            NOT NULL,
 529     stored_query    INT             REFERENCES query.stored_query (id)
 530                                     DEFERRABLE INITIALLY DEFERRED,
 531     pkey_value      TEXT,
 532         CONSTRAINT lib_name_unique UNIQUE (owning_lib, name),
 533     CONSTRAINT fieldset_one_or_the_other CHECK (
 534         (stored_query IS NOT NULL AND pkey_value IS NULL) OR
 535         (pkey_value IS NOT NULL AND stored_query IS NULL)
 536     )
 537         -- the CHECK constraint means we can update the fields for a single
 538         -- row without all the extra overhead involved in a query
 539 );
 540
 541 CREATE INDEX action_fieldset_sched_time_idx ON action.fieldset( scheduled_time );
 542 CREATE INDEX action_owner_idx               ON action.fieldset( owner );
 543
 544
 545 CREATE TABLE action.fieldset_col_val (
 546     id              SERIAL  PRIMARY KEY,
 547     fieldset        INT     NOT NULL REFERENCES action.fieldset
 548                                          ON DELETE CASCADE
 549                                          DEFERRABLE INITIALLY DEFERRED,
 550     col             TEXT    NOT NULL,  -- "field" from the idl ... the column on the table
 551     val             TEXT,              -- value for the column ... NULL means, well, NULL
 552     CONSTRAINT fieldset_col_once_per_set UNIQUE (fieldset, col)
 553 );
 554
 555
 556 -- represents a circ chain summary
 557 CREATE TYPE action.circ_chain_summary AS (
 558     num_circs INTEGER,
 559     start_time TIMESTAMP WITH TIME ZONE,
 560     checkout_workstation TEXT,
 561     last_renewal_time TIMESTAMP WITH TIME ZONE, -- NULL if no renewals
 562     last_stop_fines TEXT,
 563     last_stop_fines_time TIMESTAMP WITH TIME ZONE,
 564     last_renewal_workstation TEXT, -- NULL if no renewals
 565     last_checkin_workstation TEXT,
 566     last_checkin_time TIMESTAMP WITH TIME ZONE,
 567     last_checkin_scan_time TIMESTAMP WITH TIME ZONE
 568 );
 569
 570
 571 CREATE OR REPLACE FUNCTION action.circ_chain ( ctx_circ_id INTEGER ) RETURNS SETOF action.circulation AS $$
 572 DECLARE
 573     tmp_circ action.circulation%ROWTYPE;
 574     circ_0 action.circulation%ROWTYPE;
 575 BEGIN
 576
 577     SELECT INTO tmp_circ * FROM action.circulation WHERE id = ctx_circ_id;
 578
 579     IF tmp_circ IS NULL THEN
 580         RETURN NEXT tmp_circ;
 581     END IF;
 582     circ_0 := tmp_circ;
 583
 584     -- find the front of the chain
 585     WHILE TRUE LOOP
 586         SELECT INTO tmp_circ * FROM action.circulation WHERE id = tmp_circ.parent_circ;
 587         IF tmp_circ IS NULL THEN
 588             EXIT;
 589         END IF;
 590         circ_0 := tmp_circ;
 591     END LOOP;
 592
 593     -- now send the circs to the caller, oldest to newest
 594     tmp_circ := circ_0;
 595     WHILE TRUE LOOP
 596         IF tmp_circ IS NULL THEN
 597             EXIT;
 598         END IF;
 599         RETURN NEXT tmp_circ;
 600         SELECT INTO tmp_circ * FROM action.circulation WHERE parent_circ = tmp_circ.id;
 601     END LOOP;
 602
 603 END;
 604 $$ LANGUAGE 'plpgsql';
 605
 606 CREATE OR REPLACE FUNCTION action.summarize_circ_chain ( ctx_circ_id INTEGER ) RETURNS action.circ_chain_summary AS $$
 607
 608 DECLARE
 609
 610     -- first circ in the chain
 611     circ_0 action.circulation%ROWTYPE;
 612
 613     -- last circ in the chain
 614     circ_n action.circulation%ROWTYPE;
 615
 616     -- circ chain under construction
 617     chain action.circ_chain_summary;
 618     tmp_circ action.circulation%ROWTYPE;
 619
 620 BEGIN
 621
 622     chain.num_circs := 0;
 623     FOR tmp_circ IN SELECT * FROM action.circ_chain(ctx_circ_id) LOOP
 624
 625         IF chain.num_circs = 0 THEN
 626             circ_0 := tmp_circ;
 627         END IF;
 628
 629         chain.num_circs := chain.num_circs + 1;
 630         circ_n := tmp_circ;
 631     END LOOP;
 632
 633     chain.start_time := circ_0.xact_start;
 634     chain.last_stop_fines := circ_n.stop_fines;
 635     chain.last_stop_fines_time := circ_n.stop_fines_time;
 636     chain.last_checkin_time := circ_n.checkin_time;
 637     chain.last_checkin_scan_time := circ_n.checkin_scan_time;
 638     SELECT INTO chain.checkout_workstation name FROM actor.workstation WHERE id = circ_0.workstation;
 639     SELECT INTO chain.last_checkin_workstation name FROM actor.workstation WHERE id = circ_n.checkin_workstation;
 640
 641     IF chain.num_circs > 1 THEN
 642         chain.last_renewal_time := circ_n.xact_start;
 643         SELECT INTO chain.last_renewal_workstation name FROM actor.workstation WHERE id = circ_n.workstation;
 644     END IF;
 645
 646     RETURN chain;
 647
 648 END;
 649 $$ LANGUAGE 'plpgsql';
 650
 651 -- Return the list of circ chain heads in xact_start order that the user has chosen to "retain"
 652 CREATE OR REPLACE FUNCTION action.usr_visible_circs (usr_id INT) RETURNS SETOF action.circulation AS $func$
 653 DECLARE
 654     c               action.circulation%ROWTYPE;
 655     view_age        INTERVAL;
 656     usr_view_age    actor.usr_setting%ROWTYPE;
 657     usr_view_start  actor.usr_setting%ROWTYPE;
 658 BEGIN
 659     SELECT * INTO usr_view_age FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.circ.retention_age';
 660     SELECT * INTO usr_view_start FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.circ.retention_start';
 661
 662     IF usr_view_age.value IS NOT NULL AND usr_view_start.value IS NOT NULL THEN
 663         -- User opted in and supplied a retention age
 664         IF oils_json_to_text(usr_view_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ) THEN
 665             view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
 666         ELSE
 667             view_age := oils_json_to_text(usr_view_age.value)::INTERVAL;
 668         END IF;
 669     ELSIF usr_view_start.value IS NOT NULL THEN
 670         -- User opted in
 671         view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
 672     ELSE
 673         -- User did not opt in
 674         RETURN;
 675     END IF;
 676
 677     FOR c IN
 678         SELECT  *
 679           FROM  action.circulation
 680           WHERE usr = usr_id
 681                 AND parent_circ IS NULL
 682                 AND xact_start > NOW() - view_age
 683           ORDER BY xact_start DESC
 684     LOOP
 685         RETURN NEXT c;
 686     END LOOP;
 687
 688     RETURN;
 689 END;
 690 $func$ LANGUAGE PLPGSQL;
 691
 692 CREATE OR REPLACE FUNCTION action.usr_visible_circ_copies( INTEGER ) RETURNS SETOF BIGINT AS $$
 693     SELECT DISTINCT(target_copy) FROM action.usr_visible_circs($1)
 694 $$ LANGUAGE SQL;
 695
 696 CREATE OR REPLACE FUNCTION action.usr_visible_holds (usr_id INT) RETURNS SETOF action.hold_request AS $func$
 697 DECLARE
 698     h               action.hold_request%ROWTYPE;
 699     view_age        INTERVAL;
 700     view_count      INT;
 701     usr_view_count  actor.usr_setting%ROWTYPE;
 702     usr_view_age    actor.usr_setting%ROWTYPE;
 703     usr_view_start  actor.usr_setting%ROWTYPE;
 704 BEGIN
 705     SELECT * INTO usr_view_count FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_count';
 706     SELECT * INTO usr_view_age FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_age';
 707     SELECT * INTO usr_view_start FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_start';
 708
 709     FOR h IN
 710         SELECT  *
 711           FROM  action.hold_request
 712           WHERE usr = usr_id
 713                 AND fulfillment_time IS NULL
 714                 AND cancel_time IS NULL
 715           ORDER BY request_time DESC
 716     LOOP
 717         RETURN NEXT h;
 718     END LOOP;
 719
 720     IF usr_view_start.value IS NULL THEN
 721         RETURN;
 722     END IF;
 723
 724     IF usr_view_age.value IS NOT NULL THEN
 725         -- User opted in and supplied a retention age
 726         IF oils_json_to_text(usr_view_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ) THEN
 727             view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
 728         ELSE
 729             view_age := oils_json_to_text(usr_view_age.value)::INTERVAL;
 730         END IF;
 731     ELSE
 732         -- User opted in
 733         view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
 734     END IF;
 735
 736     IF usr_view_count.value IS NOT NULL THEN
 737         view_count := oils_json_to_text(usr_view_count.value)::INT;
 738     ELSE
 739         view_count := 1000;
 740     END IF;
 741
 742     -- show some fulfilled/canceled holds
 743     FOR h IN
 744         SELECT  *
 745           FROM  action.hold_request
 746           WHERE usr = usr_id
 747                 AND ( fulfillment_time IS NOT NULL OR cancel_time IS NOT NULL )
 748                 AND request_time > NOW() - view_age
 749           ORDER BY request_time DESC
 750           LIMIT view_count
 751     LOOP
 752         RETURN NEXT h;
 753     END LOOP;
 754
 755     RETURN;
 756 END;
 757 $func$ LANGUAGE PLPGSQL;
 758
 759 CREATE OR REPLACE FUNCTION action.purge_circulations () RETURNS INT AS $func$
 760 DECLARE
 761     usr_keep_age    actor.usr_setting%ROWTYPE;
 762     usr_keep_start  actor.usr_setting%ROWTYPE;
 763     org_keep_age    INTERVAL;
 764     org_keep_count  INT;
 765
 766     keep_age        INTERVAL;
 767
 768     target_acp      RECORD;
 769     circ_chain_head action.circulation%ROWTYPE;
 770     circ_chain_tail action.circulation%ROWTYPE;
 771
 772     purge_position  INT;
 773     count_purged    INT;
 774 BEGIN
 775
 776     count_purged := 0;
 777
 778     SELECT value::INTERVAL INTO org_keep_age FROM config.global_flag WHERE name = 'history.circ.retention_age' AND enabled;
 779
 780     SELECT value::INT INTO org_keep_count FROM config.global_flag WHERE name = 'history.circ.retention_count' AND enabled;
 781     IF org_keep_count IS NULL THEN
 782         RETURN count_purged; -- Gimme a count to keep, or I keep them all, forever
 783     END IF;
 784
 785     -- First, find copies with more than keep_count non-renewal circs
 786     FOR target_acp IN
 787         SELECT  target_copy,
 788                 COUNT(*) AS total_real_circs
 789           FROM  action.circulation
 790           WHERE parent_circ IS NULL
 791                 AND xact_finish IS NOT NULL
 792           GROUP BY target_copy
 793           HAVING COUNT(*) > org_keep_count
 794     LOOP
 795         purge_position := 0;
 796         -- And, for those, select circs that are finished and older than keep_age
 797         FOR circ_chain_head IN
 798             SELECT  *
 799               FROM  action.circulation
 800               WHERE target_copy = target_acp.target_copy
 801                     AND parent_circ IS NULL
 802               ORDER BY xact_start
 803         LOOP
 804
 805             -- Stop once we've purged enough circs to hit org_keep_count
 806             EXIT WHEN target_acp.total_real_circs - purge_position <= org_keep_count;
 807
 808             SELECT * INTO circ_chain_tail FROM action.circ_chain(circ_chain_head.id) ORDER BY xact_start DESC LIMIT 1;
 809             EXIT WHEN circ_chain_tail.xact_finish IS NULL;
 810
 811             -- Now get the user settings, if any, to block purging if the user wants to keep more circs
 812             usr_keep_age.value := NULL;
 813             SELECT * INTO usr_keep_age FROM actor.usr_setting WHERE usr = circ_chain_head.usr AND name = 'history.circ.retention_age';
 814
 815             usr_keep_start.value := NULL;
 816             SELECT * INTO usr_keep_start FROM actor.usr_setting WHERE usr = circ_chain_head.usr AND name = 'history.circ.retention_start';
 817
 818             IF usr_keep_age.value IS NOT NULL AND usr_keep_start.value IS NOT NULL THEN
 819                 IF oils_json_to_text(usr_keep_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ) THEN
 820                     keep_age := AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ);
 821                 ELSE
 822                     keep_age := oils_json_to_text(usr_keep_age.value)::INTERVAL;
 823                 END IF;
 824             ELSIF usr_keep_start.value IS NOT NULL THEN
 825                 keep_age := AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ);
 826             ELSE
 827                 keep_age := COALESCE( org_keep_age::INTERVAL, '2000 years'::INTERVAL );
 828             END IF;
 829
 830             EXIT WHEN AGE(NOW(), circ_chain_tail.xact_finish) < keep_age;
 831
 832             -- We've passed the purging tests, purge the circ chain starting at the end
 833             DELETE FROM action.circulation WHERE id = circ_chain_tail.id;
 834             WHILE circ_chain_tail.parent_circ IS NOT NULL LOOP
 835                 SELECT * INTO circ_chain_tail FROM action.circulation WHERE id = circ_chain_tail.parent_circ;
 836                 DELETE FROM action.circulation WHERE id = circ_chain_tail.id;
 837             END LOOP;
 838
 839             count_purged := count_purged + 1;
 840             purge_position := purge_position + 1;
 841
 842         END LOOP;
 843     END LOOP;
 844 END;
 845 $func$ LANGUAGE PLPGSQL;
 846
 847
 848 CREATE OR REPLACE FUNCTION action.apply_fieldset(
 849         fieldset_id IN INT,        -- id from action.fieldset
 850         table_name  IN TEXT,       -- table to be updated
 851         pkey_name   IN TEXT,       -- name of primary key column in that table
 852         query       IN TEXT        -- query constructed by qstore (for query-based
 853                                    --    fieldsets only; otherwise null
 854 )
 855 RETURNS TEXT AS $$
 856 DECLARE
 857         statement TEXT;
 858         fs_status TEXT;
 859         fs_pkey_value TEXT;
 860         fs_query TEXT;
 861         sep CHAR;
 862         status_code TEXT;
 863         msg TEXT;
 864         update_count INT;
 865         cv RECORD;
 866 BEGIN
 867         -- Sanity checks
 868         IF fieldset_id IS NULL THEN
 869                 RETURN 'Fieldset ID parameter is NULL';
 870         END IF;
 871         IF table_name IS NULL THEN
 872                 RETURN 'Table name parameter is NULL';
 873         END IF;
 874         IF pkey_name IS NULL THEN
 875                 RETURN 'Primary key name parameter is NULL';
 876         END IF;
 877         --
 878         statement := 'UPDATE ' || table_name || ' SET';
 879         --
 880         SELECT
 881                 status,
 882                 quote_literal( pkey_value )
 883         INTO
 884                 fs_status,
 885                 fs_pkey_value
 886         FROM
 887                 action.fieldset
 888         WHERE
 889                 id = fieldset_id;
 890         --
 891         IF fs_status IS NULL THEN
 892                 RETURN 'No fieldset found for id = ' || fieldset_id;
 893         ELSIF fs_status = 'APPLIED' THEN
 894                 RETURN 'Fieldset ' || fieldset_id || ' has already been applied';
 895         END IF;
 896         --
 897         sep := '';
 898         FOR cv IN
 899                 SELECT  col,
 900                                 val
 901                 FROM    action.fieldset_col_val
 902                 WHERE   fieldset = fieldset_id
 903         LOOP
 904                 statement := statement || sep || ' ' || cv.col
 905                                          || ' = ' || coalesce( quote_literal( cv.val ), 'NULL' );
 906                 sep := ',';
 907         END LOOP;
 908         --
 909         IF sep = '' THEN
 910                 RETURN 'Fieldset ' || fieldset_id || ' has no column values defined';
 911         END IF;
 912         --
 913         -- Add the WHERE clause.  This differs according to whether it's a
 914         -- single-row fieldset or a query-based fieldset.
 915         --
 916         IF query IS NULL        AND fs_pkey_value IS NULL THEN
 917                 RETURN 'Incomplete fieldset: neither a primary key nor a query available';
 918         ELSIF query IS NOT NULL AND fs_pkey_value IS NULL THEN
 919             fs_query := rtrim( query, ';' );
 920             statement := statement || ' WHERE ' || pkey_name || ' IN ( '
 921                          || fs_query || ' );';
 922         ELSIF query IS NULL     AND fs_pkey_value IS NOT NULL THEN
 923                 statement := statement || ' WHERE ' || pkey_name || ' = '
 924                                      || fs_pkey_value || ';';
 925         ELSE  -- both are not null
 926                 RETURN 'Ambiguous fieldset: both a primary key and a query provided';
 927         END IF;
 928         --
 929         -- Execute the update
 930         --
 931         BEGIN
 932                 EXECUTE statement;
 933                 GET DIAGNOSTICS update_count = ROW_COUNT;
 934                 --
 935                 IF UPDATE_COUNT > 0 THEN
 936                         status_code := 'APPLIED';
 937                         msg := NULL;
 938                 ELSE
 939                         status_code := 'ERROR';
 940                         msg := 'No eligible rows found for fieldset ' || fieldset_id;
 941         END IF;
 942         EXCEPTION WHEN OTHERS THEN
 943                 status_code := 'ERROR';
 944                 msg := 'Unable to apply fieldset ' || fieldset_id
 945                            || ': ' || sqlerrm;
 946         END;
 947         --
 948         -- Update fieldset status
 949         --
 950         UPDATE action.fieldset
 951         SET status       = status_code,
 952             applied_time = now()
 953         WHERE id = fieldset_id;
 954         --
 955         RETURN msg;
 956 END;
 957 $$ LANGUAGE plpgsql;
 958
 959 COMMENT ON FUNCTION action.apply_fieldset( INT, TEXT, TEXT, TEXT ) IS $$
 960 Applies a specified fieldset, using a supplied table name and primary
 961 key name.  The query parameter should be non-null only for
 962 query-based fieldsets.
 963
 964 Returns NULL if successful, or an error message if not.
 965 $$;
 966
 967
 968 COMMIT;