Project

General

Profile

« Previous | Next » 

Revision 2422

Added by sgarg over 19 years ago

Made changes in the sql scripts to create new tables xml_returnfield and xml_queryresult

View differences:

src/xmltables.sql
35 35
DROP SEQUENCE xml_documents_id_seq;
36 36
DROP SEQUENCE accession_number_id_seq;
37 37
DROP SEQUENCE access_log_seq;
38
               
38
DROP SEQUENCE xml_returnfield_id_seq;
39
DROP SEQUENCE xml_queryresult_id_seq;
40

  
39 41
/* Drop triggers are not necessary */
40 42
DROP TRIGGER xml_nodes_before_insert;
41 43
DROP TRIGGER xml_revisions_before_insert;
......
44 46
DROP TRIGGER xml_replication_before_insert;
45 47
DROP TRIGGER accession_number_before_insert;
46 48
DROP TRIGGER access_log_before_insert;
49
DROP TRIGGER xml_returnfield_before_insert;
50
DROP TRIGGER xml_queryresult_before_insert;
47 51

  
52

  
48 53
DROP TABLE xml_index;
49 54
DROP TABLE xml_access;
50 55
DROP TABLE xml_accesssubtree;
......
59 64
DROP TABLE harvest_site_schedule;
60 65
DROP TABLE harvest_detail_log;
61 66
DROP TABLE harvest_log;
67
DROP TABLE xml_returnfield;
68
DROP TABLE xml_queryresult;
62 69

  
63 70
/*
64 71
 *Replication -- table to store servers that metacat is replicated to
......
71 78
  datareplicate NUMBER(1),
72 79
  hub NUMBER(1),
73 80
  CONSTRAINT xml_replication_pk PRIMARY KEY (serverid)
74
);  
75
  
81
);
82

  
76 83
CREATE SEQUENCE xml_replication_id_seq;
77 84
CREATE TRIGGER xml_replication_before_insert
78 85
BEFORE INSERT ON xml_replication FOR EACH ROW
......
86 93
INSERT INTO xml_replication (server, replicate, datareplicate, hub)
87 94
 VALUES ('localhost', '0', '0', '0');
88 95

  
89
/* 
96
/*
90 97
 * Nodes -- table to store XML Nodes (both elements and attributes)
91 98
 */
92 99
CREATE SEQUENCE xml_nodes_id_seq;
......
98 105
	nodename	VARCHAR2(250),	-- the name of an element or attribute
99 106
	nodeprefix	VARCHAR2(50),	-- the namespace prefix of an element
100 107
                                        -- or attribute
101
	nodedata	VARCHAR2(4000), -- the data for this node (e.g., 
108
	nodedata	VARCHAR2(4000), -- the data for this node (e.g.,
102 109
					-- for TEXT it is the content)
103 110
	parentnodeid	NUMBER(20),	-- index of the parent of this node
104 111
	rootnodeid	NUMBER(20),	-- index of the root node of this tree
105 112
	docid		VARCHAR2(250),	-- index to the document id
106 113
	date_created	DATE,
107 114
	date_updated	DATE,
108
	nodedatanumerical NUMBER,       -- the data for this node if 
115
	nodedatanumerical NUMBER,       -- the data for this node if
109 116
					-- it is a number
110 117
   CONSTRAINT xml_nodes_pk PRIMARY KEY (nodeid),
111
   CONSTRAINT xml_nodes_root_fk 
118
   CONSTRAINT xml_nodes_root_fk
112 119
		FOREIGN KEY (rootnodeid) REFERENCES xml_nodes,
113
   CONSTRAINT xml_nodes_parent_fk 
120
   CONSTRAINT xml_nodes_parent_fk
114 121
		FOREIGN KEY (parentnodeid) REFERENCES xml_nodes
115 122
);
116 123
CREATE TRIGGER xml_nodes_before_insert
......
118 125
BEGIN
119 126
  SELECT xml_nodes_id_seq.nextval
120 127
    INTO :new.nodeid
121
    FROM dual;     
122
END;    
128
    FROM dual;
129
END;
123 130
/
124
                               
125
/* 
131

  
132
/*
126 133
 * Indexes of rootnodeid, parentnodeid, and nodename in xml_nodes
127 134
 */
128 135
CREATE INDEX xml_nodes_idx1 ON xml_nodes (rootnodeid);
129 136
CREATE INDEX xml_nodes_idx2 ON xml_nodes (parentnodeid);
130 137
CREATE INDEX xml_nodes_idx3 ON xml_nodes (nodename);
131 138

  
132
/* 
139
/*
133 140
 * XML Catalog -- table to store all external sources for XML documents
134 141
 */
135 142
CREATE TABLE xml_catalog (
......
141 148
	public_id	VARCHAR2(500),	-- the unique id for this type
142 149
	system_id	VARCHAR2(1000),	-- the local location of the object
143 150
   CONSTRAINT xml_catalog_pk PRIMARY KEY (catalog_id),
144
   CONSTRAINT xml_catalog_uk UNIQUE 
151
   CONSTRAINT xml_catalog_uk UNIQUE
145 152
		(entry_type, source_doctype, target_doctype, public_id)
146 153
);
147 154

  
......
156 163
END;
157 164
/
158 165

  
159
/* 
166
/*
160 167
 * Documents -- table to store XML documents
161 168
 */
162 169
CREATE TABLE xml_documents (
......
166 173
	doctype		VARCHAR2(100),	-- public id indicating document type
167 174
	user_owner	VARCHAR2(100),	-- the user owned the document
168 175
	user_updated	VARCHAR2(100),	-- the user updated the document
169
	server_location NUMBER(20),	-- the server on which this document 
176
	server_location NUMBER(20),	-- the server on which this document
170 177
                                        -- originates
171 178
	rev 		NUMBER(10) DEFAULT 1,--the revision number of the docume
172 179
	date_created	DATE,
173 180
	date_updated	DATE,
174 181
	public_access	NUMBER(1),	-- flag for public access
175
        catalog_id      NUMBER(20),	-- reference to xml_catalog 
182
        catalog_id      NUMBER(20),	-- reference to xml_catalog
176 183
   CONSTRAINT xml_documents_pk PRIMARY KEY (docid),
177 184
   CONSTRAINT xml_documents_rep_fk
178
    		FOREIGN KEY (server_location) REFERENCES xml_replication, 
179
   CONSTRAINT xml_documents_root_fk 
185
    		FOREIGN KEY (server_location) REFERENCES xml_replication,
186
   CONSTRAINT xml_documents_root_fk
180 187
		FOREIGN KEY (rootnodeid) REFERENCES xml_nodes,
181
   CONSTRAINT xml_documents_catalog_fk 
188
   CONSTRAINT xml_documents_catalog_fk
182 189
		FOREIGN KEY (catalog_id) REFERENCES xml_catalog
183 190
);
184 191

  
185
/* 
192
/*
186 193
 * Index of <docid,doctype> in xml_document
187 194
 */
188 195
CREATE INDEX xml_documents_idx1 ON xml_documents (docid, doctype);
189 196

  
190
/* 
197
/*
191 198
 * Revised Documents -- table to store XML documents saved after an UPDATE
192 199
 *                    or DELETE
193 200
 */
......
204 211
	date_created	DATE,
205 212
	date_updated	DATE,
206 213
	public_access	NUMBER(1),	-- flag for public access
207
        catalog_id      NUMBER(20),	-- reference to xml_catalog 
214
        catalog_id      NUMBER(20),	-- reference to xml_catalog
208 215
   CONSTRAINT xml_revisions_pk PRIMARY KEY (revisionid),
209 216
   CONSTRAINT xml_revisions_rep_fk
210 217
		FOREIGN KEY (server_location) REFERENCES xml_replication,
211
   CONSTRAINT xml_revisions_root_fk 
218
   CONSTRAINT xml_revisions_root_fk
212 219
		FOREIGN KEY (rootnodeid) REFERENCES xml_nodes,
213
   CONSTRAINT xml_revisions_catalog_fk 
220
   CONSTRAINT xml_revisions_catalog_fk
214 221
		FOREIGN KEY (catalog_id) REFERENCES xml_catalog
215 222
);
216 223

  
......
225 232
END;
226 233
/
227 234

  
228
/* 
235
/*
229 236
 * ACL -- table to store ACL for XML documents by principals
230 237
 */
231 238
CREATE TABLE xml_access (
......
242 249
  startnodeid NUMBER(20), -- start node for sub tree
243 250
  endnodeid NUMBER(20),    -- end node for sub tree
244 251
   CONSTRAINT xml_access_ck CHECK (begin_time < end_time),
245
   CONSTRAINT xml_access_accessfileid_fk 
252
   CONSTRAINT xml_access_accessfileid_fk
246 253
		FOREIGN KEY (accessfileid) REFERENCES xml_documents
247 254
);
248 255

  
249
/* 
250
 * Index of Nodes -- table to store precomputed paths through tree for 
256
/*
257
 * Index of Nodes -- table to store precomputed paths through tree for
251 258
 * quick searching in structured searches
252 259
 */
253 260
CREATE TABLE xml_index (
......
255 262
	path		VARCHAR2(1000),	-- precomputed path through tree
256 263
	docid		VARCHAR2(250),	-- index to the document id
257 264
	doctype		VARCHAR2(100),	-- public id indicating document type
258
        parentnodeid    NUMBER(20),     -- id of the parent of the node 
265
        parentnodeid    NUMBER(20),     -- id of the parent of the node
259 266
					-- represented by this row
260
	nodedata        VARCHAR2(4000), -- the data for the given path 
267
	nodedata        VARCHAR2(4000), -- the data for the given path
261 268
   CONSTRAINT xml_index_pk PRIMARY KEY (nodeid,path),
262 269
   CONSTRAINT xml_index_nodeid_fk FOREIGN KEY (nodeid) REFERENCES xml_nodes,
263
   CONSTRAINT xml_index_docid_fk 
270
   CONSTRAINT xml_index_docid_fk
264 271
		FOREIGN KEY (docid) REFERENCES xml_documents
265 272
);
266 273

  
267
/* 
268
 * Index of the paths in xml_index 
274
/*
275
 * Index of the paths in xml_index
269 276
 */
270 277
CREATE INDEX xml_index_idx1 ON xml_index (path);
271 278
CREATE INDEX xml_index_idx2 ON xml_index (docid);
......
281 288
	object        VARCHAR2(512) NOT NULL, -- the object of the relation
282 289
	objdoctype    VARCHAR2(128),          -- the doctype of the object
283 290
	CONSTRAINT xml_relation_uk UNIQUE (docid, subject, relationship, object),
284
	CONSTRAINT xml_relation_docid_fk 
291
	CONSTRAINT xml_relation_docid_fk
285 292
		FOREIGN KEY (docid) REFERENCES xml_documents
286 293
  );
287 294

  
288 295
CREATE SEQUENCE xml_relation_id_seq;
289
  
296

  
290 297
CREATE TRIGGER xml_relation_before_insert
291 298
BEFORE INSERT ON xml_relation FOR EACH ROW
292 299
BEGIN
293 300
  SELECT xml_relation_id_seq.nextval
294 301
    INTO :new.relationid
295 302
    FROM dual;
296
END;                                   
303
END;
297 304
/
298 305

  
299
/* 
306
/*
300 307
 * Table used as Unique ID generator for the uniqueid part of Accession#
301 308
 */
302 309
CREATE SEQUENCE accession_number_id_seq;
......
311 318
  SELECT accession_number_id_seq.nextval
312 319
    INTO :new.uniqueid
313 320
    FROM dual;
314
END;                                   
321
END;
315 322
/
316 323

  
317
/* 
318
 * accesssubtree -- table to store access subtree info 
324
/*
325
 * accesssubtree -- table to store access subtree info
319 326
 */
320 327
CREATE TABLE xml_accesssubtree (
321 328
	docid		VARCHAR2(250),	-- the document id #
322 329
  rev 		NUMBER(10) DEFAULT 1, --the revision number of the docume
323 330
  controllevel VARCHAR2(50), -- the level it control -- document or subtree
324
  subtreeid VARCHAR2(250), -- the subtree id 
331
  subtreeid VARCHAR2(250), -- the subtree id
325 332
	startnodeid	NUMBER(20),	-- the start node id of access subtree
326 333
  endnodeid NUMBER(20), -- the end node if of access subtree
327
  CONSTRAINT xml_accesssubtree_docid_fk 
334
  CONSTRAINT xml_accesssubtree_docid_fk
328 335
		FOREIGN KEY (docid) REFERENCES xml_documents
329 336
);
330 337

  
331 338
/*
339
 * Returnfields -- table to store combinations of returnfields requested
340
 *		   and the number of times this table is accessed
341
 */
342
CREATE TABLE xml_returnfield (
343
        returnfield_id     NUMBER(20),     -- the id for this returnfield entry
344
        returnfield_string VARCHAR2(2000), -- the returnfield string
345
        usage_count        NUMBER(20),     -- the number of times this string
346
                                           -- has been requested
347
        CONSTRAINT xml_returnfield_pk PRIMARY KEY (returnfield_id)
348
);
349
CREATE INDEX xml_returnfield_idx1 ON xml_returnfield(returnfield_string);
350

  
351
CREATE SEQUENCE xml_returnfield_id_seq;
352

  
353
CREATE TRIGGER xml_returnfield_before_insert
354
BEFORE INSERT ON xml_returnfield FOR EACH ROW
355
BEGIN
356
  SELECT xml_returnfield_id_seq.nextval
357
    INTO :new.returnfield_id
358
    FROM dual;
359
END;
360
/
361

  
362
/*
363
 * Queryresults -- table to store queryresults for a given docid
364
 * and returnfield_id
365
 */
366
CREATE TABLE xml_queryresult(
367
  queryresult_id       NUMBER(20),     -- id for this entry
368
  returnfield_id       NUMBER(20),     -- id for the returnfield corresponding to this entry
369
  docid                VARCHAR2(250),  -- docid of the document
370
  queryresult_string   VARCHAR2(4000), -- resultant text generated for this docid and given
371
  				       -- returnfield
372
  CONSTRAINT xml_queryresult_pk PRIMARY KEY (queryresult_id),
373
  CONSTRAINT xml_queryresult_searchid_fk
374
               FOREIGN KEY (returnfield_id) REFERENCES xml_returnfield
375
);
376

  
377
CREATE INDEX xml_queryresult_idx1 ON xml_queryresult (returnfield_id, docid);
378

  
379
CREATE SEQUENCE xml_queryresult_id_seq;
380

  
381
CREATE TRIGGER xml_queryresult_before_insert
382
BEFORE INSERT ON xml_queryresult FOR EACH ROW
383
BEGIN
384
 SELECT xml_queryresult_id_seq.nextval
385
   INTO :new.queryresult_id
386
   FROM dual;
387
END;
388
/
389

  
390
/*
332 391
 * Logging -- table to store metadata and data access log
333 392
 */
334 393
CREATE TABLE access_log (
......
351 410
END;
352 411
/
353 412

  
354
/* 
413
/*
355 414
 * harvest_site_schedule -- table to store harvest sites and schedule info
356 415
 */
357 416
CREATE TABLE harvest_site_schedule (
......
367 426
  CONSTRAINT harvest_site_schedule_pk PRIMARY KEY (site_schedule_id)
368 427
);
369 428

  
370
/* 
429
/*
371 430
 * harvest_log -- table to log entries for harvest operations
372 431
 */
373 432
CREATE TABLE harvest_log (
......
380 439
  CONSTRAINT harvest_log_pk PRIMARY KEY (harvest_log_id)
381 440
);
382 441

  
383
/* 
442
/*
384 443
 * harvest_detail_log -- table to log detailed info about documents that
385 444
 *                       generated errors during the harvest
386 445
 */
......
394 453
  error_message          VARCHAR2(1000), -- text error message
395 454
  document_type          VARCHAR2(100),  -- document type
396 455
  CONSTRAINT harvest_detail_log_pk PRIMARY KEY (detail_log_id),
397
  CONSTRAINT harvest_detail_log_fk 
456
  CONSTRAINT harvest_detail_log_fk
398 457
        FOREIGN KEY (harvest_log_id) REFERENCES harvest_log
399 458
);
400 459

  
src/xmltables-postgres.sql
21 21
 * along with this program; if not, write to the Free Software
22 22
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 23
 */
24
 
24

  
25 25
/*
26
 *	this is sql script does the same as the sql script named 
27
 *	xmltables.sql except that this script is to be use to 
26
 *	this is sql script does the same as the sql script named
27
 *	xmltables.sql except that this script is to be use to
28 28
 *	create the database tables on a Postgresql backend rather
29 29
 *	than an Oracle Backend
30 30
 */
......
34 34
 */
35 35
CREATE SEQUENCE xml_replication_id_seq;
36 36
CREATE TABLE xml_replication (
37
  serverid INT8 default nextval('xml_replication_id_seq'), 
37
  serverid INT8 default nextval('xml_replication_id_seq'),
38 38
  server VARCHAR(512),
39 39
  last_checked DATE,
40 40
  replicate INT8,
41 41
  datareplicate INT8,
42 42
  hub INT8,
43 43
  CONSTRAINT xml_replication_pk PRIMARY KEY (serverid)
44
);  
44
);
45 45

  
46 46
INSERT INTO xml_replication (server, replicate, datareplicate, hub) VALUES ('localhost', '0', '0', '0');
47 47

  
48
/* 
48
/*
49 49
 * Nodes -- table to store XML Nodes (both elements and attributes)
50 50
 */
51 51
CREATE SEQUENCE xml_nodes_id_seq;
......
57 57
				-- ELEMENT, ATTRIBUTE, TEXT)
58 58
	nodename VARCHAR(250),	-- the name of an element or attribute
59 59
        nodeprefix VARCHAR(50), -- the namespace prefix of the node
60
	nodedata VARCHAR(4000), -- the data for this node (e.g., 
60
	nodedata VARCHAR(4000), -- the data for this node (e.g.,
61 61
				-- for TEXT it is the content)
62 62
	parentnodeid INT8,	-- index of the parent of this node
63 63
	rootnodeid INT8,	-- index of the root node of this tree
......
67 67
        nodedatanumerical FLOAT8, -- the data for this node if
68 68
				  -- if it is a number
69 69
   CONSTRAINT xml_nodes_pk PRIMARY KEY (nodeid),
70
   CONSTRAINT xml_nodes_root_fk 
70
   CONSTRAINT xml_nodes_root_fk
71 71
		FOREIGN KEY (rootnodeid) REFERENCES xml_nodes,
72
   CONSTRAINT xml_nodes_parent_fk 
72
   CONSTRAINT xml_nodes_parent_fk
73 73
		FOREIGN KEY (parentnodeid) REFERENCES xml_nodes
74 74
);
75
/* 
75
/*
76 76
 * Indexes of rootnodeid, parentnodeid, and nodename in xml_nodes
77 77
 */
78 78
CREATE INDEX xml_nodes_idx1 ON xml_nodes (rootnodeid);
79 79
CREATE INDEX xml_nodes_idx2 ON xml_nodes (parentnodeid);
80 80
CREATE INDEX xml_nodes_idx3 ON xml_nodes (nodename);
81 81

  
82
/* 
82
/*
83 83
 * XML Catalog -- table to store all external sources for XML documents
84 84
 */
85 85
CREATE SEQUENCE xml_catalog_id_seq;
......
93 93
	public_id VARCHAR(500),	-- the unique id for this type
94 94
	system_id VARCHAR(1000),	-- the local location of the object
95 95
   CONSTRAINT xml_catalog_pk PRIMARY KEY (catalog_id),
96
   CONSTRAINT xml_catalog_uk UNIQUE  
96
   CONSTRAINT xml_catalog_uk UNIQUE
97 97
              (entry_type, source_doctype, target_doctype, public_id)
98 98
);
99 99

  
100
/* 
100
/*
101 101
 * Sequence to get uniqueID for Accession #
102 102
 */
103 103
CREATE SEQUENCE xml_documents_id_seq;
104
/* 
104
/*
105 105
 * Documents -- table to store XML documents
106 106
 */
107 107
CREATE TABLE xml_documents (
......
116 116
	date_created DATE,
117 117
	date_updated DATE,
118 118
	public_access INT8,	-- flag for public access
119
        catalog_id INT8,	-- reference to xml_catalog 
119
        catalog_id INT8,	-- reference to xml_catalog
120 120
     CONSTRAINT xml_documents_pk PRIMARY KEY (docid),
121 121
     CONSTRAINT xml_documents_rep_fk
122
     		FOREIGN KEY (server_location) REFERENCES xml_replication, 
123
    CONSTRAINT xml_documents_root_fk 
122
     		FOREIGN KEY (server_location) REFERENCES xml_replication,
123
    CONSTRAINT xml_documents_root_fk
124 124
		FOREIGN KEY (rootnodeid) REFERENCES xml_nodes,
125
   CONSTRAINT xml_documents_catalog_fk 
125
   CONSTRAINT xml_documents_catalog_fk
126 126
		FOREIGN KEY (catalog_id) REFERENCES xml_catalog
127 127
);
128 128

  
129
/* 
129
/*
130 130
 * Index of <docid,doctype> in xml_document
131 131
 */
132 132
CREATE INDEX xml_documents_idx1 ON xml_documents (docid, doctype);
133 133

  
134
/* 
134
/*
135 135
 * Revised Documents -- table to store XML documents saved after an UPDATE
136 136
 *                    or DELETE
137 137
 */
......
150 150
	date_created DATE,
151 151
	date_updated DATE,
152 152
	public_access INT8,	-- flag for public access
153
        catalog_id INT8,	-- reference to xml_catalog 
153
        catalog_id INT8,	-- reference to xml_catalog
154 154
   CONSTRAINT xml_revisions_pk PRIMARY KEY (revisionid),
155 155
   CONSTRAINT xml_revisions_rep_fk
156 156
		FOREIGN KEY (server_location) REFERENCES xml_replication,
157
   CONSTRAINT xml_revisions_root_fk 
157
   CONSTRAINT xml_revisions_root_fk
158 158
		FOREIGN KEY (rootnodeid) REFERENCES xml_nodes,
159
   CONSTRAINT xml_revisions_catalog_fk 
159
   CONSTRAINT xml_revisions_catalog_fk
160 160
		FOREIGN KEY (catalog_id) REFERENCES xml_catalog
161 161
);
162 162

  
163 163

  
164
/* 
164
/*
165 165
 * ACL -- table to store ACL for XML documents by principals
166 166
 */
167 167
CREATE TABLE xml_access (
......
178 178
  startnodeid INT8,
179 179
  endnodeid INT8,
180 180
   CONSTRAINT xml_access_ck CHECK (begin_time < end_time),
181
   CONSTRAINT xml_access_accessfileid_fk 
181
   CONSTRAINT xml_access_accessfileid_fk
182 182
		FOREIGN KEY (accessfileid) REFERENCES xml_documents
183 183
);
184 184

  
185
/* 
186
 * Index of Nodes -- table to store precomputed paths through tree for 
185
/*
186
 * Index of Nodes -- table to store precomputed paths through tree for
187 187
 * quick searching in structured searches
188 188
 */
189 189
CREATE TABLE xml_index (
......
193 193
	doctype VARCHAR(100),	-- public id indicating document type
194 194
        parentnodeid INT8,      -- id of the parent of the node represented
195 195
				-- by this row
196
	nodedata VARCHAR (4000),-- for storing data for a given path  
196
	nodedata VARCHAR (4000),-- for storing data for a given path
197 197
   CONSTRAINT xml_index_pk PRIMARY KEY (nodeid,path),
198 198
   CONSTRAINT xml_index_nodeid_fk FOREIGN KEY (nodeid) REFERENCES xml_nodes,
199
   CONSTRAINT xml_index_docid_fk 
199
   CONSTRAINT xml_index_docid_fk
200 200
		FOREIGN KEY (docid) REFERENCES xml_documents
201 201
);
202 202

  
203
/* 
204
 * Index of the paths in xml_index 
203
/*
204
 * Index of the paths in xml_index
205 205
 */
206 206
CREATE INDEX xml_index_idx1 ON xml_index (path);
207 207
CREATE INDEX xml_index_idx2 ON xml_index (docid);
......
219 219
	object VARCHAR(512) NOT NULL, -- the object of the relation
220 220
	objdoctype VARCHAR(128),          -- the doctype of the object
221 221
	CONSTRAINT xml_relation_uk UNIQUE (docid, subject, relationship, object),
222
	CONSTRAINT xml_relation_docid_fk 
222
	CONSTRAINT xml_relation_docid_fk
223 223
		FOREIGN KEY (docid) REFERENCES xml_documents
224 224
);
225 225

  
226
/* 
226
/*
227 227
 * Table used as Unique ID generator for the uniqueid part of Accession#
228 228
 */
229 229
CREATE SEQUENCE accession_number_id_seq;
......
233 233
   date_created DATE
234 234
);
235 235

  
236
/* 
237
 * accesssubtree -- table to store access subtree info 
236
/*
237
 * accesssubtree -- table to store access subtree info
238 238
 */
239 239
CREATE TABLE xml_accesssubtree (
240 240
	docid		VARCHAR(250),	-- the document id #
241 241
  rev 		INT8 default 1, --the revision number of the docume
242 242
  controllevel VARCHAR(50), -- the level it control -- document or subtree
243
  subtreeid VARCHAR(250), -- the subtree id 
243
  subtreeid VARCHAR(250), -- the subtree id
244 244
	startnodeid	INT8,	-- the start node id of access subtree
245 245
  endnodeid INT8, -- the end node if of access subtree
246
  CONSTRAINT xml_accesssubtree_docid_fk 
246
  CONSTRAINT xml_accesssubtree_docid_fk
247 247
		FOREIGN KEY (docid) REFERENCES xml_documents
248 248
);
249 249

  
250 250
/*
251
 * Returnfields -- table to store combinations of returnfields requested
252
 *		    and the number of times this table is accessed
253
 */
254
CREATE TABLE xml_returnfield (
255
        returnfield_id     INT8 default nextval('xml_returnfield_id_seq'),   -- the id for this returnfield entry
256
        returnfield_string VARCHAR(2000),                                    -- the returnfield string
257
        usage_count        INT8,                                             -- the number of times this string has been requested
258
        CONSTRAINT xml_returnfield_pk PRIMARY KEY (returnfield_id)
259
);
260
CREATE INDEX xml_returnfield_idx1 ON xml_returnfield(returnfield_string);
261

  
262
CREATE SEQUENCE xml_returnfield_id_seq;
263

  
264
/*
265
 * Queryresults -- table to store queryresults for a given docid
266
 * and returnfield_id
267
 */
268
CREATE TABLE xml_queryresult(
269
  queryresult_id INT8 default nextval('xml_queryresult_id_seq'), -- id for this entry
270
  returnfield_id       INT8,          -- id for the returnfield corresponding to this entry
271
  docid                VARCHAR(250),  -- docid of the document
272
  queryresult_string   VARCHAR(4000), -- resultant text generated for this docid and given
273
  				       -- returnfield
274
  CONSTRAINT xml_queryresult_pk PRIMARY KEY (queryresult_id),
275
  CONSTRAINT xml_queryresult_searchid_fk
276
               FOREIGN KEY (returnfield_id) REFERENCES xml_returnfield
277
);
278

  
279
CREATE INDEX xml_queryresult_idx1 ON xml_queryresult (returnfield_id, docid);
280

  
281
CREATE SEQUENCE xml_queryresult_id_seq;
282

  
283
/*
251 284
 * Logging -- table to store metadata and data access log
252 285
 */
253 286
CREATE SEQUENCE access_log_id_seq;
......
261 294
  CONSTRAINT access_log_pk PRIMARY KEY (entryid)
262 295
);
263 296

  
264
/* 
297
/*
265 298
 * harvest_site_schedule -- table to store harvest sites and schedule info
266 299
 */
267 300
CREATE TABLE harvest_site_schedule (
......
277 310
  CONSTRAINT harvest_site_schedule_pk PRIMARY KEY (site_schedule_id)
278 311
);
279 312

  
280
/* 
313
/*
281 314
 * harvest_log -- table to log entries for harvest operations
282 315
 */
283 316
CREATE TABLE harvest_log (
......
290 323
  CONSTRAINT harvest_log_pk PRIMARY KEY (harvest_log_id)
291 324
);
292 325

  
293
/* 
326
/*
294 327
 * harvest_detail_log -- table to log detailed info about documents that
295 328
 *                       generated errors during the harvest
296 329
 */
......
304 337
  error_message          VARCHAR(1000), -- text error message
305 338
  document_type          VARCHAR(100),  -- document type
306 339
  CONSTRAINT harvest_detail_log_pk PRIMARY KEY (detail_log_id),
307
  CONSTRAINT harvest_detail_log_fk 
340
  CONSTRAINT harvest_detail_log_fk
308 341
        FOREIGN KEY (harvest_log_id) REFERENCES harvest_log
309 342
);
310 343

  

Also available in: Unified diff