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     browse_nocase       BOOL
 744 );
 745
 746 CREATE OR REPLACE FUNCTION biblio.extract_metabib_field_entry (
 747     rid BIGINT,
 748     default_joiner TEXT,
 749     field_types TEXT[],
 750     only_fields INT[]
 751 ) RETURNS SETOF metabib.field_entry_template AS $func$
 752 DECLARE
 753     bib     biblio.record_entry%ROWTYPE;
 754     idx     config.metabib_field%ROWTYPE;
 755     xfrm        config.xml_transform%ROWTYPE;
 756     prev_xfrm   TEXT;
 757     transformed_xml TEXT;
 758     xml_node    TEXT;
 759     xml_node_list   TEXT[];
 760     facet_text  TEXT;
 761     display_text TEXT;
 762     browse_text TEXT;
 763     sort_value  TEXT;
 764     raw_text    TEXT;
 765     curr_text   TEXT;
 766     joiner      TEXT := default_joiner; -- XXX will index defs supply a joiner?
 767     authority_text TEXT;
 768     authority_link BIGINT;
 769     output_row  metabib.field_entry_template%ROWTYPE;
 770     process_idx BOOL;
 771 BEGIN
 772
 773     -- Start out with no field-use bools set
 774     output_row.browse_nocase = FALSE;
 775     output_row.browse_field = FALSE;
 776     output_row.facet_field = FALSE;
 777     output_row.display_field = FALSE;
 778     output_row.search_field = FALSE;
 779
 780     -- Get the record
 781     SELECT INTO bib * FROM biblio.record_entry WHERE id = rid;
 782
 783     -- Loop over the indexing entries
 784     FOR idx IN SELECT * FROM config.metabib_field WHERE id = ANY (only_fields) ORDER BY format LOOP
 785         CONTINUE WHEN idx.xpath IS NULL OR idx.xpath = ''; -- pure virtual field
 786
 787         process_idx := FALSE;
 788         IF idx.display_field AND 'display' = ANY (field_types) THEN process_idx = TRUE; END IF;
 789         IF idx.browse_field AND 'browse' = ANY (field_types) THEN process_idx = TRUE; END IF;
 790         IF idx.search_field AND 'search' = ANY (field_types) THEN process_idx = TRUE; END IF;
 791         IF idx.facet_field AND 'facet' = ANY (field_types) THEN process_idx = TRUE; END IF;
 792         CONTINUE WHEN process_idx = FALSE; -- disabled for all types
 793
 794         joiner := COALESCE(idx.joiner, default_joiner);
 795
 796         SELECT INTO xfrm * from config.xml_transform WHERE name = idx.format;
 797
 798         -- See if we can skip the XSLT ... it's expensive
 799         IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN
 800             -- Can't skip the transform
 801             IF xfrm.xslt <> '---' THEN
 802                 transformed_xml := oils_xslt_process(bib.marc,xfrm.xslt);
 803             ELSE
 804                 transformed_xml := bib.marc;
 805             END IF;
 806
 807             prev_xfrm := xfrm.name;
 808         END IF;
 809
 810         xml_node_list := oils_xpath( idx.xpath, transformed_xml, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 811
 812         raw_text := NULL;
 813         FOR xml_node IN SELECT x FROM unnest(xml_node_list) AS x LOOP
 814             CONTINUE WHEN xml_node !~ E'^\\s*<';
 815
 816             -- XXX much of this should be moved into oils_xpath_string...
 817             curr_text := ARRAY_TO_STRING(array_remove(array_remove(
 818                 oils_xpath( '//text()', -- get the content of all the nodes within the main selected node
 819                     REGEXP_REPLACE( xml_node, E'\\s+', ' ', 'g' ) -- Translate adjacent whitespace to a single space
 820                 ), ' '), ''),  -- throw away morally empty (bankrupt?) strings
 821                 joiner
 822             );
 823
 824             CONTINUE WHEN curr_text IS NULL OR curr_text = '';
 825
 826             IF raw_text IS NOT NULL THEN
 827                 raw_text := raw_text || joiner;
 828             END IF;
 829
 830             raw_text := COALESCE(raw_text,'') || curr_text;
 831
 832             -- autosuggest/metabib.browse_entry
 833             IF idx.browse_field THEN
 834                 output_row.browse_nocase = idx.browse_nocase;
 835
 836                 IF idx.browse_xpath IS NOT NULL AND idx.browse_xpath <> '' THEN
 837                     browse_text := oils_xpath_string( idx.browse_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 838                 ELSE
 839                     browse_text := curr_text;
 840                 END IF;
 841
 842                 IF idx.browse_sort_xpath IS NOT NULL AND
 843                     idx.browse_sort_xpath <> '' THEN
 844
 845                     sort_value := oils_xpath_string(
 846                         idx.browse_sort_xpath, xml_node, joiner,
 847                         ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]
 848                     );
 849                 ELSE
 850                     sort_value := browse_text;
 851                 END IF;
 852
 853                 output_row.field_class = idx.field_class;
 854                 output_row.field = idx.id;
 855                 output_row.source = rid;
 856                 output_row.value = BTRIM(REGEXP_REPLACE(browse_text, E'\\s+', ' ', 'g'));
 857                 output_row.sort_value :=
 858                     public.naco_normalize(sort_value);
 859
 860                 output_row.authority := NULL;
 861
 862                 IF idx.authority_xpath IS NOT NULL AND idx.authority_xpath <> '' THEN
 863                     authority_text := oils_xpath_string(
 864                         idx.authority_xpath, xml_node, joiner,
 865                         ARRAY[
 866                             ARRAY[xfrm.prefix, xfrm.namespace_uri],
 867                             ARRAY['xlink','http://www.w3.org/1999/xlink']
 868                         ]
 869                     );
 870
 871                     IF authority_text ~ '^\d+$' THEN
 872                         authority_link := authority_text::BIGINT;
 873                         PERFORM * FROM authority.record_entry WHERE id = authority_link;
 874                         IF FOUND THEN
 875                             output_row.authority := authority_link;
 876                         END IF;
 877                     END IF;
 878
 879                 END IF;
 880
 881                 output_row.browse_field = TRUE;
 882                 -- Returning browse rows with search_field = true for search+browse
 883                 -- configs allows us to retain granularity of being able to search
 884                 -- browse fields with "starts with" type operators (for example, for
 885                 -- titles of songs in music albums)
 886                 IF idx.search_field THEN
 887                     output_row.search_field = TRUE;
 888                 END IF;
 889                 RETURN NEXT output_row;
 890                 output_row.browse_nocase = FALSE;
 891                 output_row.browse_field = FALSE;
 892                 output_row.search_field = FALSE;
 893                 output_row.sort_value := NULL;
 894             END IF;
 895
 896             -- insert raw node text for faceting
 897             IF idx.facet_field THEN
 898
 899                 IF idx.facet_xpath IS NOT NULL AND idx.facet_xpath <> '' THEN
 900                     facet_text := oils_xpath_string( idx.facet_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 901                 ELSE
 902                     facet_text := curr_text;
 903                 END IF;
 904
 905                 output_row.field_class = idx.field_class;
 906                 output_row.field = -1 * idx.id;
 907                 output_row.source = rid;
 908                 output_row.value = BTRIM(REGEXP_REPLACE(facet_text, E'\\s+', ' ', 'g'));
 909
 910                 output_row.facet_field = TRUE;
 911                 RETURN NEXT output_row;
 912                 output_row.facet_field = FALSE;
 913             END IF;
 914
 915             -- insert raw node text for display
 916             IF idx.display_field THEN
 917
 918                 IF idx.display_xpath IS NOT NULL AND idx.display_xpath <> '' THEN
 919                     display_text := oils_xpath_string( idx.display_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 920                 ELSE
 921                     display_text := curr_text;
 922                 END IF;
 923
 924                 output_row.field_class = idx.field_class;
 925                 output_row.field = -1 * idx.id;
 926                 output_row.source = rid;
 927                 output_row.value = BTRIM(REGEXP_REPLACE(display_text, E'\\s+', ' ', 'g'));
 928
 929                 output_row.display_field = TRUE;
 930                 RETURN NEXT output_row;
 931                 output_row.display_field = FALSE;
 932             END IF;
 933
 934         END LOOP;
 935
 936         CONTINUE WHEN raw_text IS NULL OR raw_text = '';
 937
 938         -- insert combined node text for searching
 939         IF idx.search_field THEN
 940             output_row.field_class = idx.field_class;
 941             output_row.field = idx.id;
 942             output_row.source = rid;
 943             output_row.value = BTRIM(REGEXP_REPLACE(raw_text, E'\\s+', ' ', 'g'));
 944
 945             output_row.search_field = TRUE;
 946             RETURN NEXT output_row;
 947             output_row.search_field = FALSE;
 948         END IF;
 949
 950     END LOOP;
 951
 952 END;
 953 $func$ LANGUAGE PLPGSQL;
 954
 955 CREATE OR REPLACE FUNCTION metabib.update_combined_index_vectors(bib_id BIGINT) RETURNS VOID AS $func$
 956 DECLARE
 957     rdata       TSVECTOR;
 958     vclass      TEXT;
 959     vfield      INT;
 960     rfields     INT[];
 961 BEGIN
 962     DELETE FROM metabib.combined_keyword_field_entry WHERE record = bib_id;
 963     INSERT INTO metabib.combined_keyword_field_entry(record, metabib_field, index_vector)
 964         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 965         FROM metabib.keyword_field_entry WHERE source = bib_id GROUP BY field;
 966     INSERT INTO metabib.combined_keyword_field_entry(record, metabib_field, index_vector)
 967         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 968         FROM metabib.keyword_field_entry WHERE source = bib_id;
 969
 970     DELETE FROM metabib.combined_title_field_entry WHERE record = bib_id;
 971     INSERT INTO metabib.combined_title_field_entry(record, metabib_field, index_vector)
 972         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 973         FROM metabib.title_field_entry WHERE source = bib_id GROUP BY field;
 974     INSERT INTO metabib.combined_title_field_entry(record, metabib_field, index_vector)
 975         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 976         FROM metabib.title_field_entry WHERE source = bib_id;
 977
 978     DELETE FROM metabib.combined_author_field_entry WHERE record = bib_id;
 979     INSERT INTO metabib.combined_author_field_entry(record, metabib_field, index_vector)
 980         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 981         FROM metabib.author_field_entry WHERE source = bib_id GROUP BY field;
 982     INSERT INTO metabib.combined_author_field_entry(record, metabib_field, index_vector)
 983         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 984         FROM metabib.author_field_entry WHERE source = bib_id;
 985
 986     DELETE FROM metabib.combined_subject_field_entry WHERE record = bib_id;
 987     INSERT INTO metabib.combined_subject_field_entry(record, metabib_field, index_vector)
 988         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 989         FROM metabib.subject_field_entry WHERE source = bib_id GROUP BY field;
 990     INSERT INTO metabib.combined_subject_field_entry(record, metabib_field, index_vector)
 991         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 992         FROM metabib.subject_field_entry WHERE source = bib_id;
 993
 994     DELETE FROM metabib.combined_series_field_entry WHERE record = bib_id;
 995     INSERT INTO metabib.combined_series_field_entry(record, metabib_field, index_vector)
 996         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
 997         FROM metabib.series_field_entry WHERE source = bib_id GROUP BY field;
 998     INSERT INTO metabib.combined_series_field_entry(record, metabib_field, index_vector)
 999         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
1000         FROM metabib.series_field_entry WHERE source = bib_id;
1001
1002     DELETE FROM metabib.combined_identifier_field_entry WHERE record = bib_id;
1003     INSERT INTO metabib.combined_identifier_field_entry(record, metabib_field, index_vector)
1004         SELECT bib_id, field, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
1005         FROM metabib.identifier_field_entry WHERE source = bib_id GROUP BY field;
1006     INSERT INTO metabib.combined_identifier_field_entry(record, metabib_field, index_vector)
1007         SELECT bib_id, NULL, strip(COALESCE(string_agg(index_vector::TEXT,' '),'')::tsvector)
1008         FROM metabib.identifier_field_entry WHERE source = bib_id;
1009
1010     -- For each virtual def, gather the data from the combined real field
1011     -- entries and append it to the virtual combined entry.
1012     FOR vfield, rfields IN SELECT virtual, ARRAY_AGG(real)  FROM config.metabib_field_virtual_map GROUP BY virtual LOOP
1013         SELECT  field_class INTO vclass
1014           FROM  config.metabib_field
1015           WHERE id = vfield;
1016
1017         SELECT  string_agg(index_vector::TEXT,' ')::tsvector INTO rdata
1018           FROM  metabib.combined_all_field_entry
1019           WHERE record = bib_id
1020                 AND metabib_field = ANY (rfields);
1021
1022         BEGIN -- I cannot wait for INSERT ON CONFLICT ... 9.5, though
1023             EXECUTE $$
1024                 INSERT INTO metabib.combined_$$ || vclass || $$_field_entry
1025                     (record, metabib_field, index_vector) VALUES ($1, $2, $3)
1026             $$ USING bib_id, vfield, rdata;
1027         EXCEPTION WHEN unique_violation THEN
1028             EXECUTE $$
1029                 UPDATE  metabib.combined_$$ || vclass || $$_field_entry
1030                   SET   index_vector = index_vector || $3
1031                   WHERE record = $1
1032                         AND metabib_field = $2
1033             $$ USING bib_id, vfield, rdata;
1034         WHEN OTHERS THEN
1035             -- ignore and move on
1036         END;
1037     END LOOP;
1038 END;
1039 $func$ LANGUAGE PLPGSQL;
1040
1041 CREATE OR REPLACE FUNCTION metabib.reingest_metabib_field_entries(
1042     bib_id BIGINT,
1043     skip_facet BOOL DEFAULT FALSE,
1044     skip_display BOOL DEFAULT FALSE,
1045     skip_browse BOOL DEFAULT FALSE,
1046     skip_search BOOL DEFAULT FALSE,
1047     only_fields INT[] DEFAULT '{}'::INT[]
1048 ) RETURNS VOID AS $func$
1049 DECLARE
1050     fclass          RECORD;
1051     ind_data        metabib.field_entry_template%ROWTYPE;
1052     mbe_row         metabib.browse_entry%ROWTYPE;
1053     mbe_id          BIGINT;
1054     b_skip_facet    BOOL;
1055     b_skip_display    BOOL;
1056     b_skip_browse   BOOL;
1057     b_skip_search   BOOL;
1058     value_prepped   TEXT;
1059     field_list      INT[] := only_fields;
1060     field_types     TEXT[] := '{}'::TEXT[];
1061 BEGIN
1062
1063     IF field_list = '{}'::INT[] THEN
1064         SELECT ARRAY_AGG(id) INTO field_list FROM config.metabib_field;
1065     END IF;
1066
1067     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;
1068     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;
1069     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;
1070     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;
1071
1072     IF NOT b_skip_facet THEN field_types := field_types || '{facet}'; END IF;
1073     IF NOT b_skip_display THEN field_types := field_types || '{display}'; END IF;
1074     IF NOT b_skip_browse THEN field_types := field_types || '{browse}'; END IF;
1075     IF NOT b_skip_search THEN field_types := field_types || '{search}'; END IF;
1076
1077     PERFORM * FROM config.internal_flag WHERE name = 'ingest.assume_inserts_only' AND enabled;
1078     IF NOT FOUND THEN
1079         IF NOT b_skip_search THEN
1080             FOR fclass IN SELECT * FROM config.metabib_class LOOP
1081                 -- RAISE NOTICE 'Emptying out %', fclass.name;
1082                 EXECUTE $$DELETE FROM metabib.$$ || fclass.name || $$_field_entry WHERE source = $$ || bib_id;
1083             END LOOP;
1084         END IF;
1085         IF NOT b_skip_facet THEN
1086             DELETE FROM metabib.facet_entry WHERE source = bib_id;
1087         END IF;
1088         IF NOT b_skip_display THEN
1089             DELETE FROM metabib.display_entry WHERE source = bib_id;
1090         END IF;
1091         IF NOT b_skip_browse THEN
1092             DELETE FROM metabib.browse_entry_def_map WHERE source = bib_id;
1093         END IF;
1094     END IF;
1095
1096     FOR ind_data IN SELECT * FROM biblio.extract_metabib_field_entry( bib_id, ' ', field_types, field_list ) LOOP
1097
1098         -- don't store what has been normalized away
1099         CONTINUE WHEN ind_data.value IS NULL;
1100
1101         IF ind_data.field < 0 THEN
1102             ind_data.field = -1 * ind_data.field;
1103         END IF;
1104
1105         IF ind_data.facet_field AND NOT b_skip_facet THEN
1106             INSERT INTO metabib.facet_entry (field, source, value)
1107                 VALUES (ind_data.field, ind_data.source, ind_data.value);
1108         END IF;
1109
1110         IF ind_data.display_field AND NOT b_skip_display THEN
1111             INSERT INTO metabib.display_entry (field, source, value)
1112                 VALUES (ind_data.field, ind_data.source, ind_data.value);
1113         END IF;
1114
1115
1116         IF ind_data.browse_field AND NOT b_skip_browse THEN
1117             -- A caveat about this SELECT: this should take care of replacing
1118             -- old mbe rows when data changes, but not if normalization (by
1119             -- which I mean specifically the output of
1120             -- evergreen.oils_tsearch2()) changes.  It may or may not be
1121             -- expensive to add a comparison of index_vector to index_vector
1122             -- to the WHERE clause below.
1123
1124             CONTINUE WHEN ind_data.sort_value IS NULL;
1125
1126             value_prepped := metabib.browse_normalize(ind_data.value, ind_data.field);
1127             IF ind_data.browse_nocase THEN
1128                 SELECT INTO mbe_row * FROM metabib.browse_entry
1129                     WHERE evergreen.lowercase(value) = evergreen.lowercase(value_prepped) AND sort_value = ind_data.sort_value
1130                     ORDER BY sort_value, value LIMIT 1; -- gotta pick something, I guess
1131             ELSE
1132                 SELECT INTO mbe_row * FROM metabib.browse_entry
1133                     WHERE value = value_prepped AND sort_value = ind_data.sort_value;
1134             END IF;
1135
1136             IF FOUND THEN
1137                 mbe_id := mbe_row.id;
1138             ELSE
1139                 INSERT INTO metabib.browse_entry
1140                     ( value, sort_value ) VALUES
1141                     ( value_prepped, ind_data.sort_value );
1142
1143                 mbe_id := CURRVAL('metabib.browse_entry_id_seq'::REGCLASS);
1144             END IF;
1145
1146             INSERT INTO metabib.browse_entry_def_map (entry, def, source, authority)
1147                 VALUES (mbe_id, ind_data.field, ind_data.source, ind_data.authority);
1148         END IF;
1149
1150         IF ind_data.search_field AND NOT b_skip_search THEN
1151             -- Avoid inserting duplicate rows
1152             EXECUTE 'SELECT 1 FROM metabib.' || ind_data.field_class ||
1153                 '_field_entry WHERE field = $1 AND source = $2 AND value = $3'
1154                 INTO mbe_id USING ind_data.field, ind_data.source, ind_data.value;
1155                 -- RAISE NOTICE 'Search for an already matching row returned %', mbe_id;
1156             IF mbe_id IS NULL THEN
1157                 EXECUTE $$
1158                 INSERT INTO metabib.$$ || ind_data.field_class || $$_field_entry (field, source, value)
1159                     VALUES ($$ ||
1160                         quote_literal(ind_data.field) || $$, $$ ||
1161                         quote_literal(ind_data.source) || $$, $$ ||
1162                         quote_literal(ind_data.value) ||
1163                     $$);$$;
1164             END IF;
1165         END IF;
1166
1167     END LOOP;
1168
1169     IF NOT b_skip_search THEN
1170         PERFORM metabib.update_combined_index_vectors(bib_id);
1171     END IF;
1172
1173     RETURN;
1174 END;
1175 $func$ LANGUAGE PLPGSQL;
1176
1177 CREATE OR REPLACE FUNCTION authority.flatten_marc ( rid BIGINT ) RETURNS SETOF authority.full_rec AS $func$
1178 DECLARE
1179         auth    authority.record_entry%ROWTYPE;
1180         output  authority.full_rec%ROWTYPE;
1181         field   RECORD;
1182 BEGIN
1183         SELECT INTO auth * FROM authority.record_entry WHERE id = rid;
1184
1185         FOR field IN SELECT * FROM vandelay.flatten_marc( auth.marc ) LOOP
1186                 output.record := rid;
1187                 output.ind1 := field.ind1;
1188                 output.ind2 := field.ind2;
1189                 output.tag := field.tag;
1190                 output.subfield := field.subfield;
1191                 output.value := field.value;
1192
1193                 RETURN NEXT output;
1194         END LOOP;
1195 END;
1196 $func$ LANGUAGE PLPGSQL;
1197
1198 CREATE OR REPLACE FUNCTION biblio.flatten_marc ( rid BIGINT ) RETURNS SETOF metabib.full_rec AS $func$
1199 DECLARE
1200         bib     biblio.record_entry%ROWTYPE;
1201         output  metabib.full_rec%ROWTYPE;
1202         field   RECORD;
1203 BEGIN
1204         SELECT INTO bib * FROM biblio.record_entry WHERE id = rid;
1205
1206         FOR field IN SELECT * FROM vandelay.flatten_marc( bib.marc ) LOOP
1207                 output.record := rid;
1208                 output.ind1 := field.ind1;
1209                 output.ind2 := field.ind2;
1210                 output.tag := field.tag;
1211                 output.subfield := field.subfield;
1212                 output.value := field.value;
1213
1214                 RETURN NEXT output;
1215         END LOOP;
1216 END;
1217 $func$ LANGUAGE PLPGSQL;
1218
1219 CREATE OR REPLACE FUNCTION biblio.marc21_extract_fixed_field_list( rid BIGINT, ff TEXT ) RETURNS TEXT[] AS $func$
1220     SELECT * FROM vandelay.marc21_extract_fixed_field_list( (SELECT marc FROM biblio.record_entry WHERE id = $1), $2, TRUE );
1221 $func$ LANGUAGE SQL;
1222
1223 CREATE OR REPLACE FUNCTION biblio.marc21_extract_fixed_field( rid BIGINT, ff TEXT ) RETURNS TEXT AS $func$
1224     SELECT * FROM vandelay.marc21_extract_fixed_field( (SELECT marc FROM biblio.record_entry WHERE id = $1), $2, TRUE );
1225 $func$ LANGUAGE SQL;
1226
1227 CREATE OR REPLACE FUNCTION biblio.marc21_extract_all_fixed_fields( rid BIGINT ) RETURNS SETOF biblio.record_ff_map AS $func$
1228     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 );
1229 $func$ LANGUAGE SQL;
1230
1231 CREATE OR REPLACE FUNCTION biblio.marc21_physical_characteristics( rid BIGINT ) RETURNS SETOF biblio.marc21_physical_characteristics AS $func$
1232     SELECT id, $1 AS record, ptype, subfield, value FROM vandelay.marc21_physical_characteristics( (SELECT marc FROM biblio.record_entry WHERE id = $1) );
1233 $func$ LANGUAGE SQL;
1234
1235 CREATE OR REPLACE FUNCTION biblio.extract_quality ( marc TEXT, best_lang TEXT, best_type TEXT ) RETURNS INT AS $func$
1236 DECLARE
1237     qual        INT;
1238     ldr         TEXT;
1239     tval        TEXT;
1240     tval_rec    RECORD;
1241     bval        TEXT;
1242     bval_rec    RECORD;
1243     type_map    RECORD;
1244     ff_pos      RECORD;
1245     ff_tag_data TEXT;
1246 BEGIN
1247
1248     IF marc IS NULL OR marc = '' THEN
1249         RETURN NULL;
1250     END IF;
1251
1252     -- First, the count of tags
1253     qual := ARRAY_UPPER(oils_xpath('*[local-name()="datafield"]', marc), 1);
1254
1255     -- now go through a bunch of pain to get the record type
1256     IF best_type IS NOT NULL THEN
1257         ldr := (oils_xpath('//*[local-name()="leader"]/text()', marc))[1];
1258
1259         IF ldr IS NOT NULL THEN
1260             SELECT * INTO tval_rec FROM config.marc21_ff_pos_map WHERE fixed_field = 'Type' LIMIT 1; -- They're all the same
1261             SELECT * INTO bval_rec FROM config.marc21_ff_pos_map WHERE fixed_field = 'BLvl' LIMIT 1; -- They're all the same
1262
1263
1264             tval := SUBSTRING( ldr, tval_rec.start_pos + 1, tval_rec.length );
1265             bval := SUBSTRING( ldr, bval_rec.start_pos + 1, bval_rec.length );
1266
1267             -- RAISE NOTICE 'type %, blvl %, ldr %', tval, bval, ldr;
1268
1269             SELECT * INTO type_map FROM config.marc21_rec_type_map WHERE type_val LIKE '%' || tval || '%' AND blvl_val LIKE '%' || bval || '%';
1270
1271             IF type_map.code IS NOT NULL THEN
1272                 IF best_type = type_map.code THEN
1273                     qual := qual + qual / 2;
1274                 END IF;
1275
1276                 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
1277                     ff_tag_data := SUBSTRING((oils_xpath('//*[@tag="' || ff_pos.tag || '"]/text()',marc))[1], ff_pos.start_pos + 1, ff_pos.length);
1278                     IF ff_tag_data = best_lang THEN
1279                             qual := qual + 100;
1280                     END IF;
1281                 END LOOP;
1282             END IF;
1283         END IF;
1284     END IF;
1285
1286     -- Now look for some quality metrics
1287     -- DCL record?
1288     IF ARRAY_UPPER(oils_xpath('//*[@tag="040"]/*[@code="a" and contains(.,"DLC")]', marc), 1) = 1 THEN
1289         qual := qual + 10;
1290     END IF;
1291
1292     -- From OCLC?
1293     IF (oils_xpath('//*[@tag="003"]/text()', marc))[1] ~* E'oclo?c' THEN
1294         qual := qual + 10;
1295     END IF;
1296
1297     RETURN qual;
1298
1299 END;
1300 $func$ LANGUAGE PLPGSQL;
1301
1302 CREATE OR REPLACE FUNCTION biblio.extract_fingerprint ( marc text ) RETURNS TEXT AS $func$
1303 DECLARE
1304         idx             config.biblio_fingerprint%ROWTYPE;
1305         xfrm            config.xml_transform%ROWTYPE;
1306         prev_xfrm       TEXT;
1307         transformed_xml TEXT;
1308         xml_node        TEXT;
1309         xml_node_list   TEXT[];
1310         raw_text        TEXT;
1311     output_text TEXT := '';
1312 BEGIN
1313
1314     IF marc IS NULL OR marc = '' THEN
1315         RETURN NULL;
1316     END IF;
1317
1318         -- Loop over the indexing entries
1319         FOR idx IN SELECT * FROM config.biblio_fingerprint ORDER BY format, id LOOP
1320
1321                 SELECT INTO xfrm * from config.xml_transform WHERE name = idx.format;
1322
1323                 -- See if we can skip the XSLT ... it's expensive
1324                 IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN
1325                         -- Can't skip the transform
1326                         IF xfrm.xslt <> '---' THEN
1327                                 transformed_xml := oils_xslt_process(marc,xfrm.xslt);
1328                         ELSE
1329                                 transformed_xml := marc;
1330                         END IF;
1331
1332                         prev_xfrm := xfrm.name;
1333                 END IF;
1334
1335                 raw_text := COALESCE(
1336             naco_normalize(
1337                 ARRAY_TO_STRING(
1338                     oils_xpath(
1339                         '//text()',
1340                         (oils_xpath(
1341                             idx.xpath,
1342                             transformed_xml,
1343                             ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]
1344                         ))[1]
1345                     ),
1346                     ''
1347                 )
1348             ),
1349             ''
1350         );
1351
1352         raw_text := REGEXP_REPLACE(raw_text, E'\\[.+?\\]', E'');
1353         raw_text := REGEXP_REPLACE(raw_text, E'\\mthe\\M|\\man?d?d\\M', E'', 'g'); -- arg! the pain!
1354
1355         IF idx.first_word IS TRUE THEN
1356             raw_text := REGEXP_REPLACE(raw_text, E'^(\\w+).*?$', E'\\1');
1357         END IF;
1358
1359                 output_text := output_text || idx.name || ':' ||
1360                                            REGEXP_REPLACE(raw_text, E'\\s+', '', 'g') || ' ';
1361
1362         END LOOP;
1363
1364     RETURN BTRIM(output_text);
1365
1366 END;
1367 $func$ LANGUAGE PLPGSQL;
1368
1369 -- BEFORE UPDATE OR INSERT trigger for biblio.record_entry
1370 CREATE OR REPLACE FUNCTION biblio.fingerprint_trigger () RETURNS TRIGGER AS $func$
1371 BEGIN
1372
1373     -- For TG_ARGV, first param is language (like 'eng'), second is record type (like 'BKS')
1374
1375     IF NEW.deleted IS TRUE THEN -- we don't much care, then, do we?
1376         RETURN NEW;
1377     END IF;
1378
1379     NEW.fingerprint := biblio.extract_fingerprint(NEW.marc);
1380     NEW.quality := biblio.extract_quality(NEW.marc, TG_ARGV[0], TG_ARGV[1]);
1381
1382     RETURN NEW;
1383
1384 END;
1385 $func$ LANGUAGE PLPGSQL;
1386
1387 CREATE OR REPLACE FUNCTION metabib.reingest_metabib_full_rec( bib_id BIGINT ) RETURNS VOID AS $func$
1388 BEGIN
1389     PERFORM * FROM config.internal_flag WHERE name = 'ingest.assume_inserts_only' AND enabled;
1390     IF NOT FOUND THEN
1391         DELETE FROM metabib.real_full_rec WHERE record = bib_id;
1392     END IF;
1393     INSERT INTO metabib.real_full_rec (record, tag, ind1, ind2, subfield, value)
1394         SELECT record, tag, ind1, ind2, subfield, value FROM biblio.flatten_marc( bib_id );
1395
1396     RETURN;
1397 END;
1398 $func$ LANGUAGE PLPGSQL;
1399
1400 CREATE OR REPLACE FUNCTION biblio.extract_located_uris( bib_id BIGINT, marcxml TEXT, editor_id INT ) RETURNS VOID AS $func$
1401 DECLARE
1402     uris            TEXT[];
1403     uri_xml         TEXT;
1404     uri_label       TEXT;
1405     uri_href        TEXT;
1406     uri_use         TEXT;
1407     uri_owner_list  TEXT[];
1408     uri_owner       TEXT;
1409     uri_owner_id    INT;
1410     uri_id          INT;
1411     uri_cn_id       INT;
1412     uri_map_id      INT;
1413     current_uri     INT;
1414     uri_map_count   INT;
1415     current_map_owner_list  INT[];
1416     orphaned_uri_list       INT[];
1417 BEGIN
1418
1419     uris := oils_xpath('//*[@tag="856" and (@ind1="4" or @ind1="1") and (@ind2="0" or @ind2="1")]',marcxml);
1420     IF ARRAY_UPPER(uris,1) > 0 THEN
1421         FOR i IN 1 .. ARRAY_UPPER(uris, 1) LOOP
1422             -- First we pull info out of the 856
1423             uri_xml     := uris[i];
1424
1425             uri_href    := (oils_xpath('//*[@code="u"]/text()',uri_xml))[1];
1426             uri_label   := (oils_xpath('//*[@code="y"]/text()|//*[@code="3"]/text()',uri_xml))[1];
1427             uri_use     := (oils_xpath('//*[@code="z"]/text()|//*[@code="2"]/text()|//*[@code="n"]/text()',uri_xml))[1];
1428
1429             IF uri_label IS NULL THEN
1430                 uri_label := uri_href;
1431             END IF;
1432             CONTINUE WHEN uri_href IS NULL;
1433
1434             -- Get the distinct list of libraries wanting to use
1435             SELECT  ARRAY_AGG(
1436                         DISTINCT REGEXP_REPLACE(
1437                             x,
1438                             $re$^.*?\((\w+)\).*$$re$,
1439                             E'\\1'
1440                         )
1441                     ) INTO uri_owner_list
1442               FROM  UNNEST(
1443                         oils_xpath(
1444                             '//*[@code="9"]/text()|//*[@code="w"]/text()|//*[@code="n"]/text()',
1445                             uri_xml
1446                         )
1447                     )x;
1448
1449             IF ARRAY_UPPER(uri_owner_list,1) > 0 THEN
1450
1451                 -- look for a matching uri
1452                 IF uri_use IS NULL THEN
1453                     SELECT id INTO uri_id
1454                         FROM asset.uri
1455                         WHERE label = uri_label AND href = uri_href AND use_restriction IS NULL AND active
1456                         ORDER BY id LIMIT 1;
1457                     IF NOT FOUND THEN -- create one
1458                         INSERT INTO asset.uri (label, href, use_restriction) VALUES (uri_label, uri_href, uri_use);
1459                         SELECT id INTO uri_id
1460                             FROM asset.uri
1461                             WHERE label = uri_label AND href = uri_href AND use_restriction IS NULL AND active;
1462                     END IF;
1463                 ELSE
1464                     SELECT id INTO uri_id
1465                         FROM asset.uri
1466                         WHERE label = uri_label AND href = uri_href AND use_restriction = uri_use AND active
1467                         ORDER BY id LIMIT 1;
1468                     IF NOT FOUND THEN -- create one
1469                         INSERT INTO asset.uri (label, href, use_restriction) VALUES (uri_label, uri_href, uri_use);
1470                         SELECT id INTO uri_id
1471                             FROM asset.uri
1472                             WHERE label = uri_label AND href = uri_href AND use_restriction = uri_use AND active;
1473                     END IF;
1474                 END IF;
1475
1476                 FOR j IN 1 .. ARRAY_UPPER(uri_owner_list, 1) LOOP
1477                     uri_owner := uri_owner_list[j];
1478
1479                     SELECT id INTO uri_owner_id FROM actor.org_unit WHERE shortname = BTRIM(REPLACE(uri_owner,chr(160),''));
1480                     CONTINUE WHEN NOT FOUND;
1481
1482                     -- we need a call number to link through
1483                     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;
1484                     IF NOT FOUND THEN
1485                         INSERT INTO asset.call_number (owning_lib, record, create_date, edit_date, creator, editor, label)
1486                             VALUES (uri_owner_id, bib_id, 'now', 'now', editor_id, editor_id, '##URI##');
1487                         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;
1488                     END IF;
1489
1490                     -- now, link them if they're not already
1491                     SELECT id INTO uri_map_id FROM asset.uri_call_number_map WHERE call_number = uri_cn_id AND uri = uri_id;
1492                     IF NOT FOUND THEN
1493                         INSERT INTO asset.uri_call_number_map (call_number, uri) VALUES (uri_cn_id, uri_id);
1494                     END IF;
1495
1496                     current_map_owner_list := current_map_owner_list || uri_cn_id
1497
1498                 END LOOP;
1499
1500             END IF;
1501
1502         END LOOP;
1503     END IF;
1504
1505     -- Clear any orphaned URIs, URI mappings and call
1506     -- numbers for this bib that weren't mapped above.
1507     FOR uri_cn_id IN
1508         SELECT  id
1509           FROM  asset.call_number
1510           WHERE record = bib_id
1511                 AND label = '##URI##'
1512                 AND NOT deleted
1513                 AND NOT (id = ANY (current_map_owner_list))
1514     LOOP
1515         -- Check for URIs to-be-orphaned URIs
1516         FOR current_uri IN
1517             SELECT  uri
1518               FROM  asset.uri_call_number_map
1519               WHERE call_number = uri_cn_id
1520         LOOP
1521             SELECT COUNT(*) INTO uri_map_count FROM asset.uri_call_number_map WHERE uri = current_uri;
1522             IF uri_map_count = 1 THEN -- only one means it's the last
1523                 orphaned_uri_list := orphaned_uri_list || current_uri;
1524             END IF;
1525         END LOOP;
1526         -- Remove links
1527         DELETE FROM asset.uri_call_number_map WHERE call_number = uri_cn_id;
1528         DELETE FROM asset.call_number WHERE id = uri_cn_id;
1529         DELETE FROM asset.uri WHERE id = ANY (orphaned_uri_list);
1530     END LOOP;
1531
1532     RETURN;
1533 END;
1534 $func$ LANGUAGE PLPGSQL;
1535
1536 CREATE OR REPLACE FUNCTION metabib.remap_metarecord_for_bib(
1537     bib_id bigint,
1538     fp text,
1539     bib_is_deleted boolean DEFAULT false,
1540     retain_deleted boolean DEFAULT false
1541 ) RETURNS bigint AS $function$
1542 DECLARE
1543     new_mapping     BOOL := TRUE;
1544     source_count    INT;
1545     old_mr          BIGINT;
1546     tmp_mr          metabib.metarecord%ROWTYPE;
1547     deleted_mrs     BIGINT[];
1548 BEGIN
1549
1550     -- We need to make sure we're not a deleted master record of an MR
1551     IF bib_is_deleted THEN
1552         IF NOT retain_deleted THEN -- Go away for any MR that we're master of, unless retained
1553             DELETE FROM metabib.metarecord_source_map WHERE source = bib_id;
1554         END IF;
1555
1556         FOR old_mr IN SELECT id FROM metabib.metarecord WHERE master_record = bib_id LOOP
1557
1558             -- Now, are there any more sources on this MR?
1559             SELECT COUNT(*) INTO source_count FROM metabib.metarecord_source_map WHERE metarecord = old_mr;
1560
1561             IF source_count = 0 AND NOT retain_deleted THEN -- No other records
1562                 deleted_mrs := ARRAY_APPEND(deleted_mrs, old_mr); -- Just in case...
1563                 DELETE FROM metabib.metarecord WHERE id = old_mr;
1564
1565             ELSE -- indeed there are. Update it with a null cache and recalcualated master record
1566                 UPDATE  metabib.metarecord
1567                   SET   mods = NULL,
1568                         master_record = ( SELECT id FROM biblio.record_entry WHERE fingerprint = fp AND NOT deleted ORDER BY quality DESC LIMIT 1)
1569                   WHERE id = old_mr;
1570             END IF;
1571         END LOOP;
1572
1573     ELSE -- insert or update
1574
1575         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
1576
1577             -- Find the first fingerprint-matching
1578             IF old_mr IS NULL AND fp = tmp_mr.fingerprint THEN
1579                 old_mr := tmp_mr.id;
1580                 new_mapping := FALSE;
1581
1582             ELSE -- Our fingerprint changed ... maybe remove the old MR
1583                 DELETE FROM metabib.metarecord_source_map WHERE metarecord = tmp_mr.id AND source = bib_id; -- remove the old source mapping
1584                 SELECT COUNT(*) INTO source_count FROM metabib.metarecord_source_map WHERE metarecord = tmp_mr.id;
1585                 IF source_count = 0 THEN -- No other records
1586                     deleted_mrs := ARRAY_APPEND(deleted_mrs, tmp_mr.id);
1587                     DELETE FROM metabib.metarecord WHERE id = tmp_mr.id;
1588                 END IF;
1589             END IF;
1590
1591         END LOOP;
1592
1593         -- we found no suitable, preexisting MR based on old source maps
1594         IF old_mr IS NULL THEN
1595             SELECT id INTO old_mr FROM metabib.metarecord WHERE fingerprint = fp; -- is there one for our current fingerprint?
1596
1597             IF old_mr IS NULL THEN -- nope, create one and grab its id
1598                 INSERT INTO metabib.metarecord ( fingerprint, master_record ) VALUES ( fp, bib_id );
1599                 SELECT id INTO old_mr FROM metabib.metarecord WHERE fingerprint = fp;
1600
1601             ELSE -- indeed there is. update it with a null cache and recalcualated master record
1602                 UPDATE  metabib.metarecord
1603                   SET   mods = NULL,
1604                         master_record = ( SELECT id FROM biblio.record_entry WHERE fingerprint = fp AND NOT deleted ORDER BY quality DESC LIMIT 1)
1605                   WHERE id = old_mr;
1606             END IF;
1607
1608         ELSE -- there was one we already attached to, update its mods cache and master_record
1609             UPDATE  metabib.metarecord
1610               SET   mods = NULL,
1611                     master_record = ( SELECT id FROM biblio.record_entry WHERE fingerprint = fp AND NOT deleted ORDER BY quality DESC LIMIT 1)
1612               WHERE id = old_mr;
1613         END IF;
1614
1615         IF new_mapping THEN
1616             INSERT INTO metabib.metarecord_source_map (metarecord, source) VALUES (old_mr, bib_id); -- new source mapping
1617         END IF;
1618
1619     END IF;
1620
1621     IF ARRAY_UPPER(deleted_mrs,1) > 0 THEN
1622         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
1623     END IF;
1624
1625     RETURN old_mr;
1626
1627 END;
1628 $function$ LANGUAGE plpgsql;
1629
1630 CREATE OR REPLACE FUNCTION biblio.map_authority_linking (bibid BIGINT, marc TEXT) RETURNS BIGINT AS $func$
1631     DELETE FROM authority.bib_linking WHERE bib = $1;
1632     INSERT INTO authority.bib_linking (bib, authority)
1633         SELECT  y.bib,
1634                 y.authority
1635           FROM (    SELECT  DISTINCT $1 AS bib,
1636                             BTRIM(remove_paren_substring(txt))::BIGINT AS authority
1637                       FROM  unnest(oils_xpath('//*[@code="0"]/text()',$2)) x(txt)
1638                       WHERE BTRIM(remove_paren_substring(txt)) ~ $re$^\d+$$re$
1639                 ) y JOIN authority.record_entry r ON r.id = y.authority;
1640     SELECT $1;
1641 $func$ LANGUAGE SQL;
1642
1643 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$
1644 DECLARE
1645     transformed_xml TEXT;
1646     rmarc           TEXT := prmarc;
1647     tmp_val         TEXT;
1648     prev_xfrm       TEXT;
1649     normalizer      RECORD;
1650     xfrm            config.xml_transform%ROWTYPE;
1651     attr_vector     INT[] := '{}'::INT[];
1652     attr_vector_tmp INT[];
1653     attr_list       TEXT[] := pattr_list;
1654     attr_value      TEXT[];
1655     norm_attr_value TEXT[];
1656     tmp_xml         TEXT;
1657     tmp_array       TEXT[];
1658     attr_def        config.record_attr_definition%ROWTYPE;
1659     ccvm_row        config.coded_value_map%ROWTYPE;
1660     jump_past       BOOL;
1661 BEGIN
1662
1663     IF attr_list IS NULL OR rdeleted THEN -- need to do the full dance on INSERT or undelete
1664         SELECT ARRAY_AGG(name) INTO attr_list FROM config.record_attr_definition
1665         WHERE (
1666             tag IS NOT NULL OR
1667             fixed_field IS NOT NULL OR
1668             xpath IS NOT NULL OR
1669             phys_char_sf IS NOT NULL OR
1670             composite
1671         ) AND (
1672             filter OR sorter
1673         );
1674     END IF;
1675
1676     IF rmarc IS NULL THEN
1677         SELECT marc INTO rmarc FROM biblio.record_entry WHERE id = rid;
1678     END IF;
1679
1680     FOR attr_def IN SELECT * FROM config.record_attr_definition WHERE NOT composite AND name = ANY( attr_list ) ORDER BY format LOOP
1681
1682         jump_past := FALSE; -- This gets set when we are non-multi and have found something
1683         attr_value := '{}'::TEXT[];
1684         norm_attr_value := '{}'::TEXT[];
1685         attr_vector_tmp := '{}'::INT[];
1686
1687         SELECT * INTO ccvm_row FROM config.coded_value_map c WHERE c.ctype = attr_def.name LIMIT 1;
1688
1689         IF attr_def.tag IS NOT NULL THEN -- tag (and optional subfield list) selection
1690             SELECT  ARRAY_AGG(value) INTO attr_value
1691               FROM  (SELECT * FROM metabib.full_rec ORDER BY tag, subfield) AS x
1692               WHERE record = rid
1693                     AND tag LIKE attr_def.tag
1694                     AND CASE
1695                         WHEN attr_def.sf_list IS NOT NULL
1696                             THEN POSITION(subfield IN attr_def.sf_list) > 0
1697                         ELSE TRUE
1698                     END
1699               GROUP BY tag
1700               ORDER BY tag;
1701
1702             IF NOT attr_def.multi THEN
1703                 attr_value := ARRAY[ARRAY_TO_STRING(attr_value, COALESCE(attr_def.joiner,' '))];
1704                 jump_past := TRUE;
1705             END IF;
1706         END IF;
1707
1708         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
1709             attr_value := attr_value || vandelay.marc21_extract_fixed_field_list(rmarc, attr_def.fixed_field);
1710
1711             IF NOT attr_def.multi THEN
1712                 attr_value := ARRAY[attr_value[1]];
1713                 jump_past := TRUE;
1714             END IF;
1715         END IF;
1716
1717         IF NOT jump_past AND attr_def.xpath IS NOT NULL THEN -- and xpath expression
1718
1719             SELECT INTO xfrm * FROM config.xml_transform WHERE name = attr_def.format;
1720
1721             -- See if we can skip the XSLT ... it's expensive
1722             IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN
1723                 -- Can't skip the transform
1724                 IF xfrm.xslt <> '---' THEN
1725                     transformed_xml := oils_xslt_process(rmarc,xfrm.xslt);
1726                 ELSE
1727                     transformed_xml := rmarc;
1728                 END IF;
1729
1730                 prev_xfrm := xfrm.name;
1731             END IF;
1732
1733             IF xfrm.name IS NULL THEN
1734                 -- just grab the marcxml (empty) transform
1735                 SELECT INTO xfrm * FROM config.xml_transform WHERE xslt = '---' LIMIT 1;
1736                 prev_xfrm := xfrm.name;
1737             END IF;
1738
1739             FOR tmp_xml IN SELECT UNNEST(oils_xpath(attr_def.xpath, transformed_xml, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]])) LOOP
1740                 tmp_val := oils_xpath_string(
1741                                 '//*',
1742                                 tmp_xml,
1743                                 COALESCE(attr_def.joiner,' '),
1744                                 ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]
1745                             );
1746                 IF tmp_val IS NOT NULL AND BTRIM(tmp_val) <> '' THEN
1747                     attr_value := attr_value || tmp_val;
1748                     EXIT WHEN NOT attr_def.multi;
1749                 END IF;
1750             END LOOP;
1751         END IF;
1752
1753         IF NOT jump_past AND attr_def.phys_char_sf IS NOT NULL THEN -- a named Physical Characteristic, see config.marc21_physical_characteristic_*_map
1754             SELECT  ARRAY_AGG(m.value) INTO tmp_array
1755               FROM  vandelay.marc21_physical_characteristics(rmarc) v
1756                     LEFT JOIN config.marc21_physical_characteristic_value_map m ON (m.id = v.value)
1757               WHERE v.subfield = attr_def.phys_char_sf AND (m.value IS NOT NULL AND BTRIM(m.value) <> '')
1758                     AND ( ccvm_row.id IS NULL OR ( ccvm_row.id IS NOT NULL AND v.id IS NOT NULL) );
1759
1760             attr_value := attr_value || tmp_array;
1761
1762             IF NOT attr_def.multi THEN
1763                 attr_value := ARRAY[attr_value[1]];
1764             END IF;
1765
1766         END IF;
1767
1768                 -- apply index normalizers to attr_value
1769         FOR tmp_val IN SELECT value FROM UNNEST(attr_value) x(value) LOOP
1770             FOR normalizer IN
1771                 SELECT  n.func AS func,
1772                         n.param_count AS param_count,
1773                         m.params AS params
1774                   FROM  config.index_normalizer n
1775                         JOIN config.record_attr_index_norm_map m ON (m.norm = n.id)
1776                   WHERE attr = attr_def.name
1777                   ORDER BY m.pos LOOP
1778                     EXECUTE 'SELECT ' || normalizer.func || '(' ||
1779                     COALESCE( quote_literal( tmp_val ), 'NULL' ) ||
1780                         CASE
1781                             WHEN normalizer.param_count > 0
1782                                 THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
1783                                 ELSE ''
1784                             END ||
1785                     ')' INTO tmp_val;
1786
1787             END LOOP;
1788             IF tmp_val IS NOT NULL AND tmp_val <> '' THEN
1789                 -- note that a string that contains only blanks
1790                 -- is a valid value for some attributes
1791                 norm_attr_value := norm_attr_value || tmp_val;
1792             END IF;
1793         END LOOP;
1794
1795         IF attr_def.filter THEN
1796             -- Create unknown uncontrolled values and find the IDs of the values
1797             IF ccvm_row.id IS NULL THEN
1798                 FOR tmp_val IN SELECT value FROM UNNEST(norm_attr_value) x(value) LOOP
1799                     IF tmp_val IS NOT NULL AND BTRIM(tmp_val) <> '' THEN
1800                         BEGIN -- use subtransaction to isolate unique constraint violations
1801                             INSERT INTO metabib.uncontrolled_record_attr_value ( attr, value ) VALUES ( attr_def.name, tmp_val );
1802                         EXCEPTION WHEN unique_violation THEN END;
1803                     END IF;
1804                 END LOOP;
1805
1806                 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 );
1807             ELSE
1808                 SELECT ARRAY_AGG(id) INTO attr_vector_tmp FROM config.coded_value_map WHERE ctype = attr_def.name AND code = ANY( norm_attr_value );
1809             END IF;
1810
1811             -- Add the new value to the vector
1812             attr_vector := attr_vector || attr_vector_tmp;
1813         END IF;
1814
1815         IF attr_def.sorter THEN
1816             DELETE FROM metabib.record_sorter WHERE source = rid AND attr = attr_def.name;
1817             IF norm_attr_value[1] IS NOT NULL THEN
1818                 INSERT INTO metabib.record_sorter (source, attr, value) VALUES (rid, attr_def.name, norm_attr_value[1]);
1819             END IF;
1820         END IF;
1821
1822     END LOOP;
1823
1824 /* We may need to rewrite the vlist to contain
1825    the intersection of new values for requested
1826    attrs and old values for ignored attrs. To
1827    do this, we take the old attr vlist and
1828    subtract any values that are valid for the
1829    requested attrs, and then add back the new
1830    set of attr values. */
1831
1832     IF ARRAY_LENGTH(pattr_list, 1) > 0 THEN
1833         SELECT vlist INTO attr_vector_tmp FROM metabib.record_attr_vector_list WHERE source = rid;
1834         SELECT attr_vector_tmp - ARRAY_AGG(id::INT) INTO attr_vector_tmp FROM metabib.full_attr_id_map WHERE attr = ANY (pattr_list);
1835         attr_vector := attr_vector || attr_vector_tmp;
1836     END IF;
1837
1838     -- On to composite attributes, now that the record attrs have been pulled.  Processed in name order, so later composite
1839     -- attributes can depend on earlier ones.
1840     PERFORM metabib.compile_composite_attr_cache_init();
1841     FOR attr_def IN SELECT * FROM config.record_attr_definition WHERE composite AND name = ANY( attr_list ) ORDER BY name LOOP
1842
1843         FOR ccvm_row IN SELECT * FROM config.coded_value_map c WHERE c.ctype = attr_def.name ORDER BY value LOOP
1844
1845             tmp_val := metabib.compile_composite_attr( ccvm_row.id );
1846             CONTINUE WHEN tmp_val IS NULL OR tmp_val = ''; -- nothing to do
1847
1848             IF attr_def.filter THEN
1849                 IF attr_vector @@ tmp_val::query_int THEN
1850                     attr_vector = attr_vector + intset(ccvm_row.id);
1851                     EXIT WHEN NOT attr_def.multi;
1852                 END IF;
1853             END IF;
1854
1855             IF attr_def.sorter THEN
1856                 IF attr_vector @@ tmp_val THEN
1857                     DELETE FROM metabib.record_sorter WHERE source = rid AND attr = attr_def.name;
1858                     INSERT INTO metabib.record_sorter (source, attr, value) VALUES (rid, attr_def.name, ccvm_row.code);
1859                 END IF;
1860             END IF;
1861
1862         END LOOP;
1863
1864     END LOOP;
1865
1866     IF ARRAY_LENGTH(attr_vector, 1) > 0 THEN
1867         IF rdeleted THEN -- initial insert OR revivication
1868             DELETE FROM metabib.record_attr_vector_list WHERE source = rid;
1869             INSERT INTO metabib.record_attr_vector_list (source, vlist) VALUES (rid, attr_vector);
1870         ELSE
1871             UPDATE metabib.record_attr_vector_list SET vlist = attr_vector WHERE source = rid;
1872         END IF;
1873     END IF;
1874
1875 END;
1876
1877 $func$ LANGUAGE PLPGSQL;
1878
1879
1880 -- AFTER UPDATE OR INSERT trigger for biblio.record_entry
1881 CREATE OR REPLACE FUNCTION biblio.indexing_ingest_or_delete () RETURNS TRIGGER AS $func$
1882 DECLARE
1883     tmp_bool BOOL;
1884 BEGIN
1885
1886     IF NEW.deleted THEN -- If this bib is deleted
1887
1888         PERFORM * FROM config.internal_flag WHERE
1889             name = 'ingest.metarecord_mapping.preserve_on_delete' AND enabled;
1890
1891         tmp_bool := FOUND; -- Just in case this is changed by some other statement
1892
1893         PERFORM metabib.remap_metarecord_for_bib( NEW.id, NEW.fingerprint, TRUE, tmp_bool );
1894
1895         IF NOT tmp_bool THEN
1896             -- One needs to keep these around to support searches
1897             -- with the #deleted modifier, so one should turn on the named
1898             -- internal flag for that functionality.
1899             DELETE FROM metabib.record_attr_vector_list WHERE source = NEW.id;
1900         END IF;
1901
1902         DELETE FROM authority.bib_linking WHERE bib = NEW.id; -- Avoid updating fields in bibs that are no longer visible
1903         DELETE FROM biblio.peer_bib_copy_map WHERE peer_record = NEW.id; -- Separate any multi-homed items
1904         DELETE FROM metabib.browse_entry_def_map WHERE source = NEW.id; -- Don't auto-suggest deleted bibs
1905         RETURN NEW; -- and we're done
1906     END IF;
1907
1908     IF TG_OP = 'UPDATE' AND OLD.deleted IS FALSE THEN -- re-ingest?
1909         PERFORM * FROM config.internal_flag WHERE name = 'ingest.reingest.force_on_same_marc' AND enabled;
1910
1911         IF NOT FOUND AND OLD.marc = NEW.marc THEN -- don't do anything if the MARC didn't change
1912             RETURN NEW;
1913         END IF;
1914     END IF;
1915
1916     -- Record authority linking
1917     PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_authority_linking' AND enabled;
1918     IF NOT FOUND THEN
1919         PERFORM biblio.map_authority_linking( NEW.id, NEW.marc );
1920     END IF;
1921
1922     -- Flatten and insert the mfr data
1923     PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_metabib_full_rec' AND enabled;
1924     IF NOT FOUND THEN
1925         PERFORM metabib.reingest_metabib_full_rec(NEW.id);
1926
1927         -- Now we pull out attribute data, which is dependent on the mfr for all but XPath-based fields
1928         PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_metabib_rec_descriptor' AND enabled;
1929         IF NOT FOUND THEN
1930             PERFORM metabib.reingest_record_attributes(NEW.id, NULL, NEW.marc, TG_OP = 'INSERT' OR OLD.deleted);
1931         END IF;
1932     END IF;
1933
1934     -- Gather and insert the field entry data
1935     PERFORM metabib.reingest_metabib_field_entries(NEW.id);
1936
1937     -- Located URI magic
1938     PERFORM * FROM config.internal_flag WHERE name = 'ingest.disable_located_uri' AND enabled;
1939     IF NOT FOUND THEN PERFORM biblio.extract_located_uris( NEW.id, NEW.marc, NEW.editor ); END IF;
1940
1941     -- (re)map metarecord-bib linking
1942     IF TG_OP = 'INSERT' THEN -- if not deleted and performing an insert, check for the flag
1943         PERFORM * FROM config.internal_flag WHERE name = 'ingest.metarecord_mapping.skip_on_insert' AND enabled;
1944         IF NOT FOUND THEN
1945             PERFORM metabib.remap_metarecord_for_bib( NEW.id, NEW.fingerprint );
1946         END IF;
1947     ELSE -- we're doing an update, and we're not deleted, remap
1948         PERFORM * FROM config.internal_flag WHERE name = 'ingest.metarecord_mapping.skip_on_update' AND enabled;
1949         IF NOT FOUND THEN
1950             PERFORM metabib.remap_metarecord_for_bib( NEW.id, NEW.fingerprint );
1951         END IF;
1952     END IF;
1953
1954     RETURN NEW;
1955 END;
1956 $func$ LANGUAGE PLPGSQL;
1957
1958 CREATE OR REPLACE FUNCTION metabib.browse_normalize(facet_text TEXT, mapped_field INT) RETURNS TEXT AS $$
1959 DECLARE
1960     normalizer  RECORD;
1961 BEGIN
1962
1963     FOR normalizer IN
1964         SELECT  n.func AS func,
1965                 n.param_count AS param_count,
1966                 m.params AS params
1967           FROM  config.index_normalizer n
1968                 JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
1969           WHERE m.field = mapped_field AND m.pos < 0
1970           ORDER BY m.pos LOOP
1971
1972             EXECUTE 'SELECT ' || normalizer.func || '(' ||
1973                 quote_literal( facet_text ) ||
1974                 CASE
1975                     WHEN normalizer.param_count > 0
1976                         THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
1977                         ELSE ''
1978                     END ||
1979                 ')' INTO facet_text;
1980
1981     END LOOP;
1982
1983     RETURN facet_text;
1984 END;
1985
1986 $$ LANGUAGE PLPGSQL;
1987
1988
1989 -- This mimics a specific part of QueryParser, turning the first part of a
1990 -- classed search (search_class) into a set of classes and possibly fields.
1991 -- search_class might look like "author" or "title|proper" or "ti|uniform"
1992 -- or "au" or "au|corporate|personal" or anything like that, where the first
1993 -- element of the list you get by separating on the "|" character is either
1994 -- a registered class (config.metabib_class) or an alias
1995 -- (config.metabib_search_alias), and the rest of any such elements are
1996 -- fields (config.metabib_field).
1997 CREATE OR REPLACE
1998     FUNCTION metabib.search_class_to_registered_components(search_class TEXT)
1999     RETURNS SETOF RECORD AS $func$
2000 DECLARE
2001     search_parts        TEXT[];
2002     field_name          TEXT;
2003     search_part_count   INTEGER;
2004     rec                 RECORD;
2005     registered_class    config.metabib_class%ROWTYPE;
2006     registered_alias    config.metabib_search_alias%ROWTYPE;
2007     registered_field    config.metabib_field%ROWTYPE;
2008 BEGIN
2009     search_parts := REGEXP_SPLIT_TO_ARRAY(search_class, E'\\|');
2010
2011     search_part_count := ARRAY_LENGTH(search_parts, 1);
2012     IF search_part_count = 0 THEN
2013         RETURN;
2014     ELSE
2015         SELECT INTO registered_class
2016             * FROM config.metabib_class WHERE name = search_parts[1];
2017         IF FOUND THEN
2018             IF search_part_count < 2 THEN   -- all fields
2019                 rec := (registered_class.name, NULL::INTEGER);
2020                 RETURN NEXT rec;
2021                 RETURN; -- done
2022             END IF;
2023             FOR field_name IN SELECT *
2024                 FROM UNNEST(search_parts[2:search_part_count]) LOOP
2025                 SELECT INTO registered_field
2026                     * FROM config.metabib_field
2027                     WHERE name = field_name AND
2028                         field_class = registered_class.name;
2029                 IF FOUND THEN
2030                     rec := (registered_class.name, registered_field.id);
2031                     RETURN NEXT rec;
2032                 END IF;
2033             END LOOP;
2034         ELSE
2035             -- maybe we have an alias?
2036             SELECT INTO registered_alias
2037                 * FROM config.metabib_search_alias WHERE alias=search_parts[1];
2038             IF NOT FOUND THEN
2039                 RETURN;
2040             ELSE
2041                 IF search_part_count < 2 THEN   -- return w/e the alias says
2042                     rec := (
2043                         registered_alias.field_class, registered_alias.field
2044                     );
2045                     RETURN NEXT rec;
2046                     RETURN; -- done
2047                 ELSE
2048                     FOR field_name IN SELECT *
2049                         FROM UNNEST(search_parts[2:search_part_count]) LOOP
2050                         SELECT INTO registered_field
2051                             * FROM config.metabib_field
2052                             WHERE name = field_name AND
2053                                 field_class = registered_alias.field_class;
2054                         IF FOUND THEN
2055                             rec := (
2056                                 registered_alias.field_class,
2057                                 registered_field.id
2058                             );
2059                             RETURN NEXT rec;
2060                         END IF;
2061                     END LOOP;
2062                 END IF;
2063             END IF;
2064         END IF;
2065     END IF;
2066 END;
2067 $func$ LANGUAGE PLPGSQL ROWS 1;
2068
2069
2070 -- Given a string such as a user might type into a search box, prepare
2071 -- two changed variants for TO_TSQUERY(). See
2072 -- http://www.postgresql.org/docs/9.0/static/textsearch-controls.html
2073 -- The first variant is normalized to match indexed documents regardless
2074 -- of diacritics.  The second variant keeps its diacritics for proper
2075 -- highlighting via TS_HEADLINE().
2076 CREATE OR REPLACE
2077     FUNCTION metabib.autosuggest_prepare_tsquery(orig TEXT) RETURNS TEXT[] AS
2078 $$
2079 DECLARE
2080     orig_ended_in_space     BOOLEAN;
2081     result                  RECORD;
2082     plain                   TEXT;
2083     normalized              TEXT;
2084 BEGIN
2085     orig_ended_in_space := orig ~ E'\\s$';
2086
2087     orig := ARRAY_TO_STRING(
2088         evergreen.regexp_split_to_array(orig, E'\\W+'), ' '
2089     );
2090
2091     normalized := public.naco_normalize(orig); -- also trim()s
2092     plain := trim(orig);
2093
2094     IF NOT orig_ended_in_space THEN
2095         plain := plain || ':*';
2096         normalized := normalized || ':*';
2097     END IF;
2098
2099     plain := ARRAY_TO_STRING(
2100         evergreen.regexp_split_to_array(plain, E'\\s+'), ' & '
2101     );
2102     normalized := ARRAY_TO_STRING(
2103         evergreen.regexp_split_to_array(normalized, E'\\s+'), ' & '
2104     );
2105
2106     RETURN ARRAY[normalized, plain];
2107 END;
2108 $$ LANGUAGE PLPGSQL;
2109
2110 -- Functions metabib.browse, metabib.staged_browse, and metabib.suggest_browse_entries
2111 -- will be created later, after internal dependencies are resolved.
2112
2113 CREATE OR REPLACE FUNCTION public.oils_tsearch2 () RETURNS TRIGGER AS $$
2114 DECLARE
2115     normalizer      RECORD;
2116     value           TEXT := '';
2117     temp_vector     TEXT := '';
2118     ts_rec          RECORD;
2119     cur_weight      "char";
2120 BEGIN
2121
2122     value := NEW.value;
2123     NEW.index_vector = ''::tsvector;
2124
2125     IF TG_TABLE_NAME::TEXT ~ 'field_entry$' THEN
2126         FOR normalizer IN
2127             SELECT  n.func AS func,
2128                     n.param_count AS param_count,
2129                     m.params AS params
2130               FROM  config.index_normalizer n
2131                     JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
2132               WHERE field = NEW.field AND m.pos < 0
2133               ORDER BY m.pos LOOP
2134                 EXECUTE 'SELECT ' || normalizer.func || '(' ||
2135                     quote_literal( value ) ||
2136                     CASE
2137                         WHEN normalizer.param_count > 0
2138                             THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
2139                             ELSE ''
2140                         END ||
2141                     ')' INTO value;
2142
2143         END LOOP;
2144
2145         NEW.value = value;
2146
2147         FOR normalizer IN
2148             SELECT  n.func AS func,
2149                     n.param_count AS param_count,
2150                     m.params AS params
2151               FROM  config.index_normalizer n
2152                     JOIN config.metabib_field_index_norm_map m ON (m.norm = n.id)
2153               WHERE field = NEW.field AND m.pos >= 0
2154               ORDER BY m.pos LOOP
2155                 EXECUTE 'SELECT ' || normalizer.func || '(' ||
2156                     quote_literal( value ) ||
2157                     CASE
2158                         WHEN normalizer.param_count > 0
2159                             THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'')
2160                             ELSE ''
2161                         END ||
2162                     ')' INTO value;
2163
2164         END LOOP;
2165    END IF;
2166
2167     IF TG_TABLE_NAME::TEXT ~ 'browse_entry$' THEN
2168
2169         value :=  ARRAY_TO_STRING(
2170             evergreen.regexp_split_to_array(value, E'\\W+'), ' '
2171         );
2172         value := public.search_normalize(value);
2173         NEW.index_vector = to_tsvector(TG_ARGV[0]::regconfig, value);
2174
2175     ELSIF TG_TABLE_NAME::TEXT ~ 'field_entry$' THEN
2176         FOR ts_rec IN
2177
2178             SELECT DISTINCT m.ts_config, m.index_weight
2179             FROM config.metabib_class_ts_map m
2180                  LEFT JOIN metabib.record_attr_vector_list r ON (r.source = NEW.source)
2181                  LEFT JOIN config.coded_value_map ccvm ON (
2182                     ccvm.ctype IN ('item_lang', 'language') AND
2183                     ccvm.code = m.index_lang AND
2184                     r.vlist @> intset(ccvm.id)
2185                 )
2186             WHERE m.field_class = TG_ARGV[0]
2187                 AND m.active
2188                 AND (m.always OR NOT EXISTS (SELECT 1 FROM config.metabib_field_ts_map WHERE metabib_field = NEW.field))
2189                 AND (m.index_lang IS NULL OR ccvm.id IS NOT NULL)
2190                         UNION
2191             SELECT DISTINCT m.ts_config, m.index_weight
2192             FROM config.metabib_field_ts_map m
2193                  LEFT JOIN metabib.record_attr_vector_list r ON (r.source = NEW.source)
2194                  LEFT JOIN config.coded_value_map ccvm ON (
2195                     ccvm.ctype IN ('item_lang', 'language') AND
2196                     ccvm.code = m.index_lang AND
2197                     r.vlist @> intset(ccvm.id)
2198                 )
2199             WHERE m.metabib_field = NEW.field
2200                 AND m.active
2201                 AND (m.index_lang IS NULL OR ccvm.id IS NOT NULL)
2202             ORDER BY index_weight ASC
2203
2204         LOOP
2205
2206             IF cur_weight IS NOT NULL AND cur_weight != ts_rec.index_weight THEN
2207                 NEW.index_vector = NEW.index_vector || setweight(temp_vector::tsvector,cur_weight);
2208                 temp_vector = '';
2209             END IF;
2210
2211             cur_weight = ts_rec.index_weight;
2212             SELECT INTO temp_vector temp_vector || ' ' || to_tsvector(ts_rec.ts_config::regconfig, value)::TEXT;
2213
2214         END LOOP;
2215         NEW.index_vector = NEW.index_vector || setweight(temp_vector::tsvector,cur_weight);
2216     ELSE
2217         NEW.index_vector = to_tsvector(TG_ARGV[0]::regconfig, value);
2218     END IF;
2219
2220     RETURN NEW;
2221 END;
2222 $$ LANGUAGE PLPGSQL;
2223
2224
2225 CREATE TYPE metabib.flat_browse_entry_appearance AS (
2226     browse_entry    BIGINT,
2227     value           TEXT,
2228     fields          TEXT,
2229     authorities     TEXT,
2230     sees            TEXT,
2231     sources         INT,        -- visible ones, that is
2232     asources        INT,        -- visible ones, that is
2233     row_number      INT,        -- internal use, sort of
2234     accurate        BOOL,       -- Count in sources field is accurate? Not
2235                                 -- if we had more than a browse superpage
2236                                 -- of records to look at.
2237     aaccurate       BOOL,       -- See previous comment...
2238     pivot_point     BIGINT
2239 );
2240
2241
2242 CREATE OR REPLACE FUNCTION metabib.browse_bib_pivot(
2243     INT[],
2244     TEXT
2245 ) RETURNS BIGINT AS $p$
2246     SELECT  mbe.id
2247       FROM  metabib.browse_entry mbe
2248             JOIN metabib.browse_entry_def_map mbedm ON (
2249                 mbedm.entry = mbe.id
2250                 AND mbedm.def = ANY($1)
2251             )
2252       WHERE mbe.sort_value >= public.naco_normalize($2)
2253       ORDER BY mbe.sort_value, mbe.value LIMIT 1;
2254 $p$ LANGUAGE SQL STABLE;
2255
2256 CREATE OR REPLACE FUNCTION metabib.browse_authority_pivot(
2257     INT[],
2258     TEXT
2259 ) RETURNS BIGINT AS $p$
2260     SELECT  mbe.id
2261       FROM  metabib.browse_entry mbe
2262             JOIN metabib.browse_entry_simple_heading_map mbeshm ON ( mbeshm.entry = mbe.id )
2263             JOIN authority.simple_heading ash ON ( mbeshm.simple_heading = ash.id )
2264             JOIN authority.control_set_auth_field_metabib_field_map_refs map ON (
2265                 ash.atag = map.authority_field
2266                 AND map.metabib_field = ANY($1)
2267             )
2268       WHERE mbe.sort_value >= public.naco_normalize($2)
2269       ORDER BY mbe.sort_value, mbe.value LIMIT 1;
2270 $p$ LANGUAGE SQL STABLE;
2271
2272 CREATE OR REPLACE FUNCTION metabib.browse_authority_refs_pivot(
2273     INT[],
2274     TEXT
2275 ) RETURNS BIGINT AS $p$
2276     SELECT  mbe.id
2277       FROM  metabib.browse_entry mbe
2278             JOIN metabib.browse_entry_simple_heading_map mbeshm ON ( mbeshm.entry = mbe.id )
2279             JOIN authority.simple_heading ash ON ( mbeshm.simple_heading = ash.id )
2280             JOIN authority.control_set_auth_field_metabib_field_map_refs_only map ON (
2281                 ash.atag = map.authority_field
2282                 AND map.metabib_field = ANY($1)
2283             )
2284       WHERE mbe.sort_value >= public.naco_normalize($2)
2285       ORDER BY mbe.sort_value, mbe.value LIMIT 1;
2286 $p$ LANGUAGE SQL STABLE;
2287
2288 CREATE OR REPLACE FUNCTION metabib.browse_pivot(
2289     INT[],
2290     TEXT
2291 ) RETURNS BIGINT AS $p$
2292     SELECT  id FROM metabib.browse_entry
2293       WHERE id IN (
2294                 metabib.browse_bib_pivot($1, $2),
2295                 metabib.browse_authority_refs_pivot($1,$2) -- only look in 4xx, 5xx, 7xx of authority
2296             )
2297       ORDER BY sort_value, value LIMIT 1;
2298 $p$ LANGUAGE SQL STABLE;
2299
2300
2301 -- This function is used to help clean up facet labels. Due to quirks in
2302 -- MARC parsing, some facet labels may be generated with periods or commas
2303 -- at the end.  This will strip a trailing commas off all the time, and
2304 -- periods when they don't look like they are part of initials.
2305 --      Smith, John    =>  no change
2306 --      Smith, John,   =>  Smith, John
2307 --      Smith, John.   =>  Smith, John
2308 --      Public, John Q. => no change
2309 CREATE OR REPLACE FUNCTION metabib.trim_trailing_punctuation ( TEXT ) RETURNS TEXT AS $$
2310 DECLARE
2311     result    TEXT;
2312     last_char TEXT;
2313 BEGIN
2314     result := $1;
2315     last_char = substring(result from '.$');
2316
2317     IF last_char = ',' THEN
2318         result := substring(result from '^(.*),$');
2319
2320     ELSIF last_char = '.' THEN
2321         IF substring(result from ' \w\.$') IS NULL THEN
2322             result := substring(result from '^(.*)\.$');
2323         END IF;
2324     END IF;
2325
2326     RETURN result;
2327
2328 END;
2329 $$ language 'plpgsql';
2330
2331 COMMIT;
2332