1504 lines
42 KiB
Java
1504 lines
42 KiB
Java
package org.gcube.portlets.user.databasesmanager.client.panels;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.gcube.portlets.user.databasesmanager.client.GWTdbManagerServiceAsync;
|
|
import org.gcube.portlets.user.databasesmanager.client.datamodel.FileModel;
|
|
import org.gcube.portlets.user.databasesmanager.client.datamodel.Result;
|
|
import org.gcube.portlets.user.databasesmanager.client.datamodel.Row;
|
|
import org.gcube.portlets.user.databasesmanager.client.datamodel.SubmitQueryData;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.RandomSamplingEvent;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.SamplingEvent;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.SelectedItemEvent;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.ShowCreateTableEvent;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.SmartSamplingEvent;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.SubmitQueryEvent;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.RandomSamplingEventHandler;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SamplingEventHandler;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SelectedItemEventHandler;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.ShowCreateTableEventHandler;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SmartSamplingEventHandler;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SubmitQueryEventHandler;
|
|
import org.gcube.portlets.user.databasesmanager.client.toolbar.GxtToolbarFunctionality;
|
|
import org.gcube.portlets.user.databasesmanager.client.utils.ConstantsPortlet;
|
|
import com.extjs.gxt.ui.client.Style.LayoutRegion;
|
|
import com.extjs.gxt.ui.client.Style.Scroll;
|
|
import com.extjs.gxt.ui.client.store.ListStore;
|
|
import com.extjs.gxt.ui.client.util.Margins;
|
|
import com.extjs.gxt.ui.client.widget.ContentPanel;
|
|
import com.extjs.gxt.ui.client.widget.Dialog;
|
|
import com.extjs.gxt.ui.client.widget.LayoutContainer;
|
|
import com.extjs.gxt.ui.client.widget.MessageBox;
|
|
import com.extjs.gxt.ui.client.widget.form.TextField;
|
|
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
|
|
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
|
|
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
|
|
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
|
|
import com.extjs.gxt.ui.client.widget.grid.Grid;
|
|
import com.extjs.gxt.ui.client.widget.layout.BorderLayout;
|
|
import com.extjs.gxt.ui.client.widget.layout.BorderLayoutData;
|
|
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
|
|
import com.extjs.gxt.ui.client.widget.layout.RowData;
|
|
import com.google.gwt.event.shared.HandlerManager;
|
|
import com.google.gwt.user.client.Window;
|
|
import com.google.gwt.user.client.rpc.AsyncCallback;
|
|
import com.extjs.gxt.ui.client.event.Listener;
|
|
import com.extjs.gxt.ui.client.event.MessageBoxEvent;
|
|
|
|
public class GxtBorderLayoutPanel extends ContentPanel {
|
|
|
|
/* Create Root Logger */
|
|
private static Logger rootLogger = Logger.getLogger("GxtBorderLayoutPanel");
|
|
|
|
private ContentPanel north;
|
|
private ContentPanel west;
|
|
private LayoutContainer center;
|
|
private ContentPanel centerUpper;
|
|
private ContentPanel centerBottom;
|
|
private GxtTreePanel treePanel;
|
|
private GxtToolbarFunctionality toolbar;
|
|
private ArrayList<String> parsedList;
|
|
|
|
private List<String> listAttributes;
|
|
private List<Row> rows;
|
|
|
|
private HandlerManager eventBus = null;
|
|
|
|
// RPC service
|
|
private GWTdbManagerServiceAsync RPCservice = null;
|
|
|
|
// variable that keeps track of the managed event
|
|
private boolean submitQueryEventManaged = false;
|
|
|
|
public GxtBorderLayoutPanel(HandlerManager eBus,
|
|
GWTdbManagerServiceAsync service) throws Exception {
|
|
|
|
eventBus = eBus;
|
|
RPCservice = service;
|
|
|
|
north = new ContentPanel();
|
|
west = new ContentPanel();
|
|
center = new LayoutContainer();
|
|
treePanel = new GxtTreePanel(eventBus, service);
|
|
toolbar = new GxtToolbarFunctionality(eventBus, RPCservice);
|
|
|
|
initLayout();
|
|
createLayouts();
|
|
|
|
addHandler();
|
|
|
|
}
|
|
|
|
private void initLayout() {
|
|
|
|
north.setLayout(new FitLayout());
|
|
north.setTopComponent(toolbar.getToolBar());
|
|
north.add(toolbar.getToolBar());
|
|
|
|
west.setLayout(new FitLayout());
|
|
west.setHeading("Databases Resources");
|
|
|
|
west.add(treePanel);
|
|
west.setScrollMode(Scroll.AUTO);
|
|
|
|
center.setLayout(new BorderLayout());
|
|
|
|
}
|
|
|
|
public void createLayouts() {
|
|
|
|
// Border layout for the external container
|
|
final BorderLayout borderLayoutNordWest = new BorderLayout();
|
|
setLayout(borderLayoutNordWest);
|
|
|
|
// NORD
|
|
BorderLayoutData northData = new BorderLayoutData(LayoutRegion.NORTH,
|
|
55, 55, 70);
|
|
|
|
northData.setSplit(false); // Split bar between regions
|
|
// northData.setFloatable(true);
|
|
// northData.setCollapsible(true);
|
|
// northData.setHideCollapseTool(false);
|
|
// northData.setSplit(true);
|
|
northData.setMargins(new Margins(0, 0, 1, 0));
|
|
|
|
// WEST
|
|
BorderLayoutData westData = new BorderLayoutData(LayoutRegion.WEST,
|
|
330, 330, 400);
|
|
westData.setSplit(true);
|
|
westData.setCollapsible(true);
|
|
westData.setMargins(new Margins(0, 1, 0, 0));
|
|
|
|
// CENTER
|
|
|
|
BorderLayoutData centerData = new BorderLayoutData(LayoutRegion.CENTER);
|
|
centerData.setMargins(new Margins(0));
|
|
// center.setHeading("Information");
|
|
centerData.setSplit(true);
|
|
centerData.setCollapsible(true);
|
|
|
|
// CENTER UPPER
|
|
|
|
centerUpper = new ContentPanel();
|
|
centerUpper.setLayout(new FitLayout());
|
|
centerUpper.setHeading("Database Information");
|
|
centerUpper.setScrollMode(Scroll.NONE);
|
|
|
|
// CENTER BOTTOM
|
|
|
|
centerBottom = new ContentPanel();
|
|
centerBottom.setLayout(new FitLayout());
|
|
centerBottom.setHeading("Information Details");
|
|
centerBottom.setScrollMode(Scroll.NONE);
|
|
|
|
BorderLayoutData centerUpperData = new BorderLayoutData(
|
|
LayoutRegion.NORTH, 250, 100, 250);
|
|
|
|
centerUpperData.setSplit(true); // Split bar between regions
|
|
// northData.setFloatable(true);
|
|
centerUpperData.setCollapsible(false);
|
|
// northData.setHideCollapseTool(false);
|
|
// northData.setSplit(true);
|
|
centerUpperData.setMargins(new Margins(0, 0, 1, 0));
|
|
|
|
// BorderLayoutData centerBottomData = new
|
|
// BorderLayoutData(LayoutRegion.CENTER,
|
|
// 50, 30, 50);
|
|
|
|
BorderLayoutData centerBottomData = new BorderLayoutData(
|
|
LayoutRegion.CENTER);
|
|
centerBottomData.setSplit(true);
|
|
centerBottomData.setCollapsible(false);
|
|
centerBottomData.setMargins(new Margins(0));
|
|
// centerBottomData.setMargins(new Margins(1, 0, 0, 0));
|
|
|
|
// to add the central panels to the second container
|
|
center.add(centerUpper, centerUpperData);
|
|
center.add(centerBottom, centerBottomData);
|
|
|
|
add(north, northData);
|
|
add(west, westData);
|
|
add(center, centerData);
|
|
// add(east, eastData);
|
|
|
|
}
|
|
|
|
private void addHandler() {
|
|
|
|
eventBus.addHandler(SelectedItemEvent.TYPE,
|
|
new SelectedItemEventHandler() {
|
|
|
|
public void onSelectedItem(
|
|
SelectedItemEvent selectedItemEvent) {
|
|
|
|
centerBottom.removeAll();
|
|
centerBottom.layout(true);
|
|
|
|
// System.out
|
|
// .println("GxtBorderLayoutPanel: Event received");
|
|
|
|
rootLogger.log(Level.SEVERE, "Event received");
|
|
|
|
int DepthSelectedItem = treePanel
|
|
.getTreeDepthSelectedItem();
|
|
|
|
// System.out.println("GxtBorderLayoutPanel-> Depth: "
|
|
// + DepthSelectedItem);
|
|
|
|
// element name selected
|
|
String text = treePanel.getValue();
|
|
|
|
// System.out
|
|
// .println("GxtBorderLayoutPanel-> item selected: "
|
|
// + text);
|
|
|
|
rootLogger.log(Level.INFO, "item selected: " + text);
|
|
|
|
toolbar.disableButtonOnToolbar(DepthSelectedItem,
|
|
treePanel.getSelectedItemIsSchema());
|
|
|
|
if (DepthSelectedItem != 3) {
|
|
|
|
centerUpper.removeAll();
|
|
|
|
centerUpper.layout(true);
|
|
|
|
}
|
|
|
|
List<FileModel> data = treePanel.getTreePanel()
|
|
.getSelectionModel().getSelectedItems();
|
|
|
|
FileModel selectedItem = data.get(0);
|
|
|
|
if (DepthSelectedItem == 3) { // the item selected is a
|
|
// database.
|
|
|
|
// show database information in the panel
|
|
|
|
// List<FileModel> data = treePanel.getTreePanel()
|
|
// .getSelectionModel().getSelectedItems();
|
|
// FileModel selectedItem = data.get(0);
|
|
|
|
FileModel parent = treePanel.getTreeStore()
|
|
.getParent(selectedItem);
|
|
|
|
// displayDBInfo(parent);
|
|
|
|
// display information about the selected database
|
|
displayDBInfo(data.get(0));
|
|
|
|
}
|
|
|
|
// display the table name in the right panel when a
|
|
// table is selected
|
|
|
|
if (DepthSelectedItem == 5) {
|
|
|
|
centerUpper.removeAll();
|
|
|
|
centerUpper.addText(data.get(0).getName());
|
|
|
|
centerUpper.layout(true);
|
|
|
|
}
|
|
|
|
if ((DepthSelectedItem == 4)
|
|
&& (data.get(0).isSchema() == false)) {
|
|
|
|
centerUpper.removeAll();
|
|
|
|
centerUpper.addText(data.get(0).getName());
|
|
|
|
centerUpper.layout(true);
|
|
|
|
}
|
|
|
|
// System.out
|
|
// .println("GxtBorderLayoutPanel: Event finished");
|
|
|
|
rootLogger.log(Level.SEVERE, "Event finished");
|
|
|
|
}
|
|
|
|
});
|
|
|
|
eventBus.addHandler(SubmitQueryEvent.TYPE,
|
|
new SubmitQueryEventHandler() {
|
|
|
|
@Override
|
|
public void onSubmitQuery(SubmitQueryEvent submitQueryEvent) {
|
|
// TODO Auto-generated method stub
|
|
|
|
// try {
|
|
// submitQuery();
|
|
// } catch (Exception e) {
|
|
// // TODO Auto-generated catch block
|
|
// e.printStackTrace();
|
|
// }
|
|
|
|
submitQuery();
|
|
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(SamplingEvent.TYPE, new SamplingEventHandler() {
|
|
|
|
@Override
|
|
public void onSampling(SamplingEvent samplingEvent) {
|
|
// TODO Auto-generated method stub
|
|
|
|
sample();
|
|
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(SmartSamplingEvent.TYPE,
|
|
new SmartSamplingEventHandler() {
|
|
|
|
@Override
|
|
public void onSmartSampling(
|
|
SmartSamplingEvent smartSamplingEvent) {
|
|
// TODO Auto-generated method stub
|
|
|
|
smartSample();
|
|
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(RandomSamplingEvent.TYPE,
|
|
new RandomSamplingEventHandler() {
|
|
|
|
@Override
|
|
public void onRandomSampling(
|
|
RandomSamplingEvent randomSamplingEvent) {
|
|
// TODO Auto-generated method stub
|
|
|
|
randomSample();
|
|
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(ShowCreateTableEvent.TYPE,
|
|
new ShowCreateTableEventHandler() {
|
|
|
|
@Override
|
|
public void onShowCreateTable(
|
|
ShowCreateTableEvent showCreateTableEvent) {
|
|
// TODO Auto-generated method stub
|
|
|
|
// get the selected table
|
|
|
|
List<FileModel> data = treePanel.getTreePanel()
|
|
.getSelectionModel().getSelectedItems();
|
|
|
|
// the selected item is a table
|
|
FileModel selectedTable = data.get(0);
|
|
|
|
rootLogger.log(Level.INFO, "the selected table is: "
|
|
+ selectedTable);
|
|
|
|
getTableDetails(selectedTable);
|
|
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
private void submitQuery() {
|
|
|
|
// System.out.println("Start RPC - submitQuery");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - submitQuery");
|
|
|
|
// variable that keeps track of the managed event
|
|
submitQueryEventManaged = false;
|
|
|
|
// recover input data
|
|
|
|
LinkedHashMap<String, String> dataDB = treePanel
|
|
.getInfoOnSelectedItem();
|
|
|
|
final SubmitQueryData dataQuery = toolbar.getSubmitQueryData();
|
|
|
|
// RPCservice.submitQuery(dataDB, dataQuery.getQuery(),
|
|
// dataQuery.getReadOnlyQuery(), dataQuery.getSmartCorrection(),
|
|
// dataQuery.getLanguage(), new AsyncCallback<List<Result>>() {
|
|
|
|
// force the "true" value for the readonly input.
|
|
|
|
// determine the language
|
|
List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
|
|
.getSelectedItems();
|
|
FileModel selectedItem = data.get(0);
|
|
|
|
String dialect;
|
|
|
|
if (selectedItem.isDatabase()) { // the selected item is a database
|
|
|
|
// System.out.println("the selected item is a database");
|
|
rootLogger.log(Level.INFO, "the selected item is a database");
|
|
|
|
// determine the dialect recovering the dialect
|
|
dialect = selectedItem.getDBInfo().get(2).getValue();
|
|
|
|
rootLogger.log(Level.INFO,
|
|
"determined Dialect for smart correction: " + dialect);
|
|
|
|
} else {
|
|
FileModel parent1 = treePanel.getTreeStore()
|
|
.getParent(selectedItem);
|
|
|
|
if (parent1.isDatabase()) { // the selected item is a schema
|
|
|
|
// System.out.println("the selected item is a schema");
|
|
|
|
rootLogger.log(Level.INFO, "the selected item is a schema");
|
|
|
|
// determine the dialect recovering the dialect
|
|
dialect = parent1.getDBInfo().get(2).getValue();
|
|
|
|
rootLogger.log(Level.INFO,
|
|
"determined Dialect for smart correction: " + dialect);
|
|
|
|
}
|
|
|
|
else { // the selected item is a table
|
|
|
|
// System.out.println("the selected item is a table");
|
|
|
|
rootLogger.log(Level.INFO, "the selected item is a table");
|
|
|
|
FileModel parent2 = treePanel.getTreeStore().getParent(parent1);
|
|
|
|
// determine the dialect recovering the dialect
|
|
dialect = parent2.getDBInfo().get(2).getValue();
|
|
|
|
rootLogger.log(Level.INFO,
|
|
"determined Dialect for smart correction: " + dialect);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
String language = ConstantsPortlet.NONE;
|
|
|
|
if (dialect.toUpperCase().contains(ConstantsPortlet.POSTGRES)) {
|
|
|
|
language = ConstantsPortlet.POSTGRES;
|
|
}
|
|
|
|
if (dialect.toUpperCase().contains(ConstantsPortlet.MYSQL)) {
|
|
|
|
language = ConstantsPortlet.MYSQL;
|
|
}
|
|
|
|
rootLogger.log(Level.INFO, "Dialect used for smart correction: "
|
|
+ language);
|
|
|
|
RPCservice.submitQuery(dataDB, dataQuery.getQuery(), true,
|
|
dataQuery.getSmartCorrection(), language,
|
|
new AsyncCallback<List<Result>>() {
|
|
|
|
// // TO REMOVE data "true" and "POSTGRES"
|
|
// RPCservice.submitQuery(dataDB, dataQuery.getQuery(),
|
|
// true,
|
|
// dataQuery.getSmartCorrection(), "POSTGRES",
|
|
// new AsyncCallback<List<Result>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
// Window.alert(caught.getMessage());
|
|
|
|
// System.out.println("FAILURE submitQuery");
|
|
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC submitQuery");
|
|
|
|
Listener<MessageBoxEvent> l = new Listener<MessageBoxEvent>() {
|
|
public void handleEvent(MessageBoxEvent ce) {
|
|
// Button btn = ce.getButtonClicked();
|
|
// Info.display("MessageBox",
|
|
// "The '{0}' button was pressed",
|
|
// btn.getHtml());
|
|
|
|
// Button btn = ce.getButtonClicked();
|
|
|
|
Dialog form = toolbar.getDialogForm();
|
|
|
|
if (form.isMasked())
|
|
form.unmask();
|
|
|
|
}
|
|
};
|
|
|
|
// MessageBox.alert("Error "," <br/>Cause:"+caught.getCause()+"<br/>Message:"+caught.getMessage(),
|
|
// l);
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), l);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<Result> result) {
|
|
// TODO Auto-generated method stub
|
|
|
|
// System.out.println("SUCCESS submitQuery");
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC submitQuery");
|
|
|
|
rows = new ArrayList<Row>();
|
|
|
|
// System.out.println("result size: " + result.size());
|
|
|
|
rootLogger.log(Level.SEVERE,
|
|
"output size: " + result.size());
|
|
|
|
// recover query
|
|
// Result query = result.remove(0);
|
|
|
|
// recover converted query
|
|
Result convertedQuery;
|
|
|
|
if (dataQuery.getSmartCorrection() == true) {
|
|
|
|
result.remove(0);
|
|
// convertedQuery = result.get(1);
|
|
|
|
}
|
|
|
|
// get the attributes list for the result table
|
|
getListAttributes(result.get(0).getValue());
|
|
|
|
// remove the header in order to parse only the result
|
|
result.remove(0);
|
|
|
|
// variable that keeps track of the managed event
|
|
submitQueryEventManaged = true;
|
|
|
|
// parse the result in order to obtain a table
|
|
parseResult(result);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
private void sample() {
|
|
|
|
// to mask the entire content panel
|
|
|
|
this.mask("Loading", "x-mask-loading");
|
|
|
|
// System.out.println("Start RPC - submitQuery");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - sample");
|
|
|
|
// get the selected table
|
|
|
|
List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
|
|
.getSelectedItems();
|
|
|
|
// the selected item is a table
|
|
FileModel selectedItem = data.get(0);
|
|
|
|
rootLogger.log(Level.INFO, "the selected table is: " + selectedItem.getName());
|
|
|
|
// recover data inputs
|
|
|
|
LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
|
|
|
|
// check if the table has an associated schema
|
|
FileModel schema;
|
|
FileModel database;
|
|
FileModel resource;
|
|
|
|
if (treePanel.getTreeStore().getParent(selectedItem).isDatabase()) {
|
|
|
|
// the table has not a schema
|
|
|
|
database = treePanel.getTreeStore().getParent(selectedItem);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", "");
|
|
dataInput.put("TableName", selectedItem.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
// schema = treePanel.getTreeStore().getParent(selectedItem);
|
|
// database = treePanel.getTreeStore().getParent(schema);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", schema.getName());
|
|
// dataInput.put("TableName", selectedItem.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
} else {
|
|
//the table has a schema
|
|
|
|
schema = treePanel.getTreeStore().getParent(selectedItem);
|
|
database = treePanel.getTreeStore().getParent(schema);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", schema.getName());
|
|
dataInput.put("TableName", selectedItem.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
// the table has not a schema
|
|
// database = treePanel.getTreeStore().getParent(selectedItem);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", "");
|
|
// dataInput.put("TableName", selectedItem.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
}
|
|
|
|
// call remote service
|
|
|
|
RPCservice.sample(dataInput, new AsyncCallback<List<Result>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
// Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE");
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC sample");
|
|
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), null);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<Result> result) {
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC sample");
|
|
|
|
rows = new ArrayList<Row>();
|
|
|
|
// System.out.println("result size: " + result.size());
|
|
|
|
rootLogger.log(Level.SEVERE, "output size: " + result.size());
|
|
|
|
// get the attributes list for the result table
|
|
getListAttributes(result.get(0).getValue());
|
|
|
|
// remove the header in order to parse only the result
|
|
result.remove(0);
|
|
|
|
// parse the result in order to obtain a table
|
|
parseResult(result);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
private void smartSample() {
|
|
|
|
// to mask the entire content panel
|
|
|
|
this.mask("Loading", "x-mask-loading");
|
|
|
|
// System.out.println("Start RPC - submitQuery");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - smartSample");
|
|
|
|
// get the selected table
|
|
|
|
List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
|
|
.getSelectedItems();
|
|
|
|
// the selected item is a table
|
|
FileModel selectedItem = data.get(0);
|
|
|
|
rootLogger.log(Level.INFO, "the selected table is: " + selectedItem);
|
|
|
|
// recover data inputs for the algorithm
|
|
|
|
LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
|
|
|
|
// check if the table has an associated schema
|
|
FileModel schema;
|
|
FileModel database;
|
|
FileModel resource;
|
|
|
|
if (treePanel.getTreeStore().getParent(selectedItem).isDatabase()) { //the table has not a schema
|
|
|
|
database = treePanel.getTreeStore().getParent(selectedItem);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", "");
|
|
dataInput.put("TableName", selectedItem.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
|
|
// schema = treePanel.getTreeStore().getParent(selectedItem);
|
|
// database = treePanel.getTreeStore().getParent(schema);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", schema.getName());
|
|
// dataInput.put("TableName", selectedItem.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
} else {
|
|
// the table has a schema
|
|
|
|
|
|
schema = treePanel.getTreeStore().getParent(selectedItem);
|
|
database = treePanel.getTreeStore().getParent(schema);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", schema.getName());
|
|
dataInput.put("TableName", selectedItem.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
// database = treePanel.getTreeStore().getParent(selectedItem);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", "");
|
|
// dataInput.put("TableName", selectedItem.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
}
|
|
|
|
// call remote service
|
|
|
|
RPCservice.smartSample(dataInput, new AsyncCallback<List<Result>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
// Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE");
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC smartSample");
|
|
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), null);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<Result> result) {
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC smartSample");
|
|
|
|
rows = new ArrayList<Row>();
|
|
|
|
// System.out.println("result size: " + result.size());
|
|
|
|
rootLogger.log(Level.SEVERE, "output size: " + result.size());
|
|
|
|
// get the attributes list for the result table
|
|
getListAttributes(result.get(0).getValue());
|
|
|
|
// remove the header in order to parse only the result
|
|
result.remove(0);
|
|
|
|
// parse the result in order to obtain a table
|
|
parseResult(result);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
private void randomSample() {
|
|
// to mask the entire content panel
|
|
|
|
this.mask("Loading", "x-mask-loading");
|
|
|
|
// System.out.println("Start RPC - submitQuery");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - randomSample");
|
|
|
|
// get the selected table
|
|
|
|
List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
|
|
.getSelectedItems();
|
|
|
|
// the selected item is a table
|
|
FileModel selectedItem = data.get(0);
|
|
|
|
rootLogger.log(Level.INFO, "the selected table is: " + selectedItem);
|
|
|
|
// recover data inputs for the algorithm
|
|
|
|
LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
|
|
|
|
// check if the table has an associated schema
|
|
FileModel schema;
|
|
FileModel database;
|
|
FileModel resource;
|
|
|
|
if (treePanel.getTreeStore().getParent(selectedItem).isDatabase()) { //the has not a schema
|
|
|
|
database = treePanel.getTreeStore().getParent(selectedItem);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", "");
|
|
dataInput.put("TableName", selectedItem.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
// schema = treePanel.getTreeStore().getParent(selectedItem);
|
|
// database = treePanel.getTreeStore().getParent(schema);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", schema.getName());
|
|
// dataInput.put("TableName", selectedItem.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
} else {
|
|
|
|
//the table has a schema
|
|
|
|
schema = treePanel.getTreeStore().getParent(selectedItem);
|
|
database = treePanel.getTreeStore().getParent(schema);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", schema.getName());
|
|
dataInput.put("TableName", selectedItem.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
|
|
|
|
// // the table has not a schema
|
|
// database = treePanel.getTreeStore().getParent(selectedItem);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", "");
|
|
// dataInput.put("TableName", selectedItem.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + selectedItem.getName());
|
|
}
|
|
|
|
// call remote service
|
|
|
|
RPCservice.randomSample(dataInput, new AsyncCallback<List<Result>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
// Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE");
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC randomSample");
|
|
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), null);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<Result> result) {
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC randomSample");
|
|
|
|
rows = new ArrayList<Row>();
|
|
|
|
// System.out.println("result size: " + result.size());
|
|
|
|
rootLogger.log(Level.SEVERE, "output size: " + result.size());
|
|
|
|
// get the attributes list for the result table
|
|
getListAttributes(result.get(0).getValue());
|
|
|
|
// remove the header in order to parse only the result
|
|
result.remove(0);
|
|
|
|
// parse the result in order to obtain a table
|
|
parseResult(result);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
}
|
|
|
|
// start the parsing of the submit result in order to obtain a table
|
|
private void parseResult(List<Result> result) {
|
|
|
|
// if (this.isMasked()) {
|
|
// this.unmask();
|
|
// }
|
|
|
|
// to unmask the entire content panel
|
|
final GxtBorderLayoutPanel obj = this;
|
|
|
|
RPCservice.parseCVSString(result, listAttributes,
|
|
new AsyncCallback<List<Row>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
// TODO Auto-generated method stub
|
|
|
|
Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE StartParse");
|
|
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC parseResult");
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<Row> rows) {
|
|
|
|
// System.out.println("Success StartParse");
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC parseResult");
|
|
|
|
if (submitQueryEventManaged == true) {
|
|
|
|
Dialog form = toolbar.getDialogForm();
|
|
|
|
if (form.isMasked())
|
|
form.unmask();
|
|
|
|
form.hide();
|
|
|
|
}
|
|
|
|
// else {
|
|
|
|
if (rows != null) {
|
|
|
|
// Dialog form = toolbar.getDialogForm();
|
|
//
|
|
// if (form.isMasked())
|
|
// form.unmask();
|
|
//
|
|
// form.hide();
|
|
|
|
// Display the submit query result as a table
|
|
Dialog submitResult = new Dialog();
|
|
submitResult.setLayout(new FitLayout());
|
|
submitResult.setHeading("Result");
|
|
|
|
submitResult.setResizable(false);
|
|
// submitResult.setHeading("Submit Query");
|
|
// submitResult.setWidth(290);
|
|
// submitResult.setHeight(250);
|
|
|
|
submitResult.setModal(true);
|
|
submitResult.setBlinkModal(true);
|
|
|
|
// submitResult.setBodyStyle("padding:9px;");
|
|
submitResult.setSize(600, 400);
|
|
// submitResult.setScrollMode(Scroll.AUTO);
|
|
submitResult.setScrollMode(Scroll.NONE);
|
|
submitResult.setHideOnButtonClick(true);
|
|
|
|
submitResult.setMaximizable(true);
|
|
// submitResult.addText("Result Table");
|
|
|
|
ListStore<Row> store = new ListStore<Row>();
|
|
store.add(rows);
|
|
|
|
Grid<Row> grid;
|
|
|
|
grid = new Grid<Row>(store, createColumnModel());
|
|
|
|
// grid.setAutoExpandColumn("value");
|
|
grid.setBorders(true);
|
|
|
|
// grid.setAutoWidth(true);
|
|
|
|
RowData data = new RowData(.5, 1);
|
|
data.setMargins(new Margins(6));
|
|
|
|
submitResult.add(grid, data);
|
|
|
|
submitResult.show();
|
|
|
|
}
|
|
// }
|
|
|
|
if (obj.isMasked()) {
|
|
obj.unmask();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
// private void updateListRow(Row row){
|
|
//
|
|
//
|
|
//
|
|
// rows.add(row);
|
|
//
|
|
// System.out.println("CHECK size2: " + rows.size());
|
|
//
|
|
//
|
|
// }
|
|
|
|
// private void returnParsedeList(List<String> result) {
|
|
//
|
|
// parsedList = new ArrayList<String>();
|
|
// for (String s : result) {
|
|
//
|
|
// System.out.println("value: " + result);
|
|
// parsedList.add(s);
|
|
// }
|
|
//
|
|
// System.out.println("size row1: " + result.size());
|
|
//
|
|
// }
|
|
|
|
private void getListAttributes(String value) {
|
|
|
|
// recover attribute fields fo the result table
|
|
String headers = value;
|
|
|
|
// System.out.println("headers: " + headers);
|
|
|
|
rootLogger.log(Level.INFO, "Headers fields table: " + headers);
|
|
|
|
listAttributes = parseAttributesTableResult(headers);
|
|
|
|
// System.out.println("attributes number: " + listAttributes.size());
|
|
|
|
rootLogger.log(Level.INFO,
|
|
"attributes number: " + listAttributes.size());
|
|
|
|
rootLogger.log(Level.INFO, "attributes list: ");
|
|
|
|
for (int i = 0; i < listAttributes.size(); i++) {
|
|
|
|
// System.out.println(listAttributes.get(i));
|
|
|
|
rootLogger.log(Level.INFO, "attribute: " + listAttributes.get(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private ColumnModel createColumnModel() {
|
|
|
|
List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
|
|
ColumnConfig column;
|
|
|
|
column = new ColumnConfig();
|
|
|
|
column.setId("index");
|
|
column.setHeader("Index");
|
|
column.setWidth(100);
|
|
column.setSortable(false);
|
|
|
|
configs.add(column);
|
|
|
|
for (int i = 0; i < listAttributes.size(); i++) {
|
|
|
|
// System.out.println("attribute: " + listAttributes.get(i));
|
|
rootLogger.log(Level.INFO, "attribute: " + listAttributes.get(i));
|
|
column = new ColumnConfig();
|
|
column.setId(listAttributes.get(i));
|
|
// column.setId("\"" + fields.get(i) + "\"");
|
|
column.setHeader(listAttributes.get(i));
|
|
column.setWidth(100);
|
|
column.setSortable(false);
|
|
|
|
configs.add(column);
|
|
|
|
}
|
|
|
|
return new ColumnModel(configs);
|
|
}
|
|
|
|
// private String[] parseAttributesTableResult(String value) {
|
|
//
|
|
// System.out.println("parsing attributes table");
|
|
//
|
|
// String todelete = "[,]";
|
|
//
|
|
// value = value.replaceAll(todelete, " ");
|
|
// value = value.replaceAll("[ ]+", " ");
|
|
//
|
|
// String[] tokens = value.split("[ ]");
|
|
// return tokens;
|
|
//
|
|
// }
|
|
|
|
private List<String> parseAttributesTableResult(String phrase) {
|
|
|
|
String delimiter = ",";
|
|
List<String> elements = new ArrayList<String>();
|
|
int idxdelim = -1;
|
|
phrase = phrase.trim();
|
|
|
|
while ((idxdelim = phrase.indexOf(delimiter)) >= 0) {
|
|
|
|
elements.add(phrase.substring(0, idxdelim));
|
|
phrase = phrase.substring(idxdelim + 1).trim();
|
|
|
|
}
|
|
|
|
elements.add(phrase);
|
|
return elements;
|
|
|
|
}
|
|
|
|
private ColumnModel createColumnModelForDBInfo(List<Result> result) {
|
|
|
|
List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
|
|
|
|
ColumnConfig column = new ColumnConfig();
|
|
column.setId("index");
|
|
column.setHeader("Property");
|
|
column.setWidth(100);
|
|
// column1.setSortable(false);
|
|
|
|
TextField<String> textProperty = new TextField<String>();
|
|
// text.setAllowBlank(false);
|
|
column.setEditor(new CellEditor(textProperty));
|
|
|
|
configs.add(column);
|
|
|
|
column = new ColumnConfig();
|
|
column.setId("value");
|
|
column.setHeader("Value");
|
|
column.setWidth(600);
|
|
|
|
// column2.setSortable(false);
|
|
|
|
TextField<String> textValue = new TextField<String>();
|
|
// text.setAllowBlank(false);
|
|
column.setEditor(new CellEditor(textValue));
|
|
|
|
configs.add(column);
|
|
|
|
ListStore<Result> store = new ListStore<Result>();
|
|
store.add(result);
|
|
|
|
return new ColumnModel(configs);
|
|
}
|
|
|
|
private void displayDBInfo(FileModel element) {
|
|
|
|
// System.out.println("GxtBorderLayout->displaying info");
|
|
|
|
rootLogger.log(Level.INFO, "displaying info");
|
|
|
|
// LinkedHashMap<String, FileModel> data = element.getDBInfo();
|
|
|
|
List<Result> dataDB = element.getDBInfo();
|
|
|
|
// System.out.println("GxtBorderLayout->size info: " + dataDB.size());
|
|
|
|
rootLogger.log(Level.INFO, "info size: " + dataDB.size());
|
|
|
|
ListStore<Result> store = new ListStore<Result>();
|
|
store.add(dataDB);
|
|
|
|
// Grid<Result> grid = new Grid<Result>(store,
|
|
// createColumnModelForDBInfo(dataDB));
|
|
|
|
EditorGrid<Result> grid = new EditorGrid<Result>(store,
|
|
createColumnModelForDBInfo(dataDB));
|
|
|
|
// grid.setAutoExpandColumn("name");
|
|
grid.setBorders(true);
|
|
|
|
// grid.setAutoWidth(true);
|
|
|
|
// RowData data = new RowData(.5, 1);
|
|
// data.setMargins(new Margins(6));
|
|
|
|
centerUpper.removeAll();
|
|
|
|
// centerUpper.add(grid, data);
|
|
|
|
centerUpper.add(grid);
|
|
centerUpper.layout(true);
|
|
|
|
}
|
|
|
|
private void getTableDetails(final FileModel selectedTable) {
|
|
|
|
// to mask the entire content panel
|
|
|
|
this.mask("Loading", "x-mask-loading");
|
|
|
|
// to unmask the entire content panel
|
|
final GxtBorderLayoutPanel obj = this;
|
|
|
|
// System.out.println("Start RPC - submitQuery");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - getTableDetails");
|
|
|
|
// // get the selected table
|
|
//
|
|
// List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
|
|
// .getSelectedItems();
|
|
//
|
|
// // the selected item is a table
|
|
// final FileModel selectedTable = data.get(0);
|
|
//
|
|
// rootLogger.log(Level.INFO, "the selected table is: " +
|
|
// selectedTable);
|
|
|
|
// recover data inputs
|
|
|
|
LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
|
|
|
|
// check if the table has an associated schema
|
|
FileModel schema;
|
|
FileModel database;
|
|
FileModel resource;
|
|
|
|
if (treePanel.getTreeStore().getParent(selectedTable).isDatabase()) { //the table has not a schema
|
|
|
|
database = treePanel.getTreeStore().getParent(selectedTable);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", "");
|
|
dataInput.put("TableName", selectedTable.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
rootLogger
|
|
.log(Level.INFO, "SchemaName: " + selectedTable.getName());
|
|
|
|
// schema = treePanel.getTreeStore().getParent(selectedTable);
|
|
// database = treePanel.getTreeStore().getParent(schema);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", schema.getName());
|
|
// dataInput.put("TableName", selectedTable.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
// rootLogger
|
|
// .log(Level.INFO, "SchemaName: " + selectedTable.getName());
|
|
|
|
} else {
|
|
// the table has a schema
|
|
|
|
schema = treePanel.getTreeStore().getParent(selectedTable);
|
|
database = treePanel.getTreeStore().getParent(schema);
|
|
resource = treePanel.getTreeStore().getParent(database);
|
|
|
|
dataInput.put("ResourceName", resource.getName());
|
|
dataInput.put("DatabaseName", database.getName());
|
|
dataInput.put("SchemaName", schema.getName());
|
|
dataInput.put("TableName", selectedTable.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
|
|
rootLogger
|
|
.log(Level.INFO, "SchemaName: " + selectedTable.getName());
|
|
|
|
|
|
// database = treePanel.getTreeStore().getParent(selectedTable);
|
|
// resource = treePanel.getTreeStore().getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
// dataInput.put("SchemaName", "");
|
|
// dataInput.put("TableName", selectedTable.getName());
|
|
//
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
// rootLogger
|
|
// .log(Level.INFO, "SchemaName: " + selectedTable.getName());
|
|
}
|
|
|
|
if (selectedTable.isTableDetailsDisplayed()) {
|
|
|
|
displayTableDetails(selectedTable);
|
|
|
|
} else {
|
|
|
|
// call remote service
|
|
RPCservice.getTableDetails(dataInput,
|
|
new AsyncCallback<LinkedHashMap<String, FileModel>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
// TODO Auto-generated method stub
|
|
|
|
rootLogger.log(Level.SEVERE,
|
|
"FAILURE RPC getTableDetails");
|
|
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), null);
|
|
|
|
if (obj.isMasked()) {
|
|
obj.unmask();
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(
|
|
LinkedHashMap<String, FileModel> result) {
|
|
// TODO Auto-generated method stub
|
|
|
|
rootLogger.log(Level.SEVERE,
|
|
"SUCCESS RPC getTableDetails");
|
|
|
|
// details are recovered about the selected table
|
|
|
|
if (result.size() != 0) {
|
|
|
|
// recover keys from the result
|
|
|
|
Set<String> keys = result.keySet();
|
|
|
|
Object[] array = keys.toArray();
|
|
|
|
// System.out.println("array size: " +
|
|
// array.length);
|
|
|
|
// recover details
|
|
|
|
List<Result> TableDetails = new ArrayList<Result>();
|
|
|
|
for (int i = 0; i < result.size(); i++) {
|
|
|
|
if (array[i].toString().contains(
|
|
"CreateTable")) {
|
|
|
|
// recover the showCreateTable statement
|
|
|
|
Result row = new Result("CreateTable",
|
|
result.get(array[i].toString())
|
|
.getName());
|
|
|
|
TableDetails.add(row);
|
|
|
|
}
|
|
|
|
if (array[i].toString().contains(
|
|
"Column Names")) {
|
|
|
|
// recover the column names
|
|
|
|
Result row = new Result("Column Names",
|
|
result.get(array[i].toString())
|
|
.getName());
|
|
|
|
TableDetails.add(row);
|
|
|
|
}
|
|
|
|
if (array[i].toString().contains(
|
|
"NumberRows")) {
|
|
|
|
// recover the column names
|
|
|
|
Result row = new Result("NumberRows",
|
|
result.get(array[i].toString())
|
|
.getName());
|
|
|
|
TableDetails.add(row);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
selectedTable.setTableDetails(TableDetails);
|
|
|
|
displayTableDetails(selectedTable);
|
|
|
|
selectedTable.setTableDetailsDisplayed(true);
|
|
|
|
}
|
|
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void displayTableDetails(FileModel table) {
|
|
|
|
rootLogger.log(Level.INFO, "displaying table details");
|
|
|
|
List<Result> tableDetails = table.getTableDetails();
|
|
|
|
// System.out.println("GxtBorderLayout->size info: " + dataDB.size());
|
|
|
|
rootLogger.log(Level.INFO, "details size: " + tableDetails.size());
|
|
|
|
ListStore<Result> store = new ListStore<Result>();
|
|
|
|
store.add(tableDetails);
|
|
|
|
// Grid<Result> grid = new Grid<Result>(store,
|
|
// createColumnModelForDBInfo(tableDetails));
|
|
|
|
EditorGrid<Result> grid = new EditorGrid<Result>(store,
|
|
createColumnModelForDBInfo(tableDetails));
|
|
|
|
// grid.setAutoExpandColumn("name");
|
|
grid.setBorders(true);
|
|
|
|
// grid.setAutoWidth(true);
|
|
|
|
// RowData data = new RowData(.5, .1);
|
|
// data.setMargins(new Margins(6));
|
|
|
|
centerBottom.removeAll();
|
|
|
|
// centerBottom.add(grid, data);
|
|
|
|
centerBottom.add(grid);
|
|
centerBottom.layout(true);
|
|
|
|
// to unmask the entire content panel
|
|
|
|
if (this.isMasked()) {
|
|
this.unmask();
|
|
}
|
|
|
|
}
|
|
|
|
}
|