plpgsql/types.sql

   1 -- ---------------------------------------------------------
   2 -- persistent values
   3
   4 -- list of types for type_id
   5 -- 0:  nil
   6 -- 1:  false
   7 -- 2:  true
   8 -- 3:  integer
   9 -- 4:  float
  10 -- 5:  string
  11 -- 6:  keyword (not used, uses prefixed string)
  12 -- 7:  symbol
  13 -- 8:  list
  14 -- 9:  vector
  15 -- 10: hashmap
  16 -- 11: function
  17 -- 12: malfunc
  18 -- 13: atom
  19
  20 CREATE SCHEMA types
  21
  22     CREATE SEQUENCE value_id_seq START WITH 3 -- skip nil, false, true
  23
  24     CREATE TABLE value (
  25         value_id        integer NOT NULL DEFAULT nextval('value_id_seq'),
  26         type_id         integer NOT NULL,
  27         val_int         bigint,    -- set for integers
  28         val_string      varchar,   -- set for strings, keywords, symbols,
  29                                 -- and native functions (function name)
  30         val_seq         integer[], -- set for lists and vectors
  31         val_hash        hstore,    -- set for hash-maps
  32         ast_id          integer,   -- set for malfunc
  33         params_id       integer,   -- set for malfunc
  34         env_id          integer,   -- set for malfunc
  35         macro           boolean,   -- set for malfunc
  36         meta_id         integer    -- can be set for any collection
  37     );
  38
  39 ALTER TABLE types.value ADD CONSTRAINT pk_value_id
  40     PRIMARY KEY (value_id);
  41 -- drop sequence when table dropped
  42 ALTER SEQUENCE types.value_id_seq OWNED BY types.value.value_id;
  43 ALTER TABLE types.value ADD CONSTRAINT fk_meta_id
  44     FOREIGN KEY (meta_id) REFERENCES types.value(value_id);
  45 ALTER TABLE types.value ADD CONSTRAINT fk_params_id
  46     FOREIGN KEY (params_id) REFERENCES types.value(value_id);
  47
  48 CREATE INDEX ON types.value (value_id, type_id);
  49
  50 INSERT INTO types.value (value_id, type_id) VALUES (0, 0); -- nil
  51 INSERT INTO types.value (value_id, type_id) VALUES (1, 1); -- false
  52 INSERT INTO types.value (value_id, type_id) VALUES (2, 2); -- true
  53
  54
  55 -- ---------------------------------------------------------
  56 -- general functions
  57
  58 CREATE FUNCTION types._wraptf(val boolean) RETURNS integer AS $$
  59 BEGIN
  60     IF val THEN
  61         RETURN 2;
  62     ELSE
  63         RETURN 1;
  64     END IF;
  65 END; $$ LANGUAGE plpgsql IMMUTABLE;
  66
  67 -- pun both NULL and false to false
  68 CREATE FUNCTION types._tf(val boolean) RETURNS boolean AS $$
  69 BEGIN
  70     IF val IS NULL OR val = false THEN
  71         RETURN false;
  72     END IF;
  73     RETURN true;
  74 END; $$ LANGUAGE plpgsql IMMUTABLE;
  75
  76 -- pun both NULL and 0 to false
  77 CREATE FUNCTION types._tf(val integer) RETURNS boolean AS $$
  78 BEGIN
  79     IF val IS NULL OR val = 0 THEN
  80         RETURN false;
  81     END IF;
  82     RETURN true;
  83 END; $$ LANGUAGE plpgsql IMMUTABLE;
  84
  85 -- return the type of the given value_id
  86 CREATE FUNCTION types._type(obj integer) RETURNS integer AS $$
  87 BEGIN
  88     RETURN (SELECT type_id FROM types.value WHERE value_id = obj);
  89 END; $$ LANGUAGE plpgsql;
  90
  91
  92 CREATE FUNCTION types._equal_Q(a integer, b integer) RETURNS boolean AS $$
  93 DECLARE
  94     atype  integer;
  95     btype  integer;
  96     anum   bigint;
  97     bnum   bigint;
  98     avid   integer;
  99     bvid   integer;
 100     aseq   integer[];
 101     bseq   integer[];
 102     ahash  hstore;
 103     bhash  hstore;
 104     kv     RECORD;
 105     i      integer;
 106 BEGIN
 107     atype := types._type(a);
 108     btype := types._type(b);
 109     IF NOT ((atype = btype) OR
 110             (types._sequential_Q(a) AND types._sequential_Q(b))) THEN
 111         RETURN false;
 112     END IF;
 113     CASE
 114     WHEN atype = 3 THEN -- integer
 115         SELECT val_int FROM types.value INTO anum WHERE value_id = a;
 116         SELECT val_int FROM types.value INTO bnum WHERE value_id = b;
 117         RETURN anum = bnum;
 118     WHEN atype = 5 OR atype = 7 THEN -- string/symbol
 119         RETURN types._valueToString(a) = types._valueToString(b);
 120     WHEN atype IN (8, 9) THEN -- list/vector
 121         IF types._count(a) <> types._count(b) THEN
 122             RETURN false;
 123         END IF;
 124         SELECT val_seq INTO aseq FROM types.value WHERE value_id = a;
 125         SELECT val_seq INTO bseq FROM types.value WHERE value_id = b;
 126         FOR i IN 1 .. types._count(a)
 127         LOOP
 128             IF NOT types._equal_Q(aseq[i], bseq[i]) THEN
 129                 return false;
 130             END IF;
 131         END LOOP;
 132         RETURN true;
 133     WHEN atype = 10 THEN -- hash-map
 134         SELECT val_hash INTO ahash FROM types.value WHERE value_id = a;
 135         SELECT val_hash INTO bhash FROM types.value WHERE value_id = b;
 136         IF array_length(akeys(ahash), 1) <> array_length(akeys(bhash), 1) THEN
 137             RETURN false;
 138         END IF;
 139         FOR kv IN SELECT * FROM each(ahash) LOOP
 140             avid := CAST((ahash -> kv.key) AS integer);
 141             bvid := CAST((bhash -> kv.key) AS integer);
 142             IF bvid IS NULL OR NOT types._equal_Q(avid, bvid) THEN
 143                 return false;
 144             END IF;
 145         END LOOP;
 146         RETURN true;
 147     ELSE
 148         RETURN a = b;
 149     END CASE;
 150 END; $$ LANGUAGE plpgsql;
 151
 152
 153 -- _clone:
 154 -- take a value_id of a collection
 155 -- returns a new value_id of a cloned collection
 156 CREATE FUNCTION types._clone(id integer) RETURNS integer AS $$
 157 DECLARE
 158     result       integer;
 159 BEGIN
 160     INSERT INTO types.value (type_id,val_int,val_string,val_seq,val_hash,
 161                        ast_id,params_id,env_id,meta_id)
 162         (SELECT type_id,val_int,val_string,val_seq,val_hash,
 163                 ast_id,params_id,env_id,meta_id
 164               FROM types.value
 165               WHERE value_id = id)
 166         RETURNING value_id INTO result;
 167     RETURN result;
 168 END; $$ LANGUAGE plpgsql;
 169
 170
 171 -- ---------------------------------------------------------
 172 -- scalar functions
 173
 174
 175 -- _nil_Q:
 176 -- takes a value_id
 177 -- returns the whether value_id is nil
 178 CREATE FUNCTION types._nil_Q(id integer) RETURNS boolean AS $$
 179 BEGIN
 180     RETURN id = 0;
 181 END; $$ LANGUAGE plpgsql IMMUTABLE;
 182
 183 -- _true_Q:
 184 -- takes a value_id
 185 -- returns the whether value_id is true
 186 CREATE FUNCTION types._true_Q(id integer) RETURNS boolean AS $$
 187 BEGIN
 188     RETURN id = 2;
 189 END; $$ LANGUAGE plpgsql IMMUTABLE;
 190
 191 -- _false_Q:
 192 -- takes a value_id
 193 -- returns the whether value_id is false
 194 CREATE FUNCTION types._false_Q(id integer) RETURNS boolean AS $$
 195 BEGIN
 196     RETURN id = 1;
 197 END; $$ LANGUAGE plpgsql IMMUTABLE;
 198
 199 -- _string_Q:
 200 -- takes a value_id
 201 -- returns the whether value_id is string type
 202 CREATE FUNCTION types._string_Q(id integer) RETURNS boolean AS $$
 203 BEGIN
 204     IF (SELECT 1 FROM types.value WHERE type_id = 5 AND value_id = id) THEN
 205         RETURN NOT types._keyword_Q(id);
 206     END IF;
 207     RETURN false;
 208 END; $$ LANGUAGE plpgsql;
 209
 210
 211 -- _valueToString:
 212 -- takes a value_id for a string
 213 -- returns the varchar value of the string
 214 CREATE FUNCTION types._valueToString(sid integer) RETURNS varchar AS $$
 215 BEGIN
 216     RETURN (SELECT val_string FROM types.value WHERE value_id = sid);
 217 END; $$ LANGUAGE plpgsql;
 218
 219 -- _stringish:
 220 -- takes a varchar string
 221 -- returns the value_id of a stringish type (string, symbol, keyword)
 222 CREATE FUNCTION types._stringish(str varchar, type integer) RETURNS integer AS $$
 223 DECLARE
 224     result  integer;
 225 BEGIN
 226     -- TODO: share string data between string types
 227     -- lookup if it exists
 228     SELECT value_id FROM types.value INTO result
 229         WHERE val_string = str AND type_id = type;
 230     IF result IS NULL THEN
 231         -- Create string entry
 232         INSERT INTO types.value (type_id, val_string)
 233             VALUES (type, str)
 234             RETURNING value_id INTO result;
 235     END IF;
 236     RETURN result;
 237 END; $$ LANGUAGE plpgsql;
 238
 239 -- _stringv:
 240 -- takes a varchar string
 241 -- returns the value_id of a string (new or existing)
 242 CREATE FUNCTION types._stringv(str varchar) RETURNS integer AS $$
 243 BEGIN
 244     RETURN types._stringish(str, 5);
 245 END; $$ LANGUAGE plpgsql;
 246
 247 -- _keywordv:
 248 -- takes a varchar string
 249 -- returns the value_id of a keyword (new or existing)
 250 CREATE FUNCTION types._keywordv(name varchar) RETURNS integer AS $$
 251 BEGIN
 252     RETURN types._stringish(chr(CAST(x'7f' AS integer)) || name, 5);
 253 END; $$ LANGUAGE plpgsql;
 254
 255 -- _keyword_Q:
 256 -- takes a value_id
 257 -- returns the whether value_id is keyword type
 258 CREATE FUNCTION types._keyword_Q(id integer) RETURNS boolean AS $$
 259 DECLARE
 260     str  varchar;
 261 BEGIN
 262     IF (SELECT 1 FROM types.value WHERE type_id = 5 AND value_id = id) THEN
 263         str := types._valueToString(id);
 264         IF char_length(str) > 0 AND
 265            chr(CAST(x'7f' AS integer)) = substring(str FROM 1 FOR 1) THEN
 266             RETURN true;
 267         END IF;
 268     END IF;
 269     RETURN false;
 270 END; $$ LANGUAGE plpgsql;
 271
 272 -- _symbolv:
 273 -- takes a varchar string
 274 -- returns the value_id of a symbol (new or existing)
 275 CREATE FUNCTION types._symbolv(name varchar) RETURNS integer AS $$
 276 BEGIN
 277     RETURN types._stringish(name, 7);
 278 END; $$ LANGUAGE plpgsql;
 279
 280 -- _symbol_Q:
 281 -- takes a value_id
 282 -- returns the whether value_id is symbol type
 283 CREATE FUNCTION types._symbol_Q(id integer) RETURNS boolean AS $$
 284 BEGIN
 285     RETURN types._tf((SELECT 1 FROM types.value
 286             WHERE type_id = 7 AND value_id = id));
 287 END; $$ LANGUAGE plpgsql;
 288
 289 -- _numToValue:
 290 -- takes an bigint number
 291 -- returns the value_id for the number
 292 CREATE FUNCTION types._numToValue(num bigint) RETURNS integer AS $$
 293 DECLARE
 294     result  integer;
 295 BEGIN
 296     SELECT value_id FROM types.value INTO result
 297         WHERE val_int = num AND type_id = 3;
 298     IF result IS NULL THEN
 299         -- Create an integer entry
 300         INSERT INTO types.value (type_id, val_int)
 301             VALUES (3, num)
 302             RETURNING value_id INTO result;
 303     END IF;
 304     RETURN result;
 305 END; $$ LANGUAGE plpgsql;
 306
 307 -- ---------------------------------------------------------
 308 -- sequence functions
 309
 310 -- _sequential_Q:
 311 -- return true if obj value_id is a list or vector
 312 CREATE FUNCTION types._sequential_Q(obj integer) RETURNS boolean AS $$
 313 BEGIN
 314     RETURN types._tf((SELECT 1 FROM types.value
 315                 WHERE value_id = obj AND (type_id = 8 OR type_id = 9)));
 316 END; $$ LANGUAGE plpgsql;
 317
 318 -- _collection:
 319 -- takes a array of value_id integers
 320 -- returns the value_id of a new list (8), vector (9) or hash-map (10)
 321 CREATE FUNCTION types._collection(items integer[], type integer) RETURNS integer AS $$
 322 DECLARE
 323     vid  integer;
 324 BEGIN
 325     IF type IN (8, 9) THEN
 326         INSERT INTO types.value (type_id, val_seq)
 327             VALUES (type, items)
 328             RETURNING value_id INTO vid;
 329     ELSIF type = 10 THEN
 330         IF (array_length(items, 1) % 2) = 1 THEN
 331             RAISE EXCEPTION 'hash-map: odd number of arguments';
 332         END IF;
 333         INSERT INTO types.value (type_id, val_hash)
 334             VALUES (type, hstore(CAST(items AS varchar[])))
 335             RETURNING value_id INTO vid;
 336     END IF;
 337     RETURN vid;
 338 END; $$ LANGUAGE plpgsql;
 339
 340
 341 -- _list:
 342 -- takes a array of value_id integers
 343 -- returns the value_id of a new list
 344 CREATE FUNCTION types._list(items integer[]) RETURNS integer AS $$
 345 BEGIN
 346     RETURN types._collection(items, 8);
 347 END; $$ LANGUAGE plpgsql;
 348
 349 -- _vector:
 350 -- takes a array of value_id integers
 351 -- returns the value_id of a new list
 352 CREATE FUNCTION types._vector(items integer[]) RETURNS integer AS $$
 353 BEGIN
 354     RETURN types._collection(items, 9);
 355 END; $$ LANGUAGE plpgsql;
 356
 357 -- _list_Q:
 358 -- return true if obj value_id is a list
 359 CREATE FUNCTION types._list_Q(obj integer) RETURNS boolean AS $$
 360 BEGIN
 361     RETURN types._tf((SELECT 1 FROM types.value
 362             WHERE value_id = obj and type_id = 8));
 363 END; $$ LANGUAGE plpgsql;
 364
 365 -- _vector_Q:
 366 -- return true if obj value_id is a list
 367 CREATE FUNCTION types._vector_Q(obj integer) RETURNS boolean AS $$
 368 BEGIN
 369     RETURN types._tf((SELECT 1 FROM types.value
 370             WHERE value_id = obj and type_id = 9));
 371 END; $$ LANGUAGE plpgsql;
 372
 373
 374 -- _valueToArray:
 375 -- takes an value_id referring to a list or vector
 376 -- returns an array of the value_ids from the list/vector
 377 CREATE FUNCTION types._valueToArray(seq integer) RETURNS integer[] AS $$
 378 DECLARE
 379     result  integer[];
 380 BEGIN
 381     result := (SELECT val_seq FROM types.value WHERE value_id = seq);
 382     IF result IS NULL THEN
 383         result := ARRAY[]::integer[];
 384     END IF;
 385     RETURN result;
 386 END; $$ LANGUAGE plpgsql;
 387
 388 -- From: https://wiki.postgresql.org/wiki/Array_reverse
 389 CREATE FUNCTION types.array_reverse(a integer[]) RETURNS integer[] AS $$
 390 SELECT ARRAY(
 391     SELECT a[i]
 392     FROM generate_subscripts(a,1) AS s(i)
 393     ORDER BY i DESC
 394 );
 395 $$ LANGUAGE 'sql' STRICT IMMUTABLE;
 396
 397
 398 -- _nth:
 399 -- takes value_id and an index
 400 -- returns the value_id of nth element in list/vector
 401 CREATE FUNCTION types._nth(seq_id integer, indx integer) RETURNS integer AS $$
 402 DECLARE
 403     result  integer;
 404 BEGIN
 405     RETURN (SELECT val_seq[indx+1] FROM types.value WHERE value_id = seq_id);
 406 END; $$ LANGUAGE plpgsql;
 407
 408 -- _first:
 409 -- takes value_id
 410 -- returns the value_id of first element in list/vector
 411 CREATE FUNCTION types._first(seq_id integer) RETURNS integer AS $$
 412 BEGIN
 413     RETURN types._nth(seq_id, 0);
 414 END; $$ LANGUAGE plpgsql;
 415
 416
 417 -- _restArray:
 418 -- takes value_id
 419 -- returns the array of value_ids
 420 CREATE FUNCTION types._restArray(seq_id integer) RETURNS integer[] AS $$
 421 DECLARE
 422     result  integer[];
 423 BEGIN
 424     result := (SELECT val_seq FROM types.value WHERE value_id = seq_id);
 425     RETURN result[2:array_length(result, 1)];
 426 END; $$ LANGUAGE plpgsql;
 427
 428 -- _slice:
 429 -- takes value_id, a first index and an last index
 430 -- returns the value_id of new list from first (inclusive) to last (exclusive)
 431 CREATE FUNCTION types._slice(seq_id integer, first integer, last integer)
 432 RETURNS integer AS $$
 433 DECLARE
 434     seq            integer[];
 435     vid            integer;
 436     i              integer;
 437     result         integer;
 438 BEGIN
 439     SELECT val_seq INTO seq FROM types.value WHERE value_id = seq_id;
 440     INSERT INTO types.value (type_id, val_seq)
 441         VALUES (8, seq[first+1:last])
 442         RETURNING value_id INTO result;
 443     RETURN result;
 444 END; $$ LANGUAGE plpgsql;
 445
 446 -- _rest:
 447 -- takes value_id
 448 -- returns the value_id of new list
 449 CREATE FUNCTION types._rest(seq_id integer) RETURNS integer AS $$
 450 BEGIN
 451     RETURN types._slice(seq_id, 1, types._count(seq_id));
 452 END; $$ LANGUAGE plpgsql;
 453
 454 -- _count:
 455 -- takes value_id
 456 -- returns a count (not value_id)
 457 CREATE FUNCTION types._count(seq_id integer) RETURNS integer AS $$
 458 DECLARE
 459     result  integer[];
 460 BEGIN
 461     result := (SELECT val_seq FROM types.value
 462                          WHERE value_id = seq_id);
 463     RETURN COALESCE(array_length(result, 1), 0);
 464 END; $$ LANGUAGE plpgsql;
 465
 466
 467 -- ---------------------------------------------------------
 468 -- hash-map functions
 469
 470 -- _hash_map:
 471 -- return value_id of a new hash-map
 472 CREATE FUNCTION types._hash_map(items integer[]) RETURNS integer AS $$
 473 BEGIN
 474     RETURN types._collection(items, 10);
 475 END; $$ LANGUAGE plpgsql;
 476
 477 -- _hash_map_Q:
 478 -- return true if obj value_id is a list
 479 CREATE FUNCTION types._hash_map_Q(obj integer) RETURNS boolean AS $$
 480 BEGIN
 481     RETURN types._tf((SELECT 1 FROM types.value
 482             WHERE value_id = obj and type_id = 10));
 483 END; $$ LANGUAGE plpgsql;
 484
 485 -- _assoc_BANG:
 486 -- return value_id of the hash-map with new elements appended
 487 CREATE FUNCTION types._assoc_BANG(hm integer, items integer[]) RETURNS integer AS $$
 488 DECLARE
 489     hash  hstore;
 490 BEGIN
 491     IF (array_length(items, 1) % 2) = 1 THEN
 492         RAISE EXCEPTION 'hash-map: odd number of arguments';
 493     END IF;
 494     SELECT val_hash INTO hash FROM types.value WHERE value_id = hm;
 495     IF hash IS NULL THEN
 496         UPDATE types.value SET val_hash = hstore(CAST(items AS varchar[]))
 497             WHERE value_id = hm;
 498     ELSE
 499         UPDATE types.value
 500             SET val_hash = hash || hstore(CAST(items AS varchar[]))
 501             WHERE value_id = hm;
 502     END IF;
 503     RETURN hm;
 504 END; $$ LANGUAGE plpgsql;
 505
 506 -- _dissoc_BANG:
 507 -- return value_id of the hash-map with elements removed
 508 CREATE FUNCTION types._dissoc_BANG(hm integer, items integer[]) RETURNS integer AS $$
 509 DECLARE
 510     hash  hstore;
 511 BEGIN
 512     SELECT val_hash INTO hash FROM types.value WHERE value_id = hm;
 513     UPDATE types.value SET val_hash = hash - CAST(items AS varchar[])
 514             WHERE value_id = hm;
 515     RETURN hm;
 516 END; $$ LANGUAGE plpgsql;
 517
 518 -- _get:
 519 -- return value_id of the hash-map entry matching key
 520 CREATE FUNCTION types._get(hm integer, key varchar) RETURNS integer AS $$
 521 DECLARE
 522     hash  hstore;
 523 BEGIN
 524     SELECT val_hash INTO hash FROM types.value WHERE value_id = hm;
 525     RETURN hash -> CAST(types._stringv(key) AS varchar);
 526 END; $$ LANGUAGE plpgsql;
 527
 528 -- _contains_Q:
 529 -- return true if hash-map contains entry matching key
 530 CREATE FUNCTION types._contains_Q(hm integer, key varchar) RETURNS boolean AS $$
 531 DECLARE
 532     hash  hstore;
 533 BEGIN
 534     SELECT val_hash INTO hash FROM types.value WHERE value_id = hm;
 535     RETURN types._tf(hash ? CAST(types._stringv(key) AS varchar));
 536 END; $$ LANGUAGE plpgsql;
 537
 538 -- _keys:
 539 -- return array of key value_ids from hash-map
 540 CREATE FUNCTION types._keys(hm integer) RETURNS integer[] AS $$
 541 DECLARE
 542     hash  hstore;
 543 BEGIN
 544     SELECT val_hash INTO hash FROM types.value WHERE value_id = hm;
 545     RETURN CAST(akeys(hash) AS integer[]);
 546 END; $$ LANGUAGE plpgsql;
 547
 548 -- _vals:
 549 -- return array of value value_ids from hash-map
 550 CREATE FUNCTION types._vals(hm integer) RETURNS integer[] AS $$
 551 DECLARE
 552     hash  hstore;
 553 BEGIN
 554     SELECT val_hash INTO hash FROM types.value WHERE value_id = hm;
 555     RETURN CAST(avals(hash) AS integer[]);
 556 END; $$ LANGUAGE plpgsql;
 557
 558
 559 -- ---------------------------------------------------------
 560 -- function functions
 561
 562 -- _function:
 563 -- takes a function name
 564 -- returns the value_id of a new
 565 CREATE FUNCTION types._function(fname varchar)
 566 RETURNS varchar AS $$
 567 DECLARE
 568     result  integer;
 569 BEGIN
 570     INSERT INTO types.value (type_id, val_string)
 571         VALUES (11, fname)
 572         RETURNING value_id INTO result;
 573     RETURN CAST(result AS varchar);
 574 END; $$ LANGUAGE plpgsql;
 575
 576 -- _malfunc:
 577 -- takes a ast value_id, params value_id and env_id
 578 -- returns the value_id of a new function
 579 CREATE FUNCTION types._malfunc(ast integer, params integer, env integer)
 580 RETURNS integer AS $$
 581 DECLARE
 582     cid     integer = NULL;
 583     result  integer;
 584 BEGIN
 585     -- Create function entry
 586     INSERT INTO types.value (type_id, ast_id, params_id, env_id)
 587         VALUES (12, ast, params, env)
 588         RETURNING value_id into result;
 589     RETURN result;
 590 END; $$ LANGUAGE plpgsql;
 591
 592 -- _macro:
 593 CREATE FUNCTION types._macro(func integer) RETURNS integer AS $$
 594 DECLARE
 595     newfunc  integer;
 596     cid      integer;
 597 BEGIN
 598     newfunc := types._clone(func);
 599     UPDATE types.value SET macro = true WHERE value_id = newfunc;
 600     RETURN newfunc;
 601 END; $$ LANGUAGE plpgsql;
 602
 603 CREATE FUNCTION types._apply(func integer, args integer[]) RETURNS integer AS $$
 604 DECLARE
 605     type     integer;
 606     fcid     integer;
 607     fname    varchar;
 608     fast     integer;
 609     fparams  integer;
 610     fenv     integer;
 611     result   integer;
 612 BEGIN
 613     SELECT type_id, val_string, ast_id, params_id, env_id
 614         INTO type, fname, fast, fparams, fenv
 615         FROM types.value WHERE value_id = func;
 616     IF type = 11 THEN
 617         EXECUTE format('SELECT %s($1);', fname)
 618             INTO result USING args;
 619         RETURN result;
 620     ELSIF type = 12 THEN
 621         -- NOTE: forward reference to current step EVAL function
 622         RETURN mal.EVAL(fast, envs.new(fenv, fparams, args));
 623     ELSE
 624         RAISE EXCEPTION 'Invalid function call';
 625     END IF;
 626 END; $$ LANGUAGE plpgsql;
 627
 628 -- ---------------------------------------------------------
 629 -- atom functions
 630
 631 -- _atom:
 632 -- takes an ast value_id
 633 -- returns a new atom value_id
 634 CREATE FUNCTION types._atom(val integer) RETURNS integer AS $$
 635 DECLARE
 636     cid     integer = NULL;
 637     result  integer;
 638 BEGIN
 639     -- Create atom
 640     INSERT INTO types.value (type_id, val_seq)
 641         VALUES (13, ARRAY[val])
 642         RETURNING value_id INTO result;
 643     RETURN result;
 644 END; $$ LANGUAGE plpgsql;
 645
 646 -- _atom_Q:
 647 -- takes a value_id
 648 -- returns the whether value_id is an atom
 649 CREATE FUNCTION types._atom_Q(id integer) RETURNS boolean AS $$
 650 BEGIN
 651     RETURN EXISTS(SELECT 1 FROM types.value
 652         WHERE type_id = 13 AND value_id = id);
 653 END; $$ LANGUAGE plpgsql;
 654
 655 -- _deref:
 656 -- takes an atom value_id
 657 -- returns a atom value value_id
 658 CREATE FUNCTION types._deref(atm integer) RETURNS integer AS $$
 659 DECLARE
 660     result  integer;
 661 BEGIN
 662     RETURN (SELECT val_seq[1] FROM types.value WHERE value_id = atm);
 663 END; $$ LANGUAGE plpgsql;
 664
 665 -- _reset_BANG:
 666 -- takes an atom value_id and new value value_id
 667 -- returns a new value value_id
 668 CREATE FUNCTION types._reset_BANG(atm integer, newval integer) RETURNS integer AS $$
 669 BEGIN
 670     UPDATE types.value SET val_seq = ARRAY[newval] WHERE value_id = atm;
 671     RETURN newval;
 672 END; $$ LANGUAGE plpgsql;