plugins/org.argeo.slc.akb.ui/src/main/java/org/argeo/slc/akb/ui/editors/JdbcTestPage.java

   1 package org.argeo.slc.akb.ui.editors;
   2
   3 import java.sql.PreparedStatement;
   4 import java.sql.ResultSet;
   5 import java.sql.ResultSetMetaData;
   6 import java.sql.SQLException;
   7 import java.util.ArrayList;
   8 import java.util.List;
   9
  10 import javax.jcr.Node;
  11
  12 import org.argeo.security.ui.PrivilegedJob;
  13 import org.argeo.slc.SlcException;
  14 import org.argeo.slc.akb.AkbNames;
  15 import org.argeo.slc.akb.AkbService;
  16 import org.argeo.slc.akb.ui.AkbUiUtils;
  17 import org.eclipse.core.runtime.IProgressMonitor;
  18 import org.eclipse.core.runtime.IStatus;
  19 import org.eclipse.core.runtime.Status;
  20 import org.eclipse.jface.viewers.ColumnLabelProvider;
  21 import org.eclipse.jface.viewers.IContentProvider;
  22 import org.eclipse.jface.viewers.ILazyContentProvider;
  23 import org.eclipse.jface.viewers.TableViewer;
  24 import org.eclipse.jface.viewers.TableViewerColumn;
  25 import org.eclipse.jface.viewers.Viewer;
  26 import org.eclipse.swt.SWT;
  27 import org.eclipse.swt.layout.GridData;
  28 import org.eclipse.swt.widgets.Composite;
  29 import org.eclipse.swt.widgets.Table;
  30 import org.eclipse.ui.forms.IManagedForm;
  31 import org.eclipse.ui.forms.editor.FormEditor;
  32 import org.eclipse.ui.forms.editor.FormPage;
  33 import org.eclipse.ui.forms.widgets.FormToolkit;
  34 import org.eclipse.ui.forms.widgets.ScrolledForm;
  35
  36 /** Test JDBC. */
  37 public class JdbcTestPage extends FormPage implements AkbNames {
  38         private Node node;
  39         private AkbService akbService;
  40
  41         private TableViewer viewer = null;
  42         private IContentProvider contentProvider;
  43
  44         private PreparedStatement statement;
  45
  46         public JdbcTestPage(AkbService akbService, FormEditor editor, String id,
  47                         String title, Node node) {
  48                 super(editor, id, title);
  49                 this.akbService = akbService;
  50                 this.node = node;
  51         }
  52
  53         protected void createFormContent(IManagedForm managedForm) {
  54                 super.createFormContent(managedForm);
  55                 ScrolledForm form = managedForm.getForm();
  56                 form.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
  57                 Composite parent = form.getBody();
  58
  59                 parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
  60                 FormToolkit toolkit = getEditor().getToolkit();
  61                 Table table = toolkit.createTable(parent, SWT.VIRTUAL);
  62                 table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
  63                 table.setHeaderVisible(true);
  64                 table.setLinesVisible(true);
  65                 viewer = new TableViewer(table);
  66                 contentProvider = new JdbcTestContentProvider(viewer);
  67                 viewer.setContentProvider(contentProvider);
  68                 // viewer.setLabelProvider(new ColumnLabelProvider(){});
  69
  70                 statement = akbService.prepareJdbcQuery(node);
  71                 PrivilegedJob job = new PrivilegedJob("Execute query on " + node) {
  72
  73                         @Override
  74                         protected IStatus doRun(IProgressMonitor progressMonitor) {
  75                                 try {
  76                                         final ResultSet resultSet = statement.executeQuery();
  77                                         getEditorSite().getWorkbenchWindow().getShell()
  78                                                         .getDisplay().syncExec(new Runnable() {
  79
  80                                                                 @Override
  81                                                                 public void run() {
  82                                                                         viewer.setInput(resultSet);
  83                                                                 }
  84                                                         });
  85                                         return Status.OK_STATUS;
  86                                 } catch (SQLException e) {
  87                                         throw new SlcException("Cannot execute " + node, e);
  88                                 }
  89                         }
  90                 };
  91                 job.schedule();
  92         }
  93
  94         @Override
  95         public void dispose() {
  96                 try {
  97                         statement.close();
  98                         statement.getConnection().close();
  99                 } catch (SQLException e) {
 100                         // silent
 101                 }
 102         }
 103
 104         private class JdbcTestContentProvider implements ILazyContentProvider {
 105                 private TableViewer viewer;
 106                 private ResultSet resultSet;
 107                 private boolean isScrollable;
 108
 109                 private List<Object> buffer = new ArrayList<Object>();
 110
 111                 private List<JdbcColumn> columns = new ArrayList<JdbcColumn>();
 112                 private Integer columnCount = 0;
 113
 114                 private int rowCount = 0;
 115
 116                 public JdbcTestContentProvider(TableViewer viewer) {
 117                         this.viewer = viewer;
 118                 }
 119
 120                 public void dispose() {
 121                         try {
 122                                 resultSet.close();
 123                         } catch (SQLException e) {
 124                                 // silent
 125                         }
 126                 }
 127
 128                 public void inputChanged(Viewer v, Object oldInput, Object newInput) {
 129                         if (newInput == null)
 130                                 return;
 131
 132                         TableViewer viewer = (TableViewer) v;
 133
 134                         resultSet = (ResultSet) newInput;
 135                         try {
 136                                 isScrollable = resultSet.getType() != ResultSet.TYPE_FORWARD_ONLY;
 137                                 columnCount = resultSet.getMetaData().getColumnCount();
 138                                 for (int i = 1; i <= columnCount; i++) {
 139                                         columns.add(new JdbcColumn(i, resultSet.getMetaData()));
 140                                         if (oldInput == null)// first time
 141                                                 addColumn(viewer, i - 1);
 142                                 }
 143
 144                                 if (isScrollable) {
 145                                         if (resultSet.next())
 146                                                 rowCount = 1;
 147                                         viewer.setItemCount(rowCount);
 148                                 } else {
 149                                         while (resultSet.next()) {
 150                                                 Object[] lst = new Object[columnCount];
 151                                                 for (int i = 1; i <= columnCount; i++) {
 152                                                         lst[i - 1] = resultSet.getObject(i);
 153                                                         buffer.add(lst);
 154                                                 }
 155                                         }
 156                                         viewer.setItemCount(buffer.size());
 157                                 }
 158
 159                         } catch (SQLException e) {
 160                                 throw new SlcException("Cannot configure JDBC column", e);
 161                         }
 162                 }
 163
 164                 protected void addColumn(TableViewer viewer, final int index) {
 165                         TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
 166                         col.getColumn().setWidth(100);
 167                         col.getColumn().setText(columns.get(index).name);
 168                         col.setLabelProvider(new ColumnLabelProvider() {
 169                                 @Override
 170                                 public String getText(Object element) {
 171                                         Object obj = ((Object[]) element)[index];
 172                                         if (obj == null)
 173                                                 return null;
 174                                         return obj.toString();
 175                                 }
 176                         });
 177                 }
 178
 179                 public void updateElement(int index) {
 180                         if (resultSet == null)
 181                                 return;
 182
 183                         try {
 184                                 if (isScrollable) {
 185                                         resultSet.absolute(index + 1);
 186                                         Object[] lst = new Object[columnCount];
 187                                         for (int i = 1; i <= columnCount; i++) {
 188                                                 lst[i - 1] = resultSet.getObject(i);
 189                                         }
 190                                         viewer.replace(lst, index);
 191                                         int itemCount = viewer.getTable().getItemCount();
 192                                         if (index == (itemCount - 1) && resultSet.next())
 193                                                 viewer.setItemCount(itemCount + 1);
 194                                 } else {
 195                                         viewer.replace(buffer.get(index), index);
 196                                 }
 197                         } catch (Exception e) {
 198                                 throw new SlcException("Cannot update element", e);
 199                         }
 200                 }
 201         }
 202
 203         private class JdbcColumn {
 204                 // public final Integer index;
 205                 public final String name;
 206
 207                 // public final Integer type;
 208
 209                 public JdbcColumn(int index, ResultSetMetaData metaData)
 210                                 throws SQLException {
 211                         // this.index = index;
 212                         this.name = metaData.getColumnName(index);
 213                         // this.type = metaData.getColumnType(index);
 214
 215                 }
 216         }
 217
 218 }