Open-ILS/src/sql/Pg/999.functions.global.sql

   1 /*
   2  * Copyright (C) 2008 Equinox Software, Inc.
   3  * Bill Erickson <erickson@esilibrary.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16
  17 CREATE OR REPLACE FUNCTION actor.usr_merge_rows( table_name TEXT, col_name TEXT, src_usr INT, dest_usr INT ) RETURNS VOID AS $$
  18 DECLARE
  19     sel TEXT;
  20     upd TEXT;
  21     del TEXT;
  22     cur_row RECORD;
  23 BEGIN
  24     sel := 'SELECT id::BIGINT FROM ' || table_name || ' WHERE ' || quote_ident(col_name) || ' = ' || quote_literal(src_usr);
  25     upd := 'UPDATE ' || table_name || ' SET ' || quote_ident(col_name) || ' = ' || quote_literal(dest_usr) || ' WHERE id = ';
  26     del := 'DELETE FROM ' || table_name || ' WHERE id = ';
  27     FOR cur_row IN EXECUTE sel LOOP
  28         BEGIN
  29             --RAISE NOTICE 'Attempting to merge % %', table_name, cur_row.id;
  30             EXECUTE upd || cur_row.id;
  31         EXCEPTION WHEN unique_violation THEN
  32             --RAISE NOTICE 'Deleting conflicting % %', table_name, cur_row.id;
  33             EXECUTE del || cur_row.id;
  34         END;
  35     END LOOP;
  36 END;
  37 $$ LANGUAGE plpgsql;
  38
  39 COMMENT ON FUNCTION actor.usr_merge_rows(TEXT, TEXT, INT, INT) IS $$
  40 /**
  41  * Attempts to move each row of the specified table from src_user to dest_user.
  42  * Where conflicts exist, the conflicting "source" row is deleted.
  43  */
  44 $$;
  45
  46
  47 CREATE OR REPLACE FUNCTION actor.usr_merge( src_usr INT, dest_usr INT, del_addrs BOOLEAN, del_cards BOOLEAN, deactivate_cards BOOLEAN ) RETURNS VOID AS $$
  48 DECLARE
  49         suffix TEXT;
  50         bucket_row RECORD;
  51         picklist_row RECORD;
  52         queue_row RECORD;
  53         folder_row RECORD;
  54 BEGIN
  55
  56     -- do some initial cleanup
  57     UPDATE actor.usr SET card = NULL WHERE id = src_usr;
  58     UPDATE actor.usr SET mailing_address = NULL WHERE id = src_usr;
  59     UPDATE actor.usr SET billing_address = NULL WHERE id = src_usr;
  60
  61     -- actor.*
  62     IF del_cards THEN
  63         DELETE FROM actor.card where usr = src_usr;
  64     ELSE
  65         IF deactivate_cards THEN
  66             UPDATE actor.card SET active = 'f' WHERE usr = src_usr;
  67         END IF;
  68         UPDATE actor.card SET usr = dest_usr WHERE usr = src_usr;
  69     END IF;
  70
  71
  72     IF del_addrs THEN
  73         DELETE FROM actor.usr_address WHERE usr = src_usr;
  74     ELSE
  75         UPDATE actor.usr_address SET usr = dest_usr WHERE usr = src_usr;
  76     END IF;
  77
  78     UPDATE actor.usr_note SET usr = dest_usr WHERE usr = src_usr;
  79     -- dupes are technically OK in actor.usr_standing_penalty, should manually delete them...
  80     UPDATE actor.usr_standing_penalty SET usr = dest_usr WHERE usr = src_usr;
  81     PERFORM actor.usr_merge_rows('actor.usr_org_unit_opt_in', 'usr', src_usr, dest_usr);
  82     PERFORM actor.usr_merge_rows('actor.usr_setting', 'usr', src_usr, dest_usr);
  83
  84     -- permission.*
  85     PERFORM actor.usr_merge_rows('permission.usr_perm_map', 'usr', src_usr, dest_usr);
  86     PERFORM actor.usr_merge_rows('permission.usr_object_perm_map', 'usr', src_usr, dest_usr);
  87     PERFORM actor.usr_merge_rows('permission.usr_grp_map', 'usr', src_usr, dest_usr);
  88     PERFORM actor.usr_merge_rows('permission.usr_work_ou_map', 'usr', src_usr, dest_usr);
  89
  90
  91     -- container.*
  92
  93         -- For each *_bucket table: transfer every bucket belonging to src_usr
  94         -- into the custody of dest_usr.
  95         --
  96         -- In order to avoid colliding with an existing bucket owned by
  97         -- the destination user, append the source user's id (in parenthesese)
  98         -- to the name.  If you still get a collision, add successive
  99         -- spaces to the name and keep trying until you succeed.
 100         --
 101         FOR bucket_row in
 102                 SELECT id, name
 103                 FROM   container.biblio_record_entry_bucket
 104                 WHERE  owner = src_usr
 105         LOOP
 106                 suffix := ' (' || src_usr || ')';
 107                 LOOP
 108                         BEGIN
 109                                 UPDATE  container.biblio_record_entry_bucket
 110                                 SET     owner = dest_usr, name = name || suffix
 111                                 WHERE   id = bucket_row.id;
 112                         EXCEPTION WHEN unique_violation THEN
 113                                 suffix := suffix || ' ';
 114                                 CONTINUE;
 115                         END;
 116                         EXIT;
 117                 END LOOP;
 118         END LOOP;
 119
 120         FOR bucket_row in
 121                 SELECT id, name
 122                 FROM   container.call_number_bucket
 123                 WHERE  owner = src_usr
 124         LOOP
 125                 suffix := ' (' || src_usr || ')';
 126                 LOOP
 127                         BEGIN
 128                                 UPDATE  container.call_number_bucket
 129                                 SET     owner = dest_usr, name = name || suffix
 130                                 WHERE   id = bucket_row.id;
 131                         EXCEPTION WHEN unique_violation THEN
 132                                 suffix := suffix || ' ';
 133                                 CONTINUE;
 134                         END;
 135                         EXIT;
 136                 END LOOP;
 137         END LOOP;
 138
 139         FOR bucket_row in
 140                 SELECT id, name
 141                 FROM   container.copy_bucket
 142                 WHERE  owner = src_usr
 143         LOOP
 144                 suffix := ' (' || src_usr || ')';
 145                 LOOP
 146                         BEGIN
 147                                 UPDATE  container.copy_bucket
 148                                 SET     owner = dest_usr, name = name || suffix
 149                                 WHERE   id = bucket_row.id;
 150                         EXCEPTION WHEN unique_violation THEN
 151                                 suffix := suffix || ' ';
 152                                 CONTINUE;
 153                         END;
 154                         EXIT;
 155                 END LOOP;
 156         END LOOP;
 157
 158         FOR bucket_row in
 159                 SELECT id, name
 160                 FROM   container.user_bucket
 161                 WHERE  owner = src_usr
 162         LOOP
 163                 suffix := ' (' || src_usr || ')';
 164                 LOOP
 165                         BEGIN
 166                                 UPDATE  container.user_bucket
 167                                 SET     owner = dest_usr, name = name || suffix
 168                                 WHERE   id = bucket_row.id;
 169                         EXCEPTION WHEN unique_violation THEN
 170                                 suffix := suffix || ' ';
 171                                 CONTINUE;
 172                         END;
 173                         EXIT;
 174                 END LOOP;
 175         END LOOP;
 176
 177         UPDATE container.user_bucket_item SET target_user = dest_usr WHERE target_user = src_usr;
 178
 179     -- vandelay.*
 180         -- transfer queues the same way we transfer buckets (see above)
 181         FOR queue_row in
 182                 SELECT id, name
 183                 FROM   vandelay.queue
 184                 WHERE  owner = src_usr
 185         LOOP
 186                 suffix := ' (' || src_usr || ')';
 187                 LOOP
 188                         BEGIN
 189                                 UPDATE  vandelay.queue
 190                                 SET     owner = dest_usr, name = name || suffix
 191                                 WHERE   id = queue_row.id;
 192                         EXCEPTION WHEN unique_violation THEN
 193                                 suffix := suffix || ' ';
 194                                 CONTINUE;
 195                         END;
 196                         EXIT;
 197                 END LOOP;
 198         END LOOP;
 199
 200     -- money.*
 201     PERFORM actor.usr_merge_rows('money.collections_tracker', 'usr', src_usr, dest_usr);
 202     PERFORM actor.usr_merge_rows('money.collections_tracker', 'collector', src_usr, dest_usr);
 203     UPDATE money.billable_xact SET usr = dest_usr WHERE usr = src_usr;
 204     UPDATE money.billing SET voider = dest_usr WHERE voider = src_usr;
 205     UPDATE money.bnm_payment SET accepting_usr = dest_usr WHERE accepting_usr = src_usr;
 206
 207     -- action.*
 208     UPDATE action.circulation SET usr = dest_usr WHERE usr = src_usr;
 209     UPDATE action.circulation SET circ_staff = dest_usr WHERE circ_staff = src_usr;
 210     UPDATE action.circulation SET checkin_staff = dest_usr WHERE checkin_staff = src_usr;
 211
 212     UPDATE action.hold_request SET usr = dest_usr WHERE usr = src_usr;
 213     UPDATE action.hold_request SET fulfillment_staff = dest_usr WHERE fulfillment_staff = src_usr;
 214     UPDATE action.hold_request SET requestor = dest_usr WHERE requestor = src_usr;
 215     UPDATE action.hold_notification SET notify_staff = dest_usr WHERE notify_staff = src_usr;
 216
 217     UPDATE action.in_house_use SET staff = dest_usr WHERE staff = src_usr;
 218     UPDATE action.non_cataloged_circulation SET staff = dest_usr WHERE staff = src_usr;
 219     UPDATE action.non_cataloged_circulation SET patron = dest_usr WHERE patron = src_usr;
 220     UPDATE action.non_cat_in_house_use SET staff = dest_usr WHERE staff = src_usr;
 221     UPDATE action.survey_response SET usr = dest_usr WHERE usr = src_usr;
 222
 223     -- acq.*
 224     UPDATE acq.fund_allocation SET allocator = dest_usr WHERE allocator = src_usr;
 225
 226         -- transfer picklists the same way we transfer buckets (see above)
 227         FOR picklist_row in
 228                 SELECT id, name
 229                 FROM   acq.picklist
 230                 WHERE  owner = src_usr
 231         LOOP
 232                 suffix := ' (' || src_usr || ')';
 233                 LOOP
 234                         BEGIN
 235                                 UPDATE  acq.picklist
 236                                 SET     owner = dest_usr, name = name || suffix
 237                                 WHERE   id = picklist_row.id;
 238                         EXCEPTION WHEN unique_violation THEN
 239                                 suffix := suffix || ' ';
 240                                 CONTINUE;
 241                         END;
 242                         EXIT;
 243                 END LOOP;
 244         END LOOP;
 245
 246     UPDATE acq.purchase_order SET owner = dest_usr WHERE owner = src_usr;
 247     UPDATE acq.po_note SET creator = dest_usr WHERE creator = src_usr;
 248     UPDATE acq.po_note SET editor = dest_usr WHERE editor = src_usr;
 249     UPDATE acq.lineitem_note SET creator = dest_usr WHERE creator = src_usr;
 250     UPDATE acq.lineitem_note SET editor = dest_usr WHERE editor = src_usr;
 251     UPDATE acq.lineitem_usr_attr_definition SET usr = dest_usr WHERE usr = src_usr;
 252
 253     -- asset.*
 254     UPDATE asset.copy SET creator = dest_usr WHERE creator = src_usr;
 255     UPDATE asset.copy SET editor = dest_usr WHERE editor = src_usr;
 256     UPDATE asset.copy_note SET creator = dest_usr WHERE creator = src_usr;
 257     UPDATE asset.call_number SET creator = dest_usr WHERE creator = src_usr;
 258     UPDATE asset.call_number SET editor = dest_usr WHERE editor = src_usr;
 259     UPDATE asset.call_number_note SET creator = dest_usr WHERE creator = src_usr;
 260
 261     -- serial.*
 262     UPDATE serial.record_entry SET creator = dest_usr WHERE creator = src_usr;
 263     UPDATE serial.record_entry SET editor = dest_usr WHERE editor = src_usr;
 264
 265     -- reporter.*
 266     -- It's not uncommon to define the reporter schema in a replica
 267     -- DB only, so don't assume these tables exist in the write DB.
 268     BEGIN
 269         UPDATE reporter.template SET owner = dest_usr WHERE owner = src_usr;
 270     EXCEPTION WHEN undefined_table THEN
 271         -- do nothing
 272     END;
 273     BEGIN
 274         UPDATE reporter.report SET owner = dest_usr WHERE owner = src_usr;
 275     EXCEPTION WHEN undefined_table THEN
 276         -- do nothing
 277     END;
 278     BEGIN
 279         UPDATE reporter.schedule SET runner = dest_usr WHERE runner = src_usr;
 280     EXCEPTION WHEN undefined_table THEN
 281         -- do nothing
 282     END;
 283     BEGIN
 284                 -- transfer folders the same way we transfer buckets (see above)
 285                 FOR folder_row in
 286                         SELECT id, name
 287                         FROM   reporter.template_folder
 288                         WHERE  owner = src_usr
 289                 LOOP
 290                         suffix := ' (' || src_usr || ')';
 291                         LOOP
 292                                 BEGIN
 293                                         UPDATE  reporter.template_folder
 294                                         SET     owner = dest_usr, name = name || suffix
 295                                         WHERE   id = folder_row.id;
 296                                 EXCEPTION WHEN unique_violation THEN
 297                                         suffix := suffix || ' ';
 298                                         CONTINUE;
 299                                 END;
 300                                 EXIT;
 301                         END LOOP;
 302                 END LOOP;
 303     EXCEPTION WHEN undefined_table THEN
 304         -- do nothing
 305     END;
 306     BEGIN
 307                 -- transfer folders the same way we transfer buckets (see above)
 308                 FOR folder_row in
 309                         SELECT id, name
 310                         FROM   reporter.report_folder
 311                         WHERE  owner = src_usr
 312                 LOOP
 313                         suffix := ' (' || src_usr || ')';
 314                         LOOP
 315                                 BEGIN
 316                                         UPDATE  reporter.report_folder
 317                                         SET     owner = dest_usr, name = name || suffix
 318                                         WHERE   id = folder_row.id;
 319                                 EXCEPTION WHEN unique_violation THEN
 320                                         suffix := suffix || ' ';
 321                                         CONTINUE;
 322                                 END;
 323                                 EXIT;
 324                         END LOOP;
 325                 END LOOP;
 326     EXCEPTION WHEN undefined_table THEN
 327         -- do nothing
 328     END;
 329     BEGIN
 330                 -- transfer folders the same way we transfer buckets (see above)
 331                 FOR folder_row in
 332                         SELECT id, name
 333                         FROM   reporter.output_folder
 334                         WHERE  owner = src_usr
 335                 LOOP
 336                         suffix := ' (' || src_usr || ')';
 337                         LOOP
 338                                 BEGIN
 339                                         UPDATE  reporter.output_folder
 340                                         SET     owner = dest_usr, name = name || suffix
 341                                         WHERE   id = folder_row.id;
 342                                 EXCEPTION WHEN unique_violation THEN
 343                                         suffix := suffix || ' ';
 344                                         CONTINUE;
 345                                 END;
 346                                 EXIT;
 347                         END LOOP;
 348                 END LOOP;
 349     EXCEPTION WHEN undefined_table THEN
 350         -- do nothing
 351     END;
 352
 353     -- Finally, delete the source user
 354     DELETE FROM actor.usr WHERE id = src_usr;
 355
 356 END;
 357 $$ LANGUAGE plpgsql;
 358
 359 COMMENT ON FUNCTION actor.usr_merge(INT, INT, BOOLEAN, BOOLEAN, BOOLEAN) IS $$
 360 /**
 361  * Merges all user date from src_usr to dest_usr.  When collisions occur,
 362  * keep dest_usr's data and delete src_usr's data.
 363  */
 364 $$;
 365
 366
 367
 368 CREATE OR REPLACE FUNCTION actor.approve_pending_address(pending_id INT) RETURNS BIGINT AS $$
 369 DECLARE
 370     old_id INT;
 371 BEGIN
 372     SELECT INTO old_id replaces FROM actor.usr_address where id = pending_id;
 373     IF old_id IS NULL THEN
 374         UPDATE actor.usr_address SET pending = 'f' WHERE id = pending_id;
 375         RETURN pending_id;
 376     END IF;
 377     -- address replaces an existing address
 378     DELETE FROM actor.usr_address WHERE id = -old_id;
 379     UPDATE actor.usr_address SET id = -id WHERE id = old_id;
 380     UPDATE actor.usr_address SET replaces = NULL, id = old_id, pending = 'f' WHERE id = pending_id;
 381     RETURN old_id;
 382 END
 383 $$ LANGUAGE plpgsql;
 384
 385 COMMENT ON FUNCTION actor.approve_pending_address(INT) IS $$
 386 /**
 387  * Replaces an address with a pending address.  This is done by giving the pending
 388  * address the ID of the old address.  The replaced address is retained with -id.
 389  */
 390 $$;
 391
 392 CREATE OR REPLACE FUNCTION container.clear_expired_circ_history_items(
 393          ac_usr IN INTEGER
 394 ) RETURNS VOID AS $$
 395 --
 396 -- Delete old circulation bucket items for a specified user.
 397 -- "Old" means older than the interval specified by a
 398 -- user-level setting, if it is so specified.
 399 --
 400 DECLARE
 401     threshold TIMESTAMP WITH TIME ZONE;
 402 BEGIN
 403         -- Sanity check
 404         IF ac_usr IS NULL THEN
 405                 RETURN;
 406         END IF;
 407         -- Determine the threshold date that defines "old".  Subtract the
 408         -- interval from the system date, then truncate to midnight.
 409         SELECT
 410                 date_trunc(
 411                         'day',
 412                         now() - CAST( translate( value, '"', '' ) AS INTERVAL )
 413                 )
 414         INTO
 415                 threshold
 416         FROM
 417                 actor.usr_setting
 418         WHERE
 419                 usr = ac_usr
 420                 AND name = 'patron.max_reading_list_interval';
 421         --
 422         IF threshold is null THEN
 423                 -- No interval defined; don't delete anything
 424                 -- RAISE NOTICE 'No interval defined for user %', ac_usr;
 425                 return;
 426         END IF;
 427         --
 428         -- RAISE NOTICE 'Date threshold: %', threshold;
 429         --
 430         -- Threshold found; do the delete
 431         delete from container.copy_bucket_item
 432         where
 433                 bucket in
 434                 (
 435                         select
 436                                 id
 437                         from
 438                                 container.copy_bucket
 439                         where
 440                                 owner = ac_usr
 441                                 and btype = 'circ_history'
 442                 )
 443                 and create_time < threshold;
 444         --
 445         RETURN;
 446 END;
 447 $$ LANGUAGE plpgsql;
 448
 449 COMMENT ON FUNCTION container.clear_expired_circ_history_items( INTEGER ) IS $$
 450 /*
 451  * Delete old circulation bucket items for a specified user.
 452  * "Old" means older than the interval specified by a
 453  * user-level setting, if it is so specified.
 454 */
 455 $$;
 456
 457 CREATE OR REPLACE FUNCTION container.clear_all_expired_circ_history_items( )
 458 RETURNS VOID AS $$
 459 --
 460 -- Delete expired circulation bucket items for all users that have
 461 -- a setting for patron.max_reading_list_interval.
 462 --
 463 DECLARE
 464     today        TIMESTAMP WITH TIME ZONE;
 465     threshold    TIMESTAMP WITH TIME ZONE;
 466         usr_setting  RECORD;
 467 BEGIN
 468         SELECT date_trunc( 'day', now() ) INTO today;
 469         --
 470         FOR usr_setting in
 471                 SELECT
 472                         usr,
 473                         value
 474                 FROM
 475                         actor.usr_setting
 476                 WHERE
 477                         name = 'patron.max_reading_list_interval'
 478         LOOP
 479                 --
 480                 -- Make sure the setting is a valid interval
 481                 --
 482                 BEGIN
 483                         threshold := today - CAST( translate( usr_setting.value, '"', '' ) AS INTERVAL );
 484                 EXCEPTION
 485                         WHEN OTHERS THEN
 486                                 RAISE NOTICE 'Invalid setting patron.max_reading_list_interval for user %: ''%''',
 487                                         usr_setting.usr, usr_setting.value;
 488                                 CONTINUE;
 489                 END;
 490                 --
 491                 --RAISE NOTICE 'User % threshold %', usr_setting.usr, threshold;
 492                 --
 493         DELETE FROM container.copy_bucket_item
 494         WHERE
 495                 bucket IN
 496                 (
 497                     SELECT
 498                         id
 499                     FROM
 500                         container.copy_bucket
 501                     WHERE
 502                         owner = usr_setting.usr
 503                         AND btype = 'circ_history'
 504                 )
 505                 AND create_time < threshold;
 506         END LOOP;
 507         --
 508 END;
 509 $$ LANGUAGE plpgsql;
 510
 511 COMMENT ON FUNCTION container.clear_all_expired_circ_history_items( ) IS $$
 512 /*
 513  * Delete expired circulation bucket items for all users that have
 514  * a setting for patron.max_reading_list_interval.
 515 */
 516 $$
 517
 518
 519 CREATE OR REPLACE FUNCTION asset.merge_record_assets( target_record BIGINT, source_record BIGINT ) RETURNS INT AS $func$
 520 DECLARE
 521         moved_objects INT := 0;
 522         source_cn     asset.call_number%ROWTYPE;
 523         target_cn     asset.call_number%ROWTYPE;
 524         metarec       metabib.metarecord%ROWTYPE;
 525         hold          action.hold_request%ROWTYPE;
 526         ser_rec       serial.record_entry%ROWTYPE;
 527     uri_count     INT := 0;
 528     counter       INT := 0;
 529     uri_datafield TEXT;
 530     uri_text      TEXT := '';
 531 BEGIN
 532
 533     -- move any 856 entries on records that have at least one MARC-mapped URI entry
 534     SELECT  INTO uri_count COUNT(*)
 535       FROM  asset.uri_call_number_map m
 536             JOIN asset.call_number cn ON (m.call_number = cn.id)
 537       WHERE cn.record = source_record;
 538
 539     IF uri_count > 0 THEN
 540
 541         SELECT  COUNT(*) INTO counter
 542           FROM  xpath_table(
 543                     'id',
 544                     'marc',
 545                     'acq.lineitem',
 546                     '//*[@tag="856"]',
 547                     'id=' || lineitem
 548                 ) as t(i int,c text);
 549
 550         FOR i IN 1 .. counter LOOP
 551             SELECT  '<datafield xmlns="http://www.loc.gov/MARC21/slim" tag="856">' ||
 552                         array_to_string(
 553                             array_accum(
 554                                 '<subfield code="' || subfield || '">' ||
 555                                 regexp_replace(
 556                                     regexp_replace(
 557                                         regexp_replace(data,'&','&amp;','g'),
 558                                         '>', '&gt;', 'g'
 559                                     ),
 560                                     '<', '&lt;', 'g'
 561                                 ) || '</subfield>'
 562                             ), ''
 563                         ) || '</datafield>' INTO uri_datafield
 564               FROM  xpath_table(
 565                         'id',
 566                         'marc',
 567                         'biblio.record_entry',
 568                         '//*[@tag="856"][position()=' || i || ']/*/@code|' ||
 569                         '//*[@tag="856"][position()=' || i || ']/*[@code]',
 570                         'id=' || source_record
 571                     ) as t(id int,subfield text,data text);
 572
 573             uri_text := uri_text || uri_datafield;
 574         END LOOP;
 575
 576         IF uri_text <> '' THEN
 577             UPDATE  biblio.record_entry
 578               SET   marc = regexp_replace(marc,'(</[^>]*record>)', uri_text || E'\\1')
 579               WHERE id = target_record;
 580         END IF;
 581
 582     END IF;
 583
 584         -- Find and move metarecords to the target record
 585         SELECT  INTO metarec *
 586           FROM  metabib.metarecord
 587           WHERE master_record = source_record;
 588
 589         IF FOUND THEN
 590                 UPDATE  metabib.metarecord
 591                   SET   master_record = target_record,
 592                         mods = NULL
 593                   WHERE id = metarec.id;
 594
 595                 moved_objects := moved_objects + 1;
 596         END IF;
 597
 598         -- Find call numbers attached to the source ...
 599         FOR source_cn IN SELECT * FROM asset.call_number WHERE record = source_record LOOP
 600
 601                 SELECT  INTO target_cn *
 602                   FROM  asset.call_number
 603                   WHERE label = source_cn.label
 604                         AND owning_lib = source_cn.owning_lib
 605                         AND record = target_record;
 606
 607                 -- ... and if there's a conflicting one on the target ...
 608                 IF FOUND THEN
 609
 610                         -- ... move the copies to that, and ...
 611                         UPDATE  asset.copy
 612                           SET   call_number = target_cn.id
 613                           WHERE call_number = source_cn.id;
 614
 615                         -- ... move V holds to the move-target call number
 616                         FOR hold IN SELECT * FROM action.hold_request WHERE target = source_cn.id AND hold_type = 'V' LOOP
 617
 618                                 UPDATE  action.hold_request
 619                                   SET   target = target_cn.id
 620                                   WHERE id = hold.id;
 621
 622                                 moved_objects := moved_objects + 1;
 623                         END LOOP;
 624
 625                 -- ... if not ...
 626                 ELSE
 627                         -- ... just move the call number to the target record
 628                         UPDATE  asset.call_number
 629                           SET   record = target_record
 630                           WHERE id = source_cn.id;
 631                 END IF;
 632
 633                 moved_objects := moved_objects + 1;
 634         END LOOP;
 635
 636         -- Find T holds targeting the source record ...
 637         FOR hold IN SELECT * FROM action.hold_request WHERE target = source_record AND hold_type = 'T' LOOP
 638
 639                 -- ... and move them to the target record
 640                 UPDATE  action.hold_request
 641                   SET   target = target_record
 642                   WHERE id = hold.id;
 643
 644                 moved_objects := moved_objects + 1;
 645         END LOOP;
 646
 647         -- Find serial records targeting the source record ...
 648         FOR ser_rec IN SELECT * FROM serial.record_entry WHERE record = source_record LOOP
 649                 -- ... and move them to the target record
 650                 UPDATE  serial.record_entry
 651                   SET   record = target_record
 652                   WHERE id = ser_rec.id;
 653
 654                 moved_objects := moved_objects + 1;
 655         END LOOP;
 656
 657     -- Finally, "delete" the source record
 658     DELETE FROM biblio.record_entry WHERE id = source_record;
 659
 660         -- That's all, folks!
 661         RETURN moved_objects;
 662 END;
 663 $func$ LANGUAGE plpgsql;
 664