dk.eobjects.metamodel.JdbcDataContextStrategy Maven / Gradle / Ivy
The newest version!
/**
* This file is part of MetaModel.
*
* MetaModel is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MetaModel 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with MetaModel. If not, see catalogs = new ArrayList();
try {
rs = metaData.getCatalogs();
while (rs.next()) {
String catalogName = rs.getString(1);
_log.debug("Found catalogName: " + catalogName);
catalogs.add(catalogName);
}
} catch (SQLException e) {
_log.error("Error retrieving catalog metadata", e);
} finally {
close(rs, null);
_log.info("Retrieved " + catalogs.size() + " catalogs");
}
return catalogs.toArray(new String[catalogs.size()]);
}
/**
* Gets an appropriate connection object to use - either a dedicated
* connection or a new connection from the datasource object
*/
private Connection getConnection() {
if (_dataSource == null) {
return _connection;
}
try {
return _dataSource.getConnection();
} catch (SQLException e) {
throw new MetaModelException("Could not establish connection", e);
}
}
public String getDefaultSchemaName() {
// Use a boolean to check if the result has been
// found, because a schema name can actually be
// null (for example in the case of Firebird
// databases).
boolean found = false;
String result = null;
try {
String[] schemaNames = getSchemaNames();
// First strategy: If there's only one schema available, that must
// be it
if (schemaNames.length == 1) {
result = schemaNames[0];
found = true;
}
if (!found) {
Connection connection = getConnection();
DatabaseMetaData metaData = connection.getMetaData();
// Second strategy: Find default schema name by examining the
// URL
if (!found) {
String url = metaData.getURL();
if (url != null && url.length() > 0) {
if (schemaNames.length > 0) {
StringTokenizer st = new StringTokenizer(url,
"/\\:");
int tokenCount = st.countTokens();
if (tokenCount > 0) {
for (int i = 1; i < tokenCount; i++) {
st.nextToken();
}
String lastToken = st.nextToken();
for (int i = 0; i < schemaNames.length
&& !found; i++) {
String schemaName = schemaNames[i];
if (lastToken.indexOf(schemaName) != -1) {
result = schemaName;
found = true;
}
}
}
}
}
}
// Third strategy: Check for schema equal to username
if (!found) {
String username = metaData.getUserName();
if (username != null) {
for (int i = 0; i < schemaNames.length && !found; i++) {
if (username.equalsIgnoreCase(schemaNames[i])) {
result = schemaNames[i];
found = true;
}
}
}
}
// Fourth strategy: Find default schema name by vendor-specific
// hacks
if (!found) {
if (DATABASE_PRODUCT_POSTGRESQL
.equalsIgnoreCase(_databaseProductName)) {
if (_catalogName == null) {
result = "public";
} else {
result = _catalogName;
}
found = true;
}
if (DATABASE_PRODUCT_HSQLDB
.equalsIgnoreCase(_databaseProductName)) {
for (int i = 0; i < schemaNames.length && !found; i++) {
String schemaName = schemaNames[i];
if ("PUBLIC".equals(schemaName)) {
result = schemaName;
found = true;
}
}
}
}
}
} catch (SQLException e) {
_log.error("Could not determine default schema name: "
+ e.getMessage());
}
return result;
}
public Schema getSchemaByName(String name) throws MetaModelException {
DatabaseMetaData metaData;
try {
metaData = getConnection().getMetaData();
} catch (SQLException e) {
throw new MetaModelException(e);
}
JdbcSchema schema = new JdbcSchema(name, this);
// Creates string array to represent the table types
String[] types = getTableTypeAsString();
loadTables(schema, metaData, types);
return schema;
}
public String[] getSchemaNames() throws MetaModelException {
try {
DatabaseMetaData metaData = getConnection().getMetaData();
Collection result = new ArrayList();
if (DATABASE_PRODUCT_SQLSERVER.equals(_databaseProductName)) {
result = getSchemaSQLServerNames();
} else if (_usesCatalogsAsSchemas) {
String[] catalogNames = getCatalogNames();
for (String name : catalogNames) {
_log.info("Found catalogName: " + name);
result.add(name);
}
} else {
ResultSet rs = metaData.getSchemas();
while (rs.next()) {
String schemaName = rs.getString(1);
_log.info("Found schemaName: " + schemaName);
result.add(schemaName);
}
rs.close();
}
if (DATABASE_PRODUCT_MYSQL.equals(_databaseProductName)) {
result.remove("information_schema");
}
// If still no schemas are found, add a schema with a null-name
if (result.isEmpty()) {
_log
.info("No schemas or catalogs found. Creating unnamed schema.");
result.add(null);
}
return result.toArray(new String[result.size()]);
} catch (SQLException e) {
throw new MetaModelException(e);
}
}
/**
* Microsoft SQL Server returns users instead of schemas when calling
* metadata.getSchemas() This is a simple workaround.
*
* @return
* @throws SQLException
*/
private Set getSchemaSQLServerNames() throws SQLException {
// Distinct schema names. metaData.getTables() is a denormalized
// resultset
Set schemas = new HashSet();
DatabaseMetaData metaData = getConnection().getMetaData();
ResultSet rs = metaData.getTables(_catalogName, null, null,
getTableTypeAsString());
while (rs.next()) {
schemas.add(rs.getString("TABLE_SCHEM"));
}
return schemas;
}
private String[] getTableTypeAsString() {
String[] types = new String[_tableTypes.length];
for (int i = 0; i < types.length; i++) {
if (_tableTypes[i] == TableType.OTHER) {
// if the OTHER type has been selected, don't use a table
// pattern (ie. include all types)
types = null;
break;
}
types[i] = _tableTypes[i].toString();
}
return types;
}
public JdbcDataContextStrategy setQueryRewriter(IQueryRewriter queryRewriter) {
_queryRewriter = queryRewriter;
return this;
}
public IQueryRewriter getQueryRewriter() {
return _queryRewriter;
}
public String getIdentifierQuoteString() {
return _identifierQuoteString;
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy