jdbc/src/main/java/org/apache/metamodel/jdbc/JdbcMetadataLoader.java - metamodel - Git at Google

 /**
  * 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 org.apache.metamodel.jdbc;

 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Set;
 import java.util.StringTokenizer;
 import java.util.concurrent.ConcurrentHashMap;

 import org.apache.metamodel.MetaModelException;
 import org.apache.metamodel.schema.Column;
 import org.apache.metamodel.schema.ColumnType;
 import org.apache.metamodel.schema.MutableColumn;
 import org.apache.metamodel.schema.MutableRelationship;
 import org.apache.metamodel.schema.Schema;
 import org.apache.metamodel.schema.Table;
 import org.apache.metamodel.schema.TableType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * {@link MetadataLoader} for JDBC metadata loading.
  */
 final class JdbcMetadataLoader implements MetadataLoader {

 	private static final Logger logger = LoggerFactory.getLogger(JdbcMetadataLoader.class);

 	private final JdbcDataContext _dataContext;
 	private final boolean _usesCatalogsAsSchemas;
 	private final String _identifierQuoteString;

 	// these three sets contains the system identifies of whether specific items
 	// have been loaded for tables/schemas. Using system identities avoid having
 	// to call equals(...) method etc. while doing lazy loading of these items.
 	// Invoking equals(...) would be prone to stack overflows ...
 	private final Set<Integer> _loadedRelations;
 	private final Set<Integer> _loadedColumns;
 	private final Set<Integer> _loadedIndexes;
 	private final Set<Integer> _loadedPrimaryKeys;

 	public JdbcMetadataLoader(JdbcDataContext dataContext, boolean usesCatalogsAsSchemas, String identifierQuoteString) {
 		_dataContext = dataContext;
 		_usesCatalogsAsSchemas = usesCatalogsAsSchemas;
 		_identifierQuoteString = identifierQuoteString;
 		_loadedRelations = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
 		_loadedColumns = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
 		_loadedIndexes = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
 		_loadedPrimaryKeys = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
 	}

 	@Override
 	public void loadTables(JdbcSchema schema) {
 		final Connection connection = _dataContext.getConnection();
 		try {
 			final DatabaseMetaData metaData = connection.getMetaData();

 			// Creates string array to represent the table types
 			final String[] types = JdbcUtils.getTableTypesAsStrings(_dataContext.getTableTypes());
 			loadTables(schema, metaData, types);
 		} catch (SQLException e) {
 			throw JdbcUtils.wrapException(e, "retrieve table metadata for " + schema.getName());
 		} finally {
 			_dataContext.close(connection, null, null);
 		}
 	}

 	private void loadTables(JdbcSchema schema, DatabaseMetaData metaData, String[] types) {
 		String catalogName = _dataContext.getCatalogName();

 		ResultSet rs = null;
 		try {
 			if (logger.isDebugEnabled()) {
 				logger.debug("Querying for table types " + Arrays.toString(types) + " in catalog: " + catalogName
 						+ ", schema: " + schema.getName());
 			}
 			if (_usesCatalogsAsSchemas) {
 				rs = metaData.getTables(schema.getName(), null, null, types);
 			} else {
 				rs = metaData.getTables(catalogName, schema.getName(), null, types);
 			}
 			schema.clearTables();
 			int tableNumber = -1;
 			while (rs.next()) {
 				tableNumber++;
 				String tableCatalog = rs.getString(1);
 				String tableSchema = rs.getString(2);
 				String tableName = rs.getString(3);
 				String tableTypeName = rs.getString(4);
 				TableType tableType = TableType.getTableType(tableTypeName);
 				String tableRemarks = rs.getString(5);

 				if (logger.isDebugEnabled()) {
 					logger.debug("Found table: tableCatalog=" + tableCatalog + ",tableSchema=" + tableSchema
 							+ ",tableName=" + tableName);
 				}

 				if (tableSchema == null) {
 					tableSchema = tableCatalog;
 				}

 				JdbcTable table = new JdbcTable(tableName, tableType, schema, this);
 				table.setRemarks(tableRemarks);
 				table.setQuote(_identifierQuoteString);
 				schema.addTable(table);
 			}

 			final int tablesReturned = tableNumber + 1;
 			if (tablesReturned == 0) {
 				logger.info("No table metadata records returned for schema '{}'", schema.getName());
 			} else {
 				logger.debug("Returned {} table metadata records for schema '{}'", new Object[] { tablesReturned,
 						schema.getName() });
 			}

 		} catch (SQLException e) {
 			throw JdbcUtils.wrapException(e, "retrieve table metadata for " + schema.getName());
 		} finally {
 			_dataContext.close(null, rs, null);
 		}
 	}

 	@Override
 	public void loadIndexes(JdbcTable table) {
 		final int identity = System.identityHashCode(table);
 		if (_loadedIndexes.contains(identity)) {
 			return;
 		}
 		synchronized (this) {
 			if (_loadedIndexes.contains(identity)) {
 				return;
 			}

 			final Connection connection = _dataContext.getConnection();
 			try {
 				DatabaseMetaData metaData = connection.getMetaData();
 				loadIndexes(table, metaData);
 				_loadedIndexes.add(identity);
 			} catch (SQLException e) {
 				throw JdbcUtils.wrapException(e, "load indexes");
 			} finally {
 				_dataContext.close(connection, null, null);
 			}
 		}
 	}

 	@Override
 	public void loadPrimaryKeys(JdbcTable table) {
 		final int identity = System.identityHashCode(table);
 		if (_loadedPrimaryKeys.contains(identity)) {
 			return;
 		}
 		synchronized (this) {
 			if (_loadedPrimaryKeys.contains(identity)) {
 				return;
 			}
 			final Connection connection = _dataContext.getConnection();
 			try {
 				DatabaseMetaData metaData = connection.getMetaData();
 				loadPrimaryKeys(table, metaData);
 				_loadedPrimaryKeys.add(identity);
 			} catch (SQLException e) {
 				throw JdbcUtils.wrapException(e, "load primary keys");
 			} finally {
 				_dataContext.close(connection, null, null);
 			}
 		}
 	}

 	private void loadPrimaryKeys(JdbcTable table, DatabaseMetaData metaData) throws MetaModelException {
 		Schema schema = table.getSchema();
 		ResultSet rs = null;

 		try {
 			if (_usesCatalogsAsSchemas) {
 				rs = metaData.getPrimaryKeys(schema.getName(), null, table.getName());
 			} else {
 				rs = metaData.getPrimaryKeys(_dataContext.getCatalogName(), schema.getName(), table.getName());
 			}
 			while (rs.next()) {
 				String columnName = rs.getString(4);
 				if (columnName != null) {
 					MutableColumn column = (MutableColumn) table.getColumnByName(columnName);
 					if (column != null) {
 						column.setPrimaryKey(true);
 					} else {
 						logger.error("Indexed column \"{}\" could not be found in table: {}", columnName, table);
 					}
 				}
 			}
 		} catch (SQLException e) {
 			throw JdbcUtils.wrapException(e, "retrieve primary keys for " + table.getName());
 		} finally {
 			_dataContext.close(null, rs, null);
 		}
 	}

 	private void loadIndexes(Table table, DatabaseMetaData metaData) throws MetaModelException {
 		Schema schema = table.getSchema();
 		ResultSet rs = null;
 		// Ticket #170: IndexInfo is nice-to-have, not need-to-have, so
 		// we will do a nice failover on SQLExceptions
 		try {
 			if (_usesCatalogsAsSchemas) {
 				rs = metaData.getIndexInfo(schema.getName(), null, table.getName(), false, true);
 			} else {
 				rs = metaData.getIndexInfo(_dataContext.getCatalogName(), schema.getName(), table.getName(), false,
 						true);
 			}
 			while (rs.next()) {
 				String columnName = rs.getString(9);
 				if (columnName != null) {
 					MutableColumn column = (MutableColumn) table.getColumnByName(columnName);
 					if (column != null) {
 						column.setIndexed(true);
 					} else {
 						logger.error("Indexed column \"{}\" could not be found in table: {}", columnName, table);
 					}
 				}
 			}
 		} catch (SQLException e) {
 			throw JdbcUtils.wrapException(e, "retrieve index information for " + table.getName());
 		} finally {
 			_dataContext.close(null, rs, null);
 		}
 	}

 	/**
 	 * Loads column metadata (no indexes though) for a table
 	 *
 	 * @param table
 	 */
 	@Override
 	public void loadColumns(JdbcTable table) {
 		final int identity = System.identityHashCode(table);
 		if (_loadedColumns.contains(identity)) {
 			return;
 		}
 		synchronized (this) {
 			if (_loadedColumns.contains(identity)) {
 				return;
 			}

 			final Connection connection = _dataContext.getConnection();
 			try {
 				DatabaseMetaData metaData = connection.getMetaData();
 				loadColumns(table, metaData);
 				_loadedColumns.add(identity);
 			} catch (Exception e) {
 				logger.error("Could not load columns for table: " + table, e);
 			} finally {
 				_dataContext.close(connection, null, null);
 			}
 		}
 	}

 	private void loadColumns(JdbcTable table, DatabaseMetaData metaData) {
 		final Schema schema = table.getSchema();
 		ResultSet rs = null;
 		try {
 			if (logger.isDebugEnabled()) {
 				logger.debug("Querying for columns in table: " + table.getName());
 			}
 			int columnNumber = -1;
 			if (_usesCatalogsAsSchemas) {
 				rs = metaData.getColumns(schema.getName(), null, table.getName(), null);
 			} else {
 				rs = metaData.getColumns(_dataContext.getCatalogName(), schema.getName(), table.getName(), null);
 			}
 			while (rs.next()) {
 				columnNumber++;
 				final String columnName = rs.getString(4);
 				if (_identifierQuoteString == null && new StringTokenizer(columnName).countTokens() > 1) {
 					logger.warn("column name contains whitespace: \"" + columnName + "\".");
 				}

 				final int jdbcType = rs.getInt(5);
 				final String nativeType = rs.getString(6);
 				final Integer columnSize = rs.getInt(7);

 				if (logger.isDebugEnabled()) {
 					logger.debug("Found column: table=" + table.getName() + ",columnName=" + columnName
 							+ ",nativeType=" + nativeType + ",columnSize=" + columnSize);
 				}

 				final ColumnType columnType = _dataContext.getQueryRewriter().getColumnType(jdbcType, nativeType,
 						columnSize);

 				final int jdbcNullable = rs.getInt(11);
 				final Boolean nullable;
 				if (jdbcNullable == DatabaseMetaData.columnNullable) {
 					nullable = true;
 				} else if (jdbcNullable == DatabaseMetaData.columnNoNulls) {
 					nullable = false;
 				} else {
 					nullable = null;
 				}

 				final String remarks = rs.getString(12);

 				final JdbcColumn column = new JdbcColumn(columnName, columnType, table, columnNumber, nullable);
 				column.setRemarks(remarks);
 				column.setNativeType(nativeType);
 				column.setColumnSize(columnSize);
 				column.setQuote(_identifierQuoteString);
 				table.addColumn(column);
 			}

 			final int columnsReturned = columnNumber + 1;
 			if (columnsReturned == 0) {
 				logger.info("No column metadata records returned for table '{}' in schema '{}'", table.getName(),
 						schema.getName());
 			} else {
 				logger.debug("Returned {} column metadata records for table '{}' in schema '{}'", new Object[] {
 						columnsReturned, table.getName(), schema.getName() });
 			}

 		} catch (SQLException e) {
 			throw JdbcUtils.wrapException(e, "retrieve table metadata for " + table.getName());
 		} finally {
 			_dataContext.close(null, rs, null);
 		}
 	}

 	@Override
 	public void loadRelations(JdbcSchema schema) {
 		final int identity = System.identityHashCode(schema);
 		if (_loadedRelations.contains(identity)) {
 			return;
 		}
 		synchronized (this) {
 			if (_loadedRelations.contains(identity)) {
 				return;
 			}
 			final Connection connection = _dataContext.getConnection();
 			try {
 				final Table[] tables = schema.getTables();
 				final DatabaseMetaData metaData = connection.getMetaData();
 				for (Table table : tables) {
 					loadRelations(table, metaData);
 				}
 				_loadedRelations.add(identity);
 			} catch (Exception e) {
 				logger.error("Could not load relations for schema: " + schema, e);
 			} finally {
 				_dataContext.close(connection, null, null);
 			}
 		}
 	}

 	private void loadRelations(Table table, DatabaseMetaData metaData) {
 		Schema schema = table.getSchema();
 		ResultSet rs = null;
 		try {
 			if (_usesCatalogsAsSchemas) {
 				rs = metaData.getImportedKeys(schema.getName(), null, table.getName());
 			} else {
 				rs = metaData.getImportedKeys(_dataContext.getCatalogName(), schema.getName(), table.getName());
 			}
 			loadRelations(rs, schema);
 		} catch (SQLException e) {
 			throw JdbcUtils.wrapException(e, "retrieve imported keys for " + table.getName());
 		} finally {
 			_dataContext.close(null, rs, null);
 		}
 	}

 	private void loadRelations(ResultSet rs, Schema schema) throws SQLException {
 		while (rs.next()) {
 			String pkTableName = rs.getString(3);
 			String pkColumnName = rs.getString(4);

 			Column pkColumn = null;
 			Table pkTable = schema.getTableByName(pkTableName);
 			if (pkTable != null) {
 				pkColumn = pkTable.getColumnByName(pkColumnName);
 			}
 			if (logger.isDebugEnabled()) {
 				logger.debug("Found primary key relation: tableName=" + pkTableName + ",columnName=" + pkColumnName
 						+ ", matching column: " + pkColumn);
 			}

 			String fkTableName = rs.getString(7);
 			String fkColumnName = rs.getString(8);
 			Column fkColumn = null;
 			Table fkTable = schema.getTableByName(fkTableName);
 			if (fkTable != null) {
 				fkColumn = fkTable.getColumnByName(fkColumnName);
 			}
 			if (logger.isDebugEnabled()) {
 				logger.debug("Found foreign key relation: tableName=" + fkTableName + ",columnName=" + fkColumnName
 						+ ", matching column: " + fkColumn);
 			}

 			if (pkColumn == null || fkColumn == null) {
 				logger.error(
 						"Could not find relation columns: pkTableName={},pkColumnName={},fkTableName={},fkColumnName={}",
 						new Object[] { pkTableName, pkColumnName, fkTableName, fkColumnName });
 				logger.error("pkColumn={}", pkColumn);
 				logger.error("fkColumn={}", fkColumn);
 			} else {
 				MutableRelationship.createRelationship(new Column[] { pkColumn }, new Column[] { fkColumn });
 			}
 		}
 	}

 }
	/**
	* 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 org.apache.metamodel.jdbc;

	import java.sql.Connection;
	import java.sql.DatabaseMetaData;
	import java.sql.ResultSet;
	import java.sql.SQLException;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Set;
	import java.util.StringTokenizer;
	import java.util.concurrent.ConcurrentHashMap;

	import org.apache.metamodel.MetaModelException;
	import org.apache.metamodel.schema.Column;
	import org.apache.metamodel.schema.ColumnType;
	import org.apache.metamodel.schema.MutableColumn;
	import org.apache.metamodel.schema.MutableRelationship;
	import org.apache.metamodel.schema.Schema;
	import org.apache.metamodel.schema.Table;
	import org.apache.metamodel.schema.TableType;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	* {@link MetadataLoader} for JDBC metadata loading.
	*/
	final class JdbcMetadataLoader implements MetadataLoader {

	private static final Logger logger = LoggerFactory.getLogger(JdbcMetadataLoader.class);

	private final JdbcDataContext _dataContext;
	private final boolean _usesCatalogsAsSchemas;
	private final String _identifierQuoteString;

	// these three sets contains the system identifies of whether specific items
	// have been loaded for tables/schemas. Using system identities avoid having
	// to call equals(...) method etc. while doing lazy loading of these items.
	// Invoking equals(...) would be prone to stack overflows ...
	private final Set<Integer> _loadedRelations;
	private final Set<Integer> _loadedColumns;
	private final Set<Integer> _loadedIndexes;
	private final Set<Integer> _loadedPrimaryKeys;

	public JdbcMetadataLoader(JdbcDataContext dataContext, boolean usesCatalogsAsSchemas, String identifierQuoteString) {
	_dataContext = dataContext;
	_usesCatalogsAsSchemas = usesCatalogsAsSchemas;
	_identifierQuoteString = identifierQuoteString;
	_loadedRelations = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
	_loadedColumns = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
	_loadedIndexes = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
	_loadedPrimaryKeys = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
	}

	@Override
	public void loadTables(JdbcSchema schema) {
	final Connection connection = _dataContext.getConnection();
	try {
	final DatabaseMetaData metaData = connection.getMetaData();

	// Creates string array to represent the table types
	final String[] types = JdbcUtils.getTableTypesAsStrings(_dataContext.getTableTypes());
	loadTables(schema, metaData, types);
	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "retrieve table metadata for " + schema.getName());
	} finally {
	_dataContext.close(connection, null, null);
	}
	}

	private void loadTables(JdbcSchema schema, DatabaseMetaData metaData, String[] types) {
	String catalogName = _dataContext.getCatalogName();

	ResultSet rs = null;
	try {
	if (logger.isDebugEnabled()) {
	logger.debug("Querying for table types " + Arrays.toString(types) + " in catalog: " + catalogName
	+ ", schema: " + schema.getName());
	}
	if (_usesCatalogsAsSchemas) {
	rs = metaData.getTables(schema.getName(), null, null, types);
	} else {
	rs = metaData.getTables(catalogName, schema.getName(), null, types);
	}
	schema.clearTables();
	int tableNumber = -1;
	while (rs.next()) {
	tableNumber++;
	String tableCatalog = rs.getString(1);
	String tableSchema = rs.getString(2);
	String tableName = rs.getString(3);
	String tableTypeName = rs.getString(4);
	TableType tableType = TableType.getTableType(tableTypeName);
	String tableRemarks = rs.getString(5);

	if (logger.isDebugEnabled()) {
	logger.debug("Found table: tableCatalog=" + tableCatalog + ",tableSchema=" + tableSchema
	+ ",tableName=" + tableName);
	}

	if (tableSchema == null) {
	tableSchema = tableCatalog;
	}

	JdbcTable table = new JdbcTable(tableName, tableType, schema, this);
	table.setRemarks(tableRemarks);
	table.setQuote(_identifierQuoteString);
	schema.addTable(table);
	}

	final int tablesReturned = tableNumber + 1;
	if (tablesReturned == 0) {
	logger.info("No table metadata records returned for schema '{}'", schema.getName());
	} else {
	logger.debug("Returned {} table metadata records for schema '{}'", new Object[] { tablesReturned,
	schema.getName() });
	}

	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "retrieve table metadata for " + schema.getName());
	} finally {
	_dataContext.close(null, rs, null);
	}
	}

	@Override
	public void loadIndexes(JdbcTable table) {
	final int identity = System.identityHashCode(table);
	if (_loadedIndexes.contains(identity)) {
	return;
	}
	synchronized (this) {
	if (_loadedIndexes.contains(identity)) {
	return;
	}

	final Connection connection = _dataContext.getConnection();
	try {
	DatabaseMetaData metaData = connection.getMetaData();
	loadIndexes(table, metaData);
	_loadedIndexes.add(identity);
	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "load indexes");
	} finally {
	_dataContext.close(connection, null, null);
	}
	}
	}

	@Override
	public void loadPrimaryKeys(JdbcTable table) {
	final int identity = System.identityHashCode(table);
	if (_loadedPrimaryKeys.contains(identity)) {
	return;
	}
	synchronized (this) {
	if (_loadedPrimaryKeys.contains(identity)) {
	return;
	}
	final Connection connection = _dataContext.getConnection();
	try {
	DatabaseMetaData metaData = connection.getMetaData();
	loadPrimaryKeys(table, metaData);
	_loadedPrimaryKeys.add(identity);
	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "load primary keys");
	} finally {
	_dataContext.close(connection, null, null);
	}
	}
	}

	private void loadPrimaryKeys(JdbcTable table, DatabaseMetaData metaData) throws MetaModelException {
	Schema schema = table.getSchema();
	ResultSet rs = null;

	try {
	if (_usesCatalogsAsSchemas) {
	rs = metaData.getPrimaryKeys(schema.getName(), null, table.getName());
	} else {
	rs = metaData.getPrimaryKeys(_dataContext.getCatalogName(), schema.getName(), table.getName());
	}
	while (rs.next()) {
	String columnName = rs.getString(4);
	if (columnName != null) {
	MutableColumn column = (MutableColumn) table.getColumnByName(columnName);
	if (column != null) {
	column.setPrimaryKey(true);
	} else {
	logger.error("Indexed column \"{}\" could not be found in table: {}", columnName, table);
	}
	}
	}
	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "retrieve primary keys for " + table.getName());
	} finally {
	_dataContext.close(null, rs, null);
	}
	}

	private void loadIndexes(Table table, DatabaseMetaData metaData) throws MetaModelException {
	Schema schema = table.getSchema();
	ResultSet rs = null;
	// Ticket #170: IndexInfo is nice-to-have, not need-to-have, so
	// we will do a nice failover on SQLExceptions
	try {
	if (_usesCatalogsAsSchemas) {
	rs = metaData.getIndexInfo(schema.getName(), null, table.getName(), false, true);
	} else {
	rs = metaData.getIndexInfo(_dataContext.getCatalogName(), schema.getName(), table.getName(), false,
	true);
	}
	while (rs.next()) {
	String columnName = rs.getString(9);
	if (columnName != null) {
	MutableColumn column = (MutableColumn) table.getColumnByName(columnName);
	if (column != null) {
	column.setIndexed(true);
	} else {
	logger.error("Indexed column \"{}\" could not be found in table: {}", columnName, table);
	}
	}
	}
	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "retrieve index information for " + table.getName());
	} finally {
	_dataContext.close(null, rs, null);
	}
	}

	/**
	* Loads column metadata (no indexes though) for a table
	*
	* @param table
	*/
	@Override
	public void loadColumns(JdbcTable table) {
	final int identity = System.identityHashCode(table);
	if (_loadedColumns.contains(identity)) {
	return;
	}
	synchronized (this) {
	if (_loadedColumns.contains(identity)) {
	return;
	}

	final Connection connection = _dataContext.getConnection();
	try {
	DatabaseMetaData metaData = connection.getMetaData();
	loadColumns(table, metaData);
	_loadedColumns.add(identity);
	} catch (Exception e) {
	logger.error("Could not load columns for table: " + table, e);
	} finally {
	_dataContext.close(connection, null, null);
	}
	}
	}

	private void loadColumns(JdbcTable table, DatabaseMetaData metaData) {
	final Schema schema = table.getSchema();
	ResultSet rs = null;
	try {
	if (logger.isDebugEnabled()) {
	logger.debug("Querying for columns in table: " + table.getName());
	}
	int columnNumber = -1;
	if (_usesCatalogsAsSchemas) {
	rs = metaData.getColumns(schema.getName(), null, table.getName(), null);
	} else {
	rs = metaData.getColumns(_dataContext.getCatalogName(), schema.getName(), table.getName(), null);
	}
	while (rs.next()) {
	columnNumber++;
	final String columnName = rs.getString(4);
	if (_identifierQuoteString == null && new StringTokenizer(columnName).countTokens() > 1) {
	logger.warn("column name contains whitespace: \"" + columnName + "\".");
	}

	final int jdbcType = rs.getInt(5);
	final String nativeType = rs.getString(6);
	final Integer columnSize = rs.getInt(7);

	if (logger.isDebugEnabled()) {
	logger.debug("Found column: table=" + table.getName() + ",columnName=" + columnName
	+ ",nativeType=" + nativeType + ",columnSize=" + columnSize);
	}

	final ColumnType columnType = _dataContext.getQueryRewriter().getColumnType(jdbcType, nativeType,
	columnSize);

	final int jdbcNullable = rs.getInt(11);
	final Boolean nullable;
	if (jdbcNullable == DatabaseMetaData.columnNullable) {
	nullable = true;
	} else if (jdbcNullable == DatabaseMetaData.columnNoNulls) {
	nullable = false;
	} else {
	nullable = null;
	}

	final String remarks = rs.getString(12);

	final JdbcColumn column = new JdbcColumn(columnName, columnType, table, columnNumber, nullable);
	column.setRemarks(remarks);
	column.setNativeType(nativeType);
	column.setColumnSize(columnSize);
	column.setQuote(_identifierQuoteString);
	table.addColumn(column);
	}

	final int columnsReturned = columnNumber + 1;
	if (columnsReturned == 0) {
	logger.info("No column metadata records returned for table '{}' in schema '{}'", table.getName(),
	schema.getName());
	} else {
	logger.debug("Returned {} column metadata records for table '{}' in schema '{}'", new Object[] {
	columnsReturned, table.getName(), schema.getName() });
	}

	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "retrieve table metadata for " + table.getName());
	} finally {
	_dataContext.close(null, rs, null);
	}
	}

	@Override
	public void loadRelations(JdbcSchema schema) {
	final int identity = System.identityHashCode(schema);
	if (_loadedRelations.contains(identity)) {
	return;
	}
	synchronized (this) {
	if (_loadedRelations.contains(identity)) {
	return;
	}
	final Connection connection = _dataContext.getConnection();
	try {
	final Table[] tables = schema.getTables();
	final DatabaseMetaData metaData = connection.getMetaData();
	for (Table table : tables) {
	loadRelations(table, metaData);
	}
	_loadedRelations.add(identity);
	} catch (Exception e) {
	logger.error("Could not load relations for schema: " + schema, e);
	} finally {
	_dataContext.close(connection, null, null);
	}
	}
	}

	private void loadRelations(Table table, DatabaseMetaData metaData) {
	Schema schema = table.getSchema();
	ResultSet rs = null;
	try {
	if (_usesCatalogsAsSchemas) {
	rs = metaData.getImportedKeys(schema.getName(), null, table.getName());
	} else {
	rs = metaData.getImportedKeys(_dataContext.getCatalogName(), schema.getName(), table.getName());
	}
	loadRelations(rs, schema);
	} catch (SQLException e) {
	throw JdbcUtils.wrapException(e, "retrieve imported keys for " + table.getName());
	} finally {
	_dataContext.close(null, rs, null);
	}
	}

	private void loadRelations(ResultSet rs, Schema schema) throws SQLException {
	while (rs.next()) {
	String pkTableName = rs.getString(3);
	String pkColumnName = rs.getString(4);

	Column pkColumn = null;
	Table pkTable = schema.getTableByName(pkTableName);
	if (pkTable != null) {
	pkColumn = pkTable.getColumnByName(pkColumnName);
	}
	if (logger.isDebugEnabled()) {
	logger.debug("Found primary key relation: tableName=" + pkTableName + ",columnName=" + pkColumnName
	+ ", matching column: " + pkColumn);
	}

	String fkTableName = rs.getString(7);
	String fkColumnName = rs.getString(8);
	Column fkColumn = null;
	Table fkTable = schema.getTableByName(fkTableName);
	if (fkTable != null) {
	fkColumn = fkTable.getColumnByName(fkColumnName);
	}
	if (logger.isDebugEnabled()) {
	logger.debug("Found foreign key relation: tableName=" + fkTableName + ",columnName=" + fkColumnName
	+ ", matching column: " + fkColumn);
	}

	if (pkColumn == null \|\| fkColumn == null) {
	logger.error(
	"Could not find relation columns: pkTableName={},pkColumnName={},fkTableName={},fkColumnName={}",
	new Object[] { pkTableName, pkColumnName, fkTableName, fkColumnName });
	logger.error("pkColumn={}", pkColumn);
	logger.error("fkColumn={}", fkColumn);
	} else {
	MutableRelationship.createRelationship(new Column[] { pkColumn }, new Column[] { fkColumn });
	}
	}
	}

	}