チェンジセット 1647 (default)


以下の違いを無視:
日時:
2024/05/28 12:44:10 (4ヵ月前)
更新者:
hizuya@…
ログメッセージ:
  • データファイルの SQL コマンド部分、およびサブクエリーにて変数を使用出来るようにした。
  • 比較用データファイルのテーブル定義部分で変数を使用出来るようにした。
場所:
framework/trunk
ファイル:
8個の追加
4個の更新

凡例:

未変更
追加
削除

  • framework/trunk/CoreLibrary/Sources/Data/DbDataOperator.cs

    r1646 r1647  
    5959 
    6060        /// <summary> 
     61        /// 変数を表す正規表現。 
     62        /// </summary> 
     63        private static readonly Regex VariableRegex 
     64            = new Regex( 
     65                @"\${(?<name>[^${:}]+)}", 
     66                RegexOptions.ExplicitCapture); 
     67 
     68        /// <summary> 
     69        /// SQLCMD 形式を含む変数を表す正規表現。 
     70        /// </summary> 
     71        private static readonly Regex Variable2Regex 
     72            = new Regex( 
     73                @"\$({(?<name>[^${:}]+)}|\((?<name>[^$(:)]+)\))", 
     74                RegexOptions.ExplicitCapture); 
     75 
     76 
     77        /// <summary> 
    6178        /// コマンドを実行し、その結果の一覧を返します。 
    6279        /// </summary> 
    … …  
    19081925                            if (line == null || line == "}}}") 
    19091926                            { 
    1910                                 affectedRows += ExecuteNonQuery(transaction, rawCommand.ToString()); 
     1927                                affectedRows += ExecuteNonQuery(transaction, ResolveVariable(Variable2Regex, rawCommand.ToString(), variables)); 
    19111928                                rawCommand = null; 
    19121929 
    … …  
    19942011        } 
    19952012 
     2013        /// MEMO: このメソッドは DbDataComparer.ResolveVariable と同じ実装 
     2014        /// <summary> 
     2015        /// 文字列中の変数を解決して返します。 
     2016        /// </summary> 
     2017        /// <param name="regex">変数にマッチする正規表現。グループ名 <c>name</c> を使用します。</param> 
     2018        /// <param name="value">文字列。</param> 
     2019        /// <param name="variables">変数名をキーとして埋め込む値を値としたディクショナリ。</param> 
     2020        /// <returns> 
     2021        /// 変数を解決した文字列。 
     2022        /// </returns> 
     2023        private static string ResolveVariable(Regex regex, string value, IDictionary<string, object> variables) 
     2024        { 
     2025            // 変数が未設定の場合や、変数の文字数に足りていない場合 
     2026            if (variables == null || value.Length < 4) 
     2027            { 
     2028                return value; 
     2029            } 
     2030 
     2031            return regex.Replace( 
     2032                value, 
     2033                delegate(Match match) 
     2034                { 
     2035                    string variableName = match.Groups["name"].Value; 
     2036                    object variableValue; 
     2037                    if (!variables.TryGetValue(variableName, out variableValue)) 
     2038                    { 
     2039                        throw new VariableNotFoundException(variableName, (string)null); 
     2040                    } 
     2041 
     2042                    return variableValue != null ? variableValue.ToString() : string.Empty; 
     2043                }); 
     2044        } 
     2045 
    19962046        /// <summary> 
    19972047        /// SQL 文を実行します。 
    … …  
    23412391            /// </summary> 
    23422392            private static readonly char[] ColumnSeparatorChars = { ColumnSeparatorChar }; 
    2343  
    2344             /// <summary> 
    2345             /// 変数を表す正規表現。 
    2346             /// </summary> 
    2347             private static readonly Regex VariableRegex 
    2348                 = new Regex( 
    2349                     @"\${(?<name>[^${:}]+)}", 
    2350                     RegexOptions.ExplicitCapture); 
    23512393 
    23522394            /// <summary> 
    … …  
    25852627                                if (column[column.Length - 1] == '`') 
    25862628                                { 
    2587                                     // 変数の解決はしない 
    2588                                     parameterValue = GetValue(transaction, column.Substring(1, column.Length - 2)); 
     2629                                    // 変数を解決してからクエリーとして実行 
     2630                                    parameterValue = GetValue(transaction, ResolveVariable(Variable2Regex, column.Substring(1, column.Length - 2), variables)); 
    25892631                                    break; 
    25902632                                } 
    … …  
    25942636                            default: 
    25952637                                // 変数の解決 
    2596                                 parameterValue = ResolveVariable(column, variables); 
     2638                                parameterValue = ResolveVariable(VariableRegex, column, variables); 
    25972639                                break; 
    25982640                        } 
    … …  
    26702712            } 
    26712713 
    2672             /// MEMO: このメソッドは DbDataComparer.TableQuery.ResolveVariable と同じ実装 
    2673             /// <summary> 
    2674             /// 文字列中の変数を解決して返します。 
    2675             /// </summary> 
    2676             /// <param name="value">文字列。</param> 
    2677             /// <param name="variables">変数名をキーとして埋め込む値を値としたディクショナリ。</param> 
    2678             /// <returns> 
    2679             /// 変数を解決した文字列。 
    2680             /// </returns> 
    2681             private static string ResolveVariable(string value, IDictionary<string, object> variables) 
    2682             { 
    2683                 // 変数が未設定の場合や、変数の文字数に足りていない場合 
    2684                 if (variables == null || value.Length < 4) 
    2685                 { 
    2686                     return value; 
    2687                 } 
    2688  
    2689                 return VariableRegex.Replace( 
    2690                     value, 
    2691                     delegate(Match match) 
    2692                     { 
    2693                         string variableName = match.Groups["name"].Value; 
    2694                         object variableValue; 
    2695                         if (!variables.TryGetValue(variableName, out variableValue)) 
    2696                         { 
    2697                             throw new VariableNotFoundException(variableName, (string)null); 
    2698                         } 
    2699  
    2700                         return variableValue != null ? variableValue.ToString() : string.Empty; 
    2701                     }); 
    2702             } 
    2703  
    27042714            /// <summary> 
    27052715            /// 実行するクエリを準備します。 

  • framework/trunk/CoreTest/CoreTest.csproj

    r1645 r1647  
    383383    <EmbeddedResource Include="TestResources\Data\DbDataOperatorImportTest\34-VariableOnlyString-0-NoVariable.txt" /> 
    384384  </ItemGroup> 
     385  <ItemGroup> 
     386    <EmbeddedResource Include="TestResources\Data\DbDataOperatorImportTest\01-Append-0-TableQuery.txt" /> 
     387  </ItemGroup> 
     388  <ItemGroup> 
     389    <EmbeddedResource Include="TestResources\Data\DbDataOperatorImportTest\01-Append-0-TableQueryWithVariable.txt" /> 
     390  </ItemGroup> 
     391  <ItemGroup> 
     392    <EmbeddedResource Include="TestResources\Data\DbDataOperatorImportTest\62-SubQueryWithVariable-0.txt" /> 
     393    <EmbeddedResource Include="TestResources\Data\DbDataOperatorImportTest\62-SubQueryWithVariable-2.txt" /> 
     394  </ItemGroup> 
     395  <ItemGroup> 
     396    <EmbeddedResource Include="TestResources\Data\DbDataOperatorImportTest\82-CommandWithVariable-0.txt" /> 
     397    <EmbeddedResource Include="TestResources\Data\DbDataOperatorImportTest\82-CommandWithVariable-2.txt" /> 
     398  </ItemGroup> 
    385399  <Import Project="$(MSBuildThisFileDirectory)..\MSBuild.Common.targets" /> 
    386400</Project> 

  • framework/trunk/CoreTest/Sources/Data/DbDataOperatorImportTest.cs

    r1645 r1647  
    105105        [TestCase(@"61-SubQuery.txt", 0, 2, false, @"61-SubQuery-0.txt")] 
    106106        [TestCase(@"61-SubQuery.txt", 2, 2, false, @"61-SubQuery-2.txt")] 
     107        [TestCase(@"62-SubQueryWithVariable.txt", 0, 2, true, @"62-SubQueryWithVariable-0.txt")] 
     108        [TestCase(@"62-SubQueryWithVariable.txt", 2, 2, true, @"62-SubQueryWithVariable-2.txt")] 
    107109        [TestCase(@"71-MultiTable.txt", 0, 4, false, @"71-MultiTable-0.txt")] 
    108110        [TestCase(@"71-MultiTable.txt", 2, 4, false, @"71-MultiTable-2.txt")] 
    109111        [TestCase(@"81-Command.txt", 0, 2, false, @"81-Command-0.txt")] 
    110112        [TestCase(@"81-Command.txt", 2, 3, false, @"81-Command-2.txt")] 
     113        [TestCase(@"82-CommandWithVariable.txt", 0, 2, true, @"82-CommandWithVariable-0.txt")] 
     114        [TestCase(@"82-CommandWithVariable.txt", 2, 3, true, @"82-CommandWithVariable-2.txt")] 
    111115        public void TestImport(string importFileName, int initialRows, int affectedRows, bool useVariables, string expedtedDataFile) 
    112116        { 
    … …  
    177181        /// <param name="expedtedDataFile">結果のデータ。</param> 
    178182        [Test] 
     183        [TestCase(@"01-Append.txt", false, @"01-Append-0-TableQuery.txt")] 
     184        [TestCase(@"01-Append.txt", true, @"01-Append-0-TableQueryWithVariable.txt")] 
    179185        [TestCase(@"01-Append.txt", false, @"01-Append-0.txt")] 
    180186        [TestCase(@"01-Append.txt", false, @"01-Append-0-QuoteString.txt")] 

  • framework/trunk/TestLibrary/Sources/DbDataComparer.cs

    r1646 r1647  
    4242    { 
    4343        /// <summary> 
     44        /// 変数を表す正規表現。 
     45        /// </summary> 
     46        private static readonly Regex VariableRegex 
     47            = new Regex( 
     48                @"\${(?<name>[^${:}]+)}", 
     49                RegexOptions.ExplicitCapture); 
     50 
     51        /// <summary> 
     52        /// SQLCMD 形式を含む変数を表す正規表現。 
     53        /// </summary> 
     54        private static readonly Regex Variable2Regex 
     55            = new Regex( 
     56                @"\$({(?<name>[^${:}]+)}|\((?<name>[^$(:)]+)\))", 
     57                RegexOptions.ExplicitCapture); 
     58 
     59 
     60        /// <summary> 
    4461        /// 比較元のテキストデータを元にデータベースにクエリーを発行して結果を比較を行います。 
    4562        /// </summary> 
    … …  
    138155                            } 
    139156 
    140                             tableQuery = new TableQuery(tableLineNumber, transaction, notify, builder); 
     157                            tableQuery = new TableQuery(tableLineNumber, transaction, notify, builder, variables); 
    141158                            continue; 
    142159                        } 
    … …  
    259276        } 
    260277 
     278        /// MEMO: このメソッドは DbDataOperator.ResolveVariable と同じ実装 
     279        /// <summary> 
     280        /// 文字列中の変数を解決して返します。 
     281        /// </summary> 
     282        /// <param name="regex">変数にマッチする正規表現。グループ名 <c>name</c> を使用します。</param> 
     283        /// <param name="value">文字列。</param> 
     284        /// <param name="variables">変数名をキーとして埋め込む値を値としたディクショナリ。</param> 
     285        /// <returns> 
     286        /// 変数を解決した文字列。 
     287        /// </returns> 
     288        private static string ResolveVariable(Regex regex, string value, IDictionary<string, object> variables) 
     289        { 
     290            // 変数が未設定の場合や、変数の文字数に足りていない場合 
     291            if (variables == null || value.Length < 4) 
     292            { 
     293                return value; 
     294            } 
     295 
     296            return regex.Replace( 
     297                value, 
     298                delegate(Match match) 
     299                { 
     300                    string variableName = match.Groups["name"].Value; 
     301                    object variableValue; 
     302                    if (!variables.TryGetValue(variableName, out variableValue)) 
     303                    { 
     304                        throw new VariableNotFoundException(variableName, (string)null); 
     305                    } 
     306 
     307                    return variableValue != null ? variableValue.ToString() : string.Empty; 
     308                }); 
     309        } 
     310 
    261311 
    262312        /// <summary> 
    … …  
    277327 
    278328            /// <summary> 
    279             /// 変数を表す正規表現。 
    280             /// </summary> 
    281             private static readonly Regex VariableRegex 
    282                 = new Regex( 
    283                     @"\${(?<name>[^${:}]+)}", 
    284                     RegexOptions.ExplicitCapture); 
    285  
    286             /// <summary> 
    287329            /// テーブル定義の行番号。 
    288330            /// </summary> 
    … …  
    387429            /// <param name="notify">通知先。</param> 
    388430            /// <param name="query">クエリー。</param> 
    389             internal TableQuery(int tableLineNumber, ICommonDbTransaction transaction, DbDataComparerNotify notify, StringBuilder query) 
     431            /// <param name="variables">変数名をキーとして埋め込む値を値としたディクショナリ。</param> 
     432            internal TableQuery(int tableLineNumber, ICommonDbTransaction transaction, DbDataComparerNotify notify, StringBuilder query, IDictionary<string, object> variables) 
    390433            { 
    391434                this.tableLineNumber = tableLineNumber; 
    392435                this.transaction = transaction; 
    393436                this.notify = notify; 
    394                 this.query = query.ToString(); 
     437                this.query = ResolveVariable(Variable2Regex, query.ToString(), variables); 
    395438            } 
    396439 
    … …  
    671714                        } 
    672715 
    673                         column = ResolveVariable(column, variables); 
     716                        column = ResolveVariable(VariableRegex, column, variables); 
    674717                    } 
    675718 
    … …  
    678721 
    679722                return actual.Equals(expected); 
    680             } 
    681  
    682             /// MEMO: このメソッドは DbDataOperator.InsertCommand.ResolveVariable と同じ実装 
    683             /// <summary> 
    684             /// 文字列中の変数を解決して返します。 
    685             /// </summary> 
    686             /// <param name="value">文字列。</param> 
    687             /// <param name="variables">変数名をキーとして埋め込む値を値としたディクショナリ。</param> 
    688             /// <returns> 
    689             /// 変数を解決した文字列。 
    690             /// </returns> 
    691             private static string ResolveVariable(string value, IDictionary<string, object> variables) 
    692             { 
    693                 // 変数が未設定の場合や、変数の文字数に足りていない場合 
    694                 if (variables == null || value.Length < 4) 
    695                 { 
    696                     return value; 
    697                 } 
    698  
    699                 return VariableRegex.Replace( 
    700                     value, 
    701                     delegate(Match match) 
    702                     { 
    703                         string variableName = match.Groups["name"].Value; 
    704                         object variableValue; 
    705                         if (!variables.TryGetValue(variableName, out variableValue)) 
    706                         { 
    707                             throw new VariableNotFoundException(variableName, (string)null); 
    708                         } 
    709  
    710                         return variableValue != null ? variableValue.ToString() : string.Empty; 
    711                     }); 
    712723            } 
    713724 
※ 詳しい使い方は TracChangeset を参照してください。