/*
 * Copyright (C) 2005 NTT DATA Corporation
 * 
 */
package org.postgresforest.tool.db;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.Properties;

import org.postgresforest.tool.bean.BrokenLogInfo;
import org.postgresforest.tool.bean.ColumnInfo;
import org.postgresforest.tool.bean.ConfigInfo;
import org.postgresforest.tool.bean.DbLinkInfo;
import org.postgresforest.tool.bean.GSCInfo;
import org.postgresforest.tool.bean.HashInfo;
import org.postgresforest.tool.bean.PriorityInfo;
import org.postgresforest.tool.bean.ServerInfo;
import org.postgresforest.tool.bean.ServerPartition2Info;
import org.postgresforest.tool.bean.ServerPriorityInfo;
import org.postgresforest.tool.bean.TableInfo;
import org.postgresforest.tool.util.MessagesCommandLine;
import org.postgresql.jdbc3.Jdbc3Connection;

/**
 * グローバルシステムカタログクラス.
 * 
 * グローバルシステムカタログに対するデータアクセス処理を提供する。
 * 
 */
public class GSCdata extends DbBase {

	public static final int PRIMARY = 0;
	public static final int BACKUP = 1;

	public static final int SERVER_RUNNING = 1;
	public static final int SERVER_TROUBLE = -1;

	//TODOMASU テーブルスペース情報取得のため
	protected static DecimalFormat m_dcFmt = new DecimalFormat("00");
	//	/**
//	 * コンストラクタ。
//	 * 引数無しのコンストラクタは、ユーザ、パスワードをリソースファイルから取得する。
//	 *
//	 */
//	public GSCdata() {
//		super();
//
//		m_prop.put("user", m_sqlResource.getString("admin.user"));
//		m_prop.put("password", m_sqlResource.getString("admin.password"));
//
//	}
	/**
	 *　コンストラクタ.
	 */
	public GSCdata(String user, String password) {
		super(user, password);

	}
	
	/**
	 * コンストラクタ
	 * @param userPassword　ユーザ、パスワードが格納されたプロパティクラス
	 * @since 2.0
	 */
	public GSCdata(Properties userPassword) {
		super();
		m_prop = userPassword;

	}

	/**
	 * グローバルシステムカタログデータベース作成
	 * 
	 * グローバルシステムカタログ用の作成オプションをリソースから取得して、
	 * データベース作成処理を行う。
	 * 
	 * @return
	 * @throws SQLException
	 */
	public boolean makeDB()  {

		String gscOption = m_sqlResource.getString("create.db.gsc.option");
		return makeDB(gscOption, DB_MAKE);
		
	}

	/**
	 * グローバルシステムカタログのテーブル作成。
	 * ユーザのgrantも行う
	 * @return	true:成功.false:失敗
	 */
	public boolean makeGscTables()  {

		boolean ret = true;
		String connectUrl = "";


		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try {
				Statement ps = con.createStatement();

				connectUrl = ((Jdbc3Connection) con).getURL();
				
				//GSC用テーブル作成
				ps.execute(m_sqlResource.getString("create.gsc.forest_server"));
				ps.execute(m_sqlResource.getString("create.gsc.forest_servdb"));
				//Ver3.0
				ps.execute(m_sqlResource.getString("create.gsc.forest_hash"));
				ps.execute(
					m_sqlResource.getString("create.gsc.forest_tablepart"));
				ps.execute(
					m_sqlResource.getString("create.gsc.forest_tablepartdtl"));
				ps.execute(m_sqlResource.getString("create.gsc.forest_partatr"));
				ps.execute(m_sqlResource.getString("create.gsc.forest_gsc"));
				//Ver2.1
				ps.execute(m_sqlResource.getString("create.gsc.forest_brokenlog"));

				//Ver3.0
				ps.execute(m_sqlResource.getString("create.gsc.forest_config"));

				//GSC用テーブルへのユーザグラント
				ps.execute(m_sqlResource.getString("grant.gsc.forest_server"));
				ps.execute(m_sqlResource.getString("grant.gsc.forest_servdb"));
				ps.execute(
					m_sqlResource.getString("grant.gsc.forest_tablepartdtl"));
				ps.execute(m_sqlResource.getString("grant.gsc.forest_tablepart"));
				ps.execute(m_sqlResource.getString("grant.gsc.forest_partatr"));
				ps.execute(m_sqlResource.getString("grant.gsc.forest_gsc"));
				//Ver2.1
				ps.execute(m_sqlResource.getString("grant.gsc.forest_brokenlog"));

								
				ps.close();

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}
		}

		return ret;


	}

	/**
	 * サーバインスタンス削除
	 * 
	 * forest_server からしていされたIDのレコードを削除
	 * @param id	サーバID
	 * @return	true:成功.false:失敗
	 */
	public boolean delServer(int id) {

		boolean ret = true;
		String connectUrl = "";


		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try {
				connectUrl = ((Jdbc3Connection) con).getURL();
	
				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.server"));
	
				smt.setInt(1, id);
	
				smt.execute();
				smt.close();
	

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}

	/**
	 * ハッシュ関数登録
	 * 
	 * 指定されたクラスファイルをforest_hashへ追加する。
	 * 
	 * 
	 * @param name
	 * @param description
	 * @param classImage
	 * @return	true:成功.false:失敗
	 * @since 3.0
	 */
	public boolean addHash(String name, String description, byte[] classImage) {

		boolean ret = true;
		String connectUrl = "";

		//--------------
		// GSC情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.hash"));
		
				psmt.setString(1, name);
				psmt.setString(2, description);
				psmt.setBytes(3, classImage);
				psmt.execute();
		
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}

	/**
	 * ハッシュ関数登録
	 * 
	 * 指定されたクラスファイルをforest_hashへ追加する。
	 * 
	 * 
	 * @param name
	 * @param description
	 * @param classImage
	 * @return	true:成功.false:失敗
	 * @since 3.0
	 */
	public boolean addConfig(ConfigInfo configInfo) {

		boolean ret = true;
		String connectUrl = "";

		//--------------
		// GSC情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.config"));
		
				psmt.setString(1, configInfo.getConfigId());
				psmt.setString(2, configInfo.getDescription());
				psmt.setLong(3, configInfo.getCacheReflesh());
				psmt.setLong(4, configInfo.getRetryCount());
				psmt.setLong(5, configInfo.getDefectTimeout());
				psmt.setLong(6, configInfo.getDistributedCon());
				psmt.setBoolean(7, configInfo.isPertitionMode());
				psmt.setBoolean(8, configInfo.isSyncMode());
				psmt.setTimestamp(9, new Timestamp(configInfo.getUpdateDate().getTime()));

				psmt.execute();
		
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}


	/**
	 * コンフィグレーションテーブルの更新日時を現在日時で更新する。
	 * 
	 * @return	true:成功.false:失敗
	 * @since 3.0
	 */
	public boolean updateConfigDate() {

        boolean ret = true;
		String connectUrl = "";

		Timestamp tm = new Timestamp( System.currentTimeMillis() );
		
		//--------------
		// GSC情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString("update,gsc,config.date"));
		
				psmt.setTimestamp(1, tm );

				psmt.execute();
		
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;


    }
	
	/**
	 * ハッシュ関数削除
	 * 
	 * forest_server からしていされたIDのレコードを削除
	 * @param id	クラス名
	 * @return	true:成功.false:失敗
	 */
	public boolean delHash(String id) {

		boolean ret = true;
		String connectUrl = "";


		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try {
				connectUrl = ((Jdbc3Connection) con).getURL();
	
				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.hash"));
	
				smt.setString(1, id);
	
				smt.execute();
				smt.close();
	

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}
	/**
	 * ハッシュ関数削除
	 * 
	 * forest_server からしていされたIDのレコードを削除
	 * @param id	クラス名
	 * @return	true:成功.false:失敗
	 */
	public boolean delConfig(String id) {

		boolean ret = true;
		String connectUrl = "";


		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try {
				connectUrl = ((Jdbc3Connection) con).getURL();
	
				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.config"));
	
				smt.setString(1, id);
	
				smt.execute();
				smt.close();
	

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}

	/**
	 *　サーバDBリンク情報の削除
	 *
	 * 指定されたデータベース名、サーバIDをforest_servdbより削除する
	 *  
	 * @param dbName	データベース名
	 * @param serverId	サーバID
	 * @return	true:成功.false:失敗
	 */
	public boolean delServDb(String dbName, int serverId) {

		boolean ret = true;
		String connectUrl = "";


		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {

			Connection con = (Connection) iter.next();

			try {
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.servdb"));

				smt.setString(1, dbName);
				smt.setInt(2, serverId);
				smt.execute();

				smt.close();

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}

	/**
	 * サーバインスタンス登録
	 * 
	 * 指定されたホスト名、ポート番号をforest_serverへ追加する。
	 * サーバIDは既存のID最大値+1
	 * 
	 * @param host	ホスト名
	 * @param port	ポート番号
	 * @return	true:成功.false:失敗
	 */
	public boolean addServer(String host, String port) {


		boolean ret = true;
		String connectUrl = "";

		//--------------
		// serverURL生成
		//--------------
		String serverUrl = makeUrl(host, port, "");


		//--------------
		// 次のサーバID取得
		//--------------
		int nextServerId = 0;

		Connection conSelect = getSelectConnectoin();
		try{
			connectUrl = ((Jdbc3Connection) conSelect).getURL();

			Statement smt = conSelect.createStatement();

			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.server.maxserverid"));

			rs.next();
			if (rs.getInt("COUNT") > 0) {
				nextServerId = rs.getInt("MAX") + 1;
			}


			smt.close();


		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			return false;
		}



		//--------------
		// サーバ情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.server"));
		
				psmt.setInt(1, nextServerId);
				psmt.setString(2, serverUrl.toString());
				psmt.setInt(3, SERVER_RUNNING);
				psmt.execute();
		
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}


		return ret;

	}

	/**
	 *　サーバDBリンク情報の登録
	 * 指定されたデータベース名、サーバIDをforest_servdbへ登録する
	 * 
	 * @param dbName	データベース名
	 * @param serverIdList	サーバIDのリスト
	 * @param serverIdList	サーバIDのリスト
	 * @return	true:成功.false:失敗
	 */
	public boolean addServDb(String dbName, Integer[] serverIdList) {


		boolean ret = true;
		String connectUrl = "";


		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {

			Connection con = (Connection) iter.next();
			try{
				connectUrl = ((Jdbc3Connection) con).getURL();
	
	
				PreparedStatement pSelectSmt =
					con.prepareStatement(
						m_sqlResource.getString("select.gsc.servdb.maxdbno"));
	
				PreparedStatement pInsertSmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.servdb"));
	
				for (int i = 0; i < serverIdList.length; i++) {
	
					
					if (serverIdList[i] == null) {
						continue;
					}
					//--------------
					// 次のDBNO取得
					//--------------
					pSelectSmt.setString(1, dbName);
					ResultSet rs = pSelectSmt.executeQuery();
					int nextDbNo = 0;
					rs.next();
					if (rs.getInt("COUNT") > 0) {
						nextDbNo = rs.getInt("MAX") + 1;
					}
					rs.close();
	
					//--------------
					// サーバ情報更新
					//--------------
					pInsertSmt.setInt(1, serverIdList[i].intValue());
					pInsertSmt.setString(2, dbName);
					pInsertSmt.setInt(3, nextDbNo);
					pInsertSmt.execute();
	
				}
	
				pSelectSmt.close();
				pInsertSmt.close();
	
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}
		}

		return ret;

	}

	/**
	 * パーティション化テーブル情報設定
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、パーティション情報に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード挿入）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * パーティション属性情報の更新（forest_partatrへレコード挿入）
	 * </pre>
	 * @param dbName	データベース名
	 * @param tableInfo	パーティションテーブル情報
	 * @return
	 */
	public boolean setPartition(String dbName, TableInfo tableInfo, int partCount, String newHashName) {
		String connectUrl = "";
		
		String tableName = tableInfo.getName();

		//サーバ情報
		ArrayList serverList = tableInfo.getServer();

		//サーバ数取得
		int serverCount = serverList.size();
		
		//カラム情報
		ArrayList columnList = tableInfo.getColumn();

		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				//--------------
				// テーブル分割詳細情報の更新
				//--------------
				
				//forest_tablepartdtlを削除
				PreparedStatement psmt = 
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.tablepartdtl"));
				psmt.setString(1, dbName);
				psmt.setString(2, tableName);
				psmt.execute();
				
				//forest_tablepartdtlに追加
				for (Iterator iterator = serverList.iterator();
					iterator.hasNext();
					) {
	
					ServerInfo svrPartInfo =
						(ServerInfo) iterator.next();

					for (int partNo = 0; partNo < partCount; partNo++) {
						//優先順取得
						int priority = getDbNo(svrPartInfo.getId(), dbName);
						priority = priority - partNo;
						if (priority < 0){
							priority = serverCount + priority;
						}
						psmt = con.prepareStatement(
							m_sqlResource.getString("insert.gsc.tablepartdtl.partition"));
						psmt.setInt(1, getDbNo(svrPartInfo.getId(), dbName));
						psmt.setString(2, dbName);
						psmt.setString(3, tableName);
						psmt.setInt(4, partNo);
						psmt.setInt(5, priority);
						psmt.execute();
					}
				}
				
				//--------------
				// テーブル分割情報の更新
				//--------------
				//パーティション数を更新
				psmt =
					con.prepareStatement(
						m_sqlResource.getString("update.gsc.tablepart"));
	
				psmt.setInt(1, partCount);
				psmt.setInt(2, tableInfo.getPartType());
				psmt.setString(3, newHashName);
				psmt.setString(4, dbName);
				psmt.setString(5, tableName);
				psmt.execute();
	
				//--------------
				// パーティション属性情報の更新
				//--------------
				//パーティション属性情報を挿入
				psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.partatr"));
	
				for (Iterator iterator = columnList.iterator();
					iterator.hasNext();
					) {
	
					ColumnInfo columnInfo = (ColumnInfo) iterator.next();
	
					if (columnInfo.isPartition()) {
						psmt.setString(1, dbName);
						psmt.setString(2, tableName);
						psmt.setString(3, columnInfo.getName());
						psmt.setInt(4, columnInfo.getNumber());
						psmt.setString(5, columnInfo.getType());
						psmt.execute();
					}
				}
	
				psmt.close();

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				return false;
			}


		}

		return true;


	}
	/**
	 * パーティション化テーブル情報設定
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、パーティション情報に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード挿入）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * パーティション属性情報の更新（forest_partatrへレコード挿入）
	 * </pre>
	 * @param dbName	データベース名
	 * @param tableInfo	パーティションテーブル情報
	 * @return
	 */
	public boolean setPartition2(String dbName, TableInfo tableInfo, int partCount, String newHashName) {
		String connectUrl = "";
		
		String tableName = tableInfo.getName();
	
		//サーバ情報
		ArrayList serverList = tableInfo.getServer();
	
		//サーバ数取得
		int serverCount = serverList.size();
		
		//カラム情報
		ArrayList columnList = tableInfo.getColumn();
	
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();
	
			try{
				connectUrl = ((Jdbc3Connection) con).getURL();
	
				//--------------
				// テーブル分割詳細情報の更新
				//--------------
				
				//forest_tablepartdtlを削除
				PreparedStatement psmt = 
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.tablepartdtl"));
				psmt.setString(1, dbName);
				psmt.setString(2, tableName);
				psmt.execute();
				
				int[] priorityList = new int[partCount];
				for (int i = 0; i < priorityList.length; i++) {
					priorityList[i] = 0;
					
				}
				
				
				//forest_tablepartdtlに追加
				for (Iterator iterator = serverList.iterator();
					iterator.hasNext();
					) {
	
					
					ServerPartition2Info svrPartInfo =
						(ServerPartition2Info) iterator.next();

					for (int partNo = 0; partNo < partCount; partNo++) {
						
						if( svrPartInfo.getMakeInstance(partNo).booleanValue() == false ){
							continue;
						}

						int priority = priorityList[partNo]++;
						
						psmt = con.prepareStatement(
							m_sqlResource.getString("insert.gsc.tablepartdtl.partition"));
						psmt.setInt(1, getDbNo(svrPartInfo.getId(), dbName));
						psmt.setString(2, dbName);
						psmt.setString(3, tableName);
						psmt.setInt(4, partNo);
						psmt.setInt(5, priority);
						psmt.execute();
					}
				
					
				}
				
				//--------------
				// テーブル分割情報の更新
				//--------------
				//パーティション数を更新
				psmt =
					con.prepareStatement(
						m_sqlResource.getString("update.gsc.tablepart"));
	
				psmt.setInt(1, partCount);
				psmt.setInt(2, tableInfo.getPartType());
				psmt.setString(3, newHashName);
				psmt.setString(4, dbName);
				psmt.setString(5, tableName);
				psmt.execute();
	
				//--------------
				// パーティション属性情報の更新
				//--------------
				//パーティション属性情報を挿入
				psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.partatr"));
	
				for (Iterator iterator = columnList.iterator();
					iterator.hasNext();
					) {
	
					ColumnInfo columnInfo = (ColumnInfo) iterator.next();
	
					if (columnInfo.isPartition()) {
						psmt.setString(1, dbName);
						psmt.setString(2, tableName);
						psmt.setString(3, columnInfo.getName());
						psmt.setInt(4, columnInfo.getNumber());
						psmt.setString(5, columnInfo.getType());
						psmt.execute();
					}
				}
	
				psmt.close();
	
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				return false;
			}
	
	
		}
	
		return true;
	
	
	}

	/**
	 * パーティション化テーブル情報設定解除
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、パーティション情報に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード削除）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * パーティション属性情報の更新（forest_partatrへレコード削除）
	 * </pre>
	 * @param dbName	データベース名
	 * @param tableName	パーティションテーブル名
	 * @param serverList	サーバ情報リスト
	 * @return
	 */
	public boolean releasePartition(String dbName, String tableName, ArrayList serverList) {
		boolean ret = true;
		String connectUrl = "";

		//サーバ情報
		int serverCount = serverList.size();
		
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try {
				connectUrl = ((Jdbc3Connection) con).getURL();

				//--------------
				//テーブル分割詳細情報の更新
				//--------------
				
				//forest_tablepartdtlを削除
				PreparedStatement psmt = 
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.tablepartdtl"));
				psmt.setString(1, dbName);
				psmt.setString(2, tableName);
				psmt.execute();
				
				//forest_tablepartdtlに追加			
				for (Iterator iterator = serverList.iterator();
					iterator.hasNext();
					) {
	
					ServerInfo svrInfo =
						(ServerInfo) iterator.next();

					//優先順取得
					psmt = con.prepareStatement(
						m_sqlResource.getString("insert.gsc.tablepartdtl.partition"));
					psmt.setInt(1, getDbNo(svrInfo.getId(),dbName));
					psmt.setString(2, dbName);
					psmt.setString(3, tableName);
					psmt.setInt(4, 0);
					psmt.setInt(5, 0);
					psmt.execute();
				}
				
				//--------------
				//テーブル分割情報の更新
				//--------------
				psmt =
					con.prepareStatement(
						m_sqlResource.getString("update.gsc.tablepart"));
				
				psmt.setInt(1, 1);
				psmt.setInt(2, TableInfo.TYPE_MULTI);
				psmt.setString(3, null);
				psmt.setString(4, dbName);
				psmt.setString(5, tableName);
				psmt.execute();
				
				//--------------
				//パーティション属性情報の更新
				//--------------
				psmt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.partatr"));

				psmt.setString(1, dbName);
				psmt.setString(2, tableName);
				psmt.execute();

				psmt.close();

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

	
		return ret;
	}
	
	/**
	 * パーティション化テーブル情報設定
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、パーティション情報に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード挿入）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * パーティション属性情報の更新（forest_partatrへレコード挿入）
	 * </pre>
	 * @param dbName	データベース名
	 * @param tableInfo	パーティションテーブル情報
	 * @return
	 * @since 2.0
	 */
	public boolean rePartition(String dbName, TableInfo tableInfo, int partCount) {
		String connectUrl = "";
		
		//テーブル名取得
		String tableName = tableInfo.getName();

		//サーバ情報取得
		ArrayList serverList;
		try{
			serverList = getServerList(dbName);
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			return false;
		}
		
		//サーバインスタンス数取得
		int serverCount = serverList.size();
		
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				//--------------
				// テーブル分割詳細情報の更新
				//--------------
				//パーティションNoを設定		
				PreparedStatement psmt = 
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.tablepartdtl"));
				psmt.setString(1, dbName);
				psmt.setString(2, tableName);
				psmt.execute();

				for (Iterator iterator = serverList.iterator();
					iterator.hasNext();
					) {
	
					ServerInfo serverInfo =
						(ServerInfo) iterator.next();

					for (int partNo = 0; partNo < partCount; partNo++) {
						//優先順取得
						int priority = getDbNo(serverInfo.getId(), dbName);
						priority = priority - partNo;
						if (priority < 0){
							priority = serverCount + priority;
						}
						psmt = con.prepareStatement(
							m_sqlResource.getString("insert.gsc.tablepartdtl.partition"));
						psmt.setInt(1, getDbNo(serverInfo.getId(), dbName));
						psmt.setString(2, dbName);
						psmt.setString(3, tableName);
						psmt.setInt(4, partNo);
						psmt.setInt(5, priority);
						psmt.execute();
					}
				}
				
				//--------------
				// テーブル分割情報の更新
				//--------------
				//パーティション数を更新
				psmt =
					con.prepareStatement(
						m_sqlResource.getString("update.gsc.tablepart"));
	
				psmt.setInt(1, partCount);
				psmt.setInt(2, TableInfo.TYPE_PARTITION);
				psmt.setString(3, tableInfo.getHashName());
				psmt.setString(4, dbName);
				psmt.setString(5, tableName);
				psmt.execute();
	
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				return false;
			}
		}

		return true;
	}

	/**
	 * 多重化テーブル情報設定
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、テーブル名に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード挿入）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * </pre>
	 * @param dbName	データベース名
	 * @param tableInfo	パーティションテーブル情報
	 * @return
	 */
	public boolean addTable(String dbName, String tableName) {

		boolean ret = true;
		String connectUrl = "";

		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				//--------------
				//テーブル分割情報
				//--------------
				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.tablepart"));
	
				smt.setString(1, dbName);
				smt.setString(2, tableName);
				smt.execute();
	
				//--------------
				//テーブル分割詳細情報
				//--------------
				smt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.tablepartdtl"));
	
				smt.setString(1, tableName);
				smt.setString(2, dbName);
				smt.execute();
	
				smt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}
		return ret;

	}

	/**
	 * 多重化テーブル情報設定解除
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、テーブル名に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード削除）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * </pre>
	 * @param dbName	データベース名
	 * @param tableName	パーティションテーブル名
	 * @return
	 */
	public boolean delTable(String dbName, String tableName) {

		boolean ret = true;
		String connectUrl = "";

		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				//--------------
				//テーブル分割詳細情報
				//--------------
				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.tablepartdtl"));
	
				smt.setString(1, dbName);
				smt.setString(2, tableName);
				smt.execute();
	
				//--------------
				//テーブル分割情報
				//--------------
				smt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.tablepart"));
	
				smt.setString(1, dbName);
				smt.setString(2, tableName);
				smt.execute();
	
				smt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}
	
		}
		return ret;

	}
	/**
	 * サーバー情報取得
	 * @return
	 * @throws SQLException
	 */
	public ArrayList getServerList() throws SQLException {

		ArrayList servers = new ArrayList();
		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			Statement smt = con.createStatement();
	
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.server.status"));
	
			while (rs.next()) {
				ServerInfo srvInfo = new ServerInfo();
				srvInfo.setId(rs.getInt("SERVERID"));
				srvInfo.setStatus(rs.getInt("STATUS"));
				srvInfo.setChangeStatus(rs.getInt("STATUS"));
	
				Properties info = GSCdata.parseURL(rs.getString("URL"));
				srvInfo.setHost((String) info.getProperty("PGHOST",""));
				srvInfo.setPort((String) info.getProperty("PGPORT",""));
	
				srvInfo.setId(rs.getInt("SERVERID"));
	
				servers.add(srvInfo);
	
			}
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}

		return servers;
	}
	/**
	 * サーバー情報取得
	 * @return
	 * @throws SQLException
	 */
	public ArrayList getHashList() throws SQLException {
	
		ArrayList servers = new ArrayList();
		String connectUrl = "";
	
		Connection con =getSelectConnectoin(); 
	
		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			Statement smt = con.createStatement();
	
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.hash"));
	
			while (rs.next()) {
	
				servers.add(new HashInfo(rs.getString("NAME"),rs.getString("DESCRIPTION")));
	
			}
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}
	
		return servers;
	}
	/**
	 * ハッシュ関数クラスイメージ取得
	 * @return
	 * @throws SQLException
	 */
	public byte[] getHashImage(String hashName) throws SQLException {
	
		byte[] classImage = null;

		String connectUrl = "";
	
		Connection con =getSelectConnectoin(); 
	
		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			PreparedStatement psmt =
				con.prepareStatement(
					m_sqlResource.getString("select.gsc.hash.image"));

			psmt.setString(1, hashName);

			ResultSet rs = psmt.executeQuery();
			
			if (rs.next()) {
				classImage = rs.getBytes("CLASS");

			}
			
			psmt.close();

			return classImage;

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}
	
	}

	/**
	 * サーバー情報取得
	 * @return
	 * @throws SQLException
	 */
	public ArrayList getConfigList() throws SQLException {
	
		ArrayList configList = new ArrayList();
		String connectUrl = "";
	
		Connection con =getSelectConnectoin(); 
	
		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			Statement smt = con.createStatement();
	
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.config"));
	
			while (rs.next()) {
				ConfigInfo configInfo = new ConfigInfo();
				configInfo.setConfigId(rs.getString("CONFIGID"));
				configInfo.setDescription(rs.getString("DESCRIPTION"));
				configInfo.setUpdateDate(new Date(rs.getTimestamp("UPDATE_DATE").getTime()));
				
			    // cache_reflesh | retry_count | defect_timeout | distributed_connection | pertition_mode | syncronize_mode |       update_date			
				//MASUCOMMENT config値を全て取得する
				configInfo.setCacheReflesh(rs.getLong("CACHE_REFLESH"));
				configInfo.setRetryCount(rs.getLong("RETRY_COUNT"));
				configInfo.setDefectTimeout(rs.getLong("DEFECT_TIMEOUT"));
				configInfo.setDistributedCon(rs.getInt("DISTRIBUTED_CONNECTION"));
				configInfo.setPertitionMode(rs.getBoolean("PERTITION_MODE"));
				configInfo.setSyncMode(rs.getBoolean("SYNCRONIZE_MODE"));
				
				configList.add(configInfo);
	
				
			}
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}
	
		return configList;
	}
	//MASUCOMMENT BrokenLogでの追加メソッド
	/**
	 * Broken_Log情報取得
	 * @return
	 * @throws SQLException
	 * @auther tm364458
	 */
	public ArrayList getBrokenLogList() throws SQLException {
	
		ArrayList brokenLogList = new ArrayList();
		String connectUrl = "";
	
		Connection con = getSelectConnectoin(); 
	
		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			Statement smt = con.createStatement();
	
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.broken_log"));
	
			while (rs.next()) {
				BrokenLogInfo brokenLogInfo = new BrokenLogInfo();
				brokenLogInfo.setServerid(rs.getInt("serverid"));
				brokenLogInfo.setDatetime(new Date(rs.getTimestamp("datetime").getTime()));
				brokenLogInfo.setClient(rs.getString("client"));
				brokenLogInfo.setMsg(rs.getString("msg"));
				brokenLogInfo.setStatus(rs.getString("status"));
				brokenLogInfo.setQuery(rs.getString("query"));
				brokenLogInfo.setServerUrl(rs.getString("url"));
				
				brokenLogList.add(brokenLogInfo);	
			}
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}
	
		return brokenLogList;
	}
	/**
	 * コンフィグ情報取得
	 * @return
	 * @throws SQLException
	 */
	public ConfigInfo getConfigInfo(String id) throws SQLException {
	
		ConfigInfo configInfo = new ConfigInfo();

		String connectUrl = "";
	
		Connection con =getSelectConnectoin(); 
	
		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			PreparedStatement psmt =
				con.prepareStatement(
					m_sqlResource.getString("select.gsc.config.detail"));

			psmt.setString(1, id);

			ResultSet rs = psmt.executeQuery();
			
			if (rs.next()) {
				configInfo.setConfigId(rs.getString("CONFIGID"));
				configInfo.setDescription(rs.getString("DESCRIPTION"));

				configInfo.setCacheReflesh(rs.getInt("CACHE_REFLESH"));
				configInfo.setDefectTimeout(rs.getInt("DEFECT_TIMEOUT"));
				configInfo.setDistributedCon(rs.getInt("DISTRIBUTED_CONNECTION"));
				configInfo.setRetryCount(rs.getInt("RETRY_COUNT"));

				configInfo.setPertitionMode(rs.getBoolean("PERTITION_MODE"));
				configInfo.setSyncMode(rs.getBoolean("SYNCRONIZE_MODE"));

			}
			
			psmt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}
	
		return configInfo;
	}
	/**
	 * BrokenLog情報取得
	 * @return
	 * @throws SQLException
	 * 
	 * 
	 */
	public BrokenLogInfo getBrokenLogInfo(String serverid) throws SQLException {
	
		BrokenLogInfo brokenLogInfo = new BrokenLogInfo();

		String connectUrl = "";
	
		Connection con =getSelectConnectoin(); 
	
		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			PreparedStatement psmt =
				con.prepareStatement(
					m_sqlResource.getString("select.gsc.brokenlog.detail"));

			psmt.setString(1, serverid);

			ResultSet rs = psmt.executeQuery();
			
			if (rs.next()) {
				brokenLogInfo.setServerid(rs.getInt("SERVERID"));
				brokenLogInfo.setDatetime(new Date(rs.getTimestamp("DATETIME").getTime()));
				brokenLogInfo.setClient(rs.getString("CLIENT"));
				brokenLogInfo.setMsg(rs.getString("MSG"));
				brokenLogInfo.setStatus(rs.getString("STATUS"));
				brokenLogInfo.setQuery(rs.getString("QUERY"));
				brokenLogInfo.setServerUrl(rs.getString("URL"));
			}
			
			psmt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}
	
		return brokenLogInfo;
	}

	/**
	 * サーバー情報取得
	 * 
	 * 指定されたサーバIDでサーバ情報を取得する
	 * 
	 * @param ServerId	サーバID
	 * @return	サーバ情報リスト
	 * @throws SQLException
	 */
	public ArrayList getServerList(Integer[] ServerId) throws SQLException {

		String connectUrl = "";
		ArrayList servers = new ArrayList();

		Connection con =getSelectConnectoin(); 

		try {
			connectUrl = ((Jdbc3Connection) con).getURL();

			PreparedStatement smt =	con.prepareStatement(m_sqlResource.getString("select.gsc.server"));

			for (int i = 0; i < ServerId.length; i++) {

				if (ServerId[i] == null){
					continue;
				}

				smt.setInt(1, ServerId[i].intValue());
				ResultSet rs = smt.executeQuery();

				rs.next();
				ServerInfo srvInfo = new ServerInfo();
				srvInfo.setId(rs.getInt("SERVERID"));
				srvInfo.setStatus(rs.getInt("STATUS"));

				Properties info = GSCdata.parseURL(rs.getString("URL"));
				srvInfo.setHost((String) info.get("PGHOST"));
				srvInfo.setPort((String) info.get("PGPORT"));

				srvInfo.setId(rs.getInt("SERVERID"));

				servers.add(srvInfo);

			}
			smt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}

		return servers;
	}

	/**
	 * 
	 * サーバー情報取得
	 * 
	 * 指定されたDBに関連付けられたサーバ情報を取得する
	 * 
	 * @param dbName	データベース名
	 * @return	サーバ情報リスト
	 * @throws SQLException
	 */
	public ArrayList getServerList(String dbName) throws SQLException {

		ArrayList servers = new ArrayList();
		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();

			PreparedStatement smt = con.prepareStatement(m_sqlResource.getString("select.gsc.server.bydbname"));

			smt.setString(1, dbName);
			ResultSet rs = smt.executeQuery();

			while (rs.next()) {
				ServerInfo srvInfo = new ServerInfo();
				srvInfo.setId(rs.getInt("SERVERID"));
				srvInfo.setStatus(rs.getInt("STATUS"));

				Properties info = GSCdata.parseURL(rs.getString("URL"));
				srvInfo.setHost((String) info.get("PGHOST"));
				srvInfo.setPort((String) info.get("PGPORT"));

				srvInfo.setId(rs.getInt("SERVERID"));

				servers.add(srvInfo);

			}

			smt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}

		return servers;
	}

	/**
	 *  DB-サーバ情報のリンク情報を生成
	 * 
	 * サーバDBリンク情報を取得して、
	 * サーバ情報リストをDB名で紐付けし
	 * データベースーサーバ　リンク情報クラスのリストを生成する
	 * 
	 * @param serverList	サーバ情報リスト
	 * @return
	 * @throws SQLException
	 * @throws Exception
	 */
	public ArrayList getDbLinkList(ArrayList serverList)
		throws SQLException {

		String connectUrl = "";

		ArrayList dbInfoList = new ArrayList();
		Connection con =getSelectConnectoin(); 

		try {
			connectUrl = ((Jdbc3Connection) con).getURL();

			Statement smt = con.createStatement();
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.servdb.dblist"));

			String dbName = "";
			DbLinkInfo dbinfo = null;

			while (rs.next()) {
				String dbNameWk = rs.getString("DBNAME");
				if (dbNameWk.compareToIgnoreCase(dbName) != 0) {
					dbName = dbNameWk;
					dbinfo = new DbLinkInfo();
					dbinfo.setName(dbName);
					dbinfo.setServer(new ArrayList());
					dbInfoList.add(dbinfo);

				}

				//--------------
				//サーバ情報と紐付け
				//--------------
				int serverId = rs.getInt("SERVERID");
				ArrayList dbServerList = dbinfo.getServer();
				for (Iterator iter = serverList.iterator(); iter.hasNext();) {
					ServerInfo serverInfo = (ServerInfo) iter.next();
					if (serverInfo.getId() == serverId) {
						ServerInfo dbServer = new ServerInfo();
						dbServer.setHost(serverInfo.getHost());
						dbServer.setPort(serverInfo.getPort());
						dbServer.setId(serverInfo.getId());
						dbServer.setStatus(serverInfo.getStatus());
						dbServer.setChangeStatus(serverInfo.getChangeStatus());
						dbServer.setChkFlag(serverInfo.isChkFlag());
						dbServerList.add(dbServer);
						break;
					}
				}

			}

			smt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}


		return dbInfoList;
	}

	/**
	 * テーブル一覧情報情報取得
	 * 
	 * 指定されたDB名のテーブル情報の一覧を生成する
	 * 
	 * @param dbName	データベース名
	 * @param serverList	サーバ情報リスト
	 * @return
	 * @throws SQLException
	 * @throws Exception
	 */
	public ArrayList getTableList(String dbName )
		throws SQLException  {

		ArrayList tableList = new ArrayList();


		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();

			PreparedStatement smt =	con.prepareStatement(m_sqlResource.getString("select.gsc.table"));

			smt.setString(1, dbName);
			ResultSet rs = smt.executeQuery();

			String tableName = "";

			TableInfo tableInfo = null;

			while (rs.next()) {
					tableInfo = new TableInfo();
					tableInfo.setName(rs.getString("TABLE_NAME"));
					tableInfo.setServer(new ArrayList());
					tableInfo.setPartCount(rs.getInt("PART_COUNT"));
					tableInfo.setPartType(rs.getInt("PART_TYPE"));
					tableInfo.setHashName(rs.getString("HASH_NAME"));
					//TODOMASU ステータス追加
					tableInfo.setStatus(rs.getInt("STATUS"));
					tableList.add(tableInfo);

			}

			smt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}


		return tableList;
	}

	/**
	 * パーティション属性情報取得
	 * 
	 *	データベース、テーブル名からそのパーティション属性情報を取得する 
	 * 
	 * @param dbName	データベース名
	 * @param tableName	テーブル名
	 * @return	パーティション属性情報のリスト
	 * @throws SQLException
	 */
	public ArrayList getPartitionColumn(String dbName, String tableName)
		throws SQLException  {

		ArrayList columnList = new ArrayList();

		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();

			PreparedStatement smt =	con.prepareStatement(m_sqlResource.getString("select.gsc.partatr"));

			smt.setString(1, dbName);
			smt.setString(2, tableName.toLowerCase());
			ResultSet rs = smt.executeQuery();

			while (rs.next()) {
				ColumnInfo columnInfo = new ColumnInfo();
				columnInfo.setName(rs.getString("COLUMN_NAME"));
				columnInfo.setNumber(rs.getInt("COLUMN_NO"));
				columnInfo.setPartition(true);
				columnInfo.setType(rs.getString("COLUMN_TYPE"));
				columnList.add(columnInfo);
			}

			smt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}


		return columnList;
	}

	/**
	 * データベース名一覧の取得
	 * @return
	 */
	public ArrayList getDbList()  {

		ArrayList dbList = new ArrayList();

		try {

			Statement smt = getSelectConnectoin().createStatement();
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.servdb.db"));

			String dbName = "";
			DbLinkInfo dbinfo = null;

			while (rs.next()) {
				dbList.add(rs.getString("DBNAME"));

			}


		} catch (SQLException e) {
		}

		return dbList;
	}

	/**
	 * パーティション数取得
	 * 
	 *	データベース、テーブル名からそのパーティション数を取得する 
	 * 
	 * @param dbName	データベース名
	 * @param tableName	テーブル名
	 * @return	パーティション数
	 * @throws SQLException
	 */
	public int getPartitionCount(
		String dbName,
		String tableName) throws SQLException {

		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		int partCount = 0;

		try {
			connectUrl = ((Jdbc3Connection) con).getURL();

			PreparedStatement smt =
			getSelectConnectoin().prepareStatement(
					m_sqlResource.getString("select.gsc.tablepart.partcount"));

			smt.setString(1, dbName);
			smt.setString(2, tableName.toLowerCase());

			ResultSet rs = smt.executeQuery();
			if (rs.next()) {
				partCount = rs.getInt("PART_COUNT");

			}

			smt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}


		return partCount;
	}

	/**
	 * グローバルシステムカタログの更新
	 * <pre>
	 * サーバの状態フラグが故障中に設定されている場合、
	 * 該当するフラグを変更する
	 * </pre>
	 * @param id
	 */
	public boolean setDBstatus(ArrayList serverList) {

		boolean ret = true;
		String connectUrl = "";
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();
			
			try {
				connectUrl = ((Jdbc3Connection) con).getURL();
				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("update.gsc.server.status"));
					
					for (Iterator iter2 = serverList.iterator(); iter2.hasNext();) {
						ServerInfo serverInfo = (ServerInfo) iter2.next();

						smt.setInt(1, serverInfo.getChangeStatus());
						smt.setInt(2, serverInfo.getId());
						smt.execute();

				}
				smt.close();


			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;
	}



	/**
	 * GSC情報取得
	 * @return
	 * @throws SQLException
	 * @since 2.0
	 */
	public ArrayList getGscList() throws SQLException {

		ArrayList servers = new ArrayList();
		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			Statement smt = con.createStatement();
	
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.gsc"));
	
			while (rs.next()) {
				GSCInfo gscInfo = new GSCInfo();
				gscInfo.setId(rs.getInt("SERVERID"));
				gscInfo.setDb(rs.getString("DBNAME"));
				Properties info = GSCdata.parseURL(rs.getString("URL"));
				gscInfo.setHost((String) info.getProperty("PGHOST",""));
				gscInfo.setPort((String) info.getProperty("PGPORT",""));
				gscInfo.setStatus(rs.getInt("STATUS"));
				servers.add(gscInfo);
			}
			
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}

		return servers;
	}

	/**
	 * GSC情報更新
	 * @return
	 * @since 2.0
	 */
	public boolean updateGscServer() {
		boolean ret = false;
		
		try{
			//GSC情報を取得	
			ArrayList gscList = getGscList();
			
			//接続先情報リストクリア
			clearServers();
		
			//GSC情報クラスにGSC情報を設定
			if (gscList != null){
				for (int i = 0; i < gscList.size(); i++) {
					GSCInfo gscinfo = (GSCInfo)gscList.get(i);
					String hostName = gscinfo.getHost();
					String portNo = gscinfo.getPort();
					String dbName = gscinfo.getDb();
					int status = gscinfo.getStatus();
					if(dbName.compareTo("") != 0){
						addUrl(hostName, portNo, dbName);
					}
				}
			}
			ret = true;
		} catch (SQLException e) {
			ret = false;
		}
		
		return ret;
	}
	
	/**
	 * GSCインスタンス登録
	 * 
	 * 指定されたDB名とサーバIDをforest_gscへ追加する。
	 * 
	 * @param dbname	DB名
	 * @param serverid	サーバID
	 * @return	true:成功.false:失敗
	 * @since 2.0
	 */
	public boolean addGscServer(int serverid, String dbname) {

		boolean ret = true;
		String connectUrl = "";

		//--------------
		// GSC情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.gsc"));
		
				psmt.setInt(1, serverid);
				psmt.setString(2, dbname);
				psmt.execute();
		
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}
	
	/**
	 * GSCインスタンス登録
	 * 
	 * 指定されたホスト名、ポート番号をforest_serverへ追加する。
	 * サーバIDは既存のID最大値+1
	 * ホスト名、サーバIDをforest_gscへ追加する。
	 * 
	 * @param host	ホスト名
	 * @param port	ポート番号
	 * @return	true:成功.false:失敗
	 * @since 2.0
	 */
	public boolean addGscServer(String dbname, String host, String port) {


		boolean ret = true;
		String connectUrl = "";

		//--------------
		// serverURL生成
		//--------------
		String serverUrl = makeUrl(host, port, "");


		//--------------
		// 次のサーバID取得
		//--------------
		int nextServerId = 0;

		Connection conSelect = getSelectConnectoin();
		try{
			connectUrl = ((Jdbc3Connection) conSelect).getURL();

			Statement smt = conSelect.createStatement();

			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString("select.gsc.server.maxserverid"));

			rs.next();
			if (rs.getInt("COUNT") > 0) {
				nextServerId = rs.getInt("MAX") + 1;
			}


			smt.close();


		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			return false;
		}



		//--------------
		// サーバ情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.server"));
		
				psmt.setInt(1, nextServerId);
				psmt.setString(2, serverUrl.toString());
				psmt.setInt(3, SERVER_RUNNING);
				psmt.execute();
		
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}
		
		//--------------
		// GSC情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString("insert.gsc.gsc"));
		
				psmt.setInt(1, nextServerId);
				psmt.setString(2, dbname);
				psmt.execute();
		
				psmt.close();
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;

	}
	
	/**
	 * GSC情報インサート用SQL取得
	 * 
	 * GSCからGSC情報を取得し、インサート用SQLを取得する。
	 * 
	 * @return	ArrayList:インサート用SQLリスト
	 * @throws SQLException
	 * @since 2.0
	 */
	public ArrayList getGscInsertSql() throws SQLException {
		
		ArrayList sqlList = new ArrayList();

		try{

			//--------------------------------------
			// forest_hashテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
								   "select.gsc.hash.all", 
								   "insert.gsc.hash.copy");

			//--------------------------------------
			// forest_configテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
								   "select.gsc.config.all", 
								   "insert.gsc.config.copy");

			//--------------------------------------
			// forest_serverテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
                                   "select.gsc.server.all", 
                                   "insert.gsc.server.copy");
			
			//--------------------------------------
			// forest_servdbテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
								   "select.gsc.servdb.all", 
								   "insert.gsc.servdb.copy");
			
			//--------------------------------------
			// forest_tablepartテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
								   "select.gsc.tablepart.all", 
								   "insert.gsc.tablepart.copy");
								   
			//--------------------------------------
			// forest_tablepartdtlテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
								   "select.gsc.tablepartdtl.all", 
								   "insert.gsc.tablepartdtl.copy");
			
			//--------------------------------------
			// forest_partatrテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
								   "select.gsc.partatr.all", 
								   "insert.gsc.partatr.copy");
			
			//--------------------------------------
			// forest_gscテーブルのインサートSQL作成
			//--------------------------------------
			sqlList = getInsertSql(sqlList, 
								   "select.gsc.gsc.all", 
								   "insert.gsc.gsc.copy");

			
			
		} catch (SQLException e) {
			throw e;
		}

		return sqlList;
	}

	/**
	 * インサート用SQL取得
	 * 
	 * 検索用SQLの結果を元に、インサート用SQLを取得する。
	 * 
	 * @param sqlList		インサート用SQLリスト
	 * @param sqlSelect	検索用SQL
	 * @param sqlInsert	INSERT用SQL
	 * @return	ArrayList:インサート用SQLリスト
	 * @throws SQLException
	 * @since 2.0
	 */
	public ArrayList getInsertSql(ArrayList sqlList,
	                               String sqlSelect,
	                               String sqlInsert) throws SQLException {

		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
			Statement smt = con.createStatement();
	
			//--------------------------------------
			// テーブルのインサートSQL作成
			//--------------------------------------
			ResultSet rs =
				smt.executeQuery(
					m_sqlResource.getString(sqlSelect));

			ResultSetMetaData md = rs.getMetaData();
			int colCount = md.getColumnCount();
			
			while (rs.next()) {
				PreparedStatement psmt =
					con.prepareStatement(
						m_sqlResource.getString(sqlInsert));
		
				for (int i = 1; i <= colCount; i++) {
					psmt.setObject(i, rs.getObject(i));
				}
				String sql = psmt.toString();
				sqlList.add(sql);
			}
			rs.close();
			
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}

		return sqlList;
	}

	/**
	 * GSC情報インサート用SQL実行
	 * 
	 * GSC情報インサート用SQLを実行する。
	 * 
	 * @param sqlList	インサート用SQLリスト
	 * @return	true:成功.false:失敗
	 * @since 2.0
	 */
	public boolean setGscInsertSql(ArrayList sqlList) {
		boolean ret = true;
		String connectUrl = "";

		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();
	
			//--------------------------------------
			// GSC情報インサート用SQL実行
			//--------------------------------------
			for (Iterator iter = sqlList.iterator(); iter.hasNext();) {
				String sql = (String)iter.next();
				PreparedStatement smt =
					con.prepareStatement(sql);
				smt.execute();
				smt.close();
			}
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			ret = false;
		}

		return ret;
	}
	
	/**
	 * GSCインスタンス削除
	 * 
	 * forest_server から指定されたIDのレコードを削除
	 * forest_gsc から指定されたIDとDB名のレコードを削除
	 * 
	 * @param id	サーバID
	 * @param dbName	DB名
	 * @return	true:成功.false:失敗
	 * @since 2.0
	 */
	public boolean delGscServer(int id, String dbName) {

		boolean ret = true;
		String connectUrl = "";

		//--------------
		// GSC情報更新
		//--------------
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try {
				connectUrl = ((Jdbc3Connection) con).getURL();
	
				PreparedStatement smt =
					con.prepareStatement(
						m_sqlResource.getString("delete.gsc.gsc"));
	
				smt.setInt(1, id);
				smt.setString(2, dbName);
	
				smt.execute();
				smt.close();
	

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}
		
		return ret;
	}
	
	/**
	 * 優先順一覧情報情報取得
	 * 
	 * 指定されたテーブル名の優先順一覧を生成する
	 * 
	 * @param dbName		データベース名
	 * @param tableName	テーブル名
	 * @param serverList	サーバ情報リスト
	 * @return
	 * @throws SQLException
	 * @throws Exception
	 * @since 2.0
	 */
	public ArrayList getPriorityList(String dbName, String tableName, ArrayList serverList)
		throws SQLException  {

		String connectUrl = "";
		
		//パーティション数の取得
		int partCount = getPartitionCount(dbName, tableName);
		
		ArrayList priorityList = new ArrayList();
		
		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();

			for (Iterator iter = serverList.iterator(); iter.hasNext();) {
				ServerInfo serverInfo = (ServerInfo) iter.next();
				int serverId = serverInfo.getId();
				
				ServerPriorityInfo serverPriorityInfo = new ServerPriorityInfo();
				serverPriorityInfo.setId(serverInfo.getId());
				serverPriorityInfo.setHost(serverInfo.getHost());
				serverPriorityInfo.setPort(serverInfo.getPort());
				serverPriorityInfo.setStatus(serverInfo.getStatus());
				serverPriorityInfo.setChangeStatus(serverInfo.getChangeStatus());
				
				PreparedStatement smt =	
					con.prepareStatement(m_sqlResource.getString("select.gsc.priority"));
				smt.setInt(1, serverId);
				smt.setString(2, dbName);
				smt.setString(3, tableName);
				ResultSet rs = smt.executeQuery();
				
				//TODOMASU PriorityInfo beanにテーブルスペース情報を追加する
				//TODOMASU まずは、該当DBに接続
				
				DbBase dbBase = new DbBase(m_prop.getProperty("user"), m_prop.getProperty("password"));
				dbBase.addUrl(serverPriorityInfo.getHost(), serverInfo.getPort(), dbName );
				dbBase.connect(false);
				Connection targetDBCon = dbBase.getSelectConnectoin();
				PreparedStatement targetDBsmt =	
					targetDBCon.prepareStatement(m_sqlResource.getString("select.tablespace"));
				
				
				int i = 0;
				while (rs.next()) {
					PriorityInfo priorityInfo = new PriorityInfo();
					priorityInfo.setPartitionNo(rs.getInt("PART_NO"));
					priorityInfo.setPriority(new Integer(rs.getInt("PRIORITY")));
					targetDBsmt.setString(1, tableName + "_" + m_dcFmt.format(priorityInfo.getPartitionNo().intValue()));
					targetDBsmt.execute();
					ResultSet targetDBrs = targetDBsmt.getResultSet();
					String tblSpaceName = null;
					if(targetDBrs.next()){
						tblSpaceName = targetDBrs.getString("TABLESPACE");
					}
					if(tblSpaceName == null){
						tblSpaceName = "";
					}
					priorityInfo.setTableSpaceName(tblSpaceName);
					serverPriorityInfo.addPartition(priorityInfo);
					targetDBrs.close();
					i++;
				}
				priorityList.add(serverPriorityInfo);
				rs.close();
				smt.close();
				targetDBsmt.close();
				dbBase.close();
				
			}
		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
			throw e;
		}
		return priorityList;
	}
	
	/**
	 * 優先順情報設定
	 * 
	 * <pre>
	 * 指定されたDBのテーブルに対して、優先順情報に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード挿入）
	 * </pre>
	 * @param dbName	データベース名
	 * @param tableName	テーブル名
	 * @param serverList	サーバ情報リスト
	 * @return
	 */
	public boolean setPriority(String dbName, String tableName, ArrayList serverList) {
		String connectUrl = "";
		
		int serverCount = serverList.size();

		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				//--------------
				// テーブル分割詳細情報の更新
				//--------------
				//優先順を設定		
				for (Iterator iterator = serverList.iterator(); iterator.hasNext();) {
					ServerPriorityInfo svrPriorityInfo =
						(ServerPriorityInfo) iterator.next();
					ArrayList priorityList = svrPriorityInfo.getPartition();
					for (int i = 0; i < priorityList.size(); i++) {
						PriorityInfo priorityInfo =	(PriorityInfo)priorityList.get(i);
						
						PreparedStatement psmt = 
							con.prepareStatement(
								m_sqlResource.getString("update.gsc.tablepartdtl.partition"));
						psmt.setInt(1, priorityInfo.getPriority().intValue());
						psmt.setInt(2, priorityInfo.getPartitionNo().intValue());
						psmt.setString(3, dbName);
						psmt.setString(4, tableName);
						psmt.setString(5, dbName);
						psmt.setInt(6, svrPriorityInfo.getId());
						psmt.execute();
						psmt.close();
					}
				}
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				return false;
			}
		}
		return true;
	}

	/**
	 * テーブル情報(DB追加)設定
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、テーブル情報に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード挿入）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * </pre>
	 * @param dbName		データベース名
	 * @param serverIdList	サーバIDリスト
	 * @return
	 * @since 2.0
	 */
	public boolean setDbAdd(String dbName, Integer[] serverIdList) {
		String connectUrl = "";
		
		ArrayList tableList;
		try{
			//テーブル情報
			tableList = getTableList(dbName);
		} catch (SQLException e) {
			return false;
		} catch (Exception e) {
			return false;
		}
		
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				//--------------
				// テーブル分割詳細情報の更新
				//--------------
				for (Iterator iterator = tableList.iterator(); iterator.hasNext();) {
					TableInfo tableInfo = (TableInfo) iterator.next();
					String tableName = tableInfo.getName();
					for (int i = 0; i < serverIdList.length; i++) {
						if (serverIdList[i] == null) {
							continue;
						}
						
						//--------------
						// 次のパーティションNo(優先順)取得
						//--------------
						if (tableInfo.getPartType() == 0) {	//多重化テーブル
							//--------------
							// テーブル分割詳細情報へ追加
							//--------------
							PreparedStatement smt = 
								con.prepareStatement(
									m_sqlResource.getString("insert.gsc.tablepartdtl.partition"));			
							////smt.setInt(1, serverIdList[i].intValue());
							smt.setInt(1, getDbNo(serverIdList[i].intValue(), dbName));
							smt.setString(2, dbName);
							smt.setString(3, tableName);
							smt.setInt(4, 0);
							smt.setInt(5, 0);
							smt.execute();
							smt.close();
						}
						else if (tableInfo.getPartType() == 1) {	//パーティション化テーブル
							for (int partNo = 0; partNo < tableInfo.getPartCount(); partNo++) {
								int nextPriority = 0;
								
								PreparedStatement smt =
									con.prepareStatement(
										m_sqlResource.getString("select.gsc.tablepartdtl.max"));
			
								smt.setString(1, dbName);
								smt.setString(2, tableName);
								smt.setInt(3, partNo);
								ResultSet rs = smt.executeQuery();
								rs.next();
								if (rs.getInt("COUNT") > 0) {
									nextPriority = rs.getInt("MAX") + 1;
								}
								smt.close();
								rs.close();
								
								//--------------
								// テーブル分割詳細情報へ追加
								//--------------
								smt = con.prepareStatement(
									m_sqlResource.getString("insert.gsc.tablepartdtl.partition"));
								////								smt.setInt(1, serverIdList[i].intValue());
								smt.setInt(1, getDbNo(serverIdList[i].intValue(), dbName));
								smt.setString(2, dbName);
								smt.setString(3, tableName);
								smt.setInt(4, partNo);
								smt.setInt(5, nextPriority);
								smt.execute();
								smt.close();
							}
						}
					}
				}
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				return false;
			}
		}
		return true;
	}
	
	/**
	 * テーブル情報(DB移行)設定
	 * 
	 * <pre>
	 * 指定されたDBの情報に対して、テーブル情報に基づいて以下の処理を行う。
	 * テーブル分割詳細情報の更新（forest_tablepartdtlへレコード挿入）
	 * テーブル分割情報の更新（forest_tablepartの更新）
	 * </pre>
	 * @param dbName		データベース名
	 * @param tableList	テーブル情報リスト
	 * @param serverList	サーバ情報リスト
	 * @return
	 * @since 2.0
	 */
	public boolean setDbShift(String dbName, ArrayList tableList, ArrayList serverList) {
		String connectUrl = "";
		
		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try{
				connectUrl = ((Jdbc3Connection) con).getURL();

				for (int i = 0; i < tableList.size() ; i++) {
					String tableName = (String) tableList.get(i);
					
					//--------------
					// テーブル分割情報へ追加
					//--------------
					//パーティション数を更新
					PreparedStatement smt =
						con.prepareStatement(
							m_sqlResource.getString("insert.gsc.tablepart"));
					smt.setString(1, dbName);
					smt.setString(2, tableName);
					smt.execute();
					smt.close();

					for (Iterator iterator = serverList.iterator(); iterator.hasNext();) {
						ServerInfo serverInfo = (ServerInfo) iterator.next();
						
						//--------------
						// テーブル分割詳細情報へ追加
						//--------------
						smt = con.prepareStatement(
							m_sqlResource.getString("insert.gsc.tablepartdtl.partition"));
						////smt.setInt(1, serverInfo.getId());
						smt.setInt(1, getDbNo(serverInfo.getId(), dbName));
						smt.setString(2, dbName);
						smt.setString(3, tableName);
						smt.setInt(4, 0);
						smt.setInt(5, 0);
						smt.execute();
						smt.close();
					}
				}
				
			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				return false;
			}
		}
		return true;
	}
	
	/**
	 * データベースNoの取得
	 * @param serverId		サーバID
	 * @param dbName		DB名
	 * @return
	 * @since 2.0
	 */
	public int getDbNo(int serverId, String dbName)  {
		String connectUrl = "";
		int dbNo = -1;
		Connection con =getSelectConnectoin(); 

		try{
			connectUrl = ((Jdbc3Connection) con).getURL();

			PreparedStatement smt =
				con.prepareStatement(
					m_sqlResource.getString("select.gsc.servdb.dbno"));
			smt.setInt(1, serverId);
			smt.setString(2, dbName);
			ResultSet rs = smt.executeQuery();

			while (rs.next()) {
				dbNo = rs.getInt("DBNO");
			}
			rs.close();
			smt.close();

		} catch (SQLException e) {
			setErrInfo(connectUrl, e);
		}

		return dbNo;
	}
    /* (非 Javadoc)
     * @see org.postgresforest.tool.db.DbBase#connect(boolean)
     */
    public boolean connect(boolean autocommit) {
        boolean ret = super.connect(autocommit);
        if(!ret){
            
            ret = removeGsc();
        }

        
		return ret;

    }

    
    /**
     * @param ret
     * @return
     * @since 
     */
    private boolean removeGsc() {
        boolean ret = false;

        if(m_servers.size() <= 1){
            return ret;
        }
        
        StringBuffer errUrls =  new StringBuffer();
        for (Iterator iter = m_errInfoList.iterator(); iter.hasNext();) {
            ErrInfo element = (ErrInfo) iter.next();
            errUrls.append(element.getUrl());
            errUrls.append("\n");
            
        }
//        boolean removeGsc = MsgDialogUtil.question(Messages.getString("GSCに接続できませんでした。\n{0}\n処理対象から除外しますか。",errUrls.toString()));
        boolean removeGsc = true;
        System.out.println(MessagesCommandLine.getString("GSCに接続できませんでした。\n{0}\n処理対象から除外します。"));
        if(removeGsc){
            ArrayList removeList = new ArrayList();
            for (Iterator iter = m_errInfoList.iterator(); iter.hasNext();) {
                ErrInfo element = (ErrInfo) iter.next();
                
                String errUrl = element.getUrl();
                
        		for (Iterator iter2 = m_servers.iterator(); iter2.hasNext();) {
        			UrlInfo url = (UrlInfo) iter2.next();
        			String connetStr = PROTOCOL + makeUrl(url);
        			
        			//データソースへのコネクションを確立
        			if( errUrl.equals(connetStr) ){
        			    removeList.add(url);
        			    //m_servers.remove(url);
        			    
        			}
        		}
            }
            m_servers.removeAll(removeList);
            clearErrInfoList();
            ret = true;
        }
        return ret;
    }

    /* (非 Javadoc)
     * @see org.postgresforest.tool.db.DbBase#connectTemplate()
     */
    public boolean connectTemplate() {
        boolean ret = super.connectTemplate();
        if(!ret){
            
            ret = removeGsc();
        }

        
		return ret;

    }

    
    /* (非 Javadoc)
     * @see org.postgresforest.tool.db.DbBase#connectSELECT()
     */
    public boolean connectSELECT() {
        
        boolean ret = super.connectSELECT();
        if(!ret){
                        
            ret = removeGsc();
            if(ret){
                ret = connectSELECT();
            }
            
        }
        
        return ret;
    }
    
    
    //TODOMASU BrokenLogを追加することは無い
//    public boolean addBrokenLog(BrokenLogInfo brokenLogInfo){
//    	return false;
//    }
    
    public boolean delBrokenLog(String serverID, Date datetime){
    	
    	boolean ret = true;
		String connectUrl = "";


		for (Iterator iter = m_Connection.iterator(); iter.hasNext();) {
			Connection con = (Connection) iter.next();

			try {
				connectUrl = ((Jdbc3Connection) con).getURL();
	
				PreparedStatement smt =
					con.prepareStatement(
							//TODOMASU delete.gsc.brokenlogをSQL.propertiesファイルに指定する
						m_sqlResource.getString("delete.gsc.brokenlog"));
	
				smt.setString(1, serverID);
				smt.setTimestamp(2, new Timestamp(datetime.getTime()));
	
				smt.execute();
				smt.close();
	

			} catch (SQLException e) {
				setErrInfo(connectUrl, e);
				ret = false;
			}

		}

		return ret;
    }
    public boolean delBrokenLog(int serverID, Date datetime){
    	boolean ret = false;
    	ret = delBrokenLog(Integer.toString(serverID), datetime);
    	return ret;
    }
    
}
