1089 lines
37 KiB
Python
1089 lines
37 KiB
Python
# Gramps - a GTK+/GNOME based genealogy program
|
|
#
|
|
# Copyright (C) 2008 Douglas S. Blank <doug.blank@gmail.com>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
# $Id$
|
|
#
|
|
|
|
"Export to SQLite Database"
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# Standard Python Modules
|
|
#
|
|
#------------------------------------------------------------------------
|
|
from gettext import gettext as _
|
|
from gettext import ngettext
|
|
import sqlite3 as sqlite
|
|
import time
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# Set up logging
|
|
#
|
|
#------------------------------------------------------------------------
|
|
import logging
|
|
log = logging.getLogger(".ExportSql")
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# GRAMPS modules
|
|
#
|
|
#------------------------------------------------------------------------
|
|
from gen.plug import PluginManager, ExportPlugin
|
|
import ExportOptions
|
|
from Utils import create_id
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Export functions
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def lookup(index, event_ref_list):
|
|
"""
|
|
Get the unserialized event_ref in an list of them and return it.
|
|
"""
|
|
if index < 0:
|
|
return None
|
|
else:
|
|
count = 0
|
|
for event_ref in event_ref_list:
|
|
(private, note_list, attribute_list, ref, role) = event_ref
|
|
if index == count:
|
|
return ref
|
|
count += 1
|
|
return None
|
|
|
|
def makeDB(db):
|
|
db.query("""drop table note;""")
|
|
db.query("""drop table person;""")
|
|
db.query("""drop table event;""")
|
|
db.query("""drop table family;""")
|
|
db.query("""drop table repository;""")
|
|
db.query("""drop table repository_ref;""")
|
|
db.query("""drop table date;""")
|
|
db.query("""drop table place;""")
|
|
db.query("""drop table source;""")
|
|
db.query("""drop table media;""")
|
|
db.query("""drop table name;""")
|
|
db.query("""drop table link;""")
|
|
db.query("""drop table markup;""")
|
|
db.query("""drop table event_ref;""")
|
|
db.query("""drop table source_ref;""")
|
|
db.query("""drop table child_ref;""")
|
|
db.query("""drop table person_ref;""")
|
|
db.query("""drop table lds;""")
|
|
db.query("""drop table media_ref;""")
|
|
db.query("""drop table address;""")
|
|
db.query("""drop table location;""")
|
|
db.query("""drop table attribute;""")
|
|
db.query("""drop table url;""")
|
|
db.query("""drop table datamap;""")
|
|
|
|
db.query("""CREATE TABLE note (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
text TEXT,
|
|
format INTEGER,
|
|
note_type1 INTEGER,
|
|
note_type2 TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE name (
|
|
handle CHARACTER(25),
|
|
primary_name BOOLEAN,
|
|
private BOOLEAN,
|
|
first_name TEXT,
|
|
surname TEXT,
|
|
suffix TEXT,
|
|
title TEXT,
|
|
name_type0 INTEGER,
|
|
name_type1 TEXT,
|
|
prefix TEXT,
|
|
patronymic TEXT,
|
|
group_as TEXT,
|
|
sort_as INTEGER,
|
|
display_as INTEGER,
|
|
call TEXT);""")
|
|
|
|
db.query("""CREATE TABLE date (
|
|
handle CHARACTER(25),
|
|
calendar INTEGER,
|
|
modifier INTEGER,
|
|
quality INTEGER,
|
|
day1 INTEGER,
|
|
month1 INTEGER,
|
|
year1 INTEGER,
|
|
slash1 BOOLEAN,
|
|
day2 INTEGER,
|
|
month2 INTEGER,
|
|
year2 INTEGER,
|
|
slash2 BOOLEAN,
|
|
text TEXT,
|
|
sortval INTEGER,
|
|
newyear INTEGER);""")
|
|
|
|
db.query("""CREATE TABLE person (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
gender INTEGER,
|
|
death_ref_handle TEXT,
|
|
birth_ref_handle TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE family (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
father_handle CHARACTER(25),
|
|
mother_handle CHARACTER(25),
|
|
the_type0 INTEGER,
|
|
the_type1 TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE place (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
title TEXT,
|
|
main_location CHARACTER(25),
|
|
long TEXT,
|
|
lat TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE event (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
the_type0 INTEGER,
|
|
the_type1 TEXT,
|
|
description TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE source (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
title TEXT,
|
|
author TEXT,
|
|
pubinfo TEXT,
|
|
abbrev TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE media (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
path TEXT,
|
|
mime TEXT,
|
|
desc TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE repository_ref (
|
|
handle CHARACTER(25),
|
|
ref CHARACTER(25),
|
|
call_number TEXT,
|
|
source_media_type0 INTEGER,
|
|
source_media_type1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE repository (
|
|
handle CHARACTER(25),
|
|
gid CHARACTER(25),
|
|
the_type0 INTEGER,
|
|
the_type1 TEXT,
|
|
name TEXT,
|
|
change INTEGER,
|
|
marker0 INTEGER,
|
|
marker1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
# One link to link them all
|
|
db.query("""CREATE TABLE link (
|
|
from_type CHARACTER(25),
|
|
from_handle CHARACTER(25),
|
|
to_type CHARACTER(25),
|
|
to_handle CHARACTER(25));""")
|
|
|
|
db.query("""CREATE TABLE markup (
|
|
handle CHARACTER(25),
|
|
markup0 INTEGER,
|
|
markup1 TEXT,
|
|
value TEXT,
|
|
start_stop_list TEXT);""")
|
|
|
|
db.query("""CREATE TABLE event_ref (
|
|
handle CHARACTER(25),
|
|
ref CHARACTER(25),
|
|
role0 INTEGER,
|
|
role1 TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE person_ref (
|
|
handle CHARACTER(25),
|
|
description TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE source_ref (
|
|
handle CHARACTER(25),
|
|
ref CHARACTER(25),
|
|
confidence INTEGER,
|
|
page CHARACTER(25),
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE child_ref (
|
|
handle CHARACTER(25),
|
|
ref CHARACTER(25),
|
|
frel0 INTEGER,
|
|
frel1 CHARACTER(25),
|
|
mrel0 INTEGER,
|
|
mrel1 CHARACTER(25),
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE lds (
|
|
handle CHARACTER(25),
|
|
type INTEGER,
|
|
place CHARACTER(25),
|
|
famc CHARACTER(25),
|
|
temple TEXT,
|
|
status INTEGER,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE media_ref (
|
|
handle CHARACTER(25),
|
|
ref CHARACTER(25),
|
|
role0 INTEGER,
|
|
role1 INTEGER,
|
|
role2 INTEGER,
|
|
role3 INTEGER,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE address (
|
|
handle CHARACTER(25),
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE location (
|
|
handle CHARACTER(25),
|
|
street TEXT,
|
|
city TEXT,
|
|
county TEXT,
|
|
state TEXT,
|
|
country TEXT,
|
|
postal TEXT,
|
|
phone TEXT,
|
|
parish TEXT);""")
|
|
|
|
db.query("""CREATE TABLE attribute (
|
|
handle CHARACTER(25),
|
|
the_type0 INTEGER,
|
|
the_type1 TEXT,
|
|
value TEXT,
|
|
private BOOLEAN);""")
|
|
|
|
db.query("""CREATE TABLE url (
|
|
handle CHARACTER(25),
|
|
path TEXT,
|
|
desc TXT,
|
|
type0 INTEGER,
|
|
type1 TEXT,
|
|
private BOOLEAN);
|
|
""")
|
|
|
|
db.query("""CREATE TABLE datamap (
|
|
handle CHARACTER(25),
|
|
key_field TEXT,
|
|
value_field TXT);
|
|
""")
|
|
|
|
class Database(object):
|
|
"""
|
|
The db connection.
|
|
"""
|
|
def __init__(self, database):
|
|
self.database = database
|
|
self.db = sqlite.connect(self.database)
|
|
self.cursor = self.db.cursor()
|
|
|
|
def query(self, q, *args):
|
|
if q.strip().upper().startswith("DROP"):
|
|
try:
|
|
self.cursor.execute(q, args)
|
|
self.db.commit()
|
|
except:
|
|
"WARN: no such table to drop: '%s'" % q
|
|
else:
|
|
try:
|
|
self.cursor.execute(q, args)
|
|
self.db.commit()
|
|
except:
|
|
print "ERROR: query :", q
|
|
print "ERROR: values:", args
|
|
raise
|
|
return self.cursor.fetchall()
|
|
|
|
def close(self):
|
|
""" Closes and writes out tables """
|
|
self.cursor.close()
|
|
self.db.close()
|
|
|
|
def export_location_list(db, from_type, from_handle, locations):
|
|
for location in locations:
|
|
export_location(db, from_type, from_handle, location)
|
|
|
|
def export_url_list(db, from_type, from_handle, urls):
|
|
for url in urls:
|
|
# (False, u'http://www.gramps-project.org/', u'loleach', (0, u'kaabgo'))
|
|
(private, path, desc, type) = url
|
|
handle = create_id()
|
|
db.query("""insert INTO url (
|
|
handle,
|
|
path,
|
|
desc,
|
|
type0,
|
|
type1,
|
|
private) VALUES (?, ?, ?, ?, ?, ?);
|
|
""",
|
|
handle,
|
|
path,
|
|
desc,
|
|
type[0],
|
|
type[1],
|
|
private)
|
|
# finally, link this to parent
|
|
export_link(db, from_type, from_handle, "url", handle)
|
|
|
|
def export_person_ref_list(db, from_type, from_handle, person_ref_list):
|
|
for person_ref in person_ref_list:
|
|
(private,
|
|
source_list,
|
|
note_list,
|
|
handle,
|
|
desc) = person_ref
|
|
db.query("""INSERT INTO person_ref (
|
|
handle,
|
|
description,
|
|
private) VALUES (?, ?, ?);""",
|
|
handle,
|
|
desc,
|
|
private
|
|
)
|
|
export_list(db, "person_ref", handle, "note", note_list)
|
|
export_source_ref_list(db, "person_ref", handle, source_list)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "person_ref", handle)
|
|
|
|
def export_lds(db, from_type, from_handle, data):
|
|
(lsource_list, lnote_list, date, type, place,
|
|
famc, temple, status, private) = data
|
|
lds_handle = create_id()
|
|
db.query("""INSERT into lds (handle, type, place, famc, temple, status, private)
|
|
VALUES (?,?,?,?,?,?,?);""",
|
|
lds_handle, type, place, famc, temple, status, private)
|
|
export_link(db, "lds", lds_handle, "place", place)
|
|
export_list(db, "lds", lds_handle, "note", lnote_list)
|
|
export_date(db, "lds", lds_handle, date)
|
|
export_source_ref_list(db, "lds", lds_handle, lsource_list)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "lds", lds_handle)
|
|
|
|
def export_source_ref(db, from_type, from_handle, source):
|
|
(date, private, note_list, confidence, ref, page) = source
|
|
handle = create_id()
|
|
# handle is source_ref handle
|
|
# ref is source handle
|
|
db.query("""INSERT into source_ref (
|
|
handle,
|
|
ref,
|
|
confidence,
|
|
page,
|
|
private
|
|
) VALUES (?,?,?,?,?);""",
|
|
handle,
|
|
ref,
|
|
confidence,
|
|
page,
|
|
private)
|
|
export_date(db, "source_ref", handle, date)
|
|
export_list(db, "source_ref", handle, "note", note_list)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "source_ref", handle)
|
|
|
|
def export_source(db, handle, gid, title, author, pubinfo, abbrev, change,
|
|
marker0, marker1, private):
|
|
db.query("""INSERT into source (
|
|
handle,
|
|
gid,
|
|
title,
|
|
author,
|
|
pubinfo,
|
|
abbrev,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private
|
|
) VALUES (?,?,?,?,?,?,?,?,?,?);""",
|
|
handle,
|
|
gid,
|
|
title,
|
|
author,
|
|
pubinfo,
|
|
abbrev,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private)
|
|
|
|
def export_note(db, data):
|
|
(handle, gid, styled_text, format, note_type,
|
|
change, marker, private) = data
|
|
text, markup_list = styled_text
|
|
db.query("""INSERT into note (
|
|
handle,
|
|
gid,
|
|
text,
|
|
format,
|
|
note_type1,
|
|
note_type2,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private) values (?, ?, ?, ?, ?,
|
|
?, ?, ?, ?, ?);""",
|
|
handle, gid, text, format, note_type[0],
|
|
note_type[1], change, marker[0], marker[1], private)
|
|
for markup in markup_list:
|
|
markup_code, value, start_stop_list = markup
|
|
export_markup(db, "note", handle, markup_code[0], markup_code[1], value,
|
|
str(start_stop_list)) # Not normal form; use eval
|
|
|
|
def export_markup(db, from_type, from_handle, markup_code0, markup_code1, value,
|
|
start_stop_list):
|
|
markup_handle = create_id()
|
|
db.query("""INSERT INTO markup (
|
|
handle,
|
|
markup0,
|
|
markup1,
|
|
value,
|
|
start_stop_list) VALUES (?,?,?,?,?);""",
|
|
markup_handle, markup_code0, markup_code1, value,
|
|
start_stop_list)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "markup", markup_handle)
|
|
|
|
def export_event(db, data):
|
|
(handle, gid, the_type, date, description, place_handle,
|
|
source_list, note_list, media_list, attribute_list,
|
|
change, marker, private) = data
|
|
db.query("""INSERT INTO event (
|
|
handle,
|
|
gid,
|
|
the_type0,
|
|
the_type1,
|
|
description,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private) VALUES (?,?,?,?,?,?,?,?,?);""",
|
|
handle,
|
|
gid,
|
|
the_type[0],
|
|
the_type[1],
|
|
description,
|
|
change,
|
|
marker[0],
|
|
marker[1],
|
|
private)
|
|
export_date(db, "event", handle, date)
|
|
export_link(db, "event", handle, "place", place_handle)
|
|
export_list(db, "event", handle, "note", note_list)
|
|
export_attribute_list(db, "event", handle, attribute_list)
|
|
export_media_ref_list(db, "event", handle, media_list)
|
|
export_source_ref_list(db, "event", handle, source_list)
|
|
|
|
def export_event_ref(db, from_type, from_handle, event_ref):
|
|
(private, note_list, attribute_list, ref, role) = event_ref
|
|
handle = create_id()
|
|
db.query("""insert INTO event_ref (
|
|
handle,
|
|
ref,
|
|
role0,
|
|
role1,
|
|
private) VALUES (?,?,?,?,?);""",
|
|
handle,
|
|
ref,
|
|
role[0],
|
|
role[1],
|
|
private)
|
|
export_list(db, "event_ref", handle, "note", note_list)
|
|
export_attribute_list(db, "event_ref", handle, attribute_list)
|
|
# finally, link this to parent
|
|
export_link(db, from_type, from_handle, "event_ref", handle)
|
|
|
|
def export_person(db, person):
|
|
(handle, # 0
|
|
gid, # 1
|
|
gender, # 2
|
|
primary_name, # 3
|
|
alternate_names, # 4
|
|
death_ref_index, # 5
|
|
birth_ref_index, # 6
|
|
event_ref_list, # 7
|
|
family_list, # 8
|
|
parent_family_list, # 9
|
|
media_list, # 10
|
|
address_list, # 11
|
|
attribute_list, # 12
|
|
urls, # 13
|
|
lds_ord_list, # 14
|
|
psource_list, # 15
|
|
pnote_list, # 16
|
|
change, # 17
|
|
marker, # 18
|
|
private, # 19
|
|
person_ref_list, # 20
|
|
) = person
|
|
db.query("""INSERT INTO person (
|
|
handle,
|
|
gid,
|
|
gender,
|
|
death_ref_handle,
|
|
birth_ref_handle,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private) values (?, ?, ?, ?, ?, ?, ?, ?, ?);""",
|
|
handle,
|
|
gid,
|
|
gender,
|
|
lookup(death_ref_index, event_ref_list),
|
|
lookup(birth_ref_index, event_ref_list),
|
|
change,
|
|
marker[0],
|
|
marker[1],
|
|
private)
|
|
|
|
# Event Reference information
|
|
for event_ref in event_ref_list:
|
|
export_event_ref(db, "person", handle, event_ref)
|
|
export_list(db, "person", handle, "family", family_list)
|
|
export_list(db, "person", handle, "parent_family", parent_family_list)
|
|
export_media_ref_list(db, "person", handle, media_list)
|
|
export_list(db, "person", handle, "note", pnote_list)
|
|
export_attribute_list(db, "person", handle, attribute_list)
|
|
export_url_list(db, "person", handle, urls)
|
|
export_person_ref_list(db, "person", handle, person_ref_list)
|
|
export_source_ref_list(db, "person", handle, psource_list)
|
|
|
|
# -------------------------------------
|
|
# Address
|
|
# -------------------------------------
|
|
for address in address_list:
|
|
export_address(db, "person", handle, address)
|
|
|
|
# -------------------------------------
|
|
# LDS ord
|
|
# -------------------------------------
|
|
for ldsord in lds_ord_list:
|
|
export_lds(db, "person", handle, ldsord)
|
|
|
|
# -------------------------------------
|
|
# Names
|
|
# -------------------------------------
|
|
export_name(db, "person", handle, True, primary_name)
|
|
map(lambda name: export_name(db, "person", handle, False, name),
|
|
alternate_names)
|
|
|
|
def export_date(db, from_type, from_handle, data):
|
|
if data is None: return
|
|
(calendar, modifier, quality, dateval, text, sortval, newyear) = data
|
|
if len(dateval) == 4:
|
|
day1, month1, year1, slash1 = dateval
|
|
day2, month2, year2, slash2 = 0, 0, 0, 0
|
|
elif len(dateval) == 8:
|
|
day1, month1, year1, slash1, day2, month2, year2, slash2 = dateval
|
|
else:
|
|
raise ("ERROR: date dateval format", dateval)
|
|
date_handle = create_id()
|
|
db.query("""INSERT INTO date (
|
|
handle,
|
|
calendar,
|
|
modifier,
|
|
quality,
|
|
day1,
|
|
month1,
|
|
year1,
|
|
slash1,
|
|
day2,
|
|
month2,
|
|
year2,
|
|
slash2,
|
|
text,
|
|
sortval,
|
|
newyear) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,
|
|
?, ?, ?, ?, ?, ?);""",
|
|
date_handle, calendar, modifier, quality,
|
|
day1, month1, year1, slash1,
|
|
day2, month2, year2, slash2,
|
|
text, sortval, newyear)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "date", date_handle)
|
|
|
|
def export_name(db, from_type, from_handle, primary, data):
|
|
if data:
|
|
(private, source_list, note_list, date,
|
|
first_name, surname, suffix, title,
|
|
name_type, prefix, patronymic,
|
|
group_as, sort_as, display_as, call) = data
|
|
handle = create_id()
|
|
db.query("""INSERT into name (
|
|
handle,
|
|
primary_name,
|
|
private,
|
|
first_name,
|
|
surname,
|
|
suffix,
|
|
title,
|
|
name_type0,
|
|
name_type1,
|
|
prefix,
|
|
patronymic,
|
|
group_as,
|
|
sort_as,
|
|
display_as,
|
|
call
|
|
) values (?, ?, ?, ?, ?, ?, ?, ?,
|
|
?, ?, ?, ?, ?, ?, ?);""",
|
|
handle, primary, private, first_name, surname, suffix, title,
|
|
name_type[0], name_type[1], prefix, patronymic, group_as,
|
|
sort_as, display_as, call)
|
|
export_date(db, "name", handle, date)
|
|
export_list(db, "name", handle, "note", note_list)
|
|
export_source_ref_list(db, "name", handle, source_list)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "name", handle)
|
|
|
|
def export_attribute(db, from_type, from_handle, attribute):
|
|
(private, source_list, note_list, the_type, value) = attribute
|
|
handle = create_id()
|
|
db.query("""INSERT INTO attribute (
|
|
handle,
|
|
the_type0,
|
|
the_type1,
|
|
value,
|
|
private) VALUES (?,?,?,?,?);""",
|
|
handle, the_type[0], the_type[1], value, private)
|
|
export_source_ref_list(db, "attribute", handle, source_list)
|
|
export_list(db, "attribute", handle, "note", note_list)
|
|
# finally, link the parent to the address
|
|
export_link(db, from_type, from_handle, "attribute", handle)
|
|
|
|
def export_source_ref_list(db, from_type, from_handle, source_list):
|
|
for source in source_list:
|
|
export_source_ref(db, from_type, from_handle, source)
|
|
|
|
def export_media_ref_list(db, from_type, from_handle, media_list):
|
|
for media in media_list:
|
|
export_media_ref(db, from_type, from_handle, media)
|
|
|
|
def export_media_ref(db, from_type, from_handle, media):
|
|
(private, source_list, note_list, attribute_list, ref, role) = media
|
|
# handle is the media_ref handle
|
|
# ref is the media handle
|
|
handle = create_id()
|
|
if role is None:
|
|
role = (-1, -1, -1, -1)
|
|
db.query("""INSERT into media_ref (
|
|
handle,
|
|
ref,
|
|
role0,
|
|
role1,
|
|
role2,
|
|
role3,
|
|
private) VALUES (?,?,?,?,?,?,?);""",
|
|
handle, ref, role[0], role[1], role[2], role[3], private)
|
|
export_list(db, "media_ref", handle, "note", note_list)
|
|
export_attribute_list(db, "media_ref", handle, attribute_list)
|
|
export_source_ref_list(db, "media_ref", handle, source_list)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "media_ref", handle)
|
|
|
|
def export_attribute_list(db, from_type, from_handle, attr_list):
|
|
for attribute in attr_list:
|
|
export_attribute(db, from_type, from_handle, attribute)
|
|
|
|
def export_child_ref_list(db, from_type, from_handle, to_type, ref_list):
|
|
for child_ref in ref_list:
|
|
# family -> child_ref
|
|
# (False, [], [], u'b305e96e39652d8f08c', (1, u''), (1, u''))
|
|
(private, source_list, note_list, ref, frel, mrel) = child_ref
|
|
handle = create_id()
|
|
db.query("""INSERT INTO child_ref (handle,
|
|
ref, frel0, frel1, mrel0, mrel1, private)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?);""",
|
|
handle, ref, frel[0], frel[1],
|
|
mrel[0], mrel[1], private)
|
|
export_source_ref_list(db, "child_ref", handle, source_list)
|
|
export_list(db, "child_ref", handle, "note", note_list)
|
|
# And finally, make a link from parent to new object
|
|
export_link(db, from_type, from_handle, "child_ref", handle)
|
|
|
|
def export_list(db, from_type, from_handle, to_type, handle_list):
|
|
for to_handle in handle_list:
|
|
export_link(db, from_type, from_handle, to_type, to_handle)
|
|
|
|
def export_link(db, from_type, from_handle, to_type, to_handle):
|
|
if to_handle:
|
|
db.query("""insert into link (
|
|
from_type,
|
|
from_handle,
|
|
to_type,
|
|
to_handle) values (?, ?, ?, ?)""",
|
|
from_type, from_handle, to_type, to_handle)
|
|
|
|
def export_datamap_dict(db, from_type, from_handle, datamap):
|
|
for key_field in datamap:
|
|
handle = create_id()
|
|
value_field = datamap[key_field]
|
|
db.query("""INSERT INTO datamap (
|
|
handle,
|
|
key_field,
|
|
value_field) values (?, ?, ?)""",
|
|
handle, key_field, value_field)
|
|
export_link(db, from_type, from_handle, "datamap", handle)
|
|
|
|
def export_address(db, from_type, from_handle, address):
|
|
(private, asource_list, anote_list, date, location) = address
|
|
addr_handle = create_id()
|
|
db.query("""INSERT INTO address (
|
|
handle,
|
|
private) VALUES (?, ?);""", addr_handle, private)
|
|
export_location(db, "address", addr_handle, location)
|
|
export_date(db, "address", addr_handle, date)
|
|
export_list(db, "address", addr_handle, "note", anote_list)
|
|
export_source_ref_list(db, "address", addr_handle, asource_list)
|
|
# finally, link the parent to the address
|
|
export_link(db, from_type, from_handle, "address", addr_handle)
|
|
|
|
def export_location(db, from_type, from_handle, location):
|
|
if len(location) == 7:
|
|
(street, city, county, state, country, postal, phone) = location
|
|
parish = None
|
|
elif len(location) == 2:
|
|
((street, city, county, state, country, postal, phone), parish) = location
|
|
else:
|
|
print "ERROR: what kind of location is this?", location
|
|
handle = create_id()
|
|
db.query("""INSERT INTO location (
|
|
handle,
|
|
street,
|
|
city,
|
|
county,
|
|
state,
|
|
country,
|
|
postal,
|
|
phone,
|
|
parish) VALUES (?,?,?,?,?,?,?,?,?);""",
|
|
handle, street, city, county, state, country, postal, phone, parish)
|
|
# finally, link the parent to the address
|
|
export_link(db, from_type, from_handle, "location", handle)
|
|
|
|
def export_repository_ref_list(db, from_type, from_handle, reporef_list):
|
|
for repo in reporef_list:
|
|
(note_list,
|
|
ref,
|
|
call_number,
|
|
source_media_type,
|
|
private) = repo
|
|
handle = create_id()
|
|
db.query("""insert INTO repository_ref (
|
|
handle,
|
|
ref,
|
|
call_number,
|
|
source_media_type0,
|
|
source_media_type1,
|
|
private) VALUES (?,?,?,?,?,?);""",
|
|
handle,
|
|
ref,
|
|
call_number,
|
|
source_media_type[0],
|
|
source_media_type[1],
|
|
private)
|
|
export_list(db, "repository_ref", handle, "note", note_list)
|
|
# finally, link this to parent
|
|
export_link(db, from_type, from_handle, "repository_ref", handle)
|
|
|
|
def exportData(database, filename, option_box=None, callback=None):
|
|
if not callable(callback):
|
|
callback = lambda (percent): None # dummy
|
|
|
|
start = time.time()
|
|
total = (len(database.note_map) +
|
|
len(database.person_map) +
|
|
len(database.event_map) +
|
|
len(database.family_map) +
|
|
len(database.repository_map) +
|
|
len(database.place_map) +
|
|
len(database.media_map) +
|
|
len(database.source_map))
|
|
count = 0.0
|
|
|
|
db = Database(filename)
|
|
makeDB(db)
|
|
|
|
# ---------------------------------
|
|
# Notes
|
|
# ---------------------------------
|
|
for note_handle in database.note_map.keys():
|
|
data = database.note_map[note_handle]
|
|
export_note(db, data)
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
# ---------------------------------
|
|
# Event
|
|
# ---------------------------------
|
|
for event_handle in database.event_map.keys():
|
|
data = database.event_map[event_handle]
|
|
export_event(db, data)
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
# ---------------------------------
|
|
# Person
|
|
# ---------------------------------
|
|
for person_handle in database.person_map.keys():
|
|
person = database.person_map[person_handle]
|
|
export_person(db, person)
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
# ---------------------------------
|
|
# Family
|
|
# ---------------------------------
|
|
for family_handle in database.family_map.keys():
|
|
family = database.family_map[family_handle]
|
|
(handle, gid, father_handle, mother_handle,
|
|
child_ref_list, the_type, event_ref_list, media_list,
|
|
attribute_list, lds_seal_list, source_list, note_list,
|
|
change, marker, private) = family
|
|
# father_handle and/or mother_handle can be None
|
|
db.query("""INSERT INTO family (
|
|
handle,
|
|
gid,
|
|
father_handle,
|
|
mother_handle,
|
|
the_type0,
|
|
the_type1,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private) values (?,?,?,?,?,?,?,?,?,?);""",
|
|
handle, gid, father_handle, mother_handle,
|
|
the_type[0], the_type[1], change, marker[0], marker[1],
|
|
private)
|
|
|
|
export_child_ref_list(db, "family", handle, "child_ref", child_ref_list)
|
|
export_list(db, "family", handle, "note", note_list)
|
|
export_attribute_list(db, "family", handle, attribute_list)
|
|
export_source_ref_list(db, "family", handle, source_list)
|
|
export_media_ref_list(db, "family", handle, media_list)
|
|
|
|
# Event Reference information
|
|
for event_ref in event_ref_list:
|
|
export_event_ref(db, "family", handle, event_ref)
|
|
|
|
# -------------------------------------
|
|
# LDS
|
|
# -------------------------------------
|
|
for ldsord in lds_seal_list:
|
|
export_lds(db, "family", handle, ldsord)
|
|
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
# ---------------------------------
|
|
# Repository
|
|
# ---------------------------------
|
|
for repository_handle in database.repository_map.keys():
|
|
repository = database.repository_map[repository_handle]
|
|
(handle, gid, the_type, name, note_list,
|
|
address_list, urls, change, marker, private) = repository
|
|
|
|
db.query("""INSERT INTO repository (
|
|
handle,
|
|
gid,
|
|
the_type0,
|
|
the_type1,
|
|
name,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private) VALUES (?,?,?,?,?,?,?,?,?);""",
|
|
handle, gid, the_type[0], the_type[1],
|
|
name, change, marker[0], marker[1], private)
|
|
|
|
export_list(db, "repository", handle, "note", note_list)
|
|
export_url_list(db, "repository", handle, urls)
|
|
|
|
for address in address_list:
|
|
export_address(db, "repository", handle, address)
|
|
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
# ---------------------------------
|
|
# Place
|
|
# ---------------------------------
|
|
for place_handle in database.place_map.keys():
|
|
place = database.place_map[place_handle]
|
|
(handle, gid, title, long, lat,
|
|
main_loc, alt_location_list,
|
|
urls,
|
|
media_list,
|
|
source_list,
|
|
note_list,
|
|
change, marker, private) = place
|
|
|
|
db.query("""INSERT INTO place (
|
|
handle,
|
|
gid,
|
|
title,
|
|
long,
|
|
lat,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private) values (?,?,?,?,?,?,?,?,?);""",
|
|
handle, gid, title, long, lat,
|
|
change, marker[0], marker[1], private)
|
|
|
|
export_url_list(db, "place", handle, urls)
|
|
export_media_ref_list(db, "place", handle, media_list)
|
|
export_source_ref_list(db, "place", handle, source_list)
|
|
export_list(db, "place", handle, "note", note_list)
|
|
|
|
# Main Location with parish:
|
|
# No need; we have the handle, but ok:
|
|
export_location(db, "place_main", handle, main_loc)
|
|
# But we need to link these:
|
|
export_location_list(db, "place_alt", handle, alt_location_list)
|
|
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
# ---------------------------------
|
|
# Source
|
|
# ---------------------------------
|
|
for source_handle in database.source_map.keys():
|
|
source = database.source_map[source_handle]
|
|
(handle, gid, title,
|
|
author, pubinfo,
|
|
note_list,
|
|
media_list,
|
|
abbrev,
|
|
change, datamap,
|
|
reporef_list,
|
|
marker, private) = source
|
|
|
|
export_source(db, handle, gid, title, author, pubinfo, abbrev, change,
|
|
marker[0], marker[1], private)
|
|
export_list(db, "source", handle, "note", note_list)
|
|
export_media_ref_list(db, "source", handle, media_list)
|
|
export_datamap_dict(db, "source", handle, datamap)
|
|
export_repository_ref_list(db, "source", handle, reporef_list)
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
# ---------------------------------
|
|
# Media
|
|
# ---------------------------------
|
|
for media_handle in database.media_map.keys():
|
|
media = database.media_map[media_handle]
|
|
(handle, gid, path, mime, desc,
|
|
attribute_list,
|
|
source_list,
|
|
note_list,
|
|
change,
|
|
date,
|
|
marker,
|
|
private) = media
|
|
|
|
db.query("""INSERT INTO media (
|
|
handle,
|
|
gid,
|
|
path,
|
|
mime,
|
|
desc,
|
|
change,
|
|
marker0,
|
|
marker1,
|
|
private) VALUES (?,?,?,?,?,?,?,?,?);""",
|
|
handle, gid, path, mime, desc,
|
|
change, marker[0], marker[1], private)
|
|
export_date(db, "media", handle, date)
|
|
export_list(db, "media", handle, "note", note_list)
|
|
export_source_ref_list(db, "media", handle, source_list)
|
|
export_attribute_list(db, "media", handle, attribute_list)
|
|
count += 1
|
|
callback(100 * count/total)
|
|
|
|
total_time = time.time() - start
|
|
msg = ngettext('Export Complete: %d second','Export Complete: %d seconds', total_time ) % total_time
|
|
print msg
|
|
return True
|
|
|
|
# Future ideas
|
|
# Also include meta:
|
|
# Bookmarks
|
|
# Header - researcher info
|
|
# Name formats
|
|
# Namemaps?
|
|
# GRAMPS Version #, date, exporter
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Register the plugin
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
_name = _('SQLite Export')
|
|
_description = _('SQLite is a common local database format')
|
|
_config = (_('SQLite options'), ExportOptions.WriterOptionBox)
|
|
|
|
pmgr = PluginManager.get_instance()
|
|
plugin = ExportPlugin(name = _name,
|
|
description = _description,
|
|
export_function = exportData,
|
|
extension = "sql",
|
|
config = _config )
|
|
pmgr.register_plugin(plugin)
|