示例#1
0
 /// <summary>
 /// 检索SQL参数信息并填充
 /// </summary>
 /// <param name="cmd"></param>
 public void DeriveParameters(IDbCommand cmd)
 {
     if ((cmd as OracleCommand) != null)
     {
         OracleCommandBuilder.DeriveParameters(cmd as OracleCommand);
     }
 }
 public OracleCommand execSP(string SP, params object[] parametros)
 {
     try
     {
         OracleCommand cmd = new OracleCommand(SP, conn);
         cmd.CommandType = CommandType.StoredProcedure;
         //abrirConexion();
         OracleCommandBuilder.DeriveParameters(cmd);
         int cuenta = 0;
         foreach (OracleParameter param in cmd.Parameters)
         {
             if (param.ParameterName != "RETURN_VALUE")
             {
                 param.Value = parametros[cuenta];
                 cuenta++;
             }
         }
         cmd.ExecuteNonQuery();
         return(cmd);
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
示例#3
0
        DbCommand PrepareProcCommand(Database db, string procname, Dictionary <string, object> args)
        {
            DbCommand cmd = db.GetStoredProcCommand(procname);

            using (DbConnection conn = db.CreateConnection())
            {
                try
                {
                    cmd.Connection = conn;
                    cmd.Connection.Open();
                    if (db.DBType.Equals(DatabaseType.Oracle))
                    {
                        OracleCommandBuilder.DeriveParameters((OracleCommand)cmd);
                    }
                    else
                    {
                        SqlCommandBuilder.DeriveParameters((SqlCommand)cmd);
                    }
                    cmd.Connection.Close();
                    addProcParameters(db, cmd, args);
                }
                catch (Exception ex)
                {
                    throw new ApplicationException("PrepareProcCommand Fail(in Connection Open or DeriveParameters)(Message:" + ex.Message
                                                   + " procname:" + procname
                                                   + " db:" + db.DBType.ToString(), ex);
                }
            }
            return(cmd);
        }
示例#4
0
        /// <summary>
        /// Calls the CommandBuilder.DeriveParameters method for the specified provider, doing any setup and cleanup necessary
        /// </summary>
        /// <param name="cmd">The IDbCommand referencing the stored procedure from which the parameter information is to be derived. The derived parameters are added to the Parameters collection of the IDbCommand. </param>
        public override void DeriveParameters(IDbCommand cmd)
        {
            bool mustCloseConnection = false;


            if (!(cmd is OracleCommand))
            {
                throw new ArgumentException("The command provided is not a SqlCommand instance.", "cmd");
            }


            if (cmd.Connection.State != ConnectionState.Open)
            {
                cmd.Connection.Open();
                mustCloseConnection = true;
            }


            OracleCommandBuilder.DeriveParameters((OracleCommand)cmd);


            if (mustCloseConnection)
            {
                cmd.Connection.Close();
            }
        }
示例#5
0
        public void ExecuteProcedureNonquery(string CommandText, params object[] parameterValues)
        {
            OracleConnection connection = null;
            OracleCommand    command    = null;
            string           resp       = "";

            try
            {
                connection          = CreateConnection();
                command             = connection.CreateCommand();
                command.CommandType = CommandType.StoredProcedure;
                command.CommandText = CommandText;
                connection.Open();
                OracleCommandBuilder.DeriveParameters(command);
                int index = 0;
                foreach (OracleParameter parameter in command.Parameters)
                {
                    if (parameter.Direction == ParameterDirection.Input || parameter.Direction == ParameterDirection.InputOutput)
                    {
                        parameter.Value = parameterValues[index];
                        index++;
                    }
                    else
                    {
                        parameter.Value = new object();
                        index++;
                    }
                }
                command.ExecuteNonQuery();



                resp = "success";
            }

            catch (Exception ex)
            {
                resp = "error";
                //throw;
            }
            finally
            {
                if (command != null)
                {
                    command.Dispose();
                    command = null;
                }


                if (connection != null)
                {
                    if (connection.State == ConnectionState.Open)
                    {
                        connection.Close();
                    }
                    connection.Dispose();
                    connection = null;
                }
            }
        }
示例#6
0
        private void Form1_Load(object sender, EventArgs e) //this is the code which will run when the form loads
        {
            con.Open();
            OracleCommand oc = new OracleCommand("threetwo.load_ui2", con);

            oc.CommandType = CommandType.StoredProcedure;
            OracleCommandBuilder.DeriveParameters(oc);
            foreach (OracleParameter p in oc.Parameters)
            {
                System.Windows.Forms.Label temp = new System.Windows.Forms.Label();
                this.Controls.Add(temp);
                temp.Top      = a * 30;
                temp.Left     = 10;
                temp.AutoSize = true;
                temp.Text    += p.ParameterName.ToString();
                temp.Name     = "lab" + a.ToString();
                ++a;
                //for textbox
                System.Windows.Forms.TextBox temp2 = new System.Windows.Forms.TextBox();
                this.Controls.Add(temp2);
                temp2.Top  = b * 30;
                temp2.Left = 100;
                temp2.Name = "txt" + b.ToString();
                ++b;
            }
            con.Close();
        }
示例#7
0
 /// <summary>
 /// <see cref="OracleCommandBuilder.DeriveParameters"/>
 /// </summary>
 /// <param name="cmd"></param>
 public override void DeriveParameters(System.Data.IDbCommand cmd)
 {
     if (cmd is OracleCommand)
     {
         OracleCommandBuilder.DeriveParameters(cmd as OracleCommand);
     }
 }
示例#8
0
        public IEnumerable <User> GetByIds3(string[] userIds)
        {
            using (var connection = new OracleConnection(connectionString))
                using (var command = new OracleCommand("USER_PACKAGE.GET_BY_IDS3", connection))
                {
                    connection.Open();
                    command.CommandType = CommandType.StoredProcedure;
                    OracleCommandBuilder.DeriveParameters(command);
                    command.Parameters["P_USER_IDS"].Value = userIds;

                    using (var reader = command.ExecuteReader())
                    {
                        var output = new List <User>();

                        if (!reader.HasRows)
                        {
                            return(output);
                        }

                        while (reader.Read())
                        {
                            var record = new User();
                            record.UserId    = (string)reader["USER_ID"];
                            record.FirstName = (string)reader["FIRST_NAME"];
                            record.LastName  = (string)reader["LAST_NAME"];
                            output.Add(record);
                        }

                        return(output);
                    }
                }
        }
        /// <summary>
        /// The discover sp parameter set.
        /// </summary>
        /// <param name="connectionString">
        /// The connection string.
        /// </param>
        /// <param name="spName">
        /// The sp name.
        /// </param>
        /// <param name="includeReturnValueParameter">
        /// The include return value parameter.
        /// </param>
        /// <returns>
        /// The <see>
        ///     <cref>OracleParameter[]</cref>
        /// </see>
        ///     .
        /// </returns>
        private static OracleParameter[] DiscoverSpParameterSet(
            string connectionString,
            string spName,
            bool includeReturnValueParameter)
        {
            using (var cn = new OracleConnection(connectionString))
                using (var cmd = new OracleCommand(spName, cn))
                {
                    cn.Open();
                    cmd.CommandType = CommandType.StoredProcedure;

                    OracleCommandBuilder.DeriveParameters(cmd);

                    if (!includeReturnValueParameter)
                    {
                        if (ParameterDirection.ReturnValue == cmd.Parameters[0].Direction)
                        {
                            cmd.Parameters.RemoveAt(0);
                        }
                    }

                    var discoveredParameters = new OracleParameter[cmd.Parameters.Count];

                    cmd.Parameters.CopyTo(discoveredParameters, 0);

                    return(discoveredParameters);
                }
        }
示例#10
0
 protected override void DeriveParameters(IDbCommand cmd)
 {
     if (!(cmd is OracleCommand))
     {
         throw new ArgumentException("The command provided is not a OleDbCommand instance.", "cmd");
     }
     OracleCommandBuilder.DeriveParameters((OracleCommand)cmd);
 }
示例#11
0
        ///// <summary>
        ///// 是否要强制关闭连接
        ///// </summary>
        //private static bool mustCloseConnection = false;

        /// <summary>
        /// 返回一个存储过程的参数数组
        /// </summary>
        /// <param name="connection">有效的数据连接</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="includeReturnValueParameter">是否包含返回值参数</param>
        /// <returns>返回找到的参数数组.</returns>
        private static OracleParameter[] DiscoverSpParameterSet(OracleConnection connection, string spName, bool includeReturnValueParameter)
        {
            // 检验参数

            if (connection == null)
            {
                throw new ArgumentNullException("connection");
            }

            if (spName == null || spName.Length == 0)
            {
                throw new ArgumentNullException("spName");
            }

            // 定义一个模拟命令

            OracleCommand cmd = new OracleCommand(spName, connection);

            cmd.CommandType = CommandType.StoredProcedure;

            // 打开连接
            connection.Open();

            // 查找存储过程的参数

            OracleCommandBuilder.DeriveParameters(cmd);
            //// 是否要关闭连接

            //if (mustCloseConnection == true)
            //{
            //    connection.Close();
            //}

            connection.Close();

            // 如果包含返回参数,则删除第一个参数,该情况存在于SQL SERVER中

            if (!includeReturnValueParameter)
            {
                cmd.Parameters.RemoveAt(0);
            }

            // 返回找到的参数的副本
            OracleParameter[] discoveredParameters = new OracleParameter[cmd.Parameters.Count];

            cmd.Parameters.CopyTo(discoveredParameters, 0);

            // 参数一刀两断,没有关系了.
            cmd.Parameters.Clear();

            // 初始化各参数为DBNull
            foreach (OracleParameter discoveredParameter in discoveredParameters)
            {
                discoveredParameter.Value = DBNull.Value;
            }
            return(discoveredParameters);
        }
示例#12
0
        /// <summary>
        /// Retrieves parameter information from the stored procedure specified in the <see cref="DbCommand"/> and populates the Parameters collection of the specified <see cref="DbCommand"/> object.
        /// </summary>
        /// <param name="discoveryCommand">The <see cref="DbCommand"/> to do the discovery.</param>
        /// <remarks>
        /// The <see cref="DbCommand"/> must be an instance of a <see cref="OracleCommand"/> object.
        /// </remarks>
        protected override void DeriveParameters(DbCommand discoveryCommand)
        {
            OracleCommandBuilder.DeriveParameters((OracleCommand)discoveryCommand);
            OracleParameter curOut = discoveryCommand.Parameters[RefCursorName] as OracleParameter;

            if (curOut != null)
            {
                curOut.OracleDbType = OracleDbType.RefCursor;
            }
        }
示例#13
0
        internal OracleCommand ObtenerComando(string nombreprocedimiento)
        {
            OracleCommand command = this.fwconexion.CreateCommand();

            command.CommandText    = nombreprocedimiento;
            command.CommandType    = CommandType.StoredProcedure;
            command.CommandTimeout = this.timeout;
            OracleCommandBuilder.DeriveParameters(command);
            return(command);
        }
示例#14
0
        private void AttachParameters(DbCommand command, Hashtable commandParameters)
        {
            //If its a oracle procedure/package
            if (command is OracleCommand &&
                command.CommandType == CommandType.StoredProcedure)
            {
                if (_connection.State != ConnectionState.Open)
                {
                    _connection.Open();
                }

                //Derive parameter types, directions and sizes from Oracle DB
                OracleCommandBuilder.DeriveParameters((OracleCommand)command);

                if (command.Parameters.Count != commandParameters.Count)
                {
                    throw new ArgumentException(Resources.MsgParameterNumberDiffers);
                }

                foreach (var k in commandParameters.Keys)
                {
                    var key = k.ToString().ToUpper();

                    if (!command.Parameters.Contains(key))
                    {
                        throw new IndexOutOfRangeException(string.Format(Resources.MsgParameterNotFound, key));
                    }

                    command.Parameters[key].Value = (commandParameters[key] ?? DBNull.Value);
                }
            }
            else
            {
                foreach (var k in commandParameters.Keys)
                {
                    var key = k.ToString().ToUpper();

                    //Check for null values and replaces by DBNull
                    var value = (commandParameters[key] ?? DBNull.Value);

                    if (command is OracleCommand)
                    {
                        command.Parameters.Add(new OracleParameter(key, value));
                    }
                    else if (command is SqlCommand)
                    {
                        command.Parameters.Add(new SqlParameter(key, value));
                    }
                    else if (command is OleDbCommand)
                    {
                        command.Parameters.Add(new OleDbParameter(key, value));
                    }
                }
            }
        }
示例#15
0
        /// <summary>
        /// Start the DB Process
        /// </summary>
        /// <param name="procedureName">name of the process</param>
        /// <returns></returns>
        ///
#pragma warning disable 612, 618
        private bool StartDBProcess(String procedureName)
        {
            if (DatabaseType.IsPostgre)  //jz Only DB2 not support stored procedure now
            {
                return(false);
            }

            //  execute on this thread/connection
            //String sql = "{call " + procedureName + "(" + _pi.GetAD_PInstance_ID() + ")}";
            OracleConnection conn = null;

            try
            {
                //only oracle procedure are supported
                OracleCommand comm = new OracleCommand();
                conn = (OracleConnection)DataBase.DB.GetConnection();
                conn.Open();
                comm.Connection  = conn;
                comm.CommandText = procedureName;
                comm.CommandType = CommandType.StoredProcedure;
                OracleCommandBuilder.DeriveParameters(comm);
                OracleParameter[] param = new OracleParameter[1];

                foreach (OracleParameter orp in comm.Parameters)
                {
                    param[0] = new OracleParameter(orp.ParameterName, _pi.GetAD_PInstance_ID());
                }

                //log.Fine("Executing " + procedureName + "(" + _pi.GetAD_PInstance_ID() + ")");
                int res = SqlExec.Oracle.OracleHelper.ExecuteNonQuery(conn, CommandType.StoredProcedure, procedureName, param);
                conn.Close();
                if (res < 0)
                {
                    ProcessInfoUtil.SetParameterFromDB(_pi);
                    return(StartDBProcess(procedureName, _pi.GetParameter()));
                }

                //DataBase.DB.ExecuteQuery(sql, null);
            }
            catch (Exception e)
            {
                if (conn != null)
                {
                    conn.Close();
                }
                //log.Log(Level.SEVERE, "Error executing procedure " + procedureName, e);
                _pi.SetSummary(Msg.GetMsg(_ctx, "ProcessRunError") + " " + e.Message);
                _pi.SetError(true);
                return(false);
            }
            //	log.fine(Log.l4_Data, "ProcessCtl.startProcess - done");
            return(true);
        }
示例#16
0
        /// <summary>
        /// Resolve at run time the appropriate set of DbParameters for a stored procedure
        /// </summary>
        /// <param name="connection">A valid DbConnection object</param>
        /// <param name="spName">The name of the stored procedure</param>
        /// <param name="includeReturnValueParameter">Whether or not to include their return value parameter</param>
        /// <returns>The parameter array discovered.</returns>
        private static DbParameter[] DiscoverSpParameterSet(DbConnection connection, string spName,
                                                            bool includeReturnValueParameter)
        {
            if (connection == null)
            {
                throw new ArgumentNullException("connection");
            }
            if (spName == null || spName.Length == 0)
            {
                throw new ArgumentNullException("spName");
            }

            DbCommand cmd = connection.CreateCommand();

            cmd.CommandText = spName;
            cmd.CommandType = CommandType.StoredProcedure;

            connection.Open();
            if (connection is SqlConnection)
            {
                SqlCommandBuilder.DeriveParameters((SqlCommand)cmd);
            }
            else if (connection is OracleConnection)
            {
                OracleCommandBuilder.DeriveParameters((OracleCommand)cmd);
            }
            else if (connection is OdbcConnection)
            {
                OdbcCommandBuilder.DeriveParameters((OdbcCommand)cmd);
            }
            else if (connection is OleDbConnection)
            {
                OleDbCommandBuilder.DeriveParameters((OleDbCommand)cmd);
            }

            connection.Close();

            if (!includeReturnValueParameter)
            {
                cmd.Parameters.RemoveAt(0);
            }

            DbParameter[] discoveredParameters = new DbParameter[cmd.Parameters.Count];

            cmd.Parameters.CopyTo(discoveredParameters, 0);

            // Init the parameters with a DBNull value
            foreach (DbParameter discoveredParameter in discoveredParameters)
            {
                discoveredParameter.Value = DBNull.Value;
            }
            return(discoveredParameters);
        }
示例#17
0
        public override Params ExecuteStoredProcedure(string strProcedureName, params object[] cmdParams)
        {
            Params           params2;
            Params           @params       = new OracleParams();
            OracleConnection objConnection = (OracleConnection)base.objConnection;

            try
            {
                OracleCommand command = new OracleCommand(strProcedureName, objConnection)
                {
                    CommandType = CommandType.StoredProcedure
                };
                if (objConnection.State != ConnectionState.Open)
                {
                    objConnection.Open();
                }
                OracleCommandBuilder.DeriveParameters(command);
                for (int i = 0; i < command.Parameters.Count; i++)
                {
                    if (command.Parameters[i].Direction == ParameterDirection.Input)
                    {
                        if (cmdParams.Length <= i)
                        {
                            throw new Exception("Parameter Count does not match.");
                        }
                        command.Parameters[i].Value = cmdParams[i];
                    }
                    else
                    {
                        command.Parameters[i].Value = DBNull.Value;
                    }
                }
                command.ExecuteNonQuery();
                foreach (OracleParameter parameter in command.Parameters)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput) || (parameter.Direction == ParameterDirection.Output))
                    {
                        @params.Add(parameter);
                    }
                }
                params2 = @params;
            }
            catch (Exception exception)
            {
                throw exception;
            }
            finally
            {
                this.CloseConnection();
            }
            return(params2);
        }
示例#18
0
 void IDatabase.DeriveParameters()
 {
     try
     {
         OracleCommandBuilder.DeriveParameters(this.sqlDataAdapter.SelectCommand);
     }
     catch (AtomusException exception)
     {
         throw exception;
     }
     catch (Exception exception)
     {
         throw new AtomusException(exception);
     }
 }
示例#19
0
        public static void ListParms()
        {
            OracleConnection conn = new OracleConnection("SERVER=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=10.3.1.11)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=MDMSPMIS)));User Id=MDMS;Password=MDMS;");
            OracleCommand    cmd  = new OracleCommand("PKG_WEBSERVICE_MDMS.Get_DiemDo", conn);

            cmd.CommandType = CommandType.StoredProcedure;
            conn.Open();
            OracleCommandBuilder.DeriveParameters(cmd);
            foreach (OracleParameter p in cmd.Parameters)
            {
                string acb  = p.ParameterName + " " + p.OracleType + " " + p.Value + " " + p.Size;
                var    dir  = p.Direction;
                var    dirf = p.Offset;
            }
        }
示例#20
0
        /// <summary>
        /// Derives the parameters of the given DbCommand object
        /// </summary>
        /// <param name="dbCmd">A DAAB DbCommand object</param>
        public override void DeriveParameters(DbCommand dbCmd)
        {
            OracleCommand oracleCmd = (OracleCommand)dbCmd;

            oracleCmd.Connection = (OracleConnection)_database.CreateConnection();
            try
            {
                oracleCmd.Connection.Open();
                OracleCommandBuilder.DeriveParameters(oracleCmd);
            }
            finally
            {
                oracleCmd.Connection.Close();
                oracleCmd.Connection.Dispose();
            }
        }
示例#21
0
        static partial void OracleDeriveParameters(DbCommand dbCmd, ref bool processed)
        {
            if (processed)
            {
                return;
            }

            OracleCommand oraCmd = dbCmd as OracleCommand;

            if (oraCmd != null)
            {
                ShuffleCommandTextCase(oraCmd);
                OracleCommandBuilder.DeriveParameters(oraCmd);

                processed = true;
            }
        }
示例#22
0
        /// <summary>
        /// <para>Dicover the parameters for a stored procedure using a separate connection and command.</para>
        /// </summary>
        /// <param name="parameterToken"><para>The parameter delimeter for database commands.</para></param>
        protected override void DoDiscoverParameters(char parameterToken)
        {
            this.parameterToken = parameterToken;
            using (OracleCommand newCommand = CreateNewCommandAndConnectionForDiscovery())
            {
                OracleCommandBuilder.DeriveParameters(newCommand);

                foreach (IDataParameter parameter in newCommand.Parameters)
                {
                    IDataParameter cloneParameter = (IDataParameter)((ICloneable)parameter).Clone();
                    cloneParameter.ParameterName = cloneParameter.ParameterName;
                    this.command.Parameters.Add(cloneParameter);
                }

                newCommand.Connection.Close();
            }
        }
        /// <summary>
        /// resolve at run time the appropriate set of OracleParameters for a stored procedure
        /// </summary>
        /// <param name="connectionString">a valid connection string for a OracleConnection</param>
        /// <param name="spName">the name of the stored procedure</param>
        /// <param name="includeReturnValueParameter">whether or not to include their return value parameter</param>
        /// <returns></returns>
        private static OracleParameter[] DiscoverSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
        {
            using (OracleConnection cn = new OracleConnection(connectionString))
                using (OracleCommand cmd = new OracleCommand(spName, cn))
                {
                    cn.Open();
                    cmd.CommandType = CommandType.StoredProcedure;

                    OracleCommandBuilder.DeriveParameters(cmd);

                    OracleParameter[] discoveredParameters = new OracleParameter[cmd.Parameters.Count];;

                    cmd.Parameters.CopyTo(discoveredParameters, 0);

                    return(discoveredParameters);
                }
        }
示例#24
0
        private void DeriveParameters(DbCommand discoveryCommand)
        {
            if (discoveryCommand.CommandType != CommandType.StoredProcedure)
            {
                return;
            }

            if (this._dbProviderFactory is SqlClientFactory)
            {
                SqlCommandBuilder.DeriveParameters((SqlCommand)discoveryCommand);
            }

            if (this._dbProviderFactory is OracleClientFactory)
            {
                OracleCommandBuilder.DeriveParameters((OracleCommand)discoveryCommand);
            }
        }
示例#25
0
        public void Update_CommandBuilder_DeriveParameters(User record)
        {
            using (var connection = new OracleConnection(connectionString))
                using (var command = new OracleCommand("USER_PACKAGE.UPD", connection))
                {
                    connection.Open();
                    command.CommandType = CommandType.StoredProcedure;
                    // Command Builder can also generate Insert, Update, and Delete commands when given a data adapter.
                    // See https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/generating-commands-with-commandbuilders?view=netframework-4.7.2
                    OracleCommandBuilder.DeriveParameters(command);
                    command.Parameters["P_USER_ID"].Value    = record.UserId;
                    command.Parameters["P_FIRST_NAME"].Value = record.FirstName;
                    command.Parameters["P_LAST_NAME"].Value  = record.LastName;

                    var rowsAffected = command.ExecuteNonQuery(); // rowsAffected returns -1 even when successful, might look into why this is happening
                }
        }
示例#26
0
        public override DataSet ExecuteDataSet(string strCommandText, CommandType cmdType, params object[] cmdParams)
        {
            OracleConnection objConnection = (OracleConnection)base.objConnection;
            OracleCommand    command       = new OracleCommand(strCommandText, objConnection);
            List <int>       list          = new List <int>();

            command.CommandType = cmdType;
            if (cmdType == CommandType.StoredProcedure)
            {
                try
                {
                    if (objConnection.State != ConnectionState.Open)
                    {
                        objConnection.Open();
                    }
                    OracleCommandBuilder.DeriveParameters(command);
                    objConnection.Close();
                    for (int j = 0; j < command.Parameters.Count; j++)
                    {
                        OracleParameter parameter = command.Parameters[j];
                        if (parameter.OracleType != OracleType.Cursor)
                        {
                            list.Add(j);
                        }
                    }
                }
                catch (OracleException exception)
                {
                    throw exception;
                }
                for (int i = 0; i < list.Count; i++)
                {
                    if (cmdParams.Length <= i)
                    {
                        throw new Exception("Parameter Count does not match.");
                    }
                    command.Parameters[list[i]].Value = cmdParams[i];
                }
            }
            OracleDataAdapter adapter = new OracleDataAdapter(command);
            DataSet           dataSet = new DataSet();

            adapter.Fill(dataSet);
            return(dataSet);
        }
        /// <summary>
        /// Recupera información de parámetro del procedimiento almacenado especificado en SqlCommand
        /// y rellena la colección de Parameters del objeto SqlCommand especificado.
        /// </summary>
        /// <param name="server">Servidor a utilizar</param>
        /// <param name="command">Commando a rellenar con parametros</param>
        public static void DeriveParameter(ServerEnumType server, DbCommand command)
        {
            switch (server)
            {
            case ServerEnumType.SqlServer:
                SqlCommandBuilder.DeriveParameters(command as SqlCommand);
                command.Parameters.RemoveAt("@RETURN_VALUE");
                break;

            case ServerEnumType.MySQL:
                MySqlCommandBuilder.DeriveParameters(command as MySqlCommand);
                break;

            case ServerEnumType.Oracle:
                OracleCommandBuilder.DeriveParameters(command as OracleCommand);
                break;
            }
        }
示例#28
0
        /// <summary>
        /// <para>Dicover the parameters for a stored procedure using a separate connection and command.</para>
        /// </summary>
        /// <param name="parameterToken"><para>The parameter delimeter for database commands.</para></param>
        protected override void DoDiscoverParameters(char parameterToken)
        {
            this.parameterToken = parameterToken;
            using (OracleCommand newCommand = CreateNewCommandAndConnectionForDiscovery())
            {
                // Must use ODP.Net 10.1.0.3.01 to get this method see http://www.oracle.com/technology/docs/tech/windows/odpnet/readme10103.txt.
                OracleCommandBuilder.DeriveParameters(newCommand);

                foreach (IDataParameter parameter in newCommand.Parameters)
                {
                    IDataParameter cloneParameter = (IDataParameter)((ICloneable)parameter).Clone();
                    cloneParameter.ParameterName = cloneParameter.ParameterName;
                    this.command.Parameters.Add(cloneParameter);
                }

                newCommand.Connection.Close();
            }
        }
示例#29
0
        public void DeriveParameters(IDbCommand command)
        {
            var oracleCommand = (OracleCommand)command;

            OracleCommandBuilder.DeriveParameters(oracleCommand);
            //OracleCommand oracleCommand = (OracleCommand)command;
            //oracleCommand.BindByName = true;
            //string commandText = oracleCommand.CommandText;
            //string[] items = commandText.Split('.');
            //string owner = items[0];
            //string packageName = items[1];
            //string objectName = items[2];

            //CommandBuilder.DeriveParameters(oracleCommand.Connection, owner, packageName, objectName, "1", oracleCommand.Parameters);

            //if (command.Parameters.Count == 0)
            //    CommandBuilder.DeriveParameters(oracleCommand.Connection, owner, packageName, objectName, null, oracleCommand.Parameters);
        }
示例#30
0
        public DataTable SPRefcursor(string SP, params object[] parametros)
        {
            try
            {
                DataTable dt = new DataTable();
                connection          = new OracleConnection(oradb);
                command             = new OracleCommand(SP, connection);
                command.CommandType = CommandType.StoredProcedure;
                connection.Open();

                OracleCommandBuilder.DeriveParameters(command);
                int cuenta = 0;

                foreach (OracleParameter pr in command.Parameters)
                {
                    switch (pr.ParameterName)
                    {
                    case "P_REFCURSOR":
                        pr.Direction = ParameterDirection.Output;
                        OracleDataAdapter oda = new OracleDataAdapter(command);
                        command.ExecuteNonQuery();
                        oda.Fill(dt);
                        break;


                    default:
                        pr.Value = parametros[cuenta];
                        cuenta++;
                        break;
                    }
                }

                connection.Close();
                command.Dispose();
                return(dt);
            }
            catch (Exception ex)
            {
                return(null);

                throw;
            }
        }