/*
このファイルの中身は、NTT オープンソースライセンス　バージョン 1.0（「本
契約」という）の適用を受けます。
本契約を遵守しない限り、このファイルを使用してはなりません。
本契約のコピーは、次のＵＲＬから入手できます。
【配布サイトのURL】 http://www.oss.ecl.ntt.co.jp/lms/

本契約に基づき頒布されるソフトウェアは、現状のまま、明示又は黙示のあらゆ
る種類の保証なしで、頒布されます。本契約に基づく権利及び制限を律する特定
の文言については、本契約を参照してください。

「オリジナルコード」は、 NTT Cyber Space Laboratories Code です。 
「オリジナルコード」の「初期開発者」は、日本電信電話株式会社です。  
日本電信電話株式会社により創作された部分は、Copyright (C) 2004 
日本電信電話株式会社 です。
全ての権利が留保されます。 
「コントリビュータ」：_____________________________________ 


The contents of this file are subject to the NTT Opensource License
Version 1.0 (the License); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
【配布サイトのURL】 http://www.oss.ecl.ntt.co.jp/lms/

Software distributed under the License is distributed on an AS IS
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
License for the specific language governing rights and limitations
under the License.

The Original Code is NTT Cyber Space Laboratories Code .

The Initial Developer of the Original Code is NIPPON TELEGRAPH AND 
TELEPHONE CORPORATION.
Portions created by the NIPPON TELEGRAPH AND TELEPHONE CORPORATION 
are Copyright (C) 2004 NIPPON TELEGRAPH AND TELEPHONE CORPORATION. 
All Rights Reserved.

Contributor(s) ______________________________________.
*/

//
//	ScormAttemptDataAccess
//	変更履歴
//		2004.02.01	新規作成
//      2006.12.01　変更 T.Kiyokawa
//                  終了時送信ログをXMLからテキスト形式に変更し、高速化
//

package jp.co.ntt.lms.lo.scorm;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import jp.co.ntt.lms.lo.LOException;
import jp.co.ntt.lms.xmo.DataAccess;
import jp.co.ntt.lms.xmo.Environment;
import jp.co.ntt.lms.xmo.util.DebugLog;

// CommentOut 2006.11.24 (CSV対応のため)
//　import org.w3c.dom.Node;

/**
 * ScormAttemptテーブルへのアクセス・クラス。
 * @author T.Nishiki
 */
public class ScormAttemptDataAccess extends ScormDataAccess {
	/**
	 * テーブル名。
	 */
	public static final String TABLE_NAME = "Scorm_Attempt";

	/**
	 * テーブル・列名：ユーザID。
	 */
	public static final String USERID = "UserID";

	/**
	 * テーブル・列名：LOID。
	 */
	public static final String LOID = "LOID";

	/**
	 * テーブル・列名：学習セッション回数。
	 */
	public static final String STUDY_SESSION_COUNT = "StudySessionCount";

	/**
	 * テーブル・列名：アクティビティID。
	 */
	public static final String ACTIVITYID = "ActivityID";

	/**
	 * テーブル・列名：試行回数。
	 */
	public static final String ATTEMPT_COUNT = "AttemptCount";

	/**
	 * テーブル・列名：Learnセッション回数。
	 */
	public static final String LEARN_SESSION_COUNT = "LearnSessionCount";

	/**
	 * テーブル・列名：セッションID。
	 */
	public static final String SESSIONID = "SessionID";

	/**
	 * テーブル・列名：学習日時。
	 */
	public static final String LEARNSESSION_DATE = "LearnSession_Date";

	/**
	 * テーブル・列名：完了ステータス。
	 */
	public static final String COMPLETION_STATUS = "Completion_Status";

	/**
	 * テーブル・列名：正規化済み得点。
	 */
	public static final String SCALED_SCORE = "ScaledScore";

	/**
	 * テーブル・列名：得点。
	 */
	public static final String RAWSCORE = "RawScore";

	/**
	 * テーブル・列名：最高得点。
	 */
	public static final String MAXSCORE = "MaxScore";

	/**
	 * テーブル・列名：最低得点。
	 */
	public static final String MINSCORE = "MinScore";

	/**
	 * テーブル・列名：滞在時間。
	 */
	public static final String ATTEMPT_SESSION_TIME = "Attempt_Session_Time";

	/**
	 * テーブル・列名：合格ステータス。
	 */
	public static final String SUCCESS_STATUS = "Success_Status";

	/**
	 * テーブル・列名：ロケーション。
	 */
	public static final String LOCATION = "location";

	/**
	 * テーブル・列名：学習終了状態。
	 */
	public static final String EXIT = "exit";

	/**
	 * &lt;完了ステータス&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_COMPLETION_STATUS_VALUE =
		"./completionstatus/text()";

	/**
	 * &lt;正規化済み得点&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_SCALED_SCORE_VALUE =
		"./score/scaled/text()";

	/**
	 * &lt;得点&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_RAW_SCORE_VALUE = "./score/raw/text()";

	/**
	 * &lt;最高得点&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_MAX_SCORE_VALUE = "./score/max/text()";

	/**
	 * &lt;最低得点&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_MIN_SCORE_VALUE = "./score/min/text()";

	/**
	 * &lt;滞在時間&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_ATTEMPT_SESSION_TIME_VALUE =
		"./sessiontime/text()";

	/**
	 * &lt;合格ステータス&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_SUCCESS_STATUS_VALUE =
		"./successstatus/text()";

	/**
	 * &lt;ロケーション&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_LOCATION_VALUE = "./location/text()";

	/**
	 * &lt;学習終了状態&gt;要素の値を取得するためのロケーション・パス。
	 */
	public static final String PATH_EXIT_VALUE = "./exit/text()";

	/**
	 * getTotalMaxMinScoresメソッドの戻り値の配列長。<br>
	 * @see #getTotalMaxMinScores(DataAccess, String, String, String)
	 */
	private static final int MAX_MIN_SCORES_LENGTH = 2;

	/**
	 * getTotalMaxMinScoresメソッドの戻り値で最高得点があるインデックス。
	 * @see #getTotalMaxMinScores(DataAccess, String, String, String)
	 */
	public static final int INDEX_MAX_SOCRE = 0;
	/**
	 * getTotalMaxMinScoresメソッドの戻り値で最小得点があるインデックス。
	 * @see #getTotalMaxMinScores(DataAccess, String, String, String)
	 */
	public static final int INDEX_MIN_SOCRE = 1;

	/**
	 * 文字列カラムの最大サイズ。
	 */
	public static final int COLUMN_SIZE_MAX;

	/**
	 * 文字列カラムの最大サイズ。
	 */
	public static final int COLUMN_SIZE_UNIT;
	
//	ADD start 2006.11.22 T.Kiyokawa

	/** 
	CSV・列番号：SCO完了ステータス
	 */
	public static final int CSVCOL_AT_COMP_STATUS = 4 ;


	/** 
	CSV・列番号：正規化済み得点
	 */
	public static final int CSVCOL_AT_SCORE_SCALED = 5 ;


	/** 
	CSV・列番号：得点
	 */
	public static final int CSVCOL_AT_SCORE_RAW = 6 ;


	/** 
	CSV・列番号：最大得点 
	 */
	public static final int CSVCOL_AT_SCORE_MAX = 7 ;


	/** 
	CSV・列番号：最小得点 
	 */
	public static final int CSVCOL_AT_SCORE_MIN = 8 ;


	/** 
	CSV・列番号：セッションタイム
	 */
	public static final int CSVCOL_AT_SESSION_TIME = 9 ;


	/** 
	CSV・列番号：SCO合格完了フラグ
	 */
	public static final int CSVCOL_AT_SUCCESS_STATUS = 10 ;


	/** 
	CSV・列番号：学習個所 
	 */
	public static final int CSVCOL_AT_LOCATION = 11 ;


	/** 
	CSV・列番号：退出理由 
	 */
	public static final int CSVCOL_AT_EXIT = 12 ;
	
//  ADD end
	
	/**
	 * スタティック・イニシャライザ。
	 * データベースの種別に基づき、文字列カラムの最大サイズ定数を決定します。
	 */
	static {
		// データベースによってカラムサイズ・サイズ種別を設定
		int columnSizeMax = 0;
		int columnSizeUnit = 0;
		try {
			Environment environment = new Environment();
			String dbType = environment.getDBType();
			if (dbType.equals(Environment.DB_SQLSERVER)) {
				columnSizeMax = 0;
				columnSizeUnit = ScormLoConstant.COLUMN_SIZE_UNIT_SQLSERVER;
			}
			else if (dbType.equals(Environment.DB_ORACLE)) {
				columnSizeMax = 0;
				columnSizeUnit = ScormLoConstant.COLUMN_SIZE_UNIT_ORACLE;
			}
			else if (dbType.equals(Environment.DB_POSTGRE)) {
				columnSizeMax = 0;
				columnSizeUnit = ScormLoConstant.COLUMN_SIZE_UNIT_POSTGRE;
			}
		}
		catch (Exception e) {
		}
		COLUMN_SIZE_MAX = columnSizeMax;
		COLUMN_SIZE_UNIT = columnSizeUnit;
	}

	/**
	 * コンストラクタ
	 **/
	public ScormAttemptDataAccess() {
		super( TABLE_NAME );
	}

	// Add Start T.Kiyokawa 2006.11.24

	/**
	 * ScormAttemptテーブルへの書込みを実行します。<br>
	 * &lt;attempt&gt;要素ごとに呼び出され、レコードを追加します。<br>
	 *
	 * @param dataAccess データアクセスクラス。
	 * @param endLearnData 学習終了情報。
	 * @param attemptCSV attempt情報をもつ一行のCSVデータ
	 * @param activityID データを書き込む対象が属しているアクティビティのID。
	 * @param attemptCount 試行回数。
	 *         学習ログ内で、データを書き込む対象が属している
	 *         &lt;attemptcount&gt;要素の位置（１以上の整数）。
	 * @param learnSessionCount Learnセッション回数。
	 *         学習ログ内で、データを書き込む対象が属している
	 *         &lt;learnsession&gt;要素の位置（１以上の整数）。
	 * @param learnSessionDate Learnセッション回数。
	 *         学習ログ内で、データを書き込む対象が属している
	 *         &lt;learnsession&gt;要素のdate属性値。
	 *
	 * @throws LOException データベースへの書込に失敗した場合。
	 */
	public static void insert(
		DataAccess dataAccess,
		ScormLoEndLearnData endLearnData,
		ScormLoCsvData attemptCSV,
		String activityID,
		int attemptCount,
		int learnSessionCount,
		String learnSessionDate)
		throws LOException {

		////////////////////////////////////////////////////////////////////////
		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"HEAD insert("
				+ "dataAccess,endLearnData"
				+ "," + attemptCSV + "," + activityID
				+ "," + attemptCount + "," + learnSessionCount
				+ "," + learnSessionDate + ")",
			DebugLog.ROW);

		try {
			////////////////////////////////////////////////////////////////////
			// 各カラムの値を取得
			//==================================================================
			// カラムと値のマップ
			ScormColumnInfo[] columnInfos =
				makeColumnInfos(
					endLearnData, attemptCSV,
					activityID,	attemptCount,
					learnSessionCount, learnSessionDate);
			////////////////////////////////////////////////////////////////////
			// SQL文の生成
			String query =
				ScormLoUtil.makeInsertQuery(TABLE_NAME, columnInfos);
			////////////////////////////////////////////////////////////////////
			// SQL文の実行
			dataAccess.execute(query.toString());
		}
		catch (LOException e) {
			throw e;
		}
		catch (SQLException e) {
			DebugLog.write(ScormAttemptDataAccess.class, e, DebugLog.HIGHT);
			throw new LOException(e.getMessage());
		}
		////////////////////////////////////////////////////////////////////////
		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL insert("
				+ "dataAccess,endLearnData"
				+ "," + attemptCSV + "," + activityID
				+ "," + attemptCount + "," + learnSessionCount
				+ "," + learnSessionDate + ")",
			DebugLog.ROW);
	}

	/**
	 * ScormAttemtテーブルのカラム情報配列を生成します。<br>
	 * @param endLearnData 学習終了情報。
	 * @param attemptCSV &lt;attempt&gt;CSVデータ。
	 * @param activityID データを書き込む対象が属しているアクティビティのID。
	 * @param attemptCount 試行回数。
	 *         学習ログ内で、データを書き込む対象が属している
	 *         &lt;attemptcount&gt;要素の位置（１以上の整数）。
	 * @param learnSessionCount Learnセッション回数。
	 *         学習ログ内で、データを書き込む対象が属している
	 *         &lt;learnsession&gt;要素の位置（１以上の整数）。
	 * @param learnSessionDate Learnセッション回数。
	 *         学習ログ内で、データを書き込む対象が属している
	 *         &lt;learnsession&gt;要素のdate属性値。
	 *
	 * @return ScormAttemtテーブルのカラム情報配列。
	 * @throws LOException ノードからでデータ取得失敗した場合。
	 */
	private static ScormColumnInfo[] makeColumnInfos(
		ScormLoEndLearnData endLearnData,
		ScormLoCsvData attemptCSV,
		String activityID,
		int attemptCount,
		int learnSessionCount,
		String learnSessionDate)
		throws LOException {

		////////////////////////////////////////////////////////////////////////
		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"HEAD makeColumnInfos(endLearnData"
				+ "," + attemptCSV
				+ "," + activityID + "," + attemptCount
				+ "," + learnSessionCount + "," + learnSessionDate + ")",
			DebugLog.ROW);

		// このメソッドの戻り値
		ScormColumnInfo[] columnInfos = null;
		// 配列生成用リスト
		List columnInfoList = new ArrayList();
		try {
			////////////////////////////////////////////////////////////////////
			// endLearnDataより取得できるデータをカラムとして設定
			//==================================================================
			// ユーザID
			String userID = endLearnData.getUserID();
			ScormColumnInfo userIDColumn =
				new ScormColumnInfo(USERID, userID,
					ScormColumnInfo.COLUMN_TYPE_STRING,
					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
			columnInfoList.add(userIDColumn);
			// LOID
			String loID = endLearnData.getLoID();
			ScormColumnInfo loIDColumn =
				new ScormColumnInfo(LOID, loID,
					ScormColumnInfo.COLUMN_TYPE_STRING,
					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
			columnInfoList.add(loIDColumn);
			// 学習セッション回数
			int studySessionCount = endLearnData.getStudySession();
			ScormColumnInfo studySessionCountColumn =
				new ScormColumnInfo(
					STUDY_SESSION_COUNT,
					Integer.toString(studySessionCount),
					ScormColumnInfo.COLUMN_TYPE_NUMBER,
					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
			columnInfoList.add(studySessionCountColumn);
			// セッションID(ログインセッション回数)
			int sessionID = endLearnData.getLoginSession();
			ScormColumnInfo sessionIDColumn =
				new ScormColumnInfo(
					SESSIONID, Integer.toString(sessionID),
					ScormColumnInfo.COLUMN_TYPE_STRING,
					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
			columnInfoList.add(sessionIDColumn);
			////////////////////////////////////////////////////////////////////
			// endLearnData、Node以外より取得できるデータをカラムとして設定
			//==================================================================
			// アクティビティID
			ScormColumnInfo activityIDColumn =
				new ScormColumnInfo(
					ACTIVITYID, activityID,
					ScormColumnInfo.COLUMN_TYPE_STRING,
					ScormLoConstant.COLUMN_ACITIVITY_ID_SIZE_MAX,
					ScormLoConstant.COLUMN_ACITIVITY_ID_SIZE_UNIT);
			columnInfoList.add(activityIDColumn);
			// 試行回数
			ScormColumnInfo attemptCountColumn =
				new ScormColumnInfo(
					ATTEMPT_COUNT, Integer.toString(attemptCount),
					ScormColumnInfo.COLUMN_TYPE_NUMBER,
					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
			columnInfoList.add(attemptCountColumn);
			// Learnセッション回数
			ScormColumnInfo learnSessionCountColumn =
				new ScormColumnInfo(
					LEARN_SESSION_COUNT, Integer.toString(learnSessionCount),
					ScormColumnInfo.COLUMN_TYPE_NUMBER,
					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
			columnInfoList.add(learnSessionCountColumn);
			// 学習開始日時(SCORMサーバが生成した日付をDB用に書式変換)
			Date sessionDate =
					ScormLoUtil.convertScormServerFormatToDate(
						learnSessionDate);
			String learnSessionDateForDB =
					ScormLoUtil.convertDateToDbFormat(sessionDate);
			ScormColumnInfo learnSessionDateColumn =
				new ScormColumnInfo(
					LEARNSESSION_DATE, learnSessionDateForDB,
					ScormColumnInfo.COLUMN_TYPE_DATETIME,
					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
			columnInfoList.add(learnSessionDateColumn);
			////////////////////////////////////////////////////////////////////
			// Nodeより取得できるデータをカラムとして設定
			//==================================================================
			List columnInfoFromNodeList = makeColumnInfosFromCSV(attemptCSV);
			columnInfoList.addAll(columnInfoFromNodeList);
			////////////////////////////////////////////////////////////////////
			// リストを配列に変換
			columnInfos = new ScormColumnInfo[ columnInfoList.size() ];
			columnInfoList.toArray(columnInfos);

		}
		catch (LOException e) {
			throw e;
		}

		////////////////////////////////////////////////////////////////////////
		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL makeColumnInfos(endLearnData"
				+ "," + attemptCSV
				+ "," + activityID + "," + attemptCount
				+ "," + learnSessionCount + "," + learnSessionDate + ")"
				+ (" return " + columnInfos),
			DebugLog.ROW);
		return columnInfos;
	}


	/**
	 * ScormAttemptテーブルのカラム情報配列を生成します。<br>
	 * &lt;attempt&gt;CSVから取得できる情報をリストとして戻します。
	 * @param attemptCSV &lt;attempt&gt;要素を表すCSV。
	 *
	 * @return ScormAttemtテーブルのカラム情報を要素とするList。
	 * @throws LOException ノードからでデータ取得失敗した場合。
	 */
	private static List makeColumnInfosFromCSV(
		ScormLoCsvData attemptCSV)
		throws LOException {

		////////////////////////////////////////////////////////////////////////
		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"HEAD makeColumnInfosFromCSV(" + attemptCSV + ")",
			DebugLog.ROW);

		// このメソッドの戻り値
		List columnInfoList = new ArrayList();
		try {
			////////////////////////////////////////////////////////////////////
			// Nodeより取得できるデータをカラムとして設定
			//==================================================================
			// 完了ステータス
			String completionStatus =
				attemptCSV.getData(CSVCOL_AT_COMP_STATUS) ;
			if (completionStatus != null) {
				ScormColumnInfo completionStatusColumn =
					new ScormColumnInfo(
						COMPLETION_STATUS, completionStatus,
						ScormColumnInfo.COLUMN_TYPE_STRING,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(completionStatusColumn);
			}
			// 正規化済み得点
			String scaledScore =
				attemptCSV.getData(CSVCOL_AT_SCORE_SCALED) ;
			if (scaledScore != null) {
				ScormColumnInfo scaledScoreColumn =
					new ScormColumnInfo(
						SCALED_SCORE, scaledScore,
						ScormColumnInfo.COLUMN_TYPE_NUMBER,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(scaledScoreColumn);
			}
			// 得点
			String rawScore =
				attemptCSV.getData(CSVCOL_AT_SCORE_RAW) ;
			if (rawScore != null) {
				ScormColumnInfo rawScoreColumn =
					new ScormColumnInfo(RAWSCORE, rawScore,
						ScormColumnInfo.COLUMN_TYPE_NUMBER,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(rawScoreColumn);
			}
			// 最高得点
			String maxScore =
				attemptCSV.getData(CSVCOL_AT_SCORE_MAX) ;
			if (maxScore != null) {
				ScormColumnInfo maxScoreColumn =
					new ScormColumnInfo(MAXSCORE, maxScore,
						ScormColumnInfo.COLUMN_TYPE_NUMBER,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(maxScoreColumn);
			}
			// 最低得点
			String minScore =
				attemptCSV.getData(CSVCOL_AT_SCORE_MIN) ;
			if (minScore != null) {
				ScormColumnInfo minScoreColumn =
					new ScormColumnInfo(MINSCORE, minScore,
						ScormColumnInfo.COLUMN_TYPE_NUMBER,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(minScoreColumn);
			}
			// 滞在時間
			String attemptSessionTimeDuration =
				attemptCSV.getData(CSVCOL_AT_SESSION_TIME) ;
			if (attemptSessionTimeDuration != null) {
				// Duration文字列を秒数に変換
				double attemptSessionTime =
					ScormLoUtil.parseDuration(attemptSessionTimeDuration);
				ScormColumnInfo attemptSessionTimeColumn =
					new ScormColumnInfo(
						ATTEMPT_SESSION_TIME,
						Double.toString(attemptSessionTime),
						ScormColumnInfo.COLUMN_TYPE_STRING,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(attemptSessionTimeColumn);
			}
			// 合格ステータス
			String successStatus =
				attemptCSV.getData(CSVCOL_AT_SUCCESS_STATUS) ;
			if (successStatus != null) {
				ScormColumnInfo successStatusColumn =
					new ScormColumnInfo(
						SUCCESS_STATUS, successStatus,
						ScormColumnInfo.COLUMN_TYPE_STRING,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(successStatusColumn);
			}
			// ロケーション
			String location =
				attemptCSV.getData(CSVCOL_AT_LOCATION) ;
			if (location != null) {
				ScormColumnInfo locationColumn =
					new ScormColumnInfo(
						LOCATION, location,
						ScormColumnInfo.COLUMN_TYPE_STRING,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(locationColumn);
			}
			// 学習終了状態
			String exit =
				attemptCSV.getData(CSVCOL_AT_EXIT) ;
			if (exit != null) {
				ScormColumnInfo exitColumn =
					new ScormColumnInfo(
						EXIT, exit,
						ScormColumnInfo.COLUMN_TYPE_STRING,
						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
				columnInfoList.add(exitColumn);
			}
		}
		catch (LOException e) {
			throw e;
		}

		////////////////////////////////////////////////////////////////////////
		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL makeColumnInfosFromCSV(" + attemptCSV + ")"
				+ (" return " + columnInfoList),
			DebugLog.ROW);
		return columnInfoList;
	}
	// Add End
	
	// CommentOut Start 2006.11.24 T.Kiyokawa(CSV対応のため)
//	/**
//	 * ScormAttemptテーブルへの書込みを実行します。<br>
//	 * &lt;attempt&gt;要素ごとに呼び出され、レコードを追加します。<br>
//	 *
//	 * @param dataAccess データアクセスクラス。
//	 * @param endLearnData 学習終了情報。
//	 * @param attemptNode &lt;attempt&gt;要素を表すノード。
//	 * @param activityID データを書き込む対象が属しているアクティビティのID。
//	 * @param attemptCount 試行回数。
//	 *         学習ログ内で、データを書き込む対象が属している
//	 *         &lt;attemptcount&gt;要素の位置（１以上の整数）。
//	 * @param learnSessionCount Learnセッション回数。
//	 *         学習ログ内で、データを書き込む対象が属している
//	 *         &lt;learnsession&gt;要素の位置（１以上の整数）。
//	 * @param learnSessionDate Learnセッション回数。
//	 *         学習ログ内で、データを書き込む対象が属している
//	 *         &lt;learnsession&gt;要素のdate属性値。
//	 *
//	 * @throws LOException データベースへの書込に失敗した場合。
//	 */
//	public static void insert(
//		DataAccess dataAccess,
//		ScormLoEndLearnData endLearnData,
//		Node attemptNode,
//		String activityID,
//		int attemptCount,
//		int learnSessionCount,
//		String learnSessionDate)
//		throws LOException {
//
//		////////////////////////////////////////////////////////////////////////
//		// メソッド開始ログ
//		DebugLog.write(
//			ScormAttemptDataAccess.class,
//			"HEAD insert("
//				+ "dataAccess,endLearnData"
//				+ "," + attemptNode + "," + activityID
//				+ "," + attemptCount + "," + learnSessionCount
//				+ "," + learnSessionDate + ")",
//			DebugLog.ROW);
//
//		try {
//			////////////////////////////////////////////////////////////////////
//			// 各カラムの値を取得
//			//==================================================================
//			// カラムと値のマップ
//			ScormColumnInfo[] columnInfos =
//				makeColumnInfos(
//					endLearnData, attemptNode,
//					activityID,	attemptCount,
//					learnSessionCount, learnSessionDate);
//			////////////////////////////////////////////////////////////////////
//			// SQL文の生成
//			String query =
//				ScormLoUtil.makeInsertQuery(TABLE_NAME, columnInfos);
//			////////////////////////////////////////////////////////////////////
//			// SQL文の実行
//			dataAccess.execute(query.toString());
//		}
//		catch (LOException e) {
//			throw e;
//		}
//		catch (SQLException e) {
//			DebugLog.write(ScormAttemptDataAccess.class, e, DebugLog.HIGHT);
//			throw new LOException(e.getMessage());
//		}
//		////////////////////////////////////////////////////////////////////////
//		// メソッド終了ログ
//		DebugLog.write(
//			ScormAttemptDataAccess.class,
//			"TAIL insert("
//				+ "dataAccess,endLearnData"
//				+ "," + attemptNode + "," + activityID
//				+ "," + attemptCount + "," + learnSessionCount
//				+ "," + learnSessionDate + ")",
//			DebugLog.ROW);
//	}
//
//	/**
//	 * ScormAttemtテーブルのカラム情報配列を生成します。<br>
//	 * @param endLearnData 学習終了情報。
//	 * @param attemptNode &lt;attempt&gt;要素を表すノード。
//	 * @param activityID データを書き込む対象が属しているアクティビティのID。
//	 * @param attemptCount 試行回数。
//	 *         学習ログ内で、データを書き込む対象が属している
//	 *         &lt;attemptcount&gt;要素の位置（１以上の整数）。
//	 * @param learnSessionCount Learnセッション回数。
//	 *         学習ログ内で、データを書き込む対象が属している
//	 *         &lt;learnsession&gt;要素の位置（１以上の整数）。
//	 * @param learnSessionDate Learnセッション回数。
//	 *         学習ログ内で、データを書き込む対象が属している
//	 *         &lt;learnsession&gt;要素のdate属性値。
//	 *
//	 * @return ScormAttemtテーブルのカラム情報配列。
//	 * @throws LOException ノードからでデータ取得失敗した場合。
//	 */
//	private static ScormColumnInfo[] makeColumnInfos(
//		ScormLoEndLearnData endLearnData,
//		Node attemptNode,
//		String activityID,
//		int attemptCount,
//		int learnSessionCount,
//		String learnSessionDate)
//		throws LOException {
//
//		////////////////////////////////////////////////////////////////////////
//		// メソッド開始ログ
//		DebugLog.write(
//			ScormAttemptDataAccess.class,
//			"HEAD makeColumnInfos(endLearnData"
//				+ "," + attemptNode
//				+ "," + activityID + "," + attemptCount
//				+ "," + learnSessionCount + "," + learnSessionDate + ")",
//			DebugLog.ROW);
//
//		// このメソッドの戻り値
//		ScormColumnInfo[] columnInfos = null;
//		// 配列生成用リスト
//		List columnInfoList = new ArrayList();
//		try {
//			////////////////////////////////////////////////////////////////////
//			// endLearnDataより取得できるデータをカラムとして設定
//			//==================================================================
//			// ユーザID
//			String userID = endLearnData.getUserID();
//			ScormColumnInfo userIDColumn =
//				new ScormColumnInfo(USERID, userID,
//					ScormColumnInfo.COLUMN_TYPE_STRING,
//					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//			columnInfoList.add(userIDColumn);
//			// LOID
//			String loID = endLearnData.getLoID();
//			ScormColumnInfo loIDColumn =
//				new ScormColumnInfo(LOID, loID,
//					ScormColumnInfo.COLUMN_TYPE_STRING,
//					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//			columnInfoList.add(loIDColumn);
//			// 学習セッション回数
//			int studySessionCount = endLearnData.getStudySession();
//			ScormColumnInfo studySessionCountColumn =
//				new ScormColumnInfo(
//					STUDY_SESSION_COUNT,
//					Integer.toString(studySessionCount),
//					ScormColumnInfo.COLUMN_TYPE_NUMBER,
//					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//			columnInfoList.add(studySessionCountColumn);
//			// セッションID(ログインセッション回数)
//			int sessionID = endLearnData.getLoginSession();
//			ScormColumnInfo sessionIDColumn =
//				new ScormColumnInfo(
//					SESSIONID, Integer.toString(sessionID),
//					ScormColumnInfo.COLUMN_TYPE_STRING,
//					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//			columnInfoList.add(sessionIDColumn);
//			////////////////////////////////////////////////////////////////////
//			// endLearnData、Node以外より取得できるデータをカラムとして設定
//			//==================================================================
//			// アクティビティID
//			ScormColumnInfo activityIDColumn =
//				new ScormColumnInfo(
//					ACTIVITYID, activityID,
//					ScormColumnInfo.COLUMN_TYPE_STRING,
//					ScormLoConstant.COLUMN_ACITIVITY_ID_SIZE_MAX,
//					ScormLoConstant.COLUMN_ACITIVITY_ID_SIZE_UNIT);
//			columnInfoList.add(activityIDColumn);
//			// 試行回数
//			ScormColumnInfo attemptCountColumn =
//				new ScormColumnInfo(
//					ATTEMPT_COUNT, Integer.toString(attemptCount),
//					ScormColumnInfo.COLUMN_TYPE_NUMBER,
//					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//			columnInfoList.add(attemptCountColumn);
//			// Learnセッション回数
//			ScormColumnInfo learnSessionCountColumn =
//				new ScormColumnInfo(
//					LEARN_SESSION_COUNT, Integer.toString(learnSessionCount),
//					ScormColumnInfo.COLUMN_TYPE_NUMBER,
//					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//			columnInfoList.add(learnSessionCountColumn);
//			// 学習開始日時(SCORMサーバが生成した日付をDB用に書式変換)
//			Date sessionDate =
//					ScormLoUtil.convertScormServerFormatToDate(
//						learnSessionDate);
//			String learnSessionDateForDB =
//					ScormLoUtil.convertDateToDbFormat(sessionDate);
//			ScormColumnInfo learnSessionDateColumn =
//				new ScormColumnInfo(
//					LEARNSESSION_DATE, learnSessionDateForDB,
//					ScormColumnInfo.COLUMN_TYPE_DATETIME,
//					COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//			columnInfoList.add(learnSessionDateColumn);
//			////////////////////////////////////////////////////////////////////
//			// Nodeより取得できるデータをカラムとして設定
//			//==================================================================
//			List columnInfoFromNodeList = makeColumnInfosFromNode(attemptNode);
//			columnInfoList.addAll(columnInfoFromNodeList);
//			////////////////////////////////////////////////////////////////////
//			// リストを配列に変換
//			columnInfos = new ScormColumnInfo[ columnInfoList.size() ];
//			columnInfoList.toArray(columnInfos);
//
//		}
//		catch (LOException e) {
//			throw e;
//		}
//
//		////////////////////////////////////////////////////////////////////////
//		// メソッド終了ログ
//		DebugLog.write(
//			ScormAttemptDataAccess.class,
//			"TAIL makeColumnInfos(endLearnData"
//				+ "," + attemptNode
//				+ "," + activityID + "," + attemptCount
//				+ "," + learnSessionCount + "," + learnSessionDate + ")"
//				+ (" return " + columnInfos),
//			DebugLog.ROW);
//		return columnInfos;
//	}
//
//
//	/**
//	 * ScormAttemptテーブルのカラム情報配列を生成します。<br>
//	 * &lt;attempt&gt;要素ノードから取得できる情報をリストとして戻します。
//	 * @param attemptNode &lt;attempt&gt;要素を表すノード。
//	 *
//	 * @return ScormAttemtテーブルのカラム情報を要素とするList。
//	 * @throws LOException ノードからでデータ取得失敗した場合。
//	 */
//	private static List makeColumnInfosFromNode(
//		Node attemptNode)
//		throws LOException {
//
//		////////////////////////////////////////////////////////////////////////
//		// メソッド開始ログ
//		DebugLog.write(
//			ScormAttemptDataAccess.class,
//			"HEAD makeColumnInfosFromNode(" + attemptNode + ")",
//			DebugLog.ROW);
//
//		// このメソッドの戻り値
//		List columnInfoList = new ArrayList();
//		try {
//			////////////////////////////////////////////////////////////////////
//			// Nodeより取得できるデータをカラムとして設定
//			//==================================================================
//			// 完了ステータス
//			String completionStatus =
//				ScormLoUtil.getNodeValue(
//					attemptNode, PATH_COMPLETION_STATUS_VALUE);
//			if (completionStatus != null) {
//				ScormColumnInfo completionStatusColumn =
//					new ScormColumnInfo(
//						COMPLETION_STATUS, completionStatus,
//						ScormColumnInfo.COLUMN_TYPE_STRING,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(completionStatusColumn);
//			}
//			// 正規化済み得点
//			String scaledScore =
//				ScormLoUtil.getNodeValue(attemptNode, PATH_SCALED_SCORE_VALUE);
//			if (scaledScore != null) {
//				ScormColumnInfo scaledScoreColumn =
//					new ScormColumnInfo(
//						SCALED_SCORE, scaledScore,
//						ScormColumnInfo.COLUMN_TYPE_NUMBER,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(scaledScoreColumn);
//			}
//			// 得点
//			String rawScore =
//				ScormLoUtil.getNodeValue(attemptNode, PATH_RAW_SCORE_VALUE);
//			if (rawScore != null) {
//				ScormColumnInfo rawScoreColumn =
//					new ScormColumnInfo(RAWSCORE, rawScore,
//						ScormColumnInfo.COLUMN_TYPE_NUMBER,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(rawScoreColumn);
//			}
//			// 最高得点
//			String maxScore =
//				ScormLoUtil.getNodeValue(attemptNode, PATH_MAX_SCORE_VALUE);
//			if (maxScore != null) {
//				ScormColumnInfo maxScoreColumn =
//					new ScormColumnInfo(MAXSCORE, maxScore,
//						ScormColumnInfo.COLUMN_TYPE_NUMBER,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(maxScoreColumn);
//			}
//			// 最低得点
//			String minScore =
//				ScormLoUtil.getNodeValue(attemptNode, PATH_MIN_SCORE_VALUE);
//			if (minScore != null) {
//				ScormColumnInfo minScoreColumn =
//					new ScormColumnInfo(MINSCORE, minScore,
//						ScormColumnInfo.COLUMN_TYPE_NUMBER,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(minScoreColumn);
//			}
//			// 滞在時間
//			String attemptSessionTimeDuration =
//				ScormLoUtil.getNodeValue(
//					attemptNode, PATH_ATTEMPT_SESSION_TIME_VALUE);
//			if (attemptSessionTimeDuration != null) {
//				// Duration文字列を秒数に変換
//				double attemptSessionTime =
//					ScormLoUtil.parseDuration(attemptSessionTimeDuration);
//				ScormColumnInfo attemptSessionTimeColumn =
//					new ScormColumnInfo(
//						ATTEMPT_SESSION_TIME,
//						Double.toString(attemptSessionTime),
//						ScormColumnInfo.COLUMN_TYPE_STRING,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(attemptSessionTimeColumn);
//			}
//			// 合格ステータス
//			String successStatus =
//				ScormLoUtil.getNodeValue(
//					attemptNode, PATH_SUCCESS_STATUS_VALUE);
//			if (successStatus != null) {
//				ScormColumnInfo successStatusColumn =
//					new ScormColumnInfo(
//						SUCCESS_STATUS, successStatus,
//						ScormColumnInfo.COLUMN_TYPE_STRING,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(successStatusColumn);
//			}
//			// ロケーション
//			String location =
//				ScormLoUtil.getNodeValue(attemptNode, PATH_LOCATION_VALUE);
//			if (location != null) {
//				ScormColumnInfo locationColumn =
//					new ScormColumnInfo(
//						LOCATION, location,
//						ScormColumnInfo.COLUMN_TYPE_STRING,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(locationColumn);
//			}
//			// 学習終了状態
//			String exit =
//				ScormLoUtil.getNodeValue(attemptNode, PATH_EXIT_VALUE);
//			if (exit != null) {
//				ScormColumnInfo exitColumn =
//					new ScormColumnInfo(
//						EXIT, exit,
//						ScormColumnInfo.COLUMN_TYPE_STRING,
//						COLUMN_SIZE_MAX, COLUMN_SIZE_UNIT);
//				columnInfoList.add(exitColumn);
//			}
//		}
//		catch (LOException e) {
//			throw e;
//		}
//
//		////////////////////////////////////////////////////////////////////////
//		// メソッド終了ログ
//		DebugLog.write(
//			ScormAttemptDataAccess.class,
//			"TAIL makeColumnInfosFromNode(" + attemptNode + ")"
//				+ (" return " + columnInfoList),
//			DebugLog.ROW);
//		return columnInfoList;
//	}
	// CommentOut End 

	/**
	 * 教材の最大得点・最小得点の合計値を取得します。<br>
	 * 指定されたユーザID、LOID、セッションIDに該当するレコードから、
	 * アクティビティごとの最大得点・最小得点を取得し、
	 * 最大得点・最小得点それぞれの合計値を配列として戻します。<br>
	 * 配列は、要素数が２つで、先頭から順に最大得点合計、最小得点合計となります。
	 * @param dataAccess データアクセス・オブジェクト。
	 * @param userID ユーザID。
	 * @param loID LOID。
	 * @param sessionID セッションID（起動回数）。
	 * @return 以下の配列を戻します。
	 * 	<table border="1">
	 * 		<tr>
	 * 			<th>インデックス</th>
	 * 			<th>要素</th>
	 * 		</tr>
	 * 		<tr>
	 * 			<td>INDEX_MAX_SOCRE</td>
	 * 			<td>最大得点合計</td>
	 * 		</tr>
	 * 		<tr>
	 * 			<td>INDEX_MIN_SOCRE</td>
	 * 			<td>最小得点合計</td>
	 * 		</tr>
	 * 	</table><br>
	 * @throws LOException データベースアクセスに失敗した場合。
	 * @see #INDEX_MAX_SOCRE
	 * @see #INDEX_MIN_SOCRE
	 */
	public static double[] getTotalMaxMinScores(
		DataAccess dataAccess,
		String userID,
		String loID, String sessionID) throws LOException {

		////////////////////////////////////////////////////////////////////////
		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"HEAD getTotalMaxMinScores("
				+ dataAccess + "," + userID
				+ "," + loID + "," + sessionID + ")",
			DebugLog.ROW);

		double totalMinSocre = 0.0;
		double totalMaxSocre = 0.0;
		ResultSet resultSet = null;
		boolean successFlag = false;
		try {
			////////////////////////////////////////////////////////////////////
			// クエリー文の生成
			// =================================================================
			// 指定されたユーザID、LOID、セッションIDに一致するレコードのうち
			// アクティビティ別（＋ユーザID別、LOID別、セッションID別）に、
			// 試行回数、Learnセッション回数が最大値を求め、
			// それぞれが一致するレコードのみを取得し、
			// 該当するレコードの正規化得点の合計値を求めます。
			StringBuffer query = new StringBuffer();
			query.append( "SELECT" );
			// 正規化得点の最大値
			query.append( " SUM(sca.maxScaledScore)"
							+ " as maxScaledScore" );
			query.append( ",SUM(sca.minScaledScore)"
							+ " as minScaledScore" );
			query.append( " FROM" );
			// =================================================================
			// 回数最大のレコードを検索する内部クエリー
			query.append( "(" );
			query.append(     "SELECT" );
			query.append(     " " + ACTIVITYID + " as " + ACTIVITYID );
			query.append(     ",MAX(" + SCALED_SCORE + ") as maxScaledScore" );
			query.append(     ",MIN(" + SCALED_SCORE + ") as minScaledScore" );
			query.append(     " FROM " + TABLE_NAME );
			query.append(     " WHERE " + USERID + "='" + userID + "'" );
			query.append(     " AND " + LOID + "='" + loID + "'" );
			query.append(     " AND " + SESSIONID + "='" + sessionID + "'" );
			query.append(     " GROUP BY " + ACTIVITYID );
			query.append( ") sca" );
			////////////////////////////////////////////////////////////////////
			// クエリー発行
			String queryString = query.toString();
			DebugLog.write( ScormAttemptDataAccess.class,
				queryString, DebugLog.MID);
			resultSet = dataAccess.executeQuery(queryString);
			////////////////////////////////////////////////////////////////////
			// レコード取得
			// 取得した得点は正規化された値なので100掛けする。
			if (resultSet.next()) {
				totalMaxSocre = resultSet.getDouble("maxScaledScore");
				totalMaxSocre *= 100.0;
				totalMinSocre = resultSet.getDouble("minScaledScore");
				totalMinSocre *= 100.0;
			}
			// tryブロックの最後まで到達したら成功扱い。
			successFlag = true;
		}
		catch (SQLException e) {
			DebugLog.write(ScormAttemptDataAccess.class, e, DebugLog.HIGHT);
			throw new LOException(e.getMessage());
		}
		finally {
			// 結果セットのクローズ
			// 例外が発生した場合、いままで例外がなかったときにみスロー。
			if (resultSet != null) {
				try {
					resultSet.close();
				}
				catch (SQLException e) {
					DebugLog.write(ScormAttemptDataAccess.class,
						e, DebugLog.HIGHT);
					if (successFlag) {
						throw new LOException(e.getMessage());
					}
				}
			}
		}
		// 取得したデータの配列化
		double[] scores = new double[MAX_MIN_SCORES_LENGTH];
		scores[INDEX_MAX_SOCRE] = totalMaxSocre;
		scores[INDEX_MIN_SOCRE] = totalMinSocre;
		////////////////////////////////////////////////////////////////////////
		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL getTotalLatestScore("
				+ dataAccess + "," + userID
				+ "," + loID + "," + sessionID + ")"
				+ " return " + scores
				+ "(" + totalMaxSocre + "," + totalMinSocre + ")",
			DebugLog.ROW);
		return scores;
	}

	/**
	 * アクティビティごとの満点の合計値を求めます。<br>
	 *
	 * @param dataAccess データアクセス・オブジェクト。
	 * @param userID ユーザID。
	 * @param loID LOID。
	 * @param sessionID セッションID（起動回数）。
	 * @return 指定されたユーザID、LOID、セッションIDに該当するレコードから、
	 *          正規化得点が含まれるアクティビティ数に100を掛けた値を戻します。
	 * @throws LOException データベースアクセスに失敗した場合。
	 */
	public static int getTotalFullScore(
		DataAccess dataAccess,
		String userID, String loID, String sessionID) throws LOException {
		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL getTotalFullScore("
				+ dataAccess + "," + userID
				+ "," + loID + "," + sessionID + ")",
			DebugLog.ROW);

		int totalFullSocre = 0;
		ResultSet resultSet = null;
		boolean successFlag = false;
		try {
			////////////////////////////////////////////////////////////////////
			// クエリー文の生成
			// =================================================================
			// 指定されたユーザID、LOID、セッションIDに一致するレコードのうち
			// 正規化得点が含まれるアクティビティ数を求める。
			// 【クエリ修正】得点が出力されていないSCO数が含まれているので変更しました 2006/02/21 NTT-R m.kitahara
			StringBuffer query = new StringBuffer();
			//query.append( "SELECT count(*)"
			// 				+ " as activityCount" );
			//query.append( " FROM (" );
			// =================================================================
			// アクティビティごとに正規化得点が含まれるレコード数を
			// 取得する内部クエリー
			//query.append(     "SELECT" );
			//query.append(     " " + ACTIVITYID + " as " + ACTIVITYID );
			//query.append(     ",count(" + SCALED_SCORE + ")"
			//					+ " as " + SCALED_SCORE );
			//query.append(     " FROM " + TABLE_NAME );
			//query.append(     " WHERE " + USERID + "='" + userID + "'" );
			//query.append(     " AND " + LOID + "='" + loID + "'" );
			//query.append(     " AND " + SESSIONID + "='" + sessionID + "'" );
			//query.append(     " GROUP BY " + ACTIVITYID );
			//query.append( ") sca" );

			query.append( "SELECT COUNT(DISTINCT\"activityid\") AS activityCount" );
			query.append( " FROM Scorm_Attempt" );
			query.append( " WHERE UserID='" + userID + "'" );
			query.append( " AND LOID='" + loID + "'" );
			query.append( " AND ScaledScore IS NOT NULL" );

			////////////////////////////////////////////////////////////////////
			// クエリー発行
			String queryString = query.toString();
			DebugLog.write( ScormAttemptDataAccess.class,
				queryString, DebugLog.MID);
			resultSet = dataAccess.executeQuery(queryString);
			////////////////////////////////////////////////////////////////////
			// レコード取得
			// 取得した回数に100を掛けた値を満点とする。
			if (resultSet.next()) {
				totalFullSocre = resultSet.getInt("activityCount");
				totalFullSocre *= 100;
			}
			// tryブロックの最後まで到達したら成功扱い。
			successFlag = true;
		}
		catch (SQLException e) {
			DebugLog.write(ScormAttemptDataAccess.class, e, DebugLog.HIGHT);
			throw new LOException(e.getMessage());
		}
		finally {
			// 結果セットのクローズ
			// 例外が発生した場合、いままで例外がなかったときにみスロー。
			if (resultSet != null) {
				try {
					resultSet.close();
				}
				catch (SQLException e) {
					DebugLog.write(ScormAttemptDataAccess.class,
						e, DebugLog.HIGHT);
					if (successFlag) {
						throw new LOException(e.getMessage());
					}
				}
			}
		}

		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"HEAD getTotalFullScore("
				+ dataAccess + "," + userID
				+ "," + loID + "," + sessionID + ")"
				+ " return " + totalFullSocre,
			DebugLog.ROW);
		return totalFullSocre;
	}

	/**
	 * 最新の得点の合計値を求めます。<br>
	 *
	 * @param dataAccess データアクセス・オブジェクト。
	 * @param userID ユーザID。
	 * @param loID LOID。
	 * @param sessionID セッションID（起動回数）。
	 * @return 指定されたユーザID、LOID、セッションIDに該当するレコードから、
	 *          正規化得点が存在するアクティビティ回数に100を掛けた値を戻します。
	 * @throws LOException データベースアクセスに失敗した場合。
	 */
	public static double getTotalLatestScore(
		DataAccess dataAccess,
		String userID, String loID, String sessionID) throws LOException {
		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL getTotalLatestScore("
				+ dataAccess + "," + userID
				+ "," + loID + "," + sessionID + ")",
			DebugLog.ROW);

		double totalLatestSocre = 0.0;
		ResultSet resultSet = null;
		boolean successFlag = false;
		try {
			////////////////////////////////////////////////////////////////////
			// クエリー文の生成
			// =================================================================
			// 指定されたユーザID、LOID、セッションIDに一致するレコードのうち
			// アクティビティ別（＋ユーザID別、LOID別、セッションID別）に、
			// 試行回数、Learnセッション回数が最大値を求め、
			// それぞれが一致するレコードのみを取得し、
			// 該当するレコードの正規化得点の合計値を求めます。
			StringBuffer query = new StringBuffer();
			query.append("SELECT");
			// 正規化得点の合計値
			query.append(" SUM(sca." + SCALED_SCORE + ")"
							+ " as totalScore");
			query.append(" FROM " + TABLE_NAME + " sca");
			query.append(" INNER JOIN");
			// =================================================================
			// SCOごとの試行回数の中でLearnセッション回数最大となる
			// レコードを検索する内部クエリー
			query.append("(");
			query.append(    "SELECT");
			query.append(    " sca1." + USERID + " as " + USERID);
			query.append(    ",sca1." + LOID + " as " + LOID);
			query.append(    ",sca1." + ACTIVITYID + " as " + ACTIVITYID);
			query.append(    ",sca1." + SESSIONID + " as " + SESSIONID);
			query.append(    ",sca1." + ATTEMPT_COUNT + " as " + ATTEMPT_COUNT);
			query.append(    ",max(sca1." + LEARN_SESSION_COUNT + ")"
									+ " as " + LEARN_SESSION_COUNT);
			query.append(    " FROM " + TABLE_NAME + " sca1");
			query.append(    " INNER JOIN");
			query.append(    "(");
			// SCOごとの試行回数最大値を取得する内部クエリー
			query.append(        "SELECT");
			query.append(        " " + USERID + " as " + USERID);
			query.append(        "," + LOID + " as " + LOID);
			query.append(        "," + ACTIVITYID + " as " + ACTIVITYID);
			query.append(        "," + SESSIONID + " as " + SESSIONID);
			query.append(        ",max(" + ATTEMPT_COUNT + ")"
										+ " as " + ATTEMPT_COUNT);
			query.append(        " FROM " + TABLE_NAME);
			query.append(        " WHERE " + USERID + "='" + userID + "'");
			query.append(        " AND " + LOID + "='" + loID + "'");
			query.append(        " AND " + SESSIONID + "='" + sessionID + "'");
			query.append(        " GROUP BY");
			query.append(        " " + USERID);
			query.append(        "," + LOID);
			query.append(        "," + ACTIVITYID);
			query.append(        "," + SESSIONID);
			query.append(    ") lsa1");
			// SCOごとの試行回数最大値を取得する内部クエリーとの結合
			query.append(    " ON sca1." + USERID + "=lsa1." + USERID);
			query.append(    " AND sca1." + LOID
									+ "=lsa1." + LOID);
			query.append(    " AND sca1." + SESSIONID
									+ "=lsa1." + SESSIONID);
			query.append(    " AND sca1." + ACTIVITYID
									+ "=lsa1." + ACTIVITYID);
			query.append(    " AND sca1." + ATTEMPT_COUNT
									+ "=lsa1." + ATTEMPT_COUNT);
			query.append(    " GROUP BY");
			query.append(    " sca1." + USERID);
			query.append(    ",sca1." + LOID);
			query.append(    ",sca1." + ACTIVITYID);
			query.append(    ",sca1." + SESSIONID);
			query.append(    ",sca1." + ATTEMPT_COUNT);
			query.append(") lsa");
			// =================================================================
			// 内部クエリーとの結合条件
			query.append(" ON sca." + USERID + "=lsa." + USERID);
			query.append(" AND sca." + LOID
								+ "=lsa." + LOID);
			query.append(" AND sca." + SESSIONID
								+ "=lsa." + SESSIONID);
			query.append(" AND sca." + ACTIVITYID
								+ "=lsa." + ACTIVITYID);
			query.append(" AND sca." + ATTEMPT_COUNT
								+ "=lsa." + ATTEMPT_COUNT);
			query.append(" AND sca." +  LEARN_SESSION_COUNT
								+ "=lsa." + LEARN_SESSION_COUNT);
			////////////////////////////////////////////////////////////////////
			// クエリー発行
			String queryString = query.toString();
			DebugLog.write( ScormAttemptDataAccess.class,
				queryString, DebugLog.MID);
			resultSet = dataAccess.executeQuery(queryString);
			////////////////////////////////////////////////////////////////////
			// レコード取得
			// 取得した得点は正規化された値なので100掛けする。
			if (resultSet.next()) {
				totalLatestSocre = resultSet.getDouble("totalScore");
				totalLatestSocre *= 100.0;
			}
			// tryブロックの最後まで到達したら成功扱い。
			successFlag = true;
		}
		catch (SQLException e) {
			DebugLog.write(ScormAttemptDataAccess.class, e, DebugLog.HIGHT);
			throw new LOException(e.getMessage());
		}
		finally {
			// 結果セットのクローズ
			// 例外が発生した場合、いままで例外がなかったときにみスロー。
			if (resultSet != null) {
				try {
					resultSet.close();
				}
				catch (SQLException e) {
					DebugLog.write(ScormAttemptDataAccess.class,
						e, DebugLog.HIGHT);
					if (successFlag) {
						throw new LOException(e.getMessage());
					}
				}
			}
		}

		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL getTotalLatestScore("
				+ dataAccess + "," + userID
				+ "," + loID + "," + sessionID + ")"
				+ " return " + totalLatestSocre,
			DebugLog.ROW);
		return totalLatestSocre;
	}

	/**
	 * 指定されたユーザ、教材の組み合わせのログを削除します。
	 * @param dataAccess データアクセス・オブジェクト。
	 * @param userID 削除対象のユーザID。
	 * @param loID 削除対象の教材のLOID。
	 * @throws LOException データベースアクセス中に例外が発生した場合。
	 */
	public static void delete(
		DataAccess dataAccess, String userID, String loID)
		throws LOException {

		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"HEAD delete(" + dataAccess + "," + userID + "," + loID + ")",
			DebugLog.ROW);
		try {
			// WHERE句の生成
			StringBuffer queryWhere = new StringBuffer();
			if (loID != null) {
				queryWhere.append(" and " + LOID + "='" + loID + "'" );
			}
			if (userID != null) {
				queryWhere.append(" and " + USERID + "='" + userID + "'" );
			}
			// 削除クエリの生成
			StringBuffer query = new StringBuffer();
			query.append("delete from " + TABLE_NAME );
			if (queryWhere.length() > 0) {
				query.append(" where " + queryWhere.substring(5) );
			}
			// 削除クエリの実行
			String queryString = query.toString();
			DebugLog.write( ScormAttemptDataAccess.class,
				queryString, DebugLog.MID);
			dataAccess.execute(queryString);
		}
		catch (SQLException e) {
			DebugLog.write(ScormAttemptDataAccess.class,
				e, DebugLog.HIGHT);
			throw new LOException(e.getMessage());
		}
		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL delete(" + dataAccess + "," + userID + "," + loID + ")",
			DebugLog.ROW);
	}


	/**
	 * Learnセッション回数最大値を取得します。<br>
	 * 指定したユーザID、LOID、学習回数の組み合わせで、
	 * アクティビティ別に最大試行回数の最大Learnセッション回数を
	 * 文字列の２次元配列として戻します。
	 * 該当するレコードが存在しない場合、要素数０の配列を戻します。
	 * <br>
	 * @param dataAccess データアクセスオブジェクト。
	 * @param userID ユーザID。
	 * @param loID LOID。
	 * @param studySession 学習回数（開始−終了で１単位の回数）
	 * @return 以下の１次元文字列配列を要素とする配列を戻します。
	 * <table border="1">
	 * 	<tr>
	 * 		<th>インデックス</th>
	 * 		<th>値</th>
	 * 	</tr>
	 * 	<tr>
	 * 		<td align="right">0</td>
	 * 		<td>アクティビティID</td>
	 * 	</tr>
	 * 	<tr>
	 * 		<td align="right">1</td>
	 * 		<td>同じアクティビティの中で最大の試行回数</td>
	 * 	</tr>
	 * 	<tr>
	 * 		<td align="right">2</td>
	 * 		<td>
	 * 			同じアクティビティの中で最大の試行回数の中の
	 * 			最大のLearnセッション回数
	 * 		</td>
	 * 	</tr>
	 * </table>
	 * <br>
	 * @throws LOException 処理（データベースアクセス）中にエラーが発生した場合。
	 */
	public static String[][] getMaxLearnSessionCount(
			DataAccess dataAccess, String userID,
			String loID, int studySession)
			throws LOException {

		// メソッド開始ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"HEAD getMaxLearnSessionCount("
				+ dataAccess + "," + userID
				+ "," + loID + "," + studySession + ")",
			DebugLog.ROW);

		// このメソッドの戻り値
		String[][] matrix = null;
		// クエリ結果セット
		ResultSet resultSet = null;
		// tryブロック内に例外が発生していないか示すフラグ（true＝例外なし）
		boolean successFlag = false;
		try {
			////////////////////////////////////////////////////////////////////
			// クエリ文の生成
			StringBuffer query = new StringBuffer();
			query.append("select");
			// アクティビティID
			query.append(" a." + ACTIVITYID + " as " + ACTIVITYID);
			// 最大試行回数
			query.append(",a." + ATTEMPT_COUNT + " as " + ATTEMPT_COUNT);
			// その中の最大Learnセッション回数
			query.append(",max(a." + LEARN_SESSION_COUNT + ")"
							+ " as " + LEARN_SESSION_COUNT);
			query.append(" from " + TABLE_NAME + " a");
			query.append(" inner join (");
			// =================================================================
			// 最大試行回数を取得するためのサブクエリ
			query.append(	"select");
			query.append(	" " + USERID + " as " + USERID);
			query.append(	"," + LOID + " as " + LOID);
			query.append(	"," + STUDY_SESSION_COUNT);
			query.append(			" as " + STUDY_SESSION_COUNT);
			query.append(	"," + ACTIVITYID + " as " + ACTIVITYID);
			query.append(	",max(" + ATTEMPT_COUNT + ") as " + ATTEMPT_COUNT);
			query.append(	" from " + TABLE_NAME);
			// サブクエリでの条件
			// 指定されたユーザID、LOID、学習回数と一致するレコード
			query.append(	" where " + USERID + "='" + userID + "'");
			query.append(	" and " + LOID + "='" + loID + "'");
			query.append(	" and " + STUDY_SESSION_COUNT );
			query.append(		"=" + studySession );
			// サブクエリでmax(AttemptCount)を使用するためのgroup by句
			query.append(	" group by ");
			query.append(	" " + USERID);
			query.append(	"," + LOID);
			query.append(	"," + STUDY_SESSION_COUNT);
			query.append(	"," + ACTIVITYID);
			query.append(") b");
			// =================================================================
			// サブクエリとの結合条件
			// ユーザID、LOID、学習回数、アクティビティIDが一致して、
			// 試行回数が最大値のレコード
			query.append(" on a." + USERID + "=b." + USERID );
			query.append(" and a." + LOID + "=b." + LOID );
			query.append(" and a." + STUDY_SESSION_COUNT );
			query.append(		"=b." + STUDY_SESSION_COUNT );
			query.append(" and a." + ACTIVITYID + "=b." + ACTIVITYID );
			query.append(" and a." + ATTEMPT_COUNT + "=b." + ATTEMPT_COUNT );
			// =================================================================
			// where句
			// 指定されたユーザID、LOID、学習回数と一致するレコード
			query.append(" where a." + USERID + "='" + userID + "'");
			query.append(" and a." + LOID + "='" + loID + "'");
			query.append(" and a." + STUDY_SESSION_COUNT );
			query.append(		"=" + studySession );
			// =================================================================
			// max(LearnSessionCount)を使用するためのgroup by句
			query.append(" group by");
			query.append(" a." + ACTIVITYID);
			query.append(",a." + ATTEMPT_COUNT);
			////////////////////////////////////////////////////////////////////
			// クエリ発行
			String queryString = query.toString();
			DebugLog.write( ScormAttemptDataAccess.class,
				queryString, DebugLog.MID);
			resultSet = dataAccess.executeQuery(queryString);
			////////////////////////////////////////////////////////////////////
			// クエリ結果のリスト化
			List list = new ArrayList();
			while (resultSet.next()) {
				String[] record = new String[3];
				record[0] = resultSet.getString(ACTIVITYID).trim();
				record[1] = resultSet.getString(ATTEMPT_COUNT);
				record[2] = resultSet.getString(LEARN_SESSION_COUNT);

				list.add(record);
			}
			//リストを配列化
			matrix = new String[list.size()][];
			list.toArray(matrix);

			// tryブロック最後まで到達したのでフラグをtrueに変更
			successFlag = true;
		}
		catch (SQLException e) {
			DebugLog.write(ScormAttemptDataAccess.class,
				e, DebugLog.HIGHT);
			throw new LOException(e.getMessage());
		}
		finally {
			// 結果セットのクローズ
			if (resultSet != null) {
				try {
					resultSet.close();
				}
				catch (SQLException e) {
					DebugLog.write(ScormAttemptDataAccess.class,
						e, DebugLog.HIGHT);
					// tryブロックにて例外が発生しなければ、スロー
					if (successFlag) {
						throw new LOException(e.getMessage());
					}
				}
			}
		}
		// メソッド終了ログ
		DebugLog.write(
			ScormAttemptDataAccess.class,
			"TAIL getMaxLearnSessionCount("
				+ dataAccess + "," + userID
				+ "," + loID + "," + studySession + ")",
			DebugLog.ROW);
		return matrix;
	}
}
