| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| package com.sun.star.wizards.db; |
| |
| import com.sun.star.awt.XWindow; |
| import com.sun.star.lang.XInitialization; |
| import com.sun.star.ui.dialogs.XExecutableDialog; |
| |
| import com.sun.star.lang.IllegalArgumentException; |
| import com.sun.star.lang.WrappedTargetException; |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.awt.VclWindowPeerAttribute; |
| import com.sun.star.awt.XWindowPeer; |
| import com.sun.star.beans.PropertyValue; |
| import com.sun.star.beans.UnknownPropertyException; |
| import com.sun.star.beans.XPropertySet; |
| import com.sun.star.container.XHierarchicalNameAccess; |
| import com.sun.star.container.XHierarchicalNameContainer; |
| import com.sun.star.container.XNameAccess; |
| import com.sun.star.container.XNameContainer; |
| import com.sun.star.frame.XModel; |
| import com.sun.star.frame.XStorable; |
| import com.sun.star.lang.XComponent; |
| import com.sun.star.sdbc.DataType; |
| import com.sun.star.sdb.XOfficeDatabaseDocument; |
| import com.sun.star.sdb.XDocumentDataSource; |
| import com.sun.star.sdb.tools.XConnectionTools; |
| import com.sun.star.sdbcx.XColumnsSupplier; |
| |
| import com.sun.star.ucb.XSimpleFileAccess; |
| import com.sun.star.uno.UnoRuntime; |
| import com.sun.star.uno.XInterface; |
| import com.sun.star.uno.AnyConverter; |
| import com.sun.star.util.XCloseable; |
| import com.sun.star.util.XNumberFormatsSupplier; |
| |
| import com.sun.star.task.XInteractionHandler; |
| import com.sun.star.sdb.XFormDocumentsSupplier; |
| import com.sun.star.sdb.XQueryDefinitionsSupplier; |
| import com.sun.star.sdb.XReportDocumentsSupplier; |
| import com.sun.star.sdbc.SQLException; |
| import com.sun.star.sdbc.XDatabaseMetaData; |
| import com.sun.star.sdbc.XDataSource; |
| import com.sun.star.sdbc.XResultSet; |
| import com.sun.star.sdbc.XRow; |
| import com.sun.star.sdb.XCompletedConnection; |
| import com.sun.star.lang.Locale; |
| import com.sun.star.lang.XSingleServiceFactory; |
| import com.sun.star.sdb.XQueriesSupplier; |
| import com.sun.star.sdbc.XConnection; |
| import com.sun.star.sdbcx.XTablesSupplier; |
| import com.sun.star.wizards.common.Configuration; |
| import com.sun.star.wizards.common.Desktop; |
| import com.sun.star.wizards.common.FileAccess; |
| import com.sun.star.wizards.common.JavaTools; |
| import com.sun.star.wizards.common.NamedValueCollection; |
| import com.sun.star.wizards.common.NumberFormatter; |
| import com.sun.star.wizards.common.Properties; |
| import com.sun.star.wizards.common.Resource; |
| import com.sun.star.wizards.common.SystemDialog; |
| import com.sun.star.uno.Any; |
| import com.sun.star.wizards.common.PropertyNames; |
| import java.util.Vector; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| public class DBMetaData |
| { |
| private XNameAccess xQueryNames; |
| public XDatabaseMetaData xDBMetaData; |
| private XDataSource m_dataSource; |
| private XPropertySet m_dataSourceSettings; |
| private XOfficeDatabaseDocument xModel; |
| private XPropertySet xDataSourcePropertySet; |
| public String[] DataSourceNames; |
| public String[] CommandNames; |
| public java.util.Vector CommandObjects = new Vector(1); |
| public Locale aLocale; |
| public int[] CommandTypes; |
| public String DataSourceName; |
| public com.sun.star.sdbc.XConnection DBConnection; |
| private com.sun.star.sdb.tools.XConnectionTools m_connectionTools; |
| public com.sun.star.lang.XMultiServiceFactory xMSF; |
| public XComponent xConnectionComponent; |
| |
| private XNameAccess xNameAccess; |
| private XInterface xDatabaseContext; |
| private XWindowPeer xWindowPeer; |
| private String[] TableNames = new String[] {}; |
| private String[] QueryNames = new String[] {}; |
| |
| protected int[][] WidthList; |
| protected static final int[] NumericTypes = { |
| DataType.TINYINT, // == -6; |
| DataType.BIGINT, // == -5 |
| DataType.NUMERIC, // == - 2 |
| DataType.DECIMAL, // == 3; |
| DataType.INTEGER, // == 4; |
| DataType.SMALLINT, // == 5; |
| DataType.FLOAT, // == 6; |
| DataType.REAL, // == 7; |
| DataType.DOUBLE, // == 8; |
| }; |
| protected static final int[] BinaryTypes = { //new int[12]; |
| DataType.BINARY, |
| DataType.VARBINARY, |
| DataType.LONGVARBINARY, |
| DataType.BLOB, |
| DataType.SQLNULL, |
| DataType.OBJECT, |
| DataType.DISTINCT, |
| DataType.STRUCT, |
| DataType.ARRAY, |
| DataType.CLOB, |
| DataType.REF |
| /* DataType.OTHER, */ |
| }; |
| |
| private int iMaxColumnsInSelect; |
| private int iMaxColumnsInGroupBy; |
| private int iMaxColumnNameLength = -1; |
| private int iMaxTableNameLength = -1; |
| private boolean bPasswordIsRequired; |
| private final static int NOLIMIT = 9999999; |
| protected final static int RID_DB_COMMON = 1000; |
| private final static int INVALID = 9999999; |
| public TypeInspector oTypeInspector; |
| private NumberFormatter oNumberFormatter = null; |
| private long lDateCorrection = INVALID; |
| private boolean bdisposeConnection = false; |
| |
| public XPropertySet getDataSourcePropertySet() |
| { |
| return xDataSourcePropertySet; |
| } |
| |
| public DBMetaData(XMultiServiceFactory xMSF) |
| { |
| getInterfaces(xMSF); |
| InitializeWidthList(); |
| } |
| |
| public DBMetaData(XMultiServiceFactory xMSF, Locale _aLocale, NumberFormatter _oNumberFormatter) |
| { |
| oNumberFormatter = _oNumberFormatter; |
| aLocale = _aLocale; |
| getInterfaces(xMSF); |
| InitializeWidthList(); |
| } |
| |
| public NumberFormatter getNumberFormatter() |
| { |
| if (oNumberFormatter == null) |
| { |
| try |
| { |
| XNumberFormatsSupplier xNumberFormatsSupplier = (XNumberFormatsSupplier) AnyConverter.toObject(XNumberFormatsSupplier.class, xDataSourcePropertySet.getPropertyValue("NumberFormatsSupplier")); |
| //TODO get the locale from the datasource |
| aLocale = Configuration.getOfficeLocale(xMSF); |
| oNumberFormatter = new NumberFormatter(xMSF, xNumberFormatsSupplier, aLocale); |
| lDateCorrection = oNumberFormatter.getNullDateCorrection(); |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| } |
| return oNumberFormatter; |
| } |
| |
| public long getNullDateCorrection() |
| { |
| if (lDateCorrection == INVALID) |
| { |
| if (oNumberFormatter == null) |
| { |
| oNumberFormatter = getNumberFormatter(); |
| } |
| lDateCorrection = oNumberFormatter.getNullDateCorrection(); |
| } |
| return lDateCorrection; |
| } |
| |
| private void getInterfaces(XMultiServiceFactory xMSF) |
| { |
| try |
| { |
| this.xMSF = xMSF; |
| xDatabaseContext = (XInterface) xMSF.createInstance("com.sun.star.sdb.DatabaseContext"); |
| xNameAccess = UnoRuntime.queryInterface( XNameAccess.class, xDatabaseContext ); |
| DataSourceNames = xNameAccess.getElementNames(); |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| } |
| |
| public void setCommandTypes() |
| { |
| int TableCount; |
| int QueryCount; |
| int CommandCount; |
| int i; |
| int a; |
| TableCount = JavaTools.getArraylength(TableNames); |
| QueryCount = JavaTools.getArraylength(QueryNames); |
| CommandCount = TableCount + QueryCount; |
| CommandTypes = new int[CommandCount]; |
| if (TableCount > 0) |
| { |
| for (i = 0; i < TableCount; i++) |
| { |
| CommandTypes[i] = com.sun.star.sdb.CommandType.TABLE; |
| } |
| a = i; |
| for (i = 0; i < QueryCount; i++) |
| { |
| CommandTypes[a] = com.sun.star.sdb.CommandType.QUERY; |
| a += 1; |
| } |
| } |
| } |
| |
| public boolean hasTableByName(String _stablename) |
| { |
| return getTableNamesAsNameAccess().hasByName(_stablename); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void setTableByName(String _tableName) |
| { |
| CommandObject oTableObject = new CommandObject(_tableName, com.sun.star.sdb.CommandType.TABLE); |
| this.CommandObjects.addElement(oTableObject); |
| } |
| |
| public CommandObject getTableByName(String _tablename) |
| { |
| return getCommandByName(_tablename, com.sun.star.sdb.CommandType.TABLE); |
| } |
| |
| public CommandObject getQueryByName(String _queryname) |
| { |
| return getCommandByName(_queryname, com.sun.star.sdb.CommandType.QUERY); |
| } |
| |
| public CommandObject getCommandByName(String _commandname, int _commandtype) |
| { |
| CommandObject oCommand = null; |
| for (int i = 0; i < CommandObjects.size(); i++) |
| { |
| oCommand = (CommandObject) CommandObjects.elementAt(i); |
| if ((oCommand.Name.equals(_commandname)) && (oCommand.CommandType == _commandtype)) |
| { |
| return oCommand; |
| } |
| } |
| if (oCommand == null) |
| { |
| oCommand = new CommandObject(_commandname, _commandtype); |
| CommandObjects.addElement(oCommand); |
| } |
| return oCommand; |
| } |
| |
| public void setQueryByName(String _QueryName) |
| { |
| CommandObject oQueryObject = new CommandObject(_QueryName, com.sun.star.sdb.CommandType.QUERY); |
| this.CommandObjects.addElement(oQueryObject); |
| } |
| |
| public class CommandObject |
| { |
| |
| private XNameAccess xColumns; |
| private XPropertySet xPropertySet; |
| private String Name; |
| private int CommandType; |
| |
| public CommandObject(String _CommandName, int _CommandType) |
| { |
| try |
| { |
| Object oCommand; |
| this.Name = _CommandName; |
| this.CommandType = _CommandType; |
| // if (getTableNamesAsNameAccess() == null) |
| // { |
| // initCommandNames(); |
| // } |
| if (CommandType == com.sun.star.sdb.CommandType.TABLE) |
| { |
| oCommand = getTableNamesAsNameAccess().getByName(Name); |
| } |
| else |
| { |
| oCommand = getQueryNamesAsNameAccess().getByName(Name); |
| } |
| XColumnsSupplier xCommandCols = UnoRuntime.queryInterface( XColumnsSupplier.class, oCommand ); |
| xPropertySet = UnoRuntime.queryInterface( XPropertySet.class, oCommand ); |
| // TODO: Performance leak getColumns() take very long. |
| xColumns = UnoRuntime.queryInterface( XNameAccess.class, xCommandCols.getColumns() ); |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| } |
| public XNameAccess getColumns() |
| { |
| return xColumns; |
| } |
| public String getName() |
| { |
| return Name; |
| } |
| public XPropertySet getPropertySet() |
| { |
| return xPropertySet; |
| } |
| } |
| |
| public boolean hasEscapeProcessing(XPropertySet _xQueryPropertySet) |
| { |
| boolean bHasEscapeProcessing = false; |
| try |
| { |
| if (_xQueryPropertySet.getPropertySetInfo().hasPropertyByName("EscapeProcessing")) |
| { |
| bHasEscapeProcessing = AnyConverter.toBoolean(_xQueryPropertySet.getPropertyValue("EscapeProcessing")); |
| } |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| return bHasEscapeProcessing; |
| } |
| |
| public XNameAccess getQueryNamesAsNameAccess() |
| { |
| XQueriesSupplier xDBQueries = UnoRuntime.queryInterface( XQueriesSupplier.class, DBConnection ); |
| xQueryNames = xDBQueries.getQueries(); |
| return xQueryNames; |
| } |
| |
| public XNameAccess getTableNamesAsNameAccess() |
| { |
| XTablesSupplier xDBTables = UnoRuntime.queryInterface( XTablesSupplier.class, DBConnection ); |
| return xDBTables.getTables(); |
| } |
| |
| public String[] getQueryNames() |
| { |
| if (QueryNames != null) |
| { |
| if (QueryNames.length > 0) |
| { |
| return QueryNames; |
| } |
| } |
| QueryNames = getQueryNamesAsNameAccess().getElementNames(); |
| return QueryNames; |
| } |
| |
| public String[] getTableNames() |
| { |
| if (TableNames != null) |
| { |
| if (TableNames.length > 0) |
| { |
| return TableNames; |
| } |
| } |
| TableNames = getTableNamesAsNameAccess().getElementNames(); |
| return TableNames; |
| } |
| |
| private void InitializeWidthList() |
| { |
| WidthList = new int[17][2]; |
| WidthList[0][0] = DataType.BIT; // == -7; |
| WidthList[1][0] = DataType.BOOLEAN; // = 16 |
| WidthList[2][0] = DataType.TINYINT; // == -6; |
| WidthList[3][0] = DataType.BIGINT; // == -5; |
| WidthList[4][0] = DataType.LONGVARCHAR; // == -1; |
| WidthList[5][0] = DataType.CHAR; // == 1; |
| WidthList[6][0] = DataType.NUMERIC; // == 2; |
| WidthList[7][0] = DataType.DECIMAL; // == 3; [mit Nachkommastellen] |
| WidthList[8][0] = DataType.INTEGER; // == 4; |
| WidthList[9][0] = DataType.SMALLINT; // == 5; |
| WidthList[10][0] = DataType.FLOAT; // == 6; |
| WidthList[11][0] = DataType.REAL; // == 7; |
| WidthList[12][0] = DataType.DOUBLE; // == 8; |
| WidthList[13][0] = DataType.VARCHAR; // == 12; |
| WidthList[14][0] = DataType.DATE; // == 91; |
| WidthList[15][0] = DataType.TIME; // == 92; |
| WidthList[16][0] = DataType.TIMESTAMP; // == 93; |
| // NumericTypes are all types where aggregate functions can be performed on. |
| // Similarly to a major competitor date/time/timmestamp fields are not included |
| |
| |
| } |
| |
| public boolean isBinaryDataType(int _itype) |
| { |
| if (NumericTypes == null) |
| { |
| InitializeWidthList(); |
| } |
| return (JavaTools.FieldInIntTable(BinaryTypes, _itype) > -1); |
| } |
| |
| public int getMaxTablesInSelect() |
| { |
| try |
| { |
| int itablecount = xDBMetaData.getMaxTablesInSelect(); |
| if (itablecount == 0) |
| { |
| return DBMetaData.NOLIMIT; |
| } |
| else |
| { |
| return itablecount; |
| } |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return - 1; |
| } |
| } |
| |
| public int getMaxColumnsInSelect() |
| { |
| return iMaxColumnsInSelect; |
| } |
| |
| public int getMaxColumnsInGroupBy() |
| { |
| return iMaxColumnsInGroupBy; |
| } |
| |
| private void setMaxColumnsInSelect() throws SQLException |
| { |
| iMaxColumnsInSelect = xDBMetaData.getMaxColumnsInSelect(); |
| if (iMaxColumnsInSelect == 0) |
| { |
| iMaxColumnsInSelect = DBMetaData.NOLIMIT; |
| } |
| } |
| |
| private void setMaxColumnsInGroupBy() throws SQLException |
| { |
| iMaxColumnsInGroupBy = xDBMetaData.getMaxColumnsInGroupBy(); |
| if (iMaxColumnsInGroupBy == 0) |
| { |
| iMaxColumnsInGroupBy = DBMetaData.NOLIMIT; |
| } |
| } |
| |
| public int getMaxColumnsInTable() throws SQLException |
| { |
| int iMaxColumnsInTable = xDBMetaData.getMaxColumnsInTable(); |
| if (iMaxColumnsInTable == 0) |
| { |
| iMaxColumnsInTable = DBMetaData.NOLIMIT; |
| } |
| return iMaxColumnsInTable; |
| } |
| |
| private void getDataSourceObjects() throws Exception |
| { |
| try |
| { |
| xDBMetaData = DBConnection.getMetaData(); |
| getDataSourceInterfaces(); |
| setMaxColumnsInGroupBy(); |
| setMaxColumnsInSelect(); |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| } |
| |
| private void ensureDataSourceSettings() throws UnknownPropertyException, WrappedTargetException |
| { |
| if ( m_dataSourceSettings != null ) |
| return; |
| |
| XPropertySet dataSourceProperties = UnoRuntime.queryInterface( XPropertySet.class, getDataSource() ); |
| m_dataSourceSettings = UnoRuntime.queryInterface( XPropertySet.class, dataSourceProperties.getPropertyValue( "Settings" ) ); |
| } |
| |
| public boolean isSQL92CheckEnabled() |
| { |
| boolean isSQL92CheckEnabled = false; |
| try |
| { |
| ensureDataSourceSettings(); |
| isSQL92CheckEnabled = AnyConverter.toBoolean( m_dataSourceSettings.getPropertyValue( "EnableSQL92Check" ) ); |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| return isSQL92CheckEnabled; |
| } |
| |
| public String verifyName(String _sname, int _maxlen) |
| { |
| if (_sname.length() > _maxlen) |
| { |
| return _sname.substring(0, _maxlen); |
| } |
| if (this.isSQL92CheckEnabled()) |
| { |
| return Desktop.removeSpecialCharacters(xMSF, Configuration.getOfficeLocale(xMSF), _sname); |
| } |
| return _sname; |
| } |
| |
| public XDataSource getDataSource() |
| { |
| if (m_dataSource == null) |
| { |
| try |
| { |
| Object oDataSource = xNameAccess.getByName(DataSourceName); |
| m_dataSource = UnoRuntime.queryInterface( XDataSource.class, oDataSource ); |
| } |
| catch (com.sun.star.container.NoSuchElementException e) |
| { |
| } |
| catch (com.sun.star.lang.WrappedTargetException e) |
| { |
| } |
| } |
| return m_dataSource; |
| } |
| |
| private void setDataSourceByName(String _DataSourceName) |
| { |
| try |
| { |
| this.DataSourceName = _DataSourceName; |
| getDataSourceInterfaces(); |
| XDocumentDataSource xDocu = UnoRuntime.queryInterface( XDocumentDataSource.class, getDataSource() ); |
| if (xDocu != null) |
| { |
| xModel = xDocu.getDatabaseDocument(); |
| } |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| } |
| |
| public void getDataSourceInterfaces() throws Exception |
| { |
| xDataSourcePropertySet = UnoRuntime.queryInterface( XPropertySet.class, getDataSource() ); |
| bPasswordIsRequired = ((Boolean) xDataSourcePropertySet.getPropertyValue("IsPasswordRequired")).booleanValue(); |
| } |
| |
| public boolean getConnection(PropertyValue[] curproperties) |
| { |
| try |
| { |
| XConnection xConnection = null; |
| if (Properties.hasPropertyValue(curproperties, PropertyNames.ACTIVE_CONNECTION)) |
| { |
| xConnection = UnoRuntime.queryInterface( XConnection.class, Properties.getPropertyValue( curproperties, PropertyNames.ACTIVE_CONNECTION ) ); |
| if (xConnection != null) |
| { |
| com.sun.star.container.XChild child = UnoRuntime.queryInterface( com.sun.star.container.XChild.class, xConnection ); |
| |
| m_dataSource = UnoRuntime.queryInterface( XDataSource.class, child.getParent() ); |
| XDocumentDataSource xDocu = UnoRuntime.queryInterface( XDocumentDataSource.class, m_dataSource ); |
| if (xDocu != null) |
| { |
| xModel = xDocu.getDatabaseDocument(); |
| } |
| XPropertySet xPSet = UnoRuntime.queryInterface( XPropertySet.class, m_dataSource ); |
| if (xPSet != null) |
| { |
| DataSourceName = AnyConverter.toString(xPSet.getPropertyValue(PropertyNames.PROPERTY_NAME)); |
| } |
| return getConnection(xConnection); |
| } |
| else |
| { |
| bdisposeConnection = true; |
| } |
| } |
| else |
| { |
| bdisposeConnection = true; |
| } |
| if (Properties.hasPropertyValue(curproperties, "DataSourceName")) |
| { |
| String sDataSourceName = AnyConverter.toString(Properties.getPropertyValue(curproperties, "DataSourceName")); |
| return getConnection(sDataSourceName); |
| } |
| else if (Properties.hasPropertyValue(curproperties, "DataSource")) |
| { |
| m_dataSource = UnoRuntime.queryInterface( XDataSource.class, Properties.getPropertyValue( curproperties, "DataSource" ) ); |
| XDocumentDataSource xDocu = UnoRuntime.queryInterface( XDocumentDataSource.class, this.m_dataSource ); |
| if (xDocu != null) |
| { |
| xModel = xDocu.getDatabaseDocument(); |
| } |
| return getConnection(m_dataSource); |
| } |
| if (Properties.hasPropertyValue(curproperties, "DatabaseLocation")) |
| { |
| String sDataSourceName = AnyConverter.toString(Properties.getPropertyValue(curproperties, "DatabaseLocation")); |
| return getConnection(sDataSourceName); |
| } |
| } |
| catch (IllegalArgumentException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| catch (UnknownPropertyException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| catch (WrappedTargetException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| |
| return false; |
| } |
| |
| private boolean getConnection(String _DataSourceName) |
| { |
| setDataSourceByName(_DataSourceName); |
| return getConnection( getDataSource() ); |
| } |
| |
| private boolean getConnection(com.sun.star.sdbc.XConnection _DBConnection) |
| { |
| try |
| { |
| this.DBConnection = _DBConnection; |
| this.m_connectionTools = UnoRuntime.queryInterface( XConnectionTools.class, this.DBConnection ); |
| getDataSourceObjects(); |
| return true; |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return false; |
| } |
| } |
| |
| private boolean getConnection(XDataSource _dataSource) |
| { |
| Resource oResource = new Resource(xMSF, "Database", "dbw"); |
| try |
| { |
| int iMsg = 0; |
| boolean bgetConnection = false; |
| if (DBConnection != null) |
| { |
| xConnectionComponent.dispose(); |
| } |
| getDataSourceInterfaces(); |
| if (!bPasswordIsRequired) |
| { |
| DBConnection = _dataSource.getConnection(PropertyNames.EMPTY_STRING, PropertyNames.EMPTY_STRING); |
| bgetConnection = true; |
| } |
| else |
| { |
| XInteractionHandler xInteractionHandler = UnoRuntime.queryInterface( XInteractionHandler.class, xMSF.createInstance("com.sun.star.task.InteractionHandler") ); |
| boolean bExitLoop = true; |
| do |
| { |
| XCompletedConnection xCompleted2 = UnoRuntime.queryInterface( XCompletedConnection.class, _dataSource ); |
| try |
| { |
| DBConnection = xCompleted2.connectWithCompletion( xInteractionHandler ); |
| bgetConnection = DBConnection != null; |
| if (!bgetConnection) |
| { |
| bExitLoop = true; |
| } |
| } |
| catch (Exception exception) |
| { |
| // Note: WindowAttributes from toolkit/source/awt/vclxtoolkit.cxx |
| String sMsgNoConnection = oResource.getResText(RID_DB_COMMON + 14); |
| iMsg = showMessageBox("QueryBox", VclWindowPeerAttribute.RETRY_CANCEL, sMsgNoConnection); |
| bExitLoop = iMsg == 0; |
| bgetConnection = false; |
| } |
| } |
| while (!bExitLoop); |
| } |
| if (!bgetConnection) |
| { |
| String sMsgConnectionImpossible = oResource.getResText(RID_DB_COMMON + 35); |
| showMessageBox("ErrorBox", VclWindowPeerAttribute.OK, sMsgConnectionImpossible); |
| } |
| else |
| { |
| xConnectionComponent = UnoRuntime.queryInterface( XComponent.class, DBConnection ); |
| m_connectionTools = UnoRuntime.queryInterface( XConnectionTools.class, DBConnection ); |
| getDataSourceObjects(); |
| } |
| return bgetConnection; |
| } |
| catch (Exception e) |
| { |
| String sMsgConnectionImpossible = oResource.getResText(RID_DB_COMMON + 35); |
| showMessageBox("ErrorBox", VclWindowPeerAttribute.OK, sMsgConnectionImpossible); |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return false; |
| } |
| } |
| |
| public int getMaxColumnNameLength() |
| { |
| try |
| { |
| if (iMaxColumnNameLength <= 0) |
| { |
| iMaxColumnNameLength = xDBMetaData.getMaxColumnNameLength(); |
| } |
| return iMaxColumnNameLength; |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return 0; |
| } |
| } |
| |
| public int getMaxTableNameLength() |
| { |
| try |
| { |
| if (iMaxTableNameLength <= 0) |
| { |
| iMaxTableNameLength = xDBMetaData.getMaxTableNameLength(); |
| } |
| return iMaxTableNameLength; |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return 0; |
| } |
| } |
| |
| public boolean supportsPrimaryKeys() |
| { |
| boolean supportsPrimaryKeys = false; |
| try |
| { |
| ensureDataSourceSettings(); |
| Any primaryKeySupport = (Any)m_dataSourceSettings.getPropertyValue( "PrimaryKeySupport" ); |
| if ( AnyConverter.isVoid( primaryKeySupport ) ) |
| supportsPrimaryKeys = supportsCoreSQLGrammar(); |
| else |
| supportsPrimaryKeys = AnyConverter.toBoolean( primaryKeySupport ); |
| } |
| catch ( Exception ex ) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, ex ); |
| } |
| return supportsPrimaryKeys; |
| } |
| |
| public boolean supportsCoreSQLGrammar() |
| { |
| try |
| { |
| return xDBMetaData.supportsCoreSQLGrammar(); |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return false; |
| } |
| } |
| |
| public boolean supportsAutoIncrementation() |
| { |
| return false; |
| } |
| |
| public boolean supportsQueriesInFrom() |
| { |
| return m_connectionTools.getDataSourceMetaData().supportsQueriesInFrom(); |
| } |
| |
| public String suggestName( final int i_objectType, final String i_baseName ) throws IllegalArgumentException |
| { |
| return m_connectionTools.getObjectNames().suggestName( i_objectType, i_baseName ); |
| } |
| |
| /** |
| * inserts a Query to a datasource; There is no validation if the queryname is already existing in the datasource |
| * @param oQuery |
| * @param QueryName |
| */ |
| public boolean createQuery(SQLQueryComposer _oSQLQueryComposer, String _QueryName) |
| { |
| try |
| { |
| XQueryDefinitionsSupplier xQueryDefinitionsSuppl = UnoRuntime.queryInterface( XQueryDefinitionsSupplier.class, m_dataSource ); |
| XNameAccess xQueryDefs = xQueryDefinitionsSuppl.getQueryDefinitions(); |
| XSingleServiceFactory xSSFQueryDefs = UnoRuntime.queryInterface( XSingleServiceFactory.class, xQueryDefs ); |
| Object oQuery = xSSFQueryDefs.createInstance(); //"com.sun.star.sdb.QueryDefinition" |
| XPropertySet xPSet = UnoRuntime.queryInterface( XPropertySet.class, oQuery ); |
| |
| String s = _oSQLQueryComposer.m_xQueryAnalyzer.getQuery(); |
| xPSet.setPropertyValue(PropertyNames.COMMAND, s); |
| |
| XNameContainer xNameCont = UnoRuntime.queryInterface( XNameContainer.class, xQueryDefs ); |
| m_connectionTools.getObjectNames().checkNameForCreate(com.sun.star.sdb.CommandType.QUERY, _QueryName); |
| xNameCont.insertByName(_QueryName, oQuery); |
| return true; |
| } |
| catch (WrappedTargetException exception) |
| { |
| SQLException sqlError = null; |
| try |
| { |
| sqlError = (SQLException) exception.TargetException; |
| } |
| catch (ClassCastException castError) |
| { |
| } |
| |
| if (sqlError != null) |
| { |
| callSQLErrorMessageDialog(sqlError, null); |
| return false; |
| } |
| exception.printStackTrace(System.out); |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| return false; |
| } |
| |
| public void dispose() |
| { |
| if ((DBConnection != null) && (this.bdisposeConnection)) |
| { |
| xConnectionComponent.dispose(); |
| } |
| } |
| |
| public XHierarchicalNameAccess getReportDocuments() |
| { |
| XReportDocumentsSupplier xReportDocumentSuppl = UnoRuntime.queryInterface( XReportDocumentsSupplier.class, this.xModel ); |
| xReportDocumentSuppl.getReportDocuments(); |
| return UnoRuntime.queryInterface( XHierarchicalNameAccess.class, xReportDocumentSuppl.getReportDocuments() ); |
| } |
| |
| public XHierarchicalNameAccess getFormDocuments() |
| { |
| XFormDocumentsSupplier xFormDocumentSuppl = UnoRuntime.queryInterface( XFormDocumentsSupplier.class, xModel ); |
| return UnoRuntime.queryInterface( XHierarchicalNameAccess.class, xFormDocumentSuppl.getFormDocuments() ); |
| } |
| |
| public boolean hasFormDocumentByName(String _sFormName) |
| { |
| XFormDocumentsSupplier xFormDocumentSuppl = UnoRuntime.queryInterface( XFormDocumentsSupplier.class, xModel ); |
| XNameAccess xFormNameAccess = UnoRuntime.queryInterface( XNameAccess.class, xFormDocumentSuppl.getFormDocuments() ); |
| return xFormNameAccess.hasByName(_sFormName); |
| } |
| |
| public void addFormDocument(XComponent _xComponent) |
| { |
| XHierarchicalNameAccess _xFormDocNameAccess = getFormDocuments(); |
| addDatabaseDocument(_xComponent, _xFormDocNameAccess, false); |
| } |
| |
| public void addReportDocument(XComponent _xComponent, boolean _bcreatedynamicreport) |
| { |
| XHierarchicalNameAccess xReportDocNameAccess = getReportDocuments(); |
| addDatabaseDocument(_xComponent, xReportDocNameAccess, _bcreatedynamicreport); |
| } |
| |
| /** |
| * adds the passed document as a report or a form to the database. Afterwards the document is deleted. |
| * the document may not be open |
| * @param _xComponent |
| * @param _xDocNameAccess |
| * @param _bcreateTemplate describes the type of the document: "form" or "report" |
| */ |
| public void addDatabaseDocument(XComponent _xComponent, XHierarchicalNameAccess _xDocNameAccess, boolean i_createTemplate) |
| { |
| try |
| { |
| XModel xDocumentModel = UnoRuntime.queryInterface( XModel.class, _xComponent ); |
| String documentURL = xDocumentModel.getURL(); |
| String basename = FileAccess.getBasename(documentURL, "/"); |
| XCloseable xCloseable = UnoRuntime.queryInterface( XCloseable.class, _xComponent ); |
| xCloseable.close(false); |
| |
| NamedValueCollection creationArgs = new NamedValueCollection(); |
| creationArgs.put( PropertyNames.PROPERTY_NAME, basename ); |
| creationArgs.put( PropertyNames.URL, documentURL ); |
| creationArgs.put( "AsTemplate", i_createTemplate ); |
| XMultiServiceFactory xDocMSF = UnoRuntime.queryInterface( XMultiServiceFactory.class, _xDocNameAccess ); |
| Object oDBDocument = xDocMSF.createInstanceWithArguments( "com.sun.star.sdb.DocumentDefinition", creationArgs.getPropertyValues() ); |
| XHierarchicalNameContainer xHier = UnoRuntime.queryInterface( XHierarchicalNameContainer.class, _xDocNameAccess ); |
| String sdocname = Desktop.getUniqueName(_xDocNameAccess, basename); |
| xHier.insertByHierarchicalName(sdocname, oDBDocument); |
| XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); |
| XSimpleFileAccess xSimpleFileAccess = UnoRuntime.queryInterface( XSimpleFileAccess.class, xInterface ); |
| xSimpleFileAccess.kill(documentURL); |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| } |
| |
| public void createTypeInspector() throws SQLException |
| { |
| oTypeInspector = new TypeInspector(xDBMetaData.getTypeInfo()); |
| } |
| |
| public TypeInspector getDBDataTypeInspector() |
| { |
| return oTypeInspector; |
| } |
| |
| private String[] StringsFromResultSet(XResultSet _xResultSet, int _icol) |
| { |
| String[] sColValues = null; |
| try |
| { |
| XRow xRow = UnoRuntime.queryInterface( XRow.class, _xResultSet ); |
| Vector aColVector = new Vector(); |
| while (_xResultSet.next()) |
| { |
| aColVector.addElement(xRow.getString(_icol)); |
| } |
| sColValues = new String[aColVector.size()]; |
| aColVector.toArray(sColValues); |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| } |
| return sColValues; |
| } |
| |
| public String[] getCatalogNames() |
| { |
| try |
| { |
| XResultSet xResultSet = xDBMetaData.getCatalogs(); |
| return StringsFromResultSet(xResultSet, 1); |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return null; |
| } |
| } |
| |
| public String[] getSchemaNames() |
| { |
| try |
| { |
| XResultSet xResultSet = xDBMetaData.getSchemas(); |
| return StringsFromResultSet(xResultSet, 1); |
| } |
| catch (SQLException e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return null; |
| } |
| } |
| |
| public boolean storeDatabaseDocumentToTempPath(XComponent _xcomponent, String _storename) |
| { |
| try |
| { |
| XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); |
| XSimpleFileAccess xSimpleFileAccess = UnoRuntime.queryInterface( XSimpleFileAccess.class, xInterface ); |
| String storepath = FileAccess.getOfficePath(xMSF, "Temp", xSimpleFileAccess) + "/" + _storename; |
| XStorable xStoreable = UnoRuntime.queryInterface( XStorable.class, _xcomponent ); |
| PropertyValue[] oStoreProperties = new PropertyValue[1]; |
| oStoreProperties[0] = Properties.createProperty("FilterName", "writer8"); |
| storepath += ".odt"; |
| xStoreable.storeAsURL(storepath, oStoreProperties); |
| return true; |
| } |
| catch (Exception e) |
| { |
| Logger.getLogger( DBMetaData.class.getName() ).log( Level.SEVERE, null, e ); |
| return false; |
| } |
| } |
| |
| public int showMessageBox(String windowServiceName, int windowAttribute, String MessageText) |
| { |
| if (getWindowPeer() != null) |
| { |
| return SystemDialog.showMessageBox(xMSF, xWindowPeer, windowServiceName, windowAttribute, MessageText); |
| } |
| else |
| { |
| return SystemDialog.showMessageBox(xMSF, windowServiceName, windowAttribute, MessageText); |
| } |
| } |
| |
| /** |
| * @return Returns the xWindowPeer. |
| */ |
| public XWindowPeer getWindowPeer() |
| { |
| return xWindowPeer; |
| } |
| |
| /** |
| * @param windowPeer The xWindowPeer to set. |
| * Should be called as soon as a Windowpeer of a wizard dialog is available |
| * The windowpeer is needed to call a Messagebox |
| */ |
| public void setWindowPeer(XWindowPeer windowPeer) |
| { |
| xWindowPeer = windowPeer; |
| } |
| |
| public void callSQLErrorMessageDialog(SQLException oSQLException, XWindow _xWindow) |
| { |
| try |
| { |
| Object oDialog = xMSF.createInstance("com.sun.star.sdb.ErrorMessageDialog"); |
| XInitialization xInitialization = UnoRuntime.queryInterface( XInitialization.class, oDialog ); |
| PropertyValue[] aPropertyValue = new PropertyValue[2]; |
| aPropertyValue[0] = Properties.createProperty("SQLException", oSQLException); |
| aPropertyValue[1] = Properties.createProperty("ParentWindow", _xWindow); |
| xInitialization.initialize(aPropertyValue); |
| XExecutableDialog xExecutableDialog = UnoRuntime.queryInterface( XExecutableDialog.class, oDialog ); |
| xExecutableDialog.execute(); |
| } |
| catch (com.sun.star.uno.Exception ex) |
| { |
| Logger.getLogger( getClass().getName() ).log( Level.SEVERE, "error calling the error dialog", ex ); |
| } |
| } |
| |
| public void finish() |
| { |
| xQueryNames = null; |
| xNameAccess = null; |
| xDatabaseContext = null; |
| xDBMetaData = null; |
| m_dataSource = null; |
| xModel = null; |
| xDataSourcePropertySet = null; |
| xWindowPeer = null; |
| DBConnection = null; |
| m_connectionTools = null; |
| xMSF = null; |
| xConnectionComponent = null; |
| CommandObjects = null; |
| } |
| } |
