Open-ILS/src/sql/Pg/030.schema.metabib.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 metabib CASCADE;
  19
  20 BEGIN;
  21 CREATE SCHEMA metabib;
  22
  23 CREATE TABLE metabib.metarecord (
  24         id              BIGSERIAL       PRIMARY KEY,
  25         fingerprint     TEXT            NOT NULL,
  26         master_record   BIGINT,
  27         mods            TEXT
  28 );
  29 CREATE INDEX metabib_metarecord_master_record_idx ON metabib.metarecord (master_record);
  30 CREATE INDEX metabib_metarecord_fingerprint_idx ON metabib.metarecord (fingerprint);
  31
  32 CREATE TABLE metabib.identifier_field_entry (
  33         id              BIGSERIAL       PRIMARY KEY,
  34         source          BIGINT          NOT NULL,
  35         field           INT             NOT NULL,
  36         value           TEXT            NOT NULL,
  37         index_vector    tsvector        NOT NULL
  38 );
  39 CREATE TRIGGER metabib_identifier_field_entry_fti_trigger
  40         BEFORE UPDATE OR INSERT ON metabib.identifier_field_entry
  41         FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('identifier');
  42
  43 CREATE INDEX metabib_identifier_field_entry_index_vector_idx ON metabib.identifier_field_entry USING GIN (index_vector);
  44 CREATE INDEX metabib_identifier_field_entry_value_idx ON metabib.identifier_field_entry (SUBSTRING(value,1,1024)) WHERE index_vector = ''::TSVECTOR;
  45 CREATE INDEX metabib_identifier_field_entry_source_idx ON metabib.identifier_field_entry (source);
  46
  47 CREATE TABLE metabib.combined_identifier_field_entry (
  48         record          BIGINT          NOT NULL,
  49         metabib_field           INT             NULL,
  50         index_vector    tsvector        NOT NULL
  51 );
  52 CREATE UNIQUE INDEX metabib_combined_identifier_field_entry_fakepk_idx ON metabib.combined_identifier_field_entry (record, COALESCE(metabib_field::TEXT,''));
  53 CREATE INDEX metabib_combined_identifier_field_entry_index_vector_idx ON metabib.combined_identifier_field_entry USING GIN (index_vector);
  54 CREATE INDEX metabib_combined_identifier_field_source_idx ON metabib.combined_identifier_field_entry (metabib_field);
  55
  56 CREATE TABLE metabib.title_field_entry (
  57         id              BIGSERIAL       PRIMARY KEY,
  58         source          BIGINT          NOT NULL,
  59         field           INT             NOT NULL,
  60         value           TEXT            NOT NULL,
  61         index_vector    tsvector        NOT NULL
  62 );
  63 CREATE TRIGGER metabib_title_field_entry_fti_trigger
  64         BEFORE UPDATE OR INSERT ON metabib.title_field_entry
  65         FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('title');
  66
  67 CREATE INDEX metabib_title_field_entry_index_vector_idx ON metabib.title_field_entry USING GIN (index_vector);
  68 CREATE INDEX metabib_title_field_entry_value_idx ON metabib.title_field_entry (SUBSTRING(value,1,1024)) WHERE index_vector = ''::TSVECTOR;
  69 CREATE INDEX metabib_title_field_entry_source_idx ON metabib.title_field_entry (source);
  70
  71 CREATE TABLE metabib.combined_title_field_entry (
  72         record          BIGINT          NOT NULL,
  73         metabib_field           INT             NULL,
  74         index_vector    tsvector        NOT NULL
  75 );
  76 CREATE UNIQUE INDEX metabib_combined_title_field_entry_fakepk_idx ON metabib.combined_title_field_entry (record, COALESCE(metabib_field::TEXT,''));
  77 CREATE INDEX metabib_combined_title_field_entry_index_vector_idx ON metabib.combined_title_field_entry USING GIN (index_vector);
  78 CREATE INDEX metabib_combined_title_field_source_idx ON metabib.combined_title_field_entry (metabib_field);
  79
  80 CREATE TABLE metabib.author_field_entry (
  81         id              BIGSERIAL       PRIMARY KEY,
  82         source          BIGINT          NOT NULL,
  83         field           INT             NOT NULL,
  84         value           TEXT            NOT NULL,
  85         index_vector    tsvector        NOT NULL
  86 );
  87 CREATE TRIGGER metabib_author_field_entry_fti_trigger
  88         BEFORE UPDATE OR INSERT ON metabib.author_field_entry
  89         FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('author');
  90
  91 CREATE INDEX metabib_author_field_entry_index_vector_idx ON metabib.author_field_entry USING GIN (index_vector);
  92 CREATE INDEX metabib_author_field_entry_value_idx ON metabib.author_field_entry (SUBSTRING(value,1,1024)) WHERE index_vector = ''::TSVECTOR;
  93 CREATE INDEX metabib_author_field_entry_source_idx ON metabib.author_field_entry (source);
  94
  95 CREATE TABLE metabib.combined_author_field_entry (
  96         record          BIGINT          NOT NULL,
  97         metabib_field           INT             NULL,
  98         index_vector    tsvector        NOT NULL
  99 );
 100 CREATE UNIQUE INDEX metabib_combined_author_field_entry_fakepk_idx ON metabib.combined_author_field_entry (record, COALESCE(metabib_field::TEXT,''));
 101 CREATE INDEX metabib_combined_author_field_entry_index_vector_idx ON metabib.combined_author_field_entry USING GIN (index_vector);
 102 CREATE INDEX metabib_combined_author_field_source_idx ON metabib.combined_author_field_entry (metabib_field);
 103
 104 CREATE TABLE metabib.subject_field_entry (
 105         id              BIGSERIAL       PRIMARY KEY,
 106         source          BIGINT          NOT NULL,
 107         field           INT             NOT NULL,
 108         value           TEXT            NOT NULL,
 109         index_vector    tsvector        NOT NULL
 110 );
 111 CREATE TRIGGER metabib_subject_field_entry_fti_trigger
 112         BEFORE UPDATE OR INSERT ON metabib.subject_field_entry
 113         FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('subject');
 114
 115 CREATE INDEX metabib_subject_field_entry_index_vector_idx ON metabib.subject_field_entry USING GIN (index_vector);
 116 CREATE INDEX metabib_subject_field_entry_value_idx ON metabib.subject_field_entry (SUBSTRING(value,1,1024)) WHERE index_vector = ''::TSVECTOR;
 117 CREATE INDEX metabib_subject_field_entry_source_idx ON metabib.subject_field_entry (source);
 118
 119 CREATE TABLE metabib.combined_subject_field_entry (
 120         record          BIGINT          NOT NULL,
 121         metabib_field           INT             NULL,
 122         index_vector    tsvector        NOT NULL
 123 );
 124 CREATE UNIQUE INDEX metabib_combined_subject_field_entry_fakepk_idx ON metabib.combined_subject_field_entry (record, COALESCE(metabib_field::TEXT,''));
 125 CREATE INDEX metabib_combined_subject_field_entry_index_vector_idx ON metabib.combined_subject_field_entry USING GIN (index_vector);
 126 CREATE INDEX metabib_combined_subject_field_source_idx ON metabib.combined_subject_field_entry (metabib_field);
 127
 128 CREATE TABLE metabib.keyword_field_entry (
 129         id              BIGSERIAL       PRIMARY KEY,
 130         source          BIGINT          NOT NULL,
 131         field           INT             NOT NULL,
 132         value           TEXT            NOT NULL,
 133         index_vector    tsvector        NOT NULL
 134 );
 135 CREATE TRIGGER metabib_keyword_field_entry_fti_trigger
 136         BEFORE UPDATE OR INSERT ON metabib.keyword_field_entry
 137         FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('keyword');
 138
 139 CREATE INDEX metabib_keyword_field_entry_index_vector_idx ON metabib.keyword_field_entry USING GIN (index_vector);
 140 CREATE INDEX metabib_keyword_field_entry_value_idx ON metabib.keyword_field_entry (SUBSTRING(value,1,1024)) WHERE index_vector = ''::TSVECTOR;
 141 CREATE INDEX metabib_keyword_field_entry_source_idx ON metabib.keyword_field_entry (source);
 142
 143 CREATE TABLE metabib.combined_keyword_field_entry (
 144         record          BIGINT          NOT NULL,
 145         metabib_field           INT             NULL,
 146         index_vector    tsvector        NOT NULL
 147 );
 148 CREATE UNIQUE INDEX metabib_combined_keyword_field_entry_fakepk_idx ON metabib.combined_keyword_field_entry (record, COALESCE(metabib_field::TEXT,''));
 149 CREATE INDEX metabib_combined_keyword_field_entry_index_vector_idx ON metabib.combined_keyword_field_entry USING GIN (index_vector);
 150 CREATE INDEX metabib_combined_keyword_field_source_idx ON metabib.combined_keyword_field_entry (metabib_field);
 151
 152 CREATE TABLE metabib.series_field_entry (
 153         id              BIGSERIAL       PRIMARY KEY,
 154         source          BIGINT          NOT NULL,
 155         field           INT             NOT NULL,
 156         value           TEXT            NOT NULL,
 157         index_vector    tsvector        NOT NULL
 158 );
 159 CREATE TRIGGER metabib_series_field_entry_fti_trigger
 160         BEFORE UPDATE OR INSERT ON metabib.series_field_entry
 161         FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('series');
 162
 163 CREATE INDEX metabib_series_field_entry_index_vector_idx ON metabib.series_field_entry USING GIN (index_vector);
 164 CREATE INDEX metabib_series_field_entry_value_idx ON metabib.series_field_entry (SUBSTRING(value,1,1024)) WHERE index_vector = ''::TSVECTOR;
 165 CREATE INDEX metabib_series_field_entry_source_idx ON metabib.series_field_entry (source);
 166
 167 CREATE TABLE metabib.combined_series_field_entry (
 168         record          BIGINT          NOT NULL,
 169         metabib_field           INT             NULL,
 170         index_vector    tsvector        NOT NULL
 171 );
 172 CREATE UNIQUE INDEX metabib_combined_series_field_entry_fakepk_idx ON metabib.combined_series_field_entry (record, COALESCE(metabib_field::TEXT,''));
 173 CREATE INDEX metabib_combined_series_field_entry_index_vector_idx ON metabib.combined_series_field_entry USING GIN (index_vector);
 174 CREATE INDEX metabib_combined_series_field_source_idx ON metabib.combined_series_field_entry (metabib_field);
 175
 176 CREATE VIEW metabib.combined_all_field_entry AS
 177     SELECT * FROM metabib.combined_title_field_entry
 178         UNION ALL
 179     SELECT * FROM metabib.combined_author_field_entry
 180         UNION ALL
 181     SELECT * FROM metabib.combined_subject_field_entry
 182         UNION ALL
 183     SELECT * FROM metabib.combined_keyword_field_entry
 184         UNION ALL
 185     SELECT * FROM metabib.combined_identifier_field_entry
 186         UNION ALL
 187     SELECT * FROM metabib.combined_series_field_entry;
 188
 189 CREATE TABLE metabib.facet_entry (
 190         id              BIGSERIAL       PRIMARY KEY,
 191         source          BIGINT          NOT NULL,
 192         field           INT             NOT NULL,
 193         value           TEXT            NOT NULL
 194 );
 195 CREATE INDEX metabib_facet_entry_field_idx ON metabib.facet_entry (field);
 196 CREATE INDEX metabib_facet_entry_value_idx ON metabib.facet_entry (SUBSTRING(value,1,1024));
 197 CREATE INDEX metabib_facet_entry_source_idx ON metabib.facet_entry (source);
 198
 199 CREATE TABLE metabib.display_entry (
 200     id      BIGSERIAL  PRIMARY KEY,
 201     source  BIGINT     NOT NULL,
 202     field   INT        NOT NULL,
 203     value   TEXT       NOT NULL
 204 );
 205
 206 CREATE INDEX metabib_display_entry_field_idx
 207     ON metabib.display_entry (field);
 208 CREATE INDEX metabib_display_entry_source_idx
 209     ON metabib.display_entry (source);
 210
 211 CREATE VIEW metabib.flat_display_entry AS
 212     /* One row per display entry fleshed with field info */
 213     SELECT
 214         mde.source,
 215         cdfm.name,
 216         cdfm.multi,
 217         cmf.label,
 218         cmf.id AS field,
 219         mde.value
 220     FROM metabib.display_entry mde
 221     JOIN config.metabib_field cmf ON (cmf.id = mde.field)
 222     JOIN config.display_field_map cdfm ON (cdfm.field = mde.field)
 223 ;
 224
 225 CREATE VIEW metabib.compressed_display_entry AS
 226 /* Like flat_display_entry except values are compressed into
 227    one row per display_field_map and JSON-ified.  */
 228     SELECT
 229         source,
 230         name,
 231         multi,
 232         label,
 233         field,
 234         CASE WHEN multi THEN
 235             TO_JSON(ARRAY_AGG(value))
 236         ELSE
 237             TO_JSON(MIN(value))
 238         END AS value
 239     FROM metabib.flat_display_entry
 240     GROUP BY 1, 2, 3, 4, 5
 241 ;
 242
 243 CREATE VIEW metabib.wide_display_entry AS
 244 /* Table-like view of well-known display fields.
 245    This VIEW expands as well-known display fields are added. */
 246     SELECT
 247         bre.id AS source,
 248         COALESCE(mcde_title.value, 'null')::TEXT AS title,
 249         COALESCE(mcde_author.value, 'null')::TEXT AS author,
 250         COALESCE(mcde_subject_geographic.value, 'null')::TEXT AS subject_geographic,
 251         COALESCE(mcde_subject_name.value, 'null')::TEXT AS subject_name,
 252         COALESCE(mcde_subject_temporal.value, 'null')::TEXT AS subject_temporal,
 253         COALESCE(mcde_subject_topic.value, 'null')::TEXT AS subject_topic,
 254         COALESCE(mcde_creators.value, 'null')::TEXT AS creators,
 255         COALESCE(mcde_isbn.value, 'null')::TEXT AS isbn,
 256         COALESCE(mcde_issn.value, 'null')::TEXT AS issn,
 257         COALESCE(mcde_upc.value, 'null')::TEXT AS upc,
 258         COALESCE(mcde_tcn.value, 'null')::TEXT AS tcn,
 259         COALESCE(mcde_edition.value, 'null')::TEXT AS edition,
 260         COALESCE(mcde_physical_description.value, 'null')::TEXT AS physical_description,
 261         COALESCE(mcde_publisher.value, 'null')::TEXT AS publisher,
 262         COALESCE(mcde_series_title.value, 'null')::TEXT AS series_title,
 263         COALESCE(mcde_abstract.value, 'null')::TEXT AS abstract,
 264         COALESCE(mcde_toc.value, 'null')::TEXT AS toc,
 265         COALESCE(mcde_pubdate.value, 'null')::TEXT AS pubdate,
 266         COALESCE(mcde_type_of_resource.value, 'null')::TEXT AS type_of_resource
 267     FROM biblio.record_entry bre
 268     LEFT JOIN metabib.compressed_display_entry mcde_title
 269         ON (bre.id = mcde_title.source AND mcde_title.name = 'title')
 270     LEFT JOIN metabib.compressed_display_entry mcde_author
 271         ON (bre.id = mcde_author.source AND mcde_author.name = 'author')
 272     LEFT JOIN metabib.compressed_display_entry mcde_subject
 273         ON (bre.id = mcde_subject.source AND mcde_subject.name = 'subject')
 274     LEFT JOIN metabib.compressed_display_entry mcde_subject_geographic
 275         ON (bre.id = mcde_subject_geographic.source
 276             AND mcde_subject_geographic.name = 'subject_geographic')
 277     LEFT JOIN metabib.compressed_display_entry mcde_subject_name
 278         ON (bre.id = mcde_subject_name.source
 279             AND mcde_subject_name.name = 'subject_name')
 280     LEFT JOIN metabib.compressed_display_entry mcde_subject_temporal
 281         ON (bre.id = mcde_subject_temporal.source
 282             AND mcde_subject_temporal.name = 'subject_temporal')
 283     LEFT JOIN metabib.compressed_display_entry mcde_subject_topic
 284         ON (bre.id = mcde_subject_topic.source
 285             AND mcde_subject_topic.name = 'subject_topic')
 286     LEFT JOIN metabib.compressed_display_entry mcde_creators
 287         ON (bre.id = mcde_creators.source AND mcde_creators.name = 'creators')
 288     LEFT JOIN metabib.compressed_display_entry mcde_isbn
 289         ON (bre.id = mcde_isbn.source AND mcde_isbn.name = 'isbn')
 290     LEFT JOIN metabib.compressed_display_entry mcde_issn
 291         ON (bre.id = mcde_issn.source AND mcde_issn.name = 'issn')
 292     LEFT JOIN metabib.compressed_display_entry mcde_upc
 293         ON (bre.id = mcde_upc.source AND mcde_upc.name = 'upc')
 294     LEFT JOIN metabib.compressed_display_entry mcde_tcn
 295         ON (bre.id = mcde_tcn.source AND mcde_tcn.name = 'tcn')
 296     LEFT JOIN metabib.compressed_display_entry mcde_edition
 297         ON (bre.id = mcde_edition.source AND mcde_edition.name = 'edition')
 298     LEFT JOIN metabib.compressed_display_entry mcde_physical_description
 299         ON (bre.id = mcde_physical_description.source
 300             AND mcde_physical_description.name = 'physical_description')
 301     LEFT JOIN metabib.compressed_display_entry mcde_publisher
 302         ON (bre.id = mcde_publisher.source AND mcde_publisher.name = 'publisher')
 303     LEFT JOIN metabib.compressed_display_entry mcde_series_title
 304         ON (bre.id = mcde_series_title.source AND mcde_series_title.name = 'series_title')
 305     LEFT JOIN metabib.compressed_display_entry mcde_abstract
 306         ON (bre.id = mcde_abstract.source AND mcde_abstract.name = 'abstract')
 307     LEFT JOIN metabib.compressed_display_entry mcde_toc
 308         ON (bre.id = mcde_toc.source AND mcde_toc.name = 'toc')
 309     LEFT JOIN metabib.compressed_display_entry mcde_pubdate
 310         ON (bre.id = mcde_pubdate.source AND mcde_pubdate.name = 'pubdate')
 311     LEFT JOIN metabib.compressed_display_entry mcde_type_of_resource
 312         ON (bre.id = mcde_type_of_resource.source
 313             AND mcde_type_of_resource.name = 'type_of_resource')
 314 ;
 315
 316 CREATE TABLE metabib.browse_entry (
 317     id BIGSERIAL PRIMARY KEY,
 318     value TEXT,
 319     index_vector tsvector,
 320     sort_value  TEXT NOT NULL,
 321     UNIQUE(sort_value, value)
 322 );
 323
 324
 325 CREATE INDEX browse_entry_sort_value_idx
 326     ON metabib.browse_entry USING BTREE (sort_value);
 327
 328 CREATE INDEX metabib_browse_entry_index_vector_idx ON metabib.browse_entry USING GIN (index_vector);
 329 CREATE TRIGGER metabib_browse_entry_fti_trigger
 330     BEFORE INSERT OR UPDATE ON metabib.browse_entry
 331     FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('keyword');
 332
 333
 334 CREATE TABLE metabib.browse_entry_def_map (
 335     id BIGSERIAL PRIMARY KEY,
 336     entry BIGINT REFERENCES metabib.browse_entry (id),
 337     def INT REFERENCES config.metabib_field (id) ON UPDATE CASCADE DEFERRABLE INITIALLY DEFERRED,
 338     source BIGINT REFERENCES biblio.record_entry (id),
 339     authority BIGINT REFERENCES authority.record_entry (id) ON DELETE SET NULL
 340 );
 341 CREATE INDEX browse_entry_def_map_def_idx ON metabib.browse_entry_def_map (def);
 342 CREATE INDEX browse_entry_def_map_entry_idx ON metabib.browse_entry_def_map (entry);
 343 CREATE INDEX browse_entry_def_map_source_idx ON metabib.browse_entry_def_map (source);
 344
 345 CREATE TABLE metabib.browse_entry_simple_heading_map (
 346     id BIGSERIAL PRIMARY KEY,
 347     entry BIGINT REFERENCES metabib.browse_entry (id),
 348     simple_heading BIGINT REFERENCES authority.simple_heading (id) ON DELETE CASCADE
 349 );
 350 CREATE INDEX browse_entry_sh_map_entry_idx ON metabib.browse_entry_simple_heading_map (entry);
 351 CREATE INDEX browse_entry_sh_map_sh_idx ON metabib.browse_entry_simple_heading_map (simple_heading);
 352
 353 CREATE OR REPLACE FUNCTION metabib.display_field_normalize_trigger ()
 354     RETURNS TRIGGER AS $$
 355 DECLARE
 356     normalizer  RECORD;
 357     display_field_text  TEXT;
 358 BEGIN
 359     display_field_text := NEW.value;
 360
 361     FOR normalizer IN
 362         SELECT  n.func AS func,
 363                 n.param_count AS param_count,
 364                 m.params AS params
 365           FROM  config.index_normalizer n
 366                 JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
 367           WHERE m.field = NEW.field AND m.pos < 0
 368           ORDER BY m.pos LOOP
 369
 370             EXECUTE 'SELECT ' || normalizer.func || '(' ||
 371                 quote_literal( display_field_text ) ||
 372                 CASE
 373                     WHEN normalizer.param_count > 0
 374                         THEN ',' || REPLACE(REPLACE(BTRIM(
 375                             normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
 376                         ELSE ''
 377                     END ||
 378                 ')' INTO display_field_text;
 379
 380     END LOOP;
 381
 382     NEW.value = display_field_text;
 383
 384     RETURN NEW;
 385 END;
 386 $$ LANGUAGE PLPGSQL;
 387
 388 CREATE TRIGGER display_field_normalize_tgr
 389         BEFORE UPDATE OR INSERT ON metabib.display_entry
 390         FOR EACH ROW EXECUTE PROCEDURE metabib.display_field_normalize_trigger();
 391
 392 CREATE OR REPLACE FUNCTION evergreen.display_field_force_nfc()
 393     RETURNS TRIGGER AS $$
 394 BEGIN
 395     NEW.value := force_unicode_normal_form(NEW.value,'NFC');
 396     RETURN NEW;
 397 END;
 398 $$ LANGUAGE PLPGSQL;
 399
 400 CREATE TRIGGER display_field_force_nfc_tgr
 401         BEFORE UPDATE OR INSERT ON metabib.display_entry
 402         FOR EACH ROW EXECUTE PROCEDURE evergreen.display_field_force_nfc();
 403
 404
 405 CREATE OR REPLACE FUNCTION metabib.facet_normalize_trigger () RETURNS TRIGGER AS $$
 406 DECLARE
 407     normalizer  RECORD;
 408     facet_text  TEXT;
 409 BEGIN
 410     facet_text := NEW.value;
 411
 412     FOR normalizer IN
 413         SELECT  n.func AS func,
 414                 n.param_count AS param_count,
 415                 m.params AS params
 416           FROM  config.index_normalizer n
 417                 JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
 418           WHERE m.field = NEW.field AND m.pos < 0
 419           ORDER BY m.pos LOOP
 420
 421             EXECUTE 'SELECT ' || normalizer.func || '(' ||
 422                 quote_literal( facet_text ) ||
 423                 CASE
 424                     WHEN normalizer.param_count > 0
 425                         THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
 426                         ELSE ''
 427                     END ||
 428                 ')' INTO facet_text;
 429
 430     END LOOP;
 431
 432     NEW.value = facet_text;
 433
 434     RETURN NEW;
 435 END;
 436 $$ LANGUAGE PLPGSQL;
 437
 438 CREATE TRIGGER facet_normalize_tgr
 439         BEFORE UPDATE OR INSERT ON metabib.facet_entry
 440         FOR EACH ROW EXECUTE PROCEDURE metabib.facet_normalize_trigger();
 441
 442 CREATE OR REPLACE FUNCTION evergreen.facet_force_nfc() RETURNS TRIGGER AS $$
 443 BEGIN
 444     NEW.value := force_unicode_normal_form(NEW.value,'NFC');
 445     RETURN NEW;
 446 END;
 447 $$ LANGUAGE PLPGSQL;
 448
 449 CREATE TRIGGER facet_force_nfc_tgr
 450         BEFORE UPDATE OR INSERT ON metabib.facet_entry
 451         FOR EACH ROW EXECUTE PROCEDURE evergreen.facet_force_nfc();
 452
 453 -- DECREMENTING serial starts at -1
 454 CREATE SEQUENCE metabib.uncontrolled_record_attr_value_id_seq INCREMENT BY -1;
 455
 456 CREATE TABLE metabib.uncontrolled_record_attr_value (
 457     id      BIGINT  PRIMARY KEY DEFAULT nextval('metabib.uncontrolled_record_attr_value_id_seq'),
 458     attr    TEXT    NOT NULL REFERENCES config.record_attr_definition (name),
 459     value   TEXT    NOT NULL
 460 );
 461 CREATE UNIQUE INDEX muv_once_idx ON metabib.uncontrolled_record_attr_value (attr,value);
 462
 463 CREATE VIEW metabib.record_attr_id_map AS
 464     SELECT id, attr, value FROM metabib.uncontrolled_record_attr_value
 465         UNION
 466     SELECT  c.id, c.ctype AS attr, c.code AS value
 467       FROM  config.coded_value_map c
 468             JOIN config.record_attr_definition d ON (d.name = c.ctype AND NOT d.composite);
 469
 470 CREATE VIEW metabib.composite_attr_id_map AS
 471     SELECT  c.id, c.ctype AS attr, c.code AS value
 472       FROM  config.coded_value_map c
 473             JOIN config.record_attr_definition d ON (d.name = c.ctype AND d.composite);
 474
 475 CREATE VIEW metabib.full_attr_id_map AS
 476     SELECT id, attr, value FROM metabib.record_attr_id_map
 477         UNION
 478     SELECT id, attr, value FROM metabib.composite_attr_id_map;
 479
 480
 481 CREATE OR REPLACE FUNCTION metabib.compile_composite_attr_cache_init () RETURNS BOOL AS $f$
 482     $_SHARED{metabib_compile_composite_attr_cache} = {}
 483         if ! exists $_SHARED{metabib_compile_composite_attr_cache};
 484     return exists $_SHARED{metabib_compile_composite_attr_cache};
 485 $f$ LANGUAGE PLPERLU;
 486
 487 CREATE OR REPLACE FUNCTION metabib.compile_composite_attr_cache_disable () RETURNS BOOL AS $f$
 488     delete $_SHARED{metabib_compile_composite_attr_cache};
 489     return ! exists $_SHARED{metabib_compile_composite_attr_cache};
 490 $f$ LANGUAGE PLPERLU;
 491
 492 CREATE OR REPLACE FUNCTION metabib.compile_composite_attr_cache_invalidate () RETURNS BOOL AS $f$
 493     SELECT metabib.compile_composite_attr_cache_disable() AND metabib.compile_composite_attr_cache_init();
 494 $f$ LANGUAGE SQL;
 495
 496 CREATE OR REPLACE FUNCTION metabib.composite_attr_def_cache_inval_tgr () RETURNS TRIGGER AS $f$
 497 BEGIN
 498     PERFORM metabib.compile_composite_attr_cache_invalidate();
 499     RETURN NULL;
 500 END;
 501 $f$ LANGUAGE PLPGSQL;
 502
 503 CREATE TRIGGER ccraed_cache_inval_tgr AFTER INSERT OR UPDATE OR DELETE ON config.composite_attr_entry_definition FOR EACH STATEMENT EXECUTE PROCEDURE metabib.composite_attr_def_cache_inval_tgr();
 504
 505 CREATE OR REPLACE FUNCTION metabib.compile_composite_attr ( cattr_def TEXT ) RETURNS query_int AS $func$
 506
 507     use JSON::XS;
 508
 509     my $json = shift;
 510     my $def = decode_json($json);
 511
 512     die("Composite attribute definition not supplied") unless $def;
 513
 514     my $_cache = (exists $_SHARED{metabib_compile_composite_attr_cache}) ? 1 : 0;
 515
 516     return $_SHARED{metabib_compile_composite_attr_cache}{$json}
 517         if ($_cache && $_SHARED{metabib_compile_composite_attr_cache}{$json});
 518
 519     sub recurse {
 520         my $d = shift;
 521         my $j = '&';
 522         my @list;
 523
 524         if (ref $d eq 'HASH') { # node or AND
 525             if (exists $d->{_attr}) { # it is a node
 526                 my $plan = spi_prepare('SELECT * FROM metabib.full_attr_id_map WHERE attr = $1 AND value = $2', qw/TEXT TEXT/);
 527                 my $id = spi_exec_prepared(
 528                     $plan, {limit => 1}, $d->{_attr}, $d->{_val}
 529                 )->{rows}[0]{id};
 530                 spi_freeplan($plan);
 531                 return $id;
 532             } elsif (exists $d->{_not} && scalar(keys(%$d)) == 1) { # it is a NOT
 533                 return '!' . recurse($$d{_not});
 534             } else { # an AND list
 535                 @list = map { recurse($$d{$_}) } sort keys %$d;
 536             }
 537         } elsif (ref $d eq 'ARRAY') {
 538             $j = '|';
 539             @list = map { recurse($_) } @$d;
 540         }
 541
 542         @list = grep { defined && $_ ne '' } @list;
 543
 544         return '(' . join($j,@list) . ')' if @list;
 545         return '';
 546     }
 547
 548     my $val = recurse($def) || undef;
 549     $_SHARED{metabib_compile_composite_attr_cache}{$json} = $val if $_cache;
 550     return $val;
 551
 552 $func$ IMMUTABLE LANGUAGE plperlu;
 553
 554 CREATE OR REPLACE FUNCTION metabib.compile_composite_attr ( cattr_id INT ) RETURNS query_int AS $func$
 555     SELECT metabib.compile_composite_attr(definition) FROM config.composite_attr_entry_definition WHERE coded_value = $1;
 556 $func$ STRICT IMMUTABLE LANGUAGE SQL;
 557
 558 CREATE TABLE metabib.record_attr_vector_list (
 559     source  BIGINT  PRIMARY KEY REFERENCES biblio.record_entry (id),
 560     vlist   INT[]   NOT NULL -- stores id from ccvm AND murav
 561 );
 562 CREATE INDEX mrca_vlist_idx ON metabib.record_attr_vector_list USING gin ( vlist gin__int_ops );
 563
 564 /* This becomes a view, and we do sorters differently ...
 565 CREATE TABLE metabib.record_attr (
 566         id              BIGINT  PRIMARY KEY REFERENCES biblio.record_entry (id) ON DELETE CASCADE,
 567         attrs   HSTORE  NOT NULL DEFAULT ''::HSTORE
 568 );
 569 CREATE INDEX metabib_svf_attrs_idx ON metabib.record_attr USING GIN (attrs);
 570 CREATE INDEX metabib_svf_date1_idx ON metabib.record_attr ((attrs->'date1'));
 571 CREATE INDEX metabib_svf_dates_idx ON metabib.record_attr ((attrs->'date1'),(attrs->'date2'));
 572 */
 573
 574 /* ... like this */
 575 CREATE TABLE metabib.record_sorter (
 576     id      BIGSERIAL   PRIMARY KEY,
 577     source  BIGINT      NOT NULL REFERENCES biblio.record_entry (id) ON DELETE CASCADE,
 578     attr    TEXT        NOT NULL REFERENCES config.record_attr_definition (name) ON DELETE CASCADE,
 579     value   TEXT        NOT NULL
 580 );
 581 CREATE INDEX metabib_sorter_source_idx ON metabib.record_sorter (source); -- we may not need one of this or the next ... stats will tell
 582 CREATE INDEX metabib_sorter_s_a_idx ON metabib.record_sorter (source, attr);
 583 CREATE INDEX metabib_sorter_a_v_idx ON metabib.record_sorter (attr, value);
 584
 585
 586 CREATE TYPE metabib.record_attr_type AS (
 587     id      BIGINT,
 588     attrs   HSTORE
 589 );
 590
 591 -- Back-compat view ... we're moving to an INTARRAY world
 592 CREATE VIEW metabib.record_attr_flat AS
 593     SELECT  v.source AS id,
 594             m.attr AS attr,
 595             m.value AS value
 596       FROM  metabib.record_attr_vector_list v
 597             LEFT JOIN metabib.uncontrolled_record_attr_value m ON ( m.id = ANY( v.vlist ) )
 598         UNION
 599     SELECT  v.source AS id,
 600             c.ctype AS attr,
 601             c.code AS value
 602       FROM  metabib.record_attr_vector_list v
 603             LEFT JOIN config.coded_value_map c ON ( c.id = ANY( v.vlist ) );
 604
 605 CREATE VIEW metabib.record_attr AS
 606     SELECT  id, HSTORE( ARRAY_AGG( attr ), ARRAY_AGG( value ) ) AS attrs
 607       FROM  metabib.record_attr_flat
 608       WHERE attr IS NOT NULL
 609       GROUP BY 1;
 610
 611 -- Back-back-compat view ... we use to live in an HSTORE world
 612 CREATE TYPE metabib.rec_desc_type AS (
 613     item_type       TEXT,
 614     item_form       TEXT,
 615     bib_level       TEXT,
 616     control_type    TEXT,
 617     char_encoding   TEXT,
 618     enc_level       TEXT,
 619     audience        TEXT,
 620     lit_form        TEXT,
 621     type_mat        TEXT,
 622     cat_form        TEXT,
 623     pub_status      TEXT,
 624     item_lang       TEXT,
 625     vr_format       TEXT,
 626     date1           TEXT,
 627     date2           TEXT
 628 );
 629
 630 CREATE VIEW metabib.rec_descriptor AS
 631     SELECT  id,
 632             id AS record,
 633             (populate_record(NULL::metabib.rec_desc_type, attrs)).*
 634       FROM  metabib.record_attr;
 635
 636 -- Use a sequence that matches previous version, for easier upgrading.
 637 CREATE SEQUENCE metabib.full_rec_id_seq;
 638
 639 CREATE TABLE metabib.real_full_rec (
 640         id                  BIGINT      NOT NULL DEFAULT NEXTVAL('metabib.full_rec_id_seq'::REGCLASS),
 641         record          BIGINT          NOT NULL,
 642         tag             CHAR(3)         NOT NULL,
 643         ind1            TEXT,
 644         ind2            TEXT,
 645         subfield        TEXT,
 646         value           TEXT            NOT NULL,
 647         index_vector    tsvector        NOT NULL
 648 );
 649 ALTER TABLE metabib.real_full_rec ADD PRIMARY KEY (id);
 650
 651 CREATE INDEX metabib_full_rec_tag_subfield_idx ON metabib.real_full_rec (tag,subfield);
 652 CREATE INDEX metabib_full_rec_value_idx ON metabib.real_full_rec (substring(value,1,1024));
 653 /* Enable LIKE to use an index for database clusters with locales other than C or POSIX */
 654 CREATE INDEX metabib_full_rec_value_tpo_index ON metabib.real_full_rec (substring(value,1,1024) text_pattern_ops);
 655 CREATE INDEX metabib_full_rec_record_idx ON metabib.real_full_rec (record);
 656 CREATE INDEX metabib_full_rec_index_vector_idx ON metabib.real_full_rec USING GIN (index_vector);
 657 CREATE INDEX metabib_full_rec_isxn_caseless_idx
 658     ON metabib.real_full_rec (LOWER(value))
 659     WHERE tag IN ('020', '022', '024');
 660 -- This next index might fully supplant the one above, but leaving both for now.
 661 -- (they are not too large)
 662 -- The reason we need this index is to ensure that the query parser always
 663 -- prefers this index over the simpler tag/subfield index, as this greatly
 664 -- increases Vandelay overlay speed for these identifiers, especially when
 665 -- a record has many of these fields (around > 4-6 seems like the cutoff
 666 -- on at least one PG9.1 system)
 667 -- A similar index could be added for other fields (e.g. 010), but one should
 668 -- leave out the LOWER() in all other cases.
 669 -- TODO: verify whether we can discard the non tag/subfield/substring version
 670 -- above (metabib_full_rec_isxn_caseless_idx)
 671 CREATE INDEX metabib_full_rec_02x_tag_subfield_lower_substring
 672     ON metabib.real_full_rec (tag, subfield, LOWER(substring(value, 1, 1024)))
 673     WHERE tag IN ('020', '022', '024');
 674
 675
 676 CREATE TRIGGER metabib_full_rec_fti_trigger
 677         BEFORE UPDATE OR INSERT ON metabib.real_full_rec
 678         FOR EACH ROW EXECUTE PROCEDURE oils_tsearch2('default');
 679
 680 CREATE OR REPLACE VIEW metabib.full_rec AS
 681     SELECT  id,
 682             record,
 683             tag,
 684             ind1,
 685             ind2,
 686             subfield,
 687             SUBSTRING(value,1,1024) AS value,
 688             index_vector
 689       FROM  metabib.real_full_rec;
 690
 691 CREATE OR REPLACE RULE metabib_full_rec_insert_rule
 692     AS ON INSERT TO metabib.full_rec
 693     DO INSTEAD
 694     INSERT INTO metabib.real_full_rec VALUES (
 695         COALESCE(NEW.id, NEXTVAL('metabib.full_rec_id_seq'::REGCLASS)),
 696         NEW.record,
 697         NEW.tag,
 698         NEW.ind1,
 699         NEW.ind2,
 700         NEW.subfield,
 701         NEW.value,
 702         NEW.index_vector
 703     );
 704
 705 CREATE OR REPLACE RULE metabib_full_rec_update_rule
 706     AS ON UPDATE TO metabib.full_rec
 707     DO INSTEAD
 708     UPDATE  metabib.real_full_rec SET
 709         id = NEW.id,
 710         record = NEW.record,
 711         tag = NEW.tag,
 712         ind1 = NEW.ind1,
 713         ind2 = NEW.ind2,
 714         subfield = NEW.subfield,
 715         value = NEW.value,
 716         index_vector = NEW.index_vector
 717       WHERE id = OLD.id;
 718
 719 CREATE OR REPLACE RULE metabib_full_rec_delete_rule
 720     AS ON DELETE TO metabib.full_rec
 721     DO INSTEAD
 722     DELETE FROM metabib.real_full_rec WHERE id = OLD.id;
 723
 724 CREATE TABLE metabib.metarecord_source_map (
 725         id              BIGSERIAL       PRIMARY KEY,
 726         metarecord      BIGINT          NOT NULL,
 727         source          BIGINT          NOT NULL
 728 );
 729 CREATE INDEX metabib_metarecord_source_map_metarecord_idx ON metabib.metarecord_source_map (metarecord);
 730 CREATE INDEX metabib_metarecord_source_map_source_record_idx ON metabib.metarecord_source_map (source);
 731
 732 CREATE TYPE metabib.field_entry_template AS (
 733     field_class         TEXT,
 734     field               INT,
 735     facet_field         BOOL,
 736     display_field       BOOL,
 737     search_field        BOOL,
 738     browse_field        BOOL,
 739     source              BIGINT,
 740     value               TEXT,
 741     authority           BIGINT,
 742     sort_value          TEXT
 743 );
 744
 745 CREATE OR REPLACE FUNCTION biblio.extract_metabib_field_entry (
 746     rid BIGINT,
 747     default_joiner TEXT,
 748     field_types TEXT[],
 749     only_fields INT[]
 750 ) RETURNS SETOF metabib.field_entry_template AS $func$
 751 DECLARE
 752     bib     biblio.record_entry%ROWTYPE;
 753     idx     config.metabib_field%ROWTYPE;
 754     xfrm        config.xml_transform%ROWTYPE;
 755     prev_xfrm   TEXT;
 756     transformed_xml TEXT;
 757     xml_node    TEXT;
 758     xml_node_list   TEXT[];
 759     facet_text  TEXT;
 760     display_text TEXT;
 761     browse_text TEXT;
 762     sort_value  TEXT;
 763     raw_text    TEXT;
 764     curr_text   TEXT;
 765     joiner      TEXT := default_joiner; -- XXX will index defs supply a joiner?
 766     authority_text TEXT;
 767     authority_link BIGINT;
 768     output_row  metabib.field_entry_template%ROWTYPE;
 769     process_idx BOOL;
 770 BEGIN
 771
 772     -- Start out with no field-use bools set
 773     output_row.browse_field = FALSE;
 774     output_row.facet_field = FALSE;
 775     output_row.display_field = FALSE;
 776     output_row.search_field = FALSE;
 777
 778     -- Get the record
 779     SELECT INTO bib * FROM biblio.record_entry WHERE id = rid;
 780
 781     -- Loop over the indexing entries
 782     FOR idx IN SELECT * FROM config.metabib_field WHERE id = ANY (only_fields) ORDER BY format LOOP
 783         CONTINUE WHEN idx.xpath IS NULL OR idx.xpath = ''; -- pure virtual field
 784
 785         process_idx := FALSE;
 786         IF idx.display_field AND 'display' = ANY (field_types) THEN process_idx = TRUE; END IF;
 787         IF idx.browse_field AND 'browse' = ANY (field_types) THEN process_idx = TRUE; END IF;
 788         IF idx.search_field AND 'search' = ANY (field_types) THEN process_idx = TRUE; END IF;
 789         IF idx.facet_field AND 'facet' = ANY (field_types) THEN process_idx = TRUE; END IF;
 790         CONTINUE WHEN process_idx = FALSE; -- disabled for all types
 791
 792         joiner := COALESCE(idx.joiner, default_joiner);
 793
 794         SELECT INTO xfrm * from config.xml_transform WHERE name = idx.format;
 795
 796         -- See if we can skip the XSLT ... it's expensive
 797         IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN
 798             -- Can't skip the transform
 799             IF xfrm.xslt <> '---' THEN
 800                 transformed_xml := oils_xslt_process(bib.marc,xfrm.xslt);
 801             ELSE
 802                 transformed_xml := bib.marc;
 803             END IF;
 804
 805             prev_xfrm := xfrm.name;
 806         END IF;
 807
 808         xml_node_list := oils_xpath( idx.xpath, transformed_xml, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 809
 810         raw_text := NULL;
 811         FOR xml_node IN SELECT x FROM unnest(xml_node_list) AS x LOOP
 812             CONTINUE WHEN xml_node !~ E'^\\s*<';
 813
 814             -- XXX much of this should be moved into oils_xpath_string...
 815             curr_text := ARRAY_TO_STRING(array_remove(array_remove(
 816                 oils_xpath( '//text()', -- get the content of all the nodes within the main selected node
 817                     REGEXP_REPLACE( xml_node, E'\\s+', ' ', 'g' ) -- Translate adjacent whitespace to a single space
 818                 ), ' '), ''),  -- throw away morally empty (bankrupt?) strings
 819                 joiner
 820             );
 821
 822             CONTINUE WHEN curr_text IS NULL OR curr_text = '';
 823
 824             IF raw_text IS NOT NULL THEN
 825                 raw_text := raw_text || joiner;
 826             END IF;
 827
 828             raw_text := COALESCE(raw_text,'') || curr_text;
 829
 830             -- autosuggest/metabib.browse_entry
 831             IF idx.browse_field THEN
 832
 833                 IF idx.browse_xpath IS NOT NULL AND idx.browse_xpath <> '' THEN
 834                     browse_text := oils_xpath_string( idx.browse_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 835                 ELSE
 836                     browse_text := curr_text;
 837                 END IF;
 838
 839                 IF idx.browse_sort_xpath IS NOT NULL AND
 840                     idx.browse_sort_xpath <> '' THEN
 841
 842                     sort_value := oils_xpath_string(
 843                         idx.browse_sort_xpath, xml_node, joiner,
 844                         ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]
 845                     );
 846                 ELSE
 847                     sort_value := browse_text;
 848                 END IF;
 849
 850                 output_row.field_class = idx.field_class;
 851                 output_row.field = idx.id;
 852                 output_row.source = rid;
 853                 output_row.value = BTRIM(REGEXP_REPLACE(browse_text, E'\\s+', ' ', 'g'));
 854                 output_row.sort_value :=
 855                     public.naco_normalize(sort_value);
 856
 857                 output_row.authority := NULL;
 858
 859                 IF idx.authority_xpath IS NOT NULL AND idx.authority_xpath <> '' THEN
 860                     authority_text := oils_xpath_string(
 861                         idx.authority_xpath, xml_node, joiner,
 862                         ARRAY[
 863                             ARRAY[xfrm.prefix, xfrm.namespace_uri],
 864                             ARRAY['xlink','http://www.w3.org/1999/xlink']
 865                         ]
 866                     );
 867
 868                     IF authority_text ~ '^\d+$' THEN
 869                         authority_link := authority_text::BIGINT;
 870                         PERFORM * FROM authority.record_entry WHERE id = authority_link;
 871                         IF FOUND THEN
 872                             output_row.authority := authority_link;
 873                         END IF;
 874                     END IF;
 875
 876                 END IF;
 877
 878                 output_row.browse_field = TRUE;
 879                 -- Returning browse rows with search_field = true for search+browse
 880                 -- configs allows us to retain granularity of being able to search
 881                 -- browse fields with "starts with" type operators (for example, for
 882                 -- titles of songs in music albums)
 883                 IF idx.search_field THEN
 884                     output_row.search_field = TRUE;
 885                 END IF;
 886                 RETURN NEXT output_row;
 887                 output_row.browse_field = FALSE;
 888                 output_row.search_field = FALSE;
 889                 output_row.sort_value := NULL;
 890             END IF;
 891
 892             -- insert raw node text for faceting
 893             IF idx.facet_field THEN
 894
 895                 IF idx.facet_xpath IS NOT NULL AND idx.facet_xpath <> '' THEN
 896                     facet_text := oils_xpath_string( idx.facet_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 897                 ELSE
 898                     facet_text := curr_text;
 899                 END IF;
 900
 901                 output_row.field_class = idx.field_class;
 902                 output_row.field = -1 * idx.id;
 903                 output_row.source = rid;
 904                 output_row.value = BTRIM(REGEXP_REPLACE(facet_text, E'\\s+', ' ', 'g'));
 905
 906                 output_row.facet_field = TRUE;
 907                 RETURN NEXT output_row;
 908                 output_row.facet_field = FALSE;
 909             END IF;
 910
 911             -- insert raw node text for display
 912             IF idx.display_field THEN
 913
 914                 IF idx.display_xpath IS NOT NULL AND idx.display_xpath <> '' THEN
 915                     display_text := oils_xpath_string( idx.display_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 916                 ELSE
 917                     display_text := curr_text;
 918                 END IF;
 919
 920                 output_row.field_class = idx.field_class;
 921                 output_row.field = -1 * idx.id;
 922                 output_row.source = rid;
 923                 output_row.value = BTRIM(REGEXP_REPLACE(display_text, E'\\s+', ' ', 'g'));
 924
 925                 output_row.display_field = TRUE;
 926                 RETURN NEXT output_row;
 927                 output_row.display_field = FALSE;
 928             END IF;
 929
 930         END LOOP;
 931
 932         CONTINUE WHEN raw_text IS NULL OR raw_text = '';
 933
 934         -- insert combined node text for searching
 935         IF idx.search_field THEN
 936             output_row.field_class = idx.field_class;
 937             output_row.field = idx.id;
 938             output_row.source = rid;
 939             output_row.value = BTRIM(REGEXP_REPLACE(raw_text, E'\\s+', ' ', 'g'));
 940
 941             output_row.search_field = TRUE;
 942             RETURN NEXT output_row;
 943             output_row.search_field = FALSE;
 944         END IF;
 945
 946     END LOOP;
 947
 948 END;
 949 $func$ LANGUAGE PLPGSQL;
 950
 951 CREATE OR REPLACE FUNCTION metabib.update_combined_index_vectors(bib_id BIGINT) RETURNS VOID AS $func$
 952 DECLARE
 953     rdata       TSVECTOR;
 954     vclass      TEXT;
 955     vfield      INT;
 956     rfields     INT[];
 957 BEGIN
 958     DELETE FROM metabib.combined_keyword_field_entry WHERE record = bib_id;
 959     INSERT INTO metabib.combined_keyword_field_entry(record, metabib_field, index_vector)
 960         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 961         FROM metabib.keyword_field_entry WHERE source = bib_id GROUP BY field;
 962     INSERT INTO metabib.combined_keyword_field_entry(record, metabib_field, index_vector)
 963         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 964         FROM metabib.keyword_field_entry WHERE source = bib_id;
 965
 966     DELETE FROM metabib.combined_title_field_entry WHERE record = bib_id;
 967     INSERT INTO metabib.combined_title_field_entry(record, metabib_field, index_vector)
 968         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 969         FROM metabib.title_field_entry WHERE source = bib_id GROUP BY field;
 970     INSERT INTO metabib.combined_title_field_entry(record, metabib_field, index_vector)
 971         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 972         FROM metabib.title_field_entry WHERE source = bib_id;
 973
 974     DELETE FROM metabib.combined_author_field_entry WHERE record = bib_id;
 975     INSERT INTO metabib.combined_author_field_entry(record, metabib_field, index_vector)
 976         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 977         FROM metabib.author_field_entry WHERE source = bib_id GROUP BY field;
 978     INSERT INTO metabib.combined_author_field_entry(record, metabib_field, index_vector)
 979         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 980         FROM metabib.author_field_entry WHERE source = bib_id;
 981
 982     DELETE FROM metabib.combined_subject_field_entry WHERE record = bib_id;
 983     INSERT INTO metabib.combined_subject_field_entry(record, metabib_field, index_vector)
 984         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 985         FROM metabib.subject_field_entry WHERE source = bib_id GROUP BY field;
 986     INSERT INTO metabib.combined_subject_field_entry(record, metabib_field, index_vector)
 987         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 988         FROM metabib.subject_field_entry WHERE source = bib_id;
 989
 990     DELETE FROM metabib.combined_series_field_entry WHERE record = bib_id;
 991     INSERT INTO metabib.combined_series_field_entry(record, metabib_field, index_vector)
 992         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 993         FROM metabib.series_field_entry WHERE source = bib_id GROUP BY field;
 994     INSERT INTO metabib.combined_series_field_entry(record, metabib_field, index_vector)
 995         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 996         FROM metabib.series_field_entry WHERE source = bib_id;
 997
 998     DELETE FROM metabib.combined_identifier_field_entry WHERE record = bib_id;
 999     INSERT INTO metabib.combined_identifier_field_entry(record, metabib_field, index_vector)
1000         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
1001         FROM metabib.identifier_field_entry WHERE source = bib_id GROUP BY field;
1002     INSERT INTO metabib.combined_identifier_field_entry(record, metabib_field, index_vector)
1003         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
1004         FROM metabib.identifier_field_entry WHERE source = bib_id;
1005
1006     -- For each virtual def, gather the data from the combined real field
1007     -- entries and append it to the virtual combined entry.
1008     FOR vfield, rfields IN SELECT virtual, ARRAY_AGG(real)  FROM config.metabib_field_virtual_map GROUP BY virtual LOOP
1009         SELECT  field_class INTO vclass
1010           FROM  config.metabib_field
1011           WHERE id = vfield;
1012
1013         SELECT  string_agg(index_vector::TEXT,' ')::tsvector INTO rdata
1014           FROM  metabib.combined_all_field_entry
1015           WHERE record = bib_id
1016                 AND metabib_field = ANY (rfields);
1017
1018         BEGIN -- I cannot wait for INSERT ON CONFLICT ... 9.5, though
1019             EXECUTE $$
1020                 INSERT INTO metabib.combined_$$ || vclass || $$_field_entry
1021                     (record, metabib_field, index_vector) VALUES ($1, $2, $3)
1022             $$ USING bib_id, vfield, rdata;
1023         EXCEPTION WHEN unique_violation THEN
1024             EXECUTE $$
1025                 UPDATE  metabib.combined_$$ || vclass || $$_field_entry
1026                   SET   index_vector = index_vector || $3
1027                   WHERE record = $1
1028                         AND metabib_field = $2
1029             $$ USING bib_id, vfield, rdata;
1030         WHEN OTHERS THEN
1031             -- ignore and move on
1032         END;
1033     END LOOP;
1034 END;
1035 $func$ LANGUAGE PLPGSQL;
1036
1037 CREATE OR REPLACE FUNCTION metabib.reingest_metabib_field_entries(
1038     bib_id BIGINT,
1039     skip_facet BOOL DEFAULT FALSE,
1040     skip_display BOOL DEFAULT FALSE,
1041     skip_browse BOOL DEFAULT FALSE,
1042     skip_search BOOL DEFAULT FALSE,
1043     only_fields INT[] DEFAULT '{}'::INT[]
1044 ) RETURNS VOID AS $func$
1045 DECLARE
1046     fclass          RECORD;
1047     ind_data        metabib.field_entry_template%ROWTYPE;
1048     mbe_row         metabib.browse_entry%ROWTYPE;
1049     mbe_id          BIGINT;
1050     b_skip_facet    BOOL;
1051     b_skip_display    BOOL;
1052     b_skip_browse   BOOL;
1053     b_skip_search   BOOL;
1054     value_prepped   TEXT;
1055     field_list      INT[] := only_fields;
1056     field_types     TEXT[] := '{}'::TEXT[];
1057 BEGIN
1058
1059     IF field_list = '{}'::INT[] THEN
1060         SELECT ARRAY_AGG(id) INTO field_list FROM config.metabib_field;
1061     END IF;
1062
1063     SELECT COALESCE(NULLIF(skip_facet, FALSE), EXISTS (SELECT enabled FROM config.internal_flag WHERE name =  'ingest.skip_facet_indexing' AND enabled)) INTO b_skip_facet;
1064     SELECT COALESCE(NULLIF(skip_display, FALSE), EXISTS (SELECT enabled FROM config.internal_flag WHERE name =  'ingest.skip_display_indexing' AND enabled)) INTO b_skip_display;
1065     SELECT COALESCE(NULLIF(skip_browse, FALSE), EXISTS (SELECT enabled FROM config.internal_flag WHERE name =  'ingest.skip_browse_indexing' AND enabled)) INTO b_skip_browse;
1066     SELECT COALESCE(NULLIF(skip_search, FALSE), EXISTS (SELECT enabled FROM config.internal_flag WHERE name =  'ingest.skip_search_indexing' AND enabled)) INTO b_skip_search;
1067
1068     IF NOT b_skip_facet THEN field_types := field_types || '{facet}'; END IF;
1069     IF NOT b_skip_display THEN field_types := field_types || '{display}'; END IF;
1070     IF NOT b_skip_browse THEN field_types := field_types || '{browse}'; END IF;
1071     IF NOT b_skip_search THEN field_types := field_types || '{search}'; END IF;
1072
1073     PERFORM * FROM config.internal_flag WHERE name = 'ingest.assume_inserts_only' AND enabled;
1074     IF NOT FOUND THEN
1075         IF NOT b_skip_search THEN
1076             FOR fclass IN SELECT * FROM config.metabib_class LOOP
1077                 -- RAISE NOTICE 'Emptying out %', fclass.name;
1078                 EXECUTE $$DELETE FROM metabib.$$ || fclass.name || $$_field_entry WHERE source = $$ || bib_id;
1079             END LOOP;
1080         END IF;
1081         IF NOT b_skip_facet THEN
1082             DELETE FROM metabib.facet_entry WHERE source = bib_id;
1083         END IF;
1084         IF NOT b_skip_display THEN
1085             DELETE FROM metabib.display_entry WHERE source = bib_id;
1086         END IF;
1087         IF NOT b_skip_browse THEN
1088             DELETE FROM metabib.browse_entry_def_map WHERE source = bib_id;
1089         END IF;
1090     END IF;
1091
1092     FOR ind_data IN SELECT * FROM biblio.extract_metabib_field_entry( bib_id, ' ', field_types, field_list ) LOOP
1093
1094         -- don't store what has been normalized away
1095         CONTINUE WHEN ind_data.value IS NULL;
1096
1097         IF ind_data.field < 0 THEN
1098             ind_data.field = -1 * ind_data.field;
1099         END IF;
1100
1101         IF ind_data.facet_field AND NOT b_skip_facet THEN
1102             INSERT INTO metabib.facet_entry (field, source, value)
1103                 VALUES (ind_data.field, ind_data.source, ind_data.value);
1104         END IF;
1105
1106         IF ind_data.display_field AND NOT b_skip_display THEN
1107             INSERT INTO metabib.display_entry (field, source, value)
1108                 VALUES (ind_data.field, ind_data.source, ind_data.value);
1109         END IF;
1110
1111
1112         IF ind_data.browse_field AND NOT b_skip_browse THEN
1113             -- A caveat about this SELECT: this should take care of replacing
1114             -- old mbe rows when data changes, but not if normalization (by
1115             -- which I mean specifically the output of
1116             -- evergreen.oils_tsearch2()) changes.  It may or may not be
1117             -- expensive to add a comparison of index_vector to index_vector
1118             -- to the WHERE clause below.
1119
1120             CONTINUE WHEN ind_data.sort_value IS NULL;
1121
1122             value_prepped := metabib.browse_normalize(ind_data.value, ind_data.field);
1123             SELECT INTO mbe_row * FROM metabib.browse_entry
1124                 WHERE value = value_prepped AND sort_value = ind_data.sort_value;
1125
1126             IF FOUND THEN
1127                 mbe_id := mbe_row.id;
1128             ELSE
1129                 INSERT INTO metabib.browse_entry
1130                     ( value, sort_value ) VALUES
1131                     ( value_prepped, ind_data.sort_value );
1132
1133                 mbe_id := CURRVAL('metabib.browse_entry_id_seq'::REGCLASS);
1134             END IF;
1135
1136             INSERT INTO metabib.browse_entry_def_map (entry, def, source, authority)
1137                 VALUES (mbe_id, ind_data.field, ind_data.source, ind_data.authority);
1138         END IF;
1139
1140         IF ind_data.search_field AND NOT b_skip_search THEN
1141             -- Avoid inserting duplicate rows
1142             EXECUTE 'SELECT 1 FROM metabib.' || ind_data.field_class ||
1143                 '_field_entry WHERE field = $1 AND source = $2 AND value = $3'
1144                 INTO mbe_id USING ind_data.field, ind_data.source, ind_data.value;
1145                 -- RAISE NOTICE 'Search for an already matching row returned %', mbe_id;
1146             IF mbe_id IS NULL THEN
1147                 EXECUTE $$
1148                 INSERT INTO metabib.$$ || ind_data.field_class || $$_field_entry (field, source, value)
1149                     VALUES ($$ ||
1150                         quote_literal(ind_data.field) || $$, $$ ||
1151                         quote_literal(ind_data.source) || $$, $$ ||
1152                         quote_literal(ind_data.value) ||
1153                     $$);$$;
1154             END IF;
1155         END IF;
1156
1157     END LOOP;
1158
1159     IF NOT b_skip_search THEN
1160         PERFORM metabib.update_combined_index_vectors(bib_id);
1161     END IF;
1162
1163     RETURN;
1164 END;
1165 $func$ LANGUAGE PLPGSQL;
1166
1167 CREATE OR REPLACE FUNCTION authority.flatten_marc ( rid BIGINT ) RETURNS SETOF authority.full_rec AS $func$
1168 DECLARE
1169         auth    authority.record_entry%ROWTYPE;
1170         output  authority.full_rec%ROWTYPE;
1171         field   RECORD;
1172 BEGIN
1173         SELECT INTO auth * FROM authority.record_entry WHERE id = rid;
1174
1175         FOR field IN SELECT * FROM vandelay.flatten_marc( auth.marc ) LOOP
1176                 output.record := rid;
1177                 output.ind1 := field.ind1;
1178                 output.ind2 := field.ind2;
1179                 output.tag := field.tag;
1180                 output.subfield := field.subfield;
1181                 output.value := field.value;
1182
1183                 RETURN NEXT output;
1184         END LOOP;
1185 END;
1186 $func$ LANGUAGE PLPGSQL;
1187
1188 CREATE OR REPLACE FUNCTION biblio.flatten_marc ( rid BIGINT ) RETURNS SETOF metabib.full_rec AS $func$
1189 DECLARE
1190         bib     biblio.record_entry%ROWTYPE;
1191         output  metabib.full_rec%ROWTYPE;
1192         field   RECORD;
1193 BEGIN
1194         SELECT INTO bib * FROM biblio.record_entry WHERE id = rid;
1195
1196         FOR field IN SELECT * FROM vandelay.flatten_marc( bib.marc ) LOOP
1197                 output.record := rid;
1198                 output.ind1 := field.ind1;
1199                 output.ind2 := field.ind2;
1200                 output.tag := field.tag;
1201                 output.subfield := field.subfield;
1202                 output.value := field.value;
1203
1204                 RETURN NEXT output;
1205         END LOOP;
1206 END;
1207 $func$ LANGUAGE PLPGSQL;
1208
1209 CREATE OR REPLACE FUNCTION biblio.marc21_extract_fixed_field_list( rid BIGINT, ff TEXT ) RETURNS TEXT[] AS $func$
1210     SELECT * FROM vandelay.marc21_extract_fixed_field_list( (SELECT marc FROM biblio.record_entry WHERE id = $1), $2, TRUE );
1211 $func$ LANGUAGE SQL;
1212
1213 CREATE OR REPLACE FUNCTION biblio.marc21_extract_fixed_field( rid BIGINT, ff TEXT ) RETURNS TEXT AS $func$
1214     SELECT * FROM vandelay.marc21_extract_fixed_field( (SELECT marc FROM biblio.record_entry WHERE id = $1), $2, TRUE );
1215 $func$ LANGUAGE SQL;
1216
1217 CREATE OR REPLACE FUNCTION biblio.marc21_extract_all_fixed_fields( rid BIGINT ) RETURNS SETOF biblio.record_ff_map AS $func$
1218     SELECT $1 AS record, ff_name, ff_value FROM vandelay.marc21_extract_all_fixed_fields( (SELECT marc FROM biblio.record_entry WHERE id = $1), TRUE );
1219 $func$ LANGUAGE SQL;
1220
1221 CREATE OR REPLACE FUNCTION biblio.marc21_physical_characteristics( rid BIGINT ) RETURNS SETOF biblio.marc21_physical_characteristics AS $func$
1222     SELECT id, $1 AS record, ptype, subfield, value FROM vandelay.marc21_physical_characteristics( (SELECT marc FROM biblio.record_entry WHERE id = $1) );
1223 $func$ LANGUAGE SQL;
1224
1225 CREATE OR REPLACE FUNCTION biblio.extract_quality ( marc TEXT, best_lang TEXT, best_type TEXT ) RETURNS INT AS $func$
1226 DECLARE
1227     qual        INT;
1228     ldr         TEXT;
1229     tval        TEXT;
1230     tval_rec    RECORD;
1231     bval        TEXT;
1232     bval_rec    RECORD;
1233     type_map    RECORD;
1234     ff_pos      RECORD;
1235     ff_tag_data TEXT;
1236 BEGIN
1237
1238     IF marc IS NULL OR marc = '' THEN
1239         RETURN NULL;
1240     END IF;
1241
1242     -- First, the count of tags
1243     qual := ARRAY_UPPER(oils_xpath('*[local-name()="datafield"]', marc), 1);
1244
1245     -- now go through a bunch of pain to get the record type
1246     IF best_type IS NOT NULL THEN
1247         ldr := (oils_xpath('//*[local-name()="leader"]/text()', marc))[1];
1248
1249         IF ldr IS NOT NULL THEN
1250             SELECT * INTO tval_rec FROM config.marc21_ff_pos_map WHERE fixed_field = 'Type' LIMIT 1; -- They're all the same
1251             SELECT * INTO bval_rec FROM config.marc21_ff_pos_map WHERE fixed_field = 'BLvl' LIMIT 1; -- They're all the same
1252
1253
1254             tval := SUBSTRING( ldr, tval_rec.start_pos + 1, tval_rec.length );
1255             bval := SUBSTRING( ldr, bval_rec.start_pos + 1, bval_rec.length );
1256
1257             -- RAISE NOTICE 'type %, blvl %, ldr %', tval, bval, ldr;
1258
1259             SELECT * INTO type_map FROM config.marc21_rec_type_map WHERE type_val LIKE '%' || tval || '%' AND blvl_val LIKE '%' || bval || '%';
1260
1261             IF type_map.code IS NOT NULL THEN
1262                 IF best_type = type_map.code THEN
1263                     qual := qual + qual / 2;
1264                 END IF;
1265
1266                 FOR ff_pos IN SELECT * FROM config.marc21_ff_pos_map WHERE fixed_field = 'Lang' AND rec_type = type_map.code ORDER BY tag DESC LOOP
1267                     ff_tag_data := SUBSTRING((oils_xpath('//*[@tag="' || ff_pos.tag || '"]/text()',marc))[1], ff_pos.start_pos + 1, ff_pos.length);
1268                     IF ff_tag_data = best_lang THEN
1269                             qual := qual + 100;
1270                     END IF;
1271                 END LOOP;
1272             END IF;
1273         END IF;
1274     END IF;
1275
1276     -- Now look for some quality metrics
1277     -- DCL record?
1278     IF ARRAY_UPPER(oils_xpath('//*[@tag="040"]/*[@code="a" and contains(.,"DLC")]', marc), 1) = 1 THEN
1279         qual := qual + 10;
1280     END IF;
1281
1282     -- From OCLC?
1283     IF (oils_xpath('//*[@tag="003"]/text()', marc))[1] ~* E'oclo?c' THEN
1284         qual := qual + 10;
1285     END IF;
1286
1287     RETURN qual;
1288
1289 END;
1290 $func$ LANGUAGE PLPGSQL;
1291
1292 CREATE OR REPLACE FUNCTION biblio.extract_fingerprint ( marc text ) RETURNS TEXT AS $func$
1293 DECLARE
1294         idx             config.biblio_fingerprint%ROWTYPE;
1295         xfrm            config.xml_transform%ROWTYPE;
1296         prev_xfrm       TEXT;
1297         transformed_xml TEXT;
1298         xml_node        TEXT;
1299         xml_node_list   TEXT[];
1300         raw_text        TEXT;
1301     output_text TEXT := '';
1302 BEGIN
1303
1304     IF marc IS NULL OR marc = '' THEN
1305         RETURN NULL;
1306     END IF;
1307
1308         -- Loop over the indexing entries
1309         FOR idx IN SELECT * FROM config.biblio_fingerprint ORDER BY format, id LOOP
1310
1311                 SELECT INTO xfrm * from config.xml_transform WHERE name = idx.format;
1312
1313                 -- See if we can skip the XSLT ... it's expensive
1314                 IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN
1315                         -- Can't skip the transform
1316                         IF xfrm.xslt <> '---' THEN
1317                                 transformed_xml := oils_xslt_process(marc,xfrm.xslt);
1318                         ELSE
1319                                 transformed_xml := marc;
1320                         END IF;
1321
1322                         prev_xfrm := xfrm.name;
1323                 END IF;
1324
1325                 raw_text := COALESCE(
1326             naco_normalize(
1327                 ARRAY_TO_STRING(
1328                     oils_xpath(
1329                         '//text()',
1330                         (oils_xpath(
1331                             idx.xpath,
1332                             transformed_xml,
1333                             ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]
1334                         ))[1]
1335                     ),
1336                     ''
1337                 )
1338             ),
1339             ''
1340         );
1341
1342         raw_text := REGEXP_REPLACE(raw_text, E'\\[.+?\\]', E'');
1343         raw_text := REGEXP_REPLACE(raw_text, E'\\mthe\\M|\\man?d?d\\M', E'', 'g'); -- arg! the pain!
1344
1345         IF idx.first_word IS TRUE THEN
1346             raw_text := REGEXP_REPLACE(raw_text, E'^(\\w+).*?$', E'\\1');
1347         END IF;
1348
1349                 output_text := output_text || idx.name || ':' ||
1350                                            REGEXP_REPLACE(raw_text, E'\\s+', '', 'g') || ' ';
1351
1352         END LOOP;
1353
1354     RETURN BTRIM(output_text);
1355
1356 END;
1357 $func$ LANGUAGE PLPGSQL;
1358
1359 -- BEFORE UPDATE OR INSERT trigger for biblio.record_entry
1360 CREATE OR REPLACE FUNCTION biblio.fingerprint_trigger () RETURNS TRIGGER AS $func$
1361 BEGIN
1362
1363     -- For TG_ARGV, first param is language (like 'eng'), second is record type (like 'BKS')
1364
1365     IF NEW.deleted IS TRUE THEN -- we don't much care, then, do we?
1366         RETURN NEW;
1367     END IF;
1368
1369     NEW.fingerprint := biblio.extract_fingerprint(NEW.marc);
1370     NEW.quality := biblio.extract_quality(NEW.marc, TG_ARGV[0], TG_ARGV[1]);
1371
1372     RETURN NEW;
1373
1374 END;
1375 $func$ LANGUAGE PLPGSQL;
1376
1377 CREATE OR REPLACE FUNCTION metabib.reingest_metabib_full_rec( bib_id BIGINT ) RETURNS VOID AS $func$
1378 BEGIN
1379     PERFORM * FROM config.internal_flag WHERE name = 'ingest.assume_inserts_only' AND enabled;
1380     IF NOT FOUND THEN
1381         DELETE FROM metabib.real_full_rec WHERE record = bib_id;
1382     END IF;
1383     INSERT INTO metabib.real_full_rec (record, tag, ind1, ind2, subfield, value)
1384         SELECT record, tag, ind1, ind2, subfield, value FROM biblio.flatten_marc( bib_id );
1385
1386     RETURN;
1387 END;
1388 $func$ LANGUAGE PLPGSQL;
1389
1390 CREATE OR REPLACE FUNCTION biblio.extract_located_uris( bib_id BIGINT, marcxml TEXT, editor_id INT ) RETURNS VOID AS $func$
1391 DECLARE
1392     uris            TEXT[];
1393     uri_xml         TEXT;
1394     uri_label       TEXT;
1395     uri_href        TEXT;
1396     uri_use         TEXT;
1397     uri_owner_list  TEXT[];
1398     uri_owner       TEXT;
1399     uri_owner_id    INT;
1400     uri_id          INT;
1401     uri_cn_id       INT;
1402     uri_map_id      INT;
1403     current_uri     INT;
1404     uri_map_count   INT;
1405     current_map_owner_list  INT[];
1406     orphaned_uri_list       INT[];
1407 BEGIN
1408
1409     uris := oils_xpath('//*[@tag="856" and (@ind1="4" or @ind1="1") and (@ind2="0" or @ind2="1")]',marcxml);
1410     IF ARRAY_UPPER(uris,1) > 0 THEN
1411         FOR i IN 1 .. ARRAY_UPPER(uris, 1) LOOP
1412             -- First we pull info out of the 856
1413             uri_xml     := uris[i];
1414
1415             uri_href    := (oils_xpath('//*[@code="u"]/text()',uri_xml))[1];
1416             uri_label   := (oils_xpath('//*[@code="y"]/text()|//*[@code="3"]/text()',uri_xml))[1];
1417             uri_use     := (oils_xpath('//*[@code="z"]/text()|//*[@code="2"]/text()|//*[@code="n"]/text()',uri_xml))[1];
1418
1419             IF uri_label IS NULL THEN
1420                 uri_label := uri_href;
1421             END IF;
1422             CONTINUE WHEN uri_href IS NULL;
1423
1424             -- Get the distinct list of libraries wanting to use
1425             SELECT  ARRAY_AGG(
1426                         DISTINCT REGEXP_REPLACE(
1427                             x,
1428                             $re$^.*?\((\w+)\).*$$re$,
1429                             E'\\1'
1430                         )
1431                     ) INTO uri_owner_list
1432               FROM  UNNEST(
1433                         oils_xpath(
1434                             '//*[@code="9"]/text()|//*[@code="w"]/text()|//*[@code="n"]/text()',
1435                             uri_xml
1436                         )
1437                     )x;
1438
1439             IF ARRAY_UPPER(uri_owner_list,1) > 0 THEN
1440
1441                 -- look for a matching uri
1442                 IF uri_use IS NULL THEN
1443                     SELECT id INTO uri_id
1444                         FROM asset.uri
1445                         WHERE label = uri_label AND href = uri_href AND use_restriction IS NULL AND active
1446                         ORDER BY id LIMIT 1;
1447                     IF NOT FOUND THEN -- create one
1448                         INSERT INTO asset.uri (label, href, use_restriction) VALUES (uri_label, uri_href, uri_use);
1449                         SELECT id INTO uri_id
1450                             FROM asset.uri
1451                             WHERE label = uri_label AND href = uri_href AND use_restriction IS NULL AND active;
1452                     END IF;
1453                 ELSE
1454                     SELECT id INTO uri_id
1455                         FROM asset.uri
1456                         WHERE label = uri_label AND href = uri_href AND use_restriction = uri_use AND active
1457                         ORDER BY id LIMIT 1;
1458                     IF NOT FOUND THEN -- create one
1459                         INSERT INTO asset.uri (label, href, use_restriction) VALUES (uri_label, uri_href, uri_use);
1460                         SELECT id INTO uri_id
1461                             FROM asset.uri
1462                             WHERE label = uri_label AND href = uri_href AND use_restriction = uri_use AND active;
1463                     END IF;
1464                 END IF;
1465
1466                 FOR j IN 1 .. ARRAY_UPPER(uri_owner_list, 1) LOOP
1467                     uri_owner := uri_owner_list[j];
1468
1469                     SELECT id INTO uri_owner_id FROM actor.org_unit WHERE shortname = BTRIM(REPLACE(uri_owner,chr(160),''));
1470                     CONTINUE WHEN NOT FOUND;
1471
1472                     -- we need a call number to link through
1473                     SELECT id INTO uri_cn_id FROM asset.call_number WHERE owning_lib = uri_owner_id AND record = bib_id AND label = '##URI##' AND NOT deleted;
1474                     IF NOT FOUND THEN
1475                         INSERT INTO asset.call_number (owning_lib, record, create_date, edit_date, creator, editor, label)
1476                             VALUES (uri_owner_id, bib_id, 'now', 'now', editor_id, editor_id, '##URI##');
1477                         SELECT id INTO uri_cn_id FROM asset.call_number WHERE owning_lib = uri_owner_id AND record = bib_id AND label = '##URI##' AND NOT deleted;
1478                     END IF;
1479
1480                     -- now, link them if they're not already
1481                     SELECT id INTO uri_map_id FROM asset.uri_call_number_map WHERE call_number = uri_cn_id AND uri = uri_id;
1482                     IF NOT FOUND THEN
1483                         INSERT INTO asset.uri_call_number_map (call_number, uri) VALUES (uri_cn_id, uri_id);
1484                     END IF;
1485
1486                     current_map_owner_list := current_map_owner_list || uri_cn_id
1487
1488                 END LOOP;
1489
1490             END IF;
1491
1492         END LOOP;
1493     END IF;
1494
1495     -- Clear any orphaned URIs, URI mappings and call
1496     -- numbers for this bib that weren't mapped above.
1497     FOR uri_cn_id IN
1498         SELECT  id
1499           FROM  asset.call_number
1500           WHERE record = bib_id
1501                 AND label = '##URI##'
1502                 AND NOT deleted
1503                 AND NOT (id = ANY (current_map_owner_list))
1504     LOOP
1505         -- Check for URIs to-be-orphaned URIs
1506         FOR current_uri IN
1507             SELECT  uri
1508               FROM  asset.uri_call_number_map
1509               WHERE call_number = uri_cn_id
1510         LOOP
1511             SELECT COUNT(*) INTO uri_map_count FROM asset.uri_call_number_map WHERE uri = current_uri;
1512             IF uri_map_count = 1 THEN -- only one means it's the last
1513                 orphaned_uri_list := orphaned_uri_list || current_uri;
1514             END IF;
1515         END LOOP;
1516         -- Remove links
1517         DELETE FROM asset.uri_call_number_map WHERE call_number = uri_cn_id;
1518         DELETE FROM asset.call_number WHERE id = uri_cn_id;
1519         DELETE FROM asset.uri WHERE id = ANY (orphaned_uri_list);
1520     END LOOP;
1521
1522     RETURN;
1523 END;
1524 $func$ LANGUAGE PLPGSQL;
1525
1526 CREATE OR REPLACE FUNCTION metabib.remap_metarecord_for_bib(
1527     bib_id bigint,
1528     fp text,
1529     bib_is_deleted boolean DEFAULT false,
1530     retain_deleted boolean DEFAULT false
1531 ) RETURNS bigint AS $function$
1532 DECLARE
1533     new_mapping     BOOL := TRUE;
1534     source_count    INT;
1535     old_mr          BIGINT;
1536     tmp_mr          metabib.metarecord%ROWTYPE;
1537     deleted_mrs     BIGINT[];
1538 BEGIN
1539
1540     -- We need to make sure we're not a deleted master record of an MR
1541     IF bib_is_deleted THEN
1542         IF NOT retain_deleted THEN -- Go away for any MR that we're master of, unless retained
1543             DELETE FROM metabib.metarecord_source_map WHERE source = bib_id;
1544         END IF;
1545
1546         FOR old_mr IN SELECT id FROM metabib.metarecord WHERE master_record = bib_id LOOP
1547
1548             -- Now, are there any more sources on this MR?
1549             SELECT COUNT(*) INTO source_count FROM metabib.metarecord_source_map WHERE metarecord = old_mr;
1550
1551             IF source_count = 0 AND NOT retain_deleted THEN -- No other records
1552                 deleted_mrs := ARRAY_APPEND(deleted_mrs, old_mr); -- Just in case...
1553                 DELETE FROM metabib.metarecord WHERE id = old_mr;
1554
1555             ELSE -- indeed there are. Update it with a null cache and recalcualated master record
1556                 UPDATE  metabib.metarecord
1557                   SET   mods = NULL,
1558                         master_record = ( SELECT id FROM biblio.record_entry WHERE fingerprint = fp AND NOT deleted ORDER BY quality DESC LIMIT 1)
1559                   WHERE id = old_mr;
1560             END IF;
1561         END LOOP;
1562
1563     ELSE -- insert or update
1564
1565         FOR tmp_mr IN SELECT m.* FROM metabib.metarecord m JOIN metabib.metarecord_source_map s ON (s.metarecord = m.id) WHERE s.source = bib_id LOOP
1566
1567             -- Find the first fingerprint-matching
1568             IF old_mr IS NULL AND fp = tmp_mr.fingerprint THEN
1569                 old_mr := tmp_mr.id;
1570                 new_mapping := FALSE;
1571
1572             ELSE -- Our fingerprint changed ... maybe remove the old MR
1573                 DELETE FROM metabib.metarecord_source_map WHERE metarecord = tmp_mr.id AND source = bib_id; -- remove the old source mapping
1574                 SELECT COUNT(*) INTO source_count FROM metabib.metarecord_source_map WHERE metarecord = tmp_mr.id;
1575                 IF source_count = 0 THEN -- No other records
1576                     deleted_mrs := ARRAY_APPEND(deleted_mrs, tmp_mr.id);
1577                     DELETE FROM metabib.metarecord WHERE id = tmp_mr.id;
1578                 END IF;
1579             END IF;
1580
1581         END LOOP;
1582
1583         -- we found no suitable, preexisting MR based on old source maps
1584         IF old_mr IS NULL THEN
1585             SELECT id INTO old_mr FROM metabib.metarecord WHERE fingerprint = fp; -- is there one for our current fingerprint?
1586
1587             IF old_mr IS NULL THEN -- nope, create one and grab its id
1588                 INSERT INTO metabib.metarecord ( fingerprint, master_record ) VALUES ( fp, bib_id );
1589                 SELECT id INTO old_mr FROM metabib.metarecord WHERE fingerprint = fp;
1590
1591             ELSE -- indeed there is. update it with a null cache and recalcualated master record
1592                 UPDATE  metabib.metarecord
1593                   SET   mods = NULL,
1594                         master_record = ( SELECT id FROM biblio.record_entry WHERE fingerprint = fp AND NOT deleted ORDER BY quality DESC LIMIT 1)
1595                   WHERE id = old_mr;
1596             END IF;
1597
1598         ELSE -- there was one we already attached to, update its mods cache and master_record
1599             UPDATE  metabib.metarecord
1600               SET   mods = NULL,
1601                     master_record = ( SELECT id FROM biblio.record_entry WHERE fingerprint = fp AND NOT deleted ORDER BY quality DESC LIMIT 1)
1602               WHERE id = old_mr;
1603         END IF;
1604
1605         IF new_mapping THEN
1606             INSERT INTO metabib.metarecord_source_map (metarecord, source) VALUES (old_mr, bib_id); -- new source mapping
1607         END IF;
1608
1609     END IF;
1610
1611     IF ARRAY_UPPER(deleted_mrs,1) > 0 THEN
1612         UPDATE action.hold_request SET target = old_mr WHERE target IN ( SELECT unnest(deleted_mrs) ) AND hold_type = 'M'; -- if we had to delete any MRs above, make sure their holds are moved
1613     END IF;
1614
1615     RETURN old_mr;
1616
1617 END;
1618 $function$ LANGUAGE plpgsql;
1619
1620 CREATE OR REPLACE FUNCTION biblio.map_authority_linking (bibid BIGINT, marc TEXT) RETURNS BIGINT AS $func$
1621     DELETE FROM authority.bib_linking WHERE bib = $1;
1622     INSERT INTO authority.bib_linking (bib, authority)
1623         SELECT  y.bib,
1624                 y.authority
1625           FROM (    SELECT  DISTINCT $1 AS bib,
1626                             BTRIM(remove_paren_substring(txt))::BIGINT AS authority
1627                       FROM  unnest(oils_xpath('//*[@code="0"]/text()',$2)) x(txt)
1628                       WHERE BTRIM(remove_paren_substring(txt)) ~ $re$^\d+$$re$
1629                 ) y JOIN authority.record_entry r ON r.id = y.authority;
1630     SELECT $1;
1631 $func$ LANGUAGE SQL;
1632
1633 CREATE OR REPLACE FUNCTION metabib.reingest_record_attributes (rid BIGINT, pattr_list TEXT[] DEFAULT NULL, prmarc TEXT DEFAULT NULL, rdeleted BOOL DEFAULT TRUE) RETURNS VOID AS $func$
1634 DECLARE
1635     transformed_xml TEXT;
1636     rmarc           TEXT := prmarc;
1637     tmp_val         TEXT;
1638     prev_xfrm       TEXT;
1639     normalizer      RECORD;
1640     xfrm            config.xml_transform%ROWTYPE;
1641     attr_vector     INT[] := '{}'::INT[];
1642     attr_vector_tmp INT[];
1643     attr_list       TEXT[] := pattr_list;
1644     attr_value      TEXT[];
1645     norm_attr_value TEXT[];
1646     tmp_xml         TEXT;
1647     tmp_array       TEXT[];
1648     attr_def        config.record_attr_definition%ROWTYPE;
1649     ccvm_row        config.coded_value_map%ROWTYPE;
1650     jump_past       BOOL;
1651 BEGIN
1652
1653     IF attr_list IS NULL OR rdeleted THEN -- need to do the full dance on INSERT or undelete
1654         SELECT ARRAY_AGG(name) INTO attr_list FROM config.record_attr_definition
1655         WHERE (
1656             tag IS NOT NULL OR
1657             fixed_field IS NOT NULL OR
1658             xpath IS NOT NULL OR
1659             phys_char_sf IS NOT NULL OR
1660             composite
1661         ) AND (
1662             filter OR sorter
1663         );
1664     END IF;
1665
1666     IF rmarc IS NULL THEN
1667         SELECT marc INTO rmarc FROM biblio.record_entry WHERE id = rid;
1668     END IF;
1669
1670     FOR attr_def IN SELECT * FROM config.record_attr_definition WHERE NOT composite AND name = ANY( attr_list ) ORDER BY format LOOP
1671
1672         jump_past := FALSE; -- This gets set when we are non-multi and have found something
1673         attr_value := '{}'::TEXT[];
1674         norm_attr_value := '{}'::TEXT[];
1675         attr_vector_tmp := '{}'::INT[];
1676
1677         SELECT * INTO ccvm_row FROM config.coded_value_map c WHERE c.ctype = attr_def.name LIMIT 1;
1678
1679         IF attr_def.tag IS NOT NULL THEN -- tag (and optional subfield list) selection
1680             SELECT  ARRAY_AGG(value) INTO attr_value
1681               FROM  (SELECT * FROM metabib.full_rec ORDER BY tag, subfield) AS x
1682               WHERE record = rid
1683                     AND tag LIKE attr_def.tag
1684                     AND CASE
1685                         WHEN attr_def.sf_list IS NOT NULL
1686                             THEN POSITION(subfield IN attr_def.sf_list) > 0
1687                         ELSE TRUE
1688                     END
1689               GROUP BY tag
1690               ORDER BY tag;
1691
1692             IF NOT attr_def.multi THEN
1693                 attr_value := ARRAY[ARRAY_TO_STRING(attr_value, COALESCE(attr_def.joiner,' '))];
1694                 jump_past := TRUE;
1695             END IF;
1696         END IF;
1697
1698         IF NOT jump_past AND attr_def.fixed_field IS NOT NULL THEN -- a named fixed field, see config.marc21_ff_pos_map.fixed_field
1699             attr_value := attr_value || vandelay.marc21_extract_fixed_field_list(rmarc, attr_def.fixed_field);
1700
1701             IF NOT attr_def.multi THEN
1702                 attr_value := ARRAY[attr_value[1]];
1703                 jump_past := TRUE;
1704             END IF;
1705         END IF;
1706
1707         IF NOT jump_past AND attr_def.xpath IS NOT NULL THEN -- and xpath expression
1708
1709             SELECT INTO xfrm * FROM config.xml_transform WHERE name = attr_def.format;
1710
1711             -- See if we can skip the XSLT ... it's expensive
1712             IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN
1713                 -- Can't skip the transform
1714                 IF xfrm.xslt <> '---' THEN
1715                     transformed_xml := oils_xslt_process(rmarc,xfrm.xslt);
1716                 ELSE
1717                     transformed_xml := rmarc;
1718                 END IF;
1719
1720                 prev_xfrm := xfrm.name;
1721             END IF;
1722
1723             IF xfrm.name IS NULL THEN
1724                 -- just grab the marcxml (empty) transform
1725                 SELECT INTO xfrm * FROM config.xml_transform WHERE xslt = '---' LIMIT 1;
1726                 prev_xfrm := xfrm.name;
1727             END IF;
1728
1729             FOR tmp_xml IN SELECT UNNEST(oils_xpath(attr_def.xpath, transformed_xml, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]])) LOOP
1730                 tmp_val := oils_xpath_string(
1731                                 '//*',
1732                                 tmp_xml,
1733                                 COALESCE(attr_def.joiner,' '),
1734                                 ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]
1735                             );
1736                 IF tmp_val IS NOT NULL AND BTRIM(tmp_val) <> '' THEN
1737                     attr_value := attr_value || tmp_val;
1738                     EXIT WHEN NOT attr_def.multi;
1739                 END IF;
1740             END LOOP;
1741         END IF;
1742
1743         IF NOT jump_past AND attr_def.phys_char_sf IS NOT NULL THEN -- a named Physical Characteristic, see config.marc21_physical_characteristic_*_map
1744             SELECT  ARRAY_AGG(m.value) INTO tmp_array
1745               FROM  vandelay.marc21_physical_characteristics(rmarc) v
1746                     LEFT JOIN config.marc21_physical_characteristic_value_map m ON (m.id = v.value)
1747               WHERE v.subfield = attr_def.phys_char_sf AND (m.value IS NOT NULL AND BTRIM(m.value) <> '')
1748                     AND ( ccvm_row.id IS NULL OR ( ccvm_row.id IS NOT NULL AND v.id IS NOT NULL) );
1749
1750             attr_value := attr_value || tmp_array;
1751
1752             IF NOT attr_def.multi THEN
1753                 attr_value := ARRAY[attr_value[1]];
1754             END IF;
1755
1756         END IF;
1757
1758                 -- apply index normalizers to attr_value
1759         FOR tmp_val IN SELECT value FROM UNNEST(attr_value) x(value) LOOP
1760             FOR normalizer IN
1761                 SELECT  n.func AS func,
1762                         n.param_count AS param_count,
1763                         m.params AS params
1764                   FROM  config.index_normalizer n
1765                         JOIN config.record_attr_index_norm_map m ON (m.norm = n.id)
1766                   WHERE attr = attr_def.name
1767                   ORDER BY m.pos LOOP
1768                     EXECUTE 'SELECT ' || normalizer.func || '(' ||
1769                     COALESCE( quote_literal( tmp_val ), 'NULL' ) ||
1770                         CASE
1771                             WHEN normalizer.param_count > 0
1772                                 THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
1773                                 ELSE ''
1774                             END ||
1775                     ')' INTO tmp_val;
1776
1777             END LOOP;
1778             IF tmp_val IS NOT NULL AND tmp_val <> '' THEN
1779                 -- note that a string that contains only blanks
1780                 -- is a valid value for some attributes
1781                 norm_attr_value := norm_attr_value || tmp_val;
1782             END IF;
1783         END LOOP;
1784
1785         IF attr_def.filter THEN
1786             -- Create unknown uncontrolled values and find the IDs of the values
1787             IF ccvm_row.id IS NULL THEN
1788                 FOR tmp_val IN SELECT value FROM UNNEST(norm_attr_value) x(value) LOOP
1789                     IF tmp_val IS NOT NULL AND BTRIM(tmp_val) <> '' THEN
1790                         BEGIN -- use subtransaction to isolate unique constraint violations
1791                             INSERT INTO metabib.uncontrolled_record_attr_value ( attr, value ) VALUES ( attr_def.name, tmp_val );
1792                         EXCEPTION WHEN unique_violation THEN END;
1793                     END IF;
1794                 END LOOP;
1795
1796                 SELECT ARRAY_AGG(id) INTO attr_vector_tmp FROM metabib.uncontrolled_record_attr_value WHERE attr = attr_def.name AND value = ANY( norm_attr_value );
1797             ELSE
1798                 SELECT ARRAY_AGG(id) INTO attr_vector_tmp FROM config.coded_value_map WHERE ctype = attr_def.name AND code = ANY( norm_attr_value );
1799             END IF;
1800
1801             -- Add the new value to the vector
1802             attr_vector := attr_vector || attr_vector_tmp;
1803         END IF;
1804
1805         IF attr_def.sorter THEN
1806             DELETE FROM metabib.record_sorter WHERE source = rid AND attr = attr_def.name;
1807             IF norm_attr_value[1] IS NOT NULL THEN
1808                 INSERT INTO metabib.record_sorter (source, attr, value) VALUES (rid, attr_def.name, norm_attr_value[1]);
1809             END IF;
1810         END IF;
1811
1812     END LOOP;
1813
1814 /* We may need to rewrite the vlist to contain
1815    the intersection of new values for requested
1816    attrs and old values for ignored attrs. To
1817    do this, we take the old attr vlist and
1818    subtract any values that are valid for the
1819    requested attrs, and then add back the new
1820    set of attr values. */
1821
1822     IF ARRAY_LENGTH(pattr_list, 1) > 0 THEN
1823         SELECT vlist INTO attr_vector_tmp FROM metabib.record_attr_vector_list WHERE source = rid;
1824         SELECT attr_vector_tmp - ARRAY_AGG(id::INT) INTO attr_vector_tmp FROM metabib.full_attr_id_map WHERE attr = ANY (pattr_list);
1825         attr_vector := attr_vector || attr_vector_tmp;
1826     END IF;
1827
1828     -- On to composite attributes, now that the record attrs have been pulled.  Processed in name order, so later composite
1829     -- attributes can depend on earlier ones.
1830     PERFORM metabib.compile_composite_attr_cache_init();
1831     FOR attr_def IN SELECT * FROM config.record_attr_definition WHERE composite AND name = ANY( attr_list ) ORDER BY name LOOP
1832
1833         FOR ccvm_row IN SELECT * FROM config.coded_value_map c WHERE c.ctype = attr_def.name ORDER BY value LOOP
1834
1835             tmp_val := metabib.compile_composite_attr( ccvm_row.id );
1836             CONTINUE WHEN tmp_val IS NULL OR tmp_val = ''; -- nothing to do
1837
1838             IF attr_def.filter THEN
1839                 IF attr_vector @@ tmp_val::query_int THEN
1840                     attr_vector = attr_vector + intset(ccvm_row.id);
1841                     EXIT WHEN NOT attr_def.multi;
1842                 END IF;
1843             END IF;
1844
1845             IF attr_def.sorter THEN
1846                 IF attr_vector @@ tmp_val THEN
1847                     DELETE FROM metabib.record_sorter WHERE source = rid AND attr = attr_def.name;
1848                     INSERT INTO metabib.record_sorter (source, attr, value) VALUES (rid, attr_def.name, ccvm_row.code);
1849                 END IF;
1850             END IF;
1851
1852         END LOOP;
1853
1854     END LOOP;
1855
1856     IF ARRAY_LENGTH(attr_vector, 1) > 0 THEN
1857         IF rdeleted THEN -- initial insert OR revivication
1858             DELETE FROM metabib.record_attr_vector_list WHERE source = rid;
1859             INSERT INTO metabib.record_attr_vector_list (source, vlist) VALUES (rid, attr_vector);
1860         ELSE
1861             UPDATE metabib.record_attr_vector_list SET vlist = attr_vector WHERE source = rid;
1862         END IF;
1863     END IF;
1864
1865 END;
1866
1867 $func$ LANGUAGE PLPGSQL;
1868
1869
1870 -- AFTER UPDATE OR INSERT trigger for biblio.record_entry
1871 CREATE OR REPLACE FUNCTION biblio.indexing_ingest_or_delete () RETURNS TRIGGER AS $func$
1872 DECLARE
1873     tmp_bool BOOL;
1874 BEGIN
1875
1876     IF NEW.deleted THEN -- If this bib is deleted
1877
1878         PERFORM * FROM config.internal_flag WHERE
1879             name = 'ingest.metarecord_mapping.preserve_on_delete' AND enabled;
1880
1881         tmp_bool := FOUND; -- Just in case this is changed by some other statement
1882
1883         PERFORM metabib.remap_metarecord_for_bib( NEW.id, NEW.fingerprint, TRUE, tmp_bool );
1884
1885         IF NOT tmp_bool THEN
1886             -- One needs to keep these around to support searches
1887             -- with the #deleted modifier, so one should turn on the named
1888             -- internal flag for that functionality.
1889             DELETE FROM metabib.record_attr_vector_list WHERE source = NEW.id;
1890         END IF;
1891
1892         DELETE FROM authority.bib_linking WHERE bib = NEW.id; -- Avoid updating fields in bibs that are no longer visible
1893         DELETE FROM biblio.peer_bib_copy_map WHERE peer_record = NEW.id; -- Separate any multi-homed items
1894         DELETE FROM metabib.browse_entry_def_map WHERE source = NEW.id; -- Don't auto-suggest deleted bibs
1895         RETURN NEW; -- and we're done
1896     END IF;
1897
1898     IF TG_OP = 'UPDATE' AND OLD.deleted IS FALSE THEN -- re-ingest?
1899         PERFORM * FROM config.internal_flag WHERE name = 'ingest.reingest.force_on_same_marc' AND enabled;
1900
1901         IF NOT FOUND AND OLD.marc = NEW.marc THEN -- don't do anything if the MARC didn't change
1902             RETURN NEW;
1903         END IF;
1904     END IF;
1905
1906     -- Record authority linking
1907     PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_authority_linking' AND enabled;
1908     IF NOT FOUND THEN
1909         PERFORM biblio.map_authority_linking( NEW.id, NEW.marc );
1910     END IF;
1911
1912     -- Flatten and insert the mfr data
1913     PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_metabib_full_rec' AND enabled;
1914     IF NOT FOUND THEN
1915         PERFORM metabib.reingest_metabib_full_rec(NEW.id);
1916
1917         -- Now we pull out attribute data, which is dependent on the mfr for all but XPath-based fields
1918         PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_metabib_rec_descriptor' AND enabled;
1919         IF NOT FOUND THEN
1920             PERFORM metabib.reingest_record_attributes(NEW.id, NULL, NEW.marc, TG_OP = 'INSERT' OR OLD.deleted);
1921         END IF;
1922     END IF;
1923
1924     -- Gather and insert the field entry data
1925     PERFORM metabib.reingest_metabib_field_entries(NEW.id);
1926
1927     -- Located URI magic
1928     PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_located_uri' AND enabled;
1929     IF NOT FOUND THEN PERFORM biblio.extract_located_uris( NEW.id, NEW.marc, NEW.editor ); END IF;
1930
1931     -- (re)map metarecord-bib linking
1932     IF TG_OP = 'INSERT' THEN -- if not deleted and performing an insert, check for the flag
1933         PERFORM * FROM config.internal_flag WHERE name = 'ingest.metarecord_mapping.skip_on_insert' AND enabled;
1934         IF NOT FOUND THEN
1935             PERFORM metabib.remap_metarecord_for_bib( NEW.id, NEW.fingerprint );
1936         END IF;
1937     ELSE -- we're doing an update, and we're not deleted, remap
1938         PERFORM * FROM config.internal_flag WHERE name = 'ingest.metarecord_mapping.skip_on_update' AND enabled;
1939         IF NOT FOUND THEN
1940             PERFORM metabib.remap_metarecord_for_bib( NEW.id, NEW.fingerprint );
1941         END IF;
1942     END IF;
1943
1944     RETURN NEW;
1945 END;
1946 $func$ LANGUAGE PLPGSQL;
1947
1948 CREATE OR REPLACE FUNCTION metabib.browse_normalize(facet_text TEXT, mapped_field INT) RETURNS TEXT AS $$
1949 DECLARE
1950     normalizer  RECORD;
1951 BEGIN
1952
1953     FOR normalizer IN
1954         SELECT  n.func AS func,
1955                 n.param_count AS param_count,
1956                 m.params AS params
1957           FROM  config.index_normalizer n
1958                 JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
1959           WHERE m.field = mapped_field AND m.pos < 0
1960           ORDER BY m.pos LOOP
1961
1962             EXECUTE 'SELECT ' || normalizer.func || '(' ||
1963                 quote_literal( facet_text ) ||
1964                 CASE
1965                     WHEN normalizer.param_count > 0
1966                         THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
1967                         ELSE ''
1968                     END ||
1969                 ')' INTO facet_text;
1970
1971     END LOOP;
1972
1973     RETURN facet_text;
1974 END;
1975
1976 $$ LANGUAGE PLPGSQL;
1977
1978
1979 -- This mimics a specific part of QueryParser, turning the first part of a
1980 -- classed search (search_class) into a set of classes and possibly fields.
1981 -- search_class might look like "author" or "title|proper" or "ti|uniform"
1982 -- or "au" or "au|corporate|personal" or anything like that, where the first
1983 -- element of the list you get by separating on the "|" character is either
1984 -- a registered class (config.metabib_class) or an alias
1985 -- (config.metabib_search_alias), and the rest of any such elements are
1986 -- fields (config.metabib_field).
1987 CREATE OR REPLACE
1988     FUNCTION metabib.search_class_to_registered_components(search_class TEXT)
1989     RETURNS SETOF RECORD AS $func$
1990 DECLARE
1991     search_parts        TEXT[];
1992     field_name          TEXT;
1993     search_part_count   INTEGER;
1994     rec                 RECORD;
1995     registered_class    config.metabib_class%ROWTYPE;
1996     registered_alias    config.metabib_search_alias%ROWTYPE;
1997     registered_field    config.metabib_field%ROWTYPE;
1998 BEGIN
1999     search_parts := REGEXP_SPLIT_TO_ARRAY(search_class, E'\\|');
2000
2001     search_part_count := ARRAY_LENGTH(search_parts, 1);
2002     IF search_part_count = 0 THEN
2003         RETURN;
2004     ELSE
2005         SELECT INTO registered_class
2006             * FROM config.metabib_class WHERE name = search_parts[1];
2007         IF FOUND THEN
2008             IF search_part_count < 2 THEN   -- all fields
2009                 rec := (registered_class.name, NULL::INTEGER);
2010                 RETURN NEXT rec;
2011                 RETURN; -- done
2012             END IF;
2013             FOR field_name IN SELECT *
2014                 FROM UNNEST(search_parts[2:search_part_count]) LOOP
2015                 SELECT INTO registered_field
2016                     * FROM config.metabib_field
2017                     WHERE name = field_name AND
2018                         field_class = registered_class.name;
2019                 IF FOUND THEN
2020                     rec := (registered_class.name, registered_field.id);
2021                     RETURN NEXT rec;
2022                 END IF;
2023             END LOOP;
2024         ELSE
2025             -- maybe we have an alias?
2026             SELECT INTO registered_alias
2027                 * FROM config.metabib_search_alias WHERE alias=search_parts[1];
2028             IF NOT FOUND THEN
2029                 RETURN;
2030             ELSE
2031                 IF search_part_count < 2 THEN   -- return w/e the alias says
2032                     rec := (
2033                         registered_alias.field_class, registered_alias.field
2034                     );
2035                     RETURN NEXT rec;
2036                     RETURN; -- done
2037                 ELSE
2038                     FOR field_name IN SELECT *
2039                         FROM UNNEST(search_parts[2:search_part_count]) LOOP
2040                         SELECT INTO registered_field
2041                             * FROM config.metabib_field
2042                             WHERE name = field_name AND
2043                                 field_class = registered_alias.field_class;
2044                         IF FOUND THEN
2045                             rec := (
2046                                 registered_alias.field_class,
2047                                 registered_field.id
2048                             );
2049                             RETURN NEXT rec;
2050                         END IF;
2051                     END LOOP;
2052                 END IF;
2053             END IF;
2054         END IF;
2055     END IF;
2056 END;
2057 $func$ LANGUAGE PLPGSQL ROWS 1;
2058
2059
2060 -- Given a string such as a user might type into a search box, prepare
2061 -- two changed variants for TO_TSQUERY(). See
2062 -- http://www.postgresql.org/docs/9.0/static/textsearch-controls.html
2063 -- The first variant is normalized to match indexed documents regardless
2064 -- of diacritics.  The second variant keeps its diacritics for proper
2065 -- highlighting via TS_HEADLINE().
2066 CREATE OR REPLACE
2067     FUNCTION metabib.autosuggest_prepare_tsquery(orig TEXT) RETURNS TEXT[] AS
2068 $$
2069 DECLARE
2070     orig_ended_in_space     BOOLEAN;
2071     result                  RECORD;
2072     plain                   TEXT;
2073     normalized              TEXT;
2074 BEGIN
2075     orig_ended_in_space := orig ~ E'\\s$';
2076
2077     orig := ARRAY_TO_STRING(
2078         evergreen.regexp_split_to_array(orig, E'\\W+'), ' '
2079     );
2080
2081     normalized := public.naco_normalize(orig); -- also trim()s
2082     plain := trim(orig);
2083
2084     IF NOT orig_ended_in_space THEN
2085         plain := plain || ':*';
2086         normalized := normalized || ':*';
2087     END IF;
2088
2089     plain := ARRAY_TO_STRING(
2090         evergreen.regexp_split_to_array(plain, E'\\s+'), ' & '
2091     );
2092     normalized := ARRAY_TO_STRING(
2093         evergreen.regexp_split_to_array(normalized, E'\\s+'), ' & '
2094     );
2095
2096     RETURN ARRAY[normalized, plain];
2097 END;
2098 $$ LANGUAGE PLPGSQL;
2099
2100 -- Functions metabib.browse, metabib.staged_browse, and metabib.suggest_browse_entries
2101 -- will be created later, after internal dependencies are resolved.
2102
2103 CREATE OR REPLACE FUNCTION public.oils_tsearch2 () RETURNS TRIGGER AS $$
2104 DECLARE
2105     normalizer      RECORD;
2106     value           TEXT := '';
2107     temp_vector     TEXT := '';
2108     ts_rec          RECORD;
2109     cur_weight      "char";
2110 BEGIN
2111
2112     value := NEW.value;
2113     NEW.index_vector = ''::tsvector;
2114
2115     IF TG_TABLE_NAME::TEXT ~ 'field_entry$' THEN
2116         FOR normalizer IN
2117             SELECT  n.func AS func,
2118                     n.param_count AS param_count,
2119                     m.params AS params
2120               FROM  config.index_normalizer n
2121                     JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
2122               WHERE field = NEW.field AND m.pos < 0
2123               ORDER BY m.pos LOOP
2124                 EXECUTE 'SELECT ' || normalizer.func || '(' ||
2125                     quote_literal( value ) ||
2126                     CASE
2127                         WHEN normalizer.param_count > 0
2128                             THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
2129                             ELSE ''
2130                         END ||
2131                     ')' INTO value;
2132
2133         END LOOP;
2134
2135         NEW.value = value;
2136
2137         FOR normalizer IN
2138             SELECT  n.func AS func,
2139                     n.param_count AS param_count,
2140                     m.params AS params
2141               FROM  config.index_normalizer n
2142                     JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
2143               WHERE field = NEW.field AND m.pos >= 0
2144               ORDER BY m.pos LOOP
2145                 EXECUTE 'SELECT ' || normalizer.func || '(' ||
2146                     quote_literal( value ) ||
2147                     CASE
2148                         WHEN normalizer.param_count > 0
2149                             THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
2150                             ELSE ''
2151                         END ||
2152                     ')' INTO value;
2153
2154         END LOOP;
2155    END IF;
2156
2157     IF TG_TABLE_NAME::TEXT ~ 'browse_entry$' THEN
2158
2159         value :=  ARRAY_TO_STRING(
2160             evergreen.regexp_split_to_array(value, E'\\W+'), ' '
2161         );
2162         value := public.search_normalize(value);
2163         NEW.index_vector = to_tsvector(TG_ARGV[0]::regconfig, value);
2164
2165     ELSIF TG_TABLE_NAME::TEXT ~ 'field_entry$' THEN
2166         FOR ts_rec IN
2167
2168             SELECT DISTINCT m.ts_config, m.index_weight
2169             FROM config.metabib_class_ts_map m
2170                  LEFT JOIN metabib.record_attr_vector_list r ON (r.source = NEW.source)
2171                  LEFT JOIN config.coded_value_map ccvm ON (
2172                     ccvm.ctype IN ('item_lang', 'language') AND
2173                     ccvm.code = m.index_lang AND
2174                     r.vlist @> intset(ccvm.id)
2175                 )
2176             WHERE m.field_class = TG_ARGV[0]
2177                 AND m.active
2178                 AND (m.always OR NOT EXISTS (SELECT 1 FROM config.metabib_field_ts_map WHERE metabib_field = NEW.field))
2179                 AND (m.index_lang IS NULL OR ccvm.id IS NOT NULL)
2180                         UNION
2181             SELECT DISTINCT m.ts_config, m.index_weight
2182             FROM config.metabib_field_ts_map m
2183                  LEFT JOIN metabib.record_attr_vector_list r ON (r.source = NEW.source)
2184                  LEFT JOIN config.coded_value_map ccvm ON (
2185                     ccvm.ctype IN ('item_lang', 'language') AND
2186                     ccvm.code = m.index_lang AND
2187                     r.vlist @> intset(ccvm.id)
2188                 )
2189             WHERE m.metabib_field = NEW.field
2190                 AND m.active
2191                 AND (m.index_lang IS NULL OR ccvm.id IS NOT NULL)
2192             ORDER BY index_weight ASC
2193
2194         LOOP
2195
2196             IF cur_weight IS NOT NULL AND cur_weight != ts_rec.index_weight THEN
2197                 NEW.index_vector = NEW.index_vector || setweight(temp_vector::tsvector,cur_weight);
2198                 temp_vector = '';
2199             END IF;
2200
2201             cur_weight = ts_rec.index_weight;
2202             SELECT INTO temp_vector temp_vector || ' ' || to_tsvector(ts_rec.ts_config::regconfig, value)::TEXT;
2203
2204         END LOOP;
2205         NEW.index_vector = NEW.index_vector || setweight(temp_vector::tsvector,cur_weight);
2206     ELSE
2207         NEW.index_vector = to_tsvector(TG_ARGV[0]::regconfig, value);
2208     END IF;
2209
2210     RETURN NEW;
2211 END;
2212 $$ LANGUAGE PLPGSQL;
2213
2214
2215 CREATE TYPE metabib.flat_browse_entry_appearance AS (
2216     browse_entry    BIGINT,
2217     value           TEXT,
2218     fields          TEXT,
2219     authorities     TEXT,
2220     sees            TEXT,
2221     sources         INT,        -- visible ones, that is
2222     asources        INT,        -- visible ones, that is
2223     row_number      INT,        -- internal use, sort of
2224     accurate        BOOL,       -- Count in sources field is accurate? Not
2225                                 -- if we had more than a browse superpage
2226                                 -- of records to look at.
2227     aaccurate       BOOL,       -- See previous comment...
2228     pivot_point     BIGINT
2229 );
2230
2231
2232 CREATE OR REPLACE FUNCTION metabib.browse_bib_pivot(
2233     INT[],
2234     TEXT
2235 ) RETURNS BIGINT AS $p$
2236     SELECT  mbe.id
2237       FROM  metabib.browse_entry mbe
2238             JOIN metabib.browse_entry_def_map mbedm ON (
2239                 mbedm.entry = mbe.id
2240                 AND mbedm.def = ANY($1)
2241             )
2242       WHERE mbe.sort_value >= public.naco_normalize($2)
2243       ORDER BY mbe.sort_value, mbe.value LIMIT 1;
2244 $p$ LANGUAGE SQL STABLE;
2245
2246 CREATE OR REPLACE FUNCTION metabib.browse_authority_pivot(
2247     INT[],
2248     TEXT
2249 ) RETURNS BIGINT AS $p$
2250     SELECT  mbe.id
2251       FROM  metabib.browse_entry mbe
2252             JOIN metabib.browse_entry_simple_heading_map mbeshm ON ( mbeshm.entry = mbe.id )
2253             JOIN authority.simple_heading ash ON ( mbeshm.simple_heading = ash.id )
2254             JOIN authority.control_set_auth_field_metabib_field_map_refs map ON (
2255                 ash.atag = map.authority_field
2256                 AND map.metabib_field = ANY($1)
2257             )
2258       WHERE mbe.sort_value >= public.naco_normalize($2)
2259       ORDER BY mbe.sort_value, mbe.value LIMIT 1;
2260 $p$ LANGUAGE SQL STABLE;
2261
2262 CREATE OR REPLACE FUNCTION metabib.browse_authority_refs_pivot(
2263     INT[],
2264     TEXT
2265 ) RETURNS BIGINT AS $p$
2266     SELECT  mbe.id
2267       FROM  metabib.browse_entry mbe
2268             JOIN metabib.browse_entry_simple_heading_map mbeshm ON ( mbeshm.entry = mbe.id )
2269             JOIN authority.simple_heading ash ON ( mbeshm.simple_heading = ash.id )
2270             JOIN authority.control_set_auth_field_metabib_field_map_refs_only map ON (
2271                 ash.atag = map.authority_field
2272                 AND map.metabib_field = ANY($1)
2273             )
2274       WHERE mbe.sort_value >= public.naco_normalize($2)
2275       ORDER BY mbe.sort_value, mbe.value LIMIT 1;
2276 $p$ LANGUAGE SQL STABLE;
2277
2278 CREATE OR REPLACE FUNCTION metabib.browse_pivot(
2279     INT[],
2280     TEXT
2281 ) RETURNS BIGINT AS $p$
2282     SELECT  id FROM metabib.browse_entry
2283       WHERE id IN (
2284                 metabib.browse_bib_pivot($1, $2),
2285                 metabib.browse_authority_refs_pivot($1,$2) -- only look in 4xx, 5xx, 7xx of authority
2286             )
2287       ORDER BY sort_value, value LIMIT 1;
2288 $p$ LANGUAGE SQL STABLE;
2289
2290
2291 -- This function is used to help clean up facet labels. Due to quirks in
2292 -- MARC parsing, some facet labels may be generated with periods or commas
2293 -- at the end.  This will strip a trailing commas off all the time, and
2294 -- periods when they don't look like they are part of initials.
2295 --      Smith, John    =>  no change
2296 --      Smith, John,   =>  Smith, John
2297 --      Smith, John.   =>  Smith, John
2298 --      Public, John Q. => no change
2299 CREATE OR REPLACE FUNCTION metabib.trim_trailing_punctuation ( TEXT ) RETURNS TEXT AS $$
2300 DECLARE
2301     result    TEXT;
2302     last_char TEXT;
2303 BEGIN
2304     result := $1;
2305     last_char = substring(result from '.$');
2306
2307     IF last_char = ',' THEN
2308         result := substring(result from '^(.*),$');
2309
2310     ELSIF last_char = '.' THEN
2311         IF substring(result from ' \w\.$') IS NULL THEN
2312             result := substring(result from '^(.*)\.$');
2313         END IF;
2314     END IF;
2315
2316     RETURN result;
2317
2318 END;
2319 $$ language 'plpgsql';
2320
2321 COMMIT;
2322