def __init__(self, **params):
DBWorker.__init__(self, **params)
try:
metadata = MetaData(self.engine)
self.nodes = Table('nodes', metadata, autoload=True)
self.policy = Table('policy', metadata, autoload=True)
self.statistics = Table('statistics', metadata, autoload=True)
self.versions = Table('versions', metadata, autoload=True)
self.attributes = Table('attributes', metadata, autoload=True)
except NoSuchTableError:
tables = create_tables(self.engine)
map(lambda t: self.__setattr__(t.name, t), tables)
s = self.nodes.select().where(
and_(self.nodes.c.node == ROOTNODE,
self.nodes.c.parent == ROOTNODE))
wrapper = self.wrapper
wrapper.execute()
try:
rp = self.conn.execute(s)
r = rp.fetchone()
rp.close()
if not r:
s = self.nodes.insert().values(node=ROOTNODE,
parent=ROOTNODE,
path='')
self.conn.execute(s)
finally:
wrapper.commit()
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists config
( key text primary key,
value text ) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists config
( key text primary key,
value text ) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
try:
metadata = MetaData(self.engine)
self.nodes = Table('nodes', metadata, autoload=True)
self.policy = Table('policy', metadata, autoload=True)
self.statistics = Table('statistics', metadata, autoload=True)
self.versions = Table('versions', metadata, autoload=True)
self.attributes = Table('attributes', metadata, autoload=True)
except NoSuchTableError:
tables = create_tables(self.engine)
map(lambda t: self.__setattr__(t.name, t), tables)
s = self.nodes.select().where(and_(self.nodes.c.node == ROOTNODE,
self.nodes.c.parent == ROOTNODE))
wrapper = self.wrapper
wrapper.execute()
try:
rp = self.conn.execute(s)
r = rp.fetchone()
rp.close()
if not r:
s = self.nodes.insert(
).values(node=ROOTNODE, parent=ROOTNODE, path='')
self.conn.execute(s)
finally:
wrapper.commit()
def __init__(self, **params):
DBWorker.__init__(self, **params)
try:
metadata = MetaData(self.engine)
self.config = Table('config', metadata, autoload=True)
except NoSuchTableError:
tables = create_tables(self.engine)
map(lambda t: self.__setattr__(t.name, t), tables)
def __init__(self, **params):
DBWorker.__init__(self, **params)
try:
metadata = MetaData(self.engine)
self.groups = Table('groups', metadata, autoload=True)
except NoSuchTableError:
tables = create_tables(self.engine)
map(lambda t: self.__setattr__(t.name, t), tables)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists groups
( owner text,
name text,
member text,
primary key (owner, name, member) ) """)
execute(""" create index if not exists idx_groups_member
on groups(member) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists groups
( owner text,
name text,
member text,
primary key (owner, name, member) ) """)
execute(""" create index if not exists idx_groups_member
on groups(member) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists public
( public_id integer primary key autoincrement,
path text not null,
active boolean not null default 1,
url text) """)
execute(""" create unique index if not exists idx_public_path
on public(path) """)
execute(""" create unique index if not exists idx_public_url
on public(url) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists public
( public_id integer primary key autoincrement,
path text not null,
active boolean not null default 1,
url text) """)
execute(""" create unique index if not exists idx_public_path
on public(path) """)
execute(""" create unique index if not exists idx_public_url
on public(url) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" pragma foreign_keys = on """)
execute(""" create table if not exists xfeatures
( feature_id integer primary key,
path text ) """)
execute(""" create unique index if not exists idx_features_path
on xfeatures(path) """)
execute(""" create table if not exists xfeaturevals
( feature_id integer,
key integer,
value text,
primary key (feature_id, key, value)
foreign key (feature_id) references xfeatures(feature_id)
on delete cascade ) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" pragma foreign_keys = on """)
execute(""" create table if not exists xfeatures
( feature_id integer primary key,
path text ) """)
execute(""" create unique index if not exists idx_features_path
on xfeatures(path) """)
execute(""" create table if not exists xfeaturevals
( feature_id integer,
key integer,
value text,
primary key (feature_id, key, value)
foreign key (feature_id) references xfeatures(feature_id)
on delete cascade ) """)
def __init__(self, **params):
self._props = params.pop('props')
for p in self._props:
setattr(self, p.upper(), self._props[p])
self.mapfile_prefix = params.pop('mapfile_prefix', 'snf_file_')
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" pragma foreign_keys = on """)
execute(""" create table if not exists nodes
( node integer primary key,
parent integer default 0,
path text not null default '',
latest_version integer,
foreign key (parent)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create unique index if not exists idx_nodes_path
on nodes(path) """)
execute(""" create index if not exists idx_nodes_parent
on nodes(parent) """)
execute(""" create index if not exists idx_latest_version
on nodes(latest_version) """)
execute(""" create table if not exists policy
( node integer,
key text,
value text,
primary key (node, key)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists statistics
( node integer,
population integer not null default 0,
size integer not null default 0,
mtime integer,
cluster integer not null default 0,
primary key (node, cluster)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists versions
( serial integer primary key,
node integer,
hash text,
size integer not null default 0,
type text not null default '',
source integer,
mtime integer,
muser text not null default '',
uuid text not null default '',
checksum text not null default '',
cluster integer not null default 0,
available integer not null default 1,
map_check_timestamp integer,
mapfile text,
is_snapshot boolean not null default false,
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_versions_node_mtime
on versions(node, mtime) """)
execute(""" create index if not exists idx_versions_node
on versions(node) """)
execute(""" create index if not exists idx_versions_node_uuid
on versions(uuid) """)
execute(""" create table if not exists attributes
( serial integer,
domain text,
key text,
value text,
node integer not null default 0,
is_latest boolean not null default 1,
primary key (serial, domain, key)
foreign key (serial)
references versions(serial)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_attributes_domain
on attributes(domain) """)
execute(""" create index if not exists idx_attributes_serial_node
on attributes(serial, node) """)
execute(""" create table if not exists mapfile_seq
( serial integer primary key,
dummy boolean default -1) """)
wrapper = self.wrapper
wrapper.execute()
try:
q = "insert or ignore into nodes(node, parent) values (?, ?)"
execute(q, (ROOTNODE, ROOTNODE))
finally:
wrapper.commit()
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" pragma foreign_keys = on """)
execute(""" create table if not exists nodes
( node integer primary key,
parent integer default 0,
path text not null default '',
latest_version integer,
foreign key (parent)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create unique index if not exists idx_nodes_path
on nodes(path) """)
execute(""" create index if not exists idx_nodes_parent
on nodes(parent) """)
execute(""" create table if not exists policy
( node integer,
key text,
value text,
primary key (node, key)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists statistics
( node integer,
population integer not null default 0,
size integer not null default 0,
mtime integer,
cluster integer not null default 0,
primary key (node, cluster)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists versions
( serial integer primary key,
node integer,
hash text,
size integer not null default 0,
type text not null default '',
source integer,
mtime integer,
muser text not null default '',
uuid text not null default '',
checksum text not null default '',
cluster integer not null default 0,
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_versions_node_mtime
on versions(node, mtime) """)
execute(""" create index if not exists idx_versions_node_uuid
on versions(uuid) """)
execute(""" create table if not exists attributes
( serial integer,
domain text,
key text,
value text,
primary key (serial, domain, key)
foreign key (serial)
references versions(serial)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_attributes_domain
on attributes(domain) """)
wrapper = self.wrapper
wrapper.execute()
try:
q = "insert or ignore into nodes(node, parent) values (?, ?)"
execute(q, (ROOTNODE, ROOTNODE))
finally:
wrapper.commit()
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists qh_serials
( serial bigint primary key) """)
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" create table if not exists qh_serials
( serial bigint primary key) """)
def __init__(self, **params):
self._props = params.pop('props')
for p in self._props:
setattr(self, p.upper(), self._props[p])
self.mapfile_prefix = params.pop('mapfile_prefix', 'snf_file_')
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" pragma foreign_keys = on """)
execute(""" create table if not exists nodes
( node integer primary key,
parent integer default 0,
path text not null default '',
latest_version integer,
foreign key (parent)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create unique index if not exists idx_nodes_path
on nodes(path) """)
execute(""" create index if not exists idx_nodes_parent
on nodes(parent) """)
execute(""" create index if not exists idx_latest_version
on nodes(latest_version) """)
execute(""" create table if not exists policy
( node integer,
key text,
value text,
primary key (node, key)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists statistics
( node integer,
population integer not null default 0,
size integer not null default 0,
mtime integer,
cluster integer not null default 0,
primary key (node, cluster)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists versions
( serial integer primary key,
node integer,
hash text,
size integer not null default 0,
type text not null default '',
source integer,
mtime integer,
muser text not null default '',
uuid text not null default '',
checksum text not null default '',
cluster integer not null default 0,
available integer not null default 1,
map_check_timestamp integer,
mapfile text,
is_snapshot boolean not null default false,
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_versions_node_mtime
on versions(node, mtime) """)
execute(""" create index if not exists idx_versions_node
on versions(node) """)
execute(""" create index if not exists idx_versions_node_uuid
on versions(uuid) """)
execute(""" create table if not exists attributes
( serial integer,
domain text,
key text,
value text,
node integer not null default 0,
is_latest boolean not null default 1,
primary key (serial, domain, key)
foreign key (serial)
references versions(serial)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_attributes_domain
on attributes(domain) """)
execute(""" create index if not exists idx_attributes_serial_node
on attributes(serial, node) """)
execute(""" create table if not exists mapfile_seq
( serial integer primary key,
dummy boolean default -1) """)
wrapper = self.wrapper
wrapper.execute()
try:
q = "insert or ignore into nodes(node, parent) values (?, ?)"
execute(q, (ROOTNODE, ROOTNODE))
finally:
wrapper.commit()
def __init__(self, **params):
DBWorker.__init__(self, **params)
execute = self.execute
execute(""" pragma foreign_keys = on """)
execute(""" create table if not exists nodes
( node integer primary key,
parent integer default 0,
path text not null default '',
latest_version integer,
foreign key (parent)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create unique index if not exists idx_nodes_path
on nodes(path) """)
execute(""" create index if not exists idx_nodes_parent
on nodes(parent) """)
execute(""" create table if not exists policy
( node integer,
key text,
value text,
primary key (node, key)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists statistics
( node integer,
population integer not null default 0,
size integer not null default 0,
mtime integer,
cluster integer not null default 0,
primary key (node, cluster)
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create table if not exists versions
( serial integer primary key,
node integer,
hash text,
size integer not null default 0,
type text not null default '',
source integer,
mtime integer,
muser text not null default '',
uuid text not null default '',
checksum text not null default '',
cluster integer not null default 0,
foreign key (node)
references nodes(node)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_versions_node_mtime
on versions(node, mtime) """)
execute(""" create index if not exists idx_versions_node_uuid
on versions(uuid) """)
execute(""" create table if not exists attributes
( serial integer,
domain text,
key text,
value text,
primary key (serial, domain, key)
foreign key (serial)
references versions(serial)
on update cascade
on delete cascade ) """)
execute(""" create index if not exists idx_attributes_domain
on attributes(domain) """)
wrapper = self.wrapper
wrapper.execute()
try:
q = "insert or ignore into nodes(node, parent) values (?, ?)"
execute(q, (ROOTNODE, ROOTNODE))
finally:
wrapper.commit()
