def execute(self):
"""The main method that splits the arguments and starts the magic"""
options = self.options
# search exact match of connection
connection, opts = find_connection(Source.connections(), options,
lambda con, opts: con.matches(opts))
if connection is None:
raise UnknownConnectionException(
options.uri,
map(lambda c: c.autocomplete(), Source.connections()))
if opts.show not in ('values', 'columns') or opts.filter is None:
raise Exception('Specify the complete URI to a table')
try:
connection.connect(opts.database)
tables = connection.tables()
if opts.table not in tables:
raise UnknownTableException(opts.table, tables.keys())
table = tables[opts.table]
items = create_items(
connection,
connection.rows(table, opts.filter, opts.limit,
simplify=False), opts.include, opts.exclude,
opts.substitutes)
# remove duplicates
return list(OrderedDict.fromkeys(items))
finally:
connection.close()
def execute(self):
"""The main method that splits the arguments and starts the magic"""
left, right = self.left, self.right
lcon = Source.connection(left)
if not lcon:
raise UnknownConnectionException(
left.uri,
map(lambda c: c.autocomplete(), Source.connections()))
lopts = left.get(lcon.dbms)
rcon = Source.connection(right)
if not rcon:
raise UnknownConnectionException(
right.uri,
map(lambda c: c.autocomplete(), Source.connections()))
ropts = right.get(rcon.dbms)
try:
lcon.connect(lopts.database)
rcon.connect(ropts.database)
ltables = lcon.tables()
if lopts.table not in ltables:
raise UnknownTableException(lopts.table, ltables.keys())
ltable = ltables[lopts.table]
rtables = rcon.tables()
if ropts.table not in rtables:
raise UnknownTableException(ropts.table, rtables.keys())
rtable = rtables[ropts.table]
lcols = map(
column_ddl if left.compare_ddl else column_name,
ltable.columns())
rcols = map(
column_ddl if right.compare_ddl else column_name,
rtable.columns())
lplus = dict(map(
lambda c: (c.split()[0], ltable.column(c.split()[0])),
list(set(lcols) - set(rcols))))
rplus = dict(map(
lambda c: (c.split()[0], rtable.column(c.split()[0])),
list(set(rcols) - set(lcols))))
r = {}
for k, v in lplus.iteritems():
if k in rplus:
r[k] = (v, rplus[k])
else:
r[k] = (v, None)
for k, v in rplus.iteritems():
if k not in lplus:
r[k] = (None, v)
return to_dto(map(lambda (k, v): v, r.iteritems()))
finally:
lcon.close()
rcon.close()
def execute(self):
"""The main method that splits the arguments and starts the magic"""
left, right = self.left, self.right
lcon = Source.connection(left)
if not lcon:
raise UnknownConnectionException(
left.uri, map(lambda c: c.autocomplete(),
Source.connections()))
lopts = left.get(lcon.dbms)
rcon = Source.connection(right)
if not rcon:
raise UnknownConnectionException(
right.uri, map(lambda c: c.autocomplete(),
Source.connections()))
ropts = right.get(rcon.dbms)
try:
lcon.connect(lopts.database)
rcon.connect(ropts.database)
ltables = lcon.tables()
if lopts.table not in ltables:
raise UnknownTableException(lopts.table, ltables.keys())
ltable = ltables[lopts.table]
rtables = rcon.tables()
if ropts.table not in rtables:
raise UnknownTableException(ropts.table, rtables.keys())
rtable = rtables[ropts.table]
lcols = map(column_ddl if left.compare_ddl else column_name,
ltable.columns())
rcols = map(column_ddl if right.compare_ddl else column_name,
rtable.columns())
lplus = dict(
map(lambda c: (c.split()[0], ltable.column(c.split()[0])),
list(set(lcols) - set(rcols))))
rplus = dict(
map(lambda c: (c.split()[0], rtable.column(c.split()[0])),
list(set(rcols) - set(lcols))))
r = {}
for k, v in lplus.iteritems():
if k in rplus:
r[k] = (v, rplus[k])
else:
r[k] = (v, None)
for k, v in rplus.iteritems():
if k not in lplus:
r[k] = (None, v)
return to_dto(map(lambda (k, v): v, r.iteritems()))
finally:
lcon.close()
rcon.close()
def execute(self):
"""The main method that splits the arguments and starts the magic"""
options = self.options
# search exact match of connection
connection, opts = find_connection(
Source.connections(), options, lambda con, opts:
(con.matches(opts) and opts.show in
['databases', 'tables', 'columns', 'values']))
if connection is None:
raise UnknownConnectionException(
options.uri,
map(lambda c: c.autocomplete(), Source.connections()))
return self.process(connection, opts)
def execute(self):
"""The main method that splits the arguments and starts the magic"""
options = self.options
# search exact match of connection
connection, opts = find_connection(Source.connections(), options,
lambda con, opts: con.matches(opts))
if connection is None:
raise UnknownConnectionException(
options.uri,
map(lambda c: c.autocomplete(), Source.connections()))
if opts.show not in ['tables', 'columns', 'values']:
raise Exception('Specify the complete URI to a table')
return to_dto(self.build(connection, opts))
def execute(self):
"""The main method that splits the arguments and starts the magic"""
options = self.options
# search exact match of connection
connection, opts = find_connection(
Source.connections(),
options,
lambda con, opts: (
con.matches(opts)
and opts.show in ['databases', 'tables', 'columns', 'values']))
if connection is None:
raise UnknownConnectionException(
options.uri,
map(lambda c: c.autocomplete(), Source.connections()))
return self.process(connection, opts)
def execute(self):
"""The main method that splits the arguments and starts the magic"""
options = self.options
# search exact match of connection
connection, opts = find_connection(
Source.connections(),
options,
lambda con, opts: con.matches(opts))
if connection is None:
raise UnknownConnectionException(
options.uri,
map(lambda c: c.autocomplete(), Source.connections()))
if opts.show not in ['tables', 'columns', 'values']:
raise Exception('Specify the complete URI to a table')
return to_dto(self.build(connection, opts))
def execute(self):
"""The main method that splits the arguments and starts the magic"""
options = self.options
# search exact match of connection
connection, opts = find_connection(
Source.connections(),
options,
lambda con, opts: con.matches(opts))
if connection is None:
raise UnknownConnectionException(
options.uri,
map(lambda c: c.autocomplete(), Source.connections()))
if opts.show not in ('values', 'columns') or opts.filter is None:
raise Exception('Specify the complete URI to a table')
try:
connection.connect(opts.database)
tables = connection.tables()
if opts.table not in tables:
raise UnknownTableException(opts.table, tables.keys())
table = tables[opts.table]
items = create_items(
connection,
connection.rows(
table,
opts.filter,
opts.limit,
simplify=False),
opts.include,
opts.exclude,
opts.substitutes)
# remove duplicates
return list(OrderedDict.fromkeys(items))
finally:
connection.close()
def build(self, options):
cons = Source.connections()
# search exact match of connection
connection, opts = find_connection(
cons, options, lambda con, opts:
(opts.show != 'connections' and con.matches(opts)))
if connection is not None:
return create(connection, opts)
# print all connections
return sorted([c for c in cons if c.filter_(options)],
key=lambda c: c.title().lower())
def build(self, options):
cons = Source.connections()
# search exact match of connection
connection, opts = find_connection(
cons,
options,
lambda con, opts: (
opts.show != 'connections' and con.matches(opts)))
if connection is not None:
return create(connection, opts)
# print all connections
return sorted(
[c for c in cons if c.filter_(options)],
key=lambda c: c.title().lower())
def execute(self):
options = self.options
options.pattern = sanitise(options.pattern)
cons = Source.connections()
# search exact match of connection
for connection in cons:
opts = options.get(connection.dbms)
if opts.show_code > 1 and connection.matches(opts):
try:
connection.connect(opts.database)
return to_dto(map(
RowItem, opts.statement_activity(connection)))
finally:
connection.close()
raise Exception('Specify the complete URI of the connection')
def __init__(self, uri, file_, key, con_creator):
Source.__init__(self)
self.uri = uri
self.file = file_
self.key = key
self.con_creator = con_creator
def __init__(self, driver, file_, scheme, con_creator):
Source.__init__(self)
self.driver = driver
self.file = file_
self.scheme = scheme
self.con_creator = con_creator
def __init__(self, driver, file_, scheme, con_creator):
Source.__init__(self)
self.driver = driver
self.file = file_
self.scheme = scheme
self.con_creator = con_creator
def __init__(self, uri, file_, key, con_creator):
Source.__init__(self)
self.uri = uri
self.file = file_
self.key = key
self.con_creator = con_creator
