Class SqlProviderFlags

Namespace

LinqToDB.Internal.SqlProvider

Assembly

linq2db.dll

[DataContract]
public sealed class SqlProviderFlags

Inheritance

object

SqlProviderFlags

Extension Methods

Sql.IsDistinctFrom<T>(T, T)

Sql.IsNotDistinctFrom<T>(T, T)

SqlExtensions.In<T>(T, T, T)

SqlExtensions.In<T>(T, T, T, T)

SqlExtensions.In<T>(T, params T[])

SqlExtensions.In<T>(T, IEnumerable<T>)

SqlExtensions.In<T>(T, IQueryable<T>)

SqlExtensions.NotIn<T>(T, T, T)

SqlExtensions.NotIn<T>(T, T, T, T)

SqlExtensions.NotIn<T>(T, params T[])

SqlExtensions.NotIn<T>(T, IEnumerable<T>)

SqlExtensions.NotIn<T>(T, IQueryable<T>)

Properties

AcceptsOuterExpressionInAggregate

Provider supports aggregated expression with Outer reference

SELECT
(
	SELECT SUM(inner.FieldX + outer.FieldOuter)
	FROM table2 inner
) AS Sum_Column
FROM table1 outer

Otherwise aggeragated expression will be wrapped in subquery and aggregate function will be applied to subquery column.

SELECT
(
	SELECT
		SUM(sub.Column)
	FROM
		(
			SELECT inner.FieldX + outer.FieldOuter AS Column
			FROM table2 inner
		) sub
) AS Sum_Column
FROM table1 outer

Default (set by DataProviderBase): true.

[DataMember(Order = 34)]
public bool AcceptsOuterExpressionInAggregate { get; set; }

Property Value

bool

AcceptsTakeAsParameter

Indicates that TAKE/TOP/LIMIT could accept parameter. Default (set by DataProviderBase): true.

[DataMember(Order = 3)]
public bool AcceptsTakeAsParameter { get; set; }

Property Value

bool

AcceptsTakeAsParameterIfSkip

Indicates that TAKE/LIMIT could accept parameter only if also SKIP/OFFSET specified. Default (set by DataProviderBase): false.

[DataMember(Order = 4)]
public bool AcceptsTakeAsParameterIfSkip { get; set; }

Property Value

bool

CalculateSupportedCorrelatedLevelWithAggregateQueries

Gets or sets a value indicating whether the calculation of deep level includes aggregation queries. Works in conjunction with SupportedCorrelatedSubqueriesLevel.

[DataMember(Order = 58)]
public bool CalculateSupportedCorrelatedLevelWithAggregateQueries { get; set; }

Property Value

bool

CanCombineParameters

Indicates that provider could share parameter between statements in multi-statement batch. Default (set by DataProviderBase): true.

[DataMember(Order = 23)]
public bool CanCombineParameters { get; set; }

Property Value

bool

CustomFlags

Flags for use by external providers.

[DataMember(Order = 1)]
public HashSet<string> CustomFlags { get; set; }

Property Value

HashSet<string>

DefaultMultiQueryIsolationLevel

Used when there is query which needs several additional database requests for completing query (e.g. eager load or client-side GroupBy). Default (set by DataProviderBase): RepeatableRead.

[DataMember(Order = 38)]
public IsolationLevel DefaultMultiQueryIsolationLevel { get; set; }

Property Value

IsolationLevel

DefaultNullsOrdering

The provider's natural placement of NULL values in an ORDER BY (the placement used when no NULLS FIRST/NULLS LAST is specified). Unknown (the default) means it is unknown, so a requested Sql.NullsPosition is always honored (emulated or rendered) and never elided. When set, a requested position that already equals the natural placement for the item's direction is dropped, avoiding a redundant emulation sort key or NULLS token.

[DataMember(Order = 70)]
public NullsDefaultOrdering DefaultNullsOrdering { get; set; }

Property Value

NullsDefaultOrdering

DoesProviderTreatsEmptyStringAsNull

Provider treats empty string as null in queries. It is specific behaviour only for Oracle. Default false

[DataMember(Order = 31)]
public bool DoesProviderTreatsEmptyStringAsNull { get; set; }

Property Value

bool

IsAccessBuggyLeftJoinConstantNullability

Indicates that provider has bug in LEFT join translator. In the following example can_be_null is always not null, which is wrong.

SELECT
	can_be_null
FROM Some
LEFT JOIN 1 as can_be_null, * FROM Other
	ON ...

As workaround translator is trying to check for nullability all projected fields. Default value: false.

[DataMember(Order = 49)]
public bool IsAccessBuggyLeftJoinConstantNullability { get; set; }

Property Value

bool

IsAllSetOperationsSupported

Provider supports EXCEPT ALL, INTERSECT ALL set operators. Otherwise they will be emulated. Default (set by DataProviderBase): false.

[DataMember(Order = 32)]
public bool IsAllSetOperationsSupported { get; set; }

Property Value

bool

IsApplyJoinSupported

Indicates support for OUTER/CROSS APPLY. Default (set by DataProviderBase): false.

[DataMember(Order = 19)]
public bool IsApplyJoinSupported { get; set; }

Property Value

bool

IsCTESupportsOrdering

Indicates that top level CTE query supports ORDER BY. Default value: true.

[DataMember(Order = 48)]
public bool IsCTESupportsOrdering { get; set; }

Property Value

bool

IsColumnSubqueryShouldNotContainParentIsNotNull

Workaround for an Oracle 11 bug: when set to true, the validator rejects column-position scalar subqueries whose body contains an IS NOT NULL predicate resolving against a parent (outer) source, forcing the optimizer to pick a different shape (or fail upstream with a clearer error) instead of emitting SQL the server mishandles. The check is gated on being inside a SELECT-projection column expression — IS NOT NULL in WHERE / ON / HAVING positions is unaffected. Default value: false.

[DataMember(Order = 44)]
public bool IsColumnSubqueryShouldNotContainParentIsNotNull { get; set; }

Property Value

bool

Remarks

Set to true only for Oracle 11, where deep correlation through column-position scalar subqueries (UNION ALL, derived tables, IS NOT NULL projections) leaks alias scope and the server raises ORA-00904 at runtime. Oracle 12+ resolves these references correctly. The flag's "should not contain" naming reflects its role as a provider-bug constraint, not a feature toggle. See Issue3557Case1 test.

IsColumnSubqueryWithParentReferenceAndTakeSupported

Provider supports column subqueries which references outer scope when nesting is more than 1

[DataMember(Order = 43)]
public bool IsColumnSubqueryWithParentReferenceAndTakeSupported { get; set; }

Property Value

bool

Remarks

Used only for Oracle 11. linq2db emulates Take(n) via 'ROWNUM' and it causes additional nesting. Default value: true.

IsCommonTableExpressionsSupported

Indicates support of CTE expressions. If provider does not support CTE, unsuported exception will be thrown when using CTE. Default (set by DataProviderBase): false.

[DataMember(Order = 30)]
public bool IsCommonTableExpressionsSupported { get; set; }

Property Value

bool

IsComplexJoinConditionSupported

When disabled, all conditions from INNER JOIN ON moved to WHERE except conjunction of equality predicates.

FROM T1 INNER JOIN T2 ON t1.field1 == t2.field1 AND t1.field2 == t2.field2 AND t1.field3 > 10
-- with flag:
FROM T1 INNER JOIN T2 ON t1.field1 == t2.field1 AND t1.field2 == t2.field2
WHERE t1.field3 > 10

Default: true.

[DataMember(Order = 63)]
public bool IsComplexJoinConditionSupported { get; set; }

Property Value

bool

IsCorrelatedSubQueryTakeSupported

Indicates support for paging clause in correlated subquery. Default (set by DataProviderBase): true.

[DataMember(Order = 11)]
public bool IsCorrelatedSubQueryTakeSupported { get; set; }

Property Value

bool

IsCountSubQuerySupported

Indicates that database supports count subquery as scalar in column.

SELECT (SELECT COUNT(*) FROM some_table) FROM ...

Default (set by DataProviderBase): true.

[DataMember(Order = 17)]
public bool IsCountSubQuerySupported { get; set; }

Property Value

bool

IsCrossApplyJoinSupportsCondition

Indicates support for CROSS APPLY supports condition LATERAL JOIN for example. Default (set by DataProviderBase): false.

[DataMember(Order = 20)]
public bool IsCrossApplyJoinSupportsCondition { get; set; }

Property Value

bool

IsCrossJoinSupported

Indicates support for CROSS JOIN. Default (set by DataProviderBase): true.

[DataMember(Order = 29)]
public bool IsCrossJoinSupported { get; set; }

Property Value

bool

IsCrossJoinSyntaxRequired

When enabled, always prefer "FROM T1 CROSS JOIN T2" over "FROM T1, T2" join syntax. Default: false.

[DataMember(Order = 64)]
public bool IsCrossJoinSyntaxRequired { get; set; }

Property Value

bool

IsDerivedTableOrderBySupported

Provider supports SUM/AVG/MIN/MAX(DISTINCT column) function. Otherwise, it will be emulated. Default (set by DataProviderBase): true.

[DataMember(Order = 53)]
public bool IsDerivedTableOrderBySupported { get; set; }

Property Value

bool

IsDerivedTableTakeSupported

Indicates support for paging clause in derived table. Default (set by DataProviderBase): true.

[DataMember(Order = 9)]
public bool IsDerivedTableTakeSupported { get; set; }

Property Value

bool

IsDistinctFromSupported

Provider supports correlated DISTINCT FROM directly or through db-specific operator/method (e.g. DECODE, IS, <=>). This doesn't include emulation using INTERSECT. Default false

[DataMember(Order = 59)]
public bool IsDistinctFromSupported { get; set; }

Property Value

bool

IsDistinctOnSupported

Provider supports the SELECT DISTINCT ON (expr, ...) syntax (PostgreSQL, DuckDB): one row per distinct ON-expression tuple, choosing the row that sorts first under the query ORDER BY (which must begin with the ON expressions). When false (the default), DistinctBy falls back to ROW_NUMBER() / OUTER APPLY emulation.

[DataMember(Order = 75)]
public bool IsDistinctOnSupported { get; set; }

Property Value

bool

IsDistinctSetOperationsSupported

Provider supports EXCEPT, INTERSECT set operators. Otherwise it will be emulated. Default (set by DataProviderBase): true.

[DataMember(Order = 33)]
public bool IsDistinctSetOperationsSupported { get; set; }

Property Value

bool

IsExistsPreferableForContains

Default value: false.

[DataMember(Order = 40)]
public bool IsExistsPreferableForContains { get; set; }

Property Value

bool

IsIdentityParameterRequired

Indicates that provider requires explicit output parameter for insert with identity queries to get identity from database. Default (set by DataProviderBase): false.

[DataMember(Order = 18)]
public bool IsIdentityParameterRequired { get; set; }

Property Value

bool

IsInsertOrUpdateRequiresAlignedBranches

Indicates that the provider's native single-statement InsertOrUpdate shape applies one value-list to both the INSERT and UPDATE branches and cannot honor per-branch SET divergence. When true and the Upsert configuration produces different expressions for the same column on the INSERT vs UPDATE branch (typically via Insert(i => …) / Update(v => …) per-branch overrides, or per-branch Ignore), the runtime transparently falls back to the alternative UPDATE → INSERT emulation so the per-branch divergence is preserved.

Set to true for SAP HANA — its UPSERT … WITH PRIMARY KEY statement uses one VALUES list for both branches.

Default (set by DataProviderBase): false.

[DataMember(Order = 74)]
public bool IsInsertOrUpdateRequiresAlignedBranches { get; set; }

Property Value

bool

IsInsertOrUpdateSupported

Indicates support for single-query insert-or-update operation support. Otherwise two separate queries used to emulate operation (update, then insert if nothing found to update). Default (set by DataProviderBase): true.

[DataMember(Order = 22)]
public bool IsInsertOrUpdateSupported { get; set; }

Property Value

bool

IsInsertOrUpdateWithPredicateSupported

Indicates that the provider's native InsertOrUpdate emission can honor an additional predicate applied to the UPDATE branch (used by Upsert(...).Update(v => v.When(...))). When false, Upsert with a .When predicate is routed through the alternative 3-query SELECT → UPDATE → INSERT orchestration instead of the native path.

Set to false for engines whose single-statement insert-or-update shape cannot carry an UPDATE-branch predicate:

• MySQL / MariaDB — INSERT ... ON DUPLICATE KEY UPDATE has no WHERE clause.
• SAP Sybase ASE — emulated via IF @@ROWCOUNT = 0 INSERT, no UPDATE-branch predicate.
• SQL Server 2005 — pre-MERGE; emulated via IF @@ROWCOUNT = 0 INSERT.

Default (set by DataProviderBase): true.

[DataMember(Order = 71)]
public bool IsInsertOrUpdateWithPredicateSupported { get; set; }

Property Value

bool

IsJoinDerivedTableWithTakeInvalid

Indicates that provider has issue with any JOIN to subquery which has TOP statement. Default false.

[DataMember(Order = 10)]
public bool IsJoinDerivedTableWithTakeInvalid { get; set; }

Property Value

bool

Remarks

Currently use as workaround over Sybase bug.

IsMultiTablesSupportsJoins

Indicates that provider supports JOINS in FROM clause which have several tables

SELECT ...
FROM table1
   INNER JOIN query ON ...
   , table2

Otherwise the following query will be generated:

SELECT ...
FROM (
	SELECT ...
	FROM table1, table2
) S
   INNER JOIN query ON ... ,
FROM table2

Default: true. Currently not supported only by Access.

[DataMember(Order = 47)]
public bool IsMultiTablesSupportsJoins { get; set; }

Property Value

bool

IsNamingQueryBlockSupported

Provider supports Naming Query Blocks

QB_NAME(qb)

Default (set by DataProviderBase): false.

[DataMember(Order = 36)]
public bool IsNamingQueryBlockSupported { get; set; }

Property Value

bool

IsNestedJoinsSupported

Provider supports nested joins

<pre><code class="lang-csharp">A JOIN (B JOIN C ON ?) ON ?</code></pre>

otherwise nested join replaced with sub-query

<pre><code class="lang-csharp">A JOIN (SELECT ? FROM B JOIN C ON ?) ON ?</code></pre>

. Default (set by DataProviderBase): true.

[DataMember(Order = 52)]
public bool IsNestedJoinsSupported { get; set; }

Property Value

bool

IsNullsOrderingSupported

Provider renders NULLS FIRST / NULLS LAST natively in ORDER BY (and window OVER (ORDER BY …)). When false (the default), Sql.NullsPosition is emulated via a CASE WHEN <expr> IS NULL THEN … sort key.

[DataMember(Order = 69)]
public bool IsNullsOrderingSupported { get; set; }

Property Value

bool

IsOrderByAggregateFunctionSupported

Provider supports Aggregate function in ORDER BY. Default (set by DataProviderBase): true.

[DataMember(Order = 60)]
public bool IsOrderByAggregateFunctionSupported { get; set; }

Property Value

bool

Remarks

Applied only to SqlCe provider.

IsOrderByAggregateSubquerySupported

Provider supports aggregation subquery in ORDER BY Clause. Default: true.

[DataMember(Order = 61)]
public bool IsOrderByAggregateSubquerySupported { get; set; }

Property Value

bool

IsOrderBySubQuerySupported

Provider supports subquery in ORDER BY Clause.

[DataMember(Order = 62)]
public bool IsOrderBySubQuerySupported { get; set; }

Property Value

bool

IsOuterApplyJoinSupportsCondition

Indicates support for OUTER APPLY supports condition LATERAL JOIN for example. Default (set by DataProviderBase): false.

[DataMember(Order = 21)]
public bool IsOuterApplyJoinSupportsCondition { get; set; }

Property Value

bool

IsOuterJoinSupportsInnerJoin

Provider supports INNER JOIN inside OUTER JOIN. For example:

LEFT JOIN table1 ON ...
   INNER JOIN query ON ...

Otherwise the following query will be left:

LEFT JOIN (
   SELECT ...
   FROM table1
   INNER JOIN query ON ...
)

Default: true. Currently not supported only by Access.

[DataMember(Order = 46)]
public bool IsOuterJoinSupportsInnerJoin { get; set; }

Property Value

bool

IsParameterOrderDependent

Indicates that provider (not database!) uses positional parameters instead of named parameters (parameter values assigned in order they appear in query, not by parameter name). Default (set by DataProviderBase): false.

[DataMember(Order = 2)]
public bool IsParameterOrderDependent { get; set; }

Property Value

bool

IsRecursiveCTEJoinWithConditionSupported

Provider supports INNER JOIN with condition inside Recursive CTE, currently not supported only by DB2 Default value: true.

[DataMember(Order = 45)]
public bool IsRecursiveCTEJoinWithConditionSupported { get; set; }

Property Value

bool

IsRowNumberWithoutOrderBySupported

Provider supports ROW_NUMBER OVER () without ORDER BY Default value: true.

[DataMember(Order = 41)]
public bool IsRowNumberWithoutOrderBySupported { get; set; }

Property Value

bool

IsSimpleCoalesceSupported

Indicates that provider supports simple COALESCE translation without complex translation.

[DataMember(Order = 66)]
public bool IsSimpleCoalesceSupported { get; set; }

Property Value

bool

IsSkipSupported

Indicates support for SKIP/OFFSET paging clause (parameter) without TAKE clause. Provider could set this flag even if database not support it if emulates missing functionality. E.g. : TAKE [MAX_ALLOWED_VALUE] SKIP skip_value Default (set by DataProviderBase): true.

[DataMember(Order = 5)]
public bool IsSkipSupported { get; set; }

Property Value

bool

IsSkipSupportedIfTake

Indicates support for SKIP/OFFSET paging clause (parameter) only if also TAKE/LIMIT specified. Default (set by DataProviderBase): false.

[DataMember(Order = 6)]
public bool IsSkipSupportedIfTake { get; set; }

Property Value

bool

IsSubQueryColumnSupported

Indicates support for scalar subquery in select list. E.g. SELECT (SELECT TOP 1 value FROM some_table) AS MyColumn, ... Default (set by DataProviderBase): true.

[DataMember(Order = 14)]
public bool IsSubQueryColumnSupported { get; set; }

Property Value

bool

IsSubQueryOrderBySupported

Indicates support of ORDER BY clause in sub-queries. Default (set by DataProviderBase): false.

[DataMember(Order = 15)]
public bool IsSubQueryOrderBySupported { get; set; }

Property Value

bool

IsSubQuerySkipSupported

Indicates support for skip clause in column expression subquery. Default (set by DataProviderBase): true.

[DataMember(Order = 13)]
public bool IsSubQuerySkipSupported { get; set; }

Property Value

bool

IsSubQueryTakeSupported

Indicates support for paging clause in subquery. Default (set by DataProviderBase): true.

[DataMember(Order = 8)]
public bool IsSubQueryTakeSupported { get; set; }

Property Value

bool

IsSubqueryExpressionInsidePredicateSupported

Indicates that provider supports subquery in predicate, like (SELECT column FROM ...) IS NULL, COALESCE((SELECT column FROM ...), 0).

[DataMember(Order = 67)]
public bool IsSubqueryExpressionInsidePredicateSupported { get; set; }

Property Value

bool

IsSubqueryJoinOnOuterReferenceSupported

Provider supports JOIN to subquery which contains reference to parent table in join condition.

[DataMember(Order = 68)]
public bool IsSubqueryJoinOnOuterReferenceSupported { get; set; }

Property Value

bool

IsSubqueryWithParentReferenceInJoinConditionSupported

Provider supports condition in subquery which references parent table Default value: true.

[DataMember(Order = 42)]
public bool IsSubqueryWithParentReferenceInJoinConditionSupported { get; set; }

Property Value

bool

IsSupportedSimpleCorrelatedSubqueries

Provider supports correlated subqueris, which can be easily converted to JOIN. Default (set by DataProviderBase): false.

[DataMember(Order = 56)]
public bool IsSupportedSimpleCorrelatedSubqueries { get; set; }

Property Value

bool

Remarks

Applied only to ClickHouse provider.

IsSupportsJoinWithoutCondition

Indicates that provider supports JOIN without condition ON 1=1. Default (set by DataProviderBase): true.

[DataMember(Order = 12)]
public bool IsSupportsJoinWithoutCondition { get; set; }

Property Value

bool

IsTakeWithInAllAnySomeSubquerySupported

When disabled, SQL dialect doesn't support Take/LIMIT & IN/ALL/ANY/SOME subquery.

[DataMember(Order = 65)]
public bool IsTakeWithInAllAnySomeSubquerySupported { get; set; }

Property Value

bool

IsUnionAllOrderBySupported

Indicates support of ORDER BY clause in UNION ALL. Default (set by DataProviderBase): false.

[DataMember(Order = 16)]
public bool IsUnionAllOrderBySupported { get; set; }

Property Value

bool

IsUpdateFromSupported

Indicates support for following UPDATE syntax:

UPDATE A
SET ...
FROM B

Default (set by DataProviderBase): true.

[DataMember(Order = 35)]
public bool IsUpdateFromSupported { get; set; }

Property Value

bool

IsUpdateSkipTakeSupported

Provider supports SKIP+TAKE limit for UPDATE query. Default (set by DataProviderBase): false.

[DataMember(Order = 55)]
public bool IsUpdateSkipTakeSupported { get; set; }

Property Value

bool

IsUpdateTakeSupported

Provider supports TAKE limit for UPDATE query. Default (set by DataProviderBase): false.

[DataMember(Order = 54)]
public bool IsUpdateTakeSupported { get; set; }

Property Value

bool

IsUpsertMergeWithPredicateSupported

Indicates that the provider's MERGE dialect supports predicates on the WHEN MATCHED and WHEN NOT MATCHED clauses (either as WHEN MATCHED AND <cond> or WHEN MATCHED THEN UPDATE SET … WHERE <cond>). When false and an Upsert configuration with Insert(i => i.When(...)) or Update(v => v.When(...)) is routed through MERGE lowering, LinqToDBException is thrown with a descriptive message.

Set to false for Firebird 2.5 — its MERGE predates Firebird 3 which added WHEN [NOT] MATCHED [AND <cond>] syntax, and it has no UPDATE … WHERE form inside MERGE either.

Default (set by DataProviderBase): true.

[DataMember(Order = 73)]
public bool IsUpsertMergeWithPredicateSupported { get; set; }

Property Value

bool

IsUpsertWithMergeLoweringSupported

Indicates that the provider supports the synthesized two-branch MERGE shape linq2db emits when Upsert(...) cannot be lowered to the native InsertOrUpdate path — i.e. for bulk sources, non-PK match, conditional Insert(i => i.When(...)), or SkipInsert() / SkipUpdate(). When false and the Upsert configuration requires MERGE lowering, LinqToDBException is thrown with a descriptive message.

Set to false for SAP HANA — its MERGE dialect lacks the WHEN NOT MATCHED THEN INSERT branch that the ANSI shape requires.

Default (set by DataProviderBase): true.

[DataMember(Order = 72)]
public bool IsUpsertWithMergeLoweringSupported { get; set; }

Property Value

bool

IsWindowFunctionsSupported

Indicates that provider supports window functions. Default value: true.

[DataMember(Order = 37)]
public bool IsWindowFunctionsSupported { get; set; }

Property Value

bool

MaxColumnCount

Maximum number of columns in a single SELECT list enforced by linq2db when building CteUnion eager-loading queries. When the estimated column count of the combined UNION ALL projection exceeds this limit the strategy falls back to individual preamble queries. 0 means no limit is enforced. Default: 0.

[DataMember(Order = 76)]
public int MaxColumnCount { get; set; }

Property Value

int

MaxInListValuesCount

Specifies limit of number of values in single IN predicate without splitting it into several IN's. Default (set by DataProviderBase): int.MaxValue (basically means there is no limit).

[DataMember(Order = 24)]
public int MaxInListValuesCount { get; set; }

Property Value

int

OutputDeleteUseSpecialTable

If true, removed record fields in OUTPUT clause of DELETE statement should be referenced using table with special name (e.g. DELETED or OLD). Otherwise fields should be referenced using target table. Default (set by DataProviderBase): false.

[DataMember(Order = 25)]
public bool OutputDeleteUseSpecialTable { get; set; }

Property Value

bool

OutputInsertUseSpecialTable

If true, added record fields in OUTPUT clause of INSERT statement should be referenced using table with special name (e.g. INSERTED or NEW). Otherwise fields should be referenced using target table. Default (set by DataProviderBase): false.

[DataMember(Order = 26)]
public bool OutputInsertUseSpecialTable { get; set; }

Property Value

bool

OutputMergeUseSpecialTables

If true, OUTPUT clause supports both OLD and NEW data in MERGE statement using tables with special names. Otherwise only current record fields (after all changes) available using target table. Default (set by DataProviderBase): false.

[DataMember(Order = 28)]
public bool OutputMergeUseSpecialTables { get; set; }

Property Value

bool

OutputUpdateUseSpecialTables

If true, OUTPUT clause supports both OLD and NEW data in UPDATE statement using tables with special names. Otherwise only current record fields (after update) available using target table. Default (set by DataProviderBase): false.

[DataMember(Order = 27)]
public bool OutputUpdateUseSpecialTables { get; set; }

Property Value

bool

RowConstructorSupport

Provider support Row Constructor (1, 2, 3) in various positions (flags) Default (set by DataProviderBase): None.

[DataMember(Order = 39)]
public RowFeature RowConstructorSupport { get; set; }

Property Value

RowFeature

SupportedCorrelatedSubqueriesLevel

Provider supports correlated subqueris, but limited how deep in subquery outer reference Default null. If this value is 0c>, provider do not support correlated subqueries

[DataMember(Order = 57)]
public int? SupportedCorrelatedSubqueriesLevel { get; set; }

Property Value

int?

SupportsBooleanType

Indicates that boolean type could be used as predicate without additional conversions. Default value: true.

[DataMember(Order = 51)]
public bool SupportsBooleanType { get; set; }

Property Value

bool

SupportsPredicatesComparison

Indicates that provider supports direct comparison of predicates. Default value: false.

[DataMember(Order = 50)]
public bool SupportsPredicatesComparison { get; set; }

Property Value

bool

TakeHintsSupported

Indicates supported TAKE/LIMIT hints. Default (set by DataProviderBase): null (none).

[DataMember(Order = 7)]
public TakeHints? TakeHintsSupported { get; set; }

Property Value

TakeHints?

Methods

Equals(object?)

Determines whether the specified object is equal to the current object.

public override bool Equals(object? obj)

Parameters

obj object

The object to compare with the current object.

Returns

bool

true if the specified object is equal to the current object; otherwise, false.

GetAcceptsTakeAsParameterFlag(SelectQuery)

public bool GetAcceptsTakeAsParameterFlag(SelectQuery selectQuery)

Parameters

selectQuery SelectQuery

Returns

bool

GetHashCode()

Serves as the default hash function.

public override int GetHashCode()

Returns

int

A hash code for the current object.

GetIsSkipSupportedFlag(ISqlExpression?)

public bool GetIsSkipSupportedFlag(ISqlExpression? takeExpression)

Parameters

takeExpression ISqlExpression

Returns

bool

GetIsTakeHintsSupported(TakeHints)

public bool GetIsTakeHintsSupported(TakeHints hints)

Parameters

hints TakeHints

Returns

bool