Open-ILS/src/sql/Pg/upgrade/1298.schema.case-insensitive-browse-field-match.sql

   1 BEGIN;
   2
   3 SELECT evergreen.upgrade_deps_block_check('1298', :eg_version);
   4
   5 ALTER TYPE metabib.field_entry_template ADD ATTRIBUTE browse_nocase BOOL CASCADE;
   6
   7 ALTER TABLE config.metabib_field ADD COLUMN browse_nocase BOOL NOT NULL DEFAULT FALSE;
   8
   9 CREATE OR REPLACE FUNCTION biblio.extract_metabib_field_entry (
  10     rid BIGINT,
  11     default_joiner TEXT,
  12     field_types TEXT[],
  13     only_fields INT[]
  14 ) RETURNS SETOF metabib.field_entry_template AS $func$
  15 DECLARE
  16     bib     biblio.record_entry%ROWTYPE;
  17     idx     config.metabib_field%ROWTYPE;
  18     xfrm        config.xml_transform%ROWTYPE;
  19     prev_xfrm   TEXT;
  20     transformed_xml TEXT;
  21     xml_node    TEXT;
  22     xml_node_list   TEXT[];
  23     facet_text  TEXT;
  24     display_text TEXT;
  25     browse_text TEXT;
  26     sort_value  TEXT;
  27     raw_text    TEXT;
  28     curr_text   TEXT;
  29     joiner      TEXT := default_joiner; -- XXX will index defs supply a joiner?
  30     authority_text TEXT;
  31     authority_link BIGINT;
  32     output_row  metabib.field_entry_template%ROWTYPE;
  33     process_idx BOOL;
  34 BEGIN
  35
  36     -- Start out with no field-use bools set
  37     output_row.browse_nocase = FALSE;
  38     output_row.browse_field = FALSE;
  39     output_row.facet_field = FALSE;
  40     output_row.display_field = FALSE;
  41     output_row.search_field = FALSE;
  42
  43     -- Get the record
  44     SELECT INTO bib * FROM biblio.record_entry WHERE id = rid;
  45
  46     -- Loop over the indexing entries
  47     FOR idx IN SELECT * FROM config.metabib_field WHERE id = ANY (only_fields) ORDER BY format LOOP
  48         CONTINUE WHEN idx.xpath IS NULL OR idx.xpath = ''; -- pure virtual field
  49
  50         process_idx := FALSE;
  51         IF idx.display_field AND 'display' = ANY (field_types) THEN process_idx = TRUE; END IF;
  52         IF idx.browse_field AND 'browse' = ANY (field_types) THEN process_idx = TRUE; END IF;
  53         IF idx.search_field AND 'search' = ANY (field_types) THEN process_idx = TRUE; END IF;
  54         IF idx.facet_field AND 'facet' = ANY (field_types) THEN process_idx = TRUE; END IF;
  55         CONTINUE WHEN process_idx = FALSE; -- disabled for all types
  56
  57         joiner := COALESCE(idx.joiner, default_joiner);
  58
  59         SELECT INTO xfrm * from config.xml_transform WHERE name = idx.format;
  60
  61         -- See if we can skip the XSLT ... it's expensive
  62         IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN
  63             -- Can't skip the transform
  64             IF xfrm.xslt <> '---' THEN
  65                 transformed_xml := oils_xslt_process(bib.marc,xfrm.xslt);
  66             ELSE
  67                 transformed_xml := bib.marc;
  68             END IF;
  69
  70             prev_xfrm := xfrm.name;
  71         END IF;
  72
  73         xml_node_list := oils_xpath( idx.xpath, transformed_xml, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
  74
  75         raw_text := NULL;
  76         FOR xml_node IN SELECT x FROM unnest(xml_node_list) AS x LOOP
  77             CONTINUE WHEN xml_node !~ E'^\\s*<';
  78
  79             -- XXX much of this should be moved into oils_xpath_string...
  80             curr_text := ARRAY_TO_STRING(evergreen.array_remove_item_by_value(evergreen.array_remove_item_by_value(
  81                 oils_xpath( '//text()', -- get the content of all the nodes within the main selected node
  82                     REGEXP_REPLACE( xml_node, E'\\s+', ' ', 'g' ) -- Translate adjacent whitespace to a single space
  83                 ), ' '), ''),  -- throw away morally empty (bankrupt?) strings
  84                 joiner
  85             );
  86
  87             CONTINUE WHEN curr_text IS NULL OR curr_text = '';
  88
  89             IF raw_text IS NOT NULL THEN
  90                 raw_text := raw_text || joiner;
  91             END IF;
  92
  93             raw_text := COALESCE(raw_text,'') || curr_text;
  94
  95             -- autosuggest/metabib.browse_entry
  96             IF idx.browse_field THEN
  97                 output_row.browse_nocase = idx.browse_nocase;
  98
  99                 IF idx.browse_xpath IS NOT NULL AND idx.browse_xpath <> '' THEN
 100                     browse_text := oils_xpath_string( idx.browse_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 101                 ELSE
 102                     browse_text := curr_text;
 103                 END IF;
 104
 105                 IF idx.browse_sort_xpath IS NOT NULL AND
 106                     idx.browse_sort_xpath <> '' THEN
 107
 108                     sort_value := oils_xpath_string(
 109                         idx.browse_sort_xpath, xml_node, joiner,
 110                         ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]
 111                     );
 112                 ELSE
 113                     sort_value := browse_text;
 114                 END IF;
 115
 116                 output_row.field_class = idx.field_class;
 117                 output_row.field = idx.id;
 118                 output_row.source = rid;
 119                 output_row.value = BTRIM(REGEXP_REPLACE(browse_text, E'\\s+', ' ', 'g'));
 120                 output_row.sort_value :=
 121                     public.naco_normalize(sort_value);
 122
 123                 output_row.authority := NULL;
 124
 125                 IF idx.authority_xpath IS NOT NULL AND idx.authority_xpath <> '' THEN
 126                     authority_text := oils_xpath_string(
 127                         idx.authority_xpath, xml_node, joiner,
 128                         ARRAY[
 129                             ARRAY[xfrm.prefix, xfrm.namespace_uri],
 130                             ARRAY['xlink','http://www.w3.org/1999/xlink']
 131                         ]
 132                     );
 133
 134                     IF authority_text ~ '^\d+$' THEN
 135                         authority_link := authority_text::BIGINT;
 136                         PERFORM * FROM authority.record_entry WHERE id = authority_link;
 137                         IF FOUND THEN
 138                             output_row.authority := authority_link;
 139                         END IF;
 140                     END IF;
 141
 142                 END IF;
 143
 144                 output_row.browse_field = TRUE;
 145                 -- Returning browse rows with search_field = true for search+browse
 146                 -- configs allows us to retain granularity of being able to search
 147                 -- browse fields with "starts with" type operators (for example, for
 148                 -- titles of songs in music albums)
 149                 IF idx.search_field THEN
 150                     output_row.search_field = TRUE;
 151                 END IF;
 152                 RETURN NEXT output_row;
 153                 output_row.browse_nocase = FALSE;
 154                 output_row.browse_field = FALSE;
 155                 output_row.search_field = FALSE;
 156                 output_row.sort_value := NULL;
 157             END IF;
 158
 159             -- insert raw node text for faceting
 160             IF idx.facet_field THEN
 161
 162                 IF idx.facet_xpath IS NOT NULL AND idx.facet_xpath <> '' THEN
 163                     facet_text := oils_xpath_string( idx.facet_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 164                 ELSE
 165                     facet_text := curr_text;
 166                 END IF;
 167
 168                 output_row.field_class = idx.field_class;
 169                 output_row.field = -1 * idx.id;
 170                 output_row.source = rid;
 171                 output_row.value = BTRIM(REGEXP_REPLACE(facet_text, E'\\s+', ' ', 'g'));
 172
 173                 output_row.facet_field = TRUE;
 174                 RETURN NEXT output_row;
 175                 output_row.facet_field = FALSE;
 176             END IF;
 177
 178             -- insert raw node text for display
 179             IF idx.display_field THEN
 180
 181                 IF idx.display_xpath IS NOT NULL AND idx.display_xpath <> '' THEN
 182                     display_text := oils_xpath_string( idx.display_xpath, xml_node, joiner, ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]] );
 183                 ELSE
 184                     display_text := curr_text;
 185                 END IF;
 186
 187                 output_row.field_class = idx.field_class;
 188                 output_row.field = -1 * idx.id;
 189                 output_row.source = rid;
 190                 output_row.value = BTRIM(REGEXP_REPLACE(display_text, E'\\s+', ' ', 'g'));
 191
 192                 output_row.display_field = TRUE;
 193                 RETURN NEXT output_row;
 194                 output_row.display_field = FALSE;
 195             END IF;
 196
 197         END LOOP;
 198
 199         CONTINUE WHEN raw_text IS NULL OR raw_text = '';
 200
 201         -- insert combined node text for searching
 202         IF idx.search_field THEN
 203             output_row.field_class = idx.field_class;
 204             output_row.field = idx.id;
 205             output_row.source = rid;
 206             output_row.value = BTRIM(REGEXP_REPLACE(raw_text, E'\\s+', ' ', 'g'));
 207
 208             output_row.search_field = TRUE;
 209             RETURN NEXT output_row;
 210             output_row.search_field = FALSE;
 211         END IF;
 212
 213     END LOOP;
 214
 215 END;
 216 $func$ LANGUAGE PLPGSQL;
 217
 218 CREATE OR REPLACE FUNCTION metabib.reingest_metabib_field_entries(
 219     bib_id BIGINT,
 220     skip_facet BOOL DEFAULT FALSE,
 221     skip_display BOOL DEFAULT FALSE,
 222     skip_browse BOOL DEFAULT FALSE,
 223     skip_search BOOL DEFAULT FALSE,
 224     only_fields INT[] DEFAULT '{}'::INT[]
 225 ) RETURNS VOID AS $func$
 226 DECLARE
 227     fclass          RECORD;
 228     ind_data        metabib.field_entry_template%ROWTYPE;
 229     mbe_row         metabib.browse_entry%ROWTYPE;
 230     mbe_id          BIGINT;
 231     b_skip_facet    BOOL;
 232     b_skip_display    BOOL;
 233     b_skip_browse   BOOL;
 234     b_skip_search   BOOL;
 235     value_prepped   TEXT;
 236     field_list      INT[] := only_fields;
 237     field_types     TEXT[] := '{}'::TEXT[];
 238 BEGIN
 239
 240     IF field_list = '{}'::INT[] THEN
 241         SELECT ARRAY_AGG(id) INTO field_list FROM config.metabib_field;
 242     END IF;
 243
 244     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;
 245     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;
 246     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;
 247     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;
 248
 249     IF NOT b_skip_facet THEN field_types := field_types || '{facet}'; END IF;
 250     IF NOT b_skip_display THEN field_types := field_types || '{display}'; END IF;
 251     IF NOT b_skip_browse THEN field_types := field_types || '{browse}'; END IF;
 252     IF NOT b_skip_search THEN field_types := field_types || '{search}'; END IF;
 253
 254     PERFORM * FROM config.internal_flag WHERE name = 'ingest.assume_inserts_only' AND enabled;
 255     IF NOT FOUND THEN
 256         IF NOT b_skip_search THEN
 257             FOR fclass IN SELECT * FROM config.metabib_class LOOP
 258                 -- RAISE NOTICE 'Emptying out %', fclass.name;
 259                 EXECUTE $$DELETE FROM metabib.$$ || fclass.name || $$_field_entry WHERE source = $$ || bib_id;
 260             END LOOP;
 261         END IF;
 262         IF NOT b_skip_facet THEN
 263             DELETE FROM metabib.facet_entry WHERE source = bib_id;
 264         END IF;
 265         IF NOT b_skip_display THEN
 266             DELETE FROM metabib.display_entry WHERE source = bib_id;
 267         END IF;
 268         IF NOT b_skip_browse THEN
 269             DELETE FROM metabib.browse_entry_def_map WHERE source = bib_id;
 270         END IF;
 271     END IF;
 272
 273     FOR ind_data IN SELECT * FROM biblio.extract_metabib_field_entry( bib_id, ' ', field_types, field_list ) LOOP
 274
 275         -- don't store what has been normalized away
 276         CONTINUE WHEN ind_data.value IS NULL;
 277
 278         IF ind_data.field < 0 THEN
 279             ind_data.field = -1 * ind_data.field;
 280         END IF;
 281
 282         IF ind_data.facet_field AND NOT b_skip_facet THEN
 283             INSERT INTO metabib.facet_entry (field, source, value)
 284                 VALUES (ind_data.field, ind_data.source, ind_data.value);
 285         END IF;
 286
 287         IF ind_data.display_field AND NOT b_skip_display THEN
 288             INSERT INTO metabib.display_entry (field, source, value)
 289                 VALUES (ind_data.field, ind_data.source, ind_data.value);
 290         END IF;
 291
 292
 293         IF ind_data.browse_field AND NOT b_skip_browse THEN
 294             -- A caveat about this SELECT: this should take care of replacing
 295             -- old mbe rows when data changes, but not if normalization (by
 296             -- which I mean specifically the output of
 297             -- evergreen.oils_tsearch2()) changes.  It may or may not be
 298             -- expensive to add a comparison of index_vector to index_vector
 299             -- to the WHERE clause below.
 300
 301             CONTINUE WHEN ind_data.sort_value IS NULL;
 302
 303             value_prepped := metabib.browse_normalize(ind_data.value, ind_data.field);
 304             IF ind_data.browse_nocase THEN
 305                 SELECT INTO mbe_row * FROM metabib.browse_entry
 306                     WHERE evergreen.lowercase(value) = evergreen.lowercase(value_prepped) AND sort_value = ind_data.sort_value
 307                     ORDER BY sort_value, value LIMIT 1; -- gotta pick something, I guess
 308             ELSE
 309                 SELECT INTO mbe_row * FROM metabib.browse_entry
 310                     WHERE value = value_prepped AND sort_value = ind_data.sort_value;
 311             END IF;
 312
 313             IF FOUND THEN
 314                 mbe_id := mbe_row.id;
 315             ELSE
 316                 INSERT INTO metabib.browse_entry
 317                     ( value, sort_value ) VALUES
 318                     ( value_prepped, ind_data.sort_value );
 319
 320                 mbe_id := CURRVAL('metabib.browse_entry_id_seq'::REGCLASS);
 321             END IF;
 322
 323             INSERT INTO metabib.browse_entry_def_map (entry, def, source, authority)
 324                 VALUES (mbe_id, ind_data.field, ind_data.source, ind_data.authority);
 325         END IF;
 326
 327         IF ind_data.search_field AND NOT b_skip_search THEN
 328             -- Avoid inserting duplicate rows
 329             EXECUTE 'SELECT 1 FROM metabib.' || ind_data.field_class ||
 330                 '_field_entry WHERE field = $1 AND source = $2 AND value = $3'
 331                 INTO mbe_id USING ind_data.field, ind_data.source, ind_data.value;
 332                 -- RAISE NOTICE 'Search for an already matching row returned %', mbe_id;
 333             IF mbe_id IS NULL THEN
 334                 EXECUTE $$
 335                 INSERT INTO metabib.$$ || ind_data.field_class || $$_field_entry (field, source, value)
 336                     VALUES ($$ ||
 337                         quote_literal(ind_data.field) || $$, $$ ||
 338                         quote_literal(ind_data.source) || $$, $$ ||
 339                         quote_literal(ind_data.value) ||
 340                     $$);$$;
 341             END IF;
 342         END IF;
 343
 344     END LOOP;
 345
 346     IF NOT b_skip_search THEN
 347         PERFORM metabib.update_combined_index_vectors(bib_id);
 348     END IF;
 349
 350     RETURN;
 351 END;
 352 $func$ LANGUAGE PLPGSQL;
 353
 354 COMMIT;
 355