// Constructors
public BatchingCommandProcessor(CommandFactory factory, int batchSize, int maxQueryParameterCount)
: base(factory, maxQueryParameterCount)
{
ArgumentValidator.EnsureArgumentIsGreaterThan(batchSize, 1, nameof(batchSize));
this.batchSize = batchSize;
tasks = new Queue <SqlTask>();
}
// Constructors
public BatchingCommandProcessor(CommandFactory factory, int batchSize)
: base(factory)
{
ArgumentValidator.EnsureArgumentIsGreaterThan(batchSize, 1, "batchSize");
this.batchSize = batchSize;
tasks = new Queue <SqlTask>();
}
/// <summary>
/// Initializes new instance of this type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="typeName">Name of the type.</param>
/// <param name="length">The length.</param>
/// <param name="precision">The precision.</param>
/// <param name="scale">The scale.</param>
public SqlValueType(SqlType type, string typeName, int?length, int?precision, int?scale)
{
if ((type == SqlType.Unknown) != (typeName != null))
{
throw new ArgumentException(Strings.ExInvalidArgumentsNonNullTypeNameIsAllowedIfAndOnlyIfTypeEqualsSqlTypeUnknown);
}
if (precision.HasValue && precision != 0 && length.HasValue && length != 0)
{
throw new ArgumentException(Strings.ExInvalidArgumentsPrecisionAndLengthShouldNotBeUsedTogether);
}
if (precision.HasValue != scale.HasValue)
{
throw new ArgumentException(Strings.ExInvalidArgumentsScaleAndPrecisionShouldBeUsedTogether);
}
if (typeName != null)
{
ArgumentValidator.EnsureArgumentNotNullOrEmpty(typeName, "typeName");
}
if (length != null)
{
ArgumentValidator.EnsureArgumentIsGreaterThan(length.Value, 0, "length");
}
if (precision != null)
{
ArgumentValidator.EnsureArgumentIsInRange(scale.Value, 0, precision.Value, "scale");
}
Type = type;
TypeName = typeName;
Length = length;
Precision = precision;
Scale = scale;
}
// Constructors
public PersistParameterBinding(TypeMapping typeMapping, int fieldIndex, ParameterTransmissionType transmissionType, PersistParameterBindingType bindingType)
: base(typeMapping, transmissionType)
{
ArgumentValidator.EnsureArgumentIsGreaterThan(fieldIndex, -1, "fieldIndex");
ArgumentValidator.EnsureArgumentNotNull(typeMapping, "typeMapping");
FieldIndex = fieldIndex;
BindingType = bindingType;
}
/// <summary>
/// Performs full-text query for the specified search condition.
/// </summary>
/// <typeparam name="T">Type of the entity to query full-text index of.</typeparam>
/// <param name="searchCriteria">Search condition.</param>
/// <param name="topNByRank">
/// Specifies how many highest ranked matches (in descending order) result set should be returned.
/// Result set may contain less number of items than specified by the parameter.
/// </param>
/// <returns>
/// An <see cref="IQueryable{T}"/> of <see cref="FullTextMatch{T}"/>
/// allowing to continue building the query.
/// </returns>
public IQueryable <FullTextMatch <T> > ContainsTable <T>([NotNull] Expression <Func <ConditionEndpoint, IOperand> > searchCriteria, int topNByRank)
where T : Entity
{
ArgumentValidator.EnsureArgumentNotNull(searchCriteria, "searchCriteria");
ArgumentValidator.EnsureArgumentIsGreaterThan(topNByRank, 0, "topNByRank");
var method = WellKnownMembers.Query.ContainsTableExprTopNByRank.MakeGenericMethod(typeof(T));
var expression = Expression.Call(null, method, searchCriteria, Expression.Constant(topNByRank));
return(Provider.CreateQuery <FullTextMatch <T> >(expression));
}
/// <summary>
/// Performs full-text query for the text specified in free text form.
/// Limits the result by top number of elements, sorted by rank in descending order.
/// </summary>
/// <typeparam name="T">Type of the entity to query full-text index of.</typeparam>
/// <param name="searchCriteria">The search criteria in free text form.</param>
/// <param name="topNByRank">Top number of elements to be returned.</param>
/// <returns>
/// An <see cref="IQueryable{T}"/> of <see cref="FullTextMatch{T}"/>
/// allowing to continue building the query.
/// </returns>
public IQueryable <FullTextMatch <T> > FreeText <T>(Expression <Func <string> > searchCriteria, int topNByRank)
where T : Entity
{
ArgumentValidator.EnsureArgumentNotNull(searchCriteria, "searchCriteria");
ArgumentValidator.EnsureArgumentIsGreaterThan(topNByRank, 0, "topNByRank");
var method = WellKnownMembers.Query.FreeTextExpressionTopNByRank.MakeGenericMethod(typeof(T));
var expression = Expression.Call(null, method, searchCriteria, Expression.Constant(topNByRank));
return(Provider.CreateQuery <FullTextMatch <T> >(expression));
}
public void CombinedTest()
{
ArgumentValidator.EnsureArgumentIsGreaterThan(1, 0, "x");
AssertEx.ThrowsArgumentOutOfRangeException(() => ArgumentValidator.EnsureArgumentIsGreaterThan(0, 0, "x"));
AssertEx.ThrowsArgumentOutOfRangeException(() => ArgumentValidator.EnsureArgumentIsGreaterThan(-1, 0, "x"));
ArgumentValidator.EnsureArgumentIsLessThan(-1, 0, "x");
AssertEx.ThrowsArgumentOutOfRangeException(() => ArgumentValidator.EnsureArgumentIsLessThan(0, 0, "x"));
AssertEx.ThrowsArgumentOutOfRangeException(() => ArgumentValidator.EnsureArgumentIsLessThan(1, 0, "x"));
}
/// <summary>
/// Creates a stream <see cref="DataTypeInfo"/>.
/// </summary>
public static DataTypeInfo Stream(
SqlType sqlType,
DataTypeFeatures features,
int maxLength,
params string[] nativeTypes)
{
ArgumentValidator.EnsureArgumentIsGreaterThan(maxLength, 0, "maxLength");
return(new DataTypeInfo
{
Type = sqlType,
Features = features,
MaxLength = maxLength,
NativeTypes = nativeTypes.ToArraySafely(),
});
}
/// <summary>
/// Creates a fractional <see cref="DataTypeInfo"/>.
/// </summary>
public static DataTypeInfo Fractional(
SqlType sqlType,
DataTypeFeatures features,
ValueRange valueRange,
int maxPrecision,
params string[] nativeTypes)
{
ArgumentValidator.EnsureArgumentNotNull(valueRange, "valueRange");
ArgumentValidator.EnsureArgumentIsGreaterThan(maxPrecision, 0, "maxPrecision");
return(new DataTypeInfo
{
Type = sqlType,
Features = features,
ValueRange = valueRange,
MaxPrecision = maxPrecision,
NativeTypes = nativeTypes.ToArraySafely(),
});
}
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
/// <param name="field">The field whose value will be fetched.</param>
/// <param name="entitySetItemCountLimit">The maximal count of items
/// which will be loaded during prefetch of an <see cref="EntitySet{TItem}"/>.</param>
/// <param name="fetchFieldsOfReferencedEntity">If it is set to <see langword="true"/>
/// then fields' values of an <see cref="Entity"/> referenced by <see cref="Field"/>
/// will be fetched.</param>
/// <param name="fetchLazyFields">if set to <see langword="true"/>
/// children lazy-load fields will be fetched.</param>
/// <param name="keyExtractionSubscriber">The delegate which will be invoked
/// if a key of a referenced entity has been extracted and
/// its exact type can't be get or inferred.</param>
public PrefetchFieldDescriptor(
FieldInfo field,
int?entitySetItemCountLimit,
bool fetchFieldsOfReferencedEntity,
bool fetchLazyFields,
Action <Key, FieldInfo, Key> keyExtractionSubscriber)
{
ArgumentValidator.EnsureArgumentNotNull(field, "field");
if (entitySetItemCountLimit != null)
{
ArgumentValidator.EnsureArgumentIsGreaterThan(entitySetItemCountLimit.Value, 0,
"entitySetItemCountLimit");
}
Field = field;
FetchFieldsOfReferencedEntity = fetchFieldsOfReferencedEntity;
EntitySetItemCountLimit = entitySetItemCountLimit;
FetchLazyFields = fetchLazyFields;
this.keyExtractionSubscriber = keyExtractionSubscriber;
}
// Constructors
public EntityGroupTask(TypeInfo type, int[] columnIndexes, PrefetchManager manager)
{
ArgumentValidator.EnsureArgumentNotNull(type, "type");
ArgumentValidator.EnsureArgumentNotNull(columnIndexes, "columnIndexes");
ArgumentValidator.EnsureArgumentIsGreaterThan(columnIndexes.Length, 0, "columnIndexes.Length");
ArgumentValidator.EnsureArgumentNotNull(manager, "processor");
this.type = type;
this.columnIndexes = columnIndexes;
this.manager = manager;
var cachedHashCode = 0;
for (var i = 0; i < columnIndexes.Length; i++)
{
cachedHashCode = unchecked (379 * cachedHashCode + columnIndexes[i]);
}
cachedHashCode = unchecked (cachedHashCode ^ type.GetHashCode());
cacheKey = new CacheKey(columnIndexes, type, cachedHashCode);
}
// Constructors
public EntityGroupTask(TypeInfo type, int[] columnIndexes, PrefetchManager manager)
{
ArgumentValidator.EnsureArgumentNotNull(type, nameof(type));
ArgumentValidator.EnsureArgumentNotNull(columnIndexes, nameof(columnIndexes));
ArgumentValidator.EnsureArgumentIsGreaterThan(columnIndexes.Length, 0, "columnIndexes.Length");
ArgumentValidator.EnsureArgumentNotNull(manager, nameof(manager));
this.type = type;
this.manager = manager;
var cachedHashCode = 0;
foreach (var columnIndex in columnIndexes)
{
cachedHashCode = unchecked (379 * cachedHashCode + columnIndex);
}
cachedHashCode ^= type.GetHashCode();
cacheKey = new CacheKey(columnIndexes, type, cachedHashCode);
}
private static void AddConverter <T>(params Type[] types)
{
ArgumentValidator.EnsureArgumentIsGreaterThan(types.Length, -1, "types.Length");
supportedConversions.Add(typeof(T), new List <Type>(types));
}