C# OracleCommand.Prepare方法代码示例

        public static void AtualizarCliente(Cliente Cliente)
        {
            String comandoSql =
                @"UPDATE CLIENTE SET NOME = :NOME, TELEFONE = :TELEFONE, OBSERVACAO = :OBSERVACAO, EMAIL = :EMAIL, RUA = :RUA,
                                    NUMERO = :NUMERO, BAIRRO = :BAIRRO, COMPLEMENTO = :COMPLEMENTO, CIDADE = :CIDADE,
                                    ESTADO = :ESTADO, CEP = :CEP, IDENTIFICACAO = :IDENTIFICACAO, DTNASCIMENTO = :DTNASCIMENTO WHERE CODIGO = :CODIGO";

            OracleConnection conexao = PersistenciaOracle.ObterConexao();

            conexao.Open();
            OracleCommand comando =
                new OracleCommand(comandoSql);

            comando.Connection = conexao;

            comando.Parameters.Add("NOME", Cliente.Nome);
            comando.Parameters.Add("TELEFONE", Cliente.Telefone);
            comando.Parameters.Add("OBSERVACAO", Cliente.Observacao);
            comando.Parameters.Add("EMAIL", Cliente.Email);
            comando.Parameters.Add("RUA", Cliente.Rua);
            comando.Parameters.Add("NUMERO", Cliente.Numero);
            comando.Parameters.Add("BAIRRO", Cliente.Bairro);
            comando.Parameters.Add("COMPLEMENTO", Cliente.Complemento);
            comando.Parameters.Add("CIDADE", Cliente.Cidade);
            comando.Parameters.Add("ESTADO", Cliente.Estado);
            comando.Parameters.Add("CEP", Cliente.CEP);
            comando.Parameters.Add("IDENTIFICACAO", Cliente.Identificacao);
            comando.Parameters.Add("DTNASCIMENTO", Cliente.DtNascimento);

            comando.Parameters.Add("CODIGO", Cliente.Codigo);

            comando.Prepare();
            comando.ExecuteNonQuery();
            conexao.Close();
        }

        public static void Gravar(HistoricoAlteracaoAtendimento historicoAlteracao)
        {
            string sqlInsert = @"INSERT INTO HISTORICOALTERACAOATENDIMENTO
                                (CODIGOOPERADOR,CODIGOCLIENTE,NOMECLIENTE,DATAOPERACAO,
                                 DESCRICAOOPERACAO,NOMEATENDENTE,NOMESERVICO,DTHORAINICIAL,
                                NOMEOPERADOR)
                                VALUES
                                (:CODIGOOPERADOR, :CODIGOCLIENTE, :NOMECLIENTE, :DATAOPERACAO,
                                 :DESCRICAOOPERACAO, :NOMEATENDENTE, :NOMESERVICO, :DTHORAINICIAL,
                                :NOMEOPERADOR)";

            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();

            OracleCommand comando = new OracleCommand(sqlInsert);
            comando.Connection = conexao;
            comando.Parameters.Add("CODIGOOPERADOR", historicoAlteracao.CodigoOperador);
            comando.Parameters.Add("CODIGOCLIENTE", historicoAlteracao.CodigoCliente);
            comando.Parameters.Add("NOMECLIENTE", historicoAlteracao.NomeCliente);
            comando.Parameters.Add("DATAOPERACAO", historicoAlteracao.DataOperacao);
            comando.Parameters.Add("DESCRICAOOPERACAO", historicoAlteracao.DescricaoOperacao);
            comando.Parameters.Add("NOMEATENDENTE", historicoAlteracao.NomeAtendente);
            comando.Parameters.Add("NOMESERVICO", historicoAlteracao.NomeServico);
            comando.Parameters.Add("DTHORAINICIAL", historicoAlteracao.DtHoraInicial);
            comando.Parameters.Add("NOMEOPERADOR", historicoAlteracao.NomeOperador);

            comando.Prepare();
            comando.ExecuteNonQuery();

            conexao.Close();
        }

        public static int AbrirComanda(ComandaResumida comanda)
        {
            String sqlInsert = @"INSERT INTO COMANDAVENDA(NUMEROVENDA,NUMEROCOMANDA,SITUACAO,DATAABERTURA,NOME,TELEFONE)
                                                    VALUES(:NUMEROVENDA,:NUMEROCOMANDA,:SITUACAO,:DATAABERTURA,:NOME,:TELEFONE)";

            comanda.NumeroVenda = PersistenciaOracle.ObterProximoMaximoValor("COMANDAVENDA", "NUMEROVENDA");

            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand(sqlInsert);
            comando.Connection = conexao;

            comando.Parameters.Add("NUMEROVENDA", comanda.NumeroVenda);
            comando.Parameters.Add("NUMEROCOMANDA", comanda.Numero);
            comando.Parameters.Add("SITUACAO",Convert.ToInt32(comanda.Status));
            comando.Parameters.Add("DATAABERTURA", DateTime.Now);
            comando.Parameters.Add("NOME", comanda.Nome);
            comando.Parameters.Add("TELEFONE", comanda.Telefone);
            comando.Prepare();

            comando.ExecuteNonQuery();

            conexao.Close();

            return comanda.NumeroVenda;
        }

        public MuscleGroup Get(long id)
        {
            bool newConnection = _context.OpenConnection();

            try
            {
                const string sqlFetch = "SELECT id, name FROM muscle_group WHERE id = :id";
                var command = new OracleCommand(sqlFetch, _context.DbConnection);
                AddIdParam(command, id);
                command.Prepare();
                OracleDataReader reader = command.ExecuteReader();

                MuscleGroup entity = null;
                while (reader.Read())
                {
                    entity = InstantiateEntityFromReader(reader);
                }
                reader.Close();

                if (entity == null)
                {
                    throw new ApplicationException("Data not found.");
                }

                return entity;
            }
            finally
            {
                if (newConnection)
                {
                    _context.CloseConnection();
                }
            }
        }

        public void Delete(long id)
        {
            _context.OpenConnection();
            _context.BeginTransaction();

            const string sqlDelete = "DELETE FROM muscle_group WHERE id = :id";
            var command = new OracleCommand(sqlDelete, _context.DbConnection);
            AddIdParam(command, id);
            command.Prepare();
            command.ExecuteNonQuery();
        }

        public static List<ResumoAtendimento> ObterResumoAtendimento(DateTime DataInicial, DateTime DataFinal)
        {
            List<ResumoAtendimento> resumos = new List<ResumoAtendimento>();

            String comandoSql = @"SELECT A.NOMEATENDENTE,G.CODIGOSERVICO,S.NOME NOMESERVICO,COUNT(G.CODIGOSERVICO) QUANTIDADESERVICO
                                    FROM ATENDIMENTO A, AGENDAMENTO G, SERVICO S
                                    WHERE  TRUNC(A.DATAATENDIMENTO) BETWEEN TRUNC(:DATAINICIAL) AND TRUNC(:DATAFINAL)
                                        AND G.CODIGOATENDIMENTO = A.CODIGO
                                        AND A.TIPOATENDIMENTO != 4
                                        AND G.CODIGOSERVICO = S.CODIGO
                                        GROUP BY A.NOMEATENDENTE,G.CODIGOSERVICO,S.NOME";

            OracleConnection conexao = Persistencia.PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand(comandoSql);
            comando.Connection = conexao;
            comando.Parameters.Add("DATAINICIAL", DataInicial);
            comando.Parameters.Add("DATAFINAL", DataFinal);
            comando.Prepare();

            List<ResumoAtendimentoRaw> resumosRaw = new List<ResumoAtendimentoRaw>();
            OracleDataReader leitor = comando.ExecuteReader();
            while(leitor.Read())
            {
                ResumoAtendimentoRaw atdRaw = new ResumoAtendimentoRaw();
                atdRaw.NomeAtendente = UtilidadePersistencia.ObterValorTratado<String>(leitor["NOMEATENDENTE"]);
                atdRaw.NomeServico = UtilidadePersistencia.ObterValorTratado<String>(leitor["NOMESERVICO"]);
                atdRaw.CodigoServico = UtilidadePersistencia.ObterValorTratado<int>(leitor["CODIGOSERVICO"]);
                atdRaw.QuantidadeServico = UtilidadePersistencia.ObterValorTratado<int>(leitor["QUANTIDADESERVICO"]);
                resumosRaw.Add(atdRaw);
            }

            List<String> atendentes = resumosRaw.Select(r => r.NomeAtendente).Distinct().ToList();

            foreach (String nomeAtendente in atendentes)
            {
                List<ResumoAtendimentoRaw> resumosRawPorAtendente = resumosRaw.Where(r => r.NomeAtendente.Equals(nomeAtendente)).ToList();
                String descServicos = string.Empty;
                foreach(ResumoAtendimentoRaw resumo in resumosRawPorAtendente)
                {
                    descServicos += String.Format("{0} {1}, ",resumo.NomeServico,resumo.QuantidadeServico);
                }
                descServicos = descServicos.Substring(0, descServicos.Length -(descServicos.Length - descServicos.LastIndexOf(",")));
                resumos.Add(new ResumoAtendimento()
                {
                    NomeAtendente = nomeAtendente,
                    TotalAtendimentos = descServicos
                });
            }

            conexao.Close();

            return resumos;
        }

        public static void GravarParametrizacao(string DescricaoParametro, string Valor)
        {
            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand("UPDATE PARAMETRIZACAO SET VALOR = :VALOR WHERE DESCRICAO = :DESCRICAO");
            comando.Connection = conexao;
            comando.Parameters.Add("VALOR", Valor);
            comando.Parameters.Add("DESCRICAO", DescricaoParametro);

            comando.Prepare();
            comando.ExecuteNonQuery();
            conexao.Close();
        }

        public static void ExcluirBloqueio(Bloqueio BloqueioAtendente)
        {
            String comandoSql = @"DELETE FROM BLOQUEIO WHERE CODIGO = :CODIGO";
            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand(comandoSql);
            comando.Connection = conexao;

            comando.Parameters.Add("CODIGO", BloqueioAtendente.Codigo);
            comando.Prepare();
            comando.ExecuteNonQuery();

            conexao.Close();
        }

 public List<ILogItem> DataSince(DateTime time)
 {
     OracleCommand comm = new OracleCommand(@"SELECT * FROM CSE.CSE_LOG
                                             WHERE ACTIVITY_DTIME > :time order by 1 desc",
                                             conn);
     comm.Parameters.Add(":time", OracleDbType.TimeStamp,
                             time, System.Data.ParameterDirection.Input);
     comm.Connection.Open();
     comm.Prepare();
     OracleDataReader rdr = comm.ExecuteReader();
     var output = BuildObjects(rdr);
     comm.Connection.Close();
     return output;
 }

 public List<ILogItem> DataSinceId(Int32 id)
 {
     OracleCommand comm = new OracleCommand(@"SELECT * FROM CSE.CSE_LOG
                                             WHERE LOG_ID > :id order by LOG_ID desc",
                                 conn);
     comm.Parameters.Add(":id", OracleDbType.Int32,
                             id, System.Data.ParameterDirection.Input);
     comm.Connection.Open();
     comm.Prepare();
     OracleDataReader rdr = comm.ExecuteReader();
     var output = BuildObjects(rdr);
     comm.Connection.Close();
     return output;
 }

        public static void AtualizarBloqueio(Bloqueio BloqueioAtendente)
        {
            String comandoSql = @"UPDATE BLOQUEIO SET HORAFIM = :HORAFIM, TIPOBLOQUEIO = :TIPOBLOQUEIO WHERE CODIGO = :CODIGO";
            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand(comandoSql);
            comando.Connection = conexao;

            comando.Parameters.Add("HORAFIM", BloqueioAtendente.HoraFim);
            comando.Parameters.Add("TIPOBLOQUEIO", (int)BloqueioAtendente.TipoDoBloqueio);
            comando.Parameters.Add("CODIGO", BloqueioAtendente.Codigo);
            comando.Prepare();
            comando.ExecuteNonQuery();

            conexao.Close();
        }

        public static void AtribuirComandaAoAtendimento(Atendimento atd)
        {
            String sqlUpdate = @"UPDATE ATENDIMENTO SET NUMEROCOMANDA = :NUMEROCOMANDA, NUMEROVENDA = :NUMEROVENDA WHERE CODIGO = :CODIGO";

            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand(sqlUpdate);
            comando.Connection = conexao;

            comando.Parameters.Add("NUMEROCOMANDA", atd.NumeroComanda);
            comando.Parameters.Add("NUMEROVENDA", atd.NumeroVenda);
            comando.Parameters.Add("CODIGO", atd.Codigo);

            comando.Prepare();
            comando.ExecuteNonQuery();
            conexao.Close();
        }

        public static void AtualizarOrdem(String NomeAtendente, int Ordem)
        {
            String comandoSql =
                            @"UPDATE ATENDENTE SET ORDEM = :ORDEM WHERE UPPER(NOME) LIKE UPPER(:NOME)";

            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();

            OracleCommand comando = new OracleCommand(comandoSql);
            comando.Connection = conexao;

            comando.Parameters.Add("ORDEM", Ordem);

            comando.Parameters.Add("NOME", NomeAtendente);

            comando.Prepare();
            comando.ExecuteNonQuery();
            conexao.Close();
        }

        public static string ObterValorParametro(string DescricaoParametro)
        {
            string valor = string.Empty;
            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand("SELECT NVL(VALOR,'N') VALOR FROM PARAMETRIZACAO WHERE DESCRICAO LIKE :DESCRICAO");
            comando.Connection = conexao;
            comando.Parameters.Add("DESCRICAO", DescricaoParametro);

            comando.Prepare();
            OracleDataReader leitor = comando.ExecuteReader();
            if(leitor.Read())
            {
                valor = UtilidadePersistencia.ObterValorTratado<String>(leitor[0]);
            }

            conexao.Close();
            return valor;
        }

        public static List<HistoricoAlteracaoAtendimento> ObterHistoricoAlteracaoAtendimento(string Nome, DateTime Data)
        {
            List<HistoricoAlteracaoAtendimento> historico = new List<HistoricoAlteracaoAtendimento>();
            string sql = @"SELECT CODIGOOPERADOR,CODIGOCLIENTE,NOMECLIENTE,DATAOPERACAO,
                                  DESCRICAOOPERACAO,NOMEATENDENTE,NOMESERVICO,DTHORAINICIAL,
                                  NOMEOPERADOR FROM HISTORICOALTERACAOATENDIMENTO
                                    WHERE TRUNC(DATAOPERACAO) = TRUNC(:Data)";

            if(!string.IsNullOrEmpty(Nome))
            {
                sql += " AND UPPER(NOMECLIENTE) LIKE '" + Nome.ToUpper() + "%'";
            }

            sql += " ORDER BY DATAOPERACAO ASC";

            OracleConnection conexao = PersistenciaOracle.ObterConexao();
            conexao.Open();
            OracleCommand comando = new OracleCommand(sql);
            comando.Connection = conexao;
            comando.Parameters.Add("DATA", Data);
            comando.Prepare();

            OracleDataReader leitor = comando.ExecuteReader();
            while(leitor.Read())
            {
                HistoricoAlteracaoAtendimento hist = new HistoricoAlteracaoAtendimento();
                hist.CodigoOperador = UtilidadePersistencia.ObterValorTratado<decimal>(leitor["CODIGOOPERADOR"]);
                hist.CodigoCliente = UtilidadePersistencia.ObterValorTratado<decimal>(leitor["CODIGOCLIENTE"]);
                hist.NomeCliente = UtilidadePersistencia.ObterValorTratado<string>(leitor["NOMECLIENTE"]);
                hist.DataOperacao = UtilidadePersistencia.ObterValorDateTimeTratado<DateTime?>(leitor["DATAOPERACAO"]);
                hist.DescricaoOperacao = UtilidadePersistencia.ObterValorTratado<string>(leitor["DESCRICAOOPERACAO"]);
                hist.NomeAtendente = UtilidadePersistencia.ObterValorTratado<string>(leitor["NOMEATENDENTE"]);
                hist.NomeServico = UtilidadePersistencia.ObterValorTratado<string>(leitor["NOMESERVICO"]);
                hist.DtHoraInicial = UtilidadePersistencia.ObterValorDateTimeTratado<DateTime?>(leitor["DTHORAINICIAL"]);
                hist.NomeOperador = UtilidadePersistencia.ObterValorTratado<string>(leitor["NOMEOPERADOR"]);
                historico.Add(hist);
            }

            conexao.Close();
            return historico;
        }