public void TestGetType() { Assert.AreEqual(typeof(string), _constantNode.ConstantType); _constantNode = new ExprConstantNodeImpl(null); Assert.IsNull(_constantNode.ConstantType); }
public void TestToExpressionString() { _constantNode = new ExprConstantNodeImpl("5"); Assert.AreEqual("\"5\"", _constantNode.ToExpressionStringMinPrecedenceSafe()); _constantNode = new ExprConstantNodeImpl(10); Assert.AreEqual("10", _constantNode.ToExpressionStringMinPrecedenceSafe()); }
public void TestEqualsNode() { Assert.IsTrue(_constantNode.EqualsNode(new ExprConstantNodeImpl("5"))); Assert.IsFalse(_constantNode.EqualsNode(new ExprOrNode())); Assert.IsFalse(_constantNode.EqualsNode(new ExprConstantNodeImpl(null))); Assert.IsFalse(_constantNode.EqualsNode(new ExprConstantNodeImpl(3))); _constantNode = new ExprConstantNodeImpl(null); Assert.IsTrue(_constantNode.EqualsNode(new ExprConstantNodeImpl(null))); }
public void SetUp() { _constantNode = new ExprConstantNodeImpl("5"); }
private CountMinSketchSpecForge ValidateSpecification(ExprValidationContext exprValidationContext) { // default specification CountMinSketchSpecHashes hashes = new CountMinSketchSpecHashes(DEFAULT_EPS_OF_TOTAL_COUNT, DEFAULT_CONFIDENCE, DEFAULT_SEED); CountMinSketchSpecForge spec = new CountMinSketchSpecForge(hashes, null, DEFAULT_AGENT); // no parameters if (this.ChildNodes.Length == 0) { return(spec); } // check expected parameter type: a json object if (this.ChildNodes.Length > 1 || !(this.ChildNodes[0] is ExprConstantNode)) { throw GetDeclaredWrongParameterExpr(); } ExprConstantNode constantNode = (ExprConstantNode)this.ChildNodes[0]; object value = constantNode.ConstantValue; if (!(value is IDictionary <string, object>)) { throw GetDeclaredWrongParameterExpr(); } // define what to populate PopulateFieldWValueDescriptor[] descriptors = new PopulateFieldWValueDescriptor[] { new PopulateFieldWValueDescriptor( NAME_EPS_OF_TOTAL_COUNT, typeof(double?), spec.HashesSpec.GetType(), value => { if (value != null) { spec.HashesSpec.EpsOfTotalCount = value.AsDouble(); } }, true), new PopulateFieldWValueDescriptor( NAME_CONFIDENCE, typeof(double?), spec.HashesSpec.GetType(), value => { if (value != null) { spec.HashesSpec.Confidence = value.AsDouble(); } }, true), new PopulateFieldWValueDescriptor( NAME_SEED, typeof(int?), spec.HashesSpec.GetType(), value => { if (value != null) { spec.HashesSpec.Seed = value.AsInt32(); } }, true), new PopulateFieldWValueDescriptor( NAME_TOPK, typeof(int?), spec.GetType(), value => { if (value != null) { spec.TopkSpec = (int?)value; } }, true), new PopulateFieldWValueDescriptor( NAME_AGENT, typeof(string), spec.GetType(), value => { if (value != null) { CountMinSketchAgentForge transform; try { var transformClass = exprValidationContext.ImportService.ResolveClass( (string)value, false, ExtensionClassEmpty.INSTANCE); transform = TypeHelper.Instantiate <CountMinSketchAgentForge>(transformClass); } catch (Exception e) { throw new ExprValidationException("Failed to instantiate agent provider: " + e.Message, e); } spec.Agent = transform; } }, true), }; // populate from json, validates incorrect names, coerces types, instantiates transform PopulateUtil.PopulateSpecCheckParameters(descriptors, (IDictionary <string, object>)value, spec, ExprNodeOrigin.AGGPARAM, exprValidationContext); return(spec); }
// Since static method calls such as "Class.method('a')" and mapped properties "Stream.property('key')" // look the same, however as the validation could not resolve "Stream.property('key')" before calling this method, // this method tries to resolve the mapped property as a static method. // Assumes that this is an ExprIdentNode. private static ExprNode ResolveStaticMethodOrField( ExprIdentNode identNode, ExprValidationException propertyException, ExprValidationContext validationContext) { // Reconstruct the original string StringBuilder mappedProperty = new StringBuilder(identNode.UnresolvedPropertyName); if (identNode.StreamOrPropertyName != null) { mappedProperty.Insert(0, identNode.StreamOrPropertyName + '.'); } // Parse the mapped property format into a class name, method and single string parameter MappedPropertyParseResult parse = ParseMappedProperty(mappedProperty.ToString()); if (parse == null) { ExprConstantNode constNode = ResolveIdentAsEnumConst( mappedProperty.ToString(), validationContext.ImportService); if (constNode == null) { throw propertyException; } else { return constNode; } } // If there is a class name, assume a static method is possible. if (parse.ClassName != null) { IList<ExprNode> parameters = Collections.SingletonList((ExprNode) new ExprConstantNodeImpl(parse.ArgString)); IList<ExprChainedSpec> chain = new List<ExprChainedSpec>(); chain.Add(new ExprChainedSpec(parse.ClassName, Collections.GetEmptyList<ExprNode>(), false)); chain.Add(new ExprChainedSpec(parse.MethodName, parameters, false)); ConfigurationCompilerExpression exprConfig = validationContext.StatementCompileTimeService.Configuration.Compiler.Expression; ExprNode result = new ExprDotNodeImpl(chain, exprConfig.IsDuckTyping, exprConfig.IsUdfCache); // Validate try { result.Validate(validationContext); } catch (ExprValidationException e) { throw new ExprValidationException( $"Failed to resolve enumeration method, date-time method or mapped property '{mappedProperty}': {e.Message}", e); } return result; } // There is no class name, try a single-row function string functionName = parse.MethodName; try { Pair<Type, ImportSingleRowDesc> classMethodPair = validationContext.ImportService.ResolveSingleRow(functionName); IList<ExprNode> parameters = Collections.SingletonList((ExprNode) new ExprConstantNodeImpl(parse.ArgString)); IList<ExprChainedSpec> chain = Collections.SingletonList( new ExprChainedSpec(classMethodPair.Second.MethodName, parameters, false)); ExprNode result = new ExprPlugInSingleRowNode( functionName, classMethodPair.First, chain, classMethodPair.Second); // Validate try { result.Validate(validationContext); } catch (EPException) { throw; } catch (Exception ex) { throw new ExprValidationException( "Plug-in aggregation function '" + parse.MethodName + "' failed validation: " + ex.Message); } return result; } catch (ImportUndefinedException) { // Not an single-row function } catch (ImportException e) { throw new IllegalStateException("Error resolving single-row function: " + e.Message, e); } // Try an aggregation function factory try { AggregationFunctionForge aggregationForge = validationContext.ImportService.ResolveAggregationFunction(parse.MethodName); ExprNode result = new ExprPlugInAggNode(false, aggregationForge, parse.MethodName); result.AddChildNode(new ExprConstantNodeImpl(parse.ArgString)); // Validate try { result.Validate(validationContext); } catch (EPException) { throw; } catch (Exception e) { throw new ExprValidationException( "Plug-in aggregation function '" + parse.MethodName + "' failed validation: " + e.Message); } return result; } catch (ImportUndefinedException) { // Not an aggregation function } catch (ImportException e) { throw new IllegalStateException("Error resolving aggregation: " + e.Message, e); } // absolutely cannot be resolved throw propertyException; }
public void SetUp() { _container = SupportContainer.Reset(); _constantNode = new ExprConstantNodeImpl("5"); }