Dapper - omoisan-blog

参考

Dapperのかるーい話し from Takuya Shibata

www.slideshare.net

ADO.NETとORMとMicro-ORM －dapper dot netを使ってみた from Narami Kiyokura

Dapper.Netを使ってみる - けさらんぱさらん

dapper helper class

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DappetTest
{
    public class DapperHelper
    {
        /// <summary>
        /// コネクション
        /// </summary>
        SqlConnection connection;

        /// <summary>
        /// コネクション
        /// </summary>
        public SqlConnection Connection
        {
            get
            {
                return connection;
            }
        }

        /// <summary>
        /// コンストラクタ
        /// </summary>
        public DapperHelper()
        {
            this.connection = new SqlConnection(ConfigurationManager.AppSettings["ConnectionString"].ToString());
        }

    }
}

dapper sample code

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Dapper;

namespace DappetTest
{
    class Program
    {

        class Member
        {
            public int ID;
            public string Name;
            public string Sex;
        }

        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("==================== start");

                // -------------------- select
                using (SqlConnection cn = new DapperHelper().Connection)
                {
                    cn.Open();

                    // 単
                    dynamic obj = cn.Query("select * from members order by id").FirstOrDefault();
                    Console.WriteLine(obj.id + " - "+ obj.name);

                    // 複数
                    var list = cn.Query("select * from members where id < 3").ToList();
                    list.ForEach(m => {
                        Console.WriteLine(m.id + "/"+ m.name);
                    });

                    // マッピング
                    var memlist = cn.Query<Member>("select id,name,sex from members　where id < 3").ToList();
                    memlist.ForEach(m => {
                        Console.WriteLine(m.ID + "/" + m.Name + "/" + m.Sex);
                    });


                    // マッピング-パラメータあり
                    var wmlist = cn.Query<Member>("select id,name,sex from members　where id < @id", new { id=3 }).ToList();
                    wmlist.ForEach(m => {
                        Console.WriteLine(m.ID + "/" + m.Name + "/" + m.Sex);
                    });

                    cn.Close();
                }

                // -------------------- count
                using (var cn = new DapperHelper().Connection)
                {
                    cn.Open();
                    Console.WriteLine("count:" + cn.ExecuteScalar<int>("select count(*) from members"));
                }

                // -------------------- insert
                using (var cn = new DapperHelper().Connection)
                {
                    cn.Open();
                    using (SqlTransaction trn = cn.BeginTransaction())
                    {
                        try
                        {
                            cn.Execute("insert into members(name, sex) values (@name,@sex)",
                                new { name = "saito", sex = "1" },
                                trn);

                            trn.Commit();
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.ToString());
                            trn.Rollback();
                        }
                    }
                }

                // -------------------- update
                using (var cn = new DapperHelper().Connection)
                {
                    cn.Open();
                    using (SqlTransaction trn = cn.BeginTransaction())
                    {
                        try
                        {
                            cn.Execute("update members set name=@name, sex=@sex where id=@id",
                                new { name = "nomura", sex = "1", id=3 },
                                trn);

                            trn.Commit();
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.ToString());
                            trn.Rollback();
                        }
                    }
                }

                // -------------------- delete
                using (var cn = new DapperHelper().Connection)
                {
                    cn.Open();
                    using (SqlTransaction trn = cn.BeginTransaction())
                    {
                        try
                        {
                            cn.Execute("delete from  members where id=@id",
                                new { name = "nomura", sex = "1", id = 11 },
                                trn);

                            trn.Commit();
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.ToString());
                            trn.Rollback();
                        }
                    }
                }

                Console.WriteLine("==================== end");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            Console.WriteLine("");
            Console.WriteLine("press any key to exit...");
            Console.ReadKey();
        }
    }
}

dbaccess

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Dapper;

namespace common.util
{
    /// <summary>
    /// DbAccessクラス
    /// </summary>
    public class DbAccess : IDisposable
    {
        #region 変数・プロパティ

        /// <summary>
        /// コネクション
        /// </summary>
        private SqlConnection _connection = null;

        /// <summary>
        /// コネクション
        /// </summary>
        public SqlConnection Cnn
        {
            get
            {
                return _connection;
            }
        }

        /// <summary>
        /// トランザクション
        /// </summary>
        private SqlTransaction _transaction = null;

        /// <summary>
        /// トランザクション
        /// </summary>
        public SqlTransaction Trn
        {
            get
            {
                return _transaction;
            }
        }

        /// <summary>
        /// コミット済みフラグ
        /// </summary>
        private bool _commited = false;

        /// <summary>
        /// ロールバック済みフラグ
        /// </summary>
        private bool _rollbacked = false;

        /// <summary>
        /// Disposedフラグ
        /// </summary>
        private bool _disposed = false;

        #endregion


        /// <summary>
        /// コンストラクタ
        /// </summary>
        public DbAccess()
        {
            string constr = ConfigurationManager.ConnectionStrings["DBConnectionString"].ToString();
            this._connection = new SqlConnection(constr);
            this._connection.Open();
        }


        /// <summary>
        /// コンストラクタ
        /// </summary>
        public DbAccess(string constr)
        {
            this._connection = new SqlConnection(constr);
            this._connection.Open();
        }


        /// <summary>
        /// リソースを開放
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }


        /// <summary>
        /// リソースを開放
        /// </summary>
        private void Dispose(bool disposing)
        {
            if (!this._disposed)
            {
                if (disposing)
                {
                    if (this._transaction != null)
                    {
                        if (!this._commited)
                        {
                            if (!this._rollbacked)
                            {
                                this._rollbacked = true;
                                this._transaction.Rollback();
                            }
                        }

                        this._transaction.Dispose();
                        this._transaction = null;
                    }

                    if (this._connection != null)
                    {
                        this._connection.Close();
                        this._connection.Dispose();
                        this._connection = null;
                    }
                }
            }

            this._disposed = true;
        }


        /// <summary>
        /// 
        /// </summary>
        ~DbAccess()
        {
            this.Dispose(false);
        }

        /// <summary>
        /// トランザクション処理を開始
        /// </summary>
        public void BeginTransaction(IsolationLevel isolationLevel)
        {
            this._transaction = this._connection.BeginTransaction(isolationLevel);
        }

        /// <summary>
        /// トランザクション処理を開始
        /// </summary>
        public void BeginTransaction()
        {
            this._transaction = this._connection.BeginTransaction();
        }


        /// <summary>
        /// トランザクション処理をコミット
        /// </summary>
        public void Commit()
        {
            if (this._transaction != null)
            {
                if (!this._commited)
                {
                    this._commited = true;
                    this._transaction.Commit();
                }
            }
        }


        /// <summary>
        /// トランザクション処理をロールバック
        /// </summary>
        public void Rollback()
        {
            if (this._transaction != null)
            {
                this._rollbacked = true;
                this._transaction.Rollback();
            }
        }


        /// <summary>
        /// Like用エスケープ処理
        /// </summary>
        /// <param name="text">対象文字列</param>
        /// <returns>エスケープ結果</returns>
        public static string LikeEscapeString(string text)
        {
            return Regex.Replace(text, @"[%_\[]", "[$0]");
        }

        /// <summary>
        /// スペースを削除
        /// </summary>
        public string q(string sql)
        {
            return sql.Replace("    ", " ");
        }

    }
}

public xxxxResponse AssignCourse(xxxxRequest req)
{
    using (DbAccess dba = new DbAccess())
    {
        dba.BeginTransaction();

        // db 処理

        // 結果を確定
        dba.Commit();
        return new xxxxResponse { Status = (int)HttpStatusCode.OK };
    }
}

----------
using Dapper;

namespace api.app.repositories
{
    public class xxCourseRepository : xxICourseRepository
    {
        public CourseQuestionModel FindCoureQuestion(DbAccess dba, string courseID)
        {
            return new CourseQuestion(courseID).FindCourseQuestion();
        }

        public bool IsAssignedCourse(DbAccess dba, string courseID, int studentID)
        {
            int count = dba.Cnn.ExecuteScalar<int>(dba.q(@"
                select 
                    count(学習者ID)
                from 
                    学習者選択コース 
                where 
                    学習者ID = @学習者ID
                    and 
                    コースID = @コースID 
                    and 
                    状態コード = 0
            "), new {
                学習者ID = studentID,
                コースID = courseID
            }, dba.Trn);

            if (count > 0)
            {
                return true;
            }

            return false;
        }

        public int AssignCourse(DbAccess dba, AssignStudentSelectCourseModel model)
        {
            int totalCount = 0;

            foreach (var st in model.Students)
            {
                int count = dba.Cnn.Execute(dba.q(@"
                    IF EXISTS(SELECT コースid FROM 学習者選択コース WHERE コースid = @コースID AND 学習者id = @学習者ID AND 状態コード <> 0) 
                      UPDATE 
                        学習者選択コース 
                      SET 
                        契約id = @契約ID, 
                        受講開始日 = @受講開始日, 
                        受講期限 = @受講期限, 
                        閲覧期限 = @閲覧期限, 
                        状態コード = 0 
                      WHERE  
                        コースid = @コースID 
                        AND 
                        学習者id = @学習者ID 
                    ELSE 
                      INSERT INTO 学習者選択コース 
                        (
                         コースid, 
                         学習者id, 
                         契約id, 
                         受講開始日, 
                         受講期限, 
                         閲覧期限 
                         ) 
                      VALUES
                        (
                         @コースID, 
                         @学習者ID, 
                         @契約ID, 
                         @受講開始日, 
                         @受講期限, 
                         @閲覧期限
                         ) 
                    "), new {
                    コースID = model.CourseID,
                    学習者ID = st.StudentID,
                    契約ID = model.ContractID,
                    受講開始日 = model.LearningStartDate,
                    受講期限 = model.LearningDeadlineDate,
                    閲覧期限 = model.ViewingDeadlineDate,
                }, dba.Trn);

                totalCount += count;
            }

            return totalCount;
        }

        public int UnAssignCourse(DbAccess dba, AssignStudentSelectCourseModel model)
        {
            return dba.Cnn.Execute(dba.q(@"
                update 学習者選択コース
                set
                    状態コード = 2
                where
                    コースID = @コースID
                    and
                    学習者ID in @学習者IDリスト

                "), new
            {
                コースID = model.CourseID,
                学習者IDリスト = new List<int>(model.Students.Select(a => a.StudentID))

            }, dba.Trn);
        }

        public int UpdateLearningDateCourse(DbAccess dba, AssignStudentSelectCourseModel model)
        {
            return dba.Cnn.Execute(dba.q(@"
                      UPDATE 
                        学習者選択コース 
                      SET 
                        受講開始日 = @受講開始日, 
                        受講期限 = @受講期限, 
                        閲覧期限 = @閲覧期限
                      WHERE  
                        コースid = @コースID 
                        AND 
                        学習者id in @学習者IDリスト
                    "), new
                {
                    コースID = model.CourseID,
                    学習者IDリスト = new List<int>(model.Students.Select(a => a.StudentID)),
                    受講開始日 = model.LearningStartDate,
                    受講期限 = model.LearningDeadlineDate,
                    閲覧期限 = model.ViewingDeadlineDate
                }, dba.Trn);

        }


        public int ReduceAssignedCourse(DbAccess dba, int studentID, int reduceCount)
        {
            return dba.Cnn.Execute(dba.q(@"
                UPDATE 
                  学習者 
                SET
                  選択可能コース数 = 選択可能コース数 - @ReduceCount, 
                  最終更新日 = GETDATE()
                WHERE  
                  学習者id = @学習者ID 
                  AND 
                  選択可能コース数 IS NOT NULL "
                ),new {
                    学習者ID = studentID,
                    ReduceCount = reduceCount
                }, dba.Trn);
        }

        public CourseLearningPeriodModel FindCourseLearningDate(DbAccess dba, int contractID, string courseID)
        {
            return dba.Cnn.Query<CourseLearningPeriodModel>(dba.q(@"
                SELECT 
                    T_CM.受講期限 as LearningPeriod,  
                    T_CM.閲覧期間 as ViewingPeriod
                FROM   
                    契約 AS T_CON, 
                    コースマスタ AS T_CM 
                WHERE  
                    T_CON.契約id = @契約ID 
                    AND T_CON.削除 = 0 
                    AND T_CM.コースid = @コースID 
                    AND T_CM.削除 = 0 
                "), new {
                    契約ID = contractID,
                    コースID = courseID
                }, dba.Trn).FirstOrDefault();
        }

        public bool ExistAnswer(DbAccess dba, string courseID, int studentID)
        {
            int count = dba.Cnn.ExecuteScalar<int>(dba.q(@"
                    SELECT 
                        count(コースid) 
                    FROM 
                        学習者選択コース 
                    WHERE 
                        コースid = @コースID 
                        AND 
                        学習者id = @学習者ID 
                        AND 
                        状態コード = 0
            "), new {
                コースID = courseID,
                学習者ID = studentID
            }, dba.Trn);

            if (count  > 0)
            {
                return true;
            }

            return false;
        }

        public int? FindContractID(DbAccess dba, string courseID)
        {
            return dba.Cnn.ExecuteScalar<int?>(dba.q(@"
                select  
                  契約ID
                from 
                  契約コース
                where 
                  コースID = @コースID
                  and
                  削除 = 0
            "), new {
                コースID = courseID
            }, dba.Trn);
        }

        public long CreateCourseSequence(DbAccess dba)
        {
            return dba.Cnn.ExecuteScalar<long>(dba.q(@"
                select next value for dbo.course_sequence;       
            "), null, dba.Trn);
        }

        public long CreatePageSequence(DbAccess dba)
        {
            return dba.Cnn.ExecuteScalar<long>(dba.q(@"
                select next value for dbo.page_sequence;       
            "), null, dba.Trn);
        }


        public int CopyCourse(DbAccess dba, string originalCourseID, string newCourseID, string newCourseName)
        {
            return dba.Cnn.Execute(dba.q(@"
                insert into コースマスタ 
                (
                   コースID
                  ,コース名
                  ,受講期限
                  ,削除
                  ,最終更新日
                  ,コース種別コード
                  ,閲覧期間
                  ,修了証書発行フラグ
                  ,ホットライン添付ファイル数
                  ,終了間近日数
                  ,修了証書識別子
                  ,コース開講日
                  ,販売中止日
                  ,対応プラットフォーム
                  ,公開日
                  ,SCORMフラグ
                  ,印刷フラグ
                  ,受講期限延長フラグ
                  ,ページビュー数の表示フラグ
                  ,学習時間の表示フラグ
                  ,修了証書種類
                )
                select 
                   @新コースID
                  ,@新コース名
                  ,受講期限
                  ,削除
                  ,GETDATE()
                  ,コース種別コード
                  ,閲覧期間
                  ,修了証書発行フラグ
                  ,ホットライン添付ファイル数
                  ,終了間近日数
                  ,修了証書識別子
                  ,コース開講日
                  ,販売中止日
                  ,対応プラットフォーム
                  ,公開日
                  ,SCORMフラグ
                  ,印刷フラグ
                  ,受講期限延長フラグ
                  ,ページビュー数の表示フラグ
                  ,学習時間の表示フラグ
                  ,修了証書種類
                from
                  コースマスタ
                where
                  コースID = @コピー元コースID
            "), new {
                @コピー元コースID = originalCourseID,
                @新コースID = newCourseID,
                @新コース名 = newCourseName 
            }, dba.Trn);
        }

        public CourseMasterModel FindCourseMaster(DbAccess dba, string courseID)
        {
            var model = dba.Cnn.Query<CourseMasterModel>(dba.q(@"
                select
                   コースID as CourseID
                  ,コース名 as CourseName
                  ,受講期限 as LearningPeriod
                  ,削除 as DeleteFlag
                  ,コース種別コード as CourseTypeCode 
                  ,閲覧期間 as ViewingPeriod
                  ,修了証書発行フラグ as CertificateIssueFlag
                  ,ホットライン添付ファイル数 as HotlineAttachmentFileCount
                  ,終了間近日数 as DaysCloseToEnd
                  ,修了証書識別子 as CertificateIdentifier
                  ,コース開講日 as CourseStartDate
                  ,販売中止日 as DiscontinuationDate
                  ,対応プラットフォーム as TargetPlatform
                  ,公開日 as ReleaseDate
                  ,SCORMフラグ as ScormFlag
                  ,印刷フラグ as PrintFlag
                  ,受講期限延長フラグ as DeadlineExtensionFlag
                  ,ページビュー数の表示フラグ as DisplayFlagOfPageViewNumber 
                  ,学習時間の表示フラグ as DisplayFlagOfLearningTime
                  ,修了証書種類 as CertificateType
                  ,最終更新日 as UpdatedAt 
                from 
                  コースマスタ
                where
                  コースID = @コースID
                  and
                  削除 = 0

            "), new {
                コースID = courseID
            }, dba.Trn).FirstOrDefault();

            return model;
        }

        public int DeleteCourseMaster(DbAccess dba, string courseID)
        {
            return dba.Cnn.Execute(dba.q(@"
                update コースマスタ
                set 
                  削除 = 1,
                  最終更新日 = GETDATE()  
                where
                  コースID = @コースID
            "), new {
                コースID = courseID
            }, dba.Trn);
        }

        public List<AssignStudentModel> FindAssignStudent(DbAccess dba, AssignStudentSelectCourseModel model)
        {
            var asList = dba.Cnn.Query<AssignStudentModel>(dba.q(@"
                select 
                  st.ユーザID as UserID,
                    sc.受講終了 as LearningEndFlag,
                    sc.受講開始日 as LearningStartDate,
                    sc.受講期限 as LearningDeadlineDate,
                    sc.受講修了日 as LearningCompletionDate,
                    sc.閲覧期限 as ViewingDeadlineDate
                from 
                    学習者選択コース as sc
                  inner join 学習者 as st on sc.学習者ID = st.学習者ID
                where 
                    コースID=@コースID
                  and
                  状態コード = 0
                    and 
                    sc.学習者ID in @ユーザIDリスト
            "), new {
                コースID = model.CourseID, 
                ユーザIDリスト = new List<int>(model.Students.Select(a => a.StudentID))
            }, dba.Trn).ToList<AssignStudentModel>();

            return asList;
        }


        public int? FindProviderCompanyID(DbAccess dba, int companyID)
        {
            return dba.Cnn.ExecuteScalar<int?>(dba.q(@"
                select 
                   distinct(pc.提供元企業ID)
                from 
                  提供元企業 as pc 
                  inner join 企業 as cmp on pc.提供元企業ID = cmp.提供元企業ID
                  inner join 企業担当者 as ca on cmp.企業ID = ca.企業ID
                where 
                  ca.企業ID = @企業ID
                    and
                    ca.削除 = 0
                    and
                    cmp.削除 = 0
            "), new {
                企業ID = companyID
            }, dba.Trn);
        }


        public int AddProviderCourse(DbAccess dba, int providerCompanyID, string courseID)
        {
            return dba.Cnn.Execute(dba.q(@"
                insert into 提供コース
                (
                  提供元企業id
                 ,コースid
                )
                values
                (
                  @提供元企業ID
                 ,@コースid
                )
            ") , new {
                提供元企業ID = providerCompanyID,
                コースID = courseID
            }, dba.Trn);
       }

        public int FindContractID(DbAccess dba)
        {
            return dba.Cnn.ExecuteScalar<int>(dba.q(@"
                select 
                    max(契約ID) + 1 AS ContractID 
                from 
                    契約

            "), null, dba.Trn);
        }


        public int AddContract(DbAccess dba, ContractModel model)
        {
            return dba.Cnn.Execute(dba.q(@"
                insert into 契約
                   (
　　　　　　　　　　　　契約ID
                   ,企業ID
                   ,企業担当者ID
                   ,契約種別コード
                   ,契約形態コード
                   ,取扱店ID
                   ,契約日
                   ,受講開始日
                   ,受講開始期限
                   ,利用権終了日
                   ,契約担当者ID
                   ,削除
                   ,最終更新日
                   ,クラスフラグ
                   ,クラス契約コース数
                   ,クラス契約学習者数
                   ,集合研修フラグ
                   ,自動コース割付フラグ
　　　　　　　　　 )
                values
                (
                    @契約ID
                   ,@企業ID
                   ,@企業担当者ID
                   ,@契約種別コード
                   ,@契約形態コード
                   ,@取扱店ID
                   ,GETDATE()
                   ,@受講開始日
                   ,@受講開始期限
                   ,@利用権終了日
                   ,@契約担当者ID
                   ,@削除
                   ,GETDATE()
                   ,@クラスフラグ
                   ,@クラス契約コース数
                   ,@クラス契約学習者数
                   ,@集合研修フラグ
                   ,@自動コース割付フラグ
                )
            "), new {
                契約ID = model.ContractID,
                企業ID = model.CompanyID,
                企業担当者ID = model.CompanyAdminID,
                契約種別コード = model.ContractTypeCode,
                契約形態コード = model.ContractFormCode,
                取扱店ID = model.DealerID,
                受講開始日 = model.LearningStartDate,
                受講開始期限 = model.LearningDeadlineDate,
                利用権終了日 = model.ViewingDeadlineDate,
                契約担当者ID = model.ContractChargePersonID,
                削除 = model.DeleteFlag,
                クラスフラグ = model.ClassFlag,
                クラス契約コース数 = model.ClassContractCourseCount,
                クラス契約学習者数 = model.ClassContractStudentCount,
                集合研修フラグ = model.CollectiveTrainingFlag,
                自動コース割付フラグ = model.AutomaticCourseAssignmentFlag

            }, dba.Trn);
        }

        public int AddContractCourse(DbAccess dba, ContractCourseModel model)
        {
            return dba.Cnn.Execute(dba.q(@"
                insert into 契約コース
                (
                   契約ID
                  ,コースID
                  ,契約コース数
                  ,削除
                  ,最終更新日
                )
                values
                (
                   @契約ID
                  ,@コースID
                  ,@契約コース数
                  ,@削除
                  ,GETDATE()
                )
            "), new
            {
                @契約ID = model.ContractID,
                @コースID = model.CourseID,
                @契約コース数 = model.ContractCourseCount,
                @削除 = model.DeleteFlag,
            }, dba.Trn);
        }

        public int UpdateCourse(DbAccess dba, string courseID, int targetPlatform, string certificateIdentifier)
        {
            return dba.Cnn.Execute(dba.q(@"
                update コースマスタ
                set 
                   対応プラットフォーム = @対応プラットフォーム
                  ,修了証書識別子 = @修了証書識別子
                  ,最終更新日 = GETDATE()
                where
                  コースID = @コースID
            "), new
            {
                コースID = courseID,
                対応プラットフォーム = targetPlatform,
                修了証書識別子 = certificateIdentifier
            }, dba.Trn);
        }

        public int UpdateCourseName(DbAccess dba, string courseID, string courseName)
        {
            return dba.Cnn.Execute(dba.q(@"
                update コースマスタ
                set 
                   コース名 = @コース名
                  ,最終更新日 = GETDATE()
                where
                  コースID = @コースID
            "), new
            {
                コースID = courseID,
                コース名 = courseName
            }, dba.Trn);
        }

        public bool ExistContractCourse(DbAccess dba, string courseID, int companyID)
        {
            int count = dba.Cnn.ExecuteScalar<int>(dba.q(@"
                select 
                  count(a.契約ID)
                from 
                  契約 as a 
                  inner join 契約コース as b on a.契約ID = b.契約ID
                where
                  a.企業ID = @企業ID
                  and b.コースID = @コースID
                  and a.削除 = 0
                  and b.削除 = 0
            "), new
            {
                コースID = courseID,
                企業ID = companyID
            }, dba.Trn);

            return count > 0;
        }

        public int MergeCourseUpdateInfo(DbAccess dba, string courseID, int updatedUserType, int updatedIdentificationUserID, long courseFileSize, string updatedUserID)
        {
            return dba.Cnn.Execute(dba.q(@"
                merge into コースマスタ追加情報 as a 
                using (select @CourseId) 
                    as b (CourseId)
                    on (
                        a.CourseId = b.CourseId
                    )
                when matched then
                    update set 
                        CourseId                    = @CourseId
                       ,UpdatedUserType             = @UpdatedUserType
                       ,UpdatedIdentificationUserId = @UpdatedIdentificationUserId
                       ,UpdatedUserId               = @UpdatedUserId
                       ,CourseFileSize              = @CourseFileSize
                       ,UpdatedAt                   = GETDATE()
                    
                when not matched then
                    insert (CourseId,  UpdatedUserType,  UpdatedIdentificationUserId,  UpdatedUserId,  CourseFileSize, UpdatedAt)
                    values (@CourseId, @UpdatedUserType, @UpdatedIdentificationUserId, @UpdatedUserId, @CourseFileSize, GETDATE());
                
            "), new
            {
                CourseId                    = courseID,
                UpdatedUserType             = updatedUserType,
                UpdatedIdentificationUserId = updatedIdentificationUserID,
                CourseFileSize              = courseFileSize,
                UpdatedUserId               = updatedUserID
            }, dba.Trn);

        }

        public int UpdateCourseTag(DbAccess dba, string courseID, List<string> tags)
        {
            // delete
            dba.Cnn.Execute(dba.q(@"
                delete from LearningContentsTag
                where
                    ContentType = 1
                    and
                    ContentID = @ContentID
                "), new {
                    ContentID = courseID
                }, dba.Trn);

            // insert
            int count = 0;
            foreach (var tag in tags)
            {
                int result = dba.Cnn.Execute(dba.q(@"
                    insert into LearningContentsTag 
                    values (
                         @Id
                        ,@ContentType
                        ,@ContentId
                        ,@Tag
                    )
                    "), new
                    {
                        Id          = Guid.NewGuid(),
                        ContentType = 1,
                        ContentID   = courseID,
                        Tag         = tag
                    }, dba.Trn);

                count += result;
            }

            return count;
        }

        public List<string> FindCourseTag(DbAccess dba, string courseID)
        {
            return dba.Cnn.Query<string>(dba.q(@"
                select
                    Tag
                from
                    LearningContentsTag
                where
                    ContentType = 1
                    and
                    ContentID = @ContentID
                "), new
            {
                ContentID = courseID
            }, dba.Trn).ToList();
        }

        public int AddCompanyRegistedCourseList(DbAccess dba, int companyID, string courseID)
        {
            return dba.Cnn.Execute(dba.q(@"
                insert into CompanyRegistedCourseList (
                            CompanyID
                           ,LectureItemType
                           ,LectureItemTextID
                           ,LectureItemNumberID
                           ,CreateDate
                           ,UpdateDate
                           ,DeleteFlag )
                     values (
                            @companyID 
                           ,1 
                           ,@courseID 
                           ,null 
                           ,GETDATE() 
                           ,GETDATE() 
                           ,0 )
                    "), new
            {
                companyID = companyID,
                courseID = courseID
            }, dba.Trn);
        }
    }
}