diff options
Diffstat (limited to 'wizards/com/sun/star/wizards/db/DBMetaData.java')
| -rw-r--r-- | wizards/com/sun/star/wizards/db/DBMetaData.java | 1154 |
1 files changed, 1154 insertions, 0 deletions
diff --git a/wizards/com/sun/star/wizards/db/DBMetaData.java b/wizards/com/sun/star/wizards/db/DBMetaData.java new file mode 100644 index 000000000000..2a7151cd1135 --- /dev/null +++ b/wizards/com/sun/star/wizards/db/DBMetaData.java @@ -0,0 +1,1154 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: DBMetaData.java,v $ + * $Revision: 1.20 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 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 java.util.*; + +// import com.sun.star.io.IOException; +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.XChild; +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.container.XNamed; +import com.sun.star.frame.XComponentLoader; +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.XAppend; +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.wizards.common.Properties; +import com.sun.star.wizards.common.*; +// import com.sun.star.wizards.ui.UnoDialog; +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.ColumnValue; +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.util.XFlushable; +import com.sun.star.lang.XSingleServiceFactory; +import com.sun.star.sdb.XQueriesSupplier; +import com.sun.star.sdbcx.XTablesSupplier; + +public class DBMetaData +{ + + private XNameAccess xQueryNames; + public XDatabaseMetaData xDBMetaData; + private XDataSource xDataSource; + 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; + public com.sun.star.sdb.tools.XConnectionTools ConnectionTools; + public com.sun.star.lang.XMultiServiceFactory xMSF; + public XComponent xConnectionComponent; + public SQLQueryComposer oSQLQueryComposer; + + private XNameAccess m_xTableNames; + private XInteractionHandler oInteractionHandler; + private XNameAccess xNameAccess; + private XInterface xDatabaseContext; + private XCompletedConnection xCompleted; + // private int[] nDataTypes = null; + 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 iMaxColumnsInTable; + private int iMaxColumnNameLength = -1; + private int iMaxTableNameLength = -1; + private boolean bPasswordIsRequired; + // private boolean bFormatKeysareset = false; + private final static int NOLIMIT = 9999999; + protected final static int RID_DB_COMMON = 1000; + private final static int INVALID = 9999999; + public TypeInspector oTypeInspector; + private PropertyValue[] aInfoPropertyValues = null; + private boolean bisSQL92CheckEnabled = false; + 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) + { + e.printStackTrace(System.out); + } + } + return oNumberFormatter; + } + + public long getNullDateCorrection() + { + if (lDateCorrection == INVALID) + { + if (oNumberFormatter == null) + { + oNumberFormatter = getNumberFormatter(); + } + lDateCorrection = oNumberFormatter.getNullDateCorrection(); + } + return lDateCorrection; + } + + void getInterfaces(XMultiServiceFactory xMSF) + { + try + { + this.xMSF = xMSF; + xDatabaseContext = (XInterface) xMSF.createInstance("com.sun.star.sdb.DatabaseContext"); + xNameAccess = (XNameAccess) UnoRuntime.queryInterface(XNameAccess.class, xDatabaseContext); + XInterface xInteractionHandler = (XInterface) xMSF.createInstance("com.sun.star.sdb.InteractionHandler"); + oInteractionHandler = (XInteractionHandler) UnoRuntime.queryInterface(XInteractionHandler.class, xInteractionHandler); + DataSourceNames = xNameAccess.getElementNames(); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + } + + 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) + { + // getTableNames(); + return getTableNamesAsNameAccess().hasByName(_stablename); + } + + 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 = (XColumnsSupplier) UnoRuntime.queryInterface(XColumnsSupplier.class, oCommand); + xPropertySet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, oCommand); +// TODO: Performance leak getColumns() take very long. + xColumns = (XNameAccess) UnoRuntime.queryInterface(XNameAccess.class, xCommandCols.getColumns()); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + } + 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) + { + e.printStackTrace(System.out); + } + return bHasEscapeProcessing; + } + + // public void initCommandNames() + // { + // getTableNames(); + // } + + public XNameAccess getQueryNamesAsNameAccess() + { + XQueriesSupplier xDBQueries = (XQueriesSupplier) UnoRuntime.queryInterface(XQueriesSupplier.class, DBConnection); + xQueryNames = (XNameAccess) xDBQueries.getQueries(); + return xQueryNames; + } + + public XNameAccess getTableNamesAsNameAccess() + { + XTablesSupplier xDBTables = (XTablesSupplier) UnoRuntime.queryInterface(XTablesSupplier.class, DBConnection); + XNameAccess xTableNames = xDBTables.getTables(); + return xTableNames; + } + + 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 = (String[]) getTableNamesAsNameAccess().getElementNames(); + return TableNames; + } + + 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 this.NOLIMIT; + } + else + { + return itablecount; + } + } + catch (SQLException e) + { + e.printStackTrace(System.out); + return - 1; + } + } + + public int getMaxColumnsInSelect() + { + return iMaxColumnsInSelect; + } + + public int getMaxColumnsInGroupBy() + { + return iMaxColumnsInGroupBy; + } + + private void setMaxColumnsInSelect() throws SQLException + { + iMaxColumnsInSelect = xDBMetaData.getMaxColumnsInSelect(); + if (iMaxColumnsInSelect == 0) + { + iMaxColumnsInSelect = this.NOLIMIT; + } + } + + private void setMaxColumnsInGroupBy() throws SQLException + { + iMaxColumnsInGroupBy = xDBMetaData.getMaxColumnsInGroupBy(); + if (iMaxColumnsInGroupBy == 0) + { + iMaxColumnsInGroupBy = this.NOLIMIT; + } + } + + public int getMaxColumnsInTable() throws SQLException + { + iMaxColumnsInTable = xDBMetaData.getMaxColumnsInTable(); + if (iMaxColumnsInTable == 0) + { + iMaxColumnsInTable = this.NOLIMIT; + } + return iMaxColumnsInTable; + } + + private void getDataSourceObjects() throws Exception + { + try + { + xDBMetaData = DBConnection.getMetaData(); + XChild xChild = (XChild) UnoRuntime.queryInterface(XChild.class, DBConnection); + Object oDataSource = xChild.getParent(); + getDataSourceInterfaces(); + setMaxColumnsInGroupBy(); + setMaxColumnsInSelect(); + } + catch (SQLException e) + { + e.printStackTrace(System.out); + } + } + + public boolean isSQL92CheckEnabled() + { + try + { + if (aInfoPropertyValues == null) + { + aInfoPropertyValues = (PropertyValue[]) AnyConverter.toArray(this.xDataSourcePropertySet.getPropertyValue("Info")); + if (Properties.hasPropertyValue(aInfoPropertyValues, "EnableSQL92Check")) + { + bisSQL92CheckEnabled = AnyConverter.toBoolean(Properties.getPropertyValue(aInfoPropertyValues, "EnableSQL92Check")); + } + } + } + catch (Exception e) + { + e.printStackTrace(); + } + return bisSQL92CheckEnabled; + } + + 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 (xDataSource == null) + { + try + { + Object oDataSource = xNameAccess.getByName(DataSourceName); + xDataSource = (XDataSource) UnoRuntime.queryInterface(XDataSource.class, oDataSource); + } + catch (com.sun.star.container.NoSuchElementException e) + { + } + catch (com.sun.star.lang.WrappedTargetException e) + { + } + } + return xDataSource; + } + + private void setDataSourceByName(String _DataSourceName, boolean bgetInterfaces) + { + try + { + this.DataSourceName = _DataSourceName; + getDataSourceInterfaces(); + XDocumentDataSource xDocu = (XDocumentDataSource) UnoRuntime.queryInterface(XDocumentDataSource.class, getDataSource()); + if (xDocu != null) + { + xModel = xDocu.getDatabaseDocument(); + } + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + } + + public void getDataSourceInterfaces() throws Exception + { + xCompleted = (XCompletedConnection) UnoRuntime.queryInterface(XCompletedConnection.class, getDataSource()); + xDataSourcePropertySet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, getDataSource()); + bPasswordIsRequired = ((Boolean) xDataSourcePropertySet.getPropertyValue("IsPasswordRequired")).booleanValue(); + } + + public boolean getConnection(PropertyValue[] curproperties) + { + try + { + com.sun.star.sdbc.XConnection xConnection = null; + if (Properties.hasPropertyValue(curproperties, "ActiveConnection")) + { + xConnection = (com.sun.star.sdbc.XConnection) AnyConverter.toObject(com.sun.star.sdbc.XConnection.class, + Properties.getPropertyValue(curproperties, "ActiveConnection")); + if (xConnection != null) + { + com.sun.star.container.XChild child = (com.sun.star.container.XChild) UnoRuntime.queryInterface(com.sun.star.container.XChild.class, xConnection); + + xDataSource = (XDataSource) UnoRuntime.queryInterface(XDataSource.class, child.getParent()); + XDocumentDataSource xDocu = (XDocumentDataSource) UnoRuntime.queryInterface(XDocumentDataSource.class, this.xDataSource); + if (xDocu != null) + { + xModel = xDocu.getDatabaseDocument(); + } + XPropertySet xPSet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, xDataSource); + if (xPSet != null) + { + DataSourceName = AnyConverter.toString(xPSet.getPropertyValue("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")) + { + xDataSource = (XDataSource) UnoRuntime.queryInterface(XDataSource.class, Properties.getPropertyValue(curproperties, "DataSource")); + XDocumentDataSource xDocu = (XDocumentDataSource) UnoRuntime.queryInterface(XDocumentDataSource.class, this.xDataSource); + if (xDocu != null) + { + xModel = xDocu.getDatabaseDocument(); + } + return getConnection(xDataSource); + } + if (Properties.hasPropertyValue(curproperties, "DatabaseLocation")) + { + String sDataSourceName = AnyConverter.toString(Properties.getPropertyValue(curproperties, "DatabaseLocation")); + return getConnection(sDataSourceName); + } + else if (xConnection != null) + { + bdisposeConnection = false; + return getConnection(xConnection); + } + } + catch (IllegalArgumentException e) + { + e.printStackTrace(System.out); + } + catch (UnknownPropertyException e) + { + e.printStackTrace(System.out); + } + catch (WrappedTargetException e) + { + e.printStackTrace(System.out); + } + + return false; + } + + private boolean getConnection(String _DataSourceName) + { + setDataSourceByName(_DataSourceName, true); + return getConnection( getDataSource() ); + } + + private boolean getConnection(com.sun.star.sdbc.XConnection _DBConnection) + { + try + { + this.DBConnection = _DBConnection; + this.ConnectionTools = (XConnectionTools) UnoRuntime.queryInterface(XConnectionTools.class, this.DBConnection); + getDataSourceObjects(); + return true; + } + catch (Exception e) + { + e.printStackTrace(System.out); + return false; + } + } + + private boolean getConnection(XDataSource xDataSource) + { + Resource oResource = new Resource(xMSF, "Database", "dbw"); + try + { + int iMsg = 0; + boolean bgetConnection = false; + if (DBConnection != null) + { + xConnectionComponent.dispose(); + } + getDataSourceInterfaces(); + if (bPasswordIsRequired == false) + { + DBConnection = xDataSource.getConnection("", ""); + bgetConnection = true; + } + else + { + XInterface xInteractionHandler = (XInterface) xMSF.createInstance("com.sun.star.sdb.InteractionHandler"); + XInteractionHandler oInteractionHandler2 = (XInteractionHandler) UnoRuntime.queryInterface(XInteractionHandler.class, xInteractionHandler); + boolean bExitLoop = true; + do + { + XCompletedConnection xCompleted2 = (XCompletedConnection) UnoRuntime.queryInterface(XCompletedConnection.class, xDataSource); + try + { + DBConnection = xCompleted2.connectWithCompletion(oInteractionHandler2); + bgetConnection = DBConnection != null; + if (bgetConnection == false) + { + 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 == false); + } + if (bgetConnection == false) + { + String sMsgConnectionImpossible = oResource.getResText(RID_DB_COMMON + 35); + showMessageBox("ErrorBox", VclWindowPeerAttribute.OK, sMsgConnectionImpossible); + } + else + { + xConnectionComponent = (XComponent) UnoRuntime.queryInterface(XComponent.class, DBConnection); + ConnectionTools = (XConnectionTools) UnoRuntime.queryInterface(XConnectionTools.class, DBConnection); + getDataSourceObjects(); + } + return bgetConnection; + } + catch (Exception exception) + { + String sMsgConnectionImpossible = oResource.getResText(RID_DB_COMMON + 35); + showMessageBox("ErrorBox", VclWindowPeerAttribute.OK, sMsgConnectionImpossible); + exception.printStackTrace(System.out); + return false; + } + } + + public int getMaxColumnNameLength() + { + try + { + if (iMaxColumnNameLength <= 0) + { + iMaxColumnNameLength = xDBMetaData.getMaxColumnNameLength(); + } + return iMaxColumnNameLength; + } + catch (SQLException e) + { + e.printStackTrace(System.out); + return 0; + } + } + + public int getMaxTableNameLength() + { + try + { + if (iMaxTableNameLength <= 0) + { + iMaxTableNameLength = xDBMetaData.getMaxTableNameLength(); + } + return iMaxTableNameLength; + } + catch (SQLException e) + { + e.printStackTrace(System.out); + return 0; + } + } + + public boolean supportsCoreSQLGrammar() + { + try + { + return xDBMetaData.supportsCoreSQLGrammar(); + } + catch (SQLException e) + { + e.printStackTrace(System.out); + return false; + } + } + + public boolean supportsAutoIncrementation() + { + return false; + } + + /** + * 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 = (XQueryDefinitionsSupplier) UnoRuntime.queryInterface(XQueryDefinitionsSupplier.class, xDataSource); + XNameAccess xQueryDefs = xQueryDefinitionsSuppl.getQueryDefinitions(); + XSingleServiceFactory xSSFQueryDefs = (XSingleServiceFactory) UnoRuntime.queryInterface(XSingleServiceFactory.class, xQueryDefs); + Object oQuery = xSSFQueryDefs.createInstance(); //"com.sun.star.sdb.QueryDefinition" + XPropertySet xPSet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, oQuery); + + String s = _oSQLQueryComposer.m_xQueryAnalyzer.getQuery(); + xPSet.setPropertyValue("Command", s); + + XNameContainer xNameCont = (XNameContainer) UnoRuntime.queryInterface(XNameContainer.class, xQueryDefs); + XNameAccess xNameAccess = (XNameAccess) UnoRuntime.queryInterface(XNameAccess.class, xQueryDefs); + 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 exception) + { + callSQLErrorMessageDialog(exception, null); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + return false; + } + + public void dispose() + { + if ((DBConnection != null) && (this.bdisposeConnection)) + { + xConnectionComponent.dispose(); + } + } + + public XHierarchicalNameAccess getReportDocuments() + { + XReportDocumentsSupplier xReportDocumentSuppl = (XReportDocumentsSupplier) UnoRuntime.queryInterface(XReportDocumentsSupplier.class, this.xModel); + xReportDocumentSuppl.getReportDocuments(); + XHierarchicalNameAccess xReportHier = (XHierarchicalNameAccess) UnoRuntime.queryInterface(XHierarchicalNameAccess.class, xReportDocumentSuppl.getReportDocuments()); + return xReportHier; + } + + public XHierarchicalNameAccess getFormDocuments() + { + XFormDocumentsSupplier xFormDocumentSuppl = (XFormDocumentsSupplier) UnoRuntime.queryInterface(XFormDocumentsSupplier.class, xModel); + XHierarchicalNameAccess xFormHier = (XHierarchicalNameAccess) UnoRuntime.queryInterface(XHierarchicalNameAccess.class, xFormDocumentSuppl.getFormDocuments()); + return xFormHier; + } + + public boolean hasFormDocumentByName(String _sFormName) + { + XFormDocumentsSupplier xFormDocumentSuppl = (XFormDocumentsSupplier) UnoRuntime.queryInterface(XFormDocumentsSupplier.class, xModel); + XNameAccess xFormNameAccess = (XNameAccess) 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 _bcreateTemplate) + { + try + { + PropertyValue[] aDocProperties; + XModel xDocumentModel = (XModel) UnoRuntime.queryInterface(XModel.class, _xComponent); + String sPath = xDocumentModel.getURL(); + String basename = FileAccess.getBasename(sPath, "/"); + XCloseable xCloseable = (XCloseable) UnoRuntime.queryInterface(XCloseable.class, _xComponent); + _xComponent.dispose(); + xCloseable.close(false); + if (_bcreateTemplate) + { + aDocProperties = new PropertyValue[5]; + } + else + { + aDocProperties = new PropertyValue[4]; + } + aDocProperties[0] = Properties.createProperty("Name", basename); + aDocProperties[1] = Properties.createProperty("Parent", _xDocNameAccess); + aDocProperties[2] = Properties.createProperty("URL", sPath); + aDocProperties[3] = Properties.createProperty("DocumentTitle", basename); + if (_bcreateTemplate) + { + aDocProperties[4] = Properties.createProperty("AsTemplate", new Boolean(_bcreateTemplate)); + } + XMultiServiceFactory xDocMSF = (XMultiServiceFactory) UnoRuntime.queryInterface(XMultiServiceFactory.class, _xDocNameAccess); + Object oDBDocument = xDocMSF.createInstanceWithArguments("com.sun.star.sdb.DocumentDefinition", aDocProperties); + XHierarchicalNameContainer xHier = (XHierarchicalNameContainer) 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 = (XSimpleFileAccess) UnoRuntime.queryInterface(XSimpleFileAccess.class, xInterface); + xSimpleFileAccess.kill(sPath); + } + catch (Exception e) + { + e.printStackTrace(System.out); + } + } + + public XComponent[] openDatabaseDocument(String _docname, boolean _bAsTemplate, boolean _bOpenInDesign, XHierarchicalNameAccess _xDocuments) + { + XComponent[] xRetComponent = new XComponent[2]; + try + { + XComponentLoader xComponentLoader = (XComponentLoader) UnoRuntime.queryInterface(XComponentLoader.class, _xDocuments); + PropertyValue[] aPropertyValues = new PropertyValue[4]; + aPropertyValues[0] = Properties.createProperty("OpenMode", _bOpenInDesign ? "openDesign" : "open"); + aPropertyValues[1] = Properties.createProperty("ActiveConnection", this.DBConnection); + aPropertyValues[2] = Properties.createProperty("DocumentTitle", _docname); + aPropertyValues[3] = Properties.createProperty("AsTemplate", new Boolean(_bAsTemplate)); + XHierarchicalNameContainer xHier = (XHierarchicalNameContainer) UnoRuntime.queryInterface(XHierarchicalNameContainer.class, _xDocuments); + if (xHier.hasByHierarchicalName(_docname)) + { + xRetComponent[0] = (XComponent) UnoRuntime.queryInterface(XComponent.class, xHier.getByHierarchicalName(_docname)); + xRetComponent[1] = xComponentLoader.loadComponentFromURL(_docname, "", 0, aPropertyValues); + } + } + catch (Exception e) + { + e.printStackTrace(System.out); + } + return xRetComponent; + } + + public XComponent[] openFormDocument(String _sformname, boolean _bOpenInDesign) + { + XHierarchicalNameAccess xFormDocuments = getFormDocuments(); + return openDatabaseDocument(_sformname, false, _bOpenInDesign, xFormDocuments); + } + + public XComponent[] openReportDocument(String _sreportname, boolean _bAsTemplate, boolean _bOpenInDesign) + { + XHierarchicalNameAccess xReportDocuments = getReportDocuments(); + return openDatabaseDocument(_sreportname, _bAsTemplate, _bOpenInDesign, xReportDocuments); + } + + 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 = (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) + { + e.printStackTrace(); + } + return sColValues; + } + + public String[] getCatalogNames() + { + try + { + XResultSet xResultSet = xDBMetaData.getCatalogs(); + return StringsFromResultSet(xResultSet, 1); + } + catch (SQLException e) + { + e.printStackTrace(System.out); + return null; + } + } + + public String[] getSchemaNames() + { + try + { + XResultSet xResultSet = xDBMetaData.getSchemas(); + return StringsFromResultSet(xResultSet, 1); + } + catch (SQLException e) + { + e.printStackTrace(System.out); + return null; + } + } + + public boolean storeDatabaseDocumentToTempPath(XComponent _xcomponent, String _storename) + { + try + { + XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) UnoRuntime.queryInterface(XSimpleFileAccess.class, xInterface); + String storepath = FileAccess.getOfficePath(xMSF, "Temp", xSimpleFileAccess) + "/" + _storename; + XStorable xStoreable = (XStorable) 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) + { + e.printStackTrace(System.out); + 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 = (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 = (XExecutableDialog) UnoRuntime.queryInterface(XExecutableDialog.class, oDialog); + xExecutableDialog.execute(); + } + catch (com.sun.star.uno.Exception ex) + { + ex.printStackTrace(); + } + } + + public void finish() + { + xQueryNames = null; + oInteractionHandler = null; + xNameAccess = null; + xDatabaseContext = null; + xDBMetaData = null; + xDataSource = null; + xModel = null; + xCompleted = null; + xDataSourcePropertySet = null; + xWindowPeer = null; + DBConnection = null; + ConnectionTools = null; + xMSF = null; + xConnectionComponent = null; + oSQLQueryComposer = null; + CommandObjects = null; + } +} |