OdbcStoredProcedure.cs

using System;
using System.Data.Common;
using System.Data.Odbc;
using System.Threading.Tasks;
using Waher.Runtime.Threading;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Operators;
 
namespace Waher.Script.Data.Model
{
    public class OdbcStoredProcedure : ILambdaExpression, IDisposable
    {
        private readonly MultiReadSingleWriteObject synchObj;
        private readonly OdbcCommand command;
        private readonly int nrParameters;
        private readonly string[] parameterNames;
        private readonly ArgumentType[] parameterTypes;
 
        internal OdbcStoredProcedure(OdbcCommand Command)
        {
            this.synchObj = new MultiReadSingleWriteObject(this);
            this.command = Command;
            this.nrParameters = this.command.Parameters.Count;
            this.parameterNames = new string[this.nrParameters];
            this.parameterTypes = new ArgumentType[this.nrParameters];
 
            for (int i = 0; i < this.nrParameters; i++)
            {
                this.parameterNames[i] = this.command.Parameters[i].ParameterName;
                this.parameterTypes[i] = ArgumentType.Normal;
            }
        }
 
        public int NrArguments => this.nrParameters;
 
        public string[] ArgumentNames => this.parameterNames;
 
        public ArgumentType[] ArgumentTypes => this.parameterTypes;
 
        public bool IsAsynchronous => true;
 
        public void Dispose()
        {
            this.command?.Dispose();
        }
 
        public IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            return this.EvaluateAsync(Arguments, Variables).Result;
        }
 
        public async Task<IElement> EvaluateAsync(IElement[] Arguments, Variables Variables)
        {
            int i;
 
            await this.synchObj.BeginWrite();
            try
            {
                for (i = 0; i < this.nrParameters; i++)
                {
                    OdbcParameter Parameter = this.command.Parameters[i];
                    object Value = Arguments[i].AssociatedObjectValue;
 
                    switch (Parameter.OdbcType)
                    {
                        case OdbcType.Binary:
                        case OdbcType.Bit:
                        case OdbcType.Char:
                        case OdbcType.DateTime:
                        case OdbcType.Double:
                        case OdbcType.Image:
                        case OdbcType.NChar:
                        case OdbcType.NText:
                        case OdbcType.NVarChar:
                        case OdbcType.UniqueIdentifier:
                        case OdbcType.SmallDateTime:
                        case OdbcType.Text:
                        case OdbcType.Timestamp:
                        case OdbcType.VarBinary:
                        case OdbcType.VarChar:
                        case OdbcType.Date:
                        case OdbcType.Time:
                        default:
                            Parameter.Value = Value;
                            break;
 
                        case OdbcType.Decimal:
                        case OdbcType.Numeric:
                            if (Value is decimal Decimal)
                                Parameter.Value = Decimal;
                            else if (Value is double d)
                                Parameter.Value = (decimal)d;
                            else
                                Parameter.Value = Convert.ToDecimal(Value);
                            break;
 
                        case OdbcType.Real:
                            if (Value is float Single)
                                Parameter.Value = Single;
                            else if (Value is double d)
                                Parameter.Value = (float)d;
                            else
                                Parameter.Value = Convert.ToSingle(Value);
                            break;
 
                        case OdbcType.SmallInt:
                            if (Value is Int16 Int16)
                                Parameter.Value = Int16;
                            else if (Value is double d)
                                Parameter.Value = (Int16)d;
                            else
                                Parameter.Value = Convert.ToInt16(Value);
                            break;
 
                        case OdbcType.Int:
                            if (Value is Int32 Int32)
                                Parameter.Value = Int32;
                            else if (Value is double d)
                                Parameter.Value = (Int32)d;
                            else
                                Parameter.Value = Convert.ToInt32(Value);
                            break;
 
                        case OdbcType.BigInt:
                            if (Value is Int64 Int64)
                                Parameter.Value = Int64;
                            else if (Value is double d)
                                Parameter.Value = (Int64)d;
                            else
                                Parameter.Value = Convert.ToInt64(Value);
                            break;
 
                        case OdbcType.TinyInt:
                            if (Value is byte UI8)
                                Parameter.Value = UI8;
                            else if (Value is double d)
                                Parameter.Value = (byte)d;
                            else
                                Parameter.Value = Convert.ToByte(Value);
                            break;
                    }
                }
 
                DbDataReader Reader = await this.command.ExecuteReaderAsync();
 
                return await Reader.ParseAndClose();
            }
            finally
            {
                await this.synchObj.EndWrite();
            }
        }
 
        public override string ToString()
        {
            return LambdaDefinition.ToString(this);
        }
    }
}