Open-ILS/src/sql/Pg/030.schema.metabib.sql

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