private object ParseCellValue(INode p) { if (p.NodeType == NodeType.Uri) { return((p as IUriNode).Uri); } else if (p.NodeType == NodeType.Literal) { ILiteralNode literalNode = p as ILiteralNode; if (literalNode.DataType == null) { if (string.IsNullOrEmpty(literalNode.Language)) { return(literalNode.Value); } else { return(new Tuple <string, string>(literalNode.Value, literalNode.Language)); } } return(XsdTypeMapper.DeserializeString(literalNode.Value, literalNode.DataType)); } return(null); }
/// <summary> /// Takes a data value from the _queryResults datatable and returns a marshalled data object. /// </summary> /// <param name="cellValue">A cell value from a Virtuoso results datatable.</param> /// <returns>A reference to the marshalled data object.</returns> private object ParseCellValue(object cellValue) { if (cellValue is SqlExtendedString) { SqlExtendedString extendedString = cellValue as SqlExtendedString; if (extendedString.IsResource()) { // NOTE: We create an UriRef for correct equality comparision with fragment identifiers. return(new UriRef(extendedString.ToString(), UriKind.RelativeOrAbsolute)); } else if (extendedString.IsString() || extendedString.IsBlankId()) { return(extendedString.ToString()); } } else if (cellValue is SqlRdfBox) { SqlRdfBox box = cellValue as SqlRdfBox; if (box.StrType != null) { try { // NOTE: We create an UriRef for correct equality comparision with fragment identifiers. return(XsdTypeMapper.DeserializeString(box.Value.ToString(), new UriRef(box.StrType))); } catch (KeyNotFoundException) { // The given data type is not known by the XsdTypeMapper. return(box.Value.ToString()); } } else if (box.Value is SqlExtendedString && box.StrLang != null) { return(new Tuple <string, CultureInfo>(box.Value.ToString(), new CultureInfo(box.StrLang))); } else if (box.Value != null) { return(box.Value.ToString()); } } else if (cellValue is int) { // TODO: We need a different approach to store and read booleans. return(cellValue); } else if (cellValue is DateTime) { // Virtuoso delivers the time not as UTC but as "unspecified" // we convert it to local time return(((DateTime)cellValue).ToLocalTime()); } else if (cellValue is VirtuosoDateTimeOffset) { return(((VirtuosoDateTimeOffset)cellValue).Value.UtcDateTime.ToUniversalTime()); } return(cellValue); }
protected object ParseValue(INode value) { switch (value.NodeType) { case (NodeType.Literal): { return(XsdTypeMapper.DeserializeLiteralNode(value as BaseLiteralNode)); } case (NodeType.Uri): { return(new Resource((value as UriNode).Uri)); } case (NodeType.GraphLiteral): { return(null); } case (NodeType.Variable): { return(null); } default: { return(null); } } }
/// <summary> /// Create a boolean literal value. /// </summary> /// <param name="factory">A node factory.</param> /// <param name="value">Value of the literal node.</param> /// <returns>A new literal node object.</returns> public static INode CreateLiteralNode(this NodeFactory factory, bool value) { var literalValue = XmlConvert.ToString(value); var literalType = XsdTypeMapper.GetXsdTypeUri(typeof(bool)); return(factory.CreateLiteralNode(literalValue, literalType)); }
private static Uri GetDataType(ConstantExpression constant) { if (constant.Type == typeof(string)) { return(null); } else { return(XsdTypeMapper.GetXsdTypeUri(constant.Type)); } }
/// <summary> /// Convert the expression into a node. /// </summary> /// <param name="constant">A constant expression.</param> /// <returns>A <c>Node</c> object.</returns> public static INode AsNode(this ConstantExpression constant) { if (typeof(Uri).IsAssignableFrom(constant.Type)) { // If we have a URI constant, return a URI node. return(new NodeFactory().CreateUriNode(constant.Value as Uri)); } else if (XsdTypeMapper.HasXsdTypeUri(constant.Type) || constant.Value is string) { // If we have a literal value, return literal nodes. string value = GetValue(constant); Uri datatype = GetDataType(constant); if (datatype == null) { return(new NodeFactory().CreateLiteralNode(value)); } else { return(new NodeFactory().CreateLiteralNode(value, datatype)); } } else if (typeof(Resource).IsAssignableFrom(constant.Type)) { // If we have a constant of type Resource, return a URI node. Resource resource = constant.Value as Resource; return(new NodeFactory().CreateUriNode(resource.Uri)); } else { // We cannot determine the Uri of generic reference types. string msg = string.Format("Unsupported constant type: {0}", constant.Type); throw new ArgumentException(msg); } }