Conversão padrão de operador de consultaStandard Query Operator Translation

LINQ to SQLLINQ to SQL converte os operadores de consulta padrão em comandos SQL.translates Standard Query Operators to SQL commands. O processador de consulta do banco de dados determina a semântica de execução da tradução SQL.The query processor of the database determines the execution semantics of SQL translation.

Operadores de consulta padrão são definidos em sequências.Standard Query Operators are defined against sequences. Uma sequência é ordenada e depende da identidade de referência para cada elemento da sequência.A sequence is ordered and relies on reference identity for each element of the sequence. Para obter mais informações, consulte Visão geral dos operadoresC#de consulta Standard () ou Standard Query Operators Overview (Visual Basic).For more information, see Standard Query Operators Overview (C#) or Standard Query Operators Overview (Visual Basic).

O SQL lida principalmente com conjuntos de valores não ordenados.SQL deals primarily with unordered sets of values. A ordenação normalmente é indicada explicitamente, uma operação de pós-processamento que é aplicada ao resultado final de uma consulta em vez de aos resultados intermediários.Ordering is typically an explicitly stated, post-processing operation that is applied to the final result of a query rather than to intermediate results. A identidade é definida por valores.Identity is defined by values. Por esse motivo, as consultas SQL são compreendidas para lidar com conjuntos de subconjuntos (pacotes) em vez de conjuntos.For this reason, SQL queries are understood to deal with multisets (bags) instead of sets.

Os parágrafos a seguir descrevem as diferenças entre os operadores de consulta padrão e sua conversão SQL do provedor SQL Server para LINQ to SQLLINQ to SQL.The following paragraphs describe the differences between the Standard Query Operators and their SQL translation for the SQL Server provider for LINQ to SQLLINQ to SQL.

Suporte de operadorOperator Support

ConcatConcat

O método Concat é definido para multisets ordenados onde a ordem do receptor e a ordem do argumento são as mesmas.The Concat method is defined for ordered multisets where the order of the receiver and the order of the argument are the same. Concat funciona como UNION ALL sobre os conjuntos de linhas seguidos pela ordem comum.Concat works as UNION ALL over the multisets followed by the common order.

A etapa final é ordenar no SQL antes que os resultados sejam produzidos.The final step is ordering in SQL before results are produced. Concat não preserva a ordem dos seus argumentos.Concat does not preserve the order of its arguments. Para garantir a ordem apropriada, você deve ordenar explicitamente os resultados de Concat.To ensure appropriate ordering, you must explicitly order the results of Concat.

Intersect, Except, UnionIntersect, Except, Union

Os métodos Intersect e Except são bem-definidos somente em conjuntos.The Intersect and Except methods are well defined only on sets. A semântica de multisets é indefinida.The semantics for multisets is undefined.

O método Union é definido para multisets como a concatenação não ordenada dos multisets (efetivamente o resultado da cláusula UNION ALL no SQL).The Union method is defined for multisets as the unordered concatenation of the multisets (effectively the result of the UNION ALL clause in SQL).

Take, SkipTake, Skip

os métodos Take e Skip são bem definidos somente em conjuntos ordenados.Take and Skip methods are well defined only against ordered sets. A semântica de conjuntos ou de multisets não ordenados é indefinida.The semantics for unordered sets or multisets are undefined.

Observação

Take e Skip têm determinadas limitações quando são usadas em consultas em relação ao SQL Server 2000.Take and Skip have certain limitations when they are used in queries against SQL Server 2000. Para obter mais informações, consulte a entrada "ignorar e considerar exceções no SQL Server 2000" em solução de problemas.For more information, see the "Skip and Take Exceptions in SQL Server 2000" entry in Troubleshooting.

Devido a limitações na ordenação do SQL, LINQ to SQLLINQ to SQL tenta mover a ordenação do argumento desses métodos para o resultado do método.Because of limitations on ordering in SQL, LINQ to SQLLINQ to SQL tries to move the ordering of the argument of these methods to the result of the method. Por exemplo, considere a seguinte consulta LINQ to SQLLINQ to SQL:For example, consider the following LINQ to SQLLINQ to SQL query:

var custQuery =
    (from cust in db.Customers
    where cust.City == "London"
    orderby cust.CustomerID
    select cust).Skip(1).Take(1);
Dim custQuery = _
    From cust In db.Customers _
    Where cust.City = "London" _
    Order By cust.CustomerID _
    Select cust Skip 1 Take 1

O SQL gerado para esse código move a ordenação para o final, da seguinte maneira:The generated SQL for this code moves the ordering to the end, as follows:

SELECT TOP 1 [t0].[CustomerID], [t0].[CompanyName],
FROM [Customers] AS [t0]
WHERE (NOT (EXISTS(
    SELECT NULL AS [EMPTY]
    FROM (
        SELECT TOP 1 [t1].[CustomerID]
        FROM [Customers] AS [t1]
        WHERE [t1].[City] = @p0
        ORDER BY [t1].[CustomerID]
        ) AS [t2]
    WHERE [t0].[CustomerID] = [t2].[CustomerID]
    ))) AND ([t0].[City] = @p1)
ORDER BY [t0].[CustomerID]

Torna-se óbvio que qualquer ordenação especificada precisa ser consistente quando Take e Skip são encadeados juntos.It becomes obvious that all the specified ordering must be consistent when Take and Skip are chained together. Caso contrário, os resultados serão indefinidos.Otherwise, the results are undefined.

Take e Skip são definidos para argumentos inteiros não negativos, argumentos integrais constantes baseados na especificação de operador de consulta padrão.Both Take and Skip are well-defined for non-negative, constant integral arguments based on the Standard Query Operator specification.

Operadores sem a conversãoOperators with No Translation

Os seguintes métodos não são convertidos pelo LINQ to SQLLINQ to SQL.The following methods are not translated by LINQ to SQLLINQ to SQL. O motivo mais comum é a diferença entre multisets e sequências não ordenados.The most common reason is the difference between unordered multisets and sequences.

OperadoresOperators RacionalRationale
TakeWhile, SkipWhileTakeWhile, SkipWhile Consultas SQL operam em multisets, não em sequências.SQL queries operate on multisets, not on sequences. ORDER BY deve ser a última cláusula aplicada aos resultados.ORDER BY must be the last clause applied to the results. Por esse motivo, não há nenhuma conversão de finalidade geral para esses dois métodos.For this reason, there is no general-purpose translation for these two methods.
Reverse A conversão desse método é possível para um conjunto ordenado, mas, no momento, não é convertido pelo LINQ to SQLLINQ to SQL.Translation of this method is possible for an ordered set but is not currently translated by LINQ to SQLLINQ to SQL.
Last, LastOrDefaultLast, LastOrDefault A conversão desses métodos é possível para um conjunto ordenado, mas, no momento, não são convertidos pelo LINQ to SQLLINQ to SQL.Translation of these methods is possible for an ordered set but is not currently translated by LINQ to SQLLINQ to SQL.
ElementAt, ElementAtOrDefaultElementAt, ElementAtOrDefault As consultas SQL operam em multisets, não em sequências indexáveis.SQL queries operate on multisets, not on indexable sequences.
DefaultIfEmpty (sobrecarga com ARG padrão)DefaultIfEmpty (overload with default arg) Em geral, um valor padrão não pode ser especificado para um tuple arbitrário.In general, a default value cannot be specified for an arbitrary tuple. Valores nulos para tuples são possíveis em alguns casos com junções externas.Null values for tuples are possible in some cases through outer joins.

Conversão de expressãoExpression Translation

Semântica de nuloNull semantics

LINQ to SQLLINQ to SQL não impõe semânticas de comparação nula no SQL.does not impose null comparison semantics on SQL. Os operadores de comparação são convertidos sintaticamente para seus equivalentes SQL.Comparison operators are syntactically translated to their SQL equivalents. Por esse motivo, a semântica reflete a semântica do SQL que é definida pelo servidor ou pelas configurações de conexão.For this reason, the semantics reflect SQL semantics that are defined by server or connection settings. Por exemplo, dois valores nulos são considerados desiguais nas configurações padrão de SQL Server, mas você pode alterar as configurações para alterar a semântica.For example, two null values are considered unequal under default SQL Server settings, but you can change the settings to change the semantics. LINQ to SQLLINQ to SQL não considera as configurações do servidor quando ele traduz consultas.does not consider server settings when it translates queries.

Uma comparação com o nulo literal é convertida na versão apropriada do SQL (is null ou is not null).A comparison with the literal null is translated to the appropriate SQL version (is null or is not null).

O valor de null na ordenação é definido pelo SQL Server.The value of null in collation is defined by SQL Server. LINQ to SQLLINQ to SQL não altera o agrupamento.does not change the collation.

AgregaçõesAggregates

O método de agregação do operador de consulta padrão Sum avalia uma sequência vazia ou uma sequência que contém somente nulos como zero.The Standard Query Operator aggregate method Sum evaluates to zero for an empty sequence or for a sequence that contains only nulls. Em LINQ to SQLLINQ to SQL, a semântica de SQL permanece inalterada e Sum é avaliada como null em vez de zero para uma sequência vazia ou para uma sequência que contém somente valores nulos.In LINQ to SQLLINQ to SQL, the semantics of SQL are left unchanged, and Sum evaluates to null instead of zero for an empty sequence or for a sequence that contains only nulls.

As limitações do SQL em resultados intermediários se aplicam às agregações no LINQ to SQLLINQ to SQL.SQL limitations on intermediate results apply to aggregates in LINQ to SQLLINQ to SQL. A Sum de quantidades de inteiros de 32 bits não é computada usando resultados de 64 bits.The Sum of 32-bit integer quantities is not computed by using 64-bit results. Pode ocorrer estouro para uma LINQ to SQLLINQ to SQL tradução de Sum, mesmo que a implementação do operador de consulta padrão não cause um estouro para a sequência na memória correspondente.Overflow might occur for a LINQ to SQLLINQ to SQL translation of Sum, even if the Standard Query Operator implementation does not cause an overflow for the corresponding in-memory sequence.

Da mesma forma, a conversão de LINQ to SQLLINQ to SQL de valores inteiros do Average é computada como um integer, não como um double.Likewise, the LINQ to SQLLINQ to SQL translation of Average of integer values is computed as an integer, not as a double.

Argumentos de entidadeEntity Arguments

LINQ to SQLLINQ to SQL permite que os tipos de entidade sejam usados nos métodos GroupBy e OrderBy.enables entity types to be used in the GroupBy and OrderBy methods. Na conversão desses operadores, o uso de um argumento de um tipo é considerado ser o equivalente a especificar todos os membros desse tipo.In the translation of these operators, the use of an argument of a type is considered to be the equivalent to specifying all members of that type. Por exemplo, o código a seguir é equivalente:For example, the following code is equivalent:

db.Customers.GroupBy(c => c);
db.Customers.GroupBy(c => new { c.CustomerID, c.ContactName });
db.Customers.GroupBy(Function(c) c)
db.Customers.GroupBy(Function(c) New With {c.CustomerID, _
    c.ContactName})

Argumentos equitativos/comparáveisEquatable / Comparable Arguments

A igualdade dos argumentos é necessária na implementação dos seguintes métodos:Equality of arguments is required in the implementation of the following methods:

LINQ to SQLLINQ to SQL dá suporte a igualdade e comparação para argumentos simples , mas não para argumentos que contenham sequências.supports equality and comparison for flat arguments, but not for arguments that are or contain sequences. Um argumento simples é um tipo que pode ser mapeado para uma linha SQL.A flat argument is a type that can be mapped to a SQL row. Uma projeção de um ou mais tipos de entidade, que podem ser determinados estaticamente por não conterem uma sequência, é considerada um argumento simples.A projection of one or more entity types that can be statically determined not to contain a sequence is considered a flat argument.

Veja a seguir exemplos de argumentos simples:The following are examples of flat arguments:

db.Customers.Select(c => c);
db.Customers.Select(c => new { c.CustomerID, c.City });
db.Orders.Select(o => new { o.OrderID, o.Customer.City });
db.Orders.Select(o => new { o.OrderID, o.Customer });	
db.Customers.Select(Function(c) c)
db.Customers.Select(Function(c) New With {c.CustomerID, c.City})
db.Orders.Select(Function(o) New With {o.OrderID, o.Customer.City})
db.Orders.Select(Function(o) New With {o.OrderID, o.Customer})

Veja a seguir exemplos de argumentos não-simples (hierárquicos):The following are examples of non-flat (hierarchical) arguments:

// In the following line, c.Orders is a sequence.
db.Customers.Select(c => new { c.CustomerID, c.Orders });
// In the following line, the result has a sequence.
db.Customers.GroupBy(c => c.City);
' In the following line, c.Orders is a sequence.
db.Customers.Select(Function(c) New With {c.CustomerID, c.Orders})
' In the following line, the result has a sequence.
db.Customers.GroupBy(Function(c) c.City)

Conversão de função do Visual BasicVisual Basic Function Translation

As seguintes funções auxiliares que são usadas pelo compilador Visual Basic são convertidas em operadores e funções SQL correspondentes:The following helper functions that are used by the Visual Basic compiler are translated to corresponding SQL operators and functions:

  • CompareString

  • DateTime.Compare

  • Decimal.Compare

  • IIf (in Microsoft.VisualBasic.Interaction)

Métodos de conversão:Conversion methods:

ToBooleanToBoolean ToSByteToSByte ToByteToByte ToCharToChar
ToCharArrayRankOneToCharArrayRankOne ToDateToDate ToDecimalToDecimal ToDoubleToDouble
ToIntegerToInteger ToUIntegerToUInteger ToLongToLong ToULongToULong
ToShortToShort ToUShortToUShort ToSingleToSingle ToStringToString

Suporte à herançaInheritance Support

Restrições de mapeamento de herançaInheritance Mapping Restrictions

Para obter mais informações, consulte como mapear hierarquias de herança.For more information, see How to: Map Inheritance Hierarchies.

Herança em consultasInheritance in Queries

As conversões do C# são suportadas apenas na projeção.C# casts are supported only in projection. Conversões que são usadas em outro lugar não são convertidas e são ignoradas.Casts that are used elsewhere are not translated and are ignored. Com exceção dos nomes de funções SQL, o SQL realmente executa apenas o equivalente do Convert do CLR (Common Language Runtime).Aside from SQL function names, SQL really only performs the equivalent of the common language runtime (CLR) Convert. Isto é, o SQL pode alterar o valor de um tipo para outro.That is, SQL can change the value of one type to another. Não há nenhum equivalente de conversão do CLR porque não há nenhum conceito de reinterpretação dos mesmos bits como os de outro tipo.There is no equivalent of CLR cast because there is no concept of reinterpreting the same bits as those of another type. É por isso que uma conversão C# funciona apenas localmente.That is why a C# cast works only locally. Ela não funciona remotamente.It is not remoted.

Os operadores is e as e o método GetType não são restritos ao operador Select.The operators, is and as, and the GetType method are not restricted to the Select operator. Podem ser usados em outros operadores de consulta também.They can be used in other query operators also.

Suporte do SQL Server 2008SQL Server 2008 Support

A partir do .NET Framework 3.5 SP1, o LINQ to SQL dá suporte ao mapeamento para novos tipos de data e hora introduzidos com o SQL Server 2008.Starting with the .NET Framework 3.5 SP1, LINQ to SQL supports mapping to new date and time types introduced with SQL Server 2008. Mas, há algumas limitações aos operadores de consulta do LINQ to SQL que você pode usar ao operar com valores mapeados para esses novos tipos.But, there are some limitations to the LINQ to SQL query operators that you can use when operating against values mapped to these new types.

Operadores de consulta não suportadosUnsupported Query Operators

Os seguintes operadores de consulta não são suportados em valores mapeados para novos tipos de data e hora do SQL Server: DATETIME2, DATE, TIME e DATETIMEOFFSET.The following query operators are not supported on values mapped to the new SQL Server date and time types: DATETIME2, DATE, TIME, and DATETIMEOFFSET.

  • Aggregate

  • Average

  • LastOrDefault

  • OfType

  • Sum

Para obter mais informações sobre mapeamento para esses SQL Server tipos de data e hora, consulte mapeamento de tipo SQL-CLR.For more information about mapping to these SQL Server date and time types, see SQL-CLR Type Mapping.

Suporte do SQL Server 2005SQL Server 2005 Support

LINQ to SQLLINQ to SQL não oferece suporte aos seguintes recursos de SQL Server 2005:does not support the following SQL Server 2005 features:

  • Procedimentos armazenados escritos para SQL CLR.Stored procedures written for SQL CLR.

  • Tipo definido pelo usuário.User-defined type.

  • Recursos de consulta XML.XML query features.

Suporte do SQL Server 2000SQL Server 2000 Support

As limitações a seguir SQL Server 2000 (em comparação com Microsoft SQL Server 2005) afetam LINQ to SQLLINQ to SQL suporte.The following SQL Server 2000 limitations (compared to Microsoft SQL Server 2005) affect LINQ to SQLLINQ to SQL support.

Operadores Cross Apply e Outer ApplyCross Apply and Outer Apply Operators

Esses operadores não estão disponíveis no SQL Server 2000.These operators are not available in SQL Server 2000. LINQ to SQLLINQ to SQL tenta uma série de regravações para substituí-las pelas junções apropriadas.tries a series of rewrites to replace them with appropriate joins.

Cross Apply e Outer Apply são gerados para navegações de relações.Cross Apply and Outer Apply are generated for relationship navigations. O conjunto de consultas para as quais essas reescritas são possíveis não é bem definido.The set of queries for which such rewrites are possible is not well defined. Por esse motivo, o conjunto mínimo de consultas com suporte para SQL Server 2000 é o conjunto que não envolve a navegação de relação.For this reason, the minimal set of queries that is supported for SQL Server 2000 is the set that does not involve relationship navigation.

text/ntexttext / ntext

Os tipos de dados text / ntext não podem ser usados em determinadas operações de consulta em relação ao varchar(max) / nvarchar(max), que têm suporte do Microsoft SQL Server 2005.Data types text / ntext cannot be used in certain query operations against varchar(max) / nvarchar(max), which are supported by Microsoft SQL Server 2005.

Nenhuma resolução está disponível para essa limitação.No resolution is available for this limitation. Especificamente, você não pode usar Distinct() em resultados que contêm membros que são mapeados para colunas text ou ntext.Specifically, you cannot use Distinct() on any result that contains members that are mapped to text or ntext columns.

Comportamento disparado por consultas aninhadasBehavior Triggered by Nested Queries

SQL Server o associador 2000 (por meio do SP4) tem algumas idiossincrasias disparadas por consultas aninhadas.SQL Server 2000 (through SP4) binder has some idiosyncrasies that are triggered by nested queries. O conjunto de consultas SQL que dispara essas idiossincrasias não está bem definido.The set of SQL queries that triggers these idiosyncrasies is not well defined. Por esse motivo, você não pode definir o conjunto de LINQ to SQLLINQ to SQL consultas que podem causar SQL Server exceções.For this reason, you cannot define the set of LINQ to SQLLINQ to SQL queries that might cause SQL Server exceptions.

Operadores Skip e TakeSkip and Take Operators

Take e Skip têm determinadas limitações quando são usadas em consultas em relação ao SQL Server 2000.Take and Skip have certain limitations when they are used in queries against SQL Server 2000. Para obter mais informações, consulte a entrada "ignorar e considerar exceções no SQL Server 2000" em solução de problemas.For more information, see the "Skip and Take Exceptions in SQL Server 2000" entry in Troubleshooting.

Materialização de objetosObject Materialization

A materialização cria objetos CLR das linhas que são retornadas por uma ou mais consultas SQL.Materialization creates CLR objects from rows that are returned by one or more SQL queries.

  • As seguintes chamadas são executadas localmente como parte da materialização:The following calls are executed locally as a part of materialization:

    • {1>Construtores<1}Constructors

    • métodos de ToString em projeçõesToString methods in projections

    • Conversões de tipos em projeçõesType casts in projections

  • Os métodos que seguem o método AsEnumerable são executados localmente.Methods that follow the AsEnumerable method are executed locally. Esse método não provoca uma execução imediata.This method does not cause immediate execution.

  • Você pode usar struct como o tipo de retorno de um resultado de consulta ou como um membro do tipo de resultado.You can use a struct as the return type of a query result or as a member of the result type. As entidades precisam ser classes.Entities are required to be classes. Tipos anônimos são materializados como instâncias de classe, mas structs nomeados (não entidades) podem ser usados na projeção.Anonymous types are materialized as class instances, but named structs (non-entities) can be used in projection.

  • Um membro do tipo do retorno de um resultado de consulta pode ser do tipo IQueryable<T>.A member of the return type of a query result can be of type IQueryable<T>. É materializado como uma coleção local.It is materialized as a local collection.

  • Os métodos a seguir causam a materialização imediata da sequência à qual os métodos são aplicados:The following methods cause the immediate materialization of the sequence that the methods are applied to:

Consulte tambémSee also