/** * Parse some input string and translate all special tokens. This is similar to a string template * engine: it extracts <em>key</em> from <tt>${key}</tt> sequences in the input string and uses * {@link #getString(String)} to translate it. Contents in between <tt>${}</tt> sequences are * copied as-is. * * @param input The input string. * @return String with all special tokens replaced. */ public static String processTemplate(String input) { if (input == null || input.trim().length() == 0) return input; StringBuilder sb = new StringBuilder(); int last = 0; for (int i = 0; i < input.length(); i++) { if (i <= input.length() - 3 && input.charAt(i) == '$' && input.charAt(i + 1) == '{') { int j; for (j = i + 2; j < input.length() && input.charAt(j) != '}'; j++) ; if (i > 0) sb.append(input.substring(last, i)); String key = input.substring(i + 2, j); String text = null; try { text = getString(key); } catch (Exception e) { } if (text == null || text.contains(key)) { logger.error("Failed to lookup key [" + key + "]"); sb.append("${" + key + "}"); } else sb.append(text); last = j + 1; } } sb.append(input.substring(last)); logger.debug("Template string [" + input + "] turns out as [" + sb + "]"); return sb.toString(); }
private void secureAddTab(ExplainTab tab) { SessionProperties props = _session.getProperties(); if (s_log.isDebugEnabled()) { s_log.debug("secureAddTab - TabCount: " + _tabbedExecutionsPanel.getTabCount()); s_log.debug("secureAddTab - Limited?: " + props.getLimitSQLResultTabs()); s_log.debug("secureAddTab - TabLimit: " + props.getSqlResultTabLimit()); } if (props.getLimitSQLResultTabs() && props.getSqlResultTabLimit() <= _tabbedExecutionsPanel.getTabCount()) { closeTabAt(0); } _tabbedExecutionsPanel.addTab(tab.getTitle(), null, tab, tab.getToolTip()); _tabbedExecutionsPanel.setSelectedComponent(tab); }
private void closeResultTab(ResultTab tab) { if (tab == null) { throw new IllegalArgumentException("Null ResultTab passed"); } s_log.debug("SQLPanel.closeResultTab(" + tab.getIdentifier().toString() + ")"); tab.closeTab(); _tabbedExecutionsPanel.remove(tab); }
private String getExplainSql(String sql) { StringBuilder result = new StringBuilder(); IQueryTokenizer tokenizer = _session.getQueryTokenizer(); tokenizer.setScriptToTokenize(sql); while (tokenizer.hasQuery()) { String query = tokenizer.nextQuery(); result.append("BEGIN").append(tokenizer.getSQLStatementSeparator()); result.append(EXPLAIN_PREFIX).append(query).append(tokenizer.getSQLStatementSeparator()); result.append("ROLLBACK").append(tokenizer.getSQLStatementSeparator()); } if (s_log.isDebugEnabled()) { s_log.debug("getExplainSql - Input: " + sql); s_log.debug("getExplainSql - Querys: " + tokenizer.getQueryCount()); s_log.debug("getExplainSql - Result: " + result); } return result.toString(); }
public void moveToFront(final JInternalFrame fr) { if (fr != null) { GUIUtils.processOnSwingEventThread( new Runnable() { public void run() { GUIUtils.moveToFront(fr); } }); } else { s_log.debug("JInternalFrame == null"); } }
/** * Return the passed tab back into the tabbed pane. * * @param tab <TT>Resulttab</TT> to be returned * @throws IllegalArgumentException Thrown if a <TT>null</TT> <TT>ResultTab</TT> passed. */ private void returnToTabbedPane(ResultTab tab) { if (tab == null) { throw new IllegalArgumentException("Null ResultTab passed"); } s_log.debug("SQLPanel.returnToTabbedPane(" + tab.getIdentifier().toString() + ")"); for (ResultFrame sqlResultFrame : _sqlResultFrames) { if (tab == sqlResultFrame.getTab()) { _sqlResultFrames.remove(sqlResultFrame); break; } } addResultsTab(tab, null); }
/** * Create an internal frame for the specified tab and display the tab in the internal frame after * removing it from the tabbed pane. * * @param tab <TT>ResultTab</TT> to be displayed in an internal frame. * @throws IllegalArgumentException Thrown if a <TT>null</TT> <TT>ResultTab</TT> passed. */ private void createSQLResultFrame(ResultTab tab) { if (tab == null) { throw new IllegalArgumentException("Null ResultTab passed"); } s_log.debug("SQLPanel.createSQLResultFrame(" + tab.getIdentifier().toString() + ")"); _tabbedExecutionsPanel.remove(tab); ResultFrameListener resultFrameListener = new ResultFrameListener() { @Override public void frameReplaced(ResultFrame oldFrame, ResultFrame newFrame) { onFrameReplaced(oldFrame, newFrame); } }; ResultFrame frame = new ResultFrame(_session, tab, _resultTabFactory, resultFrameListener, true, false); _sqlResultFrames.add(frame); }
/** link from fw to this for updating data */ public String updateTableComponent( Object[] values, ColumnDisplayDefinition[] colDefs, int col, Object oldValue, Object newValue) { // if we could not identify which table to edit, tell user if (ti == null) return TI_ERROR_MESSAGE; // get WHERE clause using original value List<IWhereClausePart> whereClauseParts = getWhereClause(values, colDefs, col, oldValue); String whereClause = whereClausePartUtil.createWhereClause(whereClauseParts); if (s_log.isDebugEnabled()) { s_log.debug("updateTableComponent: whereClause = " + whereClause); } final ISession session = _session; final ISQLConnection conn = session.getSQLConnection(); int count = -1; final String sql = constructUpdateSql(ti.getQualifiedName(), colDefs[col].getColumnName(), whereClause); if (s_log.isDebugEnabled()) { s_log.debug("updateTableComponent: executing SQL - " + sql); } PreparedStatement pstmt = null; try { pstmt = conn.prepareStatement(sql); /* * have the DataType object fill in the appropriate kind of value of the changed data * into the first variable position in the prepared stmt */ CellComponentFactory.setPreparedStatementValue(colDefs[col], pstmt, newValue, 1); // Fill the parameters of the where clause - start at position 2 because the data which is // updated is at position 1 whereClausePartUtil.setParameters(pstmt, whereClauseParts, 2); count = pstmt.executeUpdate(); } catch (SQLException ex) { // i18n[DataSetUpdateableTableModelImpl.error.updateproblem=There // was a problem reported during the update. // The DB message was:\n{0}\nThis may or may not be serious depending // on the above message.\nThe data was probably not changed in the // database.\nYou may need to refresh the table to get an accurate // view of the current data.] String errMsg = s_stringMgr.getString( "DataSetUpdateableTableModelImpl.error.updateproblem", ex.getMessage()); s_log.error( "updateTableComponent: unexpected exception - " + ex.getMessage() + " while executing SQL: " + sql); return errMsg; } finally { SQLUtilities.closeStatement(pstmt); } if (count == -1) { // i18n[DataSetUpdateableTableModelImpl.error.unknownupdateerror=Unknown problem during // update.\nNo count of updated rows was returned.\nDatabase may be corrupted!] return s_stringMgr.getString("DataSetUpdateableTableModelImpl.error.unknownupdateerror"); } if (count == 0) { // i18n[DataSetUpdateableTableModelImpl.info.norowsupdated=No rows updated.] return s_stringMgr.getString("DataSetUpdateableTableModelImpl.info.norowsupdated"); } // everything seems to have worked ok return null; }
/** Create the <TT>IDataSet</TT> to be displayed in this tab. */ protected IDataSet createDataSet() throws DataSetException { final ISession session = getSession(); final ISQLConnection conn = session.getSQLConnection(); ISQLDatabaseMetaData md = session.getMetaData(); try { final Statement stmt = conn.createStatement(); try { final SessionProperties props = session.getProperties(); if (props.getContentsLimitRows()) { try { stmt.setMaxRows(props.getContentsNbrRowsToShow()); } catch (Exception ex) { s_log.error("Error on Statement.setMaxRows()", ex); } } final ITableInfo ti = getTableInfo(); /** * When the SessionProperties are set to read-only (either table or text) but the user has * selected "Make Editable" on the Popup menu, we want to limit the edit capability to only * that table, and only for as long as the user is looking at that one table. When the user * switches away to another table, that new table should not be editable. */ final String currentTableName = ti.getQualifiedName(); if (!currentTableName.equals(previousTableName)) { previousTableName = currentTableName; // needed to prevent an infinite loop _dataSetUpdateableTableModel.setEditModeForced(false); /** * Tell the GUI to rebuild itself. Unfortunately, this has the side effect of calling this * same function another time. The second call does not seem to be a problem, but we need * to have reset the previousTableName before makeing this call or we will be in an * infinite loop. */ // props.forceTableContentsOutputClassNameChange(); } /** * If the table has a pseudo-column that is the best unique identifier for the rows (like * Oracle's rowid), then we want to include that field in the query so that it will be * available if the user wants to edit the data later. */ String pseudoColumn = ""; try { BestRowIdentifier[] rowIDs = md.getBestRowIdentifier(ti); for (int i = 0; i < rowIDs.length; ++i) { short pseudo = rowIDs[i].getPseudoColumn(); if (pseudo == DatabaseMetaData.bestRowPseudo) { pseudoColumn = " ," + rowIDs[i].getColumnName(); break; } } } // Some DBMS's (EG Think SQL) throw an exception on a call to // getBestRowIdentifier. catch (Throwable th) { if (s_log.isDebugEnabled()) { s_log.debug("getBestRowIdentifier not supported for table " + currentTableName, th); } } // TODO: - Col - Add method to Databasemetadata that returns array // of objects for getBestRowIdentifier. For PostgreSQL put this kludge in // the new function. THis way all the kludges are kept in one place. // // KLUDGE!!!!!! // // For some DBs (e.g. PostgreSQL) there is actually a pseudo-column // providing the rowId, but the getBestRowIdentifier function is not // implemented. This kludge hardcodes the knowledge that specific // DBs use a specific pseudo-column. Additionally, as of pg 8.1, // you must create the table using "WITH OID" appended to the create // statement. Otherwise, OID column is not available by default. // if (pseudoColumn.length() == 0) { if (DialectFactory.isPostgreSQL(md)) { pseudoColumn = ", oid"; } if (DialectFactory.isOracle(md)) { pseudoColumn = ", ROWID"; } } ResultSet rs = null; try { // Note. Some DBMSs such as Oracle do not allow: // "select *, rowid from table" // You cannot have any column name in the columns clause // if you have * in there. Aliasing the table name seems to // be the best way to get around the problem. final StringBuffer buf = new StringBuffer(); buf.append("select tbl.*") .append(pseudoColumn) .append(" from ") .append(ti.getQualifiedName()) .append(" tbl"); String clause = _sqlFilterClauses.get(WhereClausePanel.getClauseIdentifier(), ti.getQualifiedName()); if ((clause != null) && (clause.length() > 0)) { buf.append(" where ").append(clause); } clause = _sqlFilterClauses.get( OrderByClausePanel.getClauseIdentifier(), ti.getQualifiedName()); if ((clause != null) && (clause.length() > 0)) { buf.append(" order by ").append(clause); } if (s_log.isDebugEnabled()) { s_log.debug("createDataSet running SQL: " + buf.toString()); } showWaitDialog(stmt); rs = stmt.executeQuery(buf.toString()); } catch (SQLException ex) { if (s_log.isDebugEnabled()) { s_log.debug("createDataSet: exception from pseudocolumn query - " + ex, ex); } // We assume here that if the pseudoColumn was used in the query, // then it was likely to have caused the SQLException. If not, // (length == 0), then retrying the query won't help - just throw // the exception. if (pseudoColumn.length() == 0) { throw ex; } // pseudocolumn query failed, so reset it. Otherwise, we'll // mistake the last column for a pseudocolumn and make it // uneditable pseudoColumn = ""; // Some tables have pseudo column primary keys and others // do not. JDBC on some DBMSs does not handle pseudo // columns 'correctly'. Also, getTables returns 'views' as // well as tables, so the thing we are looking at might not // be a table. (JDBC does not give a simple way to // determine what we are looking at since the type of // object is described in a DBMS-specific encoding.) For // these reasons, rather than testing for all these // conditions, we just try using the pseudo column info to // get the table data, and if that fails, we try to get the // table data without using the pseudo column. // TODO: Should we change the mode from editable to // non-editable? final StringBuffer buf = new StringBuffer(); buf.append("select *").append(" from ").append(ti.getQualifiedName()).append(" tbl"); String clause = _sqlFilterClauses.get(WhereClausePanel.getClauseIdentifier(), ti.getQualifiedName()); if ((clause != null) && (clause.length() > 0)) { buf.append(" where ").append(clause); } clause = _sqlFilterClauses.get( OrderByClausePanel.getClauseIdentifier(), ti.getQualifiedName()); if ((clause != null) && (clause.length() > 0)) { buf.append(" order by ").append(clause); } rs = stmt.executeQuery(buf.toString()); } final ResultSetDataSet rsds = new ResultSetDataSet(); // to allow the fw to save and reload user options related to // specific columns, we construct a unique name for the table // so the column can be associcated with only that table. // Some drivers do not provide the catalog or schema info, so // those parts of the name will end up as null. That's ok since // this string is never viewed by the user and is just used to // distinguish this table from other tables in the DB. // We also include the URL used to connect to the DB so that // the same table/DB on different machines is treated differently. rsds.setContentsTabResultSet( rs, _dataSetUpdateableTableModel.getFullTableName(), DialectFactory.getDialectType(md)); if (rs != null) { try { rs.close(); } catch (SQLException e) { } } // KLUDGE: // We want some info about the columns to be available for validating the // user input during cell editing operations. Ideally we would get that // info inside the ResultSetDataSet class during the creation of the // columnDefinition objects by using various functions in ResultSetMetaData // such as isNullable(idx). Unfortunately, in at least some DBMSs (e.g. // Postgres, HSDB) the results of those calls are not the same (and are less accurate // than) the SQLMetaData.getColumns() call used in ColumnsTab to get the column info. // Even more unfortunate is the fact that the set of attributes reported on by the two // calls is not the same, with the ResultSetMetadata listing things not provided by // getColumns. Most of the data provided by the ResultSetMetaData calls is correct. // However, the nullable/not-nullable property is not set correctly in at least two // DBMSs, while it is correct for those DBMSs in the getColumns() info. Therefore, // we collect the collumn nullability information from getColumns() and pass that // info to the ResultSet to override what it got from the ResultSetMetaData. TableColumnInfo[] columnInfos = md.getColumnInfo(getTableInfo()); final ColumnDisplayDefinition[] colDefs = rsds.getDataSetDefinition().getColumnDefinitions(); // get the nullability information and pass it into the ResultSet // Unfortunately, not all DBMSs provide the column number in object 17 as stated in the // SQL documentation, so we have to guess that the result set is in column order for (int i = 0; i < columnInfos.length; i++) { boolean isNullable = true; TableColumnInfo info = columnInfos[i]; if (info.isNullAllowed() == DatabaseMetaData.columnNoNulls) { isNullable = false; } if (i < colDefs.length) { colDefs[i].setIsNullable(isNullable); } } // ?? remember which column is the rowID (if any) so we can // ?? prevent editing on it if (pseudoColumn.length() > 0) { _dataSetUpdateableTableModel.setRowIDCol(rsds.getColumnCount() - 1); } return rsds; } finally { SQLUtilities.closeStatement(stmt); } } catch (SQLException ex) { throw new DataSetException(ex); } finally { disposeWaitDialog(); } }