2006-09-09 00:12:09 +00:00
|
|
|
-- 48
|
2006-03-14 11:34:17 +00:00
|
|
|
|
2006-03-22 16:42:22 +00:00
|
|
|
DROP TABLE IF EXISTS version;
|
2006-02-21 17:01:06 +00:00
|
|
|
CREATE TABLE version (
|
2006-06-07 15:27:21 +00:00
|
|
|
schema TEXT PRIMARY KEY,
|
|
|
|
version INT NOT NULL
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
2006-06-07 15:27:21 +00:00
|
|
|
DROP INDEX IF EXISTS schema;
|
|
|
|
CREATE INDEX schema ON version(schema);
|
2006-02-21 17:01:06 +00:00
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- The foundational table; every item collected has a unique record here
|
2006-05-18 11:25:10 +00:00
|
|
|
DROP TABLE IF EXISTS items;
|
|
|
|
CREATE TABLE items (
|
|
|
|
itemID INTEGER PRIMARY KEY,
|
|
|
|
itemTypeID INT,
|
2006-03-14 11:34:17 +00:00
|
|
|
title TEXT,
|
|
|
|
dateAdded DATETIME DEFAULT CURRENT_TIMESTAMP,
|
2006-06-01 00:22:18 +00:00
|
|
|
dateModified DATETIME DEFAULT CURRENT_TIMESTAMP
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Valid item types ("book," "journalArticle," etc.)
|
2006-05-18 11:25:10 +00:00
|
|
|
DROP TABLE IF EXISTS itemTypes;
|
|
|
|
CREATE TABLE itemTypes (
|
|
|
|
itemTypeID INTEGER PRIMARY KEY,
|
2006-02-21 17:01:06 +00:00
|
|
|
typeName TEXT
|
|
|
|
);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Describes various types of fields and their format restrictions,
|
|
|
|
-- and indicates whether data should be stored as strings or integers
|
2006-03-22 16:42:22 +00:00
|
|
|
DROP TABLE IF EXISTS fieldFormats;
|
2006-03-14 10:57:01 +00:00
|
|
|
CREATE TABLE fieldFormats (
|
|
|
|
fieldFormatID INTEGER PRIMARY KEY,
|
|
|
|
regex TEXT,
|
|
|
|
isInteger INT
|
|
|
|
);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Field types for item metadata
|
2006-03-22 16:42:22 +00:00
|
|
|
DROP TABLE IF EXISTS fields;
|
2006-02-21 17:01:06 +00:00
|
|
|
CREATE TABLE fields (
|
2006-03-14 10:57:01 +00:00
|
|
|
fieldID INTEGER PRIMARY KEY,
|
2006-02-21 17:01:06 +00:00
|
|
|
fieldName TEXT,
|
2006-03-14 10:57:01 +00:00
|
|
|
fieldFormatID INT,
|
|
|
|
FOREIGN KEY (fieldFormatID) REFERENCES fieldFormat(fieldFormatID)
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
|
|
|
|
2006-08-26 10:35:47 +00:00
|
|
|
-- Defines valid fields for each itemType, their display order, and their default visibility
|
2006-05-18 11:25:10 +00:00
|
|
|
DROP TABLE IF EXISTS itemTypeFields;
|
|
|
|
CREATE TABLE itemTypeFields (
|
|
|
|
itemTypeID INT,
|
2006-02-21 17:01:06 +00:00
|
|
|
fieldID INT,
|
2006-08-26 10:35:47 +00:00
|
|
|
hide INT,
|
2006-02-21 17:01:06 +00:00
|
|
|
orderIndex INT,
|
2006-05-18 11:25:10 +00:00
|
|
|
PRIMARY KEY (itemTypeID, fieldID),
|
|
|
|
FOREIGN KEY (itemTypeID) REFERENCES itemTypes(itemTypeID),
|
|
|
|
FOREIGN KEY (fieldID) REFERENCES itemTypes(itemTypeID)
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Type-specific data for individual items
|
2006-05-18 11:25:10 +00:00
|
|
|
DROP TABLE IF EXISTS itemData;
|
|
|
|
CREATE TABLE itemData (
|
|
|
|
itemID INT,
|
2006-02-21 17:01:06 +00:00
|
|
|
fieldID INT,
|
2006-08-31 05:58:32 +00:00
|
|
|
value,
|
2006-05-18 11:25:10 +00:00
|
|
|
PRIMARY KEY (itemID, fieldID),
|
|
|
|
FOREIGN KEY (itemID) REFERENCES items(itemID),
|
2006-02-21 17:01:06 +00:00
|
|
|
FOREIGN KEY (fieldID) REFERENCES fields(fieldID)
|
|
|
|
);
|
2006-05-18 11:25:10 +00:00
|
|
|
DROP INDEX IF EXISTS value;
|
2006-06-01 00:22:18 +00:00
|
|
|
CREATE INDEX value ON itemData(value);
|
2006-02-21 17:01:06 +00:00
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Note data for note items
|
2006-06-16 07:32:48 +00:00
|
|
|
DROP TABLE IF EXISTS itemNotes;
|
|
|
|
CREATE TABLE itemNotes (
|
|
|
|
itemID INT,
|
Fixes #29, independent notes
- Added 'note' item type
- Updated API to support independent note creation
Notes are, more or less, just regular items, with an item type of 1. They're created through Scholar.Notes.add(text, sourceItemID), which returns the itemID of the new note. sourceItemID is optional--if left out, an independent note will be created. (There's currently nothing stopping you from doing getNewItemByType(1) yourself, but the note would be contentless and broken, so you shouldn't do that.) Note data could've been stuffed into itemData, but I kept it separate in itemNotes to keep metadata searching faster and to keep things cleaner.
Methods calls that can be called on all items:
isNote() (same as testing for itemTypeID 1)
Method calls that can be called on source items only:
numNotes()
getNotes() (array of note itemIDs for a source)
Method calls that can be called on note items only:
updateNote(text)
setNoteSource(sourceItemID) (for changing source--use empty or false to make independent, which is currently what happens when you delete a note--will get option with #91)
getNote() (note content)
getNoteSource() (sourceItemID of a note)
Calling the above methods on the wrong item types will throw an error.
*** This will break note creation/display until David updates interface code. ***
2006-06-27 15:14:07 +00:00
|
|
|
sourceItemID INT,
|
2006-06-16 07:32:48 +00:00
|
|
|
note TEXT,
|
Fixes #29, independent notes
- Added 'note' item type
- Updated API to support independent note creation
Notes are, more or less, just regular items, with an item type of 1. They're created through Scholar.Notes.add(text, sourceItemID), which returns the itemID of the new note. sourceItemID is optional--if left out, an independent note will be created. (There's currently nothing stopping you from doing getNewItemByType(1) yourself, but the note would be contentless and broken, so you shouldn't do that.) Note data could've been stuffed into itemData, but I kept it separate in itemNotes to keep metadata searching faster and to keep things cleaner.
Methods calls that can be called on all items:
isNote() (same as testing for itemTypeID 1)
Method calls that can be called on source items only:
numNotes()
getNotes() (array of note itemIDs for a source)
Method calls that can be called on note items only:
updateNote(text)
setNoteSource(sourceItemID) (for changing source--use empty or false to make independent, which is currently what happens when you delete a note--will get option with #91)
getNote() (note content)
getNoteSource() (sourceItemID of a note)
Calling the above methods on the wrong item types will throw an error.
*** This will break note creation/display until David updates interface code. ***
2006-06-27 15:14:07 +00:00
|
|
|
PRIMARY KEY (itemID),
|
Addresses #17, add filesystem/ability to store files
Not finished, but enough to give David something to work with
No BLOBs -- just linking/importing of files and loaded documents
New Scholar.Item methods:
incrementFileCount() (used internally)
decrementFileCount() (used internally)
isFile()
numFiles()
getFile() -- returns nsILocalFile or false if associated file doesn't exist (note: always returns false for items with LINK_MODE_LINKED_URL, since they have no files -- use getFileURL() instead)
getFileURL() -- returns URL string
getFileLinkMode() -- compare to Scholar.Files.LINK_MODE_* constants: LINKED_FILE, IMPORTED_FILE, LINKED_URL, IMPORTED_URL
getFileMimeType() -- mime type of file (e.g. text/plain)
getFileCharset() -- charsetID of file
getFiles() -- array of file itemIDs this file is a source for
New Scholar.Files methods:
importFromFile(nsIFile file [, int sourceItemID])
linkFromFile(nsIFile file [, int sourceItemID])
importFromDocument(nsIDOMDocument document [, int sourceItemID])
linkFromDocument(nsIDOMDocument document [, int sourceItemID])
New class Scholar.FileTypes -- partially implemented, not yet used
New class Scholar.CharacterSets -- same as other *Types classes:
getID(idOrName)
getName(idOrName)
getTypes() (aliased to getAll(), which I'll probably change the others to as well)
Charsets table with all official character sets (copied from Mozilla source)
Renamed Item.setNoteSource() to setSource() and Item.getNoteSource() to getSource() and adjusted to handle both notes and files
2006-07-27 09:16:02 +00:00
|
|
|
FOREIGN KEY (itemID) REFERENCES items(itemID),
|
Fixes #29, independent notes
- Added 'note' item type
- Updated API to support independent note creation
Notes are, more or less, just regular items, with an item type of 1. They're created through Scholar.Notes.add(text, sourceItemID), which returns the itemID of the new note. sourceItemID is optional--if left out, an independent note will be created. (There's currently nothing stopping you from doing getNewItemByType(1) yourself, but the note would be contentless and broken, so you shouldn't do that.) Note data could've been stuffed into itemData, but I kept it separate in itemNotes to keep metadata searching faster and to keep things cleaner.
Methods calls that can be called on all items:
isNote() (same as testing for itemTypeID 1)
Method calls that can be called on source items only:
numNotes()
getNotes() (array of note itemIDs for a source)
Method calls that can be called on note items only:
updateNote(text)
setNoteSource(sourceItemID) (for changing source--use empty or false to make independent, which is currently what happens when you delete a note--will get option with #91)
getNote() (note content)
getNoteSource() (sourceItemID of a note)
Calling the above methods on the wrong item types will throw an error.
*** This will break note creation/display until David updates interface code. ***
2006-06-27 15:14:07 +00:00
|
|
|
FOREIGN KEY (sourceItemID) REFERENCES items(itemID)
|
2006-06-16 07:32:48 +00:00
|
|
|
);
|
Fixes #29, independent notes
- Added 'note' item type
- Updated API to support independent note creation
Notes are, more or less, just regular items, with an item type of 1. They're created through Scholar.Notes.add(text, sourceItemID), which returns the itemID of the new note. sourceItemID is optional--if left out, an independent note will be created. (There's currently nothing stopping you from doing getNewItemByType(1) yourself, but the note would be contentless and broken, so you shouldn't do that.) Note data could've been stuffed into itemData, but I kept it separate in itemNotes to keep metadata searching faster and to keep things cleaner.
Methods calls that can be called on all items:
isNote() (same as testing for itemTypeID 1)
Method calls that can be called on source items only:
numNotes()
getNotes() (array of note itemIDs for a source)
Method calls that can be called on note items only:
updateNote(text)
setNoteSource(sourceItemID) (for changing source--use empty or false to make independent, which is currently what happens when you delete a note--will get option with #91)
getNote() (note content)
getNoteSource() (sourceItemID of a note)
Calling the above methods on the wrong item types will throw an error.
*** This will break note creation/display until David updates interface code. ***
2006-06-27 15:14:07 +00:00
|
|
|
DROP INDEX IF EXISTS itemNotes_sourceItemID;
|
|
|
|
CREATE INDEX itemNotes_sourceItemID ON itemNotes(sourceItemID);
|
2006-06-16 07:32:48 +00:00
|
|
|
|
Addresses #17, add filesystem/ability to store files
Not finished, but enough to give David something to work with
No BLOBs -- just linking/importing of files and loaded documents
New Scholar.Item methods:
incrementFileCount() (used internally)
decrementFileCount() (used internally)
isFile()
numFiles()
getFile() -- returns nsILocalFile or false if associated file doesn't exist (note: always returns false for items with LINK_MODE_LINKED_URL, since they have no files -- use getFileURL() instead)
getFileURL() -- returns URL string
getFileLinkMode() -- compare to Scholar.Files.LINK_MODE_* constants: LINKED_FILE, IMPORTED_FILE, LINKED_URL, IMPORTED_URL
getFileMimeType() -- mime type of file (e.g. text/plain)
getFileCharset() -- charsetID of file
getFiles() -- array of file itemIDs this file is a source for
New Scholar.Files methods:
importFromFile(nsIFile file [, int sourceItemID])
linkFromFile(nsIFile file [, int sourceItemID])
importFromDocument(nsIDOMDocument document [, int sourceItemID])
linkFromDocument(nsIDOMDocument document [, int sourceItemID])
New class Scholar.FileTypes -- partially implemented, not yet used
New class Scholar.CharacterSets -- same as other *Types classes:
getID(idOrName)
getName(idOrName)
getTypes() (aliased to getAll(), which I'll probably change the others to as well)
Charsets table with all official character sets (copied from Mozilla source)
Renamed Item.setNoteSource() to setSource() and Item.getNoteSource() to getSource() and adjusted to handle both notes and files
2006-07-27 09:16:02 +00:00
|
|
|
DROP TABLE IF EXISTS charsets;
|
|
|
|
CREATE TABLE charsets (
|
|
|
|
charsetID INTEGER PRIMARY KEY,
|
|
|
|
charset TEXT UNIQUE
|
|
|
|
);
|
|
|
|
DROP INDEX IF EXISTS charsets_charset;
|
|
|
|
CREATE INDEX charsets_charset ON charsets(charset);
|
|
|
|
|
|
|
|
DROP TABLE IF EXISTS fileTypes;
|
|
|
|
CREATE TABLE fileTypes (
|
|
|
|
fileTypeID INTEGER PRIMARY KEY,
|
|
|
|
fileType TEXT UNIQUE
|
|
|
|
);
|
|
|
|
DROP INDEX IF EXISTS fileTypes_fileType;
|
|
|
|
CREATE INDEX fileTypes_fileType ON fileTypes(fileType);
|
|
|
|
|
|
|
|
DROP TABLE IF EXISTS fileTypeMimeTypes;
|
|
|
|
CREATE TABLE fileTypeMimeTypes (
|
2006-08-08 08:23:23 +00:00
|
|
|
fileTypeID INT,
|
|
|
|
mimeType TEXT,
|
Addresses #17, add filesystem/ability to store files
Not finished, but enough to give David something to work with
No BLOBs -- just linking/importing of files and loaded documents
New Scholar.Item methods:
incrementFileCount() (used internally)
decrementFileCount() (used internally)
isFile()
numFiles()
getFile() -- returns nsILocalFile or false if associated file doesn't exist (note: always returns false for items with LINK_MODE_LINKED_URL, since they have no files -- use getFileURL() instead)
getFileURL() -- returns URL string
getFileLinkMode() -- compare to Scholar.Files.LINK_MODE_* constants: LINKED_FILE, IMPORTED_FILE, LINKED_URL, IMPORTED_URL
getFileMimeType() -- mime type of file (e.g. text/plain)
getFileCharset() -- charsetID of file
getFiles() -- array of file itemIDs this file is a source for
New Scholar.Files methods:
importFromFile(nsIFile file [, int sourceItemID])
linkFromFile(nsIFile file [, int sourceItemID])
importFromDocument(nsIDOMDocument document [, int sourceItemID])
linkFromDocument(nsIDOMDocument document [, int sourceItemID])
New class Scholar.FileTypes -- partially implemented, not yet used
New class Scholar.CharacterSets -- same as other *Types classes:
getID(idOrName)
getName(idOrName)
getTypes() (aliased to getAll(), which I'll probably change the others to as well)
Charsets table with all official character sets (copied from Mozilla source)
Renamed Item.setNoteSource() to setSource() and Item.getNoteSource() to getSource() and adjusted to handle both notes and files
2006-07-27 09:16:02 +00:00
|
|
|
PRIMARY KEY (fileTypeID, mimeType),
|
|
|
|
FOREIGN KEY (fileTypeID) REFERENCES fileTypes(fileTypeID)
|
|
|
|
);
|
|
|
|
DROP INDEX IF EXISTS fileTypeMimeTypes_mimeType;
|
|
|
|
CREATE INDEX fileTypeMimeTypes_mimeType ON fileTypeMimeTypes(mimeType);
|
|
|
|
|
2006-08-12 00:18:20 +00:00
|
|
|
-- Metadata for attachment items
|
|
|
|
DROP TABLE IF EXISTS itemAttachments;
|
|
|
|
CREATE TABLE itemAttachments (
|
Addresses #17, add filesystem/ability to store files
Not finished, but enough to give David something to work with
No BLOBs -- just linking/importing of files and loaded documents
New Scholar.Item methods:
incrementFileCount() (used internally)
decrementFileCount() (used internally)
isFile()
numFiles()
getFile() -- returns nsILocalFile or false if associated file doesn't exist (note: always returns false for items with LINK_MODE_LINKED_URL, since they have no files -- use getFileURL() instead)
getFileURL() -- returns URL string
getFileLinkMode() -- compare to Scholar.Files.LINK_MODE_* constants: LINKED_FILE, IMPORTED_FILE, LINKED_URL, IMPORTED_URL
getFileMimeType() -- mime type of file (e.g. text/plain)
getFileCharset() -- charsetID of file
getFiles() -- array of file itemIDs this file is a source for
New Scholar.Files methods:
importFromFile(nsIFile file [, int sourceItemID])
linkFromFile(nsIFile file [, int sourceItemID])
importFromDocument(nsIDOMDocument document [, int sourceItemID])
linkFromDocument(nsIDOMDocument document [, int sourceItemID])
New class Scholar.FileTypes -- partially implemented, not yet used
New class Scholar.CharacterSets -- same as other *Types classes:
getID(idOrName)
getName(idOrName)
getTypes() (aliased to getAll(), which I'll probably change the others to as well)
Charsets table with all official character sets (copied from Mozilla source)
Renamed Item.setNoteSource() to setSource() and Item.getNoteSource() to getSource() and adjusted to handle both notes and files
2006-07-27 09:16:02 +00:00
|
|
|
itemID INT,
|
|
|
|
sourceItemID INT,
|
|
|
|
linkMode INT,
|
|
|
|
mimeType TEXT,
|
|
|
|
charsetID INT,
|
|
|
|
path TEXT,
|
|
|
|
originalPath TEXT,
|
|
|
|
PRIMARY KEY (itemID),
|
|
|
|
FOREIGN KEY (itemID) REFERENCES items(itemID),
|
|
|
|
FOREIGN KEY (sourceItemID) REFERENCES items(sourceItemID)
|
|
|
|
);
|
2006-08-12 00:18:20 +00:00
|
|
|
DROP INDEX IF EXISTS itemAttachments_sourceItemID;
|
|
|
|
CREATE INDEX itemAttachments_sourceItemID ON itemAttachments(sourceItemID);
|
|
|
|
DROP INDEX IF EXISTS itemAttachments_mimeType;
|
|
|
|
CREATE INDEX itemAttachments_mimeType ON itemAttachments(mimeType);
|
Addresses #17, add filesystem/ability to store files
Not finished, but enough to give David something to work with
No BLOBs -- just linking/importing of files and loaded documents
New Scholar.Item methods:
incrementFileCount() (used internally)
decrementFileCount() (used internally)
isFile()
numFiles()
getFile() -- returns nsILocalFile or false if associated file doesn't exist (note: always returns false for items with LINK_MODE_LINKED_URL, since they have no files -- use getFileURL() instead)
getFileURL() -- returns URL string
getFileLinkMode() -- compare to Scholar.Files.LINK_MODE_* constants: LINKED_FILE, IMPORTED_FILE, LINKED_URL, IMPORTED_URL
getFileMimeType() -- mime type of file (e.g. text/plain)
getFileCharset() -- charsetID of file
getFiles() -- array of file itemIDs this file is a source for
New Scholar.Files methods:
importFromFile(nsIFile file [, int sourceItemID])
linkFromFile(nsIFile file [, int sourceItemID])
importFromDocument(nsIDOMDocument document [, int sourceItemID])
linkFromDocument(nsIDOMDocument document [, int sourceItemID])
New class Scholar.FileTypes -- partially implemented, not yet used
New class Scholar.CharacterSets -- same as other *Types classes:
getID(idOrName)
getName(idOrName)
getTypes() (aliased to getAll(), which I'll probably change the others to as well)
Charsets table with all official character sets (copied from Mozilla source)
Renamed Item.setNoteSource() to setSource() and Item.getNoteSource() to getSource() and adjusted to handle both notes and files
2006-07-27 09:16:02 +00:00
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Individual entries for each tag
|
2006-06-28 18:06:36 +00:00
|
|
|
DROP TABLE IF EXISTS tags;
|
|
|
|
CREATE TABLE tags (
|
|
|
|
tagID INT,
|
|
|
|
tag TEXT UNIQUE,
|
|
|
|
PRIMARY KEY (tagID)
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Associates items with keywords
|
2006-06-28 18:06:36 +00:00
|
|
|
DROP TABLE IF EXISTS itemTags;
|
|
|
|
CREATE TABLE itemTags (
|
2006-05-18 11:25:10 +00:00
|
|
|
itemID INT,
|
2006-06-28 18:06:36 +00:00
|
|
|
tagID INT,
|
|
|
|
PRIMARY KEY (itemID, tagID),
|
2006-05-18 11:25:10 +00:00
|
|
|
FOREIGN KEY (itemID) REFERENCES items(itemID),
|
2006-06-28 18:06:36 +00:00
|
|
|
FOREIGN KEY (tagID) REFERENCES tags(tagID)
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
2006-06-28 18:06:36 +00:00
|
|
|
DROP INDEX IF EXISTS itemTags_tagID;
|
|
|
|
CREATE INDEX itemTags_tagID ON itemTags(tagID);
|
2006-02-21 17:01:06 +00:00
|
|
|
|
2006-06-29 01:37:53 +00:00
|
|
|
DROP TABLE IF EXISTS itemSeeAlso;
|
|
|
|
CREATE TABLE itemSeeAlso (
|
|
|
|
itemID INT,
|
|
|
|
linkedItemID INT,
|
|
|
|
PRIMARY KEY (itemID, linkedItemID),
|
|
|
|
FOREIGN KEY (itemID) REFERENCES items(itemID),
|
|
|
|
FOREIGN KEY (linkedItemID) REFERENCES items(itemID)
|
|
|
|
);
|
|
|
|
DROP INDEX IF EXISTS itemSeeAlso_linkedItemID;
|
|
|
|
CREATE INDEX itemSeeAlso_linkedItemID ON itemSeeAlso(linkedItemID);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Names of each individual "creator" (inc. authors, editors, etc.)
|
2006-03-22 16:42:22 +00:00
|
|
|
DROP TABLE IF EXISTS creators;
|
2006-02-21 17:01:06 +00:00
|
|
|
CREATE TABLE creators (
|
2006-03-14 11:34:17 +00:00
|
|
|
creatorID INT,
|
2006-02-21 17:01:06 +00:00
|
|
|
firstName TEXT,
|
2006-03-14 10:57:01 +00:00
|
|
|
lastName TEXT,
|
2006-08-11 04:36:44 +00:00
|
|
|
isInstitution INT,
|
2006-05-20 15:18:36 +00:00
|
|
|
PRIMARY KEY (creatorID)
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Defines the possible creator types (contributor, editor, author)
|
2006-03-22 16:42:22 +00:00
|
|
|
DROP TABLE IF EXISTS creatorTypes;
|
2006-02-21 17:01:06 +00:00
|
|
|
CREATE TABLE creatorTypes (
|
2006-03-14 10:57:01 +00:00
|
|
|
creatorTypeID INTEGER PRIMARY KEY,
|
2006-02-21 17:01:06 +00:00
|
|
|
creatorType TEXT
|
|
|
|
);
|
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Associates single or multiple creators to items
|
2006-05-18 11:25:10 +00:00
|
|
|
DROP TABLE IF EXISTS itemCreators;
|
|
|
|
CREATE TABLE itemCreators (
|
|
|
|
itemID INT,
|
2006-02-21 17:01:06 +00:00
|
|
|
creatorID INT,
|
2006-05-20 15:18:36 +00:00
|
|
|
creatorTypeID INT DEFAULT 1,
|
2006-03-14 11:34:17 +00:00
|
|
|
orderIndex INT DEFAULT 0,
|
2006-08-11 05:15:56 +00:00
|
|
|
PRIMARY KEY (itemID, creatorID, creatorTypeID, orderIndex),
|
2006-05-18 11:25:10 +00:00
|
|
|
FOREIGN KEY (itemID) REFERENCES items(itemID),
|
2006-02-21 17:01:06 +00:00
|
|
|
FOREIGN KEY (creatorID) REFERENCES creators(creatorID)
|
2006-05-20 15:18:36 +00:00
|
|
|
FOREIGN KEY (creatorTypeID) REFERENCES creatorTypes(creatorTypeID)
|
2006-02-21 17:01:06 +00:00
|
|
|
);
|
2006-03-14 10:57:01 +00:00
|
|
|
|
2006-08-24 19:43:48 +00:00
|
|
|
-- Collections for holding items
|
2006-06-01 00:22:18 +00:00
|
|
|
DROP TABLE IF EXISTS collections;
|
|
|
|
CREATE TABLE collections (
|
|
|
|
collectionID INT,
|
|
|
|
collectionName TEXT,
|
|
|
|
parentCollectionID INT,
|
|
|
|
PRIMARY KEY (collectionID),
|
|
|
|
FOREIGN KEY (parentCollectionID) REFERENCES collections(collectionID)
|
2006-03-14 10:57:01 +00:00
|
|
|
);
|
2006-03-23 08:51:05 +00:00
|
|
|
|
2006-08-10 22:49:17 +00:00
|
|
|
-- Associates items with the various collections they belong to
|
2006-06-01 00:22:18 +00:00
|
|
|
DROP TABLE IF EXISTS collectionItems;
|
|
|
|
CREATE TABLE collectionItems (
|
|
|
|
collectionID INT,
|
|
|
|
itemID INT,
|
|
|
|
orderIndex INT DEFAULT 0,
|
|
|
|
PRIMARY KEY (collectionID, itemID),
|
|
|
|
FOREIGN KEY (collectionID) REFERENCES collections(collectionID),
|
|
|
|
FOREIGN KEY (itemID) REFERENCES items(itemID)
|
2006-03-23 08:51:05 +00:00
|
|
|
);
|
2006-06-01 00:22:18 +00:00
|
|
|
DROP INDEX IF EXISTS itemID;
|
|
|
|
CREATE INDEX itemID ON collectionItems(itemID);
|
2006-03-14 10:57:01 +00:00
|
|
|
|
Closes #7, Add advanced search functionality to data layer
Implemented advanced/saved search architecture -- to use, you create a new search with var search = new Scholar.Search(), add conditions to it with addCondition(condition, operator, value), and run it with search(). The standard conditions with their respective operators can be retrieved with Scholar.SearchConditions.getStandardConditions(). Others are for special search flags and can be specified as follows (condition, operator, value):
'context', null, collectionIDToSearchWithin
'recursive', 'true'|'false' (as strings!--defaults to false if not specified, though, so should probably just be removed if not wanted), null
'joinMode', 'any'|'all', null
For standard conditions, currently only 'title' and the itemData fields are supported -- more coming soon.
Localized strings created for the standard search operators
API:
search.setName(name) -- must be called before save() on new searches
search.load(savedSearchID)
search.save() -- saves search to DB and returns a savedSearchID
search.addCondition(condition, operator, value)
search.updateCondition(searchConditionID, condition, operator, value)
search.removeCondition(searchConditionID)
search.getSearchCondition(searchConditionID) -- returns a specific search condition used in the search
search.getSearchConditions() -- returns search conditions used in the search
search.search() -- runs search and returns an array of item ids for results
search.getSQL() -- will be used by Dan for search-within-search
Scholar.Searches.getAll() -- returns an array of saved searches with 'id' and 'name', in alphabetical order
Scholar.Searches.erase(savedSearchID) -- deletes a given saved search from the DB
Scholar.SearchConditions.get(condition) -- get condition data (operators, etc.)
Scholar.SearchConditions.getStandardConditions() -- retrieve conditions for use in drop-down menu (as opposed to special search flags)
Scholar.SearchConditions.hasOperator() -- used by Dan for error-checking
2006-08-08 02:04:02 +00:00
|
|
|
DROP TABLE IF EXISTS savedSearches;
|
|
|
|
CREATE TABLE savedSearches (
|
|
|
|
savedSearchID INT,
|
|
|
|
savedSearchName TEXT,
|
|
|
|
PRIMARY KEY(savedSearchID)
|
|
|
|
);
|
|
|
|
|
|
|
|
DROP TABLE IF EXISTS savedSearchConditions;
|
|
|
|
CREATE TABLE savedSearchConditions (
|
|
|
|
savedSearchID INT,
|
|
|
|
searchConditionID INT,
|
|
|
|
condition TEXT,
|
|
|
|
operator TEXT,
|
|
|
|
value TEXT,
|
2006-08-10 21:05:28 +00:00
|
|
|
required NONE,
|
Closes #7, Add advanced search functionality to data layer
Implemented advanced/saved search architecture -- to use, you create a new search with var search = new Scholar.Search(), add conditions to it with addCondition(condition, operator, value), and run it with search(). The standard conditions with their respective operators can be retrieved with Scholar.SearchConditions.getStandardConditions(). Others are for special search flags and can be specified as follows (condition, operator, value):
'context', null, collectionIDToSearchWithin
'recursive', 'true'|'false' (as strings!--defaults to false if not specified, though, so should probably just be removed if not wanted), null
'joinMode', 'any'|'all', null
For standard conditions, currently only 'title' and the itemData fields are supported -- more coming soon.
Localized strings created for the standard search operators
API:
search.setName(name) -- must be called before save() on new searches
search.load(savedSearchID)
search.save() -- saves search to DB and returns a savedSearchID
search.addCondition(condition, operator, value)
search.updateCondition(searchConditionID, condition, operator, value)
search.removeCondition(searchConditionID)
search.getSearchCondition(searchConditionID) -- returns a specific search condition used in the search
search.getSearchConditions() -- returns search conditions used in the search
search.search() -- runs search and returns an array of item ids for results
search.getSQL() -- will be used by Dan for search-within-search
Scholar.Searches.getAll() -- returns an array of saved searches with 'id' and 'name', in alphabetical order
Scholar.Searches.erase(savedSearchID) -- deletes a given saved search from the DB
Scholar.SearchConditions.get(condition) -- get condition data (operators, etc.)
Scholar.SearchConditions.getStandardConditions() -- retrieve conditions for use in drop-down menu (as opposed to special search flags)
Scholar.SearchConditions.hasOperator() -- used by Dan for error-checking
2006-08-08 02:04:02 +00:00
|
|
|
PRIMARY KEY(savedSearchID, searchConditionID),
|
|
|
|
FOREIGN KEY (savedSearchID) REFERENCES savedSearches(savedSearchID)
|
|
|
|
);
|
|
|
|
|
2006-06-29 00:56:50 +00:00
|
|
|
DROP TABLE IF EXISTS translators;
|
|
|
|
CREATE TABLE translators (
|
|
|
|
translatorID TEXT PRIMARY KEY,
|
2006-06-15 06:13:02 +00:00
|
|
|
lastUpdated DATETIME,
|
2006-09-09 00:12:09 +00:00
|
|
|
inRepository INT,
|
|
|
|
priority INT,
|
|
|
|
translatorType INT,
|
2006-06-01 06:35:33 +00:00
|
|
|
label TEXT,
|
|
|
|
creator TEXT,
|
2006-06-29 00:56:50 +00:00
|
|
|
target TEXT,
|
|
|
|
detectCode TEXT,
|
|
|
|
code TEXT
|
2006-06-01 06:35:33 +00:00
|
|
|
);
|
2006-06-29 07:58:50 +00:00
|
|
|
DROP INDEX IF EXISTS translators_type;
|
2006-09-09 00:12:09 +00:00
|
|
|
CREATE INDEX translators_type ON translators(translatorType);
|
2006-06-01 06:35:33 +00:00
|
|
|
|
2006-06-22 14:01:54 +00:00
|
|
|
DROP TABLE IF EXISTS transactionSets;
|
|
|
|
CREATE TABLE transactionSets (
|
|
|
|
transactionSetID INTEGER PRIMARY KEY,
|
|
|
|
event TEXT,
|
|
|
|
id INT
|
|
|
|
);
|
|
|
|
|
|
|
|
DROP TABLE IF EXISTS transactions;
|
|
|
|
CREATE TABLE transactions (
|
|
|
|
transactionID INTEGER PRIMARY KEY,
|
|
|
|
transactionSetID INT,
|
|
|
|
context TEXT,
|
|
|
|
action TEXT
|
|
|
|
);
|
|
|
|
DROP INDEX IF EXISTS transactions_transactionSetID;
|
|
|
|
CREATE INDEX transactions_transactionSetID ON transactions(transactionSetID);
|
|
|
|
|
|
|
|
DROP TABLE IF EXISTS transactionLog;
|
|
|
|
CREATE TABLE transactionLog (
|
|
|
|
transactionID INT,
|
|
|
|
field TEXT,
|
|
|
|
value NONE,
|
|
|
|
PRIMARY KEY (transactionID, field, value),
|
|
|
|
FOREIGN KEY (transactionID) REFERENCES transactions(transactionID)
|
|
|
|
);
|
|
|
|
|
2006-08-03 04:54:16 +00:00
|
|
|
DROP TABLE IF EXISTS csl;
|
|
|
|
CREATE TABLE csl (
|
|
|
|
cslID TEXT PRIMARY KEY,
|
|
|
|
updated DATETIME,
|
|
|
|
title TEXT,
|
|
|
|
csl TEXT
|
|
|
|
);
|
|
|
|
|
2006-06-22 14:01:54 +00:00
|
|
|
|
2006-08-30 16:02:21 +00:00
|
|
|
INSERT INTO "fieldFormats" VALUES(1, '.*', 0);
|
|
|
|
INSERT INTO "fieldFormats" VALUES(2, '[0-9]*', 1);
|
|
|
|
INSERT INTO "fieldFormats" VALUES(3, '[0-9]{4}', 1);
|
|
|
|
|
Fixes #29, independent notes
- Added 'note' item type
- Updated API to support independent note creation
Notes are, more or less, just regular items, with an item type of 1. They're created through Scholar.Notes.add(text, sourceItemID), which returns the itemID of the new note. sourceItemID is optional--if left out, an independent note will be created. (There's currently nothing stopping you from doing getNewItemByType(1) yourself, but the note would be contentless and broken, so you shouldn't do that.) Note data could've been stuffed into itemData, but I kept it separate in itemNotes to keep metadata searching faster and to keep things cleaner.
Methods calls that can be called on all items:
isNote() (same as testing for itemTypeID 1)
Method calls that can be called on source items only:
numNotes()
getNotes() (array of note itemIDs for a source)
Method calls that can be called on note items only:
updateNote(text)
setNoteSource(sourceItemID) (for changing source--use empty or false to make independent, which is currently what happens when you delete a note--will get option with #91)
getNote() (note content)
getNoteSource() (sourceItemID of a note)
Calling the above methods on the wrong item types will throw an error.
*** This will break note creation/display until David updates interface code. ***
2006-06-27 15:14:07 +00:00
|
|
|
INSERT INTO itemTypes VALUES (1,'note');
|
|
|
|
INSERT INTO itemTypes VALUES (2,'book');
|
|
|
|
INSERT INTO itemTypes VALUES (3,'bookSection');
|
|
|
|
INSERT INTO itemTypes VALUES (4,'journalArticle');
|
|
|
|
INSERT INTO itemTypes VALUES (5,'magazineArticle');
|
|
|
|
INSERT INTO itemTypes VALUES (6,'newspaperArticle');
|
|
|
|
INSERT INTO itemTypes VALUES (7,'thesis');
|
|
|
|
INSERT INTO itemTypes VALUES (8,'letter');
|
|
|
|
INSERT INTO itemTypes VALUES (9,'manuscript');
|
|
|
|
INSERT INTO itemTypes VALUES (10,'interview');
|
|
|
|
INSERT INTO itemTypes VALUES (11,'film');
|
|
|
|
INSERT INTO itemTypes VALUES (12,'artwork');
|
|
|
|
INSERT INTO itemTypes VALUES (13,'website');
|
2006-08-12 00:18:20 +00:00
|
|
|
INSERT INTO itemTypes VALUES (14,'attachment');
|
2006-08-30 16:02:21 +00:00
|
|
|
|
2006-08-24 20:33:29 +00:00
|
|
|
INSERT INTO fields VALUES (1,'url',NULL);
|
2006-06-01 00:22:18 +00:00
|
|
|
INSERT INTO fields VALUES (2,'rights',NULL);
|
2006-08-13 20:31:11 +00:00
|
|
|
INSERT INTO fields VALUES (3,'series',NULL);
|
2006-06-16 07:56:24 +00:00
|
|
|
INSERT INTO fields VALUES (4,'volume',NULL);
|
2006-08-06 16:10:28 +00:00
|
|
|
INSERT INTO fields VALUES (5,'issue',NULL);
|
2006-06-16 07:56:24 +00:00
|
|
|
INSERT INTO fields VALUES (6,'edition',NULL);
|
|
|
|
INSERT INTO fields VALUES (7,'place',NULL);
|
|
|
|
INSERT INTO fields VALUES (8,'publisher',NULL);
|
2006-07-31 04:31:44 +00:00
|
|
|
INSERT INTO fields VALUES (10,'pages',NULL);
|
2006-06-16 07:56:24 +00:00
|
|
|
INSERT INTO fields VALUES (11,'ISBN',NULL);
|
2006-08-06 16:10:28 +00:00
|
|
|
INSERT INTO fields VALUES (12,'publicationTitle',NULL);
|
2006-06-16 07:56:24 +00:00
|
|
|
INSERT INTO fields VALUES (13,'ISSN',NULL);
|
2006-06-24 08:28:37 +00:00
|
|
|
INSERT INTO fields VALUES (14,'date',NULL);
|
|
|
|
INSERT INTO fields VALUES (15,'section',NULL);
|
|
|
|
INSERT INTO fields VALUES (17,'accessionNumber',NULL);
|
2006-06-25 18:10:27 +00:00
|
|
|
INSERT INTO fields VALUES (18,'callNumber',NULL);
|
2006-06-24 08:28:37 +00:00
|
|
|
INSERT INTO fields VALUES (19,'archiveLocation',NULL);
|
|
|
|
INSERT INTO fields VALUES (20,'medium',NULL);
|
|
|
|
INSERT INTO fields VALUES (21,'distributor',NULL);
|
2006-06-25 18:10:27 +00:00
|
|
|
INSERT INTO fields VALUES (22,'extra',NULL);
|
2006-06-24 08:28:37 +00:00
|
|
|
INSERT INTO fields VALUES (24,'type',NULL);
|
2006-07-31 04:31:44 +00:00
|
|
|
INSERT INTO fields VALUES (25,'journalAbbreviation',NULL);
|
2006-08-06 16:10:28 +00:00
|
|
|
INSERT INTO fields VALUES (26,'DOI',NULL);
|
|
|
|
INSERT INTO fields VALUES (27,'accessDate',NULL);
|
2006-08-13 20:31:11 +00:00
|
|
|
INSERT INTO fields VALUES (28,'seriesTitle',NULL);
|
|
|
|
INSERT INTO fields VALUES (29,'seriesText',NULL);
|
|
|
|
INSERT INTO fields VALUES (30,'seriesNumber',NULL);
|
2006-08-30 16:02:21 +00:00
|
|
|
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 3, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 30, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 4, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 5, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 6, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 7, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 8, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 14, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 10, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 11, NULL, 10);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 18, NULL, 11);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 17, NULL, 12);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 2, NULL, 13);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 1, NULL, 14);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 27, NULL, 15);
|
|
|
|
INSERT INTO itemTypeFields VALUES (2, 22, NULL, 16);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 12, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 3, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 30, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 4, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 5, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 6, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 7, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 8, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 14, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 10, NULL, 10);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 11, NULL, 11);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 18, NULL, 12);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 17, NULL, 13);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 2, NULL, 14);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 1, NULL, 15);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 27, NULL, 16);
|
|
|
|
INSERT INTO itemTypeFields VALUES (3, 22, NULL, 17);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 12, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 4, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 5, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 10, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 14, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 3, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 28, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 29, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 25, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 26, NULL, 10);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 13, NULL, 11);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 18, NULL, 12);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 17, NULL, 13);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 2, NULL, 14);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 1, NULL, 15);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 27, NULL, 16);
|
|
|
|
INSERT INTO itemTypeFields VALUES (4, 22, NULL, 17);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 12, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 14, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 10, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 13, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 18, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 17, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 2, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 1, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 27, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (5, 22, NULL, 10);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 12, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 6, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 14, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 15, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 10, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 13, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 18, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 17, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 2, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 1, NULL, 10);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 27, NULL, 11);
|
|
|
|
INSERT INTO itemTypeFields VALUES (6, 22, NULL, 12);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 8, NULL, 1);
|
2006-08-31 06:02:30 +00:00
|
|
|
INSERT INTO itemTypeFields VALUES (7, 24, NULL, 2);
|
2006-08-30 16:02:21 +00:00
|
|
|
INSERT INTO itemTypeFields VALUES (7, 14, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 10, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 18, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 17, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 2, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 1, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 27, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (7, 22, NULL, 10);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 24, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 14, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 19, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 18, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 17, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 2, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 1, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 27, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (8, 22, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 24, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 7, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 14, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 19, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 18, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 17, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 2, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 1, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 27, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (9, 22, NULL, 10);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 14, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 20, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 19, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 18, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 17, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 2, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 1, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 27, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (10, 22, NULL, 9);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 21, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 14, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 18, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 17, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 2, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 1, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 27, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (11, 22, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 24, NULL, 1);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 14, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 18, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 17, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 2, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 1, NULL, 6);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 27, NULL, 7);
|
|
|
|
INSERT INTO itemTypeFields VALUES (12, 22, NULL, 8);
|
|
|
|
INSERT INTO itemTypeFields VALUES (13, 14, NULL, 2);
|
|
|
|
INSERT INTO itemTypeFields VALUES (13, 1, NULL, 3);
|
|
|
|
INSERT INTO itemTypeFields VALUES (13, 27, NULL, 4);
|
|
|
|
INSERT INTO itemTypeFields VALUES (13, 2, NULL, 5);
|
|
|
|
INSERT INTO itemTypeFields VALUES (13, 22, NULL, 6);
|
2006-06-24 08:28:37 +00:00
|
|
|
|
2006-08-08 08:23:23 +00:00
|
|
|
INSERT INTO "fileTypes" VALUES(1, 'webpage');
|
|
|
|
INSERT INTO "fileTypes" VALUES(2, 'image');
|
|
|
|
INSERT INTO "fileTypes" VALUES(3, 'pdf');
|
|
|
|
INSERT INTO "fileTypes" VALUES(4, 'audio');
|
|
|
|
INSERT INTO "fileTypes" VALUES(5, 'video');
|
|
|
|
INSERT INTO "fileTypes" VALUES(6, 'document');
|
|
|
|
INSERT INTO "fileTypes" VALUES(7, 'presentation');
|
|
|
|
|
|
|
|
-- webpage
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(1, 'text/html');
|
|
|
|
-- image
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(2, 'image/');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(2, 'application/vnd.oasis.opendocument.graphics');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(2, 'application/vnd.oasis.opendocument.image');
|
|
|
|
-- pdf
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(3, 'application/pdf');
|
|
|
|
-- audio
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(4, 'audio/');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(4, 'x-pn-realaudio');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(4, 'application/ogg');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(4, 'application/x-killustrator');
|
|
|
|
-- video
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(5, 'video/');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(5, 'application/x-shockwave-flash');
|
|
|
|
-- document
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'text/plain');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/rtf');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/msword');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'text/xml');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/postscript');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/wordperfect5.1');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/x-latex');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/x-tex');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/x-kword');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/x-kspread');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/x-kchart');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/vnd.oasis.opendocument.chart');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/vnd.oasis.opendocument.database');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/vnd.oasis.opendocument.formula');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/vnd.oasis.opendocument.spreadsheet');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(6, 'application/vnd.oasis.opendocument.text');
|
|
|
|
-- presentation
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(7, 'application/powerpoint');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(7, 'application/vnd.oasis.opendocument.presentation');
|
|
|
|
INSERT INTO "fileTypeMIMETypes" VALUES(7, 'application/x-kpresenter');
|
|
|
|
|
Addresses #17, add filesystem/ability to store files
Not finished, but enough to give David something to work with
No BLOBs -- just linking/importing of files and loaded documents
New Scholar.Item methods:
incrementFileCount() (used internally)
decrementFileCount() (used internally)
isFile()
numFiles()
getFile() -- returns nsILocalFile or false if associated file doesn't exist (note: always returns false for items with LINK_MODE_LINKED_URL, since they have no files -- use getFileURL() instead)
getFileURL() -- returns URL string
getFileLinkMode() -- compare to Scholar.Files.LINK_MODE_* constants: LINKED_FILE, IMPORTED_FILE, LINKED_URL, IMPORTED_URL
getFileMimeType() -- mime type of file (e.g. text/plain)
getFileCharset() -- charsetID of file
getFiles() -- array of file itemIDs this file is a source for
New Scholar.Files methods:
importFromFile(nsIFile file [, int sourceItemID])
linkFromFile(nsIFile file [, int sourceItemID])
importFromDocument(nsIDOMDocument document [, int sourceItemID])
linkFromDocument(nsIDOMDocument document [, int sourceItemID])
New class Scholar.FileTypes -- partially implemented, not yet used
New class Scholar.CharacterSets -- same as other *Types classes:
getID(idOrName)
getName(idOrName)
getTypes() (aliased to getAll(), which I'll probably change the others to as well)
Charsets table with all official character sets (copied from Mozilla source)
Renamed Item.setNoteSource() to setSource() and Item.getNoteSource() to getSource() and adjusted to handle both notes and files
2006-07-27 09:16:02 +00:00
|
|
|
INSERT INTO "charsets" VALUES(1, 'utf-8');
|
|
|
|
INSERT INTO "charsets" VALUES(2, 'ascii');
|
|
|
|
INSERT INTO "charsets" VALUES(3, 'windows-1250');
|
|
|
|
INSERT INTO "charsets" VALUES(4, 'windows-1251');
|
|
|
|
INSERT INTO "charsets" VALUES(5, 'windows-1252');
|
|
|
|
INSERT INTO "charsets" VALUES(6, 'windows-1253');
|
|
|
|
INSERT INTO "charsets" VALUES(7, 'windows-1254');
|
|
|
|
INSERT INTO "charsets" VALUES(8, 'windows-1257');
|
|
|
|
INSERT INTO "charsets" VALUES(9, 'us');
|
|
|
|
INSERT INTO "charsets" VALUES(10, 'us-ascii');
|
|
|
|
INSERT INTO "charsets" VALUES(11, 'utf-7');
|
|
|
|
INSERT INTO "charsets" VALUES(12, 'iso8859-1');
|
|
|
|
INSERT INTO "charsets" VALUES(13, 'iso8859-15');
|
|
|
|
INSERT INTO "charsets" VALUES(14, 'iso_646.irv:1991');
|
|
|
|
INSERT INTO "charsets" VALUES(15, 'iso_8859-1');
|
|
|
|
INSERT INTO "charsets" VALUES(16, 'iso_8859-1:1987');
|
|
|
|
INSERT INTO "charsets" VALUES(17, 'iso_8859-2');
|
|
|
|
INSERT INTO "charsets" VALUES(18, 'iso_8859-2:1987');
|
|
|
|
INSERT INTO "charsets" VALUES(19, 'iso_8859-4');
|
|
|
|
INSERT INTO "charsets" VALUES(20, 'iso_8859-4:1988');
|
|
|
|
INSERT INTO "charsets" VALUES(21, 'iso_8859-5');
|
|
|
|
INSERT INTO "charsets" VALUES(22, 'iso_8859-5:1988');
|
|
|
|
INSERT INTO "charsets" VALUES(23, 'iso_8859-7');
|
|
|
|
INSERT INTO "charsets" VALUES(24, 'iso_8859-7:1987');
|
|
|
|
INSERT INTO "charsets" VALUES(25, 'iso-8859-1');
|
|
|
|
INSERT INTO "charsets" VALUES(26, 'iso-8859-1-windows-3.0-latin-1');
|
|
|
|
INSERT INTO "charsets" VALUES(27, 'iso-8859-1-windows-3.1-latin-1');
|
|
|
|
INSERT INTO "charsets" VALUES(28, 'iso-8859-15');
|
|
|
|
INSERT INTO "charsets" VALUES(29, 'iso-8859-2');
|
|
|
|
INSERT INTO "charsets" VALUES(30, 'iso-8859-2-windows-latin-2');
|
|
|
|
INSERT INTO "charsets" VALUES(31, 'iso-8859-3');
|
|
|
|
INSERT INTO "charsets" VALUES(32, 'iso-8859-4');
|
|
|
|
INSERT INTO "charsets" VALUES(33, 'iso-8859-5');
|
|
|
|
INSERT INTO "charsets" VALUES(34, 'iso-8859-5-windows-latin-5');
|
|
|
|
INSERT INTO "charsets" VALUES(35, 'iso-8859-6');
|
|
|
|
INSERT INTO "charsets" VALUES(36, 'iso-8859-7');
|
|
|
|
INSERT INTO "charsets" VALUES(37, 'iso-8859-8');
|
|
|
|
INSERT INTO "charsets" VALUES(38, 'iso-8859-9');
|
|
|
|
INSERT INTO "charsets" VALUES(39, 'l1');
|
|
|
|
INSERT INTO "charsets" VALUES(40, 'l2');
|
|
|
|
INSERT INTO "charsets" VALUES(41, 'l4');
|
|
|
|
INSERT INTO "charsets" VALUES(42, 'latin1');
|
|
|
|
INSERT INTO "charsets" VALUES(43, 'latin2');
|
|
|
|
INSERT INTO "charsets" VALUES(44, 'latin4');
|
|
|
|
INSERT INTO "charsets" VALUES(45, 'x-mac-ce');
|
|
|
|
INSERT INTO "charsets" VALUES(46, 'x-mac-cyrillic');
|
|
|
|
INSERT INTO "charsets" VALUES(47, 'x-mac-greek');
|
|
|
|
INSERT INTO "charsets" VALUES(48, 'x-mac-roman');
|
|
|
|
INSERT INTO "charsets" VALUES(49, 'x-mac-turkish');
|
|
|
|
INSERT INTO "charsets" VALUES(50, 'adobe-symbol-encoding');
|
|
|
|
INSERT INTO "charsets" VALUES(51, 'ansi_x3.4-1968');
|
|
|
|
INSERT INTO "charsets" VALUES(52, 'ansi_x3.4-1986');
|
|
|
|
INSERT INTO "charsets" VALUES(53, 'big5');
|
|
|
|
INSERT INTO "charsets" VALUES(54, 'chinese');
|
|
|
|
INSERT INTO "charsets" VALUES(55, 'cn-big5');
|
|
|
|
INSERT INTO "charsets" VALUES(56, 'cn-gb');
|
|
|
|
INSERT INTO "charsets" VALUES(57, 'cn-gb-isoir165');
|
|
|
|
INSERT INTO "charsets" VALUES(58, 'cp367');
|
|
|
|
INSERT INTO "charsets" VALUES(59, 'cp819');
|
|
|
|
INSERT INTO "charsets" VALUES(60, 'cp850');
|
|
|
|
INSERT INTO "charsets" VALUES(61, 'cp852');
|
|
|
|
INSERT INTO "charsets" VALUES(62, 'cp855');
|
|
|
|
INSERT INTO "charsets" VALUES(63, 'cp857');
|
|
|
|
INSERT INTO "charsets" VALUES(64, 'cp862');
|
|
|
|
INSERT INTO "charsets" VALUES(65, 'cp864');
|
|
|
|
INSERT INTO "charsets" VALUES(66, 'cp866');
|
|
|
|
INSERT INTO "charsets" VALUES(67, 'csascii');
|
|
|
|
INSERT INTO "charsets" VALUES(68, 'csbig5');
|
|
|
|
INSERT INTO "charsets" VALUES(69, 'cseuckr');
|
|
|
|
INSERT INTO "charsets" VALUES(70, 'cseucpkdfmtjapanese');
|
|
|
|
INSERT INTO "charsets" VALUES(71, 'csgb2312');
|
|
|
|
INSERT INTO "charsets" VALUES(72, 'cshalfwidthkatakana');
|
|
|
|
INSERT INTO "charsets" VALUES(73, 'cshppsmath');
|
|
|
|
INSERT INTO "charsets" VALUES(74, 'csiso103t618bit');
|
|
|
|
INSERT INTO "charsets" VALUES(75, 'csiso159jisx02121990');
|
|
|
|
INSERT INTO "charsets" VALUES(76, 'csiso2022jp');
|
|
|
|
INSERT INTO "charsets" VALUES(77, 'csiso2022jp2');
|
|
|
|
INSERT INTO "charsets" VALUES(78, 'csiso2022kr');
|
|
|
|
INSERT INTO "charsets" VALUES(79, 'csiso58gb231280');
|
|
|
|
INSERT INTO "charsets" VALUES(80, 'csisolatin4');
|
|
|
|
INSERT INTO "charsets" VALUES(81, 'csisolatincyrillic');
|
|
|
|
INSERT INTO "charsets" VALUES(82, 'csisolatingreek');
|
|
|
|
INSERT INTO "charsets" VALUES(83, 'cskoi8r');
|
|
|
|
INSERT INTO "charsets" VALUES(84, 'csksc56011987');
|
|
|
|
INSERT INTO "charsets" VALUES(85, 'csshiftjis');
|
|
|
|
INSERT INTO "charsets" VALUES(86, 'csunicode11');
|
|
|
|
INSERT INTO "charsets" VALUES(87, 'csunicode11utf7');
|
|
|
|
INSERT INTO "charsets" VALUES(88, 'csunicodeascii');
|
|
|
|
INSERT INTO "charsets" VALUES(89, 'csunicodelatin1');
|
|
|
|
INSERT INTO "charsets" VALUES(90, 'cswindows31latin5');
|
|
|
|
INSERT INTO "charsets" VALUES(91, 'cyrillic');
|
|
|
|
INSERT INTO "charsets" VALUES(92, 'ecma-118');
|
|
|
|
INSERT INTO "charsets" VALUES(93, 'elot_928');
|
|
|
|
INSERT INTO "charsets" VALUES(94, 'euc-jp');
|
|
|
|
INSERT INTO "charsets" VALUES(95, 'euc-kr');
|
|
|
|
INSERT INTO "charsets" VALUES(96, 'extended_unix_code_packed_format_for_japanese');
|
|
|
|
INSERT INTO "charsets" VALUES(97, 'gb2312');
|
|
|
|
INSERT INTO "charsets" VALUES(98, 'gb_2312-80');
|
|
|
|
INSERT INTO "charsets" VALUES(99, 'greek');
|
|
|
|
INSERT INTO "charsets" VALUES(100, 'greek8');
|
|
|
|
INSERT INTO "charsets" VALUES(101, 'hz-gb-2312');
|
|
|
|
INSERT INTO "charsets" VALUES(102, 'ibm367');
|
|
|
|
INSERT INTO "charsets" VALUES(103, 'ibm819');
|
|
|
|
INSERT INTO "charsets" VALUES(104, 'ibm850');
|
|
|
|
INSERT INTO "charsets" VALUES(105, 'ibm852');
|
|
|
|
INSERT INTO "charsets" VALUES(106, 'ibm855');
|
|
|
|
INSERT INTO "charsets" VALUES(107, 'ibm857');
|
|
|
|
INSERT INTO "charsets" VALUES(108, 'ibm862');
|
|
|
|
INSERT INTO "charsets" VALUES(109, 'ibm864');
|
|
|
|
INSERT INTO "charsets" VALUES(110, 'ibm866');
|
|
|
|
INSERT INTO "charsets" VALUES(111, 'iso-10646');
|
|
|
|
INSERT INTO "charsets" VALUES(112, 'iso-10646-j-1');
|
|
|
|
INSERT INTO "charsets" VALUES(113, 'iso-10646-ucs-2');
|
|
|
|
INSERT INTO "charsets" VALUES(114, 'iso-10646-ucs-4');
|
|
|
|
INSERT INTO "charsets" VALUES(115, 'iso-10646-ucs-basic');
|
|
|
|
INSERT INTO "charsets" VALUES(116, 'iso-10646-unicode-latin1');
|
|
|
|
INSERT INTO "charsets" VALUES(117, 'iso-2022-jp');
|
|
|
|
INSERT INTO "charsets" VALUES(118, 'iso-2022-jp-2');
|
|
|
|
INSERT INTO "charsets" VALUES(119, 'iso-2022-kr');
|
|
|
|
INSERT INTO "charsets" VALUES(120, 'iso-ir-100');
|
|
|
|
INSERT INTO "charsets" VALUES(121, 'iso-ir-101');
|
|
|
|
INSERT INTO "charsets" VALUES(122, 'iso-ir-103');
|
|
|
|
INSERT INTO "charsets" VALUES(123, 'iso-ir-110');
|
|
|
|
INSERT INTO "charsets" VALUES(124, 'iso-ir-126');
|
|
|
|
INSERT INTO "charsets" VALUES(125, 'iso-ir-144');
|
|
|
|
INSERT INTO "charsets" VALUES(126, 'iso-ir-149');
|
|
|
|
INSERT INTO "charsets" VALUES(127, 'iso-ir-159');
|
|
|
|
INSERT INTO "charsets" VALUES(128, 'iso-ir-58');
|
|
|
|
INSERT INTO "charsets" VALUES(129, 'iso-ir-6');
|
|
|
|
INSERT INTO "charsets" VALUES(130, 'iso646-us');
|
|
|
|
INSERT INTO "charsets" VALUES(131, 'jis_x0201');
|
|
|
|
INSERT INTO "charsets" VALUES(132, 'jis_x0208-1983');
|
|
|
|
INSERT INTO "charsets" VALUES(133, 'jis_x0212-1990');
|
|
|
|
INSERT INTO "charsets" VALUES(134, 'koi8-r');
|
|
|
|
INSERT INTO "charsets" VALUES(135, 'korean');
|
|
|
|
INSERT INTO "charsets" VALUES(136, 'ks_c_5601');
|
|
|
|
INSERT INTO "charsets" VALUES(137, 'ks_c_5601-1987');
|
|
|
|
INSERT INTO "charsets" VALUES(138, 'ks_c_5601-1989');
|
|
|
|
INSERT INTO "charsets" VALUES(139, 'ksc5601');
|
|
|
|
INSERT INTO "charsets" VALUES(140, 'ksc_5601');
|
|
|
|
INSERT INTO "charsets" VALUES(141, 'ms_kanji');
|
|
|
|
INSERT INTO "charsets" VALUES(142, 'shift_jis');
|
|
|
|
INSERT INTO "charsets" VALUES(143, 't.61');
|
|
|
|
INSERT INTO "charsets" VALUES(144, 't.61-8bit');
|
|
|
|
INSERT INTO "charsets" VALUES(145, 'unicode-1-1-utf-7');
|
|
|
|
INSERT INTO "charsets" VALUES(146, 'unicode-1-1-utf-8');
|
|
|
|
INSERT INTO "charsets" VALUES(147, 'unicode-2-0-utf-7');
|
|
|
|
INSERT INTO "charsets" VALUES(148, 'windows-31j');
|
|
|
|
INSERT INTO "charsets" VALUES(149, 'x-cns11643-1');
|
|
|
|
INSERT INTO "charsets" VALUES(150, 'x-cns11643-1110');
|
|
|
|
INSERT INTO "charsets" VALUES(151, 'x-cns11643-2');
|
|
|
|
INSERT INTO "charsets" VALUES(152, 'x-cp1250');
|
|
|
|
INSERT INTO "charsets" VALUES(153, 'x-cp1251');
|
|
|
|
INSERT INTO "charsets" VALUES(154, 'x-cp1253');
|
|
|
|
INSERT INTO "charsets" VALUES(155, 'x-dectech');
|
|
|
|
INSERT INTO "charsets" VALUES(156, 'x-dingbats');
|
|
|
|
INSERT INTO "charsets" VALUES(157, 'x-euc-jp');
|
|
|
|
INSERT INTO "charsets" VALUES(158, 'x-euc-tw');
|
|
|
|
INSERT INTO "charsets" VALUES(159, 'x-gb2312-11');
|
|
|
|
INSERT INTO "charsets" VALUES(160, 'x-imap4-modified-utf7');
|
|
|
|
INSERT INTO "charsets" VALUES(161, 'x-jisx0208-11');
|
|
|
|
INSERT INTO "charsets" VALUES(162, 'x-ksc5601-11');
|
|
|
|
INSERT INTO "charsets" VALUES(163, 'x-sjis');
|
|
|
|
INSERT INTO "charsets" VALUES(164, 'x-tis620');
|
|
|
|
INSERT INTO "charsets" VALUES(165, 'x-unicode-2-0-utf-7');
|
|
|
|
INSERT INTO "charsets" VALUES(166, 'x-x-big5');
|
|
|
|
INSERT INTO "charsets" VALUES(167, 'x0201');
|
|
|
|
INSERT INTO "charsets" VALUES(168, 'x0212');
|
|
|
|
|
2006-05-20 15:18:36 +00:00
|
|
|
INSERT INTO "creatorTypes" VALUES(1, "author");
|
|
|
|
INSERT INTO "creatorTypes" VALUES(2, "contributor");
|
|
|
|
INSERT INTO "creatorTypes" VALUES(3, "editor");
|
2006-07-31 04:31:44 +00:00
|
|
|
INSERT INTO "creatorTypes" VALUES(4, "translator");
|
2006-05-20 15:18:36 +00:00
|
|
|
|
2006-08-31 22:21:30 +00:00
|
|
|
INSERT INTO "items" VALUES(1233, 14, 'Zotero - Quick Start Guide', '2006-08-31 20:00:00', '2006-08-31 20:00:00');
|
|
|
|
INSERT INTO "itemAttachments" VALUES(1233, NULL, 3, 'text/html', 25, 'http://www.zotero.org/docs/quick_start_guide.php', NULL);
|