Open-ILS/src/sql/Pg/002.functions.config.sql

   1 /*
   2  * Copyright (C) 2004-2008  Georgia Public Library Service
   3  * Copyright (C) 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
  19 BEGIN;
  20
  21 /*
  22 CREATE OR REPLACE FUNCTION oils_xml_transform ( TEXT, TEXT ) RETURNS TEXT AS $_$
  23         SELECT  CASE    WHEN (SELECT COUNT(*) FROM config.xml_transform WHERE name = $2 AND xslt = '---') > 0 THEN $1
  24                         ELSE xslt_process($1, (SELECT xslt FROM config.xml_transform WHERE name = $2))
  25                 END;
  26 $_$ LANGUAGE SQL STRICT IMMUTABLE;
  27
  28 CREATE OR REPLACE FUNCTION public.extract_marc_field ( TEXT, BIGINT, TEXT, TEXT ) RETURNS TEXT AS $$
  29     SELECT regexp_replace(array_to_string( array_accum( output ),' ' ),$4,'','g') FROM oils_xpath_table('id', 'marc', $1, $3, 'id='||$2)x(id INT, output TEXT);
  30 $$ LANGUAGE SQL;
  31
  32 */
  33
  34 CREATE FUNCTION version_specific_xpath () RETURNS TEXT AS $wrapper_function$
  35 DECLARE
  36     out_text TEXT;
  37 BEGIN
  38
  39     IF REGEXP_REPLACE(VERSION(),E'^.+?(\\d+\\.\\d+).*?$',E'\\1')::FLOAT < 8.3 THEN
  40         out_text := 'Creating XPath functions that work like the native XPATH function in 8.3+';
  41
  42         EXECUTE $create_82_funcs$
  43
  44 CREATE OR REPLACE FUNCTION oils_xpath ( xpath TEXT, xml TEXT, ns ANYARRAY ) RETURNS TEXT[] AS $func$
  45 DECLARE
  46     node_text   TEXT;
  47     ns_regexp   TEXT;
  48     munged_xpath    TEXT;
  49 BEGIN
  50
  51     munged_xpath := xpath;
  52
  53     IF ns IS NOT NULL AND array_upper(ns, 1) IS NOT NULL THEN
  54         FOR namespace IN 1 .. array_upper(ns, 1) LOOP
  55             munged_xpath := REGEXP_REPLACE(
  56                 munged_xpath,
  57                 E'(' || ns[namespace][1] || E'):(\\w+)',
  58                 E'*[local-name() = "\\2" and namespace-uri() = "' || ns[namespace][2] || E'"]',
  59                 'g'
  60             );
  61         END LOOP;
  62
  63         munged_xpath := REGEXP_REPLACE( munged_xpath, E'\\]\\[(\\D)',E' and \\1', 'g');
  64     END IF;
  65
  66     -- RAISE NOTICE 'munged xpath: %', munged_xpath;
  67
  68     node_text := xpath_nodeset(xml, munged_xpath, 'XXX_OILS_NODESET');
  69     -- RAISE NOTICE 'node_text: %', node_text;
  70
  71     IF munged_xpath ~ $re$/[^/[]*@[^/]+$$re$ THEN
  72         node_text := REGEXP_REPLACE(node_text,'<XXX_OILS_NODESET>[^"]+"', '<XXX_OILS_NODESET>', 'g');
  73         node_text := REGEXP_REPLACE(node_text,'"</XXX_OILS_NODESET>', '</XXX_OILS_NODESET>', 'g');
  74     END IF;
  75
  76     node_text := REGEXP_REPLACE(node_text,'^<XXX_OILS_NODESET>', '');
  77     node_text := REGEXP_REPLACE(node_text,'</XXX_OILS_NODESET>$', '');
  78
  79     RETURN  STRING_TO_ARRAY(node_text, '</XXX_OILS_NODESET><XXX_OILS_NODESET>');
  80 END;
  81 $func$ LANGUAGE PLPGSQL IMMUTABLE;
  82
  83 CREATE OR REPLACE FUNCTION oils_xpath ( TEXT, TEXT ) RETURNS TEXT[] AS $$SELECT oils_xpath( $1, $2, '{}'::TEXT[] );$$ LANGUAGE SQL IMMUTABLE;
  84
  85 CREATE OR REPLACE FUNCTION oils_xslt_process(TEXT, TEXT) RETURNS TEXT AS $$
  86     SELECT xslt_process( $1, $2 );
  87 $$ LANGUAGE SQL IMMUTABLE;
  88
  89         $create_82_funcs$;
  90     ELSIF REGEXP_REPLACE(VERSION(),E'^.+?(\\d+\\.\\d+).*?$',E'\\1')::FLOAT = 8.3 THEN
  91         out_text := 'Creating XPath wrapper functions around the native XPATH function in 8.3.  contrib/xml2 still required!';
  92
  93         EXECUTE $create_83_funcs$
  94 -- 8.3 or after
  95 CREATE OR REPLACE FUNCTION oils_xpath ( TEXT, TEXT, ANYARRAY ) RETURNS TEXT[] AS 'SELECT XPATH( $1, $2::XML, $3 )::TEXT[];' LANGUAGE SQL IMMUTABLE;
  96 CREATE OR REPLACE FUNCTION oils_xpath ( TEXT, TEXT ) RETURNS TEXT[] AS 'SELECT XPATH( $1, $2::XML )::TEXT[];' LANGUAGE SQL IMMUTABLE;
  97
  98 CREATE OR REPLACE FUNCTION oils_xslt_process(TEXT, TEXT) RETURNS TEXT AS $$
  99     SELECT xslt_process( $1, $2 );
 100 $$ LANGUAGE SQL IMMUTABLE;
 101
 102         $create_83_funcs$;
 103
 104     ELSE
 105         out_text := 'Creating XPath wrapper functions around the native XPATH function in 8.4+, and plperlu-based xslt processor.  No contrib/xml2 needed!';
 106
 107         EXECUTE $create_84_funcs$
 108 -- 8.4 or after
 109 CREATE OR REPLACE FUNCTION oils_xpath ( TEXT, TEXT, ANYARRAY ) RETURNS TEXT[] AS 'SELECT XPATH( $1, $2::XML, $3 )::TEXT[];' LANGUAGE SQL IMMUTABLE;
 110 CREATE OR REPLACE FUNCTION oils_xpath ( TEXT, TEXT ) RETURNS TEXT[] AS 'SELECT XPATH( $1, $2::XML )::TEXT[];' LANGUAGE SQL IMMUTABLE;
 111
 112 CREATE OR REPLACE FUNCTION oils_xslt_process(TEXT, TEXT) RETURNS TEXT AS $func$
 113   use strict;
 114
 115   use XML::LibXSLT;
 116   use XML::LibXML;
 117
 118   my $doc = shift;
 119   my $xslt = shift;
 120
 121   # The following approach uses the older XML::LibXML 1.69 / XML::LibXSLT 1.68
 122   # methods of parsing XML documents and stylesheets, in the hopes of broader
 123   # compatibility with distributions
 124   my $parser = $_SHARED{'_xslt_process'}{parsers}{xml} || XML::LibXML->new();
 125
 126   # Cache the XML parser, if we do not already have one
 127   $_SHARED{'_xslt_process'}{parsers}{xml} = $parser
 128     unless ($_SHARED{'_xslt_process'}{parsers}{xml});
 129
 130   my $xslt_parser = $_SHARED{'_xslt_process'}{parsers}{xslt} || XML::LibXSLT->new();
 131
 132   # Cache the XSLT processor, if we do not already have one
 133   $_SHARED{'_xslt_process'}{parsers}{xslt} = $xslt_parser
 134     unless ($_SHARED{'_xslt_process'}{parsers}{xslt});
 135
 136   my $stylesheet = $_SHARED{'_xslt_process'}{stylesheets}{$xslt} ||
 137     $xslt_parser->parse_stylesheet( $parser->parse_string($xslt) );
 138
 139   $_SHARED{'_xslt_process'}{stylesheets}{$xslt} = $stylesheet
 140     unless ($_SHARED{'_xslt_process'}{stylesheets}{$xslt});
 141
 142   return $stylesheet->output_string(
 143     $stylesheet->transform(
 144       $parser->parse_string($doc)
 145     )
 146   );
 147
 148 $func$ LANGUAGE 'plperlu' STRICT IMMUTABLE;
 149
 150         $create_84_funcs$;
 151
 152     END IF;
 153
 154     RETURN out_text;
 155 END;
 156 $wrapper_function$ LANGUAGE PLPGSQL;
 157
 158 SELECT version_specific_xpath();
 159 DROP FUNCTION version_specific_xpath();
 160
 161
 162 CREATE OR REPLACE FUNCTION oils_xpath_string ( TEXT, TEXT, TEXT, ANYARRAY ) RETURNS TEXT AS $func$
 163     SELECT  ARRAY_TO_STRING(
 164                 oils_xpath(
 165                     $1 ||
 166                         CASE WHEN $1 ~ $re$/[^/[]*@[^]]+$$re$ OR $1 ~ $re$text\(\)$$re$ THEN '' ELSE '//text()' END,
 167                     $2,
 168                     $4
 169                 ),
 170                 $3
 171             );
 172 $func$ LANGUAGE SQL IMMUTABLE;
 173
 174 CREATE OR REPLACE FUNCTION oils_xpath_string ( TEXT, TEXT, TEXT ) RETURNS TEXT AS $func$
 175     SELECT oils_xpath_string( $1, $2, $3, '{}'::TEXT[] );
 176 $func$ LANGUAGE SQL IMMUTABLE;
 177
 178 CREATE OR REPLACE FUNCTION oils_xpath_string ( TEXT, TEXT, ANYARRAY ) RETURNS TEXT AS $func$
 179     SELECT oils_xpath_string( $1, $2, '', $3 );
 180 $func$ LANGUAGE SQL IMMUTABLE;
 181
 182 CREATE OR REPLACE FUNCTION oils_xpath_string ( TEXT, TEXT ) RETURNS TEXT AS $func$
 183     SELECT oils_xpath_string( $1, $2, '{}'::TEXT[] );
 184 $func$ LANGUAGE SQL IMMUTABLE;
 185
 186
 187 CREATE OR REPLACE FUNCTION oils_xpath_table ( key TEXT, document_field TEXT, relation_name TEXT, xpaths TEXT, criteria TEXT ) RETURNS SETOF RECORD AS $func$
 188 DECLARE
 189     xpath_list  TEXT[];
 190     select_list TEXT[];
 191     where_list  TEXT[];
 192     q           TEXT;
 193     out_record  RECORD;
 194     empty_test  RECORD;
 195 BEGIN
 196     xpath_list := STRING_TO_ARRAY( xpaths, '|' );
 197
 198     select_list := ARRAY_APPEND( select_list, key || '::INT AS key' );
 199
 200     FOR i IN 1 .. ARRAY_UPPER(xpath_list,1) LOOP
 201         select_list := ARRAY_APPEND(
 202             select_list,
 203             $sel$
 204             EXPLODE_ARRAY(
 205                 COALESCE(
 206                     NULLIF(
 207                         oils_xpath(
 208                             $sel$ ||
 209                                 quote_literal(
 210                                     CASE
 211                                         WHEN xpath_list[i] ~ $re$/[^/[]*@[^/]+$$re$ OR xpath_list[i] ~ $re$text\(\)$$re$ THEN xpath_list[i]
 212                                         ELSE xpath_list[i] || '//text()'
 213                                     END
 214                                 ) ||
 215                             $sel$,
 216                             $sel$ || document_field || $sel$
 217                         ),
 218                        '{}'::TEXT[]
 219                     ),
 220                     '{NULL}'::TEXT[]
 221                 )
 222             ) AS c_$sel$ || i
 223         );
 224         where_list := ARRAY_APPEND(
 225             where_list,
 226             'c_' || i || ' IS NOT NULL'
 227         );
 228     END LOOP;
 229
 230     q := $q$
 231 SELECT * FROM (
 232     SELECT $q$ || ARRAY_TO_STRING( select_list, ', ' ) || $q$ FROM $q$ || relation_name || $q$ WHERE ($q$ || criteria || $q$)
 233 )x WHERE $q$ || ARRAY_TO_STRING( where_list, ' AND ' );
 234     -- RAISE NOTICE 'query: %', q;
 235
 236     FOR out_record IN EXECUTE q LOOP
 237         RETURN NEXT out_record;
 238     END LOOP;
 239
 240     RETURN;
 241 END;
 242 $func$ LANGUAGE PLPGSQL IMMUTABLE;
 243
 244
 245 CREATE OR REPLACE FUNCTION extract_marc_field ( TEXT, BIGINT, TEXT, TEXT ) RETURNS TEXT AS $$
 246 DECLARE
 247     query TEXT;
 248     output TEXT;
 249 BEGIN
 250     query := $q$
 251         SELECT  regexp_replace(
 252                     oils_xpath_string(
 253                         $q$ || quote_literal($3) || $q$,
 254                         marc,
 255                         ' '
 256                     ),
 257                     $q$ || quote_literal($4) || $q$,
 258                     '',
 259                     'g')
 260           FROM  $q$ || $1 || $q$
 261           WHERE id = $q$ || $2;
 262
 263     EXECUTE query INTO output;
 264
 265     -- RAISE NOTICE 'query: %, output; %', query, output;
 266
 267     RETURN output;
 268 END;
 269 $$ LANGUAGE PLPGSQL IMMUTABLE;
 270
 271 CREATE OR REPLACE FUNCTION extract_marc_field ( TEXT, BIGINT, TEXT ) RETURNS TEXT AS $$
 272     SELECT extract_marc_field($1,$2,$3,'');
 273 $$ LANGUAGE SQL IMMUTABLE;
 274
 275
 276
 277 CREATE OR REPLACE FUNCTION oils_i18n_xlate ( keytable TEXT, keyclass TEXT, keycol TEXT, identcol TEXT, keyvalue TEXT, raw_locale TEXT ) RETURNS TEXT AS $func$
 278 DECLARE
 279     locale      TEXT := REGEXP_REPLACE( REGEXP_REPLACE( raw_locale, E'[;, ].+$', '' ), E'_', '-', 'g' );
 280     language    TEXT := REGEXP_REPLACE( locale, E'-.+$', '' );
 281     result      config.i18n_core%ROWTYPE;
 282     fallback    TEXT;
 283     keyfield    TEXT := keyclass || '.' || keycol;
 284 BEGIN
 285
 286     -- Try the full locale
 287     SELECT  * INTO result
 288       FROM  config.i18n_core
 289       WHERE fq_field = keyfield
 290             AND identity_value = keyvalue
 291             AND translation = locale;
 292
 293     -- Try just the language
 294     IF NOT FOUND THEN
 295         SELECT  * INTO result
 296           FROM  config.i18n_core
 297           WHERE fq_field = keyfield
 298                 AND identity_value = keyvalue
 299                 AND translation = language;
 300     END IF;
 301
 302     -- Fall back to the string we passed in in the first place
 303     IF NOT FOUND THEN
 304         EXECUTE
 305             'SELECT ' ||
 306                 keycol ||
 307             ' FROM ' || keytable ||
 308             ' WHERE ' || identcol || ' = ' || quote_literal(keyvalue)
 309                 INTO fallback;
 310         RETURN fallback;
 311     END IF;
 312
 313     RETURN result.string;
 314 END;
 315 $func$ LANGUAGE PLPGSQL STABLE;
 316
 317 -- Functions for marking translatable strings in SQL statements
 318 -- Parameters are: primary key, string, class hint, property
 319 CREATE OR REPLACE FUNCTION oils_i18n_gettext( INT, TEXT, TEXT, TEXT ) RETURNS TEXT AS $$
 320     SELECT $2;
 321 $$ LANGUAGE SQL;
 322
 323 CREATE OR REPLACE FUNCTION oils_i18n_gettext( TEXT, TEXT, TEXT, TEXT ) RETURNS TEXT AS $$
 324     SELECT $2;
 325 $$ LANGUAGE SQL;
 326
 327 CREATE OR REPLACE FUNCTION is_json (TEXT) RETURNS BOOL AS $func$
 328     use JSON::XS;
 329     my $json = shift();
 330     eval { decode_json( $json ) };
 331     return $@ ? 0 : 1;
 332 $func$ LANGUAGE PLPERLU IMMUTABLE;
 333
 334 COMMIT;
 335