public object Translate(TranslationContext context, ASTNode node) { var result = new SQLModel.TableExpression(); var sqlContext = (SQLTranslationContext)context; result.TableName = sqlContext.GetExpressionObjectName(String.Format("{0}.{1}", node.GetAttribute<string>("libraryName", sqlContext.ArtifactName), node.GetAttribute<string>("name"))); // If the expression being referenced is scalar, it will be automatically promoted to a query by the expression def translation // In this case, it must be demoted back to a scalar expression with a subquery access. if (!(node.ResultType is ListType) && !(node.ResultType is ObjectType)) { var selectExpression = new SQLModel.SelectExpression(); selectExpression.SelectClause = new SQLModel.SelectClause(); selectExpression.SelectClause.Columns.Add(new SQLModel.ColumnExpression(new SQLModel.QualifiedFieldExpression("value"))); selectExpression.FromClause = new SQLModel.CalculusFromClause(new SQLModel.TableSpecifier(result)); // If the result type is also boolean, the expression will be converted to a 1 or 0, so it must be demoted back to an actual boolean-valued expression if (DataTypes.Equal(node.ResultType, DataTypes.Boolean)) { return SQLTranslationUtilities.DemoteBooleanValuedExpression(selectExpression); } return selectExpression; } return result; }
protected virtual void InternalVerify(VerificationContext context, ASTNode node) { foreach (var child in node.Children) { Verifier.Verify(context, child); } }
private CREFModel.DynamicRuleDynamicRuleCriteria TranslateCriteria(TranslationContext context, ASTNode condition) { var result = new CREFModel.DynamicRuleDynamicRuleCriteria(); result.Item = context.TranslateNode(condition); return result; }
public object Translate(TranslationContext context, ASTNode node) { var result = new CREFModel.ExpressionReference(); result.Name = node.GetAttribute<string>("name"); return result; }
public static Node ReadNode(XElement element) { var nodeName = element.Name.LocalName; var nodeType = element.GetSchemaInfo().SchemaType; Node result = null; ASTNode astResult = null; if (IsExpression(nodeType)) { astResult = new ASTNode(); result = astResult; } else { result = new Node(); } result.Name = nodeName; result.NodeType = nodeType.QualifiedName.ToString(); var lineInfo = element as IXmlLineInfo; if (lineInfo != null && lineInfo.HasLineInfo()) { result.Line = lineInfo.LineNumber; result.LinePos = lineInfo.LinePosition; } result.Attributes = new Dictionary<string, object>(); foreach (var a in element.Attributes()) { var schemaInfo = a.GetSchemaInfo(); if (schemaInfo != null && schemaInfo.SchemaType != null && schemaInfo.SchemaType.QualifiedName != null && schemaInfo.SchemaType.QualifiedName.Name == "QName") { result.Attributes.Add(a.Name.LocalName, element.ExpandName(a.Value)); } else { result.Attributes.Add(a.Name.LocalName, a.Value); } } result.Children = new List<Node>(); foreach (var e in element.Elements()) { if (e.Name.LocalName == "description" && astResult != null) { astResult.Description = e.Value; } else { result.Children.Add(ReadNode(e)); } } return result; }
public void Verify(VerificationContext context, ASTNode node) { var expressionType = context.ResolveExpressionRef(node.GetAttribute<string>("libraryName"), node.GetAttribute<string>("name")); if (expressionType.Expression.ResultType == null) { throw new InvalidOperationException("Invalid forward reference."); } node.ResultType = expressionType.Expression.ResultType; }
public object Translate(TranslationContext context, ASTNode node) { var result = new CREFModel.ParameterExpression(); result.Name = node.GetAttribute<string>("name"); // TODO: Default value? return result; }
protected object TranslateCodeReference(TranslationContext context, ObjectType sourceType, ASTNode node, string path) { // Reference the Codes property with a First expression var result = GetPropertyExpression(context, node, "Codes"); result = GetFirstExpression(context, result); // TODO: Issue a warning that an arbitrary Code is being selected return result; }
public object Translate(TranslationContext context, ASTNode node) { var result = new SQLModel.TableExpression(); // TODO: Handle Cardinality // TODO: Handle whether we are in a FromClause context. var sqlContext = (SQLTranslationContext)context; result.TableName = sqlContext.GetExpressionObjectName(String.Format("{0}.{1}", node.GetAttribute<string>("libraryName", sqlContext.ArtifactName), node.GetAttribute<string>("name"))); return result; }
protected object GetPropertyExpression(TranslationContext context, ASTNode node, string path) { var result = new SQLModel.PropertyExpression(); result.Path = path; if (node.Children.Count > 0) { result.Item = context.TranslateNode(node.Children[0]); } return result; }
public object Translate(TranslationContext context, ASTNode node) { var result = new CREFModel.BinaryExpression(); result.Operator = GetOperator(); result.OperatorSpecified = true; foreach (var child in node.Children) { result.Items.Add(context.TranslateNode(child)); } return result; }
public static void Verify(VerificationContext context, ASTNode node) { try { var verifier = NodeVerifierFactory.GetHandler(node.NodeType); // Traversal occurs within the verify, because traversal may happen differently depending on the operation. verifier.Verify(context, node); } catch (Exception e) { context.ReportMessage(e, node); } }
public object Translate(TranslationContext context, ASTNode node) { var result = new CREFModel.ValueExpression(); if (DataTypes.Equal(node.ResultType, DataTypes.String)) { result.Type = Model.ValueType.String; result.TypeSpecified = true; result.Value = node.GetAttribute<string>("value"); } else if (DataTypes.Equal(node.ResultType, DataTypes.Integer)) { result.Type = Model.ValueType.Int32; result.TypeSpecified = true; result.Value = node.GetAttribute<string>("value"); } else if (DataTypes.Equal(node.ResultType, DataTypes.Boolean)) { result.Type = Model.ValueType.Boolean; result.TypeSpecified = true; result.Value = node.GetAttribute<string>("value"); } else if (DataTypes.Equal(node.ResultType, DataTypes.Decimal)) { result.Type = Model.ValueType.Decimal; result.TypeSpecified = true; result.Value = node.GetAttribute<string>("value"); } else if (DataTypes.Equal(node.ResultType, DataTypes.DateTime)) { result.Type = Model.ValueType.Date; result.TypeSpecified = true; result.Value = node.GetAttribute<string>("value"); // TODO: Convert to format expected by CREF } else { throw new NotSupportedException(String.Format("Unsupported literal type: {0}.", node.ResultType.Name)); } return result; }
public object Translate(TranslationContext context, ASTNode node) { if (DataTypes.Equal(node.ResultType, DataTypes.Boolean)) { return new Model.BinaryExpression(new Model.ValueExpression(1), "iEqual", new Model.ValueExpression(Boolean.Parse(node.GetAttribute<string>("value")) ? 1 : 0)); } else if (DataTypes.Equal(node.ResultType, DataTypes.DateTime)) { // TODO: Convert to format expected by T-SQL return new Model.CallExpression("convert", new Model.Expression[] { new Model.IdentifierExpression("datetime"), new Model.ValueExpression(node.GetAttribute<string>("value")) }); } else { var result = new Model.ValueExpression(); if (DataTypes.Equal(node.ResultType, DataTypes.String)) { result.Token = Model.TokenType.String; result.Value = node.GetAttribute<string>("value"); } else if (DataTypes.Equal(node.ResultType, DataTypes.Integer)) { result.Token = Model.TokenType.Integer; result.Value = Int32.Parse(node.GetAttribute<string>("value")); } else if (DataTypes.Equal(node.ResultType, DataTypes.Decimal)) { result.Token = Model.TokenType.Decimal; result.Value = Decimal.Parse(node.GetAttribute<string>("value")); } else { throw new NotSupportedException(String.Format("Unsupported literal type: {0}.", node.ResultType.Name)); } return result; } }
protected override DataType GetResultType(ASTNode node) { var listType = node.ResultType as ListType; if (!(listType.ElementType is IntervalType)) { throw new InvalidOperationException("Collapse operator must be invoked on a list of intervals."); } return listType; }
protected override DataType GetResultType(ASTNode node) { var listType = node.ResultType as ListType; var childListType = listType.ElementType as ListType; if (childListType == null) { throw new InvalidOperationException("Expand operator must be invoked on a list of lists."); } return childListType; }
protected abstract DataType GetResultType(ASTNode node);
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var child = node.Children[0]; var childListType = child.ResultType as ListType; if (childListType == null) { throw new InvalidOperationException("Expected an expression of a list type."); } node.ResultType = GetResultType(child); }
public void Verify(VerificationContext context, ASTNode node) { var valueNode = ((Node)node).Children.FirstOrDefault(c => c.Name == "value"); if (valueNode == null) { throw new InvalidOperationException("Could not resolve value element for complex literal."); } var resultType = context.ResolveType(valueNode.NodeType); node.ResultType = resultType; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var source = node.Children[0]; var sourceIntervalType = source.ResultType as IntervalType; if (sourceIntervalType == null) { throw new InvalidOperationException("Interval type expected."); } node.ResultType = sourceIntervalType.PointType; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); if (node.Children.Count == 0) { throw new InvalidOperationException("Expected at least one child argument."); } DataType operandType = null; foreach (var child in node.Children) { if (operandType == null) { operandType = child.ResultType; if (!(operandType is ListType || operandType is IntervalType)) { throw new InvalidOperationException("List or interval type expected."); } } else { context.VerifyType(child.ResultType, operandType); } } node.ResultType = operandType; }
public void Verify(VerificationContext context, HeD.Engine.Model.ASTNode node) { // TODO: Implement generic identifier resolution. In theory, this isn't necessary because the CQL-to-ELM translator should never spit out this type of node. throw new InvalidOperationException(String.Format("Could not resolve identifier {0}{1}.", node.GetAttribute <String>("libraryName") ?? "", node.GetAttribute <String>("name"))); }
protected override DataType GetResultType(ASTNode node) { return DataTypes.Boolean; }
public object TransformModelPath(ObjectType type, ASTNode node, string path) { var translator = ModelTranslatorFactory.GetHandler(type.Name); return translator.TransformModelPath(this, type, node, path); }
public void Verify(VerificationContext context, HeD.Engine.Model.ASTNode node) { Symbol sourceSymbol = null; // foreach source // add to the output context var sources = ((Node)node).Children.Where(c => c.Name == "source").ToList(); foreach (var source in sources) { if (sourceSymbol == null) { sourceSymbol = ProcessAliasedQuerySource(context, source); } else { throw new NotImplementedException("Multi-source query verification is not implemented."); } } if (sourceSymbol == null) { throw new InvalidOperationException("Could not determine query source type."); } var sourceSymbolListType = sourceSymbol.DataType as ListType; var sourceSymbolElementType = sourceSymbolListType != null ? sourceSymbolListType.ElementType : null; var sourceElementSymbol = sourceSymbolElementType != null ? new Symbol(sourceSymbol.Name, sourceSymbolElementType) : null; context.PushSymbol(sourceElementSymbol ?? sourceSymbol); try { // foreach define // add to the current scope var defines = ((Node)node).Children.Where(c => c.Name == "define").ToList(); foreach (var define in defines) { throw new NotImplementedException("Query defines are not implemented."); } // verify each with/without clause var relationships = ((Node)node).Children.Where(c => c.Name == "relationship").ToList(); foreach (var relationship in relationships) { var relatedSourceSymbol = ProcessAliasedQuerySource(context, relationship); var relatedSourceSymbolListType = relatedSourceSymbol.DataType as ListType; var relatedSourceSymbolElementType = relatedSourceSymbolListType != null ? relatedSourceSymbolListType.ElementType : null; var relatedSourceElementSymbol = relatedSourceSymbolElementType != null ? new Symbol(relatedSourceSymbol.Name, relatedSourceSymbolElementType) : null; context.PushSymbol(relatedSourceElementSymbol ?? relatedSourceSymbol); try { var suchThat = relationship.Children[1] as ASTNode; if (suchThat == null) { throw new InvalidOperationException(String.Format("Could not determine such that for relationship '{0}'.", relatedSourceSymbol.Name)); } Verifier.Verify(context, suchThat); context.VerifyType(suchThat.ResultType, DataTypes.Boolean); } finally { context.PopSymbol(); } } // verify the where clause var whereClause = ((Node)node).Children.Where(c => c.Name == "where").FirstOrDefault() as ASTNode; if (whereClause != null) { Verifier.Verify(context, whereClause); context.VerifyType(whereClause.ResultType, DataTypes.Boolean); } // verify the return clause var returnClause = ((Node)node).Children.Where(c => c.Name == "return").FirstOrDefault(); if (returnClause != null) { var returnElement = returnClause.Children.Where(c => c.Name == "expression").FirstOrDefault() as ASTNode; if (returnElement == null) { throw new InvalidOperationException("Could not resolve return expression for return clause."); } Verifier.Verify(context, returnElement); if (sourceSymbolListType != null) { node.ResultType = new ListType(returnElement.ResultType); } else { node.ResultType = returnElement.ResultType; } } else { node.ResultType = sourceSymbol.DataType; } // verify the sort clause var sortClause = ((Node)node).Children.Where(c => c.Name == "sort").FirstOrDefault(); if (sortClause != null) { throw new NotImplementedException("Sort clause is not implemented."); } } finally { context.PopSymbol(); } }
public void Verify(VerificationContext context, ASTNode node) { var source = node.Children[0]; var condition = node.Children[1]; Verifier.Verify(context, source); var sourceListType = source.ResultType as ListType; if (sourceListType == null) { throw new InvalidOperationException("Filter expression source must be a list type expression."); } context.PushSymbol(new Symbol(node.GetAttribute<string>("scope", VerificationContext.Current), sourceListType.ElementType)); try { Verifier.Verify(context, condition); context.VerifyType(condition.ResultType, DataTypes.Boolean); } finally { context.PopSymbol(); } node.ResultType = sourceListType; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var left = node.Children[0]; var right = node.Children[1]; var leftIntervalType = left.ResultType as IntervalType; if (leftIntervalType != null) { context.VerifyType(right.ResultType, leftIntervalType); node.ResultType = DataTypes.Boolean; } else { throw new InvalidOperationException("List type expected."); } }
public void Verify(VerificationContext context, HeD.Engine.Model.ASTNode node) { throw new NotImplementedException(); }
public void Verify(VerificationContext context, ASTNode node) { node.ResultType = context.ResolveType((String)node.Attributes["valueType"]); }
public object TranslateNode(ASTNode node) { var translator = NodeTranslatorFactory.GetHandler(node.NodeType); return translator.Translate(this, node); }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var source = node.Children[0]; var index = node.Children[1]; var sourceListType = source.ResultType as ListType; if (sourceListType != null) { node.ResultType = sourceListType.ElementType; } else { context.VerifyType(source.ResultType, DataTypes.String); node.ResultType = DataTypes.String; } context.VerifyType(index.ResultType, DataTypes.Integer); }
private Model.Statement TranslateCondition(SQLTranslationContext context, string artifactName, string conditionName, ASTNode condition) { var result = new SQLModel.CreateViewStatement(); result.ViewName = context.GetExpressionObjectName(String.Format("{0}.{1}", artifactName, conditionName)); result.Expression = SQLTranslationUtilities.EnsureSelectExpression(context.TranslateNode(condition)); return result; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var source = node.Children[0]; var element = node.Children[1]; var sourceListType = source.ResultType as ListType; if (sourceListType != null) { context.VerifyType(element.ResultType, sourceListType.ElementType); node.ResultType = DataTypes.Boolean; } var sourceIntervalType = source.ResultType as IntervalType; if (sourceIntervalType != null) { context.VerifyType(element.ResultType, sourceIntervalType.PointType); node.ResultType = DataTypes.Boolean; } if (node.ResultType == null) { throw new InvalidOperationException("Expected an argument of type list or interval."); } }