Resumo da experiência: análise de ASP e procedimentos armazenados

Existem muitos artigos sobre ASP e procedimentos armazenados (Stored Procedures), mas duvido que os autores realmente os tenham praticado. Quando eu era iniciante, consultei muitas informações relevantes e descobri que muitos dos métodos fornecidos não eram os mesmos na prática. Para aplicações simples, esses materiais podem ser úteis, mas estão limitados a isso, porque são basicamente iguais e copiam uns aos outros. Para aplicações um pouco mais complexas, eles não são claros.
Agora, basicamente acesso o SQL Server chamando procedimentos armazenados. Embora não seja possível garantir que o texto a seguir esteja absolutamente correto, espero que seja útil para todos.
Um procedimento armazenado é um ou mais comandos SQL armazenados no banco de dados como objetos executáveis.
As definições são sempre abstratas. Um procedimento armazenado é na verdade um conjunto de instruções SQL que podem completar determinadas operações, mas esse conjunto de instruções é colocado no banco de dados (aqui falamos apenas sobre SQL Server). Se criarmos procedimentos armazenados e chamarmos procedimentos armazenados em ASP, poderemos evitar misturar instruções SQL com código ASP. Há pelo menos três benefícios em fazer isso:
Primeiro, melhore muito a eficiência. A velocidade de execução do procedimento armazenado em si é muito rápida e a chamada do procedimento armazenado pode reduzir bastante o número de interações com o banco de dados.
Em segundo lugar, melhore a segurança. Se você misturar instruções SQL em código ASP, uma vez que o código seja comprometido, isso também significa que a estrutura da biblioteca será comprometida.
Terceiro, é propício à reutilização de instruções SQL.

No ASP, os procedimentos armazenados geralmente são chamados por meio do objeto de comando. Dependendo da situação, este artigo também apresenta outros métodos de chamada. Para maior comodidade de explicação, são feitas as seguintes classificações simples de acordo com a entrada e saída do processo armazenado:
1. O procedimento armazenado que retorna apenas um único conjunto de registros assume o seguinte procedimento armazenado (o objetivo deste artigo não é descrever a sintaxe T-SQL, portanto, o procedimento armazenado apenas fornece o código sem explicação):

/*SP1*/
CRIAR PROCEDIMENTO dbo.getUserList
como
ativar nocount
começar
selecione * de dbo.[userinfo]
fim

go

obtém todos os registros na tabela userinfo e retorna um conjunto de registros. O código ASP para chamar o procedimento armazenado por meio do objeto Command é o seguinte:

'**Chamar o procedimento armazenado por meio do objeto Command**
DIM MyComm,MyRst
Definir MyComm = Server.CreateObject("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
MyComm.CommandText = "getUserList" 'Especifique o nome do procedimento armazenado
MyComm.CommandType = 4 'Indica que este é um procedimento armazenado
MyComm.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
Definir MyRst = MyComm.Execute
Set MyComm = Nothing

O conjunto de registros obtido pelo procedimento armazenado é atribuído a MyRst. Em seguida, MyRst pode ser operado.
No código acima, o atributo CommandType indica o tipo de solicitação. O valor e a descrição são os seguintes:
-1 indica que o tipo do parâmetro CommandText não pode ser determinado
1 indica que CommandText é um tipo de comando geral
2 indica que o parâmetro CommandText é um nome de tabela existente
4 Indica que o parâmetro CommandText é o nome de um procedimento armazenado

. O procedimento armazenado também pode ser chamado através do objeto Connection ou do objeto Recordset. Os métodos são os seguintes:

'**Chamar o procedimento armazenado através do objeto Connection**.
DIM MyConn,MyRst
Definir MyConn = Server.CreateObject("ADODB.Connection")
MyConn.open MyConStr 'MyConStr é a string de conexão do banco de dados
Set MyRst = MyConn.Execute("getUserList",0,4) 'O último parâmetro tem o mesmo significado que CommandType
Set MyConn = Nothing

'**Chamar procedimento armazenado através do objeto Recordset**
DIM MyRst
Definir MyRst = Server.CreateObject("ADODB.Recordset")
MyRst.open "getUserList",MyConStr,0,1,4
'MyConStr é a string de conexão do banco de dados, o último parâmetro tem o mesmo significado que CommandType

2. Para procedimentos armazenados sem entrada e saída, consulte os seguintes procedimentos armazenados:

/*SP2*/
CRIAR PROCEDIMENTO dbo.delUserAll
como
ativar nocount
começar
excluir do dbo.[userinfo]
fim

go

exclui todos os registros da tabela userinfo sem qualquer entrada ou saída. O método de chamada é basicamente o mesmo mencionado acima, exceto que não há necessidade de obter o conjunto de registros:

'**Chame o procedimento armazenado por meio do comando. objeto**
DIM MeuComm
Definir MyComm = Server.CreateObject("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
MyComm.CommandText = "delUserAll" 'Especifique o nome do procedimento armazenado
MyComm.CommandType = 4 'Indica que este é um procedimento armazenado
MyComm.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
MyComm.Execute 'Não há necessidade de obter o registro definido aqui
Definir MyComm = Nothing

É claro que esses procedimentos armazenados também podem ser chamados por meio do objeto Connection ou do objeto Recordset, mas o objeto Recordset é criado para obter o conjunto de registros. Se o conjunto de registros não for retornado, é melhor usar o objeto Command.

3. Ao realizar operações semelhantes ao SP2, os procedimentos armazenados com valores de retorno devem fazer uso total dos poderosos recursos de processamento de transações do SQL Server para manter a consistência dos dados. Além disso, podemos precisar que o procedimento armazenado retorne o status de execução. Para esse fim, modifique o SP2 da seguinte maneira:

/*SP3*/.
CRIAR PROCEDIMENTO dbo.delUserAll
como
ativar nocount
começar
INICIAR TRANSAÇÃO
excluir do dbo.[userinfo]
SE @@erro=0
começar
COMPROMETIR TRANSAÇÃO
retornar 1
fim
OUTRO
começar
TRANSAÇÃO DE REVERSÃO
retornar 0
fim
retornar
fim

go

retorna 1 quando a exclusão é executada com sucesso, caso contrário, retorna 0 e executa a operação de reversão. Para obter o valor de retorno em ASP, você precisa usar a coleção Parameters para declarar os parâmetros:

'**Chame o procedimento armazenado com o valor de retorno e obtenha o valor de retorno**
DIM MyComm,MyPara
Definir MyComm = Server.CreateObject("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
MyComm.CommandText = "delUserAll" 'Especifique o nome do procedimento armazenado
MyComm.CommandType = 4 'Indica que este é um procedimento armazenado
MyComm.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
'Declara valor de retorno
Definir Mypara = MyComm.CreateParameter("RETURN",2,4)
MyComm.Parameters.Append MyPara
MeuComm.Execute
'Obtém o valor de retorno
DIM retValor
retValue = MyComm(0) 'ou retValue = MyComm.Parameters(0)
Defina MyComm = Nothing

Em MyComm.CreateParameter("RETURN",2,4), o significado de cada parâmetro é o seguinte:
O primeiro parâmetro ("RETURE") é o nome do parâmetro. O nome do parâmetro pode ser definido arbitrariamente, mas geralmente deve ser igual ao nome do parâmetro declarado no procedimento armazenado. Aqui está o valor de retorno, normalmente defino como "RETURE";
O segundo parâmetro (2) indica o tipo de dados do parâmetro. Consulte a referência ADO para obter códigos de tipo específicos abaixo:
adBigInt: 20;
adBinário: 128;
adBooleano: 11;
adChar: 129;
adDBTimeStamp: 135;
adVazio: 0;
anúncioInteiro: 3;
anúncioSmallInt: 2;
adTinyInt: 16;
adVarChar: 200;

Para o valor de retorno, apenas valores inteiros podem ser obtidos e -1 a -99 são valores reservados;
O terceiro parâmetro (4) indica a natureza do parâmetro, onde 4 indica que este é um valor de retorno. A descrição do valor deste parâmetro é a seguinte:
0: O tipo não pode ser determinado; 1: Parâmetros de entrada 2: Parâmetros de entrada 3: Parâmetros de entrada ou saída 4: Valor de retorno

O código ASP fornecido acima deve ser considerado um código completo, ou seja, o código mais complexo; Na verdade,

defina Mypara = MyComm.CreateParameter("RETURN",2,4)
MyComm.Parameters.Append MyPara

pode ser simplificado para

MyComm.Parameters.Append MyComm.CreateParameter("RETURN",2,4)

e pode até continuar a ser simplificado, o que será explicado mais tarde.
Para procedimentos armazenados com parâmetros, eles só podem ser chamados usando o objeto Command (também há informações de que eles podem ser chamados através do objeto Connection ou do objeto Recordset, mas ainda não tentei).

4. O valor de retorno de um procedimento armazenado com parâmetros de entrada e parâmetros de saída é, na verdade, um parâmetro de entrada especial. Na maioria dos casos, usamos procedimentos armazenados que possuem parâmetros de entrada e saída. Por exemplo, queremos obter o nome de usuário de um usuário com um determinado ID na tabela de informações do usuário. --user ID e um parâmetro de saída ----nome do usuário. O procedimento armazenado para implementar esta função é o seguinte:

/*SP4*/
CRIAR PROCEDIMENTO dbo.getUserName
@UserIDint,
Saída @UserName varchar(40)
como
ativar nocount
começar
se @UserID for retorno nulo
selecione @UserName=nome de usuário
de dbo.[userinfo]
onde userid=@UserID
retornar
fim

chamar

o procedimento armazenado é o seguinte:

'**Chamar um procedimento armazenado com parâmetros de entrada e saída**
DIM MeuComm,UserID,Nome de usuário
ID do usuário = 1
Definir MyComm = Server.CreateObject("ADODB.Command")
MyComm.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
MyComm.CommandText = "getUserName" 'Especifique o nome do procedimento armazenado
MyComm.CommandType = 4 'Indica que este é um procedimento armazenado
MyComm.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
'Declara parâmetros
MyComm.Parameters.append MyComm.CreateParameter("@UserID",3,1,4,UserID)
MyComm.Parameters.append MyComm.CreateParameter("@UserName",200,2,40)
MeuComm.Execute
'Pegue os parâmetros
Nome de usuário = MeuCom(1)
Definir MyComm = Nothing

No código acima, você pode ver que, diferentemente da declaração do valor de retorno, 5 parâmetros são necessários ao declarar parâmetros de entrada e 4 parâmetros são necessários ao declarar parâmetros de saída. Ao declarar parâmetros de entrada, os cinco parâmetros são: nome do parâmetro, tipo de dados do parâmetro, tipo de parâmetro, comprimento dos dados e valor do parâmetro. Ao declarar parâmetros de entrada, não existe um último parâmetro: o valor do parâmetro.

Atenção especial deve ser dada: ao declarar parâmetros, a ordem deve ser a mesma definida no procedimento armazenado, e o tipo de dados e comprimento de cada parâmetro também devem ser iguais aos definidos no procedimento armazenado.

Se o procedimento armazenado tiver vários parâmetros, o código ASP parecerá complicado. Você pode usar o comando with para simplificar o código:

'**Chamar um procedimento armazenado com parâmetros de entrada e saída (código simplificado)**.
DIM MeuComm,UserID,Nome de usuário
ID do usuário = 1
Definir MyComm = Server.CreateObject("ADODB.Command")
with MyComm

.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
.CommandText = "getUserName" 'Especifique o nome do procedimento armazenado
.CommandType = 4 'Indica que este é um procedimento armazenado
.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
.Parameters.append .CreateParameter("@UserID",3,1,4,UserID)
.Parameters.append .CreateParameter("@UserName",200,2,40)
.Executar
terminar com
Nome de usuário = MeuCom(1)
Set MyComm = Nothing

Se quisermos obter os nomes de usuário de 10 usuários com IDs de 1 a 10, precisamos criar o objeto Command 10 vezes? Não, se você precisar chamar o mesmo procedimento armazenado várias vezes, você só precisará alterar os parâmetros de entrada e obterá parâmetros de entrada diferentes:

'**Chame o mesmo procedimento armazenado várias vezes**
DIM MeuComm,UserID,Nome de usuário
Nome de usuário = ""
Definir MyComm = Server.CreateObject("ADODB.Command")
para UserID = 1 a 10
comMeuComm
.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
.CommandText = "getUserName" 'Especifique o nome do procedimento armazenado
.CommandType = 4 'Indica que este é um procedimento armazenado
.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
se UserID = 1 então
.Parameters.append .CreateParameter("@UserID",3,1,4,UserID)
.Parameters.append .CreateParameter("@UserName",200,2,40)
.Executar
outro
'Reatribuir valores aos parâmetros de entrada (parâmetros de entrada e parâmetros de saída cujos valores de parâmetros não mudam neste momento não precisam ser declarados novamente)
.Parameters("@UserID") = ID do usuário
.Executar
terminar se
terminar com
UserName = UserName + MyComm(1) + "," 'Talvez você goste de usar armazenamento em array
próximo
Set MyComm = Nothing

Como pode ser visto no código acima: ao chamar o mesmo procedimento armazenado repetidamente, você só precisa reatribuir os parâmetros de entrada cujos valores foram alterados. Este método possui vários parâmetros de entrada e saída, e apenas um é chamado. cada vez. A quantidade de código pode ser bastante reduzida quando o valor do parâmetro de entrada muda.

5. Procedimentos armazenados que possuem valores de retorno, parâmetros de entrada e parâmetros de saída ao mesmo tempo Conforme mencionado anteriormente, ao chamar um procedimento armazenado, a ordem na qual os parâmetros são declarados deve ser a mesma ordem definida no procedimento armazenado. . Outro ponto ao qual devemos prestar atenção especial: se o procedimento armazenado tiver um valor de retorno e parâmetros de entrada e saída, o valor de retorno deverá ser declarado primeiro.
Para demonstrar o método de chamada neste caso, vamos melhorar o exemplo acima. Ainda obtenha o nome de usuário do usuário com ID 1, mas é possível que o usuário não exista (o usuário foi excluído e o ID do usuário é um campo de aumento automático). O procedimento armazenado retorna valores diferentes dependendo se o usuário existe ou não. Neste momento, o procedimento armazenado e o código ASP são os seguintes:

/*SP5*/
CRIAR PROCEDIMENTO dbo.getUserName
--Para aprofundar a impressão de “ordem”, inverta a ordem de definição dos dois parâmetros a seguir.
Saída @UserName varchar(40),
@UserIDint
como
ativar nocount
começar
se @UserID for retorno nulo
selecione @UserName=nome de usuário
de dbo.[userinfo]
onde userid=@UserID
se @@rowcount>0
retornar 1
outro
retornar 0
retornar
fim
vá

'**Chame um procedimento armazenado com valor de retorno, parâmetros de entrada e parâmetros de saída**
DIM MeuComm,UserID,Nome de usuário
ID do usuário = 1
Definir MyComm = Server.CreateObject("ADODB.Command")
comMeuComm
.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
.CommandText = "getUserName" 'Especifique o nome do procedimento armazenado
.CommandType = 4 'Indica que este é um procedimento armazenado
.Prepared = true 'Requer que os comandos SQL sejam compilados primeiro

' O valor de retorno deve ser declarado primeiro
.Parameters.Append .CreateParameter("RETURN",2,4)
'A ordem de declaração dos dois parâmetros a seguir também é invertida de acordo.
.Parameters.append .CreateParameter("@UserName",200,2,40)
.Parameters.append .CreateParameter("@UserID",3,1,4,UserID)
.Executar
terminar com
se MeuCom(0) = 1 então
Nome de usuário = MeuCom(1)
outro
UserName = "Este usuário não existe"
terminar se
Set MyComm = Nothing

6. Procedimentos armazenados que retornam parâmetros e conjuntos de registros ao mesmo tempo Às vezes, precisamos de procedimentos armazenados para retornar parâmetros e conjuntos de registros ao mesmo tempo. Por exemplo, ao usar procedimentos armazenados para paginação, precisamos retornar esses parâmetros. como conjuntos de registros e dados totais ao mesmo tempo. A seguir está um procedimento armazenado para paginação:

/*SP6*/
CRIAR PROCEDIMENTO dbo.getUserList
@iPageCount int OUTPUT, --Número total de páginas
@iPage int, --Número da página atual
@iPageSize int --Número de registros por página
como
ativar nocount
começar
--Cria tabela temporária
criar tabela #t (ID int IDENTITY, --campo de incremento automático
ID do usuário interno,
nome de usuário varchar(40))
--Escreve dados na tabela temporária
insira em #t
selecione ID do usuário, nome de usuário de dbo.[UserInfo]
order by userid

--Obtém o número total de registros
declare @iRecordCount int
set @iRecordCount = @@rowcount

--determine o número total de páginas
SE @iRecordCount%@iPageSize=0
SET @iPageCount=CEILING(@iRecordCount/@iPageSize)
OUTRO
SET @iPageCount=CEILING(@iRecordCount/@iPageSize)+1

--Se o número da página solicitada for maior que o número total de páginas, a última página será exibida
SE @iPage > @iPageCount
SELECT @iPage = @iPageCount

– determina o início e o fim da página atual
DECLARE @iStart int --iniciar registro
DECLARE @iEnd int --end registro
SELECIONE @iStart = (@iPage - 1) * @iPageSize
SELECT @iEnd = @iStart + @iPageSize + 1

--Obtém o registro da página atual
selecione * de #t onde ID>@iStart e ID<@iEnd

--Delete tabela temporária
DROP TABLE #t

--retorna o número total de registros
retornar @iRecordCount
fim

No procedimento armazenado acima,

go

Para ser mais típico, o número total de registros é retornado como um valor de retorno. A seguir está o código ASP que chama o procedimento armazenado (a operação de paginação específica é omitida):

'**Chamar o procedimento armazenado de paginação**
DIM página agora, tamanho da página, contagem de páginas, contagem de registros
DIM MyComm,MyRst
pagenow = Solicitação("pn")
'Função personalizada usada para verificar números naturais
se CheckNar(pagenow) = falso então pagenow = 1
tamanho da página = 20
Defina MyComm = Server.CreateObject("ADODB.Command")

com MyComm
.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
.CommandText = "getUserList" 'Especifique o nome do procedimento armazenado
.CommandType = 4 'Indica que este é um procedimento armazenado
.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
'Valor de retorno (número total de registros)
.Parameters.Append .CreateParameter("RETURN",2,4)
'Parâmetros de saída (número total de páginas)
.Parameters.Append .CreateParameter("@iPageCount",3,2)
'Parâmetros de entrada (número da página atual)
.Parameters.append .CreateParameter("@iPage",3,1,4,pagenow)
'Parâmetros de entrada (número de registros por página)
.Parameters.append .CreateParameter("@iPageSize",3,1,4,pagesize)
SetMyRst = .Execute
terminar com
se MyRst.state = 0 then 'Nenhum dado foi obtido, MyRst está fechado
contagem de registros = -1
outro
MyRst.close 'Nota: Para obter valores de parâmetros, você precisa primeiro fechar o objeto recordset
contagem de registros = MeuCom(0)
contagem de páginas = MeuCom(1)
if cint(pagenow)>=cint(pagecount) then pagenow=pagecount
terminar se
Set MyComm = Nothing

'Exibir registros abaixo
se contagem de registros = 0 então
Resposta.Escreva "Sem registro"
elseif contagem de registros > 0 então
MeuRst.open
faça até MyRst.EOF
...
laço
'O seguinte exibe informações de paginação
...
else 'contagem de registros=-1
Response.Write "Erro de parâmetro"
end if

Em relação ao código acima, há apenas um ponto que precisa ser explicado: ao retornar o conjunto de registros e os parâmetros ao mesmo tempo, se você deseja obter os parâmetros, você precisa primeiro fechar o conjunto de registros e depois abri-lo quando usando o conjunto de registros.

7. Procedimentos armazenados que retornam vários conjuntos de registros A primeira coisa que este artigo apresenta são os procedimentos armazenados que retornam conjuntos de registros. Às vezes, um procedimento armazenado é necessário para retornar vários conjuntos de registros. No ASP, como obter esses conjuntos de registros ao mesmo tempo? Para ilustrar este problema, adicione dois campos à tabela userinfo: usertel e usermail, e defina que apenas usuários logados possam visualizar esses dois conteúdos.

/*SP7*/
CRIAR PROCEDIMENTO dbo.getUserInfo
@useridint,
@checklogin bit
como
ativar nocount
começar
se @userid for nulo ou @checklogin for nulo, retorne
selecione nome de usuário
de dbo.[usrinfo]
onde ID do usuário=@ID do usuário
--Se você for um usuário logado, pegue usertel e usermail
se @checklogin=1
selecione usertel,usermail
de dbo.[userinfo]
onde ID do usuário=@ID do usuário
retornar
fim

seguir

está o código ASP:

'**Chama um procedimento armazenado que retorna vários conjuntos de registros**
DIM checklg,UserID,UserName,UserTel,UserMail
DIM MyComm,MyRst
ID do usuário = 1
'checklogin() é uma função personalizada para determinar se o visitante está logado
checklg = checklogin()
Definir MyComm = Server.CreateObject("ADODB.Command")
with MyComm

.ActiveConnection = MyConStr 'MyConStr é a string de conexão do banco de dados
.CommandText = "getUserList" 'Especifique o nome do procedimento armazenado
.CommandType = 4 'Indica que este é um procedimento armazenado
.Prepared = true 'Requer que comandos SQL sejam compilados primeiro
.Parameters.append .CreateParameter("@userid",3,1,4,UserID)
.Parameters.append .CreateParameter("@checklogin",11,1,1,checklg)
SetMyRst = .Execute
terminar com
Set MyComm = Nothing

'Obtém o valor do primeiro conjunto de registros
Nome de usuário = MyRst(0)
'Obtém o valor do segundo conjunto de registros
se não MyRst não é nada então
Definir MyRst = MyRst.NextRecordset()
TelUsuário = MeuRst(0)
UserMail = MeuRst(1)
terminar se
Set MyRst = Nothing

No código acima, o método NextRecordset do objeto Recordset é usado para obter vários conjuntos de registros retornados pelo procedimento armazenado.

Até agora, este artigo forneceu uma explicação relativamente abrangente de diversas situações nas quais o ASP chama procedimentos armazenados. Finalmente, vamos falar sobre os diferentes métodos de chamada de vários procedimentos armazenados em um programa ASP.
Em um programa ASP, pelo menos os três métodos a seguir são viáveis ​​para chamar vários procedimentos armazenados:
1. Crie vários objetos Command.

DIM MeuComm
Definir MyComm = Server.CreateObject("ADODB.Command")
'Chama o procedimento armazenado um
...
Definir MyComm = Nada
Definir MyComm = Server.CreateObject("ADODB.Command")
'Chama o procedimento armazenado dois
...
Definir MyComm = Nada
......

2. Crie apenas um objeto Command, e ao finalizar uma chamada, limpe seu parâmetro

DIM MyComm
Definir MyComm = Server.CreateObject("ADODB.Command")
'Chama o procedimento armazenado um
.....
'Limpar parâmetros (assumindo que existem três parâmetros)
MeuComm.Parâmetros.delete 2
MeuComm.Parâmetros.delete 1
MeuComm.Parâmetros.delete 0
'Chama o procedimento armazenado dois e limpa os parâmetros
...
Definir MyComm = Nothing

Neste momento, observe: a ordem de limpeza dos parâmetros é oposta à ordem de declaração dos parâmetros. Não sei o motivo.

3. Use o método Refresh da coleta de dados de parâmetros para redefinir o objeto de parâmetro

DIM MyComm
Definir MyComm = Server.CreateObject("ADODB.Command")
'Chama o procedimento armazenado um
.....
'Redefinir todos os objetos Parameter contidos na coleção de dados Parameters
MyComm.Parameters.Refresh
'Chama o procedimento armazenado dois
.....
Definir MyComm = Nothing

Geralmente acredita-se que criar objetos repetidamente é um método menos eficiente, mas após o teste (a ferramenta de teste é o Microsoft Application Center Test), os resultados são inesperados:
Método 2 >= Método 1 >> Método 3
A velocidade de execução do método 2 é maior ou igual ao método 1 (até cerca de 4% maior). A velocidade de execução desses dois métodos é muito mais rápida que a do método 3 (até 130%). método 1 quando houver muitos parâmetros. Caso contrário, use o método 2.

Levei um dia para finalmente escrever um pouco da minha experiência superficial em chamar procedimentos armazenados em ASP. Entre eles, alguns deles eu só conheço os efeitos, mas não as causas, e alguns podem estar errados, mas tudo isso ocorre através da minha prática pessoal. Por favor, aceitem-no criticamente, leitores. Se você tiver alguma opinião diferente, por favor me avise. Agradecemos antecipadamente.