Open-ILS/src/sql/Pg/020.schema.functions.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 CREATE OR REPLACE FUNCTION public.non_filing_normalize ( TEXT, "char" ) RETURNS TEXT AS $$
  19         SELECT  SUBSTRING(
  20                         REGEXP_REPLACE(
  21                                 REGEXP_REPLACE(
  22                                         $1,
  23                                         E'\W*$',
  24                                         ''
  25                                 ),
  26                                 '  ',
  27                                 ' '
  28                         ),
  29                         CASE
  30                                 WHEN $2::INT NOT BETWEEN 48 AND 57 THEN 1
  31                                 ELSE $2::TEXT::INT + 1
  32                         END
  33                 );
  34 $$ LANGUAGE SQL STRICT IMMUTABLE;
  35
  36 CREATE OR REPLACE FUNCTION public.first_word ( TEXT ) RETURNS TEXT AS $$
  37         SELECT COALESCE(SUBSTRING( $1 FROM $_$^\S+$_$), '');
  38 $$ LANGUAGE SQL STRICT IMMUTABLE;
  39
  40 CREATE OR REPLACE FUNCTION public.normalize_space( TEXT ) RETURNS TEXT AS $$
  41     SELECT regexp_replace(regexp_replace(regexp_replace($1, E'\\n', ' ', 'g'), E'(?:^\\s+)|(\\s+$)', '', 'g'), E'\\s+', ' ', 'g');
  42 $$ LANGUAGE SQL STRICT IMMUTABLE;
  43
  44 CREATE OR REPLACE FUNCTION public.remove_commas( TEXT ) RETURNS TEXT AS $$
  45     SELECT regexp_replace($1, ',', '', 'g');
  46 $$ LANGUAGE SQL STRICT IMMUTABLE;
  47
  48 CREATE OR REPLACE FUNCTION public.remove_paren_substring( TEXT ) RETURNS TEXT AS $func$
  49     SELECT regexp_replace($1, $$\([^)]+\)$$, '', 'g');
  50 $func$ LANGUAGE SQL STRICT IMMUTABLE;
  51
  52 CREATE OR REPLACE FUNCTION public.remove_whitespace( TEXT ) RETURNS TEXT AS $$
  53     SELECT regexp_replace(normalize_space($1), E'\\s+', '', 'g');
  54 $$ LANGUAGE SQL STRICT IMMUTABLE;
  55
  56 CREATE OR REPLACE FUNCTION public.lowercase( TEXT ) RETURNS TEXT AS $$
  57     return lc(shift);
  58 $$ LANGUAGE PLPERLU STRICT IMMUTABLE;
  59
  60 CREATE OR REPLACE FUNCTION public.uppercase( TEXT ) RETURNS TEXT AS $$
  61     return uc(shift);
  62 $$ LANGUAGE PLPERLU STRICT IMMUTABLE;
  63
  64 CREATE OR REPLACE FUNCTION public.remove_diacritics( TEXT ) RETURNS TEXT AS $$
  65     use Unicode::Normalize;
  66
  67     my $x = NFD(shift);
  68     $x =~ s/\pM+//go;
  69     return $x;
  70
  71 $$ LANGUAGE PLPERLU STRICT IMMUTABLE;
  72
  73 CREATE OR REPLACE FUNCTION public.entityize( TEXT ) RETURNS TEXT AS $$
  74     use Unicode::Normalize;
  75
  76     my $x = NFC(shift);
  77     $x =~ s/([\x{0080}-\x{fffd}])/sprintf('&#x%X;',ord($1))/sgoe;
  78     return $x;
  79
  80 $$ LANGUAGE PLPERLU STRICT IMMUTABLE;
  81
  82 CREATE OR REPLACE FUNCTION public.call_number_dewey( TEXT ) RETURNS TEXT AS $$
  83         my $txt = shift;
  84         $txt =~ s/^\s+//o;
  85         $txt =~ s/[\[\]\{\}\(\)`'"#<>\*\?\-\+\$\\]+//og;
  86         $txt =~ s/\s+$//o;
  87         if ($txt =~ /(\d{3}(?:\.\d+)?)/o) {
  88                 return $1;
  89         } else {
  90                 return (split /\s+/, $txt)[0];
  91         }
  92 $$ LANGUAGE 'plperlu' STRICT IMMUTABLE;
  93
  94 CREATE OR REPLACE FUNCTION public.call_number_dewey( TEXT, INT ) RETURNS TEXT AS $$
  95         SELECT SUBSTRING(call_number_dewey($1) FROM 1 FOR $2);
  96 $$ LANGUAGE SQL STRICT IMMUTABLE;
  97
  98 CREATE OR REPLACE FUNCTION tableoid2name ( oid ) RETURNS TEXT AS $$
  99         BEGIN
 100                 RETURN $1::regclass;
 101         END;
 102 $$ language 'plpgsql';
 103
 104 CREATE OR REPLACE FUNCTION actor.org_unit_descendants( INT, INT ) RETURNS SETOF actor.org_unit AS $$
 105     WITH RECURSIVE descendant_depth AS (
 106         SELECT  ou.id,
 107                 ou.parent_ou,
 108                 out.depth
 109           FROM  actor.org_unit ou
 110                 JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
 111                 JOIN anscestor_depth ad ON (ad.id = ou.id)
 112           WHERE ad.depth = $2
 113             UNION ALL
 114         SELECT  ou.id,
 115                 ou.parent_ou,
 116                 out.depth
 117           FROM  actor.org_unit ou
 118                 JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
 119                 JOIN descendant_depth ot ON (ot.id = ou.parent_ou)
 120     ), anscestor_depth AS (
 121         SELECT  ou.id,
 122                 ou.parent_ou,
 123                 out.depth
 124           FROM  actor.org_unit ou
 125                 JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
 126           WHERE ou.id = $1
 127             UNION ALL
 128         SELECT  ou.id,
 129                 ou.parent_ou,
 130                 out.depth
 131           FROM  actor.org_unit ou
 132                 JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
 133                 JOIN anscestor_depth ot ON (ot.parent_ou = ou.id)
 134     ) SELECT ou.* FROM actor.org_unit ou JOIN descendant_depth USING (id);
 135 $$ LANGUAGE SQL ROWS 1;
 136
 137 CREATE OR REPLACE FUNCTION actor.org_unit_descendants( INT ) RETURNS SETOF actor.org_unit AS $$
 138     WITH RECURSIVE descendant_depth AS (
 139         SELECT  ou.id,
 140                 ou.parent_ou,
 141                 out.depth
 142           FROM  actor.org_unit ou
 143                 JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
 144           WHERE ou.id = $1
 145             UNION ALL
 146         SELECT  ou.id,
 147                 ou.parent_ou,
 148                 out.depth
 149           FROM  actor.org_unit ou
 150                 JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
 151                 JOIN descendant_depth ot ON (ot.id = ou.parent_ou)
 152     ) SELECT ou.* FROM actor.org_unit ou JOIN descendant_depth USING (id);
 153 $$ LANGUAGE SQL ROWS 1;
 154
 155 CREATE OR REPLACE FUNCTION actor.org_unit_descendants_distance( INT ) RETURNS TABLE (id INT, distance INT) AS $$
 156     WITH RECURSIVE org_unit_descendants_distance(id, distance) AS (
 157             SELECT $1, 0
 158         UNION
 159             SELECT ou.id, oudd.distance+1
 160             FROM actor.org_unit ou JOIN org_unit_descendants_distance oudd ON (ou.parent_ou = oudd.id)
 161     )
 162     SELECT * FROM org_unit_descendants_distance;
 163 $$ LANGUAGE SQL STABLE ROWS 1;
 164
 165 CREATE OR REPLACE FUNCTION actor.org_unit_ancestors( INT ) RETURNS SETOF actor.org_unit AS $$
 166     WITH RECURSIVE org_unit_ancestors_distance(id, distance) AS (
 167             SELECT $1, 0
 168         UNION
 169             SELECT ou.parent_ou, ouad.distance+1
 170             FROM actor.org_unit ou JOIN org_unit_ancestors_distance ouad ON (ou.id = ouad.id)
 171             WHERE ou.parent_ou IS NOT NULL
 172     )
 173     SELECT ou.* FROM actor.org_unit ou JOIN org_unit_ancestors_distance ouad USING (id) ORDER BY ouad.distance DESC;
 174 $$ LANGUAGE SQL ROWS 1;
 175
 176 CREATE OR REPLACE FUNCTION actor.org_unit_ancestor_at_depth ( INT,INT ) RETURNS actor.org_unit AS $$
 177         SELECT  a.*
 178           FROM  actor.org_unit a
 179           WHERE id = ( SELECT FIRST(x.id)
 180                          FROM   actor.org_unit_ancestors($1) x
 181                                 JOIN actor.org_unit_type y
 182                                         ON x.ou_type = y.id AND y.depth = $2);
 183 $$ LANGUAGE SQL STABLE;
 184
 185 CREATE OR REPLACE FUNCTION actor.org_unit_ancestors_distance( INT ) RETURNS TABLE (id INT, distance INT) AS $$
 186     WITH RECURSIVE org_unit_ancestors_distance(id, distance) AS (
 187             SELECT $1, 0
 188         UNION
 189             SELECT ou.parent_ou, ouad.distance+1
 190             FROM actor.org_unit ou JOIN org_unit_ancestors_distance ouad ON (ou.id = ouad.id)
 191             WHERE ou.parent_ou IS NOT NULL
 192     )
 193     SELECT * FROM org_unit_ancestors_distance;
 194 $$ LANGUAGE SQL STABLE ROWS 1;
 195
 196 CREATE OR REPLACE FUNCTION actor.org_unit_ancestors_distance( INT ) RETURNS TABLE (id INT, distance INT) AS $$
 197     WITH RECURSIVE org_unit_ancestors_distance(id, distance) AS (
 198             SELECT $1, 0
 199         UNION
 200             SELECT ou.parent_ou, ouad.distance+1
 201             FROM actor.org_unit ou JOIN org_unit_ancestors_distance ouad ON (ou.id = ouad.id)
 202             WHERE ou.parent_ou IS NOT NULL
 203     )
 204     SELECT * FROM org_unit_ancestors_distance;
 205 $$ LANGUAGE SQL STABLE ROWS 1;
 206
 207 CREATE OR REPLACE FUNCTION actor.org_unit_full_path ( INT ) RETURNS SETOF actor.org_unit AS $$
 208         SELECT  *
 209           FROM  actor.org_unit_ancestors($1)
 210                         UNION
 211         SELECT  *
 212           FROM  actor.org_unit_descendants($1);
 213 $$ LANGUAGE SQL STABLE ROWS 1;
 214
 215 CREATE OR REPLACE FUNCTION actor.org_unit_full_path ( INT, INT ) RETURNS SETOF actor.org_unit AS $$
 216         SELECT  * FROM actor.org_unit_full_path((actor.org_unit_ancestor_at_depth($1, $2)).id)
 217 $$ LANGUAGE SQL STABLE ROWS 1;
 218
 219 CREATE OR REPLACE FUNCTION actor.org_unit_combined_ancestors ( INT, INT ) RETURNS SETOF actor.org_unit AS $$
 220         SELECT  *
 221           FROM  actor.org_unit_ancestors($1)
 222                         UNION
 223         SELECT  *
 224           FROM  actor.org_unit_ancestors($2);
 225 $$ LANGUAGE SQL STABLE ROWS 1;
 226
 227 CREATE OR REPLACE FUNCTION actor.org_unit_common_ancestors ( INT, INT ) RETURNS SETOF actor.org_unit AS $$
 228         SELECT  *
 229           FROM  actor.org_unit_ancestors($1)
 230                         INTERSECT
 231         SELECT  *
 232           FROM  actor.org_unit_ancestors($2);
 233 $$ LANGUAGE SQL STABLE ROWS 1;
 234
 235 -- Given the IDs of two rows in actor.org_unit, *the second being an ancestor
 236 -- of the first*, return in array form the path from the ancestor to the
 237 -- descendant, with each point in the path being an org_unit ID.  This is
 238 -- useful for sorting org_units by their position in a depth-first (display
 239 -- order) representation of the tree.
 240 --
 241 -- This breaks with the precedent set by actor.org_unit_full_path() and others,
 242 -- and gets the parameters "backwards," but otherwise this function would
 243 -- not be very usable within json_query.
 244 CREATE OR REPLACE FUNCTION actor.org_unit_simple_path(INT, INT)
 245 RETURNS INT[] AS $$
 246     WITH RECURSIVE descendant_depth(id, path) AS (
 247         SELECT  aou.id,
 248                 ARRAY[aou.id]
 249           FROM  actor.org_unit aou
 250                 JOIN actor.org_unit_type aout ON (aout.id = aou.ou_type)
 251           WHERE aou.id = $2
 252             UNION ALL
 253         SELECT  aou.id,
 254                 dd.path || ARRAY[aou.id]
 255           FROM  actor.org_unit aou
 256                 JOIN actor.org_unit_type aout ON (aout.id = aou.ou_type)
 257                 JOIN descendant_depth dd ON (dd.id = aou.parent_ou)
 258     ) SELECT dd.path
 259         FROM actor.org_unit aou
 260         JOIN descendant_depth dd USING (id)
 261         WHERE aou.id = $1 ORDER BY dd.path;
 262 $$ LANGUAGE SQL STABLE;
 263
 264 CREATE OR REPLACE FUNCTION actor.org_unit_proximity ( INT, INT ) RETURNS INT AS $$
 265         SELECT COUNT(id)::INT FROM (
 266                 SELECT id FROM actor.org_unit_combined_ancestors($1, $2)
 267                         EXCEPT
 268                 SELECT id FROM actor.org_unit_common_ancestors($1, $2)
 269         ) z;
 270 $$ LANGUAGE SQL STABLE;
 271
 272 CREATE OR REPLACE FUNCTION actor.org_unit_ancestor_setting( setting_name TEXT, org_id INT ) RETURNS SETOF actor.org_unit_setting AS $$
 273 DECLARE
 274     setting RECORD;
 275     cur_org INT;
 276 BEGIN
 277     cur_org := org_id;
 278     LOOP
 279         SELECT INTO setting * FROM actor.org_unit_setting WHERE org_unit = cur_org AND name = setting_name;
 280         IF FOUND THEN
 281             RETURN NEXT setting;
 282             EXIT;
 283         END IF;
 284         SELECT INTO cur_org parent_ou FROM actor.org_unit WHERE id = cur_org;
 285         EXIT WHEN cur_org IS NULL;
 286     END LOOP;
 287     RETURN;
 288 END;
 289 $$ LANGUAGE plpgsql STABLE ROWS 1;
 290
 291 COMMENT ON FUNCTION actor.org_unit_ancestor_setting( TEXT, INT) IS $$
 292 Search "up" the org_unit tree until we find the first occurrence of an
 293 org_unit_setting with the given name.
 294 $$;
 295
 296 CREATE OR REPLACE FUNCTION actor.org_unit_ancestor_setting_batch( org_id INT, setting_names TEXT[] ) RETURNS SETOF actor.org_unit_setting AS $$
 297 DECLARE
 298     setting RECORD;
 299     setting_name TEXT;
 300     cur_org INT;
 301 BEGIN
 302     FOREACH setting_name IN ARRAY setting_names
 303     LOOP
 304         cur_org := org_id;
 305         LOOP
 306             SELECT INTO setting * FROM actor.org_unit_setting WHERE org_unit = cur_org AND name = setting_name;
 307             IF FOUND THEN
 308                 RETURN NEXT setting;
 309                 EXIT;
 310             END IF;
 311             SELECT INTO cur_org parent_ou FROM actor.org_unit WHERE id = cur_org;
 312             EXIT WHEN cur_org IS NULL;
 313         END LOOP;
 314     END LOOP;
 315     RETURN;
 316 END;
 317 $$ LANGUAGE plpgsql STABLE;
 318
 319 COMMENT ON FUNCTION actor.org_unit_ancestor_setting_batch( INT,  TEXT[] ) IS $$
 320 For each setting name passed, search "up" the org_unit tree until
 321 we find the first occurrence of an org_unit_setting with the given name.
 322 $$;
 323
 324 CREATE OR REPLACE FUNCTION actor.org_unit_ancestor_setting_batch_by_org(
 325     setting_name TEXT, org_ids INTEGER[])
 326     RETURNS SETOF actor.org_unit_setting AS
 327 $FUNK$
 328 DECLARE
 329     setting RECORD;
 330     org_id INTEGER;
 331 BEGIN
 332     /*  Returns one actor.org_unit_setting row per org unit ID provided.
 333         When no setting exists for a given org unit, the setting row
 334         will contain all empty values. */
 335     FOREACH org_id IN ARRAY org_ids LOOP
 336         SELECT INTO setting * FROM
 337             actor.org_unit_ancestor_setting(setting_name, org_id);
 338         RETURN NEXT setting;
 339     END LOOP;
 340     RETURN;
 341 END;
 342 $FUNK$ LANGUAGE plpgsql STABLE;
 343
 344 CREATE OR REPLACE FUNCTION evergreen.get_barcodes(select_ou INT, type TEXT, in_barcode TEXT) RETURNS SETOF evergreen.barcode_set AS $$
 345 DECLARE
 346     cur_barcode TEXT;
 347     barcode_len INT;
 348     completion_len  INT;
 349     asset_barcodes  TEXT[];
 350     actor_barcodes  TEXT[];
 351     do_asset    BOOL = false;
 352     do_serial   BOOL = false;
 353     do_booking  BOOL = false;
 354     do_actor    BOOL = false;
 355     completion_set  config.barcode_completion%ROWTYPE;
 356 BEGIN
 357
 358     IF position('asset' in type) > 0 THEN
 359         do_asset = true;
 360     END IF;
 361     IF position('serial' in type) > 0 THEN
 362         do_serial = true;
 363     END IF;
 364     IF position('booking' in type) > 0 THEN
 365         do_booking = true;
 366     END IF;
 367     IF do_asset OR do_serial OR do_booking THEN
 368         asset_barcodes = asset_barcodes || in_barcode;
 369     END IF;
 370     IF position('actor' in type) > 0 THEN
 371         do_actor = true;
 372         actor_barcodes = actor_barcodes || in_barcode;
 373     END IF;
 374
 375     barcode_len := length(in_barcode);
 376
 377     FOR completion_set IN
 378       SELECT * FROM config.barcode_completion
 379         WHERE active
 380         AND org_unit IN (SELECT aou.id FROM actor.org_unit_ancestors(select_ou) aou)
 381         LOOP
 382         IF completion_set.prefix IS NULL THEN
 383             completion_set.prefix := '';
 384         END IF;
 385         IF completion_set.suffix IS NULL THEN
 386             completion_set.suffix := '';
 387         END IF;
 388         IF completion_set.length = 0 OR completion_set.padding IS NULL OR length(completion_set.padding) = 0 THEN
 389             cur_barcode = completion_set.prefix || in_barcode || completion_set.suffix;
 390         ELSE
 391             completion_len = completion_set.length - length(completion_set.prefix) - length(completion_set.suffix);
 392             IF completion_len >= barcode_len THEN
 393                 IF completion_set.padding_end THEN
 394                     cur_barcode = rpad(in_barcode, completion_len, completion_set.padding);
 395                 ELSE
 396                     cur_barcode = lpad(in_barcode, completion_len, completion_set.padding);
 397                 END IF;
 398                 cur_barcode = completion_set.prefix || cur_barcode || completion_set.suffix;
 399             END IF;
 400         END IF;
 401         IF completion_set.actor THEN
 402             actor_barcodes = actor_barcodes || cur_barcode;
 403         END IF;
 404         IF completion_set.asset THEN
 405             asset_barcodes = asset_barcodes || cur_barcode;
 406         END IF;
 407     END LOOP;
 408
 409     IF do_asset AND do_serial THEN
 410         RETURN QUERY SELECT 'asset'::TEXT, id, barcode FROM ONLY asset.copy WHERE barcode = ANY(asset_barcodes) AND deleted = false;
 411         RETURN QUERY SELECT 'serial'::TEXT, id, barcode FROM serial.unit WHERE barcode = ANY(asset_barcodes) AND deleted = false;
 412     ELSIF do_asset THEN
 413         RETURN QUERY SELECT 'asset'::TEXT, id, barcode FROM asset.copy WHERE barcode = ANY(asset_barcodes) AND deleted = false;
 414     ELSIF do_serial THEN
 415         RETURN QUERY SELECT 'serial'::TEXT, id, barcode FROM serial.unit WHERE barcode = ANY(asset_barcodes) AND deleted = false;
 416     END IF;
 417     IF do_booking THEN
 418         RETURN QUERY SELECT 'booking'::TEXT, id::BIGINT, barcode FROM booking.resource WHERE barcode = ANY(asset_barcodes);
 419     END IF;
 420     IF do_actor THEN
 421         RETURN QUERY SELECT 'actor'::TEXT, c.usr::BIGINT, c.barcode FROM actor.card c JOIN actor.usr u ON c.usr = u.id WHERE
 422             ((c.barcode = ANY(actor_barcodes) AND c.active) OR c.barcode = in_barcode) AND NOT u.deleted ORDER BY usr;
 423     END IF;
 424     RETURN;
 425 END;
 426 $$ LANGUAGE plpgsql;
 427
 428 COMMENT ON FUNCTION evergreen.get_barcodes(INT, TEXT, TEXT) IS $$
 429 Given user input, find an appropriate barcode in the proper class.
 430
 431 Will add prefix/suffix information to do so, and return all results.
 432 $$;
 433
 434 CREATE OR REPLACE FUNCTION actor.org_unit_prox_update () RETURNS TRIGGER as $$
 435 BEGIN
 436
 437
 438 IF TG_OP = 'DELETE' THEN
 439
 440     DELETE FROM actor.org_unit_proximity WHERE (from_org = OLD.id or to_org= OLD.id);
 441
 442 END IF;
 443
 444 IF TG_OP = 'UPDATE' THEN
 445
 446     IF NEW.parent_ou <> OLD.parent_ou THEN
 447
 448         DELETE FROM actor.org_unit_proximity WHERE (from_org = OLD.id or to_org= OLD.id);
 449             INSERT INTO actor.org_unit_proximity (from_org, to_org, prox)
 450             SELECT  l.id, r.id, actor.org_unit_proximity(l.id,r.id)
 451                 FROM  actor.org_unit l, actor.org_unit r
 452                 WHERE (l.id = NEW.id or r.id = NEW.id);
 453
 454     END IF;
 455
 456 END IF;
 457
 458 IF TG_OP = 'INSERT' THEN
 459
 460      INSERT INTO actor.org_unit_proximity (from_org, to_org, prox)
 461      SELECT  l.id, r.id, actor.org_unit_proximity(l.id,r.id)
 462          FROM  actor.org_unit l, actor.org_unit r
 463          WHERE (l.id = NEW.id or r.id = NEW.id);
 464
 465 END IF;
 466
 467 RETURN null;
 468
 469 END;
 470 $$ LANGUAGE plpgsql;
 471
 472
 473 CREATE TRIGGER proximity_update_tgr AFTER INSERT OR UPDATE OR DELETE ON actor.org_unit FOR EACH ROW EXECUTE PROCEDURE actor.org_unit_prox_update ();
 474
 475 CREATE OR REPLACE FUNCTION evergreen.get_locale_name(
 476     IN locale TEXT,
 477     OUT name TEXT,
 478     OUT description TEXT
 479 ) AS $$
 480 DECLARE
 481     eg_locale TEXT;
 482 BEGIN
 483     eg_locale := LOWER(SUBSTRING(locale FROM 1 FOR 2)) || '-' || UPPER(SUBSTRING(locale FROM 4 FOR 2));
 484
 485     SELECT i18nc.string INTO name
 486     FROM config.i18n_locale i18nl
 487        INNER JOIN config.i18n_core i18nc ON i18nl.code = i18nc.translation
 488     WHERE i18nc.identity_value = eg_locale
 489        AND code = eg_locale
 490        AND i18nc.fq_field = 'i18n_l.name';
 491
 492     IF name IS NULL THEN
 493        SELECT i18nl.name INTO name
 494        FROM config.i18n_locale i18nl
 495        WHERE code = eg_locale;
 496     END IF;
 497
 498     SELECT i18nc.string INTO description
 499     FROM config.i18n_locale i18nl
 500        INNER JOIN config.i18n_core i18nc ON i18nl.code = i18nc.translation
 501     WHERE i18nc.identity_value = eg_locale
 502        AND code = eg_locale
 503        AND i18nc.fq_field = 'i18n_l.description';
 504
 505     IF description IS NULL THEN
 506        SELECT i18nl.description INTO description
 507        FROM config.i18n_locale i18nl
 508        WHERE code = eg_locale;
 509     END IF;
 510 END;
 511 $$ LANGUAGE PLPGSQL COST 1 STABLE;