/libsrc/Wi/sparql.sql

https://github.com/XixiLuo/virtuoso-opensource · SQL · 17566 lines · 15959 code · 657 blank · 950 comment · 3103 complexity · 9f0d15e8b932454fa58f529fe45da796 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. --
    2. 

  2. --  $Id$
    3. 

  3. --
    4. 

  4. --  This file is part of the OpenLink Software Virtuoso Open-Source (VOS)
    5. 

  5. --  project.
    6. 

  6. --
    7. 

  7. --  Copyright (C) 1998-2014 OpenLink Software
    8. 

  8. --
    9. 

  9. --  This project is free software; you can redistribute it and/or modify it
    10. 

  10. --  under the terms of the GNU General Public License as published by the
    11. 

  11. --  Free Software Foundation; only version 2 of the License, dated June 1991.
    12. 

  12. --
    13. 

  13. --  This program is distributed in the hope that it will be useful, but
    14. 

  14. --  WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15. --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    16. 

  16. --  General Public License for more details.
    17. 

  17. --
    18. 

  18. --  You should have received a copy of the GNU General Public License along
    19. 

  19. --  with this program; if not, write to the Free Software Foundation, Inc.,
    20. 

  20. --  51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    21. 

  21. --
    22. 

  22. --
    23. 

  23. 

  24. create table DB.DBA.RDF_QUAD (
    25. 

  25.   G IRI_ID_8,
    26. 

  26.   S IRI_ID_8,
    27. 

  27.   P IRI_ID_8,
    28. 

  28.   O any,
    29. 

  29.   primary key (P, S, O, G) column
    30. 

  30.   )
    31. 

  31. alter index RDF_QUAD on DB.DBA.RDF_QUAD partition (S int (0hexffff00))
    32. 

  32. 

  33. create distinct no primary key ref column index RDF_QUAD_SP on DB.DBA.RDF_QUAD (S, P) partition (S int (0hexffff00))
    34. 

  34. create column index RDF_QUAD_POGS on DB.DBA.RDF_QUAD (P, O, S, G) partition (O varchar (-1, 0hexffff))
    35. 

  35. create distinct no primary key ref column index RDF_QUAD_GS on DB.DBA.RDF_QUAD (G, S) partition (S int (0hexffff00))
    36. 

  36. create distinct no primary key ref column index RDF_QUAD_OP on DB.DBA.RDF_QUAD (O, P) partition (O varchar (-1, 0hexffff))
    37. 

  37. ;
    38. 

  38. 

  39. create table DB.DBA.RDF_QUAD_RECOV_TMP (
    40. 

  40.   G1 IRI_ID_8,  S1 IRI_ID_8,  P1 IRI_ID_8,  O1 any,  primary key (P1, S1, O1, G1) column)
    41. 

  41. alter index RDF_QUAD_RECOV_TMP on DB.DBA.RDF_QUAD_RECOV_TMP partition (S1 int (0hexffff00))
    42. 

  42. create column index RDF_QUAD_RECOV_TMP_POGS on DB.DBA.RDF_QUAD_RECOV_TMP (P1, O1, G1, S1) partition (O1 varchar (-1, 0hexffff))
    43. 

  43. create distinct no primary key ref column index RDF_QUAD_RECOV_TMP_OP on DB.DBA.RDF_QUAD_RECOV_TMP (O1, P1) partition (O1 varchar (-1, 0hexffff))
    44. 

  44. ;
    45. 

  45. 

  46. create function DB.DBA.RDF_MAKE_IID_OF_QNAME_SAFE (in qname any) returns IRI_ID
    47. 

  47. {
    48. 

  48.   return iri_to_id_nosignal (qname);
    49. 

  49. }
    50. 

  50. ;
    51. 

  51. 

  52. create function DB.DBA.RDF_MAKE_IID_OF_QNAME_COMP (in qname any) returns IRI_ID
    53. 

  53. {
    54. 

  54.   return iri_to_id_nosignal (qname, 0);
    55. 

  55. }
    56. 

  56. ;
    57. 

  57. 

  58. create function DB.DBA.RDF_QNAME_OF_IID (in iid IRI_ID) returns varchar -- DEPRECATED
    59. 

  59. {
    60. 

  60.   return id_to_iri_nosignal (iid);
    61. 

  61. }
    62. 

  62. ;
    63. 

  63. 

  64. DB.DBA.RDF_MAKE_IID_OF_QNAME_SAFE (null)
    65. 

  65. ;
    66. 

  66. 

  67. DB.DBA.RDF_MAKE_IID_OF_QNAME_COMP (null)
    68. 

  68. ;
    69. 

  69. 

  70. DB.DBA.RDF_QNAME_OF_IID (null)
    71. 

  71. ;
    72. 

  72. 

  73. --create trigger DB.DBA.RDF_QUAD_O_AUDIT before insert on DB.DBA.RDF_QUAD
    74. 

  74. --{
    75. 

  75. --  if (not rdf_box_is_storeable (O))
    76. 

  76. --    signal ('RDFXX', 'non-storeable O');
    77. 

  77. --}
    78. 

  78. --;
    79. 

  79. 

  80. create table DB.DBA.RDF_OBJ (
    81. 

  81.   RO_ID bigint primary key,
    82. 

  82.   RO_VAL varchar not null,
    83. 

  83.   RO_LONG long varchar,
    84. 

  84.   RO_FLAGS smallint not null default 0,
    85. 

  85.   RO_DT_AND_LANG integer not null default 16843009 compress any
    86. 

  86. )
    87. 

  87. alter index RDF_OBJ on RDF_OBJ partition (RO_ID int (0hexffff00))
    88. 

  88. 

  89. create index RO_VAL on DB.DBA.RDF_OBJ (RO_VAL, RO_DT_AND_LANG)
    90. 

  90.  partition (RO_VAL varchar (-4, 0hexffff))
    91. 

  91. ;
    92. 

  92. 

  93. 

  94. create table DB.DBA.RO_START (RS_START varchar, RS_DT_AND_LANG int, RS_RO_ID any,
    95. 

  95.   primary key (RS_START, RS_DT_AND_LANG, RS_RO_ID))
    96. 

  96. alter index RO_START on DB.DBA.RO_START partition (RS_RO_ID varchar (-1, 0hexffff))
    97. 

  97. ;
    98. 

  98. 

  99. 

  100. --create table DB.DBA.RDF_FT (
    101. 

  101. --  RF_ID bigint primary key,
    102. 

  102. --  RF_O any)
    103. 

  103. --alter index RDF_FT on RDF_FT partition (RF_ID int (0hexffff00))
    104. 

  104. --create index RF_O on RDF_FT (RF_O) partition (RF_O varchar  (-1, 0hexffff))
    105. 

  105. --;
    106. 

  106. 

  107. create table DB.DBA.RDF_DATATYPE (
    108. 

  108.   RDT_IID IRI_ID_8 not null primary key,
    109. 

  109.   RDT_TWOBYTE integer not null unique,
    110. 

  110.   RDT_QNAME varchar not null unique )
    111. 

  111. alter index RDF_DATATYPE on RDF_DATATYPE partition cluster replicated
    112. 

  112. alter index DB_DBA_RDF_DATATYPE_UNQC_RDT_TWOBYTE   on RDF_DATATYPE partition cluster replicated
    113. 

  113. alter index DB_DBA_RDF_DATATYPE_UNQC_RDT_QNAME on RDF_DATATYPE partition cluster replicated
    114. 

  114. ;
    115. 

  115. 

  116. create table DB.DBA.RDF_LANGUAGE (
    117. 

  117.   RL_ID varchar not null primary key,
    118. 

  118.   RL_TWOBYTE integer not null unique )
    119. 

  119. alter index RDF_LANGUAGE on RDF_LANGUAGE  partition cluster replicated
    120. 

  120. alter index DB_DBA_RDF_LANGUAGE_UNQC_RL_TWOBYTE on RDF_LANGUAGE  partition cluster replicated
    121. 

  121. ;
    122. 

  122. 

  123. create table DB.DBA.SYS_SPARQL_HOST (
    124. 

  124.   SH_HOST	varchar not null primary key,
    125. 

  125.   SH_GRAPH_URI	varchar,
    126. 

  126.   SH_USER_URI	varchar,
    127. 

  127.   SH_BASE_URI	varchar,
    128. 

  128.   SH_DEFINES	long varchar
    129. 

  129. )
    130. 

  130. ;
    131. 

  131. 

  132. alter table DB.DBA.SYS_SPARQL_HOST add SH_BASE_URI varchar
    133. 

  133. ;
    134. 

  134. 

  135. create table DB.DBA.RDF_OBJ_FT_RULES (
    136. 

  136.   ROFR_G varchar not null,
    137. 

  137.   ROFR_P varchar not null,
    138. 

  138.   ROFR_REASON varchar not null,
    139. 

  139.   primary key (ROFR_G, ROFR_P, ROFR_REASON) )
    140. 

  140. alter index RDF_OBJ_FT_RULES on RDF_OBJ_FT_RULES partition cluster replicated
    141. 

  141. ;
    142. 

  142. 

  143. create table DB.DBA.SYS_SPARQL_SW_LOG (
    144. 

  144.     PL_SERVER varchar,
    145. 

  145.     PL_URI    varchar,
    146. 

  146.     PL_TS     timestamp,
    147. 

  147.     PL_RC     varchar,
    148. 

  148.     PL_MSG    long varchar,
    149. 

  149.     primary key (PL_SERVER, PL_URI, PL_TS))
    150. 

  150. ;
    151. 

  151. 

  152. create table DB.DBA.SYS_XML_PERSISTENT_NS_DECL
    153. 

  153. (
    154. 

  154.   NS_PREFIX varchar not null primary key,
    155. 

  155.   NS_URL varchar not null
    156. 

  156. )
    157. 

  157. alter index SYS_XML_PERSISTENT_NS_DECL on SYS_XML_PERSISTENT_NS_DECL partition cluster replicated
    158. 

  158. ;
    159. 

  159. 

  160. create table DB.DBA.RDF_EXPLICITLY_CREATED_GRAPH
    161. 

  161. (
    162. 

  162.   REC_GRAPH_IID IRI_ID not null primary key
    163. 

  163. )
    164. 

  164. alter index RDF_EXPLICITLY_CREATED_GRAPH on RDF_EXPLICITLY_CREATED_GRAPH partition cluster replicated
    165. 

  165. ;
    166. 

  166. 

  167. create table RDF_GEO (X real no compress, Y real no compress,X2 real no compress, Y2 real no compress, ID bigint no compress, primary key (X, Y, X2, Y2, ID))
    168. 

  168. alter index RDF_GEO on RDF_GEO partition (ID int (0hexffff00))
    169. 

  169. ;
    170. 

  170. 

  171. create table DB.DBA.RDF_LABEL (RL_O any primary key, RL_RO_ID bigint, RL_TEXT varchar, RL_LANG int)
    172. 

  172. alter index RDF_LABEL on RDF_LABEL partition (RL_O varchar (-1, 0hexffff))
    173. 

  173. create index RDF_LABEL_TEXT on RDF_LABEL (RL_TEXT, RL_O) partition (RL_TEXT varchar (6, 0hexffff))
    174. 

  174. ;
    175. 

  175. 

  176. create table DB.DBA.RDF_QUAD_DELETE_QUEUE (
    177. 

  177.   EVENT_ID bigint not null,
    178. 

  178.   RULE_ID bigint not null,
    179. 

  179.   QG IRI_ID not null,
    180. 

  180.   QS IRI_ID not null,
    181. 

  181.   QP IRI_ID not null,
    182. 

  182.   QO any not null,
    183. 

  183.   primary key (EVENT_ID, RULE_ID,  QG, QS, QP, QO)
    184. 

  184. )
    185. 

  185. ;
    186. 

  186. 

  187. create table DB.DBA.SYS_IDONLY_EMPTY
    188. 

  188. (
    189. 

  189.   ID integer not null primary key
    190. 

  190. )
    191. 

  191. ;
    192. 

  192. 

  193. create table DB.DBA.SYS_IDONLY_ONE
    194. 

  194. (
    195. 

  195.   ID integer not null primary key
    196. 

  196. )
    197. 

  197. ;
    198. 

  198. 

  199. insert soft DB.DBA.SYS_IDONLY_ONE (ID) values (0)
    200. 

  200. ;
    201. 

  201. 

  202. sequence_set ('RDF_URL_IID_NAMED', 1000000, 1)
    203. 

  203. ;
    204. 

  204. 

  205. sequence_set ('RDF_PREF_SEQ', 1, 1)
    206. 

  206. ;
    207. 

  207. 

  208. sequence_set ('RDF_URL_IID_BLANK', iri_id_num (min_bnode_iri_id ()), 1)
    209. 

  209. ;
    210. 

  210. 

  211. sequence_set ('RDF_URL_IID_NAMED_BLANK', iri_id_num (min_named_bnode_iri_id ()), 1)
    212. 

  212. ;
    213. 

  213. 

  214. sequence_set ('RDF_RO_ID', 1, 1)
    215. 

  215. ;
    216. 

  216. 

  217. sequence_set ('RDF_DATATYPE_TWOBYTE', 258, 1)
    218. 

  218. ;
    219. 

  219. 

  220. sequence_set ('RDF_LANGUAGE_TWOBYTE', 258, 1)
    221. 

  221. ;
    222. 

  222. 

  223. create procedure RDF_QUAD_FT_INIT ()
    224. 

  224. {
    225. 

  225.   if (not exists (select 1 from SYS_VT_INDEX where VI_COL = 'o'))
    226. 

  226.     {
    227. 

  227.       insert soft SYS_VT_INDEX (VI_TABLE, VI_INDEX, VI_COL, VI_ID_COL, VI_INDEX_TABLE, VI_ID_IS_PK, VI_OPTIONS)
    228. 

  228. 	values ('DB.DBA.RDF_QUAD', 'RDF_QUAD_OP', 'O', 'O', 'DB.DBA.RDF_GEO', 1, 'GR');
    229. 

  229.       insert soft SYS_VT_INDEX (VI_TABLE, VI_INDEX, VI_COL, VI_ID_COL, VI_INDEX_TABLE, VI_ID_IS_PK, VI_OPTIONS)
    230. 

  230. 	values ('DB.DBA.RDF_QUAD', 'RDF_QUAD_OP', 'o', 'O', 'DB.DBA.RDF_OBJ_RO_FLAGS_WORDS', 1, null);
    231. 

  231.       __ddl_changed ('DB.DBA.RDF_QUAD');
    232. 

  232.     }
    233. 

  233. }
    234. 

  234. ;
    235. 

  235. 

  236. create procedure DB.DBA.RDF_OBJ_RO_FLAGS_INDEX_HOOK (inout vtb any, inout d_id any)
    237. 

  237. {
    238. 

  238.   if (cl_current_slice () = 0hexffff)
    239. 

  239. {
    240. 

  240.   for (select RO_LONG, RO_VAL, RO_FLAGS
    241. 

  241. 	 from DB.DBA.RDF_OBJ  where RO_ID=d_id and bit_and (RO_FLAGS, 1)) do
    242. 

  242.     {
    243. 

  243.       if (bit_and (RO_FLAGS, 2))
    244. 

  244.         vt_batch_feed (vtb, xml_tree_doc (__xml_deserialize_packed (RO_LONG)), 0);
    245. 

  245.       else
    246. 

  246.         vt_batch_feed (vtb, coalesce (RO_LONG, RO_VAL), 0);
    247. 

  247.     }
    248. 

  248.  }
    249. 

  249.   else
    250. 

  250.     {
    251. 

  251.   for (select RO_LONG, RO_VAL, RO_FLAGS
    252. 

  252. 	 from DB.DBA.RDF_OBJ table option (no cluster) where RO_ID=d_id and bit_and (RO_FLAGS, 1)) do
    253. 

  253.     {
    254. 

  254.       if (bit_and (RO_FLAGS, 2))
    255. 

  255.         vt_batch_feed (vtb, xml_tree_doc (__xml_deserialize_packed (RO_LONG)), 0);
    256. 

  256.       else
    257. 

  257.         vt_batch_feed (vtb, coalesce (RO_LONG, RO_VAL), 0);
    258. 

  258.     }
    259. 

  259.     }
    260. 

  260.   return 1;
    261. 

  261. }
    262. 

  262. ;
    263. 

  263. 

  264. create procedure DB.DBA.RDF_OBJ_RO_FLAGS_UNINDEX_HOOK (inout vtb any, inout d_id any)
    265. 

  265. {
    266. 

  266.   if (cl_current_slice () = 0hexffff)
    267. 

  267.     {
    268. 

  268.   for (select RO_LONG, RO_VAL, RO_FLAGS
    269. 

  269. 	 from DB.DBA.RDF_OBJ  where RO_ID=d_id and bit_and (RO_FLAGS, 1)) do
    270. 

  270.     {
    271. 

  271.       if (bit_and (RO_FLAGS, 2))
    272. 

  272.         vt_batch_feed (vtb, xml_tree_doc (__xml_deserialize_packed (RO_LONG)), 1);
    273. 

  273.       else
    274. 

  274.         vt_batch_feed (vtb, coalesce (RO_LONG, RO_VAL), 1);
    275. 

  275.     }
    276. 

  276.     }
    277. 

  277.   else
    278. 

  278.     {
    279. 

  279.   for (select RO_LONG, RO_VAL, RO_FLAGS
    280. 

  280. 	 from DB.DBA.RDF_OBJ table option (no cluster) where RO_ID=d_id and bit_and (RO_FLAGS, 1)) do
    281. 

  281.     {
    282. 

  282.       if (bit_and (RO_FLAGS, 2))
    283. 

  283.         vt_batch_feed (vtb, xml_tree_doc (__xml_deserialize_packed (RO_LONG)), 1);
    284. 

  284.       else
    285. 

  285.         vt_batch_feed (vtb, coalesce (RO_LONG, RO_VAL), 1);
    286. 

  286.     }
    287. 

  287.     }
    288. 

  288.   return 1;
    289. 

  289. }
    290. 

  290. ;
    291. 

  291. 

  292. create procedure sparql_exec_quiet (in expn varchar)
    293. 

  293. {
    294. 

  294.   declare sta, msg varchar;
    295. 

  295.   exec (expn, sta, msg);
    296. 

  296. }
    297. 

  297. ;
    298. 

  298. 

  299. sparql_exec_quiet ('DB.DBA.vt_create_text_index (
    300. 

  300.       fix_identifier_case (''DB.DBA.RDF_OBJ''),
    301. 

  301.       fix_identifier_case (''RO_FLAGS''),
    302. 

  302.       fix_identifier_case (''RO_ID''),
    303. 

  303.       0, 0, vector (), 1, ''*ini*'', ''UTF-8-QR'')')
    304. 

  304. ;
    305. 

  305. 

  306. sparql_exec_quiet ('DB.DBA.vt_batch_update (fix_identifier_case (''DB.DBA.RDF_OBJ''), ''ON'', 1)')
    307. 

  307. ;
    308. 

  308. 

  309. --sparql_exec_quiet ('alter index VTLOG_DB_DBA_RDF_OBJ on VTLOG_DB_DBA_RDF_OBJ partition (VTLOG_RO_ID int (0hexffff00))')
    310. 

  310. --;
    311. 

  311. 

  312. --!AWK PUBLIC
    313. 

  313. create function DB.DBA.XML_SET_NS_DECL (in prefix varchar, in url varchar, in persist integer := 1) returns integer
    314. 

  314. {
    315. 

  315.   declare res integer;
    316. 

  316.   res := __xml_set_ns_decl (prefix, url, persist);
    317. 

  317.   if (bit_and (res, 2))
    318. 

  318.     {
    319. 

  319.       declare exit handler for sqlstate '*' { __xml_remove_ns_by_prefix (prefix, persist); resignal; };
    320. 

  320.       if (exists (select 1 from DB.DBA.SYS_XML_PERSISTENT_NS_DECL where NS_PREFIX = prefix and NS_URL = url))
    321. 

  321. 	return;
    322. 

  322.       delete from DB.DBA.SYS_XML_PERSISTENT_NS_DECL where NS_PREFIX = prefix;
    323. 

  323.       insert into DB.DBA.SYS_XML_PERSISTENT_NS_DECL (NS_PREFIX, NS_URL) values (prefix, url);
    324. 

  324.       commit work;
    325. 

  325.     }
    326. 

  326.   return res;
    327. 

  327. }
    328. 

  328. ;
    329. 

  329. 

  330. --!AWK PUBLIC
    331. 

  331. create procedure DB.DBA.XML_REMOVE_NS_BY_PREFIX (in prefix varchar, in persist integer := 1)
    332. 

  332. {
    333. 

  333.   declare res integer;
    334. 

  334.   __xml_remove_ns_by_prefix (prefix, persist);
    335. 

  335.   if (bit_and (persist, 2))
    336. 

  336.     {
    337. 

  337.       whenever sqlstate '*' goto again;
    338. 

  338. again:
    339. 

  339.       delete from DB.DBA.SYS_XML_PERSISTENT_NS_DECL where NS_PREFIX=prefix;
    340. 

  340.       commit work;
    341. 

  341.     }
    342. 

  342. }
    343. 

  343. ;
    344. 

  344. 

  345. --!AWK PUBLIC
    346. 

  346. create procedure DB.DBA.XML_CLEAR_ALL_NS_DECLS (in persist integer := 1)
    347. 

  347. {
    348. 

  348.   declare res integer;
    349. 

  349.   __xml_clear_all_ns_decls (persist);
    350. 

  350.   if (bit_and (persist, 2))
    351. 

  351.     {
    352. 

  352.       whenever sqlstate '*' goto again;
    353. 

  353. again:
    354. 

  354.       delete from DB.DBA.SYS_XML_PERSISTENT_NS_DECL;
    355. 

  355.       commit work;
    356. 

  356.     }
    357. 

  357. }
    358. 

  358. ;
    359. 

  359. 

  360. --!AWK PUBLIC
    361. 

  361. create procedure DB.DBA.XML_SELECT_ALL_NS_DECLS (in persist integer := 3)
    362. 

  362. {
    363. 

  363.   declare decls any;
    364. 

  364.   declare ctr, len integer;
    365. 

  365.   declare PREFIX, URI varchar;
    366. 

  366.   decls := __xml_get_all_ns_decls (persist);
    367. 

  367.   result_names (PREFIX, URI);
    368. 

  368.   len := length (decls);
    369. 

  369.   for (ctr := 0; ctr < len; ctr := ctr + 2)
    370. 

  370.     result (decls[ctr], decls[ctr+1]);
    371. 

  371. }
    372. 

  372. ;
    373. 

  373. 

  374. create procedure DB.DBA.XML_LOAD_ALL_NS_DECLS ()
    375. 

  375. {
    376. 

  376.   for (select NS_PREFIX, NS_URL from DB.DBA.SYS_XML_PERSISTENT_NS_DECL) do
    377. 

  377.     {
    378. 

  378.       __xml_set_ns_decl (NS_PREFIX, NS_URL, 2);
    379. 

  379.     }
    380. 

  380.   DB.DBA.XML_SET_NS_DECL (	'bif'		, 'bif:'	, 2);
    381. 

  381.   DB.DBA.XML_SET_NS_DECL (	'dawgt'		, 'http://www.w3.org/2001/sw/DataAccess/tests/test-dawg#'	, 2);
    382. 

  382.   DB.DBA.XML_SET_NS_DECL (	'dbpedia'	, 'http://dbpedia.org/resource/'				, 2);
    383. 

  383.   DB.DBA.XML_SET_NS_DECL (	'dbpprop'	, 'http://dbpedia.org/property/'				, 2);
    384. 

  384.   DB.DBA.XML_SET_NS_DECL (	'dc'		, 'http://purl.org/dc/elements/1.1/'				, 2);
    385. 

  385.   DB.DBA.XML_SET_NS_DECL (	'go'		, 'http://purl.org/obo/owl/GO#'					, 2);
    386. 

  386.   DB.DBA.XML_SET_NS_DECL (	'geo'		, 'http://www.w3.org/2003/01/geo/wgs84_pos#'			, 2);
    387. 

  387.   DB.DBA.XML_SET_NS_DECL (	'fn'		, 'http://www.w3.org/2005/xpath-functions/#'			, 2);
    388. 

  388.   DB.DBA.XML_SET_NS_DECL (	'foaf'		, 'http://xmlns.com/foaf/0.1/'					, 2);
    389. 

  389.   DB.DBA.XML_SET_NS_DECL (	'obo'		, 'http://www.geneontology.org/formats/oboInOwl#'		, 2);
    390. 

  390.   DB.DBA.XML_SET_NS_DECL (	'ogc'		, 'http://www.opengis.net/'					, 2);
    391. 

  391.   DB.DBA.XML_SET_NS_DECL (	'ogcgml'	, 'http://www.opengis.net/ont/gml#'				, 2);
    392. 

  392.   DB.DBA.XML_SET_NS_DECL (	'ogcgs'		, 'http://www.opengis.net/ont/geosparql#'			, 2);
    393. 

  393.   DB.DBA.XML_SET_NS_DECL (	'ogcgsf'	, 'http://www.opengis.net/def/function/geosparql/'		, 2);
    394. 

  394.   DB.DBA.XML_SET_NS_DECL (	'ogcgsr'	, 'http://www.opengis.net/def/rule/geosparql/'			, 2);
    395. 

  395.   DB.DBA.XML_SET_NS_DECL (	'ogcsf'		, 'http://www.opengis.net/ont/sf#'				, 2);
    396. 

  396.   DB.DBA.XML_SET_NS_DECL (	'owl'		, 'http://www.w3.org/2002/07/owl#'				, 2);
    397. 

  397.   DB.DBA.XML_SET_NS_DECL (	'mesh'		, 'http://purl.org/commons/record/mesh/'			, 2);
    398. 

  398.   DB.DBA.XML_SET_NS_DECL (	'math'		, 'http://www.w3.org/2000/10/swap/math#'			, 2);
    399. 

  399.   DB.DBA.XML_SET_NS_DECL (	'mf'		, 'http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#'	, 2);
    400. 

  400.   DB.DBA.XML_SET_NS_DECL (	'nci'		, 'http://ncicb.nci.nih.gov/xml/owl/EVS/Thesaurus.owl#'		, 2);
    401. 

  401.   DB.DBA.XML_SET_NS_DECL (	'product'	, 'http://www.buy.com/rss/module/productV2/'			, 2);
    402. 

  402.   DB.DBA.XML_SET_NS_DECL (	'protseq'	, 'http://purl.org/science/protein/bysequence/'			, 2);
    403. 

  403.   DB.DBA.XML_SET_NS_DECL (	'rdf'		, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'			, 2);
    404. 

  404.   DB.DBA.XML_SET_NS_DECL (	'rdfa'		, 'http://www.w3.org/ns/rdfa#'					, 2);
    405. 

  405.   DB.DBA.XML_SET_NS_DECL (	'rdfdf'		, 'http://www.openlinksw.com/virtrdf-data-formats#'		, 2);
    406. 

  406.   DB.DBA.XML_SET_NS_DECL (	'rdfs'		, 'http://www.w3.org/2000/01/rdf-schema#'			, 2);
    407. 

  407.   DB.DBA.XML_SET_NS_DECL (	'sc'		, 'http://purl.org/science/owl/sciencecommons/'			, 2);
    408. 

  408.   DB.DBA.XML_SET_NS_DECL (	'sd'		, 'http://www.w3.org/ns/sparql-service-description#'		, 2);
    409. 

  409.   DB.DBA.XML_SET_NS_DECL (	'sioc'		, 'http://rdfs.org/sioc/ns#'					, 2);
    410. 

  410.   DB.DBA.XML_SET_NS_DECL (	'skos'		, 'http://www.w3.org/2004/02/skos/core#'			, 2);
    411. 

  411.   DB.DBA.XML_SET_NS_DECL (	'sql'		, 'sql:'							, 2);
    412. 

  412.   DB.DBA.XML_SET_NS_DECL (	'vcard'		, 'http://www.w3.org/2001/vcard-rdf/3.0#'			, 2);
    413. 

  413.   DB.DBA.XML_SET_NS_DECL (	'vcard2006'	, 'http://www.w3.org/2006/vcard/ns#'				, 2);
    414. 

  414.   DB.DBA.XML_SET_NS_DECL (	'virtrdf'	, 'http://www.openlinksw.com/schemas/virtrdf#'			, 2);
    415. 

  415.   DB.DBA.XML_SET_NS_DECL (	'virtcxml'	, 'http://www.openlinksw.com/schemas/virtcxml#'			, 2);
    416. 

  416.   DB.DBA.XML_SET_NS_DECL (	'void'		, 'http://rdfs.org/ns/void#'					, 2);
    417. 

  417.   DB.DBA.XML_SET_NS_DECL (	'xf'		, 'http://www.w3.org/2004/07/xpath-functions'			, 2);
    418. 

  418.   DB.DBA.XML_SET_NS_DECL (	'xml'		, 'http://www.w3.org/XML/1998/namespace'			, 2);
    419. 

  419.   DB.DBA.XML_SET_NS_DECL (	'xsd'		, 'http://www.w3.org/2001/XMLSchema#'				, 2);
    420. 

  420.   DB.DBA.XML_SET_NS_DECL (	'xsl10'		, 'http://www.w3.org/XSL/Transform/1.0'				, 2);
    421. 

  421.   DB.DBA.XML_SET_NS_DECL (	'xsl1999'	, 'http://www.w3.org/1999/XSL/Transform'			, 2);
    422. 

  422.   DB.DBA.XML_SET_NS_DECL (	'xslwd'		, 'http://www.w3.org/TR/WD-xsl'					, 2);
    423. 

  423.   DB.DBA.XML_SET_NS_DECL (	'yago'		, 'http://dbpedia.org/class/yago/'				, 2);
    424. 

  424. }
    425. 

  425. ;
    426. 

  426. 

  427. DB.DBA.XML_LOAD_ALL_NS_DECLS ()
    428. 

  428. ;
    429. 

  429. 

  430. rdf_inf_const_init ()
    431. 

  431. ;
    432. 

  432. 

  433. create procedure DB.DBA.RDF_LOAD_ALL_FT_RULES ()
    434. 

  434. {
    435. 

  435.   whenever sqlstate '*' goto again;
    436. 

  436. again:
    437. 

  437.   for (select ROFR_G as rule_g, ROFR_P as rule_p, ROFR_REASON as reason from DB.DBA.RDF_OBJ_FT_RULES) do
    438. 

  438.     {
    439. 

  439.       declare rule_g_iid, rule_p_iid IRI_ID;
    440. 

  440.       rule_g_iid := case (rule_g) when '' then null else iri_to_id (rule_g) end;
    441. 

  441.       rule_p_iid := case (rule_p) when '' then null else iri_to_id (rule_p) end;
    442. 

  442.       -- dbg_obj_princ ('__rdf_obj_ft_rule_add (', rule_g_iid, rule_p_iid, reason, ')');
    443. 

  443.       __rdf_obj_ft_rule_add (rule_g_iid, rule_p_iid, reason);
    444. 

  444.     }
    445. 

  445. }
    446. 

  446. ;
    447. 

  447. 

  448. DB.DBA.RDF_LOAD_ALL_FT_RULES ()
    449. 

  449. ;
    450. 

  450. 

  451. create procedure DB.DBA.RDF_REPL_START (in quiet integer := 0)
    452. 

  452. {
    453. 

  453.   if (repl_this_server () is null)
    454. 

  454.     return;
    455. 

  455.   if (isstring (registry_get ('DB.DBA.RDF_REPL')))
    456. 

  456.     {
    457. 

  457.       if (quiet)
    458. 

  458.         return;
    459. 

  459.       signal ('RDF99', 'RDF replication is already enabled');
    460. 

  460.     }
    461. 

  461.   for (select RGGM_MEMBER_IID from DB.DBA.RDF_GRAPH_GROUP_MEMBER
    462. 

  462.   where RGGM_GROUP_IID = iri_to_id (UNAME'http://www.openlinksw.com/schemas/virtrdf#rdf_repl_graph_group')
    463. 

  463.     and not __rgs_ack_cbk (RGGM_MEMBER_IID, __rdf_repl_uid(), 1) ) do
    464. 

  464.     {
    465. 

  465.       signal ('RDF99', 'RDF replication can not be enabled because it will violate security rules for read access to graph <' || id_to_iri(RGGM_MEMBER_IID) || '> by __rdf_repl account');
    466. 

  466.     }
    467. 

  467.   repl_publish ('__rdf_repl', '__rdf_repl.log');
    468. 

  468.   repl_text ('__rdf_repl', '__rdf_repl_flush_queue()');
    469. 

  469.   DB.DBA.RDF_GRAPH_GROUP_CREATE (UNAME'http://www.openlinksw.com/schemas/virtrdf#rdf_repl_graph_group', 1);
    470. 

  470.   DB.DBA.CL_EXEC ('registry_set (?,?)', vector ('DB.DBA.RDF_REPL', cast (now() as varchar)));
    471. 

  471.   exec ('checkpoint');
    472. 

  472. }
    473. 

  473. ;
    474. 

  474. 

  475. create procedure DB.DBA.RDF_REPL_STOP (in quiet integer := 0)
    476. 

  476. {
    477. 

  477.   if (not isstring (registry_get ('DB.DBA.RDF_REPL')))
    478. 

  478.     {
    479. 

  479.       if (quiet)
    480. 

  480.         return;
    481. 

  481.       signal ('RDF99', 'RDF replication is not enabled');
    482. 

  482.     }
    483. 

  483.   repl_unpublish ('__rdf_repl');
    484. 

  484.   DB.DBA.CL_EXEC ('registry_remove (?)', vector ('DB.DBA.RDF_REPL'));
    485. 

  485. }
    486. 

  486. ;
    487. 

  487. 

  488. create procedure DB.DBA.RDF_REPL_GRAPH_INS (in memb_iri varchar)
    489. 

  489. {
    490. 

  490.   declare memb_iid IRI_ID;
    491. 

  491.   memb_iid := iri_to_id (memb_iri);
    492. 

  492.   memb_iri := id_to_iri (memb_iid);
    493. 

  493.   DB.DBA.RDF_GRAPH_GROUP_INS (UNAME'http://www.openlinksw.com/schemas/virtrdf#rdf_repl_graph_group', memb_iri);
    494. 

  494. }
    495. 

  495. ;
    496. 

  496. 

  497. create procedure DB.DBA.RDF_REPL_GRAPH_DEL (in memb_iri varchar)
    498. 

  498. {
    499. 

  499.   declare memb_iid IRI_ID;
    500. 

  500.   DB.DBA.RDF_GRAPH_GROUP_DEL (UNAME'http://www.openlinksw.com/schemas/virtrdf#rdf_repl_graph_group', memb_iri);
    501. 

  501. }
    502. 

  502. ;
    503. 

  503. 

  504. create procedure DB.DBA.RDF_REPL_SYNC (in publisher varchar, in u varchar, in pwd varchar)
    505. 

  505. {
    506. 

  506.   declare lvl, stat integer;
    507. 

  507.   if (repl_this_server () is null)
    508. 

  508.     return;
    509. 

  509.   commit work;
    510. 

  510. retr:
    511. 

  511. 

  512.   repl_sync (publisher, '__rdf_repl', u, pwd);
    513. 

  513. again:
    514. 

  514.   repl_status (publisher, '__rdf_repl', lvl, stat);
    515. 

  515.   if (0 = stat)
    516. 

  516.     {
    517. 

  517.       __rdf_repl_flush_queue();
    518. 

  518.       return;
    519. 

  519.     }
    520. 

  520.   if (1 = stat)
    521. 

  521.     {
    522. 

  522.       delay (0.1);
    523. 

  523.       goto again;
    524. 

  524.     }
    525. 

  525.   if (2 = stat)
    526. 

  526.     {
    527. 

  527.       __rdf_repl_flush_queue();
    528. 

  528.       return;
    529. 

  529.     }
    530. 

  530.   goto retr;
    531. 

  531. }
    532. 

  532. ;
    533. 

  533. 

  534. 

  535. create procedure DB.DBA.RDF_REPL_INSERT_TRIPLES (in graph_iri varchar, inout triples any)
    536. 

  536. {
    537. 

  537.   declare ctr integer;
    538. 

  538.   for (ctr := length (triples) - 1; ctr >= 0; ctr := ctr - 1)
    539. 

  539.     {
    540. 

  540.       declare s_iri, p_iri, o_val, o_type, o_lang any;
    541. 

  541.       s_iri := iri_canonicalize (triples[ctr][0]);
    542. 

  542.       p_iri := iri_canonicalize (triples[ctr][1]);
    543. 

  543.       o_val := triples[ctr][2];
    544. 

  544.       if (isiri_id (o_val))
    545. 

  545.         __rdf_repl_quad (84, graph_iri, s_iri, p_iri, iri_canonicalize (o_val));
    546. 

  546.       else if (__tag of rdf_box <> __tag (o_val))
    547. 

  547.         __rdf_repl_quad (80, graph_iri, s_iri, p_iri, o_val);
    548. 

  548.       else
    549. 

  549.         {
    550. 

  550.           declare dt_twobyte, lang_twobyte integer;
    551. 

  551.           dt_twobyte := rdf_box_type (o_val);
    552. 

  552.           lang_twobyte := rdf_box_lang (o_val);
    553. 

  553.           if (257 <> dt_twobyte)
    554. 

  554.             __rdf_repl_quad (81, graph_iri, s_iri, p_iri, rdf_box_data (o_val), (select RDT_QNAME from DB.DBA.RDF_DATATYPE where RDT_TWOBYTE = dt_twobyte), NULL);
    555. 

  555.           else if (257 <> lang_twobyte)
    556. 

  556.             __rdf_repl_quad (82, graph_iri, s_iri, p_iri, rdf_box_data (o_val), NULL, (select RL_ID from DB.DBA.RDF_LANGUAGE where RL_TWOBYTE = lang_twobyte));
    557. 

  557.           else
    558. 

  558.             __rdf_repl_quad (80, graph_iri, s_iri, p_iri, rdf_box_data (o_val));
    559. 

  559.         }
    560. 

  560.     }
    561. 

  561. }
    562. 

  562. ;
    563. 

  563. 

  564. create procedure DB.DBA.RDF_REPL_DELETE_TRIPLES (in graph_iri varchar, inout triples any)
    565. 

  565. {
    566. 

  566.   declare ctr integer;
    567. 

  567.   for (ctr := length (triples) - 1; ctr >= 0; ctr := ctr - 1)
    568. 

  568.     {
    569. 

  569.       declare s_iri, p_iri, o_val, o_type, o_lang any;
    570. 

  570.       s_iri := iri_canonicalize (triples[ctr][0]);
    571. 

  571.       p_iri := iri_canonicalize (triples[ctr][1]);
    572. 

  572.       o_val := triples[ctr][2];
    573. 

  573.       if (isiri_id (o_val))
    574. 

  574.         __rdf_repl_quad (164, graph_iri, s_iri, p_iri, iri_canonicalize (o_val));
    575. 

  575.       else if (__tag of rdf_box <> __tag (o_val))
    576. 

  576.         __rdf_repl_quad (160, graph_iri, s_iri, p_iri, o_val);
    577. 

  577.       else
    578. 

  578.         {
    579. 

  579.           declare dt_twobyte, lang_twobyte integer;
    580. 

  580.           dt_twobyte := rdf_box_type (o_val);
    581. 

  581.           lang_twobyte := rdf_box_lang (o_val);
    582. 

  582.           if (257 <> dt_twobyte)
    583. 

  583.             __rdf_repl_quad (161, graph_iri, s_iri, p_iri, rdf_box_data (o_val), (select RDT_QNAME from DB.DBA.RDF_DATATYPE where RDT_TWOBYTE = dt_twobyte), NULL);
    584. 

  584.           else if (257 <> lang_twobyte)
    585. 

  585.             __rdf_repl_quad (162, graph_iri, s_iri, p_iri, rdf_box_data (o_val), NULL, (select RL_ID from DB.DBA.RDF_LANGUAGE where RL_TWOBYTE = lang_twobyte));
    586. 

  586.           else
    587. 

  587.             __rdf_repl_quad (160, graph_iri, s_iri, p_iri, rdf_box_data (o_val));
    588. 

  588.         }
    589. 

  589.     }
    590. 

  590. }
    591. 

  591. ;
    592. 

  592. 

  593. --!AFTER
    594. 

  594. create procedure DB.DBA.RDF_GLOBAL_RESET (in hard integer := 0)
    595. 

  595. {
    596. 

  596.   if (isstring (registry_get ('DB.DBA.RDF_REPL')))
    597. 

  597.     {
    598. 

  598.       signal ('42RDF', 'Can not make DB.DBA.RDF_GLOBAL_RESET while an RDF replication is enabled');
    599. 

  599.     }
    600. 

  600. --  checkpoint;
    601. 

  601.   __atomic (1);
    602. 

  602.   iri_id_cache_flush ();
    603. 

  603.   __rdf_obj_ft_rule_zap_all ();
    604. 

  604.   dict_zap (__rdf_graph_group_dict(), 2);
    605. 

  605.   dict_zap (__rdf_graph_group_of_privates_dict(), 2);
    606. 

  606.   dict_zap (__rdf_graph_default_perms_of_user_dict(0), 2);
    607. 

  607.   dict_zap (__rdf_graph_default_perms_of_user_dict(1), 2);
    608. 

  608.   dict_zap (__rdf_graph_public_perms_dict(), 2);
    609. 

  609.   for select RS_NAME from DB.DBA.SYS_RDF_SCHEMA do
    610. 

  610.     rdf_inf_clear (RS_NAME);
    611. 

  611.   delete from sys_rdf_schema;
    612. 

  612.   delete from DB.DBA.RDF_QUAD;
    613. 

  613.   delete from DB.DBA.RDF_OBJ_FT_RULES;
    614. 

  614.   delete from DB.DBA.RDF_GRAPH_GROUP;
    615. 

  615.   for (select __id2i(t.RGU_GRAPH_IID) as graph_iri from (select distinct RGU_GRAPH_IID from DB.DBA.RDF_GRAPH_USER) as t) do
    616. 

  616.     {
    617. 

  617.       if (graph_iri is not null)
    618. 

  618.         {
    619. 

  619.           jso_mark_affected (graph_iri);
    620. 

  620.           log_text ('jso_mark_affected (?)', graph_iri);
    621. 

  621.           jso_mark_affected (iri_canonicalize (graph_iri));
    622. 

  622.           log_text ('jso_mark_affected (?)', iri_canonicalize (graph_iri));
    623. 

  623.           log_text ('jso_mark_affected (iri_canonicalize (?))', graph_iri);
    624. 

  624.         }
    625. 

  625.     }
    626. 

  626.   for (select __id2i(t.RGGM_GROUP_IID) as group_iri from (select distinct RGGM_GROUP_IID from DB.DBA.RDF_GRAPH_GROUP_MEMBER) as t) do
    627. 

  627.     {
    628. 

  628.       if (group_iri is not null)
    629. 

  629. 	{
    630. 

  630. 	  jso_mark_affected (group_iri);
    631. 

  631. 	  log_text ('jso_mark_affected (?)', group_iri);
    632. 

  632. 	}
    633. 

  633.     }
    634. 

  634.   for (select __id2i(RGGM_MEMBER_IID) as memb_iri from DB.DBA.RDF_GRAPH_GROUP_MEMBER where RGGM_GROUP_IID = __i2id ('http://www.openlinksw.com/schemas/virtrdf#PrivateGraphs')) do
    635. 

  635.     {
    636. 

  636.       if (memb_iri is not null)
    637. 

  637. 	{
    638. 

  638. 	  jso_mark_affected (memb_iri);
    639. 

  639. 	  log_text ('jso_mark_affected (?)', memb_iri);
    640. 

  640. 	}
    641. 

  641.     }
    642. 

  642.   for (sparql define input:storage "" select distinct str (?qms) as ?qms_iri from virtrdf: where { ?qms a virtrdf:QuadStorage } ) do
    643. 

  643.     {
    644. 

  644.       if ("qms_iri" is not null)
    645. 

  645. 	{
    646. 

  646. 	  jso_mark_affected ("qms_iri");
    647. 

  647. 	  log_text ('jso_mark_affected (?)', "qms_iri");
    648. 

  648. 	}
    649. 

  649.     }
    650. 

  650.   jso_mark_affected ('http://www.openlinksw.com/schemas/virtrdf#PrivateGraphs');
    651. 

  651.   log_text ('jso_mark_affected (?)', 'http://www.openlinksw.com/schemas/virtrdf#PrivateGraphs');
    652. 

  652.   jso_mark_affected ('http://www.openlinksw.com/schemas/virtrdf#DefaultQuadStorage');
    653. 

  653.   log_text ('jso_mark_affected (?)', 'http://www.openlinksw.com/schemas/virtrdf#DefaultQuadStorage');
    654. 

  654.   jso_mark_affected ('http://www.openlinksw.com/schemas/virtrdf#DefaultQuadMap');
    655. 

  655.   log_text ('jso_mark_affected (?)', 'http://www.openlinksw.com/schemas/virtrdf#DefaultQuadMap');
    656. 

  656.   delete from DB.DBA.RDF_GRAPH_GROUP_MEMBER;
    657. 

  657.   delete from DB.DBA.RDF_GRAPH_USER;
    658. 

  658.   delete from DB.DBA.RDF_LABEL;
    659. 

  659.   delete from DB.DBA.RDF_GEO;
    660. 

  660.   commit work;
    661. 

  661.   if (hard)
    662. 

  662.     {
    663. 

  663.       --delete from DB.DBA.RDF_URL;
    664. 

  664.       delete from DB.DBA.RDF_IRI;
    665. 

  665.       delete from DB.DBA.RDF_PREFIX;
    666. 

  666.       delete from DB.DBA.RDF_OBJ;
    667. 

  667.       delete from DB.DBA.RO_START;
    668. 

  668.       delete from DB.DBA.RDF_DATATYPE;
    669. 

  669.       delete from DB.DBA.RDF_LANGUAGE;
    670. 

  670.       --__rdf_twobyte_cache_zap();
    671. 

  671.       --log_text ('__rdf_twobyte_cache_zap()');
    672. 

  672.       delete from DB.DBA.VTLOG_DB_DBA_RDF_OBJ;
    673. 

  673.       delete from DB.DBA.RDF_OBJ_RO_FLAGS_WORDS;
    674. 

  674.       sequence_set ('RDF_URL_IID_NAMED', 1000000, 0);
    675. 

  675.       sequence_set ('RDF_URL_IID_BLANK', iri_id_num (min_bnode_iri_id ()), 0);
    676. 

  676.       sequence_set ('RDF_URL_IID_NAMED_BLANK', iri_id_num (min_named_bnode_iri_id ()), 0);
    677. 

  677.       sequence_set ('RDF_PREF_SEQ', 1, 0);
    678. 

  678.       sequence_set ('RDF_RO_ID', 1, 0);
    679. 

  679.       sequence_set ('RDF_DATATYPE_TWOBYTE', 258, 0);
    680. 

  680.       sequence_set ('RDF_LANGUAGE_TWOBYTE', 258, 0);
    681. 

  681.       __atomic (0);
    682. 

  682.       exec ('checkpoint');
    683. 

  683.       raw_exit ();
    684. 

  684.     }
    685. 

  685.   sequence_set ('RDF_URL_IID_NAMED', 1000000, 1);
    686. 

  686.   sequence_set ('RDF_URL_IID_BLANK', iri_id_num (min_bnode_iri_id ()), 1);
    687. 

  687.   sequence_set ('RDF_URL_IID_NAMED_BLANK', iri_id_num (min_named_bnode_iri_id ()), 1);
    688. 

  688.   sequence_set ('RDF_PREF_SEQ', 1, 1);
    689. 

  689.   sequence_set ('RDF_RO_ID', 1, 1);
    690. 

  690.   sequence_set ('RDF_DATATYPE_TWOBYTE', 258, 1);
    691. 

  691.   sequence_set ('RDF_LANGUAGE_TWOBYTE', 258, 1);
    692. 

  692.   DB.DBA.RDF_LOAD_ALL_FT_RULES ();
    693. 

  693.   DB.DBA.TTLP (
    694. 

  694.     cast ( DB.DBA.XML_URI_GET (
    695. 

  695.         'http://www.openlinksw.com/sparql/virtrdf-data-formats.ttl', '' ) as varchar ),
    696. 

  696.     '', 'http://www.openlinksw.com/schemas/virtrdf#' );
    697. 

  697.   DB.DBA.TTLP ('
    698. 

  698. @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
    699. 

  699. @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
    700. 

  700. @prefix owl: <http://www.w3.org/2002/07/owl#> .
    701. 

  701. @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
    702. 

  702. @prefix virtrdf: <http://www.openlinksw.com/schemas/virtrdf#> .
    703. 

  703. @prefix rdfdf: <http://www.openlinksw.com/virtrdf-data-formats#> .
    704. 

  704. @prefix atom: <http://atomowl.org/ontologies/atomrdf#> .
    705. 

  705. 

  706. virtrdf:DefaultQuadStorage
    707. 

  707.   rdf:type virtrdf:QuadStorage ;
    708. 

  708.   virtrdf:qsUserMaps virtrdf:DefaultQuadStorage-UserMaps ;
    709. 

  709.   virtrdf:qsDefaultMap virtrdf:DefaultQuadMap ;
    710. 

  710.   virtrdf:qsMatchingFlags virtrdf:SPART_QS_NO_IMPLICIT_USER_QM .
    711. 

  711. virtrdf:DefaultQuadStorage-UserMaps
    712. 

  712.       rdf:type virtrdf:array-of-QuadMap .
    713. 

  713. 

  714. virtrdf:DefaultServiceStorage
    715. 

  715.   rdf:type virtrdf:QuadStorage ;
    716. 

  716.   virtrdf:qsUserMaps virtrdf:DefaultServiceStorage-UserMaps ;
    717. 

  717.   virtrdf:qsDefaultMap virtrdf:DefaultServiceMap ;
    718. 

  718.   virtrdf:qsMatchingFlags virtrdf:SPART_QS_NO_IMPLICIT_USER_QM .
    719. 

  719. virtrdf:DefaultServiceStorage-UserMaps
    720. 

  720.   rdf:type virtrdf:array-of-QuadMap .
    721. 

  721. 

  722. virtrdf:SyncToQuads
    723. 

  723.   rdf:type virtrdf:QuadStorage ;
    724. 

  724.   virtrdf:qsUserMaps virtrdf:SyncToQuads-UserMaps .
    725. 

  725. virtrdf:SyncToQuads-UserMaps
    726. 

  726.   rdf:type virtrdf:array-of-QuadMap .
    727. 

  727. 

  728.   ', '', 'http://www.openlinksw.com/schemas/virtrdf#' );
    729. 

  729.   delete from SYS_HTTP_SPONGE where HS_PARSER = 'DB.DBA.RDF_LOAD_HTTP_RESPONSE';
    730. 

  730.   commit work;
    731. 

  731.   sequence_set ('RDF_URL_IID_NAMED', 1010000, 1);
    732. 

  732.   sequence_set ('RDF_URL_IID_BLANK', iri_id_num (min_bnode_iri_id ()) + 10000, 1);
    733. 

  733.   sequence_set ('RDF_URL_IID_NAMED_BLANK', iri_id_num (min_named_bnode_iri_id ()) + 10000, 1);
    734. 

  734.   sequence_set ('RDF_PREF_SEQ', 101, 1);
    735. 

  735.   sequence_set ('RDF_RO_ID', 1001, 1);
    736. 

  736.   iri_id_cache_flush ();
    737. 

  737.   DB.DBA.SPARQL_RELOAD_QM_GRAPH ();
    738. 

  738.   __atomic (0);
    739. 

  739.   exec ('checkpoint');
    740. 

  740. }
    741. 

  741. ;
    742. 

  742. 

  743. 

  744. -----
    745. 

  745. -- Handling of IRI IDs
    746. 

  746. 

  747. create function DB.DBA.RDF_MAKE_IID_OF_QNAME (in qname varchar) returns IRI_ID
    748. 

  748. {
    749. 

  749.   return iri_to_id (qname);
    750. 

  750. }
    751. 

  751. ;
    752. 

  752. 

  753. 

  754. create function DB.DBA.RDF_MAKE_IID_OF_LONG (in qname any) returns IRI_ID -- DEPRECATED
    755. 

  755. {
    756. 

  756.   if (isiri_id (qname))
    757. 

  757.     return qname;
    758. 

  758.   if (not isstring (qname))
    759. 

  759.     {
    760. 

  760.       if (__tag of rdf_box = __tag (qname) and rdf_box_is_complete (qname))
    761. 

  761.         qname := rdf_box_data (qname, 1);
    762. 

  762.       else
    763. 

  763.         qname := __rdf_strsqlval (qname);
    764. 

  764.     }
    765. 

  765.   return iri_to_id_nosignal (qname);
    766. 

  766. }
    767. 

  767. ;
    768. 

  768. 

  769. create function DB.DBA.RDF_MAKE_GRAPH_IIDS_OF_QNAMES (in qnames any) returns any
    770. 

  770. {
    771. 

  771.   if (__tag of vector <> __tag (qnames))
    772. 

  772.     return vector ();
    773. 

  773.   declare res_acc any;
    774. 

  774.   vectorbld_init (res_acc);
    775. 

  775.   foreach (any qname in qnames) do
    776. 

  776.     {
    777. 

  777.       declare iid IRI_ID;
    778. 

  778.       whenever sqlstate '*' goto skip_acc;
    779. 

  779.       iid := iri_to_id (qname, 0, 0);
    780. 

  780.       if (not isinteger (iid))
    781. 

  781.         vectorbld_acc (res_acc, iid);
    782. 

  782. skip_acc: ;
    783. 

  783.     }
    784. 

  784.   vectorbld_final (res_acc);
    785. 

  785.   return res_acc;
    786. 

  786. }
    787. 

  787. ;
    788. 

  788. 

  789. -----
    790. 

  790. -- Datatypes and languages
    791. 

  791. 

  792. create function DB.DBA.RDF_TWOBYTE_OF_DATATYPE (in iid any) returns integer
    793. 

  793. {
    794. 

  794.   declare res integer;
    795. 

  795.   declare qname varchar;
    796. 

  796.   if (iid is null)
    797. 

  797.     return 257;
    798. 

  798.   if (not isiri_id (iid))
    799. 

  799.     {
    800. 

  800.       declare new_iid IRI_ID;
    801. 

  801.       new_iid := iri_to_id (iid);
    802. 

  802.       if (new_iid is NULL or new_iid >= min_bnode_iri_id ())
    803. 

  803.         signal ('RDFXX', 'Invalid datatype IRI_ID passes as an argument to DB.DBA.RDF_TWOBYTE_OF_DATATYPE()');
    804. 

  804.       iid := new_iid;
    805. 

  805.     }
    806. 

  806.   qname := id_to_iri (iid);
    807. 

  807.   res := rdf_cache_id ('t', qname);
    808. 

  808.   if (res)
    809. 

  809.     return res;
    810. 

  810.   whenever not found goto mknew;
    811. 

  811.   set isolation='committed';
    812. 

  812.   select RDT_TWOBYTE into res from DB.DBA.RDF_DATATYPE where RDT_IID = iid;
    813. 

  813.   return res;
    814. 

  814. 

  815. mknew:
    816. 

  816.   set isolation='serializable';
    817. 

  817.   declare tb_cr cursor for select RDT_TWOBYTE from DB.DBA.RDF_DATATYPE where RDT_IID = iid;
    818. 

  818.   open tb_cr (exclusive);
    819. 

  819.   whenever not found goto mknew_ser;
    820. 

  820.   fetch tb_cr into res;
    821. 

  821.   return res;
    822. 

  822. 

  823. mknew_ser:
    824. 

  824.   res := sequence_next ('RDF_DATATYPE_TWOBYTE');
    825. 

  825.   if (0 = bit_and (res, 255))
    826. 

  826.     {
    827. 

  827.       if (res = 0hex7F00)
    828. 

  828.         {
    829. 

  829.           sequence_set ('RDF_DATATYPE_TWOBYTE', 0hex7F00, 0);
    830. 

  830.           res := 0hex7F01;
    831. 

  831.           qname := 'http://www.openlinksw.com/schemas/virtrdf#Unsaved';
    832. 

  832.           iid := iri_to_id (qname);
    833. 

  833.           insert soft DB.DBA.RDF_DATATYPE
    834. 

  834.             (RDT_IID, RDT_TWOBYTE, RDT_QNAME)
    835. 

  835.           values (iid, res, qname);
    836. 

  836.           goto cache_and_log;
    837. 

  837.         }
    838. 

  838.       res := sequence_next ('RDF_DATATYPE_TWOBYTE');
    839. 

  839.     }
    840. 

  840.   insert into DB.DBA.RDF_DATATYPE
    841. 

  841.     (RDT_IID, RDT_TWOBYTE, RDT_QNAME)
    842. 

  842.   values (iid, res, qname);
    843. 

  843. cache_and_log:
    844. 

  844.   rdf_cache_id ('t', qname, res);
    845. 

  845.   log_text ('rdf_cache_id (\'t\', ?, ?)', qname, res);  --'
    846. 

  846.   return res;
    847. 

  847. }
    848. 

  848. ;
    849. 

  849. 

  850. create function DB.DBA.RDF_PRESET_TWOBYTES_OF_DATATYPES ()
    851. 

  851. {
    852. 

  852.   declare xsd_lnames any;
    853. 

  853.   xsd_lnames := vector (
    854. 

  854.     'ENTITY',
    855. 

  855.     'ENTITIES',
    856. 

  856.     'ID',
    857. 

  857.     'IDREF',
    858. 

  858.     'IDREFS',
    859. 

  859.     'NCName',
    860. 

  860.     'Name',
    861. 

  861.     'NMTOKEN',
    862. 

  862.     'NMTOKENS',
    863. 

  863.     'NOTATION',
    864. 

  864.     'QName',
    865. 

  865.     'any',
    866. 

  866.     'anyAtomicType',
    867. 

  867.     'anySimpleType',
    868. 

  868.     'anyType',
    869. 

  869.     'anyURI',
    870. 

  870.     'base64Binary',
    871. 

  871.     'boolean',
    872. 

  872.     'byte',
    873. 

  873.     'date',
    874. 

  874.     'dateTime',
    875. 

  875.     'dateTimeStamp',
    876. 

  876.     'dayTimeDuration',
    877. 

  877.     'decimal',
    878. 

  878.     'double',
    879. 

  879.     'duration',
    880. 

  880.     'float',
    881. 

  881.     'gDay',
    882. 

  882.     'gMonth',
    883. 

  883.     'gMonthDay',
    884. 

  884.     'gYear',
    885. 

  885.     'gYearMonth',
    886. 

  886.     'hexBinary',
    887. 

  887.     'int',
    888. 

  888.     'integer',
    889. 

  889.     'language',
    890. 

  890.     'long',
    891. 

  891.     'negativeInteger',
    892. 

  892.     'nonNegativeInteger',
    893. 

  893.     'nonPositiveInteger',
    894. 

  894.     'normalizedString',
    895. 

  895.     'positiveInteger',
    896. 

  896.     'short',
    897. 

  897.     'string',
    898. 

  898.     'time',
    899. 

  899.     'token',
    900. 

  900.     'unsignedByte',
    901. 

  901.     'unsignedInt',
    902. 

  902.     'unsignedLong',
    903. 

  903.     'unsignedShort',
    904. 

  904.     'yearMonthDuration' );
    905. 

  905.   foreach (varchar n in xsd_lnames) do
    906. 

  906.     {
    907. 

  907.       __dbf_set ('rb_type__xsd:' || n, DB.DBA.RDF_TWOBYTE_OF_DATATYPE (iri_to_id ('http://www.w3.org/2001/XMLSchema#' || n)));
    908. 

  908.     }
    909. 

  909.   commit work;
    910. 

  910. }
    911. 

  911. ;
    912. 

  912. 

  913. DB.DBA.RDF_PRESET_TWOBYTES_OF_DATATYPES ()
    914. 

  914. ;
    915. 

  915. 

  916. create function DB.DBA.RDF_TWOBYTE_OF_LANGUAGE (in id varchar) returns integer
    917. 

  917. {
    918. 

  918.   declare res integer;
    919. 

  919.   if (id is null)
    920. 

  920.     return 257;
    921. 

  921.   id := lower (id);
    922. 

  922.   res := rdf_cache_id ('l', id);
    923. 

  923.   if (res)
    924. 

  924.     return res;
    925. 

  925.   whenever not found goto mknew;
    926. 

  926.   set isolation='committed';
    927. 

  927.   select RL_TWOBYTE into res from DB.DBA.RDF_LANGUAGE where RL_ID = id;
    928. 

  928.   return res;
    929. 

  929. 

  930. mknew:
    931. 

  931.   set isolation='serializable';
    932. 

  932.   declare tb_cr cursor for select RL_TWOBYTE from DB.DBA.RDF_LANGUAGE where RL_ID = id;
    933. 

  933.   open tb_cr (exclusive);
    934. 

  934.   whenever not found goto mknew_ser;
    935. 

  935.   fetch tb_cr into res;
    936. 

  936.   return res;
    937. 

  937. 

  938. mknew_ser:
    939. 

  939.   res := sequence_next ('RDF_LANGUAGE_TWOBYTE');
    940. 

  940.   if (0 = bit_and (res, 255))
    941. 

  941.     {
    942. 

  942.       if (res = 0hex7F00)
    943. 

  943.         {
    944. 

  944.           sequence_set ('RDF_LANGUAGE_TWOBYTE', 0hex7F00, 0);
    945. 

  945.           res := 0hex7F01;
    946. 

  946.           id := 'x-unsaved';
    947. 

  947.           insert soft DB.DBA.RDF_LANGUAGE (RL_ID, RL_TWOBYTE) values (id, res);
    948. 

  948.           goto cache_and_log;
    949. 

  949.         }
    950. 

  950.       res := sequence_next ('RDF_LANGUAGE_TWOBYTE');
    951. 

  951.     }
    952. 

  952.   insert into DB.DBA.RDF_LANGUAGE (RL_ID, RL_TWOBYTE) values (id, res);
    953. 

  953. cache_and_log:
    954. 

  954.   rdf_cache_id ('l', id, res);
    955. 

  955.   log_text ('rdf_cache_id (\'l\', ?, ?)', id, res); --'
    956. 

  956.   return res;
    957. 

  957. }
    958. 

  958. ;
    959. 

  959. 

  960. -----
    961. 

  961. -- Conversions from and to _table fields_ in short representation
    962. 

  962. 

  963. create function DB.DBA.RQ_LONG_OF_O (in o_col any) returns any -- DEPRECATED
    964. 

  964. {
    965. 

  965.   return __rdf_long_of_obj (o_col);
    966. 

  966. }
    967. 

  967. ;
    968. 

  968. 

  969. create procedure DB.DBA.RDF_BOX_COMPLETE (inout o_col any) -- DEPRECATED
    970. 

  970. {
    971. 

  971.   __rdf_box_make_complete (o_col);
    972. 

  972. }
    973. 

  973. ;
    974. 

  974. 

  975. create function DB.DBA.RQ_SQLVAL_OF_O (in o_col any) returns any -- DEPRECATED
    976. 

  976. {
    977. 

  977.   return __rdf_sqlval_of_obj (o_col);
    978. 

  978. }
    979. 

  979. ;
    980. 

  980. 

  981. create function DB.DBA.RQ_BOOL_OF_O (in o_col any) returns any
    982. 

  982. {
    983. 

  983.   declare t, len integer;
    984. 

  984.   if (isiri_id (o_col))
    985. 

  985.     return NULL;
    986. 

  986.   if (isinteger (o_col))
    987. 

  987.     {
    988. 

  988.       if (o_col)
    989. 

  989.         return 1;
    990. 

  990.       return 0;
    991. 

  991.     }
    992. 

  992.   if (__tag of rdf_box = __tag (o_col))
    993. 

  993.     {
    994. 

  994.       declare twobyte integer;
    995. 

  995.       declare dtqname any;
    996. 

  996.       if (__tag of varchar <> rdf_box_data_tag (o_col))
    997. 

  997.         {
    998. 

  998.           whenever sqlstate '*' goto retnull;
    999. 

  999.           return neq (rdf_box_data (o_col), 0.0);
    1000. 

  1000.         }
    1001. 

  1001.       twobyte := rdf_box_type (o_col);
    1002. 

  1002.       if (257 = twobyte)
    1003. 

  1003.         goto type_ok;
    1004. 

  1004.       whenever not found goto badtype;
    1005. 

  1005.       select RDT_QNAME into dtqname from DB.DBA.RDF_DATATYPE where RDT_TWOBYTE = twobyte;
    1006. 

  1006.       if (dtqname <> UNAME'http://www.w3.org/2001/XMLSchema#string')
    1007. 

  1007.         return null;
    1008. 

  1008. 

  1009. type_ok:
    1010. 

  1010.       return case (length (rdf_box_data (o_col))) when 0 then 0 else 1 end;
    1011. 

  1011. 

  1012. badtype:
    1013. 

  1013.       signal ('RDFXX', signal ('RDFXX', sprintf ('Unknown datatype in DB.DBA.RQ_BOOL_OF_O, bad type id %d, string value "%s"',
    1014. 

  1014.     twobyte, cast (rdf_box_data (o_col) as varchar) ) );
    1015. 

  1015.     }
    1016. 

  1016.   if (o_col is null)
    1017. 

  1017.     return null;
    1018. 

  1018.   whenever sqlstate '*' goto retnull;
    1019. 

  1019.   return neq (o_col, 0.0);
    1020. 

  1020. retnull:
    1021. 

  1021.   return null;
    1022. 

  1022. }
    1023. 

  1023. ;
    1024. 

  1024. 

  1025. create function DB.DBA.RQ_IID_OF_O (in shortobj any) returns IRI_ID -- DEPRECATED
    1026. 

  1026. {
    1027. 

  1027.   return id_to_iri_nosignal (shortobj);
    1028. 

  1028. }
    1029. 

  1029. ;
    1030. 

  1030. 

  1031. create function DB.DBA.RQ_O_IS_LIT (in shortobj any) returns integer -- DEPRECATED
    1032. 

  1032. {
    1033. 

  1033.   if (isiri_id (shortobj))
    1034. 

  1034.     return 0;
    1035. 

  1035.   return 1;
    1036. 

  1036. }
    1037. 

  1037. ;
    1038. 

  1038. 

  1039. -----
    1040. 

  1040. -- Conversions from and to values in short representation that may be not field values (may perform more validation checks)
    1041. 

  1041. 

  1042. 

  1043. 

  1044. create procedure RDF_G_INS (in id int, in g any)
    1045. 

  1045. {
    1046. 

  1046.   geo_insert ('DB.DBA.RDF_GEO', g, id);
    1047. 

  1047. }
    1048. 

  1048. ;
    1049. 

  1049. 

  1050. create procedure cl_rdf_geo_insert (in id int, inout g any)
    1051. 

  1051. {
    1052. 

  1052.   declare daq any;
    1053. 

  1053.   daq := daq (1);
    1054. 

  1054.   daq_call (daq, 'DB.DBA.RDF_OBJ', 'RDF_OBJ', 'DB.DBA.RDF_G_INS', vector (id, g), 1);
    1055. 

  1055.   daq_results (daq);
    1056. 

  1056. }
    1057. 

  1057. ;
    1058. 

  1058. 

  1059. create function rdf_geo_add (in v any)
    1060. 

  1060. {
    1061. 

  1061.   declare id, h, ser, g any;
    1062. 

  1062.   if (rdf_box_ro_id (v))
    1063. 

  1063.     return v;
    1064. 

  1064.  g := rdf_box_data (v);
    1065. 

  1065.   if (not isgeometry (g))
    1066. 

  1066.     signal ('22023', 'RDFXX', 'Must be geometry box if to be stored as geo object');
    1067. 

  1067.   ser := serialize (g);
    1068. 

  1068.   if (length (ser) > 50)
    1069. 

  1069.     h := mdigest5 (ser);
    1070. 

  1070.   else
    1071. 

  1071.     {
    1072. 

  1072.       h := ser;
    1073. 

  1073.       ser := null;
    1074. 

  1074.     }
    1075. 

  1075.   set isolation = 'committed';
    1076. 

  1076.   id := (select ro_id, ro_val, ro_long from rdf_obj where ro_val = h and ro_dt_and_lang = 0hex1000101 and case when ro_long is not null then equ (blob_to_string (ro_long),  ser) else 1 end );
    1077. 

  1077.   if (id is not null)
    1078. 

  1078.     {
    1079. 

  1079.       rdf_box_set_ro_id (v, id);
    1080. 

  1080.       return v;
    1081. 

  1081.     }
    1082. 

  1082.   set isolation = 'serializable';
    1083. 

  1083.   id := (select ro_id, ro_val, ro_long from rdf_obj where ro_val = h and ro_dt_and_lang = 0hex1000101 and case when ro_long is not null then equ (blob_to_string (ro_long),  ser) else 1 end for update);
    1084. 

  1084.   if (id is not null)
    1085. 

  1085.     {
    1086. 

  1086.       rdf_box_set_ro_id (v, id);
    1087. 

  1087.       return v;
    1088. 

  1088.     }
    1089. 

  1089.  id := sequence_next ('RDF_RO_ID');
    1090. 

  1090.   set triggers off;
    1091. 

  1091.   -- dbg_obj_princ ('zero RO_FLAGS in sparql.sql:997 ', ro_val, ro_long);
    1092. 

  1092.   insert into rdf_obj (ro_id, ro_val, ro_long, ro_dt_and_lang)
    1093. 

  1093.     values (id, h, ser, 0hex1000101);
    1094. 

  1094.   if (1 = sys_stat ('cl_run_local_only'))
    1095. 

  1095.     geo_insert ('DB.DBA.RDF_GEO', g, id);
    1096. 

  1096.   else
    1097. 

  1097.     cl_rdf_geo_insert (id, g);
    1098. 

  1098.   rdf_box_set_ro_id (v, id);
    1099. 

  1099.   return v;
    1100. 

  1100. }
    1101. 

  1101. ;
    1102. 

  1102. 

  1103. create function rdf_geo_set_id (inout v any)
    1104. 

  1104. {
    1105. 

  1105.   declare id, h, ser, g any;
    1106. 

  1106.   if (rdf_box_ro_id (v))
    1107. 

  1107.     return v;
    1108. 

  1108.   g := rdf_box_data (v);
    1109. 

  1109.   if (not isgeometry (g))
    1110. 

  1110.     signal ('22023', 'RDFXX', 'Must be geometry box if to be stored as geo object');
    1111. 

  1111.   ser := serialize (g);
    1112. 

  1112.   if (length (ser) > 50)
    1113. 

  1113.     h := mdigest5 (ser);
    1114. 

  1114.   else
    1115. 

  1115.     {
    1116. 

  1116.       h := ser;
    1117. 

  1117.       ser := null;
    1118. 

  1118.     }
    1119. 

  1119.   set isolation = 'committed';
    1120. 

  1120.   id := (select RO_ID from RDF_OBJ where RO_VAL = h and RO_DT_AND_LANG = 0hex1000101
    1121. 

  1121.   	and case when RO_LONG is not null then equ (blob_to_string (RO_LONG),  ser) else 1 end );
    1122. 

  1122.   if (id is not null)
    1123. 

  1123.     {
    1124. 

  1124.       rdf_box_set_ro_id (v, id);
    1125. 

  1125.       return v;
    1126. 

  1126.     }
    1127. 

  1127.   return null;
    1128. 

  1128. }
    1129. 

  1129. ;
    1130. 

  1130. 

  1131. create function DB.DBA.RDF_OBJ_ADD (in dt_twobyte integeR, in v varchar, in lang_twobyte integeR, in ro_id_dict any := 0) returns varchar
    1132. 

  1132. {
    1133. 

  1133.   declare llong, id, need_digest integer;
    1134. 

  1134.   declare digest any;
    1135. 

  1135.   declare old_flags, dt_and_lang integer;
    1136. 

  1136.   -- dbg_obj_princ ('DB.DBA.RDF_OBJ_ADD (', dt_twobyte, v, lang_twobyte, case (isnull (ro_id_dict)) when 1 then '/*no_ft*/' else '/*want_ft*/' end,')');
    1137. 

  1137.   if (isinteger (ro_id_dict))
    1138. 

  1138.     {
    1139. 

  1139.       if (__rdf_obj_ft_rule_check (null, null))
    1140. 

  1140.         ro_id_dict := dict_new ();
    1141. 

  1141.       else
    1142. 

  1142.         ro_id_dict := null;
    1143. 

  1143.     }
    1144. 

  1144.   if (126 = __tag (v))
    1145. 

  1145.     v := blob_to_string (v);
    1146. 

  1146.   if (isstring (rdf_box_data (v)))
    1147. 

  1147.     need_digest := rdf_box_needs_digest (v, ro_id_dict);
    1148. 

  1148.   else if (__tag of XML = __tag (v))
    1149. 

  1149.     need_digest := 1;
    1150. 

  1150.   if (__tag of rdf_box = __tag (v))
    1151. 

  1151.     {
    1152. 

  1152.       if (256 = rdf_box_type (v))
    1153. 

  1153. 	return rdf_geo_add (v);
    1154. 

  1154.       if (0 = need_digest)
    1155. 

  1155.         return v;
    1156. 

  1156.       if (1 = need_digest)
    1157. 

  1157.         {
    1158. 

  1158.           if (0 <> rdf_box_ro_id (v))
    1159. 

  1159.             return v;
    1160. 

  1160.         }
    1161. 

  1161.       dt_twobyte := rdf_box_type (v);
    1162. 

  1162.       lang_twobyte := rdf_box_lang (v);
    1163. 

  1163.       v := __rdf_sqlval_of_obj (v, 1);
    1164. 

  1164.     }
    1165. 

  1165.   else
    1166. 

  1166.     {
    1167. 

  1167.       if (dt_twobyte <> 257 or lang_twobyte <> 257)
    1168. 

  1168.         need_digest := 3;
    1169. 

  1169.       else if (0 = need_digest)
    1170. 

  1170.         return v;
    1171. 

  1171.       if (dt_twobyte < 257)
    1172. 

  1172.         signal ('RDFXX', sprintf ('Bad datatype code: DB.DBA.RDF_OBJ_ADD (%d, %s, %d)',
    1173. 

  1173.           dt_twobyte, "LEFT" (cast (v as varchar), 100), lang_twobyte) );
    1174. 

  1174.       if (lang_twobyte < 257)
    1175. 

  1175.         signal ('RDFXX', sprintf ('Bad lang code: DB.DBA.RDF_OBJ_ADD (%d, %s, %d)',
    1176. 

  1176.           dt_twobyte, "LEFT" (cast (v as varchar), 100), lang_twobyte) );
    1177. 

  1177.     }
    1178. 

  1178.   dt_and_lang := bit_or (bit_shift (dt_twobyte, 16), lang_twobyte);
    1179. 

  1179.   if (not isstring (v))
    1180. 

  1180.     {
    1181. 

  1181.       declare sum64 varchar;
    1182. 

  1182.       if (__tag of XML <> __tag (v))
    1183. 

  1183.         signal ('RDFXX', sprintf ('Bad call: DB.DBA.RDF_OBJ_ADD (%d, %s, %d)',
    1184. 

  1184.           dt_twobyte, "LEFT" (cast (v as varchar), 100), lang_twobyte) );
    1185. 

  1185.       sum64 := xtree_sum64 (v);
    1186. 

  1186.       whenever not found goto serializable_xtree;
    1187. 

  1187.       set isolation='committed';
    1188. 

  1188.       select RO_ID, RO_FLAGS into id, old_flags
    1189. 

  1189.       from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1190. 

  1190.       where RO_VAL = sum64
    1191. 

  1191.       and RO_DT_AND_LANG = dt_and_lang
    1192. 

  1192.       and bit_and (RO_FLAGS, 2);
    1193. 

  1193.       --!TBD ... and paranoid check
    1194. 

  1194. 

  1195.       goto found_xtree;
    1196. 

  1196. serializable_xtree:
    1197. 

  1197.       whenever not found goto new_xtree;
    1198. 

  1198.       set isolation='serializable';
    1199. 

  1199.       declare id_cr cursor for
    1200. 

  1200.         select RO_ID, RO_FLAGS from DB.DBA.RDF_OBJ table option (index RO_VAL) where RO_VAL = sum64
    1201. 

  1201.         and RO_DT_AND_LANG = dt_and_lang
    1202. 

  1202.         and bit_and (RO_FLAGS, 2);
    1203. 

  1203.       --!TBD ... and paranoid check
    1204. 

  1204.       open id_cr (exclusive);
    1205. 

  1205.       fetch id_cr into id, old_flags;
    1206. 

  1206. found_xtree:
    1207. 

  1207.       digest := rdf_box (v, dt_twobyte, lang_twobyte, id, 1);
    1208. 

  1208.       if (ro_id_dict is not null)
    1209. 

  1209.         {
    1210. 

  1210.           if (not (bit_and (old_flags, 1)))
    1211. 

  1211. 	    {
    1212. 

  1212. 	      update DB.DBA.RDF_OBJ set RO_FLAGS = bit_or (RO_FLAGS, 1) where RO_ID = id;
    1213. 

  1213. 	      --insert soft rdf_ft (rf_id, rf_o) values (id, digest);
    1214. 

  1214. 	    }
    1215. 

  1215.           dict_put (ro_id_dict, id, 1);
    1216. 

  1216.         }
    1217. 

  1217.       if (not (rdf_box_is_storeable (digest)))
    1218. 

  1218.         signal ('RDFX2', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1219. 

  1219.       return digest;
    1220. 

  1220.       -- goto recheck;
    1221. 

  1221. new_xtree:
    1222. 

  1222.       id := sequence_next ('RDF_RO_ID');
    1223. 

  1223.       digest := rdf_box (v, dt_twobyte, lang_twobyte, id, 1);
    1224. 

  1224.       -- if (ro_id_dict is null)
    1225. 

  1225.       --   {
    1226. 

  1226.       --     dbg_obj_princ ('zero RO_FLAGS in sparql.sql:1124');
    1227. 

  1227.       --     ;
    1228. 

  1228.       --   }
    1229. 

  1229.       insert into DB.DBA.RDF_OBJ (RO_ID, RO_VAL, RO_LONG, RO_FLAGS, RO_DT_AND_LANG) values
    1230. 

  1230.         (id, sum64, __xml_serialize_packed (v), case (isnull (ro_id_dict)) when 0 then 3 else 2 end, dt_and_lang);
    1231. 

  1231.       --if (ro_id_dict is not null)
    1232. 

  1232. 	--insert soft rdf_ft (rf_id, rf_o) values (id, digest);
    1233. 

  1233.       if (ro_id_dict is not null)
    1234. 

  1234.         dict_put (ro_id_dict, id, 1);
    1235. 

  1235.       if (not (rdf_box_is_storeable (digest)))
    1236. 

  1236.         signal ('RDFX3', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1237. 

  1237.       return digest;
    1238. 

  1238.       -- old_digest := null;
    1239. 

  1239.       -- goto recheck;
    1240. 

  1240.     }
    1241. 

  1241.   if ((dt_twobyte = 257) and (lang_twobyte = 257) and (length (v) <= -1))
    1242. 

  1242.     {
    1243. 

  1243.       if (1 >= need_digest)
    1244. 

  1244.         return v;
    1245. 

  1245.       whenever not found goto serializable_veryshort;
    1246. 

  1246.       set isolation='committed';
    1247. 

  1247.       select RO_ID into id
    1248. 

  1248.       from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1249. 

  1249.       where RO_VAL = v and RO_DT_AND_LANG = dt_and_lang and not (bit_and (RO_FLAGS, 2));
    1250. 

  1250.       goto found_veryshort;
    1251. 

  1251. serializable_veryshort:
    1252. 

  1252.       whenever not found goto new_veryshort;
    1253. 

  1253.       set isolation='serializable';
    1254. 

  1254.       declare id_cr cursor for select RO_ID
    1255. 

  1255.       from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1256. 

  1256.       where RO_VAL = v and RO_DT_AND_LANG = dt_and_lang and not (bit_and (RO_FLAGS, 2));
    1257. 

  1257.       open id_cr (exclusive);
    1258. 

  1258.       fetch id_cr into id;
    1259. 

  1259. found_veryshort:
    1260. 

  1260.       if (ro_id_dict is not null)
    1261. 

  1261. 	{
    1262. 

  1262. 	  dict_put (ro_id_dict, id, 1);
    1263. 

  1263. 	  --insert soft rdf_ft (rf_id, rf_o) values (id, v);
    1264. 

  1264. 	}
    1265. 

  1265.       if (not (rdf_box_is_storeable (v)))
    1266. 

  1266.         signal ('RDFX4', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1267. 

  1267.       return v;
    1268. 

  1268. new_veryshort:
    1269. 

  1269.       id := sequence_next ('RDF_RO_ID');
    1270. 

  1270.       insert into DB.DBA.RDF_OBJ (RO_ID, RO_VAL, RO_FLAGS, RO_DT_AND_LANG) values (id, v, 1, dt_and_lang);
    1271. 

  1271.       if (ro_id_dict is not null)
    1272. 

  1272. 	{
    1273. 

  1273. 	  dict_put (ro_id_dict, id, 1);
    1274. 

  1274. 	}
    1275. 

  1275.       insert into DB.DBA.RO_START (RS_START, RS_DT_AND_LANG, RS_RO_ID)
    1276. 

  1276.         values (subseq (v, 0, case when length (v) > 10 then 10 else length (v) end), dt_and_lang, rdf_box (0, 257, 257, id, 0));
    1277. 

  1277.       if (not (rdf_box_is_storeable (v)))
    1278. 

  1278.         signal ('RDFX5', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1279. 

  1279.       return v;
    1280. 

  1280.     }
    1281. 

  1281.   llong := 50;
    1282. 

  1282.   if (length (v) > llong)
    1283. 

  1283.     {
    1284. 

  1284.       declare chksm varchar;
    1285. 

  1285.       chksm := mdigest5 (v, 1);
    1286. 

  1286.       whenever not found goto serializable_long;
    1287. 

  1287.       set isolation='committed';
    1288. 

  1288.       select RO_ID, RO_FLAGS into id, old_flags
    1289. 

  1289.       from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1290. 

  1290.       where RO_VAL = chksm
    1291. 

  1291.       and RO_DT_AND_LANG = dt_and_lang
    1292. 

  1292.       and not (bit_and (RO_FLAGS, 2))
    1293. 

  1293.       and blob_to_string (RO_LONG) = v;
    1294. 

  1294.       goto found_long;
    1295. 

  1295. serializable_long:
    1296. 

  1296.       whenever not found goto new_long;
    1297. 

  1297.       set isolation='serializable';
    1298. 

  1298.       declare id_cr cursor for
    1299. 

  1299.         select RO_ID, RO_FLAGS from DB.DBA.RDF_OBJ
    1300. 

  1300.       table option (index RO_VAL) where RO_VAL = chksm
    1301. 

  1301.       and RO_DT_AND_LANG = dt_and_lang
    1302. 

  1302.       and not (bit_and (RO_FLAGS, 2))
    1303. 

  1303.       and blob_to_string (RO_LONG) = v;
    1304. 

  1304.       open id_cr (exclusive);
    1305. 

  1305.       fetch id_cr into id, old_flags;
    1306. 

  1306. found_long:
    1307. 

  1307.       digest := rdf_box (v, dt_twobyte, lang_twobyte, id, 1);
    1308. 

  1308.       if ((not (bit_and (old_flags, 1))) and (1 < need_digest))
    1309. 

  1309.         update DB.DBA.RDF_OBJ set RO_FLAGS = bit_or (RO_FLAGS, 1) where RO_ID = id;
    1310. 

  1310.       if (ro_id_dict is not null)
    1311. 

  1311. 	{
    1312. 

  1312. 	  dict_put (ro_id_dict, id, 1);
    1313. 

  1313. 	}
    1314. 

  1314.       if (not (rdf_box_is_storeable (digest)))
    1315. 

  1315.         signal ('RDFX6', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1316. 

  1316.       return digest;
    1317. 

  1317. new_long:
    1318. 

  1318.       id := sequence_next ('RDF_RO_ID');
    1319. 

  1319.       digest := rdf_box (v, dt_twobyte, lang_twobyte, id, 1);
    1320. 

  1320.       if (1 < need_digest)
    1321. 

  1321.         insert into DB.DBA.RDF_OBJ (RO_ID, RO_VAL, RO_LONG, RO_FLAGS, RO_DT_AND_LANG)
    1322. 

  1322.         values (id, chksm, v, 1, dt_and_lang);
    1323. 

  1323.       else
    1324. 

  1324.         {
    1325. 

  1325.           set triggers off;
    1326. 

  1326.           -- dbg_obj_princ ('zero RO_FLAGS in sparql.sql:1225 ', chksm, v);
    1327. 

  1327.           insert into DB.DBA.RDF_OBJ (RO_ID, RO_VAL, RO_LONG, RO_DT_AND_LANG)
    1328. 

  1328.           values (id, chksm, v, dt_and_lang);
    1329. 

  1329.           set triggers on;
    1330. 

  1330.         }
    1331. 

  1331.       if (ro_id_dict is not null)
    1332. 

  1332. 	{
    1333. 

  1333. 	  dict_put (ro_id_dict, id, 1);
    1334. 

  1334. 	}
    1335. 

  1335.       insert into DB.DBA.RO_START (RS_START, RS_DT_AND_LANG, RS_RO_ID)
    1336. 

  1336.         -- no need in values (subseq (v, 0, case when length (v) > 10 then 10 else length (v), RO_DT_AND_LANG, rdf_box (0, 257, 257, id, 0));
    1337. 

  1337.         values (subseq (v, 0, 10), dt_and_lang, rdf_box (0, 257, 257, id, 0));
    1338. 

  1338.       if (not (rdf_box_is_storeable (digest)))
    1339. 

  1339.         signal ('RDFX7', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1340. 

  1340.       return digest;
    1341. 

  1341.     }
    1342. 

  1342.   else
    1343. 

  1343.     {
    1344. 

  1344.       whenever not found goto serializable_short;
    1345. 

  1345.       set isolation='committed';
    1346. 

  1346.       select RO_ID, RO_FLAGS into id, old_flags
    1347. 

  1347.       from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1348. 

  1348.       where RO_VAL = v
    1349. 

  1349.       and RO_DT_AND_LANG = dt_and_lang;
    1350. 

  1350.       goto found_short;
    1351. 

  1351. serializable_short:
    1352. 

  1352.       whenever not found goto new_short;
    1353. 

  1353.       set isolation='serializable';
    1354. 

  1354.       declare id_cr cursor for select RO_ID, RO_FLAGS
    1355. 

  1355.       from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1356. 

  1356.       where RO_VAL = v
    1357. 

  1357.       and RO_DT_AND_LANG = dt_and_lang;
    1358. 

  1358.       open id_cr (exclusive);
    1359. 

  1359.       fetch id_cr into id, old_flags;
    1360. 

  1360. found_short:
    1361. 

  1361.       digest := rdf_box (v, dt_twobyte, lang_twobyte, id, 1);
    1362. 

  1362.       if ((not (bit_and (old_flags, 1))) and (1 < need_digest))
    1363. 

  1363.         update DB.DBA.RDF_OBJ set RO_FLAGS = bit_or (RO_FLAGS, 1) where RO_ID = id;
    1364. 

  1364.       if (ro_id_dict is not null)
    1365. 

  1365. 	{
    1366. 

  1366. 	  dict_put (ro_id_dict, id, 1);
    1367. 

  1367. 	}
    1368. 

  1368.       if (not (rdf_box_is_storeable (digest)))
    1369. 

  1369.         signal ('RDFX8', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1370. 

  1370.       return digest;
    1371. 

  1371. new_short:
    1372. 

  1372.       id := sequence_next ('RDF_RO_ID');
    1373. 

  1373.       digest := rdf_box (v, dt_twobyte, lang_twobyte, id, 1);
    1374. 

  1374.       if (1 < need_digest)
    1375. 

  1375.         insert into DB.DBA.RDF_OBJ (RO_ID, RO_VAL, RO_FLAGS, RO_DT_AND_LANG)
    1376. 

  1376.         values (id, v, 1, dt_and_lang);
    1377. 

  1377.       else
    1378. 

  1378.         {
    1379. 

  1379.           -- dbg_obj_princ ('zero RO_FLAGS in sparql.sql:1271 ', v);
    1380. 

  1380.           set triggers off;
    1381. 

  1381.           insert into DB.DBA.RDF_OBJ (RO_ID, RO_VAL, RO_FLAGS, RO_DT_AND_LANG)
    1382. 

  1382.           values (id, v, 0, dt_and_lang);
    1383. 

  1383.           set triggers on;
    1384. 

  1384.         }
    1385. 

  1385.       insert into DB.DBA.RO_START (RS_START, RS_DT_AND_LANG, RS_RO_ID)
    1386. 

  1386.         values (subseq (v, 0, case when length (v) > 10 then 10 else length (v) end), dt_and_lang, rdf_box (0, 257, 257, id, 0));
    1387. 

  1387.       if (ro_id_dict is not null)
    1388. 

  1388. 	{
    1389. 

  1389. 	  dict_put (ro_id_dict, id, 1);
    1390. 

  1390. 	}
    1391. 

  1391.       if (not (rdf_box_is_storeable (digest)))
    1392. 

  1392.         signal ('RDFX9', 'DB.DBA.RDF_OBJ_ADD() tries to return bad digest');
    1393. 

  1393.       return digest;
    1394. 

  1394.     }
    1395. 

  1395. recheck:
    1396. 

  1396.   -- dbg_obj_princ ('recheck: id=', id, ', old_digest=', old_digest, ', need_digest=', need_digest, ', digest=', digest);
    1397. 

  1397.   signal ('FUNNY', 'Debug code of DB.DBA.RDF_OBJ_ADD() is reached. This can not happen (I believe). Please report this error.');
    1398. 

  1398. }
    1399. 

  1399. ;
    1400. 

  1400. 

  1401. create function DB.DBA.RDF_FIND_RO_DIGEST (in dt_twobyte integeR, in v varchar, in lang_twobyte integeR) returns varchar
    1402. 

  1402. {
    1403. 

  1403.   declare llong, dt_and_lang int;
    1404. 

  1404.   declare dt_s, lang_s, chksm, sum64 varchar;
    1405. 

  1405.   declare digest, old_digest any;
    1406. 

  1406.   if (126 = __tag (v))
    1407. 

  1407.     v := blob_to_string (v);
    1408. 

  1408.   dt_and_lang := bit_or (bit_shift (dt_twobyte, 16), lang_twobyte);
    1409. 

  1409.   if (not (isstring (v)))
    1410. 

  1410.     {
    1411. 

  1411.       if (__tag of XML <> __tag (v))
    1412. 

  1412.         return v;
    1413. 

  1413.       sum64 := xtree_sum64 (v);
    1414. 

  1414.       return (select rdf_box (v, dt_twobyte, lang_twobyte, RO_ID, 1)
    1415. 

  1415.         from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1416. 

  1416.         where RO_VAL = sum64
    1417. 

  1417.         and RO_DT_AND_LANG = dt_and_lang
    1418. 

  1418.         and bit_and (RO_FLAGS, 2)
    1419. 

  1419.         --!TBD ... and paranoid check
    1420. 

  1420.         );
    1421. 

  1421.     }
    1422. 

  1422.   if ((dt_twobyte = 257) and (lang_twobyte = 257) and (length (v) <= 20))
    1423. 

  1423.     return v;
    1424. 

  1424.   llong := 50;
    1425. 

  1425.   if (length (v) > llong)
    1426. 

  1426.     {
    1427. 

  1427.       chksm := mdigest5 (v, 1);
    1428. 

  1428.       return (select rdf_box (v, dt_twobyte, lang_twobyte, RO_ID, 1)
    1429. 

  1429.         from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1430. 

  1430.         where RO_VAL = chksm
    1431. 

  1431.         and RO_DT_AND_LANG = dt_and_lang
    1432. 

  1432.         and not (bit_and (RO_FLAGS, 2))
    1433. 

  1433.         and blob_to_string (RO_LONG) = v );
    1434. 

  1434.     }
    1435. 

  1435.   else
    1436. 

  1436.     {
    1437. 

  1437.       return (select rdf_box (v, dt_twobyte, lang_twobyte, RO_ID, 1)
    1438. 

  1438.         from DB.DBA.RDF_OBJ table option (index RO_VAL)
    1439. 

  1439.         where RO_VAL = v
    1440. 

  1440.         and RO_DT_AND_LANG = dt_and_lang
    1441. 

  1441.         and not (bit_and (RO_FLAGS, 2)) );
    1442. 

  1442.     }
    1443. 

  1443. }
    1444. 

  1444. ;
    1445. 

  1445. 

  1446. create function DB.DBA.RDF_MAKE_OBJ_OF_SQLVAL (in v any) returns any array
    1447. 

  1447. {
    1448. 

  1448.   declare t int;
    1449. 

  1449.   t := __tag (v);
    1450. 

  1450.   if (not (t in (126, __tag of varchar, 217, __tag of nvarchar, __tag of XML, __tag of rdf_box)))
    1451. 

  1451.     return v;
    1452. 

  1452.   if (__tag of nvarchar = t)
    1453. 

  1453.     v := charset_recode (v, '_WIDE_', 'UTF-8');
    1454. 

  1454.   else if (t in (126, 217))
    1455. 

  1455.     v := cast (v as varchar);
    1456. 

  1456.   return DB.DBA.RDF_OBJ_ADD (257, v, 257);
    1457. 

  1457. }
    1458. 

  1458. ;
    1459. 

  1459. 

  1460. create function DB.DBA.RDF_MAKE_OBJ_OF_SQLVAL_FT (in v any, in g_iid IRI_ID, in p_iid IRI_ID, in ro_id_dict any := null) returns any
    1461. 

  1461. {
    1462. 

  1462.   declare t int;
    1463. 

  1463.   -- dbg_obj_princ ('DB.DBA.RDF_MAKE_OBJ_OF_SQLVAL_FT (', v, g_iid, p_iid, ro_id_dict, ')');
    1464. 

  1464.   t := __tag (v);
    1465. 

  1465.   if (not (t in (126, __tag of varchar, 217, __tag of nvarchar, __tag of XML, __tag of rdf_box)))
    1466. 

  1466.     return v;
    1467. 

  1467.   if (__tag of nvarchar = t)
    1468. 

  1468.     v := charset_recode (v, '_WIDE_', 'UTF-8');
    1469. 

  1469.   else if (t in (126, 217))
    1470. 

  1470.     v := cast (v as varchar);
    1471. 

  1471.   if (not __rdf_obj_ft_rule_check (g_iid, p_iid))
    1472. 

  1472.     ro_id_dict := null;
    1473. 

  1473.   else
    1474. 

  1474.     {
    1475. 

  1475.       if (ro_id_dict is null)
    1476. 

  1476.         {
    1477. 

  1477.           declare res any;
    1478. 

  1478.           ro_id_dict := dict_new ();
    1479. 

  1479.           res := DB.DBA.RDF_OBJ_ADD (257, v, 257, ro_id_dict);
    1480. 

  1480.           DB.DBA.RDF_OBJ_ADD_KEYWORD_FOR_GRAPH (g_iid, ro_id_dict);
    1481. 

  1481.           return res;
    1482. 

  1482.         }
    1483. 

  1483.     }
    1484. 

  1484.   return DB.DBA.RDF_OBJ_ADD (257, v, 257, ro_id_dict);
    1485. 

  1485. }
    1486. 

  1486. ;
    1487. 

  1487. 

  1488. create function DB.DBA.RDF_MAKE_OBJ_OF_TYPEDSQLVAL (in v any, in dt_iid IRI_ID, in lang varchar) returns any array
    1489. 

  1489. {
    1490. 

  1490.   declare t, dt_twobyte, lang_twobyte int;
    1491. 

  1491.   -- dbg_obj_princ ('DB.DBA.RDF_MAKE_OBJ_OF_TYPEDSQLVAL (', v, dt_iid, lang, ')');
    1492. 

  1492. retry_unrdf:
    1493. 

  1493.   t := __tag (v);
    1494. 

  1494.   if (not (t in (126, __…
    1495.