{"id":11147,"date":"2021-05-27T08:01:06","date_gmt":"2021-05-27T15:01:06","guid":{"rendered":"https:\/\/www.couchbase.com\/blog\/?p=11147"},"modified":"2025-06-13T19:40:16","modified_gmt":"2025-06-14T02:40:16","slug":"sql-nosql-comparison-aspnet-application","status":"publish","type":"post","link":"https:\/\/www.couchbase.com\/blog\/pt\/sql-nosql-comparison-aspnet-application\/","title":{"rendered":"Compara\u00e7\u00e3o entre SQL e NoSQL: Aplicativo ASP.NET"},"content":{"rendered":"
\n

Essa compara\u00e7\u00e3o entre SQL e NoSQL \u00e9 a pr\u00f3xima etapa ap\u00f3s a convers\u00e3o do seu banco de dados do SQL Server para o Couchbase. Em a postagem anterior<\/a>Em um dos meus testes, copiei o AdventureWorks do SQL Server para o Couchbase.<\/p>\n<\/div>\n

\n

Nesta postagem, mostrarei um aplicativo ASP.NET Core que usa o SQL Server e como esse mesmo aplicativo usaria o Couchbase. Se quiser acompanhar, voc\u00ea pode conferir o Projeto SqlServerToCouchbase<\/a> no GitHub.<\/p>\n<\/div>\n

\n

Ao contr\u00e1rio da postagem anterior, n\u00e3o estou tentando fazer uma convers\u00e3o \"autom\u00e1tica\" de um aplicativo. Em vez disso, pense nisso mais como uma compara\u00e7\u00e3o entre SQL e NoSQL no n\u00edvel do aplicativo.<\/p>\n<\/div>\n

\n

Aplicativos ASP.NET SQL Server<\/h2>\n
\n
\n

Criei um aplicativo muito simples no estilo da API REST do ASP.NET Core. Usei o Entity Framework, mas se voc\u00ea estiver usando Dapper, ADO.NET, NHibernate etc., ainda poder\u00e1 acompanhar o processo.<\/p>\n<\/div>\n

\n

Cada endpoint retorna JSON. Tamb\u00e9m adicionei o Swashbuckle ao projeto, para que voc\u00ea possa emitir solicita\u00e7\u00f5es diretamente do navegador via OpenAPI.<\/p>\n<\/div>\n<\/div>\n<\/div>\n

\n

Aplicativo do servidor ASP.NET Couchbase<\/h2>\n
\n
\n

A vers\u00e3o Couchbase do aplicativo retorna os mesmos dados, porque est\u00e1 usando os mesmos dados do SQL Server AdventureWorks.<\/p>\n<\/div>\n

\n

No aplicativo, estou usando o SDK do Couchbase .NET<\/a> e Transa\u00e7\u00f5es do Couchbase<\/a> bibliotecas. (Voc\u00ea poderia usar Linq2Couchbase<\/a> como um tipo de substitui\u00e7\u00e3o do Entity Framework).<\/p>\n<\/div>\n

\n

Caso contr\u00e1rio, o aplicativo \u00e9 o mesmo, fornecendo uma compara\u00e7\u00e3o (e contraste) entre SQL e NoSQL. Os pontos de extremidade est\u00e3o retornando JSON, e o Swashbuckle est\u00e1 instalado.<\/p>\n<\/div>\n

\n

H\u00e1 um controlador em cada amostra. Vamos examinar cada endpoint no controlador e realizar uma compara\u00e7\u00e3o SQL e NoSQL.<\/p>\n<\/div>\n<\/div>\n<\/div>\n

\n

Compara\u00e7\u00e3o entre SQL e NoSQL: Obter por ID<\/h2>\n
\n
\n

Vamos come\u00e7ar com o GetPersonByIdAsync<\/code> endpoint. Dado um ID de pessoa, esse ponto de extremidade retorna os dados da pessoa para o ID fornecido.<\/p>\n<\/div>\n

\n

SQL Server<\/h3>\n
\n

Aqui est\u00e1 o exemplo do SQL Server usando o Entity Framework:<\/p>\n<\/div>\n

\n
\n
[HttpGet(\"\/person\/{personId}\")]\r\npublic async Task<IActionResult> GetPersonByIdAsync(int personId)\r\n{\r\n    var person = await _context.Persons\r\n        .SingleOrDefaultAsync(p => p.BusinessEntityID == personId);\r\n\r\n    return Ok(person);\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
Tamb\u00e9m escrevi outra vers\u00e3o desse m\u00e9todo, chamada GetPersonByIdRawAsync<\/code> que usa uma consulta SQL \"bruta\". Essa consulta \u00e9 muito parecida com a que o Entity Framework (acima) gera, e \u00e9 semelhante a uma abordagem Dapper.<\/p>\n<\/div>\n
\n
\n
[HttpGet(\"\/personRaw\/{personId}\")]\r\npublic async Task<IActionResult> GetPersonByIdRawAsync(int personId)\r\n{\r\n    var person = await _context.Persons\r\n        .FromSqlRaw(@\"SELECT * FROM Person.Person WHERE BusinessEntityID = {0}\", personId)\r\n        .SingleOrDefaultAsync();\r\n\r\n    return Ok(person);\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
Observe que, de qualquer forma, uma consulta SQL est\u00e1 sendo executada.<\/p>\n<\/div>\n
\n
Com o N1QL, podemos consultar os dados no Couchbase de forma muito semelhante. Aqui est\u00e1 o GetPersonByIdRawAsync<\/code> no projeto Couchbase:<\/p>\n<\/div>\n
\n
\n
[HttpGet(\"\/personRaw\/{personId}\")]\r\npublic async Task<IActionResult> GetPersonByIdRawAsync(int personId)\r\n{\r\n    var bucket = await _bucketProvider.GetBucketAsync();\r\n    var cluster = bucket.Cluster;\r\n    var personResult = await cluster.QueryAsync<Person>(@\"\r\n        SELECT p.* FROM AdventureWorks2016.Person.Person p WHERE p.BusinessEntityID = $personId\",\r\n        new QueryOptions().Parameter(\"personId\", personId));\r\n    return Ok(await personResult.Rows.SingleOrDefaultAsync());\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
(H\u00e1 uma etapa extra que vai de \"bucket\" para \"cluster\". Ela poderia ser ignorada, mas como uso bucket em outras partes do controlador, deixei-a l\u00e1).<\/p>\n<\/div>\n
\n
No entanto, o uso de uma consulta N1QL envolve alguma sobrecarga extra (indexa\u00e7\u00e3o, an\u00e1lise de consulta etc.). Com o Couchbase, se j\u00e1 soubermos o ID da pessoa, podemos ignorar uma consulta N1QL e fazer uma pesquisa direta de chave\/valor (K\/V).<\/p>\n<\/div>\n<\/div>\n
\n
Obter por ID com K\/V<\/h3>\n
\n
A chave j\u00e1 \u00e9 conhecida; ela \u00e9 fornecida como um argumento. Em vez de usar SQL, vamos fazer uma pesquisa de chave\/valor. Fiz isso em um m\u00e9todo de endpoint chamado GetPersonByIdAsync<\/code>:<\/p>\n<\/div>\n
\n
\n
[HttpGet(\"\/person\/{personId}\")]\r\npublic async Task<IActionResult> GetPersonByIdAsync(int personId)\r\n{\r\n    var bucket = await _bucketProvider.GetBucketAsync();\r\n    var scope = await bucket.ScopeAsync(\"Person\");\r\n    var coll = await scope.CollectionAsync(\"Person\");\r\n    var personDoc = await coll.GetAsync(personId.ToString());\r\n    return Ok(personDoc.ContentAs<Person>());\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
Ao contr\u00e1rio do SQL Server, o Couchbase oferece suporte a uma variedade de APIs para interagir com os dados. Nesse caso, a pesquisa de chave\/valor estar\u00e1 extraindo o documento Person diretamente da mem\u00f3ria. N\u00e3o h\u00e1 necessidade de analisar uma consulta SQL ou usar qualquer indexa\u00e7\u00e3o. As pesquisas de chave\/valor no Couchbase geralmente s\u00e3o medidas em microssegundos.<\/p>\n<\/div>\n
\n
Minha recomenda\u00e7\u00e3o: use a pesquisa de chave\/valor sempre que poss\u00edvel.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
Obter uma entidade expandida por ID<\/h2>\n
\n
\n
Os dados podem ser complexos e abranger v\u00e1rias tabelas (ou v\u00e1rios documentos, no caso do Couchbase). Dependendo das ferramentas que estiver usando, voc\u00ea pode ter alguma funcionalidade que possa carregar entidades relacionadas.<\/p>\n<\/div>\n
\n
Por exemplo, com o Entity Framework, voc\u00ea pode usar um Incluir<\/code> para atrair entidades relacionadas, como mostrado neste GetPersonByIdExpandedAsync<\/code> exemplo:<\/p>\n<\/div>\n
\n
\n
[HttpGet(\"\/personExpanded\/{personId}\")]\r\npublic async Task<IActionResult> GetPersonByIdExpandedAsync(int personId)\r\n{\r\n    var person = await _context.Persons\r\n        .Include(p => p.EmailAddresses)\r\n        .SingleOrDefaultAsync(p => p.BusinessEntityID == personId);\r\n\r\n    return Ok(person);\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
Nos bastidores, o Entity Framework pode gerar uma consulta JOIN e\/ou v\u00e1rias consultas SELECT para que isso aconte\u00e7a.<\/p>\n<\/div>\n
\n
\u00c9 nesse ponto que qualquer O\/RM (n\u00e3o apenas o Entity Framework) pode ser perigoso. Certifique-se de usar uma ferramenta como o SQL Profiler para ver quais consultas est\u00e3o realmente sendo executadas.<\/p>\n<\/div>\n
\n\n\n\n
\n
Observa\u00e7\u00e3o<\/div>\n<\/td>\n
Os O\/RMs podem ajudar, mas em um SQL para NoSQL<\/a> Em compara\u00e7\u00e3o, \u00e9 importante lembrar que a incompatibilidade de imped\u00e2ncia \u00e9 um problema muito menor no mundo NoSQL.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
\n
Para o exemplo do Couchbase, n\u00e3o estou usando o Entity Framework, mas, em vez disso, posso usar o Sintaxe NEST<\/a> que faz parte das extens\u00f5es N1QL do padr\u00e3o SQL. Veja como a vers\u00e3o do Couchbase do GetPersonByIdExpandedAsync<\/code> apar\u00eancia:<\/p>\n<\/div>\n
\n
\n
[HttpGet(\"\/personExpanded\/{personId}\")]\r\npublic async Task<IActionResult> GetPersonByIdExpandedAsync(int personId)\r\n{\r\n    var bucket = await _bucketProvider.GetBucketAsync();\r\n    var cluster = bucket.Cluster;\r\n    var personResult = await cluster.QueryAsync<Person>(@\"\r\n        SELECT p.*, EmailAddresses\r\n        FROM AdventureWorks2016.Person.Person p\r\n        NEST AdventureWorks2016.Person.EmailAddress EmailAddresses ON EmailAddresses.BusinessEntityID = p.BusinessEntityID\r\n        WHERE p.BusinessEntityID = $personId\",\r\n        new QueryOptions().Parameter(\"personId\", personId));\r\n    return Ok(await personResult.Rows.SingleOrDefaultAsync());\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
NEST \u00e9 um tipo de JOIN que coloca os dados JOINed em um objeto JSON aninhado. Em vez de usar um O\/RM para mapear os dados, esses dados podem ser serializados diretamente em objetos C#.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Consulta de pagina\u00e7\u00e3o<\/h2>\n
\n
\n
Vamos dar uma olhada em um exemplo em que N\u00c3O temos uma \u00fanica chave para procurar um dado. Vejamos um m\u00e9todo que retorna uma \"p\u00e1gina\" de resultados (talvez para preencher uma grade ou lista da interface do usu\u00e1rio).<\/p>\n<\/div>\n
\n
Pagina\u00e7\u00e3o no SQL Server<\/h3>\n
\n
Aqui est\u00e1 a vers\u00e3o do SQL Server de GetPersonsPageAsync<\/code>:<\/p>\n<\/div>\n
\n
\n
[HttpGet(\"\/persons\/page\/{pageNum}\")]\r\npublic async Task<IActionResult> GetPersonsPageAsync(int pageNum)\r\n{\r\n    var pageSize = 10;\r\n    var personPage = await _context.Persons\r\n        .OrderBy(p => p.LastName)\r\n        .Skip(pageNum * pageSize)\r\n        .Take(pageSize)\r\n        .Select(p => new { p.BusinessEntityID, p.FirstName, p.LastName })\r\n        .ToListAsync();\r\n    return Ok(personPage);\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
Com o Entity Framework, Ordem<\/code>, Pular<\/code>e Pegue<\/code> s\u00e3o normalmente usados para pagina\u00e7\u00e3o. Se abrirmos o SQL Server Profiler, o SQL gerado ter\u00e1 a seguinte apar\u00eancia:<\/p>\n<\/div>\n
\n
\n
exec sp_executesql N'SELECT [p].[BusinessEntityID], [p].[FirstName], [p].[LastName]\r\nFROM [Person].[Person] AS [p]\r\nORDER BY [p].[LastName]\r\nOFFSET @__p_0 ROWS FETCH NEXT @__p_0 ROWS ONLY',N'@__p_0 int',@__p_0=10<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
OFFSET ... ROWS FETCH NEXT ...<\/code> \u00e9 a sintaxe que est\u00e1 sendo usada para pagina\u00e7\u00e3o aqui.<\/p>\n<\/div>\n<\/div>\n
\n
Pagina\u00e7\u00e3o no Couchbase<\/h3>\n
\n
A sintaxe de pagina\u00e7\u00e3o sempre varia entre as implementa\u00e7\u00f5es de SQL. O Couchbase se inclina mais para a sintaxe do Oracle\/MySQL nesse aspecto. Aqui est\u00e1 a vers\u00e3o do Couchbase de GetPersonsPageAsync<\/code>:<\/p>\n<\/div>\n
\n
\n
[HttpGet(\"\/persons\/page\/{pageNum}\")]\r\npublic async Task<IActionResult> GetPersonsPageAsync(int pageNum)\r\n{\r\n    var pageSize = 10;\r\n    var bucket = await _bucketProvider.GetBucketAsync();\r\n    var bucketName = bucket.Name;\r\n    var cluster = bucket.Cluster;\r\n\r\n    var personPage = await cluster.QueryAsync<Person>($@\"\r\n        SELECT p.LastName, p.BusinessEntityID, p.FirstName\r\n        FROM `{bucketName}`.Person.Person p\r\n        WHERE p.LastName IS NOT MISSING\r\n        ORDER BY p.LastName\r\n        LIMIT {pageSize} OFFSET {(pageNum * pageSize)}\r\n    \");\r\n\r\n    return Ok(await personPage.Rows.ToListAsync());\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
Nesse caso, LIMITE ... DESLOCAMENTO ...<\/code> est\u00e1 sendo usado.<\/p>\n<\/div>\n
\n
Tamb\u00e9m quero destacar o WHERE p.LastName IS NOT MISSING<\/code>. Como o Couchbase \u00e9 um banco de dados NoSQL, o mecanismo de consulta n\u00e3o pode presumir que Sobrenome<\/code> estar\u00e1 em todos os documentos, mesmo com ORDER BY p.LastName<\/code>. Ao adicionar este ONDE<\/code> a consulta agora sabe qual \u00edndice usar. Sem isso, a consulta levar\u00e1 muito mais tempo para ser executada.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
Atualizar com uma transa\u00e7\u00e3o ACID<\/h2>\n
\n
\n
Com o modelo de estilo relacional que estamos usando no SQL Server e no Couchbase para este exemplo, as transa\u00e7\u00f5es ACID ser\u00e3o importantes para ambos os aplicativos.<\/p>\n<\/div>\n
\n
Nesses exemplos, h\u00e1 um PersonUpdateApi<\/code> que permitir\u00e1 que o usu\u00e1rio atualize ambos<\/strong> o nome de uma pessoa e seu endere\u00e7o de e-mail. Como esses dados est\u00e3o em duas tabelas\/linhas separadas (SQL Server) ou dois documentos separados (Couchbase), queremos que essa seja uma opera\u00e7\u00e3o at\u00f4mica do tipo tudo ou nada.<\/p>\n<\/div>\n
\n\n\n\n
\n
Observa\u00e7\u00e3o<\/div>\n<\/td>\n
Um ID \u00e9 especificado para ambos (para simplificar a API), pois \u00e9 poss\u00edvel (mas raro nesse conjunto de dados) que uma pessoa tenha v\u00e1rios endere\u00e7os de e-mail.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
\n
ACID com o Entity Framework<\/h3>\n
\n
Aqui est\u00e1 um exemplo de uma transa\u00e7\u00e3o ACID usando o Entity Framework para atualizar uma linha de dados na tabela Person e uma linha de dados na tabela EmailAddress.<\/p>\n<\/div>\n
\n
\n
[HttpPut(\"\/person\")]\r\npublic async Task<IActionResult> UpdatePurchaseOrderAsync(PersonUpdateApi personUpdateApi)\r\n{\r\n    var transaction = await _context.Database.BeginTransactionAsync();\r\n\r\n    try\r\n    {\r\n        \/\/ find the person\r\n        var person = await _context.Persons\r\n            .Include(p => p.EmailAddresses)\r\n            .SingleOrDefaultAsync(p => p.BusinessEntityID == personUpdateApi.PersonId);\r\n\r\n        \/\/ update name\r\n        person.FirstName = personUpdateApi.FirstName;\r\n        person.LastName = personUpdateApi.LastName;\r\n\r\n        \/\/ get the particular email address and update it\r\n        \/\/ if the supplied ID is invalid, this will throw an exception\r\n        var email = person.EmailAddresses.Single(e =>\r\n            e.EmailAddressID == personUpdateApi.EmailAddressId);\r\n        email.EmailAddress = personUpdateApi.EmailAddress;\r\n\r\n        await _context.SaveChangesAsync();\r\n\r\n        \/\/ commit transaction\r\n        await transaction.CommitAsync();\r\n\r\n        return Ok($\"Person {personUpdateApi.PersonId} name and email updated.\");\r\n    }\r\n    catch (Exception ex)\r\n    {\r\n        await transaction.RollbackAsync();\r\n        return BadRequest(\"Something went wrong, transaction rolled back\");\r\n    }\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
Observe as quatro partes principais de uma transa\u00e7\u00e3o:<\/p>\n<\/div>\n
\n
    \n
  1. Iniciar transa\u00e7\u00e3o (_context.Database.BeginTransactionAsync();<\/code>)<\/li>\n
  2. tentar<\/code>\/captura<\/code><\/li>\n
  3. Transa\u00e7\u00e3o de confirma\u00e7\u00e3o (await transaction.CommitAsync();<\/code>)<\/li>\n
  4. Transa\u00e7\u00e3o de revers\u00e3o no captura<\/code> (transaction.RollbackAsync();<\/code>)<\/li>\n<\/ol>\n<\/div>\n
    \n
    Esse \u00e9 um recurso importante em que a compara\u00e7\u00e3o entre SQL e NoSQL mudou nos \u00faltimos anos. Com o Couchbase, as transa\u00e7\u00f5es ACID agora s\u00e3o poss\u00edveis.<\/p>\n<\/div>\n<\/div>\n
    \n
    ACID com uma transa\u00e7\u00e3o do Couchbase<\/h3>\n
    \n
    Com o Couchbase, a API \u00e9 um pouco diferente, mas as mesmas etapas est\u00e3o todas l\u00e1:<\/p>\n<\/div>\n
    \n
    \n
    [HttpPut(\"\/person\")]\r\npublic async Task<IActionResult> UpdatePurchaseOrderAsync(PersonUpdateApi personUpdateApi)\r\n{\r\n    \/\/ setup bucket, cluster, and collections\r\n    var bucket = await _bucketProvider.GetBucketAsync();\r\n    var scope = await bucket.ScopeAsync(\"Person\");\r\n    var personColl = await scope.CollectionAsync(\"Person\");\r\n    var emailColl = await scope.CollectionAsync(\"EmailAddress\");\r\n\r\n    \/\/ create transaction\r\n    var cluster = bucket.Cluster;\r\n    var transaction = Transactions.Create(cluster,\r\n        TransactionConfigBuilder.Create()\r\n            .DurabilityLevel(DurabilityLevel.None)\r\n            .Build());\r\n\r\n    try\r\n    {\r\n        await transaction.RunAsync(async (context) =>\r\n        {\r\n            \/\/ update person and email documents\r\n            \/\/ based on values passed in API object\r\n            var personKey = personUpdateApi.PersonId.ToString();\r\n            var emailKey = personKey + \"::\" + personUpdateApi.EmailAddressId.ToString();\r\n            var person = await context.GetAsync(personColl, personKey);\r\n            var email = await context.GetAsync(emailColl, emailKey);\r\n\r\n            var personDoc = person.ContentAs<dynamic>();\r\n            var emailDoc = email.ContentAs<dynamic>();\r\n\r\n            personDoc.FirstName = personUpdateApi.FirstName;\r\n            personDoc.LastName = personUpdateApi.LastName;\r\n            emailDoc.EmailAddress = personUpdateApi.EmailAddress;\r\n\r\n            await context.ReplaceAsync(person, personDoc);\r\n            await context.ReplaceAsync(email, emailDoc);\r\n        });\r\n        return Ok($\"Person {personUpdateApi.PersonId} name and email updated.\");\r\n    }\r\n    catch (Exception ex)\r\n    {\r\n        return BadRequest(\"Something went wrong, transaction rolled back.\");\r\n    }\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
    \n
    As etapas principais s\u00e3o as mesmas:<\/p>\n<\/div>\n
    \n
      \n
    1. Iniciar transa\u00e7\u00e3o (transaction.RunAsync( ... )<\/code>)<\/li>\n
    2. tentar<\/code>\/captura<\/code><\/li>\n
    3. Transa\u00e7\u00e3o de compromisso (impl\u00edcita, mas contexto.CommitAsync()<\/code> poderia ser usado)<\/li>\n
    4. Transa\u00e7\u00e3o de revers\u00e3o (novamente, impl\u00edcita, mas contexto.RollbackAsync()<\/code> poderia ser usado).<\/li>\n<\/ol>\n<\/div>\n
      \n
      Em ambos os casos, temos uma transa\u00e7\u00e3o ACID. Diferente de<\/strong> SQL Server, no entanto, podemos mais tarde<\/strong> otimizar e consolidar os dados no Couchbase para reduzir a quantidade de transa\u00e7\u00f5es ACID de que precisamos e aumentar o desempenho.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      Procedimentos armazenados: uma compara\u00e7\u00e3o entre SQL e NoSQL<\/h2>\n
      \n
      \n
      Os procedimentos armazenados s\u00e3o um t\u00f3pico \u00e0s vezes controverso. De modo geral, eles podem conter muita funcionalidade e l\u00f3gica.<\/p>\n<\/div>\n
      \n
      Procedimento armazenado no SQL Server<\/h3>\n
      \n
      Criei um procedimento armazenado chamado \"ListSubcomponents\" (voc\u00ea pode ver o arquivo Detalhes completos no GitHub<\/a>). Com o Entity Framework, voc\u00ea pode usar FromSqlRaw<\/code> para execut\u00e1-lo e mapear os resultados para objetos C#. Criei um objeto C# de pseudo-entidade chamado ListSubcomponents<\/code> que \u00e9 usado apenas para esse sproc:<\/p>\n<\/div>\n
      \n
      \n
      \/\/ sproc example - see ExampleStoredProcedure.sql\r\n[HttpGet(\"\/getListSubcomponents\/{listPriceMin}\/{listPriceMax}\")]\r\npublic async Task<IActionResult> GetListSubcomponents(decimal listPriceMin, decimal listPriceMax)\r\n{\r\n    var listPriceMinParam = new SqlParameter(\"@ListPriceMin\", SqlDbType.Decimal) {Value = listPriceMin };\r\n    var listPriceMaxParam = new SqlParameter(\"@ListPriceMax\", SqlDbType.Decimal) {Value = listPriceMax };\r\n\r\n    var result = await _context.ListSubcomponents\r\n        .FromSqlRaw(\"EXECUTE dbo.ListSubcomponents @ListPriceMin, @ListPriceMax\", listPriceMinParam, listPriceMaxParam)\r\n        .ToListAsync();\r\n\r\n    return Ok(result);\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
      \n
      O procedimento armazenado tem dois par\u00e2metros.<\/p>\n<\/div>\n<\/div>\n
      \n
      Fun\u00e7\u00e3o definida pelo usu\u00e1rio do Couchbase<\/h3>\n
      \n
      O Couchbase n\u00e3o tem nada chamado de \"procedimento armazenado\" (ainda), mas tem algo chamado de fun\u00e7\u00e3o definida pelo usu\u00e1rio (UDF) que tamb\u00e9m pode conter l\u00f3gica complexa quando necess\u00e1rio.<\/p>\n<\/div>\n
      \n
      Criei um UDF chamado ListSubcomponents<\/code> (que voc\u00ea tamb\u00e9m pode visualiza\u00e7\u00e3o no GitHub<\/a>) que corresponde \u00e0 funcionalidade do sproc do SQL Server.<\/p>\n<\/div>\n
      \n
      Veja a seguir como executar esse UDF no ASP.NET:<\/p>\n<\/div>\n
      \n
      \n
      \/\/ sproc example - see ExampleStoredProcedure.sql\r\n[HttpGet(\"\/getListSubcomponents\/{listPriceMin}\/{listPriceMax}\")]\r\npublic async Task<IActionResult> GetListSubcomponents(decimal listPriceMin, decimal listPriceMax)\r\n{\r\n    var bucket = await _bucketProvider.GetBucketAsync();\r\n    var cluster = bucket.Cluster;\r\n\r\n    var options = new QueryOptions();\r\n    options.Parameter(\"$listPriceMin\", listPriceMin);\r\n    options.Parameter(\"$listPriceMax\", listPriceMax);\r\n\r\n    var result = await cluster.QueryAsync<ListSubcomponent>(\r\n        \"SELECT l.* FROM ListSubcomponents($listPriceMin, $listPriceMax) l\", options);\r\n\r\n    return Ok(await result.Rows.ToListAsync());\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
      \n
      Invoc\u00e1-lo no Couchbase com dois par\u00e2metros \u00e9 muito semelhante a usar o FromSqlRaw com o Entity Framework.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      Desempenho - Compara\u00e7\u00e3o entre SQL e NoSQL<\/h2>\n
      \n
      \n
      Agora que converti o aplicativo para usar o Couchbase, a nova vers\u00e3o \u00e9 executada pelo menos t\u00e3o rapidamente quanto a vers\u00e3o antiga do SQL Server?<\/p>\n<\/div>\n
      \n
      \u00c9 uma pergunta complicada de responder porque:<\/p>\n<\/div>\n
      \n