public ContextSpecHashItem( Chainable function, FilterSpecRaw filterSpecRaw) { Function = function; FilterSpecRaw = filterSpecRaw; }
private static bool IsMappedProperty(Chainable chainable) { if (!(chainable is ChainableCall)) { return(false); } var call = (ChainableCall)chainable; return(IsSingleParameterConstantOfType(call.Parameters, typeof(string))); }
private static bool IsArrayProperty( Chainable chainable, Chainable next) { if (!(next is ChainableArray)) { return(false); } var array = (ChainableArray)next; return(chainable is ChainableName && IsSingleParameterConstantOfType(array.Indexes, typeof(int?))); }
private static ExprNode HandleMinMaxNode( string chainFirstLowerCase, Chainable spec) { MinMaxTypeEnum minMaxTypeEnum; var filtered = chainFirstLowerCase.StartsWith("f"); if (chainFirstLowerCase.Equals("min") || chainFirstLowerCase.Equals("fmin")) { minMaxTypeEnum = MinMaxTypeEnum.MIN; } else if (chainFirstLowerCase.Equals("max") || chainFirstLowerCase.Equals("fmax")) { minMaxTypeEnum = MinMaxTypeEnum.MAX; } else { throw new ValidationException("Uncountered unrecognized min or max node '" + spec.GetRootNameOrEmptyString() + "'"); } var args = spec.GetParametersOrEmpty(); var distinct = spec.IsDistinct; var numArgsPositional = ExprAggregateNodeUtil.CountPositionalArgs(args); if (numArgsPositional > 1 && spec.IsDistinct && !filtered) { throw new ValidationException( "The distinct keyword is not valid in per-row min and max " + "functions with multiple sub-expressions"); } ExprNode minMaxNode; if (!distinct && numArgsPositional > 1 && !filtered) { // use the row function minMaxNode = new ExprMinMaxRowNode(minMaxTypeEnum); } else { // use the aggregation function minMaxNode = new ExprMinMaxAggrNode(distinct, minMaxTypeEnum, filtered, false); } minMaxNode.AddChildNodes(args); return(minMaxNode); }
private static bool DeterminePlainProperty(IList <Chainable> chain) { Chainable previous = null; foreach (var spec in chain) { if (spec is ChainableArray) { // must be "[index]" with index being an integer constant var array = (ChainableArray)spec; if (!IsSingleParameterConstantOfType(array.Indexes, typeof(int?))) { return(false); } if (previous is ChainableArray) { // plain property expressions don't allow two-dimensional array return(false); } } if (spec is ChainableCall) { // must be "x(key)" with key being a string constant var call = (ChainableCall)spec; if (!IsSingleParameterConstantOfType(call.Parameters, typeof(string))) { return(false); } } previous = spec; } return(true); }
public static void ValidateContextDesc( string contextName, ContextSpecHash hashedSpec, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { if (hashedSpec.Items.IsEmpty()) { throw new ExprValidationException("Empty list of hash items"); } foreach (var item in hashedSpec.Items) { Chainable chainable = item.Function; // determine type of hash to use var hashFuncName = chainable.GetRootNameOrEmptyString(); var hashFuncParams = chainable.GetParametersOrEmpty(); var hashFunction = HashFunctionEnumExtensions.Determine(contextName, hashFuncName); Pair<Type, ImportSingleRowDesc> hashSingleRowFunction = null; if (hashFunction == null) { try { hashSingleRowFunction = services.ImportServiceCompileTime.ResolveSingleRow( hashFuncName, services.ClassProvidedExtension); } catch (Exception) { // expected } if (hashSingleRowFunction == null) { throw new ExprValidationException( "For context '" + contextName + "' expected a hash function that is any of {" + HashFunctionEnumExtensions.GetStringList() + "} or a plug-in single-row function or script but received '" + hashFuncName + "'"); } } if (hashFuncParams.IsEmpty()) { throw new ExprValidationException( $"For context '{contextName}' expected one or more parameters to the hash function, but found no parameter list"); } // get first parameter var paramExpr = hashFuncParams[0]; var paramType = paramExpr.Forge.EvaluationType; EventPropertyValueGetterForge getter; if (hashFunction == HashFunctionEnum.CONSISTENT_HASH_CRC32) { if (hashFuncParams.Count > 1 || paramType != typeof(string)) { getter = new ContextControllerHashedGetterCRC32SerializedForge( hashFuncParams, hashedSpec.Granularity); } else { getter = new ContextControllerHashedGetterCRC32SingleForge( paramExpr, hashedSpec.Granularity); } } else if (hashFunction == HashFunctionEnum.HASH_CODE) { if (hashFuncParams.Count > 1) { getter = new ContextControllerHashedGetterHashMultiple( hashFuncParams, hashedSpec.Granularity); } else { getter = new ContextControllerHashedGetterHashSingleForge(paramExpr, hashedSpec.Granularity); } } else if (hashSingleRowFunction != null) { getter = new ContextControllerHashedGetterSingleRowForge( hashSingleRowFunction, hashFuncParams, hashedSpec.Granularity, item.FilterSpecCompiled.FilterForEventType, statementRawInfo, services); } else { throw new ArgumentException("Unrecognized hash code function '" + hashFuncName + "'"); } // create and register expression var expression = hashFuncName + "(" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(paramExpr) + ")"; var valueSerde = new DataInputOutputSerdeForgeSingleton(typeof(DIONullableIntegerSerde)); var eval = new ExprEventEvaluatorForgeFromProp(getter); var lookupable = new ExprFilterSpecLookupableForge(expression, eval, null, typeof(int), true, valueSerde); item.Lookupable = lookupable; } }
public void Chain_Dispatches_To_Objects_That_Implement_Chain() { var obj = new Chainable(100); CollectionAssert.AreEqual(R.Chain(add1, obj), new[] { 101 }); }