Line data    Source code

       1             : /*
       2             :  * SPDX-License-Identifier: MPL-2.0
       3             :  *
       4             :  * This Source Code Form is subject to the terms of the Mozilla Public
       5             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       6             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       7             :  *
       8             :  * Copyright 2024 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : /*
      14             :  * K.S. Mullender & A. de Rijke
      15             :  * The UUID module
      16             :  * The UUID module contains a wrapper for all function in
      17             :  * libuuid.
      18             :  */
      19             : 
      20             : #include "monetdb_config.h"
      21             : #if defined(HAVE_GETENTROPY) && defined(HAVE_SYS_RANDOM_H)
      22             : #include <sys/random.h>
      23             : #endif
      24             : #include "mal.h"
      25             : #include "mal_exception.h"
      26             : #include "mal_interpreter.h"
      27             : 
      28             : #if !defined(HAVE_GETENTROPY) && defined(HAVE_RAND_S)
      29             : static inline bool
      30             : generate_uuid(uuid *U)
      31             : {
      32             :         union {
      33             :                 unsigned int randbuf[4];
      34             :                 unsigned char uuid[16];
      35             :         } u;
      36             :         for (int i = 0; i < 4; i++)
      37             :                 if (rand_s(&u.randbuf[i]) != 0)
      38             :                         return false;
      39             :         /* make sure this is a variant 1 UUID (RFC 4122/DCE 1.1) */
      40             :         u.uuid[8] = (u.uuid[8] & 0x3F) |0x80;
      41             :         /* make sure this is version 4 (random UUID) */
      42             :         u.uuid[6] = (u.uuid[6] & 0x0F) |0x40;
      43             :         memcpy(U->u, u.uuid, 16);
      44             :         return true;
      45             : }
      46             : #endif
      47             : 
      48             : /**
      49             :  * Returns the string representation of the given uuid value.
      50             :  * Warning: GDK function
      51             :  * Returns the length of the string
      52             :  */
      53             : static inline void
      54         102 : UUIDgenerateUuid_internal(uuid *u)
      55             : {
      56             : #if defined(HAVE_GETENTROPY)
      57         102 :         if (getentropy(u->u, 16) == 0) {
      58             :                 /* make sure this is a variant 1 UUID (RFC 4122/DCE 1.1) */
      59         102 :                 u->u[8] = (u->u[8] & 0x3F) | 0x80;
      60             :                 /* make sure this is version 4 (random UUID) */
      61         102 :                 u->u[6] = (u->u[6] & 0x0F) | 0x40;
      62             :         } else
      63             : #elif defined(HAVE_RAND_S)
      64             :         if (!generate_uuid(u))
      65             : #endif
      66             :         {
      67             :                 /* generate something like this:
      68             :                  * cefa7a9c-1dd2-41b2-8350-880020adbeef
      69             :                  * ("%08x-%04x-%04x-%04x-%012x") */
      70           0 :                 for (int i = 0; i < 16; i += 2) {
      71             : #ifdef __COVERITY__
      72             :                         int r = 0;
      73             : #else
      74           0 :                         int r = rand();
      75             : #endif
      76           0 :                         u->u[i] = (unsigned char) (r >> 8);
      77           0 :                         u->u[i + 1] = (unsigned char) r;
      78             :                 }
      79             :                 /* make sure this is a variant 1 UUID (RFC 4122/DCE 1.1) */
      80           0 :                 u->u[8] = (u->u[8] & 0x3F) | 0x80;
      81             :                 /* make sure this is version 4 (random UUID) */
      82           0 :                 u->u[6] = (u->u[6] & 0x0F) | 0x40;
      83             :         }
      84         102 : }
      85             : 
      86             : static str
      87         102 : UUIDgenerateUuid(uuid *retval)
      88             : {
      89         102 :         UUIDgenerateUuid_internal(retval);
      90         102 :         return MAL_SUCCEED;
      91             : }
      92             : 
      93             : static str
      94           0 : UUIDgenerateUuidInt(uuid *retval, const int *d)
      95             : {
      96           0 :         (void) d;
      97           0 :         return UUIDgenerateUuid(retval);
      98             : }
      99             : 
     100             : static inline bit
     101         101 : isaUUID(const char *s)
     102             : {
     103         101 :         uuid u, *pu = &u;
     104         101 :         size_t l = UUID_SIZE;
     105         101 :         ssize_t res = BATatoms[TYPE_uuid].atomFromStr(s, &l, (void **) &pu, false);
     106             : 
     107         102 :         if (res > 1)
     108             :                 return true;
     109          86 :         else if (res == 1)
     110          31 :                 return bit_nil;
     111             :         else
     112             :                 return false;
     113             : }
     114             : 
     115             : static str
     116           0 : UUIDgenerateUuidInt_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
     117             :                                                  InstrPtr pci)
     118             : {
     119           0 :         BAT *b = NULL, *bn = NULL;
     120           0 :         BUN n = 0;
     121           0 :         str msg = MAL_SUCCEED;
     122           0 :         uuid *restrict bnt = NULL;
     123           0 :         bat *ret = getArgReference_bat(stk, pci, 0);
     124           0 :         QryCtx *qry_ctx = MT_thread_get_qry_ctx();
     125             : 
     126           0 :         (void) cntxt;
     127           0 :         if (isaBatType(getArgType(mb, pci, 1))) {
     128           0 :                 bat *bid = getArgReference_bat(stk, pci, 1);
     129           0 :                 if (!(b = BBPquickdesc(*bid))) {
     130           0 :                         throw(MAL, "uuid.generateuuidint_bulk",
     131             :                                   SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     132             :                 }
     133           0 :                 n = BATcount(b);
     134             :         } else {
     135           0 :                 n = (BUN) *getArgReference_lng(stk, pci, 1);
     136             :         }
     137             : 
     138           0 :         if ((bn = COLnew(b ? b->hseqbase : 0, TYPE_uuid, n, TRANSIENT)) == NULL) {
     139           0 :                 throw(MAL, "uuid.generateuuidint_bulk",
     140             :                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
     141             :         }
     142           0 :         bnt = Tloc(bn, 0);
     143           0 :         TIMEOUT_LOOP_IDX_DECL(i, n, qry_ctx)
     144           0 :                 UUIDgenerateUuid_internal(&(bnt[i]));
     145           0 :         TIMEOUT_CHECK(qry_ctx, GOTO_LABEL_TIMEOUT_HANDLER(bailout, qry_ctx));
     146           0 :         BATsetcount(bn, n);
     147           0 :         bn->tnonil = true;
     148           0 :         bn->tnil = false;
     149           0 :         bn->tsorted = n <= 1;
     150           0 :         bn->trevsorted = n <= 1;
     151           0 :         bn->tkey = n <= 1;
     152           0 :         *ret = bn->batCacheid;
     153           0 :         BBPkeepref(bn);
     154           0 :         return msg;
     155           0 :   bailout:
     156           0 :         BBPreclaim(bn);
     157           0 :         throw(MAL, "uuid.generateuuidint_bulk", "%s", TIMEOUT_MESSAGE(qry_ctx));
     158             : }
     159             : 
     160             : static str
     161          31 : UUIDisaUUID(bit *retval, const char *const *s)
     162             : {
     163          31 :         *retval = isaUUID(*s);
     164          31 :         if (*retval == false)
     165          26 :                 GDKclrerr();
     166          31 :         return MAL_SUCCEED;
     167             : }
     168             : 
     169             : static str
     170          20 : UUIDisaUUID_bulk(bat *ret, const bat *bid)
     171             : {
     172          20 :         BAT *b = NULL, *bn = NULL;
     173          20 :         BUN q;
     174          20 :         bit *restrict dst;
     175          20 :         str msg = MAL_SUCCEED;
     176          20 :         BATiter bi;
     177             : 
     178          20 :         if ((b = BATdescriptor(*bid)) == NULL) {
     179           0 :                 msg = createException(MAL, "uuid.isaUUID_bulk",
     180             :                                                           SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     181           0 :                 goto bailout;
     182             :         }
     183          21 :         q = BATcount(b);
     184          21 :         if ((bn = COLnew(b->hseqbase, TYPE_bit, q, TRANSIENT)) == NULL) {
     185           0 :                 msg = createException(MAL, "uuid.isaUUID_bulk",
     186             :                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
     187           0 :                 goto bailout;
     188             :         }
     189          21 :         dst = Tloc(bn, 0);
     190          21 :         bi = bat_iterator(b);
     191          92 :         for (BUN p = 0; p < q; p++)
     192          71 :                 dst[p] = isaUUID(BUNtvar(bi, p));
     193          21 :         GDKclrerr();                            /* Not interested in atomFromStr errors */
     194          21 :         BATsetcount(bn, q);
     195          21 :         bn->tnonil = bi.nonil;
     196          21 :         bn->tnil = bi.nil;
     197          21 :         bn->tsorted = bn->trevsorted = q < 2;
     198          21 :         bn->tkey = false;
     199          21 :         bat_iterator_end(&bi);
     200          21 :   bailout:
     201          21 :         BBPreclaim(b);
     202          21 :         if (bn) {                                       /* implies msg==MAL_SUCCEED */
     203          21 :                 *ret = bn->batCacheid;
     204          21 :                 BBPkeepref(bn);
     205             :         }
     206          21 :         return msg;
     207             : }
     208             : 
     209             : static str
     210           0 : UUIDuuid2uuid(uuid *retval, const uuid *i)
     211             : {
     212           0 :         *retval = *i;
     213           0 :         return MAL_SUCCEED;
     214             : }
     215             : 
     216             : static str
     217           0 : UUIDuuid2uuid_bulk(bat *res, const bat *bid, const bat *sid)
     218             : {
     219           0 :         BAT *b = NULL, *s = NULL, *dst = NULL;
     220           0 :         uuid *restrict bv, *restrict dv;
     221           0 :         str msg = NULL;
     222           0 :         struct canditer ci;
     223           0 :         oid off;
     224           0 :         bool nils = false, btsorted = false, btrevsorted = false, btkey = false;
     225           0 :         BATiter bi;
     226             : 
     227           0 :         if (sid && !is_bat_nil(*sid)) {
     228           0 :                 if ((s = BATdescriptor(*sid)) == NULL) {
     229           0 :                         msg = createException(SQL, "batcalc.uuid2uuidbulk",
     230             :                                                                   SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     231           0 :                         goto bailout;
     232             :                 }
     233             :         } else {
     234           0 :                 BBPretain(*res = *bid); /* nothing to convert, return */
     235           0 :                 return MAL_SUCCEED;
     236             :         }
     237           0 :         if ((b = BATdescriptor(*bid)) == NULL) {
     238           0 :                 msg = createException(SQL, "batcalc.uuid2uuidbulk",
     239             :                                                           SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     240           0 :                 goto bailout;
     241             :         }
     242           0 :         off = b->hseqbase;
     243           0 :         canditer_init(&ci, b, s);
     244           0 :         if (!(dst = COLnew(ci.hseq, TYPE_uuid, ci.ncand, TRANSIENT))) {
     245           0 :                 msg = createException(SQL, "batcalc.uuid2uuidbulk",
     246             :                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
     247           0 :                 goto bailout;
     248             :         }
     249             : 
     250           0 :         bi = bat_iterator(b);
     251           0 :         bv = bi.base;
     252           0 :         dv = Tloc(dst, 0);
     253           0 :         if (ci.tpe == cand_dense) {
     254           0 :                 for (BUN i = 0; i < ci.ncand; i++) {
     255           0 :                         oid p = (canditer_next_dense(&ci) - off);
     256           0 :                         uuid v = bv[p];
     257             : 
     258           0 :                         dv[i] = v;
     259           0 :                         nils |= is_uuid_nil(v);
     260             :                 }
     261             :         } else {
     262           0 :                 for (BUN i = 0; i < ci.ncand; i++) {
     263           0 :                         oid p = (canditer_next(&ci) - off);
     264           0 :                         uuid v = bv[p];
     265             : 
     266           0 :                         dv[i] = v;
     267           0 :                         nils |= is_uuid_nil(v);
     268             :                 }
     269             :         }
     270           0 :         btkey = bi.key;
     271           0 :         btsorted = bi.sorted;
     272           0 :         btrevsorted = bi.revsorted;
     273           0 :         bat_iterator_end(&bi);
     274             : 
     275           0 :   bailout:
     276           0 :         BBPreclaim(b);
     277           0 :         BBPreclaim(s);
     278           0 :         if (dst) {                                      /* implies msg==MAL_SUCCEED */
     279           0 :                 BATsetcount(dst, ci.ncand);
     280           0 :                 dst->tnil = nils;
     281           0 :                 dst->tnonil = !nils;
     282           0 :                 dst->tkey = btkey;
     283           0 :                 dst->tsorted = btsorted;
     284           0 :                 dst->trevsorted = btrevsorted;
     285           0 :                 *res = dst->batCacheid;
     286           0 :                 BBPkeepref(dst);
     287             :         }
     288             :         return msg;
     289             : }
     290             : 
     291             : static str
     292          58 : UUIDstr2uuid(uuid *retval, const char *const *s)
     293             : {
     294          58 :         size_t l = UUID_SIZE;
     295             : 
     296          58 :         if (BATatoms[TYPE_uuid].atomFromStr(*s, &l, (void **) &retval, false) > 0) {
     297             :                 return MAL_SUCCEED;
     298             :         }
     299           6 :         throw(MAL, "uuid.uuid", "Not a UUID");
     300             : }
     301             : 
     302             : static str
     303           3 : UUIDstr2uuid_bulk(bat *res, const bat *bid, const bat *sid)
     304             : {
     305           3 :         BAT *b = NULL, *s = NULL, *dst = NULL;
     306           3 :         BATiter bi;
     307           3 :         str msg = NULL;
     308           3 :         uuid *restrict vals;
     309           3 :         struct canditer ci;
     310           3 :         oid off;
     311           3 :         bool nils = false, btkey = false;
     312           3 :         size_t l = UUID_SIZE;
     313           3 :         ssize_t (*conv)(const char *, size_t *, void **, bool) = BATatoms[TYPE_uuid].atomFromStr;
     314             : 
     315           3 :         if ((b = BATdescriptor(*bid)) == NULL) {
     316           0 :                 msg = createException(SQL, "batcalc.str2uuidbulk",
     317             :                                                           SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     318           0 :                 goto bailout;
     319             :         }
     320           3 :         if (sid && !is_bat_nil(*sid) && (s = BATdescriptor(*sid)) == NULL) {
     321           0 :                 msg = createException(SQL, "batcalc.str2uuidbulk",
     322             :                                                           SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     323           0 :                 goto bailout;
     324             :         }
     325           3 :         off = b->hseqbase;
     326           3 :         canditer_init(&ci, b, s);
     327           3 :         if (!(dst = COLnew(ci.hseq, TYPE_uuid, ci.ncand, TRANSIENT))) {
     328           0 :                 msg = createException(SQL, "batcalc.str2uuidbulk",
     329             :                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
     330           0 :                 goto bailout;
     331             :         }
     332             : 
     333           3 :         bi = bat_iterator(b);
     334           3 :         vals = Tloc(dst, 0);
     335           3 :         if (ci.tpe == cand_dense) {
     336           6 :                 for (BUN i = 0; i < ci.ncand; i++) {
     337           3 :                         oid p = (canditer_next_dense(&ci) - off);
     338           3 :                         const char *v = BUNtvar(bi, p);
     339           3 :                         uuid *up = &vals[i], **pp = &up;
     340             : 
     341           3 :                         if (conv(v, &l, (void **) pp, false) <= 0) {
     342           0 :                                 msg = createException(SQL, "batcalc.str2uuidbulk",
     343             :                                                                           SQLSTATE(42000) "Not a UUID");
     344           0 :                                 goto bailout1;
     345             :                         }
     346           6 :                         nils |= strNil(v);
     347             :                 }
     348             :         } else {
     349           0 :                 for (BUN i = 0; i < ci.ncand; i++) {
     350           0 :                         oid p = (canditer_next(&ci) - off);
     351           0 :                         const char *v = BUNtvar(bi, p);
     352           0 :                         uuid *up = &vals[i], **pp = &up;
     353             : 
     354           0 :                         if (conv(v, &l, (void **) pp, false) <= 0) {
     355           0 :                                 msg = createException(SQL, "batcalc.str2uuidbulk",
     356             :                                                                           SQLSTATE(42000) "Not a UUID");
     357           0 :                                 goto bailout1;
     358             :                         }
     359           0 :                         nils |= strNil(v);
     360             :                 }
     361             :         }
     362           3 :         btkey = bi.key;
     363           3 :   bailout1:
     364           3 :         bat_iterator_end(&bi);
     365             : 
     366           3 :   bailout:
     367           3 :         BBPreclaim(b);
     368           3 :         BBPreclaim(s);
     369           3 :         if (dst && !msg) {
     370           3 :                 BATsetcount(dst, ci.ncand);
     371           3 :                 dst->tnil = nils;
     372           3 :                 dst->tnonil = !nils;
     373           3 :                 dst->tkey = btkey;
     374           3 :                 dst->tsorted = BATcount(dst) <= 1;
     375           3 :                 dst->trevsorted = BATcount(dst) <= 1;
     376           3 :                 *res = dst->batCacheid;
     377           3 :                 BBPkeepref(dst);
     378           0 :         } else if (dst)
     379           0 :                 BBPreclaim(dst);
     380           3 :         return msg;
     381             : }
     382             : 
     383             : static str
     384         101 : UUIDuuid2str(str *retval, const uuid *u)
     385             : {
     386         101 :         size_t l = 0;
     387         101 :         *retval = NULL;
     388         101 :         if (BATatoms[TYPE_uuid].atomToStr(retval, &l, u, false) < 0)
     389           0 :                 throw(MAL, "uuid.str", GDK_EXCEPTION);
     390             :         return MAL_SUCCEED;
     391             : }
     392             : 
     393             : static str
     394           0 : UUIDuuid2str_bulk(bat *res, const bat *bid, const bat *sid)
     395             : {
     396           0 :         BAT *b = NULL, *s = NULL, *dst = NULL;
     397           0 :         str msg = NULL;
     398           0 :         uuid *restrict vals;
     399           0 :         struct canditer ci;
     400           0 :         oid off;
     401           0 :         bool nils = false, btkey = false;
     402           0 :         char buf[UUID_STRLEN + 2], *pbuf = buf;
     403           0 :         size_t l = sizeof(buf);
     404           0 :         ssize_t (*conv)(char **, size_t *, const void *, bool) = BATatoms[TYPE_uuid].atomToStr;
     405           0 :         BATiter bi;
     406             : 
     407           0 :         if ((b = BATdescriptor(*bid)) == NULL) {
     408           0 :                 msg = createException(SQL, "batcalc.uuid2strbulk",
     409             :                                                           SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     410           0 :                 goto bailout;
     411             :         }
     412           0 :         if (sid && !is_bat_nil(*sid) && (s = BATdescriptor(*sid)) == NULL) {
     413           0 :                 msg = createException(SQL, "batcalc.uuid2strbulk",
     414             :                                                           SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     415           0 :                 goto bailout;
     416             :         }
     417           0 :         off = b->hseqbase;
     418           0 :         canditer_init(&ci, b, s);
     419           0 :         if (!(dst = COLnew(ci.hseq, TYPE_str, ci.ncand, TRANSIENT))) {
     420           0 :                 msg = createException(SQL, "batcalc.uuid2strbulk",
     421             :                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
     422           0 :                 goto bailout;
     423             :         }
     424             : 
     425           0 :         bi = bat_iterator(b);
     426           0 :         vals = bi.base;
     427           0 :         if (ci.tpe == cand_dense) {
     428           0 :                 for (BUN i = 0; i < ci.ncand; i++) {
     429           0 :                         oid p = (canditer_next_dense(&ci) - off);
     430           0 :                         uuid v = vals[p];
     431             : 
     432           0 :                         if (conv(&pbuf, &l, &v, false) < 0) {    /* it should never be reallocated */
     433           0 :                                 msg = createException(MAL, "batcalc.uuid2strbulk",
     434             :                                                                           GDK_EXCEPTION);
     435           0 :                                 goto bailout1;
     436             :                         }
     437           0 :                         if (tfastins_nocheckVAR(dst, i, buf) != GDK_SUCCEED) {
     438           0 :                                 msg = createException(SQL, "batcalc.uuid2strbulk",
     439             :                                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
     440           0 :                                 goto bailout1;
     441             :                         }
     442           0 :                         nils |= strNil(buf);
     443             :                 }
     444             :         } else {
     445           0 :                 for (BUN i = 0; i < ci.ncand; i++) {
     446           0 :                         oid p = (canditer_next(&ci) - off);
     447           0 :                         uuid v = vals[p];
     448             : 
     449           0 :                         if (conv(&pbuf, &l, &v, false) < 0) {    /* it should never be reallocated */
     450           0 :                                 msg = createException(MAL, "batcalc.uuid2strbulk",
     451             :                                                                           GDK_EXCEPTION);
     452           0 :                                 goto bailout1;
     453             :                         }
     454           0 :                         if (tfastins_nocheckVAR(dst, i, buf) != GDK_SUCCEED) {
     455           0 :                                 msg = createException(SQL, "batcalc.uuid2strbulk",
     456             :                                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
     457           0 :                                 goto bailout1;
     458             :                         }
     459           0 :                         nils |= strNil(buf);
     460             :                 }
     461             :         }
     462           0 :         btkey = bi.key;
     463           0 :   bailout1:
     464           0 :         bat_iterator_end(&bi);
     465             : 
     466           0 :   bailout:
     467           0 :         BBPreclaim(b);
     468           0 :         BBPreclaim(s);
     469           0 :         if (dst && !msg) {
     470           0 :                 BATsetcount(dst, ci.ncand);
     471           0 :                 dst->tnil = nils;
     472           0 :                 dst->tnonil = !nils;
     473           0 :                 dst->tkey = btkey;
     474           0 :                 dst->tsorted = BATcount(dst) <= 1;
     475           0 :                 dst->trevsorted = BATcount(dst) <= 1;
     476           0 :                 *res = dst->batCacheid;
     477           0 :                 BBPkeepref(dst);
     478           0 :         } else if (dst)
     479           0 :                 BBPreclaim(dst);
     480           0 :         return msg;
     481             : }
     482             : 
     483             : #include "mel.h"
     484             : mel_func uuid_init_funcs[] = {
     485             :  command("uuid", "new", UUIDgenerateUuid, true, "Generate a new uuid", args(1,1, arg("",uuid))),
     486             :  command("uuid", "new", UUIDgenerateUuidInt, false, "Generate a new uuid (dummy version for side effect free multiplex loop)", args(1,2, arg("",uuid),arg("d",int))),
     487             :  pattern("batuuid", "new", UUIDgenerateUuidInt_bulk, false, "Generate a new uuid (dummy version for side effect free multiplex loop)", args(1,2, batarg("",uuid),batarg("d",int))),
     488             :  pattern("batuuid", "new", UUIDgenerateUuidInt_bulk, false, "Generate a new uuid (dummy version for side effect free multiplex loop)", args(1,2, batarg("",uuid),arg("card",lng))), /* version with cardinality input */
     489             :  command("uuid", "uuid", UUIDstr2uuid, false, "Coerce a string to a uuid, validating its format", args(1,2, arg("",uuid),arg("s",str))),
     490             :  command("uuid", "str", UUIDuuid2str, false, "Coerce a uuid to its string type", args(1,2, arg("",str),arg("u",uuid))),
     491             :  command("uuid", "isaUUID", UUIDisaUUID, false, "Test a string for a UUID format", args(1,2, arg("",bit),arg("u",str))),
     492             :  command("batuuid", "isaUUID", UUIDisaUUID_bulk, false, "Test a string for a UUID format", args(1,2, batarg("",bit),batarg("u",str))),
     493             :  command("calc", "uuid", UUIDstr2uuid, false, "Coerce a string to a uuid, validating its format", args(1,2, arg("",uuid),arg("s",str))),
     494             :  command("batcalc", "uuid", UUIDstr2uuid_bulk, false, "Coerce a string to a uuid, validating its format", args(1,3, batarg("",uuid),batarg("s",str),batarg("c",oid))),
     495             :  command("calc", "uuid", UUIDuuid2uuid, false, "", args(1,2, arg("",uuid),arg("u",uuid))),
     496             :  command("batcalc", "uuid", UUIDuuid2uuid_bulk, false, "", args(1,3, batarg("",uuid),batarg("u",uuid),batarg("c",oid))),
     497             :  command("calc", "str", UUIDuuid2str, false, "Coerce a uuid to a string type", args(1,2, arg("",str),arg("s",uuid))),
     498             :  command("batcalc", "str", UUIDuuid2str_bulk, false, "Coerce a uuid to a string type", args(1,3, batarg("",str),batarg("s",uuid),batarg("c",oid))),
     499             :  { .imp=NULL }
     500             : };
     501             : #include "mal_import.h"
     502             : #ifdef _MSC_VER
     503             : #undef read
     504             : #pragma section(".CRT$XCU",read)
     505             : #endif
     506         321 : LIB_STARTUP_FUNC(init_uuid_mal)
     507         321 : { mal_module("uuid", NULL, uuid_init_funcs); }