// @@@ START COPYRIGHT @@@
//
// 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.
//
// @@@ END COPYRIGHT @@@

package org.trafodion.jdbc.t4;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.util.Locale;
import java.util.Properties;
import java.util.logging.FileHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.naming.Reference;
import javax.naming.StringRefAddr;

/**
 * <p>
 * JDBC Type 4 driver connetion properties class.
 * </p>
 * <p>
 * Description: The <code>T4Properties</code> class contains all the
 * properties associated with Type 4 connection. <code>T4Properties</code> is
 * inherited directy or indirectly by the <code>T4Driver, TrafT4DataSource,
 * TrafT4ConnectionPooledDataSource</code>
 * classes for configuring Type 4 connection properties.
 * </p>
 * <p>
 * The properties passed to the Type 4 driver have this precedence order in
 * event of the values set through more than one option:
 * </p>
 * <blockquote>
 * <p>
 * 1. java.util.properties parameter in the
 * <code>DriverManager.getConnection</code> call or through
 * <code>DataSource.setXXX()</code> call.
 * </p>
 * <p>
 * 2. <code>java.util.properties</code> file properties set through
 * <code>-Dt4jdbc.properties</code> option.
 * </p>
 * <p>
 * 3. Command line properties using -D option. All the system properties passed
 * through the command-line option have to be prefixed with
 * <code>t4jdbc</code>, to distinguish JDBC Type 4 driver properties
 * from other system properties. For example: property <code>user</code> when
 * specified with -D has to be qualified as
 * <code>-Dt4jdbc.user=super.super</code>.
 * </p>
 * </blockquote>
 * <p>
 *  Licensed to the Apache Software Foundation (ASF)
 * </p>
 */
public class T4Properties {
    final static int DEFAULT_NETWORK_TIMEOUT_IN_MILLIS = 1000;
    final static int DEFAULT_CONNECT_TIMEOUT_IN_SECS = 10;
	private String description_;
	private String dataSourceName_;
	private String serverDataSource_;
	private String catalog_;
	private String schema_;
	private String user_;
	private String url_;
	private String pwd_;
	private Locale locale_;
	private int maxPoolSize_;
	private int minPoolSize_;
	private int initialPoolSize_;
	private int maxStatements_;
	private int loginTimeout_;
	// private int closeConnectionTimeout_;
	private int networkTimeoutInMillis_ = DEFAULT_NETWORK_TIMEOUT_IN_MILLIS;
	private int connectionTimeout_;
	private int maxIdleTime_;
	private Level t4LogLevel;
	private String T4LogFile_;
	private Properties defaults_;
	private Properties inprops_;
	private PrintWriter logWriter_;
	// For LOB Support - SB 9/28/04
	private int roundMode_;
	private String language_;

	private short fetchBufferSize_;

	private String connectionID_;
	private String dialogueID_;
	private String serverID_;
	private short ncsMajorVersion_;
	private short ncsMinorVersion_;
	private short sqlmxMajorVersion_;
	private short sqlmxMinorVersion_;

    private int lobChunkSize_ = 10; // default 10M
    private boolean useLobHandle_ = false;

    // private short transportBufferSize_;
	private boolean useArrayBinding_;
	private boolean batchRecovery_;
	private final String propPrefix_ = "t4jdbc.";
	//clipVarchar flag
	private short clipVarchar_ = 0;
	// Default catalog 
	static final String DEFAULT_CATALOG = "TRAFODION";

	// propertiy queryTimeout_ for future use.
	private short queryTimeout_;
 	private boolean ignoreCancel_ = true;
	private int activeTimeBeforeCancel_; 
	private T4Address t4addr_;

	// Error handling while setting Type 4 properties.
	String sqlExceptionMessage_;

	// Logger for this connection.
	Logger logger;
	Logger t4Logger_;

	// Log file handler for this connection.
	FileHandler t4LogFileHandler_;
	
	//clientInfoProperties
	private Properties clientInfoProp;
	

	private boolean SPJEnv_ = false;
	private boolean keepRawFetchBuffer_ = false;
	private short cpuToUse_ = -1;
	private String sessionName;
	private String replacementString_;
	private String ISO88591_;

	private String _roleName;
	private String _applicationName;
	private boolean _sessionToken;
	private boolean _fetchAhead;
	private boolean _delayedErrorMode;
	private boolean _compression;
	private String _certificateDir;
	private String _certificateFileActive;
	private String _certificateFile;
	private boolean _keepAlive = false;
	private boolean _tokenAuth;
	private static int DEFAULT_MAX_IDLE_TIMEOUT = 0; // Max idle timeout
	// default = infinite
    
	//TCP Nagle's algorithm 
	private boolean _tcpNoDelay = true;

	// -----------------------------------------------------------
	//
	// The following static members and static block are ment to
	// establish the one and only global t4 logger for this JVM.
	//
	static Level t4GlobalLogLevel = null;
	static String t4GlobalLogFile = null;
	static Logger t4GlobalLogger = null;
	static FileHandler t4GlobalLogFileHandler = null;

	private String clientCharset;

	void initializeLogging() {
		if (t4GlobalLogger != null) {
			return;
		}

		t4GlobalLogger = Logger.getLogger("org.trafodion.jdbc.t4.logger");

		try {
			boolean createGlobalLogFile = false;
			String userSpecifiedLogFile = null;
			Level userSpecifiedLogLevel = null;
			Properties p = getPropertiesFileValues();

			t4GlobalLogger.setUseParentHandlers(false);
			//
			// See if the user specified a log file and/or log level via the
			// properties file or the system properties.
			//
			if (p != null) {
				userSpecifiedLogFile = p.getProperty("T4LogFile");
				String temp = p.getProperty("T4LogLevel");
				if (temp != null) {
					userSpecifiedLogLevel = Level.parse(temp);
				}
			}

			if (userSpecifiedLogFile == null) {
				userSpecifiedLogFile = System.getProperty("t4jdbc.T4LogFile");

			}
			if (userSpecifiedLogLevel == null) {
				String temp = System.getProperty("t4jdbc.T4LogLevel");
				if (temp != null) {
					userSpecifiedLogLevel = Level.parse(temp);
				} else {
					userSpecifiedLogLevel = null;
				}
			}

			//
			// At this point, if the user specified a log file and/or log level,
			// we have captured
			// that information.
			//

			//
			// Decide if we should create a global log file now or wait until
			// someone
			// asks for it. That is, until a connection turns on logging and
			// doesn't
			// specify its own log file.
			//
			if (userSpecifiedLogFile != null || (userSpecifiedLogLevel != null && userSpecifiedLogLevel != Level.OFF)) {
				createGlobalLogFile = true;
			}

			//
			// Set the global log file and global log level.
			//
			if (userSpecifiedLogFile == null) {
				t4GlobalLogFile = T4LoggingUtilities.getUniqueLogFileName(T4LoggingUtilities.getUniqueID());
			} else {
				t4GlobalLogFile = userSpecifiedLogFile;
			}
			if (userSpecifiedLogLevel == null) {
				t4GlobalLogLevel = Level.OFF;
			} else {
				t4GlobalLogLevel = userSpecifiedLogLevel;
			}
			t4GlobalLogger.setLevel(t4GlobalLogLevel);

			//
			// If we decided to make the log file now, make the file (i.e.
			// FileHandler) and
			// it the global logger.
			//
			if (createGlobalLogFile == true) {
				t4GlobalLogFileHandler = new FileHandler(t4GlobalLogFile);

				t4GlobalLogger.addHandler(t4GlobalLogFileHandler);

				Formatter ff1 = new T4LogFormatter();

				t4GlobalLogFileHandler.setFormatter(ff1);
			}
		} catch (Exception e) {
			// SQLException se = TrafT4Messages.createSQLException(null, null,
			// "problem_with_logging", e.getMessage());
			// sqlExceptionMessage_ = se.getMessage();

			SQLException se = TrafT4Messages.createSQLException(null, null, "problem_with_logging", e.getMessage());
			sqlExceptionMessage_ = se.getMessage();
			// RuntimeException rte = new RuntimeException(se.getMessage(), se);
			// throw rte;
			// e.printStackTrace();
			// throw TrafT4Messages.createSQLException(null, null,
			// "problem_with_logging", e.getMessage());
		}
	} // end initializeLogging

	// -----------------------------------------------------------------

	public T4Properties() {
		initializeLogging();
		initialize(null);
	}

	public T4Properties(Properties props) {
		initializeLogging();
		initialize(props);
	}

	void initialize(Properties props) {
		sqlExceptionMessage_ = null;
		inprops_ = props;
		setProperties();
		clientInfoProp = new Properties();
	}

	// ---------------------------------------------------------------
	private Object getHashTableEntry(String token) {
		Object outObj = null;

		// if the token is present in input-props get it
		if (inprops_ != null) {
			outObj = inprops_.get((Object) token);

		}
		return outObj;
	} // end getHashTableEntry

	// ---------------------------------------------------------------
	private String getProperty(String token) {
		String ret = null;

		// check input props first
		if (inprops_ != null) {
			ret = inprops_.getProperty(token);
		}
		// props file next
		if (ret == null && defaults_ != null) {
			ret = defaults_.getProperty(token);
		}
		// system properties with the t4jdbc prefix
		if (ret == null) {
			ret = System.getProperty(propPrefix_ + token);
		}

		return ret;
	}

	private void setProperties() {
		defaults_ = null;
		String propsFile = getProperty("properties");
		if (propsFile != null) {
			propsFile = propsFile.trim();
			if (propsFile.length() != 0) {
				FileInputStream fis = null;
				try {
					fis = new FileInputStream(new File(propsFile));
					defaults_ = new Properties();
					defaults_.load(fis);
				} catch (Exception ex) {
					fis = null;
					sqlExceptionMessage_ = "Error while loading " + propPrefix_ + "properties file: " + ex.getMessage();
				} finally {
					try {
						if (fis != null) {
							fis.close();
						}
					} catch (IOException ioe) {
						// ignore
					}
				}
			}
		}

		setDescription(getProperty("description"));
		setDataSourceName(getProperty("dataSourceName"));
		setServerDataSource(getProperty("serverDataSource"));
		setCatalog(getProperty("catalog"));
		setSchema(getProperty("schema"));

		// DriverManager passes property user. HPUX does not like
		// property user. System properties must be prefixed with t4jdbc.
		// For example user should be t4jdbc.user if set as system property.
		setUser(getProperty("user"));
		setPassword(getProperty("password"));

		// url is special. Set it from properties only when it is not already
		// set.
		if (url_ == null) {
			setUrl(getProperty("url"));

		}
		setMaxPoolSize(getProperty("maxPoolSize"));
		setMinPoolSize(getProperty("minPoolSize"));
		setInitialPoolSize(getProperty("initialPoolSize"));
		setMaxStatements(getProperty("maxStatements"));
		setLoginTimeout(getProperty("loginTimeout"));
		// setCloseConnectionTimeout(getProperty("closeConnectionTimeout"));
		setNetworkTimeout(getProperty("networkTimeout"));
		setT4LogLevel(getProperty("T4LogLevel"));
		setT4LogFile(getProperty("T4LogFile"));
		setLogger(getHashTableEntry("logger"));
		setT4LogFileHandler(getHashTableEntry("T4LogFileHandler"));
		setUseArrayBinding(getProperty("useArrayBinding"));
		setBatchRecovery(getProperty("batchRecovery"));
		// setTransportBufferSize(getProperty("TransportBufferSize"));
		setLanguage(getProperty("language"));
		setMaxIdleTime(getProperty("maxIdleTime"));
		setConnectionTimeout(getProperty("connectionTimeout"));
		setClipVarchar(getProperty("clipVarchar"));
		setFetchBufferSize(getProperty("fetchBufferSize")); 
		setQueryTimeout(getProperty("queryTimeout"));
		setActiveTimeBeforeCancel(getProperty("activeTimeBeforeCancelInSecs"));
		setRoundingMode(getProperty("roundingMode"));
		setSPJEnv(getProperty("SPJEnv"));
		setKeepRawFetchBuffer(getProperty("keepRawFetchBuffer"));
		setCpuToUse(getProperty("cpuToUse"));
		setSessionName(getProperty("sessionName"));
		setReplacementString(getProperty("replacementString"));
		setISO88591(getProperty("ISO88591"));

		setRoleName(getProperty("roleName"));
		setApplicationName(getProperty("applicationName"));
		setSessionToken(getProperty("sessionToken"));
		setFetchAhead(getProperty("fetchAhead"));
		setDelayedErrorMode(getProperty("delayedErrorMode"));
		setCompression(getProperty("compression"));
		setCertificateDir(getProperty("certificateDir"));
		setCertificateFileActive(getProperty("certificateFileActive"));
		setCertificateFile(getProperty("certificateFile"));
		setKeepAlive(getProperty("keepAlive"));
		setTokenAuth(getProperty("tokenAuth"));
        setTcpNoDelay(getProperty("tcpNoDelay"));

        setLobChunkSize(getProperty("lobChunkSize"));
        setUseLobHandle(getProperty("useLobHandle"));

        setClientCharset(getProperty("clientCharset"));
	}

	T4Properties getT4Properties() {
		return this;
	}

	/**
	 * Returns all the connection properties associated with the current Type 4
	 * connection object in the <code>java.util.Properties</code> object.
	 * 
	 * @return The properties associated with the current Type 4 connection.
	 */
	public Properties getProperties() {
		Properties props = new Properties();
		if (getCatalog() != null) {
			props.setProperty("catalog", catalog_);
		}
		if (getSchema() != null) {
			props.setProperty("schema", schema_);
		}
		if (url_ != null) {
			props.setProperty("url", url_);
		}

		props.setProperty("user", user_);
		props.setProperty("password", pwd_);
		props.setProperty("maxPoolSize", String.valueOf(maxPoolSize_));
		props.setProperty("minPoolSize", String.valueOf(minPoolSize_));
		props.setProperty("initialPoolSize", String.valueOf(initialPoolSize_));
		props.setProperty("maxStatements", String.valueOf(maxStatements_));
		props.setProperty("T4LogLevel", t4LogLevel.toString());
		props.setProperty("fetchBufferSize", String.valueOf(fetchBufferSize_));

		if (logger != null) {
			props.put("logger", logger);
		}
		if (t4LogFileHandler_ != null) {
			props.put("T4LogFileHandler", t4LogFileHandler_);

		}
		props.setProperty("T4LogFile", T4LogFile_);
		props.setProperty("loginTimeout", String.valueOf(loginTimeout_));
		// props.setProperty("closeConnectionTimeout",
		// String.valueOf(closeConnectionTimeout_));
		props.setProperty("networkTimeout", String.valueOf(getNetworkTimeout()));
		props.setProperty("connectionTimeout", String.valueOf(connectionTimeout_));
		props.setProperty("description", description_);
		props.setProperty("dataSourceName", dataSourceName_);
		props.setProperty("serverDataSource", serverDataSource_);
		// props.setProperty("transportBufferSize",
		// String.valueOf(transportBufferSize_));
		props.setProperty("useArrayBinding", String.valueOf(useArrayBinding_));
		props.setProperty("batchRecovery", String.valueOf(batchRecovery_));
		props.setProperty("maxIdleTime", String.valueOf(maxIdleTime_));
		props.setProperty("language", language_);

		// properties queryTimeout_ for future use.
		props.setProperty("queryTimeout", String.valueOf(queryTimeout_));
		props.setProperty("ignoreCancel", String.valueOf(ignoreCancel_));
		props.setProperty("activeTimeBeforeCancelInSecs", String.valueOf(activeTimeBeforeCancel_));
		props.setProperty("roundingMode", String.valueOf(roundMode_));
		props.setProperty("SPJEnv", String.valueOf(SPJEnv_));
		props.setProperty("keepRawFetchBuffer", String.valueOf(keepRawFetchBuffer_));
		props.setProperty("cpuToUse", String.valueOf(cpuToUse_));

        // NOTE
        // String.valueOf(null) will give a "null" string, this may raise bug.
        // So do not use String.valueOf() for a String variable
        if (sessionName != null) {
            props.setProperty("sessionName", sessionName);
        }
        if (replacementString_ != null) {
            props.setProperty("replacementString", replacementString_);
        }
        if (ISO88591_ != null) {
            props.setProperty("ISO88591", ISO88591_);
        }
		if (_roleName != null)
			props.setProperty("roleName", _roleName);
		if (_applicationName != null)
			props.setProperty("applicationName", _applicationName);

		props.setProperty("sessionToken", String.valueOf(_sessionToken));
		props.setProperty("fetchAhead", String.valueOf(_fetchAhead));
		props.setProperty("delayedErrorMode", String.valueOf(_delayedErrorMode));
		props.setProperty("compression", String.valueOf(_compression));
		if(_certificateDir != null) 	
			props.setProperty("certificateDir", _certificateDir);
		if(_certificateFileActive != null)
			props.setProperty("certFileActive", _certificateFileActive);
		if(_certificateFile != null)
			props.setProperty("certificateFile", _certificateFile);
		props.setProperty("keepAlive", String.valueOf(_keepAlive));
		props.setProperty("tokenAuth", String.valueOf(_tokenAuth));
        props.setProperty("tcpNoDelay", String.valueOf(_tcpNoDelay));

        props.setProperty("clipVarchar", String.valueOf(clipVarchar_));
        props.setProperty("lobChunkSize", String.valueOf(lobChunkSize_));
        props.setProperty("useLobHandle", String.valueOf(useLobHandle_));
        if (clientCharset != null)
            props.setProperty("clientCharset", clientCharset);
		return props;
	}

	/**
	 * Sets the description for the current Type 4 connection.
	 * 
	 * @param description
	 *            For the current Type 4 connection.
	 * @see #getDescription()
	 */
	void setDescription(String description) {
		if (description == null) {
			description_ = "JDBC T4 DataSource.";
		} else {
			description_ = description;
		}
	}

	/**
	 * Returns the description associated with the current Type 4 connection.
	 * 
	 * @return The description associated with the current Type 4 connection.
	 * @see #setDescription(String)
	 */
	String getDescription() {
		return description_;
	}

	/**
	 * Sets the data source name for the current Type 4 connection.
	 * 
	 * @param dataSourceName
	 *            For the client side <code>DataSource</code> object.
	 * @see #getDataSourceName()
	 */
	void setDataSourceName(String dataSourceName) {
		if (dataSourceName == null) {
			dataSourceName_ = "";
		} else {
			dataSourceName_ = dataSourceName;
		}
	}

	/**
	 * Return the data source name given to the client side data source.
	 * 
	 * @return data source name.
	 * @see #setDataSourceName(String)
	 */
	String getDataSourceName() {
		return dataSourceName_;
	}

	/**
	 * Sets the data source name to use on the NDCS server side.
	 * 
	 * @param serverDataSource
	 *            the data source name to use on the NDCS server side. The
	 *            default value is a blank string.
	 * @see #getDataSourceName()
	 */
	void setServerDataSource(String serverDataSource) {
		if (serverDataSource == null) {
			serverDataSource_ = "";
		} else {
			serverDataSource_ = serverDataSource;
		}
	}

	/**
	 * Returns the NDCS server side data source name used for the current Type 4
	 * connection. The default server data source name is
	 * <code>TDM_Defaullt_DataSource</code>.
	 * 
	 * @return NDCS server side data source Name.
	 * @see #setServerDataSource(String)
	 */
	String getServerDataSource() {
		return serverDataSource_;
	}

	/**
	 * Sets the default catalog that will be used to access SQL objects
	 * referenced in SQL statements if the SQL objects are not fully qualified.
	 * 
	 * @param catalog
	 *            Database catalog name. The default catalog name is set by
	 *            the NDCS server side data source.
	 * @see #getCatalog()
	 */
	void setCatalog(String catalog) {
		catalog_ = catalog;
		if (catalog_ == null) {
			catalog_ = getProperty("catalog");

		}
		if (catalog_ != null) {
			if (catalog_.length() == 0) {
				catalog_ = DEFAULT_CATALOG;
			} else if (!catalog_.startsWith("\"")) {
				catalog_ = catalog_.trim().toUpperCase();
			}
		} else {
			// catalog_ = null;
			catalog_ = DEFAULT_CATALOG;
		}
	}

	/**
	 * Gets the default catalog that will be used to access SQL objects
	 * referenced in SQL statements if the SQL objects are not fully qualified.
	 * 
	 * @return T4 2.0 catalog name.
	 * @see #setCatalog(String)
	 */
	String getCatalog() {
		return catalog_;
	}

	/**
	 * Sets the default schema that will be used to access SQL objects
	 * referenced in SQL statements if the SQL objects are not fully qualified.
	 * 
	 * @param schema
	 *            Sets the database schema name. The default schema name is set
	 *            by the NDCS server side data source.
	 * @see #getSchema()
	 */
	void setSchema(String schema) {
		schema_ = schema;
		if (schema_ == null) {
			schema_ = getProperty("schema");

		}
		if (schema_ != null) {
			if (!schema_.startsWith("\"")) {
				schema_ = schema_.trim().toUpperCase();
			}
		} else {
			schema_ = null;
		}
	}

	/**
	 * Gets the default schema that will be used to access SQL objects
	 * referenced in SQL statements if the SQL objects are not fully qualified.
	 * 
	 * @return The schema associated with the current Type 4 connection.
	 * @see #setSchema(String)
	 */
	String getSchema() {
		return schema_;
	}

	/**
	 * Returns the <code>java.util.Locale</code> object associated with the
	 * current Type 4 connection.
	 * 
	 * @return <code>java.util.Locale</code> object.
	 * @see #setLanguage(String language)
	 */
	Locale getLocale() {
		return locale_;
	}

	/**
	 * The maximum number of physical connections that the pool (free and inuse
	 * pool) should contain. When the maximum number of physical connections is
	 * reached, the Type 4 driver throws an <code>SQLException
	 * </code> with the
	 * message "Maximum pool size reached". Specifying a value of 0 (zero)
	 * indicates there is no maximum size for the pool. Specifying a value of -1
	 * indicates no connection pooling is performed. The default value is -1
	 * indicating that no pooling of physical connections is done.
	 * 
	 * @param maxPoolSize
	 *            the maximum number of physical connections the pool should
	 *            contain in the pool (free and inuse).
	 * @see #setMaxPoolSize(int)
	 */
	void setMaxPoolSize(String maxPoolSize) {
		int maxPs = -1;
		if (maxPoolSize != null) {
			try {
				maxPs = Integer.parseInt(maxPoolSize);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect maxPoolSize value set: " + maxPoolSize + ". " + ex.getMessage();
				maxPs = -1;
			}
		}
		setMaxPoolSize(maxPs);
	}

	/**
	 * The maximum number of physical connections that the pool (free and inuse
	 * pool) should contain. When the maximum number of physical connections is
	 * reached, the Type 4 driver throws an <code>SQLException
	 * </code> with the
	 * message "Maximum pool size reached". Specifying a value of 0 (zero)
	 * indicates there is no maximum size for the pool. Specifying a value of -1
	 * indicates no connection pooling is performed. The default value is -1
	 * indicating that no pooling of physical connections is done.
	 * 
	 * @param maxPoolSize
	 *            the maximum number of physical connections the pool should
	 *            contain in the pool (free and inuse).
	 * @see #setMaxPoolSize(String)
	 */
	void setMaxPoolSize(int maxPoolSize) {
		if (maxPoolSize < -1) {
			// The ES says that we set maxPoolSize to -1. It doesn't say we
			// produce an error.
			// sqlExceptionMessage_ = "Incorrect maxPoolSize value set: " +
			// maxPoolSize;
			maxPoolSize_ = -1;
		} else if (maxPoolSize > 0) {
			if (minPoolSize_ != 0 && minPoolSize_ > maxPoolSize) {
				maxPoolSize_ = minPoolSize_;
			} else {
				maxPoolSize_ = maxPoolSize;
			}
		} else {
			maxPoolSize_ = maxPoolSize;
		}
	}

	/**
	 * Returns the maximum number of physical connections that the pool (free
	 * and inuse) should contain. A value of zero (0) indicates no maximum size.
	 * A value of -1 indicates that connection pooling is not being done.
	 * 
	 * @return maxPoolSize the maximum number of physical connections that the
	 *         pool should contain.
	 * @see #setMaxPoolSize(int)
	 */
	int getMaxPoolSize() {
		return maxPoolSize_;
	}

	/**
	 * Sets the number of physical connections the pool should keep available at
	 * all times.
	 * 
	 * @param minPoolSize
	 *            Limits the number of physical connection that can be in the
	 *            free pool. When the number of physical connections in the free
	 *            pool reaches the value of minPoolSize, subsequent connections
	 *            that are closed are physically closed and are not added to the
	 *            free pool. Specifying a value of 0 means that the value of
	 *            minPoolSize is the same as the value of maxPoolSize. If the
	 *            value of maxPoolSize is -1, the value of minPoolSize is
	 *            ignored. The default value is 0. For this data source it is
	 *            recommended that you use the default value.
	 * @return the number of physical connections the pool should keep available
	 *         at all times.
	 * @see #getMinPoolSize()
	 * @see #setMinPoolSize(int minPoolSize)
	 */
	void setMinPoolSize(String minPoolSize) {
		int minPs = -1;
		if (minPoolSize != null) {
			try {
				minPs = Integer.parseInt(minPoolSize);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for minPoolSize set: " + minPoolSize + ". " + ex.getMessage();
				minPs = -1;
			}
		}
		setMinPoolSize(minPs);
	}

	/**
	 * Sets the number of physical connections the pool should keep available at
	 * all times.
	 * 
	 * @param minPoolSize
	 *            Limits the number of physical connection that can be in the
	 *            free pool. When the number of physical connections in the free
	 *            pool reaches the value of minPoolSize, subsequent connections
	 *            that are closed are physically closed and are not added to the
	 *            free pool. Specifying a value of 0 means that the value of
	 *            minPoolSize is the same as the value of maxPoolSize. If the
	 *            value of maxPoolSize is -1, the value of minPoolSize is
	 *            ignored. The default value is 0. For this data source it is
	 *            recommended that you use the default value.
	 * @return the number of physical connections the pool should keep available
	 *         at all times.
	 * @see #getMinPoolSize()
	 * @see #setMinPoolSize(String minPoolSize)
	 */
	void setMinPoolSize(int minPoolSize) {
		if (maxPoolSize_ == -1) {
			// minPoolSize_ = minPoolSize;
			minPoolSize_ = -1;
			return;
		}
		if (minPoolSize < -1) {
			// Swastik: Commented on 14th Feb 2005 to match behavior in
			// setMaxPoolSize(int)
			// sqlExceptionMessage_ = "Incorrect value for minPoolSize set: " +
			// minPoolSize;
			minPoolSize_ = -1;
		} else if (minPoolSize == 0) {
			minPoolSize_ = 0;
		} else {
			if (minPoolSize > 0) {
				if (maxPoolSize_ != 0 && maxPoolSize_ < minPoolSize) {
					minPoolSize_ = maxPoolSize_;
				} else {
					minPoolSize_ = minPoolSize;
				}
			} else {
				minPoolSize_ = minPoolSize;
			}
		}
	}

	/**
	 * Returns the number of physical connections the pool should keep in the
	 * free pool. A value of 0 (zero) indicates that minPoolSize is equal to
	 * maxPoolsize. If maxPoolsize is equal to -1, the value of minPoolSize is
	 * ignored. The default value is 0.
	 * 
	 * @return The number of physical connections the pool should maintain in
	 *         the free pool.
	 * @see #setMinPoolSize(int)
	 * @see #setMaxPoolSize(int)
	 */
	int getMinPoolSize() {
		return minPoolSize_;
	}

	/**
	 * The initial number of physical connections that the pool should be
	 * created with. Specifying a valueof 0 (zero) or less indicates that the
	 * pool should not be created with any initial connections. The default
	 * value is -1 indicating that no initial pool of physical connections is
	 * created. The value can be less than minPoolSize but must be less than or
	 * equal to the value of maxPoolSize. Specifying a value greater than
	 * maxPoolSize will set the initialPoolSize to the value of maxPoolSize.
	 * 
	 * @param initialPoolSize
	 *            the initial number of physical connections the pool should be
	 *            created with.
	 * @see #setInitialPoolSize(int)
	 */
	void setInitialPoolSize(String initialPoolSize) {
		int initPs = -1;
		if (initialPoolSize != null) {
			try {
				initPs = Integer.parseInt(initialPoolSize);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect initialPoolSize value set: " + initialPoolSize + ". "
						+ ex.getMessage();
				initPs = -1;
			}
		}
		setInitialPoolSize(initPs);
	}

	/**
	 * The initial number of physical connections that the pool should be
	 * created with. Specifying a valueof 0 (zero) or less indicates that the
	 * pool should not be created with any initial connections. The default
	 * value is -1 indicating that no initial pool of physical connections is
	 * created. The value can be less than minPoolSize but must be less than or
	 * equal to the value of maxPoolSize. Specifying a value greater than
	 * maxPoolSize will set the initialPoolSize to the value of maxPoolSize.
	 * 
	 * @param initialPoolSize
	 *            the initial number of physical connections the pool should be
	 *            created with.
	 * @see #setInitialPoolSize(String)
	 */
	void setInitialPoolSize(int initialPoolSize) {
		if (initialPoolSize <= 0) {
			initialPoolSize_ = -1;
			return;
		}
		// otherwise initialPoolSize > 0
		if (initialPoolSize > maxPoolSize_) {
			initialPoolSize_ = maxPoolSize_;
		} else {
			initialPoolSize_ = initialPoolSize;
		}
	}

	/**
	 * Returns the number of physical connections that the pool should be
	 * created with. A value of -1 indicates that the pool is not created with
	 * any initial connections.
	 * 
	 * @return initialPoolSize the number of physical connections that the pool
	 *         should be created with.
	 * @see #setInitialPoolSize(int)
	 */
	int getInitialPoolSize() {
		return initialPoolSize_;
	}

	/**
	 * Total number of statements that can be pooled. A value of zero (0)
	 * indicates that caching of statements is disabled.
	 * 
	 * @param maxStatements
	 *            The number of statements that can be pooled.
	 * @see #setMaxStatements(int)
	 */
	void setMaxStatements(String maxStatements) {
		int maxstmt = 0;
		if (maxStatements != null) {
			try {
				maxstmt = Integer.parseInt(maxStatements);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for maxStatements set: " + maxStatements + ex.getMessage();
				maxstmt = 0;
			}
		}
		setMaxStatements(maxstmt);
	}

	/**
	 * Total number of statements that can be pooled. A value of zero (0)
	 * indicates that caching of statements is disabled.
	 * 
	 * @param maxStatements
	 *            The number of statements that can be pooled.
	 * @see #setMaxStatements(int)
	 */
	void setMaxStatements(int maxStatements) {
		if (maxStatements < 0) {
			sqlExceptionMessage_ = "Incorrect value for maxStatements set: " + maxStatements;
			maxStatements_ = 0;
		} else {
			maxStatements_ = maxStatements;
		}
	}

	/**
	 * Returns the total number of statements that can be pooled. A value of
	 * zero (0) indicates that pooling of statements is disabled.
	 * 
	 * @return The total number of statements that can be pooled.
	 */
	int getMaxStatements() {
		return maxStatements_;
	}

	/**
	 * Returns the URL used in the current Type 4 connection. JDBC Type 4
	 * driver URL uses the following format:-
	 * <code>jdbc:t4jdbc://host:port/:</code>
	 * 
	 * @deprecated Use <code>getUrl()</code> to obtain the URL string.
	 * @return the URL string.
	 * @see #getUrl()
	 */
	String getURL() {
		return getUrl();
	}

	/**
	 * Returns the URL used in the current Type 4 connection. JDBC Type 4
	 * driver URL uses the following format:-
	 * <code>jdbc:t4jdbc://host:port/:</code>
	 * 
	 * @return the URL string.
	 * @see #setUrl(String)
	 */
	public String getUrl() {
		return url_;
	}

	/**
	 * Sets the URL for the Type 4 connection. JDBC Type 4 driver URL uses
	 * the following format:-
	 * <code>jdbc:t4jdbc://host:port/:prop-name=value</code> This method
	 * does not validate the url value.
	 * 
	 * @param url
	 *            the URL.
	 * @see #getUrl()
	 */
	void setUrl(String url) {
		if (url != null) {
			url_ = url;
		} else {
			url_ = "";
		}
	}

	/**
	 * Validates the input url string follows the correct jdbc:t4jdbc:<host>:<port>/:<prop-name=prop-val>;<prop-name=prop-val>
	 * format.
	 * 
	 * @param url
	 *            of the Type 4 driver.
	 * @return <code>true</code> when the <url> is in the Type 4 driver
	 *         format.
	 */
	boolean acceptsUrl(String url) {
		try {
			new T4Address(this, locale_, url);
		} catch (SQLException sqlex) {
			return false;
		}
		return true;
	}

	/**
	 * Sets the URL for the Type 4 connection. JDBC Type 4 driver URL uses
	 * the following format:-
	 * <code>jdbc:t4jdbc://host:port/:prop-name=value</code>. This
	 * validates the url value and throws SQLException if the URL value is
	 * incorrect.
	 * 
	 * @param url
	 *            the URL.
	 * @see #getUrl()
	 */
	Properties setURL(String url) throws SQLException {
		String host = null;
		String port = null;
		Properties props = null;

		t4addr_ = new T4Address(this, locale_, url);
		props = t4addr_.getProps();
		initialize(props);
		setUrl(t4addr_.getUrl());
		return props;
	}

	/**
	 * Retunrs the Type 4 <code>T4Address</code> class.
	 * 
	 * @return the current <code>T4Address</code> class.
	 */
	T4Address getAddress() {
		return t4addr_;
	}

	/**
	 * Sets the Safeguard user name to be used while connecting to NDCS server
	 * for authentication.
	 * 
	 * @param user
	 *            Sets the user for the current Type 4 connection.
	 * @see #getUser()
	 */
	void setUser(String user) {
		if (user == null) {
			user_ = "";
		} else {
			user_ = user;
		}
	}

	/**
	 * Returns the Safeguard user name associated with this Type 4 connection.
	 * 
	 * @return The user name.
	 * @see #setUser(String)
	 */
	String getUser() {
		return user_;
	}

	/**
	 * Sets the Safeguard password to be used for authentication when connecting
	 * to the NDCS server.
	 * 
	 * @param pwd
	 *            The Safeguard password for the current Type 4 connection.
	 */
	void setPassword(String pwd) {
		if (pwd == null) {
			pwd_ = "";
		} else {
			pwd_ = pwd;
		}
	}

	/**
	 * @deprecated <code>getPassword()</code> would not be supported in the
	 *             future releases.
	 * @return the password associated with this Type 4 connection.
	 */
	String getPassword() {
		return pwd_;
	}

	/**
	 * Sets the login timeout in seconds for the Type 4 connection. The default
	 * login timeout value is set to 30 minutes.
	 * 
	 * @param loginTimeout
	 *            The login timeout value in seconds.
	 * @see #setLoginTimeout(int)
	 * @see #getLoginTimeout()
	 */
	void setLoginTimeout(String loginTimeout) {
		int loginTo = 1800;
		if (loginTimeout != null) {
			try {
				loginTo = Short.parseShort(loginTimeout);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for loginTimeout set: " + loginTimeout + ex.getMessage();
				loginTo = 1800;
			}
		}
		setLoginTimeout(loginTo);
	}

	/**
	 * Sets the login timeout in seconds for the Type 4 connection. The default
	 * login timeout value is set to 30 minutes.
	 * 
	 * @param loginTimeout
	 *            The login timeout value in seconds.
	 * @see #setLoginTimeout(String)
	 * @see #getLoginTimeout()
	 */
	void setLoginTimeout(int loginTimeout) {
		if (loginTimeout < 0) {
			sqlExceptionMessage_ = "Incorrect value for loginTimeout set: " + loginTimeout + ".";
			loginTimeout_ = 1800;
		} else {
			loginTimeout_ = loginTimeout;
		}
	}

	/**
	 * Returns the login timeout value set for the current Type 4 connection.
	 * 
	 * @return the login timeout value in seconds.
	 * @see #setLoginTimeout(int)
	 * @see #setLoginTimeout(String)
	 */
	int getLoginTimeout() {
		return loginTimeout_;
	}

	// -----------------------------------------------------------------

	/***************************************************************************
	 * Start comment out seciont ************* * Sets the close connection
	 * timeout in seconds for the Type 4 connection. The default close
	 * connection timeout value is set to 60 seconds.
	 * 
	 * @param closeConnectionTimeout
	 *            The close connection timeout value in seconds.
	 * @see #setCloseConnectionTimeout(int)
	 * @see #getCloseConnectionTimeout()
	 * 
	 * public void setCloseConnectionTimeout(String closeConnectionTimeout) {
	 * int closeConnectionTo = 60; if (closeConnectionTimeout != null) { try {
	 * closeConnectionTo = Integer.parseInt(closeConnectionTimeout); } catch
	 * (NumberFormatException ex) { sqlExceptionMessage_ = "Incorrect value for
	 * closeConnectionTimeout set: " + closeConnectionTimeout + ex.getMessage();
	 * closeConnectionTo = 60; } } setCloseConnectionTimeout(closeConnectionTo); } *
	 * Sets the close connection timeout in seconds for the Type 4 connection.
	 * The default close connection timeout value is set to 60 seconds.
	 * @param closeConnectionTimeout
	 *            The close connection timeout value in seconds.
	 * @see #setCloseConnectionTimeout(String)
	 * @see #getCloseConnectionTimeout()
	 * 
	 * public void setCloseConnectionTimeout(int closeConnectionTimeout) { if
	 * (closeConnectionTimeout < 0) { sqlExceptionMessage_ = "Incorrect value
	 * for closeConnectionTimeout set: " + closeConnectionTimeout + ".";
	 * closeConnectionTimeout_ = 60; } else { closeConnectionTimeout_ =
	 * closeConnectionTimeout; } } * Returns the close connection timeout value
	 * set for the current Type 4 connection.
	 * @return the close connection timeout value in seconds.
	 * @see #setCloseConnectionTimeout(int)
	 * @see #setCloseConnectionTimeout(String)
	 * 
	 * public int getCloseConnectionTimeout() { return closeConnectionTimeout_; }
	 **************************************************************************/

	// -----------------------------------------------------------------
	/**
	 * Sets the network timeout in seconds for the Type 4 connection. The
	 * default network timeout value is set to infinity seconds.
	 * 
	 * @param networkTimeout
	 *            The network timeout value in seconds.
	 * @see #setNetworkTimeout(String)
	 * @see #getNetworkTimeout()
	 */
	void setNetworkTimeout(String networkTimeout) {
		int networkTo = 0;
		if (networkTimeout != null) {
			try {
				networkTo = Integer.parseInt(networkTimeout);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for networkTimeout set: " + networkTimeout + ex.getMessage();
				networkTo = 0;
			}
		}
		setNetworkTimeout(networkTo);
	}

	/**
	 * Sets the network timeout in seconds for the Type 4 connection. The
	 * default network timeout value is set to infinity seconds.
	 * 
	 * @param networkTimeout
	 *            The network timeout value in seconds.
	 * @see #setNetworkTimeout(int)
	 * @see #setNetworkTimeout()
	 */
	void setNetworkTimeout(int networkTimeout) {
		if (networkTimeout < 0) {
			sqlExceptionMessage_ = "Incorrect value for networkTimeout set: " + networkTimeout + ".";
			networkTimeoutInMillis_ = DEFAULT_NETWORK_TIMEOUT_IN_MILLIS;
		} else {
			networkTimeoutInMillis_ = networkTimeout * 1000;
		}
	}

	void setNetworkTimeoutInMillis(int networkTimeoutInMillis) {
		networkTimeoutInMillis_ = networkTimeoutInMillis;
	}

	/**
	 * Returns the network timeout value set for the current Type 4 connection.
	 * 
	 * @return the network timeout value in seconds.
	 * @see #getNetworkTimeout(int)
	 * @see #getNetworkTimeout(String)
	 */
	int getNetworkTimeout() {
		return networkTimeoutInMillis_ / 1000;
	}

        int getNetworkTimeoutInMillis() {
            return networkTimeoutInMillis_;
        }
 

	// -----------------------------------------------------------------

	/*
	 * Sets the connection timeout value for the Type 4 connection. Set this
	 * value to 0 for infinite timeout. The default is set to -1. A negative
	 * value indicates the NDCS server to use the connection timeout value set
	 * by the administrator on the NDCS data source. @param connectionTimeout
	 * The connection timeout value in seconds.
	 * 
	 * @see #setConnectionTimeout(int)
	 * @see #setServerDataSource(String)
	 */
	void setConnectionTimeout(String connectionTimeout) {
		int tmpTimeout = -1;
		if (connectionTimeout != null) {
			try {
				tmpTimeout = Integer.parseInt(connectionTimeout);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for connectionTimeout set: " + connectionTimeout + ". "
						+ ex.getMessage();
				tmpTimeout = -1;
			}
		}
		setConnectionTimeout(tmpTimeout);
	}

	void setClipVarchar(String clipVarchar) {
		short tmp = 0;
		if (clipVarchar != null) {
			try {
				tmp = Short.parseShort(clipVarchar);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for clipVarchar set: " + clipVarchar + ". "
						+ ex.getMessage();
				tmp = 0;
			}
		}
		setClipVarchar(tmp);
	}
	/*
	 * Sets the connection timeout value for the Type 4 connection. Set this
	 * value to 0 for infinite timeout. The default is set to -1. A negative
	 * value indicates the NDCS server to use the connection timeout value set
	 * by the administrator on the NDCS data source. @param connectionTimeout
	 * The connection timeout value in seconds.
	 * 
	 * @see #setConnectionTimeout(String)
	 * @see #setServerDataSource(String)
	 */
	void setConnectionTimeout(int connectionTimeout) {
        if (connectionTimeout > Short.MAX_VALUE) {
            sqlExceptionMessage_ = "Incorrect value for connectionTimeout set: [" + connectionTimeout
                    + "]. Max value is: [" + Short.MAX_VALUE + "]";
        }

		if (connectionTimeout < 0) {
			/*
			 * sqlExceptionMessage_ = "Incorrect value for connectionTimeout
			 * set: " + connectionTimeout + ". ";
			 */
			connectionTimeout_ = -1;
		} else {
			connectionTimeout_ = connectionTimeout;
		}
	}
	void setClipVarchar(short clipVarchar) {
		clipVarchar_=clipVarchar;
	}
	/**
	 * Sets the max idle time value for the Type 4 connection. The default is
	 * set to 0 (no timeout). Negative values are treated as 0.
	 * 
	 * @param maxIdleTime
	 *            The timeout value in seconds.
	 * @see #setMaxIdleTime(int)
	 */
	void setMaxIdleTime(String maxIdleTime) {
		int tmpTimeout = DEFAULT_MAX_IDLE_TIMEOUT;
		if (maxIdleTime != null) {
			try {
				tmpTimeout = Integer.parseInt(maxIdleTime);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for maxIdleTime set: " + maxIdleTime + ". " + ex.getMessage();
				tmpTimeout = DEFAULT_MAX_IDLE_TIMEOUT;
			}
		}
		setMaxIdleTime(tmpTimeout);
	}

	/**
	 * Sets the max idle time value for the Type 4 connection. The default is
	 * set to 0 (no timeout). Negative values are treated as 0.
	 * 
	 * @param maxIdleTime
	 *            The timeout value in seconds.
	 * @see #setMaxIdleTime(String)
	 */
	void setMaxIdleTime(int maxIdleTime) {
		if (maxIdleTime < 0) {
			maxIdleTime_ = DEFAULT_MAX_IDLE_TIMEOUT;
		} else {
			maxIdleTime_ = maxIdleTime;
		}
	}

	/*
	 * Returns the connection timeout value associated with this Type 4
	 * connection. @return The connection timeout value in seconds.
	 * 
	 * @see #setConnectionTimeout(int)
	 */

	int getConnectionTimeout() {
		return connectionTimeout_;
	}
	short getClipVarchar() {
		return clipVarchar_;
	}

	/**
	 * Returns the max idle time value associated with this Type 4 connection.
	 * 
	 * @return The connection timeout value in seconds.
	 * @see #setMaxIdleTime(int)
	 */
	int getMaxIdleTime() {
		return maxIdleTime_;
	}

	/**
	 * Sets the logging level for the current Type 4 connection. Default value
	 * is OFF. Other valid values are SEVERE (highest value) WARNING INFO CONFIG
	 * FINE FINER FINEST (lowest value).
	 * 
	 * @param level
	 *            logging level.
	 * @see #getT4LogLevel()
	 * @see java.util.logging.Level
	 */
	void setT4LogLevel(String level) {
		t4LogLevel = Level.parse("OFF");
		if (level != null) {
			try {
				t4LogLevel = Level.parse(level);
			} catch (Exception ex) {

				SQLException se = TrafT4Messages.createSQLException(null, null, "problem_with_logging", ex.getMessage());
				sqlExceptionMessage_ = se.getMessage();
				// throw se;
				// RuntimeException rte = new RuntimeException(se.getMessage(),
				// se);
				// throw rte;
				// sqlExceptionMessage_ = "Incorrect value for T4LogLevel set: "
				// +
				// level + ". " + ex.getMessage();
				// t4LogLevel = Level.parse("INFO");
			}
		}
	}

	/**
	 * Returns the Type 4 log level associated with the current Type 4
	 * connection. The value returned must one of the following strings. SEVERE
	 * (highest value) WARNING INFO CONFIG FINE FINER FINEST (lowest value).
	 * 
	 * @return <code>java.util.logging.Level</code> associated with the
	 *         current Type 4 connection.
	 * @see #setT4LogLevel(String)
	 * @see java.util.logging.Level
	 */
	Level getT4LogLevel() {
		return t4LogLevel;
	}

	/**
	 * Sets the location of the file to which the logging is to be done.
	 * Changing this location after making a connection has no effect; because
	 * the Type 4 reads this property before the connection is made. The default
	 * name is a generated file name defined by the following pattern:
	 * %h/t4jdbc%u.log where: "/" represents the local pathname separator "%h"
	 * represents the value of the "user.home" system property. If %h is not
	 * defined, then the behavior is undefined "%u" represents a unique number
	 * to resolve conflicts
	 * 
	 * @param t4LogFile
	 *            The Type 4 log file location. If the parameter is null, then
	 *            the T4LogFile is set to the global log file.
	 * @see #getT4LogFile()
	 * @see java.util.logging.Logger
	 */
	void setT4LogFile(String t4LogFile) {
		if (t4LogFile != null) {
			T4LogFile_ = t4LogFile;
		} else {
			T4LogFile_ = t4GlobalLogFile;
		}
	}

	/**
	 * Returns the Type 4 log file location associated with the current Type 4
	 * connection.
	 * 
	 * @return The Type 4 log file location.
	 * @see #setT4LogFile(String)
	 */
	String getT4LogFile() {
		return T4LogFile_;
	}

	String getT4GlobalLogFile() {
		return t4GlobalLogFile;
	}

	void setT4GlobalLogFile(String lgf) {
		t4GlobalLogFile = lgf;
	}

	// --------------------------------------------
	FileHandler getT4GlobalLogFileHandler() {
		return t4GlobalLogFileHandler;
	} // end getT4GlobalLogFileHandler

	// --------------------------------------------
	void setT4GlobalLogFileHandler(Object fh) {
		t4GlobalLogFileHandler = (FileHandler) fh;
	}

	// --------------------------------------------

	Logger getLogger() {
		return logger;
	}

	void setLogger(Object log) {
		if (log != null) {
			logger = (Logger) log;
			t4Logger_ = logger;
		} else {
			logger = t4GlobalLogger;
			t4Logger_ = logger;
		}
	}

	// --------------------------------------------
	/**
	 * This method will return the log file handlder It also has the side effect
	 * of creating a log file handler if one doesn't exist.
	 */
	FileHandler getT4LogFileHandler() {
		try {
			if (t4LogFileHandler_ == null) {
				if (T4LogFile_.equals(t4GlobalLogFile)) {
					t4LogFileHandler_ = t4GlobalLogFileHandler;
				} else {
					t4LogFileHandler_ = new FileHandler(T4LogFile_);
					t4LogFileHandler_.setFormatter(new T4LogFormatter());
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return t4LogFileHandler_;
	} // end getT4LogFileHandler

	// --------------------------------------------
	void setT4LogFileHandler(Object fh) {
		t4LogFileHandler_ = (FileHandler) fh;
	}

	// ----------------------------------------------------------

	/**
	 * Returns the <code>PrintWriter</code> object associated with the current
	 * Type 4 connection.
	 * 
	 * @return <code>java.io.PrintWriter</code> object associated with current
	 *         connection.
	 * @throws SQLException
	 *             when error occurs.
	 * @see #setLogWriter(PrintWriter)
	 * @see javax.sql.ConnectionPoolDataSource
	 */
	public PrintWriter getLogWriter() throws SQLException {
		return logWriter_;
	}

	/**
	 * Sets the <code>PrintWriter</code> object for the current Type 4
	 * connection.
	 * 
	 * @param printWriter
	 *            For the current Type 4 logging.
	 * @throws SQLException
	 *             when error occurs.
	 * @see #getLogWriter()
	 * @see javax.sql.ConnectionPoolDataSource
	 */
	public void setLogWriter(PrintWriter printWriter) throws SQLException {
		logWriter_ = printWriter;
	}

	// properties queryTimeout_ for future use.
	// setter/getter methods for queryTimeout. These methods are not public YET.
	/**
	 * @param queryTimeout
	 *            Sets the query timeout value in seconds. For future use only
	 *            this property is not supported in the current release.
	 */
	void setQueryTimeout(String queryTimeout) {
		short tmpQTimeOut = 0;
		if (queryTimeout != null) {
			try {
				tmpQTimeOut = Short.parseShort(queryTimeout);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for queryTimeout set: " + queryTimeout + ex.getMessage();
				tmpQTimeOut = 0;
			}
		}
		setQueryTimeout(tmpQTimeOut);
	}

	/**
	 * @param queryTimeout
	 *            Sets the query timeout value in seconds. For future use only
	 *            this property is not supported in the current release.
	 */
	void setQueryTimeout(short queryTimeout) {
		if ((queryTimeout *1000) > networkTimeoutInMillis_)
			queryTimeout = (short)(networkTimeoutInMillis_ % 1000);
		queryTimeout_ = queryTimeout;
	}

	/**
	 * @return queryTimeOut value in seconds. For future use only this property
	 *         is not supported in the current release.
	 */
	short getQueryTimeout() {
		return queryTimeout_;
	}

	void setIgnoreCancel(String ignoreCancel)
	{
		if (ignoreCancel != null)
			ignoreCancel_ = Boolean.parseBoolean(ignoreCancel);
		else
			ignoreCancel_ = true;
	}

        void setIgnoreCancel(boolean ignoreCancel)
	{
		ignoreCancel_ = ignoreCancel;
	}

	boolean getIgnoreCancel()
	{
		return ignoreCancel_;
	}

	void setActiveTimeBeforeCancel(String activeTimeBeforeCancel) {
		int tmpActiveTimeBeforeCancel = 0;
		if (activeTimeBeforeCancel != null) {
			try {
				tmpActiveTimeBeforeCancel = Integer.parseInt(activeTimeBeforeCancel);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for activeTimeBeforeCancel set: " + activeTimeBeforeCancel + ex.getMessage();
				tmpActiveTimeBeforeCancel = -1;
			}
		}
		setActiveTimeBeforeCancel(tmpActiveTimeBeforeCancel);
	}

	void setActiveTimeBeforeCancel(int activeTimeBeforeCancel) 
	{
		if (activeTimeBeforeCancel < networkTimeoutInMillis_)
			activeTimeBeforeCancel = networkTimeoutInMillis_;
		activeTimeBeforeCancel_ = activeTimeBeforeCancel;
	}

	int getActiveTimeBeforeCancel() 
	{
		return activeTimeBeforeCancel_;
	}

	
	/**
	 * Sets the value (in KB) for the size of the fetch buffer. This is used
	 * when rows are fetched are performed from a ResultSet object after a
	 * successful executeQuery() operation on a statement. The default size is
	 * 4. Zero and negative values are treated as default values.
	 * 
	 * @param fetchBufferSize
	 * @see #getFetchBufferSize()
	 * @see #setFetchBufferSize(String)
	 */
	void setFetchBufferSize(short fetchBufferSize) {
		fetchBufferSize_ = 512;
		if (fetchBufferSize > 512) {
			fetchBufferSize_ = fetchBufferSize;
		}
	}

	/**
	 * Sets the value (in KB) for the size of the fetch buffer. This is used
	 * when rows are fetched are performed from a ResultSet object after a
	 * successful executeQuery() operation on a statement. The default size is
	 * 4. Zero and negative values are treated as default values.
	 * 
	 * @param fetchBufferSize
	 * @see #getFetchBufferSize()
	 * @see #setFetchBufferSize(short)
	 */
	void setFetchBufferSize(String fetchBufferSize) {
		short setFetchSizeVal = 4;
		if (fetchBufferSize != null) {
			try {
				setFetchSizeVal = Short.parseShort(fetchBufferSize);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect fetchBufferSize value set: " + setFetchSizeVal + ". "
						+ ex.getMessage();
				setFetchSizeVal = 1;
			}
		}
		setFetchBufferSize(setFetchSizeVal);
	}

	/**
	 * Returns the size of the fetch buffer.
	 * 
	 * @see #setFetchBufferSize(short)
	 * @see #setFetchBufferSize(String)
	 */
	short getFetchBufferSize() {
		return fetchBufferSize_;
	}

	/**
	 * Configure to use array binding feature for the Type 4 connection. Default
	 * value is true.
	 * 
	 * @param useArrayBinding
	 */
	void setUseArrayBinding(String useArrayBinding) {
		boolean boolUseArrayBinding = false;
		if (useArrayBinding != null) {
			if (useArrayBinding.equalsIgnoreCase("true")) {
				boolUseArrayBinding = true;
			}
		}
		setUseArrayBinding(boolUseArrayBinding);
	}

	/**
	 * Configure to use array binding feature for the Type 4 connection. Default
	 * value is true.
	 * 
	 * @param useArrayBinding
	 */
	void setUseArrayBinding(boolean useArrayBinding) {
		useArrayBinding_ = useArrayBinding;
	}

	/**
	 * Return whether the connection uses Database array binding feature.
	 * 
	 * @return useArrayBinding boolean flag indicates Database RowSet (array
	 *         binding) feature is used or not.
	 */
	boolean getUseArrayBinding() {
		return useArrayBinding_;
	}

	/**
	 * Configure the Type 4 connection to continue batch processing of next
	 * commands even after errors. Default value is true.
	 * 
	 * @param batchRecovery
	 */
	void setBatchRecovery(String batchRecovery) {
		boolean boolBatchRecovery = true;
		if (batchRecovery != null) {
			if (batchRecovery.equalsIgnoreCase("false")) {
				boolBatchRecovery = false;
			}
		}
		setBatchRecovery(boolBatchRecovery);
	}

	/**
	 * Configure the Type 4 connection to continue batch processing of next
	 * commands even after errors. Default value is true.
	 * 
	 * @param batchRecovery
	 */
	void setBatchRecovery(boolean batchRecovery) {
		batchRecovery_ = batchRecovery;
	}

	/**
	 * Return whether the Type 4 connection is configured to continue batch
	 * processing of next commands even after errors.
	 * 
	 * @return batchRecovery
	 */
	boolean getBatchRecovery() {
		return batchRecovery_;
	}

	/**
	 * Sets the buffer size in bytes used by the transport layer between Type 4
	 * client classes and NDCS server on the NSK system.
	 * 
	 * @param transportBufferSize
	 *            set the transport buffer size in bytes for the current Type 4
	 *            connection. Default value is 32000.
	 */
	/*
	 * public void setTransportBufferSize(String transportBufferSize) { short
	 * tmpbuf = 32000; if (transportBufferSize != null) { try { tmpbuf = (new
	 * Short(transportBufferSize)).shortValue(); } catch (Exception ex) {
	 * sqlExceptionMessage_ = "Incorrect value for transportBufferSize set: " +
	 * transportBufferSize + ex.getMessage(); tmpbuf = 32000; } }
	 * setTransportBufferSize(tmpbuf); }
	 */

	/**
	 * Sets the buffer size in bytes used by the transport layer between Type 4
	 * client classes and NDCS server on the NSK system. Transport buffer
	 * minimum acceptable size is 2000 bytes. If the value set is below 2000
	 * default buffer size of 3200 is set instead.
	 * 
	 * @param transportBufferSize
	 *            set the transport buffer size in bytes for the current
	 *            connection. Default value for the driver is 32000 bytes.
	 */
	/*
	 * public void setTransportBufferSize(short transportBufferSize) { if
	 * (transportBufferSize < 2000) { transportBufferSize_ = 32000; } else {
	 * transportBufferSize_ = transportBufferSize; } }
	 */

	/**
	 * Returns the buffer size in bytes used by the transport layer between Type
	 * 4 client classes and NDCS server on the NSK system.
	 * 
	 * @return The transport buffer size used by the current Type 4 connection.
	 */
	/*
	 * public short getTransportBufferSize() { return transportBufferSize_; }
	 */

	/**
	 * @return any sql exception associated while setting the properties on this
	 *         Type 4 connection. This mthod is accessed by InterfaceConnection
	 *         to check if there is any SQL error setting the Type 4 properties.
	 */
	String getSQLException() {
		// System.out.println("sqlExceptionMessage_ = " + sqlExceptionMessage_);
		return sqlExceptionMessage_;
	}

    public int getLobChunkSize() {
        return lobChunkSize_;
    }

    public void setLobChunkSize(int lobChunkSize_) {
        this.lobChunkSize_ = lobChunkSize_;
    }

    public void setLobChunkSize(String val) {
        this.lobChunkSize_ = 10;
        if (val != null) {
            try {
                this.lobChunkSize_ = Integer.parseInt(val);
            } catch (NumberFormatException ex) {
                sqlExceptionMessage_ = "Incorrect value for setLobChunkSize set: " + val + ex.getMessage();
                this.lobChunkSize_ = 10;
            }
        }
    }

    public boolean getUseLobHandle() {
        return useLobHandle_;
    }

    public void setUseLobHandle(boolean useLobHandle) {
        this.useLobHandle_ = useLobHandle;
    }

    public void setUseLobHandle(String val) {
        if (val != null) {
            setUseLobHandle(Boolean.parseBoolean(val));
        }
        else {
            setUseLobHandle(false);
        }
    }

	/**
	 * Returns the rounding mode set for the driver as an Integer value with one
	 * of the following values. static int ROUND_CEILING Rounding mode to round
	 * towards positive infinity. static int ROUND_DOWN Rounding mode to round
	 * towards zero. static int ROUND_FLOOR Rounding mode to round towards
	 * negative infinity. static int ROUND_HALF_DOWN Rounding mode to round
	 * towards "nearest neighbor" unless both neighbors are equidistant, in
	 * which case round down. static int ROUND_HALF_EVEN Rounding mode to round
	 * towards the "nearest neighbor" unless both neighbors are equidistant, in
	 * which case, round towards the even neighbor. static int ROUND_HALF_UP
	 * Rounding mode to round towards "nearest neighbor" unless both neighbors
	 * are equidistant, in which case round up. static int ROUND_UNNECESSARY
	 * Rounding mode to assert that the requested operation has an exact result,
	 * hence no rounding is necessary. static int ROUND_UP Rounding mode to
	 * round away from zero.
	 */
	int getRoundingMode() {
		return roundMode_;
	}

	/**
	 * This method sets the round mode behaviour for the driver.
	 * 
	 * @param roundMode
	 *            Integer value with one of the following values: static int
	 *            ROUND_CEILING Rounding mode to round towards positive
	 *            infinity. static int ROUND_DOWN Rounding mode to round towards
	 *            zero. static int ROUND_FLOOR Rounding mode to round towards
	 *            negative infinity. static int ROUND_HALF_DOWN Rounding mode to
	 *            round towards "nearest neighbor" unless both neighbors are
	 *            equidistant, in which case round down. static int
	 *            ROUND_HALF_EVEN Rounding mode to round towards the "nearest
	 *            neighbor" unless both neighbors are equidistant, in which
	 *            case, round towards the even neighbor. static int
	 *            ROUND_HALF_UP Rounding mode to round towards "nearest
	 *            neighbor" unless both neighbors are equidistant, in which case
	 *            round up. static int ROUND_UNNECESSARY Rounding mode to assert
	 *            that the requested operation has an exact result, hence no
	 *            rounding is necessary. static int ROUND_UP Rounding mode to
	 *            round away from zero. The default behaviour is to do
	 *            ROUND_HALF_EVEN.
	 */
	void setRoundingMode(String roundMode) {
		roundMode_ = Utility.getRoundingMode(roundMode);
	}

	/**
	 * This method sets the round mode behaviour for the driver.
	 * 
	 * @param roundMode
	 *            Integer value with one of the following values: static int
	 *            ROUND_CEILING Rounding mode to round towards positive
	 *            infinity. static int ROUND_DOWN Rounding mode to round towards
	 *            zero. static int ROUND_FLOOR Rounding mode to round towards
	 *            negative infinity. static int ROUND_HALF_DOWN Rounding mode to
	 *            round towards "nearest neighbor" unless both neighbors are
	 *            equidistant, in which case round down. static int
	 *            ROUND_HALF_EVEN Rounding mode to round towards the "nearest
	 *            neighbor" unless both neighbors are equidistant, in which
	 *            case, round towards the even neighbor. static int
	 *            ROUND_HALF_UP Rounding mode to round towards "nearest
	 *            neighbor" unless both neighbors are equidistant, in which case
	 *            round up. static int ROUND_UNNECESSARY Rounding mode to assert
	 *            that the requested operation has an exact result, hence no
	 *            rounding is necessary. static int ROUND_UP Rounding mode to
	 *            round away from zero. The default behaviour is to do
	 *            ROUND_HALF_EVEN.
	 */
	void setRoundingMode(int roundMode) {
		roundMode_ = Utility.getRoundingMode(roundMode);
	}

	// ----------------------------------------------------------
	void setConnectionID(String connID) {
		connectionID_ = connID;
	}

	String getConnectionID() {
		return connectionID_;
	}

	// ----------------------------------------------------------
	void setDialogueID(String diaID) {
		dialogueID_ = diaID;
	}

	String getDialogueID() {
		return dialogueID_;
	}

	// ----------------------------------------------------------
	void setNcsMajorVersion(short majorVer) {
		ncsMajorVersion_ = majorVer;
	}

	void setNcsMajorVersion(String majorVer) {
		short mv = 0;

		if (majorVer != null) {
			try {
				mv = Short.parseShort(majorVer);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for NDCS major version set: " + majorVer + ex.getMessage();
				mv = 0;
			}
		}
		setNcsMajorVersion(mv);
		ncsMajorVersion_ = mv;
	}

	short getNcsMajorVersion() {
		return ncsMajorVersion_;
	}

	// ----------------------------------------------------------
	void setNcsMinorVersion(short minorVer) {
		ncsMinorVersion_ = minorVer;
	}

	void setNcsMinorVersion(String minorVer) {
		short mv = 0;

		if (minorVer != null) {
			try {
				mv = Short.parseShort(minorVer);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for NDCS minor version set: " + minorVer + ex.getMessage();
				mv = 0;
			}
		}
		setNcsMinorVersion(mv);
		ncsMinorVersion_ = mv;
	}

	short getNcsMinorVersion() {
		return ncsMinorVersion_;
	}

	void setSqlmxMajorVersion(short majorVer) {
		sqlmxMajorVersion_ = majorVer;
	}

	void setSqlmxMajorVersion(String majorVer) {
		short mv = 0;

		if (majorVer != null) {
			try {
				mv = Short.parseShort(majorVer);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for Database major version set: " + majorVer
						+ ex.getMessage();
				mv = 0;
			}
		}
		setSqlmxMajorVersion(mv);
	}

	public void setSPJEnv(String SPJEnv) {
		if (SPJEnv == null) {
			SPJEnv_ = false;
		} else {
			SPJEnv_ = (SPJEnv.equalsIgnoreCase("true"));
		}
	}

	public void setSPJEnv(boolean SPJEnv) {
		SPJEnv_ = SPJEnv;
	}

	public boolean getSPJEnv() {
		return SPJEnv_;
	}

	public void setKeepRawFetchBuffer(String keep) {
		if (keep == null) {
			keepRawFetchBuffer_ = false;
		} else {
			keepRawFetchBuffer_ = (keep.equalsIgnoreCase("true"));
		}
	}

	public void setKeepRawFetchBuffer(boolean keep) {
		keepRawFetchBuffer_ = keep;
	}

	public boolean getKeepRawFetchBuffer() {
		return keepRawFetchBuffer_;
	}

	short getSqlmxMajorVersion() {
		return sqlmxMajorVersion_;
	}

	public void setCpuToUse(String cpu) {
		if (cpu == null) {
			cpuToUse_ = -1;
		} else {
			cpuToUse_ = Short.parseShort(cpu);
		}
	}

	public void setCpuToUse(short cpu) {
		cpuToUse_ = cpu;
	}

	public short getCpuToUse() {
		return cpuToUse_;
	}

	public void setSessionName(String name) {
		if (name == null)
			sessionName = "";
		else {
			sessionName = name;
		}
	}

	public String getSessionName() {
		return sessionName;
	}

	public void setReplacementString(String str) {
		if (str == null) {
			replacementString_ = "?";
		} else {
			replacementString_ = str;
		}
	}

	public String getReplacementString() {
		return replacementString_;
	}

	void setISO88591(String lang) {
		if (lang == null) {
			ISO88591_ = InterfaceUtilities.getCharsetName(InterfaceUtilities.SQLCHARSETCODE_ISO88591);
		} else {
			ISO88591_ = lang;
		}
	}

	String getISO88591() {
		return ISO88591_;
	}

	public String getRoleName() {
		return _roleName;
	}

	public void setRoleName(String roleName) {
		if (roleName != null && roleName.length() > 0) {
			if (roleName.length() > 128)
				sqlExceptionMessage_ = "Invalid RoleName.  Max length: 128";
			}
		
		this._roleName = roleName;
	}

	public String getApplicationName() {
		return _applicationName;
	}

	public void setApplicationName(String applicationName) {
		if (applicationName == null || applicationName.length() == 0)
			this._applicationName = "FASTJDBC";
		else
			this._applicationName = applicationName;
	}
	
	public void setCertificateFileActive(String file) {
		_certificateFileActive = file;
	}
	
	public String getCertificateFileActive() {
		return _certificateFileActive;
	}
	
	public void setCertificateFile(String file) {
		_certificateFile = file;
	}
	
	public String getCertificateFile() {
		return _certificateFile;
	}
	
	public void setCertificateDir(String dir) {
		_certificateDir = dir;
	}
	
	public String getCertificateDir() {
		return _certificateDir;
	}
	
	public void setDelayedErrorMode(String mode) {
		_delayedErrorMode = Boolean.valueOf(mode).booleanValue();
	}

	public void setDelayedErrorMode(boolean mode) {
		_delayedErrorMode = mode;
	}

	public boolean getDelayedErrorMode() {
		return _delayedErrorMode;
	}
	
	public void setCompression(String compression) {
		_compression = Boolean.valueOf(compression).booleanValue();
	}

	public void setCompression(boolean compression) {
		_compression = compression;
	}

	public boolean getCompression() {
		return _compression;
	}
	
	public void setKeepAlive(String val) {
		if(val == null) 
		{
			_keepAlive = true;
		}
		else 
		{
			_keepAlive = Boolean.valueOf(val).booleanValue();
		}
	}

	public void setKeepAlive(boolean val) {
		_keepAlive = val;
	}

	public boolean getKeepAlive() {
		return _keepAlive;
	}

    public void setTcpNoDelay(String val) {
        if(val == null) {
            _tcpNoDelay = true;
        }
        else {
            _tcpNoDelay = Boolean.valueOf(val).booleanValue();
        }
    }

    public void setTcp_NoDelay(boolean val) {
        _tcpNoDelay = val;
    }

    public boolean getTcpNoDelay() {
        return _tcpNoDelay;
    }

	public void setTokenAuth(String val) {
		if(val == null) 
		{
			_tokenAuth = true;
		}
		else 
		{
			_tokenAuth = Boolean.valueOf(val).booleanValue();
		}
	}

	public void setTokenAuth(boolean val) {
		_tokenAuth = val;
	}

	public boolean getTokenAuth() {
		return _tokenAuth;
	}

	boolean getSessionToken() {
		return this._sessionToken;
	}

	void setSessionToken(boolean sessionToken) {
		this._sessionToken = sessionToken;
	}

	void setSessionToken(String sessionToken) {
		setSessionToken(Boolean.valueOf(sessionToken).booleanValue());
	}

	boolean getFetchAhead() {
		return this._fetchAhead;
	}

	void setFetchAhead(boolean fetchAhead) {
		this._fetchAhead = fetchAhead;
	}

	void setFetchAhead(String fetchAhead) {
		setFetchAhead(Boolean.valueOf(fetchAhead).booleanValue());
	}

	// ----------------------------------------------------------
	void setSqlmxMinorVersion(short minorVer) {
		sqlmxMinorVersion_ = minorVer;
	}

	void setSqlmxMinorVersion(String minorVer) {
		short mv = 0;

		if (minorVer != null) {
			try {
				mv = Short.parseShort(minorVer);
			} catch (NumberFormatException ex) {
				sqlExceptionMessage_ = "Incorrect value for Database minor version set: " + minorVer
						+ ex.getMessage();
				mv = 0;
			}
		}
		setSqlmxMinorVersion(mv);
	}

	short getSqlmxMinorVersion() {
		return sqlmxMinorVersion_;
	}

	// ----------------------------------------------------------
	BigDecimal getNcsVersion() {
		String minor = new Short(getNcsMinorVersion()).toString();
		String major = new Short(getNcsMajorVersion()).toString();
		BigDecimal bigD = new BigDecimal(major + "." + minor);
		return bigD;
	}

	// ----------------------------------------------------------
	void setServerID(String serID) {
		serverID_ = serID;
	}

	String getServerID() {
		return serverID_;
	}

	/**
	 * Sets the language to use for the error messages.
	 * 
	 * @param language
	 *            Sets the language for the current Type 4 connection. The
	 *            default language used by the Type 4 driver is American
	 *            English.
	 * @see #getLanguage()
	 */
	void setLanguage(String language) {
		if (language == null) {
			locale_ = Locale.getDefault();
		} else {
			locale_ = new Locale(language, "", "");
		}
		language_ = locale_.getLanguage();
	}

	/**
	 * Returns the language in which to the Type 4 error messages will be
	 * returned to the application.
	 * 
	 * @return The language associated with the current Type 4 connection.
	 * @see #setLanguage(String language)
	 */
	String getLanguage() {
		return language_;
	}

	// ----------------------------------------------------------

	/**
	 * @return Reference object containing all the Type 4 connection properties.
	 *         The reference object can be used to register with naming
	 *         services.
	 */
	Reference addReferences(Reference ref) {
		ref.add(new StringRefAddr("dataSourceName", getDataSourceName()));
		ref.add(new StringRefAddr("serverDataSource", getServerDataSource()));
		ref.add(new StringRefAddr("description", getDescription()));
		String val = getCatalog();
		if (val != null) {
			ref.add(new StringRefAddr("catalog", val));
		}
		val = getSchema();
		if (val != null) {
			ref.add(new StringRefAddr("schema", val));

		}
		ref.add(new StringRefAddr("language", getLanguage()));
		ref.add(new StringRefAddr("maxPoolSize", Integer.toString(getMaxPoolSize())));
		ref.add(new StringRefAddr("minPoolSize", Integer.toString(getMinPoolSize())));
		ref.add(new StringRefAddr("initialPoolSize", Integer.toString(getInitialPoolSize())));
		ref.add(new StringRefAddr("maxStatements", Integer.toString(getMaxStatements())));

		ref.add(new StringRefAddr("connectionTimeout", Integer.toString(getConnectionTimeout())));
		ref.add(new StringRefAddr("maxIdleTime", Integer.toString(getMaxIdleTime())));
		ref.add(new StringRefAddr("loginTimeout", Integer.toString(getLoginTimeout())));
		// ref.add(new StringRefAddr("closeConnectionTimeout",
		// Integer.toString(getCloseConnectionTimeout())));
		ref.add(new StringRefAddr("networkTimeout", Integer.toString(getNetworkTimeout())));
		ref.add(new StringRefAddr("T4LogLevel", getT4LogLevel().toString()));
		ref.add(new StringRefAddr("T4LogFile", getT4LogFile()));

		ref.add(new StringRefAddr("url", getUrl()));
		ref.add(new StringRefAddr("user", getUser()));
		ref.add(new StringRefAddr("password", getPassword()));
		/*
		 * ref.add(new StringRefAddr("transportBufferSize",
		 * Short.toString(getTransportBufferSize())));
		 */
		/*
		 * ref.add(new StringRefAddr("useArrayBinding",
		 * Boolean.toString(getUseArrayBinding())));
		 */

		ref.add(new StringRefAddr("roundingMode", Integer.toString(getRoundingMode())));

		// propertiy queryTimeout_ for future use.
		ref.add(new StringRefAddr("queryTimeout", Integer.toString(getQueryTimeout())));
		ref.add(new StringRefAddr("ignoreCancel", Boolean.toString(getIgnoreCancel())));
		ref.add(new StringRefAddr("activeTimeBeforeCancelInSecs", Integer.toString(getActiveTimeBeforeCancel())));
		ref.add(new StringRefAddr("fetchBufferSize", Short.toString(this.getFetchBufferSize())));
		ref.add(new StringRefAddr("batchRecovery", Boolean.toString(this.getBatchRecovery())));
		return ref;
	}

	/**
	 * Instantiated by either <code>
	 * Class.forName("org.trafodion.jdbc.t4.T4Driver")</code>
	 * or by passing <code>-Djdbc.drivers=org.trafodion.jdbc.t4.T4Driver</code>
	 * property in the command line of the JDBC program.
	 */
	DriverPropertyInfo[] getPropertyInfo(String url, Properties defaults) throws SQLException {

		String level[] = { "OFF", "SEVERE", "WARNING", "INFO", "CONFIG", "FINE", "FINER", "FINEST" };
		String roundingMode[] = { "ROUND_CEILING", "ROUND_DOWN", "ROUND_UP", "ROUND_FLOOR", "ROUND_HALF_UP",
				"ROUND_UNNECESSARY", "ROUND_HALF_EVEN", "ROUND_HALF_DOWN", "ROUND_DOWN" };

		Properties props = new Properties(defaults);
		props.setProperty("url", url);

		// catalog setting
		DriverPropertyInfo[] propertyInfo = {
				setPropertyInfo("catalog", props, true, "Database catalog name", null),
				setPropertyInfo("schema", props, true, "Database schema name", null),
				setPropertyInfo("url", props, false, "jdbc:t4jdbc://<host>:<port>/:", null),
				setPropertyInfo("user", props, true, "NSK safeguard user name", null),
				setPropertyInfo("password", props, true, "NSK safeguard user password", null),
				setPropertyInfo("maxPoolSize", props, false, "Maximum connection pool size", null),
				setPropertyInfo("minPoolSize", props, false, "Minimum connection pool size", null),
				setPropertyInfo("initialPoolSize", props, false, "Initial connection pool size", null),
				setPropertyInfo("maxStatements", props, false, "Maximum statement pool size", null),
				setPropertyInfo("T4LogLevel", props, false, "Logging Level", level),
				setPropertyInfo("T4LogFile", props, false, "Logging file location", null),
				setPropertyInfo("loginTimeout", props, false, "Login time out in secs", null),
				setPropertyInfo("networkTimeout", props, false, "Network time out in secs", null),
				setPropertyInfo("connectionTimeout", props, false, "Connection time out in secs", null),
				setPropertyInfo("maxIdleTime", props, false, "Max idle time for a free pool connection in secs", null),
				setPropertyInfo("language", props, false, "Locale language to use", null),
				setPropertyInfo("serverDataSource", props, false, "NDCS data source name", null),
				setPropertyInfo("roundingMode", props, false, "Data rounding mode", roundingMode),
				setPropertyInfo("fetchBufferSize", props, false,
						"Value (in KB) for the size of the fetch buffer to be used when rows are fetched", null),
				setPropertyInfo("batchRecovery", props, false,
						"Continue batch processing of next commands even after errors", null) };

		return propertyInfo;

	}

	private DriverPropertyInfo setPropertyInfo(String name, Properties props, boolean required, String description,
			String[] choices) {
		String value = props.getProperty(name);
		DriverPropertyInfo propertyInfo = new DriverPropertyInfo(name, value);
		propertyInfo.required = required;
		propertyInfo.description = description;
		propertyInfo.choices = choices;
		return propertyInfo;
	}

	// ---------------------------------------------------------------
	static private Properties getPropertiesFileValues() {
		Properties values = null;
		String propsFile = System.getProperty("t4jdbc.properties");

		if (propsFile != null) {
			FileInputStream fis = null;
			try {
				fis = new FileInputStream(new File(propsFile));
				values = new Properties();
				values.load(fis);
			} catch (Exception ex) {
				fis = null;
				// sqlExceptionMessage_ = "Error while loading " +
				// prefix_ + "properties file: " + ex.getMessage();
			} finally {
				if (fis != null) {
					try {
						fis.close();
					} catch (IOException ioe) {
						// ignore
					}
				}
			}
		} // end if

		return values;
	} // end getPropertiesFileValues

	// -------------------------------------------------------------------------

    void setClientInfoProperties(Properties prop) {
        this.clientInfoProp = prop;
    }

    Properties getClientInfoProperties() {
        return this.clientInfoProp;
    }

    public String getClientCharset() {
        return clientCharset;
    }

    public void setClientCharset(String clientCharset) {
        this.clientCharset = clientCharset;
    }
}