protected synchronized String getProcedureName(Connection dConn, Connection gConn) {
/// avoid #42569
ResultSet rs = null;
try {
rs = gConn.getMetaData().getProcedures(null, null, null);
List procNames = ResultSetHelper.asList(rs, false);
Log.getLogWriter().info("procedure names are " + ResultSetHelper.listToString(procNames));
rs.close();
} catch (SQLException se) {
SQLHelper.handleSQLException(se);
}
try {
rs = gConn.getMetaData().getFunctions(null, null, null);
} catch (SQLException se) {
SQLHelper.handleSQLException(se);
}
List funcNames = ResultSetHelper.asList(rs, false);
Log.getLogWriter().info("function names are " + ResultSetHelper.listToString(funcNames));
if (procedureNames == null) {
ArrayList<String> procs = new ArrayList<String>();
procs.addAll(ProcedureDDLStmt.modifyProcNameList);
procs.addAll(ProcedureDDLStmt.nonModifyProcNameList);
procedureNames = new ArrayList<String>(procs);
}
return procedureNames.get(SQLTest.random.nextInt(procedureNames.size()));
}
/**
* gets the connection key. return null if it cannot be determined.
*
* @return the key or null
*/
private static String getConnectionKey(Connection con) {
String uName = null;
String url = null;
try {
uName = con.getMetaData().getUserName();
url = con.getMetaData().getURL();
} catch (SQLException e) {
LOG.error("unable to get DB url", e);
}
return uName != null && url != null ? uName + " @ " + url : null;
}
private boolean columnExists(Connection connection, String table, String column)
throws SQLException {
ResultSet columns = connection.getMetaData().getColumns(null, null, table, column);
boolean exists = columns.next();
columns.close();
return exists;
}
SqlDialect get(DataSource dataSource) {
Connection connection = null;
try {
connection = dataSource.getConnection();
DatabaseMetaData metaData = connection.getMetaData();
String productName = metaData.getDatabaseProductName();
String productVersion = metaData.getDatabaseProductVersion();
List key = Arrays.asList(productName, productVersion);
SqlDialect dialect = map.get(key);
if (dialect == null) {
final SqlDialect.DatabaseProduct product =
SqlDialect.getProduct(productName, productVersion);
dialect = new SqlDialect(product, productName, metaData.getIdentifierQuoteString());
map.put(key, dialect);
}
connection.close();
connection = null;
return dialect;
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
// ignore
}
}
}
}
/**
* Constructor creates and initializes the meta data object create DS object per table
*
* @param tableNames - String array of database table names ,It can be zero element array
* @param singleService - select the service generation mode true one service for whole database
* when it false services per table wise
* @param dataSourceId - carbon datasource id it can be null
* <p>When create the connection there are 3 away to do it , First way is provide the relevant
* information(url, driver, username, password) which need to create connection that time
* other fields(connection, datasourceId) should be null
* <p>Second way directly you can provide connection instance
* <p>final way is you can provide carbon datasource id(name)
* <p>if you wish to use all the tables of database you can provide zero element array
*/
public DSGenerator(
String dataSourceId,
String dbName,
String[] schemas,
String[] tableNames,
boolean singleService,
String nameSpace,
String serviceName) {
this.DSErrorList = new ArrayList<String>();
try {
Connection connection;
String[] tableNameList = tableNames;
if (dataSourceId != null) {
connection = createConnection(dataSourceId);
DatabaseMetaData metaObject = connection.getMetaData();
if (tableNameList.length == 0) {
tableNameList = DSGenerator.getTableList(connection, dbName, schemas);
}
if (singleService) {
this.generatedService =
generateService(
dataSourceId, dbName, schemas, tableNameList, metaObject, nameSpace, serviceName);
} else {
this.generatedServiceList =
generateServices(dataSourceId, dbName, schemas, tableNameList, metaObject, nameSpace);
}
connection.close();
}
} catch (Exception e) {
log.error("Meta Object initialization failed due to ", e);
}
}
private ImmutableMap<String, JdbcTable> computeTables() {
Connection connection = null;
ResultSet resultSet = null;
try {
connection = dataSource.getConnection();
DatabaseMetaData metaData = connection.getMetaData();
resultSet = metaData.getTables(catalog, schema, null, null);
final ImmutableMap.Builder<String, JdbcTable> builder = ImmutableMap.builder();
while (resultSet.next()) {
final String tableName = resultSet.getString(3);
final String catalogName = resultSet.getString(1);
final String schemaName = resultSet.getString(2);
final String tableTypeName = resultSet.getString(4);
// Clean up table type. In particular, this ensures that 'SYSTEM TABLE',
// returned by Phoenix among others, maps to TableType.SYSTEM_TABLE.
// We know enum constants are upper-case without spaces, so we can't
// make things worse.
final String tableTypeName2 = tableTypeName.toUpperCase().replace(' ', '_');
final TableType tableType = Util.enumVal(TableType.class, tableTypeName2);
final JdbcTable table = new JdbcTable(this, catalogName, schemaName, tableName, tableType);
builder.put(tableName, table);
}
return builder.build();
} catch (SQLException e) {
throw new RuntimeException("Exception while reading tables", e);
} finally {
close(connection, null, resultSet);
}
}
private Table createTable(Connection conn, ResultSet rs) throws SQLException {
String realTableName = null;
try {
ResultSetMetaData rsMetaData = rs.getMetaData();
String schemaName = rs.getString("TABLE_SCHEM") == null ? "" : rs.getString("TABLE_SCHEM");
realTableName = rs.getString("TABLE_NAME");
String tableType = rs.getString("TABLE_TYPE");
String remarks = rs.getString("REMARKS");
if (remarks == null && dbHelper.isOracleDataBase()) {
remarks = getOracleTableComments(realTableName);
}
Table table = new Table();
table.setSqlName(realTableName);
table.setRemarks(remarks);
if ("SYNONYM".equals(tableType) && dbHelper.isOracleDataBase()) {
table.setOwnerSynonymName(getSynonymOwner(realTableName));
}
retriveTableColumns(table);
table.initExportedKeys(conn.getMetaData());
table.initImportedKeys(conn.getMetaData());
BeanHelper.copyProperties(
table, TableOverrideValuesProvider.getTableOverrideValues(table.getSqlName()));
return table;
} catch (SQLException e) {
throw new RuntimeException("create table object error,tableName:" + realTableName, e);
}
}
private List getAllTables(Connection conn) throws SQLException {
DatabaseMetaData dbMetaData = conn.getMetaData();
ResultSet rs = dbMetaData.getTables(getCatalog(), getSchema(), null, null);
List tables = new ArrayList();
while (rs.next()) {
tables.add(createTable(conn, rs));
}
return tables;
}
RelProtoDataType getRelDataType(String catalogName, String schemaName, String tableName)
throws SQLException {
Connection connection = null;
try {
connection = dataSource.getConnection();
DatabaseMetaData metaData = connection.getMetaData();
return getRelDataType(metaData, catalogName, schemaName, tableName);
} finally {
close(connection, null, null);
}
}
private String getMainConnName() throws RemoteException {
String schema = "";
try {
Connection connMain = getConnection();
schema = connMain.getMetaData().getUserName();
closeConnection(connMain);
} catch (Exception exc) {
exc.printStackTrace();
throw processException(exc);
}
return schema;
}
public static String[] getSchemas(Connection connection) throws Exception {
if (connection != null) {
List<String> schemaList = new ArrayList<String>();
DatabaseMetaData mObject = connection.getMetaData();
ResultSet schemas = mObject.getSchemas();
while (schemas.next()) {
schemaList.add(schemas.getString(DBConstants.DataServiceGenerator.TABLE_SCHEM));
}
String str[] = schemaList.toArray(new String[schemaList.size()]);
return str;
} else {
return null;
}
}
private Table _getTable(String catalog, String schema, String tableName) throws SQLException {
if (tableName == null || tableName.trim().length() == 0)
throw new IllegalArgumentException("tableName must be not empty");
catalog = StringHelper.defaultIfEmpty(catalog, null);
schema = StringHelper.defaultIfEmpty(schema, null);
Connection conn = getConnection();
DatabaseMetaData dbMetaData = conn.getMetaData();
ResultSet rs = dbMetaData.getTables(catalog, schema, tableName, null);
while (rs.next()) {
Table table = createTable(conn, rs);
return table;
}
return null;
}
private void loadDatabaseMetadata() {
if (!databaseMetadataLoaded) {
String componentName = "UNKNOWN";
Connection con = null;
try {
componentName = getMetaComponent().getName();
con = DataSourceConnectionProvider.getByComponent(componentName).getConnection();
DatabaseMetaData metaData = con.getMetaData();
supportsSchemasInDataManipulation = metaData.supportsSchemasInDataManipulation();
Collection timeDateFunctions =
Strings.toCollection(metaData.getTimeDateFunctions().toUpperCase());
//
// another solution instead of the use of 'if' would be to use a xml with
// the information of the functions from each BBDD
if ("DB2 UDB for AS/400".equals(metaData.getDatabaseProductName())
|| "Oracle".equals(metaData.getDatabaseProductName())
|| "PostgresSQL".equals(metaData.getDatabaseProductName())) {
supportsTranslateFunction = true;
}
if ("Oracle".equals(metaData.getDatabaseProductName())
|| "PostgreSQL".equals(metaData.getDatabaseProductName())) {
supportsYearFunction = supportsMonthFunction = false;
} else {
supportsYearFunction = timeDateFunctions.contains("YEAR");
supportsMonthFunction = timeDateFunctions.contains("MONTH");
}
databaseMetadataLoaded = true;
} catch (Exception ex) {
log.warn(XavaResources.getString("load_database_metadata_warning"));
} finally {
try {
if (con != null) {
con.close();
}
} catch (SQLException e) {
log.warn(XavaResources.getString("close_connection_warning"));
}
}
}
}
private static Map<PwmAboutProperty, String> getConnectionDebugProperties(
final Connection connection) {
if (connection != null) {
try {
final Map<PwmAboutProperty, String> returnObj = new LinkedHashMap<>();
final DatabaseMetaData databaseMetaData = connection.getMetaData();
returnObj.put(PwmAboutProperty.database_driverName, databaseMetaData.getDriverName());
returnObj.put(PwmAboutProperty.database_driverVersion, databaseMetaData.getDriverVersion());
returnObj.put(
PwmAboutProperty.database_databaseProductName,
databaseMetaData.getDatabaseProductName());
returnObj.put(
PwmAboutProperty.database_databaseProductVersion,
databaseMetaData.getDatabaseProductVersion());
return Collections.unmodifiableMap(returnObj);
} catch (SQLException e) {
LOGGER.error("error rading jdbc meta data: " + e.getMessage());
}
}
return Collections.emptyMap();
}
public List getIdentityTables() {
// delete all the data in the jbpm tables
List jbpmTableNames = new ArrayList();
try {
createConnection();
ResultSet resultSet = connection.getMetaData().getTables("", "", null, null);
while (resultSet.next()) {
String tableName = resultSet.getString("TABLE_NAME");
if ((tableName != null)
&& (tableName.length() > 5)
&& (IDENTITY_TABLE_PREFIX.equalsIgnoreCase(tableName.substring(0, 5)))) {
jbpmTableNames.add(tableName);
}
}
} catch (SQLException e) {
throw new RuntimeException("couldn't get the jbpm table names");
} finally {
closeConnection();
}
return jbpmTableNames;
}
public static String[] getTableList(Connection connection, String dbName, String[] schemas)
throws SQLException {
if (connection != null) {
List<String> tableList = new ArrayList<String>();
// String dbName = connection.getCatalog();
DatabaseMetaData mObject = connection.getMetaData();
if (schemas.length != 0) {
tableList = getTableNamesList(mObject, dbName, schemas[0]);
if (tableList.size()
== 0) { // for some drivers catalog is not same as the dbname (eg: DB2). In that case
// search tables only using schema.
tableList = getTableNamesList(mObject, null, schemas[0]);
}
} else {
tableList = getTableNamesList(mObject, dbName, null);
}
String str[] = tableList.toArray(new String[tableList.size()]);
return str;
} else {
return null;
}
}
static void truncateTable(String strTable) {
String DBMS = "";
try {
DatabaseMetaData metaData = conn.getMetaData();
DBMS = metaData.getDatabaseProductName().toLowerCase();
} catch (SQLException e) {
System.out.println("Problem determining database product name: " + e);
}
System.out.println("Truncating '" + strTable + "' ...");
try {
if (DBMS.startsWith("db2")) {
stmt.execute("TRUNCATE TABLE " + strTable + " IMMEDIATE");
} else {
stmt.execute("TRUNCATE TABLE " + strTable);
}
transCommit();
} catch (SQLException se) {
System.out.println(se.getMessage());
transRollback();
}
}
/**
* 初始化连接池
*
* @param props
* @param show_sql
*/
private static final void initDataSource(Properties dbProperties) {
try {
if (dbProperties == null) {
dbProperties = new Properties();
dbProperties.load(DBManager.class.getResourceAsStream(CONFIG_PATH));
}
// Class.forName(dbProperties.getProperty("jdbc.driverClass"));
for (Object key : dbProperties.keySet()) {
String skey = (String) key;
if (skey.startsWith("jdbc.")) {
String name = skey.substring(5);
cp_props.put(name, dbProperties.getProperty(skey));
if ("show_sql".equalsIgnoreCase(name)) {
show_sql = "true".equalsIgnoreCase(dbProperties.getProperty(skey));
}
}
}
dataSource = (DataSource) Class.forName(cp_props.getProperty("datasource")).newInstance();
if (dataSource.getClass().getName().indexOf("c3p0") > 0) {
// Disable JMX in C3P0
System.setProperty(
"com.mchange.v2.c3p0.management.ManagementCoordinator",
"com.mchange.v2.c3p0.management.NullManagementCoordinator");
}
log.info("Using DataSource : " + dataSource.getClass().getName());
BeanUtils.populate(dataSource, cp_props);
Connection conn = getConnection();
DatabaseMetaData mdm = conn.getMetaData();
log.info(
"Connected to " + mdm.getDatabaseProductName() + " " + mdm.getDatabaseProductVersion());
closeConnection();
} catch (Exception e) {
e.printStackTrace();
throw new DBException(e);
}
}
//
// Find all the methods for java.sql objects in the Connection which raise
// SQLFeatureNotSupportedException.
//
private void connectionWorkhorse(
Connection conn, HashSet<String> unsupportedList, HashSet<String> notUnderstoodList)
throws Exception {
vetSavepoint(conn, unsupportedList, notUnderstoodList);
vetLargeObjects(conn, unsupportedList, notUnderstoodList);
DatabaseMetaData dbmd = conn.getMetaData();
PreparedStatement ps = conn.prepareStatement("select * from sys.systables where tablename = ?");
ps.setString(1, "foo");
ParameterMetaData parameterMetaData = ps.getParameterMetaData();
ResultSet rs = ps.executeQuery();
ResultSetMetaData rsmd = rs.getMetaData();
Statement stmt = conn.createStatement();
CallableStatement cs = conn.prepareCall("CALL SYSCS_UTIL.SET_RUNTIMESTATISTICS(0)");
ParameterMetaData csmd = cs.getParameterMetaData();
//
// The vetObject() method calls all of the methods in these objects
// in a deterministic order, calling the close() method last.
// Inspect these objects in an order which respects the fact that
// the objects are closed as a result of calling vetObject().
//
vetObject(dbmd, unsupportedList, notUnderstoodList);
vetObject(stmt, unsupportedList, notUnderstoodList);
vetObject(csmd, unsupportedList, notUnderstoodList);
vetObject(cs, unsupportedList, notUnderstoodList);
vetObject(rsmd, unsupportedList, notUnderstoodList);
vetObject(rs, unsupportedList, notUnderstoodList);
vetObject(parameterMetaData, unsupportedList, notUnderstoodList);
vetObject(ps, unsupportedList, notUnderstoodList);
vetObject(conn, unsupportedList, notUnderstoodList);
// No need to close the objects. They were closed by vetObject().
}
/**
* Method declaration
*
* @param c
*/
void connect(Connection c) {
if (c == null) {
return;
}
if (cConn != null) {
try {
cConn.close();
} catch (SQLException e) {
}
}
cConn = c;
try {
dMeta = cConn.getMetaData();
sStatement = cConn.createStatement();
refreshTree();
} catch (SQLException e) {
e.printStackTrace();
}
}
public void load(String queryFile, String modules, String tables)
throws SQLException, IOException, InterruptedException, ExecutionException {
Properties properties = new Properties();
properties.load(new FileInputStream(queryFile));
Collection<String> keys = properties.stringPropertyNames();
// Filtering by validating if property starts with any of the module names
if (!Config.ALL.equalsIgnoreCase(modules)) {
keys =
Util.filter(
keys, "^(" + modules.replaceAll(Config.COMMA_SEPARATOR, Config.MODULE_SUFFIX) + ")");
}
// Filtering by table names
if (!Config.ALL.equalsIgnoreCase(tables)) {
keys =
Util.filter(
keys, "(" + tables.replaceAll(Config.COMMA_SEPARATOR, Config.TABLE_SUFFIX) + ")$");
}
logger.info("The final modules and tables that are being considered" + keys.toString());
ExecutorService executor = Executors.newFixedThreadPool(keys.size() * 3);
CompletionService completion = new ExecutorCompletionService(executor);
for (String key : keys) {
String query = properties.getProperty(key);
key =
(key.contains(Config.DOT_SEPARATOR)
? key.substring(key.indexOf(Config.DOT_SEPARATOR) + 1)
: key);
while (query.contains("[:")) {
String param = query.substring(query.indexOf("[:") + 2, query.indexOf("]"));
query = query.replaceFirst("\\[\\:" + param + "\\]", properties.getProperty(param));
}
int pages = 1;
String base = "";
if (config.srisvoltdb) {
if (config.isPaginated) {
try {
// find count
String countquery = query;
if (countquery.contains("<") || countquery.contains(">")) {
int bracketOpen = countquery.indexOf("<");
int bracketClose = countquery.indexOf(">");
String orderCol = countquery.substring(bracketOpen + 1, bracketClose);
countquery = countquery.replace("<" + orderCol + ">", "");
}
VoltTable vcount = client.callProcedure("@AdHoc", countquery).getResults()[0];
int count = vcount.getRowCount();
pages = (int) Math.ceil((double) count / config.pageSize);
} catch (Exception e) {
System.out.println("Count formation failure!");
}
}
// set up data in order
} else {
// find count
String countquery = query.replace("*", "COUNT(*)");
Connection conn =
DriverManager.getConnection(config.jdbcurl, config.jdbcuser, config.jdbcpassword);
base = conn.getMetaData().getDatabaseProductName().toLowerCase();
System.out.println("BASE: " + base);
Statement jdbcStmt =
conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
if (countquery.contains("<") || countquery.contains(">")) {
int bracketOpen = countquery.indexOf("<");
int bracketClose = countquery.indexOf(">");
String orderCol = countquery.substring(bracketOpen + 1, bracketClose);
countquery = countquery.replace("<" + orderCol + ">", "");
}
ResultSet rcount = jdbcStmt.executeQuery(countquery);
rcount.next();
int count = Integer.parseInt(rcount.getArray(1).toString());
// THIS IF NEEDS A WAY TO DETERMINE IF POSTGRES
if (base.contains("postgres") && config.isPaginated) {
pages = (int) Math.ceil((double) count / config.pageSize);
}
// set up data in order
}
// establish new SourceReaders and DestinationWriters for pages
SourceReader[] sr = new SourceReader[pages];
DestinationWriter[] cr = new DestinationWriter[pages];
for (int i = 0; i < pages; i++) {
sr[i] = new SourceReader();
cr[i] = new DestinationWriter();
}
Controller processor =
new Controller<ArrayList<Object[]>>(
client, sr, cr, query, key.toUpperCase() + ".insert", config, pages, base);
completion.submit(processor);
}
// wait for all tasks to complete.
for (int i = 0; i < keys.size(); ++i) {
logger.info(
"****************"
+ completion.take().get()
+ " completed *****************"); // will block until the next sub task has
// completed.
}
executor.shutdown();
}
/**
* 取得表的元数据，即取得各列名及类型
*
* @return 列名及其列类型：LinkedHashMap<String, MyMetaData> map
* @throws Exception
*/
protected void parseMetaData() throws Exception {
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
conn = DBResource.getConnection();
// 定位主键字段
Set<String> keySet = new HashSet<String>();
// log.info(">>>>"+conn.isClosed());
// log.info(">>>>"+conn.getCatalog());
rs = conn.getMetaData().getPrimaryKeys(conn.getCatalog(), null, tableName);
for (; rs.next(); ) {
String pk = rs.getString("COLUMN_NAME").toLowerCase();
keySet.add(pk);
}
rs.close();
// 获取列元数据
String sql = "SELECT * FROM " + tableName + " WHERE 1=2";
stmt = conn.prepareStatement(sql);
rs = stmt.executeQuery();
ResultSetMetaData rsmd = rs.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
String colName = rsmd.getColumnName(i).toLowerCase();
log.debug(
colName
+ ": "
+ rsmd.getColumnType(i)
+ "("
+ rsmd.getColumnTypeName(i)
+ "), "
+ rsmd.getPrecision(i)
+ "(精确度), "
+ rsmd.getScale(i)
+ "(小数点后位数)");
MetaDataDescr md = new MetaDataDescr();
md.setColName(colName);
md.setColType(rsmd.getColumnType(i));
md.setPrecision(rsmd.getPrecision(i));
md.setScale(rsmd.getScale(i));
if (keySet.contains(colName)) {
md.setPk(true);
} else {
md.setPk(false);
}
String fileldName = MappingUtil.getFieldName(colName);
md.setFieldName(fileldName);
// 把列类型映射为类属性类型
md.setFieldType(reflectToFieldType(md.getColType(), md.getScale()));
colNameMetaMap.put(colName, md);
}
} catch (SQLException e) {
log.error(e.getMessage(), e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
DBResource.freeConnection(conn);
} catch (SQLException e) {
log.error(e.getMessage(), e);
}
}
}
public synchronized Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
if (OBJECT_METHODS.contains(m)) return m.invoke(this, args);
try {
String mname = m.getName();
if (activeConnection != null) {
if (mname.equals("rawConnectionOperation")) {
ensureOkay();
txn_known_resolved = false;
return doRawConnectionOperation((Method) args[0], args[1], (Object[]) args[2]);
} else if (mname.equals("setTransactionIsolation")) {
ensureOkay();
// don't modify txn_known_resolved
m.invoke(activeConnection, args);
int lvl = ((Integer) args[0]).intValue();
isolation_lvl_nondefault = (lvl != dflt_txn_isolation);
// System.err.println("updated txn isolation to " + lvl + ", nondefault level? " +
// isolation_lvl_nondefault);
return null;
} else if (mname.equals("setCatalog")) {
ensureOkay();
// don't modify txn_known_resolved
m.invoke(activeConnection, args);
String catalog = (String) args[0];
catalog_nondefault = ObjectUtils.eqOrBothNull(catalog, dflt_catalog);
return null;
} else if (mname.equals("setHoldability")) {
ensureOkay();
// don't modify txn_known_resolved
m.invoke(
activeConnection,
args); // will throw an exception if setHoldability() not supported...
int holdability = ((Integer) args[0]).intValue();
holdability_nondefault = (holdability != dflt_holdability);
return null;
} else if (mname.equals("createStatement")) {
ensureOkay();
txn_known_resolved = false;
Object stmt = m.invoke(activeConnection, args);
return createProxyStatement((Statement) stmt);
} else if (mname.equals("prepareStatement")) {
ensureOkay();
txn_known_resolved = false;
Object pstmt;
if (scache == null) {
pstmt = m.invoke(activeConnection, args);
return createProxyStatement((Statement) pstmt);
} else {
pstmt = scache.checkoutStatement(physicalConnection, m, args);
return createProxyStatement(true, (Statement) pstmt);
}
} else if (mname.equals("prepareCall")) {
ensureOkay();
txn_known_resolved = false;
Object cstmt;
if (scache == null) {
cstmt = m.invoke(activeConnection, args);
return createProxyStatement((Statement) cstmt);
} else {
cstmt = scache.checkoutStatement(physicalConnection, m, args);
return createProxyStatement(true, (Statement) cstmt);
}
} else if (mname.equals("getMetaData")) {
ensureOkay();
txn_known_resolved = false; // views of tables etc. might be txn dependent
DatabaseMetaData innerMd = activeConnection.getMetaData();
if (metaData == null) {
// exposedProxy is protected by C3P0PooledConnection.this' lock
synchronized (C3P0PooledConnection.this) {
metaData =
new SetManagedDatabaseMetaData(innerMd, activeMetaDataResultSets, exposedProxy);
}
}
return metaData;
} else if (mname.equals("silentClose")) {
// the PooledConnection doesn't have to be okay
doSilentClose(proxy, ((Boolean) args[0]).booleanValue(), this.txn_known_resolved);
return null;
} else if (mname.equals("close")) {
// the PooledConnection doesn't have to be okay
Exception e = doSilentClose(proxy, false, this.txn_known_resolved);
if (!connection_error_signaled) ces.fireConnectionClosed();
// System.err.println("close() called on a ProxyConnection.");
if (e != null) {
// System.err.print("user close exception -- ");
// e.printStackTrace();
throw e;
} else return null;
}
// else if ( mname.equals("finalize") ) //REMOVE THIS CASE -- TMP DEBUG
// {
// System.err.println("Connection apparently finalized!");
// return m.invoke( activeConnection, args );
// }
else {
ensureOkay();
// we've disabled setting txn_known_resolved to true, ever, because
// we failed to deal with the case that clients would work with previously
// acquired Statements and ResultSets after a commit(), rollback(), or setAutoCommit().
// the new non-reflective proxies have been modified to deal with this case.
// here, with soon-to-be-deprecated in "traditional reflective proxies mode"
// we are reverting to the conservative, always-presume-you-have-to-rollback
// policy.
// txn_known_resolved = ( mname.equals("commit") || mname.equals( "rollback" ) ||
// mname.equals( "setAutoCommit" ) );
txn_known_resolved = false;
return m.invoke(activeConnection, args);
}
} else {
if (mname.equals("close") || mname.equals("silentClose")) return null;
else if (mname.equals("isClosed")) return Boolean.TRUE;
else {
throw new SQLException("You can't operate on " + "a closed connection!!!");
}
}
} catch (InvocationTargetException e) {
Throwable convertMe = e.getTargetException();
SQLException sqle = handleMaybeFatalToPooledConnection(convertMe, proxy, false);
sqle.fillInStackTrace();
throw sqle;
}
}
private static ResultSet getTables(Connection connection) throws SQLException {
return connection.getMetaData().getTables(null, null, "%", new String[] {"TABLE"});
}
protected boolean checkExistence(Connection conn, DatabaseObjectType type, String... params)
throws SQLException {
boolean result = false;
DatabaseMetaData metadata = null;
PreparedStatement pstmt = null;
BaseSchema baseSchema = catalogStore.getSchema();
if (params == null || params.length < 1) {
throw new IllegalArgumentException("checkExistence function needs at least one argument.");
}
switch (type) {
case DATA:
metadata = conn.getMetaData();
ResultSet data =
metadata.getUDTs(
null,
baseSchema.getSchemaName() != null && !baseSchema.getSchemaName().isEmpty()
? baseSchema.getSchemaName().toUpperCase()
: null,
params[0].toUpperCase(),
null);
result = data.next();
CatalogUtil.closeQuietly(data);
break;
case FUNCTION:
metadata = conn.getMetaData();
ResultSet functions =
metadata.getFunctions(
null,
baseSchema.getSchemaName() != null && !baseSchema.getSchemaName().isEmpty()
? baseSchema.getSchemaName().toUpperCase()
: null,
params[0].toUpperCase());
result = functions.next();
CatalogUtil.closeQuietly(functions);
break;
case INDEX:
if (params.length != 2) {
throw new IllegalArgumentException(
"Finding index object is needed two strings, table name and index name");
}
pstmt = getExistQuery(conn, type);
if (pstmt != null) {
result = checkExistenceByQuery(pstmt, baseSchema, params);
} else {
metadata = conn.getMetaData();
ResultSet indexes =
metadata.getIndexInfo(
null,
baseSchema.getSchemaName() != null && !baseSchema.getSchemaName().isEmpty()
? baseSchema.getSchemaName().toUpperCase()
: null,
params[0].toUpperCase(),
false,
true);
while (indexes.next()) {
if (indexes.getString("INDEX_NAME").equals(params[1].toUpperCase())) {
result = true;
break;
}
}
CatalogUtil.closeQuietly(indexes);
}
break;
case TABLE:
pstmt = getExistQuery(conn, type);
if (pstmt != null) {
result = checkExistenceByQuery(pstmt, baseSchema, params);
} else {
metadata = conn.getMetaData();
ResultSet tables =
metadata.getTables(
null,
baseSchema.getSchemaName() != null && !baseSchema.getSchemaName().isEmpty()
? baseSchema.getSchemaName().toUpperCase()
: null,
params[0].toUpperCase(),
new String[] {"TABLE"});
result = tables.next();
CatalogUtil.closeQuietly(tables);
}
break;
case DOMAIN:
case OPERATOR:
case RULE:
case SEQUENCE:
case TRIGGER:
case VIEW:
pstmt = getExistQuery(conn, type);
if (pstmt == null) {
throw new TajoInternalError(
"Finding "
+ type
+ " type of database object is not supported on this database system.");
}
result = checkExistenceByQuery(pstmt, baseSchema, params);
break;
}
return result;
}
private void insertRows(Connection connection) {
// Build the SQL INSERT statement
String sqlInsert = "insert into " + jtfTableName.getText() + " values (";
// Use a Scanner to read text from the file
Scanner input = null;
// Get file name from the text field
String filename = jtfFilename.getText().trim();
try {
// Create a scanner
input = new Scanner(new File(filename));
// Create a statement
Statement statement = connection.createStatement();
System.out.println(
"Driver major version? " + connection.getMetaData().getDriverMajorVersion());
// Determine if batchUpdatesSupported is supported
boolean batchUpdatesSupported = false;
try {
if (connection.getMetaData().supportsBatchUpdates()) {
batchUpdatesSupported = true;
System.out.println("batch updates supported");
} else {
System.out.println(
"The driver is of JDBC 2 type, but " + "does not support batch updates");
}
} catch (UnsupportedOperationException ex) {
System.out.println("The driver does not support JDBC 2");
}
// Determine if the driver is capable of batch updates
if (batchUpdatesSupported) {
// Read a line and add the insert table command to the batch
while (input.hasNext()) {
statement.addBatch(sqlInsert + input.nextLine() + ")");
}
statement.executeBatch();
jlblStatus.setText("Batch updates completed");
} else {
// Read a line and execute insert table command
while (input.hasNext()) {
statement.executeUpdate(sqlInsert + input.nextLine() + ")");
}
jlblStatus.setText("Single row update completed");
}
} catch (SQLException ex) {
System.out.println(ex);
} catch (FileNotFoundException ex) {
System.out.println("File not found: " + filename);
} catch (IOException ex) {
ex.printStackTrace();
} finally {
if (input != null) input.close();
}
}
public static void main(String[] argv) {
try {
ComboPooledDataSource cpds = new ComboPooledDataSource();
cpds.setJdbcUrl(argv[0]);
cpds.setUser(argv[1]);
cpds.setPassword(argv[2]);
cpds.setMinPoolSize(5);
cpds.setAcquireIncrement(5);
cpds.setMaxPoolSize(20);
System.err.println("Initial...");
display(cpds);
Thread.sleep(2000);
HashSet hs = new HashSet();
for (int i = 0; i < 20; ++i) {
Connection c = cpds.getConnection();
hs.add(c);
System.err.println("Adding (" + (i + 1) + ") " + c);
display(cpds);
Thread.sleep(1000);
// if (i == 9)
// {
// //System.err.println("hardReset()ing");
// //cpds.hardReset();
// System.err.println("softReset()ing");
// cpds.softReset();
// }
}
int count = 0;
for (Iterator ii = hs.iterator(); ii.hasNext(); ) {
Connection c = ((Connection) ii.next());
System.err.println("Removing " + ++count);
ii.remove();
try {
c.getMetaData().getTables(null, null, "PROBABLYNOT", new String[] {"TABLE"});
} catch (Exception e) {
System.err.println(e);
System.err.println();
continue;
} finally {
c.close();
}
Thread.sleep(2000);
display(cpds);
}
System.err.println(
"Closing data source, \"forcing\" garbage collection, and sleeping for 5 seconds...");
cpds.close();
System.gc();
System.err.println("Main Thread: Sleeping for five seconds!");
Thread.sleep(5000);
// System.gc();
// Thread.sleep(5000);
System.err.println("Bye!");
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Retrieves a <code>DatabaseMetaData</code> object that contains metadata about the database to
* which this <code>Connection</code> object represents a connection. The metadata includes
* information about the database's tables, its supported SQL grammar, its stored procedures, the
* capabilities of this connection, and so on.
*
* @return a <code>DatabaseMetaData</code> object for this <code>Connection</code> object
* @exception SQLException if a database access error occurs
*/
public DatabaseMetaData getMetaData() throws SQLException {
if (connection != null) {
return connection.getMetaData();
}
return null;
}
public DatabaseMetaData getMetaData() throws SQLException {
return conn.getMetaData();
}
public void loadTables(String tableNames, String procNames)
throws SQLException, IOException, InterruptedException, ExecutionException {
String[] tableNameArray =
tableNames != null && !"".equals(tableNames) ? tableNames.split(",") : null;
String[] procNameArray =
procNames != null && !"".equals(procNames) ? procNames.split(",") : null;
ExecutorService executor = Executors.newFixedThreadPool(tableNameArray.length * 3);
CompletionService completion = new ExecutorCompletionService(executor);
for (int j = 0; j < tableNameArray.length && tableNameArray != null; j++) {
String tableName = tableNameArray[j];
String procName = procNameArray != null ? procNameArray[j] : "";
// if procName not provided, use the default VoltDB TABLENAME.insert procedure
if (procName.length() == 0) {
if (tableName.contains("..")) {
procName = tableName.split("\\.\\.")[1].toUpperCase() + ".insert";
} else {
procName = tableName.toUpperCase() + ".insert";
}
}
// query the table
String jdbcSelect = "SELECT * FROM " + tableName + ";";
// create query to find count
String countquery = jdbcSelect.replace("*", "COUNT(*)");
int pages = 1;
String base = "";
if (config.srisvoltdb) {
if (config.isPaginated) {
try {
// find count
if (countquery.contains("<") || countquery.contains(">")) {
int bracketOpen = countquery.indexOf("<");
int bracketClose = countquery.indexOf(">");
String orderCol = countquery.substring(bracketOpen + 1, bracketClose);
countquery = countquery.replace("<" + orderCol + ">", "");
}
VoltTable vcount = client.callProcedure("@AdHoc", countquery).getResults()[0];
int count = Integer.parseInt(vcount.toString());
// determine number of pages from total data and page size
pages = (int) Math.ceil((double) count / config.pageSize);
System.out.println(pages);
} catch (Exception e) {
System.out.println("Count formation failure!");
}
}
} else {
// find count
Connection conn =
DriverManager.getConnection(config.jdbcurl, config.jdbcuser, config.jdbcpassword);
base = conn.getMetaData().getDatabaseProductName().toLowerCase();
Statement jdbcStmt =
conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
if (countquery.contains("<") || countquery.contains(">")) {
int bracketOpen = countquery.indexOf("<");
int bracketClose = countquery.indexOf(">");
String orderCol = countquery.substring(bracketOpen + 1, bracketClose);
countquery = countquery.replace("<" + orderCol + ">", "");
}
ResultSet rcount =
jdbcStmt.executeQuery(
countquery); // determine number of pages from total data and page size
if (base.contains("postgres") && config.isPaginated) {
int count = Integer.parseInt(rcount.toString());
pages = (int) Math.ceil((double) count / config.pageSize);
}
}
// establish new SourceReaders and DestinationWriters for pages
SourceReader[] sr = new SourceReader[pages];
DestinationWriter[] cr = new DestinationWriter[pages];
for (int i = 0; i < pages; i++) {
sr[i] = new SourceReader();
cr[i] = new DestinationWriter();
}
Controller processor =
new Controller<ArrayList<Object[]>>(
client, sr, cr, jdbcSelect, procName, config, pages, base);
completion.submit(processor);
}
// wait for all tasks to complete.
for (int i = 0; i < tableNameArray.length; ++i) {
logger.info(
"****************"
+ completion.take().get()
+ " completed *****************"); // will block until the next sub task has
// completed.
}
executor.shutdown();
}
