Merge pull request #5 from DIPSASA/feature/parameterStatus

Feature/parameter status

Author: epaulsen

README.md

@@ -5,13 +5,15 @@ Oracle support for Dapper Micro ORM.
 ### Introduction
 
 Dapper is a great tool if you want to write database-agnostic code.
-However, sometimes you need to access functionality that is provider-specific.  This assembly adds support for writing Oracle-specific SQL, that supports all dbtypes used by the managed provider on a parameter, supports setting various properties on the command(LOBFetchSize, ArrayBindCount, BindByName), as well as setting CollectionType on the parameter.
+However, sometimes you need to access functionality that is provider-specific.  This assembly adds support for writing Oracle-specific SQL, that supports all dbtypes used by the Oracle managed provider on a parameter, supports setting various properties on the command(LOBFetchSize, ArrayBindCount, BindByName), as well as setting CollectionType on the parameter.
 Using this package, you can now run stored procedures that returns RefCursor, or use array bind count to execute a sql statements with a array of parameters.
 
 ### Supported Oracle-specific properties
 **OracleParameter(Managed and UnManaged)**
 - OracleDbType enum (all members used by the managed provider)
 - CollectionType enum
+- ParameterStatus (return type when executing stored procedure)
+- ArrayBindSize
 
 **OracleCommand (Managed and UnManaged)**
 - ArrayBindCount property
@@ -52,6 +54,11 @@ public void RunStoredProcedureWithArrayAsParameters(IEnumerable<long> idvalues)
 }
 ```
 
+## Building
+From a powershell script, run build.ps1 from the root folder of the repo.
+Example
+build.ps1 -Task Compile
+
 
 
 

default.ps1

@@ -81,6 +81,12 @@ function Write-PaketTemplateFiles()
     }    
 }
 
+function Write-Documentation
+{
+    Write-Host "Available tasks:Clean,Init,Compile,Test,Package"
+    Write-Host "Usage example: build.ps1 -Tasks Test,Package"
+}
+
 
 function Update-AssemblyInfoFiles ([string] $version, [string]$assemblyInformalVersion) {
 #-------------------------------------------------------------------------------

releasenotes.md

@@ -1,8 +1,10 @@
 # Releasenotes
 
+### 0.9.7
+- Added Status to OracleParameter, this is returned by some stored procs.
 ### 0.9.6
 - Added ArrayBindSize property to OracleParameter, can now set this property on OracleCommand for both managed and unmanaged driver.
 ### 0.9.5
 - Made OracleDynamicParameters.AddParameters virtual, so that it can be extended in a derived class.
 ### 0.9.0
-Initial commit to Github.
+- Initial commit to Github.

src/Dapper.Oracle/OracleDynamicParameters.cs

@@ -11,11 +11,11 @@ namespace Dapper.Oracle
     /// Parameter support for Oracle-specific types and functions.  For use with Dapper.
     /// Implements <see cref="SqlMapper.IDynamicParameters"/>.
     /// </summary>
-    public class OracleDynamicParameters : SqlMapper.IDynamicParameters
+    public partial class OracleDynamicParameters : SqlMapper.IDynamicParameters
     {
         private static Dictionary<SqlMapper.Identity, Action<IDbCommand, object>> ParamReaderCache { get; } = new Dictionary<SqlMapper.Identity, Action<IDbCommand, object>>();
 
-        private Dictionary<string, ParamInfo> Parameters { get; } = new Dictionary<string, ParamInfo>();
+        private Dictionary<string, OracleParameterInfo> Parameters { get; } = new Dictionary<string, OracleParameterInfo>();
 
         private List<object> templates;
 
@@ -119,11 +119,11 @@ public void Add(
             string sourceColumn = null,
             DataRowVersion? sourceVersion = null,
             OracleMappingCollectionType? collectionType = null,
-            int[] arrayBindSize= null)
+            int[] arrayBindSize = null)
         {
-            Parameters[Clean(name)] = new ParamInfo()
+            Parameters[Clean(name)] = new OracleParameterInfo()
             {
-                Name = name,
+                Name = Clean(name),
                 Value = value,
                 ParameterDirection = direction ?? ParameterDirection.Input,
                 DbType = dbType,
@@ -161,6 +161,11 @@ public T Get<T>(string name)
             return OracleValueConverter.Convert<T>(val);
         }
 
+        public OracleParameterInfo GetParameter(string name)
+        {
+            return OracleMethodHelper.GetParameterInfo(Parameters[Clean(name)].AttachedParam);
+        }
+
         void SqlMapper.IDynamicParameters.AddParameters(IDbCommand command, SqlMapper.Identity identity)
         {
             AddParameters(command, identity);
@@ -263,7 +268,10 @@ private static string Clean(string name)
             return name;
         }
 
-        internal class ParamInfo
+        /// <summary>
+        /// Class used to pass parameter information to and from the OracleCommand object
+        /// </summary>
+        public class OracleParameterInfo
         {
             public string Name { get; set; }
 
@@ -289,6 +297,8 @@ internal class ParamInfo
 
             public int[] ArrayBindSize { get; set; } = null;
 
+            public OracleParameterMappingStatus Status { get; set; }
+
             public IDbDataParameter AttachedParam { get; set; }
         }
     }

src/Dapper.Oracle/OracleMappingType.cs

@@ -44,4 +44,15 @@ public enum OracleMappingCollectionType
         None,
         PLSQLAssociativeArray,
     }
+
+    /// <summary>
+    /// Mapping enum to map Parameter status for OracleParameter
+    /// </summary>
+    public enum OracleParameterMappingStatus
+    {
+        Success,
+        NullFetched,
+        NullInsert,
+        Truncation,
+    }
 }

src/Dapper.Oracle/OracleMethodHelper.cs

@@ -25,7 +25,7 @@ public static void SetBindByName(IDbCommand command, bool bindByName)
             Get(command).BindByName.SetValue(command, bindByName);
         }
 
-        public static void SetOracleParameters(IDbDataParameter parameter, OracleDynamicParameters.ParamInfo paramInfo)
+        public static void SetOracleParameters(IDbDataParameter parameter, OracleDynamicParameters.OracleParameterInfo oracleParameterInfo)
         {
             if (parameter == null)
             {
@@ -34,45 +34,73 @@ public static void SetOracleParameters(IDbDataParameter parameter, OracleDynamic
 
             var method = CachedOracleTypes.GetOrAdd(parameter.GetType(), GetOracleProperties);
 
-            if (paramInfo.DbType != null)
+            if (oracleParameterInfo.DbType != null)
             {
-                object value = (int)paramInfo.DbType;
+                object value = (int)oracleParameterInfo.DbType;
                 method.OraDbType.SetValue(parameter, value);
             }
 
-            if (paramInfo.IsNullable.HasValue)
+            if (oracleParameterInfo.IsNullable.HasValue)
             {
-                method.IsNullable.SetValue(parameter, paramInfo.IsNullable.Value);
+                method.IsNullable.SetValue(parameter, oracleParameterInfo.IsNullable.Value);
             }
 
-            if (paramInfo.Scale.HasValue)
+            if (oracleParameterInfo.Scale.HasValue)
             {
-                method.Scale.SetValue(parameter, paramInfo.Scale.Value);
+                method.Scale.SetValue(parameter, oracleParameterInfo.Scale.Value);
             }
 
-            if (paramInfo.Precision.HasValue)
+            if (oracleParameterInfo.Precision.HasValue)
             {
-                method.Precision.SetValue(parameter, paramInfo.Precision.Value);
+                method.Precision.SetValue(parameter, oracleParameterInfo.Precision.Value);
             }
 
-            method.SourceVersion.SetValue(parameter, paramInfo.SourceVersion);
+            method.SourceVersion.SetValue(parameter, oracleParameterInfo.SourceVersion);
 
-            if (paramInfo.SourceColumn != null)
+            if (oracleParameterInfo.SourceColumn != null)
             {
-                method.SourceColumn.SetValue(parameter, paramInfo.SourceColumn);
+                method.SourceColumn.SetValue(parameter, oracleParameterInfo.SourceColumn);
             }
 
-            if (paramInfo.CollectionType != OracleMappingCollectionType.None)
+            if (oracleParameterInfo.CollectionType != OracleMappingCollectionType.None)
             {
-                method.CollectionType.SetValue(parameter, Enum.Parse(method.OracleCollectionEnumType, paramInfo.CollectionType.ToString()));
+                method.CollectionType.SetValue(parameter, Enum.Parse(method.OracleCollectionEnumType, oracleParameterInfo.CollectionType.ToString()));
             }
 
-            if (paramInfo.ArrayBindSize != null)
+            if (oracleParameterInfo.ArrayBindSize != null)
             {
-                method.ArrayBindSize.SetValue(parameter, paramInfo.ArrayBindSize);
+                method.ArrayBindSize.SetValue(parameter, oracleParameterInfo.ArrayBindSize);
             }
         }
 
+        internal static  OracleDynamicParameters.OracleParameterInfo GetParameterInfo(IDbDataParameter parameter)
+        {
+            var method = GetOracleProperties(parameter.GetType());
+            var paramInfo = new OracleDynamicParameters.OracleParameterInfo();
+            paramInfo.Name = parameter.ParameterName;
+            paramInfo.SourceVersion = parameter.SourceVersion;
+            paramInfo.Precision = parameter.Precision;
+            paramInfo.Size = parameter.Size;
+            
+            paramInfo.DbType = (OracleMappingType)Enum.Parse(
+                    typeof(OracleMappingType),
+                    Enum.GetName(method.OracleDbEnumType, method.OraDbType.GetValue(parameter)));
+            paramInfo.ArrayBindSize = (int[])method.ArrayBindSize.GetValue(parameter);
+            paramInfo.CollectionType= (OracleMappingCollectionType)Enum.Parse(
+                    typeof(OracleMappingCollectionType),
+                    Enum.GetName(method.OracleCollectionEnumType, method.CollectionType.GetValue(parameter)));            
+            paramInfo.ParameterDirection = parameter.Direction;
+            paramInfo.IsNullable = parameter.IsNullable;
+            paramInfo.Scale = parameter.Scale;
+            paramInfo.SourceColumn = parameter.SourceColumn;
+            paramInfo.Status = (OracleParameterMappingStatus)Enum.Parse(
+                    typeof(OracleParameterMappingStatus),
+                    Enum.GetName(method.OracleStatusEnumType,method.Status.GetValue(parameter)));
+            paramInfo.Value = parameter.Value;
+
+            return paramInfo;
+        }
+        
         private static OracleParameterProperties GetOracleProperties(Type type)
         {
             Assembly assembly = type.Assembly;
@@ -86,18 +114,21 @@ private static OracleParameterProperties GetOracleProperties(Type type)
                 SourceColumn = type.GetProperty("SourceColumn"),
                 SourceVersion = type.GetProperty("SourceVersion"),
                 CollectionType = type.GetProperty("CollectionType"),
-                ArrayBindSize = type.GetProperty("ArrayBindSize")
+                ArrayBindSize = type.GetProperty("ArrayBindSize"),
+                Status = type.GetProperty("Status")
             };
             switch (type.FullName)
             {
                 case "Oracle.DataAccess.Client.OracleParameter":
                     result.OracleDbEnumType = assembly.GetType("Oracle.DataAccess.Client.OracleDbType");
                     result.OracleCollectionEnumType = assembly.GetType("Oracle.DataAccess.Client.OracleCollectionType");
+                    result.OracleStatusEnumType = assembly.GetType("Oracle.DataAccess.Client.OracleParameterStatus");
                     break;
 
                 case "Oracle.ManagedDataAccess.Client.OracleParameter":
-                    result.OracleDbEnumType = assembly.GetType("Oracle.DataAccess.Client.OracleDbType");
+                    result.OracleDbEnumType = assembly.GetType("Oracle.ManagedDataAccess.Client.OracleDbType");
                     result.OracleCollectionEnumType = assembly.GetType("Oracle.ManagedDataAccess.Client.OracleCollectionType");
+                    result.OracleStatusEnumType = assembly.GetType("Oracle.ManagedDataAccess.Client.OracleParameterStatus");
                     break;
                 default:
                     throw new NotSupportedException(
@@ -142,9 +173,14 @@ private class OracleParameterProperties
 
             public PropertyInfo CollectionType { get; set; }
 
+            public PropertyInfo Status { get; set; }
+
             public Type OracleDbEnumType { get; set; }
 
+            public Type OracleStatusEnumType { get; set; }
+
             public Type OracleCollectionEnumType { get; set; }
+            
         }
 
         private class CommandProperties

src/Dapper.Oracle/OracleValueConverter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 

src/Dapper.Oracle/Properties/AssemblyInfo.cs

@@ -11,16 +11,7 @@
 using Managed = Oracle.ManagedDataAccess.Client;
 
 namespace Tests.Dapper.Oracle
-{
-    internal class OverrideCreateCommand : TestableOracleDynamicParameters
-    {
-        public bool wasCalled = false;
-        protected override void AddParameters(IDbCommand command, SqlMapper.Identity identity)
-        {
-            wasCalled = true;
-            base.AddParameters(command, identity);
-        }
-    }
+{    
 
     internal class TestableOracleDynamicParameters : OracleDynamicParameters
     {
@@ -141,32 +132,7 @@ public void WrongTypeConnectionWillThrowException()
             testObject.Add("Foo", "Bar");
             Action act = () => testObject.AddParam(cmd);
             act.Should().Throw<NotSupportedException>();
-        }
-
-        [Theory, MemberData(nameof(OracleDataFixture))]
-        public void DerivedClassSetAllProperties(IDbCommand cmd, IOracleParameterRetretreiver retreiver)
-        {
-            var derived = new OverrideCreateCommand();
-
-            derived.Add("Foo", "Bar", OracleMappingType.Varchar2, ParameterDirection.Input, 42, true, 0, 0, "MySource", DataRowVersion.Original);
-
-            derived.AddParam(cmd);
-            cmd.Parameters.Should().HaveCount(1);
-
-            derived.wasCalled.Should().BeTrue();
-
-            var param = retreiver.GetParameter(cmd.Parameters[0]);
-            param.ParameterName.Should().Be("Foo");
-            param.Value.Should().Be("Bar");
-            param.OracleDbType.Should().Be("Varchar2");
-            param.Direction.Should().Be(ParameterDirection.Input);
-            param.Size.Should().Be(42);
-            param.IsNullable.Should().Be(true);
-            param.Scale.Should().Be(0);
-            param.Precision.Should().Be(0);
-            param.SourceColumn.Should().Be("MySource");
-            param.SourceVersion.Should().Be(DataRowVersion.Original);
-        }
+        }        
 
         [Theory, MemberData(nameof(OracleDataFixture))]
         public void ArrayBindSizeSet_ValueIsSet(IDbCommand cmd, IOracleParameterRetretreiver retreiver)

src/Tests.Dapper.Oracle/OracleDynamicParameterTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Text;
 using Dapper.Oracle;
 using FluentAssertions;
 using Oracle.DataAccess.Types;
@@ -10,7 +11,7 @@ public class OracleValueConverterTests
     {
         [Fact]
         public void GetOracleStringWithContentReturnsContent()
-        {            
+        {
             var oraString = new OracleString("Foo");
             var result = OracleValueConverter.Convert<string>(oraString);
             result.Should().Be("Foo");
@@ -26,14 +27,14 @@ public void GetOracleStringAsNullReturnsNull()
 
         [Fact]
         public void GetStringAsDbNullReturnsNull()
-        {            
+        {
             var result = OracleValueConverter.Convert<string>(DBNull.Value);
             result.Should().BeNull();
         }
 
         [Fact]
         public void GetNullAsStringReturnsNull()
-        {            
+        {
             var result = OracleValueConverter.Convert<string>(null);
             result.Should().BeNull();
         }
@@ -57,8 +58,8 @@ public void GetOracleDateTimeReturnsDateTime()
         {
             var result = OracleValueConverter.Convert<DateTime>(new OracleDate(DateTime.Today));
             result.Should().Be(DateTime.Today);
-        }
-
-
+        }                
     }
+
+    
 }