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