def verticalOutput(editor):
statement = editor.currentStatement
if statement:
rsets = editor.owner.executeScript(statement)
rset = rsets and rsets[0]
if rset:
column_name_length = max(len(col.name) for col in rset.columns)
output = [ '> %s\n' % rset.sql ]
ok = rset.goToFirstRow()
while ok:
output.append('******************** %s. row *********************' % (rset.currentRow + 1))
for column in rset.columns:
col_name, col_value = column.name.rjust(column_name_length), rset.stringFieldValueByName(column.name)
output.append('%s: %s' % (col_name, col_value if col_value is not None else 'NULL'))
ok = rset.nextRow()
output.append('%d rows in set' % (rset.currentRow + 1))
view = TextOutputTab('\n'.join(output) + '\n')
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, '', 0)
dock.select_view(view)
dock.set_view_title(view, 'Vertical Output')
rset.reset_references()
return 0
def create_ui(self):
# Main layout structure
self.server_instance_box = mforms.newBox(False)
self.server_instance_box.set_spacing(8)
instance_label = mforms.newLabel('Target RDBMS Connection Parameters')
instance_label.set_style(mforms.BoldStyle)
self.server_instance_box.add(instance_label, False, True)
# TODO: Enable the export to script option in future versions:
# self.just_script_choice = mforms.newCheckBox()
# self.just_script_choice.set_text('Do not use a live instance (SQL script output)')
# self.just_script_choice.set_tooltip('Check this if you just want an output script to execute it later')
# self.just_script_choice.add_clicked_callback(self.just_script_toggled)
# self.server_instance_box.add(self.just_script_choice, False)
# Add the view that corresponds to the selected RDBMS:
self.panel = grt.classes.ui_db_ConnectPanel()
self.panel.initialize(grt.root.wb.rdbmsMgmt)
view = mforms.fromgrt(self.panel.view)
self.server_instance_box.add(view, True, True)
box = mforms.newBox(True)
self._store_connection_check = mforms.newCheckBox()
self._store_connection_check.set_text("Store connection for future usage as ")
self._store_connection_check.add_clicked_callback(self._toggle_store_connection)
box.add(self._store_connection_check, False, False)
self._store_connection_entry = mforms.newTextEntry()
box.add(self._store_connection_entry, True, True)
self._store_connection_entry.set_enabled(False)
self.server_instance_box.add(box, False, False)
self.content.add(self.server_instance_box, True, True)
self.advanced_button.set_text("Test Connection")
def create_ui(self):
self.back_button.set_enabled(False)
# Main layout structure
self.server_instance_box = mforms.newBox(False)
self.server_instance_box.set_spacing(8)
instance_label = mforms.newLabel('Source RDBMS Connection Parameters')
instance_label.set_style(mforms.BoldStyle)
self.server_instance_box.add(instance_label, False, True)
# Add the view that corresponds to the selected RDBMS:
self.panel = grt.classes.ui_db_ConnectPanel()
self.panel.initializeWithRDBMSSelector(
grt.root.wb.rdbmsMgmt, self.supported_sources_instances)
if not self.panel.view:
raise Exception("NO PANEL!!!")
view = mforms.fromgrt(self.panel.view)
self.server_instance_box.add(view, True, True)
box = mforms.newBox(True)
self._store_connection_check = mforms.newCheckBox()
self._store_connection_check.set_text(
"Store connection for future usage as ")
self._store_connection_check.add_clicked_callback(
self._toggle_store_connection)
box.add(self._store_connection_check, False, False)
self._store_connection_entry = mforms.newTextEntry()
box.add(self._store_connection_entry, True, True)
self._store_connection_entry.set_enabled(False)
self.server_instance_box.add(box, False, False)
self.content.add(self.server_instance_box, True, True)
self.advanced_button.set_text("Test Connection")
def __init__(self, editor):
self.editor = editor
self.connection = self.editor.connection
self.server_profile = None
self.admin_pages = {}
self.page_instances = {}
self.page_titles = {}
self.disabled_pages = {}
self.admin_tab = None
self.error_box = None
self.ctrl_be = None
self.admin_access_status = None # None means OK
self.sidebar = mforms.fromgrt(editor.sidebar)
self.sidebar.add_on_section_command_callback(
self._sidebar_entry_clicked)
self.sidebar_sections = [("wba_management", "MANAGEMENT", []),
("wba_instance", "INSTANCE", []),
("wba_performance", "PERFORMANCE", [])]
self.shown_in_sidebar = False
for mod in wba_page_modules:
mod.wba_register(self)
# create server profile now, since we need it to be able to tell whether instance items should be enabled in sidebar
self._check_instance_profile()
self.show_in_sidebar()
def verticalOutput(editor):
statement = editor.currentStatement
if statement:
rsets = editor.owner.executeScript(statement)
output = [ '> %s\n' % statement ]
for idx, rset in enumerate(rsets):
if len(rsets) > 1:
output.append('Result set %i' % (idx+1))
column_name_length = max(len(col.name) for col in rset.columns)
ok = rset.goToFirstRow()
while ok:
output.append('******************** %s. row *********************' % (rset.currentRow + 1))
for i, column in enumerate(rset.columns):
col_name, col_value = column.name.rjust(column_name_length), rset.stringFieldValue(i)
output.append('%s: %s' % (col_name, col_value if col_value is not None else 'NULL'))
ok = rset.nextRow()
output.append('%d rows in set' % (rset.currentRow + 1))
rset.reset_references()
if len(rsets) > 1:
output.append('')
view = TextOutputTab('\n'.join(output) + '\n')
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, '', 0)
dock.select_view(view)
view.set_title('Vertical Output')
return 0
def verticalOutput(editor):
statements = editor.selectedText or editor.script
if statements:
rsets = editor.owner.executeScript(statements)
for rset in rsets:
column_name_length = max(len(col.name) for col in rset.columns)
output = [ '> %s\n' % rset.sql ]
ok = rset.goToFirstRow()
while ok:
output.append('******************** %s. row *********************' % (rset.currentRow + 1))
for column in rset.columns:
col_name, col_value = column.name.rjust(column_name_length), rset.stringFieldValueByName(column.name)
output.append('%s: %s' % (col_name, col_value if col_value is not None else 'NULL'))
ok = rset.nextRow()
output.append('%d rows in set' % (rset.currentRow + 1))
view = TextOutputTab('\n'.join(output) + '\n')
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, '', 0)
dock.set_view_title(view, 'Vertical Output')
rset.reset_references()
return 0
def visualExplain(editor):
version = editor.owner.serverVersion
if version.majorNumber < 5 or version.minorNumber < 6:
# explain format=json only supported in 5.6+
mforms.Utilities.show_message("Visual Explain", "Visual Explain is supported in MySQL servers 5.6 or newer, but the one you are connected to is %s.%s.%s." % (version.majorNumber, version.minorNumber, version.releaseNumber), "OK", "", "")
else:
statement = editor.currentStatement
if statement:
rset = editor.owner.executeScript("EXPLAIN FORMAT=JSON %s" % statement)
if rset:
json = rset[0].stringFieldValue(0)
view = ExplainTab(json)
#bgpattern = mforms.App.get().get_resource_path("background_stripes_light.png")
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, "", 0)
dock.select_view(view)
dock.set_view_title(view, "Explain")
view.render()
rset[0].reset_references()
return 0
def create_ui(self):
# Main layout structure
self.server_instance_box = mforms.newBox(False)
self.server_instance_box.set_spacing(8)
instance_label = mforms.newLabel('Target RDBMS Connection Parameters')
instance_label.set_style(mforms.BoldStyle)
self.server_instance_box.add(instance_label, False, True)
# TODO: Enable the export to script option in future versions:
# self.just_script_choice = mforms.newCheckBox()
# self.just_script_choice.set_text('Do not use a live instance (SQL script output)')
# self.just_script_choice.set_tooltip('Check this if you just want an output script to execute it later')
# self.just_script_choice.add_clicked_callback(self.just_script_toggled)
# self.server_instance_box.add(self.just_script_choice, False)
# Add the view that corresponds to the selected RDBMS:
self.panel = grt.classes.ui_db_ConnectPanel()
self.panel.initialize(grt.root.wb.rdbmsMgmt)
view = mforms.fromgrt(self.panel.view)
self.server_instance_box.add(view, True, True)
box = mforms.newBox(True)
self._store_connection_check = mforms.newCheckBox()
self._store_connection_check.set_text("Store connection for future usage as ")
self._store_connection_check.add_clicked_callback(self._toggle_store_connection)
box.add(self._store_connection_check, False, False)
self._store_connection_entry = mforms.newTextEntry()
box.add(self._store_connection_entry, True, True)
self._store_connection_entry.set_enabled(False)
self.server_instance_box.add(box, False, False)
self.content.add(self.server_instance_box, True, True)
self.advanced_button.set_text("Test Connection")
def create_ui(self):
self.back_button.set_enabled(False)
# Main layout structure
self.server_instance_box = mforms.newBox(False)
self.server_instance_box.set_spacing(8)
instance_label = mforms.newLabel('Source RDBMS Connection Parameters')
instance_label.set_style(mforms.BoldStyle)
self.server_instance_box.add(instance_label, False, True)
# Add the view that corresponds to the selected RDBMS:
self.panel = grt.classes.ui_db_ConnectPanel()
self.panel.initializeWithRDBMSSelector(grt.root.wb.rdbmsMgmt, self.supported_sources_instances)
if not self.panel.view:
raise Exception("NO PANEL!!!")
view = mforms.fromgrt(self.panel.view)
self.server_instance_box.add(view, True, True)
box = mforms.newBox(True)
self._store_connection_check = mforms.newCheckBox()
self._store_connection_check.set_text("Store connection for future usage as ")
self._store_connection_check.add_clicked_callback(self._toggle_store_connection)
box.add(self._store_connection_check, False, False)
self._store_connection_entry = mforms.newTextEntry()
box.add(self._store_connection_entry, True, True)
self._store_connection_entry.set_enabled(False)
self.server_instance_box.add(box, False, False)
self.content.add(self.server_instance_box, True, True)
self.advanced_button.set_text("Test Connection")
def visualExplain(editor):
version = editor.owner.serverVersion
if version.majorNumber < 5 or version.minorNumber < 6:
# explain format=json only supported in 5.6+
mforms.Utilities.show_message(
"Visual Explain",
"Visual Explain is supported in MySQL servers 5.6 or newer, but the one you are connected to is %s.%s.%s."
%
(version.majorNumber, version.minorNumber, version.releaseNumber),
"OK", "", "")
else:
statement = editor.currentStatement
if statement:
rset = editor.owner.executeScript("EXPLAIN FORMAT=JSON %s" %
statement)
if rset:
json = rset[0].stringFieldValue(0)
view = ExplainTab(json)
#bgpattern = mforms.App.get().get_resource_path("background_stripes_light.png")
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, "", 0)
dock.select_view(view)
dock.set_view_title(view, "Explain")
view.render()
rset[0].reset_references()
return 0
def visualExplain(editor, result_panel):
version = Version.fromgrt(editor.owner.serverVersion)
statement = editor.currentStatement
if statement:
try:
explain = editor.owner.executeQuery("EXPLAIN %s" % statement, 1)
except Exception as e:
log_warning("Could not execute EXPLAIN %s: %s\n" % (statement, e))
explain = None
json = None
if explain and version.is_supported_mysql_version_at_least(5, 6):
rset = editor.owner.executeQuery(
"EXPLAIN FORMAT=JSON %s" % statement, 1)
if rset and rset.goToFirstRow():
json = rset.stringFieldValue(0)
rset.reset_references()
view = ExplainTab(version, statement, json,
explain if explain else None)
dock = mforms.fromgrt(result_panel.dockingPoint)
view.set_identifier("execution_plan")
view.set_title("Execution\nPlan")
dock.dock_view(view, "output_type-executionplan.png", 0)
dock.select_view(view)
return 0
def handleContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
user_selection = None
for s in selection:
if s.type == 'db.Schema':
user_selection = {'schema': s.name, 'table': None}
break
elif s.type == 'db.Table':
user_selection = {'table': s.name, 'schema': s.schemaName}
break
else:
return
if user_selection:
if user_selection['table']:
item = mforms.newMenuItem("Table Data Export")
item.add_clicked_callback(lambda sender=sender : showPowerExport(sender, user_selection))
menu.insert_item(3, item)
item = mforms.newMenuItem("Table Data Import")
item.add_clicked_callback(lambda sender=sender : showPowerImport(sender, user_selection))
menu.insert_item(4, item)
menu.insert_item(5, mforms.newMenuItem("", mforms.SeparatorMenuItem))
def __init__(self, editor):
self.editor = editor
self.connection = self.editor.connection
self.server_profile = None
self.admin_pages = {}
self.page_instances = {}
self.admin_tab = None
self.error_box = None
self.ctrl_be = None
self.admin_access_status = None # None means OK
self.sidebar = mforms.fromgrt(editor.sidebar)
self.sidebar.add_on_section_command_callback(self._sidebar_entry_clicked)
self.sidebar_sections = [("wba_management", "MANAGEMENT", []), ("wba_instance", "INSTANCE", [])]
self.shown_in_sidebar = False
for mod in wba_page_modules:
mod.wba_register(self)
# create server profile now, since we need it to be able to tell whether instance items should be enabled in sidebar
self._check_instance_profile()
self.show_in_sidebar()
def handleContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
user_selection = None
for s in selection:
if s.type == 'db.Schema':
user_selection = {'schema': to_unicode(s.name), 'table': None}
break
elif s.type == 'db.Table':
user_selection = {'table': to_unicode(s.name), 'schema': to_unicode(s.schemaName)}
break
elif s.type == 'db.View':
user_selection = {'table': to_unicode(s.name), 'schema': to_unicode(s.schemaName)}
break
else:
return
if user_selection:
if user_selection['table']:
item = mforms.newMenuItem("Table Data Export Wizard")
item.add_clicked_callback(lambda sender=sender : showPowerExport(sender, user_selection))
menu.insert_item(4, item)
def handleResultsetContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selected-rows']
column = args.get('selected-column')
if column is not None and column >= 0 and selection:
row = selection[0]
else:
row = None
menu.add_separator()
item = menu.add_item_with_title(
"Capitalize Text", lambda: capitalizeCell(sender, row, column),
"Capitalize Text", "")
item.set_enabled(
row is not None
and isinstance(sender, grt.classes.db_query_EditableResultset))
item = menu.add_item_with_title("lowercase Text",
lambda: lowerCaseCell(sender, row, column),
"Lowercase Text", "")
item.set_enabled(
row is not None
and isinstance(sender, grt.classes.db_query_EditableResultset))
item = menu.add_item_with_title("UPPERCASE Text",
lambda: upperCaseCell(sender, row, column),
"Uppercase Text", "")
item.set_enabled(
row is not None
and isinstance(sender, grt.classes.db_query_EditableResultset))
def waitSummary(editor):
statement = editor.currentStatement
if statement:
before_rows = []
after_rows = []
rset = editor.owner.executeScript(
"select * from performance_schema.events_waits_summary_by_thread_by_event_name as e join performance_schema.threads as t on e.thread_id=t.thread_id where t.processlist_id=connection_id()"
)
if rset:
while rset[0].nextRow():
row = []
for i in range(7):
if i == 1:
row.append(rset[0].stringFieldValue(i))
else:
row.append(rset[0].intFieldValue(i))
before_rows.append(row)
editor.owner.executeScriptAndOutputToGrid(statement)
rset = editor.owner.executeScript(
"select * from performance_schema.events_waits_summary_by_thread_by_event_name as e join performance_schema.threads as t on e.thread_id=t.thread_id where t.processlist_id=connection_id()"
)
if rset:
while rset[0].nextRow():
row = []
for i in range(7):
if i == 1:
row.append(rset[0].stringFieldValue(i))
else:
row.append(rset[0].intFieldValue(i))
after_rows.append(row)
tree = event_waits_summary_by_thread_by_event_name_to_tree(
before_rows, after_rows)
print tree
import cairo
import cairo_utils
surf = cairo_utils.ImageSurface(cairo.CAIRO_FORMAT_ARGB32, 800, 800)
c = cairo_utils.Context(surf)
c.set_source_rgb(0, 0, 0)
c.paint()
chart = TreePieChart(tree, c)
chart.plot()
surf.write_to_png("/tmp/explain.png")
view = mforms.newAppView(True, "QueryEditorView", False)
scroll = mforms.newScrollPanel(mforms.ScrollPanelNoFlags)
scroll.set_visible_scrollers(True, True)
image = mforms.newImageBox()
image.set_size(800, 800)
scroll.add(image)
image.set_image("/tmp/explain.png")
view.add(scroll, True, True)
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, "", 0)
dock.set_view_title(view, "Explain")
return 0
def show_table_inspector(editor, selection):
for schema, table in selection:
sman = TableInspector(editor)
sman.show_tables(schema, table)
dpoint = mforms.fromgrt(editor.dockingPoint)
dpoint.dock_view(sman, "", 0)
dpoint.select_view(sman)
sman.set_title("%s.%s" % (schema, table))
def generateCertificates(parent, conn, conn_id):
try:
log_info("Running SSL Wizard\nParent: %s\nUser Folder: %s\nConn Parameters: %s\nConn ID: %s\n" % (str(parent), mforms.App.get().get_user_data_folder(), str(conn.parameterValues), conn_id))
p = mforms.fromgrt(parent)
log_info("Running SSL Wizard\n%s\n" % str(p))
r = SSLWizard(p, conn, conn_id)
r.run(True)
except Exception, e:
log_error("There was an exception running SSL Wizard.\n%s\n\n%s" % (str(e), traceback.format_exc()))
def generateCertificates(parent, conn, conn_id):
try:
log_info("Running SSL Wizard\nParent: %s\nUser Folder: %s\nConn Parameters: %s\nConn ID: %s\n" % (str(parent), mforms.App.get().get_user_data_folder(), str(conn.parameterValues), conn_id))
p = mforms.fromgrt(parent)
log_info("Running SSL Wizard\n%s\n" % str(p))
r = SSLWizard(p, conn, conn_id)
r.run(True)
except Exception, e:
log_error("There was an exception running SSL Wizard.\n%s\n\n%s" % (str(e), traceback.format_exc()))
def show_schema_manager(editor, selection, table_maintenance=False):
for schema_name in selection:
sman = SchemaManager(editor, schema_name)
dpoint = mforms.fromgrt(editor.dockingPoint)
dpoint.dock_view(sman, "", 0)
dpoint.select_view(sman)
sman.set_title(schema_name)
if table_maintenance:
sman.show_table_maintenance()
def show_schema_manager(editor, selection, table_maintenance=False):
for schema_name in selection:
sman = SchemaManager(editor, schema_name)
dpoint = mforms.fromgrt(editor.dockingPoint)
dpoint.dock_view(sman, "", 0)
dpoint.select_view(sman)
sman.set_title(schema_name)
if table_maintenance:
sman.show_table_maintenance()
def waitSummary(editor):
statement = editor.currentStatement
if statement:
before_rows = []
after_rows = []
rset = editor.owner.executeScript("select * from performance_schema.events_waits_summary_by_thread_by_event_name as e join performance_schema.threads as t on e.thread_id=t.thread_id where t.processlist_id=connection_id()")
if rset:
while rset[0].nextRow():
row = []
for i in range(7):
if i == 1:
row.append(rset[0].stringFieldValue(i))
else:
row.append(rset[0].intFieldValue(i))
before_rows.append(row)
editor.owner.executeScriptAndOutputToGrid(statement)
rset = editor.owner.executeScript("select * from performance_schema.events_waits_summary_by_thread_by_event_name as e join performance_schema.threads as t on e.thread_id=t.thread_id where t.processlist_id=connection_id()")
if rset:
while rset[0].nextRow():
row = []
for i in range(7):
if i == 1:
row.append(rset[0].stringFieldValue(i))
else:
row.append(rset[0].intFieldValue(i))
after_rows.append(row)
tree = event_waits_summary_by_thread_by_event_name_to_tree(before_rows, after_rows)
print tree
import cairo
import cairo_utils
surf = cairo_utils.ImageSurface(cairo.CAIRO_FORMAT_ARGB32, 800, 800)
c = cairo_utils.Context(surf)
c.set_source_rgb(0,0,0)
c.paint()
chart = TreePieChart(tree, c)
chart.plot()
surf.write_to_png("/tmp/explain.png")
view = mforms.newAppView(True, "QueryEditorView", False)
scroll = mforms.newScrollPanel(mforms.ScrollPanelNoFlags)
scroll.set_visible_scrollers(True, True)
image = mforms.newImageBox()
image.set_size(800, 800)
scroll.add(image)
image.set_image("/tmp/explain.png")
view.add(scroll, True, True)
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, "", 0)
dock.set_view_title(view, "Explain")
return 0
def visualExplainForConnection(editor, conn_id, the_query):
version = Version.fromgrt(editor.owner.serverVersion)
try:
explain = editor.owner.executeManagementQuery(
"EXPLAIN FOR CONNECTION %s" % conn_id, 1)
except grt.DBError as e:
if e.args[1] == 0:
mforms.Utilities.show_message(
"Explain for Connection",
"Explain for connection %s did not generate any output." %
conn_id, "OK", "", "")
else:
mforms.Utilities.show_error(
"Explain for Connection",
"Error executing explain for connection %s\n%s" % (conn_id, e),
"OK", "", "")
return 0
except Exception as e:
mforms.Utilities.show_error(
"Explain for Connection",
"Error executing explain for connection %s\n%s" % (conn_id, e),
"OK", "", "")
return 0
if not explain:
mforms.Utilities.show_error(
"Explain for Connection",
"Error executing explain for connection %s" % conn_id, "OK", "",
"")
return 0
if version.is_supported_mysql_version_at_least(5, 6):
rset = editor.owner.executeManagementQuery(
"EXPLAIN FORMAT=JSON FOR CONNECTION %s" % conn_id, 1)
if rset and rset.goToFirstRow():
json = rset.stringFieldValue(0)
rset.reset_references()
else:
json = None
view = ExplainTab(version, the_query, json, explain if explain else None)
view.set_identifier("execution_plan")
dock = mforms.fromgrt(editor.resultDockingPoint)
dock.dock_view(view, "", 0)
dock.select_view(view)
view.set_title("Explain for Connection")
return 0
def handleLiveTreeContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
tables_selected = []
for s in selection:
if s.type == 'db.Table':
tables_selected.append((s.schemaName, s.name))
else:
return
if selection:
item = mforms.newMenuItem("Table Inspector")
item.add_clicked_callback(lambda: show_table_inspector(sender, tables_selected))
menu.insert_item(0, item)
def handleLiveTreeContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
schemas_selected = []
for s in selection:
if s.type == 'db.Schema':
schemas_selected.append(s.name)
else:
return
if schemas_selected:
item = mforms.newMenuItem("Schema Inspector")
item.add_clicked_callback(lambda: show_schema_manager(sender, schemas_selected))
menu.insert_item(2, item)
def handleLiveTreeContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
schemas_selected = []
for s in selection:
if s.type == 'db.Schema':
schemas_selected.append(s.name)
else:
return
if schemas_selected:
item = mforms.newMenuItem("Schema Inspector")
item.add_clicked_callback(
lambda: show_schema_manager(sender, schemas_selected))
menu.insert_item(2, item)
def handleResultsetContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selected-rows']
column = args.get('selected-column')
if column is not None and column >= 0 and selection:
row = selection[0]
else:
row = None
menu.add_separator()
item = menu.add_item_with_title("Capitalize Text", lambda: capitalizeCell(sender, row, column))
item.set_enabled(row is not None and isinstance(sender, grt.classes.db_query_EditableResultset))
item = menu.add_item_with_title("lowercase Text", lambda: lowerCaseCell(sender, row, column))
item.set_enabled(row is not None and isinstance(sender, grt.classes.db_query_EditableResultset))
item = menu.add_item_with_title("UPPERCASE Text", lambda: upperCaseCell(sender, row, column))
item.set_enabled(row is not None and isinstance(sender, grt.classes.db_query_EditableResultset))
def handleContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
schemas_selected = None
for s in selection:
if s.type == 'db.Schema':
schemas_selected = s.name
break
else:
return
item = mforms.newMenuItem("Load Spatial Data")
item.add_clicked_callback(
lambda sender=sender: showImporter(sender, schemas_selected))
menu.insert_item(0, item)
menu.add_separator()
def handleContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
schemas_selected = None
for s in selection:
if s.type == 'db.Schema':
schemas_selected = s.name
break
else:
return
item = mforms.newMenuItem("Load Spatial Data")
item.add_clicked_callback(lambda sender=sender : showImporter(sender, schemas_selected))
menu.insert_item(0, item)
menu.add_separator()
def _dock_admin_tab(self):
app = mforms.App.get()
try:
self.ctrl_be = wb_admin_control.WbAdminControl(self.server_profile,
self.editor,
connect_sql=True)
self.ctrl_be.init()
self.admin_tab = wb_admin_main.AdministratorTab(
self.ctrl_be, self.server_profile, self, self.editor)
except MySQLError as exc:
if str(exc):
Utilities.show_error(
"Error Connecting to MySQL Server (%s)" % exc.location,
str(exc), "OK", "", "")
app.set_status_text("Could not Open WB Admin")
return None
except OperationCancelledError as exc:
app.set_status_text("Cancelled (%s)" % exc)
return None
except NoDriverInConnection as exc:
Utilities.show_error('Missing connection driver', str(exc), 'OK',
'', '')
app.set_status_text("Could not Open WB Admin")
return None
except Exception as exc:
import traceback
traceback.print_exc()
Utilities.show_error("Error Starting Workbench Administrator",
"%s: %s" % (type(exc).__name__, exc), "OK",
"", "")
app.set_status_text("Could not Open WB Admin")
return None
dp = mforms.fromgrt(self.editor.dockingPoint)
dp.dock_view(self.admin_tab, "", 0)
dp.select_view(self.admin_tab)
self.admin_tab.set_title("Administrator")
return self.admin_tab
def show_schema_manager(editor, selection, table_maintenance=False):
try:
editor.executeManagementQuery("select 1", 0)
except grt.DBError as e:
mforms.Utilities.show_error(
"Schema Inspector",
"Can not launch the Schema Inspector because the server is unreacheble.",
"OK", "", "")
log_error(
"Can not launch the Schema Inspector because the server is unreacheble.\n"
)
return False
for schema_name in selection:
sman = SchemaManager(editor, schema_name)
dpoint = mforms.fromgrt(editor.dockingPoint)
dpoint.dock_view(sman, "", 0)
dpoint.select_view(sman)
sman.set_title(schema_name)
if table_maintenance:
sman.show_table_maintenance()
def handleLiveTreeContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
node_type = None
mixed = False
selection_type = None
object_selected = False
object_selected_count = 0
column_selected = False
if len(selection) == 1:
object_type_caption = {
'db.Schema': "Schema",
'db.Table': "Table",
'db.View': "View",
'db.Function': "Function",
'db.StoredProcedure': "Stored Procedure",
'db.Index': "Index",
'db.Trigger': "Trigger",
'db.ForeignKey': "Foreign Key",
}
else:
object_type_caption = {
'db.Schema': "Schemas",
'db.Table': "Tables",
'db.View': "Views",
'db.Function': "Functions",
'db.StoredProcedure': "Stored Procedures",
'db.Index': "Indexes",
'db.Trigger': "Triggers",
'db.ForeignKey': "Foreign Keys",
}
unique_tables = set()
selection_db_type = None
for s in selection:
if s.type != node_type:
if node_type is None:
node_type = s.type
else:
mixed = True
if s.type == 'columns':
selection_type = s.type
column_selected = True
unique_tables.add(s.name)
elif s.type in ['tables', 'views', 'functions', 'storedProcedures']:
selection_type = s.type
object_selected = False
if s.type == 'tables':
selection_db_type = 'db.Table'
elif s.type == 'views':
selection_db_type = 'db.View'
elif s.type == 'functions':
selection_db_type = 'db.Function'
elif s.type == 'storedProcedures':
selection_db_type = 'db.StoredProcedure'
elif s.type in ('db.Schema', 'db.Table', 'db.View', 'db.Function',
'db.StoredProcedure'):
selection_type = s.type
selection_db_type = s.type
object_selected = True
object_selected_count += 1
if s.type == 'db.Table':
unique_tables.add(s.name)
elif s.type in ('db.Index', 'db.Trigger'):
selection_type = s.type
object_selected = False
elif s.type == ('db.Column'):
selection_type = s.type
if s.owner:
unique_tables.add(s.owner.name)
selection_type = s.owner.type + ':' + s.type
column_selected = True
else:
print "Unhandled type", s.type
if mixed:
selection_type = None
pass
else:
item = menu.find_item('builtins_separator')
if item:
index = menu.get_item_index(item) + 1
else:
index = 0
needs_separator = False
if False and object_selected and selection_type == 'db.Table':
item = mforms.newMenuItem(_("Export Data to CSV File..."))
item.set_name("export_table_csv")
menu.insert_item(index - 1, item)
index += 1
item = mforms.newMenuItem(_("Import Data from CSV File..."))
item.set_name("import_table_csv")
menu.insert_item(index - 1, item)
index += 1
item = mforms.newMenuItem(_("Dump Data to SQL File..."))
item.set_name("dump_table")
menu.insert_item(index - 1, item)
index += 1
if object_selected or column_selected:
# Add menu items for generating code
code_items = [
# Caption, callback name, supported node types, enable condition, mixed node types allowed
(_("Name"), 'name_short', ['db.Schema'], len(selection) > 0,
False),
(_("Name (short)"), 'name_short', [
'tables', 'views', 'functions', 'storedProcedures',
'db.Table', 'db.Table:db.Column', 'db.View:db.Column',
'db.View', 'db.StoredProcedure', 'db.Function'
], len(selection) > 0, True),
(_("Name (long)"), 'name_long', [
'tables', 'views', 'functions', 'storedProcedures',
'db.Table', 'db.Table:db.Column', 'db.View:db.Column',
'db.View', 'db.StoredProcedure', 'db.Function'
], len(selection) > 0, True),
(_("Select All Statement"), 'select_all_statement',
['db.Table', 'db.View'], len(selection) > 0, False),
(_("Select All Statement"), 'select_all_statement',
['columns'], len(selection) == 1
and selection[0].type == 'columns', False),
(_("Select Columns Statement"), 'select_columns_statement',
['db.Table:db.Column',
'db.View:db.Column'], len(unique_tables) == 1, False),
(_("Insert Statement"), 'insert_all_statement',
['db.Table', 'columns'], len(selection) > 0, False),
(_("Insert Statement"), 'insert_columns_statement',
['db.Table:db.Column'], len(selection) > 0, False),
(_("Update Statement"), 'update_all_statement',
['db.Table', 'columns'], len(selection) > 0, False),
(_("Update Statement"), 'update_columns_statement',
['db.Table:db.Column'], len(selection) > 0, False),
(_("Delete Statement"), 'delete_statement', ['db.Table'],
len(selection) > 0, False),
(_("Create Statement"), 'create_statement', [
'db.Schema', 'db.Table', 'db.View', 'db.StoredProcedure',
'db.Function'
], len(selection) > 0, False),
(_("Procedure Call"), 'call_procedure', ['db.StoredProcedure'],
len(selection) > 0, False),
(_("Function Call"), 'call_function', ['db.Function'],
len(selection) > 0, False),
(None, None, ['db.Table'], None, False),
(_("Join Selected Tables"), 'build_joined_select',
['db.Table'], len(selection) == 2, False),
(_("Delete with References"), 'build_cascaded_delete',
['db.Table'], len(selection) == 1, False),
(_("Select Row References"), 'build_cascaded_select',
['db.Table'], len(selection) == 1, False),
]
copy_submenu = mforms.newMenuItem("Copy to Clipboard")
copy_submenu.set_name("copy_to_clipboard")
menu.insert_item(index, copy_submenu)
index += 1
send_submenu = mforms.newMenuItem("Send to SQL Editor")
send_submenu.set_name("send_to_editor")
menu.insert_item(index, send_submenu)
index += 1
gencopy = CodeGenerator(sender, selection, False)
gensend = CodeGenerator(sender, selection, True)
for caption, name, types, enabled, allow_mixed in code_items:
if not allow_mixed and mixed:
continue
if types and selection_type not in types:
continue
if caption is None:
copy_submenu.add_separator()
send_submenu.add_separator()
else:
item = copy_submenu.add_item_with_title(
caption, getattr(gencopy, name), name)
item.set_enabled(enabled)
item = send_submenu.add_item_with_title(
caption, getattr(gensend, name), name)
item.set_enabled(enabled)
needs_separator = True
else:
needs_separator = False
if selection_type in ('tables', 'views', 'functions',
'storedProcedures', 'db.Schema', 'db.Table',
'db.View', 'db.Function',
'db.StoredProcedure') and len(selection) == 1:
if needs_separator:
menu.insert_item(
index, mforms.newMenuItem("", mforms.SeparatorMenuItem))
index += 1
needs_separator = False
item = mforms.newMenuItem(
"Create %s..." %
object_type_caption.get(selection_db_type, selection_db_type))
item.add_clicked_callback(lambda: do_create_object(
sender, selection[0].schemaName, selection_db_type))
menu.insert_item(index, item)
index += 1
if selection_type in ('db.Table', 'tables'):
item = mforms.newMenuItem("Create Table Like...")
menu.insert_item(index, item)
index += 1
# it = item.add_item_with_title("Selected Table", lambda: template_manager.create_table_like(sender, selection[0].schemaName, selection[0].name))
# if selection[0].type == 'tables':
# it.set_enabled(False)
for templ in template_manager.templates:
it = item.add_item_with_title(
templ.name,
lambda templ=templ, schema=selection[0].schemaName:
template_manager.create_table_like_template(
sender, schema, templ))
item.add_separator()
it = item.add_item_with_title("Edit Templates...",
template_manager.edit_templates)
if object_selected:
if needs_separator:
menu.insert_item(
index, mforms.newMenuItem("", mforms.SeparatorMenuItem))
index += 1
needs_separator = False
if object_selected_count == 1:
item = mforms.newMenuItem(
"Alter %s..." %
object_type_caption.get(selection_type, selection_type))
else:
item = mforms.newMenuItem(
"Alter %i %s..." %
(object_selected_count,
object_type_caption.get(selection_type, selection_type)))
item.add_clicked_callback(
lambda: do_alter_object(sender, selection))
menu.insert_item(index, item)
index += 1
needs_separator = True
if selection_type == 'db.Table' and object_selected:
item = mforms.newMenuItem("Table Maintenance...")
item.add_clicked_callback(lambda: show_schema_manager(
sender, set([obj.schemaName for obj in selection]), True))
menu.insert_item(index, item)
index += 1
if object_selected: # or selection_type in ('db.Index', 'db.Trigger'): <-- enable this once we support selective refresh of LST on drop of these objects
if needs_separator:
menu.insert_item(
index, mforms.newMenuItem("", mforms.SeparatorMenuItem))
index += 1
needs_separator = False
if object_selected_count == 1:
item = mforms.newMenuItem(
"Drop %s..." %
object_type_caption.get(selection_type, selection_type))
else:
item = mforms.newMenuItem(
"Drop %i %s..." %
(object_selected_count,
object_type_caption.get(selection_type, selection_type)))
item.add_clicked_callback(
lambda: do_drop_object(sender, selection))
menu.insert_item(index, item)
index += 1
if selection_type == 'db.Table' and object_selected:
item = mforms.newMenuItem(
"Truncate %s..." %
("Table" if object_selected_count == 1 else "%i Tables" %
object_selected_count))
item.add_clicked_callback(
lambda: do_truncate_table(sender, selection))
menu.insert_item(index, item)
index += 1
if selection_type in ('db.Table', 'db.Schema', 'tables'):
item = mforms.newMenuItem("Search Table Data...")
item.add_clicked_callback(lambda: open_search(sender))
insert_item_to_plugin_context_menu(menu, item)
from mforms import IconStringColumnType, StringColumnType, LongIntegerColumnType, IntegerColumnType, NumberWithUnitColumnType
from workbench.notifications import NotificationCenter
from wb_admin_utils import make_panel_header
from workbench.utils import human_size, Version
def show_schema_manager(editor, selection, table_maintenance=False):
try:
editor.executeManagementQuery("select 1", 0)
except grt.DBError, e:
mforms.Utilities.show_error("Schema Inspector", "Can not launch the Schema Inspector because the server is unreacheble.", "OK", "", "")
log_error("Can not launch the Schema Inspector because the server is unreacheble.\n")
return False
for schema_name in selection:
sman = SchemaManager(editor, schema_name)
dpoint = mforms.fromgrt(editor.dockingPoint)
dpoint.dock_view(sman, "", 0)
dpoint.select_view(sman)
sman.set_title(schema_name)
if table_maintenance:
sman.show_table_maintenance()
def handleLiveTreeContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
schemas_selected = []
def become_active_tab(self):
dp = mforms.fromgrt(self.editor.dockingPoint)
dp.select_view(self.admin_tab)
def show_schema_manager(editor, selection, table_maintenance=False):
try:
editor.executeManagementQuery("select 1", 0)
except grt.DBError, e:
mforms.Utilities.show_error(
"Schema Inspector",
"Can not launch the Schema Inspector because the server is unreacheble.",
"OK", "", "")
log_error(
"Can not launch the Schema Inspector because the server is unreacheble.\n"
)
return False
for schema_name in selection:
sman = SchemaManager(editor, schema_name)
dpoint = mforms.fromgrt(editor.dockingPoint)
dpoint.dock_view(sman, "", 0)
dpoint.select_view(sman)
sman.set_title(schema_name)
if table_maintenance:
sman.show_table_maintenance()
def handleLiveTreeContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
schemas_selected = []
Utilities.show_error('Missing connection driver', str(exc), 'OK', '', '')
app.set_status_text("Could not Open WB Admin")
return None
except Exception, exc:
import traceback
traceback.print_exc()
Utilities.show_error("Error Starting Workbench Administrator", "%s: %s" % (type(exc).__name__, exc), "OK", "", "")
app.set_status_text("Could not Open WB Admin")
return None
if self._check_server_version() is False:
app.set_status_text("Unsupported server version for Administration")
return None
dp = mforms.fromgrt(self.editor.dockingPoint)
dp.dock_view(self.admin_tab, "", 0)
dp.select_view(self.admin_tab)
self.admin_tab.set_title("Administrator")
def become_active_tab(self):
dp = mforms.fromgrt(self.editor.dockingPoint)
dp.select_view(self.admin_tab)
def _sidebar_entry_clicked(self, entry_id):
if entry_id == "configure":
grt.modules.Workbench.showInstanceManagerFor(self.editor.connection)
else:
self.open_into_section(entry_id)
def executeQueryAsText(qbuffer):
editor = qbuffer.owner
sql = qbuffer.selectedText or qbuffer.script
resultsets = editor.executeScript(sql)
if resultsets:
view = TextOutputTab("")
dock = mforms.fromgrt(qbuffer.resultDockingPoint)
dock.dock_view(view, "", 0)
view.set_title("Query Output")
dock.select_view(view)
for result in resultsets:
output = ["Execute:"]
output.append("> %s\n" % result.sql)
line = []
column_lengths = []
ncolumns = len(result.columns)
for column in result.columns:
line.append(column.name + " "*5)
column_lengths.append(len(column.name)+5)
separator = []
for c in column_lengths:
separator.append("-"*c)
separator = " + ".join(separator)
output.append("+ "+separator+" +")
line = " | ".join(line)
output.append("| "+line+" |")
output.append("+ "+separator+" +\n")
ok = result.goToFirstRow()
if ok:
view.textbox.append_text('\n'.join(output))
import time
last_flush = 0
rows = []
while ok:
line = []
for i in range(ncolumns):
value = result.stringFieldValue(i)
if value is None:
value = "NULL"
line.append(value.ljust(column_lengths[i]))
line= " | ".join(line)
rows.append("| "+line+" |")
# flush text every 1/2s
if time.time() - last_flush >= 0.5:
last_flush = time.time()
view.textbox.append_text("\n".join(rows)+"\n")
rows = []
ok = result.nextRow()
if rows:
view.textbox.append_text("\n".join(rows)+"\n")
view.textbox.append_text("+ "+separator+" +\n")
view.textbox.append_text("%i rows\n\n" % (result.currentRow + 1))
return 0
def handleLiveTreeContextMenu(name, sender, args):
menu = mforms.fromgrt(args['menu'])
selection = args['selection']
# Add extra menu items to the SQL editor live schema tree context menu
node_type = None
mixed = False
selection_type = None
object_selected = False
object_selected_count = 0
column_selected = False
if len(selection) == 1:
object_type_caption = {
'db.Schema' : "Schema",
'db.Table' : "Table",
'db.View' : "View",
'db.Function' : "Function",
'db.StoredProcedure' : "Stored Procedure",
'db.Index' : "Index",
'db.Trigger' : "Trigger",
'db.ForeignKey' : "Foreign Key",
}
else:
object_type_caption = {
'db.Schema' : "Schemas",
'db.Table' : "Tables",
'db.View' : "Views",
'db.Function' : "Functions",
'db.StoredProcedure' : "Stored Procedures",
'db.Index' : "Indexes",
'db.Trigger' : "Triggers",
'db.ForeignKey' : "Foreign Keys",
}
unique_tables = set()
selection_db_type = None
for s in selection:
if s.type != node_type:
if node_type is None:
node_type = s.type
else:
mixed = True
if s.type == 'columns':
selection_type = s.type
column_selected = True
unique_tables.add(s.name)
elif s.type in ['tables', 'views', 'functions', 'storedProcedures']:
selection_type = s.type
object_selected = False
if s.type == 'tables':
selection_db_type = 'db.Table'
elif s.type == 'views':
selection_db_type = 'db.View'
elif s.type == 'functions':
selection_db_type = 'db.Function'
elif s.type == 'storedProcedures':
selection_db_type = 'db.StoredProcedure'
elif s.type in ('db.Schema', 'db.Table', 'db.View', 'db.Function', 'db.StoredProcedure'):
selection_type = s.type
selection_db_type = s.type
object_selected = True
object_selected_count += 1
if s.type == 'db.Table':
unique_tables.add(s.name)
elif s.type in ('db.Index', 'db.Trigger'):
selection_type = s.type
object_selected = False
elif s.type == ('db.Column'):
selection_type = s.type
if s.owner:
unique_tables.add(s.owner.name)
selection_type = s.owner.type+':'+s.type
column_selected = True
else:
print "Unhandled type", s.type
if mixed:
selection_type = None
pass
else:
item = menu.find_item('builtins_separator')
if item:
index = menu.get_item_index(item)+1
else:
index = 0
needs_separator = False
if False and object_selected and selection_type == 'db.Table':
item = mforms.newMenuItem(_("Export Data to CSV File..."))
item.set_name("export_table_csv")
menu.insert_item(index-1, item)
index += 1
item = mforms.newMenuItem(_("Import Data from CSV File..."))
item.set_name("import_table_csv")
menu.insert_item(index-1, item)
index += 1
item = mforms.newMenuItem(_("Dump Data to SQL File..."))
item.set_name("dump_table")
menu.insert_item(index-1, item)
index += 1
if object_selected or column_selected:
# Add menu items for generating code
code_items = [
# Caption, callback name, supported node types, enable condition, mixed node types allowed
(_("Name"), 'name_short', ['db.Schema'], len(selection) > 0, False),
(_("Name (short)"), 'name_short', ['tables', 'views', 'functions', 'storedProcedures', 'db.Table', 'db.Table:db.Column', 'db.View:db.Column', 'db.View', 'db.StoredProcedure', 'db.Function'], len(selection) > 0, True),
(_("Name (long)"), 'name_long', ['tables', 'views', 'functions', 'storedProcedures', 'db.Table', 'db.Table:db.Column', 'db.View:db.Column', 'db.View', 'db.StoredProcedure', 'db.Function'], len(selection) > 0, True),
(_("Select All Statement"), 'select_all_statement', ['db.Table', 'db.View'], len(selection) > 0, False),
(_("Select All Statement"), 'select_all_statement', ['columns'], len(selection) == 1 and selection[0].type == 'columns', False),
(_("Select Columns Statement"), 'select_columns_statement', ['db.Table:db.Column', 'db.View:db.Column'], len(unique_tables) == 1, False),
(_("Insert Statement"), 'insert_all_statement', ['db.Table', 'columns'], len(selection) > 0, False),
(_("Insert Statement"), 'insert_columns_statement', ['db.Table:db.Column'], len(selection) > 0, False),
(_("Update Statement"), 'update_all_statement', ['db.Table', 'columns'], len(selection) > 0, False),
(_("Update Statement"), 'update_columns_statement', ['db.Table:db.Column'], len(selection) > 0, False),
(_("Delete Statement"), 'delete_statement', ['db.Table'], len(selection) > 0, False),
(_("Create Statement"), 'create_statement', ['db.Schema', 'db.Table', 'db.View', 'db.StoredProcedure', 'db.Function'], len(selection) > 0, False),
(_("Procedure Call"), 'call_procedure', ['db.StoredProcedure'], len(selection) > 0, False),
(_("Function Call"), 'call_function', ['db.Function'], len(selection) > 0, False),
(None, None, ['db.Table'], None, False),
(_("Join Selected Tables"), 'build_joined_select', ['db.Table'], len(selection) == 2, False),
(_("Delete with References"), 'build_cascaded_delete', ['db.Table'], len(selection) == 1, False),
(_("Select Row References"), 'build_cascaded_select', ['db.Table'], len(selection) == 1, False),
]
copy_submenu = mforms.newMenuItem("Copy to Clipboard")
copy_submenu.set_name("copy_to_clipboard")
menu.insert_item(index, copy_submenu)
index += 1
send_submenu = mforms.newMenuItem("Send to SQL Editor")
send_submenu.set_name("send_to_editor")
menu.insert_item(index, send_submenu)
index += 1
gencopy = CodeGenerator(sender, selection, False)
gensend = CodeGenerator(sender, selection, True)
for caption, name, types, enabled, allow_mixed in code_items:
if not allow_mixed and mixed:
continue
if types and selection_type not in types:
continue
if caption is None:
copy_submenu.add_separator()
send_submenu.add_separator()
else:
item = copy_submenu.add_item_with_title(caption, getattr(gencopy, name), name)
item.set_enabled(enabled)
item = send_submenu.add_item_with_title(caption, getattr(gensend, name), name)
item.set_enabled(enabled)
needs_separator = True
else:
needs_separator = False
if selection_type in ('tables', 'views', 'functions', 'storedProcedures', 'db.Schema', 'db.Table', 'db.View', 'db.Function', 'db.StoredProcedure') and len(selection) == 1:
if needs_separator:
menu.insert_item(index, mforms.newMenuItem("", mforms.SeparatorMenuItem))
index += 1
needs_separator = False
item = mforms.newMenuItem("Create %s..." % object_type_caption.get(selection_db_type, selection_db_type))
item.add_clicked_callback(lambda: do_create_object(sender, selection[0].schemaName, selection_db_type))
menu.insert_item(index, item)
index+= 1
if selection_type in ('db.Table', 'tables'):
item = mforms.newMenuItem("Create Table Like...")
menu.insert_item(index, item)
index += 1
# it = item.add_item_with_title("Selected Table", lambda: template_manager.create_table_like(sender, selection[0].schemaName, selection[0].name))
# if selection[0].type == 'tables':
# it.set_enabled(False)
for templ in template_manager.templates:
it = item.add_item_with_title(templ.name, lambda templ=templ, schema=selection[0].schemaName: template_manager.create_table_like_template(sender, schema, templ))
item.add_separator()
it = item.add_item_with_title("Edit Templates...", template_manager.edit_templates)
if object_selected:
if needs_separator:
menu.insert_item(index, mforms.newMenuItem("", mforms.SeparatorMenuItem))
index += 1
needs_separator = False
if object_selected_count == 1:
item = mforms.newMenuItem("Alter %s..." % object_type_caption.get(selection_type, selection_type))
else:
item = mforms.newMenuItem("Alter %i %s..." % (object_selected_count, object_type_caption.get(selection_type, selection_type)))
item.add_clicked_callback(lambda: do_alter_object(sender, selection))
menu.insert_item(index, item)
index+= 1
needs_separator = True
if selection_type == 'db.Table' and object_selected:
item = mforms.newMenuItem("Table Maintenance...")
item.add_clicked_callback(lambda: show_schema_manager(sender, set([obj.schemaName for obj in selection]), True))
menu.insert_item(index, item)
index += 1
if object_selected: # or selection_type in ('db.Index', 'db.Trigger'): <-- enable this once we support selective refresh of LST on drop of these objects
if needs_separator:
menu.insert_item(index, mforms.newMenuItem("", mforms.SeparatorMenuItem))
index += 1
needs_separator = False
if object_selected_count == 1:
item = mforms.newMenuItem("Drop %s..." % object_type_caption.get(selection_type, selection_type))
else:
item = mforms.newMenuItem("Drop %i %s..." % (object_selected_count, object_type_caption.get(selection_type, selection_type)))
item.add_clicked_callback(lambda: do_drop_object(sender, selection))
menu.insert_item(index, item)
index+= 1
if selection_type == 'db.Table' and object_selected:
item = mforms.newMenuItem("Truncate %s..." % ("Table" if object_selected_count == 1 else "%i Tables" % object_selected_count))
item.add_clicked_callback(lambda: do_truncate_table(sender, selection))
menu.insert_item(index, item)
index += 1
if selection_type in ('db.Table', 'db.Schema', 'tables'):
item = mforms.newMenuItem("Search Table Data...")
item.add_clicked_callback(lambda: open_search(sender))
insert_item_to_plugin_context_menu(menu, item)
return None
except NoDriverInConnection, exc:
Utilities.show_error('Missing connection driver', str(exc), 'OK',
'', '')
app.set_status_text("Could not Open WB Admin")
return None
except Exception, exc:
import traceback
traceback.print_exc()
Utilities.show_error("Error Starting Workbench Administrator",
"%s: %s" % (type(exc).__name__, exc), "OK",
"", "")
app.set_status_text("Could not Open WB Admin")
return None
dp = mforms.fromgrt(self.editor.dockingPoint)
dp.dock_view(self.admin_tab, "", 0)
dp.select_view(self.admin_tab)
self.admin_tab.set_title("Administrator")
return self.admin_tab
def become_active_tab(self):
dp = mforms.fromgrt(self.editor.dockingPoint)
dp.select_view(self.admin_tab)
def _sidebar_entry_clicked(self, entry_id):
if entry_id == "configure":
openConnectionSettings(self.editor)
else:
if entry_id in self.disabled_pages:
def become_active_tab(self):
dp = mforms.fromgrt(self.editor.dockingPoint)
dp.select_view(self.admin_tab)
